Fix fatal error on constant('')

conf/config.neon

@@ -175,6 +175,7 @@ parameters:
 		- ../stubs/ext-ds.stub
 		- ../stubs/ImagickPixel.stub
 		- ../stubs/PDOStatement.stub
+		- ../stubs/PhpParserName.stub
 		- ../stubs/date.stub
 		- ../stubs/ibm_db2.stub
 		- ../stubs/mysqli.stub

src/Analyser/MutatingScope.php

@@ -171,6 +171,7 @@ class MutatingScope implements Scope
 	/** @var array<string, self> */
 	private array $falseyScopes = [];
 
+	/** @var non-empty-string|null */
 	private ?string $namespace;
 
 	private ?self $scopeOutOfFirstLevelStatement = null;
@@ -5172,6 +5173,9 @@ public function debug(): array
 		return $descriptions;
 	}
 
+	/**
+	 * @param non-empty-string $className
+	 */
 	private function exactInstantiation(New_ $node, string $className): ?Type
 	{
 		$resolvedClassName = $this->resolveExactName(new Name($className));

src/Analyser/NameScope.php

@@ -24,6 +24,7 @@ class NameScope
 
 	/**
 	 * @api
+	 * @param non-empty-string|null $namespace
 	 * @param array<string, string> $uses alias(string) => fullName(string)
 	 * @param array<string, string> $constUses alias(string) => fullName(string)
 	 * @param array<string, true> $typeAliasesMap

src/Analyser/NodeScopeResolver.php

@@ -1764,6 +1764,9 @@ static function (Node $node, Scope $scope) use ($nodeCallback): void {
 				if ($const->namespacedName !== null) {
 					$constantName = new Name\FullyQualified($const->namespacedName->toString());
 				} else {
+					if ($const->name->toString() === '') {
+						throw new ShouldNotHappenException('Constant cannot have a empty name');
+					}
 					$constantName = new Name\FullyQualified($const->name->toString());
 				}
 				$scope = $scope->assignExpression(new ConstFetch($constantName), $scope->getType($const->value), $scope->getNativeType($const->value));

src/Analyser/TypeSpecifier.php

@@ -2009,6 +2009,7 @@ public function resolveIdentical(Expr\BinaryOp\Identical $expr, Scope $scope, Ty
 			$unwrappedLeftExpr->name instanceof Node\Identifier &&
 			$unwrappedRightExpr instanceof ClassConstFetch &&
 			$rightType instanceof ConstantStringType &&
+			$rightType->getValue() !== '' &&
 			strtolower($unwrappedLeftExpr->name->toString()) === 'class'
 		) {
 			return $this->specifyTypesInCondition(
@@ -2030,6 +2031,7 @@ public function resolveIdentical(Expr\BinaryOp\Identical $expr, Scope $scope, Ty
 			$unwrappedRightExpr->name instanceof Node\Identifier &&
 			$unwrappedLeftExpr instanceof ClassConstFetch &&
 			$leftType instanceof ConstantStringType &&
+			$leftType->getValue() !== '' &&
 			strtolower($unwrappedRightExpr->name->toString()) === 'class'
 		) {
 			return $this->specifyTypesInCondition(

src/Reflection/InitializerExprContext.php

@@ -8,6 +8,7 @@
 use PHPStan\BetterReflection\Reflection\Adapter\ReflectionFunction;
 use PHPStan\BetterReflection\Reflection\Adapter\ReflectionParameter;
 use PHPStan\BetterReflection\Reflection\ReflectionConstant;
+use PHPStan\ShouldNotHappenException;
 use function array_slice;
 use function count;
 use function explode;
@@ -18,6 +19,9 @@
 class InitializerExprContext implements NamespaceAnswerer
 {
 
+	/**
+	 * @param non-empty-string|null $namespace
+	 */
 	private function __construct(
 		private ?string $file,
 		private ?string $namespace,
@@ -43,11 +47,18 @@ public static function fromScope(Scope $scope): self
 		);
 	}
 
+	/**
+	 * @return non-empty-string|null
+	 */
 	private static function parseNamespace(string $name): ?string
 	{
 		$parts = explode('\\', $name);
 		if (count($parts) > 1) {
-			return implode('\\', array_slice($parts, 0, -1));
+			$ns = implode('\\', array_slice($parts, 0, -1));
+			if ($ns === '') {
+				throw new ShouldNotHappenException('Namespace cannot be empty.');
+			}
+			return $ns;
 		}
 
 		return null;
@@ -127,6 +138,10 @@ public static function fromStubParameter(
 
 	public static function fromGlobalConstant(ReflectionConstant $constant): self
 	{
+		if ($constant->getNamespaceName() === '') {
+			throw new ShouldNotHappenException('Namespace cannot be empty.');
+		}
+
 		return new self(
 			$constant->getFileName(),
 			$constant->getNamespaceName(),

src/Reflection/NamespaceAnswerer.php

@@ -6,6 +6,9 @@
 interface NamespaceAnswerer
 {
 
+	/**
+	 * @return non-empty-string|null
+	 */
 	public function getNamespace(): ?string;
 
 }

src/Rules/Generics/TemplateTypeCheck.php

@@ -11,6 +11,7 @@
 use PHPStan\Rules\ClassNameNodePair;
 use PHPStan\Rules\IdentifierRuleError;
 use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\ShouldNotHappenException;
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\BooleanType;
 use PHPStan\Type\Constant\ConstantArrayType;
@@ -66,6 +67,10 @@ public function check(
 	{
 		$messages = [];
 		foreach ($templateTags as $templateTag) {
+			if ($templateTag->getName() === '') {
+				throw new ShouldNotHappenException('Template tag name cannot be empty.');
+			}
+
 			$templateTagName = $scope->resolveName(new Node\Name($templateTag->getName()));
 			if ($this->reflectionProvider->hasClass($templateTagName)) {
 				$messages[] = RuleErrorBuilder::message(sprintf(

src/Type/BitwiseFlagHelper.php

@@ -18,6 +18,9 @@ public function __construct(private ReflectionProvider $reflectionProvider)
 	{
 	}
 
+	/**
+	 * @param non-empty-string $constName
+	 */
 	public function bitwiseOrContainsConstant(Expr $expr, Scope $scope, string $constName): TrinaryLogic
 	{
 		if ($expr instanceof ConstFetch) {

src/Type/Constant/ConstantStringType.php

@@ -238,6 +238,10 @@ public function isCallable(): TrinaryLogic
 
 	public function getCallableParametersAcceptors(ClassMemberAccessAnswerer $scope): array
 	{
+		if ($this->value === '') {
+			return [];
+		}
+
 		$reflectionProvider = ReflectionProviderStaticAccessor::getInstance();
 
 		// 'my_function'

src/Type/FileTypeMapper.php

@@ -482,6 +482,10 @@ function (Node $node) use ($fileName, $lookForTrait, $phpDocNodeMap, &$traitFoun
 				$functionName = $functionStack[count($functionStack) - 1] ?? null;
 				$nameScopeKey = $this->getNameScopeKey($originalClassFileName, $className, $lookForTrait, $functionName);
 
+				if ($namespace === '') {
+					throw new ShouldNotHappenException('Namespace cannot be empty.');
+				}
+
 				if ($node instanceof Node\Stmt\ClassLike || $node instanceof Node\Stmt\ClassMethod || $node instanceof Node\Stmt\Function_) {
 					if (array_key_exists($nameScopeKey, $phpDocNodeMap)) {
 						$phpDocNode = $phpDocNodeMap[$nameScopeKey];

src/Type/ObjectType.php

@@ -259,6 +259,9 @@ public function getReferencedClasses(): array
 
 	public function getObjectClassNames(): array
 	{
+		if ($this->className === '') {
+			return [];
+		}
 		return [$this->className];
 	}
 

src/Type/Php/ArrayFilterFunctionReturnTypeReturnTypeExtension.php

@@ -33,8 +33,8 @@
 use function array_map;
 use function count;
 use function is_string;
+use function ltrim;
 use function strtolower;
-use function substr;
 
 class ArrayFilterFunctionReturnTypeReturnTypeExtension implements DynamicFunctionReturnTypeExtension
 {
@@ -245,7 +245,16 @@ private function processKeyAndItemType(MutatingScope $scope, Type $keyType, Type
 	private static function createFunctionName(string $funcName): Name
 	{
 		if ($funcName[0] === '\\') {
-			return new Name\FullyQualified(substr($funcName, 1));
+			$fqcn = ltrim($funcName, '\\');
+			if ($fqcn === '') {
+				throw new ShouldNotHappenException();
+			}
+
+			return new Name\FullyQualified($fqcn);
+		}
+
+		if ($funcName === '') {
+			throw new ShouldNotHappenException();
 		}
 
 		return new Name($funcName);

src/Type/Php/ConstantFunctionReturnTypeExtension.php

@@ -36,6 +36,9 @@ public function getTypeFromFunctionCall(
 
 		$results = [];
 		foreach ($nameType->getConstantStrings() as $constantName) {
+			if ($constantName->getValue() === '') {
+				return null;
+			}
 			$results[] = $scope->getType($this->constantHelper->createExprFromConstantName($constantName->getValue()));
 		}
 

src/Type/Php/ConstantHelper.php

@@ -8,18 +8,27 @@
 use PhpParser\Node\Identifier;
 use PhpParser\Node\Name;
 use PhpParser\Node\Name\FullyQualified;
+use PHPStan\ShouldNotHappenException;
 use function count;
 use function explode;
 use function ltrim;
 
 class ConstantHelper
 {
 
+	/**
+	 * @param non-empty-string $constantName
+	 */
 	public function createExprFromConstantName(string $constantName): Expr
 	{
 		$classConstParts = explode('::', $constantName);
 		if (count($classConstParts) >= 2) {
-			$classConstName = new FullyQualified(ltrim($classConstParts[0], '\\'));
+			$fqcn = ltrim($classConstParts[0], '\\');
+			if ($fqcn === '') {
+				throw new ShouldNotHappenException();
+			}
+
+			$classConstName = new FullyQualified($fqcn);
 			if ($classConstName->isSpecialClassName()) {
 				$classConstName = new Name($classConstName->toString());
 			}

src/Type/Php/FilterFunctionReturnTypeHelper.php

@@ -235,6 +235,9 @@ private function getFilterTypeOptions(): array
 		return $this->filterTypeOptions;
 	}
 
+	/**
+	 * @param non-empty-string $constantName
+	 */
 	private function getConstant(string $constantName): int
 	{
 		$constant = $this->reflectionProvider->getConstant(new Node\Name($constantName), null);

src/Type/Php/PathinfoFunctionDynamicReturnTypeExtension.php

@@ -65,6 +65,9 @@ public function getTypeFromFunctionCall(
 		return TypeCombinator::union($arrayType, new StringType());
 	}
 
+	/**
+	 * @param non-empty-string $constantName
+	 */
 	private function getConstant(string $constantName): ?int
 	{
 		if (!$this->reflectionProvider->hasConstant(new Node\Name($constantName), null)) {

src/Type/Php/ReflectionFunctionConstructorThrowTypeExtension.php

@@ -34,6 +34,10 @@ public function getThrowTypeFromStaticMethodCall(MethodReflection $methodReflect
 
 		$valueType = $scope->getType($methodCall->getArgs()[0]->value);
 		foreach ($valueType->getConstantStrings() as $constantString) {
+			if ($constantString->getValue() === '') {
+				return null;
+			}
+
 			if (!$this->reflectionProvider->hasFunction(new Name($constantString->getValue()), $scope)) {
 				return $methodReflection->getThrowType();
 			}

src/Type/Type.php

@@ -32,7 +32,7 @@ interface Type
 	 */
 	public function getReferencedClasses(): array;
 
-	/** @return list<string> */
+	/** @return list<non-empty-string> */
 	public function getObjectClassNames(): array;
 
 	/**

stubs/PhpParserName.stub

@@ -0,0 +1,25 @@
+<?php declare(strict_types=1);
+
+namespace PhpParser\Node;
+
+use PhpParser\NodeAbstract;
+
+class Name extends NodeAbstract
+{
+    /**
+     * Constructs a name node.
+     *
+     * @param non-empty-string|non-empty-array<string>|self $name       Name as string, part array or Name instance (copy ctor)
+     * @param array<mixed>                $attributes Additional attributes
+     */
+    public function __construct($name, array $attributes = []) {
+    }
+
+    /** @return non-empty-string */
+    public function toString() : string {
+    }
+
+    /** @return non-empty-string */
+    public function toCodeString() : string {
+    }
+}

tests/PHPStan/Analyser/AnalyserIntegrationTest.php

@@ -1330,6 +1330,12 @@ public function testBug10772(): void
 		$this->assertNoErrors($errors);
 	}
 
+	public function testBug10867(): void
+	{
+		$errors = $this->runAnalyse(__DIR__ . '/data/bug-10867.php');
+		$this->assertNoErrors($errors);
+	}
+
 	/**
 	 * @param string[]|null $allAnalysedFiles
 	 * @return Error[]

tests/PHPStan/Analyser/TypeSpecifierTest.php

@@ -1324,11 +1324,17 @@ private function toReadableResult(SpecifiedTypes $specifiedTypes): array
 		return $descriptions;
 	}
 
+	/**
+	 * @param non-empty-string $className
+	 */
 	private function createInstanceOf(string $className, string $variableName = 'foo'): Expr\Instanceof_
 	{
 		return new Expr\Instanceof_(new Variable($variableName), new Name($className));
 	}
 
+	/**
+	 * @param non-empty-string $functionName
+	 */
 	private function createFunctionCall(string $functionName, string $variableName = 'foo'): FuncCall
 	{
 		return new FuncCall(new Name($functionName), [new Arg(new Variable($variableName))]);

tests/PHPStan/Analyser/data/bug-10867.php

@@ -0,0 +1,10 @@
+<?php
+namespace Bug10867;
+
+function doFoo():void {
+	$sysERR = '';
+?>
+
+<p><?php  echo constant($sysERR); ?></p>
+<?php
+}

tests/PHPStan/Reflection/FunctionReflectionTest.php

@@ -37,6 +37,8 @@ public function dataPhpdocFunctions(): iterable
 
 	/**
 	 * @dataProvider dataPhpdocFunctions
+	 *
+	 * @param non-empty-string $functionName
 	 */
 	public function testFunctionHasPhpdoc(string $functionName, ?string $expectedDoc): void
 	{
@@ -139,6 +141,7 @@ public function dataFunctionReturnsByReference(): iterable
 
 	/**
 	 * @dataProvider dataFunctionReturnsByReference
+	 * @param non-empty-string $functionName
 	 */
 	public function testFunctionReturnsByReference(string $functionName, TrinaryLogic $expectedReturnsByRef): void
 	{

tests/PHPStan/Reflection/ReflectionProviderGoldenTest.php

@@ -73,6 +73,10 @@ private static function generateSymbolDescription(string $symbol): string
 	{
 		[$type, $name] = explode(' ', $symbol);
 
+		if ($name === '') {
+			throw new ShouldNotHappenException();
+		}
+
 		try {
 			switch ($type) {
 				case 'FUNCTION':
@@ -152,6 +156,9 @@ private static function getPhpSymbolsFile(): string
 		return __DIR__ . '/data/golden/phpSymbols.txt';
 	}
 
+	/**
+	 * @param non-empty-string $functionName
+	 */
 	private static function generateFunctionDescription(string $functionName): string
 	{
 		$nameNode = new Name($functionName);