From bb4d2e7ff0982cbdc390c3d86949bf56f6d814ea Mon Sep 17 00:00:00 2001
From: cunei <antonio.cunei@typesafe.com>
Date: Fri, 9 Nov 2012 16:36:26 +0100
Subject: Update tools/epfl-publish

Currently, during each Scala nightly build, the epfl-publish script rsyncs the resulting dists/archives to the repository machine (chara).

Now, as a result of a change introduced a while back, dists/archives/ now also contains a symbolic link, created at the end of the build when the targets "pack-archives.latest.*" are invoked (in src/build/pack.xml). That was introduced in:

scala/scala@506bcfe71c93160ebfa0ca9b8b170b4b54e844e9
scala/scala@cb99853c8655686dae1288cbcd44a42cf1ea6609

This link, created in dists/archives/, is copied over as-is at the end of the rsync to chara by epfl-publish. On chara, however, the link points to an invalid target (the path is absolute).

Separately, the repository directory on chara is rsync'd every 30 minutes over to the machine that serves www.scala-lang.org, via cron. Rsynch finds that the link target does not exist, and generates an email with the crontab log, which is then duly sent to a system mailbox. Every 30 minutes. Since March. Needless to say, the mailbox is pretty large by now.

The fix is trivial, but this needs to be included in all the branches that are tested during the nightly. Since RC2 has just been cut, and the code frozen, I'm not sure how this change can be included without disruption; therefore, I'll just send a pull request on 2.10.0-wip, and let Josh/Paul take the appropriate steps.
---
 tools/epfl-publish | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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
-- 
cgit v1.2.3


From 8b2caf0746fd4405f2d47b54d17d484e6603c89d Mon Sep 17 00:00:00 2001
From: Jason Zaugg <jzaugg@gmail.com>
Date: Sat, 10 Nov 2012 13:07:26 +0100
Subject: SI-6646 Fix regression in for desugaring.

The early check in the parser of pattern irrefutability,
added in c82ecab, failed to consider InitCaps and
`backquoted` identifiers.
---
 .../scala/tools/nsc/ast/parser/TreeBuilder.scala   |  2 +-
 src/reflect/scala/reflect/internal/TreeInfo.scala  | 45 +++++++++++++---------
 test/files/run/t6646.check                         |  3 ++
 test/files/run/t6646.scala                         | 13 +++++++
 4 files changed, 44 insertions(+), 19 deletions(-)
 create mode 100644 test/files/run/t6646.check
 create mode 100644 test/files/run/t6646.scala

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/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala
index 38e55a3c01..56a0bac72b 100644
--- a/src/reflect/scala/reflect/internal/TreeInfo.scala
+++ b/src/reflect/scala/reflect/internal/TreeInfo.scala
@@ -245,6 +245,33 @@ abstract class TreeInfo {
     isSelfConstrCall(tree1) || isSuperConstrCall(tree1)
   }
 
+  /** 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.
+    *
+    * The following are not variable patterns.
+    *
+    * {{{
+    *   foo @ (bar, (`baz`, Quux))
+    *   foo @ (bar, Quux)
+    * }}}
+    */
+  def isVarPatternDeep(tree: Tree): Boolean = tree match {
+    case Bind(name, pat)  => isVarPatternDeep(pat)
+    case Ident(name)      => isVarPattern(tree)
+    case Apply(sel, args) =>
+      (    isReferenceToScalaMember(sel, TupleClass(args.size).name.toTermName)
+        && (args forall isVarPatternDeep)
+      )
+    case _                => false
+  }
+
   /** Is tree a variable pattern? */
   def isVarPattern(pat: Tree): Boolean = pat match {
     case x: Ident           => !x.isBackquoted && nme.isVariableName(x.name)
@@ -330,24 +357,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/test/files/run/t6646.check b/test/files/run/t6646.check
new file mode 100644
index 0000000000..e27b5b9efb
--- /dev/null
+++ b/test/files/run/t6646.check
@@ -0,0 +1,3 @@
+Found NotNull
+Found lower
+Found 2
diff --git a/test/files/run/t6646.scala b/test/files/run/t6646.scala
new file mode 100644
index 0000000000..9418bfafb1
--- /dev/null
+++ b/test/files/run/t6646.scala
@@ -0,0 +1,13 @@
+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)
+    for (option @ NotNull <- l) println("Found " + option)
+    for (option @ `lower` <- l) println("Found " + option)
+    for ((`lower`, i) <- l.zipWithIndex) println("Found " + i)
+  }
+}
-- 
cgit v1.2.3


From 1e0a30a744e6853b1e69928a63b327226f4bf27f Mon Sep 17 00:00:00 2001
From: Jason Zaugg <jzaugg@gmail.com>
Date: Sat, 10 Nov 2012 21:51:24 +0100
Subject: SI-6644 Account for varargs in extmethod forwarder

Which sounded difficult, so instead I offshored the work
to the friendly republic of TreeGen.
---
 src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala | 4 +---
 test/files/run/t6644.scala                                    | 8 ++++++++
 2 files changed, 9 insertions(+), 3 deletions(-)
 create mode 100644 test/files/run/t6644.scala

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/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))
+}
+
-- 
cgit v1.2.3


From 0b59b4627a76d99531a51c7f17bbfa8b9c8c4bd8 Mon Sep 17 00:00:00 2001
From: Jason Zaugg <jzaugg@gmail.com>
Date: Sat, 10 Nov 2012 15:31:43 +0100
Subject: SI-6640 Better reporting of deficient classpaths.

In a55788e, StubSymbols were introduced to fail-slow when
the classpath was deficient. This allowed compilation to
succeed in cases when one didn't actually use the part of
class A which referred to some missing class B.

But a few problems were introduced.

Firstly, when the deferred error eventually happened, it was
signalled with abort(msg), rather than through a thrown
MissingRequirementError. The latter is desirable, as it doesn't
lead to printing a stack trace.

Second, the actual error message changed, and no longer
included the name of the class file that refers to the missing
class.

Finally, it seems that we can end up with a stub term symbol
in a situation where a class symbol is desired. An assertion
in the constructor of ThisType throws trips when calling .isClass,
before the useful error message from StubSymbol can be emitted.

This commit addresses these points, and rewords the error
a little to be more accessible. The last point is the most fragile
in this arrangement, there might be some whack-a-mole
required to find other places that also need this.
I don't see a clean solution for this, but am open to suggestions.

We should really build a facility in partest to delete
specified classfiles between groups in separate compilation
tests, in order to have tests for this. I'll work on that as a followup.

For now, here's the result of my manual testing:

[info] Set current project to default-821d14 (in build file:/Users/jason/code/scratch1/)
> compile

[info] Compiling 1 Scala source to /Users/jason/code/scratch1/target/scala-2.10/classes...
[error]
[error]      while compiling: /Users/jason/code/scratch1/test.scala
[error]         during phase: typer
[error]      library version: version 2.10.0-RC2
[error]     compiler version: version 2.10.0-RC2
...
[error]   last tree to typer: Ident(SwingWorker)
[error]               symbol: <none> (flags: )
[error]    symbol definition: <none>
[error]        symbol owners:
[error]       context owners: object Test -> package <empty>
 ...
[error] uncaught exception during compilation: java.lang.AssertionError
[trace] Stack trace suppressed: run last compile:compile for the full output.
[error] (compile:compile) java.lang.AssertionError: assertion failed: value actors
[error] Total time: 2 s, completed Nov 10, 2012 3:18:34 PM
>
> set scalaHome := Some(file("/Users/jason/code/scala/build/pack"))
[info] Defining *:scala-home
[info] The new value will be used by no settings or tasks.
[info] Reapplying settings...
[info] Set current project to default-821d14 (in build file:/Users/jason/code/scratch1/)
^[compile
[info] Compiling 1 Scala source to /Users/jason/code/scratch1/target/scala-2.10/classes...
[error] /Users/jason/code/scratch1/test.scala:4: A signature in SwingWorker.class refers to term actors in package scala which is missing from the classpath.
[error] object Test extends SwingWorker
[error]                     ^
[error] one error found
[error] (compile:compile) Compilation failed
[error] Total time: 2 s, completed Nov 10, 2012 3:18:45 PM
---
 src/reflect/scala/reflect/internal/Symbols.scala    | 21 ++++++++-------------
 src/reflect/scala/reflect/internal/Types.scala      |  2 +-
 .../scala/reflect/internal/pickling/UnPickler.scala |  8 ++------
 3 files changed, 11 insertions(+), 20 deletions(-)

diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index 7cb9a0e105..33d99b35d8 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")
@@ -3100,14 +3100,11 @@ 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
     private def fail[T](alt: T): T = {
       // Avoid issuing lots of redundant errors
       if (!hasFlag(IS_ERROR)) {
-        globalError(s"bad symbolic reference to " + stubWarning)
+        MissingRequirementError.signal(missingMessage)
         if (settings.debug.value)
           (new Throwable).printStackTrace
 
@@ -3124,12 +3121,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/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index e8054fcdf5..86d03d7450 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -1385,7 +1385,7 @@ 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)
+    assert(sym.isClass, {sym.info; sym}) // call .info to allow StubSymbols to reveal what's missing from the classpath
     //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..15465f919a 100644
--- a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
+++ b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
@@ -233,7 +233,8 @@ 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"A signature in $filename refers to ${name.longString} in ${owner.fullLocationString} which is missing from the classpath."
+                owner.newStubSymbol(name, missingMessage)
               }
             }
           }
@@ -827,11 +828,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)
-- 
cgit v1.2.3


From 86e045e2863b04bf4af4abb5c2ce345bcdae2b80 Mon Sep 17 00:00:00 2001
From: Jason Zaugg <jzaugg@gmail.com>
Date: Sat, 10 Nov 2012 21:30:00 +0100
Subject: Refine the message and triggering of MissingRequirementError.

 - To force a failure of the stub, call a new method `failIfStub`
   rather than `info`.
 - Offer a broader range of potential root causes in the
   error message.
---
 src/reflect/scala/reflect/internal/Symbols.scala            | 4 ++++
 src/reflect/scala/reflect/internal/Types.scala              | 6 +++++-
 src/reflect/scala/reflect/internal/pickling/UnPickler.scala | 8 ++++++--
 3 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index 33d99b35d8..67b2d05224 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -1344,6 +1344,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
@@ -3100,6 +3103,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     )
   }
   trait StubSymbol extends Symbol {
+    override final def failIfStub() = fail(())
     protected def missingMessage: String
     private def fail[T](alt: T): T = {
       // Avoid issuing lots of redundant errors
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index 86d03d7450..57212bab55 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -1385,7 +1385,11 @@ 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.info; sym}) // call .info to allow StubSymbols to reveal what's missing from the classpath
+    // SI-6640 allow StubSymbols to reveal what's missing from the classpath
+    //         before we trip the assertion.
+    sym.failIfStub()
+    assert(sym.isClass, 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 15465f919a..5464a68205 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,11 @@ 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.
-                val missingMessage = s"A signature in $filename refers to ${name.longString} in ${owner.fullLocationString} which is missing from the classpath."
+                val missingMessage =
+                  s"""|A signature in $filename refers to ${name.longString} in ${owner.fullLocationString}
+                      |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)
               }
             }
-- 
cgit v1.2.3


From 079296632d8ef5ecc40aafa83757231599c78783 Mon Sep 17 00:00:00 2001
From: Jason Zaugg <jzaugg@gmail.com>
Date: Tue, 13 Nov 2012 11:02:30 +0100
Subject: SI-6440 Address regressions around MissingRequirementError

 Go back to using globalError to report when a stub's info is referenced,
 and only throw the MissingRequirementError when compilation really
 must abort due to having a StubTermSymbol in a place where a
 StubClassSymbol would have been a better choice.

 This situation arises when an entire package is missing from the
 classpath, as was the case in the reported bug.

 Adds `StoreReporterDirectTest`, which buffers messages issued
 during compilation for more structured interrogation. Use this
 in two test for manifests -- these tests were using a crude means
 of grepping compiler console output to focus on the relevant output,
 but this approach was insufficient with the new multi-line error
 message emitted as part of this change.

 Also used that base test class to add two new tests: one for
 the reported error (package missing), and another for a simpler
 error (class missing). The latter test shows how stub symbols
 allow code to compile if it doesn't the subset of signatures
 in some type that refer to a missing class.

 Gave the INFO/WARNING/ERROR members of Reporter sensible
 toString implementations; they inherit from Enumeration#Value
 in an unusual manner (why?) that means the built in toString of
 Enumeration printed `Severity@0`.
---
 .../scala/tools/nsc/reporters/Reporter.scala       | 12 +++--
 src/partest/scala/tools/partest/DirectTest.scala   |  8 ++-
 .../tools/partest/StoreReporterDirectTest.scala    | 15 ++++++
 src/reflect/scala/reflect/internal/Symbols.scala   | 10 +++-
 src/reflect/scala/reflect/internal/Types.scala     |  9 ++--
 .../reflect/internal/pickling/UnPickler.scala      |  8 +--
 test/files/neg/t5148.check                         | 10 +++-
 test/files/run/t6440.check                         |  5 +-
 test/files/run/t6440.scala                         | 47 +++++++++++++++--
 test/files/run/t6440b.check                        |  4 ++
 test/files/run/t6440b.scala                        | 61 ++++++++++++++++++++++
 ...tags_without_scala_reflect_typetag_lookup.check |  5 +-
 ...tags_without_scala_reflect_typetag_lookup.scala | 14 +++--
 ...ut_scala_reflect_typetag_manifest_interop.check |  5 +-
 ...ut_scala_reflect_typetag_manifest_interop.scala | 15 +++---
 15 files changed, 186 insertions(+), 42 deletions(-)
 create mode 100644 src/partest/scala/tools/partest/StoreReporterDirectTest.scala
 create mode 100644 test/files/run/t6440b.check
 create mode 100644 test/files/run/t6440b.scala

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/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 67b2d05224..06bf54c1f8 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -3103,12 +3103,18 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     )
   }
   trait StubSymbol extends Symbol {
-    override final def failIfStub() = fail(())
     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)) {
-        MissingRequirementError.signal(missingMessage)
+        globalError(missingMessage)
         if (settings.debug.value)
           (new Throwable).printStackTrace
 
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index 57212bab55..d5347705a6 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -1385,10 +1385,11 @@ 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 {
-    // SI-6640 allow StubSymbols to reveal what's missing from the classpath
-    //         before we trip the assertion.
-    sym.failIfStub()
-    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
diff --git a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
index 5464a68205..f3a5053a91 100644
--- a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
+++ b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
@@ -234,10 +234,10 @@ abstract class UnPickler {
               adjust(mirrorThatLoaded(owner).missingHook(owner, name)) orElse {
                 // (5) Create a stub symbol to defer hard failure a little longer.
                 val missingMessage =
-                  s"""|A signature in $filename refers to ${name.longString} in ${owner.fullLocationString}
-                      |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
+                  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/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/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
+}
-- 
cgit v1.2.3


From b9e3ea7f070806631fd318e43082bc0653a79410 Mon Sep 17 00:00:00 2001
From: Jason Zaugg <jzaugg@gmail.com>
Date: Tue, 13 Nov 2012 11:21:17 +0100
Subject: SI-6646 `ident` or Ident is always new binding.

The previous commit regressed in these cases:

    // 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`)

At the top level of the LHS of a <-, such identifiers represent
new bindings, not stable identifier patterns.
---
 src/reflect/scala/reflect/internal/TreeInfo.scala | 84 ++++++++++++++++-------
 test/files/run/t6646.check                        |  2 +
 test/files/run/t6646.scala                        |  6 ++
 3 files changed, 67 insertions(+), 25 deletions(-)

diff --git a/src/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala
index 56a0bac72b..90f4f6fc8f 100644
--- a/src/reflect/scala/reflect/internal/TreeInfo.scala
+++ b/src/reflect/scala/reflect/internal/TreeInfo.scala
@@ -245,31 +245,65 @@ abstract class TreeInfo {
     isSelfConstrCall(tree1) || isSuperConstrCall(tree1)
   }
 
-  /** 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.
-    *
-    * The following are not variable patterns.
-    *
-    * {{{
-    *   foo @ (bar, (`baz`, Quux))
-    *   foo @ (bar, Quux)
-    * }}}
-    */
-  def isVarPatternDeep(tree: Tree): Boolean = tree match {
-    case Bind(name, pat)  => isVarPatternDeep(pat)
-    case Ident(name)      => isVarPattern(tree)
-    case Apply(sel, args) =>
-      (    isReferenceToScalaMember(sel, TupleClass(args.size).name.toTermName)
-        && (args forall isVarPatternDeep)
-      )
-    case _                => false
+  /**
+   * 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 Stable Identifier Patterns.
+   *
+   * 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? */
diff --git a/test/files/run/t6646.check b/test/files/run/t6646.check
index e27b5b9efb..b0b7ad32f3 100644
--- a/test/files/run/t6646.check
+++ b/test/files/run/t6646.check
@@ -1,3 +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
index 9418bfafb1..150b0df11e 100644
--- a/test/files/run/t6646.scala
+++ b/test/files/run/t6646.scala
@@ -6,8 +6,14 @@ 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`)
   }
 }
-- 
cgit v1.2.3


From 45cf745ccfe5b3729be70dee604beb0b7b411faf Mon Sep 17 00:00:00 2001
From: Jason Zaugg <jzaugg@gmail.com>
Date: Tue, 13 Nov 2012 18:46:03 +0100
Subject: Update comment.

---
 src/reflect/scala/reflect/internal/TreeInfo.scala | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala
index 90f4f6fc8f..8ad15f37e4 100644
--- a/src/reflect/scala/reflect/internal/TreeInfo.scala
+++ b/src/reflect/scala/reflect/internal/TreeInfo.scala
@@ -249,7 +249,8 @@ abstract class TreeInfo {
    * 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 Stable Identifier Patterns.
+   * may be no subtree that will be interpreted as a
+   * Stable Identifier Pattern.
    *
    * For instance:
    *
-- 
cgit v1.2.3


From d08060ee326345970cd1dbfbb73d227105e35d67 Mon Sep 17 00:00:00 2001
From: Julien Richard-Foy <julien@richard-foy.fr>
Date: Fri, 10 Aug 2012 00:34:39 +0200
Subject: Fix raw string interpolator: string parts which were after the first
 argument were still escaped

---
 src/library/scala/StringContext.scala | 2 +-
 test/files/run/rawstrings.check       | 2 +-
 test/files/run/rawstrings.scala       | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/library/scala/StringContext.scala b/src/library/scala/StringContext.scala
index f72547724d..8be0cb1619 100644
--- a/src/library/scala/StringContext.scala
+++ b/src/library/scala/StringContext.scala
@@ -120,7 +120,7 @@ case class StringContext(parts: String*) {
     val bldr = new java.lang.StringBuilder(process(pi.next()))
     while (ai.hasNext) {
       bldr append ai.next
-      bldr append treatEscapes(pi.next())
+      bldr append process(pi.next())
     }
     bldr.toString
   }
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]")
 }
-- 
cgit v1.2.3


From 1587a77eca46b265dc677b9be2536f1f60503f65 Mon Sep 17 00:00:00 2001
From: Jason Zaugg <jzaugg@gmail.com>
Date: Sun, 11 Nov 2012 14:02:24 +0100
Subject: SI-6648 copyAttrs must preserve TypeTree#wasEmpty

This field tracks whether the type is an inferred
on, subject to removal in `resetAttrs`, or an explicit
type, which must remain.

In ae5ff662, `ResetAttrs` was modified to duplicate
trees, rather than mutate trees in place. But the
tree copier didn't pass `wasEmpty` on to the new tree,
which in turn meant that the subsequent typing run
on the tree would not re-infer the types. If the
type refers to a local class, e.g. the anonymous
function in the enclosed test case, the reference
to the old symbol would persist.

This commit overrides `copyAttrs` in TypeTree to
copy `wasEmpty`.

We might consider representing this as a tree
attachment, but this would need to be validated
for the performance impact.
---
 src/reflect/scala/reflect/internal/Trees.scala | 13 +++++++++++++
 test/files/pos/t6648.scala                     | 24 ++++++++++++++++++++++++
 2 files changed, 37 insertions(+)
 create mode 100644 test/files/pos/t6648.scala

diff --git a/src/reflect/scala/reflect/internal/Trees.scala b/src/reflect/scala/reflect/internal/Trees.scala
index 53b40da8f6..b8f5e73acb 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/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
+}
+
-- 
cgit v1.2.3


From 88b4b91b0a9191c98dc3f80c1a2cbea1a5ff4e12 Mon Sep 17 00:00:00 2001
From: Josh Suereth <joshua.suereth@gmail.com>
Date: Wed, 24 Oct 2012 10:59:50 -0400
Subject: Fixes SI-6559 - StringContext not using passed in escape function.

As reported by Curtis Stanford, with indication of what to fix.  standardInterpolator was not correctly
calling the passed in process function, so raw strings were not really raw.
---
 test/files/run/t6559.scala | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 test/files/run/t6559.scala

diff --git a/test/files/run/t6559.scala b/test/files/run/t6559.scala
new file mode 100644
index 0000000000..5c671f7275
--- /dev/null
+++ b/test/files/run/t6559.scala
@@ -0,0 +1,17 @@
+
+object Test {
+
+  def main(args: Array[String]) = {
+     val one = "1"
+     val two = "2"
+
+     val raw = raw"\n$one\n$two\n"
+     val escaped = s"\n$one\n$two\n"
+     val buggy = "\\n1\n2\n"
+     val correct = "\\n1\\n2\\n"
+
+     assert(raw != escaped, "Raw strings should not be escaped.")
+     assert(raw != buggy, "Raw strings after variables should not be escaped.")
+     assert(raw == correct, "Raw strings should stay raw.")
+  }
+}
-- 
cgit v1.2.3


From ed7bd017852cf5e98d1a8089d0a0f6aefc0d4f68 Mon Sep 17 00:00:00 2001
From: phaller <hallerp@gmail.com>
Date: Tue, 13 Nov 2012 17:45:11 +0100
Subject: SI-6661 - Remove obsolete implicit parameter of
 scala.concurrent.promise method

Clarification of @heathermiller:
This is an inconsistency introduced after refactoring implicit ExecutionContexts.
In commit 1dfce90246f7d334 the implicit ExecutionContexts were removed from everything else in Promise.scala,
but it appears that method promise was missed in the scala.concurrent package object, which would've made
sense to remove back then.
---
 src/library/scala/concurrent/package.scala | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

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.
-- 
cgit v1.2.3


From 16b5a7e722bc9272815006b9a0629733d455d039 Mon Sep 17 00:00:00 2001
From: Paul Phillips <paulp@improving.org>
Date: Thu, 15 Nov 2012 09:26:16 -0800
Subject: Fixes SI-6628, Revert "Fix for view isEmpty."

This reverts commit caf7eb6b56817fd1e1fbc1cf017f30e6f94c6bea.

I don't have a better idea right now than wholesale reversion.
---
 src/library/scala/collection/IterableLike.scala    |  3 +--
 src/library/scala/collection/SeqLike.scala         |  1 -
 src/library/scala/collection/TraversableLike.scala |  5 ++--
 .../scala/collection/TraversableViewLike.scala     | 13 ++--------
 .../scala/collection/immutable/Stream.scala        |  1 -
 .../scala/collection/mutable/IndexedSeqLike.scala  |  1 -
 .../collection/parallel/ParIterableLike.scala      | 29 +++++++++++-----------
 .../scala/collection/parallel/ParSeqLike.scala     |  3 +--
 test/files/run/t6628.check                         |  2 ++
 test/files/run/t6628.scala                         | 11 ++++++++
 10 files changed, 33 insertions(+), 36 deletions(-)
 create mode 100644 test/files/run/t6628.check
 create mode 100644 test/files/run/t6628.scala

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/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)
+  }
+}
-- 
cgit v1.2.3


From 32c57329a6cb7ff1fa479a1fce884b8166f3fc50 Mon Sep 17 00:00:00 2001
From: Adriaan Moors <adriaan.moors@epfl.ch>
Date: Thu, 15 Nov 2012 16:48:03 -0800
Subject: SI-6624 set info of case pattern binder to help find case field
 accessors

sometimes the type checker infers a weird type for a sub-pattern of a case class/extractor pattern
this confuses the pattern matcher and it can't find the case field accessors for the sub-pattern

use the expected argument type of the extractor corresponding to the case class that we're matching
as the info for the sub-pattern binder -- this type more readily admits querying its caseFieldAccessors
---
 .../tools/nsc/typechecker/PatternMatching.scala    | 12 +++++++++-
 test/files/pos/t6624.scala                         | 28 ++++++++++++++++++++++
 2 files changed, 39 insertions(+), 1 deletion(-)
 create mode 100644 test/files/pos/t6624.scala

diff --git a/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala b/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
index 5beba77155..938866deef 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/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
-- 
cgit v1.2.3


From ea7246046ee7140ea07c8daa9c14cc2cd3111f5f Mon Sep 17 00:00:00 2001
From: Josh Suereth <joshua.suereth@gmail.com>
Date: Wed, 21 Nov 2012 08:29:41 -0500
Subject: Removing controversial `either` method from Futures API.

* Removes `either` from Future
* No tests need to change, since this was an untested method.
---
 src/library/scala/concurrent/Future.scala | 23 -----------------------
 1 file changed, 23 deletions(-)

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
-  }
-
 }
 
 
-- 
cgit v1.2.3