More fix

Author: noti0na1

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -2261,9 +2261,9 @@ object desugar {
               AppliedTypeTree(ref(defn.SeqType), t),
               New(ref(defn.RepeatedAnnot.typeRef), Nil :: Nil))
         else if op.name == nme.CC_REACH then
-          Apply(ref(defn.Caps_reachCapability), t :: Nil)
+          Annotated(t, New(ref(defn.ReachCapabilityAnnot.typeRef), Nil :: Nil))
         else if op.name == nme.CC_READONLY then
-          Apply(ref(defn.Caps_readOnlyCapability), t :: Nil)
+          Annotated(t, New(ref(defn.ReadOnlyCapabilityAnnot.typeRef), Nil :: Nil))
         else
           assert(ctx.mode.isExpr || ctx.reporter.errorsReported || ctx.mode.is(Mode.Interactive), ctx.mode)
           Select(t, op.name)

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

@@ -38,15 +38,14 @@ case class CaptureAnnotation(refs: CaptureSet, boxed: Boolean)(cls: Symbol) exte
 
   /** Reconstitute annotation tree from capture set */
   override def tree(using Context) =
-    val elems = refs.elems.toList.map {
-      case cr: TermRef => ref(cr)
-      case cr: TermParamRef => untpd.Ident(cr.paramName).withType(cr)
-      case cr: ThisType => This(cr.cls)
-      case root(_) => ref(root.cap)
-      // TODO: Will crash if the type is an annotated type, for example `cap.rd`
-    }
-    val arg = repeated(elems, TypeTree(defn.AnyType))
-    New(symbol.typeRef, arg :: Nil)
+    if symbol == defn.RetainsCapAnnot then
+      New(symbol.typeRef, Nil)
+    else
+      val elems = refs.elems.toList
+      val trefs =
+        if elems.isEmpty then defn.NothingType
+        else elems.reduce[Type]((a, b) => OrType(a, b, soft = false))
+      New(AppliedType(symbol.typeRef, trefs :: Nil), Nil)
 
   override def symbol(using Context) = cls
 

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

@@ -53,12 +53,12 @@ extension (tree: Tree)
    *  throw IllegalCaptureRef otherwise
    */
   def toCaptureRefs(using Context): List[CaptureRef] = tree match
-    case ReachCapabilityApply(arg) =>
-      arg.toCaptureRefs.map(_.reach)
-    case ReadOnlyCapabilityApply(arg) =>
-      arg.toCaptureRefs.map(_.readOnly)
-    case CapsOfApply(arg) =>
-      arg.toCaptureRefs
+    // case ReachCapabilityApply(arg) =>
+    //   arg.toCaptureRefs.map(_.reach)
+    // case ReadOnlyCapabilityApply(arg) =>
+    //   arg.toCaptureRefs.map(_.readOnly)
+    // case CapsOfApply(arg) =>
+    //   arg.toCaptureRefs
     case _ => tree.tpe.dealiasKeepAnnots match
       case ref: CaptureRef if ref.isTrackableRef =>
         ref :: Nil
@@ -78,28 +78,20 @@ extension (tree: Tree)
         val refs =
           tree match
             case Apply(_: TypeApply, _) =>
-              CaptureSet(tree.retainedElemsFromType*)
+              CaptureSet(tree.retainedSet.retainedElements*)
             case _ =>
               CaptureSet(tree.retainedElems.flatMap(_.toCaptureRefs)*)
         // println(s"toCaptureSet: $tree -> $refs")
         tree.putAttachment(Captures, refs)
         refs
 
-  def retainedElemsFromType(using Context): List[CaptureRef] =
-    def collectRefs(tp: Type): List[CaptureRef] = tp match
-      case tp: CaptureRef if tp.isTrackableRef =>
-        tp :: Nil
-      case tp: TypeRef if tp.symbol.isType && tp.derivesFrom(defn.Caps_CapSet) =>
-        tp :: Nil
-      case OrType(tp1, tp2) =>
-        collectRefs(tp1) ++ collectRefs(tp2)
-      case _ =>
-        Nil
+  def retainedSet(using Context): Type =
     tree match
-      case Apply(TypeApply(_, refs :: Nil), _) =>
-        collectRefs(refs.tpe)
+      case Apply(TypeApply(_, refs :: Nil), _) => refs.tpe
       case _ =>
-        Nil
+        if tree.symbol.maybeOwner == defn.RetainsCapAnnot
+        then root.cap
+        else NoType
 
   /** The arguments of a @retains, @retainsCap or @retainsByName annotation */
   def retainedElems(using Context): List[Tree] = tree match
@@ -112,6 +104,21 @@ extension (tree: Tree)
 
 extension (tp: Type)
 
+  def retainedElements(using Context): List[CaptureRef] = tp match
+    case ReachCapability(tp1) =>
+      tp1.reach :: Nil
+    case ReadOnlyCapability(tp1) =>
+      tp1.readOnly :: Nil
+    case tp: CaptureRef if tp.isTrackableRef =>
+      tp :: Nil
+    case tp: TypeRef if tp.symbol.isType && tp.derivesFrom(defn.Caps_CapSet) =>
+      tp :: Nil
+    case OrType(tp1, tp2) =>
+      tp1.retainedElements ++ tp2.retainedElements
+    case _ =>
+      if tp.isNothingType then Nil
+      else throw IllegalCaptureRef(tp)
+
   /** Is this type a CaptureRef that can be tracked?
    *  This is true for
    *    - all ThisTypes and all TermParamRef,
@@ -543,7 +550,7 @@ extension (cls: ClassSymbol)
       || bc.is(CaptureChecked)
           && bc.givenSelfType.dealiasKeepAnnots.match
             case CapturingType(_, refs) => refs.isAlwaysEmpty
-            case RetainingType(_, refs) => refs.isEmpty
+            case RetainingType(_, refs) => refs.retainedElements.isEmpty
             case selfType =>
               isCaptureChecking  // At Setup we have not processed self types yet, so
                                  // unless a self type is explicitly given, we can't tell
@@ -661,7 +668,7 @@ class CleanupRetains(using Context) extends TypeMap:
   def apply(tp: Type): Type =
     tp match
       case AnnotatedType(tp, annot) if annot.symbol == defn.RetainsAnnot || annot.symbol == defn.RetainsByNameAnnot =>
-        RetainingType(tp, Nil, byName = annot.symbol == defn.RetainsByNameAnnot)
+        RetainingType(tp, defn.NothingType, byName = annot.symbol == defn.RetainsByNameAnnot)
       case _ => mapOver(tp)
 
 /** A typemap that follows aliases and keeps their transformed results if
@@ -680,18 +687,18 @@ trait FollowAliasesMap(using Context) extends TypeMap:
 /** An extractor for `caps.reachCapability(ref)`, which is used to express a reach
  *  capability as a tree in a @retains annotation.
  */
-object ReachCapabilityApply:
-  def unapply(tree: Apply)(using Context): Option[Tree] = tree match
-    case Apply(reach, arg :: Nil) if reach.symbol == defn.Caps_reachCapability => Some(arg)
-    case _ => None
+// object ReachCapabilityApply:
+//   def unapply(tree: Apply)(using Context): Option[Tree] = tree match
+//     case Apply(reach, arg :: Nil) if reach.symbol == defn.Caps_reachCapability => Some(arg)
+//     case _ => None
 
 /** An extractor for `caps.readOnlyCapability(ref)`, which is used to express a read-only
  *  capability as a tree in a @retains annotation.
  */
-object ReadOnlyCapabilityApply:
-  def unapply(tree: Apply)(using Context): Option[Tree] = tree match
-    case Apply(ro, arg :: Nil) if ro.symbol == defn.Caps_readOnlyCapability => Some(arg)
-    case _ => None
+// object ReadOnlyCapabilityApply:
+//   def unapply(tree: Apply)(using Context): Option[Tree] = tree match
+//     case Apply(ro, arg :: Nil) if ro.symbol == defn.Caps_readOnlyCapability => Some(arg)
+//     case _ => None
 
 /** An extractor for `caps.capsOf[X]`, which is used to express a generic capture set
  *  as a tree in a @retains annotation.

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

@@ -99,25 +99,24 @@ object CheckCaptures:
    *  This check is performed at Typer.
    */
   def checkWellformed(parent: Tree, ann: Tree)(using Context): Unit =
-    def check(elem: Tree, pos: SrcPos): Unit = elem.tpe match
+    def check(elem: Type, pos: SrcPos): Unit = elem match
       case ref: CaptureRef =>
         if !ref.isTrackableRef then
           report.error(em"$elem cannot be tracked since it is not a parameter or local value", pos)
       case tpe =>
         report.error(em"$elem: $tpe is not a legal element of a capture set", pos)
-    for elem <- ann.retainedElems do
+    for elem <- ann.retainedSet.retainedElements do
       elem match
-        case CapsOfApply(arg) =>
-          def isLegalCapsOfArg =
-            arg.symbol.isType && arg.symbol.info.derivesFrom(defn.Caps_CapSet)
-          if !isLegalCapsOfArg then
-            report.error(
-              em"""$arg is not a legal prefix for `^` here,
-                  |is must be a type parameter or abstract type with a caps.CapSet upper bound.""",
-              elem.srcPos)
-        case ReachCapabilityApply(arg) => check(arg, elem.srcPos)
-        case ReadOnlyCapabilityApply(arg) => check(arg, elem.srcPos)
-        case _ => check(elem, elem.srcPos)
+        case ref: TypeRef =>
+          val refSym = ref.symbol
+          if refSym.isType && !refSym.info.derivesFrom(defn.Caps_CapSet) then
+            report.error(em"$elem is not a legal element of a capture set", ann.srcPos)
+        case ReachCapability(ref) =>
+          check(ref, ann.srcPos)
+        case ReadOnlyCapability(ref) =>
+          check(ref, ann.srcPos)
+        case _ =>
+          check(elem, ann.srcPos)
 
   /** Under the sealed policy, report an error if some part of `tp` contains the
    *  root capability in its capture set or if it refers to a type parameter that

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

@@ -12,24 +12,22 @@ import Decorators.i
  */
 object RetainingType:
 
-  def apply(tp: Type, refs: List[Tree], byName: Boolean = false)(using Context): Type =
+  // def apply(tp: Type, refs: List[CaptureRef], byName: Boolean = false)(using Context): Type = ???
+
+  def apply(tp: Type, typeRefs: Type, byName: Boolean = false)(using Context): Type =
     val annotCls = if byName then defn.RetainsByNameAnnot else defn.RetainsAnnot
-    val annotTree =
-      New(annotCls.typeRef,
-        Typed(
-          SeqLiteral(refs, TypeTree(defn.AnyType)),
-          TypeTree(defn.RepeatedParamClass.typeRef.appliedTo(defn.AnyType))) :: Nil)
+    val annotTree = New(AppliedType(annotCls.typeRef, defn.NothingType :: Nil), Nil)
     AnnotatedType(tp, Annotation(annotTree))
 
-  def unapply(tp: AnnotatedType)(using Context): Option[(Type, List[Tree])] =
+  def unapply(tp: AnnotatedType)(using Context): Option[(Type, Type)] =
     val sym = tp.annot.symbol
     if sym.isRetainsLike then
       tp.annot match
         case _: CaptureAnnotation =>
           assert(ctx.mode.is(Mode.IgnoreCaptures), s"bad retains $tp at ${ctx.phase}")
           None
         case ann =>
-          Some((tp.parent, ann.tree.retainedElems))
+          Some((tp.parent, ann.tree.retainedSet))
     else
       None
 end RetainingType

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

@@ -790,7 +790,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
       case CapturingType(_, refs) =>
         !refs.isAlwaysEmpty
       case RetainingType(parent, refs) =>
-        !refs.isEmpty
+        !refs.retainedElements.isEmpty
       case tp: (TypeRef | AppliedType) =>
         val sym = tp.typeSymbol
         if sym.isClass
@@ -836,7 +836,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         && !refs.isUniversal  // if refs is {cap}, an added variable would not change anything
       case RetainingType(parent, refs) =>
         needsVariable(parent)
-        && !refs.tpes.exists:
+        && !refs.retainedElements.exists:
             case ref: TermRef => ref.isCap
             case _ => false
       case AnnotatedType(parent, _) =>
@@ -931,8 +931,8 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
    *  @param tpt      the tree for which an error or warning should be reported
    */
   private def checkWellformed(parent: Type, ann: Tree, tpt: Tree)(using Context): Unit =
-    capt.println(i"checkWF post $parent ${ann.retainedElems} in $tpt")
-    var retained = ann.retainedElems.toArray
+    capt.println(i"checkWF post $parent ${ann.retainedSet} in $tpt")
+    var retained = ann.retainedSet.retainedElems.toArray
     for i <- 0 until retained.length do
       val refTree = retained(i)
       val refs =
@@ -942,8 +942,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           Nil
       for ref <- refs do
         def pos =
-          if refTree.span.exists then refTree.srcPos
-          else if ann.span.exists then ann.srcPos
+          if ann.span.exists then ann.srcPos
           else tpt.srcPos
 
         def check(others: CaptureSet, dom: Type | CaptureSet): Unit =
@@ -959,14 +958,15 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
 
         val others =
           for
-            j <- 0 until retained.length if j != i
-            r <- retained(j).toCaptureRefs
+            j <- 0 until retainedRefs.length if j != i
+            r = retainedRefs(j)
             if !r.isRootCapability
           yield r
         val remaining = CaptureSet(others*)
         check(remaining, remaining)
       end for
-    end for
+    catch case ex: IllegalCaptureRef =>
+      report.error(em"Illegal capture reference: ${ex.getMessage.nn}", tpt.srcPos)
   end checkWellformed
 
   /** Check well formed at post check time. We need to wait until after

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

@@ -123,7 +123,7 @@ class Definitions {
             HKTypeLambda(argParamNames :+ "R".toTypeName, argVariances :+ Covariant)(
               tl => List.fill(arity + 1)(TypeBounds.empty),
               tl => RetainingType(underlyingClass.typeRef.appliedTo(tl.paramRefs),
-                      ref(captureRoot.termRef) :: Nil)
+                      captureRoot.termRef)
             ))
         else
           val cls = denot.asClass.classSymbol

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -178,8 +178,8 @@ class PlainPrinter(_ctx: Context) extends Printer {
       toTextCaptureRef(ref.typeOpt)
     case TypeApply(fn, arg :: Nil) if fn.symbol == defn.Caps_capsOf =>
       toTextRetainedElem(arg)
-    case ReachCapabilityApply(ref1) => toTextRetainedElem(ref1) ~ "*"
-    case ReadOnlyCapabilityApply(ref1) => toTextRetainedElem(ref1) ~ ".rd"
+    // case ReachCapabilityApply(ref1) => toTextRetainedElem(ref1) ~ "*"
+    // case ReadOnlyCapabilityApply(ref1) => toTextRetainedElem(ref1) ~ ".rd"
     case _ => toText(ref)
 
   private def toTextRetainedElems[T <: Untyped](refs: List[Tree[T]]): Text =
@@ -287,9 +287,10 @@ class PlainPrinter(_ctx: Context) extends Printer {
             && refs.isReadOnly
         then toText(parent)
         else toTextCapturing(parent, refs, boxText)
-      case tp @ RetainingType(parent, refs) =>
+      case tp @ RetainingType(parent, refsType) =>
+        val refs = refsType.retainedElements
         if Feature.ccEnabledSomewhere then
-          toTextCapturing(parent, refs, "") ~ Str("R").provided(printDebug)
+          toTextCapturing(parent, refs.map(r => ast.tpd.TypeTree(r)), "") ~ Str("R").provided(printDebug)
         else toText(parent)
       case tp: PreviousErrorType if ctx.settings.XprintTypes.value =>
         "<error>" // do not print previously reported error message because they may try to print this error type again recursively

library/src/scala/annotation/retains.scala

@@ -12,12 +12,12 @@ package scala.annotation
  *  non-standard capturing type syntax.
  */
 @experimental
-class retains[Args](xs: (Any @retainsArg)*) extends annotation.StaticAnnotation
+class retains[Elems] extends annotation.StaticAnnotation
 
 /** Equivalent in meaning to `@retains(cap)`, but consumes less bytecode.
  */
 @experimental
-class retainsCap() extends annotation.StaticAnnotation
+class retainsCap extends annotation.StaticAnnotation
   // This special case is needed to be able to load standard library modules without
   // cyclic reference errors. Specifically, load sequences involving IterableOnce.
 

library/src/scala/annotation/retainsByName.scala

@@ -2,5 +2,5 @@ package scala.annotation
 
 /** An annotation that indicates capture of an enclosing by-name type
  */
-@experimental class retainsByName[Args](xs: (Any@retainsArg)*) extends annotation.StaticAnnotation
+@experimental class retainsByName[Elems] extends annotation.StaticAnnotation
 

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

@@ -1,5 +1,10 @@
+import language.experimental.captureChecking
 import annotation.retains
+import annotation.retainsCap
+
 object Test:
 
-  def f[A <: Matchable @retains(caps.cap)](x: A): Matchable = x // error
+  def f[A <: Matchable @retains[caps.cap.type]](x: A): Matchable = x // error
+
+  def g[A <: Matchable @retainsCap](x: A): Matchable = x // error
 

tests/pos-custom-args/captures/cc-expand.scala

@@ -5,7 +5,7 @@ object Test:
   class B
   class C
   class CTC
-  type CT = CTC @retains(caps.cap)
+  type CT = CTC @retains[caps.cap.type]
 
   def test(ct: CT, dt: CT) =
 
@@ -17,6 +17,6 @@ object Test:
 
     def x4: (x: A @retains(ct)) -> B -> C = ???
 
-    def x5: A -> (x: B @retains(ct)) -> () -> C @retains(dt) = ???
-    def x6: A -> (x: B @retains(ct)) -> (() -> C @retains(dt)) @retains(x, dt) = ???
-    def x7: A -> (x: B @retains(ct)) -> (() -> C @retains(dt)) @retains(x) = ???
+    def x5: A -> (x: B @retains[ct.type]) -> () -> C @retains(dt) = ???
+    def x6: A -> (x: B @retains[ct.type]) -> (() -> C @retains[dt.type]) @retains[x.type | dt.type] = ???
+    def x7: A -> (x: B @retains[ct.type]) -> (() -> C @retains[dt.type]) @retains[x.type] = ???