Fix problem with badly initialized context

BarkingBad · BarkingBad · commit c4c63fcf58e0 · 2021-02-24T19:26:33.000+01:00
diff --git a/compiler/src/dotty/tools/dotc/Driver.scala b/compiler/src/dotty/tools/dotc/Driver.scala
@@ -66,10 +66,16 @@ class Driver {
 
   protected def command: CompilerCommand = ScalacCommand
 
-  def setup(args: Array[String], rootCtx: Context): (Option[List[AbstractFile]], Context) = {
+  /** Setup context with initialized settings from CLI arguments, then check if there are any settings that
+   *  would change the default behaviour of the compiler.
+   *
+   *  @return If there is no setting like `-help` preventing us from continuing compilation,
+   *  this method returns a list of files to compile and an updated Context.
+   *  If compilation should be interrupted, this method returns None.
+   */
+  def setup(args: Array[String], rootCtx: Context): Option[(List[AbstractFile], Context)] = {
     val ictx = rootCtx.fresh
-    val settings = config.ScalaSettings()
-    val summary = command.distill(args, settings, settings.defaultState)
+    val summary = command.distill(args, ictx.settings)(ictx.settingsState)(using ictx)
     ictx.setSettings(summary.sstate)
     MacroClassLoader.init(ictx)
     Positioned.init(using ictx)
@@ -78,9 +84,9 @@ class Driver {
       if !ctx.settings.YdropComments.value || ctx.mode.is(Mode.ReadComments) then
         ictx.setProperty(ContextDoc, new ContextDocstrings)
       val fileNamesOrNone = command.checkUsage(summary, sourcesRequired)(using ctx.settings)(using ctx.settingsState)
-      fileNamesOrNone.fold((None, ictx)) { fileNames =>
+      fileNamesOrNone.map { fileNames =>
         val files = fileNames.map(ctx.getFile)
-        (Some(files), fromTastySetup(files))
+        (files, fromTastySetup(files))
       }
     }
   }
@@ -187,10 +193,11 @@ class Driver {
    *                    if compilation succeeded.
    */
   def process(args: Array[String], rootCtx: Context): Reporter = {
-    val (files, compileCtx) = setup(args, rootCtx)
-    files.fold(compileCtx.reporter) {
-      doCompile(newCompiler(using compileCtx), _)(using compileCtx)
-    }
+    setup(args, rootCtx) match
+      case Some((files, compileCtx)) =>
+        doCompile(newCompiler(using compileCtx), files)(using compileCtx)
+      case None =>
+        rootCtx.reporter
   }
 
   def main(args: Array[String]): Unit = {
diff --git a/compiler/src/dotty/tools/dotc/Resident.scala b/compiler/src/dotty/tools/dotc/Resident.scala
@@ -40,21 +40,21 @@ class Resident extends Driver {
 
   final override def process(args: Array[String], rootCtx: Context): Reporter = {
     @tailrec def loop(args: Array[String], prevCtx: Context): Reporter = {
-      var (possibleFiles, ctx) = setup(args, prevCtx)
-      if possibleFiles.isDefined then
-        inContext(ctx) {
-          doCompile(residentCompiler, possibleFiles.get) // using more complex constructs like fold or map instead of get will make @tailrec complain
-        }
-        var nextCtx = ctx
-        var line = getLine()
-        while (line == reset) {
-          nextCtx = rootCtx
-          line = getLine()
-        }
-        if (line.startsWith(quit)) ctx.reporter
-        else loop(line split "\\s+", nextCtx)
-      else
-        ctx.reporter
+      setup(args, prevCtx) match
+        case Some((files, ctx)) =>
+          inContext(ctx) {
+            doCompile(residentCompiler, files)
+          }
+          var nextCtx = ctx
+          var line = getLine()
+          while (line == reset) {
+            nextCtx = rootCtx
+            line = getLine()
+          }
+          if (line.startsWith(quit)) ctx.reporter
+          else loop(line split "\\s+", nextCtx)
+        case None =>
+          prevCtx.reporter
     }
     loop(args, rootCtx)
   }
diff --git a/compiler/src/dotty/tools/dotc/config/CliCommand.scala b/compiler/src/dotty/tools/dotc/config/CliCommand.scala
@@ -40,7 +40,7 @@ trait CliCommand:
   """
 
   /** Distill arguments into summary detailing settings, errors and files to main */
-  def distill(args: Array[String], sg: Settings.SettingGroup, ss: SettingsState): ArgsSummary =
+  def distill(args: Array[String], sg: Settings.SettingGroup)(ss: SettingsState = sg.defaultState)(using Context): ArgsSummary =
     /**
      * Expands all arguments starting with @ to the contents of the
      * file named like each argument.
@@ -49,20 +49,20 @@ trait CliCommand:
       def stripComment(s: String) = s takeWhile (_ != '#')
       val path = Paths.get(arg stripPrefix "@")
       if (!Files.exists(path))
-        throw new java.io.FileNotFoundException("argument file %s could not be found" format path.getFileName)
-
-      val lines = Files.readAllLines(path) // default to UTF-8 encoding
-
-      val params = lines.asScala map stripComment mkString " "
-      CommandLineParser.tokenize(params)
+        report.error(s"Argument file ${path.getFileName} could not be found")
+        Nil
+      else
+        val lines = Files.readAllLines(path) // default to UTF-8 encoding
+        val params = lines.asScala map stripComment mkString " "
+        CommandLineParser.tokenize(params)
 
     // expand out @filename to the contents of that filename
     def expandedArguments = args.toList flatMap {
       case x if x startsWith "@"  => expandArg(x)
       case x                      => List(x)
     }
 
-    sg.processArguments(expandedArguments, ss, processAll = true)
+    sg.processArguments(expandedArguments, processAll = true, settingsState = ss)
 
   /** Creates a help message for a subset of options based on cond */
   protected def availableOptionsMsg(cond: Setting[?] => Boolean)(using settings: ConcreteSettings)(using SettingsState): String =
diff --git a/compiler/src/dotty/tools/dotc/config/CompilerCommand.scala b/compiler/src/dotty/tools/dotc/config/CompilerCommand.scala
@@ -10,7 +10,7 @@ import Properties._
 import scala.collection.JavaConverters._
 
 abstract class CompilerCommand extends CliCommand:
-  final type ConcreteSettings = ScalaSettings
+  type ConcreteSettings = ScalaSettings
 
   final def helpMsg(using settings: ScalaSettings)(using SettingsState, Context): String =
     if (settings.help.value) usageMessage
diff --git a/compiler/src/dotty/tools/dotc/config/PathResolver.scala b/compiler/src/dotty/tools/dotc/config/PathResolver.scala
@@ -144,7 +144,7 @@ object PathResolver {
     }
     else inContext(ContextBase().initialCtx) {
       val ArgsSummary(sstate, rest, errors, warnings) =
-        ctx.settings.processArguments(args.toList, ctx.settingsState, true)
+        ctx.settings.processArguments(args.toList, true, ctx.settingsState)
       errors.foreach(println)
       val pr = new PathResolver()(using ctx.fresh.setSettings(sstate))
       println(" COMMAND: 'scala %s'".format(args.mkString(" ")))
diff --git a/compiler/src/dotty/tools/dotc/config/Settings.scala b/compiler/src/dotty/tools/dotc/config/Settings.scala
@@ -244,7 +244,7 @@ object Settings {
       }
     }
 
-    def processArguments(arguments: List[String], settingsState: SettingsState, processAll: Boolean): ArgsSummary =
+    def processArguments(arguments: List[String], processAll: Boolean, settingsState: SettingsState = defaultState): ArgsSummary =
       processArguments(ArgsSummary(settingsState, arguments, Nil, Nil), processAll, Nil)
 
     def publish[T](settingf: Int => Setting[T]): Setting[T] = {
diff --git a/compiler/src/dotty/tools/dotc/decompiler/IDEDecompilerDriver.scala b/compiler/src/dotty/tools/dotc/decompiler/IDEDecompilerDriver.scala
@@ -19,7 +19,7 @@ class IDEDecompilerDriver(val settings: List[String]) extends dotc.Driver {
     val rootCtx = initCtx.fresh.addMode(Mode.Interactive | Mode.ReadPositions | Mode.ReadComments)
     rootCtx.setSetting(rootCtx.settings.YretainTrees, true)
     rootCtx.setSetting(rootCtx.settings.fromTasty, true)
-    val ctx = setup(settings.toArray :+ "dummy.scala", rootCtx)._2
+    val ctx = setup(settings.toArray :+ "dummy.scala", rootCtx).get._2
     ctx.initialize()(using ctx)
     ctx
   }
diff --git a/compiler/src/dotty/tools/dotc/decompiler/Main.scala b/compiler/src/dotty/tools/dotc/decompiler/Main.scala
@@ -18,7 +18,7 @@ object Main extends dotc.Driver {
     new TASTYDecompiler
   }
 
-  override def setup(args0: Array[String], rootCtx: Context): (Option[List[AbstractFile]], Context) = {
+  override def setup(args0: Array[String], rootCtx: Context): Option[(List[AbstractFile], Context)] = {
     var args = args0.filter(a => a != "-decompile")
     if (!args.contains("-from-tasty")) args = "-from-tasty" +: args
     if (args.contains("-d")) args = "-color:never" +: args
diff --git a/compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala b/compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala
@@ -32,7 +32,9 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
     val rootCtx = initCtx.fresh.addMode(Mode.ReadPositions).addMode(Mode.Interactive).addMode(Mode.ReadComments)
     rootCtx.setSetting(rootCtx.settings.YretainTrees, true)
     rootCtx.setSetting(rootCtx.settings.YcookComments, true)
-    val ctx = setup(settings.toArray, rootCtx)._2
+    val ctx = setup(settings.toArray, rootCtx) match
+      case Some((_, ctx)) => ctx
+      case None => rootCtx
     ctx.initialize()(using ctx)
     ctx
   }
diff --git a/compiler/src/dotty/tools/repl/ReplDriver.scala b/compiler/src/dotty/tools/repl/ReplDriver.scala
@@ -68,10 +68,14 @@ class ReplDriver(settings: Array[String],
   private def initialCtx = {
     val rootCtx = initCtx.fresh.addMode(Mode.ReadPositions | Mode.Interactive | Mode.ReadComments)
     rootCtx.setSetting(rootCtx.settings.YcookComments, true)
-    val (files, ictx) = setup(settings, rootCtx)
-    shouldStart = files.isDefined
-    ictx.base.initialize()(using ictx)
-    ictx
+    setup(settings, rootCtx) match
+      case Some((files, ictx)) =>
+        shouldStart = true
+        ictx.base.initialize()(using ictx)
+        ictx
+      case None =>
+        shouldStart = false
+        rootCtx
   }
 
   /** the initial, empty state of the REPL session */
@@ -105,11 +109,9 @@ class ReplDriver(settings: Array[String],
 
   /** Try to run REPL if there is nothing that prevents us doing so.
    *
-   * Possible reason for unsuccessful run are raised flags in CLI like --help or --version
+   *  Possible reason for unsuccessful run are raised flags in CLI like --help or --version
    */
-  final def tryRunning = if shouldStart then
-    println("Starting scala3 REPL...")
-    runUntilQuit()
+  final def tryRunning = if shouldStart then runUntilQuit()
 
   /** Run REPL with `state` until `:quit` command found
    *
diff --git a/compiler/src/dotty/tools/scripting/ScriptingDriver.scala b/compiler/src/dotty/tools/scripting/ScriptingDriver.scala
@@ -19,30 +19,30 @@ import sys.process._
 class ScriptingDriver(compilerArgs: Array[String], scriptFile: File, scriptArgs: Array[String]) extends Driver:
   def compileAndRun(pack:(Path, String, String) => Boolean = null): Unit =
     val outDir = Files.createTempDirectory("scala3-scripting")
-    val (toCompileOrNone, rootCtx) = setup(compilerArgs :+ scriptFile.getAbsolutePath, initCtx.fresh)
-    toCompileOrNone.map { toCompile =>
-      given Context = rootCtx.fresh.setSetting(rootCtx.settings.outputDir,
-        new PlainDirectory(Directory(outDir)))
-
-      if doCompile(newCompiler, toCompile).hasErrors then
-        throw ScriptingException("Errors encountered during compilation")
-
-      try
-        val (mainClass, mainMethod) = detectMainClassAndMethod(outDir, ctx.settings.classpath.value, scriptFile)
-        val invokeMain: Boolean =
-          Option(pack) match
-            case Some(func) =>
-              func(outDir, ctx.settings.classpath.value, mainClass)
-            case None =>
-              true
-          end match
-        if invokeMain then mainMethod.invoke(null, scriptArgs)
-      catch
-        case e: java.lang.reflect.InvocationTargetException =>
-          throw e.getCause
-      finally
-        deleteFile(outDir.toFile)
-    }
+    setup(compilerArgs :+ scriptFile.getAbsolutePath, initCtx.fresh) match
+      case Some((toCompile, rootCtx)) =>
+        given Context = rootCtx.fresh.setSetting(rootCtx.settings.outputDir,
+          new PlainDirectory(Directory(outDir)))
+
+        if doCompile(newCompiler, toCompile).hasErrors then
+          throw ScriptingException("Errors encountered during compilation")
+
+        try
+          val (mainClass, mainMethod) = detectMainClassAndMethod(outDir, ctx.settings.classpath.value, scriptFile)
+          val invokeMain: Boolean =
+            Option(pack) match
+              case Some(func) =>
+                func(outDir, ctx.settings.classpath.value, mainClass)
+              case None =>
+                true
+            end match
+          if invokeMain then mainMethod.invoke(null, scriptArgs)
+        catch
+          case e: java.lang.reflect.InvocationTargetException =>
+            throw e.getCause
+        finally
+          deleteFile(outDir.toFile)
+      case None =>
   end compileAndRun
 
   private def deleteFile(target: File): Unit =
diff --git a/compiler/test/dotty/tools/dotc/ScalaCommandTest.scala b/compiler/test/dotty/tools/dotc/ScalaCommandTest.scala
@@ -5,6 +5,7 @@ import org.junit.Assert._
 import org.junit.Rule
 import org.junit.rules.TemporaryFolder
 import dotty.tools.dotc.config.Settings._
+import core.Contexts.{Context, ContextBase}
 
 class ScalaCommandTest:
 
@@ -13,27 +14,31 @@ class ScalaCommandTest:
   @Rule
   def temporaryFolder = _temporaryFolder
 
-  @Test def `Simple one parameter`: Unit =
+  @Test def `Simple one parameter`: Unit = inContext {
     val settings = config.ScalaSettings()
     val args = "-cp path/to/classes1:other/path/to/classes2 files".split(" ")
-    val summary = ScalacCommand.distill(args, settings, settings.defaultState)
+    val summary = ScalacCommand.distill(args, settings)()
     given SettingsState = summary.sstate
     assertEquals("path/to/classes1:other/path/to/classes2", settings.classpath.value)
     assertEquals("files" :: Nil, summary.arguments)
+  }
 
-  @Test def `Unfold @file`: Unit =
+  @Test def `Unfold @file`: Unit = inContext {
     val settings = config.ScalaSettings()
     val file = temporaryFolder.newFile("config")
     val writer = java.io.FileWriter(file);
     writer.write("-sourceroot myNewRoot someMoreFiles");
     writer.close();
-    val args = s"-cp path/to/classes1:other/path/to/classes2 @$file someFiles".split(" ")
-    val summary = ScalacCommand.distill(args, settings, settings.defaultState)
+    val args = s"-cp path/to/classes1:other/path/to/classes2 @${file} someFiles".split(" ")
+    val summary = ScalacCommand.distill(args, settings)()
 
     given SettingsState = summary.sstate
     assertEquals("path/to/classes1:other/path/to/classes2", settings.classpath.value)
     assertEquals("myNewRoot", settings.sourceroot.value)
     assertEquals("someMoreFiles" :: "someFiles" :: Nil, summary.arguments)
+  }
+
+  private def inContext(f: Context ?=> Unit) = f(using (new ContextBase).initialCtx.fresh)
 
   extension [T](setting: Setting[T])
     private def value(using ss: SettingsState): T = setting.valueIn(ss)
diff --git a/compiler/test/dotty/tools/dotc/SettingsTests.scala b/compiler/test/dotty/tools/dotc/SettingsTests.scala
@@ -47,7 +47,7 @@ class SettingsTests {
 
     inContext {
       val args = List("-foo", "b", "-bar", "1")
-      val summary = Settings.processArguments(args, Settings.defaultState, true)
+      val summary = Settings.processArguments(args, true)
       assertTrue(summary.errors.isEmpty)
       given SettingsState = summary.sstate
       assertEquals("b", Settings.foo.value)
@@ -65,7 +65,7 @@ class SettingsTests {
 
     inContext {
       val args = List("-foo", "b", "-bar", "1", "-baz", "5")
-      val summary = Settings.processArguments(args, Settings.defaultState, true)
+      val summary = Settings.processArguments(args, true)
       assertTrue(summary.errors.isEmpty)
       given SettingsState = summary.sstate
       assertEquals("b", Settings.foo.value)
@@ -75,15 +75,15 @@ class SettingsTests {
 
     inContext {
       val args = List("-foo:b")
-      val summary = Settings.processArguments(args, Settings.defaultState, true)
+      val summary = Settings.processArguments(args, true)
       assertTrue(summary.errors.isEmpty)
       given SettingsState = summary.sstate
       assertEquals("b", Settings.foo.value)
     }
 
     inContext {
       val args = List("-foo", "c", "-bar", "3", "-baz", "-1")
-      val summary = Settings.processArguments(args, Settings.defaultState, true)
+      val summary = Settings.processArguments(args, true)
       val expectedErrors = List(
         "c is not a valid choice for -foo",
         "3 is not a valid choice for -bar",
@@ -94,14 +94,14 @@ class SettingsTests {
 
     inContext {
       val args = List("-foo:c")
-      val summary = Settings.processArguments(args, Settings.defaultState, true)
+      val summary = Settings.processArguments(args, true)
       val expectedErrors = List("c is not a valid choice for -foo")
       assertEquals(expectedErrors, summary.errors)
     }
 
     inContext {
       val args = List("-quux", "a", "-quuz", "0")
-      val summary = Settings.processArguments(args, Settings.defaultState, true)
+      val summary = Settings.processArguments(args, true)
       val expectedErrors = List(
         "a is not a valid choice for -quux",
         "0 is not a valid choice for -quuz",
diff --git a/compiler/test/dotty/tools/dotc/core/tasty/CommentPicklingTest.scala b/compiler/test/dotty/tools/dotc/core/tasty/CommentPicklingTest.scala
@@ -107,7 +107,7 @@ class CommentPicklingTest {
   private class UnpicklingDriver extends Driver {
     override def initCtx = super.initCtx.addMode(Mode.ReadComments)
     def unpickle[T](args: Array[String], files: List[File])(fn: (List[tpd.Tree], Context) => T): T = {
-      implicit val (_, ctx: Context) = setup(args, initCtx)
+      implicit val ctx: Context = setup(args, initCtx).map(_._2).getOrElse(initCtx)
       ctx.initialize()
       val trees = files.flatMap { f =>
         val unpickler = new DottyUnpickler(f.toByteArray())
diff --git a/sbt-bridge/src/dotty/tools/xsbt/CompilerBridgeDriver.java b/sbt-bridge/src/dotty/tools/xsbt/CompilerBridgeDriver.java
@@ -60,7 +60,7 @@ synchronized public void run(VirtualFile[] sources, AnalysisCallback callback, L
         .setReporter(reporter)
         .setSbtCallback(callback);
 
-      Contexts.Context context = setup(args, initialCtx)._2;
+      Contexts.Context context = setup(args, initialCtx).map(t -> t._2).getOrElse(() -> initialCtx);
 
       if (ScalacCommand.isHelpFlag(context.settings(), context.settingsState())) {
         throw new InterfaceCompileFailed(args, new Problem[0], StopInfoError);
diff --git a/scaladoc/src/dotty/tools/scaladoc/Scaladoc.scala b/scaladoc/src/dotty/tools/scaladoc/Scaladoc.scala
@@ -76,7 +76,7 @@ object Scaladoc:
     given CompilerContext = newContext
     val ss = ScaladocSettings()
     import ss._
-    val summary = ScaladocCommand.distill(args, ss, ss.defaultState)
+    val summary = ScaladocCommand.distill(args, ss)()
     val argumentFilesOrNone = ScaladocCommand.checkUsage(summary, true)(using ss)(using summary.sstate)
 
     extension[T](arg: Setting[T])
diff --git a/staging/src/scala/quoted/staging/QuoteDriver.scala b/staging/src/scala/quoted/staging/QuoteDriver.scala
@@ -33,7 +33,7 @@ private class QuoteDriver(appClassloader: ClassLoader) extends Driver:
           new VirtualDirectory("<quote compilation output>")
     end outDir
 
-    val (_, ctx0: Context) = setup(settings.compilerArgs.toArray :+ "dummy.scala", initCtx.fresh)
+    val ctx0 = setup(settings.compilerArgs.toArray :+ "dummy.scala", initCtx.fresh).get._2
     val ctx = setCompilerSettings(ctx0.fresh.setSetting(ctx0.settings.outputDir, outDir), settings)
 
     new QuoteCompiler().newRun(ctx).compileExpr(exprBuilder) match

Original file line number	Diff line number	Diff line change
`@@ -144,7 +144,7 @@ object PathResolver {`
`144`	`144`	`}`
`145`	`145`	`else inContext(ContextBase().initialCtx) {`
`146`	`146`	`val ArgsSummary(sstate, rest, errors, warnings) =`
`147`		`- ctx.settings.processArguments(args.toList, ctx.settingsState, true)`
	`147`	`+ ctx.settings.processArguments(args.toList, true, ctx.settingsState)`
`148`	`148`	`errors.foreach(println)`
`149`	`149`	`val pr = new PathResolver()(using ctx.fresh.setSettings(sstate))`
`150`	`150`	`println(" COMMAND: 'scala %s'".format(args.mkString(" ")))`
Original file line number	Diff line number	Diff line change
`@@ -244,7 +244,7 @@ object Settings {`
`244`	`244`	`}`
`245`	`245`	`}`
`246`	`246`
`247`		`- def processArguments(arguments: List[String], settingsState: SettingsState, processAll: Boolean): ArgsSummary =`
	`247`	`+ def processArguments(arguments: List[String], processAll: Boolean, settingsState: SettingsState = defaultState): ArgsSummary =`
`248`	`248`	`processArguments(ArgsSummary(settingsState, arguments, Nil, Nil), processAll, Nil)`
`249`	`249`
`250`	`250`	`def publish[T](settingf: Int => Setting[T]): Setting[T] = {`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ class IDEDecompilerDriver(val settings: List[String]) extends dotc.Driver {`
`19`	`19`	`val rootCtx = initCtx.fresh.addMode(Mode.Interactive \| Mode.ReadPositions \| Mode.ReadComments)`
`20`	`20`	`rootCtx.setSetting(rootCtx.settings.YretainTrees, true)`
`21`	`21`	`rootCtx.setSetting(rootCtx.settings.fromTasty, true)`
`22`		`- val ctx = setup(settings.toArray :+ "dummy.scala", rootCtx)._2`
	`22`	`+ val ctx = setup(settings.toArray :+ "dummy.scala", rootCtx).get._2`
`23`	`23`	`ctx.initialize()(using ctx)`
`24`	`24`	`ctx`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ object Main extends dotc.Driver {`
`18`	`18`	`new TASTYDecompiler`
`19`	`19`	`}`
`20`	`20`
`21`		`- override def setup(args0: Array[String], rootCtx: Context): (Option[List[AbstractFile]], Context) = {`
	`21`	`+ override def setup(args0: Array[String], rootCtx: Context): Option[(List[AbstractFile], Context)] = {`
`22`	`22`	`var args = args0.filter(a => a != "-decompile")`
`23`	`23`	`if (!args.contains("-from-tasty")) args = "-from-tasty" +: args`
`24`	`24`	`if (args.contains("-d")) args = "-color:never" +: args`