diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/CoreImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/CoreImpl.scala
index 3b89b42b7b1c..0682c5c5bbfe 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/CoreImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/CoreImpl.scala
@@ -127,4 +127,6 @@ trait CoreImpl extends scala.tasty.reflect.Core {
     type BindSymbol = core.Symbols.TermSymbol
     type ValSymbol = core.Symbols.TermSymbol
     type NoSymbol = core.Symbols.NoSymbol.type
+
+  type Flags = core.Flags.FlagSet
 }
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/FlagSet.scala b/compiler/src/dotty/tools/dotc/tastyreflect/FlagSet.scala
deleted file mode 100644
index 54918c3ce27e..000000000000
--- a/compiler/src/dotty/tools/dotc/tastyreflect/FlagSet.scala
+++ /dev/null
@@ -1,68 +0,0 @@
-package dotty.tools.dotc.tastyreflect
-
-import dotty.tools.dotc.core.Flags
-import dotty.tools.dotc.core.Flags._
-
-class FlagSet(flags: Flags.FlagSet) extends scala.tasty.reflect.FlagSet {
-
-  def isProtected: Boolean = flags.is(Protected)
-  def isAbstract: Boolean = flags.is(Abstract)
-  def isFinal: Boolean = flags.is(Final)
-  def isSealed: Boolean = flags.is(Sealed)
-  def isCase: Boolean = flags.is(Case)
-  def isImplicit: Boolean = flags.is(Implicit)
-  def isErased: Boolean = flags.is(Erased)
-  def isLazy: Boolean = flags.is(Lazy)
-  def isOverride: Boolean = flags.is(Override)
-  def isInline: Boolean = flags.is(Inline)
-  def isMacro: Boolean = flags.is(Macro)
-  def isStatic: Boolean = flags.is(JavaStatic)
-  def isObject: Boolean = flags.is(Module)
-  def isTrait: Boolean = flags.is(Trait)
-  def isLocal: Boolean = flags.is(Local)
-  def isSynthetic: Boolean = flags.is(Synthetic)
-  def isArtifact: Boolean = flags.is(Artifact)
-  def isMutable: Boolean = flags.is(Mutable)
-  def isFieldAccessor: Boolean = flags.is(Accessor)
-  def isCaseAcessor: Boolean = flags.is(CaseAccessor)
-  def isCovariant: Boolean = flags.is(Covariant)
-  def isContravariant: Boolean = flags.is(Contravariant)
-  def isScala2X: Boolean = flags.is(Scala2x)
-  def isDefaultParameterized: Boolean = flags.is(DefaultParameterized)
-  def isStable: Boolean = flags.is(Stable)
-  def isParam: Boolean = flags.is(Param)
-  def isParamAccessor: Boolean = flags.is(ParamAccessor)
-
-  override def toString: String = {
-    val flags = List.newBuilder[String]
-    if (isProtected) flags += "protected "
-    if (isAbstract) flags += "abstract"
-    if (isFinal) flags += "final"
-    if (isSealed) flags += "sealed"
-    if (isCase) flags += "case"
-    if (isImplicit) flags += "implicit"
-    if (isErased) flags += "erased"
-    if (isLazy) flags += "lazy"
-    if (isOverride) flags += "override"
-    if (isInline) flags += "inline"
-    if (isMacro) flags += "macro"
-    if (isStatic) flags += "javaStatic"
-    if (isObject) flags += "object"
-    if (isTrait) flags += "trait"
-    if (isLocal) flags += "local"
-    if (isSynthetic) flags += "synthetic"
-    if (isArtifact) flags += "artifact"
-    if (isMutable) flags += "mutable"
-    if (isFieldAccessor) flags += "accessor"
-    if (isCaseAcessor) flags += "caseAccessor"
-    if (isCovariant) flags += "covariant"
-    if (isContravariant) flags += "contravariant"
-    if (isScala2X) flags += "scala2x"
-    if (isDefaultParameterized) flags += "defaultParameterized"
-    if (isStable) flags += "stable"
-    if (isParam) flags += "param"
-    if (isParamAccessor) flags += "paramAccessor"
-    flags.result().mkString("<", ",", ">")
-  }
-
-}
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/FlagsOpsImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/FlagsOpsImpl.scala
new file mode 100644
index 000000000000..3b0d0f79e957
--- /dev/null
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/FlagsOpsImpl.scala
@@ -0,0 +1,47 @@
+package dotty.tools.dotc
+package tastyreflect
+
+import dotty.tools.dotc.core.Decorators._
+
+import scala.tasty.reflect
+
+trait FlagsOpsImpl extends scala.tasty.reflect.FlagsOps with CoreImpl {
+
+  def FlagsDeco(flagSet: Flags): FlagsAPI = new FlagsAPI {
+    def is(that: Flags): Boolean = flagSet is that
+    def |(that: Flags): Flags = flagSet | that
+    def &(that: Flags): Flags = flagSet & that
+  }
+
+  object Flags extends FlagsModule {
+    def Private: Flags = core.Flags.Private
+    def Protected: Flags = core.Flags.Protected
+    def Abstract: Flags = core.Flags.Abstract
+    def Final: Flags = core.Flags.Final
+    def Sealed: Flags = core.Flags.Sealed
+    def Case: Flags = core.Flags.Case
+    def Implicit: Flags = core.Flags.Implicit
+    def Erased: Flags = core.Flags.Erased
+    def Lazy: Flags = core.Flags.Lazy
+    def Override: Flags = core.Flags.Override
+    def Inline: Flags = core.Flags.Inline
+    def Macro: Flags = core.Flags.Macro
+    def Static: Flags = core.Flags.JavaStatic
+    def Object: Flags = core.Flags.Module
+    def Trait: Flags = core.Flags.Trait
+    def Local: Flags = core.Flags.Local
+    def Synthetic: Flags = core.Flags.Synthetic
+    def Artifact: Flags = core.Flags.Artifact
+    def Mutable: Flags = core.Flags.Mutable
+    def FieldAccessor: Flags = core.Flags.Accessor
+    def CaseAcessor: Flags = core.Flags.CaseAccessor
+    def Covariant: Flags = core.Flags.Covariant
+    def Contravariant: Flags = core.Flags.Contravariant
+    def Scala2X: Flags = core.Flags.Scala2x
+    def DefaultParameterized: Flags = core.Flags.DefaultParameterized
+    def Stable: Flags = core.Flags.Stable
+    def Param: Flags = core.Flags.Param
+    def ParamAccessor: Flags = core.Flags.ParamAccessor
+  }
+
+}
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/PrintersImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/PrintersImpl.scala
index 9f114c2f6b34..f5cd53d3dd3f 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/PrintersImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/PrintersImpl.scala
@@ -1,4 +1,5 @@
 package dotty.tools.dotc.tastyreflect
+import dotty.tools.dotc.core.Flags
 
 trait PrintersImpl extends scala.tasty.reflect.Printers with scala.tasty.reflect.Core { reflect: ReflectionImpl =>
 
@@ -48,4 +49,9 @@ trait PrintersImpl extends scala.tasty.reflect.Printers with scala.tasty.reflect
     def showCode(implicit ctx: Context): String = showSourceCode.showSymbol(symbol)
   }
 
+  /** Adds `show` as an extension method of a `Flags` */
+  implicit def FlagsShowDeco(flags: Flags): ShowAPI = new ShowAPI {
+    def show(implicit ctx: Context): String = showExtractors.showFlags(flags)
+    def showCode(implicit ctx: Context): String = showSourceCode.showFlags(flags)
+  }
 }
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/ReflectionImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/ReflectionImpl.scala
index 0f50b2e0e7b1..4f3e9cf7a12c 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/ReflectionImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/ReflectionImpl.scala
@@ -8,6 +8,7 @@ class ReflectionImpl(val rootContext: Contexts.Context)
     with CaseDefOpsImpl
     with ConstantOpsImpl
     with ContextOpsImpl
+    with FlagsOpsImpl
     with IdOpsImpl
     with ImportSelectorOpsImpl
     with QuotedOpsImpl
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/SymbolOpsImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/SymbolOpsImpl.scala
index b8d5b030f2c3..fcf3da51314a 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/SymbolOpsImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/SymbolOpsImpl.scala
@@ -9,7 +9,7 @@ trait SymbolOpsImpl extends scala.tasty.reflect.SymbolOps with CoreImpl {
 
   def SymbolDeco(symbol: Symbol): SymbolAPI = new SymbolAPI {
 
-    def flags(implicit ctx: Context): FlagSet = new FlagSet(symbol.flags)
+    def flags(implicit ctx: Context): Flags = symbol.flags
 
     def privateWithin(implicit ctx: Context): Option[Type] = {
       val within = symbol.privateWithin
diff --git a/library/src/scala/tasty/Reflection.scala b/library/src/scala/tasty/Reflection.scala
index c6957a291c58..7828444a830c 100644
--- a/library/src/scala/tasty/Reflection.scala
+++ b/library/src/scala/tasty/Reflection.scala
@@ -7,6 +7,7 @@ abstract class Reflection
     with CaseDefOps
     with ConstantOps
     with ContextOps
+    with FlagsOps
     with IdOps
     with ImportSelectorOps
     with QuotedOps
diff --git a/library/src/scala/tasty/reflect/Core.scala b/library/src/scala/tasty/reflect/Core.scala
index 5b14d3a92320..c77e306144f5 100644
--- a/library/src/scala/tasty/reflect/Core.scala
+++ b/library/src/scala/tasty/reflect/Core.scala
@@ -109,6 +109,8 @@ package scala.tasty.reflect
  *              +- BindSymbol
  *              +- NoSymbol
  *
+ *  +- Flags
+ *
  *  Aliases:
  *   # TermOrTypeTree = Term | TypeTree
  *
@@ -445,4 +447,6 @@ trait Core {
     /** No symbol available. */
     type NoSymbol <: Symbol
 
+  /** FlagSet of a Symbol */
+  type Flags
 }
diff --git a/library/src/scala/tasty/reflect/FlagSet.scala b/library/src/scala/tasty/reflect/FlagSet.scala
deleted file mode 100644
index 4b035ade47a5..000000000000
--- a/library/src/scala/tasty/reflect/FlagSet.scala
+++ /dev/null
@@ -1,85 +0,0 @@
-package scala.tasty.reflect
-
-trait FlagSet {
-
-  /** Is this symbol `protected` */
-  def isProtected: Boolean
-
-  /** Is this symbol `abstract` */
-  def isAbstract: Boolean
-
-  /** Is this symbol `final` */
-  def isFinal: Boolean
-
-  /** Is this symbol `sealed` */
-  def isSealed: Boolean
-
-  /** Is this symbol `case` */
-  def isCase: Boolean
-
-  /** Is this symbol `implicit` */
-  def isImplicit: Boolean
-
-  /** Is this symbol `erased` */
-  def isErased: Boolean
-
-  /** Is this symbol `lazy` */
-  def isLazy: Boolean
-
-  /** Is this symbol `override` */
-  def isOverride: Boolean
-
-  /** Is this symbol `inline` */
-  def isInline: Boolean
-
-  /** Is this symbol markes as a macro. An inline method containing toplevel splices */
-  def isMacro: Boolean
-
-  /** Is this symbol marked as static. Mapped to static Java member */
-  def isStatic: Boolean
-
-  /** Is this symbol an object or its class (used for a ValDef or a ClassDef extends Modifier respectively) */
-  def isObject: Boolean
-
-  /** Is this symbol a trait */
-  def isTrait: Boolean
-
-  /** Is this symbol local? Used in conjunction with Private/private[Type] to mean private[this] extends Modifier proctected[this] */
-  def isLocal: Boolean
-
-  /** Was this symbol generated by Scala compiler */
-  def isSynthetic: Boolean
-
-  /** Is this symbol to be tagged Java Synthetic */
-  def isArtifact: Boolean
-
-  /** Is this symbol a `var` (when used on a ValDef) */
-  def isMutable: Boolean
-
-  /** Is this symbol a getter or a setter */
-  def isFieldAccessor: Boolean
-
-  /** Is this symbol a getter for case class parameter */
-  def isCaseAcessor: Boolean
-
-  /** Is this symbol a type parameter marked as covariant `+` */
-  def isCovariant: Boolean
-
-  /** Is this symbol a type parameter marked as contravariant `-` */
-  def isContravariant: Boolean
-
-  /** Was this symbol imported from Scala2.x */
-  def isScala2X: Boolean
-
-  /** Is this symbol a method with default parameters */
-  def isDefaultParameterized: Boolean
-
-  /** Is this symbol member that is assumed to be stable */
-  def isStable: Boolean
-
-  /** Is this symbol a parameter */
-  def isParam: Boolean
-
-  /** Is this symbol a parameter accessor */
-  def isParamAccessor: Boolean
-}
diff --git a/library/src/scala/tasty/reflect/FlagsOps.scala b/library/src/scala/tasty/reflect/FlagsOps.scala
new file mode 100644
index 000000000000..afc413cddf46
--- /dev/null
+++ b/library/src/scala/tasty/reflect/FlagsOps.scala
@@ -0,0 +1,103 @@
+package scala.tasty.reflect
+
+trait FlagsOps extends Core {
+
+  trait FlagsAPI {
+    /** Is the given flag set a subset of this flag sets */
+    def is(flagSet: Flags): Boolean
+    /** Union of the two flag sets */
+    def |(flagSet: Flags): Flags
+    /** Intersection of the two flag sets */
+    def &(flagSet: Flags): Flags
+  }
+  implicit def FlagsDeco(flagSet: Flags): FlagsAPI
+
+  val Flags: FlagsModule
+  abstract class FlagsModule {
+
+    /** Is this symbol `private` */
+    def Private: Flags
+
+    /** Is this symbol `protected` */
+    def Protected: Flags
+
+    /** Is this symbol `abstract` */
+    def Abstract: Flags
+
+    /** Is this symbol `final` */
+    def Final: Flags
+
+    /** Is this symbol `sealed` */
+    def Sealed: Flags
+
+    /** Is this symbol `case` */
+    def Case: Flags
+
+    /** Is this symbol `implicit` */
+    def Implicit: Flags
+
+    /** Is this symbol `erased` */
+    def Erased: Flags
+
+    /** Is this symbol `lazy` */
+    def Lazy: Flags
+
+    /** Is this symbol `override` */
+    def Override: Flags
+
+    /** Is this symbol `inline` */
+    def Inline: Flags
+
+    /** Is this symbol markes as a macro. An inline method containing toplevel splices */
+    def Macro: Flags
+
+    /** Is this symbol marked as static. Mapped to static Java member */
+    def Static: Flags
+
+    /** Is this symbol an object or its class (used for a ValDef or a ClassDef extends Modifier respectively) */
+    def Object: Flags
+
+    /** Is this symbol a trait */
+    def Trait: Flags
+
+    /** Is this symbol local? Used in conjunction with private/private[Type] to mean private[this] extends Modifier proctected[this] */
+    def Local: Flags
+
+    /** Was this symbol generated by Scala compiler */
+    def Synthetic: Flags
+
+    /** Is this symbol to be tagged Java Synthetic */
+    def Artifact: Flags
+
+    /** Is this symbol a `var` (when used on a ValDef) */
+    def Mutable: Flags
+
+    /** Is this symbol a getter or a setter */
+    def FieldAccessor: Flags
+
+    /** Is this symbol a getter for case class parameter */
+    def CaseAcessor: Flags
+
+    /** Is this symbol a type parameter marked as covariant `+` */
+    def Covariant: Flags
+
+    /** Is this symbol a type parameter marked as contravariant `-` */
+    def Contravariant: Flags
+
+    /** Was this symbol imported from Scala2.x */
+    def Scala2X: Flags
+
+    /** Is this symbol a method with default parameters */
+    def DefaultParameterized: Flags
+
+    /** Is this symbol member that is assumed to be stable */
+    def Stable: Flags
+
+    /** Is this symbol a parameter */
+    def Param: Flags
+
+    /** Is this symbol a parameter accessor */
+    def ParamAccessor: Flags
+  }
+
+}
diff --git a/library/src/scala/tasty/reflect/Printers.scala b/library/src/scala/tasty/reflect/Printers.scala
index 07d8a04173d8..512e0e56e333 100644
--- a/library/src/scala/tasty/reflect/Printers.scala
+++ b/library/src/scala/tasty/reflect/Printers.scala
@@ -10,6 +10,7 @@ trait Printers
   extends Core
   with CaseDefOps
   with ConstantOps
+  with FlagsOps
   with IdOps
   with ImportSelectorOps
   with PatternOps
@@ -43,6 +44,9 @@ trait Printers
   /** Adds `show` as an extension method of a `Symbol` */
   implicit def SymbolShowDeco(symbol: Symbol): ShowAPI
 
+  /** Adds `show` as an extension method of a `Flags` */
+  implicit def FlagsShowDeco(flags: Flags): ShowAPI
+
   /** Define `show` as method */
   trait ShowAPI {
     /** Shows the tree as extractors */
@@ -68,6 +72,8 @@ trait Printers
 
     def showSymbol(symbol: Symbol)(implicit ctx: Context): String
 
+    def showFlags(flags: Flags)(implicit ctx: Context): String
+
   }
 
   class ExtractorsPrinter extends Printer {
@@ -92,6 +98,39 @@ trait Printers
     def showSymbol(symbol: Symbol)(implicit ctx: Context): String =
       new Buffer().visitSymbol(symbol).result()
 
+    def showFlags(flags: Flags)(implicit ctx: Context): String = {
+      val flagList = List.newBuilder[String]
+      if (flags.is(Flags.Private)) flagList += "Flags.Private"
+      if (flags.is(Flags.Protected)) flagList += "Flags.Protected"
+      if (flags.is(Flags.Abstract)) flagList += "Flags.Abstract"
+      if (flags.is(Flags.Final)) flagList += "Flags.Final"
+      if (flags.is(Flags.Sealed)) flagList += "Flags.Sealed"
+      if (flags.is(Flags.Case)) flagList += "Flags.Case"
+      if (flags.is(Flags.Implicit)) flagList += "Flags.Implicit"
+      if (flags.is(Flags.Erased)) flagList += "Flags.Erased"
+      if (flags.is(Flags.Lazy)) flagList += "Flags.Lazy"
+      if (flags.is(Flags.Override)) flagList += "Flags.Override"
+      if (flags.is(Flags.Inline)) flagList += "Flags.Inline"
+      if (flags.is(Flags.Macro)) flagList += "Flags.Macro"
+      if (flags.is(Flags.Static)) flagList += "Flags.javaStatic"
+      if (flags.is(Flags.Object)) flagList += "Flags.Object"
+      if (flags.is(Flags.Trait)) flagList += "Flags.Trait"
+      if (flags.is(Flags.Local)) flagList += "Flags.Local"
+      if (flags.is(Flags.Synthetic)) flagList += "Flags.Synthetic"
+      if (flags.is(Flags.Artifact)) flagList += "Flags.Artifact"
+      if (flags.is(Flags.Mutable)) flagList += "Flags.Mutable"
+      if (flags.is(Flags.FieldAccessor)) flagList += "Flags.FieldAccessor"
+      if (flags.is(Flags.CaseAcessor)) flagList += "Flags.CaseAcessor"
+      if (flags.is(Flags.Covariant)) flagList += "Flags.Covariant"
+      if (flags.is(Flags.Contravariant)) flagList += "Flags.Contravariant"
+      if (flags.is(Flags.Scala2X)) flagList += "Flags.Scala2X"
+      if (flags.is(Flags.DefaultParameterized)) flagList += "Flags.DefaultParameterized"
+      if (flags.is(Flags.Stable)) flagList += "Flags.Stable"
+      if (flags.is(Flags.Param)) flagList += "Flags.Param"
+      if (flags.is(Flags.ParamAccessor)) flagList += "Flags.ParamAccessor"
+      flagList.result().mkString(" | ")
+    }
+
     private class Buffer(implicit ctx: Context) { self =>
 
       private val sb: StringBuilder = new StringBuilder
@@ -431,6 +470,39 @@ trait Printers
     def showSymbol(symbol: Symbol)(implicit ctx: Context): String =
       symbol.fullName
 
+    def showFlags(flags: Flags)(implicit ctx: Context): String = {
+      val flagList = List.newBuilder[String]
+      if (flags.is(Flags.Private)) flagList += "private"
+      if (flags.is(Flags.Protected)) flagList += "protected"
+      if (flags.is(Flags.Abstract)) flagList += "abstract"
+      if (flags.is(Flags.Final)) flagList += "final"
+      if (flags.is(Flags.Sealed)) flagList += "sealed"
+      if (flags.is(Flags.Case)) flagList += "case"
+      if (flags.is(Flags.Implicit)) flagList += "implicit"
+      if (flags.is(Flags.Erased)) flagList += "erased"
+      if (flags.is(Flags.Lazy)) flagList += "lazy"
+      if (flags.is(Flags.Override)) flagList += "override"
+      if (flags.is(Flags.Inline)) flagList += "inline"
+      if (flags.is(Flags.Macro)) flagList += "macro"
+      if (flags.is(Flags.Static)) flagList += "javaStatic"
+      if (flags.is(Flags.Object)) flagList += "object"
+      if (flags.is(Flags.Trait)) flagList += "trait"
+      if (flags.is(Flags.Local)) flagList += "local"
+      if (flags.is(Flags.Synthetic)) flagList += "synthetic"
+      if (flags.is(Flags.Artifact)) flagList += "artifact"
+      if (flags.is(Flags.Mutable)) flagList += "mutable"
+      if (flags.is(Flags.FieldAccessor)) flagList += "accessor"
+      if (flags.is(Flags.CaseAcessor)) flagList += "caseAccessor"
+      if (flags.is(Flags.Covariant)) flagList += "covariant"
+      if (flags.is(Flags.Contravariant)) flagList += "contravariant"
+      if (flags.is(Flags.Scala2X)) flagList += "scala2x"
+      if (flags.is(Flags.DefaultParameterized)) flagList += "defaultParameterized"
+      if (flags.is(Flags.Stable)) flagList += "stable"
+      if (flags.is(Flags.Param)) flagList += "param"
+      if (flags.is(Flags.ParamAccessor)) flagList += "paramAccessor"
+      flagList.result().mkString("/*", " ", "*/")
+    }
+
     private class Buffer(implicit ctx: Context) {
 
       private[this] val sb: StringBuilder = new StringBuilder
@@ -479,7 +551,7 @@ trait Printers
         case tree @ PackageClause(name, stats) =>
           val stats1 = stats.collect {
             case IsPackageClause(stat) => stat
-            case IsDefinition(stat) if !(stat.symbol.flags.isObject && stat.symbol.flags.isLazy) => stat
+            case IsDefinition(stat) if !(stat.symbol.flags.is(Flags.Object) && stat.symbol.flags.is(Flags.Lazy)) => stat
             case stat @ Import(_, _) => stat
           }
           name match {
@@ -501,20 +573,20 @@ trait Printers
           printDefAnnotations(cdef)
 
           val flags = cdef.symbol.flags
-          if (flags.isImplicit) this += highlightKeyword("implicit ", color)
-          if (flags.isSealed) this += highlightKeyword("sealed ", color)
-          if (flags.isFinal && !flags.isObject) this += highlightKeyword("final ", color)
-          if (flags.isCase) this += highlightKeyword("case ", color)
+          if (flags.is(Flags.Implicit)) this += highlightKeyword("implicit ", color)
+          if (flags.is(Flags.Sealed)) this += highlightKeyword("sealed ", color)
+          if (flags.is(Flags.Final) && !flags.is(Flags.Object)) this += highlightKeyword("final ", color)
+          if (flags.is(Flags.Case)) this += highlightKeyword("case ", color)
 
           if (name == "package$") {
             this += highlightKeyword("package object ", color) += highlightTypeDef(cdef.symbol.owner.name.stripSuffix("$"), color)
           }
-          else if (flags.isObject) this += highlightKeyword("object ", color) += highlightTypeDef(name.stripSuffix("$"), color)
-          else if (flags.isTrait) this += highlightKeyword("trait ", color) += highlightTypeDef(name, color)
-          else if (flags.isAbstract) this += highlightKeyword("abstract class ", color) += highlightTypeDef(name, color)
+          else if (flags.is(Flags.Object)) this += highlightKeyword("object ", color) += highlightTypeDef(name.stripSuffix("$"), color)
+          else if (flags.is(Flags.Trait)) this += highlightKeyword("trait ", color) += highlightTypeDef(name, color)
+          else if (flags.is(Flags.Abstract)) this += highlightKeyword("abstract class ", color) += highlightTypeDef(name, color)
           else this += highlightKeyword("class ", color) += highlightTypeDef(name, color)
 
-          if (!flags.isObject) {
+          if (!flags.is(Flags.Object)) {
             printTargsDefs(targs)
             val it = argss.iterator
             while (it.hasNext)
@@ -558,10 +630,10 @@ trait Printers
             val flags = d.symbol.flags
             def isCaseClassUnOverridableMethod: Boolean = {
               // Currently the compiler does not allow overriding some of the methods generated for case classes
-              d.symbol.flags.isSynthetic &&
+              d.symbol.flags.is(Flags.Synthetic) &&
               (d match {
-                case DefDef("apply" | "unapply", _, _, _, _) if d.symbol.owner.flags.isObject => true
-                case DefDef(n, _, _, _, _) if d.symbol.owner.flags.isCase =>
+                case DefDef("apply" | "unapply", _, _, _, _) if d.symbol.owner.flags.is(Flags.Object) => true
+                case DefDef(n, _, _, _, _) if d.symbol.owner.flags.is(Flags.Case) =>
                   n == "copy" ||
                   n.matches("copy\\$default\\$[1-9][0-9]*") || // default parameters for the copy method
                   n.matches("_[1-9][0-9]*") || // Getters from Product
@@ -569,8 +641,8 @@ trait Printers
                 case _ => false
               })
             }
-            def isInnerModuleObject = d.symbol.flags.isLazy && d.symbol.flags.isObject
-            !flags.isParam && !flags.isParamAccessor && !flags.isFieldAccessor && !isCaseClassUnOverridableMethod && !isInnerModuleObject
+            def isInnerModuleObject = d.symbol.flags.is(Flags.Lazy) && d.symbol.flags.is(Flags.Object)
+            !flags.is(Flags.Param) && !flags.is(Flags.ParamAccessor) && !flags.is(Flags.FieldAccessor) && !isCaseClassUnOverridableMethod && !isInnerModuleObject
           }
           val stats1 = stats.collect {
             case IsDefinition(stat) if keepDefinition(stat) => stat
@@ -616,13 +688,13 @@ trait Printers
           printDefAnnotations(vdef)
 
           val flags = vdef.symbol.flags
-          if (flags.isImplicit) this += highlightKeyword("implicit ", color)
-          if (flags.isOverride) this += highlightKeyword("override ", color)
+          if (flags.is(Flags.Implicit)) this += highlightKeyword("implicit ", color)
+          if (flags.is(Flags.Override)) this += highlightKeyword("override ", color)
 
           printProtectedOrPrivate(vdef)
 
-          if (flags.isLazy) this += highlightKeyword("lazy ", color)
-          if (vdef.symbol.flags.isMutable) this += highlightKeyword("var ", color)
+          if (flags.is(Flags.Lazy)) this += highlightKeyword("lazy ", color)
+          if (vdef.symbol.flags.is(Flags.Mutable)) this += highlightKeyword("var ", color)
           else this += highlightKeyword("val ", color)
 
           this += highlightValDef(name, color) += ": "
@@ -664,9 +736,9 @@ trait Printers
           val isConstructor = name == "<init>"
 
           val flags = ddef.symbol.flags
-          if (flags.isImplicit) this += highlightKeyword("implicit ", color)
-          if (flags.isInline) this += highlightKeyword("inline ", color)
-          if (flags.isOverride) this += highlightKeyword("override ", color)
+          if (flags.is(Flags.Implicit)) this += highlightKeyword("implicit ", color)
+          if (flags.is(Flags.Inline)) this += highlightKeyword("inline ", color)
+          if (flags.is(Flags.Override)) this += highlightKeyword("override ", color)
 
           printProtectedOrPrivate(ddef)
 
@@ -786,7 +858,7 @@ trait Printers
 
         case Term.Block(stats0, expr) =>
           val stats = stats0.filter {
-            case IsValDef(tree) => !tree.symbol.flags.isObject
+            case IsValDef(tree) => !tree.symbol.flags.is(Flags.Object)
             case _ => true
           }
           printFlatBlock(stats, expr)
@@ -1092,8 +1164,8 @@ trait Printers
         args match {
           case Nil =>
           case arg :: _ =>
-            if (arg.symbol.flags.isErased) this += "erased "
-            if (arg.symbol.flags.isImplicit) this += "implicit "
+            if (arg.symbol.flags.is(Flags.Erased)) this += "erased "
+            if (arg.symbol.flags.is(Flags.Implicit)) this += "implicit "
         }
 
         def printSeparated(list: List[ValDef]): Unit = list match {
@@ -1127,16 +1199,16 @@ trait Printers
           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) {
+              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.isOverride) {
+                  if (vdef.symbol.flags.is(Flags.Override)) {
                     this += "override "
                     printedPrefix = true
                   }
                   printedPrefix  |= printProtectedOrPrivate(vdef)
-                  if (vdef.symbol.flags.isMutable) this += highlightValDef("var ", color)
-                  else if (printedPrefix || !vdef.symbol.flags.isCaseAcessor) this += highlightValDef("val ", color)
+                  if (vdef.symbol.flags.is(Flags.Mutable)) this += highlightValDef("var ", color)
+                  else if (printedPrefix || !vdef.symbol.flags.is(Flags.CaseAcessor)) this += highlightValDef("val ", color)
                   else this // val not explicitly needed
                 }
             }
@@ -1359,7 +1431,7 @@ trait Printers
               printType(prefix)
               this += "#"
             case IsType(prefix) =>
-              if (!sym.flags.isLocal) {
+              if (!sym.flags.is(Flags.Local)) {
                 printType(prefix)
                 this += "."
               }
@@ -1426,7 +1498,7 @@ trait Printers
 
         case Type.ThisType(tp) =>
           tp match {
-            case Type.SymRef(cdef, _) if !cdef.flags.isObject =>
+            case Type.SymRef(cdef, _) if !cdef.flags.is(Flags.Object) =>
               printFullClassName(tp)
               this += highlightTypeDef(".this", color)
             case Type.TypeRef(name, prefix) if name.endsWith("$") =>
@@ -1593,7 +1665,7 @@ trait Printers
             this += sym.name
           case _ => printFullClassName(within)
         }
-        if (definition.symbol.flags.isProtected) {
+        if (definition.symbol.flags.is(Flags.Protected)) {
           this += highlightKeyword("protected", color)
           definition.symbol.protectedWithin match {
             case Some(within) =>
diff --git a/library/src/scala/tasty/reflect/SymbolOps.scala b/library/src/scala/tasty/reflect/SymbolOps.scala
index 9ff45c30180b..e1915c9da180 100644
--- a/library/src/scala/tasty/reflect/SymbolOps.scala
+++ b/library/src/scala/tasty/reflect/SymbolOps.scala
@@ -12,7 +12,7 @@ trait SymbolOps extends Core {
     def owner(implicit ctx: Context): Symbol
 
     /** Flags of this symbol */
-    def flags(implicit ctx: Context): FlagSet
+    def flags(implicit ctx: Context): Flags
 
     /** This symbol is private within the resulting type. */
     def privateWithin(implicit ctx: Context): Option[Type]
diff --git a/tests/run/gestalt-type-toolbox-reflect/Macro_1.scala b/tests/run/gestalt-type-toolbox-reflect/Macro_1.scala
index e27019711420..0eafbb998104 100644
--- a/tests/run/gestalt-type-toolbox-reflect/Macro_1.scala
+++ b/tests/run/gestalt-type-toolbox-reflect/Macro_1.scala
@@ -34,7 +34,7 @@ object TypeToolbox {
   private def isCaseClassImpl(tp: Type[_])(implicit reflect: Reflection): Expr[Boolean] = {
     import reflect._
     val res = tp.unseal.symbol match {
-      case IsClassSymbol(sym) => sym.flags.isCase
+      case IsClassSymbol(sym) => sym.flags.is(Flags.Case)
       case _ => false
     }
     res.toExpr
diff --git a/tests/run/tasty-custom-show/quoted_1.scala b/tests/run/tasty-custom-show/quoted_1.scala
index 22c44c432fdc..96c51a43dd80 100644
--- a/tests/run/tasty-custom-show/quoted_1.scala
+++ b/tests/run/tasty-custom-show/quoted_1.scala
@@ -48,6 +48,7 @@ object Macros {
       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"
+      def showFlags(flags: Flags)(implicit ctx: reflect.Context): String = "Flags"
     }
   }