Update doc comments

Author: odersky

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

@@ -166,15 +166,15 @@ abstract class Constraint extends Showable {
    */
   def hasConflictingTypeVarsFor(tl: TypeLambda, that: Constraint): Boolean
 
-  /** A map that associates type variables with all other type variables that
-   *  refer to them in their bounds covariantly, such that, if the type variable
-   *  is isntantiated to a larger type, the constraint would be narrowed.
+  /** A map that associates type parameters of this constraint with all other type
+   *  parameters that refer to them in their bounds covariantly, such that, if the
+   *  type parameter is instantiated to a larger type, the constraint would be narrowed.
    */
   def coDeps: Constraint.ReverseDeps
 
-  /** A map that associates type variables with all other type variables that
-   *  refer to them in their bounds covariantly, such that, if the type variable
-   *  is isntantiated to a smaller type, the constraint would be narrowed.
+  /** A map that associates type parameters of this constraint with all other type
+   *  parameters that refer to them in their bounds covariantly, such that, if the
+   *  type parameter is instantiated to a smaller type, the constraint would be narrowed.
    */
   def contraDeps: Constraint.ReverseDeps
 
@@ -209,7 +209,6 @@ abstract class Constraint extends Showable {
 object Constraint:
   type ReverseDeps = SimpleIdentityMap[TypeParamRef, SimpleIdentitySet[TypeParamRef]]
 
-
 /** When calling `Constraint#addLess(p1, p2, ...)`, the caller might end up
  *  unifying one parameter with the other, this enum lets `addLess` know which
  *  direction the unification will take.

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

@@ -11,7 +11,6 @@ import config.Config
 import config.Printers.constr
 import reflect.ClassTag
 import Constraint.ReverseDeps
-import NameKinds.DepParamName
 import annotation.tailrec
 import annotation.internal.sharable
 import cc.{CapturingType, derivedCapturingType}
@@ -223,7 +222,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       if tvar == null then NoType
       else tvar
 
-// ------------- TypeVar dependencies -----------------------------------
+// ------------- Type parameter dependencies ----------------------------------------
 
   var coDeps, contraDeps: ReverseDeps = SimpleIdentityMap.empty
 
@@ -233,10 +232,11 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       tv.origin
     val param = origin(tv)
     val excluded = except.map(origin)
+    val qualifies: TypeParamRef => Boolean = !excluded.contains(_)
     def test(deps: ReverseDeps, lens: ConstraintLens[List[TypeParamRef]]) =
       val depending = deps(param)
-      null != depending && depending.exists(!excluded.contains(_))
-      || lens(this, tv.origin.binder, tv.origin.paramNum).exists(!excluded.contains(_))
+      null != depending && depending.exists(qualifies)
+      || lens(this, tv.origin.binder, tv.origin.paramNum).exists(qualifies)
         //.showing(i"outer depends on $tv with ${tvdeps.toList}%, % = $result")
     if co then test(coDeps, upperLens) else test(contraDeps, lowerLens)
 
@@ -259,12 +259,12 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
   end Adjuster
 
   /** Adjust dependencies to account for the delta of previous entry `prevEntry`
-   *  and new bound `entry` for the type variable `tvar`.
+   *  and new bound `entry` for the type parameter `srcParam`.
    */
   def adjustDeps(entry: Type | Null, prevEntry: Type | Null, srcParam: TypeParamRef)(using Context): this.type =
     val adjuster = new Adjuster(srcParam)
 
-    /** Adjust reverse depemdencies of all type parameters referenced by `bound`
+    /** Adjust reverse dependencies of all type parameters referenced by `bound`
      *  @param  isLower `bound` is a lower bound
      *  @param  add     if true, add referenced variables to dependencoes, otherwise drop them.
      */
@@ -316,8 +316,8 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     this
   end adjustDeps
 
-  /** Adjust dependencies to account for adding or dropping `entries` to the
-   *  constraint.
+  /** Adjust dependencies to account for adding or dropping all `entries` associated
+   *  with `poly`.
    *  @param add   if true, entries is added, otherwise it is dropped
    */
   def adjustDeps(poly: TypeLambda, entries: Array[Type], add: Boolean)(using Context): this.type =
@@ -327,7 +327,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       else adjustDeps(NoType, entries(n), poly.paramRefs(n))
     this
 
-  /** If `tp` is a type variable, remove all its reverse dependencies */
+  /** Remove all reverse dependencies of `param` */
   def dropDeps(param: TypeParamRef)(using Context): Unit =
     coDeps = coDeps.remove(param)
     contraDeps = contraDeps.remove(param)
@@ -589,8 +589,11 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
 
       def removeParam(ps: List[TypeParamRef]) = ps.filterConserve(param ne _)
 
-      def replaceParam(tp: Type, atPoly: TypeLambda, atIdx: Int): Type =
-        current.ensureNonCyclic(atPoly.paramRefs(atIdx), tp.substParam(param, replacement))
+      def replaceParam(entry: Type, atPoly: TypeLambda, atIdx: Int): Type =
+        val pref = atPoly.paramRefs(atIdx)
+        val newEntry = current.ensureNonCyclic(pref, entry.substParam(param, replacement))
+        adjustDeps(newEntry, entry, pref)
+        newEntry
 
       current.foreachParam { (p, i) =>
         current = boundsLens.map(this, current, p, i,