Check that @use annotations only appear for method and class parameters

Author: odersky

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

@@ -495,6 +495,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         case _ =>
           traverseChildren(tree)
       postProcess(tree)
+      checkProperUse(tree)
     end traverse
 
     def postProcess(tree: Tree)(using Context): Unit = tree match
@@ -637,6 +638,16 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           case _ =>
       case _ =>
     end postProcess
+
+    def checkProperUse(tree: Tree)(using Context): Unit = tree match
+      case tree: MemberDef =>
+        def useAllowed(sym: Symbol) =
+          (sym.is(Param) || sym.is(ParamAccessor)) && !sym.owner.isAnonymousFunction
+        for ann <- tree.symbol.annotations do
+          if ann.symbol == defn.UseAnnot && !useAllowed(tree.symbol) then
+            report.error(i"Only parameters of methods can have @use annotations", tree.srcPos)
+      case _ =>
+    end checkProperUse
   end setupTraverser
 
   /** Checks whether an abstract type could be impure. See also: [[needsVariable]]. */

tests/neg-custom-args/captures/bad-uses-2.scala

@@ -0,0 +1,6 @@
+import caps.use
+class Test:
+  @use def F = ???  // error
+  @use val x = ???  // error
+  @use type T       // error
+  def foo(@use c: Test): Unit = ??? // OK

tests/neg-custom-args/captures/bad-uses.scala

@@ -0,0 +1,3 @@
+import caps.use
+class Test:
+  val bar = (@use c: Test) => () // error

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

@@ -0,0 +1,10 @@
+import language.experimental.namedTuples
+
+class A:
+  type T
+
+class B extends A
+
+val f: (x: A) => x.T = ???
+val g: (x: B) => x.T = f // OK
+val h: (x: A) => x.T = g // error

tests/pending/pos/function-contravariance.scala

@@ -9,5 +9,5 @@ class Resource[T <: Capability](gen: T):
 
 @main def run =
   val myFile: File = ???
-  val r = Resource(myFile) // error
+  val r = Resource(myFile) // now ok, was error
   ()