diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index 60309d4d83bd..b86734afcc0a 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -525,8 +525,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def makeRetaining(parent: Tree, refs: List[Tree], annotName: TypeName)(using Context): Annotated =
     Annotated(parent, New(scalaAnnotationDot(annotName), List(refs)))
 
-  def makeCapsOf(id: Ident)(using Context): Tree =
-    TypeApply(Select(scalaDot(nme.caps), nme.capsOf), id :: Nil)
+  def makeCapsOf(tp: Tree)(using Context): Tree =
+    TypeApply(Select(scalaDot(nme.caps), nme.capsOf), tp :: Nil)
 
   def makeCapsBound()(using Context): Tree =
     makeRetaining(
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index 29c6528e36de..79cc7d136e45 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -194,7 +194,8 @@ extension (tp: Type)
       true
     case tp: TermRef =>
       ((tp.prefix eq NoPrefix)
-      || tp.symbol.is(ParamAccessor) && tp.prefix.isThisTypeOf(tp.symbol.owner)
+      || tp.symbol.isField && !tp.symbol.isStatic && (
+        tp.prefix.isThisTypeOf(tp.symbol.owner) || tp.prefix.isTrackableRef)
       || tp.isRootCapability
       ) && !tp.symbol.isOneOf(UnstableValueFlags)
     case tp: TypeRef =>
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
index f00c6869cd80..05162907b608 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
@@ -61,18 +61,19 @@ trait CaptureRef extends TypeProxy, ValueType:
     case tp: TermParamRef => tp.underlying.derivesFrom(defn.Caps_Exists)
     case _ => false
 
-  /** Normalize reference so that it can be compared with `eq` for equality */
-  final def normalizedRef(using Context): CaptureRef = this match
-    case tp @ AnnotatedType(parent: CaptureRef, annot) if tp.isTrackableRef =>
-      tp.derivedAnnotatedType(parent.normalizedRef, annot)
-    case tp: TermRef if tp.isTrackableRef =>
-      tp.symbol.termRef
-    case _ => this
+  // With the support of pathes, we don't need to normalize the `TermRef`s anymore.
+  // /** Normalize reference so that it can be compared with `eq` for equality */
+  // final def normalizedRef(using Context): CaptureRef = this match
+  //   case tp @ AnnotatedType(parent: CaptureRef, annot) if tp.isTrackableRef =>
+  //     tp.derivedAnnotatedType(parent.normalizedRef, annot)
+  //   case tp: TermRef if tp.isTrackableRef =>
+  //     tp.symbol.termRef
+  //   case _ => this
 
   /** The capture set consisting of exactly this reference */
   final def singletonCaptureSet(using Context): CaptureSet.Const =
     if mySingletonCaptureSet == null then
-      mySingletonCaptureSet = CaptureSet(this.normalizedRef)
+      mySingletonCaptureSet = CaptureSet(this)
     mySingletonCaptureSet.uncheckedNN
 
   /** The capture set of the type underlying this reference */
@@ -99,25 +100,56 @@ trait CaptureRef extends TypeProxy, ValueType:
    *   x: x1.type /\ x1 subsumes y  ==>  x subsumes y
    */
   final def subsumes(y: CaptureRef)(using Context): Boolean =
-    (this eq y)
-    || this.isRootCapability
-    || y.match
-        case y: TermRef =>
-          (y.prefix eq this)
-          || y.info.match
-              case y1: SingletonCaptureRef => this.subsumes(y1)
-              case _ => false
-        case MaybeCapability(y1) => this.stripMaybe.subsumes(y1)
-        case _ => false
-    || this.match
-        case ReachCapability(x1) => x1.subsumes(y.stripReach)
-        case x: TermRef =>
-          x.info match
-            case x1: SingletonCaptureRef => x1.subsumes(y)
+    def compareCaptureRefs(x: Type, y: Type): Boolean =
+      (x eq y)
+      || y.match
+          case y: CaptureRef => x.match
+            case x: CaptureRef => x.subsumes(y)
             case _ => false
-        case x: TermParamRef => subsumesExistentially(x, y)
-        case x: TypeRef => assumedContainsOf(x).contains(y)
-        case _ => false
+          case _ => false
+
+    def compareUndelying(x: Type): Boolean = x match
+      case x: SingletonCaptureRef => x.subsumes(y)
+      case x: AndType => compareUndelying(x.tp1) || compareUndelying(x.tp2)
+      case x: OrType => compareUndelying(x.tp1) && compareUndelying(x.tp2)
+      case _ => false
+
+    if (this eq y) || this.isRootCapability then return true
+
+    // similar to compareNamed in TypeComparer
+    y match
+      case y: TermRef =>
+        this match
+          case x: TermRef =>
+            val xSym = x.symbol
+            val ySym = y.symbol
+
+            // check x.f and y.f
+            if (xSym ne NoSymbol)
+                && (xSym eq ySym)
+                && compareCaptureRefs(x.prefix, y.prefix)
+              || (x.name eq y.name)
+                && x.isPrefixDependentMemberRef
+                && compareCaptureRefs(x.prefix, y.prefix)
+                && x.signature == y.signature
+                && !(xSym.isClass && ySym.isClass)
+            then return true
+          case _ =>
+
+        // shorten
+        if compareCaptureRefs(this, y.prefix) then return true
+        // underlying
+        if compareCaptureRefs(this, y.info) then return true
+      case MaybeCapability(y1) => return this.stripMaybe.subsumes(y1)
+      case _ =>
+
+    return this.match
+      case ReachCapability(x1) => x1.subsumes(y.stripReach)
+      case x: TermRef => compareUndelying(x.info)
+      case CapturingType(x1, _) => compareUndelying(x1)
+      case x: TermParamRef => subsumesExistentially(x, y)
+      case x: TypeRef => assumedContainsOf(x).contains(y)
+      case _ => false
 
   def assumedContainsOf(x: TypeRef)(using Context): SimpleIdentitySet[CaptureRef] =
     CaptureSet.assumedContains.getOrElse(x, SimpleIdentitySet.empty)
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
index 44d5e2cf4b88..81b4287961ba 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
@@ -374,7 +374,7 @@ object CaptureSet:
 
   def apply(elems: CaptureRef*)(using Context): CaptureSet.Const =
     if elems.isEmpty then empty
-    else Const(SimpleIdentitySet(elems.map(_.normalizedRef.ensuring(_.isTrackableRef))*))
+    else Const(SimpleIdentitySet(elems.map(_.ensuring(_.isTrackableRef))*))
 
   def apply(elems: Refs)(using Context): CaptureSet.Const =
     if elems.isEmpty then empty else Const(elems)
@@ -508,7 +508,11 @@ object CaptureSet:
         !noUniversal
       else elem match
         case elem: TermRef if level.isDefined =>
-          elem.symbol.ccLevel <= level
+          elem.prefix match
+            case prefix: CaptureRef =>
+              levelOK(prefix)
+            case _ =>
+              elem.symbol.ccLevel <= level
         case elem: ThisType if level.isDefined =>
           elem.cls.ccLevel.nextInner <= level
         case ReachCapability(elem1) =>
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index ec134149eb49..848abb93bac4 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -122,10 +122,6 @@ object CheckCaptures:
    *  This check is performed at Typer.
    */
   def checkWellformed(parent: Tree, ann: Tree)(using Context): Unit =
-    parent.tpe match
-      case _: SingletonType =>
-        report.error(em"Singleton type $parent cannot have capture set", parent.srcPos)
-      case _ =>
     def check(elem: Tree, pos: SrcPos): Unit = elem.tpe match
       case ref: CaptureRef =>
         if !ref.isTrackableRef then
@@ -373,45 +369,54 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  the environment's owner
      */
     def markFree(cs: CaptureSet, pos: SrcPos)(using Context): Unit =
+      // A captured reference with the symbol `sym` is visible from the environment
+      // if `sym` is not defined inside the owner of the environment.
+      inline def isVisibleFromEnv(sym: Symbol, env: Env) =
+        if env.kind == EnvKind.NestedInOwner then
+          !sym.isProperlyContainedIn(env.owner)
+        else
+          !sym.isContainedIn(env.owner)
+
+      def checkSubsetEnv(cs: CaptureSet, env: Env)(using Context): Unit =
+        // Only captured references that are visible from the environment
+        // should be included.
+        val included = cs.filter: c =>
+          c.stripReach match
+            case ref: NamedType =>
+              val refSym = ref.symbol
+              val refOwner = refSym.owner
+              val isVisible = isVisibleFromEnv(refOwner, env)
+              if isVisible && !ref.isRootCapability then
+                ref match
+                  case ref: TermRef if ref.prefix `ne` NoPrefix =>
+                    // If c is a path of a class defined outside the environment,
+                    // we check the capture set of its info.
+                    checkSubsetEnv(ref.captureSetOfInfo, env)
+                  case _ =>
+              if !isVisible
+                  && (c.isReach || ref.isType)
+                  && (!ccConfig.useSealed || refSym.is(Param))
+                  && refOwner == env.owner
+              then
+                if refSym.hasAnnotation(defn.UnboxAnnot) then
+                  capt.println(i"exempt: $ref in $refOwner")
+                else
+                  // Reach capabilities that go out of scope have to be approximated
+                  // by their underlying capture set, which cannot be universal.
+                  // Reach capabilities of @unboxed parameters are exempted.
+                  val cs = CaptureSet.ofInfo(c)
+                  cs.disallowRootCapability: () =>
+                    report.error(em"Local reach capability $c leaks into capture scope of ${env.ownerString}", pos)
+                  checkSubset(cs, env.captured, pos, provenance(env))
+              isVisible
+            case ref: ThisType => isVisibleFromEnv(ref.cls, env)
+            case _ => false
+        checkSubset(included, env.captured, pos, provenance(env))
+        capt.println(i"Include call or box capture $included from $cs in ${env.owner} --> ${env.captured}")
+
       if !cs.isAlwaysEmpty then
         forallOuterEnvsUpTo(ctx.owner.topLevelClass): env =>
-          // Whether a symbol is defined inside the owner of the environment?
-          inline def isContainedInEnv(sym: Symbol) =
-            if env.kind == EnvKind.NestedInOwner then
-              sym.isProperlyContainedIn(env.owner)
-            else
-              sym.isContainedIn(env.owner)
-          // A captured reference with the symbol `sym` is visible from the environment
-          // if `sym` is not defined inside the owner of the environment
-          inline def isVisibleFromEnv(sym: Symbol) = !isContainedInEnv(sym)
-          // Only captured references that are visible from the environment
-          // should be included.
-          val included = cs.filter: c =>
-            c.stripReach match
-              case ref: NamedType =>
-                val refSym = ref.symbol
-                val refOwner = refSym.owner
-                val isVisible = isVisibleFromEnv(refOwner)
-                if !isVisible
-                    && (c.isReach || ref.isType)
-                    && (!ccConfig.useSealed || refSym.is(Param))
-                    && refOwner == env.owner
-                then
-                  if refSym.hasAnnotation(defn.UnboxAnnot) then
-                    capt.println(i"exempt: $ref in $refOwner")
-                  else
-                    // Reach capabilities that go out of scope have to be approximated
-                    // by their underlying capture set, which cannot be universal.
-                    // Reach capabilities of @unboxed parameters are exempted.
-                    val cs = CaptureSet.ofInfo(c)
-                    cs.disallowRootCapability: () =>
-                      report.error(em"Local reach capability $c leaks into capture scope of ${env.ownerString}", pos)
-                    checkSubset(cs, env.captured, pos, provenance(env))
-                isVisible
-              case ref: ThisType => isVisibleFromEnv(ref.cls)
-              case _ => false
-          checkSubset(included, env.captured, pos, provenance(env))
-          capt.println(i"Include call or box capture $included from $cs in ${env.owner} --> ${env.captured}")
+          checkSubsetEnv(cs, env)
     end markFree
 
     /** Include references captured by the called method in the current environment stack */
@@ -488,21 +493,28 @@ class CheckCaptures extends Recheck, SymTransformer:
         case _ => denot
 
       val selType = recheckSelection(tree, qualType, name, disambiguate)
-      val selCs = selType.widen.captureSet
-      if selCs.isAlwaysEmpty
-          || selType.widen.isBoxedCapturing
+      val selWiden = selType.widen
+      def isStableSel = selType match
+        case selType: NamedType => selType.symbol.isStableMember
+        case _ => false
+        
+      if pt == LhsProto
           || qualType.isBoxedCapturing
-          || pt == LhsProto
+          || selType.isTrackableRef
+          || selWiden.isBoxedCapturing
+          || selWiden.captureSet.isAlwaysEmpty
       then
         selType
       else
         val qualCs = qualType.captureSet
-        capt.println(i"pick one of $qualType, ${selType.widen}, $qualCs, $selCs in $tree")
+        val selCs = selType.captureSet
+        capt.println(i"pick one of $qualType, ${selType.widen}, $qualCs, $selCs ${selWiden.captureSet} in $tree")
+
         if qualCs.mightSubcapture(selCs)
             && !selCs.mightSubcapture(qualCs)
             && !pt.stripCapturing.isInstanceOf[SingletonType]
         then
-          selType.widen.stripCapturing.capturing(qualCs)
+          selWiden.stripCapturing.capturing(qualCs)
             .showing(i"alternate type for select $tree: $selType --> $result, $qualCs / $selCs", capt)
         else
           selType
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 8a173faa3cec..96f09a0d6214 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1548,21 +1548,23 @@ object Parsers {
       case _ => None
     }
 
-    /** CaptureRef  ::=  ident [`*` | `^`] | `this`
+    /** CaptureRef  ::=  (ident | `this`) [`*` | `^`]
      */
     def captureRef(): Tree =
-      if in.token == THIS then simpleRef()
-      else
-        val id = termIdent()
-        if isIdent(nme.raw.STAR) then
-          in.nextToken()
-          atSpan(startOffset(id)):
-            PostfixOp(id, Ident(nme.CC_REACH))
-        else if isIdent(nme.UPARROW) then
-          in.nextToken()
-          atSpan(startOffset(id)):
-            makeCapsOf(cpy.Ident(id)(id.name.toTypeName))
-        else id
+      val ref = singleton()
+      if isIdent(nme.raw.STAR) then
+        in.nextToken()
+        atSpan(startOffset(ref)):
+          PostfixOp(ref, Ident(nme.CC_REACH))
+      else if isIdent(nme.UPARROW) then
+        in.nextToken()
+        def toTypeSel(r: Tree): Tree = r match
+          case id: Ident => cpy.Ident(id)(id.name.toTypeName)
+          case Select(qual, id) => Select(qual, id.toTypeName)
+          case _ => r
+        atSpan(startOffset(ref)):
+          makeCapsOf(toTypeSel(ref))
+      else ref
 
     /**  CaptureSet ::=  `{` CaptureRef {`,` CaptureRef} `}`    -- under captureChecking
      */
diff --git a/tests/neg-custom-args/captures/class-contra.check b/tests/neg-custom-args/captures/class-contra.check
index 9fc009ac3d48..808118bd1795 100644
--- a/tests/neg-custom-args/captures/class-contra.check
+++ b/tests/neg-custom-args/captures/class-contra.check
@@ -1,10 +1,7 @@
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/class-contra.scala:12:39 ---------------------------------
-12 |  def fun(x: K{val f: T^{a}}) = x.setf(a) // error
-   |                                       ^
-   |   Found:    (a : T^{x, y})
-   |   Required: T^{}
-   |
-   |   Note that a capability (K.this.f : T^) in a capture set appearing in contravariant position
-   |   was mapped to (x.f : T^{a}) which is not a capability. Therefore, it was under-approximated to the empty set.
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/class-contra.scala:12:40 ---------------------------------
+12 |  def fun1(k: K{val f: T^{a}}) = k.setf(a) // error
+   |                                        ^
+   |                                        Found:    (a : T^{x, y})
+   |                                        Required: T^{k.f}
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/class-contra.scala b/tests/neg-custom-args/captures/class-contra.scala
index 210fd4e331f1..8ef8e7485a18 100644
--- a/tests/neg-custom-args/captures/class-contra.scala
+++ b/tests/neg-custom-args/captures/class-contra.scala
@@ -9,5 +9,6 @@ class T
 
 def test(x: Cap, y: Cap) =
   val a: T^{x, y} = ???
-  def fun(x: K{val f: T^{a}}) = x.setf(a) // error
+  def fun1(k: K{val f: T^{a}}) = k.setf(a) // error
+  def fun2(k: K{val f: a.type}) = k.setf(a)
   ()
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/explain-under-approx.check b/tests/neg-custom-args/captures/explain-under-approx.check
index 2d2b05b4b95a..c186fc6adb11 100644
--- a/tests/neg-custom-args/captures/explain-under-approx.check
+++ b/tests/neg-custom-args/captures/explain-under-approx.check
@@ -1,20 +1,14 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/explain-under-approx.scala:12:10 -------------------------
 12 |  col.add(Future(() => 25)) // error
    |          ^^^^^^^^^^^^^^^^
-   |       Found:    Future[Int]{val a: (async : Async^)}^{async}
-   |       Required: Future[Int]^{}
-   |
-   |       Note that a capability Collector.this.futs* in a capture set appearing in contravariant position
-   |       was mapped to col.futs* which is not a capability. Therefore, it was under-approximated to the empty set.
+   |          Found:    Future[Int]{val a: (async : Async^)}^{async}
+   |          Required: Future[Int]^{col.futs*}
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/explain-under-approx.scala:15:11 -------------------------
 15 |  col1.add(Future(() => 25)) // error
    |           ^^^^^^^^^^^^^^^^
-   |      Found:    Future[Int]{val a: (async : Async^)}^{async}
-   |      Required: Future[Int]^{}
-   |
-   |      Note that a capability Collector.this.futs* in a capture set appearing in contravariant position
-   |      was mapped to col1.futs* which is not a capability. Therefore, it was under-approximated to the empty set.
+   |           Found:    Future[Int]{val a: (async : Async^)}^{async}
+   |           Required: Future[Int]^{col1.futs*}
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/filevar-multi-ios.scala b/tests/neg-custom-args/captures/filevar-multi-ios.scala
new file mode 100644
index 000000000000..8ffc8d8e299c
--- /dev/null
+++ b/tests/neg-custom-args/captures/filevar-multi-ios.scala
@@ -0,0 +1,41 @@
+import language.experimental.modularity
+import compiletime.uninitialized
+
+class IO extends caps.Capability
+
+class File:
+  def write(x: String): Unit = ???
+
+object test1:
+
+  class Service(val io: IO, val io2: IO):
+    var file: File^{io} = uninitialized
+    var file2: File^{io2} = uninitialized
+    def log = file.write("log")
+
+  def withFile[T](io: IO)(op: File^{io} => T): T =
+    op(new File)
+
+  def test(io3: IO, io4: IO) =
+    withFile(io3): f =>
+      val o = Service(io3, io4)
+      o.file = f // error
+      o.file2 = f // error
+      o.log
+
+object test2:
+
+  class Service(tracked val io: IO, tracked val io2: IO):
+    var file: File^{io} = uninitialized
+    var file2: File^{io2} = uninitialized
+    def log = file.write("log")
+
+  def withFile[T](io: IO)(op: File^{io} => T): T =
+    op(new File)
+
+  def test(io3: IO, io4: IO) =
+    withFile(io3): f =>
+      val o = Service(io3, io4)
+      o.file = f
+      o.file2 = f // error
+      o.log
diff --git a/tests/neg-custom-args/captures/i15116.check b/tests/neg-custom-args/captures/i15116.check
index df05324866e1..0a16af9f6704 100644
--- a/tests/neg-custom-args/captures/i15116.check
+++ b/tests/neg-custom-args/captures/i15116.check
@@ -18,13 +18,17 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15116.scala:5:13 ----------------------------------------
 5 |  val x = Foo(m)   // error
   |          ^^^^^^
-  |          Found:    Foo{val m: String^{Baz.this}}^{Baz.this}
+  |          Found:    Foo{val m²: (Baz.this.m : String^)}^{Baz.this.m}
   |          Required: Foo
   |
+  |          where:    m  is a value in trait Baz
+  |                    m² is a value in class Foo
+  |
+  |
   |          Note that the expected type Foo
   |          is the previously inferred type of value x
   |          which is also the type seen in separately compiled sources.
-  |          The new inferred type Foo{val m: String^{Baz.this}}^{Baz.this}
+  |          The new inferred type Foo{val m: (Baz.this.m : String^)}^{Baz.this.m}
   |          must conform to this type.
   |
   | longer explanation available when compiling with `-explain`
@@ -48,13 +52,17 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15116.scala:9:13 ----------------------------------------
 9 |  val x = Foo(m)   // error
   |          ^^^^^^
-  |          Found:    Foo{val m: String^{Baz2.this}}^{Baz2.this}
+  |          Found:    Foo{val m²: (Baz2.this.m : String^)}^{Baz2.this.m}
   |          Required: Foo
   |
+  |          where:    m  is a value in trait Baz2
+  |                    m² is a value in class Foo
+  |
+  |
   |          Note that the expected type Foo
   |          is the previously inferred type of value x
   |          which is also the type seen in separately compiled sources.
-  |          The new inferred type Foo{val m: String^{Baz2.this}}^{Baz2.this}
+  |          The new inferred type Foo{val m: (Baz2.this.m : String^)}^{Baz2.this.m}
   |          must conform to this type.
   |
   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/path-box.scala b/tests/neg-custom-args/captures/path-box.scala
new file mode 100644
index 000000000000..3213c236aaf5
--- /dev/null
+++ b/tests/neg-custom-args/captures/path-box.scala
@@ -0,0 +1,20 @@
+class A:
+  val m: A^ = ???
+  val self: this.type = this
+
+case class Box[+T](value: T)
+
+def testBox1(a: A^): Box[A^{a}] =
+  Box(a.m)
+
+def testBox2(a: A^): Box[A^{a.m}] =
+  Box(a.m)
+
+def testBox3(a: A^): Box[A^{a.m}] =
+  Box(a) // error
+
+def testBox4(a: A^): Box[A^{a.m}] =
+  Box(a.m.m.m)
+
+def testBox5(a: A^): Box[A^{a.m}] =
+  Box(a.m.m.self)
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/path-connection.scala b/tests/neg-custom-args/captures/path-connection.scala
new file mode 100644
index 000000000000..3b3820488c8d
--- /dev/null
+++ b/tests/neg-custom-args/captures/path-connection.scala
@@ -0,0 +1,46 @@
+import language.experimental.modularity
+
+trait Reader:
+  def read(): String
+
+trait Sender:
+  def send(msg: String): Unit
+
+class Connection extends Reader, Sender:
+  def read() = "hello"
+  def send(msg: String) = ()
+
+  val readOnly: Reader^ = new Reader:
+    def read() = Connection.this.read()
+
+class ReaderProxy(tracked val r: Reader^) extends Reader:
+  def read() = "(Proxy)" + r.read()
+
+class SenderProxy(tracked val s: Sender^) extends Sender:
+  def send(msg: String) = s.send("(Proxy) " + msg)
+
+def testConnection(c: Connection^)(
+    handle1: Reader^{c.readOnly} => String,
+    handle2: Sender^{c} => Unit,
+    handle3: Reader^{c} => String,
+    ) =
+  val m1 = c.read()
+  c.send("hello")
+
+  val m2 = c.readOnly.read()
+
+  val m3a = handle1(c.readOnly)
+  val m3b = handle3(c.readOnly)
+
+  val m4a = handle1(c) // error
+  val m4b = handle3(c)
+
+  val m5a = handle1(new ReaderProxy(c.readOnly))
+  val m5b = handle3(new ReaderProxy(c.readOnly))
+
+  val m6a = handle1(new ReaderProxy(c)) // error
+  val m6b = handle3(new ReaderProxy(c))
+
+  handle2(c)
+
+  handle2(new SenderProxy(c))
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/path-illigal.scala b/tests/neg-custom-args/captures/path-illigal.scala
new file mode 100644
index 000000000000..f09db0087ef7
--- /dev/null
+++ b/tests/neg-custom-args/captures/path-illigal.scala
@@ -0,0 +1,7 @@
+class A:
+  val m: A^ = ???
+  var n: A^ = ???
+
+def test1(a: A^) =
+  val c1: A^{a.m} = a.m
+  val f1: A^{a.n} = a.n // error
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/path-simple.scala b/tests/neg-custom-args/captures/path-simple.scala
new file mode 100644
index 000000000000..93b6dacebe74
--- /dev/null
+++ b/tests/neg-custom-args/captures/path-simple.scala
@@ -0,0 +1,27 @@
+
+class A:
+  val m: A^ = ???
+  val self: this.type = this
+
+case class C(ca: A^)
+
+def test1(a: A^, b: A^) =
+  val c1: A^{a} = a.m
+  val c2: A^{a.m} = a.m
+  val c3: A^{b} = a.m // error
+
+  val d1: A^{a} = a.self
+  val d2: A^{a.self} = a.self
+  val d3: A^{a.self} = a
+
+  val e1: A^{a.m} = a.self.m
+  val e2: A^{a.self.m} = a.self.m
+  val e3: A^{a.self.m} = a.m
+
+def test2(a: A^) =
+  val b: a.type = a
+  val c1: C^{a} = new C(a)
+  val c2: C^{a} = new C(a.m)
+  val c3: C^{a.m} = new C(a.m)
+  val c4: C^{b} = new C(a)
+  val c5: C^{a} = new C(b)
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/singletons.scala b/tests/neg-custom-args/captures/singletons.scala
index 194e6e850dcd..be0ee67ab1bc 100644
--- a/tests/neg-custom-args/captures/singletons.scala
+++ b/tests/neg-custom-args/captures/singletons.scala
@@ -1,6 +1,6 @@
 val x = () => ()
 
-val y1: x.type = x          // ok
-val y2: x.type^{} = x       // error: singleton type cannot have capture set
-val y3: x.type^{x} = x      // error: singleton type cannot have capture set // error
-val y4: x.type^ = x         // error: singleton type cannot have capture set
+val y1: x.type = x
+val y2: x.type^{} = x
+val y3: x.type^{x} = x // error
+val y4: x.type^ = x
diff --git a/tests/pos-custom-args/captures/filevar-expanded.scala b/tests/pos-custom-args/captures/filevar-expanded.scala
index a883471e8d2e..58e7a0e67e0a 100644
--- a/tests/pos-custom-args/captures/filevar-expanded.scala
+++ b/tests/pos-custom-args/captures/filevar-expanded.scala
@@ -1,4 +1,5 @@
 import language.experimental.captureChecking
+import language.experimental.modularity
 import compiletime.uninitialized
 
 object test1:
@@ -22,7 +23,7 @@ object test2:
   class File:
     def write(x: String): Unit = ???
 
-  class Service(io: IO^):
+  class Service(tracked val io: IO^):
     var file: File^{io} = uninitialized
     def log = file.write("log")
 
diff --git a/tests/pos-custom-args/captures/filevar.scala b/tests/pos-custom-args/captures/filevar.scala
index 9ab34fe617b5..dc8d0b18908b 100644
--- a/tests/pos-custom-args/captures/filevar.scala
+++ b/tests/pos-custom-args/captures/filevar.scala
@@ -1,4 +1,5 @@
 import language.experimental.captureChecking
+import language.experimental.modularity
 import compiletime.uninitialized
 
 object test1:
@@ -22,7 +23,7 @@ object test2:
   class File:
     def write(x: String): Unit = ???
 
-  class Service(io: IO):
+  class Service(tracked val io: IO):
     var file: File^{io} = uninitialized
     def log = file.write("log")