Change -sourcepath to behave like -scansource -sourcepath

... and delete -scansource which is now unnecessary.

The difference between these two settings is that the former assumes
that a file A.scala contains a top-level class or object A, whereas the
latter will use the outline parser to find definitions in A.scala and
create symbols for them.

So far we used the former to compile the standard library and
dotty-library, and the latter for the IDE, but we might as well always
use the latter, it's one less code path and dotty-library now uses
top-level definitions (like `type IArray` in scala/IArray.scala) so the
assumptions of -sourcepath do not apply to it anymore.

(top-level definitions are still not handled correctly with -sourcepath
after this commit, this is fixed in a latter commit in this PR)

This change required moving WithBounds which was previously in the wrong
directory.

Author: smarter

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -17,7 +17,6 @@ class ScalaSettings extends Settings.SettingGroup {
   val javabootclasspath: Setting[String] = PathSetting("-javabootclasspath", "Override java boot classpath.", Defaults.javaBootClassPath) withAbbreviation "--java-boot-class-path"
   val javaextdirs: Setting[String] = PathSetting("-javaextdirs", "Override java extdirs classpath.", Defaults.javaExtDirs) withAbbreviation "--java-extension-directories"
   val sourcepath: Setting[String] = PathSetting("-sourcepath", "Specify location(s) of source files.", Defaults.scalaSourcePath) withAbbreviation "--source-path"
-  val scansource: Setting[Boolean] = BooleanSetting("-scansource", "Scan source files to locate classes for which class-name != file-name") withAbbreviation "--scan-source"
 
   val classpath: Setting[String] = PathSetting("-classpath", "Specify where to find user class files.", defaultClasspath) withAbbreviation "-cp" withAbbreviation "--class-path"
   val outputDir: Setting[AbstractFile] = OutputSetting("-d", "directory|jar", "destination for generated classfiles.",

compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala

@@ -31,7 +31,7 @@ object SymbolLoaders {
       owner: Symbol, member: Symbol,
       completer: SymbolLoader, scope: Scope = EmptyScope)(implicit ctx: Context): Symbol = {
     val comesFromScan =
-      completer.isInstanceOf[SourcefileLoader] && ctx.settings.scansource.value
+      completer.isInstanceOf[SourcefileLoader]
     assert(comesFromScan || scope.lookup(member.name) == NoSymbol,
            s"${owner.fullName}.${member.name} already has a symbol")
     owner.asClass.enter(member, scope)
@@ -103,69 +103,60 @@ object SymbolLoaders {
       scope = scope)
   }
 
-  /** If setting -scansource is set:
-   *    Enter all toplevel classes and objects in file `src` into package `owner`, provided
-   *    they are in the right package. Issue a warning if a class or object is in the wrong
-   *    package, i.e. if the file path differs from the declared package clause.
-   *  If -scansource is not set:
-   *    Enter class and module with given `name` into scope of `owner`.
+  /** Enter all toplevel classes and objects in file `src` into package `owner`, provided
+   *  they are in the right package. Issue a warning if a class or object is in the wrong
+   *  package, i.e. if the file path differs from the declared package clause.
    *
    *  All entered symbols are given a source completer of `src` as info.
    */
   def enterToplevelsFromSource(
       owner: Symbol, name: PreName, src: AbstractFile,
-      scope: Scope = EmptyScope)(implicit ctx: Context): Unit = {
+      scope: Scope = EmptyScope)(implicit ctx: Context): Unit =
+    if src.exists && !src.isDirectory
+      val completer = new SourcefileLoader(src)
+      val filePath = owner.ownersIterator.takeWhile(!_.isRoot).map(_.name.toTermName).toList
+
+      def addPrefix(pid: RefTree, path: List[TermName]): List[TermName] = pid match {
+        case Ident(name: TermName) => name :: path
+        case Select(qual: RefTree, name: TermName) => name :: addPrefix(qual, path)
+        case _ => path
+      }
 
-    val completer = new SourcefileLoader(src)
-    if (ctx.settings.scansource.value && ctx.run != null) {
-      if (src.exists && !src.isDirectory) {
-        val filePath = owner.ownersIterator.takeWhile(!_.isRoot).map(_.name.toTermName).toList
+      def enterScanned(unit: CompilationUnit)(implicit ctx: Context) = {
 
-        def addPrefix(pid: RefTree, path: List[TermName]): List[TermName] = pid match {
-          case Ident(name: TermName) => name :: path
-          case Select(qual: RefTree, name: TermName) => name :: addPrefix(qual, path)
-          case _ => path
+        def checkPathMatches(path: List[TermName], what: String, tree: MemberDef): Boolean = {
+          val ok = filePath == path
+          if (!ok)
+            ctx.warning(i"""$what ${tree.name} is in the wrong directory.
+                           |It was declared to be in package ${path.reverse.mkString(".")}
+                           |But it is found in directory     ${filePath.reverse.mkString(File.separator)}""",
+              tree.sourcePos)
+          ok
         }
 
-        def enterScanned(unit: CompilationUnit)(implicit ctx: Context) = {
-
-          def checkPathMatches(path: List[TermName], what: String, tree: MemberDef): Boolean = {
-            val ok = filePath == path
-            if (!ok)
-              ctx.warning(i"""$what ${tree.name} is in the wrong directory.
-                              |It was declared to be in package ${path.reverse.mkString(".")}
-                              |But it is found in directory     ${filePath.reverse.mkString(File.separator)}""",
-                          tree.sourcePos)
-            ok
-          }
-
-          def traverse(tree: Tree, path: List[TermName]): Unit = tree match {
-            case PackageDef(pid, body) =>
-              val path1 = addPrefix(pid, path)
-              for (stat <- body) traverse(stat, path1)
-            case tree: TypeDef if tree.isClassDef =>
-              if (checkPathMatches(path, "class", tree))
-                enterClassAndModule(owner, tree.name, completer, scope = scope)
-                  // It might be a case class or implicit class,
-                  // so enter class and module to be on the safe side
-            case tree: ModuleDef =>
-              if (checkPathMatches(path, "object", tree))
-                enterModule(owner, tree.name, completer, scope = scope)
-            case _ =>
-          }
-
-          traverse(
-            if (unit.isJava) new OutlineJavaParser(unit.source).parse()
-            else new OutlineParser(unit.source).parse(),
-            Nil)
+        def traverse(tree: Tree, path: List[TermName]): Unit = tree match {
+          case PackageDef(pid, body) =>
+            val path1 = addPrefix(pid, path)
+            for (stat <- body) traverse(stat, path1)
+          case tree: TypeDef if tree.isClassDef =>
+            if (checkPathMatches(path, "class", tree))
+              // It might be a case class or implicit class,
+              // so enter class and module to be on the safe side
+              enterClassAndModule(owner, tree.name, completer, scope = scope)
+          case tree: ModuleDef =>
+            if (checkPathMatches(path, "object", tree))
+              enterModule(owner, tree.name, completer, scope = scope)
+          case _ =>
         }
 
-        val unit = CompilationUnit(ctx.getSource(src.path))
-        enterScanned(unit)(ctx.run.runContext.fresh.setCompilationUnit(unit))
+        traverse(
+          if (unit.isJava) new OutlineJavaParser(unit.source).parse()
+          else new OutlineParser(unit.source).parse(),
+          Nil)
       }
-    }
-    else enterClassAndModule(owner, name, completer, scope = scope)
-  }
+
+      val unit = CompilationUnit(ctx.getSource(src.path))
+      enterScanned(unit)(ctx.run.runContext.fresh.setCompilationUnit(unit))
 
   /** The package objects of scala and scala.reflect should always
    *  be loaded in binary if classfiles are available, even if sourcefiles

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -41,8 +41,8 @@ class CompilationTests extends ParallelTesting {
       compileFile("tests/pos-special/utf16encoded.scala", explicitUTF16),
       compileFile("tests/pos-special/completeFromSource/Test.scala", defaultOptions.and("-sourcepath", "tests/pos-special")),
       compileFile("tests/pos-special/completeFromSource/Test2.scala", defaultOptions.and("-sourcepath", "tests/pos-special")),
-      compileFile("tests/pos-special/completeFromSource/Test3.scala", defaultOptions.and("-sourcepath", "tests/pos-special", "-scansource")),
-      compileFile("tests/pos-special/completeFromSource/nested/Test4.scala", defaultOptions.and("-sourcepath", "tests/pos-special", "-scansource")),
+      compileFile("tests/pos-special/completeFromSource/Test3.scala", defaultOptions.and("-sourcepath", "tests/pos-special")),
+      compileFile("tests/pos-special/completeFromSource/nested/Test4.scala", defaultOptions.and("-sourcepath", "tests/pos-special")),
       compileFilesInDir("tests/pos-special/fatal-warnings", defaultOptions.and("-Xfatal-warnings", "-feature")),
       compileFilesInDir("tests/pos-special/spec-t5545", defaultOptions),
       compileFilesInDir("tests/pos-special/strawman-collections", defaultOptions),
@@ -135,7 +135,7 @@ class CompilationTests extends ParallelTesting {
       compileFilesInDir("tests/neg-custom-args/isInstanceOf", allowDeepSubtypes and "-Xfatal-warnings"),
       compileFile("tests/neg-custom-args/i3627.scala", allowDeepSubtypes),
       compileFile("tests/neg-custom-args/matchtype-loop.scala", allowDeepSubtypes),
-      compileFile("tests/neg-custom-args/completeFromSource/nested/Test1.scala", defaultOptions.and("-sourcepath", "tests/neg-custom-args", "-scansource")),
+      compileFile("tests/neg-custom-args/completeFromSource/nested/Test1.scala", defaultOptions.and("-sourcepath", "tests/neg-custom-args")),
       compileList("duplicate source", List(
         "tests/neg-custom-args/toplevel-samesource/S.scala",
         "tests/neg-custom-args/toplevel-samesource/nested/S.scala"),

language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala

@@ -87,8 +87,7 @@ class DottyLanguageServer extends LanguageServer
           config.compilerArguments.toList
             .update("-d", config.classDirectory.getAbsolutePath)
             .update("-classpath", (config.classDirectory +: config.dependencyClasspath).mkString(File.pathSeparator))
-            .update("-sourcepath", config.sourceDirectories.mkString(File.pathSeparator)) :+
-          "-scansource"
+            .update("-sourcepath", config.sourceDirectories.mkString(File.pathSeparator))
         myDrivers(config) = new InteractiveDriver(settings)
       }
     myDrivers