Don't use export on MatchDegree

Even the mitigation would have needed a workaround (because of scala#6741).

Author: odersky

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

@@ -756,9 +756,10 @@ object Denotations {
       if (!symbol.exists || symbol.isAccessibleFrom(pre, superAccess)) this else NoDenotation
 
     def atSignature(sig: Signature, site: Type, relaxed: Boolean)(implicit ctx: Context): SingleDenotation = {
+      import Signature.MatchDegree._
       val situated = if (site == NoPrefix) this else asSeenFrom(site)
       val matches = sig.matchDegree(situated.signature).ordinal >=
-        (if (relaxed) Signature.ParamMatch else Signature.FullMatch).ordinal
+        (if (relaxed) ParamMatch else FullMatch).ordinal
       if (matches) this else NoDenotation
     }
 
@@ -1090,13 +1091,14 @@ object Denotations {
     final def last: SingleDenotation = this
 
     final def matches(other: SingleDenotation)(implicit ctx: Context): Boolean = {
+      import Signature.MatchDegree._
       val d = signature.matchDegree(other.signature)
       (// fast path: signatures are the same and neither denotation is a PolyType
        // For polytypes, signatures alone do not tell us enough to be sure about matching.
-       d == Signature.FullMatch &&
+       d == FullMatch &&
        !infoOrCompleter.isInstanceOf[PolyType] && !other.infoOrCompleter.isInstanceOf[PolyType]
        ||
-       d.ordinal >= Signature.ParamMatch.ordinal && info.matches(other.info))
+       d.ordinal >= ParamMatch.ordinal && info.matches(other.info))
     }
 
     def mapInherited(ownDenots: PreDenotation, prevDenots: PreDenotation, pre: Type)(implicit ctx: Context): SingleDenotation =

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

@@ -75,16 +75,18 @@ case class Signature(paramsSig: List[TypeName], resSig: TypeName) {
    *  `NoMatch` otherwise.
    *  If the parameters are inconsistent, the result is always `NoMatch`.
    */
-  final def matchDegree(that: Signature)(implicit ctx: Context): MatchDegree =
+  final def matchDegree(that: Signature)(implicit ctx: Context): MatchDegree = {
+    import MatchDegree._
     if (consistentParams(that))
       if (resSig == that.resSig || isWildcard(resSig) || isWildcard(that.resSig)) FullMatch
       else if (!ctx.erasedTypes) ParamMatch
       else NoMatch
     else NoMatch
+  }
 
   /** Does this signature potentially clash with `that` ? */
   def clashes(that: Signature)(implicit ctx: Context): Boolean =
-    matchDegree(that) == FullMatch
+    matchDegree(that) == MatchDegree.FullMatch
 
   /** name.toString == "" or name.toString == "_" */
   private def isWildcard(name: TypeName) = name.isEmpty || name == tpnme.WILDCARD
@@ -110,11 +112,6 @@ object Signature {
   enum MatchDegree {
     case NoMatch, ParamMatch, FullMatch
   }
-  val NoMatch: MatchDegree.NoMatch.type = MatchDegree.NoMatch
-  val ParamMatch: MatchDegree.ParamMatch.type = MatchDegree.ParamMatch
-  val FullMatch: MatchDegree.FullMatch.type = MatchDegree.FullMatch
-    // DOTTY todo: Replace previous three lines by `export MatchDegree._`
-    // once 0.17 is released and #6729 is merged.
 
   /** The signature of everything that's not a method, i.e. that has
    *  a type different from PolyType, MethodType, or ExprType.
@@ -135,4 +132,4 @@ object Signature {
     assert(!resultType.isInstanceOf[ExprType])
     apply(Nil, sigName(resultType, isJava))
   }
-}
+}

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -2150,13 +2150,14 @@ object messages {
     val msg: String = {
       def nameAnd = if (decl.name != previousDecl.name) " name and" else ""
       val details = if (decl.isRealMethod && previousDecl.isRealMethod) {
+        import Signature.MatchDegree._
         // compare the signatures when both symbols represent methods
         decl.signature.matchDegree(previousDecl.signature) match {
-          case Signature.NoMatch =>
+          case NoMatch =>
             "" // shouldn't be reachable
-          case Signature.ParamMatch =>
+          case ParamMatch =>
             "have matching parameter types."
-          case Signature.FullMatch =>
+          case FullMatch =>
             i"have the same$nameAnd type after erasure."
         }
       } else ""