Reflect AbsOverride as Abstract | Override

This is the encoding used in the pickled TASTy.

Author: nicolasstucki

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

@@ -2487,13 +2487,13 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         newMethod(owner, name, tpe, Flags.EmptyFlags, noSymbol)
       def newMethod(owner: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol =
         checkValidFlags(flags.toTermFlags, Flags.validMethodFlags)
-        dotc.core.Symbols.newSymbol(owner, name.toTermName, flags | dotc.core.Flags.Method, tpe, privateWithin)
+        dotc.core.Symbols.newSymbol(owner, name.toTermName, flags.toInternalFlags | dotc.core.Flags.Method, tpe, privateWithin)
       def newVal(owner: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol =
         checkValidFlags(flags.toTermFlags, Flags.validValFlags)
-        dotc.core.Symbols.newSymbol(owner, name.toTermName, flags, tpe, privateWithin)
+        dotc.core.Symbols.newSymbol(owner, name.toTermName, flags.toInternalFlags, tpe, privateWithin)
       def newBind(owner: Symbol, name: String, flags: Flags, tpe: TypeRepr): Symbol =
         checkValidFlags(flags.toTermFlags, Flags.validBindFlags)
-        dotc.core.Symbols.newSymbol(owner, name.toTermName, flags | dotc.core.Flags.Case, tpe)
+        dotc.core.Symbols.newSymbol(owner, name.toTermName, flags.toInternalFlags | dotc.core.Flags.Case, tpe)
       def noSymbol: Symbol = dotc.core.Symbols.NoSymbol
 
       private inline def checkValidFlags(inline flags: Flags, inline valid: Flags): Unit =
@@ -2510,7 +2510,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       extension (self: Symbol)
         def owner: Symbol = self.denot.owner
         def maybeOwner: Symbol = self.denot.maybeOwner
-        def flags: Flags = self.denot.flags
+        def flags: Flags = self.denot.flags.toExternalFlags
 
         def privateWithin: Option[TypeRepr] =
           val within: Symbol =
@@ -2764,7 +2764,6 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     object Flags extends FlagsModule:
       def Abstract: Flags = dotc.core.Flags.Abstract
-      def AbsOverride: Flags = dotc.core.Flags.AbsOverride
       def Artifact: Flags = dotc.core.Flags.Artifact
       def Case: Flags = dotc.core.Flags.Case
       def CaseAccessor: Flags = dotc.core.Flags.CaseAccessor
@@ -2811,8 +2810,8 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def Trait: Flags = dotc.core.Flags.Trait
       def Transparent: Flags = dotc.core.Flags.Transparent
 
-      private[QuotesImpl] def validMethodFlags: Flags = Private | Protected | Override | Deferred | Final | Method | Implicit | Given | Local | JavaStatic | AbsOverride // Synthetic | ExtensionMethod | Exported | Erased | Infix | Invisible
-      private[QuotesImpl] def validValFlags: Flags = Private | Protected | Override | Deferred | Final | Param | Implicit | Lazy | Mutable | Local | ParamAccessor | Module | Package | Case | CaseAccessor | Given | Enum | JavaStatic | AbsOverride //  Synthetic | Erased | Invisible
+      private[QuotesImpl] def validMethodFlags: Flags = Private | Protected | Override | Deferred | Final | Method | Implicit | Given | Local | JavaStatic // Synthetic | ExtensionMethod | Exported | Erased | Infix | Invisible
+      private[QuotesImpl] def validValFlags: Flags = Private | Protected | Override | Deferred | Final | Param | Implicit | Lazy | Mutable | Local | ParamAccessor | Module | Package | Case | CaseAccessor | Given | Enum | JavaStatic //  Synthetic | Erased | Invisible
       private[QuotesImpl] def validBindFlags: Flags = Case // | Implicit | Given | Erased
     end Flags
 
@@ -2822,6 +2821,16 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         def |(that: Flags): Flags = dotc.core.Flags.or(self, that) // TODO: Replace with dotc.core.Flags.|(self)(that)  once extension names have stabilized
         def &(that: Flags): Flags = dotc.core.Flags.and(self, that)// TODO: Replace with dotc.core.Flags.&(self)(that)  once extension names have stabilized
         def show: String = Extractors.showFlags(using QuotesImpl.this)(self)
+
+        private[QuotesImpl] inline def toInternalFlags: Flags =
+          if self.isAllOf(dotc.core.Flags.AbstractOverride) then
+            self &~ dotc.core.Flags.AbstractOverride | dotc.core.Flags.AbsOverride
+          else self
+
+        private[QuotesImpl] inline def toExternalFlags: Flags =
+          if self.is(dotc.core.Flags.AbsOverride) then
+            self &~ dotc.core.Flags.AbsOverride | dotc.core.Flags.AbstractOverride
+          else self
       end extension
     end FlagsMethods
 

library/src/scala/quoted/Quotes.scala

@@ -4229,18 +4229,6 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       /** Is this symbol `abstract` */
       def Abstract: Flags
 
-      /** Is this symbol is labeled with of abstract & override
-       *
-       *  The override modifier has an additional significance when combined with the abstract modifier.
-       *  That modifier combination is only allowed for value members of traits.
-       *
-       *  We call a member MM of a template incomplete if it is either abstract (i.e. defined by a declaration), or it is labeled abstract and override and every member overridden by MM is again incomplete.
-       *
-       *  Note that the abstract override modifier combination does not influence the concept whether a member is concrete or abstract.
-       *  A member is abstract if only a declaration is given for it; it is concrete if a full definition is given.
-       */
-      @experimental def AbsOverride: Flags
-
       /** Is this generated by Scala compiler.
        *  Corresponds to ACC_SYNTHETIC in the JVM.
        */

tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala

@@ -76,7 +76,6 @@ val experimentalDefinitionInLibrary = Set(
   "scala.quoted.Quotes.reflectModule.SymbolModule.newClass",
   "scala.quoted.Quotes.reflectModule.SymbolModule.freshName",
   "scala.quoted.Quotes.reflectModule.SymbolMethods.info",
-  "scala.quoted.Quotes.reflectModule.FlagsModule.AbsOverride",
 
   // New APIs: Lightweight lazy vals. Can be stabilized in 3.3.0
   "scala.runtime.LazyVals$.Evaluating",