1. `copy_cache` in `models.py` recursively copies the caches to environment, 
2. which in
```python
def _compute_related(self, records):
        """ Compute the related field ``self`` on ``records``. """
        others = records.sudo() if self.related_sudo else records
        if records.env != others.env:
            copy_cache(records - records.filtered('id'), others.env)
        values = list(others)
        for name in self.related[:-1]:
            values = [first(value[name]) for value in values]
        for record, value in zip(records, values):
            record[self.name] = value[self.related_field.name]
```
3. copies failing cache values that have been produce previously by this line:

`models.py : def _prefetch_field()`
```python

        try:
            # THIS ONE
            result = records.read([f.name for f in fs], load='_classic_write')
        except AccessError:
            # not all records may be accessible, try with only current record
            result = self.read([f.name for f in fs], load='_classic_write')
```
I checked it's exactly the same `FailedValue` object, which is later accessed without intent (not refreshed) by the fact that the buggy environment is copied to sudo (and not refreshed).


odoo/fields.py
apply the necessary changes on the field dependencies such that the
        computation gives the expected value. Note that a computed field without
        an inverse method is readonly by default.
        The search method is invoked when processing domains before doing an
        actual search on the model. It must return a domain equivalent to the
        condition: ``field operator value``.
        .. _field-related:
        .. rubric:: Related fields
        The value of a related field is given by following a sequence of
        relational fields and reading a field on the reached model. The complete
        sequence of fields to traverse is specified by the attribute
        :param related: sequence of field names
        Some field attributes are automatically copied from the source field if
        they are not redefined: ``string``, ``help``, ``readonly``, ``required`` (only
        if all fields in the sequence are required), ``groups``, ``digits``, ``size``,
        ``translate``, ``sanitize``, ``selection``, ``comodel_name``, ``domain``,
        ``context``. All semantic-free attributes are copied from the source
        field.
        By default, the values of related fields are not stored to the database.
        Add the attribute ``store=True`` to make it stored, just like computed
        fields. Related fields are automatically recomputed when their
        dependencies are modified.
        .. _field-company-dependent:
        .. rubric:: Company-dependent fields
        Formerly known as 'property' fields, the value of those fields depends
        on the company. In other words, users that belong to different companies
        may see different values for the field on a given record.
        :param company_dependent: whether the field is company-dependent (boolean)
        .. _field-sparse:
        .. rubric:: Sparse fields