Drop FlagSet#toString

This is in preparation of making Flags an opaque type

Author: odersky

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -260,7 +260,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
           val evalue = t.symbol.name.mangledString // value the actual enumeration value.
           av.visitEnum(name, edesc, evalue)
         } else {
-            // println(i"not an enum: ${t.symbol} / ${t.symbol.denot.owner} / ${t.symbol.denot.owner.isTerm} / ${t.symbol.denot.owner.flags}")
+            // println(i"not an enum: ${t.symbol} / ${t.symbol.denot.owner} / ${t.symbol.denot.owner.isTerm} / ${t.symbol.denot.owner.flagsString}")
             assert(toDenot(t.symbol).name.is(DefaultGetterName),
               s"${toDenot(t.symbol).name.debugString}") // this should be default getter. do not emit.
         }

compiler/src/dotty/tools/dotc/core/Flags.scala

@@ -119,7 +119,7 @@ object Flags {
     }
 
     /** The string representation of this flag set */
-    override def toString: String = flagStrings.mkString(" ")
+    def flagsString: String = flagStrings.mkString(" ")
   }
 
   def termFlagSet(x: Long) = FlagSet(TERMS | x)
@@ -129,7 +129,7 @@ object Flags {
    *  `x is fc` tests whether `x` contains all flags in `fc`.
    */
   case class FlagConjunction(bits: Long) {
-    override def toString: String = FlagSet(bits).toString
+    def flagsString: String = FlagSet(bits).flagsString
     def | (fs: FlagSet): FlagConjunction = FlagConjunction((FlagSet(bits) | fs).bits)
   }
 

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -152,6 +152,8 @@ object SymDenotations {
      */
     private[dotc] final def flagsUNSAFE: FlagSet = myFlags
 
+    final def flagsString(implicit ctx: Context): String = flags.flagsString
+
     /** Adapt flag set to this denotation's term or type nature */
     private def adaptFlags(flags: FlagSet) = if (isType) flags.toTypeFlags else flags.toTermFlags
 

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -1976,7 +1976,7 @@ object Parsers {
       val name = in.name
       val mod = atSpan(in.skipToken()) { modOfToken(tok, name) }
 
-      if (mods is mod.flags) syntaxError(RepeatedModifier(mod.flags.toString))
+      if (mods is mod.flags) syntaxError(RepeatedModifier(mod.flags.flagsString))
       addMod(mods, mod)
     }
 

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -807,7 +807,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     val rawFlags = if (sym.exists) sym.flags else mods.flags
     if (rawFlags.is(Param)) flagMask = flagMask &~ Given
     val flags = rawFlags & flagMask
-    val flagsText = if (flags.isEmpty) "" else keywordStr(flags.toString)
+    val flagsText = if (flags.isEmpty) "" else keywordStr(flags.flagsString)
     val annotations =
       if (sym.exists) sym.annotations.filterNot(ann => dropAnnotForModText(ann.symbol)).map(_.tree)
       else mods.annotations.filterNot(tree => dropAnnotForModText(tree.symbol))

compiler/src/dotty/tools/dotc/transform/Bridges.scala

@@ -91,7 +91,7 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
     ctx.debuglog(
       i"""generating bridge from ${other.showLocated}: ${other.info}
              |to ${member.showLocated}: ${member.info} @ ${member.span}
-             |bridge: ${bridge.showLocated} with flags: ${bridge.flags}""")
+             |bridge: ${bridge.showLocated} with flags: ${bridge.flagsString}""")
 
     bridgeTarget(bridge) = member
     bridgesScope.enter(bridge)

compiler/src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -392,7 +392,7 @@ class TreeChecker extends Phase with SymTransformer {
             assert(vparam.symbol.is(Param),
               s"Parameter ${vparam.symbol} of ${sym.fullName} does not have flag `Param` set")
             assert(!vparam.symbol.is(AccessFlags),
-              s"Parameter ${vparam.symbol} of ${sym.fullName} has invalid flag(s): ${vparam.symbol.flags & AccessFlags}")
+              s"Parameter ${vparam.symbol} of ${sym.fullName} has invalid flag(s): ${(vparam.symbol.flags & AccessFlags).flagsString}")
           })
 
           val tpdTree = super.typedDefDef(ddef, sym)

compiler/src/dotty/tools/dotc/typer/RefChecks.scala

@@ -261,8 +261,8 @@ object RefChecks {
           sym.is(Module)) // synthetic companion
 
       def overrideAccessError() = {
-        ctx.log(i"member: ${member.showLocated} ${member.flags}") // DEBUG
-        ctx.log(i"other: ${other.showLocated} ${other.flags}") // DEBUG
+        ctx.log(i"member: ${member.showLocated} ${member.flagsString}") // DEBUG
+        ctx.log(i"other: ${other.showLocated} ${other.flagsString}") // DEBUG
         val otherAccess = (other.flags & AccessFlags).toString
         overrideError("has weaker access privileges; it should be " +
           (if (otherAccess == "") "public" else "at least " + otherAccess))

compiler/test/dotty/tools/dotc/ast/DesugarTests.scala

@@ -17,7 +17,7 @@ class DesugarTests extends DottyTest {
         sym.is(Synthetic) ||
         // or be a constructor:
         sym.name == nme.CONSTRUCTOR,
-        s"found: $sym (${sym.flags})"
+        s"found: $sym (${sym.flagsString})"
       )
   }
 

compiler/test/dotty/tools/dotc/reporting/ErrorMessagesTests.scala

@@ -702,7 +702,7 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       assertMessageCount(1, messages)
       val AbstractMemberMayNotHaveModifier(symbol, flags) :: Nil = messages
       assertEquals("value s", symbol.show)
-      assertEquals("final", flags.toString)
+      assertEquals("final", flags.flagsString)
     }
 
   @Test def typesAndTraitsCantBeImplicit =
@@ -1018,7 +1018,7 @@ class ErrorMessagesTests extends ErrorMessagesTest {
         implicit val ctx: Context = ictx
         assertMessageCount(1, messages)
         val ModifiersNotAllowed(flags, sort) :: Nil = messages
-        assertEquals(modifierAssertion, flags.toString)
+        assertEquals(modifierAssertion, flags.flagsString)
         assertEquals(typeAssertion, sort)
       }
   }