handle refs to builtin types and unions correctly

Author: ianhoffman

src/Codegen/Codegen.php

@@ -331,6 +331,9 @@ public function isArrayKeyType(): bool {
   }
 
   public function getTypeInfo(): Typing\Type {
+    if ($this->builder->isUniqueRef()) {
+      return Typing\TypeSystem::alias($this->builder->getType());
+    }
     return $this->builder->getTypeInfo();
   }
 

src/Codegen/Constraints/UniqueRefBuilder.php

@@ -71,6 +71,7 @@ public function build(): this {
         'type' => $codegen->getType(),
         'classname' => $codegen->getClassName(),
         'isArrayKeyType' => $codegen->isArrayKeyType(),
+        'typeInfo' => $codegen->getTypeInfo(),
       );
       RefCache::cacheRef($this->filename, $this->cached_ref);
     }
@@ -97,7 +98,8 @@ public function setSuffix(string $_suffix): void {
   }
 
   public function getTypeInfo(): Typing\Type {
-    return Typing\TypeSystem::alias($this->getType());
+    invariant($this->cached_ref is nonnull, 'must call `build` method before accessing type');
+    return $this->cached_ref['typeInfo'];
   }
 
   /**

src/Codegen/Constraints/UntypedBuilder.php

@@ -634,7 +634,6 @@ private function codegenType(): CodegenType {
 
   <<__Override>>
   public function getTypeInfo(): Typing\Type {
-    invariant($this->type_info is nonnull, 'must call `build` method before accessing type info');
-    return $this->type_info;
+    return Typing\TypeSystem::alias($this->getType());
   }
 }

src/Codegen/RefCache.php

@@ -9,6 +9,7 @@ final class RefCache {
     'type' => string,
     'classname' => string,
     'isArrayKeyType' => bool,
+    'typeInfo' => Typing\Type,
   );
 
   static private dict<string, self::TCachedRef> $generatedRefs = dict[];

src/Codegen/Typing/ConcreteType.hack

@@ -25,6 +25,11 @@ final class ConcreteType extends Type {
     return $this->generics;
   }
 
+  <<__Override>>
+  public function getAlias(): null {
+    return null;
+  }
+
   <<__Override>>
   public function hasAlias(): bool {
     return false;

src/Codegen/Typing/OptionalType.hack

@@ -21,6 +21,11 @@ final class OptionalType extends Type {
     return $this->type->getGenerics();
   }
 
+  <<__Override>>
+  public function getAlias(): ?string {
+    return $this->type->getAlias();
+  }
+
   <<__Override>>
   public function hasAlias(): bool {
     return $this->type->hasAlias();

src/Codegen/Typing/Type.hack

@@ -19,6 +19,11 @@ abstract class Type {
    */
   abstract public function getGenerics(): vec<Type>;
 
+  /**
+   * Alias for this type, if any.
+   */
+  abstract public function getAlias(): ?string;
+
   /**
    * Whether this type has an alias (e.g., is of form <alias> or ?<alias>).
    */

src/Codegen/Typing/TypeAlias.hack

@@ -23,6 +23,11 @@ final class TypeAlias extends Type {
     return $this->getType()->getGenerics();
   }
 
+  <<__Override>>
+  public function getAlias(): string {
+    return $this->alias;
+  }
+
   <<__Override>>
   public function hasAlias(): bool {
     return $this->getType()->hasAlias();
@@ -35,6 +40,6 @@ final class TypeAlias extends Type {
 
   <<__Override>>
   public function render(): string {
-    return $this->alias;
+    return $this->getAlias();
   }
 }

src/Codegen/Typing/TypeSystem.hack

@@ -158,8 +158,7 @@ final abstract class TypeSystem {
   /**
    * Try to map the solved type to one of the passed-in type aliases.
    *
-   * If a matching alias exists, it may make sense to prefer it over generating
-   * a fresh type.
+   * If all types are the alias or null, use the alias.
    */
   private static function maybeUseAlias(Type $type, vec<Type> $types): Type {
     $equivalent_types = vec[];
@@ -173,6 +172,9 @@ final abstract class TypeSystem {
       }
       if ($candidate_ty->isEquivalent($type)) {
         $equivalent_types[] = $candidate_ty;
+      } else if ($candidate_ty->getConcreteTypeName() !== ConcreteTypeName::NOTHING) {
+        // Conflicting type which is not null — bail out.
+        return $type;
       }
     }
 

tests/AnyOfRefiningTest.php

@@ -29,7 +29,14 @@ final class AnyOfRefiningTest extends BaseCodegenTestCase {
     $ret['codegen']->build();
     $ret = self::getBuilder('anyof-schema-4.json', 'AnyOfValidator4');
     $ret['codegen']->build();
-    $ret = self::getBuilder('anyof-schema-strings.json', 'AnyOfValidatorStrings');
+    $ret = self::getBuilder('anyof-schema-strings.json', 'AnyOfValidatorStrings', shape(
+      'refs' => shape(
+        'unique' => shape(
+          'source_root' => __DIR__,
+          'output_root' => __DIR__.'/examples/codegen',
+        ),
+      ),
+    ));
     $ret['codegen']->build();
     $ret = self::getBuilder('anyof-schema-nested-nullable-anyof.json', 'AnyOfValidatorNestedNullableAnyOf');
     $ret['codegen']->build();