Merge branch '2.10.x'

Patches applied:
 - rename of `dropRepeatedParamType` to `dropIllegalStarTypes` -- required since 8886d22cd6
 - fixed test/files/neg/t6406-regextract.flags -- how could this have worked before?

Conflicts:
	src/compiler/scala/tools/nsc/interpreter/TypeStrings.scala
	src/library/scala/collection/LinearSeqOptimized.scala
	src/library/scala/util/Properties.scala
	test/files/run/streams.check
	test/files/run/streams.scala

13 files changed, 89 insertions, 40 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVMASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVMASM.scala
index f0f91e7d1a..50fd59b23f 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVMASM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVMASM.scala
@@ -78,17 +78,19 @@ trait GenJVMASM {
           failNoForwarder("companion is a trait")
         // Now either succeeed, or issue some additional warnings for things which look like
         // attempts to be java main methods.
-        else possibles exists { m =>
-          m.info match {
-            case PolyType(_, _) =>
-              fail("main methods cannot be generic.")
-            case MethodType(params, res) =>
-              if (res.typeSymbol :: params exists (_.isAbstractType))
-                fail("main methods cannot refer to type parameters or abstract types.", m.pos)
-              else
-                isJavaMainMethod(m) || fail("main method must have exact signature (Array[String])Unit", m.pos)
-            case tp =>
-              fail("don't know what this is: " + tp, m.pos)
+        else (possibles exists isJavaMainMethod) || {
+          possibles exists { m =>
+            m.info match {
+              case PolyType(_, _) =>
+                fail("main methods cannot be generic.")
+              case MethodType(params, res) =>
+                if (res.typeSymbol :: params exists (_.isAbstractType))
+                  fail("main methods cannot refer to type parameters or abstract types.", m.pos)
+                else
+                  isJavaMainMethod(m) || fail("main method must have exact signature (Array[String])Unit", m.pos)
+              case tp =>
+                fail("don't know what this is: " + tp, m.pos)
+            }
           }
         }
       }
diff --git a/src/compiler/scala/tools/nsc/interpreter/TypeStrings.scala b/src/compiler/scala/tools/nsc/interpreter/TypeStrings.scala
index 239dbb8149..33311f5bb3 100644
--- a/src/compiler/scala/tools/nsc/interpreter/TypeStrings.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/TypeStrings.scala
@@ -205,7 +205,7 @@ trait TypeStrings {
   }
 
   private def tparamString[T: ru.TypeTag] : String = {
-    import ru._
+    import ru._ // get TypeRefTag in scope so that pattern match works (TypeRef is an abstract type)
     def typeArguments: List[ru.Type] = ru.typeOf[T] match { case ru.TypeRef(_, _, args) => args; case _ => Nil }
     brackets(typeArguments map (jc => tvarString(List(jc))): _*)
   }
diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
index 07135c3af9..ff3e856471 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
@@ -146,11 +146,23 @@ trait SyntheticMethods extends ast.TreeDSL {
         Ident(m.firstParam) IS_OBJ classExistentialType(clazz))
     }
 
-    /** (that.isInstanceOf[this.C])
-     *  where that is the given methods first parameter.
+    /** that match { case _: this.C => true ; case _ => false }
+     *  where `that` is the given method's first parameter.
+     *
+     *  An isInstanceOf test is insufficient because it has weaker
+     *  requirements than a pattern match. Given an inner class Foo and
+     *  two different instantiations of the container, an x.Foo and and a y.Foo
+     *  are both .isInstanceOf[Foo], but the one does not match as the other.
      */
-    def thatTest(eqmeth: Symbol): Tree =
-      gen.mkIsInstanceOf(Ident(eqmeth.firstParam), classExistentialType(clazz), true, false)
+    def thatTest(eqmeth: Symbol): Tree = {
+      Match(
+        Ident(eqmeth.firstParam),
+        List(
+          CaseDef(Typed(Ident(nme.WILDCARD), TypeTree(clazz.tpe)), EmptyTree, TRUE),
+          CaseDef(WILD.empty, EmptyTree, FALSE)
+        )
+      )
+    }
 
     /** (that.asInstanceOf[this.C])
      *  where that is the given methods first parameter.
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index d72978cb1a..b853f687a7 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -5189,12 +5189,18 @@ trait Typers extends Modes with Adaptations with Tags {
               "context.owner"    -> context.owner
             )
           )
-          val tree1 = typed1(tree, mode, dropExistential(pt))
+          typed1(tree, mode, dropExistential(pt))
+        }
+        // Can happen during erroneous compilation - error(s) have been
+        // reported, but we need to avoid causing an NPE with this tree
+        if (tree1.tpe eq null)
+          return setError(tree)
+
+        if (!alreadyTyped) {
           printTyping("typed %s: %s%s".format(
             ptTree(tree1), tree1.tpe,
             if (isSingleType(tree1.tpe)) " with underlying "+tree1.tpe.widen else "")
           )
-          tree1
         }
 
         tree1 modifyType (addAnnotations(tree1, _))
diff --git a/src/compiler/scala/tools/nsc/util/ClassPath.scala b/src/compiler/scala/tools/nsc/util/ClassPath.scala
index cbf6ef69d7..c51fc442dc 100644
--- a/src/compiler/scala/tools/nsc/util/ClassPath.scala
+++ b/src/compiler/scala/tools/nsc/util/ClassPath.scala
@@ -14,6 +14,7 @@ import scala.reflect.internal.util.StringOps.splitWhere
 import Jar.isJarOrZip
 import File.pathSeparator
 import java.net.MalformedURLException
+import java.util.regex.PatternSyntaxException
 
 /** <p>
  *    This module provides star expansion of '-classpath' option arguments, behaves the same as
@@ -34,8 +35,11 @@ object ClassPath {
     if (pattern == "*") lsDir(Directory("."))
     else if (pattern endsWith wildSuffix) lsDir(Directory(pattern dropRight 2))
     else if (pattern contains '*') {
-      val regexp = ("^%s$" format pattern.replaceAll("""\*""", """.*""")).r
-      lsDir(Directory(pattern).parent, regexp findFirstIn _ isDefined)
+      try {
+        val regexp = ("^" + pattern.replaceAllLiterally("""\*""", """.*""") + "$").r
+        lsDir(Directory(pattern).parent, regexp findFirstIn _ isDefined)
+      }
+      catch { case _: PatternSyntaxException => List(pattern) }
     }
     else List(pattern)
   }
diff --git a/src/library/scala/collection/LinearSeqOptimized.scala b/src/library/scala/collection/LinearSeqOptimized.scala
index f71fd227cd..ed5f2406e8 100755
--- a/src/library/scala/collection/LinearSeqOptimized.scala
+++ b/src/library/scala/collection/LinearSeqOptimized.scala
@@ -10,6 +10,8 @@ package scala.collection
 
 import mutable.ListBuffer
 import immutable.List
+import scala.util.control.Breaks._
+import scala.annotation.tailrec
 
 /** A template trait for linear sequences of type `LinearSeq[A]`  which optimizes
  *  the implementation of several methods under the assumption of fast linear access.
@@ -89,7 +91,7 @@ trait LinearSeqOptimized[+A, +Repr <: LinearSeqOptimized[A, Repr]] extends Linea
     }
     false
   }
-
+  
   override /*IterableLike*/
   def find(p: A => Boolean): Option[A] = {
     var these = this
@@ -110,7 +112,7 @@ trait LinearSeqOptimized[+A, +Repr <: LinearSeqOptimized[A, Repr]] extends Linea
     }
     acc
   }
-
+  
   override /*IterableLike*/
   def foldRight[B](z: B)(f: (A, B) => B): B =
     if (this.isEmpty) z
@@ -245,14 +247,17 @@ trait LinearSeqOptimized[+A, +Repr <: LinearSeqOptimized[A, Repr]] extends Linea
   }
 
   override /*SeqLike*/
-  def lengthCompare(len: Int): Int =  {
-    var i = 0
-    var these = self
-    while (!these.isEmpty && i <= len) {
-      i += 1
-      these = these.tail
+  def lengthCompare(len: Int): Int = {
+    @tailrec def loop(i: Int, xs: Repr): Int = {
+      if (i == len)
+        if (xs.isEmpty) 0 else 1
+      else if (xs.isEmpty)
+        -1
+      else
+        loop(i + 1, xs.tail)
     }
-    i - len
+    if (len < 0) 1
+    else loop(0, this)
   }
 
   override /*SeqLike*/
diff --git a/src/library/scala/collection/SeqLike.scala b/src/library/scala/collection/SeqLike.scala
index 955ebce6bd..35df680783 100644
--- a/src/library/scala/collection/SeqLike.scala
+++ b/src/library/scala/collection/SeqLike.scala
@@ -84,13 +84,17 @@ trait SeqLike[+A, +Repr] extends Any with IterableLike[A, Repr] with GenSeqLike[
    *  if computing `length` is cheap.
    */
   def lengthCompare(len: Int): Int = {
-    var i = 0
-    val it = iterator
-    while (it.hasNext && i <= len) {
-      it.next()
-      i += 1
+    if (len < 0) 1
+    else {
+      var i = 0
+      val it = iterator
+      while (it.hasNext) {
+        if (i == len) return if (it.hasNext) 1 else 0
+        it.next()
+        i += 1
+      }
+      i - len
     }
-    i - len
   }
 
   override /*IterableLike*/ def isEmpty: Boolean = lengthCompare(0) == 0
diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala
index 3f7d27981b..e2719df531 100644
--- a/src/library/scala/collection/immutable/Stream.scala
+++ b/src/library/scala/collection/immutable/Stream.scala
@@ -630,7 +630,7 @@ self =>
    *
    * @example {{{
    * $naturalsEx
-   * naturalsFrom(1) zip naturalsFrom(2) zip take 5 foreach println
+   * naturalsFrom(1) zip naturalsFrom(2) take 5 foreach println
    * // prints
    * // (1,2)
    * // (2,3)
diff --git a/src/library/scala/collection/mutable/ArrayOps.scala b/src/library/scala/collection/mutable/ArrayOps.scala
index bb938a7aeb..6b778b26f5 100644
--- a/src/library/scala/collection/mutable/ArrayOps.scala
+++ b/src/library/scala/collection/mutable/ArrayOps.scala
@@ -52,6 +52,20 @@ trait ArrayOps[T] extends Any with ArrayLike[T, Array[T]] with CustomParalleliza
       super.toArray[U]
   }
 
+  def :+[B >: T: scala.reflect.ClassTag](elem: B): Array[B] = {
+    val result = Array.ofDim[B](repr.length + 1)
+    Array.copy(repr, 0, result, 0, repr.length)
+    result(repr.length) = elem
+    result
+  }
+
+  def +:[B >: T: scala.reflect.ClassTag](elem: B): Array[B] = {
+    val result = Array.ofDim[B](repr.length + 1)
+    result(0) = elem
+    Array.copy(repr, 0, result, 1, repr.length)
+    result
+  }
+
   override def par = ParArray.handoff(repr)
 
   /** Flattens a two-dimensional array by concatenating all its rows
diff --git a/src/library/scala/util/Properties.scala b/src/library/scala/util/Properties.scala
index 691840cf76..cc145134c4 100644
--- a/src/library/scala/util/Properties.scala
+++ b/src/library/scala/util/Properties.scala
@@ -102,7 +102,7 @@ private[scala] trait PropertiesTrait {
    *  or "version (unknown)" if it cannot be determined.
    */
   val versionString         = "version " + scalaPropOrElse("version.number", "(unknown)")
-  val copyrightString       = scalaPropOrElse("copyright.string", "(c) 2002-2013 LAMP/EPFL")
+  val copyrightString       = scalaPropOrElse("copyright.string", "Copyright 2002-2013, LAMP/EPFL")
 
   /** This is the encoding to use reading in source files, overridden with -encoding
    *  Note that it uses "prop" i.e. looks in the scala jar, not the system properties.
diff --git a/src/partest/scala/tools/partest/PartestDefaults.scala b/src/partest/scala/tools/partest/PartestDefaults.scala
index e3f1cb8bd9..5d98a8be81 100644
--- a/src/partest/scala/tools/partest/PartestDefaults.scala
+++ b/src/partest/scala/tools/partest/PartestDefaults.scala
@@ -19,7 +19,7 @@ object PartestDefaults {
   def javaCmd     = propOrElse("partest.javacmd", "java")
   def javacCmd    = propOrElse("partest.javac_cmd", "javac")
   def javaOpts    = propOrElse("partest.java_opts", "")
-  def scalacOpts  = propOrElse("partest.scalac_opts", "-deprecation")
+  def scalacOpts  = propOrElse("partest.scalac_opts", "")
 
   def testBuild  = propOrNone("partest.build")
   def errorCount = propOrElse("partest.errors", "0").toInt
diff --git a/src/partest/scala/tools/partest/nest/CompileManager.scala b/src/partest/scala/tools/partest/nest/CompileManager.scala
index 9a48c5ce2b..0e62f9a022 100644
--- a/src/partest/scala/tools/partest/nest/CompileManager.scala
+++ b/src/partest/scala/tools/partest/nest/CompileManager.scala
@@ -41,7 +41,6 @@ class ExtConsoleReporter(settings: Settings, val writer: PrintWriter) extends Co
 class TestSettings(cp: String, error: String => Unit) extends Settings(error) {
   def this(cp: String) = this(cp, _ => ())
 
-  deprecation.value = true
   nowarnings.value  = false
   encoding.value    = "UTF-8"
   classpath.value   = cp
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index 9ccb962ec3..68f51e97bd 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -6522,7 +6522,10 @@ trait Types extends api.Types { self: SymbolTable =>
             else lubBase
           }
         }
-      existentialAbstraction(tparams, lubType)
+      // dropIllegalStarTypes is a localized fix for SI-6897. We should probably
+      // integrate that transformation at a lower level in master, but lubs are
+      // the likely and maybe only spot they escape, so fixing here for 2.10.1.
+      existentialAbstraction(tparams, dropIllegalStarTypes(lubType))
     }
     if (printLubs) {
       println(indent + "lub of " + ts + " at depth "+depth)//debug