Feature/support null and nonnull (#49)

* Add failing test for null type

* Add NullSpec with tests

* Add support for kind OF_NULL to reified generics

* No need for prettyType()

* Add test for nested nulls

* Let's add support for nonnull, while we're at it

Author: lexidor

src/TypeSpec.hack

@@ -129,6 +129,14 @@ function mixed(): TypeSpec<mixed> {
   return new __Private\MixedSpec();
 }
 
+function nonnull(): TypeSpec<nonnull> {
+  return new __Private\NonNullSpec();
+}
+
+function null(): TypeSpec<null> {
+  return new __Private\NullSpec();
+}
+
 function nullable<T>(TypeSpec<T> $inner): TypeSpec<?T> {
   return new __Private\NullableSpec($inner);
 }

src/TypeSpec/__Private/NonNullSpec.hack

@@ -0,0 +1,35 @@
+/*
+ *  Copyright (c) 2016, Fred Emmott
+ *  Copyright (c) 2017-present, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the MIT license found in the
+ *  LICENSE file in the root directory of this source tree.
+ *
+ */
+
+namespace Facebook\TypeSpec\__Private;
+
+use type Facebook\TypeAssert\IncorrectTypeException;
+use type Facebook\TypeSpec\TypeSpec;
+
+final class NonNullSpec extends TypeSpec<nonnull> {
+  use NoCoercionSpecTrait<nonnull>;
+
+  <<__Override>>
+  public function assertType(mixed $value): nonnull {
+    if ($value is null) {
+      throw IncorrectTypeException::withValue(
+        $this->getTrace(),
+        $this->toString(),
+        $value,
+      );
+    }
+    return $value;
+  }
+
+  <<__Override>>
+  public function toString(): string {
+    return 'nonnull';
+  }
+}

src/TypeSpec/__Private/NullSpec.hack

@@ -0,0 +1,35 @@
+/*
+ *  Copyright (c) 2016, Fred Emmott
+ *  Copyright (c) 2017-present, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the MIT license found in the
+ *  LICENSE file in the root directory of this source tree.
+ *
+ */
+
+namespace Facebook\TypeSpec\__Private;
+
+use type Facebook\TypeAssert\IncorrectTypeException;
+use type Facebook\TypeSpec\TypeSpec;
+
+final class NullSpec extends TypeSpec<null> {
+  use NoCoercionSpecTrait<null>;
+
+  <<__Override>>
+  public function assertType(mixed $value): null {
+    if ($value is nonnull) {
+      throw IncorrectTypeException::withValue(
+        $this->getTrace(),
+        $this->toString(),
+        $value,
+      );
+    }
+    return null;
+  }
+
+  <<__Override>>
+  public function toString(): string {
+    return 'null';
+  }
+}

src/TypeSpec/__Private/from_type_structure.hack

@@ -214,6 +214,12 @@ function from_type_structure<T>(TypeStructure<T> $ts): TypeSpec<T> {
       $enum = TypeAssert\not_null($ts['classname']);
       /* HH_IGNORE_ERROR[4323] */
       return new EnumSpec($enum);
+    case TypeStructureKind::OF_NULL:
+      /* HH_IGNORE_ERROR[4110] unsafe generics */
+      return new NullSpec();
+    case TypeStructureKind::OF_NONNULL:
+      /* HH_IGNORE_ERROR[4110] unsafe generics */
+      return new NonNullSpec();
     case TypeStructureKind::OF_UNRESOLVED:
       throw new UnsupportedTypeException('OF_UNRESOLVED');
     default:

tests/NonNullSpecTest.hack

@@ -0,0 +1,47 @@
+/*
+ *  Copyright (c) 2016, Fred Emmott
+ *  Copyright (c) 2017-present, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the MIT license found in the
+ *  LICENSE file in the root directory of this source tree.
+ *
+ */
+
+namespace Facebook\TypeAssert;
+
+use namespace Facebook\TypeSpec;
+use type Facebook\TypeSpec\TypeSpec;
+
+final class NonNullSpecTest extends TypeSpecTest<nonnull> {
+  <<__Override>>
+  public function getTypeSpec(): TypeSpec<nonnull> {
+    return TypeSpec\nonnull();
+  }
+
+  <<__Override>>
+  public function getValidCoercions(): vec<(mixed, nonnull)> {
+    return vec[
+      tuple(0, 0),
+      tuple('', ''),
+      tuple("\0", "\0"),
+      tuple(\STDIN, \STDIN),
+      tuple(false, false),
+      tuple(vec[], vec[]),
+    ];
+  }
+
+  <<__Override>>
+  public function getInvalidCoercions(): vec<(mixed)> {
+    return vec[
+      tuple(null),
+    ];
+  }
+
+  <<__Override>>
+  public function getToStringExamples(): vec<(TypeSpec<nonnull>, string)> {
+    return vec[
+      tuple(TypeSpec\nonnull(), 'nonnull'),
+    ];
+  }
+}

tests/NullSpecTest.hack

@@ -0,0 +1,47 @@
+/*
+ *  Copyright (c) 2016, Fred Emmott
+ *  Copyright (c) 2017-present, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the MIT license found in the
+ *  LICENSE file in the root directory of this source tree.
+ *
+ */
+
+namespace Facebook\TypeAssert;
+
+use namespace Facebook\TypeSpec;
+use type Facebook\TypeSpec\TypeSpec;
+
+final class NullSpecTest extends TypeSpecTest<null> {
+  <<__Override>>
+  public function getTypeSpec(): TypeSpec<null> {
+    return TypeSpec\null();
+  }
+
+  <<__Override>>
+  public function getValidCoercions(): vec<(mixed, null)> {
+    return vec[
+      tuple(null, null),
+    ];
+  }
+
+  <<__Override>>
+  public function getInvalidCoercions(): vec<(mixed)> {
+    return vec[
+      tuple(0),
+      tuple(''),
+      tuple("\0"),
+      tuple(\STDIN),
+      tuple(false),
+      tuple(vec[]),
+    ];
+  }
+
+  <<__Override>>
+  public function getToStringExamples(): vec<(TypeSpec<null>, string)> {
+    return vec[
+      tuple(TypeSpec\null(), 'null'),
+    ];
+  }
+}

tests/ReifiedGenericsTest.hack

@@ -67,4 +67,33 @@ final class ReifiedGenericsTest extends \Facebook\HackTest\HackTest {
     expect(TypeSpec\of<shape('foo' => vec<string>, ...)>()->toString())
       ->toEqual("shape(\n  'foo' => HH\\vec<string>,\n  ...\n)");
   }
+
+  public function testNullType(): void {
+    expect(TypeSpec\of<null>()->toString())->toEqual('null');
+    expect(
+      TypeSpec\of<dict<string, ?dict<string, ?dict<string, null>>>>()
+        ->toString(),
+    )->toEqual('HH\dict<string, ?HH\dict<string, ?HH\dict<string, null>>>');
+  }
+
+  public function testNonNullType(): void {
+    expect(TypeSpec\of<nonnull>()->toString())->toEqual('nonnull');
+    expect(
+      TypeSpec\of<shape(
+        ?'optional_but_never_null' => nonnull,
+        'required_but_may_be_null' => mixed,
+        'neither' => nonnull,
+        ?'both' => mixed,
+      )>()
+        ->toString(),
+    )->toEqual(<<<'TYPE'
+shape(
+  ?'optional_but_never_null' => nonnull,
+  'required_but_may_be_null' => mixed,
+  'neither' => nonnull,
+  ?'both' => mixed,
+)
+TYPE
+    );
+  }
 }