Merge pull request scala#11048 from som-snytt/revert/allow-unused-patvar

Tighter condition for nowarn a single patvar

Author: lrytz

src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala

@@ -579,9 +579,15 @@ trait TypeDiagnostics extends splain.SplainDiagnostics {
           }
         case Match(selector, cases) =>
           // don't warn when a patvar redefines the selector ident: x match { case x: X => }
+          // or extracts a single patvar named identically to the selector
           def allowVariableBindings(n: Name, pat: Tree): Unit =
-            pat.foreach {
-              case bind @ Bind(`n`, _) => bind.updateAttachment(NoWarnAttachment)
+            pat match {
+              case Bind(`n`, _) => pat.updateAttachment(NoWarnAttachment)
+              case Apply(_, _) | UnApply(_, _) => // really interested in args
+                pat.filter(_.isInstanceOf[Bind]) match { // never nme.WILDCARD
+                  case (bind @ Bind(`n`, _)) :: Nil => bind.updateAttachment(NoWarnAttachment) // one only
+                  case _ =>
+                }
               case _ =>
             }
           def allow(n: Name): Unit = cases.foreach(k => allowVariableBindings(n, k.pat))
@@ -594,7 +600,7 @@ trait TypeDiagnostics extends splain.SplainDiagnostics {
             }
           loop(selector)
         case CaseDef(pat, _, _) if settings.warnUnusedPatVars && !t.isErrorTyped =>
-          def absolveVariableBindings(app: Apply, args: List[Tree]): Unit =
+          def allowVariableBindings(app: Apply, args: List[Tree]): Unit =
             treeInfo.dissectApplied(app).core.tpe match {
               case MethodType(ps, _) =>
                 foreach2(ps, args) { (p, x) =>
@@ -606,10 +612,7 @@ trait TypeDiagnostics extends splain.SplainDiagnostics {
               case _ =>
             }
           pat.foreach {
-            case app @ Apply(_, args) => absolveVariableBindings(app, args)
-            case _ =>
-          }
-          pat.foreach {
+            case app @ Apply(_, args) => allowVariableBindings(app, args)
             case b @ Bind(n, _) if n != nme.DEFAULT_CASE => addPatVar(b)
             case _ =>
           }

src/reflect/scala/reflect/internal/Trees.scala

@@ -632,7 +632,8 @@ trait Trees extends api.Trees {
   case class UnApply(fun: Tree, args: List[Tree])
        extends TermTree with UnApplyApi {
     override def transform(transformer: Transformer): Tree =
-      transformer.treeCopy.UnApply(this, transformer.transform(fun), transformer.transformTrees(args)) // bq: see test/.../unapplyContexts2.scala
+      transformer.treeCopy.UnApply(this, transformer.transform(fun), transformer.transformTrees(args))
+        // bq: see test/.../unapplyContexts2.scala
     override def traverse(traverser: Traverser): Unit = {
       traverser.traverse(fun)
       traverser.traverseTrees(args)

test/files/neg/t13095.check

@@ -4,6 +4,18 @@ t13095.scala:12: warning: pattern var z in object Main is never used
 t13095.scala:13: warning: pattern var r in object Main is never used
   private[this] val A(q, r) = A(42, 27) // warn
                          ^
+t13095.scala:42: warning: pattern var s in method spam is never used
+      case email(s, addr) => // warn // warn each, multiple extraction
+                 ^
+t13095.scala:42: warning: pattern var addr in method spam is never used
+      case email(s, addr) => // warn // warn each, multiple extraction
+                    ^
+t13095.scala:52: warning: pattern var v in method scala-dev#902 is never used
+      case (i, v @ (_, _)) => i // warn multiple patvars
+               ^
+t13095.scala:52: warning: a pure expression does nothing in statement position
+      case (i, v @ (_, _)) => i // warn multiple patvars
+                              ^
 error: No warnings can be incurred under -Werror.
-2 warnings
+6 warnings
 1 error

test/files/neg/t13095.scala

@@ -26,6 +26,31 @@ class C {
       case x: String => // nowarn because x is not a new reference but an alias
       case _ =>
     }
+  def s(x: Option[String]) =
+    x match {
+      case x: Some[String] => // nowarn because x is not a new reference but an alias
+      case _ =>
+    }
+  def t(x: Option[String]) =
+    x match {
+      case Some(x) => // nowarn because x is not a new reference but an alias of sorts
+      case _ =>
+    }
+  val email = "(.*)@(.*)".r
+  def spam(s: String) =
+    s match {
+      case email(s, addr) => // warn // warn each, multiple extraction
+      case _ =>
+    }
+  def border(s: String) =
+    s match {
+      case email(s, _) => // nowarn only one patvar
+      case _ =>
+    }
+  def `scala-dev#902`(v: (Int, (Boolean, String))): Unit =
+    v match {
+      case (i, v @ (_, _)) => i // warn multiple patvars
+    }
 }
 
 final class ArrayOps[A](private val xs: Array[A]) extends AnyVal {