Remove vec-like and dict-like PHP array support

- remove dict_like_array()
- remove vec_like_array()
- use darray()/varray() instead of casts
- make UntypedArray return a varray_or_darray(mixed) instead of array

Treating `array` and `varray_or_darray` as interchangeable raises
notices on 4.58; this makes the modified types required - might as well
remove the old ones too while we're here, as they should go eventually.

Author: fredemmott

src/TypeSpec.hack

@@ -63,7 +63,7 @@ function darray<Tk as arraykey, Tv>(
   TypeSpec<Tk> $tsk,
   TypeSpec<Tv> $tsv,
 ): TypeSpec<darray<Tk, Tv>> {
-  return new __Private\DictLikeArraySpec('darray', $tsk, $tsv);
+  return new __Private\DarraySpec($tsk, $tsv);
 }
 
 function dict<Tk as arraykey, Tv>(
@@ -73,13 +73,6 @@ function dict<Tk as arraykey, Tv>(
   return new __Private\DictSpec($tsk, $tsv);
 }
 
-function dict_like_array<Tk as arraykey, Tv>(
-  TypeSpec<Tk> $tsk,
-  TypeSpec<Tv> $tsv,
-): TypeSpec<array<Tk, Tv>> {
-  return new __Private\DictLikeArraySpec('array', $tsk, $tsv);
-}
-
 function enum<
   Tinner as arraykey,
   T as /* HH_IGNORE_ERROR[2053] */ \HH\BuiltinEnum<Tinner>,
@@ -164,17 +157,13 @@ function untyped_array(): TypeSpec<array> {
 }
 
 function varray<Tv>(TypeSpec<Tv> $tsv): TypeSpec<varray<Tv>> {
-  return new __Private\VecLikeArraySpec('varray', $tsv);
+  return new __Private\VarraySpec($tsv);
 }
 
 function vec<Tv>(TypeSpec<Tv> $inner): TypeSpec<vec<Tv>> {
   return new __Private\VecSpec($inner);
 }
 
-function vec_like_array<Tv>(TypeSpec<Tv> $tsv): TypeSpec<array<Tv>> {
-  return new __Private\VecLikeArraySpec('array', $tsv);
-}
-
 function vector<Tv>(TypeSpec<Tv> $inner): TypeSpec<Vector<Tv>> {
   return new __Private\VectorSpec(Vector::class, $inner);
 }

…ypeSpec/__Private/DictLikeArraySpec.hack src/TypeSpec/__Private/DarraySpec.hacksrc/TypeSpec/__Private/DictLikeArraySpec.hack renamed to src/TypeSpec/__Private/DarraySpec.hack src/TypeSpec/__Private/DictLikeArraySpec.hack renamed to src/TypeSpec/__Private/DarraySpec.hack

@@ -15,63 +15,60 @@ use type Facebook\TypeSpec\TypeSpec;
 
 use namespace HH\Lib\{Dict, Str};
 
-final class DictLikeArraySpec<Tk as arraykey, Tv>
-  extends TypeSpec<array<Tk, Tv>> {
+final class DarraySpec<Tk as arraykey, Tv>
+  extends TypeSpec<darray<Tk, Tv>> {
 
   public function __construct(
-    private string $name,
     private TypeSpec<Tk> $tsk,
     private TypeSpec<Tv> $tsv,
   ) {
   }
 
   <<__Override>>
-  public function coerceType(mixed $value): array<Tk, Tv> {
+  public function coerceType(mixed $value): darray<Tk, Tv> {
     if (!$value is KeyedTraversable<_, _>) {
       throw TypeCoercionException::withValue(
         $this->getTrace(),
-        $this->name.'<Tk, Tv>',
+        'darray<Tk, Tv>',
         $value,
       );
     }
 
-    $kt = $this->getTrace()->withFrame($this->name.'<Tk, _>');
-    $vt = $this->getTrace()->withFrame($this->name.'<_, Tv>');
+    $kt = $this->getTrace()->withFrame('darray<Tk, _>');
+    $vt = $this->getTrace()->withFrame('darray<_, Tv>');
 
     return Dict\pull_with_key(
       $value,
       ($_k, $v) ==> $this->tsv->withTrace($vt)->coerceType($v),
       ($k, $_v) ==> $this->tsk->withTrace($kt)->coerceType($k),
-    )
-      |> /* HH_IGNORE_ERROR[4007] PHP array cast */ (array)$$;
+    ) |> darray($$);
   }
 
   <<__Override>>
-  public function assertType(mixed $value): array<Tk, Tv> {
+  public function assertType(mixed $value): darray<Tk, Tv> {
     if (!\is_array($value)) {
       throw IncorrectTypeException::withValue(
         $this->getTrace(),
-        $this->name.'<Tk, Tv>',
+        $this->toString(),
         $value,
       );
     }
 
-    $kt = $this->getTrace()->withFrame($this->name.'<Tk, _>');
-    $vt = $this->getTrace()->withFrame($this->name.'<_, Tv>');
+    $kt = $this->getTrace()->withFrame('darray<Tk, _>');
+    $vt = $this->getTrace()->withFrame('darray<_, Tv>');
 
     return Dict\pull_with_key(
       $value,
       ($_k, $v) ==> $this->tsv->withTrace($vt)->assertType($v),
       ($k, $_v) ==> $this->tsk->withTrace($kt)->assertType($k),
     )
-      |> /* HH_IGNORE_ERROR[4007] PHP array cast */ (array)$$;
+      |> darray($$);
   }
 
   <<__Override>>
   public function toString(): string {
     return Str\format(
-      '%s<%s, %s>',
-      $this->name,
+      'darray<%s, %s>',
       $this->tsk->toString(),
       $this->tsv->toString(),
     );

src/TypeSpec/__Private/TupleSpec.hack

@@ -80,8 +80,8 @@ final class TupleSpec extends TypeSpec<BogusTuple> {
       /* HH_IGNORE_ERROR[4110] */
       return $tuple;
     }
-    /* HH_IGNORE_ERROR[4007] */
-    return (array)$tuple;
+    /* HH_IGNORE_ERROR[4110] */
+    return varray($tuple);
   }
 
   <<__Override>>

src/TypeSpec/__Private/UntypedArraySpec.hack

@@ -13,12 +13,10 @@ namespace Facebook\TypeSpec\__Private;
 use type Facebook\TypeAssert\{IncorrectTypeException, TypeCoercionException};
 use type Facebook\TypeSpec\TypeSpec;
 
-/* HH_IGNORE_ERROR[4045] array without generics */
-final class UntypedArraySpec extends TypeSpec<array> {
+final class UntypedArraySpec extends TypeSpec<varray_or_darray<mixed>> {
 
   <<__Override>>
-  /* HH_IGNORE_ERROR[4045] array without generics */
-  public function coerceType(mixed $value): array {
+  public function coerceType(mixed $value): varray_or_darray<mixed> {
     if (!$value is KeyedTraversable<_, _>) {
       throw
         TypeCoercionException::withValue($this->getTrace(), 'array', $value);
@@ -32,18 +30,20 @@ final class UntypedArraySpec extends TypeSpec<array> {
   }
 
   <<__Override>>
-  /* HH_IGNORE_ERROR[4045] array without generics */
-  public function assertType(mixed $value): array {
+  public function assertType(mixed $value): varray_or_darray<mixed> {
     if (!\is_array($value)) {
       throw
         IncorrectTypeException::withValue($this->getTrace(), 'array', $value);
     }
 
-    return $value;
+    if (varray($value) === $value) {
+      return varray($value);
+    }
+    return darray($value);
   }
 
   <<__Override>>
   public function toString(): string {
-    return 'array';
+    return 'varray_or_darray<mixed>';
   }
 }

…TypeSpec/__Private/VecLikeArraySpec.hack src/TypeSpec/__Private/VarraySpec.hacksrc/TypeSpec/__Private/VecLikeArraySpec.hack renamed to src/TypeSpec/__Private/VarraySpec.hack src/TypeSpec/__Private/VecLikeArraySpec.hack renamed to src/TypeSpec/__Private/VarraySpec.hack

@@ -14,19 +14,18 @@ use type Facebook\TypeAssert\{IncorrectTypeException, TypeCoercionException};
 use type Facebook\TypeSpec\TypeSpec;
 use namespace HH\Lib\Vec;
 
-final class VecLikeArraySpec<T> extends TypeSpec<array<T>> {
+final class VarraySpec<T> extends TypeSpec<varray<T>> {
   public function __construct(
-    private string $name,
     private TypeSpec<T> $inner,
   ) {
   }
 
   <<__Override>>
-  public function coerceType(mixed $value): array<T> {
+  public function coerceType(mixed $value): varray<T> {
     if (!$value is Traversable<_>) {
       throw TypeCoercionException::withValue(
         $this->getTrace(),
-        $this->name.'<T>',
+        'varray<T>',
         $value,
       );
     }
@@ -36,11 +35,11 @@ final class VecLikeArraySpec<T> extends TypeSpec<array<T>> {
   }
 
   <<__Override>>
-  public function assertType(mixed $value): array<T> {
+  public function assertType(mixed $value): varray<T> {
     if (!\is_array($value)) {
       throw IncorrectTypeException::withValue(
         $this->getTrace(),
-        $this->name.'<T>',
+        'varray<T>',
         $value,
       );
     }
@@ -67,15 +66,15 @@ final class VecLikeArraySpec<T> extends TypeSpec<array<T>> {
         }
         return $this
           ->inner
-          ->withTrace($this->getTrace()->withFrame($this->name.'['.$i.']'))
+          ->withTrace($this->getTrace()->withFrame('varray['.$i.']'))
           ->assertType($inner);
       },
     )
-      |> \array_values($$);
+      |> varray($$);
   }
 
   <<__Override>>
   public function toString(): string {
-    return $this->name.'<'.$this->inner->toString().'>';
+    return 'varray<'.$this->inner->toString().'>';
   }
 }

src/TypeSpec/__Private/from_type_structure.hack

@@ -75,11 +75,10 @@ function from_type_structure<T>(TypeStructure<T> $ts): TypeSpec<T> {
           return new UntypedArraySpec();
         case 1:
           /* HH_IGNORE_ERROR[4110] */
-          return new VecLikeArraySpec('array', from_type_structure($generics[0]));
+          return new VarraySpec(from_type_structure($generics[0]));
         case 2:
           /* HH_IGNORE_ERROR[4110] */
-          return new DictLikeArraySpec(
-            'array',
+          return new DarraySpec(
             from_type_structure($generics[0]),
             from_type_structure($generics[1]),
           );

tests/DArraySpecTest.hack

@@ -12,7 +12,6 @@ namespace Facebook\TypeAssert;
 
 use namespace Facebook\TypeSpec;
 use type Facebook\TypeSpec\TypeSpec;
-use function Facebook\FBExpect\expect;
 
 final class DArraySpecTest extends TypeSpecTest<darray<arraykey, mixed>> {
   <<__Override>>
@@ -57,34 +56,6 @@ final class DArraySpecTest extends TypeSpecTest<darray<arraykey, mixed>> {
         TypeSpec\darray(TypeSpec\int(), TypeSpec\string()),
         'darray<int, string>',
       ),
-      tuple(
-        TypeSpec\dict_like_array(TypeSpec\string(), TypeSpec\int()),
-        'array<string, int>',
-      ),
-      tuple(
-        TypeSpec\dict_like_array(TypeSpec\int(), TypeSpec\string()),
-        'array<int, string>',
-      ),
-
     ];
   }
-
-  public function testDictLikeArrayIsDArray(): void {
-    $dict_like_array = (
-      (): array<string, int> ==> TypeSpec\dict_like_array(
-        TypeSpec\string(),
-        TypeSpec\int(),
-      )->assertType(darray['foo' => 123])
-    )();
-    expect($dict_like_array)->toEqual(darray['foo' => 123]);
-    $darray_asserted = (
-      (): darray<string, int> ==> TypeSpec\darray(
-        TypeSpec\string(),
-        TypeSpec\int(),
-      )->assertType($dict_like_array)
-    )();
-    expect($darray_asserted)->toEqual($dict_like_array);
-    $darray_verbatim = ((): darray<string, int> ==> $dict_like_array)();
-    expect($darray_verbatim)->toEqual($dict_like_array);
-  }
 }

tests/TypeStructureTest.hack

@@ -297,19 +297,19 @@ final class TypeStructureTest extends \Facebook\HackTest\HackTest {
         type_structure(TypeConstants::class, 'TStringArray'),
         /* HHAST_IGNORE_ERROR[NoPHPArrayLiterals] */
         array(123),
-        vec['array[0]'],
+        vec['varray[0]'],
       ),
       'int keys in array<string, string>' => tuple(
         type_structure(TypeConstants::class, 'TStringStringArray'),
         /* HHAST_IGNORE_ERROR[NoPHPArrayLiterals] */
         array(123 => 'bar', 123 => 'derp'),
-        vec['array<Tk, _>'],
+        vec['darray<Tk, _>'],
       ),
       'int values in array<string, string>' => tuple(
         type_structure(TypeConstants::class, 'TStringStringArray'),
         /* HHAST_IGNORE_ERROR[NoPHPArrayLiterals] */
         array('foo' => 123, 'bar' => 456),
-        vec['array<_, Tv>'],
+        vec['darray<_, Tv>'],
       ),
       '0 as ?string' => tuple(
         type_structure(TypeConstants::class, 'TNullableString'),

tests/VArraySpecTest.hack

@@ -12,7 +12,6 @@ namespace Facebook\TypeAssert;
 
 use namespace Facebook\TypeSpec;
 use type Facebook\TypeSpec\TypeSpec;
-use function Facebook\FBExpect\expect;
 
 final class VArraySpecTest extends TypeSpecTest<varray<mixed>> {
   <<__Override>>
@@ -51,23 +50,6 @@ final class VArraySpecTest extends TypeSpecTest<varray<mixed>> {
     return vec[
       tuple(TypeSpec\varray(TypeSpec\string()), 'varray<string>'),
       tuple(TypeSpec\varray(TypeSpec\int()), 'varray<int>'),
-      tuple(TypeSpec\vec_like_array(TypeSpec\string()), 'array<string>'),
-      tuple(TypeSpec\vec_like_array(TypeSpec\int()), 'array<int>'),
     ];
   }
-
-  public function testVecLikeArrayIsVArray(): void {
-    $vec_like_array = (
-      (): array<int> ==>
-        TypeSpec\vec_like_array(TypeSpec\int())->assertType(varray[123])
-    )();
-    expect($vec_like_array)->toEqual(varray[123]);
-    $varray_asserted = (
-      (): varray<int> ==>
-        TypeSpec\varray(TypeSpec\int())->assertType($vec_like_array)
-    )();
-    expect($varray_asserted)->toEqual($vec_like_array);
-    $varray_verbatim = ((): varray<int> ==> $vec_like_array)();
-    expect($varray_verbatim)->toEqual($vec_like_array);
-  }
 }