diff --git a/compiler/src/dotty/tools/dotc/core/Symbols.scala b/compiler/src/dotty/tools/dotc/core/Symbols.scala index 7de75e371752..379e2e5fbe0b 100644 --- a/compiler/src/dotty/tools/dotc/core/Symbols.scala +++ b/compiler/src/dotty/tools/dotc/core/Symbols.scala @@ -629,6 +629,32 @@ object Symbols extends SymUtils { newClassSymbol(owner, name, flags, completer, privateWithin, coord, compUnitInfo) } + /** 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 newNormalizedClassSymbol( + owner: Symbol, + name: TypeName, + flags: FlagSet, + parentTypes: Symbol => List[Type], + 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 + val decls = newScope + 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, decls, selfInfo) + denot.annotations = annotations.map(Annotations.Annotation(_)) + } + } + newClassSymbol(owner, name, flags, completer, privateWithin, coord, compUnitInfo) + } + def newRefinedClassSymbol(coord: Coord = NoCoord)(using Context): ClassSymbol = newCompleteClassSymbol(ctx.owner, tpnme.REFINE_CLASS, NonMember, parents = Nil, newScope, coord = coord) @@ -706,6 +732,34 @@ object Symbols extends SymUtils { privateWithin, coord, compUnitInfo) } + /** 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 newNormalizedModuleSymbol( + owner: Symbol, + name: TermName, + modFlags: FlagSet, + clsFlags: FlagSet, + parentTypes: ClassSymbol => List[Type], + decls: Scope, + 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).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, decls, TermRef(owner.thisType, module)) + } + } + newModuleSymbol( + owner, name, modFlags, clsFlags, + (module, modcls) => completer(module), + privateWithin, coord, compUnitInfo) + } + /** Create a package symbol with associated package class * from its non-info fields and a lazy type for loading the package's members. */ diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala index c35dc80c04a5..90262bc5da85 100644 --- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala +++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala @@ -854,30 +854,34 @@ object TreeChecker { val phases = ctx.base.allPhases.toList val treeChecker = new LocalChecker(previousPhases(phases)) + def reportMalformedMacroTree(msg: String | Null, err: Throwable) = + val stack = + if !ctx.settings.Ydebug.value then "\nstacktrace available when compiling with `-Ydebug`" + else if err.getStackTrace == null then " no stacktrace" + else err.getStackTrace.nn.mkString(" ", " \n", "") + report.error( + em"""Malformed tree was found while expanding macro with -Xcheck-macros. + |The tree does not conform to the compiler's tree invariants. + | + |Macro was: + |${scala.quoted.runtime.impl.QuotesImpl.showDecompiledTree(original)} + | + |The macro returned: + |${scala.quoted.runtime.impl.QuotesImpl.showDecompiledTree(expansion)} + | + |Error: + |$msg + |$stack + |""", + original + ) + try treeChecker.typed(expansion)(using checkingCtx) catch case err: java.lang.AssertionError => - val stack = - if !ctx.settings.Ydebug.value then "\nstacktrace available when compiling with `-Ydebug`" - else if err.getStackTrace == null then " no stacktrace" - else err.getStackTrace.nn.mkString(" ", " \n", "") - - report.error( - em"""Malformed tree was found while expanding macro with -Xcheck-macros. - |The tree does not conform to the compiler's tree invariants. - | - |Macro was: - |${scala.quoted.runtime.impl.QuotesImpl.showDecompiledTree(original)} - | - |The macro returned: - |${scala.quoted.runtime.impl.QuotesImpl.showDecompiledTree(expansion)} - | - |Error: - |${err.getMessage} - |$stack - |""", - original - ) + reportMalformedMacroTree(err.getMessage(), err) + case err: UnhandledError => + reportMalformedMacroTree(err.diagnostic.message, err) private[TreeChecker] def previousPhases(phases: List[Phase])(using Context): List[Phase] = phases match { case (phase: MegaPhase) :: phases1 => diff --git a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala index 28af86344621..4d16a342f484 100644 --- a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala +++ b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala @@ -12,6 +12,7 @@ import collection.mutable import reporting.* import Checking.{checkNoPrivateLeaks, checkNoWildcard} import cc.CaptureSet +import transform.Splicer trait TypeAssigner { import tpd.* @@ -301,7 +302,10 @@ trait TypeAssigner { if fntpe.isResultDependent then safeSubstMethodParams(fntpe, args.tpes) else fntpe.resultType // fast path optimization else - errorType(em"wrong number of arguments at ${ctx.phase.prev} for $fntpe: ${fn.tpe}, expected: ${fntpe.paramInfos.length}, found: ${args.length}", tree.srcPos) + val erroringPhase = + if Splicer.inMacroExpansion then i"${ctx.phase} (while expanding macro)" + else ctx.phase.prev.toString + errorType(em"wrong number of arguments at $erroringPhase for $fntpe: ${fn.tpe}, expected: ${fntpe.paramInfos.length}, found: ${args.length}", tree.srcPos) case err: ErrorType => err case t => diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala index 0965a1174500..06d3ccd8f792 100644 --- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala +++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala @@ -25,6 +25,8 @@ import scala.quoted.runtime.impl.printers.* 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 { @@ -241,9 +243,35 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler object ClassDef extends ClassDefModule: def apply(cls: Symbol, parents: List[Tree], body: List[Statement]): ClassDef = - val untpdCtr = untpd.DefDef(nme.CONSTRUCTOR, Nil, tpd.TypeTree(dotc.core.Symbols.defn.UnitClass.typeRef), tpd.EmptyTree) + val paramsDefs: List[untpd.ParamClause] = + cls.primaryConstructor.paramSymss.map { paramSym => + if paramSym.headOption.map(_.isType).getOrElse(false) then + paramSym.map(sym => TypeDef(sym)) + 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 => + def isParamAccessor(memberSym: Symbol) = memberSym.flags.is(Flags.Param) && memberSym.name == symm.name + TypeDef(cls.typeMembers.find(isParamAccessor).getOrElse(throwError())) + } + else + paramSym.map { symm => + def isParam(memberSym: Symbol) = memberSym.flags.is(Flags.ParamAccessor) && memberSym.name == symm.name + ValDef(cls.fieldMembers.find(isParam).getOrElse(throwError()), None) + } + } + + val termSymbol: dotc.core.Symbols.TermSymbol = cls.primaryConstructor.asTerm + val untpdCtr = untpd.DefDef(nme.CONSTRUCTOR, paramsDefs, tpd.TypeTree(dotc.core.Symbols.defn.UnitClass.typeRef), tpd.EmptyTree) val ctr = ctx.typeAssigner.assignType(untpdCtr, cls.primaryConstructor) - tpd.ClassDefWithParents(cls.asClass, ctr, parents, body) + tpd.ClassDefWithParents(cls.asClass, ctr, parents, paramsAccessDefs.flatten ++ 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: @unchecked @@ -2655,8 +2683,134 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler for sym <- decls(cls) do cls.enter(sym) cls - def newModule(owner: Symbol, name: String, modFlags: Flags, clsFlags: Flags, parents: 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") + def newClass( + owner: Symbol, + name: String, + parents: Symbol => List[TypeRepr], + decls: Symbol => List[Symbol], + selfType: Option[TypeRepr], + clsFlags: Flags, + clsPrivateWithin: Symbol, + conParams: List[(String, TypeRepr)] + ): Symbol = + val (conParamNames, conParamTypes) = conParams.unzip + newClass( + owner, + name, + parents, + decls, + selfType, + clsFlags, + clsPrivateWithin, + Nil, + conMethodType = res => MethodType(conParamNames)(_ => conParamTypes, _ => res), + conFlags = Flags.EmptyFlags, + conPrivateWithin = Symbol.noSymbol, + conParamFlags = List(for i <- conParamNames yield Flags.EmptyFlags), + conParamPrivateWithins = List(for i <- conParamNames yield Symbol.noSymbol) + ) + + def newClass( + owner: Symbol, + name: String, + parents: Symbol => List[TypeRepr], + decls: Symbol => List[Symbol], + selfType: Option[TypeRepr], + clsFlags: Flags, + clsPrivateWithin: Symbol, + clsAnnotations: List[Term], + conMethodType: TypeRepr => MethodOrPoly, + conFlags: Flags, + conPrivateWithin: Symbol, + conParamFlags: List[List[Flags]], + conParamPrivateWithins: List[List[Symbol]] + ) = + 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.toTermFlags, Flags.validClassConstructorFlags) + val cls = dotc.core.Symbols.newNormalizedClassSymbol( + owner, + name.toTypeName, + clsFlags, + parents, + selfType.getOrElse(Types.NoType), + clsPrivateWithin, + clsAnnotations, + NoCoord, + compUnitInfo = null + ) + 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 (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 (conParamFlags.length <= clauseIdx) throwShapeException() + if (conParamFlags(clauseIdx).length != params.length) throwShapeException() + checkMethodOrPolyShape(res, clauseIdx + 1) + 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)) + + 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).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).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 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 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).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) + cls + + 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.newNormalizedModuleSymbol( owner, @@ -2665,7 +2819,10 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler 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) @@ -3063,6 +3220,18 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler // Keep: aligned with Quotes's `newTypeAlias` doc private[QuotesImpl] def validTypeAliasFlags: Flags = Private | Protected | Override | Final | Infix | Local + // Keep: aligned with Quotes's `newClass` + private[QuotesImpl] def validClassFlags: Flags = Private | Protected | PrivateLocal | Local | Final | Trait | Abstract | Open + + // Keep: aligned with Quote's 'newClass' + private[QuotesImpl] def validClassConstructorFlags: Flags = Synthetic | Method | Private | Protected | PrivateLocal | Local + + // Keep: aligned with Quotes's `newClass` + private[QuotesImpl] def validClassTypeParamFlags: Flags = Param | Deferred | Private | PrivateLocal | Local + + // Keep: aligned with Quotes's `newClass` + private[QuotesImpl] def validClassTermParamFlags: Flags = ParamAccessor | Private | Protected | PrivateLocal | Local + end Flags given FlagsMethods: FlagsMethods with diff --git a/compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala b/compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala index 64a0ff9db9ec..7c7a688eccb2 100644 --- a/compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala +++ b/compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala @@ -1379,13 +1379,13 @@ object SourceCode { printTypeTree(bounds.low) else bounds.low match { - case Inferred() => + case Inferred() if bounds.low.tpe.typeSymbol == TypeRepr.of[Nothing].typeSymbol => case low => this += " >: " printTypeTree(low) } bounds.hi match { - case Inferred() => this + case Inferred() if bounds.hi.tpe.typeSymbol == TypeRepr.of[Any].typeSymbol => this case hi => this += " <: " printTypeTree(hi) diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala index 5ada585c23a1..e0c06d006a76 100644 --- a/library/src/scala/quoted/Quotes.scala +++ b/library/src/scala/quoted/Quotes.scala @@ -3811,7 +3811,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** The class Symbol of a global class definition */ def classSymbol(fullName: String): Symbol - /** Generates a new class symbol for a class with a parameterless constructor. + /** Generates a new class symbol for a class with a public parameterless constructor. + * For more settings, look to the other newClass methods. * * Example usage: * ``` @@ -3839,7 +3840,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * } * ``` * - * @param parent The owner of the class + * @param owner The owner of the class * @param name The name of the class * @param parents The parent classes of the class. The first parent must not be a trait. * @param decls The member declarations of the class provided the symbol of this class @@ -3852,8 +3853,181 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * @note As a macro can only splice code into the point at which it is expanded, all generated symbols must be * direct or indirect children of the reflection context's owner. */ - // TODO: add flags and privateWithin - @experimental def newClass(parent: Symbol, name: String, parents: List[TypeRepr], decls: Symbol => List[Symbol], selfType: Option[TypeRepr]): Symbol + @experimental def newClass(owner: Symbol, name: String, parents: List[TypeRepr], decls: Symbol => List[Symbol], selfType: Option[TypeRepr]): Symbol + + /** Generates a new class symbol for a class with a public single term clause constructor. + * + * Example usage: + * ``` + * 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]) + * 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('{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. + * 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. + * It is the meta-programmer's responsibility to provide exactly one corresponding definition by passing + * this symbol to the ClassDef constructor. + * + * @note As a macro can only splice code into the point at which it is expanded, all generated symbols must be + * direct or indirect children of the reflection context's owner. + */ + @experimental def newClass( + owner: Symbol, + name: String, + parents: Symbol => List[TypeRepr], + decls: Symbol => List[Symbol], + selfType: Option[TypeRepr], + clsFlags: Flags, + clsPrivateWithin: Symbol, + conParams: List[(String, TypeRepr)] + ): Symbol + + /** Generates a new class symbol with a constructor of the shape signified by a passed PolyOrMethod parameter. + * + * Example usage: + * ``` + * val name = "myClass" + * def decls(cls: Symbol): List[Symbol] = + * List(Symbol.newMethod(cls, "getParam", MethodType(Nil)(_ => Nil, _ => cls.typeMember("T").typeRef))) + * val conMethodType = + * (classType: TypeRepr) => PolyType(List("T"))(_ => List(TypeBounds.empty), polyType => + * MethodType(List("param"))((_: MethodType) => List(polyType.param(0)), (_: MethodType) => + * AppliedType(classType, List(polyType.param(0))) + * ) + * ) + * val cls = Symbol.newClass( + * Symbol.spliceOwner, + * name, + * parents = _ => List(TypeRepr.of[Object]), + * decls, + * selfType = None, + * clsFlags = Flags.EmptyFlags, + * clsPrivateWithin = Symbol.noSymbol, + * clsAnnotations = Nil, + * conMethodType, + * conFlags = Flags.EmptyFlags, + * conPrivateWithin = Symbol.noSymbol, + * conParamFlags = List(List(Flags.EmptyFlags), List(Flags.EmptyFlags)), + * conParamPrivateWithins = List(List(Symbol.noSymbol), List(Symbol.noSymbol)) + * ) + * + * val getParamSym = cls.declaredMethod("getParam").head + * def getParamRhs(): Option[Term] = + * val paramValue = This(cls).select(cls.fieldMember("param")).asExpr + * Some('{ println("Calling getParam"); $paramValue }.asTerm) + * val getParamDef = DefDef(getParamSym, _ => getParamRhs()) + * + * val clsDef = ClassDef(cls, List(TypeTree.of[Object]), body = List(getParamDef)) + * val newCls = + * Apply( + * Select( + * Apply( + * TypeApply(Select(New(TypeIdent(cls)), cls.primaryConstructor), List(TypeTree.of[String])), + * List(Expr("test").asTerm) + * ), + * cls.methodMember("getParam").head + * ), + * Nil + * ) + * + * Block(List(clsDef), newCls).asExpr + * ``` + * constructs the equivalent to + * ``` + * '{ + * class myClass[T](val param: T) extends Object { + * def getParam: T = + * println("Calling getParam") + * param + * } + * new myClass[String]("test").getParam() + * } + * ``` + * + * @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 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 clsFlags extra flags with which the class symbol should be constructed. Can be `Private` | `Protected` | `PrivateLocal` | `Local` | `Final` | `Trait` | `Abstract` | `Open` + * @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 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. + * @param conParamFlags extra flags with which the constructor parameter symbols should be constructed. Must match the shape of `conMethodType`. + * For type parameters those can be `Param` | `Deferred` | `Private` | `PrivateLocal` | `Local`. + * For term parameters those can be `ParamAccessor` | `Private` | `Protected` | `PrivateLocal` | `Local` + * @param conParamPrivateWithins the symbols within which the constructor parameters should be private. Must match the shape of `conMethodType`. Can consist of noSymbol. + * + * Term and type parameters assigned by the constructor can be obtained via `classSymbol.memberField`/`classSymbol.memberType`. + * This symbol starts without an accompanying definition. + * It is the meta-programmer's responsibility to provide exactly one corresponding definition by passing + * this symbol to the ClassDef constructor. + * + * @note As a macro can only splice code into the point at which it is expanded, all generated symbols must be + * direct or indirect children of the reflection context's owner. + */ + // Keep doc aligned with QuotesImpl's validFlags: `clsFlags` with `validClassFlags`, `conFlags` with `validClassConstructorFlags`, + // conParamFlags with `validClassTypeParamFlags` and `validClassTermParamFlags` + @experimental def newClass( + owner: Symbol, + name: String, + parents: Symbol => List[TypeRepr], + decls: Symbol => List[Symbol], + selfType: Option[TypeRepr], + clsFlags: Flags, + clsPrivateWithin: Symbol, + clsAnnotations: List[Term], + conMethodType: TypeRepr => MethodOrPoly, + conFlags: Flags, + conPrivateWithin: Symbol, + conParamFlags: List[List[Flags]], + conParamPrivateWithins: List[List[Symbol]] + ): Symbol /** Generates a new module symbol with an associated module class symbol, * this is equivalent to an `object` declaration in source code. @@ -3870,7 +4044,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * def decls(cls: Symbol): List[Symbol] = * List(Symbol.newMethod(cls, "run", MethodType(Nil)(_ => Nil, _ => TypeRepr.of[Unit]), Flags.EmptyFlags, Symbol.noSymbol)) * - * val mod = Symbol.newModule(Symbol.spliceOwner, moduleName, Flags.EmptyFlags, Flags.EmptyFlags, parents.map(_.tpe), decls, Symbol.noSymbol) + * val mod = Symbol.newModule(Symbol.spliceOwner, moduleName, Flags.EmptyFlags, Flags.EmptyFlags, _ => parents.map(_.tpe), decls, Symbol.noSymbol) * val cls = mod.moduleClass * val runSym = cls.declaredMethod("run").head * @@ -3898,7 +4072,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * @param name The name of the class * @param modFlags extra flags with which the module symbol should be constructed * @param clsFlags extra flags with which the module class symbol should be constructed - * @param parents The parent classes of the class. The first parent must not be a trait. + * @param parents A function that takes the symbol of the module class as input and returns the parent classes of the class. The first parent must not be a trait. * @param decls A function that takes the symbol of the module class as input and return the symbols of its declared members * @param privateWithin the symbol within which this new method symbol should be private. May be noSymbol. * @@ -3911,7 +4085,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * * @syntax markdown */ - @experimental def newModule(owner: Symbol, name: String, modFlags: Flags, clsFlags: Flags, parents: List[TypeRepr], decls: Symbol => List[Symbol], privateWithin: Symbol): Symbol + @experimental def newModule(owner: Symbol, name: String, modFlags: Flags, clsFlags: Flags, parents: Symbol => List[TypeRepr], decls: Symbol => List[Symbol], privateWithin: Symbol): Symbol /** Generates a new method symbol with the given parent, name and type. * diff --git a/tests/neg-macros/i19842-a.check b/tests/neg-macros/i19842-a.check index 30b295cd05a5..af628c566c15 100644 --- a/tests/neg-macros/i19842-a.check +++ b/tests/neg-macros/i19842-a.check @@ -9,8 +9,8 @@ | | at scala.runtime.Scala3RunTime$.assertFailed(Scala3RunTime.scala:8) | at dotty.tools.dotc.transform.TreeChecker$.checkParents(TreeChecker.scala:210) - | at scala.quoted.runtime.impl.QuotesImpl$reflect$ClassDef$.module(QuotesImpl.scala:257) - | at scala.quoted.runtime.impl.QuotesImpl$reflect$ClassDef$.module(QuotesImpl.scala:256) + | at scala.quoted.runtime.impl.QuotesImpl$reflect$ClassDef$.module(QuotesImpl.scala:285) + | at scala.quoted.runtime.impl.QuotesImpl$reflect$ClassDef$.module(QuotesImpl.scala:284) | at Macros$.makeSerializer(Macro.scala:25) | |--------------------------------------------------------------------------------------------------------------------- diff --git a/tests/neg-macros/i19842-a/Macro.scala b/tests/neg-macros/i19842-a/Macro.scala index 18a1bc16045f..14b7c3f24a1a 100644 --- a/tests/neg-macros/i19842-a/Macro.scala +++ b/tests/neg-macros/i19842-a/Macro.scala @@ -16,7 +16,7 @@ object Macros { name, Flags.Implicit, Flags.EmptyFlags, - List(TypeRepr.of[Object], TypeRepr.of[Serializer[T]]), + _ => List(TypeRepr.of[Object], TypeRepr.of[Serializer[T]]), _ => Nil, Symbol.noSymbol ) diff --git a/tests/neg-macros/i19842-b.check b/tests/neg-macros/i19842-b.check index d84d916acb66..b402006c2d4b 100644 --- a/tests/neg-macros/i19842-b.check +++ b/tests/neg-macros/i19842-b.check @@ -9,8 +9,8 @@ | | at scala.runtime.Scala3RunTime$.assertFailed(Scala3RunTime.scala:8) | at dotty.tools.dotc.transform.TreeChecker$.checkParents(TreeChecker.scala:210) - | at scala.quoted.runtime.impl.QuotesImpl$reflect$ClassDef$.module(QuotesImpl.scala:257) - | at scala.quoted.runtime.impl.QuotesImpl$reflect$ClassDef$.module(QuotesImpl.scala:256) + | at scala.quoted.runtime.impl.QuotesImpl$reflect$ClassDef$.module(QuotesImpl.scala:285) + | at scala.quoted.runtime.impl.QuotesImpl$reflect$ClassDef$.module(QuotesImpl.scala:284) | at Macros$.makeSerializer(Macro.scala:27) | |--------------------------------------------------------------------------------------------------------------------- diff --git a/tests/neg-macros/i19842-b/Macro.scala b/tests/neg-macros/i19842-b/Macro.scala index f1399d328f49..8b43faab76dd 100644 --- a/tests/neg-macros/i19842-b/Macro.scala +++ b/tests/neg-macros/i19842-b/Macro.scala @@ -18,7 +18,7 @@ object Macros { name, Flags.Implicit, Flags.EmptyFlags, - List(TypeRepr.of[Object], TypeRepr.of[Serializer[T]]), + _ => List(TypeRepr.of[Object], TypeRepr.of[Serializer[T]]), _ => Nil, Symbol.noSymbol ) diff --git a/tests/neg-macros/newClassParamsMissingArgument.check b/tests/neg-macros/newClassParamsMissingArgument.check new file mode 100644 index 000000000000..2a6b53bd2d79 --- /dev/null +++ b/tests/neg-macros/newClassParamsMissingArgument.check @@ -0,0 +1,32 @@ + +-- Error: tests/neg-macros/newClassParamsMissingArgument/Test_2.scala:4:2 ---------------------------------------------- +4 | makeClass("foo") // error // error + | ^^^^^^^^^^^^^^^^ + |wrong number of arguments at inlining (while expanding macro) for (idx: Int): foo: (foo# : (idx: Int): foo), expected: 1, found: 0 +-- Error: tests/neg-macros/newClassParamsMissingArgument/Test_2.scala:4:11 --------------------------------------------- +4 | makeClass("foo") // error // error + | ^^^^^^^^^^^^^^^^ + |Malformed tree was found while expanding macro with -Xcheck-macros. + |The tree does not conform to the compiler's tree invariants. + | + |Macro was: + |scala.quoted.runtime.Expr.splice[java.lang.Object](((contextual$1: scala.quoted.Quotes) ?=> Macro_1$package.inline$makeClassExpr(scala.quoted.runtime.Expr.quote[scala.Predef.String]("foo").apply(using contextual$1))(contextual$1))) + | + |The macro returned: + |{ + | class foo(val idx: scala.Int) extends java.lang.Object + | + | (new foo(): java.lang.Object) + |} + | + |Error: + |missing argument for parameter idx of constructor foo in class foo: (idx: Int): foo + | + |stacktrace available when compiling with `-Ydebug` + |--------------------------------------------------------------------------------------------------------------------- + |Inline stack trace + |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + |This location contains code that was inlined from Macro_1.scala:5 +5 |inline def makeClass(inline name: String): Object = ${ makeClassExpr('name) } + | ^^^^^^^^^^^^^^^^^^^^^^^^^ + --------------------------------------------------------------------------------------------------------------------- diff --git a/tests/neg-macros/newClassParamsMissingArgument/Macro_1.scala b/tests/neg-macros/newClassParamsMissingArgument/Macro_1.scala new file mode 100644 index 000000000000..a0ee5a899e62 --- /dev/null +++ b/tests/neg-macros/newClassParamsMissingArgument/Macro_1.scala @@ -0,0 +1,24 @@ +//> using options -experimental + +import scala.quoted._ + +inline def makeClass(inline name: String): Object = ${ makeClassExpr('name) } +private def makeClassExpr(nameExpr: Expr[String])(using Quotes): Expr[Object] = { + import quotes.reflect.* + + val name = nameExpr.valueOrAbort + 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, Flags.EmptyFlags, Symbol.noSymbol, List(("idx", TypeRepr.of[Int]))) + + val clsDef = ClassDef(cls, parents, body = Nil) + val newCls = Typed(Apply(Select(New(TypeIdent(cls)), cls.primaryConstructor), Nil), TypeTree.of[Object]) + + Block(List(clsDef), newCls).asExprOf[Object] + + // '{ + // class `name`(idx: Int) + // new `name` + // } +} diff --git a/tests/neg-macros/newClassParamsMissingArgument/Test_2.scala b/tests/neg-macros/newClassParamsMissingArgument/Test_2.scala new file mode 100644 index 000000000000..8d7142f7bd72 --- /dev/null +++ b/tests/neg-macros/newClassParamsMissingArgument/Test_2.scala @@ -0,0 +1,5 @@ +//> using options -experimental + +@main def Test: Unit = { + makeClass("foo") // error // error +} diff --git a/tests/pos-macros/newClassExtendsWithSymbolInParent/Macro_1.scala b/tests/pos-macros/newClassExtendsWithSymbolInParent/Macro_1.scala new file mode 100644 index 000000000000..569d8e0c25be --- /dev/null +++ b/tests/pos-macros/newClassExtendsWithSymbolInParent/Macro_1.scala @@ -0,0 +1,40 @@ +//> using options -experimental + +import scala.quoted.* + +transparent inline def makeClass(inline name: String): Foo[_] = ${ makeClassExpr('name) } +private def makeClassExpr(nameExpr: Expr[String])(using Quotes): Expr[Foo[_]] = { + import quotes.reflect.* + + val name = nameExpr.valueOrAbort + + // using asType on the passed Symbol leads to cyclic reference errors + def parents(cls: Symbol) = + 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, Flags.EmptyFlags, Symbol.noSymbol, conParams = Nil) + + val parentsWithSym = + cls.typeRef.asType match + case '[t] => + List(Apply(TypeApply(Select(New(TypeTree.of[Foo[t]]), TypeRepr.of[Foo[t]].typeSymbol.primaryConstructor), List(TypeTree.of[t])), List())) + val clsDef = ClassDef(cls, parentsWithSym, body = Nil) + + val newCls = cls.typeRef.asType match + case '[t] => + Typed(Apply(Select(New(TypeIdent(cls)), cls.primaryConstructor), Nil), TypeTree.of[Foo[t]]) + + cls.typeRef.asType match + case '[t] => + Block(List(clsDef), newCls).asExprOf[Foo[t]] + + // '{ + // class Name() extends Foo[Name.type]() + // new Name() + // } +} + +class Foo[X]() { self: X => + def getSelf: X = self +} diff --git a/tests/pos-macros/newClassExtendsWithSymbolInParent/Test_2.scala b/tests/pos-macros/newClassExtendsWithSymbolInParent/Test_2.scala new file mode 100644 index 000000000000..bb48bfadd96b --- /dev/null +++ b/tests/pos-macros/newClassExtendsWithSymbolInParent/Test_2.scala @@ -0,0 +1,6 @@ +//> using options -experimental + +@main def Test: Unit = { + val foo = makeClass("Bar") + foo.getSelf +} diff --git a/tests/run-macros/annot-add-global-object/Macro_1.scala b/tests/run-macros/annot-add-global-object/Macro_1.scala index 031d6e33fefe..b928cf23c2e8 100644 --- a/tests/run-macros/annot-add-global-object/Macro_1.scala +++ b/tests/run-macros/annot-add-global-object/Macro_1.scala @@ -14,7 +14,7 @@ class addClass extends MacroAnnotation: def decls(cls: Symbol): List[Symbol] = List(Symbol.newMethod(cls, "run", MethodType(Nil)(_ => Nil, _ => TypeRepr.of[Unit]), Flags.EmptyFlags, Symbol.noSymbol)) - val mod = Symbol.newModule(Symbol.spliceOwner, Symbol.freshName("Bar"), Flags.EmptyFlags, Flags.EmptyFlags, parents.map(_.tpe), decls, Symbol.noSymbol) + val mod = Symbol.newModule(Symbol.spliceOwner, Symbol.freshName("Bar"), Flags.EmptyFlags, Flags.EmptyFlags, _ => parents.map(_.tpe), decls, Symbol.noSymbol) val cls = mod.moduleClass val runSym = cls.declaredMethod("run").head diff --git a/tests/run-macros/annot-add-local-object/Macro_1.scala b/tests/run-macros/annot-add-local-object/Macro_1.scala index 3d47fafd599a..bbdfbfd287d4 100644 --- a/tests/run-macros/annot-add-local-object/Macro_1.scala +++ b/tests/run-macros/annot-add-local-object/Macro_1.scala @@ -14,7 +14,7 @@ class addClass extends MacroAnnotation: def decls(cls: Symbol): List[Symbol] = List(Symbol.newMethod(cls, "run", MethodType(Nil)(_ => Nil, _ => TypeRepr.of[Unit]), Flags.EmptyFlags, Symbol.noSymbol)) - val mod = Symbol.newModule(Symbol.spliceOwner, "Baz", Flags.EmptyFlags, Flags.EmptyFlags, parents.map(_.tpe), decls, Symbol.noSymbol) + val mod = Symbol.newModule(Symbol.spliceOwner, "Baz", Flags.EmptyFlags, Flags.EmptyFlags, _ => parents.map(_.tpe), decls, Symbol.noSymbol) val cls = mod.moduleClass val runSym = cls.declaredMethod("run").head diff --git a/tests/run-macros/annot-add-nested-object/Macro_1.scala b/tests/run-macros/annot-add-nested-object/Macro_1.scala index ce6cbaa67a57..cfc4691e95c9 100644 --- a/tests/run-macros/annot-add-nested-object/Macro_1.scala +++ b/tests/run-macros/annot-add-nested-object/Macro_1.scala @@ -14,7 +14,7 @@ class addClass extends MacroAnnotation: def decls(cls: Symbol): List[Symbol] = List(Symbol.newMethod(cls, "run", MethodType(Nil)(_ => Nil, _ => TypeRepr.of[Unit]), Flags.EmptyFlags, Symbol.noSymbol)) - val mod = Symbol.newModule(Symbol.spliceOwner, Symbol.freshName("Bar"), Flags.EmptyFlags, Flags.EmptyFlags, parents.map(_.tpe), decls, Symbol.noSymbol) + val mod = Symbol.newModule(Symbol.spliceOwner, Symbol.freshName("Bar"), Flags.EmptyFlags, Flags.EmptyFlags, _ => parents.map(_.tpe), decls, Symbol.noSymbol) val cls = mod.moduleClass val runSym = cls.declaredMethod("run").head diff --git a/tests/run-macros/newClassAnnotation.check b/tests/run-macros/newClassAnnotation.check new file mode 100644 index 000000000000..433c40f72180 --- /dev/null +++ b/tests/run-macros/newClassAnnotation.check @@ -0,0 +1,7 @@ +{ + @JavaAnnot("string in a java annotation") @ScalaAnnotation("string in a scala annotation") class name() extends java.lang.Object + + (new name(): scala.Any) +} +class Test_2$package$name$1 +string in a java annotation diff --git a/tests/run-macros/newClassAnnotation/JavaAnnot.java b/tests/run-macros/newClassAnnotation/JavaAnnot.java new file mode 100644 index 000000000000..2c815478c198 --- /dev/null +++ b/tests/run-macros/newClassAnnotation/JavaAnnot.java @@ -0,0 +1,5 @@ +import java.lang.annotation.*; +public @Retention(RetentionPolicy.RUNTIME) +@interface JavaAnnot { + public String value(); +} \ No newline at end of file diff --git a/tests/run-macros/newClassAnnotation/Macro_1.scala b/tests/run-macros/newClassAnnotation/Macro_1.scala new file mode 100644 index 000000000000..c7631317675b --- /dev/null +++ b/tests/run-macros/newClassAnnotation/Macro_1.scala @@ -0,0 +1,56 @@ +//> using options -experimental + +import scala.quoted.* +import scala.annotation.StaticAnnotation + +class ScalaAnnotation(value: String) extends StaticAnnotation + +inline def makeClass(inline name: String): Any = ${ makeClassExpr('name) } +private def makeClassExpr(nameExpr: Expr[String])(using Quotes): Expr[Any] = { + import quotes.reflect.* + + val name = nameExpr.valueOrAbort + def decls(cls: Symbol): List[Symbol] = Nil + val conMethodType = (classType: TypeRepr) => MethodType(Nil)((_: MethodType) => Nil, (_: MethodType) => classType) + + val javaAnnotSym = TypeRepr.of[JavaAnnot].typeSymbol + val scalaAnnotSym = TypeRepr.of[ScalaAnnotation].typeSymbol + + val javaAnnotationDef = Apply(Select(New(TypeIdent(javaAnnotSym)), javaAnnotSym.primaryConstructor), List(Literal(StringConstant("string in a java annotation")))) + val scalaAnnotationDef = Apply(Select(New(TypeIdent(scalaAnnotSym)), scalaAnnotSym.primaryConstructor), List(Literal(StringConstant("string in a scala annotation")))) + + val cls = Symbol.newClass( + Symbol.spliceOwner, + name, + parents = _ => List(TypeRepr.of[Object]), + decls, + selfType = None, + clsFlags = Flags.EmptyFlags, + clsPrivateWithin = Symbol.noSymbol, + clsAnnotations = List(javaAnnotationDef, scalaAnnotationDef), + conMethodType, + conFlags = Flags.EmptyFlags, + conPrivateWithin = Symbol.noSymbol, + conParamFlags = List(List()), + conParamPrivateWithins = List(List()) + ) + + val clsDef = ClassDef(cls, List(TypeTree.of[Object]), body = Nil) + val newCls = + Typed( + Apply( + Select(New(TypeIdent(cls)), cls.primaryConstructor), + Nil + ), + TypeTree.of[Any] + ) + + val res = Block(List(clsDef), newCls).asExpr + + Expr.ofTuple(res, Expr(res.show)) + + // { + // @JavaAnnot("string in a java annotation") @ScalaAnnotation("string in a scala annotation") class name() extends java.lang.Object + // (new name(): scala.Any) + // } +} diff --git a/tests/run-macros/newClassAnnotation/Test_2.scala b/tests/run-macros/newClassAnnotation/Test_2.scala new file mode 100644 index 000000000000..a824259eba09 --- /dev/null +++ b/tests/run-macros/newClassAnnotation/Test_2.scala @@ -0,0 +1,7 @@ +//> using options -experimental + +@main def Test = + val (cls, str) = makeClass("name") + println(str) + println(cls.getClass) + println(cls.getClass.getAnnotation(classOf[JavaAnnot]).value) diff --git a/tests/run-macros/newClassExtendsJavaClass.check b/tests/run-macros/newClassExtendsJavaClass.check new file mode 100644 index 000000000000..bd07b5536ebc --- /dev/null +++ b/tests/run-macros/newClassExtendsJavaClass.check @@ -0,0 +1,2 @@ +class Main_2$package$foo$1 +22 diff --git a/tests/run-macros/newClassExtendsJavaClass/JavaClass.java b/tests/run-macros/newClassExtendsJavaClass/JavaClass.java new file mode 100644 index 000000000000..8a02cf294a01 --- /dev/null +++ b/tests/run-macros/newClassExtendsJavaClass/JavaClass.java @@ -0,0 +1,9 @@ +class JavaClass { + T value; + public JavaClass(T value) { + this.value = value; + } + public T getT() { + return value; + } +} \ No newline at end of file diff --git a/tests/run-macros/newClassExtendsJavaClass/Macro_1.scala b/tests/run-macros/newClassExtendsJavaClass/Macro_1.scala new file mode 100644 index 000000000000..c342c78da796 --- /dev/null +++ b/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", 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) + // } +} \ No newline at end of file diff --git a/tests/run-macros/newClassExtendsJavaClass/Main_2.scala b/tests/run-macros/newClassExtendsJavaClass/Main_2.scala new file mode 100644 index 000000000000..b41c22427c8e --- /dev/null +++ b/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()) +} diff --git a/tests/run-macros/newClassParams.check b/tests/run-macros/newClassParams.check new file mode 100644 index 000000000000..314cd012f3e5 --- /dev/null +++ b/tests/run-macros/newClassParams.check @@ -0,0 +1 @@ +Foo method call with (10, test) diff --git a/tests/run-macros/newClassParams/Macro_1.scala b/tests/run-macros/newClassParams/Macro_1.scala new file mode 100644 index 000000000000..6ec48e24ebe3 --- /dev/null +++ b/tests/run-macros/newClassParams/Macro_1.scala @@ -0,0 +1,42 @@ +//> using options -experimental + +import scala.quoted._ + +inline def makeClassAndCall(inline name: String, idx: Int, str: String): Unit = ${ makeClassAndCallExpr('name, 'idx, 'str) } +private def makeClassAndCallExpr(nameExpr: Expr[String], idxExpr: Expr[Int], strExpr: Expr[String])(using Quotes): Expr[Unit] = { + import quotes.reflect.* + + 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] + + // '{ + // class `name`(idx: Int, str: String) { + // def foo() = println("Foo method call with ($idx, $str)") + // } + // new `name`(`idx`, `str`) + // } +} diff --git a/tests/run-macros/newClassParams/Test_2.scala b/tests/run-macros/newClassParams/Test_2.scala new file mode 100644 index 000000000000..64762f17b92f --- /dev/null +++ b/tests/run-macros/newClassParams/Test_2.scala @@ -0,0 +1,5 @@ +//> using options -experimental + +@main def Test: Unit = { + makeClassAndCall("bar", 10, "test") +} diff --git a/tests/run-macros/newClassParamsExtendsClassParams.check b/tests/run-macros/newClassParamsExtendsClassParams.check new file mode 100644 index 000000000000..86d844c7d00f --- /dev/null +++ b/tests/run-macros/newClassParamsExtendsClassParams.check @@ -0,0 +1,4 @@ +Calling Foo.foo with i = 22 +class Test_2$package$foo$1 +Calling Foo.foo with i = 22 +class Test_2$package$bar$1 diff --git a/tests/run-macros/newClassParamsExtendsClassParams/Macro_1.scala b/tests/run-macros/newClassParamsExtendsClassParams/Macro_1.scala new file mode 100644 index 000000000000..de35a4dfa206 --- /dev/null +++ b/tests/run-macros/newClassParamsExtendsClassParams/Macro_1.scala @@ -0,0 +1,29 @@ +//> using options -experimental + +import scala.quoted._ + +inline def makeClass(inline name: String): Foo = ${ makeClassExpr('name) } +private def makeClassExpr(nameExpr: Expr[String])(using Quotes): Expr[Foo] = { + import quotes.reflect.* + + val name = nameExpr.valueOrAbort + val parents = List('{ new Foo(1) }.asTerm) + 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", TypeRepr.of[Int]))) + + val parentsWithSym = List(Apply(Select(New(TypeTree.of[Foo]), TypeRepr.of[Foo].typeSymbol.primaryConstructor), 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[Foo]) + + Block(List(clsDef), newCls).asExprOf[Foo] + + // '{ + // class `name`(idx: Int) extends Foo(idx) + // new `name`(22) + // } +} + +class Foo(i: Int) { + def foo(): Unit = println(s"Calling Foo.foo with i = $i") +} diff --git a/tests/run-macros/newClassParamsExtendsClassParams/Test_2.scala b/tests/run-macros/newClassParamsExtendsClassParams/Test_2.scala new file mode 100644 index 000000000000..6e902825fdc6 --- /dev/null +++ b/tests/run-macros/newClassParamsExtendsClassParams/Test_2.scala @@ -0,0 +1,10 @@ +//> using options -experimental + +@main def Test: Unit = { + val foo: Foo = makeClass("foo") + foo.foo() + println(foo.getClass) + val bar: Foo = makeClass("bar") + bar.foo() + println(bar.getClass) +} diff --git a/tests/run-macros/newClassTraitAndAbstract.check b/tests/run-macros/newClassTraitAndAbstract.check new file mode 100644 index 000000000000..65e8c6435722 --- /dev/null +++ b/tests/run-macros/newClassTraitAndAbstract.check @@ -0,0 +1,14 @@ +class Test_2$package$anon$1 +{ + trait foo[A, B <: scala.Int](val param1: A, val param2: B) extends java.lang.Object + class anon() extends java.lang.Object with foo[java.lang.String, scala.Int]("a", 1) + + (new anon(): scala.Any) +} +class Test_2$package$anon$2 +{ + abstract class bar[A, B <: scala.Int](val param1: A, val param2: B) extends java.lang.Object + class anon() extends bar[java.lang.String, scala.Int]("a", 1) + + (new anon(): scala.Any) +} diff --git a/tests/run-macros/newClassTraitAndAbstract/Macro_1.scala b/tests/run-macros/newClassTraitAndAbstract/Macro_1.scala new file mode 100644 index 000000000000..56cd320085db --- /dev/null +++ b/tests/run-macros/newClassTraitAndAbstract/Macro_1.scala @@ -0,0 +1,99 @@ +//> using options -experimental + +import scala.quoted.* + +transparent inline def makeTrait(inline name: String): Any = ${ makeTraitExpr('name) } +transparent inline def makeAbstractClass(inline name: String): Any = ${ makeAbstractClassExpr('name) } + +private def makeTraitExpr(name: Expr[String])(using Quotes): Expr[Any] = { + makeClassExpr(name, quotes.reflect.Flags.Trait, List(quotes.reflect.TypeTree.of[Object])) + // '{ + // trait `name`[A, B <: Int](param1: A, param2: B) + // class anon() extends `name`[String, Int]("a", 1) + // new $anon() + // } +} + +private def makeAbstractClassExpr(name: Expr[String])(using Quotes): Expr[Any] = { + makeClassExpr(name, quotes.reflect.Flags.Abstract, Nil) + // '{ + // abstract class `name`[A, B <: Int](param1: A, param2: B) + // class anon() extends `name`[String, Int]("a", 1) + // new $anon() + // } +} + +private def makeClassExpr(using Quotes)( + nameExpr: Expr[String], clsFlags: quotes.reflect.Flags, childExtraParents: List[quotes.reflect.TypeTree] + ): Expr[Any] = { + import quotes.reflect.* + + val name = nameExpr.valueOrAbort + def decls(cls: Symbol): List[Symbol] = Nil + 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) => + AppliedType(classType, List(polyType.param(0), polyType.param(1))) + ) + ) + + val traitSymbol = Symbol.newClass( + Symbol.spliceOwner, + name, + parents = _ => List(TypeRepr.of[Object]), + decls, + selfType = None, + clsFlags, + clsPrivateWithin = Symbol.noSymbol, + clsAnnotations = Nil, + conMethodType, + conFlags = Flags.EmptyFlags, + conPrivateWithin = Symbol.noSymbol, + conParamFlags = List(List(Flags.EmptyFlags, Flags.EmptyFlags), List(Flags.EmptyFlags, Flags.EmptyFlags)), + conParamPrivateWithins = List(List(Symbol.noSymbol, Symbol.noSymbol), List(Symbol.noSymbol, Symbol.noSymbol)) + ) + val traitDef = ClassDef(traitSymbol, List(TypeTree.of[Object]), body = Nil) + + val traitTypeTree = Applied(TypeIdent(traitSymbol), List(TypeTree.of[String], TypeTree.of[Int])) + val clsSymbol = Symbol.newClass( + Symbol.spliceOwner, + "anon", + parents = _ => childExtraParents.map(_.tpe) ++ List(traitTypeTree.tpe), + decls = _ => Nil, + selfType = None, + clsFlags = Flags.EmptyFlags, + clsPrivateWithin = Symbol.noSymbol, + clsAnnotations = Nil, + conMethodType = (classType: TypeRepr) => MethodType(Nil)(_ => Nil, _ => classType), + conFlags = Flags.EmptyFlags, + conPrivateWithin = Symbol.noSymbol, + conParamFlags = List(List()), + conParamPrivateWithins = List(List(Symbol.noSymbol, Symbol.noSymbol), List(Symbol.noSymbol, Symbol.noSymbol)) + ) + val obj = '{new java.lang.Object()}.asTerm match + case Inlined(_, _, term) => term + + val parentsWithSym = childExtraParents ++ List( + Apply( + TypeApply( + Select(New(traitTypeTree), traitSymbol.primaryConstructor), + List(TypeTree.of[String], TypeTree.of[Int]) + ), + List(Expr("a").asTerm, Expr(1).asTerm) + ) + ) + val clsDef = ClassDef(clsSymbol, parentsWithSym, body = Nil) + + val newCls = + Typed( + Apply( + Select(New(TypeIdent(clsSymbol)), clsSymbol.primaryConstructor), + Nil + ), + TypeTree.of[Any] + ) + val res = Block(List(traitDef), Block(List(clsDef), newCls)).asExpr + + Expr.ofTuple(res, Expr(res.show)) +} diff --git a/tests/run-macros/newClassTraitAndAbstract/Test_2.scala b/tests/run-macros/newClassTraitAndAbstract/Test_2.scala new file mode 100644 index 000000000000..5b6512a49010 --- /dev/null +++ b/tests/run-macros/newClassTraitAndAbstract/Test_2.scala @@ -0,0 +1,11 @@ +//> using options -experimental + +@main def Test: Unit = { + val (cls1, show1) = makeTrait("foo") + println(cls1.getClass) + println(show1) + + val (cls2, show2) = makeAbstractClass("bar") + println(cls2.getClass) + println(show2) +} diff --git a/tests/run-macros/newClassTypeParams.check b/tests/run-macros/newClassTypeParams.check new file mode 100644 index 000000000000..8c400039681c --- /dev/null +++ b/tests/run-macros/newClassTypeParams.check @@ -0,0 +1,6 @@ +class Test_2$package$foo$1 +{ + class foo[A, B <: scala.Int](val param1: A, val param2: B) extends java.lang.Object + + (new foo[java.lang.String, scala.Int]("test", 1): scala.Any) +} diff --git a/tests/run-macros/newClassTypeParams/Macro_1.scala b/tests/run-macros/newClassTypeParams/Macro_1.scala new file mode 100644 index 000000000000..2efb31610c73 --- /dev/null +++ b/tests/run-macros/newClassTypeParams/Macro_1.scala @@ -0,0 +1,53 @@ +//> using options -experimental + +import scala.quoted.* + +transparent inline def makeClass(inline name: String): Any = ${ makeClassExpr('name) } +private def makeClassExpr(nameExpr: Expr[String])(using Quotes): Expr[Any] = { + import quotes.reflect.* + + val name = nameExpr.valueOrAbort + def decls(cls: Symbol): List[Symbol] = Nil + 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) => + AppliedType(classType, List(polyType.param(0), polyType.param(1))) + ) + ) + + val cls = Symbol.newClass( + Symbol.spliceOwner, + name, + parents = _ => List(TypeRepr.of[Object]), + decls, + selfType = None, + clsFlags = Flags.EmptyFlags, + clsPrivateWithin = Symbol.noSymbol, + clsAnnotations = Nil, + conMethodType, + conFlags = Flags.EmptyFlags, + conPrivateWithin = Symbol.noSymbol, + conParamFlags = List(List(Flags.EmptyFlags, Flags.EmptyFlags), List(Flags.EmptyFlags, Flags.EmptyFlags)), + conParamPrivateWithins = List(List(Symbol.noSymbol, Symbol.noSymbol), List(Symbol.noSymbol, Symbol.noSymbol)) + ) + + val clsDef = ClassDef(cls, List(TypeTree.of[Object]), body = Nil) + val newCls = + Typed( + Apply( + TypeApply(Select(New(TypeIdent(cls)), cls.primaryConstructor), List(TypeTree.of[String], TypeTree.of[Int])), + List(Expr("test").asTerm, Expr(1).asTerm) + ), + TypeTree.of[Any] + ) + + val res = Block(List(clsDef), newCls).asExpr + + Expr.ofTuple(res, Expr(res.show)) + + // '{ + // class `name`[A, B <: Int](param1: A, param2: B) + // new `name`[String, Int]("a", 1) + // } +} diff --git a/tests/run-macros/newClassTypeParams/Test_2.scala b/tests/run-macros/newClassTypeParams/Test_2.scala new file mode 100644 index 000000000000..742c0f480a77 --- /dev/null +++ b/tests/run-macros/newClassTypeParams/Test_2.scala @@ -0,0 +1,7 @@ +//> using options -experimental + +@main def Test: Unit = { + val (cls, show) = makeClass("foo") + println(cls.getClass) + println(show) +} diff --git a/tests/run-macros/newClassTypeParamsDoc.check b/tests/run-macros/newClassTypeParamsDoc.check new file mode 100644 index 000000000000..5d3b08bf509c --- /dev/null +++ b/tests/run-macros/newClassTypeParamsDoc.check @@ -0,0 +1,2 @@ +Calling getParam +test diff --git a/tests/run-macros/newClassTypeParamsDoc/Macro_1.scala b/tests/run-macros/newClassTypeParamsDoc/Macro_1.scala new file mode 100644 index 000000000000..9fb81e6f7348 --- /dev/null +++ b/tests/run-macros/newClassTypeParamsDoc/Macro_1.scala @@ -0,0 +1,67 @@ +//> using options -experimental + +import scala.quoted.* + +transparent inline def makeClass(): Any = ${ makeClassExpr } +private def makeClassExpr(using Quotes): Expr[Any] = { + import quotes.reflect.* + + val name = "myClass" + def decls(cls: Symbol): List[Symbol] = + List(Symbol.newMethod(cls, "getParam", MethodType(Nil)(_ => Nil, _ => cls.typeMember("T").typeRef))) + val conMethodType = + (classType: TypeRepr) => PolyType(List("T"))(_ => List(TypeBounds.empty), polyType => + MethodType(List("param"))((_: MethodType) => List(polyType.param(0)), (_: MethodType) => + AppliedType(classType, List(polyType.param(0))) + ) + ) + val cls = Symbol.newClass( + Symbol.spliceOwner, + name, + parents = _ => List(TypeRepr.of[Object]), + decls, + selfType = None, + clsFlags = Flags.EmptyFlags, + clsPrivateWithin = Symbol.noSymbol, + clsAnnotations = Nil, + conMethodType, + conFlags = Flags.EmptyFlags, + conPrivateWithin = Symbol.noSymbol, + conParamFlags = List(List(Flags.EmptyFlags), List(Flags.EmptyFlags)), + conParamPrivateWithins = List(List(Symbol.noSymbol), List(Symbol.noSymbol)) + ) + + val getParamSym = cls.declaredMethod("getParam").head + def getParamRhs(): Option[Term] = + val paramValue = This(cls).select(cls.fieldMember("param")).asExpr + Some('{ println("Calling getParam"); $paramValue }.asTerm) + val getParamDef = DefDef(getParamSym, _ => getParamRhs()) + + val clsDef = ClassDef(cls, List(TypeTree.of[Object]), body = List(getParamDef)) + val appliedTypeTree = Applied(TypeIdent(cls), List(TypeTree.of[String])) + val newCls = + Typed( + Apply( + Select( + Apply( + TypeApply(Select(New(appliedTypeTree), cls.primaryConstructor), List(TypeTree.of[String])), + List(Expr("test").asTerm) + ), + cls.methodMember("getParam").head + ), + Nil + ), + TypeTree.of[String] + ) + + Block(List(clsDef), newCls).asExpr + + // '{ + // class myClass[T](val param: T) { + // def getParam(): T = + // println("Calling getParam") + // param + // } + // new myClass[String]("test").getParam() + // } +} diff --git a/tests/run-macros/newClassTypeParamsDoc/Test_2.scala b/tests/run-macros/newClassTypeParamsDoc/Test_2.scala new file mode 100644 index 000000000000..318db32242fc --- /dev/null +++ b/tests/run-macros/newClassTypeParamsDoc/Test_2.scala @@ -0,0 +1,5 @@ +//> using options -experimental + +@main def Test: Unit = { + println(makeClass()) +}