Change match syntax

`match` is treated like an alphabetic operator, can be appear infix as
well as after `.`.

Change the `inline` syntax from
```
inline if ...
inline s match ...
```
to
```
if inline ...
s match inline ...
```
this makes it work better with the new rules for `match`.

Author: odersky

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

@@ -951,7 +951,7 @@ object Parsers {
       recur(top)
     }
 
-    /**   operand { infixop operand | ‘given’ (operand | ParArgumentExprs) } [postfixop],
+    /**   operand { infixop operand | MatchClause } [postfixop],
      *
      *  respecting rules of associativity and precedence.
      *  @param isOperator    the current token counts as an operator.
@@ -981,18 +981,14 @@ object Parsers {
           }
           else recur(operand())
         }
-        else reduceStack(base, top, minPrec, leftAssoc = true, in.name, isType)
+        else
+          val t = reduceStack(base, top, minPrec, leftAssoc = true, in.name, isType)
+          if !isType && in.token == MATCH then recur(matchClause(t, t.span.start, Match))
+          else t
 
       recur(first)
     }
 
-    def applyGiven(t: Tree, operand: () => Tree): Tree =
-      atSpan(startOffset(t), in.offset) {
-        in.nextToken()
-        val args = if (in.token == LPAREN) parArgumentExprs()._1 else operand() :: Nil
-        Apply(t, args)
-      }.setGivenApply()
-
 /* -------- IDENTIFIERS AND LITERALS ------------------------------------------- */
 
     /** Accept identifier and return its name as a term name. */
@@ -1028,9 +1024,12 @@ object Parsers {
     def wildcardIdent(): Ident =
       atSpan(accept(USCORE)) { Ident(nme.WILDCARD) }
 
-    /** Accept identifier acting as a selector on given tree `t`. */
+    /** Accept identifier or match clause acting as a selector on given tree `t` */
     def selector(t: Tree): Tree =
-      atSpan(startOffset(t), in.offset) { Select(t, ident()) }
+      atSpan(startOffset(t), in.offset) {
+        if in.token == MATCH then matchClause(t, t.span.start, Match)
+        else Select(t, ident())
+      }
 
     /** Selectors ::= id { `.' id }
      *
@@ -1877,7 +1876,7 @@ object Parsers {
           }
         }
       case _ =>
-        if isIdent(nme.inline)
+        if isIdent(nme.inline)  // TODO: drop this clause
            && !in.inModifierPosition()
            && in.lookaheadIn(in.canStartExprTokens)
         then
@@ -1886,31 +1885,27 @@ object Parsers {
             case IF =>
               ifExpr(start, InlineIf)
             case _ =>
-              val t = postfixExpr()
-              if (in.token == MATCH) matchExpr(t, start, InlineMatch)
+              val t = prefixExpr()
+              if (in.token == MATCH) matchClause(t, start, InlineMatch)
               else
-                syntaxErrorOrIncomplete(i"`match` or `if` expected but ${in.token} found")
+                syntaxErrorOrIncomplete(i"`match` or `if` expected but ${in} found")
                 t
         else expr1Rest(postfixExpr(), location)
     }
 
-    def expr1Rest(t: Tree, location: Location.Value): Tree = in.token match {
+    def expr1Rest(t: Tree, location: Location.Value): Tree = in.token match
       case EQUALS =>
-         t match {
-           case Ident(_) | Select(_, _) | Apply(_, _) =>
-             atSpan(startOffset(t), in.skipToken()) { Assign(t, subExpr()) }
-           case _ =>
-             t
-         }
+        t match
+          case Ident(_) | Select(_, _) | Apply(_, _) =>
+            atSpan(startOffset(t), in.skipToken()) { Assign(t, subExpr()) }
+          case _ =>
+            t
       case COLON =>
         in.nextToken()
-        val t1 = ascription(t, location)
-        if (in.token == MATCH) expr1Rest(t1, location) else t1
-      case MATCH =>
-        matchExpr(t, startOffset(t), Match)
+        ascription(t, location)
       case _ =>
         t
-    }
+    end expr1Rest
 
     def ascription(t: Tree, location: Location.Value): Tree = atSpan(startOffset(t)) {
       in.token match {
@@ -1938,11 +1933,14 @@ object Parsers {
       }
     }
 
-    /**    `if' `(' Expr `)' {nl} Expr [[semi] else Expr]
-     *     `if' Expr `then' Expr [[semi] else Expr]
+    /**    `if' [‘inline’] `(' Expr `)' {nl} Expr [[semi] else Expr]
+     *     `if' [‘inline’] Expr `then' Expr [[semi] else Expr]
      */
-    def ifExpr(start: Offset, mkIf: (Tree, Tree, Tree) => If): If =
+    def ifExpr(start: Offset, mkIf0: (Tree, Tree, Tree) => If): If =
       atSpan(start, in.skipToken()) {
+        val mkIf =
+          if isIdent(nme.inline) then { in.nextToken(); InlineIf }
+          else mkIf0
         val cond = condExpr(THEN)
         newLinesOpt()
         val thenp = subExpr()
@@ -1951,11 +1949,14 @@ object Parsers {
         mkIf(cond, thenp, elsep)
       }
 
-    /**    `match' `{' CaseClauses `}'
+    /**    MatchClause ::= `match' [‘inline’] `{' CaseClauses `}'
      */
-    def matchExpr(t: Tree, start: Offset, mkMatch: (Tree, List[CaseDef]) => Match) =
+    def matchClause(t: Tree, start: Offset, mkMatch0: (Tree, List[CaseDef]) => Match) =
       in.endMarkerScope(MATCH) {
         atSpan(start, in.skipToken()) {
+          val mkMatch =
+            if isIdent(nme.inline) then { in.nextToken(); InlineMatch }
+            else mkMatch0
           mkMatch(t, inBracesOrIndented(caseClauses(caseClause)))
         }
       }
@@ -2032,7 +2033,7 @@ object Parsers {
     /** PostfixExpr   ::= InfixExpr [id [nl]]
      *  InfixExpr     ::= PrefixExpr
      *                  | InfixExpr id [nl] InfixExpr
-     *                  | InfixExpr ‘given’ (InfixExpr | ParArgumentExprs)
+     *                  | InfixExpr MatchClause
      */
     def postfixExpr(): Tree = postfixExprRest(prefixExpr())
 
@@ -2063,6 +2064,7 @@ object Parsers {
      *                 |  Path
      *                 |  `(' [ExprsInParens] `)'
      *                 |  SimpleExpr `.' id
+     *                 |  SimpleExpr `.' MatchClause
      *                 |  SimpleExpr (TypeArgs | NamedTypeArgs)
      *                 |  SimpleExpr1 ArgumentExprs
      *  Quoted        ::= ‘'’ ‘{’ Block ‘}’

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

@@ -525,7 +525,8 @@ object Scanners {
         else if (lastWidth != nextWidth)
           errorButContinue(spaceTabMismatchMsg(lastWidth, nextWidth))
       currentRegion match {
-        case Indented(curWidth, others, prefix, outer) if curWidth < nextWidth && !others.contains(nextWidth) =>
+        case Indented(curWidth, others, prefix, outer)
+        if curWidth < nextWidth && !others.contains(nextWidth) && nextWidth != lastWidth =>
           if (token == OUTDENT)
             errorButContinue(
               i"""The start of this line does not match any of the previous indentation widths.

docs/docs/internals/syntax.md

@@ -184,9 +184,8 @@ BlockResult       ::=  [‘implicit’] FunParams ‘=>’ Block
 FunParams         ::=  Bindings
                     |  id
                     |  ‘_’
-Expr1             ::=  ‘if’ ‘(’ Expr ‘)’ {nl}
-                       Expr [[semi] ‘else’ Expr]                                If(Parens(cond), thenp, elsep?)
-                    |  ‘if’ Expr ‘then’ Expr [[semi] ‘else’ Expr]               If(cond, thenp, elsep?)
+Expr1             ::=  ‘if’ [‘inline’]‘(’ Expr ‘)’ {nl} Expr [[semi] ‘else’ Expr] If(Parens(cond), thenp, elsep?)
+                    |  ‘if’ [‘inline’] Expr ‘then’ Expr [[semi] ‘else’ Expr]    If(cond, thenp, elsep?)
                     |  ‘while’ ‘(’ Expr ‘)’ {nl} Expr                           WhileDo(Parens(cond), body)
                     |  ‘while’ Expr ‘do’ Expr                                   WhileDo(cond, body)
                     |  ‘try’ Expr Catches [‘finally’ Expr]                      Try(expr, catches, expr?)
@@ -198,15 +197,15 @@ Expr1             ::=  ‘if’ ‘(’ Expr ‘)’ {nl}
                     |  [SimpleExpr ‘.’] id ‘=’ Expr                             Assign(expr, expr)
                     |  SimpleExpr1 ArgumentExprs ‘=’ Expr                       Assign(expr, expr)
                     |  Expr2
-                    |  [‘inline’] Expr2 ‘match’ ‘{’ CaseClauses ‘}’             Match(expr, cases) -- point on match
 Expr2             ::=  PostfixExpr [Ascription]
 Ascription        ::=  ‘:’ InfixType                                            Typed(expr, tp)
                     |  ‘:’ Annotation {Annotation}                              Typed(expr, Annotated(EmptyTree, annot)*)
 Catches           ::=  ‘catch’ (Expr | CaseClause)
 PostfixExpr       ::=  InfixExpr [id]                                           PostfixOp(expr, op)
 InfixExpr         ::=  PrefixExpr
                     |  InfixExpr id [nl] InfixExpr                              InfixOp(expr, op, expr)
-                    |  InfixExpr ‘given’ (InfixExpr | ParArgumentExprs)
+                    |  InfixExpr MatchClause
+MatchClause       ::=  ‘match’ [‘inline’] ‘{’ CaseClauses ‘}’                   Match(expr, cases)
 PrefixExpr        ::=  [‘-’ | ‘+’ | ‘~’ | ‘!’] SimpleExpr                       PrefixOp(expr, op)
 SimpleExpr        ::=  Path
                     |  Literal
@@ -219,6 +218,7 @@ SimpleExpr        ::=  Path
                     |  ‘new’ TemplateBody
                     |  ‘(’ ExprsInParens ‘)’                                    Parens(exprs)
                     |  SimpleExpr ‘.’ id                                        Select(expr, id)
+                    |  SimpleExpr ‘.’ MatchClause
                     |  SimpleExpr TypeArgs                                      TypeApply(expr, args)
                     |  SimpleExpr ArgumentExprs                                 Apply(expr, args)
                     |  SimpleExpr ‘_’                                           PostfixOp(expr, _)

docs/docs/reference/contextual/typeclasses.md

@@ -10,25 +10,22 @@ with canonical implementations defined by given instances. Here are some example
 ### Semigroups and monoids:
 
 ```scala
-trait SemiGroup[T] {
+trait SemiGroup[T] with
   def (x: T) combine (y: T): T
-}
-trait Monoid[T] extends SemiGroup[T] {
+
+trait Monoid[T] extends SemiGroup[T] with
   def unit: T
-}
-object Monoid {
+
+object Monoid with
   def apply[T](given Monoid[T]) = summon[Monoid[T]]
-}
 
-given Monoid[String] {
+given Monoid[String] with
   def (x: String) combine (y: String): String = x.concat(y)
   def unit: String = ""
-}
 
-given Monoid[Int] {
+given Monoid[Int] with
   def (x: Int) combine (y: Int): Int = x + y
   def unit: Int = 0
-}
 
 def sum[T: Monoid](xs: List[T]): T =
     xs.foldLeft(Monoid[T].unit)(_.combine(_))

tests/pos-special/fatal-warnings/unchecked-scrutinee.scala

@@ -1,5 +1,5 @@
 object Test {
-  List(1: @unchecked, 2, 3): @unchecked match {
+  (List(1: @unchecked, 2, 3): @unchecked) match {
     case a :: as =>
   }
 }

tests/pos/matches.scala

@@ -0,0 +1,20 @@
+package matches
+object Test with
+  2 min 3 match
+    case 2 => "OK"
+    case 3 => "?"
+  match
+    case "OK" =>
+    case "?" => assertFail()
+
+  val x = 4
+  if 2 < 3
+     || x.match
+          case 4 => true
+          case _ => false
+     || (2 + 2).match
+          case 4 => true
+          case _ => false
+  then
+    println("ok")
+end Test

tests/pos/multi-given.scala

@@ -4,3 +4,5 @@ trait C
 
 def fancy(given a: A, b: B, c: C) = "Fancy!"
 def foo(implicit a: A, b: B, c: C) = "foo"
+
+given A, B {}

tests/run/typeclass-derivation2.scala

@@ -293,7 +293,7 @@ object Pickler {
   }
 
   inline def pickleElems[Elems <: Tuple](buf: mutable.ListBuffer[Int], elems: Mirror, n: Int): Unit =
-    inline erasedValue[Elems] match {
+    erasedValue[Elems] match inline {
       case _: (elem *: elems1) =>
         tryPickle[elem](buf, elems(n).asInstanceOf[elem])
         pickleElems[elems1](buf, elems, n + 1)
@@ -304,9 +304,9 @@ object Pickler {
     pickleElems[Elems](buf, r.reflect(x), 0)
 
   inline def pickleCases[T, Alts <: Tuple](r: Reflected[T], buf: mutable.ListBuffer[Int], x: T, n: Int): Unit =
-    inline erasedValue[Alts] match {
+    erasedValue[Alts] match inline {
       case _: (Shape.Case[alt, elems] *: alts1) =>
-        inline typeOf[alt] match {
+        typeOf[alt] match inline {
           case _: Subtype[T] =>
             x match {
               case x: `alt` =>
@@ -326,7 +326,7 @@ object Pickler {
   }
 
   inline def unpickleElems[Elems <: Tuple](buf: mutable.ListBuffer[Int], elems: Array[AnyRef], n: Int): Unit =
-    inline erasedValue[Elems] match {
+    erasedValue[Elems] match inline {
       case _: (elem *: elems1) =>
         elems(n) = tryUnpickle[elem](buf).asInstanceOf[AnyRef]
         unpickleElems[elems1](buf, elems, n + 1)