#14982 Make coercions that go through lazy fields more robust

Coercions into lazy fields are currently defined by a kind of universal
property: anything that coerces into parents into which the lazy field coerces
also coerces into the lazy field. Besides, one of the possible classes of lazy
field elements is a wrapper around elements of other exact fields, and the
coercion of such wrappers into other parents simply converts the wrapped
elements. This is a bit fragile, both because there is no way to know for sure
all the parents into which the lazy field coerces, and because that way to
define and apply coercion maps may lead to infinite loops.

This patch makes three changes to mitigate the issue.

1. Test for coercions into all (known) rings into which the lazy field coerces
   instead of just into the associated interval field.

2. Only consider direct (as opposed to composite) coercions.

3. Check that the conversion path does not already goes through the lazy field
   when converting a wrapper.

Author: mezzarobba

src/sage/categories/map.pyx

@@ -591,6 +591,17 @@ cdef class Map(Element):
             s += "\n  Defn: %s"%('\n        '.join(d.split('\n')))
         return s
 
+    def domains(self):
+        """
+        Yield the domain of self. In general, iterate over the domains of
+        the factors of a composite map.
+
+        EXAMPLES::
+            sage: list(QQ.coerce_map_from(ZZ).domains())
+            [Integer Ring]
+        """
+        yield self.domain()
+
     def category_for(self):
         """
         Returns the category self is a morphism for.
@@ -1903,3 +1914,17 @@ cdef class FormalCompositeMap(Map):
         if all(f.is_surjective() for f in without_bij):
             return True
         raise NotImplementedError("Not enough information to deduce surjectivity.")
+
+    def domains(self):
+        """
+        Iterate over the domains of the factors of self.
+
+        EXAMPLES:::
+
+            sage: f = QQ.coerce_map_from(ZZ)
+            sage: g = MatrixSpace(QQ, 2, 2).coerce_map_from(QQ)
+            sage: list((g*f).domains())
+            [Integer Ring, Rational Field]
+        """
+        for f in self.__list:
+            yield f.domain()

src/sage/rings/real_lazy.pyx

@@ -26,7 +26,9 @@ from operator import add, sub, mul, div, pow, neg, inv
 
 cdef canonical_coercion
 from sage.structure.element import canonical_coercion
+from sage.structure.all import parent
 
+import sage.categories.map
 from sage.categories.morphism cimport Morphism
 from sage.rings.ring cimport Field
 import sage.rings.infinity
@@ -112,8 +114,20 @@ cdef class LazyField(Field):
     cpdef _coerce_map_from_(self, R):
         r"""
         The only things that coerce into this ring are exact rings that
-        embed into `\RR` or `\CC` (depending on whether or not this field
-        is real or complex).
+        embed into `\RR` or `\CC` (depending on whether this field
+        is real or complex), that is, exact rings that coerce into all
+        rings into which this ring coerces.
+
+        .. NOTE::
+
+            The rings into which this ring coerces are currently the
+            corresponding floating-point fields (RealField(p) or
+            ComplexField(p)), machine-precision floating-point fields (RDF,
+            CDF), and interval fields (RealIntervalField(p),
+            ComplexIntervalField(p)). This method should be updated if a new
+            parent is added that declares a coercion from RLF/CLF but not from
+            one of these, otherwise coercions of elements of type LazyWrapper
+            into the new ring might fail.
 
         EXAMPLES::
 
@@ -141,8 +155,18 @@ cdef class LazyField(Field):
             if R in [int, long]:
                 from sage.structure.parent import Set_PythonType
                 return LazyWrapperMorphism(Set_PythonType(R), self)
-        elif self.interval_field().has_coerce_map_from(R) and R.is_exact():
-            return LazyWrapperMorphism(R, self)
+        elif R.is_exact():
+            ivf = self.interval_field()
+            mor = ivf.coerce_map_from(R)
+            # Indirect coercions might lead to loops both in the coercion
+            # discovery algorithm and when trying to convert LazyWrappers,
+            # so we only consider direct coercions.
+            if mor is not None and not isinstance(mor, sage.categories.map.FormalCompositeMap):
+                mor = ivf._middle_field().coerce_map_from(R)
+                if mor is not None and not isinstance(mor, sage.categories.map.FormalCompositeMap):
+                    return LazyWrapperMorphism(R, self)
+            # We can skip the test for a coercion to RDF/CDF since RR/CC
+            # already coerce into it.
 
     def algebraic_closure(self):
         """
@@ -1004,7 +1028,14 @@ cdef class LazyWrapper(LazyFieldElement):
             sage: a.eval(ZZ).parent()
             Integer Ring
         """
-        return R(self._value)
+        try:
+            mor = R.convert_map_from(parent(self._value))
+        except AttributeError:
+            return R(self._value)
+        if mor is not None and self.parent() not in mor.domains():
+            return mor(self._value)
+        else:
+            raise TypeError("unable to convert {} to an element of {}".format(self._value, R))
 
     def __reduce__(self):
         """