Fix #8856: Keep transparent flag

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -196,7 +196,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     case class Inline()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Inline)
 
-    case class Transparent()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.EmptyFlags)
+    case class Transparent()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Transparent)
   }
 
   /** Modifiers and annotations for definitions

compiler/src/dotty/tools/dotc/core/Flags.scala

@@ -347,8 +347,11 @@ object Flags {
   /** Labeled with `erased` modifier (erased value)  */
   val (_, Erased @ _, _) = newFlags(42, "erased")
 
+  /** Labelled with `transparent` modifier */
+  val (Transparent @ _, _, _) = newFlags(43, "transparent")
+
   /** An opaque type alias or a class containing one */
-  val (Opaque @ _, _, _) = newFlags(43, "opaque")
+  val (Opaque @ _, _, _) = newFlags(44, "opaque")
 
 
   // ------------ Flags following this one are not pickled ----------------------------------

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -865,8 +865,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     if (rawFlags.is(Param)) flagMask = flagMask &~ Given
     val flags = rawFlags & flagMask
     var flagsText = toTextFlags(sym, flags)
-    if mods.hasMod(classOf[untpd.Mod.Transparent]) then
-      flagsText = "transparent " ~ flagsText
     val annotations =
       if (sym.exists) sym.annotations.filterNot(ann => dropAnnotForModText(ann.symbol)).map(_.tree)
       else mods.annotations.filterNot(tree => dropAnnotForModText(tree.symbol))

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

@@ -1847,6 +1847,7 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   def Flags_Lazy: Flags = core.Flags.Lazy
   def Flags_Override: Flags = core.Flags.Override
   def Flags_Inline: Flags = core.Flags.Inline
+  def Flags_Transparent: Flags = core.Flags.Transparent
   def Flags_Macro: Flags = core.Flags.Macro
   def Flags_Static: Flags = core.Flags.JavaStatic
   def Flags_JavaDefined: Flags = core.Flags.JavaDefined

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -866,7 +866,7 @@ class Namer { typer: Typer =>
       case original: untpd.DefDef if sym.isInlineMethod =>
         def rhsToInline(using Context): tpd.Tree =
           val mdef = typedAheadExpr(original).asInstanceOf[tpd.DefDef]
-          PrepareInlineable.wrapRHS(original, mdef.tpt, mdef.rhs)
+          PrepareInlineable.wrapRHS(sym, mdef.tpt, mdef.rhs)
         PrepareInlineable.registerInlineInfo(sym, rhsToInline)(using localContext(sym))
       case _ =>
     }

compiler/src/dotty/tools/dotc/typer/PrepareInlineable.scala

@@ -204,9 +204,9 @@ object PrepareInlineable {
   def isLocal(sym: Symbol, inlineMethod: Symbol)(using Context): Boolean =
     isLocalOrParam(sym, inlineMethod) && !(sym.is(Param) && sym.owner == inlineMethod)
 
-  /** The type ascription `rhs: tpt`, unless `original` is `transparent`. */
-  def wrapRHS(original: untpd.DefDef, tpt: Tree, rhs: Tree)(using Context): Tree =
-    if original.mods.hasMod(classOf[untpd.Mod.Transparent]) then rhs
+  /** The type ascription `rhs: tpt`, unless `sym` is `transparent`. */
+  def wrapRHS(sym: Symbol, tpt: Tree, rhs: Tree)(using Context): Tree =
+    if sym.is(Transparent) then rhs
     else Typed(rhs, tpt)
 
   /** Register inline info for given inlineable method `sym`.

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1865,7 +1865,7 @@ class Typer extends Namer
 
     if (sym.isInlineMethod) rhsCtx.addMode(Mode.InlineableBody)
     val rhs1 = typedExpr(ddef.rhs, tpt1.tpe.widenExpr)(using rhsCtx)
-    val rhsToInline = PrepareInlineable.wrapRHS(ddef, tpt1, rhs1)
+    val rhsToInline = PrepareInlineable.wrapRHS(sym, tpt1, rhs1)
 
     if (sym.isInlineMethod)
       PrepareInlineable.registerInlineInfo(sym, rhsToInline)

library/src/scala/tasty/Reflection.scala

@@ -2607,6 +2607,9 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     /** Is this symbol `inline` */
     def Inline: Flags = internal.Flags_Inline
 
+    /** Is this symbol a `transparent` */
+    def Transparent: Flags = internal.Flags_Transparent
+
     /** Is this symbol marked as a macro. An inline method containing toplevel splices */
     def Macro: Flags = internal.Flags_Macro
 

library/src/scala/tasty/reflect/CompilerInterface.scala

@@ -1397,6 +1397,7 @@ trait CompilerInterface {
   def Flags_Lazy: Flags
   def Flags_Override: Flags
   def Flags_Inline: Flags
+  def Flags_Transparent: Flags
   def Flags_Macro: Flags
   def Flags_Static: Flags
   def Flags_JavaDefined: Flags

library/src/scala/tasty/reflect/SourceCodePrinter.scala

@@ -34,6 +34,7 @@ class SourceCodePrinter[R <: Reflection & Singleton](val tasty: R)(syntaxHighlig
     if (flags.is(Flags.Lazy)) flagList += "lazy"
     if (flags.is(Flags.Override)) flagList += "override"
     if (flags.is(Flags.Inline)) flagList += "inline"
+    if (flags.is(Flags.Transparent)) flagList += "transparent"
     if (flags.is(Flags.Macro)) flagList += "macro"
     if (flags.is(Flags.JavaDefined)) flagList += "javaDefined"
     if (flags.is(Flags.Static)) flagList += "javaStatic"

tasty/src/dotty/tools/tasty/TastyFormat.scala

@@ -248,7 +248,7 @@ Standard Section: "Comments" Comment*
 object TastyFormat {
 
   final val header: Array[Int] = Array(0x5C, 0xA1, 0xAB, 0x1F)
-  val MajorVersion: Int = 22
+  val MajorVersion: Int = 23
   val MinorVersion: Int = 0
 
   /** Tags used to serialize names, should update [[nameTagToString]] if a new constant is added */