source: trip-planner-front/node_modules/@angular/compiler/esm2015/src/aot/summary_serializer.js

/**
 * @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
 */
import { CompileNgModuleMetadata, CompileSummaryKind } from '../compile_metadata';
import * as o from '../output/output_ast';
import { ValueTransformer, visitValue } from '../util';
import { StaticSymbol } from './static_symbol';
import { unwrapResolvedMetadata } from './static_symbol_resolver';
import { isLoweredSymbol, ngfactoryFilePath, summaryForJitFileName, summaryForJitName } from './util';
export function serializeSummaries(srcFileName, forJitCtx, summaryResolver, symbolResolver, symbols, types, createExternalSymbolReexports = false) {
    const toJsonSerializer = new ToJsonSerializer(symbolResolver, summaryResolver, srcFileName);
    // for symbols, we use everything except for the class metadata itself
    // (we keep the statics though), as the class metadata is contained in the
    // CompileTypeSummary.
    symbols.forEach((resolvedSymbol) => toJsonSerializer.addSummary({ symbol: resolvedSymbol.symbol, metadata: resolvedSymbol.metadata }));
    // Add type summaries.
    types.forEach(({ summary, metadata }) => {
        toJsonSerializer.addSummary({ symbol: summary.type.reference, metadata: undefined, type: summary });
    });
    const { json, exportAs } = toJsonSerializer.serialize(createExternalSymbolReexports);
    if (forJitCtx) {
        const forJitSerializer = new ForJitSerializer(forJitCtx, symbolResolver, summaryResolver);
        types.forEach(({ summary, metadata }) => {
            forJitSerializer.addSourceType(summary, metadata);
        });
        toJsonSerializer.unprocessedSymbolSummariesBySymbol.forEach((summary) => {
            if (summaryResolver.isLibraryFile(summary.symbol.filePath) && summary.type) {
                forJitSerializer.addLibType(summary.type);
            }
        });
        forJitSerializer.serialize(exportAs);
    }
    return { json, exportAs };
}
export function deserializeSummaries(symbolCache, summaryResolver, libraryFileName, json) {
    const deserializer = new FromJsonDeserializer(symbolCache, summaryResolver);
    return deserializer.deserialize(libraryFileName, json);
}
export function createForJitStub(outputCtx, reference) {
    return createSummaryForJitFunction(outputCtx, reference, o.NULL_EXPR);
}
function createSummaryForJitFunction(outputCtx, reference, value) {
    const fnName = summaryForJitName(reference.name);
    outputCtx.statements.push(o.fn([], [new o.ReturnStatement(value)], new o.ArrayType(o.DYNAMIC_TYPE)).toDeclStmt(fnName, [
        o.StmtModifier.Final, o.StmtModifier.Exported
    ]));
}
class ToJsonSerializer extends ValueTransformer {
    constructor(symbolResolver, summaryResolver, srcFileName) {
        super();
        this.symbolResolver = symbolResolver;
        this.summaryResolver = summaryResolver;
        this.srcFileName = srcFileName;
        // Note: This only contains symbols without members.
        this.symbols = [];
        this.indexBySymbol = new Map();
        this.reexportedBy = new Map();
        // This now contains a `__symbol: number` in the place of
        // StaticSymbols, but otherwise has the same shape as the original objects.
        this.processedSummaryBySymbol = new Map();
        this.processedSummaries = [];
        this.unprocessedSymbolSummariesBySymbol = new Map();
        this.moduleName = symbolResolver.getKnownModuleName(srcFileName);
    }
    addSummary(summary) {
        let unprocessedSummary = this.unprocessedSymbolSummariesBySymbol.get(summary.symbol);
        let processedSummary = this.processedSummaryBySymbol.get(summary.symbol);
        if (!unprocessedSummary) {
            unprocessedSummary = { symbol: summary.symbol, metadata: undefined };
            this.unprocessedSymbolSummariesBySymbol.set(summary.symbol, unprocessedSummary);
            processedSummary = { symbol: this.processValue(summary.symbol, 0 /* None */) };
            this.processedSummaries.push(processedSummary);
            this.processedSummaryBySymbol.set(summary.symbol, processedSummary);
        }
        if (!unprocessedSummary.metadata && summary.metadata) {
            let metadata = summary.metadata || {};
            if (metadata.__symbolic === 'class') {
                // For classes, we keep everything except their class decorators.
                // We need to keep e.g. the ctor args, method names, method decorators
                // so that the class can be extended in another compilation unit.
                // We don't keep the class decorators as
                // 1) they refer to data
                //   that should not cause a rebuild of downstream compilation units
                //   (e.g. inline templates of @Component, or @NgModule.declarations)
                // 2) their data is already captured in TypeSummaries, e.g. DirectiveSummary.
                const clone = {};
                Object.keys(metadata).forEach((propName) => {
                    if (propName !== 'decorators') {
                        clone[propName] = metadata[propName];
                    }
                });
                metadata = clone;
            }
            else if (isCall(metadata)) {
                if (!isFunctionCall(metadata) && !isMethodCallOnVariable(metadata)) {
                    // Don't store complex calls as we won't be able to simplify them anyways later on.
                    metadata = {
                        __symbolic: 'error',
                        message: 'Complex function calls are not supported.',
                    };
                }
            }
            // Note: We need to keep storing ctor calls for e.g.
            // `export const x = new InjectionToken(...)`
            unprocessedSummary.metadata = metadata;
            processedSummary.metadata = this.processValue(metadata, 1 /* ResolveValue */);
            if (metadata instanceof StaticSymbol &&
                this.summaryResolver.isLibraryFile(metadata.filePath)) {
                const declarationSymbol = this.symbols[this.indexBySymbol.get(metadata)];
                if (!isLoweredSymbol(declarationSymbol.name)) {
                    // Note: symbols that were introduced during codegen in the user file can have a reexport
                    // if a user used `export *`. However, we can't rely on this as tsickle will change
                    // `export *` into named exports, using only the information from the typechecker.
                    // As we introduce the new symbols after typecheck, Tsickle does not know about them,
                    // and omits them when expanding `export *`.
                    // So we have to keep reexporting these symbols manually via .ngfactory files.
                    this.reexportedBy.set(declarationSymbol, summary.symbol);
                }
            }
        }
        if (!unprocessedSummary.type && summary.type) {
            unprocessedSummary.type = summary.type;
            // Note: We don't add the summaries of all referenced symbols as for the ResolvedSymbols,
            // as the type summaries already contain the transitive data that they require
            // (in a minimal way).
            processedSummary.type = this.processValue(summary.type, 0 /* None */);
            // except for reexported directives / pipes, so we need to store
            // their summaries explicitly.
            if (summary.type.summaryKind === CompileSummaryKind.NgModule) {
                const ngModuleSummary = summary.type;
                ngModuleSummary.exportedDirectives.concat(ngModuleSummary.exportedPipes).forEach((id) => {
                    const symbol = id.reference;
                    if (this.summaryResolver.isLibraryFile(symbol.filePath) &&
                        !this.unprocessedSymbolSummariesBySymbol.has(symbol)) {
                        const summary = this.summaryResolver.resolveSummary(symbol);
                        if (summary) {
                            this.addSummary(summary);
                        }
                    }
                });
            }
        }
    }
    /**
     * @param createExternalSymbolReexports Whether external static symbols should be re-exported.
     * This can be enabled if external symbols should be re-exported by the current module in
     * order to avoid dynamically generated module dependencies which can break strict dependency
     * enforcements (as in Google3). Read more here: https://github.com/angular/angular/issues/25644
     */
    serialize(createExternalSymbolReexports) {
        const exportAs = [];
        const json = JSON.stringify({
            moduleName: this.moduleName,
            summaries: this.processedSummaries,
            symbols: this.symbols.map((symbol, index) => {
                symbol.assertNoMembers();
                let importAs = undefined;
                if (this.summaryResolver.isLibraryFile(symbol.filePath)) {
                    const reexportSymbol = this.reexportedBy.get(symbol);
                    if (reexportSymbol) {
                        // In case the given external static symbol is already manually exported by the
                        // user, we just proxy the external static symbol reference to the manual export.
                        // This ensures that the AOT compiler imports the external symbol through the
                        // user export and does not introduce another dependency which is not needed.
                        importAs = this.indexBySymbol.get(reexportSymbol);
                    }
                    else if (createExternalSymbolReexports) {
                        // In this case, the given external static symbol is *not* manually exported by
                        // the user, and we manually create a re-export in the factory file so that we
                        // don't introduce another module dependency. This is useful when running within
                        // Bazel so that the AOT compiler does not introduce any module dependencies
                        // which can break the strict dependency enforcement. (e.g. as in Google3)
                        // Read more about this here: https://github.com/angular/angular/issues/25644
                        const summary = this.unprocessedSymbolSummariesBySymbol.get(symbol);
                        if (!summary || !summary.metadata || summary.metadata.__symbolic !== 'interface') {
                            importAs = `${symbol.name}_${index}`;
                            exportAs.push({ symbol, exportAs: importAs });
                        }
                    }
                }
                return {
                    __symbol: index,
                    name: symbol.name,
                    filePath: this.summaryResolver.toSummaryFileName(symbol.filePath, this.srcFileName),
                    importAs: importAs
                };
            })
        });
        return { json, exportAs };
    }
    processValue(value, flags) {
        return visitValue(value, this, flags);
    }
    visitOther(value, context) {
        if (value instanceof StaticSymbol) {
            let baseSymbol = this.symbolResolver.getStaticSymbol(value.filePath, value.name);
            const index = this.visitStaticSymbol(baseSymbol, context);
            return { __symbol: index, members: value.members };
        }
    }
    /**
     * Strip line and character numbers from ngsummaries.
     * Emitting them causes white spaces changes to retrigger upstream
     * recompilations in bazel.
     * TODO: find out a way to have line and character numbers in errors without
     * excessive recompilation in bazel.
     */
    visitStringMap(map, context) {
        if (map['__symbolic'] === 'resolved') {
            return visitValue(map['symbol'], this, context);
        }
        if (map['__symbolic'] === 'error') {
            delete map['line'];
            delete map['character'];
        }
        return super.visitStringMap(map, context);
    }
    /**
     * Returns null if the options.resolveValue is true, and the summary for the symbol
     * resolved to a type or could not be resolved.
     */
    visitStaticSymbol(baseSymbol, flags) {
        let index = this.indexBySymbol.get(baseSymbol);
        let summary = null;
        if (flags & 1 /* ResolveValue */ &&
            this.summaryResolver.isLibraryFile(baseSymbol.filePath)) {
            if (this.unprocessedSymbolSummariesBySymbol.has(baseSymbol)) {
                // the summary for this symbol was already added
                // -> nothing to do.
                return index;
            }
            summary = this.loadSummary(baseSymbol);
            if (summary && summary.metadata instanceof StaticSymbol) {
                // The summary is a reexport
                index = this.visitStaticSymbol(summary.metadata, flags);
                // reset the summary as it is just a reexport, so we don't want to store it.
                summary = null;
            }
        }
        else if (index != null) {
            // Note: == on purpose to compare with undefined!
            // No summary and the symbol is already added -> nothing to do.
            return index;
        }
        // Note: == on purpose to compare with undefined!
        if (index == null) {
            index = this.symbols.length;
            this.symbols.push(baseSymbol);
        }
        this.indexBySymbol.set(baseSymbol, index);
        if (summary) {
            this.addSummary(summary);
        }
        return index;
    }
    loadSummary(symbol) {
        let summary = this.summaryResolver.resolveSummary(symbol);
        if (!summary) {
            // some symbols might originate from a plain typescript library
            // that just exported .d.ts and .metadata.json files, i.e. where no summary
            // files were created.
            const resolvedSymbol = this.symbolResolver.resolveSymbol(symbol);
            if (resolvedSymbol) {
                summary = { symbol: resolvedSymbol.symbol, metadata: resolvedSymbol.metadata };
            }
        }
        return summary;
    }
}
class ForJitSerializer {
    constructor(outputCtx, symbolResolver, summaryResolver) {
        this.outputCtx = outputCtx;
        this.symbolResolver = symbolResolver;
        this.summaryResolver = summaryResolver;
        this.data = [];
    }
    addSourceType(summary, metadata) {
        this.data.push({ summary, metadata, isLibrary: false });
    }
    addLibType(summary) {
        this.data.push({ summary, metadata: null, isLibrary: true });
    }
    serialize(exportAsArr) {
        const exportAsBySymbol = new Map();
        for (const { symbol, exportAs } of exportAsArr) {
            exportAsBySymbol.set(symbol, exportAs);
        }
        const ngModuleSymbols = new Set();
        for (const { summary, metadata, isLibrary } of this.data) {
            if (summary.summaryKind === CompileSummaryKind.NgModule) {
                // collect the symbols that refer to NgModule classes.
                // Note: we can't just rely on `summary.type.summaryKind` to determine this as
                // we don't add the summaries of all referenced symbols when we serialize type summaries.
                // See serializeSummaries for details.
                ngModuleSymbols.add(summary.type.reference);
                const modSummary = summary;
                for (const mod of modSummary.modules) {
                    ngModuleSymbols.add(mod.reference);
                }
            }
            if (!isLibrary) {
                const fnName = summaryForJitName(summary.type.reference.name);
                createSummaryForJitFunction(this.outputCtx, summary.type.reference, this.serializeSummaryWithDeps(summary, metadata));
            }
        }
        ngModuleSymbols.forEach((ngModuleSymbol) => {
            if (this.summaryResolver.isLibraryFile(ngModuleSymbol.filePath)) {
                let exportAs = exportAsBySymbol.get(ngModuleSymbol) || ngModuleSymbol.name;
                const jitExportAsName = summaryForJitName(exportAs);
                this.outputCtx.statements.push(o.variable(jitExportAsName)
                    .set(this.serializeSummaryRef(ngModuleSymbol))
                    .toDeclStmt(null, [o.StmtModifier.Exported]));
            }
        });
    }
    serializeSummaryWithDeps(summary, metadata) {
        const expressions = [this.serializeSummary(summary)];
        let providers = [];
        if (metadata instanceof CompileNgModuleMetadata) {
            expressions.push(...
            // For directives / pipes, we only add the declared ones,
            // and rely on transitively importing NgModules to get the transitive
            // summaries.
            metadata.declaredDirectives.concat(metadata.declaredPipes)
                .map(type => type.reference)
                // For modules,
                // we also add the summaries for modules
                // from libraries.
                // This is ok as we produce reexports for all transitive modules.
                .concat(metadata.transitiveModule.modules.map(type => type.reference)
                .filter(ref => ref !== metadata.type.reference))
                .map((ref) => this.serializeSummaryRef(ref)));
            // Note: We don't use `NgModuleSummary.providers`, as that one is transitive,
            // and we already have transitive modules.
            providers = metadata.providers;
        }
        else if (summary.summaryKind === CompileSummaryKind.Directive) {
            const dirSummary = summary;
            providers = dirSummary.providers.concat(dirSummary.viewProviders);
        }
        // Note: We can't just refer to the `ngsummary.ts` files for `useClass` providers (as we do for
        // declaredDirectives / declaredPipes), as we allow
        // providers without ctor arguments to skip the `@Injectable` decorator,
        // i.e. we didn't generate .ngsummary.ts files for these.
        expressions.push(...providers.filter(provider => !!provider.useClass).map(provider => this.serializeSummary({
            summaryKind: CompileSummaryKind.Injectable,
            type: provider.useClass
        })));
        return o.literalArr(expressions);
    }
    serializeSummaryRef(typeSymbol) {
        const jitImportedSymbol = this.symbolResolver.getStaticSymbol(summaryForJitFileName(typeSymbol.filePath), summaryForJitName(typeSymbol.name));
        return this.outputCtx.importExpr(jitImportedSymbol);
    }
    serializeSummary(data) {
        const outputCtx = this.outputCtx;
        class Transformer {
            visitArray(arr, context) {
                return o.literalArr(arr.map(entry => visitValue(entry, this, context)));
            }
            visitStringMap(map, context) {
                return new o.LiteralMapExpr(Object.keys(map).map((key) => new o.LiteralMapEntry(key, visitValue(map[key], this, context), false)));
            }
            visitPrimitive(value, context) {
                return o.literal(value);
            }
            visitOther(value, context) {
                if (value instanceof StaticSymbol) {
                    return outputCtx.importExpr(value);
                }
                else {
                    throw new Error(`Illegal State: Encountered value ${value}`);
                }
            }
        }
        return visitValue(data, new Transformer(), null);
    }
}
class FromJsonDeserializer extends ValueTransformer {
    constructor(symbolCache, summaryResolver) {
        super();
        this.symbolCache = symbolCache;
        this.summaryResolver = summaryResolver;
    }
    deserialize(libraryFileName, json) {
        const data = JSON.parse(json);
        const allImportAs = [];
        this.symbols = data.symbols.map((serializedSymbol) => this.symbolCache.get(this.summaryResolver.fromSummaryFileName(serializedSymbol.filePath, libraryFileName), serializedSymbol.name));
        data.symbols.forEach((serializedSymbol, index) => {
            const symbol = this.symbols[index];
            const importAs = serializedSymbol.importAs;
            if (typeof importAs === 'number') {
                allImportAs.push({ symbol, importAs: this.symbols[importAs] });
            }
            else if (typeof importAs === 'string') {
                allImportAs.push({ symbol, importAs: this.symbolCache.get(ngfactoryFilePath(libraryFileName), importAs) });
            }
        });
        const summaries = visitValue(data.summaries, this, null);
        return { moduleName: data.moduleName, summaries, importAs: allImportAs };
    }
    visitStringMap(map, context) {
        if ('__symbol' in map) {
            const baseSymbol = this.symbols[map['__symbol']];
            const members = map['members'];
            return members.length ? this.symbolCache.get(baseSymbol.filePath, baseSymbol.name, members) :
                baseSymbol;
        }
        else {
            return super.visitStringMap(map, context);
        }
    }
}
function isCall(metadata) {
    return metadata && metadata.__symbolic === 'call';
}
function isFunctionCall(metadata) {
    return isCall(metadata) && unwrapResolvedMetadata(metadata.expression) instanceof StaticSymbol;
}
function isMethodCallOnVariable(metadata) {
    return isCall(metadata) && metadata.expression && metadata.expression.__symbolic === 'select' &&
        unwrapResolvedMetadata(metadata.expression.expression) instanceof StaticSymbol;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"summary_serializer.js","sourceRoot":"","sources":["../../../../../../../packages/compiler/src/aot/summary_serializer.ts"],"names":[],"mappings":"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","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 */\nimport {CompileDirectiveMetadata, CompileDirectiveSummary, CompileNgModuleMetadata, CompileNgModuleSummary, CompilePipeMetadata, CompileProviderMetadata, CompileSummaryKind, CompileTypeMetadata, CompileTypeSummary} from '../compile_metadata';\nimport {OutputContext} from '../constant_pool';\nimport * as o from '../output/output_ast';\nimport {Summary, SummaryResolver} from '../summary_resolver';\nimport {ValueTransformer, ValueVisitor, visitValue} from '../util';\n\nimport {StaticSymbol, StaticSymbolCache} from './static_symbol';\nimport {ResolvedStaticSymbol, StaticSymbolResolver, unwrapResolvedMetadata} from './static_symbol_resolver';\nimport {isLoweredSymbol, ngfactoryFilePath, summaryForJitFileName, summaryForJitName} from './util';\n\nexport function serializeSummaries(\n    srcFileName: string, forJitCtx: OutputContext|null,\n    summaryResolver: SummaryResolver<StaticSymbol>, symbolResolver: StaticSymbolResolver,\n    symbols: ResolvedStaticSymbol[], types: {\n      summary: CompileTypeSummary,\n      metadata: CompileNgModuleMetadata|CompileDirectiveMetadata|CompilePipeMetadata|\n      CompileTypeMetadata\n    }[],\n    createExternalSymbolReexports =\n        false): {json: string, exportAs: {symbol: StaticSymbol, exportAs: string}[]} {\n  const toJsonSerializer = new ToJsonSerializer(symbolResolver, summaryResolver, srcFileName);\n\n  // for symbols, we use everything except for the class metadata itself\n  // (we keep the statics though), as the class metadata is contained in the\n  // CompileTypeSummary.\n  symbols.forEach(\n      (resolvedSymbol) => toJsonSerializer.addSummary(\n          {symbol: resolvedSymbol.symbol, metadata: resolvedSymbol.metadata}));\n\n  // Add type summaries.\n  types.forEach(({summary, metadata}) => {\n    toJsonSerializer.addSummary(\n        {symbol: summary.type.reference, metadata: undefined, type: summary});\n  });\n  const {json, exportAs} = toJsonSerializer.serialize(createExternalSymbolReexports);\n  if (forJitCtx) {\n    const forJitSerializer = new ForJitSerializer(forJitCtx, symbolResolver, summaryResolver);\n    types.forEach(({summary, metadata}) => {\n      forJitSerializer.addSourceType(summary, metadata);\n    });\n    toJsonSerializer.unprocessedSymbolSummariesBySymbol.forEach((summary) => {\n      if (summaryResolver.isLibraryFile(summary.symbol.filePath) && summary.type) {\n        forJitSerializer.addLibType(summary.type);\n      }\n    });\n    forJitSerializer.serialize(exportAs);\n  }\n  return {json, exportAs};\n}\n\nexport function deserializeSummaries(\n    symbolCache: StaticSymbolCache, summaryResolver: SummaryResolver<StaticSymbol>,\n    libraryFileName: string, json: string): {\n  moduleName: string|null,\n  summaries: Summary<StaticSymbol>[],\n  importAs: {symbol: StaticSymbol, importAs: StaticSymbol}[]\n} {\n  const deserializer = new FromJsonDeserializer(symbolCache, summaryResolver);\n  return deserializer.deserialize(libraryFileName, json);\n}\n\nexport function createForJitStub(outputCtx: OutputContext, reference: StaticSymbol) {\n  return createSummaryForJitFunction(outputCtx, reference, o.NULL_EXPR);\n}\n\nfunction createSummaryForJitFunction(\n    outputCtx: OutputContext, reference: StaticSymbol, value: o.Expression) {\n  const fnName = summaryForJitName(reference.name);\n  outputCtx.statements.push(\n      o.fn([], [new o.ReturnStatement(value)], new o.ArrayType(o.DYNAMIC_TYPE)).toDeclStmt(fnName, [\n        o.StmtModifier.Final, o.StmtModifier.Exported\n      ]));\n}\n\nconst enum SerializationFlags {\n  None = 0,\n  ResolveValue = 1,\n}\n\nclass ToJsonSerializer extends ValueTransformer {\n  // Note: This only contains symbols without members.\n  private symbols: StaticSymbol[] = [];\n  private indexBySymbol = new Map<StaticSymbol, number>();\n  private reexportedBy = new Map<StaticSymbol, StaticSymbol>();\n  // This now contains a `__symbol: number` in the place of\n  // StaticSymbols, but otherwise has the same shape as the original objects.\n  private processedSummaryBySymbol = new Map<StaticSymbol, any>();\n  private processedSummaries: any[] = [];\n  private moduleName: string|null;\n\n  unprocessedSymbolSummariesBySymbol = new Map<StaticSymbol, Summary<StaticSymbol>>();\n\n  constructor(\n      private symbolResolver: StaticSymbolResolver,\n      private summaryResolver: SummaryResolver<StaticSymbol>, private srcFileName: string) {\n    super();\n    this.moduleName = symbolResolver.getKnownModuleName(srcFileName);\n  }\n\n  addSummary(summary: Summary<StaticSymbol>) {\n    let unprocessedSummary = this.unprocessedSymbolSummariesBySymbol.get(summary.symbol);\n    let processedSummary = this.processedSummaryBySymbol.get(summary.symbol);\n    if (!unprocessedSummary) {\n      unprocessedSummary = {symbol: summary.symbol, metadata: undefined};\n      this.unprocessedSymbolSummariesBySymbol.set(summary.symbol, unprocessedSummary);\n      processedSummary = {symbol: this.processValue(summary.symbol, SerializationFlags.None)};\n      this.processedSummaries.push(processedSummary);\n      this.processedSummaryBySymbol.set(summary.symbol, processedSummary);\n    }\n    if (!unprocessedSummary.metadata && summary.metadata) {\n      let metadata = summary.metadata || {};\n      if (metadata.__symbolic === 'class') {\n        // For classes, we keep everything except their class decorators.\n        // We need to keep e.g. the ctor args, method names, method decorators\n        // so that the class can be extended in another compilation unit.\n        // We don't keep the class decorators as\n        // 1) they refer to data\n        //   that should not cause a rebuild of downstream compilation units\n        //   (e.g. inline templates of @Component, or @NgModule.declarations)\n        // 2) their data is already captured in TypeSummaries, e.g. DirectiveSummary.\n        const clone: {[key: string]: any} = {};\n        Object.keys(metadata).forEach((propName) => {\n          if (propName !== 'decorators') {\n            clone[propName] = metadata[propName];\n          }\n        });\n        metadata = clone;\n      } else if (isCall(metadata)) {\n        if (!isFunctionCall(metadata) && !isMethodCallOnVariable(metadata)) {\n          // Don't store complex calls as we won't be able to simplify them anyways later on.\n          metadata = {\n            __symbolic: 'error',\n            message: 'Complex function calls are not supported.',\n          };\n        }\n      }\n      // Note: We need to keep storing ctor calls for e.g.\n      // `export const x = new InjectionToken(...)`\n      unprocessedSummary.metadata = metadata;\n      processedSummary.metadata = this.processValue(metadata, SerializationFlags.ResolveValue);\n      if (metadata instanceof StaticSymbol &&\n          this.summaryResolver.isLibraryFile(metadata.filePath)) {\n        const declarationSymbol = this.symbols[this.indexBySymbol.get(metadata)!];\n        if (!isLoweredSymbol(declarationSymbol.name)) {\n          // Note: symbols that were introduced during codegen in the user file can have a reexport\n          // if a user used `export *`. However, we can't rely on this as tsickle will change\n          // `export *` into named exports, using only the information from the typechecker.\n          // As we introduce the new symbols after typecheck, Tsickle does not know about them,\n          // and omits them when expanding `export *`.\n          // So we have to keep reexporting these symbols manually via .ngfactory files.\n          this.reexportedBy.set(declarationSymbol, summary.symbol);\n        }\n      }\n    }\n    if (!unprocessedSummary.type && summary.type) {\n      unprocessedSummary.type = summary.type;\n      // Note: We don't add the summaries of all referenced symbols as for the ResolvedSymbols,\n      // as the type summaries already contain the transitive data that they require\n      // (in a minimal way).\n      processedSummary.type = this.processValue(summary.type, SerializationFlags.None);\n      // except for reexported directives / pipes, so we need to store\n      // their summaries explicitly.\n      if (summary.type.summaryKind === CompileSummaryKind.NgModule) {\n        const ngModuleSummary = <CompileNgModuleSummary>summary.type;\n        ngModuleSummary.exportedDirectives.concat(ngModuleSummary.exportedPipes).forEach((id) => {\n          const symbol: StaticSymbol = id.reference;\n          if (this.summaryResolver.isLibraryFile(symbol.filePath) &&\n              !this.unprocessedSymbolSummariesBySymbol.has(symbol)) {\n            const summary = this.summaryResolver.resolveSummary(symbol);\n            if (summary) {\n              this.addSummary(summary);\n            }\n          }\n        });\n      }\n    }\n  }\n\n  /**\n   * @param createExternalSymbolReexports Whether external static symbols should be re-exported.\n   * This can be enabled if external symbols should be re-exported by the current module in\n   * order to avoid dynamically generated module dependencies which can break strict dependency\n   * enforcements (as in Google3). Read more here: https://github.com/angular/angular/issues/25644\n   */\n  serialize(createExternalSymbolReexports: boolean):\n      {json: string, exportAs: {symbol: StaticSymbol, exportAs: string}[]} {\n    const exportAs: {symbol: StaticSymbol, exportAs: string}[] = [];\n    const json = JSON.stringify({\n      moduleName: this.moduleName,\n      summaries: this.processedSummaries,\n      symbols: this.symbols.map((symbol, index) => {\n        symbol.assertNoMembers();\n        let importAs: string|number = undefined!;\n        if (this.summaryResolver.isLibraryFile(symbol.filePath)) {\n          const reexportSymbol = this.reexportedBy.get(symbol);\n          if (reexportSymbol) {\n            // In case the given external static symbol is already manually exported by the\n            // user, we just proxy the external static symbol reference to the manual export.\n            // This ensures that the AOT compiler imports the external symbol through the\n            // user export and does not introduce another dependency which is not needed.\n            importAs = this.indexBySymbol.get(reexportSymbol)!;\n          } else if (createExternalSymbolReexports) {\n            // In this case, the given external static symbol is *not* manually exported by\n            // the user, and we manually create a re-export in the factory file so that we\n            // don't introduce another module dependency. This is useful when running within\n            // Bazel so that the AOT compiler does not introduce any module dependencies\n            // which can break the strict dependency enforcement. (e.g. as in Google3)\n            // Read more about this here: https://github.com/angular/angular/issues/25644\n            const summary = this.unprocessedSymbolSummariesBySymbol.get(symbol);\n            if (!summary || !summary.metadata || summary.metadata.__symbolic !== 'interface') {\n              importAs = `${symbol.name}_${index}`;\n              exportAs.push({symbol, exportAs: importAs});\n            }\n          }\n        }\n        return {\n          __symbol: index,\n          name: symbol.name,\n          filePath: this.summaryResolver.toSummaryFileName(symbol.filePath, this.srcFileName),\n          importAs: importAs\n        };\n      })\n    });\n    return {json, exportAs};\n  }\n\n  private processValue(value: any, flags: SerializationFlags): any {\n    return visitValue(value, this, flags);\n  }\n\n  override visitOther(value: any, context: any): any {\n    if (value instanceof StaticSymbol) {\n      let baseSymbol = this.symbolResolver.getStaticSymbol(value.filePath, value.name);\n      const index = this.visitStaticSymbol(baseSymbol, context);\n      return {__symbol: index, members: value.members};\n    }\n  }\n\n  /**\n   * Strip line and character numbers from ngsummaries.\n   * Emitting them causes white spaces changes to retrigger upstream\n   * recompilations in bazel.\n   * TODO: find out a way to have line and character numbers in errors without\n   * excessive recompilation in bazel.\n   */\n  override visitStringMap(map: {[key: string]: any}, context: any): any {\n    if (map['__symbolic'] === 'resolved') {\n      return visitValue(map['symbol'], this, context);\n    }\n    if (map['__symbolic'] === 'error') {\n      delete map['line'];\n      delete map['character'];\n    }\n    return super.visitStringMap(map, context);\n  }\n\n  /**\n   * Returns null if the options.resolveValue is true, and the summary for the symbol\n   * resolved to a type or could not be resolved.\n   */\n  private visitStaticSymbol(baseSymbol: StaticSymbol, flags: SerializationFlags): number {\n    let index: number|undefined|null = this.indexBySymbol.get(baseSymbol);\n    let summary: Summary<StaticSymbol>|null = null;\n    if (flags & SerializationFlags.ResolveValue &&\n        this.summaryResolver.isLibraryFile(baseSymbol.filePath)) {\n      if (this.unprocessedSymbolSummariesBySymbol.has(baseSymbol)) {\n        // the summary for this symbol was already added\n        // -> nothing to do.\n        return index!;\n      }\n      summary = this.loadSummary(baseSymbol);\n      if (summary && summary.metadata instanceof StaticSymbol) {\n        // The summary is a reexport\n        index = this.visitStaticSymbol(summary.metadata, flags);\n        // reset the summary as it is just a reexport, so we don't want to store it.\n        summary = null;\n      }\n    } else if (index != null) {\n      // Note: == on purpose to compare with undefined!\n      // No summary and the symbol is already added -> nothing to do.\n      return index;\n    }\n    // Note: == on purpose to compare with undefined!\n    if (index == null) {\n      index = this.symbols.length;\n      this.symbols.push(baseSymbol);\n    }\n    this.indexBySymbol.set(baseSymbol, index);\n    if (summary) {\n      this.addSummary(summary);\n    }\n    return index;\n  }\n\n  private loadSummary(symbol: StaticSymbol): Summary<StaticSymbol>|null {\n    let summary = this.summaryResolver.resolveSummary(symbol);\n    if (!summary) {\n      // some symbols might originate from a plain typescript library\n      // that just exported .d.ts and .metadata.json files, i.e. where no summary\n      // files were created.\n      const resolvedSymbol = this.symbolResolver.resolveSymbol(symbol);\n      if (resolvedSymbol) {\n        summary = {symbol: resolvedSymbol.symbol, metadata: resolvedSymbol.metadata};\n      }\n    }\n    return summary;\n  }\n}\n\nclass ForJitSerializer {\n  private data: Array<{\n    summary: CompileTypeSummary,\n    metadata: CompileNgModuleMetadata|CompileDirectiveMetadata|CompilePipeMetadata|\n    CompileTypeMetadata|null,\n    isLibrary: boolean\n  }> = [];\n\n  constructor(\n      private outputCtx: OutputContext, private symbolResolver: StaticSymbolResolver,\n      private summaryResolver: SummaryResolver<StaticSymbol>) {}\n\n  addSourceType(\n      summary: CompileTypeSummary,\n      metadata: CompileNgModuleMetadata|CompileDirectiveMetadata|CompilePipeMetadata|\n      CompileTypeMetadata) {\n    this.data.push({summary, metadata, isLibrary: false});\n  }\n\n  addLibType(summary: CompileTypeSummary) {\n    this.data.push({summary, metadata: null, isLibrary: true});\n  }\n\n  serialize(exportAsArr: {symbol: StaticSymbol, exportAs: string}[]): void {\n    const exportAsBySymbol = new Map<StaticSymbol, string>();\n    for (const {symbol, exportAs} of exportAsArr) {\n      exportAsBySymbol.set(symbol, exportAs);\n    }\n    const ngModuleSymbols = new Set<StaticSymbol>();\n\n    for (const {summary, metadata, isLibrary} of this.data) {\n      if (summary.summaryKind === CompileSummaryKind.NgModule) {\n        // collect the symbols that refer to NgModule classes.\n        // Note: we can't just rely on `summary.type.summaryKind` to determine this as\n        // we don't add the summaries of all referenced symbols when we serialize type summaries.\n        // See serializeSummaries for details.\n        ngModuleSymbols.add(summary.type.reference);\n        const modSummary = <CompileNgModuleSummary>summary;\n        for (const mod of modSummary.modules) {\n          ngModuleSymbols.add(mod.reference);\n        }\n      }\n      if (!isLibrary) {\n        const fnName = summaryForJitName(summary.type.reference.name);\n        createSummaryForJitFunction(\n            this.outputCtx, summary.type.reference,\n            this.serializeSummaryWithDeps(summary, metadata!));\n      }\n    }\n\n    ngModuleSymbols.forEach((ngModuleSymbol) => {\n      if (this.summaryResolver.isLibraryFile(ngModuleSymbol.filePath)) {\n        let exportAs = exportAsBySymbol.get(ngModuleSymbol) || ngModuleSymbol.name;\n        const jitExportAsName = summaryForJitName(exportAs);\n        this.outputCtx.statements.push(o.variable(jitExportAsName)\n                                           .set(this.serializeSummaryRef(ngModuleSymbol))\n                                           .toDeclStmt(null, [o.StmtModifier.Exported]));\n      }\n    });\n  }\n\n  private serializeSummaryWithDeps(\n      summary: CompileTypeSummary,\n      metadata: CompileNgModuleMetadata|CompileDirectiveMetadata|CompilePipeMetadata|\n      CompileTypeMetadata): o.Expression {\n    const expressions: o.Expression[] = [this.serializeSummary(summary)];\n    let providers: CompileProviderMetadata[] = [];\n    if (metadata instanceof CompileNgModuleMetadata) {\n      expressions.push(...\n                       // For directives / pipes, we only add the declared ones,\n                       // and rely on transitively importing NgModules to get the transitive\n                       // summaries.\n                       metadata.declaredDirectives.concat(metadata.declaredPipes)\n                           .map(type => type.reference)\n                           // For modules,\n                           // we also add the summaries for modules\n                           // from libraries.\n                           // This is ok as we produce reexports for all transitive modules.\n                           .concat(metadata.transitiveModule.modules.map(type => type.reference)\n                                       .filter(ref => ref !== metadata.type.reference))\n                           .map((ref) => this.serializeSummaryRef(ref)));\n      // Note: We don't use `NgModuleSummary.providers`, as that one is transitive,\n      // and we already have transitive modules.\n      providers = metadata.providers;\n    } else if (summary.summaryKind === CompileSummaryKind.Directive) {\n      const dirSummary = <CompileDirectiveSummary>summary;\n      providers = dirSummary.providers.concat(dirSummary.viewProviders);\n    }\n    // Note: We can't just refer to the `ngsummary.ts` files for `useClass` providers (as we do for\n    // declaredDirectives / declaredPipes), as we allow\n    // providers without ctor arguments to skip the `@Injectable` decorator,\n    // i.e. we didn't generate .ngsummary.ts files for these.\n    expressions.push(\n        ...providers.filter(provider => !!provider.useClass).map(provider => this.serializeSummary({\n          summaryKind: CompileSummaryKind.Injectable,\n          type: provider.useClass\n        } as CompileTypeSummary)));\n    return o.literalArr(expressions);\n  }\n\n  private serializeSummaryRef(typeSymbol: StaticSymbol): o.Expression {\n    const jitImportedSymbol = this.symbolResolver.getStaticSymbol(\n        summaryForJitFileName(typeSymbol.filePath), summaryForJitName(typeSymbol.name));\n    return this.outputCtx.importExpr(jitImportedSymbol);\n  }\n\n  private serializeSummary(data: {[key: string]: any}): o.Expression {\n    const outputCtx = this.outputCtx;\n\n    class Transformer implements ValueVisitor {\n      visitArray(arr: any[], context: any): any {\n        return o.literalArr(arr.map(entry => visitValue(entry, this, context)));\n      }\n      visitStringMap(map: {[key: string]: any}, context: any): any {\n        return new o.LiteralMapExpr(Object.keys(map).map(\n            (key) => new o.LiteralMapEntry(key, visitValue(map[key], this, context), false)));\n      }\n      visitPrimitive(value: any, context: any): any {\n        return o.literal(value);\n      }\n      visitOther(value: any, context: any): any {\n        if (value instanceof StaticSymbol) {\n          return outputCtx.importExpr(value);\n        } else {\n          throw new Error(`Illegal State: Encountered value ${value}`);\n        }\n      }\n    }\n\n    return visitValue(data, new Transformer(), null);\n  }\n}\n\nclass FromJsonDeserializer extends ValueTransformer {\n  // TODO(issue/24571): remove '!'.\n  private symbols!: StaticSymbol[];\n\n  constructor(\n      private symbolCache: StaticSymbolCache,\n      private summaryResolver: SummaryResolver<StaticSymbol>) {\n    super();\n  }\n\n  deserialize(libraryFileName: string, json: string): {\n    moduleName: string|null,\n    summaries: Summary<StaticSymbol>[],\n    importAs: {symbol: StaticSymbol, importAs: StaticSymbol}[]\n  } {\n    const data = JSON.parse(json) as {moduleName: string | null, summaries: any[], symbols: any[]};\n    const allImportAs: {symbol: StaticSymbol, importAs: StaticSymbol}[] = [];\n    this.symbols = data.symbols.map(\n        (serializedSymbol) => this.symbolCache.get(\n            this.summaryResolver.fromSummaryFileName(serializedSymbol.filePath, libraryFileName),\n            serializedSymbol.name));\n    data.symbols.forEach((serializedSymbol, index) => {\n      const symbol = this.symbols[index];\n      const importAs = serializedSymbol.importAs;\n      if (typeof importAs === 'number') {\n        allImportAs.push({symbol, importAs: this.symbols[importAs]});\n      } else if (typeof importAs === 'string') {\n        allImportAs.push(\n            {symbol, importAs: this.symbolCache.get(ngfactoryFilePath(libraryFileName), importAs)});\n      }\n    });\n    const summaries = visitValue(data.summaries, this, null) as Summary<StaticSymbol>[];\n    return {moduleName: data.moduleName, summaries, importAs: allImportAs};\n  }\n\n  override visitStringMap(map: {[key: string]: any}, context: any): any {\n    if ('__symbol' in map) {\n      const baseSymbol = this.symbols[map['__symbol']];\n      const members = map['members'];\n      return members.length ? this.symbolCache.get(baseSymbol.filePath, baseSymbol.name, members) :\n                              baseSymbol;\n    } else {\n      return super.visitStringMap(map, context);\n    }\n  }\n}\n\nfunction isCall(metadata: any): boolean {\n  return metadata && metadata.__symbolic === 'call';\n}\n\nfunction isFunctionCall(metadata: any): boolean {\n  return isCall(metadata) && unwrapResolvedMetadata(metadata.expression) instanceof StaticSymbol;\n}\n\nfunction isMethodCallOnVariable(metadata: any): boolean {\n  return isCall(metadata) && metadata.expression && metadata.expression.__symbolic === 'select' &&\n      unwrapResolvedMetadata(metadata.expression.expression) instanceof StaticSymbol;\n}\n"]}