Add ConstFetchNode support in array shape key

Author: VincentLanglet

src/PhpDoc/TypeNodeResolver.php

@@ -20,6 +20,7 @@
 use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprStringNode;
 use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprTrueNode;
 use PHPStan\PhpDocParser\Ast\ConstExpr\ConstFetchNode;
+use PHPStan\PhpDocParser\Ast\Type\ArrayShapeItemNode;
 use PHPStan\PhpDocParser\Ast\Type\ArrayShapeNode;
 use PHPStan\PhpDocParser\Ast\Type\ArrayTypeNode;
 use PHPStan\PhpDocParser\Ast\Type\CallableTypeNode;
@@ -1050,16 +1051,7 @@ private function resolveArrayShapeNode(ArrayShapeNode $typeNode, NameScope $name
 		}
 
 		foreach ($typeNode->items as $itemNode) {
-			$offsetType = null;
-			if ($itemNode->keyName instanceof ConstExprIntegerNode) {
-				$offsetType = new ConstantIntegerType((int) $itemNode->keyName->value);
-			} elseif ($itemNode->keyName instanceof IdentifierTypeNode) {
-				$offsetType = new ConstantStringType($itemNode->keyName->name);
-			} elseif ($itemNode->keyName instanceof ConstExprStringNode) {
-				$offsetType = new ConstantStringType($itemNode->keyName->value);
-			} elseif ($itemNode->keyName !== null) {
-				throw new ShouldNotHappenException('Unsupported key node type: ' . get_class($itemNode->keyName));
-			}
+			$offsetType = $this->resolveArrayShapeOffsetType($itemNode, $nameScope);
 			$builder->setOffsetValueType($offsetType, $this->resolve($itemNode->valueType, $nameScope), $itemNode->optional);
 		}
 
@@ -1081,6 +1073,69 @@ private function resolveArrayShapeNode(ArrayShapeNode $typeNode, NameScope $name
 		return $arrayType;
 	}
 
+	private function resolveArrayShapeOffsetType(ArrayShapeItemNode $itemNode, NameScope $nameScope): ?Type
+	{
+		if ($itemNode->keyName instanceof ConstExprIntegerNode) {
+			return new ConstantIntegerType((int) $itemNode->keyName->value);
+		} elseif ($itemNode->keyName instanceof IdentifierTypeNode) {
+			return new ConstantStringType($itemNode->keyName->name);
+		} elseif ($itemNode->keyName instanceof ConstExprStringNode) {
+			return new ConstantStringType($itemNode->keyName->value);
+		} elseif ($itemNode->keyName instanceof ConstFetchNode) {
+			$constExpr = $itemNode->keyName;
+			if ($constExpr->className === '') {
+				throw new ShouldNotHappenException(); // global constant should get parsed as class name in IdentifierTypeNode
+			}
+
+			if ($nameScope->getClassName() !== null) {
+				switch (strtolower($constExpr->className)) {
+					case 'static':
+					case 'self':
+						$className = $nameScope->getClassName();
+						break;
+
+					case 'parent':
+						if ($this->getReflectionProvider()->hasClass($nameScope->getClassName())) {
+							$classReflection = $this->getReflectionProvider()->getClass($nameScope->getClassName());
+							if ($classReflection->getParentClass() === null) {
+								return new ErrorType();
+
+							}
+
+							$className = $classReflection->getParentClass()->getName();
+						}
+						break;
+				}
+			}
+
+			if (!isset($className)) {
+				$className = $nameScope->resolveStringName($constExpr->className);
+			}
+
+			if (!$this->getReflectionProvider()->hasClass($className)) {
+				return new ErrorType();
+			}
+			$classReflection = $this->getReflectionProvider()->getClass($className);
+
+			$constantName = $constExpr->name;
+			if (!$classReflection->hasConstant($constantName)) {
+				return new ErrorType();
+			}
+
+			$reflectionConstant = $classReflection->getNativeReflection()->getReflectionConstant($constantName);
+			if ($reflectionConstant === false) {
+				return new ErrorType();
+			}
+			$declaringClass = $reflectionConstant->getDeclaringClass();
+
+			return $this->initializerExprTypeResolver->getType($reflectionConstant->getValueExpression(), InitializerExprContext::fromClass($declaringClass->getName(), $declaringClass->getFileName() ?: null));
+		} elseif ($itemNode->keyName !== null) {
+			throw new ShouldNotHappenException('Unsupported key node type: ' . get_class($itemNode->keyName));
+		}
+
+		return null;
+	}
+
 	private function resolveObjectShapeNode(ObjectShapeNode $typeNode, NameScope $nameScope): Type
 	{
 		$properties = [];

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

@@ -0,0 +1,51 @@
+<?php
+
+namespace Bug6989;
+
+use function PHPStan\Testing\assertType;
+
+class MyClass
+{
+	public const MY_KEY = 'key';
+
+	/**
+	 * @param array{static::MY_KEY: string} $items1
+	 * @param array{self::MY_KEY: string} $items2
+	 * @param array{MyClass::MY_KEY: string} $items3
+	 *
+	 * @return string
+	 */
+	public function myMethod(array $items1, array $items2, array $items3): array
+	{
+		assertType('array{key: string}', $items1);
+		assertType('array{key: string}', $items2);
+		assertType('array{key: string}', $items3);
+
+		return $items1[static::MY_KEY];
+	}
+}
+
+class ParentClass extends MyClass
+{
+	public const MY_KEY = 'different_key';
+
+	/**
+	 * @param array{static::MY_KEY: string} $items1
+	 * @param array{self::MY_KEY: string} $items2
+	 * @param array{MyClass::MY_KEY: string} $items3
+	 * @param array{ParentClass::MY_KEY: string} $items4
+	 * @param array{parent::MY_KEY: string} $items5
+	 *
+	 * @return string
+	 */
+	public function myMethod2(array $items1, array $items2, array $items3, array $items4, array $items5): array
+	{
+		assertType('array{different_key: string}', $items1);
+		assertType('array{different_key: string}', $items2);
+		assertType('array{key: string}', $items3);
+		assertType('array{different_key: string}', $items4);
+		assertType('array{key: string}', $items5);
+
+		return $items1[static::MY_KEY];
+	}
+}