Support disallow_array_literal (#17)

* Support `disallow_array_literal`

* Enable strict options that introduce test failures

* Require HHVM 4.25 for HHI support of array_literal

* Test on composer.json version of hhvm

Author: lexidor

.hhconfig

@@ -8,3 +8,4 @@ enable_experimental_tc_features=shape_field_check,sealed_classes
 user_attributes=
 disable_primitive_refinement=true
 disable_static_local_variables = true
+disallow_array_literal = true

.travis.yml

@@ -2,7 +2,7 @@ sudo: required
 language: generic
 services: docker
 env:
-- HHVM_VERSION=4.18-latest
+- HHVM_VERSION=4.25-latest
 - HHVM_VERSION=latest
 - HHVM_VERSION=nightly
 install:

composer.json

@@ -5,7 +5,7 @@
   "keywords": ["hack", "router", "routing", "hhvm"],
   "homepage": "https://github.com/hhvm/hack-router",
   "require": {
-    "hhvm": "^4.18",
+    "hhvm": "^4.25",
     "hhvm/hsl": "^4.0",
     "facebook/hack-http-request-response-interfaces": "^0.2"
   },

src/router/PrefixMatchingResolver.php

@@ -63,7 +63,7 @@ private function resolveWithMap(
     $regexps = $map->getRegexps();
     foreach ($regexps as $regexp => $_sub_map) {
       $pattern = '#^'.$regexp.'#';
-      $matches = [];
+      $matches = varray[];
 
       if (\preg_match_with_matches($pattern, $path, inout $matches) !== 1) {
         continue;

src/router/SimpleRegexpResolver.php

@@ -33,7 +33,7 @@ public function resolve(
     }
     $map = $this->map[$method];
     foreach ($map as $regexp => $responder) {
-      $matches = [];
+      $matches = varray[];
       if (\preg_match_with_matches($regexp, $path, inout $matches) !== 1) {
         continue;
       }

tests/ParserTest.php

@@ -14,8 +14,8 @@
 use type Facebook\HackTest\DataProvider;
 
 final class ParserTest extends \Facebook\HackTest\HackTest {
-  public function getExamplePatterns(): array<(string, string)> {
-    return [
+  public function getExamplePatterns(): varray<(string, string)> {
+    return varray[
       tuple('/foo', "['/foo']"),
       tuple('/foo/{bar}', "['/foo/', {bar}]"),
       tuple('/foo/[{bar}]', "['/foo/', ?[{bar}]]"),

tests/RequestParametersTest.php

@@ -15,38 +15,38 @@
 
 final class RequestParametersTest extends \Facebook\HackTest\HackTest {
   public function testStringParam(): void {
-    $parts = [new StringRequestParameter(
+    $parts = varray[new StringRequestParameter(
       StringRequestParameterSlashes::WITHOUT_SLASHES,
       'foo',
     )];
     $data = dict['foo' => 'bar'];
-    expect((new RequestParameters($parts, [], $data))->getString('foo'))
+    expect((new RequestParameters($parts, varray[], $data))->getString('foo'))
       ->toBeSame('bar');
   }
 
   public function testIntParam(): void {
-    $parts = [new IntRequestParameter('foo')];
+    $parts = varray[new IntRequestParameter('foo')];
     $data = dict['foo' => '123'];
-    expect((new RequestParameters($parts, [], $data))->getInt('foo'))->toBeSame(
+    expect((new RequestParameters($parts, varray[], $data))->getInt('foo'))->toBeSame(
       123,
     );
   }
 
   public function testFetchingStringAsInt(): void {
     expect(() ==> {
-      $parts = [new StringRequestParameter(
+      $parts = varray[new StringRequestParameter(
         StringRequestParameterSlashes::WITHOUT_SLASHES,
         'foo',
       )];
       $data = dict['foo' => 'bar'];
-      (new RequestParameters($parts, [], $data))->getInt('foo');
+      (new RequestParameters($parts, varray[], $data))->getInt('foo');
     })->toThrow(InvariantException::class);
   }
 
   public function testEnumParam(): void {
-    $parts = [new EnumRequestParameter(TestIntEnum::class, 'foo')];
+    $parts = varray[new EnumRequestParameter(TestIntEnum::class, 'foo')];
     $data = dict['foo' => (string)TestIntEnum::BAR];
-    $value = (new RequestParameters($parts, [], $data))->getEnum(
+    $value = (new RequestParameters($parts, varray[], $data))->getEnum(
       TestIntEnum::class,
       'foo',
     );
@@ -85,7 +85,7 @@ public function testFromPattern(): void {
       'bar' => '123',
       'baz' => (string)TestIntEnum::FOO,
     ];
-    $params = new RequestParameters($parts, [], $data);
+    $params = new RequestParameters($parts, varray[], $data);
     expect($params->getString('foo'))->toBeSame('some string');
     expect($params->getInt('bar'))->toBeSame(123);
     expect($params->getEnum(TestIntEnum::class, 'baz'))->toBeSame(
@@ -95,8 +95,8 @@ public function testFromPattern(): void {
 
   public function testGetOptional(): void {
     $params = new RequestParameters(
-      [],
-      [new StringRequestParameter(
+      varray[],
+      varray[new StringRequestParameter(
         StringRequestParameterSlashes::WITHOUT_SLASHES,
         'foo',
       )],
@@ -107,8 +107,8 @@ public function testGetOptional(): void {
 
   public function testGetMissingOptional(): void {
     $params = new RequestParameters(
-      [],
-      [new StringRequestParameter(
+      varray[],
+      varray[new StringRequestParameter(
         StringRequestParameterSlashes::WITHOUT_SLASHES,
         'foo',
       )],
@@ -120,8 +120,8 @@ public function testGetMissingOptional(): void {
   public function testGetOptionalAsRequired(): void {
     expect(() ==> {
       $params = new RequestParameters(
-        [],
-        [new StringRequestParameter(
+        varray[],
+        varray[new StringRequestParameter(
           StringRequestParameterSlashes::WITHOUT_SLASHES,
           'foo',
         )],
@@ -134,11 +134,11 @@ public function testGetOptionalAsRequired(): void {
   public function testGetRequiredAsOptional(): void {
     expect(() ==> {
       $params = new RequestParameters(
-        [new StringRequestParameter(
+        varray[new StringRequestParameter(
           StringRequestParameterSlashes::WITHOUT_SLASHES,
           'foo',
         )],
-        [],
+        varray[],
         dict['foo' => 'bar'],
       );
       $params->getOptionalString('foo');

tests/RouterTest.php

@@ -38,8 +38,8 @@ final class RouterTest extends \Facebook\HackTest\HackTest {
     ];
 
   public function expectedMatches(
-  ): array<(string, string, dict<string, string>)> {
-    return [
+  ): varray<(string, string, dict<string, string>)> {
+    return varray[
       tuple('/foo', '/foo', dict[]),
       tuple('/foo/', '/foo/', dict[]),
       tuple('/foo/bar', '/foo/bar', dict[]),
@@ -96,7 +96,7 @@ public function getAllResolvers(
       (function(dict<HttpMethod, dict<string, string>>): IResolver<string>),
     )
   > {
-    return [
+    return varray[
       tuple('simple regexp', $map ==> new SimpleRegexpResolver($map)),
       tuple(
         'prefix matching',
@@ -110,7 +110,7 @@ public function expectedMatchesWithResolvers(
     $map = dict[HttpMethod::GET => dict(self::MAP)];
     $resolvers = Dict\from_entries($this->getAllResolvers());
 
-    $out = [];
+    $out = varray[];
     $examples = $this->expectedMatches();
     foreach ($resolvers as $name => $resolver) {
       $resolver = $resolver($map);

tests/UriPatternTest.php

@@ -71,8 +71,8 @@ public function testIntParamAssertSucceeds(): void {
     )->toBeSame((new IntRequestParameter('foo'))->assert('123'));
   }
 
-  public function exampleInvalidInts(): array<array<string>> {
-    return [['foo'], ['0123foo'], ['0.123foo'], ['0.123'], ['0x1e3']];
+  public function exampleInvalidInts(): varray<varray<string>> {
+    return varray[varray['foo'], varray['0123foo'], varray['0.123foo'], varray['0.123'], varray['0x1e3']];
   }
 
   <<DataProvider('exampleInvalidInts')>>