wip

Author: nicolasstucki

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

@@ -1597,6 +1597,11 @@ 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

@@ -229,7 +229,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     object ClassDef extends ClassDefModule:
       def apply(cls: Symbol, constr: DefDef, parents: List[Tree], body: List[Statement]): ClassDef =
-        tpd.ClassDefWithParents(cls, constr, parents, body)
+        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 = {
         val dotc.ast.Trees.TypeDef(_, originalImpl: tpd.Template) = original
@@ -263,6 +263,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     object DefDef extends DefDefModule:
       def apply(symbol: Symbol, rhsFn: List[List[Tree]] => Option[Term]): DefDef =
+        assert(symbol.isTerm, s"expected a term symbol but received $symbol")
         withDefaultPos(tpd.DefDef(symbol.asTerm, prefss =>
           xCheckMacroedOwners(xCheckMacroValidExpr(rhsFn(prefss)), symbol).getOrElse(tpd.EmptyTree)
         ))
@@ -1807,7 +1808,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         (x.prefix, x.name.toString)
     end TermRef
 
-    type TypeRef = dotc.core.Types.NamedType
+    type TypeRef = dotc.core.Types.TypeRef
 
     object TypeRefTypeTest extends TypeTest[TypeRepr, TypeRef]:
       def unapply(x: TypeRepr): Option[TypeRef & x.type] = x match
@@ -2457,6 +2458,20 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def requiredModule(path: String): Symbol = dotc.core.Symbols.requiredModule(path)
       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(
+          owner,
+          name.toTypeName,
+          flags,
+          parents,
+          dotc.core.Scopes.newScopeWith(decls*),
+          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)
+
       def newMethod(owner: Symbol, name: String, tpe: TypeRepr): Symbol =
         newMethod(owner, name, tpe, Flags.EmptyFlags, noSymbol)
       def newMethod(owner: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol =

library/src/scala/quoted/Quotes.scala

@@ -3534,6 +3534,8 @@ 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
+
       /** Generates a new method symbol with the given parent, name and type.
       *
       *  This symbol starts without an accompanying definition.

tests/run-macros/ClassDef_apply.check

@@ -0,0 +1 @@
+a

tests/run-macros/ClassDef_apply/Macro_1.scala

@@ -0,0 +1,24 @@
+import scala.quoted.*
+
+inline def makeClass(inline name: String): Any = ${ makeClassExpr('name) }
+private def makeClassExpr(name: 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 constr = DefDef(cls.primaryConstructor, argss => Some('{}.asTerm))
+  val clsDef = ClassDef(cls, constr, parents = Nil, body = Nil)
+  val newCls = Typed(Apply(Select(New(TypeIdent(cls)), cls.primaryConstructor), Nil), Inferred(TypeRepr.of[Object]))
+  Block(List(clsDef), newCls).asExpr
+  // '{
+  //   class `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)]))

tests/run-macros/ClassDef_apply/Test_2.scala

@@ -0,0 +1,4 @@
+@main def Test: Unit = {
+  val x = makeClass("foo")
+  println(x.getClass)
+}