Skip to content

Tasty reflect symbol refactorings #7313

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 13 commits into from
Sep 26, 2019
Merged

Tasty reflect symbol refactorings #7313

Show file tree
Hide file tree
Changes from 9 commits
Commits
Show all changes
13 commits
Select commit Hold shift + click to select a range
2cccb23
Move `.tree` to Reflection.Symbol
nicolasstucki Sep 24, 2019
4e6c615
Replace IsXYZSymbol with isXYZ methods
nicolasstucki Sep 24, 2019
c17c7c7
Replace ClassSymbol.of with Symbol.classSymbol
nicolasstucki Sep 24, 2019
a63758c
Move all symbol extension method to SymbolAPI
nicolasstucki Sep 24, 2019
6b7dc95
Use `NoSymbol` instead of `Option`s
nicolasstucki Sep 24, 2019
873e44e
Remove subtypes of Symbol
nicolasstucki Sep 24, 2019
52f4ee8
Homogenize Symbol methods in CompilerInterface
nicolasstucki Sep 25, 2019
ba9c2bf
Remove redundant method in CompilerInterface
nicolasstucki Sep 25, 2019
1070c7d
Remove redundant Symbol.asXYZ methods
nicolasstucki Sep 25, 2019
8e7233f
Add missing falgs in assertion
nicolasstucki Sep 26, 2019
a7ce985
Cleanup Symbol.isXYZ methods and add docs
nicolasstucki Sep 26, 2019
35b6b7c
Add documentation
nicolasstucki Sep 26, 2019
d8d28bd
Add missing flags check
nicolasstucki Sep 26, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion community-build/community-projects/semanticdb
Open in desktop
Submodule semanticdb updated 1 files
+31 −57 src/main/scala/dotty/semanticdb/SemanticdbConsumer.scala
2 changes: 1 addition & 1 deletion community-build/community-projects/shapeless
Open in desktop
Submodule shapeless updated 1 files
+5 −2 core/src/main/scala/shapeless/typeable.scala
2 changes: 1 addition & 1 deletion community-build/community-projects/sourcecode
Open in desktop
Submodule sourcecode updated 1 files
+10 −18 sourcecode/src-dotty/sourcecode/Macros.scala
164 changes: 55 additions & 109 deletions compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -156,7 +156,7 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
if (self.symbol.is(core.Flags.JavaDefined)) Nil // FIXME should also support java packages
else self.symbol.info.decls.iterator.map(definitionFromSym).toList

def PackageDef_symbol(self: PackageDef)(given Context): PackageDefSymbol = self.symbol
def PackageDef_symbol(self: PackageDef)(given Context): Symbol = self.symbol

type ClassDef = tpd.TypeDef

Expand All @@ -170,7 +170,7 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
def ClassDef_derived(self: ClassDef)(given Context): List[TypeTree] = ClassDef_rhs(self).derived.asInstanceOf[List[TypeTree]]
def ClassDef_self(self: ClassDef)(given Context): Option[ValDef] = optional(ClassDef_rhs(self).self)
def ClassDef_body(self: ClassDef)(given Context): List[Statement] = ClassDef_rhs(self).body
def ClassDef_symbol(self: ClassDef)(given Context): ClassDefSymbol = self.symbol.asClass
def ClassDef_symbol(self: ClassDef)(given Context): Symbol = self.symbol.asClass
private def ClassDef_rhs(self: ClassDef) = self.rhs.asInstanceOf[tpd.Template]

def ClassDef_copy(original: ClassDef)(name: String, constr: DefDef, parents: List[Term | TypeTree], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement])(given Context): ClassDef = {
Expand All @@ -186,9 +186,9 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
}

def TypeDef_rhs(self: TypeDef)(given Context): TypeTree | TypeBoundsTree = self.rhs
def TypeDef_symbol(self: TypeDef)(given Context): TypeDefSymbol = self.symbol.asType
def TypeDef_symbol(self: TypeDef)(given Context): Symbol = self.symbol.asType

def TypeDef_apply(symbol: TypeDefSymbol)(given Context): TypeDef = withDefaultPos(tpd.TypeDef(symbol))
def TypeDef_apply(symbol: Symbol)(given Context): TypeDef = withDefaultPos(tpd.TypeDef(symbol.asType))
def TypeDef_copy(original: TypeDef)(name: String, rhs: TypeTree | TypeBoundsTree)(given Context): TypeDef =
tpd.cpy.TypeDef(original)(name.toTypeName, rhs)

Expand All @@ -203,10 +203,10 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
def DefDef_paramss(self: DefDef)(given Context): List[List[ValDef]] = self.vparamss
def DefDef_returnTpt(self: DefDef)(given Context): TypeTree = self.tpt
def DefDef_rhs(self: DefDef)(given Context): Option[Tree] = optional(self.rhs)
def DefDef_symbol(self: DefDef)(given Context): DefDefSymbol = self.symbol.asTerm
def DefDef_symbol(self: DefDef)(given Context): Symbol = self.symbol.asTerm

def DefDef_apply(symbol: DefDefSymbol, rhsFn: List[Type] => List[List[Term]] => Option[Term])(given Context): DefDef =
withDefaultPos(tpd.polyDefDef(symbol, tparams => vparamss => rhsFn(tparams)(vparamss).getOrElse(tpd.EmptyTree)))
def DefDef_apply(symbol: Symbol, rhsFn: List[Type] => List[List[Term]] => Option[Term])(given Context): DefDef =
withDefaultPos(tpd.polyDefDef(symbol.asTerm, tparams => vparamss => rhsFn(tparams)(vparamss).getOrElse(tpd.EmptyTree)))

def DefDef_copy(original: DefDef)(name: String, typeParams: List[TypeDef], paramss: List[List[ValDef]], tpt: TypeTree, rhs: Option[Term])(given Context): DefDef =
tpd.cpy.DefDef(original)(name.toTermName, typeParams, paramss, tpt, rhs.getOrElse(tpd.EmptyTree))
Expand All @@ -220,10 +220,10 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend

def ValDef_tpt(self: ValDef)(given Context): TypeTree = self.tpt
def ValDef_rhs(self: ValDef)(given Context): Option[Tree] = optional(self.rhs)
def ValDef_symbol(self: ValDef)(given Context): ValDefSymbol = self.symbol.asTerm
def ValDef_symbol(self: ValDef)(given Context): Symbol = self.symbol.asTerm

def ValDef_apply(symbol: ValDefSymbol, rhs: Option[Term])(given Context): ValDef =
tpd.ValDef(symbol, rhs.getOrElse(tpd.EmptyTree))
def ValDef_apply(symbol: Symbol, rhs: Option[Term])(given Context): ValDef =
tpd.ValDef(symbol.asTerm, rhs.getOrElse(tpd.EmptyTree))

def ValDef_copy(original: ValDef)(name: String, tpt: TypeTree, rhs: Option[Term])(given Context): ValDef =
tpd.cpy.ValDef(original)(name.toTermName, tpt, rhs.getOrElse(tpd.EmptyTree))
Expand Down Expand Up @@ -319,8 +319,8 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend

def This_id(self: This)(given Context): Option[Id] = optional(self.qual)

def This_apply(cls: ClassDefSymbol)(given Context): This =
withDefaultPos(tpd.This(cls))
def This_apply(cls: Symbol)(given Context): This =
withDefaultPos(tpd.This(cls.asClass))

def This_copy(original: Tree)(qual: Option[Id])(given Context): This =
tpd.cpy.This(original)(qual.getOrElse(untpd.EmptyTypeIdent))
Expand Down Expand Up @@ -1088,7 +1088,7 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend

def Type_simplified(self: Type)(given Context): Type = self.simplified

def Type_classSymbol(self: Type)(given Context): Option[ClassDefSymbol] =
def Type_classSymbol(self: Type)(given Context): Option[Symbol] =
if (self.classSymbol.exists) Some(self.classSymbol.asClass) else None

def Type_typeSymbol(self: Type)(given Context): Symbol = self.typeSymbol
Expand All @@ -1100,7 +1100,7 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
def Type_memberType(self: Type)(member: Symbol)(given Context): Type =
member.info.asSeenFrom(self, member.owner)

def Type_derivesFrom(self: Type)(cls: ClassDefSymbol)(given Context): Boolean =
def Type_derivesFrom(self: Type)(cls: Symbol)(given Context): Boolean =
self.derivesFrom(cls)

def Type_isFunctionType(self: Type)(given Context): Boolean =
Expand Down Expand Up @@ -1458,6 +1458,16 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend

def Symbol_flags(self: Symbol)(given Context): Flags = self.flags

def Symbol_tree(self: Symbol)(given Context): Tree = {
assert(!self.is(Case))
FromSymbol.definitionFromSym(self)
}

def Symbol_pattern(self: Symbol)(given ctx: Context): Pattern = {
assert(self.is(Case))
FromSymbol.definitionFromSym(self)
}

def Symbol_privateWithin(self: Symbol)(given Context): Option[Type] = {
val within = self.privateWithin
if (within.exists && !self.is(core.Flags.Protected)) Some(within.typeRef)
Expand Down Expand Up @@ -1506,148 +1516,84 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
def Symbol_isAbstractType(self: Symbol)(given Context): Boolean = self.isAbstractType
def Symbol_isClassConstructor(self: Symbol)(given Context): Boolean = self.isClassConstructor

type PackageDefSymbol = core.Symbols.Symbol

def matchPackageDefSymbol(symbol: Symbol)(given Context): Option[PackageDefSymbol] =
if (symbol.is(core.Flags.Package)) Some(symbol) else None

def PackageDefSymbol_tree(self: PackageDefSymbol)(given Context): PackageDef =
FromSymbol.packageDefFromSym(self)

type TypeSymbol = core.Symbols.TypeSymbol

def matchTypeSymbol(symbol: Symbol)(given Context): Option[TypeSymbol] =
if (symbol.isType) Some(symbol.asType) else None
def Symbol_isPackageDefSymbol(symbol: Symbol)(given Context): Boolean =
symbol.is(core.Flags.Package)

type ClassDefSymbol = core.Symbols.ClassSymbol
def Symbol_isTypeSymbol(symbol: Symbol)(given Context): Boolean =
symbol.isType

def matchClassDefSymbol(symbol: Symbol)(given Context): Option[ClassDefSymbol] =
if (symbol.isClass) Some(symbol.asClass) else None
def Symbol_isClassDefSymbol(symbol: Symbol)(given Context): Boolean =
symbol.isClass

def ClassDefSymbol_tree(self: ClassDefSymbol)(given Context): ClassDef =
FromSymbol.classDef(self)

def ClassDefSymbol_fields(self: Symbol)(given Context): List[Symbol] =
def Symbol_fields(self: Symbol)(given Context): List[Symbol] =
self.unforcedDecls.filter(isField)

def ClassDefSymbol_field(self: Symbol)(name: String)(given Context): Option[Symbol] = {
def Symbol_field(self: Symbol)(name: String)(given Context): Symbol = {
val sym = self.unforcedDecls.find(sym => sym.name == name.toTermName)
if (sym.exists && isField(sym)) Some(sym) else None
if (isField(sym)) sym else core.Symbols.NoSymbol
}

def ClassDefSymbol_classMethod(self: Symbol)(name: String)(given Context): List[DefDefSymbol] =
def Symbol_classMethod(self: Symbol)(name: String)(given Context): List[Symbol] =
self.typeRef.decls.iterator.collect {
case sym if isMethod(sym) && sym.name.toString == name => sym.asTerm
}.toList

def ClassDefSymbol_classMethods(self: Symbol)(given Context): List[DefDefSymbol] =
def Symbol_classMethods(self: Symbol)(given Context): List[Symbol] =
self.typeRef.decls.iterator.collect {
case sym if isMethod(sym) => sym.asTerm
}.toList

private def appliedTypeRef(sym: Symbol): Type = sym.typeRef.appliedTo(sym.typeParams.map(_.typeRef))

def ClassDefSymbol_method(self: Symbol)(name: String)(given Context): List[DefDefSymbol] =
def Symbol_method(self: Symbol)(name: String)(given Context): List[Symbol] =
appliedTypeRef(self).allMembers.iterator.map(_.symbol).collect {
case sym if isMethod(sym) && sym.name.toString == name => sym.asTerm
}.toList

def ClassDefSymbol_methods(self: Symbol)(given Context): List[DefDefSymbol] =
def Symbol_methods(self: Symbol)(given Context): List[Symbol] =
appliedTypeRef(self).allMembers.iterator.map(_.symbol).collect {
case sym if isMethod(sym) => sym.asTerm
}.toList

private def isMethod(sym: Symbol)(given Context): Boolean =
sym.isTerm && sym.is(Flags.Method) && !sym.isConstructor

def ClassDefSymbol_caseFields(self: Symbol)(given Context): List[ValDefSymbol] =
def Symbol_caseFields(self: Symbol)(given Context): List[Symbol] =
if (!self.isClass) Nil
else self.asClass.paramAccessors.collect {
case sym if sym.is(Flags.CaseAccessor) => sym.asTerm
}

def ClassDefSymbol_companionClass(self: Symbol)(given Context): Option[ClassDefSymbol] = {
val sym = self.companionModule.companionClass
if (sym.exists) Some(sym.asClass) else None
}

def ClassDefSymbol_companionModule(self: Symbol)(given Context): Option[ValDefSymbol] = {
val sym = self.companionModule
if (sym.exists) Some(sym.asTerm) else None
}

def ClassDefSymbol_moduleClass(self: Symbol)(given Context): Option[Symbol] = {
val sym = self.moduleClass
if (sym.exists) Some(sym.asTerm) else None
}

private def isField(sym: Symbol)(given Context): Boolean = sym.isTerm && !sym.is(Flags.Method)

def ClassDefSymbol_of(fullName: String)(given ctx: Context): ClassDefSymbol = ctx.requiredClass(fullName)
def Symbol_of(fullName: String)(given ctx: Context): Symbol =
ctx.requiredClass(fullName)

type TypeDefSymbol = core.Symbols.TypeSymbol

def matchTypeDefSymbol(symbol: Symbol)(given Context): Option[TypeDefSymbol] =
if (symbol.isType) Some(symbol.asType) else None

def TypeDefSymbol_tree(self: TypeDefSymbol)(given Context): TypeDef =
FromSymbol.typeDefFromSym(self)
def TypeDefSymbol_isTypeParam(self: TypeDefSymbol)(given Context): Boolean =
def Symbol_isTypeParam(self: Symbol)(given Context): Boolean =
self.isTypeParam

type TypeBindSymbol = core.Symbols.TypeSymbol

def matchTypeBindSymbol(symbol: Symbol)(given Context): Option[TypeBindSymbol] =
if (symbol.isType && symbol.is(core.Flags.Case)) Some(symbol.asType) else None

def TypeBindSymbol_tree(self: TypeBindSymbol)(given Context): TypeBind =
FromSymbol.typeBindFromSym(self)

type TermSymbol = core.Symbols.TermSymbol

def matchTermSymbol(symbol: Symbol)(given Context): Option[TermSymbol] =
if (symbol.isTerm) Some(symbol.asTerm) else None

type DefDefSymbol = core.Symbols.TermSymbol
def Symbol_isTypeBindSymbol(symbol: Symbol)(given Context): Boolean =
symbol.isType && symbol.is(core.Flags.Case)

def matchDefDefSymbol(symbol: Symbol)(given Context): Option[DefDefSymbol] =
if (symbol.isTerm && symbol.is(core.Flags.Method)) Some(symbol.asTerm) else None
def Symbol_isTermSymbol(symbol: Symbol)(given Context): Boolean =
symbol.isTerm

def DefDefSymbol_tree(self: DefDefSymbol)(given Context): DefDef =
FromSymbol.defDefFromSym(self)
def Symbol_isDefDefSymbol(symbol: Symbol)(given Context): Boolean =
symbol.isTerm && symbol.is(core.Flags.Method)

def DefDefSymbol_signature(self: DefDefSymbol)(given Context): Signature =
def Symbol_signature(self: Symbol)(given Context): Signature =
self.signature

type ValDefSymbol = core.Symbols.TermSymbol

def matchValDefSymbol(symbol: Symbol)(given Context): Option[ValDefSymbol] =
if (symbol.isTerm && !symbol.is(core.Flags.Method) && !symbol.is(core.Flags.Case)) Some(symbol.asTerm) else None

def ValDefSymbol_tree(self: ValDefSymbol)(given Context): ValDef =
FromSymbol.valDefFromSym(self)

def ValDefSymbol_moduleClass(self: ValDefSymbol)(given Context): Option[ClassDefSymbol] = {
val sym = self.moduleClass
if (sym.exists) Some(sym.asClass) else None
}

def ValDefSymbol_companionClass(self: ValDefSymbol)(given Context): Option[ClassDefSymbol] = {
val sym = self.companionClass
if (sym.exists) Some(sym.asClass) else None
}

type BindSymbol = core.Symbols.TermSymbol
def Symbol_isValDefSymbol(symbol: Symbol)(given Context): Boolean =
symbol.isTerm && !symbol.is(core.Flags.Method) && !symbol.is(core.Flags.Case)

def matchBindSymbol(symbol: Symbol)(given Context): Option[BindSymbol] =
if (symbol.isTerm && symbol.is(core.Flags.Case)) Some(symbol.asTerm) else None
def Symbol_moduleClass(self: Symbol)(given Context): Symbol = self.moduleClass

def BindSymbol_tree(self: BindSymbol)(given Context): Bind =
FromSymbol.bindFromSym(self)
def Symbol_companionClass(self: Symbol)(given Context): Symbol = self.companionClass

type NoSymbol = core.Symbols.NoSymbol.type
def Symbol_companionModule(self: Symbol)(given Context): Symbol = self.companionModule

def matchNoSymbol(symbol: Symbol)(given Context): Boolean = symbol eq core.Symbols.NoSymbol
def Symbol_noSymbol(given ctx: Context): Symbol = core.Symbols.NoSymbol

//
// FLAGS
Expand Down Expand Up @@ -1792,7 +1738,7 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
def Definitions_Array_length: Symbol = defn.Array_length.asTerm
def Definitions_Array_update: Symbol = defn.Array_update.asTerm

def Definitions_RepeatedParamClass: ClassDefSymbol = defn.RepeatedParamClass
def Definitions_RepeatedParamClass: Symbol = defn.RepeatedParamClass

def Definitions_OptionClass: Symbol = defn.OptionClass
def Definitions_NoneModule: Symbol = defn.NoneModule
Expand Down
Loading