Use X&Y|null instead of ?X&Y

nicolas-grekas · nicolas-grekas · commit 5bc99467b8df · 2021-07-20T10:20:21.000+02:00
diff --git a/Zend/tests/type_declarations/intersection_types/assigning_intersection_types.phpt b/Zend/tests/type_declarations/intersection_types/assigning_intersection_types.phpt
@@ -20,7 +20,7 @@ class A {
     public function method2(X $a): X&Y {
         return new TestParent();
     }
-    public function method3(?X&Y $a): ?X&Y {
+    public function method3(X&Y|null $a): X&Y|null {
         return $a;
     }
 }
diff --git a/Zend/tests/type_declarations/intersection_types/bug81268.phpt b/Zend/tests/type_declarations/intersection_types/bug81268.phpt
@@ -9,4 +9,4 @@ class Test {
 
 ?>
 --EXPECTF--
-Fatal error: Default value for property of type X&Y may not be null. Use the nullable type ?X&Y to allow null default value in %s on line %d
+Fatal error: Default value for property of type X&Y may not be null. Use the nullable type X&Y|null to allow null default value in %s on line %d
diff --git a/Zend/tests/type_declarations/intersection_types/parameter.phpt b/Zend/tests/type_declarations/intersection_types/parameter.phpt
@@ -9,7 +9,7 @@ interface B {}
 class Foo implements A, B {}
 class Bar implements A {}
 
-function foo(?A&B $bar) {
+function foo(A&B|null $bar) {
     var_dump($bar);
 }
 
@@ -27,4 +27,4 @@ try {
 NULL
 object(Foo)#1 (0) {
 }
-foo(): Argument #1 ($bar) must be of type ?A&B, Bar given, called in %s on line %d
+foo(): Argument #1 ($bar) must be of type A&B|null, Bar given, called in %s on line %d
diff --git a/Zend/tests/type_declarations/intersection_types/typed_reference2.phpt b/Zend/tests/type_declarations/intersection_types/typed_reference2.phpt
@@ -11,7 +11,7 @@ class A implements X, Y, Z {}
 class B implements X, Y {}
 
 class Test {
-    public ?X&Y $y;
+    public X&Y|null $y;
     public X&Z $z;
 }
 $test = new Test;
diff --git a/Zend/tests/type_declarations/intersection_types/typed_reference3.phpt b/Zend/tests/type_declarations/intersection_types/typed_reference3.phpt
@@ -11,8 +11,8 @@ class A implements X, Y, Z {}
 class B implements X, Y {}
 
 class Test {
-    public ?X&Y $y;
-    public ?X&Z $z;
+    public X&Y|null $y;
+    public X&Z|null $z;
 }
 $test = new Test;
 $r = new A;
diff --git a/Zend/tests/type_declarations/intersection_types/variance/invalid7.phpt b/Zend/tests/type_declarations/intersection_types/variance/invalid7.phpt
@@ -22,11 +22,11 @@ class FooChild extends Foo {
 }
 
 class FooSecondChild extends FooChild {
-    public function foo(): ?A&B {
+    public function foo(): A&B|null {
         return new Test();
     }
 }
 
 ?>
 --EXPECTF--
-Fatal error: Declaration of FooSecondChild::foo(): ?A&B must be compatible with FooChild::foo(): A&B in %s on line %d
+Fatal error: Declaration of FooSecondChild::foo(): A&B|null must be compatible with FooChild::foo(): A&B in %s on line %d
diff --git a/Zend/tests/type_declarations/intersection_types/variance/invalid8.phpt b/Zend/tests/type_declarations/intersection_types/variance/invalid8.phpt
@@ -7,12 +7,12 @@ class A {}
 class B extends A {}
 
 class Test {
-    public ?A&B $prop;
+    public A&B|null $prop;
 }
 class Test2 extends Test {
     public A&B $prop;
 }
 
 ?>
 --EXPECTF--
-Fatal error: Type of Test2::$prop must be ?A&B (as in class Test) in %s on line %d
+Fatal error: Type of Test2::$prop must be A&B|null (as in class Test) in %s on line %d
diff --git a/Zend/tests/type_declarations/intersection_types/variance/invalid9.phpt b/Zend/tests/type_declarations/intersection_types/variance/invalid9.phpt
@@ -7,7 +7,7 @@ interface A {}
 interface B {}
 
 class Foo {
-    public function foo(?A&B $foo) {
+    public function foo(A&B|null $foo) {
     }
 }
 
@@ -18,4 +18,4 @@ class FooChild extends Foo {
 
 ?>
 --EXPECTF--
-Fatal error: Declaration of FooChild::foo(A&B $foo) must be compatible with Foo::foo(?A&B $foo) in %s on line %d
+Fatal error: Declaration of FooChild::foo(A&B $foo) must be compatible with Foo::foo(A&B|null $foo) in %s on line %d
diff --git a/Zend/tests/type_declarations/intersection_types/variance/valid10.phpt b/Zend/tests/type_declarations/intersection_types/variance/valid10.phpt
@@ -11,15 +11,15 @@ class TestParent implements X, Y, Z {}
 class TestChild implements Z {}
 
 class A {
-    public ?X&Y $prop;
+    public X&Y|null $prop;
 
-    public function method1(X&Y&Z $a): ?X&Y {}
+    public function method1(X&Y&Z $a): X&Y|null{}
     public function method2(X&Y $a): ?X {}
 }
 class B extends A {
-    public ?X&Y $prop;
+    public X&Y|null $prop;
 
-    public function method1(?X&Y $a): X&Y&Z {}
+    public function method1(X&Y|null $a): X&Y&Z {}
     public function method2(?X $a): X&Y {}
 }
 
diff --git a/Zend/tests/type_declarations/intersection_types/variance/valid9.phpt b/Zend/tests/type_declarations/intersection_types/variance/valid9.phpt
@@ -10,7 +10,7 @@ interface C {}
 class Test implements A, B, C {}
 
 class Foo {
-    public function foo(): ?A&B {
+    public function foo(): A&B|null {
         return null;
     }
 }
diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c
@@ -1535,9 +1535,6 @@ static ZEND_COLD void zend_ast_export_type(smart_str *str, zend_ast *ast, int in
 		}
 		return;
 	}
-	if (ast->attr & ZEND_TYPE_NULLABLE) {
-		smart_str_appendc(str, '?');
-	}
 	if (ast->kind == ZEND_AST_TYPE_INTERSECTION) {
 		zend_ast_list *list = zend_ast_get_list(ast);
 		for (uint32_t i = 0; i < list->children; i++) {
@@ -1546,8 +1543,14 @@ static ZEND_COLD void zend_ast_export_type(smart_str *str, zend_ast *ast, int in
 			}
 			zend_ast_export_type(str, list->child[i], indent);
 		}
+		if (ast->attr & ZEND_TYPE_NULLABLE) {
+			smart_str_appends(str, "|null");
+		}
 		return;
 	}
+	if (ast->attr & ZEND_TYPE_NULLABLE) {
+		smart_str_appendc(str, '?');
+	}
 	zend_ast_export_ns_name(str, ast, 0, indent);
 }
 
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
@@ -1284,7 +1284,7 @@ zend_string *zend_type_to_string_resolved(zend_type type, zend_class_entry *scop
 
 	if (type_mask & MAY_BE_NULL) {
 		bool is_union = !str || memchr(ZSTR_VAL(str), '|', ZSTR_LEN(str)) != NULL;
-		if (!is_union) {
+		if (!is_union && !ZEND_TYPE_IS_INTERSECTION(type)) {
 			zend_string *nullable_str = zend_string_concat2("?", 1, ZSTR_VAL(str), ZSTR_LEN(str));
 			zend_string_release(str);
 			return nullable_str;
diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
@@ -287,6 +287,8 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 
 %type <ident> reserved_non_modifiers semi_reserved
 
+%type <void> null_type
+
 %% /* Rules */
 
 start:
@@ -793,12 +795,22 @@ optional_type_without_static:
 	|	type_expr_without_static	{ $$ = $1; }
 ;
 
+null_type:
+		T_STRING {
+			zend_string *str = Z_STR(((zend_ast_zval*)$1)->val);
+			if (!zend_string_equals_literal_ci(str, "null")) {
+				zend_error(E_PARSE, "Invalid compound type expression");
+			}
+			zend_string_free(str);
+		}
+;
+
 type_expr:
 		type				{ $$ = $1; }
 	|	'?' type			{ $$ = $2; $$->attr |= ZEND_TYPE_NULLABLE; }
 	|	union_type			{ $$ = $1; }
+	|	intersection_type '|' null_type	{ $$ = $1; $$->attr |= ZEND_TYPE_NULLABLE; }
 	|	intersection_type	{ $$ = $1; }
-	|	'?' intersection_type	{ $$ = $2; $$->attr |= ZEND_TYPE_NULLABLE; }
 ;
 
 type:
@@ -823,8 +835,8 @@ type_expr_without_static:
 		type_without_static			{ $$ = $1; }
 	|	'?' type_without_static		{ $$ = $2; $$->attr |= ZEND_TYPE_NULLABLE; }
 	|	union_type_without_static	{ $$ = $1; }
+	|	intersection_type_without_static '|' null_type	{ $$ = $1; $$->attr |= ZEND_TYPE_NULLABLE; }
 	|	intersection_type_without_static	{ $$ = $1; }
-	|	'?' intersection_type_without_static	{ $$ = $2; $$->attr |= ZEND_TYPE_NULLABLE; }
 ;
 
 type_without_static:

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ class A {`
`20`	`20`	`public function method2(X $a): X&Y {`
`21`	`21`	`return new TestParent();`
`22`	`22`	`}`
`23`		`- public function method3(?X&Y $a): ?X&Y {`
	`23`	`+ public function method3(X&Y\|null $a): X&Y\|null {`
`24`	`24`	`return $a;`
`25`	`25`	`}`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ interface B {}`
`9`	`9`	`class Foo implements A, B {}`
`10`	`10`	`class Bar implements A {}`
`11`	`11`
`12`		`-function foo(?A&B $bar) {`
	`12`	`+function foo(A&B\|null $bar) {`
`13`	`13`	`var_dump($bar);`
`14`	`14`	`}`
`15`	`15`
`@@ -27,4 +27,4 @@ try {`
`27`	`27`	`NULL`
`28`	`28`	`object(Foo)#1 (0) {`
`29`	`29`	`}`
`30`		`-foo(): Argument #1 ($bar) must be of type ?A&B, Bar given, called in %s on line %d`
	`30`	`+foo(): Argument #1 ($bar) must be of type A&B\|null, Bar given, called in %s on line %d`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ class A implements X, Y, Z {}`
`11`	`11`	`class B implements X, Y {}`
`12`	`12`
`13`	`13`	`class Test {`
`14`		`- public ?X&Y $y;`
	`14`	`+ public X&Y\|null $y;`
`15`	`15`	`public X&Z $z;`
`16`	`16`	`}`
`17`	`17`	`$test = new Test;`
Original file line number	Diff line number	Diff line change
`@@ -22,11 +22,11 @@ class FooChild extends Foo {`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`class FooSecondChild extends FooChild {`
`25`		`- public function foo(): ?A&B {`
	`25`	`+ public function foo(): A&B\|null {`
`26`	`26`	`return new Test();`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`?>`
`31`	`31`	`--EXPECTF--`
`32`		`-Fatal error: Declaration of FooSecondChild::foo(): ?A&B must be compatible with FooChild::foo(): A&B in %s on line %d`
	`32`	`+Fatal error: Declaration of FooSecondChild::foo(): A&B\|null must be compatible with FooChild::foo(): A&B in %s on line %d`
Original file line number	Diff line number	Diff line change
`@@ -7,12 +7,12 @@ class A {}`
`7`	`7`	`class B extends A {}`
`8`	`8`
`9`	`9`	`class Test {`
`10`		`- public ?A&B $prop;`
	`10`	`+ public A&B\|null $prop;`
`11`	`11`	`}`
`12`	`12`	`class Test2 extends Test {`
`13`	`13`	`public A&B $prop;`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`?>`
`17`	`17`	`--EXPECTF--`
`18`		`-Fatal error: Type of Test2::$prop must be ?A&B (as in class Test) in %s on line %d`
	`18`	`+Fatal error: Type of Test2::$prop must be A&B\|null (as in class Test) in %s on line %d`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ interface A {}`
`7`	`7`	`interface B {}`
`8`	`8`
`9`	`9`	`class Foo {`
`10`		`- public function foo(?A&B $foo) {`
	`10`	`+ public function foo(A&B\|null $foo) {`
`11`	`11`	`}`
`12`	`12`	`}`
`13`	`13`
`@@ -18,4 +18,4 @@ class FooChild extends Foo {`
`18`	`18`
`19`	`19`	`?>`
`20`	`20`	`--EXPECTF--`
`21`		`-Fatal error: Declaration of FooChild::foo(A&B $foo) must be compatible with Foo::foo(?A&B $foo) in %s on line %d`
	`21`	`+Fatal error: Declaration of FooChild::foo(A&B $foo) must be compatible with Foo::foo(A&B\|null $foo) in %s on line %d`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ interface C {}`
`10`	`10`	`class Test implements A, B, C {}`
`11`	`11`
`12`	`12`	`class Foo {`
`13`		`- public function foo(): ?A&B {`
	`13`	`+ public function foo(): A&B\|null {`
`14`	`14`	`return null;`
`15`	`15`	`}`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1535,9 +1535,6 @@ static ZEND_COLD void zend_ast_export_type(smart_str str, zend_ast ast, int in`
`1535`	`1535`	`}`
`1536`	`1536`	`return;`
`1537`	`1537`	`}`
`1538`		`- if (ast->attr & ZEND_TYPE_NULLABLE) {`
`1539`		`- smart_str_appendc(str, '?');`
`1540`		`- }`
`1541`	`1538`	`if (ast->kind == ZEND_AST_TYPE_INTERSECTION) {`
`1542`	`1539`	`zend_ast_list *list = zend_ast_get_list(ast);`
`1543`	`1540`	`for (uint32_t i = 0; i < list->children; i++) {`
`@@ -1546,8 +1543,14 @@ static ZEND_COLD void zend_ast_export_type(smart_str str, zend_ast ast, int in`
`1546`	`1543`	`}`
`1547`	`1544`	`zend_ast_export_type(str, list->child[i], indent);`
`1548`	`1545`	`}`
	`1546`	`+ if (ast->attr & ZEND_TYPE_NULLABLE) {`
	`1547`	`+ smart_str_appends(str, "\|null");`
	`1548`	`+ }`
`1549`	`1549`	`return;`
`1550`	`1550`	`}`
	`1551`	`+ if (ast->attr & ZEND_TYPE_NULLABLE) {`
	`1552`	`+ smart_str_appendc(str, '?');`
	`1553`	`+ }`
`1551`	`1554`	`zend_ast_export_ns_name(str, ast, 0, indent);`
`1552`	`1555`	`}`
`1553`	`1556`