Allow into on opaque type aliases

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -652,6 +652,8 @@ object desugar {
         tdef, evidenceBuf,
         (tdef.mods.flags.toTermFlags & AccessFlags) | Lazy | DeferredGivenFlags,
         inventGivenName, Nil)
+    if tdef.mods.flags.is(Into, butNot = Opaque) then
+      report.error(ModifierNotAllowedForDefinition(Into), flagSourcePos(tdef, Into))
     if evidenceBuf.isEmpty then result else Thicket(result :: evidenceBuf.toList)
 
   /** The expansion of a class definition. See inline comments for what is involved */

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -9,6 +9,7 @@ import Annotations.Annotation
 import NameKinds.ContextBoundParamName
 import typer.ConstFold
 import reporting.trace
+import util.SrcPos
 
 import Decorators.*
 import Constants.Constant
@@ -522,6 +523,10 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
       if id.span == result.span.startPos => Some(result)
       case _ => None
   end ImpureByNameTypeTree
+
+  /** The position of the modifier associated with given flag in this definition. */
+  def flagSourcePos(mdef: DefTree, flag: FlagSet): SrcPos =
+    mdef.mods.mods.find(_.flags == flag).getOrElse(mdef).srcPos
 }
 
 trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>

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

@@ -547,7 +547,7 @@ object Flags {
   val RetainedExportTypeFlags = Infix
 
   /** Flags that apply only to classes */
-  val ClassOnlyFlags = Sealed | Open | Into | Abstract.toTypeFlags
+  val ClassOnlyFlags = Sealed | Open | Abstract.toTypeFlags
 
 // ------- Other flag sets -------------------------------------
 

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

@@ -458,7 +458,7 @@ object Types extends TypeUtils {
     def isConversionTargetType(using Context): Boolean =
       dealias(KeepOpaques).match
         case tp: TypeRef =>
-          tp.symbol.isClass && tp.symbol.is(Into)
+          (tp.symbol.isClass || tp.symbol.isOpaqueAlias) && tp.symbol.is(Into)
         case tp @ AppliedType(tycon, _) =>
           isInto || tycon.isConversionTargetType
         case tp: AndOrType =>

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

@@ -631,8 +631,7 @@ object Checking {
    */
   def checkWellFormedModule(mdef: untpd.ModuleDef)(using Context) =
     val mods = mdef.mods
-    def flagSourcePos(flag: FlagSet) =
-      mods.mods.find(_.flags == flag).getOrElse(mdef).srcPos
+    def flagSourcePos(flag: Flag) = untpd.flagSourcePos(mdef, flag)
     if mods.is(Open) then
       report.error(ModifierNotAllowedForDefinition(Open), flagSourcePos(Open))
     if mods.is(Into) then

docs/_docs/reference/experimental/into.md

@@ -20,7 +20,7 @@ class without requiring a language import.
 The first scheme is
 to have a special type `into[T]` which serves as a marker that conversions into that type are allowed. These types are typically used in parameters of methods that are designed to work with implicit conversions of their arguments. This allows fine-grained control over where implicit conversions should be allowed. We call this scheme "_into as a type constructor_".
 
-The second scheme allows `into` as a soft modifier on traits and classes. If a trait or class is declared with this modifier, conversions to that type are allowed. The second scheme requires that one has control over the conversion target types so that an `into` can be added to their declaration. It is appropriate where there are a few designated types that are meant to be conversion targets. If that's the case, migration from Scala 2 to Scala 3
+The second scheme allows `into` as a soft modifier on traits, classes, and opaque type aliases. If a type definition is declared with this modifier, conversions to that type are allowed. The second scheme requires that one has control over the conversion target types so that an `into` can be added to their declaration. It is appropriate where there are a few designated types that are meant to be conversion targets. If that's the case, migration from Scala 2 to Scala 3
 becomes easier since no function signatures need to be rewritten. We call this scheme "_into as a modifier_".
 
 
@@ -117,7 +117,7 @@ number of `IterableOnce[Char]` arguments, and also allows implicit conversions i
 
 ```scala
 def concatAll(xss: into[IterableOnce[Char]]*): List[Char] =
-  xss.foldLeft(List[Char]())(_ ++ _)
+  xss.foldRight(Nil)(_ ++: _)
 ```
 Here, the call
 ```scala
@@ -176,7 +176,7 @@ and then `++`, `flatMap` and other functions could use this alias in their param
 The `into` scheme discussed so far strikes a nice balance between explicitness and convenience. But migrating to it from Scala 2 implicits does require major changes since possibly a large number of function signatures has to be changed to allow conversions on the arguments. This might ultimately hold back migration to Scala 3 implicits.
 
 To facilitate migration, we also introduce an alternative way to specify target types of implicit conversions. We allow `into` as a soft modifier on
-classes and traits. If a class or trait is declared with `into`, then implicit conversions into that class or trait don't need a language import.
+classes, traits, and opaque type aliases. If a type definition is declared with `into`, then implicit conversions into that type don't need a language import.
 
 For instance, the Laminar framework
 defines a trait `Modifier` that is commonly used as a parameter type of user-defined methods and that should support implicit conversions into it.
@@ -205,17 +205,15 @@ The `into`-as-a-modifier scheme is handy in codebases that have a small set of s
 
 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 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.
-
+ - A type of the form `into[T]`.
+ - A reference `p.C` to a class, trait, or opaque type alias `C` that is declared with an `into` modifier. The reference can be followed by type arguments.
+ - 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.
 
 Type parameters that are not fully instantiated do not count as valid conversion target types. For instance, consider:
 
@@ -283,5 +281,5 @@ of the original `Modifier` trait has changed. In summary, upgrading Laminar to u
 LocalModifier     ::=  ...  |  ‘into’
 ```
 
-`into` is a soft modifier. It is only allowed on traits and classes.
+`into` is a soft modifier. It is only allowed classes, traits, and opaque type aliases.
 

tests/neg/into-mods.check

@@ -6,11 +6,11 @@
 7 |into object M   // error
   |^^^^^^^^^^^^^
   |Modifier into is not allowed for this definition
+-- [E156] Syntax Error: tests/neg/into-mods.scala:12:2 -----------------------------------------------------------------
+12 |  into type T = Int // error
+   |  ^^^^
+   |  Modifier into is not allowed for this definition
 -- Error: tests/neg/into-mods.scala:11:11 ------------------------------------------------------------------------------
 11 |  into val x = 33   // error
    |  ^^^^^^^^^^^^^^^
    |  modifier(s) `into` incompatible with value definition
--- Error: tests/neg/into-mods.scala:12:12 ------------------------------------------------------------------------------
-12 |  into type T = Int // error
-   |            ^
-   |            only classes can be into

tests/neg/into-mods.scala

@@ -10,4 +10,5 @@ object Test:
   into def foo = 22 // error
   into val x = 33   // error
   into type T = Int // error
+  into opaque type U = Int // ok
 

tests/warn/into-as-mod.scala

@@ -6,6 +6,10 @@ import Conversion.into
 into trait T
 class C(x: Int) extends T
 
+object K:
+  into opaque type A = C
+  given Conversion[Int, A] = C(_)
+
 object Test:
   given Conversion[Int, C] = C(_)
 
@@ -14,6 +18,10 @@ object Test:
   f(1)      // ok
   g(1)      // warn
 
+  import K.*
+  def h(x: A) = ()
+  h(1)
+
   into class Keyword(str: String)
   given stringToKeyword: Conversion[String, Keyword] = Keyword(_)