Fix ClassConstantAccessType to use declared types for non-final classes

When the inner type is still a StaticType (not yet resolved to a concrete
class), use the declared type (native or PHPDoc) instead of the literal
value for non-final constants on non-final classes. For final constants
or final classes, the literal value is preserved since subclasses cannot
override them.

Added test cases for:
- Constants with native type (const string)
- Constants with PHPDoc type (@var non-empty-string)
- Constants with both native and PHPDoc types
- Final constants on non-final classes
- Untyped constants

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

Author: github-actions[bot]

src/Type/ClassConstantAccessType.php

@@ -51,11 +51,25 @@ public function isResolvable(): bool
 
 	protected function getResult(): Type
 	{
-		if ($this->type->hasConstant($this->constantName)->yes()) {
-			return $this->type->getConstant($this->constantName)->getValueType();
+		if (!$this->type->hasConstant($this->constantName)->yes()) {
+			return new ErrorType();
 		}
 
-		return new ErrorType();
+		$constantReflection = $this->type->getConstant($this->constantName);
+
+		if (
+			$this->type instanceof StaticType
+			&& !$this->type->getClassReflection()->isFinal()
+			&& !$constantReflection->isFinal()
+		) {
+			if ($constantReflection->hasNativeType() || $constantReflection->hasPhpDocType()) {
+				return $constantReflection->getValueType();
+			}
+
+			return new MixedType();
+		}
+
+		return $constantReflection->getValueType();
 	}
 
 	/**

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

@@ -41,3 +41,110 @@ function testFinal(FinalFoo $foo): void
 {
 	assertType("'foo'", $foo->test());
 }
+
+class WithNativeType
+{
+	const string FOO_BAR = 'foo';
+
+	/** @return static::FOO_BAR */
+	public function test(): string
+	{
+		return static::FOO_BAR;
+	}
+}
+
+class WithNativeTypeChild extends WithNativeType
+{
+	const string FOO_BAR = 'bar';
+}
+
+function testNativeType(WithNativeType $foo, WithNativeTypeChild $bar): void
+{
+	assertType('string', $foo->test());
+	assertType('string', $bar->test());
+}
+
+class WithPhpDocType
+{
+	/** @var non-empty-string */
+	const FOO_BAR = 'foo';
+
+	/** @return static::FOO_BAR */
+	public function test(): string
+	{
+		return static::FOO_BAR;
+	}
+}
+
+class WithPhpDocTypeChild extends WithPhpDocType
+{
+	/** @var non-empty-string */
+	const FOO_BAR = 'bar';
+}
+
+function testPhpDocType(WithPhpDocType $foo, WithPhpDocTypeChild $bar): void
+{
+	assertType('non-empty-string', $foo->test());
+	assertType('non-empty-string', $bar->test());
+}
+
+class WithBothTypes
+{
+	/** @var non-empty-string */
+	const string FOO_BAR = 'foo';
+
+	/** @return static::FOO_BAR */
+	public function test(): string
+	{
+		return static::FOO_BAR;
+	}
+}
+
+class WithBothTypesChild extends WithBothTypes
+{
+	/** @var non-empty-string */
+	const string FOO_BAR = 'bar';
+}
+
+function testBothTypes(WithBothTypes $foo, WithBothTypesChild $bar): void
+{
+	assertType('non-empty-string', $foo->test());
+	assertType('non-empty-string', $bar->test());
+}
+
+class WithFinalConstant
+{
+	final const FOO_BAR = 'foo';
+
+	/** @return static::FOO_BAR */
+	public function test(): string
+	{
+		return static::FOO_BAR;
+	}
+}
+
+class WithFinalConstantChild extends WithFinalConstant
+{
+}
+
+function testFinalConstant(WithFinalConstant $foo, WithFinalConstantChild $bar): void
+{
+	assertType("'foo'", $foo->test());
+	assertType("'foo'", $bar->test());
+}
+
+class WithUntypedConstant
+{
+	const FOO_BAR = 'foo';
+
+	/** @return static::FOO_BAR */
+	public function test(): string
+	{
+		return static::FOO_BAR;
+	}
+}
+
+function testUntypedConstant(WithUntypedConstant $foo): void
+{
+	assertType("'foo'", $foo->test());
+}