Merge pull request #1663 from paulp/merge-2.10.wip-x

Merge 2.10.0-wip into 2.10.x.

40 files changed, 410 insertions, 141 deletions

diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
index 0d13623e0c..0ac46a18bc 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
@@ -285,7 +285,7 @@ abstract class TreeBuilder {
   def makeGenerator(pos: Position, pat: Tree, valeq: Boolean, rhs: Tree): Enumerator = {
     val pat1 = patvarTransformer.transform(pat)
     val rhs1 =
-      if (valeq || treeInfo.isVariablePattern(pat)) rhs
+      if (valeq || treeInfo.isVarPatternDeep(pat)) rhs
       else makeFilter(rhs, pat1.duplicate, nme.CHECK_IF_REFUTABLE_STRING)
 
     if (valeq) ValEq(pos, pat1, rhs1)
diff --git a/src/compiler/scala/tools/nsc/reporters/Reporter.scala b/src/compiler/scala/tools/nsc/reporters/Reporter.scala
index c5321dd728..8871ae6555 100644
--- a/src/compiler/scala/tools/nsc/reporters/Reporter.scala
+++ b/src/compiler/scala/tools/nsc/reporters/Reporter.scala
@@ -20,9 +20,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/transform/ExtensionMethods.scala b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
index 6cc957a9eb..6f3d7932a5 100644
--- a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
+++ b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
@@ -173,9 +173,7 @@ abstract class ExtensionMethods extends Transform with TypingTransformers {
               List(This(currentOwner)))
           val extensionCall = atOwner(origMeth) {
             localTyper.typedPos(rhs.pos) {
-              (extensionCallPrefix /: vparamss) {
-                case (fn, params) => Apply(fn, params map (param => Ident(param.symbol)))
-              }
+              gen.mkForwarder(extensionCallPrefix, mmap(vparamss)(_.symbol))
             }
           }
           deriveDefDef(tree)(_ => extensionCall)
diff --git a/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala b/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
index 31db042942..2b6b82f0ab 100644
--- a/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
@@ -417,7 +417,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/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 0ffd99c88c..6871a3cb73 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 fc7202b96b..5f193eb211 100644
--- a/src/library/scala/collection/TraversableLike.scala
+++ b/src/library/scala/collection/TraversableLike.scala
@@ -86,7 +86,7 @@ trait TraversableLike[+A, +Repr] extends Any
   def repr: Repr = this.asInstanceOf[Repr]
 
   final def isTraversableAgain: Boolean = true
-
+  
   /** The underlying collection seen as an instance of `$Coll`.
    *  By default this is implemented as the current collection object itself,
    *  but this can be overridden.
@@ -174,7 +174,7 @@ trait TraversableLike[+A, +Repr] extends Any
    *
    *  @usecase def ++:[B](that: TraversableOnce[B]): $Coll[B]
    *    @inheritdoc
-   *
+   * 
    *    Example:
    *    {{{
    *      scala> val x = List(1)
@@ -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 0925fe4770..14f865c2f0 100644
--- a/src/library/scala/collection/TraversableViewLike.scala
+++ b/src/library/scala/collection/TraversableViewLike.scala
@@ -59,7 +59,7 @@ trait ViewMkString[+A] {
  *  $viewInfo
  *
  *  All views for traversable collections are defined by creating a new `foreach` method.
- *
+ *  
  *  @author Martin Odersky
  *  @version 2.8
  *  @since   2.8
@@ -162,7 +162,7 @@ trait TraversableViewLike[+A,
 //     if (b.isInstanceOf[NoBuilder[_]]) newFlatMapped(f).asInstanceOf[That]
 //    else super.flatMap[B, That](f)(bf)
   }
-  override def flatten[B](implicit asTraversable: A => /*<:<!!!*/ GenTraversableOnce[B]) =
+  override def flatten[B](implicit asTraversable: A => /*<:<!!!*/ GenTraversableOnce[B]) = 
     newFlatMapped(asTraversable)
   private[this] implicit def asThis(xs: Transformed[A]): This = xs.asInstanceOf[This]
 
@@ -193,15 +193,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/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala
index 426ab6f0fb..be2cd91c68 100644
--- a/src/library/scala/collection/immutable/Stream.scala
+++ b/src/library/scala/collection/immutable/Stream.scala
@@ -937,7 +937,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 21cff70473..f0c31ec7fb 100644
--- a/src/library/scala/collection/mutable/IndexedSeqLike.scala
+++ b/src/library/scala/collection/mutable/IndexedSeqLike.scala
@@ -53,7 +53,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/parallel/ParIterableLike.scala b/src/library/scala/collection/parallel/ParIterableLike.scala
index 9825587b0e..0f06ff37af 100644
--- a/src/library/scala/collection/parallel/ParIterableLike.scala
+++ b/src/library/scala/collection/parallel/ParIterableLike.scala
@@ -171,9 +171,9 @@ self: ParIterableLike[T, Repr, Sequential] =>
 
   /** The task support object which is responsible for scheduling and
    *  load-balancing tasks to processors.
-   *
+   *                                                                              
    *  @see [[scala.collection.parallel.TaskSupport]]
-   */
+   */     
   def tasksupport = {
     val ts = _tasksupport
     if (ts eq null) {
@@ -188,18 +188,18 @@ self: ParIterableLike[T, Repr, Sequential] =>
    *  A task support object can be changed in a parallel collection after it
    *  has been created, but only during a quiescent period, i.e. while there
    *  are no concurrent invocations to parallel collection methods.
-   *
-   *  Here is a way to change the task support of a parallel collection:
-   *
-   *  {{{
-   *  import scala.collection.parallel._
-   *  val pc = mutable.ParArray(1, 2, 3)
-   *  pc.tasksupport = new ForkJoinTaskSupport(
-   *    new scala.concurrent.forkjoin.ForkJoinPool(2))
-   *  }}}
+   *                                                                              
+   *  Here is a way to change the task support of a parallel collection:          
+   *                                                                              
+   *  {{{                                                                         
+   *  import scala.collection.parallel._                                          
+   *  val pc = mutable.ParArray(1, 2, 3)                                          
+   *  pc.tasksupport = new ForkJoinTaskSupport(                                   
+   *    new scala.concurrent.forkjoin.ForkJoinPool(2))                            
+   *  }}}                                                                         
    *
    *  @see [[scala.collection.parallel.TaskSupport]]
-   */
+   */     
   def tasksupport_=(ts: TaskSupport) = _tasksupport = ts
 
   def seq: Sequential
@@ -848,7 +848,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] = {
@@ -878,13 +877,13 @@ self: ParIterableLike[T, Repr, Sequential] =>
   override def toSet[U >: T]: immutable.ParSet[U] = toParCollection[U, immutable.ParSet[U]](() => immutable.ParSet.newCombiner[U])
 
   override def toMap[K, V](implicit ev: T <:< (K, V)): immutable.ParMap[K, V] = toParMap[K, V, immutable.ParMap[K, V]](() => immutable.ParMap.newCombiner[K, V])
-
+  
   override def toVector: Vector[T] = to[Vector]
 
   override def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, T, Col[T @uncheckedVariance]]): Col[T @uncheckedVariance] = if (cbf().isCombiner) {
     toParCollection[T, Col[T]](() => cbf().asCombiner)
   } else seq.to(cbf)
-
+  
   /* tasks */
 
   protected trait StrictSplitterCheckTask[R, Tp] extends Task[R, Tp] {
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/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index 9254cc9ac9..c42cc1cea8 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -423,9 +423,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")
@@ -1349,6 +1349,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
@@ -3105,14 +3108,18 @@ 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)"
-    }
+    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
 
@@ -3129,12 +3136,10 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     override def rawInfo         = fail(NoType)
     override def companionSymbol = fail(NoSymbol)
 
-    locally {
-      debugwarn("creating stub symbol for " + stubWarning)
-    }
+    debugwarn("creating stub symbol to defer error: " + missingMessage)
   }
-  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/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala
index 38e55a3c01..8ad15f37e4 100644
--- a/src/reflect/scala/reflect/internal/TreeInfo.scala
+++ b/src/reflect/scala/reflect/internal/TreeInfo.scala
@@ -245,6 +245,68 @@ abstract class TreeInfo {
     isSelfConstrCall(tree1) || isSuperConstrCall(tree1)
   }
 
+  /**
+   * Does this tree represent an irrefutable pattern match
+   * in the position `for { <tree> <- expr }` based only
+   * on information at the `parser` phase? To qualify, there
+   * may be no subtree that will be interpreted as a
+   * Stable Identifier Pattern.
+   *
+   * For instance:
+   *
+   * {{{
+   * foo @ (bar, (baz, quux))
+   * }}}
+   *
+   * is a variable pattern; if the structure matches,
+   * then the remainder is inevitable.
+   *
+   * The following are not variable patterns.
+   *
+   * {{{
+   *   foo @ (bar, (`baz`, quux)) // back quoted ident, not at top level
+   *   foo @ (bar, Quux)          // UpperCase ident, not at top level
+   * }}}
+   *
+   * If the pattern is a simple identifier, it is always
+   * a variable pattern. For example, the following
+   * introduce new bindings:
+   *
+   * {{{
+   * for { X <- xs } yield X
+   * for { `backquoted` <- xs } yield `backquoted`
+   * }}}
+   *
+   * Note that this differs from a case clause:
+   *
+   * {{{
+   *   object X
+   *   scrut match {
+   *      case X =>  // case _ if scrut == X
+   *   }
+   * }}}
+   *
+   * Background: [[https://groups.google.com/d/msg/scala-internals/qwa_XOw_7Ks/IktkeTBYqg0J]]
+   *
+   */
+  def isVarPatternDeep(tree: Tree): Boolean = {
+    def isVarPatternDeep0(tree: Tree): Boolean = {
+      tree match {
+        case Bind(name, pat)  => isVarPatternDeep0(pat)
+        case Ident(name)      => isVarPattern(tree)
+        case Apply(sel, args) =>
+          (    isReferenceToScalaMember(sel, TupleClass(args.size).name.toTermName)
+            && (args forall isVarPatternDeep0)
+            )
+        case _                => false
+      }
+    }
+    tree match {
+      case Ident(name) => true
+      case _           => isVarPatternDeep0(tree)
+    }
+  }
+
   /** Is tree a variable pattern? */
   def isVarPattern(pat: Tree): Boolean = pat match {
     case x: Ident           => !x.isBackquoted && nme.isVariableName(x.name)
@@ -330,24 +392,6 @@ abstract class TreeInfo {
     case _                                       => false
   }
 
-  /** Is this tree comprised of nothing but identifiers,
-   *  but possibly in bindings or tuples? For instance
-   *
-   *    foo @ (bar, (baz, quux))
-   *
-   *  is a variable pattern; if the structure matches,
-   *  then the remainder is inevitable.
-   */
-  def isVariablePattern(tree: Tree): Boolean = tree match {
-    case Bind(name, pat)  => isVariablePattern(pat)
-    case Ident(name)      => true
-    case Apply(sel, args) =>
-      (    isReferenceToScalaMember(sel, TupleClass(args.size).name.toTermName)
-        && (args forall isVariablePattern)
-      )
-    case _ => false
-  }
-
   /** Is this argument node of the form <expr> : _* ?
    */
   def isWildcardStarArg(tree: Tree): Boolean = tree match {
diff --git a/src/reflect/scala/reflect/internal/Trees.scala b/src/reflect/scala/reflect/internal/Trees.scala
index 74bde132cb..b2158de9ec 100644
--- a/src/reflect/scala/reflect/internal/Trees.scala
+++ b/src/reflect/scala/reflect/internal/Trees.scala
@@ -482,6 +482,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
@@ -502,6 +506,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 6df6ed4417..0c4cda8313 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -1398,7 +1398,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)
+    }
+
     //assert(sym.isClass && !sym.isModuleClass || sym.isRoot, sym)
     override def isTrivial: Boolean = sym.isPackageClass
     override def isNotNull = true
diff --git a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
index 43b982a8a4..f3a5053a91 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._
 
@@ -233,7 +233,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)
               }
             }
           }
@@ -827,11 +832,6 @@ abstract class UnPickler /*extends scala.reflect.generic.UnPickler*/ {
     protected def errorBadSignature(msg: String) =
       throw new RuntimeException("malformed Scala signature of " + classRoot.name + " at " + readIndex + "; " + msg)
 
-    protected def errorMissingRequirement(name: Name, owner: Symbol): Symbol =
-      mirrorThatLoaded(owner).missingHook(owner, name) orElse MissingRequirementError.signal(
-        s"bad reference while unpickling $filename: ${name.longString} not found in ${owner.tpe.widen}"
-      )
-
     def inferMethodAlternative(fun: Tree, argtpes: List[Type], restpe: Type) {} // can't do it; need a compiler for that.
 
     def newLazyTypeRef(i: Int): LazyType = new LazyTypeRef(i)
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/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/rawstrings.check b/test/files/run/rawstrings.check
index 36e63594df..2b6c40725a 100644
--- a/test/files/run/rawstrings.check
+++ b/test/files/run/rawstrings.check
@@ -1 +1 @@
-[\n\t'"$]
+[\n\t'"$\n]
diff --git a/test/files/run/rawstrings.scala b/test/files/run/rawstrings.scala
index 9df64f6625..b4d6e0c40a 100644
--- a/test/files/run/rawstrings.scala
+++ b/test/files/run/rawstrings.scala
@@ -1,3 +1,3 @@
 object Test extends App {
-  println(raw"[\n\t'${'"'}$$]")
+  println(raw"[\n\t'${'"'}$$\n]")
 }
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/t6644.scala b/test/files/run/t6644.scala
new file mode 100644
index 0000000000..b8b36f957c
--- /dev/null
+++ b/test/files/run/t6644.scala
@@ -0,0 +1,8 @@
+class Testable(val c: String) extends AnyVal {
+  def matching(cases: Boolean*) = cases contains true
+}
+
+object Test extends App {
+  assert(new Testable("").matching(true, false))
+}
+
diff --git a/test/files/run/t6646.check b/test/files/run/t6646.check
new file mode 100644
index 0000000000..b0b7ad32f3
--- /dev/null
+++ b/test/files/run/t6646.check
@@ -0,0 +1,5 @@
+Found NotNull
+Found lower
+Found 2
+A single ident is always a pattern
+A single ident is always a pattern
diff --git a/test/files/run/t6646.scala b/test/files/run/t6646.scala
new file mode 100644
index 0000000000..150b0df11e
--- /dev/null
+++ b/test/files/run/t6646.scala
@@ -0,0 +1,19 @@
+sealed trait ColumnOption
+case object NotNull extends ColumnOption
+case object PrimaryKey extends ColumnOption
+case object lower extends ColumnOption
+
+object Test {
+  def main(args: Array[String]) {
+    val l = List(PrimaryKey, NotNull, lower)
+
+    // withFilter must be generated in these
+    for (option @ NotNull <- l) println("Found " + option)
+    for (option @ `lower` <- l) println("Found " + option)
+    for ((`lower`, i) <- l.zipWithIndex) println("Found " + i)
+
+    // no withFilter
+    for (X <- List("A single ident is always a pattern")) println(X)
+    for (`x` <- List("A single ident is always a pattern")) println(`x`)
+  }
+}
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
+}
diff --git a/tools/epfl-publish b/tools/epfl-publish
index de5e17b13f..cdf18823a5 100755
--- a/tools/epfl-publish
+++ b/tools/epfl-publish
@@ -24,7 +24,7 @@ if [[ -z $publish_to ]]; then
 else
   echo "Publishing nightly build to $publish_to"
   # Archive Scala nightly distribution
-  rsync -az dists/archives/ "$publish_to/distributions"
+  rsync -az --exclude scala-latest-sources.tgz dists/archives/ "$publish_to/distributions"
   # only publish scaladoc nightly for trunk
   [[ $version == "master" ]] && rsync -az build/scaladoc/ "$publish_to/docs"
   # sbaz