Implement SymbolOps members in kernel

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tastyreflect/CoreImpl.scala

@@ -3,7 +3,7 @@ package tastyreflect
 
 import dotty.tools.dotc.ast.{Trees, tpd, untpd}
 import dotty.tools.dotc.ast.tpd.TreeOps
-import dotty.tools.dotc.core.{Constants, NameKinds, Names, Types}
+import dotty.tools.dotc.core._
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.StdNames.nme
 import dotty.tools.dotc.core.quoted.PickledQuotes
@@ -1410,31 +1410,125 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
   def isPackageSymbol(symbol: Symbol)(implicit ctx: Context): Option[PackageSymbol] =
     if (symbol.is(core.Flags.Package)) Some(symbol) else None
 
+  def PackageSymbol_tree(self: PackageSymbol)(implicit ctx: Context): PackageDef =
+    FromSymbol.packageDefFromSym(self)
+
   type ClassSymbol = core.Symbols.ClassSymbol
 
   def isClassSymbol(symbol: Symbol)(implicit ctx: Context): Option[ClassSymbol] =
     if (symbol.isClass) Some(symbol.asClass) else None
 
+  def ClassSymbol_tree(self: ClassSymbol)(implicit ctx: Context): ClassDef =
+    FromSymbol.classDef(self)
+
+  def ClassSymbol_fields(self: Symbol)(implicit ctx: Context): List[Symbol] =
+    self.unforcedDecls.filter(isField)
+
+  def ClassSymbol_field(self: Symbol)(name: String)(implicit ctx: Context): Option[Symbol] = {
+    val sym = self.unforcedDecls.find(sym => sym.name == name.toTermName)
+    if (sym.exists && isField(sym)) Some(sym) else None
+  }
+
+  def ClassSymbol_classMethod(self: Symbol)(name: String)(implicit ctx: Context): List[DefSymbol] = {
+    self.typeRef.decls.iterator.collect {
+      case sym if isMethod(sym) && sym.name.toString == name => sym.asTerm
+    }.toList
+  }
+
+  def ClassSymbol_classMethods(self: Symbol)(implicit ctx: Context): List[DefSymbol] = {
+    self.typeRef.decls.iterator.collect {
+      case sym if isMethod(sym) => sym.asTerm
+    }.toList
+  }
+
+  def ClassSymbol_method(self: Symbol)(name: String)(implicit ctx: Context): List[DefSymbol] = {
+    self.typeRef.allMembers.iterator.map(_.symbol).collect {
+      case sym if isMethod(sym) && sym.name.toString == name => sym.asTerm
+    }.toList
+  }
+
+  def ClassSymbol_methods(self: Symbol)(implicit ctx: Context): List[DefSymbol] = {
+    self.typeRef.allMembers.iterator.map(_.symbol).collect {
+      case sym if isMethod(sym) => sym.asTerm
+    }.toList
+  }
+
+  private def isMethod(sym: Symbol)(implicit ctx: Context): Boolean =
+    sym.isTerm && sym.is(Flags.Method) && !sym.isConstructor
+
+  def ClassSymbol_caseFields(self: Symbol)(implicit ctx: Context): List[ValSymbol] = {
+    if (!self.isClass) Nil
+    else self.asClass.paramAccessors.collect {
+      case sym if sym.is(Flags.CaseAccessor) => sym.asTerm
+    }
+  }
+
+  def ClassSymbol_companionClass(self: Symbol)(implicit ctx: Context): Option[ClassSymbol] = {
+    val sym = self.companionModule.companionClass
+    if (sym.exists) Some(sym.asClass) else None
+  }
+
+  def ClassSymbol_companionModule(self: Symbol)(implicit ctx: Context): Option[ValSymbol] = {
+    val sym = self.companionModule
+    if (sym.exists) Some(sym.asTerm) else None
+  }
+
+  def ClassSymbol_moduleClass(self: Symbol)(implicit ctx: Context): Option[Symbol] = {
+    val sym = self.moduleClass
+    if (sym.exists) Some(sym.asTerm) else None
+  }
+
+  private def isField(sym: Symbol)(implicit ctx: Context): Boolean = sym.isTerm && !sym.is(Flags.Method)
+
+  def ClassSymbol_of(fullName: String)(implicit ctx: Context): ClassSymbol = ctx.requiredClass(fullName)
+
   type TypeSymbol = core.Symbols.TypeSymbol
 
   def isTypeSymbol(symbol: Symbol)(implicit ctx: Context): Option[TypeSymbol] =
     if (symbol.isType) Some(symbol.asType) else None
 
+  def TypeSymbol_tree(self: TypeSymbol)(implicit ctx: Context): TypeDef =
+    FromSymbol.typeDefFromSym(self)
+  def TypeSymbol_isTypeParam(self: TypeSymbol)(implicit ctx: Context): Boolean =
+    self.isTypeParam
+
   type DefSymbol = core.Symbols.TermSymbol
 
   def isDefSymbol(symbol: Symbol)(implicit ctx: Context): Option[DefSymbol] =
     if (symbol.isTerm && symbol.is(core.Flags.Method)) Some(symbol.asTerm) else None
 
-  type BindSymbol = core.Symbols.TermSymbol
+  def DefSymbol_tree(self: DefSymbol)(implicit ctx: Context): DefDef =
+    FromSymbol.defDefFromSym(self)
 
-  def isBindSymbol(symbol: Symbol)(implicit ctx: Context): Option[BindSymbol] =
-    if (symbol.isTerm && symbol.is(core.Flags.Case)) Some(symbol.asTerm) else None
+  def DefSymbol_signature(self: DefSymbol)(implicit ctx: Context): Signature =
+    self.signature
 
   type ValSymbol = core.Symbols.TermSymbol
 
   def isValSymbol(symbol: Symbol)(implicit ctx: Context): Option[ValSymbol] =
     if (symbol.isTerm && !symbol.is(core.Flags.Method) && !symbol.is(core.Flags.Case)) Some(symbol.asTerm) else None
 
+  def ValSymbol_tree(self: ValSymbol)(implicit ctx: Context): ValDef =
+    FromSymbol.valDefFromSym(self)
+
+  def ValSymbol_moduleClass(self: ValSymbol)(implicit ctx: Context): Option[ClassSymbol] = {
+    val sym = self.moduleClass
+    if (sym.exists) Some(sym.asClass) else None
+  }
+
+  def ValSymbol_companionClass(self: ValSymbol)(implicit ctx: Context): Option[ClassSymbol] = {
+    val sym = self.companionClass
+    if (sym.exists) Some(sym.asClass) else None
+  }
+
+  type BindSymbol = core.Symbols.TermSymbol
+
+  def isBindSymbol(symbol: Symbol)(implicit ctx: Context): Option[BindSymbol] =
+    if (symbol.isTerm && symbol.is(core.Flags.Case)) Some(symbol.asTerm) else None
+
+  def BindSymbol_tree(self: BindSymbol)(implicit ctx: Context): Bind =
+    FromSymbol.bindFromSym(self)
+
   type NoSymbol = core.Symbols.NoSymbol.type
 
   def isNoSymbol(symbol: Symbol)(implicit ctx: Context): Boolean = symbol ne core.Symbols.NoSymbol

compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala

@@ -4,9 +4,7 @@ import dotty.tools.dotc.core._
 import dotty.tools.dotc.util.{SourcePosition, Spans}
 
 class ReflectionImpl private (ctx: Contexts.Context, pos: SourcePosition)
-    extends scala.tasty.Reflection
-    with CoreImpl
-    with SymbolOpsImpl {
+    extends scala.tasty.Reflection {
 
   val kernel: KernelImpl = new KernelImpl(ctx, pos)
 

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionImpl.scala

@@ -1156,31 +1156,90 @@ trait Kernel {
 
   def isPackageSymbol(symbol: Symbol)(implicit ctx: Context): Option[PackageSymbol]
 
+  def PackageSymbol_tree(self: PackageSymbol)(implicit ctx: Context): PackageDef
+
   /** Symbol of a class definition. This includes anonymous class definitions and the class of a module object. */
   type ClassSymbol <: Symbol
 
   def isClassSymbol(symbol: Symbol)(implicit ctx: Context): Option[ClassSymbol]
 
+  /** ClassDef tree of this defintion */
+  def ClassSymbol_tree(self: ClassSymbol)(implicit ctx: Context): ClassDef
+
+  /** Fields directly declared in the class */
+  def ClassSymbol_fields(self: Symbol)(implicit ctx: Context): List[Symbol]
+
+  /** Field with the given name directly declared in the class */
+  def ClassSymbol_field(self: Symbol)(name: String)(implicit ctx: Context): Option[Symbol]
+
+  /** Get non-private named methods defined directly inside the class */
+  def ClassSymbol_classMethod(self: Symbol)(name: String)(implicit ctx: Context): List[DefSymbol]
+
+  /** Get all non-private methods defined directly inside the class, exluding constructors */
+  def ClassSymbol_classMethods(self: Symbol)(implicit ctx: Context): List[DefSymbol]
+
+  /** Get named non-private methods declared or inherited */
+  def ClassSymbol_method(self: Symbol)(name: String)(implicit ctx: Context): List[DefSymbol]
+
+  /** Get all non-private methods declared or inherited */
+  def ClassSymbol_methods(self: Symbol)(implicit ctx: Context): List[DefSymbol]
+
+  /** Fields of a case class type -- only the ones declared in primary constructor */
+  def ClassSymbol_caseFields(self: Symbol)(implicit ctx: Context): List[ValSymbol]
+
+  /** The class symbol of the companion module class */
+  def ClassSymbol_companionClass(self: Symbol)(implicit ctx: Context): Option[ClassSymbol]
+
+  /** The symbol of the companion module */
+  def ClassSymbol_companionModule(self: Symbol)(implicit ctx: Context): Option[ValSymbol]
+
+  /** The symbol of the class of the companion module */
+  def ClassSymbol_moduleClass(self: Symbol)(implicit ctx: Context): Option[Symbol]
+
+  def ClassSymbol_of(fullName: String)(implicit ctx: Context): ClassSymbol
+
   /** Symbol of a type (parameter or member) definition. */
   type TypeSymbol <: Symbol
 
   def isTypeSymbol(symbol: Symbol)(implicit ctx: Context): Option[TypeSymbol]
 
+  def TypeSymbol_isTypeParam(self: TypeSymbol)(implicit ctx: Context): Boolean
+
+  /** TypeDef tree of this definition */
+  def TypeSymbol_tree(self: TypeSymbol)(implicit ctx: Context): TypeDef
+
   /** Symbol representing a method definition. */
   type DefSymbol <: Symbol
 
   def isDefSymbol(symbol: Symbol)(implicit ctx: Context): Option[DefSymbol]
 
+  /** DefDef tree of this defintion */
+  def DefSymbol_tree(self: DefSymbol)(implicit ctx: Context): DefDef
+
+  /** Signature of this defintion */
+  def DefSymbol_signature(self: DefSymbol)(implicit ctx: Context): Signature
+
   /** Symbol representing a value definition. This includes `val`, `lazy val`, `var`, `object` and parameter definitions. */
   type ValSymbol <: Symbol
 
   def isValSymbol(symbol: Symbol)(implicit ctx: Context): Option[ValSymbol]
 
+  /** ValDef tree of this defintion */
+  def ValSymbol_tree(self: ValSymbol)(implicit ctx: Context): ValDef
+
+  /** The class symbol of the companion module class */
+  def ValSymbol_moduleClass(self: ValSymbol)(implicit ctx: Context): Option[ClassSymbol]
+
+  def ValSymbol_companionClass(self: ValSymbol)(implicit ctx: Context): Option[ClassSymbol]
+
   /** Symbol representing a bind definition. */
   type BindSymbol <: Symbol
 
   def isBindSymbol(symbol: Symbol)(implicit ctx: Context): Option[BindSymbol]
 
+  /** Bind pattern of this definition */
+  def BindSymbol_tree(self: BindSymbol)(implicit ctx: Context): Bind
+
   /** No symbol available. */
   type NoSymbol <: Symbol