Start implementing part of the variance checks

Author: Girgias

Zend/tests/type_declarations/disjoint_union_types/variance/invalid1.phpt

@@ -0,0 +1,28 @@
+--TEST--
+Co-variance check failure for intersection type where child replace one of intersection type members with a supertype
+--FILE--
+<?php
+
+interface A {}
+interface B extends A {}
+interface C {}
+interface X {}
+
+class Test implements B, C {}
+
+class Foo {
+    public function foo(): (B&C)|X {
+        return new Test();
+    }
+}
+
+/* This fails because A is a parent type for B */
+class FooChild extends Foo {
+    public function foo(): (A&C)|X {
+        return new Test();
+    }
+}
+
+?>
+--EXPECTF--
+Fatal error: Declaration of FooChild::foo(): (A&C)|X must be compatible with Foo::foo(): (B&C)|X in %s on line %d

Zend/tests/type_declarations/disjoint_union_types/variance/invalid_covariance_drop_type1.phpt

@@ -0,0 +1,27 @@
+--TEST--
+Co-variance check failure for intersection type where child removes one of intersection type members
+--FILE--
+<?php
+
+interface A {}
+interface B {}
+interface X {}
+
+class Test implements A, B {}
+
+class Foo {
+    public function foo(): (A&B)|X {
+        return new Test();
+    }
+}
+
+/* This fails because just A larger than A&B */
+class FooChild extends Foo {
+    public function foo(): A|X {
+        return new Test();
+    }
+}
+
+?>
+--EXPECTF--
+Fatal error: Declaration of FooChild::foo(): A|X must be compatible with Foo::foo(): (A&B)|X in %s on line %d

Zend/tests/type_declarations/disjoint_union_types/variance/invalid_covariance_drop_type2.phpt

@@ -0,0 +1,28 @@
+--TEST--
+Co-variance check failure for intersection type where child removes one of intersection type members
+--FILE--
+<?php
+
+interface A {}
+interface B {}
+interface C {}
+interface X {}
+
+class Test implements A, B, C {}
+
+class Foo {
+    public function foo(): (A&B&C)|X {
+        return new Test();
+    }
+}
+
+/* This fails because just (A&B) larger than ((A&B)&C) */
+class FooChild extends Foo {
+    public function foo(): (A&B)|X {
+        return new Test();
+    }
+}
+
+?>
+--EXPECTF--
+Fatal error: Declaration of FooChild::foo(): (A&B)|X must be compatible with Foo::foo(): (A&B&C)|X in %s on line %d

Zend/tests/type_declarations/disjoint_union_types/variance/invalid_covariance_intersection_to_union1.phpt

@@ -0,0 +1,26 @@
+--TEST--
+Co-variance failure for intersection type where child is union, but not all members are a subtype of intersection 1
+--FILE--
+<?php
+
+interface X {}
+interface Y {}
+
+interface L {}
+
+class TestOne implements X, Y {}
+class TestTwo implements X {}
+
+interface A
+{
+    public function foo(): (X&Y)|L;
+}
+
+interface B extends A
+{
+    public function foo(): TestOne|TestTwo;
+}
+
+?>
+--EXPECTF--
+Fatal error: Declaration of B::foo(): TestOne|TestTwo must be compatible with A::foo(): (X&Y)|L in %s on line %d

Zend/tests/type_declarations/disjoint_union_types/variance/invalid_covariance_intersection_to_union2.phpt

@@ -0,0 +1,23 @@
+--TEST--
+Co-variance failure for intersection type where child is union, but not all members are a subtype of intersection 2
+--FILE--
+<?php
+
+interface X {}
+interface Y {}
+
+class TestOne implements X, Y {}
+
+interface A
+{
+    public function foo(): X&Y;
+}
+
+interface B extends A
+{
+    public function foo(): TestOne|int;
+}
+
+?>
+--EXPECTF--
+Fatal error: Declaration of B::foo(): TestOne|int must be compatible with A::foo(): X&Y in %s on line %d

Zend/tests/type_declarations/disjoint_union_types/variance/invalid_covariance_intersection_to_union3.phpt

@@ -0,0 +1,25 @@
+--TEST--
+Co-variance failure for intersection type where child is union, but not all members are a subtype of intersection 2
+--FILE--
+<?php
+
+interface X {}
+interface Y {}
+interface Z extends Y {}
+
+class TestOne implements X, Z {}
+class TestTwo implements X, Y {}
+
+interface A
+{
+    public function foo(): X&Z;
+}
+
+interface B extends A
+{
+    public function foo(): TestOne|TestTwo;
+}
+
+?>
+--EXPECTF--
+Fatal error: Declaration of B::foo(): TestOne|TestTwo must be compatible with A::foo(): X&Z in %s on line %d

Zend/tests/type_declarations/disjoint_union_types/variance/invalid_invariance1.phpt

@@ -0,0 +1,18 @@
+--TEST--
+Property types must be invariant
+--FILE--
+<?php
+
+interface X {}
+interface Y {}
+
+class A {
+    public (X&Y)|L $prop;
+}
+class B extends A {
+    public (X&Y&Z)|L $prop;
+}
+
+?>
+--EXPECTF--
+Fatal error: Type of B::$prop must be (X&Y)|L (as in class A) in %s on line %d

Zend/tests/type_declarations/disjoint_union_types/variance/invalid_invariance2.phpt

@@ -0,0 +1,21 @@
+--TEST--
+Intersection type reduction invalid invariant type check
+--FILE--
+<?php
+
+interface X {}
+interface Y {}
+class A implements X, Y {}
+class B {}
+
+class Test {
+    public (X&Y)|B $prop;
+}
+class Test2 extends Test {
+    public A|B $prop;
+}
+
+?>
+===DONE===
+--EXPECTF--
+Fatal error: Type of Test2::$prop must be (X&Y)|B (as in class Test) in %s on line %d

Zend/tests/type_declarations/disjoint_union_types/variance/valid1.phpt

@@ -0,0 +1,40 @@
+--TEST--
+Valid inheritence - co-variance
+--FILE--
+<?php
+
+interface A {}
+interface B {}
+interface C {}
+
+class Test implements A, B, C {}
+
+class Foo {
+    public function foo(): A {
+        return new Test();
+    }
+}
+
+class FooChild extends Foo {
+    public function foo(): A&B {
+        return new Test();
+    }
+}
+
+class FooSecondChild extends FooChild {
+    public function foo(): A&B&C {
+        return new Test();
+    }
+}
+
+$o = new FooChild();
+var_dump($o->foo());
+$o = new FooSecondChild();
+var_dump($o->foo());
+
+?>
+--EXPECTF--
+object(Test)#%d (0) {
+}
+object(Test)#%d (0) {
+}

Zend/tests/type_declarations/disjoint_union_types/variance/valid2.phpt

@@ -0,0 +1,23 @@
+--TEST--
+Commutative intersection types
+--FILE--
+<?php
+
+interface A {}
+interface B {}
+interface X {}
+
+class Foo {
+    public X|(A&B) $prop;
+    public function foo(X|(A&B) $v): X|(A&B) {}
+}
+
+class FooChild extends Foo {
+    public (B&A)|X $prop;
+    public function foo((B&A)|X $v): (B&A)|X {}
+}
+
+?>
+===DONE===
+--EXPECT--
+===DONE===

Zend/tests/type_declarations/disjoint_union_types/variance/valid4.phpt

@@ -0,0 +1,20 @@
+--TEST--
+Intersection type reduction valid invariant type check
+--FILE--
+<?php
+
+class A {}
+class B extends A {}
+interface X {}
+
+class Test {
+    public (A&B)|X $prop;
+}
+class Test2 extends Test {
+    public B|X $prop;
+}
+
+?>
+===DONE===
+--EXPECT--
+===DONE===

Zend/tests/type_declarations/disjoint_union_types/variance/valid5.phpt

@@ -0,0 +1,46 @@
+--TEST--
+Replacing union of classes respecting intersection type by intersection type
+--FILE--
+<?php
+
+interface X {}
+interface Y {}
+
+class TestOne implements X, Y {}
+class TestTwo implements X, Y {}
+class Foo {}
+
+interface A
+{
+    public function foo(TestOne|TestTwo|Foo $param): (X&Y)|Foo;
+}
+
+interface B extends A
+{
+    public function foo((X&Y)|Foo $param): TestOne|TestTwo|Foo;
+}
+
+interface C extends A
+{
+    public function foo(X|Foo $param): TestTwo;
+}
+
+interface D extends A
+{
+    public function foo(Y|Foo $param): TestOne;
+}
+
+interface E extends B
+{
+    public function foo(X|Foo $param): TestTwo;
+}
+
+interface F extends B
+{
+    public function foo(Y|Foo $param): TestOne;
+}
+
+?>
+===DONE===
+--EXPECT--
+===DONE===

Zend/tests/type_declarations/disjoint_union_types/variance/valid6.phpt

@@ -0,0 +1,20 @@
+--TEST--
+Replacing union type by intersection type
+--FILE--
+<?php
+
+interface X {}
+interface Y {}
+interface Z {}
+
+class A {
+    public function test(): X|Z {}
+}
+class B extends A {
+    public function test(): (X&Y)|Z {}
+}
+
+?>
+===DONE===
+--EXPECT--
+===DONE===

Zend/tests/type_declarations/disjoint_union_types/variance/valid7.phpt

@@ -0,0 +1,23 @@
+--TEST--
+Replacing object type with intersection type
+--FILE--
+<?php
+
+// It's sufficient that Y is loadable.
+interface Y {}
+
+class Test {
+    function method1(): object {}
+    function method2(): object|int {}
+    function method3(): Y|int {}
+}
+class Test2 extends Test {
+    function method1(): (X&Y)|Countable {}
+    function method2(): (X&Y)|int {}
+    function method3(): (X&Y)|int {}
+}
+
+?>
+===DONE===
+--EXPECT--
+===DONE===