Fix rebase breakage

Author: odersky

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

@@ -703,14 +703,6 @@ object Capabilities:
       (this eq y)
       || this.match
         case x: FreshCap =>
-          def levelOK =
-            if ccConfig.useFreshLevels && !CCState.collapseFresh then
-              val yOwner = y.levelOwner
-              yOwner.isStaticOwner || x.ccOwner.isContainedIn(yOwner)
-            else y.core match
-              case ResultCap(_) | _: ParamRef => false
-              case _ => true
-
           vs.ifNotSeen(this)(x.hiddenSet.elems.exists(_.subsumes(y)))
           || x.acceptsLevelOf(y)
               && ( y.tryClassifyAs(x.hiddenSet.classifier)
@@ -1017,69 +1009,6 @@ object Capabilities:
     def inverse = Inverse()
   end Internalize
 
-  /** The local dual of a result type of a closure type.
-   *  @param binder  the method type of the anonymous function whose result is mapped
-   *  @pre           the context's owner is the anonymous function
-   */
-  class Internalize(binder: MethodType)(using Context) extends BiTypeMap:
-    thisMap =>
-
-    val sym = ctx.owner
-    assert(sym.isAnonymousFunction)
-    val paramSyms = atPhase(ctx.phase.prev):
-      // We need to ask one phase before since `sym` should not be completed as a side effect.
-      // The result of Internalize is used to se the result type of an anonymous function, and
-      // the new info of that function is built with the result.
-      sym.paramSymss.head
-    val resultToFresh = EqHashMap[ResultCap, FreshCap]()
-    val freshToResult = EqHashMap[FreshCap, ResultCap]()
-
-    override def apply(t: Type) =
-      if variance < 0 then t
-      else t match
-        case t: ParamRef =>
-          if t.binder == this.binder then paramSyms(t.paramNum).termRef else t
-        case _ => mapOver(t)
-
-    override def mapCapability(c: Capability, deep: Boolean): Capability = c match
-      case r: ResultCap if r.binder == this.binder =>
-        resultToFresh.get(r) match
-          case Some(f) => f
-          case None =>
-            val f = FreshCap(Origin.LocalInstance(binder.resType))
-            resultToFresh(r) = f
-            freshToResult(f) = r
-            f
-      case _ =>
-        super.mapCapability(c, deep)
-
-    class Inverse extends BiTypeMap:
-      def apply(t: Type): Type =
-        if variance < 0 then t
-        else t match
-          case t: TermRef if paramSyms.contains(t) =>
-            binder.paramRefs(paramSyms.indexOf(t.symbol))
-          case _ => mapOver(t)
-
-      override def mapCapability(c: Capability, deep: Boolean): Capability = c match
-        case f: FreshCap if f.owner == sym =>
-          freshToResult.get(f) match
-            case Some(r) => r
-            case None =>
-              val r = ResultCap(binder)
-              resultToFresh(r) = f
-              freshToResult(f) = r
-              r
-        case _ => super.mapCapability(c, deep)
-
-      def inverse = thisMap
-      override def toString = thisMap.toString + ".inverse"
-    end Inverse
-
-    override def toString = "InternalizeClosureResult"
-    def inverse = Inverse()
-  end Internalize
-
   /** Map top-level free existential variables one-to-one to Fresh instances */
   def resultToFresh(tp: Type, origin: Origin)(using Context): Type =
     val subst = new TypeMap:

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

@@ -3,7 +3,7 @@
   |  ^^^^^^^^^^^^^^^^^^^^^^
   |  Found:    () ->{f} Unit
   |  Required: () -> Unit
-  |  Note that capability (f : () => Unit) is not included in capture set {}.
+  |  Note that capability f is not included in capture set {}.
   |
   | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/i21347.scala:11:15 ------------------------------------------------------------

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

@@ -12,12 +12,13 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i21614.scala:15:12 ---------------------------------------
 15 |  files.map(new Logger(_)) // error, Q: can we improve the error message?
    |            ^^^^^^^^^^^^^
-   |Found:    (_$1: File^?) ->{C} Logger{val f: File^{_$1}}^{cap.rd, _$1}
-   |Required: File^{C} => Logger{val f: File^?}^?
+   |Found:    (_$1: File^'s1) ->{C} Logger{val f: File^{_$1}}^{cap.rd, _$1}
+   |Required: File^{C} => Logger{val f: File^'s2}^'s3
    |
    |where:    =>  refers to a fresh root capability created in method mkLoggers2 when checking argument to parameter f of method map
    |          cap is a root capability associated with the result type of (_$1: File^'s1): Logger{val f: File^{_$1}}^{cap.rd, _$1}
    |
-   |Note that capability <cap of (_$1: File^{files*}): Logger{val f: File^'s2}^'s3>.rd cannot be included in outer capture set 's3.
+   |Note that capability C is not classified as trait SharedCapability, therefore it
+   |cannot be included in capture set 's1 of parameter _$1 of SharedCapability elements.
    |
    | longer explanation available when compiling with `-explain`

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

@@ -108,8 +108,8 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/reaches.scala:90:10 --------------------------------------
 90 |  ps.map((x, y) => compose1(x, y)) // error
    |          ^^^^^^^^^^^^^^^^^^^^^^^
-   |Found:    (x$1: (A^ ->? A^?, A^ ->? A^?)^?) ->? A^? ->? A^?
-   |Required: ((A ->{C} A, A ->{C} A)) => A^? ->? A^?
+   |Found:    (x$1: (A^ ->'s20 A^'s21, A^ ->'s22 A^'s23)^'s24) ->'s25 A^'s26 ->'s27 A^'s28
+   |Required: ((A ->{C} A, A ->{C} A)) => A^'s29 ->'s30 A^'s31
    |
    |where:    => refers to a fresh root capability created in method mapCompose2 when checking argument to parameter f of method map
    |          ^  refers to the universal root capability

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

@@ -27,14 +27,14 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/vars.scala:36:8 ------------------------------------------
 36 |  local { cap3 => // error
    |        ^
-   |      Found:    (cap3: CC^) ->'s1 String => String
-   |      Required: CC^ -> String =>² String
+   |Found:    (cap3: CC^) ->'s1 String => String
+   |Required: CC^ -> String =>² String
    |
    |where:    =>  refers to a root capability associated with the result type of (cap3: CC^): String => String
    |          =>² refers to a fresh root capability created in method test of parameter parameter cap3² of method $anonfun
    |          ^   refers to the universal root capability
    |
-   |      Note that capability <cap of (cap3: CC^): String => String> cannot be included in outer capture set {cap}.
+   |Note that capability <cap of (cap3: CC^): String => String> cannot be included in outer capture set {cap}.
 37 |    def g(x: String): String = if cap3 == cap3 then "" else "a"
 38 |    g
 39 |  }