Merge branch 'master' into error-msg/stable-identifiers

Author: Hermes Espínola González

.drone.yml

@@ -52,7 +52,7 @@ pipeline:
     image: lampepfl/dotty:2018-10-01
     commands:
       - ./project/scripts/genDocs
-    secrets: [ bot_pass ]
+    secrets: [ bot_token ]
     when:
       event: push
       # We only generate the documentation for the master branch
@@ -114,7 +114,3 @@ pipeline:
     when:
       status: [ failure ]
       event: [ push, tag, deployment ]
-
-branches:
-  # The gh-pages branch holds the documentation and don't need to be built
-  exclude: gh-pages

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

@@ -3,12 +3,14 @@ package dotc
 
 import util.SourceFile
 import ast.{tpd, untpd}
-import tpd.{ Tree, TreeTraverser }
+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) {
 
@@ -23,10 +25,10 @@ class CompilationUnit(val source: SourceFile) {
   /** Pickled TASTY binaries, indexed by class. */
   var pickled: Map[ClassSymbol, Array[Byte]] = Map()
 
-  /** Will be reset to `true` if `untpdTree` contains `Quote` trees. The information
-   *  is used in phase ReifyQuotes in order to avoid traversing a quote-less tree.
+  /** 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.
    */
-  var containsQuotesOrSplices: Boolean = false
+  var needsStaging: Boolean = false
 
   /** A structure containing a temporary map for generating inline accessors */
   val inlineAccessors: InlineAccessors = new InlineAccessors
@@ -46,17 +48,18 @@ object CompilationUnit {
     if (forceTrees) {
       val force = new Force
       force.traverse(unit1.tpdTree)
-      unit1.containsQuotesOrSplices = force.containsQuotes
+      unit1.needsStaging = force.needsStaging
     }
     unit1
   }
 
   /** Force the tree to be loaded */
   private class Force extends TreeTraverser {
-    var containsQuotes = false
+    var needsStaging = false
     def traverse(tree: Tree)(implicit ctx: Context): Unit = {
-      if (tree.symbol.isQuote)
-        containsQuotes = true
+      // Note that top-level splices are still inside the inline methods
+      if (tree.symbol.isQuote || tpd.isInlineCall(tree))
+        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 ReifyQuotes) ::        // Turn quoted trees into explicit run-time data structures
+    List(new Staging) ::            // Inline calls, expand macros and turn quoted trees into explicit run-time data structures
     Nil
 
   /** Phases dealing with the transformation from pickled trees to backend trees */
@@ -69,8 +69,7 @@ class Compiler {
          new ExplicitOuter,          // Add accessors to outer classes from nested ones.
          new ExplicitSelf,           // Make references to non-trivial self types explicit as casts
          new StringInterpolatorOpt,  // Optimizes raw and s string interpolators by rewriting them to string concatentations
-         new CrossCastAnd,           // Normalize selections involving intersection types.
-         new Splitter) ::            // Expand selections involving union types into conditionals
+         new CrossCastAnd) ::        // Normalize selections involving intersection types.
     List(new PruneErasedDefs,        // Drop erased definitions from scopes and simplify erased expressions
          new VCInlineMethods,        // Inlines calls to value class methods
          new SeqLiterals,            // Express vararg arguments as arrays

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

@@ -34,6 +34,9 @@ class Driver {
         case ex: FatalError  =>
           ctx.error(ex.getMessage) // signals that we should fail compilation.
           ctx.reporter
+        case ex: Throwable =>
+          println(s"$ex while compiling ${fileNames.mkString(", ")}")
+          throw ex
       }
     else ctx.reporter
 

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

@@ -870,10 +870,21 @@ object desugar {
    *      def pn = x$1._n
    *      body
    *    }
+   *
+   *  or if `isGenericTuple`
+   *
+   *    x$1 => {
+   *      def p1 = x$1.apply(0)
+   *      ...
+   *      def pn = x$1.apply(n-1)
+   *      body
+   *    }
    */
-  def makeTupledFunction(params: List[ValDef], body: Tree)(implicit ctx: Context): Tree = {
+  def makeTupledFunction(params: List[ValDef], body: Tree, isGenericTuple: Boolean)(implicit ctx: Context): Tree = {
     val param = makeSyntheticParameter()
-    def selector(n: Int) = Select(refOfDef(param), nme.selectorName(n))
+    def selector(n: Int) =
+      if (isGenericTuple) Apply(Select(refOfDef(param), nme.apply), Literal(Constant(n)))
+      else Select(refOfDef(param), nme.selectorName(n))
     val vdefs =
       params.zipWithIndex.map{
         case (param, idx) =>

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
+import typer.{ConstFold, Inliner}
 import reporting.trace
 
 import scala.annotation.tailrec
@@ -737,6 +737,17 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     case _ => This(ctx.owner.enclosingClass.asClass)
   }
 
+  /** Is this an application on a structural selection?
+   *
+   *  @see isStructuralTermSelect
+   */
+  def isStructuralTermApply(tree: Tree)(implicit ctx: Context): Boolean = tree match {
+    case Apply(fun, _) =>
+      isStructuralTermSelect(fun)
+    case _ =>
+      false
+  }
+
   /** Is this a selection of a member of a structural type that is not a member
    *  of an underlying class or trait?
    */
@@ -759,6 +770,14 @@ 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

@@ -484,8 +484,10 @@ object Trees {
 
   /** { stats; expr } */
   case class Block[-T >: Untyped] private[ast] (stats: List[Tree[T]], expr: Tree[T])
-    extends TermTree[T] {
+    extends Tree[T] {
     type ThisTree[-T >: Untyped] = Block[T]
+    override def isType: Boolean = expr.isType
+    override def isTerm: Boolean = !isType // this will classify empty trees as terms, which is necessary
   }
 
   /** if cond then thenp else elsep */
@@ -583,9 +585,8 @@ object Trees {
 
   /** A tree representing inlined code.
    *
-   *  @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  call      Info about the original call that was inlined.
+   *                    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/ast/tpd.scala

@@ -40,11 +40,15 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Super(qual: Tree, mixName: TypeName, inConstrCall: Boolean, mixinClass: Symbol = NoSymbol)(implicit ctx: Context): Super =
     Super(qual, if (mixName.isEmpty) untpd.EmptyTypeIdent else untpd.Ident(mixName), inConstrCall, mixinClass)
 
-  def Apply(fn: Tree, args: List[Tree])(implicit ctx: Context): Apply =
+  def Apply(fn: Tree, args: List[Tree])(implicit ctx: Context): Apply = {
+    assert(fn.isInstanceOf[RefTree] || fn.isInstanceOf[GenericApply[_]])
     ta.assignType(untpd.Apply(fn, args), fn, args)
+  }
 
-  def TypeApply(fn: Tree, args: List[Tree])(implicit ctx: Context): TypeApply =
+  def TypeApply(fn: Tree, args: List[Tree])(implicit ctx: Context): TypeApply = {
+    assert(fn.isInstanceOf[RefTree] || fn.isInstanceOf[GenericApply[_]])
     ta.assignType(untpd.TypeApply(fn, args), fn, args)
+  }
 
   def Literal(const: Constant)(implicit ctx: Context): Literal =
     ta.assignType(untpd.Literal(const))
@@ -181,8 +185,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Alternative(trees: List[Tree])(implicit ctx: Context): Alternative =
     ta.assignType(untpd.Alternative(trees), trees)
 
-  def UnApply(fun: Tree, implicits: List[Tree], patterns: List[Tree], proto: Type)(implicit ctx: Context): UnApply =
+  def UnApply(fun: Tree, implicits: List[Tree], patterns: List[Tree], proto: Type)(implicit ctx: Context): UnApply = {
+    assert(fun.isInstanceOf[RefTree] || fun.isInstanceOf[GenericApply[_]])
     ta.assignType(untpd.UnApply(fun, implicits, patterns), proto)
+  }
 
   def ValDef(sym: TermSymbol, rhs: LazyTree = EmptyTree)(implicit ctx: Context): ValDef =
     ta.assignType(untpd.ValDef(sym.name, TypeTree(sym.info), rhs), sym)
@@ -913,7 +919,17 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def outerSelect(levels: Int, tp: Type)(implicit ctx: Context): Tree =
       untpd.Select(tree, OuterSelectName(EmptyTermName, levels)).withType(SkolemType(tp))
 
-    def underlyingArgument(implicit ctx: Context): Tree = mapToUnderlying.transform(tree)
+    /** Replace Inlined nodes and InlineProxy references to underlying arguments */
+    def underlyingArgument(implicit ctx: Context): Tree = {
+      val mapToUnderlying = new MapToUnderlying {
+        override def skipLocal(sym: Symbol): Boolean =
+          sym.is(InlineProxy) || sym.is(Synthetic)
+      }
+      mapToUnderlying.transform(tree)
+    }
+
+    /** Replace Ident nodes references to the underlying tree that defined them */
+    def underlying(implicit ctx: Context): Tree = new MapToUnderlying().transform(tree)
 
     // --- Higher order traversal methods -------------------------------
 
@@ -941,18 +957,22 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
   }
 
-  /** Map Inlined nodes, InlineProxy references and Synthetic val references to underlying arguments */
-  object mapToUnderlying extends TreeMap {
+  /** Map Inlined nodes, NamedArgs, Blocks with no statements and local references to underlying arguments.
+   *  Also drops Inline and Block with no statements.
+   */
+  class MapToUnderlying extends TreeMap {
     override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
-      case tree: Ident if tree.symbol.is(InlineProxy) || (tree.symbol.is(Synthetic) && !tree.symbol.owner.isClass) =>
+      case tree: Ident if !tree.symbol.owner.isClass && skipLocal(tree.symbol) =>
         tree.symbol.defTree match {
           case defTree: ValOrDefDef => transform(defTree.rhs)
           case _ => tree
         }
       case Inlined(_, _, arg) => transform(arg)
+      case Block(Nil, arg) => transform(arg)
       case NamedArg(_, arg) => transform(arg)
       case tree => super.transform(tree)
     }
+    def skipLocal(sym: Symbol): Boolean = true
   }
 
   implicit class ListOfTreeDecorator(val xs: List[tpd.Tree]) extends AnyVal {

compiler/src/dotty/tools/dotc/config/Printers.scala

@@ -28,6 +28,7 @@ object Printers {
   val overload: Printer = noPrinter
   val patmatch: Printer = noPrinter
   val pickling: Printer = noPrinter
+  val quotePickling: Printer = noPrinter
   val plugins: Printer = noPrinter
   val simplify: Printer = noPrinter
   val subtyping: Printer = noPrinter

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -116,6 +116,7 @@ class ScalaSettings extends Settings.SettingGroup {
   val YprintDebug: Setting[Boolean] = BooleanSetting("-Yprint-debug", "when printing trees, print some extra information useful for debugging.")
   val YprintDebugOwners: Setting[Boolean] = BooleanSetting("-Yprint-debug-owners", "when printing trees, print owners of definitions.")
   val YshowPrintErrors: Setting[Boolean] = BooleanSetting("-Yshow-print-errors", "don't suppress exceptions thrown during tree printing.")
+  val YshowRawQuoteTrees: Setting[Boolean] = BooleanSetting("-Yshow-raw-tree", "don't remove quote artifacts")
   val YtestPickler: Setting[Boolean] = BooleanSetting("-Ytest-pickler", "self-test for pickling functionality; should be used with -Ystop-after:pickler")
   val YcheckReentrant: Setting[Boolean] = BooleanSetting("-Ycheck-reentrant", "check that compiled program does not contain vars that can be accessed from a global root.")
   val YdropComments: Setting[Boolean] = BooleanSetting("-Ydrop-comments", "Drop comments when scanning source files.")

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

@@ -24,9 +24,6 @@ object Definitions {
    *  else without affecting the set of programs that can be compiled.
    */
   val MaxImplementedFunctionArity: Int = 22
-
-  /** The maximal arity of a function that can be accessed as member of a structural type */
-  val MaxStructuralMethodArity: Int = 7
 }
 
 /** A class defining symbols and types of standard definitions

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

@@ -501,7 +501,6 @@ object StdNames {
     val scala_ : N              = "scala"
     val scalaShadowing : N      = "scalaShadowing"
     val selectDynamic: N        = "selectDynamic"
-    val selectDynamicMethod: N  = "selectDynamicMethod"
     val selectOverloadedMethod: N = "selectOverloadedMethod"
     val selectTerm: N           = "selectTerm"
     val selectType: N           = "selectType"

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

@@ -1631,7 +1631,10 @@ object SymDenotations {
           Stats.record("basetype cache entries")
           if (!baseTp.exists) Stats.record("basetype cache NoTypes")
         }
-        btrCache.put(tp, baseTp)
+        if (!tp.isProvisional)
+          btrCache.put(tp, baseTp)
+        else
+          btrCache.remove(tp) // Remove any potential sentinel value
       }
 
       def ensureAcyclic(baseTp: Type) = {
@@ -1682,8 +1685,8 @@ object SymDenotations {
                 case _ =>
                   val superTp = tp.superType
                   val baseTp = recur(superTp)
-                  if (inCache(superTp) && tp.symbol.maybeOwner.isType)
-                    record(tp, baseTp)   // typeref cannot be a GADT, so cache is stable
+                  if (inCache(superTp))
+                    record(tp, baseTp)
                   else
                     btrCache.remove(tp)
                   baseTp
@@ -1717,8 +1720,6 @@ object SymDenotations {
               val baseTp = recur(superTp)
               tp match {
                 case tp: CachedType if baseTp.exists && inCache(superTp) =>
-                  // Note: This also works for TypeVars: If they are not instantiated, their supertype
-                  // is a TypeParamRef, which is never cached. So uninstantiated TypeVars are not cached either.
                   record(tp, baseTp)
                 case _ =>
               }