Disallow inferred into types as implicit conversion target types

Author: odersky

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

@@ -452,6 +452,25 @@ object Types extends TypeUtils {
       case AppliedType(tycon: TypeRef, arg :: Nil) => defn.isInto(tycon.symbol)
       case _ => false
 
+    /** Is this type a legal target type for an implicit conversion, so that
+     *  no `implicitConversions` language import is necessary?
+     */
+    def isConversionTargetType(using Context): Boolean =
+      dealias(KeepTypeVars | KeepOpaques).match
+        case _: AppliedType =>
+          isInto
+        case tp: AndOrType =>
+          tp.tp1.isConversionTargetType && tp.tp2.isConversionTargetType
+        case tp: TypeVar =>
+          false
+        case tp: MatchType =>
+          val tp1 = tp.reduced
+          (tp1 ne tp) && tp1.isConversionTargetType
+        case tp: RefinedType =>
+          tp.parent.isConversionTargetType
+        case _ =>
+          false
+
     /** Is this the type of a method that has a repeated parameter type as
      *  last parameter type?
      */

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -1146,7 +1146,7 @@ trait Checking {
     if sym.name == nme.apply
        && sym.owner.derivesFrom(defn.ConversionClass)
        && !sym.info.isErroneous
-       && !expected.isInto
+       && !expected.isConversionTargetType
     then
       def conv = methPart(tree) match
         case Select(qual, _) => qual.symbol.orElse(sym.owner)

docs/_docs/reference/experimental/into.md

@@ -18,7 +18,7 @@ import scala.language.implicitConversions
 in any code that uses them as implicit conversions (code that calls conversions explicitly is not affected). If the import is missing, a feature warning is currently issued, and this will become an error in future versions of Scala 3. The motivation for this restriction is two-fold:
 
  - Code with hidden implicit conversions is hard to understand and might have correctness or performance issues that go undetected.
- - If we require explicit user-opt in for implicit conversions, we can significantly improve type inference by propagating expected type information more widely in those parts of the program where there is no opt-in.
+ - If we require explicit user opt-in for implicit conversions, we can significantly improve type inference by propagating expected type information more widely in those parts of the program where there is no opt-in.
 
 There is one broad use case, however, where implicit conversions are very hard to replace. This is the case where an implicit conversion is used to adapt a method argument to its formal parameter type. An example from the standard library:
 ```scala
@@ -132,5 +132,52 @@ type Modifier = into[ModifierClass]
 ```
 The into-erasure for function parameters also works in aliased types. So a function defining parameters of `Modifier` type can use them internally as if they were from the underlying `ModifierClass`.
 
-## Alternatives
+## Details: Conversion target types
 
+The description so far said that conversions are allowed if the target type
+
+A conversion target type is one of the following:
+
+ - a type of the form `into[T]`,
+ - a reference `p.C` to a class or trait `C` that is declared with an `into` modifier,
+   which can also be followed by type arguments,
+ - a type alias of a conversion target type,
+ - a match type that reduces to a conversion target type,
+ - an annotated type `T @ann` where `T` is a conversion target type,
+ - a refined type `T {...}` where `T` is a conversion target type,
+ - a union `T | U` if two conversion target types `T` and `U`,
+ - an intersection `T & U` if two conversion target types `T` and `U`,
+ - an instance of a type parameter that is explicitly instantiated to a conversion target type.
+
+
+Inferred type parameters do not count as conversion target types. For instance, consider:
+
+```scala
+  trait Token
+  class Keyword(str: String)
+  given Conversion[String, Keyword] = KeyWord(_)
+
+  List[into[Keyword]]("if", "then", "else")
+```
+This type-checks since the target type of the list elements is the type parameter of the `List.apply` method which is explicitly instantiated to `into[Keyword]`. On the other hand, if we continue the example as follows we get an error:
+```scala
+  val ifKW: into[Keyword] = "if"
+  List(ifKW, "then", "else")         // error
+```
+Here, the type variable of `List.apply` is not explicitly instantiated, but is inferred to have type `into[Keyword]`. This is not enough to allow
+implicit conversions on the second and third arguments.
+
+Subclasses of `into` classes or traits do not count as conversion target types. For instance, consider:
+
+```scala
+into trait T
+class C(x: Int) extends T
+given Conversion[Int, C] = C(_)
+
+def f(x: T) = ()
+def g(x: C) = ()
+f("abc")      // ok
+g("abc")      // error
+```
+The call `f("abc")` type-checks since `f`'s parameter type `T` is `into`.
+But the call `g("abc")` does not type-check since `g`'s parameter type `C` is not `into`. It does not matter that `C` extends a trait `T` that is `into`.

tests/warn/into-inferred.check

@@ -0,0 +1,16 @@
+-- Feature Warning: tests/warn/into-inferred.scala:23:43 ---------------------------------------------------------------
+23 |  val ys: List[into[Keyword]] = List(ifKW, "then", "else")         // warn // warn
+   |                                           ^^^^^^
+   |      Use of implicit conversion given instance given_Conversion_String_Keyword in object Test should be enabled
+   |      by adding the import clause 'import scala.language.implicitConversions'
+   |      or by setting the compiler option -language:implicitConversions.
+   |      See the Scala docs for value scala.language.implicitConversions for a discussion
+   |      why the feature should be explicitly enabled.
+-- Feature Warning: tests/warn/into-inferred.scala:23:51 ---------------------------------------------------------------
+23 |  val ys: List[into[Keyword]] = List(ifKW, "then", "else")         // warn // warn
+   |                                                   ^^^^^^
+   |      Use of implicit conversion given instance given_Conversion_String_Keyword in object Test should be enabled
+   |      by adding the import clause 'import scala.language.implicitConversions'
+   |      or by setting the compiler option -language:implicitConversions.
+   |      See the Scala docs for value scala.language.implicitConversions for a discussion
+   |      why the feature should be explicitly enabled.

tests/warn/into-inferred.scala

@@ -0,0 +1,23 @@
+//> using options  -feature
+
+import language.experimental.into
+import Conversion.{into, underlying}
+
+trait Token
+class Keyword(str: String)
+case class Phrase(words: into[Keyword]*)
+
+object Test:
+  given Conversion[String, Keyword] = Keyword(_)
+
+  val xs = List[into[Keyword]]("if", "then", "else") // ok
+  val _: List[Keyword] = xs.map(_.underlying)
+
+  val p = Phrase("if", "then", "else") // ok
+  val ws = p.words
+  val _: Seq[Keyword] = ws
+
+  val p2 = Phrase(xs*) // ok
+
+  val ifKW: into[Keyword] = "if"
+  val ys: List[into[Keyword]] = List(ifKW, "then", "else")         // warn // warn