Add additional checks for type parameters and update tests

Author: jchyb

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

@@ -2727,7 +2727,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         assert(!clsPrivateWithin.exists || clsPrivateWithin.isType, "clsPrivateWithin must be a type symbol or `Symbol.noSymbol`")
         assert(!conPrivateWithin.exists || conPrivateWithin.isType, "consPrivateWithin must be a type symbol or `Symbol.noSymbol`")
         checkValidFlags(clsFlags.toTypeFlags, Flags.validClassFlags)
-        checkValidFlags(conFlags, Flags.validClassConstructorFlags)
+        checkValidFlags(conFlags.toTermFlags, Flags.validClassConstructorFlags)
         val cls = dotc.core.Symbols.newNormalizedClassSymbolUsingClassSymbolinParents(
           owner,
           name.toTypeName,
@@ -2750,33 +2750,58 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
               if (conParamFlags.length <= clauseIdx) throwShapeException()
               if (conParamFlags(clauseIdx).length != params.length) throwShapeException()
               checkMethodOrPolyShape(res, clauseIdx + 1)
-            case _ =>
+            case other =>
+              xCheckMacroAssert(
+                other.typeSymbol == cls,
+                "Incorrect type returned from the innermost PolyOrMethod."
+              )
+              (other, methodType) match
+                case (AppliedType(tycon, args), pt: PolyType) =>
+                  xCheckMacroAssert(
+                    args.length == pt.typeParams.length &&
+                    args.zip(pt.typeParams).forall {
+                      case (arg, param) => arg == param.paramRef
+                    },
+                    "Constructor result type does not correspond to the declared type parameters"
+                  )
+                case _ =>
+                  xCheckMacroAssert(
+                    !(other.isInstanceOf[AppliedType] || methodType.isInstanceOf[PolyType]),
+                    "AppliedType has to be the innermost resultTypeExp result if and only if conMethodType returns a PolyType"
+                  )
         checkMethodOrPolyShape(methodType, clauseIdx = 0)
+
         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)] =
+
+        case class ParamSymbolData(name: String, tpe: TypeRepr, isTypeParam: Boolean, clauseIdx: Int, elementIdx: Int)
+        def getParamSymbolsData(methodType: TypeRepr, clauseIdx: Int): List[ParamSymbolData] =
           methodType match
             case MethodType(paramInfosExp, resultTypeExp, res) =>
-              paramInfosExp.zip(resultTypeExp).map(_ :* false :* clauseIdx).zipWithIndex ++ getParamAccessors(res, clauseIdx + 1)
+              paramInfosExp.zip(resultTypeExp).zipWithIndex.map { case ((name, tpe), elementIdx) =>
+                ParamSymbolData(name, tpe, isTypeParam = false, clauseIdx, elementIdx)
+              } ++ getParamSymbolsData(res, clauseIdx + 1)
             case pt @ PolyType(paramNames, paramBounds, res) =>
-              paramNames.zip(paramBounds).map(_ :* true :* clauseIdx).zipWithIndex ++ getParamAccessors(res, clauseIdx + 1)
+              paramNames.zip(paramBounds).zipWithIndex.map {case ((name, tpe), elementIdx) =>
+                ParamSymbolData(name, tpe, isTypeParam = true, clauseIdx, elementIdx)
+              } ++ getParamSymbolsData(res, clauseIdx + 1)
             case result =>
               List()
-        // Maps PolyType indexes to type parameter symbols
+        // Maps PolyType indexes to type parameter symbol typerefs
         val paramRefMap = collection.mutable.HashMap[Int, Symbol]()
         val paramRefRemapper = new Types.TypeMap {
           def apply(tp: Types.Type) = tp match {
             case pRef: ParamRef if pRef.binder == methodType => paramRefMap(pRef.paramNum).typeRef
             case _ => mapOver(tp)
           }
         }
-        for ((name, tpe, isType, clauseIdx), elementIdx) <- getParamAccessors(methodType, 0) do
-          if isType then
-            checkValidFlags(conParamFlags(clauseIdx)(elementIdx), Flags.validClassTypeParamFlags)
+        for case ParamSymbolData(name, tpe, isTypeParam, clauseIdx, elementIdx) <- getParamSymbolsData(methodType, 0) do
+          if isTypeParam then
+            checkValidFlags(conParamFlags(clauseIdx)(elementIdx).toTypeFlags, Flags.validClassTypeParamFlags)
             val symbol = dotc.core.Symbols.newSymbol(cls, name.toTypeName, Flags.Param | Flags.Deferred | Flags.Private | Flags.PrivateLocal | Flags.Local | conParamFlags(clauseIdx)(elementIdx), tpe, conParamPrivateWithins(clauseIdx)(elementIdx))
             paramRefMap.addOne(elementIdx, symbol)
             cls.enter(symbol)
           else
-            checkValidFlags(conParamFlags(clauseIdx)(elementIdx), Flags.validClassTermParamFlags)
+            checkValidFlags(conParamFlags(clauseIdx)(elementIdx).toTermFlags, Flags.validClassTermParamFlags)
             val fixedType = paramRefRemapper(tpe)
             cls.enter(dotc.core.Symbols.newSymbol(cls, name.toTermName, Flags.ParamAccessor | conParamFlags(clauseIdx)(elementIdx), fixedType, conParamPrivateWithins(clauseIdx)(elementIdx)))
         for sym <- decls(cls) do cls.enter(sym)

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

@@ -3812,6 +3812,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       def classSymbol(fullName: String): Symbol
 
       /** Generates a new class symbol for a class with a public parameterless constructor.
+       *  For more settings, look to the other newClass methods.
        *
        *  Example usage:
        *  ```
@@ -3856,13 +3857,41 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
 
       /** Generates a new class symbol for a class with a public single term clause constructor.
        *
-       * @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.
-       * Takes the constructed class symbol as an argument. Calling `cls.typeRef.asType` as part of this function will lead to cyclic reference errors.
-       * @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 conParams constructor parameter pairs of names and types.
+       *  Example usage:
+       *  ```
+       *  val name = nameExpr.valueOrAbort
+       *  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,
+       *    clsFlags = Flags.EmptyFlags,
+       *    Symbol.noSymbol,
+       *    List(("idx", TypeRepr.of[Int]), ("str", TypeRepr.of[String]))
+       *  )
+       *
+       *  val fooSym = cls.declaredMethod("foo").head
+       *  val idxSym = cls.fieldMember("idx")
+       *  val strSym = cls.fieldMember("str")
+       *  val fooDef = DefDef(fooSym, argss =>
+       *    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))
+       *
+       *  Block(List(clsDef), Apply(Select(newCls, cls.methodMember("foo")(0)), Nil)).asExprOf[Unit]
+       *  ```
+       *  @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.
+       *  Takes the constructed class symbol as an argument. Calling `cls.typeRef.asType` as part of this function will lead to cyclic reference errors.
+       *  @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 conParams constructor parameter pairs of names and types.
        *
        *  Parameters assigned by the constructor can be obtained via `classSymbol.memberField`.
        *  This symbol starts without an accompanying definition.
@@ -3893,7 +3922,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
        *  val conMethodType =
        *    (classType: TypeRepr) => PolyType(List("T"))(_ => List(TypeBounds.empty), polyType =>
        *      MethodType(List("param"))((_: MethodType) => List(polyType.param(0)), (_: MethodType) =>
-       *        classType
+       *        AppliedType(classType, List(polyType.param(0)))
        *      )
        *    )
        *  val cls = Symbol.newClass(
@@ -3955,7 +3984,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
        * @param clsPrivateWithin the symbol within which this new class symbol should be private. May be noSymbol
        * @param clsAnnotations annotations of the class
        * @param conMethodType Function returning MethodOrPoly type representing the type of the constructor.
-       * Takes the result type as parameter which must be returned from the innermost MethodOrPoly.
+       * Takes the result type as parameter which must be returned from the innermost MethodOrPoly and have type parameters applied if those are used.
        * PolyType may only represent the first clause of the constructor.
        * @param conFlags extra flags with which the constructor symbol should be constructed. Can be `Synthetic` | `Method` | `Private` | `Protected` | `PrivateLocal` | `Local`
        * @param conPrivateWithin the symbol within which the constructor for this new class symbol should be private. May be noSymbol.

Diff for: tests/run-macros/newClassParams/Macro_1.scala

@@ -8,11 +8,26 @@ private def makeClassAndCallExpr(nameExpr: Expr[String], idxExpr: Expr[Int], str
 
   val name = nameExpr.valueOrAbort
 
-  def decls(cls: Symbol): List[Symbol] = List(Symbol.newMethod(cls, "foo", MethodType(Nil)(_ => Nil, _ => TypeRepr.of[Unit])))
+  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, Flags.EmptyFlags, Symbol.noSymbol, List(("idx", TypeRepr.of[Int]), ("str", TypeRepr.of[String])))
+  val cls = Symbol.newClass(
+    Symbol.spliceOwner,
+    name,
+    parents = _ => parents.map(_.tpe),
+    decls,
+    selfType = None,
+    clsFlags = Flags.EmptyFlags,
+    Symbol.noSymbol,
+    List(("idx", TypeRepr.of[Int]), ("str", 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 fooSym = cls.declaredMethod("foo").head
+  val idxSym = cls.fieldMember("idx")
+  val strSym = cls.fieldMember("str")
+  val fooDef = DefDef(fooSym, argss =>
+    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))
 

Diff for: tests/run-macros/newClassTraitAndAbstract/Macro_1.scala

@@ -33,7 +33,9 @@ private def makeClassExpr(using Quotes)(
   val conMethodType =
     (classType: TypeRepr) => PolyType(List("A", "B"))(
       _ => List(TypeBounds.empty, TypeBounds.upper(TypeRepr.of[Int])),
-      polyType => MethodType(List("param1", "param2"))((_: MethodType) => List(polyType.param(0), polyType.param(1)), (_: MethodType) => classType)
+      polyType => MethodType(List("param1", "param2"))((_: MethodType) => List(polyType.param(0), polyType.param(1)), (_: MethodType) =>
+        AppliedType(classType, List(polyType.param(0), polyType.param(1)))
+      )
     )
 
   val traitSymbol = Symbol.newClass(

Diff for: tests/run-macros/newClassTypeParams/Macro_1.scala

@@ -11,7 +11,9 @@ private def makeClassExpr(nameExpr: Expr[String])(using Quotes): Expr[Any] = {
   val conMethodType =
     (classType: TypeRepr) => PolyType(List("A", "B"))(
       _ => List(TypeBounds.empty, TypeBounds.upper(TypeRepr.of[Int])),
-      polyType => MethodType(List("param1", "param2"))((_: MethodType) => List(polyType.param(0), polyType.param(1)), (_: MethodType) => classType)
+      polyType => MethodType(List("param1", "param2"))((_: MethodType) => List(polyType.param(0), polyType.param(1)), (_: MethodType) =>
+        AppliedType(classType, List(polyType.param(0), polyType.param(1)))
+      )
     )
 
   val cls = Symbol.newClass(