Parse inline and implicit matches

Just syntax and parsing, no interpretation yet.

Author: odersky

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

@@ -20,6 +20,7 @@ import StdNames._
 import util.Positions._
 import Constants._
 import ScriptParsers._
+import Decorators._
 import scala.annotation.{tailrec, switch}
 import rewrites.Rewrites.patch
 
@@ -1101,8 +1102,8 @@ object Parsers {
      *                      |  Expr
      *  BlockResult       ::=  [FunArgMods] FunParams =>' Block
      *                      |  Expr1
-     *  Expr1             ::=  [‘inline’] `if' `(' Expr `)' {nl} Expr [[semi] else Expr]
-     *                      |  [‘inline’] `if' Expr `then' Expr [[semi] else Expr]
+     *  Expr1             ::=  `if' `(' Expr `)' {nl} Expr [[semi] else Expr]
+     *                      |  `if' Expr `then' Expr [[semi] else Expr]
      *                      |  `while' `(' Expr `)' {nl} Expr
      *                      |  `while' Expr `do' Expr
      *                      |  `do' Expr [semi] `while' Expr
@@ -1130,7 +1131,8 @@ object Parsers {
       val start = in.offset
       if (in.token == IMPLICIT || in.token == ERASED) {
         val imods = modifiers(funArgMods)
-        implicitClosure(start, location, imods)
+        if (in.token == MATCH) implicitMatch(start, imods)
+        else implicitClosure(start, location, imods)
       } else {
         val saved = placeholderParams
         placeholderParams = Nil
@@ -1210,7 +1212,13 @@ object Parsers {
       case FOR =>
         forExpr()
       case _ =>
-        expr1Rest(postfixExpr(), location)
+        if (isIdent(nme.INLINEkw)) {
+          val start = in.skipToken()
+          val t = postfixExpr()
+          accept(MATCH)
+          matchExpr(t, start, MatchKind.Inline)
+        }
+        else expr1Rest(postfixExpr(), location)
     }
 
     def expr1Rest(t: Tree, location: Location.Value): Tree = in.token match {
@@ -1224,7 +1232,7 @@ object Parsers {
       case COLON =>
         ascription(t, location)
       case MATCH =>
-        matchExpr(t, startOffset(t))
+        matchExpr(t, startOffset(t), MatchKind.Regular)
       case _ =>
         t
     }
@@ -1269,12 +1277,34 @@ object Parsers {
       }
 
     /**    `match' { CaseClauses }
-     *     `match' { ImplicitCaseClauses }
      */
-    def matchExpr(t: Tree, start: Offset): Match =
+    def matchExpr(t: Tree, start: Offset, kind: MatchKind): Match =
       atPos(start, in.skipToken()) {
-        inBraces(Match(t, caseClauses(caseClause)))
+        inBraces(Match(t, caseClauses(caseClause), kind))
+      }
+
+    /**    `match' { ImplicitCaseClauses }
+     */
+    def implicitMatch(start: Int, imods: Modifiers) = {
+      def markFirstIllegal(mods: List[Mod]) = mods match {
+        case mod :: _ => syntaxError(em"illegal modifier for implicit match", mod.pos)
+        case _ =>
       }
+      imods.mods match {
+        case Mod.Implicit() :: mods => markFirstIllegal(mods)
+        case mods => markFirstIllegal(mods)
+      }
+      val result @ Match(t, cases) = matchExpr(EmptyTree, start, MatchKind.Implicit)
+      for (CaseDef(pat, _, _) <- cases) {
+        def isImplicitPattern(pat: Tree) = pat match {
+          case Typed(pat1, _) => isVarPattern(pat1)
+          case pat => isVarPattern(pat)
+        }
+        if (!isImplicitPattern(pat))
+          syntaxError(em"not a legal pattern for an implicit match", pat.pos)
+      }
+      result
+    }
 
     /**    `match' { TypeCaseClauses }
      */
@@ -2617,6 +2647,8 @@ object Parsers {
             var imods = modifiers(funArgMods)
             if (isBindingIntro && !isIdent(nme.INLINEkw))
               stats += implicitClosure(start, Location.InBlock, imods)
+            else if (in.token == MATCH)
+              stats += implicitMatch(start, imods)
             else
               stats +++= localDef(start, imods)
           } else {

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

@@ -564,7 +564,8 @@ class Typer extends Namer
       def typedTpt = checkSimpleKinded(typedType(tree.tpt))
       def handlePattern: Tree = {
         val tpt1 = typedTpt
-        if (!ctx.isAfterTyper) constrainPatternType(tpt1.tpe, pt)(ctx.addMode(Mode.GADTflexible))
+        if (!ctx.isAfterTyper /* && pt != defn.ImplicitScrutineeTypeRef @@@ */)
+          constrainPatternType(tpt1.tpe, pt)(ctx.addMode(Mode.GADTflexible))
         // special case for an abstract type that comes with a class tag
         tryWithClassTag(ascription(tpt1, isWildcard = true), pt)
       }
@@ -970,6 +971,11 @@ class Typer extends Namer
         val (protoFormals, _) = decomposeProtoFunction(pt, 1)
         val unchecked = pt.isRef(defn.PartialFunctionClass)
         typed(desugar.makeCaseLambda(tree.cases, protoFormals.length, unchecked) withPos tree.pos, pt)
+      /* @@@ case id @ untpd.ImplicitScrutinee() =>
+        checkInInlineContext("implicit match", tree.pos)
+        val sel1 = id.withType(defn.ImplicitScrutineeTypeRef)
+        typedMatchFinish(tree, sel1, sel1.tpe, pt)
+      */
       case _ =>
         val sel1 = typedExpr(tree.selector)
         val selType = fullyDefinedType(sel1.tpe, "pattern selector", tree.pos).widen
@@ -1376,6 +1382,7 @@ class Typer extends Namer
             if (body1.tpe.isInstanceOf[TermRef]) pt1
             else body1.tpe.underlyingIfRepeated(isJava = false)
           val sym = ctx.newPatternBoundSymbol(tree.name, symTp, tree.pos)
+          // @@@ if (pt == defn.ImplicitScrutineeTypeRef) sym.setFlag(Implicit)
           if (ctx.mode.is(Mode.InPatternAlternative))
             ctx.error(i"Illegal variable ${sym.name} in pattern alternative", tree.pos)
           assignType(cpy.Bind(tree)(tree.name, body1), sym)

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

@@ -8,3 +8,4 @@ t8133
 t8133b
 tuples1.scala
 tuples1a.scala
+implicitMatch.scala

docs/docs/internals/syntax.md

@@ -177,7 +177,8 @@ Expr1             ::=  ‘if’ ‘(’ Expr ‘)’ {nl}
                     |  [SimpleExpr ‘.’] id ‘=’ Expr                             Assign(expr, expr)
                     |  SimpleExpr1 ArgumentExprs ‘=’ Expr                       Assign(expr, expr)
                     |  PostfixExpr [Ascription]
-                    |  PostfixExpr ‘match’ ‘{’ CaseClauses ‘}’                  Match(expr, cases) -- point on match
+                    |  [‘inline’] PostfixExpr ‘match’ ‘{’ CaseClauses ‘}’       Match(expr, cases) -- point on match
+                    |  ‘implicit’ ‘match’ ‘{’ ImplicitCaseClauses ‘}’
 Ascription        ::=  ‘:’ InfixType                                            Typed(expr, tp)
                     |  ‘:’ Annotation {Annotation}                              Typed(expr, Annotated(EmptyTree, annot)*)
 Catches           ::=  ‘catch’ Expr
@@ -226,6 +227,8 @@ Guard             ::=  ‘if’ PostfixExpr
 
 CaseClauses       ::=  CaseClause { CaseClause }                                Match(EmptyTree, cases)
 CaseClause        ::=  ‘case’ (Pattern [Guard] ‘=>’ Block | INT)                CaseDef(pat, guard?, block)   // block starts at =>
+ImplicitCaseClauses ::=  ImplicitCaseClause { ImplicitCaseClause }
+ImplicitCaseClause  ::=  ‘case’ PatVar [‘:’ RefinedType] [Guard] ‘=>’ Block
 TypeCaseClauses   ::=  TypeCaseClause { TypeCaseClause }
 TypeCaseClause    ::=  ‘case’ InfixType ‘=>’ Type [nl]