try always typecheck for SourcefileLoader

Author: bishabosha

compiler/src-bootstrapped/b/Bar.scala

@@ -0,0 +1,4 @@
+package b
+
+object Bar:
+  inline def bar = Foo.foo

compiler/src-bootstrapped/b/zz.scala

@@ -0,0 +1,5 @@
+package b
+
+object Foo:
+  inline def foo =
+    ???

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

@@ -119,7 +119,7 @@ object SymbolLoaders {
    *  All entered symbols are given a source completer of `src` as info.
    */
   def enterToplevelsFromSource(
-      owner: Symbol, name: PreName, src: AbstractFile,
+      owner: Symbol, src: AbstractFile,
       scope: Scope = EmptyScope)(using Context): Unit =
     if src.exists && !src.isDirectory then
       val completer = new SourcefileLoader(src)
@@ -193,10 +193,10 @@ object SymbolLoaders {
     ((classRep.binary, classRep.source): @unchecked) match {
       case (Some(bin), Some(src)) if needCompile(bin, src) && !binaryOnly(owner, nameOf(classRep)) =>
         if (ctx.settings.verbose.value) report.inform("[symloader] picked up newer source file for " + src.path)
-        enterToplevelsFromSource(owner, nameOf(classRep), src)
+        enterToplevelsFromSource(owner, src)
       case (None, Some(src)) =>
         if (ctx.settings.verbose.value) report.inform("[symloader] no class, picked up source file for " + src.path)
-        enterToplevelsFromSource(owner, nameOf(classRep), src)
+        enterToplevelsFromSource(owner, src)
       case (Some(bin), _) =>
         enterClassAndModule(owner, nameOf(classRep), ctx.platform.newClassLoader(bin))
     }
@@ -271,8 +271,8 @@ object SymbolLoaders {
         for (classRep <- classReps)
           if (!maybeModuleClass(classRep) && hasFlatName(classRep) == flat &&
             (!flat || isAbsent(classRep))) // on 2nd enter of flat names, check that the name has not been entered before
-            if packageName == "a" then
-              report.echo(s"initialising ${classRep} for ${root.symbol} in package $packageName")
+            if packageName == "a" || packageName == "b" then
+              report.echo(s"initialising ${classRep} for ${root.symbol} [${root.symbol.id}] in package $packageName")
             initializeFromClassPath(root.symbol, classRep)
         for (classRep <- classReps)
           if (maybeModuleClass(classRep) && hasFlatName(classRep) == flat &&
@@ -431,7 +431,7 @@ class SourcefileLoader(val srcfile: AbstractFile) extends SymbolLoader {
   def description(using Context): String = "source file " + srcfile.toString
   override def sourceFileOrNull: AbstractFile = srcfile
   def doComplete(root: SymDenotation)(using Context): Unit =
-    ctx.run.lateCompile(srcfile, typeCheck = ctx.settings.YretainTrees.value)
+    ctx.run.lateCompile(srcfile, typeCheck = true) // TODO: or if sourcePath is enabled?
 }
 
 /** A NoCompleter which is also a SymbolLoader. */

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

@@ -37,10 +37,13 @@ import config.Printers.typr
 
 object SymbolCapturing {
   def ids = Set(
-    2844, // a.Foo$.foo (before)
-    2756, // a.Foo (before)
-    4949, // a.Foo$.foo (after)
-    2756, // a.Foo (after)
+    2757, // a.Foo$ (before (from source /library/src-bootstrapped/b/zz.scala))
+    2758, // a.Foo (before (from source /library/src-bootstrapped/b/zz.scala))
+    2845, // a.Foo$.foo (before (from source /library/src-bootstrapped/b/zz.scala))
+    4947, // a.Foo$.foo (after)
+    6464, // b.Foo.foo (after (from source /compiler/src-bootstrapped/b/zz.scala))
+    6109, // b.Foo.foo (after (from tasty))
+    2762, // b.Foo (after (from tasty))
   )
   def doCapture(sym: Symbol): Boolean = ids.contains(sym.id)
 }

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -117,6 +117,9 @@ class TreeUnpickler(reader: TastyReader,
     val owner = ctx.owner
     val source = ctx.source
     def complete(denot: SymDenotation)(using Context): Unit =
+      if SymbolCapturing.doCapture(denot.symbol) then
+        val trace = if denot.symbol.tracer != null then s"created: ${denot.symbol.tracer}" else "no trace"
+        report.echo(i"forcing ${denot.kindString} ${denot.symbol.fullName} from source ${denot.symbol.denot.fullName} [id? ${denot.symbol.id}, trace? $trace]")
       treeAtAddr(currentAddr) = atPhaseBeforeTransforms {
         new TreeReader(reader).readIndexedDef()(
           using ctx.withOwner(owner).withSource(source))

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -719,6 +719,9 @@ private class ExtractAPICollector(using Context) extends ThunkHolder {
             seenInlines += sym // dont re-enter hashing this ref
             sym.defTree match
               case defTree: ValOrDefDef =>
+                val trace = if sym.tracer != null then s"created at: ${sym.tracer}" else "no tracer"
+                val infoTrace = if sym.denot.infoTracer != null then s"info assigned at: ${sym.denot.infoTracer}" else "no info tracer"
+                // h = err(i"#### FALSE ALARM `${ref.name}` [tree? ${tree.show}, symId? ${sym.id}, defined in ${sym.owner.id} [${sym.owner}], run? ${sym.runUUID}, $trace, $infoTrace]", ref.name, ref, h)
                 h = inlineReferenceHash(sym, defTree.rhs, h)
               case tree =>
                 val trace = if sym.tracer != null then s"created at: ${sym.tracer}" else "no tracer"

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

@@ -1257,7 +1257,7 @@ class Namer { typer: Typer =>
     override def completeInCreationContext(denot: SymDenotation): Unit = {
       if SymbolCapturing.doCapture(cls) then
         val trace = if cls.tracer != null then s"created: ${cls.tracer}" else "no trace"
-        report.echo(i"forcing class ${cls.denot.fullName} [id? ${cls.id}, trace? $trace]")
+        report.echo(i"forcing class from source ${cls.denot.fullName} [id? ${cls.id}, trace? $trace]")
       val parents = impl.parents
 
       /* The type of a parent constructor. Types constructor arguments

library/src-bootstrapped/a/Bar.scala

@@ -0,0 +1,4 @@
+package a
+
+object Bar:
+  inline def bar = Foo.foo

library/src-bootstrapped/a/b/Bar.scala

@@ -1,7 +1,6 @@
 package a
 
 object Foo:
-  inline def foo: Nothing =
-    ???
+  inline def foo =
     ???
     ???