Sourcefile refactoring

Don't check whether a sourcefile exists when creating it - it might
lead to spurious errors. Do it instead at the point where we create
a CompilationUnit from a source file.

Author: odersky

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

@@ -9,8 +9,9 @@ import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.SymDenotations.ClassDenotation
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.transform.SymUtils._
+import util.{NoSource, SourceFile}
 
-class CompilationUnit(val source: SourceFile) {
+class CompilationUnit protected (val source: SourceFile) {
 
   override def toString: String = source.toString
 
@@ -35,11 +36,11 @@ class CompilationUnit(val source: SourceFile) {
 object CompilationUnit {
 
   /** Make a compilation unit for top class `clsd` with the contents of the `unpickled` tree */
-  def mkCompilationUnit(clsd: ClassDenotation, unpickled: Tree, forceTrees: Boolean)(implicit ctx: Context): CompilationUnit =
-    mkCompilationUnit(new SourceFile(clsd.symbol.associatedFile, Array.empty[Char]), unpickled, forceTrees)
+  def apply(clsd: ClassDenotation, unpickled: Tree, forceTrees: Boolean)(implicit ctx: Context): CompilationUnit =
+    apply(new SourceFile(clsd.symbol.associatedFile, Array.empty[Char]), unpickled, forceTrees)
 
   /** Make a compilation unit, given picked bytes and unpickled tree */
-  def mkCompilationUnit(source: SourceFile, unpickled: Tree, forceTrees: Boolean)(implicit ctx: Context): CompilationUnit = {
+  def apply(source: SourceFile, unpickled: Tree, forceTrees: Boolean)(implicit ctx: Context): CompilationUnit = {
     assert(!unpickled.isEmpty, unpickled)
     val unit1 = new CompilationUnit(source)
     unit1.tpdTree = unpickled
@@ -51,6 +52,20 @@ object CompilationUnit {
     unit1
   }
 
+  def apply(source: SourceFile)(implicit ctx: Context): CompilationUnit = {
+    val src =
+      if (source.file.isDirectory) {
+        ctx.error(s"expected file, received directory '${source.file.path}'")
+        NoSource
+      }
+      else if (!source.file.exists) {
+        ctx.error(s"not found: ${source.file.path}")
+        NoSource
+      }
+      else source
+    new CompilationUnit(source)
+  }
+
   /** Force the tree to be loaded */
   private class Force extends TreeTraverser {
     var needsStaging = false

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

@@ -100,7 +100,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   private[this] var finalizeActions = mutable.ListBuffer[() => Unit]()
 
   def compile(fileNames: List[String]): Unit = try {
-    val sources = fileNames.map(ctx.getSource)
+    val sources = fileNames.map(ctx.getSource(_))
     compileSources(sources)
   } catch {
     case NonFatal(ex) =>
@@ -116,7 +116,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
    */
   def compileSources(sources: List[SourceFile]): Unit =
     if (sources forall (_.exists)) {
-      units = sources map (new CompilationUnit(_))
+      units = sources.map(CompilationUnit(_))
       compileUnits()
     }
 
@@ -192,7 +192,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   def lateCompile(file: AbstractFile, typeCheck: Boolean)(implicit ctx: Context): Unit =
     if (!files.contains(file) && !lateFiles.contains(file)) {
       lateFiles += file
-      val unit = new CompilationUnit(ctx.getSource(file.path))
+      val unit = CompilationUnit(ctx.getSource(file.path))
       def process()(implicit ctx: Context) = {
         unit.untpdTree =
           if (unit.isJava) new JavaParser(unit.source).parse()

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

@@ -244,19 +244,9 @@ object Contexts {
         source
       case None =>
         val f = new PlainFile(Path(path.toString))
-        if (f.isDirectory) {
-          error(s"expected file, received directory '$path'")
-          NoSource
-        }
-        else if (f.exists) {
-          val src = getSource(f)
-          base.sourceNamed(path) = src
-          src
-        }
-        else {
-          error(s"not found: $path")
-          NoSource
-        }
+        val src = getSource(f)
+        base.sourceNamed(path) = src
+        src
     }
 
     /** Sourcefile with given path, memoized */

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

@@ -159,7 +159,7 @@ object SymbolLoaders {
             Nil)
         }
 
-        val unit = new CompilationUnit(ctx.getSource(src.path))
+        val unit = CompilationUnit(ctx.getSource(src.path))
         enterScanned(unit)(ctx.run.runContext.fresh.setCompilationUnit(unit))
       }
     }

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

@@ -775,8 +775,7 @@ object Symbols {
             def sourceFromTopLevel(implicit ctx: Context) =
               denot.topLevelClass.unforcedAnnotation(defn.SourceFileAnnot) match {
                 case Some(sourceAnnot) => sourceAnnot.argumentConstant(0) match {
-                  case Some(Constant(path: String)) =>
-                    ctx.getSource(path)
+                  case Some(Constant(path: String)) => ctx.getSource(path)
                   case none => NoSource
                 }
                 case none => NoSource

compiler/src/dotty/tools/dotc/fromtasty/ReadTasty.scala

@@ -9,7 +9,6 @@ import Symbols.{Symbol, ClassSymbol}
 import SymDenotations.ClassDenotation
 import NameOps._
 import ast.Trees.Tree
-import CompilationUnit.mkCompilationUnit
 import Phases.Phase
 
 
@@ -44,7 +43,7 @@ class ReadTasty extends Phase {
             case unpickler: tasty.DottyUnpickler =>
               if (cls.rootTree.isEmpty) None
               else {
-                val unit = mkCompilationUnit(cls, cls.rootTree, forceTrees = true)
+                val unit = CompilationUnit(cls, cls.rootTree, forceTrees = true)
                 unit.pickled += (cls -> unpickler.unpickler.bytes)
                 Some(unit)
               }

compiler/src/dotty/tools/dotc/quoted/QuoteCompiler.scala

@@ -52,12 +52,12 @@ class QuoteCompiler extends Compiler {
             if (putInClass) inClass(exprUnit.expr)
             else PickledQuotes.quotedExprToTree(exprUnit.expr)
           val source = SourceFile.virtual("<quoted.Expr>", "")
-          CompilationUnit.mkCompilationUnit(source, tree, forceTrees = true)
+          CompilationUnit(source, tree, forceTrees = true)
         case typeUnit: TypeCompilationUnit =>
           assert(!putInClass)
           val tree = PickledQuotes.quotedTypeToTree(typeUnit.tpe)
           val source = SourceFile.virtual("<quoted.Type>", "")
-          CompilationUnit.mkCompilationUnit(source, tree, forceTrees = true)
+          CompilationUnit(source, tree, forceTrees = true)
       }
     }
 

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

@@ -140,8 +140,8 @@ class ReplCompiler extends Compiler {
     PackageDef(Ident(nme.EMPTY_PACKAGE), List(module))
   }
 
-  private def createUnit(defs: Definitions, sourceCode: String): CompilationUnit = {
-    val unit = new CompilationUnit(SourceFile.virtual(objectName(defs.state).toString, sourceCode))
+  private def createUnit(defs: Definitions, sourceCode: String)(implicit ctx: Context): CompilationUnit = {
+    val unit = CompilationUnit(SourceFile.virtual(objectName(defs.state).toString, sourceCode))
     unit.untpdTree = wrapped(defs)
     unit
   }
@@ -156,7 +156,7 @@ class ReplCompiler extends Compiler {
 
   final def compile(parsed: Parsed)(implicit state: State): Result[(CompilationUnit, State)] = {
     val defs = definitions(parsed.trees, state)
-    val unit = createUnit(defs, parsed.sourceCode)
+    val unit = createUnit(defs, parsed.sourceCode)(state.context)
     runCompilationUnit(unit, defs.state)
   }
 
@@ -273,7 +273,7 @@ class ReplCompiler extends Compiler {
       .setSetting(state.context.settings.YstopAfter, List("frontend"))
 
     wrapped(expr, src, state).flatMap { pkg =>
-      val unit = new CompilationUnit(src)
+      val unit = CompilationUnit(src)
       unit.untpdTree = pkg
       ctx.run.compileUnits(unit :: Nil, ctx)
 

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

@@ -149,7 +149,7 @@ class ReplDriver(settings: Array[String],
 
   /** Extract possible completions at the index of `cursor` in `expr` */
   protected[this] final def completions(cursor: Int, expr: String, state0: State): List[Candidate] = {
-    def makeCandidate(completion: Completion)(implicit ctx: Context) = {
+    def makeCandidate(completion: Completion) = {
       val displ = completion.label
       new Candidate(
         /* value    = */ displ,
@@ -166,7 +166,7 @@ class ReplDriver(settings: Array[String],
       .typeCheck(expr, errorsAllowed = true)
       .map { tree =>
         val file = SourceFile.virtual("<completions>", expr)
-        val unit = new CompilationUnit(file)
+        val unit = CompilationUnit(file)(state.context)
         unit.tpdTree = tree
         implicit val ctx = state.context.fresh.setCompilationUnit(unit)
         val srcPos = SourcePosition(file, Span(cursor))