Split out HSL from /hack/ to /hsl/

As well as correctness, this gets us another APIProduct, which will be
useful for improving search result rendering.

Author: fredemmott

LocalConfig.php

@@ -2,6 +2,17 @@
 
 namespace HHVM\UserDocumentation;
 
+use namespace HH\Lib\Str;
+
 abstract final class LocalConfig {
   const string ROOT = __DIR__;
+
+  <<__Memoize>>
+  public static function getBuildID(): string {
+    invariant(
+      \file_exists(BuildPaths::BUILD_ID_FILE),
+      "Build ID does not exist",
+    );
+    return Str\trim(\file_get_contents(BuildPaths::BUILD_ID_FILE));
+  }
 }

bin/build.php

@@ -11,6 +11,9 @@
 namespace HHVM\UserDocumentation;
 
 require(__DIR__.'/../vendor/hh_autoload.php');
+
+use namespace HH\Lib\Vec;
+
 function build_site(?Traversable<string> $filters = null): void {
   if (!is_dir(BuildPaths::BUILD_DIR)) {
     mkdir(BuildPaths::BUILD_DIR);
@@ -50,7 +53,7 @@ function build_site(?Traversable<string> $filters = null): void {
     StaticResourceMapBuildStep::class,
 
     // Needs the static resources
-    MergedMarkdownBuildStep::class,
+    APIMarkdownBuildStep::class,
 
     // Needs the Markdown
     GuidesHTMLBuildStep::class,
@@ -70,7 +73,7 @@ function (classname<BuildStep> $step): bool use ($filters) {
     );
   }
 
-  $steps[] = BuildIDBuildStep::class;
+  $steps = Vec\concat(vec[BuildIDBuildStep::class], $steps);
 
   foreach ($steps as $step) {
     (new $step())->buildAll();

bin/class-reference-skeletons.php

@@ -14,13 +14,43 @@
 use namespace HH\Lib\{C, Math, Str, Vec};
 
 final class APIIndex {
+  private function __construct(
+    private ProductAPIIndexShape $index,
+  ) {
+  }
+
   <<__Memoize>>
-  public static function getIndex(
+  public static function get(APIProduct $product): APIIndex {
+    $idx = self::getRawIndex();
+    switch ($product) {
+      case APIProduct::HACK:
+        return new self($idx[APIProduct::HACK]);
+      case APIProduct::HSL:
+        return new self($idx[APIProduct::HSL]);
+      case APIProduct::PHP:
+        invariant_violation("Can't handle PHP index");
+    }
+  }
+
+  public function getIndex(): ProductAPIIndexShape {
+    return $this->index;
+  }
+
+  public static function searchAllProducts(string $term): vec<SearchResult> {
+    return Vec\concat(
+      self::get(APIProduct::HACK)->search($term),
+      self::get(APIProduct::HSL)->search($term),
+    );
+  }
+
+  <<__Memoize>>
+  private static function getRawIndex(
   ): APIIndexShape {
-    $key = __CLASS__.'!'.BuildPaths::BUILD_ID;
+    $key = __CLASS__.'!'.LocalConfig::getBuildID();
 
     $success = false;
     $data = apc_fetch($key, $success);
+    $success = false;
     if ($success) {
       return $data;
     }
@@ -33,44 +63,47 @@ public static function getIndex(
     return $data;
   }
 
-  public static function getIndexForType(
+  public function getIndexForType(
     APIDefinitionType $type,
   ): array<string, APIIndexEntry> {
-    $index = Shapes::toArray(self::getIndex());
+    $index = Shapes::toArray($this->index);
     invariant(
       array_key_exists($type, $index),
       'invalid type: %s',
       (string) $type,
     );
-    // UNSAFE
     return $index[$type];
   }
 
-  public static function getFunctionIndex(
+  public function getFunctionIndex(
   ): array<string, APIFunctionIndexEntry> {
-    return self::getIndex()['function'];
+    return $this->index['function'];
   }
 
-  public static function getClassIndex(
+  public function getClassIndex(
     APIDefinitionType $type,
   ): array<string, APIClassIndexEntry> {
-    invariant(
-      $type !== APIDefinitionType::FUNCTION_DEF,
-      'functions are not classes',
-    );
-    // UNSAFE
-    return self::getIndex()[$type];
+    switch($type) {
+      case APIDefinitionType::FUNCTION_DEF:
+        invariant_violation('functions are not classes');
+      case APIDefinitionType::CLASS_DEF:
+        return $this->index['class'];
+      case APIDefinitionType::INTERFACE_DEF:
+        return $this->index['interface'];
+      case APIDefinitionType::TRAIT_DEF:
+        return $this->index['trait'];
+    }
   }
 
-  public static function search(
+  public function search(
     string $term,
   ): vec<SearchResult> {
     return APIDefinitionType::getValues()
-      |> Vec\map($$, $type ==> self::searchEntries($term, $type))
+      |> Vec\map($$, $type ==> $this->searchEntries($term, $type))
       |> Vec\flatten($$);
   }
 
-  private static function getMethods(
+  private function getMethods(
     APIIndexEntry $entry,
   ): ?vec<APIMethodIndexEntry> {
     $arr = Shapes::toArray($entry);
@@ -87,14 +120,14 @@ private static function getMethods(
     return null;
   }
 
-  private static function searchEntries (
+  private function searchEntries (
     string $term,
     APIDefinitionType $type,
   ): vec<SearchResult> {
     $terms = Str\split($term, ' ');
     $results = vec[];
 
-    $entries = self::getIndexForType($type);
+    $entries = $this->getIndexForType($type);
     foreach ($entries as $_ => $entry) {
       $name = $entry['name'];
       $type = Str\contains($name, "HH\\Lib\\")
@@ -106,7 +139,7 @@ private static function searchEntries (
         $results[] = new SearchResult($type, $score, $name, $entry['urlPath']);
       }
 
-      $methods = self::getMethods($entry);
+      $methods = $this->getMethods($entry);
       if ($methods === null) {
         continue;
       }
@@ -122,10 +155,10 @@ private static function searchEntries (
     return $results;
   }
 
-  public static function getDataForFunction(
+  public function getDataForFunction(
     string $name,
   ): APIFunctionIndexEntry {
-    $index = self::getIndex();
+    $index = $this->index;
     invariant(
       array_key_exists($name, $index['function']),
       'function %s does not exist',
@@ -134,11 +167,11 @@ public static function getDataForFunction(
     return $index['function'][$name];
   }
 
-  public static function getDataForClass(
+  public function getDataForClass(
     APIDefinitionType $class_type,
     string $class_name,
   ): APIClassIndexEntry {
-    $index = self::getClassIndex($class_type);
+    $index = $this->getClassIndex($class_type);
     invariant(
       array_key_exists($class_name, $index),
       'class %s does not exist',
@@ -147,12 +180,12 @@ public static function getDataForClass(
     return $index[$class_name];
   }
 
-  public static function getDataForMethod(
+  public function getDataForMethod(
     APIDefinitionType $class_type,
     string $class_name,
     string $method_name,
   ): APIMethodIndexEntry {
-    $index = self::getClassIndex($class_type);
+    $index = $this->getClassIndex($class_type);
     invariant(
       array_key_exists($class_name, $index),
       'class %s does not exist',