Erased parameters/functions quotes API changes

- `isErased` => `erasedArgs`/`erasedParams` and `hasErasedArgs`/`hasErasedParams`
- `FunctionClass` now fails when `isErased = true`. Add `ErasedFunctionClass`.

Author: natsukagami

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -1581,8 +1581,12 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           self.nonEmpty && self.head.symbol.is(dotc.core.Flags.Implicit)
         def isGiven: Boolean =
           self.nonEmpty && self.head.symbol.is(dotc.core.Flags.Given)
-        def isErased: Boolean =
-          self.nonEmpty && self.head.symbol.is(dotc.core.Flags.Erased)
+        def isErased: Boolean = false
+
+        def erasedArgs: List[Boolean] =
+          self.map(param => param.tpe.hasAnnotation(dotc.core.Symbols.defn.ErasedParamAnnot))
+        def hasErasedArgs: Boolean =
+          self.exists(param => param.tpe.hasAnnotation(dotc.core.Symbols.defn.ErasedParamAnnot))
     end TermParamClauseMethods
 
     type TypeParamClause = List[tpd.TypeDef]
@@ -2139,9 +2143,12 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     given MethodTypeMethods: MethodTypeMethods with
       extension (self: MethodType)
-        def isErased: Boolean = self.hasErasedParams
+        def isErased: Boolean = false
         def isImplicit: Boolean = self.isImplicitMethod
         def param(idx: Int): TypeRepr = self.newParamRef(idx)
+
+        def erasedParams: List[Boolean] = self.erasedParams
+        def hasErasedParams: Boolean = self.hasErasedParams
       end extension
     end MethodTypeMethods
 
@@ -2768,13 +2775,14 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def ProductClass: Symbol = dotc.core.Symbols.defn.ProductClass
       def FunctionClass(arity: Int, isImplicit: Boolean = false, isErased: Boolean = false): Symbol =
         if arity < 0 then throw IllegalArgumentException(s"arity: $arity")
-        if isErased
-        then dotc.core.Symbols.defn.ErasedFunctionClass
+        if isErased then
+          throw new Exception("Erased function classes are not supported. Use a refined `scala.runtime.ErasedFunction`")
         else dotc.core.Symbols.defn.FunctionSymbol(arity, isImplicit)
       def FunctionClass(arity: Int): Symbol =
         FunctionClass(arity, false, false)
       def FunctionClass(arity: Int, isContextual: Boolean): Symbol =
         FunctionClass(arity, isContextual, false)
+      def ErasedFunctionClass = dotc.core.Symbols.defn.ErasedFunctionClass
       def TupleClass(arity: Int): Symbol =
         dotc.core.Symbols.defn.TupleType(arity).nn.classSymbol.asClass
       def isTupleClass(sym: Symbol): Boolean =

library/src/scala/quoted/Quotes.scala

@@ -2374,7 +2374,16 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
         /** Is this a given parameter clause `(using X1, ..., Xn)` or `(using x1: X1, ..., xn: Xn)` */
         def isGiven: Boolean
         /** Is this a erased parameter clause `(erased x1: X1, ..., xn: Xn)` */
+        // TODO:deprecate in 3.4 and stabilize `erasedParams` and `hasErasedParams`.
+        // @deprecated("Use `hasErasedArgs`","3.4")
         def isErased: Boolean
+
+        /** List of `erased` flags for each parameter of the clause */
+        @experimental
+        def erasedArgs: List[Boolean]
+        /** Whether the clause has any erased parameters */
+        @experimental
+        def hasErasedArgs: Boolean
     end TermParamClauseMethods
 
     /** A type parameter clause `[X1, ..., Xn]` */
@@ -2650,7 +2659,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
         */
         def isContextFunctionType: Boolean
 
-        /** Is this type an erased function type?
+        /** Is this type a function type with erased parameters?
         *
         *  @see `isFunctionType`
         */
@@ -3145,7 +3154,17 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       extension (self: MethodType)
         /** Is this the type of using parameter clause `(implicit X1, ..., Xn)`, `(using X1, ..., Xn)` or `(using x1: X1, ..., xn: Xn)` */
         def isImplicit: Boolean
+        /** Is this the type of erased parameter clause `(erased x1: X1, ..., xn: Xn)` */
+        // TODO:deprecate in 3.4 and stabilize `erasedParams` and `hasErasedParams`.
+        // @deprecated("Use `hasErasedParams`","3.4")
         def isErased: Boolean
+
+        /** List of `erased` flags for each parameters of the clause */
+        @experimental
+        def erasedParams: List[Boolean]
+        /** Whether the clause has any erased parameters */
+        @experimental
+        def hasErasedParams: Boolean
         def param(idx: Int): TypeRepr
       end extension
     end MethodTypeMethods
@@ -4275,6 +4294,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       @experimental
       def FunctionClass(arity: Int, isContextual: Boolean): Symbol
 
+      /** The `scala.runtime.ErasedFunction` built-in trait. */
+      @experimental
+      def ErasedFunctionClass: Symbol
+
       /** Function-like object that maps arity to symbols for classes `scala.TupleX`.
       *   -  0th element is `NoSymbol`
       *   -  1st element is `NoSymbol`

tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala

@@ -84,7 +84,12 @@ val experimentalDefinitionInLibrary = Set(
 
   // New feature: functions with erased parameters.
   // Need erasedDefinitions enabled.
-  "scala.compiletime.ErasedFunction"
+  "scala.runtime.ErasedFunction",
+  "scala.quoted.Quotes.reflectModule.MethodTypeMethods.erasedParams",
+  "scala.quoted.Quotes.reflectModule.MethodTypeMethods.hasErasedParams",
+  "scala.quoted.Quotes.reflectModule.TermParamClauseMethods.erasedArgs",
+  "scala.quoted.Quotes.reflectModule.TermParamClauseMethods.hasErasedArgs",
+  "scala.quoted.Quotes.reflectModule.defnModule.ErasedFunctionClass"
 )
 
 

tests/run-macros/tasty-definitions-1.check

@@ -108,56 +108,8 @@ ContextFunction24
 ContextFunction24
 ContextFunction25
 ContextFunction25
-ErasedFunction1
-ErasedFunction2
-ErasedFunction3
-ErasedFunction4
-ErasedFunction5
-ErasedFunction6
-ErasedFunction7
-ErasedFunction8
-ErasedFunction9
-ErasedFunction10
-ErasedFunction11
-ErasedFunction12
-ErasedFunction13
-ErasedFunction14
-ErasedFunction15
-ErasedFunction16
-ErasedFunction17
-ErasedFunction18
-ErasedFunction19
-ErasedFunction20
-ErasedFunction21
-ErasedFunction22
-ErasedFunction23
-ErasedFunction24
-ErasedFunction25
-ErasedContextFunction1
-ErasedContextFunction2
-ErasedContextFunction3
-ErasedContextFunction4
-ErasedContextFunction5
-ErasedContextFunction6
-ErasedContextFunction7
-ErasedContextFunction8
-ErasedContextFunction9
-ErasedContextFunction10
-ErasedContextFunction11
-ErasedContextFunction12
-ErasedContextFunction13
-ErasedContextFunction14
-ErasedContextFunction15
-ErasedContextFunction16
-ErasedContextFunction17
-ErasedContextFunction18
-ErasedContextFunction19
-ErasedContextFunction20
-ErasedContextFunction21
-ErasedContextFunction22
-ErasedContextFunction23
-ErasedContextFunction24
-ErasedContextFunction25
+class java.lang.Exception: Erased function classes are not supported. Use a refined `ErasedFunctionClass`
+ErasedFunction
 Tuple2
 Tuple3
 Tuple4

tests/run-macros/tasty-definitions-1/quoted_1.scala

@@ -63,11 +63,10 @@ object Macros {
       printout(defn.FunctionClass(i, isContextual = true).name)
       printout(defn.FunctionClass(i, isImplicit = true).name)
 
-    for (i <- 1 to 25)
-      printout(defn.FunctionClass(i, isErased = true).name)
+    // should fail
+    printout(defn.FunctionClass(1, isErased = true).name)
 
-    for (i <- 1 to 25)
-      printout(defn.FunctionClass(i, isImplicit = true, isErased = true).name)
+    printout(defn.ErasedFunctionClass.name)
 
     for (i <- 2 to 22)
       printout(defn.TupleClass(i).name)