WIP for bound parameter type forwarding

Seldaek · staabm · commit 8b0541c9fe8c · 2022-05-18T15:15:16.000+02:00
diff --git a/src/Extensions/DoctrineConnectionExecuteQueryDynamicReturnTypeExtension.php b/src/Extensions/DoctrineConnectionExecuteQueryDynamicReturnTypeExtension.php
@@ -54,28 +54,33 @@ public function getTypeFromMethodCall(MethodReflection $methodReflection, Method
         }
 
         $params = null;
+        $paramTypes = null;
         if (\count($args) > 1) {
             $params = $args[1]->value;
         }
+        if (\count($args) > 2) {
+            $paramTypes = $args[2]->value;
+        }
 
-        $resultType = $this->inferType($args[0]->value, $params, $scope);
+        $resultType = $this->inferType($args[0]->value, $params, $paramTypes, $scope);
         if (null !== $resultType) {
             return $resultType;
         }
 
         return $defaultReturn;
     }
 
-    private function inferType(Expr $queryExpr, ?Expr $paramsExpr, Scope $scope): ?Type
+    private function inferType(Expr $queryExpr, ?Expr $paramsExpr, ?Expr $paramTypesExpr, Scope $scope): ?Type
     {
         if (null === $paramsExpr) {
             $queryReflection = new QueryReflection();
             $queryStrings = $queryReflection->resolveQueryStrings($queryExpr, $scope);
         } else {
             $parameterTypes = $scope->getType($paramsExpr);
+            $boundParameterTypes = $scope->getType($paramsExpr);
 
             $queryReflection = new QueryReflection();
-            $queryStrings = $queryReflection->resolvePreparedQueryStrings($queryExpr, $parameterTypes, $scope);
+            $queryStrings = $queryReflection->resolvePreparedQueryStrings($queryExpr, $parameterTypes, $boundParameterTypes, $scope);
         }
 
         $doctrineReflection = new DoctrineReflection();
diff --git a/src/Extensions/DoctrineConnectionFetchDynamicReturnTypeExtension.php b/src/Extensions/DoctrineConnectionFetchDynamicReturnTypeExtension.php
@@ -88,7 +88,7 @@ private function inferType(MethodReflection $methodReflection, Expr $queryExpr,
             $queryStrings = $queryReflection->resolveQueryStrings($queryExpr, $scope);
         } else {
             $parameterTypes = $scope->getType($paramsExpr);
-            $queryStrings = $queryReflection->resolvePreparedQueryStrings($queryExpr, $parameterTypes, $scope);
+            $queryStrings = $queryReflection->resolvePreparedQueryStrings($queryExpr, $parameterTypes, null, $scope);
         }
 
         return $doctrineReflection->createFetchType($queryStrings, $methodReflection);
diff --git a/src/Extensions/DoctrineStatementExecuteDynamicReturnTypeExtension.php b/src/Extensions/DoctrineStatementExecuteDynamicReturnTypeExtension.php
@@ -70,7 +70,7 @@ private function inferType(MethodReflection $methodReflection, MethodCall $metho
         }
 
         $queryReflection = new QueryReflection();
-        $queryStrings = $queryReflection->resolvePreparedQueryStrings($queryExpr, $parameterTypes, $scope);
+        $queryStrings = $queryReflection->resolvePreparedQueryStrings($queryExpr, $parameterTypes, null, $scope);
 
         return $doctrineReflection->createGenericResult($queryStrings, QueryReflector::FETCH_TYPE_BOTH);
     }
diff --git a/src/Extensions/PdoStatementExecuteTypeSpecifyingExtension.php b/src/Extensions/PdoStatementExecuteTypeSpecifyingExtension.php
@@ -66,7 +66,7 @@ private function inferStatementType(MethodReflection $methodReflection, MethodCa
         $parameterTypes = $scope->getType($args[0]->value);
 
         $queryReflection = new QueryReflection();
-        $queryStrings = $queryReflection->resolvePreparedQueryStrings($queryExpr, $parameterTypes, $scope);
+        $queryStrings = $queryReflection->resolvePreparedQueryStrings($queryExpr, $parameterTypes, null, $scope);
 
         $reflectionFetchType = QueryReflection::getRuntimeConfiguration()->getDefaultFetchMode();
 
diff --git a/src/QueryReflection/QueryReflection.php b/src/QueryReflection/QueryReflection.php
@@ -73,12 +73,12 @@ public function getResultType(string $queryString, int $fetchType): ?Type
      *
      * @throws UnresolvableQueryException
      */
-    public function resolvePreparedQueryStrings(Expr $queryExpr, Type $parameterTypes, Scope $scope): iterable
+    public function resolvePreparedQueryStrings(Expr $queryExpr, Type $parameterTypes, ?Type $boundParameterTypes, Scope $scope): iterable
     {
         $type = $scope->getType($queryExpr);
 
         if ($type instanceof UnionType) {
-            $parameters = $this->resolveParameters($parameterTypes);
+            $parameters = $this->resolveParameters($parameterTypes, $boundParameterTypes);
             if (null === $parameters) {
                 return null;
             }
@@ -103,15 +103,15 @@ public function resolvePreparedQueryStrings(Expr $queryExpr, Type $parameterType
      *
      * @throws UnresolvableQueryException
      */
-    public function resolvePreparedQueryString(Expr $queryExpr, Type $parameterTypes, Scope $scope): ?string
+    public function resolvePreparedQueryString(Expr $queryExpr, Type $parameterTypes, ?Type, $boundParameterTypes, Scope $scope): ?string
     {
         $queryString = $this->resolveQueryExpr($queryExpr, $scope);
 
         if (null === $queryString) {
             return null;
         }
 
-        $parameters = $this->resolveParameters($parameterTypes);
+        $parameters = $this->resolveParameters($parameterTypes, $boundParameterTypes);
         if (null === $parameters) {
             return null;
         }
@@ -211,20 +211,20 @@ public static function getQueryType(string $query): ?string
      *
      * @throws UnresolvableQueryException
      */
-    public function resolveParameters(Type $parameterTypes): ?array
+    public function resolveParameters(Type $parameterTypes, ?Type $boundParameterTypes): ?array
     {
         $parameters = [];
 
         if ($parameterTypes instanceof UnionType) {
             foreach (TypeUtils::getConstantArrays($parameterTypes) as $constantArray) {
-                $parameters = $parameters + $this->resolveConstantArray($constantArray, true);
+                $parameters = $parameters + $this->resolveConstantArray($constantArray, $boundParameterTypes, true);
             }
 
             return $parameters;
         }
 
         if ($parameterTypes instanceof ConstantArrayType) {
-            return $this->resolveConstantArray($parameterTypes, false);
+            return $this->resolveConstantArray($parameterTypes, $boundParameterTypes, false);
         }
 
         return null;
@@ -235,7 +235,7 @@ public function resolveParameters(Type $parameterTypes): ?array
      *
      * @throws UnresolvableQueryException
      */
-    private function resolveConstantArray(ConstantArrayType $parameterTypes, bool $forceOptional): array
+    private function resolveConstantArray(ConstantArrayType $parameterTypes, ?Type $boundParameterTypes, bool $forceOptional): array
     {
         $parameters = [];
 
@@ -259,7 +259,7 @@ private function resolveConstantArray(ConstantArrayType $parameterTypes, bool $f
                 $param = new Parameter(
                     $placeholderName,
                     $valueTypes[$i],
-                    QuerySimulation::simulateParamValueType($valueTypes[$i], true),
+                    QuerySimulation::simulateParamValueType($valueTypes[$i], true), // TODO pass $i of $boundParameterTypes here if a resolved constant type is available?
                     $isOptional
                 );
 
@@ -268,7 +268,7 @@ private function resolveConstantArray(ConstantArrayType $parameterTypes, bool $f
                 $param = new Parameter(
                     null,
                     $valueTypes[$i],
-                    QuerySimulation::simulateParamValueType($valueTypes[$i], true),
+                    QuerySimulation::simulateParamValueType($valueTypes[$i], true), // TODO pass $i of $boundParameterTypes here if a resolved constant type is available?
                     $isOptional
                 );
 
diff --git a/src/Rules/PdoStatementExecuteMethodRule.php b/src/Rules/PdoStatementExecuteMethodRule.php
@@ -95,7 +95,7 @@ private function checkErrors(MethodReflection $methodReflection, MethodCall $met
         }
 
         try {
-            $parameters = $queryReflection->resolveParameters($parameterTypes) ?? [];
+            $parameters = $queryReflection->resolveParameters($parameterTypes, null) ?? [];
         } catch (UnresolvableQueryException $exception) {
             return [
                 RuleErrorBuilder::message($exception->asRuleMessage())->tip(UnresolvableQueryException::RULE_TIP)->line($methodCall->getLine())->build(),

Original file line number	Diff line number	Diff line change
`@@ -54,28 +54,33 @@ public function getTypeFromMethodCall(MethodReflection $methodReflection, Method`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`$params = null;`
	`57`	`+ $paramTypes = null;`
`57`	`58`	`if (\count($args) > 1) {`
`58`	`59`	`$params = $args[1]->value;`
`59`	`60`	`}`
	`61`	`+ if (\count($args) > 2) {`
	`62`	`+ $paramTypes = $args[2]->value;`
	`63`	`+ }`
`60`	`64`
`61`		`- $resultType = $this->inferType($args[0]->value, $params, $scope);`
	`65`	`+ $resultType = $this->inferType($args[0]->value, $params, $paramTypes, $scope);`
`62`	`66`	`if (null !== $resultType) {`
`63`	`67`	`return $resultType;`
`64`	`68`	`}`
`65`	`69`
`66`	`70`	`return $defaultReturn;`
`67`	`71`	`}`
`68`	`72`
`69`		`- private function inferType(Expr $queryExpr, ?Expr $paramsExpr, Scope $scope): ?Type`
	`73`	`+ private function inferType(Expr $queryExpr, ?Expr $paramsExpr, ?Expr $paramTypesExpr, Scope $scope): ?Type`
`70`	`74`	`{`
`71`	`75`	`if (null === $paramsExpr) {`
`72`	`76`	`$queryReflection = new QueryReflection();`
`73`	`77`	`$queryStrings = $queryReflection->resolveQueryStrings($queryExpr, $scope);`
`74`	`78`	`} else {`
`75`	`79`	`$parameterTypes = $scope->getType($paramsExpr);`
	`80`	`+ $boundParameterTypes = $scope->getType($paramsExpr);`
`76`	`81`
`77`	`82`	`$queryReflection = new QueryReflection();`
`78`		`- $queryStrings = $queryReflection->resolvePreparedQueryStrings($queryExpr, $parameterTypes, $scope);`
	`83`	`+ $queryStrings = $queryReflection->resolvePreparedQueryStrings($queryExpr, $parameterTypes, $boundParameterTypes, $scope);`
`79`	`84`	`}`
`80`	`85`
`81`	`86`	`$doctrineReflection = new DoctrineReflection();`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ private function inferType(MethodReflection $methodReflection, Expr $queryExpr,`
`88`	`88`	`$queryStrings = $queryReflection->resolveQueryStrings($queryExpr, $scope);`
`89`	`89`	`} else {`
`90`	`90`	`$parameterTypes = $scope->getType($paramsExpr);`
`91`		`- $queryStrings = $queryReflection->resolvePreparedQueryStrings($queryExpr, $parameterTypes, $scope);`
	`91`	`+ $queryStrings = $queryReflection->resolvePreparedQueryStrings($queryExpr, $parameterTypes, null, $scope);`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`return $doctrineReflection->createFetchType($queryStrings, $methodReflection);`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ private function inferType(MethodReflection $methodReflection, MethodCall $metho`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`$queryReflection = new QueryReflection();`
`73`		`- $queryStrings = $queryReflection->resolvePreparedQueryStrings($queryExpr, $parameterTypes, $scope);`
	`73`	`+ $queryStrings = $queryReflection->resolvePreparedQueryStrings($queryExpr, $parameterTypes, null, $scope);`
`74`	`74`
`75`	`75`	`return $doctrineReflection->createGenericResult($queryStrings, QueryReflector::FETCH_TYPE_BOTH);`
`76`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -73,12 +73,12 @@ public function getResultType(string $queryString, int $fetchType): ?Type`
`73`	`73`	`*`
`74`	`74`	`* @throws UnresolvableQueryException`
`75`	`75`	`*/`
`76`		`- public function resolvePreparedQueryStrings(Expr $queryExpr, Type $parameterTypes, Scope $scope): iterable`
	`76`	`+ public function resolvePreparedQueryStrings(Expr $queryExpr, Type $parameterTypes, ?Type $boundParameterTypes, Scope $scope): iterable`
`77`	`77`	`{`
`78`	`78`	`$type = $scope->getType($queryExpr);`
`79`	`79`
`80`	`80`	`if ($type instanceof UnionType) {`
`81`		`- $parameters = $this->resolveParameters($parameterTypes);`
	`81`	`+ $parameters = $this->resolveParameters($parameterTypes, $boundParameterTypes);`
`82`	`82`	`if (null === $parameters) {`
`83`	`83`	`return null;`
`84`	`84`	`}`
`@@ -103,15 +103,15 @@ public function resolvePreparedQueryStrings(Expr $queryExpr, Type $parameterType`
`103`	`103`	`*`
`104`	`104`	`* @throws UnresolvableQueryException`
`105`	`105`	`*/`
`106`		`- public function resolvePreparedQueryString(Expr $queryExpr, Type $parameterTypes, Scope $scope): ?string`
	`106`	`+ public function resolvePreparedQueryString(Expr $queryExpr, Type $parameterTypes, ?Type, $boundParameterTypes, Scope $scope): ?string`
`107`	`107`	`{`
`108`	`108`	`$queryString = $this->resolveQueryExpr($queryExpr, $scope);`
`109`	`109`
`110`	`110`	`if (null === $queryString) {`
`111`	`111`	`return null;`
`112`	`112`	`}`
`113`	`113`
`114`		`- $parameters = $this->resolveParameters($parameterTypes);`
	`114`	`+ $parameters = $this->resolveParameters($parameterTypes, $boundParameterTypes);`
`115`	`115`	`if (null === $parameters) {`
`116`	`116`	`return null;`
`117`	`117`	`}`
`@@ -211,20 +211,20 @@ public static function getQueryType(string $query): ?string`
`211`	`211`	`*`
`212`	`212`	`* @throws UnresolvableQueryException`
`213`	`213`	`*/`
`214`		`- public function resolveParameters(Type $parameterTypes): ?array`
	`214`	`+ public function resolveParameters(Type $parameterTypes, ?Type $boundParameterTypes): ?array`
`215`	`215`	`{`
`216`	`216`	`$parameters = [];`
`217`	`217`
`218`	`218`	`if ($parameterTypes instanceof UnionType) {`
`219`	`219`	`foreach (TypeUtils::getConstantArrays($parameterTypes) as $constantArray) {`
`220`		`- $parameters = $parameters + $this->resolveConstantArray($constantArray, true);`
	`220`	`+ $parameters = $parameters + $this->resolveConstantArray($constantArray, $boundParameterTypes, true);`
`221`	`221`	`}`
`222`	`222`
`223`	`223`	`return $parameters;`
`224`	`224`	`}`
`225`	`225`
`226`	`226`	`if ($parameterTypes instanceof ConstantArrayType) {`
`227`		`- return $this->resolveConstantArray($parameterTypes, false);`
	`227`	`+ return $this->resolveConstantArray($parameterTypes, $boundParameterTypes, false);`
`228`	`228`	`}`
`229`	`229`
`230`	`230`	`return null;`
`@@ -235,7 +235,7 @@ public function resolveParameters(Type $parameterTypes): ?array`
`235`	`235`	`*`
`236`	`236`	`* @throws UnresolvableQueryException`
`237`	`237`	`*/`
`238`		`- private function resolveConstantArray(ConstantArrayType $parameterTypes, bool $forceOptional): array`
	`238`	`+ private function resolveConstantArray(ConstantArrayType $parameterTypes, ?Type $boundParameterTypes, bool $forceOptional): array`
`239`	`239`	`{`
`240`	`240`	`$parameters = [];`
`241`	`241`
`@@ -259,7 +259,7 @@ private function resolveConstantArray(ConstantArrayType $parameterTypes, bool $f`
`259`	`259`	`$param = new Parameter(`
`260`	`260`	`$placeholderName,`
`261`	`261`	`$valueTypes[$i],`
`262`		`- QuerySimulation::simulateParamValueType($valueTypes[$i], true),`
	`262`	`+ QuerySimulation::simulateParamValueType($valueTypes[$i], true), // TODO pass $i of $boundParameterTypes here if a resolved constant type is available?`
`263`	`263`	`$isOptional`
`264`	`264`	`);`
`265`	`265`
`@@ -268,7 +268,7 @@ private function resolveConstantArray(ConstantArrayType $parameterTypes, bool $f`
`268`	`268`	`$param = new Parameter(`
`269`	`269`	`null,`
`270`	`270`	`$valueTypes[$i],`
`271`		`- QuerySimulation::simulateParamValueType($valueTypes[$i], true),`
	`271`	`+ QuerySimulation::simulateParamValueType($valueTypes[$i], true), // TODO pass $i of $boundParameterTypes here if a resolved constant type is available?`
`272`	`272`	`$isOptional`
`273`	`273`	`);`
`274`	`274`
Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ private function checkErrors(MethodReflection $methodReflection, MethodCall $met`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`try {`
`98`		`- $parameters = $queryReflection->resolveParameters($parameterTypes) ?? [];`
	`98`	`+ $parameters = $queryReflection->resolveParameters($parameterTypes, null) ?? [];`
`99`	`99`	`} catch (UnresolvableQueryException $exception) {`
`100`	`100`	`return [`
`101`	`101`	`RuleErrorBuilder::message($exception->asRuleMessage())->tip(UnresolvableQueryException::RULE_TIP)->line($methodCall->getLine())->build(),`