feat(compiler): support isolated declarations for NgModule via syntactic transform

Support Isolated Declarations for @NgModule by bypassing static resolution of declarations, imports, and exports arrays in declaration-only mode, and instead performing a purely syntactic transform to generate the corresponding type tuples in the .d.ts file. This adds an Isolated metadata kind to R3NgModuleMetadata and updates createNgModuleType to use it.

TAG=agy

CONV=78b5e951-e08a-440f-896f-9aa8aad00083

Author: alxhub

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

@@ -31,6 +31,7 @@ import {
   ReturnStatement,
   SchemaMetadata,
   Statement,
+  TypeofExpr,
   WrappedNodeExpr,
 } from '@angular/compiler';
 import ts from 'typescript';
@@ -364,17 +365,20 @@ export class NgModuleDecoratorHandler implements DecoratorHandler<
 
     // Resolving declarations
     let declarationRefs: Reference<ClassDeclaration>[] = [];
+    let unresolvedDeclarations: DynamicValue[] = [];
     const rawDeclarations: ts.Expression | null = ngModule.get('declarations') ?? null;
     if (rawDeclarations !== null) {
       const declarationMeta = this.evaluator.evaluate(rawDeclarations, forwardRefResolver);
-      declarationRefs = this.resolveTypeList(
+      const result = this.resolveTypeList(
         rawDeclarations,
         declarationMeta,
         name,
         'declarations',
         0,
         allowUnresolvedReferences,
-      ).references;
+      );
+      declarationRefs = result.references;
+      unresolvedDeclarations = result.dynamicValues;
 
       // Look through the declarations to make sure they're all a part of the current compilation.
       for (const ref of declarationRefs) {
@@ -399,6 +403,7 @@ export class NgModuleDecoratorHandler implements DecoratorHandler<
 
     // Resolving imports
     let importRefs: Reference<ClassDeclaration>[] = [];
+    let unresolvedImports: DynamicValue[] = [];
     let rawImports: ts.Expression | null = ngModule.get('imports') ?? null;
     if (rawImports !== null) {
       const importsMeta = this.evaluator.evaluate(rawImports, moduleResolvers);
@@ -431,21 +436,25 @@ export class NgModuleDecoratorHandler implements DecoratorHandler<
       }
 
       importRefs = result.references;
+      unresolvedImports = result.dynamicValues;
     }
 
     // Resolving exports
     let exportRefs: Reference<ClassDeclaration>[] = [];
+    let unresolvedExports: DynamicValue[] = [];
     const rawExports: ts.Expression | null = ngModule.get('exports') ?? null;
     if (rawExports !== null) {
       const exportsMeta = this.evaluator.evaluate(rawExports, moduleResolvers);
-      exportRefs = this.resolveTypeList(
+      const result = this.resolveTypeList(
         rawExports,
         exportsMeta,
         name,
         'exports',
         0,
         allowUnresolvedReferences,
-      ).references;
+      );
+      exportRefs = result.references;
+      unresolvedExports = result.dynamicValues;
       this.referencesRegistry.add(node, ...exportRefs);
     }
 
@@ -534,12 +543,33 @@ export class NgModuleDecoratorHandler implements DecoratorHandler<
         exportedDeclarations.push(decl.type);
       }
     }
-    const imports = importRefs.map((imp) =>
-      this._toR3Reference(imp.getOriginForDiagnostics(meta, node.name), imp, valueContext),
-    );
-    const exports = exportRefs.map((exp) =>
-      this._toR3Reference(exp.getOriginForDiagnostics(meta, node.name), exp, valueContext),
-    );
+    if (this.emitDeclarationOnly) {
+      for (const d of unresolvedDeclarations) {
+        const declExpr = new WrappedNodeExpr(d.node);
+        declarations.push({
+          value: declExpr,
+          type: declExpr,
+        });
+      }
+    }
+    const imports = [
+      ...importRefs.map((imp) =>
+        this._toR3Reference(imp.getOriginForDiagnostics(meta, node.name), imp, valueContext),
+      ),
+      ...unresolvedImports.map((d) => ({
+        value: new WrappedNodeExpr(d.node),
+        type: new WrappedNodeExpr(d.node),
+      })),
+    ];
+    const exports = [
+      ...exportRefs.map((exp) =>
+        this._toR3Reference(exp.getOriginForDiagnostics(meta, node.name), exp, valueContext),
+      ),
+      ...unresolvedExports.map((d) => ({
+        value: new WrappedNodeExpr(d.node),
+        type: new WrappedNodeExpr(d.node),
+      })),
+    ];
 
     const isForwardReference = (ref: R3Reference) =>
       isExpressionForwardReference(ref.value, node.name!, valueContext);
@@ -552,7 +582,30 @@ export class NgModuleDecoratorHandler implements DecoratorHandler<
     const type = wrapTypeReference(node);
 
     let ngModuleMetadata: R3NgModuleMetadata;
-    if (allowUnresolvedReferences) {
+
+    const transformToTypeTupleExpression = (expr: ts.Expression) => {
+      if (ts.isArrayLiteralExpression(expr)) {
+        const types = expr.elements.map((el) => new TypeofExpr(new WrappedNodeExpr(el)));
+        return new LiteralArrayExpr(types);
+      }
+      return new TypeofExpr(new WrappedNodeExpr(expr));
+    };
+
+    if (this.emitDeclarationOnly) {
+      ngModuleMetadata = {
+        kind: R3NgModuleMetadataKind.Isolated,
+        type,
+        bootstrapExpression: rawBootstrap ? new WrappedNodeExpr(rawBootstrap) : null,
+        declarationsExpression: rawDeclarations
+          ? transformToTypeTupleExpression(rawDeclarations)
+          : null,
+        importsExpression: rawImports ? transformToTypeTupleExpression(rawImports) : null,
+        exportsExpression: rawExports ? transformToTypeTupleExpression(rawExports) : null,
+        id,
+        selectorScopeMode: R3SelectorScopeMode.Omit,
+        schemas: [],
+      };
+    } else if (allowUnresolvedReferences) {
       ngModuleMetadata = {
         kind: R3NgModuleMetadataKind.Local,
         type,
@@ -1181,12 +1234,8 @@ export class NgModuleDecoratorHandler implements DecoratorHandler<
         entry instanceof DynamicValue &&
         entry.isFromUnknownIdentifier()
       ) {
-        throw createValueHasWrongTypeError(
-          entry.node,
-          entry,
-          `Value at position ${absoluteIndex} in the NgModule.${arrayName} of ${className} is an external reference. ` +
-            'External references in @NgModule declarations are not supported in experimental declaration-only emission mode',
-        );
+        dynamicValueSet.add(entry);
+        continue;
       } else {
         // TODO(alxhub): Produce a better diagnostic here - the array index may be an inner array.
         throw createValueHasWrongTypeError(

packages/compiler-cli/src/ngtsc/metadata/BUILD.bazel

@@ -12,6 +12,7 @@ ts_project(
         "//packages/compiler",
         "//packages/compiler-cli/src/ngtsc/file_system",
         "//packages/compiler-cli/src/ngtsc/imports",
+        "//packages/compiler-cli/src/ngtsc/partial_evaluator",
         "//packages/compiler-cli/src/ngtsc/reflection",
         "//packages/compiler-cli/src/ngtsc/util",
     ],

packages/compiler-cli/src/ngtsc/metadata/src/dts.ts

@@ -16,6 +16,7 @@ import {
   ReflectionHost,
   TypeValueReferenceKind,
 } from '../../reflection';
+import {PartialEvaluator, ResolvedValue} from '../../partial_evaluator/index';
 import {nodeDebugInfo} from '../../util/src/typescript';
 
 import {
@@ -42,10 +43,14 @@ import {
  * from an upstream compilation already.
  */
 export class DtsMetadataReader implements MetadataReader {
+  private evaluator: PartialEvaluator;
+
   constructor(
     private checker: ts.TypeChecker,
     private reflector: ReflectionHost,
-  ) {}
+  ) {
+    this.evaluator = new PartialEvaluator(this.reflector, this.checker, null);
+  }
 
   /**
    * Read the metadata from a class that has already been compiled somehow (either it's in a .d.ts
@@ -76,19 +81,16 @@ export class DtsMetadataReader implements MetadataReader {
     // Read the ModuleData out of the type arguments.
     const [_, declarationMetadata, importMetadata, exportMetadata] = ngModuleDef.type.typeArguments;
 
-    const declarations = extractReferencesFromType(
-      this.checker,
-      declarationMetadata,
+    const declarations = this.extractReferencesFromResolvedValue(
+      this.evaluator.evaluateType(declarationMetadata, ref.bestGuessOwningModule),
       ref.bestGuessOwningModule,
     );
-    const exports = extractReferencesFromType(
-      this.checker,
-      exportMetadata,
+    const exports = this.extractReferencesFromResolvedValue(
+      this.evaluator.evaluateType(exportMetadata, ref.bestGuessOwningModule),
       ref.bestGuessOwningModule,
     );
-    const imports = extractReferencesFromType(
-      this.checker,
-      importMetadata,
+    const imports = this.extractReferencesFromResolvedValue(
+      this.evaluator.evaluateType(importMetadata, ref.bestGuessOwningModule),
       ref.bestGuessOwningModule,
     );
 
@@ -116,6 +118,30 @@ export class DtsMetadataReader implements MetadataReader {
     };
   }
 
+  private extractReferencesFromResolvedValue(
+    value: ResolvedValue,
+    bestGuessOwningModule: OwningModule | null,
+  ): {result: Reference<ClassDeclaration>[]; isIncomplete: boolean} {
+    const result: Reference<ClassDeclaration>[] = [];
+    let isIncomplete = false;
+
+    if (Array.isArray(value)) {
+      for (const element of value) {
+        if (element instanceof Reference && this.reflector.isClass(element.node)) {
+          result.push(element as Reference<ClassDeclaration>);
+        } else {
+          isIncomplete = true;
+        }
+      }
+    } else if (value instanceof Reference && this.reflector.isClass(value.node)) {
+      result.push(value as Reference<ClassDeclaration>);
+    } else {
+      isIncomplete = true;
+    }
+
+    return {result, isIncomplete};
+  }
+
   /**
    * Read directive (or component) metadata from a referenced class in a .d.ts file.
    */

packages/compiler-cli/src/ngtsc/partial_evaluator/src/interface.ts

@@ -8,7 +8,7 @@
 
 import ts from 'typescript';
 
-import {Reference} from '../../imports';
+import {OwningModule, Reference} from '../../imports';
 import {DependencyTracker} from '../../incremental/api';
 import {ReflectionHost} from '../../reflection';
 
@@ -41,4 +41,20 @@ export class PartialEvaluator {
       foreignFunctionResolver,
     });
   }
+
+  evaluateType(
+    typeNode: ts.TypeNode,
+    owningModule: OwningModule | null = null,
+    foreignFunctionResolver?: ForeignFunctionResolver,
+  ): ResolvedValue {
+    const interpreter = new StaticInterpreter(this.host, this.checker, this.dependencyTracker);
+    const sourceFile = typeNode.getSourceFile();
+    return interpreter.visitType(typeNode, {
+      originatingFile: sourceFile,
+      absoluteModuleName: owningModule ? owningModule.specifier : null,
+      resolutionContext: owningModule ? owningModule.resolutionContext : sourceFile.fileName,
+      scope: new Map<ts.ParameterDeclaration, ResolvedValue>(),
+      foreignFunctionResolver,
+    });
+  }
 }

packages/compiler-cli/src/ngtsc/partial_evaluator/src/interpreter.ts

@@ -11,7 +11,14 @@ import ts from 'typescript';
 import {Reference} from '../../imports';
 import {OwningModule} from '../../imports/src/references';
 import {DependencyTracker} from '../../incremental/api';
-import {Declaration, DeclarationNode, FunctionDefinition, ReflectionHost} from '../../reflection';
+import {
+  Declaration,
+  DeclarationNode,
+  FunctionDefinition,
+  ReflectionHost,
+  reflectTypeEntityToDeclaration,
+} from '../../reflection';
+import {TypeEntityToDeclarationError} from '../../reflection/src/typescript';
 import {isDeclaration} from '../../util/src/typescript';
 
 import {ArrayConcatBuiltinFn, ArraySliceBuiltinFn, StringConcatBuiltinFn} from './builtin';
@@ -707,7 +714,7 @@ export class StaticInterpreter {
     return new Reference(node, owningModule(context));
   }
 
-  private visitType(node: ts.TypeNode, context: Context): ResolvedValue {
+  public visitType(node: ts.TypeNode, context: Context): ResolvedValue {
     if (ts.isLiteralTypeNode(node)) {
       return this.visitExpression(node.literal, context);
     } else if (ts.isTupleTypeNode(node)) {
@@ -718,6 +725,8 @@ export class StaticInterpreter {
       return this.visitType(node.type, context);
     } else if (ts.isTypeQueryNode(node)) {
       return this.visitTypeQuery(node, context);
+    } else if (ts.isTypeReferenceNode(node)) {
+      return this.visitTypeReference(node, context);
     }
 
     return DynamicValue.fromDynamicType(node);
@@ -734,18 +743,74 @@ export class StaticInterpreter {
   }
 
   private visitTypeQuery(node: ts.TypeQueryNode, context: Context): ResolvedValue {
-    const exprName = ts.isQualifiedName(node.exprName) ? node.exprName.right : node.exprName;
-    if (!ts.isIdentifier(exprName)) {
+    try {
+      const result = reflectTypeEntityToDeclaration(node.exprName, this.checker);
+      const declNode = result.node;
+      const from = result.from;
+
+      let declContext = context;
+      if (from !== null && !from.startsWith('.')) {
+        declContext = {
+          ...context,
+          absoluteModuleName: from,
+          resolutionContext: node.getSourceFile().fileName,
+        };
+      }
+
+      return this.visitDeclaration(declNode, declContext);
+    } catch (e) {
+      if (e instanceof TypeEntityToDeclarationError) {
+        return DynamicValue.fromUnknown(node);
+      }
+      throw e;
+    }
+  }
+
+  private visitTypeReference(node: ts.TypeReferenceNode, context: Context): ResolvedValue {
+    const typeName = ts.isQualifiedName(node.typeName) ? node.typeName.right : node.typeName;
+    if (!ts.isIdentifier(typeName)) {
       return DynamicValue.fromUnknown(node);
     }
 
-    const decl = this.host.getDeclarationOfIdentifier(exprName);
-    if (decl === null) {
-      return DynamicValue.fromUnknownIdentifier(exprName);
+    if (
+      typeName.text === 'ReturnType' &&
+      node.typeArguments !== undefined &&
+      node.typeArguments.length === 1
+    ) {
+      const typeArg = node.typeArguments[0];
+      const evaluatedTypeArg = this.visitType(typeArg, context);
+
+      if (evaluatedTypeArg instanceof Reference) {
+        const decl = evaluatedTypeArg.node;
+        if (ts.isFunctionDeclaration(decl) || ts.isMethodDeclaration(decl)) {
+          const rawType = decl.type;
+          if (rawType !== undefined) {
+            if (ts.isTypeReferenceNode(rawType)) {
+              const mwpTypeName = ts.isQualifiedName(rawType.typeName)
+                ? rawType.typeName.right
+                : rawType.typeName;
+              if (ts.isIdentifier(mwpTypeName) && mwpTypeName.text === 'ModuleWithProviders') {
+                if (rawType.typeArguments !== undefined && rawType.typeArguments.length === 1) {
+                  const arg = rawType.typeArguments[0];
+                  return this.visitType(arg, context);
+                }
+              }
+            }
+          }
+        }
+      }
     }
 
-    const declContext: Context = {...context, ...joinModuleContext(context, node, decl)};
-    return this.visitDeclaration(decl.node, declContext);
+    // Handle general type reference to a class!
+    const decl = this.host.getDeclarationOfIdentifier(typeName);
+    if (decl !== null && this.host.isClass(decl.node)) {
+      return this.getReference(decl.node, {
+        ...context,
+        ...joinModuleContext(context, typeName, decl),
+      });
+    }
+
+    return DynamicValue.fromDynamicType(node);
   }
 }