Don't perform the apply rule optimization under boxing

This was already the case for the select rule optimization in recheckSelection
but was missing for the corresponding rule for applications.

This caused one regression in the standard library, here:
```
  private def eagerHeadConcatIterators[A](it: Iterator[collection.Iterable[A]^]^): LazyListIterable[A]^{it} =
    if !it.hasNext then Empty
    else
      eagerHeadPrependIterator
          (it.next().iterator)
          (eagerHeadConcatIterators(it))
```
Previously the access to `it.next()` was considered to have type `it` by applying the apply rule
incorrectly. It should be `it*`. This means we now have `it*` instead of `it` in the result type
and we also have an illegal use of `it*` leaking outside `eagerHeadConcatIterators`. The second
problem was fixed by adding an unsafe escape hatch `unsafeDiscardUses` that suppressed use recording.
This leads to:
```
  private def eagerHeadConcatIterators[A](it: Iterator[collection.Iterable[A]^]^): LazyListIterable[A]^{it*} =
    if !it.hasNext then Empty
    else
      eagerHeadPrependIterator
          (caps.unsafe.unsafeDiscardUses(it.next()).iterator)
          (eagerHeadConcatIterators(it))
```
This also did not compile since it claimed that the `it @reachCapability` was not a legal element of a capture set.
The root cause was that we forced some definitions already in parser, which can lead to confusion when compiling the
standard library itself. We now refrain from doing that and build the references to these annotations as untyped
trees all the way down.

Author: odersky

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

@@ -523,7 +523,10 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def rootDot(name: Name)(implicit src: SourceFile): Select = Select(Ident(nme.ROOTPKG), name)
   def scalaDot(name: Name)(implicit src: SourceFile): Select = Select(rootDot(nme.scala), name)
   def scalaAnnotationDot(name: Name)(using SourceFile): Select = Select(scalaDot(nme.annotation), name)
+  def scalaAnnotationInternalDot(name: Name)(using SourceFile): Select = Select(scalaAnnotationDot(nme.internal), name)
   def scalaRuntimeDot(name: Name)(using SourceFile): Select = Select(scalaDot(nme.runtime), name)
+  def scalaCapsDot(name: Name)(using SourceFile): Select = Select(scalaDot(nme.caps), name)
+  def scalaCapsInternalDot(name: Name)(using SourceFile): Select = Select(scalaCapsDot(nme.internal), name)
   def scalaUnit(implicit src: SourceFile): Select = scalaDot(tpnme.Unit)
   def scalaAny(implicit src: SourceFile): Select = scalaDot(tpnme.Any)
 
@@ -553,16 +556,16 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     Annotated(parent, annot)
 
   def makeReachAnnot()(using Context): Tree =
-    New(ref(defn.ReachCapabilityAnnot.typeRef), Nil :: Nil)
+    New(scalaAnnotationInternalDot(tpnme.reachCapability), Nil :: Nil)
 
   def makeReadOnlyAnnot()(using Context): Tree =
-    New(ref(defn.ReadOnlyCapabilityAnnot.typeRef), Nil :: Nil)
+    New(scalaAnnotationInternalDot(tpnme.readOnlyCapability), Nil :: Nil)
 
   def makeOnlyAnnot(qid: Tree)(using Context) =
-    New(AppliedTypeTree(ref(defn.OnlyCapabilityAnnot.typeRef), qid :: Nil), Nil :: Nil)
+    New(AppliedTypeTree(scalaAnnotationInternalDot(tpnme.onlyCapability), qid :: Nil), Nil :: Nil)
 
   def makeConsumeAnnot()(using Context): Tree =
-    New(ref(defn.ConsumeAnnot.typeRef), Nil :: Nil)
+    New(scalaCapsInternalDot(tpnme.consume), Nil :: Nil)
 
   def makeConstructor(tparams: List[TypeDef], vparamss: List[List[ValDef]], rhs: Tree = EmptyTree)(using Context): DefDef =
     DefDef(nme.CONSTRUCTOR, joinParams(tparams, vparamss), TypeTree(), rhs)

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

@@ -130,8 +130,8 @@ object CheckCaptures:
                 |A classifier class is a class extending `caps.Capability` and directly extending `caps.Classifier`.""",
             ann.srcPos)
         check(ref)
-      case tpe =>
-        report.error(em"$elem: $tpe is not a legal element of a capture set", ann.srcPos)
+      case elem =>
+        report.error(em"$elem is not a legal element of a capture set", ann.srcPos)
     ann.retainedSet.retainedElementsRaw.foreach(check)
 
   /** Disallow bad roots anywhere in type `tp``.
@@ -840,6 +840,8 @@ class CheckCaptures extends Recheck, SymTransformer:
       appType match
         case appType @ CapturingType(appType1, refs)
         if qualType.exists
+            && !qualType.isBoxedCapturing
+            && !resultType.isBoxedCapturing
             && !tree.fun.symbol.isConstructor
             && !resultType.captureSet.containsResultCapability
             && qualCaptures.mightSubcapture(refs)

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

@@ -573,6 +573,7 @@ object StdNames {
     val ofDim: N                = "ofDim"
     val on: N                   = "on"
     val only: N                 = "only"
+    val onlyCapability: N       = "onlyCapability"
     val opaque: N               = "opaque"
     val open: N                 = "open"
     val ordinal: N              = "ordinal"
@@ -591,6 +592,8 @@ object StdNames {
     val productPrefix: N        = "productPrefix"
     val quotes : N              = "quotes"
     val raw_ : N                = "raw"
+    val reachCapability: N      = "reachCapability"
+    val readOnlyCapability: N   = "readOnlyCapability"
     val rd: N                   = "rd"
     val refl: N                 = "refl"
     val reflect: N              = "reflect"

library/src/scala/collection/immutable/LazyListIterable.scala

@@ -1264,13 +1264,26 @@ object LazyListIterable extends IterableFactory[LazyListIterable] {
     if (it.hasNext) eagerCons(it.next(), newLL(eagerHeadFromIterator(it)))
     else Empty
 
+  // TODO This should be (xss: (collection.Iterable[A]^)*)
   override def concat[A](xss: collection.Iterable[A]*): LazyListIterable[A] =
     if (xss.knownSize == 0) empty
     else newLL(eagerHeadConcatIterators(xss.iterator))
 
-  private def eagerHeadConcatIterators[A](it: Iterator[collection.Iterable[A]^]^): LazyListIterable[A]^{it} =
-    if (!it.hasNext) Empty
-    else eagerHeadPrependIterator(it.next().iterator)(eagerHeadConcatIterators(it))
+  /* TODO This should be:
+  private def eagerHeadConcatIterators[A](it: Iterator[collection.Iterable[A]^]^): LazyListIterable[A]^{it*} =
+    if !it.hasNext then Empty
+    else
+      eagerHeadPrependIterator
+          (caps.unsafe.unsafeDiscardUses(it.next()).iterator)
+          (eagerHeadConcatIterators(it))
+  */
+
+  private def eagerHeadConcatIterators[A](it: Iterator[collection.Iterable[A]]^): LazyListIterable[A]^{it} =
+    if !it.hasNext then Empty
+    else
+      eagerHeadPrependIterator
+          (it.next().iterator)
+          (eagerHeadConcatIterators(it))
 
   /** An infinite LazyListIterable that repeatedly applies a given function to a start value.
     *

tests/neg-custom-args/captures/apply-rule.check

@@ -0,0 +1,46 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/apply-rule.scala:3:19 ------------------------------------
+3 |  val _: () -> A = x // error
+  |                   ^
+  |                   Found:    (x : () ->{s*} A^{})
+  |                   Required: () -> A
+  |
+  |                   Note that capability s* is not included in capture set {}.
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/apply-rule.scala:5:19 ------------------------------------
+5 |  val _: () -> A = y // error
+  |                   ^
+  |                   Found:    (y : () ->{s*} A^{})
+  |                   Required: () -> A
+  |
+  |                   Note that capability s* is not included in capture set {}.
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/apply-rule.scala:9:19 ------------------------------------
+9 |  val _: () -> A = x // error
+  |                   ^
+  |                   Found:    (x : () ->{C} A^{})
+  |                   Required: () -> A
+  |
+  |                   Note that capability C is not included in capture set {}.
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/apply-rule.scala:11:19 -----------------------------------
+11 |  val _: () -> A = y // error
+   |                   ^
+   |                   Found:    (y : () ->{C} A^{})
+   |                   Required: () -> A
+   |
+   |                   Note that capability C is not included in capture set {}.
+   |
+   | longer explanation available when compiling with `-explain`
+-- Error: tests/neg-custom-args/captures/apply-rule.scala:2:11 ---------------------------------------------------------
+2 |  val x = s(0) // error
+  |          ^^^^
+  |          Local reach capability s* leaks into capture scope of method select.
+  |          You could try to abstract the capabilities referred to by s* in a capset variable.
+-- Error: tests/neg-custom-args/captures/apply-rule.scala:4:12 ---------------------------------------------------------
+4 |  val y = s.head // error
+  |          ^^^^^^
+  |          Local reach capability s* leaks into capture scope of method select.
+  |          You could try to abstract the capabilities referred to by s* in a capset variable.

tests/neg-custom-args/captures/apply-rule.scala

@@ -0,0 +1,16 @@
+def select[A](s: Seq[() => A]) =
+  val x = s(0) // error
+  val _: () -> A = x // error
+  val y = s.head // error
+  val _: () -> A = y // error
+
+def select2[A, C^](s: Seq[() ->{C} A]) =
+  val x = s(0)
+  val _: () -> A = x // error
+  val y = s.head
+  val _: () -> A = y // error
+
+
+
+
+

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

@@ -0,0 +1,12 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/nicolas1.scala:10:2 --------------------------------------
+10 |  val all: Seq[Rand ?->{head, tail*} A] = head +: tail // error
+   |  ^
+   |  Found:    (contextual$1: Rand^'s1) ?->{head, tail*} A^'s2
+   |  Required: (Rand^) ?->{head} A
+   |
+   |  Note that capability tail* is not included in capture set {head}.
+   |
+   |  where:    ^ refers to the universal root capability
+11 |  all(nextInt(all.length))
+   |
+   | longer explanation available when compiling with `-explain`

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

@@ -0,0 +1,11 @@
+import caps.*
+
+trait Rand extends SharedCapability:
+  def range(min: Int, max: Int): Int
+
+def nextInt(max: Int): Rand ?-> Int =
+  r ?=> r.range(0, max)
+
+def oneOf[A](head: Rand ?=> A, tail: (Rand ?=> A)*): Rand ?->{head} A =
+  val all: Seq[Rand ?->{head, tail*} A] = head +: tail // error
+  all(nextInt(all.length))