Change parameter names, add tests

Author: jchyb

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

@@ -249,15 +249,21 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
             else
               paramSym.map(ValDef(_, None))
           }
+        def throwError() =
+          throw new RuntimeException(
+            "Symbols necessary for creation of the ClassDef tree could not be found."
+          )
         val paramsAccessDefs: List[untpd.ParamClause] =
           cls.primaryConstructor.paramSymss.map { paramSym =>
             if paramSym.headOption.map(_.isType).getOrElse(false) then
               paramSym.map { symm =>
-                TypeDef(cls.typeMember(symm.name.toString()))
+                def isParamAccessor(memberSym: Symbol) = memberSym.flags.is(Flags.Param) && memberSym.name == symm.name
+                TypeDef(cls.typeMembers.find(isParamAccessor).getOrElse(throwError()))
               }
             else
               paramSym.map { symm =>
-                ValDef(cls.fieldMember(symm.name.toString()), None)// TODO I don't like the toString here
+                def isParam(memberSym: Symbol) = memberSym.flags.is(Flags.ParamAccessor) && memberSym.name == symm.name
+                ValDef(cls.fieldMembers.find(isParam).getOrElse(throwError()), None)
               }
           }
 
@@ -2645,13 +2651,13 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         parents: Symbol => List[TypeRepr],
         decls: Symbol => List[Symbol],
         selfType: Option[TypeRepr],
-        paramNames: List[String],
-        paramTypes: List[TypeRepr],
         clsFlags: Flags,
-        clsPrivateWithin: Symbol
+        clsPrivateWithin: Symbol,
+        conParamNames: List[String],
+        conParamTypes: List[TypeRepr],
       ): Symbol =
-        checkValidFlags(clsFlags.toTermFlags, Flags.validClassFlags)
-        assert(paramNames.length == paramTypes.length, "paramNames and paramTypes must have the same length")
+        checkValidFlags(clsFlags, Flags.validClassFlags)
+        assert(conParamNames.length == conParamTypes.length, "paramNames and paramTypes must have the same length")
         assert(!clsPrivateWithin.exists || clsPrivateWithin.isType, "clsPrivateWithin must be a type symbol or `Symbol.noSymbol`")
         val cls = dotc.core.Symbols.newNormalizedClassSymbolUsingClassSymbolinParents(
           owner,
@@ -2660,8 +2666,8 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           parents,
           selfType.getOrElse(Types.NoType),
           clsPrivateWithin)
-        cls.enter(dotc.core.Symbols.newConstructor(cls, dotc.core.Flags.Synthetic, paramNames.map(_.toTermName), paramTypes))
-        for (name, tpe) <- paramNames.zip(paramTypes) do
+        cls.enter(dotc.core.Symbols.newConstructor(cls, dotc.core.Flags.Synthetic, conParamNames.map(_.toTermName), conParamTypes))
+        for (name, tpe) <- conParamNames.zip(conParamTypes) do
           cls.enter(dotc.core.Symbols.newSymbol(cls, name.toTermName, Flags.ParamAccessor, tpe, Symbol.noSymbol))
         for sym <- decls(cls) do cls.enter(sym)
         cls
@@ -2672,39 +2678,39 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         parents: Symbol => List[TypeRepr],
         decls: Symbol => List[Symbol],
         selfType: Option[TypeRepr],
-        constructorMethodType: TypeRepr => MethodOrPoly,
         clsFlags: Flags,
         clsPrivateWithin: Symbol,
-        consFlags: Flags,
-        consPrivateWithin: Symbol,
-        consParamFlags: List[List[Flags]]
+        conMethodType: TypeRepr => MethodOrPoly,
+        conFlags: Flags,
+        conPrivateWithin: Symbol,
+        conParamFlags: List[List[Flags]]
       ) =
         assert(!clsPrivateWithin.exists || clsPrivateWithin.isType, "clsPrivateWithin must be a type symbol or `Symbol.noSymbol`")
-        assert(!consPrivateWithin.exists || consPrivateWithin.isType, "consPrivateWithin must be a type symbol or `Symbol.noSymbol`")
-        checkValidFlags(clsFlags.toTermFlags, Flags.validClassFlags)
+        assert(!conPrivateWithin.exists || conPrivateWithin.isType, "consPrivateWithin must be a type symbol or `Symbol.noSymbol`")
+        checkValidFlags(clsFlags.toTypeFlags, Flags.validClassFlags)
         val cls = dotc.core.Symbols.newNormalizedClassSymbolUsingClassSymbolinParents(
           owner,
           name.toTypeName,
           clsFlags,
           parents,
           selfType.getOrElse(Types.NoType),
           clsPrivateWithin)
-        val methodType: MethodOrPoly = constructorMethodType(cls.typeRef)
-        def throwShapeException() = throw new Exception("Shapes of constructorMethodType and consParamFlags differ.")
+        val methodType: MethodOrPoly = conMethodType(cls.typeRef)
+        def throwShapeException() = throw new Exception("Shapes of conMethodType and conParamFlags differ.")
         def checkMethodOrPolyShape(checkedMethodType: TypeRepr, clauseIdx: Int): Unit =
           checkedMethodType match
             case PolyType(params, _, res) if clauseIdx == 0 =>
-              if (consParamFlags.length < clauseIdx) throwShapeException()
-              if (consParamFlags(clauseIdx).length != params.length) throwShapeException()
+              if (conParamFlags.length < clauseIdx) throwShapeException()
+              if (conParamFlags(clauseIdx).length != params.length) throwShapeException()
               checkMethodOrPolyShape(res, clauseIdx + 1)
             case PolyType(_, _, _) => throw new Exception("Clause interleaving not supported for constructors")
             case MethodType(params, _, res) =>
-              if (consParamFlags.length < clauseIdx) throwShapeException()
-              if (consParamFlags(clauseIdx).length != params.length) throwShapeException()
+              if (conParamFlags.length <= clauseIdx) throwShapeException()
+              if (conParamFlags(clauseIdx).length != params.length) throwShapeException()
               checkMethodOrPolyShape(res, clauseIdx + 1)
             case _ =>
         checkMethodOrPolyShape(methodType, clauseIdx = 0)
-        cls.enter(dotc.core.Symbols.newSymbol(cls, nme.CONSTRUCTOR, Flags.Synthetic | Flags.Method | consFlags, methodType, consPrivateWithin, dotty.tools.dotc.util.Spans.NoCoord)) // constructor flags
+        cls.enter(dotc.core.Symbols.newSymbol(cls, nme.CONSTRUCTOR, Flags.Synthetic | Flags.Method | conFlags, methodType, conPrivateWithin, dotty.tools.dotc.util.Spans.NoCoord))
         def getParamAccessors(methodType: TypeRepr, clauseIdx: Int): List[((String, TypeRepr, Boolean, Int), Int)] =
           methodType match
             case MethodType(paramInfosExp, resultTypeExp, res) =>
@@ -2723,17 +2729,16 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         }
         for ((name, tpe, isType, clauseIdx), elementIdx) <- getParamAccessors(methodType, 0) do
           if isType then
-            val symbol = dotc.core.Symbols.newSymbol(cls, name.toTypeName, Flags.Param | Flags.Deferred | consParamFlags(clauseIdx)(elementIdx), tpe, Symbol.noSymbol)
+            val symbol = dotc.core.Symbols.newSymbol(cls, name.toTypeName, Flags.Param | Flags.Deferred | Flags.Private | Flags.PrivateLocal | Flags.Local | conParamFlags(clauseIdx)(elementIdx), tpe, Symbol.noSymbol)
             paramRefMap.addOne(elementIdx, symbol)
             cls.enter(symbol)
           else
             val fixedType = paramRefRemapper(tpe)
-            cls.enter(dotc.core.Symbols.newSymbol(cls, name.toTermName, Flags.ParamAccessor | consParamFlags(clauseIdx)(elementIdx), fixedType, Symbol.noSymbol)) // add other flags (local, private, privatelocal) and set privateWithin
+            cls.enter(dotc.core.Symbols.newSymbol(cls, name.toTermName, Flags.ParamAccessor | conParamFlags(clauseIdx)(elementIdx), fixedType, Symbol.noSymbol)) // set privateWithin
         for sym <- decls(cls) do cls.enter(sym)
         cls
 
       def newModule(owner: Symbol, name: String, modFlags: Flags, clsFlags: Flags, parents: Symbol => List[TypeRepr], decls: Symbol => List[Symbol], privateWithin: Symbol): Symbol =
-        // assert(parents.nonEmpty && !parents.head.typeSymbol.is(dotc.core.Flags.Trait), "First parent must be a class")
         assert(!privateWithin.exists || privateWithin.isType, "privateWithin must be a type symbol or `Symbol.noSymbol`")
         val mod = dotc.core.Symbols.newNormalizedModuleSymbolUsingClassSymbolInParents(
           owner,
@@ -3141,7 +3146,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       private[QuotesImpl] def validTypeAliasFlags: Flags = Private | Protected | Override | Final | Infix | Local
 
       // Keep: aligned with Quotes's `newClass`
-      private[QuotesImpl] def validClassFlags: Flags = Private | Protected | Final // Abstract, AbsOverride Local OPen ? PrivateLocal Protected ?
+      private[QuotesImpl] def validClassFlags: Flags = Private | Protected | PrivateLocal | Local | Final | Trait | Abstract // AbsOverride, Open
 
     end Flags
 

library/src/scala/quoted/Quotes.scala

@@ -3846,10 +3846,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
        * @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.
        * Takes the constructed class symbol as an argument. Calling `cls.typeRef.asType` as part of this function will lead to cyclic reference errors.
-       * @param paramNames constructor parameter names.
-       * @param paramTypes constructor parameter types.
        * @param clsFlags extra flags with which the class symbol should be constructed.
        * @param clsPrivateWithin the symbol within which this new class symbol should be private. May be noSymbol.
+       * @param conParamNames constructor parameter names.
+       * @param conParamTypes constructor parameter types.
        *
        * Parameters can be obtained via classSymbol.memberField
        */
@@ -3858,28 +3858,28 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
         name: String,
         parents: Symbol => List[TypeRepr],
         decls: Symbol => List[Symbol], selfType: Option[TypeRepr],
-        paramNames: List[String],
-        paramTypes: List[TypeRepr],
         clsFlags: Flags,
-        clsPrivateWithin: Symbol
+        clsPrivateWithin: Symbol,
+        conParamNames: List[String],
+        conParamTypes: List[TypeRepr]
       ): Symbol
 
       /**
         *
         *
         * @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.
+        * @param parents Function returning the parent classes of the class. The first parent must not be a trait
         * Takes the constructed class symbol as an argument. Calling `cls.typeRef.asType` as part of this function will lead to cyclic reference errors.
         * @param decls The member declarations of the class provided the symbol of this class
         * @param selfType The self type of the class if it has one
-        * @param constructorMethodType The MethodOrPoly type representing the type of the constructor.
-        * PolyType may only represent only the first clause of the constructor.
-        * @param clsFlags extra flags with which the class symbol should be constructed.
+        * @param clsFlags extra flags with which the class symbol should be constructed
         * @param clsPrivateWithin the symbol within which this new class symbol should be private. May be noSymbol
-        * @param consFlags extra flags with which the constructor symbol should be constructed.
-        * @param consPrivateWithin the symbol within which the constructor for this new class symbol should be private. May be noSymbol
-        * @param conParamFlags extra flags with which the constructor parameter symbols should be constructed. Must match the shape of @param constructorMethodType
+        * @param conMethodType The MethodOrPoly type representing the type of the constructor.
+        * PolyType may only represent the first clause of the constructor.
+        * @param conFlags extra flags with which the constructor symbol should be constructed
+        * @param conPrivateWithin the symbol within which the constructor for this new class symbol should be private. May be noSymbol.
+        * @param conParamFlags extra flags with which the constructor parameter symbols should be constructed. Must match the shape of `conMethodType`.
         *
         */
       @experimental def newClass(
@@ -3888,11 +3888,11 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
         parents: Symbol => List[TypeRepr],
         decls: Symbol => List[Symbol],
         selfType: Option[TypeRepr],
-        constructorMethodType: TypeRepr => MethodOrPoly,
         clsFlags: Flags,
         clsPrivateWithin: Symbol,
-        consFlags: Flags,
-        consPrivateWithin: Symbol,
+        conMethodType: TypeRepr => MethodOrPoly,
+        conFlags: Flags,
+        conPrivateWithin: Symbol,
         conParamFlags: List[List[Flags]]
       ): Symbol
 

tests/neg-macros/newClassParamsMissingArgument/Macro_1.scala

@@ -10,7 +10,7 @@ private def makeClassExpr(nameExpr: Expr[String])(using Quotes): Expr[Object] =
   val parents = List(TypeTree.of[Object])
   def decls(cls: Symbol): List[Symbol] = Nil
 
-  val cls = Symbol.newClass(Symbol.spliceOwner, name, parents = _ => parents.map(_.tpe), decls, selfType = None, List("idx"), List(TypeRepr.of[Int]), Flags.EmptyFlags, Symbol.noSymbol)
+  val cls = Symbol.newClass(Symbol.spliceOwner, name, parents = _ => parents.map(_.tpe), decls, selfType = None, Flags.EmptyFlags, Symbol.noSymbol, List("idx"), List(TypeRepr.of[Int]))
 
   val clsDef = ClassDef(cls, parents, body = Nil)
   val newCls = Typed(Apply(Select(New(TypeIdent(cls)), cls.primaryConstructor), Nil), TypeTree.of[Object])

tests/pos-macros/newClassExtendsWithSymbolInParent/Macro_1.scala

@@ -13,7 +13,7 @@ private def makeClassExpr(nameExpr: Expr[String])(using Quotes): Expr[Foo[_]] =
     List(AppliedType(TypeRepr.typeConstructorOf(Class.forName("Foo")), List(TypeIdent(cls).tpe)))
   def decls(cls: Symbol): List[Symbol] = Nil
 
-  val cls = Symbol.newClass(Symbol.spliceOwner, name, parents, decls, selfType = None, paramNames = Nil, paramTypes = Nil, Flags.EmptyFlags, Symbol.noSymbol)
+  val cls = Symbol.newClass(Symbol.spliceOwner, name, parents, decls, selfType = None, Flags.EmptyFlags, Symbol.noSymbol, conParamNames = Nil, conParamTypes = Nil)
 
   val parentsWithSym =
     cls.typeRef.asType match

tests/run-macros/newClassExtendsJavaClass.check

@@ -0,0 +1,2 @@
+class Main_2$package$foo$1
+22

tests/run-macros/newClassExtendsJavaClass/JavaClass.java

@@ -0,0 +1,9 @@
+class JavaClass<T> {
+  T value;
+  public JavaClass(T value) {
+    this.value = value;
+  }
+  public T getT() {
+    return value;
+  }
+}

tests/run-macros/newClassExtendsJavaClass/Macro_1.scala

@@ -0,0 +1,24 @@
+//> using options -experimental
+
+import scala.quoted.*
+
+transparent inline def makeClass(inline name: String): JavaClass[Int] = ${ makeClassExpr('name) }
+private def makeClassExpr(nameExpr: Expr[String])(using Quotes): Expr[JavaClass[Int]] = {
+  import quotes.reflect.*
+
+  val name = nameExpr.valueOrAbort
+  val parents = List(TypeTree.of[JavaClass[Int]])
+  def decls(cls: Symbol): List[Symbol] = Nil
+
+  val cls = Symbol.newClass(Symbol.spliceOwner, name, parents = _ => parents.map(_.tpe), decls, selfType = None, Flags.EmptyFlags, Symbol.noSymbol, List("idx"), List(TypeRepr.of[Int]))
+
+  val parentsWithSym = List(Apply(TypeApply(Select(New(TypeTree.of[JavaClass[Int]]), TypeRepr.of[JavaClass].typeSymbol.primaryConstructor), List(TypeTree.of[Int])), List(Ref(cls.fieldMember("idx")))))
+  val clsDef = ClassDef(cls, parentsWithSym, body = Nil)
+  val newCls = Typed(Apply(Select(New(TypeIdent(cls)), cls.primaryConstructor), List(Literal(IntConstant(22)))), TypeTree.of[JavaClass[Int]])
+
+  Block(List(clsDef), newCls).asExprOf[JavaClass[Int]]
+  // '{
+  //   class `name`(idx: Int) extends JavaClass[Int](idx)
+  //   new `name`(22)
+  // }
+}

tests/run-macros/newClassExtendsJavaClass/Main_2.scala

@@ -0,0 +1,7 @@
+//> using options -experimental
+
+@main def Test: Unit = {
+  val cls = makeClass("foo")
+  println(cls.getClass)
+  println(cls.getT())
+}

tests/run-macros/newClassParams.check

@@ -1 +1 @@
-Foo method call with (10, test)
+Foo method call with (10, test)

tests/run-macros/newClassParams/Macro_1.scala

@@ -10,7 +10,7 @@ private def makeClassAndCallExpr(nameExpr: Expr[String], idxExpr: Expr[Int], str
 
   def decls(cls: Symbol): List[Symbol] = List(Symbol.newMethod(cls, "foo", MethodType(Nil)(_ => Nil, _ => TypeRepr.of[Unit])))
   val parents = List(TypeTree.of[Object])
-  val cls = Symbol.newClass(Symbol.spliceOwner, name, parents = _ => parents.map(_.tpe), decls, selfType = None, List("idx", "str"), List(TypeRepr.of[Int], TypeRepr.of[String]), Flags.EmptyFlags, Symbol.noSymbol)
+  val cls = Symbol.newClass(Symbol.spliceOwner, name, parents = _ => parents.map(_.tpe), decls, selfType = None, Flags.EmptyFlags, Symbol.noSymbol, List("idx", "str"), List(TypeRepr.of[Int], TypeRepr.of[String]))
 
   val fooDef = DefDef(cls.methodMember("foo")(0), argss => Some('{println(s"Foo method call with (${${Ref(cls.fieldMember("idx")).asExpr}}, ${${Ref(cls.fieldMember("str")).asExpr}})")}.asTerm))
   val clsDef = ClassDef(cls, parents, body = List(fooDef))
@@ -25,4 +25,3 @@ private def makeClassAndCallExpr(nameExpr: Expr[String], idxExpr: Expr[Int], str
   //   new `name`(`idx`, `str`)
   // }
 }
-