fix(ivy): reuse default imports in type-to-value references (#29266)

This fixes an issue with commit b6f6b117. In this commit, default imports
processed in a type-to-value conversion were recorded as non-local imports
with a '*' name, and the ImportManager generated a new default import for
them. When transpiled to ES2015 modules, this resulted in the following
correct code:

import i3 from './module';

// somewhere in the file, a value reference of i3:
{type: i3}

However, when the AST with this synthetic import and reference was
transpiled to non-ES2015 modules (for example, to commonjs) an issue
appeared:

var module_1 = require('./module');
{type: i3}

TypeScript renames the imported identifier from i3 to module_1, but doesn't
substitute later references to i3. This is because the import and reference
are both synthetic, and never went through the TypeScript AST step of
"binding" which associates the reference to its import. This association is
important during emit when the identifiers might change.

Synthetic (transformer-added) imports will never be bound properly. The only
possible solution is to reuse the user's original import and the identifier
from it, which will be properly downleveled. The issue with this approach
(which prompted the fix in b6f6b117) is that if the import is only used in a
type position, TypeScript will mark it for deletion in the generated JS,
even though additional non-type usages are added in the transformer. This
again would leave a dangling import.

To work around this, it's necessary for the compiler to keep track of
identifiers that it emits which came from default imports, and tell TS not
to remove those imports during transpilation. A `DefaultImportTracker` class
is implemented to perform this tracking. It implements a
`DefaultImportRecorder` interface, which is used to record two significant
pieces of information:

* when a WrappedNodeExpr is generated which refers to a default imported
  value, the ts.Identifier is associated to the ts.ImportDeclaration via
  the recorder.
* when that WrappedNodeExpr is later emitted as part of the statement /
  expression translators, the fact that the ts.Identifier was used is
  also recorded.

Combined, this tracking gives the `DefaultImportTracker` enough information
to implement another TS transformer, which can recognize default imports
which were used in the output of the Ivy transform and can prevent them
from being elided. This is done by creating a new ts.ImportDeclaration for
the imports with the same ts.ImportClause. A test verifies that this works.

PR Close #29266

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

@@ -12,7 +12,7 @@ import * as ts from 'typescript';
 
 import {CycleAnalyzer} from '../../cycles';
 import {ErrorCode, FatalDiagnosticError} from '../../diagnostics';
-import {ModuleResolver, Reference, ReferenceEmitter} from '../../imports';
+import {DefaultImportRecorder, ModuleResolver, Reference, ReferenceEmitter} from '../../imports';
 import {EnumValue, PartialEvaluator} from '../../partial_evaluator';
 import {Decorator, ReflectionHost, filterToMembersWithDecorator, reflectObjectLiteral} from '../../reflection';
 import {LocalModuleScopeRegistry, ScopeDirective, extractDirectiveGuards} from '../../scope';
@@ -45,7 +45,7 @@ export class ComponentDecoratorHandler implements
       private resourceLoader: ResourceLoader, private rootDirs: string[],
       private defaultPreserveWhitespaces: boolean, private i18nUseExternalIds: boolean,
       private moduleResolver: ModuleResolver, private cycleAnalyzer: CycleAnalyzer,
-      private refEmitter: ReferenceEmitter) {}
+      private refEmitter: ReferenceEmitter, private defaultImportRecorder: DefaultImportRecorder) {}
 
   private literalCache = new Map<Decorator, ts.ObjectLiteralExpression>();
   private boundTemplateCache = new Map<ts.Declaration, BoundTarget<ScopeDirective>>();
@@ -135,7 +135,7 @@ export class ComponentDecoratorHandler implements
     // @Component inherits @Directive, so begin by extracting the @Directive metadata and building
     // on it.
     const directiveResult = extractDirectiveMetadata(
-        node, decorator, this.reflector, this.evaluator, this.isCore,
+        node, decorator, this.reflector, this.evaluator, this.defaultImportRecorder, this.isCore,
         this.elementSchemaRegistry.getDefaultComponentElementName());
     if (directiveResult === undefined) {
       // `extractDirectiveMetadata` returns undefined when the @Directive has `jit: true`. In this
@@ -302,7 +302,8 @@ export class ComponentDecoratorHandler implements
           viewProviders,
           i18nUseExternalIds: this.i18nUseExternalIds, relativeContextFilePath
         },
-        metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.isCore),
+        metadataStmt: generateSetClassMetadataCall(
+            node, this.reflector, this.defaultImportRecorder, this.isCore),
         parsedTemplate: template.nodes,
       },
       typeCheck: true,

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

@@ -10,7 +10,7 @@ import {ConstantPool, Expression, ParseError, ParsedHostBindings, R3DirectiveMet
 import * as ts from 'typescript';
 
 import {ErrorCode, FatalDiagnosticError} from '../../diagnostics';
-import {Reference} from '../../imports';
+import {DefaultImportRecorder, Reference} from '../../imports';
 import {DynamicValue, EnumValue, PartialEvaluator} from '../../partial_evaluator';
 import {ClassMember, ClassMemberKind, Decorator, ReflectionHost, filterToMembersWithDecorator, reflectObjectLiteral} from '../../reflection';
 import {LocalModuleScopeRegistry} from '../../scope/src/local';
@@ -30,7 +30,8 @@ export class DirectiveDecoratorHandler implements
     DecoratorHandler<DirectiveHandlerData, Decorator> {
   constructor(
       private reflector: ReflectionHost, private evaluator: PartialEvaluator,
-      private scopeRegistry: LocalModuleScopeRegistry, private isCore: boolean) {}
+      private scopeRegistry: LocalModuleScopeRegistry,
+      private defaultImportRecorder: DefaultImportRecorder, private isCore: boolean) {}
 
   readonly precedence = HandlerPrecedence.PRIMARY;
 
@@ -50,8 +51,8 @@ export class DirectiveDecoratorHandler implements
   }
 
   analyze(node: ts.ClassDeclaration, decorator: Decorator): AnalysisOutput<DirectiveHandlerData> {
-    const directiveResult =
-        extractDirectiveMetadata(node, decorator, this.reflector, this.evaluator, this.isCore);
+    const directiveResult = extractDirectiveMetadata(
+        node, decorator, this.reflector, this.evaluator, this.defaultImportRecorder, this.isCore);
     const analysis = directiveResult && directiveResult.metadata;
 
     // If the directive has a selector, it should be registered with the `SelectorScopeRegistry` so
@@ -77,7 +78,8 @@ export class DirectiveDecoratorHandler implements
     return {
       analysis: {
         meta: analysis,
-        metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.isCore),
+        metadataStmt: generateSetClassMetadataCall(
+            node, this.reflector, this.defaultImportRecorder, this.isCore),
       }
     };
   }
@@ -103,7 +105,8 @@ export class DirectiveDecoratorHandler implements
  */
 export function extractDirectiveMetadata(
     clazz: ts.ClassDeclaration, decorator: Decorator, reflector: ReflectionHost,
-    evaluator: PartialEvaluator, isCore: boolean, defaultSelector: string | null = null): {
+    evaluator: PartialEvaluator, defaultImportRecorder: DefaultImportRecorder, isCore: boolean,
+    defaultSelector: string | null = null): {
   decorator: Map<string, ts.Expression>,
   metadata: R3DirectiveMetadata,
   decoratedElements: ClassMember[],
@@ -205,7 +208,7 @@ export function extractDirectiveMetadata(
   const usesInheritance = reflector.hasBaseClass(clazz);
   const metadata: R3DirectiveMetadata = {
     name: clazz.name !.text,
-    deps: getValidConstructorDependencies(clazz, reflector, isCore), host,
+    deps: getValidConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore), host,
     lifecycle: {
         usesOnChanges,
     },

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

@@ -10,6 +10,7 @@ import {Expression, LiteralExpr, R3DependencyMetadata, R3InjectableMetadata, R3R
 import * as ts from 'typescript';
 
 import {ErrorCode, FatalDiagnosticError} from '../../diagnostics';
+import {DefaultImportRecorder} from '../../imports';
 import {Decorator, ReflectionHost, reflectObjectLiteral} from '../../reflection';
 import {AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerPrecedence} from '../../transform';
 
@@ -27,8 +28,8 @@ export interface InjectableHandlerData {
 export class InjectableDecoratorHandler implements
     DecoratorHandler<InjectableHandlerData, Decorator> {
   constructor(
-      private reflector: ReflectionHost, private isCore: boolean, private strictCtorDeps: boolean) {
-  }
+      private reflector: ReflectionHost, private defaultImportRecorder: DefaultImportRecorder,
+      private isCore: boolean, private strictCtorDeps: boolean) {}
 
   readonly precedence = HandlerPrecedence.SHARED;
 
@@ -51,8 +52,10 @@ export class InjectableDecoratorHandler implements
     return {
       analysis: {
         meta: extractInjectableMetadata(
-            node, decorator, this.reflector, this.isCore, this.strictCtorDeps),
-        metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.isCore),
+            node, decorator, this.reflector, this.defaultImportRecorder, this.isCore,
+            this.strictCtorDeps),
+        metadataStmt: generateSetClassMetadataCall(
+            node, this.reflector, this.defaultImportRecorder, this.isCore),
       },
     };
   }
@@ -78,7 +81,8 @@ export class InjectableDecoratorHandler implements
  * A `null` return value indicates this is @Injectable has invalid data.
  */
 function extractInjectableMetadata(
-    clazz: ts.ClassDeclaration, decorator: Decorator, reflector: ReflectionHost, isCore: boolean,
+    clazz: ts.ClassDeclaration, decorator: Decorator, reflector: ReflectionHost,
+    defaultImportRecorder: DefaultImportRecorder, isCore: boolean,
     strictCtorDeps: boolean): R3InjectableMetadata {
   if (clazz.name === undefined) {
     throw new FatalDiagnosticError(
@@ -101,9 +105,10 @@ function extractInjectableMetadata(
     // signature does not work for DI then an ngInjectableDef that throws.
     let ctorDeps: R3DependencyMetadata[]|'invalid'|null = null;
     if (strictCtorDeps) {
-      ctorDeps = getValidConstructorDependencies(clazz, reflector, isCore);
+      ctorDeps = getValidConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore);
     } else {
-      const possibleCtorDeps = getConstructorDependencies(clazz, reflector, isCore);
+      const possibleCtorDeps =
+          getConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore);
       if (possibleCtorDeps !== null) {
         if (possibleCtorDeps.deps !== null) {
           // This use of @Injectable has valid constructor dependencies.
@@ -124,7 +129,7 @@ function extractInjectableMetadata(
       providedIn: new LiteralExpr(null), ctorDeps,
     };
   } else if (decorator.args.length === 1) {
-    const rawCtorDeps = getConstructorDependencies(clazz, reflector, isCore);
+    const rawCtorDeps = getConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore);
     let ctorDeps: R3DependencyMetadata[]|'invalid'|null = null;
 
     // rawCtorDeps will be null if the class has no constructor.

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

@@ -9,10 +9,12 @@
 import {Expression, ExternalExpr, FunctionExpr, Identifiers, InvokeFunctionExpr, LiteralArrayExpr, LiteralExpr, ReturnStatement, Statement, WrappedNodeExpr, literalMap} from '@angular/compiler';
 import * as ts from 'typescript';
 
+import {DefaultImportRecorder} from '../../imports';
 import {CtorParameter, Decorator, ReflectionHost} from '../../reflection';
 
 import {valueReferenceToExpression} from './util';
 
+
 /**
  * Given a class declaration, generate a call to `setClassMetadata` with the Angular metadata
  * present on the class or its member fields.
@@ -21,7 +23,8 @@ import {valueReferenceToExpression} from './util';
  * as a `Statement` for inclusion along with the class.
  */
 export function generateSetClassMetadataCall(
-    clazz: ts.Declaration, reflection: ReflectionHost, isCore: boolean): Statement|null {
+    clazz: ts.Declaration, reflection: ReflectionHost, defaultImportRecorder: DefaultImportRecorder,
+    isCore: boolean): Statement|null {
   if (!reflection.isClass(clazz) || clazz.name === undefined || !ts.isIdentifier(clazz.name)) {
     return null;
   }
@@ -44,7 +47,8 @@ export function generateSetClassMetadataCall(
   let metaCtorParameters: Expression = new LiteralExpr(null);
   const classCtorParameters = reflection.getConstructorParameters(clazz);
   if (classCtorParameters !== null) {
-    const ctorParameters = classCtorParameters.map(param => ctorParameterToMetadata(param, isCore));
+    const ctorParameters = classCtorParameters.map(
+        param => ctorParameterToMetadata(param, defaultImportRecorder, isCore));
     metaCtorParameters = new FunctionExpr([], [
       new ReturnStatement(new LiteralArrayExpr(ctorParameters)),
     ]);
@@ -80,11 +84,13 @@ export function generateSetClassMetadataCall(
 /**
  * Convert a reflected constructor parameter to metadata.
  */
-function ctorParameterToMetadata(param: CtorParameter, isCore: boolean): Expression {
+function ctorParameterToMetadata(
+    param: CtorParameter, defaultImportRecorder: DefaultImportRecorder,
+    isCore: boolean): Expression {
   // Parameters sometimes have a type that can be referenced. If so, then use it, otherwise
   // its type is undefined.
   const type = param.typeValueReference !== null ?
-      valueReferenceToExpression(param.typeValueReference) :
+      valueReferenceToExpression(param.typeValueReference, defaultImportRecorder) :
       new LiteralExpr(undefined);
 
   const mapEntries: {key: string, value: Expression, quoted: false}[] = [

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

@@ -10,7 +10,7 @@ import {Expression, ExternalExpr, InvokeFunctionExpr, LiteralArrayExpr, R3Identi
 import * as ts from 'typescript';
 
 import {ErrorCode, FatalDiagnosticError} from '../../diagnostics';
-import {Reference, ReferenceEmitter} from '../../imports';
+import {DefaultImportRecorder, Reference, ReferenceEmitter} from '../../imports';
 import {PartialEvaluator, ResolvedValue} from '../../partial_evaluator';
 import {Decorator, ReflectionHost, reflectObjectLiteral, typeNodeToValueExpr} from '../../reflection';
 import {NgModuleRouteAnalyzer} from '../../routing';
@@ -39,7 +39,8 @@ export class NgModuleDecoratorHandler implements DecoratorHandler<NgModuleAnalys
       private reflector: ReflectionHost, private evaluator: PartialEvaluator,
       private scopeRegistry: LocalModuleScopeRegistry,
       private referencesRegistry: ReferencesRegistry, private isCore: boolean,
-      private routeAnalyzer: NgModuleRouteAnalyzer|null, private refEmitter: ReferenceEmitter) {}
+      private routeAnalyzer: NgModuleRouteAnalyzer|null, private refEmitter: ReferenceEmitter,
+      private defaultImportRecorder: DefaultImportRecorder) {}
 
   readonly precedence = HandlerPrecedence.PRIMARY;
 
@@ -162,7 +163,9 @@ export class NgModuleDecoratorHandler implements DecoratorHandler<NgModuleAnalys
     const ngInjectorDef: R3InjectorMetadata = {
       name,
       type: new WrappedNodeExpr(node.name !),
-      deps: getValidConstructorDependencies(node, this.reflector, this.isCore), providers,
+      deps: getValidConstructorDependencies(
+          node, this.reflector, this.defaultImportRecorder, this.isCore),
+      providers,
       imports: new LiteralArrayExpr(injectorImports),
     };
 
@@ -171,7 +174,8 @@ export class NgModuleDecoratorHandler implements DecoratorHandler<NgModuleAnalys
         ngModuleDef,
         ngInjectorDef,
         declarations,
-        metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.isCore),
+        metadataStmt: generateSetClassMetadataCall(
+            node, this.reflector, this.defaultImportRecorder, this.isCore),
       },
       factorySymbolName: node.name !== undefined ? node.name.text : undefined,
     };

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

@@ -10,7 +10,7 @@ import {LiteralExpr, R3PipeMetadata, Statement, WrappedNodeExpr, compilePipeFrom
 import * as ts from 'typescript';
 
 import {ErrorCode, FatalDiagnosticError} from '../../diagnostics';
-import {Reference} from '../../imports';
+import {DefaultImportRecorder, Reference} from '../../imports';
 import {PartialEvaluator} from '../../partial_evaluator';
 import {Decorator, ReflectionHost, reflectObjectLiteral} from '../../reflection';
 import {LocalModuleScopeRegistry} from '../../scope/src/local';
@@ -27,7 +27,8 @@ export interface PipeHandlerData {
 export class PipeDecoratorHandler implements DecoratorHandler<PipeHandlerData, Decorator> {
   constructor(
       private reflector: ReflectionHost, private evaluator: PartialEvaluator,
-      private scopeRegistry: LocalModuleScopeRegistry, private isCore: boolean) {}
+      private scopeRegistry: LocalModuleScopeRegistry,
+      private defaultImportRecorder: DefaultImportRecorder, private isCore: boolean) {}
 
   readonly precedence = HandlerPrecedence.PRIMARY;
 
@@ -98,9 +99,12 @@ export class PipeDecoratorHandler implements DecoratorHandler<PipeHandlerData, D
           name,
           type,
           pipeName,
-          deps: getValidConstructorDependencies(clazz, this.reflector, this.isCore), pure,
+          deps: getValidConstructorDependencies(
+              clazz, this.reflector, this.defaultImportRecorder, this.isCore),
+          pure,
         },
-        metadataStmt: generateSetClassMetadataCall(clazz, this.reflector, this.isCore),
+        metadataStmt: generateSetClassMetadataCall(
+            clazz, this.reflector, this.defaultImportRecorder, this.isCore),
       },
     };
   }

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

@@ -10,7 +10,7 @@ import {Expression, ExternalExpr, R3DependencyMetadata, R3Reference, R3ResolvedD
 import * as ts from 'typescript';
 
 import {ErrorCode, FatalDiagnosticError} from '../../diagnostics';
-import {ImportMode, Reference, ReferenceEmitter} from '../../imports';
+import {DefaultImportRecorder, ImportMode, Reference, ReferenceEmitter} from '../../imports';
 import {ForeignFunctionResolver} from '../../partial_evaluator';
 import {ClassMemberKind, CtorParameter, Decorator, Import, ReflectionHost, TypeValueReference} from '../../reflection';
 
@@ -33,7 +33,8 @@ export interface ConstructorDepError {
 }
 
 export function getConstructorDependencies(
-    clazz: ts.ClassDeclaration, reflector: ReflectionHost, isCore: boolean): ConstructorDeps|null {
+    clazz: ts.ClassDeclaration, reflector: ReflectionHost,
+    defaultImportRecorder: DefaultImportRecorder, isCore: boolean): ConstructorDeps|null {
   const deps: R3DependencyMetadata[] = [];
   const errors: ConstructorDepError[] = [];
   let ctorParams = reflector.getConstructorParameters(clazz);
@@ -45,7 +46,7 @@ export function getConstructorDependencies(
     }
   }
   ctorParams.forEach((param, idx) => {
-    let token = valueReferenceToExpression(param.typeValueReference);
+    let token = valueReferenceToExpression(param.typeValueReference, defaultImportRecorder);
     let optional = false, self = false, skipSelf = false, host = false;
     let resolved = R3ResolvedDependencyType.Token;
     (param.decorators || []).filter(dec => isCore || isAngularCore(dec)).forEach(dec => {
@@ -101,13 +102,24 @@ export function getConstructorDependencies(
  * references are converted to an `ExternalExpr`. Note that this is only valid in the context of the
  * file in which the `TypeValueReference` originated.
  */
-export function valueReferenceToExpression(valueRef: TypeValueReference): Expression;
-export function valueReferenceToExpression(valueRef: null): null;
-export function valueReferenceToExpression(valueRef: TypeValueReference | null): Expression|null;
-export function valueReferenceToExpression(valueRef: TypeValueReference | null): Expression|null {
+export function valueReferenceToExpression(
+    valueRef: TypeValueReference, defaultImportRecorder: DefaultImportRecorder): Expression;
+export function valueReferenceToExpression(
+    valueRef: null, defaultImportRecorder: DefaultImportRecorder): null;
+export function valueReferenceToExpression(
+    valueRef: TypeValueReference | null, defaultImportRecorder: DefaultImportRecorder): Expression|
+    null;
+export function valueReferenceToExpression(
+    valueRef: TypeValueReference | null, defaultImportRecorder: DefaultImportRecorder): Expression|
+    null {
   if (valueRef === null) {
     return null;
   } else if (valueRef.local) {
+    if (defaultImportRecorder !== null && valueRef.defaultImportStatement !== null &&
+        ts.isIdentifier(valueRef.expression)) {
+      defaultImportRecorder.recordImportedIdentifier(
+          valueRef.expression, valueRef.defaultImportStatement);
+    }
     return new WrappedNodeExpr(valueRef.expression);
   } else {
     // TODO(alxhub): this cast is necessary because the g3 typescript version doesn't narrow here.
@@ -116,10 +128,10 @@ export function valueReferenceToExpression(valueRef: TypeValueReference | null):
 }
 
 export function getValidConstructorDependencies(
-    clazz: ts.ClassDeclaration, reflector: ReflectionHost, isCore: boolean): R3DependencyMetadata[]|
-    null {
+    clazz: ts.ClassDeclaration, reflector: ReflectionHost,
+    defaultImportRecorder: DefaultImportRecorder, isCore: boolean): R3DependencyMetadata[]|null {
   return validateConstructorDependencies(
-      clazz, getConstructorDependencies(clazz, reflector, isCore));
+      clazz, getConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore));
 }
 
 export function validateConstructorDependencies(

packages/compiler-cli/src/ngtsc/annotations/test/component_spec.ts

@@ -10,7 +10,7 @@ import * as ts from 'typescript';
 
 import {CycleAnalyzer, ImportGraph} from '../../cycles';
 import {ErrorCode, FatalDiagnosticError} from '../../diagnostics';
-import {ModuleResolver, ReferenceEmitter} from '../../imports';
+import {ModuleResolver, NOOP_DEFAULT_IMPORT_RECORDER, ReferenceEmitter} from '../../imports';
 import {PartialEvaluator} from '../../partial_evaluator';
 import {TypeScriptReflectionHost} from '../../reflection';
 import {LocalModuleScopeRegistry, MetadataDtsModuleScopeResolver} from '../../scope';
@@ -55,7 +55,7 @@ describe('ComponentDecoratorHandler', () => {
 
     const handler = new ComponentDecoratorHandler(
         reflectionHost, evaluator, scopeRegistry, false, new NoopResourceLoader(), [''], false,
-        true, moduleResolver, cycleAnalyzer, refEmitter);
+        true, moduleResolver, cycleAnalyzer, refEmitter, NOOP_DEFAULT_IMPORT_RECORDER);
     const TestCmp = getDeclaration(program, 'entry.ts', 'TestCmp', ts.isClassDeclaration);
     const detected = handler.detect(TestCmp, reflectionHost.getDecoratorsOfDeclaration(TestCmp));
     if (detected === undefined) {

packages/compiler-cli/src/ngtsc/annotations/test/directive_spec.ts

@@ -8,7 +8,7 @@
 
 import * as ts from 'typescript';
 
-import {ReferenceEmitter} from '../../imports';
+import {NOOP_DEFAULT_IMPORT_RECORDER, ReferenceEmitter} from '../../imports';
 import {PartialEvaluator} from '../../partial_evaluator';
 import {TypeScriptReflectionHost} from '../../reflection';
 import {LocalModuleScopeRegistry, MetadataDtsModuleScopeResolver} from '../../scope';
@@ -43,7 +43,8 @@ describe('DirectiveDecoratorHandler', () => {
     const scopeRegistry = new LocalModuleScopeRegistry(
         new MetadataDtsModuleScopeResolver(checker, reflectionHost, null), new ReferenceEmitter([]),
         null);
-    const handler = new DirectiveDecoratorHandler(reflectionHost, evaluator, scopeRegistry, false);
+    const handler = new DirectiveDecoratorHandler(
+        reflectionHost, evaluator, scopeRegistry, NOOP_DEFAULT_IMPORT_RECORDER, false);
 
     const analyzeDirective = (dirName: string) => {
       const DirNode = getDeclaration(program, 'entry.ts', dirName, ts.isClassDeclaration);

packages/compiler-cli/src/ngtsc/annotations/test/metadata_spec.ts

@@ -8,11 +8,10 @@
 
 import * as ts from 'typescript';
 
-import {NoopImportRewriter} from '../../imports';
+import {NOOP_DEFAULT_IMPORT_RECORDER, NoopImportRewriter} from '../../imports';
 import {TypeScriptReflectionHost} from '../../reflection';
 import {getDeclaration, makeProgram} from '../../testing/in_memory_typescript';
 import {ImportManager, translateStatement} from '../../translator';
-
 import {generateSetClassMetadataCall} from '../src/metadata';
 
 const CORE = {
@@ -83,13 +82,13 @@ function compileAndPrint(contents: string): string {
   ]);
   const host = new TypeScriptReflectionHost(program.getTypeChecker());
   const target = getDeclaration(program, 'index.ts', 'Target', ts.isClassDeclaration);
-  const call = generateSetClassMetadataCall(target, host, false);
+  const call = generateSetClassMetadataCall(target, host, NOOP_DEFAULT_IMPORT_RECORDER, false);
   if (call === null) {
     return '';
   }
   const sf = program.getSourceFile('index.ts') !;
   const im = new ImportManager(new NoopImportRewriter(), 'i');
-  const tsStatement = translateStatement(call, im);
+  const tsStatement = translateStatement(call, im, NOOP_DEFAULT_IMPORT_RECORDER);
   const res = ts.createPrinter().printNode(ts.EmitHint.Unspecified, tsStatement, sf);
   return res.replace(/\s+/g, ' ');
 }

packages/compiler-cli/src/ngtsc/annotations/test/ng_module_spec.ts

@@ -10,7 +10,7 @@ import {WrappedNodeExpr} from '@angular/compiler';
 import {R3Reference} from '@angular/compiler/src/compiler';
 import * as ts from 'typescript';
 
-import {LocalIdentifierStrategy, ReferenceEmitter} from '../../imports';
+import {LocalIdentifierStrategy, NOOP_DEFAULT_IMPORT_RECORDER, ReferenceEmitter} from '../../imports';
 import {PartialEvaluator} from '../../partial_evaluator';
 import {TypeScriptReflectionHost} from '../../reflection';
 import {LocalModuleScopeRegistry, MetadataDtsModuleScopeResolver} from '../../scope';
@@ -61,7 +61,8 @@ describe('NgModuleDecoratorHandler', () => {
     const refEmitter = new ReferenceEmitter([new LocalIdentifierStrategy()]);
 
     const handler = new NgModuleDecoratorHandler(
-        reflectionHost, evaluator, scopeRegistry, referencesRegistry, false, null, refEmitter);
+        reflectionHost, evaluator, scopeRegistry, referencesRegistry, false, null, refEmitter,
+        NOOP_DEFAULT_IMPORT_RECORDER);
     const TestModule = getDeclaration(program, 'entry.ts', 'TestModule', ts.isClassDeclaration);
     const detected =
         handler.detect(TestModule, reflectionHost.getDecoratorsOfDeclaration(TestModule));