Merge remote-tracking branch 'origin/master' into promotion-rule-2

Author: natsukagami

.gitmodules

@@ -184,3 +184,6 @@
 [submodule "community-build/community-projects/akka"]
 	path = community-build/community-projects/akka
 	url = https://github.com/dotty-staging/akka.git
+[submodule "community-build/community-projects/protoquill"]
+	path = community-build/community-projects/protoquill
+	url = https://github.com/dotty-staging/protoquill.git

community-build/community-projects/protoquill

@@ -91,7 +91,7 @@ final case class SbtCommunityProject(
     dependencies: List[CommunityProject] = Nil,
     sbtPublishCommand: String = null,
     sbtDocCommand: String = null,
-    scalacOptions: List[String] = List("-Ycheck-init")
+    scalacOptions: List[String] = SbtCommunityProject.scalacOptions
   ) extends CommunityProject:
   override val binaryName: String = "sbt"
 
@@ -127,6 +127,12 @@ final case class SbtCommunityProject(
       s"--addPluginSbtFile=$sbtPluginFilePath"
     )
 
+object SbtCommunityProject:
+  def scalacOptions = List(
+    "-Ycheck:macros",
+    "-Ycheck-init",
+  )
+
 object projects:
 
   private def forceDoc(projects: String*) =
@@ -452,6 +458,7 @@ object projects:
     project        = "verify",
     sbtTestCommand = "verifyJVM/test",
     sbtDocCommand = "verifyJVM/doc",
+    scalacOptions = SbtCommunityProject.scalacOptions.filter(_ != "-Ycheck:macros") // TODO enable -Ycheck:macros
   )
 
   lazy val discipline = SbtCommunityProject(
@@ -473,7 +480,7 @@ object projects:
     sbtTestCommand = "test",
     sbtPublishCommand = "coreJVM/publishLocal;coreJS/publishLocal",
     dependencies = List(discipline),
-    scalacOptions = Nil // disable -Ycheck-init
+    scalacOptions = SbtCommunityProject.scalacOptions.filter(_ != "-Ycheck-init")
   )
 
   lazy val simulacrumScalafixAnnotations = SbtCommunityProject(
@@ -487,7 +494,8 @@ object projects:
     sbtTestCommand = "set scalaJSStage in Global := FastOptStage;buildJVM;validateAllJS",
     sbtPublishCommand = "catsJVM/publishLocal;catsJS/publishLocal",
     dependencies = List(discipline, disciplineMunit, scalacheck, simulacrumScalafixAnnotations),
-    scalacOptions = Nil  // disable -Ycheck-init, due to -Xfatal-warning
+    scalacOptions = SbtCommunityProject.scalacOptions.filter(_ != "-Ycheck-init") // disable -Ycheck-init, due to -Xfatal-warning
+
   )
 
   lazy val catsMtl = SbtCommunityProject(
@@ -598,6 +606,14 @@ object projects:
     dependencies = List(scalatest, scalatestplusJunit, scalatestplusScalacheck)
   )
 
+  lazy val protoquill = SbtCommunityProject(
+    project = "protoquill",
+    sbtTestCommand = "test",
+    sbtPublishCommand = "publishLocal",
+    dependencies = List(), // TODO add scalatest and pprint (see protoquill/build.sbt)
+    scalacOptions = List("-language:implicitConversions"), // disabled -Ycheck-init, due to bug in macro
+  )
+
 end projects
 
 def allProjects = List(
@@ -663,6 +679,7 @@ def allProjects = List(
   projects.izumiReflect,
   projects.perspective,
   projects.akka,
+  projects.protoquill,
 )
 
 lazy val projectMap = allProjects.groupBy(_.project)

community-build/community-projects/scalatest

@@ -108,6 +108,7 @@ class CommunityBuildTestA extends CommunityBuildTest:
   @Test def upickle = projects.upickle.run()
   @Test def utest = projects.utest.run()
   @Test def zio = projects.zio.run()
+  @Test def protoquill = projects.protoquill.run()
 
   // 'scala-stm' and 'Sciss/Lucre':
   // @Test def scissEqual      = projects.scissEqual     .run()

community-build/community-projects/shapeless

@@ -335,6 +335,14 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
         emitAssocs(av, assocs, BCodeHelpers.this)(this)
       }
 
+    /*
+     * must-single-thread
+     */
+    def emitParamNames(jmethod: asm.MethodVisitor, params: List[Symbol]) =
+      for param <- params do
+        var access = asm.Opcodes.ACC_FINAL
+        jmethod.visitParameter(param.name.mangledString, access)
+
     /*
      * must-single-thread
      */

community-build/community-projects/utest

@@ -615,7 +615,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
     /*
      * must-single-thread
      */
-    def initJMethod(flags: Int, paramAnnotations: List[List[Annotation]]): Unit = {
+    def initJMethod(flags: Int, params: List[Symbol]): Unit = {
 
       val jgensig = getGenericSignature(methSymbol, claszSymbol)
       val (excs, others) = methSymbol.annotations.partition(_.symbol eq defn.ThrowsAnnot)
@@ -637,7 +637,8 @@ trait BCodeSkelBuilder extends BCodeHelpers {
       // TODO param names: (m.params map (p => javaName(p.sym)))
 
       emitAnnotations(mnode, others)
-      emitParamAnnotations(mnode, paramAnnotations)
+      emitParamNames(mnode, params)
+      emitParamAnnotations(mnode, params.map(_.annotations))
 
     } // end of method initJMethod
 
@@ -749,7 +750,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
           .addFlagIf(isNative, asm.Opcodes.ACC_NATIVE) // native methods of objects are generated in mirror classes
 
       // TODO needed? for(ann <- m.symbol.annotations) { ann.symbol.initialize }
-      initJMethod(flags, params.map(p => p.symbol.annotations))
+      initJMethod(flags, params.map(_.symbol))
 
 
       if (!isAbstractMethod && !isNative) {

community-build/community-projects/verify

@@ -42,7 +42,6 @@ class Compiler {
     List(new semanticdb.ExtractSemanticDB) :: // Extract info into .semanticdb files
     List(new PostTyper) ::          // Additional checks and cleanups after type checking
     List(new sjs.PrepJSInterop) ::  // Additional checks and transformations for Scala.js (Scala.js only)
-    List(new Staging) ::            // Check PCP, heal quoted types and expand macros
     List(new sbt.ExtractAPI) ::     // Sends a representation of the API of classes to sbt via callbacks
     List(new SetRootTree) ::        // Set the `rootTreeOrProvider` on class symbols
     Nil
@@ -51,6 +50,7 @@ class Compiler {
   protected def picklerPhases: List[List[Phase]] =
     List(new Pickler) ::            // Generate TASTY info
     List(new Inlining) ::           // Inline and execute macros
+    List(new Staging) ::            // Check staging levels and heal staged types
     List(new PickleQuotes) ::       // Turn quoted trees into explicit run-time data structures
     Nil
 

community-build/src/scala/dotty/communitybuild/projects.scala

@@ -64,19 +64,30 @@ class Driver {
 
   protected def sourcesRequired: Boolean = true
 
-  def setup(args: Array[String], rootCtx: Context): (List[AbstractFile], Context) = {
+  protected def command: CompilerCommand = ScalacCommand
+
+  /** Setup context with initialized settings from CLI arguments, then check if there are any settings that
+   *  would change the default behaviour of the compiler.
+   *
+   *  @return If there is no setting like `-help` preventing us from continuing compilation,
+   *  this method returns a list of files to compile and an updated Context.
+   *  If compilation should be interrupted, this method returns None.
+   */
+  def setup(args: Array[String], rootCtx: Context): Option[(List[AbstractFile], Context)] = {
     val ictx = rootCtx.fresh
-    val summary = CompilerCommand.distill(args)(using ictx)
+    val summary = command.distill(args, ictx.settings)(ictx.settingsState)(using ictx)
     ictx.setSettings(summary.sstate)
     MacroClassLoader.init(ictx)
     Positioned.init(using ictx)
 
     inContext(ictx) {
       if !ctx.settings.YdropComments.value || ctx.mode.is(Mode.ReadComments) then
         ictx.setProperty(ContextDoc, new ContextDocstrings)
-      val fileNames = CompilerCommand.checkUsage(summary, sourcesRequired)
-      val files = fileNames.map(ctx.getFile)
-      (files, fromTastySetup(files))
+      val fileNamesOrNone = command.checkUsage(summary, sourcesRequired)(using ctx.settings)(using ctx.settingsState)
+      fileNamesOrNone.map { fileNames =>
+        val files = fileNames.map(ctx.getFile)
+        (files, fromTastySetup(files))
+      }
     }
   }
 
@@ -182,8 +193,11 @@ class Driver {
    *                    if compilation succeeded.
    */
   def process(args: Array[String], rootCtx: Context): Reporter = {
-    val (files, compileCtx) = setup(args, rootCtx)
-    doCompile(newCompiler(using compileCtx), files)(using compileCtx)
+    setup(args, rootCtx) match
+      case Some((files, compileCtx)) =>
+        doCompile(newCompiler(using compileCtx), files)(using compileCtx)
+      case None =>
+        rootCtx.reporter
   }
 
   def main(args: Array[String]): Unit = {

community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala

@@ -40,16 +40,21 @@ class Resident extends Driver {
 
   final override def process(args: Array[String], rootCtx: Context): Reporter = {
     @tailrec def loop(args: Array[String], prevCtx: Context): Reporter = {
-      var (files, ctx) = setup(args, prevCtx)
-      inContext(ctx) { doCompile(residentCompiler, files) }
-      var nextCtx = ctx
-      var line = getLine()
-      while (line == reset) {
-        nextCtx = rootCtx
-        line = getLine()
-      }
-      if (line.startsWith(quit)) ctx.reporter
-      else loop(line split "\\s+", nextCtx)
+      setup(args, prevCtx) match
+        case Some((files, ctx)) =>
+          inContext(ctx) {
+            doCompile(residentCompiler, files)
+          }
+          var nextCtx = ctx
+          var line = getLine()
+          while (line == reset) {
+            nextCtx = rootCtx
+            line = getLine()
+          }
+          if (line.startsWith(quit)) ctx.reporter
+          else loop(line split "\\s+", nextCtx)
+        case None =>
+          prevCtx.reporter
     }
     loop(args, rootCtx)
   }

compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala

@@ -0,0 +1,9 @@
+package dotty.tools.dotc
+
+import config.Properties._
+import config.CompilerCommand
+
+object ScalacCommand extends CompilerCommand:
+  override def cmdName: String = "scalac"
+  override def versionMsg: String = s"Scala compiler $versionString -- $copyrightString"
+  override def ifErrorsMsg: String = "  scalac -help  gives more information"

compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala

@@ -914,14 +914,22 @@ object desugar {
               def badRightAssoc(problem: String) =
                 report.error(i"right-associative extension method $problem", mdef.srcPos)
                 ext.paramss ++ mdef.paramss
-              params1 match
+              def noVParam = badRightAssoc("must start with a single parameter")
+              def checkVparam(params: ParamClause) = params match
                 case ValDefs(vparam :: Nil) =>
                   if !vparam.mods.is(Given) then
                     val (leadingUsing, otherExtParamss) = ext.paramss.span(isUsingOrTypeParamClause)
                     leadingUsing ::: params1 :: otherExtParamss ::: paramss1
                   else badRightAssoc("cannot start with using clause")
                 case _ =>
-                  badRightAssoc("must start with a single parameter")
+                  noVParam
+              params1 match
+                case TypeDefs(_) => paramss1 match
+                  case params2 :: _ => checkVparam(params2)
+                  case _            => noVParam
+                case _ =>
+                  checkVparam(params1)
+
             case _ =>
               ext.paramss ++ mdef.paramss
         ).withMods(mdef.mods | ExtensionMethod)

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -251,14 +251,16 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case TypeDefs(_) => true
     case _ => isUsingClause(params)
 
+  private val languageSubCategories = Set(nme.experimental, nme.deprecated)
+
   /** If `path` looks like a language import, `Some(name)` where name
    *  is `experimental` if that sub-module is imported, and the empty
    *  term name otherwise.
    */
   def languageImport(path: Tree): Option[TermName] = path match
-    case Select(p1, nme.experimental) =>
+    case Select(p1, name: TermName) if languageSubCategories.contains(name) =>
       languageImport(p1) match
-        case Some(EmptyTermName) => Some(nme.experimental)
+        case Some(EmptyTermName) => Some(name)
         case _ => None
     case p1: RefTree if p1.name == nme.language =>
       p1.qualifier match
@@ -936,10 +938,15 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
      *  The result can be the contents of a term or type quote, which
      *  will return a term or type tree respectively.
      */
-    def unapply(tree: tpd.Tree)(using Context): Option[tpd.Tree] = tree match {
-      case tree: GenericApply if tree.symbol.isQuote => Some(tree.args.head)
-      case _ => None
-    }
+    def unapply(tree: tpd.Apply)(using Context): Option[tpd.Tree] =
+      if tree.symbol == defn.QuotedRuntime_exprQuote then
+        // quoted.runtime.Expr.quote[T](<body>)
+        Some(tree.args.head)
+      else if tree.symbol == defn.QuotedTypeModule_of then
+        // quoted.Type.of[<body>](quotes)
+        val TypeApply(_, body :: _) = tree.fun
+        Some(body)
+      else None
   }
 
   /** Extractors for splices */

compiler/src/dotty/tools/dotc/Driver.scala

@@ -26,7 +26,7 @@ class TreeMapWithImplicits extends tpd.TreeMap {
    *   - be tail-recursive where possible
    *   - don't re-allocate trees where nothing has changed
    */
-  def transformStats(stats: List[Tree], exprOwner: Symbol)(using Context): List[Tree] = {
+  override def transformStats(stats: List[Tree], exprOwner: Symbol)(using Context): List[Tree] = {
 
     @tailrec def traverse(curStats: List[Tree])(using Context): List[Tree] = {
 
@@ -85,23 +85,23 @@ class TreeMapWithImplicits extends tpd.TreeMap {
   }
 
   override def transform(tree: Tree)(using Context): Tree = {
-    def localCtx =
-      if (tree.hasType && tree.symbol.exists) ctx.withOwner(tree.symbol) else ctx
     try tree match {
-      case tree: Block =>
-        super.transform(tree)(using nestedScopeCtx(tree.stats))
+      case Block(stats, expr) =>
+        inContext(nestedScopeCtx(stats)) {
+          if stats.exists(_.isInstanceOf[Import]) then
+            // need to transform stats and expr together to account for import visibility
+            val stats1 = transformStats(stats :+ expr, ctx.owner)
+            cpy.Block(tree)(stats1.init, stats1.last)
+          else super.transform(tree)
+        }
       case tree: DefDef =>
-        inContext(localCtx) {
+        inContext(localCtx(tree)) {
           cpy.DefDef(tree)(
             tree.name,
             transformParamss(tree.paramss),
             transform(tree.tpt),
             transform(tree.rhs)(using nestedScopeCtx(tree.paramss.flatten)))
         }
-      case EmptyValDef =>
-        tree
-      case _: PackageDef | _: MemberDef =>
-        super.transform(tree)(using localCtx)
       case impl @ Template(constr, parents, self, _) =>
         cpy.Template(tree)(
           transformSub(constr),

compiler/src/dotty/tools/dotc/Resident.scala

@@ -130,7 +130,7 @@ class TreeTypeMap(
       }
   }
 
-  override def transformStats(trees: List[tpd.Tree])(using Context): List[Tree] =
+  override def transformStats(trees: List[tpd.Tree], exprOwner: Symbol)(using Context): List[Tree] =
     transformDefs(trees)._2
 
   def transformDefs[TT <: tpd.Tree](trees: List[TT])(using Context): (TreeTypeMap, List[TT]) = {