Fix #5897 and #6200: implicits are not retained in REPL

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

@@ -13,11 +13,11 @@ import printing.Texts.Text
 
 object ImportInfo {
   /** The import info for a root import from given symbol `sym` */
-  def rootImport(refFn: () => TermRef)(implicit ctx: Context): ImportInfo = {
+  def rootImport(refFn: () => TermRef, importImplied: Boolean = false)(implicit ctx: Context): ImportInfo = {
     val selectors = untpd.Ident(nme.WILDCARD) :: Nil
     def expr(implicit ctx: Context) = tpd.Ident(refFn())
-    def imp(implicit ctx: Context) = tpd.Import(importImplied = false, expr, selectors)
-    new ImportInfo(implicit ctx => imp.symbol, selectors, None, importImplied = false, isRootImport = true)
+    def imp(implicit ctx: Context) = tpd.Import(importImplied = importImplied, expr, selectors)
+    new ImportInfo(implicit ctx => imp.symbol, selectors, None, importImplied = importImplied, isRootImport = true)
   }
 }
 

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

@@ -48,9 +48,12 @@ class ReplCompiler extends Compiler {
       def importPreviousRun(id: Int)(implicit ctx: Context) = {
         // we first import the wrapper object id
         val path = nme.EMPTY_PACKAGE ++ "." ++ objectNames(id)
-        val importInfo = ImportInfo.rootImport(() =>
-          ctx.requiredModuleRef(path))
-        val ctx0 = ctx.fresh.setNewScope.setImportInfo(importInfo)
+        def importWrapper(c: Context, importImplied: Boolean) = {
+          val importInfo = ImportInfo.rootImport(() =>
+            c.requiredModuleRef(path), importImplied)
+          c.fresh.setNewScope.setImportInfo(importInfo)
+        }
+        val ctx0 = importWrapper(importWrapper(ctx, false), true)
 
         // then its user defined imports
         val imports = state.imports.getOrElse(id, Nil)

compiler/test/dotty/tools/repl/ReplCompilerTests.scala

@@ -127,4 +127,42 @@ class ReplCompilerTests extends ReplTest {
     run(source)
     assertEquals(expected, lines())
   }
+
+  @Test def i5897 =
+    fromInitialState { implicit state => run("implied for Int = 10") }
+    .andThen         { implicit state =>
+      assertEquals(
+        "def Int_instance: Int",
+        storedOutput().trim
+      )
+      run("implicitly[Int]")
+      assertEquals(
+        "val res0: Int = 10",
+        storedOutput().trim
+      )
+    }
+
+  @Test def i6200 =
+    fromInitialState { implicit state =>
+      run("""
+        |trait Ord[T] {
+        |  def compare(x: T, y: T): Int
+        |  def (x: T) < (y: T) = compare(x, y) < 0
+        |  def (x: T) > (y: T) = compare(x, y) > 0
+        |}
+        |
+        |implied IntOrd for Ord[Int] {
+        |  def compare(x: Int, y: Int) =
+        |  if (x < y) -1 else if (x > y) +1 else 0
+        |}
+      """.stripMargin) }
+    .andThen         { implicit state =>
+      assertEquals(
+        """// defined trait Ord
+          |// defined object IntOrd""".stripMargin,
+        storedOutput().trim
+      )
+      run("IntOrd")
+      assertTrue(storedOutput().startsWith("val res0: IntOrd.type ="))
+    }
 }