@angular/compiler-cli 10.0.6 → 10.0.10

package/src/ngtsc/typecheck/src/checker.js

@@ -11,25 +11,28 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/src/ngtsc/typecheck/src/checker", ["require", "exports", "tslib", "@angular/compiler-cli/src/ngtsc/file_system", "@angular/compiler-cli/src/ngtsc/shims", "@angular/compiler-cli/src/ngtsc/typecheck/src/api", "@angular/compiler-cli/src/ngtsc/typecheck/src/context", "@angular/compiler-cli/src/ngtsc/typecheck/src/diagnostics"], factory);
+        define("@angular/compiler-cli/src/ngtsc/typecheck/src/checker", ["require", "exports", "tslib", "@angular/compiler", "@angular/compiler-cli/src/ngtsc/file_system", "@angular/compiler-cli/src/ngtsc/shims", "@angular/compiler-cli/src/ngtsc/util/src/typescript", "@angular/compiler-cli/src/ngtsc/typecheck/api", "@angular/compiler-cli/src/ngtsc/typecheck/src/context", "@angular/compiler-cli/src/ngtsc/typecheck/src/diagnostics", "@angular/compiler-cli/src/ngtsc/typecheck/src/source"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.TemplateTypeChecker = void 0;
+    exports.TemplateTypeCheckerImpl = void 0;
     var tslib_1 = require("tslib");
+    var compiler_1 = require("@angular/compiler");
     var file_system_1 = require("@angular/compiler-cli/src/ngtsc/file_system");
     var shims_1 = require("@angular/compiler-cli/src/ngtsc/shims");
-    var api_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/src/api");
+    var typescript_1 = require("@angular/compiler-cli/src/ngtsc/util/src/typescript");
+    var api_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/api");
     var context_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/src/context");
     var diagnostics_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/src/diagnostics");
+    var source_1 = require("@angular/compiler-cli/src/ngtsc/typecheck/src/source");
     /**
      * Primary template type-checking engine, which performs type-checking using a
      * `TypeCheckingProgramStrategy` for type-checking program maintenance, and the
      * `ProgramTypeCheckAdapter` for generation of template type-checking code.
      */
-    var TemplateTypeChecker = /** @class */ (function () {
-        function TemplateTypeChecker(originalProgram, typeCheckingStrategy, typeCheckAdapter, config, refEmitter, reflector, compilerHost, priorBuild) {
+    var TemplateTypeCheckerImpl = /** @class */ (function () {
+        function TemplateTypeCheckerImpl(originalProgram, typeCheckingStrategy, typeCheckAdapter, config, refEmitter, reflector, compilerHost, priorBuild) {
             this.originalProgram = originalProgram;
             this.typeCheckingStrategy = typeCheckingStrategy;
             this.typeCheckAdapter = typeCheckAdapter;
@@ -38,88 +41,417 @@
             this.reflector = reflector;
             this.compilerHost = compilerHost;
             this.priorBuild = priorBuild;
-            this.files = new Map();
+            this.state = new Map();
+            this.isComplete = false;
         }
-        /**
-         * Reset the internal type-checking program by generating type-checking code from the user's
-         * program.
-         */
-        TemplateTypeChecker.prototype.refresh = function () {
-            var e_1, _a, e_2, _b;
-            this.files.clear();
-            var ctx = new context_1.TypeCheckContext(this.config, this.compilerHost, this.refEmitter, this.reflector);
+        TemplateTypeCheckerImpl.prototype.resetOverrides = function () {
+            var e_1, _a;
             try {
-                // Typecheck all the files.
-                for (var _c = tslib_1.__values(this.originalProgram.getSourceFiles()), _d = _c.next(); !_d.done; _d = _c.next()) {
-                    var sf = _d.value;
-                    if (sf.isDeclarationFile || shims_1.isShim(sf)) {
-                        continue;
-                    }
-                    var previousResults = this.priorBuild.priorTypeCheckingResultsFor(sf);
-                    if (previousResults === null) {
-                        // Previous results were not available, so generate new type-checking code for this file.
-                        this.typeCheckAdapter.typeCheck(sf, ctx);
-                    }
-                    else {
-                        // Previous results were available, and can be adopted into the current build.
-                        ctx.adoptPriorResults(sf, previousResults);
+                for (var _b = tslib_1.__values(this.state.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var fileRecord = _c.value;
+                    if (fileRecord.templateOverrides !== null) {
+                        fileRecord.templateOverrides = null;
+                        fileRecord.shimData.clear();
+                        fileRecord.isComplete = false;
                     }
                 }
             }
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
-                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
                 finally { if (e_1) throw e_1.error; }
             }
-            var results = ctx.finalize();
-            this.typeCheckingStrategy.updateFiles(results.updates, api_1.UpdateMode.Complete);
+        };
+        TemplateTypeCheckerImpl.prototype.overrideComponentTemplate = function (component, template) {
+            var _a = compiler_1.parseTemplate(template, 'override.html', {
+                preserveWhitespaces: true,
+                leadingTriviaChars: [],
+            }), nodes = _a.nodes, errors = _a.errors;
+            if (errors !== undefined) {
+                return { nodes: nodes, errors: errors };
+            }
+            var filePath = file_system_1.absoluteFromSourceFile(component.getSourceFile());
+            var fileRecord = this.getFileData(filePath);
+            var id = fileRecord.sourceManager.getTemplateId(component);
+            if (fileRecord.templateOverrides === null) {
+                fileRecord.templateOverrides = new Map();
+            }
+            fileRecord.templateOverrides.set(id, nodes);
+            // Clear data for the shim in question, so it'll be regenerated on the next request.
+            var shimFile = this.typeCheckingStrategy.shimPathForComponent(component);
+            fileRecord.shimData.delete(shimFile);
+            fileRecord.isComplete = false;
+            this.isComplete = false;
+            return { nodes: nodes };
+        };
+        /**
+         * Retrieve type-checking diagnostics from the given `ts.SourceFile` using the most recent
+         * type-checking program.
+         */
+        TemplateTypeCheckerImpl.prototype.getDiagnosticsForFile = function (sf, optimizeFor) {
+            var e_2, _a;
+            switch (optimizeFor) {
+                case api_1.OptimizeFor.WholeProgram:
+                    this.ensureAllShimsForAllFiles();
+                    break;
+                case api_1.OptimizeFor.SingleFile:
+                    this.ensureAllShimsForOneFile(sf);
+                    break;
+            }
+            var sfPath = file_system_1.absoluteFromSourceFile(sf);
+            var fileRecord = this.state.get(sfPath);
+            var typeCheckProgram = this.typeCheckingStrategy.getProgram();
+            var diagnostics = [];
+            if (fileRecord.hasInlines) {
+                var inlineSf = file_system_1.getSourceFileOrError(typeCheckProgram, sfPath);
+                diagnostics.push.apply(diagnostics, tslib_1.__spread(typeCheckProgram.getSemanticDiagnostics(inlineSf).map(function (diag) { return convertDiagnostic(diag, fileRecord.sourceManager); })));
+            }
             try {
-                for (var _e = tslib_1.__values(results.perFileData), _f = _e.next(); !_f.done; _f = _e.next()) {
-                    var _g = tslib_1.__read(_f.value, 2), file = _g[0], fileData = _g[1];
-                    this.files.set(file, fileData);
+                for (var _b = tslib_1.__values(fileRecord.shimData), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var _d = tslib_1.__read(_c.value, 2), shimPath = _d[0], shimRecord = _d[1];
+                    var shimSf = file_system_1.getSourceFileOrError(typeCheckProgram, shimPath);
+                    diagnostics.push.apply(diagnostics, tslib_1.__spread(typeCheckProgram.getSemanticDiagnostics(shimSf).map(function (diag) { return convertDiagnostic(diag, fileRecord.sourceManager); })));
+                    diagnostics.push.apply(diagnostics, tslib_1.__spread(shimRecord.genesisDiagnostics));
                 }
             }
             catch (e_2_1) { e_2 = { error: e_2_1 }; }
             finally {
                 try {
-                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
                 finally { if (e_2) throw e_2.error; }
             }
-            return results;
+            return diagnostics.filter(function (diag) { return diag !== null; });
         };
-        /**
-         * Retrieve type-checking diagnostics from the given `ts.SourceFile` using the most recent
-         * type-checking program.
-         */
-        TemplateTypeChecker.prototype.getDiagnosticsForFile = function (sf) {
-            var path = file_system_1.absoluteFromSourceFile(sf);
-            if (!this.files.has(path)) {
+        TemplateTypeCheckerImpl.prototype.getDiagnosticsForComponent = function (component) {
+            this.ensureShimForComponent(component);
+            var sf = component.getSourceFile();
+            var sfPath = file_system_1.absoluteFromSourceFile(sf);
+            var shimPath = this.typeCheckingStrategy.shimPathForComponent(component);
+            var fileRecord = this.getFileData(sfPath);
+            if (!fileRecord.shimData.has(shimPath)) {
                 return [];
             }
-            var record = this.files.get(path);
+            var templateId = fileRecord.sourceManager.getTemplateId(component);
+            var shimRecord = fileRecord.shimData.get(shimPath);
             var typeCheckProgram = this.typeCheckingStrategy.getProgram();
-            var typeCheckSf = file_system_1.getSourceFileOrError(typeCheckProgram, record.typeCheckFile);
-            var rawDiagnostics = [];
-            rawDiagnostics.push.apply(rawDiagnostics, tslib_1.__spread(typeCheckProgram.getSemanticDiagnostics(typeCheckSf)));
-            if (record.hasInlines) {
-                var inlineSf = file_system_1.getSourceFileOrError(typeCheckProgram, path);
-                rawDiagnostics.push.apply(rawDiagnostics, tslib_1.__spread(typeCheckProgram.getSemanticDiagnostics(inlineSf)));
-            }
-            return rawDiagnostics
-                .map(function (diag) {
-                if (!diagnostics_1.shouldReportDiagnostic(diag)) {
-                    return null;
+            var diagnostics = [];
+            if (shimRecord.hasInlines) {
+                var inlineSf = file_system_1.getSourceFileOrError(typeCheckProgram, sfPath);
+                diagnostics.push.apply(diagnostics, tslib_1.__spread(typeCheckProgram.getSemanticDiagnostics(inlineSf).map(function (diag) { return convertDiagnostic(diag, fileRecord.sourceManager); })));
+            }
+            var shimSf = file_system_1.getSourceFileOrError(typeCheckProgram, shimPath);
+            diagnostics.push.apply(diagnostics, tslib_1.__spread(typeCheckProgram.getSemanticDiagnostics(shimSf).map(function (diag) { return convertDiagnostic(diag, fileRecord.sourceManager); })));
+            diagnostics.push.apply(diagnostics, tslib_1.__spread(shimRecord.genesisDiagnostics));
+            return diagnostics.filter(function (diag) {
+                return diag !== null && diag.templateId === templateId;
+            });
+        };
+        TemplateTypeCheckerImpl.prototype.getTypeCheckBlock = function (component) {
+            this.ensureAllShimsForOneFile(component.getSourceFile());
+            var program = this.typeCheckingStrategy.getProgram();
+            var filePath = file_system_1.absoluteFromSourceFile(component.getSourceFile());
+            var shimPath = this.typeCheckingStrategy.shimPathForComponent(component);
+            if (!this.state.has(filePath)) {
+                throw new Error("Error: no data for source file: " + filePath);
+            }
+            var fileRecord = this.state.get(filePath);
+            var id = fileRecord.sourceManager.getTemplateId(component);
+            var shimSf = typescript_1.getSourceFileOrNull(program, shimPath);
+            if (shimSf === null || !fileRecord.shimData.has(shimPath)) {
+                throw new Error("Error: no shim file in program: " + shimPath);
+            }
+            var node = diagnostics_1.findTypeCheckBlock(shimSf, id);
+            if (node === null) {
+                // Try for an inline block.
+                var inlineSf = file_system_1.getSourceFileOrError(program, filePath);
+                node = diagnostics_1.findTypeCheckBlock(inlineSf, id);
+            }
+            return node;
+        };
+        TemplateTypeCheckerImpl.prototype.maybeAdoptPriorResultsForFile = function (sf) {
+            var sfPath = file_system_1.absoluteFromSourceFile(sf);
+            if (this.state.has(sfPath)) {
+                var existingResults = this.state.get(sfPath);
+                if (existingResults.templateOverrides !== null) {
+                    // Cannot adopt prior results if template overrides have been requested.
+                    return;
+                }
+                if (existingResults.isComplete) {
+                    // All data for this file has already been generated, so no need to adopt anything.
+                    return;
+                }
+            }
+            var previousResults = this.priorBuild.priorTypeCheckingResultsFor(sf);
+            if (previousResults === null || !previousResults.isComplete ||
+                previousResults.templateOverrides !== null) {
+                return;
+            }
+            this.state.set(sfPath, previousResults);
+        };
+        TemplateTypeCheckerImpl.prototype.ensureAllShimsForAllFiles = function () {
+            var e_3, _a;
+            if (this.isComplete) {
+                return;
+            }
+            var host = new WholeProgramTypeCheckingHost(this);
+            var ctx = this.newContext(host);
+            try {
+                for (var _b = tslib_1.__values(this.originalProgram.getSourceFiles()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var sf = _c.value;
+                    if (sf.isDeclarationFile || shims_1.isShim(sf)) {
+                        continue;
+                    }
+                    this.maybeAdoptPriorResultsForFile(sf);
+                    var sfPath = file_system_1.absoluteFromSourceFile(sf);
+                    var fileData = this.getFileData(sfPath);
+                    if (fileData.isComplete) {
+                        continue;
+                    }
+                    this.typeCheckAdapter.typeCheck(sf, ctx);
+                    fileData.isComplete = true;
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            this.updateFromContext(ctx);
+            this.isComplete = true;
+        };
+        TemplateTypeCheckerImpl.prototype.ensureAllShimsForOneFile = function (sf) {
+            this.maybeAdoptPriorResultsForFile(sf);
+            var sfPath = file_system_1.absoluteFromSourceFile(sf);
+            var fileData = this.getFileData(sfPath);
+            if (fileData.isComplete) {
+                // All data for this file is present and accounted for already.
+                return;
+            }
+            var host = new SingleFileTypeCheckingHost(sfPath, fileData, this.typeCheckingStrategy, this);
+            var ctx = this.newContext(host);
+            this.typeCheckAdapter.typeCheck(sf, ctx);
+            fileData.isComplete = true;
+            this.updateFromContext(ctx);
+        };
+        TemplateTypeCheckerImpl.prototype.ensureShimForComponent = function (component) {
+            var sf = component.getSourceFile();
+            var sfPath = file_system_1.absoluteFromSourceFile(sf);
+            this.maybeAdoptPriorResultsForFile(sf);
+            var fileData = this.getFileData(sfPath);
+            var shimPath = this.typeCheckingStrategy.shimPathForComponent(component);
+            if (fileData.shimData.has(shimPath)) {
+                // All data for this component is available.
+                return;
+            }
+            var host = new SingleShimTypeCheckingHost(sfPath, fileData, this.typeCheckingStrategy, this, shimPath);
+            var ctx = this.newContext(host);
+            this.typeCheckAdapter.typeCheck(sf, ctx);
+            this.updateFromContext(ctx);
+        };
+        TemplateTypeCheckerImpl.prototype.newContext = function (host) {
+            var inlining = this.typeCheckingStrategy.supportsInlineOperations ? context_1.InliningMode.InlineOps :
+                context_1.InliningMode.Error;
+            return new context_1.TypeCheckContextImpl(this.config, this.compilerHost, this.typeCheckingStrategy, this.refEmitter, this.reflector, host, inlining);
+        };
+        /**
+         * Remove any shim data that depends on inline operations applied to the type-checking program.
+         *
+         * This can be useful if new inlines need to be applied, and it's not possible to guarantee that
+         * they won't overwrite or corrupt existing inlines that are used by such shims.
+         */
+        TemplateTypeCheckerImpl.prototype.clearAllShimDataUsingInlines = function () {
+            var e_4, _a, e_5, _b;
+            try {
+                for (var _c = tslib_1.__values(this.state.values()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var fileData = _d.value;
+                    if (!fileData.hasInlines) {
+                        continue;
+                    }
+                    try {
+                        for (var _e = (e_5 = void 0, tslib_1.__values(fileData.shimData.entries())), _f = _e.next(); !_f.done; _f = _e.next()) {
+                            var _g = tslib_1.__read(_f.value, 2), shimFile = _g[0], shimData = _g[1];
+                            if (shimData.hasInlines) {
+                                fileData.shimData.delete(shimFile);
+                            }
+                        }
+                    }
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    finally {
+                        try {
+                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                    }
+                    fileData.hasInlines = false;
+                    fileData.isComplete = false;
+                    this.isComplete = false;
                 }
-                return diagnostics_1.translateDiagnostic(diag, record.sourceResolver);
-            })
-                .filter(function (diag) { return diag !== null; })
-                .concat(record.genesisDiagnostics);
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        };
+        TemplateTypeCheckerImpl.prototype.updateFromContext = function (ctx) {
+            var updates = ctx.finalize();
+            this.typeCheckingStrategy.updateFiles(updates, api_1.UpdateMode.Incremental);
+            this.priorBuild.recordSuccessfulTypeCheck(this.state);
+        };
+        TemplateTypeCheckerImpl.prototype.getFileData = function (path) {
+            if (!this.state.has(path)) {
+                this.state.set(path, {
+                    hasInlines: false,
+                    templateOverrides: null,
+                    sourceManager: new source_1.TemplateSourceManager(),
+                    isComplete: false,
+                    shimData: new Map(),
+                });
+            }
+            return this.state.get(path);
+        };
+        return TemplateTypeCheckerImpl;
+    }());
+    exports.TemplateTypeCheckerImpl = TemplateTypeCheckerImpl;
+    function convertDiagnostic(diag, sourceResolver) {
+        if (!diagnostics_1.shouldReportDiagnostic(diag)) {
+            return null;
+        }
+        return diagnostics_1.translateDiagnostic(diag, sourceResolver);
+    }
+    /**
+     * Drives a `TypeCheckContext` to generate type-checking code for every component in the program.
+     */
+    var WholeProgramTypeCheckingHost = /** @class */ (function () {
+        function WholeProgramTypeCheckingHost(impl) {
+            this.impl = impl;
+        }
+        WholeProgramTypeCheckingHost.prototype.getSourceManager = function (sfPath) {
+            return this.impl.getFileData(sfPath).sourceManager;
+        };
+        WholeProgramTypeCheckingHost.prototype.shouldCheckComponent = function (node) {
+            var fileData = this.impl.getFileData(file_system_1.absoluteFromSourceFile(node.getSourceFile()));
+            var shimPath = this.impl.typeCheckingStrategy.shimPathForComponent(node);
+            // The component needs to be checked unless the shim which would contain it already exists.
+            return !fileData.shimData.has(shimPath);
+        };
+        WholeProgramTypeCheckingHost.prototype.getTemplateOverride = function (sfPath, node) {
+            var fileData = this.impl.getFileData(sfPath);
+            if (fileData.templateOverrides === null) {
+                return null;
+            }
+            var templateId = fileData.sourceManager.getTemplateId(node);
+            if (fileData.templateOverrides.has(templateId)) {
+                return fileData.templateOverrides.get(templateId);
+            }
+            return null;
+        };
+        WholeProgramTypeCheckingHost.prototype.recordShimData = function (sfPath, data) {
+            var fileData = this.impl.getFileData(sfPath);
+            fileData.shimData.set(data.path, data);
+            if (data.hasInlines) {
+                fileData.hasInlines = true;
+            }
+        };
+        WholeProgramTypeCheckingHost.prototype.recordComplete = function (sfPath) {
+            this.impl.getFileData(sfPath).isComplete = true;
+        };
+        return WholeProgramTypeCheckingHost;
+    }());
+    /**
+     * Drives a `TypeCheckContext` to generate type-checking code efficiently for a single input file.
+     */
+    var SingleFileTypeCheckingHost = /** @class */ (function () {
+        function SingleFileTypeCheckingHost(sfPath, fileData, strategy, impl) {
+            this.sfPath = sfPath;
+            this.fileData = fileData;
+            this.strategy = strategy;
+            this.impl = impl;
+            this.seenInlines = false;
+        }
+        SingleFileTypeCheckingHost.prototype.assertPath = function (sfPath) {
+            if (this.sfPath !== sfPath) {
+                throw new Error("AssertionError: querying TypeCheckingHost outside of assigned file");
+            }
+        };
+        SingleFileTypeCheckingHost.prototype.getSourceManager = function (sfPath) {
+            this.assertPath(sfPath);
+            return this.fileData.sourceManager;
+        };
+        SingleFileTypeCheckingHost.prototype.shouldCheckComponent = function (node) {
+            if (this.sfPath !== file_system_1.absoluteFromSourceFile(node.getSourceFile())) {
+                return false;
+            }
+            var shimPath = this.strategy.shimPathForComponent(node);
+            // Only need to generate a TCB for the class if no shim exists for it currently.
+            return !this.fileData.shimData.has(shimPath);
         };
-        return TemplateTypeChecker;
+        SingleFileTypeCheckingHost.prototype.getTemplateOverride = function (sfPath, node) {
+            this.assertPath(sfPath);
+            if (this.fileData.templateOverrides === null) {
+                return null;
+            }
+            var templateId = this.fileData.sourceManager.getTemplateId(node);
+            if (this.fileData.templateOverrides.has(templateId)) {
+                return this.fileData.templateOverrides.get(templateId);
+            }
+            return null;
+        };
+        SingleFileTypeCheckingHost.prototype.recordShimData = function (sfPath, data) {
+            this.assertPath(sfPath);
+            // Previous type-checking state may have required the use of inlines (assuming they were
+            // supported). If the current operation also requires inlines, this presents a problem:
+            // generating new inlines may invalidate any old inlines that old state depends on.
+            //
+            // Rather than resolve this issue by tracking specific dependencies on inlines, if the new state
+            // relies on inlines, any old state that relied on them is simply cleared. This happens when the
+            // first new state that uses inlines is encountered.
+            if (data.hasInlines && !this.seenInlines) {
+                this.impl.clearAllShimDataUsingInlines();
+                this.seenInlines = true;
+            }
+            this.fileData.shimData.set(data.path, data);
+            if (data.hasInlines) {
+                this.fileData.hasInlines = true;
+            }
+        };
+        SingleFileTypeCheckingHost.prototype.recordComplete = function (sfPath) {
+            this.assertPath(sfPath);
+            this.fileData.isComplete = true;
+        };
+        return SingleFileTypeCheckingHost;
     }());
-    exports.TemplateTypeChecker = TemplateTypeChecker;
+    /**
+     * Drives a `TypeCheckContext` to generate type-checking code efficiently for only those components
+     * which map to a single shim of a single input file.
+     */
+    var SingleShimTypeCheckingHost = /** @class */ (function (_super) {
+        tslib_1.__extends(SingleShimTypeCheckingHost, _super);
+        function SingleShimTypeCheckingHost(sfPath, fileData, strategy, impl, shimPath) {
+            var _this = _super.call(this, sfPath, fileData, strategy, impl) || this;
+            _this.shimPath = shimPath;
+            return _this;
+        }
+        SingleShimTypeCheckingHost.prototype.shouldCheckNode = function (node) {
+            if (this.sfPath !== file_system_1.absoluteFromSourceFile(node.getSourceFile())) {
+                return false;
+            }
+            // Only generate a TCB for the component if it maps to the requested shim file.
+            var shimPath = this.strategy.shimPathForComponent(node);
+            if (shimPath !== this.shimPath) {
+                return false;
+            }
+            // Only need to generate a TCB for the class if no shim exists for it currently.
+            return !this.fileData.shimData.has(shimPath);
+        };
+        return SingleShimTypeCheckingHost;
+    }(SingleFileTypeCheckingHost));
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checker.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/src/checker.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 {absoluteFromSourceFile, AbsoluteFsPath, getSourceFileOrError} from '../../file_system';\nimport {ReferenceEmitter} from '../../imports';\nimport {IncrementalBuild} from '../../incremental/api';\nimport {ReflectionHost} from '../../reflection';\nimport {isShim} from '../../shims';\n\nimport {TypeCheckingConfig, TypeCheckingProgramStrategy, UpdateMode} from './api';\nimport {FileTypeCheckingData, TypeCheckContext, TypeCheckRequest} from './context';\nimport {shouldReportDiagnostic, translateDiagnostic} from './diagnostics';\n\n/**\n * Interface to trigger generation of type-checking code for a program given a new\n * `TypeCheckContext`.\n */\nexport interface ProgramTypeCheckAdapter {\n  typeCheck(sf: ts.SourceFile, ctx: TypeCheckContext): void;\n}\n\n/**\n * Primary template type-checking engine, which performs type-checking using a\n * `TypeCheckingProgramStrategy` for type-checking program maintenance, and the\n * `ProgramTypeCheckAdapter` for generation of template type-checking code.\n */\nexport class TemplateTypeChecker {\n  private files = new Map<AbsoluteFsPath, FileTypeCheckingData>();\n\n  constructor(\n      private originalProgram: ts.Program,\n      private typeCheckingStrategy: TypeCheckingProgramStrategy,\n      private typeCheckAdapter: ProgramTypeCheckAdapter, private config: TypeCheckingConfig,\n      private refEmitter: ReferenceEmitter, private reflector: ReflectionHost,\n      private compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>,\n      private priorBuild: IncrementalBuild<unknown, FileTypeCheckingData>) {}\n\n  /**\n   * Reset the internal type-checking program by generating type-checking code from the user's\n   * program.\n   */\n  refresh(): TypeCheckRequest {\n    this.files.clear();\n\n    const ctx =\n        new TypeCheckContext(this.config, this.compilerHost, this.refEmitter, this.reflector);\n\n    // Typecheck all the files.\n    for (const sf of this.originalProgram.getSourceFiles()) {\n      if (sf.isDeclarationFile || isShim(sf)) {\n        continue;\n      }\n\n      const previousResults = this.priorBuild.priorTypeCheckingResultsFor(sf);\n      if (previousResults === null) {\n        // Previous results were not available, so generate new type-checking code for this file.\n        this.typeCheckAdapter.typeCheck(sf, ctx);\n      } else {\n        // Previous results were available, and can be adopted into the current build.\n        ctx.adoptPriorResults(sf, previousResults);\n      }\n    }\n\n    const results = ctx.finalize();\n    this.typeCheckingStrategy.updateFiles(results.updates, UpdateMode.Complete);\n    for (const [file, fileData] of results.perFileData) {\n      this.files.set(file, fileData);\n    }\n\n    return results;\n  }\n\n  /**\n   * Retrieve type-checking diagnostics from the given `ts.SourceFile` using the most recent\n   * type-checking program.\n   */\n  getDiagnosticsForFile(sf: ts.SourceFile): ts.Diagnostic[] {\n    const path = absoluteFromSourceFile(sf);\n    if (!this.files.has(path)) {\n      return [];\n    }\n    const record = this.files.get(path)!;\n\n    const typeCheckProgram = this.typeCheckingStrategy.getProgram();\n    const typeCheckSf = getSourceFileOrError(typeCheckProgram, record.typeCheckFile);\n    const rawDiagnostics = [];\n    rawDiagnostics.push(...typeCheckProgram.getSemanticDiagnostics(typeCheckSf));\n    if (record.hasInlines) {\n      const inlineSf = getSourceFileOrError(typeCheckProgram, path);\n      rawDiagnostics.push(...typeCheckProgram.getSemanticDiagnostics(inlineSf));\n    }\n\n    return rawDiagnostics\n        .map(diag => {\n          if (!shouldReportDiagnostic(diag)) {\n            return null;\n          }\n          return translateDiagnostic(diag, record.sourceResolver);\n        })\n        .filter((diag: ts.Diagnostic|null): diag is ts.Diagnostic => diag !== null)\n        .concat(record.genesisDiagnostics);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checker.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/src/checker.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 {ParseError, parseTemplate, TmplAstNode} from '@angular/compiler';\nimport * as ts from 'typescript';\n\nimport {absoluteFromSourceFile, AbsoluteFsPath, getSourceFileOrError} from '../../file_system';\nimport {ReferenceEmitter} from '../../imports';\nimport {IncrementalBuild} from '../../incremental/api';\nimport {ReflectionHost} from '../../reflection';\nimport {isShim} from '../../shims';\nimport {getSourceFileOrNull} from '../../util/src/typescript';\nimport {OptimizeFor, ProgramTypeCheckAdapter, TemplateId, TemplateTypeChecker, TypeCheckingConfig, TypeCheckingProgramStrategy, UpdateMode} from '../api';\n\nimport {InliningMode, ShimTypeCheckingData, TypeCheckContextImpl, TypeCheckingHost} from './context';\nimport {findTypeCheckBlock, shouldReportDiagnostic, TemplateDiagnostic, TemplateSourceResolver, translateDiagnostic} from './diagnostics';\nimport {TemplateSourceManager} from './source';\n\n/**\n * Primary template type-checking engine, which performs type-checking using a\n * `TypeCheckingProgramStrategy` for type-checking program maintenance, and the\n * `ProgramTypeCheckAdapter` for generation of template type-checking code.\n */\nexport class TemplateTypeCheckerImpl implements TemplateTypeChecker {\n  private state = new Map<AbsoluteFsPath, FileTypeCheckingData>();\n  private isComplete = false;\n\n  constructor(\n      private originalProgram: ts.Program,\n      readonly typeCheckingStrategy: TypeCheckingProgramStrategy,\n      private typeCheckAdapter: ProgramTypeCheckAdapter, private config: TypeCheckingConfig,\n      private refEmitter: ReferenceEmitter, private reflector: ReflectionHost,\n      private compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>,\n      private priorBuild: IncrementalBuild<unknown, FileTypeCheckingData>) {}\n\n  resetOverrides(): void {\n    for (const fileRecord of this.state.values()) {\n      if (fileRecord.templateOverrides !== null) {\n        fileRecord.templateOverrides = null;\n        fileRecord.shimData.clear();\n        fileRecord.isComplete = false;\n      }\n    }\n  }\n\n  overrideComponentTemplate(component: ts.ClassDeclaration, template: string):\n      {nodes: TmplAstNode[], errors?: ParseError[]} {\n    const {nodes, errors} = parseTemplate(template, 'override.html', {\n      preserveWhitespaces: true,\n      leadingTriviaChars: [],\n    });\n\n    if (errors !== undefined) {\n      return {nodes, errors};\n    }\n\n    const filePath = absoluteFromSourceFile(component.getSourceFile());\n\n    const fileRecord = this.getFileData(filePath);\n    const id = fileRecord.sourceManager.getTemplateId(component);\n\n    if (fileRecord.templateOverrides === null) {\n      fileRecord.templateOverrides = new Map();\n    }\n\n    fileRecord.templateOverrides.set(id, nodes);\n\n    // Clear data for the shim in question, so it'll be regenerated on the next request.\n    const shimFile = this.typeCheckingStrategy.shimPathForComponent(component);\n    fileRecord.shimData.delete(shimFile);\n    fileRecord.isComplete = false;\n    this.isComplete = false;\n\n    return {nodes};\n  }\n\n  /**\n   * Retrieve type-checking diagnostics from the given `ts.SourceFile` using the most recent\n   * type-checking program.\n   */\n  getDiagnosticsForFile(sf: ts.SourceFile, optimizeFor: OptimizeFor): ts.Diagnostic[] {\n    switch (optimizeFor) {\n      case OptimizeFor.WholeProgram:\n        this.ensureAllShimsForAllFiles();\n        break;\n      case OptimizeFor.SingleFile:\n        this.ensureAllShimsForOneFile(sf);\n        break;\n    }\n\n    const sfPath = absoluteFromSourceFile(sf);\n    const fileRecord = this.state.get(sfPath)!;\n\n    const typeCheckProgram = this.typeCheckingStrategy.getProgram();\n\n    const diagnostics: (ts.Diagnostic|null)[] = [];\n    if (fileRecord.hasInlines) {\n      const inlineSf = getSourceFileOrError(typeCheckProgram, sfPath);\n      diagnostics.push(...typeCheckProgram.getSemanticDiagnostics(inlineSf).map(\n          diag => convertDiagnostic(diag, fileRecord.sourceManager)));\n    }\n\n    for (const [shimPath, shimRecord] of fileRecord.shimData) {\n      const shimSf = getSourceFileOrError(typeCheckProgram, shimPath);\n      diagnostics.push(...typeCheckProgram.getSemanticDiagnostics(shimSf).map(\n          diag => convertDiagnostic(diag, fileRecord.sourceManager)));\n      diagnostics.push(...shimRecord.genesisDiagnostics);\n    }\n\n    return diagnostics.filter((diag: ts.Diagnostic|null): diag is ts.Diagnostic => diag !== null);\n  }\n\n  getDiagnosticsForComponent(component: ts.ClassDeclaration): ts.Diagnostic[] {\n    this.ensureShimForComponent(component);\n\n    const sf = component.getSourceFile();\n    const sfPath = absoluteFromSourceFile(sf);\n    const shimPath = this.typeCheckingStrategy.shimPathForComponent(component);\n\n    const fileRecord = this.getFileData(sfPath);\n\n    if (!fileRecord.shimData.has(shimPath)) {\n      return [];\n    }\n\n    const templateId = fileRecord.sourceManager.getTemplateId(component);\n    const shimRecord = fileRecord.shimData.get(shimPath)!;\n\n    const typeCheckProgram = this.typeCheckingStrategy.getProgram();\n\n    const diagnostics: (TemplateDiagnostic|null)[] = [];\n    if (shimRecord.hasInlines) {\n      const inlineSf = getSourceFileOrError(typeCheckProgram, sfPath);\n      diagnostics.push(...typeCheckProgram.getSemanticDiagnostics(inlineSf).map(\n          diag => convertDiagnostic(diag, fileRecord.sourceManager)));\n    }\n\n    const shimSf = getSourceFileOrError(typeCheckProgram, shimPath);\n    diagnostics.push(...typeCheckProgram.getSemanticDiagnostics(shimSf).map(\n        diag => convertDiagnostic(diag, fileRecord.sourceManager)));\n    diagnostics.push(...shimRecord.genesisDiagnostics);\n\n    return diagnostics.filter(\n        (diag: TemplateDiagnostic|null): diag is TemplateDiagnostic =>\n            diag !== null && diag.templateId === templateId);\n  }\n\n  getTypeCheckBlock(component: ts.ClassDeclaration): ts.Node|null {\n    this.ensureAllShimsForOneFile(component.getSourceFile());\n\n    const program = this.typeCheckingStrategy.getProgram();\n    const filePath = absoluteFromSourceFile(component.getSourceFile());\n    const shimPath = this.typeCheckingStrategy.shimPathForComponent(component);\n\n    if (!this.state.has(filePath)) {\n      throw new Error(`Error: no data for source file: ${filePath}`);\n    }\n    const fileRecord = this.state.get(filePath)!;\n    const id = fileRecord.sourceManager.getTemplateId(component);\n\n    const shimSf = getSourceFileOrNull(program, shimPath);\n    if (shimSf === null || !fileRecord.shimData.has(shimPath)) {\n      throw new Error(`Error: no shim file in program: ${shimPath}`);\n    }\n\n    let node: ts.Node|null = findTypeCheckBlock(shimSf, id);\n    if (node === null) {\n      // Try for an inline block.\n      const inlineSf = getSourceFileOrError(program, filePath);\n      node = findTypeCheckBlock(inlineSf, id);\n    }\n\n    return node;\n  }\n\n  private maybeAdoptPriorResultsForFile(sf: ts.SourceFile): void {\n    const sfPath = absoluteFromSourceFile(sf);\n    if (this.state.has(sfPath)) {\n      const existingResults = this.state.get(sfPath)!;\n      if (existingResults.templateOverrides !== null) {\n        // Cannot adopt prior results if template overrides have been requested.\n        return;\n      }\n\n      if (existingResults.isComplete) {\n        // All data for this file has already been generated, so no need to adopt anything.\n        return;\n      }\n    }\n\n    const previousResults = this.priorBuild.priorTypeCheckingResultsFor(sf);\n    if (previousResults === null || !previousResults.isComplete ||\n        previousResults.templateOverrides !== null) {\n      return;\n    }\n\n    this.state.set(sfPath, previousResults);\n  }\n\n  private ensureAllShimsForAllFiles(): void {\n    if (this.isComplete) {\n      return;\n    }\n\n    const host = new WholeProgramTypeCheckingHost(this);\n    const ctx = this.newContext(host);\n\n    for (const sf of this.originalProgram.getSourceFiles()) {\n      if (sf.isDeclarationFile || isShim(sf)) {\n        continue;\n      }\n\n      this.maybeAdoptPriorResultsForFile(sf);\n\n      const sfPath = absoluteFromSourceFile(sf);\n      const fileData = this.getFileData(sfPath);\n      if (fileData.isComplete) {\n        continue;\n      }\n\n      this.typeCheckAdapter.typeCheck(sf, ctx);\n\n      fileData.isComplete = true;\n    }\n\n    this.updateFromContext(ctx);\n    this.isComplete = true;\n  }\n\n  private ensureAllShimsForOneFile(sf: ts.SourceFile): void {\n    this.maybeAdoptPriorResultsForFile(sf);\n\n    const sfPath = absoluteFromSourceFile(sf);\n\n    const fileData = this.getFileData(sfPath);\n    if (fileData.isComplete) {\n      // All data for this file is present and accounted for already.\n      return;\n    }\n\n    const host = new SingleFileTypeCheckingHost(sfPath, fileData, this.typeCheckingStrategy, this);\n    const ctx = this.newContext(host);\n\n    this.typeCheckAdapter.typeCheck(sf, ctx);\n\n    fileData.isComplete = true;\n\n    this.updateFromContext(ctx);\n  }\n\n  private ensureShimForComponent(component: ts.ClassDeclaration): void {\n    const sf = component.getSourceFile();\n    const sfPath = absoluteFromSourceFile(sf);\n\n    this.maybeAdoptPriorResultsForFile(sf);\n\n    const fileData = this.getFileData(sfPath);\n    const shimPath = this.typeCheckingStrategy.shimPathForComponent(component);\n\n    if (fileData.shimData.has(shimPath)) {\n      // All data for this component is available.\n      return;\n    }\n\n    const host =\n        new SingleShimTypeCheckingHost(sfPath, fileData, this.typeCheckingStrategy, this, shimPath);\n    const ctx = this.newContext(host);\n\n    this.typeCheckAdapter.typeCheck(sf, ctx);\n    this.updateFromContext(ctx);\n  }\n\n  private newContext(host: TypeCheckingHost): TypeCheckContextImpl {\n    const inlining = this.typeCheckingStrategy.supportsInlineOperations ? InliningMode.InlineOps :\n                                                                          InliningMode.Error;\n    return new TypeCheckContextImpl(\n        this.config, this.compilerHost, this.typeCheckingStrategy, this.refEmitter, this.reflector,\n        host, inlining);\n  }\n\n  /**\n   * Remove any shim data that depends on inline operations applied to the type-checking program.\n   *\n   * This can be useful if new inlines need to be applied, and it's not possible to guarantee that\n   * they won't overwrite or corrupt existing inlines that are used by such shims.\n   */\n  clearAllShimDataUsingInlines(): void {\n    for (const fileData of this.state.values()) {\n      if (!fileData.hasInlines) {\n        continue;\n      }\n\n      for (const [shimFile, shimData] of fileData.shimData.entries()) {\n        if (shimData.hasInlines) {\n          fileData.shimData.delete(shimFile);\n        }\n      }\n\n      fileData.hasInlines = false;\n      fileData.isComplete = false;\n      this.isComplete = false;\n    }\n  }\n\n  private updateFromContext(ctx: TypeCheckContextImpl): void {\n    const updates = ctx.finalize();\n    this.typeCheckingStrategy.updateFiles(updates, UpdateMode.Incremental);\n    this.priorBuild.recordSuccessfulTypeCheck(this.state);\n  }\n\n  getFileData(path: AbsoluteFsPath): FileTypeCheckingData {\n    if (!this.state.has(path)) {\n      this.state.set(path, {\n        hasInlines: false,\n        templateOverrides: null,\n        sourceManager: new TemplateSourceManager(),\n        isComplete: false,\n        shimData: new Map(),\n      });\n    }\n    return this.state.get(path)!;\n  }\n}\n\nfunction convertDiagnostic(\n    diag: ts.Diagnostic, sourceResolver: TemplateSourceResolver): TemplateDiagnostic|null {\n  if (!shouldReportDiagnostic(diag)) {\n    return null;\n  }\n  return translateDiagnostic(diag, sourceResolver);\n}\n\n/**\n * Data for template type-checking related to a specific input file in the user's program (which\n * contains components to be checked).\n */\nexport interface FileTypeCheckingData {\n  /**\n   * Whether the type-checking shim required any inline changes to the original file, which affects\n   * whether the shim can be reused.\n   */\n  hasInlines: boolean;\n\n  /**\n   * Source mapping information for mapping diagnostics from inlined type check blocks back to the\n   * original template.\n   */\n  sourceManager: TemplateSourceManager;\n\n  /**\n   * Map of template overrides applied to any components in this input file.\n   */\n  templateOverrides: Map<TemplateId, TmplAstNode[]>|null;\n\n  /**\n   * Data for each shim generated from this input file.\n   *\n   * A single input file will generate one or more shim files that actually contain template\n   * type-checking code.\n   */\n  shimData: Map<AbsoluteFsPath, ShimTypeCheckingData>;\n\n  /**\n   * Whether the template type-checker is certain that all components from this input file have had\n   * type-checking code generated into shims.\n   */\n  isComplete: boolean;\n}\n\n/**\n * Drives a `TypeCheckContext` to generate type-checking code for every component in the program.\n */\nclass WholeProgramTypeCheckingHost implements TypeCheckingHost {\n  constructor(private impl: TemplateTypeCheckerImpl) {}\n\n  getSourceManager(sfPath: AbsoluteFsPath): TemplateSourceManager {\n    return this.impl.getFileData(sfPath).sourceManager;\n  }\n\n  shouldCheckComponent(node: ts.ClassDeclaration): boolean {\n    const fileData = this.impl.getFileData(absoluteFromSourceFile(node.getSourceFile()));\n    const shimPath = this.impl.typeCheckingStrategy.shimPathForComponent(node);\n    // The component needs to be checked unless the shim which would contain it already exists.\n    return !fileData.shimData.has(shimPath);\n  }\n\n  getTemplateOverride(sfPath: AbsoluteFsPath, node: ts.ClassDeclaration): TmplAstNode[]|null {\n    const fileData = this.impl.getFileData(sfPath);\n    if (fileData.templateOverrides === null) {\n      return null;\n    }\n\n    const templateId = fileData.sourceManager.getTemplateId(node);\n    if (fileData.templateOverrides.has(templateId)) {\n      return fileData.templateOverrides.get(templateId)!;\n    }\n\n    return null;\n  }\n\n  recordShimData(sfPath: AbsoluteFsPath, data: ShimTypeCheckingData): void {\n    const fileData = this.impl.getFileData(sfPath);\n    fileData.shimData.set(data.path, data);\n    if (data.hasInlines) {\n      fileData.hasInlines = true;\n    }\n  }\n\n  recordComplete(sfPath: AbsoluteFsPath): void {\n    this.impl.getFileData(sfPath).isComplete = true;\n  }\n}\n\n/**\n * Drives a `TypeCheckContext` to generate type-checking code efficiently for a single input file.\n */\nclass SingleFileTypeCheckingHost implements TypeCheckingHost {\n  private seenInlines = false;\n\n  constructor(\n      protected sfPath: AbsoluteFsPath, protected fileData: FileTypeCheckingData,\n      protected strategy: TypeCheckingProgramStrategy, protected impl: TemplateTypeCheckerImpl) {}\n\n  private assertPath(sfPath: AbsoluteFsPath): void {\n    if (this.sfPath !== sfPath) {\n      throw new Error(`AssertionError: querying TypeCheckingHost outside of assigned file`);\n    }\n  }\n\n  getSourceManager(sfPath: AbsoluteFsPath): TemplateSourceManager {\n    this.assertPath(sfPath);\n    return this.fileData.sourceManager;\n  }\n\n  shouldCheckComponent(node: ts.ClassDeclaration): boolean {\n    if (this.sfPath !== absoluteFromSourceFile(node.getSourceFile())) {\n      return false;\n    }\n    const shimPath = this.strategy.shimPathForComponent(node);\n\n    // Only need to generate a TCB for the class if no shim exists for it currently.\n    return !this.fileData.shimData.has(shimPath);\n  }\n\n  getTemplateOverride(sfPath: AbsoluteFsPath, node: ts.ClassDeclaration): TmplAstNode[]|null {\n    this.assertPath(sfPath);\n    if (this.fileData.templateOverrides === null) {\n      return null;\n    }\n\n    const templateId = this.fileData.sourceManager.getTemplateId(node);\n    if (this.fileData.templateOverrides.has(templateId)) {\n      return this.fileData.templateOverrides.get(templateId)!;\n    }\n\n    return null;\n  }\n\n  recordShimData(sfPath: AbsoluteFsPath, data: ShimTypeCheckingData): void {\n    this.assertPath(sfPath);\n\n    // Previous type-checking state may have required the use of inlines (assuming they were\n    // supported). If the current operation also requires inlines, this presents a problem:\n    // generating new inlines may invalidate any old inlines that old state depends on.\n    //\n    // Rather than resolve this issue by tracking specific dependencies on inlines, if the new state\n    // relies on inlines, any old state that relied on them is simply cleared. This happens when the\n    // first new state that uses inlines is encountered.\n    if (data.hasInlines && !this.seenInlines) {\n      this.impl.clearAllShimDataUsingInlines();\n      this.seenInlines = true;\n    }\n\n    this.fileData.shimData.set(data.path, data);\n    if (data.hasInlines) {\n      this.fileData.hasInlines = true;\n    }\n  }\n\n  recordComplete(sfPath: AbsoluteFsPath): void {\n    this.assertPath(sfPath);\n    this.fileData.isComplete = true;\n  }\n}\n\n/**\n * Drives a `TypeCheckContext` to generate type-checking code efficiently for only those components\n * which map to a single shim of a single input file.\n */\nclass SingleShimTypeCheckingHost extends SingleFileTypeCheckingHost {\n  constructor(\n      sfPath: AbsoluteFsPath, fileData: FileTypeCheckingData, strategy: TypeCheckingProgramStrategy,\n      impl: TemplateTypeCheckerImpl, private shimPath: AbsoluteFsPath) {\n    super(sfPath, fileData, strategy, impl);\n  }\n\n  shouldCheckNode(node: ts.ClassDeclaration): boolean {\n    if (this.sfPath !== absoluteFromSourceFile(node.getSourceFile())) {\n      return false;\n    }\n\n    // Only generate a TCB for the component if it maps to the requested shim file.\n    const shimPath = this.strategy.shimPathForComponent(node);\n    if (shimPath !== this.shimPath) {\n      return false;\n    }\n\n    // Only need to generate a TCB for the class if no shim exists for it currently.\n    return !this.fileData.shimData.has(shimPath);\n  }\n}\n"]}