Resolve array_column property checks through ArrayColumnHelper

Move the object-property-missing detection used by ArrayColumnRule into
ArrayColumnHelper, the single home for array_column() semantics, and have
the rule delegate to it instead of duplicating the property resolution.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: phpstan-bot

src/Rules/Functions/ArrayColumnRule.php

@@ -11,6 +11,7 @@
 use PHPStan\Rules\IdentifierRuleError;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\Type\Php\ArrayColumnHelper;
 use PHPStan\Type\Type;
 use PHPStan\Type\VerbosityLevel;
 use function count;
@@ -27,6 +28,7 @@ final class ArrayColumnRule implements Rule
 
 	public function __construct(
 		private readonly ReflectionProvider $reflectionProvider,
+		private readonly ArrayColumnHelper $arrayColumnHelper,
 		private readonly bool $treatPhpDocTypesAsCertain,
 		private readonly bool $treatPhpDocTypesAsCertainTip,
 	)
@@ -95,37 +97,32 @@ private function checkColumn(Node\Expr $columnExpr, Type $valueType, Type $nativ
 	{
 		$checkedValueType = $this->treatPhpDocTypesAsCertain ? $valueType : $nativeValueType;
 
-		// array_column() reads object properties (never ArrayAccess offsets), so
-		// only check when the elements are definitely objects. Array elements use
-		// offset access, scalars never have the member - leave those to other rules.
-		if (!$checkedValueType->isObject()->yes()) {
+		$columnType = $scope->getType($columnExpr);
+		$missingProperties = $this->arrayColumnHelper->findMissingObjectProperties($checkedValueType, $columnType);
+		if ($missingProperties === []) {
 			return [];
 		}
 
-		$columnType = $scope->getType($columnExpr);
-		$propertyNames = $columnType->getConstantStrings();
-		if ($propertyNames === []) {
-			return [];
+		$nativeMissingPropertyNames = [];
+		foreach ($this->arrayColumnHelper->findMissingObjectProperties($nativeValueType, $columnType) as $nativeMissingProperty) {
+			$nativeMissingPropertyNames[$nativeMissingProperty->getValue()] = true;
 		}
 
 		$errors = [];
-		foreach ($propertyNames as $propertyNameType) {
-			$propertyName = $propertyNameType->getValue();
-			if (!$this->isPropertyMissing($checkedValueType, $propertyName)) {
-				continue;
-			}
-
+		foreach ($missingProperties as $propertyNameType) {
 			$errorBuilder = RuleErrorBuilder::message(sprintf(
 				'Parameter %s of function array_column expects a valid property name, %s given, but %s does not have such property.',
 				$parameter,
 				$propertyNameType->describe(VerbosityLevel::value()),
 				$checkedValueType->describe(VerbosityLevel::typeOnly()),
 			))->identifier('arrayColumn.property');
 
-			if ($this->treatPhpDocTypesAsCertain && $this->treatPhpDocTypesAsCertainTip) {
-				if (!$nativeValueType->isObject()->yes() || !$this->isPropertyMissing($nativeValueType, $propertyName)) {
-					$errorBuilder->treatPhpDocTypesAsCertainTip();
-				}
+			if (
+				$this->treatPhpDocTypesAsCertain
+				&& $this->treatPhpDocTypesAsCertainTip
+				&& !isset($nativeMissingPropertyNames[$propertyNameType->getValue()])
+			) {
+				$errorBuilder->treatPhpDocTypesAsCertainTip();
 			}
 
 			$errors[] = $errorBuilder->build();
@@ -134,29 +131,4 @@ private function checkColumn(Node\Expr $columnExpr, Type $valueType, Type $nativ
 		return $errors;
 	}
 
-	private function isPropertyMissing(Type $valueType, string $propertyName): bool
-	{
-		$classReflections = $valueType->getObjectClassReflections();
-		if ($classReflections === []) {
-			return false;
-		}
-
-		foreach ($classReflections as $classReflection) {
-			if ($classReflection->isEnum()) {
-				return false;
-			}
-			if ($classReflection->hasInstanceProperty($propertyName)) {
-				return false;
-			}
-			if ($classReflection->allowsDynamicProperties()) {
-				return false;
-			}
-			if ($classReflection->hasNativeMethod('__isset') && $classReflection->hasNativeMethod('__get')) {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
 }

src/Type/Php/ArrayColumnHelper.php

@@ -11,6 +11,7 @@
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\Constant\ConstantArrayType;
 use PHPStan\Type\Constant\ConstantArrayTypeBuilder;
+use PHPStan\Type\Constant\ConstantStringType;
 use PHPStan\Type\IntegerType;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\NeverType;
@@ -150,6 +151,69 @@ public function handleConstantArray(ConstantArrayType $arrayType, Type $columnTy
 		return $builder->getArray();
 	}
 
+	/**
+	 * Returns the property names from $columnType that the objects contained in
+	 * $iterableValueType certainly lack, so that reading them via array_column()
+	 * would yield nothing.
+	 *
+	 * Unlike the type-inference path (getOffsetOrProperty), this resolves
+	 * properties at the ClassReflection level so that concrete and non-final
+	 * element classes are reported - matching how AccessPropertiesRule reports
+	 * direct property fetches.
+	 *
+	 * @return list<ConstantStringType>
+	 */
+	public function findMissingObjectProperties(Type $iterableValueType, Type $columnType): array
+	{
+		// array_column() reads object properties (never ArrayAccess offsets), so
+		// only check when the elements are definitely objects. Array elements use
+		// offset access, scalars never have the member - leave those to other rules.
+		if (!$iterableValueType->isObject()->yes()) {
+			return [];
+		}
+
+		$propertyNameTypes = $columnType->getConstantStrings();
+		if ($propertyNameTypes === []) {
+			return [];
+		}
+
+		$missing = [];
+		foreach ($propertyNameTypes as $propertyNameType) {
+			if (!$this->isObjectPropertyMissing($iterableValueType, $propertyNameType->getValue())) {
+				continue;
+			}
+
+			$missing[] = $propertyNameType;
+		}
+
+		return $missing;
+	}
+
+	private function isObjectPropertyMissing(Type $iterableValueType, string $propertyName): bool
+	{
+		$classReflections = $iterableValueType->getObjectClassReflections();
+		if ($classReflections === []) {
+			return false;
+		}
+
+		foreach ($classReflections as $classReflection) {
+			if ($classReflection->isEnum()) {
+				return false;
+			}
+			if ($classReflection->hasInstanceProperty($propertyName)) {
+				return false;
+			}
+			if ($classReflection->allowsDynamicProperties()) {
+				return false;
+			}
+			if ($classReflection->hasNativeMethod('__isset') && $classReflection->hasNativeMethod('__get')) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
 	/**
 	 * @return array{Type, TrinaryLogic}
 	 */

tests/PHPStan/Rules/Functions/ArrayColumnRuleTest.php

@@ -4,6 +4,7 @@
 
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
+use PHPStan\Type\Php\ArrayColumnHelper;
 use PHPUnit\Framework\Attributes\RequiresPhp;
 
 /**
@@ -16,6 +17,7 @@ protected function getRule(): Rule
 	{
 		return new ArrayColumnRule(
 			self::createReflectionProvider(),
+			self::getContainer()->getByType(ArrayColumnHelper::class),
 			$this->shouldTreatPhpDocTypesAsCertain(),
 			true,
 		);