From c0c2ab30cb38f99b4d5570d8b7beffff07dcd717 Mon Sep 17 00:00:00 2001 From: Pete Bacon Darwin Date: Wed, 18 Dec 2019 14:03:05 +0000 Subject: [PATCH] fix(ngcc): use the correct identifiers when updating typings files (#34254) Previously the identifiers used in the typings files were the same as those used in the source files. When the typings files and the source files do not match exactly, e.g. when one of them is flattened, while the other is a deep tree, it is possible for identifiers to be renamed. This commit ensures that the correct identifier is used in typings files when the typings file does not export the same name as the source file. Fixes https://github.com/angular/ngcc-validation/pull/608 PR Close #34254 --- .../ngcc/test/integration/ngcc_spec.ts | 28 +++++++++++++++++++ .../src/ngtsc/annotations/src/directive.ts | 9 +++--- .../src/ngtsc/annotations/src/injectable.ts | 4 +-- .../src/ngtsc/annotations/src/ng_module.ts | 16 +++++++---- .../src/ngtsc/annotations/src/pipe.ts | 5 ++-- .../src/ngtsc/annotations/src/util.ts | 15 ++++++++++ .../compiler/src/injectable_compiler_2.ts | 10 +++---- packages/compiler/src/jit_compiler_facade.ts | 12 ++++---- packages/compiler/src/render3/r3_factory.ts | 6 ++-- .../src/render3/r3_module_compiler.ts | 8 +++--- .../compiler/src/render3/r3_pipe_compiler.ts | 10 +++---- packages/compiler/src/render3/util.ts | 5 ++++ packages/compiler/src/render3/view/api.ts | 3 +- .../compiler/src/render3/view/compiler.ts | 2 +- 14 files changed, 94 insertions(+), 39 deletions(-) diff --git a/packages/compiler-cli/ngcc/test/integration/ngcc_spec.ts b/packages/compiler-cli/ngcc/test/integration/ngcc_spec.ts index e2387792c79..cd2311c11ae 100644 --- a/packages/compiler-cli/ngcc/test/integration/ngcc_spec.ts +++ b/packages/compiler-cli/ngcc/test/integration/ngcc_spec.ts @@ -235,6 +235,34 @@ runInEachFileSystem(() => { `TestClass.ɵprov = ɵngcc0.ɵɵdefineInjectable({`); }); + it('should use the correct type name in typings files when an export has a different name in source files', + () => { + // We need to make sure that changes to the typings files use the correct name + // static ɵprov: ɵngcc0.ɵɵInjectableDef<ɵangular_packages_common_common_a>; + mainNgcc({ + basePath: '/node_modules', + targetEntryPointPath: '@angular/common', + propertiesToConsider: ['esm2015'] + }); + + // In `@angular/common` the `NgClassR3Impl` class gets exported as something like + // `ɵangular_packages_common_common_a`. + const jsContents = fs.readFile(_(`/node_modules/@angular/common/fesm2015/common.js`)); + const exportedNameMatch = jsContents.match(/export.* NgClassR3Impl as ([^ ,}]+)/); + if (exportedNameMatch === null) { + return fail( + 'Expected `/node_modules/@angular/common/fesm2015/common.js` to export `NgClassR3Impl` via an alias'); + } + const exportedName = exportedNameMatch[1]; + + // We need to make sure that the flat typings file exports this directly + const dtsContents = fs.readFile(_('/node_modules/@angular/common/common.d.ts')); + expect(dtsContents) + .toContain(`export declare class ${exportedName} implements ɵNgClassImpl`); + // And that ngcc's modifications to that class use the correct (exported) name + expect(dtsContents).toContain(`static ɵprov: ɵngcc0.ɵɵInjectableDef<${exportedName}>`); + }); + it('should add generic type for ModuleWithProviders and generate exports for private modules', () => { compileIntoApf('test-package', { diff --git a/packages/compiler-cli/src/ngtsc/annotations/src/directive.ts b/packages/compiler-cli/src/ngtsc/annotations/src/directive.ts index 64bf4167281..77f1918fb0b 100644 --- a/packages/compiler-cli/src/ngtsc/annotations/src/directive.ts +++ b/packages/compiler-cli/src/ngtsc/annotations/src/directive.ts @@ -20,7 +20,7 @@ import {AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerFl import {compileNgFactoryDefField} from './factory'; import {generateSetClassMetadataCall} from './metadata'; -import {findAngularDecorator, getConstructorDependencies, isAngularDecorator, makeDuplicateDeclarationError, readBaseClass, unwrapConstructorDependencies, unwrapExpression, unwrapForwardRef, validateConstructorDependencies, wrapFunctionExpressionsInParens} from './util'; +import {findAngularDecorator, getConstructorDependencies, isAngularDecorator, makeDuplicateDeclarationError, readBaseClass, unwrapConstructorDependencies, unwrapExpression, unwrapForwardRef, validateConstructorDependencies, wrapFunctionExpressionsInParens, wrapTypeReference} from './util'; const EMPTY_OBJECT: {[key: string]: string} = {}; const FIELD_DECORATORS = [ @@ -292,6 +292,9 @@ export function extractDirectiveMetadata( // Detect if the component inherits from another class const usesInheritance = reflector.hasBaseClass(clazz); + const type = wrapTypeReference(reflector, clazz); + const internalType = new WrappedNodeExpr(reflector.getInternalNameOfClass(clazz)); + const metadata: R3DirectiveMetadata = { name: clazz.name.text, deps: ctorDeps, host, @@ -300,9 +303,7 @@ export function extractDirectiveMetadata( }, inputs: {...inputsFromMeta, ...inputsFromFields}, outputs: {...outputsFromMeta, ...outputsFromFields}, queries, viewQueries, selector, - fullInheritance: !!(flags & HandlerFlags.FULL_INHERITANCE), - type: new WrappedNodeExpr(clazz.name), - internalType: new WrappedNodeExpr(reflector.getInternalNameOfClass(clazz)), + fullInheritance: !!(flags & HandlerFlags.FULL_INHERITANCE), type, internalType, typeArgumentCount: reflector.getGenericArityOfClass(clazz) || 0, typeSourceSpan: EMPTY_SOURCE_SPAN, usesInheritance, exportAs, providers }; diff --git a/packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts b/packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts index aba230e0927..93717607b5f 100644 --- a/packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts +++ b/packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts @@ -16,7 +16,7 @@ import {AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerPr import {compileNgFactoryDefField} from './factory'; import {generateSetClassMetadataCall} from './metadata'; -import {findAngularDecorator, getConstructorDependencies, getValidConstructorDependencies, isAngularCore, unwrapConstructorDependencies, unwrapForwardRef, validateConstructorDependencies} from './util'; +import {findAngularDecorator, getConstructorDependencies, getValidConstructorDependencies, isAngularCore, unwrapConstructorDependencies, unwrapForwardRef, validateConstructorDependencies, wrapTypeReference} from './util'; export interface InjectableHandlerData { meta: R3InjectableMetadata; @@ -130,7 +130,7 @@ function extractInjectableMetadata( clazz: ClassDeclaration, decorator: Decorator, reflector: ReflectionHost): R3InjectableMetadata { const name = clazz.name.text; - const type = new WrappedNodeExpr(clazz.name); + const type = wrapTypeReference(reflector, clazz); const internalType = new WrappedNodeExpr(reflector.getInternalNameOfClass(clazz)); const typeArgumentCount = reflector.getGenericArityOfClass(clazz) || 0; if (decorator.args === null) { diff --git a/packages/compiler-cli/src/ngtsc/annotations/src/ng_module.ts b/packages/compiler-cli/src/ngtsc/annotations/src/ng_module.ts index 9ba2c1186ef..7e43c198eec 100644 --- a/packages/compiler-cli/src/ngtsc/annotations/src/ng_module.ts +++ b/packages/compiler-cli/src/ngtsc/annotations/src/ng_module.ts @@ -22,7 +22,7 @@ import {getSourceFile} from '../../util/src/typescript'; import {generateSetClassMetadataCall} from './metadata'; import {ReferencesRegistry} from './references_registry'; -import {combineResolvers, findAngularDecorator, forwardRefResolver, getReferenceOriginForDiagnostics, getValidConstructorDependencies, isExpressionForwardReference, toR3Reference, unwrapExpression, wrapFunctionExpressionsInParens} from './util'; +import {combineResolvers, findAngularDecorator, forwardRefResolver, getReferenceOriginForDiagnostics, getValidConstructorDependencies, isExpressionForwardReference, toR3Reference, unwrapExpression, wrapFunctionExpressionsInParens, wrapTypeReference} from './util'; export interface NgModuleAnalysis { mod: R3NgModuleMetadata; @@ -220,10 +220,14 @@ export class NgModuleDecoratorHandler implements declarations.some(isForwardReference) || imports.some(isForwardReference) || exports.some(isForwardReference); + const type = wrapTypeReference(this.reflector, node); + const internalType = new WrappedNodeExpr(this.reflector.getInternalNameOfClass(node)); + const adjacentType = new WrappedNodeExpr(this.reflector.getAdjacentNameOfClass(node)); + const ngModuleDef: R3NgModuleMetadata = { - type: new WrappedNodeExpr(node.name), - internalType: new WrappedNodeExpr(this.reflector.getInternalNameOfClass(node)), - adjacentType: new WrappedNodeExpr(this.reflector.getAdjacentNameOfClass(node)), + type, + internalType, + adjacentType, bootstrap, declarations, exports, @@ -256,8 +260,8 @@ export class NgModuleDecoratorHandler implements const ngInjectorDef: R3InjectorMetadata = { name, - type: new WrappedNodeExpr(node.name), - internalType: new WrappedNodeExpr(this.reflector.getInternalNameOfClass(node)), + type, + internalType, deps: getValidConstructorDependencies( node, this.reflector, this.defaultImportRecorder, this.isCore), providers, diff --git a/packages/compiler-cli/src/ngtsc/annotations/src/pipe.ts b/packages/compiler-cli/src/ngtsc/annotations/src/pipe.ts index fa3b831d0b6..0210aba6633 100644 --- a/packages/compiler-cli/src/ngtsc/annotations/src/pipe.ts +++ b/packages/compiler-cli/src/ngtsc/annotations/src/pipe.ts @@ -19,7 +19,7 @@ import {AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerPr import {compileNgFactoryDefField} from './factory'; import {generateSetClassMetadataCall} from './metadata'; -import {findAngularDecorator, getValidConstructorDependencies, makeDuplicateDeclarationError, unwrapExpression} from './util'; +import {findAngularDecorator, getValidConstructorDependencies, makeDuplicateDeclarationError, unwrapExpression, wrapTypeReference} from './util'; export interface PipeHandlerData { meta: R3PipeMetadata; @@ -53,8 +53,9 @@ export class PipeDecoratorHandler implements DecoratorHandler): AnalysisOutput { const name = clazz.name.text; - const type = new WrappedNodeExpr(clazz.name); + const type = wrapTypeReference(this.reflector, clazz); const internalType = new WrappedNodeExpr(this.reflector.getInternalNameOfClass(clazz)); + if (decorator.args === null) { throw new FatalDiagnosticError( ErrorCode.DECORATOR_NOT_CALLED, Decorator.nodeForError(decorator), diff --git a/packages/compiler-cli/src/ngtsc/annotations/src/util.ts b/packages/compiler-cli/src/ngtsc/annotations/src/util.ts index d10ff5f2c15..989275dfbff 100644 --- a/packages/compiler-cli/src/ngtsc/annotations/src/util.ts +++ b/packages/compiler-cli/src/ngtsc/annotations/src/util.ts @@ -435,3 +435,18 @@ export function makeDuplicateDeclarationError( ErrorCode.NGMODULE_DECLARATION_NOT_UNIQUE, node.name, `The ${kind} '${node.name.text}' is declared by more than one NgModule.`, context); } + +/** + * Create an R3Reference for a class. + * + * The `value` is the exported declaration of the class from its source file. + * The `type` is an expression that would be used by ngcc in the typings (.d.ts) files. + */ +export function wrapTypeReference(reflector: ReflectionHost, clazz: ClassDeclaration): R3Reference { + const dtsClass = reflector.getDtsDeclaration(clazz); + const value = new WrappedNodeExpr(clazz.name); + const type = dtsClass !== null && isNamedClassDeclaration(dtsClass) ? + new WrappedNodeExpr(dtsClass.name) : + value; + return {value, type}; +} diff --git a/packages/compiler/src/injectable_compiler_2.ts b/packages/compiler/src/injectable_compiler_2.ts index 2fccf84c2b9..b3b0a2221b6 100644 --- a/packages/compiler/src/injectable_compiler_2.ts +++ b/packages/compiler/src/injectable_compiler_2.ts @@ -9,7 +9,7 @@ import {Identifiers} from './identifiers'; import * as o from './output/output_ast'; import {R3DependencyMetadata, R3FactoryDelegateType, R3FactoryMetadata, R3FactoryTarget, compileFactoryFunction} from './render3/r3_factory'; -import {mapToMapExpression, typeWithParameters} from './render3/util'; +import {R3Reference, mapToMapExpression, typeWithParameters} from './render3/util'; export interface InjectableDef { expression: o.Expression; @@ -19,7 +19,7 @@ export interface InjectableDef { export interface R3InjectableMetadata { name: string; - type: o.Expression; + type: R3Reference; internalType: o.Expression; typeArgumentCount: number; providedIn: o.Expression; @@ -69,7 +69,7 @@ export function compileInjectable(meta: R3InjectableMetadata): InjectableDef { result = compileFactoryFunction(factoryMeta); } else { result = delegateToFactory( - meta.type as o.WrappedNodeExpr, meta.useClass as o.WrappedNodeExpr); + meta.type.value as o.WrappedNodeExpr, meta.useClass as o.WrappedNodeExpr); } } else if (meta.useFactory !== undefined) { if (meta.userDeps !== undefined) { @@ -101,7 +101,7 @@ export function compileInjectable(meta: R3InjectableMetadata): InjectableDef { }); } else { result = delegateToFactory( - meta.type as o.WrappedNodeExpr, meta.internalType as o.WrappedNodeExpr); + meta.type.value as o.WrappedNodeExpr, meta.internalType as o.WrappedNodeExpr); } const token = meta.internalType; @@ -116,7 +116,7 @@ export function compileInjectable(meta: R3InjectableMetadata): InjectableDef { const expression = o.importExpr(Identifiers.ɵɵdefineInjectable).callFn([mapToMapExpression(injectableProps)]); const type = new o.ExpressionType(o.importExpr( - Identifiers.InjectableDef, [typeWithParameters(meta.type, meta.typeArgumentCount)])); + Identifiers.InjectableDef, [typeWithParameters(meta.type.type, meta.typeArgumentCount)])); return { expression, diff --git a/packages/compiler/src/jit_compiler_facade.ts b/packages/compiler/src/jit_compiler_facade.ts index acd7502e9bf..b1095f801d1 100644 --- a/packages/compiler/src/jit_compiler_facade.ts +++ b/packages/compiler/src/jit_compiler_facade.ts @@ -39,7 +39,7 @@ export class CompilerFacadeImpl implements CompilerFacade { any { const metadata: R3PipeMetadata = { name: facade.name, - type: new WrappedNodeExpr(facade.type), + type: wrapReference(facade.type), internalType: new WrappedNodeExpr(facade.type), typeArgumentCount: facade.typeArgumentCount, deps: convertR3DependencyMetadataArray(facade.deps), @@ -55,7 +55,7 @@ export class CompilerFacadeImpl implements CompilerFacade { facade: R3InjectableMetadataFacade): any { const {expression, statements} = compileInjectable({ name: facade.name, - type: new WrappedNodeExpr(facade.type), + type: wrapReference(facade.type), internalType: new WrappedNodeExpr(facade.type), typeArgumentCount: facade.typeArgumentCount, providedIn: computeProvidedIn(facade.providedIn), @@ -74,7 +74,7 @@ export class CompilerFacadeImpl implements CompilerFacade { facade: R3InjectorMetadataFacade): any { const meta: R3InjectorMetadata = { name: facade.name, - type: new WrappedNodeExpr(facade.type), + type: wrapReference(facade.type), internalType: new WrappedNodeExpr(facade.type), deps: convertR3DependencyMetadataArray(facade.deps), providers: new WrappedNodeExpr(facade.providers), @@ -88,7 +88,7 @@ export class CompilerFacadeImpl implements CompilerFacade { angularCoreEnv: CoreEnvironment, sourceMapUrl: string, facade: R3NgModuleMetadataFacade): any { const meta: R3NgModuleMetadata = { - type: new WrappedNodeExpr(facade.type), + type: wrapReference(facade.type), internalType: new WrappedNodeExpr(facade.type), adjacentType: new WrappedNodeExpr(facade.type), bootstrap: facade.bootstrap.map(wrapReference), @@ -163,7 +163,7 @@ export class CompilerFacadeImpl implements CompilerFacade { angularCoreEnv: CoreEnvironment, sourceMapUrl: string, meta: R3FactoryDefMetadataFacade) { const factoryRes = compileFactoryFunction({ name: meta.name, - type: new WrappedNodeExpr(meta.type), + type: wrapReference(meta.type), internalType: new WrappedNodeExpr(meta.type), typeArgumentCount: meta.typeArgumentCount, deps: convertR3DependencyMetadataArray(meta.deps), @@ -252,7 +252,7 @@ function convertDirectiveFacadeToMetadata(facade: R3DirectiveMetadataFacade): R3 return { ...facade as R3DirectiveMetadataFacadeNoPropAndWhitespace, typeSourceSpan: facade.typeSourceSpan, - type: new WrappedNodeExpr(facade.type), + type: wrapReference(facade.type), internalType: new WrappedNodeExpr(facade.type), deps: convertR3DependencyMetadataArray(facade.deps), host: extractHostBindings(facade.propMetadata, facade.typeSourceSpan, facade.host), diff --git a/packages/compiler/src/render3/r3_factory.ts b/packages/compiler/src/render3/r3_factory.ts index 7fe5eefc480..c3ede764a51 100644 --- a/packages/compiler/src/render3/r3_factory.ts +++ b/packages/compiler/src/render3/r3_factory.ts @@ -15,7 +15,7 @@ import * as o from '../output/output_ast'; import {Identifiers as R3} from '../render3/r3_identifiers'; import {OutputContext} from '../util'; -import {typeWithParameters} from './util'; +import {R3Reference, typeWithParameters} from './util'; import {unsupported} from './view/util'; @@ -32,7 +32,7 @@ export interface R3ConstructorFactoryMetadata { /** * An expression representing the interface type being constructed. */ - type: o.Expression; + type: R3Reference; /** * An expression representing the constructor type, intended for use within a class definition @@ -270,7 +270,7 @@ export function compileFactoryFunction(meta: R3FactoryMetadata): R3FactoryFn { `${meta.name}_Factory`), statements, type: o.expressionType( - o.importExpr(R3.FactoryDef, [typeWithParameters(meta.type, meta.typeArgumentCount)])) + o.importExpr(R3.FactoryDef, [typeWithParameters(meta.type.type, meta.typeArgumentCount)])) }; } diff --git a/packages/compiler/src/render3/r3_module_compiler.ts b/packages/compiler/src/render3/r3_module_compiler.ts index 37bb1b5add0..833a88bc533 100644 --- a/packages/compiler/src/render3/r3_module_compiler.ts +++ b/packages/compiler/src/render3/r3_module_compiler.ts @@ -29,7 +29,7 @@ export interface R3NgModuleMetadata { /** * An expression representing the module type being compiled. */ - type: o.Expression; + type: R3Reference; /** * An expression representing the module type being compiled, intended for use within a class @@ -160,7 +160,7 @@ export function compileNgModule(meta: R3NgModuleMetadata): R3NgModuleDef { const expression = o.importExpr(R3.defineNgModule).callFn([mapToMapExpression(definitionMap)]); const type = new o.ExpressionType(o.importExpr(R3.NgModuleDefWithMeta, [ - new o.ExpressionType(moduleType), tupleTypeOf(declarations), tupleTypeOf(imports), + new o.ExpressionType(moduleType.type), tupleTypeOf(declarations), tupleTypeOf(imports), tupleTypeOf(exports) ])); @@ -228,7 +228,7 @@ export interface R3InjectorDef { export interface R3InjectorMetadata { name: string; - type: o.Expression; + type: R3Reference; internalType: o.Expression; deps: R3DependencyMetadata[]|null; providers: o.Expression|null; @@ -259,7 +259,7 @@ export function compileInjector(meta: R3InjectorMetadata): R3InjectorDef { const expression = o.importExpr(R3.defineInjector).callFn([mapToMapExpression(definitionMap)]); const type = - new o.ExpressionType(o.importExpr(R3.InjectorDef, [new o.ExpressionType(meta.type)])); + new o.ExpressionType(o.importExpr(R3.InjectorDef, [new o.ExpressionType(meta.type.type)])); return {expression, type, statements: result.statements}; } diff --git a/packages/compiler/src/render3/r3_pipe_compiler.ts b/packages/compiler/src/render3/r3_pipe_compiler.ts index 03bfab91e16..703a001a48a 100644 --- a/packages/compiler/src/render3/r3_pipe_compiler.ts +++ b/packages/compiler/src/render3/r3_pipe_compiler.ts @@ -14,7 +14,7 @@ import {OutputContext, error} from '../util'; import {R3DependencyMetadata, R3FactoryTarget, compileFactoryFunction, dependenciesFromGlobalMetadata} from './r3_factory'; import {Identifiers as R3} from './r3_identifiers'; -import {typeWithParameters} from './util'; +import {R3Reference, typeWithParameters, wrapReference} from './util'; export interface R3PipeMetadata { /** @@ -25,7 +25,7 @@ export interface R3PipeMetadata { /** * An expression representing a reference to the pipe itself. */ - type: o.Expression; + type: R3Reference; /** * An expression representing the pipe being compiled, intended for use within a class definition @@ -64,14 +64,14 @@ export function compilePipeFromMetadata(metadata: R3PipeMetadata) { definitionMapValues.push({key: 'name', value: o.literal(metadata.pipeName), quoted: false}); // e.g. `type: MyPipe` - definitionMapValues.push({key: 'type', value: metadata.type, quoted: false}); + definitionMapValues.push({key: 'type', value: metadata.type.value, quoted: false}); // e.g. `pure: true` definitionMapValues.push({key: 'pure', value: o.literal(metadata.pure), quoted: false}); const expression = o.importExpr(R3.definePipe).callFn([o.literalMap(definitionMapValues)]); const type = new o.ExpressionType(o.importExpr(R3.PipeDefWithMeta, [ - typeWithParameters(metadata.type, metadata.typeArgumentCount), + typeWithParameters(metadata.type.type, metadata.typeArgumentCount), new o.ExpressionType(new o.LiteralExpr(metadata.pipeName)), ])); @@ -92,7 +92,7 @@ export function compilePipeFromRender2( const type = outputCtx.importExpr(pipe.type.reference); const metadata: R3PipeMetadata = { name, - type, + type: wrapReference(type), internalType: type, pipeName: pipe.name, typeArgumentCount: 0, diff --git a/packages/compiler/src/render3/util.ts b/packages/compiler/src/render3/util.ts index 1bfecc586f7..5572495dcff 100644 --- a/packages/compiler/src/render3/util.ts +++ b/packages/compiler/src/render3/util.ts @@ -98,3 +98,8 @@ export function jitOnlyGuardedExpression(expr: o.Expression): o.Expression { /* sourceSpan */ undefined, true); return new o.BinaryOperatorExpr(o.BinaryOperator.And, jitFlagUndefinedOrTrue, expr); } + +export function wrapReference(value: any): R3Reference { + const wrapped = new o.WrappedNodeExpr(value); + return {value: wrapped, type: wrapped}; +} \ No newline at end of file diff --git a/packages/compiler/src/render3/view/api.ts b/packages/compiler/src/render3/view/api.ts index 0372ede4b5b..5b38e0a6a67 100644 --- a/packages/compiler/src/render3/view/api.ts +++ b/packages/compiler/src/render3/view/api.ts @@ -12,6 +12,7 @@ import * as o from '../../output/output_ast'; import {ParseSourceSpan} from '../../parse_util'; import * as t from '../r3_ast'; import {R3DependencyMetadata} from '../r3_factory'; +import {R3Reference} from '../util'; /** @@ -26,7 +27,7 @@ export interface R3DirectiveMetadata { /** * An expression representing a reference to the directive itself. */ - type: o.Expression; + type: R3Reference; /** * An expression representing a reference to the directive being compiled, intended for use within diff --git a/packages/compiler/src/render3/view/compiler.ts b/packages/compiler/src/render3/view/compiler.ts index c4b7ca3f2a0..f0fa0e49445 100644 --- a/packages/compiler/src/render3/view/compiler.ts +++ b/packages/compiler/src/render3/view/compiler.ts @@ -481,7 +481,7 @@ function createTypeForDef(meta: R3DirectiveMetadata, typeBase: o.ExternalReferen const selectorForType = meta.selector !== null ? meta.selector.replace(/\n/g, '') : null; return o.expressionType(o.importExpr(typeBase, [ - typeWithParameters(meta.type, meta.typeArgumentCount), + typeWithParameters(meta.type.type, meta.typeArgumentCount), selectorForType !== null ? stringAsType(selectorForType) : o.NONE_TYPE, meta.exportAs !== null ? stringArrayAsType(meta.exportAs) : o.NONE_TYPE, stringMapAsType(meta.inputs),