More precise types after assignment when strict-types=0

src/Analyser/NodeScopeResolver.php

@@ -5628,24 +5628,25 @@ static function (): void {
 				$nodeCallback(new PropertyAssignNode($var, $assignedExpr, $isAssignOp), $scope);
 				if ($propertyReflection->canChangeTypeAfterAssignment()) {
 					if ($propertyReflection->hasNativeType()) {
-						$assignedNativeType = $scope->getNativeType($assignedExpr);
 						$propertyNativeType = $propertyReflection->getNativeType();
 
-						$assignedTypeIsCompatible = false;
-						foreach (TypeUtils::flattenTypes($propertyNativeType) as $type) {
-							if ($type->isSuperTypeOf($assignedNativeType)->yes()) {
-								$assignedTypeIsCompatible = true;
-								break;
+						$assignedTypeIsCompatible = $propertyNativeType->isSuperTypeOf($assignedExprType)->yes();
+						if (!$assignedTypeIsCompatible) {
+							foreach (TypeUtils::flattenTypes($propertyNativeType) as $type) {
+								if ($type->isSuperTypeOf($assignedExprType)->yes()) {
+									$assignedTypeIsCompatible = true;
+									break;
+								}
 							}
 						}
 
 						if ($assignedTypeIsCompatible) {
-							$scope = $scope->assignExpression($var, $assignedExprType, $assignedNativeType);
-						} elseif ($scope->isDeclareStrictTypes()) {
+							$scope = $scope->assignExpression($var, $assignedExprType, $scope->getNativeType($assignedExpr));
+						} else {
 							$scope = $scope->assignExpression(
 								$var,
-								TypeCombinator::intersect($assignedExprType->toCoercedArgumentType(true), $propertyNativeType),
-								TypeCombinator::intersect($assignedNativeType->toCoercedArgumentType(true), $propertyNativeType),
+								TypeCombinator::intersect($assignedExprType->toCoercedArgumentType($scope->isDeclareStrictTypes()), $propertyNativeType),
+								TypeCombinator::intersect($scope->getNativeType($assignedExpr)->toCoercedArgumentType($scope->isDeclareStrictTypes()), $propertyNativeType),
 							);
 						}
 					} else {
@@ -5716,24 +5717,25 @@ static function (): void {
 				$nodeCallback(new PropertyAssignNode($var, $assignedExpr, $isAssignOp), $scope);
 				if ($propertyReflection !== null && $propertyReflection->canChangeTypeAfterAssignment()) {
 					if ($propertyReflection->hasNativeType()) {
-						$assignedNativeType = $scope->getNativeType($assignedExpr);
 						$propertyNativeType = $propertyReflection->getNativeType();
+						$assignedTypeIsCompatible = $propertyNativeType->isSuperTypeOf($assignedExprType)->yes();
 
-						$assignedTypeIsCompatible = false;
-						foreach (TypeUtils::flattenTypes($propertyNativeType) as $type) {
-							if ($type->isSuperTypeOf($assignedNativeType)->yes()) {
-								$assignedTypeIsCompatible = true;
-								break;
+						if (!$assignedTypeIsCompatible) {
+							foreach (TypeUtils::flattenTypes($propertyNativeType) as $type) {
+								if ($type->isSuperTypeOf($assignedExprType)->yes()) {
+									$assignedTypeIsCompatible = true;
+									break;
+								}
 							}
 						}
 
 						if ($assignedTypeIsCompatible) {
-							$scope = $scope->assignExpression($var, $assignedExprType, $assignedNativeType);
-						} elseif ($scope->isDeclareStrictTypes()) {
+							$scope = $scope->assignExpression($var, $assignedExprType, $scope->getNativeType($assignedExpr));
+						} else {
 							$scope = $scope->assignExpression(
 								$var,
-								TypeCombinator::intersect($assignedExprType->toCoercedArgumentType(true), $propertyNativeType),
-								TypeCombinator::intersect($assignedNativeType->toCoercedArgumentType(true), $propertyNativeType),
+								TypeCombinator::intersect($assignedExprType->toCoercedArgumentType($scope->isDeclareStrictTypes()), $propertyNativeType),
+								TypeCombinator::intersect($scope->getNativeType($assignedExpr)->toCoercedArgumentType($scope->isDeclareStrictTypes()), $propertyNativeType),
 							);
 						}
 					} else {

src/Type/Accessory/AccessoryLiteralStringType.php

@@ -29,6 +29,7 @@
 use PHPStan\Type\Traits\NonRemoveableTypeTrait;
 use PHPStan\Type\Traits\UndecidedComparisonCompoundTypeTrait;
 use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\UnionType;
 use PHPStan\Type\VerbosityLevel;
 
@@ -215,6 +216,10 @@ public function toArrayKey(): Type
 
 	public function toCoercedArgumentType(bool $strictTypes): Type
 	{
+		if (!$strictTypes) {
+			return TypeCombinator::union($this->toInteger(), $this->toFloat(), $this, $this->toBoolean());
+		}
+
 		return $this;
 	}
 

src/Type/Accessory/AccessoryLowercaseStringType.php

@@ -29,6 +29,7 @@
 use PHPStan\Type\Traits\NonRemoveableTypeTrait;
 use PHPStan\Type\Traits\UndecidedComparisonCompoundTypeTrait;
 use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\UnionType;
 use PHPStan\Type\VerbosityLevel;
 
@@ -212,6 +213,10 @@ public function toArrayKey(): Type
 
 	public function toCoercedArgumentType(bool $strictTypes): Type
 	{
+		if (!$strictTypes) {
+			return TypeCombinator::union($this->toInteger(), $this->toFloat(), $this, $this->toBoolean());
+		}
+
 		return $this;
 	}
 

src/Type/Accessory/AccessoryNonEmptyStringType.php

@@ -213,6 +213,10 @@ public function toArrayKey(): Type
 
 	public function toCoercedArgumentType(bool $strictTypes): Type
 	{
+		if (!$strictTypes) {
+			return TypeCombinator::union($this->toInteger(), $this->toFloat(), $this, $this->toBoolean());
+		}
+
 		return $this;
 	}
 

src/Type/Accessory/AccessoryNonFalsyStringType.php

@@ -215,6 +215,10 @@ public function toArrayKey(): Type
 
 	public function toCoercedArgumentType(bool $strictTypes): Type
 	{
+		if (!$strictTypes) {
+			return TypeCombinator::union($this->toInteger(), $this->toFloat(), $this, $this->toBoolean());
+		}
+
 		return $this;
 	}
 

src/Type/Accessory/AccessoryNumericStringType.php

@@ -215,6 +215,10 @@ public function toArrayKey(): Type
 
 	public function toCoercedArgumentType(bool $strictTypes): Type
 	{
+		if (!$strictTypes) {
+			return TypeCombinator::union($this->toInteger(), $this->toFloat(), $this, $this->toBoolean());
+		}
+
 		return $this;
 	}
 

src/Type/Accessory/AccessoryUppercaseStringType.php

@@ -29,6 +29,7 @@
 use PHPStan\Type\Traits\NonRemoveableTypeTrait;
 use PHPStan\Type\Traits\UndecidedComparisonCompoundTypeTrait;
 use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\UnionType;
 use PHPStan\Type\VerbosityLevel;
 
@@ -212,6 +213,10 @@ public function toArrayKey(): Type
 
 	public function toCoercedArgumentType(bool $strictTypes): Type
 	{
+		if (!$strictTypes) {
+			return TypeCombinator::union($this->toInteger(), $this->toFloat(), $this, $this->toBoolean());
+		}
+
 		return $this;
 	}
 

src/Type/BooleanType.php

@@ -113,6 +113,10 @@ public function toArrayKey(): Type
 
 	public function toCoercedArgumentType(bool $strictTypes): Type
 	{
+		if (!$strictTypes) {
+			return TypeCombinator::union($this->toInteger(), $this->toFloat(), $this->toString(), $this);
+		}
+
 		return $this;
 	}
 

src/Type/CallableType.php

@@ -24,6 +24,7 @@
 use PHPStan\Reflection\Php\DummyParameter;
 use PHPStan\ShouldNotHappenException;
 use PHPStan\TrinaryLogic;
+use PHPStan\Type\Accessory\AccessoryNonEmptyStringType;
 use PHPStan\Type\Generic\TemplateType;
 use PHPStan\Type\Generic\TemplateTypeHelper;
 use PHPStan\Type\Generic\TemplateTypeMap;
@@ -331,7 +332,12 @@ public function toArrayKey(): Type
 
 	public function toCoercedArgumentType(bool $strictTypes): Type
 	{
-		return TypeCombinator::union($this, new StringType(), new ArrayType(new MixedType(true), new MixedType(true)), new ObjectType(Closure::class));
+		return TypeCombinator::union(
+			$this,
+			TypeCombinator::intersect(new StringType(), new AccessoryNonEmptyStringType()),
+			new ArrayType(new MixedType(true), new MixedType(true)),
+			new ObjectType(Closure::class),
+		);
 	}
 
 	public function isOffsetAccessLegal(): TrinaryLogic

src/Type/Constant/ConstantBooleanType.php

@@ -14,6 +14,7 @@
 use PHPStan\Type\StaticTypeFactory;
 use PHPStan\Type\Traits\ConstantScalarTypeTrait;
 use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\VerbosityLevel;
 
 /** @api */
@@ -109,6 +110,10 @@ public function toArrayKey(): Type
 
 	public function toCoercedArgumentType(bool $strictTypes): Type
 	{
+		if (!$strictTypes) {
+			return TypeCombinator::union($this->toInteger(), $this->toFloat(), $this->toString(), $this);
+		}
+
 		return $this;
 	}
 

src/Type/Constant/ConstantIntegerType.php

@@ -14,6 +14,7 @@
 use PHPStan\Type\Traits\ConstantNumericComparisonTypeTrait;
 use PHPStan\Type\Traits\ConstantScalarTypeTrait;
 use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\VerbosityLevel;
 use function abs;
 use function sprintf;
@@ -92,6 +93,15 @@ public function toArrayKey(): Type
 		return $this;
 	}
 
+	public function toCoercedArgumentType(bool $strictTypes): Type
+	{
+		if (!$strictTypes) {
+			return TypeCombinator::union($this, $this->toFloat(), $this->toString(), $this->toBoolean());
+		}
+
+		return TypeCombinator::union($this, $this->toFloat());
+	}
+
 	public function generalize(GeneralizePrecision $precision): Type
 	{
 		return new IntegerType();

src/Type/FloatType.php

@@ -145,6 +145,10 @@ public function toArrayKey(): Type
 
 	public function toCoercedArgumentType(bool $strictTypes): Type
 	{
+		if (!$strictTypes) {
+			return TypeCombinator::union($this->toInteger(), $this, $this->toString(), $this->toBoolean());
+		}
+
 		return $this;
 	}
 

src/Type/IntegerType.php

@@ -100,6 +100,10 @@ public function toArrayKey(): Type
 
 	public function toCoercedArgumentType(bool $strictTypes): Type
 	{
+		if (!$strictTypes) {
+			return TypeCombinator::union($this, $this->toFloat(), $this->toString(), $this->toBoolean());
+		}
+
 		return TypeCombinator::union($this, $this->toFloat());
 	}
 

src/Type/ObjectType.php

@@ -706,6 +706,18 @@ public function toArrayKey(): Type
 
 	public function toCoercedArgumentType(bool $strictTypes): Type
 	{
+		if (!$strictTypes) {
+			$classReflection = $this->getClassReflection();
+			if (
+				$classReflection === null
+				|| !$classReflection->hasNativeMethod('__toString')
+			) {
+				return $this;
+			}
+
+			return TypeCombinator::union($this, $this->toString());
+		}
+
 		return $this;
 	}
 

src/Type/StringType.php

@@ -183,6 +183,13 @@ public function toArrayKey(): Type
 
 	public function toCoercedArgumentType(bool $strictTypes): Type
 	{
+		if (!$strictTypes) {
+			if ($this->isNumericString()->no()) {
+				return TypeCombinator::union($this, $this->toBoolean());
+			}
+			return TypeCombinator::union($this->toInteger(), $this->toFloat(), $this, $this->toBoolean());
+		}
+
 		return $this;
 	}
 

src/Type/Traits/ObjectTypeTrait.php

@@ -21,6 +21,7 @@
 use PHPStan\Type\MixedType;
 use PHPStan\Type\StringType;
 use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
 
 trait ObjectTypeTrait
 {
@@ -275,6 +276,10 @@ public function toArrayKey(): Type
 
 	public function toCoercedArgumentType(bool $strictTypes): Type
 	{
+		if (!$strictTypes) {
+			return TypeCombinator::union($this, $this->toString());
+		}
+
 		return $this;
 	}
 

tests/PHPStan/Analyser/nsrt/bug-12393-php84.php

@@ -0,0 +1,23 @@
+<?php // lint >= 8.4
+
+declare(strict_types = 1);
+
+namespace Bug12393Php84;
+
+use function PHPStan\Testing\assertNativeType;
+use function PHPStan\Testing\assertType;
+
+
+class StringableFoo {
+	private string $foo;
+
+	// https://3v4l.org/2SPPj#v8.4.6
+	public function doFoo3(\BcMath\Number $foo): void {
+		$this->foo = $foo;
+		assertType('*NEVER*', $this->foo);
+	}
+
+	public function __toString(): string {
+		return 'Foo';
+	}
+}

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

@@ -143,3 +143,42 @@ public function getMixed()
 	}
 
 }
+
+// https://3v4l.org/LK6Rh
+class CallableString {
+	private string $foo;
+
+	public function doFoo(callable $foo): void {
+		$this->foo = $foo; // PHPStorm wrongly reports an error on this line
+		assertType('callable-string|non-empty-string', $this->foo);
+	}
+}
+
+// https://3v4l.org/WJ8NW
+class CallableArray {
+	private array $foo;
+
+	public function doFoo(callable $foo): void {
+		$this->foo = $foo;
+		assertType('array', $this->foo); // could be non-empty-array
+	}
+}
+
+class StringableFoo {
+	private string $foo;
+
+	// https://3v4l.org/DQSgA#v8.4.6
+	public function doFoo(StringableFoo $foo): void {
+		$this->foo = $foo;
+		assertType('*NEVER*', $this->foo);
+	}
+
+	public function doFoo2(NotStringable $foo): void {
+		$this->foo = $foo;
+		assertType('*NEVER*', $this->foo);
+	}
+
+	public function __toString(): string {
+		return 'Foo';
+	}
+}