/** * @license * Copyright Google LLC 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 */ (function (factory) { if (typeof module === "object" && typeof module.exports === "object") { var v = factory(require, exports); if (v !== undefined) module.exports = v; } else if (typeof define === "function" && define.amd) { define("@angular/compiler-cli/src/transformers/downlevel_decorators_transform", ["require", "exports", "tslib", "typescript", "@angular/compiler-cli/src/transformers/patch_alias_reference_resolution"], factory); } })(function (require, exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.getDownlevelDecoratorsTransform = void 0; var tslib_1 = require("tslib"); var ts = require("typescript"); var patch_alias_reference_resolution_1 = require("@angular/compiler-cli/src/transformers/patch_alias_reference_resolution"); /** * Whether a given decorator should be treated as an Angular decorator. * Either it's used in @angular/core, or it's imported from there. */ function isAngularDecorator(decorator, isCore) { return isCore || (decorator.import !== null && decorator.import.from === '@angular/core'); } /* ##################################################################### Code below has been extracted from the tsickle decorator downlevel transformer and a few local modifications have been applied: 1. Tsickle by default processed all decorators that had the `@Annotation` JSDoc. We modified the transform to only be concerned with known Angular decorators. 2. Tsickle by default added `@nocollapse` to all generated `ctorParameters` properties. We only do this when `annotateForClosureCompiler` is enabled. 3. Tsickle does not handle union types for dependency injection. i.e. if a injected type is denoted with `@Optional`, the actual type could be set to `T | null`. See: https://github.com/angular/angular-cli/commit/826803d0736b807867caff9f8903e508970ad5e4. 4. Tsickle relied on `emitDecoratorMetadata` to be set to `true`. This is due to a limitation in TypeScript transformers that never has been fixed. We were able to work around this limitation so that `emitDecoratorMetadata` doesn't need to be specified. See: `patchAliasReferenceResolution` for more details. Here is a link to the tsickle revision on which this transformer is based: https://github.com/angular/tsickle/blob/fae06becb1570f491806060d83f29f2d50c43cdd/src/decorator_downlevel_transformer.ts ##################################################################### */ /** * Creates the AST for the decorator field type annotation, which has the form * { type: Function, args?: any[] }[] */ function createDecoratorInvocationType() { var typeElements = []; typeElements.push(ts.createPropertySignature(undefined, 'type', undefined, ts.createTypeReferenceNode(ts.createIdentifier('Function'), undefined), undefined)); typeElements.push(ts.createPropertySignature(undefined, 'args', ts.createToken(ts.SyntaxKind.QuestionToken), ts.createArrayTypeNode(ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)), undefined)); return ts.createArrayTypeNode(ts.createTypeLiteralNode(typeElements)); } /** * Extracts the type of the decorator (the function or expression invoked), as well as all the * arguments passed to the decorator. Returns an AST with the form: * * // For @decorator(arg1, arg2) * { type: decorator, args: [arg1, arg2] } */ function extractMetadataFromSingleDecorator(decorator, diagnostics) { var e_1, _a; var metadataProperties = []; var expr = decorator.expression; switch (expr.kind) { case ts.SyntaxKind.Identifier: // The decorator was a plain @Foo. metadataProperties.push(ts.createPropertyAssignment('type', expr)); break; case ts.SyntaxKind.CallExpression: // The decorator was a call, like @Foo(bar). var call = expr; metadataProperties.push(ts.createPropertyAssignment('type', call.expression)); if (call.arguments.length) { var args = []; try { for (var _b = tslib_1.__values(call.arguments), _c = _b.next(); !_c.done; _c = _b.next()) { var arg = _c.value; args.push(arg); } } catch (e_1_1) { e_1 = { error: e_1_1 }; } finally { try { if (_c && !_c.done && (_a = _b.return)) _a.call(_b); } finally { if (e_1) throw e_1.error; } } var argsArrayLiteral = ts.createArrayLiteral(args); argsArrayLiteral.elements.hasTrailingComma = true; metadataProperties.push(ts.createPropertyAssignment('args', argsArrayLiteral)); } break; default: diagnostics.push({ file: decorator.getSourceFile(), start: decorator.getStart(), length: decorator.getEnd() - decorator.getStart(), messageText: ts.SyntaxKind[decorator.kind] + " not implemented in gathering decorator metadata.", category: ts.DiagnosticCategory.Error, code: 0, }); break; } return ts.createObjectLiteral(metadataProperties); } /** * Takes a list of decorator metadata object ASTs and produces an AST for a * static class property of an array of those metadata objects. */ function createDecoratorClassProperty(decoratorList) { var modifier = ts.createToken(ts.SyntaxKind.StaticKeyword); var type = createDecoratorInvocationType(); var initializer = ts.createArrayLiteral(decoratorList, true); // NB: the .decorators property does not get a @nocollapse property. There is // no good reason why - it means .decorators is not runtime accessible if you // compile with collapse properties, whereas propDecorators is, which doesn't // follow any stringent logic. However this has been the case previously, and // adding it back in leads to substantial code size increases as Closure fails // to tree shake these props without @nocollapse. return ts.createProperty(undefined, [modifier], 'decorators', undefined, type, initializer); } /** * Creates the AST for the 'ctorParameters' field type annotation: * () => ({ type: any, decorators?: {type: Function, args?: any[]}[] }|null)[] */ function createCtorParametersClassPropertyType() { // Sorry about this. Try reading just the string literals below. var typeElements = []; typeElements.push(ts.createPropertySignature(undefined, 'type', undefined, ts.createTypeReferenceNode(ts.createIdentifier('any'), undefined), undefined)); typeElements.push(ts.createPropertySignature(undefined, 'decorators', ts.createToken(ts.SyntaxKind.QuestionToken), ts.createArrayTypeNode(ts.createTypeLiteralNode([ ts.createPropertySignature(undefined, 'type', undefined, ts.createTypeReferenceNode(ts.createIdentifier('Function'), undefined), undefined), ts.createPropertySignature(undefined, 'args', ts.createToken(ts.SyntaxKind.QuestionToken), ts.createArrayTypeNode(ts.createTypeReferenceNode(ts.createIdentifier('any'), undefined)), undefined), ])), undefined)); // TODO(alan-agius4): Remove when we no longer support TS 3.9 var nullLiteral = ts.createNull(); var nullType = ts.versionMajorMinor.charAt(0) === '4' ? ts.createLiteralTypeNode(nullLiteral) : nullLiteral; return ts.createFunctionTypeNode(undefined, [], ts.createArrayTypeNode(ts.createUnionTypeNode([ ts.createTypeLiteralNode(typeElements), nullType, ]))); } /** * Sets a Closure \@nocollapse synthetic comment on the given node. This prevents Closure Compiler * from collapsing the apparently static property, which would make it impossible to find for code * trying to detect it at runtime. */ function addNoCollapseComment(n) { ts.setSyntheticLeadingComments(n, [{ kind: ts.SyntaxKind.MultiLineCommentTrivia, text: '* @nocollapse ', pos: -1, end: -1, hasTrailingNewLine: true }]); } /** * createCtorParametersClassProperty creates a static 'ctorParameters' property containing * downleveled decorator information. * * The property contains an arrow function that returns an array of object literals of the shape: * static ctorParameters = () => [{ * type: SomeClass|undefined, // the type of the param that's decorated, if it's a value. * decorators: [{ * type: DecoratorFn, // the type of the decorator that's invoked. * args: [ARGS], // the arguments passed to the decorator. * }] * }]; */ function createCtorParametersClassProperty(diagnostics, entityNameToExpression, ctorParameters, isClosureCompilerEnabled) { var e_2, _a, e_3, _b; var params = []; try { for (var ctorParameters_1 = tslib_1.__values(ctorParameters), ctorParameters_1_1 = ctorParameters_1.next(); !ctorParameters_1_1.done; ctorParameters_1_1 = ctorParameters_1.next()) { var ctorParam = ctorParameters_1_1.value; if (!ctorParam.type && ctorParam.decorators.length === 0) { params.push(ts.createNull()); continue; } var paramType = ctorParam.type ? typeReferenceToExpression(entityNameToExpression, ctorParam.type) : undefined; var members = [ts.createPropertyAssignment('type', paramType || ts.createIdentifier('undefined'))]; var decorators = []; try { for (var _c = (e_3 = void 0, tslib_1.__values(ctorParam.decorators)), _d = _c.next(); !_d.done; _d = _c.next()) { var deco = _d.value; decorators.push(extractMetadataFromSingleDecorator(deco, diagnostics)); } } catch (e_3_1) { e_3 = { error: e_3_1 }; } finally { try { if (_d && !_d.done && (_b = _c.return)) _b.call(_c); } finally { if (e_3) throw e_3.error; } } if (decorators.length) { members.push(ts.createPropertyAssignment('decorators', ts.createArrayLiteral(decorators))); } params.push(ts.createObjectLiteral(members)); } } catch (e_2_1) { e_2 = { error: e_2_1 }; } finally { try { if (ctorParameters_1_1 && !ctorParameters_1_1.done && (_a = ctorParameters_1.return)) _a.call(ctorParameters_1); } finally { if (e_2) throw e_2.error; } } var initializer = ts.createArrowFunction(undefined, undefined, [], undefined, ts.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.createArrayLiteral(params, true)); var type = createCtorParametersClassPropertyType(); var ctorProp = ts.createProperty(undefined, [ts.createToken(ts.SyntaxKind.StaticKeyword)], 'ctorParameters', undefined, type, initializer); if (isClosureCompilerEnabled) { addNoCollapseComment(ctorProp); } return ctorProp; } /** * createPropDecoratorsClassProperty creates a static 'propDecorators' property containing type * information for every property that has a decorator applied. * * static propDecorators: {[key: string]: {type: Function, args?: any[]}[]} = { * propA: [{type: MyDecorator, args: [1, 2]}, ...], * ... * }; */ function createPropDecoratorsClassProperty(diagnostics, properties) { var e_4, _a; // `static propDecorators: {[key: string]: ` + {type: Function, args?: any[]}[] + `} = {\n`); var entries = []; try { for (var _b = tslib_1.__values(properties.entries()), _c = _b.next(); !_c.done; _c = _b.next()) { var _d = tslib_1.__read(_c.value, 2), name = _d[0], decorators = _d[1]; entries.push(ts.createPropertyAssignment(name, ts.createArrayLiteral(decorators.map(function (deco) { return extractMetadataFromSingleDecorator(deco, diagnostics); })))); } } catch (e_4_1) { e_4 = { error: e_4_1 }; } finally { try { if (_c && !_c.done && (_a = _b.return)) _a.call(_b); } finally { if (e_4) throw e_4.error; } } var initializer = ts.createObjectLiteral(entries, true); var type = ts.createTypeLiteralNode([ts.createIndexSignature(undefined, undefined, [ts.createParameter(undefined, undefined, undefined, 'key', undefined, ts.createTypeReferenceNode('string', undefined), undefined)], createDecoratorInvocationType())]); return ts.createProperty(undefined, [ts.createToken(ts.SyntaxKind.StaticKeyword)], 'propDecorators', undefined, type, initializer); } /** * Returns an expression representing the (potentially) value part for the given node. * * This is a partial re-implementation of TypeScript's serializeTypeReferenceNode. This is a * workaround for https://github.com/Microsoft/TypeScript/issues/17516 (serializeTypeReferenceNode * not being exposed). In practice this implementation is sufficient for Angular's use of type * metadata. */ function typeReferenceToExpression(entityNameToExpression, node) { var kind = node.kind; if (ts.isLiteralTypeNode(node)) { // Treat literal types like their base type (boolean, string, number). kind = node.literal.kind; } switch (kind) { case ts.SyntaxKind.FunctionType: case ts.SyntaxKind.ConstructorType: return ts.createIdentifier('Function'); case ts.SyntaxKind.ArrayType: case ts.SyntaxKind.TupleType: return ts.createIdentifier('Array'); case ts.SyntaxKind.TypePredicate: case ts.SyntaxKind.TrueKeyword: case ts.SyntaxKind.FalseKeyword: case ts.SyntaxKind.BooleanKeyword: return ts.createIdentifier('Boolean'); case ts.SyntaxKind.StringLiteral: case ts.SyntaxKind.StringKeyword: return ts.createIdentifier('String'); case ts.SyntaxKind.ObjectKeyword: return ts.createIdentifier('Object'); case ts.SyntaxKind.NumberKeyword: case ts.SyntaxKind.NumericLiteral: return ts.createIdentifier('Number'); case ts.SyntaxKind.TypeReference: var typeRef = node; // Ignore any generic types, just return the base type. return entityNameToExpression(typeRef.typeName); case ts.SyntaxKind.UnionType: // TODO(alan-agius4): remove `t.kind !== ts.SyntaxKind.NullKeyword` when // TS 3.9 support is dropped. In TS 4.0 NullKeyword is a child of LiteralType. var childTypeNodes = node .types.filter(function (t) { return t.kind !== ts.SyntaxKind.NullKeyword && !(ts.isLiteralTypeNode(t) && t.literal.kind === ts.SyntaxKind.NullKeyword); }); return childTypeNodes.length === 1 ? typeReferenceToExpression(entityNameToExpression, childTypeNodes[0]) : undefined; default: return undefined; } } /** * Checks whether a given symbol refers to a value that exists at runtime (as distinct from a type). * * Expands aliases, which is important for the case where * import * as x from 'some-module'; * and x is now a value (the module object). */ function symbolIsRuntimeValue(typeChecker, symbol) { if (symbol.flags & ts.SymbolFlags.Alias) { symbol = typeChecker.getAliasedSymbol(symbol); } // Note that const enums are a special case, because // while they have a value, they don't exist at runtime. return (symbol.flags & ts.SymbolFlags.Value & ts.SymbolFlags.ConstEnumExcludes) !== 0; } /** * Gets a transformer for downleveling Angular decorators. * @param typeChecker Reference to the program's type checker. * @param host Reflection host that is used for determining decorators. * @param diagnostics List which will be populated with diagnostics if any. * @param isCore Whether the current TypeScript program is for the `@angular/core` package. * @param isClosureCompilerEnabled Whether closure annotations need to be added where needed. * @param skipClassDecorators Whether class decorators should be skipped from downleveling. * This is useful for JIT mode where class decorators should be preserved as they could rely * on immediate execution. e.g. downleveling `@Injectable` means that the injectable factory * is not created, and injecting the token will not work. If this decorator would not be * downleveled, the `Injectable` decorator will execute immediately on file load, and * Angular will generate the corresponding injectable factory. */ function getDownlevelDecoratorsTransform(typeChecker, host, diagnostics, isCore, isClosureCompilerEnabled, skipClassDecorators) { return function (context) { var referencedParameterTypes = new Set(); /** * Converts an EntityName (from a type annotation) to an expression (accessing a value). * * For a given qualified name, this walks depth first to find the leftmost identifier, * and then converts the path into a property access that can be used as expression. */ function entityNameToExpression(name) { var symbol = typeChecker.getSymbolAtLocation(name); // Check if the entity name references a symbol that is an actual value. If it is not, it // cannot be referenced by an expression, so return undefined. if (!symbol || !symbolIsRuntimeValue(typeChecker, symbol) || !symbol.declarations || symbol.declarations.length === 0) { return undefined; } // If we deal with a qualified name, build up a property access expression // that could be used in the JavaScript output. if (ts.isQualifiedName(name)) { var containerExpr = entityNameToExpression(name.left); if (containerExpr === undefined) { return undefined; } return ts.createPropertyAccess(containerExpr, name.right); } var decl = symbol.declarations[0]; // If the given entity name has been resolved to an alias import declaration, // ensure that the alias declaration is not elided by TypeScript, and use its // name identifier to reference it at runtime. if (patch_alias_reference_resolution_1.isAliasImportDeclaration(decl)) { referencedParameterTypes.add(decl); // If the entity name resolves to an alias import declaration, we reference the // entity based on the alias import name. This ensures that TypeScript properly // resolves the link to the import. Cloning the original entity name identifier // could lead to an incorrect resolution at local scope. e.g. Consider the following // snippet: `constructor(Dep: Dep) {}`. In such a case, the local `Dep` identifier // would resolve to the actual parameter name, and not to the desired import. // This happens because the entity name identifier symbol is internally considered // as type-only and therefore TypeScript tries to resolve it as value manually. // We can help TypeScript and avoid this non-reliable resolution by using an identifier // that is not type-only and is directly linked to the import alias declaration. if (decl.name !== undefined) { return ts.getMutableClone(decl.name); } } // Clone the original entity name identifier so that it can be used to reference // its value at runtime. This is used when the identifier is resolving to a file // local declaration (otherwise it would resolve to an alias import declaration). return ts.getMutableClone(name); } /** * Transforms a class element. Returns a three tuple of name, transformed element, and * decorators found. Returns an undefined name if there are no decorators to lower on the * element, or the element has an exotic name. */ function transformClassElement(element) { var e_5, _a; element = ts.visitEachChild(element, decoratorDownlevelVisitor, context); var decoratorsToKeep = []; var toLower = []; var decorators = host.getDecoratorsOfDeclaration(element) || []; try { for (var decorators_1 = tslib_1.__values(decorators), decorators_1_1 = decorators_1.next(); !decorators_1_1.done; decorators_1_1 = decorators_1.next()) { var decorator = decorators_1_1.value; // We only deal with concrete nodes in TypeScript sources, so we don't // need to handle synthetically created decorators. var decoratorNode = decorator.node; if (!isAngularDecorator(decorator, isCore)) { decoratorsToKeep.push(decoratorNode); continue; } toLower.push(decoratorNode); } } catch (e_5_1) { e_5 = { error: e_5_1 }; } finally { try { if (decorators_1_1 && !decorators_1_1.done && (_a = decorators_1.return)) _a.call(decorators_1); } finally { if (e_5) throw e_5.error; } } if (!toLower.length) return [undefined, element, []]; if (!element.name || !ts.isIdentifier(element.name)) { // Method has a weird name, e.g. // [Symbol.foo]() {...} diagnostics.push({ file: element.getSourceFile(), start: element.getStart(), length: element.getEnd() - element.getStart(), messageText: "Cannot process decorators for class element with non-analyzable name.", category: ts.DiagnosticCategory.Error, code: 0, }); return [undefined, element, []]; } var name = element.name.text; var mutable = ts.getMutableClone(element); mutable.decorators = decoratorsToKeep.length ? ts.setTextRange(ts.createNodeArray(decoratorsToKeep), mutable.decorators) : undefined; return [name, mutable, toLower]; } /** * Transforms a constructor. Returns the transformed constructor and the list of parameter * information collected, consisting of decorators and optional type. */ function transformConstructor(ctor) { var e_6, _a, e_7, _b; ctor = ts.visitEachChild(ctor, decoratorDownlevelVisitor, context); var newParameters = []; var oldParameters = ts.visitParameterList(ctor.parameters, decoratorDownlevelVisitor, context); var parametersInfo = []; try { for (var oldParameters_1 = tslib_1.__values(oldParameters), oldParameters_1_1 = oldParameters_1.next(); !oldParameters_1_1.done; oldParameters_1_1 = oldParameters_1.next()) { var param = oldParameters_1_1.value; var decoratorsToKeep = []; var paramInfo = { decorators: [], type: null }; var decorators = host.getDecoratorsOfDeclaration(param) || []; try { for (var decorators_2 = (e_7 = void 0, tslib_1.__values(decorators)), decorators_2_1 = decorators_2.next(); !decorators_2_1.done; decorators_2_1 = decorators_2.next()) { var decorator = decorators_2_1.value; // We only deal with concrete nodes in TypeScript sources, so we don't // need to handle synthetically created decorators. var decoratorNode = decorator.node; if (!isAngularDecorator(decorator, isCore)) { decoratorsToKeep.push(decoratorNode); continue; } paramInfo.decorators.push(decoratorNode); } } catch (e_7_1) { e_7 = { error: e_7_1 }; } finally { try { if (decorators_2_1 && !decorators_2_1.done && (_b = decorators_2.return)) _b.call(decorators_2); } finally { if (e_7) throw e_7.error; } } if (param.type) { // param has a type provided, e.g. "foo: Bar". // The type will be emitted as a value expression in entityNameToExpression, which takes // care not to emit anything for types that cannot be expressed as a value (e.g. // interfaces). paramInfo.type = param.type; } parametersInfo.push(paramInfo); var newParam = ts.updateParameter(param, // Must pass 'undefined' to avoid emitting decorator metadata. decoratorsToKeep.length ? decoratorsToKeep : undefined, param.modifiers, param.dotDotDotToken, param.name, param.questionToken, param.type, param.initializer); newParameters.push(newParam); } } catch (e_6_1) { e_6 = { error: e_6_1 }; } finally { try { if (oldParameters_1_1 && !oldParameters_1_1.done && (_a = oldParameters_1.return)) _a.call(oldParameters_1); } finally { if (e_6) throw e_6.error; } } var updated = ts.updateConstructor(ctor, ctor.decorators, ctor.modifiers, newParameters, ts.visitFunctionBody(ctor.body, decoratorDownlevelVisitor, context)); return [updated, parametersInfo]; } /** * Transforms a single class declaration: * - dispatches to strip decorators on members * - converts decorators on the class to annotations * - creates a ctorParameters property * - creates a propDecorators property */ function transformClassDeclaration(classDecl) { var e_8, _a, e_9, _b; classDecl = ts.getMutableClone(classDecl); var newMembers = []; var decoratedProperties = new Map(); var classParameters = null; try { for (var _c = tslib_1.__values(classDecl.members), _d = _c.next(); !_d.done; _d = _c.next()) { var member = _d.value; switch (member.kind) { case ts.SyntaxKind.PropertyDeclaration: case ts.SyntaxKind.GetAccessor: case ts.SyntaxKind.SetAccessor: case ts.SyntaxKind.MethodDeclaration: { var _e = tslib_1.__read(transformClassElement(member), 3), name = _e[0], newMember = _e[1], decorators_4 = _e[2]; newMembers.push(newMember); if (name) decoratedProperties.set(name, decorators_4); continue; } case ts.SyntaxKind.Constructor: { var ctor = member; if (!ctor.body) break; var _f = tslib_1.__read(transformConstructor(member), 2), newMember = _f[0], parametersInfo = _f[1]; classParameters = parametersInfo; newMembers.push(newMember); continue; } default: break; } newMembers.push(ts.visitEachChild(member, decoratorDownlevelVisitor, context)); } } catch (e_8_1) { e_8 = { error: e_8_1 }; } finally { try { if (_d && !_d.done && (_a = _c.return)) _a.call(_c); } finally { if (e_8) throw e_8.error; } } var decorators = host.getDecoratorsOfDeclaration(classDecl) || []; var hasAngularDecorator = false; var decoratorsToLower = []; var decoratorsToKeep = []; try { for (var decorators_3 = tslib_1.__values(decorators), decorators_3_1 = decorators_3.next(); !decorators_3_1.done; decorators_3_1 = decorators_3.next()) { var decorator = decorators_3_1.value; // We only deal with concrete nodes in TypeScript sources, so we don't // need to handle synthetically created decorators. var decoratorNode = decorator.node; var isNgDecorator = isAngularDecorator(decorator, isCore); // Keep track if we come across an Angular class decorator. This is used // for to determine whether constructor parameters should be captured or not. if (isNgDecorator) { hasAngularDecorator = true; } if (isNgDecorator && !skipClassDecorators) { decoratorsToLower.push(extractMetadataFromSingleDecorator(decoratorNode, diagnostics)); } else { decoratorsToKeep.push(decoratorNode); } } } catch (e_9_1) { e_9 = { error: e_9_1 }; } finally { try { if (decorators_3_1 && !decorators_3_1.done && (_b = decorators_3.return)) _b.call(decorators_3); } finally { if (e_9) throw e_9.error; } } if (decoratorsToLower.length) { newMembers.push(createDecoratorClassProperty(decoratorsToLower)); } if (classParameters) { if (hasAngularDecorator || classParameters.some(function (p) { return !!p.decorators.length; })) { // Capture constructor parameters if the class has Angular decorator applied, // or if any of the parameters has decorators applied directly. newMembers.push(createCtorParametersClassProperty(diagnostics, entityNameToExpression, classParameters, isClosureCompilerEnabled)); } } if (decoratedProperties.size) { newMembers.push(createPropDecoratorsClassProperty(diagnostics, decoratedProperties)); } var members = ts.setTextRange(ts.createNodeArray(newMembers, classDecl.members.hasTrailingComma), classDecl.members); return ts.updateClassDeclaration(classDecl, decoratorsToKeep.length ? decoratorsToKeep : undefined, classDecl.modifiers, classDecl.name, classDecl.typeParameters, classDecl.heritageClauses, members); } /** * Transformer visitor that looks for Angular decorators and replaces them with * downleveled static properties. Also collects constructor type metadata for * class declaration that are decorated with an Angular decorator. */ function decoratorDownlevelVisitor(node) { if (ts.isClassDeclaration(node)) { return transformClassDeclaration(node); } return ts.visitEachChild(node, decoratorDownlevelVisitor, context); } return function (sf) { // Ensure that referenced type symbols are not elided by TypeScript. Imports for // such parameter type symbols previously could be type-only, but now might be also // used in the `ctorParameters` static property as a value. We want to make sure // that TypeScript does not elide imports for such type references. Read more // about this in the description for `patchAliasReferenceResolution`. patch_alias_reference_resolution_1.patchAliasReferenceResolutionOrDie(context, referencedParameterTypes); // Downlevel decorators and constructor parameter types. We will keep track of all // referenced constructor parameter types so that we can instruct TypeScript to // not elide their imports if they previously were only type-only. return ts.visitEachChild(sf, decoratorDownlevelVisitor, context); }; }; } exports.getDownlevelDecoratorsTransform = getDownlevelDecoratorsTransform; }); //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"downlevel_decorators_transform.js","sourceRoot":"","sources":["../../../../../../../packages/compiler-cli/src/transformers/downlevel_decorators_transform.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;;;IAEH,+BAAiC;IAEjC,4HAAgH;IAEhH;;;OAGG;IACH,SAAS,kBAAkB,CAAC,SAAoB,EAAE,MAAe;QAC/D,OAAO,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,IAAI,IAAI,SAAS,CAAC,MAAM,CAAC,IAAI,KAAK,eAAe,CAAC,CAAC;IAC5F,CAAC;IAED;;;;;;;;;;;;;;;;;;;;MAoBE;IAEF;;;OAGG;IACH,SAAS,6BAA6B;QACpC,IAAM,YAAY,GAAqB,EAAE,CAAC;QAC1C,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,uBAAuB,CACxC,SAAS,EAAE,MAAM,EAAE,SAAS,EAC5B,EAAE,CAAC,uBAAuB,CAAC,EAAE,CAAC,gBAAgB,CAAC,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;QACxF,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,uBAAuB,CACxC,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EAC9D,EAAE,CAAC,mBAAmB,CAAC,EAAE,CAAC,qBAAqB,CAAC,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;QAC5F,OAAO,EAAE,CAAC,mBAAmB,CAAC,EAAE,CAAC,qBAAqB,CAAC,YAAY,CAAC,CAAC,CAAC;IACxE,CAAC;IAED;;;;;;OAMG;IACH,SAAS,kCAAkC,CACvC,SAAuB,EAAE,WAA4B;;QACvD,IAAM,kBAAkB,GAAkC,EAAE,CAAC;QAC7D,IAAM,IAAI,GAAG,SAAS,CAAC,UAAU,CAAC;QAClC,QAAQ,IAAI,CAAC,IAAI,EAAE;YACjB,KAAK,EAAE,CAAC,UAAU,CAAC,UAAU;gBAC3B,kCAAkC;gBAClC,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,wBAAwB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;gBACnE,MAAM;YACR,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc;gBAC/B,4CAA4C;gBAC5C,IAAM,IAAI,GAAG,IAAyB,CAAC;gBACvC,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,wBAAwB,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;gBAC9E,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE;oBACzB,IAAM,IAAI,GAAoB,EAAE,CAAC;;wBACjC,KAAkB,IAAA,KAAA,iBAAA,IAAI,CAAC,SAAS,CAAA,gBAAA,4BAAE;4BAA7B,IAAM,GAAG,WAAA;4BACZ,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;yBAChB;;;;;;;;;oBACD,IAAM,gBAAgB,GAAG,EAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;oBACrD,gBAAgB,CAAC,QAAQ,CAAC,gBAAgB,GAAG,IAAI,CAAC;oBAClD,kBAAkB,CAAC,IAAI,CAAC,EAAE,CAAC,wBAAwB,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;iBAChF;gBACD,MAAM;YACR;gBACE,WAAW,CAAC,IAAI,CAAC;oBACf,IAAI,EAAE,SAAS,CAAC,aAAa,EAAE;oBAC/B,KAAK,EAAE,SAAS,CAAC,QAAQ,EAAE;oBAC3B,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,GAAG,SAAS,CAAC,QAAQ,EAAE;oBACjD,WAAW,EACJ,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,sDAAmD;oBACvF,QAAQ,EAAE,EAAE,CAAC,kBAAkB,CAAC,KAAK;oBACrC,IAAI,EAAE,CAAC;iBACR,CAAC,CAAC;gBACH,MAAM;SACT;QACD,OAAO,EAAE,CAAC,mBAAmB,CAAC,kBAAkB,CAAC,CAAC;IACpD,CAAC;IAED;;;OAGG;IACH,SAAS,4BAA4B,CAAC,aAA2C;QAC/E,IAAM,QAAQ,GAAG,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;QAC7D,IAAM,IAAI,GAAG,6BAA6B,EAAE,CAAC;QAC7C,IAAM,WAAW,GAAG,EAAE,CAAC,kBAAkB,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;QAC/D,6EAA6E;QAC7E,6EAA6E;QAC7E,6EAA6E;QAC7E,6EAA6E;QAC7E,8EAA8E;QAC9E,iDAAiD;QACjD,OAAO,EAAE,CAAC,cAAc,CAAC,SAAS,EAAE,CAAC,QAAQ,CAAC,EAAE,YAAY,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;IAC9F,CAAC;IAED;;;OAGG;IACH,SAAS,qCAAqC;QAC5C,gEAAgE;QAChE,IAAM,YAAY,GAAqB,EAAE,CAAC;QAC1C,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,uBAAuB,CACxC,SAAS,EAAE,MAAM,EAAE,SAAS,EAC5B,EAAE,CAAC,uBAAuB,CAAC,EAAE,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;QACnF,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,uBAAuB,CACxC,SAAS,EAAE,YAAY,EAAE,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EACpE,EAAE,CAAC,mBAAmB,CAAC,EAAE,CAAC,qBAAqB,CAAC;YAC9C,EAAE,CAAC,uBAAuB,CACtB,SAAS,EAAE,MAAM,EAAE,SAAS,EAC5B,EAAE,CAAC,uBAAuB,CAAC,EAAE,CAAC,gBAAgB,CAAC,UAAU,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC;YACtF,EAAE,CAAC,uBAAuB,CACtB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,EAC9D,EAAE,CAAC,mBAAmB,CAClB,EAAE,CAAC,uBAAuB,CAAC,EAAE,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC,EACtE,SAAS,CAAC;SACf,CAAC,CAAC,EACH,SAAS,CAAC,CAAC,CAAC;QAEhB,6DAA6D;QAC7D,IAAM,WAAW,GAAG,EAAE,CAAC,UAAU,EAAS,CAAC;QAC3C,IAAM,QAAQ,GAAG,EAAE,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC;YACrD,EAAE,CAAC,qBAAqB,CAAC,WAAkB,CAAC,CAAC,CAAC;YAC9C,WAAW,CAAC;QAChB,OAAO,EAAE,CAAC,sBAAsB,CAAC,SAAS,EAAE,EAAE,EAAE,EAAE,CAAC,mBAAmB,CAAC,EAAE,CAAC,mBAAmB,CAAC;YAC5F,EAAE,CAAC,qBAAqB,CAAC,YAAY,CAAC;YACtC,QAAQ;SACT,CAAC,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;;;OAIG;IACH,SAAS,oBAAoB,CAAC,CAAU;QACtC,EAAE,CAAC,2BAA2B,CAAC,CAAC,EAAE,CAAC;gBACF,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,sBAAsB;gBAC1C,IAAI,EAAE,gBAAgB;gBACtB,GAAG,EAAE,CAAC,CAAC;gBACP,GAAG,EAAE,CAAC,CAAC;gBACP,kBAAkB,EAAE,IAAI;aACzB,CAAC,CAAC,CAAC;IACrC,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,SAAS,iCAAiC,CACtC,WAA4B,EAC5B,sBAAuE,EACvE,cAAyC,EACzC,wBAAiC;;QACnC,IAAM,MAAM,GAAoB,EAAE,CAAC;;YAEnC,KAAwB,IAAA,mBAAA,iBAAA,cAAc,CAAA,8CAAA,0EAAE;gBAAnC,IAAM,SAAS,2BAAA;gBAClB,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,SAAS,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;oBACxD,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC,CAAC;oBAC7B,SAAS;iBACV;gBAED,IAAM,SAAS,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;oBAC9B,yBAAyB,CAAC,sBAAsB,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;oBACnE,SAAS,CAAC;gBACd,IAAM,OAAO,GACT,CAAC,EAAE,CAAC,wBAAwB,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;gBAEzF,IAAM,UAAU,GAAiC,EAAE,CAAC;;oBACpD,KAAmB,IAAA,oBAAA,iBAAA,SAAS,CAAC,UAAU,CAAA,CAAA,gBAAA,4BAAE;wBAApC,IAAM,IAAI,WAAA;wBACb,UAAU,CAAC,IAAI,CAAC,kCAAkC,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC;qBACxE;;;;;;;;;gBACD,IAAI,UAAU,CAAC,MAAM,EAAE;oBACrB,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,wBAAwB,CAAC,YAAY,EAAE,EAAE,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;iBAC5F;gBACD,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC,CAAC;aAC9C;;;;;;;;;QAED,IAAM,WAAW,GAAG,EAAE,CAAC,mBAAmB,CACtC,SAAS,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,CAAC,sBAAsB,CAAC,EACzF,EAAE,CAAC,kBAAkB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;QACzC,IAAM,IAAI,GAAG,qCAAqC,EAAE,CAAC;QACrD,IAAM,QAAQ,GAAG,EAAE,CAAC,cAAc,CAC9B,SAAS,EAAE,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC,EAAE,gBAAgB,EAAE,SAAS,EAAE,IAAI,EAC3F,WAAW,CAAC,CAAC;QACjB,IAAI,wBAAwB,EAAE;YAC5B,oBAAoB,CAAC,QAAQ,CAAC,CAAC;SAChC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;;;;;;OAQG;IACH,SAAS,iCAAiC,CACtC,WAA4B,EAAE,UAAuC;;QACvE,8FAA8F;QAC9F,IAAM,OAAO,GAAkC,EAAE,CAAC;;YAClD,KAAiC,IAAA,KAAA,iBAAA,UAAU,CAAC,OAAO,EAAE,CAAA,gBAAA,4BAAE;gBAA5C,IAAA,KAAA,2BAAkB,EAAjB,IAAI,QAAA,EAAE,UAAU,QAAA;gBAC1B,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,wBAAwB,CACpC,IAAI,EACJ,EAAE,CAAC,kBAAkB,CACjB,UAAU,CAAC,GAAG,CAAC,UAAA,IAAI,IAAI,OAAA,kCAAkC,CAAC,IAAI,EAAE,WAAW,CAAC,EAArD,CAAqD,CAAC,CAAC,CAAC,CAAC,CAAC;aAC1F;;;;;;;;;QACD,IAAM,WAAW,GAAG,EAAE,CAAC,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAC1D,IAAM,IAAI,GAAG,EAAE,CAAC,qBAAqB,CAAC,CAAC,EAAE,CAAC,oBAAoB,CAC1D,SAAS,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC,eAAe,CACf,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EACjD,EAAE,CAAC,uBAAuB,CAAC,QAAQ,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,CAAC,EACtF,6BAA6B,EAAE,CAAC,CAAC,CAAC,CAAC;QACvC,OAAO,EAAE,CAAC,cAAc,CACpB,SAAS,EAAE,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC,EAAE,gBAAgB,EAAE,SAAS,EAAE,IAAI,EAC3F,WAAW,CAAC,CAAC;IACnB,CAAC;IAED;;;;;;;OAOG;IACH,SAAS,yBAAyB,CAC9B,sBAAuE,EACvE,IAAiB;QACnB,IAAI,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACrB,IAAI,EAAE,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE;YAC9B,sEAAsE;YACtE,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;SAC1B;QACD,QAAQ,IAAI,EAAE;YACZ,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;YAChC,KAAK,EAAE,CAAC,UAAU,CAAC,eAAe;gBAChC,OAAO,EAAE,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;YACzC,KAAK,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC;YAC7B,KAAK,EAAE,CAAC,UAAU,CAAC,SAAS;gBAC1B,OAAO,EAAE,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;YACtC,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;YACjC,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;YAC/B,KAAK,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC;YAChC,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc;gBAC/B,OAAO,EAAE,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC;YACxC,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;YACjC,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa;gBAC9B,OAAO,EAAE,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;YACvC,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa;gBAC9B,OAAO,EAAE,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;YACvC,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa,CAAC;YACjC,KAAK,EAAE,CAAC,UAAU,CAAC,cAAc;gBAC/B,OAAO,EAAE,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;YACvC,KAAK,EAAE,CAAC,UAAU,CAAC,aAAa;gBAC9B,IAAM,OAAO,GAAG,IAA4B,CAAC;gBAC7C,uDAAuD;gBACvD,OAAO,sBAAsB,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;YAClD,KAAK,EAAE,CAAC,UAAU,CAAC,SAAS;gBAC1B,wEAAwE;gBACxE,8EAA8E;gBAC9E,IAAM,cAAc,GACf,IAAyB;qBACrB,KAAK,CAAC,MAAM,CACT,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW;oBACrC,CAAC,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,EADzE,CACyE,CAAC,CAAC;gBAC5F,OAAO,cAAc,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC;oBAChC,yBAAyB,CAAC,sBAAsB,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;oBACtE,SAAS,CAAC;YAChB;gBACE,OAAO,SAAS,CAAC;SACpB;IACH,CAAC;IAED;;;;;;OAMG;IACH,SAAS,oBAAoB,CAAC,WAA2B,EAAE,MAAiB;QAC1E,IAAI,MAAM,CAAC,KAAK,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,EAAE;YACvC,MAAM,GAAG,WAAW,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;SAC/C;QAED,oDAAoD;QACpD,wDAAwD;QACxD,OAAO,CAAC,MAAM,CAAC,KAAK,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,GAAG,EAAE,CAAC,WAAW,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;IACxF,CAAC;IAaD;;;;;;;;;;;;;OAaG;IACH,SAAgB,+BAA+B,CAC3C,WAA2B,EAAE,IAAoB,EAAE,WAA4B,EAC/E,MAAe,EAAE,wBAAiC,EAClD,mBAA4B;QAC9B,OAAO,UAAC,OAAiC;YACvC,IAAI,wBAAwB,GAAG,IAAI,GAAG,EAAkB,CAAC;YAEzD;;;;;eAKG;YACH,SAAS,sBAAsB,CAAC,IAAmB;gBACjD,IAAM,MAAM,GAAG,WAAW,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;gBACrD,yFAAyF;gBACzF,8DAA8D;gBAC9D,IAAI,CAAC,MAAM,IAAI,CAAC,oBAAoB,CAAC,WAAW,EAAE,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY;oBAC7E,MAAM,CAAC,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE;oBACpC,OAAO,SAAS,CAAC;iBAClB;gBACD,0EAA0E;gBAC1E,+CAA+C;gBAC/C,IAAI,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE;oBAC5B,IAAM,aAAa,GAAG,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;oBACxD,IAAI,aAAa,KAAK,SAAS,EAAE;wBAC/B,OAAO,SAAS,CAAC;qBAClB;oBACD,OAAO,EAAE,CAAC,oBAAoB,CAAC,aAAa,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;iBAC3D;gBACD,IAAM,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;gBACpC,6EAA6E;gBAC7E,6EAA6E;gBAC7E,8CAA8C;gBAC9C,IAAI,2DAAwB,CAAC,IAAI,CAAC,EAAE;oBAClC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;oBACnC,+EAA+E;oBAC/E,+EAA+E;oBAC/E,+EAA+E;oBAC/E,oFAAoF;oBACpF,kFAAkF;oBAClF,6EAA6E;oBAC7E,kFAAkF;oBAClF,+EAA+E;oBAC/E,uFAAuF;oBACvF,gFAAgF;oBAChF,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE;wBAC3B,OAAO,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;qBACtC;iBACF;gBACD,gFAAgF;gBAChF,gFAAgF;gBAChF,iFAAiF;gBACjF,OAAO,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;YAClC,CAAC;YAED;;;;eAIG;YACH,SAAS,qBAAqB,CAAC,OAAwB;;gBAErD,OAAO,GAAG,EAAE,CAAC,cAAc,CAAC,OAAO,EAAE,yBAAyB,EAAE,OAAO,CAAC,CAAC;gBACzE,IAAM,gBAAgB,GAAmB,EAAE,CAAC;gBAC5C,IAAM,OAAO,GAAmB,EAAE,CAAC;gBACnC,IAAM,UAAU,GAAG,IAAI,CAAC,0BAA0B,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;;oBAClE,KAAwB,IAAA,eAAA,iBAAA,UAAU,CAAA,sCAAA,8DAAE;wBAA/B,IAAM,SAAS,uBAAA;wBAClB,sEAAsE;wBACtE,mDAAmD;wBACnD,IAAM,aAAa,GAAG,SAAS,CAAC,IAAqB,CAAC;wBACtD,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE;4BAC1C,gBAAgB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;4BACrC,SAAS;yBACV;wBACD,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;qBAC7B;;;;;;;;;gBACD,IAAI,CAAC,OAAO,CAAC,MAAM;oBAAE,OAAO,CAAC,SAAS,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC;gBAErD,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;oBACnD,gCAAgC;oBAChC,yBAAyB;oBACzB,WAAW,CAAC,IAAI,CAAC;wBACf,IAAI,EAAE,OAAO,CAAC,aAAa,EAAE;wBAC7B,KAAK,EAAE,OAAO,CAAC,QAAQ,EAAE;wBACzB,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE;wBAC7C,WAAW,EAAE,uEAAuE;wBACpF,QAAQ,EAAE,EAAE,CAAC,kBAAkB,CAAC,KAAK;wBACrC,IAAI,EAAE,CAAC;qBACR,CAAC,CAAC;oBACH,OAAO,CAAC,SAAS,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC;iBACjC;gBAED,IAAM,IAAI,GAAI,OAAO,CAAC,IAAsB,CAAC,IAAI,CAAC;gBAClD,IAAM,OAAO,GAAG,EAAE,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;gBAC3C,OAAe,CAAC,UAAU,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;oBACnD,EAAE,CAAC,YAAY,CAAC,EAAE,CAAC,eAAe,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;oBAC3E,SAAS,CAAC;gBACd,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;YAClC,CAAC;YAED;;;eAGG;YACH,SAAS,oBAAoB,CAAC,IAA+B;;gBAE3D,IAAI,GAAG,EAAE,CAAC,cAAc,CAAC,IAAI,EAAE,yBAAyB,EAAE,OAAO,CAAC,CAAC;gBAEnE,IAAM,aAAa,GAA8B,EAAE,CAAC;gBACpD,IAAM,aAAa,GACf,EAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,EAAE,yBAAyB,EAAE,OAAO,CAAC,CAAC;gBAC/E,IAAM,cAAc,GAA8B,EAAE,CAAC;;oBACrD,KAAoB,IAAA,kBAAA,iBAAA,aAAa,CAAA,4CAAA,uEAAE;wBAA9B,IAAM,KAAK,0BAAA;wBACd,IAAM,gBAAgB,GAAmB,EAAE,CAAC;wBAC5C,IAAM,SAAS,GAA4B,EAAC,UAAU,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAC,CAAC;wBACxE,IAAM,UAAU,GAAG,IAAI,CAAC,0BAA0B,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;;4BAEhE,KAAwB,IAAA,8BAAA,iBAAA,UAAU,CAAA,CAAA,sCAAA,8DAAE;gCAA/B,IAAM,SAAS,uBAAA;gCAClB,sEAAsE;gCACtE,mDAAmD;gCACnD,IAAM,aAAa,GAAG,SAAS,CAAC,IAAqB,CAAC;gCACtD,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE;oCAC1C,gBAAgB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;oCACrC,SAAS;iCACV;gCACD,SAAU,CAAC,UAAU,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;6BAC3C;;;;;;;;;wBACD,IAAI,KAAK,CAAC,IAAI,EAAE;4BACd,8CAA8C;4BAC9C,wFAAwF;4BACxF,gFAAgF;4BAChF,eAAe;4BACf,SAAU,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;yBAC9B;wBACD,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;wBAC/B,IAAM,QAAQ,GAAG,EAAE,CAAC,eAAe,CAC/B,KAAK;wBACL,8DAA8D;wBAC9D,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,SAAS,EAAE,KAAK,CAAC,SAAS,EACvE,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,aAAa,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;wBAC1F,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;qBAC9B;;;;;;;;;gBACD,IAAM,OAAO,GAAG,EAAE,CAAC,iBAAiB,CAChC,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,SAAS,EAAE,aAAa,EACpD,EAAE,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,EAAE,yBAAyB,EAAE,OAAO,CAAC,CAAC,CAAC;gBACzE,OAAO,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;YACnC,CAAC;YAED;;;;;;eAMG;YACH,SAAS,yBAAyB,CAAC,SAA8B;;gBAC/D,SAAS,GAAG,EAAE,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;gBAE1C,IAAM,UAAU,GAAsB,EAAE,CAAC;gBACzC,IAAM,mBAAmB,GAAG,IAAI,GAAG,EAA0B,CAAC;gBAC9D,IAAI,eAAe,GAAmC,IAAI,CAAC;;oBAE3D,KAAqB,IAAA,KAAA,iBAAA,SAAS,CAAC,OAAO,CAAA,gBAAA,4BAAE;wBAAnC,IAAM,MAAM,WAAA;wBACf,QAAQ,MAAM,CAAC,IAAI,EAAE;4BACnB,KAAK,EAAE,CAAC,UAAU,CAAC,mBAAmB,CAAC;4BACvC,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;4BAC/B,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC;4BAC/B,KAAK,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC;gCAC9B,IAAA,KAAA,eAAgC,qBAAqB,CAAC,MAAM,CAAC,IAAA,EAA5D,IAAI,QAAA,EAAE,SAAS,QAAA,EAAE,YAAU,QAAiC,CAAC;gCACpE,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;gCAC3B,IAAI,IAAI;oCAAE,mBAAmB,CAAC,GAAG,CAAC,IAAI,EAAE,YAAU,CAAC,CAAC;gCACpD,SAAS;6BACV;4BACD,KAAK,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;gCAC9B,IAAM,IAAI,GAAG,MAAmC,CAAC;gCACjD,IAAI,CAAC,IAAI,CAAC,IAAI;oCAAE,MAAM;gCAChB,IAAA,KAAA,eACF,oBAAoB,CAAC,MAAmC,CAAC,IAAA,EADtD,SAAS,QAAA,EAAE,cAAc,QAC6B,CAAC;gCAC9D,eAAe,GAAG,cAAc,CAAC;gCACjC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;gCAC3B,SAAS;6BACV;4BACD;gCACE,MAAM;yBACT;wBACD,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,cAAc,CAAC,MAAM,EAAE,yBAAyB,EAAE,OAAO,CAAC,CAAC,CAAC;qBAChF;;;;;;;;;gBACD,IAAM,UAAU,GAAG,IAAI,CAAC,0BAA0B,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;gBAEpE,IAAI,mBAAmB,GAAG,KAAK,CAAC;gBAChC,IAAM,iBAAiB,GAAG,EAAE,CAAC;gBAC7B,IAAM,gBAAgB,GAAmB,EAAE,CAAC;;oBAC5C,KAAwB,IAAA,eAAA,iBAAA,UAAU,CAAA,sCAAA,8DAAE;wBAA/B,IAAM,SAAS,uBAAA;wBAClB,sEAAsE;wBACtE,mDAAmD;wBACnD,IAAM,aAAa,GAAG,SAAS,CAAC,IAAqB,CAAC;wBACtD,IAAM,aAAa,GAAG,kBAAkB,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;wBAE5D,wEAAwE;wBACxE,6EAA6E;wBAC7E,IAAI,aAAa,EAAE;4BACjB,mBAAmB,GAAG,IAAI,CAAC;yBAC5B;wBAED,IAAI,aAAa,IAAI,CAAC,mBAAmB,EAAE;4BACzC,iBAAiB,CAAC,IAAI,CAAC,kCAAkC,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC,CAAC;yBACxF;6BAAM;4BACL,gBAAgB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;yBACtC;qBACF;;;;;;;;;gBAED,IAAI,iBAAiB,CAAC,MAAM,EAAE;oBAC5B,UAAU,CAAC,IAAI,CAAC,4BAA4B,CAAC,iBAAiB,CAAC,CAAC,CAAC;iBAClE;gBACD,IAAI,eAAe,EAAE;oBACnB,IAAI,mBAAmB,IAAI,eAAe,CAAC,IAAI,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,EAArB,CAAqB,CAAC,EAAE;wBAC3E,6EAA6E;wBAC7E,+DAA+D;wBAC/D,UAAU,CAAC,IAAI,CAAC,iCAAiC,CAC7C,WAAW,EAAE,sBAAsB,EAAE,eAAe,EAAE,wBAAwB,CAAC,CAAC,CAAC;qBACtF;iBACF;gBACD,IAAI,mBAAmB,CAAC,IAAI,EAAE;oBAC5B,UAAU,CAAC,IAAI,CAAC,iCAAiC,CAAC,WAAW,EAAE,mBAAmB,CAAC,CAAC,CAAC;iBACtF;gBAED,IAAM,OAAO,GAAG,EAAE,CAAC,YAAY,CAC3B,EAAE,CAAC,eAAe,CAAC,UAAU,EAAE,SAAS,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;gBAE3F,OAAO,EAAE,CAAC,sBAAsB,CAC5B,SAAS,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,SAAS,EAAE,SAAS,CAAC,SAAS,EACtF,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,cAAc,EAAE,SAAS,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;YACpF,CAAC;YAED;;;;eAIG;YACH,SAAS,yBAAyB,CAAC,IAAa;gBAC9C,IAAI,EAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE;oBAC/B,OAAO,yBAAyB,CAAC,IAAI,CAAC,CAAC;iBACxC;gBACD,OAAO,EAAE,CAAC,cAAc,CAAC,IAAI,EAAE,yBAAyB,EAAE,OAAO,CAAC,CAAC;YACrE,CAAC;YAED,OAAO,UAAC,EAAiB;gBACvB,gFAAgF;gBAChF,mFAAmF;gBACnF,gFAAgF;gBAChF,6EAA6E;gBAC7E,qEAAqE;gBACrE,qEAAkC,CAAC,OAAO,EAAE,wBAAwB,CAAC,CAAC;gBACtE,kFAAkF;gBAClF,+EAA+E;gBAC/E,kEAAkE;gBAClE,OAAO,EAAE,CAAC,cAAc,CAAC,EAAE,EAAE,yBAAyB,EAAE,OAAO,CAAC,CAAC;YACnE,CAAC,CAAC;QACJ,CAAC,CAAC;IACJ,CAAC;IApQD,0EAoQC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as ts from 'typescript';\nimport {Decorator, ReflectionHost} from '../ngtsc/reflection';\nimport {isAliasImportDeclaration, patchAliasReferenceResolutionOrDie} from './patch_alias_reference_resolution';\n\n/**\n * Whether a given decorator should be treated as an Angular decorator.\n * Either it's used in @angular/core, or it's imported from there.\n */\nfunction isAngularDecorator(decorator: Decorator, isCore: boolean): boolean {\n  return isCore || (decorator.import !== null && decorator.import.from === '@angular/core');\n}\n\n/*\n #####################################################################\n  Code below has been extracted from the tsickle decorator downlevel transformer\n  and a few local modifications have been applied:\n\n    1. Tsickle by default processed all decorators that had the `@Annotation` JSDoc.\n       We modified the transform to only be concerned with known Angular decorators.\n    2. Tsickle by default added `@nocollapse` to all generated `ctorParameters` properties.\n       We only do this when `annotateForClosureCompiler` is enabled.\n    3. Tsickle does not handle union types for dependency injection. i.e. if a injected type\n       is denoted with `@Optional`, the actual type could be set to `T | null`.\n       See: https://github.com/angular/angular-cli/commit/826803d0736b807867caff9f8903e508970ad5e4.\n    4. Tsickle relied on `emitDecoratorMetadata` to be set to `true`. This is due to a limitation\n       in TypeScript transformers that never has been fixed. We were able to work around this\n       limitation so that `emitDecoratorMetadata` doesn't need to be specified.\n       See: `patchAliasReferenceResolution` for more details.\n\n  Here is a link to the tsickle revision on which this transformer is based:\n  https://github.com/angular/tsickle/blob/fae06becb1570f491806060d83f29f2d50c43cdd/src/decorator_downlevel_transformer.ts\n #####################################################################\n*/\n\n/**\n * Creates the AST for the decorator field type annotation, which has the form\n *     { type: Function, args?: any[] }[]\n */\nfunction createDecoratorInvocationType(): ts.TypeNode {\n  const typeElements: ts.TypeElement[] = [];\n  typeElements.push(ts.createPropertySignature(\n      undefined, 'type', undefined,\n      ts.createTypeReferenceNode(ts.createIdentifier('Function'), undefined), undefined));\n  typeElements.push(ts.createPropertySignature(\n      undefined, 'args', ts.createToken(ts.SyntaxKind.QuestionToken),\n      ts.createArrayTypeNode(ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)), undefined));\n  return ts.createArrayTypeNode(ts.createTypeLiteralNode(typeElements));\n}\n\n/**\n * Extracts the type of the decorator (the function or expression invoked), as well as all the\n * arguments passed to the decorator. Returns an AST with the form:\n *\n *     // For @decorator(arg1, arg2)\n *     { type: decorator, args: [arg1, arg2] }\n */\nfunction extractMetadataFromSingleDecorator(\n    decorator: ts.Decorator, diagnostics: ts.Diagnostic[]): ts.ObjectLiteralExpression {\n  const metadataProperties: ts.ObjectLiteralElementLike[] = [];\n  const expr = decorator.expression;\n  switch (expr.kind) {\n    case ts.SyntaxKind.Identifier:\n      // The decorator was a plain @Foo.\n      metadataProperties.push(ts.createPropertyAssignment('type', expr));\n      break;\n    case ts.SyntaxKind.CallExpression:\n      // The decorator was a call, like @Foo(bar).\n      const call = expr as ts.CallExpression;\n      metadataProperties.push(ts.createPropertyAssignment('type', call.expression));\n      if (call.arguments.length) {\n        const args: ts.Expression[] = [];\n        for (const arg of call.arguments) {\n          args.push(arg);\n        }\n        const argsArrayLiteral = ts.createArrayLiteral(args);\n        argsArrayLiteral.elements.hasTrailingComma = true;\n        metadataProperties.push(ts.createPropertyAssignment('args', argsArrayLiteral));\n      }\n      break;\n    default:\n      diagnostics.push({\n        file: decorator.getSourceFile(),\n        start: decorator.getStart(),\n        length: decorator.getEnd() - decorator.getStart(),\n        messageText:\n            `${ts.SyntaxKind[decorator.kind]} not implemented in gathering decorator metadata.`,\n        category: ts.DiagnosticCategory.Error,\n        code: 0,\n      });\n      break;\n  }\n  return ts.createObjectLiteral(metadataProperties);\n}\n\n/**\n * Takes a list of decorator metadata object ASTs and produces an AST for a\n * static class property of an array of those metadata objects.\n */\nfunction createDecoratorClassProperty(decoratorList: ts.ObjectLiteralExpression[]) {\n  const modifier = ts.createToken(ts.SyntaxKind.StaticKeyword);\n  const type = createDecoratorInvocationType();\n  const initializer = ts.createArrayLiteral(decoratorList, true);\n  // NB: the .decorators property does not get a @nocollapse property. There is\n  // no good reason why - it means .decorators is not runtime accessible if you\n  // compile with collapse properties, whereas propDecorators is, which doesn't\n  // follow any stringent logic. However this has been the case previously, and\n  // adding it back in leads to substantial code size increases as Closure fails\n  // to tree shake these props without @nocollapse.\n  return ts.createProperty(undefined, [modifier], 'decorators', undefined, type, initializer);\n}\n\n/**\n * Creates the AST for the 'ctorParameters' field type annotation:\n *   () => ({ type: any, decorators?: {type: Function, args?: any[]}[] }|null)[]\n */\nfunction createCtorParametersClassPropertyType(): ts.TypeNode {\n  // Sorry about this. Try reading just the string literals below.\n  const typeElements: ts.TypeElement[] = [];\n  typeElements.push(ts.createPropertySignature(\n      undefined, 'type', undefined,\n      ts.createTypeReferenceNode(ts.createIdentifier('any'), undefined), undefined));\n  typeElements.push(ts.createPropertySignature(\n      undefined, 'decorators', ts.createToken(ts.SyntaxKind.QuestionToken),\n      ts.createArrayTypeNode(ts.createTypeLiteralNode([\n        ts.createPropertySignature(\n            undefined, 'type', undefined,\n            ts.createTypeReferenceNode(ts.createIdentifier('Function'), undefined), undefined),\n        ts.createPropertySignature(\n            undefined, 'args', ts.createToken(ts.SyntaxKind.QuestionToken),\n            ts.createArrayTypeNode(\n                ts.createTypeReferenceNode(ts.createIdentifier('any'), undefined)),\n            undefined),\n      ])),\n      undefined));\n\n  // TODO(alan-agius4): Remove when we no longer support TS 3.9\n  const nullLiteral = ts.createNull() as any;\n  const nullType = ts.versionMajorMinor.charAt(0) === '4' ?\n      ts.createLiteralTypeNode(nullLiteral as any) :\n      nullLiteral;\n  return ts.createFunctionTypeNode(undefined, [], ts.createArrayTypeNode(ts.createUnionTypeNode([\n    ts.createTypeLiteralNode(typeElements),\n    nullType,\n  ])));\n}\n\n/**\n * Sets a Closure \\@nocollapse synthetic comment on the given node. This prevents Closure Compiler\n * from collapsing the apparently static property, which would make it impossible to find for code\n * trying to detect it at runtime.\n */\nfunction addNoCollapseComment(n: ts.Node) {\n  ts.setSyntheticLeadingComments(n, [{\n                                   kind: ts.SyntaxKind.MultiLineCommentTrivia,\n                                   text: '* @nocollapse ',\n                                   pos: -1,\n                                   end: -1,\n                                   hasTrailingNewLine: true\n                                 }]);\n}\n\n/**\n * createCtorParametersClassProperty creates a static 'ctorParameters' property containing\n * downleveled decorator information.\n *\n * The property contains an arrow function that returns an array of object literals of the shape:\n *     static ctorParameters = () => [{\n *       type: SomeClass|undefined,  // the type of the param that's decorated, if it's a value.\n *       decorators: [{\n *         type: DecoratorFn,  // the type of the decorator that's invoked.\n *         args: [ARGS],       // the arguments passed to the decorator.\n *       }]\n *     }];\n */\nfunction createCtorParametersClassProperty(\n    diagnostics: ts.Diagnostic[],\n    entityNameToExpression: (n: ts.EntityName) => ts.Expression | undefined,\n    ctorParameters: ParameterDecorationInfo[],\n    isClosureCompilerEnabled: boolean): ts.PropertyDeclaration {\n  const params: ts.Expression[] = [];\n\n  for (const ctorParam of ctorParameters) {\n    if (!ctorParam.type && ctorParam.decorators.length === 0) {\n      params.push(ts.createNull());\n      continue;\n    }\n\n    const paramType = ctorParam.type ?\n        typeReferenceToExpression(entityNameToExpression, ctorParam.type) :\n        undefined;\n    const members =\n        [ts.createPropertyAssignment('type', paramType || ts.createIdentifier('undefined'))];\n\n    const decorators: ts.ObjectLiteralExpression[] = [];\n    for (const deco of ctorParam.decorators) {\n      decorators.push(extractMetadataFromSingleDecorator(deco, diagnostics));\n    }\n    if (decorators.length) {\n      members.push(ts.createPropertyAssignment('decorators', ts.createArrayLiteral(decorators)));\n    }\n    params.push(ts.createObjectLiteral(members));\n  }\n\n  const initializer = ts.createArrowFunction(\n      undefined, undefined, [], undefined, ts.createToken(ts.SyntaxKind.EqualsGreaterThanToken),\n      ts.createArrayLiteral(params, true));\n  const type = createCtorParametersClassPropertyType();\n  const ctorProp = ts.createProperty(\n      undefined, [ts.createToken(ts.SyntaxKind.StaticKeyword)], 'ctorParameters', undefined, type,\n      initializer);\n  if (isClosureCompilerEnabled) {\n    addNoCollapseComment(ctorProp);\n  }\n  return ctorProp;\n}\n\n/**\n * createPropDecoratorsClassProperty creates a static 'propDecorators' property containing type\n * information for every property that has a decorator applied.\n *\n *     static propDecorators: {[key: string]: {type: Function, args?: any[]}[]} = {\n *       propA: [{type: MyDecorator, args: [1, 2]}, ...],\n *       ...\n *     };\n */\nfunction createPropDecoratorsClassProperty(\n    diagnostics: ts.Diagnostic[], properties: Map<string, ts.Decorator[]>): ts.PropertyDeclaration {\n  //  `static propDecorators: {[key: string]: ` + {type: Function, args?: any[]}[] + `} = {\\n`);\n  const entries: ts.ObjectLiteralElementLike[] = [];\n  for (const [name, decorators] of properties.entries()) {\n    entries.push(ts.createPropertyAssignment(\n        name,\n        ts.createArrayLiteral(\n            decorators.map(deco => extractMetadataFromSingleDecorator(deco, diagnostics)))));\n  }\n  const initializer = ts.createObjectLiteral(entries, true);\n  const type = ts.createTypeLiteralNode([ts.createIndexSignature(\n      undefined, undefined, [ts.createParameter(\n                                undefined, undefined, undefined, 'key', undefined,\n                                ts.createTypeReferenceNode('string', undefined), undefined)],\n      createDecoratorInvocationType())]);\n  return ts.createProperty(\n      undefined, [ts.createToken(ts.SyntaxKind.StaticKeyword)], 'propDecorators', undefined, type,\n      initializer);\n}\n\n/**\n * Returns an expression representing the (potentially) value part for the given node.\n *\n * This is a partial re-implementation of TypeScript's serializeTypeReferenceNode. This is a\n * workaround for https://github.com/Microsoft/TypeScript/issues/17516 (serializeTypeReferenceNode\n * not being exposed). In practice this implementation is sufficient for Angular's use of type\n * metadata.\n */\nfunction typeReferenceToExpression(\n    entityNameToExpression: (n: ts.EntityName) => ts.Expression | undefined,\n    node: ts.TypeNode): ts.Expression|undefined {\n  let kind = node.kind;\n  if (ts.isLiteralTypeNode(node)) {\n    // Treat literal types like their base type (boolean, string, number).\n    kind = node.literal.kind;\n  }\n  switch (kind) {\n    case ts.SyntaxKind.FunctionType:\n    case ts.SyntaxKind.ConstructorType:\n      return ts.createIdentifier('Function');\n    case ts.SyntaxKind.ArrayType:\n    case ts.SyntaxKind.TupleType:\n      return ts.createIdentifier('Array');\n    case ts.SyntaxKind.TypePredicate:\n    case ts.SyntaxKind.TrueKeyword:\n    case ts.SyntaxKind.FalseKeyword:\n    case ts.SyntaxKind.BooleanKeyword:\n      return ts.createIdentifier('Boolean');\n    case ts.SyntaxKind.StringLiteral:\n    case ts.SyntaxKind.StringKeyword:\n      return ts.createIdentifier('String');\n    case ts.SyntaxKind.ObjectKeyword:\n      return ts.createIdentifier('Object');\n    case ts.SyntaxKind.NumberKeyword:\n    case ts.SyntaxKind.NumericLiteral:\n      return ts.createIdentifier('Number');\n    case ts.SyntaxKind.TypeReference:\n      const typeRef = node as ts.TypeReferenceNode;\n      // Ignore any generic types, just return the base type.\n      return entityNameToExpression(typeRef.typeName);\n    case ts.SyntaxKind.UnionType:\n      // TODO(alan-agius4): remove `t.kind !== ts.SyntaxKind.NullKeyword` when\n      // TS 3.9 support is dropped. In TS 4.0 NullKeyword is a child of LiteralType.\n      const childTypeNodes =\n          (node as ts.UnionTypeNode)\n              .types.filter(\n                  t => t.kind !== ts.SyntaxKind.NullKeyword &&\n                      !(ts.isLiteralTypeNode(t) && t.literal.kind === ts.SyntaxKind.NullKeyword));\n      return childTypeNodes.length === 1 ?\n          typeReferenceToExpression(entityNameToExpression, childTypeNodes[0]) :\n          undefined;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Checks whether a given symbol refers to a value that exists at runtime (as distinct from a type).\n *\n * Expands aliases, which is important for the case where\n *   import * as x from 'some-module';\n * and x is now a value (the module object).\n */\nfunction symbolIsRuntimeValue(typeChecker: ts.TypeChecker, symbol: ts.Symbol): boolean {\n  if (symbol.flags & ts.SymbolFlags.Alias) {\n    symbol = typeChecker.getAliasedSymbol(symbol);\n  }\n\n  // Note that const enums are a special case, because\n  // while they have a value, they don't exist at runtime.\n  return (symbol.flags & ts.SymbolFlags.Value & ts.SymbolFlags.ConstEnumExcludes) !== 0;\n}\n\n/** ParameterDecorationInfo describes the information for a single constructor parameter. */\ninterface ParameterDecorationInfo {\n  /**\n   * The type declaration for the parameter. Only set if the type is a value (e.g. a class, not an\n   * interface).\n   */\n  type: ts.TypeNode|null;\n  /** The list of decorators found on the parameter, null if none. */\n  decorators: ts.Decorator[];\n}\n\n/**\n * Gets a transformer for downleveling Angular decorators.\n * @param typeChecker Reference to the program's type checker.\n * @param host Reflection host that is used for determining decorators.\n * @param diagnostics List which will be populated with diagnostics if any.\n * @param isCore Whether the current TypeScript program is for the `@angular/core` package.\n * @param isClosureCompilerEnabled Whether closure annotations need to be added where needed.\n * @param skipClassDecorators Whether class decorators should be skipped from downleveling.\n *   This is useful for JIT mode where class decorators should be preserved as they could rely\n *   on immediate execution. e.g. downleveling `@Injectable` means that the injectable factory\n *   is not created, and injecting the token will not work. If this decorator would not be\n *   downleveled, the `Injectable` decorator will execute immediately on file load, and\n *   Angular will generate the corresponding injectable factory.\n */\nexport function getDownlevelDecoratorsTransform(\n    typeChecker: ts.TypeChecker, host: ReflectionHost, diagnostics: ts.Diagnostic[],\n    isCore: boolean, isClosureCompilerEnabled: boolean,\n    skipClassDecorators: boolean): ts.TransformerFactory<ts.SourceFile> {\n  return (context: ts.TransformationContext) => {\n    let referencedParameterTypes = new Set<ts.Declaration>();\n\n    /**\n     * Converts an EntityName (from a type annotation) to an expression (accessing a value).\n     *\n     * For a given qualified name, this walks depth first to find the leftmost identifier,\n     * and then converts the path into a property access that can be used as expression.\n     */\n    function entityNameToExpression(name: ts.EntityName): ts.Expression|undefined {\n      const symbol = typeChecker.getSymbolAtLocation(name);\n      // Check if the entity name references a symbol that is an actual value. If it is not, it\n      // cannot be referenced by an expression, so return undefined.\n      if (!symbol || !symbolIsRuntimeValue(typeChecker, symbol) || !symbol.declarations ||\n          symbol.declarations.length === 0) {\n        return undefined;\n      }\n      // If we deal with a qualified name, build up a property access expression\n      // that could be used in the JavaScript output.\n      if (ts.isQualifiedName(name)) {\n        const containerExpr = entityNameToExpression(name.left);\n        if (containerExpr === undefined) {\n          return undefined;\n        }\n        return ts.createPropertyAccess(containerExpr, name.right);\n      }\n      const decl = symbol.declarations[0];\n      // If the given entity name has been resolved to an alias import declaration,\n      // ensure that the alias declaration is not elided by TypeScript, and use its\n      // name identifier to reference it at runtime.\n      if (isAliasImportDeclaration(decl)) {\n        referencedParameterTypes.add(decl);\n        // If the entity name resolves to an alias import declaration, we reference the\n        // entity based on the alias import name. This ensures that TypeScript properly\n        // resolves the link to the import. Cloning the original entity name identifier\n        // could lead to an incorrect resolution at local scope. e.g. Consider the following\n        // snippet: `constructor(Dep: Dep) {}`. In such a case, the local `Dep` identifier\n        // would resolve to the actual parameter name, and not to the desired import.\n        // This happens because the entity name identifier symbol is internally considered\n        // as type-only and therefore TypeScript tries to resolve it as value manually.\n        // We can help TypeScript and avoid this non-reliable resolution by using an identifier\n        // that is not type-only and is directly linked to the import alias declaration.\n        if (decl.name !== undefined) {\n          return ts.getMutableClone(decl.name);\n        }\n      }\n      // Clone the original entity name identifier so that it can be used to reference\n      // its value at runtime. This is used when the identifier is resolving to a file\n      // local declaration (otherwise it would resolve to an alias import declaration).\n      return ts.getMutableClone(name);\n    }\n\n    /**\n     * Transforms a class element. Returns a three tuple of name, transformed element, and\n     * decorators found. Returns an undefined name if there are no decorators to lower on the\n     * element, or the element has an exotic name.\n     */\n    function transformClassElement(element: ts.ClassElement):\n        [string|undefined, ts.ClassElement, ts.Decorator[]] {\n      element = ts.visitEachChild(element, decoratorDownlevelVisitor, context);\n      const decoratorsToKeep: ts.Decorator[] = [];\n      const toLower: ts.Decorator[] = [];\n      const decorators = host.getDecoratorsOfDeclaration(element) || [];\n      for (const decorator of decorators) {\n        // We only deal with concrete nodes in TypeScript sources, so we don't\n        // need to handle synthetically created decorators.\n        const decoratorNode = decorator.node! as ts.Decorator;\n        if (!isAngularDecorator(decorator, isCore)) {\n          decoratorsToKeep.push(decoratorNode);\n          continue;\n        }\n        toLower.push(decoratorNode);\n      }\n      if (!toLower.length) return [undefined, element, []];\n\n      if (!element.name || !ts.isIdentifier(element.name)) {\n        // Method has a weird name, e.g.\n        //   [Symbol.foo]() {...}\n        diagnostics.push({\n          file: element.getSourceFile(),\n          start: element.getStart(),\n          length: element.getEnd() - element.getStart(),\n          messageText: `Cannot process decorators for class element with non-analyzable name.`,\n          category: ts.DiagnosticCategory.Error,\n          code: 0,\n        });\n        return [undefined, element, []];\n      }\n\n      const name = (element.name as ts.Identifier).text;\n      const mutable = ts.getMutableClone(element);\n      (mutable as any).decorators = decoratorsToKeep.length ?\n          ts.setTextRange(ts.createNodeArray(decoratorsToKeep), mutable.decorators) :\n          undefined;\n      return [name, mutable, toLower];\n    }\n\n    /**\n     * Transforms a constructor. Returns the transformed constructor and the list of parameter\n     * information collected, consisting of decorators and optional type.\n     */\n    function transformConstructor(ctor: ts.ConstructorDeclaration):\n        [ts.ConstructorDeclaration, ParameterDecorationInfo[]] {\n      ctor = ts.visitEachChild(ctor, decoratorDownlevelVisitor, context);\n\n      const newParameters: ts.ParameterDeclaration[] = [];\n      const oldParameters =\n          ts.visitParameterList(ctor.parameters, decoratorDownlevelVisitor, context);\n      const parametersInfo: ParameterDecorationInfo[] = [];\n      for (const param of oldParameters) {\n        const decoratorsToKeep: ts.Decorator[] = [];\n        const paramInfo: ParameterDecorationInfo = {decorators: [], type: null};\n        const decorators = host.getDecoratorsOfDeclaration(param) || [];\n\n        for (const decorator of decorators) {\n          // We only deal with concrete nodes in TypeScript sources, so we don't\n          // need to handle synthetically created decorators.\n          const decoratorNode = decorator.node! as ts.Decorator;\n          if (!isAngularDecorator(decorator, isCore)) {\n            decoratorsToKeep.push(decoratorNode);\n            continue;\n          }\n          paramInfo!.decorators.push(decoratorNode);\n        }\n        if (param.type) {\n          // param has a type provided, e.g. \"foo: Bar\".\n          // The type will be emitted as a value expression in entityNameToExpression, which takes\n          // care not to emit anything for types that cannot be expressed as a value (e.g.\n          // interfaces).\n          paramInfo!.type = param.type;\n        }\n        parametersInfo.push(paramInfo);\n        const newParam = ts.updateParameter(\n            param,\n            // Must pass 'undefined' to avoid emitting decorator metadata.\n            decoratorsToKeep.length ? decoratorsToKeep : undefined, param.modifiers,\n            param.dotDotDotToken, param.name, param.questionToken, param.type, param.initializer);\n        newParameters.push(newParam);\n      }\n      const updated = ts.updateConstructor(\n          ctor, ctor.decorators, ctor.modifiers, newParameters,\n          ts.visitFunctionBody(ctor.body, decoratorDownlevelVisitor, context));\n      return [updated, parametersInfo];\n    }\n\n    /**\n     * Transforms a single class declaration:\n     * - dispatches to strip decorators on members\n     * - converts decorators on the class to annotations\n     * - creates a ctorParameters property\n     * - creates a propDecorators property\n     */\n    function transformClassDeclaration(classDecl: ts.ClassDeclaration): ts.ClassDeclaration {\n      classDecl = ts.getMutableClone(classDecl);\n\n      const newMembers: ts.ClassElement[] = [];\n      const decoratedProperties = new Map<string, ts.Decorator[]>();\n      let classParameters: ParameterDecorationInfo[]|null = null;\n\n      for (const member of classDecl.members) {\n        switch (member.kind) {\n          case ts.SyntaxKind.PropertyDeclaration:\n          case ts.SyntaxKind.GetAccessor:\n          case ts.SyntaxKind.SetAccessor:\n          case ts.SyntaxKind.MethodDeclaration: {\n            const [name, newMember, decorators] = transformClassElement(member);\n            newMembers.push(newMember);\n            if (name) decoratedProperties.set(name, decorators);\n            continue;\n          }\n          case ts.SyntaxKind.Constructor: {\n            const ctor = member as ts.ConstructorDeclaration;\n            if (!ctor.body) break;\n            const [newMember, parametersInfo] =\n                transformConstructor(member as ts.ConstructorDeclaration);\n            classParameters = parametersInfo;\n            newMembers.push(newMember);\n            continue;\n          }\n          default:\n            break;\n        }\n        newMembers.push(ts.visitEachChild(member, decoratorDownlevelVisitor, context));\n      }\n      const decorators = host.getDecoratorsOfDeclaration(classDecl) || [];\n\n      let hasAngularDecorator = false;\n      const decoratorsToLower = [];\n      const decoratorsToKeep: ts.Decorator[] = [];\n      for (const decorator of decorators) {\n        // We only deal with concrete nodes in TypeScript sources, so we don't\n        // need to handle synthetically created decorators.\n        const decoratorNode = decorator.node! as ts.Decorator;\n        const isNgDecorator = isAngularDecorator(decorator, isCore);\n\n        // Keep track if we come across an Angular class decorator. This is used\n        // for to determine whether constructor parameters should be captured or not.\n        if (isNgDecorator) {\n          hasAngularDecorator = true;\n        }\n\n        if (isNgDecorator && !skipClassDecorators) {\n          decoratorsToLower.push(extractMetadataFromSingleDecorator(decoratorNode, diagnostics));\n        } else {\n          decoratorsToKeep.push(decoratorNode);\n        }\n      }\n\n      if (decoratorsToLower.length) {\n        newMembers.push(createDecoratorClassProperty(decoratorsToLower));\n      }\n      if (classParameters) {\n        if (hasAngularDecorator || classParameters.some(p => !!p.decorators.length)) {\n          // Capture constructor parameters if the class has Angular decorator applied,\n          // or if any of the parameters has decorators applied directly.\n          newMembers.push(createCtorParametersClassProperty(\n              diagnostics, entityNameToExpression, classParameters, isClosureCompilerEnabled));\n        }\n      }\n      if (decoratedProperties.size) {\n        newMembers.push(createPropDecoratorsClassProperty(diagnostics, decoratedProperties));\n      }\n\n      const members = ts.setTextRange(\n          ts.createNodeArray(newMembers, classDecl.members.hasTrailingComma), classDecl.members);\n\n      return ts.updateClassDeclaration(\n          classDecl, decoratorsToKeep.length ? decoratorsToKeep : undefined, classDecl.modifiers,\n          classDecl.name, classDecl.typeParameters, classDecl.heritageClauses, members);\n    }\n\n    /**\n     * Transformer visitor that looks for Angular decorators and replaces them with\n     * downleveled static properties. Also collects constructor type metadata for\n     * class declaration that are decorated with an Angular decorator.\n     */\n    function decoratorDownlevelVisitor(node: ts.Node): ts.Node {\n      if (ts.isClassDeclaration(node)) {\n        return transformClassDeclaration(node);\n      }\n      return ts.visitEachChild(node, decoratorDownlevelVisitor, context);\n    }\n\n    return (sf: ts.SourceFile) => {\n      // Ensure that referenced type symbols are not elided by TypeScript. Imports for\n      // such parameter type symbols previously could be type-only, but now might be also\n      // used in the `ctorParameters` static property as a value. We want to make sure\n      // that TypeScript does not elide imports for such type references. Read more\n      // about this in the description for `patchAliasReferenceResolution`.\n      patchAliasReferenceResolutionOrDie(context, referencedParameterTypes);\n      // Downlevel decorators and constructor parameter types. We will keep track of all\n      // referenced constructor parameter types so that we can instruct TypeScript to\n      // not elide their imports if they previously were only type-only.\n      return ts.visitEachChild(sf, decoratorDownlevelVisitor, context);\n    };\n  };\n}\n"]}