Check overrides and disallow non-local inferred capture types

Author: odersky

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

@@ -15,6 +15,7 @@ import NameKinds.{DocArtifactName, OuterSelectName, DefaultGetterName}
 import Trees._
 import scala.util.control.NonFatal
 import typer.ErrorReporting._
+import typer.RefChecks
 import util.Spans.Span
 import util.{SimpleIdentitySet, EqHashMap, SrcPos}
 import util.Chars.*
@@ -96,6 +97,21 @@ class CheckCaptures extends Recheck:
 
   def newRechecker()(using Context) = CaptureChecker(ctx)
 
+  override def run(using Context): Unit =
+    checkOverrides.traverse(ctx.compilationUnit.tpdTree)
+    super.run
+
+  def checkOverrides = new TreeTraverser:
+    def traverse(t: Tree)(using Context) =
+      t match
+        case t: Template =>
+          // ^^^ TODO: Can we avoid doing overrides checks twice?
+          // We need to do them here since only at this phase CaptureTypes are relevant
+          // But maybe we can then elide the check during the RefChecks phase if -Ycc is set?
+          RefChecks.checkAllOverrides(ctx.owner.asClass)
+        case _ =>
+      traverseChildren(t)
+
   class CaptureChecker(ictx: Context) extends Rechecker(ictx):
     import ast.tpd.*
 
@@ -404,6 +420,28 @@ class CheckCaptures extends Recheck:
             for arg <- args do
               //println(i"checking $arg in $tree: ${knownType(tree).captureSet}")
               checkNotGlobal(arg, args*)
+          case t: ValOrDefDef if t.tpt.isInstanceOf[InferredTypeTree] =>
+            val sym = t.symbol
+            val isLocal =
+              sym.ownersIterator.exists(_.isTerm)
+              || sym.accessBoundary(defn.RootClass).isContainedIn(sym.topLevelClass)
+
+            // The following classes of definitions need explicit capture types ...
+            if !isLocal                            // ... since external capture types are not inferred
+              || sym.owner.is(Trait)               // ... since we do OverridingPairs checking before capture inference
+              || sym.allOverriddenSymbols.nonEmpty // ... since we do override checking before capture inference
+            then
+              val inferred = knownType(t.tpt)
+              def checkPure(tp: Type) = tp match
+                case CapturingType(_, refs, _) if !refs.elems.isEmpty =>
+                  val resultStr = if t.isInstanceOf[DefDef] then " result" else ""
+                  report.error(
+                    em"""Non-local $sym cannot have an inferred$resultStr type
+                        |$inferred
+                        |with non-empty capture set $refs.
+                        |The type needs to be declared explicitly.""", t.srcPos)
+                case _ =>
+              inferred.foreachPart(checkPure, StopAt.Static)
           case _ =>
         traverseChildren(tree)
 

compiler/src/dotty/tools/dotc/typer/RefChecks.scala

@@ -224,7 +224,7 @@ object RefChecks {
    *  TODO This still needs to be cleaned up; the current version is a straight port of what was there
    *       before, but it looks too complicated and method bodies are far too large.
    */
-  private def checkAllOverrides(clazz: ClassSymbol)(using Context): Unit = {
+  def checkAllOverrides(clazz: ClassSymbol)(using Context): Unit = {
     val self = clazz.thisType
     val upwardsSelf = upwardsThisType(clazz)
     var hasErrors = false

tests/pos-custom-args/captures/lazylist.scala renamed to tests/disabled/pos/lazylist.scala

@@ -11,15 +11,25 @@ abstract class LazyList[+T]:
     if isEmpty then LazyNil
     else LazyCons(f(head), () => tail.map(f))
 
+  def concat[U >: T](that: {*} LazyList[U]): {this, that} LazyList[U]
+
+//  def flatMap[U](f: {*} T => LazyList[U]): {f, this} LazyList[U]
+
 class LazyCons[+T](val x: T, val xs: {*} () => {*} LazyList[T]) extends LazyList[T]:
   def isEmpty = false
   def head = x
-  def tail = xs()
+  def tail: {*} LazyList[T] = xs()
+  def concat[U >: T](that: {*} LazyList[U]): {this, that} LazyList[U] =
+    LazyCons(x, () => xs().concat(that))
+//  def flatMap[U](f: {*} T => LazyList[U]): {f, this} LazyList[U] =
+//    f(x).concat(xs().flatMap(f))
 
 object LazyNil extends LazyList[Nothing]:
   def isEmpty = true
   def head = ???
   def tail = ???
+  def concat[U](that: {*} LazyList[U]): {that} LazyList[U] = that
+//  def flatMap[U](f: {*} Nothing => LazyList[U]): LazyList[U] = LazyNil
 
 def map[A, B](xs: {*} LazyList[A], f: {*} A => B): {f, xs} LazyList[B] =
   xs.map(f)

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

@@ -1,3 +1,10 @@
+-- [E163] Declaration Error: tests/neg-custom-args/captures/lazylist.scala:22:6 ----------------------------------------
+22 |  def tail: {*} LazyList[Nothing] = ???  // error overriding
+   |      ^
+   |      error overriding method tail in class LazyList of type => lazylists.LazyList[Nothing];
+   |        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:35:29 -------------------------------------
 35 |  val ref1c: LazyList[Int] = ref1 // error
    |                             ^^^^
@@ -26,3 +33,10 @@ longer explanation available when compiling with `-explain`
    |                                             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
+   |  {*} lazylists.LazyList[T]
+   |  with non-empty capture set {*}.
+   |  The type needs to be declared explicitly.

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

@@ -14,12 +14,12 @@ 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()
+  def tail = xs() // error: cannot have an inferred type
 
 object LazyNil extends LazyList[Nothing]:
   def isEmpty = true
   def head = ???
-  def tail = ???
+  def tail: {*} LazyList[Nothing] = ???  // error overriding
 
 def map[A, B](xs: {*} LazyList[A], f: {*} A => B): {f, xs} LazyList[B] =
   xs.map(f)