Add "into as a modifier" scheme

Author: odersky

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

@@ -236,6 +236,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     case class Tracked()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Tracked)
 
+    case class Into()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Into)
+
     /** Used under pureFunctions to mark impure function types `A => B` in `FunctionWithMods` */
     case class Impure()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Impure)
   }

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

@@ -252,7 +252,7 @@ object Flags {
   /** A field generated for a primary constructor parameter (no matter if it's a 'val' or not),
    *  or an accessor of such a field.
    */
-  val (_, ParamAccessor @ _, _) = newFlags(14, "<paramaccessor>")
+  val (ParamAccessorOrInto @ _, ParamAccessor @ _, Into @ _) = newFlags(14, "<paramaccessor>", "into")
 
   /** A value or class implementing a module */
   val (Module @ _, ModuleVal @ _, ModuleClass @ _) = newFlags(15, "module")
@@ -452,7 +452,7 @@ object Flags {
     commonFlags(Private, Protected, Final, Case, Implicit, Given, Override, JavaStatic, Transparent, Erased)
 
   val TypeSourceModifierFlags: FlagSet =
-    CommonSourceModifierFlags.toTypeFlags | Abstract | Sealed | Opaque | Open
+    CommonSourceModifierFlags.toTypeFlags | Abstract | Sealed | Opaque | Open | Into
 
   val TermSourceModifierFlags: FlagSet =
     CommonSourceModifierFlags.toTermFlags | Inline | AbsOverride | Lazy | Tracked
@@ -467,7 +467,7 @@ object Flags {
    *  TODO: Should check that FromStartFlags do not change in completion
    */
   val FromStartFlags: FlagSet = commonFlags(
-    Module, Package, Deferred, Method, Case, Enum, Param, ParamAccessor,
+    Module, Package, Deferred, Method, Case, Enum, Param, ParamAccessorOrInto,
     Scala2SpecialFlags, MutableOrOpen, Opaque, Touched, JavaStatic,
     OuterOrCovariant, LabelOrContravariant, CaseAccessor, Tracked,
     Extension, NonMember, Implicit, Given, Permanent, Synthetic, Exported,
@@ -547,7 +547,7 @@ object Flags {
   val RetainedExportTypeFlags = Infix
 
   /** Flags that apply only to classes */
-  val ClassOnlyFlags = Sealed | Open | Abstract.toTypeFlags
+  val ClassOnlyFlags = Sealed | Open | Into | Abstract.toTypeFlags
 
 // ------- Other flag sets -------------------------------------
 

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

@@ -458,8 +458,10 @@ object Types extends TypeUtils {
      */
     def isConversionTargetType(using Context): Boolean =
       dealias(KeepTypeVars | KeepOpaques).match
-        case _: AppliedType =>
-          isInto
+        case tp: TypeRef =>
+          tp.symbol.isClass && tp.symbol.is(Into)
+        case tp @ AppliedType(tycon: TypeRef, _) =>
+          isInto || tycon.isConversionTargetType
         case tp: AndOrType =>
           tp.tp1.isConversionTargetType && tp.tp2.isConversionTargetType
         case tp: TypeVar =>

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -905,6 +905,7 @@ class TreePickler(pickler: TastyPickler, attributes: Attributes) {
       if (flags.is(Contravariant)) writeModTag(CONTRAVARIANT)
       if (flags.is(Opaque)) writeModTag(OPAQUE)
       if (flags.is(Open)) writeModTag(OPEN)
+      if (flags.is(Into)) writeModTag(INTO)
     }
   }
 

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -758,6 +758,7 @@ class TreeUnpickler(reader: TastyReader,
           case TRANSPARENT => addFlag(Transparent)
           case INFIX => addFlag(Infix)
           case TRACKED => addFlag(Tracked)
+          case INTO => addFlag(Into)
           case PRIVATEqualified =>
             readByte()
             privateWithin = readWithin

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3284,6 +3284,7 @@ object Parsers {
       case IDENTIFIER =>
         name match {
           case nme.inline => Mod.Inline()
+          case nme.into => Mod.Into()
           case nme.opaque => Mod.Opaque()
           case nme.open => Mod.Open()
           case nme.transparent => Mod.Transparent()

compiler/src/dotty/tools/dotc/parsing/Tokens.scala

@@ -299,7 +299,7 @@ object Tokens extends TokensCommon {
 
   final val closingParens = BitSet(RPAREN, RBRACKET, RBRACE)
 
-  final val softModifierNames = Set(nme.inline, nme.opaque, nme.open, nme.transparent, nme.infix)
+  final val softModifierNames = Set(nme.inline, nme.into, nme.opaque, nme.open, nme.transparent, nme.infix)
 
   def showTokenDetailed(token: Int): String = debugString(token)
 

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

@@ -635,6 +635,8 @@ object Checking {
       mods.mods.find(_.flags == flag).getOrElse(mdef).srcPos
     if mods.is(Open) then
       report.error(ModifierNotAllowedForDefinition(Open), flagSourcePos(Open))
+    if mods.is(Into) then
+      report.error(ModifierNotAllowedForDefinition(Into), flagSourcePos(Open))
     if mods.is(Abstract) then
       report.error(ModifierNotAllowedForDefinition(Abstract), flagSourcePos(Abstract))
     if mods.is(Sealed) then

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -3183,6 +3183,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def Implicit: Flags = dotc.core.Flags.Implicit
       def Infix: Flags = dotc.core.Flags.Infix
       def Inline: Flags = dotc.core.Flags.Inline
+      def Into: Flags = dotc.core.Flags.Into
       def Invisible: Flags = dotc.core.Flags.Invisible
       def JavaDefined: Flags = dotc.core.Flags.JavaDefined
       def JavaStatic: Flags = dotc.core.Flags.JavaStatic
@@ -3208,6 +3209,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def StableRealizable: Flags = dotc.core.Flags.StableRealizable
       @deprecated("Use JavaStatic instead", "3.3.0") def Static: Flags = dotc.core.Flags.JavaStatic
       def Synthetic: Flags = dotc.core.Flags.Synthetic
+      def Tracked: Flags = dotc.core.Flags.Tracked
       def Trait: Flags = dotc.core.Flags.Trait
       def Transparent: Flags = dotc.core.Flags.Transparent
 

docs/_docs/reference/experimental/into.md

@@ -132,6 +132,28 @@ 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`.
 
+## Alternative: `into` as a Modifier
+
+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.
+
+Example:
+```scala
+into class Keyword
+given stringToKeyword: Conversion[String, Keyword] = Keyword(_)
+
+val dclKeywords = List("def", "val")
+val xs: List[Keyword] = dclkeywords ++ List("if", "then", "else")
+```
+Here, the strings `"if"`, `"then"`, and `"else"` are converted to `Keyword` using the given conversion `stringToKeyword`. No feature warning or error is issued since `Keyword` is declared as `into`.
+
+The `into`-as-a-modifier scheme is handy in codebases that have a small set of specific types that are intended to be the targets of implicit conversions defined in the same codebase. But it can be easily abused.
+One should restrict the number of `into`-declared types to the absolute minimum. In particular, never make a type `into` to just cater for the
+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
@@ -176,8 +198,8 @@ given Conversion[Int, C] = C(_)
 
 def f(x: T) = ()
 def g(x: C) = ()
-f("abc")      // ok
-g("abc")      // error
+f(1)      // ok
+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`.

tasty/src/dotty/tools/tasty/TastyFormat.scala

@@ -229,6 +229,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   OPEN                                                             -- an open class
                   INVISIBLE                                                        -- invisible during typechecking, except when resolving from TASTy
                   TRACKED                                                          -- a tracked class parameter / a dependent class
+                  INTO                                                             -- a trait or class declared with `into`
                   Annotation
 
   Variance      = STABLE                                                           -- invariant
@@ -511,6 +512,7 @@ object TastyFormat {
   final val EMPTYCLAUSE = 45
   final val SPLITCLAUSE = 46
   final val TRACKED = 47
+  final val INTO = 48
 
   // Tree Cat. 2:    tag Nat
   final val firstNatTreeTag = SHAREDterm
@@ -703,7 +705,8 @@ object TastyFormat {
        | ANNOTATION
        | PRIVATEqualified
        | PROTECTEDqualified
-       | TRACKED => true
+       | TRACKED
+       | INTO => true
     case _ => false
   }
 
@@ -763,6 +766,8 @@ object TastyFormat {
     case PARAMsetter => "PARAMsetter"
     case EXPORTED => "EXPORTED"
     case OPEN => "OPEN"
+    case INTO => "INTO"
+    case TRACKED => "TRACKED"
     case INVISIBLE => "INVISIBLE"
     case PARAMalias => "PARAMalias"
     case EMPTYCLAUSE => "EMPTYCLAUSE"

tests/neg/i21786.scala

@@ -0,0 +1,16 @@
+-- Error: tests/neg/into-mods.scala:10:11 ------------------------------------------------------------------------------
+10 |  into def foo = 22 // error
+   |           ^
+   |            values cannot be into
+-- [E156] Syntax Error: tests/neg/into-mods.scala:7:12 -----------------------------------------------------------------
+7 |into object M   // 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.check

@@ -0,0 +1,13 @@
+import language.experimental.into
+
+into class Test
+
+into trait T
+
+into object M   // error
+
+object Test:
+  into def foo = 22 // error
+  into val x = 33   // error
+  into type T = Int // error
+

tests/neg/into-mods.scala

@@ -0,0 +1,15 @@
+//> using options -feature
+
+import language.experimental.into
+import Conversion.into
+
+into trait T
+class C(x: Int) extends T
+
+object Test:
+  given Conversion[Int, C] = C(_)
+
+  def f(x: T) = ()
+  def g(x: C) = ()
+  f(1)      // ok
+  g(1)      // warn