Merge remote-tracking branch 'upstream/master' into batch-files

Author: michelou

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

@@ -39,6 +39,7 @@ class Compiler {
     List(new sbt.ExtractDependencies) :: // Sends information on classes' dependencies to sbt via callbacks
     List(new PostTyper) ::          // Additional checks and cleanups after type checking
     List(new sbt.ExtractAPI) ::     // Sends a representation of the API of classes to sbt via callbacks
+    List(new SetRootTree) ::        // Set the `rootTreeOrProvider` on class symbols
     Nil
 
   /** Phases dealing with TASTY tree pickling and unpickling */

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

@@ -61,7 +61,7 @@ class Driver {
   }
 
   /** Setup extra classpath and figure out class names for tasty file inputs */
-  private def fromTastySetup(fileNames0: List[String], ctx0: Context) = {
+  protected def fromTastySetup(fileNames0: List[String], ctx0: Context): (List[String], Context) = {
     if (ctx0.settings.fromTasty.value(ctx0)) {
       // Resolve classpath and class names of tasty files
       val (classPaths, classNames) = fileNames0.map { name =>

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

@@ -200,7 +200,8 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
 
   /** Enter top-level definitions of classes and objects contain in Scala source file `file`.
    *  The newly added symbols replace any previously entered symbols.
-   *  If `typeCheck = true`, also run typer on the compilation unit.
+   *  If `typeCheck = true`, also run typer on the compilation unit, and set
+   *  `rootTreeOrProvider`.
    */
   def lateCompile(file: AbstractFile, typeCheck: Boolean)(implicit ctx: Context): Unit =
     if (!files.contains(file) && !lateFiles.contains(file)) {
@@ -211,9 +212,13 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
           if (unit.isJava) new JavaParser(unit.source).parse()
           else new Parser(unit.source).parse()
         ctx.typer.lateEnter(unit.untpdTree)
-        def typeCheckUnit() = unit.tpdTree = ctx.typer.typedExpr(unit.untpdTree)
+        def processUnit() = {
+          unit.tpdTree = ctx.typer.typedExpr(unit.untpdTree)
+          val phase = new transform.SetRootTree()
+          phase.run
+        }
         if (typeCheck)
-          if (compiling) finalizeActions += (() => typeCheckUnit()) else typeCheckUnit()
+          if (compiling) finalizeActions += (() => processUnit()) else processUnit()
       }
       process()(runContext.fresh.setCompilationUnit(unit))
     }

compiler/src/dotty/tools/dotc/interactive/Interactive.scala

@@ -8,6 +8,7 @@ import scala.collection._
 import ast.{NavigateAST, Trees, tpd, untpd}
 import core._, core.Decorators.{sourcePos => _, _}
 import Contexts._, Flags._, Names._, NameOps._, Symbols._, Trees._, Types._
+import transform.SymUtils.decorateSymbol
 import util.Positions._, util.SourceFile, util.SourcePosition
 import core.Denotations.SingleDenotation
 import NameKinds.SimpleNameKind
@@ -33,6 +34,7 @@ object Interactive {
       def isDefinitions: Boolean = (bits & definitions.bits) != 0
       def isLinkedClass: Boolean = (bits & linkedClass.bits) != 0
       def isImports: Boolean = (bits & imports.bits) != 0
+      def isLocal: Boolean = (bits & local.bits) != 0
     }
 
     /** The empty set */
@@ -41,10 +43,7 @@ object Interactive {
     /** Include trees whose symbol is overridden by `sym` */
     val overridden: Set = Set(1 << 0)
 
-    /**
-     * Include trees whose symbol overrides `sym` (but for performance only in same source
-     * file)
-     */
+    /** Include trees whose symbol overrides `sym` */
     val overriding: Set = Set(1 << 1)
 
     /** Include references */
@@ -59,6 +58,9 @@ object Interactive {
     /** Include imports in the results */
     val imports: Set = Set(1 << 5)
 
+    /** Include local symbols, inspect local trees */
+    val local: Set = Set(1 << 6)
+
     /** All the flags */
     val all: Set = Set(~0)
   }
@@ -164,40 +166,44 @@ object Interactive {
     else
       namedTrees(trees, include, matchSymbol(_, sym, include))
 
-  /** Find named trees with a non-empty position whose name contains `nameSubstring` in `trees`.
-   */
-  def namedTrees(trees: List[SourceTree], nameSubstring: String)
-   (implicit ctx: Context): List[SourceTree] = {
-    val predicate: NameTree => Boolean = _.name.toString.contains(nameSubstring)
-    namedTrees(trees, Include.empty, predicate)
-  }
-
   /** Find named trees with a non-empty position satisfying `treePredicate` in `trees`.
    *
-   *  @param includeReferences  If true, include references and not just definitions
+   *  @param trees         The trees to inspect.
+   *  @param include       Whether to include references, definitions, etc.
+   *  @param treePredicate An additional predicate that the trees must match.
+   *  @return The trees with a non-empty position satisfying `treePredicate`.
    */
-  def namedTrees(trees: List[SourceTree], include: Include.Set, treePredicate: NameTree => Boolean)
-    (implicit ctx: Context): List[SourceTree] = safely {
+  def namedTrees(trees: List[SourceTree],
+                 include: Include.Set,
+                 treePredicate: NameTree => Boolean = util.common.alwaysTrue
+                )(implicit ctx: Context): List[SourceTree] = safely {
     val buf = new mutable.ListBuffer[SourceTree]
 
     def traverser(source: SourceFile) = {
       new untpd.TreeTraverser {
+        private def handle(utree: untpd.NameTree): Unit = {
+          val tree = utree.asInstanceOf[tpd.NameTree]
+          if (tree.symbol.exists
+               && !tree.symbol.is(Synthetic)
+               && !tree.symbol.isPrimaryConstructor
+               && tree.pos.exists
+               && !tree.pos.isZeroExtent
+               && (include.isReferences || isDefinition(tree))
+               && treePredicate(tree))
+            buf += SourceTree(tree, source)
+        }
         override def traverse(tree: untpd.Tree)(implicit ctx: Context) = {
           tree match {
             case imp: untpd.Import if include.isImports && tree.hasType =>
               val tree = imp.asInstanceOf[tpd.Import]
               val selections = tpd.importSelections(tree)
               traverse(imp.expr)
               selections.foreach(traverse)
+            case utree: untpd.ValOrDefDef if tree.hasType =>
+              handle(utree)
+              if (include.isLocal) traverseChildren(tree)
             case utree: untpd.NameTree if tree.hasType =>
-              val tree = utree.asInstanceOf[tpd.NameTree]
-              if (tree.symbol.exists
-                   && !tree.symbol.is(Synthetic)
-                   && tree.pos.exists
-                   && !tree.pos.isZeroExtent
-                   && (include.isReferences || isDefinition(tree))
-                   && treePredicate(tree))
-                buf += SourceTree(tree, source)
+              handle(utree)
               traverseChildren(tree)
             case tree: untpd.Inlined =>
               traverse(tree.call)
@@ -228,8 +234,7 @@ object Interactive {
                        )(implicit ctx: Context): List[SourceTree] = {
     val linkedSym = symbol.linkedClass
     val fullPredicate: NameTree => Boolean = tree =>
-      (  !tree.symbol.isPrimaryConstructor
-      && (includes.isDefinitions || !Interactive.isDefinition(tree))
+      (  (includes.isDefinitions || !Interactive.isDefinition(tree))
       && (  Interactive.matchSymbol(tree, symbol, includes)
          || ( includes.isLinkedClass
             && linkedSym.exists
@@ -320,34 +325,46 @@ object Interactive {
     path.find(_.isInstanceOf[DefTree]).getOrElse(EmptyTree)
 
   /**
-   * Find the definitions of the symbol at the end of `path`.
+   * Find the definitions of the symbol at the end of `path`. In the case of an import node,
+   * all imported symbols will be considered.
    *
    * @param path   The path to the symbol for which we want the definitions.
    * @param driver The driver responsible for `path`.
    * @return The definitions for the symbol at the end of `path`.
    */
-  def findDefinitions(path: List[Tree], pos: SourcePosition, driver: InteractiveDriver)(implicit ctx: Context): List[SourceTree] = {
-    enclosingSourceSymbols(path, pos).flatMap { sym =>
-      val enclTree = enclosingTree(path)
-
-      val (trees, include) =
-        if (enclTree.isInstanceOf[MemberDef])
-          (driver.allTreesContaining(sym.name.sourceModuleName.toString),
-            Include.definitions | Include.overriding | Include.overridden)
-        else sym.topLevelClass match {
-          case cls: ClassSymbol =>
-            val trees = Option(cls.sourceFile).flatMap(InteractiveDriver.toUriOption) match {
-              case Some(uri) if driver.openedTrees.contains(uri) =>
-                driver.openedTrees(uri)
-              case _ => // Symbol comes from the classpath
-                SourceTree.fromSymbol(cls).toList
-            }
-            (trees, Include.definitions | Include.overriding)
-          case _ =>
-            (Nil, Include.empty)
-        }
+  def findDefinitions(path: List[Tree], pos: SourcePosition, driver: InteractiveDriver): List[SourceTree] = {
+    implicit val ctx = driver.currentCtx
+    val enclTree = enclosingTree(path)
+    val includeOverridden = enclTree.isInstanceOf[MemberDef]
+    val symbols = enclosingSourceSymbols(path, pos)
+    val includeExternal = symbols.exists(!_.isLocal)
+    findDefinitions(symbols, driver, includeOverridden, includeExternal)
+  }
 
-      findTreesMatching(trees, include, sym)
+  /**
+   * Find the definitions of `symbols`.
+   *
+   * @param symbols           The list of symbols for which to find a definition.
+   * @param driver            The driver responsible for the given symbols.
+   * @param includeOverridden If true, also include the symbols overridden by any of `symbols`.
+   * @param includeExternal   If true, also look for definitions on the classpath.
+   * @return The definitions for the symbols in `symbols`, and if `includeOverridden` is set, the
+   *         definitions for the symbols that they override.
+   */
+  def findDefinitions(symbols: List[Symbol],
+                      driver: InteractiveDriver,
+                      includeOverridden: Boolean,
+                      includeExternal: Boolean): List[SourceTree] = {
+    implicit val ctx = driver.currentCtx
+    val include = Include.definitions | Include.overriding |
+      (if (includeOverridden) Include.overridden else Include.empty)
+    symbols.flatMap { sym =>
+      val name = sym.name.sourceModuleName.toString
+      val includeLocal = if (sym.exists && sym.isLocal) Include.local else Include.empty
+      val trees =
+        if (includeExternal) driver.allTreesContaining(name)
+        else driver.sourceTreesContaining(name)
+      findTreesMatching(trees, include | includeLocal, sym)
     }
   }
 

compiler/src/dotty/tools/dotc/interactive/InteractiveCompiler.scala

@@ -13,6 +13,7 @@ class InteractiveCompiler extends Compiler {
   // after each phase group instead of waiting for the pipeline to finish.
   override def phases: List[List[Phase]] = List(
     List(new FrontEnd),
+    List(new transform.SetRootTree),
     List(new transform.CookComments)
   )
 }

compiler/src/dotty/tools/dotc/tastyreflect/QuotedOpsImpl.scala

@@ -1,9 +1,6 @@
 package dotty.tools.dotc.tastyreflect
 
-import dotty.tools.dotc.core.Contexts.FreshContext
 import dotty.tools.dotc.core.quoted.PickledQuotes
-import dotty.tools.dotc.reporting.Reporter
-import dotty.tools.dotc.reporting.diagnostic.MessageContainer
 
 trait QuotedOpsImpl extends scala.tasty.reflect.QuotedOps with CoreImpl {
 
@@ -18,30 +15,17 @@ trait QuotedOpsImpl extends scala.tasty.reflect.QuotedOps with CoreImpl {
   def TermToQuoteDeco(term: Term): TermToQuotedAPI = new TermToQuotedAPI {
 
     def seal[T: scala.quoted.Type](implicit ctx: Context): scala.quoted.Expr[T] = {
-      typecheck(ctx)
+      typecheck()
       new scala.quoted.Exprs.TastyTreeExpr(term).asInstanceOf[scala.quoted.Expr[T]]
     }
 
-    private def typecheck[T: scala.quoted.Type](ctx: Context): Unit = {
-      implicit val ctx0: FreshContext = ctx.fresh
-      ctx0.setTyperState(ctx0.typerState.fresh())
-      ctx0.typerState.setReporter(new Reporter {
-        def doReport(m: MessageContainer)(implicit ctx: Context): Unit = ()
-      })
-      val tp = QuotedTypeDeco(implicitly[scala.quoted.Type[T]]).unseal
-      ctx0.typer.typed(term, tp.tpe)
-      if (ctx0.reporter.hasErrors) {
-        val stack = new Exception().getStackTrace
-        def filter(elem: StackTraceElement) =
-          elem.getClassName.startsWith("dotty.tools.dotc.tasty.ReflectionImpl") ||
-            !elem.getClassName.startsWith("dotty.tools.dotc")
+    private def typecheck[T: scala.quoted.Type]()(implicit ctx: Context): Unit = {
+      val tpt = QuotedTypeDeco(implicitly[scala.quoted.Type[T]]).unseal
+      if (!(term.tpe <:< tpt.tpe)) {
         throw new scala.tasty.TastyTypecheckError(
-          s"""Error during tasty reflection while typing term
-             |term: ${term.show}
-             |with expected type: ${tp.tpe.show}
-             |
-               |  ${stack.takeWhile(filter).mkString("\n  ")}
-             """.stripMargin
+          s"""Term: ${term.show}
+             |did not conform to type: ${tpt.tpe.show}
+             |""".stripMargin
         )
       }
     }

compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala

@@ -236,12 +236,8 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
     }
 
     object Select extends SelectExtractor {
-      def unapply(x: Term)(implicit ctx: Context): Option[(Term, String, Option[Signature])] = x match {
-        case x: tpd.Select if x.isTerm =>
-          val sig =
-            if (x.symbol.signature == core.Signature.NotAMethod) None
-            else Some(x.symbol.signature)
-          Some((x.qualifier, x.name.toString, sig))
+      def unapply(x: Term)(implicit ctx: Context): Option[(Term, String)] = x match {
+        case x: tpd.Select if x.isTerm => Some((x.qualifier, x.name.toString))
         case _ => None
       }
     }

compiler/src/dotty/tools/dotc/transform/SetRootTree.scala

@@ -0,0 +1,44 @@
+package dotty.tools.dotc.transform
+
+import dotty.tools.dotc.CompilationUnit
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Phases.Phase
+
+/** Set the `rootTreeOrProvider` property of class symbols. */
+class SetRootTree extends Phase {
+
+  override val phaseName: String = SetRootTree.name
+  override def isRunnable(implicit ctx: Context) =
+    super.isRunnable && ctx.settings.YretainTrees.value
+
+  override def run(implicit ctx: Context): Unit = {
+    val tree = ctx.compilationUnit.tpdTree
+    traverser.traverse(tree)
+  }
+
+  private def traverser = new tpd.TreeTraverser {
+    override def traverse(tree: tpd.Tree)(implicit ctx: Context): Unit = {
+      tree match {
+        case pkg: tpd.PackageDef =>
+          traverseChildren(pkg)
+        case td: tpd.TypeDef =>
+          if (td.symbol.isClass) {
+            val sym = td.symbol.asClass
+            tpd.sliceTopLevel(ctx.compilationUnit.tpdTree, sym) match {
+              case (pkg: tpd.PackageDef) :: Nil =>
+                sym.rootTreeOrProvider = pkg
+              case _ =>
+                sym.rootTreeOrProvider = td
+            }
+          }
+        case _ =>
+          ()
+      }
+    }
+  }
+}
+
+object SetRootTree {
+  val name: String = "SetRootTree"
+}

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

@@ -1642,7 +1642,11 @@ class Typer extends Namer
       // check value class constraints
       checkDerivedValueClass(cls, body1)
 
-      if (ctx.settings.YretainTrees.value) cls.rootTreeOrProvider = cdef1
+
+      // Temporarily set the typed class def as root tree so that we have at least some
+      // information in the IDE in case we never reach `SetRootTree`.
+      if (ctx.mode.is(Mode.Interactive) && ctx.settings.YretainTrees.value)
+        cls.rootTreeOrProvider = cdef1
 
       cdef1
 

doc-tool/src/dotty/tools/dottydoc/DocDriver.scala

@@ -27,7 +27,7 @@ class DocDriver extends Driver {
     ctx.setProperty(ContextDoc, new ContextDottydoc)
 
     val fileNames = CompilerCommand.checkUsage(summary, sourcesRequired)(ctx)
-    (fileNames, ctx)
+    fromTastySetup(fileNames, ctx)
   }
 
   override def newCompiler(implicit ctx: Context): Compiler = new DocCompiler

doc-tool/src/dotty/tools/dottydoc/core/TypeLinkingPhases.scala

@@ -106,7 +106,7 @@ trait TypeLinker extends MemberLookup {
         ref.copy(left = linkReference(ent, left, packs), right = linkReference(ent, right, packs))
       case ref @ NamedReference(_, rf, _, _) =>
         ref.copy(ref = linkRef(rf))
-      case ref @ FunctionReference(args, rv) =>
+      case ref @ FunctionReference(args, rv, _) =>
         ref.copy(args = args.map(linkReference(ent, _, packs)), returnValue = linkReference(ent, rv, packs))
       case ref @ TupleReference(args) =>
         ref.copy(args = args.map(linkRef))