Fix reflect-printing of given and erased flags

Author: odersky

compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala

@@ -1647,13 +1647,15 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
   /** Intersection of the two flag sets */
   def Flags_and(self: Flags)(that: Flags): Flags = self & that
 
+  def Flags_EmptyFlags: Flags = core.Flags.EmptyFlags
   def Flags_Private: Flags = core.Flags.Private
   def Flags_Protected: Flags = core.Flags.Protected
   def Flags_Abstract: Flags = core.Flags.Abstract
   def Flags_Final: Flags = core.Flags.Final
   def Flags_Sealed: Flags = core.Flags.Sealed
   def Flags_Case: Flags = core.Flags.Case
   def Flags_Implicit: Flags = core.Flags.Implicit
+  def Flags_Given: Flags = core.Flags.Given
   def Flags_Implied: Flags = core.Flags.Implied
   def Flags_Erased: Flags = core.Flags.Erased
   def Flags_Lazy: Flags = core.Flags.Lazy

library/src/scala/tasty/reflect/FlagsOps.scala

@@ -17,6 +17,9 @@ trait FlagsOps extends Core {
 
   object Flags {
 
+    /** The empty set of flags */
+    def EmptyFlags = kernel.Flags_EmptyFlags
+
     /** Is this symbol `private` */
     def Private: Flags = kernel.Flags_Private
 
@@ -38,7 +41,10 @@ trait FlagsOps extends Core {
     /** Is this symbol `implicit` */
     def Implicit: Flags = kernel.Flags_Implicit
 
-    /** Is this symbol `erased` */
+    /** Is this symbol an inferable ("given") parameter */
+    def Given: Flags = kernel.Flags_Given
+
+     /** Is this symbol `erased` */
     def Erased: Flags = kernel.Flags_Erased
 
     /** Is this symbol `lazy` */

library/src/scala/tasty/reflect/Kernel.scala

@@ -1338,13 +1338,15 @@ trait Kernel {
   /** Intersection of the two flag sets */
   def Flags_and(self: Flags)(that: Flags): Flags
 
+  def Flags_EmptyFlags: Flags
   def Flags_Private: Flags
   def Flags_Protected: Flags
   def Flags_Abstract: Flags
   def Flags_Final: Flags
   def Flags_Sealed: Flags
   def Flags_Case: Flags
   def Flags_Implicit: Flags
+  def Flags_Given: Flags
   def Flags_Implied: Flags
   def Flags_Erased: Flags
   def Flags_Lazy: Flags

library/src/scala/tasty/reflect/Printers.scala

@@ -1203,24 +1203,30 @@ trait Printers
         }
       }
 
-      def printArgsDefs(args: List[ValDef])(implicit elideThis: Option[Symbol]): Unit = inParens {
-        args match {
-          case Nil =>
-          case arg :: _ =>
-            if (arg.symbol.flags.is(Flags.Erased)) this += "erased "
-            if (arg.symbol.flags.is(Flags.Implicit)) this += "implicit "
+      def printArgsDefs(args: List[ValDef])(implicit elideThis: Option[Symbol]): Unit = {
+        val argFlags = args match {
+          case Nil => Flags.EmptyFlags
+          case arg :: _ => arg.symbol.flags
         }
-
-        def printSeparated(list: List[ValDef]): Unit = list match {
-          case Nil =>
-          case x :: Nil => printParamDef(x)
-          case x :: xs =>
-            printParamDef(x)
-            this += ", "
-            printSeparated(xs)
+        if (argFlags.is(Flags.Erased | Flags.Given)) {
+          if (argFlags.is(Flags.Given)) this += " given"
+          if (argFlags.is(Flags.Erased)) this += " erased"
+          this += " "
         }
+        inParens {
+          if (argFlags.is(Flags.Implicit) && !argFlags.is(Flags.Given)) this += "implicit "
 
-        printSeparated(args)
+          def printSeparated(list: List[ValDef]): Unit = list match {
+            case Nil =>
+            case x :: Nil => printParamDef(x)
+            case x :: xs =>
+              printParamDef(x)
+              this += ", "
+              printSeparated(xs)
+          }
+
+          printSeparated(args)
+        }
       }
 
       def printAnnotations(trees: List[Term])(implicit elideThis: Option[Symbol]): Buffer = {

tests/neg/erased-implicit.scala

@@ -5,4 +5,6 @@ object Test {
   def fun(implicit a: Double): Int = 42
 
   erased implicit def doubleImplicit: Double = 42.0
+
+  def foo erased (implicit a: Double) = 42   // error
 }