source: trip-planner-front/node_modules/@angular/compiler-cli/src/ngtsc/core/src/compiler.js@ 6a3a178

/**
 * @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/ngtsc/core/src/compiler", ["require", "exports", "tslib", "typescript", "@angular/compiler-cli/src/ngtsc/annotations", "@angular/compiler-cli/src/ngtsc/cycles", "@angular/compiler-cli/src/ngtsc/diagnostics", "@angular/compiler-cli/src/ngtsc/entry_point", "@angular/compiler-cli/src/ngtsc/file_system", "@angular/compiler-cli/src/ngtsc/imports", "@angular/compiler-cli/src/ngtsc/incremental", "@angular/compiler-cli/src/ngtsc/indexer", "@angular/compiler-cli/src/ngtsc/metadata", "@angular/compiler-cli/src/ngtsc/partial_evaluator", "@angular/compiler-cli/src/ngtsc/perf", "@angular/compiler-cli/src/ngtsc/reflection", "@angular/compiler-cli/src/ngtsc/resource", "@angular/compiler-cli/src/ngtsc/routing", "@angular/compiler-cli/src/ngtsc/scope", "@angular/compiler-cli/src/ngtsc/shims", "@angular/compiler-cli/src/ngtsc/switch", "@angular/compiler-cli/src/ngtsc/transform", "@angular/compiler-cli/src/ngtsc/typecheck", "@angular/compiler-cli/src/ngtsc/typecheck/api", "@angular/compiler-cli/src/ngtsc/typecheck/extended", "@angular/compiler-cli/src/ngtsc/typecheck/extended/checks/invalid_banana_in_box", "@angular/compiler-cli/src/ngtsc/typecheck/extended/checks/nullish_coalescing_not_nullable", "@angular/compiler-cli/src/ngtsc/util/src/typescript"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.isAngularCorePackage = exports.NgCompiler = exports.resourceChangeTicket = exports.incrementalFromStateTicket = exports.incrementalFromCompilerTicket = exports.freshCompilationTicket = exports.CompilationTicketKind = void 0;
    var tslib_1 = require("tslib");
    var ts = require("typescript");
    var annotations_1 = require("@angular/compiler-cli/src/ngtsc/annotations");
    var cycles_1 = require("@angular/compiler-cli/src/ngtsc/cycles");
    var diagnostics_1 = require("@angular/compiler-cli/src/ngtsc/diagnostics");
    var entry_point_1 = require("@angular/compiler-cli/src/ngtsc/entry_point");
    var file_system_1 = require("@angular/compiler-cli/src/ngtsc/file_system");
    var imports_1 = require("@angular/compiler-cli/src/ngtsc/imports");
    var incremental_1 = require("@angular/compiler-cli/src/ngtsc/incremental");
    var indexer_1 = require("@angular/compiler-cli/src/ngtsc/indexer");
    var metadata_1 = require("@angular/compiler-cli/src/ngtsc/metadata");
    var partial_evaluator_1 = require("@angular/compiler-cli/src/ngtsc/partial_evaluator");
    var perf_1 = require("@angular/compiler-cli/src/ngtsc/perf");
    var reflection_1 = require("@angular/compiler-cli/src/ngtsc/reflection");
    var resource_1 = require("@angular/compiler-cli/src/ngtsc/resource");
    var routing_1 = require("@angular/compiler-cli/src/ngtsc/routing");
    var scope_1 = require("@angular/compiler-cli/src/ngtsc/scope");
    var shims_1 = require("@angular/compiler-cli/src/ngtsc/shims");
    var switch_1 = require("@angular/compiler-cli/src/ngtsc/switch");
    var transform_1 = require("@angular/compiler-cli/src/ngtsc/transform");
    var typecheck_1 = require("@angular/compiler-cli/src/ngtsc/typecheck");
    var api_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/api");
    var extended_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/extended");
    var invalid_banana_in_box_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/extended/checks/invalid_banana_in_box");
    var nullish_coalescing_not_nullable_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/extended/checks/nullish_coalescing_not_nullable");
    var typescript_1 = require("@angular/compiler-cli/src/ngtsc/util/src/typescript");
    /**
     * Discriminant type for a `CompilationTicket`.
     */
    var CompilationTicketKind;
    (function (CompilationTicketKind) {
        CompilationTicketKind[CompilationTicketKind["Fresh"] = 0] = "Fresh";
        CompilationTicketKind[CompilationTicketKind["IncrementalTypeScript"] = 1] = "IncrementalTypeScript";
        CompilationTicketKind[CompilationTicketKind["IncrementalResource"] = 2] = "IncrementalResource";
    })(CompilationTicketKind = exports.CompilationTicketKind || (exports.CompilationTicketKind = {}));
    /**
     * Create a `CompilationTicket` for a brand new compilation, using no prior state.
     */
    function freshCompilationTicket(tsProgram, options, incrementalBuildStrategy, programDriver, perfRecorder, enableTemplateTypeChecker, usePoisonedData) {
        return {
            kind: CompilationTicketKind.Fresh,
            tsProgram: tsProgram,
            options: options,
            incrementalBuildStrategy: incrementalBuildStrategy,
            programDriver: programDriver,
            enableTemplateTypeChecker: enableTemplateTypeChecker,
            usePoisonedData: usePoisonedData,
            perfRecorder: perfRecorder !== null && perfRecorder !== void 0 ? perfRecorder : perf_1.ActivePerfRecorder.zeroedToNow(),
        };
    }
    exports.freshCompilationTicket = freshCompilationTicket;
    /**
     * Create a `CompilationTicket` as efficiently as possible, based on a previous `NgCompiler`
     * instance and a new `ts.Program`.
     */
    function incrementalFromCompilerTicket(oldCompiler, newProgram, incrementalBuildStrategy, programDriver, modifiedResourceFiles, perfRecorder) {
        var oldProgram = oldCompiler.getCurrentProgram();
        var oldState = oldCompiler.incrementalStrategy.getIncrementalState(oldProgram);
        if (oldState === null) {
            // No incremental step is possible here, since no IncrementalDriver was found for the old
            // program.
            return freshCompilationTicket(newProgram, oldCompiler.options, incrementalBuildStrategy, programDriver, perfRecorder, oldCompiler.enableTemplateTypeChecker, oldCompiler.usePoisonedData);
        }
        if (perfRecorder === null) {
            perfRecorder = perf_1.ActivePerfRecorder.zeroedToNow();
        }
        var incrementalCompilation = incremental_1.IncrementalCompilation.incremental(newProgram, versionMapFromProgram(newProgram, programDriver), oldProgram, oldState, modifiedResourceFiles, perfRecorder);
        return {
            kind: CompilationTicketKind.IncrementalTypeScript,
            enableTemplateTypeChecker: oldCompiler.enableTemplateTypeChecker,
            usePoisonedData: oldCompiler.usePoisonedData,
            options: oldCompiler.options,
            incrementalBuildStrategy: incrementalBuildStrategy,
            incrementalCompilation: incrementalCompilation,
            programDriver: programDriver,
            newProgram: newProgram,
            perfRecorder: perfRecorder,
        };
    }
    exports.incrementalFromCompilerTicket = incrementalFromCompilerTicket;
    /**
     * Create a `CompilationTicket` directly from an old `ts.Program` and associated Angular compilation
     * state, along with a new `ts.Program`.
     */
    function incrementalFromStateTicket(oldProgram, oldState, newProgram, options, incrementalBuildStrategy, programDriver, modifiedResourceFiles, perfRecorder, enableTemplateTypeChecker, usePoisonedData) {
        if (perfRecorder === null) {
            perfRecorder = perf_1.ActivePerfRecorder.zeroedToNow();
        }
        var incrementalCompilation = incremental_1.IncrementalCompilation.incremental(newProgram, versionMapFromProgram(newProgram, programDriver), oldProgram, oldState, modifiedResourceFiles, perfRecorder);
        return {
            kind: CompilationTicketKind.IncrementalTypeScript,
            newProgram: newProgram,
            options: options,
            incrementalBuildStrategy: incrementalBuildStrategy,
            incrementalCompilation: incrementalCompilation,
            programDriver: programDriver,
            enableTemplateTypeChecker: enableTemplateTypeChecker,
            usePoisonedData: usePoisonedData,
            perfRecorder: perfRecorder,
        };
    }
    exports.incrementalFromStateTicket = incrementalFromStateTicket;
    function resourceChangeTicket(compiler, modifiedResourceFiles) {
        return {
            kind: CompilationTicketKind.IncrementalResource,
            compiler: compiler,
            modifiedResourceFiles: modifiedResourceFiles,
            perfRecorder: perf_1.ActivePerfRecorder.zeroedToNow(),
        };
    }
    exports.resourceChangeTicket = resourceChangeTicket;
    /**
     * The heart of the Angular Ivy compiler.
     *
     * The `NgCompiler` provides an API for performing Angular compilation within a custom TypeScript
     * compiler. Each instance of `NgCompiler` supports a single compilation, which might be
     * incremental.
     *
     * `NgCompiler` is lazy, and does not perform any of the work of the compilation until one of its
     * output methods (e.g. `getDiagnostics`) is called.
     *
     * See the README.md for more information.
     */
    var NgCompiler = /** @class */ (function () {
        function NgCompiler(adapter, options, inputProgram, programDriver, incrementalStrategy, incrementalCompilation, enableTemplateTypeChecker, usePoisonedData, livePerfRecorder) {
            var _a, e_1, _b;
            var _this = this;
            this.adapter = adapter;
            this.options = options;
            this.inputProgram = inputProgram;
            this.programDriver = programDriver;
            this.incrementalStrategy = incrementalStrategy;
            this.incrementalCompilation = incrementalCompilation;
            this.enableTemplateTypeChecker = enableTemplateTypeChecker;
            this.usePoisonedData = usePoisonedData;
            this.livePerfRecorder = livePerfRecorder;
            /**
             * Lazily evaluated state of the compilation.
             *
             * This is created on demand by calling `ensureAnalyzed`.
             */
            this.compilation = null;
            /**
             * Any diagnostics related to the construction of the compilation.
             *
             * These are diagnostics which arose during setup of the host and/or program.
             */
            this.constructionDiagnostics = [];
            /**
             * Non-template diagnostics related to the program itself. Does not include template
             * diagnostics because the template type checker memoizes them itself.
             *
             * This is set by (and memoizes) `getNonTemplateDiagnostics`.
             */
            this.nonTemplateDiagnostics = null;
            /**
             * `NgCompiler` can be reused for multiple compilations (for resource-only changes), and each
             * new compilation uses a fresh `PerfRecorder`. Thus, classes created with a lifespan of the
             * `NgCompiler` use a `DelegatingPerfRecorder` so the `PerfRecorder` they write to can be updated
             * with each fresh compilation.
             */
            this.delegatingPerfRecorder = new perf_1.DelegatingPerfRecorder(this.perfRecorder);
            if (this.options._extendedTemplateDiagnostics === true &&
                this.options.strictTemplates === false) {
                throw new Error('The \'_extendedTemplateDiagnostics\' option requires \'strictTemplates\' to also be enabled.');
            }
            (_a = this.constructionDiagnostics).push.apply(_a, tslib_1.__spreadArray([], tslib_1.__read(this.adapter.constructionDiagnostics)));
            var incompatibleTypeCheckOptionsDiagnostic = verifyCompatibleTypeCheckOptions(this.options);
            if (incompatibleTypeCheckOptionsDiagnostic !== null) {
                this.constructionDiagnostics.push(incompatibleTypeCheckOptionsDiagnostic);
            }
            this.currentProgram = inputProgram;
            this.closureCompilerEnabled = !!this.options.annotateForClosureCompiler;
            this.entryPoint =
                adapter.entryPoint !== null ? typescript_1.getSourceFileOrNull(inputProgram, adapter.entryPoint) : null;
            var moduleResolutionCache = ts.createModuleResolutionCache(this.adapter.getCurrentDirectory(), 
            // doen't retain a reference to `this`, if other closures in the constructor here reference
            // `this` internally then a closure created here would retain them. This can cause major
            // memory leak issues since the `moduleResolutionCache` is a long-lived object and finds its
            // way into all kinds of places inside TS internal objects.
            this.adapter.getCanonicalFileName.bind(this.adapter));
            this.moduleResolver =
                new imports_1.ModuleResolver(inputProgram, this.options, this.adapter, moduleResolutionCache);
            this.resourceManager = new resource_1.AdapterResourceLoader(adapter, this.options);
            this.cycleAnalyzer = new cycles_1.CycleAnalyzer(new cycles_1.ImportGraph(inputProgram.getTypeChecker(), this.delegatingPerfRecorder));
            this.incrementalStrategy.setIncrementalState(this.incrementalCompilation.state, inputProgram);
            this.ignoreForDiagnostics =
                new Set(inputProgram.getSourceFiles().filter(function (sf) { return _this.adapter.isShim(sf); }));
            this.ignoreForEmit = this.adapter.ignoreForEmit;
            var dtsFileCount = 0;
            var nonDtsFileCount = 0;
            try {
                for (var _c = tslib_1.__values(inputProgram.getSourceFiles()), _d = _c.next(); !_d.done; _d = _c.next()) {
                    var sf = _d.value;
                    if (sf.isDeclarationFile) {
                        dtsFileCount++;
                    }
                    else {
                        nonDtsFileCount++;
                    }
                }
            }
            catch (e_1_1) { e_1 = { error: e_1_1 }; }
            finally {
                try {
                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
                }
                finally { if (e_1) throw e_1.error; }
            }
            livePerfRecorder.eventCount(perf_1.PerfEvent.InputDtsFile, dtsFileCount);
            livePerfRecorder.eventCount(perf_1.PerfEvent.InputTsFile, nonDtsFileCount);
        }
        /**
         * Convert a `CompilationTicket` into an `NgCompiler` instance for the requested compilation.
         *
         * Depending on the nature of the compilation request, the `NgCompiler` instance may be reused
         * from a previous compilation and updated with any changes, it may be a new instance which
         * incrementally reuses state from a previous compilation, or it may represent a fresh
         * compilation entirely.
         */
        NgCompiler.fromTicket = function (ticket, adapter) {
            switch (ticket.kind) {
                case CompilationTicketKind.Fresh:
                    return new NgCompiler(adapter, ticket.options, ticket.tsProgram, ticket.programDriver, ticket.incrementalBuildStrategy, incremental_1.IncrementalCompilation.fresh(ticket.tsProgram, versionMapFromProgram(ticket.tsProgram, ticket.programDriver)), ticket.enableTemplateTypeChecker, ticket.usePoisonedData, ticket.perfRecorder);
                case CompilationTicketKind.IncrementalTypeScript:
                    return new NgCompiler(adapter, ticket.options, ticket.newProgram, ticket.programDriver, ticket.incrementalBuildStrategy, ticket.incrementalCompilation, ticket.enableTemplateTypeChecker, ticket.usePoisonedData, ticket.perfRecorder);
                case CompilationTicketKind.IncrementalResource:
                    var compiler = ticket.compiler;
                    compiler.updateWithChangedResources(ticket.modifiedResourceFiles, ticket.perfRecorder);
                    return compiler;
            }
        };
        Object.defineProperty(NgCompiler.prototype, "perfRecorder", {
            get: function () {
                return this.livePerfRecorder;
            },
            enumerable: false,
            configurable: true
        });
        Object.defineProperty(NgCompiler.prototype, "incrementalDriver", {
            /**
             * Exposes the `IncrementalCompilation` under an old property name that the CLI uses, avoiding a
             * chicken-and-egg problem with the rename to `incrementalCompilation`.
             *
             * TODO(alxhub): remove when the CLI uses the new name.
             */
            get: function () {
                return this.incrementalCompilation;
            },
            enumerable: false,
            configurable: true
        });
        NgCompiler.prototype.updateWithChangedResources = function (changedResources, perfRecorder) {
            var _this = this;
            this.livePerfRecorder = perfRecorder;
            this.delegatingPerfRecorder.target = perfRecorder;
            perfRecorder.inPhase(perf_1.PerfPhase.ResourceUpdate, function () {
                var e_2, _a, e_3, _b, e_4, _c, e_5, _d;
                if (_this.compilation === null) {
                    // Analysis hasn't happened yet, so no update is necessary - any changes to resources will
                    // be captured by the inital analysis pass itself.
                    return;
                }
                _this.resourceManager.invalidate();
                var classesToUpdate = new Set();
                try {
                    for (var changedResources_1 = tslib_1.__values(changedResources), changedResources_1_1 = changedResources_1.next(); !changedResources_1_1.done; changedResources_1_1 = changedResources_1.next()) {
                        var resourceFile = changedResources_1_1.value;
                        try {
                            for (var _e = (e_3 = void 0, tslib_1.__values(_this.getComponentsWithTemplateFile(resourceFile))), _f = _e.next(); !_f.done; _f = _e.next()) {
                                var templateClass = _f.value;
                                classesToUpdate.add(templateClass);
                            }
                        }
                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
                        finally {
                            try {
                                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
                            }
                            finally { if (e_3) throw e_3.error; }
                        }
                        try {
                            for (var _g = (e_4 = void 0, tslib_1.__values(_this.getComponentsWithStyleFile(resourceFile))), _h = _g.next(); !_h.done; _h = _g.next()) {
                                var styleClass = _h.value;
                                classesToUpdate.add(styleClass);
                            }
                        }
                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
                        finally {
                            try {
                                if (_h && !_h.done && (_c = _g.return)) _c.call(_g);
                            }
                            finally { if (e_4) throw e_4.error; }
                        }
                    }
                }
                catch (e_2_1) { e_2 = { error: e_2_1 }; }
                finally {
                    try {
                        if (changedResources_1_1 && !changedResources_1_1.done && (_a = changedResources_1.return)) _a.call(changedResources_1);
                    }
                    finally { if (e_2) throw e_2.error; }
                }
                try {
                    for (var classesToUpdate_1 = tslib_1.__values(classesToUpdate), classesToUpdate_1_1 = classesToUpdate_1.next(); !classesToUpdate_1_1.done; classesToUpdate_1_1 = classesToUpdate_1.next()) {
                        var clazz = classesToUpdate_1_1.value;
                        _this.compilation.traitCompiler.updateResources(clazz);
                        if (!ts.isClassDeclaration(clazz)) {
                            continue;
                        }
                        _this.compilation.templateTypeChecker.invalidateClass(clazz);
                    }
                }
                catch (e_5_1) { e_5 = { error: e_5_1 }; }
                finally {
                    try {
                        if (classesToUpdate_1_1 && !classesToUpdate_1_1.done && (_d = classesToUpdate_1.return)) _d.call(classesToUpdate_1);
                    }
                    finally { if (e_5) throw e_5.error; }
                }
            });
        };
        /**
         * Get the resource dependencies of a file.
         *
         * If the file is not part of the compilation, an empty array will be returned.
         */
        NgCompiler.prototype.getResourceDependencies = function (file) {
            this.ensureAnalyzed();
            return this.incrementalCompilation.depGraph.getResourceDependencies(file);
        };
        /**
         * Get all Angular-related diagnostics for this compilation.
         */
        NgCompiler.prototype.getDiagnostics = function () {
            var diagnostics = [];
            diagnostics.push.apply(diagnostics, tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(this.getNonTemplateDiagnostics())), tslib_1.__read(this.getTemplateDiagnostics())));
            if (this.options._extendedTemplateDiagnostics) {
                diagnostics.push.apply(diagnostics, tslib_1.__spreadArray([], tslib_1.__read(this.getExtendedTemplateDiagnostics())));
            }
            return this.addMessageTextDetails(diagnostics);
        };
        /**
         * Get all Angular-related diagnostics for this compilation.
         *
         * If a `ts.SourceFile` is passed, only diagnostics related to that file are returned.
         */
        NgCompiler.prototype.getDiagnosticsForFile = function (file, optimizeFor) {
            var diagnostics = [];
            diagnostics.push.apply(diagnostics, tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(this.getNonTemplateDiagnostics().filter(function (diag) { return diag.file === file; }))), tslib_1.__read(this.getTemplateDiagnosticsForFile(file, optimizeFor))));
            if (this.options._extendedTemplateDiagnostics) {
                diagnostics.push.apply(diagnostics, tslib_1.__spreadArray([], tslib_1.__read(this.getExtendedTemplateDiagnostics(file))));
            }
            return this.addMessageTextDetails(diagnostics);
        };
        /**
         * Get all `ts.Diagnostic`s currently available that pertain to the given component.
         */
        NgCompiler.prototype.getDiagnosticsForComponent = function (component) {
            var compilation = this.ensureAnalyzed();
            var ttc = compilation.templateTypeChecker;
            var diagnostics = [];
            diagnostics.push.apply(diagnostics, tslib_1.__spreadArray([], tslib_1.__read(ttc.getDiagnosticsForComponent(component))));
            if (this.options._extendedTemplateDiagnostics) {
                var extendedTemplateChecker = compilation.extendedTemplateChecker;
                diagnostics.push.apply(diagnostics, tslib_1.__spreadArray([], tslib_1.__read(extendedTemplateChecker.getDiagnosticsForComponent(component))));
            }
            return this.addMessageTextDetails(diagnostics);
        };
        /**
         * Add Angular.io error guide links to diagnostics for this compilation.
         */
        NgCompiler.prototype.addMessageTextDetails = function (diagnostics) {
            return diagnostics.map(function (diag) {
                if (diag.code && diagnostics_1.COMPILER_ERRORS_WITH_GUIDES.has(diagnostics_1.ngErrorCode(diag.code))) {
                    return tslib_1.__assign(tslib_1.__assign({}, diag), { messageText: diag.messageText +
                            (". Find more at " + diagnostics_1.ERROR_DETAILS_PAGE_BASE_URL + "/NG" + diagnostics_1.ngErrorCode(diag.code)) });
                }
                return diag;
            });
        };
        /**
         * Get all setup-related diagnostics for this compilation.
         */
        NgCompiler.prototype.getOptionDiagnostics = function () {
            return this.constructionDiagnostics;
        };
        /**
         * Get the current `ts.Program` known to this `NgCompiler`.
         *
         * Compilation begins with an input `ts.Program`, and during template type-checking operations new
         * `ts.Program`s may be produced using the `ProgramDriver`. The most recent such `ts.Program` to
         * be produced is available here.
         *
         * This `ts.Program` serves two key purposes:
         *
         * * As an incremental starting point for creating the next `ts.Program` based on files that the
         *   user has changed (for clients using the TS compiler program APIs).
         *
         * * As the "before" point for an incremental compilation invocation, to determine what's changed
         *   between the old and new programs (for all compilations).
         */
        NgCompiler.prototype.getCurrentProgram = function () {
            return this.currentProgram;
        };
        NgCompiler.prototype.getTemplateTypeChecker = function () {
            if (!this.enableTemplateTypeChecker) {
                throw new Error('The `TemplateTypeChecker` does not work without `enableTemplateTypeChecker`.');
            }
            return this.ensureAnalyzed().templateTypeChecker;
        };
        /**
         * Retrieves the `ts.Declaration`s for any component(s) which use the given template file.
         */
        NgCompiler.prototype.getComponentsWithTemplateFile = function (templateFilePath) {
            var resourceRegistry = this.ensureAnalyzed().resourceRegistry;
            return resourceRegistry.getComponentsWithTemplate(file_system_1.resolve(templateFilePath));
        };
        /**
         * Retrieves the `ts.Declaration`s for any component(s) which use the given template file.
         */
        NgCompiler.prototype.getComponentsWithStyleFile = function (styleFilePath) {
            var resourceRegistry = this.ensureAnalyzed().resourceRegistry;
            return resourceRegistry.getComponentsWithStyle(file_system_1.resolve(styleFilePath));
        };
        /**
         * Retrieves external resources for the given component.
         */
        NgCompiler.prototype.getComponentResources = function (classDecl) {
            if (!reflection_1.isNamedClassDeclaration(classDecl)) {
                return null;
            }
            var resourceRegistry = this.ensureAnalyzed().resourceRegistry;
            var styles = resourceRegistry.getStyles(classDecl);
            var template = resourceRegistry.getTemplate(classDecl);
            if (template === null) {
                return null;
            }
            return { styles: styles, template: template };
        };
        NgCompiler.prototype.getMeta = function (classDecl) {
            var _a;
            if (!reflection_1.isNamedClassDeclaration(classDecl)) {
                return null;
            }
            var ref = new imports_1.Reference(classDecl);
            var metaReader = this.ensureAnalyzed().metaReader;
            var meta = (_a = metaReader.getPipeMetadata(ref)) !== null && _a !== void 0 ? _a : metaReader.getDirectiveMetadata(ref);
            if (meta === null) {
                return null;
            }
            return meta;
        };
        /**
         * Perform Angular's analysis step (as a precursor to `getDiagnostics` or `prepareEmit`)
         * asynchronously.
         *
         * Normally, this operation happens lazily whenever `getDiagnostics` or `prepareEmit` are called.
         * However, certain consumers may wish to allow for an asynchronous phase of analysis, where
         * resources such as `styleUrls` are resolved asynchonously. In these cases `analyzeAsync` must be
         * called first, and its `Promise` awaited prior to calling any other APIs of `NgCompiler`.
         */
        NgCompiler.prototype.analyzeAsync = function () {
            return tslib_1.__awaiter(this, void 0, void 0, function () {
                var _this = this;
                return tslib_1.__generator(this, function (_a) {
                    switch (_a.label) {
                        case 0:
                            if (this.compilation !== null) {
                                return [2 /*return*/];
                            }
                            return [4 /*yield*/, this.perfRecorder.inPhase(perf_1.PerfPhase.Analysis, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                                    var promises, _a, _b, sf, analysisPromise;
                                    var e_6, _c;
                                    return tslib_1.__generator(this, function (_d) {
                                        switch (_d.label) {
                                            case 0:
                                                this.compilation = this.makeCompilation();
                                                promises = [];
                                                try {
                                                    for (_a = tslib_1.__values(this.inputProgram.getSourceFiles()), _b = _a.next(); !_b.done; _b = _a.next()) {
                                                        sf = _b.value;
                                                        if (sf.isDeclarationFile) {
                                                            continue;
                                                        }
                                                        analysisPromise = this.compilation.traitCompiler.analyzeAsync(sf);
                                                        if (analysisPromise !== undefined) {
                                                            promises.push(analysisPromise);
                                                        }
                                                    }
                                                }
                                                catch (e_6_1) { e_6 = { error: e_6_1 }; }
                                                finally {
                                                    try {
                                                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                                                    }
                                                    finally { if (e_6) throw e_6.error; }
                                                }
                                                return [4 /*yield*/, Promise.all(promises)];
                                            case 1:
                                                _d.sent();
                                                this.perfRecorder.memory(perf_1.PerfCheckpoint.Analysis);
                                                this.resolveCompilation(this.compilation.traitCompiler);
                                                return [2 /*return*/];
                                        }
                                    });
                                }); })];
                        case 1:
                            _a.sent();
                            return [2 /*return*/];
                    }
                });
            });
        };
        /**
         * List lazy routes detected during analysis.
         *
         * This can be called for one specific route, or to retrieve all top-level routes.
         */
        NgCompiler.prototype.listLazyRoutes = function (entryRoute) {
            if (entryRoute) {
                // htts://github.com/angular/angular/blob/50732e156/packages/compiler-cli/src/transformers/compiler_host.ts#L175-L188).
                //
                // `@angular/cli` will always call this API with an absolute path, so the resolution step is
                // not necessary, but keeping it backwards compatible in case someone else is using the API.
                // Relative entry paths are disallowed.
                if (entryRoute.startsWith('.')) {
                    throw new Error("Failed to list lazy routes: Resolution of relative paths (" + entryRoute + ") is not supported.");
                }
                // Non-relative entry paths fall into one of the following categories:
                // - Absolute system paths (e.g. `/foo/bar/my-project/my-module`), which are unaffected by the
                //   logic below.
                // - Paths to enternal modules (e.g. `some-lib`).
                // - Paths mapped to directories in `tsconfig.json` (e.g. `shared/my-module`).
                //   (See https://www.typescriptlang.org/docs/handbook/module-resolution.html#path-mapping.)
                //
                // In all cases above, the `containingFile` argument is ignored, so we can just take the first
                // of the root files.
                var containingFile = this.inputProgram.getRootFileNames()[0];
                var _a = tslib_1.__read(entryRoute.split('#'), 2), entryPath = _a[0], moduleName = _a[1];
                var resolvedModule = typescript_1.resolveModuleName(entryPath, containingFile, this.options, this.adapter, null);
                if (resolvedModule) {
                    entryRoute = routing_1.entryPointKeyFor(resolvedModule.resolvedFileName, moduleName);
                }
            }
            var compilation = this.ensureAnalyzed();
            return compilation.routeAnalyzer.listLazyRoutes(entryRoute);
        };
        /**
         * Fetch transformers and other information which is necessary for a consumer to `emit` the
         * program with Angular-added definitions.
         */
        NgCompiler.prototype.prepareEmit = function () {
            var compilation = this.ensureAnalyzed();
            var coreImportsFrom = compilation.isCore ? getR3SymbolsFile(this.inputProgram) : null;
            var importRewriter;
            if (coreImportsFrom !== null) {
                importRewriter = new imports_1.R3SymbolsImportRewriter(coreImportsFrom.fileName);
            }
            else {
                importRewriter = new imports_1.NoopImportRewriter();
            }
            var defaultImportTracker = new imports_1.DefaultImportTracker();
            var before = [
                transform_1.ivyTransformFactory(compilation.traitCompiler, compilation.reflector, importRewriter, defaultImportTracker, this.delegatingPerfRecorder, compilation.isCore, this.closureCompilerEnabled),
                transform_1.aliasTransformFactory(compilation.traitCompiler.exportStatements),
                defaultImportTracker.importPreservingTransformer(),
            ];
            var afterDeclarations = [];
            if (compilation.dtsTransforms !== null) {
                afterDeclarations.push(transform_1.declarationTransformFactory(compilation.dtsTransforms, importRewriter));
            }
            // Only add aliasing re-exports to the .d.ts output if the `AliasingHost` requests it.
            if (compilation.aliasingHost !== null && compilation.aliasingHost.aliasExportsInDts) {
                afterDeclarations.push(transform_1.aliasTransformFactory(compilation.traitCompiler.exportStatements));
            }
            if (this.adapter.factoryTracker !== null) {
                before.push(shims_1.generatedFactoryTransform(this.adapter.factoryTracker.sourceInfo, importRewriter));
            }
            before.push(switch_1.ivySwitchTransform);
            return { transformers: { before: before, afterDeclarations: afterDeclarations } };
        };
        /**
         * Run the indexing process and return a `Map` of all indexed components.
         *
         * See the `indexing` package for more details.
         */
        NgCompiler.prototype.getIndexedComponents = function () {
            var compilation = this.ensureAnalyzed();
            var context = new indexer_1.IndexingContext();
            compilation.traitCompiler.index(context);
            return indexer_1.generateAnalysis(context);
        };
        /**
         * Collect i18n messages into the `Xi18nContext`.
         */
        NgCompiler.prototype.xi18n = function (ctx) {
            // Note that the 'resolve' phase is not strictly necessary for xi18n, but this is not currently
            // optimized.
            var compilation = this.ensureAnalyzed();
            compilation.traitCompiler.xi18n(ctx);
        };
        NgCompiler.prototype.ensureAnalyzed = function () {
            if (this.compilation === null) {
                this.analyzeSync();
            }
            return this.compilation;
        };
        NgCompiler.prototype.analyzeSync = function () {
            var _this = this;
            this.perfRecorder.inPhase(perf_1.PerfPhase.Analysis, function () {
                var e_7, _a;
                _this.compilation = _this.makeCompilation();
                try {
                    for (var _b = tslib_1.__values(_this.inputProgram.getSourceFiles()), _c = _b.next(); !_c.done; _c = _b.next()) {
                        var sf = _c.value;
                        if (sf.isDeclarationFile) {
                            continue;
                        }
                        _this.compilation.traitCompiler.analyzeSync(sf);
                    }
                }
                catch (e_7_1) { e_7 = { error: e_7_1 }; }
                finally {
                    try {
                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                    }
                    finally { if (e_7) throw e_7.error; }
                }
                _this.perfRecorder.memory(perf_1.PerfCheckpoint.Analysis);
                _this.resolveCompilation(_this.compilation.traitCompiler);
            });
        };
        NgCompiler.prototype.resolveCompilation = function (traitCompiler) {
            var _this = this;
            this.perfRecorder.inPhase(perf_1.PerfPhase.Resolve, function () {
                traitCompiler.resolve();
                // At this point, analysis is complete and the compiler can now calculate which files need to
                // be emitted, so do that.
                _this.incrementalCompilation.recordSuccessfulAnalysis(traitCompiler);
                _this.perfRecorder.memory(perf_1.PerfCheckpoint.Resolve);
            });
        };
        Object.defineProperty(NgCompiler.prototype, "fullTemplateTypeCheck", {
            get: function () {
                // Determine the strictness level of type checking based on compiler options. As
                // `strictTemplates` is a superset of `fullTemplateTypeCheck`, the former implies the latter.
                // Also see `verifyCompatibleTypeCheckOptions` where it is verified that `fullTemplateTypeCheck`
                // is not disabled when `strictTemplates` is enabled.
                var strictTemplates = !!this.options.strictTemplates;
                return strictTemplates || !!this.options.fullTemplateTypeCheck;
            },
            enumerable: false,
            configurable: true
        });
        NgCompiler.prototype.getTypeCheckingConfig = function () {
            // Determine the strictness level of type checking based on compiler options. As
            // `strictTemplates` is a superset of `fullTemplateTypeCheck`, the former implies the latter.
            // Also see `verifyCompatibleTypeCheckOptions` where it is verified that `fullTemplateTypeCheck`
            // is not disabled when `strictTemplates` is enabled.
            var strictTemplates = !!this.options.strictTemplates;
            var useInlineTypeConstructors = this.programDriver.supportsInlineOperations;
            // First select a type-checking configuration, based on whether full template type-checking is
            // requested.
            var typeCheckingConfig;
            if (this.fullTemplateTypeCheck) {
                typeCheckingConfig = {
                    applyTemplateContextGuards: strictTemplates,
                    checkQueries: false,
                    checkTemplateBodies: true,
                    alwaysCheckSchemaInTemplateBodies: true,
                    checkTypeOfInputBindings: strictTemplates,
                    honorAccessModifiersForInputBindings: false,
                    strictNullInputBindings: strictTemplates,
                    checkTypeOfAttributes: strictTemplates,
                    // Even in full template type-checking mode, DOM binding checks are not quite ready yet.
                    checkTypeOfDomBindings: false,
                    checkTypeOfOutputEvents: strictTemplates,
                    checkTypeOfAnimationEvents: strictTemplates,
                    // Checking of DOM events currently has an adverse effect on developer experience,
                    // e.g. for `<input (blur)="update($event.target.value)">` enabling this check results in:
                    // - error TS2531: Object is possibly 'null'.
                    // - error TS2339: Property 'value' does not exist on type 'EventTarget'.
                    checkTypeOfDomEvents: strictTemplates,
                    checkTypeOfDomReferences: strictTemplates,
                    // Non-DOM references have the correct type in View Engine so there is no strictness flag.
                    checkTypeOfNonDomReferences: true,
                    // Pipes are checked in View Engine so there is no strictness flag.
                    checkTypeOfPipes: true,
                    strictSafeNavigationTypes: strictTemplates,
                    useContextGenericType: strictTemplates,
                    strictLiteralTypes: true,
                    enableTemplateTypeChecker: this.enableTemplateTypeChecker,
                    useInlineTypeConstructors: useInlineTypeConstructors,
                    // Warnings for suboptimal type inference are only enabled if in Language Service mode
                    // (providing the full TemplateTypeChecker API) and if strict mode is not enabled. In strict
                    // mode, the user is in full control of type inference.
                    suggestionsForSuboptimalTypeInference: this.enableTemplateTypeChecker && !strictTemplates,
                };
            }
            else {
                typeCheckingConfig = {
                    applyTemplateContextGuards: false,
                    checkQueries: false,
                    checkTemplateBodies: false,
                    // Enable deep schema checking in "basic" template type-checking mode only if Closure
                    // compilation is requested, which is a good proxy for "only in google3".
                    alwaysCheckSchemaInTemplateBodies: this.closureCompilerEnabled,
                    checkTypeOfInputBindings: false,
                    strictNullInputBindings: false,
                    honorAccessModifiersForInputBindings: false,
                    checkTypeOfAttributes: false,
                    checkTypeOfDomBindings: false,
                    checkTypeOfOutputEvents: false,
                    checkTypeOfAnimationEvents: false,
                    checkTypeOfDomEvents: false,
                    checkTypeOfDomReferences: false,
                    checkTypeOfNonDomReferences: false,
                    checkTypeOfPipes: false,
                    strictSafeNavigationTypes: false,
                    useContextGenericType: false,
                    strictLiteralTypes: false,
                    enableTemplateTypeChecker: this.enableTemplateTypeChecker,
                    useInlineTypeConstructors: useInlineTypeConstructors,
                    // In "basic" template type-checking mode, no warnings are produced since most things are
                    // not checked anyways.
                    suggestionsForSuboptimalTypeInference: false,
                };
            }
            // Apply explicitly configured strictness flags on top of the default configuration
            // based on "fullTemplateTypeCheck".
            if (this.options.strictInputTypes !== undefined) {
                typeCheckingConfig.checkTypeOfInputBindings = this.options.strictInputTypes;
                typeCheckingConfig.applyTemplateContextGuards = this.options.strictInputTypes;
            }
            if (this.options.strictInputAccessModifiers !== undefined) {
                typeCheckingConfig.honorAccessModifiersForInputBindings =
                    this.options.strictInputAccessModifiers;
            }
            if (this.options.strictNullInputTypes !== undefined) {
                typeCheckingConfig.strictNullInputBindings = this.options.strictNullInputTypes;
            }
            if (this.options.strictOutputEventTypes !== undefined) {
                typeCheckingConfig.checkTypeOfOutputEvents = this.options.strictOutputEventTypes;
                typeCheckingConfig.checkTypeOfAnimationEvents = this.options.strictOutputEventTypes;
            }
            if (this.options.strictDomEventTypes !== undefined) {
                typeCheckingConfig.checkTypeOfDomEvents = this.options.strictDomEventTypes;
            }
            if (this.options.strictSafeNavigationTypes !== undefined) {
                typeCheckingConfig.strictSafeNavigationTypes = this.options.strictSafeNavigationTypes;
            }
            if (this.options.strictDomLocalRefTypes !== undefined) {
                typeCheckingConfig.checkTypeOfDomReferences = this.options.strictDomLocalRefTypes;
            }
            if (this.options.strictAttributeTypes !== undefined) {
                typeCheckingConfig.checkTypeOfAttributes = this.options.strictAttributeTypes;
            }
            if (this.options.strictContextGenerics !== undefined) {
                typeCheckingConfig.useContextGenericType = this.options.strictContextGenerics;
            }
            if (this.options.strictLiteralTypes !== undefined) {
                typeCheckingConfig.strictLiteralTypes = this.options.strictLiteralTypes;
            }
            return typeCheckingConfig;
        };
        NgCompiler.prototype.getTemplateDiagnostics = function () {
            var e_8, _a;
            var compilation = this.ensureAnalyzed();
            // Get the diagnostics.
            var diagnostics = [];
            try {
                for (var _b = tslib_1.__values(this.inputProgram.getSourceFiles()), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var sf = _c.value;
                    if (sf.isDeclarationFile || this.adapter.isShim(sf)) {
                        continue;
                    }
                    diagnostics.push.apply(diagnostics, tslib_1.__spreadArray([], tslib_1.__read(compilation.templateTypeChecker.getDiagnosticsForFile(sf, api_1.OptimizeFor.WholeProgram))));
                }
            }
            catch (e_8_1) { e_8 = { error: e_8_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_8) throw e_8.error; }
            }
            var program = this.programDriver.getProgram();
            this.incrementalStrategy.setIncrementalState(this.incrementalCompilation.state, program);
            this.currentProgram = program;
            return diagnostics;
        };
        NgCompiler.prototype.getTemplateDiagnosticsForFile = function (sf, optimizeFor) {
            var compilation = this.ensureAnalyzed();
            // Get the diagnostics.
            var diagnostics = [];
            if (!sf.isDeclarationFile && !this.adapter.isShim(sf)) {
                diagnostics.push.apply(diagnostics, tslib_1.__spreadArray([], tslib_1.__read(compilation.templateTypeChecker.getDiagnosticsForFile(sf, optimizeFor))));
            }
            var program = this.programDriver.getProgram();
            this.incrementalStrategy.setIncrementalState(this.incrementalCompilation.state, program);
            this.currentProgram = program;
            return diagnostics;
        };
        NgCompiler.prototype.getNonTemplateDiagnostics = function () {
            var _a;
            if (this.nonTemplateDiagnostics === null) {
                var compilation = this.ensureAnalyzed();
                this.nonTemplateDiagnostics = tslib_1.__spreadArray([], tslib_1.__read(compilation.traitCompiler.diagnostics));
                if (this.entryPoint !== null && compilation.exportReferenceGraph !== null) {
                    (_a = this.nonTemplateDiagnostics).push.apply(_a, tslib_1.__spreadArray([], tslib_1.__read(entry_point_1.checkForPrivateExports(this.entryPoint, this.inputProgram.getTypeChecker(), compilation.exportReferenceGraph))));
                }
            }
            return this.nonTemplateDiagnostics;
        };
        /**
         * Calls the `extendedTemplateCheck` phase of the trait compiler
         * @param sf optional parameter to get diagnostics for a certain file
         *     or all files in the program if `sf` is undefined
         * @returns generated extended template diagnostics
         */
        NgCompiler.prototype.getExtendedTemplateDiagnostics = function (sf) {
            var e_9, _a;
            var diagnostics = [];
            var compilation = this.ensureAnalyzed();
            var extendedTemplateChecker = compilation.extendedTemplateChecker;
            if (sf !== undefined) {
                return compilation.traitCompiler.extendedTemplateCheck(sf, extendedTemplateChecker);
            }
            try {
                for (var _b = tslib_1.__values(this.inputProgram.getSourceFiles()), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var sf_1 = _c.value;
                    diagnostics.push.apply(diagnostics, tslib_1.__spreadArray([], tslib_1.__read(compilation.traitCompiler.extendedTemplateCheck(sf_1, extendedTemplateChecker))));
                }
            }
            catch (e_9_1) { e_9 = { error: e_9_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_9) throw e_9.error; }
            }
            return diagnostics;
        };
        NgCompiler.prototype.makeCompilation = function () {
            var _this = this;
            var checker = this.inputProgram.getTypeChecker();
            var reflector = new reflection_1.TypeScriptReflectionHost(checker);
            // Construct the ReferenceEmitter.
            var refEmitter;
            var aliasingHost = null;
            if (this.adapter.unifiedModulesHost === null || !this.options._useHostForImportGeneration) {
                var localImportStrategy = void 0;
                // The strategy used for local, in-project imports depends on whether TS has been configured
                // with rootDirs. If so, then multiple directories may be mapped in the same "module
                // namespace" and the logic of `LogicalProjectStrategy` is required to generate correct
                // imports which may cross these multiple directories. Otherwise, plain relative imports are
                // sufficient.
                if (this.options.rootDir !== undefined ||
                    (this.options.rootDirs !== undefined && this.options.rootDirs.length > 0)) {
                    // rootDirs logic is in effect - use the `LogicalProjectStrategy` for in-project relative
                    // imports.
                    localImportStrategy = new imports_1.LogicalProjectStrategy(reflector, new file_system_1.LogicalFileSystem(tslib_1.__spreadArray([], tslib_1.__read(this.adapter.rootDirs)), this.adapter));
                }
                else {
                    // Plain relative imports are all that's needed.
                    localImportStrategy = new imports_1.RelativePathStrategy(reflector);
                }
                // The CompilerHost doesn't have fileNameToModuleName, so build an NPM-centric reference
                // resolution strategy.
                refEmitter = new imports_1.ReferenceEmitter([
                    // First, try to use local identifiers if available.
                    new imports_1.LocalIdentifierStrategy(),
                    // Next, attempt to use an absolute import.
                    new imports_1.AbsoluteModuleStrategy(this.inputProgram, checker, this.moduleResolver, reflector),
                    // Finally, check if the reference is being written into a file within the project's .ts
                    // sources, and use a relative import if so. If this fails, ReferenceEmitter will throw
                    // an error.
                    localImportStrategy,
                ]);
                // If an entrypoint is present, then all user imports should be directed through the
                // entrypoint and private exports are not needed. The compiler will validate that all publicly
                // visible directives/pipes are importable via this entrypoint.
                if (this.entryPoint === null && this.options.generateDeepReexports === true) {
                    // No entrypoint is present and deep re-exports were requested, so configure the aliasing
                    // system to generate them.
                    aliasingHost = new imports_1.PrivateExportAliasingHost(reflector);
                }
            }
            else {
                // The CompilerHost supports fileNameToModuleName, so use that to emit imports.
                refEmitter = new imports_1.ReferenceEmitter([
                    // First, try to use local identifiers if available.
                    new imports_1.LocalIdentifierStrategy(),
                    // Then use aliased references (this is a workaround to StrictDeps checks).
                    new imports_1.AliasStrategy(),
                    // Then use fileNameToModuleName to emit imports.
                    new imports_1.UnifiedModulesStrategy(reflector, this.adapter.unifiedModulesHost),
                ]);
                aliasingHost = new imports_1.UnifiedModulesAliasingHost(this.adapter.unifiedModulesHost);
            }
            var evaluator = new partial_evaluator_1.PartialEvaluator(reflector, checker, this.incrementalCompilation.depGraph);
            var dtsReader = new metadata_1.DtsMetadataReader(checker, reflector);
            var localMetaRegistry = new metadata_1.LocalMetadataRegistry();
            var localMetaReader = localMetaRegistry;
            var depScopeReader = new scope_1.MetadataDtsModuleScopeResolver(dtsReader, aliasingHost);
            var scopeRegistry = new scope_1.LocalModuleScopeRegistry(localMetaReader, depScopeReader, refEmitter, aliasingHost);
            var scopeReader = scopeRegistry;
            var semanticDepGraphUpdater = this.incrementalCompilation.semanticDepGraphUpdater;
            var metaRegistry = new metadata_1.CompoundMetadataRegistry([localMetaRegistry, scopeRegistry]);
            var injectableRegistry = new metadata_1.InjectableClassRegistry(reflector);
            var metaReader = new metadata_1.CompoundMetadataReader([localMetaReader, dtsReader]);
            var typeCheckScopeRegistry = new scope_1.TypeCheckScopeRegistry(scopeReader, metaReader);
            // If a flat module entrypoint was specified, then track references via a `ReferenceGraph` in
            // order to produce proper diagnostics for incorrectly exported directives/pipes/etc. If there
            // is no flat module entrypoint then don't pay the cost of tracking references.
            var referencesRegistry;
            var exportReferenceGraph = null;
            if (this.entryPoint !== null) {
                exportReferenceGraph = new entry_point_1.ReferenceGraph();
                referencesRegistry = new ReferenceGraphAdapter(exportReferenceGraph);
            }
            else {
                referencesRegistry = new annotations_1.NoopReferencesRegistry();
            }
            var routeAnalyzer = new routing_1.NgModuleRouteAnalyzer(this.moduleResolver, evaluator);
            var dtsTransforms = new transform_1.DtsTransformRegistry();
            var isCore = isAngularCorePackage(this.inputProgram);
            var resourceRegistry = new metadata_1.ResourceRegistry();
            var compilationMode = this.options.compilationMode === 'partial' ? transform_1.CompilationMode.PARTIAL : transform_1.CompilationMode.FULL;
            // Cycles are handled in full compilation mode by "remote scoping".
            // "Remote scoping" does not work well with tree shaking for libraries.
            // So in partial compilation mode, when building a library, a cycle will cause an error.
            var cycleHandlingStrategy = compilationMode === transform_1.CompilationMode.FULL ?
                0 /* UseRemoteScoping */ :
                1 /* Error */;
            // Set up the IvyCompilation, which manages state for the Ivy transformer.
            var handlers = [
                new annotations_1.ComponentDecoratorHandler(reflector, evaluator, metaRegistry, metaReader, scopeReader, scopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, this.resourceManager, this.adapter.rootDirs, this.options.preserveWhitespaces || false, this.options.i18nUseExternalIds !== false, this.options.enableI18nLegacyMessageIdFormat !== false, this.usePoisonedData, this.options.i18nNormalizeLineEndingsInICUs, this.moduleResolver, this.cycleAnalyzer, cycleHandlingStrategy, refEmitter, this.incrementalCompilation.depGraph, injectableRegistry, semanticDepGraphUpdater, this.closureCompilerEnabled, this.delegatingPerfRecorder),
                // TODO(alxhub): understand why the cast here is necessary (something to do with `null`
                // not being assignable to `unknown` when wrapped in `Readonly`).
                // clang-format off
                new annotations_1.DirectiveDecoratorHandler(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, injectableRegistry, isCore, semanticDepGraphUpdater, this.closureCompilerEnabled, /** compileUndecoratedClassesWithAngularFeatures */ false, this.delegatingPerfRecorder),
                // clang-format on
                // Pipe handler must be before injectable handler in list so pipe factories are printed
                // before injectable factories (so injectable factories can delegate to them)
                new annotations_1.PipeDecoratorHandler(reflector, evaluator, metaRegistry, scopeRegistry, injectableRegistry, isCore, this.delegatingPerfRecorder),
                new annotations_1.InjectableDecoratorHandler(reflector, isCore, this.options.strictInjectionParameters || false, injectableRegistry, this.delegatingPerfRecorder),
                new annotations_1.NgModuleDecoratorHandler(reflector, evaluator, metaReader, metaRegistry, scopeRegistry, referencesRegistry, isCore, routeAnalyzer, refEmitter, this.adapter.factoryTracker, this.closureCompilerEnabled, injectableRegistry, this.delegatingPerfRecorder, this.options.i18nInLocale),
            ];
            var traitCompiler = new transform_1.TraitCompiler(handlers, reflector, this.delegatingPerfRecorder, this.incrementalCompilation, this.options.compileNonExportedClasses !== false, compilationMode, dtsTransforms, semanticDepGraphUpdater);
            // Template type-checking may use the `ProgramDriver` to produce new `ts.Program`(s). If this
            // happens, they need to be tracked by the `NgCompiler`.
            var notifyingDriver = new NotifyingProgramDriverWrapper(this.programDriver, function (program) {
                _this.incrementalStrategy.setIncrementalState(_this.incrementalCompilation.state, program);
                _this.currentProgram = program;
            });
            var templateTypeChecker = new typecheck_1.TemplateTypeCheckerImpl(this.inputProgram, notifyingDriver, traitCompiler, this.getTypeCheckingConfig(), refEmitter, reflector, this.adapter, this.incrementalCompilation, scopeRegistry, typeCheckScopeRegistry, this.delegatingPerfRecorder);
            var templateChecks = [new invalid_banana_in_box_1.InvalidBananaInBoxCheck()];
            if (this.options.strictNullChecks) {
                templateChecks.push(new nullish_coalescing_not_nullable_1.NullishCoalescingNotNullableCheck());
            }
            var extendedTemplateChecker = new extended_1.ExtendedTemplateCheckerImpl(templateTypeChecker, checker, templateChecks);
            return {
                isCore: isCore,
                traitCompiler: traitCompiler,
                reflector: reflector,
                scopeRegistry: scopeRegistry,
                dtsTransforms: dtsTransforms,
                exportReferenceGraph: exportReferenceGraph,
                routeAnalyzer: routeAnalyzer,
                metaReader: metaReader,
                typeCheckScopeRegistry: typeCheckScopeRegistry,
                aliasingHost: aliasingHost,
                refEmitter: refEmitter,
                templateTypeChecker: templateTypeChecker,
                resourceRegistry: resourceRegistry,
                extendedTemplateChecker: extendedTemplateChecker
            };
        };
        return NgCompiler;
    }());
    exports.NgCompiler = NgCompiler;
    /**
     * Determine if the given `Program` is @angular/core.
     */
    function isAngularCorePackage(program) {
        // Look for its_just_angular.ts somewhere in the program.
        var r3Symbols = getR3SymbolsFile(program);
        if (r3Symbols === null) {
            return false;
        }
        // Look for the constant ITS_JUST_ANGULAR in that file.
        return r3Symbols.statements.some(function (stmt) {
            // The statement must be a variable declaration statement.
            if (!ts.isVariableStatement(stmt)) {
                return false;
            }
            // It must be exported.
            if (stmt.modifiers === undefined ||
                !stmt.modifiers.some(function (mod) { return mod.kind === ts.SyntaxKind.ExportKeyword; })) {
                return false;
            }
            // It must declare ITS_JUST_ANGULAR.
            return stmt.declarationList.declarations.some(function (decl) {
                // The declaration must match the name.
                if (!ts.isIdentifier(decl.name) || decl.name.text !== 'ITS_JUST_ANGULAR') {
                    return false;
                }
                // It must initialize the variable to true.
                if (decl.initializer === undefined || decl.initializer.kind !== ts.SyntaxKind.TrueKeyword) {
                    return false;
                }
                // This definition matches.
                return true;
            });
        });
    }
    exports.isAngularCorePackage = isAngularCorePackage;
    /**
     * Find the 'r3_symbols.ts' file in the given `Program`, or return `null` if it wasn't there.
     */
    function getR3SymbolsFile(program) {
        return program.getSourceFiles().find(function (file) { return file.fileName.indexOf('r3_symbols.ts') >= 0; }) || null;
    }
    /**
     * Since "strictTemplates" is a true superset of type checking capabilities compared to
     * "fullTemplateTypeCheck", it is required that the latter is not explicitly disabled if the
     * former is enabled.
     */
    function verifyCompatibleTypeCheckOptions(options) {
        if (options.fullTemplateTypeCheck === false && options.strictTemplates === true) {
            return {
                category: ts.DiagnosticCategory.Error,
                code: diagnostics_1.ngErrorCode(diagnostics_1.ErrorCode.CONFIG_STRICT_TEMPLATES_IMPLIES_FULL_TEMPLATE_TYPECHECK),
                file: undefined,
                start: undefined,
                length: undefined,
                messageText: "Angular compiler option \"strictTemplates\" is enabled, however \"fullTemplateTypeCheck\" is disabled.\n\nHaving the \"strictTemplates\" flag enabled implies that \"fullTemplateTypeCheck\" is also enabled, so\nthe latter can not be explicitly disabled.\n\nOne of the following actions is required:\n1. Remove the \"fullTemplateTypeCheck\" option.\n2. Remove \"strictTemplates\" or set it to 'false'.\n\nMore information about the template type checking compiler options can be found in the documentation:\nhttps://v9.angular.io/guide/template-typecheck#template-type-checking",
            };
        }
        return null;
    }
    var ReferenceGraphAdapter = /** @class */ (function () {
        function ReferenceGraphAdapter(graph) {
            this.graph = graph;
        }
        ReferenceGraphAdapter.prototype.add = function (source) {
            var e_10, _a;
            var references = [];
            for (var _i = 1; _i < arguments.length; _i++) {
                references[_i - 1] = arguments[_i];
            }
            try {
                for (var references_1 = tslib_1.__values(references), references_1_1 = references_1.next(); !references_1_1.done; references_1_1 = references_1.next()) {
                    var node = references_1_1.value.node;
                    var sourceFile = node.getSourceFile();
                    if (sourceFile === undefined) {
                        sourceFile = ts.getOriginalNode(node).getSourceFile();
                    }
                    // Only record local references (not references into .d.ts files).
                    if (sourceFile === undefined || !typescript_1.isDtsPath(sourceFile.fileName)) {
                        this.graph.add(source, node);
                    }
                }
            }
            catch (e_10_1) { e_10 = { error: e_10_1 }; }
            finally {
                try {
                    if (references_1_1 && !references_1_1.done && (_a = references_1.return)) _a.call(references_1);
                }
                finally { if (e_10) throw e_10.error; }
            }
        };
        return ReferenceGraphAdapter;
    }());
    var NotifyingProgramDriverWrapper = /** @class */ (function () {
        function NotifyingProgramDriverWrapper(delegate, notifyNewProgram) {
            var _a;
            this.delegate = delegate;
            this.notifyNewProgram = notifyNewProgram;
            this.getSourceFileVersion = (_a = this.delegate.getSourceFileVersion) === null || _a === void 0 ? void 0 : _a.bind(this);
        }
        Object.defineProperty(NotifyingProgramDriverWrapper.prototype, "supportsInlineOperations", {
            get: function () {
                return this.delegate.supportsInlineOperations;
            },
            enumerable: false,
            configurable: true
        });
        NotifyingProgramDriverWrapper.prototype.getProgram = function () {
            return this.delegate.getProgram();
        };
        NotifyingProgramDriverWrapper.prototype.updateFiles = function (contents, updateMode) {
            this.delegate.updateFiles(contents, updateMode);
            this.notifyNewProgram(this.delegate.getProgram());
        };
        return NotifyingProgramDriverWrapper;
    }());
    function versionMapFromProgram(program, driver) {
        var e_11, _a;
        if (driver.getSourceFileVersion === undefined) {
            return null;
        }
        var versions = new Map();
        try {
            for (var _b = tslib_1.__values(program.getSourceFiles()), _c = _b.next(); !_c.done; _c = _b.next()) {
                var possiblyRedirectedSourceFile = _c.value;
                var sf = typescript_1.toUnredirectedSourceFile(possiblyRedirectedSourceFile);
                versions.set(file_system_1.absoluteFromSourceFile(sf), driver.getSourceFileVersion(sf));
            }
        }
        catch (e_11_1) { e_11 = { error: e_11_1 }; }
        finally {
            try {
                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
            }
            finally { if (e_11) throw e_11.error; }
        }
        return versions;
    }
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compiler.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/core/src/compiler.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 */\n\nimport * as ts from 'typescript';\n\nimport {ComponentDecoratorHandler, DirectiveDecoratorHandler, InjectableDecoratorHandler, NgModuleDecoratorHandler, NoopReferencesRegistry, PipeDecoratorHandler, ReferencesRegistry} from '../../annotations';\nimport {CycleAnalyzer, CycleHandlingStrategy, ImportGraph} from '../../cycles';\nimport {COMPILER_ERRORS_WITH_GUIDES, ERROR_DETAILS_PAGE_BASE_URL, ErrorCode, ngErrorCode} from '../../diagnostics';\nimport {checkForPrivateExports, ReferenceGraph} from '../../entry_point';\nimport {absoluteFromSourceFile, AbsoluteFsPath, LogicalFileSystem, resolve} from '../../file_system';\nimport {AbsoluteModuleStrategy, AliasingHost, AliasStrategy, DefaultImportTracker, ImportRewriter, LocalIdentifierStrategy, LogicalProjectStrategy, ModuleResolver, NoopImportRewriter, PrivateExportAliasingHost, R3SymbolsImportRewriter, Reference, ReferenceEmitStrategy, ReferenceEmitter, RelativePathStrategy, UnifiedModulesAliasingHost, UnifiedModulesStrategy} from '../../imports';\nimport {IncrementalBuildStrategy, IncrementalCompilation, IncrementalState} from '../../incremental';\nimport {SemanticSymbol} from '../../incremental/semantic_graph';\nimport {generateAnalysis, IndexedComponent, IndexingContext} from '../../indexer';\nimport {ComponentResources, CompoundMetadataReader, CompoundMetadataRegistry, DirectiveMeta, DtsMetadataReader, InjectableClassRegistry, LocalMetadataRegistry, MetadataReader, PipeMeta, ResourceRegistry} from '../../metadata';\nimport {PartialEvaluator} from '../../partial_evaluator';\nimport {ActivePerfRecorder, DelegatingPerfRecorder, PerfCheckpoint, PerfEvent, PerfPhase} from '../../perf';\nimport {FileUpdate, ProgramDriver, UpdateMode} from '../../program_driver';\nimport {DeclarationNode, isNamedClassDeclaration, TypeScriptReflectionHost} from '../../reflection';\nimport {AdapterResourceLoader} from '../../resource';\nimport {entryPointKeyFor, NgModuleRouteAnalyzer} from '../../routing';\nimport {ComponentScopeReader, LocalModuleScopeRegistry, MetadataDtsModuleScopeResolver, TypeCheckScopeRegistry} from '../../scope';\nimport {generatedFactoryTransform} from '../../shims';\nimport {ivySwitchTransform} from '../../switch';\nimport {aliasTransformFactory, CompilationMode, declarationTransformFactory, DecoratorHandler, DtsTransformRegistry, ivyTransformFactory, TraitCompiler} from '../../transform';\nimport {TemplateTypeCheckerImpl} from '../../typecheck';\nimport {OptimizeFor, TemplateTypeChecker, TypeCheckingConfig} from '../../typecheck/api';\nimport {ExtendedTemplateCheckerImpl} from '../../typecheck/extended';\nimport {ExtendedTemplateChecker, TemplateCheck} from '../../typecheck/extended/api';\nimport {InvalidBananaInBoxCheck} from '../../typecheck/extended/checks/invalid_banana_in_box';\nimport {NullishCoalescingNotNullableCheck} from '../../typecheck/extended/checks/nullish_coalescing_not_nullable';\nimport {getSourceFileOrNull, isDtsPath, resolveModuleName, toUnredirectedSourceFile} from '../../util/src/typescript';\nimport {Xi18nContext} from '../../xi18n';\nimport {LazyRoute, NgCompilerAdapter, NgCompilerOptions} from '../api';\n\n/**\n * State information about a compilation which is only generated once some data is requested from\n * the `NgCompiler` (for example, by calling `getDiagnostics`).\n */\ninterface LazyCompilationState {\n  isCore: boolean;\n  traitCompiler: TraitCompiler;\n  reflector: TypeScriptReflectionHost;\n  metaReader: MetadataReader;\n  scopeRegistry: LocalModuleScopeRegistry;\n  typeCheckScopeRegistry: TypeCheckScopeRegistry;\n  exportReferenceGraph: ReferenceGraph|null;\n  routeAnalyzer: NgModuleRouteAnalyzer;\n  dtsTransforms: DtsTransformRegistry;\n  aliasingHost: AliasingHost|null;\n  refEmitter: ReferenceEmitter;\n  templateTypeChecker: TemplateTypeChecker;\n  resourceRegistry: ResourceRegistry;\n  extendedTemplateChecker: ExtendedTemplateChecker;\n}\n\n\n\n/**\n * Discriminant type for a `CompilationTicket`.\n */\nexport enum CompilationTicketKind {\n  Fresh,\n  IncrementalTypeScript,\n  IncrementalResource,\n}\n\n/**\n * Begin an Angular compilation operation from scratch.\n */\nexport interface FreshCompilationTicket {\n  kind: CompilationTicketKind.Fresh;\n  options: NgCompilerOptions;\n  incrementalBuildStrategy: IncrementalBuildStrategy;\n  programDriver: ProgramDriver;\n  enableTemplateTypeChecker: boolean;\n  usePoisonedData: boolean;\n  tsProgram: ts.Program;\n  perfRecorder: ActivePerfRecorder;\n}\n\n/**\n * Begin an Angular compilation operation that incorporates changes to TypeScript code.\n */\nexport interface IncrementalTypeScriptCompilationTicket {\n  kind: CompilationTicketKind.IncrementalTypeScript;\n  options: NgCompilerOptions;\n  newProgram: ts.Program;\n  incrementalBuildStrategy: IncrementalBuildStrategy;\n  incrementalCompilation: IncrementalCompilation;\n  programDriver: ProgramDriver;\n  enableTemplateTypeChecker: boolean;\n  usePoisonedData: boolean;\n  perfRecorder: ActivePerfRecorder;\n}\n\nexport interface IncrementalResourceCompilationTicket {\n  kind: CompilationTicketKind.IncrementalResource;\n  compiler: NgCompiler;\n  modifiedResourceFiles: Set<string>;\n  perfRecorder: ActivePerfRecorder;\n}\n\n/**\n * A request to begin Angular compilation, either starting from scratch or from a known prior state.\n *\n * `CompilationTicket`s are used to initialize (or update) an `NgCompiler` instance, the core of the\n * Angular compiler. They abstract the starting state of compilation and allow `NgCompiler` to be\n * managed independently of any incremental compilation lifecycle.\n */\nexport type CompilationTicket = FreshCompilationTicket|IncrementalTypeScriptCompilationTicket|\n    IncrementalResourceCompilationTicket;\n\n/**\n * Create a `CompilationTicket` for a brand new compilation, using no prior state.\n */\nexport function freshCompilationTicket(\n    tsProgram: ts.Program, options: NgCompilerOptions,\n    incrementalBuildStrategy: IncrementalBuildStrategy, programDriver: ProgramDriver,\n    perfRecorder: ActivePerfRecorder|null, enableTemplateTypeChecker: boolean,\n    usePoisonedData: boolean): CompilationTicket {\n  return {\n    kind: CompilationTicketKind.Fresh,\n    tsProgram,\n    options,\n    incrementalBuildStrategy,\n    programDriver,\n    enableTemplateTypeChecker,\n    usePoisonedData,\n    perfRecorder: perfRecorder ?? ActivePerfRecorder.zeroedToNow(),\n  };\n}\n\n/**\n * Create a `CompilationTicket` as efficiently as possible, based on a previous `NgCompiler`\n * instance and a new `ts.Program`.\n */\nexport function incrementalFromCompilerTicket(\n    oldCompiler: NgCompiler, newProgram: ts.Program,\n    incrementalBuildStrategy: IncrementalBuildStrategy, programDriver: ProgramDriver,\n    modifiedResourceFiles: Set<AbsoluteFsPath>,\n    perfRecorder: ActivePerfRecorder|null): CompilationTicket {\n  const oldProgram = oldCompiler.getCurrentProgram();\n  const oldState = oldCompiler.incrementalStrategy.getIncrementalState(oldProgram);\n  if (oldState === null) {\n    // No incremental step is possible here, since no IncrementalDriver was found for the old\n    // program.\n    return freshCompilationTicket(\n        newProgram, oldCompiler.options, incrementalBuildStrategy, programDriver, perfRecorder,\n        oldCompiler.enableTemplateTypeChecker, oldCompiler.usePoisonedData);\n  }\n\n  if (perfRecorder === null) {\n    perfRecorder = ActivePerfRecorder.zeroedToNow();\n  }\n\n  const incrementalCompilation = IncrementalCompilation.incremental(\n      newProgram, versionMapFromProgram(newProgram, programDriver), oldProgram, oldState,\n      modifiedResourceFiles, perfRecorder);\n\n  return {\n    kind: CompilationTicketKind.IncrementalTypeScript,\n    enableTemplateTypeChecker: oldCompiler.enableTemplateTypeChecker,\n    usePoisonedData: oldCompiler.usePoisonedData,\n    options: oldCompiler.options,\n    incrementalBuildStrategy,\n    incrementalCompilation,\n    programDriver,\n    newProgram,\n    perfRecorder,\n  };\n}\n\n/**\n * Create a `CompilationTicket` directly from an old `ts.Program` and associated Angular compilation\n * state, along with a new `ts.Program`.\n */\nexport function incrementalFromStateTicket(\n    oldProgram: ts.Program, oldState: IncrementalState, newProgram: ts.Program,\n    options: NgCompilerOptions, incrementalBuildStrategy: IncrementalBuildStrategy,\n    programDriver: ProgramDriver, modifiedResourceFiles: Set<AbsoluteFsPath>,\n    perfRecorder: ActivePerfRecorder|null, enableTemplateTypeChecker: boolean,\n    usePoisonedData: boolean): CompilationTicket {\n  if (perfRecorder === null) {\n    perfRecorder = ActivePerfRecorder.zeroedToNow();\n  }\n  const incrementalCompilation = IncrementalCompilation.incremental(\n      newProgram, versionMapFromProgram(newProgram, programDriver), oldProgram, oldState,\n      modifiedResourceFiles, perfRecorder);\n  return {\n    kind: CompilationTicketKind.IncrementalTypeScript,\n    newProgram,\n    options,\n    incrementalBuildStrategy,\n    incrementalCompilation,\n    programDriver,\n    enableTemplateTypeChecker,\n    usePoisonedData,\n    perfRecorder,\n  };\n}\n\nexport function resourceChangeTicket(compiler: NgCompiler, modifiedResourceFiles: Set<string>):\n    IncrementalResourceCompilationTicket {\n  return {\n    kind: CompilationTicketKind.IncrementalResource,\n    compiler,\n    modifiedResourceFiles,\n    perfRecorder: ActivePerfRecorder.zeroedToNow(),\n  };\n}\n\n\n/**\n * The heart of the Angular Ivy compiler.\n *\n * The `NgCompiler` provides an API for performing Angular compilation within a custom TypeScript\n * compiler. Each instance of `NgCompiler` supports a single compilation, which might be\n * incremental.\n *\n * `NgCompiler` is lazy, and does not perform any of the work of the compilation until one of its\n * output methods (e.g. `getDiagnostics`) is called.\n *\n * See the README.md for more information.\n */\nexport class NgCompiler {\n  /**\n   * Lazily evaluated state of the compilation.\n   *\n   * This is created on demand by calling `ensureAnalyzed`.\n   */\n  private compilation: LazyCompilationState|null = null;\n\n  /**\n   * Any diagnostics related to the construction of the compilation.\n   *\n   * These are diagnostics which arose during setup of the host and/or program.\n   */\n  private constructionDiagnostics: ts.Diagnostic[] = [];\n\n  /**\n   * Non-template diagnostics related to the program itself. Does not include template\n   * diagnostics because the template type checker memoizes them itself.\n   *\n   * This is set by (and memoizes) `getNonTemplateDiagnostics`.\n   */\n  private nonTemplateDiagnostics: ts.Diagnostic[]|null = null;\n\n  private closureCompilerEnabled: boolean;\n  private currentProgram: ts.Program;\n  private entryPoint: ts.SourceFile|null;\n  private moduleResolver: ModuleResolver;\n  private resourceManager: AdapterResourceLoader;\n  private cycleAnalyzer: CycleAnalyzer;\n  readonly ignoreForDiagnostics: Set<ts.SourceFile>;\n  readonly ignoreForEmit: Set<ts.SourceFile>;\n\n  /**\n   * `NgCompiler` can be reused for multiple compilations (for resource-only changes), and each\n   * new compilation uses a fresh `PerfRecorder`. Thus, classes created with a lifespan of the\n   * `NgCompiler` use a `DelegatingPerfRecorder` so the `PerfRecorder` they write to can be updated\n   * with each fresh compilation.\n   */\n  private delegatingPerfRecorder = new DelegatingPerfRecorder(this.perfRecorder);\n\n  /**\n   * Convert a `CompilationTicket` into an `NgCompiler` instance for the requested compilation.\n   *\n   * Depending on the nature of the compilation request, the `NgCompiler` instance may be reused\n   * from a previous compilation and updated with any changes, it may be a new instance which\n   * incrementally reuses state from a previous compilation, or it may represent a fresh\n   * compilation entirely.\n   */\n  static fromTicket(ticket: CompilationTicket, adapter: NgCompilerAdapter) {\n    switch (ticket.kind) {\n      case CompilationTicketKind.Fresh:\n        return new NgCompiler(\n            adapter,\n            ticket.options,\n            ticket.tsProgram,\n            ticket.programDriver,\n            ticket.incrementalBuildStrategy,\n            IncrementalCompilation.fresh(\n                ticket.tsProgram, versionMapFromProgram(ticket.tsProgram, ticket.programDriver)),\n            ticket.enableTemplateTypeChecker,\n            ticket.usePoisonedData,\n            ticket.perfRecorder,\n        );\n      case CompilationTicketKind.IncrementalTypeScript:\n        return new NgCompiler(\n            adapter,\n            ticket.options,\n            ticket.newProgram,\n            ticket.programDriver,\n            ticket.incrementalBuildStrategy,\n            ticket.incrementalCompilation,\n            ticket.enableTemplateTypeChecker,\n            ticket.usePoisonedData,\n            ticket.perfRecorder,\n        );\n      case CompilationTicketKind.IncrementalResource:\n        const compiler = ticket.compiler;\n        compiler.updateWithChangedResources(ticket.modifiedResourceFiles, ticket.perfRecorder);\n        return compiler;\n    }\n  }\n\n  private constructor(\n      private adapter: NgCompilerAdapter,\n      readonly options: NgCompilerOptions,\n      private inputProgram: ts.Program,\n      readonly programDriver: ProgramDriver,\n      readonly incrementalStrategy: IncrementalBuildStrategy,\n      readonly incrementalCompilation: IncrementalCompilation,\n      readonly enableTemplateTypeChecker: boolean,\n      readonly usePoisonedData: boolean,\n      private livePerfRecorder: ActivePerfRecorder,\n  ) {\n    if (this.options._extendedTemplateDiagnostics === true &&\n        this.options.strictTemplates === false) {\n      throw new Error(\n          'The \\'_extendedTemplateDiagnostics\\' option requires \\'strictTemplates\\' to also be enabled.');\n    }\n\n    this.constructionDiagnostics.push(...this.adapter.constructionDiagnostics);\n    const incompatibleTypeCheckOptionsDiagnostic = verifyCompatibleTypeCheckOptions(this.options);\n    if (incompatibleTypeCheckOptionsDiagnostic !== null) {\n      this.constructionDiagnostics.push(incompatibleTypeCheckOptionsDiagnostic);\n    }\n\n    this.currentProgram = inputProgram;\n    this.closureCompilerEnabled = !!this.options.annotateForClosureCompiler;\n\n    this.entryPoint =\n        adapter.entryPoint !== null ? getSourceFileOrNull(inputProgram, adapter.entryPoint) : null;\n\n    const moduleResolutionCache = ts.createModuleResolutionCache(\n        this.adapter.getCurrentDirectory(),\n        // doen't retain a reference to `this`, if other closures in the constructor here reference\n        // `this` internally then a closure created here would retain them. This can cause major\n        // memory leak issues since the `moduleResolutionCache` is a long-lived object and finds its\n        // way into all kinds of places inside TS internal objects.\n        this.adapter.getCanonicalFileName.bind(this.adapter));\n    this.moduleResolver =\n        new ModuleResolver(inputProgram, this.options, this.adapter, moduleResolutionCache);\n    this.resourceManager = new AdapterResourceLoader(adapter, this.options);\n    this.cycleAnalyzer = new CycleAnalyzer(\n        new ImportGraph(inputProgram.getTypeChecker(), this.delegatingPerfRecorder));\n    this.incrementalStrategy.setIncrementalState(this.incrementalCompilation.state, inputProgram);\n\n    this.ignoreForDiagnostics =\n        new Set(inputProgram.getSourceFiles().filter(sf => this.adapter.isShim(sf)));\n    this.ignoreForEmit = this.adapter.ignoreForEmit;\n\n    let dtsFileCount = 0;\n    let nonDtsFileCount = 0;\n    for (const sf of inputProgram.getSourceFiles()) {\n      if (sf.isDeclarationFile) {\n        dtsFileCount++;\n      } else {\n        nonDtsFileCount++;\n      }\n    }\n\n    livePerfRecorder.eventCount(PerfEvent.InputDtsFile, dtsFileCount);\n    livePerfRecorder.eventCount(PerfEvent.InputTsFile, nonDtsFileCount);\n  }\n\n  get perfRecorder(): ActivePerfRecorder {\n    return this.livePerfRecorder;\n  }\n\n  /**\n   * Exposes the `IncrementalCompilation` under an old property name that the CLI uses, avoiding a\n   * chicken-and-egg problem with the rename to `incrementalCompilation`.\n   *\n   * TODO(alxhub): remove when the CLI uses the new name.\n   */\n  get incrementalDriver(): IncrementalCompilation {\n    return this.incrementalCompilation;\n  }\n\n  private updateWithChangedResources(\n      changedResources: Set<string>, perfRecorder: ActivePerfRecorder): void {\n    this.livePerfRecorder = perfRecorder;\n    this.delegatingPerfRecorder.target = perfRecorder;\n\n    perfRecorder.inPhase(PerfPhase.ResourceUpdate, () => {\n      if (this.compilation === null) {\n        // Analysis hasn't happened yet, so no update is necessary - any changes to resources will\n        // be captured by the inital analysis pass itself.\n        return;\n      }\n\n      this.resourceManager.invalidate();\n\n      const classesToUpdate = new Set<DeclarationNode>();\n      for (const resourceFile of changedResources) {\n        for (const templateClass of this.getComponentsWithTemplateFile(resourceFile)) {\n          classesToUpdate.add(templateClass);\n        }\n\n        for (const styleClass of this.getComponentsWithStyleFile(resourceFile)) {\n          classesToUpdate.add(styleClass);\n        }\n      }\n\n      for (const clazz of classesToUpdate) {\n        this.compilation.traitCompiler.updateResources(clazz);\n        if (!ts.isClassDeclaration(clazz)) {\n          continue;\n        }\n\n        this.compilation.templateTypeChecker.invalidateClass(clazz);\n      }\n    });\n  }\n\n  /**\n   * Get the resource dependencies of a file.\n   *\n   * If the file is not part of the compilation, an empty array will be returned.\n   */\n  getResourceDependencies(file: ts.SourceFile): string[] {\n    this.ensureAnalyzed();\n\n    return this.incrementalCompilation.depGraph.getResourceDependencies(file);\n  }\n\n  /**\n   * Get all Angular-related diagnostics for this compilation.\n   */\n  getDiagnostics(): ts.Diagnostic[] {\n    const diagnostics: ts.Diagnostic[] = [];\n    diagnostics.push(...this.getNonTemplateDiagnostics(), ...this.getTemplateDiagnostics());\n    if (this.options._extendedTemplateDiagnostics) {\n      diagnostics.push(...this.getExtendedTemplateDiagnostics());\n    }\n    return this.addMessageTextDetails(diagnostics);\n  }\n\n  /**\n   * Get all Angular-related diagnostics for this compilation.\n   *\n   * If a `ts.SourceFile` is passed, only diagnostics related to that file are returned.\n   */\n  getDiagnosticsForFile(file: ts.SourceFile, optimizeFor: OptimizeFor): ts.Diagnostic[] {\n    const diagnostics: ts.Diagnostic[] = [];\n    diagnostics.push(\n        ...this.getNonTemplateDiagnostics().filter(diag => diag.file === file),\n        ...this.getTemplateDiagnosticsForFile(file, optimizeFor));\n    if (this.options._extendedTemplateDiagnostics) {\n      diagnostics.push(...this.getExtendedTemplateDiagnostics(file));\n    }\n    return this.addMessageTextDetails(diagnostics);\n  }\n\n  /**\n   * Get all `ts.Diagnostic`s currently available that pertain to the given component.\n   */\n  getDiagnosticsForComponent(component: ts.ClassDeclaration): ts.Diagnostic[] {\n    const compilation = this.ensureAnalyzed();\n    const ttc = compilation.templateTypeChecker;\n    const diagnostics: ts.Diagnostic[] = [];\n    diagnostics.push(...ttc.getDiagnosticsForComponent(component));\n    if (this.options._extendedTemplateDiagnostics) {\n      const extendedTemplateChecker = compilation.extendedTemplateChecker;\n      diagnostics.push(...extendedTemplateChecker.getDiagnosticsForComponent(component));\n    }\n    return this.addMessageTextDetails(diagnostics);\n  }\n\n  /**\n   * Add Angular.io error guide links to diagnostics for this compilation.\n   */\n  private addMessageTextDetails(diagnostics: ts.Diagnostic[]): ts.Diagnostic[] {\n    return diagnostics.map(diag => {\n      if (diag.code && COMPILER_ERRORS_WITH_GUIDES.has(ngErrorCode(diag.code))) {\n        return {\n          ...diag,\n          messageText: diag.messageText +\n              `. Find more at ${ERROR_DETAILS_PAGE_BASE_URL}/NG${ngErrorCode(diag.code)}`\n        };\n      }\n      return diag;\n    });\n  }\n\n  /**\n   * Get all setup-related diagnostics for this compilation.\n   */\n  getOptionDiagnostics(): ts.Diagnostic[] {\n    return this.constructionDiagnostics;\n  }\n\n  /**\n   * Get the current `ts.Program` known to this `NgCompiler`.\n   *\n   * Compilation begins with an input `ts.Program`, and during template type-checking operations new\n   * `ts.Program`s may be produced using the `ProgramDriver`. The most recent such `ts.Program` to\n   * be produced is available here.\n   *\n   * This `ts.Program` serves two key purposes:\n   *\n   * * As an incremental starting point for creating the next `ts.Program` based on files that the\n   *   user has changed (for clients using the TS compiler program APIs).\n   *\n   * * As the \"before\" point for an incremental compilation invocation, to determine what's changed\n   *   between the old and new programs (for all compilations).\n   */\n  getCurrentProgram(): ts.Program {\n    return this.currentProgram;\n  }\n\n  getTemplateTypeChecker(): TemplateTypeChecker {\n    if (!this.enableTemplateTypeChecker) {\n      throw new Error(\n          'The `TemplateTypeChecker` does not work without `enableTemplateTypeChecker`.');\n    }\n    return this.ensureAnalyzed().templateTypeChecker;\n  }\n\n  /**\n   * Retrieves the `ts.Declaration`s for any component(s) which use the given template file.\n   */\n  getComponentsWithTemplateFile(templateFilePath: string): ReadonlySet<DeclarationNode> {\n    const {resourceRegistry} = this.ensureAnalyzed();\n    return resourceRegistry.getComponentsWithTemplate(resolve(templateFilePath));\n  }\n\n  /**\n   * Retrieves the `ts.Declaration`s for any component(s) which use the given template file.\n   */\n  getComponentsWithStyleFile(styleFilePath: string): ReadonlySet<DeclarationNode> {\n    const {resourceRegistry} = this.ensureAnalyzed();\n    return resourceRegistry.getComponentsWithStyle(resolve(styleFilePath));\n  }\n\n  /**\n   * Retrieves external resources for the given component.\n   */\n  getComponentResources(classDecl: DeclarationNode): ComponentResources|null {\n    if (!isNamedClassDeclaration(classDecl)) {\n      return null;\n    }\n    const {resourceRegistry} = this.ensureAnalyzed();\n    const styles = resourceRegistry.getStyles(classDecl);\n    const template = resourceRegistry.getTemplate(classDecl);\n    if (template === null) {\n      return null;\n    }\n\n    return {styles, template};\n  }\n\n  getMeta(classDecl: DeclarationNode): PipeMeta|DirectiveMeta|null {\n    if (!isNamedClassDeclaration(classDecl)) {\n      return null;\n    }\n    const ref = new Reference(classDecl);\n    const {metaReader} = this.ensureAnalyzed();\n    const meta = metaReader.getPipeMetadata(ref) ?? metaReader.getDirectiveMetadata(ref);\n    if (meta === null) {\n      return null;\n    }\n    return meta;\n  }\n\n  /**\n   * Perform Angular's analysis step (as a precursor to `getDiagnostics` or `prepareEmit`)\n   * asynchronously.\n   *\n   * Normally, this operation happens lazily whenever `getDiagnostics` or `prepareEmit` are called.\n   * However, certain consumers may wish to allow for an asynchronous phase of analysis, where\n   * resources such as `styleUrls` are resolved asynchonously. In these cases `analyzeAsync` must be\n   * called first, and its `Promise` awaited prior to calling any other APIs of `NgCompiler`.\n   */\n  async analyzeAsync(): Promise<void> {\n    if (this.compilation !== null) {\n      return;\n    }\n\n    await this.perfRecorder.inPhase(PerfPhase.Analysis, async () => {\n      this.compilation = this.makeCompilation();\n\n      const promises: Promise<void>[] = [];\n      for (const sf of this.inputProgram.getSourceFiles()) {\n        if (sf.isDeclarationFile) {\n          continue;\n        }\n\n        let analysisPromise = this.compilation.traitCompiler.analyzeAsync(sf);\n        if (analysisPromise !== undefined) {\n          promises.push(analysisPromise);\n        }\n      }\n\n      await Promise.all(promises);\n\n      this.perfRecorder.memory(PerfCheckpoint.Analysis);\n      this.resolveCompilation(this.compilation.traitCompiler);\n    });\n  }\n\n  /**\n   * List lazy routes detected during analysis.\n   *\n   * This can be called for one specific route, or to retrieve all top-level routes.\n   */\n  listLazyRoutes(entryRoute?: string): LazyRoute[] {\n    if (entryRoute) {\n      // htts://github.com/angular/angular/blob/50732e156/packages/compiler-cli/src/transformers/compiler_host.ts#L175-L188).\n      //\n      // `@angular/cli` will always call this API with an absolute path, so the resolution step is\n      // not necessary, but keeping it backwards compatible in case someone else is using the API.\n\n      // Relative entry paths are disallowed.\n      if (entryRoute.startsWith('.')) {\n        throw new Error(`Failed to list lazy routes: Resolution of relative paths (${\n            entryRoute}) is not supported.`);\n      }\n\n      // Non-relative entry paths fall into one of the following categories:\n      // - Absolute system paths (e.g. `/foo/bar/my-project/my-module`), which are unaffected by the\n      //   logic below.\n      // - Paths to enternal modules (e.g. `some-lib`).\n      // - Paths mapped to directories in `tsconfig.json` (e.g. `shared/my-module`).\n      //   (See https://www.typescriptlang.org/docs/handbook/module-resolution.html#path-mapping.)\n      //\n      // In all cases above, the `containingFile` argument is ignored, so we can just take the first\n      // of the root files.\n      const containingFile = this.inputProgram.getRootFileNames()[0];\n      const [entryPath, moduleName] = entryRoute.split('#');\n      const resolvedModule =\n          resolveModuleName(entryPath, containingFile, this.options, this.adapter, null);\n\n      if (resolvedModule) {\n        entryRoute = entryPointKeyFor(resolvedModule.resolvedFileName, moduleName);\n      }\n    }\n\n    const compilation = this.ensureAnalyzed();\n    return compilation.routeAnalyzer.listLazyRoutes(entryRoute);\n  }\n\n  /**\n   * Fetch transformers and other information which is necessary for a consumer to `emit` the\n   * program with Angular-added definitions.\n   */\n  prepareEmit(): {\n    transformers: ts.CustomTransformers,\n  } {\n    const compilation = this.ensureAnalyzed();\n\n    const coreImportsFrom = compilation.isCore ? getR3SymbolsFile(this.inputProgram) : null;\n    let importRewriter: ImportRewriter;\n    if (coreImportsFrom !== null) {\n      importRewriter = new R3SymbolsImportRewriter(coreImportsFrom.fileName);\n    } else {\n      importRewriter = new NoopImportRewriter();\n    }\n\n    const defaultImportTracker = new DefaultImportTracker();\n\n    const before = [\n      ivyTransformFactory(\n          compilation.traitCompiler, compilation.reflector, importRewriter, defaultImportTracker,\n          this.delegatingPerfRecorder, compilation.isCore, this.closureCompilerEnabled),\n      aliasTransformFactory(compilation.traitCompiler.exportStatements),\n      defaultImportTracker.importPreservingTransformer(),\n    ];\n\n    const afterDeclarations: ts.TransformerFactory<ts.SourceFile>[] = [];\n    if (compilation.dtsTransforms !== null) {\n      afterDeclarations.push(\n          declarationTransformFactory(compilation.dtsTransforms, importRewriter));\n    }\n\n    // Only add aliasing re-exports to the .d.ts output if the `AliasingHost` requests it.\n    if (compilation.aliasingHost !== null && compilation.aliasingHost.aliasExportsInDts) {\n      afterDeclarations.push(aliasTransformFactory(compilation.traitCompiler.exportStatements));\n    }\n\n    if (this.adapter.factoryTracker !== null) {\n      before.push(\n          generatedFactoryTransform(this.adapter.factoryTracker.sourceInfo, importRewriter));\n    }\n    before.push(ivySwitchTransform);\n\n    return {transformers: {before, afterDeclarations} as ts.CustomTransformers};\n  }\n\n  /**\n   * Run the indexing process and return a `Map` of all indexed components.\n   *\n   * See the `indexing` package for more details.\n   */\n  getIndexedComponents(): Map<DeclarationNode, IndexedComponent> {\n    const compilation = this.ensureAnalyzed();\n    const context = new IndexingContext();\n    compilation.traitCompiler.index(context);\n    return generateAnalysis(context);\n  }\n\n  /**\n   * Collect i18n messages into the `Xi18nContext`.\n   */\n  xi18n(ctx: Xi18nContext): void {\n    // Note that the 'resolve' phase is not strictly necessary for xi18n, but this is not currently\n    // optimized.\n    const compilation = this.ensureAnalyzed();\n    compilation.traitCompiler.xi18n(ctx);\n  }\n\n  private ensureAnalyzed(this: NgCompiler): LazyCompilationState {\n    if (this.compilation === null) {\n      this.analyzeSync();\n    }\n    return this.compilation!;\n  }\n\n  private analyzeSync(): void {\n    this.perfRecorder.inPhase(PerfPhase.Analysis, () => {\n      this.compilation = this.makeCompilation();\n      for (const sf of this.inputProgram.getSourceFiles()) {\n        if (sf.isDeclarationFile) {\n          continue;\n        }\n        this.compilation.traitCompiler.analyzeSync(sf);\n      }\n\n      this.perfRecorder.memory(PerfCheckpoint.Analysis);\n\n      this.resolveCompilation(this.compilation.traitCompiler);\n    });\n  }\n\n  private resolveCompilation(traitCompiler: TraitCompiler): void {\n    this.perfRecorder.inPhase(PerfPhase.Resolve, () => {\n      traitCompiler.resolve();\n\n      // At this point, analysis is complete and the compiler can now calculate which files need to\n      // be emitted, so do that.\n      this.incrementalCompilation.recordSuccessfulAnalysis(traitCompiler);\n\n      this.perfRecorder.memory(PerfCheckpoint.Resolve);\n    });\n  }\n\n  private get fullTemplateTypeCheck(): boolean {\n    // Determine the strictness level of type checking based on compiler options. As\n    // `strictTemplates` is a superset of `fullTemplateTypeCheck`, the former implies the latter.\n    // Also see `verifyCompatibleTypeCheckOptions` where it is verified that `fullTemplateTypeCheck`\n    // is not disabled when `strictTemplates` is enabled.\n    const strictTemplates = !!this.options.strictTemplates;\n    return strictTemplates || !!this.options.fullTemplateTypeCheck;\n  }\n\n  private getTypeCheckingConfig(): TypeCheckingConfig {\n    // Determine the strictness level of type checking based on compiler options. As\n    // `strictTemplates` is a superset of `fullTemplateTypeCheck`, the former implies the latter.\n    // Also see `verifyCompatibleTypeCheckOptions` where it is verified that `fullTemplateTypeCheck`\n    // is not disabled when `strictTemplates` is enabled.\n    const strictTemplates = !!this.options.strictTemplates;\n\n    const useInlineTypeConstructors = this.programDriver.supportsInlineOperations;\n\n    // First select a type-checking configuration, based on whether full template type-checking is\n    // requested.\n    let typeCheckingConfig: TypeCheckingConfig;\n    if (this.fullTemplateTypeCheck) {\n      typeCheckingConfig = {\n        applyTemplateContextGuards: strictTemplates,\n        checkQueries: false,\n        checkTemplateBodies: true,\n        alwaysCheckSchemaInTemplateBodies: true,\n        checkTypeOfInputBindings: strictTemplates,\n        honorAccessModifiersForInputBindings: false,\n        strictNullInputBindings: strictTemplates,\n        checkTypeOfAttributes: strictTemplates,\n        // Even in full template type-checking mode, DOM binding checks are not quite ready yet.\n        checkTypeOfDomBindings: false,\n        checkTypeOfOutputEvents: strictTemplates,\n        checkTypeOfAnimationEvents: strictTemplates,\n        // Checking of DOM events currently has an adverse effect on developer experience,\n        // e.g. for `<input (blur)=\"update($event.target.value)\">` enabling this check results in:\n        // - error TS2531: Object is possibly 'null'.\n        // - error TS2339: Property 'value' does not exist on type 'EventTarget'.\n        checkTypeOfDomEvents: strictTemplates,\n        checkTypeOfDomReferences: strictTemplates,\n        // Non-DOM references have the correct type in View Engine so there is no strictness flag.\n        checkTypeOfNonDomReferences: true,\n        // Pipes are checked in View Engine so there is no strictness flag.\n        checkTypeOfPipes: true,\n        strictSafeNavigationTypes: strictTemplates,\n        useContextGenericType: strictTemplates,\n        strictLiteralTypes: true,\n        enableTemplateTypeChecker: this.enableTemplateTypeChecker,\n        useInlineTypeConstructors,\n        // Warnings for suboptimal type inference are only enabled if in Language Service mode\n        // (providing the full TemplateTypeChecker API) and if strict mode is not enabled. In strict\n        // mode, the user is in full control of type inference.\n        suggestionsForSuboptimalTypeInference: this.enableTemplateTypeChecker && !strictTemplates,\n      };\n    } else {\n      typeCheckingConfig = {\n        applyTemplateContextGuards: false,\n        checkQueries: false,\n        checkTemplateBodies: false,\n        // Enable deep schema checking in \"basic\" template type-checking mode only if Closure\n        // compilation is requested, which is a good proxy for \"only in google3\".\n        alwaysCheckSchemaInTemplateBodies: this.closureCompilerEnabled,\n        checkTypeOfInputBindings: false,\n        strictNullInputBindings: false,\n        honorAccessModifiersForInputBindings: false,\n        checkTypeOfAttributes: false,\n        checkTypeOfDomBindings: false,\n        checkTypeOfOutputEvents: false,\n        checkTypeOfAnimationEvents: false,\n        checkTypeOfDomEvents: false,\n        checkTypeOfDomReferences: false,\n        checkTypeOfNonDomReferences: false,\n        checkTypeOfPipes: false,\n        strictSafeNavigationTypes: false,\n        useContextGenericType: false,\n        strictLiteralTypes: false,\n        enableTemplateTypeChecker: this.enableTemplateTypeChecker,\n        useInlineTypeConstructors,\n        // In \"basic\" template type-checking mode, no warnings are produced since most things are\n        // not checked anyways.\n        suggestionsForSuboptimalTypeInference: false,\n      };\n    }\n\n    // Apply explicitly configured strictness flags on top of the default configuration\n    // based on \"fullTemplateTypeCheck\".\n    if (this.options.strictInputTypes !== undefined) {\n      typeCheckingConfig.checkTypeOfInputBindings = this.options.strictInputTypes;\n      typeCheckingConfig.applyTemplateContextGuards = this.options.strictInputTypes;\n    }\n    if (this.options.strictInputAccessModifiers !== undefined) {\n      typeCheckingConfig.honorAccessModifiersForInputBindings =\n          this.options.strictInputAccessModifiers;\n    }\n    if (this.options.strictNullInputTypes !== undefined) {\n      typeCheckingConfig.strictNullInputBindings = this.options.strictNullInputTypes;\n    }\n    if (this.options.strictOutputEventTypes !== undefined) {\n      typeCheckingConfig.checkTypeOfOutputEvents = this.options.strictOutputEventTypes;\n      typeCheckingConfig.checkTypeOfAnimationEvents = this.options.strictOutputEventTypes;\n    }\n    if (this.options.strictDomEventTypes !== undefined) {\n      typeCheckingConfig.checkTypeOfDomEvents = this.options.strictDomEventTypes;\n    }\n    if (this.options.strictSafeNavigationTypes !== undefined) {\n      typeCheckingConfig.strictSafeNavigationTypes = this.options.strictSafeNavigationTypes;\n    }\n    if (this.options.strictDomLocalRefTypes !== undefined) {\n      typeCheckingConfig.checkTypeOfDomReferences = this.options.strictDomLocalRefTypes;\n    }\n    if (this.options.strictAttributeTypes !== undefined) {\n      typeCheckingConfig.checkTypeOfAttributes = this.options.strictAttributeTypes;\n    }\n    if (this.options.strictContextGenerics !== undefined) {\n      typeCheckingConfig.useContextGenericType = this.options.strictContextGenerics;\n    }\n    if (this.options.strictLiteralTypes !== undefined) {\n      typeCheckingConfig.strictLiteralTypes = this.options.strictLiteralTypes;\n    }\n\n    return typeCheckingConfig;\n  }\n\n  private getTemplateDiagnostics(): ReadonlyArray<ts.Diagnostic> {\n    const compilation = this.ensureAnalyzed();\n\n    // Get the diagnostics.\n    const diagnostics: ts.Diagnostic[] = [];\n    for (const sf of this.inputProgram.getSourceFiles()) {\n      if (sf.isDeclarationFile || this.adapter.isShim(sf)) {\n        continue;\n      }\n\n      diagnostics.push(\n          ...compilation.templateTypeChecker.getDiagnosticsForFile(sf, OptimizeFor.WholeProgram));\n    }\n\n    const program = this.programDriver.getProgram();\n    this.incrementalStrategy.setIncrementalState(this.incrementalCompilation.state, program);\n    this.currentProgram = program;\n\n    return diagnostics;\n  }\n\n  private getTemplateDiagnosticsForFile(sf: ts.SourceFile, optimizeFor: OptimizeFor):\n      ReadonlyArray<ts.Diagnostic> {\n    const compilation = this.ensureAnalyzed();\n\n    // Get the diagnostics.\n    const diagnostics: ts.Diagnostic[] = [];\n    if (!sf.isDeclarationFile && !this.adapter.isShim(sf)) {\n      diagnostics.push(...compilation.templateTypeChecker.getDiagnosticsForFile(sf, optimizeFor));\n    }\n\n    const program = this.programDriver.getProgram();\n    this.incrementalStrategy.setIncrementalState(this.incrementalCompilation.state, program);\n    this.currentProgram = program;\n\n    return diagnostics;\n  }\n\n  private getNonTemplateDiagnostics(): ts.Diagnostic[] {\n    if (this.nonTemplateDiagnostics === null) {\n      const compilation = this.ensureAnalyzed();\n      this.nonTemplateDiagnostics = [...compilation.traitCompiler.diagnostics];\n      if (this.entryPoint !== null && compilation.exportReferenceGraph !== null) {\n        this.nonTemplateDiagnostics.push(...checkForPrivateExports(\n            this.entryPoint, this.inputProgram.getTypeChecker(), compilation.exportReferenceGraph));\n      }\n    }\n    return this.nonTemplateDiagnostics;\n  }\n\n  /**\n   * Calls the `extendedTemplateCheck` phase of the trait compiler\n   * @param sf optional parameter to get diagnostics for a certain file\n   *     or all files in the program if `sf` is undefined\n   * @returns generated extended template diagnostics\n   */\n  private getExtendedTemplateDiagnostics(sf?: ts.SourceFile): ts.Diagnostic[] {\n    const diagnostics: ts.Diagnostic[] = [];\n    const compilation = this.ensureAnalyzed();\n    const extendedTemplateChecker = compilation.extendedTemplateChecker;\n    if (sf !== undefined) {\n      return compilation.traitCompiler.extendedTemplateCheck(sf, extendedTemplateChecker);\n    }\n    for (const sf of this.inputProgram.getSourceFiles()) {\n      diagnostics.push(\n          ...compilation.traitCompiler.extendedTemplateCheck(sf, extendedTemplateChecker));\n    }\n\n    return diagnostics;\n  }\n\n  private makeCompilation(): LazyCompilationState {\n    const checker = this.inputProgram.getTypeChecker();\n\n    const reflector = new TypeScriptReflectionHost(checker);\n\n    // Construct the ReferenceEmitter.\n    let refEmitter: ReferenceEmitter;\n    let aliasingHost: AliasingHost|null = null;\n    if (this.adapter.unifiedModulesHost === null || !this.options._useHostForImportGeneration) {\n      let localImportStrategy: ReferenceEmitStrategy;\n\n      // The strategy used for local, in-project imports depends on whether TS has been configured\n      // with rootDirs. If so, then multiple directories may be mapped in the same \"module\n      // namespace\" and the logic of `LogicalProjectStrategy` is required to generate correct\n      // imports which may cross these multiple directories. Otherwise, plain relative imports are\n      // sufficient.\n      if (this.options.rootDir !== undefined ||\n          (this.options.rootDirs !== undefined && this.options.rootDirs.length > 0)) {\n        // rootDirs logic is in effect - use the `LogicalProjectStrategy` for in-project relative\n        // imports.\n        localImportStrategy = new LogicalProjectStrategy(\n            reflector, new LogicalFileSystem([...this.adapter.rootDirs], this.adapter));\n      } else {\n        // Plain relative imports are all that's needed.\n        localImportStrategy = new RelativePathStrategy(reflector);\n      }\n\n      // The CompilerHost doesn't have fileNameToModuleName, so build an NPM-centric reference\n      // resolution strategy.\n      refEmitter = new ReferenceEmitter([\n        // First, try to use local identifiers if available.\n        new LocalIdentifierStrategy(),\n        // Next, attempt to use an absolute import.\n        new AbsoluteModuleStrategy(this.inputProgram, checker, this.moduleResolver, reflector),\n        // Finally, check if the reference is being written into a file within the project's .ts\n        // sources, and use a relative import if so. If this fails, ReferenceEmitter will throw\n        // an error.\n        localImportStrategy,\n      ]);\n\n      // If an entrypoint is present, then all user imports should be directed through the\n      // entrypoint and private exports are not needed. The compiler will validate that all publicly\n      // visible directives/pipes are importable via this entrypoint.\n      if (this.entryPoint === null && this.options.generateDeepReexports === true) {\n        // No entrypoint is present and deep re-exports were requested, so configure the aliasing\n        // system to generate them.\n        aliasingHost = new PrivateExportAliasingHost(reflector);\n      }\n    } else {\n      // The CompilerHost supports fileNameToModuleName, so use that to emit imports.\n      refEmitter = new ReferenceEmitter([\n        // First, try to use local identifiers if available.\n        new LocalIdentifierStrategy(),\n        // Then use aliased references (this is a workaround to StrictDeps checks).\n        new AliasStrategy(),\n        // Then use fileNameToModuleName to emit imports.\n        new UnifiedModulesStrategy(reflector, this.adapter.unifiedModulesHost),\n      ]);\n      aliasingHost = new UnifiedModulesAliasingHost(this.adapter.unifiedModulesHost);\n    }\n\n    const evaluator =\n        new PartialEvaluator(reflector, checker, this.incrementalCompilation.depGraph);\n    const dtsReader = new DtsMetadataReader(checker, reflector);\n    const localMetaRegistry = new LocalMetadataRegistry();\n    const localMetaReader: MetadataReader = localMetaRegistry;\n    const depScopeReader = new MetadataDtsModuleScopeResolver(dtsReader, aliasingHost);\n    const scopeRegistry =\n        new LocalModuleScopeRegistry(localMetaReader, depScopeReader, refEmitter, aliasingHost);\n    const scopeReader: ComponentScopeReader = scopeRegistry;\n    const semanticDepGraphUpdater = this.incrementalCompilation.semanticDepGraphUpdater;\n    const metaRegistry = new CompoundMetadataRegistry([localMetaRegistry, scopeRegistry]);\n    const injectableRegistry = new InjectableClassRegistry(reflector);\n\n    const metaReader = new CompoundMetadataReader([localMetaReader, dtsReader]);\n    const typeCheckScopeRegistry = new TypeCheckScopeRegistry(scopeReader, metaReader);\n\n\n    // If a flat module entrypoint was specified, then track references via a `ReferenceGraph` in\n    // order to produce proper diagnostics for incorrectly exported directives/pipes/etc. If there\n    // is no flat module entrypoint then don't pay the cost of tracking references.\n    let referencesRegistry: ReferencesRegistry;\n    let exportReferenceGraph: ReferenceGraph|null = null;\n    if (this.entryPoint !== null) {\n      exportReferenceGraph = new ReferenceGraph();\n      referencesRegistry = new ReferenceGraphAdapter(exportReferenceGraph);\n    } else {\n      referencesRegistry = new NoopReferencesRegistry();\n    }\n\n    const routeAnalyzer = new NgModuleRouteAnalyzer(this.moduleResolver, evaluator);\n\n    const dtsTransforms = new DtsTransformRegistry();\n\n    const isCore = isAngularCorePackage(this.inputProgram);\n\n    const resourceRegistry = new ResourceRegistry();\n\n    const compilationMode =\n        this.options.compilationMode === 'partial' ? CompilationMode.PARTIAL : CompilationMode.FULL;\n\n    // Cycles are handled in full compilation mode by \"remote scoping\".\n    // \"Remote scoping\" does not work well with tree shaking for libraries.\n    // So in partial compilation mode, when building a library, a cycle will cause an error.\n    const cycleHandlingStrategy = compilationMode === CompilationMode.FULL ?\n        CycleHandlingStrategy.UseRemoteScoping :\n        CycleHandlingStrategy.Error;\n\n    // Set up the IvyCompilation, which manages state for the Ivy transformer.\n    const handlers: DecoratorHandler<unknown, unknown, SemanticSymbol|null, unknown>[] = [\n      new ComponentDecoratorHandler(\n          reflector, evaluator, metaRegistry, metaReader, scopeReader, scopeRegistry,\n          typeCheckScopeRegistry, resourceRegistry, isCore, this.resourceManager,\n          this.adapter.rootDirs, this.options.preserveWhitespaces || false,\n          this.options.i18nUseExternalIds !== false,\n          this.options.enableI18nLegacyMessageIdFormat !== false, this.usePoisonedData,\n          this.options.i18nNormalizeLineEndingsInICUs, this.moduleResolver, this.cycleAnalyzer,\n          cycleHandlingStrategy, refEmitter, this.incrementalCompilation.depGraph,\n          injectableRegistry, semanticDepGraphUpdater, this.closureCompilerEnabled,\n          this.delegatingPerfRecorder),\n\n      // TODO(alxhub): understand why the cast here is necessary (something to do with `null`\n      // not being assignable to `unknown` when wrapped in `Readonly`).\n      // clang-format off\n        new DirectiveDecoratorHandler(\n            reflector, evaluator, metaRegistry, scopeRegistry, metaReader,\n            injectableRegistry, isCore, semanticDepGraphUpdater,\n          this.closureCompilerEnabled, /** compileUndecoratedClassesWithAngularFeatures */ false,\n          this.delegatingPerfRecorder,\n        ) as Readonly<DecoratorHandler<unknown, unknown, SemanticSymbol | null,unknown>>,\n      // clang-format on\n      // Pipe handler must be before injectable handler in list so pipe factories are printed\n      // before injectable factories (so injectable factories can delegate to them)\n      new PipeDecoratorHandler(\n          reflector, evaluator, metaRegistry, scopeRegistry, injectableRegistry, isCore,\n          this.delegatingPerfRecorder),\n      new InjectableDecoratorHandler(\n          reflector, isCore, this.options.strictInjectionParameters || false, injectableRegistry,\n          this.delegatingPerfRecorder),\n      new NgModuleDecoratorHandler(\n          reflector, evaluator, metaReader, metaRegistry, scopeRegistry, referencesRegistry, isCore,\n          routeAnalyzer, refEmitter, this.adapter.factoryTracker, this.closureCompilerEnabled,\n          injectableRegistry, this.delegatingPerfRecorder, this.options.i18nInLocale),\n    ];\n\n    const traitCompiler = new TraitCompiler(\n        handlers, reflector, this.delegatingPerfRecorder, this.incrementalCompilation,\n        this.options.compileNonExportedClasses !== false, compilationMode, dtsTransforms,\n        semanticDepGraphUpdater);\n\n    // Template type-checking may use the `ProgramDriver` to produce new `ts.Program`(s). If this\n    // happens, they need to be tracked by the `NgCompiler`.\n    const notifyingDriver =\n        new NotifyingProgramDriverWrapper(this.programDriver, (program: ts.Program) => {\n          this.incrementalStrategy.setIncrementalState(this.incrementalCompilation.state, program);\n          this.currentProgram = program;\n        });\n\n    const templateTypeChecker = new TemplateTypeCheckerImpl(\n        this.inputProgram, notifyingDriver, traitCompiler, this.getTypeCheckingConfig(), refEmitter,\n        reflector, this.adapter, this.incrementalCompilation, scopeRegistry, typeCheckScopeRegistry,\n        this.delegatingPerfRecorder);\n\n    const templateChecks: TemplateCheck<ErrorCode>[] = [new InvalidBananaInBoxCheck()];\n    if (this.options.strictNullChecks) {\n      templateChecks.push(new NullishCoalescingNotNullableCheck());\n    }\n    const extendedTemplateChecker =\n        new ExtendedTemplateCheckerImpl(templateTypeChecker, checker, templateChecks);\n\n    return {\n      isCore,\n      traitCompiler,\n      reflector,\n      scopeRegistry,\n      dtsTransforms,\n      exportReferenceGraph,\n      routeAnalyzer,\n      metaReader,\n      typeCheckScopeRegistry,\n      aliasingHost,\n      refEmitter,\n      templateTypeChecker,\n      resourceRegistry,\n      extendedTemplateChecker\n    };\n  }\n}\n\n/**\n * Determine if the given `Program` is @angular/core.\n */\nexport function isAngularCorePackage(program: ts.Program): boolean {\n  // Look for its_just_angular.ts somewhere in the program.\n  const r3Symbols = getR3SymbolsFile(program);\n  if (r3Symbols === null) {\n    return false;\n  }\n\n  // Look for the constant ITS_JUST_ANGULAR in that file.\n  return r3Symbols.statements.some(stmt => {\n    // The statement must be a variable declaration statement.\n    if (!ts.isVariableStatement(stmt)) {\n      return false;\n    }\n    // It must be exported.\n    if (stmt.modifiers === undefined ||\n        !stmt.modifiers.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword)) {\n      return false;\n    }\n    // It must declare ITS_JUST_ANGULAR.\n    return stmt.declarationList.declarations.some(decl => {\n      // The declaration must match the name.\n      if (!ts.isIdentifier(decl.name) || decl.name.text !== 'ITS_JUST_ANGULAR') {\n        return false;\n      }\n      // It must initialize the variable to true.\n      if (decl.initializer === undefined || decl.initializer.kind !== ts.SyntaxKind.TrueKeyword) {\n        return false;\n      }\n      // This definition matches.\n      return true;\n    });\n  });\n}\n\n/**\n * Find the 'r3_symbols.ts' file in the given `Program`, or return `null` if it wasn't there.\n */\nfunction getR3SymbolsFile(program: ts.Program): ts.SourceFile|null {\n  return program.getSourceFiles().find(file => file.fileName.indexOf('r3_symbols.ts') >= 0) || null;\n}\n\n/**\n * Since \"strictTemplates\" is a true superset of type checking capabilities compared to\n * \"fullTemplateTypeCheck\", it is required that the latter is not explicitly disabled if the\n * former is enabled.\n */\nfunction verifyCompatibleTypeCheckOptions(options: NgCompilerOptions): ts.Diagnostic|null {\n  if (options.fullTemplateTypeCheck === false && options.strictTemplates === true) {\n    return {\n      category: ts.DiagnosticCategory.Error,\n      code: ngErrorCode(ErrorCode.CONFIG_STRICT_TEMPLATES_IMPLIES_FULL_TEMPLATE_TYPECHECK),\n      file: undefined,\n      start: undefined,\n      length: undefined,\n      messageText:\n          `Angular compiler option \"strictTemplates\" is enabled, however \"fullTemplateTypeCheck\" is disabled.\n\nHaving the \"strictTemplates\" flag enabled implies that \"fullTemplateTypeCheck\" is also enabled, so\nthe latter can not be explicitly disabled.\n\nOne of the following actions is required:\n1. Remove the \"fullTemplateTypeCheck\" option.\n2. Remove \"strictTemplates\" or set it to 'false'.\n\nMore information about the template type checking compiler options can be found in the documentation:\nhttps://v9.angular.io/guide/template-typecheck#template-type-checking`,\n    };\n  }\n\n  return null;\n}\n\nclass ReferenceGraphAdapter implements ReferencesRegistry {\n  constructor(private graph: ReferenceGraph) {}\n\n  add(source: DeclarationNode, ...references: Reference<DeclarationNode>[]): void {\n    for (const {node} of references) {\n      let sourceFile = node.getSourceFile();\n      if (sourceFile === undefined) {\n        sourceFile = ts.getOriginalNode(node).getSourceFile();\n      }\n\n      // Only record local references (not references into .d.ts files).\n      if (sourceFile === undefined || !isDtsPath(sourceFile.fileName)) {\n        this.graph.add(source, node);\n      }\n    }\n  }\n}\n\nclass NotifyingProgramDriverWrapper implements ProgramDriver {\n  constructor(\n      private delegate: ProgramDriver, private notifyNewProgram: (program: ts.Program) => void) {}\n\n  get supportsInlineOperations() {\n    return this.delegate.supportsInlineOperations;\n  }\n\n  getProgram(): ts.Program {\n    return this.delegate.getProgram();\n  }\n\n  updateFiles(contents: Map<AbsoluteFsPath, FileUpdate>, updateMode: UpdateMode): void {\n    this.delegate.updateFiles(contents, updateMode);\n    this.notifyNewProgram(this.delegate.getProgram());\n  }\n\n  getSourceFileVersion = this.delegate.getSourceFileVersion?.bind(this);\n}\n\nfunction versionMapFromProgram(\n    program: ts.Program, driver: ProgramDriver): Map<AbsoluteFsPath, string>|null {\n  if (driver.getSourceFileVersion === undefined) {\n    return null;\n  }\n\n  const versions = new Map<AbsoluteFsPath, string>();\n  for (const possiblyRedirectedSourceFile of program.getSourceFiles()) {\n    const sf = toUnredirectedSourceFile(possiblyRedirectedSourceFile);\n    versions.set(absoluteFromSourceFile(sf), driver.getSourceFileVersion(sf));\n  }\n  return versions;\n}\n"]}