Merge pull request #2831 from soc/SI-7624

SI-7624 Fix -feature and some -Xlint warnings

15 files changed, 59 insertions, 96 deletions

diff --git a/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala b/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala
index 32c6da8007..2e82e34bd9 100644
--- a/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala
+++ b/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala
@@ -2,7 +2,6 @@ package scala.reflect.macros
 package compiler
 
 import scala.tools.nsc.Global
-import scala.reflect.macros.contexts.Context
 
 abstract class DefaultMacroCompiler extends Resolvers
                                        with Validators
@@ -11,7 +10,6 @@ abstract class DefaultMacroCompiler extends Resolvers
   import global._
 
   val typer: global.analyzer.Typer
-  private implicit val context0 = typer.context
   val context = typer.context
 
   val macroDdef: DefDef
diff --git a/src/compiler/scala/reflect/macros/compiler/Validators.scala b/src/compiler/scala/reflect/macros/compiler/Validators.scala
index 60cfc94a23..fafd79d1d7 100644
--- a/src/compiler/scala/reflect/macros/compiler/Validators.scala
+++ b/src/compiler/scala/reflect/macros/compiler/Validators.scala
@@ -11,8 +11,6 @@ trait Validators {
   import global._
   import analyzer._
   import definitions._
-  import treeInfo._
-  import typer.infer._
 
   def validateMacroImplRef() = {
     sanityCheck()
diff --git a/src/compiler/scala/reflect/macros/runtime/JavaReflectionRuntimes.scala b/src/compiler/scala/reflect/macros/runtime/JavaReflectionRuntimes.scala
index 3ef11fad9d..450cb4d9ea 100644
--- a/src/compiler/scala/reflect/macros/runtime/JavaReflectionRuntimes.scala
+++ b/src/compiler/scala/reflect/macros/runtime/JavaReflectionRuntimes.scala
@@ -10,8 +10,6 @@ trait JavaReflectionRuntimes {
   trait JavaReflectionResolvers {
     self: MacroRuntimeResolver =>
 
-    import global._
-
     def resolveJavaReflectionRuntime(classLoader: ClassLoader): MacroRuntime = {
       val implClass = Class.forName(className, true, classLoader)
       val implMeths = implClass.getDeclaredMethods.find(_.getName == methName)
diff --git a/src/compiler/scala/reflect/macros/runtime/MacroRuntimes.scala b/src/compiler/scala/reflect/macros/runtime/MacroRuntimes.scala
index 0f89163803..ffdbe11151 100644
--- a/src/compiler/scala/reflect/macros/runtime/MacroRuntimes.scala
+++ b/src/compiler/scala/reflect/macros/runtime/MacroRuntimes.scala
@@ -1,11 +1,8 @@
 package scala.reflect.macros
 package runtime
 
-import scala.collection.mutable.{Map => MutableMap}
 import scala.reflect.internal.Flags._
 import scala.reflect.runtime.ReflectionUtils
-import scala.tools.nsc.util.ScalaClassLoader
-import scala.tools.nsc.util.AbstractFileClassLoader
 
 trait MacroRuntimes extends JavaReflectionRuntimes with ScalaReflectionRuntimes {
   self: scala.tools.nsc.typechecker.Analyzer =>
diff --git a/src/compiler/scala/reflect/macros/runtime/ScalaReflectionRuntimes.scala b/src/compiler/scala/reflect/macros/runtime/ScalaReflectionRuntimes.scala
index 1999e525ff..50f64310f8 100644
--- a/src/compiler/scala/reflect/macros/runtime/ScalaReflectionRuntimes.scala
+++ b/src/compiler/scala/reflect/macros/runtime/ScalaReflectionRuntimes.scala
@@ -9,8 +9,6 @@ trait ScalaReflectionRuntimes {
   trait ScalaReflectionResolvers {
     self: MacroRuntimeResolver =>
 
-    import global._
-
     def resolveScalaReflectionRuntime(classLoader: ClassLoader): MacroRuntime = {
       val macroMirror: ru.JavaMirror = ru.runtimeMirror(classLoader)
       val implContainerSym = macroMirror.classSymbol(Class.forName(className, true, classLoader))
diff --git a/src/compiler/scala/reflect/macros/util/Helpers.scala b/src/compiler/scala/reflect/macros/util/Helpers.scala
index 9b7680717e..f12582a3a1 100644
--- a/src/compiler/scala/reflect/macros/util/Helpers.scala
+++ b/src/compiler/scala/reflect/macros/util/Helpers.scala
@@ -23,7 +23,7 @@ trait Helpers {
    *  or to streamline creation of the list of macro arguments.
    */
   def transformTypeTagEvidenceParams(macroImplRef: Tree, transform: (Symbol, Symbol) => Symbol): List[List[Symbol]] = {
-    val treeInfo.MacroImplReference(isBundle, owner, macroImpl, _) = macroImplRef
+    val treeInfo.MacroImplReference(isBundle, _, macroImpl, _) = macroImplRef
     val paramss = macroImpl.paramss
     if (paramss.isEmpty || paramss.last.isEmpty) return paramss // no implicit parameters in the signature => nothing to do
     val rc =
@@ -44,11 +44,6 @@ trait Helpers {
     if (transformed.isEmpty) paramss.init else paramss.init :+ transformed
   }
 
-  private def dealiasAndRewrap(tp: Type)(fn: Type => Type): Type = {
-    if (isRepeatedParamType(tp)) scalaRepeatedType(fn(tp.typeArgs.head.dealias))
-    else fn(tp.dealias)
-  }
-
   /** Increases metalevel of the type, i.e. transforms:
    *    * T to c.Expr[T]
    *
diff --git a/src/compiler/scala/tools/ant/sabbus/Settings.scala b/src/compiler/scala/tools/ant/sabbus/Settings.scala
index 4cbc03d8d4..a86af73fe3 100644
--- a/src/compiler/scala/tools/ant/sabbus/Settings.scala
+++ b/src/compiler/scala/tools/ant/sabbus/Settings.scala
@@ -93,7 +93,7 @@ class Settings {
     case _ => false
   }
 
-  override lazy val hashCode: Int = Seq(
+  override lazy val hashCode: Int = Seq[Any](
     gBf,
     uncheckedBf,
     classpathBf,
diff --git a/src/compiler/scala/tools/cmd/CommandLineParser.scala b/src/compiler/scala/tools/cmd/CommandLineParser.scala
index ef55178594..6132eff557 100644
--- a/src/compiler/scala/tools/cmd/CommandLineParser.scala
+++ b/src/compiler/scala/tools/cmd/CommandLineParser.scala
@@ -40,16 +40,16 @@ object CommandLineParser {
   // parse `in` for an argument, return it and the remainder of the input (or an error message)
   // (argument may be in single/double quotes, taking escaping into account, quotes are stripped)
   private def argument(in: String): Either[String, (String, String)] = in match {
-    case DoubleQuoted(arg, rest) => Right(arg, rest)
-    case SingleQuoted(arg, rest) => Right(arg, rest)
-    case Word(arg, rest)         => Right(arg, rest)
-    case _                       => Left("Illegal argument: "+ in)
+    case DoubleQuoted(arg, rest) => Right((arg, rest))
+    case SingleQuoted(arg, rest) => Right((arg, rest))
+    case Word(arg, rest)         => Right((arg, rest))
+    case _                       => Left(s"Illegal argument: $in")
   }
 
   // parse a list of whitespace-separated arguments (ignoring whitespace in quoted arguments)
   @tailrec private def commandLine(in: String, accum: List[String] = Nil): Either[String, (List[String], String)] = {
     val trimmed = in.trim
-    if (trimmed.isEmpty) Right(accum.reverse, "")
+    if (trimmed.isEmpty) Right((accum.reverse, ""))
     else argument(trimmed) match {
       case Right((arg, next)) =>
         (next span Character.isWhitespace) match {
diff --git a/src/compiler/scala/tools/cmd/gen/AnyVals.scala b/src/compiler/scala/tools/cmd/gen/AnyVals.scala
index 7e01afac2b..842851b4f6 100644
--- a/src/compiler/scala/tools/cmd/gen/AnyVals.scala
+++ b/src/compiler/scala/tools/cmd/gen/AnyVals.scala
@@ -6,24 +6,23 @@
 package scala.tools.cmd
 package gen
 
-/** Code generation of the AnyVal types and their companions.
- */
+/** Code generation of the AnyVal types and their companions. */
 trait AnyValReps {
   self: AnyVals =>
 
-  sealed abstract class AnyValNum(name: String, repr: Option[String], javaEquiv: String) extends AnyValRep(name,repr,javaEquiv) {
+  sealed abstract class AnyValNum(name: String, repr: Option[String], javaEquiv: String)
+      extends AnyValRep(name,repr,javaEquiv) {
 
     case class Op(op : String, doc : String)
 
     private def companionCoercions(tos: AnyValRep*) = {
       tos.toList map (to =>
-        """implicit def @javaequiv@2%s(x: @name@): %s = x.to%s""".format(to.javaEquiv, to.name, to.name)
+        s"implicit def @javaequiv@2${to.javaEquiv}(x: @name@): ${to.name} = x.to${to.name}"
       )
     }
-    def coercionCommentExtra = ""
-    def coercionComment = """
-/** Language mandated coercions from @name@ to "wider" types.%s
- */""".format(coercionCommentExtra)
+    def coercionComment =
+"""/** Language mandated coercions from @name@ to "wider" types. */
+import scala.language.implicitConversions"""
 
     def implicitCoercions: List[String] = {
       val coercions = this match {
@@ -41,12 +40,8 @@ trait AnyValReps {
     def isCardinal: Boolean = isIntegerType(this)
     def unaryOps = {
       val ops = List(
-        Op("+", "/**\n" +
-                " * Returns this value, unmodified.\n" +
-                " */"),
-        Op("-", "/**\n" +
-                " * Returns the negation of this value.\n" +
-                " */"))
+        Op("+", "/** Returns this value, unmodified. */"),
+        Op("-", "/** Returns the negation of this value. */"))
 
       if(isCardinal)
         Op("~", "/**\n" +
@@ -95,7 +90,7 @@ trait AnyValReps {
                      "  */"))
       else Nil
 
-    def shiftOps            =
+    def shiftOps =
       if (isCardinal)
         List(
           Op("<<",  "/**\n" +
@@ -127,20 +122,20 @@ trait AnyValReps {
                        "  */"))
       else Nil
 
-    def comparisonOps       = List(
-      Op("==", "/**\n  * Returns `true` if this value is equal to x, `false` otherwise.\n  */"),
-      Op("!=", "/**\n  * Returns `true` if this value is not equal to x, `false` otherwise.\n  */"),
-      Op("<",  "/**\n  * Returns `true` if this value is less than x, `false` otherwise.\n  */"),
-      Op("<=", "/**\n  * Returns `true` if this value is less than or equal to x, `false` otherwise.\n  */"),
-      Op(">",  "/**\n  * Returns `true` if this value is greater than x, `false` otherwise.\n  */"),
-      Op(">=", "/**\n  * Returns `true` if this value is greater than or equal to x, `false` otherwise.\n  */"))
+    def comparisonOps = List(
+      Op("==", "/** Returns `true` if this value is equal to x, `false` otherwise. */"),
+      Op("!=", "/** Returns `true` if this value is not equal to x, `false` otherwise. */"),
+      Op("<",  "/** Returns `true` if this value is less than x, `false` otherwise. */"),
+      Op("<=", "/** Returns `true` if this value is less than or equal to x, `false` otherwise. */"),
+      Op(">",  "/** Returns `true` if this value is greater than x, `false` otherwise. */"),
+      Op(">=", "/** Returns `true` if this value is greater than or equal to x, `false` otherwise. */"))
 
     def otherOps = List(
-      Op("+", "/**\n  * Returns the sum of this value and `x`.\n  */"),
-      Op("-", "/**\n  * Returns the difference of this value and `x`.\n  */"),
-      Op("*", "/**\n  * Returns the product of this value and `x`.\n  */"),
-      Op("/", "/**\n  * Returns the quotient of this value and `x`.\n  */"),
-      Op("%", "/**\n  * Returns the remainder of the division of this value by `x`.\n  */"))
+      Op("+", "/** Returns the sum of this value and `x`. */"),
+      Op("-", "/** Returns the difference of this value and `x`. */"),
+      Op("*", "/** Returns the product of this value and `x`. */"),
+      Op("/", "/** Returns the quotient of this value and `x`. */"),
+      Op("%", "/** Returns the remainder of the division of this value by `x`. */"))
 
     // Given two numeric value types S and T , the operation type of S and T is defined as follows:
     // If both S and T are subrange types then the operation type of S and T is Int.
@@ -278,8 +273,7 @@ trait AnyValReps {
 }
 
 trait AnyValTemplates {
-  def headerTemplate = ("""
-/*                     __                                               *\
+  def headerTemplate = """/*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
 **    / __/ __// _ | / /  / _ |    (c) 2002-2013, LAMP/EPFL             **
 **  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
@@ -287,12 +281,13 @@ trait AnyValTemplates {
 **                          |/                                          **
 \*                                                                      */
 
-%s
-package scala
+// DO NOT EDIT, CHANGES WILL BE LOST
+// This auto-generated code can be modified in scala.tools.cmd.gen.
+// Afterwards, running tools/codegen-anyvals regenerates this source file.
 
-import scala.language.implicitConversions
+package scala
 
-""".trim.format(timestampString) + "\n\n")
+"""
 
   def classDocTemplate = ("""
 /** `@name@`@representation@ (equivalent to Java's `@javaequiv@` primitive type) is a
@@ -304,8 +299,6 @@ import scala.language.implicitConversions
  */
 """.trim + "\n")
 
-  def timestampString = "// DO NOT EDIT, CHANGES WILL BE LOST.\n"
-
   def allCompanions = """
 /** Transform a value type into a boxed reference type.
  *@boxRunTimeDoc@
@@ -324,20 +317,17 @@ def box(x: @name@): @boxed@ = @boxImpl@
  */
 def unbox(x: java.lang.Object): @name@ = @unboxImpl@
 
-/** The String representation of the scala.@name@ companion object.
- */
+/** The String representation of the scala.@name@ companion object. */
 override def toString = "object scala.@name@"
 """
 
   def nonUnitCompanions = ""  // todo
 
   def cardinalCompanion = """
-/** The smallest value representable as a @name@.
- */
+/** The smallest value representable as a @name@. */
 final val MinValue = @boxed@.MIN_VALUE
 
-/** The largest value representable as a @name@.
- */
+/** The largest value representable as a @name@. */
 final val MaxValue = @boxed@.MAX_VALUE
 """
 
@@ -372,18 +362,16 @@ class AnyVals extends AnyValReps with AnyValTemplates {
   object D extends AnyValNum("Double",  Some("64-bit IEEE-754 floating point number"), "double")
   object Z extends AnyValRep("Boolean", None,                                          "boolean") {
     def classLines = """
-/**
- * Negates a Boolean expression.
- *
- * - `!a` results in `false` if and only if `a` evaluates to `true` and
- * - `!a` results in `true` if and only if `a` evaluates to `false`.
- *
- * @return the negated expression
- */
+/** Negates a Boolean expression.
+  *
+  * - `!a` results in `false` if and only if `a` evaluates to `true` and
+  * - `!a` results in `true` if and only if `a` evaluates to `false`.
+  *
+  * @return the negated expression
+  */
 def unary_! : Boolean
 
-/**
-  * Compares two Boolean expressions and returns `true` if they evaluate to the same value.
+/** Compares two Boolean expressions and returns `true` if they evaluate to the same value.
   *
   * `a == b` returns `true` if and only if
   *  - `a` and `b` are `true` or
@@ -400,8 +388,7 @@ def ==(x: Boolean): Boolean
   */
 def !=(x: Boolean): Boolean
 
-/**
-  * Compares two Boolean expressions and returns `true` if one or both of them evaluate to true.
+/** Compares two Boolean expressions and returns `true` if one or both of them evaluate to true.
   *
   * `a || b` returns `true` if and only if
   *  - `a` is `true` or
@@ -414,8 +401,7 @@ def !=(x: Boolean): Boolean
   */
 def ||(x: Boolean): Boolean
 
-/**
-  * Compares two Boolean expressions and returns `true` if both of them evaluate to true.
+/** Compares two Boolean expressions and returns `true` if both of them evaluate to true.
   *
   * `a && b` returns `true` if and only if
   *  - `a` and `b` are `true`.
@@ -430,8 +416,7 @@ def &&(x: Boolean): Boolean
 // def ||(x: => Boolean): Boolean
 // def &&(x: => Boolean): Boolean
 
-/**
-  * Compares two Boolean expressions and returns `true` if one or both of them evaluate to true.
+/** Compares two Boolean expressions and returns `true` if one or both of them evaluate to true.
   *
   * `a | b` returns `true` if and only if
   *  - `a` is `true` or
@@ -442,8 +427,7 @@ def &&(x: Boolean): Boolean
   */
 def |(x: Boolean): Boolean
 
-/**
-  * Compares two Boolean expressions and returns `true` if both of them evaluate to true.
+/** Compares two Boolean expressions and returns `true` if both of them evaluate to true.
   *
   * `a & b` returns `true` if and only if
   *  - `a` and `b` are `true`.
@@ -452,8 +436,7 @@ def |(x: Boolean): Boolean
   */
 def &(x: Boolean): Boolean
 
-/**
-  * Compares two Boolean expressions and returns `true` if they evaluate to a different value.
+/** Compares two Boolean expressions and returns `true` if they evaluate to a different value.
   *
   * `a ^ b` returns `true` if and only if
   *  - `a` is `true` and `b` is `false` or
@@ -499,5 +482,3 @@ override def getClass(): Class[Boolean] = null
 
   def make() = values map (x => (x.name, x.make()))
 }
-
-object AnyVals extends AnyVals { }
diff --git a/src/compiler/scala/tools/cmd/gen/Codegen.scala b/src/compiler/scala/tools/cmd/gen/Codegen.scala
index b49322ab4a..c3aa527ef2 100644
--- a/src/compiler/scala/tools/cmd/gen/Codegen.scala
+++ b/src/compiler/scala/tools/cmd/gen/Codegen.scala
@@ -6,11 +6,9 @@
 package scala.tools.cmd
 package gen
 
-import scala.language.postfixOps
-
 class Codegen(args: List[String]) extends {
   val parsed = CodegenSpec(args: _*)
-} with CodegenSpec with Instance { }
+} with CodegenSpec with Instance
 
 object Codegen {
   def echo(msg: String) = Console println msg
@@ -31,7 +29,7 @@ object Codegen {
       val av = new AnyVals { }
 
       av.make() foreach { case (name, code ) =>
-        val file = out / (name + ".scala") toFile;
+        val file = (out / (name + ".scala")).toFile
         echo("Writing: " + file)
         file writeAll code
       }
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
index c6ea6b23e5..454c9db73c 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
@@ -74,7 +74,6 @@ abstract class ClassfileParser {
   def srcfile = srcfile0
 
   private def optimized         = settings.optimise.value
-  private def currentIsTopLevel = !(currentClass.decodedName containsChar '$')
 
   // u1, u2, and u4 are what these data types are called in the JVM spec.
   // They are an unsigned byte, unsigned char, and unsigned int respectively.
@@ -349,7 +348,7 @@ abstract class ClassfileParser {
 
     /** Throws an exception signaling a bad tag at given address. */
     protected def errorBadTag(start: Int) =
-      abort("bad constant pool tag ${in.buf(start)} at byte $start")
+      abort(s"bad constant pool tag ${in.buf(start)} at byte $start")
   }
 
   private def loadClassSymbol(name: Name): Symbol = {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
index 1b6443a4cb..f3a22a2cee 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
@@ -1340,6 +1340,7 @@ trait Contexts { self: Analyzer =>
 }
 
 object ContextMode {
+  import scala.language.implicitConversions
   private implicit def liftIntBitsToContextState(bits: Int): ContextMode = apply(bits)
   def apply(bits: Int): ContextMode = new ContextMode(bits)
   final val NOmode: ContextMode                   = 0
diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index c87de8839f..4265efc839 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -815,7 +815,7 @@ trait Implicits {
           if (search.isDivergent && countdown > 0) {
             countdown -= 1
             implicitSym = i.sym
-            log("discarding divergent implicit ${implicitSym} during implicit search")
+            log(s"discarding divergent implicit $implicitSym during implicit search")
             SearchFailure
           } else search
       }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
index 06892053fa..8ca0d82e93 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -700,7 +700,7 @@ trait Infer extends Checkable {
         tp nonPrivateMember nme.apply match {
           case NoSymbol                                 => tp
           case sym if !sym.isOverloaded && sym.isPublic => OverloadedType(tp, sym.alternatives)
-          case sym                                      => OverloadedType(tp, sym filter (_.isPublic) alternatives)
+          case sym                                      => OverloadedType(tp, sym.filter(_.isPublic).alternatives)
         }
     }
 
diff --git a/src/compiler/scala/tools/util/PathResolver.scala b/src/compiler/scala/tools/util/PathResolver.scala
index bdd6a02043..82f2c5dc74 100644
--- a/src/compiler/scala/tools/util/PathResolver.scala
+++ b/src/compiler/scala/tools/util/PathResolver.scala
@@ -8,8 +8,8 @@ package tools
 package util
 
 import scala.tools.reflect.WrappedProperties.AccessControl
-import scala.tools.nsc.{ Settings, GenericRunnerSettings }
-import scala.tools.nsc.util.{ ClassPath, JavaClassPath, ScalaClassLoader }
+import scala.tools.nsc.{ Settings }
+import scala.tools.nsc.util.{ ClassPath, JavaClassPath }
 import scala.reflect.io.{ File, Directory, Path, AbstractFile }
 import ClassPath.{ JavaContext, DefaultJavaContext, join, split }
 import PartialFunction.condOpt