Refactoring: use isOK on CompareResult

Author: odersky

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

@@ -93,8 +93,7 @@ sealed abstract class CaptureSet extends Showable:
   def accountsFor(x: CaptureRef)(using ctx: Context): Boolean =
     reporting.trace(i"$this accountsFor $x, ${x.captureSetOfInfo}?", show = true) {
       elems.contains(x)
-      || !x.isRootCapability
-          && x.captureSetOfInfo.subCaptures(this, frozen = true) == CompareResult.OK
+      || !x.isRootCapability && x.captureSetOfInfo.subCaptures(this, frozen = true).isOK
     }
 
   /** The subcapturing test */
@@ -105,9 +104,9 @@ sealed abstract class CaptureSet extends Showable:
     def recur(elems: List[CaptureRef]): CompareResult = elems match
       case elem :: elems1 =>
         var result = that.tryInclude(elem, this)
-        if result != CompareResult.OK && !elem.isRootCapability && summon[VarState] != FrozenState then
+        if !result.isOK && !elem.isRootCapability && summon[VarState] != FrozenState then
           result = elem.captureSetOfInfo.subCaptures(that)
-        if result == CompareResult.OK then
+        if result.isOK then
           recur(elems1)
         else
           varState.abort()
@@ -118,15 +117,15 @@ sealed abstract class CaptureSet extends Showable:
       .showing(i"subcaptures $this <:< $that = ${result.show}", capt)
 
   def =:= (that: CaptureSet)(using Context): Boolean =
-       this.subCaptures(that, frozen = true) == CompareResult.OK
-    && that.subCaptures(this, frozen = true) == CompareResult.OK
+       this.subCaptures(that, frozen = true).isOK
+    && that.subCaptures(this, frozen = true).isOK
 
   /** The smallest capture set (via <:<) that is a superset of both
    *  `this` and `that`
    */
   def ++ (that: CaptureSet)(using Context): CaptureSet =
-    if this.subCaptures(that, frozen = true) == CompareResult.OK then that
-    else if that.subCaptures(this, frozen = true) == CompareResult.OK then this
+    if this.subCaptures(that, frozen = true).isOK then that
+    else if that.subCaptures(this, frozen = true).isOK then this
     else if this.isConst && that.isConst then Const(this.elems ++ that.elems)
     else Var(this.elems ++ that.elems).addSub(this).addSub(that)
 
@@ -138,8 +137,8 @@ sealed abstract class CaptureSet extends Showable:
   /** The largest capture set (via <:<) that is a subset of both `this` and `that`
    */
   def **(that: CaptureSet)(using Context): CaptureSet =
-    if this.subCaptures(that, frozen = true) == CompareResult.OK then this
-    else if that.subCaptures(this, frozen = true) == CompareResult.OK then that
+    if this.subCaptures(that, frozen = true).isOK then this
+    else if that.subCaptures(this, frozen = true).isOK then that
     else if this.isConst && that.isConst then Const(elems.intersect(that.elems))
     else if that.isConst then Intersected(this.asVar, that)
     else Intersected(that.asVar, this)
@@ -273,7 +272,7 @@ object CaptureSet:
         val depsIt = deps.iterator
         while depsIt.hasNext do
           val result = depsIt.next.tryInclude(newElems, this)
-          if result != CompareResult.OK then return result
+          if !result.isOK then return result
         CompareResult.OK
       else
         CompareResult.fail(this)
@@ -306,8 +305,7 @@ object CaptureSet:
         //println(i"solving var $this $approx ${approx.isConst} deps = ${deps.toList}")
         if approx.isConst then
           val newElems = approx.elems -- elems
-          if newElems.isEmpty
-              || addNewElems(newElems, empty)(using ctx, VarState()) == CompareResult.OK then
+          if newElems.isEmpty || addNewElems(newElems, empty)(using ctx, VarState()).isOK then
             markSolved()
 
     def markSolved()(using Context): Unit =
@@ -362,7 +360,7 @@ object CaptureSet:
             return CompareResult.fail(this)
           Const(newElems)
       val result = super.addNewElems(added.elems, origin)
-      if result == CompareResult.OK then
+      if result.isOK then
         if added.isConst then result
         else if added.asVar.recordDepsState() then { addSub(added); result }
         else CompareResult.fail(this)
@@ -387,7 +385,7 @@ object CaptureSet:
         super.addNewElems(newElems.map(bimap.forward), origin)
       else
         val r = super.addNewElems(newElems, origin)
-        if r == CompareResult.OK then
+        if r.isOK then
           source.tryInclude(newElems.map(bimap.backward), this)
             .showing(i"propagating new elems $newElems backward from $this to $source", capt)
           else r
@@ -449,7 +447,7 @@ object CaptureSet:
     extension (result: Type)
       def isOK: Boolean = result eq OK
       def blocking: CaptureSet = result
-      def show: String = if result == OK then "OK" else result.toString
+      def show: String = if result.isOK then "OK" else result.toString
       inline def andAlso(op: => Type) = if result.isOK then op else result
 
   class VarState:

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

@@ -491,7 +491,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             // under -Ycheck. Test case is i7965.scala.
 
       case CapturingType(parent1, refs1, _) =>
-        if subCaptures(refs1, tp2.captureSet, frozenConstraint) == CaptureSet.CompareResult.OK then
+        if subCaptures(refs1, tp2.captureSet, frozenConstraint).isOK then
           recur(parent1, tp2)
         else
           thirdTry

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

@@ -166,7 +166,7 @@ object TypeOps:
         simplify(l, theMap) | simplify(r, theMap)
       case CapturingType(parent, refs, _) =>
         if !ctx.mode.is(Mode.Type)
-            && refs.subCaptures(parent.captureSet, frozen = true) == CompareResult.OK then
+            && refs.subCaptures(parent.captureSet, frozen = true).isOK then
           simplify(parent, theMap)
         else
           mapOver

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

@@ -1849,7 +1849,7 @@ object Types {
       else CapturingType(this, ref.singletonCaptureSet, this.isBoxedCapturing)
 
     def capturing(cs: CaptureSet)(using Context): Type =
-      if cs.isConst && cs.subCaptures(captureSet, frozen = true) == CompareResult.OK then this
+      if cs.isConst && cs.subCaptures(captureSet, frozen = true).isOK then this
       else this match
         case CapturingType(parent, cs1, boxed) => parent.capturing(cs1 ++ cs)
         case _ => CapturingType(this, cs, this.isBoxedCapturing)

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

@@ -264,16 +264,16 @@ class CheckCaptures extends Recheck:
         checkSubset(targetSet, curEnv.captured, pos)
 
     def assertSub(cs1: CaptureSet, cs2: CaptureSet)(using Context) =
-      assert(cs1.subCaptures(cs2, frozen = false) == CompareResult.OK, i"$cs1 is not a subset of $cs2")
+      assert(cs1.subCaptures(cs2, frozen = false).isOK, i"$cs1 is not a subset of $cs2")
 
     def checkElem(elem: CaptureRef, cs: CaptureSet, pos: SrcPos)(using Context) =
       val res = elem.singletonCaptureSet.subCaptures(cs, frozen = false)
-      if res != CompareResult.OK then
+      if !res.isOK then
         report.error(i"$elem cannot be referenced here; it is not included in allowed capture set ${res.blocking}", pos)
 
     def checkSubset(cs1: CaptureSet, cs2: CaptureSet, pos: SrcPos)(using Context) =
       val res = cs1.subCaptures(cs2, frozen = false)
-      if res != CompareResult.OK then
+      if !res.isOK then
         report.error(i"references $cs1 are not all included in allowed capture set ${res.blocking}", pos)
 
     override def recheckClosure(tree: Closure, pt: Type)(using Context): Type =