Drop switch on newScheme, drop code that's no longer used.

Author: odersky

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

@@ -652,42 +652,20 @@ class CheckCaptures extends Recheck, SymTransformer:
       if sym.is(Method) then
         // If ident refers to a parameterless method, charge its cv to the environment
         includeCallCaptures(sym, sym.info, tree)
-      else if !sym.isStatic then
-        if ccConfig.newScheme && sym.exists
-        then markPathFree(sym.termRef, pt, tree)
-        else markFree(sym, pathRef(sym.termRef, pt), tree)
+      else if sym.exists && !sym.isStatic then
+        markPathFree(sym.termRef, pt, tree)
       mapResultRoots(super.recheckIdent(tree, pt), tree.symbol)
 
     override def recheckThis(tree: This, pt: Type)(using Context): Type =
-      if ccConfig.newScheme
-      then markPathFree(tree.tpe.asInstanceOf[ThisType], pt, tree)
-      else markFree(pathRef(tree.tpe.asInstanceOf[ThisType], pt), tree)
+      markPathFree(tree.tpe.asInstanceOf[ThisType], pt, tree)
       super.recheckThis(tree, pt)
 
     /** Add all selections and also any `.rd modifier implied by the expected
-     *  type `pt` to `base`. Example:
+     *  type `pt` to `ref`. Expand the marked tree accordingly to take account of
+     *  the added path. Example:
      *  If we have `x` and the expected type says we select that with `.a.b`
-     *  where `b` is a read-only method, we charge `x.a.b.rd` instead of `x`.
-     */
-    private def pathRef(base: TermRef | ThisType, pt: Type)(using Context): Capability =
-      def addSelects(ref: TermRef | ThisType, pt: Type): Capability = pt match
-        case pt: PathSelectionProto if ref.isTracked =>
-          if pt.select.symbol.isReadOnlyMethod then
-            ref.readOnly
-          else
-            // if `ref` is not tracked then the selection could not give anything new
-            // class SerializationProxy in stdlib-cc/../LazyListIterable.scala has an example where this matters.
-            addSelects(ref.select(pt.select.symbol).asInstanceOf[TermRef], pt.pt)
-        case _ => ref
-      val ref: Capability = addSelects(base, pt)
-      if ref.derivesFromMutable && pt.isValueType && !pt.isMutableType
-      then ref.readOnly
-      else ref
-
-    /** Add all selections and also any `.rd modifier implied by the expected
-     *  type `pt` to `base`. Example:
-     *  If we have `x` and the expected type says we select that with `.a.b`
-     *  where `b` is a read-only method, we charge `x.a.b.rd` instead of `x`.
+     *  where `b` is a read-only method, we charge `x.a.b.rd` for tree `x.a.b`
+     *  instead of just charging `x`.
      */
     private def markPathFree(ref: TermRef | ThisType, pt: Type, tree: Tree)(using Context): Unit =
       pt match