Simplifications

 - Drop valsCanBeLevelOwners and levelOwnersNeedCapParam config settings
 - Drop !isCaseClassSynthetic condition in isLevelOwner
 - Drop handling of anonymous functions in levelOwnerNamed

Neither are needed anymore with the the conflg flags gone.

Author: odersky

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

@@ -28,15 +28,7 @@ private val adaptUnpickledFunctionTypes = false
  */
 private val constrainRootsWhenMapping = true
 
-/** If true, most vals can be level owners. If false, only vals defined by a
- *  closure as RHS can be level owners
- */
-private val valsCanBeLevelOwners = true
-
-/** If true, only vals, defs, and classes with a universal capability in a parameter
- *  or self type are considered as level owners.
- */
-private val levelOwnersNeedCapParam = true
+private val constructorsAreLevelOwners = false
 
 def allowUniversalInBoxed(using Context) =
   Feature.sourceVersion.isAtLeast(SourceVersion.`3.3`)
@@ -390,25 +382,21 @@ extension (sym: Symbol)
     def isCaseClassSynthetic = // TODO drop
       symd.maybeOwner.isClass && symd.owner.is(Case) && symd.is(Synthetic) && symd.info.firstParamNames.isEmpty
     def classQualifies =
-      !levelOwnersNeedCapParam
-      || takesCappedParamIn(symd.primaryConstructor.info)
+      takesCappedParamIn(symd.primaryConstructor.info)
       || symd.asClass.givenSelfType.hasUniversalRootOf(sym)
-    def termQualifies =
-      !levelOwnersNeedCapParam || takesCappedParamIn(symd.info)
     def compute =
       if symd.isClass then
         symd.is(CaptureChecked) && classQualifies || symd.isRoot
       else
         (symd.is(Method, butNot = Accessor)
-          || valsCanBeLevelOwners && symd.isTerm && !symd.isOneOf(TermParamOrAccessor | Mutable))
+          || symd.isTerm && !symd.isOneOf(TermParamOrAccessor | Mutable))
         && (!symd.owner.isClass
             || symd.owner.is(CaptureChecked)
             || Synthetics.needsTransform(symd)
             )
-        && !isCaseClassSynthetic
         && !symd.isConstructor
         && (!symd.isAnonymousFunction || sym.definedLocalRoot.exists)
-        && termQualifies
+        && takesCappedParamIn(symd.info)
         && { ccSetup.println(i"Level owner $sym"); true }
 
     ccState.isLevelOwner.getOrElseUpdate(sym, compute)
@@ -433,17 +421,13 @@ extension (sym: Symbol)
    *  owner.
    */
   def levelOwnerNamed(name: String)(using Context): Symbol =
-    def recur(sym: Symbol, prev: Symbol): Symbol =
+    def recur(sym: Symbol): Symbol =
       if sym.name.toString == name then
         if sym.isLevelOwner then sym
-        else if sym.isTerm && !sym.isOneOf(Method | Module) && prev.exists then prev
         else NoSymbol
-      else if sym == defn.RootClass then
-        NoSymbol
-      else
-        val prev1 = if sym.isAnonymousFunction && sym.isLevelOwner then sym else NoSymbol
-        recur(sym.owner, prev1)
-    recur(sym, NoSymbol)
+      else if sym == defn.RootClass then NoSymbol
+      else recur(sym.owner)
+    recur(sym)
       .showing(i"find outer $sym [ $name ] = $result", capt)
 
   /** The parameter with type caps.Cap in the leading term parameter section,

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

@@ -463,8 +463,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
               case possiblyTypedClosureDef(ddef)
               if !mentionsCap(rhsOfEtaExpansion(ddef))
                   && !sym.is(Mutable)
-                  && (!levelOwnersNeedCapParam
-                      || ddef.symbol.takesCappedParamIn(ddef.symbol.info)) =>
+                  && ddef.symbol.takesCappedParamIn(ddef.symbol.info) =>
                 ccSetup.println(i"Level owner at setup $sym / ${ddef.symbol.info}")
                 ccState.isLevelOwner(sym) = true
               case _ =>
@@ -571,6 +570,8 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
                 // closures are handled specially; the newInfo is constrained from
                 // the expected type and only afterwards we recheck the definition
                 newInfo
+              else if sym.isPrimaryConstructor then
+                newInfo
               else new LazyType:
                 def complete(denot: SymDenotation)(using Context) =
                   // infos of other methods are determined from their definitions which

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

@@ -157,12 +157,12 @@ object Synthetics:
       case DefaultGetterName(nme.copy, n) =>
         transformDefaultGetterCaptures(info, symd.owner, n)
       case nme.unapply =>
-        if levelOwnersNeedCapParam then ccState.isLevelOwner(symd.symbol) = true
+        ccState.isLevelOwner(symd.symbol) = true
         transformUnapplyCaptures(info)
       case nme.apply | nme.copy =>
         addCaptureDeps(info)
       case nme.andThen | nme.compose =>
-        if levelOwnersNeedCapParam then ccState.isLevelOwner(symd.symbol) = true
+        ccState.isLevelOwner(symd.symbol) = true
         transformComposeCaptures(info, symd.owner)
       case nme.curried | nme.tupled =>
         transformCurriedTupledCaptures(info, symd.owner)

tests/pos-custom-args/captures/concat-iterator.scala

@@ -0,0 +1,17 @@
+package test
+
+trait IOnce[A]:
+  self: I[A]^ =>
+
+trait I[+A]:
+  self: I[A]^ =>
+
+  def concat[B >: A](xs: => IOnce[B]^): I[B]^{this, xs} = new I.ConcatI[B](self).concat(xs)
+
+object I:
+  private final class ConcatI[+A](val from: I[A]^) extends I[A]:
+    override def concat[B >: A](that: => IOnce[B]^): I[B]^{this, that} = ???
+
+
+
+