Add support for stubs to declare intersection type class properties (#8751)

Author: Girgias

Zend/tests/type_declarations/typed_properties_095.phpt

@@ -2,6 +2,7 @@
 Typed properties in internal classes
 --EXTENSIONS--
 zend_test
+spl
 --FILE--
 <?php
 
@@ -70,6 +71,8 @@ object(_ZendTestClass)#1 (3) {
   }
   ["classUnionProp"]=>
   NULL
+  ["classIntersectionProp"]=>
+  uninitialized(Traversable&Countable)
   ["readonlyProp"]=>
   uninitialized(int)
 }
@@ -84,6 +87,8 @@ object(Test)#4 (3) {
   }
   ["classUnionProp"]=>
   NULL
+  ["classIntersectionProp"]=>
+  uninitialized(Traversable&Countable)
   ["readonlyProp"]=>
   uninitialized(int)
 }

Zend/zend_types.h

@@ -280,6 +280,9 @@ typedef struct {
 #define ZEND_TYPE_INIT_UNION(ptr, extra_flags) \
 	{ (void *) (ptr), (_ZEND_TYPE_LIST_BIT|_ZEND_TYPE_UNION_BIT) | (extra_flags) }
 
+#define ZEND_TYPE_INIT_INTERSECTION(ptr, extra_flags) \
+	{ (void *) (ptr), (_ZEND_TYPE_LIST_BIT|_ZEND_TYPE_INTERSECTION_BIT) | (extra_flags) }
+
 #define ZEND_TYPE_INIT_CLASS(class_name, allow_null, extra_flags) \
 	ZEND_TYPE_INIT_PTR(class_name, _ZEND_TYPE_NAME_BIT, allow_null, extra_flags)
 

build/gen_stub.php

@@ -548,23 +548,26 @@ public function equals(SimpleType $other): bool {
 class Type {
     /** @var SimpleType[] */
     public $types;
+    /** @var bool */
+    public $isIntersection = false;
 
     public static function fromNode(Node $node): Type {
-        if ($node instanceof Node\UnionType) {
+        if ($node instanceof Node\UnionType || $node instanceof Node\IntersectionType) {
             $nestedTypeObjects = array_map(['Type', 'fromNode'], $node->types);
             $types = [];
             foreach ($nestedTypeObjects as $typeObject) {
                 array_push($types, ...$typeObject->types);
             }
-            return new Type($types);
+            return new Type($types, ($node instanceof Node\IntersectionType));
         }
 
         if ($node instanceof Node\NullableType) {
             return new Type(
                 [
                     ...Type::fromNode($node->type)->types,
                     SimpleType::null(),
-                ]
+                ],
+                false
             );
         }
 
@@ -573,18 +576,20 @@ public static function fromNode(Node $node): Type {
                 [
                     SimpleType::fromString("Traversable"),
                     ArrayType::createGenericArray(),
-                ]
+                ],
+                false
             );
         }
 
-        return new Type([SimpleType::fromNode($node)]);
+        return new Type([SimpleType::fromNode($node)], false);
     }
 
     public static function fromString(string $typeString): self {
         $typeString .= "|";
         $simpleTypes = [];
         $simpleTypeOffset = 0;
         $inArray = false;
+        $isIntersection = false;
 
         $typeStringLength = strlen($typeString);
         for ($i = 0; $i < $typeStringLength; $i++) {
@@ -604,7 +609,8 @@ public static function fromString(string $typeString): self {
                 continue;
             }
 
-            if ($char === "|") {
+            if ($char === "|" || $char === "&") {
+                $isIntersection = ($char === "&");
                 $simpleTypeName = trim(substr($typeString, $simpleTypeOffset, $i - $simpleTypeOffset));
 
                 $simpleTypes[] = SimpleType::fromString($simpleTypeName);
@@ -613,14 +619,15 @@ public static function fromString(string $typeString): self {
             }
         }
 
-        return new Type($simpleTypes);
+        return new Type($simpleTypes, $isIntersection);
     }
 
     /**
      * @param SimpleType[] $types
      */
-    private function __construct(array $types) {
+    private function __construct(array $types, bool $isIntersection) {
         $this->types = $types;
+        $this->isIntersection = $isIntersection;
     }
 
     public function isScalar(): bool {
@@ -650,7 +657,8 @@ public function getWithoutNull(): Type {
                 function(SimpleType $type) {
                     return !$type->isNull();
                 }
-            )
+            ),
+            false
         );
     }
 
@@ -683,6 +691,7 @@ public function toOptimizerTypeMask(): string {
         $optimizerTypes = [];
 
         foreach ($this->types as $type) {
+            // TODO Support for toOptimizerMask for intersection
             $optimizerTypes[] = $type->toOptimizerTypeMask();
         }
 
@@ -711,8 +720,9 @@ public function toOptimizerTypeMaskForArrayValue(): string {
 
     public function getTypeForDoc(DOMDocument $doc): DOMElement {
         if (count($this->types) > 1) {
+            $typeSort = $this->isIntersection ? "intersection" : "union";
             $typeElement = $doc->createElement('type');
-            $typeElement->setAttribute("class", "union");
+            $typeElement->setAttribute("class", $typeSort);
 
             foreach ($this->types as $type) {
                 $unionTypeElement = $doc->createElement('type', $type->name);
@@ -755,7 +765,8 @@ public function __toString() {
             return 'mixed';
         }
 
-        return implode('|', array_map(
+        $char = $this->isIntersection ? '&' : '|';
+        return implode($char, array_map(
             function ($type) { return $type->name; },
             $this->types)
         );
@@ -2237,7 +2248,11 @@ public function getDeclaration(iterable $allConstInfos): string {
 
                     $typeMaskCode = $this->type->toArginfoType()->toTypeMask();
 
-                    $code .= "\tzend_type property_{$propertyName}_type = ZEND_TYPE_INIT_UNION(property_{$propertyName}_type_list, $typeMaskCode);\n";
+                    if ($this->type->isIntersection) {
+                        $code .= "\tzend_type property_{$propertyName}_type = ZEND_TYPE_INIT_INTERSECTION(property_{$propertyName}_type_list, $typeMaskCode);\n";
+                    } else {
+                        $code .= "\tzend_type property_{$propertyName}_type = ZEND_TYPE_INIT_UNION(property_{$propertyName}_type_list, $typeMaskCode);\n";
+                    }
                     $typeCode = "property_{$propertyName}_type";
                 } else {
                     $escapedClassName = $arginfoType->classTypes[0]->toEscapedName();

ext/zend_test/test.stub.php

@@ -21,6 +21,7 @@ class _ZendTestClass implements _ZendTestInterface {
         public int $intProp = 123;
         public ?stdClass $classProp = null;
         public stdClass|Iterator|null $classUnionProp = null;
+        public Traversable&Countable $classIntersectionProp;
         public readonly int $readonlyProp;
 
         public static function is_object(): int {}

ext/zend_test/test_arginfo.h

@@ -0,0 +1,46 @@
+--TEST--
+Test that internal classes can register intersection types
+--EXTENSIONS--
+zend_test
+spl
+--FILE--
+<?php
+
+class C implements Countable {
+    public function count(): int {
+        return 1;
+    }
+}
+
+class I extends EmptyIterator implements Countable {
+    public function count(): int {
+        return 1;
+    }
+}
+
+$o = new _ZendTestClass();
+
+try {
+    var_dump($o->classIntersectionProp);
+} catch (Error $e) {
+    echo $e::class, ': ', $e->getMessage(), PHP_EOL;
+}
+try {
+    $o->classIntersectionProp = new EmptyIterator();
+} catch (TypeError $e) {
+    echo $e->getMessage(), PHP_EOL;
+}
+try {
+    $o->classIntersectionProp = new C();
+} catch (TypeError $e) {
+    echo $e->getMessage(), PHP_EOL;
+}
+$o->classIntersectionProp = new I();
+
+?>
+==DONE==
+--EXPECT--
+Error: Typed property _ZendTestClass::$classIntersectionProp must not be accessed before initialization
+Cannot assign EmptyIterator to property _ZendTestClass::$classIntersectionProp of type Traversable&Countable
+Cannot assign C to property _ZendTestClass::$classIntersectionProp of type Traversable&Countable
+==DONE==