Fixes and well-formedness check for capture-dependent types

Author: odersky

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -3661,7 +3661,8 @@ object Types {
     /** Does result type contain references to parameters of this method type,
      *  which cannot be eliminated by de-aliasing?
      */
-    def isResultDependent(using Context): Boolean = dependencyStatus == TrueDeps
+    def isResultDependent(using Context): Boolean =
+      dependencyStatus == TrueDeps || dependencyStatus == CaptureDeps
 
     /** Does one of the parameter types contain references to earlier parameters
      *  of this method type which cannot be eliminated by de-aliasing?
@@ -3671,13 +3672,13 @@ object Types {
     /** Is there either a true or false type dependency, or does the result
      *  type capture a parameter?
      */
-    def isCaptureDependent(using Context) = dependencyStatus >= CaptureDeps
+    def isCaptureDependent(using Context) = dependencyStatus == CaptureDeps
 
     def newParamRef(n: Int): TermParamRef = new TermParamRefImpl(this, n)
 
     /** The least supertype of `resultType` that does not contain parameter dependencies */
     def nonDependentResultApprox(using Context): Type =
-      if (isResultDependent) {
+      if isResultDependent then
         val dropDependencies = new ApproximatingTypeMap {
           def apply(tp: Type) = tp match {
             case tp @ TermParamRef(thisLambdaType, _) =>
@@ -3686,7 +3687,6 @@ object Types {
           }
         }
         dropDependencies(resultType)
-      }
       else resultType
   }
 
@@ -4054,8 +4054,8 @@ object Types {
     type DependencyStatus = Byte
     final val Unknown: DependencyStatus = 0   // not yet computed
     final val NoDeps: DependencyStatus = 1    // no dependent parameters found
-    final val CaptureDeps: DependencyStatus = 2
-    final val FalseDeps: DependencyStatus = 3 // all dependent parameters are prefixes of non-depended alias types
+    final val FalseDeps: DependencyStatus = 2 // all dependent parameters are prefixes of non-depended alias types
+    final val CaptureDeps: DependencyStatus = 3
     final val TrueDeps: DependencyStatus = 4  // some truly dependent parameters exist
     final val StatusMask: DependencyStatus = 7 // the bits indicating actual dependency status
     final val Provisional: DependencyStatus = 8  // set if dependency status can still change due to type variable instantiations

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

@@ -18,7 +18,7 @@ import Trees._
 import scala.util.control.NonFatal
 import typer.ErrorReporting._
 import util.Spans.Span
-import util.SimpleIdentitySet
+import util.{SimpleIdentitySet, SrcPos}
 import util.Chars.*
 import Nullables._
 import transform.*
@@ -96,6 +96,24 @@ class CheckCaptures extends RefineTypes:
 
   inline val disallowGlobal = true
 
+  def checkWellFormed(whole: Type, pos: SrcPos)(using Context): Unit =
+    def checkRelativeVariance(mt: MethodType) = new TypeTraverser:
+      def traverse(tp: Type): Unit = tp match
+        case CapturingType(parent, ref @ TermParamRef(`mt`, _)) =>
+          if variance <= 0 then
+            val direction = if variance < 0 then "contra" else "in"
+            report.error(em"captured reference $ref appears ${direction}variantly in type $whole", pos)
+          traverse(parent)
+        case _ =>
+          traverseChildren(tp)
+    val checkVariance = new TypeTraverser:
+      def traverse(tp: Type): Unit = tp match
+        case mt: MethodType if mt.isResultDependent =>
+          checkRelativeVariance(mt).traverse(mt)
+        case _ =>
+          traverseChildren(tp)
+    checkVariance.traverse(whole)
+
   object PostRefinerCheck extends TreeTraverser:
     def traverse(tree: Tree)(using Context) =
       tree match
@@ -116,6 +134,10 @@ class CheckCaptures extends RefineTypes:
                        |The inferred arguments are: [$args%, %]"""
                   case _ => s"type argument$notAllowed"
                 report.error(msg, arg.srcPos)
+        case tree: TypeTree =>
+          // it's inferred, no need to check
+        case tree: TypTree =>
+          checkWellFormed(tree.tpe, tree.srcPos)
         case _ =>
       traverseChildren(tree)
 

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

@@ -311,10 +311,10 @@ trait TypeAssigner {
     val ownType = fn.tpe.widen match {
       case fntpe: MethodType =>
         if (sameLength(fntpe.paramInfos, args) || ctx.phase.prev.relaxedTyping)
-          if fntpe.isResultDependent then
-            safeSubstParams(fntpe.resultType, fntpe.paramRefs, args.tpes)
-          else if fntpe.isCaptureDependent then
+          if fntpe.isCaptureDependent then
             fntpe.resultType.substParams(fntpe, args.tpes)
+          else if fntpe.isResultDependent then
+            safeSubstParams(fntpe.resultType, fntpe.paramRefs, args.tpes)
           else
             fntpe.resultType
         else

tests/neg-custom-args/captures/capt-wf.scala

@@ -0,0 +1,7 @@
+class C
+type Cap = C retains *
+type Top = Any retains *
+
+type T = (x: Cap) => List[String retains x.type] => Unit // error
+val x: (x: Cap) => Array[String retains x.type] = ??? // error
+val y = x

tests/pos-special/captures/capt-depfun.scala

@@ -0,0 +1,11 @@
+class C
+type Cap = C retains *
+type Top = Any retains *
+
+type T = (x: Cap) => String retains x.type
+
+def f(y: Cap): String retains * =
+  val a: T = (x: Cap) => ""
+  val b = a(y)
+  val c: String retains y.type = b
+  c