Add native Dotty REPL

build.sbt

@@ -18,6 +18,7 @@ val `dotty-bench-bootstrapped` = Build.`dotty-bench-bootstrapped`
 val `scala-library` = Build.`scala-library`
 val `scala-compiler` = Build.`scala-compiler`
 val `scala-reflect` = Build.`scala-reflect`
+val `dotty-repl` = Build.`dotty-repl`
 val scalap = Build.scalap
 val dist = Build.dist
 val `dist-bootstrapped` = Build.`dist-bootstrapped`

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

@@ -16,8 +16,6 @@ object Bench extends Driver {
 
   @sharable private var numRuns = 1
 
-  def newCompiler(implicit ctx: Context): Compiler = new Compiler
-
   private def ntimes(n: Int)(op: => Reporter): Reporter =
     (emptyReporter /: (0 until n)) ((_, _) => op)
 

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

@@ -116,41 +116,13 @@ class Compiler {
     runId += 1; runId
   }
 
-  /** Produces the following contexts, from outermost to innermost
-   *
-   *    bootStrap:   A context with next available runId and a scope consisting of
-   *                 the RootPackage _root_
-   *    start        A context with RootClass as owner and the necessary initializations
-   *                 for type checking.
-   *    imports      For each element of RootImports, an import context
-   */
-  def rootContext(implicit ctx: Context): Context = {
-    ctx.initialize()(ctx)
-    ctx.setPhasePlan(phases)
-    val rootScope = new MutableScope
-    val bootstrap = ctx.fresh
-      .setPeriod(Period(nextRunId, FirstPhaseId))
-      .setScope(rootScope)
-    rootScope.enter(ctx.definitions.RootPackage)(bootstrap)
-    val start = bootstrap.fresh
-      .setOwner(defn.RootClass)
-      .setTyper(new Typer)
-      .addMode(Mode.ImplicitsEnabled)
-      .setTyperState(new MutableTyperState(ctx.typerState, ctx.typerState.reporter, isCommittable = true))
-      .setFreshNames(new FreshNameCreator.Default)
-    ctx.initialize()(start) // re-initialize the base context with start
-    def addImport(ctx: Context, refFn: () => TermRef) =
-      ctx.fresh.setImportInfo(ImportInfo.rootImport(refFn)(ctx))
-    (start.setRunInfo(new RunInfo(start)) /: defn.RootImportFns)(addImport)
-  }
-
   def reset()(implicit ctx: Context): Unit = {
     ctx.base.reset()
     ctx.runInfo.clear()
   }
 
   def newRun(implicit ctx: Context): Run = {
     reset()
-    new Run(this)(rootContext)
+    new Run(this, ctx)
   }
 }

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

@@ -13,9 +13,9 @@ import scala.util.control.NonFatal
  *  process, but in most cases you only need to call [[process]] on the
  *  existing object [[Main]].
  */
-abstract class Driver extends DotClass {
+class Driver extends DotClass {
 
-  protected def newCompiler(implicit ctx: Context): Compiler
+  protected def newCompiler(implicit ctx: Context): Compiler = new Compiler
 
   protected def emptyReporter: Reporter = new StoreReporter(null)
 

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

@@ -45,11 +45,11 @@ object FromTasty extends Driver {
 
     override def newRun(implicit ctx: Context): Run = {
       reset()
-      new TASTYRun(this)(rootContext)
+      new TASTYRun(this, ctx)
     }
   }
 
-  class TASTYRun(comp: Compiler)(implicit ctx: Context) extends Run(comp) {
+  class TASTYRun(comp: Compiler, ictx: Context) extends Run(comp, ictx) {
     override def compile(classNames: List[String]) = {
       units = classNames.map(new TASTYCompilationUnit(_))
       compileUnits()

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

@@ -4,6 +4,4 @@ package dotc
 import core.Contexts.Context
 
 /** Main class of the `dotc` batch compiler. */
-object Main extends Driver {
-  override def newCompiler(implicit ctx: Context): Compiler = new Compiler
-}
+object Main extends Driver

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

@@ -27,8 +27,6 @@ class Resident extends Driver {
 
   object residentCompiler extends Compiler
 
-  override def newCompiler(implicit ctx: Context): Compiler = ???
-
   override def sourcesRequired = false
 
   private val quit = ":q"

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

@@ -6,6 +6,9 @@ import Contexts._
 import Periods._
 import Symbols._
 import Phases._
+import Types._
+import Scopes._
+import typer.{FrontEnd, Typer, ImportInfo, RefChecks}
 import Decorators._
 import dotty.tools.dotc.transform.TreeTransforms.TreeTransformer
 import io.PlainFile
@@ -22,12 +25,41 @@ import dotty.tools.io.VirtualFile
 import scala.util.control.NonFatal
 
 /** A compiler run. Exports various methods to compile source files */
-class Run(comp: Compiler)(implicit ctx: Context) {
-
-  assert(ctx.runId <= Periods.MaxPossibleRunId)
+class Run(comp: Compiler, ictx: Context) {
 
   var units: List[CompilationUnit] = _
 
+  /** Produces the following contexts, from outermost to innermost
+   *
+   *    bootStrap:   A context with next available runId and a scope consisting of
+   *                 the RootPackage _root_
+   *    start        A context with RootClass as owner and the necessary initializations
+   *                 for type checking.
+   *    imports      For each element of RootImports, an import context
+   */
+  protected[this] def rootContext(implicit ctx: Context): Context = {
+    ctx.initialize()(ctx)
+    ctx.setPhasePlan(comp.phases)
+    val rootScope = new MutableScope
+    val bootstrap = ctx.fresh
+      .setPeriod(Period(comp.nextRunId, FirstPhaseId))
+      .setScope(rootScope)
+    rootScope.enter(ctx.definitions.RootPackage)(bootstrap)
+    val start = bootstrap.fresh
+      .setOwner(defn.RootClass)
+      .setTyper(new Typer)
+      .addMode(Mode.ImplicitsEnabled)
+      .setTyperState(new MutableTyperState(ctx.typerState, ctx.typerState.reporter, isCommittable = true))
+      .setFreshNames(new FreshNameCreator.Default)
+    ctx.initialize()(start) // re-initialize the base context with start
+    def addImport(ctx: Context, refFn: () => TermRef) =
+      ctx.fresh.setImportInfo(ImportInfo.rootImport(refFn)(ctx))
+    (start.setRunInfo(new RunInfo(start)) /: defn.RootImportFns)(addImport)
+  }
+
+  protected[this] implicit val ctx: Context = rootContext(ictx)
+  assert(ctx.runId <= Periods.MaxPossibleRunId)
+
   def getSource(fileName: String): SourceFile = {
     val f = new PlainFile(fileName)
     if (f.isDirectory) {
@@ -63,7 +95,17 @@ class Run(comp: Compiler)(implicit ctx: Context) {
       compileUnits()
     }
 
-  protected def compileUnits() = Stats.monitorHeartBeat {
+  def compileUnits(us: List[CompilationUnit]): Unit = {
+    units = us
+    compileUnits()
+  }
+
+  def compileUnits(us: List[CompilationUnit], ctx: Context): Unit = {
+    units = us
+    compileUnits()(ctx)
+  }
+
+  protected def compileUnits()(implicit ctx: Context) = Stats.monitorHeartBeat {
     ctx.checkSingleThreaded()
 
     // If testing pickler, make sure to stop after pickling phase:
@@ -76,7 +118,7 @@ class Run(comp: Compiler)(implicit ctx: Context) {
     ctx.usePhases(phases)
     var lastPrintedTree: PrintedTree = NoPrintedTree
     for (phase <- ctx.allPhases)
-      if (!ctx.reporter.hasErrors) {
+      if (phase.isRunnable) {
         val start = System.currentTimeMillis
         units = phase.runOn(units)
         if (ctx.settings.Xprint.value.containsPhase(phase)) {

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

@@ -251,7 +251,7 @@ class Definitions {
     lazy val Any_getClass = enterMethod(AnyClass, nme.getClass_, MethodType(Nil, ClassClass.typeRef.appliedTo(TypeBounds.empty)), Final)
     lazy val Any_isInstanceOf = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOf_, _ => BooleanType, Final)
     lazy val Any_asInstanceOf = enterT1ParameterlessMethod(AnyClass, nme.asInstanceOf_, TypeParamRef(_, 0), Final)
-    lazy val Any_typeTest = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOfPM, _ => BooleanType, Final)
+    lazy val Any_typeTest = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOfPM, _ => BooleanType, Final | Synthetic)
       // generated by pattern matcher, eliminated by erasure
 
     def AnyMethods = List(Any_==, Any_!=, Any_equals, Any_hashCode,
@@ -863,8 +863,8 @@ class Definitions {
   )
 
   val PredefImportFns = List[() => TermRef](
-      () => ScalaPredefModuleRef,
-      () => DottyPredefModuleRef
+    () => ScalaPredefModuleRef,
+    () => DottyPredefModuleRef
   )
 
   lazy val RootImportFns =

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

@@ -64,7 +64,8 @@ object NameOps {
     def isConstructorName = name == CONSTRUCTOR || name == TRAIT_CONSTRUCTOR
     def isStaticConstructorName = name == STATIC_CONSTRUCTOR
     def isLocalDummyName = name startsWith str.LOCALDUMMY_PREFIX
-    def isReplWrapperName = name.toString contains str.INTERPRETER_IMPORT_WRAPPER
+    def isReplWrapperName = name.toString contains str.REPL_SESSION_LINE
+    def isReplAssignName = name.toString contains str.REPL_ASSIGN_SUFFIX
     def isSetterName = name endsWith str.SETTER_SUFFIX
     def isScala2LocalSuffix = testSimple(_.endsWith(" "))
     def isSelectorName = testSimple(n => n.startsWith("_") && n.drop(1).forall(_.isDigit))

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

@@ -272,11 +272,16 @@ object Phases {
      */
     def phaseName: String
 
+    def isRunnable(implicit ctx: Context): Boolean =
+      !ctx.reporter.hasErrors
+
     /** List of names of phases that should precede this phase */
     def runsAfter: Set[Class[_ <: Phase]] = Set.empty
 
+    /** @pre `isRunnable` returns true */
     def run(implicit ctx: Context): Unit
 
+    /** @pre `isRunnable` returns true */
     def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] =
       units.map { unit =>
         val unitCtx = ctx.fresh.setPhase(this.start).setCompilationUnit(unit)

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

@@ -30,10 +30,10 @@ object StdNames {
     final val ANON_CLASS               = "$anon"
     final val ANON_FUN                 = "$anonfun"
 
-    final val INTERPRETER_IMPORT_WRAPPER = "$iw"
-    final val INTERPRETER_LINE_PREFIX    = "line"
-    final val INTERPRETER_VAR_PREFIX     = "res"
-    final val INTERPRETER_WRAPPER_SUFFIX = "$object"
+    final val REPL_SESSION_LINE  = "rs$line$"
+    final val REPL_ASSIGN_SUFFIX = "$assign"
+    final val REPL_RES_PREFIX    = "res"
+
     final val MODULE_INSTANCE_FIELD      = "MODULE$"
 
     final val Function                   = "Function"

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

@@ -1994,7 +1994,9 @@ object SymDenotations {
     }
 
     def isValidAt(phase: Phase)(implicit ctx: Context) =
-      createdAt.runId == ctx.runId && sameGroup(ctx.phases(createdAt.phaseId), phase)
+      createdAt.runId == ctx.runId &&
+      createdAt.phaseId < ctx.phases.length &&
+      sameGroup(ctx.phases(createdAt.phaseId), phase)
   }
 
   private class InvalidCache extends InheritedCache {

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

@@ -154,6 +154,14 @@ object Types {
         false
     }
 
+    def isInfixType(implicit ctx: Context): Boolean = this match {
+      case TypeApplications.AppliedType(tycon, args) =>
+        args.length == 2 &&
+          !Character.isUnicodeIdentifierStart(tycon.typeSymbol.name.toString.head)
+          // TODO: Once we use the 2.12 stdlib, also check the @showAsInfix annotation
+      case _ => false
+    }
+
     /** Does this type refer exactly to class symbol `sym`, instead of to a subclass of `sym`?
      *  Implemented like `isRef`, but follows more types: all type proxies as well as and- and or-types
      */

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

@@ -65,35 +65,51 @@ object Interactive {
   private def safely[T](op: => List[T]): List[T] =
     try op catch { case ex: TypeError => Nil }
 
-  /** Possible completions at position `pos` */
-  def completions(trees: List[SourceTree], pos: SourcePosition)(implicit ctx: Context): List[Symbol] = {
+  /** Get possible completions from tree at `pos`
+   *
+   *  @return offset and list of symbols for possible completions
+   */
+  def completions(trees: List[SourceTree], pos: SourcePosition)(implicit ctx: Context): (Int, List[Symbol]) = {
     val path = pathTo(trees, pos)
     val boundary = enclosingDefinitionInPath(path).symbol
 
-    path.take(1).flatMap {
-      case Select(qual, _) =>
+    // FIXME: Get all declarations available in the current scope, not just
+    // those from the enclosing class
+    def scopeCompletions: List[Symbol] =
+      boundary.enclosingClass match {
+        case csym: ClassSymbol =>
+          val classRef = csym.classInfo.typeRef
+          completions(classRef, boundary)
+        case _ =>
+          Nil
+      }
+
+    path.headOption.map {
+      case sel @ Select(qual, name) =>
         // When completing "`a.foo`, return the members of `a`
-        completions(qual.tpe, boundary)
+        (sel.pos.point, completions(qual.tpe, boundary))
+      case id @ Ident(name) =>
+        (id.pos.point, scopeCompletions)
       case _ =>
-        // FIXME: Get all declarations available in the current scope, not just
-        // those from the enclosing class
-        boundary.enclosingClass match {
-          case csym: ClassSymbol =>
-            val classRef = csym.classInfo.typeRef
-            completions(classRef, boundary)
-          case _ =>
-            Nil
-        }
+        (0, scopeCompletions)
     }
+    .getOrElse((0, Nil))
   }
 
   /** Possible completions of members of `prefix` which are accessible when called inside `boundary` */
   def completions(prefix: Type, boundary: Symbol)(implicit ctx: Context): List[Symbol] =
     safely {
-      val boundaryCtx = ctx.withOwner(boundary)
-      prefix.memberDenots(completionsFilter, (name, buf) =>
-        buf ++= prefix.member(name).altsWith(d => !d.isAbsent && d.symbol.isAccessibleFrom(prefix)(boundaryCtx))
-      ).map(_.symbol).toList
+      if (boundary != NoSymbol) {
+        val boundaryCtx = ctx.withOwner(boundary)
+        prefix.memberDenots(completionsFilter, (name, buf) =>
+          buf ++= prefix.member(name).altsWith{ d =>
+            !d.isAbsent &&
+            !d.is(Synthetic) && !d.is(Artifact) &&
+            d.symbol.isAccessibleFrom(prefix)(boundaryCtx)
+          }
+        ).map(_.symbol).toList
+      }
+      else Nil
     }
 
   /** Filter for names that should appear when looking for completions. */

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

@@ -28,8 +28,6 @@ class InteractiveDriver(settings: List[String]) extends Driver {
   import tpd._
   import InteractiveDriver._
 
-  // FIXME: Change the Driver API to not require implementing this method
-  override protected def newCompiler(implicit ctx: Context): Compiler = ???
   override def sourcesRequired = false
 
   private val myInitCtx: Context = {

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -125,23 +125,15 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         ("implicit " provided isImplicit) ~ argStr ~ " => " ~ argText(args.last)
       }
 
-    def isInfixType(tp: Type): Boolean = tp match {
-      case AppliedType(tycon, args) =>
-        args.length == 2 &&
-          !Character.isUnicodeIdentifierStart(tycon.typeSymbol.name.toString.head)
-          // TODO: Once we use the 2.12 stdlib, also check the @showAsInfix annotation
-      case _ =>
-        false
-    }
     def toTextInfixType(op: Type, args: List[Type]): Text = {
       /* SLS 3.2.8: all infix types have the same precedence.
        * In A op B op' C, op and op' need the same associativity.
        * Therefore, if op is left associative, anything on its right
        * needs to be parenthesized if it's an infix type, and vice versa. */
       val l :: r :: Nil = args
       val isRightAssoc = op.typeSymbol.name.endsWith(":")
-      val leftArg = if (isRightAssoc && isInfixType(l)) "(" ~ toText(l) ~ ")" else toText(l)
-      val rightArg = if (!isRightAssoc && isInfixType(r)) "(" ~ toText(r) ~ ")" else toText(r)
+      val leftArg = if (isRightAssoc && l.isInfixType) "(" ~ toText(l) ~ ")" else toText(l)
+      val rightArg = if (!isRightAssoc && r.isInfixType) "(" ~ toText(r) ~ ")" else toText(r)
 
       leftArg ~ " " ~ toTextLocal(op) ~ " " ~ rightArg
     }
@@ -154,7 +146,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         if (tycon.isRepeatedParam) return toTextLocal(args.head) ~ "*"
         if (defn.isFunctionClass(cls)) return toTextFunction(args, cls.name.isImplicitFunction)
         if (defn.isTupleClass(cls)) return toTextTuple(args)
-        if (isInfixType(tp)) return toTextInfixType(tycon, args)
+        if (tp.isInfixType) return toTextInfixType(tycon, args)
       case EtaExpansion(tycon) =>
         return toText(tycon)
       case tp: TypeRef =>