Refine test of vals with inferred types contributing fresh

Author: odersky

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

@@ -1239,10 +1239,9 @@ class CheckCaptures extends Recheck, SymTransformer:
           |must conform to this type."""
 
       tree.tpt match
-        case tpt: InferredTypeTree if !isExemptFromChecks =>
-          if !sym.isLocalToCompilationUnit
-             // Symbols that can't be seen outside the compilation unit can have inferred types
-             // except for the else clause below.
+        case tpt: InferredTypeTree =>
+          if !sym.isLocalToCompilationUnit && !isExemptFromChecks
+            // Symbols that can't be seen outside the compilation unit can have inferred types
           then
             val expected = tpt.tpe.dropAllRetains
             todoAtPostCheck += { () =>
@@ -1251,18 +1250,19 @@ class CheckCaptures extends Recheck, SymTransformer:
                 // The check that inferred <: expected is done after recheck so that it
                 // does not interfere with normal rechecking by constraining capture set variables.
             }
-          else if sym.is(Private)
-              && !sym.isLocalToCompilationUnitIgnoringPrivate
-              && tree.tpt.nuType.spanCaptureSet.containsTerminalCapability
+          if !sym.isLocalToCompilationUnitIgnoringPrivate
               && contributesFreshToClass(sym)
               // Private symbols capturing a root capability need explicit types
               // so that we can compute field constributions to class instance
               // capture sets across compilation units.
           then
-            report.error(
-              em"""$sym needs an explicit type because it captures a root capability in its type ${tree.tpt.nuType}.
-                  |Fields of publicily accessible classes that capture a root capability need to be given an explicit type.""",
-            tpt.srcPos)
+            todoAtPostCheck += { () =>
+              if sym.info.spanCaptureSet.containsTerminalCapability then
+                report.error(
+                  em"""$sym needs an explicit type because it captures a root capability in its type ${tree.tpt.nuType}.
+                      |Fields of publicily accessible classes that capture a root capability need to be given an explicit type.""",
+                tpt.srcPos)
+            }
         case _ =>
       tp
     end checkInferredResult

tests/neg-custom-args/captures/i24335.scala

@@ -6,4 +6,13 @@ class C(val io: IO):
   val l1 = () => c.io.write()
   val _: () -> Unit = l1 // error
 
+class Ref extends caps.Mutable:
+  var x: Int = 0
+
+class D:
+  val r = Ref() // error
+
+def test =
+  val d = D()
+  val _: D^{} = d