Drop special code paths for objects

Treat objects like normal lazy vals when it comes to computing and checking their types.
Previously, the type of an object was its self type, but that is problematic since self types
get interpolated upwards.

By dropping the special code paths we make sure that objects are treated like other vals
that are initialized with new.

Author: odersky

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

@@ -543,6 +543,9 @@ object Capabilities:
           case prefix: Capability => prefix.computeOwner(mapUnscoped)
           case NoPrefix if mapUnscoped && classifier.derivesFrom(defn.Caps_Unscoped) =>
             ctx.owner.topLevelClass
+              .orElse: // fallback needed if ctx.owner is a toplevel module val
+                assert(ctx.owner.is(ModuleVal))
+                ctx.owner
           case _ => setOwner
       case _ /* : GlobalCap | ResultCap | ParamRef */ => NoSymbol
 

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

@@ -1018,9 +1018,9 @@ object CaptureSet:
           && !elems.contains(elem)
           && !owner.isAnonymousFunction =>
         def fail = i"attempting to add $elem to $this"
-        def hideIn(fc: FreshCap): Unit =
+        def hideIn(fc: FreshCap): Boolean =
           assert(elem.tryClassifyAs(fc.hiddenSet.classifier), fail)
-          if !isRefining then
+          if isRefining then
             // If a variable is added by addCaptureRefinements in a synthetic
             // refinement of a class type, don't do level checking. The problem is
             // that the variable might be matched against a type that does not have
@@ -1030,14 +1030,16 @@ object CaptureSet:
             // TODO: We should instead mark the variable as impossible to instantiate
             // and drop the refinement later in the inferred type.
             // Test case is drop-refinement.scala.
-            assert(fc.acceptsLevelOf(elem),
-              i"level failure, cannot add $elem with ${elem.levelOwner} to $owner / $getClass / $fail")
-          fc.hiddenSet.add(elem)
+            true
+          else if fc.acceptsLevelOf(elem) then
+            fc.hiddenSet.add(elem)
+            true
+          else
+            capt.println(i"level failure when subsuming fresh caps, cannot add $elem with ${elem.levelOwner} to $owner / $fail")
+            false
         val isSubsumed = (false /: elems): (isSubsumed, prev) =>
           prev match
-            case prev: FreshCap =>
-              hideIn(prev)
-              true
+            case prev: FreshCap => hideIn(prev)
             case _ => isSubsumed
         if !isSubsumed then
           if elem.origin != Origin.InDecl(owner) || elem.hiddenSet.isConst then

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

@@ -1213,43 +1213,41 @@ class CheckCaptures extends Recheck, SymTransformer:
       val savedEnv = curEnv
       val runInConstructor = !sym.isOneOf(Param | ParamAccessor | Lazy | NonMember)
       try
-        if sym.is(Module) then sym.info // Modules are checked by checking the module class
-        else
-          if sym.is(Mutable) then
-            if !sym.hasAnnotation(defn.UncheckedCapturesAnnot) then
-              val addendum = setup.capturedBy.get(sym) match
-                case Some(encl) =>
-                  val enclStr =
-                    if encl.isAnonymousFunction then
-                      val location = setup.anonFunCallee.get(encl) match
-                        case Some(meth) if meth.exists => i" argument in a call to $meth"
-                        case _ => ""
-                      s"an anonymous function$location"
-                    else encl.show
-                  i"\n\nNote that $sym does not count as local since it is captured by $enclStr"
-                case _ =>
-                  ""
-              disallowBadRootsIn(
-                tree.tpt.nuType, NoSymbol, i"Mutable $sym", "have type", addendum, sym.srcPos)
-            if ccConfig.strictMutability
-                && sym.owner.isClass
-                && !sym.owner.derivesFrom(defn.Caps_Stateful)
-                && !sym.hasAnnotation(defn.UntrackedCapturesAnnot) then
-              report.error(
-                em"""Mutable $sym is defined in a class that does not extend `Stateful`.
-                    |The variable needs to be annotated with `untrackedCaptures` to allow this.""",
-                tree.namePos)
-
-          // Lazy vals need their own environment to track captures from their RHS,
-          // similar to how methods work
-          if sym.is(Lazy) then
-            val localSet = capturedVars(sym)
-            if localSet ne CaptureSet.empty then
-              curEnv = Env(sym, EnvKind.Regular, localSet, curEnv, nestedClosure = NoSymbol)
-          else if runInConstructor then
-            pushConstructorEnv()
-
-          checkInferredResult(super.recheckValDef(tree, sym), tree)
+        if sym.is(Mutable) then
+          if !sym.hasAnnotation(defn.UncheckedCapturesAnnot) then
+            val addendum = setup.capturedBy.get(sym) match
+              case Some(encl) =>
+                val enclStr =
+                  if encl.isAnonymousFunction then
+                    val location = setup.anonFunCallee.get(encl) match
+                      case Some(meth) if meth.exists => i" argument in a call to $meth"
+                      case _ => ""
+                    s"an anonymous function$location"
+                  else encl.show
+                i"\n\nNote that $sym does not count as local since it is captured by $enclStr"
+              case _ =>
+                ""
+            disallowBadRootsIn(
+              tree.tpt.nuType, NoSymbol, i"Mutable $sym", "have type", addendum, sym.srcPos)
+          if ccConfig.strictMutability
+              && sym.owner.isClass
+              && !sym.owner.derivesFrom(defn.Caps_Stateful)
+              && !sym.hasAnnotation(defn.UntrackedCapturesAnnot) then
+            report.error(
+              em"""Mutable $sym is defined in a class that does not extend `Stateful`.
+                  |The variable needs to be annotated with `untrackedCaptures` to allow this.""",
+              tree.namePos)
+
+        // Lazy vals need their own environment to track captures from their RHS,
+        // similar to how methods work
+        if sym.is(Lazy) then
+          val localSet = capturedVars(sym)
+          if localSet ne CaptureSet.empty then
+            curEnv = Env(sym, EnvKind.Regular, localSet, curEnv, nestedClosure = NoSymbol)
+        else if runInConstructor then
+          pushConstructorEnv()
+
+        checkInferredResult(super.recheckValDef(tree, sym), tree)
       finally
         if !sym.is(Param) then
           // Parameters with inferred types belong to anonymous methods. We need to wait
@@ -1264,7 +1262,13 @@ class CheckCaptures extends Recheck, SymTransformer:
         if runInConstructor && savedEnv.owner.isClass then
           markFree(declaredCaptures, tree, addUseInfo = false)
 
-        if sym.owner.isStaticOwner && !declaredCaptures.elems.isEmpty && sym != defn.captureRoot then
+        if sym.owner.isStaticOwner
+            && !declaredCaptures.elems.isEmpty
+            && sym != defn.captureRoot
+            && !(sym.is(ModuleVal) && sym.owner.is(Package))
+                 // global modules that don't derive from capability can have captures
+                 // only if their fields have them, and then the field was already reported.
+        then
           def where =
             if sym.effectiveOwner.is(Package) then "top-level definition"
             else i"member of static ${sym.owner}"

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

@@ -515,7 +515,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     private def transformTT(tree: TypeTree, sym: Symbol, boxed: Boolean)(using Context): Unit =
       if !tree.hasNuType then
         var transformed =
-          if tree.isInferred
+          if tree.isInferred || sym.is(ModuleVal)
           then transformInferredType(tree.tpe)
           else transformExplicitType(tree.tpe, sym, tptToCheck = tree)
         if boxed then transformed = transformed.boxDeeply
@@ -756,18 +756,6 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           updateInfo(cls, newInfo, cls.owner)
           capt.println(i"update class info of $cls with parents $ps selfinfo $selfInfo to $newInfo")
           cls.thisType.asInstanceOf[ThisType].invalidateCaches()
-          if cls.is(ModuleClass) then
-            // if it's a module, the capture set of the module reference is the capture set of the self type
-            val modul = cls.sourceModule
-            val selfCaptures = selfInfo1 match
-              case CapturingType(_, refs) => refs
-              case _ => CaptureSet.empty
-            // Note: Can't do val selfCaptures = selfInfo1.captureSet here.
-            // This would potentially give stackoverflows when setup is run repeatedly.
-            // One test case is pos-custom-args/captures/checkbounds.scala under
-            // ccConfig.alwaysRepeatRun = true.
-            updateInfo(modul, CapturingType(modul.info, selfCaptures), modul.owner)
-            modul.termRef.invalidateCaches()
       case _ =>
     end postProcess
 

library/src/scala/collection/Map.scala

@@ -445,7 +445,7 @@ object MapOps {
 @SerialVersionUID(3L)
 object Map extends MapFactory.Delegate[Map](immutable.Map) {
   private val DefaultSentinel: AnyRef = new AnyRef
-  private val DefaultSentinelFn: () => AnyRef = () => DefaultSentinel
+  private val DefaultSentinelFn: () -> AnyRef = () => DefaultSentinel
 }
 
 /** Explicit instantiation of the `Map` trait to reduce class file size in subclasses. */

tests/neg-custom-args/captures/class-uses.check

@@ -1,9 +1,3 @@
--- Warning: tests/neg-custom-args/captures/class-uses.scala:7:0 --------------------------------------------------------
-7 |object Console extends SharedCapability:
-  |^
-  |object Console has a non-empty capture set but will not be added as
-  |a capability to computed capture sets since it is globally accessible
-  |as a top-level definition. Global values cannot be capabilities.
 -- Error: tests/neg-custom-args/captures/class-uses.scala:17:22 --------------------------------------------------------
 17 |      Console.println(g.toString) // error
    |                      ^

tests/neg-custom-args/captures/object-uses.check

@@ -0,0 +1,14 @@
+-- Error: tests/neg-custom-args/captures/object-uses.scala:12:22 -------------------------------------------------------
+12 |      Console.println(g.toString) // error
+   |                      ^
+   |                      reference (A.this.g : test.File^) is not included in the allowed capture set {A.this.f}
+   |                      of the enclosing object B in class A
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/object-uses.scala:15:18 ----------------------------------
+15 |  val _: Object = b // error
+   |                  ^
+   |                  Found:    (A.this.b : A.this.B.type)
+   |                  Required: Object
+   |
+   |                  Note that capability A.this.f is not included in capture set {}.
+   |
+   | longer explanation available when compiling with `-explain`

tests/neg-custom-args/captures/object-uses.scala

@@ -0,0 +1,17 @@
+package test
+
+class File
+
+class A {
+  val f: File^ = File()
+  val g: File^ = File()
+
+  object B uses f:
+    def show =
+      Console.println(f.toString)
+      Console.println(g.toString) // error
+
+  val b = B
+  val _: Object = b // error
+
+}