Address reviews

Author: Girgias

build/gen_stub.php

@@ -548,31 +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);
-        }
-        if ($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, true);
+            return new Type($types, ($node instanceof Node\IntersectionType));
         }
 
         if ($node instanceof Node\NullableType) {
             return new Type(
                 [
                     ...Type::fromNode($node->type)->types,
                     SimpleType::null(),
-                ]
+                ],
+                false
             );
         }
 
@@ -581,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++) {
@@ -612,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);
@@ -621,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, public readonly bool $isIntersection = false) {
+    private function __construct(array $types, bool $isIntersection) {
         $this->types = $types;
+        $this->isIntersection = $isIntersection;
     }
 
     public function isScalar(): bool {
@@ -658,7 +657,8 @@ public function getWithoutNull(): Type {
                 function(SimpleType $type) {
                     return !$type->isNull();
                 }
-            )
+            ),
+            false
         );
     }
 
@@ -691,6 +691,7 @@ public function toOptimizerTypeMask(): string {
         $optimizerTypes = [];
 
         foreach ($this->types as $type) {
+            // TODO Support for toOptimizerMask for intersection
             $optimizerTypes[] = $type->toOptimizerTypeMask();
         }
 
@@ -719,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);
@@ -763,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)
         );