Add reflect fresh names API

* Add `Symbol.freshName`
* Remove `Symbol.newUniqueMethod`
* Remove `Symbol.newUniqueVal`

This API is necessary to be able to create new class members without
having name clashes. It should also be usable to create new top level
definitions that have names that do not clash.

This version of unique name can be used for `val`, `def` and `class` symbols.

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/NameKinds.scala

@@ -300,6 +300,7 @@ object NameKinds {
   val UniqueInlineName: UniqueNameKind       = new UniqueNameKind("$i")
   val InlineScrutineeName: UniqueNameKind    = new UniqueNameKind("$scrutinee")
   val InlineBinderName: UniqueNameKind       = new UniqueNameKind("$proxy")
+  val MacroNames: UniqueNameKind             = new UniqueNameKind("$macro$")
 
   /** A kind of unique extension methods; Unlike other unique names, these can be
    *  unmangled.

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -2485,17 +2485,14 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         newMethod(owner, name, tpe, Flags.EmptyFlags, noSymbol)
       def newMethod(owner: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol =
         dotc.core.Symbols.newSymbol(owner, name.toTermName, flags | dotc.core.Flags.Method, tpe, privateWithin)
-      def newUniqueMethod(owner: Symbol, namePrefix: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol =
-        val name = NameKinds.UniqueName.fresh(namePrefix.toTermName)
-        dotc.core.Symbols.newSymbol(owner, name, dotc.core.Flags.PrivateMethod | flags, tpe, privateWithin)
       def newVal(owner: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol =
         dotc.core.Symbols.newSymbol(owner, name.toTermName, flags, tpe, privateWithin)
-      def newUniqueVal(owner: Symbol, namePrefix: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol =
-        val name = NameKinds.UniqueName.fresh(namePrefix.toTermName)
-        dotc.core.Symbols.newSymbol(owner, name, flags, tpe, privateWithin)
       def newBind(owner: Symbol, name: String, flags: Flags, tpe: TypeRepr): Symbol =
         dotc.core.Symbols.newSymbol(owner, name.toTermName, flags | Case, tpe)
       def noSymbol: Symbol = dotc.core.Symbols.NoSymbol
+
+      def freshName(prefix: String): String =
+        NameKinds.MacroNames.fresh(prefix.toTermName).toString
     end Symbol
 
     given SymbolMethods: SymbolMethods with

library/src/scala/annotation/MacroAnnotation.scala

@@ -34,7 +34,8 @@ trait MacroAnnotation extends StaticAnnotation:
    *        case DefDef(name, TermParamClause(param  :: Nil) :: Nil, tpt, Some(rhsTree)) =>
    *          (param.tpt.tpe.asType, tpt.tpe.asType) match
    *            case ('[t], '[u]) =>
-   *              val cacheSymbol = Symbol.newUniqueVal(Symbol.spliceOwner, name + "Cache", TypeRepr.of[mutable.Map[t, u]], Flags.Private, Symbol.noSymbol)
+   *              val cacheName = Symbol.freshName(name + "Cache")
+   *              val cacheSymbol = Symbol.newVal(Symbol.spliceOwner, cacheName, TypeRepr.of[mutable.Map[t, u]], Flags.Private, Symbol.noSymbol)
    *              val cacheRhs =
    *                given Quotes = cacheSymbol.asQuotes
    *                '{ mutable.Map.empty[t, u] }.asTerm
@@ -60,10 +61,10 @@ trait MacroAnnotation extends StaticAnnotation:
    *  ```
    *  and the macro will modify the definition to create
    *  ```scala
-   *   val fibCache =
+   *   val fibCache$macro$1 =
    *     scala.collection.mutable.Map.empty[Int, Int]
    *   def fib(n: Int): Int =
-   *     fibCache.getOrElseUpdate(
+   *     fibCache$macro$1.getOrElseUpdate(
    *       n,
    *       {
    *         println(s"compute fib of $n")

library/src/scala/quoted/Quotes.scala

@@ -3669,25 +3669,6 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       */
       def newMethod(parent: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol
 
-      /** Generates a new method symbol with the given parent, name and type.
-       *
-       *  To define a member method of a class, use the `newMethod` within the `decls` function of `newClass`.
-       *
-       *  @param parent The owner of the method
-       *  @param name The name of the method
-       *  @param tpe The type of the method (MethodType, PolyType, ByNameType)
-       *  @param flags extra flags to with which the symbol should be constructed
-       *  @param privateWithin the symbol within which this new method symbol should be private. May be noSymbol.
-       *
-       *  This symbol starts without an accompanying definition.
-       *  It is the meta-programmer's responsibility to provide exactly one corresponding definition by passing
-       *  this symbol to the DefDef constructor.
-       *
-       *  @note As a macro can only splice code into the point at which it is expanded, all generated symbols must be
-       *        direct or indirect children of the reflection context's owner.
-       */
-      @experimental def newUniqueMethod(parent: Symbol, namePrefix: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol
-
       /** Generates a new val/var/lazy val symbol with the given parent, name and type.
       *
       *  This symbol starts without an accompanying definition.
@@ -3706,25 +3687,6 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       */
       def newVal(parent: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol
 
-      /** Generates a new val/var/lazy val symbol with the given parent, name prefix and type.
-       *
-       *  This symbol starts without an accompanying definition.
-       *  It is the meta-programmer's responsibility to provide exactly one corresponding definition by passing
-       *  this symbol to the ValDef constructor.
-       *
-       *  Note: Also see newVal
-       *  Note: Also see ValDef.let
-       *
-       *  @param parent The owner of the val/var/lazy val
-       *  @param name The name of the val/var/lazy val
-       *  @param tpe The type of the val/var/lazy val
-       *  @param flags extra flags to with which the symbol should be constructed
-       *  @param privateWithin the symbol within which this new method symbol should be private. May be noSymbol.
-       *  @note As a macro can only splice code into the point at which it is expanded, all generated symbols must be
-       *        direct or indirect children of the reflection context's owner.
-       */
-      @experimental def newUniqueVal(parent: Symbol, namePrefix: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol
-
       /** Generates a pattern bind symbol with the given parent, name and type.
       *
       *  This symbol starts without an accompanying definition.
@@ -3742,6 +3704,18 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
 
       /** Definition not available */
       def noSymbol: Symbol
+
+      /** A fresh name for class or member symbol names.
+       *
+       *  Fresh names are constructed using the following format `prefix + "$macro$" + freshIndex`.
+       *  The `freshIndex` are unique within the current source file.
+       *
+       *  Examples: See `scala.annotation.MacroAnnotation`
+       *
+       *  @param prefix Prefix of the fresh name
+       */
+      @experimental
+      def freshName(prefix: String): String
     }
 
     /** Makes extension methods on `Symbol` available without any imports */
@@ -4415,6 +4389,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       end extension
     }
 
+
     ///////////////
     // POSITIONS //
     ///////////////

tests/neg-macros/annot-accessIndirect/Macro_1.scala

@@ -5,7 +5,7 @@ import scala.quoted._
 class hello extends MacroAnnotation {
   def transform(using Quotes)(tree: quotes.reflect.Definition): List[quotes.reflect.Definition] =
     import quotes.reflect._
-    val helloSymbol = Symbol.newUniqueVal(Symbol.spliceOwner, "hello", TypeRepr.of[String], Flags.EmptyFlags, Symbol.noSymbol)
+    val helloSymbol = Symbol.newVal(Symbol.spliceOwner, Symbol.freshName("hello"), TypeRepr.of[String], Flags.EmptyFlags, Symbol.noSymbol)
     val helloVal = ValDef(helloSymbol, Some(Literal(StringConstant("Hello, World!"))))
     List(helloVal, tree)
 }

tests/neg-macros/annot-result-owner.check

@@ -2,8 +2,8 @@
 -- Error: tests/neg-macros/annot-result-owner/Test_2.scala:1:0 ---------------------------------------------------------
 1 |@insertVal // error
   |^^^^^^^^^^
-  |macro annotation @insertVal added value definitionWithWrongOwner$1 with an inconsistent owner. Expected it to be owned by package object Test_2$package but was owned by method foo.
+  |macro annotation @insertVal added value definitionWithWrongOwner$macro$1 with an inconsistent owner. Expected it to be owned by package object Test_2$package but was owned by method foo.
 -- Error: tests/neg-macros/annot-result-owner/Test_2.scala:5:2 ---------------------------------------------------------
 5 |  @insertVal // error
   |  ^^^^^^^^^^
-  |macro annotation @insertVal added value definitionWithWrongOwner$2 with an inconsistent owner. Expected it to be owned by method bar but was owned by method foo.
+  |macro annotation @insertVal added value definitionWithWrongOwner$macro$2 with an inconsistent owner. Expected it to be owned by method bar but was owned by method foo.

tests/neg-macros/annot-result-owner/Macro_1.scala

@@ -6,6 +6,6 @@ class insertVal extends MacroAnnotation:
   def transform(using Quotes)(tree: quotes.reflect.Definition): List[quotes.reflect.Definition] =
     import quotes.reflect._
     // Use of wrong owner
-    val valSym = Symbol.newUniqueVal(tree.symbol, "definitionWithWrongOwner", TypeRepr.of[Unit], Flags.Private, Symbol.noSymbol)
+    val valSym = Symbol.newVal(tree.symbol, Symbol.freshName("definitionWithWrongOwner"), TypeRepr.of[Unit], Flags.Private, Symbol.noSymbol)
     val valDef = ValDef(valSym, Some('{}.asTerm))
     List(valDef, tree)

tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala

@@ -74,8 +74,7 @@ val experimentalDefinitionInLibrary = Set(
   // Need experimental annotation macros to check that design works.
   "scala.quoted.Quotes.reflectModule.ClassDefModule.apply",
   "scala.quoted.Quotes.reflectModule.SymbolModule.newClass",
-  "scala.quoted.Quotes.reflectModule.SymbolModule.newUniqueMethod",
-  "scala.quoted.Quotes.reflectModule.SymbolModule.newUniqueVal",
+  "scala.quoted.Quotes.reflectModule.SymbolModule.freshName",
   "scala.quoted.Quotes.reflectModule.SymbolMethods.info",
 
   // New APIs: Lightweight lazy vals. Can be stabilized in 3.3.0

tests/run-macros/annot-bind/Macro_1.scala

@@ -7,7 +7,7 @@ class bind(str: String) extends MacroAnnotation:
     import quotes.reflect._
     tree match
       case ValDef(name, tpt, Some(rhsTree)) =>
-        val valSym = Symbol.newUniqueVal(Symbol.spliceOwner, str, tpt.tpe, Flags.Private, Symbol.noSymbol)
+        val valSym = Symbol.newVal(Symbol.spliceOwner, Symbol.freshName(str), tpt.tpe, Flags.Private, Symbol.noSymbol)
         val valDef = ValDef(valSym, Some(rhsTree))
         val newRhs = Ref(valSym)
         val newTree = ValDef.copy(tree)(name, tpt, Some(newRhs))

tests/run-macros/annot-generate/Macro_1.scala

@@ -5,7 +5,7 @@ import scala.quoted._
 class hello extends MacroAnnotation {
   def transform(using Quotes)(tree: quotes.reflect.Definition): List[quotes.reflect.Definition] =
     import quotes.reflect._
-    val helloSymbol = Symbol.newUniqueVal(Symbol.spliceOwner, "hello", TypeRepr.of[String], Flags.EmptyFlags, Symbol.noSymbol)
+    val helloSymbol = Symbol.newVal(Symbol.spliceOwner, Symbol.freshName("hello"), TypeRepr.of[String], Flags.EmptyFlags, Symbol.noSymbol)
     val helloVal = ValDef(helloSymbol, Some(Literal(StringConstant("Hello, World!"))))
     List(helloVal, tree)
 }

tests/run-macros/annot-memo/Macro_1.scala

@@ -10,7 +10,8 @@ class memoize extends MacroAnnotation:
       case DefDef(name, TermParamClause(param  :: Nil) :: Nil, tpt, Some(rhsTree)) =>
         (param.tpt.tpe.asType, tpt.tpe.asType) match
           case ('[t], '[u]) =>
-            val cacheSymbol = Symbol.newUniqueVal(Symbol.spliceOwner, name + "Cache", TypeRepr.of[mutable.Map[t, u]], Flags.Private, Symbol.noSymbol)
+            val cacheName = Symbol.freshName(name + "Cache")
+            val cacheSymbol = Symbol.newVal(Symbol.spliceOwner, cacheName, TypeRepr.of[mutable.Map[t, u]], Flags.Private, Symbol.noSymbol)
             val cacheRhs =
               given Quotes = cacheSymbol.asQuotes
               '{ mutable.Map.empty[t, u] }.asTerm

tests/run-macros/annot-memo/Test_2.scala

@@ -12,6 +12,14 @@ class Bar:
   //>     else fib(n - 1) + fib(n - 2)
   //>   })
 
+  //> private val fibCache$macro$1: mutable.Map[(n : Int), Int] = mutable.Map.empty[(n : Int), Int] // FIXME: leaks (n : Int)
+  //> @memoize def fib(n: Int): Int =
+  //>  fibCache$macro$1.getOrElseUpdate(n, {
+  //>     println(s"compute fib of $n")
+  //>     if n <= 1 then n
+  //>     else fib(n - 1) + fib(n - 2)
+  //>   })
+
   @memoize
   def fib(n: Long): Long =
     println(s"compute fib of $n")

tests/run-macros/annot-result-order/Macro_1.scala

@@ -6,7 +6,7 @@ class print(msg: String) extends MacroAnnotation:
   def transform(using Quotes)(tree: quotes.reflect.Definition): List[quotes.reflect.Definition] =
     import quotes.reflect._
     def printMsg(msg: String) =
-      val valSym = Symbol.newUniqueVal(Symbol.spliceOwner, tree.symbol.name + "$print$" + msg, TypeRepr.of[Unit], Flags.Private, Symbol.noSymbol)
+      val valSym = Symbol.newVal(Symbol.spliceOwner, Symbol.freshName("print"), TypeRepr.of[Unit], Flags.Private, Symbol.noSymbol)
       val valRhs =
         given Quotes = valSym.asQuotes
         '{ println(${Expr(msg)}) }.asTerm

tests/run-macros/annot-simple-fib/Macro_1.scala

@@ -8,7 +8,8 @@ class memoize extends MacroAnnotation {
     import quotes.reflect._
     tree match
       case DefDef(name, params, tpt, Some(fibTree)) =>
-        val cacheSymbol = Symbol.newUniqueVal(Symbol.spliceOwner, name + "Cache", TypeRepr.of[Map[Int, Int]], Flags.EmptyFlags, Symbol.noSymbol)
+        val cacheName = Symbol.freshName(name + "Cache")
+        val cacheSymbol = Symbol.newVal(Symbol.spliceOwner, cacheName, TypeRepr.of[Map[Int, Int]], Flags.EmptyFlags, Symbol.noSymbol)
         val cacheRhs =
           given Quotes = cacheSymbol.asQuotes
           '{Map.empty[Int, Int]}.asTerm

tests/run-macros/annot-simple-fib/Test_2.scala

@@ -4,6 +4,16 @@ class Bar:
     println(s"compute fib of $n")
     if n <= 1 then n
     else fib(n - 1) + fib(n - 2)
+  //> val fibCache$macro$1: mutable.Map[Int, Int] = mutable.Map.empty[Int, Int]
+  //> @memoize def fib(n: Int): Int =
+  //>   if fibCache$macro$1.contains(n) then fibCache$macro$1(n)
+  //>   else
+  //>     val res: Int =
+  //>       println(s"compute fib of $n")
+  //>       if n <= 1 then n
+  //>       else fib(n - 1) + fib(n - 2)
+  //>     fibCache$macro$1.update(n, res)
+  //>     res
 
 @main def Test =
   val t = new Bar