@angular/compiler-cli 11.2.4 → 11.2.5

package/src/ngtsc/incremental/semantic_graph/src/graph.js

@@ -0,0 +1,302 @@
+/**
+ * @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/incremental/semantic_graph/src/graph", ["require", "exports", "tslib", "@angular/compiler", "@angular/compiler-cli/src/ngtsc/incremental/semantic_graph/src/api"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SemanticDepGraphUpdater = exports.SemanticDepGraph = void 0;
+    var tslib_1 = require("tslib");
+    var compiler_1 = require("@angular/compiler");
+    var api_1 = require("@angular/compiler-cli/src/ngtsc/incremental/semantic_graph/src/api");
+    /**
+     * Represents a declaration for which no semantic symbol has been registered. For example,
+     * declarations from external dependencies have not been explicitly registered and are represented
+     * by this symbol. This allows the unresolved symbol to still be compared to a symbol from a prior
+     * compilation.
+     */
+    var OpaqueSymbol = /** @class */ (function (_super) {
+        tslib_1.__extends(OpaqueSymbol, _super);
+        function OpaqueSymbol() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        OpaqueSymbol.prototype.isPublicApiAffected = function () {
+            return false;
+        };
+        OpaqueSymbol.prototype.isTypeCheckApiAffected = function () {
+            return false;
+        };
+        return OpaqueSymbol;
+    }(api_1.SemanticSymbol));
+    /**
+     * The semantic dependency graph of a single compilation.
+     */
+    var SemanticDepGraph = /** @class */ (function () {
+        function SemanticDepGraph() {
+            this.files = new Map();
+            this.symbolByDecl = new Map();
+        }
+        /**
+         * Registers a symbol in the graph. The symbol is given a unique identifier if possible, such that
+         * its equivalent symbol can be obtained from a prior graph even if its declaration node has
+         * changed across rebuilds. Symbols without an identifier are only able to find themselves in a
+         * prior graph if their declaration node is identical.
+         */
+        SemanticDepGraph.prototype.registerSymbol = function (symbol) {
+            this.symbolByDecl.set(symbol.decl, symbol);
+            if (symbol.identifier !== null) {
+                // If the symbol has a unique identifier, record it in the file that declares it. This enables
+                // the symbol to be requested by its unique name.
+                if (!this.files.has(symbol.path)) {
+                    this.files.set(symbol.path, new Map());
+                }
+                this.files.get(symbol.path).set(symbol.identifier, symbol);
+            }
+        };
+        /**
+         * Attempts to resolve a symbol in this graph that represents the given symbol from another graph.
+         * If no matching symbol could be found, null is returned.
+         *
+         * @param symbol The symbol from another graph for which its equivalent in this graph should be
+         * found.
+         */
+        SemanticDepGraph.prototype.getEquivalentSymbol = function (symbol) {
+            // First lookup the symbol by its declaration. It is typical for the declaration to not have
+            // changed across rebuilds, so this is likely to find the symbol. Using the declaration also
+            // allows to diff symbols for which no unique identifier could be determined.
+            var previousSymbol = this.getSymbolByDecl(symbol.decl);
+            if (previousSymbol === null && symbol.identifier !== null) {
+                // The declaration could not be resolved to a symbol in a prior compilation, which may
+                // happen because the file containing the declaration has changed. In that case we want to
+                // lookup the symbol based on its unique identifier, as that allows us to still compare the
+                // changed declaration to the prior compilation.
+                previousSymbol = this.getSymbolByName(symbol.path, symbol.identifier);
+            }
+            return previousSymbol;
+        };
+        /**
+         * Attempts to find the symbol by its identifier.
+         */
+        SemanticDepGraph.prototype.getSymbolByName = function (path, identifier) {
+            if (!this.files.has(path)) {
+                return null;
+            }
+            var file = this.files.get(path);
+            if (!file.has(identifier)) {
+                return null;
+            }
+            return file.get(identifier);
+        };
+        /**
+         * Attempts to resolve the declaration to its semantic symbol.
+         */
+        SemanticDepGraph.prototype.getSymbolByDecl = function (decl) {
+            if (!this.symbolByDecl.has(decl)) {
+                return null;
+            }
+            return this.symbolByDecl.get(decl);
+        };
+        return SemanticDepGraph;
+    }());
+    exports.SemanticDepGraph = SemanticDepGraph;
+    /**
+     * Implements the logic to go from a previous dependency graph to a new one, along with information
+     * on which files have been affected.
+     */
+    var SemanticDepGraphUpdater = /** @class */ (function () {
+        function SemanticDepGraphUpdater(
+        /**
+         * The semantic dependency graph of the most recently succeeded compilation, or null if this
+         * is the initial build.
+         */
+        priorGraph) {
+            this.priorGraph = priorGraph;
+            this.newGraph = new SemanticDepGraph();
+            /**
+             * Contains opaque symbols that were created for declarations for which there was no symbol
+             * registered, which happens for e.g. external declarations.
+             */
+            this.opaqueSymbols = new Map();
+        }
+        /**
+         * Registers the symbol in the new graph that is being created.
+         */
+        SemanticDepGraphUpdater.prototype.registerSymbol = function (symbol) {
+            this.newGraph.registerSymbol(symbol);
+        };
+        /**
+         * Takes all facts that have been gathered to create a new semantic dependency graph. In this
+         * process, the semantic impact of the changes is determined which results in a set of files that
+         * need to be emitted and/or type-checked.
+         */
+        SemanticDepGraphUpdater.prototype.finalize = function () {
+            if (this.priorGraph === null) {
+                // If no prior dependency graph is available then this was the initial build, in which case
+                // we don't need to determine the semantic impact as everything is already considered
+                // logically changed.
+                return {
+                    needsEmit: new Set(),
+                    needsTypeCheckEmit: new Set(),
+                    newGraph: this.newGraph,
+                };
+            }
+            var needsEmit = this.determineInvalidatedFiles(this.priorGraph);
+            var needsTypeCheckEmit = this.determineInvalidatedTypeCheckFiles(this.priorGraph);
+            return {
+                needsEmit: needsEmit,
+                needsTypeCheckEmit: needsTypeCheckEmit,
+                newGraph: this.newGraph,
+            };
+        };
+        SemanticDepGraphUpdater.prototype.determineInvalidatedFiles = function (priorGraph) {
+            var e_1, _a, e_2, _b;
+            var isPublicApiAffected = new Set();
+            try {
+                // The first phase is to collect all symbols which have their public API affected. Any symbols
+                // that cannot be matched up with a symbol from the prior graph are considered affected.
+                for (var _c = tslib_1.__values(this.newGraph.symbolByDecl.values()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var symbol = _d.value;
+                    var previousSymbol = priorGraph.getEquivalentSymbol(symbol);
+                    if (previousSymbol === null || symbol.isPublicApiAffected(previousSymbol)) {
+                        isPublicApiAffected.add(symbol);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            // The second phase is to find all symbols for which the emit result is affected, either because
+            // their used declarations have changed or any of those used declarations has had its public API
+            // affected as determined in the first phase.
+            var needsEmit = new Set();
+            try {
+                for (var _e = tslib_1.__values(this.newGraph.symbolByDecl.values()), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var symbol = _f.value;
+                    if (symbol.isEmitAffected === undefined) {
+                        continue;
+                    }
+                    var previousSymbol = priorGraph.getEquivalentSymbol(symbol);
+                    if (previousSymbol === null || symbol.isEmitAffected(previousSymbol, isPublicApiAffected)) {
+                        needsEmit.add(symbol.path);
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return needsEmit;
+        };
+        SemanticDepGraphUpdater.prototype.determineInvalidatedTypeCheckFiles = function (priorGraph) {
+            var e_3, _a, e_4, _b;
+            var isTypeCheckApiAffected = new Set();
+            try {
+                // The first phase is to collect all symbols which have their public API affected. Any symbols
+                // that cannot be matched up with a symbol from the prior graph are considered affected.
+                for (var _c = tslib_1.__values(this.newGraph.symbolByDecl.values()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var symbol = _d.value;
+                    var previousSymbol = priorGraph.getEquivalentSymbol(symbol);
+                    if (previousSymbol === null || symbol.isTypeCheckApiAffected(previousSymbol)) {
+                        isTypeCheckApiAffected.add(symbol);
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            // The second phase is to find all symbols for which the emit result is affected, either because
+            // their used declarations have changed or any of those used declarations has had its public API
+            // affected as determined in the first phase.
+            var needsTypeCheckEmit = new Set();
+            try {
+                for (var _e = tslib_1.__values(this.newGraph.symbolByDecl.values()), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var symbol = _f.value;
+                    if (symbol.isTypeCheckBlockAffected === undefined) {
+                        continue;
+                    }
+                    var previousSymbol = priorGraph.getEquivalentSymbol(symbol);
+                    if (previousSymbol === null ||
+                        symbol.isTypeCheckBlockAffected(previousSymbol, isTypeCheckApiAffected)) {
+                        needsTypeCheckEmit.add(symbol.path);
+                    }
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+            return needsTypeCheckEmit;
+        };
+        /**
+         * Creates a `SemanticReference` for the reference to `decl` using the expression `expr`. See
+         * the documentation of `SemanticReference` for details.
+         */
+        SemanticDepGraphUpdater.prototype.getSemanticReference = function (decl, expr) {
+            return {
+                symbol: this.getSymbol(decl),
+                importPath: getImportPath(expr),
+            };
+        };
+        /**
+         * Gets the `SemanticSymbol` that was registered for `decl` during the current compilation, or
+         * returns an opaque symbol that represents `decl`.
+         */
+        SemanticDepGraphUpdater.prototype.getSymbol = function (decl) {
+            var symbol = this.newGraph.getSymbolByDecl(decl);
+            if (symbol === null) {
+                // No symbol has been recorded for the provided declaration, which would be the case if the
+                // declaration is external. Return an opaque symbol in that case, to allow the external
+                // declaration to be compared to a prior compilation.
+                return this.getOpaqueSymbol(decl);
+            }
+            return symbol;
+        };
+        /**
+         * Gets or creates an `OpaqueSymbol` for the provided class declaration.
+         */
+        SemanticDepGraphUpdater.prototype.getOpaqueSymbol = function (decl) {
+            if (this.opaqueSymbols.has(decl)) {
+                return this.opaqueSymbols.get(decl);
+            }
+            var symbol = new OpaqueSymbol(decl);
+            this.opaqueSymbols.set(decl, symbol);
+            return symbol;
+        };
+        return SemanticDepGraphUpdater;
+    }());
+    exports.SemanticDepGraphUpdater = SemanticDepGraphUpdater;
+    function getImportPath(expr) {
+        if (expr instanceof compiler_1.ExternalExpr) {
+            return expr.value.moduleName + "$" + expr.value.name;
+        }
+        else {
+            return null;
+        }
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"graph.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/graph.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;;;IAEH,8CAA2D;IAG3D,0FAAwD;IAmBxD;;;;;OAKG;IACH;QAA2B,wCAAc;QAAzC;;QAQA,CAAC;QAPC,0CAAmB,GAAnB;YACE,OAAO,KAAK,CAAC;QACf,CAAC;QAED,6CAAsB,GAAtB;YACE,OAAO,KAAK,CAAC;QACf,CAAC;QACH,mBAAC;IAAD,CAAC,AARD,CAA2B,oBAAc,GAQxC;IAED;;OAEG;IACH;QAAA;YACW,UAAK,GAAG,IAAI,GAAG,EAA+C,CAAC;YAC/D,iBAAY,GAAG,IAAI,GAAG,EAAoC,CAAC;QAmEtE,CAAC;QAjEC;;;;;WAKG;QACH,yCAAc,GAAd,UAAe,MAAsB;YACnC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YAE3C,IAAI,MAAM,CAAC,UAAU,KAAK,IAAI,EAAE;gBAC9B,8FAA8F;gBAC9F,iDAAiD;gBACjD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;oBAChC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,EAA0B,CAAC,CAAC;iBAChE;gBACD,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAE,CAAC,GAAG,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;aAC7D;QACH,CAAC;QAED;;;;;;WAMG;QACH,8CAAmB,GAAnB,UAAoB,MAAsB;YACxC,4FAA4F;YAC5F,4FAA4F;YAC5F,6EAA6E;YAC7E,IAAI,cAAc,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YACvD,IAAI,cAAc,KAAK,IAAI,IAAI,MAAM,CAAC,UAAU,KAAK,IAAI,EAAE;gBACzD,sFAAsF;gBACtF,0FAA0F;gBAC1F,2FAA2F;gBAC3F,gDAAgD;gBAChD,cAAc,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC;aACvE;YAED,OAAO,cAAc,CAAC;QACxB,CAAC;QAED;;WAEG;QACK,0CAAe,GAAvB,UAAwB,IAAoB,EAAE,UAAkB;YAC9D,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;gBACzB,OAAO,IAAI,CAAC;aACb;YACD,IAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC;YACnC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE;gBACzB,OAAO,IAAI,CAAC;aACb;YACD,OAAO,IAAI,CAAC,GAAG,CAAC,UAAU,CAAE,CAAC;QAC/B,CAAC;QAED;;WAEG;QACH,0CAAe,GAAf,UAAgB,IAAsB;YACpC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;gBAChC,OAAO,IAAI,CAAC;aACb;YACD,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC;QACtC,CAAC;QACH,uBAAC;IAAD,CAAC,AArED,IAqEC;IArEY,4CAAgB;IAuE7B;;;OAGG;IACH;QASE;QACI;;;WAGG;QACK,UAAiC;YAAjC,eAAU,GAAV,UAAU,CAAuB;YAb5B,aAAQ,GAAG,IAAI,gBAAgB,EAAE,CAAC;YAEnD;;;eAGG;YACc,kBAAa,GAAG,IAAI,GAAG,EAAkC,CAAC;QAO3B,CAAC;QAEjD;;WAEG;QACH,gDAAc,GAAd,UAAe,MAAsB;YACnC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;QACvC,CAAC;QAED;;;;WAIG;QACH,0CAAQ,GAAR;YACE,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,EAAE;gBAC5B,2FAA2F;gBAC3F,qFAAqF;gBACrF,qBAAqB;gBACrB,OAAO;oBACL,SAAS,EAAE,IAAI,GAAG,EAAkB;oBACpC,kBAAkB,EAAE,IAAI,GAAG,EAAkB;oBAC7C,QAAQ,EAAE,IAAI,CAAC,QAAQ;iBACxB,CAAC;aACH;YAED,IAAM,SAAS,GAAG,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAClE,IAAM,kBAAkB,GAAG,IAAI,CAAC,kCAAkC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACpF,OAAO;gBACL,SAAS,WAAA;gBACT,kBAAkB,oBAAA;gBAClB,QAAQ,EAAE,IAAI,CAAC,QAAQ;aACxB,CAAC;QACJ,CAAC;QAEO,2DAAyB,GAAjC,UAAkC,UAA4B;;YAC5D,IAAM,mBAAmB,GAAG,IAAI,GAAG,EAAkB,CAAC;;gBAEtD,8FAA8F;gBAC9F,wFAAwF;gBACxF,KAAqB,IAAA,KAAA,iBAAA,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,MAAM,EAAE,CAAA,gBAAA,4BAAE;oBAArD,IAAM,MAAM,WAAA;oBACf,IAAM,cAAc,GAAG,UAAU,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;oBAC9D,IAAI,cAAc,KAAK,IAAI,IAAI,MAAM,CAAC,mBAAmB,CAAC,cAAc,CAAC,EAAE;wBACzE,mBAAmB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;qBACjC;iBACF;;;;;;;;;YAED,gGAAgG;YAChG,gGAAgG;YAChG,6CAA6C;YAC7C,IAAM,SAAS,GAAG,IAAI,GAAG,EAAkB,CAAC;;gBAC5C,KAAqB,IAAA,KAAA,iBAAA,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,MAAM,EAAE,CAAA,gBAAA,4BAAE;oBAArD,IAAM,MAAM,WAAA;oBACf,IAAI,MAAM,CAAC,cAAc,KAAK,SAAS,EAAE;wBACvC,SAAS;qBACV;oBAED,IAAM,cAAc,GAAG,UAAU,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;oBAC9D,IAAI,cAAc,KAAK,IAAI,IAAI,MAAM,CAAC,cAAc,CAAC,cAAc,EAAE,mBAAmB,CAAC,EAAE;wBACzF,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;qBAC5B;iBACF;;;;;;;;;YAED,OAAO,SAAS,CAAC;QACnB,CAAC;QAEO,oEAAkC,GAA1C,UAA2C,UAA4B;;YACrE,IAAM,sBAAsB,GAAG,IAAI,GAAG,EAAkB,CAAC;;gBAEzD,8FAA8F;gBAC9F,wFAAwF;gBACxF,KAAqB,IAAA,KAAA,iBAAA,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,MAAM,EAAE,CAAA,gBAAA,4BAAE;oBAArD,IAAM,MAAM,WAAA;oBACf,IAAM,cAAc,GAAG,UAAU,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;oBAC9D,IAAI,cAAc,KAAK,IAAI,IAAI,MAAM,CAAC,sBAAsB,CAAC,cAAc,CAAC,EAAE;wBAC5E,sBAAsB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;qBACpC;iBACF;;;;;;;;;YAED,gGAAgG;YAChG,gGAAgG;YAChG,6CAA6C;YAC7C,IAAM,kBAAkB,GAAG,IAAI,GAAG,EAAkB,CAAC;;gBACrD,KAAqB,IAAA,KAAA,iBAAA,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,MAAM,EAAE,CAAA,gBAAA,4BAAE;oBAArD,IAAM,MAAM,WAAA;oBACf,IAAI,MAAM,CAAC,wBAAwB,KAAK,SAAS,EAAE;wBACjD,SAAS;qBACV;oBAED,IAAM,cAAc,GAAG,UAAU,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;oBAC9D,IAAI,cAAc,KAAK,IAAI;wBACvB,MAAM,CAAC,wBAAwB,CAAC,cAAc,EAAE,sBAAsB,CAAC,EAAE;wBAC3E,kBAAkB,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;qBACrC;iBACF;;;;;;;;;YAED,OAAO,kBAAkB,CAAC;QAC5B,CAAC;QAED;;;WAGG;QACH,sDAAoB,GAApB,UAAqB,IAAsB,EAAE,IAAgB;YAC3D,OAAO;gBACL,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;gBAC5B,UAAU,EAAE,aAAa,CAAC,IAAI,CAAC;aAChC,CAAC;QACJ,CAAC;QAED;;;WAGG;QACH,2CAAS,GAAT,UAAU,IAAsB;YAC9B,IAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;YACnD,IAAI,MAAM,KAAK,IAAI,EAAE;gBACnB,2FAA2F;gBAC3F,uFAAuF;gBACvF,qDAAqD;gBACrD,OAAO,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;aACnC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;QAED;;WAEG;QACK,iDAAe,GAAvB,UAAwB,IAAsB;YAC5C,IAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;gBAChC,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC;aACtC;YAED,IAAM,MAAM,GAAG,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;YACtC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YACrC,OAAO,MAAM,CAAC;QAChB,CAAC;QACH,8BAAC;IAAD,CAAC,AApJD,IAoJC;IApJY,0DAAuB;IAsJpC,SAAS,aAAa,CAAC,IAAgB;QACrC,IAAI,IAAI,YAAY,uBAAY,EAAE;YAChC,OAAU,IAAI,CAAC,KAAK,CAAC,UAAU,SAAK,IAAI,CAAC,KAAK,CAAC,IAAM,CAAC;SACvD;aAAM;YACL,OAAO,IAAI,CAAC;SACb;IACH,CAAC","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 {Expression, ExternalExpr} from '@angular/compiler';\nimport {AbsoluteFsPath} from '../../../file_system';\nimport {ClassDeclaration} from '../../../reflection';\nimport {SemanticReference, SemanticSymbol} from './api';\n\nexport interface SemanticDependencyResult {\n  /**\n   * The files that need to be re-emitted.\n   */\n  needsEmit: Set<AbsoluteFsPath>;\n\n  /**\n   * The files for which the type-check block should be regenerated.\n   */\n  needsTypeCheckEmit: Set<AbsoluteFsPath>;\n\n  /**\n   * The newly built graph that represents the current compilation.\n   */\n  newGraph: SemanticDepGraph;\n}\n\n/**\n * Represents a declaration for which no semantic symbol has been registered. For example,\n * declarations from external dependencies have not been explicitly registered and are represented\n * by this symbol. This allows the unresolved symbol to still be compared to a symbol from a prior\n * compilation.\n */\nclass OpaqueSymbol extends SemanticSymbol {\n  isPublicApiAffected(): false {\n    return false;\n  }\n\n  isTypeCheckApiAffected(): false {\n    return false;\n  }\n}\n\n/**\n * The semantic dependency graph of a single compilation.\n */\nexport class SemanticDepGraph {\n  readonly files = new Map<AbsoluteFsPath, Map<string, SemanticSymbol>>();\n  readonly symbolByDecl = new Map<ClassDeclaration, SemanticSymbol>();\n\n  /**\n   * Registers a symbol in the graph. The symbol is given a unique identifier if possible, such that\n   * its equivalent symbol can be obtained from a prior graph even if its declaration node has\n   * changed across rebuilds. Symbols without an identifier are only able to find themselves in a\n   * prior graph if their declaration node is identical.\n   */\n  registerSymbol(symbol: SemanticSymbol): void {\n    this.symbolByDecl.set(symbol.decl, symbol);\n\n    if (symbol.identifier !== null) {\n      // If the symbol has a unique identifier, record it in the file that declares it. This enables\n      // the symbol to be requested by its unique name.\n      if (!this.files.has(symbol.path)) {\n        this.files.set(symbol.path, new Map<string, SemanticSymbol>());\n      }\n      this.files.get(symbol.path)!.set(symbol.identifier, symbol);\n    }\n  }\n\n  /**\n   * Attempts to resolve a symbol in this graph that represents the given symbol from another graph.\n   * If no matching symbol could be found, null is returned.\n   *\n   * @param symbol The symbol from another graph for which its equivalent in this graph should be\n   * found.\n   */\n  getEquivalentSymbol(symbol: SemanticSymbol): SemanticSymbol|null {\n    // First lookup the symbol by its declaration. It is typical for the declaration to not have\n    // changed across rebuilds, so this is likely to find the symbol. Using the declaration also\n    // allows to diff symbols for which no unique identifier could be determined.\n    let previousSymbol = this.getSymbolByDecl(symbol.decl);\n    if (previousSymbol === null && symbol.identifier !== null) {\n      // The declaration could not be resolved to a symbol in a prior compilation, which may\n      // happen because the file containing the declaration has changed. In that case we want to\n      // lookup the symbol based on its unique identifier, as that allows us to still compare the\n      // changed declaration to the prior compilation.\n      previousSymbol = this.getSymbolByName(symbol.path, symbol.identifier);\n    }\n\n    return previousSymbol;\n  }\n\n  /**\n   * Attempts to find the symbol by its identifier.\n   */\n  private getSymbolByName(path: AbsoluteFsPath, identifier: string): SemanticSymbol|null {\n    if (!this.files.has(path)) {\n      return null;\n    }\n    const file = this.files.get(path)!;\n    if (!file.has(identifier)) {\n      return null;\n    }\n    return file.get(identifier)!;\n  }\n\n  /**\n   * Attempts to resolve the declaration to its semantic symbol.\n   */\n  getSymbolByDecl(decl: ClassDeclaration): SemanticSymbol|null {\n    if (!this.symbolByDecl.has(decl)) {\n      return null;\n    }\n    return this.symbolByDecl.get(decl)!;\n  }\n}\n\n/**\n * Implements the logic to go from a previous dependency graph to a new one, along with information\n * on which files have been affected.\n */\nexport class SemanticDepGraphUpdater {\n  private readonly newGraph = new SemanticDepGraph();\n\n  /**\n   * Contains opaque symbols that were created for declarations for which there was no symbol\n   * registered, which happens for e.g. external declarations.\n   */\n  private readonly opaqueSymbols = new Map<ClassDeclaration, OpaqueSymbol>();\n\n  constructor(\n      /**\n       * The semantic dependency graph of the most recently succeeded compilation, or null if this\n       * is the initial build.\n       */\n      private priorGraph: SemanticDepGraph|null) {}\n\n  /**\n   * Registers the symbol in the new graph that is being created.\n   */\n  registerSymbol(symbol: SemanticSymbol): void {\n    this.newGraph.registerSymbol(symbol);\n  }\n\n  /**\n   * Takes all facts that have been gathered to create a new semantic dependency graph. In this\n   * process, the semantic impact of the changes is determined which results in a set of files that\n   * need to be emitted and/or type-checked.\n   */\n  finalize(): SemanticDependencyResult {\n    if (this.priorGraph === null) {\n      // If no prior dependency graph is available then this was the initial build, in which case\n      // we don't need to determine the semantic impact as everything is already considered\n      // logically changed.\n      return {\n        needsEmit: new Set<AbsoluteFsPath>(),\n        needsTypeCheckEmit: new Set<AbsoluteFsPath>(),\n        newGraph: this.newGraph,\n      };\n    }\n\n    const needsEmit = this.determineInvalidatedFiles(this.priorGraph);\n    const needsTypeCheckEmit = this.determineInvalidatedTypeCheckFiles(this.priorGraph);\n    return {\n      needsEmit,\n      needsTypeCheckEmit,\n      newGraph: this.newGraph,\n    };\n  }\n\n  private determineInvalidatedFiles(priorGraph: SemanticDepGraph): Set<AbsoluteFsPath> {\n    const isPublicApiAffected = new Set<SemanticSymbol>();\n\n    // The first phase is to collect all symbols which have their public API affected. Any symbols\n    // that cannot be matched up with a symbol from the prior graph are considered affected.\n    for (const symbol of this.newGraph.symbolByDecl.values()) {\n      const previousSymbol = priorGraph.getEquivalentSymbol(symbol);\n      if (previousSymbol === null || symbol.isPublicApiAffected(previousSymbol)) {\n        isPublicApiAffected.add(symbol);\n      }\n    }\n\n    // The second phase is to find all symbols for which the emit result is affected, either because\n    // their used declarations have changed or any of those used declarations has had its public API\n    // affected as determined in the first phase.\n    const needsEmit = new Set<AbsoluteFsPath>();\n    for (const symbol of this.newGraph.symbolByDecl.values()) {\n      if (symbol.isEmitAffected === undefined) {\n        continue;\n      }\n\n      const previousSymbol = priorGraph.getEquivalentSymbol(symbol);\n      if (previousSymbol === null || symbol.isEmitAffected(previousSymbol, isPublicApiAffected)) {\n        needsEmit.add(symbol.path);\n      }\n    }\n\n    return needsEmit;\n  }\n\n  private determineInvalidatedTypeCheckFiles(priorGraph: SemanticDepGraph): Set<AbsoluteFsPath> {\n    const isTypeCheckApiAffected = new Set<SemanticSymbol>();\n\n    // The first phase is to collect all symbols which have their public API affected. Any symbols\n    // that cannot be matched up with a symbol from the prior graph are considered affected.\n    for (const symbol of this.newGraph.symbolByDecl.values()) {\n      const previousSymbol = priorGraph.getEquivalentSymbol(symbol);\n      if (previousSymbol === null || symbol.isTypeCheckApiAffected(previousSymbol)) {\n        isTypeCheckApiAffected.add(symbol);\n      }\n    }\n\n    // The second phase is to find all symbols for which the emit result is affected, either because\n    // their used declarations have changed or any of those used declarations has had its public API\n    // affected as determined in the first phase.\n    const needsTypeCheckEmit = new Set<AbsoluteFsPath>();\n    for (const symbol of this.newGraph.symbolByDecl.values()) {\n      if (symbol.isTypeCheckBlockAffected === undefined) {\n        continue;\n      }\n\n      const previousSymbol = priorGraph.getEquivalentSymbol(symbol);\n      if (previousSymbol === null ||\n          symbol.isTypeCheckBlockAffected(previousSymbol, isTypeCheckApiAffected)) {\n        needsTypeCheckEmit.add(symbol.path);\n      }\n    }\n\n    return needsTypeCheckEmit;\n  }\n\n  /**\n   * Creates a `SemanticReference` for the reference to `decl` using the expression `expr`. See\n   * the documentation of `SemanticReference` for details.\n   */\n  getSemanticReference(decl: ClassDeclaration, expr: Expression): SemanticReference {\n    return {\n      symbol: this.getSymbol(decl),\n      importPath: getImportPath(expr),\n    };\n  }\n\n  /**\n   * Gets the `SemanticSymbol` that was registered for `decl` during the current compilation, or\n   * returns an opaque symbol that represents `decl`.\n   */\n  getSymbol(decl: ClassDeclaration): SemanticSymbol {\n    const symbol = this.newGraph.getSymbolByDecl(decl);\n    if (symbol === null) {\n      // No symbol has been recorded for the provided declaration, which would be the case if the\n      // declaration is external. Return an opaque symbol in that case, to allow the external\n      // declaration to be compared to a prior compilation.\n      return this.getOpaqueSymbol(decl);\n    }\n    return symbol;\n  }\n\n  /**\n   * Gets or creates an `OpaqueSymbol` for the provided class declaration.\n   */\n  private getOpaqueSymbol(decl: ClassDeclaration): OpaqueSymbol {\n    if (this.opaqueSymbols.has(decl)) {\n      return this.opaqueSymbols.get(decl)!;\n    }\n\n    const symbol = new OpaqueSymbol(decl);\n    this.opaqueSymbols.set(decl, symbol);\n    return symbol;\n  }\n}\n\nfunction getImportPath(expr: Expression): string|null {\n  if (expr instanceof ExternalExpr) {\n    return `${expr.value.moduleName}\\$${expr.value.name}`;\n  } else {\n    return null;\n  }\n}\n"]}

package/src/ngtsc/incremental/semantic_graph/src/type_parameters.d.ts

@@ -0,0 +1,30 @@
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/incremental/semantic_graph/src/type_parameters" />
+import { ClassDeclaration } from '../../../reflection';
+/**
+ * Describes a generic type parameter of a semantic symbol. A class declaration with type parameters
+ * needs special consideration in certain contexts. For example, template type-check blocks may
+ * contain type constructors of used directives which include the type parameters of the directive.
+ * As a consequence, if a change is made that affects the type parameters of said directive, any
+ * template type-check blocks that use the directive need to be regenerated.
+ *
+ * This type represents a single generic type parameter. It currently only tracks whether the
+ * type parameter has a constraint, i.e. has an `extends` clause. When a constraint is present, we
+ * currently assume that the type parameter is affected in each incremental rebuild; proving that
+ * a type parameter with constraint is not affected is non-trivial as it requires full semantic
+ * understanding of the type constraint.
+ */
+export interface SemanticTypeParameter {
+    /**
+     * Whether a type constraint, i.e. an `extends` clause is present on the type parameter.
+     */
+    hasGenericTypeBound: boolean;
+}
+/**
+ * Converts the type parameters of the given class into their semantic representation. If the class
+ * does not have any type parameters, then `null` is returned.
+ */
+export declare function extractSemanticTypeParameters(node: ClassDeclaration): SemanticTypeParameter[] | null;
+/**
+ * Compares the list of type parameters to determine if they can be considered equal.
+ */
+export declare function areTypeParametersEqual(current: SemanticTypeParameter[] | null, previous: SemanticTypeParameter[] | null): boolean;

package/src/ngtsc/incremental/semantic_graph/src/type_parameters.js

@@ -0,0 +1,55 @@
+(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/incremental/semantic_graph/src/type_parameters", ["require", "exports", "typescript", "@angular/compiler-cli/src/ngtsc/incremental/semantic_graph/src/util"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.areTypeParametersEqual = exports.extractSemanticTypeParameters = void 0;
+    /**
+     * @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
+     */
+    var ts = require("typescript");
+    var util_1 = require("@angular/compiler-cli/src/ngtsc/incremental/semantic_graph/src/util");
+    /**
+     * Converts the type parameters of the given class into their semantic representation. If the class
+     * does not have any type parameters, then `null` is returned.
+     */
+    function extractSemanticTypeParameters(node) {
+        if (!ts.isClassDeclaration(node) || node.typeParameters === undefined) {
+            return null;
+        }
+        return node.typeParameters.map(function (typeParam) { return ({ hasGenericTypeBound: typeParam.constraint !== undefined }); });
+    }
+    exports.extractSemanticTypeParameters = extractSemanticTypeParameters;
+    /**
+     * Compares the list of type parameters to determine if they can be considered equal.
+     */
+    function areTypeParametersEqual(current, previous) {
+        // First compare all type parameters one-to-one; any differences mean that the list of type
+        // parameters has changed.
+        if (!util_1.isArrayEqual(current, previous, isTypeParameterEqual)) {
+            return false;
+        }
+        // If there is a current list of type parameters and if any of them has a generic type constraint,
+        // then the meaning of that type parameter may have changed without us being aware; as such we
+        // have to assume that the type parameters have in fact changed.
+        if (current !== null && current.some(function (typeParam) { return typeParam.hasGenericTypeBound; })) {
+            return false;
+        }
+        return true;
+    }
+    exports.areTypeParametersEqual = areTypeParametersEqual;
+    function isTypeParameterEqual(a, b) {
+        return a.hasGenericTypeBound === b.hasGenericTypeBound;
+    }
+});
+//# sourceMappingURL=data:application/json;base64,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

package/src/ngtsc/incremental/semantic_graph/src/util.d.ts

@@ -0,0 +1,29 @@
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/incremental/semantic_graph/src/util" />
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { SemanticReference, SemanticSymbol } from './api';
+/**
+ * Determines whether the provided symbols represent the same declaration.
+ */
+export declare function isSymbolEqual(a: SemanticSymbol, b: SemanticSymbol): boolean;
+/**
+ * Determines whether the provided references to a semantic symbol are still equal, i.e. represent
+ * the same symbol and are imported by the same path.
+ */
+export declare function isReferenceEqual(a: SemanticReference, b: SemanticReference): boolean;
+export declare function referenceEquality<T>(a: T, b: T): boolean;
+/**
+ * Determines if the provided arrays are equal to each other, using the provided equality tester
+ * that is called for all entries in the array.
+ */
+export declare function isArrayEqual<T>(a: readonly T[] | null, b: readonly T[] | null, equalityTester?: (a: T, b: T) => boolean): boolean;
+/**
+ * Determines if the provided sets are equal to each other, using the provided equality tester.
+ * Sets that only differ in ordering are considered equal.
+ */
+export declare function isSetEqual<T>(a: ReadonlySet<T> | null, b: ReadonlySet<T> | null, equalityTester?: (a: T, b: T) => boolean): boolean;

package/src/ngtsc/incremental/semantic_graph/src/util.js

@@ -0,0 +1,111 @@
+(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/incremental/semantic_graph/src/util", ["require", "exports", "tslib"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isSetEqual = exports.isArrayEqual = exports.referenceEquality = exports.isReferenceEqual = exports.isSymbolEqual = void 0;
+    var tslib_1 = require("tslib");
+    /**
+     * Determines whether the provided symbols represent the same declaration.
+     */
+    function isSymbolEqual(a, b) {
+        if (a.decl === b.decl) {
+            // If the declaration is identical then it must represent the same symbol.
+            return true;
+        }
+        if (a.identifier === null || b.identifier === null) {
+            // Unidentifiable symbols are assumed to be different.
+            return false;
+        }
+        return a.path === b.path && a.identifier === b.identifier;
+    }
+    exports.isSymbolEqual = isSymbolEqual;
+    /**
+     * Determines whether the provided references to a semantic symbol are still equal, i.e. represent
+     * the same symbol and are imported by the same path.
+     */
+    function isReferenceEqual(a, b) {
+        if (!isSymbolEqual(a.symbol, b.symbol)) {
+            // If the reference's target symbols are different, the reference itself is different.
+            return false;
+        }
+        // The reference still corresponds with the same symbol, now check that the path by which it is
+        // imported has not changed.
+        return a.importPath === b.importPath;
+    }
+    exports.isReferenceEqual = isReferenceEqual;
+    function referenceEquality(a, b) {
+        return a === b;
+    }
+    exports.referenceEquality = referenceEquality;
+    /**
+     * Determines if the provided arrays are equal to each other, using the provided equality tester
+     * that is called for all entries in the array.
+     */
+    function isArrayEqual(a, b, equalityTester) {
+        if (equalityTester === void 0) { equalityTester = referenceEquality; }
+        if (a === null || b === null) {
+            return a === b;
+        }
+        if (a.length !== b.length) {
+            return false;
+        }
+        return !a.some(function (item, index) { return !equalityTester(item, b[index]); });
+    }
+    exports.isArrayEqual = isArrayEqual;
+    /**
+     * Determines if the provided sets are equal to each other, using the provided equality tester.
+     * Sets that only differ in ordering are considered equal.
+     */
+    function isSetEqual(a, b, equalityTester) {
+        var e_1, _a, e_2, _b;
+        if (equalityTester === void 0) { equalityTester = referenceEquality; }
+        if (a === null || b === null) {
+            return a === b;
+        }
+        if (a.size !== b.size) {
+            return false;
+        }
+        try {
+            for (var a_1 = tslib_1.__values(a), a_1_1 = a_1.next(); !a_1_1.done; a_1_1 = a_1.next()) {
+                var itemA = a_1_1.value;
+                var found = false;
+                try {
+                    for (var b_1 = (e_2 = void 0, tslib_1.__values(b)), b_1_1 = b_1.next(); !b_1_1.done; b_1_1 = b_1.next()) {
+                        var itemB = b_1_1.value;
+                        if (equalityTester(itemA, itemB)) {
+                            found = true;
+                            break;
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (b_1_1 && !b_1_1.done && (_b = b_1.return)) _b.call(b_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                if (!found) {
+                    return false;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (a_1_1 && !a_1_1.done && (_a = a_1.return)) _a.call(a_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return true;
+    }
+    exports.isSetEqual = isSetEqual;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/src/ngtsc/incremental/src/dependency_tracking.d.ts

@@ -27,11 +27,8 @@ export declare class FileDependencyGraph<T extends {
     private nodes;
     addDependency(from: T, on: T): void;
     addResourceDependency(from: T, resource: AbsoluteFsPath): void;
-    addTransitiveDependency(from: T, on: T): void;
-    addTransitiveResources(from: T, resourcesOf: T): void;
     recordDependencyAnalysisFailure(file: T): void;
     getResourceDependencies(from: T): AbsoluteFsPath[];
-    isStale(sf: T, changedTsPaths: Set<string>, changedResources: Set<AbsoluteFsPath>): boolean;
     /**
      * Update the current dependency graph from a previous one, incorporating a set of physical
      * changes.