Add more tests for super constraints

Summary:
Adds more tests to the type constants super constraints tests:

1) Simple test to ensure we can return values with types which are subtypes of the declared lower bound

2) Ensure we detect 'inconsistent' bounds on abstract type constants through inheritance

3) Ensure we detect impossible refinements on lower bounds

4) Make sure super bounds interact well with expression dependent types

Reviewed By: mheiber

Differential Revision: D88078731

fbshipit-source-id: b9236995acc2176be672c336a494b0171e3b460d

Author: Michael Thomas

hphp/hack/test/typecheck/typeconsts/super_constraints/consistent_bad.php

@@ -0,0 +1,16 @@
+<?hh
+
+class AAA {}
+class BBB extends AAA {}
+
+// These are deliberately not subtypes of AAA or BBB
+class One {}
+class Two extends One {}
+
+abstract class Foo extends Bar {
+  abstract const type Ta as AAA super Two;
+}
+
+abstract class Bar {
+  abstract const type Ta as AAA super One;
+}

hphp/hack/test/typecheck/typeconsts/super_constraints/consistent_bad.php.exp

@@ -0,0 +1,6 @@
+ERROR: File "consistent_bad.php", line 11, characters 23-24:
+The constraint on this type constant is inconsistent with its parent (Typing[4110])
+  File "consistent_bad.php", line 11, characters 39-41:
+  Expected `Two`
+  File "consistent_bad.php", line 15, characters 39-41:
+  But got `One`

hphp/hack/test/typecheck/typeconsts/super_constraints/consistent_good.php

@@ -0,0 +1,16 @@
+<?hh
+
+class AAA {}
+class BBB extends AAA {}
+
+// These are deliberately not subtypes of AAA or BBB
+class One {}
+class Two extends One {}
+
+abstract class Foo {
+  abstract const type Ta as AAA super Two;
+}
+
+abstract class Bar extends Foo {
+  abstract const type Ta as BBB super One;
+}

hphp/hack/test/typecheck/typeconsts/super_constraints/consistent_good.php.exp

@@ -0,0 +1 @@
+No errors

hphp/hack/test/typecheck/typeconsts/super_constraints/expr_dep.php

@@ -0,0 +1,17 @@
+<?hh
+
+class One {}
+class Two extends One {}
+class Three extends Two {}
+
+abstract class Foo {
+  abstract const type Ta as One super Two;
+
+  abstract public function wibble(): this::Ta;
+  abstract public function wobble(this::Ta $_): void;
+}
+
+function test(Foo $x): void {
+  $ta = $x->wibble();
+  $x->wobble($ta);
+}

hphp/hack/test/typecheck/typeconsts/super_constraints/expr_dep.php.exp

@@ -0,0 +1 @@
+No errors

hphp/hack/test/typecheck/typeconsts/super_constraints/refinements.php

@@ -0,0 +1,21 @@
+<?hh
+
+class One {}
+class Two extends One {}
+class Three extends Two {}
+
+abstract class Foo {
+  abstract const type Ta as One super Two;
+}
+
+function ok(Foo with { type Ta as One super Two } $x): void {}
+
+function redundant(Foo with { type Ta as One super Three } $x): void {}
+
+function also_redundant(Foo with { type Ta as One } $x): void {}
+
+function nope(Foo with { type Ta super One } $x): void {}
+
+function test(Foo $x): void {
+  nope($x);
+}

hphp/hack/test/typecheck/typeconsts/super_constraints/refinements.php.exp

@@ -0,0 +1,18 @@
+ERROR: File "refinements.php", line 20, characters 8-9:
+Invalid argument (Typing[4110])
+  File "refinements.php", line 17, characters 15-44:
+  Expected a class with `{type Ta super One}`
+  File "refinements.php", line 19, characters 15-17:
+  But got `<expr#2> as Foo`
+  File "refinements.php", line 20, characters 8-9:
+    where `<expr#2>` is a reference to this expression
+  File "refinements.php", line 17, characters 15-44:
+  Expected a class with `{type Ta super One}`
+  File "refinements.php", line 19, characters 15-17:
+  But got `Foo`
+  File "refinements.php", line 17, characters 40-42:
+  This `super` refinement constraint is violated
+  File "refinements.php", line 8, characters 39-41:
+  Expected `Two`
+  File "refinements.php", line 17, characters 40-42:
+  But got `One`

hphp/hack/test/typecheck/typeconsts/super_constraints/return_sub_lower_bound.php

@@ -0,0 +1,23 @@
+<?hh
+
+class Huge {}
+class Bigly extends Huge {}
+class Middling extends Bigly {}
+class Smol extends Middling {}
+class Tiny extends Smol {}
+
+abstract class Foo {
+  abstract const type Ta as Huge super Middling;
+
+  public function returnMiddling(): this::Ta {
+    return new Middling();
+  }
+
+  public function returnSmol(): this::Ta {
+    return new Smol();
+  }
+
+  public function returnTiny(): this::Ta {
+    return new Tiny();
+  }
+}

hphp/hack/test/typecheck/typeconsts/super_constraints/return_sub_lower_bound.php.exp

@@ -0,0 +1 @@
+No errors