Merge pull request scala#10812 from som-snytt/issue/10287-for-warnings

Fix unused warnings in for comprehensions [ci: last-only]

Author: som-snytt

build.sbt

@@ -161,6 +161,7 @@ lazy val commonSettings = instanceSettings ++ clearSourceAndResourceDirectories
   run / fork := true,
   run / connectInput := true,
   Compile / scalacOptions ++= Seq("-feature", "-Xlint",
+    //"-Vprint",
     //"-Xmaxerrs", "5", "-Xmaxwarns", "5", // uncomment for ease of development while breaking things
     // work around https://github.com/scala/bug/issues/11534
     "-Wconf:cat=unchecked&msg=The outer reference in this type test cannot be checked at run time.:s",
@@ -463,6 +464,9 @@ lazy val reflect = configureAsSubproject(project)
     name := "scala-reflect",
     description := "Scala Reflection Library",
     Osgi.bundleName := "Scala Reflect",
+    Compile / scalacOptions ++= Seq(
+      "-Wconf:cat=deprecation&msg=early initializers:s", // compiler heavily relies upon early initializers
+    ),
     Compile / doc / scalacOptions ++= Seq(
       "-skip-packages", "scala.reflect.macros.internal:scala.reflect.internal:scala.reflect.io"
     ),
@@ -534,6 +538,7 @@ lazy val compiler = configureAsSubproject(project)
       ).get
     },
     Compile / scalacOptions ++= Seq(
+      //"-Wunused", //"-Wnonunit-statement",
       "-Wconf:cat=deprecation&msg=early initializers:s", // compiler heavily relies upon early initializers
     ),
     Compile / doc / scalacOptions ++= Seq(
@@ -694,6 +699,9 @@ lazy val partest = configureAsSubproject(project)
     name := "scala-partest",
     description := "Scala Compiler Testing Tool",
     libraryDependencies ++= List(testInterfaceDep, diffUtilsDep, junitDep),
+    Compile / scalacOptions ++= Seq(
+      "-Wconf:cat=deprecation&msg=early initializers:s", // compiler heavily relies upon early initializers
+    ),
     Compile / javacOptions ++= Seq("-XDenableSunApiLintControl", "-Xlint") ++
       (if (fatalWarnings.value) Seq("-Werror") else Seq()),
     pomDependencyExclusions ++= List((organization.value, "scala-repl-frontend"), (organization.value, "scala-compiler-doc")),

src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala

@@ -71,7 +71,7 @@ abstract class DefaultMacroCompiler extends Resolvers
     val vanillaResult = tryCompile(vanillaImplRef)
     val bundleResult = tryCompile(bundleImplRef)
 
-    def ensureUnambiguousSuccess() = {
+    def ensureUnambiguousSuccess(): Unit = {
       // we now face a hard choice of whether to report ambiguity:
       //   1) when there are eponymous methods in both bundle and object
       //   2) when both references to eponymous methods are resolved successfully
@@ -100,6 +100,7 @@ abstract class DefaultMacroCompiler extends Resolvers
     try {
       if (vanillaResult.isSuccess || bundleResult.isSuccess) ensureUnambiguousSuccess()
       if (vanillaResult.isFailure && bundleResult.isFailure) reportMostAppropriateFailure()
+      //else // TODO
       vanillaResult.orElse(bundleResult).get
     } catch {
       case MacroImplResolutionException(pos, msg) =>

src/compiler/scala/reflect/macros/compiler/Resolvers.scala

@@ -34,7 +34,7 @@ trait Resolvers {
     lazy val (macroImplRef, isBlackbox, macroImplOwner, macroImpl, targs) =
       typer.silent(_.typed(markMacroImplRef(untypedMacroImplRef)), reportAmbiguousErrors = false) match {
         case SilentResultValue(macroImplRef @ MacroImplReference(_, isBlackbox, owner, meth, targs)) => (macroImplRef, isBlackbox, owner, meth, targs)
-        case SilentResultValue(macroImplRef) => MacroImplReferenceWrongShapeError()
+        case SilentResultValue(_) => MacroImplReferenceWrongShapeError()
         case ste: SilentTypeError => abort(ste.err.errPos, ste.err.errMsg)
       }
   }

src/compiler/scala/reflect/macros/compiler/Validators.scala

@@ -127,7 +127,7 @@ trait Validators {
      */
     private lazy val macroImplSig: MacroImplSig = {
       val tparams = macroImpl.typeParams
-      val paramss = transformTypeTagEvidenceParams(macroImplRef, (param, tparam) => NoSymbol)
+      val paramss = transformTypeTagEvidenceParams(macroImplRef, (_, _) => NoSymbol)
       val ret = macroImpl.info.finalResultType
       MacroImplSig(tparams, paramss, ret)
     }

src/compiler/scala/reflect/quasiquotes/Parsers.scala

@@ -42,16 +42,16 @@ trait Parsers { self: Quasiquotes =>
       val posMapList = posMap.toList
       def containsOffset(start: Int, end: Int) = start <= offset && offset < end
       def fallbackPosition = posMapList match {
-        case (pos1, (start1, end1)) :: _   if start1 > offset => pos1
-        case _ :+ ((pos2, (start2, end2))) if end2 <= offset  => pos2.withPoint(pos2.point + (end2 - start2))
-        case x                                                => throw new MatchError(x)
+        case (pos1, (start1, _)) :: _   if start1 > offset   => pos1
+        case _ :+ ((pos2, (start2, end2))) if end2 <= offset => pos2.withPoint(pos2.point + (end2 - start2))
+        case x                                               => throw new MatchError(x)
       }
       posMapList.sliding(2).collect {
-        case (pos1, (start1, end1)) :: _                        if containsOffset(start1, end1) => (pos1, offset - start1)
-        case (pos1, (start1, end1)) :: (pos2, (start2, _)) :: _ if containsOffset(end1, start2) => (pos1, end1 - start1)
-        case _ :: (pos2, (start2, end2)) :: _                   if containsOffset(start2, end2) => (pos2, offset - start2)
-      }.map { case (pos, offset) =>
-        pos.withPoint(pos.point + offset)
+        case (pos1, (start1, end1)) :: _                     if containsOffset(start1, end1) => (pos1, offset - start1)
+        case (pos1, (start1, end1)) :: (_, (start2, _)) :: _ if containsOffset(end1, start2) => (pos1, end1 - start1)
+        case _ :: (pos2, (start2, end2)) :: _                if containsOffset(start2, end2) => (pos2, offset - start2)
+      }.map {
+        case (pos, offset) => pos.withPoint(pos.point + offset)
       }.toList.headOption.getOrElse(fallbackPosition)
     }
 
@@ -92,7 +92,7 @@ trait Parsers { self: Quasiquotes =>
               case _ => gen.mkBlock(stats, doFlatten = true)
             }
           case nme.unapply => gen.mkBlock(stats, doFlatten = false)
-          case other       => global.abort("unreachable")
+          case _           => global.abort("unreachable")
         }
 
         // tq"$a => $b"

src/compiler/scala/reflect/quasiquotes/Reifiers.scala

@@ -319,7 +319,7 @@ trait Reifiers { self: Quasiquotes =>
      */
     def group[T](lst: List[T])(similar: (T, T) => Boolean) = lst.foldLeft[List[List[T]]](List()) {
       case (Nil, el) => List(List(el))
-      case (ll :+ (last @ (lastinit :+ lastel)), el) if similar(lastel, el) => ll :+ (last :+ el)
+      case (ll :+ (last @ _ :+ lastel), el) if similar(lastel, el) => ll :+ (last :+ el)
       case (ll, el) => ll :+ List(el)
     }
 
@@ -363,7 +363,7 @@ trait Reifiers { self: Quasiquotes =>
       case ParamPlaceholder(Hole(tree, DotDot)) => tree
       case SyntacticPatDef(mods, pat, tpt, rhs) =>
         reifyBuildCall(nme.SyntacticPatDef, mods, pat, tpt, rhs)
-      case SyntacticValDef(mods, p @ Placeholder(h: ApplyHole), tpt, rhs) if h.tpe <:< treeType =>
+      case SyntacticValDef(mods, Placeholder(h: ApplyHole), tpt, rhs) if h.tpe <:< treeType =>
         mirrorBuildCall(nme.SyntacticPatDef, reify(mods), h.tree, reify(tpt), reify(rhs))
     }
 

src/compiler/scala/reflect/reify/Taggers.scala

@@ -78,21 +78,21 @@ abstract class Taggers {
           translatingReificationErrors(materializer)
       }
     try c.typecheck(result)
-    catch { case terr @ TypecheckException(pos, msg) => failTag(result, terr) }
+    catch { case terr: TypecheckException => failTag(result, terr) }
   }
 
   def materializeExpr(universe: Tree, mirror: Tree, expr: Tree): Tree = {
     val result = translatingReificationErrors(c.reifyTree(universe, mirror, expr))
     try c.typecheck(result)
-    catch { case terr @ TypecheckException(pos, msg) => failExpr(result, terr) }
+    catch { case terr: TypecheckException => failExpr(result, terr) }
   }
 
   private def translatingReificationErrors(materializer: => Tree): Tree = {
     try materializer
     catch {
       case ReificationException(pos, msg) =>
         c.abort(pos.asInstanceOf[c.Position], msg) // this cast is a very small price for the confidence of exception handling
-      case UnexpectedReificationException(pos, err, cause) if cause != null =>
+      case UnexpectedReificationException(_, _, cause) if cause != null =>
         throw cause
     }
   }

src/compiler/scala/reflect/reify/codegen/GenPositions.scala

@@ -23,6 +23,6 @@ trait GenPositions {
   // but I can hardly imagine when one would need a position that points to the reified code
   // usually reified trees are used to compose macro expansions or to be fed to the runtime compiler
   // however both macros and toolboxes have their own means to report errors in synthetic trees
-  def reifyPosition(pos: Position): Tree =
-    reifyMirrorObject(NoPosition)
+  @annotation.nowarn
+  def reifyPosition(pos: Position): Tree = reifyMirrorObject(NoPosition)
 }

src/compiler/scala/reflect/reify/codegen/GenTypes.scala

@@ -46,35 +46,35 @@ trait GenTypes {
     if (tsym.isClass && tpe == tsym.typeConstructor && tsym.isStatic)
       Select(Select(reify(tsym), nme.asType), nme.toTypeConstructor)
     else tpe match {
-      case tpe : NoType.type =>
+      case tpe: NoType.type =>
         reifyMirrorObject(tpe)
-      case tpe : NoPrefix.type =>
+      case tpe: NoPrefix.type =>
         reifyMirrorObject(tpe)
-      case tpe @ ThisType(root) if root.isRoot =>
+      case ThisType(root) if root.isRoot =>
         mirrorBuildCall(nme.thisPrefix, mirrorMirrorSelect(nme.RootClass))
-      case tpe @ ThisType(empty) if empty.isEmptyPackageClass =>
+      case ThisType(empty) if empty.isEmptyPackageClass =>
         mirrorBuildCall(nme.thisPrefix, mirrorMirrorSelect(nme.EmptyPackageClass))
-      case tpe @ ThisType(clazz) if clazz.isModuleClass && clazz.isStatic =>
+      case ThisType(clazz) if clazz.isModuleClass && clazz.isStatic =>
         val module = reify(clazz.sourceModule)
         val moduleClass = Select(Select(module, nme.asModule), nme.moduleClass)
         mirrorBuildCall(nme.ThisType, moduleClass)
-      case tpe @ ThisType(sym) =>
+      case ThisType(sym) =>
         reifyBuildCall(nme.ThisType, sym)
-      case tpe @ SuperType(thistpe, supertpe) =>
+      case SuperType(thistpe, supertpe) =>
         reifyBuildCall(nme.SuperType, thistpe, supertpe)
-      case tpe @ SingleType(pre, sym) =>
+      case SingleType(pre, sym) =>
         reifyBuildCall(nme.SingleType, pre, sym)
-      case tpe @ ConstantType(value) =>
+      case ConstantType(value) =>
         mirrorBuildCall(nme.ConstantType, reifyProduct(value))
-      case tpe @ TypeRef(pre, sym, args) =>
+      case TypeRef(pre, sym, args) =>
         reifyBuildCall(nme.TypeRef, pre, sym, args)
-      case tpe @ TypeBounds(lo, hi) =>
+      case TypeBounds(lo, hi) =>
         reifyBuildCall(nme.TypeBounds, lo, hi)
-      case tpe @ NullaryMethodType(restpe) =>
+      case NullaryMethodType(restpe) =>
         reifyBuildCall(nme.NullaryMethodType, restpe)
-      case tpe @ AnnotatedType(anns, underlying) =>
+      case tpe: AnnotatedType =>
         reifyAnnotatedType(tpe)
-      case _ =>
+      case tpe =>
         reifyToughType(tpe)
     }
   }
@@ -165,7 +165,7 @@ trait GenTypes {
    *  I.e. we can compile the code that involves `ru.Type`, but we cannot serialize an instance of `ru.Type`.
    */
   private def reifySemiConcreteTypeMember(tpe: Type): Tree = tpe match {
-    case tpe @ TypeRef(pre @ SingleType(prepre, presym), sym, args) if sym.isAbstractType && !sym.isExistential =>
+    case TypeRef(pre @ SingleType(_, _), sym, args) if sym.isAbstractType && !sym.isExistential =>
       mirrorBuildCall(nme.TypeRef, reify(pre), mirrorBuildCall(nme.selectType, reify(sym.owner), reify(sym.name.toString)), reify(args))
     case x => throw new MatchError(x)
   }
@@ -187,18 +187,18 @@ trait GenTypes {
 
     tpe match {
       case tpe @ RefinedType(parents, decls) =>
-        reifySymDef(tpe.typeSymbol)
+        List(tpe.typeSymbol).foreach(reifySymDef)
         mirrorBuildCall(nme.RefinedType, reify(parents), reifyScope(decls), reify(tpe.typeSymbol))
-      case tpe @ ExistentialType(tparams, underlying) =>
-        tparams foreach reifySymDef
+      case ExistentialType(tparams, underlying) =>
+        tparams.foreach(reifySymDef)
         reifyBuildCall(nme.ExistentialType, tparams, underlying)
       case tpe @ ClassInfoType(parents, decls, clazz) =>
-        reifySymDef(clazz)
+        List(clazz).foreach(reifySymDef)
         mirrorBuildCall(nme.ClassInfoType, reify(parents), reifyScope(decls), reify(tpe.typeSymbol))
-      case tpe @ MethodType(params, restpe) =>
+      case MethodType(params, restpe) =>
         params foreach reifySymDef
         reifyBuildCall(nme.MethodType, params, restpe)
-      case tpe @ PolyType(tparams, underlying) =>
+      case PolyType(tparams, underlying) =>
         tparams foreach reifySymDef
         reifyBuildCall(nme.PolyType, tparams, underlying)
       case _ =>

src/compiler/scala/reflect/reify/codegen/GenUtils.scala

@@ -117,7 +117,7 @@ trait GenUtils {
   @tailrec
   final def isCrossStageTypeBearer(tree: Tree): Boolean = tree match {
     case TypeApply(hk, _) => isCrossStageTypeBearer(hk)
-    case Select(sym @ Select(_, ctor), nme.apply) if ctor == nme.WeakTypeTag || ctor == nme.TypeTag || ctor == nme.Expr => true
+    case Select(Select(_, nme.WeakTypeTag|nme.TypeTag|nme.Expr), nme.apply) => true
     case _ => false
   }
 

src/compiler/scala/reflect/reify/phases/Reshape.scala

@@ -13,7 +13,7 @@
 package scala.reflect.reify
 package phases
 
-import scala.annotation.tailrec
+import scala.annotation.{tailrec, unused}
 import scala.tools.nsc.symtab.Flags._
 
 trait Reshape {
@@ -192,7 +192,7 @@ trait Reshape {
 
     @tailrec
     private def toPreTyperTypedOrAnnotated(tree: Tree): Tree = tree match {
-      case ty @ Typed(expr1, tpt) =>
+      case ty @ Typed(_, tpt) =>
         if (reifyDebug) println("reify typed: " + tree)
         val original = tpt match {
           case tt @ TypeTree() => tt.original
@@ -201,11 +201,10 @@ trait Reshape {
         val annotatedArg = {
           @tailrec
           def loop(tree: Tree): Tree = tree match {
-            case annotated1 @ Annotated(ann, annotated2 @ Annotated(_, _)) => loop(annotated2)
-            case annotated1 @ Annotated(ann, arg) => arg
+            case Annotated(_, annotated2 @ Annotated(_, _)) => loop(annotated2)
+            case Annotated(_, arg) => arg
             case _ => EmptyTree
           }
-
           loop(original)
         }
         if (annotatedArg != EmptyTree) {
@@ -220,7 +219,7 @@ trait Reshape {
           if (reifyDebug) println("verdict: wasn't annotated, reify as usual")
           ty
         }
-      case at @ Annotated(annot, arg) =>
+      case at @ Annotated(_, arg) =>
         if (reifyDebug) println("reify type annotations for: " + tree)
         assert(at.tpe.isInstanceOf[AnnotatedType], "%s (%s)".format(at.tpe, at.tpe.kind))
         val annot1 = toPreTyperAnnotation(at.tpe.asInstanceOf[AnnotatedType].annotations(0))
@@ -251,7 +250,7 @@ trait Reshape {
       New(TypeTree(ann.atp) setOriginal extractOriginal(ann.original), List(args))
     }
 
-    private def trimAccessors(deff: Tree, stats: List[Tree]): List[Tree] = {
+    private def trimAccessors(@unused deff: Tree, stats: List[Tree]): List[Tree] = {
       val symdefs = (stats collect { case vodef: ValOrDefDef => vodef } map (vodeff => vodeff.symbol -> vodeff)).toMap
       val accessors = scala.collection.mutable.Map[ValDef, List[DefDef]]()
       stats collect { case ddef: DefDef => ddef } foreach (defdef => {
@@ -311,7 +310,7 @@ trait Reshape {
       stats1
     }
 
-    private def trimSyntheticCaseClassMembers(deff: Tree, stats: List[Tree]): List[Tree] =
+    private def trimSyntheticCaseClassMembers(@unused deff: Tree, stats: List[Tree]): List[Tree] =
       stats filterNot (memberDef => memberDef.isDef && {
         val isSynthetic = memberDef.symbol.isSynthetic
         // this doesn't work for local classes, e.g. for ones that are top-level to a quasiquote (see comments to companionClass)

src/compiler/scala/reflect/reify/utils/Extractors.scala

@@ -242,8 +242,8 @@ trait Extractors {
 
   object TypeRefToFreeType {
     def unapply(tree: Tree): Option[TermName] = tree match {
-      case Apply(Select(Select(uref @ Ident(_), typeRef), apply), List(Select(_, noSymbol), Ident(freeType: TermName), nil))
-      if (uref.name == nme.UNIVERSE_SHORT && typeRef == nme.TypeRef && noSymbol == nme.NoSymbol && freeType.startsWith(nme.REIFY_FREE_PREFIX)) =>
+      case Apply(Select(Select(Ident(nme.UNIVERSE_SHORT), nme.TypeRef), apply@_), List(Select(_, nme.NoSymbol), Ident(freeType: TermName), _))
+      if freeType.startsWith(nme.REIFY_FREE_PREFIX) =>
         Some(freeType)
       case _ =>
         None

src/compiler/scala/reflect/reify/utils/StdAttachments.scala

@@ -23,7 +23,7 @@ trait StdAttachments {
   def reifyBinding(tree: Tree): Tree =
     tree.attachments.get[ReifyBindingAttachment] match {
       case Some(ReifyBindingAttachment(binding)) => binding
-      case other => Ident(NoSymbol)
+      case _ => Ident(NoSymbol)
     }
 
   case class ReifyAliasAttachment(sym: Symbol, alias: TermName)

src/compiler/scala/reflect/reify/utils/SymbolTables.scala

@@ -13,6 +13,7 @@
 package scala.reflect.reify
 package utils
 
+import scala.annotation._
 import scala.collection.{immutable, mutable}, mutable.{ArrayBuffer, ListBuffer}
 import java.lang.System.{lineSeparator => EOL}
 
@@ -89,7 +90,7 @@ trait SymbolTables {
       new SymbolTable(newSymtab, newAliases)
     }
 
-    def add(sym: Symbol, name0: TermName, reification: Tree): SymbolTable = {
+    def add(@unused sym: Symbol, name0: TermName, reification: Tree): SymbolTable = {
       def freshName(name0: TermName): TermName = {
         var name = name0.toString
         name = name.replace(".type", "$type")
@@ -133,10 +134,11 @@ trait SymbolTables {
       s"""symtab = [$symtabString], aliases = [$aliasesString]${if (original.isDefined) ", has original" else ""}"""
     }
 
+    @nowarn // spurious unused buf.type
     def debugString: String = {
       val buf = new StringBuilder
       buf.append("symbol table = " + (if (syms.length == 0) "<empty>" else "")).append(EOL)
-      syms foreach (sym => buf.append(symDef(sym)).append(EOL))
+      syms.foreach(sym => buf.append(symDef(sym)).append(EOL))
       buf.delete(buf.length - EOL.length, buf.length)
       buf.toString
     }

src/compiler/scala/tools/nsc/ClassPathMemoryConsumptionTester.scala

@@ -42,15 +42,15 @@ object ClassPathMemoryConsumptionTester {
   private def doTest(args: Array[String]) = {
     val settings = loadSettings(args.toList)
 
-    val mains = (1 to settings.requiredInstances.value) map (_ => new MainRetainsGlobal)
+    val mains = (1 to settings.requiredInstances.value).map(_ => new MainRetainsGlobal)
 
     // we need original settings without additional params to be able to use them later
     val baseArgs = argsWithoutRequiredInstances(args)
 
     println(s"Loading classpath ${settings.requiredInstances.value} times")
     val startTime = System.currentTimeMillis()
 
-    mains map (_.process(baseArgs))
+    mains.foreach(_.process(baseArgs))
 
     val elapsed = System.currentTimeMillis() - startTime
     println(s"Operation finished - elapsed $elapsed ms")