Merge pull request #5170 from retronym/merge/2.11.x-to-2.12.x-20160517

Merge 2.11.x to 2.12.x [ci: last-only]

9 files changed, 115 insertions, 27 deletions

diff --git a/build.sbt b/build.sbt
index e9ea2c7153..bd76167278 100644
--- a/build.sbt
+++ b/build.sbt
@@ -4,7 +4,7 @@
  * What you see below is very much work-in-progress. The following features are implemented:
  *   - Compiling all classses for the compiler and library ("compile" in the respective subprojects)
  *   - Running JUnit tests ("test") and partest ("test/it:test")
- *   - Creating build/quick with all compiled classes and launcher scripts ("˜")
+ *   - Creating build/quick with all compiled classes and launcher scripts ("dist/mkQuick")
  *   - Creating build/pack with all JARs and launcher scripts ("dist/mkPack")
  *   - Building all scaladoc sets ("doc")
  *   - Publishing ("publishDists" and standard sbt tasks like "publish" and "publishLocal")
@@ -208,7 +208,9 @@ lazy val commonSettings = clearSourceAndResourceDirectories ++ publishSettings +
 
   // Don't log process output (e.g. of forked `compiler/runMain ...Main`), just pass it
   // directly to stdout
-  outputStrategy in run := Some(StdoutOutput)
+  outputStrategy in run := Some(StdoutOutput),
+  Quiet.silenceScalaBinaryVersionWarning,
+  Quiet.silenceIvyUpdateInfoLogging
 )
 
 /** Extra post-processing for the published POM files. These are needed to create POMs that
@@ -494,6 +496,7 @@ lazy val replJlineEmbedded = Project("repl-jline-embedded", file(".") / "target"
       JarJar(inputs, outdir, config)
     }),
     connectInput in run := true
+
   )
   .dependsOn(replJline)
 
@@ -686,7 +689,8 @@ lazy val root = (project in file("."))
       genprod.main(Array(dir.getPath))
       GenerateAnyVals.run(dir.getAbsoluteFile)
       state
-    }
+    },
+    Quiet.silenceIvyUpdateInfoLogging
   )
   .aggregate(library, reflect, compiler, interactive, repl, replJline, replJlineEmbedded,
     scaladoc, scalap, partestExtras, junit, libraryAll, scalaDist).settings(
diff --git a/project/Quiet.scala b/project/Quiet.scala
new file mode 100644
index 0000000000..de30ebe6ab
--- /dev/null
+++ b/project/Quiet.scala
@@ -0,0 +1,33 @@
+import sbt._
+import Keys._
+
+object Quiet {
+  // Workaround SBT issue described:
+  //
+  //   https://github.com/scala/scala-dev/issues/100
+  def silenceScalaBinaryVersionWarning = ivyConfiguration := {
+    ivyConfiguration.value match {
+      case c: InlineIvyConfiguration =>
+        val delegate = c.log
+        val logger = new Logger {
+          override def trace(t: => Throwable): Unit = delegate.trace(t)
+          override def log(level: sbt.Level.Value, message: => String): Unit = {
+            level match {
+              case sbt.Level.Warn =>
+                val message0 = message
+                val newLevel = if (message.contains("differs from Scala binary version in project"))
+                  delegate.log(sbt.Level.Debug, message)
+                else
+                  delegate.log(level, message)
+              case _ => delegate.log(level, message)
+            }
+          }
+          override def success(message: => String): Unit = delegate.success(message)
+        }
+        new InlineIvyConfiguration(c.paths, c.resolvers, c.otherResolvers, c.moduleConfigurations, c.localOnly, c.lock, c.checksums, c.resolutionCacheDir, c.updateOptions, logger)
+      case x => x
+    }
+  }
+
+  def silenceIvyUpdateInfoLogging = logLevel in update := Level.Warn
+}
diff --git a/project/plugins.sbt b/project/plugins.sbt
index 23e71c1f26..ac60cd3dd2 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -1,6 +1,6 @@
 libraryDependencies += "org.apache.commons" % "commons-lang3" % "3.3.2"
 
-libraryDependencies += "org.pantsbuild" % "jarjar" % "1.6.0"
+libraryDependencies += "org.pantsbuild" % "jarjar" % "1.6.3"
 
 libraryDependencies += "biz.aQute.bnd" % "biz.aQute.bnd" % "2.4.1"
 
diff --git a/src/repl/scala/tools/nsc/interpreter/Imports.scala b/src/repl/scala/tools/nsc/interpreter/Imports.scala
index fdbd93d862..0cda9c4da3 100644
--- a/src/repl/scala/tools/nsc/interpreter/Imports.scala
+++ b/src/repl/scala/tools/nsc/interpreter/Imports.scala
@@ -127,7 +127,11 @@ trait Imports {
           case rh :: rest if !keepHandler(rh.handler) => select(rest, wanted)
           case rh :: rest                             =>
             import rh.handler._
-            val newWanted = wanted ++ referencedNames -- definedNames -- importedNames
+            val augment = rh match {
+              case ReqAndHandler(_, _: ImportHandler) => referencedNames            // for "import a.b", add "a" to names to be resolved
+              case _ => Nil
+            }
+            val newWanted = wanted ++ augment -- definedNames -- importedNames
             rh :: select(rest, newWanted)
         }
       }
@@ -161,6 +165,8 @@ trait Imports {
       val tempValLines = mutable.Set[Int]()
       for (ReqAndHandler(req, handler) <- reqsToUse) {
         val objName = req.lineRep.readPathInstance
+        if (isReplTrace)
+          code.append(ss"// $objName definedNames ${handler.definedNames}, curImps $currentImps\n")
         handler match {
           case h: ImportHandler if checkHeader(h) =>
             header.clear()
@@ -175,21 +181,20 @@ trait Imports {
             currentImps ++= x.importedNames
 
           case x if isClassBased =>
-            for (imv <- x.definedNames) {
-              if (!currentImps.contains(imv)) {
-                x match {
-                  case _: ClassHandler =>
-                    code.append("import " + objName + req.accessPath + ".`" + imv + "`\n")
-                  case _ =>
-                    val valName = req.lineRep.packageName + req.lineRep.readName
-                    if (!tempValLines.contains(req.lineRep.lineId)) {
-                      code.append(s"val $valName: ${objName}.type = $objName\n")
-                      tempValLines += req.lineRep.lineId
-                    }
-                    code.append(s"import $valName${req.accessPath}.`$imv`;\n")
-                }
-                currentImps += imv
+            for (sym <- x.definedSymbols) {
+              maybeWrap(sym.name)
+              x match {
+                case _: ClassHandler =>
+                  code.append(s"import ${objName}${req.accessPath}.`${sym.name}`\n")
+                case _ =>
+                  val valName = s"${req.lineRep.packageName}${req.lineRep.readName}"
+                  if (!tempValLines.contains(req.lineRep.lineId)) {
+                    code.append(s"val $valName: ${objName}.type = $objName\n")
+                    tempValLines += req.lineRep.lineId
+                  }
+                  code.append(s"import ${valName}${req.accessPath}.`${sym.name}`\n")
               }
+              currentImps += sym.name
             }
           // For other requests, import each defined name.
           // import them explicitly instead of with _, so that
diff --git a/src/repl/scala/tools/nsc/interpreter/package.scala b/src/repl/scala/tools/nsc/interpreter/package.scala
index 7de1dda15f..97b32bfa86 100644
--- a/src/repl/scala/tools/nsc/interpreter/package.scala
+++ b/src/repl/scala/tools/nsc/interpreter/package.scala
@@ -202,13 +202,14 @@ package object interpreter extends ReplConfig with ReplStrings {
     }
   }
 
-  /* debug assist
+  /* An s-interpolator that uses `stringOf(arg)` instead of `String.valueOf(arg)`. */
   private[nsc] implicit class `smart stringifier`(val sc: StringContext) extends AnyVal {
     import StringContext._, runtime.ScalaRunTime.stringOf
     def ss(args: Any*): String = sc.standardInterpolator(treatEscapes, args map stringOf)
-  } debug assist */
+  }
+  /* Try (body) lastly (more) */
   private[nsc] implicit class `try lastly`[A](val t: Try[A]) extends AnyVal {
-    private def effect[X](last: =>Unit)(a: X): Try[A] = { last; t }
-    def lastly(last: =>Unit): Try[A] = t transform (effect(last) _, effect(last) _)
+    private def effect[X](last: => Unit)(a: X): Try[A] = { last; t }
+    def lastly(last: => Unit): Try[A] = t transform (effect(last) _, effect(last) _)
   }
 }
diff --git a/test/files/jvm/interpreter.check b/test/files/jvm/interpreter.check
index ce3c8062d7..9a2162a906 100644
--- a/test/files/jvm/interpreter.check
+++ b/test/files/jvm/interpreter.check
@@ -353,7 +353,7 @@ defined class Term
 scala> def f(e: Exp) = e match {  // non-exhaustive warning here
   case _:Fact => 3
 }
-<console>:22: warning: match may not be exhaustive.
+<console>:18: warning: match may not be exhaustive.
 It would fail on the following inputs: Exp(), Term()
        def f(e: Exp) = e match {  // non-exhaustive warning here
                        ^
diff --git a/test/files/run/repl-classbased.check b/test/files/run/repl-classbased.check
new file mode 100644
index 0000000000..e11fc170e5
--- /dev/null
+++ b/test/files/run/repl-classbased.check
@@ -0,0 +1,23 @@
+
+scala> case class K(s: String)
+defined class K
+
+scala> class C { implicit val k: K = K("OK?"); override def toString = s"C($k)" }
+defined class C
+
+scala> val c = new C
+c: C = C(K(OK?))
+
+scala> import c.k
+import c.k
+
+scala> implicitly[K]
+res0: K = K(OK?)
+
+scala> val k = 42
+k: Int = 42
+
+scala> k                 // was K(OK?)
+res1: Int = 42
+
+scala> :quit
diff --git a/test/files/run/repl-classbased.scala b/test/files/run/repl-classbased.scala
new file mode 100644
index 0000000000..595e123159
--- /dev/null
+++ b/test/files/run/repl-classbased.scala
@@ -0,0 +1,22 @@
+
+import scala.tools.partest.ReplTest
+import scala.tools.nsc.Settings
+
+//SI-9740
+object Test extends ReplTest {
+  override def transformSettings(s: Settings): Settings = {
+    s.Yreplclassbased.value = true
+    s
+  }
+
+  def code = 
+    """
+case class K(s: String)
+class C { implicit val k: K = K("OK?"); override def toString = s"C($k)" }
+val c = new C
+import c.k
+implicitly[K]
+val k = 42
+k                 // was K(OK?)
+    """
+}
diff --git a/test/files/run/t7319.check b/test/files/run/t7319.check
index 4d8429e8f2..31923e7119 100644
--- a/test/files/run/t7319.check
+++ b/test/files/run/t7319.check
@@ -15,21 +15,21 @@ warning: there was one feature warning; re-run with -feature for details
 convert: [F[X <: F[X]]](builder: F[_ <: F[_]])Int
 
 scala> convert(Some[Int](0))
-<console>:16: error: no type parameters for method convert: (builder: F[_ <: F[_]])Int exist so that it can be applied to arguments (Some[Int])
+<console>:15: error: no type parameters for method convert: (builder: F[_ <: F[_]])Int exist so that it can be applied to arguments (Some[Int])
  --- because ---
 argument expression's type is not compatible with formal parameter type;
  found   : Some[Int]
  required: ?F[_$1] forSome { type _$1 <: ?F[_$2] forSome { type _$2 } }
        convert(Some[Int](0))
        ^
-<console>:16: error: type mismatch;
+<console>:15: error: type mismatch;
  found   : Some[Int]
  required: F[_ <: F[_]]
        convert(Some[Int](0))
                         ^
 
 scala> Range(1,2).toArray: Seq[_]
-<console>:15: error: polymorphic expression cannot be instantiated to expected type;
+<console>:14: error: polymorphic expression cannot be instantiated to expected type;
  found   : [B >: Int]Array[B]
  required: Seq[_]
        Range(1,2).toArray: Seq[_]