Typechecking with into modifiers

Author: odersky

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

@@ -1016,6 +1016,7 @@ class Definitions {
   @tu lazy val ImplicitNotFoundAnnot: ClassSymbol = requiredClass("scala.annotation.implicitNotFound")
   @tu lazy val InlineParamAnnot: ClassSymbol = requiredClass("scala.annotation.internal.InlineParam")
   @tu lazy val IntoAnnot: ClassSymbol = requiredClass("scala.annotation.internal.into")
+  @tu lazy val IntoParamAnnot: ClassSymbol = requiredClass("scala.annotation.internal.$into")
   @tu lazy val ErasedParamAnnot: ClassSymbol = requiredClass("scala.annotation.internal.ErasedParam")
   @tu lazy val MainAnnot: ClassSymbol = requiredClass("scala.main")
   @tu lazy val MappedAlternativeAnnot: ClassSymbol = requiredClass("scala.annotation.internal.MappedAlternative")

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

@@ -419,8 +419,9 @@ object Types extends TypeUtils {
       typeSymbol eq defn.RepeatedParamClass
 
     /** Is this a parameter type that allows implicit argument converson? */
-    def isInto(using Context): Boolean =
-      typeSymbol eq ???
+    def isInto(using Context): Boolean = this match
+      case AnnotatedType(_, annot) => annot.symbol == defn.IntoParamAnnot
+      case _ => false
 
     /** Is this the type of a method that has a repeated parameter type as
      *  last parameter type?
@@ -1927,7 +1928,9 @@ object Types extends TypeUtils {
             case res => res
           }
           defn.FunctionNOf(
-            mt.paramInfos.mapConserve(_.translateFromRepeated(toArray = isJava)),
+            mt.paramInfos.mapConserve: 
+              _.translateFromRepeated(toArray = isJava)
+               .mapIntoAnnot(defn.IntoParamAnnot, null),
             result1, isContextual)
         if mt.hasErasedParams then
           defn.PolyFunctionOf(mt)
@@ -1975,6 +1978,38 @@ object Types extends TypeUtils {
       case _ => this
     }
 
+    /** A mapping between mapping one kind of into annotation to another or
+     *  dropping into annotations.
+     *  @param from the into annotation to map
+     *  @param to   either the replacement annotation symbol, or `null`
+     *              in which case the `from` annotations are dropped.
+     */
+    def mapIntoAnnot(from: ClassSymbol, to: ClassSymbol | Null)(using Context): Type = this match
+      case self @ AnnotatedType(tp, annot) =>
+        val tp1 = tp.mapIntoAnnot(from, to)
+        if annot.symbol == from then
+          if to == null then tp1
+          else AnnotatedType(tp1, Annotation(to, from.span))
+        else self.derivedAnnotatedType(tp1, annot)
+      case AppliedType(tycon, arg :: Nil) if tycon.typeSymbol == defn.RepeatedParamClass =>
+        val arg1 = arg.mapIntoAnnot(from, to)
+        if arg1 eq arg then this
+        else AppliedType(tycon, arg1 :: Nil)
+      case defn.FunctionOf(argTypes, resType, isContextual) =>
+        val resType1 = resType.mapIntoAnnot(from, to)
+        if resType1 eq resType then this
+        else defn.FunctionOf(argTypes, resType1, isContextual)
+      case RefinedType(parent, rname, mt: MethodOrPoly) =>
+        val mt1 = mt.mapIntoAnnot(from, to)
+        if mt1 eq mt then this
+        else RefinedType(parent.mapIntoAnnot(from, to), rname, mt1)
+      case mt: MethodOrPoly =>
+        mt.derivedLambdaType(resType = mt.resType.mapIntoAnnot(from, to))
+      case tp: ExprType =>
+        tp.derivedExprType(tp.resType.mapIntoAnnot(from, to))
+      case _ =>
+        this
+
     /** A type capturing `ref` */
     def capturing(ref: CaptureRef)(using Context): Type =
       if captureSet.accountsFor(ref) then this
@@ -4122,6 +4157,7 @@ object Types extends TypeUtils {
     /** Produce method type from parameter symbols, with special mappings for repeated
      *  and inline parameters:
      *   - replace @repeated annotations on Seq or Array types by <repeated> types
+     *   - map into annotations to $into annotations
      *   - add @inlineParam to inline parameters
      *   - add @erasedParam to erased parameters
      *   - wrap types of parameters that have an @allowConversions annotation with Into[_]
@@ -4134,7 +4170,7 @@ object Types extends TypeUtils {
       def paramInfo(param: Symbol) =
         var paramType = param.info
           .annotatedToRepeated
-          //.mapIntoAnnot(defn.IntoType.appliedTo(_))
+          .mapIntoAnnot(defn.IntoAnnot, defn.IntoParamAnnot)
         if param.is(Inline) then
           paramType = addAnnotation(paramType, defn.InlineParamAnnot, param)
         if param.is(Erased) then

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -287,9 +287,9 @@ class PlainPrinter(_ctx: Context) extends Printer {
       case AnnotatedType(tpe, annot) =>
         if annot.symbol == defn.InlineParamAnnot || annot.symbol == defn.ErasedParamAnnot
         then toText(tpe)
-        else if annot.symbol == defn.IntoAnnot && !printDebug then
-          atPrec(GlobalPrec):
-            Str("into ") ~ toText(tpe)
+        else if (annot.symbol == defn.IntoAnnot || annot.symbol == defn.IntoParamAnnot)
+            && !printDebug
+        then atPrec(GlobalPrec)( Str("into ") ~ toText(tpe) )
         else toTextLocal(tpe) ~ " " ~ toText(annot)
       case tp: TypeVar =>
         def toTextCaret(tp: Type) = if printDebug then toTextLocal(tp) ~ Str("^") else toText(tp)

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -244,7 +244,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           case _ =>
             val tsym = tycon.typeSymbol
             if tycon.isRepeatedParam then toTextLocal(args.head) ~ "*"
-            else if tp.isInto then atPrec(GlobalPrec)( "into " ~ toText(args.head) )
             else if defn.isFunctionSymbol(tsym) then toTextFunction(tp)
             else if isInfixType(tp) then
               val l :: r :: Nil = args: @unchecked

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

@@ -1082,7 +1082,7 @@ trait Checking {
 
   /** If `tree` is an application of a new-style implicit conversion (using the apply
    *  method of a `scala.Conversion` instance), check that the expected type is
-   *  a convertible formal parameter type or that implicit conversions are enabled.
+   *  annotated with @$into or that implicit conversions are enabled.
    */
   def checkImplicitConversionUseOK(tree: Tree, expected: Type)(using Context): Unit =
     val sym = tree.symbol

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

@@ -8,7 +8,7 @@ import Symbols.*, Types.*, Contexts.*, Flags.*, Names.*, NameOps.*, NameKinds.*
 import StdNames.*, Denotations.*, Phases.*, SymDenotations.*
 import NameKinds.DefaultGetterName
 import util.Spans.*
-import scala.collection.mutable
+import scala.collection.{mutable, immutable}
 import ast.*
 import MegaPhase.*
 import config.Printers.{checks, noPrinter, capt}
@@ -368,6 +368,52 @@ object RefChecks {
       && atPhase(typerPhase):
         loop(member.info.paramInfoss, other.info.paramInfoss)
 
+    /** A map of all occurrences of `into` in a member type.
+     *  Key: number of parameter carrying `into` annotation(s)
+     *  Value: A list of all depths of into annotations, where each
+     *  function arrow increases the depth.
+     *  Example:
+     *      def foo(x: into A, y: => [X] => into (x: X) => into B): C
+     *  produces the map
+     *      (0 -> List(0), 1 -> List(1, 2))
+     */
+    type IntoOccurrenceMap = immutable.Map[Int, List[Int]]
+
+    def intoOccurrences(tp: Type): IntoOccurrenceMap =
+
+      def traverseInfo(depth: Int, tp: Type): List[Int] = tp match
+        case AnnotatedType(tp, annot) if annot.symbol == defn.IntoParamAnnot =>
+          depth :: traverseInfo(depth, tp)
+        case AppliedType(tycon, arg :: Nil) if tycon.typeSymbol == defn.RepeatedParamClass =>
+          traverseInfo(depth, arg)
+        case defn.FunctionOf(_, resType, _) =>
+          traverseInfo(depth + 1, resType)
+        case RefinedType(parent, rname, mt: MethodOrPoly) =>
+          traverseInfo(depth, mt)
+        case tp: MethodOrPoly =>
+          traverseInfo(depth + 1, tp.resType)
+        case tp: ExprType =>
+          traverseInfo(depth, tp.resType)
+        case _ =>
+          Nil
+
+      def traverseParams(n: Int, formals: List[Type], acc: IntoOccurrenceMap): IntoOccurrenceMap =
+        if formals.isEmpty then acc
+        else
+          val occs = traverseInfo(0, formals.head)
+          traverseParams(n + 1, formals.tail, if occs.isEmpty then acc else acc + (n -> occs))
+
+      def traverse(n: Int, tp: Type, acc: IntoOccurrenceMap): IntoOccurrenceMap = tp match
+        case tp: PolyType =>
+          traverse(n, tp.resType, acc)
+        case tp: MethodType =>
+          traverse(n + tp.paramInfos.length, tp.resType, traverseParams(n, tp.paramInfos, acc))
+        case _ =>
+          acc
+
+      traverse(0, tp, immutable.Map.empty)
+    end intoOccurrences
+
     val checker =
       if makeOverridingPairsChecker == null then OverridingPairsChecker(clazz, self)
       else makeOverridingPairsChecker(clazz, self)
@@ -572,6 +618,8 @@ object RefChecks {
           overrideError(i"needs to be declared with @targetName(${"\""}${other.targetName}${"\""}) so that external names match")
         else
           overrideError("cannot have a @targetName annotation since external names would be different")
+      else if intoOccurrences(memberTp(self)) != intoOccurrences(otherTp(self)) then
+        overrideError("has different occurrences of `into` modifiers", compareTypes = true)
       else if other.is(ParamAccessor) && !isInheritedAccessor(member, other) then // (1.12)
         report.errorOrMigrationWarning(
             em"cannot override val parameter ${other.showLocated}",
@@ -1002,9 +1050,9 @@ object RefChecks {
   end checkNoPrivateOverrides
 
   def checkVolatile(sym: Symbol)(using Context): Unit =
-    if sym.isVolatile && !sym.is(Mutable) then 
+    if sym.isVolatile && !sym.is(Mutable) then
       report.warning(VolatileOnVal(), sym.srcPos)
-  
+
   /** Check that unary method definition do not receive parameters.
    *  They can only receive inferred parameters such as type parameters and implicit parameters.
    */

compiler/test/dotty/tools/vulpix/TestConfiguration.scala

@@ -66,7 +66,9 @@ object TestConfiguration {
   val yCheckOptions = Array("-Ycheck:all")
 
   val commonOptions = Array("-indent") ++ checkOptions ++ noCheckOptions ++ yCheckOptions
+  val noYcheckCommonOptions = Array("-indent") ++ checkOptions ++ noCheckOptions
   val defaultOptions = TestFlags(basicClasspath, commonOptions)
+  val noYcheckOptions = TestFlags(basicClasspath, noYcheckCommonOptions)
   val unindentOptions = TestFlags(basicClasspath, Array("-no-indent") ++ checkOptions ++ noCheckOptions ++ yCheckOptions)
   val withCompilerOptions =
     defaultOptions.withClasspath(withCompilerClasspath).withRunClasspath(withCompilerClasspath)

library/src/scala/annotation/internal/Into.scala

@@ -0,0 +1,14 @@
+package scala.annotation.internal
+import annotation.experimental
+
+/** An annotation on (part of) a parameter type that allows implicit conversions
+ *  for its arguments. The `into` modifier on parameter types in Scala 3 is
+ *  mapped to this annotation. We can also install a more generally accessible
+ *  alias so that Scala 2 libraries can use the feature.
+ */
+@experimental
+class into() extends annotation.StaticAnnotation
+
+@experimental
+class $into() extends annotation.StaticAnnotation
+

tests/neg-custom-args/convertible.check

@@ -0,0 +1,21 @@
+-- [E120] Naming Error: tests/neg-custom-args/convertible.scala:15:6 ---------------------------------------------------
+15 |trait C[X] extends A[X]:  // error
+   |      ^
+   |      Name clash between defined and inherited member:
+   |      def f(x: X): Unit in trait A at line 10 and
+   |      override def f(x: into X): Unit in trait C at line 16
+   |      have the same type after erasure.
+   |
+   |      Consider adding a @targetName annotation to one of the conflicting definitions
+   |      for disambiguation.
+-- [E120] Naming Error: tests/neg-custom-args/convertible.scala:18:6 ---------------------------------------------------
+18 |class D[X] extends B[X], C[X] // error
+   |      ^
+   |      Name clash between inherited members:
+   |      override def f(x: X): Unit in trait B at line 13 and
+   |      override def f(x: into X): Unit in trait C at line 16
+   |      have the same type after erasure.
+   |
+   |      Consider adding a @targetName annotation to one of the conflicting definitions
+   |      for disambiguation.
+there was 1 feature warning; re-run with -feature for details

tests/neg/into-override.check

@@ -0,0 +1,21 @@
+-- [E164] Declaration Error: tests/neg/into-override.scala:16:15 -------------------------------------------------------
+16 |  override def f(x: into X) = super.f(x)    // error
+   |               ^
+   |               error overriding method f in trait A of type (x: X): Unit;
+   |                 method f of type (x: into X): Unit has different occurrences of `into` modifiers
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E164] Declaration Error: tests/neg/into-override.scala:18:6 --------------------------------------------------------
+18 |class D[X] extends B[X], C[X] // error
+   |      ^
+   |      error overriding method f in trait B of type (x: X): Unit;
+   |        method f in trait C of type (x: into X): Unit has different occurrences of `into` modifiers
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E164] Declaration Error: tests/neg/into-override.scala:21:15 -------------------------------------------------------
+21 |  override def f(x: X) = super.f(x) // error
+   |               ^
+   |               error overriding method f in trait C of type (x: into X): Unit;
+   |                 method f of type (x: X): Unit has different occurrences of `into` modifiers
+   |
+   | longer explanation available when compiling with `-explain`

tests/neg/into-override.scala

@@ -0,0 +1,23 @@
+//> using options -Xfatal-warnings
+
+import language.experimental.into
+
+class Text(val str: String)
+
+given Conversion[String, Text] = Text(_)
+
+trait A[X]:
+  def f(x: X): Unit = ()
+
+trait B[X] extends A[X]:
+  override def f(x: X) = super.f(x)
+
+trait C[X] extends A[X]:
+  override def f(x: into X) = super.f(x)    // error
+
+class D[X] extends B[X], C[X] // error
+
+trait E[X] extends C[X]:
+  override def f(x: X) = super.f(x) // error
+
+def f = new D[Text].f("abc")

tests/neg/into-syntax.check

@@ -0,0 +1,61 @@
+-- [E040] Syntax Error: tests/neg/into-syntax.scala:7:22 ---------------------------------------------------------------
+7 |  def f1(x: List[into Int]) = () // error // error
+  |                      ^^^
+  |                      ',' or ']' expected, but identifier found
+-- Error: tests/neg/into-syntax.scala:11:20 ----------------------------------------------------------------------------
+11 |  def f4(x: into Int*) = () // error
+   |                    ^
+   |                    `*` cannot directly follow `into` parameter
+   |                    the `into` parameter needs to be put in parentheses
+-- [E040] Syntax Error: tests/neg/into-syntax.scala:21:23 --------------------------------------------------------------
+21 |  def f11(x: ((y: into Int) => into Int => Int)*) = () // error // error
+   |                       ^^^
+   |                       ')' expected, but identifier found
+-- Error: tests/neg/into-syntax.scala:24:14 ----------------------------------------------------------------------------
+24 |  def f14(x: (into Int) => Int) = () // error
+   |              ^^^^
+   |              no `into` modifier allowed here
+-- Error: tests/neg/into-syntax.scala:25:14 ----------------------------------------------------------------------------
+25 |  def f15(x: (into Int, into Int)) = () // error // error
+   |              ^^^^
+   |              no `into` modifier allowed here
+-- Error: tests/neg/into-syntax.scala:25:24 ----------------------------------------------------------------------------
+25 |  def f15(x: (into Int, into Int)) = () // error // error
+   |                        ^^^^
+   |                        no `into` modifier allowed here
+-- Error: tests/neg/into-syntax.scala:26:14 ----------------------------------------------------------------------------
+26 |  def f16(x: (into Int, into Int) => Int) = () // error // error
+   |              ^^^^
+   |              no `into` modifier allowed here
+-- Error: tests/neg/into-syntax.scala:26:24 ----------------------------------------------------------------------------
+26 |  def f16(x: (into Int, into Int) => Int) = () // error // error
+   |                        ^^^^
+   |                        no `into` modifier allowed here
+-- [E040] Syntax Error: tests/neg/into-syntax.scala:27:27 --------------------------------------------------------------
+27 |  def f17(x: into (y: into Int, z: into Int) => into Int) = () // error // error // error
+   |                           ^^^
+   |                           ')' expected, but identifier found
+-- [E019] Syntax Error: tests/neg/into-syntax.scala:27:44 --------------------------------------------------------------
+27 |  def f17(x: into (y: into Int, z: into Int) => into Int) = () // error // error // error
+   |                                            ^
+   |                                            Missing return type
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E006] Not Found Error: tests/neg/into-syntax.scala:7:17 ------------------------------------------------------------
+7 |  def f1(x: List[into Int]) = () // error // error
+  |                 ^^^^
+  |                 Not found: type into - did you mean into.type?
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E006] Not Found Error: tests/neg/into-syntax.scala:21:18 -----------------------------------------------------------
+21 |  def f11(x: ((y: into Int) => into Int => Int)*) = () // error // error
+   |                  ^^^^
+   |                  Not found: type into - did you mean into.type?
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E006] Not Found Error: tests/neg/into-syntax.scala:27:22 -----------------------------------------------------------
+27 |  def f17(x: into (y: into Int, z: into Int) => into Int) = () // error // error // error
+   |                      ^^^^
+   |                      Not found: type into - did you mean into.type?
+   |
+   | longer explanation available when compiling with `-explain`

tests/neg/into-syntax.scala

@@ -0,0 +1,27 @@
+//> using options -feature
+
+import language.experimental.into
+
+
+object x1:
+  def f1(x: List[into Int]) = () // error // error
+object x3:
+  def f3(x: ((into Int))) = () // ok
+object x4:
+  def f4(x: into Int*) = () // error
+object x5:
+  def f5(x: ((into Int))*) = () // ok
+
+object x6:
+  def f6(x: (into Int)*) = () // ok
+  def f7(x: (Int => into Int)*) = () // ok
+  def f8(x: (Int => (into Int))*) = () // ok
+  def f9(x: (y: Int) => into Int) = () // ok
+  def f10(x: ((y: Int) => into Int)*) = () // ok
+  def f11(x: ((y: into Int) => into Int => Int)*) = () // error // error
+
+object x7:
+  def f14(x: (into Int) => Int) = () // error
+  def f15(x: (into Int, into Int)) = () // error // error
+  def f16(x: (into Int, into Int) => Int) = () // error // error
+  def f17(x: into (y: into Int, z: into Int) => into Int) = () // error // error // error

tests/pos/into-class.scala

@@ -0,0 +1,15 @@
+import language.experimental.into
+
+class Text(str: String)
+
+case class C(x: into Text)
+
+case class D(x: Text)
+
+given Conversion[String, Text] = Text(_)
+
+def Test =
+  val c = C("a")
+  val d = new C("b")
+  val e = c.copy()
+  val f = c.copy(x = "d")