Return exact value for final constants in ClassConstantAccessType::getResult()

Add getInitializerExprType() to ClassConstantReflection to retrieve the
concrete initializer value type, bypassing PHPDoc/native type declarations.
Use it in ClassConstantAccessType::getResult() for final constants, since
they cannot be overridden and their exact value is always known.

Update test expectations for final typed constants to expect exact values
instead of declared types. Add test cases for non-final class with non-final
typed constants to verify they correctly resolve to PHPDoc/native types.

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

Author: phpstan-bot

src/Reflection/ClassConstantReflection.php

@@ -40,4 +40,6 @@ public function getNativeType(): ?Type;
 
 	public function getResolvedPhpDoc(): ?ResolvedPhpDocBlock;
 
+	public function getInitializerExprType(): Type;
+
 }

src/Reflection/Dummy/DummyClassConstantReflection.php

@@ -122,4 +122,9 @@ public function getResolvedPhpDoc(): ?ResolvedPhpDocBlock
 		return null;
 	}
 
+	public function getInitializerExprType(): Type
+	{
+		return new MixedType();
+	}
+
 }

src/Reflection/RealClassClassConstantReflection.php

@@ -91,6 +91,11 @@ public function getValueType(): Type
 		return $this->valueType;
 	}
 
+	public function getInitializerExprType(): Type
+	{
+		return $this->initializerExprTypeResolver->getType($this->getValueExpr(), InitializerExprContext::fromClassReflection($this->declaringClass));
+	}
+
 	public function getDeclaringClass(): ClassReflection
 	{
 		return $this->declaringClass;

src/Rules/RestrictedUsage/RewrittenDeclaringClassClassConstantReflection.php

@@ -119,4 +119,9 @@ public function getResolvedPhpDoc(): ?ResolvedPhpDocBlock
 		return $this->constantReflection->getResolvedPhpDoc();
 	}
 
+	public function getInitializerExprType(): Type
+	{
+		return $this->constantReflection->getInitializerExprType();
+	}
+
 }

src/Type/ClassConstantAccessType.php

@@ -88,7 +88,7 @@ protected function getResult(): Type
 		$isFinalClass = count($classReflections) === 1 && $classReflections[0]->isFinal();
 
 		if ($isFinalClass || $constantReflection->isFinal()) {
-			return $constantReflection->getValueType();
+			return $constantReflection->getInitializerExprType();
 		}
 
 		if (!$constantReflection->hasPhpDocType() && !$constantReflection->hasNativeType()) {

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

@@ -173,7 +173,7 @@ public function test(): string
 
 function testFinalTypedConstant(WithFinalTypedConstant $foo): void
 {
-	assertType('non-empty-string', $foo->test());
+	assertType("'foo'", $foo->test());
 }
 
 final class FinalClassWithNativeType
@@ -240,7 +240,7 @@ public function test(): string
 
 function testFinalPhpDocConstant(WithFinalPhpDocConstant $foo): void
 {
-	assertType('non-empty-string', $foo->test());
+	assertType("'foo'", $foo->test());
 }
 
 class WithFinalNativeConstant
@@ -256,5 +256,5 @@ public function test(): string
 
 function testFinalNativeConstant(WithFinalNativeConstant $foo): void
 {
-	assertType('string', $foo->test());
+	assertType("'foo'", $foo->test());
 }

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

@@ -31,3 +31,69 @@ function test(FooBar $foo, BarBaz $bar, FinalBarBaz $baz): void
 	assertType('mixed', $bar->test());
 	assertType("'bar'", $baz->test());
 }
+
+class WithNativeType
+{
+	const string FOO_BAR = 'foo';
+
+	/** @return static::FOO_BAR */
+	public function test(): string
+	{
+		return static::FOO_BAR;
+	}
+}
+
+function testNativeType(WithNativeType $foo): void
+{
+	assertType('string', $foo->test());
+}
+
+class WithPhpDocType
+{
+	/** @var non-empty-string */
+	const FOO_BAR = 'foo';
+
+	/** @return static::FOO_BAR */
+	public function test(): string
+	{
+		return static::FOO_BAR;
+	}
+}
+
+function testPhpDocType(WithPhpDocType $foo): void
+{
+	assertType('non-empty-string', $foo->test());
+}
+
+class WithFinalConstant
+{
+	final const FOO_BAR = 'foo';
+
+	/** @return static::FOO_BAR */
+	public function test(): string
+	{
+		return static::FOO_BAR;
+	}
+}
+
+function testFinalConstant(WithFinalConstant $foo): void
+{
+	assertType("'foo'", $foo->test());
+}
+
+class WithFinalTypedConstant
+{
+	/** @var non-empty-string */
+	final const string FOO_BAR = 'foo';
+
+	/** @return static::FOO_BAR */
+	public function test(): string
+	{
+		return static::FOO_BAR;
+	}
+}
+
+function testFinalTypedConstant(WithFinalTypedConstant $foo): void
+{
+	assertType("'foo'", $foo->test());
+}