Fix documentation generation from tasty with sourcepath

When running scaladoc with `-from-tasty` and `-sourcepath`, documentation
generation failed with capture checking errors and ambiguous reference errors.

Two issues were identified and fixed:

1. Capture checking was re-running on already capture-checked code from tasty,
   causing spurious errors. Now `ccEnabled` and `ccEnabledSomewhere` return
   false when `-from-tasty` is set.

2. Source files from the sourcepath were being loaded and their symbols
   entered, conflicting with symbols already loaded from tasty. Now
   `initializeFromClassPath` skips source file symbol loading when
   `-from-tasty` is set.

Additionally, the `classExistsOnSelf` check in Typer is skipped when compiling
from tasty to avoid false positives from re-typechecking.

Author: bracevac

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

@@ -140,21 +140,27 @@ object Feature:
     || ctx.compilationUnit.knowsPureFuns
     || ccEnabled
 
-  /** Is captureChecking enabled for this compilation unit? */
+  /** Is captureChecking enabled for this compilation unit?
+   *  Disabled when compiling from tasty since capture checking was already performed.
+   */
   def ccEnabled(using Context) =
-    enabledBySetting(captureChecking)
-    || ctx.originalCompilationUnit.needsCaptureChecking
+    !ctx.settings.fromTasty.value
+    && (enabledBySetting(captureChecking)
+        || ctx.originalCompilationUnit.needsCaptureChecking)
 
   /** Is pureFunctions enabled for any of the currently compiled compilation units? */
   def pureFunsEnabledSomewhere(using Context) =
     enabledBySetting(pureFunctions)
     || ctx.run != null && ctx.run.nn.pureFunsImportEncountered
     || ccEnabledSomewhere
 
-  /** Is captureChecking enabled for any of the currently compiled compilation units? */
+  /** Is captureChecking enabled for any of the currently compiled compilation units?
+   *  Disabled when compiling from tasty since capture checking was already performed.
+   */
   def ccEnabledSomewhere(using Context) =
-    if ctx.run != null then ctx.run.nn.ccEnabledSomewhere
-    else enabledBySetting(captureChecking)
+    !ctx.settings.fromTasty.value
+    && (if ctx.run != null then ctx.run.nn.ccEnabledSomewhere
+        else enabledBySetting(captureChecking))
 
   def sourceVersionSetting(using Context): SourceVersion =
     SourceVersion.valueOf(ctx.settings.source.value)

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

@@ -210,18 +210,23 @@ object SymbolLoaders {
   /** Initialize toplevel class and module symbols in `owner` from class path representation `classRep`
    */
   def initializeFromClassPath(owner: Symbol, classRep: ClassRepresentation)(using Context): Unit =
+    // When compiling from tasty, don't enter symbols from source files - they would conflict
+    // with symbols already loaded from tasty. Source files on the sourcepath are only used
+    // for documentation comments, not for symbol loading.
+    val skipSourceLoading = ctx.settings.fromTasty.value
     ((classRep.binary, classRep.source): @unchecked) match {
-      case (Some(bin), Some(src)) if needCompile(bin, src) && !binaryOnly(owner, nameOf(classRep)) =>
+      case (Some(bin), Some(src)) if !skipSourceLoading && 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)
-      case (None, Some(src)) =>
+      case (None, Some(src)) if !skipSourceLoading =>
         if (ctx.settings.verbose.value) report.inform("[symloader] no class or tasty, picked up source file for " + src.path)
         enterToplevelsFromSource(owner, nameOf(classRep), src)
       case (Some(bin), _) =>
         val completer =
           if bin.hasTastyExtension || bin.hasBetastyExtension then ctx.platform.newTastyLoader(bin)
           else ctx.platform.newClassLoader(bin)
         enterClassAndModule(owner, nameOf(classRep), completer)
+      case _ => // source-only when skipSourceLoading is true - skip
     }
 
   def needCompile(bin: AbstractFile, src: AbstractFile): Boolean =

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

@@ -3398,7 +3398,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       constr1.symbol.resetFlag(Private)
 
     val self1 = typed(self)(using ctx.outer).asInstanceOf[ValDef] // outer context where class members are not visible
-    if (self1.tpt.tpe.isError || classExistsOnSelf(cls.unforcedDecls, self1))
+    // Skip classExistsOnSelf check when compiling from tasty - this check can produce
+    // false positives when re-typechecking code that was already validated
+    if (self1.tpt.tpe.isError || (!ctx.settings.fromTasty.value && classExistsOnSelf(cls.unforcedDecls, self1)))
       // fail fast to avoid typing the body with an error type
       cdef.withType(UnspecifiedErrorType)
     else {

project/Build.scala

@@ -1312,7 +1312,7 @@ object Build {
   lazy val `scala-library-bootstrapped` = project.in(file("library"))
     .enablePlugins(ScalaLibraryPlugin)
     .settings(publishSettings)
-    .settings(disableDocSetting) // TODO now produces empty JAR to satisfy Sonatype, see https://github.com/scala/scala3/issues/24434
+    //.settings(disableDocSetting) // TODO now produces empty JAR to satisfy Sonatype, see https://github.com/scala/scala3/issues/24434
     .settings(
       name          := "scala-library-bootstrapped",
       moduleName    := "scala-library",