Bugfix: Fix setup of overriding symbols

 - Avoid accidental addition of capture set variables through traverseChildren
   of exact ValDefs and DefDefs.
 - Don't require that overriding symbols need explicit types if their capture set
   is non-empty. This is not needed since an overriding symbol with inferred type
   will get the type of the overridden symbol.

Author: odersky

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

@@ -884,12 +884,11 @@ class CheckCaptures extends Recheck, SymTransformer:
           val isLocal =
             sym.owner.ownersIterator.exists(_.isTerm)
             || sym.accessBoundary(defn.RootClass).isContainedIn(sym.topLevelClass)
-          def canUseInferred =            // If canUseInferred is false, all capturing types in the type of `sym` need to be given explicitly
-            sym.is(Private)                         // private symbols can always have inferred types
-            ||                                      // non-local symbols cannot have inferred types since external capture types are not inferred
-              isLocal                               // local symbols still need an explicit types if
-              && !sym.owner.is(Trait)               //   - they are defined in a trait, since we do OverridingPairs checking before capture inference
-              && !sym.allOverriddenSymbols.nonEmpty //   - they override some other symbol, since we do override checking before capture inference
+          def canUseInferred =        // If canUseInferred is false, all capturing types in the type of `sym` need to be given explicitly
+            sym.is(Private)           // private symbols can always have inferred types
+            ||                        // non-local symbols cannot have inferred types since external capture types are not inferred
+              isLocal                 // local symbols still need explicit types if
+              && !sym.owner.is(Trait) // they are defined in a trait, since we do OverridingPairs checking before capture inference
           def isNotPureThis(ref: CaptureRef) = ref match {
             case ref: ThisType => !ref.cls.isPureClass
             case _ => true

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

@@ -385,20 +385,18 @@ extends tpd.TreeTraverser:
           return
         tree.tpt match
           case tpt: TypeTree if tree.symbol.allOverriddenSymbols.hasNext =>
+            tree.paramss.foreach(traverse)
             transformTT(tpt, boxed = false, exact = true)
+            traverse(tree.rhs)
             //println(i"TYPE of ${tree.symbol.showLocated} = ${tpt.knownType}")
           case _ =>
-        traverseChildren(tree)
+            traverseChildren(tree)
       case tree @ ValDef(_, tpt: TypeTree, _) =>
-        val isVar = tree.symbol.is(Mutable)
-        val overrides = tree.symbol.allOverriddenSymbols.hasNext
-        //if overrides then println(i"transforming overriding ${tree.symbol}")
-        if isVar || overrides then
-          transformTT(tpt,
-              boxed = isVar,    // types of mutable variables are boxed
-              exact = overrides // types of symbols that override a parent don't get a capture set
-            )
-        traverseChildren(tree)
+        transformTT(tpt,
+          boxed = tree.symbol.is(Mutable),    // types of mutable variables are boxed
+          exact = tree.symbol.allOverriddenSymbols.hasNext // types of symbols that override a parent don't get a capture set
+        )
+        traverse(tree.rhs)
       case tree @ TypeApply(fn, args) =>
         traverse(fn)
         for case arg: TypeTree <- args do

tests/neg-custom-args/captures/lazylist.check

@@ -5,6 +5,13 @@
    |        method tail of type -> {*} lazylists.LazyList[Nothing] has incompatible type
    |
    | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylist.scala:17:15 -------------------------------------
+17 |  def tail = xs() // error
+   |             ^^^^
+   |             Found:    {LazyCons.this.xs} lazylists.LazyList[T]
+   |             Required: lazylists.LazyList[T]
+   |
+   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylist.scala:35:29 -------------------------------------
 35 |  val ref1c: LazyList[Int] = ref1 // error
    |                             ^^^^
@@ -33,10 +40,3 @@
    |                                             Required: {cap1, ref3, cap3} lazylists.LazyList[Int]
    |
    | longer explanation available when compiling with `-explain`
--- Error: tests/neg-custom-args/captures/lazylist.scala:17:6 -----------------------------------------------------------
-17 |  def tail = xs() // error: cannot have an inferred type
-   |  ^^^^^^^^^^^^^^^
-   |  Non-local method tail cannot have an inferred result type
-   |  {LazyCons.this.xs} lazylists.LazyList[? T]
-   |  with non-empty capture set {LazyCons.this.xs}.
-   |  The type needs to be declared explicitly.

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

@@ -14,7 +14,7 @@ abstract class LazyList[+T]:
 class LazyCons[+T](val x: T, val xs: () => {*} LazyList[T]) extends LazyList[T]:
   def isEmpty = false
   def head = x
-  def tail = xs() // error: cannot have an inferred type
+  def tail = xs() // error
 
 object LazyNil extends LazyList[Nothing]:
   def isEmpty = true