Merge pull request #2914 from gkossakowski/merge-2.10.x

Merge 2.10.x into master

16 files changed, 396 insertions, 5 deletions

diff --git a/build.xml b/build.xml
index 4a2456eebf..13533303f9 100755
--- a/build.xml
+++ b/build.xml
@@ -1326,9 +1326,11 @@ TODO:
           <attribute name="Class-Path" value="scala-reflect.jar scala-library.jar"/>
         </manifest>
       </pre>
+      <!-- script api is 2.11-only so far
       <jar-opts>
         <service type="javax.script.ScriptEngineFactory" provider="scala.tools.nsc.interpreter.IMain$Factory"/>
       </jar-opts>
+      -->
     </staged-pack>
   </target>
 
diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
index e5101a27a8..6a09f9f07c 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
@@ -3067,7 +3067,7 @@ self =>
       while (!isStatSeqEnd && !isCaseDefStart) {
         if (in.token == IMPORT) {
           stats ++= importClause()
-          acceptStatSep()
+          acceptStatSepOpt()
         }
         else if (isExprIntro) {
           stats += statement(InBlock)
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index dd16b5be85..d29d9dbe18 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -3789,7 +3789,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           // we need symbol-ful originals for reification
           // hence we go the extra mile to hand-craft tis guy
           val original = arg1 match {
-            case tt @ TypeTree() => Annotated(ann, tt.original)
+            case tt @ TypeTree() if tt.original != null => Annotated(ann, tt.original)
             // this clause is needed to correctly compile stuff like "new C @D" or "@(inline @getter)"
             case _ => Annotated(ann, arg1)
           }
diff --git a/src/compiler/scala/tools/reflect/WrappedProperties.scala b/src/compiler/scala/tools/reflect/WrappedProperties.scala
index 20567719be..523287fc66 100644
--- a/src/compiler/scala/tools/reflect/WrappedProperties.scala
+++ b/src/compiler/scala/tools/reflect/WrappedProperties.scala
@@ -27,9 +27,13 @@ trait WrappedProperties extends PropertiesTrait {
   override def envOrNone(name: String)               = wrap(super.envOrNone(name)).flatten
   override def envOrSome(name: String, alt: Option[String]) = wrap(super.envOrNone(name)).flatten orElse alt
 
-  def systemProperties: Iterator[(String, String)] = {
+  def systemProperties: List[(String, String)] = {
     import scala.collection.JavaConverters._
-    wrap(System.getProperties.asScala.iterator) getOrElse Iterator.empty
+    wrap {
+      val props = System.getProperties
+      // SI-7269 Be careful to avoid `ConcurrentModificationException` if another thread modifies the properties map
+      props.stringPropertyNames().asScala.toList.map(k => (k, props.get(k).asInstanceOf[String]))
+    } getOrElse Nil
   }
 }
 
diff --git a/src/reflect/scala/reflect/internal/ExistentialsAndSkolems.scala b/src/reflect/scala/reflect/internal/ExistentialsAndSkolems.scala
index 073f124630..0eeca4aace 100644
--- a/src/reflect/scala/reflect/internal/ExistentialsAndSkolems.scala
+++ b/src/reflect/scala/reflect/internal/ExistentialsAndSkolems.scala
@@ -19,6 +19,9 @@ trait ExistentialsAndSkolems {
    *  can be deskolemized to the original type parameter. (A skolem is a
    *  representation of a bound variable when viewed inside its scope.)
    *  !!!Adriaan: this does not work for hk types.
+   *
+   *  Skolems will be created at level 0, rather than the current value
+   *  of `skolemizationLevel`. (See SI-7782)
    */
   def deriveFreshSkolems(tparams: List[Symbol]): List[Symbol] = {
     class Deskolemizer extends LazyType {
@@ -30,7 +33,11 @@ trait ExistentialsAndSkolems {
         sym setInfo sym.deSkolemize.info.substSym(typeParams, typeSkolems)
       }
     }
-    (new Deskolemizer).typeSkolems
+
+    val saved = skolemizationLevel
+    skolemizationLevel = 0
+    try new Deskolemizer().typeSkolems
+    finally skolemizationLevel = saved
   }
 
   def isRawParameter(sym: Symbol) = // is it a type parameter leaked by a raw type?
diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala
index 7a2287664a..13fc7ce0dc 100644
--- a/src/reflect/scala/reflect/internal/StdNames.scala
+++ b/src/reflect/scala/reflect/internal/StdNames.scala
@@ -40,6 +40,7 @@ trait StdNames {
     def result: Set[TermName] = try kws finally kws = null
   }
 
+  private[reflect] def compactifyName(orig: String): String = compactify(orig)
   private final object compactify extends (String => String) {
     val md5 = MessageDigest.getInstance("MD5")
 
diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
index dd77b084c5..c9a9b74c54 100644
--- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala
+++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
@@ -1180,6 +1180,17 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
         var fullNameOfJavaClass = ownerClazz.getName
         if (childOfClass || childOfTopLevel) fullNameOfJavaClass += "$"
         fullNameOfJavaClass += clazz.name
+
+        // compactify (see SI-7779)
+        fullNameOfJavaClass = fullNameOfJavaClass match {
+          case PackageAndClassPattern(pack, clazzName) =>
+            // in a package
+            pack + compactifyName(clazzName)
+          case _ =>
+            // in the empty package
+            compactifyName(fullNameOfJavaClass)
+        }
+
         if (clazz.isModuleClass) fullNameOfJavaClass += "$"
 
         // println(s"ownerChildren = ${ownerChildren.toList}")
@@ -1189,6 +1200,8 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
         noClass
     }
 
+    private val PackageAndClassPattern = """(.*\.)(.*)$""".r
+
     private def expandedName(sym: Symbol): String =
       if (sym.isPrivate) nme.expandedName(sym.name.toTermName, sym.owner).toString
       else sym.name.toString
@@ -1243,6 +1256,7 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
       case TypeRef(_, ArrayClass, List(elemtpe))     => jArrayClass(typeToJavaClass(elemtpe))
       case TypeRef(_, sym: ClassSymbol, _)           => classToJava(sym.asClass)
       case tpe @ TypeRef(_, sym: AliasTypeSymbol, _) => typeToJavaClass(tpe.dealias)
+      case SingleType(_, sym: ModuleSymbol)          => classToJava(sym.moduleClass.asClass)
       case _                                         => throw new NoClassDefFoundError("no Java class corresponding to "+tpe+" found")
     }
   }
diff --git a/test/files/pos/t4760.scala b/test/files/pos/t4760.scala
new file mode 100644
index 0000000000..767e3847f4
--- /dev/null
+++ b/test/files/pos/t4760.scala
@@ -0,0 +1,34 @@
+
+class Test {
+  // parses
+  def f1 = {
+    import scala._;
+  }
+  // b.scala:7: error: ';' expected but '}' found.
+  //   }
+  //   ^
+  // one error found
+  def f2 = {
+    import scala._
+  }
+  def f2b = {
+    import scala.collection.mutable.{ Map => MMap }
+  }
+  def f(): Unit = {
+    locally {
+      import scala.util.Properties.lineSeparator
+    }
+  }
+  
+  // parses
+  def f3 = {
+    import scala._
+    5
+  }
+  locally { (x: Int) =>
+    import scala.util._
+  }
+  1 match {
+    case 1 => import scala.concurrent._
+  }
+}
diff --git a/test/files/pos/t7782.scala b/test/files/pos/t7782.scala
new file mode 100644
index 0000000000..037bdad673
--- /dev/null
+++ b/test/files/pos/t7782.scala
@@ -0,0 +1,25 @@
+package pack
+
+object Test {
+  import O.empty
+  empty // this will trigger completion of `test`
+        // with skolemizationLevel = 1
+}
+
+object O {
+  // order matters (!!!)
+
+  // this order breaks under 2.10.x
+  def empty[E]: C[E] = ???
+  def empty(implicit a: Any): Any = ???
+}
+
+abstract class C[E] {
+  def foo[BB](f: BB)
+  def test[B](f: B): Any = foo(f)
+  // error: no type parameters for method foo: (<param> f: BB)scala.this.Unit exist so that it can be applied to arguments (B&1)
+  // --- because ---
+  // argument expression's type is not compatible with formal parameter type;
+  // found   : B&1
+  // required: ?BB
+}
diff --git a/test/files/pos/t7782b.scala b/test/files/pos/t7782b.scala
new file mode 100644
index 0000000000..09da4a5c5b
--- /dev/null
+++ b/test/files/pos/t7782b.scala
@@ -0,0 +1,25 @@
+package pack
+
+object Test {
+  import O.empty
+  empty // this will trigger completion of `test`
+        // with skolemizationLevel = 1
+}
+
+object O {
+  // order matters (!!!)
+
+  // this order breaks under 2.11.x
+  def empty(implicit a: Any): Any = ???
+  def empty[E]: C[E] = ???
+}
+
+abstract class C[E] {
+  def foo[BB](f: BB)
+  def test[B](f: B): Any = foo(f)
+  // error: no type parameters for method foo: (<param> f: BB)scala.this.Unit exist so that it can be applied to arguments (B&1)
+  // --- because ---
+  // argument expression's type is not compatible with formal parameter type;
+  // found   : B&1
+  // required: ?BB
+}
diff --git a/test/files/run/WeakHashSetTest.scala b/test/files/run/WeakHashSetTest.scala
new file mode 100644
index 0000000000..3c8f380150
--- /dev/null
+++ b/test/files/run/WeakHashSetTest.scala
@@ -0,0 +1,174 @@
+object Test {
+  def main(args: Array[String]) {
+    val test = scala.reflect.internal.util.WeakHashSetTest
+    test.checkEmpty
+    test.checkPlusEquals
+    test.checkPlusEqualsCollisions
+    test.checkRehashing
+    test.checkRehashCollisions
+    test.checkFindOrUpdate
+    test.checkMinusEquals
+    test.checkMinusEqualsCollisions
+    test.checkClear
+    test.checkIterator
+    test.checkIteratorCollisions
+
+    // This test is commented out because it relies on gc behavior which isn't reliable enough in an automated environment
+    // test.checkRemoveUnreferencedObjects
+  }
+}
+
+// put the main test object in the same package as WeakHashSet because
+// it uses the package private "diagnostics" method
+package scala.reflect.internal.util {
+
+  object WeakHashSetTest {
+    // a class guaranteed to provide hash collisions
+    case class Collider(x : String) extends Comparable[Collider] with Serializable {
+      override def hashCode = 0
+      def compareTo(y : Collider) = this.x compareTo y.x
+    }
+
+    // basic emptiness check
+    def checkEmpty {
+      val hs = new WeakHashSet[String]()
+      assert(hs.size == 0)
+      hs.diagnostics.fullyValidate    
+    }
+
+    // make sure += works
+    def checkPlusEquals {
+      val hs = new WeakHashSet[String]()
+      val elements = List("hello", "goodbye")
+      elements foreach (hs += _)
+      assert(hs.size == 2)
+      assert(hs contains "hello")
+      assert(hs contains "goodbye")
+      hs.diagnostics.fullyValidate
+    }
+
+    // make sure += works when there are collisions
+    def checkPlusEqualsCollisions {
+      val hs = new WeakHashSet[Collider]()
+      val elements = List("hello", "goodbye") map Collider
+      elements foreach (hs += _)
+      assert(hs.size == 2)
+      assert(hs contains Collider("hello"))
+      assert(hs contains Collider("goodbye"))
+      hs.diagnostics.fullyValidate
+    }
+
+    // add a large number of elements to force rehashing and then validate
+    def checkRehashing {
+      val size = 200
+      val hs = new WeakHashSet[String]()
+      val elements = (0 until size).toList map ("a" + _)
+      elements foreach (hs += _)
+      elements foreach {i => assert(hs contains i)}
+      hs.diagnostics.fullyValidate
+    }
+
+    // make sure rehashing works properly when the set is rehashed
+    def checkRehashCollisions {
+      val size = 200
+      val hs = new WeakHashSet[Collider]()
+      val elements = (0 until size).toList map {x => Collider("a" + x)}
+      elements foreach (hs += _)
+      elements foreach {i => assert(hs contains i)}
+      hs.diagnostics.fullyValidate
+    }
+
+    // test that unreferenced objects are removed
+    // not run in an automated environment because gc behavior can't be relied on
+    def checkRemoveUnreferencedObjects {
+      val size = 200
+      val hs = new WeakHashSet[Collider]()
+      val elements = (0 until size).toList map {x => Collider("a" + x)}
+      elements foreach (hs += _)
+      // don't throw the following into a retained collection so gc 
+      // can remove them
+      for (i <- 0 until size) {
+        hs += Collider("b" + i)
+      }
+      System.gc()
+      Thread.sleep(1000)
+      assert(hs.size == 200)
+      elements foreach {i => assert(hs contains i)}
+      for (i <- 0 until size) {
+        assert(!(hs contains Collider("b" + i)))
+      }
+      hs.diagnostics.fullyValidate
+    }
+
+    // make sure findOrUpdate returns the originally entered element
+    def checkFindOrUpdate {
+      val size = 200
+      val hs = new WeakHashSet[Collider]()
+      val elements = (0 until size).toList map {x => Collider("a" + x)}
+      elements foreach {x => assert(hs findEntryOrUpdate x eq x)}
+      for (i <- 0 until size) {
+        // when we do a lookup the result should be the same reference we
+        // original put in
+        assert(hs findEntryOrUpdate(Collider("a" + i)) eq elements(i))
+      }
+      hs.diagnostics.fullyValidate
+    }
+
+    // check -= functionality
+    def checkMinusEquals {
+      val hs = new WeakHashSet[String]()
+      val elements = List("hello", "goodbye")
+      elements foreach (hs += _)
+      hs -= "goodbye"
+      assert(hs.size == 1)
+      assert(hs contains "hello")
+      assert(!(hs contains "goodbye"))
+      hs.diagnostics.fullyValidate
+    }
+
+    // check -= when there are collisions
+    def checkMinusEqualsCollisions {
+      val hs = new WeakHashSet[Collider]
+      val elements = List(Collider("hello"), Collider("goodbye"))
+      elements foreach (hs += _)
+      hs -= Collider("goodbye")
+      assert(hs.size == 1)
+      assert(hs contains Collider("hello"))
+      assert(!(hs contains Collider("goodbye")))
+      hs -= Collider("hello")
+      assert(hs.size == 0)
+      assert(!(hs contains Collider("hello")))
+      hs.diagnostics.fullyValidate
+    }
+
+    // check that the clear method actually cleans everything
+    def checkClear {
+      val size = 200
+      val hs = new WeakHashSet[String]()
+      val elements = (0 until size).toList map ("a" + _)
+      elements foreach (hs += _)
+      hs.clear()
+      assert(hs.size == 0)
+      elements foreach {i => assert(!(hs contains i))}
+      hs.diagnostics.fullyValidate    
+    }
+    
+    // check that the iterator covers all the contents
+    def checkIterator {
+      val hs = new WeakHashSet[String]()
+      val elements = (0 until 20).toList map ("a" + _)
+      elements foreach (hs += _)
+      assert(elements.iterator.toList.sorted == elements.sorted)
+      hs.diagnostics.fullyValidate
+    }
+    
+    // check that the iterator covers all the contents even when there is a collision
+    def checkIteratorCollisions {
+      val hs = new WeakHashSet[Collider]
+      val elements = (0 until 20).toList map {x => Collider("a" + x)}
+      elements foreach (hs += _)
+      assert(elements.iterator.toList.sorted == elements.sorted) 
+      hs.diagnostics.fullyValidate
+    }
+  }
+}  
diff --git a/test/files/run/t7775.scala b/test/files/run/t7775.scala
new file mode 100644
index 0000000000..5fb0327611
--- /dev/null
+++ b/test/files/run/t7775.scala
@@ -0,0 +1,17 @@
+import scala.concurrent.{duration, future, Await, ExecutionContext}
+import scala.tools.nsc.Settings
+import ExecutionContext.Implicits.global
+
+// Was failing pretty regularly with a ConcurrentModificationException as
+// WrappedProperties#systemProperties iterated directly over the mutable
+// global system properties map.
+object Test {
+  def main(args: Array[String]) {
+    val tries = 1000 // YMMV
+    val compiler = future {
+      for(_ <- 1 to tries) new Settings(_ => {})
+    }
+    for(i <- 1 to tries * 10) System.setProperty(s"foo$i", i.toString)
+    Await.result(compiler, duration.Duration.Inf)
+  }
+}
diff --git a/test/files/run/t7779.scala b/test/files/run/t7779.scala
new file mode 100644
index 0000000000..db32cb751f
--- /dev/null
+++ b/test/files/run/t7779.scala
@@ -0,0 +1,67 @@
+// -Xmax-classfile-length doesn't compress top-level classes.
+// class :::::::::::::::::::::::::::::::::::::::::::::::::
+
+trait Marker
+
+class Short extends Marker
+
+// We just test with member classes
+object O {
+  object ::::::::::::::::::::::::::::::::::::::::::::::::: extends Marker
+}
+class C {
+  class D {
+    class ::::::::::::::::::::::::::::::::::::::::::::::::: extends Marker
+  }
+}
+
+package pack {
+  // abbreviates to: $colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon to $read$$iw$$iw$$colon$colon$colon$colon$colon$colon$colon$colon$$$$c39b3f245029fbed9732fc888d44231b$$$$on$colon$colon$colon$colon$colon$colon$colon$colon$colon$colon
+  // class :::::::::::::::::::::::::::::::::::::::::::::::::
+
+  class Short extends Marker
+
+  // We just test with member classes
+  object O {
+    object ::::::::::::::::::::::::::::::::::::::::::::::::: extends Marker
+  }
+  class C {
+    class D {
+      class ::::::::::::::::::::::::::::::::::::::::::::::::: extends Marker
+    }
+  }
+  package p2 {
+    class Short extends Marker
+
+    object O {
+      object ::::::::::::::::::::::::::::::::::::::::::::::::: extends Marker
+    }
+    class C {
+      class D {
+        class ::::::::::::::::::::::::::::::::::::::::::::::::: extends Marker
+      }
+    }
+  }
+}
+
+
+object Test extends App {
+  import reflect.runtime.universe._
+  def test[T: TypeTag] = {
+    val tt = typeTag[T]
+    val clz = tt.mirror.runtimeClass(tt.tpe)
+    assert(classOf[Marker].isAssignableFrom(clz), clz.toString)
+  }
+
+  test[Short]
+  test[O.:::::::::::::::::::::::::::::::::::::::::::::::::.type]
+  test[C#D#`:::::::::::::::::::::::::::::::::::::::::::::::::`]
+
+  test[pack.Short]
+  test[pack.O.:::::::::::::::::::::::::::::::::::::::::::::::::.type]
+  test[pack.C#D#`:::::::::::::::::::::::::::::::::::::::::::::::::`]
+
+  test[pack.p2.Short]
+  test[pack.p2.O.:::::::::::::::::::::::::::::::::::::::::::::::::.type]
+  test[pack.p2.C#D#`:::::::::::::::::::::::::::::::::::::::::::::::::`]
+}
diff --git a/test/files/run/typed-annotated.check b/test/files/run/typed-annotated.check
new file mode 100644
index 0000000000..d81cc0710e
--- /dev/null
+++ b/test/files/run/typed-annotated.check
@@ -0,0 +1 @@
+42
diff --git a/test/files/run/typed-annotated/Macros_1.scala b/test/files/run/typed-annotated/Macros_1.scala
new file mode 100644
index 0000000000..dd18c63d90
--- /dev/null
+++ b/test/files/run/typed-annotated/Macros_1.scala
@@ -0,0 +1,17 @@
+import scala.reflect.macros.Context
+import language.experimental.macros
+
+class ann extends scala.annotation.StaticAnnotation
+
+object Macros {
+  def impl(c: Context) = {
+    import c.universe._
+    // val tpt = Annotated(Apply(Select(New(Ident(newTypeName("ann"))), nme.CONSTRUCTOR), List()), Ident(newTypeName("Int")))
+    val tpt = Annotated(Apply(Select(New(Ident(newTypeName("ann"))), nme.CONSTRUCTOR), List()), TypeTree(weakTypeOf[Int]))
+    c.Expr[Unit](Block(
+      List(ValDef(Modifiers(), newTermName("x"), tpt, Literal(Constant(42)))),
+      Apply(Ident(newTermName("println")), List(Ident(newTermName("x"))))))
+  }
+
+  def foo = macro impl
+}
\ No newline at end of file
diff --git a/test/files/run/typed-annotated/Test_2.scala b/test/files/run/typed-annotated/Test_2.scala
new file mode 100644
index 0000000000..acfddae942
--- /dev/null
+++ b/test/files/run/typed-annotated/Test_2.scala
@@ -0,0 +1,3 @@
+object Test extends App {
+  Macros.foo
+}
\ No newline at end of file