<form method="POST">
    <h3>Editing: MorphTo.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

namespace Illuminate\Database\Eloquent\Relations;

use BadMethodCallException;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\Concerns\InteractsWithDictionary;

class MorphTo extends BelongsTo
{
    use InteractsWithDictionary;

    /**
     * The type of the polymorphic relation.
     *
     * @var string
     */
    protected $morphType;

    /**
     * The models whose relations are being eager loaded.
     *
     * @var \Illuminate\Database\Eloquent\Collection
     */
    protected $models;

    /**
     * All of the models keyed by ID.
     *
     * @var array
     */
    protected $dictionary = [];

    /**
     * A buffer of dynamic calls to query macros.
     *
     * @var array
     */
    protected $macroBuffer = [];

    /**
     * A map of relations to load for each individual morph type.
     *
     * @var array
     */
    protected $morphableEagerLoads = [];

    /**
     * A map of relationship counts to load for each individual morph type.
     *
     * @var array
     */
    protected $morphableEagerLoadCounts = [];

    /**
     * A map of constraints to apply for each individual morph type.
     *
     * @var array
     */
    protected $morphableConstraints = [];

    /**
     * Create a new morph to relationship instance.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $query
     * @param  \Illuminate\Database\Eloquent\Model  $parent
     * @param  string  $foreignKey
     * @param  string  $ownerKey
     * @param  string  $type
     * @param  string  $relation
     * @return void
     */
    public function __construct(Builder $query, Model $parent, $foreignKey, $ownerKey, $type, $relation)
    {
        $this-&gt;morphType = $type;

        parent::__construct($query, $parent, $foreignKey, $ownerKey, $relation);
    }

    /**
     * Set the constraints for an eager load of the relation.
     *
     * @param  array  $models
     * @return void
     */
    public function addEagerConstraints(array $models)
    {
        $this-&gt;buildDictionary($this-&gt;models = Collection::make($models));
    }

    /**
     * Build a dictionary with the models.
     *
     * @param  \Illuminate\Database\Eloquent\Collection  $models
     * @return void
     */
    protected function buildDictionary(Collection $models)
    {
        foreach ($models as $model) {
            if ($model-&gt;{$this-&gt;morphType}) {
                $morphTypeKey = $this-&gt;getDictionaryKey($model-&gt;{$this-&gt;morphType});
                $foreignKeyKey = $this-&gt;getDictionaryKey($model-&gt;{$this-&gt;foreignKey});

                $this-&gt;dictionary[$morphTypeKey][$foreignKeyKey][] = $model;
            }
        }
    }

    /**
     * Get the results of the relationship.
     *
     * Called via eager load method of Eloquent query builder.
     *
     * @return mixed
     */
    public function getEager()
    {
        foreach (array_keys($this-&gt;dictionary) as $type) {
            $this-&gt;matchToMorphParents($type, $this-&gt;getResultsByType($type));
        }

        return $this-&gt;models;
    }

    /**
     * Get all of the relation results for a type.
     *
     * @param  string  $type
     * @return \Illuminate\Database\Eloquent\Collection
     */
    protected function getResultsByType($type)
    {
        $instance = $this-&gt;createModelByType($type);

        $ownerKey = $this-&gt;ownerKey ?? $instance-&gt;getKeyName();

        $query = $this-&gt;replayMacros($instance-&gt;newQuery())
                            -&gt;mergeConstraintsFrom($this-&gt;getQuery())
                            -&gt;with(array_merge(
                                $this-&gt;getQuery()-&gt;getEagerLoads(),
                                (array) ($this-&gt;morphableEagerLoads[get_class($instance)] ?? [])
                            ))
                            -&gt;withCount(
                                (array) ($this-&gt;morphableEagerLoadCounts[get_class($instance)] ?? [])
                            );

        if ($callback = ($this-&gt;morphableConstraints[get_class($instance)] ?? null)) {
            $callback($query);
        }

        $whereIn = $this-&gt;whereInMethod($instance, $ownerKey);

        return $query-&gt;{$whereIn}(
            $instance-&gt;getTable().'.'.$ownerKey, $this-&gt;gatherKeysByType($type, $instance-&gt;getKeyType())
        )-&gt;get();
    }

    /**
     * Gather all of the foreign keys for a given type.
     *
     * @param  string  $type
     * @param  string  $keyType
     * @return array
     */
    protected function gatherKeysByType($type, $keyType)
    {
        return $keyType !== 'string'
                    ? array_keys($this-&gt;dictionary[$type])
                    : array_map(function ($modelId) {
                        return (string) $modelId;
                    }, array_filter(array_keys($this-&gt;dictionary[$type])));
    }

    /**
     * Create a new model instance by type.
     *
     * @param  string  $type
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function createModelByType($type)
    {
        $class = Model::getActualClassNameForMorph($type);

        return tap(new $class, function ($instance) {
            if (! $instance-&gt;getConnectionName()) {
                $instance-&gt;setConnection($this-&gt;getConnection()-&gt;getName());
            }
        });
    }

    /**
     * Match the eagerly loaded results to their parents.
     *
     * @param  array  $models
     * @param  \Illuminate\Database\Eloquent\Collection  $results
     * @param  string  $relation
     * @return array
     */
    public function match(array $models, Collection $results, $relation)
    {
        return $models;
    }

    /**
     * Match the results for a given type to their parents.
     *
     * @param  string  $type
     * @param  \Illuminate\Database\Eloquent\Collection  $results
     * @return void
     */
    protected function matchToMorphParents($type, Collection $results)
    {
        foreach ($results as $result) {
            $ownerKey = ! is_null($this-&gt;ownerKey) ? $this-&gt;getDictionaryKey($result-&gt;{$this-&gt;ownerKey}) : $result-&gt;getKey();

            if (isset($this-&gt;dictionary[$type][$ownerKey])) {
                foreach ($this-&gt;dictionary[$type][$ownerKey] as $model) {
                    $model-&gt;setRelation($this-&gt;relationName, $result);
                }
            }
        }
    }

    /**
     * Associate the model instance to the given parent.
     *
     * @param  \Illuminate\Database\Eloquent\Model  $model
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function associate($model)
    {
        if ($model instanceof Model) {
            $foreignKey = $this-&gt;ownerKey &amp;&amp; $model-&gt;{$this-&gt;ownerKey}
                            ? $this-&gt;ownerKey
                            : $model-&gt;getKeyName();
        }

        $this-&gt;parent-&gt;setAttribute(
            $this-&gt;foreignKey, $model instanceof Model ? $model-&gt;{$foreignKey} : null
        );

        $this-&gt;parent-&gt;setAttribute(
            $this-&gt;morphType, $model instanceof Model ? $model-&gt;getMorphClass() : null
        );

        return $this-&gt;parent-&gt;setRelation($this-&gt;relationName, $model);
    }

    /**
     * Dissociate previously associated model from the given parent.
     *
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function dissociate()
    {
        $this-&gt;parent-&gt;setAttribute($this-&gt;foreignKey, null);

        $this-&gt;parent-&gt;setAttribute($this-&gt;morphType, null);

        return $this-&gt;parent-&gt;setRelation($this-&gt;relationName, null);
    }

    /**
     * Touch all of the related models for the relationship.
     *
     * @return void
     */
    public function touch()
    {
        if (! is_null($this-&gt;child-&gt;{$this-&gt;foreignKey})) {
            parent::touch();
        }
    }

    /**
     * Make a new related instance for the given model.
     *
     * @param  \Illuminate\Database\Eloquent\Model  $parent
     * @return \Illuminate\Database\Eloquent\Model
     */
    protected function newRelatedInstanceFor(Model $parent)
    {
        return $parent-&gt;{$this-&gt;getRelationName()}()-&gt;getRelated()-&gt;newInstance();
    }

    /**
     * Get the foreign key &quot;type&quot; name.
     *
     * @return string
     */
    public function getMorphType()
    {
        return $this-&gt;morphType;
    }

    /**
     * Get the dictionary used by the relationship.
     *
     * @return array
     */
    public function getDictionary()
    {
        return $this-&gt;dictionary;
    }

    /**
     * Specify which relations to load for a given morph type.
     *
     * @param  array  $with
     * @return \Illuminate\Database\Eloquent\Relations\MorphTo
     */
    public function morphWith(array $with)
    {
        $this-&gt;morphableEagerLoads = array_merge(
            $this-&gt;morphableEagerLoads, $with
        );

        return $this;
    }

    /**
     * Specify which relationship counts to load for a given morph type.
     *
     * @param  array  $withCount
     * @return \Illuminate\Database\Eloquent\Relations\MorphTo
     */
    public function morphWithCount(array $withCount)
    {
        $this-&gt;morphableEagerLoadCounts = array_merge(
            $this-&gt;morphableEagerLoadCounts, $withCount
        );

        return $this;
    }

    /**
     * Specify constraints on the query for a given morph type.
     *
     * @param  array  $callbacks
     * @return \Illuminate\Database\Eloquent\Relations\MorphTo
     */
    public function constrain(array $callbacks)
    {
        $this-&gt;morphableConstraints = array_merge(
            $this-&gt;morphableConstraints, $callbacks
        );

        return $this;
    }

    /**
     * Replay stored macro calls on the actual related instance.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $query
     * @return \Illuminate\Database\Eloquent\Builder
     */
    protected function replayMacros(Builder $query)
    {
        foreach ($this-&gt;macroBuffer as $macro) {
            $query-&gt;{$macro['method']}(...$macro['parameters']);
        }

        return $query;
    }

    /**
     * Handle dynamic method calls to the relationship.
     *
     * @param  string  $method
     * @param  array  $parameters
     * @return mixed
     */
    public function __call($method, $parameters)
    {
        try {
            $result = parent::__call($method, $parameters);

            if (in_array($method, ['select', 'selectRaw', 'selectSub', 'addSelect', 'withoutGlobalScopes'])) {
                $this-&gt;macroBuffer[] = compact('method', 'parameters');
            }

            return $result;
        }

        // If we tried to call a method that does not exist on the parent Builder instance,
        // we'll assume that we want to call a query macro (e.g. withTrashed) that only
        // exists on related models. We will just store the call and replay it later.
        catch (BadMethodCallException $e) {
            $this-&gt;macroBuffer[] = compact('method', 'parameters');

            return $this;
        }
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>