Merge pull request #2991 from dotty-staging/topic/new-repl

Add native Dotty REPL

Author: felixmulder

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))