fix(bazel/rules_angular): ensure correct typescript version is utilized in persistent worker runfiles

Updates the symlink_package rule to correctly propagate transitive source files, including standard library definitions, into the generated Bzlmod runfiles layout. Additionally, integrates the BazelSafeFilesystem instance within the persistent compiler worker to reliably resolve and load the workspace-provided TS toolchain at execution time.

Author: alan-agius4

MODULE.bazel.lock

@@ -72,9 +72,11 @@ npm.npm_translate_lock(
 )
 use_repo(npm, "rules_angular_npm")
 
-rules_angular = use_extension("//setup:extensions.bzl", "rules_angular")
-rules_angular.setup(
+rules_angular_dev = use_extension("//setup:extensions.bzl", "rules_angular", dev_dependency = True)
+rules_angular_dev.setup(
     angular_compiler_cli = "//:node_modules/@angular/compiler-cli",
     typescript = "//:node_modules/typescript",
 )
+
+rules_angular = use_extension("//setup:extensions.bzl", "rules_angular")
 use_repo(rules_angular, "rules_angular_configurable_deps")

bazel/rules/rules_angular/MODULE.bazel

@@ -1,21 +1,37 @@
 load("//setup:repositories.bzl", "configurable_deps_repo")
 
 def _extension(ctx):
+    root_setup = None
+    generated = {}
     for mod in ctx.modules:
+        if mod.is_root and mod.tags.setup:
+            root_setup = mod.tags.setup[0]
+        elif not root_setup and mod.tags.setup:
+            root_setup = mod.tags.setup[0]
+
         for attr in mod.tags.setup:
-            configurable_deps_repo(
-                name = attr.name,
-                angular_compiler_cli = attr.angular_compiler_cli,
-                typescript = attr.typescript,
-            )
+            if attr.name not in generated:
+                generated[attr.name] = True
+                configurable_deps_repo(
+                    name = attr.name,
+                    angular_compiler_cli = attr.angular_compiler_cli,
+                    typescript = attr.typescript,
+                )
+
+    if "rules_angular_configurable_deps" not in generated and root_setup:
+        configurable_deps_repo(
+            name = "rules_angular_configurable_deps",
+            angular_compiler_cli = root_setup.angular_compiler_cli,
+            typescript = root_setup.typescript,
+        )
 
 rules_angular = module_extension(
     implementation = _extension,
     tag_classes = {
         "setup": tag_class(attrs = {
             "name": attr.string(default = "rules_angular_configurable_deps"),
-            "angular_compiler_cli": attr.string(mandatory = True),
-            "typescript": attr.string(mandatory = True),
+            "angular_compiler_cli": attr.label(mandatory = True),
+            "typescript": attr.label(mandatory = True),
         }),
     },
 )

bazel/rules/rules_angular/MODULE.bazel.lock

@@ -65,7 +65,10 @@ def _symlink_impl(ctx):
         target_path = relative_file(src_manifest_path, destination_manifest_path),
     )
 
-    runfiles = ctx.runfiles(files = [destination, destination_build])
+    runfiles = ctx.runfiles(
+        files = [destination, destination_build],
+        transitive_files = src[JsInfo].transitive_sources,
+    )
 
     return [
         DefaultInfo(

bazel/rules/rules_angular/setup/extensions.bzl

@@ -1,3 +1,4 @@
+import {createRequire} from 'node:module';
 import {NodeJSFileSystem, AbsoluteFsPath} from './angular_foundation_utils.mjs';
 
 // Guarding against unexpected scenarios from within the Bazel worker.
@@ -20,4 +21,10 @@ export class BazelSafeFilesystem extends NodeJSFileSystem {
   removeDeep() {
     throw new Error('Not implemented');
   }
+
+  getDefaultLibLocation(): AbsoluteFsPath {
+    const requireFn = createRequire(import.meta.filename);
+
+    return this.resolve(requireFn.resolve('typescript'), '..');
+  }
 }

bazel/rules/rules_angular/src/private/symlink_package.bzl

@@ -6,7 +6,37 @@ import ts from 'typescript';
 
 export type AngularHostFactoryFn = (fs: FileSystem, options: ts.CompilerOptions) => ts.CompilerHost;
 
-export function createBaseCompilerHost<Host extends ts.CompilerHost>(
+/**
+ * A compiler host that is used for vanilla TypeScript compilations.
+ * It extends the AngularCompilerHostForVanillaCompilations class and overrides
+ * the methods in the base class to ensure the correct TS version is used.
+ */
+class CompilerHostForVanillaCompilations extends AngularCompilerHostForVanillaCompilations {
+  constructor(fs: FileSystem, options: ts.CompilerOptions) {
+    super(fs, options);
+  }
+
+  override getDefaultLibFileName(options: ts.CompilerOptions): string {
+    return this.fs.join(this.fs.getDefaultLibLocation(), ts.getDefaultLibFileName(options));
+  }
+
+  override getSourceFile(
+    fileName: string,
+    languageVersion: ts.ScriptTarget,
+  ): ts.SourceFile | undefined {
+    const text = this.readFile(fileName);
+    return text !== undefined
+      ? ts.createSourceFile(fileName, text, languageVersion, true)
+      : undefined;
+  }
+}
+
+/**
+ * Creates a compiler host for the given options and file system.
+ * If an Angular factory function is provided, it will be used to create the compiler host.
+ * Otherwise, a compiler host for vanilla TypeScript compilations will be created.
+ */
+export function createBaseCompilerHost(
   options: ts.CompilerOptions,
   fs: FileSystem,
   angularFactoryFn: AngularHostFactoryFn | null,
@@ -15,7 +45,7 @@ export function createBaseCompilerHost<Host extends ts.CompilerHost>(
     ? angularFactoryFn(fs, options)
     : // Even for vanilla compilations, we want to use a FS-respecting host. We can
       // just use the one from npm safely then.
-      new AngularCompilerHostForVanillaCompilations(fs, options);
+      new CompilerHostForVanillaCompilations(fs, options);
 
   // Support `--traceResolution`.
   base.trace = (output) => console.error(output);

bazel/rules/rules_angular/src/worker/bazel_safe_filesystem.mts

@@ -13,17 +13,9 @@ import {TsStructureIsReused} from './program_abstractions/structure_reused.mjs';
 import {VanillaTsProgram} from './program_abstractions/vanilla_ts.mjs';
 import {ProgramCache, WorkerProgramCacheEntry} from './program_cache.mjs';
 import {WorkRequest} from './protocol/worker.cjs';
-import {
-  AbsoluteFsPath,
-  NodeJSFileSystem,
-  readConfiguration,
-  FileSystem,
-  setFileSystem,
-} from './angular_foundation_utils.mjs';
-import {
-  ProgramDescriptor,
-  ProgramDescriptorCtor,
-} from './program_abstractions/program_descriptor.mjs';
+import {AbsoluteFsPath, readConfiguration, setFileSystem} from './angular_foundation_utils.mjs';
+import {ProgramDescriptorCtor} from './program_abstractions/program_descriptor.mjs';
+import {BazelSafeFilesystem} from './bazel_safe_filesystem.mjs';
 
 // Used for debug counting.
 let buildCount = 0;
@@ -70,7 +62,7 @@ export async function executeBuild(
   const fs =
     workerSortedInputFileNames !== null
       ? new WorkerSandboxFileSystem(workerSortedInputFileNames)
-      : new NodeJSFileSystem();
+      : new BazelSafeFilesystem();
 
   // Note: This is needed because functions like `readConfiguration` do not properly
   // re-use the passed `fs`, but call `getFileSystem`.