Add covariance/contravariance to inherited methods

Return types are covariant; parameter types are contravariant.

Author: morrisonlevi

Zend/tests/bug76451.inc

@@ -0,0 +1,4 @@
+<?php
+
+class Foo {}
+class_alias('Foo', 'Bar');

Zend/tests/bug76451.phpt

@@ -0,0 +1,20 @@
+--TEST--
+Aliases during inheritance type checks affected by opcache
+--INI--
+opcache.enable=1
+opcache.enable_cli=1
+opcache.optimization_level=-1
+--SKIPIF--
+<?php if (!extension_loaded('Zend OPcache') || php_sapi_name() != "cli") die("skip CLI only"); ?>
+--FILE--
+<?php
+require __DIR__ . "/bug76451.inc";
+
+class A {
+  public function test(Foo $foo) {}
+}
+class B extends A {
+  public function test(Bar $foo) {}
+}
+?>
+--EXPECT--

Zend/tests/object_types/object_variance.phpt

@@ -0,0 +1,22 @@
+--TEST--
+Testing object's variance in inheritance
+--FILE--
+<?php
+
+interface I1 {
+  function method1(I1 $o): object;
+}
+interface I2 extends I1 {
+  function method1(object $o): I1;
+}
+final class C1 implements I2 {
+  function method1($o = null): self {
+    return $this;
+  }
+}
+
+$o = new C1();
+echo get_class($o->method1());
+?>
+--EXPECT--
+C1

Zend/tests/return_types/008.phpt

@@ -14,6 +14,7 @@ class qux implements foo {
 }
 
 $qux = new qux();
-var_dump($qux->bar());
---EXPECTF--
-Fatal error: Declaration of qux::bar(): qux must be compatible with foo::bar(): foo in %s008.php on line 7
+echo get_class($qux->bar());
+
+--EXPECT--
+qux

Zend/tests/return_types/generators003.phpt

@@ -15,6 +15,7 @@ class SomeCollection implements Collection {
 }
 
 $some = new SomeCollection();
-var_dump($some->getIterator());
---EXPECTF--
-Fatal error: Declaration of SomeCollection::getIterator(): Generator must be compatible with Collection::getIterator(): Iterator in %sgenerators003.php on line 6
+echo get_class($some->getIterator());
+
+--EXPECT--
+Generator

Zend/tests/return_types/inheritance005.phpt

@@ -13,5 +13,8 @@ class Bar extends Foo {
         return new Bar;
     }
 }
---EXPECTF--
-Fatal error: Declaration of Bar::test(): Bar must be compatible with Foo::test(): Foo in %sinheritance005.php on line 12
+
+echo get_class(Bar::test());
+
+--EXPECT--
+Bar

Zend/tests/return_types/inheritance006.phpt

@@ -17,5 +17,8 @@ class Bar extends Foo {
         return new B;
     }
 }
---EXPECTF--
-Fatal error: Declaration of Bar::test(): B must be compatible with Foo::test(): A in %sinheritance006.php on line 14
+
+echo get_class(Bar::test());
+
+--EXPECT--
+B

Zend/tests/return_types/inheritance007.phpt

@@ -15,5 +15,8 @@ class Bar extends Foo {
         return new ArrayObject([1, 2]);
     }
 }
---EXPECTF--
-Fatal error: Declaration of Bar::test(): ArrayObject must be compatible with Foo::test(): Traversable in %sinheritance007.php on line 12
+
+echo get_class(Bar::test());
+
+--EXPECT--
+ArrayObject

Zend/tests/typehints/undefined_type_during_variance_check_01.phpt

@@ -0,0 +1,15 @@
+--TEST--
+Undefined types during variance checks are warnings
+--FILE--
+<?php
+
+class X {
+  function m(stdClass $z) {}
+}
+
+class Y extends X {
+  function m(UndefinedA $z) {}
+}
+?>
+--EXPECTF--
+Warning: Declaration of Y::m(UndefinedA $z) should be compatible with X::m(stdClass $z) in %s on line %d

Zend/tests/typehints/undefined_type_during_variance_check_02.phpt

@@ -0,0 +1,15 @@
+--TEST--
+Undefined types during variance checks are warnings
+--FILE--
+<?php
+
+abstract class X {
+  function m(stdClass $z) {}
+}
+
+class Y extends X {
+  function m(UndefinedA $z) {}
+}
+?>
+--EXPECTF--
+Warning: Declaration of Y::m(UndefinedA $z) should be compatible with X::m(stdClass $z) in %s on line %d

Zend/tests/typehints/undefined_type_during_variance_check_03.phpt

@@ -0,0 +1,15 @@
+--TEST--
+Undefined types during variance checks are errors
+--FILE--
+<?php
+
+abstract class X {
+  abstract function m(stdClass $z);
+}
+
+class Y extends X {
+  function m(UndefinedA $z) {}
+}
+?>
+--EXPECTF--
+Fatal error: Declaration of Y::m(UndefinedA $z) must be compatible with X::m(stdClass $z) in %s on line %d

Zend/tests/typehints/undefined_type_during_variance_check_04.phpt

@@ -0,0 +1,16 @@
+--TEST--
+Undefined types during variance checks are errors
+--FILE--
+<?php
+
+interface X {
+  function m(stdClass $z);
+}
+
+class Y implements X {
+  function m(UndefinedA $z) {}
+}
+?>
+--EXPECTF--
+Fatal error: Declaration of Y::m(UndefinedA $z) must be compatible with X::m(stdClass $z) in %s on line %d
+

Zend/zend.c

@@ -629,6 +629,8 @@ static void compiler_globals_ctor(zend_compiler_globals *compiler_globals) /* {{
 	zend_hash_init_ex(compiler_globals->class_table, 64, NULL, ZEND_CLASS_DTOR, 1, 0);
 	zend_hash_copy(compiler_globals->class_table, global_class_table, zend_class_add_ref);
 
+	compiler_globals->unverified_types = NULL;
+
 	zend_set_default_compile_time_values();
 
 	compiler_globals->auto_globals = (HashTable *) malloc(sizeof(HashTable));

Zend/zend_compile.c

@@ -3965,6 +3965,26 @@ void zend_compile_static_call(znode *result, zend_ast *ast, uint32_t type) /* {{
 
 zend_op *zend_compile_class_decl(zend_ast *ast, zend_bool toplevel);
 
+static
+void _backup_unverified_variance_types(HashTable *unverified_types,
+                                       HashTable **prev_unverified_types)
+{
+	zend_hash_init(unverified_types, 0, NULL, NULL, 1);
+	*prev_unverified_types = CG(unverified_types);
+	CG(unverified_types) = unverified_types;
+}
+
+static void _compile_verify_variance(HashTable *unverified_types)
+{
+	zend_string *lcname;
+	ZEND_HASH_FOREACH_STR_KEY(unverified_types, lcname) {
+		zend_op *opline = get_next_op();
+		opline->op1_type = IS_CONST;
+		opline->opcode = ZEND_VERIFY_VARIANCE;
+		LITERAL_STR(opline->op1, zend_string_copy(lcname));
+	} ZEND_HASH_FOREACH_END();
+}
+
 void zend_compile_new(znode *result, zend_ast *ast) /* {{{ */
 {
 	zend_ast *class_ast = ast->child[0];
@@ -3974,11 +3994,22 @@ void zend_compile_new(znode *result, zend_ast *ast) /* {{{ */
 	zend_op *opline;
 
 	if (class_ast->kind == ZEND_AST_CLASS) {
+		/* backup previous unverified variance list; anon classes are immediately verified */
+		HashTable unverified_types;
+		HashTable *prev_unverified_types;
+		_backup_unverified_variance_types(&unverified_types, &prev_unverified_types);
+
 		/* jump over anon class declaration */
 		opline = zend_compile_class_decl(class_ast, 0);
 		class_node.op_type = opline->result_type;
 		class_node.u.op.var = opline->result.var;
 		opline->extended_value = get_next_op_number();
+
+		_compile_verify_variance(&unverified_types);
+
+		zend_hash_destroy(&unverified_types);
+		CG(unverified_types) = prev_unverified_types;
+
 	} else {
 		zend_compile_class_ref(&class_node, class_ast, ZEND_FETCH_CLASS_EXCEPTION);
 	}
@@ -6308,6 +6339,14 @@ zend_op *zend_compile_class_decl(zend_ast *ast, zend_bool toplevel) /* {{{ */
 		ce->ce_flags |= ZEND_ACC_TOP_LEVEL;
 	}
 
+	if (extends_ast || implements_ast) {
+		if (CG(unverified_types)) {
+			zend_hash_add_empty_element(CG(unverified_types), lcname);
+		} else {
+			// todo: figure out why it's null; need a caller (somewhere) to initialize, emit, and destroy the unverified types
+		}
+	}
+
 	if (toplevel
 		/* We currently don't early-bind classes that implement interfaces or use traits */
 	 && !(ce->ce_flags & (ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) {
@@ -8139,6 +8178,35 @@ void zend_const_expr_to_zval(zval *result, zend_ast *ast) /* {{{ */
 }
 /* }}} */
 
+static zend_bool _is_type_decl(zend_ast *ast) {
+	return ast && ast->kind == ZEND_AST_CLASS;
+}
+
+static zend_bool _is_not_decl_stmt(zend_ast *ast) {
+	if (ast) {
+		/* todo: what else should be considered a decl stmt? */
+		switch (ast->kind) {
+		case ZEND_AST_FUNC_DECL:
+		case ZEND_AST_CLASS:
+			return 0;
+
+		default:
+			return 1;
+		}
+	}
+
+	/* todo: why are these sometimes null? */
+	return 0;
+}
+
+static zend_ast **_ast_find(zend_ast **begin, zend_ast **end,
+                            zend_bool (*pred)(zend_ast *)) {
+	for (; begin < end; ++begin)
+		if (pred(*begin))
+			return begin;
+	return begin;
+}
+
 /* Same as compile_stmt, but with early binding */
 void zend_compile_top_stmt(zend_ast *ast) /* {{{ */
 {
@@ -8148,9 +8216,37 @@ void zend_compile_top_stmt(zend_ast *ast) /* {{{ */
 
 	if (ast->kind == ZEND_AST_STMT_LIST) {
 		zend_ast_list *list = zend_ast_get_list(ast);
-		uint32_t i;
-		for (i = 0; i < list->children; ++i) {
-			zend_compile_top_stmt(list->child[i]);
+		zend_ast **begin = list->child;
+		zend_ast **end = begin + list->children;
+		zend_ast **first_decl = _ast_find(begin, end, &_is_type_decl);
+		zend_ast **last_decl = _ast_find(first_decl, end, &_is_not_decl_stmt);
+		zend_ast **p;
+
+		/* Compile opcodes before first type decl */
+		for (p = begin; p < first_decl; ++p) {
+			zend_compile_top_stmt(*p);
+		}
+
+		/* Compile decl stmts */
+		{
+			HashTable unverified_types;
+			HashTable *prev_unverified_types;
+			_backup_unverified_variance_types(&unverified_types, &prev_unverified_types);
+
+			for (p = first_decl; p < last_decl; ++p) {
+				zend_compile_top_stmt(*p);
+			}
+
+			_compile_verify_variance(&unverified_types);
+
+			zend_hash_destroy(&unverified_types);
+			CG(unverified_types) = prev_unverified_types;
+		}
+
+		/* Compile remainder */
+		/* todo: loop to catch any non-consecutive type declarations */
+		for (p = last_decl; p < end; ++p) {
+			zend_compile_top_stmt(*p);
 		}
 		return;
 	}

Zend/zend_globals.h

@@ -67,6 +67,7 @@ struct _zend_compiler_globals {
 	zend_stack loop_var_stack;
 
 	zend_class_entry *active_class_entry;
+	HashTable *unverified_types;
 
 	zend_string *compiled_filename;