[12.x] Fix usage of Scoped and Singleton on interfaces (#56620)

* failing test

* Update Container.php

* fix container binding

* style

* remove unnecessary coalescence

* remove unnecessary

* formatting

---------

Co-authored-by: Taylor Otwell <[email protected]>

Author: cosmastech

src/Illuminate/Container/Container.php

@@ -281,21 +281,36 @@ public function isShared($abstract)
             return false;
         }
 
-        $reflection = new ReflectionClass($abstract);
-
-        if (! empty($reflection->getAttributes(Singleton::class))) {
-            return true;
+        if (($scopedType = $this->getScopedTyped(new ReflectionClass($abstract))) === null) {
+            return false;
         }
 
-        if (! empty($reflection->getAttributes(Scoped::class))) {
+        if ($scopedType === 'scoped') {
             if (! in_array($abstract, $this->scopedInstances, true)) {
                 $this->scopedInstances[] = $abstract;
             }
+        }
 
-            return true;
+        return true;
+    }
+
+    /**
+     * Determine if a ReflectionClass has scoping attributes applied.
+     *
+     * @param  ReflectionClass<object>  $reflection
+     * @return "singleton"|"scoped"|null
+     */
+    protected function getScopedTyped(ReflectionClass $reflection): ?string
+    {
+        if (! empty($reflection->getAttributes(Singleton::class))) {
+            return 'singleton';
         }
 
-        return false;
+        if (! empty($reflection->getAttributes(Scoped::class))) {
+            return 'scoped';
+        }
+
+        return null;
     }
 
     /**
@@ -983,34 +998,34 @@ protected function getConcrete($abstract)
             return $abstract;
         }
 
-        $attributes = [];
-
-        try {
-            $attributes = (new ReflectionClass($abstract))->getAttributes(Bind::class);
-        } catch (ReflectionException) {
-        }
-
-        $this->checkedForAttributeBindings[$abstract] = true;
-
-        if ($attributes === []) {
-            return $abstract;
-        }
-
-        return $this->getConcreteBindingFromAttributes($abstract, $attributes);
+        return $this->getConcreteBindingFromAttributes($abstract);
     }
 
     /**
      * Get the concrete binding for an abstract from the Bind attribute.
      *
      * @param  string  $abstract
-     * @param  array<int, \ReflectionAttribute<Bind>>  $reflectedAttributes
      * @return mixed
      */
-    protected function getConcreteBindingFromAttributes($abstract, $reflectedAttributes)
+    protected function getConcreteBindingFromAttributes($abstract)
     {
+        $this->checkedForAttributeBindings[$abstract] = true;
+
+        try {
+            $reflected = new ReflectionClass($abstract);
+        } catch (ReflectionException) {
+            return $abstract;
+        }
+
+        $bindAttributes = $reflected->getAttributes(Bind::class);
+
+        if ($bindAttributes === []) {
+            return $abstract;
+        }
+
         $concrete = $maybeConcrete = null;
 
-        foreach ($reflectedAttributes as $reflectedAttribute) {
+        foreach ($bindAttributes as $reflectedAttribute) {
             $instance = $reflectedAttribute->newInstance();
 
             if ($instance->environments === ['*']) {
@@ -1034,7 +1049,11 @@ protected function getConcreteBindingFromAttributes($abstract, $reflectedAttribu
             return $abstract;
         }
 
-        $this->bind($abstract, $concrete);
+        match ($this->getScopedTyped($reflected)) {
+            'scoped' => $this->scoped($abstract, $concrete),
+            'singleton' => $this->singleton($abstract, $concrete),
+            null => $this->bind($abstract, $concrete),
+        };
 
         return $this->bindings[$abstract]['concrete'];
     }

tests/Container/ContainerTest.php

@@ -875,6 +875,30 @@ public function testNoMatchingEnvironmentAndNoWildcardThrowsBindingResolutionExc
         $container->make(ProdEnvOnlyInterface::class);
     }
 
+    public function testScopedSingletonWithBind()
+    {
+        $container = new Container;
+        $container->resolveEnvironmentUsing(fn ($environments) => true);
+
+        $original = $container->make(IsScoped::class);
+        $new = $container->make(IsScoped::class);
+
+        $this->assertSame($original, $new);
+        $container->forgetScopedInstances();
+        $this->assertNotSame($original, $container->make(IsScoped::class));
+    }
+
+    public function testSingletonWithBind()
+    {
+        $container = new Container;
+        $container->resolveEnvironmentUsing(fn ($environments) => true);
+
+        $original = $container->make(IsSingleton::class);
+        $new = $container->make(IsSingleton::class);
+
+        $this->assertSame($original, $new);
+    }
+
     // public function testContainerCanCatchCircularDependency()
     // {
     //     $this->expectException(\Illuminate\Contracts\Container\CircularDependencyException::class);
@@ -1131,3 +1155,19 @@ class OriginalConcrete implements OverrideInterface
 class AltConcrete implements OverrideInterface
 {
 }
+
+#[Bind(IsScopedConcrete::class)]
+#[Scoped]
+interface IsScoped
+{
+}
+
+class IsScopedConcrete implements IsScoped
+{
+}
+
+#[Bind(IsScopedConcrete::class)]
+#[Singleton]
+interface IsSingleton
+{
+}