Change scheme to use an opaque type alias

Author: odersky

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

@@ -753,6 +753,9 @@ class Definitions {
   @tu lazy val StringBuilderClass: ClassSymbol = requiredClass("scala.collection.mutable.StringBuilder")
   @tu lazy val MatchErrorClass   : ClassSymbol = requiredClass("scala.MatchError")
   @tu lazy val ConversionClass   : ClassSymbol = requiredClass("scala.Conversion").typeRef.symbol.asClass
+  @tu lazy val ConversionModule  : Symbol = ConversionClass.companionModule
+  @tu lazy val ConversionModuleClass: ClassSymbol = ConversionModule.moduleClass.asClass
+    @tu lazy val Conversion_into : Symbol = ConversionModuleClass.requiredType("into")
 
   @tu lazy val StringAddClass    : ClassSymbol = requiredClass("scala.runtime.StringAdd")
     @tu lazy val StringAdd_+ : Symbol = StringAddClass.requiredMethod(nme.raw.PLUS)
@@ -1039,8 +1042,6 @@ class Definitions {
   @tu lazy val ImplicitAmbiguousAnnot: ClassSymbol = requiredClass("scala.annotation.implicitAmbiguous")
   @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.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")
@@ -1058,6 +1059,7 @@ class Definitions {
   // @tu lazy val ScalaStrictFPAnnot: ClassSymbol = requiredClass("scala.annotation.strictfp")
   @tu lazy val ScalaStaticAnnot: ClassSymbol = requiredClass("scala.annotation.static")
   @tu lazy val SerialVersionUIDAnnot: ClassSymbol = requiredClass("scala.SerialVersionUID")
+  @tu lazy val SilentIntoAnnot: ClassSymbol = requiredClass("scala.annotation.internal.$into")
   @tu lazy val TailrecAnnot: ClassSymbol = requiredClass("scala.annotation.tailrec")
   @tu lazy val ThreadUnsafeAnnot: ClassSymbol = requiredClass("scala.annotation.threadUnsafe")
   @tu lazy val ConstructorOnlyAnnot: ClassSymbol = requiredClass("scala.annotation.constructorOnly")
@@ -1117,7 +1119,7 @@ class Definitions {
 
   // Set of annotations that are not printed in types except under -Yprint-debug
   @tu lazy val SilentAnnots: Set[Symbol] =
-    Set(InlineParamAnnot, ErasedParamAnnot, RefineOverrideAnnot)
+    Set(InlineParamAnnot, ErasedParamAnnot, RefineOverrideAnnot, SilentIntoAnnot)
 
   // A list of annotations that are commonly used to indicate that a field/method argument or return
   // type is not null. These annotations are used by the nullification logic in JavaNullInterop to
@@ -1387,6 +1389,9 @@ class Definitions {
   final def isNamedTuple_From(sym: Symbol)(using Context): Boolean =
     sym.name == tpnme.From && sym.owner == NamedTupleModule.moduleClass
 
+  final def isInto(sym: Symbol)(using Context): Boolean =
+    sym.name == tpnme.into && sym.owner == ConversionModuleClass
+
   private val compiletimePackageAnyTypes: Set[Name] = Set(
     tpnme.Equals, tpnme.NotEquals, tpnme.IsConst, tpnme.ToString
   )

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

@@ -317,4 +317,11 @@ object NamerOps:
             ann.tree match
               case ast.tpd.WitnessNamesAnnot(witnessNames) =>
                 addContextBoundCompanionFor(sym, witnessNames, Nil)
+
+  /** if `sym` is a term parameter or parameter accessor, map all occurrences of
+   *  `into[T]` in its type to `T @$into`.
+   */
+  extension (tp: Type)
+    def suppressIntoIfParam(sym: Symbol)(using Context): Type =
+      if sym.isOneOf(TermParamOrAccessor) then TypeOps.suppressInto(tp) else tp
 end NamerOps

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

@@ -18,6 +18,7 @@ import typer.ForceDegree
 import typer.Inferencing.*
 import typer.IfBottom
 import reporting.TestingReporter
+import Annotations.Annotation
 import cc.{CapturingType, derivedCapturingType, CaptureSet, captureSet, isBoxed, isBoxedCapturing}
 import CaptureSet.{CompareResult, IdentityCaptRefMap, VarState}
 
@@ -936,6 +937,28 @@ object TypeOps:
   class StripTypeVarsMap(using Context) extends TypeMap:
     def apply(tp: Type) = mapOver(tp).stripTypeVar
 
+  /** Map no-flip covariant occurrences of `into[T]` to `T @$into` */
+  def suppressInto(using Context) = new FollowAliasesMap:
+    def apply(t: Type): Type =
+      if variance <= 0 then t
+      else t match
+        case AppliedType(tycon: TypeRef, arg :: Nil) if defn.isInto(tycon.symbol) =>
+          AnnotatedType(arg, Annotation(defn.SilentIntoAnnot, util.Spans.NoSpan))
+        case _ =>
+          mapFollowingAliases(t)
+
+  /** Map no-flip covariant occurrences of `T @$into` to `into[T]` */
+  def revealInto(using Context) = new FollowAliasesMap:
+    def apply(t: Type): Type =
+      if variance <= 0 then t
+      else t match
+        case AnnotatedType(t1, ann) if ann.symbol == defn.SilentIntoAnnot =>
+          AppliedType(
+            defn.ConversionModule.termRef.select(defn.Conversion_into), // the external reference to the opaque type
+            t1 :: Nil)
+        case _ =>
+          mapFollowingAliases(t)
+
   /** Apply [[Type.stripTypeVar]] recursively. */
   def stripTypeVars(tp: Type)(using Context): Type =
     new StripTypeVarsMap().apply(tp)

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

@@ -445,9 +445,11 @@ object Types extends TypeUtils {
     def isRepeatedParam(using Context): Boolean =
       typeSymbol eq defn.RepeatedParamClass
 
-    /** Is this a parameter type that allows implicit argument converson? */
+    /** Is this type of the form `compiletime.into[T]`, which means it can be the
+     *  target of an implicit converson without requiring a language import?
+     */
     def isInto(using Context): Boolean = this match
-      case AnnotatedType(_, annot) => annot.symbol == defn.IntoParamAnnot
+      case AppliedType(tycon: TypeRef, arg :: Nil) => defn.isInto(tycon.symbol)
       case _ => false
 
     /** Is this the type of a method that has a repeated parameter type as
@@ -1965,8 +1967,7 @@ object Types extends TypeUtils {
           }
           defn.FunctionNOf(
             mt.paramInfos.mapConserve:
-              _.translateFromRepeated(toArray = isJava)
-               .mapIntoAnnot(defn.IntoParamAnnot, null),
+              _.translateFromRepeated(toArray = isJava),
             result1, isContextual)
         if mt.hasErasedParams then
           defn.PolyFunctionOf(mt)
@@ -2014,38 +2015,6 @@ 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, annot.tree.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
-
     /** The set of distinct symbols referred to by this type, after all aliases are expanded */
     def coveringSet(using Context): Set[Symbol] =
       (new CoveringSetAccumulator).apply(Set.empty[Symbol], this)
@@ -4174,11 +4143,11 @@ 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
+     *   - 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[_]
+     *   - add `@inlineParam` to inline parameters
+     *   - add `@erasedParam` to erased parameters
+     *   - map `T @$into` types to `into[T]`
      */
     def fromSymbols(params: List[Symbol], resultType: Type)(using Context): MethodType =
       apply(params.map(_.name.asTermName))(
@@ -4192,9 +4161,7 @@ object Types extends TypeUtils {
       def addAnnotation(tp: Type, cls: ClassSymbol, param: Symbol): Type = tp match
         case ExprType(resType) => ExprType(addAnnotation(resType, cls, param))
         case _ => AnnotatedType(tp, Annotation(cls, param.span))
-      var paramType = pinfo
-        .annotatedToRepeated
-        .mapIntoAnnot(defn.IntoAnnot, defn.IntoParamAnnot)
+      var paramType = TypeOps.revealInto(pinfo).annotatedToRepeated
       if param.is(Inline) then
         paramType = addAnnotation(paramType, defn.InlineParamAnnot, param)
       if param.is(Erased) then

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

@@ -933,7 +933,7 @@ class TreeUnpickler(reader: TastyReader,
           DefDef(paramDefss, tpt)
         case VALDEF =>
           val tpt = readTpt()(using localCtx)
-          sym.info = tpt.tpe
+          sym.info = tpt.tpe.suppressIntoIfParam(sym)
           ValDef(tpt)
         case TYPEDEF | TYPEPARAM =>
           if (sym.isClass) {
@@ -978,7 +978,7 @@ class TreeUnpickler(reader: TastyReader,
         case PARAM =>
           val tpt = readTpt()(using localCtx)
           assert(nothingButMods(end))
-          sym.info = tpt.tpe
+          sym.info = tpt.tpe.suppressIntoIfParam(sym)
           ValDef(tpt)
       }
       goto(end)

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

@@ -1688,7 +1688,7 @@ object Parsers {
             accept(ARROW)
 
           val resultType =
-            if isPure then capturesAndResult(typ) else typ()
+            if isPure then capturesAndResult(() => typ()) else typ()
           if token == TLARROW then
             for case ValDef(_, tpt, _) <- params do
               if isByNameType(tpt) then
@@ -1778,7 +1778,7 @@ object Parsers {
             LambdaTypeTree(tparams, toplevelTyp())
         else if in.token == ARROW || isPureArrow(nme.PUREARROW) then
           val arrowOffset = in.skipToken()
-          val body = toplevelTyp(nestedIntoOK(in.token))
+          val body = toplevelTyp()
           makePolyFunction(tparams, body, "type", Ident(nme.ERROR.toTypeName), start, arrowOffset)
         else
           accept(TLARROW)
@@ -2171,7 +2171,7 @@ object Parsers {
      *               |  `=>' Type
      *               |  `->' [CaptureSet] Type
      */
-    val funArgType: () => Tree = () => paramTypeOf(typ)
+    val funArgType: () => Tree = () => paramTypeOf(() => typ())
 
     /** ParamType  ::=  ParamValueType
      *               |  `=>' ParamValueType
@@ -2184,11 +2184,6 @@ object Parsers {
     def paramValueType(): Tree =
       val t = toplevelTyp()
       if isIdent(nme.raw.STAR) then
-        if !t.isInstanceOf[Parens] && isInto(t) then
-          syntaxError(
-            em"""`*` cannot directly follow `into` parameter
-                |the `into` parameter needs to be put in parentheses""",
-            in.offset)
         in.nextToken()
         atSpan(startOffset(t)):
           PostfixOp(t, Ident(tpnme.raw.STAR))
@@ -3490,7 +3485,7 @@ object Parsers {
      */
     def contextTypes(paramOwner: ParamOwner, numLeadParams: Int, impliedMods: Modifiers): List[ValDef] =
       typesToParams(
-        commaSeparated(() => paramTypeOf(toplevelTyp)),
+        commaSeparated(() => paramTypeOf(() => toplevelTyp())),
         paramOwner, numLeadParams, impliedMods)
 
     def typesToParams(tps: List[Tree], paramOwner: ParamOwner, numLeadParams: Int, impliedMods: Modifiers): List[ValDef] =

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

@@ -326,10 +326,6 @@ class PlainPrinter(_ctx: Context) extends Printer {
       case AnnotatedType(tpe, annot) =>
         if defn.SilentAnnots.contains(annot.symbol) && !printDebug then
           toText(tpe)
-        else if (annot.symbol == defn.IntoParamAnnot)
-            && !printDebug
-        then atPrec(GlobalPrec):
-          "into[" ~ toText(tpe) ~ "]"
         else if annot.isInstanceOf[CaptureAnnotation] then
           toTextLocal(tpe) ~ "^" ~ toText(annot)
         else

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

@@ -833,7 +833,9 @@ class Namer { typer: Typer =>
     protected def typeSig(sym: Symbol): Type = original match
       case original: ValDef =>
         if (sym.is(Module)) moduleValSig(sym)
-        else valOrDefDefSig(original, sym, Nil, identity)(using localContext(sym).setNewScope)
+        else
+          valOrDefDefSig(original, sym, Nil, identity)(using localContext(sym).setNewScope)
+            .suppressIntoIfParam(sym)
       case original: DefDef =>
         // For the primary constructor DefDef, it is:
         // * indexed as a part of completing the class, with indexConstructor; and

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

@@ -374,52 +374,6 @@ 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)
@@ -653,8 +607,6 @@ 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) != intoOccurrences(otherTp) then
-        overrideError("has different occurrences of `into` modifiers", compareTypes = true)
       else if other.is(ParamAccessor) && !isInheritedAccessor(member, other)
            && !member.is(Tracked) // see remark on tracked members above
       then // (1.12)

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

@@ -2666,9 +2666,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           && checkedArgs(1).tpe.derivesFrom(defn.RuntimeExceptionClass)
       then
         report.error(em"throws clause cannot be defined for RuntimeException", checkedArgs(1).srcPos)
-      else if tycon == defn.IntoType then
-        // <into> is defined in package scala but this should be hidden from user programs
-        report.error(em"not found: <into>", tpt1.srcPos)
       else if (ctx.isJava)
         if tycon eq defn.ArrayClass then
           checkedArgs match {

compiler/test/dotc/run-test-pickling.excludelist

@@ -50,3 +50,5 @@ named-tuples-strawman-2.scala
 typeCheckErrors.scala
 i18150.scala
 
+# Pickling differences with local parameters export forwarders of methods with into parameters. But their external type is the same
+Parser.scala