build: properly compile tests in core with Angular compiler (angular#60268)

Previously we never could use relative imports to import e.g. `Component`
in e.g. the `core/tests/bundling` folder. This was necessary because otherwise the
Angular compiler wouldn't process those files as it wouldn't recognize
the Angular decorator as the one from `@angular/core`.

Notably this still isn't a large issue because relative imports still
work for most core tests, that are JIT compiled!

For bundling tests though, or some smaller targets, our new upcoming
guidelines for using relative imports inside the full package; fall
apart. This commit unblocks this effort and allows us to use relative
imports in all tests of `packages/core`. This is achieved by leveraging
the existing `isCore` functionality of the compiler, and fixing a few
instances that were missing before.

PR Close angular#60268

Author: devversion

packages/bazel/src/ng_module/ng_module.bzl

@@ -5,7 +5,6 @@
 """Run Angular's AOT template compiler
 """
 
-load("//packages/bazel/src/ng_module:partial_compilation.bzl", "NgPartialCompilationInfo")
 load(
     "//packages/bazel/src:external.bzl",
     "COMMON_ATTRIBUTES",
@@ -23,6 +22,7 @@ load(
     "ts_providers_dict_to_struct",
     "tsc_wrapped_tsconfig",
 )
+load("//packages/bazel/src/ng_module:partial_compilation.bzl", "NgPartialCompilationInfo")
 
 # enable_perf_logging controls whether Ivy's performance tracing system will be enabled for any
 # compilation which includes this provider.
@@ -180,6 +180,7 @@ def _ngc_tsconfig(ctx, files, srcs, **kwargs):
         # for aliased exports. We disable relative paths and always use manifest paths in google3.
         "_useHostForImportGeneration": (not _is_bazel()),
         "_useManifestPathsAsModuleName": (not _is_bazel()),
+        "_isAngularCoreCompilation": ctx.attr.is_angular_core_compilation,
     }
 
     if is_perf_requested(ctx):
@@ -474,6 +475,10 @@ NG_MODULE_ATTRIBUTES = {
         executable = True,
         cfg = "exec",
     ),
+    "is_angular_core_compilation": attr.bool(
+        default = False,
+        doc = "Whether this is a compilation of Angular core.",
+    ),
     "_partial_compilation_flag": attr.label(
         default = "//packages/bazel/src:partial_compilation",
         providers = [NgPartialCompilationInfo],

packages/compiler-cli/private/migrations.ts

@@ -11,7 +11,7 @@
  * package requires for migration schematics.
  */
 
-export {forwardRefResolver} from '../src/ngtsc/annotations';
+export {createForwardRefResolver} from '../src/ngtsc/annotations';
 export {AbsoluteFsPath} from '../src/ngtsc/file_system';
 export {Reference} from '../src/ngtsc/imports';
 export {

packages/compiler-cli/src/ngtsc/annotations/common/src/evaluation.ts

@@ -22,12 +22,16 @@ export function resolveEnumValue(
   metadata: Map<string, ts.Expression>,
   field: string,
   enumSymbolName: string,
+  isCore: boolean,
 ): number | null {
   let resolved: number | null = null;
   if (metadata.has(field)) {
     const expr = metadata.get(field)!;
     const value = evaluator.evaluate(expr) as any;
-    if (value instanceof EnumValue && isAngularCoreReference(value.enumRef, enumSymbolName)) {
+    if (
+      value instanceof EnumValue &&
+      isAngularCoreReference(value.enumRef, enumSymbolName, isCore)
+    ) {
       resolved = value.resolved as number;
     } else {
       throw createValueHasWrongTypeError(

packages/compiler-cli/src/ngtsc/annotations/common/src/util.ts

@@ -107,8 +107,14 @@ export function isAngularCore(decorator: Decorator): decorator is Decorator & {i
   return decorator.import !== null && decorator.import.from === CORE_MODULE;
 }
 
-export function isAngularCoreReference(reference: Reference, symbolName: string): boolean {
-  return reference.ownedByModuleGuess === CORE_MODULE && reference.debugName === symbolName;
+export function isAngularCoreReference(
+  reference: Reference,
+  symbolName: string,
+  isCore: boolean,
+): boolean {
+  return (
+    (reference.ownedByModuleGuess === CORE_MODULE || isCore) && reference.debugName === symbolName
+  );
 }
 
 export function findAngularDecorator(
@@ -225,22 +231,19 @@ export function tryUnwrapForwardRef(
  * @param args the arguments to the invocation of the forwardRef expression
  * @returns an unwrapped argument if `ref` pointed to forwardRef, or null otherwise
  */
-export const forwardRefResolver: ForeignFunctionResolver = (
-  fn,
-  callExpr,
-  resolve,
-  unresolvable,
-) => {
-  if (!isAngularCoreReference(fn, 'forwardRef') || callExpr.arguments.length !== 1) {
-    return unresolvable;
-  }
-  const expanded = expandForwardRef(callExpr.arguments[0]);
-  if (expanded !== null) {
-    return resolve(expanded);
-  } else {
-    return unresolvable;
-  }
-};
+export function createForwardRefResolver(isCore: boolean): ForeignFunctionResolver {
+  return (fn, callExpr, resolve, unresolvable) => {
+    if (!isAngularCoreReference(fn, 'forwardRef', isCore) || callExpr.arguments.length !== 1) {
+      return unresolvable;
+    }
+    const expanded = expandForwardRef(callExpr.arguments[0]);
+    if (expanded !== null) {
+      return resolve(expanded);
+    } else {
+      return unresolvable;
+    }
+  };
+}
 
 /**
  * Combines an array of resolver functions into a one.

packages/compiler-cli/src/ngtsc/annotations/component/src/handler.ts

@@ -132,11 +132,11 @@ import {
   compileInputTransformFields,
   compileNgFactoryDefField,
   compileResults,
+  createForwardRefResolver,
   extractClassDebugInfo,
   extractClassMetadata,
   extractSchemas,
   findAngularDecorator,
-  forwardRefResolver,
   getDirectiveDiagnostics,
   getProviderDiagnostics,
   InjectableClassRegistry,
@@ -492,7 +492,13 @@ export class ComponentDecoratorHandler
     } = directiveResult;
     const encapsulation: number =
       (this.compilationMode !== CompilationMode.LOCAL
-        ? resolveEnumValue(this.evaluator, component, 'encapsulation', 'ViewEncapsulation')
+        ? resolveEnumValue(
+            this.evaluator,
+            component,
+            'encapsulation',
+            'ViewEncapsulation',
+            this.isCore,
+          )
         : resolveEncapsulationEnumValueLocally(component.get('encapsulation'))) ??
       ViewEncapsulation.Emulated;
 
@@ -503,6 +509,7 @@ export class ComponentDecoratorHandler
         component,
         'changeDetection',
         'ChangeDetectionStrategy',
+        this.isCore,
       );
     } else if (component.has('changeDetection')) {
       changeDetection = new o.WrappedNodeExpr(component.get('changeDetection')!);
@@ -597,7 +604,7 @@ export class ComponentDecoratorHandler
     ) {
       const importResolvers = combineResolvers([
         createModuleWithProvidersResolver(this.reflector, this.isCore),
-        forwardRefResolver,
+        createForwardRefResolver(this.isCore),
       ]);
 
       const importDiagnostics: ts.Diagnostic[] = [];

packages/compiler-cli/src/ngtsc/annotations/directive/src/shared.ts

@@ -47,6 +47,7 @@ import {
 import {
   DynamicValue,
   EnumValue,
+  ForeignFunctionResolver,
   PartialEvaluator,
   ResolvedValue,
   traceDynamicValue,
@@ -65,9 +66,9 @@ import {
 import {CompilationMode} from '../../../transform';
 import {
   assertLocalCompilationUnresolvedConst,
+  createForwardRefResolver,
   createSourceSpan,
   createValueHasWrongTypeError,
-  forwardRefResolver,
   getAngularDecorators,
   getConstructorDependencies,
   isAngularDecorator,
@@ -373,7 +374,12 @@ export function extractDirectiveMetadata(
   const hostDirectives =
     rawHostDirectives === null
       ? null
-      : extractHostDirectives(rawHostDirectives, evaluator, compilationMode);
+      : extractHostDirectives(
+          rawHostDirectives,
+          evaluator,
+          compilationMode,
+          createForwardRefResolver(isCore),
+        );
 
   if (compilationMode !== CompilationMode.LOCAL && hostDirectives !== null) {
     // In global compilation mode where we do type checking, the template type-checker will need to
@@ -1672,6 +1678,7 @@ function extractHostDirectives(
   rawHostDirectives: ts.Expression,
   evaluator: PartialEvaluator,
   compilationMode: CompilationMode,
+  forwardRefResolver: ForeignFunctionResolver,
 ): HostDirectiveMeta[] {
   const resolved = evaluator.evaluate(rawHostDirectives, forwardRefResolver);
   if (!Array.isArray(resolved)) {

packages/compiler-cli/src/ngtsc/annotations/index.ts

@@ -9,7 +9,7 @@
 /// <reference types="node" />
 
 export {
-  forwardRefResolver,
+  createForwardRefResolver,
   findAngularDecorator,
   getAngularDecorators,
   isAngularDecorator,

packages/compiler-cli/src/ngtsc/annotations/ng_module/src/handler.ts

@@ -91,11 +91,11 @@ import {
   combineResolvers,
   compileDeclareFactory,
   compileNgFactoryDefField,
+  createForwardRefResolver,
   createValueHasWrongTypeError,
   extractClassMetadata,
   extractSchemas,
   findAngularDecorator,
-  forwardRefResolver,
   getProviderDiagnostics,
   getValidConstructorDependencies,
   InjectableClassRegistry,
@@ -348,6 +348,7 @@ export class NgModuleDecoratorHandler
       return {};
     }
 
+    const forwardRefResolver = createForwardRefResolver(this.isCore);
     const moduleResolvers = combineResolvers([
       createModuleWithProvidersResolver(this.reflector, this.isCore),
       forwardRefResolver,

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

@@ -126,6 +126,15 @@ export interface InternalOptions {
    * Whether to check the event side of two-way bindings.
    */
   _checkTwoWayBoundEvents?: boolean;
+
+  /**
+   * Whether this is a compilation of Angular core itself.
+   *
+   * By default, we detect this automatically based on the existence of `r3_symbols.ts`
+   * in the compilation, but there are other test targets within the `core` package that
+   * import e.g. `Component` relatively and should be detected by the compiler.
+   */
+  _isAngularCoreCompilation?: boolean;
 }
 
 /**

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

@@ -1257,7 +1257,8 @@ export class NgCompiler {
   }
 
   private makeCompilation(): LazyCompilationState {
-    const isCore = isAngularCorePackage(this.inputProgram);
+    const isCore =
+      this.options._isAngularCoreCompilation ?? isAngularCorePackage(this.inputProgram);
 
     // Note: If this compilation builds `@angular/core`, we always build in full compilation
     // mode. Code inside the core package is always compatible with itself, so it does not