diff --git a/.github/workflows/e2e-tests.yml b/.github/workflows/e2e-tests.yml index ae29efb84c7..52915482eed 100644 --- a/.github/workflows/e2e-tests.yml +++ b/.github/workflows/e2e-tests.yml @@ -744,6 +744,10 @@ jobs: ../../bin/phpstan clear-result-cache ../bashunit -a exit_code "0" "../../bin/phpstan analyse --error-format=raw -c with-full-baseline.neon" ../bashunit -a exit_code "0" "../../bin/phpstan analyse --error-format=raw -c with-full-baseline.neon" + - script: | + cd e2e/bug-12585 + composer install + ../../bin/phpstan - script: | cd e2e/result-cache-meta-extension composer install @@ -1522,6 +1526,10 @@ jobs: OUTPUT=$(../bashunit -a exit_code "1" "../../bin/phpstan analyse --no-progress") echo "$OUTPUT" ../bashunit -a contains 'killed by signal 9 (SIGKILL)' "$OUTPUT" + - script: | + cd e2e/parameter-type-extension + composer install + ../../bin/phpstan analyze steps: - name: Harden the runner (Audit all outbound calls) diff --git a/e2e/bug-12585/.gitignore b/e2e/bug-12585/.gitignore new file mode 100644 index 00000000000..8b7ef350326 --- /dev/null +++ b/e2e/bug-12585/.gitignore @@ -0,0 +1,2 @@ +/vendor +composer.lock diff --git a/e2e/bug-12585/composer.json b/e2e/bug-12585/composer.json new file mode 100644 index 00000000000..a072011fe86 --- /dev/null +++ b/e2e/bug-12585/composer.json @@ -0,0 +1,5 @@ +{ + "autoload-dev": { + "classmap": ["src/"] + } +} diff --git a/e2e/bug-12585/phpstan.neon b/e2e/bug-12585/phpstan.neon new file mode 100644 index 00000000000..a463d651063 --- /dev/null +++ b/e2e/bug-12585/phpstan.neon @@ -0,0 +1,10 @@ +parameters: + level: 8 + paths: + - src + +services: + - + class: Bug12585\EloquentBuilderRelationParameterExtension + tags: + - phpstan.dynamicMethodParameterTypeExtension diff --git a/e2e/bug-12585/src/extension.php b/e2e/bug-12585/src/extension.php new file mode 100644 index 00000000000..285e732b1a3 --- /dev/null +++ b/e2e/bug-12585/src/extension.php @@ -0,0 +1,255 @@ + */ + private array $methods = ['whereHas', 'withWhereHas']; + + public function __construct(private ReflectionProvider $reflectionProvider) + { + } + + public function isMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool + { + if (! $methodReflection->getDeclaringClass()->is(Builder::class)) { + return false; + } + + if (! in_array($methodReflection->getName(), $this->methods, strict: true)) { + return false; + } + + return $parameter->getName() === 'callback'; + } + + public function getTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, ParameterReflection $parameter, Scope $scope): Type|null + { + $method = $methodReflection->getName(); + $relations = $this->getRelationsFromMethodCall($methodCall, $scope); + $models = $this->getModelsFromRelations($relations); + + if (count($models) === 0) { + return null; + } + + $type = $this->getBuilderTypeForModels($models); + + if ($method === 'withWhereHas') { + $type = TypeCombinator::union($type, ...$relations); + } + + return new ClosureType([new ClosureQueryParameter('query', $type)], new MixedType(), false); + } + + /** + * @param array $relations + * @return array + */ + private function getModelsFromRelations(array $relations): array + { + $models = []; + + foreach ($relations as $relation) { + $classNames = $relation->getTemplateType(Relation::class, 'TRelatedModel')->getObjectClassNames(); + foreach ($classNames as $className) { + $models[] = $className; + } + } + + return $models; + } + + /** @return array */ + private function getRelationsFromMethodCall(MethodCall $methodCall, Scope $scope): array + { + $relationType = null; + + foreach ($methodCall->args as $arg) { + if ($arg instanceof VariadicPlaceholder) { + continue; + } + + if ($arg->name === null || $arg->name->toString() === 'relation') { + $relationType = $scope->getType($arg->value); + break; + } + } + + if ($relationType === null) { + return []; + } + + $calledOnModels = $scope->getType($methodCall->var) + ->getTemplateType(Builder::class, 'TModel') + ->getObjectClassNames(); + + $values = array_map(fn ($type) => $type->getValue(), $relationType->getConstantStrings()); + $relationTypes = [$relationType]; + + foreach ($values as $relation) { + $relationTypes = array_merge( + $relationTypes, + $this->getRelationTypeFromString($calledOnModels, explode('.', $relation), $scope) + ); + } + + return array_values(array_filter( + $relationTypes, + static fn ($r) => (new ObjectType(Relation::class))->isSuperTypeOf($r)->yes() + )); + } + + /** + * @param list $calledOnModels + * @param list $relationParts + * @return list + */ + private function getRelationTypeFromString(array $calledOnModels, array $relationParts, Scope $scope): array + { + $relations = []; + + while ($relationName = array_shift($relationParts)) { + $relations = []; + $relatedModels = []; + + foreach ($calledOnModels as $model) { + $modelType = new ObjectType($model); + + if (! $modelType->hasMethod($relationName)->yes()) { + continue; + } + + $relationType = $modelType->getMethod($relationName, $scope)->getVariants()[0]->getReturnType(); + + if (! (new ObjectType(Relation::class))->isSuperTypeOf($relationType)->yes()) { + continue; + } + + $relations[] = $relationType; + + array_push($relatedModels, ...$relationType->getTemplateType(Relation::class, 'TRelatedModel')->getObjectClassNames()); + } + + $calledOnModels = $relatedModels; + } + + return $relations; + } + + private function determineBuilderName(string $modelClassName): string + { + $method = $this->reflectionProvider->getClass($modelClassName)->getNativeMethod('query'); + + $returnType = $method->getVariants()[0]->getReturnType(); + + if (in_array(Builder::class, $returnType->getReferencedClasses(), true)) { + return Builder::class; + } + + $classNames = $returnType->getObjectClassNames(); + + if (count($classNames) === 1) { + return $classNames[0]; + } + + return $returnType->describe(VerbosityLevel::value()); + } + + /** + * @param array|string|TypeWithClassName $models + * @return ($models is array ? Type : ObjectType) + */ + private function getBuilderTypeForModels(array|string|TypeWithClassName $models): Type + { + $models = is_array($models) ? $models : [$models]; + $models = array_unique($models, SORT_REGULAR); + + $mappedModels = []; + foreach ($models as $model) { + if (is_string($model)) { + $mappedModels[$model] = new ObjectType($model); + } else { + $mappedModels[$model->getClassName()] = $model; + } + } + + $groupedByBuilder = []; + foreach ($mappedModels as $class => $type) { + $builderName = $this->determineBuilderName($class); + $groupedByBuilder[$builderName][] = $type; + } + + $builderTypes = []; + foreach ($groupedByBuilder as $builder => $models) { + $builderReflection = $this->reflectionProvider->getClass($builder); + + $builderTypes[] = $builderReflection->isGeneric() + ? new GenericObjectType($builder, [TypeCombinator::union(...$models)]) + : new ObjectType($builder); + } + + return TypeCombinator::union(...$builderTypes); + } +} + +final class ClosureQueryParameter implements ParameterReflection +{ + public function __construct(private string $name, private Type $type) + { + } + + public function getName(): string + { + return $this->name; + } + + public function isOptional(): bool + { + return false; + } + + public function getType(): Type + { + return $this->type; + } + + public function passedByReference(): PassedByReference + { + return PassedByReference::createNo(); + } + + public function isVariadic(): bool + { + return false; + } + + public function getDefaultValue(): Type|null + { + return null; + } +} diff --git a/e2e/bug-12585/src/test.php b/e2e/bug-12585/src/test.php new file mode 100644 index 00000000000..f665ac47c2c --- /dev/null +++ b/e2e/bug-12585/src/test.php @@ -0,0 +1,199 @@ + $related + * @return BelongsTo + */ + public function belongsTo(string $related): BelongsTo + { + return new BelongsTo(); // @phpstan-ignore return.type + } + + /** + * @template T of Model + * @param class-string $related + * @return HasMany + */ + public function hasMany(string $related): HasMany + { + return new HasMany(); // @phpstan-ignore return.type + } + + /** @return Builder */ + public static function query(): Builder + { + return new Builder(new static()); + } +} + +/** @template TModel of Model */ +class Builder +{ + /** @param TModel $model */ + final public function __construct(protected Model $model) + { + } + + /** + * @param (\Closure(static): mixed)|string $column + * @return $this + */ + public function where(Closure|string $column, mixed $value = null) + { + return $this; + } + + /** + * @template TRelatedModel of Model + * + * @param Relation|string $relation + * @param (\Closure(Builder): mixed)|null $callback + * @return $this + */ + public function whereHas($relation, ?Closure $callback = null) + { + return $this; + } + + /** + * @param string $relation + * @param (\Closure(Builder<*>|Relation<*, *>): mixed)|null $callback + * @return $this + */ + public function withWhereHas($relation, ?Closure $callback = null) + { + return $this; + } + + /** + * @template T of Model + * @param T $model + * @return self + */ + public static function create(Model $model): self + { + return new self($model); + } +} + +/** + * @template TRelatedModel of Model + * @template TDeclaringModel of Model + * @mixin Builder + */ +abstract class Relation +{ +} + +/** + * @template TRelatedModel of Model + * @template TDeclaringModel of Model + * @extends Relation + */ +class BelongsTo extends Relation +{ +} + +/** + * @template TRelatedModel of Model + * @template TDeclaringModel of Model + * @extends Relation + */ +class HasMany extends Relation +{ +} + +final class User extends Model +{ + /** @return HasMany */ + public function posts(): HasMany + { + return $this->hasMany(Post::class); + } + +} + +final class Post extends Model +{ + /** @return BelongsTo */ + public function user(): BelongsTo + { + return $this->belongsTo(User::class); + } + + public static function query(): PostBuilder + { + return new PostBuilder(new self()); + } +} + +/** @extends Builder */ +class PostBuilder extends Builder +{ +} + +function test(): void +{ + User::query()->whereHas('posts', function ($query) { + assertType('Bug12585\PostBuilder', $query); + }); + User::query()->whereHas('posts', function (Builder $query) { + return $query->where('name', 'test'); + }); + User::query()->whereHas('posts', function (PostBuilder $query) { + return $query->where('name', 'test'); + }); + User::query()->whereHas('posts', fn (Builder $q) => $q->where('name', 'test')); + User::query()->whereHas('posts', fn (PostBuilder $q) => $q->where('name', 'test')); + + Post::query()->whereHas('user', fn ($q) => $q->where('name', 'test')); + Post::query()->withWhereHas('user', function ($query) { + assertType('Bug12585\BelongsTo|Bug12585\Builder', $query); + }); + Post::query()->withWhereHas('user', fn (Builder|Relation $q) => $q->where('name', 'test')); + Post::query()->withWhereHas('user', fn (Builder|BelongsTo $q) => $q->where('name', 'test')); +} + +function testNullsafeMethodCall(): void +{ + $userOrNull = rand() ? User::query() : null; + $userOrNull?->whereHas('posts', function ($query) { + assertType('Bug12585\PostBuilder', $query); + }); +} + +function testNullOrObject(): void +{ + /** @var Builder|null $builderOrNull */ + $builderOrNull = null; + $builderOrNull?->whereHas('posts', function ($query) { + assertType('Bug12585\PostBuilder', $query); + }); +} + +function testNew(): void +{ + (new Builder(new User()))->whereHas('posts', function ($query) { + assertType('Bug12585\PostBuilder', $query); + }); +} + +function testStaticCall(): void +{ + Builder::create(new User())->whereHas('posts', function ($query) { + assertType('Bug12585\PostBuilder', $query); + }); +} diff --git a/e2e/parameter-type-extension/.gitignore b/e2e/parameter-type-extension/.gitignore new file mode 100644 index 00000000000..de4a392c331 --- /dev/null +++ b/e2e/parameter-type-extension/.gitignore @@ -0,0 +1,2 @@ +/vendor +/composer.lock diff --git a/e2e/parameter-type-extension/composer.json b/e2e/parameter-type-extension/composer.json new file mode 100644 index 00000000000..f8a4e6ebedf --- /dev/null +++ b/e2e/parameter-type-extension/composer.json @@ -0,0 +1,7 @@ +{ + "autoload": { + "psr-4": { + "App\\": "src/" + } + } +} diff --git a/e2e/parameter-type-extension/phpstan.neon.dist b/e2e/parameter-type-extension/phpstan.neon.dist new file mode 100644 index 00000000000..399cb981817 --- /dev/null +++ b/e2e/parameter-type-extension/phpstan.neon.dist @@ -0,0 +1,9 @@ +parameters: + level: 9 + paths: + - src +services: + - + class: App\ParameterTypeExtension + tags: + - phpstan.dynamicMethodParameterTypeExtension diff --git a/e2e/parameter-type-extension/src/ParameterTypeExtension.php b/e2e/parameter-type-extension/src/ParameterTypeExtension.php new file mode 100644 index 00000000000..d7ad9d149e1 --- /dev/null +++ b/e2e/parameter-type-extension/src/ParameterTypeExtension.php @@ -0,0 +1,110 @@ +getDeclaringClass()->is(Builder::class)) { + return false; + } + + return $methodReflection->getName() === 'with'; + } + + public function getTypeFromMethodCall( + MethodReflection $methodReflection, + MethodCall $methodCall, + ParameterReflection $parameter, + Scope $scope, + ): Type|null { + $arg = $methodCall->getArgs()[0] ?? null; + if (!$arg) { + return null; + } + + $type = $scope->getType($arg->value)->getConstantArrays()[0] ?? null; + if (!$type) { + return null; + } + + $model = $scope->getType($methodCall->var) + ->getTemplateType(Builder::class, 'TModel') + ->getObjectClassNames()[0] ?? null; + if (!$model) { + return null; + } + + foreach ($type->getKeyTypes() as $keyType) { + $relationType = $this->getRelationTypeFromModel($model, (string) $keyType->getValue(), $scope); + if (!$relationType) { + continue; + } + + $newType = new ClosureType([ + new class('test', $relationType) implements ParameterReflection { + public function __construct(private string $name, private Type $type) {} + public function getName(): string + { + return $this->name; + } + public function isOptional(): bool + { + return false; + } + public function getType(): Type + { + return $this->type; + } + public function passedByReference(): PassedByReference + { + return PassedByReference::createNo(); + } + public function isVariadic(): bool + { + return false; + } + public function getDefaultValue(): ?Type + { + return null; + } + }, + ], new MixedType(), false); + + $type = $type->setOffsetValueType($keyType, $newType, false); + } + + return $type; + } + + public function getRelationTypeFromModel(string $model, string $relation, Scope $scope): ?Type + { + $modelType = new ObjectType($model); + + if (! $modelType->hasMethod($relation)->yes()) { + return null; + } + + $relationType = $modelType->getMethod($relation, $scope)->getVariants()[0]->getReturnType(); + + if (! (new ObjectType(Relation::class))->isSuperTypeOf($relationType)->yes()) { + return null; + } + + return $relationType; + } +} diff --git a/e2e/parameter-type-extension/src/test.php b/e2e/parameter-type-extension/src/test.php new file mode 100644 index 00000000000..51fc3c2b635 --- /dev/null +++ b/e2e/parameter-type-extension/src/test.php @@ -0,0 +1,88 @@ + */ + public function car(): HasOne + { + return new HasOne(); // @phpstan-ignore return.type + } + + /** @return MorphTo */ + public function monitorable(): MorphTo + { + return new MorphTo(); // @phpstan-ignore return.type + } +} + +/** + * @template TRelatedModel of Model + * @template TDeclaringModel of Model + * @template TResult + */ +class Relation { + /** + * @param list $columns + * @return $this + */ + public function select(array $columns): static + { + return $this; + } +} + +/** + * @template TRelatedModel of Model + * @template TDeclaringModel of Model + * @extends Relation + */ +class HasOne extends Relation {} + +/** + * @template TRelatedModel of Model + * @template TDeclaringModel of Model + * @extends Relation + */ +class MorphTo extends Relation { + /** @return $this */ + public function morphWith(): static + { + return $this; + } +} + +/** @template TModel of Model */ +class Builder +{ + /** + * @param array): mixed> $relations + * @return $this + */ + public function with(array $relations): static + { + return $this; + } +} + +/** @param Builder $query */ +function test(Builder $query): void +{ + $query->with([ + 'car' => function ($r) { assertType('App\HasOne', $r); }, + 'monitorable' => function ($r) { assertType('App\MorphTo', $r); }, + ]); + $query->with([ + 'car' => fn (HasOne $q) => $q->select(['id']), + 'monitorable' => fn (MorphTo $q) => $q->morphWith(), + ]); +} diff --git a/phpstan-baseline.neon b/phpstan-baseline.neon index d8ee14cf595..2d03bb967be 100644 --- a/phpstan-baseline.neon +++ b/phpstan-baseline.neon @@ -90,6 +90,96 @@ parameters: count: 1 path: src/Analyser/MutatingScope.php + - + rawMessage: Access to constant on deprecated interface PHPStan\Type\FunctionParameterClosureTypeExtension. + identifier: classConstant.deprecatedInterface + count: 1 + path: src/Analyser/NodeScopeResolver.php + + - + rawMessage: Access to constant on deprecated interface PHPStan\Type\MethodParameterClosureTypeExtension. + identifier: classConstant.deprecatedInterface + count: 1 + path: src/Analyser/NodeScopeResolver.php + + - + rawMessage: Access to constant on deprecated interface PHPStan\Type\StaticMethodParameterClosureTypeExtension. + identifier: classConstant.deprecatedInterface + count: 1 + path: src/Analyser/NodeScopeResolver.php + + - + rawMessage: 'Call to method getTypeFromFunctionCall() of deprecated interface PHPStan\Type\FunctionParameterClosureTypeExtension.' + identifier: method.deprecatedInterface + count: 1 + path: src/Analyser/NodeScopeResolver.php + + - + rawMessage: 'Call to method getTypeFromMethodCall() of deprecated interface PHPStan\Type\MethodParameterClosureTypeExtension.' + identifier: method.deprecatedInterface + count: 1 + path: src/Analyser/NodeScopeResolver.php + + - + rawMessage: 'Call to method getTypeFromStaticMethodCall() of deprecated interface PHPStan\Type\StaticMethodParameterClosureTypeExtension.' + identifier: method.deprecatedInterface + count: 2 + path: src/Analyser/NodeScopeResolver.php + + - + rawMessage: 'Call to method isFunctionSupported() of deprecated interface PHPStan\Type\FunctionParameterClosureTypeExtension.' + identifier: method.deprecatedInterface + count: 1 + path: src/Analyser/NodeScopeResolver.php + + - + rawMessage: 'Call to method isMethodSupported() of deprecated interface PHPStan\Type\MethodParameterClosureTypeExtension.' + identifier: method.deprecatedInterface + count: 1 + path: src/Analyser/NodeScopeResolver.php + + - + rawMessage: 'Call to method isStaticMethodSupported() of deprecated interface PHPStan\Type\StaticMethodParameterClosureTypeExtension.' + identifier: method.deprecatedInterface + count: 2 + path: src/Analyser/NodeScopeResolver.php + + - + rawMessage: 'Parameter $functionParameterClosureTypeExtensions of method PHPStan\Analyser\NodeScopeResolver::__construct() has typehint with deprecated interface PHPStan\Type\FunctionParameterClosureTypeExtension.' + identifier: parameter.deprecatedInterface + count: 1 + path: src/Analyser/NodeScopeResolver.php + + - + rawMessage: 'Parameter $methodParameterClosureTypeExtensions of method PHPStan\Analyser\NodeScopeResolver::__construct() has typehint with deprecated interface PHPStan\Type\MethodParameterClosureTypeExtension.' + identifier: parameter.deprecatedInterface + count: 1 + path: src/Analyser/NodeScopeResolver.php + + - + rawMessage: 'Parameter $staticMethodParameterClosureTypeExtensions of method PHPStan\Analyser\NodeScopeResolver::__construct() has typehint with deprecated interface PHPStan\Type\StaticMethodParameterClosureTypeExtension.' + identifier: parameter.deprecatedInterface + count: 1 + path: src/Analyser/NodeScopeResolver.php + + - + rawMessage: Property $functionParameterClosureTypeExtensions references deprecated interface PHPStan\Type\FunctionParameterClosureTypeExtension in its type. + identifier: property.deprecatedInterface + count: 1 + path: src/Analyser/NodeScopeResolver.php + + - + rawMessage: Property $methodParameterClosureTypeExtensions references deprecated interface PHPStan\Type\MethodParameterClosureTypeExtension in its type. + identifier: property.deprecatedInterface + count: 1 + path: src/Analyser/NodeScopeResolver.php + + - + rawMessage: Property $staticMethodParameterClosureTypeExtensions references deprecated interface PHPStan\Type\StaticMethodParameterClosureTypeExtension in its type. + identifier: property.deprecatedInterface + count: 1 + path: src/Analyser/NodeScopeResolver.php + - rawMessage: 'Doing instanceof PHPStan\Type\Constant\ConstantBooleanType is error-prone and deprecated. Use Type::isTrue() or Type::isFalse() instead.' identifier: phpstanApi.instanceofType @@ -738,6 +828,48 @@ parameters: count: 1 path: src/Testing/LevelsTestCase.php + - + rawMessage: Access to constant on deprecated interface PHPStan\Type\FunctionParameterClosureTypeExtension. + identifier: classConstant.deprecatedInterface + count: 1 + path: src/Testing/RuleTestCase.php + + - + rawMessage: Access to constant on deprecated interface PHPStan\Type\MethodParameterClosureTypeExtension. + identifier: classConstant.deprecatedInterface + count: 1 + path: src/Testing/RuleTestCase.php + + - + rawMessage: Access to constant on deprecated interface PHPStan\Type\StaticMethodParameterClosureTypeExtension. + identifier: classConstant.deprecatedInterface + count: 1 + path: src/Testing/RuleTestCase.php + + - + rawMessage: 'Parameter #1 $callback of function array_map expects Closure(string): mixed, array{PHPStan\File\FileHelper, ''normalizePath''} given.' + identifier: argument.type + count: 1 + path: src/Testing/RuleTestCase.php + + - + rawMessage: Access to constant on deprecated interface PHPStan\Type\FunctionParameterClosureTypeExtension. + identifier: classConstant.deprecatedInterface + count: 1 + path: src/Testing/TypeInferenceTestCase.php + + - + rawMessage: Access to constant on deprecated interface PHPStan\Type\MethodParameterClosureTypeExtension. + identifier: classConstant.deprecatedInterface + count: 1 + path: src/Testing/TypeInferenceTestCase.php + + - + rawMessage: Access to constant on deprecated interface PHPStan\Type\StaticMethodParameterClosureTypeExtension. + identifier: classConstant.deprecatedInterface + count: 1 + path: src/Testing/TypeInferenceTestCase.php + - rawMessage: 'Doing instanceof PHPStan\Type\ConstantScalarType is error-prone and deprecated. Use Type::isConstantScalarValue() or Type::getConstantScalarTypes() or Type::getConstantScalarValues() instead.' identifier: phpstanApi.instanceofType @@ -1434,6 +1566,18 @@ parameters: count: 1 path: src/Type/IntersectionType.php + - + rawMessage: 'Parameter #1 $callback of function array_map expects Closure(PHPStan\Type\Type): mixed, callable(PHPStan\Type\Type): PHPStan\Type\Type given.' + identifier: argument.type + count: 1 + path: src/Type/IntersectionType.php + + - + rawMessage: 'Parameter #2 $callback of function array_filter expects Closure(PHPStan\Type\Type): bool, callable(PHPStan\Type\Type): bool given.' + identifier: argument.type + count: 1 + path: src/Type/IntersectionType.php + - rawMessage: Doing instanceof PHPStan\Type\IntersectionType is error-prone and deprecated. identifier: phpstanApi.instanceofType @@ -1512,12 +1656,36 @@ parameters: count: 1 path: src/Type/PHPStan/ClassNameUsageLocationCreateIdentifierDynamicReturnTypeExtension.php + - + rawMessage: Class PHPStan\Type\Php\ArrayFilterParameterClosureTypeExtension implements deprecated interface PHPStan\Type\FunctionParameterClosureTypeExtension. + identifier: class.implementsDeprecatedInterface + count: 1 + path: src/Type/Php/ArrayFilterParameterClosureTypeExtension.php + + - + rawMessage: Class PHPStan\Type\Php\ArrayFindParameterClosureTypeExtension implements deprecated interface PHPStan\Type\FunctionParameterClosureTypeExtension. + identifier: class.implementsDeprecatedInterface + count: 1 + path: src/Type/Php/ArrayFindParameterClosureTypeExtension.php + - rawMessage: 'Doing instanceof PHPStan\Type\Constant\ConstantStringType is error-prone and deprecated. Use Type::getConstantStrings() instead.' identifier: phpstanApi.instanceofType count: 1 path: src/Type/Php/ArrayKeyExistsFunctionTypeSpecifyingExtension.php + - + rawMessage: Class PHPStan\Type\Php\ArrayMapParameterClosureTypeExtension implements deprecated interface PHPStan\Type\FunctionParameterClosureTypeExtension. + identifier: class.implementsDeprecatedInterface + count: 1 + path: src/Type/Php/ArrayMapParameterClosureTypeExtension.php + + - + rawMessage: Class PHPStan\Type\Php\ArrayWalkParameterClosureTypeExtension implements deprecated interface PHPStan\Type\FunctionParameterClosureTypeExtension. + identifier: class.implementsDeprecatedInterface + count: 1 + path: src/Type/Php/ArrayWalkParameterClosureTypeExtension.php + - rawMessage: 'Doing instanceof PHPStan\Type\ConstantScalarType is error-prone and deprecated. Use Type::isConstantScalarValue() or Type::getConstantScalarTypes() or Type::getConstantScalarValues() instead.' identifier: phpstanApi.instanceofType @@ -1554,6 +1722,12 @@ parameters: count: 1 path: src/Type/Php/InArrayFunctionTypeSpecifyingExtension.php + - + rawMessage: 'Parameter #1 $callback of function array_map expects Closure(non-falsy-string): mixed, ''strtoupper'' given.' + identifier: argument.type + count: 1 + path: src/Type/Php/MbStrlenFunctionReturnTypeExtension.php + - rawMessage: 'Doing instanceof PHPStan\Type\Constant\ConstantStringType is error-prone and deprecated. Use Type::getConstantStrings() instead.' identifier: phpstanApi.instanceofType @@ -1770,6 +1944,24 @@ parameters: count: 2 path: src/Type/VoidType.php + - + rawMessage: Access to constant on deprecated interface PHPStan\Type\FunctionParameterClosureTypeExtension. + identifier: classConstant.deprecatedInterface + count: 1 + path: tests/PHPStan/Analyser/AnalyserTest.php + + - + rawMessage: Access to constant on deprecated interface PHPStan\Type\MethodParameterClosureTypeExtension. + identifier: classConstant.deprecatedInterface + count: 1 + path: tests/PHPStan/Analyser/AnalyserTest.php + + - + rawMessage: Access to constant on deprecated interface PHPStan\Type\StaticMethodParameterClosureTypeExtension. + identifier: classConstant.deprecatedInterface + count: 1 + path: tests/PHPStan/Analyser/AnalyserTest.php + - rawMessage: 'Class PHPStan\Analyser\AnonymousClassNameRuleTest extends generic class PHPStan\Testing\RuleTestCase but does not specify its types: TRule' identifier: missingType.generics diff --git a/src/Analyser/ExprHandler.php b/src/Analyser/ExprHandler.php index 5e57b94e2e0..b049745128c 100644 --- a/src/Analyser/ExprHandler.php +++ b/src/Analyser/ExprHandler.php @@ -32,6 +32,7 @@ public function processExpr( ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, + ?Type $overriddenType, ): ExpressionResult; /** diff --git a/src/Analyser/ExprHandler/ArrayDimFetchHandler.php b/src/Analyser/ExprHandler/ArrayDimFetchHandler.php index dfdc46932d3..158c1a09dd0 100644 --- a/src/Analyser/ExprHandler/ArrayDimFetchHandler.php +++ b/src/Analyser/ExprHandler/ArrayDimFetchHandler.php @@ -83,17 +83,17 @@ public function resolveType(MutatingScope $scope, Expr $expr): Type ); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; if ($expr->dim === null) { - $varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $scope, $storage, $nodeCallback, $context->enterDeep()); + $varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $scope, $storage, $nodeCallback, $context->enterDeep(), null); return $this->composeResult($nodeScopeResolver, $stmt, $expr, null, $varResult, $storage, $context, $beforeScope); } - $dimResult = $nodeScopeResolver->processExprNode($stmt, $expr->dim, $scope, $storage, $nodeCallback, $context->enterDeep()); - $varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $dimResult->getScope(), $storage, $nodeCallback, $context->enterDeep()); + $dimResult = $nodeScopeResolver->processExprNode($stmt, $expr->dim, $scope, $storage, $nodeCallback, $context->enterDeep(), null); + $varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $dimResult->getScope(), $storage, $nodeCallback, $context->enterDeep(), null); return $this->composeResult($nodeScopeResolver, $stmt, $expr, $dimResult, $varResult, $storage, $context, $beforeScope); } diff --git a/src/Analyser/ExprHandler/ArrayHandler.php b/src/Analyser/ExprHandler/ArrayHandler.php index 2ac6d9cead4..efe356dd9b7 100644 --- a/src/Analyser/ExprHandler/ArrayHandler.php +++ b/src/Analyser/ExprHandler/ArrayHandler.php @@ -24,10 +24,12 @@ use PHPStan\Node\LiteralArrayNode; use PHPStan\Reflection\InitializerExprTypeResolver; use PHPStan\Type\CallableType; +use PHPStan\Type\Constant\ConstantIntegerType; use PHPStan\Type\Type; use PHPStan\Type\TypeCombinator; use function array_merge; use function count; +use function is_int; /** * @implements ExprHandler @@ -72,7 +74,7 @@ public function resolveType(MutatingScope $scope, Expr $expr): Type return $type; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $itemNodes = []; @@ -80,11 +82,14 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $throwPoints = []; $impurePoints = []; $isAlwaysTerminating = false; + $nextAutoIndex = 0; foreach ($expr->items as $arrayItem) { $itemNodes[] = new LiteralArrayItem($scope, $arrayItem); $itemCallbackScope = $scope; + $keyType = new ConstantIntegerType($nextAutoIndex); if ($arrayItem->key !== null) { - $keyResult = $nodeScopeResolver->processExprNode($stmt, $arrayItem->key, $scope, $storage, $nodeCallback, $context->enterDeep()); + $keyType = $scope->getType($arrayItem->key); + $keyResult = $nodeScopeResolver->processExprNode($stmt, $arrayItem->key, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $hasYield = $hasYield || $keyResult->hasYield(); $throwPoints = array_merge($throwPoints, $keyResult->getThrowPoints()); $impurePoints = array_merge($impurePoints, $keyResult->getImpurePoints()); @@ -92,7 +97,24 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $scope = $keyResult->getScope(); } - $valueResult = $nodeScopeResolver->processExprNode($stmt, $arrayItem->value, $scope, $storage, $nodeCallback, $context->enterDeep()); + // an overridden array type prices each item against the type declared + // for its key, so a nested closure is walked with the parameters the + // extension announced instead of the declared (contravariant) ones + $overriddenValueType = null; + if ($overriddenType !== null && $overriddenType->hasOffsetValueType($keyType)->yes()) { + $overriddenValueType = $overriddenType->getOffsetValueType($keyType); + } + + if ($arrayItem->key === null) { + $nextAutoIndex++; + } else { + $keyIntegers = $keyType->getConstantScalarValues(); + if (count($keyIntegers) === 1 && is_int($keyIntegers[0])) { + $nextAutoIndex = $keyIntegers[0] + 1; + } + } + + $valueResult = $nodeScopeResolver->processExprNode($stmt, $arrayItem->value, $scope, $storage, $nodeCallback, $context->enterDeep(), $overriddenValueType); $hasYield = $hasYield || $valueResult->hasYield(); $throwPoints = array_merge($throwPoints, $valueResult->getThrowPoints()); $impurePoints = array_merge($impurePoints, $valueResult->getImpurePoints()); diff --git a/src/Analyser/ExprHandler/ArrowFunctionHandler.php b/src/Analyser/ExprHandler/ArrowFunctionHandler.php index b811653920a..fb68cee3a2b 100644 --- a/src/Analyser/ExprHandler/ArrowFunctionHandler.php +++ b/src/Analyser/ExprHandler/ArrowFunctionHandler.php @@ -39,9 +39,9 @@ public function supports(Expr $expr): bool return $expr instanceof ArrowFunction; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { - $arrowFunctionResult = $nodeScopeResolver->processArrowFunctionNode($stmt, $expr, $scope, $storage, $nodeCallback, null); + $arrowFunctionResult = $nodeScopeResolver->processArrowFunctionNode($stmt, $expr, $scope, $storage, $nodeCallback, $overriddenType); $this->closureTypeResolver->seedCacheFromArrowFunctionWalk($scope, $expr, $arrowFunctionResult); $result = $arrowFunctionResult->getExpressionResult(); diff --git a/src/Analyser/ExprHandler/AssignHandler.php b/src/Analyser/ExprHandler/AssignHandler.php index b3de7b4b461..05386a4846e 100644 --- a/src/Analyser/ExprHandler/AssignHandler.php +++ b/src/Analyser/ExprHandler/AssignHandler.php @@ -303,7 +303,7 @@ public function specifyTypes(TypeSpecifier $typeSpecifier, Scope $scope, Expr $e return $specifiedTypes; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $target = $this->prepareTarget( @@ -348,7 +348,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex ); } - $assignedExprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $valueScope, $storage, $nodeCallback, $valueContext->enterDeep()); + $assignedExprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $valueScope, $storage, $nodeCallback, $valueContext->enterDeep(), null); $valueImpurePoints = array_merge($valueImpurePoints, $assignedExprResult->getImpurePoints()); $valueScope = $assignedExprResult->getScope(); @@ -489,7 +489,7 @@ private function doPrepareTarget( if (!is_string($var->name)) { // `$$name OP= ...` evaluates the name before reading the old // value: walk it once here, the write flow consumes the result - $variableNameResult = $nodeScopeResolver->processExprNode($stmt, $var->name, $scope, $storage, $nodeCallback, $context); + $variableNameResult = $nodeScopeResolver->processExprNode($stmt, $var->name, $scope, $storage, $nodeCallback, $context, null); $hasYield = $variableNameResult->hasYield(); $throwPoints = $variableNameResult->getThrowPoints(); $impurePoints = $variableNameResult->getImpurePoints(); @@ -559,7 +559,7 @@ private function doPrepareTarget( if ($enterExpressionAssign) { $scope = $scope->enterExpressionAssign($var, false); } - $result = $nodeScopeResolver->processExprNode($stmt, $var, $scope, $storage, $nodeCallback, $context->enterDeep()); + $result = $nodeScopeResolver->processExprNode($stmt, $var, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $rootReadResult = $result; $hasYield = $result->hasYield(); $throwPoints = $result->getThrowPoints(); @@ -607,7 +607,7 @@ private function doPrepareTarget( throwPoints: [], impurePoints: [], )); - $result = $nodeScopeResolver->processExprNode($stmt, $dimExpr, $scope, $storage, $nodeCallback, $context->enterDeep()); + $result = $nodeScopeResolver->processExprNode($stmt, $dimExpr, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $dimResults[$key] = $result; $offsetTypes[] = [$result->getType(), $dimFetch]; $offsetNativeTypes[] = [$result->getNativeType(), $dimFetch]; @@ -668,7 +668,7 @@ private function doPrepareTarget( if ($var instanceof PropertyFetch) { $scopeBeforeVar = $scope; - $objectResult = $nodeScopeResolver->processExprNode($stmt, $var->var, $scope, $storage, $nodeCallback, $context); + $objectResult = $nodeScopeResolver->processExprNode($stmt, $var->var, $scope, $storage, $nodeCallback, $context, null); $hasYield = $objectResult->hasYield(); $throwPoints = $objectResult->getThrowPoints(); $impurePoints = $objectResult->getImpurePoints(); @@ -680,7 +680,7 @@ private function doPrepareTarget( if ($var->name instanceof Node\Identifier) { $propertyName = $var->name->name; } else { - $propertyNameResult = $nodeScopeResolver->processExprNode($stmt, $var->name, $scope, $storage, $nodeCallback, $context); + $propertyNameResult = $nodeScopeResolver->processExprNode($stmt, $var->name, $scope, $storage, $nodeCallback, $context, null); $hasYield = $hasYield || $propertyNameResult->hasYield(); $throwPoints = array_merge($throwPoints, $propertyNameResult->getThrowPoints()); $impurePoints = array_merge($impurePoints, $propertyNameResult->getImpurePoints()); @@ -719,7 +719,7 @@ private function doPrepareTarget( if ($var->class instanceof Node\Name) { $propertyHolderType = $scope->resolveTypeByName($var->class); } else { - $classResult = $nodeScopeResolver->processExprNode($stmt, $var->class, $scope, $storage, $nodeCallback, $context); + $classResult = $nodeScopeResolver->processExprNode($stmt, $var->class, $scope, $storage, $nodeCallback, $context, null); $propertyHolderType = $scope->getType($var->class); } @@ -728,7 +728,7 @@ private function doPrepareTarget( if ($var->name instanceof Node\Identifier) { $propertyName = $var->name->name; } else { - $propertyNameResult = $nodeScopeResolver->processExprNode($stmt, $var->name, $scope, $storage, $nodeCallback, $context); + $propertyNameResult = $nodeScopeResolver->processExprNode($stmt, $var->name, $scope, $storage, $nodeCallback, $context, null); $hasYield = $propertyNameResult->hasYield(); $throwPoints = $propertyNameResult->getThrowPoints(); $impurePoints = $propertyNameResult->getImpurePoints(); @@ -827,7 +827,7 @@ private function doPrepareTarget( ); } - $varResult = $nodeScopeResolver->processExprNode($stmt, $var, $scope, $storage, $nodeCallback, $context); + $varResult = $nodeScopeResolver->processExprNode($stmt, $var, $scope, $storage, $nodeCallback, $context, null); $hasYield = $varResult->hasYield(); $throwPoints = array_merge($throwPoints, $varResult->getThrowPoints()); $impurePoints = array_merge($impurePoints, $varResult->getImpurePoints()); @@ -909,7 +909,7 @@ public function applyWrite( if ($if === null) { $if = $assignedExpr->cond; } - $condScope = $nodeScopeResolver->processExprNode($stmt, $assignedExpr->cond, $scope, $storage->duplicate(), new NoopNodeCallback(), ExpressionContext::createDeep())->getScope(); + $condScope = $nodeScopeResolver->processExprNode($stmt, $assignedExpr->cond, $scope, $storage->duplicate(), new NoopNodeCallback(), ExpressionContext::createDeep(), null)->getScope(); $truthySpecifiedTypes = $this->typeSpecifier->specifyTypesInCondition($condScope, $assignedExpr->cond, TypeSpecifierContext::createTruthy()); $falseySpecifiedTypes = $this->typeSpecifier->specifyTypesInCondition($condScope, $assignedExpr->cond, TypeSpecifierContext::createFalsey()); $truthyScope = $condScope->applySpecifiedTypes($truthySpecifiedTypes); @@ -1000,7 +1000,7 @@ public function applyWrite( // a plain assignment does not read the target, so the dynamic name // is walked here; read-modify-write targets walked it in // prepareTarget() and already carry its state - $nameExprResult = $nodeScopeResolver->processExprNode($stmt, $var->name, $scope, $storage, $nodeCallback, $context); + $nameExprResult = $nodeScopeResolver->processExprNode($stmt, $var->name, $scope, $storage, $nodeCallback, $context, null); $hasYield = $hasYield || $nameExprResult->hasYield(); $throwPoints = array_merge($throwPoints, $nameExprResult->getThrowPoints()); $impurePoints = array_merge($impurePoints, $nameExprResult->getImpurePoints()); @@ -1293,7 +1293,7 @@ public function applyWrite( $itemScope = $nodeScopeResolver->lookForSetAllowedUndefinedExpressions($itemScope, $arrayItem->value); $nodeScopeResolver->callNodeCallback($nodeCallback, $arrayItem, $itemScope, $storage); if ($arrayItem->key !== null) { - $keyResult = $nodeScopeResolver->processExprNode($stmt, $arrayItem->key, $itemScope, $storage, $nodeCallback, $context->enterDeep()); + $keyResult = $nodeScopeResolver->processExprNode($stmt, $arrayItem->key, $itemScope, $storage, $nodeCallback, $context->enterDeep(), null); $hasYield = $hasYield || $keyResult->hasYield(); $throwPoints = array_merge($throwPoints, $keyResult->getThrowPoints()); $impurePoints = array_merge($impurePoints, $keyResult->getImpurePoints()); diff --git a/src/Analyser/ExprHandler/AssignOpHandler.php b/src/Analyser/ExprHandler/AssignOpHandler.php index 186c792b0b8..0e3740ee424 100644 --- a/src/Analyser/ExprHandler/AssignOpHandler.php +++ b/src/Analyser/ExprHandler/AssignOpHandler.php @@ -54,7 +54,7 @@ public function supports(Expr $expr): bool return $expr instanceof AssignOp; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $target = $this->assignHandler->prepareTarget( @@ -86,7 +86,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex } } - $valueResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $valueScope, $storage, $nodeCallback, $valueContext->enterDeep()); + $valueResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $valueScope, $storage, $nodeCallback, $valueContext->enterDeep(), null); if ($expr instanceof Expr\AssignOp\Coalesce) { $isAlwaysTerminatingCoalesce = $valueResult->isAlwaysTerminating() && $valueBeforeScope->getType($expr->var)->isNull()->yes(); $valueResult = $this->expressionResultFactory->create( diff --git a/src/Analyser/ExprHandler/BinaryOpHandler.php b/src/Analyser/ExprHandler/BinaryOpHandler.php index f8df18444ef..ec4e6b919e9 100644 --- a/src/Analyser/ExprHandler/BinaryOpHandler.php +++ b/src/Analyser/ExprHandler/BinaryOpHandler.php @@ -83,11 +83,11 @@ public function supports(Expr $expr): bool && !$expr instanceof BinaryOp\Pipe; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; - $leftResult = $nodeScopeResolver->processExprNode($stmt, $expr->left, $scope, $storage, $nodeCallback, $context->enterDeep()); - $rightResult = $nodeScopeResolver->processExprNode($stmt, $expr->right, $leftResult->getScope(), $storage, $nodeCallback, $context->enterDeep()); + $leftResult = $nodeScopeResolver->processExprNode($stmt, $expr->left, $scope, $storage, $nodeCallback, $context->enterDeep(), null); + $rightResult = $nodeScopeResolver->processExprNode($stmt, $expr->right, $leftResult->getScope(), $storage, $nodeCallback, $context->enterDeep(), null); $throwPoints = array_merge($leftResult->getThrowPoints(), $rightResult->getThrowPoints()); $impurePoints = array_merge($leftResult->getImpurePoints(), $rightResult->getImpurePoints()); if ( diff --git a/src/Analyser/ExprHandler/BitwiseNotHandler.php b/src/Analyser/ExprHandler/BitwiseNotHandler.php index 4b6b6667823..716db963fa6 100644 --- a/src/Analyser/ExprHandler/BitwiseNotHandler.php +++ b/src/Analyser/ExprHandler/BitwiseNotHandler.php @@ -39,9 +39,9 @@ public function supports(Expr $expr): bool return $expr instanceof BitwiseNot; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { - $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep()); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep(), null); return $this->expressionResultFactory->create( $exprResult->getScope(), diff --git a/src/Analyser/ExprHandler/BooleanAndHandler.php b/src/Analyser/ExprHandler/BooleanAndHandler.php index d2ad23c7bed..536b6e382c7 100644 --- a/src/Analyser/ExprHandler/BooleanAndHandler.php +++ b/src/Analyser/ExprHandler/BooleanAndHandler.php @@ -64,7 +64,7 @@ public function resolveType(MutatingScope $scope, Expr $expr): Type } if (self::getBooleanExpressionDepth($expr->left) <= self::BOOLEAN_EXPRESSION_MAX_PROCESS_DEPTH) { - $leftResult = $this->nodeScopeResolver->processExprNode(new Stmt\Expression($expr->left), $expr->left, $scope, new ExpressionResultStorage(), new NoopNodeCallback(), ExpressionContext::createDeep()); + $leftResult = $this->nodeScopeResolver->processExprNode(new Stmt\Expression($expr->left), $expr->left, $scope, new ExpressionResultStorage(), new NoopNodeCallback(), ExpressionContext::createDeep(), null); $rightBooleanType = $leftResult->getTruthyScope()->getType($expr->right)->toBoolean(); } else { $rightBooleanType = $scope->filterByTruthyValue($expr->left)->getType($expr->right)->toBoolean(); @@ -263,11 +263,11 @@ private function isTrackableExpression(Expr $expr): bool || $expr instanceof Expr\StaticPropertyFetch; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { - $leftResult = $nodeScopeResolver->processExprNode($stmt, $expr->left, $scope, $storage, $nodeCallback, $context->enterDeep()); + $leftResult = $nodeScopeResolver->processExprNode($stmt, $expr->left, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $leftTruthyScope = $leftResult->getTruthyScope(); - $rightResult = $nodeScopeResolver->processExprNode($stmt, $expr->right, $leftTruthyScope, $storage, $nodeCallback, $context); + $rightResult = $nodeScopeResolver->processExprNode($stmt, $expr->right, $leftTruthyScope, $storage, $nodeCallback, $context, null); $rightExprType = $rightResult->getType(); if ($rightExprType instanceof NeverType && $rightExprType->isExplicit()) { $leftMergedWithRightScope = $leftResult->getFalseyScope(); diff --git a/src/Analyser/ExprHandler/BooleanNotHandler.php b/src/Analyser/ExprHandler/BooleanNotHandler.php index 59cb5a986c1..d5d83ca5e05 100644 --- a/src/Analyser/ExprHandler/BooleanNotHandler.php +++ b/src/Analyser/ExprHandler/BooleanNotHandler.php @@ -37,10 +37,10 @@ public function supports(Expr $expr): bool return $expr instanceof BooleanNot; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; - $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep()); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $scope = $exprResult->getScope(); return $this->expressionResultFactory->create( diff --git a/src/Analyser/ExprHandler/BooleanOrHandler.php b/src/Analyser/ExprHandler/BooleanOrHandler.php index a44ce06fc16..339e8087c48 100644 --- a/src/Analyser/ExprHandler/BooleanOrHandler.php +++ b/src/Analyser/ExprHandler/BooleanOrHandler.php @@ -72,7 +72,7 @@ public function resolveType(MutatingScope $scope, Expr $expr): Type } if (BooleanAndHandler::getBooleanExpressionDepth($expr->left) <= self::BOOLEAN_EXPRESSION_MAX_PROCESS_DEPTH) { - $leftResult = $this->nodeScopeResolver->processExprNode(new Stmt\Expression($expr->left), $expr->left, $scope, new ExpressionResultStorage(), new NoopNodeCallback(), ExpressionContext::createDeep()); + $leftResult = $this->nodeScopeResolver->processExprNode(new Stmt\Expression($expr->left), $expr->left, $scope, new ExpressionResultStorage(), new NoopNodeCallback(), ExpressionContext::createDeep(), null); $rightBooleanType = $leftResult->getFalseyScope()->getType($expr->right)->toBoolean(); } else { $rightBooleanType = $scope->filterByFalseyValue($expr->left)->getType($expr->right)->toBoolean(); @@ -254,11 +254,11 @@ private function specifyTypesForFlattenedBooleanOr( return $result->setRootExpr($expr); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { - $leftResult = $nodeScopeResolver->processExprNode($stmt, $expr->left, $scope, $storage, $nodeCallback, $context->enterDeep()); + $leftResult = $nodeScopeResolver->processExprNode($stmt, $expr->left, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $leftFalseyScope = $leftResult->getFalseyScope(); - $rightResult = $nodeScopeResolver->processExprNode($stmt, $expr->right, $leftFalseyScope, $storage, $nodeCallback, $context); + $rightResult = $nodeScopeResolver->processExprNode($stmt, $expr->right, $leftFalseyScope, $storage, $nodeCallback, $context, null); $rightExprType = $rightResult->getType(); if ($rightExprType instanceof NeverType && $rightExprType->isExplicit()) { $leftMergedWithRightScope = $leftResult->getTruthyScope(); diff --git a/src/Analyser/ExprHandler/CastHandler.php b/src/Analyser/ExprHandler/CastHandler.php index 6877fdd5b3e..f446f81ecbd 100644 --- a/src/Analyser/ExprHandler/CastHandler.php +++ b/src/Analyser/ExprHandler/CastHandler.php @@ -46,10 +46,10 @@ public function supports(Expr $expr): bool return $expr instanceof Cast && !$expr instanceof Cast\String_; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; - $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep()); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $scope = $exprResult->getScope(); return $this->expressionResultFactory->create( diff --git a/src/Analyser/ExprHandler/CastStringHandler.php b/src/Analyser/ExprHandler/CastStringHandler.php index bb13a0e2817..c5f4ecb5f64 100644 --- a/src/Analyser/ExprHandler/CastStringHandler.php +++ b/src/Analyser/ExprHandler/CastStringHandler.php @@ -44,10 +44,10 @@ public function supports(Expr $expr): bool return $expr instanceof Cast\String_; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; - $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep()); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $impurePoints = $exprResult->getImpurePoints(); $throwPoints = $exprResult->getThrowPoints(); diff --git a/src/Analyser/ExprHandler/ClassConstFetchHandler.php b/src/Analyser/ExprHandler/ClassConstFetchHandler.php index fe989f332c9..e8f9ec80bc6 100644 --- a/src/Analyser/ExprHandler/ClassConstFetchHandler.php +++ b/src/Analyser/ExprHandler/ClassConstFetchHandler.php @@ -56,7 +56,7 @@ public function resolveType(MutatingScope $scope, Expr $expr): Type ); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $hasYield = false; @@ -65,7 +65,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $isAlwaysTerminating = false; if ($expr->class instanceof Expr) { - $classResult = $nodeScopeResolver->processExprNode($stmt, $expr->class, $scope, $storage, $nodeCallback, $context->enterDeep()); + $classResult = $nodeScopeResolver->processExprNode($stmt, $expr->class, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $scope = $classResult->getScope(); $hasYield = $classResult->hasYield(); $throwPoints = $classResult->getThrowPoints(); @@ -78,7 +78,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex if ($expr->name instanceof Identifier) { $nodeScopeResolver->callNodeCallback($nodeCallback, $expr->name, $scope, $storage); } else { - $nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->name, $scope, $storage, $nodeCallback, $context->enterDeep()); + $nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->name, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $scope = $nameResult->getScope(); $hasYield = $hasYield || $nameResult->hasYield(); $throwPoints = array_merge($throwPoints, $nameResult->getThrowPoints()); diff --git a/src/Analyser/ExprHandler/CloneHandler.php b/src/Analyser/ExprHandler/CloneHandler.php index bc707347411..dc5ebb7c6ab 100644 --- a/src/Analyser/ExprHandler/CloneHandler.php +++ b/src/Analyser/ExprHandler/CloneHandler.php @@ -39,9 +39,9 @@ public function supports(Expr $expr): bool return $expr instanceof Clone_; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { - $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep()); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep(), null); return $this->expressionResultFactory->create( $exprResult->getScope(), diff --git a/src/Analyser/ExprHandler/ClosureHandler.php b/src/Analyser/ExprHandler/ClosureHandler.php index 07f600f69d4..ab2d62646dd 100644 --- a/src/Analyser/ExprHandler/ClosureHandler.php +++ b/src/Analyser/ExprHandler/ClosureHandler.php @@ -39,9 +39,9 @@ public function supports(Expr $expr): bool return $expr instanceof Closure; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { - $processClosureResult = $nodeScopeResolver->processClosureNode($stmt, $expr, $scope, $storage, $nodeCallback, $context, null); + $processClosureResult = $nodeScopeResolver->processClosureNode($stmt, $expr, $scope, $storage, $nodeCallback, $context, $overriddenType); $this->closureTypeResolver->seedCacheFromClosureWalk($scope, $expr, $processClosureResult); return $this->expressionResultFactory->create( diff --git a/src/Analyser/ExprHandler/CoalesceHandler.php b/src/Analyser/ExprHandler/CoalesceHandler.php index c0a54c5bee3..08d9022006f 100644 --- a/src/Analyser/ExprHandler/CoalesceHandler.php +++ b/src/Analyser/ExprHandler/CoalesceHandler.php @@ -118,17 +118,17 @@ public function specifyTypes(TypeSpecifier $typeSpecifier, Scope $scope, Expr $e return (new SpecifiedTypes([], []))->setRootExpr($expr); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $nonNullabilityResult = $this->nonNullabilityHelper->ensureNonNullability($scope, $expr->left); $condScope = $nodeScopeResolver->lookForSetAllowedUndefinedExpressions($nonNullabilityResult->getScope(), $expr->left); - $condResult = $nodeScopeResolver->processExprNode($stmt, $expr->left, $condScope, $storage, $nodeCallback, $context->enterDeep()); + $condResult = $nodeScopeResolver->processExprNode($stmt, $expr->left, $condScope, $storage, $nodeCallback, $context->enterDeep(), null); $scope = $this->nonNullabilityHelper->revertNonNullability($condResult->getScope(), $nonNullabilityResult->getSpecifiedExpressions()); $scope = $nodeScopeResolver->lookForUnsetAllowedUndefinedExpressions($scope, $expr->left); $rightScope = $scope->filterByFalseyValue($expr); - $rightResult = $nodeScopeResolver->processExprNode($stmt, $expr->right, $rightScope, $storage, $nodeCallback, $context->enterDeep()); + $rightResult = $nodeScopeResolver->processExprNode($stmt, $expr->right, $rightScope, $storage, $nodeCallback, $context->enterDeep(), null); $rightExprType = $rightResult->getType(); if ($rightExprType instanceof NeverType && $rightExprType->isExplicit()) { $scope = $scope->filterByTruthyValue(new Expr\Isset_([$expr->left])); diff --git a/src/Analyser/ExprHandler/ConstFetchHandler.php b/src/Analyser/ExprHandler/ConstFetchHandler.php index 17f429322e0..ec4a9a9dc22 100644 --- a/src/Analyser/ExprHandler/ConstFetchHandler.php +++ b/src/Analyser/ExprHandler/ConstFetchHandler.php @@ -44,7 +44,7 @@ public function supports(Expr $expr): bool return $expr instanceof ConstFetch; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $nodeScopeResolver->callNodeCallback($nodeCallback, $expr->name, $scope, $storage); diff --git a/src/Analyser/ExprHandler/EmptyHandler.php b/src/Analyser/ExprHandler/EmptyHandler.php index 45e30427624..35a15d6a4aa 100644 --- a/src/Analyser/ExprHandler/EmptyHandler.php +++ b/src/Analyser/ExprHandler/EmptyHandler.php @@ -86,12 +86,12 @@ public function specifyTypes(TypeSpecifier $typeSpecifier, Scope $scope, Expr $e ), $context)->setRootExpr($expr); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $nonNullabilityResult = $this->nonNullabilityHelper->ensureNonNullability($scope, $expr->expr); $scope = $nodeScopeResolver->lookForSetAllowedUndefinedExpressions($nonNullabilityResult->getScope(), $expr->expr); - $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep()); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $scope = $exprResult->getScope(); $scope = $this->nonNullabilityHelper->revertNonNullability($scope, $nonNullabilityResult->getSpecifiedExpressions()); $scope = $nodeScopeResolver->lookForUnsetAllowedUndefinedExpressions($scope, $expr->expr); diff --git a/src/Analyser/ExprHandler/ErrorSuppressHandler.php b/src/Analyser/ExprHandler/ErrorSuppressHandler.php index ca006ebcedb..8e2fca6ed2d 100644 --- a/src/Analyser/ExprHandler/ErrorSuppressHandler.php +++ b/src/Analyser/ExprHandler/ErrorSuppressHandler.php @@ -35,9 +35,9 @@ public function supports(Expr $expr): bool return $expr instanceof ErrorSuppress; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { - $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context, null); return $this->expressionResultFactory->create( $exprResult->getScope(), diff --git a/src/Analyser/ExprHandler/EvalHandler.php b/src/Analyser/ExprHandler/EvalHandler.php index 93cf1adc508..9e52d9381c9 100644 --- a/src/Analyser/ExprHandler/EvalHandler.php +++ b/src/Analyser/ExprHandler/EvalHandler.php @@ -44,10 +44,10 @@ public function resolveType(MutatingScope $scope, Expr $expr): Type return new MixedType(); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; - $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep()); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $scope = $exprResult->getScope()->invalidateVolatileExpressions(); return $this->expressionResultFactory->create( diff --git a/src/Analyser/ExprHandler/ExitHandler.php b/src/Analyser/ExprHandler/ExitHandler.php index 7c1029c14e2..83c7eca56ef 100644 --- a/src/Analyser/ExprHandler/ExitHandler.php +++ b/src/Analyser/ExprHandler/ExitHandler.php @@ -38,7 +38,7 @@ public function supports(Expr $expr): bool return $expr instanceof Exit_; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $kind = $expr->getAttribute('kind', Exit_::KIND_EXIT); @@ -50,7 +50,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $hasYield = false; $throwPoints = []; if ($expr->expr !== null) { - $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep()); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $hasYield = $exprResult->hasYield(); $throwPoints = $exprResult->getThrowPoints(); $impurePoints = array_merge($impurePoints, $exprResult->getImpurePoints()); diff --git a/src/Analyser/ExprHandler/FirstClassCallableFuncCallHandler.php b/src/Analyser/ExprHandler/FirstClassCallableFuncCallHandler.php index 266996eaeb2..eb9fed81d12 100644 --- a/src/Analyser/ExprHandler/FirstClassCallableFuncCallHandler.php +++ b/src/Analyser/ExprHandler/FirstClassCallableFuncCallHandler.php @@ -49,6 +49,7 @@ public function processExpr( ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, + ?Type $overriddenType, ): ExpressionResult { // handled in NodeScopeResolver before ExprHandlers are called diff --git a/src/Analyser/ExprHandler/FirstClassCallableMethodCallHandler.php b/src/Analyser/ExprHandler/FirstClassCallableMethodCallHandler.php index 1cafdd5b120..4cef4f47935 100644 --- a/src/Analyser/ExprHandler/FirstClassCallableMethodCallHandler.php +++ b/src/Analyser/ExprHandler/FirstClassCallableMethodCallHandler.php @@ -49,6 +49,7 @@ public function processExpr( ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, + ?Type $overriddenType, ): ExpressionResult { // handled in NodeScopeResolver before ExprHandlers are called diff --git a/src/Analyser/ExprHandler/FirstClassCallableNewHandler.php b/src/Analyser/ExprHandler/FirstClassCallableNewHandler.php index e158a8cc7b8..9ade7f94c3a 100644 --- a/src/Analyser/ExprHandler/FirstClassCallableNewHandler.php +++ b/src/Analyser/ExprHandler/FirstClassCallableNewHandler.php @@ -48,6 +48,7 @@ public function processExpr( ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, + ?Type $overriddenType, ): ExpressionResult { // handled in NodeScopeResolver before ExprHandlers are called diff --git a/src/Analyser/ExprHandler/FirstClassCallableStaticCallHandler.php b/src/Analyser/ExprHandler/FirstClassCallableStaticCallHandler.php index 4d3519cf944..fd7c4c042a8 100644 --- a/src/Analyser/ExprHandler/FirstClassCallableStaticCallHandler.php +++ b/src/Analyser/ExprHandler/FirstClassCallableStaticCallHandler.php @@ -47,6 +47,7 @@ public function processExpr( ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, + ?Type $overriddenType, ): ExpressionResult { // handled in NodeScopeResolver before ExprHandlers are called diff --git a/src/Analyser/ExprHandler/FuncCallHandler.php b/src/Analyser/ExprHandler/FuncCallHandler.php index f7e1aa61073..7efe4b49070 100644 --- a/src/Analyser/ExprHandler/FuncCallHandler.php +++ b/src/Analyser/ExprHandler/FuncCallHandler.php @@ -96,7 +96,7 @@ public function supports(Expr $expr): bool return $expr instanceof FuncCall && !$expr->isFirstClassCallable(); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $parametersAcceptor = null; @@ -109,7 +109,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex if ($expr->name instanceof Expr) { // process the dynamic callee name first, then consume its type rather // than reading it before processExprNode() stores its result - $nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->name, $scope, $storage, $nodeCallback, $context->enterDeep()); + $nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->name, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $nameType = $nameResult->getType(); if (!$nameType->isCallable()->no()) { $variants = $nameType->getCallableParametersAcceptors($scope); @@ -313,6 +313,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $storage, new NoopNodeCallback(), $context->enterDeep(), + null, ); $throwPoints = array_merge($throwPoints, $invokeResult->getThrowPoints()); $impurePoints = array_merge($impurePoints, $invokeResult->getImpurePoints()); diff --git a/src/Analyser/ExprHandler/Helper/ClosureTypeResolver.php b/src/Analyser/ExprHandler/Helper/ClosureTypeResolver.php index cb8411fed35..882cc5ccfb1 100644 --- a/src/Analyser/ExprHandler/Helper/ClosureTypeResolver.php +++ b/src/Analyser/ExprHandler/Helper/ClosureTypeResolver.php @@ -178,6 +178,7 @@ static function (Node $node, Scope $scope) use ($arrowScope, &$arrowFunctionImpu $invalidateExpressions[] = new InvalidateExprNode($node->getPropertyFetch()); }, ExpressionContext::createDeep(), + null, ); } finally { self::$resolveClosureTypeDepth--; diff --git a/src/Analyser/ExprHandler/IncludeHandler.php b/src/Analyser/ExprHandler/IncludeHandler.php index e251cd84f44..776459478aa 100644 --- a/src/Analyser/ExprHandler/IncludeHandler.php +++ b/src/Analyser/ExprHandler/IncludeHandler.php @@ -45,10 +45,10 @@ public function resolveType(MutatingScope $scope, Expr $expr): Type return new MixedType(); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; - $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep()); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $identifier = in_array($expr->type, [Include_::TYPE_INCLUDE, Include_::TYPE_INCLUDE_ONCE], true) ? 'include' : 'require'; $scope = $exprResult->getScope()->afterExtractCall()->invalidateVolatileExpressions(); diff --git a/src/Analyser/ExprHandler/InstanceofHandler.php b/src/Analyser/ExprHandler/InstanceofHandler.php index b5288696912..e33ffd1e25a 100644 --- a/src/Analyser/ExprHandler/InstanceofHandler.php +++ b/src/Analyser/ExprHandler/InstanceofHandler.php @@ -48,17 +48,17 @@ public function supports(Expr $expr): bool return $expr instanceof Instanceof_; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; - $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep()); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $hasYield = $exprResult->hasYield(); $throwPoints = $exprResult->getThrowPoints(); $impurePoints = $exprResult->getImpurePoints(); $isAlwaysTerminating = $exprResult->isAlwaysTerminating(); $scope = $exprResult->getScope(); if (!$expr->class instanceof Name) { - $classResult = $nodeScopeResolver->processExprNode($stmt, $expr->class, $scope, $storage, $nodeCallback, $context->enterDeep()); + $classResult = $nodeScopeResolver->processExprNode($stmt, $expr->class, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $scope = $classResult->getScope(); $hasYield = $hasYield || $classResult->hasYield(); $throwPoints = array_merge($throwPoints, $classResult->getThrowPoints()); diff --git a/src/Analyser/ExprHandler/InterpolatedStringHandler.php b/src/Analyser/ExprHandler/InterpolatedStringHandler.php index cdf2bdba301..64a8e60b321 100644 --- a/src/Analyser/ExprHandler/InterpolatedStringHandler.php +++ b/src/Analyser/ExprHandler/InterpolatedStringHandler.php @@ -44,7 +44,7 @@ public function supports(Expr $expr): bool return $expr instanceof InterpolatedString; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $hasYield = false; @@ -55,7 +55,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex if (!$part instanceof Expr) { continue; } - $partResult = $nodeScopeResolver->processExprNode($stmt, $part, $scope, $storage, $nodeCallback, $context->enterDeep()); + $partResult = $nodeScopeResolver->processExprNode($stmt, $part, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $hasYield = $hasYield || $partResult->hasYield(); $throwPoints = array_merge($throwPoints, $partResult->getThrowPoints()); $impurePoints = array_merge($impurePoints, $partResult->getImpurePoints()); diff --git a/src/Analyser/ExprHandler/IssetHandler.php b/src/Analyser/ExprHandler/IssetHandler.php index 82c1ae5af79..5709a0731e9 100644 --- a/src/Analyser/ExprHandler/IssetHandler.php +++ b/src/Analyser/ExprHandler/IssetHandler.php @@ -350,7 +350,7 @@ public function specifyTypes(TypeSpecifier $typeSpecifier, Scope $scope, Expr $e return $types; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $hasYield = false; @@ -362,7 +362,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex foreach ($expr->vars as $var) { $nonNullabilityResult = $this->nonNullabilityHelper->ensureNonNullability($scope, $var); $scope = $nodeScopeResolver->lookForSetAllowedUndefinedExpressions($nonNullabilityResult->getScope(), $var); - $varResult = $nodeScopeResolver->processExprNode($stmt, $var, $scope, $storage, $nodeCallback, $context->enterDeep()); + $varResult = $nodeScopeResolver->processExprNode($stmt, $var, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $varResults[] = $varResult; $scope = $varResult->getScope(); $hasYield = $hasYield || $varResult->hasYield(); diff --git a/src/Analyser/ExprHandler/MatchHandler.php b/src/Analyser/ExprHandler/MatchHandler.php index 719a9c10da3..98bb4bada72 100644 --- a/src/Analyser/ExprHandler/MatchHandler.php +++ b/src/Analyser/ExprHandler/MatchHandler.php @@ -207,11 +207,11 @@ public function getArmScopesAndTypes(MutatingScope $scope, Match_ $expr): array return $armScopesAndTypes; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $deepContext = $context->enterDeep(); - $condResult = $nodeScopeResolver->processExprNode($stmt, $expr->cond, $scope, $storage, $nodeCallback, $deepContext); + $condResult = $nodeScopeResolver->processExprNode($stmt, $expr->cond, $scope, $storage, $nodeCallback, $deepContext, null); $condType = $condResult->getType(); $condNativeType = $condResult->getNativeType(); $scope = $condResult->getScope(); @@ -322,7 +322,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex } } - $nodeScopeResolver->processExprNode($stmt, $cond, $armConditionScope, $storage, $nodeCallback, $deepContext); + $nodeScopeResolver->processExprNode($stmt, $cond, $armConditionScope, $storage, $nodeCallback, $deepContext, null); $condNodes[] = new MatchExpressionArmCondition( $cond, @@ -359,6 +359,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $storage, $nodeCallback, ExpressionContext::createTopLevel(), + null, ); $armScope = $armResult->getScope(); if (!$armResult->isAlwaysTerminating()) { @@ -395,7 +396,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $hasDefaultCond = true; $matchArmBody = new MatchExpressionArmBody($matchScope, $arm->body); $armNodes[$i] = new MatchExpressionArm($matchArmBody, [], $arm->getStartLine()); - $armResult = $nodeScopeResolver->processExprNode($stmt, $arm->body, $matchScope, $storage, $nodeCallback, ExpressionContext::createTopLevel()); + $armResult = $nodeScopeResolver->processExprNode($stmt, $arm->body, $matchScope, $storage, $nodeCallback, ExpressionContext::createTopLevel(), null); $matchScope = $armResult->getScope(); $hasYield = $hasYield || $armResult->hasYield(); $throwPoints = array_merge($throwPoints, $armResult->getThrowPoints()); @@ -420,7 +421,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex continue; } $condNodes[] = new MatchExpressionArmCondition($armCond, $armCondScope, $armCond->getStartLine()); - $armCondResult = $nodeScopeResolver->processExprNode($stmt, $armCond, $armCondScope, $storage, $nodeCallback, $deepContext); + $armCondResult = $nodeScopeResolver->processExprNode($stmt, $armCond, $armCondScope, $storage, $nodeCallback, $deepContext, null); $hasYield = $hasYield || $armCondResult->hasYield(); $throwPoints = array_merge($throwPoints, $armCondResult->getThrowPoints()); $impurePoints = array_merge($impurePoints, $armCondResult->getImpurePoints()); @@ -451,6 +452,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $storage, $nodeCallback, ExpressionContext::createTopLevel(), + null, ); $armScope = $armResult->getScope(); if (!$armResult->isAlwaysTerminating()) { diff --git a/src/Analyser/ExprHandler/MethodCallHandler.php b/src/Analyser/ExprHandler/MethodCallHandler.php index 8a07d219db7..29b9e1212b5 100644 --- a/src/Analyser/ExprHandler/MethodCallHandler.php +++ b/src/Analyser/ExprHandler/MethodCallHandler.php @@ -75,7 +75,7 @@ public function supports(Expr $expr): bool return $expr instanceof MethodCall && !$expr->isFirstClassCallable(); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $originalScope = $scope; @@ -91,7 +91,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex ); } - $varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $closureCallScope ?? $scope, $storage, $nodeCallback, $context->enterDeep()); + $varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $closureCallScope ?? $scope, $storage, $nodeCallback, $context->enterDeep(), null); $hasYield = $varResult->hasYield(); $throwPoints = $varResult->getThrowPoints(); $impurePoints = $varResult->getImpurePoints(); @@ -117,7 +117,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $parametersAcceptor = ParametersAcceptorSelector::combineVariantsForNormalization($expr->getArgs(), $variants, $namedArgumentsVariants); } } else { - $methodNameResult = $nodeScopeResolver->processExprNode($stmt, $expr->name, $scope, $storage, $nodeCallback, $context->enterDeep()); + $methodNameResult = $nodeScopeResolver->processExprNode($stmt, $expr->name, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $throwPoints = array_merge($throwPoints, $methodNameResult->getThrowPoints()); $scope = $methodNameResult->getScope(); } diff --git a/src/Analyser/ExprHandler/NewHandler.php b/src/Analyser/ExprHandler/NewHandler.php index 639a21b85db..85e66dd2252 100644 --- a/src/Analyser/ExprHandler/NewHandler.php +++ b/src/Analyser/ExprHandler/NewHandler.php @@ -96,7 +96,7 @@ public function supports(Expr $expr): bool return $expr instanceof New_ && !$expr->isFirstClassCallable(); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $parametersAcceptor = null; @@ -178,7 +178,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $isDynamic = true; $objectClasses = $scope->getType($expr)->getObjectClassNames(); if (count($objectClasses) === 1) { - $objectExprResult = $nodeScopeResolver->processExprNode($stmt, new New_(new Name($objectClasses[0])), $scope, $storage, new NoopNodeCallback(), $context->enterDeep()); + $objectExprResult = $nodeScopeResolver->processExprNode($stmt, new New_(new Name($objectClasses[0])), $scope, $storage, new NoopNodeCallback(), $context->enterDeep(), null); $className = $objectClasses[0]; $additionalThrowPoints = $objectExprResult->getThrowPoints(); } else { @@ -186,7 +186,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $additionalThrowPoints = [InternalThrowPoint::createImplicit($scope, $expr)]; } - $classResult = $nodeScopeResolver->processExprNode($stmt, $expr->class, $scope, $storage, $nodeCallback, $context->enterDeep()); + $classResult = $nodeScopeResolver->processExprNode($stmt, $expr->class, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $scope = $classResult->getScope(); $hasYield = $classResult->hasYield(); $throwPoints = $classResult->getThrowPoints(); diff --git a/src/Analyser/ExprHandler/NullsafeMethodCallHandler.php b/src/Analyser/ExprHandler/NullsafeMethodCallHandler.php index 30ddfc2c4c2..6b0153d6c53 100644 --- a/src/Analyser/ExprHandler/NullsafeMethodCallHandler.php +++ b/src/Analyser/ExprHandler/NullsafeMethodCallHandler.php @@ -85,7 +85,7 @@ public function specifyTypes(TypeSpecifier $typeSpecifier, Scope $scope, Expr $e return $context->true() ? $types->unionWith($nullSafeTypes) : $types->intersectWith($nullSafeTypes); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $calledOnType = $scope->getScopeType($expr->var); @@ -108,6 +108,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $storage, $nodeCallback, $context, + null, ); $scope = $this->nonNullabilityHelper->revertNonNullability($exprResult->getScope(), $nonNullabilityResult->getSpecifiedExpressions()); diff --git a/src/Analyser/ExprHandler/NullsafePropertyFetchHandler.php b/src/Analyser/ExprHandler/NullsafePropertyFetchHandler.php index a81a392a55d..db046ebef0c 100644 --- a/src/Analyser/ExprHandler/NullsafePropertyFetchHandler.php +++ b/src/Analyser/ExprHandler/NullsafePropertyFetchHandler.php @@ -85,7 +85,7 @@ public function specifyTypes(TypeSpecifier $typeSpecifier, Scope $scope, Expr $e return $context->true() ? $types->unionWith($nullSafeTypes) : $types->intersectWith($nullSafeTypes); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $calledOnType = $scope->getScopeType($expr->var); @@ -97,7 +97,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $expr->var, $expr->name, $attributes, - ), $nonNullabilityResult->getScope(), $storage, $nodeCallback, $context); + ), $nonNullabilityResult->getScope(), $storage, $nodeCallback, $context, null); $scope = $this->nonNullabilityHelper->revertNonNullability($exprResult->getScope(), $nonNullabilityResult->getSpecifiedExpressions()); // the nullsafe operation is processed; emit a virtual node carrying the diff --git a/src/Analyser/ExprHandler/PipeHandler.php b/src/Analyser/ExprHandler/PipeHandler.php index a10009c2d56..4a8ae31238f 100644 --- a/src/Analyser/ExprHandler/PipeHandler.php +++ b/src/Analyser/ExprHandler/PipeHandler.php @@ -63,7 +63,7 @@ public function resolveType(MutatingScope $scope, Expr $expr): Type ])); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $rightAttributes = array_merge($expr->right->getAttributes(), ['virtualPipeOperatorCall' => true]); unset($rightAttributes[ExprPrinter::ATTRIBUTE_CACHE_KEY]); @@ -106,7 +106,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex )); } - $callResult = $nodeScopeResolver->processExprNode($stmt, $callExpr, $scope, $storage, $nodeCallback, $context); + $callResult = $nodeScopeResolver->processExprNode($stmt, $callExpr, $scope, $storage, $nodeCallback, $context, null); return $this->expressionResultFactory->create( $callResult->getScope(), diff --git a/src/Analyser/ExprHandler/PostDecHandler.php b/src/Analyser/ExprHandler/PostDecHandler.php index a4ede3c45b0..1eda61ecd8c 100644 --- a/src/Analyser/ExprHandler/PostDecHandler.php +++ b/src/Analyser/ExprHandler/PostDecHandler.php @@ -36,9 +36,9 @@ public function supports(Expr $expr): bool return $expr instanceof PostDec; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { - $varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $scope, $storage, $nodeCallback, $context->enterDeep()); + $varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $scope, $storage, $nodeCallback, $context->enterDeep(), null); // processVirtualAssign() emits nodes (PropertyAssignNode) whose rules ask // about this whole expression - store a before-scope anchored result diff --git a/src/Analyser/ExprHandler/PostIncHandler.php b/src/Analyser/ExprHandler/PostIncHandler.php index 45feee87c08..ca7c1d86ca5 100644 --- a/src/Analyser/ExprHandler/PostIncHandler.php +++ b/src/Analyser/ExprHandler/PostIncHandler.php @@ -36,9 +36,9 @@ public function supports(Expr $expr): bool return $expr instanceof PostInc; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { - $varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $scope, $storage, $nodeCallback, $context->enterDeep()); + $varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $scope, $storage, $nodeCallback, $context->enterDeep(), null); // processVirtualAssign() emits nodes (PropertyAssignNode) whose rules ask // about this whole expression - store a before-scope anchored result diff --git a/src/Analyser/ExprHandler/PreDecHandler.php b/src/Analyser/ExprHandler/PreDecHandler.php index 542fecd6a28..6c71fd46022 100644 --- a/src/Analyser/ExprHandler/PreDecHandler.php +++ b/src/Analyser/ExprHandler/PreDecHandler.php @@ -99,9 +99,9 @@ public function resolveType(MutatingScope $scope, Expr $expr): Type return $scope->getType(new Minus($expr->var, new Int_(1))); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { - $varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $scope, $storage, $nodeCallback, $context->enterDeep()); + $varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $scope, $storage, $nodeCallback, $context->enterDeep(), null); // processVirtualAssign() emits nodes (PropertyAssignNode) whose rules ask // about this whole expression - store a before-scope anchored result diff --git a/src/Analyser/ExprHandler/PreIncHandler.php b/src/Analyser/ExprHandler/PreIncHandler.php index f1cfc99720a..f772b022bc6 100644 --- a/src/Analyser/ExprHandler/PreIncHandler.php +++ b/src/Analyser/ExprHandler/PreIncHandler.php @@ -100,9 +100,9 @@ public function resolveType(MutatingScope $scope, Expr $expr): Type return $scope->getType(new Plus($expr->var, new Int_(1))); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { - $varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $scope, $storage, $nodeCallback, $context->enterDeep()); + $varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $scope, $storage, $nodeCallback, $context->enterDeep(), null); // processVirtualAssign() emits nodes (PropertyAssignNode) whose rules ask // about this whole expression - store a before-scope anchored result diff --git a/src/Analyser/ExprHandler/PrintHandler.php b/src/Analyser/ExprHandler/PrintHandler.php index cd6a90aee17..cfff0e3f0a6 100644 --- a/src/Analyser/ExprHandler/PrintHandler.php +++ b/src/Analyser/ExprHandler/PrintHandler.php @@ -47,10 +47,10 @@ public function resolveType(MutatingScope $scope, Expr $expr): Type return new ConstantIntegerType(1); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; - $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep()); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $throwPoints = $exprResult->getThrowPoints(); $impurePoints = $exprResult->getImpurePoints(); diff --git a/src/Analyser/ExprHandler/PropertyFetchHandler.php b/src/Analyser/ExprHandler/PropertyFetchHandler.php index efb6d007bb9..a25f0209250 100644 --- a/src/Analyser/ExprHandler/PropertyFetchHandler.php +++ b/src/Analyser/ExprHandler/PropertyFetchHandler.php @@ -55,14 +55,14 @@ public function supports(Expr $expr): bool return $expr instanceof PropertyFetch; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $scopeBeforeVar = $scope; - $varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $scope, $storage, $nodeCallback, $context->enterDeep()); + $varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $nameResult = null; if (!$expr->name instanceof Identifier) { - $nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->name, $varResult->getScope(), $storage, $nodeCallback, $context->enterDeep()); + $nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->name, $varResult->getScope(), $storage, $nodeCallback, $context->enterDeep(), null); } return $this->composeResult($nodeScopeResolver, $expr, $varResult, $nameResult, $scopeBeforeVar, $beforeScope); diff --git a/src/Analyser/ExprHandler/ScalarHandler.php b/src/Analyser/ExprHandler/ScalarHandler.php index 9b4de986801..b2a79e8cba6 100644 --- a/src/Analyser/ExprHandler/ScalarHandler.php +++ b/src/Analyser/ExprHandler/ScalarHandler.php @@ -41,7 +41,7 @@ public function supports(Expr $expr): bool return $expr instanceof Scalar && !$expr instanceof InterpolatedString; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { return $this->expressionResultFactory->create( $scope, diff --git a/src/Analyser/ExprHandler/ShellExecHandler.php b/src/Analyser/ExprHandler/ShellExecHandler.php index fa756b88650..72f226fafae 100644 --- a/src/Analyser/ExprHandler/ShellExecHandler.php +++ b/src/Analyser/ExprHandler/ShellExecHandler.php @@ -48,7 +48,7 @@ public function supports(Expr $expr): bool return $expr instanceof ShellExec; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $hasYield = false; @@ -59,7 +59,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex if (!$part instanceof Expr) { continue; } - $partResult = $nodeScopeResolver->processExprNode($stmt, $part, $scope, $storage, $nodeCallback, $context->enterDeep()); + $partResult = $nodeScopeResolver->processExprNode($stmt, $part, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $hasYield = $hasYield || $partResult->hasYield(); $throwPoints = array_merge($throwPoints, $partResult->getThrowPoints()); $impurePoints = array_merge($impurePoints, $partResult->getImpurePoints()); diff --git a/src/Analyser/ExprHandler/StaticCallHandler.php b/src/Analyser/ExprHandler/StaticCallHandler.php index 606248f72a9..e935cbc4b46 100644 --- a/src/Analyser/ExprHandler/StaticCallHandler.php +++ b/src/Analyser/ExprHandler/StaticCallHandler.php @@ -81,7 +81,7 @@ public function supports(Expr $expr): bool return $expr instanceof StaticCall && !$expr->isFirstClassCallable(); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $hasYield = false; @@ -90,7 +90,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $isAlwaysTerminating = false; $containsNullsafe = false; if ($expr->class instanceof Expr) { - $classResult = $nodeScopeResolver->processExprNode($stmt, $expr->class, $scope, $storage, $nodeCallback, $context->enterDeep()); + $classResult = $nodeScopeResolver->processExprNode($stmt, $expr->class, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $hasYield = $classResult->hasYield(); $throwPoints = array_merge($throwPoints, $classResult->getThrowPoints()); $impurePoints = array_merge($impurePoints, $classResult->getImpurePoints()); @@ -179,7 +179,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex } } } else { - $nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->name, $scope, $storage, $nodeCallback, $context->enterDeep()); + $nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->name, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $hasYield = $hasYield || $nameResult->hasYield(); $throwPoints = array_merge($throwPoints, $nameResult->getThrowPoints()); $impurePoints = array_merge($impurePoints, $nameResult->getImpurePoints()); @@ -192,7 +192,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $objectClasses = $scope->getType(new New_($expr->class))->getObjectClassNames(); } if (count($objectClasses) === 1) { - $objectExprResult = $nodeScopeResolver->processExprNode($stmt, new StaticCall(new Name($objectClasses[0]), $expr->name, []), $scope, $storage, new NoopNodeCallback(), $context->enterDeep()); + $objectExprResult = $nodeScopeResolver->processExprNode($stmt, new StaticCall(new Name($objectClasses[0]), $expr->name, []), $scope, $storage, new NoopNodeCallback(), $context->enterDeep(), null); $additionalThrowPoints = $objectExprResult->getThrowPoints(); } else { $additionalThrowPoints = [InternalThrowPoint::createImplicit($scope, $expr)]; diff --git a/src/Analyser/ExprHandler/StaticPropertyFetchHandler.php b/src/Analyser/ExprHandler/StaticPropertyFetchHandler.php index 3283f6fdadf..b05bff6ba33 100644 --- a/src/Analyser/ExprHandler/StaticPropertyFetchHandler.php +++ b/src/Analyser/ExprHandler/StaticPropertyFetchHandler.php @@ -53,17 +53,17 @@ public function supports(Expr $expr): bool return $expr instanceof StaticPropertyFetch; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $classResult = null; if ($expr->class instanceof Expr) { - $classResult = $nodeScopeResolver->processExprNode($stmt, $expr->class, $scope, $storage, $nodeCallback, $context->enterDeep()); + $classResult = $nodeScopeResolver->processExprNode($stmt, $expr->class, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $scope = $classResult->getScope(); } $nameResult = null; if (!$expr->name instanceof VarLikeIdentifier) { - $nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->name, $scope, $storage, $nodeCallback, $context->enterDeep()); + $nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->name, $scope, $storage, $nodeCallback, $context->enterDeep(), null); } return $this->composeResult($expr, $classResult, $nameResult, $beforeScope); diff --git a/src/Analyser/ExprHandler/TernaryHandler.php b/src/Analyser/ExprHandler/TernaryHandler.php index 16350c525c1..a8d48444356 100644 --- a/src/Analyser/ExprHandler/TernaryHandler.php +++ b/src/Analyser/ExprHandler/TernaryHandler.php @@ -46,7 +46,7 @@ public function supports(Expr $expr): bool public function resolveType(MutatingScope $scope, Expr $expr): Type { - $condResult = $this->nodeScopeResolver->processExprNode(new Stmt\Expression($expr->cond), $expr->cond, $scope, new ExpressionResultStorage(), new NoopNodeCallback(), ExpressionContext::createDeep()); + $condResult = $this->nodeScopeResolver->processExprNode(new Stmt\Expression($expr->cond), $expr->cond, $scope, new ExpressionResultStorage(), new NoopNodeCallback(), ExpressionContext::createDeep(), null); if ($expr->if === null) { $conditionType = $scope->getType($expr->cond); $booleanConditionType = $conditionType->toBoolean(); @@ -100,9 +100,9 @@ public function specifyTypes(TypeSpecifier $typeSpecifier, Scope $scope, Expr $e return $typeSpecifier->specifyTypesInCondition($scope, $conditionExpr, $context)->setRootExpr($expr); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { - $ternaryCondResult = $nodeScopeResolver->processExprNode($stmt, $expr->cond, $scope, $storage, $nodeCallback, $context->enterDeep()); + $ternaryCondResult = $nodeScopeResolver->processExprNode($stmt, $expr->cond, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $throwPoints = $ternaryCondResult->getThrowPoints(); $impurePoints = $ternaryCondResult->getImpurePoints(); $hasYield = $ternaryCondResult->hasYield(); @@ -111,20 +111,20 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $ifTrueType = null; if ($expr->if === null) { - $elseResult = $nodeScopeResolver->processExprNode($stmt, $expr->else, $ifFalseScope, $storage, $nodeCallback, $context); + $elseResult = $nodeScopeResolver->processExprNode($stmt, $expr->else, $ifFalseScope, $storage, $nodeCallback, $context, null); $throwPoints = array_merge($throwPoints, $elseResult->getThrowPoints()); $impurePoints = array_merge($impurePoints, $elseResult->getImpurePoints()); $hasYield = $hasYield || $elseResult->hasYield(); $ifFalseScope = $elseResult->getScope(); } else { - $ifResult = $nodeScopeResolver->processExprNode($stmt, $expr->if, $ifTrueScope, $storage, $nodeCallback, $context); + $ifResult = $nodeScopeResolver->processExprNode($stmt, $expr->if, $ifTrueScope, $storage, $nodeCallback, $context, null); $throwPoints = array_merge($throwPoints, $ifResult->getThrowPoints()); $impurePoints = array_merge($impurePoints, $ifResult->getImpurePoints()); $hasYield = $hasYield || $ifResult->hasYield(); $ifTrueScope = $ifResult->getScope(); $ifTrueType = $ifResult->getType(); - $elseResult = $nodeScopeResolver->processExprNode($stmt, $expr->else, $ifFalseScope, $storage, $nodeCallback, $context); + $elseResult = $nodeScopeResolver->processExprNode($stmt, $expr->else, $ifFalseScope, $storage, $nodeCallback, $context, null); $throwPoints = array_merge($throwPoints, $elseResult->getThrowPoints()); $impurePoints = array_merge($impurePoints, $elseResult->getImpurePoints()); $hasYield = $hasYield || $elseResult->hasYield(); diff --git a/src/Analyser/ExprHandler/ThrowHandler.php b/src/Analyser/ExprHandler/ThrowHandler.php index e9b1ce7d37a..45bc3a2bdb3 100644 --- a/src/Analyser/ExprHandler/ThrowHandler.php +++ b/src/Analyser/ExprHandler/ThrowHandler.php @@ -38,9 +38,9 @@ public function supports(Expr $expr): bool return $expr instanceof Throw_; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { - $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, ExpressionContext::createDeep()->enterThrow()); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, ExpressionContext::createDeep()->enterThrow(), null); return $this->expressionResultFactory->create( $scope, diff --git a/src/Analyser/ExprHandler/UnaryMinusHandler.php b/src/Analyser/ExprHandler/UnaryMinusHandler.php index ea67e7dabc4..3304dbc75e3 100644 --- a/src/Analyser/ExprHandler/UnaryMinusHandler.php +++ b/src/Analyser/ExprHandler/UnaryMinusHandler.php @@ -39,9 +39,9 @@ public function supports(Expr $expr): bool return $expr instanceof UnaryMinus; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { - $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep()); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep(), null); return $this->expressionResultFactory->create( $exprResult->getScope(), diff --git a/src/Analyser/ExprHandler/UnaryPlusHandler.php b/src/Analyser/ExprHandler/UnaryPlusHandler.php index 6ec1abe38fc..f5805cdf310 100644 --- a/src/Analyser/ExprHandler/UnaryPlusHandler.php +++ b/src/Analyser/ExprHandler/UnaryPlusHandler.php @@ -39,9 +39,9 @@ public function supports(Expr $expr): bool return $expr instanceof UnaryPlus; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { - $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep()); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep(), null); return $this->expressionResultFactory->create( $exprResult->getScope(), diff --git a/src/Analyser/ExprHandler/VariableHandler.php b/src/Analyser/ExprHandler/VariableHandler.php index 8cdfdd7b387..846b06a8d61 100644 --- a/src/Analyser/ExprHandler/VariableHandler.php +++ b/src/Analyser/ExprHandler/VariableHandler.php @@ -77,12 +77,12 @@ public function resolveType(MutatingScope $scope, Expr $expr): Type return new MixedType(); } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $nameResult = null; if (!is_string($expr->name)) { - $nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->name, $scope, $storage, $nodeCallback, $context->enterDeep()); + $nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->name, $scope, $storage, $nodeCallback, $context->enterDeep(), null); } return $this->composeResult($expr, $nameResult, $beforeScope); diff --git a/src/Analyser/ExprHandler/Virtual/AlwaysRememberedExprHandler.php b/src/Analyser/ExprHandler/Virtual/AlwaysRememberedExprHandler.php index 99d6d9925e8..2840e56163d 100644 --- a/src/Analyser/ExprHandler/Virtual/AlwaysRememberedExprHandler.php +++ b/src/Analyser/ExprHandler/Virtual/AlwaysRememberedExprHandler.php @@ -43,11 +43,12 @@ public function processExpr( ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, + ?Type $overriddenType, ): ExpressionResult { $beforeScope = $scope; $innerExpr = $expr->getExpr(); - $innerResult = $nodeScopeResolver->processExprNode($stmt, $innerExpr, $scope, $storage, $nodeCallback, $context); + $innerResult = $nodeScopeResolver->processExprNode($stmt, $innerExpr, $scope, $storage, $nodeCallback, $context, null); $scope = $innerResult->getScope(); return $this->expressionResultFactory->create( diff --git a/src/Analyser/ExprHandler/Virtual/ExistingArrayDimFetchHandler.php b/src/Analyser/ExprHandler/Virtual/ExistingArrayDimFetchHandler.php index 411d2ee8d65..2e832d641d5 100644 --- a/src/Analyser/ExprHandler/Virtual/ExistingArrayDimFetchHandler.php +++ b/src/Analyser/ExprHandler/Virtual/ExistingArrayDimFetchHandler.php @@ -35,7 +35,7 @@ public function supports(Expr $expr): bool return $expr instanceof ExistingArrayDimFetch; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { // because this is a virtual node handler, the caller will only be interested in the type // we don't need to process the inner expr diff --git a/src/Analyser/ExprHandler/Virtual/FunctionCallableNodeHandler.php b/src/Analyser/ExprHandler/Virtual/FunctionCallableNodeHandler.php index e56509e627e..bb40f102f36 100644 --- a/src/Analyser/ExprHandler/Virtual/FunctionCallableNodeHandler.php +++ b/src/Analyser/ExprHandler/Virtual/FunctionCallableNodeHandler.php @@ -36,7 +36,7 @@ public function supports(Expr $expr): bool return $expr instanceof FunctionCallableNode; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $throwPoints = []; @@ -44,7 +44,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $hasYield = false; $isAlwaysTerminating = false; if ($expr->getName() instanceof Expr) { - $nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->getName(), $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->getName(), $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $scope = $nameResult->getScope(); $hasYield = $nameResult->hasYield(); $throwPoints = $nameResult->getThrowPoints(); diff --git a/src/Analyser/ExprHandler/Virtual/InstantiationCallableNodeHandler.php b/src/Analyser/ExprHandler/Virtual/InstantiationCallableNodeHandler.php index 937b6618d85..129391d4194 100644 --- a/src/Analyser/ExprHandler/Virtual/InstantiationCallableNodeHandler.php +++ b/src/Analyser/ExprHandler/Virtual/InstantiationCallableNodeHandler.php @@ -36,7 +36,7 @@ public function supports(Expr $expr): bool return $expr instanceof InstantiationCallableNode; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $throwPoints = []; @@ -44,7 +44,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $hasYield = false; $isAlwaysTerminating = false; if ($expr->getClass() instanceof Expr) { - $classResult = $nodeScopeResolver->processExprNode($stmt, $expr->getClass(), $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $classResult = $nodeScopeResolver->processExprNode($stmt, $expr->getClass(), $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $scope = $classResult->getScope(); $hasYield = $classResult->hasYield(); $throwPoints = $classResult->getThrowPoints(); diff --git a/src/Analyser/ExprHandler/Virtual/IssetExprHandler.php b/src/Analyser/ExprHandler/Virtual/IssetExprHandler.php index 8709610e6c0..7ba39bf3e22 100644 --- a/src/Analyser/ExprHandler/Virtual/IssetExprHandler.php +++ b/src/Analyser/ExprHandler/Virtual/IssetExprHandler.php @@ -42,7 +42,7 @@ public function supports(Expr $expr): bool return $expr instanceof IssetExpr; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { // a virtual node handler - the caller will only be interested in the // type; the inner expr is not processed, its type is just reported diff --git a/src/Analyser/ExprHandler/Virtual/MethodCallableNodeHandler.php b/src/Analyser/ExprHandler/Virtual/MethodCallableNodeHandler.php index 28492541bce..502d309fd5e 100644 --- a/src/Analyser/ExprHandler/Virtual/MethodCallableNodeHandler.php +++ b/src/Analyser/ExprHandler/Virtual/MethodCallableNodeHandler.php @@ -37,17 +37,17 @@ public function supports(Expr $expr): bool return $expr instanceof MethodCallableNode; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; - $varResult = $nodeScopeResolver->processExprNode($stmt, $expr->getVar(), $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $varResult = $nodeScopeResolver->processExprNode($stmt, $expr->getVar(), $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $scope = $varResult->getScope(); $hasYield = $varResult->hasYield(); $throwPoints = $varResult->getThrowPoints(); $impurePoints = $varResult->getImpurePoints(); $isAlwaysTerminating = false; if ($expr->getName() instanceof Expr) { - $nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->getName(), $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->getName(), $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $scope = $nameResult->getScope(); $hasYield = $hasYield || $nameResult->hasYield(); $throwPoints = array_merge($throwPoints, $nameResult->getThrowPoints()); diff --git a/src/Analyser/ExprHandler/Virtual/NativeTypeExprHandler.php b/src/Analyser/ExprHandler/Virtual/NativeTypeExprHandler.php index 852d00b14cd..be509c911e2 100644 --- a/src/Analyser/ExprHandler/Virtual/NativeTypeExprHandler.php +++ b/src/Analyser/ExprHandler/Virtual/NativeTypeExprHandler.php @@ -35,7 +35,7 @@ public function supports(Expr $expr): bool return $expr instanceof NativeTypeExpr; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { // because this is a virtual node handler, the caller will only be interested in the type // we don't need to process the inner expr diff --git a/src/Analyser/ExprHandler/Virtual/SetExistingOffsetValueTypeExprHandler.php b/src/Analyser/ExprHandler/Virtual/SetExistingOffsetValueTypeExprHandler.php index 31f221a9e32..5b80d6b3721 100644 --- a/src/Analyser/ExprHandler/Virtual/SetExistingOffsetValueTypeExprHandler.php +++ b/src/Analyser/ExprHandler/Virtual/SetExistingOffsetValueTypeExprHandler.php @@ -35,7 +35,7 @@ public function supports(Expr $expr): bool return $expr instanceof SetExistingOffsetValueTypeExpr; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { // because this is a virtual node handler, the caller will only be interested in the type // we don't need to process the inner expr diff --git a/src/Analyser/ExprHandler/Virtual/SetOffsetValueTypeExprHandler.php b/src/Analyser/ExprHandler/Virtual/SetOffsetValueTypeExprHandler.php index ee9201224ee..abbdf58ce6b 100644 --- a/src/Analyser/ExprHandler/Virtual/SetOffsetValueTypeExprHandler.php +++ b/src/Analyser/ExprHandler/Virtual/SetOffsetValueTypeExprHandler.php @@ -35,7 +35,7 @@ public function supports(Expr $expr): bool return $expr instanceof SetOffsetValueTypeExpr; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { // because this is a virtual node handler, the caller will only be interested in the type // we don't need to process the inner expr diff --git a/src/Analyser/ExprHandler/Virtual/StaticMethodCallableNodeHandler.php b/src/Analyser/ExprHandler/Virtual/StaticMethodCallableNodeHandler.php index b12d7e120e5..69b82bcd7a9 100644 --- a/src/Analyser/ExprHandler/Virtual/StaticMethodCallableNodeHandler.php +++ b/src/Analyser/ExprHandler/Virtual/StaticMethodCallableNodeHandler.php @@ -37,7 +37,7 @@ public function supports(Expr $expr): bool return $expr instanceof StaticMethodCallableNode; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $throwPoints = []; @@ -45,7 +45,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $hasYield = false; $isAlwaysTerminating = false; if ($expr->getClass() instanceof Expr) { - $classResult = $nodeScopeResolver->processExprNode($stmt, $expr->getClass(), $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $classResult = $nodeScopeResolver->processExprNode($stmt, $expr->getClass(), $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $scope = $classResult->getScope(); $hasYield = $classResult->hasYield(); $throwPoints = $classResult->getThrowPoints(); @@ -53,7 +53,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex $isAlwaysTerminating = $classResult->isAlwaysTerminating(); } if ($expr->getName() instanceof Expr) { - $nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->getName(), $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $nameResult = $nodeScopeResolver->processExprNode($stmt, $expr->getName(), $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $scope = $nameResult->getScope(); $hasYield = $hasYield || $nameResult->hasYield(); $throwPoints = array_merge($throwPoints, $nameResult->getThrowPoints()); diff --git a/src/Analyser/ExprHandler/Virtual/TypeExprHandler.php b/src/Analyser/ExprHandler/Virtual/TypeExprHandler.php index 6ca636fe081..c1fe6be22a2 100644 --- a/src/Analyser/ExprHandler/Virtual/TypeExprHandler.php +++ b/src/Analyser/ExprHandler/Virtual/TypeExprHandler.php @@ -35,7 +35,7 @@ public function supports(Expr $expr): bool return $expr instanceof TypeExpr; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { // because this is a virtual node handler, the caller will only be interested in the type // we don't need to process the inner expr diff --git a/src/Analyser/ExprHandler/Virtual/UnsetOffsetExprHandler.php b/src/Analyser/ExprHandler/Virtual/UnsetOffsetExprHandler.php index d414e648fd2..0556490cf68 100644 --- a/src/Analyser/ExprHandler/Virtual/UnsetOffsetExprHandler.php +++ b/src/Analyser/ExprHandler/Virtual/UnsetOffsetExprHandler.php @@ -35,7 +35,7 @@ public function supports(Expr $expr): bool return $expr instanceof UnsetOffsetExpr; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { // because this is a virtual node handler, the caller will only be interested in the type // we don't need to process the inner expr diff --git a/src/Analyser/ExprHandler/YieldFromHandler.php b/src/Analyser/ExprHandler/YieldFromHandler.php index 1aac8244af7..b36e6d9cb1a 100644 --- a/src/Analyser/ExprHandler/YieldFromHandler.php +++ b/src/Analyser/ExprHandler/YieldFromHandler.php @@ -52,10 +52,10 @@ public function resolveType(MutatingScope $scope, Expr $expr): Type return $generatorReturnType; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; - $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep()); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $expr->expr, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $scope = $exprResult->getScope(); return $this->expressionResultFactory->create( diff --git a/src/Analyser/ExprHandler/YieldHandler.php b/src/Analyser/ExprHandler/YieldHandler.php index 07abbc7e6ee..b602bcab54e 100644 --- a/src/Analyser/ExprHandler/YieldHandler.php +++ b/src/Analyser/ExprHandler/YieldHandler.php @@ -57,7 +57,7 @@ public function resolveType(MutatingScope $scope, Expr $expr): Type return $generatorSendType; } - public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult + public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, ?Type $overriddenType): ExpressionResult { $beforeScope = $scope; $throwPoints = [ @@ -74,14 +74,14 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex ]; $isAlwaysTerminating = false; if ($expr->key !== null) { - $keyResult = $nodeScopeResolver->processExprNode($stmt, $expr->key, $scope, $storage, $nodeCallback, $context->enterDeep()); + $keyResult = $nodeScopeResolver->processExprNode($stmt, $expr->key, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $scope = $keyResult->getScope(); $throwPoints = $keyResult->getThrowPoints(); $impurePoints = array_merge($impurePoints, $keyResult->getImpurePoints()); $isAlwaysTerminating = $keyResult->isAlwaysTerminating(); } if ($expr->value !== null) { - $valueResult = $nodeScopeResolver->processExprNode($stmt, $expr->value, $scope, $storage, $nodeCallback, $context->enterDeep()); + $valueResult = $nodeScopeResolver->processExprNode($stmt, $expr->value, $scope, $storage, $nodeCallback, $context->enterDeep(), null); $scope = $valueResult->getScope(); $throwPoints = array_merge($throwPoints, $valueResult->getThrowPoints()); $impurePoints = array_merge($impurePoints, $valueResult->getImpurePoints()); diff --git a/src/Analyser/NodeScopeResolver.php b/src/Analyser/NodeScopeResolver.php index 90e7657c837..85be707f7ae 100644 --- a/src/Analyser/NodeScopeResolver.php +++ b/src/Analyser/NodeScopeResolver.php @@ -77,6 +77,7 @@ use PHPStan\ShouldNotHappenException; use PHPStan\TrinaryLogic; use PHPStan\Type\ClosureType; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPStan\Type\FileTypeMapper; use PHPStan\Type\FunctionParameterClosureThisExtension; use PHPStan\Type\FunctionParameterClosureTypeExtension; @@ -171,6 +172,7 @@ public function __construct( private readonly ExtensionsCollection $methodParameterClosureThisExtensions, #[AutowiredExtensions(of: StaticMethodParameterClosureThisExtension::class)] private readonly ExtensionsCollection $staticMethodParameterClosureThisExtensions, + private readonly DynamicParameterTypeResolver $dynamicParameterTypeResolver, #[AutowiredExtensions(of: FunctionParameterClosureTypeExtension::class)] private readonly ExtensionsCollection $functionParameterClosureTypeExtensions, #[AutowiredExtensions(of: MethodParameterClosureTypeExtension::class)] @@ -867,6 +869,7 @@ public function processExprNode( ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context, + ?Type $overriddenType, ): ExpressionResult { if ($expr instanceof Expr\CallLike && $expr->isFirstClassCallable()) { @@ -882,7 +885,7 @@ public function processExprNode( throw new ShouldNotHappenException(); } - $newExprResult = $this->processExprNode($stmt, $newExpr, $scope, $storage, $nodeCallback, $context); + $newExprResult = $this->processExprNode($stmt, $newExpr, $scope, $storage, $nodeCallback, $context, null); $expressionResult = $this->expressionResultFactory->create( $newExprResult->getScope(), beforeScope: $scope, @@ -898,7 +901,7 @@ public function processExprNode( $exprHandler = ExprHandlerRegistry::resolve($expr, $this->container); if ($exprHandler !== null) { - $expressionResult = $exprHandler->processExpr($this, $stmt, $expr, $scope, $storage, $nodeCallback, $context); + $expressionResult = $exprHandler->processExpr($this, $stmt, $expr, $scope, $storage, $nodeCallback, $context, $overriddenType); $this->storeExpressionResult($storage, $expr, $expressionResult); // The node's own callback fires AFTER its result is stored, with the // scope captured before processing. Rules observe the same (scope, @@ -1209,7 +1212,7 @@ public function processClosureNode( $scope = $scope->assignVariable($inAssignRightSideVariableName, $variableType, $variableNativeType, TrinaryLogic::createYes()); } } - $this->processExprNode($stmt, $use->var, $useScope, $storage, $nodeCallback, $context); + $this->processExprNode($stmt, $use->var, $useScope, $storage, $nodeCallback, $context, null); if (!$use->byRef) { continue; } @@ -1294,6 +1297,7 @@ public function processClosureNode( $publicStatementResult, $executionEnds, array_merge($publicStatementResult->getImpurePoints(), $closureImpurePoints), + $passedToType, ), $closureReturnStatementsNodeScope, $storage); return new ProcessClosureResult( @@ -1395,6 +1399,7 @@ public function processClosureNode( $publicStatementResult, $executionEnds, array_merge($publicStatementResult->getImpurePoints(), $closureImpurePoints), + $passedToType, ), $closureReturnStatementsNodeScope, $storage); return new ProcessClosureResult( @@ -1535,7 +1540,7 @@ public function processArrowFunctionNode( $this->pushNodeGatherer($arrowFunctionStmtsGatherer); try { - $exprResult = $this->processExprNode($stmt, $expr->expr, $arrowFunctionScope, $storage, $nodeCallback, ExpressionContext::createTopLevel()); + $exprResult = $this->processExprNode($stmt, $expr->expr, $arrowFunctionScope, $storage, $nodeCallback, ExpressionContext::createTopLevel(), null); } finally { $this->popNodeGatherer(); } @@ -1562,7 +1567,7 @@ public function processArrowFunctionNode( false, ); $refinedArrowFunctionScope = $arrowFunctionScope->withAnonymousFunctionReflection($refinedArrowFunctionType); - $this->callNodeCallback($nodeCallback, new InArrowFunctionNode($refinedArrowFunctionType, $expr), $refinedArrowFunctionScope, $storage); + $this->callNodeCallback($nodeCallback, new InArrowFunctionNode($refinedArrowFunctionType, $expr, $passedToType), $refinedArrowFunctionScope, $storage); return new ProcessArrowFunctionResult( $this->expressionResultFactory->create($scope, beforeScope: $scope, expr: $expr, hasYield: false, isAlwaysTerminating: $exprResult->isAlwaysTerminating(), throwPoints: $exprResult->getThrowPoints(), impurePoints: $exprResult->getImpurePoints()), @@ -1703,7 +1708,7 @@ public function processParamNode( return; } - $this->processExprNode($stmt, $param->default, $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $this->processExprNode($stmt, $param->default, $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); } /** @@ -1739,7 +1744,7 @@ public function processAttributeGroups( } foreach ($attr->args as $arg) { - $this->processExprNode($stmt, $arg->value, $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $this->processExprNode($stmt, $arg->value, $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $this->callNodeCallback($nodeCallback, $arg, $scope, $storage); } $this->callNodeCallback($nodeCallback, $attr, $scope, $storage); @@ -1968,6 +1973,7 @@ public function processArgs( $assignByReference = false; $parameter = null; $parameterType = null; + $overwritingParameterType = null; $parameterNativeType = null; if ($parameters !== null) { $matchedParameter = null; @@ -2002,6 +2008,18 @@ public function processArgs( } } + if ($parameter !== null && $calleeReflection !== null) { + $overwritingParameterType = $this->dynamicParameterTypeResolver->resolve($callLike, $calleeReflection, $parameter, $scope); + if ($overwritingParameterType !== null) { + $parameterType = $overwritingParameterType; + + $overwritingParameterNativeType = $this->dynamicParameterTypeResolver->resolve($callLike, $calleeReflection, $parameter, $scope->doNotTreatPhpDocTypesAsCertain()); + if ($overwritingParameterNativeType !== null) { + $parameterNativeType = $overwritingParameterNativeType; + } + } + } + $lookForUnset = false; if ($assignByReference) { $isBuiltin = false; @@ -2049,6 +2067,7 @@ public function processArgs( } } + // @todo remove once the closure type extensions are removed if ($parameter !== null) { $overwritingParameterType = $this->getParameterTypeFromParameterClosureTypeExtension($callLike, $calleeReflection, $parameter, $scopeToPass); @@ -2140,6 +2159,7 @@ public function processArgs( } } + // @todo remove once the closure type extensions are removed if ($parameter !== null) { $overwritingParameterType = $this->getParameterTypeFromParameterClosureTypeExtension($callLike, $calleeReflection, $parameter, $scopeToPass); @@ -2183,7 +2203,7 @@ public function processArgs( if ($enterExpressionAssignForByRef) { $scopeToPass = $scopeToPass->enterExpressionAssign($arg->value); } - $exprResult = $this->processExprNode($stmt, $arg->value, $scopeToPass, $storage, $nodeCallback, $context->enterDeep()); + $exprResult = $this->processExprNode($stmt, $arg->value, $scopeToPass, $storage, $nodeCallback, $context->enterDeep(), $parameterType); $throwPoints = array_merge($throwPoints, $exprResult->getThrowPoints()); $impurePoints = array_merge($impurePoints, $exprResult->getImpurePoints()); $isAlwaysTerminating = $isAlwaysTerminating || $exprResult->isAlwaysTerminating(); diff --git a/src/Analyser/StmtHandler/BreakContinueHandler.php b/src/Analyser/StmtHandler/BreakContinueHandler.php index f8ce30f0be3..c1c4c84e6a1 100644 --- a/src/Analyser/StmtHandler/BreakContinueHandler.php +++ b/src/Analyser/StmtHandler/BreakContinueHandler.php @@ -37,7 +37,7 @@ public function processStmt( ): InternalStatementResult { if ($stmt->num !== null) { - $result = $nodeScopeResolver->processExprNode($stmt, $stmt->num, $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $result = $nodeScopeResolver->processExprNode($stmt, $stmt->num, $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $scope = $result->getScope(); $hasYield = $result->hasYield(); $throwPoints = $result->getThrowPoints(); diff --git a/src/Analyser/StmtHandler/ClassConstHandler.php b/src/Analyser/StmtHandler/ClassConstHandler.php index fd6f1977582..b79788c0ec9 100644 --- a/src/Analyser/StmtHandler/ClassConstHandler.php +++ b/src/Analyser/StmtHandler/ClassConstHandler.php @@ -42,7 +42,7 @@ public function processStmt( $impurePoints = []; $nodeScopeResolver->processAttributeGroups($stmt, $stmt->attrGroups, $scope, $storage, $nodeCallback); foreach ($stmt->consts as $const) { - $constResult = $nodeScopeResolver->processExprNode($stmt, $const->value, $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $constResult = $nodeScopeResolver->processExprNode($stmt, $const->value, $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); // the constant's callback fires after its value was processed, so // rule-side asks about the value answer from the storage $nodeScopeResolver->callNodeCallback($nodeCallback, $const, $scope, $storage); diff --git a/src/Analyser/StmtHandler/ConstHandler.php b/src/Analyser/StmtHandler/ConstHandler.php index 9dd7404d9ee..e3deca3d8b9 100644 --- a/src/Analyser/StmtHandler/ConstHandler.php +++ b/src/Analyser/StmtHandler/ConstHandler.php @@ -40,7 +40,7 @@ public function processStmt( $entryScope = $scope; $impurePoints = []; foreach ($stmt->consts as $const) { - $constResult = $nodeScopeResolver->processExprNode($stmt, $const->value, $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $constResult = $nodeScopeResolver->processExprNode($stmt, $const->value, $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); // the constant's callback fires after its value was processed, so // rule-side asks about the value answer from the storage $nodeScopeResolver->callNodeCallback($nodeCallback, $const, $scope, $storage); diff --git a/src/Analyser/StmtHandler/DoWhileHandler.php b/src/Analyser/StmtHandler/DoWhileHandler.php index 5d069942715..289cfa6241a 100644 --- a/src/Analyser/StmtHandler/DoWhileHandler.php +++ b/src/Analyser/StmtHandler/DoWhileHandler.php @@ -85,7 +85,7 @@ public function processStmt( $replayPassStorage = $storage; $replayPassResult = $bodyScopeResult; } - $bodyScope = $nodeScopeResolver->processExprNode($stmt, $stmt->cond, $bodyScope, $storage, new NoopNodeCallback(), ExpressionContext::createDeep())->getTruthyScope(); + $bodyScope = $nodeScopeResolver->processExprNode($stmt, $stmt->cond, $bodyScope, $storage, new NoopNodeCallback(), ExpressionContext::createDeep(), null)->getTruthyScope(); if ($bodyScope->equals($prevScope)) { break; } @@ -135,13 +135,13 @@ public function processStmt( $finalScope = $scope; } if (!$alwaysTerminating) { - $condResult = $nodeScopeResolver->processExprNode($stmt, $stmt->cond, $bodyScope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $condResult = $nodeScopeResolver->processExprNode($stmt, $stmt->cond, $bodyScope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $hasYield = $condResult->hasYield(); $throwPoints = $condResult->getThrowPoints(); $impurePoints = $condResult->getImpurePoints(); $finalScope = $condResult->getFalseyScope(); } else { - $nodeScopeResolver->processExprNode($stmt, $stmt->cond, $bodyScope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $nodeScopeResolver->processExprNode($stmt, $stmt->cond, $bodyScope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); } // both emissions fire after the condition's final walk stored its diff --git a/src/Analyser/StmtHandler/EchoHandler.php b/src/Analyser/StmtHandler/EchoHandler.php index b71a3f0fe31..0537d362aef 100644 --- a/src/Analyser/StmtHandler/EchoHandler.php +++ b/src/Analyser/StmtHandler/EchoHandler.php @@ -47,7 +47,7 @@ public function processStmt( $impurePoints = []; $isAlwaysTerminating = false; foreach ($stmt->exprs as $echoExpr) { - $result = $nodeScopeResolver->processExprNode($stmt, $echoExpr, $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $result = $nodeScopeResolver->processExprNode($stmt, $echoExpr, $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $throwPoints = array_merge($throwPoints, $result->getThrowPoints()); $impurePoints = array_merge($impurePoints, $result->getImpurePoints()); $toStringResult = $this->implicitToStringCallHelper->processImplicitToStringCall($echoExpr, $scope); diff --git a/src/Analyser/StmtHandler/EnumCaseHandler.php b/src/Analyser/StmtHandler/EnumCaseHandler.php index bec51099998..1cb6daef28a 100644 --- a/src/Analyser/StmtHandler/EnumCaseHandler.php +++ b/src/Analyser/StmtHandler/EnumCaseHandler.php @@ -37,7 +37,7 @@ public function processStmt( $nodeScopeResolver->processAttributeGroups($stmt, $stmt->attrGroups, $scope, $storage, $nodeCallback); $impurePoints = []; if ($stmt->expr !== null) { - $exprResult = $nodeScopeResolver->processExprNode($stmt, $stmt->expr, $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $stmt->expr, $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $impurePoints = $exprResult->getImpurePoints(); } diff --git a/src/Analyser/StmtHandler/ExpressionHandler.php b/src/Analyser/StmtHandler/ExpressionHandler.php index 9db8b02f087..3a7d69e8c6b 100644 --- a/src/Analyser/StmtHandler/ExpressionHandler.php +++ b/src/Analyser/StmtHandler/ExpressionHandler.php @@ -67,7 +67,7 @@ public function processStmt( $hasAssign = true; }); try { - $result = $nodeScopeResolver->processExprNode($stmt, $stmt->expr, $scope, $storage, $nodeCallback, ExpressionContext::createTopLevel()); + $result = $nodeScopeResolver->processExprNode($stmt, $stmt->expr, $scope, $storage, $nodeCallback, ExpressionContext::createTopLevel(), null); } finally { $nodeScopeResolver->popNodeGatherer(); } diff --git a/src/Analyser/StmtHandler/ForHandler.php b/src/Analyser/StmtHandler/ForHandler.php index 46d2fb9e8e1..c7fe8588110 100644 --- a/src/Analyser/StmtHandler/ForHandler.php +++ b/src/Analyser/StmtHandler/ForHandler.php @@ -126,7 +126,7 @@ public function processStmt( $throwPoints = []; $impurePoints = []; foreach ($stmt->init as $initExpr) { - $initResult = $nodeScopeResolver->processExprNode($stmt, $initExpr, $initScope, $storage, $nodeCallback, ExpressionContext::createTopLevel()); + $initResult = $nodeScopeResolver->processExprNode($stmt, $initExpr, $initScope, $storage, $nodeCallback, ExpressionContext::createTopLevel(), null); $initScope = $initResult->getScope(); $hasYield = $hasYield || $initResult->hasYield(); $throwPoints = array_merge($throwPoints, $initResult->getThrowPoints()); @@ -141,7 +141,7 @@ public function processStmt( if (count($stmt->cond) > 0) { $storage = $originalStorage->duplicate(); foreach ($stmt->cond as $condExpr) { - $condResult = $nodeScopeResolver->processExprNode($stmt, $condExpr, $bodyScope, $storage, new NoopNodeCallback(), ExpressionContext::createDeep()); + $condResult = $nodeScopeResolver->processExprNode($stmt, $condExpr, $bodyScope, $storage, new NoopNodeCallback(), ExpressionContext::createDeep(), null); $initScope = $condResult->getScope(); // only the last condition expression is relevant whether the loop continues @@ -173,7 +173,7 @@ public function processStmt( } $prevEntryScope = $bodyScope; if ($lastCondExpr !== null) { - $bodyScope = $nodeScopeResolver->processExprNode($stmt, $lastCondExpr, $bodyScope, $storage, new NoopNodeCallback(), ExpressionContext::createDeep())->getTruthyScope(); + $bodyScope = $nodeScopeResolver->processExprNode($stmt, $lastCondExpr, $bodyScope, $storage, new NoopNodeCallback(), ExpressionContext::createDeep(), null)->getTruthyScope(); } $bodyScopeResult = $nodeScopeResolver->processStmtNodesInternal($stmt, $stmt->stmts, $bodyScope, $storage, new NoopNodeCallback(), $context->enterDeep())->filterOutLoopExitPoints(); $bodyScope = $bodyScopeResult->getScope(); @@ -182,7 +182,7 @@ public function processStmt( } foreach ($stmt->loop as $loopExpr) { - $exprResult = $nodeScopeResolver->processExprNode($stmt, $loopExpr, $bodyScope, $storage, new NoopNodeCallback(), ExpressionContext::createTopLevel()); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $loopExpr, $bodyScope, $storage, new NoopNodeCallback(), ExpressionContext::createTopLevel(), null); $bodyScope = $exprResult->getScope(); $hasYield = $hasYield || $exprResult->hasYield(); $throwPoints = array_merge($throwPoints, $exprResult->getThrowPoints()); @@ -210,7 +210,7 @@ public function processStmt( // storage miss (the condition was only stored into discarded // convergence duplicates) that re-priced it on demand $alwaysIterates = $alwaysIterates->and($bodyScope->getType($lastCondExpr)->toBoolean()->isTrue()); - $bodyScope = $nodeScopeResolver->processExprNode($stmt, $lastCondExpr, $bodyScope, $storage, $nodeCallback, ExpressionContext::createDeep())->getTruthyScope(); + $bodyScope = $nodeScopeResolver->processExprNode($stmt, $lastCondExpr, $bodyScope, $storage, $nodeCallback, ExpressionContext::createDeep(), null)->getTruthyScope(); $bodyScope = $this->inferForLoopExpressions($stmt, $lastCondExpr, $bodyScope); } @@ -222,7 +222,7 @@ public function processStmt( $loopScope = $finalScope; foreach ($stmt->loop as $loopExpr) { - $loopScope = $nodeScopeResolver->processExprNode($stmt, $loopExpr, $loopScope, $storage, $nodeCallback, ExpressionContext::createTopLevel())->getScope(); + $loopScope = $nodeScopeResolver->processExprNode($stmt, $loopExpr, $loopScope, $storage, $nodeCallback, ExpressionContext::createTopLevel(), null)->getScope(); } $finalScope = $finalScope->generalizeWith($loopScope); diff --git a/src/Analyser/StmtHandler/ForeachHandler.php b/src/Analyser/StmtHandler/ForeachHandler.php index 89e7d6d866f..2b1a1365535 100644 --- a/src/Analyser/StmtHandler/ForeachHandler.php +++ b/src/Analyser/StmtHandler/ForeachHandler.php @@ -94,7 +94,7 @@ public function processStmt( if ($stmt->expr instanceof Variable && is_string($stmt->expr->name)) { $scope = $this->varAnnotationProcessor->processVarAnnotation($scope, [$stmt->expr->name], $stmt); } - $condResult = $nodeScopeResolver->processExprNode($stmt, $stmt->expr, $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $condResult = $nodeScopeResolver->processExprNode($stmt, $stmt->expr, $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $nodeScopeResolver->callNodeCallback($nodeCallback, $stmt, $entryScope, $storage); $throwPoints = $condResult->getThrowPoints(); $impurePoints = $condResult->getImpurePoints(); diff --git a/src/Analyser/StmtHandler/GlobalHandler.php b/src/Analyser/StmtHandler/GlobalHandler.php index 96a45ae59d8..c6122012f02 100644 --- a/src/Analyser/StmtHandler/GlobalHandler.php +++ b/src/Analyser/StmtHandler/GlobalHandler.php @@ -77,7 +77,7 @@ public function processStmt( throw new ShouldNotHappenException(); } $scope = $nodeScopeResolver->lookForSetAllowedUndefinedExpressions($scope, $var); - $varResult = $nodeScopeResolver->processExprNode($stmt, $var, $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $varResult = $nodeScopeResolver->processExprNode($stmt, $var, $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $impurePoints = array_merge($impurePoints, $varResult->getImpurePoints()); $scope = $nodeScopeResolver->lookForUnsetAllowedUndefinedExpressions($scope, $var); diff --git a/src/Analyser/StmtHandler/IfHandler.php b/src/Analyser/StmtHandler/IfHandler.php index 32b1386c391..d42493a687f 100644 --- a/src/Analyser/StmtHandler/IfHandler.php +++ b/src/Analyser/StmtHandler/IfHandler.php @@ -38,7 +38,7 @@ public function processStmt( ): InternalStatementResult { $entryScope = $scope; - $condResult = $nodeScopeResolver->processExprNode($stmt, $stmt->cond, $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $condResult = $nodeScopeResolver->processExprNode($stmt, $stmt->cond, $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $nodeScopeResolver->callNodeCallback($nodeCallback, $stmt, $entryScope, $storage); $conditionType = ($nodeScopeResolver->shouldTreatPhpDocTypesAsCertain() ? $condResult->getType() : $condResult->getNativeType())->toBoolean(); $ifAlwaysTrue = $conditionType->isTrue()->yes(); @@ -74,7 +74,7 @@ public function processStmt( $condScope = $scope; foreach ($stmt->elseifs as $elseif) { - $condResult = $nodeScopeResolver->processExprNode($stmt, $elseif->cond, $condScope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $condResult = $nodeScopeResolver->processExprNode($stmt, $elseif->cond, $condScope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $nodeScopeResolver->callNodeCallback($nodeCallback, $elseif, $scope, $storage); $elseIfConditionType = ($nodeScopeResolver->shouldTreatPhpDocTypesAsCertain() ? $condResult->getType() : $condResult->getNativeType())->toBoolean(); $throwPoints = array_merge($throwPoints, $condResult->getThrowPoints()); diff --git a/src/Analyser/StmtHandler/PropertyHandler.php b/src/Analyser/StmtHandler/PropertyHandler.php index 7df721de11f..52882625d4c 100644 --- a/src/Analyser/StmtHandler/PropertyHandler.php +++ b/src/Analyser/StmtHandler/PropertyHandler.php @@ -60,7 +60,7 @@ public function processStmt( foreach ($stmt->props as $prop) { $nodeScopeResolver->callNodeCallback($nodeCallback, $prop, $scope, $storage); if ($prop->default !== null) { - $nodeScopeResolver->processExprNode($stmt, $prop->default, $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $nodeScopeResolver->processExprNode($stmt, $prop->default, $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); } if (!$scope->isInClass()) { diff --git a/src/Analyser/StmtHandler/ReturnHandler.php b/src/Analyser/StmtHandler/ReturnHandler.php index 02c5f7ddf4b..bd199095316 100644 --- a/src/Analyser/StmtHandler/ReturnHandler.php +++ b/src/Analyser/StmtHandler/ReturnHandler.php @@ -37,7 +37,7 @@ public function processStmt( { $entryScope = $scope; if ($stmt->expr !== null) { - $result = $nodeScopeResolver->processExprNode($stmt, $stmt->expr, $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $result = $nodeScopeResolver->processExprNode($stmt, $stmt->expr, $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $throwPoints = $result->getThrowPoints(); $impurePoints = $result->getImpurePoints(); $scope = $result->getScope(); diff --git a/src/Analyser/StmtHandler/StaticVariableHandler.php b/src/Analyser/StmtHandler/StaticVariableHandler.php index e35edc409c0..ddf326bf3bf 100644 --- a/src/Analyser/StmtHandler/StaticVariableHandler.php +++ b/src/Analyser/StmtHandler/StaticVariableHandler.php @@ -64,12 +64,12 @@ public function processStmt( } if ($var->default !== null) { - $defaultExprResult = $nodeScopeResolver->processExprNode($stmt, $var->default, $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $defaultExprResult = $nodeScopeResolver->processExprNode($stmt, $var->default, $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $impurePoints = array_merge($impurePoints, $defaultExprResult->getImpurePoints()); } $scope = $scope->enterExpressionAssign($var->var); - $varResult = $nodeScopeResolver->processExprNode($stmt, $var->var, $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $varResult = $nodeScopeResolver->processExprNode($stmt, $var->var, $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $impurePoints = array_merge($impurePoints, $varResult->getImpurePoints()); $scope = $scope->exitExpressionAssign($var->var); diff --git a/src/Analyser/StmtHandler/SwitchHandler.php b/src/Analyser/StmtHandler/SwitchHandler.php index e5156d02dd8..8cf503b45ed 100644 --- a/src/Analyser/StmtHandler/SwitchHandler.php +++ b/src/Analyser/StmtHandler/SwitchHandler.php @@ -43,7 +43,7 @@ public function processStmt( ): InternalStatementResult { $entryScope = $scope; - $condResult = $nodeScopeResolver->processExprNode($stmt, $stmt->cond, $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $condResult = $nodeScopeResolver->processExprNode($stmt, $stmt->cond, $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $scope = $condResult->getScope(); $scopeForBranches = $scope; $finalScope = null; @@ -68,7 +68,7 @@ public function processStmt( if ($caseNode->cond !== null) { $condExpr = new BinaryOp\Equal($stmt->cond, $caseNode->cond); $fullCondExpr = $fullCondExpr === null ? $condExpr : new BooleanOr($fullCondExpr, $condExpr); - $caseResult = $nodeScopeResolver->processExprNode($stmt, $caseNode->cond, $scopeForBranches, $storage, $nodeCallback, ExpressionContext::createDeep()); + $caseResult = $nodeScopeResolver->processExprNode($stmt, $caseNode->cond, $scopeForBranches, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $scopeForBranches = $caseResult->getScope(); $hasYield = $hasYield || $caseResult->hasYield(); $throwPoints = array_merge($throwPoints, $caseResult->getThrowPoints()); diff --git a/src/Analyser/StmtHandler/UnsetHandler.php b/src/Analyser/StmtHandler/UnsetHandler.php index af630eba78b..c3532933af6 100644 --- a/src/Analyser/StmtHandler/UnsetHandler.php +++ b/src/Analyser/StmtHandler/UnsetHandler.php @@ -58,7 +58,7 @@ public function processStmt( $impurePoints = []; foreach ($stmt->vars as $var) { $scope = $nodeScopeResolver->lookForSetAllowedUndefinedExpressions($scope, $var); - $exprResult = $nodeScopeResolver->processExprNode($stmt, $var, $scope, $storage, $nodeCallback, ExpressionContext::createDeep()); + $exprResult = $nodeScopeResolver->processExprNode($stmt, $var, $scope, $storage, $nodeCallback, ExpressionContext::createDeep(), null); $scope = $exprResult->getScope(); $scope = $nodeScopeResolver->lookForUnsetAllowedUndefinedExpressions($scope, $var); $hasYield = $hasYield || $exprResult->hasYield(); diff --git a/src/Analyser/StmtHandler/WhileHandler.php b/src/Analyser/StmtHandler/WhileHandler.php index ec01f387ed8..3bbab0a6e0b 100644 --- a/src/Analyser/StmtHandler/WhileHandler.php +++ b/src/Analyser/StmtHandler/WhileHandler.php @@ -43,7 +43,7 @@ public function processStmt( { $originalStorage = $storage; $storage = $originalStorage->duplicate(); - $condResult = $nodeScopeResolver->processExprNode($stmt, $stmt->cond, $scope, $storage, new NoopNodeCallback(), ExpressionContext::createDeep()); + $condResult = $nodeScopeResolver->processExprNode($stmt, $stmt->cond, $scope, $storage, new NoopNodeCallback(), ExpressionContext::createDeep(), null); $beforeCondBooleanType = ($nodeScopeResolver->shouldTreatPhpDocTypesAsCertain() ? $condResult->getType() : $condResult->getNativeType())->toBoolean(); $condScope = $condResult->getFalseyScope(); if (!$context->isTopLevel() && $beforeCondBooleanType->isFalse()->yes()) { @@ -83,7 +83,7 @@ public function processStmt( $storage = $originalStorage->duplicate(); $condRecording = $bodyIsReplayable ? new RecordingNodeCallback() : new NoopNodeCallback(); $bodyRecording = $bodyIsReplayable ? new RecordingNodeCallback() : new NoopNodeCallback(); - $bodyScope = $nodeScopeResolver->processExprNode($stmt, $stmt->cond, $bodyScope, $storage, $condRecording, ExpressionContext::createDeep())->getTruthyScope(); + $bodyScope = $nodeScopeResolver->processExprNode($stmt, $stmt->cond, $bodyScope, $storage, $condRecording, ExpressionContext::createDeep(), null)->getTruthyScope(); $bodyScopeResult = $nodeScopeResolver->processStmtNodesInternal($stmt, $stmt->stmts, $bodyScope, $storage, $bodyRecording, $context->enterDeep())->filterOutLoopExitPoints(); $bodyScope = $bodyScopeResult->getScope(); foreach ($bodyScopeResult->getExitPointsByType(Continue_::class) as $continueExitPoint) { @@ -127,7 +127,7 @@ public function processStmt( $nodeScopeResolver->replayRecording($replayBodyRecording, $nodeCallback, $originalStorage); $finalScopeResult = $replayPassResult; } else { - $bodyScope = $nodeScopeResolver->processExprNode($stmt, $stmt->cond, $bodyScope, $storage, $nodeCallback, ExpressionContext::createDeep())->getTruthyScope(); + $bodyScope = $nodeScopeResolver->processExprNode($stmt, $stmt->cond, $bodyScope, $storage, $nodeCallback, ExpressionContext::createDeep(), null)->getTruthyScope(); // the While_ callback is deferred from processStmtNode(): it fires // after the condition's real walk stored its result, with the entry scope $nodeScopeResolver->callNodeCallback($nodeCallback, $stmt, $scope, $storage); diff --git a/src/Node/ClosureReturnStatementsNode.php b/src/Node/ClosureReturnStatementsNode.php index 2f44a979459..1cc6882ad62 100644 --- a/src/Node/ClosureReturnStatementsNode.php +++ b/src/Node/ClosureReturnStatementsNode.php @@ -10,6 +10,7 @@ use PhpParser\NodeAbstract; use PHPStan\Analyser\ImpurePoint; use PHPStan\Analyser\StatementResult; +use PHPStan\Type\Type; use function count; /** @@ -35,6 +36,7 @@ public function __construct( private StatementResult $statementResult, private array $executionEnds, private array $impurePoints, + private ?Type $overriddenType = null, ) { parent::__construct($closureExpr->getAttributes()); @@ -91,6 +93,11 @@ public function returnsByRef(): bool return $this->closureExpr->byRef; } + public function getOverriddenType(): ?Type + { + return $this->overriddenType; + } + #[Override] public function getType(): string { diff --git a/src/Node/InArrowFunctionNode.php b/src/Node/InArrowFunctionNode.php index 6876978cece..c92fb487d59 100644 --- a/src/Node/InArrowFunctionNode.php +++ b/src/Node/InArrowFunctionNode.php @@ -7,6 +7,7 @@ use PhpParser\Node\Expr\ArrowFunction; use PhpParser\NodeAbstract; use PHPStan\Type\ClosureType; +use PHPStan\Type\Type; /** * @api @@ -16,7 +17,11 @@ final class InArrowFunctionNode extends NodeAbstract implements VirtualNode private Node\Expr\ArrowFunction $originalNode; - public function __construct(private ClosureType $closureType, ArrowFunction $originalNode) + public function __construct( + private ClosureType $closureType, + ArrowFunction $originalNode, + private ?Type $overriddenType = null, + ) { parent::__construct($originalNode->getAttributes()); $this->originalNode = $originalNode; @@ -32,6 +37,11 @@ public function getOriginalNode(): Node\Expr\ArrowFunction return $this->originalNode; } + public function getOverriddenType(): ?Type + { + return $this->overriddenType; + } + #[Override] public function getType(): string { diff --git a/src/Rules/FunctionCallParametersCheck.php b/src/Rules/FunctionCallParametersCheck.php index 8952bd3599f..ad6147c1027 100644 --- a/src/Rules/FunctionCallParametersCheck.php +++ b/src/Rules/FunctionCallParametersCheck.php @@ -12,6 +12,8 @@ use PHPStan\DependencyInjection\AutowiredService; use PHPStan\Reflection\ConstantReflection; use PHPStan\Reflection\ExtendedParameterReflection; +use PHPStan\Reflection\FunctionReflection; +use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; use PHPStan\Reflection\ParametersAcceptor; use PHPStan\Reflection\ReflectionProvider; @@ -23,6 +25,7 @@ use PHPStan\TrinaryLogic; use PHPStan\Type\ConditionalType; use PHPStan\Type\Constant\ConstantIntegerType; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPStan\Type\ErrorType; use PHPStan\Type\Generic\AbsorbedTemplateArgumentType; use PHPStan\Type\Generic\TemplateType; @@ -56,6 +59,7 @@ public function __construct( private UnresolvableTypeHelper $unresolvableTypeHelper, private PropertyReflectionFinder $propertyReflectionFinder, private ReflectionProvider $reflectionProvider, + private DynamicParameterTypeResolver $dynamicParameterTypeResolver, #[AutowiredParameter(ref: '%checkFunctionArgumentTypes%')] private bool $checkArgumentTypes, #[AutowiredParameter] @@ -99,6 +103,7 @@ public function check( string $exclusiveConstantsMessage, string $bitmaskNotAllowedMessage, ?array $renamedNamedArgumentParameterData, + MethodReflection|FunctionReflection|null $calleeReflection = null, ): array { if ($funcCall instanceof Node\Expr\MethodCall || $funcCall instanceof Node\Expr\StaticCall || $funcCall instanceof Node\Expr\FuncCall) { @@ -392,6 +397,15 @@ public function check( if ($this->checkArgumentTypes) { $parameterType = TypeUtils::resolveLateResolvableTypes($parameter->getType()); + // judge the argument against the type the extensions announced for + // the parameter, which is what NodeScopeResolver walked it with + if (!$funcCall instanceof Node\Expr\New_) { + $overriddenType = $this->dynamicParameterTypeResolver->resolve($funcCall, $calleeReflection, $parameter, $scope); + if ($overriddenType !== null) { + $parameterType = $overriddenType; + } + } + if ( !$parameter->passedByReference()->createsNewVariable() || (!$isBuiltin && !$argumentValueType instanceof ErrorType) diff --git a/src/Rules/Functions/ArrowFunctionReturnTypeRule.php b/src/Rules/Functions/ArrowFunctionReturnTypeRule.php index ab1fecfe737..70f2786cd96 100644 --- a/src/Rules/Functions/ArrowFunctionReturnTypeRule.php +++ b/src/Rules/Functions/ArrowFunctionReturnTypeRule.php @@ -12,6 +12,8 @@ use PHPStan\ShouldNotHappenException; use PHPStan\Type\NeverType; use PHPStan\Type\ObjectType; +use PHPStan\Type\TypeCombinator; +use function array_map; /** * @implements Rule @@ -37,6 +39,13 @@ public function processNode(Node $node, Scope $scope): array $returnType = $scope->getAnonymousFunctionReturnType(); $generatorType = new ObjectType(Generator::class); + $overriddenType = $node->getOverriddenType(); + if ($overriddenType !== null && $overriddenType->isCallable()->yes()) { + $returnType = TypeCombinator::union(...array_map( + static fn ($a) => $a->getReturnType(), + $overriddenType->getCallableParametersAcceptors($scope), + )); + } $originalNode = $node->getOriginalNode(); $isVoidSuperType = $returnType->isVoid(); diff --git a/src/Rules/Functions/CallToFunctionParametersRule.php b/src/Rules/Functions/CallToFunctionParametersRule.php index f01a081fdae..be1bdf1d78c 100644 --- a/src/Rules/Functions/CallToFunctionParametersRule.php +++ b/src/Rules/Functions/CallToFunctionParametersRule.php @@ -74,6 +74,7 @@ public function processNode(Node $node, Scope&NodeCallbackInvoker&CollectedDataE 'Constants %s cannot be combined for %s of function ' . $functionName . '.', 'Combining constants with | is not allowed for %s of function ' . $functionName . '.', null, + $function, ); } diff --git a/src/Rules/Functions/ClosureReturnTypeRule.php b/src/Rules/Functions/ClosureReturnTypeRule.php index abeb7c3866d..abfe196e39a 100644 --- a/src/Rules/Functions/ClosureReturnTypeRule.php +++ b/src/Rules/Functions/ClosureReturnTypeRule.php @@ -9,6 +9,7 @@ use PHPStan\Rules\FunctionReturnTypeCheck; use PHPStan\Rules\Rule; use PHPStan\Type\TypeCombinator; +use function array_map; /** * @implements Rule @@ -33,6 +34,13 @@ public function processNode(Node $node, Scope $scope): array } $returnType = $scope->getAnonymousFunctionReturnType(); + $overriddenType = $node->getOverriddenType(); + if ($overriddenType !== null && $overriddenType->isCallable()->yes()) { + $returnType = TypeCombinator::union(...array_map( + static fn ($a) => $a->getReturnType(), + $overriddenType->getCallableParametersAcceptors($scope), + )); + } $containsNull = TypeCombinator::containsNull($returnType); $hasNativeTypehint = $node->getClosureExpr()->returnType !== null; diff --git a/src/Rules/Methods/CallMethodsRule.php b/src/Rules/Methods/CallMethodsRule.php index 51881bfbea2..b593f2c8d38 100644 --- a/src/Rules/Methods/CallMethodsRule.php +++ b/src/Rules/Methods/CallMethodsRule.php @@ -108,6 +108,7 @@ private function processSingleMethodCall(Scope&NodeCallbackInvoker&CollectedData $declaringClass->getName(), $methodReflection->getName(), ] : null, + $methodReflection, )); } diff --git a/src/Rules/Methods/CallStaticMethodsRule.php b/src/Rules/Methods/CallStaticMethodsRule.php index a275d3fb731..009514adcaf 100644 --- a/src/Rules/Methods/CallStaticMethodsRule.php +++ b/src/Rules/Methods/CallStaticMethodsRule.php @@ -114,6 +114,7 @@ private function processSingleMethodCall(Scope&NodeCallbackInvoker&CollectedData 'Constants %s cannot be combined for %s of ' . $lowercasedMethodName . '.', 'Combining constants with | is not allowed for %s of ' . $lowercasedMethodName . '.', null, + $method, )); return $errors; diff --git a/src/Testing/RuleTestCase.php b/src/Testing/RuleTestCase.php index 247331d03f2..bc6f9d70f23 100644 --- a/src/Testing/RuleTestCase.php +++ b/src/Testing/RuleTestCase.php @@ -26,6 +26,7 @@ use PHPStan\Rules\IdentifierRuleError; use PHPStan\Rules\Properties\ReadWritePropertiesExtension; use PHPStan\Rules\Rule; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPStan\Type\FileTypeMapper; use PHPStan\Type\FunctionParameterClosureThisExtension; use PHPStan\Type\FunctionParameterClosureTypeExtension; @@ -96,6 +97,7 @@ protected function createNodeScopeResolver(): NodeScopeResolver self::getContainer()->getExtensionsCollection(FunctionParameterClosureThisExtension::class), self::getContainer()->getExtensionsCollection(MethodParameterClosureThisExtension::class), self::getContainer()->getExtensionsCollection(StaticMethodParameterClosureThisExtension::class), + self::getContainer()->getByType(DynamicParameterTypeResolver::class), self::getContainer()->getExtensionsCollection(FunctionParameterClosureTypeExtension::class), self::getContainer()->getExtensionsCollection(MethodParameterClosureTypeExtension::class), self::getContainer()->getExtensionsCollection(StaticMethodParameterClosureTypeExtension::class), diff --git a/src/Testing/TypeInferenceTestCase.php b/src/Testing/TypeInferenceTestCase.php index 51541bfa411..bb4778cbd02 100644 --- a/src/Testing/TypeInferenceTestCase.php +++ b/src/Testing/TypeInferenceTestCase.php @@ -21,6 +21,7 @@ use PHPStan\ShouldNotHappenException; use PHPStan\TrinaryLogic; use PHPStan\Type\ConstantScalarType; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPStan\Type\FileTypeMapper; use PHPStan\Type\FunctionParameterClosureThisExtension; use PHPStan\Type\FunctionParameterClosureTypeExtension; @@ -72,6 +73,7 @@ protected static function createNodeScopeResolver(): NodeScopeResolver $container->getExtensionsCollection(FunctionParameterClosureThisExtension::class), $container->getExtensionsCollection(MethodParameterClosureThisExtension::class), $container->getExtensionsCollection(StaticMethodParameterClosureThisExtension::class), + $container->getByType(DynamicParameterTypeResolver::class), $container->getExtensionsCollection(FunctionParameterClosureTypeExtension::class), $container->getExtensionsCollection(MethodParameterClosureTypeExtension::class), $container->getExtensionsCollection(StaticMethodParameterClosureTypeExtension::class), diff --git a/src/Type/DynamicFunctionParameterTypeExtension.php b/src/Type/DynamicFunctionParameterTypeExtension.php new file mode 100644 index 00000000000..1eed7eab09c --- /dev/null +++ b/src/Type/DynamicFunctionParameterTypeExtension.php @@ -0,0 +1,34 @@ + $functionParameterTypeExtensions + * @param ExtensionsCollection $methodParameterTypeExtensions + * @param ExtensionsCollection $staticMethodParameterTypeExtensions + */ + public function __construct( + #[AutowiredExtensions(of: DynamicFunctionParameterTypeExtension::class)] + private readonly ExtensionsCollection $functionParameterTypeExtensions, + #[AutowiredExtensions(of: DynamicMethodParameterTypeExtension::class)] + private readonly ExtensionsCollection $methodParameterTypeExtensions, + #[AutowiredExtensions(of: DynamicStaticMethodParameterTypeExtension::class)] + private readonly ExtensionsCollection $staticMethodParameterTypeExtensions, + ) + { + } + + public function resolve( + CallLike $callLike, + MethodReflection|FunctionReflection|null $calleeReflection, + ParameterReflection $parameter, + Scope $scope, + ): ?Type + { + if ($calleeReflection === null) { + return null; + } + + if ($callLike instanceof FuncCall && $calleeReflection instanceof FunctionReflection) { + foreach ($this->functionParameterTypeExtensions->getAll() as $extension) { + if (!$extension->isFunctionSupported($calleeReflection, $parameter)) { + continue; + } + $type = $extension->getTypeFromFunctionCall($calleeReflection, $callLike, $parameter, $scope); + if ($type !== null) { + return $type; + } + } + + return null; + } + + if ($callLike instanceof MethodCall && $calleeReflection instanceof MethodReflection) { + foreach ($this->methodParameterTypeExtensions->getAll() as $extension) { + if (!$extension->isMethodSupported($calleeReflection, $parameter)) { + continue; + } + $type = $extension->getTypeFromMethodCall($calleeReflection, $callLike, $parameter, $scope); + if ($type !== null) { + return $type; + } + } + + return null; + } + + if (!$calleeReflection instanceof MethodReflection) { + return null; + } + + if ($callLike instanceof StaticCall) { + $staticCall = $callLike; + } elseif ($callLike instanceof New_ && $callLike->class instanceof Name) { + // constructors are described by static method extensions + $staticCall = new StaticCall($callLike->class, new Identifier('__construct'), $callLike->getArgs()); + } else { + return null; + } + + foreach ($this->staticMethodParameterTypeExtensions->getAll() as $extension) { + if (!$extension->isStaticMethodSupported($calleeReflection, $parameter)) { + continue; + } + $type = $extension->getTypeFromStaticMethodCall($calleeReflection, $staticCall, $parameter, $scope); + if ($type !== null) { + return $type; + } + } + + return null; + } + +} diff --git a/src/Type/DynamicStaticMethodParameterTypeExtension.php b/src/Type/DynamicStaticMethodParameterTypeExtension.php new file mode 100644 index 00000000000..8bfc5e9d381 --- /dev/null +++ b/src/Type/DynamicStaticMethodParameterTypeExtension.php @@ -0,0 +1,34 @@ +getExtensionsCollection(FunctionParameterClosureThisExtension::class), $container->getExtensionsCollection(MethodParameterClosureThisExtension::class), $container->getExtensionsCollection(StaticMethodParameterClosureThisExtension::class), + $container->getByType(DynamicParameterTypeResolver::class), $container->getExtensionsCollection(FunctionParameterClosureTypeExtension::class), $container->getExtensionsCollection(MethodParameterClosureTypeExtension::class), $container->getExtensionsCollection(StaticMethodParameterClosureTypeExtension::class), diff --git a/tests/PHPStan/Analyser/Bug9307CallMethodsRuleTest.php b/tests/PHPStan/Analyser/Bug9307CallMethodsRuleTest.php index 3cf21124155..87ddf794d1e 100644 --- a/tests/PHPStan/Analyser/Bug9307CallMethodsRuleTest.php +++ b/tests/PHPStan/Analyser/Bug9307CallMethodsRuleTest.php @@ -11,6 +11,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; /** * @extends RuleTestCase @@ -44,6 +45,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Analyser/DynamicParameterTypeExtensionArraysTest.php b/tests/PHPStan/Analyser/DynamicParameterTypeExtensionArraysTest.php new file mode 100644 index 00000000000..756d80acfc1 --- /dev/null +++ b/tests/PHPStan/Analyser/DynamicParameterTypeExtensionArraysTest.php @@ -0,0 +1,30 @@ += 8.0.0')] +class DynamicParameterTypeExtensionArraysTest extends TypeInferenceTestCase +{ + + public static function dataFileAsserts(): iterable + { + yield from self::gatherAssertTypes(__DIR__ . '/data/dynamic-parameter-type-extension-arrays.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__ . '/dynamic-parameter-type-extension-arrays.neon']; + } + +} diff --git a/tests/PHPStan/Analyser/DynamicParameterTypeExtensionClosuresTest.php b/tests/PHPStan/Analyser/DynamicParameterTypeExtensionClosuresTest.php new file mode 100644 index 00000000000..7a4c0890ace --- /dev/null +++ b/tests/PHPStan/Analyser/DynamicParameterTypeExtensionClosuresTest.php @@ -0,0 +1,30 @@ += 8.0.0')] +class DynamicParameterTypeExtensionClosuresTest extends TypeInferenceTestCase +{ + + public static function dataFileAsserts(): iterable + { + yield from self::gatherAssertTypes(__DIR__ . '/data/dynamic-parameter-type-extension-closures.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__ . '/dynamic-parameter-type-extension-closures.neon']; + } + +} diff --git a/tests/PHPStan/Analyser/DynamicParameterTypeExtensionErrorsRuleTest.php b/tests/PHPStan/Analyser/DynamicParameterTypeExtensionErrorsRuleTest.php new file mode 100644 index 00000000000..d71213e828f --- /dev/null +++ b/tests/PHPStan/Analyser/DynamicParameterTypeExtensionErrorsRuleTest.php @@ -0,0 +1,72 @@ + + */ +class DynamicParameterTypeExtensionErrorsRuleTest extends RuleTestCase +{ + + protected function getRule(): Rule + { + $reflectionProvider = self::createReflectionProvider(); + $ruleLevelHelper = new RuleLevelHelper( + $reflectionProvider, + checkNullables: true, + checkThisOnly: false, + checkUnionTypes: true, + checkExplicitMixed: true, + checkImplicitMixed: false, + checkBenevolentUnionTypes: false, + discoveringSymbolsTip: true, + ); + return new CallMethodsRule( + new MethodCallCheck( + $reflectionProvider, + $ruleLevelHelper, + checkFunctionNameCase: true, + reportMagicMethods: true, + ), + new FunctionCallParametersCheck( + $ruleLevelHelper, + new NullsafeCheck(), + new UnresolvableTypeHelper(), + new PropertyReflectionFinder(), + $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), + checkArgumentTypes: true, + checkArgumentsPassedByReference: true, + checkExtraArguments: true, + checkMissingTypehints: true, + ), + ); + } + + public static function getAdditionalConfigFiles(): array + { + return [__DIR__ . '/dynamic-parameter-type-extension-closures-errors.neon']; + } + + public function testErrorCases(): void + { + $this->analyse([__DIR__ . '/data/dynamic-parameter-type-extension-closures-errors.php'], [ + [ + 'Call to an undefined method DynamicParameterTypeExtensionClosuresErrors\Generic::nonExistentMethod().', + 84, + ], + ]); + } + +} diff --git a/tests/PHPStan/Analyser/ExpressionResultTest.php b/tests/PHPStan/Analyser/ExpressionResultTest.php index 4da555b362f..11dd4c2dd61 100644 --- a/tests/PHPStan/Analyser/ExpressionResultTest.php +++ b/tests/PHPStan/Analyser/ExpressionResultTest.php @@ -212,6 +212,7 @@ public function testIsAlwaysTerminating( static function (): void { }, ExpressionContext::createTopLevel(), + null, ); $this->assertSame($expectedIsAlwaysTerminating, $result->isAlwaysTerminating()); } diff --git a/tests/PHPStan/Analyser/data/dynamic-parameter-type-extension-arrays.php b/tests/PHPStan/Analyser/data/dynamic-parameter-type-extension-arrays.php new file mode 100644 index 00000000000..8267ae3e30c --- /dev/null +++ b/tests/PHPStan/Analyser/data/dynamic-parameter-type-extension-arrays.php @@ -0,0 +1,181 @@ += 8.0 + +namespace DynamicParameterTypeExtensionArrays; + +use PhpParser\Node\Expr\FuncCall; +use PhpParser\Node\Expr\MethodCall; +use PhpParser\Node\Expr\StaticCall; +use PHPStan\Analyser\Scope; +use PHPStan\Reflection\FunctionReflection; +use PHPStan\Reflection\MethodReflection; +use PHPStan\Reflection\Native\NativeParameterReflection; +use PHPStan\Reflection\ParameterReflection; +use PHPStan\Reflection\PassedByReference; +use PHPStan\Type\CallableType; +use PHPStan\Type\FloatType; +use PHPStan\Type\Generic\GenericObjectType; +use PHPStan\Type\Constant\ConstantIntegerType; +use PHPStan\Type\Constant\ConstantStringType; +use PHPStan\Type\DynamicFunctionParameterTypeExtension; +use PHPStan\Type\DynamicMethodParameterTypeExtension; +use PHPStan\Type\DynamicStaticMethodParameterTypeExtension; +use PHPStan\Type\IntegerType; +use PHPStan\Type\StringType; +use PHPStan\Type\Type; +use PHPStan\Type\MixedType; +use PHPStan\TrinaryLogic; +use function PHPStan\Testing\assertType; + +final class DynamicParameterTypeExtension implements DynamicFunctionParameterTypeExtension, DynamicMethodParameterTypeExtension, DynamicStaticMethodParameterTypeExtension +{ + + public function isFunctionSupported(FunctionReflection $functionReflection, ParameterReflection $parameter): bool + { + return true; + } + + public function isMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool + { + return true; + } + + public function isStaticMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool + { + return true; + } + + public function getTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type + { + return $this->getType($methodReflection, $methodCall, $parameter, $scope); + } + + public function getTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type + { + return $this->getType($methodReflection, $methodCall, $parameter, $scope); + } + + public function getTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $functionCall, ParameterReflection $parameter, Scope $scope): ?Type + { + return $this->getType($functionReflection, $functionCall, $parameter, $scope); + } + + private function getType( + FunctionReflection|MethodReflection $functionReflection, + FuncCall|MethodCall|StaticCall $call, + ParameterReflection $parameter, + Scope $scope, + ): ?Type + { + $arg = $call->getArgs()[0] ?? null; + if (!$arg) { + return null; + } + + $type = $scope->getType($arg->value)->getConstantArrays()[0] ?? null; + if (!$type) { + return null; + } + + $replacements = [ + 'a' => new IntegerType(), + 'b' => new StringType(), + 0 => new IntegerType(), + 1 => new StringType(), + 2 => new FloatType(), + ]; + + foreach ($replacements as $key => $value) { + $keyType = is_int($key) ? new ConstantIntegerType($key) : new ConstantStringType($key); + if ($type->hasOffsetValueType($keyType)->no()) { + continue; + } + + $newType = new CallableType([ + new NativeParameterReflection('test', false, new GenericObjectType(Generic::class, [$value]), PassedByReference::createNo(), false, null), + ], new MixedType(), false); + + $type = $type->setOffsetValueType($keyType, $newType, false); + } + + return $type; + } +} + +class Foo +{ + + /** @param array)> $array */ + public function methodWithArray($array) {} + + public static function staticMethodWithArray(array $array) {} + +} + +/** @template T */ +class Generic +{ + public function __construct( + /** @var T */ + private mixed $value, + ) { + } + + /** @return T */ + public function getValue() + { + return $this->value; + } +} + +/** @param array)> $array */ +function functionWithArray(array $array): void {} + +/** @param list)> $list */ +function functionWithNumericArray(array $list): void {} + +function test(Foo $foo): void +{ + functionWithArray([ + fn ($i) => assertType('int', $i->getValue()), + fn ($i) => assertType('string', $i->getValue()), + fn ($i) => assertType('float', $i->getValue()), + ]); + + functionWithArray([ + 0 => fn ($i) => assertType('int', $i->getValue()), + 1 => fn ($i) => assertType('string', $i->getValue()), + 2 => fn ($i) => assertType('float', $i->getValue()), + ]); + + functionWithArray([ + 'a' => fn ($i) => assertType('int', $i->getValue()), + 'b' => fn ($i) => assertType('string', $i->getValue()), + 'c' => fn (int $i) => assertType('int', $i), + ]); + $foo->methodWithArray([ + 'a' => fn ($i) => assertType('int', $i->getValue()), + 'b' => fn ($i) => assertType('string', $i->getValue()), + 'c' => fn (int $i) => assertType('int', $i), + ]); + Foo::staticMethodWithArray([ + 'a' => fn ($i) => assertType('int', $i->getValue()), + 'b' => fn ($i) => assertType('string', $i->getValue()), + 'c' => fn (int $i) => assertType('int', $i), + ]); + + functionWithArray([ + 'a' => function ($i) { assertType('int', $i->getValue()); }, + 'b' => function ($i) { assertType('string', $i->getValue()); }, + 'c' => function (int $i) { assertType('int', $i); }, + ]); + $foo->methodWithArray([ + 'a' => function ($i) { assertType('int', $i->getValue()); }, + 'b' => function ($i) { assertType('string', $i->getValue()); }, + 'c' => function (int $i) { assertType('int', $i); }, + ]); + Foo::staticMethodWithArray([ + 'a' => function ($i) { assertType('int', $i->getValue()); }, + 'b' => function ($i) { assertType('string', $i->getValue()); }, + 'c' => function (int $i) { assertType('int', $i); }, + ]); +} diff --git a/tests/PHPStan/Analyser/data/dynamic-parameter-type-extension-closures-errors.php b/tests/PHPStan/Analyser/data/dynamic-parameter-type-extension-closures-errors.php new file mode 100644 index 00000000000..0eee2e608e2 --- /dev/null +++ b/tests/PHPStan/Analyser/data/dynamic-parameter-type-extension-closures-errors.php @@ -0,0 +1,96 @@ += 8.0 + +namespace DynamicParameterTypeExtensionClosuresErrors; + +use PhpParser\Node\Expr\MethodCall; +use PHPStan\Analyser\Scope; +use PHPStan\Reflection\MethodReflection; +use PHPStan\Reflection\Native\NativeParameterReflection; +use PHPStan\Reflection\ParameterReflection; +use PHPStan\Reflection\PassedByReference; +use PHPStan\Type\CallableType; +use PHPStan\Type\DynamicMethodParameterTypeExtension; +use PHPStan\Type\Generic\GenericObjectType; +use PHPStan\Type\IntegerType; +use PHPStan\Type\MixedType; +use PHPStan\Type\StringType; +use PHPStan\Type\Type; + +/** @template T */ +class Generic +{ + /** @param T $value */ + public function __construct(private mixed $value) {} + + /** @return T */ + public function getValue() { return $this->value; } +} + +class Foo +{ + public function methodWithCallable(int $foo, callable $callback): void {} +} + +final class ErrorTestExtension implements DynamicMethodParameterTypeExtension +{ + + public function isMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool + { + return $methodReflection->getDeclaringClass()->getName() === Foo::class + && $parameter->getName() === 'callback' + && $methodReflection->getName() === 'methodWithCallable'; + } + + public function getTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type + { + $args = $methodCall->getArgs(); + if (count($args) < 2) { + return null; + } + + $integer = $scope->getType($args[0]->value)->getConstantScalarValues()[0] ?? null; + + $valueType = $integer === 1 ? new IntegerType() : new StringType(); + + return new CallableType( + [ + new NativeParameterReflection('test', false, new GenericObjectType(Generic::class, [$valueType]), PassedByReference::createNo(), false, null), + ], + new MixedType(), + ); + } + +} + +function acceptInt(int $value): void {} +function acceptString(string $value): void {} + +function testErrorCases(Foo $foo): void +{ + // Extension overrides param to Generic, getValue() returns int + // Passing int where string is expected should be an error + $foo->methodWithCallable(1, function ($i) { + acceptString($i->getValue()); + }); + + // Extension overrides param to Generic, getValue() returns string + // Passing string where int is expected should be an error + $foo->methodWithCallable(2, function ($i) { + acceptInt($i->getValue()); + }); + + // Calling non-existent method on overridden type should be an error + $foo->methodWithCallable(1, function ($i) { + $i->nonExistentMethod(); + }); + + // No error: correct usage matches overridden parameter type + $foo->methodWithCallable(1, function ($i) { + acceptInt($i->getValue()); + }); + + // No error: correct usage for string variant + $foo->methodWithCallable(2, function ($i) { + acceptString($i->getValue()); + }); +} diff --git a/tests/PHPStan/Analyser/data/dynamic-parameter-type-extension-closures.php b/tests/PHPStan/Analyser/data/dynamic-parameter-type-extension-closures.php new file mode 100644 index 00000000000..7afc522247b --- /dev/null +++ b/tests/PHPStan/Analyser/data/dynamic-parameter-type-extension-closures.php @@ -0,0 +1,269 @@ += 8.0 + +namespace DynamicParameterTypeExtensionClosures; + +use PhpParser\Node\Expr\FuncCall; +use PhpParser\Node\Expr\MethodCall; +use PhpParser\Node\Expr\StaticCall; +use PHPStan\Analyser\Scope; +use PHPStan\Reflection\FunctionReflection; +use PHPStan\Reflection\MethodReflection; +use PHPStan\Reflection\Native\NativeParameterReflection; +use PHPStan\Reflection\ParameterReflection; +use PHPStan\Reflection\PassedByReference; +use PHPStan\Type\CallableType; +use PHPStan\Type\DynamicFunctionParameterTypeExtension; +use PHPStan\Type\DynamicMethodParameterTypeExtension; +use PHPStan\Type\DynamicStaticMethodParameterTypeExtension; +use PHPStan\Type\FloatType; +use PHPStan\Type\Generic\GenericObjectType; +use PHPStan\Type\IntegerType; +use PHPStan\Type\StringType; +use PHPStan\Type\Type; +use PHPStan\Type\MixedType; +use function PHPStan\Testing\assertType; + +final class DynamicParameterTypeExtension implements DynamicFunctionParameterTypeExtension, DynamicMethodParameterTypeExtension, DynamicStaticMethodParameterTypeExtension +{ + + public function isFunctionSupported(FunctionReflection $functionReflection, ParameterReflection $parameter): bool + { + return $functionReflection->getName() === 'DynamicParameterTypeExtensionClosures\functionWithCallable'; + } + + public function isMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool + { + return $methodReflection->getDeclaringClass()->getName() === Foo::class && + $parameter->getName() === 'callback' && + $methodReflection->getName() === 'methodWithCallable'; + } + + public function isStaticMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool + { + if ($methodReflection->getDeclaringClass()->getName() === Foo::class && $methodReflection->getName() === 'staticMethodWithCallable') { + return true; + } + + if ($methodReflection->getDeclaringClass()->getName() === Bar::class && $methodReflection->getName() === '__construct') { + return true; + } + + return false; + } + + public function getTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $functionCall, ParameterReflection $parameter, Scope $scope): ?Type + { + return $this->getType($functionReflection, $functionCall, $parameter, $scope); + } + + public function getTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type + { + return $this->getType($methodReflection, $methodCall, $parameter, $scope); + } + + public function getTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type + { + if ($methodReflection->getDeclaringClass()->getName() === Bar::class && $methodReflection->getName() === '__construct') { + $args = $methodCall->getArgs(); + + if (count($args) < 2) { + return null; + } + + $integer = $scope->getType($args[0]->value)->getConstantScalarValues()[0]; + + if ($integer === 1) { + return new CallableType( + [ + new NativeParameterReflection('test', false, new IntegerType(), PassedByReference::createNo(), false, null), + ], + new MixedType() + ); + } + + return new CallableType( + [ + new NativeParameterReflection('test', false, new StringType(), PassedByReference::createNo(), false, null), + ], + new MixedType() + ); + } + + return new CallableType( + [ + new NativeParameterReflection('test', false, new FloatType(), PassedByReference::createNo(), false, null), + ], + new MixedType() + ); + } + + private function getType( + FunctionReflection|MethodReflection $methodReflection, + FuncCall|MethodCall $methodCall, + ParameterReflection $parameter, + Scope $scope, + ): ?Type { + $args = $methodCall->getArgs(); + + if (count($args) < 2) { + return null; + } + + $integer = $scope->getType($args[0]->value)->getConstantScalarValues()[0]; + + if ($integer === 1) { + return new CallableType( + [ + new NativeParameterReflection('test', false, new GenericObjectType(Generic::class, [new IntegerType()]), PassedByReference::createNo(), false, null), + ], + new MixedType() + ); + } + + return new CallableType( + [ + new NativeParameterReflection('test', false, new GenericObjectType(Generic::class, [new StringType()]), PassedByReference::createNo(), false, null), + ], + new MixedType() + ); + } +} + +class Foo +{ + + /** + * @param int $foo + * @param callable(Generic) $callback + * + * @return void + */ + public function methodWithCallable(int $foo, callable $callback) {} + + /** @return void */ + public static function staticMethodWithCallable(callable $callback) {} + +} + +/** @template T */ +class Generic +{ + private $value; + + /** @param T $value */ + public function __construct($value) + { + $this->value = $value; + } + + /** @return T */ + public function getValue() + { + return $this->value; + } +} + +class Bar +{ + + /** + * @param int $foo + * @param callable(mixed) $callback + */ + public function __construct(int $foo, callable $callback) + { + + } + +} + +/** + * @param int $foo + * @param callable(Generic) $callback + * + * @return void + */ +function functionWithCallable(int $foo, callable $callback) {} + +function test(Foo $foo): void +{ + + // arrow functions + $foo->methodWithCallable(1, fn ($i) => assertType('int', $i->getValue())); + (new Foo)->methodWithCallable(2, fn (Generic $i) => assertType('string', $i->getValue())); + Foo::staticMethodWithCallable(fn ($i) => assertType('float', $i)); + functionWithCallable(1, fn ($i) => assertType('int', $i->getValue())); + functionWithCallable(2, fn (Generic $i) => assertType('string', $i->getValue())); + + new Bar(1, fn ($i) => assertType('int', $i)); + new Bar(2, fn ($i) => assertType('string', $i)); + + + // closures + $foo->methodWithCallable(1, function ($i) { assertType('int', $i->getValue()); }); + (new Foo)->methodWithCallable(2, function (Generic $i) { assertType('string', $i->getValue()); }); + Foo::staticMethodWithCallable(function ($i) { assertType('float', $i); }); + functionWithCallable(1, function ($i) { assertType('int', $i->getValue()); }); + functionWithCallable(2, function (Generic $i) { assertType('string', $i->getValue()); }); + + new Bar(1, function ($i) { assertType('int', $i); }); + new Bar(2, function ($i) { assertType('string', $i); }); +} + +/** + * @param callable(int): void|null $callback + */ +function functionWithUnionCallable(callable|null $callback): void {} + +/** + * @param callable(int): string $callback + */ +function functionWithCallableReturnType(callable $callback): void {} + +function testUnionCallable(): void +{ + // Test with union type containing callable and non-callable + functionWithUnionCallable(fn ($i) => assertType('int', $i)); + functionWithUnionCallable(function ($i) { assertType('int', $i); }); + + // Test closure return type checking + functionWithCallableReturnType(fn ($i): string => 'test'); + functionWithCallableReturnType(function ($i): string { return 'test'; }); +} + +function testComplexExpressions(Foo $foo): void +{ + // Type narrowing inside overridden closure + $foo->methodWithCallable(1, function ($i) { + $val = $i->getValue(); + assertType('int', $val); + + if ($val > 0) { + assertType('int<1, max>', $val); + } + }); + + // Variable assignment and reuse + functionWithCallable(2, function ($i) { + $val = $i->getValue(); + assertType('string', $val); + + $upper = strtoupper($val); + assertType('uppercase-string', $upper); + }); + + // Nested method calls on overridden type + $foo->methodWithCallable(1, function ($i) { + assertType('DynamicParameterTypeExtensionClosures\Generic', $i); + assertType('int', $i->getValue()); + }); + + // Multiple statements in closure body + functionWithCallable(1, function ($i) { + $a = $i->getValue(); + $b = $i->getValue(); + assertType('int', $a); + assertType('int', $b); + assertType('int', $a + $b); + }); +} diff --git a/tests/PHPStan/Analyser/dynamic-parameter-type-extension-arrays.neon b/tests/PHPStan/Analyser/dynamic-parameter-type-extension-arrays.neon new file mode 100644 index 00000000000..82f6e9cb59d --- /dev/null +++ b/tests/PHPStan/Analyser/dynamic-parameter-type-extension-arrays.neon @@ -0,0 +1,7 @@ +services: + - + class: DynamicParameterTypeExtensionArrays\DynamicParameterTypeExtension + tags: + - phpstan.dynamicFunctionParameterTypeExtension + - phpstan.dynamicMethodParameterTypeExtension + - phpstan.dynamicStaticMethodParameterTypeExtension diff --git a/tests/PHPStan/Analyser/dynamic-parameter-type-extension-closures-errors.neon b/tests/PHPStan/Analyser/dynamic-parameter-type-extension-closures-errors.neon new file mode 100644 index 00000000000..94483d2f9d3 --- /dev/null +++ b/tests/PHPStan/Analyser/dynamic-parameter-type-extension-closures-errors.neon @@ -0,0 +1,5 @@ +services: + - + class: DynamicParameterTypeExtensionClosuresErrors\ErrorTestExtension + tags: + - phpstan.dynamicMethodParameterTypeExtension diff --git a/tests/PHPStan/Analyser/dynamic-parameter-type-extension-closures.neon b/tests/PHPStan/Analyser/dynamic-parameter-type-extension-closures.neon new file mode 100644 index 00000000000..13c6ef79d71 --- /dev/null +++ b/tests/PHPStan/Analyser/dynamic-parameter-type-extension-closures.neon @@ -0,0 +1,7 @@ +services: + - + class: DynamicParameterTypeExtensionClosures\DynamicParameterTypeExtension + tags: + - phpstan.dynamicFunctionParameterTypeExtension + - phpstan.dynamicMethodParameterTypeExtension + - phpstan.dynamicStaticMethodParameterTypeExtension diff --git a/tests/PHPStan/Rules/Classes/ClassAttributesRuleTest.php b/tests/PHPStan/Rules/Classes/ClassAttributesRuleTest.php index 026661a35e9..c9137ba5cd1 100644 --- a/tests/PHPStan/Rules/Classes/ClassAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ClassAttributesRuleTest.php @@ -15,6 +15,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPUnit\Framework\Attributes\RequiresPhp; /** @@ -49,6 +50,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Rules/Classes/ClassConstantAttributesRuleTest.php b/tests/PHPStan/Rules/Classes/ClassConstantAttributesRuleTest.php index 78c6df8bb9e..c35908ffef8 100644 --- a/tests/PHPStan/Rules/Classes/ClassConstantAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ClassConstantAttributesRuleTest.php @@ -15,6 +15,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; /** * @extends RuleTestCase @@ -44,6 +45,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Rules/Classes/ForbiddenNameCheckExtensionRuleTest.php b/tests/PHPStan/Rules/Classes/ForbiddenNameCheckExtensionRuleTest.php index 0a15eba1e0b..dcaa6dbd396 100644 --- a/tests/PHPStan/Rules/Classes/ForbiddenNameCheckExtensionRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ForbiddenNameCheckExtensionRuleTest.php @@ -15,6 +15,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; use function array_merge; /** @@ -46,6 +47,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php b/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php index 1ef99a5f51a..db07943b5e1 100644 --- a/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php +++ b/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php @@ -15,6 +15,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPUnit\Framework\Attributes\DataProvider; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -53,6 +54,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Rules/Constants/ConstantAttributesRuleTest.php b/tests/PHPStan/Rules/Constants/ConstantAttributesRuleTest.php index 875f774992d..841f4c04f97 100644 --- a/tests/PHPStan/Rules/Constants/ConstantAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Constants/ConstantAttributesRuleTest.php @@ -16,6 +16,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPUnit\Framework\Attributes\DataProvider; use PHPUnit\Framework\Attributes\RequiresPhp; use const PHP_VERSION_ID; @@ -50,6 +51,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Rules/EnumCases/EnumCaseAttributesRuleTest.php b/tests/PHPStan/Rules/EnumCases/EnumCaseAttributesRuleTest.php index 66c84d1dbcb..2241b6f63f8 100644 --- a/tests/PHPStan/Rules/EnumCases/EnumCaseAttributesRuleTest.php +++ b/tests/PHPStan/Rules/EnumCases/EnumCaseAttributesRuleTest.php @@ -15,6 +15,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPUnit\Framework\Attributes\RequiresPhp; /** @@ -45,6 +46,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Rules/Functions/ArrowFunctionAttributesRuleTest.php b/tests/PHPStan/Rules/Functions/ArrowFunctionAttributesRuleTest.php index fbfd8e33bf1..2583e52e2b9 100644 --- a/tests/PHPStan/Rules/Functions/ArrowFunctionAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ArrowFunctionAttributesRuleTest.php @@ -15,6 +15,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; /** * @extends RuleTestCase @@ -44,6 +45,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Rules/Functions/Bug14844Test.php b/tests/PHPStan/Rules/Functions/Bug14844Test.php index 0dc44d2ba63..94c36a078a2 100644 --- a/tests/PHPStan/Rules/Functions/Bug14844Test.php +++ b/tests/PHPStan/Rules/Functions/Bug14844Test.php @@ -9,6 +9,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPUnit\Framework\Attributes\RequiresPhp; /** @@ -37,6 +38,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $broker, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Rules/Functions/CallCallablesRuleTest.php b/tests/PHPStan/Rules/Functions/CallCallablesRuleTest.php index d2a48d3ae62..064a4faad3b 100644 --- a/tests/PHPStan/Rules/Functions/CallCallablesRuleTest.php +++ b/tests/PHPStan/Rules/Functions/CallCallablesRuleTest.php @@ -9,6 +9,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPUnit\Framework\Attributes\DataProvider; use PHPUnit\Framework\Attributes\RequiresPhp; use const PHP_VERSION_ID; @@ -41,6 +42,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Rules/Functions/CallToFunctionParametersRuleTest.php b/tests/PHPStan/Rules/Functions/CallToFunctionParametersRuleTest.php index 1476da715e2..27056d4c3e0 100644 --- a/tests/PHPStan/Rules/Functions/CallToFunctionParametersRuleTest.php +++ b/tests/PHPStan/Rules/Functions/CallToFunctionParametersRuleTest.php @@ -9,6 +9,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPUnit\Framework\Attributes\DataProvider; use PHPUnit\Framework\Attributes\RequiresPhp; use function sprintf; @@ -46,6 +47,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $broker, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, @@ -744,19 +746,19 @@ public function testPregReplaceCallback(): void { $this->analyse([__DIR__ . '/data/preg_replace_callback.php'], [ [ - 'Parameter #2 $callback of function preg_replace_callback expects callable(array): string, Closure(string): string given.', + 'Parameter #2 $callback of function preg_replace_callback expects Closure(array{non-falsy-string}): string, Closure(string): string given.', 6, ], [ - 'Parameter #2 $callback of function preg_replace_callback expects callable(array): string, Closure(string): string given.', + 'Parameter #2 $callback of function preg_replace_callback expects Closure(array{non-falsy-string}): string, Closure(string): string given.', 13, ], [ - 'Parameter #2 $callback of function preg_replace_callback expects callable(array): string, Closure(array): void given.', + 'Parameter #2 $callback of function preg_replace_callback expects Closure(array{non-falsy-string}): string, Closure(array): void given.', 20, ], [ - 'Parameter #2 $callback of function preg_replace_callback expects callable(array): string, Closure(): void given.', + 'Parameter #2 $callback of function preg_replace_callback expects Closure(array{non-falsy-string}): string, Closure(): void given.', 25, ], ]); @@ -2936,11 +2938,11 @@ public function testConstantParameterCheck(): void 110, ], [ - 'Parameter #2 $callback of function preg_replace_callback expects callable(array): string, Closure(mixed): array{non-falsy-string, int<-1, max>} given.', + 'Parameter #2 $callback of function preg_replace_callback expects Closure(array{array{non-falsy-string, int<-1, max>}}): string, Closure(mixed): array{non-falsy-string, int<-1, max>} given.', 113, ], [ - 'Parameter #2 $callback of function preg_replace_callback expects callable(array): string, Closure(mixed): array{non-falsy-string|null, int<-1, max>} given.', + 'Parameter #2 $callback of function preg_replace_callback expects Closure(array{array{non-falsy-string|null, int<-1, max>}}): string, Closure(mixed): array{non-falsy-string|null, int<-1, max>} given.', 116, ], [ diff --git a/tests/PHPStan/Rules/Functions/CallUserFuncRuleTest.php b/tests/PHPStan/Rules/Functions/CallUserFuncRuleTest.php index a05d57f9457..6da81fbcdd2 100644 --- a/tests/PHPStan/Rules/Functions/CallUserFuncRuleTest.php +++ b/tests/PHPStan/Rules/Functions/CallUserFuncRuleTest.php @@ -9,6 +9,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPUnit\Framework\Attributes\RequiresPhp; /** @@ -37,6 +38,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Rules/Functions/ClosureAttributesRuleTest.php b/tests/PHPStan/Rules/Functions/ClosureAttributesRuleTest.php index 83a4275b876..0122bd9ce4b 100644 --- a/tests/PHPStan/Rules/Functions/ClosureAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ClosureAttributesRuleTest.php @@ -15,6 +15,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; /** * @extends RuleTestCase @@ -44,6 +45,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Rules/Functions/FunctionAttributesRuleTest.php b/tests/PHPStan/Rules/Functions/FunctionAttributesRuleTest.php index 1400a20f41b..d0866dadb2a 100644 --- a/tests/PHPStan/Rules/Functions/FunctionAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Functions/FunctionAttributesRuleTest.php @@ -15,6 +15,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; /** * @extends RuleTestCase @@ -44,6 +45,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Rules/Functions/ParamAttributesRuleTest.php b/tests/PHPStan/Rules/Functions/ParamAttributesRuleTest.php index b33a196c946..447e7f88ece 100644 --- a/tests/PHPStan/Rules/Functions/ParamAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ParamAttributesRuleTest.php @@ -15,6 +15,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; /** * @extends RuleTestCase @@ -44,6 +45,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Rules/Methods/CallMethodsRuleTest.php b/tests/PHPStan/Rules/Methods/CallMethodsRuleTest.php index a62a64f4292..e5694a45326 100644 --- a/tests/PHPStan/Rules/Methods/CallMethodsRuleTest.php +++ b/tests/PHPStan/Rules/Methods/CallMethodsRuleTest.php @@ -9,6 +9,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPUnit\Framework\Attributes\DataProvider; use PHPUnit\Framework\Attributes\RequiresPhp; use const PHP_VERSION_ID; @@ -55,6 +56,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php b/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php index 18f7bbc6feb..206fe36596f 100644 --- a/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php +++ b/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php @@ -14,6 +14,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPUnit\Framework\Attributes\DataProvider; use PHPUnit\Framework\Attributes\RequiresPhp; use function array_merge; @@ -71,6 +72,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Rules/Methods/MethodAttributesRuleTest.php b/tests/PHPStan/Rules/Methods/MethodAttributesRuleTest.php index eb6e3c6f6ad..febfb6bfa58 100644 --- a/tests/PHPStan/Rules/Methods/MethodAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Methods/MethodAttributesRuleTest.php @@ -15,6 +15,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPUnit\Framework\Attributes\DataProvider; /** @@ -47,6 +48,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Rules/Methods/MethodCallWithPossiblyRenamedNamedArgumentRuleTest.php b/tests/PHPStan/Rules/Methods/MethodCallWithPossiblyRenamedNamedArgumentRuleTest.php index bcece2e61ef..fa83bf91ba8 100644 --- a/tests/PHPStan/Rules/Methods/MethodCallWithPossiblyRenamedNamedArgumentRuleTest.php +++ b/tests/PHPStan/Rules/Methods/MethodCallWithPossiblyRenamedNamedArgumentRuleTest.php @@ -12,6 +12,7 @@ use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\CompositeRule; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPUnit\Framework\Attributes\RequiresPhp; /** @@ -32,7 +33,7 @@ protected function getRule(): Rule return new CompositeRule([ new CallMethodsRule( new MethodCallCheck($reflectionProvider, $ruleLevelHelper, true, true), - new FunctionCallParametersCheck($ruleLevelHelper, new NullsafeCheck(), new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, true, true, true, true), + new FunctionCallParametersCheck($ruleLevelHelper, new NullsafeCheck(), new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, self::getContainer()->getByType(DynamicParameterTypeResolver::class), true, true, true, true), ), new OverridingMethodRule( $phpVersion, diff --git a/tests/PHPStan/Rules/Properties/PropertyAttributesRuleTest.php b/tests/PHPStan/Rules/Properties/PropertyAttributesRuleTest.php index 8b1c56aa1c0..92ac69d9245 100644 --- a/tests/PHPStan/Rules/Properties/PropertyAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Properties/PropertyAttributesRuleTest.php @@ -15,6 +15,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPUnit\Framework\Attributes\RequiresPhp; use const PHP_VERSION_ID; @@ -46,6 +47,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Rules/Properties/PropertyHookAttributesRuleTest.php b/tests/PHPStan/Rules/Properties/PropertyHookAttributesRuleTest.php index 7b00b3faafd..c92453b2786 100644 --- a/tests/PHPStan/Rules/Properties/PropertyHookAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Properties/PropertyHookAttributesRuleTest.php @@ -14,6 +14,7 @@ use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPUnit\Framework\Attributes\RequiresPhp; /** @@ -44,6 +45,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true, diff --git a/tests/PHPStan/Rules/Traits/TraitAttributesRuleTest.php b/tests/PHPStan/Rules/Traits/TraitAttributesRuleTest.php index 086984256f1..95eebda2113 100644 --- a/tests/PHPStan/Rules/Traits/TraitAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Traits/TraitAttributesRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Traits; +use PHPStan\Type\DynamicParameterTypeResolver; use PHPStan\Php\PhpVersion; use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Classes\ForbiddenClassNameExtension; @@ -51,6 +52,7 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new PropertyReflectionFinder(), $reflectionProvider, + self::getContainer()->getByType(DynamicParameterTypeResolver::class), checkArgumentTypes: true, checkArgumentsPassedByReference: true, checkExtraArguments: true,