Merge branch 'merge-2.10.wip-x' into merge-2.10.x-master

* merge-2.10.wip-x: (24 commits)
  SI-6023 reify abstract vals
  Removing controversial `either` method from Futures API.
  SI-6695 Test case for fixed Array match bug
  adds comments to standard attachments
  SI-6673 fixes macro problems with eta expansions
  Restore the opimization apparently lost after merge.
  SI-6624 set info of case pattern binder to help find case field accessors
  Scaladoc update for collection.mutable.MultiMap
  SI-6663: don't ignore type parameter on selectDynamic invocation
  SI-6551: don't insert apply call in polymorphic expression.
  SI-6634 Fixes data corruption issue in ListBuffer#remove
  Fixes SI-6628, Revert "Fix for view isEmpty."
  SI-6661 - Remove obsolete implicit parameter of scala.concurrent.promise method
  Fixes SI-6150 - backport to 2.10.x branch.
  SI-5330, SI-6014 deal with existential self-type
  Fixes SI-6559 - StringContext not using passed in escape function.
  SI-6648 copyAttrs must preserve TypeTree#wasEmpty
  Fix raw string interpolator: string parts which were after the first argument were still escaped
  sane printing of renamed imports
  SI-6440 Address regressions around MissingRequirementError
  ...

Conflicts:
	src/library/scala/collection/generic/IndexedSeqFactory.scala
	src/library/scala/collection/mutable/ListBuffer.scala
	src/reflect/scala/reflect/internal/Symbols.scala
	src/reflect/scala/reflect/internal/Types.scala
	test/files/run/t6150.scala

58 files changed, 736 insertions, 180 deletions

diff --git a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
index 96ecf51e44..04f95455a5 100644
--- a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
+++ b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
@@ -455,28 +455,16 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
     def inheritanceDiagram = makeInheritanceDiagram(this)
     def contentDiagram = makeContentDiagram(this)
 
-    def groupSearch[T](extractor: Comment => T, default: T): T = {
-      // query this template
-      if (comment.isDefined) {
-        val entity = extractor(comment.get)
-        if (entity != default) return entity
+    def groupSearch[T](extractor: Comment => Option[T]): Option[T] = {
+      val comments = comment +: linearizationTemplates.collect { case dtpl: DocTemplateImpl => dtpl.comment }
+      comments.flatten.map(extractor).flatten.headOption orElse {
+        Option(inTpl) flatMap (_.groupSearch(extractor))
       }
-      // query linearization
-      if (!sym.isPackage)
-        for (tpl <- linearizationTemplates.collect{ case dtpl: DocTemplateImpl if dtpl!=this => dtpl}) {
-          val entity = tpl.groupSearch(extractor, default)
-          if (entity != default) return entity
-        }
-      // query inTpl, going up the ownerChain
-      if (inTpl != null)
-        inTpl.groupSearch(extractor, default)
-      else
-        default
     }
 
-    def groupDescription(group: String): Option[Body] = groupSearch(_.groupDesc.get(group), if (group == defaultGroup) defaultGroupDesc else None)
-    def groupPriority(group: String): Int = groupSearch(_.groupPrio.get(group) match { case Some(prio) => prio; case _ => 0 }, if (group == defaultGroup) defaultGroupPriority else 0)
-    def groupName(group: String): String = groupSearch(_.groupNames.get(group) match { case Some(name) => name; case _ => group }, if (group == defaultGroup) defaultGroupName else group)
+    def groupDescription(group: String): Option[Body] = groupSearch(_.groupDesc.get(group)) orElse { if (group == defaultGroup) defaultGroupDesc else None }
+    def groupPriority(group: String): Int = groupSearch(_.groupPrio.get(group)) getOrElse { if (group == defaultGroup) defaultGroupPriority else 0 }
+    def groupName(group: String): String = groupSearch(_.groupNames.get(group)) getOrElse { if (group == defaultGroup) defaultGroupName else group }
   }
 
   abstract class PackageImpl(sym: Symbol, inTpl: PackageImpl) extends DocTemplateImpl(sym, inTpl) with Package {
diff --git a/src/compiler/scala/tools/nsc/reporters/Reporter.scala b/src/compiler/scala/tools/nsc/reporters/Reporter.scala
index cddbd62994..817ec47ab3 100644
--- a/src/compiler/scala/tools/nsc/reporters/Reporter.scala
+++ b/src/compiler/scala/tools/nsc/reporters/Reporter.scala
@@ -19,9 +19,15 @@ abstract class Reporter {
   class Severity(val id: Int) extends severity.Value {
     var count: Int = 0
   }
-  val INFO    = new Severity(0)
-  val WARNING = new Severity(1)
-  val ERROR   = new Severity(2)
+  val INFO    = new Severity(0) {
+    override def toString: String = "INFO"
+  }
+  val WARNING = new Severity(1) {
+    override def toString: String = "WARNING"
+  }
+  val ERROR   = new Severity(2) {
+    override def toString: String = "ERROR"
+  }
 
   /** Whether very long lines can be truncated.  This exists so important
    *  debugging information (like printing the classpath) is not rendered
diff --git a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
index e67d6814f1..3ac5d388d3 100644
--- a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
@@ -373,6 +373,7 @@ trait MethodSynthesis {
         // spot that brand of them. In other words it's an artifact of the implementation.
         val tpt = derivedSym.tpe.finalResultType match {
           case ExistentialType(_, _)  => TypeTree()
+          case _ if mods.isDeferred   => TypeTree()
           case tp                     => TypeTree(tp)
         }
         tpt setPos derivedSym.pos.focus
diff --git a/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala b/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
index 76ff341d3f..c5245c4e9e 100644
--- a/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
@@ -414,7 +414,17 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
             // (the prefix of the argument passed to the unapply must equal the prefix of the type of the binder)
             val treeMaker = TypeTestTreeMaker(patBinder, patBinder, extractor.paramType, extractor.paramType)(pos, extractorArgTypeTest = true)
             (List(treeMaker), treeMaker.nextBinder)
-          } else (Nil, patBinder)
+          } else {
+            // no type test needed, but the tree maker relies on `patBinderOrCasted` having type `extractor.paramType` (and not just some type compatible with it)
+            // SI-6624 shows this is necessary because apparently patBinder may have an unfortunate type (.decls don't have the case field accessors)
+            // TODO: get to the bottom of this -- I assume it happens when type checking infers a weird type for an unapply call
+            // by going back to the parameterType for the extractor call we get a saner type, so let's just do that for now
+            /* TODO: uncomment when `settings.developer` and `devWarning` become available
+              if (settings.developer.value && !(patBinder.info =:= extractor.paramType))
+                devWarning(s"resetting info of $patBinder: ${patBinder.info} to ${extractor.paramType}")
+            */
+            (Nil, patBinder setInfo extractor.paramType)
+          }
 
         withSubPats(typeTestTreeMaker :+ extractor.treeMaker(patBinderOrCasted, pos), extractor.subBindersAndPatterns: _*)
       }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 1cfc8c909b..42c7d4a6b8 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -1058,6 +1058,10 @@ trait Typers extends Modes with Adaptations with Tags {
           instantiateToMethodType(mt)
 
         case _ =>
+          def shouldInsertApply(tree: Tree) = inAllModes(mode, EXPRmode | FUNmode) && (tree.tpe match {
+            case _: MethodType | _: OverloadedType | _: PolyType => false
+            case _                                               => applyPossible
+          })
           def applyPossible = {
             def applyMeth = member(adaptToName(tree, nme.apply), nme.apply)
             dyna.acceptsApplyDynamic(tree.tpe) || (
@@ -1071,14 +1075,12 @@ trait Typers extends Modes with Adaptations with Tags {
             adaptType()
           else if (
               inExprModeButNot(mode, FUNmode) && !tree.isDef &&   // typechecking application
-              tree.symbol != null && tree.symbol.isTermMacro)     // of a macro
+              tree.symbol != null && tree.symbol.isTermMacro &&   // of a macro
+              !tree.attachments.get[SuppressMacroExpansionAttachment.type].isDefined)
             macroExpand(this, tree, mode, pt)
           else if (inAllModes(mode, PATTERNmode | FUNmode))
             adaptConstrPattern()
-          else if (inAllModes(mode, EXPRmode | FUNmode) &&
-            !tree.tpe.isInstanceOf[MethodType] &&
-            !tree.tpe.isInstanceOf[OverloadedType] &&
-            applyPossible)
+          else if (shouldInsertApply(tree))
             insertApply()
           else if (!context.undetparams.isEmpty && !inPolyMode(mode)) { // (9)
             assert(!inHKMode(mode), modeString(mode)) //@M
@@ -3772,9 +3774,14 @@ trait Typers extends Modes with Adaptations with Tags {
             case t: ValOrDefDef => t.rhs
             case t              => t
           }
-          val (outer, explicitTargs) = cxTree1 match {
+          val cxTree2 = cxTree1 match {
+            case Typed(t, tpe)  => t // ignore outer type annotation
+            case t              => t
+          }
+          val (outer, explicitTargs) = cxTree2 match {
             case TypeApply(fun, targs)              => (fun, targs)
             case Apply(TypeApply(fun, targs), args) => (Apply(fun, args), targs)
+            case Select(TypeApply(fun, targs), nme) => (Select(fun, nme), targs)
             case t                                  => (t, Nil)
           }
           def hasNamedArg(as: List[Tree]) = as.collectFirst{case AssignOrNamedArg(lhs, rhs) =>}.nonEmpty
@@ -4855,9 +4862,9 @@ trait Typers extends Modes with Adaptations with Tags {
             // find out whether the programmer is trying to eta-expand a macro def
             // to do that we need to typecheck the tree first (we need a symbol of the eta-expandee)
             // that typecheck must not trigger macro expansions, so we explicitly prohibit them
-            // Q: "but, " - you may ask - ", `typed1` doesn't call adapt, which does macro expansion, so why explicit check?"
-            // A: solely for robustness reasons. this mechanism might change in the future, which might break unprotected code
-            val exprTyped = context.withMacrosDisabled(typed1(expr, mode, pt))
+            // however we cannot do `context.withMacrosDisabled`
+            // because `expr` might contain nested macro calls (see SI-6673)
+            val exprTyped = typed1(expr updateAttachment SuppressMacroExpansionAttachment, mode, pt)
             exprTyped match {
               case macroDef if macroDef.symbol != null && macroDef.symbol.isTermMacro && !macroDef.symbol.isErroneous =>
                 MacroEtaError(exprTyped)
@@ -5001,8 +5008,14 @@ trait Typers extends Modes with Adaptations with Tags {
       }
 
       def typedTypeTree(tree: TypeTree) = {
-        if (tree.original != null)
-          tree setType typedType(tree.original, mode).tpe
+        if (tree.original != null) {
+          val newTpt = typedType(tree.original, mode)
+          tree setType newTpt.tpe
+          newTpt match {
+            case tt @ TypeTree() => tree setOriginal tt.original
+            case _ => tree
+          }
+        } 
         else
           // we should get here only when something before failed
           // and we try again (@see tryTypedApply). In that case we can assign
diff --git a/src/library/scala/collection/IterableLike.scala b/src/library/scala/collection/IterableLike.scala
index 8d1fa80815..540bd84b79 100644
--- a/src/library/scala/collection/IterableLike.scala
+++ b/src/library/scala/collection/IterableLike.scala
@@ -171,7 +171,7 @@ self =>
    *          fewer elements than size.
    */
   def sliding(size: Int): Iterator[Repr] = sliding(size, 1)
-
+  
   /** Groups elements in fixed size blocks by passing a "sliding window"
    *  over them (as opposed to partitioning them, as is done in grouped.)
    *  @see [[scala.collection.Iterator]], method `sliding`
@@ -293,7 +293,6 @@ self =>
 
   override /*TraversableLike*/ def view = new IterableView[A, Repr] {
     protected lazy val underlying = self.repr
-    override def isEmpty = self.isEmpty
     override def iterator = self.iterator
   }
 
diff --git a/src/library/scala/collection/SeqLike.scala b/src/library/scala/collection/SeqLike.scala
index 48e1e04c44..603e0b6497 100644
--- a/src/library/scala/collection/SeqLike.scala
+++ b/src/library/scala/collection/SeqLike.scala
@@ -630,7 +630,6 @@ trait SeqLike[+A, +Repr] extends Any with IterableLike[A, Repr] with GenSeqLike[
 
   override def view = new SeqView[A, Repr] {
     protected lazy val underlying = self.repr
-    override def isEmpty = self.isEmpty
     override def iterator = self.iterator
     override def length = self.length
     override def apply(idx: Int) = self.apply(idx)
diff --git a/src/library/scala/collection/TraversableLike.scala b/src/library/scala/collection/TraversableLike.scala
index 5ea1faa0df..c1a68b6b16 100644
--- a/src/library/scala/collection/TraversableLike.scala
+++ b/src/library/scala/collection/TraversableLike.scala
@@ -660,7 +660,6 @@ trait TraversableLike[+A, +Repr] extends Any
   def view = new TraversableView[A, Repr] {
     protected lazy val underlying = self.repr
     override def foreach[U](f: A => U) = self foreach f
-    override def isEmpty = self.isEmpty
   }
 
   /** Creates a non-strict view of a slice of this $coll.
diff --git a/src/library/scala/collection/TraversableViewLike.scala b/src/library/scala/collection/TraversableViewLike.scala
index 6846a505bf..36f6210ef4 100644
--- a/src/library/scala/collection/TraversableViewLike.scala
+++ b/src/library/scala/collection/TraversableViewLike.scala
@@ -192,15 +192,6 @@ trait TraversableViewLike[+A,
   override def span(p: A => Boolean): (This, This) = (newTakenWhile(p), newDroppedWhile(p))
   override def splitAt(n: Int): (This, This) = (newTaken(n), newDropped(n))
 
-  // Without this, isEmpty tests go back to the Traversable default, which
-  // involves starting a foreach, which can force the first element of the
-  // view. This is just a backstop - it's overridden at all the "def view"
-  // instantiation points in the collections where the Coll type is known.
-  override def isEmpty = underlying match {
-    case x: GenTraversableOnce[_] => x.isEmpty
-    case _                        => super.isEmpty
-  }
-
   override def scanLeft[B, That](z: B)(op: (B, A) => B)(implicit bf: CanBuildFrom[This, B, That]): That =
     newForced(thisSeq.scanLeft(z)(op)).asInstanceOf[That]
 
diff --git a/src/library/scala/collection/generic/GenTraversableFactory.scala b/src/library/scala/collection/generic/GenTraversableFactory.scala
index 318780ef6d..b36dd3ccaf 100644
--- a/src/library/scala/collection/generic/GenTraversableFactory.scala
+++ b/src/library/scala/collection/generic/GenTraversableFactory.scala
@@ -36,7 +36,7 @@ import scala.language.higherKinds
  *    @see GenericCanBuildFrom
  */
 abstract class GenTraversableFactory[CC[X] <: GenTraversable[X] with GenericTraversableTemplate[X, CC]]
-  extends GenericCompanion[CC] {
+extends GenericCompanion[CC] {
 
   private[this] val ReusableCBFInstance: GenericCanBuildFrom[Nothing] = new GenericCanBuildFrom[Nothing] {
     override def apply() = newBuilder[Nothing]
diff --git a/src/library/scala/collection/generic/IndexedSeqFactory.scala b/src/library/scala/collection/generic/IndexedSeqFactory.scala
index e5162c640b..200d033c2d 100644
--- a/src/library/scala/collection/generic/IndexedSeqFactory.scala
+++ b/src/library/scala/collection/generic/IndexedSeqFactory.scala
@@ -13,7 +13,7 @@ import language.higherKinds
 
 /** A template for companion objects of IndexedSeq and subclasses thereof.
  *
- *  @since 2.8
+ *  @since 2.10
  */
 abstract class IndexedSeqFactory[CC[X] <: IndexedSeq[X] with GenericTraversableTemplate[X, CC]] extends SeqFactory[CC] {
   override def ReusableCBF: GenericCanBuildFrom[Nothing] =
diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala
index e520ddc27c..3f7d27981b 100644
--- a/src/library/scala/collection/immutable/Stream.scala
+++ b/src/library/scala/collection/immutable/Stream.scala
@@ -969,7 +969,6 @@ self =>
 
   override def view = new StreamView[A, Stream[A]] {
     protected lazy val underlying = self.repr
-    override def isEmpty = self.isEmpty
     override def iterator = self.iterator
     override def length = self.length
     override def apply(idx: Int) = self.apply(idx)
diff --git a/src/library/scala/collection/mutable/IndexedSeqLike.scala b/src/library/scala/collection/mutable/IndexedSeqLike.scala
index c5d0f58b94..7b582eb5cb 100644
--- a/src/library/scala/collection/mutable/IndexedSeqLike.scala
+++ b/src/library/scala/collection/mutable/IndexedSeqLike.scala
@@ -50,7 +50,6 @@ trait IndexedSeqLike[A, +Repr] extends Any with scala.collection.IndexedSeqLike[
    */
   override def view = new IndexedSeqView[A, Repr] {
     protected lazy val underlying = self.repr
-    override def isEmpty = self.isEmpty
     override def iterator = self.iterator
     override def length = self.length
     override def apply(idx: Int) = self.apply(idx)
diff --git a/src/library/scala/collection/mutable/ListBuffer.scala b/src/library/scala/collection/mutable/ListBuffer.scala
index bc38768e29..b7b487964c 100644
--- a/src/library/scala/collection/mutable/ListBuffer.scala
+++ b/src/library/scala/collection/mutable/ListBuffer.scala
@@ -135,29 +135,27 @@ final class ListBuffer[A]
    *  @throws Predef.IndexOutOfBoundsException if `n` is out of bounds.
    */
   def update(n: Int, x: A) {
-    try {
-      if (exported) copy()
-      if (n == 0) {
-        val newElem = new :: (x, start.tail);
-        if ((last0 eq null) || (last0 eq start)) {
-          last0 = newElem
-        }
-        start = newElem
-      } else {
-        var cursor = start
-        var i = 1
-        while (i < n) {
-          cursor = cursor.tail
-          i += 1
-        }
-        val newElem = new :: (x, cursor.tail.tail)
-        if (last0 eq cursor.tail) {
-          last0 = newElem
-        }
-        cursor.asInstanceOf[::[A]].tl = newElem
+    // We check the bounds early, so that we don't trigger copying.
+    if (n < 0 || n >= len) throw new IndexOutOfBoundsException(n.toString)
+    if (exported) copy()
+    if (n == 0) {
+      val newElem = new :: (x, start.tail);
+      if (last0 eq start) {
+        last0 = newElem
+      }
+      start = newElem
+    } else {
+      var cursor = start
+      var i = 1
+      while (i < n) {
+        cursor = cursor.tail
+        i += 1
+      }
+      val newElem = new :: (x, cursor.tail.tail)
+      if (last0 eq cursor.tail) {
+        last0 = newElem
       }
-    } catch {
-      case ex: Exception => throw new IndexOutOfBoundsException(n.toString())
+      cursor.asInstanceOf[::[A]].tl = newElem
     }
   }
 
@@ -219,34 +217,31 @@ final class ListBuffer[A]
    *  @throws Predef.IndexOutOfBoundsException if `n` is out of bounds.
    */
   def insertAll(n: Int, seq: Traversable[A]) {
-    try {
-      if (exported) copy()
-      var elems = seq.toList.reverse
-      len += elems.length
-      if (n == 0) {
-        while (!elems.isEmpty) {
-          val newElem = new :: (elems.head, start)
-          if (isEmpty) last0 = newElem
-          start = newElem
-          elems = elems.tail
-        }
-      } else {
-        var cursor = start
-        var i = 1
-        while (i < n) {
-          cursor = cursor.tail
-          i += 1
-        }
-        while (!elems.isEmpty) {
-          val newElem = new :: (elems.head, cursor.tail)
-          if (cursor.tail.isEmpty) last0 = newElem
-          cursor.asInstanceOf[::[A]].tl = newElem
-          elems = elems.tail
-        }
+    // We check the bounds early, so that we don't trigger copying.
+    if (n < 0 || n > len) throw new IndexOutOfBoundsException(n.toString)
+    if (exported) copy()
+    var elems = seq.toList.reverse
+    len += elems.length
+    if (n == 0) {
+      while (!elems.isEmpty) {
+        val newElem = new :: (elems.head, start)
+        if (start.isEmpty) last0 = newElem
+        start = newElem
+        elems = elems.tail
+      }
+    } else {
+      var cursor = start
+      var i = 1
+      while (i < n) {
+        cursor = cursor.tail
+        i += 1
+      }
+      while (!elems.isEmpty) {
+        val newElem = new :: (elems.head, cursor.tail)
+        if (cursor.tail.isEmpty) last0 = newElem
+        cursor.asInstanceOf[::[A]].tl = newElem
+        elems = elems.tail
       }
-    } catch {
-      case ex: Exception =>
-        throw new IndexOutOfBoundsException(n.toString())
     }
   }
 
@@ -265,7 +260,12 @@ final class ListBuffer[A]
    *  @param n         the index which refers to the first element to remove.
    *  @param count     the number of elements to remove.
    */
+  @annotation.migration("Invalid input values will be rejected in future releases.", "2.11")
   override def remove(n: Int, count: Int) {
+    if (n >= len)
+      return
+    if (count < 0)
+      throw new IllegalArgumentException(s"removing negative number ($count) of elements")
     if (exported) copy()
     val n1 = n max 0
     val count1 = count min (len - n1)
diff --git a/src/library/scala/collection/mutable/MultiMap.scala b/src/library/scala/collection/mutable/MultiMap.scala
index 31c8a50a84..4635bfbe64 100644
--- a/src/library/scala/collection/mutable/MultiMap.scala
+++ b/src/library/scala/collection/mutable/MultiMap.scala
@@ -15,8 +15,36 @@ package mutable
 /** A trait for mutable maps with multiple values assigned to a key.
  *
  *  This class is typically used as a mixin. It turns maps which map `A`
- *  to `Set[B]` objects into multi maps which map `A` to
- *  `B` objects.
+ *  to `Set[B]` objects into multimaps that map `A` to `B` objects.
+ *
+ *  @example {{{
+ *  // first import all necessary types from package `collection.mutable`
+ *  import collection.mutable.{ HashMap, MultiMap, Set }
+ *
+ *  // to create a `MultiMap` the easiest way is to mixin it into a normal
+ *  // `Map` instance
+ *  val mm = new HashMap[Int, Set[String]] with MultiMap[Int, String]
+ *
+ *  // to add key-value pairs to a multimap it is important to use
+ *  // the method `addBinding` because standard methods like `+` will
+ *  // overwrite the complete key-value pair instead of adding the
+ *  // value to the existing key
+ *  mm.addBinding(1, "a")
+ *  mm.addBinding(2, "b")
+ *  mm.addBinding(1, "c")
+ *
+ *  // mm now contains `Map(2 -> Set(b), 1 -> Set(c, a))`
+ *
+ *  // to check if the multimap contains a value there is method
+ *  // `entryExists`, which allows to traverse the including set
+ *  mm.entryExists(1, _ == "a") == true
+ *  mm.entryExists(1, _ == "b") == false
+ *  mm.entryExists(2, _ == "b") == true
+ *
+ *  // to remove a previous added value there is the method `removeBinding`
+ *  mm.removeBinding(1, "a")
+ *  mm.entryExists(1, _ == "a") == false
+ *  }}}
  *
  *  @define coll multimap
  *  @define Coll `MultiMap`
@@ -57,7 +85,8 @@ trait MultiMap[A, B] extends Map[A, Set[B]] {
     this
   }
 
-  /** Removes the binding of `value` to `key` if it exists.
+  /** Removes the binding of `value` to `key` if it exists, otherwise this
+   *  operation doesn't have any effect.
    *
    *  If this was the last value assigned to the specified key, the
    *  set assigned to that key will be removed as well.
diff --git a/src/library/scala/collection/parallel/ParIterableLike.scala b/src/library/scala/collection/parallel/ParIterableLike.scala
index be9c934402..d77e5a6744 100644
--- a/src/library/scala/collection/parallel/ParIterableLike.scala
+++ b/src/library/scala/collection/parallel/ParIterableLike.scala
@@ -849,7 +849,6 @@ self: ParIterableLike[T, Repr, Sequential] =>
     override def seq = self.seq.view
     def splitter = self.splitter
     def size = splitter.remaining
-    override def isEmpty = size == 0
   }
 
   override def toArray[U >: T: ClassTag]: Array[U] = {
diff --git a/src/library/scala/collection/parallel/ParSeqLike.scala b/src/library/scala/collection/parallel/ParSeqLike.scala
index 4f1c3fa7a2..201b624c72 100644
--- a/src/library/scala/collection/parallel/ParSeqLike.scala
+++ b/src/library/scala/collection/parallel/ParSeqLike.scala
@@ -44,7 +44,7 @@ trait ParSeqLike[+T, +Repr <: ParSeq[T], +Sequential <: Seq[T] with SeqLike[T, S
 extends scala.collection.GenSeqLike[T, Repr]
    with ParIterableLike[T, Repr, Sequential] {
 self =>
-
+  
   type SuperParIterator = IterableSplitter[T]
 
   /** A more refined version of the iterator found in the `ParallelIterable` trait,
@@ -330,7 +330,6 @@ self =>
     def apply(idx: Int) = self(idx)
     override def seq = self.seq.view
     def splitter = self.splitter
-    override def isEmpty = size == 0
   }
 
   /* tasks */
diff --git a/src/library/scala/concurrent/Future.scala b/src/library/scala/concurrent/Future.scala
index 320a4f22b8..4b9e74708d 100644
--- a/src/library/scala/concurrent/Future.scala
+++ b/src/library/scala/concurrent/Future.scala
@@ -522,29 +522,6 @@ trait Future[+T] extends Awaitable[T] {
     p.future
   }
 
-  /** Creates a new future which holds the result of either this future or `that` future, depending on
-   *  which future was completed first.
-   *
-   *  $nonDeterministic
-   *
-   *  Example:
-   *  {{{
-   *  val f = future { sys.error("failed") }
-   *  val g = future { 5 }
-   *  val h = f either g
-   *  await(h, 0) // evaluates to either 5 or throws a runtime exception
-   *  }}}
-   */
-  def either[U >: T](that: Future[U]): Future[U] = {
-    val p = Promise[U]()
-    val completePromise: PartialFunction[Try[U], _] = { case result => p tryComplete result }
-
-    this onComplete completePromise
-    that onComplete completePromise
-
-    p.future
-  }
-
 }
 
 
diff --git a/src/library/scala/concurrent/package.scala b/src/library/scala/concurrent/package.scala
index f7c732b851..3e849f1722 100644
--- a/src/library/scala/concurrent/package.scala
+++ b/src/library/scala/concurrent/package.scala
@@ -29,13 +29,12 @@ package object concurrent {
    */
   def future[T](body: =>T)(implicit execctx: ExecutionContext): Future[T] = Future[T](body)
 
-  /** Creates a promise object which can be completed with a value.
+  /** Creates a promise object which can be completed with a value or an exception.
    *  
    *  @tparam T       the type of the value in the promise
-   *  @param execctx  the execution context on which the promise is created on
    *  @return         the newly created `Promise` object
    */
-  def promise[T]()(implicit execctx: ExecutionContext): Promise[T] = Promise[T]()
+  def promise[T](): Promise[T] = Promise[T]()
 
   /** Used to designate a piece of code which potentially blocks, allowing the current [[BlockContext]] to adjust
    *  the runtime's behavior.
diff --git a/src/partest/scala/tools/partest/DirectTest.scala b/src/partest/scala/tools/partest/DirectTest.scala
index 554e7848c7..8c18809ad6 100644
--- a/src/partest/scala/tools/partest/DirectTest.scala
+++ b/src/partest/scala/tools/partest/DirectTest.scala
@@ -8,6 +8,7 @@ package scala.tools.partest
 import scala.tools.nsc._
 import io.Directory
 import util.{BatchSourceFile, CommandLineParser}
+import reporters.{Reporter, ConsoleReporter}
 
 /** A class for testing code which is embedded as a string.
  *  It allows for more complete control over settings, compiler
@@ -38,9 +39,12 @@ abstract class DirectTest extends App {
   // new compiler
   def newCompiler(args: String*): Global = {
     val settings = newSettings((CommandLineParser tokenize ("-d \"" + testOutput.path + "\" " + extraSettings)) ++ args.toList)
-    if (settings.Yrangepos.value) new Global(settings) with interactive.RangePositions
-    else new Global(settings)
+    if (settings.Yrangepos.value) new Global(settings, reporter(settings)) with interactive.RangePositions
+    else new Global(settings, reporter(settings))
   }
+
+  def reporter(settings: Settings): Reporter = new ConsoleReporter(settings)
+
   def newSources(sourceCodes: String*) = sourceCodes.toList.zipWithIndex map {
     case (src, idx) => new BatchSourceFile("newSource" + (idx + 1), src)
   }
diff --git a/src/partest/scala/tools/partest/StoreReporterDirectTest.scala b/src/partest/scala/tools/partest/StoreReporterDirectTest.scala
new file mode 100644
index 0000000000..7f3604c86c
--- /dev/null
+++ b/src/partest/scala/tools/partest/StoreReporterDirectTest.scala
@@ -0,0 +1,15 @@
+package scala.tools.partest
+
+import scala.tools.nsc.Settings
+import scala.tools.nsc.reporters.StoreReporter
+import scala.collection.mutable
+
+trait StoreReporterDirectTest extends DirectTest {
+  lazy val storeReporter: StoreReporter = new scala.tools.nsc.reporters.StoreReporter()
+
+  /** Discards all but the first message issued at a given position. */
+  def filteredInfos: Seq[storeReporter.Info] = storeReporter.infos.groupBy(_.pos).map(_._2.head).toList
+
+  /** Hook into [[scala.tools.partest.DirectTest]] to install the custom reporter */
+  override def reporter(settings: Settings) = storeReporter
+}
diff --git a/src/reflect/scala/reflect/internal/Printers.scala b/src/reflect/scala/reflect/internal/Printers.scala
index 08ba93520a..c36724e388 100644
--- a/src/reflect/scala/reflect/internal/Printers.scala
+++ b/src/reflect/scala/reflect/internal/Printers.scala
@@ -559,8 +559,11 @@ trait Printers extends api.Printers { self: SymbolTable =>
                   if (isError) print(": error>")
                 } else if (hasSymbolField) {
                   tree match {
-                    case _: Ident | _: Select | _: SelectFromTypeTree => print(tree.symbol)
-                    case _ => print(tree.symbol.name)
+                    case refTree: RefTree =>
+                      if (tree.symbol.name != refTree.name) print("[", tree.symbol, " aka ", refTree.name, "]")
+                      else print(tree.symbol)
+                    case _ =>
+                      print(tree.symbol.name)
                   }
                 } else {
                   print(name)
diff --git a/src/reflect/scala/reflect/internal/StdAttachments.scala b/src/reflect/scala/reflect/internal/StdAttachments.scala
index 9fe443bf50..1df91a67b0 100644
--- a/src/reflect/scala/reflect/internal/StdAttachments.scala
+++ b/src/reflect/scala/reflect/internal/StdAttachments.scala
@@ -19,9 +19,26 @@ trait StdAttachments {
     def setPos(newpos: Position): this.type = { pos = newpos; this }
   }
 
+  /** When present, indicates that the host `Ident` has been created from a backquoted identifier.
+   */
   case object BackquotedIdentifierAttachment
 
+  /** Stores the trees that give rise to a refined type to be used in reification.
+   *  Unfortunately typed `CompoundTypeTree` is lacking essential info, and the reifier cannot use `CompoundTypeTree.tpe`.
+   *  Therefore we need this hack (see `Reshape.toPreTyperTypeTree` for a detailed explanation).
+   */
   case class CompoundTypeTreeOriginalAttachment(parents: List[Tree], stats: List[Tree])
 
+  /** Is added by the macro engine to the results of macro expansions.
+   *  Stores the original expandee as it entered the `macroExpand` function.
+   */
   case class MacroExpansionAttachment(original: Tree)
+
+  /** When present, suppresses macro expansion for the host.
+   *  This is occasionally necessary, e.g. to prohibit eta-expansion of macros.
+   *
+   *  Does not affect expandability of child nodes, there's context.withMacrosDisabled for that
+   *  (but think thrice before using that API - see the discussion at https://github.com/scala/scala/pull/1639).
+   */
+  case object SuppressMacroExpansionAttachment
 }
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index 032c75f6df..ad7dbe5ef1 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -404,9 +404,9 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
      *  failure to the point when that name is used for something, which is
      *  often to the point of never.
      */
-    def newStubSymbol(name: Name): Symbol = name match {
-      case n: TypeName  => new StubClassSymbol(this, n)
-      case _            => new StubTermSymbol(this, name.toTermName)
+    def newStubSymbol(name: Name, missingMessage: String): Symbol = name match {
+      case n: TypeName  => new StubClassSymbol(this, n, missingMessage)
+      case _            => new StubTermSymbol(this, name.toTermName, missingMessage)
     }
 
     @deprecated("Use the other signature", "2.10.0")
@@ -1360,6 +1360,9 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       }
     }
 
+    /** Raises a `MissingRequirementError` if this symbol is a `StubSymbol` */
+    def failIfStub() {}
+
     /** Initialize the symbol */
     final def initialize: this.type = {
       if (!isInitialized) info
@@ -3066,14 +3069,20 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     )
   }
   trait StubSymbol extends Symbol {
-    protected def stubWarning = {
-      val from = if (associatedFile == null) "" else s" - referenced from ${associatedFile.canonicalPath}"
-      s"$kindString $nameString$locationString$from (a classfile may be missing)"
-    }
+    devWarning("creating stub symbol to defer error: " + missingMessage)
+
+    protected def missingMessage: String
+
+    /** Fail the stub by throwing a [[scala.reflect.internal.MissingRequirementError]]. */
+    override final def failIfStub() = {MissingRequirementError.signal(missingMessage)} //
+
+    /** Fail the stub by reporting an error to the reporter, setting the IS_ERROR flag
+      * on this symbol, and returning the dummy value `alt`.
+      */
     private def fail[T](alt: T): T = {
       // Avoid issuing lots of redundant errors
       if (!hasFlag(IS_ERROR)) {
-        globalError(s"bad symbolic reference to " + stubWarning)
+        globalError(missingMessage)
         if (settings.debug.value)
           (new Throwable).printStackTrace
 
@@ -3089,13 +3098,9 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     override def info            = fail(NoType)
     override def rawInfo         = fail(NoType)
     override def companionSymbol = fail(NoSymbol)
-
-    locally {
-      devWarning("creating stub symbol for " + stubWarning)
-    }
   }
-  class StubClassSymbol(owner0: Symbol, name0: TypeName) extends ClassSymbol(owner0, owner0.pos, name0) with StubSymbol
-  class StubTermSymbol(owner0: Symbol, name0: TermName) extends TermSymbol(owner0, owner0.pos, name0) with StubSymbol
+  class StubClassSymbol(owner0: Symbol, name0: TypeName, protected val missingMessage: String) extends ClassSymbol(owner0, owner0.pos, name0) with StubSymbol
+  class StubTermSymbol(owner0: Symbol, name0: TermName, protected val missingMessage: String) extends TermSymbol(owner0, owner0.pos, name0) with StubSymbol
 
   trait FreeSymbol extends Symbol {
     def origin: String
diff --git a/src/reflect/scala/reflect/internal/Trees.scala b/src/reflect/scala/reflect/internal/Trees.scala
index 50b07f0cc8..f944e1d5d1 100644
--- a/src/reflect/scala/reflect/internal/Trees.scala
+++ b/src/reflect/scala/reflect/internal/Trees.scala
@@ -493,6 +493,10 @@ trait Trees extends api.Trees { self: SymbolTable =>
 
   case class TypeTree() extends TypTree with TypeTreeContextApi {
     private var orig: Tree = null
+    /** Was this type tree originally empty? That is, does it now contain
+      * an inferred type that must be forgotten in `resetAttrs` to
+      * enable retyping.
+      */
     private[scala] var wasEmpty: Boolean = false
 
     override def symbol = typeTreeSymbol(this) // if (tpe == null) null else tpe.typeSymbol
@@ -513,6 +517,15 @@ trait Trees extends api.Trees { self: SymbolTable =>
       wasEmpty = isEmpty
       setType(tp)
     }
+
+    override private[scala] def copyAttrs(tree: Tree) = {
+      super.copyAttrs(tree)
+      tree match {
+        case other: TypeTree => wasEmpty = other.wasEmpty // SI-6648 Critical for correct operation of `resetAttrs`.
+        case _ =>
+      }
+      this
+    }
   }
   object TypeTree extends TypeTreeExtractor
 
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index 8bcccbf33e..09fc534d8a 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -1334,7 +1334,12 @@ trait Types extends api.Types { self: SymbolTable =>
   /** A class for this-types of the form <sym>.this.type
    */
   abstract case class ThisType(sym: Symbol) extends SingletonType with ThisTypeApi {
-    assert(sym.isClass, sym)
+    if (!sym.isClass) {
+      // SI-6640 allow StubSymbols to reveal what's missing from the classpath before we trip the assertion.
+      sym.failIfStub()
+      assert(false, sym)
+    }
+
     override def isTrivial: Boolean = sym.isPackageClass
     override def isNotNull = true
     override def typeSymbol = sym
diff --git a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
index 2dab9b37b4..5a0454a569 100644
--- a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
+++ b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
@@ -20,7 +20,7 @@ import scala.annotation.switch
 /** @author Martin Odersky
  *  @version 1.0
  */
-abstract class UnPickler /*extends scala.reflect.generic.UnPickler*/ {
+abstract class UnPickler {
   val global: SymbolTable
   import global._
 
@@ -232,7 +232,12 @@ abstract class UnPickler /*extends scala.reflect.generic.UnPickler*/ {
               // (4) Call the mirror's "missing" hook.
               adjust(mirrorThatLoaded(owner).missingHook(owner, name)) orElse {
                 // (5) Create a stub symbol to defer hard failure a little longer.
-                owner.newStubSymbol(name)
+                val missingMessage =
+                  s"""|bad symbolic reference. A signature in $filename refers to ${name.longString}
+                      |in ${owner.kindString} ${owner.fullName} which is not available.
+                      |It may be completely missing from the current classpath, or the version on
+                      |the classpath might be incompatible with the version used when compiling $filename.""".stripMargin
+                owner.newStubSymbol(name, missingMessage)
               }
             }
           }
diff --git a/test/files/neg/t5148.check b/test/files/neg/t5148.check
index 6edfdf2b1e..25107c4dbe 100644
--- a/test/files/neg/t5148.check
+++ b/test/files/neg/t5148.check
@@ -1,3 +1,9 @@
-error: bad symbolic reference to value global in class IMain - referenced from t5148.scala (a classfile may be missing)
-error: bad symbolic reference to value memberHandlers in class IMain - referenced from t5148.scala (a classfile may be missing)
+error: bad symbolic reference. A signature in Imports.class refers to term global
+in class scala.tools.nsc.interpreter.IMain which is not available.
+It may be completely missing from the current classpath, or the version on
+the classpath might be incompatible with the version used when compiling Imports.class.
+error: bad symbolic reference. A signature in Imports.class refers to term memberHandlers
+in class scala.tools.nsc.interpreter.IMain which is not available.
+It may be completely missing from the current classpath, or the version on
+the classpath might be incompatible with the version used when compiling Imports.class.
 two errors found
diff --git a/test/files/neg/t6663.check b/test/files/neg/t6663.check
new file mode 100644
index 0000000000..aa4faa4a46
--- /dev/null
+++ b/test/files/neg/t6663.check
@@ -0,0 +1,6 @@
+t6663.scala:16: error: type mismatch;
+ found   : String
+ required: Int
+  var v = new C(42).foo[String].get :Int
+                                ^
+one error found
diff --git a/test/files/neg/t6663.scala b/test/files/neg/t6663.scala
new file mode 100644
index 0000000000..4a358dfbc5
--- /dev/null
+++ b/test/files/neg/t6663.scala
@@ -0,0 +1,19 @@
+import language.dynamics
+
+class C(v: Any) extends Dynamic {
+  def selectDynamic[T](n: String): Option[T] = Option(v.asInstanceOf[T])
+  def applyDynamic[T](n: String)(): Option[T] = Option(v.asInstanceOf[T])
+}
+
+object Test extends App {
+  // this should be converted to
+  // C(42).selectDynamic[String]("foo").get
+  // causing a compile error.
+
+  // but, before fixing SI-6663, became
+  // C(42).selectDynamic("foo").get, ignoring
+  // the [String] type parameter
+  var v = new C(42).foo[String].get :Int
+  println(v)
+}
+
diff --git a/test/files/pos/t6551.scala b/test/files/pos/t6551.scala
new file mode 100644
index 0000000000..fb68663809
--- /dev/null
+++ b/test/files/pos/t6551.scala
@@ -0,0 +1,13 @@
+import language.dynamics
+
+object Test {
+  def main(args: Array[String]) {
+    class Lenser[T] extends Dynamic {
+      def selectDynamic(propName: String) = ???
+    }
+
+    def lens[T] = new Lenser[T]
+
+    val qq = lens[String]
+  }
+}
diff --git a/test/files/pos/t6624.scala b/test/files/pos/t6624.scala
new file mode 100644
index 0000000000..1a92b92d53
--- /dev/null
+++ b/test/files/pos/t6624.scala
@@ -0,0 +1,28 @@
+sealed trait KList[+M[_]]
+
+case class KCons[M[_], +T <: KList[M]](
+  tail: T
+) extends KList[M]
+
+case class KNil[M[_]]() extends KList[M]
+
+object Test {
+  val klist: KCons[Option, KCons[Option, KCons[Option, KNil[Nothing]]]] = ???
+
+  // crashes with
+  // "Exception in thread "main" scala.reflect.internal.Types$TypeError: value _1 is not a member 
+  // of KCons[Option,KCons[Option,KNil[Nothing]]]"
+  klist match {
+   case KCons(KCons(KCons(_))) =>
+  }
+
+  // fails with a similar message as an error, rather than a crash.
+  klist match {
+    case KCons(KCons(_)) =>
+  }
+
+  // succeeds
+  klist match {
+    case KCons(_) =>
+  }
+}
\ No newline at end of file
diff --git a/test/files/pos/t6648.scala b/test/files/pos/t6648.scala
new file mode 100644
index 0000000000..9593ebfee9
--- /dev/null
+++ b/test/files/pos/t6648.scala
@@ -0,0 +1,24 @@
+abstract class Node extends NodeSeq
+trait NodeSeq extends Seq[Node]
+object NodeSeq {
+  implicit def seqToNodeSeq(ns: Seq[Node]): NodeSeq = ???
+   def foo[B, That](f: Seq[B])(implicit bf: scala.collection.generic.CanBuildFrom[Seq[Int], B, That]): That = ???
+}
+
+class Transformer {
+  def apply(nodes: Any): Any = ???
+}
+
+object transformer1 extends Transformer {
+  // Adding explicit type arguments, or making the impilcit view
+  // seqToNodeSeq explicit avoids the crash
+  NodeSeq.foo {
+    // These both avoid the crash:
+    // val t = new Transformer {}; t.apply(null)
+    // new Transformer().apply(null)
+    new Transformer {}.apply(null)
+
+    null: NodeSeq
+  }: NodeSeq
+}
+
diff --git a/test/files/run/showraw_aliases.check b/test/files/run/showraw_aliases.check
new file mode 100644
index 0000000000..1838bf9bec
--- /dev/null
+++ b/test/files/run/showraw_aliases.check
@@ -0,0 +1,2 @@
+Block(List(Import(Select(Select(Ident(scala), scala.reflect), scala.reflect.runtime), List(ImportSelector(newTermName("universe"), 52, newTermName("ru"), 64)))), Select(Select(Select(Select(Ident(scala), scala.reflect), scala.reflect.runtime), scala.reflect.runtime.package), [newTermName("universe") aka newTermName("ru")]))
+Block(List(Import(Select(Select(Ident(scala#<id>), scala.reflect#<id>), scala.reflect.runtime#<id>), List(ImportSelector(newTermName("universe"), 52, newTermName("ru"), 64)))), Select(Select(Select(Select(Ident(scala#<id>), scala.reflect#<id>), scala.reflect.runtime#<id>), scala.reflect.runtime.package#<id>), [newTermName("universe")#<id> aka newTermName("ru")]))
diff --git a/test/files/run/showraw_aliases.scala b/test/files/run/showraw_aliases.scala
new file mode 100644
index 0000000000..3a68ca37b2
--- /dev/null
+++ b/test/files/run/showraw_aliases.scala
@@ -0,0 +1,15 @@
+import scala.reflect.runtime.universe._
+import scala.tools.reflect.ToolBox
+
+object Test extends App {
+  val tb = runtimeMirror(getClass.getClassLoader).mkToolBox()
+  val tree = tb.parse("""
+    import scala.reflect.runtime.{universe => ru}
+    ru
+  """)
+  val ttree = tb.typeCheck(tree)
+
+  def stabilize(s: String) = """#\d+""".r.replaceAllIn(s, "#<id>")
+  println(showRaw(ttree))
+  println(stabilize(showRaw(ttree, printIds = true)))
+}
\ No newline at end of file
diff --git a/test/files/run/t6023.check b/test/files/run/t6023.check
new file mode 100644
index 0000000000..ee93565234
--- /dev/null
+++ b/test/files/run/t6023.check
@@ -0,0 +1,12 @@
+{
+  abstract trait Foo extends AnyRef {
+    <stable> <accessor> def a: Int
+  };
+  ()
+}
+{
+  abstract trait Foo extends AnyRef {
+    <stable> <accessor> def a: Int
+  };
+  ()
+}
diff --git a/test/files/run/t6023.scala b/test/files/run/t6023.scala
new file mode 100644
index 0000000000..07af3685a5
--- /dev/null
+++ b/test/files/run/t6023.scala
@@ -0,0 +1,17 @@
+import scala.reflect.runtime.universe._
+import scala.reflect.runtime.{currentMirror => cm}
+import scala.tools.reflect.ToolBox
+
+object Test extends App {
+  // test 1: reify
+  val tree = reify{ trait Foo { val a: Int } }.tree
+  println(tree.toString)
+
+  // test 2: import and typecheck
+  val toolbox = cm.mkToolBox()
+  val ttree = toolbox.typeCheck(tree)
+  println(ttree.toString)
+
+  // test 3: import and compile
+  toolbox.eval(tree)
+}
diff --git a/test/files/run/t6440.check b/test/files/run/t6440.check
index b5684daee4..69c253eab4 100644
--- a/test/files/run/t6440.check
+++ b/test/files/run/t6440.check
@@ -1 +1,4 @@
-Stream((), ?)
+pos: source-newSource1,line-9,offset=109 bad symbolic reference. A signature in U.class refers to term pack1
+in package <root> which is not available.
+It may be completely missing from the current classpath, or the version on
+the classpath might be incompatible with the version used when compiling U.class. ERROR
diff --git a/test/files/run/t6440.scala b/test/files/run/t6440.scala
index 2b690f31e1..5a3a4150d9 100644
--- a/test/files/run/t6440.scala
+++ b/test/files/run/t6440.scala
@@ -1,7 +1,48 @@
-object Test {
+import scala.tools.partest._
+import java.io.File
 
-  def main(args: Array[String]): Unit = {
-    println(Stream.continually(()).filterNot(_ => false).take(2))
+object Test extends StoreReporterDirectTest {
+  def code = ???
+
+  def compileCode(code: String) = {
+    val classpath = List(sys.props("partest.lib"), testOutput.path) mkString sys.props("path.separator")
+    compileString(newCompiler("-cp", classpath, "-d", testOutput.path))(code)
   }
 
+  def library1 = """
+    package pack1
+    trait T
+  """
+
+  def library2 = """
+    package pack2
+    trait U extends pack1.T
+  """
+
+  def app = """
+    package pack3
+    object X {
+      trait U
+    }
+    import X._
+    import pack2._
+
+    trait V extends U
+  """
+
+  def show(): Unit = {
+    Seq(library1, library2) foreach compileCode
+    assert(filteredInfos.isEmpty, filteredInfos)
+
+    // blow away the entire package
+    val pack1 = new File(testOutput.path, "pack1")
+    val tClass = new File(pack1, "T.class")
+    assert(tClass.exists)
+    assert(tClass.delete())
+    assert(pack1.delete())
+
+    // bad symbolic reference error expected (but no stack trace!)
+    compileCode(app)
+    println(filteredInfos.mkString("\n"))
+  }
 }
diff --git a/test/files/run/t6440b.check b/test/files/run/t6440b.check
new file mode 100644
index 0000000000..9771ce5efb
--- /dev/null
+++ b/test/files/run/t6440b.check
@@ -0,0 +1,4 @@
+pos: NoPosition bad symbolic reference. A signature in U.class refers to type T
+in package pack1 which is not available.
+It may be completely missing from the current classpath, or the version on
+the classpath might be incompatible with the version used when compiling U.class. ERROR
diff --git a/test/files/run/t6440b.scala b/test/files/run/t6440b.scala
new file mode 100644
index 0000000000..974aca2844
--- /dev/null
+++ b/test/files/run/t6440b.scala
@@ -0,0 +1,61 @@
+import scala.tools.partest._
+import java.io.File
+
+object Test extends StoreReporterDirectTest {
+  def code = ???
+
+  def compileCode(code: String) = {
+    val classpath = List(sys.props("partest.lib"), testOutput.path) mkString sys.props("path.separator")
+    compileString(newCompiler("-cp", classpath, "-d", testOutput.path))(code)
+  }
+
+  def library1 = """
+    package pack1
+    trait T
+    class U {
+      def t = new T {}
+      def one = 1
+    }
+  """
+
+  def library2 = """
+    package pack2
+    object V {
+      def u = new pack1.U
+    }
+    """
+
+  def app1 = """
+    package pack3
+    object Test {
+      pack2.V.u.one // okay
+    }
+  """
+
+  def app2 = """
+    package pack3
+    object Test {
+      pack2.V.u.t // we have to fail if T.class is misisng
+    }
+  """
+
+  def show(): Unit = {
+    compileCode(library1)
+    val pack1 = new File(testOutput.path, "pack1")
+    val tClass = new File(pack1, "T.class")
+    assert(tClass.exists)
+    assert(tClass.delete())
+
+    // allowed to compile, no direct reference to `T`
+    compileCode(library2)
+    assert(filteredInfos.isEmpty, filteredInfos)
+
+    // allowed to compile, no direct reference to `T`
+    compileCode(app1)
+    assert(filteredInfos.isEmpty, filteredInfos)
+
+    // bad symbolic reference error expected (but no stack trace!)
+    compileCode(app2)
+    println(filteredInfos.mkString("\n"))
+  }
+}
diff --git a/test/files/run/t6628.check b/test/files/run/t6628.check
new file mode 100644
index 0000000000..bb101b641b
--- /dev/null
+++ b/test/files/run/t6628.check
@@ -0,0 +1,2 @@
+true
+true
diff --git a/test/files/run/t6628.scala b/test/files/run/t6628.scala
new file mode 100644
index 0000000000..84524a7a35
--- /dev/null
+++ b/test/files/run/t6628.scala
@@ -0,0 +1,11 @@
+object Test {
+  def coll = new Traversable[String] {
+    override def foreach[U](f:String=>U) { f("1") }
+  }
+  val dropped = coll.view drop 1
+
+  def main(args: Array[String]): Unit = {
+    println(dropped.isEmpty)
+    println(dropped.force.isEmpty)
+  }
+}
diff --git a/test/files/run/t6632.check b/test/files/run/t6632.check
new file mode 100644
index 0000000000..1f084b1dac
--- /dev/null
+++ b/test/files/run/t6632.check
@@ -0,0 +1,3 @@
+java.lang.IndexOutOfBoundsException: -1
+java.lang.IndexOutOfBoundsException: -2
+java.lang.IndexOutOfBoundsException: -3
diff --git a/test/files/run/t6632.scala b/test/files/run/t6632.scala
new file mode 100644
index 0000000000..c1c8d4abe0
--- /dev/null
+++ b/test/files/run/t6632.scala
@@ -0,0 +1,29 @@
+object Test extends App {
+  import collection.mutable.ListBuffer
+  
+  def newLB = ListBuffer('a, 'b, 'c, 'd, 'e)
+
+  val lb0 = newLB
+
+  try {
+    lb0.insert(-1, 'x)
+  } catch {
+    case ex: IndexOutOfBoundsException => println(ex)
+  }
+
+  val lb1 = newLB
+
+  try {
+    lb1.insertAll(-2, Array('x, 'y, 'z))
+  } catch {
+    case ex: IndexOutOfBoundsException => println(ex)
+  }
+
+  val lb2 = newLB
+
+  try {
+    lb2.update(-3, 'u)
+  } catch {
+    case ex: IndexOutOfBoundsException => println(ex)
+  }
+}
\ No newline at end of file
diff --git a/test/files/run/t6633.check b/test/files/run/t6633.check
new file mode 100644
index 0000000000..1ff8cdbc44
--- /dev/null
+++ b/test/files/run/t6633.check
@@ -0,0 +1,3 @@
+java.lang.IndexOutOfBoundsException: 9
+replStringOf OK
+length OK
diff --git a/test/files/run/t6633.scala b/test/files/run/t6633.scala
new file mode 100644
index 0000000000..bd993c8d88
--- /dev/null
+++ b/test/files/run/t6633.scala
@@ -0,0 +1,33 @@
+object Test extends App {
+  import collection.mutable.ListBuffer
+
+  def newLB = ListBuffer('a, 'b, 'c, 'd, 'e)
+
+  val lb0 = newLB
+
+  try {
+    lb0.insert(9, 'x)
+  } catch {
+    case ex: IndexOutOfBoundsException => println(ex)
+  }
+
+  val lb1 = newLB
+
+  try {
+    lb1.insert(9, 'x)
+  } catch {
+    case ex: IndexOutOfBoundsException =>
+  }
+
+  val replStr = scala.runtime.ScalaRunTime.replStringOf(lb1, 100)
+  if (replStr == "ListBuffer('a, 'b, 'c, 'd, 'e)\n")
+    println("replStringOf OK")
+  else
+    println("replStringOf FAILED: " + replStr)
+
+  val len = lb1.length
+  if (len == 5)
+    println("length OK")
+  else
+    println("length FAILED: " + len)
+}
\ No newline at end of file
diff --git a/test/files/run/t6634.check b/test/files/run/t6634.check
new file mode 100644
index 0000000000..f6cbb30c67
--- /dev/null
+++ b/test/files/run/t6634.check
@@ -0,0 +1,31 @@
+Trying lb0 ...
+Checking ...
+String OK.
+Length OK.
+
+Trying lb1 ...
+Checking ...
+String OK.
+Length OK.
+
+Trying lb2 ...
+Checking ...
+String OK.
+Length OK.
+
+Trying lb3 ...
+Checking ...
+String OK.
+Length OK.
+
+Trying lb4 ...
+Checking ...
+String OK.
+Length OK.
+
+Trying lb5 ...
+java.lang.IllegalArgumentException: removing negative number (-1) of elements
+Checking ...
+String OK.
+Length OK.
+
diff --git a/test/files/run/t6634.scala b/test/files/run/t6634.scala
new file mode 100644
index 0000000000..759e6d519d
--- /dev/null
+++ b/test/files/run/t6634.scala
@@ -0,0 +1,80 @@
+import collection.mutable.ListBuffer
+
+object Test extends App {
+  def newLB = ListBuffer('a, 'b, 'c, 'd, 'e)
+
+  val lb0 = newLB
+  println("Trying lb0 ...")
+  try {
+    lb0.remove(5, 0)
+  } catch {
+    // Not thrown in 2.10, will be thrown in 2.11
+    case ex: IndexOutOfBoundsException => println(ex)
+  }
+  checkNotCorrupted(lb0)
+
+  val lb1 = newLB
+  println("Trying lb1 ...")
+  try {
+    lb1.remove(6, 6)
+  } catch {
+    // Not thrown in 2.10, will be thrown in 2.11
+    case ex: IndexOutOfBoundsException => println(ex)
+  }
+  checkNotCorrupted(lb1)
+
+  val lb2 = newLB
+  println("Trying lb2 ...")
+  try {
+    lb2.remove(99, 6)
+  } catch {
+    // Not thrown in 2.10, will be thrown in 2.11
+    case ex: IndexOutOfBoundsException => println(ex)
+  }
+  checkNotCorrupted(lb2)
+
+  val lb3 = newLB
+  println("Trying lb3 ...")
+  try {
+    lb3.remove(1, 9)
+  } catch {
+    // Not thrown in 2.10, will be thrown in 2.11
+    case ex: IllegalArgumentException => println(ex)
+  }
+  checkNotCorrupted(lb3, "ListBuffer('a)", 1)
+
+  val lb4 = newLB
+  println("Trying lb4 ...")
+  try {
+    lb4.remove(-1, 1)
+  } catch {
+    // Not thrown in 2.10, will be thrown in 2.11
+    case ex: IndexOutOfBoundsException => println(ex)
+  }
+  checkNotCorrupted(lb4, "ListBuffer('b, 'c, 'd, 'e)", 4)
+
+  val lb5 = newLB
+  println("Trying lb5 ...")
+  try {
+    lb5.remove(1, -1)
+  } catch {
+    case ex: IllegalArgumentException => println(ex)
+  }
+  checkNotCorrupted(lb5)
+
+  // buffer should neither be changed nor corrupted after calling remove with invalid arguments
+  def checkNotCorrupted(
+    lb: ListBuffer[Symbol],
+    expectedString: String = "ListBuffer('a, 'b, 'c, 'd, 'e)",
+    expectedLength: Int = 5) = {
+    println("Checking ...")
+    val replStr = scala.runtime.ScalaRunTime.replStringOf(lb, 100)
+    if (replStr == expectedString + "\n") println("String OK.")
+    else println("!!! replStringOf FAILED: " + replStr)
+
+    val len = lb.length
+    if (len == expectedLength) println("Length OK.")
+    else println("!!! length FAILED: " + len)
+    println()
+  }
+}
\ No newline at end of file
diff --git a/test/files/run/t6663.check b/test/files/run/t6663.check
new file mode 100644
index 0000000000..d81cc0710e
--- /dev/null
+++ b/test/files/run/t6663.check
@@ -0,0 +1 @@
+42
diff --git a/test/files/run/t6663.scala b/test/files/run/t6663.scala
new file mode 100644
index 0000000000..6818d286d9
--- /dev/null
+++ b/test/files/run/t6663.scala
@@ -0,0 +1,17 @@
+import language.dynamics
+
+class C(v: Any) extends Dynamic {
+  def selectDynamic[T](n: String): Option[T] = Option(v.asInstanceOf[T])
+  def applyDynamic[T](n: String)(): Option[T] = Option(v.asInstanceOf[T])
+}
+
+object Test extends App {
+  // this should be converted to
+  // C(42).selectDynamic[Int]("foo").get
+  // but, before fixing SI-6663, became
+  // C(42).selectDynamic[Nothing]("foo").get
+  // leading to a ClassCastException
+  var v = new C(42).foo[Int].get
+  println(v)
+}
+
diff --git a/test/files/run/t6673.check b/test/files/run/t6673.check
new file mode 100644
index 0000000000..ef2aa551dc
--- /dev/null
+++ b/test/files/run/t6673.check
@@ -0,0 +1 @@
+List(x)
diff --git a/test/files/run/t6673.scala b/test/files/run/t6673.scala
new file mode 100644
index 0000000000..115bbdf234
--- /dev/null
+++ b/test/files/run/t6673.scala
@@ -0,0 +1,5 @@
+object Test extends App {
+  def foo(f: String => Array[String])(s: String) = f(s)
+  val test = foo(Array(_)) _
+  println(test("x").toList)
+}
\ No newline at end of file
diff --git a/test/files/run/t6695.scala b/test/files/run/t6695.scala
new file mode 100644
index 0000000000..b527238a51
--- /dev/null
+++ b/test/files/run/t6695.scala
@@ -0,0 +1,18 @@
+object Test extends App {
+	try {
+	  Array("a", "b", "c") match {
+	  	case Array("a", "x", "c") => println("x")
+	  	case Array("a", "b", "x") => println("a");
+	  	case Array("a", "d", _*) => println("wrongly positive")
+	  }
+	  assert(false, "match succeeded")
+	} catch {
+		case _: MatchError => // okay
+	}
+
+  Array("a", "b", "c") match {
+  	case Array("a", "x", "c") => println("x")
+  	case Array("a", "b", "x") => println("a");
+  	case Array("a", "b", _*) => // okay
+  }
+}
diff --git a/test/files/run/typetags_without_scala_reflect_typetag_lookup.check b/test/files/run/typetags_without_scala_reflect_typetag_lookup.check
index 53df68cfc2..8c558ced60 100644
--- a/test/files/run/typetags_without_scala_reflect_typetag_lookup.check
+++ b/test/files/run/typetags_without_scala_reflect_typetag_lookup.check
@@ -1,3 +1,2 @@
-newSource1:9: error: could not find implicit value for evidence parameter of type reflect.runtime.package.universe.TypeTag[Int]
-      Library.foo[Int]
-                 ^
+
+pos: source-newSource1,line-9,offset=466 could not find implicit value for evidence parameter of type reflect.runtime.package.universe.TypeTag[Int] ERROR
diff --git a/test/files/run/typetags_without_scala_reflect_typetag_lookup.scala b/test/files/run/typetags_without_scala_reflect_typetag_lookup.scala
index e51ecdb180..1fbdc62a1e 100644
--- a/test/files/run/typetags_without_scala_reflect_typetag_lookup.scala
+++ b/test/files/run/typetags_without_scala_reflect_typetag_lookup.scala
@@ -1,6 +1,6 @@
 import scala.tools.partest._
 
-object Test extends DirectTest {
+object Test extends StoreReporterDirectTest {
   def code = ???
 
   def library = """
@@ -32,14 +32,12 @@ object Test extends DirectTest {
   }
 
   def show(): Unit = {
-    val prevErr = System.err
-    val baos = new java.io.ByteArrayOutputStream();
-    System.setErr(new java.io.PrintStream(baos));
     compileLibrary();
+    println(filteredInfos.mkString("\n"))
+    storeReporter.infos.clear()
     compileApp();
-    // we should get bad symbolic reference errors, because we're trying to call a method that can't be unpickled
+    // we should get bad symbolic reference errors, because we're trying to use an implicit that can't be unpickled
     // but we don't know the number of these errors and their order, so I just ignore them all
-    baos.toString.split("\n") filter (!_.startsWith("error: bad symbolic reference")) foreach println
-    System.setErr(prevErr)
+    println(filteredInfos.filterNot(_.msg.contains("bad symbolic reference")).mkString("\n"))
   }
-}
\ No newline at end of file
+}
diff --git a/test/files/run/typetags_without_scala_reflect_typetag_manifest_interop.check b/test/files/run/typetags_without_scala_reflect_typetag_manifest_interop.check
index 729c0715df..acfecce628 100644
--- a/test/files/run/typetags_without_scala_reflect_typetag_manifest_interop.check
+++ b/test/files/run/typetags_without_scala_reflect_typetag_manifest_interop.check
@@ -1,3 +1,2 @@
-newSource1:9: error: No Manifest available for App.this.T.
-      manifest[T]
-              ^
+
+pos: source-newSource1,line-9,offset=479 No Manifest available for App.this.T. ERROR
diff --git a/test/files/run/typetags_without_scala_reflect_typetag_manifest_interop.scala b/test/files/run/typetags_without_scala_reflect_typetag_manifest_interop.scala
index e984127583..6804baa0c3 100644
--- a/test/files/run/typetags_without_scala_reflect_typetag_manifest_interop.scala
+++ b/test/files/run/typetags_without_scala_reflect_typetag_manifest_interop.scala
@@ -1,6 +1,7 @@
 import scala.tools.partest._
+import scala.tools.nsc.Settings
 
-object Test extends DirectTest {
+object Test extends StoreReporterDirectTest {
   def code = ???
 
   def library = """
@@ -29,18 +30,18 @@ object Test extends DirectTest {
   """
   def compileApp() = {
     val classpath = List(sys.props("partest.lib"), testOutput.path) mkString sys.props("path.separator")
+    val global = newCompiler("-cp", classpath, "-d", testOutput.path)
     compileString(newCompiler("-cp", classpath, "-d", testOutput.path))(app)
+    //global.reporter.ERROR.foreach(println)
   }
 
   def show(): Unit = {
-    val prevErr = System.err
-    val baos = new java.io.ByteArrayOutputStream();
-    System.setErr(new java.io.PrintStream(baos));
     compileLibrary();
+    println(filteredInfos.mkString("\n"))
+    storeReporter.infos.clear()
     compileApp();
     // we should get bad symbolic reference errors, because we're trying to use an implicit that can't be unpickled
     // but we don't know the number of these errors and their order, so I just ignore them all
-    baos.toString.split("\n") filter (!_.startsWith("error: bad symbolic reference")) foreach println
-    System.setErr(prevErr)
+    println(filteredInfos.filterNot (_.msg.contains("bad symbolic reference")).mkString("\n"))
   }
-}
\ No newline at end of file
+}