Add transparent modifier

Author: odersky

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

@@ -93,4 +93,7 @@ object Mode {
 
   /** We are in the IDE */
   val Interactive = newMode(20, "Interactive")
+
+  /** We are typing the body of a transparent method */
+  val TransparentBody = newMode(21, "TransparentBody")
 }

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

@@ -783,7 +783,7 @@ object SymDenotations {
       is(InlineMethod, butNot = Accessor)
 
     def isTransparentMethod(implicit ctx: Context): Boolean =
-      is(TransparentMethod, butNot = Accessor)
+      is(TransparentMethod, butNot = AccessorOrSynthetic)
 
     def isInlineableMethod(implicit ctx: Context) = isInlinedMethod || isTransparentMethod
 

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

@@ -532,7 +532,7 @@ class TreeUnpickler(reader: TastyReader,
             rootd.symbol
           case _ =>
             val completer = adjustIfModule(new Completer(ctx.owner, subReader(start, end)))
-F            if (isClass)
+            if (isClass)
               ctx.newClassSymbol(ctx.owner, name.asTypeName, flags, completer, privateWithin, coord)
             else
               ctx.newSymbol(ctx.owner, name, flags, completer, privateWithin, coord)
@@ -547,7 +547,7 @@ F            if (isClass)
         sym.completer.withDecls(newScope)
         forkAt(templateStart).indexTemplateParams()(localContext(sym))
       }
-      else if (sym.isInlineableMethod)
+      else if (sym.isInlinedMethod)
         sym.addAnnotation(LazyBodyAnnotation { ctx0 =>
           implicit val ctx: Context = localContext(sym)(ctx0).addMode(Mode.ReadPositions)
             // avoids space leaks by not capturing the current context

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

@@ -232,7 +232,7 @@ object Inliner {
    *  from Scala2x class files might be `@inline`, but still lack that body.
    */
   def hasBodyToInline(sym: SymDenotation)(implicit ctx: Context): Boolean =
-    sym.isInlinedMethod && sym.hasAnnotation(defn.BodyAnnot) // TODO: Open this up for transparent methods as well
+    sym.isInlineableMethod && sym.hasAnnotation(defn.BodyAnnot)
 
   /** The body to inline for method `sym`.
    *  @pre  hasBodyToInline(sym)

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

@@ -1128,7 +1128,8 @@ class Namer { typer: Typer =>
       // it would be erased to BoxedUnit.
       def dealiasIfUnit(tp: Type) = if (tp.isRef(defn.UnitClass)) defn.UnitType else tp
 
-      val rhsCtx = ctx.addMode(Mode.InferringReturnType)
+      var rhsCtx = ctx.addMode(Mode.InferringReturnType)
+      if (sym.isTransparentMethod) rhsCtx = rhsCtx.addMode(Mode.TransparentBody)
       def rhsType = typedAheadExpr(mdef.rhs, inherited orElse rhsProto)(rhsCtx).tpe
 
       // Approximate a type `tp` with a type that does not contain skolem types.

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

@@ -1428,6 +1428,7 @@ class Typer extends Namer
       (tparams1, sym.owner.typeParams).zipped.foreach ((tdef, tparam) =>
         rhsCtx.gadt.setBounds(tdef.symbol, TypeAlias(tparam.typeRef)))
     }
+    if (sym.isTransparentMethod) rhsCtx = rhsCtx.addMode(Mode.TransparentBody)
     val rhs1 = normalizeErasedRhs(typedExpr(ddef.rhs, tpt1.tpe)(rhsCtx), sym)
 
     // Overwrite inline body to make sure it is not evaluated twice