General cleanups and less warnings during a Scala build

48 files changed, 80 insertions, 128 deletions

diff --git a/src/compiler/scala/reflect/macros/contexts/Reifiers.scala b/src/compiler/scala/reflect/macros/contexts/Reifiers.scala
index ecef1c7289..010829f6ab 100644
--- a/src/compiler/scala/reflect/macros/contexts/Reifiers.scala
+++ b/src/compiler/scala/reflect/macros/contexts/Reifiers.scala
@@ -61,9 +61,9 @@ trait Reifiers {
       // logging free vars only when they are untyped prevents avalanches of duplicate messages
       symtab.syms map (sym => symtab.symDef(sym)) foreach {
         case FreeTermDef(_, _, binding, _, origin) if universe.settings.logFreeTerms && binding.tpe == null =>
-          reporter.echo(position, "free term: %s %s".format(showRaw(binding), origin))
+          reporter.echo(position, s"free term: ${showRaw(binding)} $origin")
         case FreeTypeDef(_, _, binding, _, origin) if universe.settings.logFreeTypes && binding.tpe == null =>
-          reporter.echo(position, "free type: %s %s".format(showRaw(binding), origin))
+          reporter.echo(position, s"free type: ${showRaw(binding)} $origin")
         case _ =>
           // do nothing
       }
diff --git a/src/compiler/scala/reflect/macros/contexts/Typers.scala b/src/compiler/scala/reflect/macros/contexts/Typers.scala
index baf066c7d9..a0dfbf5df1 100644
--- a/src/compiler/scala/reflect/macros/contexts/Typers.scala
+++ b/src/compiler/scala/reflect/macros/contexts/Typers.scala
@@ -40,12 +40,12 @@ trait Typers {
   }
 
   def inferImplicitValue(pt: Type, silent: Boolean = true, withMacrosDisabled: Boolean = false, pos: Position = enclosingPosition): Tree = {
-    macroLogVerbose("inferring implicit value of type %s, macros = %s".format(pt, !withMacrosDisabled))
+    macroLogVerbose(s"inferring implicit value of type $pt, macros = ${!withMacrosDisabled}")
     universe.analyzer.inferImplicit(universe.EmptyTree, pt, false, callsiteTyper.context, silent, withMacrosDisabled, pos, (pos, msg) => throw TypecheckException(pos, msg))
   }
 
   def inferImplicitView(tree: Tree, from: Type, to: Type, silent: Boolean = true, withMacrosDisabled: Boolean = false, pos: Position = enclosingPosition): Tree = {
-    macroLogVerbose("inferring implicit view from %s to %s for %s, macros = %s".format(from, to, tree, !withMacrosDisabled))
+    macroLogVerbose(s"inferring implicit view from $from to $to for $tree, macros = ${!withMacrosDisabled}")
     val viewTpe = universe.appliedType(universe.definitions.FunctionClass(1).toTypeConstructor, List(from, to))
     universe.analyzer.inferImplicit(tree, viewTpe, true, callsiteTyper.context, silent, withMacrosDisabled, pos, (pos, msg) => throw TypecheckException(pos, msg))
   }
diff --git a/src/compiler/scala/reflect/macros/runtime/MacroRuntimes.scala b/src/compiler/scala/reflect/macros/runtime/MacroRuntimes.scala
index d4b8175d28..7e700a524c 100644
--- a/src/compiler/scala/reflect/macros/runtime/MacroRuntimes.scala
+++ b/src/compiler/scala/reflect/macros/runtime/MacroRuntimes.scala
@@ -4,7 +4,6 @@ package runtime
 import java.net.URLClassLoader
 
 import scala.reflect.internal.Flags._
-import scala.reflect.internal.util.ScalaClassLoader
 import scala.reflect.runtime.ReflectionUtils
 import scala.reflect.internal.util.AbstractFileClassLoader
 
@@ -84,4 +83,4 @@ trait MacroRuntimes extends JavaReflectionRuntimes {
       }
     }
   }
-}
\ No newline at end of file
+}
diff --git a/src/compiler/scala/tools/ant/FastScalac.scala b/src/compiler/scala/tools/ant/FastScalac.scala
index e0b7be8004..3b62c493d3 100644
--- a/src/compiler/scala/tools/ant/FastScalac.scala
+++ b/src/compiler/scala/tools/ant/FastScalac.scala
@@ -109,7 +109,7 @@ class FastScalac extends Scalac {
       List(
         /*scalac*/
         s.debuginfo, s.target
-      ) filter (x => x.value != x.default) map (x => "%s:%s".format(x.name, x.value))
+      ) filter (x => x.value != x.default) map (x => s"${x.name}:${x.value}")
 
     val booleanSettings =
       List(
@@ -129,7 +129,7 @@ class FastScalac extends Scalac {
     val phaseSetting = {
       val s = settings.log
       if (s.value.isEmpty) Nil
-      else List("%s:%s".format(s.name, s.value.mkString(",")))
+      else List(s"${s.name}:${s.value.mkString(",")}")
     }
 
     val fscOptions =
@@ -147,8 +147,7 @@ class FastScalac extends Scalac {
         case cl: AntClassLoader =>
           path add new Path(getProject, cl.getClasspath)
         case _ =>
-          buildError("Compilation failed because of an internal compiler error;"+
-                     " see the error output for details.")
+          buildError("Compilation failed because of an internal compiler error; see the error output for details.")
       }
       path
     }
@@ -160,8 +159,7 @@ class FastScalac extends Scalac {
       File(url.getFile).jfile.getParentFile.getParentFile.getAbsolutePath
     } catch {
       case _: Throwable =>
-        buildError("Compilation failed because of an internal compiler error;"+
-                   " couldn't determine value for -Dscala.home=<value>")
+        buildError("Compilation failed because of an internal compiler error; couldn't determine value for -Dscala.home=<value>")
     }
     java.createJvmarg() setValue "-Dscala.usejavacp=true"
     java.createJvmarg() setValue ("-Dscala.home="+scalaHome)
@@ -186,7 +184,6 @@ class FastScalac extends Scalac {
     val res = execWithArgFiles(java, paths)
 
     if (failonerror && res != 0)
-      buildError("Compilation failed because of an internal compiler error;"+
-            " see the error output for details.")
+      buildError("Compilation failed because of an internal compiler error; see the error output for details.")
   }
 }
diff --git a/src/compiler/scala/tools/ant/Scalac.scala b/src/compiler/scala/tools/ant/Scalac.scala
index fe9815be20..930163af36 100644
--- a/src/compiler/scala/tools/ant/Scalac.scala
+++ b/src/compiler/scala/tools/ant/Scalac.scala
@@ -551,7 +551,7 @@ class Scalac extends ScalaMatchingTask with ScalacShared {
         val str =
           if (javaFiles.isEmpty) "%d source file%s".format(list.length, plural(list))
           else "%d scala and %d java source files".format(scalaFiles.length, javaFiles.length)
-        log("Compiling %s to %s".format(str, getDestination.toString))
+        log(s"Compiling $str to $getDestination")
       }
       else log("No files selected for compilation", Project.MSG_VERBOSE)
 
diff --git a/src/compiler/scala/tools/cmd/CommandLine.scala b/src/compiler/scala/tools/cmd/CommandLine.scala
index 781cc564cb..3a36a7d345 100644
--- a/src/compiler/scala/tools/cmd/CommandLine.scala
+++ b/src/compiler/scala/tools/cmd/CommandLine.scala
@@ -51,7 +51,7 @@ class CommandLine(val spec: Reference, val originalArgs: List[String]) extends C
       /* Assumes known options have all been ruled out already. */
       def isUnknown(opt: String) =
         onlyKnownOptions && (opt startsWith "-") && {
-          errorFn("Option '%s' not recognized.".format(opt))
+          errorFn(s"Option '$opt' not recognized.")
           true
         }
 
@@ -61,7 +61,7 @@ class CommandLine(val spec: Reference, val originalArgs: List[String]) extends C
         case x :: Nil         =>
           expand(x) foreach (exp => return loop(exp))
           if (isBinaryOption(x) && enforceArity)
-            errorFn("Option '%s' requires argument, found EOF instead.".format(x))
+            errorFn(s"Option '$x' requires argument, found EOF instead.")
 
           if (isUnaryOption(x)) mapForUnary(x)
           else if (isUnknown(x)) Map()
diff --git a/src/compiler/scala/tools/cmd/Opt.scala b/src/compiler/scala/tools/cmd/Opt.scala
index df3d0c4462..70756c5bb2 100644
--- a/src/compiler/scala/tools/cmd/Opt.scala
+++ b/src/compiler/scala/tools/cmd/Opt.scala
@@ -20,7 +20,7 @@ object Opt {
     self: Implicit =>
 
     protected def fail(msg: String) = runAndExit(println(programInfo.runner + ": " + msg))
-    protected def failOption(arg: String, why: String) = fail("%s: '%s' is %s".format(opt, arg, why))
+    protected def failOption(arg: String, why: String) = fail(s"$opt: '$arg' is $why")
   }
 
   trait Implicit {
diff --git a/src/compiler/scala/tools/cmd/Reference.scala b/src/compiler/scala/tools/cmd/Reference.scala
index 62b6c893cf..25a16b1e3e 100644
--- a/src/compiler/scala/tools/cmd/Reference.scala
+++ b/src/compiler/scala/tools/cmd/Reference.scala
@@ -70,18 +70,18 @@ object Reference {
     def addHelpAlias(f: () => String) = mapHelp { s =>
       val str = "alias for '%s'" format f()
       def noHelp = (helpFormatStr.format("", "")).length == s.length
-      val str2 = if (noHelp) str else " (" + str + ")"
+      val str2 = if (noHelp) str else s" ($str)"
 
       s + str2
     }
     def addHelpDefault(f: () => String): Unit = mapHelp { s =>
       val str = "(default: %s)" format f()
 
-      if (s.length + str.length < MaxLine) s + " " + str
+      if (s.length + str.length < MaxLine) s"$s $str"
       else defaultFormatStr.format(s, str)
     }
     def addHelpEnvDefault(name: String): Unit = mapHelp { s =>
-      val line1     = "%s (default: %s)".format(s, name)
+      val line1     = s"$s (default: $name)"
       val envNow    = envOrNone(name) map ("'" + _ + "'") getOrElse "unset"
       val line2     = defaultFormatStr.format("Currently " + envNow)
 
diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index 1a794f7554..847c4cb2d1 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -283,7 +283,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
   // Over 200 closure objects are eliminated by inlining this.
   @inline final def log(msg: => AnyRef) {
     if (shouldLogAtThisPhase)
-      inform("[log %s%s] %s".format(globalPhase, atPhaseStackMessage, msg))
+      inform(s"[log $globalPhase$atPhaseStackMessage] $msg")
   }
 
   @inline final override def debuglog(msg: => String) {
@@ -305,10 +305,10 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
       try Some(Charset.forName(name))
       catch {
         case _: IllegalCharsetNameException =>
-          globalError("illegal charset name '" + name + "'")
+          globalError(s"illegal charset name '$name'")
           None
         case _: UnsupportedCharsetException =>
-          globalError("unsupported charset '" + name + "'")
+          globalError(s"unsupported charset '$name'")
           None
       }
 
diff --git a/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala b/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala
index 9a53737554..00771b6b8c 100644
--- a/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala
+++ b/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala
@@ -7,7 +7,7 @@ package scala
 package tools.nsc
 package backend
 
-import scala.collection.{ mutable, immutable }
+import scala.collection.mutable
 
 /** Scala primitive operations are represented as methods in `Any` and
  *  `AnyVal` subclasses. Here we demultiplex them by providing a mapping
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
index a4d08cb123..6d3d458324 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
@@ -11,7 +11,6 @@ package jvm
 
 import scala.annotation.switch
 import scala.reflect.internal.Flags
-import java.lang.invoke.LambdaMetafactory
 
 import scala.tools.asm
 import GenBCode._
@@ -803,7 +802,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
       for (caze @ CaseDef(pat, guard, body) <- tree.cases) {
         assert(guard == EmptyTree, guard)
         val switchBlockPoint = new asm.Label
-        switchBlocks ::= (switchBlockPoint, body)
+        switchBlocks ::= ((switchBlockPoint, body))
         pat match {
           case Literal(value) =>
             flatKeys ::= value.intValue
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
index a2ccce9d21..c5fb2d3604 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
@@ -8,7 +8,6 @@ package tools.nsc
 package backend.jvm
 
 import scala.tools.asm
-import scala.collection.mutable
 import scala.tools.nsc.io.AbstractFile
 import GenBCode._
 import BackendReporting._
@@ -896,10 +895,10 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
 
         if(!isValidSignature) {
           reporter.warning(sym.pos,
-              """|compiler bug: created invalid generic signature for %s in %s
-                 |signature: %s
+            sm"""|compiler bug: created invalid generic signature for $sym in ${sym.owner.skipPackageObject.fullName}
+                 |signature: $sig
                  |if this is reproducible, please report bug at https://issues.scala-lang.org/
-              """.trim.stripMargin.format(sym, sym.owner.skipPackageObject.fullName, sig))
+              """.trim)
           return null
         }
       }
@@ -909,13 +908,13 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
         val bytecodeTpe = owner.thisType.memberInfo(sym)
         if (!sym.isType && !sym.isConstructor && !(erasure.erasure(sym)(normalizedTpe) =:= bytecodeTpe)) {
           reporter.warning(sym.pos,
-              """|compiler bug: created generic signature for %s in %s that does not conform to its erasure
-                 |signature: %s
-                 |original type: %s
-                 |normalized type: %s
-                 |erasure type: %s
+            sm"""|compiler bug: created generic signature for $sym in ${sym.owner.skipPackageObject.fullName} that does not conform to its erasure
+                 |signature: $sig
+                 |original type: $memberTpe
+                 |normalized type: $normalizedTpe
+                 |erasure type: $bytecodeTpe
                  |if this is reproducible, please report bug at http://issues.scala-lang.org/
-              """.trim.stripMargin.format(sym, sym.owner.skipPackageObject.fullName, sig, memberTpe, normalizedTpe, bytecodeTpe))
+              """.trim)
            return null
         }
       }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala b/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala
index 1d29fdee10..84f6d87c5c 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala
@@ -6,7 +6,7 @@
 package scala.tools.nsc
 package backend.jvm
 
-import java.io.{ DataOutputStream, FileOutputStream, IOException, OutputStream, File => JFile }
+import java.io.{ DataOutputStream, FileOutputStream, IOException, File => JFile }
 import scala.tools.nsc.io._
 import java.util.jar.Attributes.Name
 import scala.language.postfixOps
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala
index ab9fd94a93..4d03f9851e 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala
@@ -1,7 +1,6 @@
 package scala.tools.nsc
 package backend.jvm
 
-import scala.annotation.switch
 import scala.tools.asm
 import scala.tools.nsc.backend.jvm.BTypes.InternalName
 
@@ -31,7 +30,7 @@ import scala.tools.nsc.backend.jvm.BTypes.InternalName
 class CoreBTypes[BTFS <: BTypesFromSymbols[_ <: Global]](val bTypes: BTFS) {
   import bTypes._
   import global._
-  import rootMirror.{requiredClass, requiredModule, getRequiredClass, getClassIfDefined}
+  import rootMirror.{requiredClass, getRequiredClass, getClassIfDefined}
   import definitions._
 
   /**
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala b/src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala
index a6b9faa933..f1facce173 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala
@@ -3,13 +3,12 @@ package backend.jvm
 package analysis
 
 import scala.annotation.switch
-import scala.tools.asm.{Handle, Type, Label}
+import scala.tools.asm.{Handle, Type}
 import scala.tools.asm.Opcodes._
 import scala.tools.asm.tree._
 import scala.tools.asm.tree.analysis.{Frame, BasicInterpreter, Analyzer, Value}
 import GenBCode._
 import scala.tools.nsc.backend.jvm.BTypes._
-import scala.tools.nsc.backend.jvm.opt.BytecodeUtils
 import scala.tools.nsc.backend.jvm.opt.BytecodeUtils._
 import java.lang.invoke.LambdaMetafactory
 import scala.collection.mutable
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/analysis/ProdConsAnalyzerImpl.scala b/src/compiler/scala/tools/nsc/backend/jvm/analysis/ProdConsAnalyzerImpl.scala
index 419c686bd8..6b645cb803 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/analysis/ProdConsAnalyzerImpl.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/analysis/ProdConsAnalyzerImpl.scala
@@ -15,7 +15,6 @@ import scala.tools.asm.{Type, MethodVisitor}
 import scala.tools.asm.Opcodes._
 import scala.tools.asm.tree._
 import scala.tools.asm.tree.analysis._
-import scala.tools.nsc.backend.jvm.BTypes.InternalName
 
 import opt.BytecodeUtils._
 
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala
index f48f60a438..2afc095af6 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala
@@ -8,6 +8,7 @@ package backend.jvm
 package opt
 
 import scala.annotation.{tailrec, switch}
+
 import scala.collection.mutable
 import scala.reflect.internal.util.Collections._
 import scala.tools.asm.commons.CodeSizeEvaluator
@@ -17,7 +18,6 @@ import scala.tools.asm.Opcodes._
 import scala.tools.asm.tree._
 import GenBCode._
 import scala.collection.convert.decorateAsScala._
-import scala.tools.nsc.backend.jvm.BTypes.InternalName
 import scala.tools.nsc.backend.jvm.analysis.InstructionStackEffect
 
 object BytecodeUtils {
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/ClosureOptimizer.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/ClosureOptimizer.scala
index 4935b9d1a0..e5d2e030f9 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/ClosureOptimizer.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/ClosureOptimizer.scala
@@ -8,10 +8,10 @@ package backend.jvm
 package opt
 
 import scala.annotation.switch
-import scala.collection.{mutable, immutable}
+import scala.collection.mutable
 import scala.collection.immutable.IntMap
 import scala.reflect.internal.util.NoPosition
-import scala.tools.asm.{Handle, Type, Opcodes}
+import scala.tools.asm.{Type, Opcodes}
 import scala.tools.asm.tree._
 import scala.tools.nsc.backend.jvm.BTypes.InternalName
 import BytecodeUtils._
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/InlinerHeuristics.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/InlinerHeuristics.scala
index 7e35d0e7f0..388c35274b 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/InlinerHeuristics.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/InlinerHeuristics.scala
@@ -7,9 +7,7 @@ package scala.tools.nsc
 package backend.jvm
 package opt
 
-import scala.collection.immutable.IntMap
-import scala.tools.asm.Type
-import scala.tools.asm.tree.{MethodNode, MethodInsnNode}
+import scala.tools.asm.tree.MethodNode
 import scala.tools.nsc.backend.jvm.BTypes.InternalName
 import scala.collection.convert.decorateAsScala._
 import scala.tools.nsc.backend.jvm.BackendReporting.OptimizerWarning
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala
index 085463633f..f120357c63 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala
@@ -8,11 +8,12 @@ package backend.jvm
 package opt
 
 import scala.annotation.{tailrec, switch}
+
 import scala.tools.asm.Type
 import scala.tools.asm.tree.analysis.Frame
 import scala.tools.asm.Opcodes._
 import scala.tools.asm.tree._
-import scala.collection.{mutable, immutable}
+import scala.collection.mutable
 import scala.collection.convert.decorateAsScala._
 import scala.tools.nsc.backend.jvm.BTypes.InternalName
 import scala.tools.nsc.backend.jvm.analysis._
diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
index e924dc856a..7b98011759 100644
--- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
@@ -9,10 +9,11 @@ package tools
 package nsc
 package settings
 
+import scala.language.existentials
+
 import scala.annotation.elidable
 import scala.tools.util.PathResolver.Defaults
 import scala.collection.mutable
-import scala.language.{implicitConversions, existentials}
 
 trait ScalaSettings extends AbsScalaSettings
                        with StandardScalaSettings
diff --git a/src/compiler/scala/tools/nsc/settings/Warnings.scala b/src/compiler/scala/tools/nsc/settings/Warnings.scala
index f570037760..79795bcc17 100644
--- a/src/compiler/scala/tools/nsc/settings/Warnings.scala
+++ b/src/compiler/scala/tools/nsc/settings/Warnings.scala
@@ -7,8 +7,6 @@ package scala.tools
 package nsc
 package settings
 
-import language.existentials
-
 /** Settings influencing the printing of warnings.
  */
 trait Warnings {
diff --git a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
index 1cee76ae65..9a8eca152f 100644
--- a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
+++ b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
@@ -8,7 +8,6 @@ package transform
 
 import symtab._
 import Flags._
-import scala.tools.nsc.util.ClassPath
 
 abstract class AddInterfaces extends InfoTransform { self: Erasure =>
   import global._                  // the global environment
diff --git a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala
index 76c84bd428..d350ca8e17 100644
--- a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala
+++ b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala
@@ -4,7 +4,6 @@ package transform
 import symtab._
 import Flags._
 import scala.collection._
-import scala.collection.mutable.LinkedHashMap
 
 /**
   * This transformer is responsible for preparing Function nodes for runtime,
diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
index 0050d08f1b..4b1f1efee4 100644
--- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
+++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
@@ -9,8 +9,6 @@ package transform
 
 import scala.tools.nsc.symtab.Flags
 import scala.collection.{ mutable, immutable }
-import scala.language.postfixOps
-import scala.language.existentials
 import scala.annotation.tailrec
 
 /** Specialize code on types.
@@ -168,7 +166,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
 
     /** Reduce the given environment to contain mappings only for type variables in tps. */
     def restrict(env: TypeEnv, tps: immutable.Set[Symbol]): TypeEnv =
-      env filterKeys tps toMap
+      env.filterKeys(tps).toMap
 
     /** Is the given environment a valid specialization for sym?
      *  It is valid if each binding is from a @specialized type parameter in sym (or its owner)
@@ -367,7 +365,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
     }
   )
 
-  lazy val specializableTypes = ScalaValueClasses map (_.tpe) sorted
+  lazy val specializableTypes = ScalaValueClasses.map(_.tpe).sorted
 
   /** If the symbol is the companion of a value class, the value class.
    *  Otherwise, AnyRef.
@@ -386,7 +384,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
     val types = if (!sym.isSpecialized)
       Nil // no @specialized Annotation
     else
-      specializedOn(sym) map (s => specializesClass(s).tpe) sorted
+      specializedOn(sym).map(s => specializesClass(s).tpe).sorted
 
     if (isBoundedGeneric(sym.tpe) && (types contains AnyRefClass))
       reporter.warning(sym.pos, sym + " is always a subtype of " + AnyRefTpe + ".")
@@ -474,7 +472,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
     case ExistentialType(_, res)     => specializedTypeVars(res)
     case AnnotatedType(_, tp)        => specializedTypeVars(tp)
     case TypeBounds(lo, hi)          => specializedTypeVars(lo :: hi :: Nil)
-    case RefinedType(parents, _)     => parents flatMap specializedTypeVars toSet
+    case RefinedType(parents, _)     => parents.flatMap(specializedTypeVars).toSet
     case _                           => immutable.Set.empty
   }
 
@@ -861,7 +859,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
               if (unusedStvars.length == 1) "is" else "are")
           )
           unusedStvars foreach (_ removeAnnotation SpecializedClass)
-          specializingOn = specializingOn filterNot (unusedStvars contains)
+          specializingOn = specializingOn filterNot (unusedStvars contains _)
         }
         for (env0 <- specializations(specializingOn) if needsSpecialization(env0, sym)) yield {
           // !!! Can't this logic be structured so that the new symbol's name is
@@ -1021,7 +1019,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
         case (NoSymbol, _)     =>
           if (overriding.isSuperAccessor) {
             val alias = overriding.alias
-            debuglog("checking special overload for super accessor: %s, alias for %s".format(overriding.fullName, alias.fullName))
+            debuglog(s"checking special overload for super accessor: ${overriding.fullName}, alias for ${alias.fullName}")
             needsSpecialOverride(alias) match {
               case nope @ (NoSymbol, _) => None
               case (overridden, env) =>
@@ -1043,7 +1041,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
               param.name = overriding.paramss(i)(j).name // SI-6555 Retain the parameter names from the subclass.
             }
           }
-          debuglog("specialized overload %s for %s in %s: %s".format(om, overriding.name.decode, pp(env), om.info))
+          debuglog(s"specialized overload $om for ${overriding.name.decode} in ${pp(env)}: ${om.info}")
           if (overriding.isAbstractOverride) om.setFlag(ABSOVERRIDE)
           typeEnv(om) = env
           addConcreteSpecMethod(overriding)
@@ -1092,7 +1090,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
    */
   private def unify(tp1: Type, tp2: Type, env: TypeEnv, strict: Boolean, tparams: Boolean = false): TypeEnv = (tp1, tp2) match {
     case (TypeRef(_, sym1, _), _) if sym1.isSpecialized =>
-      debuglog("Unify " + tp1 + ", " + tp2)
+      debuglog(s"Unify $tp1, $tp2")
       if (isPrimitiveValueClass(tp2.typeSymbol) || isSpecializedAnyRefSubtype(tp2, sym1))
         env + ((sym1, tp2))
       else if (isSpecializedAnyRefSubtype(tp2, sym1))
@@ -1103,20 +1101,20 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
         env
     case (TypeRef(_, sym1, args1), TypeRef(_, sym2, args2)) =>
       if (args1.nonEmpty || args2.nonEmpty)
-        debuglog("Unify types " + tp1 + " and " + tp2)
+        debuglog(s"Unify types $tp1 and $tp2")
 
       if (strict && args1.length != args2.length) unifyError(tp1, tp2)
       val e = unify(args1, args2, env, strict)
-      if (e.nonEmpty) debuglog("unified to: " + e)
+      if (e.nonEmpty) debuglog(s"unified to: $e")
       e
     case (TypeRef(_, sym1, _), _) if sym1.isTypeParameterOrSkolem =>
       env
     case (MethodType(params1, res1), MethodType(params2, res2)) =>
       if (strict && params1.length != params2.length) unifyError(tp1, tp2)
-      debuglog("Unify methods " + tp1 + " and " + tp2)
+      debuglog(s"Unify methods $tp1 and $tp2")
       unify(res1 :: (params1 map (_.tpe)), res2 :: (params2 map (_.tpe)), env, strict)
     case (PolyType(tparams1, res1), PolyType(tparams2, res2)) =>
-      debuglog("Unify polytypes " + tp1 + " and " + tp2)
+      debuglog(s"Unify polytypes $tp1 and $tp2")
       if (strict && tparams1.length != tparams2.length)
         unifyError(tp1, tp2)
       else if (tparams && tparams1.length == tparams2.length)
@@ -1134,7 +1132,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
     case (ExistentialType(_, res1), _)                => unify(tp2, res1, env, strict)
     case (TypeBounds(lo1, hi1), TypeBounds(lo2, hi2)) => unify(List(lo1, hi1), List(lo2, hi2), env, strict)
     case _ =>
-      debuglog("don't know how to unify %s [%s] with %s [%s]".format(tp1, tp1.getClass, tp2, tp2.getClass))
+      debuglog(s"don't know how to unify $tp1 [${tp1.getClass}] with $tp2 [${tp2.getClass}]")
       env
   }
 
@@ -1144,9 +1142,9 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
       if (!strict) unify(args._1, args._2, env, strict)
       else {
         val nenv = unify(args._1, args._2, emptyEnv, strict)
-        if (env.keySet intersect nenv.keySet isEmpty) env ++ nenv
+        if (env.keySet.intersect(nenv.keySet).isEmpty) env ++ nenv
         else {
-          debuglog("could not unify: u(" + args._1 + ", " + args._2 + ") yields " + nenv + ", env: " + env)
+          debuglog(s"could not unify: u(${args._1}, ${args._2}) yields $nenv, env: $env")
           unifyError(tp1, tp2)
         }
       }
@@ -1242,7 +1240,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
     env forall { case (tvar, tpe) =>
       matches(tvar.info.bounds.lo, tpe) && matches(tpe, tvar.info.bounds.hi) || {
         if (warnings)
-          reporter.warning(tvar.pos, "Bounds prevent specialization of " + tvar)
+          reporter.warning(tvar.pos, s"Bounds prevent specialization of $tvar")
 
         debuglog("specvars: " +
           tvar.info.bounds.lo + ": " +
@@ -1373,7 +1371,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
             sym, currentClass, sym.owner.enclClass, isAccessible(sym), nme.isLocalName(sym.name))
           )
         if (shouldMakePublic(sym) && !isAccessible(sym)) {
-          debuglog("changing private flag of " + sym)
+          debuglog(s"changing private flag of $sym")
           sym.makeNotPrivate(sym.owner)
         }
         super.transform(tree)
@@ -1428,10 +1426,10 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
       (treeType =:= memberType) || { // anyref specialization
         memberType match {
           case PolyType(_, resTpe) =>
-            debuglog("Conformance for anyref - polytype with result type: " + resTpe + " and " + treeType + "\nOrig. sym.: " + origSymbol)
+            debuglog(s"Conformance for anyref - polytype with result type: $resTpe and $treeType\nOrig. sym.: $origSymbol")
             try {
               val e = unify(origSymbol.tpe, memberType, emptyEnv, true)
-              debuglog("obtained env: " + e)
+              debuglog(s"obtained env: $e")
               e.keySet == env.keySet
             } catch {
               case _: Throwable =>
@@ -1531,7 +1529,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
         )
 
         val tree1 = gen.mkTypeApply(specTree, residualTargs)
-        debuglog("rewrote " + tree + " to " + tree1)
+        debuglog(s"rewrote $tree to $tree1")
         localTyper.typedOperator(atPos(tree.pos)(tree1)) // being polymorphic, it must be a method
       }
 
@@ -1539,7 +1537,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
       tree match {
         case Apply(Select(New(tpt), nme.CONSTRUCTOR), args) =>
           def transformNew = {
-            debuglog("Attempting to specialize new %s(%s)".format(tpt, args.mkString(", ")))
+            debuglog(s"Attempting to specialize new $tpt(${args.mkString(", ")})")
             val found = specializedType(tpt.tpe)
             if (found.typeSymbol ne tpt.tpe.typeSymbol) { // the ctor can be specialized
               val inst = New(found, transformTrees(args): _*)
diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
index 628090dba5..e0b1543f24 100644
--- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala
+++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
@@ -8,7 +8,6 @@ package tools.nsc
 package transform
 
 import scala.annotation.tailrec
-import scala.language.postfixOps
 
 import symtab.Flags._
 import scala.collection.mutable
diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala
index 2b16995f0b..ec493b9507 100644
--- a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala
+++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala
@@ -6,8 +6,6 @@
 
 package scala.tools.nsc.transform.patmat
 
-import scala.language.postfixOps
-
 import scala.collection.mutable
 import scala.reflect.internal.util.Statistics
 
diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchWarnings.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchWarnings.scala
index 27d674762f..3f27d18e64 100644
--- a/src/compiler/scala/tools/nsc/transform/patmat/MatchWarnings.scala
+++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchWarnings.scala
@@ -6,8 +6,6 @@
 
 package scala.tools.nsc.transform.patmat
 
-import scala.language.postfixOps
-
 trait MatchWarnings {
   self: PatternMatching =>
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
index abc3e91ed2..c03094bc6a 100644
--- a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
@@ -5,8 +5,6 @@
 package scala.tools.nsc
 package typechecker
 
-import scala.language.higherKinds
-
 import symtab.Flags._
 import scala.reflect.internal.util.StringOps.ojoin
 import scala.reflect.internal.util.ListOfNil
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index fdf7058ab1..8f5c4b9f6d 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -2882,7 +2882,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
         val paramsMissingType = mutable.ArrayBuffer.empty[ValDef] //.sizeHint(numVparams) probably useless, since initial size is 16 and max fun arity is 22
         // first, try to define param types from expected function's arg types if needed
         foreach2(vparams, argpts) { (vparam, argpt) =>
-          if (vparam.tpt isEmpty) {
+          if (vparam.tpt.isEmpty) {
             if (isFullyDefined(argpt)) vparam.tpt setType argpt
             else paramsMissingType += vparam
 
diff --git a/src/compiler/scala/tools/util/PathResolver.scala b/src/compiler/scala/tools/util/PathResolver.scala
index 1c9167b2ea..9decc99c8d 100644
--- a/src/compiler/scala/tools/util/PathResolver.scala
+++ b/src/compiler/scala/tools/util/PathResolver.scala
@@ -7,14 +7,11 @@ package scala
 package tools
 package util
 
-import scala.language.postfixOps
-
 import java.net.URL
 import scala.tools.reflect.WrappedProperties.AccessControl
 import scala.tools.nsc.Settings
 import scala.tools.nsc.util.{ ClassFileLookup, ClassPath, JavaClassPath }
 import scala.reflect.io.{ File, Directory, Path, AbstractFile }
-import scala.reflect.runtime.ReflectionUtils
 import ClassPath.{ JavaContext, DefaultJavaContext, split }
 import PartialFunction.condOpt
 import scala.tools.nsc.classpath.{ AggregateFlatClassPath, ClassPathFactory, FlatClassPath, FlatClassPathFactory }
diff --git a/src/interactive/scala/tools/nsc/interactive/Pickler.scala b/src/interactive/scala/tools/nsc/interactive/Pickler.scala
index c0446b0402..ffd3b7bc64 100644
--- a/src/interactive/scala/tools/nsc/interactive/Pickler.scala
+++ b/src/interactive/scala/tools/nsc/interactive/Pickler.scala
@@ -1,7 +1,5 @@
 package scala.tools.nsc.interactive
 
-import scala.language.implicitConversions
-
 import Lexer._
 import java.io.Writer
 
diff --git a/src/library/scala/collection/mutable/IndexedSeqView.scala b/src/library/scala/collection/mutable/IndexedSeqView.scala
index 7acdeeff18..b525baaf5f 100644
--- a/src/library/scala/collection/mutable/IndexedSeqView.scala
+++ b/src/library/scala/collection/mutable/IndexedSeqView.scala
@@ -15,7 +15,6 @@ package mutable
 import generic._
 
 import TraversableView.NoBuilder
-import scala.language.implicitConversions
 
 /** A non-strict view of a mutable `IndexedSeq`.
  *  $viewInfo
diff --git a/src/library/scala/collection/mutable/ReusableBuilder.scala b/src/library/scala/collection/mutable/ReusableBuilder.scala
index caab3071b6..83a4fcfc29 100644
--- a/src/library/scala/collection/mutable/ReusableBuilder.scala
+++ b/src/library/scala/collection/mutable/ReusableBuilder.scala
@@ -11,8 +11,6 @@ package scala
 package collection
 package mutable
 
-import generic._
-
 /** `ReusableBuilder` is a marker trait that indicates that a `Builder`
  *  can be reused to build more than one instance of a collection.  In
  *  particular, calling `result` followed by `clear` will produce a
@@ -44,7 +42,7 @@ trait ReusableBuilder[-Elem, +To] extends Builder[Elem, To] {
    *  After a call to `result`, the behavior of all other methods is undefined
    *  save for `clear`.  If `clear` is called, then the builder is reset and
    *  may be used to build another instance.
-   *  
+   *
    *  @return a collection containing the elements added to this builder.
    */
   override def result(): To    // Note: overriding for scaladoc only!
diff --git a/src/library/scala/collection/parallel/mutable/LazyCombiner.scala b/src/library/scala/collection/parallel/mutable/LazyCombiner.scala
index 5ab2bb81c6..cc25b5b4b2 100644
--- a/src/library/scala/collection/parallel/mutable/LazyCombiner.scala
+++ b/src/library/scala/collection/parallel/mutable/LazyCombiner.scala
@@ -30,7 +30,6 @@ trait LazyCombiner[Elem, +To, Buff <: Growable[Elem] with Sizing] extends Combin
   def result: To = allocateAndCopy
   def clear() = { chain.clear() }
   def combine[N <: Elem, NewTo >: To](other: Combiner[N, NewTo]): Combiner[N, NewTo] = if (this ne other) {
-    import language.existentials // FIXME: See SI-7750
     if (other.isInstanceOf[LazyCombiner[_, _, _]]) {
       val that = other.asInstanceOf[LazyCombiner[Elem, To, Buff]]
       newLazyCombiner(chain ++= that.chain)
diff --git a/src/library/scala/collection/parallel/mutable/ParTrieMap.scala b/src/library/scala/collection/parallel/mutable/ParTrieMap.scala
index a1dc37cec9..2faf223b99 100644
--- a/src/library/scala/collection/parallel/mutable/ParTrieMap.scala
+++ b/src/library/scala/collection/parallel/mutable/ParTrieMap.scala
@@ -152,18 +152,9 @@ extends TrieMapIterator[K, V](lev, ct, mustInit)
 /** Only used within the `ParTrieMap`. */
 private[mutable] trait ParTrieMapCombiner[K, V] extends Combiner[(K, V), ParTrieMap[K, V]] {
 
-  def combine[N <: (K, V), NewTo >: ParTrieMap[K, V]](other: Combiner[N, NewTo]): Combiner[N, NewTo] = if (this eq other) this else {
-    throw new UnsupportedOperationException("This shouldn't have been called in the first place.")
-
-    val thiz = this.asInstanceOf[ParTrieMap[K, V]]
-    val that = other.asInstanceOf[ParTrieMap[K, V]]
-    val result = new ParTrieMap[K, V]
-
-    result ++= thiz.iterator
-    result ++= that.iterator
-
-    result
-  }
+  def combine[N <: (K, V), NewTo >: ParTrieMap[K, V]](other: Combiner[N, NewTo]): Combiner[N, NewTo] =
+    if (this eq other) this
+    else throw new UnsupportedOperationException("This shouldn't have been called in the first place.")
 
   override def canBeShared = true
 }
diff --git a/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala b/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala
index d53b56d484..e71e61f2f1 100644
--- a/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala
+++ b/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala
@@ -14,8 +14,6 @@ import scala.collection.mutable.DoublingUnrolledBuffer
 import scala.collection.mutable.UnrolledBuffer.Unrolled
 import scala.collection.parallel.Combiner
 import scala.collection.parallel.Task
-import scala.reflect.ClassTag
-
 
 /** An array combiner that uses doubling unrolled buffers to store elements. */
 trait UnrolledParArrayCombiner[T]
diff --git a/src/library/scala/concurrent/duration/Duration.scala b/src/library/scala/concurrent/duration/Duration.scala
index a905ef345c..f69030bd3d 100644
--- a/src/library/scala/concurrent/duration/Duration.scala
+++ b/src/library/scala/concurrent/duration/Duration.scala
@@ -9,8 +9,6 @@
 package scala.concurrent.duration
 
 import java.lang.{ Double => JDouble, Long => JLong }
-import scala.language.implicitConversions
-import scala.language.postfixOps
 
 object Duration {
 
@@ -57,7 +55,7 @@ object Duration {
       case "Inf" | "PlusInf" | "+Inf" => Inf
       case "MinusInf" | "-Inf"        => MinusInf
       case _                          =>
-        val unitName = s1.reverse takeWhile (_.isLetter) reverse;
+        val unitName = s1.reverse.takeWhile(_.isLetter).reverse;
         timeUnit get unitName match {
           case Some(unit) =>
             val valueStr = s1 dropRight unitName.length
@@ -87,11 +85,11 @@ object Duration {
 
   // TimeUnit => standard label
   protected[duration] val timeUnitName: Map[TimeUnit, String] =
-    timeUnitLabels.toMap mapValues (s => words(s).last) toMap
+    timeUnitLabels.toMap.mapValues(s => words(s).last).toMap
 
   // Label => TimeUnit
   protected[duration] val timeUnit: Map[String, TimeUnit] =
-    timeUnitLabels flatMap { case (unit, names) => expandLabels(names) map (_ -> unit) } toMap
+    timeUnitLabels.flatMap{ case (unit, names) => expandLabels(names) map (_ -> unit) }.toMap
 
   /**
    * Extract length and time unit out of a string, where the format must match the description for [[Duration$.apply(s:String)* apply(String)]].
diff --git a/src/library/scala/util/Either.scala b/src/library/scala/util/Either.scala
index 675b3c8c61..01da0c1ef2 100644
--- a/src/library/scala/util/Either.scala
+++ b/src/library/scala/util/Either.scala
@@ -11,8 +11,6 @@
 package scala
 package util
 
-import scala.language.implicitConversions
-
 /** Represents a value of one of two possible types (a disjoint union.)
  *  Instances of Either are either an instance of [[scala.util.Left]] or [[scala.util.Right]].
  *
diff --git a/src/library/scala/util/Try.scala b/src/library/scala/util/Try.scala
index 84d170249d..3c8b21b03c 100644
--- a/src/library/scala/util/Try.scala
+++ b/src/library/scala/util/Try.scala
@@ -10,7 +10,6 @@ package scala
 package util
 
 import scala.util.control.NonFatal
-import scala.language.implicitConversions
 
 /**
  * The `Try` type represents a computation that may either result in an exception, or return a
diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
index 8074b448fe..d2312440cc 100644
--- a/src/reflect/scala/reflect/internal/Definitions.scala
+++ b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -840,7 +840,7 @@ trait Definitions extends api.StandardDefinitions {
     def samOf(tp: Type): Symbol = if (!doSam) NoSymbol else {
       // look at erased type because we (only) care about what ends up in bytecode
       // (e.g., an alias type or intersection type is fine as long as the intersection dominator compiles to an interface)
-      val tpSym = erasure.javaErasure(tp).typeSymbol
+      val tpSym: Symbol = erasure.javaErasure(tp).typeSymbol
 
       if (tpSym.exists && tpSym.isClass
           // if tp has a constructor (its class is not a trait), it must be public and must not take any arguments
diff --git a/src/reflect/scala/reflect/internal/Internals.scala b/src/reflect/scala/reflect/internal/Internals.scala
index cfacad24b4..1a48701ca7 100644
--- a/src/reflect/scala/reflect/internal/Internals.scala
+++ b/src/reflect/scala/reflect/internal/Internals.scala
@@ -3,7 +3,6 @@ package reflect
 package internal
 
 import scala.language.implicitConversions
-import scala.language.higherKinds
 
 import scala.reflect.api.Universe
 import scala.reflect.macros.Attachments
diff --git a/src/reflect/scala/reflect/internal/ReificationSupport.scala b/src/reflect/scala/reflect/internal/ReificationSupport.scala
index c58cb71e97..30f2efd7e3 100644
--- a/src/reflect/scala/reflect/internal/ReificationSupport.scala
+++ b/src/reflect/scala/reflect/internal/ReificationSupport.scala
@@ -287,6 +287,8 @@ trait ReificationSupport { self: SymbolTable =>
           val evdefs = gvdefs.zip(lvdefs).map {
             case (gvdef @ ValDef(_, _, tpt: TypeTree, _), ValDef(_, _, _, rhs)) =>
               copyValDef(gvdef)(tpt = tpt.original, rhs = rhs)
+            case (tr1, tr2) =>
+              throw new MatchError((tr1, tr2))
           }
           val edefs = evdefs ::: etdefs
           if (ctorMods.isTrait)
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index f385ca08c9..62f16aa8f7 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -3933,6 +3933,8 @@ trait Types
         et.withTypeVars(isConsistent(_, tp2))
       case (_, et: ExistentialType) =>
         et.withTypeVars(isConsistent(tp1, _))
+      case (_, _) =>
+        throw new MatchError((tp1, tp2))
     }
 
     def check(tp1: Type, tp2: Type) = (
diff --git a/src/reflect/scala/reflect/internal/transform/Transforms.scala b/src/reflect/scala/reflect/internal/transform/Transforms.scala
index 296ccde443..0d2f355aa5 100644
--- a/src/reflect/scala/reflect/internal/transform/Transforms.scala
+++ b/src/reflect/scala/reflect/internal/transform/Transforms.scala
@@ -23,9 +23,9 @@ trait Transforms { self: SymbolTable =>
     }
   }
 
-  private val refChecksLazy = new Lazy(new { val global: Transforms.this.type = self } with RefChecks)
-  private val uncurryLazy = new Lazy(new { val global: Transforms.this.type = self } with UnCurry)
-  private val erasureLazy = new Lazy(new { val global: Transforms.this.type = self } with Erasure)
+  private val refChecksLazy   = new Lazy(new { val global: Transforms.this.type = self } with RefChecks)
+  private val uncurryLazy     = new Lazy(new { val global: Transforms.this.type = self } with UnCurry)
+  private val erasureLazy     = new Lazy(new { val global: Transforms.this.type = self } with Erasure)
   private val postErasureLazy = new Lazy(new { val global: Transforms.this.type = self } with PostErasure)
 
   def refChecks = refChecksLazy.force
diff --git a/src/reflect/scala/reflect/macros/Enclosures.scala b/src/reflect/scala/reflect/macros/Enclosures.scala
index 1eb6832b5b..798fed2a15 100644
--- a/src/reflect/scala/reflect/macros/Enclosures.scala
+++ b/src/reflect/scala/reflect/macros/Enclosures.scala
@@ -2,8 +2,6 @@ package scala
 package reflect
 package macros
 
-import scala.language.existentials // SI-6541
-
 /**
  * <span class="badge badge-red" style="float: right;">EXPERIMENTAL</span>
  *
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/HtmlFactory.scala b/src/scaladoc/scala/tools/nsc/doc/html/HtmlFactory.scala
index b5d5163088..88b84be65e 100644
--- a/src/scaladoc/scala/tools/nsc/doc/html/HtmlFactory.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/html/HtmlFactory.scala
@@ -17,7 +17,7 @@ import page.diagram._
   * @author David Bernard
   * @author Gilles Dubochet */
 class HtmlFactory(val universe: doc.Universe, val reporter: ScalaDocReporter) {
-  import page.{IndexScript, EntityPage}
+  import page.IndexScript
 
   /** The character encoding to be used for generated Scaladoc sites.
     * This value is currently always UTF-8. */
diff --git a/src/scalap/scala/tools/scalap/scalax/rules/scalasig/ScalaSigPrinter.scala b/src/scalap/scala/tools/scalap/scalax/rules/scalasig/ScalaSigPrinter.scala
index 3bfb82a639..064c7ac34c 100644
--- a/src/scalap/scala/tools/scalap/scalax/rules/scalasig/ScalaSigPrinter.scala
+++ b/src/scalap/scala/tools/scalap/scalax/rules/scalasig/ScalaSigPrinter.scala
@@ -11,8 +11,6 @@ package scalax
 package rules
 package scalasig
 
-import language.postfixOps
-
 import java.io.{PrintStream, ByteArrayOutputStream}
 import java.util.regex.Pattern
 import scala.tools.scalap.scalax.util.StringUtil