Merge pull request #1004 from paulp/topic/warnings-2.10.x

Topic/warnings 2.10.x

66 files changed, 316 insertions, 148 deletions

diff --git a/build.xml b/build.xml
index 6833986ac8..c0f0e33f80 100644
--- a/build.xml
+++ b/build.xml
@@ -1294,7 +1294,7 @@ QUICK BUILD (QUICK)
     <scalacfork
       destdir="${build-quick.dir}/classes/scalacheck"
       compilerpathref="quick.classpath"
-      params="${scalac.args.quick}"
+      params="${scalac.args.quick} -nowarn"
       srcdir="${src.dir}/scalacheck"
       jvmargs="${scalacfork.jvmargs}">
       <include name="**/*.scala"/>
@@ -1942,7 +1942,7 @@ BOOTSTRAPPING BUILD (STRAP)
     <scalacfork
       destdir="${build-strap.dir}/classes/scalacheck"
       compilerpathref="pack.classpath"
-      params="${scalac.args.quick}"
+      params="${scalac.args.quick} -nowarn"
       srcdir="${src.dir}/scalacheck"
       jvmargs="${scalacfork.jvmargs}">
       <include name="**/*.scala"/>
diff --git a/src/actors-migration/scala/actors/Pattern.scala b/src/actors-migration/scala/actors/Pattern.scala
index 97dbd2cccd..26e9d1bb64 100644
--- a/src/actors-migration/scala/actors/Pattern.scala
+++ b/src/actors-migration/scala/actors/Pattern.scala
@@ -1,6 +1,7 @@
 package scala.actors
 
 import scala.concurrent.util.Duration
+import language.implicitConversions
 
 object pattern {
 
diff --git a/src/actors-migration/scala/actors/StashingActor.scala b/src/actors-migration/scala/actors/StashingActor.scala
index 37300f9d63..8f96e1b002 100644
--- a/src/actors-migration/scala/actors/StashingActor.scala
+++ b/src/actors-migration/scala/actors/StashingActor.scala
@@ -3,6 +3,7 @@ package scala.actors
 import scala.collection._
 import scala.concurrent.util.Duration
 import java.util.concurrent.TimeUnit
+import language.implicitConversions
 
 object StashingActor extends Combinators {
   implicit def mkBody[A](body: => A) = new InternalActor.Body[A] {
diff --git a/src/actors-migration/scala/actors/Timeout.scala b/src/actors-migration/scala/actors/Timeout.scala
index 0d9532a14b..7e400ab140 100644
--- a/src/actors-migration/scala/actors/Timeout.scala
+++ b/src/actors-migration/scala/actors/Timeout.scala
@@ -10,6 +10,7 @@ package scala.actors
 
 import scala.concurrent.util.Duration
 import java.util.concurrent.TimeUnit
+import language.implicitConversions
 
 case class Timeout(duration: Duration) {
   def this(timeout: Long) = this(Duration(timeout, TimeUnit.MILLISECONDS))
diff --git a/src/actors/scala/actors/AbstractActor.scala b/src/actors/scala/actors/AbstractActor.scala
index 3817f9cda3..dec91859bb 100644
--- a/src/actors/scala/actors/AbstractActor.scala
+++ b/src/actors/scala/actors/AbstractActor.scala
@@ -6,9 +6,10 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.actors
 
+import language.higherKinds
+
 /**
  * @author Philipp Haller
  *
diff --git a/src/actors/scala/actors/Actor.scala b/src/actors/scala/actors/Actor.scala
index bc9bbc6ef0..0b1e7fb1e9 100644
--- a/src/actors/scala/actors/Actor.scala
+++ b/src/actors/scala/actors/Actor.scala
@@ -1,5 +1,3 @@
-
-
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
 **    / __/ __// _ | / /  / _ |    (c) 2005-2011, LAMP/EPFL             **
@@ -12,6 +10,7 @@ package scala.actors
 
 import scala.util.control.ControlThrowable
 import java.util.{Timer, TimerTask}
+import language.implicitConversions
 
 /**
  * Provides functions for the definition of actors, as well as actor
diff --git a/src/actors/scala/actors/CanReply.scala b/src/actors/scala/actors/CanReply.scala
index 5053f43e94..9bf0022247 100644
--- a/src/actors/scala/actors/CanReply.scala
+++ b/src/actors/scala/actors/CanReply.scala
@@ -6,9 +6,10 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.actors
 
+import language.higherKinds
+
 /**
  * Defines result-bearing message send operations.
  *
diff --git a/src/actors/scala/actors/Combinators.scala b/src/actors/scala/actors/Combinators.scala
index c1a9095614..dd704436fc 100644
--- a/src/actors/scala/actors/Combinators.scala
+++ b/src/actors/scala/actors/Combinators.scala
@@ -10,6 +10,8 @@
 
 package scala.actors
 
+import language.implicitConversions
+
 private[actors] trait Combinators {
 
   /**
diff --git a/src/actors/scala/actors/MQueue.scala b/src/actors/scala/actors/MQueue.scala
index 4a148d2cb3..43074649fd 100644
--- a/src/actors/scala/actors/MQueue.scala
+++ b/src/actors/scala/actors/MQueue.scala
@@ -121,7 +121,7 @@ private[actors] class MQueue[Msg >: Null](protected val label: String) {
    *  or `'''null'''` if `p` fails for all of them.
    */
   def extractFirst(p: (Msg, OutputChannel[Any]) => Boolean): MQueueElement[Msg] =
-    removeInternal(0)(p) orNull
+    removeInternal(0)(p).orNull
 
   def extractFirst(pf: PartialFunction[Msg, Any]): MQueueElement[Msg] = {
     if (isEmpty)    // early return
diff --git a/src/actors/scala/actors/Reactor.scala b/src/actors/scala/actors/Reactor.scala
index 7a8d738758..c962bb9d3d 100644
--- a/src/actors/scala/actors/Reactor.scala
+++ b/src/actors/scala/actors/Reactor.scala
@@ -12,6 +12,7 @@ package scala.actors
 import scala.actors.scheduler.{DelegatingScheduler, ExecutorScheduler,
                                ForkJoinScheduler, ThreadPoolConfig}
 import java.util.concurrent.{ThreadPoolExecutor, TimeUnit, LinkedBlockingQueue}
+import language.implicitConversions
 
 private[actors] object Reactor {
 
diff --git a/src/compiler/scala/tools/cmd/CommandLine.scala b/src/compiler/scala/tools/cmd/CommandLine.scala
index d9a74a698c..ced3a97380 100644
--- a/src/compiler/scala/tools/cmd/CommandLine.scala
+++ b/src/compiler/scala/tools/cmd/CommandLine.scala
@@ -7,7 +7,6 @@ package scala.tools
 package cmd
 
 import scala.collection.mutable.ListBuffer
-import language.postfixOps
 
 trait CommandLineConfig {
   def enforceArity: Boolean = true
diff --git a/src/compiler/scala/tools/cmd/FromString.scala b/src/compiler/scala/tools/cmd/FromString.scala
index 415940b3fd..d473796f39 100644
--- a/src/compiler/scala/tools/cmd/FromString.scala
+++ b/src/compiler/scala/tools/cmd/FromString.scala
@@ -43,7 +43,7 @@ object FromString {
       else cmd.runAndExit(println("'%s' is not an existing directory." format s))
   }
   def ExistingDirRelativeTo(root: Directory) = new FromString[Directory]()(tagOfDirectory) {
-    private def resolve(s: String) = toDir(s) toAbsoluteWithRoot root toDirectory
+    private def resolve(s: String) = (toDir(s) toAbsoluteWithRoot root).toDirectory
     override def isDefinedAt(s: String) = resolve(s).isDirectory
     def apply(s: String): Directory =
       if (isDefinedAt(s)) resolve(s)
diff --git a/src/compiler/scala/tools/cmd/package.scala b/src/compiler/scala/tools/cmd/package.scala
index 5786b00fd1..8e74e6169e 100644
--- a/src/compiler/scala/tools/cmd/package.scala
+++ b/src/compiler/scala/tools/cmd/package.scala
@@ -8,6 +8,10 @@ package scala.tools
 package object cmd {
   def returning[T](x: T)(f: T => Unit): T = { f(x) ; x }
 
+  // make some language features in this package compile without warning
+  implicit def implicitConversions = language.implicitConversions
+  implicit def postfixOps = language.postfixOps
+
   private[cmd] def debug(msg: String) = println(msg)
 
   def runAndExit(body: => Unit): Nothing = {
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
index 025046f19e..e590a0b691 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
@@ -1159,7 +1159,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
       val linkedClass  = moduleClass.companionClass
       val linkedModule = linkedClass.companionSymbol
       lazy val conflictingNames: Set[Name] = {
-        linkedClass.info.members collect { case sym if sym.name.isTermName => sym.name } toSet
+        (linkedClass.info.members collect { case sym if sym.name.isTermName => sym.name }).toSet
       }
       debuglog("Potentially conflicting names for forwarders: " + conflictingNames)
 
@@ -1351,7 +1351,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
 
       val ps = c.symbol.info.parents
       val superInterfaces0: List[Symbol] = if(ps.isEmpty) Nil else c.symbol.mixinClasses;
-      val superInterfaces = superInterfaces0 ++ c.symbol.annotations.flatMap(ann => newParentForAttr(ann.symbol)) distinct
+      val superInterfaces = (superInterfaces0 ++ c.symbol.annotations.flatMap(ann => newParentForAttr(ann.symbol))).distinct
 
       if(superInterfaces.isEmpty) EMPTY_STRING_ARRAY
       else mkArray(minimizeInterfaces(superInterfaces) map javaName)
@@ -3183,7 +3183,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
             hops ::= prev
             if (hops.contains(dest)) {
               // leave infinite-loops in place
-              return (dest, hops filterNot (dest eq))
+              return (dest, hops filterNot (dest eq _))
             }
             prev = dest;
             false
diff --git a/src/compiler/scala/tools/nsc/doc/html/page/diagram/DotDiagramGenerator.scala b/src/compiler/scala/tools/nsc/doc/html/page/diagram/DotDiagramGenerator.scala
index bae61f1a3b..c46c33c1ee 100644
--- a/src/compiler/scala/tools/nsc/doc/html/page/diagram/DotDiagramGenerator.scala
+++ b/src/compiler/scala/tools/nsc/doc/html/page/diagram/DotDiagramGenerator.scala
@@ -333,7 +333,7 @@ class DotDiagramGenerator(settings: doc.Settings) extends DiagramGenerator {
         else
           NodeSeq.Empty
       } catch {
-        case exc =>
+        case exc: Exception =>
           if (settings.docDiagramsDebug.value) {
             settings.printMsg("\n\n**********************************************************************")
             settings.printMsg("Encountered an error while generating page for " + template.qualifiedName)
diff --git a/src/compiler/scala/tools/nsc/javac/JavaScanners.scala b/src/compiler/scala/tools/nsc/javac/JavaScanners.scala
index a37fdc3ed1..58c2426602 100644
--- a/src/compiler/scala/tools/nsc/javac/JavaScanners.scala
+++ b/src/compiler/scala/tools/nsc/javac/JavaScanners.scala
@@ -139,7 +139,7 @@ trait JavaScanners extends ast.parser.ScannersCommon {
       kwOffset = offset
       arr
     }
-    final val tokenName = allKeywords map (_.swap) toMap
+    final val tokenName = allKeywords.map(_.swap).toMap
 
 //Token representation -----------------------------------------------------
 
diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
index ffcb682cf7..63f93aa000 100644
--- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
+++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
@@ -798,6 +798,10 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
         var specializingOn = specializedParams(sym)
         val unusedStvars   = specializingOn filterNot specializedTypeVars(sym.info)
 
+        // I think the last condition should be !sym.isHidden, but that made the
+        // compiler start warning about Tuple1.scala and Tuple2.scala claiming
+        // their type parameters are used in non-specializable positions.  Why is
+        // unusedStvars.nonEmpty for these classes???
         if (unusedStvars.nonEmpty && currentRun.compiles(sym) && !sym.isSynthetic) {
           reporter.warning(sym.pos,
             "%s %s unused or used in non-specializable positions.".format(
diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
index bcbcb96400..e096b75d6d 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -1324,66 +1324,89 @@ trait Infer {
     }
 
     // if top-level abstract types can be checked using a classtag extractor, don't warn about them
-    def checkCheckable(tree: Tree, tp: Type, inPattern: Boolean, canRemedy: Boolean = false) = {
-      val kind = if (inPattern) "pattern " else ""
+    def checkCheckable(tree: Tree, typeToTest: Type, typeEnsured: Type, inPattern: Boolean, canRemedy: Boolean = false) = {
+      log(s"checkCheckable($tree, $typeToTest, $typeEnsured, inPattern = $inPattern, canRemedy = $canRemedy")
 
-      def patternWarning(tp0: Type, prefix: String) = {
-        context.unit.uncheckedWarning(tree.pos, prefix+tp0+" in type "+kind+tp+" is unchecked since it is eliminated by erasure")
+      sealed abstract class TypeConformance(check: (Type, Type) => Boolean) {
+        def apply(t1: Type, t2: Type): Boolean = check(t1, t2) && {
+          log(s"Skipping unchecked for statically verifiable condition $t1 ${this} $t2")
+          true
+        }
       }
-      def check(tp: Type, bound: List[Symbol]) {
-        def isLocalBinding(sym: Symbol) =
-          sym.isAbstractType &&
-          ((bound contains sym) ||
-           sym.name == tpnme.WILDCARD || {
+      // I tried to use varianceInType to track the variance implications
+      // but I could not make it work.
+      case object =:= extends TypeConformance(_ =:= _)
+      case object <:< extends TypeConformance(_ <:< _)
+      case object >:> extends TypeConformance((t1, t2) => t2 <:< t1)
+      case object =!= extends TypeConformance((t1, t2) => false)
+
+      var bound: List[Symbol] = Nil
+      var warningMessages: List[String] = Nil
+
+      def isLocalBinding(sym: Symbol) = (
+        sym.isAbstractType && (
+             (bound contains sym)
+          || (sym.name == tpnme.WILDCARD)
+          || {
             val e = context.scope.lookupEntry(sym.name)
             (e ne null) && e.sym == sym && !e.sym.isTypeParameterOrSkolem && e.owner == context.scope
-          })
-        tp match {
-          case SingleType(pre, _) =>
-            check(pre, bound)
-          case TypeRef(pre, sym, args) =>
-            if (sym.isAbstractType) {
-              // we only use the extractor for top-level type tests, type arguments (see below) remain unchecked
-              if (!isLocalBinding(sym) && !canRemedy) patternWarning(tp, "abstract type ")
-            } else if (sym.isAliasType) {
-              check(tp.normalize, bound)
-            } else if (sym == NothingClass || sym == NullClass || sym == AnyValClass) {
-              TypePatternOrIsInstanceTestError(tree, tp)
-            } else {
-              for (arg <- args) {
-                if (sym == ArrayClass) check(arg, bound)
-                // avoid spurious warnings with higher-kinded types
-                else if (arg.typeArgs exists (_.typeSymbol.isTypeParameterOrSkolem)) ()
-                // no way to suppress unchecked warnings on try/catch
-                else if (sym == NonLocalReturnControlClass) ()
-                else arg match {
-                  case TypeRef(_, sym, _) if isLocalBinding(sym) =>
-                    ;
-                  case _ =>
-                    // Want to warn about type arguments, not type parameters. Otherwise we'll
-                    // see warnings about "invisible" types, like: val List(x0) = x1 leading to "non
-                    // variable type-argument A in type pattern List[A]..."
-                    if (!arg.typeSymbol.isTypeParameterOrSkolem)
-                      patternWarning(arg, "non variable type-argument ")
-                }
-              }
-            }
-            check(pre, bound)
-          case RefinedType(parents, decls) =>
-            if (decls.isEmpty) for (p <- parents) check(p, bound)
-            else patternWarning(tp, "refinement ")
-          case ExistentialType(quantified, tp1) =>
-            check(tp1, bound ::: quantified)
-          case ThisType(_) =>
-            ()
-          case NoPrefix =>
-            ()
-          case _ =>
-            patternWarning(tp, "type ")
-            ()
+          }
+        )
+      )
+      def check(tp0: Type, pt: Type, conformance: TypeConformance): Boolean = {
+        val tp = tp0.normalize
+        // Set the warning message to be issued when the top-level call fails.
+        def warn(what: String): Boolean = {
+          warningMessages ::= what
+          false
+        }
+        def checkArg(param: Symbol, arg: Type) = {
+          def conforms = (
+            if (param.isCovariant) <:<
+            else if (param.isContravariant) >:>
+            else =:=
+          )
+          val TypeRef(_, sym, args) = arg
+
+          (    isLocalBinding(sym)
+            || arg.typeSymbol.isTypeParameterOrSkolem
+            || (sym.name == tpnme.WILDCARD) // avoid spurious warnings on HK types
+            || check(arg, param.tpe, conforms)
+            || warn("non-variable type argument " + arg)
+          )
         }
+
+        // Checking if pt (the expected type of the pattern, and the type
+        // we are guaranteed) conforms to tp (the type expressed in the pattern's
+        // type test.) If it does, then even if the type being checked for appears
+        // to be uncheckable, it is not a warning situation, because it is indeed
+        // checked: not at runtime, but statically.
+        conformance.apply(pt, tp) || (tp match {
+          case SingleType(pre, _)                           => check(pre, pt, =:=)
+          case ExistentialType(quantified, tp1)             => bound :::= quantified ; check(tp1, pt, <:<)
+          case ThisType(_) | NoPrefix                       => true
+          case RefinedType(parents, decls) if decls.isEmpty => parents forall (p => check(p, pt, <:<))
+          case RefinedType(_, _)                            => warn("refinement " + tp)
+          case TypeRef(_, ArrayClass, arg :: Nil)           => check(arg, NoType, =!=)
+          case TypeRef(_, NonLocalReturnControlClass, _)    => true // no way to suppress unchecked warnings on try/catch
+          // we only use the extractor for top-level type tests, type arguments remain unchecked
+          case TypeRef(_, sym, _) if sym.isAbstractType     => isLocalBinding(sym) || canRemedy || warn("abstract type " + tp)
+          case TypeRef(_, _, Nil)                           => false // leaf node
+          case TypeRef(pre, sym, args)                      => forall2(sym.typeParams, args)(checkArg) && check(pre, pt.prefix, =:=)
+          case _                                            => warn("type " + tp)
+        })
+      }
+      typeToTest match {
+        // Prohibit top-level type tests for these, but they are
+        // acceptable nested (e.g. case Foldable[Nothing] => ... )
+        case TypeRef(_, NothingClass | NullClass | AnyValClass, _) =>
+          TypePatternOrIsInstanceTestError(tree, typeToTest)
+        case _ =>
+          def where = ( if (inPattern) "pattern " else "" ) + typeToTest
+          if (check(typeToTest, typeEnsured, =:=)) ()
+          else warningMessages foreach (m =>
+            context.unit.uncheckedWarning(tree.pos, s"$m in type $where is unchecked since it is eliminated by erasure"))
       }
-      check(tp, List())
     }
 
     /** Type intersection of simple type tp1 with general type tp2.
@@ -1420,7 +1443,7 @@ trait Infer {
         return ErrorType
       }
 
-      checkCheckable(tree0, pattp, inPattern = true, canRemedy)
+      checkCheckable(tree0, pattp, pt, inPattern = true, canRemedy)
       if (pattp <:< pt) ()
       else {
         debuglog("free type params (1) = " + tpparams)
diff --git a/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala b/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
index 8b7c70c048..cf5c7265ad 100644
--- a/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
@@ -412,8 +412,9 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
         **/
         // must treat Typed and Bind together -- we need to know the patBinder of the Bind pattern to get at the actual type
         case MaybeBoundTyped(subPatBinder, pt) =>
+          val next = glb(List(patBinder.info.widen, pt)).normalize
           // a typed pattern never has any subtrees
-          noFurtherSubPats(TypeTestTreeMaker(subPatBinder, patBinder, pt, glb(List(patBinder.info.widen, pt)).normalize)(pos))
+          noFurtherSubPats(TypeTestTreeMaker(subPatBinder, patBinder, pt, next)(pos))
 
         /** A pattern binder x@p consists of a pattern variable x and a pattern p.
             The type of the variable x is the static type T of the pattern p.
diff --git a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala
index a378a95786..fe82af5b23 100644
--- a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala
@@ -14,7 +14,7 @@ import util.returning
 abstract class TreeCheckers extends Analyzer {
   import global._
 
-  private def classstr(x: AnyRef) = x.getClass.getName split """\\.|\\$""" last;
+  private def classstr(x: AnyRef) = (x.getClass.getName split """\\.|\\$""").last
   private def typestr(x: Type)    = " (tpe = " + x + ")"
   private def treestr(t: Tree)    = t + " [" + classstr(t) + "]" + typestr(t.tpe)
   private def ownerstr(s: Symbol) = "'" + s + "'" + s.locationString
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 51753baa4f..269ab9611a 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -3672,7 +3672,8 @@ trait Typers extends Modes with Adaptations with Tags {
             typedClassOf(tree, args.head, true)
           else {
             if (!isPastTyper && fun.symbol == Any_isInstanceOf && !targs.isEmpty)
-              checkCheckable(tree, targs.head, inPattern = false)
+              checkCheckable(tree, targs.head, AnyClass.tpe, inPattern = false)
+
             val resultpe = restpe.instantiateTypeParams(tparams, targs)
             //@M substitution in instantiateParams needs to be careful!
             //@M example: class Foo[a] { def foo[m[x]]: m[a] = error("") } (new Foo[Int]).foo[List] : List[Int]
diff --git a/src/continuations/plugin/scala/tools/selectivecps/SelectiveANFTransform.scala b/src/continuations/plugin/scala/tools/selectivecps/SelectiveANFTransform.scala
index 017c8d24fd..211560e343 100644
--- a/src/continuations/plugin/scala/tools/selectivecps/SelectiveANFTransform.scala
+++ b/src/continuations/plugin/scala/tools/selectivecps/SelectiveANFTransform.scala
@@ -475,7 +475,7 @@ abstract class SelectiveANFTransform extends PluginComponent with Transform with
         val (prologue, rest) = (anfStats :+ anfExpr) span (s => !s.isInstanceOf[DefDef]) // find first case
         // println("rest: "+ rest)
         // val (defs, calls) = rest partition (_.isInstanceOf[DefDef])
-        if (rest nonEmpty){
+        if (rest.nonEmpty) {
           // the filter drops the ()'s emitted when transValue encountered a LabelDef
           val stats = prologue ++ (rest filter (_.isInstanceOf[DefDef])).reverse // ++ calls
           // println("REVERSED "+ (stats mkString ("{", "\n", "}")))
diff --git a/src/library/scala/collection/GenTraversableOnce.scala b/src/library/scala/collection/GenTraversableOnce.scala
index 25edcfe19c..4e0f71ee8b 100644
--- a/src/library/scala/collection/GenTraversableOnce.scala
+++ b/src/library/scala/collection/GenTraversableOnce.scala
@@ -11,6 +11,7 @@ package scala.collection
 import scala.reflect.ClassTag
 import scala.collection.generic.CanBuildFrom
 import scala.annotation.unchecked.{ uncheckedVariance => uV }
+import language.higherKinds
 
 /** A template trait for all traversable-once objects which may be
  *  traversed in parallel.
diff --git a/src/library/scala/collection/TraversableLike.scala b/src/library/scala/collection/TraversableLike.scala
index 9356832afd..641dd095da 100644
--- a/src/library/scala/collection/TraversableLike.scala
+++ b/src/library/scala/collection/TraversableLike.scala
@@ -13,6 +13,7 @@ import mutable.{ Builder }
 import annotation.{tailrec, migration, bridge}
 import annotation.unchecked.{ uncheckedVariance => uV }
 import parallel.ParIterable
+import language.higherKinds
 
 /** A template trait for traversable collections of type `Traversable[A]`.
  *
diff --git a/src/library/scala/collection/concurrent/TrieMap.scala b/src/library/scala/collection/concurrent/TrieMap.scala
index 2d8217551a..3d0aa6fd07 100644
--- a/src/library/scala/collection/concurrent/TrieMap.scala
+++ b/src/library/scala/collection/concurrent/TrieMap.scala
@@ -188,7 +188,7 @@ private[collection] final class INode[K, V](bn: MainNode[K, V], g: Gen) extends
                 if (sn.hc == hc && equal(sn.k, k, ct)) {
                   if (GCAS(cn, cn.updatedAt(pos, new SNode(k, v, hc), gen), ct)) Some(sn.v) else null
                 } else None
-              case otherv: V =>
+              case otherv =>
                 if (sn.hc == hc && equal(sn.k, k, ct) && sn.v == otherv) {
                   if (GCAS(cn, cn.updatedAt(pos, new SNode(k, v, hc), gen), ct)) Some(sn.v) else null
                 } else None
@@ -200,7 +200,7 @@ private[collection] final class INode[K, V](bn: MainNode[K, V], g: Gen) extends
             val ncnode = rn.insertedAt(pos, flag, new SNode(k, v, hc), gen)
             if (GCAS(cn, ncnode, ct)) None else null
           case INode.KEY_PRESENT => None
-          case otherv: V => None
+          case otherv => None
         }
       case sn: TNode[K, V] =>
         clean(parent, ct, lev - 5)
@@ -224,9 +224,9 @@ private[collection] final class INode[K, V](bn: MainNode[K, V], g: Gen) extends
               case Some(v0) => if (insertln()) Some(v0) else null
               case None => None
             }
-          case otherv: V =>
+          case otherv =>
             ln.get(k) match {
-              case Some(v0) if v0 == otherv => if (insertln()) Some(otherv) else null
+              case Some(v0) if v0 == otherv => if (insertln()) Some(otherv.asInstanceOf[V]) else null
               case _ => None
             }
         }
diff --git a/src/library/scala/collection/parallel/ParIterableLike.scala b/src/library/scala/collection/parallel/ParIterableLike.scala
index d4f1c2f39f..85758b29bc 100644
--- a/src/library/scala/collection/parallel/ParIterableLike.scala
+++ b/src/library/scala/collection/parallel/ParIterableLike.scala
@@ -30,7 +30,7 @@ import java.util.concurrent.atomic.AtomicBoolean
 
 import annotation.unchecked.uncheckedVariance
 import annotation.unchecked.uncheckedStable
-import language.implicitConversions
+import language.{ higherKinds, implicitConversions }
 
 
 /** A template trait for parallel collections of type `ParIterable[T]`.
diff --git a/src/library/scala/reflect/base/Names.scala b/src/library/scala/reflect/base/Names.scala
index 280a6ce8a2..532b780e7e 100644
--- a/src/library/scala/reflect/base/Names.scala
+++ b/src/library/scala/reflect/base/Names.scala
@@ -1,6 +1,8 @@
 package scala.reflect
 package base
 
+import language.implicitConversions
+
 /** A trait that manages names.
  *  A name is a string in one of two name universes: terms and types.
  *  The same string can be a name in both universes.
diff --git a/src/library/scala/runtime/Tuple2Zipped.scala b/src/library/scala/runtime/Tuple2Zipped.scala
index 5ad364c8a5..dce7eef08d 100644
--- a/src/library/scala/runtime/Tuple2Zipped.scala
+++ b/src/library/scala/runtime/Tuple2Zipped.scala
@@ -10,6 +10,7 @@ package scala.runtime
 
 import scala.collection.{ TraversableLike, IterableLike }
 import scala.collection.generic.{ CanBuildFrom => CBF }
+import language.{ higherKinds, implicitConversions }
 
 /** This interface is intended as a minimal interface, not complicated
  *  by the requirement to resolve type constructors, for implicit search (which only
diff --git a/src/library/scala/runtime/Tuple3Zipped.scala b/src/library/scala/runtime/Tuple3Zipped.scala
index 4e9c542c58..f3ca08649d 100644
--- a/src/library/scala/runtime/Tuple3Zipped.scala
+++ b/src/library/scala/runtime/Tuple3Zipped.scala
@@ -10,6 +10,7 @@ package scala.runtime
 
 import scala.collection.{ TraversableLike, IterableLike }
 import scala.collection.generic.{ CanBuildFrom => CBF }
+import language.{ higherKinds, implicitConversions }
 
 /** See comment on ZippedTraversable2. */
 trait ZippedTraversable3[+El1, +El2, +El3] {
diff --git a/src/library/scala/util/Try.scala b/src/library/scala/util/Try.scala
index 9475a05d5a..f85bac0b84 100644
--- a/src/library/scala/util/Try.scala
+++ b/src/library/scala/util/Try.scala
@@ -8,11 +8,9 @@
 
 package scala.util
 
-
-
 import collection.Seq
 import scala.util.control.NonFatal
-
+import language.implicitConversions
 
 /**
  * The `Try` type represents a computation that may either result in an exception, or return a
@@ -208,7 +206,7 @@ final case class Success[+T](value: T) extends Try[T] {
   def flatMap[U](f: T => Try[U]): Try[U] =
     try f(value)
     catch {
-      case e => Failure(e)
+      case e: Throwable => Failure(e)
     }
   def flatten[U](implicit ev: T <:< Try[U]): Try[U] = value
   def foreach[U](f: T => U): Unit = f(value)
diff --git a/src/library/scala/xml/dtd/ElementValidator.scala b/src/library/scala/xml/dtd/ElementValidator.scala
index 111c1b5e78..f97da1c8a3 100644
--- a/src/library/scala/xml/dtd/ElementValidator.scala
+++ b/src/library/scala/xml/dtd/ElementValidator.scala
@@ -115,6 +115,7 @@ class ElementValidator() extends Function1[Node,Boolean] {
           (dfa delta q).getOrElse(e, throw ValidationException("element %s not allowed here" format e))
         }
       }
+    case _ => false
   }
 
   /** applies various validations - accumulates error messages in exc
diff --git a/src/partest/scala/tools/partest/DirectTest.scala b/src/partest/scala/tools/partest/DirectTest.scala
index 5b4e1b4b25..323705b695 100644
--- a/src/partest/scala/tools/partest/DirectTest.scala
+++ b/src/partest/scala/tools/partest/DirectTest.scala
@@ -70,7 +70,7 @@ abstract class DirectTest extends App {
 
   /**  Constructor/main body  **/
   try show()
-  catch { case t => println(t.getMessage) ; t.printStackTrace ; sys.exit(1) }
+  catch { case t: Exception => println(t.getMessage) ; t.printStackTrace ; sys.exit(1) }
 
   /** Debugger interest only below this line **/
   protected def isDebug       = (sys.props contains "partest.debug") || (sys.env contains "PARTEST_DEBUG")
diff --git a/src/partest/scala/tools/partest/ScaladocModelTest.scala b/src/partest/scala/tools/partest/ScaladocModelTest.scala
index ffc5e74cc0..7117d7c715 100644
--- a/src/partest/scala/tools/partest/ScaladocModelTest.scala
+++ b/src/partest/scala/tools/partest/ScaladocModelTest.scala
@@ -72,7 +72,7 @@ abstract class ScaladocModelTest extends DirectTest {
       testModel(universe.rootPackage)
       println("Done.")
     } catch {
-      case e =>
+      case e: Exception =>
         println(e)
         e.printStackTrace
     }
@@ -102,7 +102,7 @@ abstract class ScaladocModelTest extends DirectTest {
   // finally, enable easy navigation inside the entities
   object access {
 
-    class TemplateAccess(tpl: DocTemplateEntity) {
+    implicit class TemplateAccess(tpl: DocTemplateEntity) {
       def _class(name: String): DocTemplateEntity = getTheFirst(_classes(name), tpl.qualifiedName + ".class(" + name + ")")
       def _classes(name: String): List[DocTemplateEntity] = tpl.templates.filter(_.name == name).collect({ case c: DocTemplateEntity with Class => c})
 
@@ -143,21 +143,21 @@ abstract class ScaladocModelTest extends DirectTest {
       def _aliasTypeTpls(name: String): List[DocTemplateEntity] = tpl.members.collect({ case dtpl: DocTemplateEntity with AliasType if dtpl.name == name => dtpl })
     }
 
-    class PackageAccess(pack: Package) extends TemplateAccess(pack) {
+    trait WithMembers {
+      def members: List[MemberEntity]
+      def _member(name: String): MemberEntity = getTheFirst(_members(name), this.toString + ".member(" + name + ")")
+      def _members(name: String): List[MemberEntity] = members.filter(_.name == name)
+    }
+    implicit class PackageAccess(pack: Package) extends TemplateAccess(pack) {
       def _package(name: String): Package = getTheFirst(_packages(name), pack.qualifiedName + ".package(" + name + ")")
       def _packages(name: String): List[Package] = pack.packages.filter(_.name == name)
     }
-
-    class MemberAccess(mbrs: WithMembers) {
-      def _member(name: String): MemberEntity = getTheFirst(_members(name), mbrs.toString + ".member(" + name + ")")
-      def _members(name: String): List[MemberEntity] = mbrs.members.filter(_.name == name)
+    implicit class DocTemplateEntityMembers(val underlying: DocTemplateEntity) extends WithMembers {
+      def members = underlying.members
+    }
+    implicit class ImplicitConversionMembers(val underlying: ImplicitConversion) extends WithMembers {
+      def members = underlying.members
     }
-
-    type WithMembers = { def members: List[MemberEntity]; def toString: String } /* DocTemplates and ImplicitConversions */
-
-    implicit def templateAccess(tpl: DocTemplateEntity) = new TemplateAccess(tpl)
-    implicit def packageAccess(pack: Package) = new PackageAccess(pack)
-    implicit def membersAccess(mbrs: WithMembers) = new MemberAccess(mbrs)
 
     def getTheFirst[T](list: List[T], expl: String): T = list.length match {
       case 1 => list.head
diff --git a/src/partest/scala/tools/partest/nest/RunnerManager.scala b/src/partest/scala/tools/partest/nest/RunnerManager.scala
index dc15d4475b..5a7684dc61 100644
--- a/src/partest/scala/tools/partest/nest/RunnerManager.scala
+++ b/src/partest/scala/tools/partest/nest/RunnerManager.scala
@@ -82,7 +82,7 @@ class RunnerManager(kind: String, val fileManager: FileManager, params: TestRunP
 
   private def compareFiles(f1: File, f2: File): String =
     try fileManager.compareFiles(f1, f2)
-    catch { case t => t.toString }
+    catch { case t: Exception => t.toString }
 
   /** This does something about absolute paths and file separator
    *  chars before diffing.
@@ -779,11 +779,11 @@ class RunnerManager(kind: String, val fileManager: FileManager, params: TestRunP
         logStackTrace(logFile, t, "Possible compiler crash during test of: " + testFile + "\n")
         LogContext(logFile)
       }
-      catch { case t => LogContext(null) }
+      catch { case t: Throwable => LogContext(null) }
     }
 
     def run(): (Boolean, LogContext) = {
-      val result = try processSingleFile(testFile) catch { case t => (false, crashContext(t)) }
+      val result = try processSingleFile(testFile) catch { case t: Throwable => (false, crashContext(t)) }
       passed = Some(result._1)
       result
     }
diff --git a/src/partest/scala/tools/partest/package.scala b/src/partest/scala/tools/partest/package.scala
index 9b510eacd6..9f45b380eb 100644
--- a/src/partest/scala/tools/partest/package.scala
+++ b/src/partest/scala/tools/partest/package.scala
@@ -30,6 +30,9 @@ package object partest {
   implicit private[partest] def temporaryPath2File(x: Path): JFile = x.jfile
   implicit private[partest] def temporaryFile2Path(x: JFile): Path = Path(x)
 
+  implicit lazy val postfixOps = language.postfixOps
+  implicit lazy val implicitConversions = language.implicitConversions
+
   def timed[T](body: => T): (T, Long) = {
     val t1 = System.currentTimeMillis
     val result = body
@@ -60,7 +63,7 @@ package object partest {
 
   def allPropertiesString = {
     import collection.JavaConversions._
-    System.getProperties.toList.sorted map { case (k, v) => "%s -> %s\n".format(k, v) } mkString
+    System.getProperties.toList.sorted map { case (k, v) => "%s -> %s\n".format(k, v) } mkString ""
   }
 
   def showAllJVMInfo() {
diff --git a/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala b/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala
index fa758edf05..19f70ba785 100644
--- a/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala
+++ b/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala
@@ -226,7 +226,7 @@ trait BaseTypeSeqs {
     override def map(g: Type => Type) = lateMap(g)
     override def lateMap(g: Type => Type) = orig.lateMap(x => g(f(x)))
     override def exists(p: Type => Boolean) = elems exists (x => p(f(x)))
-    override protected def maxDepthOfElems: Int = elems map (x => typeDepth(f(x))) max
+    override protected def maxDepthOfElems: Int = elems.map(x => typeDepth(f(x))).max
     override def toString = elems.mkString("MBTS(", ",", ")")
   }
 
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index 6054af0ac2..b14306282b 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -163,8 +163,8 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
             val passedIn = named.collect {
               case (argName, argType) if argName == paramName => argType
             }.headOption
-            if (passedIn isDefined) passedIn
-            else defaults.get(paramIndex).map(_.asInstanceOf[Type])
+
+            passedIn orElse defaults.get(paramIndex).map(_.asInstanceOf[Type])
           }
 
           val rest1 = {
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index 01679a777d..14a9fe6701 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -600,7 +600,7 @@ trait Types extends api.Types { self: SymbolTable =>
     def decl(name: Name): Symbol = findDecl(name, 0)
 
     /** A list of all non-private members defined or declared in this type. */
-    def nonPrivateDecls: List[Symbol] = decls filter (x => !x.isPrivate) toList
+    def nonPrivateDecls: List[Symbol] = decls.filterNot(_.isPrivate).toList
 
     /** The non-private defined or declared members with name `name` in this type;
      *  an OverloadedSymbol if several exist, NoSymbol if none exist.
@@ -2613,7 +2613,7 @@ trait Types extends api.Types { self: SymbolTable =>
   case class PolyType(override val typeParams: List[Symbol], override val resultType: Type)
        extends Type with PolyTypeApi {
     //assert(!(typeParams contains NoSymbol), this)
-    assert(typeParams nonEmpty, this) // used to be a marker for nullary method type, illegal now (see @NullaryMethodType)
+    assert(typeParams.nonEmpty, this) // used to be a marker for nullary method type, illegal now (see @NullaryMethodType)
 
     override def paramSectionCount: Int = resultType.paramSectionCount
     override def paramss: List[List[Symbol]] = resultType.paramss
@@ -3275,7 +3275,7 @@ trait Types extends api.Types { self: SymbolTable =>
       // to never be resumed with the current implementation
       assert(!suspended, this)
       TypeVar.trace("clone", originLocation)(
-        TypeVar(origin, constr cloneInternal, typeArgs, params) // @M TODO: clone args/params?
+        TypeVar(origin, constr.cloneInternal, typeArgs, params) // @M TODO: clone args/params?
       )
     }
   }
@@ -3637,7 +3637,7 @@ trait Types extends api.Types { self: SymbolTable =>
    */
   object GenPolyType {
     def apply(tparams: List[Symbol], tpe: Type): Type = (
-      if (tparams nonEmpty) typeFun(tparams, tpe)
+      if (tparams.nonEmpty) typeFun(tparams, tpe)
       else tpe // it's okay to be forgiving here
     )
     def unapply(tpe: Type): Option[(List[Symbol], Type)] = tpe match {
@@ -4652,14 +4652,14 @@ trait Types extends api.Types { self: SymbolTable =>
 // dependent method types
   object IsDependentCollector extends TypeCollector(false) {
     def traverse(tp: Type) {
-      if(tp isImmediatelyDependent) result = true
+      if (tp.isImmediatelyDependent) result = true
       else if (!result) mapOver(tp)
     }
   }
 
   object ApproximateDependentMap extends TypeMap {
     def apply(tp: Type): Type =
-      if(tp isImmediatelyDependent) WildcardType
+      if (tp.isImmediatelyDependent) WildcardType
       else mapOver(tp)
   }
 
@@ -6159,7 +6159,7 @@ trait Types extends api.Types { self: SymbolTable =>
     }
 
     val sorted       = btsMap.toList.sortWith((x, y) => x._1.typeSymbol isLess y._1.typeSymbol)
-    val maxSeqLength = sorted map (_._2.size) max
+    val maxSeqLength = sorted.map(_._2.size).max
     val padded       = sorted map (_._2.padTo(maxSeqLength, NoType))
     val transposed   = padded.transpose
 
@@ -6265,7 +6265,7 @@ trait Types extends api.Types { self: SymbolTable =>
             }).mkString("")
 
             println("Frontier(\n" + str + ")")
-            printLubMatrix(ts zip tsBts toMap, lubListDepth)
+            printLubMatrix((ts zip tsBts).toMap, lubListDepth)
           }
 
           loop(newtps)
@@ -6275,7 +6275,7 @@ trait Types extends api.Types { self: SymbolTable =>
 
     val initialBTSes = ts map (_.baseTypeSeq.toList)
     if (printLubs)
-      printLubMatrix(ts zip initialBTSes toMap, depth)
+      printLubMatrix((ts zip initialBTSes).toMap, depth)
 
     loop(initialBTSes)
   }
@@ -6483,7 +6483,7 @@ trait Types extends api.Types { self: SymbolTable =>
                 map2(narrowts, syms)((t, sym) => t.memberInfo(sym).substThis(t.typeSymbol, lubThisType))
               if (proto.isTerm) // possible problem: owner of info is still the old one, instead of new refinement class
                 proto.cloneSymbol(lubRefined.typeSymbol).setInfoOwnerAdjusted(lub(symtypes, decr(depth)))
-              else if (symtypes.tail forall (symtypes.head =:=))
+              else if (symtypes.tail forall (symtypes.head =:= _))
                 proto.cloneSymbol(lubRefined.typeSymbol).setInfoOwnerAdjusted(symtypes.head)
               else {
                 def lubBounds(bnds: List[TypeBounds]): TypeBounds =
@@ -6857,7 +6857,7 @@ trait Types extends api.Types { self: SymbolTable =>
     tps map {
       case MethodType(params1, res) if (isSameTypes(params1 map (_.tpe), pts)) =>
         res
-      case NullaryMethodType(res) if pts isEmpty =>
+      case NullaryMethodType(res) if pts.isEmpty =>
         res
       case _ =>
         throw new NoCommonType(tps)
diff --git a/src/reflect/scala/reflect/internal/util/Origins.scala b/src/reflect/scala/reflect/internal/util/Origins.scala
index 0bd5ad55ca..3111730f76 100644
--- a/src/reflect/scala/reflect/internal/util/Origins.scala
+++ b/src/reflect/scala/reflect/internal/util/Origins.scala
@@ -96,7 +96,7 @@ object Origins {
     || (el.getClassName startsWith "java.lang.")
   )
   private def findCutoff() = {
-    val cutoff = Thread.currentThread.getStackTrace dropWhile preCutoff head;
+    val cutoff = (Thread.currentThread.getStackTrace dropWhile preCutoff).head
     OriginId(cutoff.getClassName, cutoff.getMethodName)
   }
 
diff --git a/src/reflect/scala/reflect/internal/util/SourceFile.scala b/src/reflect/scala/reflect/internal/util/SourceFile.scala
index df4a3336c3..f24e44b351 100644
--- a/src/reflect/scala/reflect/internal/util/SourceFile.scala
+++ b/src/reflect/scala/reflect/internal/util/SourceFile.scala
@@ -41,7 +41,7 @@ abstract class SourceFile {
     (content drop offset) startsWith text
 
   def lineToString(index: Int): String =
-    content drop lineToOffset(index) takeWhile (c => !isLineBreakChar(c.toChar)) mkString
+    content drop lineToOffset(index) takeWhile (c => !isLineBreakChar(c.toChar)) mkString ""
 
   @tailrec
   final def skipWhitespace(offset: Int): Int =
diff --git a/src/reflect/scala/reflect/internal/util/TableDef.scala b/src/reflect/scala/reflect/internal/util/TableDef.scala
index d692a6d8f5..2e60ce3bcc 100644
--- a/src/reflect/scala/reflect/internal/util/TableDef.scala
+++ b/src/reflect/scala/reflect/internal/util/TableDef.scala
@@ -1,6 +1,7 @@
 package scala.reflect.internal.util
 
 import TableDef._
+import language.postfixOps
 
 /** A class for representing tabular data in a way that preserves
  *  its inner beauty.  See Exceptional for an example usage.
diff --git a/src/reflect/scala/reflect/runtime/ReflectionUtils.scala b/src/reflect/scala/reflect/runtime/ReflectionUtils.scala
index 7839850529..f696aceb93 100644
--- a/src/reflect/scala/reflect/runtime/ReflectionUtils.scala
+++ b/src/reflect/scala/reflect/runtime/ReflectionUtils.scala
@@ -38,6 +38,8 @@ object ReflectionUtils {
   )
 
   def show(cl: ClassLoader): String = {
+    import language.reflectiveCalls
+
     def isAbstractFileClassLoader(clazz: Class[_]): Boolean = {
       if (clazz == null) return false
       if (clazz.getName == "scala.tools.nsc.interpreter.AbstractFileClassLoader") return true
diff --git a/src/reflect/scala/tools/nsc/io/File.scala b/src/reflect/scala/tools/nsc/io/File.scala
index eedf92ef98..1f3cac7ee1 100644
--- a/src/reflect/scala/tools/nsc/io/File.scala
+++ b/src/reflect/scala/tools/nsc/io/File.scala
@@ -120,13 +120,13 @@ class File(jfile: JFile)(implicit constructorCodec: Codec) extends Path(jfile) w
   def writeAll(strings: String*): Unit = {
     val out = bufferedWriter()
     try strings foreach (out write _)
-    finally out close
+    finally out.close()
   }
 
   def writeBytes(bytes: Array[Byte]): Unit = {
     val out = bufferedOutput()
     try out write bytes
-    finally out close
+    finally out.close()
   }
 
   def appendAll(strings: String*): Unit = {
@@ -139,7 +139,7 @@ class File(jfile: JFile)(implicit constructorCodec: Codec) extends Path(jfile) w
   def printlnAll(strings: String*): Unit = {
     val out = printWriter()
     try strings foreach (out println _)
-    finally out close
+    finally out.close()
   }
 
   def safeSlurp(): Option[String] =
diff --git a/src/reflect/scala/tools/nsc/io/Path.scala b/src/reflect/scala/tools/nsc/io/Path.scala
index 984c96dfbb..74bd6cf16b 100644
--- a/src/reflect/scala/tools/nsc/io/Path.scala
+++ b/src/reflect/scala/tools/nsc/io/Path.scala
@@ -78,7 +78,7 @@ object Path {
     else new Path(jfile)
 
   /** Avoiding any shell/path issues by only using alphanumerics. */
-  private[io] def randomPrefix = alphanumeric take 6 mkString
+  private[io] def randomPrefix = alphanumeric take 6 mkString ""
   private[io] def fail(msg: String) = throw FileOperationException(msg)
 }
 import Path._
diff --git a/src/reflect/scala/tools/nsc/io/Streamable.scala b/src/reflect/scala/tools/nsc/io/Streamable.scala
index 03318674ee..4d872c0221 100644
--- a/src/reflect/scala/tools/nsc/io/Streamable.scala
+++ b/src/reflect/scala/tools/nsc/io/Streamable.scala
@@ -112,7 +112,7 @@ object Streamable {
     finally stream.close()
 
   def bytes(is: => InputStream): Array[Byte] =
-    new Bytes { def inputStream() = is } toByteArray
+    (new Bytes { def inputStream() = is }).toByteArray
 
   def slurp(is: => InputStream)(implicit codec: Codec): String =
     new Chars { def inputStream() = is } slurp codec
diff --git a/src/reflect/scala/tools/nsc/io/VirtualDirectory.scala b/src/reflect/scala/tools/nsc/io/VirtualDirectory.scala
index 0bcb2de43f..7272921054 100644
--- a/src/reflect/scala/tools/nsc/io/VirtualDirectory.scala
+++ b/src/reflect/scala/tools/nsc/io/VirtualDirectory.scala
@@ -48,7 +48,7 @@ extends AbstractFile {
   def iterator = files.values.toList.iterator
 
   override def lookupName(name: String, directory: Boolean): AbstractFile =
-    files get name filter (_.isDirectory == directory) orNull
+    (files get name filter (_.isDirectory == directory)).orNull
 
   override def fileNamed(name: String): AbstractFile =
     Option(lookupName(name, false)) getOrElse {
diff --git a/src/scalap/scala/tools/scalap/Arguments.scala b/src/scalap/scala/tools/scalap/Arguments.scala
index 37f6cd84ac..53f722994d 100644
--- a/src/scalap/scala/tools/scalap/Arguments.scala
+++ b/src/scalap/scala/tools/scalap/Arguments.scala
@@ -48,7 +48,7 @@ object Arguments {
 
     def parseBinding(str: String, separator: Char): (String, String) = (str indexOf separator) match {
       case -1   => argumentError("missing '" + separator + "' in binding '" + str + "'") ; Pair("", "")
-      case idx  => Pair(str take idx trim, str drop (idx + 1) trim)
+      case idx  => Pair((str take idx).trim, (str drop (idx + 1)).trim)
     }
 
     def parse(args: Array[String]): Arguments = {
diff --git a/src/scalap/scala/tools/scalap/CodeWriter.scala b/src/scalap/scala/tools/scalap/CodeWriter.scala
index d895ce3836..f5db183abb 100644
--- a/src/scalap/scala/tools/scalap/CodeWriter.scala
+++ b/src/scalap/scala/tools/scalap/CodeWriter.scala
@@ -58,7 +58,7 @@ class CodeWriter(writer: Writer) {
       try {
         writer.write(nl)
       } catch {
-        case e => sys.error("IO error")
+        case e: Exception => sys.error("IO error")
       }
       line = align
       align = true
@@ -127,7 +127,7 @@ class CodeWriter(writer: Writer) {
     line = false
     this
   } catch {
-    case e => sys.error("IO error")
+    case e: Exception => sys.error("IO error")
   }
 
   override def toString(): String = writer.toString()
diff --git a/src/scalap/scala/tools/scalap/Decode.scala b/src/scalap/scala/tools/scalap/Decode.scala
index 4e12075541..26cea76893 100644
--- a/src/scalap/scala/tools/scalap/Decode.scala
+++ b/src/scalap/scala/tools/scalap/Decode.scala
@@ -49,7 +49,7 @@ object Decode {
     import classFile._
 
     classFile annotation SCALA_SIG_ANNOTATION map { case Annotation(_, els) =>
-      val bytesElem = els find (x => constant(x.elementNameIndex) == BYTES_VALUE) get
+      val bytesElem = els find (x => constant(x.elementNameIndex) == BYTES_VALUE) getOrElse null
       val _bytes    = bytesElem.elementValue match { case ConstValueIndex(x) => constantWrapped(x) }
       val bytes     = _bytes.asInstanceOf[StringBytesPair].bytes
       val length    = ByteCodecs.decode(bytes)
@@ -81,7 +81,7 @@ object Decode {
             xs.toList map (_.name dropRight 1)
         }
 
-      (ssig.symbols collect f).flatten toList
+      (ssig.symbols collect f).flatten.toList
     }
   }
 
diff --git a/src/scalap/scala/tools/scalap/MetaParser.scala b/src/scalap/scala/tools/scalap/MetaParser.scala
index ca9bd93f86..036738c5e9 100644
--- a/src/scalap/scala/tools/scalap/MetaParser.scala
+++ b/src/scalap/scala/tools/scalap/MetaParser.scala
@@ -61,7 +61,7 @@ class MetaParser(meta: String) {
         else
           None
       } catch {
-        case _ => None
+        case _: Exception => None
       }
     } else
       None;
diff --git a/src/scalap/scala/tools/scalap/scalax/rules/package.scala b/src/scalap/scala/tools/scalap/scalax/rules/package.scala
new file mode 100644
index 0000000000..324e87435e
--- /dev/null
+++ b/src/scalap/scala/tools/scalap/scalax/rules/package.scala
@@ -0,0 +1,9 @@
+package scala.tools.scalap
+package scalax
+
+package object rules {
+  implicit lazy val higherKinds         = language.higherKinds
+  implicit lazy val postfixOps          = language.postfixOps
+  implicit lazy val implicitConversions = language.implicitConversions
+  implicit lazy val reflectiveCalls     = language.reflectiveCalls
+}
diff --git a/src/swing/scala/swing/Action.scala b/src/swing/scala/swing/Action.scala
index 9deea0f3d4..a609329510 100644
--- a/src/swing/scala/swing/Action.scala
+++ b/src/swing/scala/swing/Action.scala
@@ -135,7 +135,7 @@ abstract class Action(title0: String) {
   def accelerator: Option[KeyStroke] =
     toOption(peer.getValue(javax.swing.Action.ACCELERATOR_KEY))
   def accelerator_=(k: Option[KeyStroke]) {
-    peer.putValue(javax.swing.Action.ACCELERATOR_KEY, k orNull)
+    peer.putValue(javax.swing.Action.ACCELERATOR_KEY, k.orNull)
   }
 
   /**
diff --git a/src/swing/scala/swing/ComboBox.scala b/src/swing/scala/swing/ComboBox.scala
index 75f981064b..c7a457d082 100644
--- a/src/swing/scala/swing/ComboBox.scala
+++ b/src/swing/scala/swing/ComboBox.scala
@@ -6,8 +6,6 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.swing
 
 import event._
@@ -205,6 +203,6 @@ class ComboBox[A](items: Seq[A]) extends Component with Publisher {
 
   def prototypeDisplayValue: Option[A] = toOption[A](peer.getPrototypeDisplayValue)
   def prototypeDisplayValue_=(v: Option[A]) {
-    peer.setPrototypeDisplayValue(v map toAnyRef orNull)
+    peer.setPrototypeDisplayValue((v map toAnyRef).orNull)
   }
 }
diff --git a/src/swing/scala/swing/GridBagPanel.scala b/src/swing/scala/swing/GridBagPanel.scala
index d5b2472e38..dd4cbe3bcf 100644
--- a/src/swing/scala/swing/GridBagPanel.scala
+++ b/src/swing/scala/swing/GridBagPanel.scala
@@ -6,13 +6,10 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.swing
 
 import java.awt.{GridBagConstraints, GridBagLayout}
 
-
 object GridBagPanel {
   object Fill extends Enumeration {
     val None = Value(GridBagConstraints.NONE)
diff --git a/src/swing/scala/swing/RichWindow.scala b/src/swing/scala/swing/RichWindow.scala
index 977aab300a..8eb58d56c9 100644
--- a/src/swing/scala/swing/RichWindow.scala
+++ b/src/swing/scala/swing/RichWindow.scala
@@ -145,7 +145,7 @@ object Dialog {
                   initial: Int): Result.Value = {
     val r = JOptionPane.showOptionDialog(nullPeer(parent), message, title,
       optionType.id, messageType.id, Swing.wrapIcon(icon),
-      entries map toAnyRef toArray, entries(initial))
+      (entries map toAnyRef).toArray, entries(initial))
     Result(r)
   }
 
@@ -157,7 +157,7 @@ object Dialog {
                    entries: Seq[A] = Nil,
                    initial: A): Option[A] = {
     val e = if (entries.isEmpty) null
-    else entries map toAnyRef toArray
+    else (entries map toAnyRef).toArray
     val r = JOptionPane.showInputDialog(nullPeer(parent), message, title,
       messageType.id, Swing.wrapIcon(icon),
       e, initial)
diff --git a/src/swing/scala/swing/ScrollPane.scala b/src/swing/scala/swing/ScrollPane.scala
index 5c18bb138a..966d5889e2 100644
--- a/src/swing/scala/swing/ScrollPane.scala
+++ b/src/swing/scala/swing/ScrollPane.scala
@@ -65,17 +65,17 @@ class ScrollPane extends Component with Container {
   def rowHeaderView: Option[Component] =
     Option(peer.getRowHeader.getView) map UIElement.cachedWrapper[Component]
   def rowHeaderView_=(c: Component) = peer.setRowHeaderView(c.peer)
-  def rowHeaderView_=(c: Option[Component]) = peer.setRowHeaderView(c map (_.peer) orNull)
+  def rowHeaderView_=(c: Option[Component]) = peer.setRowHeaderView(c.map(_.peer).orNull)
 
   def columnHeaderView: Option[Component] =
     Option(peer.getColumnHeader.getView) map UIElement.cachedWrapper[Component]
   def columnHeaderView_=(c: Component) = peer.setColumnHeaderView(c.peer)
-  def columnHeaderView_=(c: Option[Component]) = peer.setColumnHeaderView(c map (_.peer) orNull)
+  def columnHeaderView_=(c: Option[Component]) = peer.setColumnHeaderView(c.map(_.peer).orNull)
 
   def viewportView: Option[Component] =
     Option(peer.getViewport.getView) map UIElement.cachedWrapper[Component]
   def viewportView_=(c: Component) = peer.setViewportView(c.peer)
-  def viewportView_=(c: Option[Component]) = peer.setViewportView(c map (_.peer) orNull)
+  def viewportView_=(c: Option[Component]) = peer.setViewportView(c.map(_.peer).orNull)
 
   def verticalScrollBarPolicy = BarPolicy.wrap(peer.getVerticalScrollBarPolicy)
   def verticalScrollBarPolicy_=(p: BarPolicy.Value) = peer.setVerticalScrollBarPolicy(p.verticalPeer)
diff --git a/src/swing/scala/swing/Swing.scala b/src/swing/scala/swing/Swing.scala
index 519ccbaf33..05291f9aee 100644
--- a/src/swing/scala/swing/Swing.scala
+++ b/src/swing/scala/swing/Swing.scala
@@ -15,6 +15,7 @@ import javax.swing.event._
 import javax.swing.border._
 import javax.swing.{JComponent, Icon, BorderFactory, SwingUtilities}
 
+
 /**
  * Helpers for this package.
  */
diff --git a/src/swing/scala/swing/UIElement.scala b/src/swing/scala/swing/UIElement.scala
index 04e2217943..a83496fff0 100644
--- a/src/swing/scala/swing/UIElement.scala
+++ b/src/swing/scala/swing/UIElement.scala
@@ -37,7 +37,7 @@ object UIElement {
       case c: javax.swing.JComponent => c.getClientProperty(ClientKey)
       case _ => wrapperCache.get(c)
     }
-    try { w.asInstanceOf[C] } catch { case _ => null }
+    try { w.asInstanceOf[C] } catch { case _: Exception => null }
   }
 
   /**
diff --git a/src/swing/scala/swing/Window.scala b/src/swing/scala/swing/Window.scala
index 7991026a69..db911be0d7 100644
--- a/src/swing/scala/swing/Window.scala
+++ b/src/swing/scala/swing/Window.scala
@@ -51,7 +51,7 @@ abstract class Window extends UIElement with RootPanel with Publisher { outer =>
     peer.getRootPane.setDefaultButton(b.peer)
   }
   def defaultButton_=(b: Option[Button]) {
-    peer.getRootPane.setDefaultButton(b map (_.peer) orNull)
+    peer.getRootPane.setDefaultButton(b.map(_.peer).orNull)
   }
 
   def dispose() { peer.dispose() }
diff --git a/src/swing/scala/swing/package.scala b/src/swing/scala/swing/package.scala
index d5095f021b..96530e2e94 100644
--- a/src/swing/scala/swing/package.scala
+++ b/src/swing/scala/swing/package.scala
@@ -14,6 +14,9 @@ package object swing {
   type Image = java.awt.Image
   type Font = java.awt.Font
 
+  implicit lazy val reflectiveCalls     = language.reflectiveCalls
+  implicit lazy val implicitConversions = language.implicitConversions
+
   private[swing] def ifNull[A](o: Object, a: A): A = if(o eq null) a else o.asInstanceOf[A]
   private[swing] def toOption[A](o: Object): Option[A] = if(o eq null) None else Some(o.asInstanceOf[A])
   private[swing] def toAnyRef(x: Any): AnyRef = x.asInstanceOf[AnyRef]
diff --git a/test/files/neg/unchecked.check b/test/files/neg/unchecked.check
new file mode 100644
index 0000000000..34a11db1a0
--- /dev/null
+++ b/test/files/neg/unchecked.check
@@ -0,0 +1,19 @@
+unchecked.scala:18: error: non-variable type argument String in type pattern Iterable[String] is unchecked since it is eliminated by erasure
+    case xs: Iterable[String] => xs.head // unchecked
+             ^
+unchecked.scala:22: error: non-variable type argument Any in type pattern Set[Any] is unchecked since it is eliminated by erasure
+    case xs: Set[Any]    => xs.head // unchecked
+             ^
+unchecked.scala:26: error: non-variable type argument Any in type pattern Map[Any,Any] is unchecked since it is eliminated by erasure
+    case xs: Map[Any, Any] => xs.head // unchecked
+             ^
+unchecked.scala:35: error: non-variable type argument List[Nothing] in type pattern Test.Contra[List[Nothing]] is unchecked since it is eliminated by erasure
+    case xs: Contra[List[Nothing]] => xs.head // unchecked
+             ^
+unchecked.scala:50: error: non-variable type argument String in type pattern Test.Exp[String] is unchecked since it is eliminated by erasure
+    case ArrayApply(x: Exp[Array[T]], _, j: Exp[String]) => x // unchecked
+                                            ^
+unchecked.scala:55: error: non-variable type argument Array[T] in type pattern Test.Exp[Array[T]] is unchecked since it is eliminated by erasure
+    case ArrayApply(x: Exp[Array[T]], _, _) => x // unchecked
+                       ^
+6 errors found
diff --git a/test/files/neg/unchecked.flags b/test/files/neg/unchecked.flags
new file mode 100644
index 0000000000..464cc20ea6
--- /dev/null
+++ b/test/files/neg/unchecked.flags
@@ -0,0 +1 @@
+-Xfatal-warnings -unchecked
\ No newline at end of file
diff --git a/test/files/neg/unchecked.scala b/test/files/neg/unchecked.scala
new file mode 100644
index 0000000000..b50cdf9d7a
--- /dev/null
+++ b/test/files/neg/unchecked.scala
@@ -0,0 +1,74 @@
+import language.existentials
+
+object Test {
+  class Def[T]
+  class Exp[T]
+  class Contra[-T] { def head[T1 <: T] : T1 = ??? }
+  class Cov[+T] { }
+
+  case class ArrayApply[T](x: Exp[Array[T]], i: Exp[Int], j: Exp[_]) extends Def[T]
+
+  val IntArrayApply = ArrayApply[Int](new Exp[Array[Int]], new Exp[Int], new Exp[Int])
+
+  def f(x: Any) = x match {
+    case xs: Iterable[Any]    => xs.head // okay
+    case _                    => 0
+  }
+  def f2(x: Any) = x match {
+    case xs: Iterable[String] => xs.head // unchecked
+    case _                    => 0
+  }
+  def f3(x: Any) = x match {
+    case xs: Set[Any]    => xs.head // unchecked
+    case _                    => 0
+  }
+  def f4(x: Any) = x match {
+    case xs: Map[Any, Any] => xs.head // unchecked
+    case _                 => 0
+  }
+
+  def cf1(x: Any) = x match {
+    case xs: Contra[Nothing] => xs.head // okay
+    case _                   => 0
+  }
+  def cf2(x: Any) = x match {
+    case xs: Contra[List[Nothing]] => xs.head // unchecked
+    case _                         => 0
+  }
+
+  def co1(x: List[Cov[List[Int]]]) = x match {
+    case _: Seq[Cov[Seq[Any]]] => true  // okay
+    case _                     => false
+  }
+
+  def g[T](x: Def[T]) = x match {
+    case ArrayApply(x: Exp[Array[T]], i: Exp[Int], _) => x // okay
+    case _                                            => 0
+  }
+
+  def g2[T](x: Def[T]) = x match {
+    case ArrayApply(x: Exp[Array[T]], _, j: Exp[String]) => x // unchecked
+    case _                                               => 0
+  }
+
+  def g3[T](x: Any) = x match {
+    case ArrayApply(x: Exp[Array[T]], _, _) => x // unchecked
+    case _                                  => 0
+  }
+
+  def g4 = IntArrayApply match {
+    case ArrayApply(x: Exp[Array[Int]], _, _) => x // okay
+    case _                                    => ()
+  }
+  def g5[T](x: ArrayApply[Int]) = x match {
+    case ArrayApply(x: Exp[Array[Int]], _, _) => x // okay
+    case _                                    => 0
+  }
+
+  // Nope
+  //
+  // def g5 = IntArrayApply match {
+  //   case ArrayApply(x: Exp[Array[String]], _, _) => x // nope
+  //   case _                                       => ()
+  // }
+}
diff --git a/test/files/neg/unchecked2.check b/test/files/neg/unchecked2.check
index 2c0be9ce00..e37865928e 100644
--- a/test/files/neg/unchecked2.check
+++ b/test/files/neg/unchecked2.check
@@ -1,19 +1,19 @@
-unchecked2.scala:2: error: non variable type-argument Int in type Option[Int] is unchecked since it is eliminated by erasure
+unchecked2.scala:2: error: non-variable type argument Int in type Option[Int] is unchecked since it is eliminated by erasure
   Some(123).isInstanceOf[Option[Int]]
                         ^
-unchecked2.scala:3: error: non variable type-argument String in type Option[String] is unchecked since it is eliminated by erasure
+unchecked2.scala:3: error: non-variable type argument String in type Option[String] is unchecked since it is eliminated by erasure
   Some(123).isInstanceOf[Option[String]]
                         ^
-unchecked2.scala:4: error: non variable type-argument List[String] in type Option[List[String]] is unchecked since it is eliminated by erasure
+unchecked2.scala:4: error: non-variable type argument List[String] in type Option[List[String]] is unchecked since it is eliminated by erasure
   Some(123).isInstanceOf[Option[List[String]]]
                         ^
-unchecked2.scala:5: error: non variable type-argument List[Int => String] in type Option[List[Int => String]] is unchecked since it is eliminated by erasure
+unchecked2.scala:5: error: non-variable type argument List[Int => String] in type Option[List[Int => String]] is unchecked since it is eliminated by erasure
   Some(123).isInstanceOf[Option[List[Int => String]]]
                         ^
-unchecked2.scala:6: error: non variable type-argument (String, Double) in type Option[(String, Double)] is unchecked since it is eliminated by erasure
+unchecked2.scala:6: error: non-variable type argument (String, Double) in type Option[(String, Double)] is unchecked since it is eliminated by erasure
   Some(123).isInstanceOf[Option[(String, Double)]]
                         ^
-unchecked2.scala:7: error: non variable type-argument String => Double in type Option[String => Double] is unchecked since it is eliminated by erasure
+unchecked2.scala:7: error: non-variable type argument String => Double in type Option[String => Double] is unchecked since it is eliminated by erasure
   Some(123).isInstanceOf[Option[String => Double]]
                         ^
 6 errors found
diff --git a/test/files/pos/unchecked-a.flags b/test/files/pos/unchecked-a.flags
new file mode 100644
index 0000000000..779916d58f
--- /dev/null
+++ b/test/files/pos/unchecked-a.flags
@@ -0,0 +1 @@
+-unchecked -Xfatal-warnings
\ No newline at end of file
diff --git a/test/files/pos/unchecked-a.scala b/test/files/pos/unchecked-a.scala
new file mode 100644
index 0000000000..deceb91c36
--- /dev/null
+++ b/test/files/pos/unchecked-a.scala
@@ -0,0 +1,15 @@
+trait Y
+trait Z extends Y
+class X[+A <: Y]
+
+object Test {
+  def f1(x: X[_ <: Y]) = x match {
+    case _: X[Any] => // looks a little funny; `Any` is outside the bounds for `A`
+  }
+  def f2(x: X[_ <: Y]) = x match {
+    case _: X[Y]   => // looks better, let's allow this (too)
+  }
+
+  // NonLocalReturnControl[_] warnings
+  def foo: Int = List(0).foldLeft(0){case _ => return 0}
+}