2 files changed, 28 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 {