diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/FromSymbol.scala b/compiler/src/dotty/tools/dotc/tastyreflect/FromSymbol.scala
index c2a91a914e5c..e327a97fdf52 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/FromSymbol.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/FromSymbol.scala
@@ -1,6 +1,7 @@
 package dotty.tools.dotc.tastyreflect
 
 import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.ast.untpd
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.StdNames._
@@ -15,6 +16,7 @@ object FromSymbol {
     else if (sym.isClass) classDef(sym.asClass)
     else if (sym.isType) typeDefFromSym(sym.asType)
     else if (sym.is(Method)) defDefFromSym(sym.asTerm)
+    else if (sym.is(Case)) bindFromSym(sym.asTerm)
     else valDefFromSym(sym.asTerm)
   }
 
@@ -48,4 +50,8 @@ object FromSymbol {
     case tpd.EmptyTree => tpd.ValDef(sym)
   }
 
+  def bindFromSym(sym: TermSymbol)(implicit ctx: Context): tpd.Bind = sym.defTree match {
+    case tree: tpd.Bind => tree
+    case tpd.EmptyTree => tpd.Bind(sym, untpd.Ident(nme.WILDCARD).withType(sym.typeRef))
+  }
 }
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/PrintersImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/PrintersImpl.scala
index d691871f9746..d86669b083c9 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/PrintersImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/PrintersImpl.scala
@@ -40,4 +40,9 @@ trait PrintersImpl extends scala.tasty.reflect.Printers with scala.tasty.reflect
     def show(implicit ctx: Contexts.Context, s: Show[tasty.type]): String = s.showConstant(const)
   }
 
+  /** Adds `show` as an extension method of a `Symbol` */
+  def SymbolShowDeco(symbol: Symbol): ShowAPI = new ShowAPI {
+    def show(implicit ctx: Contexts.Context, s: Show[tasty.type]): String = s.showSymbol(symbol)
+  }
+
 }
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/SymbolOpsImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/SymbolOpsImpl.scala
index 53e1299c1632..a01cdc224bc7 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/SymbolOpsImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/SymbolOpsImpl.scala
@@ -1,15 +1,13 @@
 package dotty.tools.dotc
 package tastyreflect
 
+import dotty.tools.dotc.core.Flags
 import dotty.tools.dotc.core.Symbols._
 
 trait SymbolOpsImpl extends scala.tasty.reflect.SymbolOps with TastyCoreImpl {
 
   def SymbolDeco(symbol: Symbol): SymbolAPI = new SymbolAPI {
 
-    def exists(implicit ctx: Context): Boolean = symbol eq NoSymbol
-    def isClass(implicit ctx: Context): Boolean = symbol.isClass
-
     def flags(implicit ctx: Context): FlagSet = new FlagSet(symbol.flags)
 
     def privateWithin(implicit ctx: Context): Option[Type] = {
@@ -34,8 +32,39 @@ trait SymbolOpsImpl extends scala.tasty.reflect.SymbolOps with TastyCoreImpl {
       else ctx
     }
 
-    def tree(implicit ctx: Context): Option[Definition] =
-      if (exists) None else Some(FromSymbol.definitionFromSym(symbol))
+    def asPackage(implicit ctx: Context): PackageSymbol = symbol match {
+      case IsPackageSymbol(symbol) => symbol
+      case _ => throw new Exception("not a PackageSymbol")
+    }
+
+    def asClass(implicit ctx: Context): ClassSymbol = symbol match {
+      case IsClassSymbol(symbol) => symbol.asClass
+      case _ => throw new Exception("not a ClassSymbol")
+    }
+
+    def asDef(implicit ctx: Context): DefSymbol = symbol match {
+      case IsDefSymbol(symbol) => symbol.asTerm
+      case _ => throw new Exception("not a DefSymbol")
+    }
+
+    def asVal(implicit ctx: Context): ValSymbol = symbol match {
+      case IsValSymbol(symbol) => symbol
+      case _ => throw new Exception("not a ValSymbol")
+    }
+
+    def asBind(implicit ctx: Context): BindSymbol = symbol match {
+      case IsBindSymbol(symbol) => symbol
+      case _ => throw new Exception("not a BindSymbol")
+    }
+
+    def asType(implicit ctx: Context): TypeSymbol = symbol match {
+      case IsTypeSymbol(symbol) => symbol.asType
+      case _ => throw new Exception("not a TypeSymbol")
+    }
+
+    def treeOpt(implicit ctx: Context): Option[Definition] =
+      if (symbol eq core.Symbols.NoSymbol) None
+      else Some(FromSymbol.definitionFromSym(symbol))
 
     def annots(implicit ctx: Context): List[Term] = {
       symbol.annotations.flatMap {
@@ -46,4 +75,61 @@ trait SymbolOpsImpl extends scala.tasty.reflect.SymbolOps with TastyCoreImpl {
 
   }
 
+  object IsPackageSymbol extends IsPackageSymbolExtractor {
+    def unapply(symbol: Symbol)(implicit ctx: Context): Option[PackageSymbol] =
+      if (symbol.is(Flags.Package)) Some(symbol) else None
+  }
+
+  def PackageSymbolDeco(symbol: PackageSymbol): PackageSymbolAPI = new PackageSymbolAPI {
+    def tree(implicit ctx: Context): PackageDef = FromSymbol.packageDefFromSym(symbol)
+  }
+
+  object IsTypeSymbol extends IsTypeSymbolExtractor {
+    def unapply(symbol: Symbol)(implicit ctx: Context): Option[TypeSymbol] =
+      if (symbol.isType) Some(symbol.asType) else None
+  }
+
+  def TypeSymbolDeco(symbol: TypeSymbol): TypeSymbolAPI = new TypeSymbolAPI {
+    def tree(implicit ctx: Context): TypeDef = FromSymbol.typeDefFromSym(symbol)
+  }
+
+  object IsClassSymbol extends IsClassSymbolExtractor {
+    def unapply(symbol: Symbol)(implicit ctx: Context): Option[ClassSymbol] =
+      if (symbol.isClass) Some(symbol.asClass) else None
+  }
+
+  def ClassSymbolDeco(symbol: ClassSymbol): ClassSymbolAPI = new ClassSymbolAPI {
+    def tree(implicit ctx: Context): ClassDef = FromSymbol.classDef(symbol)
+  }
+
+  object IsDefSymbol extends IsDefSymbolExtractor {
+    def unapply(symbol: Symbol)(implicit ctx: Context): Option[DefSymbol] =
+      if (symbol.isTerm && symbol.is(Flags.Method)) Some(symbol.asTerm) else None
+  }
+
+  def DefSymbolDeco(symbol: DefSymbol): DefSymbolAPI = new DefSymbolAPI {
+    def tree(implicit ctx: Context): DefDef = FromSymbol.defDefFromSym(symbol)
+  }
+
+  object IsValSymbol extends IsValSymbolExtractor {
+    def unapply(symbol: Symbol)(implicit ctx: Context): Option[ValSymbol] =
+      if (symbol.isTerm && !symbol.is(Flags.Method) && !symbol.is(Flags.Case)) Some(symbol.asTerm) else None
+  }
+
+  def ValSymbolDeco(symbol: ValSymbol): ValSymbolAPI = new ValSymbolAPI {
+    def tree(implicit ctx: Context): ValDef = FromSymbol.valDefFromSym(symbol)
+  }
+
+  object IsBindSymbol extends IsBindSymbolExtractor {
+    def unapply(symbol: Symbol)(implicit ctx: Context): Option[BindSymbol] =
+      if (symbol.isTerm && symbol.is(Flags.Case)) Some(symbol.asTerm) else None // TODO
+  }
+
+  def BindSymbolDeco(symbol: BindSymbol): BindSymbolAPI = new BindSymbolAPI {
+    def tree(implicit ctx: Context): Bind = FromSymbol.bindFromSym(symbol)
+  }
+
+  object NoSymbol extends NoSymbolExtractor {
+    def unapply(symbol: Symbol)(implicit ctx: Context): Boolean = symbol ne core.Symbols.NoSymbol
+  }
 }
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/TastyCoreImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/TastyCoreImpl.scala
index 8f57ef504112..3d56904cd6c2 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/TastyCoreImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/TastyCoreImpl.scala
@@ -16,16 +16,21 @@ trait TastyCoreImpl extends scala.tasty.reflect.TastyCore {
     type Statement = tpd.Tree
       type Import = tpd.Import
       type Definition = tpd.Tree
+        type PackageDef = PackageDefinition
         type ClassDef = tpd.TypeDef
         type TypeDef = tpd.TypeDef
         type DefDef = tpd.DefDef
         type ValDef = tpd.ValDef
-        type PackageDef = PackageDefinition
       type Term = tpd.Tree
 
   type CaseDef = tpd.CaseDef
 
   type Pattern = tpd.Tree
+    type Value = tpd.Tree
+    type Bind = tpd.Bind
+    type Unapply = tpd.Tree
+    type Alternative = tpd.Alternative
+    type TypeTest = tpd.Typed
 
   type TypeOrBoundsTree = tpd.Tree
     type TypeTree = tpd.Tree
@@ -52,5 +57,11 @@ trait TastyCoreImpl extends scala.tasty.reflect.TastyCore {
   type Constant = Constants.Constant
 
   type Symbol = core.Symbols.Symbol
-
+    type PackageSymbol = core.Symbols.Symbol
+    type ClassSymbol = core.Symbols.ClassSymbol
+    type TypeSymbol = core.Symbols.TypeSymbol
+    type DefSymbol = core.Symbols.TermSymbol
+    type BindSymbol = core.Symbols.TermSymbol
+    type ValSymbol = core.Symbols.TermSymbol
+    type NoSymbol = core.Symbols.NoSymbol.type
 }
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala
index 77e0d87d1a7e..75d7712f591b 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala
@@ -1,6 +1,6 @@
 package dotty.tools.dotc.tastyreflect
 
-import dotty.tools.dotc.ast.{Trees, tpd, untpd}
+import dotty.tools.dotc.ast.{Trees, tpd}
 import dotty.tools.dotc.core
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.StdNames.nme
@@ -12,7 +12,6 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He
   def TreeDeco(tree: Tree): TreeAPI = new TreeAPI {
     def pos(implicit ctx: Context): Position = tree.pos
     def symbol(implicit ctx: Context): Symbol = tree.symbol
-
   }
 
   object IsPackageClause extends IsPackageClauseExtractor {
@@ -84,6 +83,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He
     def parents(implicit ctx: Context): List[tpd.Tree] = rhs.parents
     def self(implicit ctx: Context): Option[tpd.ValDef] = optional(rhs.self)
     def body(implicit ctx: Context): List[tpd.Tree] = rhs.body
+    def symbol(implicit ctx: Context): ClassSymbol = cdef.symbol.asClass
   }
 
   // DefDef
@@ -108,6 +108,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He
     def paramss(implicit ctx: Context): List[List[ValDef]] = ddef.vparamss
     def returnTpt(implicit ctx: Context): TypeTree = ddef.tpt
     def rhs(implicit ctx: Context): Option[Tree] = optional(ddef.rhs)
+    def symbol(implicit ctx: Context): DefSymbol = ddef.symbol.asTerm
   }
 
   // ValDef
@@ -130,6 +131,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He
   def ValDefDeco(vdef: ValDef): ValDefAPI = new ValDefAPI {
     def tpt(implicit ctx: Context): TypeTree = vdef.tpt
     def rhs(implicit ctx: Context): Option[Tree] = optional(vdef.rhs)
+    def symbol(implicit ctx: Context): ValSymbol = vdef.symbol.asTerm
   }
 
   // TypeDef
@@ -150,6 +152,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He
 
   def TypeDefDeco(tdef: TypeDef): TypeDefAPI = new TypeDefAPI {
     def rhs(implicit ctx: Context): TypeOrBoundsTree = tdef.rhs
+    def symbol(implicit ctx: Context): TypeSymbol = tdef.symbol.asType
   }
 
   // PackageDef
@@ -162,6 +165,8 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He
       if (pdef.symbol.is(core.Flags.JavaDefined)) Nil // FIXME should also support java packages
       else pdef.symbol.info.decls.iterator.map(definitionFromSym).toList
     }
+
+    def symbol(implicit ctx: Context): PackageSymbol = pdef.symbol
   }
 
   object IsPackageDef extends IsPackageDefExtractor {
diff --git a/library/src/scala/tasty/reflect/Printers.scala b/library/src/scala/tasty/reflect/Printers.scala
index cdbf5c31d278..9b68c9aab7bf 100644
--- a/library/src/scala/tasty/reflect/Printers.scala
+++ b/library/src/scala/tasty/reflect/Printers.scala
@@ -31,6 +31,9 @@ trait Printers { tasty: Tasty =>
   /** Adds `show` as an extension method of a `Constant` */
   implicit def ConstantShowDeco(const: Constant): ShowAPI
 
+  /** Adds `show` as an extension method of a `Symbol` */
+  implicit def SymbolShowDeco(symbol: Symbol): ShowAPI
+
   /** Define `show` as method */
   trait ShowAPI {
     /** Shows the string representation based on an implicit instance of `Show[tasty.type]`
diff --git a/library/src/scala/tasty/reflect/SymbolOps.scala b/library/src/scala/tasty/reflect/SymbolOps.scala
index 5e5849ab872b..72719c0b1555 100644
--- a/library/src/scala/tasty/reflect/SymbolOps.scala
+++ b/library/src/scala/tasty/reflect/SymbolOps.scala
@@ -4,13 +4,12 @@ package reflect
 /** Tasty reflect symbol */
 trait SymbolOps extends TastyCore {
 
+  // Symbol
+
   trait SymbolAPI {
 
     def owner(implicit ctx: Context): Symbol
 
-    def exists(implicit ctx: Context): Boolean
-    def isClass(implicit ctx: Context): Boolean
-
     def flags(implicit ctx: Context): FlagSet
 
     def privateWithin(implicit ctx: Context): Option[Type]
@@ -21,11 +20,94 @@ trait SymbolOps extends TastyCore {
 
     def localContext(implicit ctx: Context): Context
 
-    def tree(implicit ctx: Context): Option[Definition]
+    def asPackage(implicit ctx: Context): PackageSymbol
+    def asClass(implicit ctx: Context): ClassSymbol
+    def asDef(implicit ctx: Context): DefSymbol
+    def asVal(implicit ctx: Context): ValSymbol
+    def asType(implicit ctx: Context): TypeSymbol
+    def asBind(implicit ctx: Context): BindSymbol
 
     def annots(implicit ctx: Context): List[Term]
 
   }
   implicit def SymbolDeco(symbol: Symbol): SymbolAPI
 
+  // PackageSymbol
+
+  val IsPackageSymbol: IsPackageSymbolExtractor
+  abstract class IsPackageSymbolExtractor {
+    def unapply(symbol: Symbol)(implicit ctx: Context): Option[PackageSymbol]
+  }
+
+  trait PackageSymbolAPI {
+    def tree(implicit ctx: Context): PackageDef
+  }
+  implicit def PackageSymbolDeco(symbol: PackageSymbol): PackageSymbolAPI
+
+  // ClassSymbol
+
+  val IsClassSymbol: IsClassSymbolExtractor
+  abstract class IsClassSymbolExtractor {
+    def unapply(symbol: Symbol)(implicit ctx: Context): Option[ClassSymbol]
+  }
+
+  trait ClassSymbolAPI {
+    def tree(implicit ctx: Context): ClassDef
+  }
+  implicit def ClassSymbolDeco(symbol: ClassSymbol): ClassSymbolAPI
+
+  // TypeSymbol
+
+  val IsTypeSymbol: IsTypeSymbolExtractor
+  abstract class IsTypeSymbolExtractor {
+    def unapply(symbol: Symbol)(implicit ctx: Context): Option[TypeSymbol]
+  }
+
+  trait TypeSymbolAPI {
+    def tree(implicit ctx: Context): TypeDef
+  }
+  implicit def TypeSymbolDeco(symbol: TypeSymbol): TypeSymbolAPI
+
+  // DefSymbol
+
+  val IsDefSymbol: IsDefSymbolExtractor
+  abstract class IsDefSymbolExtractor {
+    def unapply(symbol: Symbol)(implicit ctx: Context): Option[DefSymbol]
+  }
+
+  trait DefSymbolAPI {
+    def tree(implicit ctx: Context): DefDef
+  }
+  implicit def DefSymbolDeco(symbol: DefSymbol): DefSymbolAPI
+
+  // ValSymbol
+
+  val IsValSymbol: IsValSymbolExtractor
+  abstract class IsValSymbolExtractor {
+    def unapply(symbol: Symbol)(implicit ctx: Context): Option[ValSymbol]
+  }
+
+  trait ValSymbolAPI {
+    def tree(implicit ctx: Context): ValDef
+  }
+  implicit def ValSymbolDeco(symbol: ValSymbol): ValSymbolAPI
+
+  // BindSymbol
+
+  val IsBindSymbol: IsBindSymbolExtractor
+  abstract class IsBindSymbolExtractor {
+    def unapply(symbol: Symbol)(implicit ctx: Context): Option[BindSymbol]
+  }
+
+  trait BindSymbolAPI {
+    def tree(implicit ctx: Context): Bind
+  }
+  implicit def BindSymbolDeco(symbol: BindSymbol): BindSymbolAPI
+
+  // NoSymbol
+
+  val NoSymbol: NoSymbolExtractor
+  abstract class NoSymbolExtractor {
+    def unapply(symbol: Symbol)(implicit ctx: Context): Boolean
+  }
 }
diff --git a/library/src/scala/tasty/reflect/TastyCore.scala b/library/src/scala/tasty/reflect/TastyCore.scala
index 1479494f39cd..fd736335c936 100644
--- a/library/src/scala/tasty/reflect/TastyCore.scala
+++ b/library/src/scala/tasty/reflect/TastyCore.scala
@@ -6,11 +6,11 @@ package scala.tasty.reflect
  *
  *  +- Tree -+- PackageClause
  *           +- Import
- *           +- Statement -+- Definition --+- ClassDef
+ *           +- Statement -+- Definition --+- PackageDef
+ *                         |               +- ClassDef
  *                         |               +- TypeDef
  *                         |               +- DefDef
  *                         |               +- ValDef
- *                         |               +- PackageDef
  *                         |
  *                         +- Term --------+- Ident
  *                                         +- Select
@@ -96,7 +96,13 @@ package scala.tasty.reflect
  *
  *  +- Constant
  *
- *  +- Symbol
+ *  +- Symbol --+- PackageSymbol
+ *              +- ClassSymbol
+ *              +- TypeSymbol
+ *              +- DefSymbol
+ *              +- ValSymbol
+ *              +- BindSymbol
+ *              +- NoSymbol
  *
  *  Aliases:
  *   # TermOrTypeTree = Term | TypeTree
@@ -118,11 +124,11 @@ trait TastyCore {
     type Statement <: Tree
       type Import <: Statement
       type Definition <: Statement
+        type PackageDef <: Definition
         type ClassDef <: Definition
         type TypeDef <: Definition
         type DefDef <: Definition
         type ValDef <: Definition
-        type PackageDef <: Definition
       type Term <: Statement
 
   /** Branch of a pattern match or catch clause */
@@ -130,6 +136,11 @@ trait TastyCore {
 
   /** Pattern tree of the pattern part of a CaseDef */
   type Pattern
+    type Value <: Pattern
+    type Bind <: Pattern
+    type Unapply <: Pattern
+    type Alternative <: Pattern
+    type TypeTest <: Pattern
 
   /** Tree representing a type written in the source */
   type TypeOrBoundsTree
@@ -167,5 +178,12 @@ trait TastyCore {
    *  Then can be compared with == to know if the definition is the same.
    */
   type Symbol
+    type PackageSymbol <: Symbol
+    type ClassSymbol <: Symbol
+    type TypeSymbol <: Symbol
+    type DefSymbol <: Symbol
+    type ValSymbol <: Symbol
+    type BindSymbol <: Symbol
+    type NoSymbol <: Symbol
 
 }
diff --git a/library/src/scala/tasty/reflect/TreeOps.scala b/library/src/scala/tasty/reflect/TreeOps.scala
index 5fde64a3ed61..1cd035e34bc4 100644
--- a/library/src/scala/tasty/reflect/TreeOps.scala
+++ b/library/src/scala/tasty/reflect/TreeOps.scala
@@ -66,6 +66,8 @@ trait TreeOps extends TastyCore {
     def parents(implicit ctx: Context): List[TermOrTypeTree]
     def self(implicit ctx: Context): Option[ValDef]
     def body(implicit ctx: Context): List[Statement]
+
+    def symbol(implicit ctx: Context): ClassSymbol
   }
   implicit def ClassDefDeco(cdef: ClassDef): ClassDefAPI
 
@@ -86,6 +88,8 @@ trait TreeOps extends TastyCore {
     def paramss(implicit ctx: Context): List[List[ValDef]]
     def returnTpt(implicit ctx: Context): TypeTree
     def rhs(implicit ctx: Context): Option[Term]
+
+    def symbol(implicit ctx: Context): DefSymbol
   }
   implicit def DefDefDeco(ddef: DefDef): DefDefAPI
 
@@ -104,6 +108,8 @@ trait TreeOps extends TastyCore {
   trait ValDefAPI {
     def tpt(implicit ctx: Context): TypeTree
     def rhs(implicit ctx: Context): Option[Term]
+
+    def symbol(implicit ctx: Context): ValSymbol
   }
   implicit def ValDefDeco(vdef: ValDef): ValDefAPI
 
@@ -121,6 +127,7 @@ trait TreeOps extends TastyCore {
 
   trait TypeDefAPI {
     def rhs(implicit ctx: Context): TypeOrBoundsTree
+    def symbol(implicit ctx: Context): TypeSymbol
   }
   implicit def TypeDefDeco(tdef: TypeDef): TypeDefAPI
 
@@ -134,6 +141,7 @@ trait TreeOps extends TastyCore {
   trait PackageDefAPI {
     def owner(implicit ctx: Context): PackageDef
     def members(implicit ctx: Context): List[Statement]
+    def symbol(implicit ctx: Context): PackageSymbol
   }
   implicit def PackageDefDeco(pdef: PackageDef): PackageDefAPI
 
diff --git a/library/src/scala/tasty/util/Show.scala b/library/src/scala/tasty/util/Show.scala
index e1beb41e59da..0be3a11b9c77 100644
--- a/library/src/scala/tasty/util/Show.scala
+++ b/library/src/scala/tasty/util/Show.scala
@@ -16,4 +16,6 @@ abstract class Show[T <: Tasty with Singleton](val tasty: T) {
 
   def showConstant(const: tasty.Constant)(implicit ctx: tasty.Context): String
 
+  def showSymbol(symbol: tasty.Symbol)(implicit ctx: tasty.Context): String
+
 }
diff --git a/library/src/scala/tasty/util/ShowExtractors.scala b/library/src/scala/tasty/util/ShowExtractors.scala
index 6104d5c4c919..b09e5dc6280e 100644
--- a/library/src/scala/tasty/util/ShowExtractors.scala
+++ b/library/src/scala/tasty/util/ShowExtractors.scala
@@ -23,6 +23,9 @@ class ShowExtractors[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
   def showConstant(const: Constant)(implicit ctx: Context): String =
     new Buffer().visitConstant(const).result()
 
+  def showSymbol(symbol: Symbol)(implicit ctx: Context): String =
+    new Buffer().visitSymbol(symbol).result()
+
   private class Buffer(implicit ctx: Context) { self =>
 
     private val sb: StringBuilder = new StringBuilder
@@ -166,9 +169,7 @@ class ShowExtractors[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
       case Type.ConstantType(value) =>
         this += "Type.ConstantType(" += value += ")"
       case Type.SymRef(sym, qual) =>
-        this += "Type.SymRef("
-        this += "<" += sym.fullName += ">"
-        this += ", " += qual += ")"
+        this += "Type.SymRef(" += sym += ", " += qual += ")"
       case Type.TermRef(name, qual) =>
         this += "Type.TermRef(\"" += name += "\", " += qual += ")"
       case Type.TypeRef(name, qual) =>
@@ -224,6 +225,15 @@ class ShowExtractors[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
       case OmitSelector(id) => this += "OmitSelector(" += id += ")"
     }
 
+    def visitSymbol(x: Symbol): Buffer = x match {
+      case IsPackageSymbol(x) => this += "IsPackageSymbol(<" += x.fullName += ">)"
+      case IsClassSymbol(x) => this += "IsClassSymbol(<" += x.fullName += ">)"
+      case IsDefSymbol(x) => this += "IsDefSymbol(<" += x.fullName += ">)"
+      case IsValSymbol(x) => this += "IsValSymbol(<" += x.fullName += ">)"
+      case IsTypeSymbol(x) => this += "IsTypeSymbol(<" += x.fullName += ">)"
+      case NoSymbol() => this += "NoSymbol()"
+    }
+
     def +=(x: Boolean): Buffer = { sb.append(x); this }
     def +=(x: Byte): Buffer = { sb.append(x); this }
     def +=(x: Short): Buffer = { sb.append(x); this }
@@ -281,6 +291,10 @@ class ShowExtractors[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
       def ++=(x: List[ImportSelector]): Buffer = { visitList(x, visitImportSelector); buff }
     }
 
+    private implicit class SymbolOps(buff: Buffer) {
+      def +=(x: Symbol): Buffer = { visitSymbol(x); buff }
+    }
+
     private def visitOption[U](opt: Option[U], visit: U => Buffer): Buffer = opt match {
       case Some(x) =>
         this += "Some("
diff --git a/library/src/scala/tasty/util/ShowSourceCode.scala b/library/src/scala/tasty/util/ShowSourceCode.scala
index 78ea62494d39..c79e76814287 100644
--- a/library/src/scala/tasty/util/ShowSourceCode.scala
+++ b/library/src/scala/tasty/util/ShowSourceCode.scala
@@ -24,6 +24,9 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
   def showConstant(const: Constant)(implicit ctx: Context): String =
     (new Buffer).printConstant(const).result()
 
+  def showSymbol(symbol: Symbol)(implicit ctx: Context): String =
+    symbol.fullName
+
   private class Buffer(implicit ctx: Context) {
 
     private[this] val sb: StringBuilder = new StringBuilder
@@ -622,9 +625,9 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
 
     def printParamDef(arg: ValDef): Unit = {
       val name = arg.name
-      arg.symbol.owner.tree match {
-        case Some(DefDef("<init>", _, _, _, _)) =>
-          val Some(ClassDef(_, _, _, _, body)) = arg.symbol.owner.owner.tree
+      arg.symbol.owner match {
+        case IsDefSymbol(sym) if sym.name == "<init>" =>
+          val ClassDef(_, _, _, _, body) = sym.owner.asClass.tree
           body.collectFirst {
             case IsValDef(vdef @ ValDef(`name`, _, _)) if vdef.symbol.flags.isParamAccessor =>
               if (!vdef.symbol.flags.isLocal) {
@@ -745,10 +748,10 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
             printTypeAndAnnots(tp)
             this += " "
             printAnnotation(annot)
-          case Type.SymRef(sym, _) if sym.isClass && (sym.fullName == "scala.runtime.Null$" || sym.fullName == "scala.runtime.Nothing$") =>
+          case Type.SymRef(IsClassSymbol(sym), _) if sym.fullName == "scala.runtime.Null$" || sym.fullName == "scala.runtime.Nothing$" =>
             // scala.runtime.Null$ and scala.runtime.Nothing$ are not modules, those are their actual names
             printType(tpe)
-          case tpe @ Type.SymRef(sym, _) if sym.isClass && sym.name.endsWith("$") =>
+          case tpe @ Type.SymRef(IsClassSymbol(sym), _) if sym.name.endsWith("$") =>
             printType(tpe)
             this += ".type"
           case tpe => printType(tpe)
@@ -828,7 +831,7 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
       case Type.SymRef(sym, prefix) =>
         prefix match {
           case Types.EmptyPrefix() =>
-          case IsType(prefix @ Type.SymRef(sym, _)) if sym.isClass =>
+          case IsType(prefix @ Type.SymRef(IsClassSymbol(_), _)) =>
             printType(prefix)
             this += "#"
           case IsType(prefix) =>
@@ -1085,7 +1088,7 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
 
     def printFullClassName(tp: TypeOrBounds): Unit = {
       def printClassPrefix(prefix: TypeOrBounds): Unit = prefix match {
-        case Type.SymRef(sym, prefix2) if sym.isClass =>
+        case Type.SymRef(IsClassSymbol(sym), prefix2) =>
           printClassPrefix(prefix2)
           this += sym.name += "."
         case _ =>
@@ -1124,11 +1127,8 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
     def unapply(arg: Tree)(implicit ctx: Context): Option[(String, List[Term])] = arg match {
       case IsTerm(arg @ Term.Apply(fn, args)) =>
         fn.tpe match {
-          case Type.SymRef(sym, Type.ThisType(Type.SymRef(sym2, _))) if sym2.name == "<special-ops>" =>
-            sym.tree match {
-              case Some(DefDef(op, _, _, _, _)) => Some((op, args))
-              case _ => None
-            }
+          case Type.SymRef(IsDefSymbol(sym), Type.ThisType(Type.SymRef(sym2, _))) if sym2.name == "<special-ops>" =>
+            Some((sym.tree.name, args))
           case _ => None
         }
       case _ => None
diff --git a/tests/neg/tasty-macro-assert/quoted_1.scala b/tests/neg/tasty-macro-assert/quoted_1.scala
index ed2c7b87bab6..59c7d29a4378 100644
--- a/tests/neg/tasty-macro-assert/quoted_1.scala
+++ b/tests/neg/tasty-macro-assert/quoted_1.scala
@@ -20,11 +20,7 @@ object Asserts {
     val tree = cond.toTasty
 
     def isOps(tpe: TypeOrBounds): Boolean = tpe match {
-      case Type.SymRef(sym, _) =>
-        sym.tree match {
-          case Some(DefDef("Ops", _, _, _, _)) => true // TODO check that the parent is Asserts
-          case _ => false
-        }
+      case Type.SymRef(IsDefSymbol(sym), _) => sym.name == "Ops" // TODO check that the parent is Asserts
       case _ => false
     }
 
diff --git a/tests/run-custom-args/Yretain-trees/tasty-definitions-2.check b/tests/run-custom-args/Yretain-trees/tasty-definitions-2.check
index bf0bf9e9f070..8ec783b9eff8 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-definitions-2.check
+++ b/tests/run-custom-args/Yretain-trees/tasty-definitions-2.check
@@ -1,2 +1,3 @@
 DefDef("foo", Nil, Nil, TypeTree.Ident("Int"), Some(Term.Apply(Term.Select(Term.Literal(Constant.Int(1)), "+", Some(Signature(List(scala.Int), scala.Int))), List(Term.Literal(Constant.Int(2))))))
 ValDef("bar", TypeTree.Ident("Int"), Some(Term.Apply(Term.Select(Term.Literal(Constant.Int(2)), "+", Some(Signature(List(scala.Int), scala.Int))), List(Term.Literal(Constant.Int(3))))))
+Pattern.Bind("x", Pattern.Value(Term.Ident("_")))
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 99a314dfeefe..2764c8609800 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,11 +8,12 @@ object Foo {
 
   def inspectBodyImpl(x: Expr[Int])(implicit tasty: Tasty): Expr[String] = {
     import tasty._
-    def definitionString(tree: Tree): Expr[String] = tree.symbol.tree match {
-      case Some(definition) => definition.show.toExpr
-      case None => '("NO DEFINTION")
+    def definitionString(tree: Tree): Expr[String] = tree.symbol match {
+      case IsDefSymbol(sym) => sym.tree.show.toExpr
+      case IsValSymbol(sym) => sym.tree.show.toExpr
+      case IsBindSymbol(sym) => sym.tree.show.toExpr
     }
-     x.toTasty match {
+    x.toTasty match {
       case Term.Inlined(None, Nil, arg) => definitionString(arg)
       case arg => definitionString(arg) // TODO should all by name parameters be in an inline node?
     }
diff --git a/tests/run-custom-args/Yretain-trees/tasty-definitions-2/Test_2.scala b/tests/run-custom-args/Yretain-trees/tasty-definitions-2/Test_2.scala
index 323560068029..6bb234543066 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-definitions-2/Test_2.scala
+++ b/tests/run-custom-args/Yretain-trees/tasty-definitions-2/Test_2.scala
@@ -2,5 +2,10 @@ object Test {
   def main(args: Array[String]): Unit = {
     println(Foo.inspectBody(Foo.foo))
     println(Foo.inspectBody(Foo.bar))
+
+    3 match {
+      case x =>
+        println(Foo.inspectBody(x))
+    }
   }
 }
diff --git a/tests/run-custom-args/Yretain-trees/tasty-definitions-3.check b/tests/run-custom-args/Yretain-trees/tasty-definitions-3.check
index bf0bf9e9f070..8ec783b9eff8 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-definitions-3.check
+++ b/tests/run-custom-args/Yretain-trees/tasty-definitions-3.check
@@ -1,2 +1,3 @@
 DefDef("foo", Nil, Nil, TypeTree.Ident("Int"), Some(Term.Apply(Term.Select(Term.Literal(Constant.Int(1)), "+", Some(Signature(List(scala.Int), scala.Int))), List(Term.Literal(Constant.Int(2))))))
 ValDef("bar", TypeTree.Ident("Int"), Some(Term.Apply(Term.Select(Term.Literal(Constant.Int(2)), "+", Some(Signature(List(scala.Int), scala.Int))), List(Term.Literal(Constant.Int(3))))))
+Pattern.Bind("x", Pattern.Value(Term.Ident("_")))
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 2c24eb3b35db..f4ad6dd432fc 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,9 +8,10 @@ object Foo {
 
   def inspectBodyImpl(x: Expr[Int])(implicit tasty: Tasty): Expr[String] = {
     import tasty._
-     def definitionString(tree: Tree): Expr[String] = tree.symbol.tree match {
-      case Some(definition) => definition.show.toExpr
-      case None => '("NO DEFINTION")
+    def definitionString(tree: Tree): Expr[String] = tree.symbol match {
+      case IsDefSymbol(sym) => sym.tree.show.toExpr
+      case IsValSymbol(sym) => sym.tree.show.toExpr
+      case IsBindSymbol(sym) => sym.tree.show.toExpr
     }
     x.toTasty match {
       case Term.Inlined(None, Nil, arg) => definitionString(arg)
diff --git a/tests/run-custom-args/Yretain-trees/tasty-definitions-3/Test_2.scala b/tests/run-custom-args/Yretain-trees/tasty-definitions-3/Test_2.scala
index 9df0c7c1bfe5..3663f00a8198 100644
--- a/tests/run-custom-args/Yretain-trees/tasty-definitions-3/Test_2.scala
+++ b/tests/run-custom-args/Yretain-trees/tasty-definitions-3/Test_2.scala
@@ -3,6 +3,11 @@ object Test {
   def main(args: Array[String]): Unit = {
     println(Foo.inspectBody(foo))
     println(Foo.inspectBody(bar))
+
+    3 match {
+      case x =>
+        println(Foo.inspectBody(x))
+    }
   }
 
   def foo: Int = 1 + 2
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 861c20983489..d15bdc32e1e0 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
@@ -13,18 +13,27 @@ object Macros {
 
     val buff = new StringBuilder
 
+    implicit class SymOps(sym: Symbol) {
+      def treeOpt: Option[Tree] = sym match {
+        case IsClassSymbol(sym) => Some(sym.tree)
+        case IsDefSymbol(sym) => Some(sym.tree)
+        case IsValSymbol(sym) => Some(sym.tree)
+        case _ => None
+      }
+    }
+
     val output = new TreeTraverser(tasty) {
       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.tree.get.show)
+            buff.append(tree.symbol.owner.treeOpt.get.show)
             buff.append("\n\n")
           case IsDefinition(tree @ ValDef(name, _, _)) =>
             buff.append(name)
             buff.append("\n")
-            buff.append(tree.symbol.owner.tree.get.show)
+            buff.append(tree.symbol.owner.treeOpt.get.show)
             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 6e0b8d551d87..c86cfd34c63a 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
@@ -10,9 +10,11 @@ object Foo {
   def inspectBodyImpl(x: Expr[Int])(implicit tasty: Tasty): Expr[String] = {
     import tasty._
 
-    def definitionString(tree: Tree): Expr[String] = tree.symbol.tree match {
-      case Some(definition) => definition.show.toExpr
-      case None => '("NO DEFINTION")
+    def definitionString(tree: Tree): Expr[String] = tree.symbol match {
+      case IsClassSymbol(sym) => sym.tree.show.toExpr
+      case IsDefSymbol(sym) => sym.tree.show.toExpr
+      case IsValSymbol(sym) => sym.tree.show.toExpr
+      case _ => '("NO DEFINTION")
     }
 
     x.toTasty match {
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 7008417dac7a..93288b453058 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
@@ -10,9 +10,11 @@ object Foo {
   def inspectBodyImpl(x: Expr[Int])(implicit tasty: Tasty): Expr[String] = {
     import tasty._
 
-    def definitionString(tree: Tree): Expr[String] = tree.symbol.tree match {
-      case Some(definition) => definition.show.toExpr
-      case None => '("NO DEFINTION")
+    def definitionString(tree: Tree): Expr[String] = tree.symbol match {
+      case IsClassSymbol(sym) => sym.tree.show.toExpr
+      case IsDefSymbol(sym) => sym.tree.show.toExpr
+      case IsValSymbol(sym) => sym.tree.show.toExpr
+      case _ => '("NO DEFINTION")
     }
 
     x.toTasty match {
diff --git a/tests/run/tasty-custom-show/quoted_1.scala b/tests/run/tasty-custom-show/quoted_1.scala
index 22bc340678c6..b886e985c577 100644
--- a/tests/run/tasty-custom-show/quoted_1.scala
+++ b/tests/run/tasty-custom-show/quoted_1.scala
@@ -21,12 +21,12 @@ object Macros {
           case IsDefinition(tree @ DefDef(name, _, _, _, _)) =>
             buff.append(name)
             buff.append("\n")
-            buff.append(tree.symbol.owner.tree.get.show)
+            buff.append(tree.show)
             buff.append("\n\n")
           case IsDefinition(tree @ ValDef(name, _, _)) =>
             buff.append(name)
             buff.append("\n")
-            buff.append(tree.symbol.owner.tree.get.show)
+            buff.append(tree.show)
             buff.append("\n\n")
           case _ =>
         }
@@ -49,4 +49,5 @@ class DummyShow[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty0) {
   def showTypeOrBoundsTree(tpt: TypeOrBoundsTree)(implicit ctx: Context): String = "TypeOrBoundsTree"
   def showTypeOrBounds(tpe: TypeOrBounds)(implicit ctx: Context): String = "TypeOrBounds"
   def showConstant(const: Constant)(implicit ctx: Context): String = "Constant"
+  def showSymbol(symbol: Symbol)(implicit ctx: Context): String = "Symbol"
 }
diff --git a/tests/run/tasty-definitions-1.check b/tests/run/tasty-definitions-1.check
index 507aab21d794..88e8f9f8aa2b 100644
--- a/tests/run/tasty-definitions-1.check
+++ b/tests/run/tasty-definitions-1.check
@@ -155,18 +155,18 @@ Tuple21
 Tuple22
 List(Unit, Boolean, Byte, Short, Int, Long, Float, Double, Char)
 List(Byte, Short, Int, Long, Float, Double, Char)
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
-Type.SymRef(<scala.Byte>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
-Type.SymRef(<scala.Char>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
-Type.SymRef(<scala.Int>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
-Type.SymRef(<scala.Long>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
-Type.SymRef(<scala.Float>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
-Type.SymRef(<scala.Double>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
-Type.SymRef(<scala.Boolean>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
-Type.SymRef(<scala.Any>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
-Type.SymRef(<scala.AnyVal>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
-Type.SymRef(<scala.AnyRef>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
-Type.SymRef(<java.lang.Object>, Type.ThisType(Type.SymRef(<java.lang>, NoPrefix())))
-Type.SymRef(<scala.Nothing>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
-Type.SymRef(<scala.Null>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
-Type.SymRef(<java.lang.String>, Type.ThisType(Type.SymRef(<java.lang>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Byte>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Char>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Int>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Long>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Float>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Double>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Boolean>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Any>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.AnyVal>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
+Type.SymRef(IsTypeSymbol(<scala.AnyRef>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
+Type.SymRef(IsClassSymbol(<java.lang.Object>), Type.ThisType(Type.SymRef(IsPackageSymbol(<java.lang>), NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Nothing>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Null>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
+Type.SymRef(IsClassSymbol(<java.lang.String>), Type.ThisType(Type.SymRef(IsPackageSymbol(<java.lang>), NoPrefix())))
diff --git a/tests/run/tasty-eval/quoted_1.scala b/tests/run/tasty-eval/quoted_1.scala
index 11ca7f81e4b3..db8c8adc0734 100644
--- a/tests/run/tasty-eval/quoted_1.scala
+++ b/tests/run/tasty-eval/quoted_1.scala
@@ -23,16 +23,11 @@ object Macros {
       import tasty._
 
       e.toTasty.tpe match {
-        case Type.SymRef(sym, pre) =>
-          sym.tree match {
-            case Some(ValDef(_, tpt, _)) =>
-              tpt.tpe match {
-                case Type.ConstantType(Constant.Int(i)) => Some(i)
-                case _ => None
-              }
+        case Type.SymRef(IsValSymbol(sym), pre) =>
+          sym.tree.tpt.tpe match {
+            case Type.ConstantType(Constant.Int(i)) => Some(i)
             case _ => None
           }
-
         case Type.ConstantType(Constant.Int(i)) => Some(i)
         case _ => None
       }
diff --git a/tests/run/tasty-extractors-1.check b/tests/run/tasty-extractors-1.check
index 2e44782722e3..3fbae43cd759 100644
--- a/tests/run/tasty-extractors-1.check
+++ b/tests/run/tasty-extractors-1.check
@@ -17,16 +17,16 @@ Term.Literal(Constant.String("abc"))
 Type.ConstantType(Constant.String("abc"))
 
 Term.Inlined(None, Nil, Term.Apply(Term.Ident("println"), List(Term.Literal(Constant.String("abc")))))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Typed(Term.Literal(Constant.Int(8)), TypeTree.Ident("Int")))
-Type.SymRef(<scala.Int>, Type.SymRef(<scala>, Type.ThisType(Type.SymRef(<<root>>, NoPrefix()))))
+Type.SymRef(IsClassSymbol(<scala.Int>), Type.SymRef(IsPackageSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageSymbol(<<root>>), NoPrefix()))))
 
 Term.Inlined(None, Nil, Term.Typed(Term.Literal(Constant.Byte(8)), TypeTree.Ident("Byte")))
-Type.SymRef(<scala.Byte>, Type.SymRef(<scala>, Type.ThisType(Type.SymRef(<<root>>, NoPrefix()))))
+Type.SymRef(IsClassSymbol(<scala.Byte>), Type.SymRef(IsPackageSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageSymbol(<<root>>), NoPrefix()))))
 
 Term.Inlined(None, Nil, Term.Typed(Term.Literal(Constant.Short(8)), TypeTree.Ident("Short")))
-Type.SymRef(<scala.Short>, Type.SymRef(<scala>, Type.ThisType(Type.SymRef(<<root>>, NoPrefix()))))
+Type.SymRef(IsClassSymbol(<scala.Short>), Type.SymRef(IsPackageSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageSymbol(<<root>>), NoPrefix()))))
 
 Term.Literal(Constant.Char(a))
 Type.ConstantType(Constant.Char(a))
@@ -35,86 +35,86 @@ Term.Inlined(None, Nil, Term.Block(List(Term.Literal(Constant.Int(1)), Term.Lite
 Type.ConstantType(Constant.Int(3))
 
 Term.Inlined(None, Nil, Term.If(Term.Typed(Term.Literal(Constant.Boolean(true)), TypeTree.Ident("Boolean")), Term.Literal(Constant.Int(1)), Term.Literal(Constant.Int(2))))
-Type.SymRef(<scala.Int>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Int>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Match(Term.Literal(Constant.String("a")), List(CaseDef(Pattern.Value(Term.Literal(Constant.String("a"))), None, Term.Literal(Constant.Unit())))))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Match(Term.Literal(Constant.String("b")), List(CaseDef(Pattern.Bind("n", Pattern.Value(Term.Ident("_"))), None, Term.Literal(Constant.Unit())))))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Match(Term.Literal(Constant.String("c")), List(CaseDef(Pattern.Bind("n", Pattern.TypeTest(TypeTree.Ident("String"))), None, Term.Literal(Constant.Unit())))))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Match(Term.Literal(Constant.String("e")), List(CaseDef(Pattern.Value(Term.Ident("_")), None, Term.Literal(Constant.Unit())))))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Match(Term.Literal(Constant.String("f")), List(CaseDef(Pattern.TypeTest(TypeTree.Ident("String")), None, Term.Literal(Constant.Unit())))))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Match(Term.Typed(Term.Literal(Constant.String("g")), TypeTree.Ident("Any")), List(CaseDef(Pattern.Alternative(List(Pattern.TypeTest(TypeTree.Ident("String")), Pattern.TypeTest(TypeTree.Ident("Int")))), None, Term.Literal(Constant.Unit())))))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Match(Term.Literal(Constant.String("h")), List(CaseDef(Pattern.Value(Term.Ident("_")), Some(Term.Literal(Constant.Boolean(false))), Term.Literal(Constant.Unit())))))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ValDef("a", TypeTree.Synthetic(), Some(Term.Literal(Constant.String("o"))))), Term.Match(Term.Literal(Constant.String("i")), List(CaseDef(Pattern.Bind("a", Pattern.Value(Term.Ident("_"))), None, Term.Literal(Constant.Unit()))))))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Match(Term.Ident("Nil"), List(CaseDef(Pattern.Unapply(Term.TypeApply(Term.Select(Term.Ident("List"), "unapplySeq", Some(Signature(List(scala.collection.Seq), scala.Some))), List(TypeTree.Synthetic())), Nil, List(Pattern.Bind("a", Pattern.Value(Term.Ident("_"))), Pattern.Bind("b", Pattern.Value(Term.Ident("_"))), Pattern.Bind("c", Pattern.Value(Term.Ident("_"))))), None, Term.Literal(Constant.Unit())))))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Try(Term.Literal(Constant.Int(1)), List(CaseDef(Pattern.Value(Term.Ident("_")), None, Term.Literal(Constant.Unit()))), None))
-Type.OrType(Type.SymRef(<scala.Int>, Type.ThisType(Type.SymRef(<scala>, NoPrefix()))), Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix()))))
+Type.OrType(Type.SymRef(IsClassSymbol(<scala.Int>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix()))), Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix()))))
 
 Term.Inlined(None, Nil, Term.Try(Term.Literal(Constant.Int(2)), Nil, Some(Term.Literal(Constant.Unit()))))
 Type.ConstantType(Constant.Int(2))
 
 Term.Inlined(None, Nil, Term.Try(Term.Literal(Constant.Int(3)), List(CaseDef(Pattern.Value(Term.Ident("_")), None, Term.Literal(Constant.Unit()))), Some(Term.Literal(Constant.Unit()))))
-Type.OrType(Type.SymRef(<scala.Int>, Type.ThisType(Type.SymRef(<scala>, NoPrefix()))), Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix()))))
+Type.OrType(Type.SymRef(IsClassSymbol(<scala.Int>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix()))), Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix()))))
 
 Term.Inlined(None, Nil, Term.Apply(Term.Select(Term.Literal(Constant.String("a")), "==", Some(Signature(List(java.lang.Object), scala.Boolean))), List(Term.Literal(Constant.String("b")))))
-Type.SymRef(<scala.Boolean>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Boolean>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Apply(Term.Select(Term.New(TypeTree.Ident("Object")), "<init>", Some(Signature(Nil, java.lang.Object))), Nil))
-Type.SymRef(<java.lang.Object>, Type.ThisType(Type.SymRef(<java.lang>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<java.lang.Object>), Type.ThisType(Type.SymRef(IsPackageSymbol(<java.lang>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Apply(Term.Select(Term.Ident("Int"), "box", Some(Signature(List(scala.Int), java.lang.Integer))), List(Term.NamedArg("x", Term.Literal(Constant.Int(9))))))
-Type.SymRef(<java.lang.Integer>, Type.ThisType(Type.SymRef(<java.lang>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<java.lang.Integer>), Type.ThisType(Type.SymRef(IsPackageSymbol(<java.lang>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Apply(Term.TypeApply(Term.Select(Term.Ident("Ordering"), "apply", Some(Signature(List(scala.math.Ordering), scala.math.Ordering))), List(TypeTree.Ident("Int"))), List(Term.Ident("Int"))))
-Type.AppliedType(Type.SymRef(<scala.math.Ordering>, Type.ThisType(Type.SymRef(<scala.math>, NoPrefix()))), List(Type.SymRef(<scala.Int>, Type.SymRef(<scala>, Type.ThisType(Type.SymRef(<<root>>, NoPrefix()))))))
+Type.AppliedType(Type.SymRef(IsClassSymbol(<scala.math.Ordering>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala.math>), NoPrefix()))), List(Type.SymRef(IsClassSymbol(<scala.Int>), Type.SymRef(IsPackageSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageSymbol(<<root>>), NoPrefix()))))))
 
 Term.Inlined(None, Nil, Term.Block(List(ValDef("a", TypeTree.Ident("Int"), Some(Term.Literal(Constant.Int(3))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ValDef("b", TypeTree.Ident("Int"), Some(Term.Literal(Constant.Int(3))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(DefDef("f1", Nil, Nil, TypeTree.Ident("Int"), Some(Term.Literal(Constant.Int(3))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(DefDef("f2", Nil, Nil, TypeTree.Ident("Int"), Some(Term.Return(Term.Literal(Constant.Int(4)))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(DefDef("f3", Nil, List(List(ValDef("i", TypeTree.Ident("Int"), None))), TypeTree.Ident("Int"), Some(Term.Ident("i")))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(DefDef("f4", Nil, List(List(ValDef("i", TypeTree.Ident("Int"), None)), List(ValDef("j", TypeTree.Ident("Int"), None))), TypeTree.Ident("Int"), Some(Term.Apply(Term.Select(Term.Ident("i"), "+", Some(Signature(List(scala.Int), scala.Int))), List(Term.Ident("j")))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(DefDef("f5", Nil, List(List(ValDef("i", TypeTree.Ident("Int"), None))), TypeTree.Ident("Int"), Some(Term.Ident("i"))), DefDef("f5$default$1", Nil, Nil, TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(9))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(DefDef("f6", List(TypeDef("T", TypeBoundsTree(TypeTree.Synthetic(), TypeTree.Synthetic()))), List(List(ValDef("x", TypeTree.Ident("T"), None))), TypeTree.Ident("T"), Some(Term.Ident("x")))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(DefDef("f7", List(TypeDef("T", TypeBoundsTree(TypeTree.Synthetic(), TypeTree.Synthetic()))), List(List(ValDef("x", TypeTree.Ident("T"), None))), TypeTree.Singleton(Term.Ident("x")), Some(Term.Ident("x")))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(DefDef("f8", Nil, List(List(ValDef("i", TypeTree.Annotated(TypeTree.Applied(TypeTree.Synthetic(), List(TypeTree.Ident("Int"))), Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, scala.annotation.internal.Repeated))), Nil)), None))), TypeTree.Ident("Int"), Some(Term.Literal(Constant.Int(9))))), Term.Apply(Term.Ident("f8"), List(Term.Typed(Term.Repeated(List(Term.Literal(Constant.Int(1)), Term.Literal(Constant.Int(2)), Term.Literal(Constant.Int(3)))), TypeTree.Synthetic())))))
-Type.SymRef(<scala.Int>, Type.SymRef(<scala>, Type.ThisType(Type.SymRef(<<root>>, NoPrefix()))))
+Type.SymRef(IsClassSymbol(<scala.Int>), Type.SymRef(IsPackageSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageSymbol(<<root>>), NoPrefix()))))
 
 Term.Inlined(None, Nil, Term.Block(List(DefDef("f9", Nil, List(List(ValDef("i", TypeTree.ByName(TypeTree.Ident("Int")), None))), TypeTree.Ident("Int"), Some(Term.Ident("i")))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
diff --git a/tests/run/tasty-extractors-2.check b/tests/run/tasty-extractors-2.check
index b376e56472f7..992426301e8d 100644
--- a/tests/run/tasty-extractors-2.check
+++ b/tests/run/tasty-extractors-2.check
@@ -1,105 +1,105 @@
 Term.Inlined(None, Nil, Term.Block(List(ValDef("x", TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(1))))), Term.Assign(Term.Ident("x"), Term.Literal(Constant.Int(2)))))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(DefDef("$anonfun", Nil, List(List(ValDef("x", TypeTree.Ident("Int"), None))), TypeTree.Synthetic(), Some(Term.Ident("x")))), Term.Lambda(Term.Ident("$anonfun"), None)))
-Type.AppliedType(Type.SymRef(<scala.Function1>, Type.ThisType(Type.SymRef(<scala>, NoPrefix()))), List(Type.SymRef(<scala.Int>, Type.SymRef(<scala>, Type.ThisType(Type.SymRef(<<root>>, NoPrefix())))), Type.SymRef(<scala.Int>, Type.SymRef(<scala>, Type.ThisType(Type.SymRef(<<root>>, NoPrefix()))))))
+Type.AppliedType(Type.SymRef(IsClassSymbol(<scala.Function1>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix()))), List(Type.SymRef(IsClassSymbol(<scala.Int>), Type.SymRef(IsPackageSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageSymbol(<<root>>), NoPrefix())))), Type.SymRef(IsClassSymbol(<scala.Int>), Type.SymRef(IsPackageSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageSymbol(<<root>>), NoPrefix()))))))
 
 Term.Inlined(None, Nil, Term.Ident("???"))
-Type.SymRef(<scala.Predef$.???>, Type.SymRef(<scala.Predef>, Type.ThisType(Type.SymRef(<scala>, NoPrefix()))))
+Type.SymRef(IsDefSymbol(<scala.Predef$.???>), Type.SymRef(IsValSymbol(<scala.Predef>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix()))))
 
 Term.Literal(Constant.Int(1))
 Type.ConstantType(Constant.Int(1))
 
 Term.Inlined(None, Nil, Term.Typed(Term.Literal(Constant.Int(1)), TypeTree.Ident("Int")))
-Type.SymRef(<scala.Int>, Type.SymRef(<scala>, Type.ThisType(Type.SymRef(<<root>>, NoPrefix()))))
+Type.SymRef(IsClassSymbol(<scala.Int>), Type.SymRef(IsPackageSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageSymbol(<<root>>), NoPrefix()))))
 
 Term.Inlined(None, Nil, Term.Typed(Term.Ident("Nil"), TypeTree.Applied(TypeTree.Ident("List"), List(TypeTree.Ident("Int")))))
-Type.AppliedType(Type.SymRef(<scala.collection.immutable.List>, Type.ThisType(Type.SymRef(<scala.collection.immutable>, NoPrefix()))), List(Type.SymRef(<scala.Int>, Type.SymRef(<scala>, Type.ThisType(Type.SymRef(<<root>>, NoPrefix()))))))
+Type.AppliedType(Type.SymRef(IsClassSymbol(<scala.collection.immutable.List>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala.collection.immutable>), NoPrefix()))), List(Type.SymRef(IsClassSymbol(<scala.Int>), Type.SymRef(IsPackageSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageSymbol(<<root>>), NoPrefix()))))))
 
 Term.Inlined(None, Nil, Term.Typed(Term.Apply(Term.Select(Term.New(TypeTree.Ident("Baz")), "<init>", Some(Signature(Nil, Baz))), Nil), TypeTree.And(TypeTree.Ident("Foo"), TypeTree.Ident("Bar"))))
-Type.AndType(Type.SymRef(<Foo>, Type.ThisType(Type.SymRef(<<empty>>, NoPrefix()))), Type.SymRef(<Bar>, Type.ThisType(Type.SymRef(<<empty>>, NoPrefix()))))
+Type.AndType(Type.SymRef(IsClassSymbol(<Foo>), Type.ThisType(Type.SymRef(IsPackageSymbol(<<empty>>), NoPrefix()))), Type.SymRef(IsClassSymbol(<Bar>), Type.ThisType(Type.SymRef(IsPackageSymbol(<<empty>>), NoPrefix()))))
 
 Term.Inlined(None, Nil, Term.Typed(Term.Literal(Constant.Int(1)), TypeTree.Or(TypeTree.Ident("Int"), TypeTree.Ident("String"))))
-Type.OrType(Type.SymRef(<scala.Int>, Type.SymRef(<scala>, Type.ThisType(Type.SymRef(<<root>>, NoPrefix())))), Type.SymRef(<scala.Predef$.String>, Type.SymRef(<scala.Predef>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))))
+Type.OrType(Type.SymRef(IsClassSymbol(<scala.Int>), Type.SymRef(IsPackageSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageSymbol(<<root>>), NoPrefix())))), Type.SymRef(IsTypeSymbol(<scala.Predef$.String>), Type.SymRef(IsValSymbol(<scala.Predef>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, Nil)), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ValDef("Foo", TypeTree.Ident("Foo$"), Some(Term.Apply(Term.Select(Term.New(TypeTree.Ident("Foo$")), "<init>", Some(Signature(Nil, Test$._$Foo$))), Nil))), ClassDef("Foo$", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), Some(ValDef("_", TypeTree.Singleton(Term.Ident("Foo")), None)), Nil)), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(TypeDef("Foo", TypeBoundsTree(TypeTree.Synthetic(), TypeTree.Synthetic()))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(TypeDef("Foo", TypeTree.Ident("Int"))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(TypeDef("Foo", TypeBoundsTree(TypeTree.Ident("Null"), TypeTree.Ident("Object")))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(0)))), DefDef("a_=", Nil, List(List(ValDef("x$1", TypeTree.Synthetic(), None))), TypeTree.Synthetic(), Some(Term.Literal(Constant.Unit())))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(DefDef("a", Nil, Nil, TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(0))))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(DefDef("a", Nil, Nil, TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(0))))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(DefDef("a", Nil, Nil, TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(0))))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil), TypeTree.Select(Term.Select(Term.Ident("_root_"), "scala", None), "Product")), None, List(DefDef("copy", Nil, List(Nil), TypeTree.Synthetic(), Some(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, Test$._$Foo))), Nil))), DefDef("hashCode", Nil, List(Nil), TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(394005536)))), DefDef("equals", Nil, List(List(ValDef("x$0", TypeTree.Synthetic(), None))), TypeTree.Synthetic(), Some(Term.Apply(Term.Select(Term.Apply(Term.Select(Term.This(Some(Id("Foo"))), "eq", Some(Signature(List(java.lang.Object), scala.Boolean))), List(Term.TypeApply(Term.Select(Term.Ident("x$0"), "asInstanceOf", Some(Signature(Nil, java.lang.Object))), List(TypeTree.Synthetic())))), "||", Some(Signature(List(scala.Boolean), scala.Boolean))), List(Term.Match(Term.Ident("x$0"), List(CaseDef(Pattern.Bind("x$0", Pattern.TypeTest(TypeTree.Synthetic())), None, Term.Literal(Constant.Boolean(true))), CaseDef(Pattern.Value(Term.Ident("_")), None, Term.Literal(Constant.Boolean(false))))))))), DefDef("toString", Nil, List(Nil), TypeTree.Synthetic(), Some(Term.Apply(Term.Ident("_toString"), List(Term.This(Some(Id("Foo"))))))), DefDef("canEqual", Nil, List(List(ValDef("that", TypeTree.Synthetic(), None))), TypeTree.Synthetic(), Some(Term.TypeApply(Term.Select(Term.Ident("that"), "isInstanceOf", Some(Signature(Nil, scala.Boolean))), List(TypeTree.Synthetic())))), DefDef("productArity", Nil, Nil, TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(0)))), DefDef("productPrefix", Nil, Nil, TypeTree.Synthetic(), Some(Term.Literal(Constant.String("Foo")))), DefDef("productElement", Nil, List(List(ValDef("n", TypeTree.Synthetic(), None))), TypeTree.Synthetic(), Some(Term.Match(Term.Ident("n"), List(CaseDef(Pattern.Value(Term.Ident("_")), None, Term.Apply(Term.Ident("throw"), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(List(java.lang.String), java.lang.IndexOutOfBoundsException))), List(Term.Apply(Term.Select(Term.Ident("n"), "toString", Some(Signature(Nil, java.lang.String))), Nil)))))))))))), ValDef("Foo", TypeTree.Ident("Foo$"), Some(Term.Apply(Term.Select(Term.New(TypeTree.Ident("Foo$")), "<init>", Some(Signature(Nil, Test$._$Foo$))), Nil))), ClassDef("Foo$", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil), TypeTree.Applied(TypeTree.Synthetic(), List(TypeTree.Synthetic()))), Some(ValDef("_", TypeTree.Singleton(Term.Ident("Foo")), None)), List(DefDef("apply", Nil, List(Nil), TypeTree.Synthetic(), Some(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, Test$._$Foo))), Nil))), DefDef("unapply", Nil, List(List(ValDef("x$1", TypeTree.Synthetic(), None))), TypeTree.Synthetic(), Some(Term.Literal(Constant.Boolean(true))))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo1", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.Ident("Int"), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), None)))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo2", DefDef("<init>", Nil, List(List(ValDef("b", TypeTree.Ident("Int"), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("b", TypeTree.Synthetic(), None)))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo3", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.Ident("Int"), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), None))), ValDef("Foo3", TypeTree.Ident("Foo3$"), Some(Term.Apply(Term.Select(Term.New(TypeTree.Ident("Foo3$")), "<init>", Some(Signature(Nil, Test$._$Foo3$))), Nil))), ClassDef("Foo3$", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), Some(ValDef("_", TypeTree.Singleton(Term.Ident("Foo3")), None)), List(DefDef("$lessinit$greater$default$1", Nil, Nil, TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(5))))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo4", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.Ident("Int"), None)), List(ValDef("b", TypeTree.Ident("Int"), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), None), ValDef("b", TypeTree.Synthetic(), None)))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo5", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.Ident("Int"), None)), List(ValDef("b", TypeTree.Ident("Int"), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), None), ValDef("b", TypeTree.Synthetic(), None))), ValDef("Foo5", TypeTree.Ident("Foo5$"), Some(Term.Apply(Term.Select(Term.New(TypeTree.Ident("Foo5$")), "<init>", Some(Signature(Nil, Test$._$Foo5$))), Nil))), ClassDef("Foo5$", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), Some(ValDef("_", TypeTree.Singleton(Term.Ident("Foo5")), None)), List(DefDef("$lessinit$greater$default$2", Nil, List(List(ValDef("a", TypeTree.Ident("Int"), None))), TypeTree.Synthetic(), Some(Term.Ident("a")))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo6", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.Ident("Int"), None)), List(ValDef("b", TypeTree.Singleton(Term.Ident("a")), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), None), ValDef("b", TypeTree.Synthetic(), None)))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo7", DefDef("<init>", Nil, List(List(ValDef("a", TypeTree.Ident("Int"), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), None), DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), Some(Term.Block(List(Term.Apply(Term.Select(Term.This(Some(Id("Foo7"))), "<init>", Some(Signature(List(scala.Int), Test$._$Foo7))), List(Term.Literal(Constant.Int(6))))), Term.Literal(Constant.Unit()))))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo8", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(Term.Apply(Term.Ident("println"), List(Term.Literal(Constant.Int(0))))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo10", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(9))))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo11", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(10)))), DefDef("a_=", Nil, List(List(ValDef("x$1", TypeTree.Synthetic(), None))), TypeTree.Synthetic(), Some(Term.Literal(Constant.Unit())))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo12", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("a", TypeTree.Synthetic(), Some(Term.Literal(Constant.Int(11))))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, Nil), ClassDef("Bar", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Ident("Foo")), "<init>", Some(Signature(Nil, Test$._$Foo))), Nil)), None, Nil)), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo2", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(TypeTree.Synthetic()), None, Nil), ClassDef("Bar", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil), TypeTree.Ident("Foo2")), None, Nil)), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(List(ValDef("i", TypeTree.Ident("Int"), None))), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(ValDef("i", TypeTree.Synthetic(), None))), ClassDef("Bar", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Ident("Foo")), "<init>", Some(Signature(List(scala.Int), Test$._$Foo))), List(Term.Literal(Constant.Int(1))))), None, Nil)), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(TypeDef("X", TypeTree.Ident("Int")))), DefDef("f", Nil, List(List(ValDef("a", TypeTree.Ident("Foo"), None))), TypeTree.Select(Term.Ident("a"), "X"), Some(Term.Ident("???")))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ClassDef("Foo", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(TypeDef("X", TypeBoundsTree(TypeTree.Synthetic(), TypeTree.Synthetic())))), DefDef("f", Nil, List(List(ValDef("a", TypeTree.Refined(TypeTree.Ident("Foo"), List(TypeDef("X", TypeTree.Ident("Int")))), None))), TypeTree.Select(Term.Ident("a"), "X"), Some(Term.Ident("???")))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
 Term.Inlined(None, Nil, Term.Block(List(ValDef("lambda", TypeTree.Applied(TypeTree.Synthetic(), List(TypeTree.Ident("Int"), TypeTree.Ident("Int"))), Some(Term.Block(List(DefDef("$anonfun", Nil, List(List(ValDef("x", TypeTree.Synthetic(), None))), TypeTree.Synthetic(), Some(Term.Ident("x")))), Term.Lambda(Term.Ident("$anonfun"), None))))), Term.Literal(Constant.Unit())))
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
diff --git a/tests/run/tasty-extractors-3.check b/tests/run/tasty-extractors-3.check
index d7dc393a6343..c543ea5cf05e 100644
--- a/tests/run/tasty-extractors-3.check
+++ b/tests/run/tasty-extractors-3.check
@@ -1,42 +1,42 @@
-Type.SymRef(<scala.Int>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Int>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
-Type.SymRef(<Test$._$x>, NoPrefix())
+Type.SymRef(IsValSymbol(<Test$._$x>), NoPrefix())
 
-TypeBounds(Type.SymRef(<scala.Nothing>, Type.ThisType(Type.SymRef(<scala>, NoPrefix()))), Type.SymRef(<scala.Any>, Type.ThisType(Type.SymRef(<scala>, NoPrefix()))))
+TypeBounds(Type.SymRef(IsClassSymbol(<scala.Nothing>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix()))), Type.SymRef(IsClassSymbol(<scala.Any>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix()))))
 
-Type.SymRef(<scala.Nothing>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Nothing>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
-Type.SymRef(<scala.Any>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Any>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
-Type.SymRef(<Test$._$_$T>, NoPrefix())
+Type.SymRef(IsTypeSymbol(<Test$._$_$T>), NoPrefix())
 
-TypeBounds(Type.SymRef(<scala.Int>, Type.SymRef(<scala>, Type.ThisType(Type.SymRef(<<root>>, NoPrefix())))), Type.SymRef(<scala.Int>, Type.SymRef(<scala>, Type.ThisType(Type.SymRef(<<root>>, NoPrefix())))))
+TypeBounds(Type.SymRef(IsClassSymbol(<scala.Int>), Type.SymRef(IsPackageSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageSymbol(<<root>>), NoPrefix())))), Type.SymRef(IsClassSymbol(<scala.Int>), Type.SymRef(IsPackageSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageSymbol(<<root>>), NoPrefix())))))
 
-Type.SymRef(<scala.Int>, Type.SymRef(<scala>, Type.ThisType(Type.SymRef(<<root>>, NoPrefix()))))
+Type.SymRef(IsClassSymbol(<scala.Int>), Type.SymRef(IsPackageSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageSymbol(<<root>>), NoPrefix()))))
 
-Type.SymRef(<scala.Int>, Type.SymRef(<scala>, Type.ThisType(Type.SymRef(<<root>>, NoPrefix()))))
+Type.SymRef(IsClassSymbol(<scala.Int>), Type.SymRef(IsPackageSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageSymbol(<<root>>), NoPrefix()))))
 
-Type.SymRef(<Test$._$_$T>, NoPrefix())
+Type.SymRef(IsTypeSymbol(<Test$._$_$T>), NoPrefix())
 
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
-Type.SymRef(<java.lang.Object>, Type.ThisType(Type.SymRef(<java.lang>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<java.lang.Object>), Type.ThisType(Type.SymRef(IsPackageSymbol(<java.lang>), NoPrefix())))
 
-TypeBounds(Type.SymRef(<scala.Nothing>, Type.ThisType(Type.SymRef(<scala>, NoPrefix()))), Type.SymRef(<scala.Any>, Type.ThisType(Type.SymRef(<scala>, NoPrefix()))))
+TypeBounds(Type.SymRef(IsClassSymbol(<scala.Nothing>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix()))), Type.SymRef(IsClassSymbol(<scala.Any>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix()))))
 
-Type.SymRef(<scala.Nothing>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Nothing>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
-Type.SymRef(<scala.Any>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Any>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
-Type.Refinement(Type.SymRef(<Test$._$Foo>, NoPrefix()), X, TypeBounds(Type.SymRef(<scala.Predef$.String>, Type.SymRef(<scala.Predef>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))), Type.SymRef(<scala.Predef$.String>, Type.SymRef(<scala.Predef>, Type.ThisType(Type.SymRef(<scala>, NoPrefix()))))))
+Type.Refinement(Type.SymRef(IsClassSymbol(<Test$._$Foo>), NoPrefix()), X, TypeBounds(Type.SymRef(IsTypeSymbol(<scala.Predef$.String>), Type.SymRef(IsValSymbol(<scala.Predef>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))), Type.SymRef(IsTypeSymbol(<scala.Predef$.String>), Type.SymRef(IsValSymbol(<scala.Predef>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix()))))))
 
-Type.SymRef(<scala.Unit>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))
+Type.SymRef(IsClassSymbol(<scala.Unit>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))
 
-Type.SymRef(<Test$._$Foo>, NoPrefix())
+Type.SymRef(IsClassSymbol(<Test$._$Foo>), NoPrefix())
 
-Type.SymRef(<scala.Predef$.String>, Type.SymRef(<scala.Predef>, Type.ThisType(Type.SymRef(<scala>, NoPrefix()))))
+Type.SymRef(IsTypeSymbol(<scala.Predef$.String>), Type.SymRef(IsValSymbol(<scala.Predef>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix()))))
 
-Type.SymRef(<Test$._$_$$anon>, NoPrefix())
+Type.SymRef(IsClassSymbol(<Test$._$_$$anon>), NoPrefix())
 
-Type.Refinement(Type.SymRef(<Test$._$Foo>, NoPrefix()), X, TypeBounds(Type.SymRef(<scala.Predef$.String>, Type.SymRef(<scala.Predef>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))), Type.SymRef(<scala.Predef$.String>, Type.SymRef(<scala.Predef>, Type.ThisType(Type.SymRef(<scala>, NoPrefix()))))))
+Type.Refinement(Type.SymRef(IsClassSymbol(<Test$._$Foo>), NoPrefix()), X, TypeBounds(Type.SymRef(IsTypeSymbol(<scala.Predef$.String>), Type.SymRef(IsValSymbol(<scala.Predef>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))), Type.SymRef(IsTypeSymbol(<scala.Predef$.String>), Type.SymRef(IsValSymbol(<scala.Predef>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix()))))))
 
diff --git a/tests/run/tasty-extractors-types.check b/tests/run/tasty-extractors-types.check
index 6707ff0c5103..cf3856f1b7d8 100644
--- a/tests/run/tasty-extractors-types.check
+++ b/tests/run/tasty-extractors-types.check
@@ -1,12 +1,12 @@
 TypeTree.Synthetic()
-Type.SymRef(<scala.Int>, Type.SymRef(<scala>, Type.ThisType(Type.SymRef(<<root>>, NoPrefix()))))
+Type.SymRef(IsClassSymbol(<scala.Int>), Type.SymRef(IsPackageSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageSymbol(<<root>>), NoPrefix()))))
 
 TypeTree.Synthetic()
-Type.AppliedType(Type.SymRef(<scala.collection.immutable.List>, Type.ThisType(Type.SymRef(<scala.collection.immutable>, NoPrefix()))), List(Type.SymRef(<scala.Predef$.String>, Type.SymRef(<scala.Predef>, Type.ThisType(Type.SymRef(<scala>, NoPrefix()))))))
+Type.AppliedType(Type.SymRef(IsClassSymbol(<scala.collection.immutable.List>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala.collection.immutable>), NoPrefix()))), List(Type.SymRef(IsTypeSymbol(<scala.Predef$.String>), Type.SymRef(IsValSymbol(<scala.Predef>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix()))))))
 
 TypeTree.Synthetic()
-Type.AppliedType(Type.SymRef(<scala.collection.immutable.Map>, Type.ThisType(Type.SymRef(<scala.collection.immutable>, NoPrefix()))), List(Type.SymRef(<scala.Predef$.String>, Type.SymRef(<scala.Predef>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))), Type.SymRef(<scala.Int>, Type.SymRef(<scala>, Type.ThisType(Type.SymRef(<<root>>, NoPrefix()))))))
+Type.AppliedType(Type.SymRef(IsClassSymbol(<scala.collection.immutable.Map>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala.collection.immutable>), NoPrefix()))), List(Type.SymRef(IsTypeSymbol(<scala.Predef$.String>), Type.SymRef(IsValSymbol(<scala.Predef>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))), Type.SymRef(IsClassSymbol(<scala.Int>), Type.SymRef(IsPackageSymbol(<scala>), Type.ThisType(Type.SymRef(IsPackageSymbol(<<root>>), NoPrefix()))))))
 
 TypeTree.Synthetic()
-Type.AppliedType(Type.SymRef(<scala.collection.immutable.Map>, Type.ThisType(Type.SymRef(<scala.collection.immutable>, NoPrefix()))), List(Type.SymRef(<scala.Predef$.String>, Type.SymRef(<scala.Predef>, Type.ThisType(Type.SymRef(<scala>, NoPrefix())))), Type.SymRef(<Test$._$I>, NoPrefix())))
+Type.AppliedType(Type.SymRef(IsClassSymbol(<scala.collection.immutable.Map>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala.collection.immutable>), NoPrefix()))), List(Type.SymRef(IsTypeSymbol(<scala.Predef$.String>), Type.SymRef(IsValSymbol(<scala.Predef>), Type.ThisType(Type.SymRef(IsPackageSymbol(<scala>), NoPrefix())))), Type.SymRef(IsTypeSymbol(<Test$._$I>), NoPrefix())))
 
diff --git a/tests/run/tasty-macro-assert/quoted_1.scala b/tests/run/tasty-macro-assert/quoted_1.scala
index 4b481225a9db..a3cb5ab55d34 100644
--- a/tests/run/tasty-macro-assert/quoted_1.scala
+++ b/tests/run/tasty-macro-assert/quoted_1.scala
@@ -20,11 +20,7 @@ object Asserts {
     val tree = cond.toTasty
 
     def isOps(tpe: TypeOrBounds): Boolean = tpe match {
-      case Type.SymRef(sym, _) =>
-        sym.tree match {
-          case Some(DefDef("Ops", _, _, _, _)) => true // TODO check that the parent is Asserts
-          case _ => false
-        }
+      case Type.SymRef(IsDefSymbol(sym), _) => sym.name == "Ops"// TODO check that the parent is Asserts
       case _ => false
     }