Use quotes alias

Author: nicolasstucki

sourcecode/src-3/sourcecode/Macros.scala

@@ -64,25 +64,25 @@ trait ArgsMacros {
 }
 
 object Util{
-  def isSynthetic(using Quotes)(s: qctx.reflect.Symbol) = isSyntheticName(getName(s))
+  def isSynthetic(using Quotes)(s: quotes.reflect.Symbol) = isSyntheticName(getName(s))
   def isSyntheticName(name: String) = {
     name == "<init>" || (name.startsWith("<local ") && name.endsWith(">")) || name == "$anonfun" || name == "macro"
   }
-  def getName(using Quotes)(s: qctx.reflect.Symbol) = {
+  def getName(using Quotes)(s: quotes.reflect.Symbol) = {
     s.name.trim
       .stripSuffix("$") // meh
   }
 }
 
 object Macros {
 
-  def findOwner(using Quotes)(owner: qctx.reflect.Symbol, skipIf: qctx.reflect.Symbol => Boolean): qctx.reflect.Symbol = {
+  def findOwner(using Quotes)(owner: quotes.reflect.Symbol, skipIf: quotes.reflect.Symbol => Boolean): quotes.reflect.Symbol = {
     var owner0 = owner
     while(skipIf(owner0)) owner0 = owner0.owner
     owner0
   }
 
-  def actualOwner(using Quotes)(owner: qctx.reflect.Symbol): qctx.reflect.Symbol =
+  def actualOwner(using Quotes)(owner: quotes.reflect.Symbol): quotes.reflect.Symbol =
     findOwner(owner, owner0 => Util.isSynthetic(owner0) || Util.getName(owner0) == "ev")
 
   /**
@@ -94,11 +94,11 @@ object Macros {
    * Where n is an ordinal. This method returns the first owner that is not
    * such a synthetic variable.
    */
-  def nonMacroOwner(using Quotes)(owner: qctx.reflect.Symbol): qctx.reflect.Symbol =
-    findOwner(owner, owner0 => { owner0.flags.is(qctx.reflect.Flags.Macro) && Util.getName(owner0) == "macro"})
+  def nonMacroOwner(using Quotes)(owner: quotes.reflect.Symbol): quotes.reflect.Symbol =
+    findOwner(owner, owner0 => { owner0.flags.is(quotes.reflect.Flags.Macro) && Util.getName(owner0) == "macro"})
 
   def nameImpl(using Quotes): Expr[Name] = {
-    import qctx.reflect._
+    import quotes.reflect._
     val owner = actualOwner(Symbol.spliceOwner)
     val simpleName = Util.getName(owner)
     '{Name(${Expr(simpleName)})}
@@ -112,14 +112,14 @@ object Macros {
       s
 
   def nameMachineImpl(using Quotes): Expr[Name.Machine] = {
-    import qctx.reflect._
+    import quotes.reflect._
     val owner = nonMacroOwner(Symbol.spliceOwner)
     val simpleName = adjustName(Util.getName(owner))
     '{Name.Machine(${Expr(simpleName)})}
   }
 
   def fullNameImpl(using Quotes): Expr[FullName] = {
-    import qctx.reflect._
+    import quotes.reflect._
     @annotation.tailrec def cleanChunk(chunk: String): String =
       val refined = chunk.stripPrefix("_$").stripSuffix("$")
       if chunk != refined then cleanChunk(refined) else refined
@@ -135,7 +135,7 @@ object Macros {
   }
 
   def fullNameMachineImpl(using Quotes): Expr[FullName.Machine] = {
-    import qctx.reflect._
+    import quotes.reflect._
     val owner = nonMacroOwner(Symbol.spliceOwner)
     val fullName = owner.fullName.trim
       .split("\\.", -1)
@@ -146,23 +146,23 @@ object Macros {
   }
 
   def fileImpl(using Quotes): Expr[sourcecode.File] = {
-    import qctx.reflect._
-    val file = qctx.reflect.Position.ofMacroExpansion.sourceFile.jpath.toAbsolutePath.toString
+    import quotes.reflect._
+    val file = quotes.reflect.Position.ofMacroExpansion.sourceFile.jpath.toAbsolutePath.toString
     '{sourcecode.File(${Expr(file)})}
   }
 
   def fileNameImpl(using Quotes): Expr[sourcecode.FileName] = {
-    val name = qctx.reflect.Position.ofMacroExpansion.sourceFile.jpath.getFileName.toString
+    val name = quotes.reflect.Position.ofMacroExpansion.sourceFile.jpath.getFileName.toString
     '{sourcecode.FileName(${Expr(name)})}
   }
 
   def lineImpl(using Quotes): Expr[sourcecode.Line] = {
-    val line = qctx.reflect.Position.ofMacroExpansion.startLine + 1
+    val line = quotes.reflect.Position.ofMacroExpansion.startLine + 1
     '{sourcecode.Line(${Expr(line)})}
   }
 
   def enclosingImpl(using Quotes): Expr[Enclosing] = {
-    import qctx.reflect._
+    import quotes.reflect._
     val path = enclosing(machine = false)(!Util.isSynthetic(_))
     '{Enclosing(${Expr(path)})}
   }
@@ -182,7 +182,7 @@ object Macros {
   }
 
   def argsImpl(using qctx: Quotes): Expr[Args] = {
-    import qctx.reflect._
+    import quotes.reflect._
 
     val param: List[List[ValDef]] = {
       def nearestEnclosingMethod(owner: Symbol): List[List[ValDef]] =
@@ -212,7 +212,7 @@ object Macros {
 
 
   def text[T: Type](v: Expr[T])(using Quotes): Expr[sourcecode.Text[T]] = {
-    import qctx.reflect._
+    import quotes.reflect._
     val txt = Term.of(v).pos.sourceCode
     '{sourcecode.Text[T]($v, ${Expr(txt)})}
   }
@@ -225,8 +225,8 @@ object Macros {
 
   }
 
-  def enclosing(using Quotes)(machine: Boolean)(filter: qctx.reflect.Symbol => Boolean): String = {
-    import qctx.reflect._
+  def enclosing(using Quotes)(machine: Boolean)(filter: quotes.reflect.Symbol => Boolean): String = {
+    import quotes.reflect._
 
     var current = Symbol.spliceOwner
     if (!machine)