refactor(compiler-cli): Add skeleton tests around source->source compiler transform mode

adds skeleton and tests for source->source compiler transform.

Author: atscott

packages/compiler-cli/src/ngtsc/core/src/compiler.ts

@@ -836,6 +836,8 @@ export class NgCompiler {
         compilation.isCore,
         this.closureCompilerEnabled,
         this.emitDeclarationOnly,
+        compilation.refEmitter,
+        !!this.options['_experimentalEmitIntermediateTs'],
       ),
       aliasTransformFactory(compilation.traitCompiler.exportStatements),
       defaultImportTracker.importPreservingTransformer(),
@@ -1632,6 +1634,7 @@ export class NgCompiler {
       semanticDepGraphUpdater,
       this.adapter,
       this.emitDeclarationOnly,
+      !!this.options['_experimentalEmitIntermediateTs'],
     );
 
     // Template type-checking may use the `ProgramDriver` to produce new `ts.Program`(s). If this

packages/compiler-cli/src/ngtsc/preprocessor.ts

@@ -0,0 +1,144 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+import ts from 'typescript';
+
+import {NgCompiler, NgCompilerHost} from './core';
+import {NgCompilerOptions} from './core/api';
+import {TrackedIncrementalBuildStrategy} from './incremental';
+import {ActivePerfRecorder, PerfPhase} from './perf';
+import {TsCreateProgramDriver} from './program_driver';
+import {
+  CompilationTicket,
+  freshCompilationTicket,
+  incrementalFromCompilerTicket,
+} from './core/src/compiler';
+
+/**
+ * A driver for the Angular Compiler that performs "Source-to-Source" transformation.
+ *
+ * Unlike `NgtscProgram`, this driver does NOT use `program.emit()`. Instead, it:
+ * 1. Analyzes the program using `NgCompiler`.
+ * 2. Manually runs `ts.transform` with Angular's Ivy transformers.
+ * 3. Prints the transformed AST back to a TypeScript string.
+ *
+ * This mode is designed for a mode where the Angular Compiler
+ * acts as a pre-processor for a downstream TypeScript compiler.
+ */
+export class NgtscIsolatedPreprocessor {
+  readonly compiler: NgCompiler;
+  private tsProgram: ts.Program;
+  private host: NgCompilerHost;
+  private incrementalStrategy: TrackedIncrementalBuildStrategy;
+
+  constructor(
+    rootNames: ReadonlyArray<string>,
+    private options: NgCompilerOptions,
+    delegateHost: ts.CompilerHost,
+    oldProgram?: NgtscIsolatedPreprocessor,
+  ) {
+    // Enable type reification for source-to-source transformation
+    this.options = {...options, '_experimentalEmitIntermediateTs': true};
+
+    const perfRecorder = ActivePerfRecorder.zeroedToNow();
+    perfRecorder.phase(PerfPhase.Setup);
+
+    const reuseProgram = oldProgram?.compiler.getCurrentProgram();
+    this.host = NgCompilerHost.wrap(delegateHost, rootNames, options, reuseProgram ?? null);
+
+    this.tsProgram = ts.createProgram(this.host.inputFiles, options, this.host, reuseProgram);
+
+    const programDriver = new TsCreateProgramDriver(
+      this.tsProgram,
+      this.host,
+      this.options,
+      this.host.shimExtensionPrefixes,
+    );
+
+    this.incrementalStrategy =
+      oldProgram !== undefined
+        ? oldProgram.incrementalStrategy.toNextBuildStrategy()
+        : new TrackedIncrementalBuildStrategy();
+
+    let ticket: CompilationTicket;
+    if (oldProgram === undefined) {
+      ticket = freshCompilationTicket(
+        this.tsProgram,
+        this.options,
+        this.incrementalStrategy,
+        programDriver,
+        perfRecorder,
+        /* enableTemplateTypeChecker */ !!this.options._enableTemplateTypeChecker,
+        /* usePoisonedData */ false,
+      );
+    } else {
+      ticket = incrementalFromCompilerTicket(
+        oldProgram.compiler,
+        this.tsProgram,
+        this.incrementalStrategy,
+        programDriver,
+        new Set(), // TODO: track modified resource files
+        perfRecorder,
+      );
+    }
+
+    this.compiler = NgCompiler.fromTicket(ticket, this.host);
+  }
+
+  transformAndPrint(): {fileName: string; content: string}[] {
+    // 1. Generate TCBs
+    this.compiler['ensureAnalyzed']().templateTypeChecker.generateAllTypeCheckBlocks();
+
+    const transformers = this.compiler.prepareEmit().transformers;
+    // We only care about 'before' transformers for source-to-source
+    const beforeTransformers = (transformers.before ||
+      []) as unknown as ts.TransformerFactory<ts.SourceFile>[];
+
+    const result: {fileName: string; content: string}[] = [];
+    const printer = ts.createPrinter({
+      newLine: ts.NewLineKind.LineFeed,
+      removeComments: false,
+    });
+
+    const program = this.compiler.getCurrentProgram();
+
+    for (const sf of program.getSourceFiles()) {
+      if (sf.isDeclarationFile) {
+        continue;
+      }
+
+      // If it is a TCB file (ends in .ngtypecheck.ts), we want it as-is, without any transformations.
+      if (sf.fileName.endsWith('.ngtypecheck.ts')) {
+        const content = printer.printFile(sf);
+        result.push({fileName: sf.fileName, content});
+        continue;
+      }
+
+      // Manually transform the source file
+      const transformationResult = ts.transform(sf, beforeTransformers, this.options);
+
+      if (transformationResult.transformed.length !== 1) {
+        transformationResult.dispose();
+        throw new Error(
+          `Expected exactly one transformed file, got ${transformationResult.transformed.length}`,
+        );
+      }
+
+      const transformedSf = transformationResult.transformed[0];
+
+      const content = printer.printFile(transformedSf);
+      result.push({fileName: sf.fileName, content});
+
+      transformationResult.dispose();
+
+      this.compiler.incrementalCompilation.recordSuccessfulEmit(sf);
+    }
+
+    return result;
+  }
+}

packages/compiler-cli/src/ngtsc/transform/src/compilation.ts

@@ -119,6 +119,7 @@ export class TraitCompiler implements ProgramTypeCheckAdapter {
     private semanticDepGraphUpdater: SemanticDepGraphUpdater | null,
     private sourceFileTypeIdentifier: SourceFileTypeIdentifier,
     private emitDeclarationOnly: boolean,
+    private emitIntermediateTs: boolean,
   ) {
     for (const handler of handlers) {
       this.handlersByName.set(handler.name, handler);

packages/compiler-cli/src/ngtsc/transform/src/transform.ts

@@ -13,6 +13,7 @@ import {
   DefaultImportTracker,
   ImportRewriter,
   LocalCompilationExtraImportsTracker,
+  ReferenceEmitter,
 } from '../../imports';
 import {getDefaultImportDeclaration} from '../../imports/src/default';
 import {PerfPhase, PerfRecorder} from '../../perf';
@@ -23,6 +24,7 @@ import {
   RecordWrappedNodeFn,
   translateExpression,
   translateStatement,
+  translateType,
   TranslatorOptions,
 } from '../../translator';
 import {visit, VisitListEntryResult, Visitor} from '../../util/src/visitor';
@@ -53,6 +55,8 @@ export function ivyTransformFactory(
   isCore: boolean,
   isClosureCompilerEnabled: boolean,
   emitDeclarationOnly: boolean,
+  refEmitter: ReferenceEmitter | null,
+  enableTypeReification: boolean,
 ): ts.TransformerFactory<ts.SourceFile> {
   const recordWrappedNode = createRecorderFn(defaultImportTracker);
   return (context: ts.TransformationContext): ts.Transformer<ts.SourceFile> => {
@@ -68,6 +72,8 @@ export function ivyTransformFactory(
           isCore,
           isClosureCompilerEnabled,
           emitDeclarationOnly,
+          refEmitter,
+          enableTypeReification,
           recordWrappedNode,
         ),
       );
@@ -129,6 +135,8 @@ class IvyTransformationVisitor extends Visitor {
     private isClosureCompilerEnabled: boolean,
     private isCore: boolean,
     private deferrableImports: Set<ts.ImportDeclaration>,
+    private refEmitter: ReferenceEmitter | null,
+    private enableTypeReification: boolean,
   ) {
     super();
   }
@@ -175,11 +183,22 @@ class IvyTransformationVisitor extends Visitor {
       );
 
       // Create a static property declaration for the new field.
+      let typeNode: ts.TypeNode | undefined = undefined;
+      if (this.enableTypeReification && this.refEmitter !== null) {
+        typeNode = translateType(
+          field.type,
+          sourceFile,
+          this.reflector,
+          this.refEmitter,
+          this.importManager,
+        );
+      }
+
       const property = ts.factory.createPropertyDeclaration(
         [ts.factory.createToken(ts.SyntaxKind.StaticKeyword)],
         field.name,
         undefined,
-        undefined,
+        typeNode,
         exprNode,
       );
 
@@ -376,6 +395,8 @@ function transformIvySourceFile(
   isCore: boolean,
   isClosureCompilerEnabled: boolean,
   emitDeclarationOnly: boolean,
+  refEmitter: ReferenceEmitter | null,
+  enableTypeReification: boolean,
   recordWrappedNode: RecordWrappedNodeFn<ts.Expression>,
 ): ts.SourceFile {
   const constantPool = new ConstantPool(isClosureCompilerEnabled);
@@ -414,6 +435,8 @@ function transformIvySourceFile(
     isClosureCompilerEnabled,
     isCore,
     compilationVisitor.deferrableImports,
+    refEmitter,
+    enableTypeReification,
   );
   let sf = visit(file, transformationVisitor, context);
 

packages/compiler-cli/src/ngtsc/transform/test/compilation_spec.ts

@@ -63,6 +63,7 @@ runInEachFileSystem(() => {
         null,
         fakeSfTypeIdentifier,
         /* emitDeclarationOnly */ false,
+        /* emitIntermediateTs */ false,
       );
       const sourceFile = program.getSourceFile(filename)!;
 

packages/compiler-cli/test/compliance/isolated/BUILD.bazel

@@ -0,0 +1,24 @@
+load("//tools:defaults.bzl", "jasmine_test", "ts_project")
+
+ts_project(
+    name = "test_lib",
+    testonly = True,
+    srcs = ["isolated_compile_spec.ts"],
+    deps = [
+        "//:node_modules/typescript",
+        "//packages/compiler-cli",
+        "//packages/compiler-cli/src/ngtsc/file_system",
+        "//packages/compiler-cli/src/ngtsc/testing",
+        "//packages/compiler-cli/test/compliance/test_helpers",
+    ],
+)
+
+jasmine_test(
+    name = "isolated",
+    data = [
+        ":test_lib",
+        "//packages/compiler-cli/test/compliance/test_cases",
+        "//packages/core:npm_package",
+    ],
+    shard_count = 2,
+)

packages/compiler-cli/test/compliance/isolated/isolated_compile_spec.ts

@@ -0,0 +1,110 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+
+import ts from 'typescript';
+import {checkExpectations} from '../test_helpers/check_expectations';
+import {checkNoUnexpectedErrors} from '../test_helpers/check_errors';
+import {FileSystem} from '../../../src/ngtsc/file_system';
+import {NgtscTestCompilerHost} from '../../../src/ngtsc/testing';
+import {
+  getBuildOutputDirectory,
+  initMockTestFileSystem,
+  getOptions,
+  getRootDirectory,
+} from '../test_helpers/compile_test';
+import {ComplianceTest, getAllComplianceTests} from '../test_helpers/get_compliance_tests';
+import {NgtscIsolatedPreprocessor} from '@angular/compiler-cli/src/ngtsc/preprocessor';
+
+describe('isolated compliance tests', () => {
+  for (const test of getAllComplianceTests()) {
+    if (!test.relativePath.includes('isolated')) {
+      continue;
+    }
+    describe(`[${test.relativePath}]`, () => {
+      it(test.description, () => {
+        const fs = initMockTestFileSystem(test.realTestPath);
+        const {errors} = compileTests(fs, test);
+        for (const expectation of test.expectations) {
+          checkExpectations(
+            fs,
+            test.relativePath,
+            expectation.failureMessage,
+            expectation.files,
+            expectation.extraChecks,
+          );
+          checkNoUnexpectedErrors(test.relativePath, errors);
+        }
+      });
+    });
+  }
+});
+
+function compileTests(fs: FileSystem, test: ComplianceTest): {errors: string[]} {
+  const rootDir = getRootDirectory(fs);
+  const outDir = getBuildOutputDirectory(fs);
+  const compilerOptions = test.compilerOptions;
+  const angularCompilerOptions = test.angularCompilerOptions;
+
+  const options = getOptions(rootDir, outDir, compilerOptions, angularCompilerOptions);
+  // Resolve inputs relative to rootDir.
+  const rootNames = test.inputFiles.map((f) => fs.resolve(rootDir, f));
+
+  const host = new NgtscTestCompilerHost(fs, options);
+  const preprocessor = new NgtscIsolatedPreprocessor(rootNames, options, host);
+
+  const transformedFiles = preprocessor.transformAndPrint();
+
+  const emittedFiles: string[] = [];
+  const validFiles = new Set<string>();
+
+  for (const file of transformedFiles) {
+    const relativePath = fs.relative(rootDir, fs.resolve(file.fileName));
+    const path = fs.resolve(outDir, relativePath);
+    fs.ensureDir(fs.dirname(path));
+    fs.writeFile(path, file.content);
+    emittedFiles.push(path);
+    validFiles.add(path);
+  }
+
+  const verifyHost = new NgtscTestCompilerHost(fs, options);
+  const verifyProgram = ts.createProgram({
+    rootNames: [...emittedFiles],
+    options: {
+      ...test.compilerOptions,
+      noEmit: true,
+      skipLibCheck: true,
+      // Ensure we can resolve the imports in the mock FS
+      baseUrl: rootDir,
+      paths: {
+        '*': ['node_modules/*'],
+      },
+      // Use classic Node resolution which works better with the simple mock FS structure
+      // than 'Bundler' or 'NodeNext' which expect specific package.json exports.
+      moduleResolution: ts.ModuleResolutionKind.Node10,
+      strict: true,
+      // TODO: enable once we fix the generated code
+      noImplicitAny: false,
+      target: ts.ScriptTarget.ES2015,
+      types: [],
+    },
+    host: verifyHost,
+  });
+
+  const verifyDiags = ts.getPreEmitDiagnostics(verifyProgram);
+
+  return {
+    errors: verifyDiags.map((d) => {
+      let message = ts.flattenDiagnosticMessageText(d.messageText, '\n');
+      if (d.file) {
+        const {line, character} = d.file.getLineAndCharacterOfPosition(d.start!);
+        message = `${d.file.fileName} (${line + 1},${character + 1}): ${message}`;
+      }
+      return message;
+    }),
+  };
+}