Parsing and desugaring of new into modifier on parameter types

Author: odersky

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

@@ -178,21 +178,7 @@ object desugar {
     val valName = normalizeName(vdef, tpt).asTermName
     var mods1 = vdef.mods
 
-    def dropInto(tpt: Tree): Tree = tpt match
-      case Into(tpt1) =>
-        mods1 = vdef.mods.withAddedAnnotation(
-          TypedSplice(
-            Annotation(defn.AllowConversionsAnnot, tpt.span.startPos).tree))
-        tpt1
-      case ByNameTypeTree(tpt1) =>
-        cpy.ByNameTypeTree(tpt)(dropInto(tpt1))
-      case PostfixOp(tpt1, op) if op.name == tpnme.raw.STAR =>
-        cpy.PostfixOp(tpt)(dropInto(tpt1), op)
-      case _ =>
-        tpt
-
-    val vdef1 = cpy.ValDef(vdef)(name = valName, tpt = dropInto(tpt))
-      .withMods(mods1)
+    val vdef1 = cpy.ValDef(vdef)(name = valName).withMods(mods1)
 
     if isSetterNeeded(vdef) then
       val setterParam = makeSyntheticParameter(tpt = SetterParamTree().watching(vdef))
@@ -1876,8 +1862,11 @@ object desugar {
           assert(ctx.mode.isExpr || ctx.reporter.errorsReported || ctx.mode.is(Mode.Interactive), ctx.mode)
           Select(t, op.name)
       case PrefixOp(op, t) =>
-        val nspace = if (ctx.mode.is(Mode.Type)) tpnme else nme
-        Select(t, nspace.UNARY_PREFIX ++ op.name)
+        if op.name == tpnme.into then
+          Annotated(t, New(ref(defn.IntoAnnot.typeRef), Nil :: Nil))
+        else
+          val nspace = if (ctx.mode.is(Mode.Type)) tpnme else nme
+          Select(t, nspace.UNARY_PREFIX ++ op.name)
       case ForDo(enums, body) =>
         makeFor(nme.foreach, nme.foreach, enums, body) orElse tree
       case ForYield(enums, body) =>

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

@@ -304,6 +304,7 @@ object Trees {
 
     def withFlags(flags: FlagSet): ThisTree[Untyped] = withMods(untpd.Modifiers(flags))
     def withAddedFlags(flags: FlagSet): ThisTree[Untyped] = withMods(rawMods | flags)
+    def withAddedAnnotation(annot: Tree[Untyped]): ThisTree[Untyped] = withMods(rawMods.withAddedAnnotation(annot))
 
     /** Destructively update modifiers. To be used with care. */
     def setMods(mods: untpd.Modifiers): Unit = myMods = mods

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

@@ -118,7 +118,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   case class ContextBounds(bounds: TypeBoundsTree, cxBounds: List[Tree])(implicit @constructorOnly src: SourceFile) extends TypTree
   case class PatDef(mods: Modifiers, pats: List[Tree], tpt: Tree, rhs: Tree)(implicit @constructorOnly src: SourceFile) extends DefTree
   case class ExtMethods(paramss: List[ParamClause], methods: List[Tree])(implicit @constructorOnly src: SourceFile) extends Tree
-  case class Into(tpt: Tree)(implicit @constructorOnly src: SourceFile) extends Tree
   case class MacroTree(expr: Tree)(implicit @constructorOnly src: SourceFile) extends Tree
 
   case class ImportSelector(imported: Ident, renamed: Tree = EmptyTree, bound: Tree = EmptyTree)(implicit @constructorOnly src: SourceFile) extends Tree {
@@ -552,6 +551,12 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     ValDef(nme.syntheticParamName(n), if (tpt == null) TypeTree() else tpt, EmptyTree)
       .withFlags(flags)
 
+  def isInto(t: Tree)(using Context): Boolean = t match
+    case PrefixOp(Ident(tpnme.into), _) => true
+    case Function(_, res) => isInto(res)
+    case Parens(t) => isInto(t)
+    case _ => false
+
   def lambdaAbstract(params: List[ValDef] | List[TypeDef], tpt: Tree)(using Context): Tree =
     params match
       case Nil               => tpt
@@ -666,9 +671,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     def ExtMethods(tree: Tree)(paramss: List[ParamClause], methods: List[Tree])(using Context): Tree = tree match
       case tree: ExtMethods if (paramss eq tree.paramss) && (methods == tree.methods) => tree
       case _ => finalize(tree, untpd.ExtMethods(paramss, methods)(tree.source))
-    def Into(tree: Tree)(tpt: Tree)(using Context): Tree = tree match
-      case tree: Into if tpt eq tree.tpt => tree
-      case _ => finalize(tree, untpd.Into(tpt)(tree.source))
     def ImportSelector(tree: Tree)(imported: Ident, renamed: Tree, bound: Tree)(using Context): Tree = tree match {
       case tree: ImportSelector if (imported eq tree.imported) && (renamed eq tree.renamed) && (bound eq tree.bound) => tree
       case _ => finalize(tree, untpd.ImportSelector(imported, renamed, bound)(tree.source))
@@ -734,8 +736,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         cpy.PatDef(tree)(mods, transform(pats), transform(tpt), transform(rhs))
       case ExtMethods(paramss, methods) =>
         cpy.ExtMethods(tree)(transformParamss(paramss), transformSub(methods))
-      case Into(tpt) =>
-        cpy.Into(tree)(transform(tpt))
       case ImportSelector(imported, renamed, bound) =>
         cpy.ImportSelector(tree)(transformSub(imported), transform(renamed), transform(bound))
       case Number(_, _) | TypedSplice(_) =>
@@ -791,8 +791,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         this(this(this(x, pats), tpt), rhs)
       case ExtMethods(paramss, methods) =>
         this(paramss.foldLeft(x)(apply), methods)
-      case Into(tpt) =>
-        this(x, tpt)
       case ImportSelector(imported, renamed, bound) =>
         this(this(this(x, imported), renamed), bound)
       case Number(_, _) =>

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

@@ -642,8 +642,6 @@ class Definitions {
 
   @tu lazy val RepeatedParamClass: ClassSymbol = enterSpecialPolyClass(tpnme.REPEATED_PARAM_CLASS, Covariant, Seq(ObjectType, SeqType))
 
-  @tu lazy val IntoType: TypeSymbol = enterAliasType(tpnme.INTO, HKTypeLambda(TypeBounds.empty :: Nil)(_.paramRefs(0)))
-
   // fundamental classes
   @tu lazy val StringClass: ClassSymbol = requiredClass("java.lang.String")
   def StringType: Type = StringClass.typeRef
@@ -1002,7 +1000,6 @@ class Definitions {
   @tu lazy val JavaAnnotationClass: ClassSymbol = requiredClass("java.lang.annotation.Annotation")
 
   // Annotation classes
-  @tu lazy val AllowConversionsAnnot: ClassSymbol = requiredClass("scala.annotation.allowConversions")
   @tu lazy val AnnotationDefaultAnnot: ClassSymbol = requiredClass("scala.annotation.internal.AnnotationDefault")
   @tu lazy val AssignedNonLocallyAnnot: ClassSymbol = requiredClass("scala.annotation.internal.AssignedNonLocally")
   @tu lazy val BeanPropertyAnnot: ClassSymbol = requiredClass("scala.beans.BeanProperty")
@@ -1018,6 +1015,7 @@ 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.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")
@@ -2137,7 +2135,6 @@ class Definitions {
       orType,
       RepeatedParamClass,
       ByNameParamClass2x,
-      IntoType,
       AnyValClass,
       NullClass,
       NothingClass,

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

@@ -131,7 +131,7 @@ object StdNames {
     val EXCEPTION_RESULT_PREFIX: N    = "exceptionResult"
     val EXPAND_SEPARATOR: N           = str.EXPAND_SEPARATOR
     val IMPORT: N                     = "<import>"
-    val INTO: N                       = "<into>"
+    val INTO: N                       = "$into"
     val MODULE_SUFFIX: N              = str.MODULE_SUFFIX
     val OPS_PACKAGE: N                = "<special-ops>"
     val OVERLOADED: N                 = "<overloaded>"

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

@@ -419,8 +419,8 @@ object Types extends TypeUtils {
       typeSymbol eq defn.RepeatedParamClass
 
     /** Is this a parameter type that allows implicit argument converson? */
-    def isConvertibleParam(using Context): Boolean =
-      typeSymbol eq defn.IntoType
+    def isInto(using Context): Boolean =
+      typeSymbol eq ???
 
     /** Is this the type of a method that has a repeated parameter type as
      *  last parameter type?
@@ -4131,34 +4131,14 @@ object Types extends TypeUtils {
         case ExprType(resType) => ExprType(addAnnotation(resType, cls, param))
         case _ => AnnotatedType(tp, Annotation(cls, param.span))
 
-      def wrapConvertible(tp: Type) =
-        AppliedType(defn.IntoType.typeRef, tp :: Nil)
-
-      /** Add `Into[..] to the type itself and if it is a function type, to all its
-       *  curried result type(s) as well.
-       */
-      def addInto(tp: Type): Type = tp match
-        case tp @ AppliedType(tycon, args) if tycon.typeSymbol == defn.RepeatedParamClass =>
-          tp.derivedAppliedType(tycon, addInto(args.head) :: Nil)
-        case tp @ AppliedType(tycon, args) if defn.isFunctionNType(tp) =>
-          wrapConvertible(tp.derivedAppliedType(tycon, args.init :+ addInto(args.last)))
-        case tp @ defn.RefinedFunctionOf(rinfo) =>
-          wrapConvertible(tp.derivedRefinedType(refinedInfo = addInto(rinfo)))
-        case tp: MethodOrPoly =>
-          tp.derivedLambdaType(resType = addInto(tp.resType))
-        case ExprType(resType) =>
-          ExprType(addInto(resType))
-        case _ =>
-          wrapConvertible(tp)
-
       def paramInfo(param: Symbol) =
-        var paramType = param.info.annotatedToRepeated
+        var paramType = param.info
+          .annotatedToRepeated
+          //.mapIntoAnnot(defn.IntoType.appliedTo(_))
         if param.is(Inline) then
           paramType = addAnnotation(paramType, defn.InlineParamAnnot, param)
         if param.is(Erased) then
           paramType = addAnnotation(paramType, defn.ErasedParamAnnot, param)
-        if param.hasAnnotation(defn.AllowConversionsAnnot) then
-          paramType = addInto(paramType)
         paramType
 
       apply(params.map(_.name.asTermName))(

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

@@ -73,6 +73,9 @@ object Parsers {
   enum ParseKind:
     case Expr, Type, Pattern
 
+  enum IntoOK:
+    case Yes, No, Nested
+
   type StageKind = Int
   object StageKind {
     val None = 0
@@ -1484,7 +1487,7 @@ object Parsers {
     /** Same as [[typ]], but if this results in a wildcard it emits a syntax error and
      *  returns a tree for type `Any` instead.
      */
-    def toplevelTyp(): Tree = rejectWildcardType(typ())
+    def toplevelTyp(intoOK: IntoOK = IntoOK.No): Tree = rejectWildcardType(typ(intoOK))
 
     private def getFunction(tree: Tree): Option[Function] = tree match {
       case Parens(tree1) => getFunction(tree1)
@@ -1535,12 +1538,21 @@ object Parsers {
      *                   |  `(' [ FunArgType {`,' FunArgType } ] `)'
      *                   |  '(' [ TypedFunParam {',' TypedFunParam } ')'
      *  MatchType      ::=  InfixType `match` <<< TypeCaseClauses >>>
+     *  IntoType       ::=  [‘into’] IntoTargetType
+     *                   |  ‘( IntoType ‘)’
+     *  IntoTargetType ::=  Type
+     *                   |  FunTypeArgs (‘=>’ | ‘?=>’) IntoType
      */
-    def typ(): Tree =
+    def typ(intoOK: IntoOK = IntoOK.No): Tree =
       val start = in.offset
       var imods = Modifiers()
       val erasedArgs: ListBuffer[Boolean] = ListBuffer()
 
+      def nestedIntoOK(token: Int) =
+        if token == TLARROW then IntoOK.No
+        else if intoOK == IntoOK.Nested then IntoOK.Yes
+        else intoOK
+
       def functionRest(params: List[Tree]): Tree =
         val paramSpan = Span(start, in.lastOffset)
         atSpan(start, in.offset) {
@@ -1569,8 +1581,9 @@ object Parsers {
           else
             accept(ARROW)
 
+          def resType() = typ(nestedIntoOK(token))
           val resultType =
-            if isPure then capturesAndResult(typ) else typ()
+            if isPure then capturesAndResult(resType) else resType()
           if token == TLARROW then
             for case ValDef(_, tpt, _) <- params do
               if isByNameType(tpt) then
@@ -1605,6 +1618,12 @@ object Parsers {
             syntaxError(ErasedTypesCanOnlyBeFunctionTypes(), implicitKwPos(start))
           t
 
+      def isIntoPrefix: Boolean =
+        intoOK == IntoOK.Yes
+        && in.isIdent(nme.into)
+        && in.featureEnabled(Feature.into)
+        && canStartTypeTokens.contains(in.lookahead.token)
+
       var isValParamList = false
       if in.token == LPAREN then
         in.nextToken()
@@ -1635,17 +1654,36 @@ object Parsers {
                     funArgType()
                   commaSeparatedRest(t, funArg)
           accept(RPAREN)
+
+          val intoAllowed =
+            intoOK == IntoOK.Yes
+            && args.lengthCompare(1) == 0
+            && (!canFollowSimpleTypeTokens.contains(in.token) || followingIsVararg())
+          val byNameAllowed = in.isArrow || isPureArrow
+
+          def sanitize(arg: Tree): Tree = arg match
+            case ByNameTypeTree(t) if !byNameAllowed =>
+              syntaxError(ByNameParameterNotSupported(t), t.span)
+              t
+            case PrefixOp(id @ Ident(tpnme.into), t) if !intoAllowed =>
+              syntaxError(em"no `into` modifier allowed here", id.span)
+              t
+            case Parens(t) =>
+              cpy.Parens(arg)(sanitize(t))
+            case arg: FunctionWithMods =>
+              val body1 = sanitize(arg.body)
+              if body1 eq arg.body then arg
+              else FunctionWithMods(arg.args, body1, arg.mods, arg.erasedParams).withSpan(arg.span)
+            case Function(args, res) if !intoAllowed =>
+              cpy.Function(arg)(args, sanitize(res))
+            case arg =>
+              arg
+
+          val args1 = args.mapConserve(sanitize)
           if isValParamList || in.isArrow || isPureArrow then
             functionRest(args)
           else
-            val args1 = args.mapConserve: t =>
-              if isByNameType(t) then
-                syntaxError(ByNameParameterNotSupported(t), t.span)
-                stripByNameType(t)
-              else
-                t
-            val tuple = atSpan(start):
-              makeTupleOrParens(args1)
+            val tuple = atSpan(start)(makeTupleOrParens(args1))
             typeRest:
               infixTypeRest:
                 refinedTypeRest:
@@ -1660,7 +1698,7 @@ object Parsers {
             LambdaTypeTree(tparams, toplevelTyp())
         else if in.token == ARROW || isPureArrow(nme.PUREARROW) then
           val arrowOffset = in.skipToken()
-          val body = toplevelTyp()
+          val body = toplevelTyp(nestedIntoOK(in.token))
           atSpan(start, arrowOffset):
             getFunction(body) match
               case Some(f) =>
@@ -1673,6 +1711,8 @@ object Parsers {
           typ()
       else if in.token == INDENT then
         enclosed(INDENT, typ())
+      else if isIntoPrefix then
+        PrefixOp(typeIdent(), typ(IntoOK.Nested))
       else
         typeRest(infixType())
     end typ
@@ -2047,18 +2087,13 @@ object Parsers {
       else
         core()
 
-    private def maybeInto(tp: () => Tree) =
-      if in.isIdent(nme.into)
-          && in.featureEnabled(Feature.into)
-          && canStartTypeTokens.contains(in.lookahead.token)
-      then atSpan(in.skipToken()) { Into(tp()) }
-      else tp()
-
     /** FunArgType ::=  Type
      *               |  `=>' Type
      *               |  `->' [CaptureSet] Type
      */
-    val funArgType: () => Tree = () => paramTypeOf(typ)
+    val funArgType: () => Tree =
+      () => paramTypeOf(() => typ(IntoOK.Yes))
+        // We allow intoOK and filter out afterwards in typ()
 
     /** ParamType  ::=  ParamValueType
      *               |  `=>' ParamValueType
@@ -2067,15 +2102,21 @@ object Parsers {
     def paramType(): Tree = paramTypeOf(paramValueType)
 
     /** ParamValueType ::= Type [`*']
+     *                   | IntoType
+     *                   | ‘(’ IntoType ‘)’ `*'
      */
-    def paramValueType(): Tree = {
-      val t = maybeInto(toplevelTyp)
-      if (isIdent(nme.raw.STAR)) {
+    def paramValueType(): Tree =
+      val t = toplevelTyp(IntoOK.Yes)
+      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)) }
-      }
+        atSpan(startOffset(t)):
+          PostfixOp(t, Ident(tpnme.raw.STAR))
       else t
-    }
 
     /** TypeArgs      ::= `[' Type {`,' Type} `]'
      *  NamedTypeArgs ::= `[' NamedTypeArg {`,' NamedTypeArg} `]'
@@ -3315,7 +3356,7 @@ object Parsers {
     /** ContextTypes   ::=  FunArgType {‘,’ FunArgType}
      */
     def contextTypes(paramOwner: ParamOwner, numLeadParams: Int, impliedMods: Modifiers): List[ValDef] =
-      val tps = commaSeparated(() => paramTypeOf(toplevelTyp))
+      val tps = commaSeparated(() => paramTypeOf(() => toplevelTyp()))
       var counter = numLeadParams
       def nextIdx = { counter += 1; counter }
       val paramFlags = if paramOwner.isClass then LocalParamAccessor else Param

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

@@ -238,6 +238,9 @@ object Tokens extends TokensCommon {
 
   final val canStartPatternTokens = atomicExprTokens | openParensTokens | BitSet(USCORE, QUOTE)
 
+  val canFollowSimpleTypeTokens =
+    BitSet(AT, WITH, COLONop, COLONfollow, COLONeol, LBRACE, IDENTIFIER, BACKQUOTED_IDENT, ARROW, CTXARROW, MATCH, FORSOME)
+
   final val templateIntroTokens: TokenSet = BitSet(CLASS, TRAIT, OBJECT, ENUM, CASECLASS, CASEOBJECT)
 
   final val dclIntroTokens: TokenSet = BitSet(DEF, VAL, VAR, TYPE, GIVEN)

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

@@ -285,7 +285,11 @@ class PlainPrinter(_ctx: Context) extends Printer {
           toTextGlobal(tp.resultType)
         }
       case AnnotatedType(tpe, annot) =>
-        if annot.symbol == defn.InlineParamAnnot || annot.symbol == defn.ErasedParamAnnot then toText(tpe)
+        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 toTextLocal(tpe) ~ " " ~ toText(annot)
       case tp: TypeVar =>
         def toTextCaret(tp: Type) = if printDebug then toTextLocal(tp) ~ Str("^") else toText(tp)