Merge branch '2.13.x' into inPartest

Author: adriaanm

CODE_OF_CONDUCT.md

@@ -0,0 +1 @@
+all repositories in the [scala](https://github.com/scala) and [scalacenter](https://github.com/scalacenter) organizations are covered by the Scala Code of Conduct: https://scala-lang.org/conduct/

build.sbt

@@ -32,13 +32,12 @@
  *   - to modularize the Scala compiler or library further
  */
 
-import java.io.{PrintWriter, StringWriter}
-
 import sbt.TestResult
 import sbt.testing.TestSelector
 
 import scala.build._
 import VersionUtil._
+import scala.tools.nsc.util.ScalaClassLoader.URLClassLoader
 
 // Non-Scala dependencies:
 val junitDep          = "junit"                          % "junit"                            % "4.11"
@@ -117,6 +116,34 @@ lazy val instanceSettings = Seq[Setting[_]](
   Quiet.silenceScalaBinaryVersionWarning
 )
 
+// be careful with using this instance, as it may cause performance problems (e.g., MetaSpace exhaustion)r
+lazy val quickInstanceSettings = Seq[Setting[_]](
+  organization := "org.scala-lang",
+  // we don't cross build Scala itself
+  crossPaths := false,
+  // do not add Scala library jar as a dependency automatically
+  autoScalaLibrary := false,
+  // Avoid circular dependencies for scalaInstance (see https://github.com/sbt/sbt/issues/1872)
+  managedScalaInstance := false,
+  scalaInstance := {
+    // TODO: express in terms of distDependencies?
+    val cpElems: Seq[java.io.File] = (fullClasspath in Compile in replFrontend).value.map(_.data) ++ (fullClasspath in Compile in scaladoc).value.map(_.data)
+    val libraryJar = cpElems.find(_.getPath.endsWith("classes/library")).get
+    val compilerJar = cpElems.find(_.getPath.endsWith("classes/compiler")).get
+    val extraJars = cpElems.filter(f => (f ne libraryJar) && (f ne compilerJar))
+    val v = (version in Global).value
+    new ScalaInstance(v, new URLClassLoader(cpElems.map(_.toURI.toURL).toArray[URL], null), libraryJar, compilerJar, extraJars, Some(v))
+  },
+  // As of sbt 0.13.12 (sbt/sbt#2634) sbt endeavours to align both scalaOrganization and scalaVersion
+  // in the Scala artefacts, for example scala-library and scala-compiler.
+  // This doesn't work in the scala/scala build because the version of scala-library and the scalaVersion of
+  // scala-library are correct to be different. So disable overriding.
+  ivyScala ~= (_ map (_ copy (overrideScalaVersion = false))),
+  Quiet.silenceScalaBinaryVersionWarning
+)
+
+
+
 lazy val commonSettings = instanceSettings ++ clearSourceAndResourceDirectories ++ publishSettings ++ Seq[Setting[_]](
   // we always assume that Java classes are standalone and do not have any dependency
   // on Scala classes
@@ -561,6 +588,27 @@ lazy val junit = project.in(file("test") / "junit")
     unmanagedSourceDirectories in Test := List(baseDirectory.value)
   )
 
+// imported from scalamacros/paradise for the test suite -- TODO: integrate into build structure, get rid of quickInstanceSettings?
+lazy val macroAnnot = project.in(file("test") / "macro-annot")
+  .dependsOn(library, reflect, compiler, repl, replFrontend, scaladoc)
+  .settings(disableDocs)
+  .settings(disablePublishing)
+  .settings(quickInstanceSettings) // use quick compiler as Scala Instance
+  .settings(
+    fork in Test := true,
+    javaOptions in Test += "-Xss1M",
+    libraryDependencies ++= Seq(junitDep, junitInterfaceDep),
+    testOptions += Tests.Argument(TestFrameworks.JUnit, "-q", "-v",
+                                  s"-Dsbt.paths.tests.classpath=${(fullClasspath in Test).value.files.map(_.getAbsolutePath).mkString(java.io.File.pathSeparatorChar.toString)}"),
+
+    baseDirectory in Compile := (baseDirectory in ThisBuild).value,
+    baseDirectory in Test := (baseDirectory in ThisBuild).value,
+
+    scalacOptions += "-Ymacro-annotations",
+    scalacOptions += "-Ywarn-unused-import",
+    scalacOptions += "-Xfatal-warnings"
+  )
+
 lazy val scalacheck = project.in(file("test") / "scalacheck")
   .dependsOn(library, reflect, compiler, scaladoc)
   .settings(clearSourceAndResourceDirectories)
@@ -805,6 +853,7 @@ lazy val root: Project = (project in file("."))
       val results = ScriptCommands.sequence[(Result[Unit], String)](List(
         (Keys.test in Test in junit).result map (_ -> "junit/test"),
         (Keys.test in Test in scalacheck).result map (_ -> "scalacheck/test"),
+        (Keys.test in Test in macroAnnot).result map (_ -> "macroAnnot/test"),
         (testOnly in IntegrationTest in testP).toTask(" -- run").result map (_ -> "partest run"),
         (testOnly in IntegrationTest in testP).toTask(" -- pos neg jvm").result map (_ -> "partest pos neg jvm"),
         (testOnly in IntegrationTest in testP).toTask(" -- res scalap specialized").result map (_ -> "partest res scalap specialized"),
@@ -872,7 +921,7 @@ lazy val root: Project = (project in file("."))
     }
   )
   .aggregate(library, reflect, compiler, interactive, repl, replFrontend,
-    scaladoc, scalap, partest, junit, scalaDist).settings(
+    scaladoc, scalap, partest, junit, scalaDist, macroAnnot).settings(
     sources in Compile := Seq.empty,
     onLoadMessage := """|*** Welcome to the sbt build definition for Scala! ***
       |Check README.md for more information.""".stripMargin

doc/LICENSE.md

@@ -56,5 +56,4 @@ This license is used by the following third-party libraries:
 This license is used by the following third-party libraries:
 
   * jquery
-  * sizzle
   * tools tooltip

doc/License.rtf

@@ -53,5 +53,4 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \'93AS IS\'9
 
 \fs26 This license is used by the following third-party libraries:\
 	\'95	jquery\
-	\'95	sizzle\
 	\'95	tools tooltip\

doc/licenses/mit_sizzle.txt

@@ -87,7 +87,7 @@ object ScalaOptionParser {
     "-Ybreak-cycles", "-Ydebug", "-Ycompact-trees", "-YdisableFlatCpCaching", "-Ydoc-debug",
     "-Yide-debug", "-Yinfer-argument-types",
     "-Yissue-debug", "-Ylog-classpath", "-Ymacro-debug-lite", "-Ymacro-debug-verbose", "-Ymacro-no-expand",
-    "-Yno-completion", "-Yno-generic-signatures", "-Yno-imports", "-Yno-predef",
+    "-Yno-completion", "-Yno-generic-signatures", "-Yno-imports", "-Yno-predef", "-Ymacro-annotations",
     "-Yoverride-objects", "-Yoverride-vars", "-Ypatmat-debug", "-Yno-adapted-args", "-Ypos-debug", "-Ypresentation-debug",
     "-Ypresentation-strict", "-Ypresentation-verbose", "-Yquasiquote-debug", "-Yrangepos", "-Yreify-copypaste", "-Yreify-debug", "-Yrepl-class-based",
     "-Yrepl-sync", "-Yshow-member-pos", "-Yshow-symkinds", "-Yshow-symowners", "-Yshow-syms", "-Yshow-trees", "-Yshow-trees-compact", "-Yshow-trees-stringified", "-Ytyper-debug",

project/ScalaOptionParser.scala

@@ -445,9 +445,9 @@ class Global(var currentSettings: Settings, reporter0: Reporter)
   // I only changed analyzer.
   //
   // factory for phases: namer, packageobjects, typer
-  lazy val analyzer = new {
-    val global: Global.this.type = Global.this
-  } with Analyzer
+  lazy val analyzer =
+    if (settings.YmacroAnnotations) new { val global: Global.this.type = Global.this } with Analyzer with MacroAnnotationNamers
+    else new { val global: Global.this.type = Global.this } with Analyzer
 
   // phaseName = "patmat"
   object patmat extends {

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

@@ -6,12 +6,14 @@
 package scala.tools.nsc
 package ast
 
+import scala.reflect.internal.MacroAnnotionTreeInfo
+
 /** This class ...
  *
  *  @author Martin Odersky
  *  @version 1.0
  */
-abstract class TreeInfo extends scala.reflect.internal.TreeInfo {
+abstract class TreeInfo extends scala.reflect.internal.TreeInfo with MacroAnnotionTreeInfo {
   val global: Global
   import global._
   import definitions._

src/compiler/scala/tools/nsc/ast/TreeInfo.scala

@@ -2370,10 +2370,7 @@ self =>
       val nameOffset = in.offset
       val name = ident()
       var bynamemod = 0
-      val tpt =
-        if ((settings.YmethodInfer && !owner.isTypeName) && in.token != COLON) {
-          TypeTree()
-        } else { // XX-METHOD-INFER
+      val tpt = {
           accept(COLON)
           if (in.token == ARROW) {
             if (owner.isTypeName && !mods.isLocalToThis)

src/compiler/scala/tools/nsc/ast/parser/Parsers.scala

@@ -212,7 +212,7 @@ trait Scanners extends ScannersCommon {
 
     /** Clear buffer and set name and token */
     private def finishNamed(idtoken: Token = IDENTIFIER): Unit = {
-      name = newTermName(cbuf.toString)
+      name = newTermName(cbuf.toArray)
       cbuf.clear()
       token = idtoken
       if (idtoken == IDENTIFIER) {

src/compiler/scala/tools/nsc/ast/parser/Scanners.scala

@@ -682,8 +682,9 @@ abstract class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
     // Note that the presence of the `FINAL` flag on a symbol does not correspond 1:1 to emitting
     // ACC_FINAL in bytecode.
     //
-    // Top-level modules are marked ACC_FINAL in bytecode (even without the FINAL flag). Nested
-    // objects don't get the flag to allow overriding (under -Yoverride-objects, scala/bug#5676).
+    // Top-level modules are marked ACC_FINAL in bytecode (even without the FINAL flag).
+    // Currently, nested objects don't get the flag (originally, to allow overriding under the now-removed -Yoverride-objects, scala/bug#5676).
+    // TODO: give nested objects the ACC_FINAL flag again, since we won't let them be overridden
     //
     // For fields, only eager val fields can receive ACC_FINAL. vars or lazy vals can't:
     // Source: http://docs.oracle.com/javase/specs/jls/se7/html/jls-17.html#jls-17.5.3

src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala

@@ -141,11 +141,9 @@ trait ScalaSettings extends AbsScalaSettings
   val showPhases         = BooleanSetting      ("-Xshow-phases", "Print a synopsis of compiler phases.")
   val sourceReader       = StringSetting       ("-Xsource-reader", "classname", "Specify a custom method for reading source files.", "")
   val reporter           = StringSetting       ("-Xreporter", "classname", "Specify a custom reporter for compiler messages.", "scala.tools.nsc.reporters.ConsoleReporter")
-  val strictInference    = BooleanSetting      ("-Xstrict-inference", "Don't infer known-unsound types")
   val source             = ScalaVersionSetting ("-Xsource", "version", "Treat compiler input as Scala source for the specified version, see scala/bug#8126.", initial = ScalaVersion("2.13"))
 
   val XnoPatmatAnalysis = BooleanSetting ("-Xno-patmat-analysis", "Don't perform exhaustivity/unreachability analysis. Also, ignore @switch annotation.")
-  val XfullLubs         = BooleanSetting ("-Xfull-lubs", "Retains pre 2.10 behavior of less aggressive truncation of least upper bounds.")
 
   val XmixinForceForwarders = ChoiceSetting(
     name    = "-Xmixin-force-forwarders",
@@ -187,8 +185,6 @@ trait ScalaSettings extends AbsScalaSettings
   /**
    * -Y "Private" settings
    */
-  val overrideObjects = BooleanSetting    ("-Yoverride-objects", "Allow member objects to be overridden.")
-  val overrideVars    = BooleanSetting    ("-Yoverride-vars", "Allow vars to be overridden.")
   val Yhelp           = BooleanSetting    ("-Y", "Print a synopsis of private options.")
   val breakCycles     = BooleanSetting    ("-Ybreak-cycles", "Attempt to break cycles encountered during typing")
   val browse          = PhasesSetting     ("-Ybrowse", "Browse the abstract syntax tree after")
@@ -203,7 +199,6 @@ trait ScalaSettings extends AbsScalaSettings
   val Ynogenericsig   = BooleanSetting    ("-Yno-generic-signatures", "Suppress generation of generic signatures for Java.")
   val noimports       = BooleanSetting    ("-Yno-imports", "Compile without importing scala.*, java.lang.*, or Predef.")
   val nopredef        = BooleanSetting    ("-Yno-predef", "Compile without importing Predef.")
-  val noAdaptedArgs   = BooleanSetting    ("-Yno-adapted-args", "Do not adapt an argument list (either by inserting () or creating a tuple) to match the receiver.")
   val Yrecursion      = IntSetting        ("-Yrecursion", "Set recursion depth used when locking symbols.", 0, Some((0, Int.MaxValue)), (_: String) => None)
   val Xshowtrees      = BooleanSetting    ("-Yshow-trees", "(Requires -Xprint:) Print detailed ASTs in formatted form.")
   val XshowtreesCompact
@@ -223,14 +218,13 @@ trait ScalaSettings extends AbsScalaSettings
   val Yreifycopypaste = BooleanSetting    ("-Yreify-copypaste", "Dump the reified trees in copypasteable representation.")
   val Ymacroexpand    = ChoiceSetting     ("-Ymacro-expand", "policy", "Control expansion of macros, useful for scaladoc and presentation compiler.", List(MacroExpand.Normal, MacroExpand.None, MacroExpand.Discard), MacroExpand.Normal)
   val Ymacronoexpand  = BooleanSetting    ("-Ymacro-no-expand", "Don't expand macros. Might be useful for scaladoc and presentation compiler, but will crash anything which uses macros and gets past typer.") withDeprecationMessage(s"Use ${Ymacroexpand.name}:${MacroExpand.None}") withPostSetHook(_ => Ymacroexpand.value = MacroExpand.None)
+  val YmacroAnnotations = BooleanSetting  ("-Ymacro-annotations", "Enable support for macro annotations, formerly in macro paradise.")
   val Yreplsync       = BooleanSetting    ("-Yrepl-sync", "Do not use asynchronous code for repl startup")
   val Yreplclassbased = BooleanSetting    ("-Yrepl-class-based", "Use classes to wrap REPL snippets instead of objects")
   val Yreploutdir     = StringSetting     ("-Yrepl-outdir", "path", "Write repl-generated classfiles to given output directory (use \"\" to generate a temporary dir)" , "")
-  val YmethodInfer    = BooleanSetting    ("-Yinfer-argument-types", "Infer types for arguments of overridden methods.")
   val YdisableFlatCpCaching  = BooleanSetting    ("-YdisableFlatCpCaching", "Do not cache flat classpath representation of classpath elements from jars across compiler instances.")
   val YcachePluginClassLoader  = CachePolicy.setting("plugin", "compiler plugins")
   val YcacheMacroClassLoader   = CachePolicy.setting("macro", "macros")
-  val Yvirtpatmat     = BooleanSetting    ("-Yvirtpatmat", "Enable pattern matcher virtualization")
 
   val exposeEmptyPackage = BooleanSetting ("-Yexpose-empty-package", "Internal only: expose the empty package.").internalOnly()
   val Ydelambdafy        = ChoiceSetting  ("-Ydelambdafy", "strategy", "Strategy used for translating lambdas into JVM code.", List("inline", "method"), "method")

src/compiler/scala/tools/nsc/settings/ScalaSettings.scala

@@ -100,44 +100,6 @@ trait MatchCodeGen extends Interface {
     }
   }
 
-  trait PureMatchMonadInterface extends MatchMonadInterface {
-    val matchStrategy: Tree
-    import CODE._
-    def _match(n: Name): SelectStart = matchStrategy DOT n
-
-    // TODO: error message
-    private lazy val oneType              = typer.typedOperator(_match(vpmName.one)).tpe
-    override def pureType(tp: Type): Type = firstParamType(appliedType(oneType, tp :: Nil))
-  }
-
-  trait PureCodegen extends CodegenCore with PureMatchMonadInterface {
-    def codegen: AbsCodegen = pureCodegen
-
-    object pureCodegen extends CommonCodegen with Casegen { import CODE._
-      //// methods in MatchingStrategy (the monad companion) -- used directly in translation
-      // __match.runOrElse(`scrut`)(`scrutSym` => `matcher`)
-      // TODO: consider catchAll, or virtualized matching will break in exception handlers
-      def matcher(scrut: Tree, scrutSym: Symbol, restpe: Type)(cases: List[Casegen => Tree], matchFailGen: Option[Tree => Tree]): Tree =
-        _match(vpmName.runOrElse) APPLY (scrut) APPLY (fun(scrutSym, cases map (f => f(this)) reduceLeft typedOrElse))
-
-      // __match.one(`res`)
-      def one(res: Tree): Tree = (_match(vpmName.one)) (res)
-      // __match.zero
-      protected def zero: Tree = _match(vpmName.zero)
-      // __match.guard(`c`, `then`)
-      def guard(c: Tree, thenp: Tree): Tree = _match(vpmName.guard) APPLY (c, thenp)
-
-      //// methods in the monad instance -- used directly in translation
-      // `prev`.flatMap(`b` => `next`)
-      def flatMap(prev: Tree, b: Symbol, next: Tree): Tree = (prev DOT vpmName.flatMap)(fun(b, next))
-      // `thisCase`.orElse(`elseCase`)
-      def typedOrElse(thisCase: Tree, elseCase: Tree): Tree = (thisCase DOT vpmName.orElse) APPLY (elseCase)
-      //  __match.guard(`cond`, `res`).flatMap(`nextBinder` => `next`)
-      def flatMapCond(cond: Tree, res: Tree, nextBinder: Symbol, next: Tree): Tree = flatMap(guard(cond, res), nextBinder, next)
-      //  __match.guard(`guardTree`, ()).flatMap((_: P[Unit]) => `next`)
-      def flatMapGuard(guardTree: Tree, next: Tree): Tree = flatMapCond(guardTree, CODE.UNIT, freshSym(guardTree.pos, pureType(UnitTpe)), next)
-    }
-  }
 
   trait OptimizedCodegen extends CodegenCore with TypedSubstitution with MatchMonadInterface {
     override def codegen: AbsCodegen = optimizedCodegen