Merge pull request #89 from dotty-staging/dotty-community-build

Upgrade Dotty to 0.24.0-RC1

Author: anatoliykmetyuk

build.sc

@@ -64,7 +64,8 @@ trait SourcecodeTestModule extends ScalaModule {
 }
 
 object sourcecode extends Module {
-  object jvm extends Cross[JvmSourcecodeModule]("2.11.12", "2.12.10", "2.13.1", "0.21.0-RC1")
+  val dottyVersion = Option(sys.props("dottyVersion"))
+  object jvm extends Cross[JvmSourcecodeModule]((List("2.11.12", "2.12.8", "2.13.0", "0.24.0-RC1") ++ dottyVersion): _*)
   class JvmSourcecodeModule(val crossScalaVersion: String)
     extends SourcecodeMainModule with ScalaModule with SourcecodeModule {
 

sourcecode/src-0/sourcecode/Macros.scala

@@ -67,29 +67,41 @@ trait ArgsMacros {
 object Util{
   def isSynthetic(c: Reflection)(s: c.Symbol) = isSyntheticName(getName(c)(s))
   def isSyntheticName(name: String) = {
-    name == "<init>" || (name.startsWith("<local ") && name.endsWith(">")) || name == "$anonfun"
+    name == "<init>" || (name.startsWith("<local ") && name.endsWith(">")) || name == "$anonfun" || name == "macro"
   }
   def getName(c: Reflection)(s: c.Symbol) = {
-    import c.given
+    import c.{given _}
     s.name.trim
       .stripSuffix("$") // meh
   }
 }
 
 object Macros {
 
-  def actualOwner(c: Reflection)(owner: c.Symbol): c.Symbol = {
-    import c.given
+  def findOwner(c: Reflection)(owner: c.Symbol, skipIf: (c: Reflection) => (c.Symbol) => Boolean): c.Symbol = {
+    import c.{given _}
     var owner0 = owner
-    // second condition is meh
-    while(Util.isSynthetic(c)(owner0) || Util.getName(c)(owner0) == "ev") {
-      owner0 = owner0.owner
-    }
+    while(skipIf(c)(owner0)) owner0 = owner0.owner
     owner0
   }
 
-  def nameImpl(given ctx: QuoteContext): Expr[Name] = {
-    import ctx.tasty.given
+  def actualOwner(c: Reflection)(owner: c.Symbol): c.Symbol =
+    findOwner(c)(owner, c => owner0 => Util.isSynthetic(c)(owner0) || Util.getName(c)(owner0) == "ev")
+
+  /**
+   * In Scala 3, macro `mcr()` is expanded to:
+   *
+   * val macro = ...
+   * macro
+   *
+   * Where n is an ordinal. This method returns the first owner that is not
+   * such a synthetic variable.
+   */
+  def nonMacroOwner(c: Reflection)(owner: c.Symbol): c.Symbol =
+    findOwner(c)(owner, c => owner0 => {import c.{given _}; owner0.flags.is(c.Flags.Macro) && Util.getName(c)(owner0) == "macro"})
+
+  def nameImpl(using ctx: QuoteContext): Expr[Name] = {
+    import ctx.tasty.{given _}
     val owner = actualOwner(ctx.tasty)(ctx.tasty.rootContext.owner)
     val simpleName = Util.getName(ctx.tasty)(owner)
     '{Name(${Expr(simpleName)})}
@@ -102,15 +114,15 @@ object Macros {
     else
       s
 
-  def nameMachineImpl(given ctx: QuoteContext): Expr[Name.Machine] = {
-    import ctx.tasty.given
-    val owner = ctx.tasty.rootContext.owner
+  def nameMachineImpl(using ctx: QuoteContext): Expr[Name.Machine] = {
+    import ctx.tasty.{given _}
+    val owner = nonMacroOwner(ctx.tasty)(ctx.tasty.rootContext.owner)
     val simpleName = adjustName(Util.getName(ctx.tasty)(owner))
     '{Name.Machine(${Expr(simpleName)})}
   }
 
-  def fullNameImpl(given ctx: QuoteContext): Expr[FullName] = {
-    import ctx.tasty.given
+  def fullNameImpl(using ctx: QuoteContext): Expr[FullName] = {
+    import ctx.tasty.{given _}
     @annotation.tailrec def cleanChunk(chunk: String): String =
       val refined = chunk.stripPrefix("_$").stripSuffix("$")
       if chunk != refined then cleanChunk(refined) else refined
@@ -125,9 +137,9 @@ object Macros {
     '{FullName(${Expr(fullName)})}
   }
 
-  def fullNameMachineImpl(given ctx: QuoteContext): Expr[FullName.Machine] = {
-    import ctx.tasty.given
-    val owner = ctx.tasty.rootContext.owner
+  def fullNameMachineImpl(using ctx: QuoteContext): Expr[FullName.Machine] = {
+    import ctx.tasty.{given _}
+    val owner = nonMacroOwner(ctx.tasty)(ctx.tasty.rootContext.owner)
     val fullName = owner.fullName.trim
       .split("\\.", -1)
       .map(_.stripPrefix("_$").stripSuffix("$")) // meh
@@ -136,39 +148,39 @@ object Macros {
     '{FullName.Machine(${Expr(fullName)})}
   }
 
-  def fileImpl(given ctx: QuoteContext): Expr[sourcecode.File] = {
-    import ctx.tasty.given
+  def fileImpl(using ctx: QuoteContext): Expr[sourcecode.File] = {
+    import ctx.tasty.{given _}
     val file = ctx.tasty.rootPosition.sourceFile.jpath.toAbsolutePath.toString
     '{sourcecode.File(${Expr(file)})}
   }
 
-  def fileNameImpl(given ctx: QuoteContext): Expr[sourcecode.FileName] = {
-    import ctx.tasty.given
+  def fileNameImpl(using ctx: QuoteContext): Expr[sourcecode.FileName] = {
+    import ctx.tasty.{given _}
     val name = ctx.tasty.rootPosition.sourceFile.jpath.getFileName.toString
     '{sourcecode.FileName(${Expr(name)})}
   }
 
-  def lineImpl(given ctx: QuoteContext): Expr[sourcecode.Line] = {
-    import ctx.tasty.given
+  def lineImpl(using ctx: QuoteContext): Expr[sourcecode.Line] = {
+    import ctx.tasty.{given _}
     val line = ctx.tasty.rootPosition.startLine + 1
     '{sourcecode.Line(${Expr(line)})}
   }
 
-  def enclosingImpl(given ctx: QuoteContext): Expr[Enclosing] = {
+  def enclosingImpl(using ctx: QuoteContext): Expr[Enclosing] = {
     val path = enclosing(ctx.tasty)(
       !Util.isSynthetic(ctx.tasty)(_)
     )
 
     '{Enclosing(${Expr(path)})}
   }
 
-  def enclosingMachineImpl(given ctx: QuoteContext): Expr[Enclosing.Machine] = {
+  def enclosingMachineImpl(using ctx: QuoteContext): Expr[Enclosing.Machine] = {
     val path = enclosing(ctx.tasty, machine = true)(_ => true)
     '{Enclosing.Machine(${Expr(path)})}
   }
 
-  def pkgImpl(given ctx: QuoteContext): Expr[Pkg] = {
-    import ctx.tasty.given
+  def pkgImpl(using ctx: QuoteContext): Expr[Pkg] = {
+    import ctx.tasty.{given _}
     val path = enclosing(ctx.tasty) {
       case s if s.isPackageDef => true
       case _ => false
@@ -177,8 +189,8 @@ object Macros {
     '{Pkg(${Expr(path)})}
   }
 
-  def argsImpl(given ctx: QuoteContext): Expr[Args] = {
-    import ctx.tasty.{ _, given }
+  def argsImpl(using ctx: QuoteContext): Expr[Args] = {
+    import ctx.tasty.{ _, given _ }
 
     val param: List[List[ctx.tasty.ValDef]] = {
       def nearestEnclosingMethod(owner: ctx.tasty.Symbol): List[List[ctx.tasty.ValDef]] =
@@ -207,8 +219,8 @@ object Macros {
   }
 
 
-  def text[T: Type](v: Expr[T])(given ctx: QuoteContext): Expr[sourcecode.Text[T]] = {
-    import ctx.tasty.given
+  def text[T: Type](v: Expr[T])(using ctx: QuoteContext): Expr[sourcecode.Text[T]] = {
+    import ctx.tasty.{given _}
     val txt = v.unseal.pos.sourceCode
     '{sourcecode.Text[T]($v, ${Expr(txt)})}
   }
@@ -222,11 +234,13 @@ object Macros {
   }
 
   def enclosing(c: Reflection, machine: Boolean = false)(filter: c.Symbol => Boolean): String = {
-    import c.{ _, given }
+    import c.{ _, given _ }
 
     var current = c.rootContext.owner
     if (!machine)
       current = actualOwner(c)(current)
+    else
+      current = nonMacroOwner(c)(current)
     var path = List.empty[Chunk]
     while(current != Symbol.noSymbol && current != defn.RootPackage && current != defn.RootClass){
       if (filter(current)) {