literal-string in the type system

Author: ondrejmirtes

src/Analyser/MutatingScope.php

@@ -47,6 +47,7 @@
 use PHPStan\Reflection\TrivialParametersAcceptor;
 use PHPStan\Rules\Properties\PropertyReflectionFinder;
 use PHPStan\TrinaryLogic;
+use PHPStan\Type\Accessory\AccessoryLiteralStringType;
 use PHPStan\Type\Accessory\AccessoryNonEmptyStringType;
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\BenevolentUnionType;
@@ -1051,11 +1052,17 @@ private function resolveType(Expr $node): Type
 				return $leftStringType->append($rightStringType);
 			}
 
+			$accessoryTypes = [];
 			if ($leftStringType->isNonEmptyString()->or($rightStringType->isNonEmptyString())->yes()) {
-				return new IntersectionType([
-					new StringType(),
-					new AccessoryNonEmptyStringType(),
-				]);
+				$accessoryTypes[] = new AccessoryNonEmptyStringType();
+			}
+
+			if ($leftStringType->isLiteralString()->and($rightStringType->isLiteralString())->yes()) {
+				$accessoryTypes[] = new AccessoryLiteralStringType();
+			}
+
+			if (count($accessoryTypes) > 0) {
+				return new IntersectionType([new StringType(), ...$accessoryTypes]);
 			}
 
 			return new StringType();

src/PhpDoc/TypeNodeResolver.php

@@ -28,6 +28,7 @@
 use PHPStan\Reflection\Native\NativeParameterReflection;
 use PHPStan\Reflection\PassedByReference;
 use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Type\Accessory\AccessoryLiteralStringType;
 use PHPStan\Type\Accessory\AccessoryNonEmptyStringType;
 use PHPStan\Type\Accessory\AccessoryNumericStringType;
 use PHPStan\Type\Accessory\NonEmptyArrayType;
@@ -147,7 +148,7 @@ private function resolveIdentifierTypeNode(IdentifierTypeNode $typeNode, NameSco
 				return new StringType();
 
 			case 'literal-string':
-				return new StringType();
+				return new IntersectionType([new StringType(), new AccessoryLiteralStringType()]);
 
 			case 'class-string':
 				return new ClassStringType();

src/Type/Accessory/AccessoryLiteralStringType.php

@@ -0,0 +1,181 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Accessory;
+
+use PHPStan\TrinaryLogic;
+use PHPStan\Type\CompoundType;
+use PHPStan\Type\CompoundTypeHelper;
+use PHPStan\Type\Constant\ConstantArrayType;
+use PHPStan\Type\Constant\ConstantIntegerType;
+use PHPStan\Type\ErrorType;
+use PHPStan\Type\FloatType;
+use PHPStan\Type\IntegerType;
+use PHPStan\Type\IntersectionType;
+use PHPStan\Type\MixedType;
+use PHPStan\Type\StringType;
+use PHPStan\Type\Traits\MaybeCallableTypeTrait;
+use PHPStan\Type\Traits\NonGenericTypeTrait;
+use PHPStan\Type\Traits\NonIterableTypeTrait;
+use PHPStan\Type\Traits\NonObjectTypeTrait;
+use PHPStan\Type\Traits\TruthyBooleanTypeTrait;
+use PHPStan\Type\Traits\UndecidedComparisonCompoundTypeTrait;
+use PHPStan\Type\Type;
+use PHPStan\Type\UnionType;
+
+class AccessoryLiteralStringType implements CompoundType, AccessoryType
+{
+
+	use MaybeCallableTypeTrait;
+	use NonObjectTypeTrait;
+	use NonIterableTypeTrait;
+	use TruthyBooleanTypeTrait;
+	use UndecidedComparisonCompoundTypeTrait;
+	use NonGenericTypeTrait;
+
+	/** @api */
+	public function __construct()
+	{
+	}
+
+	public function getReferencedClasses(): array
+	{
+		return [];
+	}
+
+	public function accepts(Type $type, bool $strictTypes): TrinaryLogic
+	{
+		if ($type instanceof MixedType) {
+			return TrinaryLogic::createNo();
+		}
+		if ($type instanceof CompoundType) {
+			return CompoundTypeHelper::accepts($type, $this, $strictTypes);
+		}
+
+		return $type->isLiteralString();
+	}
+
+	public function isSuperTypeOf(Type $type): TrinaryLogic
+	{
+		if ($type instanceof CompoundType) {
+			return $type->isSubTypeOf($this);
+		}
+
+		if ($this->equals($type)) {
+			return TrinaryLogic::createYes();
+		}
+
+		return $type->isLiteralString();
+	}
+
+	public function isSubTypeOf(Type $otherType): TrinaryLogic
+	{
+		if ($otherType instanceof UnionType || $otherType instanceof IntersectionType) {
+			return $otherType->isSuperTypeOf($this);
+		}
+
+		return $otherType->isLiteralString()
+			->and($otherType instanceof self ? TrinaryLogic::createYes() : TrinaryLogic::createMaybe());
+	}
+
+	public function isAcceptedBy(Type $acceptingType, bool $strictTypes): TrinaryLogic
+	{
+		return $this->isSubTypeOf($acceptingType);
+	}
+
+	public function equals(Type $type): bool
+	{
+		return $type instanceof self;
+	}
+
+	public function describe(\PHPStan\Type\VerbosityLevel $level): string
+	{
+		return 'literal-string';
+	}
+
+	public function isOffsetAccessible(): TrinaryLogic
+	{
+		return TrinaryLogic::createYes();
+	}
+
+	public function hasOffsetValueType(Type $offsetType): TrinaryLogic
+	{
+		return (new IntegerType())->isSuperTypeOf($offsetType)->and(TrinaryLogic::createMaybe());
+	}
+
+	public function getOffsetValueType(Type $offsetType): Type
+	{
+		if ($this->hasOffsetValueType($offsetType)->no()) {
+			return new ErrorType();
+		}
+
+		return new StringType();
+	}
+
+	public function setOffsetValueType(?Type $offsetType, Type $valueType, bool $unionValues = true): Type
+	{
+		return $this;
+	}
+
+	public function isArray(): TrinaryLogic
+	{
+		return TrinaryLogic::createNo();
+	}
+
+	public function toNumber(): Type
+	{
+		return new UnionType([
+			$this->toInteger(),
+			$this->toFloat(),
+		]);
+	}
+
+	public function toInteger(): Type
+	{
+		return new IntegerType();
+	}
+
+	public function toFloat(): Type
+	{
+		return new FloatType();
+	}
+
+	public function toString(): Type
+	{
+		return $this;
+	}
+
+	public function toArray(): Type
+	{
+		return new ConstantArrayType(
+			[new ConstantIntegerType(0)],
+			[$this],
+			1
+		);
+	}
+
+	public function isNumericString(): TrinaryLogic
+	{
+		return TrinaryLogic::createMaybe();
+	}
+
+	public function isNonEmptyString(): TrinaryLogic
+	{
+		return TrinaryLogic::createMaybe();
+	}
+
+	public function isLiteralString(): TrinaryLogic
+	{
+		return TrinaryLogic::createYes();
+	}
+
+	public function traverse(callable $cb): Type
+	{
+		return $this;
+	}
+
+	public static function __set_state(array $properties): Type
+	{
+		return new self();
+	}
+
+}

src/Type/Accessory/AccessoryNonEmptyStringType.php

@@ -163,6 +163,11 @@ public function isNonEmptyString(): TrinaryLogic
 		return TrinaryLogic::createYes();
 	}
 
+	public function isLiteralString(): TrinaryLogic
+	{
+		return TrinaryLogic::createMaybe();
+	}
+
 	public function traverse(callable $cb): Type
 	{
 		return $this;

src/Type/Accessory/AccessoryNumericStringType.php

@@ -159,6 +159,11 @@ public function isNonEmptyString(): TrinaryLogic
 		return TrinaryLogic::createYes();
 	}
 
+	public function isLiteralString(): TrinaryLogic
+	{
+		return TrinaryLogic::createMaybe();
+	}
+
 	public function traverse(callable $cb): Type
 	{
 		return $this;

src/Type/Accessory/HasOffsetType.php

@@ -136,6 +136,11 @@ public function isNonEmptyString(): TrinaryLogic
 		return TrinaryLogic::createMaybe();
 	}
 
+	public function isLiteralString(): TrinaryLogic
+	{
+		return TrinaryLogic::createMaybe();
+	}
+
 	public function toNumber(): Type
 	{
 		return new ErrorType();

src/Type/Accessory/NonEmptyArrayType.php

@@ -142,6 +142,11 @@ public function isNonEmptyString(): TrinaryLogic
 		return TrinaryLogic::createNo();
 	}
 
+	public function isLiteralString(): TrinaryLogic
+	{
+		return TrinaryLogic::createNo();
+	}
+
 	public function toNumber(): Type
 	{
 		return new ErrorType();

src/Type/ArrayType.php

@@ -200,6 +200,11 @@ public function isNonEmptyString(): TrinaryLogic
 		return TrinaryLogic::createNo();
 	}
 
+	public function isLiteralString(): TrinaryLogic
+	{
+		return TrinaryLogic::createNo();
+	}
+
 	public function isOffsetAccessible(): TrinaryLogic
 	{
 		return TrinaryLogic::createYes();

src/Type/ClassStringType.php

@@ -75,6 +75,11 @@ public function isNonEmptyString(): TrinaryLogic
 		return TrinaryLogic::createYes();
 	}
 
+	public function isLiteralString(): TrinaryLogic
+	{
+		return TrinaryLogic::createMaybe();
+	}
+
 	/**
 	 * @param mixed[] $properties
 	 * @return Type

src/Type/ClosureType.php

@@ -411,6 +411,11 @@ public function isNonEmptyString(): TrinaryLogic
 		return TrinaryLogic::createNo();
 	}
 
+	public function isLiteralString(): TrinaryLogic
+	{
+		return TrinaryLogic::createNo();
+	}
+
 	/**
 	 * @param mixed[] $properties
 	 * @return Type