make parser warnings and @nowarn work in the repl

Author: lrytz

Diff for: compiler/src/dotty/tools/dotc/Run.scala

@@ -106,6 +106,13 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   private val mySuspendedMessages: mutable.LinkedHashMap[SourceFile, mutable.LinkedHashSet[Warning]] = mutable.LinkedHashMap.empty
 
   object suppressions:
+    // When the REPL creates a new run (ReplDriver.compile), parsing is already done in the old context, with the
+    // previous Run. Parser warnings were suspended in the old run and need to be copied over so they are not lost.
+    // Same as scala/scala/commit/79ca1408c7.
+    def initSuspendedMessages(oldRun: Run) = if oldRun != null then
+      mySuspendedMessages.clear()
+      mySuspendedMessages ++= oldRun.mySuspendedMessages
+
     def suppressionsComplete(source: SourceFile) = source == NoSource || mySuppressionsComplete(source)
 
     def addSuspendedMessage(warning: Warning) =

Diff for: compiler/src/dotty/tools/dotc/reporting/Reporter.scala

@@ -90,6 +90,8 @@ abstract class Reporter extends interfaces.ReporterResult {
     finally incompleteHandler = saved
   }
 
+  private def isIncompleteChecking = incompleteHandler ne defaultIncompleteHandler
+
   private var _errorCount = 0
   private var _warningCount = 0
 
@@ -170,6 +172,9 @@ abstract class Reporter extends interfaces.ReporterResult {
       }
     end go
 
+    // `ctx.run` can be null in test, also in the repl when parsing the first line. The parser runs early, the Run is
+    // only created in ReplDriver.compile when a line is submitted. This means that `@nowarn` doesnt work on parser
+    // warnings in the first line.
     dia match
       case w: Warning if ctx.run != null =>
         val sup = ctx.run.suppressions
@@ -178,7 +183,11 @@ abstract class Reporter extends interfaces.ReporterResult {
           case Action.Verbose => w.setVerbose(); go()
           case Action.Silent =>
         else
-          sup.addSuspendedMessage(w)
+          // ParseResult.isIncomplete creates a new source file and reporter to check if the input is complete.
+          // The reporter's warnings are discarded, and we should not add them to the run's suspended messages,
+          // otherwise they are later reported.
+          if !isIncompleteChecking then
+            sup.addSuspendedMessage(w)
       case _ => go()
   end issueIfNotSuppressed
 

Diff for: compiler/src/dotty/tools/repl/ReplCompiler.scala

@@ -37,34 +37,36 @@ class ReplCompiler extends Compiler {
     List(new PostTyper),
   )
 
-  def newRun(initCtx: Context, state: State): Run = new Run(this, initCtx) {
-
-    /** Import previous runs and user defined imports */
-    override protected def rootContext(using Context): Context = {
-      def importContext(imp: tpd.Import)(using Context) =
-        ctx.importContext(imp, imp.symbol)
-
-      def importPreviousRun(id: Int)(using Context) = {
-        // we first import the wrapper object id
-        val path = nme.REPL_PACKAGE ++ "." ++ objectNames(id)
-        val ctx0 = ctx.fresh
-          .setNewScope
-          .withRootImports(RootRef(() => requiredModuleRef(path)) :: Nil)
-
-        // then its user defined imports
-        val imports = state.imports.getOrElse(id, Nil)
-        if imports.isEmpty then ctx0
-        else imports.foldLeft(ctx0.fresh.setNewScope)((ctx, imp) =>
-          importContext(imp)(using ctx))
-      }
+  def newRun(initCtx: Context, state: State): Run =
+    val run = new Run(this, initCtx) {
+      /** Import previous runs and user defined imports */
+      override protected def rootContext(using Context): Context = {
+        def importContext(imp: tpd.Import)(using Context) =
+          ctx.importContext(imp, imp.symbol)
+
+        def importPreviousRun(id: Int)(using Context) = {
+          // we first import the wrapper object id
+          val path = nme.REPL_PACKAGE ++ "." ++ objectNames(id)
+          val ctx0 = ctx.fresh
+            .setNewScope
+            .withRootImports(RootRef(() => requiredModuleRef(path)) :: Nil)
+
+          // then its user defined imports
+          val imports = state.imports.getOrElse(id, Nil)
+          if imports.isEmpty then ctx0
+          else imports.foldLeft(ctx0.fresh.setNewScope)((ctx, imp) =>
+            importContext(imp)(using ctx))
+        }
 
-      val rootCtx = super.rootContext
-        .withRootImports   // default root imports
-        .withRootImports(RootRef(() => defn.EmptyPackageVal.termRef) :: Nil)
-      (1 to state.objectIndex).foldLeft(rootCtx)((ctx, id) =>
-        importPreviousRun(id)(using ctx))
+        val rootCtx = super.rootContext
+          .withRootImports   // default root imports
+          .withRootImports(RootRef(() => defn.EmptyPackageVal.termRef) :: Nil)
+        (1 to state.objectIndex).foldLeft(rootCtx)((ctx, id) =>
+          importPreviousRun(id)(using ctx))
+      }
     }
-  }
+    run.suppressions.initSuspendedMessages(state.context.run)
+    run
 
   private val objectNames = mutable.Map.empty[Int, TermName]
 

Diff for: compiler/test-resources/repl/nowarn.scala

@@ -0,0 +1,25 @@
+scala> @annotation.nowarn def f = try 1 // @nowarn doesn't work on first line, ctx.run is null in issueIfNotSuppressed
+1 |@annotation.nowarn def f = try 1 // @nowarn doesn't work on first line, ctx.run is null in issueIfNotSuppressed
+  |                           ^^^^^
+  |                   A try without catch or finally is equivalent to putting
+  |                   its body in a block; no exceptions are handled.
+def f: Int
+
+scala> @annotation.nowarn def f = try 1
+def f: Int
+
+scala> def f = try 1
+1 |def f = try 1
+  |        ^^^^^
+  |        A try without catch or finally is equivalent to putting
+  |        its body in a block; no exceptions are handled.
+def f: Int
+
+scala> @annotation.nowarn def f = { 1; 2 }
+def f: Int
+
+scala> def f = { 1; 2 }
+1 |def f = { 1; 2 }
+  |          ^
+  |A pure expression does nothing in statement position; you may be omitting necessary parentheses
+def f: Int