Merge pull request #5383 from dotty-staging/add-specializing-inline

Add specializing inline

Author: nicolasstucki

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

@@ -3,14 +3,12 @@ package dotc
 
 import util.SourceFile
 import ast.{tpd, untpd}
-import dotty.tools.dotc.ast.Trees
 import tpd.{Tree, TreeTraverser}
 import typer.PrepareInlineable.InlineAccessors
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.SymDenotations.ClassDenotation
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.transform.SymUtils._
-import dotty.tools.dotc.typer.Inliner
 
 class CompilationUnit(val source: SourceFile) {
 
@@ -25,8 +23,8 @@ class CompilationUnit(val source: SourceFile) {
   /** Pickled TASTY binaries, indexed by class. */
   var pickled: Map[ClassSymbol, Array[Byte]] = Map()
 
-  /** Will be set to `true` if contains `Quote`, `Splice` or calls to inline methods.
-   * The information is used in phase `Staging` in order to avoid traversing a quote-less tree.
+  /** Will be set to `true` if contains `Quote`.
+   *  The information is used in phase `Staging` in order to avoid traversing trees that need no transformations.
    */
   var needsStaging: Boolean = false
 
@@ -57,8 +55,7 @@ object CompilationUnit {
   private class Force extends TreeTraverser {
     var needsStaging = false
     def traverse(tree: Tree)(implicit ctx: Context): Unit = {
-      // Note that top-level splices are still inside the inline methods
-      if (tree.symbol.isQuote || tpd.isInlineCall(tree))
+      if (tree.symbol.isQuote)
         needsStaging = true
       traverseChildren(tree)
     }

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

@@ -44,7 +44,7 @@ class Compiler {
   /** Phases dealing with TASTY tree pickling and unpickling */
   protected def picklerPhases: List[List[Phase]] =
     List(new Pickler) ::            // Generate TASTY info
-    List(new Staging) ::            // Inline calls, expand macros and turn quoted trees into explicit run-time data structures
+    List(new Staging) ::            // Expand macros and turn quoted trees into explicit run-time data structures
     Nil
 
   /** Phases dealing with the transformation from pickled trees to backend trees */

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

@@ -157,19 +157,31 @@ object desugar {
        ValDef(epname, tpt, EmptyTree).withFlags(paramFlags | Implicit)
     }
 
-  /** Expand context bounds to evidence params. E.g.,
+  /** 1. Expand context bounds to evidence params. E.g.,
    *
    *      def f[T >: L <: H : B](params)
    *  ==>
    *      def f[T >: L <: H](params)(implicit evidence$0: B[T])
    *
-   *  Expand default arguments to default getters. E.g,
+   *  2. Expand default arguments to default getters. E.g,
    *
    *      def f[T: B](x: Int = 1)(y: String = x + "m") = ...
    *  ==>
    *      def f[T](x: Int)(y: String)(implicit evidence$0: B[T]) = ...
    *      def f$default$1[T] = 1
    *      def f$default$2[T](x: Int) = x + "m"
+   *
+   *  3. Convert <: T to : T in specializing inline methods. E.g.
+   *
+   *      inline def f(x: Boolean) <: Any = if (x) 1 else ""
+   *  ==>
+   *      inline def f(x: Boolean): Any = if (x) 1 else ""
+   *
+   *  4. Upcast non-specializing inline methods. E.g.
+   *
+   *      inline def f(x: Boolean): Any = if (x) 1 else ""
+   *  ==>
+   *      inline def f(x: Boolean): Any = (if (x) 1 else ""): Any
    */
   private def defDef(meth: DefDef, isPrimaryConstructor: Boolean = false)(implicit ctx: Context): Tree = {
     val DefDef(name, tparams, vparamss, tpt, rhs) = meth
@@ -188,7 +200,16 @@ object desugar {
       cpy.TypeDef(tparam)(rhs = desugarContextBounds(tparam.rhs))
     }
 
-    val meth1 = addEvidenceParams(cpy.DefDef(meth)(tparams = tparams1), epbuf.toList)
+    var meth1 = addEvidenceParams(cpy.DefDef(meth)(tparams = tparams1), epbuf.toList)
+
+    if (meth1.mods.is(Inline))
+      meth1.tpt match {
+        case TypeBoundsTree(_, tpt1) =>
+          meth1 = cpy.DefDef(meth1)(tpt = tpt1)
+        case tpt if !tpt.isEmpty && !meth1.rhs.isEmpty =>
+          meth1 = cpy.DefDef(meth1)(rhs = Typed(meth1.rhs, tpt))
+        case _ =>
+      }
 
     /** The longest prefix of parameter lists in vparamss whose total length does not exceed `n` */
     def takeUpTo(vparamss: List[List[ValDef]], n: Int): List[List[ValDef]] = vparamss match {

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

@@ -5,7 +5,7 @@ package ast
 import core._
 import Flags._, Trees._, Types._, Contexts._
 import Names._, StdNames._, NameOps._, Symbols._
-import typer.{ConstFold, Inliner}
+import typer.ConstFold
 import reporting.trace
 
 import scala.annotation.tailrec
@@ -770,14 +770,6 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       false
   }
 
-  /** Is this call a call to a method that is marked as Inline */
-  def isInlineCall(arg: Tree)(implicit ctx: Context): Boolean = arg match {
-    case _: RefTree | _: GenericApply[_] =>
-      !arg.tpe.widenDealias.isInstanceOf[MethodicType] && Inliner.isInlineable(arg)
-    case _ =>
-      false
-  }
-
   /** Structural tree comparison (since == on trees is reference equality).
    *  For the moment, only Ident, Select, Literal, Apply and TypeApply are supported
    */

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

@@ -585,8 +585,9 @@ object Trees {
 
   /** A tree representing inlined code.
    *
-   *  @param  call      Info about the original call that was inlined.
-   *                    Only a reference to the toplevel class from which the call was inlined.
+   *  @param  call      Info about the original call that was inlined
+   *                    Until PostTyper, this is the full call, afterwards only
+   *                    a reference to the toplevel class from which the call was inlined.
    *  @param  bindings  Bindings for proxies to be used in the inlined code
    *  @param  expansion The inlined tree, minus bindings.
    *

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

@@ -4,7 +4,7 @@ package core
 import java.security.MessageDigest
 import scala.io.Codec
 import Names._, StdNames._, Contexts._, Symbols._, Flags._, NameKinds._, Types._
-import util.Chars
+import scala.tasty.util.Chars
 import Chars.isOperatorPart
 import Definitions._
 

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

@@ -7,7 +7,7 @@ import util.NameTransformer
 import printing.{Showable, Texts, Printer}
 import Texts.Text
 import StdNames.str
-import util.Chars.isIdentifierStart
+import scala.tasty.util.Chars.isIdentifierStart
 import collection.immutable
 import config.Config
 import java.util.HashMap

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

@@ -86,6 +86,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   TYPED          Length expr_Term ascriptionType_Tern
                   ASSIGN         Length lhs_Term rhs_Term
                   BLOCK          Length expr_Term Stat*
+                  INLINED        Length expr_Term call_Term? ValOrDefDef*
                   LAMBDA         Length meth_Term target_Type?
                   IF             Length cond_Term then_Term else_Term
                   MATCH          Length sel_Term CaseDef*
@@ -184,6 +185,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   OVERRIDE
                   INLINE
                   MACRO                               // inline method containing toplevel splices
+                  INLINEPROXY                         // symbol of binding representing an inline parameter
                   STATIC                              // mapped to static Java member
                   OBJECT                              // an object or its class
                   TRAIT                               // a trait
@@ -233,7 +235,7 @@ Standard Section: "Comments" Comment*
 object TastyFormat {
 
   final val header: Array[Int] = Array(0x5C, 0xA1, 0xAB, 0x1F)
-  val MajorVersion: Int = 13
+  val MajorVersion: Int = 11
   val MinorVersion: Int = 0
 
   /** Tags used to serialize names */
@@ -286,25 +288,26 @@ object TastyFormat {
   final val IMPLICIT = 13
   final val LAZY = 14
   final val OVERRIDE = 15
-  final val INLINE = 16
-  final val STATIC = 17
-  final val OBJECT = 18
-  final val TRAIT = 19
-  final val ENUM = 20
-  final val LOCAL = 21
-  final val SYNTHETIC = 22
-  final val ARTIFACT = 23
-  final val MUTABLE = 24
-  final val FIELDaccessor = 25
-  final val CASEaccessor = 26
-  final val COVARIANT = 27
-  final val CONTRAVARIANT = 28
-  final val SCALA2X = 29
-  final val DEFAULTparameterized = 30
-  final val STABLE = 31
-  final val MACRO = 32
-  final val ERASED = 33
-  final val PARAMsetter = 34
+  final val INLINEPROXY = 16
+  final val INLINE = 17
+  final val STATIC = 18
+  final val OBJECT = 19
+  final val TRAIT = 20
+  final val ENUM = 21
+  final val LOCAL = 22
+  final val SYNTHETIC = 23
+  final val ARTIFACT = 24
+  final val MUTABLE = 25
+  final val FIELDaccessor = 26
+  final val CASEaccessor = 27
+  final val COVARIANT = 28
+  final val CONTRAVARIANT = 29
+  final val SCALA2X = 30
+  final val DEFAULTparameterized = 31
+  final val STABLE = 32
+  final val MACRO = 33
+  final val ERASED = 34
+  final val PARAMsetter = 35
 
   // Cat. 2:    tag Nat
 
@@ -378,35 +381,36 @@ object TastyFormat {
   final val RETURN = 144
   final val WHILE = 145
   final val TRY = 146
-  final val SELECTouter = 147
-  final val REPEATED = 148
-  final val BIND = 149
-  final val ALTERNATIVE = 150
-  final val UNAPPLY = 151
-  final val ANNOTATEDtype = 152
-  final val ANNOTATEDtpt = 153
-  final val CASEDEF = 154
-  final val TEMPLATE = 155
-  final val SUPER = 156
-  final val SUPERtype = 157
-  final val REFINEDtype = 158
-  final val REFINEDtpt = 159
-  final val APPLIEDtype = 160
-  final val APPLIEDtpt = 161
-  final val TYPEBOUNDS = 162
-  final val TYPEBOUNDStpt = 163
-  final val ANDtype = 164
-  final val ANDtpt = 165
-  final val ORtype = 166
-  final val ORtpt = 167
-  final val POLYtype = 168
-  final val TYPELAMBDAtype = 169
-  final val LAMBDAtpt = 170
-  final val PARAMtype = 171
-  final val ANNOTATION = 172
-  final val TERMREFin = 173
-  final val TYPEREFin = 174
-  final val OBJECTDEF = 175
+  final val INLINED = 147
+  final val SELECTouter = 148
+  final val REPEATED = 149
+  final val BIND = 150
+  final val ALTERNATIVE = 151
+  final val UNAPPLY = 152
+  final val ANNOTATEDtype = 153
+  final val ANNOTATEDtpt = 154
+  final val CASEDEF = 155
+  final val TEMPLATE = 156
+  final val SUPER = 157
+  final val SUPERtype = 158
+  final val REFINEDtype = 159
+  final val REFINEDtpt = 160
+  final val APPLIEDtype = 161
+  final val APPLIEDtpt = 162
+  final val TYPEBOUNDS = 163
+  final val TYPEBOUNDStpt = 164
+  final val ANDtype = 165
+  final val ANDtpt = 166
+  final val ORtype = 167
+  final val ORtpt = 168
+  final val POLYtype = 169
+  final val TYPELAMBDAtype = 170
+  final val LAMBDAtpt = 171
+  final val PARAMtype = 172
+  final val ANNOTATION = 173
+  final val TERMREFin = 174
+  final val TYPEREFin = 175
+  final val OBJECTDEF = 176
 
   // In binary: 101101EI
   // I = implicit method type
@@ -456,6 +460,7 @@ object TastyFormat {
        | LAZY
        | OVERRIDE
        | INLINE
+       | INLINEPROXY
        | MACRO
        | STATIC
        | OBJECT
@@ -512,6 +517,7 @@ object TastyFormat {
     case LAZY => "LAZY"
     case OVERRIDE => "OVERRIDE"
     case INLINE => "INLINE"
+    case INLINEPROXY => "INLINEPROXY"
     case MACRO => "MACRO"
     case STATIC => "STATIC"
     case OBJECT => "OBJECT"
@@ -579,6 +585,7 @@ object TastyFormat {
     case MATCH => "MATCH"
     case RETURN => "RETURN"
     case WHILE => "WHILE"
+    case INLINED => "INLINED"
     case SELECTouter => "SELECTouter"
     case TRY => "TRY"
     case REPEATED => "REPEATED"

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

@@ -442,6 +442,17 @@ class TreePickler(pickler: TastyPickler) {
         case SeqLiteral(elems, elemtpt) =>
           writeByte(REPEATED)
           withLength { pickleTree(elemtpt); elems.foreach(pickleTree) }
+        case Inlined(call, bindings, expansion) =>
+          writeByte(INLINED)
+          bindings.foreach(preRegister)
+          withLength {
+            pickleTree(expansion)
+            if (!call.isEmpty) pickleTree(call)
+            bindings.foreach { b =>
+              assert(b.isInstanceOf[DefDef] || b.isInstanceOf[ValDef])
+              pickleTree(b)
+            }
+          }
         case Bind(name, body) =>
           registerDef(tree.symbol)
           writeByte(BIND)
@@ -608,6 +619,7 @@ class TreePickler(pickler: TastyPickler) {
     if (flags is Case) writeByte(CASE)
     if (flags is Override) writeByte(OVERRIDE)
     if (flags is Inline) writeByte(INLINE)
+    if (flags is InlineProxy) writeByte(INLINEPROXY)
     if (flags is Macro) writeByte(MACRO)
     if (flags is JavaStatic) writeByte(STATIC)
     if (flags is Module) writeByte(OBJECT)

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

@@ -604,6 +604,7 @@ class TreeUnpickler(reader: TastyReader,
           case LAZY => addFlag(Lazy)
           case OVERRIDE => addFlag(Override)
           case INLINE => addFlag(Inline)
+          case INLINEPROXY => addFlag(InlineProxy)
           case MACRO => addFlag(Macro)
           case STATIC => addFlag(JavaStatic)
           case OBJECT => addFlag(Module)
@@ -1072,6 +1073,17 @@ class TreeUnpickler(reader: TastyReader,
               val stats = readStats(ctx.owner, end)
               val expr = exprReader.readTerm()
               Block(stats, expr)
+            case INLINED =>
+              val exprReader = fork
+              skipTree()
+              def maybeCall = nextUnsharedTag match {
+                case VALDEF | DEFDEF => EmptyTree
+                case _ => readTerm()
+              }
+              val call = ifBefore(end)(maybeCall, EmptyTree)
+              val bindings = readStats(ctx.owner, end).asInstanceOf[List[ValOrDefDef]]
+              val expansion = exprReader.readTerm() // need bindings in scope, so needs to be read before
+              Inlined(call, bindings, expansion)
             case IF =>
               If(readTerm(), readTerm(), readTerm())
             case LAMBDA =>