Merge pull request #14 from scala/2.13.x

2.13.x

Author: wwjiang007

README.md

@@ -39,6 +39,7 @@ If you need some help with your PR at any time, please feel free to @-mention an
 
 P.S.: If you have some spare time to help out around here, we would be delighted to add your name to this list!
 
+
 # Repository structure
 
 ```
@@ -73,6 +74,13 @@ You need the following tools:
 Mac OS X and Linux work. Windows may work if you use Cygwin. Community help with keeping
 the build working on Windows is appreciated.
 
+## Tools we use
+
+We are grateful for the following OSS licenses:
+  - [JProfiler Java profiler](https://www.ej-technologies.com/products/jprofiler/overview.html)
+  - [YourKit Java Profiler](https://www.yourkit.com/java/profiler/)
+  - [IntelliJ IDEA](https://www.jetbrains.com/idea/download/)
+
 ## Build setup
 
 ### Basics

build.sbt

@@ -394,7 +394,8 @@ lazy val compiler = configureAsSubproject(project)
     description := "Scala Compiler",
     libraryDependencies ++= Seq(antDep, asmDep),
     // These are only needed for the POM:
-    libraryDependencies ++= Seq(scalaXmlDep, jlineDep % "optional"),
+    // TODO: jline dependency is only needed for the REPL shell, which should move to its own jar
+    libraryDependencies ++= Seq(scalaXmlDep, jlineDep),
     buildCharacterPropertiesFile := (resourceManaged in Compile).value / "scala-buildcharacter.properties",
     resourceGenerators in Compile += generateBuildCharacterPropertiesFile.map(file => Seq(file)).taskValue,
     // this a way to make sure that classes from interactive and scaladoc projects
@@ -406,8 +407,7 @@ lazy val compiler = configureAsSubproject(project)
         (products in Compile in packageBin in LocalProject("interactive")).value ++
         (products in Compile in packageBin in LocalProject("scaladoc")).value ++
         (products in Compile in packageBin in LocalProject("repl")).value ++
-        (products in Compile in packageBin in LocalProject("repl-jline")).value ++
-        (products in Compile in packageBin in LocalProject("repl-jline-embedded")).value,
+        (products in Compile in packageBin in LocalProject("repl-frontend")).value,
     includeFilter in unmanagedResources in Compile :=
       "*.tmpl" | "*.xml" | "*.js" | "*.css" | "*.html" | "*.properties" | "*.swf" |
       "*.png" | "*.gif" | "*.gif" | "*.txt",
@@ -466,58 +466,21 @@ lazy val interactive = configureAsSubproject(project)
 lazy val repl = configureAsSubproject(project)
   .settings(disableDocs)
   .settings(disablePublishing)
-  .settings(
-    connectInput in run := true,
-    run := (run in Compile).partialInput(" -usejavacp").evaluated // Automatically add this so that `repl/run` works without additional arguments.
-  )
   .dependsOn(compiler, interactive)
 
-lazy val replJline = configureAsSubproject(Project("repl-jline", file(".") / "src" / "repl-jline"))
+lazy val replFrontend = configureAsSubproject(Project("repl-frontend", file(".") / "src" / "repl-frontend"))
   .settings(disableDocs)
   .settings(disablePublishing)
   .settings(
     libraryDependencies += jlineDep,
-    name := "scala-repl-jline"
+    name := "scala-repl-frontend"
   )
-  .dependsOn(repl)
-
-lazy val replJlineEmbedded = Project("repl-jline-embedded", file(".") / "target" / "repl-jline-embedded-src-dummy")
-  .settings(scalaSubprojectSettings)
-  .settings(disablePublishing)
   .settings(
-    name := "scala-repl-jline-embedded",
-    // There is nothing to compile for this project. Instead we use the compile task to create
-    // shaded versions of repl-jline and jline.jar. dist/mkBin puts all of quick/repl,
-    // quick/repl-jline and quick/repl-jline-shaded on the classpath for quick/bin scripts.
-    // This is different from the Ant build where all parts are combined into quick/repl, but
-    // it is cleaner because it avoids circular dependencies.
-    compile in Compile := (compile in Compile).dependsOn(Def.task {
-      import java.util.jar._
-      import collection.JavaConverters._
-      val inputs: Iterator[JarJar.Entry] = {
-        val repljlineClasses = (products in Compile in replJline).value.flatMap(base => Path.allSubpaths(base).map(x => (base, x._1)))
-        val jlineJAR = findJar((dependencyClasspath in Compile).value, jlineDep).get.data
-        val jarFile = new JarFile(jlineJAR)
-        val jarEntries = jarFile.entries.asScala.filterNot(_.isDirectory).map(entry => JarJar.JarEntryInput(jarFile, entry))
-        def compiledClasses = repljlineClasses.iterator.map { case (base, file) => JarJar.FileInput(base, file) }
-        (jarEntries ++ compiledClasses).filter(x =>
-          x.name.endsWith(".class") || x.name.endsWith(".properties") || x.name.startsWith("META-INF/native") || x.name.startsWith("META-INF/maven")
-        )
-      }
-      import JarJar.JarJarConfig._
-      val config: Seq[JarJar.JarJarConfig] = Seq(
-        Rule("org.fusesource.**", "scala.tools.fusesource_embedded.@1"),
-        Rule("jline.**", "scala.tools.jline_embedded.@1"),
-        Rule("scala.tools.nsc.interpreter.jline.**", "scala.tools.nsc.interpreter.jline_embedded.@1"),
-        Keep("scala.tools.**")
-      )
-      val outdir = (classDirectory in Compile).value
-      JarJar(inputs, outdir, config)
-    }).value,
-    connectInput in run := true
-
+    connectInput in run := true,
+    run := (run in Compile).partialInput(" -usejavacp").evaluated // Automatically add this so that `repl/run` works without additional arguments.
   )
-  .dependsOn(replJline)
+  .dependsOn(repl)
+
 
 lazy val scaladoc = configureAsSubproject(project)
   .settings(disableDocs)
@@ -544,7 +507,7 @@ lazy val scalap = configureAsSubproject(project)
   .dependsOn(compiler)
 
 lazy val partestExtras = Project("partest-extras", file(".") / "src" / "partest-extras")
-  .dependsOn(replJlineEmbedded, scaladoc)
+  .dependsOn(replFrontend, scaladoc)
   .settings(commonSettings)
   .settings(generatePropertiesFileSettings)
   .settings(clearSourceAndResourceDirectories)
@@ -654,7 +617,7 @@ lazy val partestJavaAgent = Project("partest-javaagent", file(".") / "src" / "pa
   )
 
 lazy val test = project
-  .dependsOn(compiler, interactive, replJlineEmbedded, scalap, partestExtras, partestJavaAgent, scaladoc)
+  .dependsOn(compiler, interactive, replFrontend, scalap, partestExtras, partestJavaAgent, scaladoc)
   .configs(IntegrationTest)
   .settings(commonSettings)
   .settings(disableDocs)
@@ -867,15 +830,15 @@ lazy val root: Project = (project in file("."))
     antStyle := false,
     incOptions := incOptions.value.withNameHashing(!antStyle.value).withAntStyle(antStyle.value)
   )
-  .aggregate(library, reflect, compiler, interactive, repl, replJline, replJlineEmbedded,
+  .aggregate(library, reflect, compiler, interactive, repl, replFrontend,
     scaladoc, scalap, partestExtras, junit, scalaDist).settings(
     sources in Compile := Seq.empty,
     onLoadMessage := """|*** Welcome to the sbt build definition for Scala! ***
       |Check README.md for more information.""".stripMargin
   )
 
 // The following subprojects' binaries are required for building "pack":
-lazy val distDependencies = Seq(replJline, replJlineEmbedded, compiler, library, reflect, scalap, scaladoc)
+lazy val distDependencies = Seq(replFrontend, compiler, library, reflect, scalap, scaladoc)
 
 lazy val dist = (project in file("dist"))
   .settings(commonSettings)
@@ -978,7 +941,7 @@ lazy val mkBinImpl: Def.Initialize[Task[Seq[File]]] = Def.task {
 
   streams.value.log.info(s"Creating scripts in $quickOutDir and $packOutDir")
 
-  mkBin("scala"    , "scala.tools.nsc.MainGenericRunner", (fullClasspath in Compile in replJlineEmbedded).value) ++
+  mkBin("scala"    , "scala.tools.nsc.MainGenericRunner", (fullClasspath in Compile in replFrontend).value) ++
   mkBin("scalac"   , "scala.tools.nsc.Main",              (fullClasspath in Compile in compiler).value) ++
   mkBin("fsc"      , "scala.tools.nsc.CompileClient",     (fullClasspath in Compile in compiler).value) ++
   mkBin("scaladoc" , "scala.tools.nsc.ScalaDoc",          (fullClasspath in Compile in scaladoc).value) ++
@@ -1009,7 +972,7 @@ watchSources ++= PartestUtil.testFilePaths((baseDirectory in ThisBuild).value, (
 commands ++= {
   val commands =
   List(("scalac",   "compiler", "scala.tools.nsc.Main"),
-       ("scala",    "repl-jline-embedded", "scala.tools.nsc.MainGenericRunner"),
+       ("scala",    "repl-frontend", "scala.tools.nsc.MainGenericRunner"),
        ("scaladoc", "scaladoc", "scala.tools.nsc.ScalaDoc"))
 
   commands.map {
@@ -1051,8 +1014,7 @@ intellij := {
       moduleDeps(partestJavaAgent).value,
       moduleDeps(reflect).value,
       moduleDeps(repl).value,
-      moduleDeps(replJline).value,
-      // moduleDeps(replJlineEmbedded).value,   // No sources
+      moduleDeps(replFrontend).value,
       // moduleDeps(root).value,                // No sources
       // moduleDeps(scalaDist).value,           // No sources
       moduleDeps(scalacheck, config = Test).value,

project/ScalaOptionParser.scala

@@ -25,12 +25,12 @@ object ScalaOptionParser {
     def ChoiceSetting(name: String, choices: List[String]): Parser[String] =
       concat(token(concat(name ~ ":")) ~ token(StringBasic.examples(choices: _*)).map(_.mkString))
     def MultiChoiceSetting(name: String, choices: List[String]): Parser[String] =
-      concat(token(concat(name ~ ":")) ~ rep1sep(token(StringBasic.examples(choices: _*)), token(",")).map(_.mkString))
+      concat(token(concat(name ~ ":")) ~ rep1sep(token(StringBasic.examples(choices: _*)), token(",")).map(_.mkString(",")))
     def PathSetting(name: String): Parser[String] = {
-      concat(concat(token(name) ~ Space.string) ~ rep1sep(JarOrDirectoryParser.filter(!_.contains(":"), x => x), token(java.io.File.pathSeparator)).map(_.mkString))
+      concat(concat(token(name) ~ Space.string) ~ rep1sep(JarOrDirectoryParser.filter(!_.contains(":"), x => x), token(java.io.File.pathSeparator)).map(_.mkString(java.io.File.pathSeparator)))
     }
     def FileSetting(name: String): Parser[String] = {
-      concat(concat(token(name) ~ Space.string) ~ rep1sep(JarOrDirectoryParser.filter(!_.contains(":"), x => x), token(java.io.File.pathSeparator)).map(_.mkString))
+      concat(concat(token(name) ~ Space.string) ~ rep1sep(JarOrDirectoryParser.filter(!_.contains(":"), x => x), token(java.io.File.pathSeparator)).map(_.mkString(java.io.File.pathSeparator)))
     }
     val Phase = token(NotSpace.examples(phases: _*))
     def PhaseSettingParser(name: String): Parser[String] = {

project/VersionUtil.scala

@@ -12,6 +12,7 @@ import BuildSettings.autoImport._
 object VersionUtil {
   lazy val copyrightString = settingKey[String]("Copyright string.")
   lazy val versionProperties = settingKey[Versions]("Version properties.")
+  lazy val gitProperties = settingKey[GitProperties]("Current git information")
   lazy val buildCharacterPropertiesFile = settingKey[File]("The file which gets generated by generateBuildCharacterPropertiesFile")
   lazy val generateVersionPropertiesFile = taskKey[File]("Generate version properties file.")
   lazy val generateBuildCharacterPropertiesFile = taskKey[File]("Generate buildcharacter.properties file.")
@@ -20,6 +21,7 @@ object VersionUtil {
   lazy val globalVersionSettings = Seq[Setting[_]](
     // Set the version properties globally (they are the same for all projects)
     versionProperties in Global := versionPropertiesImpl.value,
+    gitProperties := gitPropertiesImpl.value,
     version in Global := versionProperties.value.mavenVersion
   )
 
@@ -50,6 +52,39 @@ object VersionUtil {
     )
   }
 
+  case class GitProperties(date: String, sha: String)
+
+  private lazy val gitPropertiesImpl: Def.Initialize[GitProperties] = Def.setting {
+    val log = sLog.value
+    val (dateObj, sha) = {
+      try {
+        // Use JGit to get the commit date and SHA
+        import org.eclipse.jgit.storage.file.FileRepositoryBuilder
+        import org.eclipse.jgit.revwalk.RevWalk
+        val db = new FileRepositoryBuilder().findGitDir.build
+        val head = db.resolve("HEAD")
+        if (head eq null) {
+          log.info("No git HEAD commit found -- Using current date and 'unknown' SHA")
+          (new Date, "unknown")
+        } else {
+          val commit = new RevWalk(db).parseCommit(head)
+          (new Date(commit.getCommitTime.toLong * 1000L), commit.getName.substring(0, 7))
+        }
+      } catch {
+        case ex: Exception =>
+          log.error("Could not determine commit date + SHA: " + ex)
+          log.trace(ex)
+          (new Date, "unknown")
+      }
+    }
+    val date = {
+      val df = new SimpleDateFormat("yyyyMMdd-HHmmss", Locale.ENGLISH)
+      df.setTimeZone(TimeZone.getTimeZone("UTC"))
+      df.format(dateObj)
+    }
+    GitProperties(date, sha)
+  }
+
   /** Compute the canonical, Maven and OSGi version number from `baseVersion` and `baseVersionSuffix`.
     * Examples of the generated versions:
     *
@@ -68,6 +103,7 @@ object VersionUtil {
     * value "SPLIT" is used to split the real suffix off from `baseVersion` instead and then apply the usual logic. */
   private lazy val versionPropertiesImpl: Def.Initialize[Versions] = Def.setting {
     val log = sLog.value
+    val (date, sha) = (gitProperties.value.date, gitProperties.value.sha)
 
     val (base, suffix) = {
       val (b, s) = (baseVersion.value, baseVersionSuffix.value)
@@ -78,31 +114,7 @@ object VersionUtil {
       } else (b, s)
     }
 
-    val (dateObj, sha) = {
-      try {
-        // Use JGit to get the commit date and SHA
-        import org.eclipse.jgit.storage.file.FileRepositoryBuilder
-        import org.eclipse.jgit.revwalk.RevWalk
-        val db = new FileRepositoryBuilder().findGitDir.build
-        val head = db.resolve("HEAD")
-        if(head eq null) {
-          log.info("No git HEAD commit found -- Using current date and 'unknown' SHA")
-          (new Date, "unknown")
-        } else {
-          val commit = new RevWalk(db).parseCommit(head)
-          (new Date(commit.getCommitTime.toLong * 1000L), commit.getName.substring(0, 7))
-        }
-      } catch { case ex: Exception =>
-        log.error("Could not determine commit date + SHA: "+ex)
-        log.trace(ex)
-        (new Date, "unknown")
-      }
-    }
-    val date = {
-      val df = new SimpleDateFormat("yyyyMMdd-HHmmss", Locale.ENGLISH)
-      df.setTimeZone(TimeZone.getTimeZone("UTC"))
-      df.format(dateObj)
-    }
+
 
     val Patch = """\d+\.\d+\.(\d+)""".r
     def cross = base match {
@@ -115,9 +127,10 @@ object VersionUtil {
       case "SHA-SNAPSHOT" => (s"$base-$date-$sha",   s"-$cross-$sha-SNAPSHOT", s"$base.v$date-$sha",         false)
       case "SHA"          => (s"$base-$sha",         s"-$cross-$sha",          s"$base.v$date-$sha",         false)
       case ""             => (s"$base",              "",                       s"$base.v$date-VFINAL-$sha",  true)
-      case suffix         => (s"$base-$suffix",      s"-$suffix",              s"$base.v$date-$suffix-$sha", true)
+      case _              => (s"$base-$suffix",      s"-$suffix",              s"$base.v$date-$suffix-$sha", true)
     }
 
+
     Versions(canonicalV, base, mavenSuffix, osgiV, sha, date, release)
   }
 

spec/01-lexical-syntax.md

@@ -553,6 +553,20 @@ but are required to be properly nested.  Therefore, a comment like
 `/* /* */` will be rejected as having an unterminated
 comment.
 
+## Trailing Commas in Multi-line Expressions
+
+If a comma (`,`) is followed immediately, ignoring whitespace, by a newline and
+a closing parenthesis (`)`), bracket (`]`), or brace (`}`), then the comma is
+treated as a "trailing comma" and is ignored. For example:
+
+```scala
+foo(
+  23,
+  "bar",
+  true,
+)
+```
+
 ## XML mode
 
 In order to allow literal inclusion of XML fragments, lexical analysis

spec/02-identifiers-names-and-scopes.md

@@ -105,24 +105,24 @@ precedences between them.
 package p {                   // `X' bound by package clause
 import Console._              // `println' bound by wildcard import
 object Y {
-  println(s"L4: $X")          // `X' refers to `p.X' here
+  println(s"L4: \$X")          // `X' refers to `p.X' here
   locally {
     import q._                // `X' bound by wildcard import
-    println(s"L7: $X")        // `X' refers to `q.X' here
+    println(s"L7: \$X")        // `X' refers to `q.X' here
     import X._                // `x' and `y' bound by wildcard import
-    println(s"L9: $x")        // `x' refers to `q.X.x' here
+    println(s"L9: \$x")        // `x' refers to `q.X.x' here
     locally {
       val x = 3               // `x' bound by local definition
-      println(s"L12: $x")     // `x' refers to constant `3' here
+      println(s"L12: \$x")     // `x' refers to constant `3' here
       locally {
         import q.X._          // `x' and `y' bound by wildcard import
-//      println(s"L15: $x")   // reference to `x' is ambiguous here
+//      println(s"L15: \$x")   // reference to `x' is ambiguous here
         import X.y            // `y' bound by explicit import
-        println(s"L17: $y")   // `y' refers to `q.X.y' here
+        println(s"L17: \$y")   // `y' refers to `q.X.y' here
         locally {
           val x = "abc"       // `x' bound by local definition
           import p.X._        // `x' and `y' bound by wildcard import
-//        println(s"L21: $y") // reference to `y' is ambiguous here
-          println(s"L22: $x") // `x' refers to string "abc" here
+//        println(s"L21: \$y") // reference to `y' is ambiguous here
+          println(s"L22: \$x") // `x' refers to string "abc" here
 }}}}}}
 ```

src/compiler/scala/reflect/reify/phases/Metalevels.scala

@@ -1,7 +1,7 @@
 package scala.reflect.reify
 package phases
 
-import scala.collection.{ mutable }
+import scala.collection.mutable
 
 trait Metalevels {
   self: Reifier =>

src/compiler/scala/tools/cmd/CommandLine.scala

@@ -27,7 +27,7 @@ class CommandLine(val spec: Reference, val originalArgs: List[String]) extends C
   def mapForUnary(opt: String) = Map(fromOpt(opt) -> ValueForUnaryOption)
   def errorFn(msg: String) = println(msg)
 
-  /** argMap is option -> argument (or "" if it is a unary argument)
+  /** argMap is option -> argument (or "true" if it is a unary argument)
    *  residualArgs are what is left after removing the options and their args.
    */
   lazy val (argMap, residualArgs): (Map[String, String], List[String]) = {

src/compiler/scala/tools/nsc/Global.scala

@@ -580,7 +580,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
     val runsRightAfter = None
   } with Delambdafy
 
-  // phaseName = "bcode"
+  // phaseName = "jvm"
   object genBCode extends {
     val global: Global.this.type = Global.this
     val runsAfter = List("cleanup")
@@ -1404,11 +1404,11 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
 
       units match {
         case Nil => checkDeprecations()   // nothing to compile, report deprecated options
-        case _   => compileUnits(units, firstPhase)
+        case _   => compileUnits(units)
       }
     }
 
-    def compileUnits(units: List[CompilationUnit], fromPhase: Phase): Unit =
+    def compileUnits(units: List[CompilationUnit], fromPhase: Phase = firstPhase): Unit =
       compileUnitsInternal(units, fromPhase)
 
     private def compileUnitsInternal(units: List[CompilationUnit], fromPhase: Phase) {