Rework reflect Flags

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -2462,6 +2462,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def CaseAccessor: Flags = dotc.core.Flags.CaseAccessor
       def Contravariant: Flags = dotc.core.Flags.Contravariant
       def Covariant: Flags = dotc.core.Flags.Covariant
+      def Deferred: Flags = dotc.core.Flags.Deferred
       def EmptyFlags = dotc.core.Flags.EmptyFlags
       def Enum: Flags = dotc.core.Flags.Enum
       def Erased: Flags = dotc.core.Flags.Erased
@@ -2472,14 +2473,17 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def Given: Flags = dotc.core.Flags.Given
       def HasDefault: Flags = dotc.core.Flags.HasDefault
       def Implicit: Flags = dotc.core.Flags.Implicit
+      def Infix: Flags = dotc.core.Flags.Infix
       def Inline: Flags = dotc.core.Flags.Inline
       def JavaDefined: Flags = dotc.core.Flags.JavaDefined
+      def JavaStatic: Flags = dotc.core.Flags.JavaStatic
       def Lazy: Flags = dotc.core.Flags.Lazy
       def Local: Flags = dotc.core.Flags.Local
       def Macro: Flags = dotc.core.Flags.Macro
-      def ModuleClass: Flags = dotc.core.Flags.ModuleClass
+      def Method: Flags = dotc.core.Flags.Method
+      def Module: Flags = dotc.core.Flags.Module
       def Mutable: Flags = dotc.core.Flags.Mutable
-      def Object: Flags = dotc.core.Flags.Module
+      def NoInits: Flags = dotc.core.Flags.NoInits
       def Opaque: Flags = dotc.core.Flags.Opaque
       def Open: Flags = dotc.core.Flags.Open
       def Override: Flags = dotc.core.Flags.Override
@@ -2495,6 +2499,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def Static: Flags = dotc.core.Flags.JavaStatic
       def Synthetic: Flags = dotc.core.Flags.Synthetic
       def Trait: Flags = dotc.core.Flags.Trait
+      def Transparent: Flags = dotc.core.Flags.Transparent
     end Flags
 
     object FlagsMethodsImpl extends FlagsMethods:

compiler/src/scala/quoted/runtime/impl/printers/Extractors.scala

@@ -26,22 +26,26 @@ object Extractors {
     if (flags.is(Flags.CaseAccessor)) flagList += "Flags.CaseAccessor"
     if (flags.is(Flags.Contravariant)) flagList += "Flags.Contravariant"
     if (flags.is(Flags.Covariant)) flagList += "Flags.Covariant"
+    if (flags.is(Flags.Deferred)) flagList += "Flags.Deferred"
     if (flags.is(Flags.Enum)) flagList += "Flags.Enum"
     if (flags.is(Flags.Erased)) flagList += "Flags.Erased"
-    if (flags.is(Flags.ExtensionMethod)) flagList += "Flags.ExtensionMethod"
     if (flags.is(Flags.Exported)) flagList += "Flags.Exported"
+    if (flags.is(Flags.ExtensionMethod)) flagList += "Flags.ExtensionMethod"
     if (flags.is(Flags.FieldAccessor)) flagList += "Flags.FieldAccessor"
     if (flags.is(Flags.Final)) flagList += "Flags.Final"
     if (flags.is(Flags.HasDefault)) flagList += "Flags.HasDefault"
     if (flags.is(Flags.Implicit)) flagList += "Flags.Implicit"
+    if (flags.is(Flags.Infix)) flagList += "Flags.Infix"
     if (flags.is(Flags.Inline)) flagList += "Flags.Inline"
     if (flags.is(Flags.JavaDefined)) flagList += "Flags.JavaDefined"
+    if (flags.is(Flags.JavaStatic)) flagList += "Flags.JavaStatic"
     if (flags.is(Flags.Lazy)) flagList += "Flags.Lazy"
     if (flags.is(Flags.Local)) flagList += "Flags.Local"
     if (flags.is(Flags.Macro)) flagList += "Flags.Macro"
-    if (flags.is(Flags.ModuleClass)) flagList += "Flags.ModuleClass"
+    if (flags.is(Flags.Method)) flagList += "Flags.Method"
+    if (flags.is(Flags.Module)) flagList += "Flags.Module"
     if (flags.is(Flags.Mutable)) flagList += "Flags.Mutable"
-    if (flags.is(Flags.Object)) flagList += "Flags.Object"
+    if (flags.is(Flags.NoInits)) flagList += "Flags.NoInits"
     if (flags.is(Flags.Override)) flagList += "Flags.Override"
     if (flags.is(Flags.Package)) flagList += "Flags.Package"
     if (flags.is(Flags.Param)) flagList += "Flags.Param"
@@ -55,6 +59,7 @@ object Extractors {
     if (flags.is(Flags.Static)) flagList += "Flags.javaStatic"
     if (flags.is(Flags.Synthetic)) flagList += "Flags.Synthetic"
     if (flags.is(Flags.Trait)) flagList += "Flags.Trait"
+    if (flags.is(Flags.Transparent)) flagList += "Flags.Transparent"
     flagList.result().mkString(" | ")
   }
 

compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala

@@ -27,22 +27,26 @@ object SourceCode {
     if (flags.is(Flags.CaseAccessor)) flagList += "caseAccessor"
     if (flags.is(Flags.Contravariant)) flagList += "contravariant"
     if (flags.is(Flags.Covariant)) flagList += "covariant"
+    if (flags.is(Flags.Deferred)) flagList += "deferred"
     if (flags.is(Flags.Enum)) flagList += "enum"
     if (flags.is(Flags.Erased)) flagList += "erased"
-    if (flags.is(Flags.ExtensionMethod)) flagList += "extension"
     if (flags.is(Flags.Exported)) flagList += "exported"
+    if (flags.is(Flags.ExtensionMethod)) flagList += "extension"
     if (flags.is(Flags.FieldAccessor)) flagList += "accessor"
     if (flags.is(Flags.Final)) flagList += "final"
     if (flags.is(Flags.HasDefault)) flagList += "hasDefault"
     if (flags.is(Flags.Implicit)) flagList += "implicit"
+    if (flags.is(Flags.Infix)) flagList += "infix"
     if (flags.is(Flags.Inline)) flagList += "inline"
     if (flags.is(Flags.JavaDefined)) flagList += "javaDefined"
+    if (flags.is(Flags.JavaStatic)) flagList += "static"
     if (flags.is(Flags.Lazy)) flagList += "lazy"
     if (flags.is(Flags.Local)) flagList += "local"
     if (flags.is(Flags.Macro)) flagList += "macro"
-    if (flags.is(Flags.ModuleClass)) flagList += "moduleClass"
+    if (flags.is(Flags.Method)) flagList += "method"
+    if (flags.is(Flags.Module)) flagList += "object"
     if (flags.is(Flags.Mutable)) flagList += "mutable"
-    if (flags.is(Flags.Object)) flagList += "object"
+    if (flags.is(Flags.NoInits)) flagList += "noInits"
     if (flags.is(Flags.Override)) flagList += "override"
     if (flags.is(Flags.Package)) flagList += "package"
     if (flags.is(Flags.Param)) flagList += "param"
@@ -56,6 +60,7 @@ object SourceCode {
     if (flags.is(Flags.Static)) flagList += "javaStatic"
     if (flags.is(Flags.Synthetic)) flagList += "synthetic"
     if (flags.is(Flags.Trait)) flagList += "trait"
+    if (flags.is(Flags.Transparent)) flagList += "transparent"
     flagList.result().mkString("/*", " ", "*/")
   }
 
@@ -109,7 +114,7 @@ object SourceCode {
       case tree @ PackageClause(name, stats) =>
         val stats1 = stats.collect {
           case stat: PackageClause => stat
-          case stat: Definition if !(stat.symbol.flags.is(Flags.Object) && stat.symbol.flags.is(Flags.Lazy)) => stat
+          case stat: Definition if !(stat.symbol.flags.is(Flags.Module) && stat.symbol.flags.is(Flags.Lazy)) => stat
           case stat @ Import(_, _) => stat
         }
         name match {
@@ -133,19 +138,19 @@ object SourceCode {
         val flags = cdef.symbol.flags
         if (flags.is(Flags.Implicit)) this += highlightKeyword("implicit ")
         if (flags.is(Flags.Sealed)) this += highlightKeyword("sealed ")
-        if (flags.is(Flags.Final) && !flags.is(Flags.Object)) this += highlightKeyword("final ")
+        if (flags.is(Flags.Final) && !flags.is(Flags.Module)) this += highlightKeyword("final ")
         if (flags.is(Flags.Case)) this += highlightKeyword("case ")
 
         if (name == "package$") {
           this += highlightKeyword("package object ") += highlightTypeDef(cdef.symbol.owner.name.stripSuffix("$"))
         }
-        else if (flags.is(Flags.Object)) this += highlightKeyword("object ") += highlightTypeDef(name.stripSuffix("$"))
+        else if (flags.is(Flags.Module)) this += highlightKeyword("object ") += highlightTypeDef(name.stripSuffix("$"))
         else if (flags.is(Flags.Trait)) this += highlightKeyword("trait ") += highlightTypeDef(name)
         else if (flags.is(Flags.Abstract)) this += highlightKeyword("abstract class ") += highlightTypeDef(name)
         else this += highlightKeyword("class ") += highlightTypeDef(name)
 
         val typeParams = stats.collect { case targ: TypeDef => targ  }.filter(_.symbol.isTypeParam).zip(targs)
-        if (!flags.is(Flags.Object)) {
+        if (!flags.is(Flags.Module)) {
           printTargsDefs(typeParams)
           val it = argss.iterator
           while (it.hasNext)
@@ -201,7 +206,7 @@ object SourceCode {
             // Currently the compiler does not allow overriding some of the methods generated for case classes
             d.symbol.flags.is(Flags.Synthetic) &&
             (d match {
-              case DefDef("apply" | "unapply" | "writeReplace", _, _, _, _) if d.symbol.owner.flags.is(Flags.Object) => true
+              case DefDef("apply" | "unapply" | "writeReplace", _, _, _, _) if d.symbol.owner.flags.is(Flags.Module) => 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
@@ -210,7 +215,7 @@ object SourceCode {
               case _ => false
             })
           }
-          def isInnerModuleObject = d.symbol.flags.is(Flags.Lazy) && d.symbol.flags.is(Flags.Object)
+          def isInnerModuleObject = d.symbol.flags.is(Flags.Lazy) && d.symbol.flags.is(Flags.Module)
           !flags.is(Flags.Param) && !flags.is(Flags.ParamAccessor) && !flags.is(Flags.FieldAccessor) && !isUndecompilableCaseClassMethod && !isInnerModuleObject
         }
         val stats1 = stats.collect {
@@ -259,7 +264,7 @@ object SourceCode {
         val flags = vdef.symbol.flags
         if (flags.is(Flags.Implicit)) this += highlightKeyword("implicit ")
         if (flags.is(Flags.Override)) this += highlightKeyword("override ")
-        if (flags.is(Flags.Final) && !flags.is(Flags.Object)) this += highlightKeyword("final ")
+        if (flags.is(Flags.Final) && !flags.is(Flags.Module)) this += highlightKeyword("final ")
 
         printProtectedOrPrivate(vdef)
 
@@ -299,7 +304,7 @@ object SourceCode {
         if (flags.is(Flags.Implicit)) this += highlightKeyword("implicit ")
         if (flags.is(Flags.Inline)) this += highlightKeyword("inline ")
         if (flags.is(Flags.Override)) this += highlightKeyword("override ")
-        if (flags.is(Flags.Final) && !flags.is(Flags.Object)) this += highlightKeyword("final ")
+        if (flags.is(Flags.Final) && !flags.is(Flags.Module)) this += highlightKeyword("final ")
 
         printProtectedOrPrivate(ddef)
 
@@ -466,7 +471,7 @@ object SourceCode {
 
       case Block(stats0, expr) =>
         val stats = stats0.filter {
-          case tree: ValDef => !tree.symbol.flags.is(Flags.Object)
+          case tree: ValDef => !tree.symbol.flags.is(Flags.Module)
           case _ => true
         }
         printFlatBlock(stats, expr)
@@ -1158,7 +1163,7 @@ object SourceCode {
 
       case ThisType(tp) =>
         tp match {
-          case tp: TypeRef if !tp.typeSymbol.flags.is(Flags.Object) =>
+          case tp: TypeRef if !tp.typeSymbol.flags.is(Flags.Module) =>
             printFullClassName(tp)
             this += highlightTypeDef(".this")
           case TypeRef(prefix, name) if name.endsWith("$") =>

library/src/scala/quoted/Quotes.scala

@@ -3888,7 +3888,9 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       /** Is this symbol `abstract` */
       def Abstract: Flags
 
-      /** Was this symbol generated by Scala compiler */
+      /** Is this generated by Scala compiler.
+       *  Coresponds to ACC_SYNTHETIC in the JVM.
+       */
       def Artifact: Flags
 
       /** Is this symbol `case` */
@@ -3903,6 +3905,9 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       /** Is this symbol a type parameter marked as covariant `+` */
       def Covariant: Flags
 
+      /** Is a declared, but not defined member */
+      def Deferred: Flags
+
       /** The empty set of flags */
       def EmptyFlags: Flags
 
@@ -3933,12 +3938,18 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       /** Is this symbol `implicit` */
       def Implicit: Flags
 
+      /** Is an infix method or type */
+      def Infix: Flags
+
       /** Is this symbol `inline` */
       def Inline: Flags
 
       /** Is this symbol defined in a Java class */
       def JavaDefined: Flags
 
+      /** Is implemented as a Java static */
+      def JavaStatic: Flags
+
       /** Is this symbol `lazy` */
       def Lazy: Flags
 
@@ -3948,14 +3959,16 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       /** Is this symbol marked as a macro. An inline method containing toplevel splices */
       def Macro: Flags
 
-      /** Is this symbol a module class */
-      def ModuleClass: Flags
+      def Method: Flags
+
+      /** Is this symbol an object or its class (used for a ValDef or a ClassDef extends Modifier respectively) */
+      def Module: Flags
 
       /** Is this symbol a `var` (when used on a ValDef) */
       def Mutable: Flags
 
-      /** Is this symbol an object or its class (used for a ValDef or a ClassDef extends Modifier respectively) */
-      def Object: Flags
+      /** Trait does not have fields or initialization code. */
+      def NoInits: Flags
 
       /** Is this symbol `opaque` */
       def Opaque: Flags
@@ -4001,6 +4014,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
 
       /** Is this symbol a trait */
       def Trait: Flags
+
+      /** Is a transparent inline method or trait */
+      def Transparent: Flags
+
     }
 
     /** Makes extension methods on `Flags` available without any imports */

scala3doc/src/dotty/dokka/tasty/ClassLikeSupport.scala

@@ -21,7 +21,7 @@ trait ClassLikeSupport:
   private val placeholderModifier = JMap(ctx.sourceSet -> KotlinModifier.Empty.INSTANCE)
 
   private def kindForClasslike(sym: Symbol): Kind =
-        if sym.flags.is(Flags.Object) then Kind.Object
+        if sym.flags.is(Flags.Module) then Kind.Object
         else if sym.flags.is(Flags.Trait) then Kind.Trait
         else if sym.flags.is(Flags.Enum) then Kind.Enum
         else Kind.Class
@@ -125,9 +125,9 @@ trait ClassLikeSupport:
           .map { _ =>
             parseMethod(dd.symbol, kind = Kind.Given(getGivenInstance(dd).map(_.asSignature), None))
           }
-          
+
       case dd: DefDef if !dd.symbol.isHiddenByVisibility && dd.symbol.isExported =>
-        val exportedTarget = dd.rhs.collect { 
+        val exportedTarget = dd.rhs.collect {
           case a: Apply => a.fun.asInstanceOf[Select]
           case s: Select => s
         }
@@ -137,7 +137,7 @@ trait ClassLikeSupport:
           case Select(qualifier: Ident, _) => qualifier.tpe.typeSymbol.normalizedName
         }.getOrElse("instance")
         val dri = dd.rhs.collect {
-          case s: Select if s.symbol.isDefDef => s.symbol.dri 
+          case s: Select if s.symbol.isDefDef => s.symbol.dri
         }.orElse(exportedTarget.map(_.qualifier.tpe.typeSymbol.dri))
         Some(parseMethod(dd.symbol, kind = Kind.Exported).withOrigin(Origin.ExportedFrom(s"$instanceName.$functionName", dri)))
 
@@ -151,7 +151,7 @@ trait ClassLikeSupport:
         && (!vd.symbol.flags.is(Flags.Case) || !vd.symbol.flags.is(Flags.Enum))
         && vd.symbol.isGiven =>
           val classDef = Some(vd.tpt.tpe).flatMap(_.classSymbol.map(_.tree.asInstanceOf[ClassDef]))
-          Some(classDef.filter(_.symbol.flags.is(Flags.ModuleClass)).fold[Member](parseValDef(vd))(parseGivenClasslike(_)))
+          Some(classDef.filter(_.symbol.flags.is(Flags.Module)).fold[Member](parseValDef(vd))(parseGivenClasslike(_)))
 
       case vd: ValDef if !isSyntheticField(vd.symbol) && (!vd.symbol.flags.is(Flags.Case) || !vd.symbol.flags.is(Flags.Enum)) =>
         Some(parseValDef(vd))
@@ -261,7 +261,7 @@ trait ClassLikeSupport:
       )
 
   def parseClasslike(classDef: ClassDef, signatureOnly: Boolean = false): DClass = classDef match
-    case c: ClassDef if classDef.symbol.flags.is(Flags.Object) => parseObject(c, signatureOnly)
+    case c: ClassDef if classDef.symbol.flags.is(Flags.Module) => parseObject(c, signatureOnly)
     case c: ClassDef if classDef.symbol.flags.is(Flags.Enum) => parseEnum(c, signatureOnly)
     case clazz => DClass(classDef)(signatureOnly = signatureOnly)
 

scala3doc/src/dotty/dokka/tasty/NameNormalizer.scala

@@ -6,7 +6,7 @@ trait NameNormalizer { self: TastyParser =>
   import qctx.reflect._
   extension (s: Symbol) def normalizedName: String = {
     val withoutGivenPrefix = if s.isGiven then s.name.stripPrefix("given_") else s.name
-    val withoutObjectSuffix = if s.flags.is(Flags.Object) then withoutGivenPrefix.stripSuffix("$") else withoutGivenPrefix
+    val withoutObjectSuffix = if s.flags.is(Flags.Module) then withoutGivenPrefix.stripSuffix("$") else withoutGivenPrefix
     val constructorNormalizedName = if s.isClassConstructor then "this" else withoutObjectSuffix
     constructorNormalizedName
   }

scala3doc/src/dotty/dokka/tasty/SymOps.scala

@@ -78,7 +78,7 @@ class SymOps[Q <: Quotes](val q: Q):
 
     def getCompanionSymbol: Option[Symbol] = Some(sym.companionClass).filter(_.exists)
 
-    def isCompanionObject: Boolean = sym.flags.is(Flags.Object) && sym.companionClass.exists
+    def isCompanionObject: Boolean = sym.flags.is(Flags.Module) && sym.companionClass.exists
 
     def isGiven: Boolean = sym.flags.is(Flags.Given)
 

scala3doc/src/dotty/dokka/tasty/SyntheticSupport.scala

@@ -38,7 +38,7 @@ trait SyntheticsSupport:
     def getAllMembers: List[Symbol] = hackGetAllMembers(using qctx)(s)
 
   def isSyntheticField(c: Symbol) =
-    c.flags.is(Flags.CaseAccessor) || (c.flags.is(Flags.Object) && !c.flags.is(Flags.Given))
+    c.flags.is(Flags.CaseAccessor) || (c.flags.is(Flags.Module) && !c.flags.is(Flags.Given))
 
   def isValidPos(pos: Position) =
     pos.exists && pos.start != pos.end

scala3doc/src/dotty/dokka/tasty/comments/MemberLookup.scala

@@ -101,7 +101,7 @@ trait MemberLookup {
         )
 
       def hackResolveModule(s: Symbol): Symbol =
-        if s.flags.is(Flags.Object) then s.moduleClass else s
+        if s.flags.is(Flags.Module) then s.moduleClass else s
 
       val matched = syms.find(matches)
 

scala3doc/test/dotty/dokka/tasty/comments/MemberLookupTests.scala

@@ -86,7 +86,7 @@ class LookupTestCases[Q <: Quotes](val q: Quotes) {
   case class Sym(symbol: q.reflect.Symbol) {
     def fld(name: String) =
       def hackResolveModule(s: q.reflect.Symbol): q.reflect.Symbol =
-        if s.flags.is(q.reflect.Flags.Object) then s.moduleClass else s
+        if s.flags.is(q.reflect.Flags.Module) then s.moduleClass else s
       Sym(hackResolveModule(symbol.field(name)))
     def fun(name: String) =
       val List(sym) = symbol.method(name)

tests/run-custom-args/tasty-interpreter/interpreter/jvm/Interpreter.scala

@@ -71,7 +71,7 @@ class Interpreter[Q <: Quotes & Singleton](using q0: Q) extends TreeInterpreter[
           // FIXME not necesarly static
           jvmReflection.interpretStaticVal(fn.symbol.owner, fn.symbol)
         case _ =>
-          if (fn.symbol.flags.is(Flags.Object))
+          if (fn.symbol.flags.is(Flags.Module))
             jvmReflection.loadModule(fn.symbol.moduleClass)
           else
             jvmReflection.interpretStaticVal(fn.symbol.owner, fn.symbol)