Fix unstable compiler output due to using Set

`membersBasedOnFlags` internally uses `memberNames` which returns a Set,
so the order of its elements is unstable. We were using it when
generating static forwarder methods which lead to some idempotency tests
failing (no idea why this didn't manifest itself before). Fixed by
adding a new `sortedMembersBasedOnFlags` which sorts members by names
and signatures (this required adding a somewhat arbitrary lexicographic
ordering to Signature).

Author: smarter

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

@@ -387,7 +387,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       }
       debuglog(s"Potentially conflicting names for forwarders: $conflictingNames")
 
-      for (m0 <- moduleClass.info.membersBasedOnFlags(ExcludedForwarderFlags, Flag_METHOD)) {
+      for (m0 <- moduleClass.info.sortedMembersBasedOnFlags(required = Flag_METHOD, excluded = ExcludedForwarderFlags)) {
         val m = if (m0.isBridge) m0.nextOverriddenSymbol else m0
         if (m == NoSymbol)
           log(s"$m0 is a bridge method that overrides nothing, something went wrong in a previous phase.")

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

@@ -602,7 +602,11 @@ abstract class BackendInterface extends BackendInterfaceDefinitions {
     def params: List[Symbol]
     def resultType: Type
     def memberInfo(s: Symbol): Type
-    def membersBasedOnFlags(excludedFlags: Flags, requiredFlags: Flags): List[Symbol]
+
+    /** The members of this type that have all of `required` flags but none of `excluded` flags set.
+     *  The members are sorted by name and signature to guarantee a stable ordering.
+     */
+    def sortedMembersBasedOnFlags(required: Flags, excluded: Flags): List[Symbol]
     def members: List[Symbol]
     def decls: List[Symbol]
     def underlying: Type

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

@@ -878,8 +878,18 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
 
     def =:=(other: Type): Boolean = tp =:= other
 
-    def membersBasedOnFlags(excludedFlags: Flags, requiredFlags: Flags): List[Symbol] =
-      tp.membersBasedOnFlags(termFlagSet(requiredFlags), termFlagSet(excludedFlags)).map(_.symbol).toList
+    def sortedMembersBasedOnFlags(required: Flags, excluded: Flags): List[Symbol] = {
+      val requiredFlagSet = termFlagSet(required)
+      val excludedFlagSet = termFlagSet(excluded)
+      // The output of `memberNames` is a Set, sort it to guarantee a stable ordering.
+      val names = tp.memberNames(takeAllFilter).toSeq.sorted
+      val buffer = mutable.ListBuffer[Symbol]()
+      names.foreach { name =>
+        buffer ++= tp.memberBasedOnFlags(name, requiredFlagSet, excludedFlagSet)
+          .alternatives.sortBy(_.signature)(Signature.lexicographicOrdering).map(_.symbol)
+      }
+      buffer.toList
+    }
 
     def resultType: Type = tp.resultType
 

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

@@ -158,4 +158,32 @@ object Signature {
     assert(!resultType.isInstanceOf[ExprType])
     apply(Nil, sigName(resultType, isJava))
   }
+
+  val lexicographicOrdering: Ordering[Signature] = new Ordering[Signature] {
+    val paramSigOrdering: Ordering[Signature.ParamSig] = new Ordering[Signature.ParamSig] {
+      def compare(x: ParamSig, y: ParamSig): Int = x match { // `(x, y) match` leads to extra allocations
+        case x: TypeName =>
+          y match {
+            case y: TypeName =>
+              // `Ordering[TypeName]` doesn't work due to `Ordering` still being invariant
+              the[Ordering[Name]].compare(x, y)
+            case y: Int =>
+              1
+          }
+        case x: Int =>
+          y match {
+            case y: Name =>
+              -1
+            case y: Int =>
+              x - y
+          }
+      }
+    }
+    def compare(x: Signature, y: Signature): Int = {
+      import scala.math.Ordering.Implicits.seqOrdering
+      val paramsOrdering = seqOrdering(paramSigOrdering).compare(x.paramsSig, y.paramsSig)
+      if (paramsOrdering != 0) paramsOrdering
+      else the[Ordering[Name]].compare(x.resSig, y.resSig)
+    }
+  }
 }