Introduce Transparent flag

Let the `transparent` modifier translate to it. allow `transparent` on traits and
inline methods only.

Author: odersky

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

@@ -212,7 +212,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

@@ -342,6 +342,9 @@ object Flags {
   /** Symbol is a Java default method */
   val (_, DefaultMethod @ _, _) = newFlags(38, "<defaultmethod>")
 
+  /** Symbol is a transparent inline method or trait */
+  val (Transparent @ _, _, _) = newFlags(39, "transparent")
+
   /** Symbol is an enum class or enum case (if used with case) */
   val (Enum @ _, EnumVal @ _, _) = newFlags(40, "enum")
 
@@ -419,7 +422,7 @@ object Flags {
 
   /** Flags representing source modifiers */
   private val CommonSourceModifierFlags: FlagSet =
-    commonFlags(Private, Protected, Final, Case, Implicit, Given, Override, JavaStatic)
+    commonFlags(Private, Protected, Final, Case, Implicit, Given, Override, JavaStatic, Transparent)
 
   val TypeSourceModifierFlags: FlagSet =
     CommonSourceModifierFlags.toTypeFlags | Abstract | Sealed | Opaque | Open
@@ -449,7 +452,7 @@ object Flags {
    *  is completed)
    */
   val AfterLoadFlags: FlagSet = commonFlags(
-    FromStartFlags, AccessFlags, Final, AccessorOrSealed, LazyOrTrait, SelfName, JavaDefined)
+    FromStartFlags, AccessFlags, Final, AccessorOrSealed, LazyOrTrait, SelfName, JavaDefined, Transparent)
 
   /** A value that's unstable unless complemented with a Stable flag */
   val UnstableValueFlags: FlagSet = Mutable | Method
@@ -499,7 +502,7 @@ object Flags {
   /** Flags that can apply to a module val */
   val RetainedModuleValFlags: FlagSet = RetainedModuleValAndClassFlags |
     Override | Final | Method | Implicit | Given | Lazy |
-    Accessor | AbsOverride | StableRealizable | Captured | Synchronized | Erased
+    Accessor | AbsOverride | StableRealizable | Captured | Synchronized | Erased | Transparent
 
   /** Flags that can apply to a module class */
   val RetainedModuleClassFlags: FlagSet = RetainedModuleValAndClassFlags | Enum

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -712,6 +712,7 @@ class TreePickler(pickler: TastyPickler) {
     if (flags.is(Local)) writeModTag(LOCAL)
     if (flags.is(Synthetic)) writeModTag(SYNTHETIC)
     if (flags.is(Artifact)) writeModTag(ARTIFACT)
+    if flags.is(Transparent) then writeModTag(TRANSPARENT)
     if (isTerm) {
       if (flags.is(Implicit)) writeModTag(IMPLICIT)
       if (flags.is(Given)) writeModTag(GIVEN)

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -667,15 +667,13 @@ class TreeUnpickler(reader: TastyReader,
           case PARAMalias => addFlag(SuperParamAlias)
           case EXPORTED => addFlag(Exported)
           case OPEN => addFlag(Open)
+          case TRANSPARENT => addFlag(Transparent)
           case PRIVATEqualified =>
             readByte()
             privateWithin = readWithin
           case PROTECTEDqualified =>
             addFlag(Protected)
             privateWithin = readWithin
-          case SUPERTRAIT =>
-            readByte()
-            annotFns = (_ => Annotation(defn.MixinAnnot)) :: annotFns
           case ANNOTATION =>
             annotFns = readAnnot :: annotFns
           case tag =>

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -2807,11 +2807,7 @@ object Parsers {
         }
         else
           mods
-      val result = normalize(loop(start))
-      for case mod @ Mod.Transparent() <- result.mods do
-        if !result.is(Inline) then
-          syntaxError(em"`transparent` can only be used in conjunction with `inline`", mod.span)
-      result
+      normalize(loop(start))
     }
 
     val funTypeArgMods: BitSet = BitSet(ERASED)

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

@@ -897,8 +897,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/typer/Checking.scala

@@ -449,6 +449,11 @@ object Checking {
       if (sym.isType)
         fail(TypesAndTraitsCantBeImplicit())
     }
+    if sym.is(Transparent) then
+      if sym.isType then
+        if !sym.is(Trait) then fail(em"`transparent` can only be used for traits")
+      else
+        if !sym.isInlineMethod then fail(em"`transparent` can only be used for inline methods")
     if (!sym.isClass && sym.is(Abstract))
       fail(OnlyClassesCanBeAbstract(sym))
         // note: this is not covered by the next test since terms can be abstract (which is a dual-mode flag)

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

@@ -206,8 +206,7 @@ object PrepareInlineable {
 
   /** 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
-    else Typed(rhs, tpt)
+    if original.mods.is(Transparent) then rhs else Typed(rhs, tpt)
 
   /** Return result of evaluating `op`, but drop `Inline` flag and `Body` annotation
    *  of `sym` in case that leads to errors.

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

@@ -370,7 +370,7 @@ object TastyFormat {
   final val OPEN = 40
   final val PARAMEND = 41
   final val PARAMalias = 42
-  final val SUPERTRAIT = 43  // TODO: remove
+  final val TRANSPARENT = 43
 
   // Cat. 2:    tag Nat
 
@@ -485,7 +485,7 @@ object TastyFormat {
 
   /** Useful for debugging */
   def isLegalTag(tag: Int): Boolean =
-    firstSimpleTreeTag <= tag && tag <= SUPERTRAIT ||
+    firstSimpleTreeTag <= tag && tag <= TRANSPARENT ||
     firstNatTreeTag <= tag && tag <= RENAMED ||
     firstASTTreeTag <= tag && tag <= BOUNDED ||
     firstNatASTTreeTag <= tag && tag <= NAMEDARG ||
@@ -514,7 +514,7 @@ object TastyFormat {
        | STATIC
        | OBJECT
        | TRAIT
-       | SUPERTRAIT
+       | TRANSPARENT
        | ENUM
        | LOCAL
        | SYNTHETIC
@@ -575,7 +575,7 @@ object TastyFormat {
     case STATIC => "STATIC"
     case OBJECT => "OBJECT"
     case TRAIT => "TRAIT"
-    case SUPERTRAIT => "SUPERTRAIT"
+    case TRANSPARENT => "TRANSPARENT"
     case ENUM => "ENUM"
     case LOCAL => "LOCAL"
     case SYNTHETIC => "SYNTHETIC"

tests/neg/transparent.scala

@@ -0,0 +1,9 @@
+transparent def foo = 1  // error
+transparent inline def bar = 2 // ok
+transparent inline val x = 2 // error
+transparent class c // error
+transparent object y // error
+transparent trait t // ok
+transparent type T = c  // error
+transparent given c // error
+