Erase all covariant and invariant into occurrences

Erase all covariant and invariant into occurrences in parameter types

Author: odersky

compiler/src/dotty/tools/dotc/core/TypeOps.scala

@@ -939,25 +939,25 @@ object TypeOps:
 
   /** Map no-flip covariant occurrences of `into[T]` to `T @$into` */
   def suppressInto(using Context) = new FollowAliasesMap:
-    def apply(t: Type): Type =
-      if variance <= 0 then t
-      else t match
-        case AppliedType(tycon: TypeRef, arg :: Nil) if defn.isInto(tycon.symbol) =>
-          AnnotatedType(arg, Annotation(defn.SilentIntoAnnot, util.Spans.NoSpan))
-        case _ =>
-          mapFollowingAliases(t)
+    def apply(t: Type): Type = t match
+      case AppliedType(tycon: TypeRef, arg :: Nil) if variance >= 0 && defn.isInto(tycon.symbol) =>
+        AnnotatedType(arg, Annotation(defn.SilentIntoAnnot, util.Spans.NoSpan))
+      case _: MatchType | _: LazyRef =>
+        t
+      case _ =>
+        mapFollowingAliases(t)
 
   /** Map no-flip covariant occurrences of `T @$into` to `into[T]` */
   def revealInto(using Context) = new FollowAliasesMap:
-    def apply(t: Type): Type =
-      if variance <= 0 then t
-      else t match
-        case AnnotatedType(t1, ann) if ann.symbol == defn.SilentIntoAnnot =>
-          AppliedType(
-            defn.ConversionModule.termRef.select(defn.Conversion_into), // the external reference to the opaque type
-            t1 :: Nil)
-        case _ =>
-          mapFollowingAliases(t)
+    def apply(t: Type): Type = t match
+      case AnnotatedType(t1, ann) if variance >= 0 && ann.symbol == defn.SilentIntoAnnot =>
+        AppliedType(
+          defn.ConversionModule.termRef.select(defn.Conversion_into), // the external reference to the opaque type
+          t1 :: Nil)
+      case _: MatchType | _: LazyRef =>
+        t
+      case _ =>
+        mapFollowingAliases(t)
 
   /** Apply [[Type.stripTypeVar]] recursively. */
   def stripTypeVars(tp: Type)(using Context): Type =

docs/_docs/reference/experimental/into.md

@@ -121,7 +121,8 @@ as they are seen in a method body. Here is an example:
 ```
 Inside the `++` method, the `elems` parameter is of type `IterableOnce[A]`, not `into[IterableOne[A]]`. Hence, we can simply write `elems.iterator` to get at the `iterator` method of the `IterableOnce` class.
 
-Specifically (meaning in spec-language): We erase all `into` wrappers in the local types of parameter types, on the top-level of these types as well as in all _top-level covariant_ subparts. Here, a part `S` of a type `T` is top-level covariant it is not enclosed in some type that appears in contra-variant or invariant position in `T`.
+Specifically, we erase all `into` wrappers in the local types of parameter types that appear in covariant or invariant position. Contravariant `into` wrappers are kept since these typically are on the parameters of function arguments.
+
 
 ## Into in Aliases