Introduce AccessoryNumericStringType

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\AccessoryNumericStringType;
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\BenevolentUnionType;
 use PHPStan\Type\BooleanType;
@@ -145,6 +146,22 @@ private function resolveIdentifierTypeNode(IdentifierTypeNode $typeNode, NameSco
 			case 'number':
 				return new UnionType([new IntegerType(), new FloatType()]);
 
+			case 'numeric':
+				return new UnionType([
+					new IntegerType(),
+					new FloatType(),
+					new IntersectionType([
+						new StringType(),
+						new AccessoryNumericStringType(),
+					]),
+				]);
+
+			case 'numeric-string':
+				return new IntersectionType([
+					new StringType(),
+					new AccessoryNumericStringType(),
+				]);
+
 			case 'bool':
 			case 'boolean':
 				return new BooleanType();

src/Rules/Comparison/ImpossibleCheckTypeHelper.php

@@ -12,7 +12,6 @@
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Type\Constant\ConstantArrayType;
 use PHPStan\Type\Constant\ConstantStringType;
-use PHPStan\Type\ErrorType;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\NeverType;
 use PHPStan\Type\ObjectType;
@@ -75,14 +74,6 @@ public function findSpecifiedType(
 				}
 				if ($functionName === 'count') {
 					return null;
-				} elseif ($functionName === 'is_numeric') {
-					$argType = $scope->getType($node->args[0]->value);
-					if (count(TypeUtils::getConstantScalars($argType)) > 0) {
-						return !$argType->toNumber() instanceof ErrorType;
-					}
-					if (TypeUtils::containsGeneralString($argType)) {
-						return null;
-					}
 				} elseif ($functionName === 'defined') {
 					return null;
 				} elseif (

src/Type/Accessory/AccessoryNumericStringType.php

@@ -0,0 +1,156 @@
+<?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\StringType;
+use PHPStan\Type\Traits\NonCallableTypeTrait;
+use PHPStan\Type\Traits\NonGenericTypeTrait;
+use PHPStan\Type\Traits\NonIterableTypeTrait;
+use PHPStan\Type\Traits\NonObjectTypeTrait;
+use PHPStan\Type\Traits\UndecidedBooleanTypeTrait;
+use PHPStan\Type\Type;
+use PHPStan\Type\UnionType;
+
+class AccessoryNumericStringType implements CompoundType, AccessoryType
+{
+
+	use NonCallableTypeTrait;
+	use NonObjectTypeTrait;
+	use NonIterableTypeTrait;
+	use UndecidedBooleanTypeTrait;
+	use NonGenericTypeTrait;
+
+	public function getReferencedClasses(): array
+	{
+		return [];
+	}
+
+	public function accepts(Type $type, bool $strictTypes): TrinaryLogic
+	{
+		if ($type instanceof CompoundType) {
+			return CompoundTypeHelper::accepts($type, $this, $strictTypes);
+		}
+
+		return $type->isNumericString();
+	}
+
+	public function isSuperTypeOf(Type $type): TrinaryLogic
+	{
+		if ($this->equals($type)) {
+			return TrinaryLogic::createYes();
+		}
+
+		return $type->isNumericString();
+	}
+
+	public function isSubTypeOf(Type $otherType): TrinaryLogic
+	{
+		if ($otherType instanceof UnionType || $otherType instanceof IntersectionType) {
+			return $otherType->isSuperTypeOf($this);
+		}
+
+		return $otherType->isNumericString()
+			->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 'numeric';
+	}
+
+	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): 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::createYes();
+	}
+
+	public function traverse(callable $cb): Type
+	{
+		return $this;
+	}
+
+	public static function __set_state(array $properties): Type
+	{
+		return new self();
+	}
+
+}

src/Type/Accessory/HasOffsetType.php

@@ -123,6 +123,11 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createMaybe();
 	}
 
+	public function isNumericString(): TrinaryLogic
+	{
+		return TrinaryLogic::createMaybe();
+	}
+
 	public function toNumber(): Type
 	{
 		return new ErrorType();

src/Type/Accessory/NonEmptyArrayType.php

@@ -123,6 +123,11 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createYes();
 	}
 
+	public function isNumericString(): TrinaryLogic
+	{
+		return TrinaryLogic::createNo();
+	}
+
 	public function toNumber(): Type
 	{
 		return new ErrorType();

src/Type/ArrayType.php

@@ -184,6 +184,11 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createYes();
 	}
 
+	public function isNumericString(): TrinaryLogic
+	{
+		return TrinaryLogic::createNo();
+	}
+
 	public function isOffsetAccessible(): TrinaryLogic
 	{
 		return TrinaryLogic::createYes();

src/Type/CallableType.php

@@ -290,6 +290,11 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createMaybe();
 	}
 
+	public function isNumericString(): TrinaryLogic
+	{
+		return TrinaryLogic::createNo();
+	}
+
 	/**
 	 * @param mixed[] $properties
 	 * @return Type

src/Type/ClosureType.php

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

src/Type/Constant/ConstantStringType.php

@@ -232,6 +232,11 @@ public function toFloat(): Type
 		return $type->toFloat();
 	}
 
+	public function isNumericString(): TrinaryLogic
+	{
+		return TrinaryLogic::createFromBoolean(is_numeric($this->getValue()));
+	}
+
 	public function hasOffsetValueType(Type $offsetType): TrinaryLogic
 	{
 		if ($offsetType instanceof ConstantIntegerType) {

src/Type/FloatType.php

@@ -121,6 +121,11 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createNo();
 	}
 
+	public function isNumericString(): TrinaryLogic
+	{
+		return TrinaryLogic::createNo();
+	}
+
 	public function traverse(callable $cb): Type
 	{
 		return $this;

src/Type/IntersectionType.php

@@ -273,6 +273,13 @@ public function isArray(): TrinaryLogic
 		});
 	}
 
+	public function isNumericString(): TrinaryLogic
+	{
+		return $this->intersectResults(static function (Type $type): TrinaryLogic {
+			return $type->isNumericString();
+		});
+	}
+
 	public function isOffsetAccessible(): TrinaryLogic
 	{
 		return $this->intersectResults(static function (Type $type): TrinaryLogic {

src/Type/IterableType.php

@@ -221,6 +221,11 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createMaybe();
 	}
 
+	public function isNumericString(): TrinaryLogic
+	{
+		return TrinaryLogic::createNo();
+	}
+
 	public function inferTemplateTypes(Type $receivedType): TemplateTypeMap
 	{
 		if ($receivedType instanceof UnionType || $receivedType instanceof IntersectionType) {

src/Type/JustNullableTypeTrait.php

@@ -56,4 +56,9 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createNo();
 	}
 
+	public function isNumericString(): TrinaryLogic
+	{
+		return TrinaryLogic::createNo();
+	}
+
 }

src/Type/MixedType.php

@@ -331,6 +331,11 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createMaybe();
 	}
 
+	public function isNumericString(): TrinaryLogic
+	{
+		return TrinaryLogic::createMaybe();
+	}
+
 	/**
 	 * @param mixed[] $properties
 	 * @return Type

src/Type/NeverType.php

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

src/Type/NullType.php

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

src/Type/ObjectType.php

@@ -564,6 +564,11 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createNo();
 	}
 
+	public function isNumericString(): TrinaryLogic
+	{
+		return TrinaryLogic::createNo();
+	}
+
 	private function isExtraOffsetAccessibleClass(): TrinaryLogic
 	{
 		$classReflection = $this->getClassReflection();

src/Type/Php/IsNumericFunctionTypeSpecifyingExtension.php

@@ -9,10 +9,10 @@
 use PHPStan\Analyser\TypeSpecifierAwareExtension;
 use PHPStan\Analyser\TypeSpecifierContext;
 use PHPStan\Reflection\FunctionReflection;
+use PHPStan\Type\Accessory\AccessoryNumericStringType;
 use PHPStan\Type\FloatType;
 use PHPStan\Type\FunctionTypeSpecifyingExtension;
 use PHPStan\Type\IntegerType;
-use PHPStan\Type\StringType;
 use PHPStan\Type\UnionType;
 
 class IsNumericFunctionTypeSpecifyingExtension implements FunctionTypeSpecifyingExtension, TypeSpecifierAwareExtension
@@ -39,7 +39,7 @@ public function specifyTypes(FunctionReflection $functionReflection, FuncCall $n
 		];
 
 		if ($context->truthy()) {
-			$numericTypes[] = new StringType();
+			$numericTypes[] = new AccessoryNumericStringType();
 		}
 
 		return $this->typeSpecifier->create($node->args[0]->value, new UnionType($numericTypes), $context);