More refactoring, avoid globally accessible variable

Author: odersky

compiler/src/dotty/tools/dotc/cc/CaptureSet.scala

@@ -1083,10 +1083,15 @@ object CaptureSet:
    */
   case class ExistentialSubsumesFailure(val ex: root.Result, val other: CaptureRef) extends ErrorNote
 
-  enum CompareResult extends Showable:
-    case OK
-    case Fail(trace: List[CaptureSet])
-    case LevelError(cs: CaptureSet, elem: CaptureRef) extends CompareResult, ErrorNote
+  trait AcceptsNotes extends CompareResult:
+    protected var myErrorNotes: List[ErrorNote] = Nil
+    override def errorNotes: List[ErrorNote] = myErrorNotes
+    override def withNotes(notes: List[ErrorNote]): CompareResult =
+      myErrorNotes = notes
+      this
+
+  class CompareResult extends Showable:
+    import CompareResult.*
 
     override def toText(printer: Printer): Text =
       inContext(printer.printerContext):
@@ -1111,16 +1116,6 @@ object CaptureSet:
       case result: LevelError => Some(result)
       case _ => None
 
-    private var myErrorNotes: List[ErrorNote] = Nil
-
-    def errorNotes: List[ErrorNote] = myErrorNotes
-
-    def withNotes(notes: List[ErrorNote]): CompareResult = this match
-      case OK => OK
-      case _ =>
-        myErrorNotes = notes
-        this
-
     inline def andAlso(op: Context ?=> CompareResult)(using Context): CompareResult =
       if isOK then op else this
 
@@ -1134,6 +1129,15 @@ object CaptureSet:
     inline def addToTrace(cs: CaptureSet): CompareResult = this match
       case Fail(trace) => Fail(cs :: trace)
       case _ => this
+
+    def errorNotes: List[ErrorNote] = Nil
+    def withNotes(notes: List[ErrorNote]): CompareResult = this
+
+  object CompareResult:
+    val OK: CompareResult = new CompareResult:
+      override def toString = "OK"
+    case class Fail(trace: List[CaptureSet]) extends CompareResult, AcceptsNotes
+    case class LevelError(cs: CaptureSet, elem: CaptureRef) extends CompareResult, AcceptsNotes, ErrorNote
   end CompareResult
 
   /** A VarState serves as a snapshot mechanism that can undo