Fix #1846: add regression test

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

@@ -1564,7 +1564,6 @@ object Parsers {
      *                    |  `(' [Patterns] `)'
      *                    |  SimplePattern1 [TypeArgs] [ArgumentPatterns]
      *  SimplePattern1   ::= Path
-     *                    |  `{' Block `}'
      *                    |  SimplePattern1 `.' id
      *  PatVar           ::= id
      *                    |  `_'
@@ -1587,8 +1586,6 @@ object Parsers {
         } else wildIndent
       case LPAREN =>
         atPos(in.offset) { makeTupleOrParens(inParens(patternsOpt())) }
-      case LBRACE =>
-        dotSelectors(blockExpr())
       case XMLSTART =>
         xmlLiteralPattern()
       case _ =>

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

@@ -35,7 +35,8 @@ class ReTyper extends Typer {
 
   override def typedSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context): Tree = {
     assert(tree.hasType, tree)
-    val qual1 = typed(tree.qualifier, AnySelectionProto)
+    // a qualifier cannot be a pattern
+    val qual1 = typed(tree.qualifier, AnySelectionProto)(ctx.retractMode(Mode.Pattern))
     untpd.cpy.Select(tree)(qual1, tree.name).withType(tree.typeOpt)
   }
 

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

@@ -75,6 +75,21 @@ object RefChecks {
     }
   }
 
+  /** Check that a stable identifier pattern is indeed stable (SLS 8.1.5)
+   */
+  private def checkStableIdentPattern(tree: Tree)(implicit ctx: Context) = {
+    def error = ctx.error(s"stable identifier required, but ${tree.show} found", tree.pos)
+    tree match {
+      case _: Ident if !isWildcardArg(tree) =>
+        if (!tree.tpe.isStable) error
+      case _: Select =>
+        if (!tree.tpe.isStable) error
+      case _: Apply =>
+        error
+      case _ =>
+    }
+  }
+
   /** The this-type of `cls` which should be used when looking at the types of
    *  inherited members. If `cls` has a non-trivial self type, this returns a skolem
    *  with the class type instead of the `this-type` of the class as usual.
@@ -884,6 +899,26 @@ class RefChecks extends MiniPhase { thisPhase =>
     currentLevel.enterReference(sym, tree.pos)
     tree
   }
+
+  override def transformUnApply(tree: UnApply)(implicit ctx: Context): Tree = {
+    tree.patterns.foreach(checkStableIdentPattern(_))
+    tree
+  }
+
+  override def transformAlternative(tree: Alternative)(implicit ctx: Context): Tree = {
+    tree.trees.foreach(checkStableIdentPattern(_))
+    tree
+  }
+
+  override def transformBind(tree: Bind)(implicit ctx: Context): Tree = {
+     checkStableIdentPattern(tree.body)
+    tree
+  }
+
+  override def transformCaseDef(tree: CaseDef)(implicit ctx: Context) = {
+    checkStableIdentPattern(tree.pat)
+    tree
+  }
 }
 
 /* todo: rewrite and re-enable

docs/docs/internals/syntax.md

@@ -202,7 +202,7 @@ ParArgumentExprs  ::=  ‘(’ ExprsInParens ‘)’
                     |  ‘(’ [ExprsInParens] PostfixExpr ‘:’ ‘_’ ‘*’ ‘)’          exprs :+ Typed(expr, Ident(wildcardStar))
 ArgumentExprs     ::=  ParArgumentExprs
                     |  [nl] BlockExpr
-BlockExpr         ::=  ‘{’ BlockExprContents ‘}’                                
+BlockExpr         ::=  ‘{’ BlockExprContents ‘}’
 BlockExprContents ::=  CaseClauses | Block
 Block             ::=  {BlockStat semi} [BlockResult]                           Block(stats, expr?)
 BlockStat         ::=  Import
@@ -234,7 +234,6 @@ SimplePattern     ::=  PatVar
                     |  XmlPattern
                     |  SimplePattern1 [TypeArgs] [ArgumentPatterns]
 SimplePattern1    ::=  Path
-                    |  ‘{’ Block ‘}’
                     |  SimplePattern1 ‘.’ id
 PatVar            ::=  varid
                     |  ‘_’

tests/neg/i1846.scala

@@ -0,0 +1,19 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    val x = 42
+    val Y = "42"
+
+    x match { case { 42 }           => () } // error
+    x match { case { 42.toString }  => () } // error
+    x match { case { 42 }.toString  => () } // error
+    x match { case "42".toInt       => () } // error
+    x match { case { "42".toInt }   => () } // error
+    x match { case { "42" }.toInt   => () } // error
+    x match { case { "42".toInt }   => () } // error
+    x match { case Y                => () } // error
+    x match { case { Y.toInt }      => () } // error
+    x match { case { Y }.toInt      => () } // error
+    x match { case { Y }.toString   => () } // error
+    x match { case { Y.toString }   => () } // error
+  }
+}

tests/neg/i3812.scala

@@ -0,0 +1,13 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    val x = 42
+    val Y = "42"
+
+    x match { case { 42 }           => () } // error
+    x match { case { "42".toInt }   => () } // error
+    x match { case { "42" }.toInt   => () } // error
+    x match { case { "42".toInt }   => () } // error
+    x match { case { Y.toInt }      => () } // error
+    x match { case { Y }.toInt      => () } // error
+  }
+}

tests/neg/i3812b.scala

@@ -0,0 +1,27 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    case class Box(v: Int)
+
+    val x = 42
+    var Y1 = 42
+    val Y2 = "42"
+    var Z1 = Box(4)
+    val Z2 = Box(4)
+
+    x match { case Y1                => () } // error
+    x match { case Y2.toInt          => () } // error
+    x match { case Y1.toString       => () } // error
+
+    x match { case Z1.v              => () } // error
+    x match { case Z2.v              => () } // ok
+
+    Some(x) match { case Some(Z1.v)  => () } // error
+    Some(x) match { case Some(Z2.v)  => () } // ok
+
+    Some(x) match { case Some(4) | Some(Z1.v) => () } // error
+    Some(x) match { case a @ Some(Z1.v)       => () } // error
+
+    Some(x) match { case Some(4) | Some(Z2.v) => () } // ok
+    Some(x) match { case a @ Some(Z2.v)       => () } // ok
+  }
+}