Drop some BiTypeMaps

Also simplify BiTypeMap: the special cases for TypeParamRefs with underlying NoType are no linger needed
since isTrackableRef was changed to include these TypeParamRefs.

Author: odersky

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

@@ -55,7 +55,7 @@ object ccConfig:
 
   /** Not used currently. Handy for trying out new features */
   def newScheme(using Context): Boolean =
-    Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.7`)
+    Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.8`)
 
 end ccConfig
 

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

@@ -320,11 +320,6 @@ sealed abstract class CaptureSet extends Showable:
    *  sound nor complete.
    */
   def map(tm: TypeMap)(using Context): CaptureSet =
-    def freeze() = this match
-      case self: Var if !isConst && ccConfig.newScheme =>
-        if tm.variance < 0 then self.solve()
-        else self.markSolved(provisional = true)
-      case _ =>
     tm match
       case tm: BiTypeMap =>
         val mappedElems = elems.map(tm.forward)
@@ -341,7 +336,7 @@ sealed abstract class CaptureSet extends Showable:
         if isConst then
           if mapped.isConst && mapped.elems == elems && !mapped.keepAlways then this
           else mapped
-        else if ccConfig.newScheme then
+        else if true || ccConfig.newScheme then
           if mapped.elems == elems then this
           else
             asVar.markSolved(provisional = true)
@@ -458,7 +453,10 @@ object CaptureSet:
     def isProvisionallySolved(using Context) = false
 
     def addThisElem(elem: CaptureRef)(using Context, VarState): CompareResult =
-      addIfHiddenOrFail(elem)
+      val res = addIfHiddenOrFail(elem)
+      if !res.isOK && this.isProvisionallySolved then
+        println(i"Cannot add $elem to provisionally solved $this")
+      res
 
     def addDependent(cs: CaptureSet)(using Context, VarState) = CompareResult.OK
 

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

@@ -92,44 +92,6 @@ object CheckCaptures:
     override def toString = "SubstParamsMap"
   end SubstParamsMap
 
-  /** Used for substituting parameters in a special case: when all actual arguments
-   *  are mutually distinct capabilities.
-   */
-  final class SubstParamsBiMap(from: LambdaType, to: List[Type])(using Context)
-  extends BiTypeMap:
-    thisMap =>
-
-    def apply(tp: Type): Type = tp match
-      case tp: ParamRef =>
-        if tp.binder == from then to(tp.paramNum) else tp
-      case tp: NamedType =>
-        if tp.prefix `eq` NoPrefix then tp
-        else tp.derivedSelect(apply(tp.prefix))
-      case _: ThisType =>
-        tp
-      case _ =>
-        mapOver(tp)
-    override def toString = "SubstParamsBiMap"
-
-    lazy val inverse = new BiTypeMap:
-      def apply(tp: Type): Type = tp match
-        case tp: NamedType =>
-          var idx = 0
-          var to1 = to
-          while idx < to.length && (tp ne to(idx)) do
-            idx += 1
-            to1 = to1.tail
-          if idx < to.length then from.paramRefs(idx)
-          else if tp.prefix `eq` NoPrefix then tp
-          else tp.derivedSelect(apply(tp.prefix))
-        case _: ThisType =>
-          tp
-        case _ =>
-          mapOver(tp)
-      override def toString = "SubstParamsBiMap.inverse"
-      def inverse = thisMap
-  end SubstParamsBiMap
-
   /** A prototype that indicates selection with an immutable value */
   class PathSelectionProto(val sym: Symbol, val pt: Type)(using Context) extends WildcardSelectionProto
 
@@ -825,19 +787,11 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  This means
      *   - Instantiate result type with actual arguments
      *   - if `sym` is a constructor, refine its type with `refineInstanceType`
-     *  If all argument types are mutually different trackable capture references, use a BiTypeMap,
-     *  since that is more precise. Otherwise use a normal idempotent map, which might lose information
-     *  in the case where the result type contains captureset variables that are further
-     *  constrained afterwards.
      */
     override def instantiate(mt: MethodType, argTypes: List[Type], sym: Symbol)(using Context): Type =
       val ownType =
-        if !mt.isResultDependent then
-          mt.resType
-        else if argTypes.forall(_.isTrackableRef) && isDistinct(argTypes) then
-          SubstParamsBiMap(mt, argTypes)(mt.resType)
-        else
-          SubstParamsMap(mt, argTypes)(mt.resType)
+        if !mt.isResultDependent then mt.resType
+        else SubstParamsMap(mt, argTypes)(mt.resType)
       if sym.isConstructor then refineConstructorInstance(ownType, mt, argTypes, sym)
       else ownType
 
@@ -958,8 +912,10 @@ class CheckCaptures extends Recheck, SymTransformer:
           case FunctionOrMethod(argTypes, resType) =>
             assert(params.hasSameLengthAs(argTypes), i"$mdef vs $pt, ${params}")
             for (argType, param) <- argTypes.lazyZip(params) do
-              //println(i"compare $argType against $param")
-              checkConformsExpr(argType, root.freshToCap(param.asInstanceOf[ValDef].tpt.nuType), param)
+              val paramTpt = param.asInstanceOf[ValDef].tpt
+              val paramType = root.freshToCap(paramTpt.nuType)
+              checkConformsExpr(argType, paramType, param)
+                .showing(i"compared expected closure formal $argType against $param with ${paramTpt.nuType}", capt)
             if ccConfig.preTypeClosureResults && !(isEtaExpansion(mdef) && ccConfig.handleEtaExpansionsSpecially) then
               // Check whether the closure's result conforms to the expected type
               // This constrains parameter types of the closure which can give better

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

@@ -468,44 +468,6 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     else tp3
   end transformExplicitType
 
-  /** Substitute parameter symbols in `from` to paramRefs in corresponding
-   *  method or poly types `to`. We use a single BiTypeMap to do everything.
-   *  @param from  a list of lists of type or term parameter symbols of a curried method
-   *  @param to    a list of method or poly types corresponding one-to-one to the parameter lists
-   */
-  private class SubstParams(from: List[List[Symbol]], to: List[LambdaType])(using Context)
-  extends DeepTypeMap, BiTypeMap:
-
-    def apply(t: Type): Type = t match
-      case t: NamedType =>
-        if t.prefix == NoPrefix then
-          val sym = t.symbol
-          def outer(froms: List[List[Symbol]], tos: List[LambdaType]): Type =
-            def inner(from: List[Symbol], to: List[ParamRef]): Type =
-              if from.isEmpty then outer(froms.tail, tos.tail)
-              else if sym eq from.head then to.head
-              else inner(from.tail, to.tail)
-            if tos.isEmpty then t
-            else inner(froms.head, tos.head.paramRefs)
-          outer(from, to)
-        else t.derivedSelect(apply(t.prefix))
-      case _ =>
-        mapOver(t)
-
-    lazy val inverse = new BiTypeMap:
-      override def toString = "SubstParams.inverse"
-      def apply(t: Type): Type = t match
-        case t: ParamRef =>
-          def recur(from: List[LambdaType], to: List[List[Symbol]]): Type =
-            if from.isEmpty then t
-            else if t.binder eq from.head then to.head(t.paramNum).namedType
-            else recur(from.tail, to.tail)
-          recur(to, from)
-        case _ =>
-          mapOver(t)
-      def inverse = SubstParams.this
-  end SubstParams
-
   /** Update info of `sym` for CheckCaptures phase only */
   private def updateInfo(sym: Symbol, info: Type)(using Context) =
     toBeUpdated += sym
@@ -664,44 +626,6 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         def signatureChanges =
           tree.tpt.hasNuType || paramSignatureChanges
 
-        // Replace an existing symbol info with inferred types where capture sets of
-        // TypeParamRefs and TermParamRefs are put in correspondence by BiTypeMaps with the
-        // capture sets of the types of the method's parameter symbols and result type.
-        def integrateRT(
-            info: Type,                     // symbol info to replace
-            psymss: List[List[Symbol]],     // the local (type and term) parameter symbols corresponding to `info`
-            resType: Type,                  // the locally computed return type
-            prevPsymss: List[List[Symbol]], // the local parameter symbols seen previously in reverse order
-            prevLambdas: List[LambdaType]   // the outer method and polytypes generated previously in reverse order
-          ): Type =
-          info match
-            case mt: MethodOrPoly =>
-              val psyms = psymss.head
-              // TODO: the substitution does not work for param-dependent method types.
-              // For example, `(x: T, y: x.f.type) => Unit`. In this case, when we
-              // substitute `x.f.type`, `x` becomes a `TermParamRef`. But the new method
-              // type is still under initialization and `paramInfos` is still `null`,
-              // so the new `NamedType` will not have a denotation.
-              def adaptedInfo(psym: Symbol, info: mt.PInfo): mt.PInfo = mt.companion match
-                case mtc: MethodTypeCompanion => mtc.adaptParamInfo(psym, info).asInstanceOf[mt.PInfo]
-                case _ => info
-              mt.companion(mt.paramNames)(
-                mt1 =>
-                  if !paramSignatureChanges && !mt.isParamDependent && prevLambdas.isEmpty then
-                    mt.paramInfos
-                  else
-                    val subst = SubstParams(psyms :: prevPsymss, mt1 :: prevLambdas)
-                    psyms.map(psym => adaptedInfo(psym, subst(root.freshToCap(psym.nextInfo)).asInstanceOf[mt.PInfo])),
-                mt1 =>
-                  integrateRT(mt.resType, psymss.tail, resType, psyms :: prevPsymss, mt1 :: prevLambdas)
-              )
-            case info: ExprType =>
-              info.derivedExprType(resType =
-                integrateRT(info.resType, psymss, resType, prevPsymss, prevLambdas))
-            case info =>
-              if prevLambdas.isEmpty then resType
-              else SubstParams(prevPsymss, prevLambdas)(resType)
-
         def paramsToCap(mt: Type)(using Context): Type = mt match
           case mt: MethodType =>
             mt.derivedLambdaType(
@@ -714,52 +638,30 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         // If there's a change in the signature, update the info of `sym`
         if sym.exists && signatureChanges then
           val updatedInfo =
-            if ccConfig.newScheme then
-              val paramSymss = sym.paramSymss
-              def newInfo(using Context) = // will be run in this or next phase
-                root.toResultInResults(report.error(_, tree.srcPos)):
-                  if sym.is(Method) then
-                    paramsToCap(methodType(paramSymss, localReturnType))
-                  else tree.tpt.nuType
-              if tree.tpt.isInstanceOf[InferredTypeTree]
-                  && !sym.is(Param) && !sym.is(ParamAccessor)
-              then
-                val prevInfo = sym.info
-                new LazyType:
-                  def complete(denot: SymDenotation)(using Context) =
-                    assert(ctx.phase == thisPhase.next, i"$sym")
-                    sym.info = prevInfo // set info provisionally so we can analyze the symbol in recheck
-                    completeDef(tree, sym, this)
-                    sym.info = newInfo
-                      .showing(i"new info of $sym = $result", capt)
-              else if sym.is(Method) then
-                new LazyType:
-                  def complete(denot: SymDenotation)(using Context) =
-                    sym.info = newInfo
-                      .showing(i"new info of $sym = $result", capt)
-              else newInfo
-            else
-              val newInfo =
-                root.toResultInResults(report.error(_, tree.srcPos)):
-                  integrateRT(sym.info, sym.paramSymss, localReturnType, Nil, Nil)
-                .showing(i"update info $sym: ${sym.info} = $result", capt)
-              if sym.isAnonymousFunction
-                  || sym.is(Param)
-                  || sym.is(ParamAccessor)
-                  || sym.isPrimaryConstructor
-              then
-                // closures are handled specially; the newInfo is constrained from
-                // the expected type and only afterwards we recheck the definition
-                newInfo
-              else new LazyType:
-                // infos of other methods are determined from their definitions, which
-                // are checked on demand
+
+            val paramSymss = sym.paramSymss
+            def newInfo(using Context) = // will be run in this or next phase
+              root.toResultInResults(report.error(_, tree.srcPos)):
+                if sym.is(Method) then
+                  paramsToCap(methodType(paramSymss, localReturnType))
+                else tree.tpt.nuType
+            if tree.tpt.isInstanceOf[InferredTypeTree]
+                && !sym.is(Param) && !sym.is(ParamAccessor)
+            then
+              val prevInfo = sym.info
+              new LazyType:
                 def complete(denot: SymDenotation)(using Context) =
                   assert(ctx.phase == thisPhase.next, i"$sym")
-                  capt.println(i"forcing $sym, printing = ${ctx.mode.is(Mode.Printing)}")
-                  //if ctx.mode.is(Mode.Printing) then new Error().printStackTrace()
-                  sym.info = newInfo
+                  sym.info = prevInfo // set info provisionally so we can analyze the symbol in recheck
                   completeDef(tree, sym, this)
+                  sym.info = newInfo
+                    .showing(i"new info of $sym = $result", capt)
+            else if sym.is(Method) then
+              new LazyType:
+                def complete(denot: SymDenotation)(using Context) =
+                  sym.info = newInfo
+                    .showing(i"new info of $sym = $result", capt)
+            else newInfo
           updateInfo(sym, updatedInfo)
 
       case tree: Bind =>

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

@@ -188,7 +188,7 @@ object root:
 
     override def toString = "CapToFresh"
 
-    lazy val inverse: BiTypeMap & FollowAliasesMap = new BiTypeMap with FollowAliasesMap:
+    object inverse extends BiTypeMap, FollowAliasesMap:
       def apply(t: Type): Type = t match
         case t @ Fresh(_) => cap
         case t @ CapturingType(_, refs) => mapOver(t)

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

@@ -180,7 +180,7 @@ object Substituters:
     def apply(tp: Type): Type = subst(tp, from, to, this)(using mapCtx)
   }
 
-  final class SubstSymMap(from: List[Symbol], to: List[Symbol])(using Context) extends DeepTypeMap, BiTypeMap {
+  final class SubstSymMap(from: List[Symbol], to: List[Symbol])(using Context) extends DeepTypeMap {
     def apply(tp: Type): Type = substSym(tp, from, to, this)(using mapCtx)
     def inverse = SubstSymMap(to, from) // implicitly requires that `to` contains no duplicates.
   }

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

@@ -6085,9 +6085,6 @@ object Types extends TypeUtils {
     def forward(ref: CaptureRef): CaptureRef =
       val result = this(ref)
       def ensureTrackable(tp: Type): CaptureRef = tp match
-        /* Issue #22437: handle case when info is not yet available during postProcess in CC setup */
-        case tp: (TypeParamRef | TermRef) if tp.underlying == NoType =>
-          tp
         case tp: CaptureRef =>
           if tp.isTrackableRef then tp
           else ensureTrackable(tp.underlying)
@@ -6099,9 +6096,6 @@ object Types extends TypeUtils {
 
     /** A restriction of the inverse to a function on tracked CaptureRefs */
     def backward(ref: CaptureRef): CaptureRef = inverse(ref) match
-      /* Ensure bijection for issue #22437 fix in method forward above:  */
-      case result: (TypeParamRef | TermRef) if result.underlying == NoType =>
-        result
       case result: CaptureRef if result.isTrackableRef => result
   end BiTypeMap
 

tests/pos-custom-args/captures/i20135-explicit.scala

@@ -0,0 +1,11 @@
+import language.experimental.captureChecking
+
+class Network
+
+class Page(val nw: Network^):
+  def render(client: Page^{nw} -> Unit) = client(this)
+
+def main(net: Network^) =
+  var page: Page{val nw: Network^{net}}^{net} = Page(net)
+  page.render(p => ())
+