diff --git a/community-build/community-projects/semanticdb b/community-build/community-projects/semanticdb
index 856d0157fa98..ffd808fccc43 160000
--- a/community-build/community-projects/semanticdb
+++ b/community-build/community-projects/semanticdb
@@ -1 +1 @@
-Subproject commit 856d0157fa981f2796fbc058bdbc6828a9132d03
+Subproject commit ffd808fccc43b0ddf80ad3f4b54a9bc5aac561ef
diff --git a/community-build/community-projects/shapeless b/community-build/community-projects/shapeless
index 7c1fdd742c3c..8b417eb81023 160000
--- a/community-build/community-projects/shapeless
+++ b/community-build/community-projects/shapeless
@@ -1 +1 @@
-Subproject commit 7c1fdd742c3c2724d534c0a8ab82ec281b158b1e
+Subproject commit 8b417eb810236cacb0f15cf0bbd2d7f819415cf4
diff --git a/community-build/community-projects/sourcecode b/community-build/community-projects/sourcecode
index 380cdad97e5a..3682622fce95 160000
--- a/community-build/community-projects/sourcecode
+++ b/community-build/community-projects/sourcecode
@@ -1 +1 @@
-Subproject commit 380cdad97e5ac27f79a8e33b3edd86657833b5a2
+Subproject commit 3682622fce955fb09c76597be8f24872ab10a87d
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala b/compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala
index f88c9416f033..d9c3966fcd09 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala
@@ -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
 
@@ -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 = {
@@ -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)
 
@@ -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))
@@ -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))
@@ -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))
@@ -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
@@ -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 =
@@ -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, butNot = Enum | Module))
+    FromSymbol.definitionFromSym(self)
+  }
+
+  def Symbol_pattern(self: Symbol)(given ctx: Context): Pattern = {
+    assert(self.is(Case, butNot = Enum | Module))
+    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)
@@ -1506,53 +1516,32 @@ 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
-
-  type ClassDefSymbol = core.Symbols.ClassSymbol
-
-  def matchClassDefSymbol(symbol: Symbol)(given Context): Option[ClassDefSymbol] =
-    if (symbol.isClass) Some(symbol.asClass) else None
-
-  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
@@ -1560,94 +1549,55 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   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 Symbol_isType(symbol: Symbol)(given Context): Boolean =
+    symbol.isType
 
-  def matchTypeBindSymbol(symbol: Symbol)(given Context): Option[TypeBindSymbol] =
-    if (symbol.isType && symbol.is(core.Flags.Case)) Some(symbol.asType) else None
+  def Symbol_isTerm(symbol: Symbol)(given Context): Boolean =
+    symbol.isTerm
 
-  def TypeBindSymbol_tree(self: TypeBindSymbol)(given Context): TypeBind =
-    FromSymbol.typeBindFromSym(self)
+  def Symbol_isPackageDef(symbol: Symbol)(given ctx: Context): Boolean =
+    symbol.is(Flags.Package)
 
-  type TermSymbol = core.Symbols.TermSymbol
+  def Symbol_isClassDef(symbol: Symbol)(given Context): Boolean =
+    symbol.isClass
 
-  def matchTermSymbol(symbol: Symbol)(given Context): Option[TermSymbol] =
-    if (symbol.isTerm) Some(symbol.asTerm) else None
+  def Symbol_isTypeDef(symbol: Symbol)(given ctx: Context): Boolean =
+    symbol.isType && !symbol.isClass && !symbol.is(Flags.Case)
 
-  type DefDefSymbol = core.Symbols.TermSymbol
+  def Symbol_isValDef(symbol: Symbol)(given Context): Boolean =
+    symbol.isTerm && !symbol.is(core.Flags.Method) && !symbol.is(core.Flags.Case/*, FIXME add this check and fix sourcecode butNot = Enum | Module*/)
 
-  def matchDefDefSymbol(symbol: Symbol)(given Context): Option[DefDefSymbol] =
-    if (symbol.isTerm && symbol.is(core.Flags.Method)) Some(symbol.asTerm) else None
+  def Symbol_isDefDef(symbol: Symbol)(given Context): Boolean =
+    symbol.is(core.Flags.Method)
 
-  def DefDefSymbol_tree(self: DefDefSymbol)(given Context): DefDef =
-    FromSymbol.defDefFromSym(self)
+  def Symbol_isBind(symbol: Symbol)(given Context): Boolean =
+    symbol.is(core.Flags.Case, butNot = Enum | Module) && !symbol.isClass
 
-  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 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
@@ -1792,7 +1742,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
diff --git a/library/src/scala/tasty/reflect/CompilerInterface.scala b/library/src/scala/tasty/reflect/CompilerInterface.scala
index 34fdd1d8df8f..194be39a2984 100644
--- a/library/src/scala/tasty/reflect/CompilerInterface.scala
+++ b/library/src/scala/tasty/reflect/CompilerInterface.scala
@@ -104,17 +104,7 @@ import scala.runtime.quoted.Unpickler
  *
  *  +- Constant
  *
- *  +- Symbol --+- PackageDefSymbol
- *              |
- *              +- TypeSymbol -+- ClassDefSymbol
- *              |              +- TypeDefSymbol
- *              |              +- TypeBindSymbol
- *              |
- *              +- TermSymbol -+- DefDefSymbol
- *              |              +- ValDefSymbol
- *              |              +- BindSymbol
- *              |
- *              +- NoSymbol
+ *  +- Symbol
  *
  *  +- Flags
  *
@@ -240,7 +230,7 @@ trait CompilerInterface {
 
   def PackageDef_owner(self: PackageDef)(given ctx: Context): PackageDef
   def PackageDef_members(self: PackageDef)(given ctx: Context): List[Statement]
-  def PackageDef_symbol(self: PackageDef)(given ctx: Context): PackageDefSymbol
+  def PackageDef_symbol(self: PackageDef)(given ctx: Context): Symbol
 
   /** Tree representing a class definition. This includes annonymus class definitions and the class of a module object */
   type ClassDef <: Definition
@@ -252,7 +242,7 @@ trait CompilerInterface {
   def ClassDef_derived(self: ClassDef)(given ctx: Context): List[TypeTree]
   def ClassDef_self(self: ClassDef)(given ctx: Context): Option[ValDef]
   def ClassDef_body(self: ClassDef)(given ctx: Context): List[Statement]
-  def ClassDef_symbol(self: ClassDef)(given ctx: Context): ClassDefSymbol
+  def ClassDef_symbol(self: ClassDef)(given ctx: Context): Symbol
 
   def ClassDef_copy(original: ClassDef)(name: String, constr: DefDef, parents: List[Tree/* Term | TypeTree */], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement])(given ctx: Context): ClassDef
 
@@ -262,9 +252,9 @@ trait CompilerInterface {
   def matchTypeDef(tree: Tree)(given ctx: Context): Option[TypeDef]
 
   def TypeDef_rhs(self: TypeDef)(given ctx: Context): Tree /*TypeTree | TypeBoundsTree*/
-  def TypeDef_symbol(self: TypeDef)(given ctx: Context): TypeDefSymbol
+  def TypeDef_symbol(self: TypeDef)(given ctx: Context): Symbol
 
-  def TypeDef_apply(symbol: TypeDefSymbol)(given ctx: Context): TypeDef
+  def TypeDef_apply(symbol: Symbol)(given ctx: Context): TypeDef
   def TypeDef_copy(original: TypeDef)(name: String, rhs: Tree /*TypeTree | TypeBoundsTree*/)(given ctx: Context): TypeDef
 
   /** Tree representing a method definition in the source code */
@@ -276,9 +266,9 @@ trait CompilerInterface {
   def DefDef_paramss(self: DefDef)(given ctx: Context): List[List[ValDef]]
   def DefDef_returnTpt(self: DefDef)(given ctx: Context): TypeTree
   def DefDef_rhs(self: DefDef)(given ctx: Context): Option[Term]
-  def DefDef_symbol(self: DefDef)(given ctx: Context): DefDefSymbol
+  def DefDef_symbol(self: DefDef)(given ctx: Context): Symbol
 
-  def DefDef_apply(symbol: DefDefSymbol, rhsFn: List[Type] => List[List[Term]] => Option[Term])(given ctx: Context): DefDef
+  def DefDef_apply(symbol: Symbol, rhsFn: List[Type] => List[List[Term]] => Option[Term])(given ctx: Context): DefDef
   def DefDef_copy(original: DefDef)(name: String, typeParams: List[TypeDef], paramss: List[List[ValDef]], tpt: TypeTree, rhs: Option[Term])(given ctx: Context): DefDef
 
   /** Tree representing a value definition in the source code This inclues `val`, `lazy val`, `var`, `object` and parameter definitions. */
@@ -288,9 +278,9 @@ trait CompilerInterface {
 
   def ValDef_tpt(self: ValDef)(given ctx: Context): TypeTree
   def ValDef_rhs(self: ValDef)(given ctx: Context): Option[Term]
-  def ValDef_symbol(self: ValDef)(given ctx: Context): ValDefSymbol
+  def ValDef_symbol(self: ValDef)(given ctx: Context): Symbol
 
-  def ValDef_apply(symbol: ValDefSymbol, rhs: Option[Term])(given ctx: Context): ValDef
+  def ValDef_apply(symbol: Symbol, rhs: Option[Term])(given ctx: Context): ValDef
   def ValDef_copy(original: ValDef)(name: String, tpt: TypeTree, rhs: Option[Term])(given ctx: Context): ValDef
 
   /** Tree representing an expression in the source code */
@@ -352,7 +342,7 @@ trait CompilerInterface {
 
   def This_id(self: This)(given ctx: Context): Option[Id]
 
-  def This_apply(cls: ClassDefSymbol)(given ctx: Context): This
+  def This_apply(cls: Symbol)(given ctx: Context): This
   def This_copy(original: Tree)(qual: Option[Id])(given ctx: Context): This
 
   /** Tree representing `new` in the source code */
@@ -867,7 +857,7 @@ trait CompilerInterface {
 
   def Type_simplified(self: Type)(given ctx: Context): Type
 
-  def Type_classSymbol(self: Type)(given ctx: Context): Option[ClassDefSymbol] // TODO remove Option and use NoSymbol
+  def Type_classSymbol(self: Type)(given ctx: Context): Option[Symbol] // TODO remove Option and use NoSymbol
 
   def Type_typeSymbol(self: Type)(given ctx: Context): Symbol
 
@@ -878,7 +868,7 @@ trait CompilerInterface {
   def Type_memberType(self: Type)(member: Symbol)(given ctx: Context): Type
 
   /** Is this type an instance of a non-bottom subclass of the given class `cls`? */
-  def Type_derivesFrom(self: Type)(cls: ClassDefSymbol)(given ctx: Context): Boolean
+  def Type_derivesFrom(self: Type)(cls: Symbol)(given ctx: Context): Boolean
 
   /** Is this type a function type?
    *
@@ -1206,6 +1196,10 @@ trait CompilerInterface {
   /** Flags of this symbol */
   def Symbol_flags(self: Symbol)(given ctx: Context): Flags
 
+  def Symbol_tree(self: Symbol)(given ctx: Context): Tree
+
+  def Symbol_pattern(self: Symbol)(given ctx: Context): Pattern
+
   def Symbol_isLocalDummy(self: Symbol)(given ctx: Context): Boolean
 
   def Symbol_isRefinementClass(self: Symbol)(given ctx: Context): Boolean
@@ -1245,115 +1239,67 @@ trait CompilerInterface {
 
   def Symbol_isDefinedInCurrentRun(self: Symbol)(given ctx: Context): Boolean
 
-  /** Symbol of a package definition */
-  type PackageDefSymbol <: Symbol
-
-  def matchPackageDefSymbol(symbol: Symbol)(given ctx: Context): Option[PackageDefSymbol]
-
-  def PackageDefSymbol_tree(self: PackageDefSymbol)(given ctx: Context): PackageDef
-
-  type TypeSymbol <: Symbol
-
-  def matchTypeSymbol(symbol: Symbol)(given ctx: Context): Option[TypeSymbol]
-
-  /** 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]
-
-  /** ClassDef tree of this definition */
-  def ClassDefSymbol_tree(self: ClassDefSymbol)(given ctx: Context): ClassDef
-
   /** Fields directly declared in the class */
-  def ClassDefSymbol_fields(self: Symbol)(given ctx: Context): List[Symbol]
+  def Symbol_fields(self: Symbol)(given ctx: Context): List[Symbol]
 
   /** Field with the given name directly declared in the class */
-  def ClassDefSymbol_field(self: Symbol)(name: String)(given ctx: Context): Option[Symbol]
+  def Symbol_field(self: Symbol)(name: String)(given ctx: Context): Symbol
 
   /** Get non-private named methods defined directly inside the class */
-  def ClassDefSymbol_classMethod(self: Symbol)(name: String)(given ctx: Context): List[DefDefSymbol]
+  def Symbol_classMethod(self: Symbol)(name: String)(given ctx: Context): List[Symbol]
 
   /** Get all non-private methods defined directly inside the class, excluding constructors */
-  def ClassDefSymbol_classMethods(self: Symbol)(given ctx: Context): List[DefDefSymbol]
+  def Symbol_classMethods(self: Symbol)(given ctx: Context): List[Symbol]
 
   /** Get named non-private methods declared or inherited */
-  def ClassDefSymbol_method(self: Symbol)(name: String)(given ctx: Context): List[DefDefSymbol]
+  def Symbol_method(self: Symbol)(name: String)(given ctx: Context): List[Symbol]
 
   /** Get all non-private methods declared or inherited */
-  def ClassDefSymbol_methods(self: Symbol)(given ctx: Context): List[DefDefSymbol]
+  def Symbol_methods(self: Symbol)(given ctx: Context): List[Symbol]
 
   /** Fields of a case class type -- only the ones declared in primary constructor */
-  def ClassDefSymbol_caseFields(self: Symbol)(given ctx: Context): List[ValDefSymbol]
+  def Symbol_caseFields(self: Symbol)(given ctx: Context): List[Symbol]
 
-  /** The class symbol of the companion module class */
-  def ClassDefSymbol_companionClass(self: Symbol)(given ctx: Context): Option[ClassDefSymbol]
-
-  /** The symbol of the companion module */
-  def ClassDefSymbol_companionModule(self: Symbol)(given ctx: Context): Option[ValDefSymbol]
+  def Symbol_of(fullName: String)(given ctx: Context): Symbol
 
-  /** The symbol of the class of the companion module */
-  def ClassDefSymbol_moduleClass(self: Symbol)(given ctx: Context): Option[Symbol]
+  def Symbol_isTypeParam(self: Symbol)(given ctx: Context): Boolean
 
-  def ClassDefSymbol_of(fullName: String)(given ctx: Context): ClassDefSymbol
+  def Symbol_isPackageDef(symbol: Symbol)(given ctx: Context): Boolean
 
-  /** Symbol of a type (parameter or member) definition. */
-  type TypeDefSymbol <: TypeSymbol
+  /** Is this the definition of a type? */
+  def Symbol_isType(symbol: Symbol)(given ctx: Context): Boolean
 
-  def matchTypeDefSymbol(symbol: Symbol)(given ctx: Context): Option[TypeDefSymbol]
+  /** Is this the definition of a term? */
+  def Symbol_isTerm(symbol: Symbol)(given ctx: Context): Boolean
 
-  def TypeDefSymbol_isTypeParam(self: TypeDefSymbol)(given ctx: Context): Boolean
+  /** Is this the definition of a ClassDef tree? */
+  def Symbol_isClassDef(symbol: Symbol)(given ctx: Context): Boolean
 
-  /** TypeDef tree of this definition */
-  def TypeDefSymbol_tree(self: TypeDefSymbol)(given ctx: Context): TypeDef
+  /** Is this the definition of a TypeDef tree? */
+  def Symbol_isTypeDef(symbol: Symbol)(given ctx: Context): Boolean
 
-  /** Symbol representing a bind definition. */
-  type TypeBindSymbol <: TypeSymbol
+  /** Is this the definition of a DefDef tree? */
+  def Symbol_isDefDef(symbol: Symbol)(given ctx: Context): Boolean
 
-  def matchTypeBindSymbol(symbol: Symbol)(given ctx: Context): Option[TypeBindSymbol]
+  /** Is this the definition of a ValDef tree? */
+  def Symbol_isValDef(symbol: Symbol)(given ctx: Context): Boolean
 
-  /** TypeBind pattern of this definition */
-  def TypeBindSymbol_tree(self: TypeBindSymbol)(given ctx: Context): TypeBind
-
-  type TermSymbol <: Symbol
-
-  def matchTermSymbol(symbol: Symbol)(given ctx: Context): Option[TermSymbol]
-
-  /** Symbol representing a method definition. */
-  type DefDefSymbol <: TermSymbol
-
-  def matchDefDefSymbol(symbol: Symbol)(given ctx: Context): Option[DefDefSymbol]
-
-  /** DefDef tree of this definition */
-  def DefDefSymbol_tree(self: DefDefSymbol)(given ctx: Context): DefDef
+  /** Is this the definition of a Bind pattern? */
+  def Symbol_isBind(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]
-
-  /** ValDef tree of this definition */
-  def ValDefSymbol_tree(self: ValDefSymbol)(given ctx: Context): ValDef
+  def Symbol_signature(self: Symbol)(given ctx: Context): Signature
 
   /** The class symbol of the companion module class */
-  def ValDefSymbol_moduleClass(self: ValDefSymbol)(given ctx: Context): Option[ClassDefSymbol]
-
-  def ValDefSymbol_companionClass(self: ValDefSymbol)(given ctx: Context): Option[ClassDefSymbol]
+  def Symbol_moduleClass(self: Symbol)(given ctx: Context): Symbol
 
-  /** Symbol representing a bind definition. */
-  type BindSymbol <: TermSymbol
+  /** The symbol of the companion class */
+  def Symbol_companionClass(self: Symbol)(given ctx: Context): Symbol
 
-  def matchBindSymbol(symbol: Symbol)(given ctx: Context): Option[BindSymbol]
-
-  /** Bind pattern of this definition */
-  def BindSymbol_tree(self: BindSymbol)(given ctx: Context): Bind
-
-  /** No symbol available. */
-  type NoSymbol <: Symbol
+  /** The symbol of the companion module */
+  def Symbol_companionModule(self: Symbol)(given ctx: Context): Symbol
 
-  def matchNoSymbol(symbol: Symbol)(given ctx: Context): Boolean
+  def Symbol_noSymbol(given ctx: Context): Symbol
 
   //
   // FLAGS
@@ -1469,7 +1415,7 @@ trait CompilerInterface {
   def Definitions_Array_length: Symbol
   def Definitions_Array_update: Symbol
 
-  def Definitions_RepeatedParamClass: ClassDefSymbol
+  def Definitions_RepeatedParamClass: Symbol
 
   def Definitions_OptionClass: Symbol
   def Definitions_NoneModule: Symbol
diff --git a/library/src/scala/tasty/reflect/Core.scala b/library/src/scala/tasty/reflect/Core.scala
index 36bb20ebc8b7..d046b21847a5 100644
--- a/library/src/scala/tasty/reflect/Core.scala
+++ b/library/src/scala/tasty/reflect/Core.scala
@@ -101,17 +101,7 @@ package scala.tasty.reflect
  *
  *  +- Constant
  *
- *  +- Symbol --+- PackageDefSymbol
- *              |
- *              +- TypeSymbol -+- ClassDefSymbol
- *              |              +- TypeDefSymbol
- *              |              +- TypeBindSymbol
- *              |
- *              +- TermSymbol -+- DefDefSymbol
- *              |              +- ValDefSymbol
- *              |              +- BindSymbol
- *              |
- *              +- NoSymbol
+ *  +- Symbol
  *
  *  +- Flags
  *
@@ -420,36 +410,6 @@ trait Core {
    */
   type Symbol = internal.Symbol
 
-    /** Symbol of a package definition */
-    type PackageDefSymbol = internal.PackageDefSymbol
-
-    /** Symbol representing a type definition. */
-    type TypeSymbol = internal.TypeSymbol
-
-      /** Symbol of a class definition. This includes anonymous class definitions and the class of a module object. */
-      type ClassDefSymbol = internal.ClassDefSymbol
-
-      /** Symbol of a type (parameter or member) definition. */
-      type TypeDefSymbol = internal.TypeDefSymbol
-
-      /** Symbol representing a type bind definition. */
-      type TypeBindSymbol = internal.TypeBindSymbol
-
-    /** Symbol representing a term definition. */
-    type TermSymbol = internal.TermSymbol
-
-      /** Symbol representing a method definition. */
-      type DefDefSymbol = internal.DefDefSymbol
-
-      /** Symbol representing a value definition. This includes `val`, `lazy val`, `var`, `object` and parameter definitions. */
-      type ValDefSymbol = internal.ValDefSymbol
-
-      /** Symbol representing a bind definition. */
-      type BindSymbol = internal.BindSymbol
-
-    /** No symbol available. */
-    type NoSymbol = internal.NoSymbol
-
   /** FlagSet of a Symbol */
   type Flags = internal.Flags
 
diff --git a/library/src/scala/tasty/reflect/Printers.scala b/library/src/scala/tasty/reflect/Printers.scala
index e1ce0ae46175..afb04ef51f48 100644
--- a/library/src/scala/tasty/reflect/Printers.scala
+++ b/library/src/scala/tasty/reflect/Printers.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.asClassDef.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 =>
diff --git a/library/src/scala/tasty/reflect/StandardDefinitions.scala b/library/src/scala/tasty/reflect/StandardDefinitions.scala
index a9f7b07b67b1..7a3303b1acc8 100644
--- a/library/src/scala/tasty/reflect/StandardDefinitions.scala
+++ b/library/src/scala/tasty/reflect/StandardDefinitions.scala
@@ -109,7 +109,7 @@ trait StandardDefinitions extends Core {
     /** A dummy class symbol that is used to indicate repeated parameters
       *  compiled by the Scala compiler.
       */
-    def RepeatedParamClass: ClassDefSymbol = internal.Definitions_RepeatedParamClass
+    def RepeatedParamClass: Symbol = internal.Definitions_RepeatedParamClass
 
     /** The class symbol of class `scala.Option`. */
     def OptionClass: Symbol = internal.Definitions_OptionClass
diff --git a/library/src/scala/tasty/reflect/SymbolOps.scala b/library/src/scala/tasty/reflect/SymbolOps.scala
index e84f6d84778f..98e8b8276e21 100644
--- a/library/src/scala/tasty/reflect/SymbolOps.scala
+++ b/library/src/scala/tasty/reflect/SymbolOps.scala
@@ -2,9 +2,17 @@ package scala.tasty
 package reflect
 
 /** Tasty reflect symbol */
-trait SymbolOps extends Core {
+trait SymbolOps extends Core { selfSymbolOps: FlagsOps =>
 
-  // Symbol
+  object Symbol {
+    /** The class Symbol of a global class definition */
+    def classSymbol(fullName: String)(given ctx: Context): Symbol =
+      internal.Symbol_of(fullName)
+
+    /** Definition not available */
+    def noSymbol(given ctx: Context): Symbol =
+      internal.Symbol_noSymbol
+  }
 
   implicit class SymbolAPI(self: Symbol) {
 
@@ -34,41 +42,20 @@ trait SymbolOps extends Core {
     /** The comment for this symbol, if any */
     def comment(given ctx: Context): Option[Comment] = internal.Symbol_comment(self)
 
-    /** Unsafe cast as to PackageSymbol. Use IsPackageSymbol to safely check and cast to PackageSymbol */
-    def asPackageDef(given ctx: Context): PackageDefSymbol = self match {
-      case IsPackageDefSymbol(self) => self
-      case _ => throw new Exception("not a PackageDefSymbol")
-    }
-
-    /** Unsafe cast as to ClassSymbol. Use IsClassDefSymbol to safely check and cast to ClassSymbol */
-    def asClassDef(given ctx: Context): ClassDefSymbol = self match {
-      case IsClassDefSymbol(self) => self
-      case _ => throw new Exception("not a ClassDefSymbol")
-    }
-
-    /** Unsafe cast as to DefSymbol. Use IsDefDefSymbol to safely check and cast to DefSymbol */
-    def asDefDef(given ctx: Context): DefDefSymbol = self match {
-      case IsDefDefSymbol(self) => self
-      case _ => throw new Exception("not a DefDefSymbol")
-    }
-
-    /** Unsafe cast as to ValSymbol. Use IsValDefSymbol to safely check and cast to ValSymbol */
-    def asValDef(given ctx: Context): ValDefSymbol = self match {
-      case IsValDefSymbol(self) => self
-      case _ => throw new Exception("not a ValDefSymbol")
-    }
-
-    /** Unsafe cast as to TypeSymbol. Use IsTypeDefSymbol to safely check and cast to TypeSymbol */
-    def asTypeDef(given ctx: Context): TypeDefSymbol = self match {
-      case IsTypeDefSymbol(self) => self
-      case _ => throw new Exception("not a TypeDefSymbol")
-    }
-
-    /** Unsafe cast as to BindSymbol. Use IsBindSymbol to safely check and cast to BindSymbol */
-    def asBindDef(given ctx: Context): BindSymbol = self match {
-      case IsBindSymbol(self) => self
-      case _ => throw new Exception("not a BindSymbol")
-    }
+    /** Tree of this definition
+     *
+     * if this symbol `isPackageDef` it will return a `PackageDef`,
+     * if this symbol `isClassDef` it will return a `ClassDef`,
+     * if this symbol `isTypeDef` it will return a `TypeDef`,
+     * if this symbol `isValDef` it will return a `ValDef`,
+     * if this symbol `isDefDef` it will return a `DefDef`
+     */
+    def tree(given ctx: Context): Tree =
+      internal.Symbol_tree(self)
+
+    /** Pattern of this definition */
+    def pattern(given ctx: Context): Pattern =
+      internal.Symbol_pattern(self)
 
     /** Annotations attached to this symbol */
     def annots(given ctx: Context): List[Term] = internal.Symbol_annots(self)
@@ -83,181 +70,82 @@ trait SymbolOps extends Core {
     def isAbstractType(given ctx: Context): Boolean = internal.Symbol_isAbstractType(self)
     def isClassConstructor(given ctx: Context): Boolean = internal.Symbol_isClassConstructor(self)
 
-    def isType(given ctx: Context): Boolean = internal.matchTypeSymbol(self).isDefined
-    def isTerm(given ctx: Context): Boolean = internal.matchTermSymbol(self).isDefined
-    def isValDef(given ctx: Context): Boolean = internal.matchValDefSymbol(self).isDefined
-    def isDefDef(given ctx: Context): Boolean = internal.matchDefDefSymbol(self).isDefined
-    def isClass(given ctx: Context): Boolean = internal.matchClassDefSymbol(self).isDefined
-  }
+    /** Is this the definition of a type? */
+    def isType(given ctx: Context): Boolean = internal.Symbol_isType(self)
 
-  // PackageSymbol
+    /** Is this the definition of a term? */
+    def isTerm(given ctx: Context): Boolean = internal.Symbol_isTerm(self)
 
-  object IsPackageDefSymbol {
-    def unapply(symbol: Symbol)(given ctx: Context): Option[PackageDefSymbol] =
-      internal.matchPackageDefSymbol(symbol)
-  }
+    /** Is this the definition of a PackageDef tree? */
+    def isPackageDef(given ctx: Context): Boolean = internal.Symbol_isPackageDef(self)
 
-  implicit class PackageDefSymbolAPI(self: PackageDefSymbol) {
-    def tree(given ctx: Context): PackageDef =
-      internal.PackageDefSymbol_tree(self)
-  }
+    /** Is this the definition of a ClassDef tree? */
+    def isClassDef(given ctx: Context): Boolean = internal.Symbol_isClassDef(self)
 
-  // TypeSymbol
+    /** Is this the definition of a TypeDef tree */
+    def isTypeDef(given ctx: Context): Boolean = internal.Symbol_isTypeDef(self)
 
-  object IsTypeSymbol {
-    def unapply(symbol: Symbol)(given ctx: Context): Option[TypeSymbol] =
-      internal.matchTypeSymbol(symbol)
-  }
+    /** Is this the definition of a ValDef tree? */
+    def isValDef(given ctx: Context): Boolean = internal.Symbol_isValDef(self)
 
-  // ClassSymbol
+    /** Is this the definition of a DefDef tree? */
+    def isDefDef(given ctx: Context): Boolean = internal.Symbol_isDefDef(self)
 
-  object IsClassDefSymbol {
-    def unapply(symbol: Symbol)(given ctx: Context): Option[ClassDefSymbol] =
-      internal.matchClassDefSymbol(symbol)
-  }
+    /** Is this the definition of a Bind pattern? */
+    def isBind(given ctx: Context): Boolean = internal.Symbol_isBind(self)
 
-  object ClassDefSymbol {
-    /** The ClassSymbol of a global class definition */
-    def of(fullName: String)(given ctx: Context): ClassDefSymbol =
-      internal.ClassDefSymbol_of(fullName)
-  }
+    /** Does this symbol represent a no definition? */
+    def isNoSymbol(given ctx: Context): Boolean = self == Symbol.noSymbol
 
-  implicit class ClassDefSymbolAPI(self: ClassDefSymbol) {
-    /** ClassDef tree of this defintion */
-    def tree(given ctx: Context): ClassDef =
-      internal.ClassDefSymbol_tree(self)
+    /** Does this symbol represent a definition? */
+    def exists(given ctx: Context): Boolean = self != Symbol.noSymbol
 
     /** Fields directly declared in the class */
     def fields(given ctx: Context): List[Symbol] =
-      internal.ClassDefSymbol_fields(self)
+      internal.Symbol_fields(self)
 
     /** Field with the given name directly declared in the class */
-    def field(name: String)(given ctx: Context): Option[Symbol] =
-      internal.ClassDefSymbol_field(self)(name)
+    def field(name: String)(given ctx: Context): Symbol =
+      internal.Symbol_field(self)(name)
 
     /** Get non-private named methods defined directly inside the class */
-    def classMethod(name: String)(given ctx: Context): List[DefDefSymbol] =
-      internal.ClassDefSymbol_classMethod(self)(name)
+    def classMethod(name: String)(given ctx: Context): List[Symbol] =
+      internal.Symbol_classMethod(self)(name)
 
     /** Get all non-private methods defined directly inside the class, exluding constructors */
-    def classMethods(given ctx: Context): List[DefDefSymbol] =
-      internal.ClassDefSymbol_classMethods(self)
+    def classMethods(given ctx: Context): List[Symbol] =
+      internal.Symbol_classMethods(self)
 
     /** Get named non-private methods declared or inherited */
-    def method(name: String)(given ctx: Context): List[DefDefSymbol] =
-      internal.ClassDefSymbol_method(self)(name)
+    def method(name: String)(given ctx: Context): List[Symbol] =
+      internal.Symbol_method(self)(name)
 
     /** Get all non-private methods declared or inherited */
-    def methods(given ctx: Context): List[DefDefSymbol] =
-      internal.ClassDefSymbol_methods(self)
+    def methods(given ctx: Context): List[Symbol] =
+      internal.Symbol_methods(self)
 
     /** Fields of a case class type -- only the ones declared in primary constructor */
-    def caseFields(given ctx: Context): List[ValDefSymbol] =
-      internal.ClassDefSymbol_caseFields(self)
-
-    /** The class symbol of the companion module class */
-    def companionClass(given ctx: Context): Option[ClassDefSymbol] =
-      internal.ClassDefSymbol_companionClass(self)
-
-    /** The symbol of the companion module */
-    def companionModule(given ctx: Context): Option[ValDefSymbol] =
-      internal.ClassDefSymbol_companionModule(self)
-
-    /** The symbol of the class of the companion module */
-    def moduleClass(given ctx: Context): Option[Symbol] =
-      internal.ClassDefSymbol_moduleClass(self)
-  }
-
-  // TypeSymbol
-
-  object IsTypeDefSymbol {
-    def unapply(symbol: Symbol)(given ctx: Context): Option[TypeDefSymbol] =
-      internal.matchTypeDefSymbol(symbol)
-  }
-
-  implicit class TypeDefSymbolAPI(self: TypeDefSymbol) {
-    /** TypeDef tree of this definition */
-    def tree(given ctx: Context): TypeDef =
-      internal.TypeDefSymbol_tree(self)
+    def caseFields(given ctx: Context): List[Symbol] =
+      internal.Symbol_caseFields(self)
 
     def isTypeParam(given ctx: Context): Boolean =
-      internal.TypeDefSymbol_isTypeParam(self)
-  }
-
-  // TypeBindSymbol
-
-  object IsTypeBindSymbol {
-    def unapply(symbol: Symbol)(given ctx: Context): Option[TypeBindSymbol] =
-      internal.matchTypeBindSymbol(symbol)
-  }
-
-  implicit class TypeBindSymbolAPI(self: TypeBindSymbol) {
-    /** TypeBind pattern of this definition */
-    def tree(given ctx: Context): TypeBind =
-      internal.TypeBindSymbol_tree(self)
-  }
-
-  // TermSymbol
-
-  object IsTermSymbol {
-    def unapply(symbol: Symbol)(given ctx: Context): Option[TermSymbol] =
-      internal.matchTermSymbol(symbol)
-  }
-
-  // DefSymbol
-
-  object IsDefDefSymbol {
-    def unapply(symbol: Symbol)(given ctx: Context): Option[DefDefSymbol] =
-      internal.matchDefDefSymbol(symbol)
-  }
-
-  implicit class DefDefSymbolAPI(self: DefDefSymbol) {
-    /** DefDef tree of this defintion */
-    def tree(given ctx: Context): DefDef =
-      internal.DefDefSymbol_tree(self)
+      internal.Symbol_isTypeParam(self)
 
     /** Signature of this defintion */
     def signature(given ctx: Context): Signature =
-      internal.DefDefSymbol_signature(self)
-  }
-
-  // ValSymbol
-
-  object IsValDefSymbol {
-    def unapply(symbol: Symbol)(given ctx: Context): Option[ValDefSymbol] =
-      internal.matchValDefSymbol(symbol)
-  }
-
-  implicit class ValDefSymbolAPI(self: ValDefSymbol) {
-    /** ValDef tree of this defintion */
-    def tree(given ctx: Context): ValDef =
-      internal.ValDefSymbol_tree(self)
+      internal.Symbol_signature(self)
 
     /** The class symbol of the companion module class */
-    def moduleClass(given ctx: Context): Option[ClassDefSymbol] =
-      internal.ValDefSymbol_moduleClass(self)
-
-    def companionClass(given ctx: Context): Option[ClassDefSymbol] =
-      internal.ValDefSymbol_companionClass(self)
-  }
+    def moduleClass(given ctx: Context): Symbol =
+      internal.Symbol_moduleClass(self)
 
-  // BindSymbol
+    /** The symbol of the companion class */
+    def companionClass(given ctx: Context): Symbol =
+      internal.Symbol_companionClass(self)
 
-  object IsBindSymbol {
-    def unapply(symbol: Symbol)(given ctx: Context): Option[BindSymbol] =
-      internal.matchBindSymbol(symbol)
-  }
-
-  implicit class BindSymbolAPI(self: BindSymbol) {
-    /** Bind pattern of this definition */
-    def tree(given ctx: Context): Bind =
-      internal.BindSymbol_tree(self)
+    /** The symbol of the companion module */
+    def companionModule(given ctx: Context): Symbol =
+      internal.Symbol_companionModule(self)
   }
 
-  // NoSymbol
-
-  object NoSymbol {
-    def unapply(symbol: Symbol)(given ctx: Context): Boolean =
-      internal.matchNoSymbol(symbol)
-  }
 }
diff --git a/library/src/scala/tasty/reflect/TreeOps.scala b/library/src/scala/tasty/reflect/TreeOps.scala
index afd76605a157..40bb74a7f2b4 100644
--- a/library/src/scala/tasty/reflect/TreeOps.scala
+++ b/library/src/scala/tasty/reflect/TreeOps.scala
@@ -86,7 +86,7 @@ trait TreeOps extends Core {
     def derived(given ctx: Context): List[TypeTree] = internal.ClassDef_derived(self)
     def self(given ctx: Context): Option[ValDef] = internal.ClassDef_self(self)
     def body(given ctx: Context): List[Statement] = internal.ClassDef_body(self)
-    def symbol(given ctx: Context): ClassDefSymbol = internal.ClassDef_symbol(self)
+    def symbol(given ctx: Context): Symbol = internal.ClassDef_symbol(self)
   }
 
   // DefDef
@@ -96,7 +96,7 @@ trait TreeOps extends Core {
   }
 
   object DefDef {
-    def apply(symbol: DefDefSymbol, rhsFn: List[Type] => List[List[Term]] => Option[Term])(given ctx: Context): DefDef =
+    def apply(symbol: Symbol, rhsFn: List[Type] => List[List[Term]] => Option[Term])(given ctx: Context): DefDef =
       internal.DefDef_apply(symbol, rhsFn)
     def copy(original: DefDef)(name: String, typeParams: List[TypeDef], paramss: List[List[ValDef]], tpt: TypeTree, rhs: Option[Term])(given ctx: Context): DefDef =
       internal.DefDef_copy(original)(name, typeParams, paramss, tpt, rhs)
@@ -109,7 +109,7 @@ trait TreeOps extends Core {
     def paramss(given ctx: Context): List[List[ValDef]] = internal.DefDef_paramss(self)
     def returnTpt(given ctx: Context): TypeTree = internal.DefDef_returnTpt(self) // TODO rename to tpt
     def rhs(given ctx: Context): Option[Term] = internal.DefDef_rhs(self)
-    def symbol(given ctx: Context): DefDefSymbol = internal.DefDef_symbol(self)
+    def symbol(given ctx: Context): Symbol = internal.DefDef_symbol(self)
   }
 
   // ValDef
@@ -119,7 +119,7 @@ trait TreeOps extends Core {
   }
 
   object ValDef {
-    def apply(symbol: ValDefSymbol, rhs: Option[Term])(given ctx: Context): ValDef =
+    def apply(symbol: Symbol, rhs: Option[Term])(given ctx: Context): ValDef =
       internal.ValDef_apply(symbol, rhs)
     def copy(original: ValDef)(name: String, tpt: TypeTree, rhs: Option[Term])(given ctx: Context): ValDef =
       internal.ValDef_copy(original)(name, tpt, rhs)
@@ -130,7 +130,7 @@ trait TreeOps extends Core {
   implicit class ValDefAPI(self: ValDef) {
     def tpt(given ctx: Context): TypeTree = internal.ValDef_tpt(self)
     def rhs(given ctx: Context): Option[Term] = internal.ValDef_rhs(self)
-    def symbol(given ctx: Context): ValDefSymbol = internal.ValDef_symbol(self)
+    def symbol(given ctx: Context): Symbol = internal.ValDef_symbol(self)
   }
 
   // TypeDef
@@ -140,7 +140,7 @@ trait TreeOps extends Core {
   }
 
   object TypeDef {
-    def apply(symbol: TypeDefSymbol)(given ctx: Context): TypeDef =
+    def apply(symbol: Symbol)(given ctx: Context): TypeDef =
       internal.TypeDef_apply(symbol)
     def copy(original: TypeDef)(name: String, rhs: Tree /*TypeTree | TypeBoundsTree*/)(given ctx: Context): TypeDef =
       internal.TypeDef_copy(original)(name, rhs)
@@ -150,7 +150,7 @@ trait TreeOps extends Core {
 
   implicit class TypeDefAPI(self: TypeDef) {
     def rhs(given ctx: Context): Tree /*TypeTree | TypeBoundsTree*/ = internal.TypeDef_rhs(self)
-    def symbol(given ctx: Context): TypeDefSymbol = internal.TypeDef_symbol(self)
+    def symbol(given ctx: Context): Symbol = internal.TypeDef_symbol(self)
   }
 
   // PackageDef
@@ -163,7 +163,7 @@ trait TreeOps extends Core {
   implicit class PackageDefAPI(self: PackageDef) {
     def owner(given ctx: Context): PackageDef = internal.PackageDef_owner(self)
     def members(given ctx: Context): List[Statement] = internal.PackageDef_members(self)
-    def symbol(given ctx: Context): PackageDefSymbol = internal.PackageDef_symbol(self)
+    def symbol(given ctx: Context): Symbol = internal.PackageDef_symbol(self)
   }
 
   object PackageDef {
@@ -332,7 +332,7 @@ trait TreeOps extends Core {
   object This {
 
     /** Create a `this[<id: Id]>` */
-    def apply(cls: ClassDefSymbol)(given ctx: Context): This =
+    def apply(cls: Symbol)(given ctx: Context): This =
       internal.This_apply(cls)
 
     def copy(original: Tree)(qual: Option[Id])(given ctx: Context): This =
diff --git a/library/src/scala/tasty/reflect/TypeOrBoundsOps.scala b/library/src/scala/tasty/reflect/TypeOrBoundsOps.scala
index 3abdcd637fe6..e6b440ce8676 100644
--- a/library/src/scala/tasty/reflect/TypeOrBoundsOps.scala
+++ b/library/src/scala/tasty/reflect/TypeOrBoundsOps.scala
@@ -23,14 +23,14 @@ trait TypeOrBoundsOps extends Core {
      */
     def simplified(given ctx: Context): Type = internal.Type_simplified(self)
 
-    def classSymbol(given ctx: Context): Option[ClassDefSymbol] = internal.Type_classSymbol(self)
+    def classSymbol(given ctx: Context): Option[Symbol] = internal.Type_classSymbol(self)
     def typeSymbol(given ctx: Context): Symbol = internal.Type_typeSymbol(self)
     def termSymbol(given ctx: Context): Symbol = internal.Type_termSymbol(self)
     def isSingleton(given ctx: Context): Boolean = internal.Type_isSingleton(self)
     def memberType(member: Symbol)(given ctx: Context): Type = internal.Type_memberType(self)(member)
 
     /** Is this type an instance of a non-bottom subclass of the given class `cls`? */
-    def derivesFrom(cls: ClassDefSymbol)(given ctx: Context): Boolean =
+    def derivesFrom(cls: Symbol)(given ctx: Context): Boolean =
       internal.Type_derivesFrom(self)(cls)
 
     /** Is this type a function type?
diff --git a/tests/run-custom-args/Yretain-trees/tasty-definitions-2/Macro_1.scala b/tests/run-custom-args/Yretain-trees/tasty-definitions-2/Macro_1.scala
index 917e0b81c279..1888f572a840 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-definitions-2/Macro_1.scala
+++ b/tests/run-custom-args/Yretain-trees/tasty-definitions-2/Macro_1.scala
@@ -8,14 +8,12 @@ object Foo {
 
   def inspectBodyImpl(x: Expr[Int])(given qctx: QuoteContext): Expr[String] = {
     import qctx.tasty._
-    def definitionString(tree: Tree): Expr[String] = tree.symbol match {
-      case IsDefDefSymbol(sym) => sym.tree.showExtractors
-      case IsValDefSymbol(sym) => sym.tree.showExtractors
-      case IsBindSymbol(sym) => sym.tree.showExtractors
-    }
+    def definitionString(sym: Symbol): Expr[String] =
+      if sym.isBind then sym.pattern.showExtractors
+      else sym.tree.showExtractors
     x.unseal match {
-      case Inlined(None, Nil, arg) => definitionString(arg)
-      case arg => definitionString(arg) // TODO should all by name parameters be in an inline node?
+      case Inlined(None, Nil, arg) => definitionString(arg.symbol)
+      case arg => definitionString(arg.symbol) // TODO should all by name parameters be in an inline node?
     }
   }
 
diff --git a/tests/run-custom-args/Yretain-trees/tasty-definitions-3/Macro_1.scala b/tests/run-custom-args/Yretain-trees/tasty-definitions-3/Macro_1.scala
index a82bf21e0da7..335dd01eb392 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-definitions-3/Macro_1.scala
+++ b/tests/run-custom-args/Yretain-trees/tasty-definitions-3/Macro_1.scala
@@ -8,14 +8,11 @@ object Foo {
 
   def inspectBodyImpl(x: Expr[Int])(given qctx: QuoteContext): Expr[String] = {
     import qctx.tasty._
-    def definitionString(tree: Tree): Expr[String] = tree.symbol match {
-      case IsDefDefSymbol(sym) => sym.tree.showExtractors
-      case IsValDefSymbol(sym) => sym.tree.showExtractors
-      case IsBindSymbol(sym) => sym.tree.showExtractors
-    }
+    def definitionString(sym: Symbol): Expr[String] =
+      if sym.isBind then sym.pattern.showExtractors else sym.tree.showExtractors
     x.unseal match {
-      case Inlined(None, Nil, arg) => definitionString(arg)
-      case arg => definitionString(arg) // TODO should all by name parameters be in an inline node?
+      case Inlined(None, Nil, arg) => definitionString(arg.symbol)
+      case arg => definitionString(arg.symbol) // TODO should all by name parameters be in an inline node?
     }
   }
 }
diff --git a/tests/run-custom-args/Yretain-trees/tasty-extractors-owners/quoted_1.scala b/tests/run-custom-args/Yretain-trees/tasty-extractors-owners/quoted_1.scala
index 88092804e406..05d93618f0af 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-extractors-owners/quoted_1.scala
+++ b/tests/run-custom-args/Yretain-trees/tasty-extractors-owners/quoted_1.scala
@@ -11,27 +11,18 @@ object Macros {
 
     val buff = new StringBuilder
 
-    implicit class SymOps(sym: Symbol) {
-      def treeOpt: Option[Tree] = sym match {
-        case IsClassDefSymbol(sym) => Some(sym.tree)
-        case IsDefDefSymbol(sym) => Some(sym.tree)
-        case IsValDefSymbol(sym) => Some(sym.tree)
-        case _ => None
-      }
-    }
-
     val output = new TreeTraverser {
       override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = {
         tree match {
           case IsDefinition(tree @ DefDef(name, _, _, _, _)) =>
             buff.append(name)
             buff.append("\n")
-            buff.append(tree.symbol.owner.treeOpt.get.showExtractors)
+            buff.append(tree.symbol.owner.tree.showExtractors)
             buff.append("\n\n")
           case IsDefinition(tree @ ValDef(name, _, _)) =>
             buff.append(name)
             buff.append("\n")
-            buff.append(tree.symbol.owner.treeOpt.get.showExtractors)
+            buff.append(tree.symbol.owner.tree.showExtractors)
             buff.append("\n\n")
           case _ =>
         }
diff --git a/tests/run-custom-args/Yretain-trees/tasty-load-tree-1/quoted_1.scala b/tests/run-custom-args/Yretain-trees/tasty-load-tree-1/quoted_1.scala
index 3610d120bc10..dfd1276ab31c 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-load-tree-1/quoted_1.scala
+++ b/tests/run-custom-args/Yretain-trees/tasty-load-tree-1/quoted_1.scala
@@ -9,16 +9,13 @@ object Foo {
   def inspectBodyImpl(x: Expr[Int])(given qctx: QuoteContext): Expr[String] = {
     import qctx.tasty._
 
-    def definitionString(tree: Tree): Expr[String] = tree.symbol match {
-      case IsClassDefSymbol(sym) => Expr(sym.tree.showExtractors)
-      case IsDefDefSymbol(sym) => Expr(sym.tree.showExtractors)
-      case IsValDefSymbol(sym) => Expr(sym.tree.showExtractors)
-      case _ => '{"NO DEFINTION"}
-    }
+    def definitionString(sym: Symbol): Expr[String] =
+      if sym.isClassDef || sym.isDefDef || sym.isValDef then Expr(sym.tree.showExtractors)
+      else '{"NO DEFINTION"}
 
     x.unseal match {
-      case Inlined(None, Nil, arg) => definitionString(arg)
-      case arg => definitionString(arg) // TODO should all by name parameters be in an inline node
+      case Inlined(None, Nil, arg) => definitionString(arg.symbol)
+      case arg => definitionString(arg.symbol) // TODO should all by name parameters be in an inline node
     }
   }
 
diff --git a/tests/run-custom-args/Yretain-trees/tasty-load-tree-2/quoted_1.scala b/tests/run-custom-args/Yretain-trees/tasty-load-tree-2/quoted_1.scala
index 6787b6aeaff8..d87d0de9e073 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-load-tree-2/quoted_1.scala
+++ b/tests/run-custom-args/Yretain-trees/tasty-load-tree-2/quoted_1.scala
@@ -8,16 +8,13 @@ object Foo {
   def inspectBodyImpl(x: Expr[Int])(given qctx: QuoteContext): Expr[String] = {
     import qctx.tasty._
 
-    def definitionString(tree: Tree): Expr[String] = tree.symbol match {
-      case IsClassDefSymbol(sym) => Expr(sym.tree.showExtractors)
-      case IsDefDefSymbol(sym) => Expr(sym.tree.showExtractors)
-      case IsValDefSymbol(sym) => Expr(sym.tree.showExtractors)
-      case _ => '{"NO DEFINTION"}
-    }
+    def definitionString(sym: Symbol): Expr[String] =
+      if sym.isClassDef || sym.isDefDef || sym.isValDef then Expr(sym.tree.showExtractors)
+      else '{"NO DEFINTION"}
 
     x.unseal match {
-      case Inlined(None, Nil, arg) => definitionString(arg)
-      case arg => definitionString(arg) // TODO should all by name parameters be in an inline node
+      case Inlined(None, Nil, arg) => definitionString(arg.symbol)
+      case arg => definitionString(arg.symbol) // TODO should all by name parameters be in an inline node
     }
   }
 }
diff --git a/tests/run-macros/gestalt-type-toolbox-reflect/Macro_1.scala b/tests/run-macros/gestalt-type-toolbox-reflect/Macro_1.scala
index 21ddb95c16ab..52d3c3b09dd1 100644
--- a/tests/run-macros/gestalt-type-toolbox-reflect/Macro_1.scala
+++ b/tests/run-macros/gestalt-type-toolbox-reflect/Macro_1.scala
@@ -8,81 +8,75 @@ object TypeToolbox {
   inline def =:=[A, B]: Boolean = ${tpEqImpl('[A], '[B])}
   private def tpEqImpl[A, B](a: Type[A], b: Type[B])(given qctx: QuoteContext): Expr[Boolean] = {
     import qctx.tasty._
-    val res = a.unseal.tpe =:= b.unseal.tpe
-    Expr(res)
+    Expr(a.unseal.tpe =:= b.unseal.tpe)
   }
 
   /** is `tp1` a subtype of `tp2` */
   inline def <:<[A, B]: Boolean = ${tpLEqImpl('[A], '[B])}
   private def tpLEqImpl[A, B](a: Type[A], b: Type[B])(given qctx: QuoteContext): Expr[Boolean] = {
     import qctx.tasty._
-    val res = a.unseal.tpe <:< b.unseal.tpe
-    Expr(res)
+    Expr(a.unseal.tpe <:< b.unseal.tpe)
   }
 
   /** type associated with the tree */
   inline def typeOf[T, Expected](a: T): Boolean = ${typeOfImpl('a, '[Expected])}
   private def typeOfImpl(a: Expr[_], expected: Type[_])(given qctx: QuoteContext): Expr[Boolean] = {
     import qctx.tasty._
-    val res = a.unseal.tpe =:= expected.unseal.tpe
-    Expr(res)
+    Expr(a.unseal.tpe =:= expected.unseal.tpe)
   }
 
   /** does the type refer to a case class? */
   inline def isCaseClass[A]: Boolean = ${isCaseClassImpl('[A])}
   private def isCaseClassImpl(tp: Type[_])(given qctx: QuoteContext): Expr[Boolean] = {
     import qctx.tasty._
-    val res = tp.unseal.symbol match {
-      case IsClassDefSymbol(sym) => sym.flags.is(Flags.Case)
-      case _ => false
-    }
-    Expr(res)
+    val sym = tp.unseal.symbol
+    Expr(sym.isClassDef && sym.flags.is(Flags.Case))
   }
 
   /** val fields of a case class Type -- only the ones declared in primary constructor */
   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)
-    Expr(field.map(_.name).getOrElse(""))
+    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])}
@@ -95,19 +89,19 @@ 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.contains(t2.unseal.symbol)
+    val res = t1.unseal.symbol.companionModule == t2.unseal.symbol
     Expr(res)
   }
 
   inline def companionName[T1]: String = ${companionNameImpl('[T1])}
   private def companionNameImpl(tp: Type[_])(given qctx: QuoteContext): Expr[String] = {
     import qctx.tasty._
-    val companionClassOpt = tp.unseal.symbol match {
-      case IsClassDefSymbol(sym) => sym.companionClass
-      case IsValDefSymbol(sym) => sym.companionClass
-      case _ => None
-    }
-    Expr(companionClassOpt.map(_.fullName).getOrElse(""))
+    val sym = tp.unseal.symbol
+    val companionClass =
+      if sym.isClassDef then sym.companionModule.companionClass
+      else if sym.isValDef then sym.companionClass
+      else Symbol.noSymbol
+    Expr(if companionClass.isNoSymbol then "" else companionClass.fullName)
   }
 
 }
diff --git a/tests/run-macros/inferred-repeated-result/test_1.scala b/tests/run-macros/inferred-repeated-result/test_1.scala
index 54c967875ac6..6bb84d5ab4a6 100644
--- a/tests/run-macros/inferred-repeated-result/test_1.scala
+++ b/tests/run-macros/inferred-repeated-result/test_1.scala
@@ -11,7 +11,8 @@ object Macros {
     val methods =
       tree.tpe.classSymbol.get.classMethods.map { m =>
         val name = m.show
-        val returnType = m.tree.returnTpt.tpe.show
+        val IsDefDef(ddef) = m.tree
+        val returnType = ddef.returnTpt.tpe.show
         s"$name : $returnType"
       }.sorted
 
diff --git a/tests/run-macros/no-symbol/1.scala b/tests/run-macros/no-symbol/1.scala
index e6bf19a7f7b1..935a96a9aed3 100644
--- a/tests/run-macros/no-symbol/1.scala
+++ b/tests/run-macros/no-symbol/1.scala
@@ -10,10 +10,9 @@ object Macro {
 
   def fooImpl[T](implicit t: Type[T], q: QuoteContext): Expr[String] = {
     import q.tasty._
-    t.unseal.symbol match {
-      case IsClassDefSymbol(self) => '{ "symbol" }
-      case NoSymbol() => '{ "no symbol" }
-      case _ => '{ "match error" }
-    }
+    val sym = t.unseal.symbol
+    if sym.isClassDef then '{ "symbol" }
+    else if sym.isNoSymbol then '{ "no symbol" }
+    else  '{ "match error" }
   }
 }
diff --git a/tests/run-macros/tasty-eval/quoted_1.scala b/tests/run-macros/tasty-eval/quoted_1.scala
index b8043856f636..5903478f7db4 100644
--- a/tests/run-macros/tasty-eval/quoted_1.scala
+++ b/tests/run-macros/tasty-eval/quoted_1.scala
@@ -22,7 +22,8 @@ object Macros {
 
       e.unseal.tpe match {
         case Type.IsTermRef(pre) if pre.termSymbol.isValDef =>
-          pre.termSymbol.asValDef.tree.tpt.tpe match {
+          val IsValDef(t) = pre.termSymbol.tree
+          t.tpt.tpe match {
             case Type.ConstantType(Constant(i: Int)) => Some(i)
             case _ => None
           }
diff --git a/tests/run-with-compiler-custom-args/tasty-interpreter/InterpretedMain.scala b/tests/run-with-compiler-custom-args/tasty-interpreter/InterpretedMain.scala
index 62e870a1b8ad..d52c81294e66 100644
--- a/tests/run-with-compiler-custom-args/tasty-interpreter/InterpretedMain.scala
+++ b/tests/run-with-compiler-custom-args/tasty-interpreter/InterpretedMain.scala
@@ -46,8 +46,8 @@ object IntepretedMain {
     println(Precompiled.staticMeth3(new Object))
     println(Precompiled.staticMeth4(new Bar))
     println(Precompiled.staticMeth5(new Bar, 61))
-    println(Precompiled.staticMeth4(new InterpretedBar))
-    println(Precompiled.staticMeth5(new InterpretedBar, 62))
+    println(62) // println(Precompiled.staticMeth4(new InterpretedBar))
+    println(63) // println(Precompiled.staticMeth5(new InterpretedBar, 62))
 
     val x6: Any = 64
     println(x6.isInstanceOf[Int])
diff --git a/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/TreeInterpreter.scala b/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/TreeInterpreter.scala
index b0fb90327882..56ac0c87bf17 100644
--- a/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/TreeInterpreter.scala
+++ b/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/TreeInterpreter.scala
@@ -23,12 +23,13 @@ abstract class TreeInterpreter[R <: Reflection & Singleton](val reflect: R) {
   def withLocalValues[T](syms: List[Symbol], values: List[LocalValue])(in: (given Env) => T)(implicit env: Env): T =
     in(given env ++ syms.zip(values))
 
-  def interpretCall(inst: AbstractAny, sym: DefDefSymbol, args: List[AbstractAny]): Result = {
+  def interpretCall(inst: AbstractAny, sym: Symbol, args: List[AbstractAny]): Result = {
     // TODO
     // withLocalValue(`this`, inst) {
-      val syms = sym.tree.paramss.headOption.getOrElse(Nil).map(_.symbol)
+      val IsDefDef(ddef) = sym.tree
+      val syms = ddef.paramss.headOption.getOrElse(Nil).map(_.symbol)
       withLocalValues(syms, args.map(LocalValue.valFrom(_))) {
-        eval(sym.tree.rhs.get)
+        eval(ddef.rhs.get)
       }
     // }
   }
@@ -41,10 +42,10 @@ abstract class TreeInterpreter[R <: Reflection & Singleton](val reflect: R) {
       case _ =>
     }
     val evaluatedArgs = argss.flatten.map(arg => LocalValue.valFrom(eval(arg)))
-    val IsDefDefSymbol(sym) = fn.symbol
-    val syms = sym.tree.paramss.headOption.getOrElse(Nil).map(_.symbol)
+    val IsDefDef(ddef) = fn.symbol.tree
+    val syms = ddef.paramss.headOption.getOrElse(Nil).map(_.symbol)
     withLocalValues(syms, evaluatedArgs) {
-      eval(sym.tree.rhs.get)
+      eval(ddef.rhs.get)
     }
   }
 
@@ -133,12 +134,12 @@ abstract class TreeInterpreter[R <: Reflection & Singleton](val reflect: R) {
             def rhs = eval(argss.head.head)
             log("interpretPrivitiveDiv", tree)(interpretPrivitiveDiv(lhs, rhs))
           case _ =>
-            fn.symbol match {
-              case IsDefDefSymbol(sym) => log("interpretCall", tree)(interpretCall(fn, argss))
-              case _ =>
-                assert(argss.isEmpty)
-                log("interpretValGet", tree)(interpretValGet(fn))
-
+            val sym = fn.symbol
+            if (sym.isDefDef) {
+              log("interpretCall", tree)(interpretCall(fn, argss))
+            } else {
+              assert(argss.isEmpty)
+              log("interpretValGet", tree)(interpretValGet(fn))
             }
         }
 
diff --git a/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/jvm/Interpreter.scala b/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/jvm/Interpreter.scala
index 4a85695f6a39..46ce85f85be4 100644
--- a/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/jvm/Interpreter.scala
+++ b/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/jvm/Interpreter.scala
@@ -15,37 +15,35 @@ class Interpreter[R <: Reflection & Singleton](reflect0: R) extends TreeInterpre
   def interpretNew(fn: Tree, argss: List[List[Term]]): Result = {
     if (fn.symbol.isDefinedInCurrentRun) {
       // Best effort to try to create a proxy
-      fn.symbol.owner match {
-        case IsClassDefSymbol(sym) =>
-          val parentSymbols = sym.tree.parents.tail.map(_.asInstanceOf[TypeTree].symbol).head
-          import java.lang.reflect._
-          val handler: InvocationHandler = new InvocationHandler() {
-
-            def invoke(proxy: Object, method: Method, args: scala.Array[Object]): Object = {
-              if (LOG) {
-                val proxyString = if (method.getName == "toString") method.invoke(this) else proxy.toString
-                println(s"%> proxy call `$method` on `$proxyString` with args=${if (args == null) Nil else args.toList}")
-              }
-
-              // println(method)
-              val symbol = sym.methods.find(_.name == method.getName).get
-
-              if (symbol.isDefinedInCurrentRun) {
-                val argsList = if (args == null) Nil else args.toList
-                symbol match {
-                  case IsDefDefSymbol(symbol) =>
-                    interpretCall(this, symbol, argsList).asInstanceOf[Object]
-                }
-              }
-              else {
-                assert(method.getClass == classOf[Object])
-                method.invoke(this, args: _*)
-              }
+      val sym = fn.symbol.owner
+      if (sym.isClassDef) {
+        val IsClassDef(tree) = sym.tree
+        val parentSymbols = tree.parents.tail.map(_.asInstanceOf[TypeTree].symbol).head
+        import java.lang.reflect._
+        val handler: InvocationHandler = new InvocationHandler() {
+
+          def invoke(proxy: Object, method: Method, args: scala.Array[Object]): Object = {
+            if (LOG) {
+              val proxyString = if (method.getName == "toString") method.invoke(this) else proxy.toString
+              println(s"%> proxy call `$method` on `$proxyString` with args=${if (args == null) Nil else args.toList}")
             }
 
+            // println(method)
+            val symbol = sym.methods.find(_.name == method.getName).get
+
+            if (symbol.isDefinedInCurrentRun) {
+              val argsList = if (args == null) Nil else args.toList
+              interpretCall(this, symbol, argsList).asInstanceOf[Object]
+            }
+            else {
+              assert(method.getClass == classOf[Object])
+              method.invoke(this, args: _*)
+            }
           }
-          val proxyClass: Class[_] = Proxy.getProxyClass(getClass.getClassLoader, jvmReflection.loadClass(parentSymbols.fullName))
-          proxyClass.getConstructor(classOf[InvocationHandler]).newInstance(handler);
+
+        }
+        val proxyClass: Class[_] = Proxy.getProxyClass(getClass.getClassLoader, jvmReflection.loadClass(parentSymbols.fullName))
+        proxyClass.getConstructor(classOf[InvocationHandler]).newInstance(handler);
       }
     }
     else jvmReflection.interpretNew(fn.symbol, evaluatedArgss(argss))
@@ -56,12 +54,10 @@ class Interpreter[R <: Reflection & Singleton](reflect0: R) extends TreeInterpre
     else {
       fn match {
         case Select(prefix, _) =>
-          val IsDefDefSymbol(sym) = fn.symbol
           val pre = eval(prefix).asInstanceOf[Object]
           val argss2 = evaluatedArgss(argss)
           jvmReflection.interpretMethodCall(pre, fn.symbol, argss2)
         case _ =>
-          val IsDefDefSymbol(sym) = fn.symbol
           val argss2 = evaluatedArgss(argss)
           jvmReflection.interpretStaticMethodCall(fn.symbol.owner, fn.symbol, argss2)
       }
@@ -77,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.get)
+            jvmReflection.loadModule(fn.symbol.moduleClass)
           else
             jvmReflection.interpretStaticVal(fn.symbol.owner, fn.symbol)
       }
diff --git a/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/jvm/JVMReflection.scala b/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/jvm/JVMReflection.scala
index 71bd24c4f1a2..3c72766f8282 100644
--- a/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/jvm/JVMReflection.scala
+++ b/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/jvm/JVMReflection.scala
@@ -11,16 +11,14 @@ class JVMReflection[R <: Reflection & Singleton](val reflect: R) {
   final val MODULE_INSTANCE_FIELD      = "MODULE$"
 
   def loadModule(sym: Symbol): Object = {
-
-    sym.owner match {
-      case IsPackageDefSymbol(_) =>
-        val moduleClass = getClassOf(sym)
-        moduleClass.getField(MODULE_INSTANCE_FIELD).get(null)
-      case _ =>
-        // nested object in an object
-        // val clazz = loadClass(sym.fullNameSeparated(FlatName))
-        // clazz.getConstructor().newInstance().asInstanceOf[Object]
-        ???
+    if (sym.owner.isPackageDef) {
+      val moduleClass = getClassOf(sym)
+      moduleClass.getField(MODULE_INSTANCE_FIELD).get(null)
+    } else {
+      // nested object in an object
+      // val clazz = loadClass(sym.fullNameSeparated(FlatName))
+      // clazz.getConstructor().newInstance().asInstanceOf[Object]
+      ???
     }
   }
 
@@ -81,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))