Replace IsXYZSymbol with isXYZ methods

Author: nicolasstucki

community-build/community-projects/semanticdb

@@ -1518,18 +1518,16 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
 
   type PackageDefSymbol = core.Symbols.Symbol
 
-  def matchPackageDefSymbol(symbol: Symbol)(given Context): Option[PackageDefSymbol] =
-    if (symbol.is(core.Flags.Package)) Some(symbol) else None
+  def isPackageDefSymbol(symbol: Symbol)(given Context): Boolean =
+    symbol.is(core.Flags.Package)
 
   type TypeSymbol = core.Symbols.TypeSymbol
 
-  def matchTypeSymbol(symbol: Symbol)(given Context): Option[TypeSymbol] =
-    if (symbol.isType) Some(symbol.asType) else None
+  def isTypeSymbol(symbol: Symbol)(given Context): Boolean = symbol.isType
 
   type ClassDefSymbol = core.Symbols.ClassSymbol
 
-  def matchClassDefSymbol(symbol: Symbol)(given Context): Option[ClassDefSymbol] =
-    if (symbol.isClass) Some(symbol.asClass) else None
+  def isClassDefSymbol(symbol: Symbol)(given Context): Boolean = symbol.isClass
 
   def ClassDefSymbol_fields(self: Symbol)(given Context): List[Symbol] =
     self.unforcedDecls.filter(isField)
@@ -1591,34 +1589,33 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
 
   type TypeDefSymbol = core.Symbols.TypeSymbol
 
-  def matchTypeDefSymbol(symbol: Symbol)(given Context): Option[TypeDefSymbol] =
-    if (symbol.isType) Some(symbol.asType) else None
+  def isTypeDefSymbol(symbol: Symbol)(given Context): Boolean =
+    symbol.isType && !symbol.is(core.Flags.Case)
 
   def TypeDefSymbol_isTypeParam(self: TypeDefSymbol)(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 isTypeBindSymbol(symbol: Symbol)(given Context): Boolean =
+    symbol.isType && symbol.is(core.Flags.Case)
 
   type TermSymbol = core.Symbols.TermSymbol
 
-  def matchTermSymbol(symbol: Symbol)(given Context): Option[TermSymbol] =
-    if (symbol.isTerm) Some(symbol.asTerm) else None
+  def isTermSymbol(symbol: Symbol)(given Context): Boolean = symbol.isTerm
 
   type DefDefSymbol = core.Symbols.TermSymbol
 
-  def matchDefDefSymbol(symbol: Symbol)(given Context): Option[DefDefSymbol] =
-    if (symbol.isTerm && symbol.is(core.Flags.Method)) Some(symbol.asTerm) else None
+  def isDefDefSymbol(symbol: Symbol)(given Context): Boolean =
+    symbol.isTerm && symbol.is(core.Flags.Method)
 
   def DefDefSymbol_signature(self: DefDefSymbol)(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 isValDefSymbol(symbol: Symbol)(given Context): Boolean =
+    symbol.isTerm && !symbol.is(core.Flags.Method) && !symbol.is(core.Flags.Case)
 
   def ValDefSymbol_moduleClass(self: ValDefSymbol)(given Context): Option[ClassDefSymbol] = {
     val sym = self.moduleClass
@@ -1632,12 +1629,12 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
 
   type BindSymbol = core.Symbols.TermSymbol
 
-  def matchBindSymbol(symbol: Symbol)(given Context): Option[BindSymbol] =
-    if (symbol.isTerm && symbol.is(core.Flags.Case)) Some(symbol.asTerm) else None
+  def isBindSymbol(symbol: Symbol)(given Context): Boolean =
+    symbol.isTerm && symbol.is(core.Flags.Case)
 
   type NoSymbol = core.Symbols.NoSymbol.type
 
-  def matchNoSymbol(symbol: Symbol)(given Context): Boolean = symbol eq core.Symbols.NoSymbol
+  def isNoSymbol(symbol: Symbol)(given Context): Boolean = symbol eq core.Symbols.NoSymbol
 
   //
   // FLAGS

community-build/community-projects/sourcecode

@@ -1252,16 +1252,16 @@ trait CompilerInterface {
   /** Symbol of a package definition */
   type PackageDefSymbol <: Symbol
 
-  def matchPackageDefSymbol(symbol: Symbol)(given ctx: Context): Option[PackageDefSymbol]
+  def isPackageDefSymbol(symbol: Symbol)(given ctx: Context): Boolean
 
   type TypeSymbol <: Symbol
 
-  def matchTypeSymbol(symbol: Symbol)(given ctx: Context): Option[TypeSymbol]
+  def isTypeSymbol(symbol: Symbol)(given ctx: Context): Boolean
 
   /** Symbol of a class definition. This includes anonymous class definitions and the class of a module object. */
   type ClassDefSymbol <: TypeSymbol
 
-  def matchClassDefSymbol(symbol: Symbol)(given ctx: Context): Option[ClassDefSymbol]
+  def isClassDefSymbol(symbol: Symbol)(given ctx: Context): Boolean
 
   /** Fields directly declared in the class */
   def ClassDefSymbol_fields(self: Symbol)(given ctx: Context): List[Symbol]
@@ -1298,31 +1298,31 @@ trait CompilerInterface {
   /** Symbol of a type (parameter or member) definition. */
   type TypeDefSymbol <: TypeSymbol
 
-  def matchTypeDefSymbol(symbol: Symbol)(given ctx: Context): Option[TypeDefSymbol]
+  def isTypeDefSymbol(symbol: Symbol)(given ctx: Context): Boolean
 
   def TypeDefSymbol_isTypeParam(self: TypeDefSymbol)(given ctx: Context): Boolean
 
   /** Symbol representing a bind definition. */
   type TypeBindSymbol <: TypeSymbol
 
-  def matchTypeBindSymbol(symbol: Symbol)(given ctx: Context): Option[TypeBindSymbol]
+  def isTypeBindSymbol(symbol: Symbol)(given ctx: Context): Boolean
 
   type TermSymbol <: Symbol
 
-  def matchTermSymbol(symbol: Symbol)(given ctx: Context): Option[TermSymbol]
+  def isTermSymbol(symbol: Symbol)(given ctx: Context): Boolean
 
   /** Symbol representing a method definition. */
   type DefDefSymbol <: TermSymbol
 
-  def matchDefDefSymbol(symbol: Symbol)(given ctx: Context): Option[DefDefSymbol]
+  def isDefDefSymbol(symbol: Symbol)(given ctx: Context): Boolean
 
   /** Signature of this definition */
   def DefDefSymbol_signature(self: DefDefSymbol)(given ctx: Context): Signature
 
   /** Symbol representing a value definition. This includes `val`, `lazy val`, `var`, `object` and parameter definitions. */
   type ValDefSymbol <: TermSymbol
 
-  def matchValDefSymbol(symbol: Symbol)(given ctx: Context): Option[ValDefSymbol]
+  def isValDefSymbol(symbol: Symbol)(given ctx: Context): Boolean
 
   /** The class symbol of the companion module class */
   def ValDefSymbol_moduleClass(self: ValDefSymbol)(given ctx: Context): Option[ClassDefSymbol]
@@ -1332,12 +1332,12 @@ trait CompilerInterface {
   /** Symbol representing a bind definition. */
   type BindSymbol <: TermSymbol
 
-  def matchBindSymbol(symbol: Symbol)(given ctx: Context): Option[BindSymbol]
+  def isBindSymbol(symbol: Symbol)(given ctx: Context): Boolean
 
   /** No symbol available. */
   type NoSymbol <: Symbol
 
-  def matchNoSymbol(symbol: Symbol)(given ctx: Context): Boolean
+  def isNoSymbol(symbol: Symbol)(given ctx: Context): Boolean
 
   //
   // FLAGS

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

@@ -365,14 +365,13 @@ trait Printers
         case OmitSelector(id) => this += "OmitSelector(" += id += ")"
       }
 
-      def visitSymbol(x: Symbol): Buffer = x match {
-        case IsPackageDefSymbol(x) => this += "IsPackageDefSymbol(<" += x.fullName += ">)"
-        case IsClassDefSymbol(x) => this += "IsClassDefSymbol(<" += x.fullName += ">)"
-        case IsDefDefSymbol(x) => this += "IsDefDefSymbol(<" += x.fullName += ">)"
-        case IsValDefSymbol(x) => this += "IsValDefSymbol(<" += x.fullName += ">)"
-        case IsTypeDefSymbol(x) => this += "IsTypeDefSymbol(<" += x.fullName += ">)"
-        case NoSymbol() => this += "NoSymbol()"
-      }
+      def visitSymbol(x: Symbol): Buffer =
+        if x.isPackageDef  then this += "IsPackageDefSymbol(<" += x.fullName += ">)"
+        else if x.isClassDef then this += "IsClassDefSymbol(<" += x.fullName += ">)"
+        else if x.isDefDef then this += "IsDefDefSymbol(<" += x.fullName += ">)"
+        else if x.isValDef then this += "IsValDefSymbol(<" += x.fullName += ">)"
+        else if x.isTypeDef then this += "IsTypeDefSymbol(<" += x.fullName += ">)"
+        else { assert(x.isNoSymbol); this += "NoSymbol()" }
 
       def +=(x: Boolean): Buffer = { sb.append(x); this }
       def +=(x: Byte): Buffer = { sb.append(x); this }
@@ -1272,24 +1271,23 @@ trait Printers
 
       def printParamDef(arg: ValDef)(given elideThis: Option[Symbol]): Unit = {
         val name = arg.name
-        arg.symbol.owner match {
-          case IsDefDefSymbol(sym) if sym.name == "<init>" =>
-            val ClassDef(_, _, _, _, _, body) = sym.owner.tree
-            body.collectFirst {
-              case IsValDef(vdef @ ValDef(`name`, _, _)) if vdef.symbol.flags.is(Flags.ParamAccessor) =>
-                if (!vdef.symbol.flags.is(Flags.Local)) {
-                  var printedPrefix = false
-                  if (vdef.symbol.flags.is(Flags.Override)) {
-                    this += "override "
-                    printedPrefix = true
-                  }
-                  printedPrefix  |= printProtectedOrPrivate(vdef)
-                  if (vdef.symbol.flags.is(Flags.Mutable)) this += highlightValDef("var ")
-                  else if (printedPrefix || !vdef.symbol.flags.is(Flags.CaseAcessor)) this += highlightValDef("val ")
+        val sym = arg.symbol.owner
+        if sym.isDefDef && sym.name == "<init>" then
+          val ClassDef(_, _, _, _, _, body) = sym.owner.tree
+          body.collectFirst {
+            case IsValDef(vdef @ ValDef(`name`, _, _)) if vdef.symbol.flags.is(Flags.ParamAccessor) =>
+              if (!vdef.symbol.flags.is(Flags.Local)) {
+                var printedPrefix = false
+                if (vdef.symbol.flags.is(Flags.Override)) {
+                  this += "override "
+                  printedPrefix = true
                 }
-            }
-          case _ =>
-        }
+                printedPrefix  |= printProtectedOrPrivate(vdef)
+                if (vdef.symbol.flags.is(Flags.Mutable)) this += highlightValDef("var ")
+                else if (printedPrefix || !vdef.symbol.flags.is(Flags.CaseAcessor)) this += highlightValDef("val ")
+              }
+          }
+        end if
 
         this += highlightValDef(name) += ": "
         printTypeTree(arg.tpt)
@@ -1421,10 +1419,10 @@ trait Printers
             case Type.IsTypeRef(tpe) if tpe.typeSymbol.fullName == "scala.runtime.Null$" || tpe.typeSymbol.fullName == "scala.runtime.Nothing$" =>
               // scala.runtime.Null$ and scala.runtime.Nothing$ are not modules, those are their actual names
               printType(tpe)
-            case Type.IsTermRef(tpe) if tpe.termSymbol.isClass && tpe.termSymbol.name.endsWith("$") =>
+            case Type.IsTermRef(tpe) if tpe.termSymbol.isClassDef && tpe.termSymbol.name.endsWith("$") =>
               printType(tpe)
               this += ".type"
-            case Type.IsTypeRef(tpe) if tpe.typeSymbol.isClass && tpe.typeSymbol.name.endsWith("$") =>
+            case Type.IsTypeRef(tpe) if tpe.typeSymbol.isClassDef && tpe.typeSymbol.name.endsWith("$") =>
               printType(tpe)
               this += ".type"
             case tpe @ Type.TermRef(sym, _) =>
@@ -1528,10 +1526,10 @@ trait Printers
                 if (packagePath != "")
                   this += packagePath += "."
               }
-            case Type.IsTermRef(prefix) if prefix.termSymbol.isClass =>
+            case Type.IsTermRef(prefix) if prefix.termSymbol.isClassDef =>
               printType(prefix)
               this += "#"
-            case Type.IsTypeRef(prefix) if prefix.typeSymbol.isClass =>
+            case Type.IsTypeRef(prefix) if prefix.typeSymbol.isClassDef =>
               printType(prefix)
               this += "#"
             case IsType(Type.ThisType(Type.TermRef(cdef, _))) if elideThis.nonEmpty && cdef == elideThis.get =>