Merge pull request #6491 from dotty-staging/implicit-alias-rhs

Cache Right Hand Side of Parameterless Alias Implicits

Author: biboudis

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -62,6 +62,7 @@ class Compiler {
          new ExpandSAMs,             // Expand single abstract method closures to anonymous classes
          new ProtectedAccessors,     // Add accessors for protected members
          new ExtensionMethods,       // Expand methods of value classes with extension methods
+         new CacheAliasImplicits,    // Cache RHS of parameterless alias implicits
          new ShortcutImplicits,      // Allow implicit functions without creating closures
          new ByNameClosures,         // Expand arguments to by-name parameters to closures
          new HoistSuperArgs,         // Hoist complex arguments of supercalls to enclosing scope

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

@@ -512,7 +512,15 @@ object desugar {
         case _ =>
           constrVparamss
       }
-      New(classTypeRef, vparamss.nestedMap(refOfDef))
+      val nu = (makeNew(classTypeRef) /: vparamss) { (nu, vparams) =>
+        val app = Apply(nu, vparams.map(refOfDef))
+        vparams match {
+          case vparam :: _ if vparam.mods.is(Given) => app.pushAttachment(ApplyGiven, ())
+          case _ =>
+        }
+        app
+      }
+      ensureApplied(nu)
     }
 
     val copiedAccessFlags = if (ctx.scala2Setting) EmptyFlags else AccessFlags

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

@@ -57,6 +57,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def unitLiteral(implicit ctx: Context): Literal =
     Literal(Constant(()))
 
+  def nullLiteral(implicit ctx: Context): Literal =
+    Literal(Constant(null))
+
   def New(tpt: Tree)(implicit ctx: Context): New =
     ta.assignType(untpd.New(tpt), tpt)
 
@@ -496,7 +499,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     else if (tpw isRef defn.DoubleClass) Literal(Constant(0d))
     else if (tpw isRef defn.ByteClass) Literal(Constant(0.toByte))
     else if (tpw isRef defn.ShortClass) Literal(Constant(0.toShort))
-    else Literal(Constant(null)).select(defn.Any_asInstanceOf).appliedToType(tpe)
+    else nullLiteral.select(defn.Any_asInstanceOf).appliedToType(tpe)
   }
 
   private class FindLocalDummyAccumulator(cls: ClassSymbol)(implicit ctx: Context) extends TreeAccumulator[Symbol] {
@@ -915,7 +918,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         Typed(tree, TypeTree(defn.AnyRefType))
       }
       else tree.ensureConforms(defn.ObjectType)
-      receiver.select(defn.Object_ne).appliedTo(Literal(Constant(null)))
+      receiver.select(defn.Object_ne).appliedTo(nullLiteral)
     }
 
     /** If inititializer tree is `_', the default value of its type,

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

@@ -68,7 +68,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     override def isType: Boolean = body.isType
   }
 
-  /** A function type with `implicit`, `erased`, or `contextual` modifiers */
+  /** A function type with `implicit`, `erased`, or `given` modifiers */
   class FunctionWithMods(args: List[Tree], body: Tree, val mods: Modifiers)(implicit @constructorOnly src: SourceFile)
     extends Function(args, body)
 
@@ -352,7 +352,13 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
    *  navigation into these arguments from the IDE, and to do the right thing in
    *  PrepareInlineable.
    */
-  def New(tpt: Tree, argss: List[List[Tree]])(implicit ctx: Context): Tree = {
+  def New(tpt: Tree, argss: List[List[Tree]])(implicit ctx: Context): Tree =
+    ensureApplied((makeNew(tpt) /: argss)(Apply(_, _)))
+
+  /** A new expression with constrictor and possibly type arguments. See
+   *  `New(tpt, argss)` for details.
+   */
+  def makeNew(tpt: Tree)(implicit ctx: Context): Tree = {
     val (tycon, targs) = tpt match {
       case AppliedTypeTree(tycon, targs) =>
         (tycon, targs)
@@ -363,9 +369,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       case _ =>
         (tpt, Nil)
     }
-    var prefix: Tree = Select(New(tycon), nme.CONSTRUCTOR)
-    if (targs.nonEmpty) prefix = TypeApply(prefix, targs)
-    ensureApplied((prefix /: argss)(Apply(_, _)))
+    val nu: Tree = Select(New(tycon), nme.CONSTRUCTOR)
+    if (targs.nonEmpty) TypeApply(nu, targs) else nu
   }
 
   def Block(stat: Tree, expr: Tree)(implicit src: SourceFile): Block =

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

@@ -394,6 +394,9 @@ object Flags {
   /** Symbol is an enum class or enum case (if used with case) */
   final val Enum: FlagSet = commonFlag(40, "<enum>")
 
+  /** An export forwarder */
+  final val Exported: FlagSet = commonFlag(41, "exported")
+
   /** Labeled with `erased` modifier (erased value)  */
   final val Erased: FlagSet = termFlag(42, "erased")
 
@@ -459,7 +462,7 @@ object Flags {
 
   /** Flags representing source modifiers */
   private val CommonSourceModifierFlags: FlagSet =
-    commonFlags(Private, Protected, Final, Case, Implicit, Implied, Override, JavaStatic)
+    commonFlags(Private, Protected, Final, Case, Implicit, Implied, Given, Override, JavaStatic)
 
   final val TypeSourceModifierFlags: FlagSet =
     CommonSourceModifierFlags.toTypeFlags | Abstract | Sealed | Opaque

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

@@ -359,6 +359,7 @@ object NameKinds {
   val InlineAccessorName: PrefixNameKind = new PrefixNameKind(INLINEACCESSOR, "inline$")
 
   val AvoidClashName: SuffixNameKind = new SuffixNameKind(AVOIDCLASH, "$_avoid_name_clash_$")
+  val CacheName = new SuffixNameKind(CACHE, "$_cache")
   val DirectMethodName: SuffixNameKind = new SuffixNameKind(DIRECT, "$direct") { override def definesNewName = true }
   val FieldName: SuffixNameKind = new SuffixNameKind(FIELD, "$$local") {
       override def mkString(underlying: TermName, info: ThisInfo) = underlying.toString

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

@@ -36,6 +36,8 @@ object NameTags extends TastyFormat.NameTags {
   final val IMPLMETH = 32       // Used to define methods in implementation classes
                                 // (can probably be removed).
 
+  final val CACHE = 33          // Used as a cache for the rhs of an alias implicit.
+
   def nameTagToString(tag: Int): String = tag match {
     case UTF8 => "UTF8"
     case QUALIFIED => "QUALIFIED"

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

@@ -208,6 +208,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   EXTENSION                                                        -- An extension method
                   GIVEN                                                            -- A new style implicit parameter, introduced with `given`
                   PARAMsetter                                                      -- The setter part `x_=` of a var parameter `x` which itself is pickled as a PARAM
+                  EXPORTED                                                         -- An export forwarder
                   Annotation
 
   Annotation    = ANNOTATION     Length tycon_Type fullAnnotation_Term             -- An annotation, given (class) type of constructor, and full application tree
@@ -329,6 +330,7 @@ object TastyFormat {
   final val GIVEN = 37
   final val IMPLIED = 38
   final val PARAMsetter = 39
+  final val EXPORTED = 40
 
   // Cat. 2:    tag Nat
 
@@ -457,7 +459,7 @@ object TastyFormat {
 
   /** Useful for debugging */
   def isLegalTag(tag: Int): Boolean =
-    firstSimpleTreeTag <= tag && tag <= PARAMsetter ||
+    firstSimpleTreeTag <= tag && tag <= EXPORTED ||
     firstNatTreeTag <= tag && tag <= SYMBOLconst ||
     firstASTTreeTag <= tag && tag <= SINGLETONtpt ||
     firstNatASTTreeTag <= tag && tag <= NAMEDARG ||
@@ -500,6 +502,7 @@ object TastyFormat {
        | EXTENSION
        | GIVEN
        | PARAMsetter
+       | EXPORTED
        | ANNOTATION
        | PRIVATEqualified
        | PROTECTEDqualified => true
@@ -560,6 +563,7 @@ object TastyFormat {
     case EXTENSION => "EXTENSION"
     case GIVEN => "GIVEN"
     case PARAMsetter => "PARAMsetter"
+    case EXPORTED => "EXPORTED"
 
     case SHAREDterm => "SHAREDterm"
     case SHAREDtype => "SHAREDtype"

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

@@ -656,6 +656,7 @@ class TreePickler(pickler: TastyPickler) {
       if (flags is Extension) writeByte(EXTENSION)
       if (flags is Given) writeByte(GIVEN)
       if (flags is ParamAccessor) writeByte(PARAMsetter)
+      if (flags is Exported) writeByte(EXPORTED)
       assert(!(flags is Label))
     } else {
       if (flags is Sealed) writeByte(SEALED)

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

@@ -632,8 +632,8 @@ class TreeUnpickler(reader: TastyReader,
           case STABLE => addFlag(StableRealizable)
           case EXTENSION => addFlag(Extension)
           case GIVEN => addFlag(Given)
-          case PARAMsetter =>
-            addFlag(ParamAccessor)
+          case PARAMsetter => addFlag(ParamAccessor)
+          case EXPORTED => addFlag(Exported)
           case PRIVATEqualified =>
             readByte()
             privateWithin = readWithin(ctx)