Refactor hardenedVars handling

Author: odersky

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

@@ -498,7 +498,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         /** Mark toplevel type vars in `tp2` as hard in the current typerState */
         def hardenTypeVars(tp2: Type): Unit = tp2.dealiasKeepRefiningAnnots match
           case tvar: TypeVar if constraint.contains(tvar.origin) =>
-            state.hardVars += tvar
+            state.hardenTypeVar(tvar)
           case tp2: TypeParamRef if constraint.contains(tp2) =>
             hardenTypeVars(constraint.typeVarOfParam(tp2))
           case tp2: AndOrType =>

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

@@ -96,9 +96,7 @@ class TyperState() {
    *  its lower bound, top-level soft unions in the instance type are converted
    *  to hard unions instead of being widened in `widenOr`.
    */
-  private var myHardVars: TypeVars = _
-  def hardVars: TypeVars = myHardVars
-  def hardVars_=(tvs: TypeVars): Unit = myHardVars = tvs
+  private var hardVars: TypeVars = _
 
   private var upLevels: LevelMap = _
 
@@ -112,7 +110,7 @@ class TyperState() {
     this.myConstraint = constraint
     this.previousConstraint = constraint
     this.myOwnedVars = SimpleIdentitySet.empty
-    this.myHardVars = SimpleIdentitySet.empty
+    this.hardVars = SimpleIdentitySet.empty
     this.upLevels = SimpleIdentityMap.empty
     this.isCommitted = false
     this
@@ -131,6 +129,12 @@ class TyperState() {
   /** The uninstantiated variables */
   def uninstVars: collection.Seq[TypeVar] = constraint.uninstVars
 
+  /** Register type variable `tv` as hard. */
+  def hardenTypeVar(tv: TypeVar): Unit = hardVars += tv
+
+  /** Is type variable `tv` registered as hard? */
+  def isHard(tv: TypeVar): Boolean = hardVars.contains(tv)
+
   /** The nestingLevel of `tv` in this typer state */
   def nestingLevel(tv: TypeVar): Int =
     val own = upLevels(tv)
@@ -195,6 +199,7 @@ class TyperState() {
         if !ownedVars.isEmpty then ownedVars.foreach(targetState.includeVar)
       else
         targetState.mergeConstraintWith(this)
+        for tv <- hardVars do targetState.hardVars += tv
 
     upLevels.foreachBinding { (tv, level) =>
       if level < targetState.nestingLevel(tv) then
@@ -250,7 +255,6 @@ class TyperState() {
           val otherLos = other.lower(p)
           val otherHis = other.upper(p)
           val otherEntry = other.entry(p)
-          if that.hardVars.contains(tv) then this.myHardVars += tv
           (  (otherLos eq constraint.lower(p)) || otherLos.forall(_ <:< p)) &&
           (  (otherHis eq constraint.upper(p)) || otherHis.forall(p <:< _)) &&
           ((otherEntry eq constraint.entry(p)) || otherEntry.match

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

@@ -4721,8 +4721,7 @@ object Types {
         instantiateWith(tp)
 
     /** Widen unions when instantiating this variable in the current context? */
-    def widenUnions(using Context): Boolean =
-      !ctx.typerState.hardVars.contains(this)
+    def widenUnions(using Context): Boolean = !ctx.typerState.isHard(this)
 
     /** For uninstantiated type variables: the entry in the constraint (either bounds or
      *  provisional instance value)