SI-6646 Fix regression in for desugaring.

The early check in the parser of pattern irrefutability,
added in c82ecab, failed to consider InitCaps and
`backquoted` identifiers.

4 files changed, 44 insertions, 19 deletions

diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
index 0d13623e0c..0ac46a18bc 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
@@ -285,7 +285,7 @@ abstract class TreeBuilder {
   def makeGenerator(pos: Position, pat: Tree, valeq: Boolean, rhs: Tree): Enumerator = {
     val pat1 = patvarTransformer.transform(pat)
     val rhs1 =
-      if (valeq || treeInfo.isVariablePattern(pat)) rhs
+      if (valeq || treeInfo.isVarPatternDeep(pat)) rhs
       else makeFilter(rhs, pat1.duplicate, nme.CHECK_IF_REFUTABLE_STRING)
 
     if (valeq) ValEq(pos, pat1, rhs1)
diff --git a/src/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala
index 38e55a3c01..56a0bac72b 100644
--- a/src/reflect/scala/reflect/internal/TreeInfo.scala
+++ b/src/reflect/scala/reflect/internal/TreeInfo.scala
@@ -245,6 +245,33 @@ abstract class TreeInfo {
     isSelfConstrCall(tree1) || isSuperConstrCall(tree1)
   }
 
+  /** Is this tree comprised of nothing but identifiers,
+    * but possibly in bindings or tuples? For instance:
+    *
+    * {{{
+    * foo @ (bar, (baz, quux))
+    * }}}
+    *
+    * is a variable pattern; if the structure matches,
+    * then the remainder is inevitable.
+    *
+    * The following are not variable patterns.
+    *
+    * {{{
+    *   foo @ (bar, (`baz`, Quux))
+    *   foo @ (bar, Quux)
+    * }}}
+    */
+  def isVarPatternDeep(tree: Tree): Boolean = tree match {
+    case Bind(name, pat)  => isVarPatternDeep(pat)
+    case Ident(name)      => isVarPattern(tree)
+    case Apply(sel, args) =>
+      (    isReferenceToScalaMember(sel, TupleClass(args.size).name.toTermName)
+        && (args forall isVarPatternDeep)
+      )
+    case _                => false
+  }
+
   /** Is tree a variable pattern? */
   def isVarPattern(pat: Tree): Boolean = pat match {
     case x: Ident           => !x.isBackquoted && nme.isVariableName(x.name)
@@ -330,24 +357,6 @@ abstract class TreeInfo {
     case _                                       => false
   }
 
-  /** Is this tree comprised of nothing but identifiers,
-   *  but possibly in bindings or tuples? For instance
-   *
-   *    foo @ (bar, (baz, quux))
-   *
-   *  is a variable pattern; if the structure matches,
-   *  then the remainder is inevitable.
-   */
-  def isVariablePattern(tree: Tree): Boolean = tree match {
-    case Bind(name, pat)  => isVariablePattern(pat)
-    case Ident(name)      => true
-    case Apply(sel, args) =>
-      (    isReferenceToScalaMember(sel, TupleClass(args.size).name.toTermName)
-        && (args forall isVariablePattern)
-      )
-    case _ => false
-  }
-
   /** Is this argument node of the form <expr> : _* ?
    */
   def isWildcardStarArg(tree: Tree): Boolean = tree match {
diff --git a/test/files/run/t6646.check b/test/files/run/t6646.check
new file mode 100644
index 0000000000..e27b5b9efb
--- /dev/null
+++ b/test/files/run/t6646.check
@@ -0,0 +1,3 @@
+Found NotNull
+Found lower
+Found 2
diff --git a/test/files/run/t6646.scala b/test/files/run/t6646.scala
new file mode 100644
index 0000000000..9418bfafb1
--- /dev/null
+++ b/test/files/run/t6646.scala
@@ -0,0 +1,13 @@
+sealed trait ColumnOption
+case object NotNull extends ColumnOption
+case object PrimaryKey extends ColumnOption
+case object lower extends ColumnOption
+
+object Test {
+  def main(args: Array[String]) {
+    val l = List(PrimaryKey, NotNull, lower)
+    for (option @ NotNull <- l) println("Found " + option)
+    for (option @ `lower` <- l) println("Found " + option)
+    for ((`lower`, i) <- l.zipWithIndex) println("Found " + i)
+  }
+}