The class Symbol of a global class definition
The class Symbol of a global class definition
AttributesGenerates a pattern bind symbol with the given parent, name and type.
Generates a pattern bind symbol with the given parent, name and type.
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 BindDef constructor.
Value parametersextra flags to with which the symbol should be constructed. Case flag will be added. Can be Case
The name of the binding
The owner of the binding
The type of the binding
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.
Generates a new method symbol with the given parent, name and type.
Generates a new method symbol with the given parent, name and type.
To define a member method of a class, use the newMethod within the decls function of newClass.
The name of the method
The owner of the method
The type of the method (MethodType, PolyType, ByNameType) 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 DefDef constructor.
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.
Works as the other newMethod, but with additional parameters.
Works as the other newMethod, but with additional parameters.
To define a member method of a class, use the newMethod within the decls function of newClass.
extra flags to with which the symbol should be constructed. Method flag will be added. Can be Private | Protected | Override | Deferred | Final | Method | Implicit | Given | Local | JavaStatic | Synthetic | Artifact
The name of the method
The owner of the method
the symbol within which this new method symbol should be private. May be noSymbol.
The type of the method (MethodType, PolyType, ByNameType)
Generates a new val/var/lazy val symbol with the given parent, name and type.
Generates a new val/var/lazy val symbol with the given parent, name and type.
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 ValDef constructor.
Note: Also see ValDef.let
Value parametersextra flags to with which the symbol should be constructed. Can be Private | Protected | Override | Deferred | Final | Param | Implicit | Lazy | Mutable | Local | ParamAccessor | Module | Package | Case | CaseAccessor | Given | Enum | JavaStatic | Synthetic | Artifact
The name of the val/var/lazy val
The owner of the val/var/lazy val
the symbol within which this new method symbol should be private. May be noSymbol.
The type of the val/var/lazy val
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.
Get class symbol if class is either defined in current compilation run or present on classpath.
Get class symbol if class is either defined in current compilation run or present on classpath.
AttributesGet method symbol if method is either defined in current compilation run or present on classpath. Throws if the method has an overload.
Get method symbol if method is either defined in current compilation run or present on classpath. Throws if the method has an overload.
AttributesGet module symbol if module is either defined in current compilation run or present on classpath.
Get module symbol if module is either defined in current compilation run or present on classpath.
AttributesGet package symbol if package is either defined in current compilation run or present on classpath.
Get package symbol if package is either defined in current compilation run or present on classpath.
AttributesSymbol of the definition that encloses the current splicing context.
Symbol of the definition that encloses the current splicing context.
For example, the following call to spliceOwner would return the symbol x.
val x = ${ ... Symbol.spliceOwner ... }
For a macro splice, it is the symbol of the definition where the macro expansion happens.
AttributesA fresh name for class or member symbol names.
A fresh name for class or member symbol names.
Fresh names are constructed using the following format prefix + "$macro$" + freshIndex. The freshIndex are unique within the current source file.
Examples: See scala.annotation.MacroAnnotation
Prefix of the fresh name
Generate a new type symbol for a type bounds with the given parent, name and type
Generate a new type symbol for a type bounds with the given parent, name and type
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 TypeDef constructor.
Value parametersextra flags to with which symbol can be constructed. Deferred flag will be added. Can be Private | Protected | Override | Deferred | Final | Infix | Local
The name of the type
The owner of the type
the symbol within which this new type symbol should be private. May be noSymbol.
The bounds of the type
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.
Generates a new class symbol for a class with a public parameterless constructor. For more settings, look to the other newClass methods.
Generates a new class symbol for a class with a public parameterless constructor. For more settings, look to the other newClass methods.
Example usage:
val name: String = "myClass"
val parents = List(TypeTree.of[Object], TypeTree.of[Foo])
def decls(cls: Symbol): List[Symbol] =
List(Symbol.newMethod(cls, "foo", MethodType(Nil)(_ => Nil, _ => TypeRepr.of[Unit])))
val cls = Symbol.newClass(Symbol.spliceOwner, name, parents = parents.map(_.tpe), decls, selfType = None)
val fooSym = cls.declaredMethod("foo").head
val fooDef = DefDef(fooSym, argss => Some('{println(s"Calling foo")}.asTerm))
val clsDef = ClassDef(cls, parents, body = List(fooDef))
val newCls = Typed(Apply(Select(New(TypeIdent(cls)), cls.primaryConstructor), Nil), TypeTree.of[Foo])
Block(List(clsDef), newCls).asExprOf[Foo]
constructs the equivalent to
'{
class myClass() extends Object with Foo {
def foo(): Unit = println("Calling foo")
}
new myClass(): Foo
}
The member declarations of the class provided the symbol of this class
The name of the class
The owner of the class
The parent classes of the class. The first parent must not be a trait.
The self type of the class if it has one 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.
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.
Generates a new class symbol for a class with a public single term clause constructor.
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()
}
extra flags with which the class symbol should be constructed.
the symbol within which this new class symbol should be private. May be noSymbol.
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.
The name of the class
The owner of the class
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.
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.
Generates a new class symbol with a constructor of the shape signified by a passed PolyOrMethod parameter.
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()
}
annotations of the class
extra flags with which the class symbol should be constructed. Can be Private | Protected | PrivateLocal | Local | Final | Trait | Abstract | Open
the symbol within which this new class symbol should be private. May be noSymbol
extra flags with which the constructor symbol should be constructed. Can be Synthetic | Method | Private | Protected | PrivateLocal | Local
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.
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
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.
the symbol within which the constructor for this new class symbol should be private. May be noSymbol.
The member declarations of the class provided the symbol of this class
The name of the class
The owner of the class
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.
The self type of the class if it has one
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.
Generates a new module symbol with an associated module class symbol, this is equivalent to an object declaration in source code. This method returns the module symbol. The module class can be accessed calling moduleClass on this symbol.
Generates a new module symbol with an associated module class symbol, this is equivalent to an object declaration in source code. This method returns the module symbol. The module class can be accessed calling moduleClass on this symbol.
Example usage:
given Quotes = ???
import quotes.reflect.*
val moduleName: String = Symbol.freshName("MyModule")
val parents = List(TypeTree.of[Object])
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 cls = mod.moduleClass
val runSym = cls.declaredMethod("run").head
val runDef = DefDef(runSym, _ => Some('{ println("run") }.asTerm))
val modDef = ClassDef.module(mod, parents, body = List(runDef))
val callRun = Apply(Select(Ref(mod), runSym), Nil)
Block(modDef.toList, callRun)
constructs the equivalent to
given Quotes = ???
import quotes.reflect.*
'{
object MyModule$macro$1 extends Object:
def run(): Unit = println("run")
MyModule$macro$1.run()
}
extra flags with which the module class symbol should be constructed
A function that takes the symbol of the module class as input and return the symbols of its declared members
extra flags with which the module symbol should be constructed
The name of the class
The owner of the class
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.
the symbol within which this new method symbol should be private. May be noSymbol. 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 ClassDef.module.
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.
Generate a new type symbol for a type alias with the given parent, name and type
Generate a new type symbol for a type alias with the given parent, name and type
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 TypeDef constructor.
Value parametersextra flags to with which symbol can be constructed. Can be Private | Protected | Override | Final | Infix | Local
The name of the type
The owner of the type
the symbol within which this new type symbol should be private. May be noSymbol.
The rhs the type alias
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.
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4