Lots of tedious warning and tree printing work.

Fewer deprecation warnings, prettier trees, prettier
symbols, more polished error messages.

Oh the interesting people you meet handling warnings, I
feel sorry for you all that I get to do it all the time.
One of the characters I met invited me into the "Dead Code
Society" and that's what I'm doing on Tuesdays now.  No of
course you haven't, it's a SECRET society.

34 files changed, 286 insertions, 201 deletions

diff --git a/src/compiler/scala/reflect/internal/Definitions.scala b/src/compiler/scala/reflect/internal/Definitions.scala
index bd823c3128..a2dd6fc4c3 100644
--- a/src/compiler/scala/reflect/internal/Definitions.scala
+++ b/src/compiler/scala/reflect/internal/Definitions.scala
@@ -764,9 +764,25 @@ trait Definitions extends reflect.api.StandardDefinitions {
       else
         removeRedundantObjects(parents)
     }
+
+    def typeStringNoPackage(tp: Type) =
+      "" + tp stripPrefix tp.typeSymbol.enclosingPackage.fullName + "."
+
+    def briefParentsString(parents: List[Type]) =
+      normalizedParents(parents) map typeStringNoPackage mkString " with "
+
     def parentsString(parents: List[Type]) =
       normalizedParents(parents) mkString " with "
 
+    def typeParamsString(tp: Type) = tp match {
+      case PolyType(tparams, _) => tparams map (_.defString) mkString ("[", ",", "]")
+      case _                    => ""
+    }
+    def valueParamsString(tp: Type) = tp match {
+      case MethodType(params, _) => params map (_.defString) mkString ("(", ",", ")")
+      case _                     => ""
+    }
+
     // members of class java.lang.{ Object, String }
     lazy val Object_## = enterNewMethod(ObjectClass, nme.HASHHASH, Nil, inttype, FINAL)
     lazy val Object_== = enterNewMethod(ObjectClass, nme.EQ, anyrefparam, booltype, FINAL)
@@ -970,7 +986,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
         case (_, restpe)             => NullaryMethodType(restpe)
       }
 
-      msym setInfoAndEnter polyType(tparams, mtpe)
+      msym setInfoAndEnter genPolyType(tparams, mtpe)
     }
 
     /** T1 means one type parameter.
diff --git a/src/compiler/scala/reflect/internal/Kinds.scala b/src/compiler/scala/reflect/internal/Kinds.scala
index 23bff950b8..eca63c7c15 100644
--- a/src/compiler/scala/reflect/internal/Kinds.scala
+++ b/src/compiler/scala/reflect/internal/Kinds.scala
@@ -49,9 +49,15 @@ trait Kinds {
     private def kindMessage(a: Symbol, p: Symbol)(f: (String, String) => String): String =
       f(a+qualify(a,p), p+qualify(p,a))
 
+    // Normally it's nicer to print nothing rather than '>: Nothing <: Any' all over
+    // the place, but here we need it for the message to make sense.
     private def strictnessMessage(a: Symbol, p: Symbol) =
-      kindMessage(a, p)("%s's bounds %s are stricter than %s's declared bounds %s".format(
-        _, a.info, _, p.info))
+      kindMessage(a, p)("%s's bounds%s are stricter than %s's declared bounds%s".format(
+        _, a.info, _, p.info match {
+          case tb @ TypeBounds(_, _) if tb.isEmptyBounds  => " >: Nothing <: Any"
+          case tb                                         => "" + tb
+        })
+      )
 
     private def varianceMessage(a: Symbol, p: Symbol) =
       kindMessage(a, p)("%s is %s, but %s is declared %s".format(_, varStr(a), _, varStr(p)))
@@ -62,11 +68,16 @@ trait Kinds {
         _, countAsString(p.typeParams.length))
       )
 
+    private def buildMessage(xs: List[SymPair], f: (Symbol, Symbol) => String) = (
+      if (xs.isEmpty) ""
+      else xs map f.tupled mkString ("\n", ", ", "")
+    )
+
     def errorMessage(targ: Type, tparam: Symbol): String = (
-        (targ+"'s type parameters do not match "+tparam+"'s expected parameters: ")
-      + (arity map { case (a, p) => arityMessage(a, p) } mkString ", ")
-      + (variance map { case (a, p) => varianceMessage(a, p) } mkString ", ")
-      + (strictness map { case (a, p) => strictnessMessage(a, p) } mkString ", ")
+        (targ+"'s type parameters do not match "+tparam+"'s expected parameters:")
+      + buildMessage(arity, arityMessage)
+      + buildMessage(variance, varianceMessage)
+      + buildMessage(strictness, strictnessMessage)
     )
   }
   val NoKindErrors = KindErrors(Nil, Nil, Nil)
diff --git a/src/compiler/scala/reflect/internal/Symbols.scala b/src/compiler/scala/reflect/internal/Symbols.scala
index 907f7d1237..2ba45c5972 100644
--- a/src/compiler/scala/reflect/internal/Symbols.scala
+++ b/src/compiler/scala/reflect/internal/Symbols.scala
@@ -2078,47 +2078,32 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       case s    => " in " + s
     }
     def fullLocationString: String = toString + locationString
-    def signatureString: String = if (hasRawInfo) infoString(rawInfo) else "<_>"
+    def signatureString: String    = if (hasRawInfo) infoString(rawInfo) else "<_>"
 
     /** String representation of symbol's definition following its name */
     final def infoString(tp: Type): String = {
-      def typeParamsString: String = tp match {
-        case PolyType(tparams, _) if tparams.nonEmpty =>
-          (tparams map (_.defString)).mkString("[", ",", "]")
-        case _ =>
-          ""
-      }
-      if (isClass)
-        typeParamsString + " extends " + tp.resultType
-      else if (isAliasType)
-        typeParamsString + " = " + tp.resultType
-      else if (isAbstractType)
-        typeParamsString + {
-          tp.resultType match {
-            case TypeBounds(lo, hi) =>
-              (if (lo.typeSymbol == NothingClass) "" else " >: " + lo) +
-              (if (hi.typeSymbol == AnyClass) "" else " <: " + hi)
-            case rtp =>
-              "<: " + rtp
-          }
-        }
-      else if (isModule)
-        moduleClass.infoString(tp)
-      else
-        tp match {
-          case PolyType(tparams, res) =>
-            typeParamsString + infoString(res)
-          case NullaryMethodType(res) =>
-            infoString(res)
-          case MethodType(params, res) =>
-            params.map(_.defString).mkString("(", ",", ")") + infoString(res)
-          case _ =>
-            ": " + tp
+      def parents = (
+        if (settings.debug.value) parentsString(tp.parents)
+        else briefParentsString(tp.parents)
+      )
+      if (isType) typeParamsString(tp) + (
+        if (isClass) " extends " + parents
+        else if (isAliasType) " = " + tp.resultType
+        else tp.resultType match {
+          case rt @ TypeBounds(_, _) => "" + rt
+          case rt                    => " <: " + rt
         }
+      )
+      else if (isModule) moduleClass.infoString(tp)
+      else tp match {
+        case PolyType(tparams, res)  => typeParamsString(tp) + infoString(res)
+        case NullaryMethodType(res)  => infoString(res)
+        case MethodType(params, res) => valueParamsString(tp) + infoString(res)
+        case _                       => ": " + tp
+      }
     }
 
-    def infosString = infos.toString()
-
+    def infosString = infos.toString
     def debugLocationString = fullLocationString + " " + debugFlagString
     def debugFlagString = hasFlagsToString(-1L)
     def hasFlagsToString(mask: Long): String = flagsToString(
@@ -2684,7 +2669,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     override def rawInfo: Type = NoType
     protected def doCookJavaRawInfo() {}
     override def accessBoundary(base: Symbol): Symbol = RootClass
-    def cloneSymbolImpl(owner: Symbol, newFlags: Long): Symbol = abort()
+    def cloneSymbolImpl(owner: Symbol, newFlags: Long): Symbol = abort("NoSymbol.clone()")
     override def originalEnclosingMethod = this
 
     override def owner: Symbol =
diff --git a/src/compiler/scala/reflect/internal/Types.scala b/src/compiler/scala/reflect/internal/Types.scala
index 2bb19e2b65..a20853adc8 100644
--- a/src/compiler/scala/reflect/internal/Types.scala
+++ b/src/compiler/scala/reflect/internal/Types.scala
@@ -1337,9 +1337,14 @@ trait Types extends api.Types { self: SymbolTable =>
       case TypeBounds(_, _) => that <:< this
       case _                => lo <:< that && that <:< hi
     }
-    def isEmptyBounds = (lo.typeSymbolDirect eq NothingClass) && (hi.typeSymbolDirect eq AnyClass)
+    private def lowerString = if (emptyLowerBound) "" else " >: " + lo
+    private def upperString = if (emptyUpperBound) "" else " <: " + hi
+    private def emptyLowerBound = lo.typeSymbolDirect eq NothingClass
+    private def emptyUpperBound = hi.typeSymbolDirect eq AnyClass
+    def isEmptyBounds = emptyLowerBound && emptyUpperBound
+
     // override def isNullable: Boolean = NullClass.tpe <:< lo;
-    override def safeToString = ">: " + lo + " <: " + hi
+    override def safeToString = lowerString + upperString
     override def kind = "TypeBoundsType"
   }
 
@@ -3321,16 +3326,18 @@ trait Types extends api.Types { self: SymbolTable =>
    *  may or may not be poly? (It filched the standard "canonical creator" name.)
    */
   object GenPolyType {
-    def apply(tparams: List[Symbol], tpe: Type): Type =
-    if (tparams nonEmpty) typeFun(tparams, tpe)
-    else tpe // it's okay to be forgiving here
+    def apply(tparams: List[Symbol], tpe: Type): Type = (
+      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 {
-      case PolyType(tparams, restpe) => Some(tparams, restpe)
-      case _ => Some(List(), tpe)
+      case PolyType(tparams, restpe) => Some((tparams, restpe))
+      case _                         => Some((Nil, tpe))
     }
   }
+  def genPolyType(params: List[Symbol], tpe: Type): Type = GenPolyType(params, tpe)
 
-  @deprecated("use GenPolyType(...) instead")
+  @deprecated("use genPolyType(...) instead", "2.10.0")
   def polyType(params: List[Symbol], tpe: Type): Type = GenPolyType(params, tpe)
 
   /** A creator for anonymous type functions, where the symbol for the type function still needs to be created.
diff --git a/src/compiler/scala/reflect/runtime/ToolBoxes.scala b/src/compiler/scala/reflect/runtime/ToolBoxes.scala
index 8cc4d5f788..28f12b378f 100644
--- a/src/compiler/scala/reflect/runtime/ToolBoxes.scala
+++ b/src/compiler/scala/reflect/runtime/ToolBoxes.scala
@@ -1,6 +1,7 @@
 package scala.reflect
 package runtime
 
+import scala.tools.nsc
 import scala.tools.nsc.reporters.Reporter
 import scala.tools.nsc.reporters.StoreReporter
 import scala.tools.nsc.reporters.AbstractReporter
@@ -21,8 +22,7 @@ trait ToolBoxes extends { self: Universe =>
 
   class ToolBox(val reporter: Reporter = new StoreReporter, val options: String = "") {
 
-    class ToolBoxGlobal(settings: scala.tools.nsc.Settings, reporter: scala.tools.nsc.reporters.Reporter)
-    extends ReflectGlobal(settings, reporter) {
+    class ToolBoxGlobal(settings0: nsc.Settings, reporter0: nsc.reporters.Reporter) extends ReflectGlobal(settings0, reporter0) {
       import definitions._
 
       private val trace = scala.tools.nsc.util.trace when settings.debug.value
diff --git a/src/compiler/scala/tools/nsc/ast/NodePrinters.scala b/src/compiler/scala/tools/nsc/ast/NodePrinters.scala
index 07e864879d..acbdcd501f 100644
--- a/src/compiler/scala/tools/nsc/ast/NodePrinters.scala
+++ b/src/compiler/scala/tools/nsc/ast/NodePrinters.scala
@@ -65,7 +65,7 @@ abstract class NodePrinters {
     def showDefTreeName(tree: DefTree) = showName(tree.name)
     def showFlags(tree: MemberDef)     = flagsToString(tree.symbol.flags | tree.mods.flags)
     def showLiteral(lit: Literal)      = lit.value.escapedStringValue
-    def showTypeTree(tt: TypeTree)     = "<tpt>" + showAttributes(tt)
+    def showTypeTree(tt: TypeTree)     = "<tpt>" + emptyOrComment(showType(tt))
     def showName(name: Name)           = name match {
       case nme.EMPTY | tpnme.EMPTY => "<empty>"
       case name                    => "\"" + name + "\""
@@ -74,18 +74,18 @@ abstract class NodePrinters {
     def showSymbol(tree: Tree): String = {
       val sym = tree.symbol
       if (sym == null || sym == NoSymbol) ""
-      else " sym/owner/tpe=%s %s/%s/%s".format(sym.accurateKindString, sym.name, sym.owner, sym.tpe)
+      else sym.defString + sym.locationString
     }
     def showType(tree: Tree): String = {
       val tpe = tree.tpe
       if (tpe == null || tpe == NoType) ""
-      else " tree.tpe=" + tpe
+      else "tree.tpe=" + tpe
     }
   
     def showAttributes(tree: Tree): String = {
       if (infolevel == InfoLevel.Quiet) ""
       else {
-        try   { showSymbol(tree) + showType(tree) trim }
+        try   { List(showSymbol(tree), showType(tree)) filterNot (_ == "") mkString ", " trim }
         catch { case ex: Throwable => "sym= <error> " + ex.getMessage }
       }
     }
@@ -115,13 +115,11 @@ abstract class NodePrinters {
         case Select(_, _)             => prefix0 + "."
         case _                        => ""
       })
-      def attrs = showAttributes(tree) match {
-        case "" => ""
-        case s  => " // " + s
-      }
-      prefix + showName(tree.name) + attrs
+      prefix + showName(tree.name) + emptyOrComment(showAttributes(tree))
     }
 
+    def emptyOrComment(s: String) = if (s == "") "" else " // " + s
+
     def stringify(tree: Tree): String = {
       buf.clear()
       level = 0
@@ -141,7 +139,10 @@ abstract class NodePrinters {
       buf append "  " * level
       buf append value
       if (comment != "") {
-        buf append " // "
+        if (value != "")
+          buf append " "
+
+        buf append "// "
         buf append comment
       }
       buf append EOL
@@ -179,7 +180,7 @@ abstract class NodePrinters {
     def applyCommon(tree: Tree, fun: Tree, args: List[Tree]) {
       printMultiline(tree) {
         traverse(fun)
-        traverseList("Nil", _ + " arguments(s)")(args)
+        traverseList("Nil", "argument")(args)
       }
     }
     
@@ -191,17 +192,26 @@ abstract class NodePrinters {
       indent(body)
       println(")")
     }
+
     @inline private def indent[T](body: => T): T = {
       level += 1
       try body
       finally level -= 1
     }
 
-    def traverseList(ifEmpty: String, comment: Int => String)(trees: List[Tree]) {
+    def traverseList(ifEmpty: String, what: String)(trees: List[Tree]) {
       if (trees.isEmpty)
         println(ifEmpty)
-      else
-        printMultiline("List", comment(trees.length))(trees foreach traverse)
+      else if (trees.tail.isEmpty)
+        traverse(trees.head)
+      else {
+        printLine("", trees.length + " " + what + "s")
+        trees foreach traverse
+      }
+    }
+
+    def printSingle(tree: Tree, name: Name) {
+      println(tree.printingPrefix + "(" + showName(name) + ")" + showAttributes(tree))
     }
 
     def traverse(tree: Tree) {
@@ -210,16 +220,44 @@ abstract class NodePrinters {
         case ApplyDynamic(fun, args)    => applyCommon(tree, fun, args)
         case Apply(fun, args)           => applyCommon(tree, fun, args)
 
+        case Throw(Ident(name)) =>
+          printSingle(tree, name)
+
+        case Function(vparams, body) =>
+          printMultiline(tree) {
+            traverseList("()", "parameter")(vparams)
+            traverse(body)
+          }
+        case Try(block, catches, finalizer) =>
+          printMultiline(tree) {
+            traverse(block)
+            traverseList("{}", "case")(catches)
+            if (finalizer ne EmptyTree)
+              traverse(finalizer)
+          }
+
+        case Match(selector, cases) =>
+          printMultiline(tree) {
+            traverse(selector)
+            traverseList("", "case")(cases)
+          }
+        case CaseDef(pat, guard, body) =>
+          printMultiline(tree) {
+            traverse(pat)
+            if (guard ne EmptyTree)
+              traverse(guard)
+            traverse(body)
+          }
         case Block(stats, expr) =>
           printMultiline(tree) {
-            traverseList("{}", _ + " statement(s)")(stats)
+            traverseList("{}", "statement")(stats)
             traverse(expr)
           }
         case cd @ ClassDef(mods, name, tparams, impl) =>
           printMultiline(tree) {
             printModifiers(cd)
             println(showDefTreeName(cd))
-            traverseList("[]", _ + " type parameter(s)")(tparams)
+            traverseList("[]", "type parameter")(tparams)
             traverse(impl)
           }
         case md @ ModuleDef(mods, name, impl) =>
@@ -232,14 +270,16 @@ abstract class NodePrinters {
           printMultiline(tree) {
             printModifiers(dd)
             println(showDefTreeName(dd))
-            traverseList("[]", _ + " type parameter(s)")(tparams)
+            traverseList("[]", "type parameter")(tparams)
             vparamss match {
               case Nil        => println("Nil")
               case Nil :: Nil => println("List(Nil)")
-              case xss        =>
-                printMultiline("List", xss.length + " parameter list(s)") {
-                  xss foreach (xs => traverseList("()", _ + " parameter(s)")(xs))
-                }
+              case ps  :: Nil =>
+                printLine("", "1 parameter list")
+                ps foreach traverse
+              case pss        =>
+                printLine("", pss.length + " parameter lists")
+                pss foreach (ps => traverseList("()", "parameter")(ps))
             }
             traverse(tpt)
             traverse(rhs)
@@ -268,14 +308,14 @@ abstract class NodePrinters {
             }
             printLine(ps0 mkString ", ", "parents")
             traverse(self)
-            traverseList("{}", _ + " statements in body")(body)
+            traverseList("{}", "statement")(body)
           }
         case This(qual) =>
-          println("This(\"" + showName(qual) + "\")" + showAttributes(tree))
+          printSingle(tree, qual)
         case TypeApply(fun, args) =>
           printMultiline(tree) {
             traverse(fun)
-            traverseList("[]", _ + " type argument(s)")(args)
+            traverseList("[]", "type argument")(args)
           }
         case tt @ TypeTree() =>
           println(showTypeTree(tt))
@@ -296,7 +336,7 @@ abstract class NodePrinters {
           printMultiline(tree) {
             printModifiers(td)
             println(showDefTreeName(td))
-            traverseList("[]", _ + " type parameter(s)")(tparams)
+            traverseList("[]", "type parameter")(tparams)
             traverse(rhs)
           }
         
diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala
index 877c51ebc1..d31eafff48 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala
@@ -645,7 +645,7 @@ abstract class TypeFlowAnalysis {
       } while(!done)
 
       lastInstruction.clear()
-      for(b <- isOnPerimeter; val lastIns = b.toList.reverse find isOnWatchlist) {
+      for (b <- isOnPerimeter; lastIns = b.toList.reverse find isOnWatchlist) {
         lastInstruction += (b -> lastIns.get.asInstanceOf[opcodes.CALL_METHOD])
       }
 
diff --git a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala
index a734b2b92b..dfe9081ee5 100644
--- a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala
+++ b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala
@@ -262,7 +262,7 @@ abstract class Inliners extends SubComponent {
       def inlineWithoutTFA(inputBlocks: Traversable[BasicBlock], callsites: Function1[BasicBlock, List[opcodes.CALL_METHOD]]): Int = {
         var inlineCount = 0
         import scala.util.control.Breaks._
-        for(x <- inputBlocks; val easyCake = callsites(x); if easyCake.nonEmpty) {
+        for(x <- inputBlocks; easyCake = callsites(x); if easyCake.nonEmpty) {
           breakable {
             for(ocm <- easyCake) {
               assert(ocm.method.isEffectivelyFinal && ocm.method.owner.isEffectivelyFinal)
diff --git a/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala b/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala
index c76a04c6ba..f5335fb0f5 100644
--- a/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala
+++ b/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala
@@ -8,7 +8,7 @@ package reporters
 
 import java.io.{ BufferedReader, IOException, PrintWriter }
 import util._
-import scala.tools.util.StringOps.countElementsAsString
+import scala.tools.util.StringOps
 
 /**
  * This class implements a Reporter that displays messages on a text
@@ -40,7 +40,7 @@ class ConsoleReporter(val settings: Settings, reader: BufferedReader, writer: Pr
    *  @return         ...
    */
   private def getCountString(severity: Severity): String =
-    countElementsAsString((severity).count, label(severity))
+    StringOps.countElementsAsString((severity).count, label(severity))
 
   /** Prints the message. */
   def printMessage(msg: String) { writer.print(msg + "\n"); writer.flush() }
diff --git a/src/compiler/scala/tools/nsc/symtab/clr/TypeParser.scala b/src/compiler/scala/tools/nsc/symtab/clr/TypeParser.scala
index e11a5a4ad9..4b847fa94a 100644
--- a/src/compiler/scala/tools/nsc/symtab/clr/TypeParser.scala
+++ b/src/compiler/scala/tools/nsc/symtab/clr/TypeParser.scala
@@ -108,7 +108,7 @@ abstract class TypeParser {
     val method = new ConstructorInfo(declType, attrs, Array[MSILType]())
     val flags = Flags.JAVA
     val owner = clazz
-    val methodSym = owner.newMethod(NoPosition, nme.CONSTRUCTOR).setFlag(flags)
+    val methodSym = owner.newMethod(nme.CONSTRUCTOR, NoPosition, flags)
     val rettype = clazz.tpe
     val mtype = methodType(Array[MSILType](), rettype);
     val mInfo = mtype(methodSym)
@@ -224,14 +224,14 @@ abstract class TypeParser {
 
     if (canBeTakenAddressOf) {
       clazzBoxed.setInfo( if (ownTypeParams.isEmpty) classInfoAsInMetadata
-                          else polyType(ownTypeParams, classInfoAsInMetadata) )
+                          else genPolyType(ownTypeParams, classInfoAsInMetadata) )
       clazzBoxed.setFlag(flags)
       val rawValueInfoType = ClassInfoType(definitions.anyvalparam, instanceDefs, clazz)
       clazz.setInfo( if (ownTypeParams.isEmpty) rawValueInfoType
-                     else polyType(ownTypeParams, rawValueInfoType) )
+                     else genPolyType(ownTypeParams, rawValueInfoType) )
     } else {
       clazz.setInfo( if (ownTypeParams.isEmpty) classInfoAsInMetadata
-                     else polyType(ownTypeParams, classInfoAsInMetadata) )
+                     else genPolyType(ownTypeParams, classInfoAsInMetadata) )
     }
 
     // TODO I don't remember if statics.setInfo and staticModule.setInfo should also know about type params
@@ -284,7 +284,7 @@ abstract class TypeParser {
 	    else
 	      getCLRType(field.FieldType)
       val owner = if (field.IsStatic()) statics else clazz;
-      val sym = owner.newValue(NoPosition, name).setFlag(flags).setInfo(fieldType);
+      val sym = owner.newValue(name, NoPosition, flags).setInfo(fieldType);
         // TODO: set private within!!! -> look at typechecker/Namers.scala
         (if (field.IsStatic()) staticDefs else instanceDefs).enter(sym);
       clrTypes.fields(sym) = field;
@@ -313,7 +313,7 @@ abstract class TypeParser {
 	    val name: Name = if (gparamsLength == 0) prop.Name else nme.apply;
 	    val flags = translateAttributes(getter);
 	    val owner: Symbol = if (getter.IsStatic) statics else clazz;
-	    val methodSym = owner.newMethod(NoPosition, name).setFlag(flags)
+            val methodSym = owner.newMethod(name, NoPosition, flags)
       val mtype: Type = if (gparamsLength == 0) NullaryMethodType(propType) // .NET properties can't be polymorphic
                         else methodType(getter, getter.ReturnType)(methodSym)
         methodSym.setInfo(mtype);
@@ -337,7 +337,7 @@ abstract class TypeParser {
 	    val flags = translateAttributes(setter);
 	    val mtype = methodType(setter, definitions.UnitClass.tpe);
 	    val owner: Symbol = if (setter.IsStatic) statics else clazz;
-	    val methodSym = owner.newMethod(NoPosition, name).setFlag(flags)
+            val methodSym = owner.newMethod(name, NoPosition, flags)
         methodSym.setInfo(mtype(methodSym))
 	    methodSym.setFlag(Flags.ACCESSOR);
 	    (if (setter.IsStatic) staticDefs else instanceDefs).enter(methodSym);
@@ -424,14 +424,14 @@ abstract class TypeParser {
 
       val flags = Flags.JAVA | Flags.FINAL
       for (cmpName <- ENUM_CMP_NAMES) {
-        val enumCmp = clazz.newMethod(NoPosition, cmpName)
+        val enumCmp = clazz.newMethod(cmpName)
         val enumCmpType = JavaMethodType(enumCmp.newSyntheticValueParams(List(clazz.tpe)), definitions.BooleanClass.tpe)
         enumCmp.setFlag(flags).setInfo(enumCmpType)
         instanceDefs.enter(enumCmp)
       }
 
       for (bitLogName <- ENUM_BIT_LOG_NAMES) {
-        val enumBitLog = clazz.newMethod(NoPosition, bitLogName)
+        val enumBitLog = clazz.newMethod(bitLogName)
         val enumBitLogType = JavaMethodType(enumBitLog.newSyntheticValueParams(List(clazz.tpe)), clazz.tpe /* was classInfo, infinite typer */)
         enumBitLog.setFlag(flags).setInfo(enumBitLogType)
         instanceDefs.enter(enumBitLog)
@@ -469,7 +469,7 @@ abstract class TypeParser {
 
     val flags = translateAttributes(method);
     val owner = if (method.IsStatic()) statics else clazz;
-    val methodSym = owner.newMethod(NoPosition, getName(method)).setFlag(flags)
+    val methodSym = owner.newMethod(getName(method), NoPosition, flags)
     /* START CLR generics (snippet 3) */
     val newMethodTParams = populateMethodTParams(method, methodSym)
     /* END CLR generics (snippet 3) */
@@ -480,7 +480,7 @@ abstract class TypeParser {
     val mtype = methodType(method, rettype);
     if (mtype == null) return;
 /* START CLR generics (snippet 4) */
-    val mInfo = if (method.IsGeneric) polyType(newMethodTParams, mtype(methodSym))
+    val mInfo = if (method.IsGeneric) genPolyType(newMethodTParams, mtype(methodSym))
                 else mtype(methodSym)
 /* END CLR generics (snippet 4) */
 /* START CLR non-generics (snippet 4)
@@ -500,7 +500,7 @@ abstract class TypeParser {
   }
 
   private def createMethod(name: Name, flags: Long, mtype: Symbol => Type, method: MethodInfo, statik: Boolean): Symbol = {
-    val methodSym: Symbol = (if (statik)  statics else clazz).newMethod(NoPosition, name)
+    val methodSym: Symbol = (if (statik)  statics else clazz).newMethod(name)
     methodSym.setFlag(flags).setInfo(mtype(methodSym))
     (if (statik) staticDefs else instanceDefs).enter(methodSym)
     if (method != null)
diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
index 03bef83a90..e54e0289bb 100644
--- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala
+++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
@@ -168,7 +168,7 @@ abstract class UnCurry extends InfoTransform
     private def nonLocalReturnTry(body: Tree, key: Symbol, meth: Symbol) = {
       localTyper typed {
         val extpe   = nonLocalReturnExceptionType(meth.tpe.finalResultType)
-        val ex      = meth.newValue(body.pos, nme.ex) setInfo extpe
+        val ex      = meth.newValue(nme.ex, body.pos) setInfo extpe
         val pat     = gen.mkBindForCase(ex, NonLocalReturnControlClass, List(meth.tpe.finalResultType))
         val rhs = (
           IF   ((ex DOT nme.key)() OBJ_EQ Ident(key))
diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
index ed9fee986f..e37f5784c9 100644
--- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
@@ -684,7 +684,7 @@ trait ContextErrors {
         def errMsg = {
           val location = if (sym.isClassConstructor) owner0 else pre.widen
 
-          underlying(sym).fullLocationString + " cannot be accessed in " +
+          underlyingSymbol(sym).fullLocationString + " cannot be accessed in " +
           location + explanation
         }
         NormalTypeError(tree, errMsg, ErrorKinds.Access)
diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
index ec42d251ff..fa19f380fd 100644
--- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
@@ -266,7 +266,7 @@ abstract class RefChecks extends InfoTransform with reflect.internal.transform.R
         (if (showLocation)
           sym1.locationString +
           (if (sym1.isAliasType) ", which equals "+self.memberInfo(sym1)
-           else if (sym1.isAbstractType) " with bounds "+self.memberInfo(sym1)
+           else if (sym1.isAbstractType) " with bounds"+self.memberInfo(sym1)
            else if (sym1.isTerm) " of type "+self.memberInfo(sym1)
            else "")
          else "")
diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
index 2f4eff30d2..da87d38ab0 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
@@ -136,7 +136,7 @@ trait SyntheticMethods extends ast.TreeDSL {
      *  where that is the given methods first parameter.
      */
     def thatTest(eqmeth: Symbol): Tree =
-      gen.mkIsInstanceOf(Ident(eqmeth.firstParam), typeCaseType(clazz), true, false)
+      gen.mkIsInstanceOf(Ident(eqmeth.firstParam), classExistentialType(clazz), true, false)
 
     /** (that.asInstanceOf[this.C])
      *  where that is the given methods first parameter.
diff --git a/src/library/scala/Specializable.scala b/src/library/scala/Specializable.scala
index 67126b3069..d5e22195d2 100644
--- a/src/library/scala/Specializable.scala
+++ b/src/library/scala/Specializable.scala
@@ -20,10 +20,10 @@ object Specializable {
   // Smuggle a list of types by way of a tuple upon which Group is parameterized.
   class Group[T >: Null](value: T) extends SpecializedGroup { }
 
-  final val Primitives  = new Group(Byte, Short, Int, Long, Char, Float, Double, Boolean, Unit)
-  final val Everything  = new Group(Byte, Short, Int, Long, Char, Float, Double, Boolean, Unit, AnyRef)
-  final val Bits32AndUp = new Group(Int, Long, Float, Double)
-  final val Integral    = new Group(Byte, Short, Int, Long, Char)
-  final val AllNumeric  = new Group(Byte, Short, Int, Long, Char, Float, Double)
-  final val BestOfBreed = new Group(Int, Double, Boolean, Unit, AnyRef)
+  final val Primitives  = new Group((Byte, Short, Int, Long, Char, Float, Double, Boolean, Unit))
+  final val Everything  = new Group((Byte, Short, Int, Long, Char, Float, Double, Boolean, Unit, AnyRef))
+  final val Bits32AndUp = new Group((Int, Long, Float, Double))
+  final val Integral    = new Group((Byte, Short, Int, Long, Char))
+  final val AllNumeric  = new Group((Byte, Short, Int, Long, Char, Float, Double))
+  final val BestOfBreed = new Group((Int, Double, Boolean, Unit, AnyRef))
 }
diff --git a/src/library/scala/collection/GenTraversableOnce.scala b/src/library/scala/collection/GenTraversableOnce.scala
index f18e2ab6bb..019d3d0785 100644
--- a/src/library/scala/collection/GenTraversableOnce.scala
+++ b/src/library/scala/collection/GenTraversableOnce.scala
@@ -124,7 +124,7 @@ trait GenTraversableOnce[+A] extends Any {
    *      scala> val b = (a /:\ 5)(_+_)
    *      b: Int = 15
    * }}}*/
-  @deprecated("use fold instead")
+  @deprecated("use fold instead", "2.10.0")
   def /:\[A1 >: A](z: A1)(op: (A1, A1) => A1): A1 = fold(z)(op)
 
   /** Applies a binary operator to a start value and all elements of this $coll,
diff --git a/src/library/scala/collection/mutable/ConcurrentTrieMap.scala b/src/library/scala/collection/mutable/ConcurrentTrieMap.scala
index 1a44c8e423..cfe1b1950d 100644
--- a/src/library/scala/collection/mutable/ConcurrentTrieMap.scala
+++ b/src/library/scala/collection/mutable/ConcurrentTrieMap.scala
@@ -1027,7 +1027,7 @@ private[collection] class ConcurrentTrieMapIterator[K, V](var level: Int, privat
     Seq(this)
   }
 
-  def printDebug {
+  def printDebug() {
     println("ctrie iterator")
     println(stackpos.mkString(","))
     println("depth: " + depth)
diff --git a/src/library/scala/concurrent/DelayedLazyVal.scala b/src/library/scala/concurrent/DelayedLazyVal.scala
index a17153bad5..96a66d83b6 100644
--- a/src/library/scala/concurrent/DelayedLazyVal.scala
+++ b/src/library/scala/concurrent/DelayedLazyVal.scala
@@ -40,9 +40,8 @@ class DelayedLazyVal[T](f: () => T, body: => Unit) {
   def apply(): T = if (isDone) complete else f()
 
   // TODO replace with scala.concurrent.future { ... }
-  ops.future {
+  future {
     body
     _isDone = true
   }
-
 }
diff --git a/src/library/scala/reflect/api/Trees.scala b/src/library/scala/reflect/api/Trees.scala
index a8276dc853..466c380cef 100644
--- a/src/library/scala/reflect/api/Trees.scala
+++ b/src/library/scala/reflect/api/Trees.scala
@@ -165,11 +165,12 @@ trait Trees { self: Universe =>
     def foreach(f: Tree => Unit) { new ForeachTreeTraverser(f).traverse(this) }
 
     /** Find all subtrees matching predicate `p` */
-    def filter(f: Tree => Boolean): List[Tree] = {
+    def withFilter(f: Tree => Boolean): List[Tree] = {
       val ft = new FilterTreeTraverser(f)
       ft.traverse(this)
       ft.hits.toList
     }
+    def filter(f: Tree => Boolean): List[Tree] = withFilter(f)
 
     /** Returns optionally first tree (in a preorder traversal) which satisfies predicate `p`,
      *  or None if none exists.
diff --git a/src/library/scala/xml/Elem.scala b/src/library/scala/xml/Elem.scala
index cc244a5b88..5b6b9f2bb9 100755
--- a/src/library/scala/xml/Elem.scala
+++ b/src/library/scala/xml/Elem.scala
@@ -23,12 +23,12 @@ object Elem {
    * @deprecated This factory method is retained for backward compatibility; please use the other one, with which you
    *             can specify your own preference for minimizeEmpty.
    */
-  @deprecated
-  def apply(prefix: String,label: String, attributes: MetaData, scope: NamespaceBinding, child: Node*): Elem =
+  @deprecated("Use the other apply method in this object", "2.10.0")
+  def apply(prefix: String, label: String, attributes: MetaData, scope: NamespaceBinding, child: Node*): Elem =
     apply(prefix, label, attributes, scope, child.isEmpty, child: _*)
 
-  def apply(prefix: String,label: String, attributes: MetaData, scope: NamespaceBinding, minimizeEmpty: Boolean, child: Node*): Elem =
-    new Elem(prefix,label,attributes,scope, minimizeEmpty, child:_*)
+  def apply(prefix: String, label: String, attributes: MetaData, scope: NamespaceBinding, minimizeEmpty: Boolean, child: Node*): Elem =
+    new Elem(prefix, label, attributes, scope, minimizeEmpty, child: _*)
 
   def unapplySeq(n: Node) = n match {
     case _: SpecialNode | _: Group  => None
diff --git a/src/library/scala/xml/XML.scala b/src/library/scala/xml/XML.scala
index 4beba91899..f6955c6612 100755
--- a/src/library/scala/xml/XML.scala
+++ b/src/library/scala/xml/XML.scala
@@ -15,8 +15,7 @@ import java.io.{ InputStream, Reader, StringReader, Writer }
 import java.nio.channels.Channels
 import scala.util.control.Exception.ultimately
 
-object Source
-{
+object Source {
   def fromFile(file: File)              = new InputSource(new FileInputStream(file))
   def fromFile(fd: FileDescriptor)      = new InputSource(new FileInputStream(fd))
   def fromFile(name: String)            = new InputSource(new FileInputStream(name))
@@ -31,13 +30,18 @@ object Source
  * Governs how empty elements (i.e. those without child elements) should be serialized.
  */
 object MinimizeMode extends Enumeration {
-  /** Minimize empty tags if they were originally empty when parsed, or if they were constructed with [[scala.xml.Elem]]`#minimizeEmpty` == true */
+  /** Minimize empty tags if they were originally empty when parsed, or if they were constructed
+   *  with [[scala.xml.Elem]]`#minimizeEmpty` == true
+   */
   val Default = Value
 
-  /** Always minimize empty tags.  Note that this may be problematic for XHTML, in which case [[scala.xml.Xhtml]]`#toXhtml` should be used instead. */
+  /** Always minimize empty tags.  Note that this may be problematic for XHTML, in which
+   * case [[scala.xml.Xhtml]]`#toXhtml` should be used instead.
+   */
   val Always = Value
 
-  /** Never minimize empty tags. */
+  /** Never minimize empty tags.
+   */
   val Never = Value
 }
 
@@ -50,8 +54,7 @@ import Source._
  *  @author  Burak Emir
  *  @version 1.0, 25/04/2005
  */
-object XML extends XMLLoader[Elem]
-{
+object XML extends XMLLoader[Elem] {
   val xml       = "xml"
   val xmlns     = "xmlns"
   val namespace = "http://www.w3.org/XML/1998/namespace"
diff --git a/test/files/neg/t1364.check b/test/files/neg/t1364.check
index 78375333c2..cb8803abdc 100644
--- a/test/files/neg/t1364.check
+++ b/test/files/neg/t1364.check
@@ -1,4 +1,4 @@
-t1364.scala:9: error: overriding type T in trait A with bounds >: Nothing <: AnyRef{type S[-U]};
+t1364.scala:9: error: overriding type T in trait A with bounds <: AnyRef{type S[-U]};
  type T has incompatible type
  type T = { type S[U] = U }
       ^
diff --git a/test/files/neg/t1477.check b/test/files/neg/t1477.check
index e497637857..72bffa3270 100644
--- a/test/files/neg/t1477.check
+++ b/test/files/neg/t1477.check
@@ -1,4 +1,4 @@
-t1477.scala:13: error: overriding type V in trait C with bounds >: Nothing <: Middle.this.D;
+t1477.scala:13: error: overriding type V in trait C with bounds <: Middle.this.D;
  type V is a volatile type; cannot override a type with non-volatile upper bound
     type V <: (D with U)
          ^
diff --git a/test/files/neg/t2070.check b/test/files/neg/t2070.check
index bd049409a8..ef1d08f7b7 100644
--- a/test/files/neg/t2070.check
+++ b/test/files/neg/t2070.check
@@ -1,5 +1,6 @@
 t2070.scala:8: error: The kind of trait T does not conform to the expected kind of type T[X] in trait A.
-t2070.B.T's type parameters do not match type T's expected parameters: type X (in object B) has one type parameter, but type X (in trait A) has none
+t2070.B.T's type parameters do not match type T's expected parameters:
+type X (in object B) has one type parameter, but type X (in trait A) has none
     trait T[X[_]]
           ^
 one error found
diff --git a/test/files/neg/t4044.check b/test/files/neg/t4044.check
index 75dcf63bfe..41a04f69b9 100644
--- a/test/files/neg/t4044.check
+++ b/test/files/neg/t4044.check
@@ -2,15 +2,18 @@ t4044.scala:9: error: AnyRef takes no type parameters, expected: one
   M[AnyRef] // error, (AnyRef :: *) not kind-conformant to (N :: * -> * -> *)
     ^
 t4044.scala:9: error: kinds of the type arguments (<error>) do not conform to the expected kinds of the type parameters (type N).
-<error>'s type parameters do not match type N's expected parameters: <none> has no type parameters, but type N has one
+<error>'s type parameters do not match type N's expected parameters:
+<none> has no type parameters, but type N has one
   M[AnyRef] // error, (AnyRef :: *) not kind-conformant to (N :: * -> * -> *)
    ^
 t4044.scala:11: error: kinds of the type arguments (Test.A) do not conform to the expected kinds of the type parameters (type N).
-Test.A's type parameters do not match type N's expected parameters: type _ has no type parameters, but type O has one
+Test.A's type parameters do not match type N's expected parameters:
+type _ has no type parameters, but type O has one
   M[A] // error, (A :: (* -> *) not kind-conformant to (N :: * -> * -> *)
    ^
 t4044.scala:15: error: kinds of the type arguments (Test.C) do not conform to the expected kinds of the type parameters (type N).
-Test.C's type parameters do not match type N's expected parameters: type _ has one type parameter, but type _ has none
+Test.C's type parameters do not match type N's expected parameters:
+type _ has one type parameter, but type _ has none
   M[C] // error, (C :: (* -> * -> * -> *) not kind-conformant to (N :: * -> * -> *)
    ^
 four errors found
diff --git a/test/files/neg/t5152.check b/test/files/neg/t5152.check
index 80e0141b64..fd510dbae0 100644
--- a/test/files/neg/t5152.check
+++ b/test/files/neg/t5152.check
@@ -1,9 +1,11 @@
 t5152.scala:7: error: kinds of the type arguments (Test.B) do not conform to the expected kinds of the type parameters (type E) in class A.
-Test.B's type parameters do not match type E's expected parameters: type E has one type parameter, but type _ has none
+Test.B's type parameters do not match type E's expected parameters:
+type E has one type parameter, but type _ has none
   class B[E[_]] extends A[B] { }  // B is depth 2 but A requires 1
                         ^
 t5152.scala:11: error: kinds of the type arguments (Test.B1) do not conform to the expected kinds of the type parameters (type E) in class A1.
-Test.B1's type parameters do not match type E's expected parameters: type _ has no type parameters, but type G has one
+Test.B1's type parameters do not match type E's expected parameters:
+type _ has no type parameters, but type G has one
   class B1[E[_]] extends A1[B1]   // B1 is depth 2 but A1 requires 3
                          ^
 two errors found
diff --git a/test/files/neg/t708.check b/test/files/neg/t708.check
index 15a9c9ed93..4983aab613 100644
--- a/test/files/neg/t708.check
+++ b/test/files/neg/t708.check
@@ -1,4 +1,4 @@
-t708.scala:8: error: overriding type S in trait X with bounds >: Nothing <: A.this.T;
+t708.scala:8: error: overriding type S in trait X with bounds <: A.this.T;
  type S has incompatible type
     override private[A] type S = Any;
                              ^
diff --git a/test/files/neg/t742.check b/test/files/neg/t742.check
index f587948ef1..d355715442 100644
--- a/test/files/neg/t742.check
+++ b/test/files/neg/t742.check
@@ -1,5 +1,6 @@
 t742.scala:5: error: kinds of the type arguments (Crash._1,Crash._2,Any) do not conform to the expected kinds of the type parameters (type m,type n,type z).
-Crash._1's type parameters do not match type m's expected parameters: type s1 has one type parameter, but type n has two
+Crash._1's type parameters do not match type m's expected parameters:
+type s1 has one type parameter, but type n has two
     type p = mul[_1, _2, Any]  // mul[_1, _1, Any] needs -Yrecursion
              ^
 one error found
diff --git a/test/files/neg/tcpoly_override.check b/test/files/neg/tcpoly_override.check
index 95529329e8..dbc3ff9461 100644
--- a/test/files/neg/tcpoly_override.check
+++ b/test/files/neg/tcpoly_override.check
@@ -1,5 +1,6 @@
 tcpoly_override.scala:9: error: The kind of type T does not conform to the expected kind of type T[_] in trait A.
-C.this.T's type parameters do not match type T's expected parameters: type T (in class C) has no type parameters, but type T (in trait A) has one
+C.this.T's type parameters do not match type T's expected parameters:
+type T (in class C) has no type parameters, but type T (in trait A) has one
  type T = B // This compiles well (@M: ... but it shouldn't)
       ^
 one error found
diff --git a/test/files/neg/tcpoly_typealias.check b/test/files/neg/tcpoly_typealias.check
index 670add2c04..4beac0e440 100644
--- a/test/files/neg/tcpoly_typealias.check
+++ b/test/files/neg/tcpoly_typealias.check
@@ -1,13 +1,16 @@
 tcpoly_typealias.scala:37: error: The kind of type m does not conform to the expected kind of type m[+x] in trait A.
-BInv.this.m's type parameters do not match type m's expected parameters: type x (in trait BInv) is invariant, but type x (in trait A) is declared covariant
+BInv.this.m's type parameters do not match type m's expected parameters:
+type x (in trait BInv) is invariant, but type x (in trait A) is declared covariant
   type m[x] = FooCov[x] // error: invariant x in alias def
        ^
 tcpoly_typealias.scala:41: error: The kind of type m does not conform to the expected kind of type m[+x] in trait A.
-BCon.this.m's type parameters do not match type m's expected parameters: type x (in trait BCon) is contravariant, but type x (in trait A) is declared covariant
+BCon.this.m's type parameters do not match type m's expected parameters:
+type x (in trait BCon) is contravariant, but type x (in trait A) is declared covariant
   type m[-x] = FooCon[x] // error: contravariant x
        ^
 tcpoly_typealias.scala:45: error: The kind of type m does not conform to the expected kind of type m[+x] in trait A.
-BBound.this.m's type parameters do not match type m's expected parameters: type x (in trait BBound)'s bounds >: Nothing <: String are stricter than type x (in trait A)'s declared bounds >: Nothing <: Any
+BBound.this.m's type parameters do not match type m's expected parameters:
+type x (in trait BBound)'s bounds <: String are stricter than type x (in trait A)'s declared bounds >: Nothing <: Any
   type m[+x <: String] = FooBound[x] // error: x with stricter bound
        ^
 three errors found
diff --git a/test/files/neg/tcpoly_variance_enforce.check b/test/files/neg/tcpoly_variance_enforce.check
index 44b5b2c15c..3299cc3435 100644
--- a/test/files/neg/tcpoly_variance_enforce.check
+++ b/test/files/neg/tcpoly_variance_enforce.check
@@ -1,45 +1,57 @@
 tcpoly_variance_enforce.scala:15: error: kinds of the type arguments (FooInvar) do not conform to the expected kinds of the type parameters (type m) in trait coll.
-FooInvar's type parameters do not match type m's expected parameters: type x (in class FooInvar) is invariant, but type x is declared covariant
+FooInvar's type parameters do not match type m's expected parameters:
+type x (in class FooInvar) is invariant, but type x is declared covariant
 object fcollinv extends coll[FooInvar]      // error
                         ^
 tcpoly_variance_enforce.scala:16: error: kinds of the type arguments (FooContra) do not conform to the expected kinds of the type parameters (type m) in trait coll.
-FooContra's type parameters do not match type m's expected parameters: type x (in class FooContra) is contravariant, but type x is declared covariant
+FooContra's type parameters do not match type m's expected parameters:
+type x (in class FooContra) is contravariant, but type x is declared covariant
 object fcollcon extends coll[FooContra]     // error
                         ^
 tcpoly_variance_enforce.scala:17: error: kinds of the type arguments (FooString) do not conform to the expected kinds of the type parameters (type m) in trait coll.
-FooString's type parameters do not match type m's expected parameters: type x (in class FooString)'s bounds >: Nothing <: String are stricter than type x's declared bounds >: Nothing <: Any
+FooString's type parameters do not match type m's expected parameters:
+type x (in class FooString)'s bounds <: String are stricter than type x's declared bounds >: Nothing <: Any
 object fcollwb extends coll[FooString]      // error
                        ^
 tcpoly_variance_enforce.scala:19: error: kinds of the type arguments (FooCov) do not conform to the expected kinds of the type parameters (type m) in trait coll2.
-FooCov's type parameters do not match type m's expected parameters: type x (in class FooCov) is covariant, but type x is declared contravariant
+FooCov's type parameters do not match type m's expected parameters:
+type x (in class FooCov) is covariant, but type x is declared contravariant
 object fcoll2ok extends coll2[FooCov]       // error
                         ^
 tcpoly_variance_enforce.scala:20: error: kinds of the type arguments (FooInvar) do not conform to the expected kinds of the type parameters (type m) in trait coll2.
-FooInvar's type parameters do not match type m's expected parameters: type x (in class FooInvar) is invariant, but type x is declared contravariant
+FooInvar's type parameters do not match type m's expected parameters:
+type x (in class FooInvar) is invariant, but type x is declared contravariant
 object fcoll2inv extends coll2[FooInvar]    // error
                          ^
 tcpoly_variance_enforce.scala:22: error: kinds of the type arguments (FooString) do not conform to the expected kinds of the type parameters (type m) in trait coll2.
-FooString's type parameters do not match type m's expected parameters: type x (in class FooString) is covariant, but type x is declared contravarianttype x (in class FooString)'s bounds >: Nothing <: String are stricter than type x's declared bounds >: Nothing <: Any
+FooString's type parameters do not match type m's expected parameters:
+type x (in class FooString) is covariant, but type x is declared contravariant
+type x (in class FooString)'s bounds <: String are stricter than type x's declared bounds >: Nothing <: Any
 object fcoll2wb extends coll2[FooString]      // error
                         ^
 tcpoly_variance_enforce.scala:27: error: kinds of the type arguments (FooString) do not conform to the expected kinds of the type parameters (type m) in trait coll3.
-FooString's type parameters do not match type m's expected parameters: type x (in class FooString)'s bounds >: Nothing <: String are stricter than type x's declared bounds >: Nothing <: Any
+FooString's type parameters do not match type m's expected parameters:
+type x (in class FooString)'s bounds <: String are stricter than type x's declared bounds >: Nothing <: Any
 object fcoll3wb extends  coll3[FooString]   // error
                          ^
 tcpoly_variance_enforce.scala:30: error: kinds of the type arguments (FooString,Int) do not conform to the expected kinds of the type parameters (type m,type y) in trait coll4.
-FooString's type parameters do not match type m's expected parameters: type x (in class FooString)'s bounds >: Nothing <: String are stricter than type x's declared bounds >: Nothing <: y
+FooString's type parameters do not match type m's expected parameters:
+type x (in class FooString)'s bounds <: String are stricter than type x's declared bounds <: y
 object fcoll4_1 extends  coll4[FooString, Int] // error
                          ^
 tcpoly_variance_enforce.scala:31: error: kinds of the type arguments (FooString,Any) do not conform to the expected kinds of the type parameters (type m,type y) in trait coll4.
-FooString's type parameters do not match type m's expected parameters: type x (in class FooString)'s bounds >: Nothing <: String are stricter than type x's declared bounds >: Nothing <: y
+FooString's type parameters do not match type m's expected parameters:
+type x (in class FooString)'s bounds <: String are stricter than type x's declared bounds <: y
 object fcoll4_2 extends  coll4[FooString, Any] // error
                          ^
 tcpoly_variance_enforce.scala:37: error: kinds of the type arguments (FooInvar) do not conform to the expected kinds of the type parameters (type m) in trait coll.
-FooInvar's type parameters do not match type m's expected parameters: type x (in class FooInvar) is invariant, but type x is declared covariant
+FooInvar's type parameters do not match type m's expected parameters:
+type x (in class FooInvar) is invariant, but type x is declared covariant
   def x: coll[FooInvar] = sys.error("foo") // error
          ^
 tcpoly_variance_enforce.scala:38: error: kinds of the type arguments (FooContra) do not conform to the expected kinds of the type parameters (type m) in trait coll.
-FooContra's type parameters do not match type m's expected parameters: type x (in class FooContra) is contravariant, but type x is declared covariant
+FooContra's type parameters do not match type m's expected parameters:
+type x (in class FooContra) is contravariant, but type x is declared covariant
   def y: coll[FooContra] = sys.error("foo") // error
          ^
 11 errors found
diff --git a/test/files/run/existentials-in-compiler.check b/test/files/run/existentials-in-compiler.check
index c8040a4cb1..83e3cdf435 100644
--- a/test/files/run/existentials-in-compiler.check
+++ b/test/files/run/existentials-in-compiler.check
@@ -1,156 +1,156 @@
-abstract trait Bippy[A <: AnyRef,B] extends Object
+abstract trait Bippy[A <: AnyRef, B] extends Object
     extest.Bippy[_ <: AnyRef, _]
 
-abstract trait BippyBud[A <: AnyRef,B,C <: List[A]] extends Object
+abstract trait BippyBud[A <: AnyRef, B, C <: List[A]] extends Object
     extest.BippyBud[A,B,C] forSome { A <: AnyRef; B; C <: List[A] }
 
-abstract trait BippyLike[A <: AnyRef,B <: List[A],This <: extest.BippyLike[A,B,This] with extest.Bippy[A,B]] extends Object
+abstract trait BippyLike[A <: AnyRef, B <: List[A], This <: extest.BippyLike[A,B,This] with extest.Bippy[A,B]] extends Object
     extest.BippyLike[A,B,This] forSome { A <: AnyRef; B <: List[A]; This <: extest.BippyLike[A,B,This] with extest.Bippy[A,B] }
 
-abstract trait Contra[-A >: AnyRef,-B] extends Object
+abstract trait Contra[-A >: AnyRef, -B] extends Object
     extest.Contra[_ >: AnyRef, _]
 
-abstract trait ContraLike[-A >: AnyRef,-B >: List[A]] extends Object
+abstract trait ContraLike[-A >: AnyRef, -B >: List[A]] extends Object
     extest.ContraLike[A,B] forSome { -A >: AnyRef; -B >: List[A] }
 
-abstract trait Cov01[+A <: AnyRef,+B] extends Object
+abstract trait Cov01[+A <: AnyRef, +B] extends Object
     extest.Cov01[_ <: AnyRef, _]
 
-abstract trait Cov02[+A <: AnyRef,B] extends Object
+abstract trait Cov02[+A <: AnyRef, B] extends Object
     extest.Cov02[_ <: AnyRef, _]
 
-abstract trait Cov03[+A <: AnyRef,-B] extends Object
+abstract trait Cov03[+A <: AnyRef, -B] extends Object
     extest.Cov03[_ <: AnyRef, _]
 
-abstract trait Cov04[A <: AnyRef,+B] extends Object
+abstract trait Cov04[A <: AnyRef, +B] extends Object
     extest.Cov04[_ <: AnyRef, _]
 
-abstract trait Cov05[A <: AnyRef,B] extends Object
+abstract trait Cov05[A <: AnyRef, B] extends Object
     extest.Cov05[_ <: AnyRef, _]
 
-abstract trait Cov06[A <: AnyRef,-B] extends Object
+abstract trait Cov06[A <: AnyRef, -B] extends Object
     extest.Cov06[_ <: AnyRef, _]
 
-abstract trait Cov07[-A <: AnyRef,+B] extends Object
+abstract trait Cov07[-A <: AnyRef, +B] extends Object
     extest.Cov07[_ <: AnyRef, _]
 
-abstract trait Cov08[-A <: AnyRef,B] extends Object
+abstract trait Cov08[-A <: AnyRef, B] extends Object
     extest.Cov08[_ <: AnyRef, _]
 
-abstract trait Cov09[-A <: AnyRef,-B] extends Object
+abstract trait Cov09[-A <: AnyRef, -B] extends Object
     extest.Cov09[_ <: AnyRef, _]
 
-abstract trait Cov11[+A <: AnyRef,+B <: List[_]] extends Object
+abstract trait Cov11[+A <: AnyRef, +B <: List[_]] extends Object
     extest.Cov11[_ <: AnyRef, _ <: List[_]]
 
-abstract trait Cov12[+A <: AnyRef,B <: List[_]] extends Object
+abstract trait Cov12[+A <: AnyRef, B <: List[_]] extends Object
     extest.Cov12[_ <: AnyRef, _ <: List[_]]
 
-abstract trait Cov13[+A <: AnyRef,-B <: List[_]] extends Object
+abstract trait Cov13[+A <: AnyRef, -B <: List[_]] extends Object
     extest.Cov13[_ <: AnyRef, _ <: List[_]]
 
-abstract trait Cov14[A <: AnyRef,+B <: List[_]] extends Object
+abstract trait Cov14[A <: AnyRef, +B <: List[_]] extends Object
     extest.Cov14[_ <: AnyRef, _ <: List[_]]
 
-abstract trait Cov15[A <: AnyRef,B <: List[_]] extends Object
+abstract trait Cov15[A <: AnyRef, B <: List[_]] extends Object
     extest.Cov15[_ <: AnyRef, _ <: List[_]]
 
-abstract trait Cov16[A <: AnyRef,-B <: List[_]] extends Object
+abstract trait Cov16[A <: AnyRef, -B <: List[_]] extends Object
     extest.Cov16[_ <: AnyRef, _ <: List[_]]
 
-abstract trait Cov17[-A <: AnyRef,+B <: List[_]] extends Object
+abstract trait Cov17[-A <: AnyRef, +B <: List[_]] extends Object
     extest.Cov17[_ <: AnyRef, _ <: List[_]]
 
-abstract trait Cov18[-A <: AnyRef,B <: List[_]] extends Object
+abstract trait Cov18[-A <: AnyRef, B <: List[_]] extends Object
     extest.Cov18[_ <: AnyRef, _ <: List[_]]
 
-abstract trait Cov19[-A <: AnyRef,-B <: List[_]] extends Object
+abstract trait Cov19[-A <: AnyRef, -B <: List[_]] extends Object
     extest.Cov19[_ <: AnyRef, _ <: List[_]]
 
-abstract trait Cov21[+A,+B] extends Object
+abstract trait Cov21[+A, +B] extends Object
     extest.Cov21[_, _]
 
-abstract trait Cov22[+A,B] extends Object
+abstract trait Cov22[+A, B] extends Object
     extest.Cov22[_, _]
 
-abstract trait Cov23[+A,-B] extends Object
+abstract trait Cov23[+A, -B] extends Object
     extest.Cov23[_, _]
 
-abstract trait Cov24[A,+B] extends Object
+abstract trait Cov24[A, +B] extends Object
     extest.Cov24[_, _]
 
-abstract trait Cov25[A,B] extends Object
+abstract trait Cov25[A, B] extends Object
     extest.Cov25[_, _]
 
-abstract trait Cov26[A,-B] extends Object
+abstract trait Cov26[A, -B] extends Object
     extest.Cov26[_, _]
 
-abstract trait Cov27[-A,+B] extends Object
+abstract trait Cov27[-A, +B] extends Object
     extest.Cov27[_, _]
 
-abstract trait Cov28[-A,B] extends Object
+abstract trait Cov28[-A, B] extends Object
     extest.Cov28[_, _]
 
-abstract trait Cov29[-A,-B] extends Object
+abstract trait Cov29[-A, -B] extends Object
     extest.Cov29[_, _]
 
-abstract trait Cov31[+A,+B,C <: (A, B)] extends Object
+abstract trait Cov31[+A, +B, C <: (A, B)] extends Object
     extest.Cov31[A,B,C] forSome { +A; +B; C <: (A, B) }
 
-abstract trait Cov32[+A,B,C <: (A, B)] extends Object
+abstract trait Cov32[+A, B, C <: (A, B)] extends Object
     extest.Cov32[A,B,C] forSome { +A; B; C <: (A, B) }
 
-abstract trait Cov33[+A,-B,C <: (A, _$10) forSome { type _$10 }] extends Object
+abstract trait Cov33[+A, -B, C <: (A, _$10) forSome { type _$10 }] extends Object
     extest.Cov33[A,B,C] forSome { +A; -B; C <: (A, _$10) forSome { type _$10 } }
 
-abstract trait Cov34[A,+B,C <: (A, B)] extends Object
+abstract trait Cov34[A, +B, C <: (A, B)] extends Object
     extest.Cov34[A,B,C] forSome { A; +B; C <: (A, B) }
 
-abstract trait Cov35[A,B,C <: (A, B)] extends Object
+abstract trait Cov35[A, B, C <: (A, B)] extends Object
     extest.Cov35[A,B,C] forSome { A; B; C <: (A, B) }
 
-abstract trait Cov36[A,-B,C <: (A, _$11) forSome { type _$11 }] extends Object
+abstract trait Cov36[A, -B, C <: (A, _$11) forSome { type _$11 }] extends Object
     extest.Cov36[A,B,C] forSome { A; -B; C <: (A, _$11) forSome { type _$11 } }
 
-abstract trait Cov37[-A,+B,C <: (_$12, B) forSome { type _$12 }] extends Object
+abstract trait Cov37[-A, +B, C <: (_$12, B) forSome { type _$12 }] extends Object
     extest.Cov37[A,B,C] forSome { -A; +B; C <: (_$12, B) forSome { type _$12 } }
 
-abstract trait Cov38[-A,B,C <: (_$13, B) forSome { type _$13 }] extends Object
+abstract trait Cov38[-A, B, C <: (_$13, B) forSome { type _$13 }] extends Object
     extest.Cov38[A,B,C] forSome { -A; B; C <: (_$13, B) forSome { type _$13 } }
 
-abstract trait Cov39[-A,-B,C <: Tuple2[_, _]] extends Object
+abstract trait Cov39[-A, -B, C <: Tuple2[_, _]] extends Object
     extest.Cov39[_, _, _ <: Tuple2[_, _]]
 
-abstract trait Cov41[+A >: Null,+B] extends Object
+abstract trait Cov41[+A >: Null, +B] extends Object
     extest.Cov41[_ >: Null, _]
 
-abstract trait Cov42[+A >: Null,B] extends Object
+abstract trait Cov42[+A >: Null, B] extends Object
     extest.Cov42[_ >: Null, _]
 
-abstract trait Cov43[+A >: Null,-B] extends Object
+abstract trait Cov43[+A >: Null, -B] extends Object
     extest.Cov43[_ >: Null, _]
 
-abstract trait Cov44[A >: Null,+B] extends Object
+abstract trait Cov44[A >: Null, +B] extends Object
     extest.Cov44[_ >: Null, _]
 
-abstract trait Cov45[A >: Null,B] extends Object
+abstract trait Cov45[A >: Null, B] extends Object
     extest.Cov45[_ >: Null, _]
 
-abstract trait Cov46[A >: Null,-B] extends Object
+abstract trait Cov46[A >: Null, -B] extends Object
     extest.Cov46[_ >: Null, _]
 
-abstract trait Cov47[-A >: Null,+B] extends Object
+abstract trait Cov47[-A >: Null, +B] extends Object
     extest.Cov47[_ >: Null, _]
 
-abstract trait Cov48[-A >: Null,B] extends Object
+abstract trait Cov48[-A >: Null, B] extends Object
     extest.Cov48[_ >: Null, _]
 
-abstract trait Cov49[-A >: Null,-B] extends Object
+abstract trait Cov49[-A >: Null, -B] extends Object
     extest.Cov49[_ >: Null, _]
 
-abstract trait Covariant[+A <: AnyRef,+B] extends Object
+abstract trait Covariant[+A <: AnyRef, +B] extends Object
     extest.Covariant[_ <: AnyRef, _]
 
-abstract trait CovariantLike[+A <: AnyRef,+B <: List[A],+This <: extest.CovariantLike[A,B,This] with extest.Covariant[A,B]] extends Object
+abstract trait CovariantLike[+A <: AnyRef, +B <: List[A], +This <: extest.CovariantLike[A,B,This] with extest.Covariant[A,B]] extends Object
     extest.CovariantLike[A,B,This] forSome { +A <: AnyRef; +B <: List[A]; +This <: extest.CovariantLike[A,B,This] with extest.Covariant[A,B] }
 
diff --git a/test/files/run/reify_ann1a.check b/test/files/run/reify_ann1a.check
index 97d4848a49..66dce778a8 100644
--- a/test/files/run/reify_ann1a.check
+++ b/test/files/run/reify_ann1a.check
@@ -1,5 +1,5 @@
 {
-  @new ann(immutable.this.List.apply[String]("1a")) @new ann(immutable.this.List.apply[String]("1b")) class C[@new ann(immutable.this.List.apply[String]("2a")) @new ann(immutable.this.List.apply[String]("2b")) T>: Nothing <: Any] extends scala.AnyRef {
+  @new ann(immutable.this.List.apply[String]("1a")) @new ann(immutable.this.List.apply[String]("1b")) class C[@new ann(immutable.this.List.apply[String]("2a")) @new ann(immutable.this.List.apply[String]("2b")) T] extends scala.AnyRef {
     @new ann(immutable.this.List.apply[String]("3a")) @new ann(immutable.this.List.apply[String]("3b")) <paramaccessor> private[this] val x: T @ann(immutable.this.List.apply[String]("4a")) @ann(immutable.this.List.apply[String]("4b")) = _;
     def <init>(@new ann(immutable.this.List.apply[String]("3a")) @new ann(immutable.this.List.apply[String]("3b")) x: T @ann(immutable.this.List.apply[String]("4a")) @ann(immutable.this.List.apply[String]("4b"))) = {
       super.<init>();
@@ -14,7 +14,7 @@
   ()
 }
 {
-  @ann(immutable.this.List.apply[String]("1a")) @ann(immutable.this.List.apply[String]("1b")) class C[@ann(immutable.this.List.apply[String]("2a")) @ann(immutable.this.List.apply[String]("2b")) T>: Nothing <: Any] extends scala.AnyRef {
+  @ann(immutable.this.List.apply[String]("1a")) @ann(immutable.this.List.apply[String]("1b")) class C[@ann(immutable.this.List.apply[String]("2a")) @ann(immutable.this.List.apply[String]("2b")) T] extends scala.AnyRef {
     @ann(immutable.this.List.apply[String]("3a")) @ann(immutable.this.List.apply[String]("3b")) <paramaccessor> private[this] val x: T @ann(immutable.this.List.apply[String]("4b")) @ann(immutable.this.List.apply[String]("4a")) = _;
     def <init>(@ann(immutable.this.List.apply[String]("3a")) @ann(immutable.this.List.apply[String]("3b")) x: T @ann(immutable.this.List.apply[String]("4b")) @ann(immutable.this.List.apply[String]("4a"))): C[T] = {
       C.super.<init>();
diff --git a/test/files/run/reify_ann1b.check b/test/files/run/reify_ann1b.check
index ceebc0e2ed..9bc65a422e 100644
--- a/test/files/run/reify_ann1b.check
+++ b/test/files/run/reify_ann1b.check
@@ -1,5 +1,5 @@
 {
-  @new ann(bar = "1a") @new ann(bar = "1b") class C[@new ann(bar = "2a") @new ann(bar = "2b") T>: Nothing <: Any] extends scala.AnyRef {
+  @new ann(bar = "1a") @new ann(bar = "1b") class C[@new ann(bar = "2a") @new ann(bar = "2b") T] extends scala.AnyRef {
     @new ann(bar = "3a") @new ann(bar = "3b") <paramaccessor> private[this] val x: T @ann(bar = "4a") @ann(bar = "4b") = _;
     def <init>(@new ann(bar = "3a") @new ann(bar = "3b") x: T @ann(bar = "4a") @ann(bar = "4b")) = {
       super.<init>();
@@ -14,7 +14,7 @@
   ()
 }
 {
-  @ann(bar = "1a") @ann(bar = "1b") class C[@ann(bar = "2a") @ann(bar = "2b") T>: Nothing <: Any] extends scala.AnyRef {
+  @ann(bar = "1a") @ann(bar = "1b") class C[@ann(bar = "2a") @ann(bar = "2b") T] extends scala.AnyRef {
     @ann(bar = "3a") @ann(bar = "3b") <paramaccessor> private[this] val x: T @ann(bar = "4b") @ann(bar = "4a") = _;
     def <init>(@ann(bar = "3a") @ann(bar = "3b") x: T @ann(bar = "4b") @ann(bar = "4a")): C[T] = {
       C.super.<init>();