fix: use Scope to get type of arg in AppMakeHelper

src/ReturnTypes/AppMakeDynamicReturnTypeExtension.php

@@ -30,6 +30,6 @@ public function isStaticMethodSupported(MethodReflection $methodReflection): boo
 
     public function getTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, Scope $scope): ?Type
     {
-        return $this->appMakeHelper->resolveTypeFromCall($methodCall);
+        return $this->appMakeHelper->resolveTypeFromCall($methodCall, $scope);
     }
 }

src/ReturnTypes/AppMakeHelper.php

@@ -3,48 +3,52 @@
 namespace NunoMaduro\Larastan\ReturnTypes;
 
 use NunoMaduro\Larastan\Concerns\HasContainer;
-use PhpParser\Node\Expr\ClassConstFetch;
 use PhpParser\Node\Expr\FuncCall;
 use PhpParser\Node\Expr\MethodCall;
 use PhpParser\Node\Expr\StaticCall;
-use PhpParser\Node\Name\FullyQualified;
-use PhpParser\Node\Scalar\String_;
+use PHPStan\Analyser\Scope;
 use PHPStan\Type\ErrorType;
-use PHPStan\Type\NeverType;
+use PHPStan\Type\MixedType;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
 use Throwable;
 
 final class AppMakeHelper
 {
     use HasContainer;
 
-    public function resolveTypeFromCall(FuncCall|MethodCall|StaticCall $call): Type
+    public function resolveTypeFromCall(FuncCall|MethodCall|StaticCall $call, Scope $scope): Type
     {
-        if (count($call->getArgs()) === 0) {
+        $args = $call->getArgs();
+        if (count($args) === 0) {
             return new ErrorType();
         }
 
-        $expr = $call->getArgs()[0]->value;
-        if ($expr instanceof String_) {
-            try {
-                /** @var object|null $resolved */
-                $resolved = $this->resolve($expr->value);
+        $argType = $scope->getType($args[0]->value);
 
-                if ($resolved === null) {
+        $constantStrings = $argType->getConstantStrings();
+
+        if (count($constantStrings) > 0) {
+            $types = [];
+            foreach ($constantStrings as $constantString) {
+                try {
+                    /** @var object|null $resolved */
+                    $resolved = $this->resolve($constantString->getValue());
+
+                    if ($resolved === null) {
+                        return new ErrorType();
+                    }
+
+                    $types[] = new ObjectType(get_class($resolved));
+                } catch (Throwable $exception) {
                     return new ErrorType();
                 }
-
-                return new ObjectType(get_class($resolved));
-            } catch (Throwable $exception) {
-                return new ErrorType();
             }
-        }
 
-        if ($expr instanceof ClassConstFetch && $expr->class instanceof FullyQualified) {
-            return new ObjectType($expr->class->toString());
+            return count($types) === 1 ? $types[0] : TypeCombinator::union(...$types);
         }
 
-        return new NeverType();
+        return new MixedType();
     }
 }

src/ReturnTypes/ApplicationMakeDynamicReturnTypeExtension.php

@@ -30,6 +30,6 @@ public function isMethodSupported(MethodReflection $methodReflection): bool
 
     public function getTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, Scope $scope): ?Type
     {
-        return $this->appMakeHelper->resolveTypeFromCall($methodCall);
+        return $this->appMakeHelper->resolveTypeFromCall($methodCall, $scope);
     }
 }

src/ReturnTypes/ContainerMakeDynamicReturnTypeExtension.php

@@ -30,6 +30,6 @@ public function isMethodSupported(MethodReflection $methodReflection): bool
 
     public function getTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, Scope $scope): ?Type
     {
-        return $this->appMakeHelper->resolveTypeFromCall($methodCall);
+        return $this->appMakeHelper->resolveTypeFromCall($methodCall, $scope);
     }
 }

src/ReturnTypes/Helpers/AppExtension.php

@@ -34,6 +34,6 @@ public function getTypeFromFunctionCall(
             return new ObjectType(Application::class);
         }
 
-        return $this->appMakeHelper->resolveTypeFromCall($functionCall);
+        return $this->appMakeHelper->resolveTypeFromCall($functionCall, $scope);
     }
 }

tests/Type/data/application-make.php

@@ -3,14 +3,24 @@
 namespace ApplicationMake;
 
 use Illuminate\Contracts\Config\Repository;
+use Illuminate\Database\Eloquent\Model;
 use function PHPStan\Testing\assertType;
 
-/** @var \Illuminate\Foundation\Application $app */
-assertType('Illuminate\Contracts\Config\Repository', $app->make(Repository::class));
-assertType('Illuminate\Contracts\Config\Repository', $app->makeWith(Repository::class));
-assertType('Illuminate\Contracts\Config\Repository', $app->resolve(Repository::class));
+function doFoo(\Illuminate\Foundation\Application $app, \Illuminate\Contracts\Foundation\Application $app2)
+{
+    assertType('Illuminate\Config\Repository', $app->make(Repository::class));
+    assertType('Illuminate\Config\Repository', $app->makeWith(Repository::class));
+    assertType('Illuminate\Config\Repository', $app->resolve(Repository::class));
 
-/** @var \Illuminate\Contracts\Foundation\Application $app */
-assertType('Illuminate\Contracts\Config\Repository', $app->make(Repository::class));
-assertType('Illuminate\Contracts\Config\Repository', $app->makeWith(Repository::class));
-assertType('Illuminate\Contracts\Config\Repository', $app->resolve(Repository::class));
+    assertType('Illuminate\Config\Repository', $app2->make(Repository::class));
+    assertType('Illuminate\Config\Repository', $app2->makeWith(Repository::class));
+    assertType('Illuminate\Config\Repository', $app2->resolve(Repository::class));
+}
+
+/** @param class-string<Model> $foo */
+function doBar(string $foo, \Illuminate\Foundation\Application $app)
+{
+    assertType('mixed', $app->make($foo));
+    assertType('mixed', $app->makeWith($foo));
+    assertType('mixed', $app->resolve($foo));
+}

tests/Type/data/container-make.php

@@ -3,14 +3,24 @@
 namespace ContainerMake;
 
 use Illuminate\Contracts\Config\Repository;
+use Illuminate\Database\Eloquent\Model;
 use function PHPStan\Testing\assertType;
 
-/** @var \Illuminate\Container\Container $container */
-assertType('Illuminate\Contracts\Config\Repository', $container->make(Repository::class));
-assertType('Illuminate\Contracts\Config\Repository', $container->makeWith(Repository::class));
-assertType('Illuminate\Contracts\Config\Repository', $container->resolve(Repository::class));
+function doFoo(\Illuminate\Container\Container $container, \Illuminate\Contracts\Container\Container $container2)
+{
+    assertType('Illuminate\Config\Repository', $container->make(Repository::class));
+    assertType('Illuminate\Config\Repository', $container->makeWith(Repository::class));
+    assertType('Illuminate\Config\Repository', $container->resolve(Repository::class));
 
-/** @var \Illuminate\Contracts\Container\Container $container */
-assertType('Illuminate\Contracts\Config\Repository', $container->make(Repository::class));
-assertType('Illuminate\Contracts\Config\Repository', $container->makeWith(Repository::class));
-assertType('Illuminate\Contracts\Config\Repository', $container->resolve(Repository::class));
+    assertType('Illuminate\Config\Repository', $container2->make(Repository::class));
+    assertType('Illuminate\Config\Repository', $container2->makeWith(Repository::class));
+    assertType('Illuminate\Config\Repository', $container2->resolve(Repository::class));
+}
+
+/** @param class-string<Model> $foo */
+function doBar(string $foo, \Illuminate\Contracts\Container\Container $container)
+{
+    assertType('mixed', $container->make($foo));
+    assertType('mixed', $container->makeWith($foo));
+    assertType('mixed', $container->resolve($foo));
+}