Merge pull request scala#10496 from som-snytt/tweak/discarded-values

Tweaks for lint-friendliness [ci: last-only]

Author: lrytz

src/compiler/scala/reflect/quasiquotes/Placeholders.scala

@@ -32,14 +32,14 @@ trait Placeholders { self: Quasiquotes =>
   lazy val code = {
     val sb = new StringBuilder()
 
-    def appendPart(value: String, pos: Position) = {
+    def appendPart(value: String, pos: Position): Unit = {
       val start = sb.length
       sb.append(value)
       val end = sb.length
       posMap += pos -> ((start, end))
     }
 
-    def appendHole(tree: Tree, rank: Rank) = {
+    def appendHole(tree: Tree, rank: Rank): Unit = {
       val placeholderName = c.freshName(TermName(nme.QUASIQUOTE_PREFIX))
       sb.append(placeholderName)
       val holeTree =
@@ -76,14 +76,13 @@ trait Placeholders { self: Quasiquotes =>
       accessed += skey
       value
     }
-    def update(key: Name, hole: Hole) =
+    def update(key: Name, hole: Hole): Unit =
       underlying += key.toString -> hole
     def get(key: Name): Option[Hole] = {
       val skey = key.toString
-      underlying.get(skey).map { v =>
-        accessed += skey
-        v
-      }
+      val res = underlying.get(skey)
+      res.foreach(_ => accessed += skey)
+      res
     }
     def keysIterator: Iterator[TermName] = underlying.keysIterator.map(TermName(_))
   }

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

@@ -60,8 +60,8 @@ trait Calculate {
         bindRelatedSymbol(tree.symbol.moduleClass, "moduleClass")
         bindRelatedSymbol(tree.symbol.companionClass, "companionClass")
         bindRelatedSymbol(tree.symbol.companionModule, "companionModule")
-        Some(tree.symbol) collect { case termSymbol: TermSymbol => bindRelatedSymbol(termSymbol.referenced, "referenced") }
-        Some(tree) collect { case labelDef: LabelDef => labelDef.params foreach (param => bindRelatedSymbol(param.symbol, "labelParam")) }
+        tree.symbol match { case termSymbol: TermSymbol => bindRelatedSymbol(termSymbol.referenced, "referenced") case _ => }
+        tree match { case labelDef: LabelDef => labelDef.params.foreach(param => bindRelatedSymbol(param.symbol, "labelParam")) case _ => }
         def bindRelatedSymbol(related: Symbol, name: String): Unit =
           if (related != null && related != NoSymbol) {
             if (reifyDebug) println("boundSym (" + name + "): " + related)

src/compiler/scala/tools/nsc/Global.scala

@@ -82,8 +82,8 @@ class Global(var currentSettings: Settings, reporter0: Reporter)
   def findMemberFromRoot(fullName: Name): Symbol = rootMirror.findMemberFromRoot(fullName)
 
   override def openPackageModule(pkgClass: Symbol, force: Boolean): Unit = {
-    if (force || isPast(currentRun.namerPhase)) super.openPackageModule(pkgClass, true)
-    else analyzer.packageObjects.deferredOpen.add(pkgClass)
+    if (force || isPast(currentRun.namerPhase)) super.openPackageModule(pkgClass, force = true)
+    else analyzer.packageObjects.deferredOpen.addOne(pkgClass)
   }
 
   // alternate constructors ------------------------------------------
@@ -976,7 +976,7 @@ class Global(var currentSettings: Settings, reporter0: Reporter)
       cp.packages(parent).exists(_.name == fullPackageName)
     }
 
-    def invalidateOrRemove(pkg: ClassSymbol) = {
+    def invalidateOrRemove(pkg: ClassSymbol): Unit = {
       if (packageExists(fullClasspath))
         pkg setInfo new loaders.PackageLoader(fullPackageName, fullClasspath)
       else
@@ -1192,7 +1192,7 @@ class Global(var currentSettings: Settings, reporter0: Reporter)
     private class SyncedCompilationBuffer { self =>
       private val underlying = new mutable.ArrayBuffer[CompilationUnit]
       def size = synchronized { underlying.size }
-      def +=(cu: CompilationUnit): this.type = { synchronized { underlying += cu }; this }
+      def +=(cu: CompilationUnit): this.type = synchronized { underlying += cu; this }
       def head: CompilationUnit = synchronized { underlying.head }
       def apply(i: Int): CompilationUnit = synchronized { underlying(i) }
       def iterator: Iterator[CompilationUnit] = new collection.AbstractIterator[CompilationUnit] {
@@ -1691,7 +1691,7 @@ class Global(var currentSettings: Settings, reporter0: Reporter)
      */
     @tailrec
     private def resetPackageClass(pclazz: Symbol): Unit = if (typerPhase != NoPhase) {
-      enteringPhase(firstPhase) {
+      enteringPhase[Unit](firstPhase) {
         pclazz.setInfo(enteringPhase(typerPhase)(pclazz.info))
       }
       if (!pclazz.isRoot) resetPackageClass(pclazz.owner)

src/compiler/scala/tools/nsc/PipelineMain.scala

@@ -48,7 +48,7 @@ class PipelineMainClass(argFiles: Seq[Path], pipelineSettings: PipelineMain.Pipe
     val validRootPathComponent = root.toString.replace("/", "").replace(":", "")
     val result = changeExtension(pickleCache.resolve(validRootPathComponent).resolve(root.relativize(file)).normalize(), newExtension)
     if (useJars) Files.createDirectories(result.getParent)
-    strippedAndExportedClassPath.put(file.toRealPath().normalize(), result)
+    strippedAndExportedClassPath.update(file.toRealPath().normalize(), result)
     result
   }
 
@@ -176,7 +176,7 @@ class PipelineMainClass(argFiles: Seq[Path], pipelineSettings: PipelineMain.Pipe
       val awaitAllFutures: Future[_] = sequenceFailSlow(allFutures)
       var lastNumCompleted = allFutures.count(_.isCompleted)
       while (true) try {
-        Await.result(awaitAllFutures, Duration(60, "s"))
+        Await.ready(awaitAllFutures, Duration(60, "s"))
         timer.stop()
         val numCompleted = allFutures.count(_.isCompleted)
         reporterEcho(s"PROGRESS: $numCompleted / $numAllFutures")

src/compiler/scala/tools/nsc/Reporting.scala

@@ -520,7 +520,7 @@ object Reporting {
     private val insertDash = "(?=[A-Z][a-z])".r
 
     val all: mutable.Map[String, WarningCategory] = mutable.Map.empty
-    private def add(c: WarningCategory): Unit = all.put(c.name, c).ensuring(_.isEmpty, s"lint '${c.name}' added twice")
+    private def add(c: WarningCategory): Unit = all.put(c.name, c).foreach(_ => assert(false, s"lint '${c.name}' added twice"))
 
     object Deprecation extends WarningCategory; add(Deprecation)
 

src/compiler/scala/tools/nsc/ast/Trees.scala

@@ -279,12 +279,9 @@ trait Trees extends scala.reflect.internal.Trees { self: Global =>
 
       override def traverse(tree: Tree) = {
         tree match {
-         case _: DefTree | Function(_, _) | Template(_, _, _) =>
-           markLocal(tree)
-         case _ =>
-           tree
+          case _: DefTree | Function(_, _) | Template(_, _, _) => markLocal(tree)
+          case _ =>
         }
-
         tree.traverse(this)
       }
     }

src/compiler/scala/tools/nsc/backend/jvm/PerRunInit.scala

@@ -25,7 +25,7 @@ trait PerRunInit {
   // so the back end may initialise them in parallel, and ListBuffer is not threadsafe
   private val inits = ListBuffer.empty[() => Unit]
 
-  def perRunInit(init: => Unit): Unit = inits.synchronized (inits += (() => init))
+  def perRunInit(init: => Unit): Unit = inits.synchronized[Unit](inits += (() => init))
 
   def initialize(): Unit = inits.synchronized(inits.foreach(_.apply()))
 }

src/compiler/scala/tools/nsc/backend/jvm/analysis/AliasingAnalyzer.scala

@@ -492,7 +492,7 @@ class AliasSet(var set: Object /*SmallBitSet | Array[Long]*/, var size: Int) {
   }
 
   override def clone(): AliasSet = {
-    val resSet = (set: @unchecked) match {
+    val resSet: Object = (set: @unchecked) match {
       case s: SmallBitSet => new SmallBitSet(s.a, s.b, s.c, s.d)
       case bits: Array[Long] => bits.clone()
     }

src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala

@@ -96,7 +96,7 @@ abstract class CallGraph {
   def removeCallsite(invocation: MethodInsnNode, methodNode: MethodNode): Option[Callsite] = {
     val methodCallsites = callsites(methodNode)
     val newCallsites = methodCallsites - invocation
-    if (newCallsites.isEmpty) callsites.remove(methodNode)
+    if (newCallsites.isEmpty) callsites.subtractOne(methodNode)
     else callsites(methodNode) = newCallsites
     methodCallsites.get(invocation)
   }
@@ -111,7 +111,7 @@ abstract class CallGraph {
   def removeClosureInstantiation(indy: InvokeDynamicInsnNode, methodNode: MethodNode): Option[ClosureInstantiation] = {
     val methodClosureInits = closureInstantiations(methodNode)
     val newClosureInits = methodClosureInits - indy
-    if (newClosureInits.isEmpty) closureInstantiations.remove(methodNode)
+    if (newClosureInits.isEmpty) closureInstantiations.subtractOne(methodNode)
     else closureInstantiations(methodNode) = newClosureInits
     methodClosureInits.get(indy)
   }
@@ -122,8 +122,8 @@ abstract class CallGraph {
   }
 
   def refresh(methodNode: MethodNode, definingClass: ClassBType): Unit = {
-    callsites.remove(methodNode)
-    closureInstantiations.remove(methodNode)
+    callsites.subtractOne(methodNode)
+    closureInstantiations.subtractOne(methodNode)
     // callsitePositions, inlineAnnotatedCallsites, noInlineAnnotatedCallsites, staticallyResolvedInvokespecial
     // are left unchanged. They contain individual instructions, the state for those remains valid in case
     // the inliner performs a rollback.

src/compiler/scala/tools/nsc/backend/jvm/opt/CopyProp.scala

@@ -629,11 +629,11 @@ abstract class CopyProp {
 
     val pairStartStack = new mutable.Stack[(AbstractInsnNode, mutable.ListBuffer[RemovePairDependency])]
 
-    def push(insn: AbstractInsnNode) = {
+    def push(insn: AbstractInsnNode): Unit = {
       pairStartStack push ((insn, mutable.ListBuffer.empty))
     }
 
-    def addDepends(dependency: RemovePairDependency) = if (pairStartStack.nonEmpty) {
+    def addDepends(dependency: RemovePairDependency): Unit = if (pairStartStack.nonEmpty) {
       val (_, depends) = pairStartStack.top
       depends += dependency
     }

src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala

@@ -359,7 +359,7 @@ abstract class Inliner {
             state.illegalAccessInstructions += instructionMap(ins)
           }
           val callInsn = r.callsite.callsiteInstruction
-          state.illegalAccessInstructions.remove(callInsn)
+          state.illegalAccessInstructions.subtractOne(callInsn)
           if (state.illegalAccessInstructions.isEmpty)
             state.undoLog = NoUndoLogging
           state.inlineLog.logSuccess(r, sizeBefore, method.instructions.size, state.outerCallsite(r.callsite.callsiteInstruction))
@@ -664,7 +664,7 @@ abstract class Inliner {
         BackendUtils.clearDceDone(methodNode)
         callGraph.refresh(methodNode, ownerClass)
 
-        onIndyLambdaImplMethodIfPresent(ownerClass.internalName)(_.remove(methodNode))
+        onIndyLambdaImplMethodIfPresent(ownerClass.internalName)(_.subtractOne(methodNode))
         if (currentIndyLambdaBodyMethods.nonEmpty)
           onIndyLambdaImplMethod(ownerClass.internalName)(ms => ms(methodNode) = mutable.Map.empty ++= currentIndyLambdaBodyMethods)
       }

src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala

@@ -584,7 +584,7 @@ abstract class LocalOpt {
     while (top != -1) {
       val insnIndex = deq()
       val insn = method.instructions.get(insnIndex)
-      visited.add(insnIndex)
+      visited.addOne(insnIndex)
 
       if (insn.getOpcode == -1) { // frames, labels, line numbers
         enqInsnIndex(insnIndex + 1)
@@ -1019,7 +1019,7 @@ object LocalOptImpls {
     }
 
     def removeJumpFromMap(jump: JumpInsnNode) = {
-      jumpInsns.remove(jump)
+      jumpInsns.subtractOne(jump)
       _jumpTargets = null
     }
 

src/compiler/scala/tools/nsc/classpath/ZipAndJarFileLookupFactory.scala

@@ -119,7 +119,7 @@ object ZipAndJarClassPathFactory extends ZipAndJarFileLookupFactory {
             case pkgFile :: rest =>
               val subpackages = getSubpackages(pkgFile)
               val fullPkgName = packagePrefix + pkgFile.name
-              packages.put(fullPkgName, PackageFileInfo(pkgFile, subpackages))
+              packages.update(fullPkgName, PackageFileInfo(pkgFile, subpackages))
               val newPackagePrefix = fullPkgName + "."
               subpackagesQueue.enqueue(PackageInfo(newPackagePrefix, subpackages))
               loop(rest)
@@ -128,7 +128,7 @@ object ZipAndJarClassPathFactory extends ZipAndJarFileLookupFactory {
           loop(filesForPrefix)
         }
       val subpackages = getSubpackages(file)
-      packages.put(ClassPath.RootPackage, PackageFileInfo(file, subpackages))
+      packages.update(ClassPath.RootPackage, PackageFileInfo(file, subpackages))
       val infos = mutable.Queue(PackageInfo(ClassPath.RootPackage, subpackages))
       traverse(infos)
       packages
@@ -225,7 +225,7 @@ final class FileBasedCache[K, T] {
                       override def run(): Unit = {
                         cache.synchronized {
                           if (e.referenceCount.compareAndSet(0, -1)) {
-                            cache.remove(key)
+                            cache.subtractOne(key)
                             cl.close()
                           }
                         }
@@ -294,15 +294,15 @@ final class FileBasedCache[K, T] {
           }
           val value = create()
           val entry = Entry(k, stamps, value)
-          cache.put(key, entry)
+          cache.update(key, entry)
           closeableRegistry.registerCloseable(referenceCountDecrementer(entry, key))
           value
         }
       case _ =>
         // Cache miss
         val value = create()
         val entry = Entry(k, stamps, value)
-        cache.put(key, entry)
+        cache.update(key, entry)
         closeableRegistry.registerCloseable(referenceCountDecrementer(entry, key))
         value
     }

src/compiler/scala/tools/nsc/io/Jar.scala

@@ -64,9 +64,9 @@ class Jar(file: File) extends AbstractIterable[JarEntry] {
       jarFile getEntry name match {
         case null   => f(None)
         case entry  =>
-          val in = Some(jarFile getInputStream entry)
+          val in = Some(jarFile.getInputStream(entry))
           try f(in)
-          finally in map (_.close())
+          finally in.foreach(_.close())
       }
     try apply() finally jarFile.close()
   }

src/compiler/scala/tools/nsc/transform/Fields.scala

@@ -187,8 +187,8 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
   // (in traits, getters must also hold annotations that target the underlying field,
   //  because the latter won't be created until the trait is mixed into a class)
   // TODO do bean getters need special treatment to suppress field-targeting annotations in traits?
-  def dropFieldAnnotationsFromGetter(sym: Symbol) =
-    sym setAnnotations (sym.annotations filter AnnotationInfo.mkFilter(GetterTargetClass, defaultRetention = false))
+  def dropFieldAnnotationsFromGetter(sym: Symbol): Unit =
+    sym.setAnnotations(sym.annotations.filter(AnnotationInfo.mkFilter(GetterTargetClass, defaultRetention = false)))
 
   def symbolAnnotationsTargetFieldAndGetter(sym: Symbol): Boolean = sym.isGetter && (sym.isLazy || sym.owner.isTrait)
 

src/compiler/scala/tools/nsc/transform/async/AnfTransform.scala

@@ -269,7 +269,8 @@ private[async] trait AnfTransform extends TransformUtils {
           onTail(ts)
         case i =>
           val group = new Array[T](i + 1)
-          ts.copyToArray(group)
+          @annotation.unused val copied = ts.copyToArray(group)
+          //assert(copied == group.length, s"$copied != ${group.length}")
           onGroup(group)
           foreachGroupsEndingWith(ts.drop(i + 1))(isGroupEnd, onGroup, onTail)
       }

src/compiler/scala/tools/nsc/transform/async/AsyncNames.scala

@@ -70,15 +70,15 @@ final class AsyncNames[U <: reflect.internal.Names with Singleton](val u: U) {
       if (seenPrefixes.contains(name)) {
         TermName(freshNameCreator.newName(name.toStringWithSuffix("$")))
       } else {
-        seenPrefixes.add(name)
+        seenPrefixes.addOne(name)
         name
       }
     }
     final def freshenIfNeeded(name: TypeName): TypeName = {
       if (seenPrefixes.contains(name)) {
         TypeName(freshNameCreator.newName(name.toStringWithSuffix("$")))
       } else {
-        seenPrefixes.add(name)
+        seenPrefixes.addOne(name)
         name
       }
     }

src/compiler/scala/tools/nsc/transform/async/ExprBuilder.scala

@@ -198,7 +198,7 @@ trait ExprBuilder extends TransformUtils with AsyncAnalysis {
 
     addStats()
 
-    private def addState(state: AsyncState): AsyncState = {
+    private def addState(state: AsyncState): state.type = {
       assert(building, "must be building to add state")
       assert(!statesMap.contains(state.state), "Duplicate state: " + state)
       statesMap(state.state) = state
@@ -490,7 +490,7 @@ trait ExprBuilder extends TransformUtils with AsyncAnalysis {
         val (initial :: Nil, rest) = all.partition(_.state == blockBuilder.startState): @unchecked
         val map = all.iterator.map(x => (x.state, x)).toMap
         val seen = mutable.HashSet[Int]()
-        seen.add(all.last.state)
+        seen.addOne(all.last.state)
         def followEmptyState(state: AsyncState): AsyncState = if (state.isEmpty && state.nextStates.size == 1) {
           val next = state.nextStates(0)
           if (next == blockBuilder.endState) state
@@ -506,7 +506,7 @@ trait ExprBuilder extends TransformUtils with AsyncAnalysis {
         }
         def loop(state: AsyncState): Unit = {
           if (!emptyReplacements.contains(state.state))
-            seen.add(state.state)
+            seen.addOne(state.state)
           for (i <- state.nextStates if !seen.contains(i) && i != StateAssigner.Terminal) {
             loop(map(i))
           }

src/compiler/scala/tools/nsc/transform/patmat/Logic.scala

@@ -230,7 +230,8 @@ trait Logic extends Debugging {
           checkPair(a, b) || checkPair(a, c) || checkPair(b, c)
         } else {
           val ops = new Array[Prop](size)
-          ops0.copyToArray(ops)
+          @annotation.unused val copied = ops0.copyToArray(ops)
+          //assert(copied == ops.length, "")
           var i = 0
           val len = ops.length
           while (i < len - 1) {

src/compiler/scala/tools/nsc/transform/patmat/PatternExpansion.scala

@@ -241,7 +241,7 @@ trait PatternExpansion {
       val offeringString = if (isErroneous) "<error>" else productTypes match {
         case tps if isSeq => (tps.map(_.toString) :+ s"${elementType}*").mkString("(", ", ", ")")
         case Nil       => "Boolean"
-        case tp :: Nil => tp
+        case tp :: Nil => tp.toString
         case tps       => tps.mkString("(", ", ", ")")
       }
       val offerString = if (isErroneous) "" else s" offering $offeringString"

src/compiler/scala/tools/nsc/transform/patmat/Solving.scala

@@ -356,7 +356,8 @@ trait Solving extends Logic {
           // scala/bug#6942:
           // CNF(P1 /\ ... /\ PN) == CNF(P1) ++ CNF(...) ++ CNF(PN)
           val cnfs = new Array[Solvable](props.size)
-          props.iterator.map(x => cnfFor(x)).copyToArray(cnfs)
+          @annotation.unused val copied = props.iterator.map(x => cnfFor(x)).copyToArray(cnfs)
+          //assert(copied == cnfs.length, "")
           new Solvable(cnfs.flatten[Clause](_.cnf, reflect.classTag[Clause]), cnfs.head.symbolMapping)
         case p          =>
           cnfFor(p)

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

@@ -68,7 +68,7 @@ trait Analyzer extends AnyRef
           case ModuleDef(_, _, _) =>
             if (tree.symbol.name == nme.PACKAGEkw) {
               // we've actually got a source file
-              deferredOpen.remove(tree.symbol.owner)
+              deferredOpen.subtractOne(tree.symbol.owner)
 
               openPackageModule(tree.symbol, tree.symbol.owner)
             }