Parsing of term lambdas

Author: odersky

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

@@ -669,6 +669,11 @@ object Trees {
     type ThisTree[-T >: Untyped] = LambdaTypeTree[T]
   }
 
+  case class TermLambdaTypeTree[-T >: Untyped] private[ast] (params: List[ValDef[T]], body: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends TypTree[T] {
+    type ThisTree[-T >: Untyped] = TermLambdaTypeTree[T]
+  }
+
   /** [bound] selector match { cases } */
   case class MatchTypeTree[-T >: Untyped] private[ast] (bound: Tree[T], selector: Tree[T], cases: List[CaseDef[T]])(implicit @constructorOnly src: SourceFile)
     extends TypTree[T] {
@@ -964,6 +969,7 @@ object Trees {
     type RefinedTypeTree = Trees.RefinedTypeTree[T]
     type AppliedTypeTree = Trees.AppliedTypeTree[T]
     type LambdaTypeTree = Trees.LambdaTypeTree[T]
+    type TermLambdaTypeTree = Trees.TermLambdaTypeTree[T]
     type MatchTypeTree = Trees.MatchTypeTree[T]
     type ByNameTypeTree = Trees.ByNameTypeTree[T]
     type TypeBoundsTree = Trees.TypeBoundsTree[T]
@@ -1135,6 +1141,10 @@ object Trees {
         case tree: LambdaTypeTree if (tparams eq tree.tparams) && (body eq tree.body) => tree
         case _ => finalize(tree, untpd.LambdaTypeTree(tparams, body)(sourceFile(tree)))
       }
+      def TermLambdaTypeTree(tree: Tree)(params: List[ValDef], body: Tree)(implicit ctx: Context): TermLambdaTypeTree = tree match {
+        case tree: TermLambdaTypeTree if (params eq tree.params) && (body eq tree.body) => tree
+        case _ => finalize(tree, untpd.TermLambdaTypeTree(params, body)(sourceFile(tree)))
+      }
       def MatchTypeTree(tree: Tree)(bound: Tree, selector: Tree, cases: List[CaseDef])(implicit ctx: Context): MatchTypeTree = tree match {
         case tree: MatchTypeTree if (bound eq tree.bound) && (selector eq tree.selector) && (cases eq tree.cases) => tree
         case _ => finalize(tree, untpd.MatchTypeTree(bound, selector, cases)(sourceFile(tree)))
@@ -1293,6 +1303,10 @@ object Trees {
               inContext(localCtx) {
                 cpy.LambdaTypeTree(tree)(transformSub(tparams), transform(body))
               }
+            case TermLambdaTypeTree(params, body) =>
+              inContext(localCtx) {
+                cpy.TermLambdaTypeTree(tree)(transformSub(params), transform(body))
+              }
             case MatchTypeTree(bound, selector, cases) =>
               cpy.MatchTypeTree(tree)(transform(bound), transform(selector), transformSub(cases))
             case ByNameTypeTree(result) =>
@@ -1422,6 +1436,10 @@ object Trees {
               inContext(localCtx) {
                 this(this(x, tparams), body)
               }
+            case TermLambdaTypeTree(params, body) =>
+              inContext(localCtx) {
+                this(this(x, params), body)
+              }
             case MatchTypeTree(bound, selector, cases) =>
               this(this(this(x, bound), selector), cases)
             case ByNameTypeTree(result) =>

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

@@ -377,6 +377,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def RefinedTypeTree(tpt: Tree, refinements: List[Tree])(implicit src: SourceFile): RefinedTypeTree = new RefinedTypeTree(tpt, refinements)
   def AppliedTypeTree(tpt: Tree, args: List[Tree])(implicit src: SourceFile): AppliedTypeTree = new AppliedTypeTree(tpt, args)
   def LambdaTypeTree(tparams: List[TypeDef], body: Tree)(implicit src: SourceFile): LambdaTypeTree = new LambdaTypeTree(tparams, body)
+  def TermLambdaTypeTree(params: List[ValDef], body: Tree)(implicit src: SourceFile): TermLambdaTypeTree = new TermLambdaTypeTree(params, body)
   def MatchTypeTree(bound: Tree, selector: Tree, cases: List[CaseDef])(implicit src: SourceFile): MatchTypeTree = new MatchTypeTree(bound, selector, cases)
   def ByNameTypeTree(result: Tree)(implicit src: SourceFile): ByNameTypeTree = new ByNameTypeTree(result)
   def TypeBoundsTree(lo: Tree, hi: Tree, alias: Tree = EmptyTree)(implicit src: SourceFile): TypeBoundsTree = new TypeBoundsTree(lo, hi, alias)

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

@@ -1360,6 +1360,7 @@ object Parsers {
 
     /** Type        ::=  FunType
      *                |  HkTypeParamClause ‘=>>’ Type
+     *                |  ‘(’ TypedFunParams ‘)’ ‘=>>’ Type
      *                |  MatchType
      *                |  InfixType
      *  FunType     ::=  (MonoFunType | PolyFunType)
@@ -1374,6 +1375,16 @@ object Parsers {
       var imods = Modifiers()
       def functionRest(params: List[Tree]): Tree =
         atSpan(start, in.offset) {
+          if in.token == TLARROW then
+            if !imods.flags.isEmpty || params.isEmpty then
+              syntaxError(em"illegal parameter list for type lambda", start)
+              in.token = ARROW
+            else
+              for case ValDef(_, tpt: ByNameTypeTree, _) <- params do
+                syntaxError(em"parameter of type lambda may not be call-by-name", tpt.span)
+              in.nextToken()
+              return TermLambdaTypeTree(params.asInstanceOf[List[ValDef]], typ())
+
           if in.token == CTXARROW then
             in.nextToken()
             imods |= Given

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

@@ -486,6 +486,10 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         changePrec(GlobalPrec) {
           tparamsText(tparams) ~ " =>> " ~ toText(body)
         }
+      case TermLambdaTypeTree(params, body) =>
+        changePrec(GlobalPrec) {
+          paramsText(params) ~ " =>> " ~ toText(body)
+        }
       case MatchTypeTree(bound, sel, cases) =>
         changePrec(GlobalPrec) {
           toText(sel) ~ keywordStr(" match ") ~ blockText(cases) ~

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

@@ -146,5 +146,9 @@ object ErrorReporting {
       else ""
   }
 
+  def dependentStr =
+    """Term-dependent types are experimental,
+      |they must be enabled with a `experimental.dependent` language import or setting""".stripMargin
+
   def err(using Context): Errors = new Errors
 }

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

@@ -1578,6 +1578,14 @@ class Typer extends Namer
   }
 
   def typedAppliedTypeTree(tree: untpd.AppliedTypeTree)(using Context): Tree = {
+    tree.args match
+      case arg :: _ if arg.isTerm =>
+        if dependentEnabled then
+          return errorTree(tree, i"Not yet implemented: T(...)")
+        else
+          return errorTree(tree, dependentStr)
+      case _ =>
+
     val tpt1 = typed(tree.tpt, AnyTypeConstructorProto)(using ctx.retractMode(Mode.Pattern))
     val tparams = tpt1.tpe.typeParams
     if (tparams.isEmpty) {
@@ -1654,6 +1662,12 @@ class Typer extends Namer
     assignType(cpy.LambdaTypeTree(tree)(tparams1, body1), tparams1, body1)
   }
 
+  def typedTermLambdaTypeTree(tree: untpd.TermLambdaTypeTree)(using Context): Tree =
+    if dependentEnabled then
+      errorTree(tree, i"Not yet implemented: (...) =>> ...")
+    else
+      errorTree(tree, dependentStr)
+
   def typedMatchTypeTree(tree: untpd.MatchTypeTree, pt: Type)(using Context): Tree = {
     val bound1 =
       if (tree.bound.isEmpty && isFullyDefined(pt, ForceDegree.none)) TypeTree(pt)
@@ -2369,6 +2383,7 @@ class Typer extends Namer
           case tree: untpd.RefinedTypeTree => typedRefinedTypeTree(tree)
           case tree: untpd.AppliedTypeTree => typedAppliedTypeTree(tree)
           case tree: untpd.LambdaTypeTree => typedLambdaTypeTree(tree)(using ctx.localContext(tree, NoSymbol).setNewScope)
+          case tree: untpd.TermLambdaTypeTree => typedTermLambdaTypeTree(tree)(using ctx.localContext(tree, NoSymbol).setNewScope)
           case tree: untpd.MatchTypeTree => typedMatchTypeTree(tree, pt)
           case tree: untpd.ByNameTypeTree => typedByNameTypeTree(tree)
           case tree: untpd.TypeBoundsTree => typedTypeBoundsTree(tree, pt)

tests/neg/deptypes-badsyntax.scala

@@ -0,0 +1,2 @@
+
+type Bad1[T] = () =>> Array[T] // error

tests/neg/deptypes.scala

@@ -0,0 +1,5 @@
+
+type Vec[T] = (n: Int) =>> Array[T] // error: needs to be enabled
+val x: Vec[Int](10) = ???  // error: needs to be enabled
+val n = 10
+type T = Vec[String](n)  // error: needs to be enabled