Merge commit 'b403234a27' into wip/fresh-merge2

Conflicts:
	src/compiler/scala/tools/nsc/matching/ParallelMatching.scala
	src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
	src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala
	test/files/neg/t6963.check

25 files changed, 423 insertions, 51 deletions

diff --git a/src/compiler/scala/tools/nsc/doc/model/IndexModelFactory.scala b/src/compiler/scala/tools/nsc/doc/model/IndexModelFactory.scala
index 1d6063255d..1272906df5 100755
--- a/src/compiler/scala/tools/nsc/doc/model/IndexModelFactory.scala
+++ b/src/compiler/scala/tools/nsc/doc/model/IndexModelFactory.scala
@@ -18,7 +18,7 @@ object IndexModelFactory {
       object result extends mutable.HashMap[Char,SymbolMap] {
 
         /* symbol name ordering */
-        implicit def orderingMap = math.Ordering.String.on { x: String => x.toLowerCase }
+        implicit def orderingMap = math.Ordering.String
 
         def addMember(d: MemberEntity) = {
           val firstLetter = {
diff --git a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala
index 748c6069f0..0e44ef63a1 100644
--- a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala
@@ -213,6 +213,7 @@ class MutableSettings(val errorFn: String => Unit)
   def OutputSetting(outputDirs: OutputDirs, default: String) = add(new OutputSetting(outputDirs, default))
   def PhasesSetting(name: String, descr: String, default: String = "") = add(new PhasesSetting(name, descr, default))
   def StringSetting(name: String, arg: String, descr: String, default: String) = add(new StringSetting(name, arg, descr, default))
+  def ScalaVersionSetting(name: String, arg: String, descr: String, default: ScalaVersion) = add(new ScalaVersionSetting(name, arg, descr, default))
   def PathSetting(name: String, descr: String, default: String): PathSetting = {
     val prepend = StringSetting(name + "/p", "", "", "").internalOnly()
     val append = StringSetting(name + "/a", "", "", "").internalOnly()
@@ -478,6 +479,35 @@ class MutableSettings(val errorFn: String => Unit)
     withHelpSyntax(name + " <" + arg + ">")
   }
 
+  /** A setting represented by a Scala version, (`default` unless set) */
+  class ScalaVersionSetting private[nsc](
+    name: String,
+    val arg: String,
+    descr: String,
+    default: ScalaVersion)
+  extends Setting(name, descr) {
+    import ScalaVersion._
+    
+    type T = ScalaVersion
+    protected var v: T = NoScalaVersion
+
+    override def tryToSet(args: List[String]) = {
+      value = default
+      Some(args)
+    }
+    
+    override def tryToSetColon(args: List[String]) = args match {
+      case Nil      => value = default; Some(Nil)
+      case x :: xs  => value = ScalaVersion(x, errorFn) ; Some(xs)
+    }
+    
+    override def tryToSetFromPropertyValue(s: String) = tryToSet(List(s))
+    
+    def unparse: List[String] = if (value == NoScalaVersion) Nil else List(s"${name}:${value.unparse}")
+
+    withHelpSyntax(s"${name}:<${arg}>")
+  }
+
   class PathSetting private[nsc](
     name: String,
     descr: String,
diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
index 0875c1879a..9fe3016c02 100644
--- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
@@ -82,8 +82,7 @@ trait ScalaSettings extends AbsScalaSettings
   val logFreeTerms  = BooleanSetting    ("-Xlog-free-terms", "Print a message when reification creates a free term.")
   val logFreeTypes  = BooleanSetting    ("-Xlog-free-types", "Print a message when reification resorts to generating a free type.")
   val maxClassfileName = IntSetting     ("-Xmax-classfile-name", "Maximum filename length for generated classes", 255, Some((72, 255)), _ => None)
-  val Xmigration28  = BooleanSetting    ("-Xmigration", "Warn about constructs whose behavior may have changed between 2.7 and 2.8.").
-                        withDeprecationMessage("This setting is no longer useful and will be removed. Please remove it from your build.")
+  val Xmigration    = ScalaVersionSetting("-Xmigration", "version", "Warn about constructs whose behavior may have changed since version.", AnyScalaVersion)
   val nouescape     = BooleanSetting    ("-Xno-uescape", "Disable handling of \\u unicode escapes.")
   val Xnojline      = BooleanSetting    ("-Xnojline", "Do not use JLine for editing.")
   val Xverify       = BooleanSetting    ("-Xverify", "Verify generic signatures in generated bytecode (asm backend only.)")
diff --git a/src/compiler/scala/tools/nsc/settings/ScalaVersion.scala b/src/compiler/scala/tools/nsc/settings/ScalaVersion.scala
new file mode 100644
index 0000000000..d6a0149411
--- /dev/null
+++ b/src/compiler/scala/tools/nsc/settings/ScalaVersion.scala
@@ -0,0 +1,194 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2013 LAMP/EPFL
+ * @author  James Iry
+ */
+// $Id$
+
+package scala.tools.nsc.settings
+
+/**
+ * Represents a single Scala version in a manner that
+ * supports easy comparison and sorting.
+ */
+abstract class ScalaVersion extends Ordered[ScalaVersion] {
+  def unparse: String
+}
+
+/**
+ * A scala version that sorts higher than all actual versions
+ */
+case object NoScalaVersion extends ScalaVersion {
+  def unparse = "none"
+      
+  def compare(that: ScalaVersion): Int = that match {
+    case NoScalaVersion => 0
+    case _ => 1
+  }
+}
+
+/**
+ * A specific Scala version, not one of the magic min/max versions. An SpecificScalaVersion
+ * may or may not be a released version - i.e. this same class is used to represent
+ * final, release candidate, milestone, and development builds. The build argument is used
+ * to segregate builds
+ */
+case class SpecificScalaVersion(major: Int, minor: Int, rev: Int, build: ScalaBuild) extends ScalaVersion {
+  def unparse = s"${major}.${minor}.${rev}.${build.unparse}"  
+
+  def compare(that: ScalaVersion): Int =  that match {
+    case SpecificScalaVersion(thatMajor, thatMinor, thatRev, thatBuild) =>
+      // this could be done more cleanly by importing scala.math.Ordering.Implicits, but we have to do these
+      // comparisons a lot so I'm using brute force direct style code
+      if (major < thatMajor) -1
+      else if (major > thatMajor) 1
+      else if (minor < thatMinor) -1
+      else if (minor > thatMinor) 1
+      else if (rev < thatRev) -1
+      else if (rev > thatRev) 1
+      else build compare thatBuild
+    case AnyScalaVersion => 1
+    case NoScalaVersion => -1
+  }  
+}
+
+/**
+ * A Scala version that sorts lower than all actual versions
+ */
+case object AnyScalaVersion extends ScalaVersion {
+  def unparse = "any"
+      
+  def compare(that: ScalaVersion): Int = that match {
+    case AnyScalaVersion => 0
+    case _ => -1
+  }
+}
+
+/**
+ * Factory methods for producing ScalaVersions
+ */
+object ScalaVersion {
+  private val dot = "\\."
+  private val dash = "\\-"
+  private def not(s:String) = s"[^${s}]"
+  private val R = s"((${not(dot)}*)(${dot}(${not(dot)}*)(${dot}(${not(dash)}*)(${dash}(.*))?)?)?)".r  
+
+  def apply(versionString : String, errorHandler: String => Unit): ScalaVersion = {
+    def errorAndValue() = {
+        errorHandler(
+          s"There was a problem parsing ${versionString}. " +
+          "Versions should be in the form major[.minor[.revision]] " +
+          "where each part is a positive number, as in 2.10.1. " +
+          "The minor and revision parts are optional."
+        )
+        AnyScalaVersion
+    }
+    
+    def toInt(s: String) = s match {
+      case null | "" => 0
+      case _ => s.toInt
+    }
+    
+    def isInt(s: String) = util.Try(toInt(s)).isSuccess
+    
+    def toBuild(s: String) = s match {
+      case null | "FINAL" => Final
+      case s if (s.toUpperCase.startsWith("RC") && isInt(s.substring(2))) => RC(toInt(s.substring(2)))
+      case s if (s.toUpperCase.startsWith("M") && isInt(s.substring(1))) => Milestone(toInt(s.substring(1)))
+      case _ => Development(s)
+    }
+    
+    try versionString match {
+      case "none" => NoScalaVersion
+      case "any" => AnyScalaVersion
+      case R(_, majorS, _, minorS, _, revS, _, buildS) => 
+        SpecificScalaVersion(toInt(majorS), toInt(minorS), toInt(revS), toBuild(buildS))
+      case _ => 
+        errorAndValue()
+    } catch {
+      case e: NumberFormatException => errorAndValue()
+    }
+  }
+  
+  def apply(versionString: String): ScalaVersion = 
+      apply(versionString, msg => throw new NumberFormatException(msg))
+  
+  /**
+   * The version of the compiler running now
+   */
+  val current = apply(util.Properties.versionNumberString)
+  
+  /**
+   * The 2.8.0 version.
+   */
+  val twoDotEight = SpecificScalaVersion(2, 8, 0, Final)
+}
+
+/**
+ * Represents the data after the dash in major.minor.rev-build
+ */
+abstract class ScalaBuild extends Ordered[ScalaBuild] {  
+  /**
+   * Return a version of this build information that can be parsed back into the
+   * same ScalaBuild
+   */
+  def unparse: String
+}
+/**
+ * A development, test, nightly, snapshot or other "unofficial" build
+ */
+case class Development(id: String) extends ScalaBuild {
+  def unparse = s"-${id}"
+      
+  def compare(that: ScalaBuild) = that match {
+    // sorting two development builds based on id is reasonably valid for two versions created with the same schema
+    // otherwise it's not correct, but since it's impossible to put a total ordering on development build versions
+    // this is a pragmatic compromise
+    case Development(thatId) => id compare thatId
+    // assume a development build is newer than anything else, that's not really true, but good luck
+    // mapping development build versions to other build types
+    case _ => 1
+  }
+}
+/**
+ * A final final
+ */
+case object Final extends ScalaBuild {
+  def unparse = ""
+      
+  def compare(that: ScalaBuild) = that match {
+    case Final => 0
+    // a final is newer than anything other than a development build or another final
+    case Development(_) => -1
+    case _ => 1
+  }
+}
+
+/**
+ * A candidate for final release
+ */
+case class RC(n: Int) extends ScalaBuild {
+  def unparse = s"-RC${n}"
+      
+  def compare(that: ScalaBuild) = that match {
+    // compare two rcs based on their RC numbers
+    case RC(thatN) => n - thatN
+    // an rc is older than anything other than a milestone or another rc
+    case Milestone(_) => 1
+    case _ => -1    
+  }  
+}
+
+/**
+ * An intermediate release
+ */
+case class Milestone(n: Int) extends ScalaBuild {
+  def unparse = s"-M${n}"
+      
+  def compare(that: ScalaBuild) = that match {
+    // compare two milestones based on their milestone numbers
+    case Milestone(thatN) => n - thatN
+    // a milestone is older than anything other than another milestone
+    case _ => -1
+    
+  }  
+}
diff --git a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
index 7a2caf2330..0e991a5d72 100644
--- a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
+++ b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
@@ -9,6 +9,7 @@ package transform
 import symtab._
 import Flags.{ CASE => _, _ }
 import scala.collection.mutable.ListBuffer
+import scala.tools.nsc.settings.ScalaVersion
 
 /** This class ...
  *
@@ -461,6 +462,13 @@ abstract class ExplicitOuter extends InfoTransform
           }
 
         case _ =>
+          if (settings.Xmigration.value < ScalaVersion.twoDotEight) tree match {
+            case TypeApply(fn @ Select(qual, _), args) if fn.symbol == Object_isInstanceOf || fn.symbol == Any_isInstanceOf =>
+              if (isArraySeqTest(qual.tpe, args.head.tpe))
+                unit.warning(tree.pos, "An Array will no longer match as Seq[_].")
+            case _ => ()
+          }
+
           val x = super.transform(tree)
           if (x.tpe eq null) x
           else x setType transformInfo(currentOwner, x.tpe)
diff --git a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala
index dd60b292bf..fa141e95e1 100644
--- a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala
@@ -265,26 +265,32 @@ trait NamesDefaults { self: Analyzer =>
      *
      * For by-name parameters, create a value
      *  x$n: () => T = () => arg
+     *
+     * For Ident(<unapply-selector>) arguments, no ValDef is created (SI-3353).
      */
-    def argValDefs(args: List[Tree], paramTypes: List[Type], blockTyper: Typer): List[ValDef] = {
+    def argValDefs(args: List[Tree], paramTypes: List[Type], blockTyper: Typer): List[Option[ValDef]] = {
       val context = blockTyper.context
-      val symPs = map2(args, paramTypes)((arg, tpe) => {
-        val byName   = isByNameParamType(tpe)
-        val repeated = isScalaRepeatedParamType(tpe)
-        val argTpe = (
-          if (repeated) arg match {
-            case Typed(expr, Ident(tpnme.WILDCARD_STAR)) => expr.tpe
-            case _                                       => seqType(arg.tpe)
-          }
-          else arg.tpe
-        ).widen // have to widen or types inferred from literal defaults will be singletons
-        val s = context.owner.newValue(unit.freshTermName("x$"), arg.pos, newFlags = ARTIFACT) setInfo (
-          if (byName) functionType(Nil, argTpe) else argTpe
-        )
-        (context.scope.enter(s), byName, repeated)
+      val symPs = map2(args, paramTypes)((arg, tpe) => arg match {
+        case Ident(nme.SELECTOR_DUMMY) =>
+          None // don't create a local ValDef if the argument is <unapply-selector>
+        case _ =>
+          val byName   = isByNameParamType(tpe)
+          val repeated = isScalaRepeatedParamType(tpe)
+          val argTpe = (
+            if (repeated) arg match {
+              case Typed(expr, Ident(tpnme.WILDCARD_STAR)) => expr.tpe
+              case _                                       => seqType(arg.tpe)
+            }
+            else arg.tpe
+            ).widen // have to widen or types inferred from literal defaults will be singletons
+          val s = context.owner.newValue(unit.freshTermName("x$"), arg.pos, newFlags = ARTIFACT) setInfo (
+              if (byName) functionType(Nil, argTpe) else argTpe
+              )
+          Some((context.scope.enter(s), byName, repeated))
       })
       map2(symPs, args) {
-        case ((sym, byName, repeated), arg) =>
+        case (None, _) => None
+        case (Some((sym, byName, repeated)), arg) =>
           val body =
             if (byName) {
               val res = blockTyper.typed(Function(List(), arg))
@@ -300,7 +306,7 @@ trait NamesDefaults { self: Analyzer =>
                   blockTyper.typed(Apply(factory, List(resetLocalAttrs(arg))))
               } else arg
             }
-          atPos(body.pos)(ValDef(sym, body).setType(NoType))
+          Some(atPos(body.pos)(ValDef(sym, body).setType(NoType)))
       }
     }
 
@@ -326,27 +332,29 @@ trait NamesDefaults { self: Analyzer =>
             // ValDef's in the block), change the arguments to these local values.
             case Apply(expr, typedArgs) =>
               // typedArgs: definition-site order
-              val formals = formalTypes(expr.tpe.paramTypes, typedArgs.length, false, false)
+              val formals = formalTypes(expr.tpe.paramTypes, typedArgs.length, removeByName = false, removeRepeated = false)
               // valDefs: call-site order
               val valDefs = argValDefs(reorderArgsInv(typedArgs, argPos),
                                        reorderArgsInv(formals, argPos),
                                        blockTyper)
               // refArgs: definition-site order again
-              val refArgs = map2(reorderArgs(valDefs, argPos), formals)((vDef, tpe) => {
-                val ref = gen.mkAttributedRef(vDef.symbol)
-                atPos(vDef.pos.focus) {
-                  // for by-name parameters, the local value is a nullary function returning the argument
-                  tpe.typeSymbol match {
-                    case ByNameParamClass   => Apply(ref, Nil)
-                    case RepeatedParamClass => Typed(ref, Ident(tpnme.WILDCARD_STAR))
-                    case _                  => ref
+              val refArgs = map3(reorderArgs(valDefs, argPos), formals, typedArgs)((vDefOpt, tpe, origArg) => vDefOpt match {
+                case None => origArg
+                case Some(vDef) =>
+                  val ref = gen.mkAttributedRef(vDef.symbol)
+                  atPos(vDef.pos.focus) {
+                    // for by-name parameters, the local value is a nullary function returning the argument
+                    tpe.typeSymbol match {
+                      case ByNameParamClass   => Apply(ref, Nil)
+                      case RepeatedParamClass => Typed(ref, Ident(tpnme.WILDCARD_STAR))
+                      case _                  => ref
+                    }
                   }
-                }
               })
               // cannot call blockTyper.typedBlock here, because the method expr might be partially applied only
               val res = blockTyper.doTypedApply(tree, expr, refArgs, mode, pt)
               res.setPos(res.pos.makeTransparent)
-              val block = Block(stats ::: valDefs, res).setType(res.tpe).setPos(tree.pos.makeTransparent)
+              val block = Block(stats ::: valDefs.flatten, res).setType(res.tpe).setPos(tree.pos.makeTransparent)
               context.namedApplyBlockInfo =
                 Some((block, NamedApplyInfo(qual, targs, vargss :+ refArgs, blockTyper)))
               block
diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
index 285e1cb7af..7c60ce275a 100644
--- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
@@ -11,6 +11,9 @@ import scala.collection.{ mutable, immutable }
 import transform.InfoTransform
 import scala.collection.mutable.ListBuffer
 import scala.language.postfixOps
+import scala.tools.nsc.settings.ScalaVersion
+import scala.tools.nsc.settings.AnyScalaVersion
+import scala.tools.nsc.settings.NoScalaVersion
 
 /** <p>
  *    Post-attribution checking and transformation.
@@ -1233,10 +1236,18 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
      *  indicating it has changed semantics between versions.
      */
     private def checkMigration(sym: Symbol, pos: Position) = {
-      if (sym.hasMigrationAnnotation)
-        unit.warning(pos, "%s has changed semantics in version %s:\n%s".format(
-          sym.fullLocationString, sym.migrationVersion.get, sym.migrationMessage.get)
-        )
+      if (sym.hasMigrationAnnotation) {
+        val changed = try 
+          settings.Xmigration.value < ScalaVersion(sym.migrationVersion.get)
+        catch {
+          case e : NumberFormatException => 
+            unit.warning(pos, s"${sym.fullLocationString} has an unparsable version number: ${e.getMessage()}")
+            // if we can't parse the format on the migration annotation just conservatively assume it changed         
+            true
+        }
+        if (changed)
+          unit.warning(pos, s"${sym.fullLocationString} has changed semantics in version ${sym.migrationVersion.get}:\n${sym.migrationMessage.get}")
+      }
     }
 
     private def checkCompileTimeOnly(sym: Symbol, pos: Position) = {
@@ -1449,7 +1460,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
        *  arbitrarily choose one as more important than the other.
        */
       checkDeprecated(sym, tree.pos)
-      if (settings.Xmigration28.value)
+      if(settings.Xmigration.value != NoScalaVersion)
         checkMigration(sym, tree.pos)
       checkCompileTimeOnly(sym, tree.pos)
 
diff --git a/src/library/scala/annotation/migration.scala b/src/library/scala/annotation/migration.scala
index 49fea9434c..adb6de6afd 100644
--- a/src/library/scala/annotation/migration.scala
+++ b/src/library/scala/annotation/migration.scala
@@ -17,7 +17,8 @@ package scala.annotation
  * order between Scala 2.7 and 2.8.
  *
  * @param message A message describing the change, which is emitted
- * by the compiler if the flag `-Xmigration` is set.
+ * by the compiler if the flag `-Xmigration` indicates a version 
+ * prior to the changedIn version.
  *
  * @param changedIn The version, in which the behaviour change was
  * introduced.
diff --git a/src/library/scala/collection/mutable/ListMap.scala b/src/library/scala/collection/mutable/ListMap.scala
index 212ee917c5..7f05deffc8 100644
--- a/src/library/scala/collection/mutable/ListMap.scala
+++ b/src/library/scala/collection/mutable/ListMap.scala
@@ -12,6 +12,7 @@ package scala.collection
 package mutable
 
 import generic._
+import annotation.tailrec
 
 /** A simple mutable map backed by a list.
  *
@@ -47,13 +48,17 @@ extends AbstractMap[A, B]
 
   def get(key: A): Option[B] = elems find (_._1 == key) map (_._2)
   def iterator: Iterator[(A, B)] = elems.iterator
-  def += (kv: (A, B)) = { elems = remove(kv._1, elems); elems = kv :: elems; siz += 1; this }
-  def -= (key: A) = { elems = remove(key, elems); this }
 
-  private def remove(key: A, elems: List[(A, B)]): List[(A, B)] =
-    if (elems.isEmpty) elems
-    else if (elems.head._1 == key) { siz -= 1; elems.tail }
-    else elems.head :: remove(key, elems.tail)
+  def += (kv: (A, B)) = { elems = remove(kv._1, elems, List()); elems = kv :: elems; siz += 1; this }
+  def -= (key: A) = { elems = remove(key, elems, List()); this }
+
+  @tailrec
+  private def remove(key: A, elems: List[(A, B)], acc: List[(A, B)]): List[(A, B)] = {
+    if (elems.isEmpty) acc
+    else if (elems.head._1 == key) { siz -= 1; acc ::: elems.tail }
+    else remove(key, elems.tail, elems.head :: acc)
+  }
+
 
   override def clear() = { elems = List(); siz = 0 }
   override def size: Int = siz
diff --git a/test/files/neg/t6963.check b/test/files/neg/t6963.check
deleted file mode 100644
index cc4a7a48fc..0000000000
--- a/test/files/neg/t6963.check
+++ /dev/null
@@ -1,4 +0,0 @@
-warning: -Xmigration is deprecated: This setting is no longer useful and will be removed. Please remove it from your build.
-error: No warnings can be incurred under -Xfatal-warnings.
-one warning found
-one error found
diff --git a/test/files/neg/t6963.flags b/test/files/neg/t6963.flags
deleted file mode 100644
index 0b6d71496a..0000000000
--- a/test/files/neg/t6963.flags
+++ /dev/null
@@ -1 +0,0 @@
--Xmigration -deprecation -Xfatal-warnings
\ No newline at end of file
diff --git a/test/files/neg/t6963.scala b/test/files/neg/t6963.scala
deleted file mode 100644
index 4da52764f5..0000000000
--- a/test/files/neg/t6963.scala
+++ /dev/null
@@ -1,3 +0,0 @@
-
-object test {
-}
diff --git a/test/files/neg/t6963a.check b/test/files/neg/t6963a.check
new file mode 100644
index 0000000000..159896fd10
--- /dev/null
+++ b/test/files/neg/t6963a.check
@@ -0,0 +1,5 @@
+t6963a.scala:4: error: method scanRight in trait TraversableLike has changed semantics in version 2.9.0:
+The behavior of `scanRight` has changed. The previous behavior can be reproduced with scanRight.reverse.
+  List(1,2,3,4,5).scanRight(0)(_+_)
+                  ^
+one error found
diff --git a/test/files/neg/t6963a.flags b/test/files/neg/t6963a.flags
new file mode 100644
index 0000000000..4c61ed9430
--- /dev/null
+++ b/test/files/neg/t6963a.flags
@@ -0,0 +1 @@
+-Xfatal-warnings -Xmigration:2.7
diff --git a/test/files/neg/t6963a.scala b/test/files/neg/t6963a.scala
new file mode 100644
index 0000000000..b3366b2557
--- /dev/null
+++ b/test/files/neg/t6963a.scala
@@ -0,0 +1,5 @@
+object Test {
+  import scala.collection.mutable._
+  
+  List(1,2,3,4,5).scanRight(0)(_+_)
+}
diff --git a/test/files/neg/t6963b.check b/test/files/neg/t6963b.check
new file mode 100644
index 0000000000..7e205a41d0
--- /dev/null
+++ b/test/files/neg/t6963b.check
@@ -0,0 +1,13 @@
+t6963b.scala:2: error: An Array will no longer match as Seq[_].
+  def f1(x: Any) = x.isInstanceOf[Seq[_]]
+                                 ^
+t6963b.scala:4: error: An Array will no longer match as Seq[_].
+    case _: Seq[_]  => true
+          ^
+t6963b.scala:16: error: An Array will no longer match as Seq[_].
+    case (Some(_: Seq[_]), Nil, _)        => 1
+                ^
+t6963b.scala:17: error: An Array will no longer match as Seq[_].
+    case (None, List(_: List[_], _), _)   => 2
+                    ^
+four errors found
diff --git a/test/files/neg/t6963b.flags b/test/files/neg/t6963b.flags
new file mode 100644
index 0000000000..83caa2b147
--- /dev/null
+++ b/test/files/neg/t6963b.flags
@@ -0,0 +1 @@
+-Xmigration:2.7 -Xfatal-warnings
\ No newline at end of file
diff --git a/test/files/neg/t6963b.scala b/test/files/neg/t6963b.scala
new file mode 100644
index 0000000000..3cfa8f0dca
--- /dev/null
+++ b/test/files/neg/t6963b.scala
@@ -0,0 +1,20 @@
+object Test {
+  def f1(x: Any) = x.isInstanceOf[Seq[_]]
+  def f2(x: Any) = x match {
+    case _: Seq[_]  => true
+    case _          => false
+  }
+
+  def f3(x: Any) = x match {
+    case _: Array[_]  => true
+    case _            => false
+  }
+  
+  def f4(x: Any) = x.isInstanceOf[Traversable[_]]
+  
+  def f5(x1: Any, x2: Any, x3: AnyRef) = (x1, x2, x3) match {
+    case (Some(_: Seq[_]), Nil, _)        => 1
+    case (None, List(_: List[_], _), _)   => 2
+    case _                                => 3
+  }
+}
diff --git a/test/files/pos/t6963c.flags b/test/files/pos/t6963c.flags
new file mode 100644
index 0000000000..4d6e04914f
--- /dev/null
+++ b/test/files/pos/t6963c.flags
@@ -0,0 +1 @@
+-Xmigration:2.9 -Xfatal-warnings
\ No newline at end of file
diff --git a/test/files/pos/t6963c.scala b/test/files/pos/t6963c.scala
new file mode 100644
index 0000000000..0b6b5c757f
--- /dev/null
+++ b/test/files/pos/t6963c.scala
@@ -0,0 +1,25 @@
+object Test {
+  def f1(x: Any) = x.isInstanceOf[Seq[_]]
+  def f2(x: Any) = x match {
+    case _: Seq[_]  => true
+    case _          => false
+  }
+
+  def f3(x: Any) = x match {
+    case _: Array[_]  => true
+    case _            => false
+  }
+  
+  def f4(x: Any) = x.isInstanceOf[Traversable[_]]
+  
+  def f5(x1: Any, x2: Any, x3: AnyRef) = (x1, x2, x3) match {
+    case (Some(_: Seq[_]), Nil, _)        => 1
+    case (None, List(_: List[_], _), _)   => 2
+    case _                                => 3
+  }
+
+  def f5: Unit = {
+    import scala.collection.mutable._
+    List(1,2,3,4,5).scanRight(0)(_+_)
+  }
+}
diff --git a/test/files/run/t3353.check b/test/files/run/t3353.check
new file mode 100644
index 0000000000..8b4ae1fe69
--- /dev/null
+++ b/test/files/run/t3353.check
@@ -0,0 +1 @@
+Got: foo and None
diff --git a/test/files/run/t3353.scala b/test/files/run/t3353.scala
new file mode 100644
index 0000000000..eeb63c1b05
--- /dev/null
+++ b/test/files/run/t3353.scala
@@ -0,0 +1,10 @@
+object Test extends App {
+
+  "foo" match {
+    case Matcher(result) => println(result)
+  }
+
+  object Matcher{
+    def unapply(s: String)(implicit secondParam: Option[String] = None) = Some("Got: " + s + " and " + secondParam)
+  }
+}
diff --git a/test/files/run/t6853.scala b/test/files/run/t6853.scala
new file mode 100644
index 0000000000..352375c99c
--- /dev/null
+++ b/test/files/run/t6853.scala
@@ -0,0 +1,18 @@
+// Test cases: the only place we can cut and paste without crying
+// ourself to sleep.
+object Test {
+
+  def main(args: Array[String]): Unit = {
+    // First testing the basic operations
+    val m = collection.mutable.ListMap[String, Int]()
+    var i = 0
+    while(i < 2) { m += ("foo" + i) -> i; i = i+1}
+    assert(m == Map("foo1"->1,"foo0"->0))
+    m-= "foo0"
+    assert(m == Map("foo1"->1))
+    // Now checking if it scales as described in SI-6853
+    i = 0
+    while(i < 80000) { m += ("foo" + i) -> i; i = i+1}
+    assert(m.size == 80000)
+  }
+}
diff --git a/test/scaladoc/run/SI-6017.check b/test/scaladoc/run/SI-6017.check
new file mode 100644
index 0000000000..619c56180b
--- /dev/null
+++ b/test/scaladoc/run/SI-6017.check
@@ -0,0 +1 @@
+Done.
diff --git a/test/scaladoc/run/SI-6017.scala b/test/scaladoc/run/SI-6017.scala
new file mode 100644
index 0000000000..a4950e48d8
--- /dev/null
+++ b/test/scaladoc/run/SI-6017.scala
@@ -0,0 +1,23 @@
+import scala.tools.nsc.doc
+import scala.tools.nsc.doc.model._
+import scala.tools.nsc.doc.html.page.{Index, ReferenceIndex}
+import scala.tools.partest.ScaladocModelTest
+
+object Test extends ScaladocModelTest {
+  override def scaladocSettings = ""
+  override def code = """
+    class STAR
+    class Star
+  """
+
+  def testModel(rootPackage: Package) {
+    model match {
+      case Some(universe) => {
+        val index = IndexModelFactory.makeIndex(universe)
+        // Because "STAR" and "Star" are different
+        assert(index.firstLetterIndex('s').keys.toSeq.length == 2)
+      }
+      case _ => assert(false)
+    }
+  }
+}