Make magic imply capture checking

Comes with the following bug fixes:

 1. Maybe arguments should not be boxed.
 2. Capture sets of module vals need to be interpolated
 3. When reporting overriding errors under -explain, use isSubTypeWhenFrozen
 4. Interpolate self types of modules downwards
 5. Make Tuple a Pure trait (fails i13968-maybe.scala otherwise)

Author: odersky

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

@@ -1535,9 +1535,10 @@ class CheckCaptures extends Recheck, SymTransformer:
 
       val saved = curEnv
       curEnv = Env(cls, EnvKind.Regular, localSet, curEnv)
+      val selfType = cls.classInfo.selfType
       try
         // (2) Capture set of self type includes capture set of class
-        val thisSet = cls.classInfo.selfType.captureSet.withDescription(i"of the self type of $cls")
+        val thisSet = selfType.captureSet.withDescription(i"of the self type of $cls")
         withGlobalCapAsRoot: // OK? We need this here since self types use GlobalAny instead of a LocalCap
           checkSubset(localSet, thisSet, tree.srcPos)
 
@@ -1576,8 +1577,9 @@ class CheckCaptures extends Recheck, SymTransformer:
       finally
         if cls.is(ModuleClass) then
           interpolate(cls.sourceModule.info, cls.sourceModule)
+          interpolate(selfType, cls)
         else
-          capt.println(i"Use set of $cls = ${cls.useSet}, self type: ${cls.classInfo.selfType}")
+          capt.println(i"Use set of $cls = ${cls.useSet}, self type: $selfType")
         completed += cls
         curEnv = saved
     end recheckClassDef

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

@@ -311,9 +311,11 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         CapturingType(OrType(parent1, tp2, tp.isSoft), refs1, tp1.isBoxed)
       case tp @ OrType(tp1, tp2 @ CapturingType(parent2, refs2)) =>
         CapturingType(OrType(tp1, parent2, tp.isSoft), refs2, tp2.isBoxed)
-      case tp @ AppliedType(tycon, args)
-      if !defn.isFunctionClass(tp.dealias.typeSymbol) && (tp.dealias eq tp) =>
-        tp.derivedAppliedType(tycon, args.mapConserve(_.boxDeeply))
+      case tp @ AppliedType(tycon, args) if tp.dealias eq tp =>
+        val sym = tycon.typeSymbol
+        if !defn.isFunctionClass(sym) && sym != defn.MagicMaybeClass
+        then tp.derivedAppliedType(tycon, args.mapConserve(_.boxDeeply))
+        else tp
       case tp: RealTypeBounds =>
         tp.derivedTypeBounds(tp.lo, tp.hi.boxDeeply)
       case tp: LazyRef =>

compiler/src/dotty/tools/dotc/config/Feature.scala

@@ -327,26 +327,27 @@ object Feature:
    *  @return true iff the import was handled
    */
   def handleGlobalLanguageImport(prefix: TermName, imported: Name)(using Context): Boolean =
+    def enableCC() =
+      ctx.compilationUnit.needsCaptureChecking = true
+      if ctx.run != null then ctx.run.nn.ccEnabledSomewhere = true
     QualifiedName(prefix, imported.asTermName) match
       case `pureFunctions` =>
         ctx.compilationUnit.knowsPureFuns = true
         if ctx.run != null then ctx.run.nn.pureFunsImportEncountered = true
         true
       case `captureChecking` =>
-        ctx.compilationUnit.needsCaptureChecking = true
-        if ctx.run != null then ctx.run.nn.ccEnabledSomewhere = true
+        enableCC()
         true
       case `separationChecking` =>
-        ctx.compilationUnit.needsCaptureChecking = true
+        enableCC()
         ctx.compilationUnit.needsSeparationChecking = true
-        if ctx.run != null then ctx.run.nn.ccEnabledSomewhere = true
         true
       case `safe` =>
-        ctx.compilationUnit.needsCaptureChecking = true
+        enableCC()
         ctx.compilationUnit.safeMode = true
-        if ctx.run != null then ctx.run.nn.ccEnabledSomewhere = true
         true
       case `magic` =>
+        enableCC()
         ctx.compilationUnit.magic = true
         ctx.compilationUnit.sourceVersion = Some(SourceVersion.future)
         true

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -1223,7 +1223,7 @@ extends DeclarationMsg(OverrideErrorID), NoDisambiguation:
   override def canExplain =
     memberTp.exists && otherTp.exists
   def explain(using Context) =
-    if canExplain then err.whyNoMatchStr(memberTp, otherTp) else ""
+    if canExplain then err.whyNoMatchStr(memberTp, otherTp, frozen = true) else ""
 
 class ForwardReferenceExtendsOverDefinition(value: Symbol, definition: Symbol)(using Context)
 extends ReferenceMsg(ForwardReferenceExtendsOverDefinitionID) {
@@ -3960,7 +3960,7 @@ final class IllegalUseOfSpecialized(using Context)
         inline def foo[T: Specialized](v: Vec[T]) = v.x
 
         In this instance it was used in a way which is unsupported, such as
-        trying to create a type synonym or a value with explicit type Specialized[X].  
+        trying to create a type synonym or a value with explicit type Specialized[X].
       """
 
 /** Shows up as a TypeError (in the notes field) if variance is attempted
@@ -3974,17 +3974,17 @@ final class IllegalVarianceInSpecializedTraitsNote(using Context) extends Note:
     - Primitives are specialized: Foo[Int] erases to Foo$$sp$$Int
     - Reference types are specialized to the highest non-top class: Foo[Lion] erases to Foo$$sp$$Animal
     - Top classes are erased normally: Foo[Any] / Foo[AnyVal] / Foo[Object] / Foo[AnyRef] erase to Foo.
-    This means that variance patterns that cross these erasure categories will fail at 
+    This means that variance patterns that cross these erasure categories will fail at
     runtime due to a ClassCastException, so they are not permitted.
 
     Please see the docs for more information on how specialized traits are erased.
     Suggested fixes:
       - Make the type of the target site more general e.g. Foo[Object] instead of Foo[Animal].
-      - Reconsider if you really need to use Nothing / Object / Any / AnyRef / AnyVal in your code. 
+      - Reconsider if you really need to use Nothing / Object / Any / AnyRef / AnyVal in your code.
       - Remove Specialized from the definition of the corresponding parameter.
     """
 
-  override def covers(other: Note)(using Context): Boolean =    
+  override def covers(other: Note)(using Context): Boolean =
     other.isInstanceOf[IllegalVarianceInSpecializedTraitsNote]
 
 final class VarianceInSpecializedTraitsLimitation(using Context)
@@ -3997,17 +3997,17 @@ final class VarianceInSpecializedTraitsLimitation(using Context)
     - Primitives are specialized: Foo[Int] erases to Foo$$sp$$Int
     - Reference types are specialized to the highest non-top class: Foo[Lion] erases to Foo$$sp$$Animal
     - Top classes are erased normally: Foo[Any] / Foo[AnyVal] / Foo[Object] / Foo[AnyRef] erase to Foo.
-    This means that certain variance patterns that cross these erasure categories will fail at 
+    This means that certain variance patterns that cross these erasure categories will fail at
     runtime due to a ClassCastException, so they are not permitted.
-    
-    For example, treating Foo[Any] as Foo[Animal] via contravariance is not allowed with Specialized. 
+
+    For example, treating Foo[Any] as Foo[Animal] via contravariance is not allowed with Specialized.
 
     Please see the docs for more information on how specialized traits are erased.
 
     If you accept this limitation you can silence this warning with @nowarn. For example:
-    
+
     @nowarn("id=E${VarianceInSpecializedTraitsLimitationID.errorNumber}")
     inline trait Foo[-T: Specialized]:
- 
+
     Otherwise, remove Specialized, or remove the variance.
     """

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

@@ -226,7 +226,7 @@ object ErrorReporting {
       else ""
 
     /** A subtype log explaining why `found` does not conform to `expected` */
-    def whyNoMatchStr(found: Type, expected: Type): String =
+    def whyNoMatchStr(found: Type, expected: Type, frozen: Boolean = false): String =
       val header =
         i"""I tried to show that
           |  $found
@@ -241,7 +241,9 @@ object ErrorReporting {
         else
           i"""a constraint with:
              |$c"""
-      i"""${TypeComparer.explained(_.isSubType(found, expected), header, short = !ctx.settings.Ydebug.value)}
+      i"""${TypeComparer.explained(
+              if frozen then _.isSubTypeWhenFrozen(found, expected)
+              else _.isSubType(found, expected), header, short = !ctx.settings.Ydebug.value)}
          |
          |The tests were made under $constraintText"""
 

library/src/scala/Tuple.scala

@@ -6,7 +6,7 @@ import compiletime.*
 import compiletime.ops.int.*
 
 /** Tuple of arbitrary arity. */
-sealed trait Tuple extends Product {
+sealed trait Tuple extends Product, caps.Pure {
   import Tuple.*
 
   /** Creates a copy of this tuple as an Array. */

tests/neg-custom-args/captures/effect-swaps-explicit.check

@@ -5,7 +5,7 @@
    |Capability `contextual$1` outlives its scope: it leaks into outer capture set 's1 which is owned by method fail3.
    |The leakage occurred when trying to match the following types:
    |
-   |Found:    (contextual$1: boundary.Label[Result[Future[T^'s2]^'s3, E^'s4]^'s5]^) ?->{Result, fr, async}
+   |Found:    (contextual$1: boundary.Label[Result[Future[T^'s2]^'s3, E^'s4]^'s5]^) ?->{fr, async}
    |  Result[Future[T^'s6]^{fr, contextual$1}, E^'s7]^'s8
    |Required: (boundary.Label[Result[Future[T^'s9]^'s1, E^'s10]^'s11]^) ?=> Result[Future[T^'s9]^'s1, E^'s10]^'s11
    |

tests/neg-custom-args/captures/effect-swaps.check

@@ -5,7 +5,7 @@
    |Capability `contextual$1` outlives its scope: it leaks into outer capture set 's1 which is owned by method fail3.
    |The leakage occurred when trying to match the following types:
    |
-   |Found:    (contextual$1: boundary.Label[Result[Future[T^'s2]^'s3, E^'s4]^'s5]^) ?->{Result, fr, async}
+   |Found:    (contextual$1: boundary.Label[Result[Future[T^'s2]^'s3, E^'s4]^'s5]^) ?->{fr, async}
    |  Result[Future[T^'s6]^{fr, contextual$1}, E^'s7]^'s8
    |Required: (boundary.Label[Result[Future[T^'s9]^'s1, E^'s10]^'s11]^) ?=> Result[Future[T^'s9]^'s1, E^'s10]^'s11
    |

tests/neg-custom-args/captures/local-mutables-2.check

@@ -1,7 +1,7 @@
 -- Error: tests/neg-custom-args/captures/local-mutables-2.scala:7:9 ----------------------------------------------------
 7 |def foo() = // error: separation failure
   |         ^
-  |Separation failure in method foo's inferred result type (() ->{any.rd} Int, (x: Int) => Unit)^{}.
+  |Separation failure in method foo's inferred result type (() ->{any.rd} Int, (x: Int) => Unit).
   |One part,  () ->{any.rd} Int, hides capabilities  {any².rd}.
   |Another part,  (x: Int) => Unit,  captures capabilities  {any³, any, any²}.
   |The two sets overlap at  {`any` of value r}.
@@ -12,7 +12,7 @@
 -- Error: tests/neg-custom-args/captures/local-mutables-2.scala:11:10 --------------------------------------------------
 11 |def foo2() = // error: separation failure
    |          ^
-   |          Separation failure in method foo2's inferred result type (() ->{any.rd} Int, (x: Int) => Unit)^{}.
+   |          Separation failure in method foo2's inferred result type (() ->{any.rd} Int, (x: Int) => Unit).
    |          One part,  (x: Int) => Unit, hides capabilities  {any}.
    |          Another part,  () ->{any.rd} Int,  captures capabilities  {any.rd}.
    |          The two sets overlap at  {`any` of variable r}.

tests/run/LazyLists-maybe.scala

@@ -4,7 +4,7 @@ package xcollections:
   import annotation.unchecked.uncheckedVariance
   import compiletime.uninitialized
 
-  abstract class LazyList[+T]:
+  abstract class LazyList[+T] extends caps.Pure:
 
     private var myHead: T = uninitialized
     private var myTail: LazyList[T] = uninitialized
@@ -69,12 +69,12 @@ package xcollections:
           else set(xs.head, xs.tail ++ ys)
 
     extension [T, U](xs: LazyList[T])
-      def map(f: T => U): LazyList[U] = new:
+      def map(f: T -> U): LazyList[U] = new:
         protected def force() =
           if xs.isEmpty then empty
           else set(f(xs.head), xs.tail.map(f))
 
-      def flatMap(f: T => LazyList[U]): LazyList[U] = new:
+      def flatMap(f: T -> LazyList[U]): LazyList[U] = new:
         protected def force(): LazyList[U] =
           if xs.isEmpty then empty
           else f(xs.head) ++ xs.tail.flatMap(f)
@@ -84,7 +84,7 @@ package xcollections:
         else xs.tail.foldLeft(f(z, xs.head))(f)
 
     extension [T](xs: LazyList[T])
-      def filter(p: T => Boolean): LazyList[T] = new:
+      def filter(p: T -> Boolean): LazyList[T] = new:
         protected def force(): LazyList[T] =
           if xs.isEmpty then empty
           else if p(xs.head) then set(xs.head, xs.tail.filter(p))