Remove redundant Symbol.asXYZ methods

Author: nicolasstucki

community-build/community-projects/semanticdb

@@ -42,36 +42,6 @@ trait SymbolOps extends Core { selfSymbolOps: FlagsOps =>
     /** The comment for this symbol, if any */
     def comment(given ctx: Context): Option[Comment] = internal.Symbol_comment(self)
 
-    /** Unsafe cast as to PackageSymbol */
-    def asPackageDef(given ctx: Context): Symbol =
-      if self.isPackageDef then self
-      else throw new Exception("not a PackageDefSymbol")
-
-    /** Unsafe cast as to ClassSymbol */
-    def asClassDef(given ctx: Context): Symbol =
-      if self.isClassDef then self
-      else throw new Exception("not a class Symbol")
-
-    /** Unsafe cast as to DefSymbol */
-    def asDefDef(given ctx: Context): Symbol =
-      if self.isDefDef then self
-      else throw new Exception("not a def Symbol")
-
-    /** Unsafe cast as to ValSymbol */
-    def asValDef(given ctx: Context): Symbol =
-      if self.isValDef then self
-      else throw new Exception("not a val Symbol")
-
-    /** Unsafe cast as to TypeSymbol */
-    def asTypeDef(given ctx: Context): Symbol =
-      if self.isTypeDef then self
-      else throw new Exception("not a type Symbol")
-
-    /** Unsafe cast as to BindSymbol */
-    def asBindDef(given ctx: Context): Symbol =
-      if self.isBind then self
-      else throw new Exception("not a bind Symbol")
-
     /** Tree of this definition */
     def tree(given ctx: Context): Tree =
       internal.Symbol_tree(self)

community-build/community-projects/shapeless

@@ -37,46 +37,46 @@ object TypeToolbox {
   inline def caseFields[T]: List[String] = ${caseFieldsImpl('[T])}
   private def caseFieldsImpl(tp: Type[_])(given qctx: QuoteContext): Expr[List[String]] = {
     import qctx.tasty._
-    val fields = tp.unseal.symbol.asClassDef.caseFields.map(_.name)
+    val fields = tp.unseal.symbol.caseFields.map(_.name)
     Expr(fields)
   }
 
   inline def fieldIn[T](inline mem: String): String = ${fieldInImpl('[T], mem)}
   private def fieldInImpl(t: Type[_], mem: String)(given qctx: QuoteContext): Expr[String] = {
     import qctx.tasty._
-    val field = t.unseal.symbol.asClassDef.field(mem)
+    val field = t.unseal.symbol.field(mem)
     Expr(if field.isNoSymbol then "" else field.name)
   }
 
   inline def fieldsIn[T]: Seq[String] = ${fieldsInImpl('[T])}
   private def fieldsInImpl(t: Type[_])(given qctx: QuoteContext): Expr[Seq[String]] = {
     import qctx.tasty._
-    val fields = t.unseal.symbol.asClassDef.fields
+    val fields = t.unseal.symbol.fields
     Expr(fields.map(_.name).toList)
   }
 
   inline def methodIn[T](inline mem: String): Seq[String] = ${methodInImpl('[T], mem)}
   private def methodInImpl(t: Type[_], mem: String)(given qctx: QuoteContext): Expr[Seq[String]] = {
     import qctx.tasty._
-    Expr(t.unseal.symbol.asClassDef.classMethod(mem).map(_.name))
+    Expr(t.unseal.symbol.classMethod(mem).map(_.name))
   }
 
   inline def methodsIn[T]: Seq[String] = ${methodsInImpl('[T])}
   private def methodsInImpl(t: Type[_])(given qctx: QuoteContext): Expr[Seq[String]] = {
     import qctx.tasty._
-    Expr(t.unseal.symbol.asClassDef.classMethods.map(_.name))
+    Expr(t.unseal.symbol.classMethods.map(_.name))
   }
 
   inline def method[T](inline mem: String): Seq[String] = ${methodImpl('[T], mem)}
   private def methodImpl(t: Type[_], mem: String)(given qctx: QuoteContext): Expr[Seq[String]] = {
     import qctx.tasty._
-    Expr(t.unseal.symbol.asClassDef.method(mem).map(_.name))
+    Expr(t.unseal.symbol.method(mem).map(_.name))
   }
 
   inline def methods[T]: Seq[String] = ${methodsImpl('[T])}
   private def methodsImpl(t: Type[_])(given qctx: QuoteContext): Expr[Seq[String]] = {
     import qctx.tasty._
-    Expr(t.unseal.symbol.asClassDef.methods.map(_.name))
+    Expr(t.unseal.symbol.methods.map(_.name))
   }
 
   inline def typeTag[T](x: T): String = ${typeTagImpl('[T])}
@@ -89,7 +89,7 @@ object TypeToolbox {
   inline def companion[T1, T2]: Boolean = ${companionImpl('[T1], '[T2])}
   private def companionImpl(t1: Type[_], t2: Type[_])(given qctx: QuoteContext): Expr[Boolean] = {
     import qctx.tasty._
-    val res = t1.unseal.symbol.asClassDef.companionModule == t2.unseal.symbol
+    val res = t1.unseal.symbol.companionModule == t2.unseal.symbol
     Expr(res)
   }
 

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

@@ -29,11 +29,11 @@ class Interpreter[R <: Reflection & Singleton](reflect0: R) extends TreeInterpre
             }
 
             // println(method)
-            val symbol = sym.asClassDef.methods.find(_.name == method.getName).get
+            val symbol = sym.methods.find(_.name == method.getName).get
 
             if (symbol.isDefinedInCurrentRun) {
               val argsList = if (args == null) Nil else args.toList
-              interpretCall(this, symbol.asDefDef, argsList).asInstanceOf[Object]
+              interpretCall(this, symbol, argsList).asInstanceOf[Object]
             }
             else {
               assert(method.getClass == classOf[Object])
@@ -73,7 +73,7 @@ class Interpreter[R <: Reflection & Singleton](reflect0: R) extends TreeInterpre
           jvmReflection.interpretStaticVal(fn.symbol.owner, fn.symbol)
         case _ =>
           if (fn.symbol.flags.is(Flags.Object))
-            jvmReflection.loadModule(fn.symbol.asValDef.moduleClass)
+            jvmReflection.loadModule(fn.symbol.moduleClass)
           else
             jvmReflection.interpretStaticVal(fn.symbol.owner, fn.symbol)
       }

tests/run-macros/gestalt-type-toolbox-reflect/Macro_1.scala

@@ -79,7 +79,7 @@ class JVMReflection[R <: Reflection & Singleton](val reflect: R) {
   }
 
   private def paramsSig(sym: Symbol): List[Class[_]] = {
-    sym.asDefDef.signature.paramSigs.collect {
+    sym.signature.paramSigs.collect {
       case param: String =>
         def javaArraySig(name: String): String = {
           if (name.endsWith("[]")) "[" + javaArraySig(name.dropRight(2))