Remove redundant method in CompilerInterface

Author: nicolasstucki

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

@@ -1526,12 +1526,10 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
     symbol.isClass
 
   def Symbol_fields(self: Symbol)(given Context): List[Symbol] =
-    self.unforcedDecls.filter(isField)
+    self.unforcedDecls.filter(sym => sym.isTerm && !sym.is(Flags.Method))
 
-  def Symbol_field(self: Symbol)(name: String)(given Context): Symbol = {
-    val sym = self.unforcedDecls.find(sym => sym.name == name.toTermName)
-    if (isField(sym)) sym else core.Symbols.NoSymbol
-  }
+  def Symbol_field(self: Symbol)(name: String)(given Context): Symbol =
+    self.unforcedDecls.find(sym => sym.isTerm && !sym.is(Flags.Method) && sym.name == name.toTermName)
 
   def Symbol_classMethod(self: Symbol)(name: String)(given Context): List[Symbol] =
     self.typeRef.decls.iterator.collect {
@@ -1564,14 +1562,9 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
       case sym if sym.is(Flags.CaseAccessor) => sym.asTerm
     }
 
-  private def isField(sym: Symbol)(given Context): Boolean = sym.isTerm && !sym.is(Flags.Method)
-
   def Symbol_of(fullName: String)(given ctx: Context): Symbol =
     ctx.requiredClass(fullName)
 
-  def Symbol_isTypeDefSymbol(symbol: Symbol)(given Context): Boolean =
-    symbol.isType && !symbol.is(core.Flags.Case)
-
   def Symbol_isTypeParam(self: Symbol)(given Context): Boolean =
     self.isTypeParam
 
@@ -1581,28 +1574,17 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   def Symbol_isTermSymbol(symbol: Symbol)(given Context): Boolean =
     symbol.isTerm
 
-  def Symbol_isDefDefSymbol(symbol: Symbol)(given Context): Boolean =
-    symbol.isTerm && symbol.is(core.Flags.Method)
-
   def Symbol_signature(self: Symbol)(given Context): Signature =
     self.signature
 
-  def Symbol_isValDefSymbol(symbol: Symbol)(given Context): Boolean =
-    symbol.isTerm && !symbol.is(core.Flags.Method) && !symbol.is(core.Flags.Case)
-
   def Symbol_moduleClass(self: Symbol)(given Context): Symbol = self.moduleClass
 
   def Symbol_companionClass(self: Symbol)(given Context): Symbol = self.companionClass
 
   def Symbol_companionModule(self: Symbol)(given Context): Symbol = self.companionModule
 
-  def Symbol_isBindSymbol(symbol: Symbol)(given Context): Boolean =
-    symbol.isTerm && symbol.is(core.Flags.Case)
-
   def Symbol_noSymbol(given ctx: Context): Symbol = core.Symbols.NoSymbol
 
-  def Symbol_isNoSymbol(symbol: Symbol)(given Context): Boolean = symbol eq core.Symbols.NoSymbol
-
   //
   // FLAGS
   //
@@ -1628,6 +1610,7 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   def Flags_Implicit: Flags = core.Flags.Implicit
   def Flags_Given: Flags = core.Flags.Given
   def Flags_Erased: Flags = core.Flags.Erased
+  def Flags_Method: Flags = core.Flags.Method
   def Flags_Lazy: Flags = core.Flags.Lazy
   def Flags_Override: Flags = core.Flags.Override
   def Flags_Inline: Flags = core.Flags.Inline

library/src/scala/tasty/reflect/CompilerInterface.scala

@@ -1268,21 +1268,15 @@ trait CompilerInterface {
 
   def Symbol_of(fullName: String)(given ctx: Context): Symbol
 
-  def Symbol_isTypeDefSymbol(symbol: Symbol)(given ctx: Context): Boolean
-
   def Symbol_isTypeParam(self: Symbol)(given ctx: Context): Boolean
 
   def Symbol_isTypeBindSymbol(symbol: Symbol)(given ctx: Context): Boolean
 
   def Symbol_isTermSymbol(symbol: Symbol)(given ctx: Context): Boolean
 
-  def Symbol_isDefDefSymbol(symbol: Symbol)(given ctx: Context): Boolean
-
   /** Signature of this definition */
   def Symbol_signature(self: Symbol)(given ctx: Context): Signature
 
-  def Symbol_isValDefSymbol(symbol: Symbol)(given ctx: Context): Boolean
-
   /** The class symbol of the companion module class */
   def Symbol_moduleClass(self: Symbol)(given ctx: Context): Symbol
 
@@ -1292,12 +1286,8 @@ trait CompilerInterface {
   /** The symbol of the companion module */
   def Symbol_companionModule(self: Symbol)(given ctx: Context): Symbol
 
-  def Symbol_isBindSymbol(symbol: Symbol)(given ctx: Context): Boolean
-
   def Symbol_noSymbol(given ctx: Context): Symbol
 
-  def Symbol_isNoSymbol(symbol: Symbol)(given ctx: Context): Boolean
-
   //
   // FLAGS
   //
@@ -1324,6 +1314,7 @@ trait CompilerInterface {
   def Flags_Implicit: Flags
   def Flags_Given: Flags
   def Flags_Erased: Flags
+  def Flags_Method: Flags
   def Flags_Lazy: Flags
   def Flags_Override: Flags
   def Flags_Inline: Flags

library/src/scala/tasty/reflect/FlagsOps.scala

@@ -47,6 +47,9 @@ trait FlagsOps extends Core {
      /** Is this symbol `erased` */
     def Erased: Flags = internal.Flags_Erased
 
+    /** Is this symbol a method */
+    def Method: Flags = internal.Flags_Method
+
     /** Is this symbol `lazy` */
     def Lazy: Flags = internal.Flags_Lazy
 

library/src/scala/tasty/reflect/SymbolOps.scala

@@ -2,9 +2,7 @@ package scala.tasty
 package reflect
 
 /** Tasty reflect symbol */
-trait SymbolOps extends Core {
-
-  // Symbol
+trait SymbolOps extends Core { selfSymbolOps: FlagsOps =>
 
   object Symbol {
     /** The class Symbol of a global class definition */
@@ -97,13 +95,14 @@ trait SymbolOps extends Core {
 
     def isType(given ctx: Context): Boolean = internal.Symbol_isTypeSymbol(self)
     def isTerm(given ctx: Context): Boolean = internal.Symbol_isTermSymbol(self)
-    def isValDef(given ctx: Context): Boolean = internal.Symbol_isValDefSymbol(self)
-    def isDefDef(given ctx: Context): Boolean = internal.Symbol_isDefDefSymbol(self)
-    def isTypeDef(given ctx: Context): Boolean = internal.Symbol_isTypeDefSymbol(self)
+    def isValDef(given ctx: Context): Boolean = self.isTerm && !self.flags.is(Flags.Method) && !self.flags.is(Flags.Case)
+    def isDefDef(given ctx: Context): Boolean = self.isTerm && self.flags.is(Flags.Method)
+    def isTypeDef(given ctx: Context): Boolean = self.isType && !self.flags.is(Flags.Case)
     def isClassDef(given ctx: Context): Boolean = internal.Symbol_isClassDefSymbol(self)
-    def isBind(given ctx: Context): Boolean = internal.Symbol_isBindSymbol(self)
+    def isBind(given ctx: Context): Boolean = self.isTerm && self.flags.is(Flags.Case)
+    def isTypeBind(given ctx: Context): Boolean = self.isType && self.flags.is(Flags.Case)
     def isPackageDef(given ctx: Context): Boolean = internal.Symbol_isPackageDefSymbol(self)
-    def isNoSymbol(given ctx: Context): Boolean = internal.Symbol_isNoSymbol(self)
+    def isNoSymbol(given ctx: Context): Boolean = self == Symbol.noSymbol
 
     /** Fields directly declared in the class */
     def fields(given ctx: Context): List[Symbol] =