Convert repl classes

Author: odersky

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

@@ -11,7 +11,7 @@ object ReflectionImpl {
   def apply(rootContext: Contexts.Context): scala.tasty.Reflection =
     new scala.tasty.Reflection(new ReflectionCompilerInterface(rootContext))
 
-  def showTree(tree: tpd.Tree)(implicit ctx: Contexts.Context): String = {
+  def showTree(tree: tpd.Tree)(using Contexts.Context): String = {
     val refl = new scala.tasty.Reflection(new ReflectionCompilerInterface(MacroExpansion.context(tree)))
     val reflCtx = ctx.asInstanceOf[refl.Context]
     val reflTree = tree.asInstanceOf[refl.Tree]

compiler/src/dotty/tools/repl/CollectTopLevelImports.scala

@@ -18,7 +18,7 @@ class CollectTopLevelImports extends Phase {
   private var myImports: List[Import] = _
   def imports: List[Import] = myImports
 
-  def run(implicit ctx: Context): Unit = {
+  def run(using Context): Unit = {
     def topLevelImports(tree: Tree) = {
       val PackageDef(_, _ :: TypeDef(_, rhs: Template) :: _) = tree
       rhs.body.collect { case tree: Import => tree }

compiler/src/dotty/tools/repl/JLineTerminal.scala

@@ -24,11 +24,11 @@ final class JLineTerminal extends java.io.Closeable {
     .build()
   private val history = new DefaultHistory
 
-  private def blue(str: String)(implicit ctx: Context) =
+  private def blue(str: String)(using Context) =
     if (ctx.settings.color.value != "never") Console.BLUE + str + Console.RESET
     else str
-  private def prompt(implicit ctx: Context)        = blue("scala> ")
-  private def newLinePrompt(implicit ctx: Context) = blue("     | ")
+  private def prompt(using Context)        = blue("scala> ")
+  private def newLinePrompt(using Context) = blue("     | ")
 
   /** Blockingly read line from `System.in`
    *
@@ -45,7 +45,7 @@ final class JLineTerminal extends java.io.Closeable {
    */
   def readLine(
     completer: Completer // provide auto-completions
-  )(implicit ctx: Context): String = {
+  )(using Context): String = {
     import LineReader.Option._
     import LineReader._
     val userHome = System.getProperty("user.home")
@@ -74,7 +74,7 @@ final class JLineTerminal extends java.io.Closeable {
   def close(): Unit = terminal.close()
 
   /** Provide syntax highlighting */
-  private class Highlighter(implicit ctx: Context) extends reader.Highlighter {
+  private class Highlighter(using Context) extends reader.Highlighter {
     def highlight(reader: LineReader, buffer: String): AttributedString = {
       val highlighted = SyntaxHighlighting.highlight(buffer)
       AttributedString.fromAnsi(highlighted)
@@ -84,7 +84,7 @@ final class JLineTerminal extends java.io.Closeable {
   }
 
   /** Provide multi-line editing support */
-  private class Parser(implicit ctx: Context) extends reader.Parser {
+  private class Parser(using Context) extends reader.Parser {
 
     /**
      * @param cursor     The cursor position within the line

compiler/src/dotty/tools/repl/ParseResult.scala

@@ -3,7 +3,7 @@ package repl
 
 import dotc.CompilationUnit
 import dotc.ast.untpd
-import dotc.core.Contexts.{Context, inContext}
+import dotc.core.Contexts.{Context, ctx, inContext}
 import dotc.core.StdNames.str
 import dotc.parsing.Parsers.Parser
 import dotc.parsing.Tokens
@@ -112,7 +112,7 @@ object ParseResult {
 
   @sharable private val CommandExtract = """(:[\S]+)\s*(.*)""".r
 
-  private def parseStats(implicit ctx: Context): List[untpd.Tree] = {
+  private def parseStats(using Context): List[untpd.Tree] = {
     val parser = new Parser(ctx.source)
     val stats = parser.blockStatSeq()
     parser.accept(Tokens.EOF)
@@ -144,7 +144,7 @@ object ParseResult {
       case _ =>
         inContext(state.context) {
           val reporter = newStoreReporter
-          val stats = parseStats(state.context.fresh.setReporter(reporter).withSource(source))
+          val stats = parseStats(using state.context.fresh.setReporter(reporter).withSource(source))
 
           if (reporter.hasErrors)
             SyntaxErrors(
@@ -165,7 +165,7 @@ object ParseResult {
    *  This can be used in order to check if a newline can be inserted without
    *  having to evaluate the expression.
    */
-  def isIncomplete(sourceCode: String)(implicit ctx: Context): Boolean =
+  def isIncomplete(sourceCode: String)(using Context): Boolean =
     sourceCode match {
       case CommandExtract(_) | "" => false
       case _ => {
@@ -177,7 +177,7 @@ object ParseResult {
                           .setReporter(reporter)
         var needsMore = false
         reporter.withIncompleteHandler((_, _) => needsMore = true) {
-          parseStats(localCtx)
+          parseStats(using localCtx)
         }
         !reporter.hasErrors && needsMore
       }

compiler/src/dotty/tools/repl/Rendering.scala

@@ -33,7 +33,7 @@ private[repl] class Rendering(parentClassLoader: Option[ClassLoader] = None) {
 
   /** A `MessageRenderer` for the REPL without file positions */
   private val messageRenderer = new MessageRendering {
-    override def posStr(pos: SourcePosition, diagnosticLevel: String, message: Message)(implicit ctx: Context): String = ""
+    override def posStr(pos: SourcePosition, diagnosticLevel: String, message: Message)(using Context): String = ""
   }
 
   private var myClassLoader: ClassLoader = _
@@ -42,7 +42,7 @@ private[repl] class Rendering(parentClassLoader: Option[ClassLoader] = None) {
 
 
   /** Class loader used to load compiled code */
-  private[repl] def classLoader()(implicit ctx: Context) =
+  private[repl] def classLoader()(using Context) =
     if (myClassLoader != null) myClassLoader
     else {
       val parent = parentClassLoader.getOrElse {
@@ -65,7 +65,7 @@ private[repl] class Rendering(parentClassLoader: Option[ClassLoader] = None) {
     }
 
   /** Return a String representation of a value we got from `classLoader()`. */
-  private[repl] def replStringOf(value: Object)(implicit ctx: Context): String = {
+  private[repl] def replStringOf(value: Object)(using Context): String = {
     assert(myReplStringOf != null,
       "replStringOf should only be called on values creating using `classLoader()`, but `classLoader()` has not been called so far")
     myReplStringOf(value)
@@ -75,7 +75,7 @@ private[repl] class Rendering(parentClassLoader: Option[ClassLoader] = None) {
    *
    *  Calling this method evaluates the expression using reflection
    */
-  private def valueOf(sym: Symbol)(implicit ctx: Context): Option[String] = {
+  private def valueOf(sym: Symbol)(using Context): Option[String] = {
     val objectName = sym.owner.fullName.encode.toString.stripSuffix("$")
     val resObj: Class[?] = Class.forName(objectName, true, classLoader())
     val value =
@@ -102,18 +102,18 @@ private[repl] class Rendering(parentClassLoader: Option[ClassLoader] = None) {
       dia.level
     )
 
-  def renderTypeDef(d: Denotation)(implicit ctx: Context): Diagnostic =
+  def renderTypeDef(d: Denotation)(using Context): Diagnostic =
     infoDiagnostic("// defined " ++ d.symbol.showUser, d)
 
-  def renderTypeAlias(d: Denotation)(implicit ctx: Context): Diagnostic =
+  def renderTypeAlias(d: Denotation)(using Context): Diagnostic =
     infoDiagnostic("// defined alias " ++ d.symbol.showUser, d)
 
   /** Render method definition result */
-  def renderMethod(d: Denotation)(implicit ctx: Context): Diagnostic =
+  def renderMethod(d: Denotation)(using Context): Diagnostic =
     infoDiagnostic(d.symbol.showUser, d)
 
   /** Render value definition result */
-  def renderVal(d: Denotation)(implicit ctx: Context): Option[Diagnostic] = {
+  def renderVal(d: Denotation)(using Context): Option[Diagnostic] = {
     val dcl = d.symbol.showUser
 
     try {
@@ -135,15 +135,15 @@ private[repl] class Rendering(parentClassLoader: Option[ClassLoader] = None) {
     sw.toString
   }
 
-  private def infoDiagnostic(msg: String, d: Denotation)(implicit ctx: Context): Diagnostic =
+  private def infoDiagnostic(msg: String, d: Denotation)(using Context): Diagnostic =
     new Diagnostic.Info(msg, d.symbol.sourcePos)
 
 }
 
 object Rendering {
 
   implicit class ShowUser(val s: Symbol) extends AnyVal {
-    def showUser(implicit ctx: Context): String = {
+    def showUser(using Context): String = {
       val printer = new ReplPrinter(ctx)
       val text = printer.dclText(s)
       text.mkString(ctx.settings.pageWidth.value, ctx.settings.printLines.value)

compiler/src/dotty/tools/repl/ReplCompiler.scala

@@ -41,11 +41,11 @@ class ReplCompiler extends Compiler {
   def newRun(initCtx: Context, state: State): Run = new Run(this, initCtx) {
 
     /** Import previous runs and user defined imports */
-    override protected def rootContext(implicit ctx: Context): Context = {
-      def importContext(imp: tpd.Import)(implicit ctx: Context) =
+    override protected def rootContext(using Context): Context = {
+      def importContext(imp: tpd.Import)(using Context) =
         ctx.importContext(imp, imp.symbol)
 
-      def importPreviousRun(id: Int)(implicit ctx: Context) = {
+      def importPreviousRun(id: Int)(using Context) = {
         // we first import the wrapper object id
         val path = nme.EMPTY_PACKAGE ++ "." ++ objectNames(id)
         def importWrapper(c: Context, importGiven: Boolean) = {
@@ -59,11 +59,11 @@ class ReplCompiler extends Compiler {
         val imports = state.imports.getOrElse(id, Nil)
         if (imports.isEmpty) ctx0
         else imports.foldLeft(ctx0.fresh.setNewScope)((ctx, imp) =>
-          importContext(imp)(ctx))
+          importContext(imp)(using ctx))
       }
 
       (1 to state.objectIndex).foldLeft(super.rootContext)((ctx, id) =>
-        importPreviousRun(id)(ctx))
+        importPreviousRun(id)(using ctx))
     }
   }
 
@@ -136,7 +136,7 @@ class ReplCompiler extends Compiler {
       PackageDef(Ident(nme.EMPTY_PACKAGE), List(module))
     }
 
-  private def createUnit(defs: Definitions, span: Span)(implicit ctx: Context): CompilationUnit = {
+  private def createUnit(defs: Definitions, span: Span)(using Context): CompilationUnit = {
     val objectName = ctx.source.file.toString
     assert(objectName.startsWith(str.REPL_SESSION_LINE))
     assert(objectName.endsWith(defs.state.objectIndex.toString))
@@ -159,7 +159,7 @@ class ReplCompiler extends Compiler {
   final def compile(parsed: Parsed)(implicit state: State): Result[(CompilationUnit, State)] = {
     assert(!parsed.trees.isEmpty)
     val defs = definitions(parsed.trees, state)
-    val unit = createUnit(defs, Span(0, parsed.trees.last.span.end))(state.context)
+    val unit = createUnit(defs, Span(0, parsed.trees.last.span.end))(using state.context)
     runCompilationUnit(unit, defs.state)
   }
 
@@ -225,7 +225,7 @@ class ReplCompiler extends Compiler {
 
   final def typeCheck(expr: String, errorsAllowed: Boolean = false)(implicit state: State): Result[tpd.ValDef] = {
 
-    def wrapped(expr: String, sourceFile: SourceFile, state: State)(implicit ctx: Context): Result[untpd.PackageDef] = {
+    def wrapped(expr: String, sourceFile: SourceFile, state: State)(using Context): Result[untpd.PackageDef] = {
       def wrap(trees: List[untpd.Tree]): untpd.PackageDef = {
         import untpd._
 
@@ -252,7 +252,7 @@ class ReplCompiler extends Compiler {
       }
     }
 
-    def unwrapped(tree: tpd.Tree, sourceFile: SourceFile)(implicit ctx: Context): Result[tpd.ValDef] = {
+    def unwrapped(tree: tpd.Tree, sourceFile: SourceFile)(using Context): Result[tpd.ValDef] = {
       def error: Result[tpd.ValDef] =
         List(new Diagnostic.Error(s"Invalid scala expression",
           sourceFile.atSpan(Span(0, sourceFile.content.length)))).errors

compiler/src/dotty/tools/repl/ReplFrontEnd.scala

@@ -13,9 +13,9 @@ import dotc.core.Contexts.{Context, ctx}
  */
 private[repl] class REPLFrontEnd extends FrontEnd {
 
-  override def isRunnable(implicit ctx: Context): Boolean = true
+  override def isRunnable(using Context): Boolean = true
 
-  override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] = {
+  override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] = {
     assert(units.size == 1) // REPl runs one compilation unit at a time
 
     val unitContext = ctx.fresh.setCompilationUnit(units.head)

compiler/src/dotty/tools/repl/ScriptEngine.scala

@@ -37,7 +37,7 @@ class ScriptEngine extends AbstractScriptEngine {
     val vid = state.valIndex
     state = driver.run(script)(state)
     val oid = state.objectIndex
-    Class.forName(s"${str.REPL_SESSION_LINE}$oid", true, rendering.classLoader()(state.context))
+    Class.forName(s"${str.REPL_SESSION_LINE}$oid", true, rendering.classLoader()(using state.context))
       .getDeclaredMethods.find(_.getName == s"${str.REPL_RES_PREFIX}$vid")
       .map(_.invoke(null))
       .getOrElse(null)