Difference between Instance and Static properties

src/Analyser/MutatingScope.php

@@ -4370,7 +4370,7 @@ public function assignInitializedProperty(Type $fetchedOnType, string $propertyN
 			return $this;
 		}
 
-		$propertyReflection = $this->getPropertyReflection($fetchedOnType, $propertyName);
+		$propertyReflection = $this->getInstancePropertyReflection($fetchedOnType, $propertyName);
 		if ($propertyReflection === null) {
 			return $this;
 		}
@@ -6204,7 +6204,10 @@ private function methodCallReturnType(Type $typeWithMethod, string $methodName,
 		return $this->transformVoidToNull($parametersAcceptor->getReturnType(), $methodCall);
 	}
 
-	/** @api */
+	/**
+	 * @api
+	 * @deprecated Use getInstancePropertyReflection or getStaticPropertyReflection instead
+	 */
 	public function getPropertyReflection(Type $typeWithProperty, string $propertyName): ?ExtendedPropertyReflection
 	{
 		if ($typeWithProperty instanceof UnionType) {
@@ -6217,12 +6220,43 @@ public function getPropertyReflection(Type $typeWithProperty, string $propertyNa
 		return $typeWithProperty->getProperty($propertyName, $this);
 	}
 
+	/** @api */
+	public function getInstancePropertyReflection(Type $typeWithProperty, string $propertyName): ?ExtendedPropertyReflection
+	{
+		if ($typeWithProperty instanceof UnionType) {
+			$typeWithProperty = $typeWithProperty->filterTypes(static fn (Type $innerType) => $innerType->hasInstanceProperty($propertyName)->yes());
+		}
+		if (!$typeWithProperty->hasInstanceProperty($propertyName)->yes()) {
+			return null;
+		}
+
+		return $typeWithProperty->getInstanceProperty($propertyName, $this);
+	}
+
+	/** @api */
+	public function getStaticPropertyReflection(Type $typeWithProperty, string $propertyName): ?ExtendedPropertyReflection
+	{
+		if ($typeWithProperty instanceof UnionType) {
+			$typeWithProperty = $typeWithProperty->filterTypes(static fn (Type $innerType) => $innerType->hasStaticProperty($propertyName)->yes());
+		}
+		if (!$typeWithProperty->hasStaticProperty($propertyName)->yes()) {
+			return null;
+		}
+
+		return $typeWithProperty->getStaticProperty($propertyName, $this);
+	}
+
 	/**
 	 * @param PropertyFetch|Node\Expr\StaticPropertyFetch $propertyFetch
 	 */
 	private function propertyFetchType(Type $fetchedOnType, string $propertyName, Expr $propertyFetch): ?Type
 	{
-		$propertyReflection = $this->getPropertyReflection($fetchedOnType, $propertyName);
+		if ($propertyFetch instanceof PropertyFetch) {
+			$propertyReflection = $this->getInstancePropertyReflection($fetchedOnType, $propertyName);
+		} else {
+			$propertyReflection = $this->getStaticPropertyReflection($fetchedOnType, $propertyName);
+		}
+
 		if ($propertyReflection === null) {
 			return null;
 		}

src/Analyser/NodeScopeResolver.php

@@ -3216,7 +3216,7 @@ static function (Node $node, Scope $scope) use ($nodeCallback): void {
 			} else {
 				$propertyName = $expr->name->toString();
 				$propertyHolderType = $scopeBeforeVar->getType($expr->var);
-				$propertyReflection = $scopeBeforeVar->getPropertyReflection($propertyHolderType, $propertyName);
+				$propertyReflection = $scopeBeforeVar->getInstancePropertyReflection($propertyHolderType, $propertyName);
 				if ($propertyReflection !== null && $this->phpVersion->supportsPropertyHooks()) {
 					$propertyDeclaringClass = $propertyReflection->getDeclaringClass();
 					if ($propertyDeclaringClass->hasNativeProperty($propertyName)) {
@@ -5898,8 +5898,8 @@ static function (): void {
 			}
 
 			$propertyHolderType = $scope->getType($var->var);
-			if ($propertyName !== null && $propertyHolderType->hasProperty($propertyName)->yes()) {
-				$propertyReflection = $propertyHolderType->getProperty($propertyName, $scope);
+			if ($propertyName !== null && $propertyHolderType->hasInstanceProperty($propertyName)->yes()) {
+				$propertyReflection = $propertyHolderType->getInstanceProperty($propertyName, $scope);
 				$assignedExprType = $scope->getType($assignedExpr);
 				$nodeCallback(new PropertyAssignNode($var, $assignedExpr, $isAssignOp), $scopeBeforeAssignEval);
 				if ($propertyReflection->canChangeTypeAfterAssignment()) {
@@ -5991,7 +5991,7 @@ static function (): void {
 			$scope = $result->getScope();
 
 			if ($propertyName !== null) {
-				$propertyReflection = $scope->getPropertyReflection($propertyHolderType, $propertyName);
+				$propertyReflection = $scope->getStaticPropertyReflection($propertyHolderType, $propertyName);
 				$assignedExprType = $scope->getType($assignedExpr);
 				$nodeCallback(new PropertyAssignNode($var, $assignedExpr, $isAssignOp), $scopeBeforeAssignEval);
 				if ($propertyReflection !== null && $propertyReflection->canChangeTypeAfterAssignment()) {

src/Analyser/Scope.php

@@ -75,8 +75,13 @@ public function getMaybeDefinedVariables(): array;
 
 	public function hasConstant(Name $name): bool;
 
+	/** @deprecated Use getInstancePropertyReflection or getStaticPropertyReflection instead */
 	public function getPropertyReflection(Type $typeWithProperty, string $propertyName): ?ExtendedPropertyReflection;
 
+	public function getInstancePropertyReflection(Type $typeWithProperty, string $propertyName): ?ExtendedPropertyReflection;
+
+	public function getStaticPropertyReflection(Type $typeWithProperty, string $propertyName): ?ExtendedPropertyReflection;
+
 	public function getMethodReflection(Type $typeWithMethod, string $methodName): ?ExtendedMethodReflection;
 
 	public function getConstantReflection(Type $typeWithConstant, string $constantName): ?ClassConstantReflection;

src/Dependency/DependencyResolver.php

@@ -261,7 +261,7 @@ public function resolveDependencies(Node $node, Scope $scope): NodeDependencies
 			}
 
 			if ($node->name instanceof Node\Identifier) {
-				$propertyReflection = $scope->getPropertyReflection($fetchedOnType, $node->name->toString());
+				$propertyReflection = $scope->getInstancePropertyReflection($fetchedOnType, $node->name->toString());
 				if ($propertyReflection !== null) {
 					$this->addClassToDependencies($propertyReflection->getDeclaringClass()->getName(), $dependenciesReflections);
 				}
@@ -377,13 +377,13 @@ public function resolveDependencies(Node $node, Scope $scope): NodeDependencies
 					$className = $scope->resolveName($node->class);
 					if ($this->reflectionProvider->hasClass($className)) {
 						$propertyClassReflection = $this->reflectionProvider->getClass($className);
-						if ($propertyClassReflection->hasProperty($node->name->toString())) {
-							$propertyReflection = $propertyClassReflection->getProperty($node->name->toString(), $scope);
+						if ($propertyClassReflection->hasStaticProperty($node->name->toString())) {
+							$propertyReflection = $propertyClassReflection->getStaticProperty($node->name->toString());
 							$this->addClassToDependencies($propertyReflection->getDeclaringClass()->getName(), $dependenciesReflections);
 						}
 					}
 				} else {
-					$propertyReflection = $scope->getPropertyReflection($scope->getType($node->class), $node->name->toString());
+					$propertyReflection = $scope->getStaticPropertyReflection($scope->getType($node->class), $node->name->toString());
 					if ($propertyReflection !== null) {
 						$this->addClassToDependencies($propertyReflection->getDeclaringClass()->getName(), $dependenciesReflections);
 					}

src/Node/ClassPropertiesNode.php

@@ -201,7 +201,7 @@ public function getUninitializedProperties(
 				continue;
 			}
 
-			$propertyReflection = $usageScope->getPropertyReflection($fetchedOnType, $propertyName);
+			$propertyReflection = $usageScope->getInstancePropertyReflection($fetchedOnType, $propertyName);
 			if ($propertyReflection === null) {
 				continue;
 			}

src/Reflection/ClassReflection.php

@@ -83,6 +83,12 @@ final class ClassReflection
 	/** @var ExtendedPropertyReflection[] */
 	private array $properties = [];
 
+	/** @var ExtendedPropertyReflection[] */
+	private array $instanceProperties = [];
+
+	/** @var ExtendedPropertyReflection[] */
+	private array $staticProperties = [];
+
 	/** @var RealClassClassConstantReflection[] */
 	private array $constants = [];
 
@@ -149,6 +155,12 @@ final class ClassReflection
 	/** @var array<string, bool> */
 	private array $hasPropertyCache = [];
 
+	/** @var array<string, bool> */
+	private array $hasInstancePropertyCache = [];
+
+	/** @var array<string, bool> */
+	private array $hasStaticPropertyCache = [];
+
 	/**
 	 * @param PropertiesClassReflectionExtension[] $propertiesClassReflectionExtensions
 	 * @param MethodsClassReflectionExtension[] $methodsClassReflectionExtensions
@@ -449,6 +461,9 @@ public function allowsDynamicProperties(): bool
 		return $attributes !== [];
 	}
 
+	/**
+	 * @deprecated Use hasInstanceProperty or hasStaticProperty instead
+	 */
 	public function hasProperty(string $propertyName): bool
 	{
 		if (array_key_exists($propertyName, $this->hasPropertyCache)) {
@@ -468,13 +483,68 @@ public function hasProperty(string $propertyName): bool
 			}
 		}
 
+		// For BC purpose
+		if ($this->getPhpExtension()->hasProperty($this, $propertyName)) {
+			return $this->hasPropertyCache[$propertyName] = true;
+		}
+
 		if ($this->requireExtendsPropertiesClassReflectionExtension->hasProperty($this, $propertyName)) {
 			return $this->hasPropertyCache[$propertyName] = true;
 		}
 
 		return $this->hasPropertyCache[$propertyName] = false;
 	}
 
+	public function hasInstanceProperty(string $propertyName): bool
+	{
+		if (array_key_exists($propertyName, $this->hasInstancePropertyCache)) {
+			return $this->hasInstancePropertyCache[$propertyName];
+		}
+
+		if ($this->isEnum()) {
+			return $this->hasInstancePropertyCache[$propertyName] = $this->hasNativeProperty($propertyName);
+		}
+
+		foreach ($this->propertiesClassReflectionExtensions as $i => $extension) {
+			if ($i > 0 && !$this->allowsDynamicProperties()) {
+				break;
+			}
+			if ($extension->hasProperty($this, $propertyName)) {
+				$property = $extension->getProperty($this, $propertyName);
+				if ($property->isStatic()) {
+					continue;
+				}
+				return $this->hasInstancePropertyCache[$propertyName] = true;
+			}
+		}
+
+		if ($this->requireExtendsPropertiesClassReflectionExtension->hasInstanceProperty($this, $propertyName)) {
+			return $this->hasPropertyCache[$propertyName] = true;
+		}
+
+		return $this->hasPropertyCache[$propertyName] = false;
+	}
+
+	public function hasStaticProperty(string $propertyName): bool
+	{
+		if (array_key_exists($propertyName, $this->hasStaticPropertyCache)) {
+			return $this->hasStaticPropertyCache[$propertyName];
+		}
+
+		if ($this->getPhpExtension()->hasProperty($this, $propertyName)) {
+			$property = $this->getPhpExtension()->getProperty($this, $propertyName);
+			if ($property->isStatic()) {
+				return $this->hasStaticPropertyCache[$propertyName] = true;
+			}
+		}
+
+		if ($this->requireExtendsPropertiesClassReflectionExtension->hasStaticProperty($this, $propertyName)) {
+			return $this->hasStaticPropertyCache[$propertyName] = true;
+		}
+
+		return $this->hasStaticPropertyCache[$propertyName] = false;
+	}
+
 	public function hasMethod(string $methodName): bool
 	{
 		if (array_key_exists($methodName, $this->hasMethodCache)) {
@@ -619,6 +689,20 @@ public function evictPrivateSymbols(): void
 
 			unset($this->properties[$name]);
 		}
+		foreach ($this->instanceProperties as $name => $property) {
+			if (!$property->isPrivate()) {
+				continue;
+			}
+
+			unset($this->instanceProperties[$name]);
+		}
+		foreach ($this->staticProperties as $name => $property) {
+			if (!$property->isPrivate()) {
+				continue;
+			}
+
+			unset($this->staticProperties[$name]);
+		}
 		foreach ($this->methods as $name => $method) {
 			if (!$method->isPrivate()) {
 				continue;
@@ -629,6 +713,7 @@ public function evictPrivateSymbols(): void
 		$this->getPhpExtension()->evictPrivateSymbols($this->getCacheKey());
 	}
 
+	/** @deprecated Use getInstanceProperty or getStaticProperty */
 	public function getProperty(string $propertyName, ClassMemberAccessAnswerer $scope): ExtendedPropertyReflection
 	{
 		if ($this->isEnum()) {
@@ -658,6 +743,13 @@ public function getProperty(string $propertyName, ClassMemberAccessAnswerer $sco
 			}
 		}
 
+		// For BC purpose
+		if ($this->getPhpExtension()->hasProperty($this, $propertyName)) {
+			$property = $this->getPhpExtension()->getProperty($this, $propertyName);
+
+			return $this->properties[$key] = $property;
+		}
+
 		if (!isset($this->properties[$key])) {
 			if ($this->requireExtendsPropertiesClassReflectionExtension->hasProperty($this, $propertyName)) {
 				$property = $this->requireExtendsPropertiesClassReflectionExtension->getProperty($this, $propertyName);
@@ -672,6 +764,79 @@ public function getProperty(string $propertyName, ClassMemberAccessAnswerer $sco
 		return $this->properties[$key];
 	}
 
+	public function getInstanceProperty(string $propertyName, ClassMemberAccessAnswerer $scope): ExtendedPropertyReflection
+	{
+		if ($this->isEnum()) {
+			return $this->getNativeProperty($propertyName);
+		}
+
+		$key = $propertyName;
+		if ($scope->isInClass()) {
+			$key = sprintf('%s-%s', $key, $scope->getClassReflection()->getCacheKey());
+		}
+
+		if (!isset($this->instanceProperties[$key])) {
+			foreach ($this->propertiesClassReflectionExtensions as $i => $extension) {
+				if ($i > 0 && !$this->allowsDynamicProperties()) {
+					break;
+				}
+
+				if (!$extension->hasProperty($this, $propertyName)) {
+					continue;
+				}
+
+				$nakedProperty = $extension->getProperty($this, $propertyName);
+				if ($nakedProperty->isStatic()) {
+					continue;
+				}
+
+				$property = $this->wrapExtendedProperty($propertyName, $nakedProperty);
+				if ($scope->canReadProperty($property)) {
+					return $this->instanceProperties[$key] = $property;
+				}
+				$this->instanceProperties[$key] = $property;
+			}
+		}
+
+		if (!isset($this->instanceProperties[$key])) {
+			if ($this->requireExtendsPropertiesClassReflectionExtension->hasInstanceProperty($this, $propertyName)) {
+				$property = $this->requireExtendsPropertiesClassReflectionExtension->getInstanceProperty($this, $propertyName);
+				$this->instanceProperties[$key] = $property;
+			}
+		}
+
+		if (!isset($this->instanceProperties[$key])) {
+			throw new MissingPropertyFromReflectionException($this->getName(), $propertyName);
+		}
+
+		return $this->instanceProperties[$key];
+	}
+
+	public function getStaticProperty(string $propertyName): ExtendedPropertyReflection
+	{
+		$key = $propertyName;
+		if (isset($this->staticProperties[$key])) {
+			return $this->staticProperties[$key];
+		}
+
+		if ($this->getPhpExtension()->hasProperty($this, $propertyName)) {
+			$nakedProperty = $this->getPhpExtension()->getProperty($this, $propertyName);
+			if ($nakedProperty->isStatic()) {
+				$property = $this->wrapExtendedProperty($propertyName, $nakedProperty);
+				if ($property->isStatic()) {
+					return $this->staticProperties[$key] = $property;
+				}
+			}
+		}
+
+		if ($this->requireExtendsPropertiesClassReflectionExtension->hasStaticProperty($this, $propertyName)) {
+			$property = $this->requireExtendsPropertiesClassReflectionExtension->getStaticProperty($this, $propertyName);
+			return $this->staticProperties[$key] = $property;
+		}
+
+		throw new MissingPropertyFromReflectionException($this->getName(), $propertyName);
+	}
+
 	public function hasNativeProperty(string $propertyName): bool
 	{
 		return $this->getPhpExtension()->hasProperty($this, $propertyName);

src/Reflection/InitializerExprTypeResolver.php

@@ -408,11 +408,11 @@ public function getType(Expr $expr, InitializerExprContext $context): Type
 
 		if ($expr instanceof PropertyFetch && $expr->name instanceof Identifier) {
 			$fetchedOnType = $this->getType($expr->var, $context);
-			if (!$fetchedOnType->hasProperty($expr->name->name)->yes()) {
+			if (!$fetchedOnType->hasInstanceProperty($expr->name->name)->yes()) {
 				return new ErrorType();
 			}
 
-			return $fetchedOnType->getProperty($expr->name->name, new OutOfClassScope())->getReadableType();
+			return $fetchedOnType->getInstanceProperty($expr->name->name, new OutOfClassScope())->getReadableType();
 		}
 
 		return new MixedType();