build(ivy): support alternate compilation modes to enable Ivy testing (#24056)

Bazel has a restriction that a single output (eg. a compiled version of
//packages/common) can only be produced by a single rule. This precludes
the Angular repo from having multiple rules that build the same code. And
the complexity of having a single rule produce multiple outputs (eg. an
ngc-compiled version of //packages/common and an Ivy-enabled version) is
too high.

Additionally, the Angular repo has lots of existing tests which could be
executed as-is under Ivy. Such testing is very valuable, and it would be
nice to share not only the code, but the dependency graph / build config
as well.

Thus, this change introduces a --define flag 'compile' with three potential
values. When --define=compile=X is set, the entire build system runs in a
particular mode - the behavior of all existing targets is controlled by
the flag. This allows us to reuse our entire build structure for testing
in a variety of different manners. The flag has three possible settings:

* legacy (the default): the traditional View Engine (ngc) build
* local: runs the prototype ngtsc compiler, which does not rely on global
  analysis
* jit: runs ngtsc in a mode which executes tsickle, but excludes the
  Angular related transforms, which approximates the behavior of plain
  tsc. This allows the main packages such as common to be tested with
  the JIT compiler.

Additionally, the ivy_ng_module() rule still exists and runs ngc in a mode
where Ivy-compiled output is produced from global analysis information, as
a stopgap while ngtsc is being developed.

PR Close #24056

packages/compiler-cli/integrationtest/bazel/injector_def/ivy_build/app/BUILD.bazel

@@ -1,6 +1,6 @@
 package(default_visibility = ["//visibility:public"])
 
-load("//tools:defaults.bzl", "ivy_ng_module", "ts_library")
+load("//tools:defaults.bzl", "ivy_ng_module")
 load("//packages/bazel/src:ng_rollup_bundle.bzl", "ng_rollup_bundle")
 
 ivy_ng_module(

packages/compiler-cli/src/main.ts

@@ -40,8 +40,8 @@ export function main(
 
 
 function createEmitCallback(options: api.CompilerOptions): api.TsEmitCallback|undefined {
-  const transformDecorators =
-      options.enableIvy !== 'ngtsc' && options.annotationsAs !== 'decorators';
+  const transformDecorators = options.enableIvy !== 'ngtsc' && options.enableIvy !== 'tsc' &&
+      options.annotationsAs !== 'decorators';
   const transformTypesToClosure = options.annotateForClosureCompiler;
   if (!transformDecorators && !transformTypesToClosure) {
     return undefined;

packages/compiler-cli/src/transformers/api.ts

@@ -182,9 +182,17 @@ export interface CompilerOptions extends ts.CompilerOptions {
    * Not all features are supported with this option enabled. It is only supported
    * for experimentation and testing of Render3 style code generation.
    *
+   * Acceptable values are as follows:
+   *
+   * `false` - run ngc normally
+   * `true` - run ngc with its usual global analysis, but compile decorators to Ivy fields instead
+   *  of running the View Engine compilers
+   * `ngtsc` - run the ngtsc compiler instead of the normal ngc compiler
+   * `tsc` - behave like plain tsc as much as possible (used for testing JIT code)
+   *
    * @experimental
    */
-  enableIvy?: boolean|'ngtsc';
+  enableIvy?: boolean|'ngtsc'|'tsc';
 
   /** @internal */
   collectAllErrors?: boolean;

packages/compiler-cli/src/transformers/compiler_host.ts

@@ -24,7 +24,7 @@ const EXT = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
 export function createCompilerHost(
     {options, tsHost = ts.createCompilerHost(options, true)}:
         {options: CompilerOptions, tsHost?: ts.CompilerHost}): CompilerHost {
-  if (options.enableIvy) {
+  if (options.enableIvy === 'ngtsc' || options.enableIvy === 'tsc') {
     return new NgtscCompilerHost(tsHost);
   }
   return tsHost;

packages/compiler-cli/src/transformers/program.ts

@@ -26,6 +26,7 @@ import {getAngularEmitterTransformFactory} from './node_emitter_transform';
 import {PartialModuleMetadataTransformer} from './r3_metadata_transform';
 import {StripDecoratorsMetadataTransformer, getDecoratorStripTransformerFactory} from './r3_strip_decorators';
 import {getAngularClassTransformerFactory} from './r3_transform';
+import {TscPassThroughProgram} from './tsc_pass_through';
 import {DTS, GENERATED_FILES, StructureIsReused, TS, createMessageDiagnostic, isInRootDir, ngToTsDiagnostic, tsStructureIsReused, userError} from './util';
 
 
@@ -287,7 +288,7 @@ class AngularCompilerProgram implements Program {
     emitCallback?: TsEmitCallback,
     mergeEmitResultsCallback?: TsMergeEmitResultsCallback,
   } = {}): ts.EmitResult {
-    if (this.options.enableIvy === 'ngtsc') {
+    if (this.options.enableIvy === 'ngtsc' || this.options.enableIvy === 'tsc') {
       throw new Error('Cannot run legacy compiler in ngtsc mode');
     }
     return this.options.enableIvy === true ? this._emitRender3(parameters) :
@@ -337,14 +338,34 @@ class AngularCompilerProgram implements Program {
         /* genFiles */ undefined, /* partialModules */ modules,
         /* stripDecorators */ this.reifiedDecorators, customTransformers);
 
-    const emitResult = emitCallback({
-      program: this.tsProgram,
-      host: this.host,
-      options: this.options,
-      writeFile: writeTsFile, emitOnlyDtsFiles,
-      customTransformers: tsCustomTransformers
-    });
-    return emitResult;
+
+    // Restore the original references before we emit so TypeScript doesn't emit
+    // a reference to the .d.ts file.
+    const augmentedReferences = new Map<ts.SourceFile, ReadonlyArray<ts.FileReference>>();
+    for (const sourceFile of this.tsProgram.getSourceFiles()) {
+      const originalReferences = getOriginalReferences(sourceFile);
+      if (originalReferences) {
+        augmentedReferences.set(sourceFile, sourceFile.referencedFiles);
+        sourceFile.referencedFiles = originalReferences;
+      }
+    }
+
+    try {
+      return emitCallback({
+        program: this.tsProgram,
+        host: this.host,
+        options: this.options,
+        writeFile: writeTsFile, emitOnlyDtsFiles,
+        customTransformers: tsCustomTransformers
+      });
+    } finally {
+      // Restore the references back to the augmented value to ensure that the
+      // checks that TypeScript makes for project structure reuse will succeed.
+      for (const [sourceFile, references] of Array.from(augmentedReferences)) {
+        // TODO(chuckj): Remove any cast after updating build to 2.6
+        (sourceFile as any).referencedFiles = references;
+      }
+    }
   }
 
   private _emitRender2(
@@ -909,6 +930,8 @@ export function createProgram({rootNames, options, host, oldProgram}: {
 }): Program {
   if (options.enableIvy === 'ngtsc') {
     return new NgtscProgram(rootNames, options, host, oldProgram);
+  } else if (options.enableIvy === 'tsc') {
+    return new TscPassThroughProgram(rootNames, options, host, oldProgram);
   }
   return new AngularCompilerProgram(rootNames, options, host, oldProgram);
 }

packages/compiler-cli/src/transformers/tsc_pass_through.ts

@@ -0,0 +1,107 @@
+/**
+ * @license
+ * Copyright Google Inc. 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.io/license
+ */
+
+import {GeneratedFile} from '@angular/compiler';
+import * as path from 'path';
+import * as ts from 'typescript';
+
+import * as api from '../transformers/api';
+
+/**
+ * An implementation of the `Program` API which behaves like plain `tsc` and does not include any
+ * Angular-specific behavior whatsoever.
+ *
+ * This allows `ngc` to behave like `tsc` in cases where JIT code needs to be tested.
+ */
+export class TscPassThroughProgram implements api.Program {
+  private tsProgram: ts.Program;
+
+  constructor(
+      rootNames: ReadonlyArray<string>, private options: api.CompilerOptions,
+      private host: api.CompilerHost, oldProgram?: api.Program) {
+    this.tsProgram =
+        ts.createProgram(rootNames, options, host, oldProgram && oldProgram.getTsProgram());
+  }
+
+  getTsProgram(): ts.Program { return this.tsProgram; }
+
+  getTsOptionDiagnostics(cancellationToken?: ts.CancellationToken|
+                         undefined): ReadonlyArray<ts.Diagnostic> {
+    return this.tsProgram.getOptionsDiagnostics(cancellationToken);
+  }
+
+  getNgOptionDiagnostics(cancellationToken?: ts.CancellationToken|
+                         undefined): ReadonlyArray<api.Diagnostic> {
+    return [];
+  }
+
+  getTsSyntacticDiagnostics(
+      sourceFile?: ts.SourceFile|undefined,
+      cancellationToken?: ts.CancellationToken|undefined): ReadonlyArray<ts.Diagnostic> {
+    return this.tsProgram.getSyntacticDiagnostics(sourceFile, cancellationToken);
+  }
+
+  getNgStructuralDiagnostics(cancellationToken?: ts.CancellationToken|
+                             undefined): ReadonlyArray<api.Diagnostic> {
+    return [];
+  }
+
+  getTsSemanticDiagnostics(
+      sourceFile?: ts.SourceFile|undefined,
+      cancellationToken?: ts.CancellationToken|undefined): ReadonlyArray<ts.Diagnostic> {
+    return this.tsProgram.getSemanticDiagnostics(sourceFile, cancellationToken);
+  }
+
+  getNgSemanticDiagnostics(
+      fileName?: string|undefined,
+      cancellationToken?: ts.CancellationToken|undefined): ReadonlyArray<api.Diagnostic> {
+    return [];
+  }
+
+  loadNgStructureAsync(): Promise<void> { return Promise.resolve(); }
+
+  listLazyRoutes(entryRoute?: string|undefined): api.LazyRoute[] {
+    throw new Error('Method not implemented.');
+  }
+
+  getLibrarySummaries(): Map<string, api.LibrarySummary> {
+    throw new Error('Method not implemented.');
+  }
+
+  getEmittedGeneratedFiles(): Map<string, GeneratedFile> {
+    throw new Error('Method not implemented.');
+  }
+
+  getEmittedSourceFiles(): Map<string, ts.SourceFile> {
+    throw new Error('Method not implemented.');
+  }
+
+  emit(opts?: {
+    emitFlags?: api.EmitFlags,
+    cancellationToken?: ts.CancellationToken,
+    customTransformers?: api.CustomTransformers,
+    emitCallback?: api.TsEmitCallback,
+    mergeEmitResultsCallback?: api.TsMergeEmitResultsCallback
+  }): ts.EmitResult {
+    const emitCallback = opts && opts.emitCallback || defaultEmitCallback;
+
+    const emitResult = emitCallback({
+      program: this.tsProgram,
+      host: this.host,
+      options: this.options,
+      emitOnlyDtsFiles: false,
+    });
+    return emitResult;
+  }
+}
+
+const defaultEmitCallback: api.TsEmitCallback =
+    ({program, targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles,
+      customTransformers}) =>
+        program.emit(
+            targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers);