Introduce more virtual expr handlers

Author: ondrejmirtes

src/Analyser/ExprHandler/Virtual/ExistingArrayDimFetchHandler.php

@@ -0,0 +1,48 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser\ExprHandler\Virtual;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Stmt;
+use PHPStan\Analyser\ExpressionContext;
+use PHPStan\Analyser\ExpressionResult;
+use PHPStan\Analyser\ExpressionResultStorage;
+use PHPStan\Analyser\ExprHandler;
+use PHPStan\Analyser\MutatingScope;
+use PHPStan\Analyser\NodeScopeResolver;
+use PHPStan\DependencyInjection\AutowiredService;
+use PHPStan\Node\Expr\ExistingArrayDimFetch;
+use PHPStan\Type\Type;
+
+/**
+ * @implements ExprHandler<ExistingArrayDimFetch>
+ */
+#[AutowiredService]
+final class ExistingArrayDimFetchHandler implements ExprHandler
+{
+
+	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
+	{
+		// 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
+
+		return new ExpressionResult(
+			$scope,
+			hasYield: false,
+			isAlwaysTerminating: false,
+			throwPoints: [],
+			impurePoints: [],
+		);
+	}
+
+	public function resolveType(MutatingScope $scope, Expr $expr): Type
+	{
+		return $scope->getType(new Expr\ArrayDimFetch($expr->getVar(), $expr->getDim()));
+	}
+
+}

src/Analyser/ExprHandler/Virtual/GetIterableKeyTypeExprHandler.php

@@ -0,0 +1,48 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser\ExprHandler\Virtual;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Stmt;
+use PHPStan\Analyser\ExpressionContext;
+use PHPStan\Analyser\ExpressionResult;
+use PHPStan\Analyser\ExpressionResultStorage;
+use PHPStan\Analyser\ExprHandler;
+use PHPStan\Analyser\MutatingScope;
+use PHPStan\Analyser\NodeScopeResolver;
+use PHPStan\DependencyInjection\AutowiredService;
+use PHPStan\Node\Expr\GetIterableKeyTypeExpr;
+use PHPStan\Type\Type;
+
+/**
+ * @implements ExprHandler<GetIterableKeyTypeExpr>
+ */
+#[AutowiredService]
+final class GetIterableKeyTypeExprHandler implements ExprHandler
+{
+
+	public function supports(Expr $expr): bool
+	{
+		return $expr instanceof GetIterableKeyTypeExpr;
+	}
+
+	public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): 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
+
+		return new ExpressionResult(
+			$scope,
+			hasYield: false,
+			isAlwaysTerminating: false,
+			throwPoints: [],
+			impurePoints: [],
+		);
+	}
+
+	public function resolveType(MutatingScope $scope, Expr $expr): Type
+	{
+		return $scope->getIterableKeyType($scope->getType($expr->getExpr()));
+	}
+
+}

src/Analyser/ExprHandler/Virtual/GetIterableValueTypeExprHandler.php

@@ -0,0 +1,48 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser\ExprHandler\Virtual;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Stmt;
+use PHPStan\Analyser\ExpressionContext;
+use PHPStan\Analyser\ExpressionResult;
+use PHPStan\Analyser\ExpressionResultStorage;
+use PHPStan\Analyser\ExprHandler;
+use PHPStan\Analyser\MutatingScope;
+use PHPStan\Analyser\NodeScopeResolver;
+use PHPStan\DependencyInjection\AutowiredService;
+use PHPStan\Node\Expr\GetIterableValueTypeExpr;
+use PHPStan\Type\Type;
+
+/**
+ * @implements ExprHandler<GetIterableValueTypeExpr>
+ */
+#[AutowiredService]
+final class GetIterableValueTypeExprHandler implements ExprHandler
+{
+
+	public function supports(Expr $expr): bool
+	{
+		return $expr instanceof GetIterableValueTypeExpr;
+	}
+
+	public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): 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
+
+		return new ExpressionResult(
+			$scope,
+			hasYield: false,
+			isAlwaysTerminating: false,
+			throwPoints: [],
+			impurePoints: [],
+		);
+	}
+
+	public function resolveType(MutatingScope $scope, Expr $expr): Type
+	{
+		return $scope->getIterableValueType($scope->getType($expr->getExpr()));
+	}
+
+}

src/Analyser/ExprHandler/Virtual/GetOffsetValueTypeExprHandler.php

@@ -0,0 +1,48 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser\ExprHandler\Virtual;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Stmt;
+use PHPStan\Analyser\ExpressionContext;
+use PHPStan\Analyser\ExpressionResult;
+use PHPStan\Analyser\ExpressionResultStorage;
+use PHPStan\Analyser\ExprHandler;
+use PHPStan\Analyser\MutatingScope;
+use PHPStan\Analyser\NodeScopeResolver;
+use PHPStan\DependencyInjection\AutowiredService;
+use PHPStan\Node\Expr\GetOffsetValueTypeExpr;
+use PHPStan\Type\Type;
+
+/**
+ * @implements ExprHandler<GetOffsetValueTypeExpr>
+ */
+#[AutowiredService]
+final class GetOffsetValueTypeExprHandler implements ExprHandler
+{
+
+	public function supports(Expr $expr): bool
+	{
+		return $expr instanceof GetOffsetValueTypeExpr;
+	}
+
+	public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): 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
+
+		return new ExpressionResult(
+			$scope,
+			hasYield: false,
+			isAlwaysTerminating: false,
+			throwPoints: [],
+			impurePoints: [],
+		);
+	}
+
+	public function resolveType(MutatingScope $scope, Expr $expr): Type
+	{
+		return $scope->getType($expr->getVar())->getOffsetValueType($scope->getType($expr->getDim()));
+	}
+
+}

src/Analyser/ExprHandler/Virtual/NativeTypeExprHandler.php

@@ -0,0 +1,51 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser\ExprHandler\Virtual;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Stmt;
+use PHPStan\Analyser\ExpressionContext;
+use PHPStan\Analyser\ExpressionResult;
+use PHPStan\Analyser\ExpressionResultStorage;
+use PHPStan\Analyser\ExprHandler;
+use PHPStan\Analyser\MutatingScope;
+use PHPStan\Analyser\NodeScopeResolver;
+use PHPStan\DependencyInjection\AutowiredService;
+use PHPStan\Node\Expr\NativeTypeExpr;
+use PHPStan\Type\Type;
+
+/**
+ * @implements ExprHandler<NativeTypeExpr>
+ */
+#[AutowiredService]
+final class NativeTypeExprHandler implements ExprHandler
+{
+
+	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
+	{
+		// 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
+
+		return new ExpressionResult(
+			$scope,
+			hasYield: false,
+			isAlwaysTerminating: false,
+			throwPoints: [],
+			impurePoints: [],
+		);
+	}
+
+	public function resolveType(MutatingScope $scope, Expr $expr): Type
+	{
+		if ($scope->nativeTypesPromoted) {
+			return $expr->getNativeType();
+		}
+		return $expr->getPhpDocType();
+	}
+
+}

src/Analyser/ExprHandler/Virtual/OriginalPropertyTypeExprHandler.php

@@ -0,0 +1,61 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser\ExprHandler\Virtual;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Stmt;
+use PHPStan\Analyser\ExpressionContext;
+use PHPStan\Analyser\ExpressionResult;
+use PHPStan\Analyser\ExpressionResultStorage;
+use PHPStan\Analyser\ExprHandler;
+use PHPStan\Analyser\MutatingScope;
+use PHPStan\Analyser\NodeScopeResolver;
+use PHPStan\DependencyInjection\AutowiredService;
+use PHPStan\Node\Expr\OriginalPropertyTypeExpr;
+use PHPStan\Rules\Properties\PropertyReflectionFinder;
+use PHPStan\Type\ErrorType;
+use PHPStan\Type\Type;
+
+/**
+ * @implements ExprHandler<OriginalPropertyTypeExpr>
+ */
+#[AutowiredService]
+final class OriginalPropertyTypeExprHandler implements ExprHandler
+{
+
+	public function __construct(
+		private PropertyReflectionFinder $propertyReflectionFinder,
+	)
+	{
+	}
+
+	public function supports(Expr $expr): bool
+	{
+		return $expr instanceof OriginalPropertyTypeExpr;
+	}
+
+	public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): 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
+
+		return new ExpressionResult(
+			$scope,
+			hasYield: false,
+			isAlwaysTerminating: false,
+			throwPoints: [],
+			impurePoints: [],
+		);
+	}
+
+	public function resolveType(MutatingScope $scope, Expr $expr): Type
+	{
+		$propertyReflection = $this->propertyReflectionFinder->findPropertyReflectionFromNode($expr->getPropertyFetch(), $scope);
+		if ($propertyReflection === null) {
+			return new ErrorType();
+		}
+
+		return $propertyReflection->getReadableType();
+	}
+
+}

src/Analyser/ExprHandler/Virtual/SetExistingOffsetValueTypeExprHandler.php

@@ -0,0 +1,61 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser\ExprHandler\Virtual;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Stmt;
+use PHPStan\Analyser\ExpressionContext;
+use PHPStan\Analyser\ExpressionResult;
+use PHPStan\Analyser\ExpressionResultStorage;
+use PHPStan\Analyser\ExprHandler;
+use PHPStan\Analyser\MutatingScope;
+use PHPStan\Analyser\NodeScopeResolver;
+use PHPStan\DependencyInjection\AutowiredService;
+use PHPStan\Node\Expr\OriginalPropertyTypeExpr;
+use PHPStan\Node\Expr\SetExistingOffsetValueTypeExpr;
+use PHPStan\Type\Type;
+use PHPStan\Type\UnionType;
+
+/**
+ * @implements ExprHandler<SetExistingOffsetValueTypeExpr>
+ */
+#[AutowiredService]
+final class SetExistingOffsetValueTypeExprHandler implements ExprHandler
+{
+
+	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
+	{
+		// 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
+
+		return new ExpressionResult(
+			$scope,
+			hasYield: false,
+			isAlwaysTerminating: false,
+			throwPoints: [],
+			impurePoints: [],
+		);
+	}
+
+	public function resolveType(MutatingScope $scope, Expr $expr): Type
+	{
+		$varNode = $expr->getVar();
+		$varType = $scope->getType($varNode);
+		if ($varNode instanceof OriginalPropertyTypeExpr) {
+			$currentPropertyType = $scope->getType($varNode->getPropertyFetch());
+			if ($varType instanceof UnionType) {
+				$varType = $varType->filterTypes(static fn (Type $innerType) => !$innerType->isSuperTypeOf($currentPropertyType)->no());
+			}
+		}
+		return $varType->setExistingOffsetValueType(
+			$scope->getType($expr->getDim()),
+			$scope->getType($expr->getValue()),
+		);
+	}
+
+}