address review comments

Author: jchyb

Diff for: compiler/src/dotty/tools/dotc/core/Symbols.scala

@@ -629,19 +629,19 @@ object Symbols extends SymUtils {
     newClassSymbol(owner, name, flags, completer, privateWithin, coord, compUnitInfo)
   }
 
-  /** Same as `newNormalizedClassSymbol` except that `parents` can be a function returning a list of arbitrary
-   *  types which get normalized into type refs and parameter bindings.
+  /** Same as the other `newNormalizedClassSymbol` except that `parents` can be a function returning a list of arbitrary
+   *  types which get normalized into type refs and parameter bindings and annotations can be assigned in the completer.
    */
-  def newNormalizedClassSymbolUsingClassSymbolinParents(
+  def newNormalizedClassSymbol(
       owner: Symbol,
       name: TypeName,
       flags: FlagSet,
       parentTypes: Symbol => List[Type],
-      selfInfo: Type = NoType,
-      privateWithin: Symbol = NoSymbol,
-      annotations: List[Tree] = Nil,
-      coord: Coord = NoCoord,
-      compUnitInfo: CompilationUnitInfo | Null = null)(using Context): ClassSymbol = {
+      selfInfo: Type,
+      privateWithin: Symbol,
+      annotations: List[Tree],
+      coord: Coord,
+      compUnitInfo: CompilationUnitInfo | Null)(using Context): ClassSymbol = {
     def completer = new LazyType {
       def complete(denot: SymDenotation)(using Context): Unit = {
         val cls = denot.asClass.classSymbol
@@ -735,23 +735,23 @@ object Symbols extends SymUtils {
   /** Same as `newNormalizedModuleSymbol` except that `parents` can be a function returning a list of arbitrary
    *  types which get normalized into type refs and parameter bindings.
    */
-  def newNormalizedModuleSymbolUsingClassSymbolInParents(
+  def newNormalizedModuleSymbol(
       owner: Symbol,
       name: TermName,
       modFlags: FlagSet,
       clsFlags: FlagSet,
       parentTypes: ClassSymbol => List[Type],
       decls: Scope,
-      privateWithin: Symbol = NoSymbol,
-      coord: Coord = NoCoord,
-      compUnitInfo: CompilationUnitInfo | Null = null)(using Context): TermSymbol = {
+      privateWithin: Symbol,
+      coord: Coord,
+      compUnitInfo: CompilationUnitInfo | Null)(using Context): TermSymbol = {
     def completer(module: Symbol) = new LazyType {
       def complete(denot: SymDenotation)(using Context): Unit = {
         val cls = denot.asClass.classSymbol
         val decls = newScope
-        val parents = parentTypes(cls)
+        val parents = parentTypes(cls).map(_.dealias)
         assert(parents.nonEmpty && !parents.head.typeSymbol.is(dotc.core.Flags.Trait), "First parent must be a class")
-        denot.info = ClassInfo(owner.thisType, cls, parents.map(_.dealias), decls, TermRef(owner.thisType, module))
+        denot.info = ClassInfo(owner.thisType, cls, parents, decls, TermRef(owner.thisType, module))
       }
     }
     newModuleSymbol(

Diff for: compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -26,6 +26,7 @@ import scala.reflect.TypeTest
 import dotty.tools.dotc.core.NameKinds.ExceptionBinderName
 import dotty.tools.dotc.transform.TreeChecker
 import dotty.tools.dotc.core.Names
+import dotty.tools.dotc.util.Spans.NoCoord
 
 object QuotesImpl {
 
@@ -2728,14 +2729,16 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         assert(!conPrivateWithin.exists || conPrivateWithin.isType, "consPrivateWithin must be a type symbol or `Symbol.noSymbol`")
         checkValidFlags(clsFlags.toTypeFlags, Flags.validClassFlags)
         checkValidFlags(conFlags.toTermFlags, Flags.validClassConstructorFlags)
-        val cls = dotc.core.Symbols.newNormalizedClassSymbolUsingClassSymbolinParents(
+        val cls = dotc.core.Symbols.newNormalizedClassSymbol(
           owner,
           name.toTypeName,
           clsFlags,
           parents,
           selfType.getOrElse(Types.NoType),
           clsPrivateWithin,
-          clsAnnotations
+          clsAnnotations,
+          NoCoord,
+          compUnitInfo = null
         )
         val methodType: MethodOrPoly = conMethodType(cls.typeRef)
         def throwShapeException() = throw new Exception("Shapes of conMethodType and conParamFlags differ.")
@@ -2809,14 +2812,17 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
       def newModule(owner: Symbol, name: String, modFlags: Flags, clsFlags: Flags, parents: Symbol => List[TypeRepr], decls: Symbol => List[Symbol], privateWithin: Symbol): Symbol =
         assert(!privateWithin.exists || privateWithin.isType, "privateWithin must be a type symbol or `Symbol.noSymbol`")
-        val mod = dotc.core.Symbols.newNormalizedModuleSymbolUsingClassSymbolInParents(
+        val mod = dotc.core.Symbols.newNormalizedModuleSymbol(
           owner,
           name.toTermName,
           modFlags | dotc.core.Flags.ModuleValCreationFlags,
           clsFlags | dotc.core.Flags.ModuleClassCreationFlags,
           parents,
           dotc.core.Scopes.newScope,
-          privateWithin)
+          privateWithin,
+          NoCoord,
+          compUnitInfo = null
+        )
         val cls = mod.moduleClass.asClass
         cls.enter(dotc.core.Symbols.newConstructor(cls, dotc.core.Flags.Synthetic, Nil, Nil))
         for sym <- decls(cls) do cls.enter(sym)

Diff for: library/src/scala/quoted/Quotes.scala

@@ -3859,7 +3859,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
        *
        *  Example usage:
        *  ```
-       *  val name = nameExpr.valueOrAbort
+       *  val name = "myClass"
        *  def decls(cls: Symbol): List[Symbol] =
        *    List(Symbol.newMethod(cls, "foo", MethodType(Nil)(_ => Nil, _ => TypeRepr.of[Unit])))
        *  val parents = List(TypeTree.of[Object])
@@ -3881,10 +3881,20 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
        *    Some('{println(s"Foo method call with (${${Ref(idxSym).asExpr}}, ${${Ref(strSym).asExpr}})")}.asTerm)
        *  )
        *  val clsDef = ClassDef(cls, parents, body = List(fooDef))
-       *  val newCls = Apply(Select(New(TypeIdent(cls)), cls.primaryConstructor), List(idxExpr.asTerm, strExpr.asTerm))
+       *  val newCls = Apply(Select(New(TypeIdent(cls)), cls.primaryConstructor), List('{0}.asTerm, '{string}.asTerm))
        *
        *  Block(List(clsDef), Apply(Select(newCls, cls.methodMember("foo")(0)), Nil)).asExprOf[Unit]
        *  ```
+       *  construct the equivalent to
+       *  ```
+       *  '{
+       *    class myClass(idx: Int, str: String) extends Object {
+       *      def foo() =
+       *        println(s"Foo method call with $idx, $str")
+       *    }
+       *    new myClass(0, "string").foo()
+       *  }
+       *  ```
        *  @param owner The owner of the class
        *  @param name The name of the class
        *  @param parents Function returning the parent classes of the class. The first parent must not be a trait.
@@ -3965,7 +3975,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
        *  constructs the equivalent to
        *  ```
        *  '{
-       *    class myClass[T](val param: T) {
+       *    class myClass[T](val param: T) extends Object {
        *      def getParam: T =
        *        println("Calling getParam")
        *        param