Simplify ParamRef disambiguation

Author: odersky

compiler/src/dotty/tools/dotc/reporting/Message.scala

@@ -62,13 +62,6 @@ object Message:
    */
   private class Seen(disambiguate: Disambiguation):
 
-    /** The set of lambdas that were opened at some point during printing. */
-    private val openedLambdas = new collection.mutable.HashSet[LambdaType]
-
-    /** Register that `tp` was opened during printing. */
-    def openLambda(tp: LambdaType): Unit =
-      openedLambdas += tp
-
     val seen = new collection.mutable.HashMap[SeenKey, List[Recorded]].withDefaultValue(Nil)
 
     var nonSensical = false
@@ -109,16 +102,17 @@ object Message:
         lazy val dealiased = followAlias(entry)
 
         /** All lambda parameters with the same name are given the same superscript as
-         *  long as their corresponding binder has been printed.
-         *  See tests/neg/lambda-rename.scala for test cases.
+         *  long as their corresponding binders have the same parameter name lists.
+         *  This avoids spurious distinctions between parameters of mapped lambdas at
+         *  the risk that sometimes we cannot distinguish parameters of distinct functions
+         *  that have the same parameter names. See tests/neg/lambda-rename.scala for test cases.
          */
         def sameSuperscript(cur: Recorded, existing: Recorded) =
           (cur eq existing) ||
           (cur, existing).match
             case (cur: ParamRef, existing: ParamRef) =>
-              (cur.paramName eq existing.paramName) &&
-              openedLambdas.contains(cur.binder) &&
-              openedLambdas.contains(existing.binder)
+              (cur.paramName eq existing.paramName)
+              && cur.binder.paramNames == existing.binder.paramNames
             case _ =>
               false
 
@@ -266,20 +260,10 @@ object Message:
         case _ =>
           super.funMiddleText(isContextual, isPure, refs)
 
-    override def toTextMethodAsFunction(info: Type, isPure: Boolean, refs: GeneralCaptureSet | Null): Text =
-      info match
-        case info: LambdaType =>
-          seen.openLambda(info)
-        case _ =>
-      super.toTextMethodAsFunction(info, isPure, refs)
-
     override def toText(tp: Type): Text =
       if !tp.exists || tp.isErroneous then seen.nonSensical = true
       tp match
         case tp: TypeRef if useSourceModule(tp.symbol) => Str("object ") ~ super.toText(tp)
-        case tp: LambdaType =>
-          seen.openLambda(tp)
-          super.toText(tp)
         case _ => super.toText(tp)
 
     override def toText(sym: Symbol): Text =

tests/neg-custom-args/captures/filevar.check

@@ -4,7 +4,7 @@
    |Found:    (f: File^'s1) ->'s2 Unit
    |Required: (f: File^{l}) => Unit
    |
-   |where:    => refers to a fresh root capability created in anonymous function of type (using l²: scala.caps.Capability): File^{l²} -> Unit when instantiating expected result type (f: File^{l}) ->{cap} Unit of function literal
+   |where:    => refers to a fresh root capability created in anonymous function of type (using l: scala.caps.Capability): File^{l} -> Unit when instantiating expected result type (f: File^{l}) ->{cap} Unit of function literal
    |
    |Note that capability l cannot be included in outer capture set 's1 of parameter f.
 16 |    val o = Service()

tests/neg-custom-args/captures/i15923.check

@@ -2,11 +2,9 @@
 27 |    val leak = withCap(cap => mkId(cap))  // error (was: no error here since type aliases don't box)
    |                       ^^^^^^^^^^^^^^^^
    |Found:    (cap: test2.Cap^'s1) ->'s2 [T] => (op: test2.Cap^'s3 ->'s4 T) ->'s5 T
-   |Required: test2.Cap^{lcap} => [T] => (op²: test2.Cap^'s6 ->'s7 T) ->'s8 T
+   |Required: test2.Cap^{lcap} => [T] => (op: test2.Cap^'s6 ->'s7 T) ->'s8 T
    |
-   |where:    =>  refers to a fresh root capability created in anonymous function of type (using lcap²: scala.caps.Capability): test2.Cap^{lcap²} -> [T] => (op³: test2.Cap^{lcap²} => T) -> T when instantiating expected result type test2.Cap^{lcap} ->{cap²} [T] => (op²: test2.Cap^'s6 ->'s7 T) ->'s8 T of function literal
-   |          op  is a reference to a value parameter
-   |          op² is a reference to a value parameter
+   |where:    => refers to a fresh root capability created in anonymous function of type (using lcap: scala.caps.Capability): test2.Cap^{lcap} -> [T] => (op: test2.Cap^{lcap} => T) -> T when instantiating expected result type test2.Cap^{lcap} ->{cap²} [T] => (op: test2.Cap^'s6 ->'s7 T) ->'s8 T of function literal
    |
    |Note that capability lcap cannot be included in outer capture set 's1 of parameter cap.
    |
@@ -17,7 +15,7 @@
    |Found:    (cap: Cap^'s9) ->'s10 Id[Cap^'s11]^'s12
    |Required: Cap^{lcap} => Id[Cap^'s13]^'s14
    |
-   |where:    => refers to a fresh root capability created in anonymous function of type (using lcap²: scala.caps.Capability): Cap^{lcap²} -> Id[Cap] when instantiating expected result type Cap^{lcap} ->{cap²} Id[Cap^'s13]^'s14 of function literal
+   |where:    => refers to a fresh root capability created in anonymous function of type (using lcap: scala.caps.Capability): Cap^{lcap} -> Id[Cap] when instantiating expected result type Cap^{lcap} ->{cap²} Id[Cap^'s13]^'s14 of function literal
    |
    |Note that capability lcap cannot be included in outer capture set 's9 of parameter cap.
    |