Drop the restriction on instantiated TypeVars

Drop the restriction that instantiated TypeVars cannot be conversion targets

Author: odersky

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

@@ -456,10 +456,10 @@ object Types extends TypeUtils {
      *  no `implicitConversions` language import is necessary?
      */
     def isConversionTargetType(using Context): Boolean =
-      dealias(KeepTypeVars | KeepOpaques).match
+      dealias(KeepOpaques).match
         case tp: TypeRef =>
           tp.symbol.isClass && tp.symbol.is(Into)
-        case tp @ AppliedType(tycon: TypeRef, _) =>
+        case tp @ AppliedType(tycon, _) =>
           isInto || tycon.isConversionTargetType
         case tp: AndOrType =>
           tp.tp1.isConversionTargetType && tp.tp2.isConversionTargetType
@@ -1503,7 +1503,7 @@ object Types extends TypeUtils {
         val tycon1 = tycon.dealias(keeps)
         if tycon1 ne tycon then app.superType.dealias(keeps)
         else this
-      case tp: TypeVar if (keeps & KeepTypeVars) == 0 =>
+      case tp: TypeVar =>
         val tp1 = tp.instanceOpt
         if tp1.exists then tp1.dealias(keeps) else tp
       case tp: AnnotatedType =>
@@ -7086,7 +7086,6 @@ object Types extends TypeUtils {
   private val KeepAnnots = 1
   private val KeepRefiningAnnots = 2
   private val KeepOpaques = 4
-  private val KeepTypeVars = 8
 
   // ----- Debug ---------------------------------------------------------
 

docs/_docs/reference/experimental/into.md

@@ -156,23 +156,21 @@ possibility that someone might want to add an implicit conversion to it.
 
 ## 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:
+To make the preceding descriptions more precise: An implicit conversion is permitted without an `implicitConversions` language import if the target type is a valid conversion target type. A valid 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.
+ - a type alias of a valid conversion target type,
+ - a match type that reduces to a valid conversion target type,
+ - an annotated type `T @ann` where `T` is a valid conversion target type,
+ - a refined type `T {...}` where `T` is a valid conversion target type,
+ - a union `T | U` of two valid conversion target types `T` and `U`,
+ - an intersection `T & U` of two valid conversion target types `T` and `U`,
+ - an instance of a type parameter that is explicitly instantiated to a valid conversion target type.
 
 
-Inferred type parameters do not count as conversion target types. For instance, consider:
+Type parameters that are not fully instantiated do not count as valid conversion target types. For instance, consider:
 
 ```scala
   trait Token
@@ -184,12 +182,13 @@ Inferred type parameters do not count as conversion target types. For instance,
 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
+  val ys: List[into[Keyword]] = List(ifKW, "then", "else")
 ```
-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
+Here, the type variable of `List.apply` is not explicitly instantiated
+when we check the `List(...)` arguments (it is just upper-bounded by the target 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:
+Subclasses of `into` classes or traits do not count as valid conversion target types. For instance, consider:
 
 ```scala
 into trait T
@@ -203,3 +202,4 @@ g(1)      // 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/neg/into-inferred.check

@@ -0,0 +1,39 @@
+-- [E007] Type Mismatch Error: tests/neg/into-inferred.scala:34:32 -----------------------------------------------------
+34 |  val l1: List[into[Keyword]] = l :+ "then" :+ "else"  // error
+   |                                ^^^^^^^^^^^^^^^^^^^^^
+   |                                Found:    List[Conversion.into[Keyword] | String]
+   |                                Required: List[Conversion.into[Keyword]]
+   |
+   | longer explanation available when compiling with `-explain`
+-- Feature Warning: tests/neg/into-inferred.scala:22:43 ----------------------------------------------------------------
+22 |  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/neg/into-inferred.scala:22:51 ----------------------------------------------------------------
+22 |  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/neg/into-inferred.scala:35:42 ----------------------------------------------------------------
+35 |  val l2: List[into[Keyword]] = l ++ List("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/neg/into-inferred.scala:35:50 ----------------------------------------------------------------
+35 |  val l2: List[into[Keyword]] = l ++ List("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/neg/into-inferred.scala

@@ -0,0 +1,37 @@
+//> 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
+
+  val s = Set(ifKW)
+  val s1 = s + "then" + "else"
+  val _: Set[into[Keyword]] = s1
+  val s2 = s ++ List("then", "else")
+  val s3: Set[into[Keyword] | String] = s2
+  val s4 = s3.map(_.underlying)
+  val _: Set[Keyword | String] = s4
+
+
+  val l = List(ifKW)
+  val l1: List[into[Keyword]] = l :+ "then" :+ "else"  // error
+  val l2: List[into[Keyword]] = l ++ List("then", "else")  // warn // warn
+
+

tests/warn/into-as-mod.scala

@@ -13,3 +13,9 @@ object Test:
   def g(x: C) = ()
   f(1)      // ok
   g(1)      // warn
+
+  into class Keyword(str: String)
+  given stringToKeyword: Conversion[String, Keyword] = Keyword(_)
+
+  val dclKeywords = Set[Keyword]("def", "val") // ok
+  val keywords = dclKeywords + "if" + "then" + "else" // ok

tests/warn/into-inferred.check

@@ -1,5 +1,4 @@
 //> using options  -feature
-
 import language.experimental.into
 import Conversion.{into, underlying}
 
@@ -21,3 +20,17 @@ object Test:
 
   val ifKW: into[Keyword] = "if"
   val ys: List[into[Keyword]] = List(ifKW, "then", "else")         // warn // warn
+
+  val s = Set(ifKW)
+  val s1 = s + "then" + "else"
+  val _: Set[into[Keyword]] = s1
+  val s2 = s ++ List("then", "else")
+  val s3: Set[into[Keyword] | String] = s2
+  val s4 = s3.map(_.underlying)
+  val _: Set[Keyword | String] = s4
+
+  val l = List(ifKW)
+  val l1: List[into[Keyword]] = l :+ "then" :+ "else"  // error
+  val l2: List[into[Keyword]] = l ++ List("then", "else")  // warn // warn
+
+