Scan for classes under -scansource

This lets us find a class for completion even if its name is not the filename
of the containing class.

Author: odersky

compiler/src/dotty/tools/dotc/Run.scala

@@ -88,7 +88,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     myFiles
   }
 
-  private def getSource(fileName: String): SourceFile = {
+  def getSource(fileName: String): SourceFile = {
     val f = new PlainFile(io.Path(fileName))
     if (f.isDirectory) {
       ctx.error(s"expected file, received directory '$fileName'")
@@ -170,7 +170,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     runPhases(runCtx)
     if (!ctx.reporter.hasErrors) Rewrites.writeBack()
   }
-  
+
   /** Enter top-level definitions of classes and objects contain in Scala source file `file`.
    *  The newly added symbols replace any previously entered symbols.
    */

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

@@ -16,7 +16,9 @@ class ScalaSettings extends Settings.SettingGroup {
   val extdirs = PathSetting("-extdirs", "Override location of installed extensions.", Defaults.scalaExtDirs)
   val javabootclasspath = PathSetting("-javabootclasspath", "Override java boot classpath.", Defaults.javaBootClassPath)
   val javaextdirs = PathSetting("-javaextdirs", "Override java extdirs classpath.", Defaults.javaExtDirs)
-  val sourcepath = PathSetting("-sourcepath", "Specify location(s) of source files.", "") // Defaults.scalaSourcePath
+  val sourcepath = PathSetting("-sourcepath", "Specify location(s) of source files.", Defaults.scalaSourcePath)
+  val scansource = BooleanSetting("-scansource", "Scan source files to locate classes for which class-name != file-name")
+
   val classpath = PathSetting("-classpath", "Specify where to find user class files.", defaultClasspath) withAbbreviation "-cp"
   val outputDir = PathSetting("-d", "directory|jar", "destination for generated classfiles.", ".")
   val priorityclasspath = PathSetting("-priorityclasspath", "class path that takes precedence over all other paths (or testing only)", "")
@@ -131,6 +133,7 @@ class ScalaSettings extends Settings.SettingGroup {
     sys.props("user.dir")
   )
 
+
   val projectName = StringSetting (
     "-project",
     "project title",

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

@@ -275,7 +275,7 @@ object SymDenotations {
     final def privateWithin(implicit ctx: Context): Symbol = { ensureCompleted(); myPrivateWithin }
 
     /** Set privateWithin. */
-    protected[core] final def privateWithin_=(sym: Symbol): Unit =
+    protected[dotc] final def privateWithin_=(sym: Symbol): Unit =
       myPrivateWithin = sym
 
     /** The annotations of this denotation */

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

@@ -2,7 +2,7 @@ package dotty.tools
 package dotc
 package core
 
-import java.io.IOException
+import java.io.{IOException, File}
 import scala.compat.Platform.currentTime
 import dotty.tools.io.{ ClassPath, ClassRepresentation, AbstractFile }
 import classpath._
@@ -11,8 +11,10 @@ import StdNames._, NameOps._
 import Decorators.{PreNamedString, StringInterpolators}
 import classfile.ClassfileParser
 import util.Stats
+import Decorators._
 import scala.util.control.NonFatal
 import ast.Trees._
+import parsing.Parsers.OutlineParser
 import reporting.trace
 
 object SymbolLoaders {
@@ -24,11 +26,15 @@ object SymbolLoaders {
 
 /** A base class for Symbol loaders with some overridable behavior  */
 class SymbolLoaders {
+  import ast.untpd._
 
   protected def enterNew(
       owner: Symbol, member: Symbol,
       completer: SymbolLoader, scope: Scope = EmptyScope)(implicit ctx: Context): Symbol = {
-    assert(scope.lookup(member.name) == NoSymbol, s"${owner.fullName}.${member.name} already has a symbol")
+    val comesFromScan =
+      completer.isInstanceOf[SourcefileLoader] && ctx.settings.scansource.value
+    assert(comesFromScan || scope.lookup(member.name) == NoSymbol,
+           s"${owner.fullName}.${member.name} already has a symbol")
     owner.asClass.enter(member, scope)
     member
   }
@@ -98,16 +104,65 @@ class SymbolLoaders {
       scope = scope)
   }
 
-  /** In batch mode: Enter class and module with given `name` into scope of `owner`
-   *  and give them a source completer for given `src` as type.
-   *  In IDE mode: Find all toplevel definitions in `src` and enter then into scope of `owner`
-   *  with source completer for given `src` as type.
-   *  (overridden in interactive.Global).
+  /** 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`.
+   *
+   *  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 = {
-    enterClassAndModule(owner, name, new SourcefileLoader(src), scope = scope)
+
+    val completer = new SourcefileLoader(src)
+    if (ctx.settings.scansource.value) {
+      if (src.exists && !src.isDirectory) {
+        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
+        }
+
+        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 wrong directory.
+                              |It was declared to be in package ${path.reverse.mkString(".")}
+                              |But it is found in directory     ${filePath.reverse.mkString(File.separator)}""",
+                          tree.pos)
+            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(new OutlineParser(unit.source).parse(), Nil)
+        }
+
+        val unit = new CompilationUnit(ctx.run.getSource(src.path))
+        enterScanned(unit)(ctx.run.runContext.fresh.setCompilationUnit(unit))
+      }
+    }
+    else enterClassAndModule(owner, name, completer, scope = scope)
   }
 
   /** The package objects of scala and scala.reflect should always

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

@@ -284,14 +284,32 @@ class Namer { typer: Typer =>
         else name
     }
 
+    /** Create new symbol or redefine existing symbol under lateCompile. */
+    def createOrRefine[S <: Symbol](
+        tree: MemberDef, name: Name, flags: FlagSet, infoFn: S => Type,
+        symFn: (FlagSet, S => Type, Symbol) => S): Symbol = {
+      val prev =
+        if (lateCompile && ctx.owner.is(Package)) ctx.effectiveScope.lookup(name)
+        else NoSymbol
+      val sym =
+        if (prev.exists) {
+          prev.flags = flags
+          prev.info = infoFn(prev.asInstanceOf[S])
+          prev.privateWithin = privateWithinClass(tree.mods)
+          prev
+        }
+        else symFn(flags, infoFn, privateWithinClass(tree.mods))
+      recordSym(sym, tree)
+    }
+
     tree match {
       case tree: TypeDef if tree.isClassDef =>
         val name = checkNoConflict(tree.name).asTypeName
         val flags = checkFlags(tree.mods.flags &~ Implicit)
-        val cls = recordSym(ctx.newClassSymbol(
-          ctx.owner, name, flags,
-          cls => adjustIfModule(new ClassCompleter(cls, tree)(ctx), tree),
-          privateWithinClass(tree.mods), tree.namePos, ctx.source.file), tree)
+        val cls =
+          createOrRefine[ClassSymbol](tree, name, flags,
+            cls => adjustIfModule(new ClassCompleter(cls, tree)(ctx), tree),
+            ctx.newClassSymbol(ctx.owner, name, _, _, _, tree.namePos, ctx.source.file))
         cls.completer.asInstanceOf[ClassCompleter].init()
         cls
       case tree: MemberDef =>
@@ -320,11 +338,10 @@ class Namer { typer: Typer =>
           case tree: TypeDef => new TypeDefCompleter(tree)(cctx)
           case _ => new Completer(tree)(cctx)
         }
-
-        recordSym(ctx.newSymbol(
-          ctx.owner, name, flags | deferred | method | higherKinded,
-          adjustIfModule(completer, tree),
-          privateWithinClass(tree.mods), tree.namePos), tree)
+        val info = adjustIfModule(completer, tree)
+        createOrRefine[Symbol](tree, name, flags | deferred | method | higherKinded,
+          _ => info,
+          (fs, _, pwithin) => ctx.newSymbol(ctx.owner, name, fs, info, pwithin, tree.namePos))
       case tree: Import =>
         recordSym(ctx.newImportSymbol(ctx.owner, new Completer(tree), tree.pos), tree)
       case _ =>
@@ -337,15 +354,6 @@ class Namer { typer: Typer =>
     */
   def enterSymbol(sym: Symbol)(implicit ctx: Context) = {
     if (sym.exists) {
-      if (lateCompile && sym.owner.is(Package)) {
-        val preExisting = ctx.effectiveScope.lookup(sym.name)
-        if (preExisting.exists) {
-          typr.println(i"overwriting $preExisting to late loaded $sym")
-          val old = preExisting.denot
-          old.replaceWith(sym.denot)
-          old.info = sym.info
-        }
-      }
       typr.println(s"entered: $sym in ${ctx.owner}")
       ctx.enter(sym)
     }
@@ -745,7 +753,7 @@ class Namer { typer: Typer =>
   }
 
   /** The completer of a symbol defined by a member def or import (except ClassSymbols) */
-  class Completer(val original: Tree)(implicit ctx: Context) extends LazyType {
+  class Completer(val original: Tree)(implicit ctx: Context) extends LazyType with SymbolLoaders.SecondCompleter {
 
     protected def localContext(owner: Symbol) = ctx.fresh.setOwner(owner).setTree(original)
 

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

@@ -60,6 +60,7 @@ class CompilationTests extends ParallelTesting {
     compileFile("../tests/pos-special/i3589-b.scala", defaultOptions.and("-Xfatal-warnings")) +
     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")) +
     compileList(
       "compileMixed",
       List(

tests/pos-special/completeFromSource/Test3.scala

@@ -0,0 +1,16 @@
+package completeFromSource
+import nested._
+
+class Test3 {
+
+  val x = if (true) new B(1) else new C("xx")
+
+  x match {
+    case B(n) => println(s"B($n)")
+    case C(s) => println(s"C($s)")
+  }
+}
+
+
+
+

tests/pos-special/completeFromSource/nested/BC.scala

@@ -0,0 +1,6 @@
+package completeFromSource.nested
+
+
+case class B(x: Int) extends A(x)
+
+case class C(s: String) extends A(s.length)