Various tests and test-fixes for erasedDefinitions feature

natsukagami · natsukagami · commit 27c6866428d3 · 2023-02-27T17:58:42.000+01:00
- Change tests in accordance to new erased parameter Quotes API

- Add quotes test for some erased parameters APIs

- Add tests for Reflect `hasErasedParams`/`erasedParams` and creating an erased method
diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1834,7 +1834,7 @@ object desugar {
             cpy.ByNameTypeTree(parent)(annotate(tpnme.retainsByName, restpt))
           case _ =>
             annotate(tpnme.retains, parent)
-      case f: FunctionWithMods if f.erasedParams.contains(true) => makeFunctionWithValDefs(f, pt)
+      case f: FunctionWithMods if f.hasErasedParams => makeFunctionWithValDefs(f, pt)
     }
     desugared.withSpan(tree.span)
   }
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -80,6 +80,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   class FunctionWithMods(args: List[Tree], body: Tree, val mods: Modifiers, val erasedParams: List[Boolean])(implicit @constructorOnly src: SourceFile)
     extends Function(args, body) {
       assert(args.length == erasedParams.length)
+
+      def hasErasedParams = erasedParams.contains(true)
     }
 
   /** A polymorphic function type */
diff --git a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
@@ -648,11 +648,11 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
     case tp: MethodType =>
       def paramErasure(tpToErase: Type) =
         erasureFn(sourceLanguage, semiEraseVCs, isConstructor, isSymbol, wildcardOK)(tpToErase)
-      val (names, formals0) = if (tp.hasErasedParams)
+      val (names, formals0) = if tp.hasErasedParams then
         tp.paramNames
           .zip(tp.paramInfos)
           .zip(tp.erasedParams)
-          .flatMap((p, e) => if e then None else Some(p))
+          .collect{ case (param, isErased) if !isErased => param }
           .unzip
       else (tp.paramNames, tp.paramInfos)
       val formals = formals0.mapConserve(paramErasure)
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -3734,7 +3734,7 @@ object Types {
             val params = if (hasErasedParams)
               tp.paramInfos
                 .zip(tp.erasedParams)
-                .flatMap((p, e) => if e then None else Some(p))
+                .collect { case (param, isErased) if !isErased => param }
             else tp.paramInfos
             resultSignature.prependTermParams(params, sourceLanguage)
           case tp: PolyType =>
diff --git a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -235,7 +235,6 @@ class PlainPrinter(_ctx: Context) extends Printer {
         changePrec(GlobalPrec) {
           "("
           ~ keywordText("using ").provided(tp.isContextualMethod)
-          ~ keywordText("erased ").provided(tp.isErasedMethod)
           ~ keywordText("implicit ").provided(tp.isImplicitMethod && !tp.isContextualMethod)
           ~ paramsText(tp)
           ~ ")"
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -287,7 +287,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case tp @ FunProto(args, resultType) =>
         "[applied to ("
         ~ keywordText("using ").provided(tp.isContextualMethod)
-        ~ keywordText("erased ").provided(tp.isErasedMethod)
         ~ argsTreeText(args)
         ~ ") returning "
         ~ toText(resultType)
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -1584,9 +1584,9 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         def isErased: Boolean = false
 
         def erasedArgs: List[Boolean] =
-          self.map(param => param.tpe.hasAnnotation(dotc.core.Symbols.defn.ErasedParamAnnot))
+          self.map(_.symbol.is(dotc.core.Flags.Erased))
         def hasErasedArgs: Boolean =
-          self.exists(param => param.tpe.hasAnnotation(dotc.core.Symbols.defn.ErasedParamAnnot))
+          self.exists(_.symbol.is(dotc.core.Flags.Erased))
     end TermParamClauseMethods
 
     type TypeParamClause = List[tpd.TypeDef]
diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala
@@ -2374,7 +2374,7 @@ 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`.
+        // TODO:deprecate in 3.4 and stabilize `erasedArgs` and `hasErasedArgs`.
         // @deprecated("Use `hasErasedArgs`","3.4")
         def isErased: Boolean
 
diff --git a/tests/neg/safeThrowsStrawman2.scala b/tests/neg/safeThrowsStrawman2.scala
@@ -24,7 +24,7 @@ def bar(x: Boolean)(using CanThrow[Fail]): Int =
     val x = new CanThrow[Fail]()      // OK, x is erased
     val y: Any = new CanThrow[Fail]() // error: illegal reference to erased class CanThrow
     val y2: Any = new CTF()       // error: illegal reference to erased class CanThrow
-    println(foo(true, ctf))       // error: ctf is declared as erased, but is in fact used
+    println(foo(true, ctf))       // not error: ctf will be erased at erasure
     val a = (1, new CanThrow[Fail]()) // error: illegal reference to erased class CanThrow
     def b: (Int, CanThrow[Fail]) = ???
     def c = b._2                  // ok; we only check creation sites
diff --git a/tests/run-custom-args/erased/erased-15.scala b/tests/run-custom-args/erased/erased-15.scala
@@ -1,4 +1,4 @@
-import scala.compiletime.ErasedFunction
+import scala.runtime.ErasedFunction
 
 object Test {
 
diff --git a/tests/run-custom-args/erased/erased-27.check b/tests/run-custom-args/erased/erased-27.check
@@ -1,3 +1,2 @@
 block
-x
 foo
diff --git a/tests/run-custom-args/erased/erased-28.check b/tests/run-custom-args/erased/erased-28.check
@@ -1,4 +1,2 @@
-x
 foo
-x
 bar
diff --git a/tests/run-custom-args/erased/erased-class-are-erased.check b/tests/run-custom-args/erased/erased-class-are-erased.check
@@ -0,0 +1 @@
+27
diff --git a/tests/run-custom-args/erased/erased-class-are-erased.scala b/tests/run-custom-args/erased/erased-class-are-erased.scala
@@ -0,0 +1,14 @@
+object Test {
+  erased class Erased() {
+    println("Oh no!!!")
+  }
+
+  def f(x: Erased, y: Int = 0): Int = y + 5
+
+  def g() = Erased()
+
+  def main(args: Array[String]) =
+    val y = Erased()
+    val z = 10
+    println(f(Erased()) + z + f(g(), 7))
+}
diff --git a/tests/run-custom-args/erased/quotes-add-erased.check b/tests/run-custom-args/erased/quotes-add-erased.check
@@ -0,0 +1 @@
+1
diff --git a/tests/run-custom-args/erased/quotes-add-erased/Macro_1.scala b/tests/run-custom-args/erased/quotes-add-erased/Macro_1.scala
@@ -0,0 +1,26 @@
+import scala.annotation.MacroAnnotation
+import scala.annotation.internal.ErasedParam
+import scala.quoted._
+
+class NewAnnotation extends scala.annotation.Annotation
+
+class erasedParamsMethod extends MacroAnnotation:
+  def transform(using Quotes)(tree: quotes.reflect.Definition): List[quotes.reflect.Definition] =
+    import quotes.reflect._
+    tree match
+      case ClassDef(name, ctr, parents, self, body) =>
+        val erasedInt = AnnotatedType(TypeRepr.of[Int], '{ new ErasedParam }.asTerm)
+        val methType = MethodType(List("x", "y"))(_ => List(erasedInt, TypeRepr.of[Int]), _ => TypeRepr.of[Int])
+
+        assert(methType.hasErasedParams)
+        assert(methType.erasedParams == List(true, false))
+
+        val methSym = Symbol.newMethod(tree.symbol, "takesErased", methType, Flags.EmptyFlags, Symbol.noSymbol)
+        val methDef = DefDef(methSym, _ => Some(Literal(IntConstant(1))))
+
+        val clsDef = ClassDef.copy(tree)(name, ctr, parents, self, methDef :: body)
+
+        List(clsDef)
+      case _ =>
+        report.error("Annotation only supports `class`")
+        List(tree)
diff --git a/tests/run-custom-args/erased/quotes-add-erased/Test_2.scala b/tests/run-custom-args/erased/quotes-add-erased/Test_2.scala
@@ -0,0 +1,12 @@
+import scala.language.experimental.erasedDefinitions
+
+class TakesErased {
+  def takesErased(erased x: Int, y: Int): Int = ???
+}
+
+@erasedParamsMethod class Foo extends TakesErased
+
+@main def Test() =
+  val foo = Foo()
+  val v = foo.takesErased(1, 2)
+  println(v)
diff --git a/tests/run-custom-args/erased/quotes-reflection.check b/tests/run-custom-args/erased/quotes-reflection.check
@@ -0,0 +1,10 @@
+method <init>: () isGiven=false isImplicit=false erasedArgs=List()
+method m1: (i: scala.Int) isGiven=true isImplicit=false erasedArgs=List(false)
+method m2: (i: scala.Int) isGiven=false isImplicit=false erasedArgs=List(true)
+method m3: (i: scala.Int, j: scala.Int) isGiven=false isImplicit=false erasedArgs=List(false, true)
+method m4: (i: EC) isGiven=false isImplicit=false erasedArgs=List(true)
+val l1: scala.ContextFunction1[scala.Int, scala.Int]
+val l2: scala.runtime.ErasedFunction with apply: (x$0: scala.Int @scala.annotation.internal.ErasedParam) isImplicit=false erasedParams=List(true)
+val l3: scala.runtime.ErasedFunction with apply: (x$0: scala.Int @scala.annotation.internal.ErasedParam) isImplicit=true erasedParams=List(true)
+val l4: scala.runtime.ErasedFunction with apply: (x$0: scala.Int, x$1: scala.Int @scala.annotation.internal.ErasedParam) isImplicit=false erasedParams=List(false, true)
+val l5: scala.runtime.ErasedFunction with apply: (x$0: EC @scala.annotation.internal.ErasedParam) isImplicit=false erasedParams=List(true)
diff --git a/tests/run-custom-args/erased/quotes-reflection/Macros_1.scala b/tests/run-custom-args/erased/quotes-reflection/Macros_1.scala
@@ -0,0 +1,35 @@
+import scala.quoted.*
+
+inline def inspect[A]: String =
+  ${ inspect2[A] }
+
+def inspect2[A: Type](using Quotes): Expr[String] = {
+  import quotes.reflect.*
+
+  val methods = TypeRepr.of[A].typeSymbol.declarations
+  val names = methods.map { m =>
+    m.tree match
+      case dd @ DefDef(name, params, r, body) =>
+        val paramStr =
+          params.map {
+            case ps: TermParamClause =>
+              val params = ps.params.map(p => s"${p.name}: ${p.tpt.show}").mkString("(", ", ", ")")
+              s"$params isGiven=${ps.isGiven} isImplicit=${ps.isImplicit} erasedArgs=${ps.erasedArgs}"
+            case ps: TypeParamClause => ps.params.map(_.show).mkString("[", ", ", "]")
+          }.mkString("")
+        s"method $name: $paramStr"
+      case vd @ ValDef(name, tpt, body) =>
+        tpt.tpe match
+          case Refinement(parent, "apply", tpe: MethodType) if parent == defn.ErasedFunctionClass.typeRef =>
+            assert(tpt.tpe.isErasedFunctionType)
+
+            val params = tpe.paramNames.zip(tpe.paramTypes).map((n, t) => s"$n: ${t.show}").mkString("(", ", ", ")")
+            s"val $name: ${parent.show} with apply: ${params} isImplicit=${tpe.isImplicit} erasedParams=${tpe.erasedParams}"
+          case _ =>
+            s"val $name: ${tpt.show}"
+      case td @ TypeDef(name, tpt) => s"type $name: ${tpt.show}"
+      case _ => s"something else: $m"
+  }
+
+  Expr(names.mkString("\n"))
+}
diff --git a/tests/run-custom-args/erased/quotes-reflection/Test_2.scala b/tests/run-custom-args/erased/quotes-reflection/Test_2.scala
@@ -0,0 +1,20 @@
+import scala.language.experimental.erasedDefinitions
+
+erased class EC
+
+trait X {
+  def m1(using i: Int): Int
+  def m2(erased i: Int): Int
+  def m3(i: Int, erased j: Int): Int
+  def m4(i: EC): Int
+
+  val l1 = (x: Int) ?=> 5
+  val l2 = (erased x: Int) => 5
+  val l3 = (erased x: Int) ?=> 5
+  val l4 = (x: Int, erased y: Int) => 5
+  val l5 = (x: EC) => 5
+}
+
+@main def Test = {
+  println(inspect[X])
+}
diff --git a/tests/run-custom-args/run-macros-erased/macro-erased/1.scala b/tests/run-custom-args/run-macros-erased/macro-erased/1.scala
@@ -13,8 +13,8 @@ object Macro {
   def case1(erased i: Expr[Int])(using Quotes): Expr[Int] = '{ 0 }
   def case2 (i: Int)(erased j: Expr[Int])(using Quotes): Expr[Int] = '{ 0 }
   def case3(erased i: Expr[Int]) (j: Int)(using Quotes): Expr[Int] = '{ 0 }
-  def case4 (h: Int)(erased i: Expr[Int], j: Expr[Int])(using Quotes): Expr[Int] = '{ 0 }
-  def case5(erased i: Expr[Int], j: Expr[Int]) (h: Int)(using Quotes): Expr[Int] = '{ 0 }
+  def case4 (h: Int)(erased i: Expr[Int], erased j: Expr[Int])(using Quotes): Expr[Int] = '{ 0 }
+  def case5(erased i: Expr[Int], erased j: Expr[Int]) (h: Int)(using Quotes): Expr[Int] = '{ 0 }
   def case6 (h: Int)(erased i: Expr[Int])(erased j: Expr[Int])(using Quotes): Expr[Int] = '{ 0 }
   def case7(erased i: Expr[Int]) (h: Int)(erased j: Expr[Int])(using Quotes): Expr[Int] = '{ 0 }
   def case8(erased i: Expr[Int])(erased j: Expr[Int]) (h: Int)(using Quotes): Expr[Int] = '{ 0 }
diff --git a/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala b/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala
@@ -81,6 +81,12 @@ val experimentalDefinitionInLibrary = Set(
   "scala.quoted.Quotes.reflectModule.SymbolModule.newModule",
   "scala.quoted.Quotes.reflectModule.SymbolModule.freshName",
   "scala.quoted.Quotes.reflectModule.SymbolMethods.info",
+  // Quotes for functions with erased parameters.
+  "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",
 
   // New feature: functions with erased parameters.
   // Need erasedDefinitions enabled.
diff --git a/tests/run-macros/i12021.check b/tests/run-macros/i12021.check
@@ -1,3 +1,5 @@
-X1: (i: scala.Int) isImplicit=true, isGiven=false, isErased=false
-X2: (i: scala.Int) isImplicit=false, isGiven=true, isErased=false
-X3: (i: scala.Int) isImplicit=false, isGiven=false, isErased=true
+X1: (i: scala.Int) isImplicit=true, isGiven=false, erasedArgs=List(false)
+X2: (i: scala.Int) isImplicit=false, isGiven=true, erasedArgs=List(false)
+X3: (i: scala.Int) isImplicit=false, isGiven=false, erasedArgs=List(true)
+X4: (i: scala.Int, j: scala.Int) isImplicit=false, isGiven=false, erasedArgs=List(false, true)
+X5: (i: EC) isImplicit=false, isGiven=false, erasedArgs=List(true)
diff --git a/tests/run-macros/i12021/Macro_1.scala b/tests/run-macros/i12021/Macro_1.scala
@@ -14,5 +14,5 @@ def inspect2[A: Type](using Quotes): Expr[String] = {
 
   val names = ps.params.map(p => s"${p.name}: ${p.tpt.show}").mkString("(", ", ", ")")
 
-  Expr(s"${Type.show[A]}: $names isImplicit=${ps.isImplicit}, isGiven=${ps.isGiven}, isErased=${ps.isErased}")
+  Expr(s"${Type.show[A]}: $names isImplicit=${ps.isImplicit}, isGiven=${ps.isGiven}, erasedArgs=${ps.erasedArgs}")
 }
diff --git a/tests/run-macros/i12021/Test_2.scala b/tests/run-macros/i12021/Test_2.scala
@@ -1,11 +1,17 @@
 import scala.language.experimental.erasedDefinitions
 
+erased class EC
+
 class X1(implicit i: Int)
 class X2(using i: Int)
 class X3(erased i: Int)
+class X4(i: Int, erased j: Int)
+class X5(i: EC)
 
 @main def Test = {
   println(inspect[X1])
   println(inspect[X2])
   println(inspect[X3])
-}
+  println(inspect[X4])
+  println(inspect[X5])
+}
diff --git a/tests/run-macros/tasty-definitions-1.check b/tests/run-macros/tasty-definitions-1.check
@@ -108,7 +108,7 @@ ContextFunction24
 ContextFunction24
 ContextFunction25
 ContextFunction25
-class java.lang.Exception: Erased function classes are not supported. Use a refined `ErasedFunctionClass`
+class java.lang.Exception: Erased function classes are not supported. Use a refined `scala.runtime.ErasedFunction`
 ErasedFunction
 Tuple2
 Tuple3

Original file line number	Diff line number	Diff line change
`@@ -1834,7 +1834,7 @@ object desugar {`
`1834`	`1834`	`cpy.ByNameTypeTree(parent)(annotate(tpnme.retainsByName, restpt))`
`1835`	`1835`	`case _ =>`
`1836`	`1836`	`annotate(tpnme.retains, parent)`
`1837`		`- case f: FunctionWithMods if f.erasedParams.contains(true) => makeFunctionWithValDefs(f, pt)`
	`1837`	`+ case f: FunctionWithMods if f.hasErasedParams => makeFunctionWithValDefs(f, pt)`
`1838`	`1838`	`}`
`1839`	`1839`	`desugared.withSpan(tree.span)`
`1840`	`1840`	`}`
Original file line number	Diff line number	Diff line change
`@@ -80,6 +80,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {`
`80`	`80`	`class FunctionWithMods(args: List[Tree], body: Tree, val mods: Modifiers, val erasedParams: List[Boolean])(implicit @constructorOnly src: SourceFile)`
`81`	`81`	`extends Function(args, body) {`
`82`	`82`	`assert(args.length == erasedParams.length)`
	`83`	`+`
	`84`	`+ def hasErasedParams = erasedParams.contains(true)`
`83`	`85`	`}`
`84`	`86`
`85`	`87`	`/** A polymorphic function type */`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-import scala.compiletime.ErasedFunction`
	`1`	`+import scala.runtime.ErasedFunction`
`2`	`2`
`3`	`3`	`object Test {`
`4`	`4`