[13.x] Model trait initializers collide with Attribute parsing

[Propaganistas]

Laravel Version

13.2.0

PHP Version

8.5.2

Database Driver & Version

No response

Description

When using the following trait:

trait SomeTrait
{
    protected function initializeSomeTrait()
    {
        $this->mergeAppends(['url']);
    }
}

on the following model:

#[Appends(['name'])]
class MyModel extends Model
{
    use SomeTrait;
}

The final appendable attributes are set to ['url'], even though mergeAppends() was used in the trait's initialize method. The same applies for calling mergeHidden(), mergeVisible(), mergeFillable() and mergeGuarded() in a trait initializer.

This used to work fine in Laravel 12 and below, but breaks with the current parsing implementation of Attributes. Could this be an unanticipated breaking change?

---

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

Lines 217 to 219 in 7106836

	if (empty($this->appends)) {
	$this->appends = static::resolveClassAttribute(Appends::class, 'columns') ?? [];
	}

I've tried to remove the conditional and apply mergeAppends() here as well. That works. But when doing the same trick for fillable and guarded properties things are becoming complicated (there's a fillable precedence rule, and guarded has additional * logic). I've even considered to have all framework traits initialize before anything else, but again the guarded logic is pesky.

So I'm raising it here instead.

Steps To Reproduce

#[Appends(['name'])
class TestModel extends Model
{
    use TestTrait;
}

trait TestTrait
{
    protected function initializeTestTrait()
    {
        $this->mergeAppends(['email']);
    }
}

public function test_it()
{
    $model = new TestModel;

    $this->assertEqualsCanonicalizing(['name', 'email'], $model->getAppends()); // Currently fails.
}

[sadique-cws]

[13.x] Fix trait initializer collision with Attribute parsing

Fixes #59381

Problem

When a model uses both a PHP Attribute (e.g. #[Appends(['name'])]) and a trait that calls merge*() in its initializer (e.g. $this->mergeAppends(['url'])), the trait's values get silently dropped. The final result only contains the Attribute values—or worse, only the trait's values—depending on execution order.

#[Appends(['name'])]
class MyModel extends Model
{
    use SomeTrait;
}

trait SomeTrait
{
    protected function initializeSomeTrait()
    {
        $this->mergeAppends(['url']);
    }
}

$model = new MyModel;
$model->getAppends(); // ❌ Returns ['url'] — 'name' is missing!

Root Cause

The framework's trait initializers (initializeHasAttributes, initializeHidesAttributes, initializeGuardsAttributes) used if (empty($this->property)) guards before assigning from PHP Attributes:

if (empty($this->appends)) {
    $this->appends = static::resolveClassAttribute(Appends::class, 'columns') ?? [];
}

When a user's trait initializer runs first and populates the property via merge*(), the empty() check sees a non-empty value and skips the Attribute entirely — silently dropping its values.

Solution

Replace the guarded assignment pattern with the corresponding merge*() method:

$this->mergeAppends(static::resolveClassAttribute(Appends::class, 'columns') ?? []);

This ensures values from both sources are always combined, regardless of initializer execution order.

Files Changed

File	Change
HasAttributes.php	appends: guarded assign → mergeAppends()
HidesAttributes.php	hidden/visible: guarded assign → mergeHidden()/mergeVisible()
GuardsAttributes.php	fillable: guarded assign → mergeFillable()

Note: The guarded property is left unchanged because its ['*'] default sentinel value has special "totally guarded" semantics that require the existing conditional logic.

Tests

Added 4 new test cases in DatabaseEloquentModelAttributesTest.php that verify trait initializer values are correctly merged with PHP Attribute values for appends, hidden, visible, and fillable.

Updated 1 existing test (test_fillable_property_merges_with_attribute) to reflect that property values and Attribute values are now merged rather than the property silently overriding.