phpstan · phpstan-bot · Sep 5, 2026
diff --git a/src/Reflection/ClassReflection.php b/src/Reflection/ClassReflection.php
@@ -955,7 +955,7 @@ public function getBackedEnumType(): ?Type
 			return null;
 		}
 
-		return TypehintHelper::decideTypeFromReflection($this->reflection->getBackingType());
+		return TypehintHelper::decideTypeFromReflection($this->reflection->getBackingType(), isBuiltin: $this->isBuiltin());
 	}
 
 	public function hasEnumCase(string $name): bool
@@ -1305,7 +1305,7 @@ public function getConstant(string $name): ClassConstantReflection
 
 			$nativeType = null;
 			if ($reflectionConstant->getType() !== null) {
-				$nativeType = TypehintHelper::decideTypeFromReflection($reflectionConstant->getType(), selfClass: $declaringClass);
+				$nativeType = TypehintHelper::decideTypeFromReflection($reflectionConstant->getType(), selfClass: $declaringClass, isBuiltin: $declaringClass->isBuiltin());
 			} elseif ($this->signatureMapProvider->hasClassConstantMetadata($declaringClass->getName(), $name)) {
 				$nativeType = $this->signatureMapProvider->getClassConstantMetadata($declaringClass->getName(), $name)['nativeType'];
 			}
@@ -1366,7 +1366,7 @@ public function getConstantPhpDocType(string $name): ?Type
 
 		$nativeType = null;
 		if ($reflectionConstant->getType() !== null) {
-			$nativeType = TypehintHelper::decideTypeFromReflection($reflectionConstant->getType());
+			$nativeType = TypehintHelper::decideTypeFromReflection($reflectionConstant->getType(), isBuiltin: $reflectionConstant->getDeclaringClass()->isInternal());
 		}
 
 		$declaringClassName = $reflectionConstant->getDeclaringClass()->getName();

diff --git a/src/Reflection/InitializerExprTypeResolver.php b/src/Reflection/InitializerExprTypeResolver.php
@@ -2659,7 +2659,7 @@ public function getClassConstFetchTypeByReflection(Name|Expr $class, string $con
 				$constantType = $this->getType($reflectionConstant->getValueExpression(), InitializerExprContext::fromClass($reflectionConstantDeclaringClass->getName(), $reflectionConstantDeclaringClass->getFileName() ?: null));
 				$nativeType = null;
 				if ($reflectionConstant->getType() !== null) {
-					$nativeType = TypehintHelper::decideTypeFromReflection($reflectionConstant->getType(), selfClass: $constantClassReflection);
+					$nativeType = TypehintHelper::decideTypeFromReflection($reflectionConstant->getType(), selfClass: $constantClassReflection, isBuiltin: $reflectionConstantDeclaringClass->isInternal());
 				}
 				$resolvedType = $this->constantResolver->resolveClassConstantType(
 					$constantClassReflection->getName(),

diff --git a/src/Reflection/Native/NativeMethodReflection.php b/src/Reflection/Native/NativeMethodReflection.php
@@ -86,7 +86,7 @@ public function getPrototype(): ClassMemberReflection
 
 			$tentativeReturnType = null;
 			if ($prototypeMethod->getTentativeReturnType() !== null) {
-				$tentativeReturnType = TypehintHelper::decideTypeFromReflection($prototypeMethod->getTentativeReturnType(), selfClass: $prototypeDeclaringClass);
+				$tentativeReturnType = TypehintHelper::decideTypeFromReflection($prototypeMethod->getTentativeReturnType(), selfClass: $prototypeDeclaringClass, isBuiltin: $prototypeDeclaringClass->isBuiltin());
 			}
 
 			return new MethodPrototypeReflection(

diff --git a/src/Reflection/Php/PhpClassReflectionExtension.php b/src/Reflection/Php/PhpClassReflectionExtension.php
@@ -367,7 +367,7 @@ private function createProperty(
 			);
 		}
 
-		$nativeType = TypehintHelper::decideTypeFromReflection($propertyReflection->getType(), selfClass: $declaringClassReflection);
+		$nativeType = TypehintHelper::decideTypeFromReflection($propertyReflection->getType(), selfClass: $declaringClassReflection, isBuiltin: $declaringClassReflection->isBuiltin());
 
 		$declaringTrait = null;
 		$reflectionProvider = $this->reflectionProviderProvider->getReflectionProvider();
@@ -881,6 +881,7 @@ public function createUserlandMethodReflection(ClassReflection $fileDeclaringCla
 		$nativeReturnType = TypehintHelper::decideTypeFromReflection(
 			$methodReflection->getReturnType(),
 			selfClass: $actualDeclaringClass,
+			isBuiltin: $actualDeclaringClass->isBuiltin(),
 		);
 
 		$isPure = null;

diff --git a/src/Reflection/Php/PhpFunctionReflection.php b/src/Reflection/Php/PhpFunctionReflection.php
@@ -133,6 +133,7 @@ private function getParameters(): array
 				$this->attributeReflectionFactory->fromNativeReflection($reflection->getAttributes(), InitializerExprContext::fromReflectionParameter($reflection)),
 				$this->allowedConstantsMapProvider->getForFunctionParameter(strtolower($this->reflection->getName()), $reflection->getName()),
 				TrinaryLogic::createFromBoolean($this->phpDocParameterPureUnlessCallableIsImpure[$reflection->getName()] ?? false),
+				$this->isBuiltin(),
 			);
 		}, $this->reflection->getParameters());
 	}
@@ -147,6 +148,7 @@ private function getReturnType(): Type
 		return TypehintHelper::decideTypeFromReflection(
 			$this->reflection->getReturnType(),
 			$this->phpDocReturnType,
+			isBuiltin: $this->isBuiltin(),
 		);
 	}
 
@@ -161,7 +163,7 @@ private function getPhpDocReturnType(): Type
 
 	private function getNativeReturnType(): Type
 	{
-		return TypehintHelper::decideTypeFromReflection($this->reflection->getReturnType());
+		return TypehintHelper::decideTypeFromReflection($this->reflection->getReturnType(), isBuiltin: $this->isBuiltin());
 	}
 
 	public function getDeprecatedDescription(): ?string

diff --git a/src/Reflection/Php/PhpMethodReflection.php b/src/Reflection/Php/PhpMethodReflection.php
@@ -124,7 +124,7 @@ public function getPrototype(): ClassMemberReflection
 
 			$tentativeReturnType = null;
 			if ($prototypeMethod->getTentativeReturnType() !== null) {
-				$tentativeReturnType = TypehintHelper::decideTypeFromReflection($prototypeMethod->getTentativeReturnType(), selfClass: $prototypeDeclaringClass);
+				$tentativeReturnType = TypehintHelper::decideTypeFromReflection($prototypeMethod->getTentativeReturnType(), selfClass: $prototypeDeclaringClass, isBuiltin: $prototypeDeclaringClass->isBuiltin());
 			}
 
 			return new MethodPrototypeReflection(
@@ -232,6 +232,7 @@ private function getParameters(): array
 			$this->attributeReflectionFactory->fromNativeReflection($reflection->getAttributes(), InitializerExprContext::fromReflectionParameter($reflection)),
 			$this->allowedConstantsMapProvider->getForMethodParameter($this->declaringClass->getName(), $this->reflection->getName(), $reflection->getName()),
 			TrinaryLogic::createFromBoolean($this->pureUnlessCallableIsImpureParameters[$reflection->getName()] ?? false),
+			$this->reflection->isInternal(),
 		), $this->reflection->getParameters());
 	}
 
@@ -277,6 +278,7 @@ private function getReturnType(): Type
 				$returnType,
 				$this->phpDocReturnType,
 				$this->declaringClass,
+				isBuiltin: $this->reflection->isInternal(),
 			);
 		}
 
@@ -297,6 +299,7 @@ private function getNativeReturnType(): Type
 		return $this->nativeReturnType ??= TypehintHelper::decideTypeFromReflection(
 			$this->reflection->getReturnType(),
 			selfClass: $this->declaringClass,
+			isBuiltin: $this->reflection->isInternal(),
 		);
 	}
 

diff --git a/src/Reflection/Php/PhpParameterReflection.php b/src/Reflection/Php/PhpParameterReflection.php
@@ -38,6 +38,7 @@ public function __construct(
 		private array $attributes,
 		private ?ParameterAllowedConstants $allowedConstants,
 		private TrinaryLogic $pureUnlessCallableIsImpureParameter,
+		private bool $isBuiltin = false,
 	)
 	{
 	}
@@ -74,6 +75,7 @@ public function getType(): Type
 				$phpDocType,
 				$this->declaringClass,
 				$this->isVariadic(),
+				$this->isBuiltin,
 			);
 		}
 
@@ -112,6 +114,7 @@ public function getNativeType(): Type
 			$this->reflection->getType(),
 			selfClass: $this->declaringClass,
 			isVariadic: $this->isVariadic(),
+			isBuiltin: $this->isBuiltin,
 		);
 	}
 

diff --git a/src/Reflection/SignatureMap/FunctionSignatureMapProvider.php b/src/Reflection/SignatureMap/FunctionSignatureMapProvider.php
@@ -149,7 +149,7 @@ private function createSignature(string $functionName, ?string $className, ?Refl
 				$parameter->getName(),
 				$parameter->isOptional(),
 				$parameter->getType(),
-				TypehintHelper::decideTypeFromReflection($nativeParameters[$i]->getType()),
+				TypehintHelper::decideTypeFromReflection($nativeParameters[$i]->getType(), isBuiltin: true),
 				$parameter->passedByReference(),
 				$parameter->isVariadic(),
 				$nativeParameters[$i]->isDefaultValueAvailable() ? $this->initializerExprTypeResolver->getType(
@@ -163,7 +163,7 @@ private function createSignature(string $functionName, ?string $className, ?Refl
 		if ($reflectionFunction === null) {
 			$nativeReturnType = new MixedType();
 		} else {
-			$nativeReturnType = TypehintHelper::decideTypeFromReflection($reflectionFunction->getReturnType());
+			$nativeReturnType = TypehintHelper::decideTypeFromReflection($reflectionFunction->getReturnType(), isBuiltin: true);
 		}
 
 		return new FunctionSignature(

diff --git a/src/Reflection/SignatureMap/Php8SignatureMapProvider.php b/src/Reflection/SignatureMap/Php8SignatureMapProvider.php
@@ -142,7 +142,7 @@ private function findClassStubs(string $className): void
 					continue;
 				}
 
-				$this->constantTypes[$lowerClassName][$const->name->toLowerString()] = ParserNodeTypeToPHPStanType::resolve($stmt->type, null);
+				$this->constantTypes[$lowerClassName][$const->name->toLowerString()] = ParserNodeTypeToPHPStanType::resolve($stmt->type, null, true);
 			}
 		}
 	}
@@ -442,7 +442,7 @@ private function getSignature(
 			if (!$name instanceof Variable || !is_string($name->name)) {
 				throw new ShouldNotHappenException();
 			}
-			$parameterType = ParserNodeTypeToPHPStanType::resolve($param->type, $classReflection);
+			$parameterType = ParserNodeTypeToPHPStanType::resolve($param->type, $classReflection, true);
 			$phpDocParameterType = $phpDocParameterTypes[$name->name] ?? null;
 
 			if ($param->default instanceof ConstFetch) {
@@ -473,7 +473,7 @@ private function getSignature(
 			$variadic = $variadic || $param->variadic;
 		}
 
-		$returnType = ParserNodeTypeToPHPStanType::resolve($function->getReturnType(), $classReflection);
+		$returnType = ParserNodeTypeToPHPStanType::resolve($function->getReturnType(), $classReflection, true);
 
 		return new FunctionSignature(
 			$parameters,

diff --git a/src/Type/ParserNodeTypeToPHPStanType.php b/src/Type/ParserNodeTypeToPHPStanType.php
@@ -18,14 +18,20 @@ final class ParserNodeTypeToPHPStanType
 
 	/**
 	 * @param Node\Name|Node\Identifier|Node\ComplexType|null $type
+	 * @param bool $isBuiltin Whether the type declaration comes from a PHP internal symbol.
+	 *                        Stubs of internal functions declare the resource pseudo-type
+	 *                        as `resource`, which PHP itself would read as a class name.
 	 */
-	public static function resolve($type, ?ClassReflection $classReflection): Type
+	public static function resolve($type, ?ClassReflection $classReflection, bool $isBuiltin = false): Type
 	{
 		if ($type === null) {
 			return new MixedType();
 		} elseif ($type instanceof Name) {
 			$typeClassName = (string) $type;
 			$lowercasedClassName = strtolower($typeClassName);
+			if ($isBuiltin && $lowercasedClassName === 'resource') {
+				return new ResourceType();
+			}
 			if ($classReflection !== null && in_array($lowercasedClassName, ['self', 'static'], true)) {
 				if ($lowercasedClassName === 'static') {
 					return new StaticType($classReflection);
@@ -41,18 +47,18 @@ public static function resolve($type, ?ClassReflection $classReflection): Type
 
 			return new ObjectType($typeClassName);
 		} elseif ($type instanceof NullableType) {
-			return TypeCombinator::addNull(self::resolve($type->type, $classReflection));
+			return TypeCombinator::addNull(self::resolve($type->type, $classReflection, $isBuiltin));
 		} elseif ($type instanceof Node\UnionType) {
 			$types = [];
 			foreach ($type->types as $unionTypeType) {
-				$types[] = self::resolve($unionTypeType, $classReflection);
+				$types[] = self::resolve($unionTypeType, $classReflection, $isBuiltin);
 			}
 
 			return TypeCombinator::union(...$types);
 		} elseif ($type instanceof Node\IntersectionType) {
 			$types = [];
 			foreach ($type->types as $intersectionTypeType) {
-				$innerType = self::resolve($intersectionTypeType, $classReflection);
+				$innerType = self::resolve($intersectionTypeType, $classReflection, $isBuiltin);
 				if (!$innerType->isObject()->yes()) {
 					return new NeverType();
 				}

diff --git a/src/Type/TypehintHelper.php b/src/Type/TypehintHelper.php
@@ -20,12 +20,18 @@
 final class TypehintHelper
 {
 
-	/** @api */
+	/**
+	 * @api
+	 * @param bool $isBuiltin Whether the type declaration comes from a PHP internal symbol.
+	 *                        Stubs of internal functions declare the resource pseudo-type
+	 *                        as `resource`, which PHP itself would read as a class name.
+	 */
 	public static function decideTypeFromReflection(
 		?ReflectionType $reflectionType,
 		?Type $phpDocType = null,
 		ClassReflection|null $selfClass = null,
 		bool $isVariadic = false,
+		bool $isBuiltin = false,
 	): Type
 	{
 		if ($reflectionType === null) {
@@ -36,15 +42,15 @@ public static function decideTypeFromReflection(
 		}
 
 		if ($reflectionType instanceof ReflectionUnionType) {
-			$type = TypeCombinator::union(...array_map(static fn (ReflectionType $type): Type => self::decideTypeFromReflection($type, selfClass: $selfClass), $reflectionType->getTypes()));
+			$type = TypeCombinator::union(...array_map(static fn (ReflectionType $type): Type => self::decideTypeFromReflection($type, selfClass: $selfClass, isBuiltin: $isBuiltin), $reflectionType->getTypes()));
 
 			return self::decideType($type, $phpDocType);
 		}
 
 		if ($reflectionType instanceof ReflectionIntersectionType) {
 			$types = [];
 			foreach ($reflectionType->getTypes() as $innerReflectionType) {
-				$innerType = self::decideTypeFromReflection($innerReflectionType, selfClass: $selfClass);
+				$innerType = self::decideTypeFromReflection($innerReflectionType, selfClass: $selfClass, isBuiltin: $isBuiltin);
 				if (!$innerType->isObject()->yes()) {
 					return new NeverType();
 				}
@@ -65,7 +71,7 @@ public static function decideTypeFromReflection(
 			$typeNode = new FullyQualified($reflectionType->getName());
 		}
 
-		$type = ParserNodeTypeToPHPStanType::resolve($typeNode, $selfClass);
+		$type = ParserNodeTypeToPHPStanType::resolve($typeNode, $selfClass, $isBuiltin);
 		if ($reflectionType->allowsNull()) {
 			$type = TypeCombinator::addNull($type);
 		}

diff --git a/tests/PHPStan/Analyser/Bug15185Test.php b/tests/PHPStan/Analyser/Bug15185Test.php
@@ -0,0 +1,36 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser;
+
+use PHPStan\Testing\TypeInferenceTestCase;
+use PHPUnit\Framework\Attributes\DataProvider;
+
+class Bug15185Test extends TypeInferenceTestCase
+{
+
+	public static function dataFileAsserts(): iterable
+	{
+		yield from self::gatherAssertTypes(__DIR__ . '/data/bug-15185.php');
+	}
+
+	/**
+	 * @param mixed ...$args
+	 */
+	#[DataProvider('dataFileAsserts')]
+	public function testFileAsserts(
+		string $assertType,
+		string $file,
+		...$args,
+	): void
+	{
+		$this->assertFileAsserts($assertType, $file, ...$args);
+	}
+
+	public static function getAdditionalConfigFiles(): array
+	{
+		return [
+			__DIR__ . '/nodeScopeResolverPhp7.neon',
+		];
+	}
+
+}
diff --git a/tests/PHPStan/Analyser/data/bug-15185.php b/tests/PHPStan/Analyser/data/bug-15185.php
@@ -0,0 +1,31 @@
+<?php declare(strict_types = 1);
+
+namespace Bug15185;
+
+use function PHPStan\Testing\assertType;
+
+function doFoo(string $connectionString, string $query): void
+{
+	$connection = pg_connect($connectionString);
+	if ($connection === false) {
+		return;
+	}
+
+	$result = pg_exec($connection, $query);
+	assertType('resource|false', $result);
+	if (is_resource($result)) {
+		assertType('resource', $result);
+	}
+}
+
+function doBar(): void
+{
+	$handle = curl_init();
+	assertType('(resource|false)', $handle);
+	if (is_resource($handle)) {
+		assertType('resource', $handle);
+	}
+
+	$info = curl_getinfo($handle, CURLINFO_HTTP_CODE);
+	assertType('int', $info);
+}