Implement inline

bridge/src/sbt-test/source-dependencies/inline/A.scala

@@ -0,0 +1,3 @@
+object A {
+  def get: Int = 1
+}

bridge/src/sbt-test/source-dependencies/inline/C.scala

@@ -0,0 +1,5 @@
+object C {
+  def main(args: Array[String]): Unit = {
+    val i: Int = B.getInline
+  }
+}

bridge/src/sbt-test/source-dependencies/inline/changes/B1.scala

@@ -0,0 +1,4 @@
+object B {
+  @inline def getInline: Int =
+    A.get
+}

bridge/src/sbt-test/source-dependencies/inline/changes/B2.scala

@@ -0,0 +1,4 @@
+object B {
+  @inline def getInline: Double =
+    A.get
+}

bridge/src/sbt-test/source-dependencies/inline/changes/B3.scala

@@ -0,0 +1,4 @@
+object B {
+  @inline def getInline: Int =
+    sys.error("This is an expected failure when running C")
+}

bridge/src/sbt-test/source-dependencies/inline/project/DottyInjectedPlugin.scala

@@ -0,0 +1,17 @@
+import sbt._
+import Keys._
+
+object DottyInjectedPlugin extends AutoPlugin {
+  override def requires = plugins.JvmPlugin
+  override def trigger = allRequirements
+
+  override val projectSettings = Seq(
+    scalaVersion := "0.1-SNAPSHOT",
+    scalaOrganization := "ch.epfl.lamp",
+    scalacOptions += "-language:Scala2",
+    scalaBinaryVersion  := "2.11",
+    autoScalaLibrary := false,
+    libraryDependencies ++= Seq("org.scala-lang" % "scala-library" % "2.11.5"),
+    scalaCompilerBridgeSource := ("ch.epfl.lamp" % "dotty-bridge" % "0.1.1-SNAPSHOT" % "component").sources()
+  )
+}

bridge/src/sbt-test/source-dependencies/inline/test

@@ -0,0 +1,14 @@
+$ copy-file changes/B1.scala B.scala
+> compile
+
+$ copy-file changes/B2.scala B.scala
+# Compilation of C.scala should fail because B.getInline now has type Double instead of Int
+-> compile
+
+$ copy-file changes/B1.scala B.scala
+> run
+
+$ copy-file changes/B3.scala B.scala
+# The body of B.getInline was changed so C.scala should be recompiled
+# If it was recompiled, run should fail since B.getInline now throws an exception
+-> run

docs/SyntaxSummary.txt

@@ -231,14 +231,15 @@ grammar.
   ClsParamClauses   ::=  {ClsParamClause} [[nl] `(' `implicit' ClsParams `)']
   ClsParamClause    ::=  [nl] `(' [ClsParams] ')'
   ClsParams         ::=  ClsParam {`' ClsParam}
-  ClsParam          ::=  {Annotation} [{Modifier} (`val' | `var')] Param        ValDef(mods, id, tpe, expr) -- point of mods on val/var
+  ClsParam          ::=  {Annotation}
+                         [{Modifier} (`val' | `var') | `inline'] Param          ValDef(mods, id, tpe, expr) -- point of mods on val/var
   Param             ::=  id `:' ParamType [`=' Expr]
                       |  INT
 
   DefParamClauses   ::=  {DefParamClause} [[nl] `(' `implicit' DefParams `)']
   DefParamClause    ::=  [nl] `(' [DefParams] ')'
   DefParams         ::=  DefParam {`,' DefParam}
-  DefParam          ::=  {Annotation} Param                                     ValDef(mods, id, tpe, expr) -- point of mods at id.
+  DefParam          ::=  {Annotation} [`inline'] Param                          ValDef(mods, id, tpe, expr) -- point of mods at id.
 
   Bindings          ::=  `(' Binding {`,' Binding `)'                           bindings
   Binding           ::=  (id | `_') [`:' Type]                                  ValDef(_, id, tpe, EmptyTree)

dottydoc/test/BaseTest.scala

@@ -18,6 +18,7 @@ trait DottyTest {
     val ctx = base.initialCtx.fresh
     ctx.setSetting(ctx.settings.language, List("Scala2"))
     ctx.setSetting(ctx.settings.YkeepComments, true)
+    ctx.setSetting(ctx.settings.YnoInline, true)
     base.initialize()(ctx)
     ctx
   }

project/Build.scala

@@ -64,6 +64,9 @@ object DottyBuild extends Build {
   lazy val dotty = project.in(file(".")).
     dependsOn(`dotty-interfaces`).
     settings(
+      // Disable scaladoc generation, makes publishLocal much faster
+      publishArtifact in packageDoc := false,
+
       overrideScalaVersionSetting,
 
       // set sources to src/, tests to test/ and resources to resources/

src/dotty/annotation/internal/Body.scala

@@ -0,0 +1,8 @@
+package dotty.annotation.internal
+
+import scala.annotation.Annotation
+
+/** The class associated with a `BodyAnnotation`, which indicates
+ *  an inline method's right hand side
+ */
+final class Body() extends Annotation

src/dotty/annotation/internal/InlineParam.scala

@@ -0,0 +1,6 @@
+package dotty.annotation.internal
+
+import scala.annotation.Annotation
+
+/** An annotation produced by Namer to indicate an inline parameter */
+final class InlineParam() extends Annotation

src/dotty/tools/dotc/Compiler.scala

@@ -94,6 +94,7 @@ class Compiler {
            new SelectStatic,        // get rid of selects that would be compiled into GetStatic
            new CollectEntryPoints,  // Find classes with main methods
            new CollectSuperCalls,   // Find classes that are called with super
+           new DropInlined,         // Drop Inlined nodes, since backend has no use for them
            new MoveStatics,         // Move static methods to companion classes
            new LabelDefs),          // Converts calls to labels to jumps
       List(new GenSJSIR),           // Generate .js code

src/dotty/tools/dotc/FromTasty.scala

@@ -86,7 +86,7 @@ object FromTasty extends Driver {
               case info: ClassfileLoader =>
                 info.load(clsd) match {
                   case Some(unpickler: DottyUnpickler) =>
-                    val List(unpickled) = unpickler.body(readPositions = true)
+                    val List(unpickled) = unpickler.body(ctx.addMode(Mode.ReadPositions))
                     val unit1 = new CompilationUnit(new SourceFile(clsd.symbol.sourceFile, Seq()))
                     unit1.tpdTree = unpickled
                     unit1.unpicklers += (clsd.classSymbol -> unpickler.unpickler)

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

@@ -8,15 +8,15 @@ import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._
 import Decorators._
 import language.higherKinds
 import collection.mutable.ListBuffer
-import util.Attachment
+import util.Property
 
 object desugar {
   import untpd._
 
   /** Tags a .withFilter call generated by desugaring a for expression.
    *  Such calls can alternatively be rewritten to use filter.
    */
-  val MaybeFilter = new Attachment.Key[Unit]
+  val MaybeFilter = new Property.Key[Unit]
 
   /** Info of a variable in a pattern: The named tree and its type */
   private type VarInfo = (NameTree, Tree)
@@ -607,11 +607,17 @@ object desugar {
    *  ==>
    *      def $anonfun(params) = body
    *      Closure($anonfun)
+   *
+   *  If `inlineable` is true, tag $anonfun with an @inline annotation.
    */
-  def makeClosure(params: List[ValDef], body: Tree, tpt: Tree = TypeTree()) =
+  def makeClosure(params: List[ValDef], body: Tree, tpt: Tree = TypeTree(), inlineable: Boolean)(implicit ctx: Context) = {
+    var mods = synthetic
+    if (inlineable)
+      mods = mods.withAddedAnnotation(New(ref(defn.InlineAnnotType), Nil).withPos(body.pos))
     Block(
-      DefDef(nme.ANON_FUN, Nil, params :: Nil, tpt, body).withMods(synthetic),
+      DefDef(nme.ANON_FUN, Nil, params :: Nil, tpt, body).withMods(mods),
       Closure(Nil, Ident(nme.ANON_FUN), EmptyTree))
+  }
 
   /** If `nparams` == 1, expand partial function
    *

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

@@ -88,12 +88,6 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case mp => mp
   }
 
-  /** If tree is a closure, it's body, otherwise tree itself */
-  def closureBody(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = tree match {
-    case Block((meth @ DefDef(nme.ANON_FUN, _, _, _, _)) :: Nil, Closure(_, _, _)) => meth.rhs
-    case _ => tree
-  }
-
   /** If this is an application, its function part, stripping all
    *  Apply nodes (but leaving TypeApply nodes in). Otherwise the tree itself.
    */
@@ -311,6 +305,8 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       if (vdef.symbol.flags is Mutable) Impure else exprPurity(vdef.rhs)
     case _ =>
       Impure
+      // TODO: It seem like this should be exprPurity(tree)
+      // But if we do that the repl/vars test break. Need to figure out why that's the case.
   }
 
   /** The purity level of this expression.
@@ -327,13 +323,13 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     case EmptyTree
        | This(_)
        | Super(_, _)
-       | Literal(_) =>
+       | Literal(_)
+       | Closure(_, _, _) =>
       Pure
     case Ident(_) =>
       refPurity(tree)
     case Select(qual, _) =>
-      refPurity(tree).min(
-       if (tree.symbol.is(Inline)) Pure else exprPurity(qual))
+      refPurity(tree).min(exprPurity(qual))
     case TypeApply(fn, _) =>
       exprPurity(fn)
 /*
@@ -435,6 +431,36 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     }
   }
 
+  /** Decompose a call fn[targs](vargs_1)...(vargs_n)
+   *  into its constituents (where targs, vargss may be empty)
+   */
+  def decomposeCall(tree: Tree): (Tree, List[Tree], List[List[Tree]]) = tree match {
+    case Apply(fn, args) =>
+      val (meth, targs, argss) = decomposeCall(fn)
+      (meth, targs, argss :+ args)
+    case TypeApply(fn, targs) =>
+      val (meth, Nil, Nil) = decomposeCall(fn)
+      (meth, targs, Nil)
+    case _ =>
+      (tree, Nil, Nil)
+  }
+
+  /** An extractor for closures, either contained in a block or standalone.
+   */
+  object closure {
+    def unapply(tree: Tree): Option[(List[Tree], Tree, Tree)] = tree match {
+      case Block(_, Closure(env, meth, tpt)) => Some(env, meth, tpt)
+      case Closure(env, meth, tpt) => Some(env, meth, tpt)
+      case _ => None
+    }
+  }
+
+  /** If tree is a closure, its body, otherwise tree itself */
+  def closureBody(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = tree match {
+    case Block((meth @ DefDef(nme.ANON_FUN, _, _, _, _)) :: Nil, Closure(_, _, _)) => meth.rhs
+    case _ => tree
+  }
+
   /** The variables defined by a pattern, in reverse order of their appearance. */
   def patVars(tree: Tree)(implicit ctx: Context): List[Symbol] = {
     val acc = new TreeAccumulator[List[Symbol]] {

src/dotty/tools/dotc/ast/TreeTypeMap.scala

@@ -92,11 +92,20 @@ final class TreeTypeMap(
         case ddef @ DefDef(name, tparams, vparamss, tpt, _) =>
           val (tmap1, tparams1) = transformDefs(ddef.tparams)
           val (tmap2, vparamss1) = tmap1.transformVParamss(vparamss)
-          cpy.DefDef(ddef)(name, tparams1, vparamss1, tmap2.transform(tpt), tmap2.transform(ddef.rhs))
+          val res = cpy.DefDef(ddef)(name, tparams1, vparamss1, tmap2.transform(tpt), tmap2.transform(ddef.rhs))
+          res.symbol.transformAnnotations {
+            case ann: BodyAnnotation => ann.derivedAnnotation(res.rhs)
+            case ann => ann
+          }
+          res
         case blk @ Block(stats, expr) =>
           val (tmap1, stats1) = transformDefs(stats)
           val expr1 = tmap1.transform(expr)
           cpy.Block(blk)(stats1, expr1)
+        case inlined @ Inlined(call, bindings, expanded) =>
+          val (tmap1, bindings1) = transformDefs(bindings)
+          val expanded1 = tmap1.transform(expanded)
+          cpy.Inlined(inlined)(call, bindings1, expanded1)
         case cdef @ CaseDef(pat, guard, rhs) =>
           val tmap = withMappedSyms(patVars(pat))
           val pat1 = tmap.transform(pat)
@@ -127,10 +136,7 @@ final class TreeTypeMap(
 
   def apply[ThisTree <: tpd.Tree](tree: ThisTree): ThisTree = transform(tree).asInstanceOf[ThisTree]
 
-  def apply(annot: Annotation): Annotation = {
-    val tree1 = apply(annot.tree)
-    if (tree1 eq annot.tree) annot else ConcreteAnnotation(tree1)
-  }
+  def apply(annot: Annotation): Annotation = annot.derivedAnnotation(apply(annot.tree))
 
   /** The current tree map composed with a substitution [from -> to] */
   def withSubstitution(from: List[Symbol], to: List[Symbol]): TreeTypeMap =

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

@@ -12,7 +12,7 @@ import collection.immutable.IndexedSeq
 import collection.mutable.ListBuffer
 import parsing.Tokens.Token
 import printing.Printer
-import util.{Stats, Attachment, DotClass}
+import util.{Stats, Attachment, Property, DotClass}
 import annotation.unchecked.uncheckedVariance
 import language.implicitConversions
 import parsing.Scanners.Comment
@@ -30,8 +30,8 @@ object Trees {
   /** The total number of created tree nodes, maintained if Stats.enabled */
   @sharable var ntrees = 0
 
-  /** Attachment key for trees with documentation strings attached */
-  val DocComment = new Attachment.Key[Comment]
+  /** Property key for trees with documentation strings attached */
+  val DocComment = new Property.Key[Comment]
 
    @sharable private var nextId = 0 // for debugging
 
@@ -503,6 +503,25 @@ object Trees {
     override def toString = s"JavaSeqLiteral($elems, $elemtpt)"
   }
 
+  /** A tree representing inlined code.
+   *
+   *  @param  call      The original call that was inlined
+   *  @param  bindings  Bindings for proxies to be used in the inlined code
+   *  @param  expansion The inlined tree, minus bindings.
+   *
+   *  The full inlined code is equivalent to
+   *
+   *      { bindings; expansion }
+   *
+   *  The reason to keep `bindings` separate is because they are typed in a
+   *  different context: `bindings` represent the arguments to the inlined
+   *  call, whereas `expansion` represents the body of the inlined function.
+   */
+  case class Inlined[-T >: Untyped] private[ast] (call: tpd.Tree, bindings: List[MemberDef[T]], expansion: Tree[T])
+    extends Tree[T] {
+    type ThisTree[-T >: Untyped] = Inlined[T]
+  }
+
   /** A type tree that represents an existing or inferred type */
   case class TypeTree[-T >: Untyped] private[ast] (original: Tree[T])
     extends DenotingTree[T] with TypTree[T] {
@@ -797,6 +816,7 @@ object Trees {
     type Try = Trees.Try[T]
     type SeqLiteral = Trees.SeqLiteral[T]
     type JavaSeqLiteral = Trees.JavaSeqLiteral[T]
+    type Inlined = Trees.Inlined[T]
     type TypeTree = Trees.TypeTree[T]
     type SingletonTypeTree = Trees.SingletonTypeTree[T]
     type AndTypeTree = Trees.AndTypeTree[T]
@@ -939,6 +959,10 @@ object Trees {
         case tree: SeqLiteral if (elems eq tree.elems) && (elemtpt eq tree.elemtpt) => tree
         case _ => finalize(tree, untpd.SeqLiteral(elems, elemtpt))
       }
+      def Inlined(tree: Tree)(call: tpd.Tree, bindings: List[MemberDef], expansion: Tree)(implicit ctx: Context): Inlined = tree match {
+        case tree: Inlined if (call eq tree.call) && (bindings eq tree.bindings) && (expansion eq tree.expansion) => tree
+        case _ => finalize(tree, untpd.Inlined(call, bindings, expansion))
+      }
       def TypeTree(tree: Tree)(original: Tree): TypeTree = tree match {
         case tree: TypeTree if original eq tree.original => tree
         case _ => finalize(tree, untpd.TypeTree(original))
@@ -1083,6 +1107,8 @@ object Trees {
           cpy.Try(tree)(transform(block), transformSub(cases), transform(finalizer))
         case SeqLiteral(elems, elemtpt) =>
           cpy.SeqLiteral(tree)(transform(elems), transform(elemtpt))
+        case Inlined(call, bindings, expansion) =>
+          cpy.Inlined(tree)(call, transformSub(bindings), transform(expansion))
         case TypeTree(original) =>
           tree
         case SingletonTypeTree(ref) =>
@@ -1185,6 +1211,8 @@ object Trees {
             this(this(this(x, block), handler), finalizer)
           case SeqLiteral(elems, elemtpt) =>
             this(this(x, elems), elemtpt)
+          case Inlined(call, bindings, expansion) =>
+            this(this(x, bindings), expansion)
           case TypeTree(original) =>
             x
           case SingletonTypeTree(ref) =>