Cleanups

Better comments and refactorings that move some things around
so that less modules depend on Inliner.

Author: odersky

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

@@ -6,7 +6,6 @@ import core._
 import Types._, Contexts._, Constants._, Names._, Flags._
 import SymDenotations._, Symbols._, Annotations._, Trees._, Symbols._
 import Denotations._, Decorators._
-import config.Printers.inlining
 import dotty.tools.dotc.transform.SymUtils._
 
 /** A map that applies three functions and a substitution together to a tree and

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

@@ -11,6 +11,7 @@ import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._, Symbols.
 import Denotations._, Decorators._, DenotTransformers._
 import config.Printers._
 import collection.mutable
+import util.{Property, SourceFile, NoSource}
 import typer.ErrorReporting._
 
 import scala.annotation.tailrec
@@ -945,8 +946,25 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
   }
 
-  // ensure that constructors are fully applied?
-  // ensure that normal methods are fully applied?
+  /** A key to be used in a context property that tracks enclosing inlined calls */
+  private val InlinedCalls = new Property.Key[List[Tree]]
 
+  /** A context derived form `ctx` that records `call` as innermost enclosing
+   *  call for which the inlined version is currently processed.
+   */
+  def inlineContext(call: Tree)(implicit ctx: Context): Context =
+    ctx.fresh.setProperty(InlinedCalls, call :: enclosingInlineds)
+
+  /** All enclosing calls that are currently inlined, from innermost to outermost */
+  def enclosingInlineds(implicit ctx: Context): List[Tree] =
+    ctx.property(InlinedCalls).getOrElse(Nil)
+
+  /** The source file where the symbol of the `@inline` method referred to by `call`
+   *  is defined
+   */
+  def sourceFile(call: Tree)(implicit ctx: Context) = {
+    val file = call.symbol.sourceFile
+    if (file != null && file.exists) new SourceFile(file) else NoSource
+  }
 }
 

src/dotty/tools/dotc/core/Decorators.scala

@@ -7,8 +7,7 @@ import Contexts._, Names._, Phases._, printing.Texts._, printing.Printer, printi
 import util.Positions.Position, util.SourcePosition
 import collection.mutable.ListBuffer
 import dotty.tools.dotc.transform.TreeTransforms._
-import typer.Inliner
-import ast.tpd.Tree
+import ast.tpd._
 import scala.language.implicitConversions
 import printing.Formatting._
 
@@ -153,11 +152,11 @@ object Decorators {
   implicit def sourcePos(pos: Position)(implicit ctx: Context): SourcePosition = {
     def recur(inlinedCalls: List[Tree], pos: Position): SourcePosition = inlinedCalls match {
       case inlinedCall :: rest =>
-        Inliner.sourceFile(inlinedCall).atPos(pos).withOuter(recur(rest, inlinedCall.pos))
+        sourceFile(inlinedCall).atPos(pos).withOuter(recur(rest, inlinedCall.pos))
       case empty =>
         ctx.source.atPos(pos)
     }
-    recur(Inliner.enclosingInlineds, pos)
+    recur(enclosingInlineds, pos)
   }
 
   implicit class StringInterpolators(val sc: StringContext) extends AnyVal {

src/dotty/tools/dotc/core/TyperState.scala

@@ -123,7 +123,7 @@ extends TyperState(r) {
    *  that were temporarily instantiated in the current typer state are permanently
    *  instantiated instead.
    *
-   *  A note on merging: A case is in isApplicableSafe.scala. It turns out that this
+   *  A note on merging: An interesting test case is isApplicableSafe.scala. It turns out that this
    *  requires a context merge using the new `&' operator. Sequence of actions:
    *  1) Typecheck argument in typerstate 1.
    *  2) Cache argument.

src/dotty/tools/dotc/transform/TreeTransform.scala

@@ -15,7 +15,6 @@ import dotty.tools.dotc.core.Mode
 import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.util.DotClass
-import dotty.tools.dotc.typer.Inliner
 import scala.annotation.tailrec
 import config.Printers.transforms
 import scala.util.control.NonFatal
@@ -1175,7 +1174,7 @@ object TreeTransforms {
           if (mutatedInfo eq null) tree
           else {
             val bindings = transformSubTrees(tree.bindings, mutatedInfo, cur)
-            val expansion = transform(tree.expansion, mutatedInfo, cur)(Inliner.inlineContext(tree))
+            val expansion = transform(tree.expansion, mutatedInfo, cur)(inlineContext(tree))
             goInlined(cpy.Inlined(tree)(tree.call, bindings, expansion), mutatedInfo.nx.nxTransInlined(cur))
           }
         case tree: TypeTree =>

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

@@ -21,25 +21,21 @@ import transform.ExplicitOuter
 import Inferencing.fullyDefinedType
 import config.Printers.inlining
 import ErrorReporting.errorTree
-import util.{Property, SourceFile, NoSource}
 import collection.mutable
 import transform.TypeUtils._
 
 object Inliner {
   import tpd._
 
-  /** A key to be used in a context property that tracks enclosing inlined calls */
-  private val InlinedCalls = new Property.Key[List[Tree]] // to be used in context
-
   /** Adds accessors accessors for all non-public term members accessed
    *  from `tree`. Non-public type members are currently left as they are.
    *  This means that references to a private type will lead to typing failures
    *  on the code when it is inlined. Less than ideal, but hard to do better (see below).
-   *  
+   *
    *  @return If there are accessors generated, a thicket consisting of the rewritten `tree`
    *          and all accessors, otherwise the original tree.
    */
-  def makeInlineable(tree: Tree)(implicit ctx: Context) = {
+  private def makeInlineable(tree: Tree)(implicit ctx: Context) = {
 
     /** A tree map which inserts accessors for all non-public term members accessed
      *  from inlined code. Accesors are collected in the `accessors` buffer.
@@ -250,24 +246,6 @@ object Inliner {
     tpd.seq(inlined.bindings, reposition.transform(inlined.expansion))
   }
 
-  /** A context derived form `ctx` that records `call` as innermost enclosing
-   *  call for which the inlined version is currently processed.
-   */
-  def inlineContext(call: Tree)(implicit ctx: Context): Context =
-    ctx.fresh.setProperty(InlinedCalls, call :: enclosingInlineds)
-
-  /** All enclosing calls that are currently inlined, from innermost to outermost */
-  def enclosingInlineds(implicit ctx: Context): List[Tree] =
-    ctx.property(InlinedCalls).getOrElse(Nil)
-
-  /** The source file where the symbol of the `@inline` method referred to by `call`
-   *  is defined
-   */
-  def sourceFile(call: Tree)(implicit ctx: Context) = {
-    val file = call.symbol.sourceFile
-    if (file != null && file.exists) new SourceFile(file) else NoSource
-  }
-
   /** The qualifier part of a Select, Ident, or SelectFromTypeTree tree.
    *  For an Ident, this is the `This` of the current class. (TODO: use elsewhere as well?)
    */

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

@@ -920,7 +920,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
 
   def typedInlined(tree: untpd.Inlined, pt: Type)(implicit ctx: Context): Inlined = {
     val (exprCtx, bindings1) = typedBlockStats(tree.bindings)
-    val expansion1 = typed(tree.expansion, pt)(Inliner.inlineContext(tree.call)(exprCtx))
+    val expansion1 = typed(tree.expansion, pt)(inlineContext(tree.call)(exprCtx))
     assignType(cpy.Inlined(tree)(tree.call, bindings1.asInstanceOf[List[MemberDef]], expansion1),
         bindings1, expansion1)
   }