Fix ClassConstantAccessType resolution and array shape offset handling

1. Add `use function count` to fix coding standard error
2. In getResult(), return value type directly when inner type is StaticType.
   This prevents premature resolution to `mixed` during decideType() which
   would cause the native return type to override the PHPDoc type before
   transformStaticType() has a chance to replace StaticType with a concrete
   ObjectType. After transformation, the new instance resolves correctly.
3. Revert resolveArrayShapeOffsetType to treat static:: like self:: because
   array shape keys need concrete ConstantStringType values, not
   ClassConstantAccessType which resolves to mixed for untyped constants.

Co-authored-by: Ondřej Mirtes <ondrejmirtes@users.noreply.github.com>

Author: github-actions[bot]

src/PhpDoc/TypeNodeResolver.php

@@ -1202,14 +1202,9 @@ private function resolveConstTypeNode(ConstTypeNode $typeNode, NameScope $nameSc
 				throw new ShouldNotHappenException(); // global constant should get parsed as class name in IdentifierTypeNode
 			}
 
-			$isStatic = false;
 			if ($nameScope->getClassName() !== null) {
 				switch (strtolower($constExpr->className)) {
 					case 'static':
-						$className = $nameScope->getClassName();
-						$isStatic = true;
-						break;
-
 					case 'self':
 						$className = $nameScope->getClassName();
 						break;
@@ -1238,10 +1233,6 @@ private function resolveConstTypeNode(ConstTypeNode $typeNode, NameScope $nameSc
 
 			$classReflection = $this->getReflectionProvider()->getClass($className);
 
-			if ($isStatic && $classReflection->isFinal()) {
-				$isStatic = false;
-			}
-
 			$constantName = $constExpr->name;
 			if (Strings::contains($constantName, '*')) {
 				// convert * into .*? and escape everything else so the constants can be matched against the pattern
@@ -1258,16 +1249,6 @@ private function resolveConstTypeNode(ConstTypeNode $typeNode, NameScope $nameSc
 						continue;
 					}
 
-					if ($isStatic) {
-						$constantReflection = $classReflection->getConstant($classConstantName);
-						if (!$constantReflection->isFinal() && !$constantReflection->hasPhpDocType() && !$constantReflection->hasNativeType()) {
-							$constantTypes[] = new MixedType();
-							continue;
-						}
-						$constantTypes[] = $constantReflection->getValueType();
-						continue;
-					}
-
 					$declaringClassName = $reflectionConstant->getDeclaringClass()->getName();
 					if (!$this->getReflectionProvider()->hasClass($declaringClassName)) {
 						continue;
@@ -1296,10 +1277,6 @@ private function resolveConstTypeNode(ConstTypeNode $typeNode, NameScope $nameSc
 				return new EnumCaseObjectType($classReflection->getName(), $constantName);
 			}
 
-			if ($isStatic) {
-				return new ClassConstantAccessType(new StaticType($classReflection), $constantName);
-			}
-
 			$reflectionConstant = $classReflection->getNativeReflection()->getReflectionConstant($constantName);
 			if ($reflectionConstant === false) {
 				return new ErrorType();

src/Type/ClassConstantAccessType.php

@@ -8,6 +8,7 @@
 use PHPStan\Type\Generic\TemplateTypeVariance;
 use PHPStan\Type\Traits\LateResolvableTypeTrait;
 use PHPStan\Type\Traits\NonGeneralizableTypeTrait;
+use function count;
 
 final class ClassConstantAccessType implements CompoundType, LateResolvableType
 {
@@ -51,6 +52,20 @@ public function isResolvable(): bool
 
 	protected function getResult(): Type
 	{
+		// When the inner type is still a StaticType, this ClassConstantAccessType
+		// has not yet been transformed by CalledOnTypeUnresolvedMethodPrototypeReflection.
+		// Return the value type directly so that decideType() accepts the PHPDoc type
+		// as compatible with the native return type. Once transformStaticType() replaces
+		// the StaticType with a concrete ObjectType, traverse() creates a new instance
+		// whose getResult() applies the full resolution logic below.
+		if ($this->type instanceof StaticType) {
+			if (!$this->type->hasConstant($this->constantName)->yes()) {
+				return new ErrorType();
+			}
+
+			return $this->type->getConstant($this->constantName)->getValueType();
+		}
+
 		$classReflections = $this->type->getObjectClassReflections();
 		if (count($classReflections) !== 1) {
 			if (!$this->type->hasConstant($this->constantName)->yes()) {