Fix: Skip Attribute accessor invocation for non-arrayable attributes (#55067)

This change ensures that Attribute-based get mutators are only invoked
during serialization when the attribute is actually arrayable. Hidden and non-visible Attribute accessors are no longer invoked during serialization. `attributesToArray()` now only processes mutators for attributes that are actually arrayable (visible and not hidden).

This resolves an issue where hidden Attribute accessors could run
unexpectedly during serialization, potentially causing unnecessary work
or exceptions when accessing unloaded relationships.

Key changes:
- Added `getArrayableMutatedAttributes()` to filter mutated attributes
  based on arrayable keys
- Reverted to original `getAttributeMarkedMutatorMethods()` to avoid
  breaking changes
- Added regression test verifying hidden Attribute accessors are not
  invoked during serialization

Resolves #55067

Author: elliota43

src/Illuminate/Database/Eloquent/Concerns/HasAttributes.php

@@ -682,25 +682,15 @@ public function hasAttributeMutator($key)
      */
     public function hasAttributeGetMutator($key)
     {
-        $class = get_class($this);
-
-        if (array_key_exists($key, static::$getAttributeMutatorCache[$class] ?? [])) {
-            return static::$getAttributeMutatorCache[$class][$key];
+        if (isset(static::$getAttributeMutatorCache[get_class($this)][$key])) {
+            return static::$getAttributeMutatorCache[get_class($this)][$key];
         }
 
-        // First, ensure there's actually an Attribute-returning method
         if (! $this->hasAttributeMutator($key)) {
-            return static::$getAttributeMutatorCache[$class][$key] = false;
+            return static::$getAttributeMutatorCache[get_class($this)][$key] = false;
         }
 
-        // Lazy evaluation: only now do we resolve and inspect the Attribute
-        try {
-            $attribute = $this->{Str::camel($key)}();
-
-            return static::$getAttributeMutatorCache[$class][$key] = is_callable($attribute->get);
-        } catch (\Throwable $e) {
-            return static::$getAttributeMutatorCache[$class][$key] = false;
-        }
+        return static::$getAttributeMutatorCache[get_class($this)][$key] = is_callable($this->{Str::camel($key)}()->get);
     }
 
     /**
@@ -765,14 +755,14 @@ protected function mutateAttributeForArray($key, $value)
     {
         if ($this->isClassCastable($key)) {
             $value = $this->getClassCastableAttributeValue($key, $value);
-        } elseif ($this->hasAttributeGetMutator($key)) {
-            // Attribute::make(get: ...)
+        } elseif (isset(static::$getAttributeMutatorCache[get_class($this)][$key]) &&
+                  static::$getAttributeMutatorCache[get_class($this)][$key] === true) {
             $value = $this->mutateAttributeMarkedAttribute($key, $value);
 
-            if ($value instanceof DateTimeInterface) {
-                $value = $this->serializeDate($value);
-            }
-        } elseif ($this->hasGetMutator($key)) {
+            $value = $value instanceof DateTimeInterface
+                ? $this->serializeDate($value)
+                : $value;
+        } else {
             $value = $this->mutateAttribute($key, $value);
         }
 
@@ -2476,16 +2466,9 @@ public static function cacheMutatedAttributes($classOrInstance)
 
         $class = $reflection->getName();
 
-        // Get Attribute return type methods without invoking them (lazy caching)
-        $attributeMutatorMethods = static::getAttributeMarkedMutatorMethods($classOrInstance);
-
-        // Initialize cache with method names but don't set to true yet
-        // This allows us to know which methods might be Attribute mutators
-        // without invoking them. The actual 'get' callable check happens lazily
-        // in hasAttributeGetMutator() when the attribute is actually accessed.
-        static::$getAttributeMutatorCache[$class] = (new Collection($attributeMutatorMethods))
+        static::$getAttributeMutatorCache[$class] = (new Collection($attributeMutatorMethods = static::getAttributeMarkedMutatorMethods($classOrInstance)))
             ->mapWithKeys(fn ($match) => [
-                lcfirst(static::$snakeAttributes ? Str::snake($match) : $match) => null,
+                lcfirst(static::$snakeAttributes ? Str::snake($match) : $match) => true,
             ])
             ->all();
 
@@ -2518,9 +2501,19 @@ protected static function getAttributeMarkedMutatorMethods($class)
     {
         $instance = is_object($class) ? $class : new $class;
 
-        return (new Collection((new ReflectionClass($instance))->getMethods()))
-            ->filter(fn ($method) => $method->getReturnType() instanceof ReflectionNamedType &&
-                $method->getReturnType()->getName() === Attribute::class)
-            ->map->name->values()->all();
+        return (new Collection((new ReflectionClass($instance))->getMethods()))->filter(function ($method) use ($instance) {
+            $returnType = $method->getReturnType();
+
+            if ($returnType instanceof ReflectionNamedType &&
+                $returnType->getName() === Attribute::class) {
+                if (is_callable($method->invoke($instance)->get)) {
+                    return true;
+                }
+            }
+
+            return false;
+        })->map->name->values()->all();
     }
+
+
 }

tests/Database/DatabaseEloquentModelTest.php

@@ -3663,6 +3663,27 @@ protected function foo(): Attribute
         // Should not crash and should still include the "foo" attribute.
         $this->assertArrayHasKey('foo', $array);
     }
+
+    public function testHiddenAttributeAccessorIsNotInvokedDuringSerialization()
+    {
+        $model = new class extends Model
+        {
+            protected $hidden = ['dangerous'];
+
+            protected function dangerous(): Attribute
+            {
+                return Attribute::make(
+                    get: function () {
+                        throw new \RuntimeException('Hidden attribute accessor should not be invoked');
+                    }
+                );
+            }
+        };
+
+        $array = $model->toArray();
+
+        $this->assertArrayNotHasKey('dangerous', $array);
+    }
 }
 
 class CustomBuilder extends Builder