@angular/compiler-cli 9.0.0-rc.6 → 9.0.0

package/src/ngtsc/imports/src/references.d.ts

@@ -8,10 +8,6 @@
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/imports/src/references" />
 import { Expression } from '@angular/compiler';
 import * as ts from 'typescript';
-export declare enum ImportMode {
-    UseExistingImport = 0,
-    ForceNewImport = 1
-}
 export interface OwningModule {
     specifier: string;
     resolutionContext: string;
@@ -56,21 +52,21 @@ export declare class Reference<T extends ts.Node = ts.Node> {
      * The best guess at which module specifier owns this particular reference, or `null` if there
      * isn't one.
      */
-    readonly ownedByModuleGuess: string | null;
+    get ownedByModuleGuess(): string | null;
     /**
      * Whether this reference has a potential owning module or not.
      *
      * See `bestGuessOwningModule`.
      */
-    readonly hasOwningModuleGuess: boolean;
+    get hasOwningModuleGuess(): boolean;
     /**
      * A name for the node, if one is available.
      *
      * This is only suited for debugging. Any actual references to this node should be made with
      * `ts.Identifier`s (see `getIdentityIn`).
      */
-    readonly debugName: string | null;
-    readonly alias: Expression | null;
+    get debugName(): string | null;
+    get alias(): Expression | null;
     /**
      * Record a `ts.Identifier` by which it's valid to refer to this node, within the context of this
      * `Reference`.
@@ -81,6 +77,32 @@ export declare class Reference<T extends ts.Node = ts.Node> {
      * given `ts.SourceFile`, if any.
      */
     getIdentityIn(context: ts.SourceFile): ts.Identifier | null;
+    /**
+     * Get a `ts.Identifier` for this `Reference` that exists within the given expression.
+     *
+     * This is very useful for producing `ts.Diagnostic`s that reference `Reference`s that were
+     * extracted from some larger expression, as it can be used to pinpoint the `ts.Identifier` within
+     * the expression from which the `Reference` originated.
+     */
+    getIdentityInExpression(expr: ts.Expression): ts.Identifier | null;
+    /**
+     * Given the 'container' expression from which this `Reference` was extracted, produce a
+     * `ts.Expression` to use in a diagnostic which best indicates the position within the container
+     * expression that generated the `Reference`.
+     *
+     * For example, given a `Reference` to the class 'Bar' and the containing expression:
+     * `[Foo, Bar, Baz]`, this function would attempt to return the `ts.Identifier` for `Bar` within
+     * the array. This could be used to produce a nice diagnostic context:
+     *
+     * ```text
+     * [Foo, Bar, Baz]
+     *       ~~~
+     * ```
+     *
+     * If no specific node can be found, then the `fallback` expression is used, which defaults to the
+     * entire containing expression.
+     */
+    getOriginForDiagnostics(container: ts.Expression, fallback?: ts.Expression): ts.Expression;
     cloneWithAlias(alias: Expression): Reference<T>;
     cloneWithNoIdentifiers(): Reference<T>;
 }

package/src/ngtsc/imports/src/references.js

@@ -18,11 +18,6 @@
     Object.defineProperty(exports, "__esModule", { value: true });
     var tslib_1 = require("tslib");
     var typescript_1 = require("@angular/compiler-cli/src/ngtsc/util/src/typescript");
-    var ImportMode;
-    (function (ImportMode) {
-        ImportMode[ImportMode["UseExistingImport"] = 0] = "UseExistingImport";
-        ImportMode[ImportMode["ForceNewImport"] = 1] = "ForceNewImport";
-    })(ImportMode = exports.ImportMode || (exports.ImportMode = {}));
     /**
      * A `ts.Node` plus the context in which it was discovered.
      *
@@ -110,6 +105,46 @@
         Reference.prototype.getIdentityIn = function (context) {
             return this.identifiers.find(function (id) { return id.getSourceFile() === context; }) || null;
         };
+        /**
+         * Get a `ts.Identifier` for this `Reference` that exists within the given expression.
+         *
+         * This is very useful for producing `ts.Diagnostic`s that reference `Reference`s that were
+         * extracted from some larger expression, as it can be used to pinpoint the `ts.Identifier` within
+         * the expression from which the `Reference` originated.
+         */
+        Reference.prototype.getIdentityInExpression = function (expr) {
+            var sf = expr.getSourceFile();
+            return this.identifiers.find(function (id) {
+                if (id.getSourceFile() !== sf) {
+                    return false;
+                }
+                // This identifier is a match if its position lies within the given expression.
+                return id.pos >= expr.pos && id.end <= expr.end;
+            }) ||
+                null;
+        };
+        /**
+         * Given the 'container' expression from which this `Reference` was extracted, produce a
+         * `ts.Expression` to use in a diagnostic which best indicates the position within the container
+         * expression that generated the `Reference`.
+         *
+         * For example, given a `Reference` to the class 'Bar' and the containing expression:
+         * `[Foo, Bar, Baz]`, this function would attempt to return the `ts.Identifier` for `Bar` within
+         * the array. This could be used to produce a nice diagnostic context:
+         *
+         * ```text
+         * [Foo, Bar, Baz]
+         *       ~~~
+         * ```
+         *
+         * If no specific node can be found, then the `fallback` expression is used, which defaults to the
+         * entire containing expression.
+         */
+        Reference.prototype.getOriginForDiagnostics = function (container, fallback) {
+            if (fallback === void 0) { fallback = container; }
+            var id = this.getIdentityInExpression(container);
+            return id !== null ? id : fallback;
+        };
         Reference.prototype.cloneWithAlias = function (alias) {
             var ref = new Reference(this.node, this.bestGuessOwningModule);
             ref.identifiers = tslib_1.__spread(this.identifiers);
@@ -126,4 +161,4 @@
     }());
     exports.Reference = Reference;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"references.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/imports/src/references.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;;IAKH,kFAA2D;IAE3D,IAAY,UAGX;IAHD,WAAY,UAAU;QACpB,qEAAiB,CAAA;QACjB,+DAAc,CAAA;IAChB,CAAC,EAHW,UAAU,GAAV,kBAAU,KAAV,kBAAU,QAGrB;IAOD;;;;;;;;;;OAUG;IACH;QA2BE,mBAAqB,IAAO,EAAE,qBAA+C;YAA/C,sCAAA,EAAA,4BAA+C;YAAxD,SAAI,GAAJ,IAAI,CAAG;YAZpB,gBAAW,GAAoB,EAAE,CAAC;YAE1C;;;;;eAKG;YACH,cAAS,GAAG,KAAK,CAAC;YAEV,WAAM,GAAoB,IAAI,CAAC;YAGrC,IAAI,CAAC,qBAAqB,GAAG,qBAAqB,CAAC;YAEnD,IAAM,EAAE,GAAG,6BAAgB,CAAC,IAAI,CAAC,CAAC;YAClC,IAAI,EAAE,KAAK,IAAI,EAAE;gBACf,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;aAC3B;QACH,CAAC;QAMD,sBAAI,yCAAkB;YAJtB;;;eAGG;iBACH;gBACE,IAAI,IAAI,CAAC,qBAAqB,KAAK,IAAI,EAAE;oBACvC,OAAO,IAAI,CAAC,qBAAqB,CAAC,SAAS,CAAC;iBAC7C;qBAAM;oBACL,OAAO,IAAI,CAAC;iBACb;YACH,CAAC;;;WAAA;QAOD,sBAAI,2CAAoB;YALxB;;;;eAIG;iBACH,cAAsC,OAAO,IAAI,CAAC,qBAAqB,KAAK,IAAI,CAAC,CAAC,CAAC;;;WAAA;QAQnF,sBAAI,gCAAS;YANb;;;;;eAKG;iBACH;gBACE,IAAM,EAAE,GAAG,6BAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACvC,OAAO,EAAE,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;YACtC,CAAC;;;WAAA;QAED,sBAAI,4BAAK;iBAAT,cAA+B,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;;;WAAA;QAGpD;;;WAGG;QACH,iCAAa,GAAb,UAAc,UAAyB,IAAU,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAErF;;;WAGG;QACH,iCAAa,GAAb,UAAc,OAAsB;YAClC,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAA,EAAE,IAAI,OAAA,EAAE,CAAC,aAAa,EAAE,KAAK,OAAO,EAA9B,CAA8B,CAAC,IAAI,IAAI,CAAC;QAC7E,CAAC;QAED,kCAAc,GAAd,UAAe,KAAiB;YAC9B,IAAM,GAAG,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,qBAAqB,CAAC,CAAC;YACjE,GAAG,CAAC,WAAW,oBAAO,IAAI,CAAC,WAAW,CAAC,CAAC;YACxC,GAAG,CAAC,MAAM,GAAG,KAAK,CAAC;YACnB,OAAO,GAAG,CAAC;QACb,CAAC;QAED,0CAAsB,GAAtB;YACE,IAAM,GAAG,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,qBAAqB,CAAC,CAAC;YACjE,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;YACzB,GAAG,CAAC,WAAW,GAAG,EAAE,CAAC;YACrB,OAAO,GAAG,CAAC;QACb,CAAC;QACH,gBAAC;IAAD,CAAC,AAhGD,IAgGC;IAhGY,8BAAS","sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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} from '@angular/compiler';\nimport * as ts from 'typescript';\n\nimport {identifierOfNode} from '../../util/src/typescript';\n\nexport enum ImportMode {\n  UseExistingImport,\n  ForceNewImport,\n}\n\nexport interface OwningModule {\n  specifier: string;\n  resolutionContext: string;\n}\n\n/**\n * A `ts.Node` plus the context in which it was discovered.\n *\n * A `Reference` is a pointer to a `ts.Node` that was extracted from the program somehow. It\n * contains not only the node itself, but the information regarding how the node was located. In\n * particular, it might track different identifiers by which the node is exposed, as well as\n * potentially a module specifier which might expose the node.\n *\n * The Angular compiler uses `Reference`s instead of `ts.Node`s when tracking classes or generating\n * imports.\n */\nexport class Reference<T extends ts.Node = ts.Node> {\n  /**\n   * The compiler's best guess at an absolute module specifier which owns this `Reference`.\n   *\n   * This is usually determined by tracking the import statements which led the compiler to a given\n   * node. If any of these imports are absolute, it's an indication that the node being imported\n   * might come from that module.\n   *\n   * It is not _guaranteed_ that the node in question is exported from its `bestGuessOwningModule` -\n   * that is mostly a convention that applies in certain package formats.\n   *\n   * If `bestGuessOwningModule` is `null`, then it's likely the node came from the current program.\n   */\n  readonly bestGuessOwningModule: OwningModule|null;\n\n  private identifiers: ts.Identifier[] = [];\n\n  /**\n   * Indicates that the Reference was created synthetically, not as a result of natural value\n   * resolution.\n   *\n   * This is used to avoid misinterpreting the Reference in certain contexts.\n   */\n  synthetic = false;\n\n  private _alias: Expression|null = null;\n\n  constructor(readonly node: T, bestGuessOwningModule: OwningModule|null = null) {\n    this.bestGuessOwningModule = bestGuessOwningModule;\n\n    const id = identifierOfNode(node);\n    if (id !== null) {\n      this.identifiers.push(id);\n    }\n  }\n\n  /**\n   * The best guess at which module specifier owns this particular reference, or `null` if there\n   * isn't one.\n   */\n  get ownedByModuleGuess(): string|null {\n    if (this.bestGuessOwningModule !== null) {\n      return this.bestGuessOwningModule.specifier;\n    } else {\n      return null;\n    }\n  }\n\n  /**\n   * Whether this reference has a potential owning module or not.\n   *\n   * See `bestGuessOwningModule`.\n   */\n  get hasOwningModuleGuess(): boolean { return this.bestGuessOwningModule !== null; }\n\n  /**\n   * A name for the node, if one is available.\n   *\n   * This is only suited for debugging. Any actual references to this node should be made with\n   * `ts.Identifier`s (see `getIdentityIn`).\n   */\n  get debugName(): string|null {\n    const id = identifierOfNode(this.node);\n    return id !== null ? id.text : null;\n  }\n\n  get alias(): Expression|null { return this._alias; }\n\n\n  /**\n   * Record a `ts.Identifier` by which it's valid to refer to this node, within the context of this\n   * `Reference`.\n   */\n  addIdentifier(identifier: ts.Identifier): void { this.identifiers.push(identifier); }\n\n  /**\n   * Get a `ts.Identifier` within this `Reference` that can be used to refer within the context of a\n   * given `ts.SourceFile`, if any.\n   */\n  getIdentityIn(context: ts.SourceFile): ts.Identifier|null {\n    return this.identifiers.find(id => id.getSourceFile() === context) || null;\n  }\n\n  cloneWithAlias(alias: Expression): Reference<T> {\n    const ref = new Reference(this.node, this.bestGuessOwningModule);\n    ref.identifiers = [...this.identifiers];\n    ref._alias = alias;\n    return ref;\n  }\n\n  cloneWithNoIdentifiers(): Reference<T> {\n    const ref = new Reference(this.node, this.bestGuessOwningModule);\n    ref._alias = this._alias;\n    ref.identifiers = [];\n    return ref;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"references.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/imports/src/references.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;;IAKH,kFAA2D;IAO3D;;;;;;;;;;OAUG;IACH;QA2BE,mBAAqB,IAAO,EAAE,qBAA+C;YAA/C,sCAAA,EAAA,4BAA+C;YAAxD,SAAI,GAAJ,IAAI,CAAG;YAZpB,gBAAW,GAAoB,EAAE,CAAC;YAE1C;;;;;eAKG;YACH,cAAS,GAAG,KAAK,CAAC;YAEV,WAAM,GAAoB,IAAI,CAAC;YAGrC,IAAI,CAAC,qBAAqB,GAAG,qBAAqB,CAAC;YAEnD,IAAM,EAAE,GAAG,6BAAgB,CAAC,IAAI,CAAC,CAAC;YAClC,IAAI,EAAE,KAAK,IAAI,EAAE;gBACf,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;aAC3B;QACH,CAAC;QAMD,sBAAI,yCAAkB;YAJtB;;;eAGG;iBACH;gBACE,IAAI,IAAI,CAAC,qBAAqB,KAAK,IAAI,EAAE;oBACvC,OAAO,IAAI,CAAC,qBAAqB,CAAC,SAAS,CAAC;iBAC7C;qBAAM;oBACL,OAAO,IAAI,CAAC;iBACb;YACH,CAAC;;;WAAA;QAOD,sBAAI,2CAAoB;YALxB;;;;eAIG;iBACH,cAAsC,OAAO,IAAI,CAAC,qBAAqB,KAAK,IAAI,CAAC,CAAC,CAAC;;;WAAA;QAQnF,sBAAI,gCAAS;YANb;;;;;eAKG;iBACH;gBACE,IAAM,EAAE,GAAG,6BAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACvC,OAAO,EAAE,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;YACtC,CAAC;;;WAAA;QAED,sBAAI,4BAAK;iBAAT,cAA+B,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;;;WAAA;QAGpD;;;WAGG;QACH,iCAAa,GAAb,UAAc,UAAyB,IAAU,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAErF;;;WAGG;QACH,iCAAa,GAAb,UAAc,OAAsB;YAClC,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAA,EAAE,IAAI,OAAA,EAAE,CAAC,aAAa,EAAE,KAAK,OAAO,EAA9B,CAA8B,CAAC,IAAI,IAAI,CAAC;QAC7E,CAAC;QAED;;;;;;WAMG;QACH,2CAAuB,GAAvB,UAAwB,IAAmB;YACzC,IAAM,EAAE,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YAChC,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAA,EAAE;gBAC7B,IAAI,EAAE,CAAC,aAAa,EAAE,KAAK,EAAE,EAAE;oBAC7B,OAAO,KAAK,CAAC;iBACd;gBAED,+EAA+E;gBAC/E,OAAO,EAAE,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC;YAClD,CAAC,CAAC;gBACE,IAAI,CAAC;QACX,CAAC;QAED;;;;;;;;;;;;;;;;WAgBG;QACH,2CAAuB,GAAvB,UAAwB,SAAwB,EAAE,QAAmC;YAAnC,yBAAA,EAAA,oBAAmC;YAEnF,IAAM,EAAE,GAAG,IAAI,CAAC,uBAAuB,CAAC,SAAS,CAAC,CAAC;YACnD,OAAO,EAAE,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;QACrC,CAAC;QAED,kCAAc,GAAd,UAAe,KAAiB;YAC9B,IAAM,GAAG,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,qBAAqB,CAAC,CAAC;YACjE,GAAG,CAAC,WAAW,oBAAO,IAAI,CAAC,WAAW,CAAC,CAAC;YACxC,GAAG,CAAC,MAAM,GAAG,KAAK,CAAC;YACnB,OAAO,GAAG,CAAC;QACb,CAAC;QAED,0CAAsB,GAAtB;YACE,IAAM,GAAG,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,qBAAqB,CAAC,CAAC;YACjE,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;YACzB,GAAG,CAAC,WAAW,GAAG,EAAE,CAAC;YACrB,OAAO,GAAG,CAAC;QACb,CAAC;QACH,gBAAC;IAAD,CAAC,AA3ID,IA2IC;IA3IY,8BAAS","sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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} from '@angular/compiler';\nimport * as ts from 'typescript';\n\nimport {identifierOfNode} from '../../util/src/typescript';\n\nexport interface OwningModule {\n  specifier: string;\n  resolutionContext: string;\n}\n\n/**\n * A `ts.Node` plus the context in which it was discovered.\n *\n * A `Reference` is a pointer to a `ts.Node` that was extracted from the program somehow. It\n * contains not only the node itself, but the information regarding how the node was located. In\n * particular, it might track different identifiers by which the node is exposed, as well as\n * potentially a module specifier which might expose the node.\n *\n * The Angular compiler uses `Reference`s instead of `ts.Node`s when tracking classes or generating\n * imports.\n */\nexport class Reference<T extends ts.Node = ts.Node> {\n  /**\n   * The compiler's best guess at an absolute module specifier which owns this `Reference`.\n   *\n   * This is usually determined by tracking the import statements which led the compiler to a given\n   * node. If any of these imports are absolute, it's an indication that the node being imported\n   * might come from that module.\n   *\n   * It is not _guaranteed_ that the node in question is exported from its `bestGuessOwningModule` -\n   * that is mostly a convention that applies in certain package formats.\n   *\n   * If `bestGuessOwningModule` is `null`, then it's likely the node came from the current program.\n   */\n  readonly bestGuessOwningModule: OwningModule|null;\n\n  private identifiers: ts.Identifier[] = [];\n\n  /**\n   * Indicates that the Reference was created synthetically, not as a result of natural value\n   * resolution.\n   *\n   * This is used to avoid misinterpreting the Reference in certain contexts.\n   */\n  synthetic = false;\n\n  private _alias: Expression|null = null;\n\n  constructor(readonly node: T, bestGuessOwningModule: OwningModule|null = null) {\n    this.bestGuessOwningModule = bestGuessOwningModule;\n\n    const id = identifierOfNode(node);\n    if (id !== null) {\n      this.identifiers.push(id);\n    }\n  }\n\n  /**\n   * The best guess at which module specifier owns this particular reference, or `null` if there\n   * isn't one.\n   */\n  get ownedByModuleGuess(): string|null {\n    if (this.bestGuessOwningModule !== null) {\n      return this.bestGuessOwningModule.specifier;\n    } else {\n      return null;\n    }\n  }\n\n  /**\n   * Whether this reference has a potential owning module or not.\n   *\n   * See `bestGuessOwningModule`.\n   */\n  get hasOwningModuleGuess(): boolean { return this.bestGuessOwningModule !== null; }\n\n  /**\n   * A name for the node, if one is available.\n   *\n   * This is only suited for debugging. Any actual references to this node should be made with\n   * `ts.Identifier`s (see `getIdentityIn`).\n   */\n  get debugName(): string|null {\n    const id = identifierOfNode(this.node);\n    return id !== null ? id.text : null;\n  }\n\n  get alias(): Expression|null { return this._alias; }\n\n\n  /**\n   * Record a `ts.Identifier` by which it's valid to refer to this node, within the context of this\n   * `Reference`.\n   */\n  addIdentifier(identifier: ts.Identifier): void { this.identifiers.push(identifier); }\n\n  /**\n   * Get a `ts.Identifier` within this `Reference` that can be used to refer within the context of a\n   * given `ts.SourceFile`, if any.\n   */\n  getIdentityIn(context: ts.SourceFile): ts.Identifier|null {\n    return this.identifiers.find(id => id.getSourceFile() === context) || null;\n  }\n\n  /**\n   * Get a `ts.Identifier` for this `Reference` that exists within the given expression.\n   *\n   * This is very useful for producing `ts.Diagnostic`s that reference `Reference`s that were\n   * extracted from some larger expression, as it can be used to pinpoint the `ts.Identifier` within\n   * the expression from which the `Reference` originated.\n   */\n  getIdentityInExpression(expr: ts.Expression): ts.Identifier|null {\n    const sf = expr.getSourceFile();\n    return this.identifiers.find(id => {\n      if (id.getSourceFile() !== sf) {\n        return false;\n      }\n\n      // This identifier is a match if its position lies within the given expression.\n      return id.pos >= expr.pos && id.end <= expr.end;\n    }) ||\n        null;\n  }\n\n  /**\n   * Given the 'container' expression from which this `Reference` was extracted, produce a\n   * `ts.Expression` to use in a diagnostic which best indicates the position within the container\n   * expression that generated the `Reference`.\n   *\n   * For example, given a `Reference` to the class 'Bar' and the containing expression:\n   * `[Foo, Bar, Baz]`, this function would attempt to return the `ts.Identifier` for `Bar` within\n   * the array. This could be used to produce a nice diagnostic context:\n   *\n   * ```text\n   * [Foo, Bar, Baz]\n   *       ~~~\n   * ```\n   *\n   * If no specific node can be found, then the `fallback` expression is used, which defaults to the\n   * entire containing expression.\n   */\n  getOriginForDiagnostics(container: ts.Expression, fallback: ts.Expression = container):\n      ts.Expression {\n    const id = this.getIdentityInExpression(container);\n    return id !== null ? id : fallback;\n  }\n\n  cloneWithAlias(alias: Expression): Reference<T> {\n    const ref = new Reference(this.node, this.bestGuessOwningModule);\n    ref.identifiers = [...this.identifiers];\n    ref._alias = alias;\n    return ref;\n  }\n\n  cloneWithNoIdentifiers(): Reference<T> {\n    const ref = new Reference(this.node, this.bestGuessOwningModule);\n    ref._alias = this._alias;\n    ref.identifiers = [];\n    return ref;\n  }\n}\n"]}

package/src/ngtsc/imports/src/resolver.d.ts

@@ -7,10 +7,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import * as ts from 'typescript';
-import { Reference } from './references';
-export interface ReferenceResolver {
-    resolve(decl: ts.Declaration, importFromHint: string | null, fromFile: string): Reference<ts.Declaration>;
-}
 /**
  * Used by `RouterEntryPointManager` and `NgModuleRouteAnalyzer` (which is in turn is used by
  * `NgModuleDecoratorHandler`) for resolving the module source-files references in lazy-loaded
@@ -21,6 +17,7 @@ export declare class ModuleResolver {
     private program;
     private compilerOptions;
     private host;
-    constructor(program: ts.Program, compilerOptions: ts.CompilerOptions, host: ts.CompilerHost);
-    resolveModuleName(module: string, containingFile: ts.SourceFile): ts.SourceFile | null;
+    private moduleResolutionCache;
+    constructor(program: ts.Program, compilerOptions: ts.CompilerOptions, host: ts.CompilerHost, moduleResolutionCache: ts.ModuleResolutionCache | null);
+    resolveModule(moduleName: string, containingFile: string): ts.SourceFile | null;
 }

package/src/ngtsc/imports/src/resolver.js

@@ -18,13 +18,14 @@
      * definitions).
      */
     var ModuleResolver = /** @class */ (function () {
-        function ModuleResolver(program, compilerOptions, host) {
+        function ModuleResolver(program, compilerOptions, host, moduleResolutionCache) {
             this.program = program;
             this.compilerOptions = compilerOptions;
             this.host = host;
+            this.moduleResolutionCache = moduleResolutionCache;
         }
-        ModuleResolver.prototype.resolveModuleName = function (module, containingFile) {
-            var resolved = typescript_1.resolveModuleName(module, containingFile.fileName, this.compilerOptions, this.host);
+        ModuleResolver.prototype.resolveModule = function (moduleName, containingFile) {
+            var resolved = typescript_1.resolveModuleName(moduleName, containingFile, this.compilerOptions, this.host, this.moduleResolutionCache);
             if (resolved === undefined) {
                 return null;
             }
@@ -34,4 +35,4 @@
     }());
     exports.ModuleResolver = ModuleResolver;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/incremental/api" />
+import * as ts from 'typescript';
+import { AbsoluteFsPath } from '../file_system';
+/**
+ * Interface of the incremental build engine.
+ *
+ * `W` is a generic type representing a unit of work. This is generic to avoid a cyclic dependency
+ * between the incremental engine API definition and its consumer(s).
+ */
+export interface IncrementalBuild<W> {
+    /**
+     * Retrieve the prior analysis work, if any, done for the given source file.
+     */
+    priorWorkFor(sf: ts.SourceFile): W[] | null;
+}
+/**
+ * Tracks dependencies between source files or resources in the application.
+ */
+export interface DependencyTracker<T extends {
+    fileName: string;
+} = ts.SourceFile> {
+    /**
+     * Record that the file `from` depends on the file `on`.
+     */
+    addDependency(from: T, on: T): void;
+    /**
+     * Record that the file `from` depends on the resource file `on`.
+     */
+    addResourceDependency(from: T, on: AbsoluteFsPath): void;
+    /**
+     * Record that the file `from` depends on the file `on` as well as `on`'s direct dependencies.
+     *
+     * This operation is reified immediately, so if future dependencies are added to `on` they will
+     * not automatically be added to `from`.
+     */
+    addTransitiveDependency(from: T, on: T): void;
+    /**
+     * Record that the file `from` depends on the resource dependencies of `resourcesOf`.
+     *
+     * This operation is reified immediately, so if future resource dependencies are added to
+     * `resourcesOf` they will not automatically be added to `from`.
+     */
+    addTransitiveResources(from: T, resourcesOf: T): void;
+}

package/src/ngtsc/incremental/api.js

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright Google Inc. 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/api", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -6,4 +6,5 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/incremental" />
+export { NOOP_INCREMENTAL_BUILD } from './src/noop';
 export { IncrementalDriver } from './src/state';

package/src/ngtsc/incremental/index.js

@@ -11,12 +11,14 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/src/ngtsc/incremental", ["require", "exports", "@angular/compiler-cli/src/ngtsc/incremental/src/state"], factory);
+        define("@angular/compiler-cli/src/ngtsc/incremental", ["require", "exports", "@angular/compiler-cli/src/ngtsc/incremental/src/noop", "@angular/compiler-cli/src/ngtsc/incremental/src/state"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
+    var noop_1 = require("@angular/compiler-cli/src/ngtsc/incremental/src/noop");
+    exports.NOOP_INCREMENTAL_BUILD = noop_1.NOOP_INCREMENTAL_BUILD;
     var state_1 = require("@angular/compiler-cli/src/ngtsc/incremental/src/state");
     exports.IncrementalDriver = state_1.IncrementalDriver;
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvc3JjL25ndHNjL2luY3JlbWVudGFsL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7Ozs7O0lBRUgsK0VBQThDO0lBQXRDLG9DQUFBLGlCQUFpQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQge0luY3JlbWVudGFsRHJpdmVyfSBmcm9tICcuL3NyYy9zdGF0ZSc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvc3JjL25ndHNjL2luY3JlbWVudGFsL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7Ozs7O0lBRUgsNkVBQWtEO0lBQTFDLHdDQUFBLHNCQUFzQixDQUFBO0lBQzlCLCtFQUE4QztJQUF0QyxvQ0FBQSxpQkFBaUIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0IHtOT09QX0lOQ1JFTUVOVEFMX0JVSUxEfSBmcm9tICcuL3NyYy9ub29wJztcbmV4cG9ydCB7SW5jcmVtZW50YWxEcml2ZXJ9IGZyb20gJy4vc3JjL3N0YXRlJztcbiJdfQ==

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

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/incremental/src/dependency_tracking" />
+import * as ts from 'typescript';
+import { AbsoluteFsPath } from '../../file_system';
+import { DependencyTracker } from '../api';
+/**
+ * An implementation of the `DependencyTracker` dependency graph API.
+ *
+ * The `FileDependencyGraph`'s primary job is to determine whether a given file has "logically"
+ * changed, given the set of physical changes (direct changes to files on disk).
+ *
+ * A file is logically changed if at least one of three conditions is met:
+ *
+ * 1. The file itself has physically changed.
+ * 2. One of its dependencies has physically changed.
+ * 3. One of its resource dependencies has physically changed.
+ */
+export declare class FileDependencyGraph<T extends {
+    fileName: string;
+} = ts.SourceFile> implements DependencyTracker<T> {
+    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;
+    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.
+     *
+     * This method performs two tasks:
+     *
+     * 1. For files which have not logically changed, their dependencies from `previous` are added to
+     *    `this` graph.
+     * 2. For files which have logically changed, they're added to a set of logically changed files
+     *    which is eventually returned.
+     *
+     * In essence, for build `n`, this method performs:
+     *
+     * G(n) + L(n) = G(n - 1) + P(n)
+     *
+     * where:
+     *
+     * G(n) = the dependency graph of build `n`
+     * L(n) = the logically changed files from build n - 1 to build n.
+     * P(n) = the physically changed files from build n - 1 to build n.
+     */
+    updateWithPhysicalChanges(previous: FileDependencyGraph<T>, changedTsPaths: Set<string>, deletedTsPaths: Set<string>, changedResources: Set<AbsoluteFsPath>): Set<string>;
+    private nodeFor;
+}

package/src/ngtsc/incremental/src/dependency_tracking.js

@@ -0,0 +1,186 @@
+/**
+ * @license
+ * Copyright Google Inc. 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/src/dependency_tracking", ["require", "exports", "tslib"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
+    /**
+     * An implementation of the `DependencyTracker` dependency graph API.
+     *
+     * The `FileDependencyGraph`'s primary job is to determine whether a given file has "logically"
+     * changed, given the set of physical changes (direct changes to files on disk).
+     *
+     * A file is logically changed if at least one of three conditions is met:
+     *
+     * 1. The file itself has physically changed.
+     * 2. One of its dependencies has physically changed.
+     * 3. One of its resource dependencies has physically changed.
+     */
+    var FileDependencyGraph = /** @class */ (function () {
+        function FileDependencyGraph() {
+            this.nodes = new Map();
+        }
+        FileDependencyGraph.prototype.addDependency = function (from, on) { this.nodeFor(from).dependsOn.add(on.fileName); };
+        FileDependencyGraph.prototype.addResourceDependency = function (from, resource) {
+            this.nodeFor(from).usesResources.add(resource);
+        };
+        FileDependencyGraph.prototype.addTransitiveDependency = function (from, on) {
+            var e_1, _a;
+            var nodeFrom = this.nodeFor(from);
+            nodeFrom.dependsOn.add(on.fileName);
+            var nodeOn = this.nodeFor(on);
+            try {
+                for (var _b = tslib_1.__values(nodeOn.dependsOn), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var dep = _c.value;
+                    nodeFrom.dependsOn.add(dep);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        };
+        FileDependencyGraph.prototype.addTransitiveResources = function (from, resourcesOf) {
+            var e_2, _a;
+            var nodeFrom = this.nodeFor(from);
+            var nodeOn = this.nodeFor(resourcesOf);
+            try {
+                for (var _b = tslib_1.__values(nodeOn.usesResources), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var dep = _c.value;
+                    nodeFrom.usesResources.add(dep);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        };
+        FileDependencyGraph.prototype.isStale = function (sf, changedTsPaths, changedResources) {
+            return isLogicallyChanged(sf, this.nodeFor(sf), changedTsPaths, EMPTY_SET, changedResources);
+        };
+        /**
+         * Update the current dependency graph from a previous one, incorporating a set of physical
+         * changes.
+         *
+         * This method performs two tasks:
+         *
+         * 1. For files which have not logically changed, their dependencies from `previous` are added to
+         *    `this` graph.
+         * 2. For files which have logically changed, they're added to a set of logically changed files
+         *    which is eventually returned.
+         *
+         * In essence, for build `n`, this method performs:
+         *
+         * G(n) + L(n) = G(n - 1) + P(n)
+         *
+         * where:
+         *
+         * G(n) = the dependency graph of build `n`
+         * L(n) = the logically changed files from build n - 1 to build n.
+         * P(n) = the physically changed files from build n - 1 to build n.
+         */
+        FileDependencyGraph.prototype.updateWithPhysicalChanges = function (previous, changedTsPaths, deletedTsPaths, changedResources) {
+            var e_3, _a;
+            var logicallyChanged = new Set();
+            try {
+                for (var _b = tslib_1.__values(previous.nodes.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var sf = _c.value;
+                    var node = previous.nodeFor(sf);
+                    if (isLogicallyChanged(sf, node, changedTsPaths, deletedTsPaths, changedResources)) {
+                        logicallyChanged.add(sf.fileName);
+                    }
+                    else if (!deletedTsPaths.has(sf.fileName)) {
+                        this.nodes.set(sf, {
+                            dependsOn: new Set(node.dependsOn),
+                            usesResources: new Set(node.usesResources),
+                        });
+                    }
+                }
+            }
+            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; }
+            }
+            return logicallyChanged;
+        };
+        FileDependencyGraph.prototype.nodeFor = function (sf) {
+            if (!this.nodes.has(sf)) {
+                this.nodes.set(sf, {
+                    dependsOn: new Set(),
+                    usesResources: new Set(),
+                });
+            }
+            return this.nodes.get(sf);
+        };
+        return FileDependencyGraph;
+    }());
+    exports.FileDependencyGraph = FileDependencyGraph;
+    /**
+     * Determine whether `sf` has logically changed, given its dependencies and the set of physically
+     * changed files and resources.
+     */
+    function isLogicallyChanged(sf, node, changedTsPaths, deletedTsPaths, changedResources) {
+        var e_4, _a, e_5, _b;
+        // A file is logically changed if it has physically changed itself (including being deleted).
+        if (changedTsPaths.has(sf.fileName) || deletedTsPaths.has(sf.fileName)) {
+            return true;
+        }
+        try {
+            // A file is logically changed if one of its dependencies has physically changed.
+            for (var _c = tslib_1.__values(node.dependsOn), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var dep = _d.value;
+                if (changedTsPaths.has(dep) || deletedTsPaths.has(dep)) {
+                    return true;
+                }
+            }
+        }
+        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; }
+        }
+        try {
+            // A file is logically changed if one of its resources has physically changed.
+            for (var _e = tslib_1.__values(node.usesResources), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var dep = _f.value;
+                if (changedResources.has(dep)) {
+                    return true;
+                }
+            }
+        }
+        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; }
+        }
+        return false;
+    }
+    var EMPTY_SET = new Set();
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dependency_tracking.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/incremental/src/dependency_tracking.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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 {AbsoluteFsPath} from '../../file_system';\nimport {DependencyTracker} from '../api';\n\n/**\n * An implementation of the `DependencyTracker` dependency graph API.\n *\n * The `FileDependencyGraph`'s primary job is to determine whether a given file has \"logically\"\n * changed, given the set of physical changes (direct changes to files on disk).\n *\n * A file is logically changed if at least one of three conditions is met:\n *\n * 1. The file itself has physically changed.\n * 2. One of its dependencies has physically changed.\n * 3. One of its resource dependencies has physically changed.\n */\nexport class FileDependencyGraph<T extends{fileName: string} = ts.SourceFile> implements\n    DependencyTracker<T> {\n  private nodes = new Map<T, FileNode>();\n\n  addDependency(from: T, on: T): void { this.nodeFor(from).dependsOn.add(on.fileName); }\n\n  addResourceDependency(from: T, resource: AbsoluteFsPath): void {\n    this.nodeFor(from).usesResources.add(resource);\n  }\n\n  addTransitiveDependency(from: T, on: T): void {\n    const nodeFrom = this.nodeFor(from);\n    nodeFrom.dependsOn.add(on.fileName);\n\n    const nodeOn = this.nodeFor(on);\n    for (const dep of nodeOn.dependsOn) {\n      nodeFrom.dependsOn.add(dep);\n    }\n  }\n\n  addTransitiveResources(from: T, resourcesOf: T): void {\n    const nodeFrom = this.nodeFor(from);\n    const nodeOn = this.nodeFor(resourcesOf);\n    for (const dep of nodeOn.usesResources) {\n      nodeFrom.usesResources.add(dep);\n    }\n  }\n\n  isStale(sf: T, changedTsPaths: Set<string>, changedResources: Set<AbsoluteFsPath>): boolean {\n    return isLogicallyChanged(sf, this.nodeFor(sf), changedTsPaths, EMPTY_SET, changedResources);\n  }\n\n  /**\n   * Update the current dependency graph from a previous one, incorporating a set of physical\n   * changes.\n   *\n   * This method performs two tasks:\n   *\n   * 1. For files which have not logically changed, their dependencies from `previous` are added to\n   *    `this` graph.\n   * 2. For files which have logically changed, they're added to a set of logically changed files\n   *    which is eventually returned.\n   *\n   * In essence, for build `n`, this method performs:\n   *\n   * G(n) + L(n) = G(n - 1) + P(n)\n   *\n   * where:\n   *\n   * G(n) = the dependency graph of build `n`\n   * L(n) = the logically changed files from build n - 1 to build n.\n   * P(n) = the physically changed files from build n - 1 to build n.\n   */\n  updateWithPhysicalChanges(\n      previous: FileDependencyGraph<T>, changedTsPaths: Set<string>, deletedTsPaths: Set<string>,\n      changedResources: Set<AbsoluteFsPath>): Set<string> {\n    const logicallyChanged = new Set<string>();\n\n    for (const sf of previous.nodes.keys()) {\n      const node = previous.nodeFor(sf);\n      if (isLogicallyChanged(sf, node, changedTsPaths, deletedTsPaths, changedResources)) {\n        logicallyChanged.add(sf.fileName);\n      } else if (!deletedTsPaths.has(sf.fileName)) {\n        this.nodes.set(sf, {\n          dependsOn: new Set(node.dependsOn),\n          usesResources: new Set(node.usesResources),\n        });\n      }\n    }\n\n    return logicallyChanged;\n  }\n\n  private nodeFor(sf: T): FileNode {\n    if (!this.nodes.has(sf)) {\n      this.nodes.set(sf, {\n        dependsOn: new Set<string>(),\n        usesResources: new Set<AbsoluteFsPath>(),\n      });\n    }\n    return this.nodes.get(sf) !;\n  }\n}\n\n/**\n * Determine whether `sf` has logically changed, given its dependencies and the set of physically\n * changed files and resources.\n */\nfunction isLogicallyChanged<T extends{fileName: string}>(\n    sf: T, node: FileNode, changedTsPaths: ReadonlySet<string>, deletedTsPaths: ReadonlySet<string>,\n    changedResources: ReadonlySet<AbsoluteFsPath>): boolean {\n  // A file is logically changed if it has physically changed itself (including being deleted).\n  if (changedTsPaths.has(sf.fileName) || deletedTsPaths.has(sf.fileName)) {\n    return true;\n  }\n\n  // A file is logically changed if one of its dependencies has physically changed.\n  for (const dep of node.dependsOn) {\n    if (changedTsPaths.has(dep) || deletedTsPaths.has(dep)) {\n      return true;\n    }\n  }\n\n  // A file is logically changed if one of its resources has physically changed.\n  for (const dep of node.usesResources) {\n    if (changedResources.has(dep)) {\n      return true;\n    }\n  }\n  return false;\n}\n\ninterface FileNode {\n  dependsOn: Set<string>;\n  usesResources: Set<AbsoluteFsPath>;\n}\n\nconst EMPTY_SET: ReadonlySet<any> = new Set<any>();\n"]}

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

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/incremental/src/noop" />
+import { IncrementalBuild } from '../api';
+export declare const NOOP_INCREMENTAL_BUILD: IncrementalBuild<any>;

package/src/ngtsc/incremental/src/noop.js

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright Google Inc. 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/src/noop", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NOOP_INCREMENTAL_BUILD = {
+        priorWorkFor: function () { return null; }
+    };
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9vcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBpbGVyLWNsaS9zcmMvbmd0c2MvaW5jcmVtZW50YWwvc3JjL25vb3AudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HOzs7Ozs7Ozs7Ozs7SUFJVSxRQUFBLHNCQUFzQixHQUEwQjtRQUMzRCxZQUFZLEVBQUUsY0FBTSxPQUFBLElBQUksRUFBSixDQUFJO0tBQ3pCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7SW5jcmVtZW50YWxCdWlsZH0gZnJvbSAnLi4vYXBpJztcblxuZXhwb3J0IGNvbnN0IE5PT1BfSU5DUkVNRU5UQUxfQlVJTEQ6IEluY3JlbWVudGFsQnVpbGQ8YW55PiA9IHtcbiAgcHJpb3JXb3JrRm9yOiAoKSA9PiBudWxsXG59O1xuIl19