refactor PdoStatementFetchDynamicReturnTypeExtension (#57)

Co-authored-by: Markus Staab <[email protected]>

Author: staabm

src/Extensions/PdoQuoteDynamicReturnTypeExtension.php

@@ -90,7 +90,7 @@ private function inferType(MethodCall $methodCall, Scope $scope): ?Type
             return $stringType;
         }
 
-        return TypeCombinator::union($stringType, new ConstantBooleanType(false));;
+        return TypeCombinator::union($stringType, new ConstantBooleanType(false));
     }
 
     private function inferStringType(Type $argType): Type

src/Extensions/PdoStatementFetchDynamicReturnTypeExtension.php

@@ -50,73 +50,75 @@ public function isMethodSupported(MethodReflection $methodReflection): bool
 
     public function getTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, Scope $scope): Type
     {
-        $args = $methodCall->getArgs();
         $defaultReturn = ParametersAcceptorSelector::selectSingle($methodReflection->getVariants())->getReturnType();
 
         if (QueryReflection::getRuntimeConfiguration()->throwsPdoExceptions($this->phpVersion) && !$defaultReturn instanceof MixedType) {
             $defaultReturn = TypeCombinator::remove($defaultReturn, new ConstantBooleanType(false));
         }
 
+        $resultType = $this->inferType($methodReflection, $methodCall, $scope);
+        if (null !== $resultType) {
+            return $resultType;
+        }
+
+        return $defaultReturn;
+    }
+
+    private function inferType(MethodReflection $methodReflection, MethodCall $methodCall, Scope $scope): ?Type
+    {
+        $args = $methodCall->getArgs();
         $statementType = $scope->getType($methodCall->var);
 
-        if ($statementType instanceof GenericObjectType) {
-            $genericTypes = $statementType->getTypes();
+        if (!$statementType instanceof GenericObjectType) {
+            return null;
+        }
 
-            if (1 !== \count($genericTypes)) {
-                return $defaultReturn;
-            }
+        $genericTypes = $statementType->getTypes();
 
-            $fetchType = PDO::FETCH_BOTH;
-            if (\count($args) > 0) {
-                $fetchModeType = $scope->getType($args[0]->value);
-                if (!$fetchModeType instanceof ConstantIntegerType) {
-                    return $defaultReturn;
-                }
-                $fetchType = $fetchModeType->getValue();
+        if (1 !== \count($genericTypes)) {
+            return null;
+        }
 
-                if (!\in_array($fetchType, [PDO::FETCH_ASSOC, PDO::FETCH_NUM, PDO::FETCH_BOTH])) {
-                    return $defaultReturn;
-                }
+        $fetchType = PDO::FETCH_BOTH;
+        if (\count($args) > 0) {
+            $fetchModeType = $scope->getType($args[0]->value);
+            if (!$fetchModeType instanceof ConstantIntegerType) {
+                return null;
             }
+            $fetchType = $fetchModeType->getValue();
 
-            $resultType = $genericTypes[0];
-
-            if ((PDO::FETCH_NUM === $fetchType || PDO::FETCH_ASSOC === $fetchType) && $resultType instanceof ConstantArrayType) {
-                $builder = ConstantArrayTypeBuilder::createEmpty();
+            if (!\in_array($fetchType, [PDO::FETCH_ASSOC, PDO::FETCH_NUM, PDO::FETCH_BOTH])) {
+                return null;
+            }
+        }
 
-                $keyTypes = $resultType->getKeyTypes();
-                $valueTypes = $resultType->getValueTypes();
+        $resultType = $genericTypes[0];
 
-                foreach ($keyTypes as $i => $keyType) {
-                    if (PDO::FETCH_NUM === $fetchType && $keyType instanceof ConstantIntegerType) {
-                        $builder->setOffsetValueType($keyType, $valueTypes[$i]);
-                    } elseif (PDO::FETCH_ASSOC === $fetchType && $keyType instanceof ConstantStringType) {
-                        $builder->setOffsetValueType($keyType, $valueTypes[$i]);
-                    }
-                }
+        if ((PDO::FETCH_NUM === $fetchType || PDO::FETCH_ASSOC === $fetchType) && $resultType instanceof ConstantArrayType) {
+            $builder = ConstantArrayTypeBuilder::createEmpty();
 
-                if ('fetchAll' === $methodReflection->getName()) {
-                    return new ArrayType(new IntegerType(), $builder->getArray());
-                }
+            $keyTypes = $resultType->getKeyTypes();
+            $valueTypes = $resultType->getValueTypes();
 
-                if (QueryReflection::getRuntimeConfiguration()->throwsPdoExceptions($this->phpVersion)) {
-                    return $builder->getArray();
+            foreach ($keyTypes as $i => $keyType) {
+                if (PDO::FETCH_NUM === $fetchType && $keyType instanceof ConstantIntegerType) {
+                    $builder->setOffsetValueType($keyType, $valueTypes[$i]);
+                } elseif (PDO::FETCH_ASSOC === $fetchType && $keyType instanceof ConstantStringType) {
+                    $builder->setOffsetValueType($keyType, $valueTypes[$i]);
                 }
-
-                return new UnionType([$builder->getArray(), new ConstantBooleanType(false)]);
             }
 
-            if ('fetchAll' === $methodReflection->getName()) {
-                return new ArrayType(new IntegerType(), $resultType);
-            }
+            $resultType = $builder->getArray();
+        }
 
-            if (QueryReflection::getRuntimeConfiguration()->throwsPdoExceptions($this->phpVersion)) {
-                return $resultType;
-            }
+        if ('fetchAll' === $methodReflection->getName()) {
+            return new ArrayType(new IntegerType(), $resultType);
+        }
 
-            return new UnionType([$resultType, new ConstantBooleanType(false)]);
+        if (QueryReflection::getRuntimeConfiguration()->throwsPdoExceptions($this->phpVersion)) {
+            return $resultType;
         }
 
-        return $defaultReturn;
+        return new UnionType([$resultType, new ConstantBooleanType(false)]);
     }
 }