refactor(compiler,cli): drive whole-workspace compiles through the driver instead of a per-package CLI loop

compile_project looped over every workspace member calling typecheck_package,
which built a brand-new executor/workspace/session per package -- discarding
CompilerDriver::compile_package's own dependency cache every iteration, so
std/libc and shared sibling dependencies got recompiled once per package.
CompilerDriver::compile_workspace now treats members as dependencies of a
synthetic root and reuses compile_package's existing recursive, cached walk
in one call, so std is compiled once per workspace and a single member's
failure/panic fails the whole compile rather than being silently isolated.

Also collapses fp-kotlin's ad hoc 5-tuple + separately-merged map of
workspace-wide serialization facts into one KotlinWorkspaceContext struct.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: JakkuSakura

crates/fp-cli/src/commands/compile.rs

@@ -1003,115 +1003,110 @@ async fn compile_project(
     // to decide `val` vs `var` when emitting the struct, so that has to be
     // computed from every package's fully-processed AST, not just the one
     // currently being serialized.
-    let mut prepared: Vec<(PackageId, PackageSource)> = Vec::with_capacity(packages.len());
+    //
+    // Every member is compiled through ONE `CompilerDriver::compile_workspace`
+    // call, which treats the members as if they were dependencies of a
+    // synthetic root package and walks them via `compile_package`'s own
+    // recursive, cached, cycle-safe dependency machinery — so `std`/`libc`
+    // and any inter-member dependency (a workspace path dependency) is
+    // compiled exactly once for the whole workspace, not once per member. A
+    // typecheck error or panic in any one member fails/falls back the whole
+    // workspace compile (not just that member) — a package's own
+    // dependencies already work this way (an unresolvable dependency fails
+    // its dependent), so treating members the same way needs no special
+    // per-member recovery bookkeeping in the shared driver.
+    let untyped_prepared = |packages: &[PackageId]| -> Result<Vec<(PackageId, PackageSource)>> {
+        packages
+            .iter()
+            .map(|package_id| {
+                materializing_provider
+                    .load_package_source(package_id)
+                    .map(|source| (package_id.clone(), source))
+                    .map_err(|e| CliError::Compilation(e.to_string()))
+            })
+            .collect()
+    };
 
-    for package_id in &packages {
-        // Typecheck: resolve types via HIR to populate AST type slots.
-        //
-        // Batched by whole *package*, not per-file: a package's `impl SomeType`
-        // block routinely lives in a different file than `SomeType`'s own
-        // definition (e.g. types.rs defines the struct, other files add impls
-        // for it) — typechecking file-by-file makes those siblings invisible
-        // to each other, causing spurious "unresolved impl self type" errors
-        // for essentially every real multi-file package. Whole-package batching
-        // gives the typechecker the full context it needs at the cost of
-        // coarser fault isolation (one bad item anywhere in the package falls
-        // the *whole* package back to untyped, not just its one file) — still
-        // safe either way, since the call is wrapped in `catch_unwind` below.
-        let source = if !args.skip_typing {
-            let provider_for_typecheck = materializing_provider.clone();
-            let package_id_for_typecheck = package_id.clone();
-            let lossy = LossyCompileOptions {
-                enabled: args.lossy || fp_core::config::lossy_mode(),
-            };
-            let lang = lang.to_string();
-            let capabilities = crate::languages::backend::capabilities_for_target(target);
-            match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-                compiler::typecheck_package(
-                    provider_for_typecheck,
-                    &package_id_for_typecheck,
-                    lossy,
-                    &lang,
-                    capabilities,
-                )
-            })) {
-                Ok(Ok(typed_source)) => typed_source,
-                Ok(Err(e)) => {
-                    if !lossy.enabled {
-                        return Err(CliError::Compilation(format!(
-                            "typecheck failed for {}: {}",
-                            package_id.as_str(),
-                            e
-                        )));
-                    }
-                    warn!(
-                        "typecheck failed for {}: {} — falling back to untyped (lossy mode)",
-                        package_id.as_str(),
+    let capabilities = crate::languages::backend::capabilities_for_target(target);
+    let prepared: Vec<(PackageId, PackageSource)> = if !args.skip_typing {
+        let lossy = LossyCompileOptions {
+            enabled: args.lossy || fp_core::config::lossy_mode(),
+        };
+        let root_name = input
+            .file_name()
+            .and_then(|n| n.to_str())
+            .unwrap_or("workspace");
+        let root_id = PackageId::new(format!("{root_name}::__workspace_root__"));
+        let (executor, mut session) = compiler::build_workspace_session(
+            materializing_provider.clone(),
+            lang,
+            lossy,
+            capabilities,
+        );
+        match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            executor.run(session.driver().compile_workspace(&root_id, &packages))
+        })) {
+            Ok(Ok(compiled)) => {
+                compiler::drain_driver(session.driver(), lossy)?;
+                packages
+                    .iter()
+                    .zip(compiled.iter())
+                    .map(|(package_id, compiled_package)| {
+                        (
+                            package_id.clone(),
+                            compiler::package_source_from_compiled(package_id, compiled_package),
+                        )
+                    })
+                    .collect()
+            }
+            Ok(Err(e)) => {
+                if !lossy.enabled {
+                    return Err(CliError::Compilation(format!(
+                        "typecheck failed for project at {}: {}",
+                        input.display(),
                         e
-                    );
-                    materializing_provider
-                        .load_package_source(package_id)
-                        .map_err(|e| CliError::Compilation(e.to_string()))?
+                    )));
                 }
-                Err(panic_info) => {
-                    let msg = panic_info
-                        .downcast_ref::<String>()
-                        .map(|s| s.as_str())
-                        .or_else(|| panic_info.downcast_ref::<&str>().copied())
-                        .unwrap_or("(unknown)");
-                    if !lossy.enabled {
-                        return Err(CliError::Compilation(format!(
-                            "typecheck panicked for {}: {}",
-                            package_id.as_str(),
-                            msg
-                        )));
-                    }
-                    warn!(
-                        "typecheck panicked for {}: {} — falling back to untyped (lossy mode)",
-                        package_id.as_str(),
+                warn!(
+                    "typecheck failed for project at {}: {} — falling back to untyped (lossy mode)",
+                    input.display(),
+                    e
+                );
+                untyped_prepared(&packages)?
+            }
+            Err(panic_info) => {
+                let msg = panic_info
+                    .downcast_ref::<String>()
+                    .map(|s| s.as_str())
+                    .or_else(|| panic_info.downcast_ref::<&str>().copied())
+                    .unwrap_or("(unknown)");
+                if !lossy.enabled {
+                    return Err(CliError::Compilation(format!(
+                        "typecheck panicked for project at {}: {}",
+                        input.display(),
                         msg
-                    );
-                    materializing_provider
-                        .load_package_source(package_id)
-                        .map_err(|e| CliError::Compilation(e.to_string()))?
+                    )));
                 }
+                warn!(
+                    "typecheck panicked for project at {}: {} — falling back to untyped (lossy mode)",
+                    input.display(),
+                    msg
+                );
+                untyped_prepared(&packages)?
             }
-        } else {
-            materializing_provider
-                .load_package_source(package_id)
-                .map_err(|e| CliError::Compilation(e.to_string()))?
-        };
-
-        prepared.push((package_id.clone(), source));
-    }
-
-    // Field mutability (`val` vs `var`) and List-vs-String disambiguation
-    // (`.len()` -> `.size` not `.length`, range-index -> `.subList` not
-    // `.substring`) are both decided workspace-wide: a struct's fields can
-    // be defined in one package and mutated/read from another.
-    let (workspace_mutated_fields, workspace_list_fields, workspace_string_fields, workspace_enum_fields, workspace_enum_variant_names) =
-        if matches!(target, crate::languages::backend::BuiltinLanguageTarget::Kotlin) {
-            (
-                fp_kotlin::collect_mutated_field_names(prepared.iter().flat_map(|(_, src)| &src.items)),
-                fp_kotlin::collect_list_field_names(prepared.iter().flat_map(|(_, src)| &src.items)),
-                fp_kotlin::collect_string_field_names(prepared.iter().flat_map(|(_, src)| &src.items)),
-                fp_kotlin::collect_enum_field_names(prepared.iter().flat_map(|(_, src)| &src.items)),
-                fp_kotlin::collect_enum_variant_names(prepared.iter().flat_map(|(_, src)| &src.items)),
-            )
-        } else {
-            (Default::default(), Default::default(), Default::default(), Default::default(), Default::default())
-        };
+        }
+    } else {
+        untyped_prepared(&packages)?
+    };
 
-    // Every item's own qualified path -> qualified paths it references,
-    // merged across every package in the workspace (see `PackageSource::
-    // referenced_paths`) — lets the Kotlin serializer compute imports for
-    // spliced-in content from actual usage rather than only echoing the
-    // source file's pre-existing `use` items.
-    let workspace_referenced_paths: std::collections::HashMap<Vec<String>, Vec<Vec<String>>> = prepared
-        .iter()
-        .flat_map(|(_, src)| src.referenced_paths.iter())
-        .map(|(path, refs)| (path.clone(), refs.clone()))
-        .collect();
+    // Cross-package facts (field mutability, List-vs-String disambiguation,
+    // referenced-path imports) the Kotlin backend needs before serializing
+    // any single package — see `KotlinWorkspaceContext`'s doc comment.
+    let kotlin_ctx = if matches!(target, crate::languages::backend::BuiltinLanguageTarget::Kotlin) {
+        fp_kotlin::KotlinWorkspaceContext::collect(prepared.iter().map(|(_, src)| src))
+    } else {
+        fp_kotlin::KotlinWorkspaceContext::default()
+    };
 
     // Phase 2: serialize + write every package now that the workspace-wide
     // mutability set (and any other cross-package info) is complete.
@@ -1146,7 +1141,7 @@ async fn compile_project(
         let files = if let crate::languages::backend::BuiltinLanguageTarget::Kotlin = target {
             let serializer = fp_kotlin::KotlinSerializer;
             serializer
-                .serialize_package(source, &workspace_packages, &workspace_mutated_fields, &workspace_list_fields, &workspace_string_fields, &workspace_enum_fields, &workspace_referenced_paths, &workspace_enum_variant_names)
+                .serialize_package(source, &workspace_packages, &kotlin_ctx)
                 .map_err(|e| CliError::Compilation(e.to_string()))?
         } else {
             serialize_package_for_target(source, target, &args, &output.join(name))?

crates/fp-cli/src/compiler.rs

@@ -1090,7 +1090,7 @@ fn compile_source_file(
     Ok(session.into_driver())
 }
 
-fn drain_driver(driver: &mut CompilerDriver, lossy: LossyCompileOptions) -> Result<()> {
+pub fn drain_driver(driver: &mut CompilerDriver, lossy: LossyCompileOptions) -> Result<()> {
     emit_typing_diagnostics(&driver.state.borrow().typing_ctx.diagnostics.borrow(), lossy)
 }
 
@@ -1162,6 +1162,31 @@ pub fn parse_file_with_mode(
     parse_file_with_context(path, source_language, parse_mode, lossy)
 }
 
+/// Builds the executor/provider/workspace/session a typechecking compile
+/// needs — shared by `typecheck_package`'s single-package path and
+/// `compile_project`'s (`fp-cli/src/commands/compile.rs`) whole-workspace
+/// path, so a workspace compile builds this once for every member instead
+/// of once per member.
+pub fn build_workspace_session(
+    provider: Arc<dyn PackageProvider>,
+    language: &str,
+    lossy: LossyCompileOptions,
+    capabilities: fp_core::capabilities::LanguageCapabilities,
+) -> (CompilerExecutor, CompilerSession) {
+    let executor = CompilerExecutor::new();
+    let std_provider = std_provider_for(language);
+    let combined = Arc::new(fp_core::package::provider::CompositeProvider::new(vec![
+        std_provider,
+        provider,
+    ]));
+    let workspace = std::rc::Rc::new(fp_core::workspace::WorkspaceContext::new(combined));
+    let mut session = CompilerSession::new(data_layout(), &executor, workspace);
+    session.driver().pipeline = PipelineMode::TypecheckedTranspile;
+    session.driver().state.borrow_mut().set_lossy(lossy.enabled);
+    session.driver().state.borrow_mut().set_capabilities(capabilities);
+    (executor, session)
+}
+
 /// Typecheck a whole package by registering its real `PackageProvider` with
 /// a fresh `CompilerDriver` under `PipelineMode::TypecheckedTranspile`,
 /// instead of flattening the package's items into a single tag-less `File`
@@ -1184,17 +1209,7 @@ pub fn typecheck_package(
     language: &str,
     capabilities: fp_core::capabilities::LanguageCapabilities,
 ) -> Result<PackageSource> {
-    let executor = CompilerExecutor::new();
-    let std_provider = std_provider_for(language);
-    let combined = Arc::new(fp_core::package::provider::CompositeProvider::new(vec![
-        std_provider,
-        provider,
-    ]));
-    let workspace = std::rc::Rc::new(fp_core::workspace::WorkspaceContext::new(combined));
-    let mut session = CompilerSession::new(data_layout(), &executor, workspace);
-    session.driver().pipeline = PipelineMode::TypecheckedTranspile;
-    session.driver().state.borrow_mut().set_lossy(lossy.enabled);
-    session.driver().state.borrow_mut().set_capabilities(capabilities);
+    let (executor, mut session) = build_workspace_session(provider, language, lossy, capabilities);
     let package = executor
         .run(session.driver().compile_package(package_id))
         .map_err(|err| CliError::Compilation(err.to_string()))?;
@@ -1209,7 +1224,18 @@ pub fn typecheck_package(
     // placeholders through as if nothing were wrong.
     drain_driver(session.driver(), lossy)?;
 
-    let package = package.borrow();
+    Ok(package_source_from_compiled(package_id, &package))
+}
+
+/// Builds a `PackageSource` from a compiled package — shared by
+/// `typecheck_package`'s single-package path and `compile_project`'s
+/// (`fp-cli/src/commands/compile.rs`) whole-workspace path, so both read
+/// back the same typed/normalized content the same way.
+pub fn package_source_from_compiled(
+    package_id: &PackageId,
+    compiled: &std::rc::Rc<std::cell::RefCell<fp_core::package::CompiledPackage>>,
+) -> PackageSource {
+    let package = compiled.borrow();
     // Typed/normalized content is already spliced onto `package.items` by
     // `CompilerDriver::compile_package` (qualified-path-keyed, including
     // impl methods) — nothing left to reconcile here.
@@ -1229,15 +1255,14 @@ pub fn typecheck_package(
                 .collect()
         })
         .unwrap_or_default();
-    let source = PackageSource {
+    PackageSource {
         package_id: package_id.clone(),
         name: package.name.clone(),
         graph: package.graph.clone(),
         module_paths: package.module_paths.clone(),
         items,
         referenced_paths,
-    };
-    Ok(source)
+    }
 }
 
 fn parse_file_with_context(