wip

Author: nicolasstucki

compiler/src/dotty/tools/dotc/typer/Inliner.scala

@@ -1597,11 +1597,6 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
                         && level == 0
                         && !hasInliningErrors =>
           val expanded = expandMacro(res.args.head, tree.srcPos)
-          println(" ")
-          println(expanded)
-          println(expanded.show)
-          println(" ")
-          println(" ")
           typedExpr(expanded) // Inline calls and constant fold code generated by the macro
         case res =>
           specializeEq(inlineIfNeeded(res))

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

@@ -228,7 +228,10 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
     end ClassDefTypeTest
 
     object ClassDef extends ClassDefModule:
-      def apply(cls: Symbol, constr: DefDef, parents: List[Tree], body: List[Statement]): ClassDef =
+      def apply(cls: Symbol, parents: List[Tree], body: List[Statement]): ClassDef =
+        val constr = ctx.typeAssigner.assignType(untpd.DefDef(nme.CONSTRUCTOR, Nil, tpd.TypeTree(dotc.core.Symbols.defn.UnitClass.typeRef), untpd.EmptyTree), cls.primaryConstructor)
+        println(constr.show)
+        println(constr)
         tpd.ClassDefWithParents(cls.asClass, constr, parents, body)
 
       def copy(original: Tree)(name: String, constr: DefDef, parents: List[Tree], selfOpt: Option[ValDef], body: List[Statement]): ClassDef = {
@@ -2459,18 +2462,18 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def requiredMethod(path: String): Symbol = dotc.core.Symbols.requiredMethod(path)
       def classSymbol(fullName: String): Symbol = dotc.core.Symbols.requiredClass(fullName)
 
-      def newClass(owner: Symbol, name: String, flags: Flags, parents: List[TypeRepr], decls: List[Symbol], selfInfo: Option[TypeRepr], privateWithin: Symbol): Symbol =
-        dotc.core.Symbols.newNormalizedClassSymbol(
+      def newClass(owner: Symbol, name: String, parents: List[TypeRepr], decls: Symbol => List[Symbol], selfInfo: Option[TypeRepr]): Symbol =
+        val cls = dotc.core.Symbols.newNormalizedClassSymbol(
           owner,
           name.toTypeName,
-          flags,
+          Flags.EmptyFlags,
           parents,
-          dotc.core.Scopes.newScopeWith(decls*),
+          dotc.core.Scopes.newScope, // TODO remove from parameters of newNormalizedClassSymbol
           selfInfo.getOrElse(Types.NoType),
-          privateWithin)
-
-      def newPrimaryConstructor(cls: Symbol, tpe: TypeRepr): Symbol =
-        dotc.core.Symbols.newSymbol(cls, nme.CONSTRUCTOR, dotc.core.Flags.Method, tpe, noSymbol)
+          dotc.core.Symbols.NoSymbol)
+        val ctrTpe = Types.MethodType(Nil)(_ => Nil, _ => dotc.core.Symbols.defn.UnitClass.typeRef)
+        cls.enter(dotc.core.Symbols.newSymbol(cls, nme.CONSTRUCTOR, dotc.core.Flags.Method, ctrTpe, noSymbol))
+        cls
 
       def newMethod(owner: Symbol, name: String, tpe: TypeRepr): Symbol =
         newMethod(owner, name, tpe, Flags.EmptyFlags, noSymbol)

library/src/scala/quoted/Quotes.scala

@@ -464,7 +464,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
 
     /** Methods of the module object `val ClassDef` */
     trait ClassDefModule { this: ClassDef.type =>
-      @experimental def apply(cls: Symbol, constr: DefDef, parents: List[Tree /* Term | TypeTree */], body: List[Statement]): ClassDef
+      @experimental def apply(cls: Symbol, parents: List[Tree /* Term | TypeTree */], body: List[Statement]): ClassDef
       def copy(original: Tree)(name: String, constr: DefDef, parents: List[Tree /* Term | TypeTree */], selfOpt: Option[ValDef], body: List[Statement]): ClassDef
       def unapply(cdef: ClassDef): (String, DefDef, List[Tree /* Term | TypeTree */], Option[ValDef], List[Statement])
     }
@@ -3534,7 +3534,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       /** The class Symbol of a global class definition */
       def classSymbol(fullName: String): Symbol
 
-      def newClass(owner: Symbol, name: String, flags: Flags, parents: List[TypeRepr], decls: List[Symbol], selfInfo: Option[TypeRepr], privateWithin: Symbol): Symbol
+      @experimental def newClass(owner: Symbol, name: String, parents: List[TypeRepr], decls: Symbol => List[Symbol], selfInfo: Option[TypeRepr]): Symbol
 
       /** Generates a new method symbol with the given parent, name and type.
       *

tests/run-macros/ClassDef_apply.check

@@ -1 +1,2 @@
-a
+Constructing foo
+class Test_2$package$foo$1

tests/run-macros/ClassDef_apply/Macro_1.scala

@@ -1,24 +1,21 @@
 import scala.quoted.*
 
 inline def makeClass(inline name: String): Any = ${ makeClassExpr('name) }
-private def makeClassExpr(name: Expr[String])(using Quotes): Expr[Any] = {
+private def makeClassExpr(nameExpr: Expr[String])(using Quotes): Expr[Any] = {
   import quotes.reflect.*
 
-  val cls = Symbol.newClass(Symbol.spliceOwner, name.valueOrAbort, Flags.EmptyFlags, parents = List(TypeRepr.of[Object]), decls = Nil, selfInfo = None, privateWithin = Symbol.noSymbol)
+  val name = nameExpr.valueOrAbort
+  val parents = List(Inferred(TypeRepr.of[Object]))
+  def decls(cls: Symbol): List[Symbol] = Nil
 
-  val constr = DefDef(cls.primaryConstructor, argss => Some('{}.asTerm))
-  val clsDef = ClassDef(cls, constr, parents = Nil, body = Nil)
+  val cls = Symbol.newClass(Symbol.spliceOwner, name, parents = parents.map(_.tpe), decls, selfInfo = None)
+
+  val clsDef = ClassDef(cls, parents, body = List('{println(s"Constructing ${$nameExpr}")}.asTerm))
   val newCls = Typed(Apply(Select(New(TypeIdent(cls)), cls.primaryConstructor), Nil), Inferred(TypeRepr.of[Object]))
+
   Block(List(clsDef), newCls).asExpr
   // '{
-  //   class `name`()
+  //   class `name`() { println("Constructing `name`") }
   //   new `name`()
   // }
 }
-
-// Block(List(TypeDef(foo,Template(DefDef(<init>,List(List()),
-  // TypeTree[TypeRef(ThisType(TypeRef(NoPrefix,module class scala)),class Unit)],Literal(Constant(()))),List(),
-  // ValDef(_,EmptyTree,EmptyTree),List()))),Apply(Select(New(TypeTree[TypeRef(NoPrefix,class foo)]),<init>),List()))
-// Block(List(TypeDef(foo,Template(DefDef(<init>,List(List()),
-  // TypeTree[TypeRef(TermRef(ThisType(TypeRef(NoPrefix,module class <root>)),object scala),Unit)],EmptyTree),List(Apply(Select(New(TypeTree[TypeRef(TermRef(ThisType(TypeRef(NoPrefix,module class java)),object lang),Object)]),<init>),List())),
-  // ValDef(_,EmptyTree,EmptyTree),List()))),Typed(Apply(Select(New(Ident(foo)),<init>),List()),TypeTree[TypeRef(TermRef(ThisType(TypeRef(NoPrefix,module class java)),object lang),Object)]))