Merge remote-tracking branch 'origin/master' into ticket/7345-2

Conflicts:
	src/compiler/scala/tools/nsc/typechecker/Contexts.scala
	src/compiler/scala/tools/nsc/typechecker/Typers.scala

20 files changed, 319 insertions, 328 deletions

diff --git a/src/compiler/scala/reflect/reify/phases/Reshape.scala b/src/compiler/scala/reflect/reify/phases/Reshape.scala
index bc2dbeed3e..5f53f558b4 100644
--- a/src/compiler/scala/reflect/reify/phases/Reshape.scala
+++ b/src/compiler/scala/reflect/reify/phases/Reshape.scala
@@ -167,7 +167,7 @@ trait Reshape {
         // if this assumption fails, please, don't be quick to add postprocessing here (like I did before)
         // but rather try to fix this in Typer, so that it produces quality originals (like it's done for typedAnnotated)
         if (reifyDebug) println("TypeTree, essential: %s (%s)".format(tt.tpe, tt.tpe.kind))
-        if (reifyDebug) println("verdict: rolled back to original %s".format(tt.original))
+        if (reifyDebug) println("verdict: rolled back to original %s".format(tt.original.toString.replaceAll("\\s+", " ")))
         transform(tt.original)
       } else {
         // type is deemed to be non-essential
diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index 8b78ddd59d..d0b59b53cc 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -1105,7 +1105,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
 
       ("\n" + info1) :: info2 :: info3 mkString "\n\n"
     }
-    catch { case x: Exception => errorMessage }
+    catch { case _: Exception | _: TypeError => errorMessage }
 
   /** The id of the currently active run
    */
diff --git a/src/compiler/scala/tools/nsc/ast/TreeInfo.scala b/src/compiler/scala/tools/nsc/ast/TreeInfo.scala
index 6a0f4407fc..0731d78a9b 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeInfo.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeInfo.scala
@@ -87,12 +87,4 @@ abstract class TreeInfo extends scala.reflect.internal.TreeInfo {
     case DocDef(_, definition) => isPureDef(definition)
     case _ => super.isPureDef(tree)
   }
-
- /** Does list of trees start with a definition of
-   *  a class of module with given name (ignoring imports)
-   */
-  override def firstDefinesClassOrObject(trees: List[Tree], name: Name): Boolean = trees match {
-    case ClassDef(_, `name`, _, _) :: Nil => true
-    case _ => super.firstDefinesClassOrObject(trees, name)
-  }
 }
diff --git a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala
index 4d086e787e..cd23ad74e4 100644
--- a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala
@@ -251,8 +251,7 @@ class MutableSettings(val errorFn: String => Unit)
       else if (allowJar && dir == null && Jar.isJarOrZip(name, examineFile = false))
         new PlainFile(Path(name))
       else
-//      throw new FatalError(name + " does not exist or is not a directory")
-        dir
+        throw new FatalError(name + " does not exist or is not a directory")
     )
 
     /** Set the single output directory. From now on, all files will
diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
index 8e008edde2..6f3771b58d 100644
--- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
+++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
@@ -808,7 +808,11 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
   private def normalizeMember(owner: Symbol, sym: Symbol, outerEnv: TypeEnv): List[Symbol] = {
     sym :: (
       if (!sym.isMethod || enteringTyper(sym.typeParams.isEmpty)) Nil
-      else {
+      else if (sym.hasDefault) {
+        /* Specializing default getters is useless, also see SI-7329 . */
+        sym.resetFlag(SPECIALIZED)
+        Nil
+      } else {
         // debuglog("normalizeMember: " + sym.fullNameAsName('.').decode)
         var specializingOn = specializedParams(sym)
         val unusedStvars   = specializingOn filterNot specializedTypeVars(sym.info)
@@ -1008,27 +1012,25 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
           if (overriding.isAbstractOverride) om.setFlag(ABSOVERRIDE)
           typeEnv(om) = env
           addConcreteSpecMethod(overriding)
-          info(om) = (
-            if (overriding.isDeferred) { // abstract override
-              debuglog("abstract override " + overriding.fullName + " with specialized " + om.fullName)
-              Forward(overriding)
-            }
-            else {
-              // if the override is a normalized member, 'om' gets the
-              // implementation from its original target, and adds the
-              // environment of the normalized member (that is, any
-              // specialized /method/ type parameter bindings)
-              val impl = info get overriding match {
-                case Some(NormalizedMember(target)) =>
-                  typeEnv(om) = env ++ typeEnv(overriding)
-                  target
-                case _ =>
-                  overriding
-              }
-              info(overriding) = Forward(om setPos overriding.pos)
-              SpecialOverride(impl)
+          if (overriding.isDeferred) { // abstract override
+            debuglog("abstract override " + overriding.fullName + " with specialized " + om.fullName)
+            info(om) = Forward(overriding)
+          }
+          else {
+            // if the override is a normalized member, 'om' gets the
+            // implementation from its original target, and adds the
+            // environment of the normalized member (that is, any
+            // specialized /method/ type parameter bindings)
+            info get overriding match {
+              case Some(NormalizedMember(target)) =>
+                typeEnv(om) = env ++ typeEnv(overriding)
+                info(om) = Forward(target)
+              case _ =>
+                info(om) = SpecialOverride(overriding)
             }
-          )
+            info(overriding) = Forward(om setPos overriding.pos)
+          }
+
           newOverload(overriding, om, env)
           ifDebug(exitingSpecialize(assert(
             overridden.owner.info.decl(om.name) != NoSymbol,
@@ -1851,6 +1853,5 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
       }
 
       resultTree
-    }
-  }
+    }  }
 }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
index 6daa00e7f8..7a4b28486b 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
@@ -89,7 +89,10 @@ trait Contexts { self: Analyzer =>
 
     if (settings.noimports) Nil
     else if (unit.isJava) RootImports.javaList
-    else if (settings.nopredef || treeInfo.noPredefImportForUnit(unit.body)) RootImports.javaAndScalaList
+    else if (settings.nopredef || treeInfo.noPredefImportForUnit(unit.body)) {
+      debuglog("Omitted import of Predef._ for " + unit)
+      RootImports.javaAndScalaList
+    }
     else RootImports.completeList
   }
 
@@ -107,6 +110,7 @@ trait Contexts { self: Analyzer =>
         case Import(qual, _) => qual setType singleType(qual.symbol.owner.thisType, qual.symbol)
         case _               =>
       }
+      context.reportBuffer.clearAll()
     }
   }
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
index 1bd17e51d2..49188d1deb 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -287,7 +287,11 @@ trait Infer extends Checkable {
       //   println("set error: "+tree);
       //   throw new Error()
       // }
-      def name        = newTermName("<error: " + tree.symbol + ">")
+      def name = {
+        val sym = tree.symbol
+        val nameStr = try sym.toString catch { case _: CyclicReference => sym.nameString }
+        newTermName(s"<error: $nameStr>")
+      }
       def errorClass  = if (context.reportErrors) context.owner.newErrorClass(name.toTypeName) else stdErrorClass
       def errorValue  = if (context.reportErrors) context.owner.newErrorValue(name) else stdErrorValue
       def errorSym    = if (tree.isType) errorClass else errorValue
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 01f7b11362..37a7e3c8cc 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -489,11 +489,6 @@ trait Typers extends Adaptations with Tags {
       res
     }
 
-    final def newImplTyper[T](impl: ImplDef, clazz: Symbol): Typer = {
-      val c = context.make(impl.impl, clazz, newScope)
-      newTyper(c)
-    }
-
     @inline
     final def withSavedContext[T](c: Context)(f: => T) = {
       val savedErrors = c.flushAndReturnBuffer()
@@ -734,16 +729,19 @@ trait Typers extends Adaptations with Tags {
           if (!OK) {
             val Some(AnnotationInfo(_, List(Literal(Constant(featureDesc: String)), Literal(Constant(required: Boolean))), _)) =
               featureTrait getAnnotation LanguageFeatureAnnot
-            val req = if (required) "needs to" else "should"
-            var raw = featureDesc + " " + req + " be enabled\n" +
-              "by making the implicit value language." + featureName + " visible."
-            if (!(currentRun.reportedFeature contains featureTrait))
-              raw += "\nThis can be achieved by adding the import clause 'import scala.language." + featureName + "'\n" +
-                "or by setting the compiler option -language:" + featureName + ".\n" +
-                "See the Scala docs for value scala.language." + featureName + " for a discussion\n" +
-                "why the feature " + req + " be explicitly enabled."
+            val req     = if (required) "needs to" else "should"
+            val fqname  = "scala.language." + featureName
+            val explain = (
+              if (currentRun.reportedFeature contains featureTrait) "" else
+              s"""|
+                  |This can be achieved by adding the import clause 'import $fqname'
+                  |or by setting the compiler option -language:$featureName.
+                  |See the Scala docs for value $fqname for a discussion
+                  |why the feature $req be explicitly enabled.""".stripMargin
+            )
             currentRun.reportedFeature += featureTrait
-            val msg = raw replace ("#", construct)
+
+            val msg = s"$featureDesc $req be enabled\nby making the implicit value $fqname visible.$explain" replace ("#", construct)
             if (required) unit.error(pos, msg)
             else currentRun.featureWarnings.warn(pos, msg)
           }
@@ -1734,14 +1732,16 @@ trait Typers extends Adaptations with Tags {
           if (psym.isFinal)
             pending += ParentFinalInheritanceError(parent, psym)
 
-          if (psym.hasDeprecatedInheritanceAnnotation) {
+          val sameSourceFile = context.unit.source.file == psym.sourceFile
+
+          if (psym.hasDeprecatedInheritanceAnnotation && !sameSourceFile) {
             val suffix = psym.deprecatedInheritanceMessage map (": " + _) getOrElse ""
             val msg = s"inheritance from ${psym.fullLocationString} is deprecated$suffix"
             unit.deprecationWarning(parent.pos, msg)
           }
 
           if (psym.isSealed && !phase.erasedTypes)
-            if (context.unit.source.file == psym.sourceFile)
+            if (sameSourceFile)
               psym addChild context.owner
             else
               pending += ParentSealedInheritanceError(parent, psym)
@@ -1797,7 +1797,7 @@ trait Typers extends Adaptations with Tags {
       assert(clazz != NoSymbol, cdef)
       reenterTypeParams(cdef.tparams)
       val tparams1 = cdef.tparams mapConserve (typedTypeDef)
-      val impl1 = newImplTyper(cdef, clazz).typedTemplate(cdef.impl, typedParentTypes(cdef.impl))
+      val impl1 = newTyper(context.make(cdef.impl, clazz, newScope)).typedTemplate(cdef.impl, typedParentTypes(cdef.impl))
       val impl2 = finishMethodSynthesis(impl1, clazz, context)
       if (clazz.isTrait && clazz.info.parents.nonEmpty && clazz.info.firstParent.typeSymbol == AnyClass)
         checkEphemeral(clazz, impl2.body)
@@ -1838,7 +1838,7 @@ trait Typers extends Adaptations with Tags {
         || !linkedClass.isSerializable
         || clazz.isSerializable
       )
-      val impl1 = newImplTyper(mdef, clazz).typedTemplate(mdef.impl, {
+      val impl1 = newTyper(context.make(mdef.impl, clazz, newScope)).typedTemplate(mdef.impl, {
         typedParentTypes(mdef.impl) ++ (
           if (noSerializable) Nil
           else {
@@ -1850,6 +1850,9 @@ trait Typers extends Adaptations with Tags {
 
       val impl2  = finishMethodSynthesis(impl1, clazz, context)
 
+      if (mdef.symbol == PredefModule)
+        ensurePredefParentsAreInSameSourceFile(impl2)
+
       // SI-5954. On second compile of a companion class contained in a package object we end up
       // with some confusion of names which leads to having two symbols with the same name in the
       // same owner. Until that can be straightened out we will warn on companion objects in package
@@ -1878,6 +1881,12 @@ trait Typers extends Adaptations with Tags {
 
       treeCopy.ModuleDef(mdef, typedMods, mdef.name, impl2) setType NoType
     }
+
+    private def ensurePredefParentsAreInSameSourceFile(template: Template) = {
+      val parentSyms = template.parents map (_.symbol) filterNot (_ == AnyRefClass)
+      if (parentSyms exists (_.associatedFile != PredefModule.associatedFile))
+        unit.error(template.pos, s"All parents of Predef must be defined in ${PredefModule.associatedFile}.")
+    }
     /** In order to override this in the TreeCheckers Typer so synthetics aren't re-added
      *  all the time, it is exposed here the module/class typing methods go through it.
      *  ...but it turns out it's also the ideal spot for namer/typer coordination for
@@ -3792,8 +3801,16 @@ trait Typers extends Adaptations with Tags {
         if (vd.symbol.tpe.isVolatile)
           AbstractionFromVolatileTypeError(vd)
       val tpt1 = typedType(tree.tpt, mode)
-      existentialTransform(whereClauses1 map (_.symbol), tpt1.tpe)((tparams, tp) =>
-        TypeTree(newExistentialType(tparams, tp)) setOriginal tree
+      existentialTransform(whereClauses1 map (_.symbol), tpt1.tpe)((tparams, tp) => {
+        val original = tpt1 match {
+          case tpt : TypeTree => atPos(tree.pos)(ExistentialTypeTree(tpt.original, tree.whereClauses))
+          case _ => {
+            debuglog(s"cannot reconstruct the original for $tree, because $tpt1 is not a TypeTree")
+            tree
+          }
+        }
+        TypeTree(newExistentialType(tparams, tp)) setOriginal original
+      }
       )
     }
 
@@ -4407,63 +4424,58 @@ trait Typers extends Adaptations with Tags {
 
       def normalTypedApply(tree: Tree, fun: Tree, args: List[Tree]) = {
         val stableApplication = (fun.symbol ne null) && fun.symbol.isMethod && fun.symbol.isStable
-        if (stableApplication && isPatternMode) {
-          // treat stable function applications f() as expressions.
-          typed1(tree, (mode &~ PATTERNmode) | EXPRmode, pt)
-        } else {
-          val funpt = if (isPatternMode) pt else WildcardType
-          val appStart = if (Statistics.canEnable) Statistics.startTimer(failedApplyNanos) else null
-          val opeqStart = if (Statistics.canEnable) Statistics.startTimer(failedOpEqNanos) else null
-
-          def onError(reportError: => Tree): Tree = {
-              fun match {
-                case Select(qual, name)
-                if !isPatternMode && nme.isOpAssignmentName(newTermName(name.decode)) =>
-                  val qual1 = typedQualifier(qual)
-                  if (treeInfo.isVariableOrGetter(qual1)) {
-                    if (Statistics.canEnable) Statistics.stopTimer(failedOpEqNanos, opeqStart)
-                    convertToAssignment(fun, qual1, name, args)
-                  } else {
-                    if (Statistics.canEnable) Statistics.stopTimer(failedApplyNanos, appStart)
-                      reportError
-                  }
-                case _ =>
+        val funpt = if (isPatternMode) pt else WildcardType
+        val appStart = if (Statistics.canEnable) Statistics.startTimer(failedApplyNanos) else null
+        val opeqStart = if (Statistics.canEnable) Statistics.startTimer(failedOpEqNanos) else null
+
+        def onError(reportError: => Tree): Tree = {
+            fun match {
+              case Select(qual, name)
+              if !isPatternMode && nme.isOpAssignmentName(newTermName(name.decode)) =>
+                val qual1 = typedQualifier(qual)
+                if (treeInfo.isVariableOrGetter(qual1)) {
+                  if (Statistics.canEnable) Statistics.stopTimer(failedOpEqNanos, opeqStart)
+                  convertToAssignment(fun, qual1, name, args)
+                } else {
                   if (Statistics.canEnable) Statistics.stopTimer(failedApplyNanos, appStart)
-                  reportError
-              }
-          }
-          val silentResult = silent(
-            op                    = _.typed(fun, mode.forFunMode, funpt),
-            reportAmbiguousErrors = !mode.inExprMode && context.ambiguousErrors,
-            newtree               = if (mode.inExprMode) tree else context.tree
-          )
-          silentResult match {
-            case SilentResultValue(fun1) =>
-              val fun2 = if (stableApplication) stabilizeFun(fun1, mode, pt) else fun1
-              if (Statistics.canEnable) Statistics.incCounter(typedApplyCount)
-              val noSecondTry = (
-                   isPastTyper
-                || (fun2.symbol ne null) && fun2.symbol.isConstructor
-                || (fun2.tpe match { case mt: MethodType => mt.isImplicit case _ => false })
-              )
-              val isFirstTry = !noSecondTry && (
-                fun2 match {
-                  case Select(_, _) => mode inExprModeButNot SNDTRYmode
-                  case _            => false
+                    reportError
                 }
-              )
-              if (isFirstTry)
-                tryTypedApply(fun2, args)
-              else
-                doTypedApply(tree, fun2, args, mode, pt)
+              case _ =>
+                if (Statistics.canEnable) Statistics.stopTimer(failedApplyNanos, appStart)
+                reportError
+            }
+        }
+        val silentResult = silent(
+          op                    = _.typed(fun, mode.forFunMode, funpt),
+          reportAmbiguousErrors = !mode.inExprMode && context.ambiguousErrors,
+          newtree               = if (mode.inExprMode) tree else context.tree
+        )
+        silentResult match {
+          case SilentResultValue(fun1) =>
+            val fun2 = if (stableApplication) stabilizeFun(fun1, mode, pt) else fun1
+            if (Statistics.canEnable) Statistics.incCounter(typedApplyCount)
+            val noSecondTry = (
+                 isPastTyper
+              || (fun2.symbol ne null) && fun2.symbol.isConstructor
+              || (fun2.tpe match { case mt: MethodType => mt.isImplicit case _ => false })
+            )
+            val isFirstTry = !noSecondTry && (
+              fun2 match {
+                case Select(_, _) => mode inExprModeButNot SNDTRYmode
+                case _            => false
+              }
+            )
+            if (isFirstTry)
+              tryTypedApply(fun2, args)
+            else
+              doTypedApply(tree, fun2, args, mode, pt)
 
-            case SilentTypeError(err) =>
-              onError({issue(err); setError(tree)})
-          }
+          case SilentTypeError(err) =>
+            onError({issue(err); setError(tree)})
         }
       }
 
-                // convert new Array[T](len) to evidence[ClassTag[T]].newArray(len)
+      // convert new Array[T](len) to evidence[ClassTag[T]].newArray(len)
       // convert new Array^N[T](len) for N > 1 to evidence[ClassTag[Array[...Array[T]...]]].newArray(len)
       // where Array HK gets applied (N-1) times
       object ArrayInstantiation {
diff --git a/src/library/scala/LowPriorityImplicits.scala b/src/library/scala/LowPriorityImplicits.scala
deleted file mode 100644
index 535f1ac699..0000000000
--- a/src/library/scala/LowPriorityImplicits.scala
+++ /dev/null
@@ -1,95 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2002-2013, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-
-package scala
-
-import scala.collection.{ mutable, immutable, generic }
-import mutable.WrappedArray
-import immutable.WrappedString
-import generic.CanBuildFrom
-import scala.language.implicitConversions
-
-/** The `LowPriorityImplicits` class provides implicit values that
- *  are valid in all Scala compilation units without explicit qualification,
- *  but that are partially overridden by higher-priority conversions in object
- *  `Predef`.
- *
- *  @author  Martin Odersky
- *  @since 2.8
- */
-private[scala] abstract class LowPriorityImplicits {
-  /** We prefer the java.lang.* boxed types to these wrappers in
-   *  any potential conflicts.  Conflicts do exist because the wrappers
-   *  need to implement ScalaNumber in order to have a symmetric equals
-   *  method, but that implies implementing java.lang.Number as well.
-   *
-   *  Note - these are inlined because they are value classes, but
-   *  the call to xxxWrapper is not eliminated even though it does nothing.
-   *  Even inlined, every call site does a no-op retrieval of Predef's MODULE$
-   *  because maybe loading Predef has side effects!
-   */
-  @inline implicit def byteWrapper(x: Byte)       = new runtime.RichByte(x)
-  @inline implicit def shortWrapper(x: Short)     = new runtime.RichShort(x)
-  @inline implicit def intWrapper(x: Int)         = new runtime.RichInt(x)
-  @inline implicit def charWrapper(c: Char)       = new runtime.RichChar(c)
-  @inline implicit def longWrapper(x: Long)       = new runtime.RichLong(x)
-  @inline implicit def floatWrapper(x: Float)     = new runtime.RichFloat(x)
-  @inline implicit def doubleWrapper(x: Double)   = new runtime.RichDouble(x)
-  @inline implicit def booleanWrapper(x: Boolean) = new runtime.RichBoolean(x)
-
-  // These eight implicits exist solely to exclude Null from the domain of
-  // the boxed types, so that e.g. "var x: Int = null" is a compile time
-  // error rather than a delayed null pointer exception by way of the
-  // conversion from java.lang.Integer.  If defined in the same file as
-  // Integer2int, they would have higher priority because Null is a subtype
-  // of Integer.  We balance that out and create conflict by moving the
-  // definition into the superclass.
-  //
-  // Caution: do not adjust tightrope tension without safety goggles in place.
-  implicit def Byte2byteNullConflict(x: Null): Byte          = sys.error("value error")
-  implicit def Short2shortNullConflict(x: Null): Short       = sys.error("value error")
-  implicit def Character2charNullConflict(x: Null): Char     = sys.error("value error")
-  implicit def Integer2intNullConflict(x: Null): Int         = sys.error("value error")
-  implicit def Long2longNullConflict(x: Null): Long          = sys.error("value error")
-  implicit def Float2floatNullConflict(x: Null): Float       = sys.error("value error")
-  implicit def Double2doubleNullConflict(x: Null): Double    = sys.error("value error")
-  implicit def Boolean2booleanNullConflict(x: Null): Boolean = sys.error("value error")
-
-  implicit def genericWrapArray[T](xs: Array[T]): WrappedArray[T] =
-    if (xs eq null) null
-    else WrappedArray.make(xs)
-
-  // Since the JVM thinks arrays are covariant, one 0-length Array[AnyRef]
-  // is as good as another for all T <: AnyRef.  Instead of creating 100,000,000
-  // unique ones by way of this implicit, let's share one.
-  implicit def wrapRefArray[T <: AnyRef](xs: Array[T]): WrappedArray[T] = {
-    if (xs eq null) null
-    else if (xs.length == 0) WrappedArray.empty[T]
-    else new WrappedArray.ofRef[T](xs)
-  }
-
-  implicit def wrapIntArray(xs: Array[Int]): WrappedArray[Int] = if (xs ne null) new WrappedArray.ofInt(xs) else null
-  implicit def wrapDoubleArray(xs: Array[Double]): WrappedArray[Double] = if (xs ne null) new WrappedArray.ofDouble(xs) else null
-  implicit def wrapLongArray(xs: Array[Long]): WrappedArray[Long] = if (xs ne null) new WrappedArray.ofLong(xs) else null
-  implicit def wrapFloatArray(xs: Array[Float]): WrappedArray[Float] = if (xs ne null) new WrappedArray.ofFloat(xs) else null
-  implicit def wrapCharArray(xs: Array[Char]): WrappedArray[Char] = if (xs ne null) new WrappedArray.ofChar(xs) else null
-  implicit def wrapByteArray(xs: Array[Byte]): WrappedArray[Byte] = if (xs ne null) new WrappedArray.ofByte(xs) else null
-  implicit def wrapShortArray(xs: Array[Short]): WrappedArray[Short] = if (xs ne null) new WrappedArray.ofShort(xs) else null
-  implicit def wrapBooleanArray(xs: Array[Boolean]): WrappedArray[Boolean] = if (xs ne null) new WrappedArray.ofBoolean(xs) else null
-  implicit def wrapUnitArray(xs: Array[Unit]): WrappedArray[Unit] = if (xs ne null) new WrappedArray.ofUnit(xs) else null
-
-  implicit def wrapString(s: String): WrappedString = if (s ne null) new WrappedString(s) else null
-  implicit def unwrapString(ws: WrappedString): String = if (ws ne null) ws.self else null
-
-  implicit def fallbackStringCanBuildFrom[T]: CanBuildFrom[String, T, immutable.IndexedSeq[T]] =
-    new CanBuildFrom[String, T, immutable.IndexedSeq[T]] {
-      def apply(from: String) = immutable.IndexedSeq.newBuilder[T]
-      def apply() = immutable.IndexedSeq.newBuilder[T]
-    }
-}
-
diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala
index 9a468489a2..569157de20 100644
--- a/src/library/scala/Predef.scala
+++ b/src/library/scala/Predef.scala
@@ -446,3 +446,88 @@ private[scala] trait DeprecatedPredef {
   @deprecated("Use the method in `scala.io.ReadStdin`", "2.11.0") def readf2(format: String)             = ReadStdin.readf2(format)
   @deprecated("Use the method in `scala.io.ReadStdin`", "2.11.0") def readf3(format: String)             = ReadStdin.readf3(format)
 }
+
+/** The `LowPriorityImplicits` class provides implicit values that
+*  are valid in all Scala compilation units without explicit qualification,
+*  but that are partially overridden by higher-priority conversions in object
+*  `Predef`.
+*
+*  @author  Martin Odersky
+*  @since 2.8
+*/
+// SI-7335 Parents of Predef are defined in the same compilation unit to avoid
+// cyclic reference errors compiling the standard library *without* a previously
+// compiled copy on the classpath.
+private[scala] abstract class LowPriorityImplicits {
+  import mutable.WrappedArray
+  import immutable.WrappedString
+
+  /** We prefer the java.lang.* boxed types to these wrappers in
+   *  any potential conflicts.  Conflicts do exist because the wrappers
+   *  need to implement ScalaNumber in order to have a symmetric equals
+   *  method, but that implies implementing java.lang.Number as well.
+   *
+   *  Note - these are inlined because they are value classes, but
+   *  the call to xxxWrapper is not eliminated even though it does nothing.
+   *  Even inlined, every call site does a no-op retrieval of Predef's MODULE$
+   *  because maybe loading Predef has side effects!
+   */
+  @inline implicit def byteWrapper(x: Byte)       = new runtime.RichByte(x)
+  @inline implicit def shortWrapper(x: Short)     = new runtime.RichShort(x)
+  @inline implicit def intWrapper(x: Int)         = new runtime.RichInt(x)
+  @inline implicit def charWrapper(c: Char)       = new runtime.RichChar(c)
+  @inline implicit def longWrapper(x: Long)       = new runtime.RichLong(x)
+  @inline implicit def floatWrapper(x: Float)     = new runtime.RichFloat(x)
+  @inline implicit def doubleWrapper(x: Double)   = new runtime.RichDouble(x)
+  @inline implicit def booleanWrapper(x: Boolean) = new runtime.RichBoolean(x)
+
+  // These eight implicits exist solely to exclude Null from the domain of
+  // the boxed types, so that e.g. "var x: Int = null" is a compile time
+  // error rather than a delayed null pointer exception by way of the
+  // conversion from java.lang.Integer.  If defined in the same template as
+  // Integer2int, they would have higher priority because Null is a subtype
+  // of Integer.  We balance that out and create conflict by moving the
+  // definition into the superclass.
+  //
+  // Caution: do not adjust tightrope tension without safety goggles in place.
+  implicit def Byte2byteNullConflict(x: Null): Byte          = sys.error("value error")
+  implicit def Short2shortNullConflict(x: Null): Short       = sys.error("value error")
+  implicit def Character2charNullConflict(x: Null): Char     = sys.error("value error")
+  implicit def Integer2intNullConflict(x: Null): Int         = sys.error("value error")
+  implicit def Long2longNullConflict(x: Null): Long          = sys.error("value error")
+  implicit def Float2floatNullConflict(x: Null): Float       = sys.error("value error")
+  implicit def Double2doubleNullConflict(x: Null): Double    = sys.error("value error")
+  implicit def Boolean2booleanNullConflict(x: Null): Boolean = sys.error("value error")
+
+  implicit def genericWrapArray[T](xs: Array[T]): WrappedArray[T] =
+    if (xs eq null) null
+    else WrappedArray.make(xs)
+
+  // Since the JVM thinks arrays are covariant, one 0-length Array[AnyRef]
+  // is as good as another for all T <: AnyRef.  Instead of creating 100,000,000
+  // unique ones by way of this implicit, let's share one.
+  implicit def wrapRefArray[T <: AnyRef](xs: Array[T]): WrappedArray[T] = {
+    if (xs eq null) null
+    else if (xs.length == 0) WrappedArray.empty[T]
+    else new WrappedArray.ofRef[T](xs)
+  }
+
+  implicit def wrapIntArray(xs: Array[Int]): WrappedArray[Int] = if (xs ne null) new WrappedArray.ofInt(xs) else null
+  implicit def wrapDoubleArray(xs: Array[Double]): WrappedArray[Double] = if (xs ne null) new WrappedArray.ofDouble(xs) else null
+  implicit def wrapLongArray(xs: Array[Long]): WrappedArray[Long] = if (xs ne null) new WrappedArray.ofLong(xs) else null
+  implicit def wrapFloatArray(xs: Array[Float]): WrappedArray[Float] = if (xs ne null) new WrappedArray.ofFloat(xs) else null
+  implicit def wrapCharArray(xs: Array[Char]): WrappedArray[Char] = if (xs ne null) new WrappedArray.ofChar(xs) else null
+  implicit def wrapByteArray(xs: Array[Byte]): WrappedArray[Byte] = if (xs ne null) new WrappedArray.ofByte(xs) else null
+  implicit def wrapShortArray(xs: Array[Short]): WrappedArray[Short] = if (xs ne null) new WrappedArray.ofShort(xs) else null
+  implicit def wrapBooleanArray(xs: Array[Boolean]): WrappedArray[Boolean] = if (xs ne null) new WrappedArray.ofBoolean(xs) else null
+  implicit def wrapUnitArray(xs: Array[Unit]): WrappedArray[Unit] = if (xs ne null) new WrappedArray.ofUnit(xs) else null
+
+  implicit def wrapString(s: String): WrappedString = if (s ne null) new WrappedString(s) else null
+  implicit def unwrapString(ws: WrappedString): String = if (ws ne null) ws.self else null
+
+  implicit def fallbackStringCanBuildFrom[T]: CanBuildFrom[String, T, immutable.IndexedSeq[T]] =
+    new CanBuildFrom[String, T, immutable.IndexedSeq[T]] {
+      def apply(from: String) = immutable.IndexedSeq.newBuilder[T]
+      def apply() = immutable.IndexedSeq.newBuilder[T]
+    }
+}
diff --git a/src/library/scala/deprecatedInheritance.scala b/src/library/scala/deprecatedInheritance.scala
index 70065560b1..7d20219d4d 100644
--- a/src/library/scala/deprecatedInheritance.scala
+++ b/src/library/scala/deprecatedInheritance.scala
@@ -11,7 +11,8 @@ package scala
 /** An annotation that designates that inheriting from a class is deprecated.
  *
  *  This is usually done to warn about a non-final class being made final in a future version.
- *  Sub-classing such a class then generates a warning.
+ *  Sub-classing such a class then generates a warning. No warnings are generated if the
+ *  subclass is in the same compilation unit.
  *
  *  @param  message the message to print during compilation if the class was sub-classed
  *  @param  since   a string identifying the first version in which inheritance was deprecated
diff --git a/src/partest/scala/tools/partest/nest/PathSettings.scala b/src/partest/scala/tools/partest/nest/PathSettings.scala
index 7c005b4f61..b1f868c9d2 100644
--- a/src/partest/scala/tools/partest/nest/PathSettings.scala
+++ b/src/partest/scala/tools/partest/nest/PathSettings.scala
@@ -8,6 +8,7 @@ package nest
 import scala.tools.nsc.Properties.{ setProp, propOrEmpty, propOrNone, propOrElse }
 import scala.tools.nsc.util.ClassPath
 import scala.tools.nsc.io
+import scala.util.Properties.{ envOrElse, envOrNone, javaHome, jdkHome }
 import io.{ Path, File, Directory }
 
 object PathSettings {
@@ -74,6 +75,35 @@ object PathSettings {
 
   lazy val diffUtils: File =
     findJar(buildPackLibDir.files, "diffutils") getOrElse sys.error(s"No diffutils.jar found in '$buildPackLibDir'.")
+
+  /** The platform-specific support jar.
+   *  Usually this is tools.jar in the jdk/lib directory of the platform distribution.
+   *  The file location is determined by probing the lib directory under JDK_HOME or JAVA_HOME,
+   *  if one of those environment variables is set, then the lib directory under java.home,
+   *  and finally the lib directory under the parent of java.home. Or, as a last resort,
+   *  search deeply under those locations (except for the parent of java.home, on the notion
+   *  that if this is not a canonical installation, then that search would have litte
+   *  chance of succeeding).
+   */
+  lazy val platformTools: Option[File] = {
+    val jarName = "tools.jar"
+    def jarPath(path: Path) = (path / "lib" / jarName).toFile
+    def jarAt(path: Path) = {
+      val f = jarPath(path)
+      if (f.isFile) Some(f) else None
+    }
+    val jdkDir = {
+      val d = Directory(jdkHome)
+      if (d.isDirectory) Some(d) else None
+    }
+    def deeply(dir: Directory) = dir.deepFiles find (_.name == jarName)
+
+    val home    = envOrNone("JDK_HOME") orElse envOrNone("JAVA_HOME") map (p => Path(p))
+    val install = Some(Path(javaHome))
+
+    (home flatMap jarAt) orElse (install flatMap jarAt) orElse (install map (_.parent) flatMap jarAt) orElse
+      (jdkDir flatMap deeply)
+  }
 }
 
 class PathSettings() {
diff --git a/src/partest/scala/tools/partest/nest/RunnerManager.scala b/src/partest/scala/tools/partest/nest/RunnerManager.scala
index 1c689714c7..fa2b5ea74b 100644
--- a/src/partest/scala/tools/partest/nest/RunnerManager.scala
+++ b/src/partest/scala/tools/partest/nest/RunnerManager.scala
@@ -74,8 +74,10 @@ object Output {
 
 class RunnerManager(kind: String, val fileManager: FileManager, params: TestRunParams) {
   import fileManager._
+
   fileManager.CLASSPATH += File.pathSeparator + PathSettings.scalaCheck
   fileManager.CLASSPATH += File.pathSeparator + PathSettings.diffUtils // needed to put diffutils on test/partest's classpath
+  PathSettings.platformTools foreach (fileManager.CLASSPATH += File.pathSeparator + _)
 
   def runTest(testFile: File): TestState = {
     val runner = new Runner(testFile, fileManager) {
diff --git a/src/reflect/scala/reflect/api/TypeTags.scala b/src/reflect/scala/reflect/api/TypeTags.scala
index e988971ace..7457910226 100644
--- a/src/reflect/scala/reflect/api/TypeTags.scala
+++ b/src/reflect/scala/reflect/api/TypeTags.scala
@@ -221,24 +221,7 @@ trait TypeTags { self: Universe =>
 
 
     def apply[T](mirror1: scala.reflect.api.Mirror[self.type], tpec1: TypeCreator): WeakTypeTag[T] =
-      tpec1(mirror1) match {
-        case ByteTpe    => WeakTypeTag.Byte.asInstanceOf[WeakTypeTag[T]]
-        case ShortTpe   => WeakTypeTag.Short.asInstanceOf[WeakTypeTag[T]]
-        case CharTpe    => WeakTypeTag.Char.asInstanceOf[WeakTypeTag[T]]
-        case IntTpe     => WeakTypeTag.Int.asInstanceOf[WeakTypeTag[T]]
-        case LongTpe    => WeakTypeTag.Long.asInstanceOf[WeakTypeTag[T]]
-        case FloatTpe   => WeakTypeTag.Float.asInstanceOf[WeakTypeTag[T]]
-        case DoubleTpe  => WeakTypeTag.Double.asInstanceOf[WeakTypeTag[T]]
-        case BooleanTpe => WeakTypeTag.Boolean.asInstanceOf[WeakTypeTag[T]]
-        case UnitTpe    => WeakTypeTag.Unit.asInstanceOf[WeakTypeTag[T]]
-        case AnyTpe     => WeakTypeTag.Any.asInstanceOf[WeakTypeTag[T]]
-        case AnyValTpe  => WeakTypeTag.AnyVal.asInstanceOf[WeakTypeTag[T]]
-        case AnyRefTpe  => WeakTypeTag.AnyRef.asInstanceOf[WeakTypeTag[T]]
-        case ObjectTpe  => WeakTypeTag.Object.asInstanceOf[WeakTypeTag[T]]
-        case NothingTpe => WeakTypeTag.Nothing.asInstanceOf[WeakTypeTag[T]]
-        case NullTpe    => WeakTypeTag.Null.asInstanceOf[WeakTypeTag[T]]
-        case _          => new WeakTypeTagImpl[T](mirror1.asInstanceOf[Mirror], tpec1)
-      }
+      new WeakTypeTagImpl[T](mirror1.asInstanceOf[Mirror], tpec1)
 
     def unapply[T](ttag: WeakTypeTag[T]): Option[Type] = Some(ttag.tpe)
   }
@@ -299,24 +282,7 @@ trait TypeTags { self: Universe =>
     val Null:    TypeTag[scala.Null]       = new PredefTypeTag[scala.Null]       (NullTpe,    _.TypeTag.Null)
 
     def apply[T](mirror1: scala.reflect.api.Mirror[self.type], tpec1: TypeCreator): TypeTag[T] =
-      tpec1(mirror1) match {
-        case ByteTpe    => TypeTag.Byte.asInstanceOf[TypeTag[T]]
-        case ShortTpe   => TypeTag.Short.asInstanceOf[TypeTag[T]]
-        case CharTpe    => TypeTag.Char.asInstanceOf[TypeTag[T]]
-        case IntTpe     => TypeTag.Int.asInstanceOf[TypeTag[T]]
-        case LongTpe    => TypeTag.Long.asInstanceOf[TypeTag[T]]
-        case FloatTpe   => TypeTag.Float.asInstanceOf[TypeTag[T]]
-        case DoubleTpe  => TypeTag.Double.asInstanceOf[TypeTag[T]]
-        case BooleanTpe => TypeTag.Boolean.asInstanceOf[TypeTag[T]]
-        case UnitTpe    => TypeTag.Unit.asInstanceOf[TypeTag[T]]
-        case AnyTpe     => TypeTag.Any.asInstanceOf[TypeTag[T]]
-        case AnyValTpe  => TypeTag.AnyVal.asInstanceOf[TypeTag[T]]
-        case AnyRefTpe  => TypeTag.AnyRef.asInstanceOf[TypeTag[T]]
-        case ObjectTpe  => TypeTag.Object.asInstanceOf[TypeTag[T]]
-        case NothingTpe => TypeTag.Nothing.asInstanceOf[TypeTag[T]]
-        case NullTpe    => TypeTag.Null.asInstanceOf[TypeTag[T]]
-        case _          => new TypeTagImpl[T](mirror1.asInstanceOf[Mirror], tpec1)
-      }
+      new TypeTagImpl[T](mirror1.asInstanceOf[Mirror], tpec1)
 
     def unapply[T](ttag: TypeTag[T]): Option[Type] = Some(ttag.tpe)
   }
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index 8ef2805529..a87d002f25 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -887,9 +887,23 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
         supersym == NoSymbol || supersym.isIncompleteIn(base)
       }
 
-    // Does not always work if the rawInfo is a SourcefileLoader, see comment
-    // in "def coreClassesFirst" in Global.
-    def exists = !isTopLevel || { rawInfo.load(this); rawInfo != NoType }
+    def exists: Boolean = !isTopLevel || {
+      val isSourceLoader = rawInfo match {
+        case sl: SymLoader => sl.fromSource
+        case _             => false
+      }
+      def warnIfSourceLoader() {
+        if (isSourceLoader)
+          // Predef is completed early due to its autoimport; we used to get here when type checking its
+          // parent LowPriorityImplicits. See comment in c5441dc for more elaboration.
+          // Since the fix for SI-7335 Predef parents must be defined in Predef.scala, and we should not
+          // get here anymore.
+          devWarning(s"calling Symbol#exists with sourcefile based symbol loader may give incorrect results.");
+      }
+
+      rawInfo load this
+      rawInfo != NoType || { warnIfSourceLoader(); false }
+    }
 
     final def isInitialized: Boolean =
       validTo != NoPeriod
@@ -2621,32 +2635,20 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     }
 
     /** change name by appending $$<fully-qualified-name-of-class `base`>
-     *  Do the same for any accessed symbols or setters/getters.
-     *  If the accessor to be renamed is overriding a base symbol, enter
-     *  a cloned symbol with the original name but without ACCESSOR flag.
+     *  Do the same for any accessed symbols or setters/getters
      */
     override def expandName(base: Symbol) {
-      def expand(sym: Symbol) {
-        if ((sym eq NoSymbol) || (sym hasFlag EXPANDEDNAME)) () // skip
-        else sym setFlag EXPANDEDNAME setName nme.expandedName(sym.name.toTermName, base)
-      }
-      def cloneAndExpand(accessor: Symbol) {
-        val clone = accessor.cloneSymbol(accessor.owner, (accessor.flags | ARTIFACT) & ~ACCESSOR)
-        expand(accessor)
-        log(s"Expanded overriding accessor to $accessor, but cloned $clone to preserve override")
-        accessor.owner.info.decls enter clone
-      }
-      def expandAccessor(accessor: Symbol) {
-        if (accessor.isOverridingSymbol) cloneAndExpand(accessor) else expand(accessor)
-      }
-      if (hasAccessorFlag && !isDeferred) {
-        expand(accessed)
-      }
-      else if (hasGetter) {
-        expandAccessor(getter(owner))
-        expandAccessor(setter(owner))
+      if (!hasFlag(EXPANDEDNAME)) {
+        setFlag(EXPANDEDNAME)
+        if (hasAccessorFlag && !isDeferred) {
+          accessed.expandName(base)
+        }
+        else if (hasGetter) {
+          getter(owner).expandName(base)
+          setter(owner).expandName(base)
+        }
+        name = nme.expandedName(name.toTermName, base)
       }
-      expand(this)
     }
   }
   implicit val TermSymbolTag = ClassTag[TermSymbol](classOf[TermSymbol])
diff --git a/src/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala
index 461d929e7a..bf3857ea4e 100644
--- a/src/reflect/scala/reflect/internal/TreeInfo.scala
+++ b/src/reflect/scala/reflect/internal/TreeInfo.scala
@@ -670,20 +670,9 @@ abstract class TreeInfo {
       unapply(dissectApplied(tree))
   }
 
-  /** Does list of trees start with a definition of
-   *  a class of module with given name (ignoring imports)
-   */
-  def firstDefinesClassOrObject(trees: List[Tree], name: Name): Boolean = trees match {
-      case Import(_, _) :: xs               => firstDefinesClassOrObject(xs, name)
-      case Annotated(_, tree1) :: Nil       => firstDefinesClassOrObject(List(tree1), name)
-      case ModuleDef(_, `name`, _) :: Nil   => true
-      case ClassDef(_, `name`, _, _) :: Nil => true
-      case _                                => false
-    }
-
-
   /** Is this file the body of a compilation unit which should not
-   *  have Predef imported?
+   *  have Predef imported? This is the case iff the first import in the
+   *  unit explicitly refers to Predef.
    */
   def noPredefImportForUnit(body: Tree) = {
     // Top-level definition whose leading imports include Predef.
@@ -692,13 +681,7 @@ abstract class TreeInfo {
       case Import(expr, _)      => isReferenceToPredef(expr)
       case _                    => false
     }
-    // Compilation unit is class or object 'name' in package 'scala'
-    def isUnitInScala(tree: Tree, name: Name) = tree match {
-      case PackageDef(Ident(nme.scala_), defs) => firstDefinesClassOrObject(defs, name)
-      case _                                   => false
-    }
-
-    isUnitInScala(body, nme.Predef) || isLeadingPredefImport(body)
+    isLeadingPredefImport(body)
   }
 
   def isAbsTypeDef(tree: Tree) = tree match {
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index 25b05ae6b3..60d9e1c3cd 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -2956,12 +2956,14 @@ trait Types
     /** The variable's skolemization level */
     val level = skolemizationLevel
 
-    /** Two occurrences of a higher-kinded typevar, e.g. `?CC[Int]` and `?CC[String]`, correspond to
-     *  ''two instances'' of `TypeVar` that share the ''same'' `TypeConstraint`.
+    /** Applies this TypeVar to type arguments, if arity matches.
      *
-     *  `constr` for `?CC` only tracks type constructors anyway,
-     *   so when `?CC[Int] <:< List[Int]` and `?CC[String] <:< Iterable[String]`
-     *  `?CC's` hibounds contains List and Iterable.
+     * Different applications of the same type constructor variable `?CC`,
+     * e.g. `?CC[Int]` and `?CC[String]`, are modeled as distinct instances of `TypeVar`
+     * that share a `TypeConstraint`, so that the comparisons `?CC[Int] <:< List[Int]`
+     * and `?CC[String] <:< Iterable[String]` result in `?CC` being upper-bounded by `List` and `Iterable`.
+     *
+     * Applying the wrong number of type args results in a TypeVar whose instance is set to `ErrorType`.
      */
     def applyArgs(newArgs: List[Type]): TypeVar = (
       if (newArgs.isEmpty && typeArgs.isEmpty)
@@ -2971,7 +2973,7 @@ trait Types
         TypeVar.trace("applyArgs", "In " + originLocation + ", apply args " + newArgs.mkString(", ") + " to " + originName)(tv)
       }
       else
-        throw new Error("Invalid type application in TypeVar: " + params + ", " + newArgs)
+        TypeVar(typeSymbol).setInst(ErrorType)
     )
     // newArgs.length may differ from args.length (could've been empty before)
     //
@@ -3001,16 +3003,17 @@ trait Types
     // <region name="constraint mutators + undoLog">
     // invariant: before mutating constr, save old state in undoLog
     // (undoLog is used to reset constraints to avoid piling up unrelated ones)
-    def setInst(tp: Type) {
+    def setInst(tp: Type): this.type = {
       if (tp eq this) {
         log(s"TypeVar cycle: called setInst passing $this to itself.")
-        return
+        return this
       }
       undoLog record this
       // if we were compared against later typeskolems, repack the existential,
       // because skolems are only compatible if they were created at the same level
       val res = if (shouldRepackType) repackExistential(tp) else tp
       constr.inst = TypeVar.trace("setInst", "In " + originLocation + ", " + originName + "=" + res)(res)
+      this
     }
 
     def addLoBound(tp: Type, isNumericBound: Boolean = false) {
diff --git a/src/reflect/scala/reflect/internal/util/Position.scala b/src/reflect/scala/reflect/internal/util/Position.scala
index bb8c9e9b26..fe6c7db989 100644
--- a/src/reflect/scala/reflect/internal/util/Position.scala
+++ b/src/reflect/scala/reflect/internal/util/Position.scala
@@ -20,18 +20,12 @@ object Position {
       else if (posIn.isDefined) posIn.inUltimateSource(posIn.source)
       else posIn
     )
-    def file   = pos.source.file
-    def prefix = if (shortenFile) file.name else file.path
+    val prefix = if (shortenFile) pos.sourceName else pos.sourcePath
 
     pos match {
       case FakePos(fmsg) => fmsg+" "+msg
       case NoPosition    => msg
-      case _             =>
-        List(
-          "%s:%s: %s".format(prefix, pos.line, msg),
-          pos.lineContent.stripLineEnd,
-          " " * (pos.column - 1) + "^"
-        ) mkString "\n"
+      case _             => "%s:%s: %s\n%s\n%s".format(prefix, pos.line, msg, pos.lineContent, pos.lineCarat)
     }
   }
 }
@@ -206,12 +200,39 @@ abstract class Position extends scala.reflect.api.Position { self =>
 
   def column: Int = throw new UnsupportedOperationException("Position.column")
 
+  /** A line with a ^ padded with the right number of spaces.
+   */
+  def lineCarat: String = " " * (column - 1) + "^"
+
+  /** The line of code and the corresponding carat pointing line, trimmed
+   *  to the maximum specified width, with the trimmed versions oriented
+   *  around the point to give maximum context.
+   */
+  def lineWithCarat(maxWidth: Int): (String, String) = {
+    val radius = maxWidth / 2
+    var start  = math.max(column - radius, 0)
+    var result = lineContent drop start take maxWidth
+
+    if (result.length < maxWidth) {
+      result = lineContent takeRight maxWidth
+      start = lineContent.length - result.length
+    }
+
+    (result, lineCarat drop start take maxWidth)
+  }
+
   /** Convert this to a position around `point` that spans a single source line */
   def toSingleLine: Position = this
 
-  def lineContent: String =
-    if (isDefined) source.lineToString(line - 1)
-    else "NO_LINE"
+  /** The source code corresponding to the range, if this is a range position.
+   *  Otherwise the empty string.
+   */
+  def sourceCode    = ""
+  def sourceName    = "<none>"
+  def sourcePath    = "<none>"
+  def lineContent   = "<none>"
+  def lengthInChars = 0
+  def lengthInLines = 0
 
   /** Map this position to a position in an original source
    * file.  If the SourceFile is a normal SourceFile, simply
@@ -240,7 +261,10 @@ class OffsetPosition(override val source: SourceFile, override val point: Int) e
   override def withPoint(off: Int) = new OffsetPosition(source, off)
   override def withSource(source: SourceFile, shift: Int) = new OffsetPosition(source, point + shift)
 
-  override def line: Int = source.offsetToLine(point) + 1
+  override def line        = source.offsetToLine(point) + 1
+  override def sourceName  = source.file.name
+  override def sourcePath  = source.file.path
+  override def lineContent = source.lineToString(line - 1)
 
   override def column: Int = {
     var idx = source.lineToOffset(source.offsetToLine(point))
diff --git a/src/scaladoc/scala/tools/nsc/doc/Settings.scala b/src/scaladoc/scala/tools/nsc/doc/Settings.scala
index 90b94e1336..afffca12d1 100644
--- a/src/scaladoc/scala/tools/nsc/doc/Settings.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/Settings.scala
@@ -199,12 +199,6 @@ class Settings(error: String => Unit, val printMsg: String => Unit = println(_))
     "Expand all type aliases and abstract types into full template pages. (locally this can be done with the @template annotation)"
   )
 
-  val docExternalUrls = MultiStringSetting (
-    "-external-urls",
-    "externalUrl(s)",
-    "(deprecated) comma-separated list of package_names=doc_URL for external dependencies, where package names are ':'-separated"
-  )
-
   val docGroups = BooleanSetting (
     "-groups",
     "Group similar functions together (based on the @group annotation)"
@@ -254,15 +248,6 @@ class Settings(error: String => Unit, val printMsg: String => Unit = println(_))
     if (url.endsWith(index)) url else url + index
   }
 
-  // Deprecated together with 'docExternalUrls' option.
-  lazy val extUrlPackageMapping: Map[String, String] = (Map.empty[String, String] /: docExternalUrls.value) {
-    case (map, binding) =>
-      val idx = binding indexOf "="
-      val pkgs = binding substring (0, idx) split ":"
-      val url = appendIndex(binding substring (idx + 1))
-      map ++ (pkgs map (_ -> url))
-  }
-
   lazy val extUrlMapping: Map[String, String] = docExternalDoc.value flatMap { s =>
     val idx = s.indexOf("#")
     if (idx > 0) {
diff --git a/src/scaladoc/scala/tools/nsc/doc/model/MemberLookup.scala b/src/scaladoc/scala/tools/nsc/doc/model/MemberLookup.scala
index 23259a4ae8..339129bdbc 100644
--- a/src/scaladoc/scala/tools/nsc/doc/model/MemberLookup.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/model/MemberLookup.scala
@@ -49,13 +49,6 @@ trait MemberLookup extends base.MemberLookupBase {
       settings.extUrlMapping get path map { url =>
         LinkToExternal(name, url + "#" + name)
       }
-    } orElse {
-      // Deprecated option.
-      settings.extUrlPackageMapping find {
-        case (pkg, _) => name startsWith pkg
-      } map {
-        case (_, url) => LinkToExternal(name, url + "#" + name)
-      }
     }
   }