Support intersecting object shapes in TypeCombinator

- Added ObjectShapeType merging logic in TypeCombinator::intersect() so that
  two object shapes can be intersected by combining their properties
- Properties present in both shapes have their types intersected; if the
  intersection is never, the whole result is never
- A property is optional in the result only if it is optional in both shapes
- Updated TypeCombinatorTest expectations and baseline for new instanceof count
- New regression test in tests/PHPStan/Analyser/nsrt/bug-13227.php

Author: VincentLanglet

phpstan-baseline.neon

@@ -1728,7 +1728,7 @@ parameters:
 		-
 			rawMessage: 'Doing instanceof PHPStan\Type\ObjectShapeType is error-prone and deprecated. Use Type::isObject() and Type::hasProperty() instead.'
 			identifier: phpstanApi.instanceofType
-			count: 2
+			count: 4
 			path: src/Type/TypeCombinator.php
 
 		-

src/Type/TypeCombinator.php

@@ -26,6 +26,7 @@
 use PHPStan\Type\Generic\TemplateType;
 use PHPStan\Type\Generic\TemplateTypeFactory;
 use PHPStan\Type\Generic\TemplateUnionType;
+use function array_filter;
 use function array_key_exists;
 use function array_key_first;
 use function array_merge;
@@ -36,6 +37,7 @@
 use function get_class;
 use function in_array;
 use function is_int;
+use function ksort;
 use function sprintf;
 use function usort;
 use const PHP_INT_MAX;
@@ -1300,6 +1302,38 @@ public static function intersect(Type ...$types): Type
 					}
 				}
 
+				if ($types[$i] instanceof ObjectShapeType && $types[$j] instanceof ObjectShapeType) {
+					$mergedProperties = $types[$i]->getProperties();
+					$mergedOptionalProperties = $types[$i]->getOptionalProperties();
+					foreach ($types[$j]->getProperties() as $propertyName => $propertyType) {
+						if (array_key_exists($propertyName, $mergedProperties)) {
+							$intersectedPropertyType = self::intersect($mergedProperties[$propertyName], $propertyType);
+							if ($intersectedPropertyType instanceof NeverType) {
+								return new NeverType();
+							}
+							$mergedProperties[$propertyName] = $intersectedPropertyType;
+							$isOptionalInI = in_array($propertyName, $mergedOptionalProperties, true);
+							$isOptionalInJ = in_array($propertyName, $types[$j]->getOptionalProperties(), true);
+							if ($isOptionalInI && !$isOptionalInJ) {
+								$mergedOptionalProperties = array_values(array_filter(
+									$mergedOptionalProperties,
+									static fn ($p) => $p !== $propertyName,
+								));
+							}
+						} else {
+							$mergedProperties[$propertyName] = $propertyType;
+							if (in_array($propertyName, $types[$j]->getOptionalProperties(), true)) {
+								$mergedOptionalProperties[] = $propertyName;
+							}
+						}
+					}
+					ksort($mergedProperties);
+					$types[$i] = new ObjectShapeType($mergedProperties, $mergedOptionalProperties);
+					array_splice($types, $j--, 1);
+					$typesCount--;
+					continue;
+				}
+
 				if ($types[$j] instanceof IterableType) {
 					$isSuperTypeA = $types[$j]->isSuperTypeOfMixed($types[$i]);
 				} else {

tests/PHPStan/Analyser/nsrt/bug-13227.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Bug13227;
+
+use function PHPStan\Testing\assertType;
+
+/**
+ * @phpstan-type Type1 object{ a: int }
+ * @phpstan-type Type2 Type1 & object{ b: int }
+ * @phpstan-type Type3 object{ a: int, b?: string } & object{ b: string, c?: int }
+ */
+class Foo
+{
+	/**
+	 * @param Type2 $x
+	 */
+	public function doFoo($x): void
+	{
+		assertType('object{a: int, b: int}', $x);
+	}
+
+	/**
+	 * @param Type3 $y
+	 */
+	public function doBar($y): void
+	{
+		assertType('object{a: int, b: string, c?: int}', $y);
+	}
+}

tests/PHPStan/Type/TypeCombinatorTest.php

@@ -4512,8 +4512,8 @@ public static function dataIntersect(): iterable
 				new ObjectShapeType(['foo' => new IntegerType()], []),
 				new ObjectShapeType(['bar' => new StringType()], []),
 			],
-			NeverType::class,
-			'*NEVER*=implicit',
+			ObjectShapeType::class,
+			'object{bar: string, foo: int}',
 		];
 		yield [
 			[