Drop remaining references to use.

Author: odersky

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

@@ -719,7 +719,7 @@ extension (sym: Symbol) {
     sym.is(TypeParam) && sym.info.derivesFromCapSet
 
   /** `sym` or its info is annotated with `@consume`. */
-  def isConsumeParam(using Context): Boolean =
+  def isConsume(using Context): Boolean =
     sym.hasAnnotation(defn.ConsumeAnnot)
     || sym.info.hasAnnotation(defn.ConsumeAnnot)
 

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

@@ -571,8 +571,7 @@ class CheckCaptures extends Recheck, SymTransformer:
     /** Type arguments come either from a TypeApply node or from an AppliedType
      *  which represents a trait parent in a template.
      *   - Disallow GlobalCaps and ResultCaps in such arguments.
-     *   - If a corresponding formal type parameter is declared or implied @use,
-     *     charge the deep capture set of the argument to the environent.
+     *   - Charge the deep capture sets of arguments to capset parameters.
      *  @param  fn   the type application, of type TypeApply or TypeTree
      *  @param  sym  the constructor symbol (could be a method or a val or a class)
      *  @param  args the type arguments
@@ -777,9 +776,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         res
 
     /** Recheck argument against an instantiated version of `formal` where toplevel `any`
-     *  occurrences are replaced by LocalCap instances. Also, if formal parameter carries a `@use`
-     *  or @consume, charge the deep capture set of the actual argument to the environment.
-     *  TODO: Maybe not charge deep capture sets for consume?
+     *  occurrences are replaced by LocalCap instances.
      */
     protected override def recheckArg(arg: Tree, formal: Type, pref: ParamRef, app: Apply)(using Context): Type =
       val meth = app.fun.symbol
@@ -791,9 +788,10 @@ class CheckCaptures extends Recheck, SymTransformer:
       val argType = recheck(arg, instantiatedFormal)
         .showing(i"recheck arg $arg vs $instantiatedFormal = $result", capt)
       if formal.hasAnnotation(defn.ConsumeAnnot) then
-        // The @use and/or @consume annotation is added to `formal` when creating methods types.
+        // The @consume annotation is added to `formal` when creating methods types.
         // See [[MethodTypeCompanion.adaptParamInfo]].
-        // TODO: Needed?
+        // We need to charge the deep capture set because to inform SepCheck which set
+        // is consumed.
         capt.println(i"charging deep capture set of $arg: ${argType} = ${argType.deepCaptureSet}")
         markFree(argType.deepCaptureSet, arg)
       if formal.containsGlobalAny then
@@ -809,8 +807,7 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  ---------------------
      *  E |- f(a): Tr^C
      *
-     *  If the function `f` does not have an `@use` parameter, then
-     *  any unboxing it does would be charged to the environment of the function
+     *  Any unboxing of function `f` would be charged to the environment of the function
      *  so they have to appear in Cq. Since any capabilities of the result of the
      *  application must already be present in the application, an upper
      *  approximation of the result capture set is Cq \union Ca, where `Ca`
@@ -2010,8 +2007,8 @@ class CheckCaptures extends Recheck, SymTransformer:
           case _ =>
             actual
       else
-        // Compute the widened type. Drop `@use` and `@consume` annotations from the type,
-        // since they obscures the capturing type.
+        // Compute the widened type. Drop `@consume` annotations from the type,
+        // since they obscure the capturing type.
         val widened = actual.widen.dealiasKeepAnnots.dropAnnot(defn.ConsumeAnnot)
         val improvedVAR = improveCaptures(widened, actual)
         val adaptedReadOnly = adaptReadOnly(improvedVAR, actual, expected, tree)
@@ -2090,7 +2087,7 @@ class CheckCaptures extends Recheck, SymTransformer:
 
         override def checkInheritedTraitParameters: Boolean = false
 
-        /** Check that overrides don't change the @use, @consume, or @reserve status of their parameters */
+        /** Check that overrides don't change the @consume status of their parameters */
         override def additionalChecks(member: Symbol, other: Symbol)(using Context): Unit =
           for
             (params1, params2) <- member.rawParamss.lazyZip(other.rawParamss)

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

@@ -695,7 +695,7 @@ class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser:
             if currentOwner.enclosingMethodOrClassOrObject.isProperlyContainedIn(refSym.enclosingMethodOrClassOrObject) then
               report.error(em"""Separation failure: $descr non-local $refSym""", pos)
             else if refSym.is(TermParam)
-              && !refSym.isConsumeParam
+              && !refSym.isConsume
               && currentOwner.isContainedIn(refSym.owner)
             then
               badParams += refSym
@@ -1052,7 +1052,7 @@ class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser:
     if !isUnsafeAssumeSeparate(tree) then trace(i"checking separate $tree"):
       checkUse(tree)
       tree match
-        case tree @ Select(qual, _) if tree.symbol.is(Method) && tree.symbol.isConsumeParam =>
+        case tree @ Select(qual, _) if tree.symbol.is(Method) && tree.symbol.isConsume =>
           traverseChildren(tree)
           checkConsumedRefs(
               spanCaptures(qual).directFootprint.nonPeaks, qual.nuType,

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

@@ -864,9 +864,8 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
       case _ =>
     end postProcess
 
-    /** Check that @use and @consume annotations only appear on parameters and not on
-     *  anonymous function parameters. Check that @use annotations don't appear
-     *  at all from 3.8 on.
+    /** Check that @consume annotations only appear on parameters and not on
+     *  anonymous function parameters.
      */
     def checkProperConsume(tree: Tree)(using Context): Unit = tree match
       case tree: MemberDef =>
@@ -884,6 +883,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
                     |can have a consume modifier.""",
                 tree.srcPos)
       case _ =>
+
   end setupTraverser
 
 // --------------- Adding capture set variables ----------------------------------

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

@@ -7,7 +7,7 @@ import config.{Feature, SourceVersion}
 
 object ccConfig:
 
-  /** If enabled, cache capture sets of infos capabilities */
+  /** If enabled, cache capture sets of infos of capabilities */
   inline val cacheCaptureSetOfInfo = false
 
   /** If this and `preTypeClosureResults` are both enabled, disable `preTypeClosureResults`
@@ -50,10 +50,6 @@ object ccConfig:
   def newScheme(using ctx: Context): Boolean =
     Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.10`)
 
-  /** Allow @use annotations */
-  def allowUse(using Context): Boolean =
-    Feature.sourceVersion.stable.isAtMost(SourceVersion.`3.7`)
-
   /** Treat arrays as mutable types and force all mutable fields to be in Stateful
    *  classes, unless they are annotated with @untrackedCaptures.
    *  Enabled under separation checking