Update reference and member searching and tests

Author: noti0na1

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

@@ -542,9 +542,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       annot.putAttachment(RetainsAnnot, ())
     Annotated(parent, annot)
 
-  def makeCapsOf(tp: RefTree)(using Context): Tree =
-    TypeApply(capsInternalDot(nme.capsOf), tp :: 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/CaptureOps.scala

@@ -674,14 +674,6 @@ trait FollowAliasesMap(using Context) extends TypeMap:
 //     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.
- */
-object CapsOfApply:
-  def unapply(tree: TypeApply)(using Context): Option[Tree] = tree match
-    case TypeApply(capsOf, arg :: Nil) if capsOf.symbol == defn.Caps_capsOf => Some(arg)
-    case _ => None
-
 abstract class AnnotatedCapability(annotCls: Context ?=> ClassSymbol):
   def apply(tp: Type)(using Context): AnnotatedType =
     assert(tp.isTrackableRef, i"not a trackable ref: $tp")

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

@@ -1001,9 +1001,6 @@ class Definitions {
     @tu lazy val Caps_Capability: ClassSymbol = requiredClass("scala.caps.Capability")
     @tu lazy val Caps_CapSet: ClassSymbol = requiredClass("scala.caps.CapSet")
     @tu lazy val CapsInternalModule: Symbol = requiredModule("scala.caps.internal")
-    @tu lazy val Caps_reachCapability: TermSymbol = CapsInternalModule.requiredMethod("reachCapability")
-    @tu lazy val Caps_readOnlyCapability: TermSymbol = CapsInternalModule.requiredMethod("readOnlyCapability")
-    @tu lazy val Caps_capsOf: TermSymbol = CapsInternalModule.requiredMethod("capsOf")
     @tu lazy val CapsUnsafeModule: Symbol = requiredModule("scala.caps.unsafe")
     @tu lazy val Caps_unsafeAssumePure: Symbol = CapsUnsafeModule.requiredMethod("unsafeAssumePure")
     @tu lazy val Caps_unsafeAssumeSeparate: Symbol = CapsUnsafeModule.requiredMethod("unsafeAssumeSeparate")

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

@@ -380,6 +380,8 @@ object Flags {
   /** Tracked modifier for class parameter / a class with some tracked parameters */
   val (Tracked @ _, _, Dependent @ _) = newFlags(46, "tracked")
 
+  val (CaptureParam @ _, _, _) = newFlags(47, "capture-param")
+
   // ------------ Flags following this one are not pickled ----------------------------------
 
   /** Symbol is not a member of its owner */
@@ -449,7 +451,7 @@ object Flags {
 
   /** Flags representing source modifiers */
   private val CommonSourceModifierFlags: FlagSet =
-    commonFlags(Private, Protected, Final, Case, Implicit, Given, Override, JavaStatic, Transparent, Erased)
+    commonFlags(Private, Protected, Final, Case, Implicit, Given, Override, JavaStatic, Transparent, Erased, CaptureParam)
 
   val TypeSourceModifierFlags: FlagSet =
     CommonSourceModifierFlags.toTypeFlags | Abstract | Sealed | Opaque | Open
@@ -469,7 +471,7 @@ object Flags {
   val FromStartFlags: FlagSet = commonFlags(
     Module, Package, Deferred, Method, Case, Enum, Param, ParamAccessor,
     Scala2SpecialFlags, MutableOrOpen, Opaque, Touched, JavaStatic,
-    OuterOrCovariant, LabelOrContravariant, CaseAccessor, Tracked,
+    OuterOrCovariant, LabelOrContravariant, CaseAccessor, Tracked, CaptureParam,
     Extension, NonMember, Implicit, Given, Permanent, Synthetic, Exported,
     SuperParamAliasOrScala2x, Inline, Macro, ConstructorProxy, Invisible)
 

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

@@ -315,4 +315,17 @@ object NamerOps:
             ann.tree match
               case ast.tpd.WitnessNamesAnnot(witnessNames) =>
                 addContextBoundCompanionFor(sym, witnessNames, Nil)
+
+  /** Add a dummy term symbol for a type def that has capture parameter flag.
+   *  The dummy symbol has the same name as the original type symbol and is stable.
+   *
+   *  @param param the original type symbol of the capture parameter
+   */
+  def addDummyTermCaptureParam(param: Symbol)(using Context): Unit =
+    val name = param.name.toTermName
+    val flags = (param.flagsUNSAFE & AccessFlags).toTermFlags | CaptureParam | StableRealizable | Synthetic
+    val dummy = newSymbol(param.owner, name, flags, param.typeRef)
+    typr.println(i"Adding dummy term symbol $dummy for $param, flags = $flags")
+    ctx.enter(dummy)
+
 end NamerOps

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

@@ -445,7 +445,6 @@ object StdNames {
     val canEqual_ : N           = "canEqual"
     val canEqualAny : N         = "canEqualAny"
     val caps: N                 = "caps"
-    val capsOf: N               = "capsOf"
     val captureChecking: N      = "captureChecking"
     val checkInitialized: N     = "checkInitialized"
     val classOf: N              = "classOf"

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

@@ -90,6 +90,9 @@ class SymUtils:
     def isContextBoundCompanion(using Context): Boolean =
       self.is(Synthetic) && self.infoOrCompleter.typeSymbol == defn.CBCompanion
 
+    def isDummyCaptureParam(using Context): Boolean =
+      self.is(Synthetic) && self.is(CaptureParam)
+
     /** Is this a case class for which a product mirror is generated?
     *  Excluded are value classes, abstract classes and case classes with more than one
     *  parameter section.

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

@@ -747,7 +747,8 @@ object Types extends TypeUtils {
         case tp: ClassInfo => tp.appliedRef
         case _ => widenIfUnstable
       }
-      findMember(name, pre, required, excluded)
+      val excluded1 = if ctx.mode.is(Mode.InCaptureSet) then excluded else excluded | CaptureParam
+      findMember(name, pre, required, excluded1)
     }
 
     /** The implicit members with given name. If there are none and the denotation

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

@@ -176,10 +176,6 @@ class PlainPrinter(_ctx: Context) extends Printer {
   private def toTextRetainedElem[T <: Untyped](ref: Tree[T]): Text = ref match
     case ref: RefTree[?] if ref.typeOpt.exists =>
       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 _ => toText(ref)
 
   private def toTextRetainedElems[T <: Untyped](refs: List[Tree[T]]): Text =

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -350,6 +350,8 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
         unusable(ConstructorProxyNotValue(_))
       else if tree.symbol.isContextBoundCompanion then
         unusable(ContextBoundCompanionNotValue(_))
+      else if tree.symbol.isDummyCaptureParam then
+        throw new Exception(s"Dummy capture param ${tree.symbol} should not be used as a value")
       else
         tree
 

compiler/src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -387,7 +387,9 @@ object TreeChecker {
     }
 
     def isSymWithoutDef(sym: Symbol)(using Context): Boolean =
-      sym.is(ConstructorProxy) || sym.isContextBoundCompanion
+      sym.is(ConstructorProxy)
+      || sym.isContextBoundCompanion
+      || sym.isDummyCaptureParam
 
     /** Exclude from double definition checks any erased symbols that were
      *  made `private` in phase `UnlinkErasedDecls`. These symbols will be removed

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

@@ -1132,6 +1132,9 @@ class Namer { typer: Typer =>
       ensureUpToDate(sym.typeRef, dummyInfo1)
       if (dummyInfo2 `ne` dummyInfo1) ensureUpToDate(sym.typeRef, dummyInfo2)
 
+      if sym.info.derivesFrom(defn.Caps_CapSet) then
+        addDummyTermCaptureParam(sym)(using ictx)
+
       sym.info
     end typeSig
   }

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

@@ -480,8 +480,8 @@ object RefChecks {
         }
 
       def emitOverrideError(fullmsg: Message) =
-        if (!(hasErrors && member.is(Synthetic) && member.is(Module))) {
-          // suppress errors relating toi synthetic companion objects if other override
+        if (!(hasErrors && member.is(Synthetic) && member.is(Module) || member.isDummyCaptureParam)) {
+          // suppress errors relating to synthetic companion objects if other override
           // errors (e.g. relating to the companion class) have already been reported.
           if (member.owner == clazz) report.error(fullmsg, member.srcPos)
           else mixinOverrideErrors += new MixinOverrideError(member, fullmsg)

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

@@ -162,7 +162,8 @@ trait TypeAssigner {
             // if this fails.
             ctx.javaFindMember(name, pre, lookInCompanion = false)
           else
-            qualType.findMember(name, pre)
+            val excluded = if ctx.mode.is(Mode.InCaptureSet) then EmptyFlags else CaptureParam
+            qualType.findMember(name, pre, excluded = excluded)
 
         if reallyExists(mbr) && NamedType.validPrefix(qualType) then qualType.select(name, mbr)
         else if qualType.isErroneous || name.toTermName == nme.ERROR then UnspecifiedErrorType

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

@@ -626,8 +626,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       val saved2 = foundUnderScala2
       unimported = Set.empty
       foundUnderScala2 = NoType
+      val excluded = if ctx.mode.is(Mode.InCaptureSet) then EmptyFlags else CaptureParam
       try
-        val found = findRef(name, pt, EmptyFlags, EmptyFlags, tree.srcPos)
+        val found = findRef(name, pt, EmptyFlags, excluded, tree.srcPos)
         if foundUnderScala2.exists && !(foundUnderScala2 =:= found) then
           report.migrationWarning(
             em"""Name resolution will change.
@@ -715,11 +716,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         && ctx.owner.owner.unforcedDecls.lookup(tree.name).exists
     then // we are in the arguments of a this(...) constructor call
       errorTree(tree, em"$tree is not accessible from constructor arguments")
-    else if name.isTermName && ctx.mode.is(Mode.InCaptureSet) then
-      // If we are in a capture set and the identifier is not a term name,
-      // try to type it with the same name but as a type
-      // typed(untpd.makeCapsOf(untpd.cpy.Ident(tree)(name.toTypeName)), pt)
-      typed(untpd.cpy.Ident(tree)(name.toTypeName), pt)
     else
       errorTree(tree, MissingIdent(tree, kind, name, pt))
   end typedIdent
@@ -925,13 +921,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         typedCBSelect(tree0, pt, qual)
       else EmptyTree
 
-    // Otherwise, if we are in a capture set, try to type it as a capture variable
-    // reference (as selecting a type name).
-    def trySelectTypeInCaptureSet() =
-      if tree0.name.isTermName && ctx.mode.is(Mode.InCaptureSet) then
-        typedSelectWithAdapt(untpd.cpy.Select(tree0)(qual, tree0.name.toTypeName), pt, qual)
-      else EmptyTree
-
     // Otherwise, report an error
     def reportAnError() =
       assignType(tree,
@@ -953,7 +942,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       .orElse(tryDynamic())
       .orElse(trySelectable())
       .orElse(tryCBCompanion())
-      .orElse(trySelectTypeInCaptureSet())
       .orElse(reportAnError())
   end typedSelectWithAdapt
 
@@ -2543,10 +2531,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
   def typedSingletonTypeTree(tree: untpd.SingletonTypeTree)(using Context): Tree = {
     val ref1 = typedExpr(tree.ref, SingletonTypeProto)
-    // println(i"typed singleton type $ref1 : ${ref1.tpe}, ${ctx.mode.is(Mode.InCaptureSet)}")
-    ref1.tpe match
-      case _: TypeRef if ctx.mode.is(Mode.InCaptureSet) => return ref1
-      case _ =>
+    if ctx.mode.is(Mode.InCaptureSet) && ref1.symbol.is(Flags.CaptureParam) then
+      // println(s"typedSingletonTypeTree: $ref1 -> ${ref1.tpe.widen}")
+      return Ident(ref1.tpe.widen.asInstanceOf[TypeRef]).withSpan(tree.span)
     checkStable(ref1.tpe, tree.srcPos, "singleton type")
     assignType(cpy.SingletonTypeTree(tree)(ref1), ref1)
   }

library/src/scala/annotation/retains.scala

@@ -2,7 +2,7 @@ package scala.annotation
 
 /** An annotation that indicates capture of a set of references under capture checking.
  *
- *      T @retains(x, y, z)
+ *      T @retains[x.type | y.type | z.type]
  *
  *  is the internal representation used for the capturing type
  *
@@ -14,7 +14,7 @@ package scala.annotation
 @experimental
 class retains[Elems] extends annotation.StaticAnnotation
 
-/** Equivalent in meaning to `@retains(cap)`, but consumes less bytecode.
+/** Equivalent in meaning to `@retains[cap.type]`, but consumes less bytecode.
  */
 @experimental
 class retainsCap extends annotation.StaticAnnotation

library/src/scala/caps/package.scala

@@ -88,24 +88,6 @@ sealed trait Exists extends Capability
 @experimental
 object internal:
 
-  /** A wrapper indicating a type variable in a capture argument list of a
-   *  @retains annotation. E.g. `^{x, Y^}` is represented as `@retains(x, capsOf[Y])`.
-   */
-  @compileTimeOnly("Should be be used only internally by the Scala compiler")
-  def capsOf[CS >: CapSet <: CapSet @retainsCap]: Any = ???
-
-  /** Reach capabilities x* which appear as terms in @retains annotations are encoded
-   *  as `caps.reachCapability(x)`. When converted to CaptureRef types in capture sets
-   *  they are  represented as `x.type @annotation.internal.reachCapability`.
-   */
-  extension (x: Any) def reachCapability: Any = x
-
-  /** Read-only capabilities x.rd which appear as terms in @retains annotations are encoded
-   *  as `caps.readOnlyCapability(x)`. When converted to CaptureRef types in capture sets
-   *  they are  represented as `x.type @annotation.internal.readOnlyCapability`.
-   */
-  extension (x: Any) def readOnlyCapability: Any = x
-
   /** An internal annotation placed on a refinement created by capture checking.
    *  Refinements with this annotation unconditionally override any
    *  info from the parent type, so no intersection needs to be formed.

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

@@ -1,17 +1,17 @@
 // No longer valid
 class C
-type Cap = C @retains(caps.cap)
-type Top = Any @retains(caps.cap)
+type Cap = C @retains[caps.cap.type]
+type Top = Any @retains[caps.cap.type]
 
-type T = (x: Cap) => List[String @retains(x)] => Unit // error
-val x: (x: Cap) => Array[String @retains(x)] = ??? // error
+type T = (x: Cap) => List[String @retains[x.type]] => Unit // error
+val x: (x: Cap) => Array[String @retains[x.type]] = ??? // error
 val y = x
 
 def test: Unit =
   def f(x: Cap) = // ok
-    val g = (xs: List[String @retains(x)]) => ()
+    val g = (xs: List[String @retains[x.type]]) => ()
     g
-  def f2(x: Cap)(xs: List[String @retains(x)]) = ()
+  def f2(x: Cap)(xs: List[String @retains[x.type]]) = ()
   val x = f // error
   val x2 = f2 // error
   val y = f(C()) // ok

tests/disabled/neg-custom-args/captures/try2.scala

@@ -5,7 +5,7 @@ import annotation.ability
 @ability erased val canThrow: * = ???
 
 class CanThrow[E <: Exception] extends Retains[canThrow.type]
-type Top  = Any @retains(caps.cap)
+type Top  = Any @retains[caps.cap.type]
 
 infix type throws[R, E <: Exception] = (erased CanThrow[E]) ?=> R
 

tests/neg-custom-args/boxmap.scala

@@ -1,5 +1,5 @@
 import annotation.retains
-type Top = Any @retains(caps.cap)
+type Top = Any @retains[caps.cap.type]
 
 type Box[+T <: Top] = ([K <: Top] -> (T => K) -> K)
 

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

@@ -2,10 +2,10 @@ import annotation.retains
 
 
 class C
-type Cap = C @retains(caps.cap)
+type Cap = C @retains[caps.cap.type]
 class Str
 
 def f(y: Cap, z: Cap) =
-  def g(): C @retains(y, z) = ???
-  val ac: ((x: Cap) => Str @retains(x) => Str @retains(x)) = ???
+  def g(): C @retains[y.type | z.type] = ???
+  val ac: ((x: Cap) => Str @retains[x.type] => Str @retains[x.type]) = ???
   val dc: ((Str^{y, z}) => Str^{y, z}) = ac(g()) // error // error: separatioon

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

@@ -1,11 +1,11 @@
 import annotation.retains
 class C
-type Cap = C @retains(caps.cap)
+type Cap = C @retains[caps.cap.type]
 class Str
 
 def f(y: Cap, z: Cap) =
-  def g(): C @retains(y, z) = ???
-  val ac: ((x: Cap) => Array[Str @retains(x)]) = ???
+  def g(): C @retains[y.type | z.type] = ???
+  val ac: ((x: Cap) => Array[Str @retains[x.type]]) = ???
   val dc = ac(g()) // error: Needs explicit type Array[? >: Str <: {y, z} Str]
                    // This is a shortcoming of rechecking since the originally inferred
                    // type is `Array[Str]` and the actual type after rechecking

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

@@ -2,8 +2,8 @@ import annotation.retains
 import language.experimental.erasedDefinitions
 
 class CT[E <: Exception]
-type CanThrow[E <: Exception] = CT[E] @retains(caps.cap)
-type Top  = Any @retains(caps.cap)
+type CanThrow[E <: Exception] = CT[E] @retains[caps.cap.type]
+type Top  = Any @retains[caps.cap.type]
 
 infix type throws[R, E <: Exception] = (erased CanThrow[E]) ?=> R
 
@@ -14,7 +14,7 @@ def raise[E <: Exception](e: E): Nothing throws E = throw e
 def foo(x: Boolean): Int throws Fail =
   if x then 1 else raise(Fail())
 
-def handle[E <: Exception,  R <: Top](op: (CT[E] @retains(caps.cap)) => R)(handler: E => R): R =
+def handle[E <: Exception,  R <: Top](op: (CT[E] @retains[caps.cap.type]) => R)(handler: E => R): R =
   val x: CT[E] = ???
   try op(x)
   catch case ex: E => handler(ex)

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

@@ -6,6 +6,6 @@ object foo
 
 def test(c: Cap, other: String): Unit =
   val x7: String^{c} = ??? // OK
-  val x8: String @retains(x7 + x7) = ??? // error
-  val x9: String @retains(foo) = ??? // error
+  val x8: String @retains[x7 + x7] = ??? // error
+  val x9: String @retains[foo] = ??? // error
   ()

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

@@ -54,7 +54,7 @@
    |
    | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/capt1.scala:38:13 -------------------------------------------------------------
-38 |  val z3 = h[(() -> Cap) @retains(x)](() => x)(() => C())  // error
+38 |  val z3 = h[(() -> Cap) @retains[x.type]](() => x)(() => C())  // error
    |             ^^^^^^^^^^^^^^^^^^^^^^^
    |             Type variable X of method h cannot be instantiated to box () ->{x} C^ since
    |             the part C^ of that type captures the root capability `cap`.