New match kinds: inline, implicit

Introduce trees for inline and implicit matches

Author: odersky

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

@@ -512,11 +512,18 @@ object Trees {
   }
 
   /** selector match { cases } */
-  case class Match[-T >: Untyped] private[ast] (selector: Tree[T], cases: List[CaseDef[T]])
+  case class Match[-T >: Untyped] private[ast] (selector: Tree[T], cases: List[CaseDef[T]])(val kind: MatchKind)
     extends TermTree[T] {
     type ThisTree[-T >: Untyped] = Match[T]
   }
 
+  type MatchKind = Int
+  object MatchKind {
+    val Regular = 0
+    val Inline = 1
+    val Implicit = 2
+  }
+
   /** case pat if guard => body; only appears as child of a Match */
   case class CaseDef[-T >: Untyped] private[ast] (pat: Tree[T], guard: Tree[T], body: Tree[T])
     extends Tree[T] {
@@ -1037,7 +1044,9 @@ object Trees {
         case _ => finalize(tree, untpd.Closure(env, meth, tpt))
       }
       def Match(tree: Tree)(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match = tree match {
-        case tree: Match if (selector eq tree.selector) && (cases eq tree.cases) => tree
+        case tree: Match =>
+          if ((selector eq tree.selector) && (cases eq tree.cases)) tree
+          else finalize(tree, untpd.Match(selector, cases, tree.kind))
         case _ => finalize(tree, untpd.Match(selector, cases))
       }
       def CaseDef(tree: Tree)(pat: Tree, guard: Tree, body: Tree)(implicit ctx: Context): CaseDef = tree match {

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

@@ -118,7 +118,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def CaseDef(pat: Tree, guard: Tree, body: Tree)(implicit ctx: Context): CaseDef =
     ta.assignType(untpd.CaseDef(pat, guard, body), pat, body)
 
-  def Match(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match =
+  def Match(selector: Tree, cases: List[CaseDef], kind: MatchKind = MatchKind.Regular)(implicit ctx: Context): Match =
     ta.assignType(untpd.Match(selector, cases), selector, cases)
 
   def Labeled(bind: Bind, expr: Tree)(implicit ctx: Context): Labeled =

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

@@ -272,7 +272,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def Block(stats: List[Tree], expr: Tree): Block = new Block(stats, expr)
   def If(cond: Tree, thenp: Tree, elsep: Tree): If = new If(cond, thenp, elsep)
   def Closure(env: List[Tree], meth: Tree, tpt: Tree): Closure = new Closure(env, meth, tpt)
-  def Match(selector: Tree, cases: List[CaseDef]): Match = new Match(selector, cases)
+  def Match(selector: Tree, cases: List[CaseDef], kind: MatchKind = MatchKind.Regular): Match = new Match(selector, cases)(kind)
   def CaseDef(pat: Tree, guard: Tree, body: Tree): CaseDef = new CaseDef(pat, guard, body)
   def Labeled(bind: Bind, expr: Tree): Labeled = new Labeled(bind, expr)
   def Return(expr: Tree, from: Tree): Return = new Return(expr, from)

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

@@ -90,6 +90,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   LAMBDA         Length meth_Term target_Type?
                   IF             Length cond_Term then_Term else_Term
                   MATCH          Length sel_Term CaseDef*
+                  INLINEMATCH    Length (sel_Term | IMPLICIT) CaseDef*
                   TRY            Length expr_Term CaseDef* finalizer_Term?
                   RETURN         Length meth_ASTRef expr_Term?
                   WHILE          Length cond_Term body_Term
@@ -236,7 +237,7 @@ Standard Section: "Comments" Comment*
 object TastyFormat {
 
   final val header: Array[Int] = Array(0x5C, 0xA1, 0xAB, 0x1F)
-  val MajorVersion: Int = 11
+  val MajorVersion: Int = 13
   val MinorVersion: Int = 0
 
   /** Tags used to serialize names */
@@ -380,39 +381,41 @@ object TastyFormat {
   final val IF = 141
   final val LAMBDA = 142
   final val MATCH = 143
-  final val RETURN = 144
-  final val WHILE = 145
-  final val TRY = 146
-  final val INLINED = 147
-  final val SELECTouter = 148
-  final val REPEATED = 149
-  final val BIND = 150
-  final val ALTERNATIVE = 151
-  final val UNAPPLY = 152
-  final val ANNOTATEDtype = 153
-  final val ANNOTATEDtpt = 154
-  final val CASEDEF = 155
-  final val TEMPLATE = 156
-  final val SUPER = 157
-  final val SUPERtype = 158
-  final val REFINEDtype = 159
-  final val REFINEDtpt = 160
-  final val APPLIEDtype = 161
-  final val APPLIEDtpt = 162
-  final val TYPEBOUNDS = 163
-  final val TYPEBOUNDStpt = 164
-  final val ANDtype = 165
-  final val ANDtpt = 166
-  final val ORtype = 167
-  final val ORtpt = 168
-  final val POLYtype = 169
-  final val TYPELAMBDAtype = 170
-  final val LAMBDAtpt = 171
-  final val PARAMtype = 172
-  final val ANNOTATION = 173
-  final val TERMREFin = 174
-  final val TYPEREFin = 175
-  final val OBJECTDEF = 176
+  final val INLINEMATCH = 144
+
+  final val RETURN = 146
+  final val WHILE = 147
+  final val TRY = 148
+  final val INLINED = 149
+  final val SELECTouter = 150
+  final val REPEATED = 151
+  final val BIND = 152
+  final val ALTERNATIVE = 153
+  final val UNAPPLY = 154
+  final val ANNOTATEDtype = 155
+  final val ANNOTATEDtpt = 156
+  final val CASEDEF = 157
+  final val TEMPLATE = 158
+  final val SUPER = 159
+  final val SUPERtype = 160
+  final val REFINEDtype = 161
+  final val REFINEDtpt = 162
+  final val APPLIEDtype = 163
+  final val APPLIEDtpt = 164
+  final val TYPEBOUNDS = 165
+  final val TYPEBOUNDStpt = 166
+  final val ANDtype = 167
+  final val ANDtpt = 168
+  final val ORtype = 169
+  final val ORtpt = 170
+  final val POLYtype = 171
+  final val TYPELAMBDAtype = 172
+  final val LAMBDAtpt = 173
+  final val PARAMtype = 174
+  final val ANNOTATION = 175
+  final val TERMREFin = 176
+  final val TYPEREFin = 177
+  final val OBJECTDEF = 178
 
   // In binary: 101101EI
   // I = implicit method type
@@ -587,6 +590,7 @@ object TastyFormat {
     case IF => "IF"
     case LAMBDA => "LAMBDA"
     case MATCH => "MATCH"
+    case INLINEMATCH => "INLINEMATCH"
     case RETURN => "RETURN"
     case WHILE => "WHILE"
     case INLINED => "INLINED"

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

@@ -424,9 +424,13 @@ class TreePickler(pickler: TastyPickler) {
             pickleTree(meth)
             if (tpt.tpe.exists) pickleTpt(tpt)
           }
-        case Match(selector, cases) =>
-          writeByte(MATCH)
-          withLength { pickleTree(selector); cases.foreach(pickleTree) }
+        case mtch @ Match(selector, cases) =>
+          writeByte(if (mtch.kind == MatchKind.Regular) MATCH else INLINEMATCH)
+          withLength {
+            if (mtch.kind == MatchKind.Implicit) writeByte(IMPLICIT)
+            else pickleTree(selector)
+            cases.foreach(pickleTree)
+          }
         case CaseDef(pat, guard, rhs) =>
           writeByte(CASEDEF)
           withLength { pickleTree(pat); pickleTree(rhs); pickleTreeUnlessEmpty(guard) }

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

@@ -1088,6 +1088,12 @@ class TreeUnpickler(reader: TastyReader,
               Closure(Nil, meth, tpt)
             case MATCH =>
               Match(readTerm(), readCases(end))
+            case INLINEMATCH =>
+              if (nextByte == IMPLICIT) {
+                readByte()
+                Match(EmptyTree, readCases(end), MatchKind.Implicit)
+              }
+              else Match(readTerm(), readCases(end), MatchKind.Inline)
             case RETURN =>
               val from = readSymRef()
               val expr = ifBefore(end)(readTerm(), EmptyTree)