Make maybeCapability a compiler-generated symbol without source

It's used only during the capture checking phase, cannot appear in source
or Tasty. So it's best contained as a synthetic symbol created directly by
the compiler.

Author: odersky

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

@@ -240,7 +240,7 @@ extension (tp: Type)
    *
    *      Array[_ >: C^{} <: C^{x}]
    *
-   *   but it has fewer issues with type inference. 
+   *   but it has fewer issues with type inference.
    */
   def maybe(using Context): CaptureRef = tp match
     case tp: CaptureRef if tp.isTrackableRef =>

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

@@ -535,6 +535,10 @@ class Definitions {
       List(AnyType), EmptyScope)
   @tu lazy val SingletonType: TypeRef = SingletonClass.typeRef
 
+  @tu lazy val MaybeCapabilityAnnot: ClassSymbol =
+    completeClass(enterCompleteClassSymbol(
+      ScalaPackageClass, tpnme.maybeCapability, Final, List(StaticAnnotationClass.typeRef)))
+
   @tu lazy val CollectionSeqType: TypeRef  = requiredClassRef("scala.collection.Seq")
   @tu lazy val SeqType: TypeRef            = requiredClassRef("scala.collection.immutable.Seq")
   @tu lazy val SeqModule: Symbol           = requiredModule("scala.collection.immutable.Seq")
@@ -993,7 +997,7 @@ class Definitions {
 
   // Annotation base classes
   @tu lazy val AnnotationClass: ClassSymbol = requiredClass("scala.annotation.Annotation")
-  // @tu lazy val StaticAnnotationClass: ClassSymbol = requiredClass("scala.annotation.StaticAnnotation")
+  @tu lazy val StaticAnnotationClass: ClassSymbol = requiredClass("scala.annotation.StaticAnnotation")
   @tu lazy val RefiningAnnotationClass: ClassSymbol = requiredClass("scala.annotation.RefiningAnnotation")
   @tu lazy val JavaAnnotationClass: ClassSymbol = requiredClass("java.lang.annotation.Annotation")
 
@@ -1054,7 +1058,6 @@ class Definitions {
   @tu lazy val FunctionalInterfaceAnnot: ClassSymbol = requiredClass("java.lang.FunctionalInterface")
   @tu lazy val TargetNameAnnot: ClassSymbol = requiredClass("scala.annotation.targetName")
   @tu lazy val VarargsAnnot: ClassSymbol = requiredClass("scala.annotation.varargs")
-  @tu lazy val MaybeCapabilityAnnot = requiredClass("scala.annotation.internal.maybeCapability")
   @tu lazy val ReachCapabilityAnnot = requiredClass("scala.annotation.internal.reachCapability")
   @tu lazy val RequiresCapabilityAnnot: ClassSymbol = requiredClass("scala.annotation.internal.requiresCapability")
   @tu lazy val RetainsAnnot: ClassSymbol = requiredClass("scala.annotation.retains")
@@ -2137,7 +2140,8 @@ class Definitions {
       AnyValClass,
       NullClass,
       NothingClass,
-      SingletonClass)
+      SingletonClass,
+      MaybeCapabilityAnnot)
 
   @tu lazy val syntheticCoreClasses: List[Symbol] = syntheticScalaClasses ++ List(
     EmptyPackageVal,

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

@@ -537,6 +537,7 @@ object StdNames {
     val ManifestFactory: N      = "ManifestFactory"
     val manifestToTypeTag: N    = "manifestToTypeTag"
     val map: N                  = "map"
+    val maybeCapability: N      = "maybeCapability"
     val materializeClassTag: N  = "materializeClassTag"
     val materializeWeakTypeTag: N = "materializeWeakTypeTag"
     val materializeTypeTag: N   = "materializeTypeTag"

library/src/scala/annotation/internal/maybeCapability.scala

@@ -1,7 +1,7 @@
 -- [E007] Type Mismatch Error: tests/neg/i19470.scala:9:12 -------------------------------------------------------------
 9 |    List(foo(f())) // error
   |         ^^^^^^^^
-  |         Found:    Inv[? >: IO <: box IO^{f}]
+  |         Found:    Inv[box IO^{f?}]
   |         Required: box Inv[box IO^?]^?
   |
   | longer explanation available when compiling with `-explain`