@angular/compiler-cli 11.2.3 → 11.2.7

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

@@ -41,6 +41,33 @@ export declare enum ImportFlags {
      */
     AllowTypeImports = 4
 }
+/**
+ * An emitter strategy has the ability to indicate which `ts.SourceFile` is being imported by the
+ * expression that it has generated. This information is useful for consumers of the emitted
+ * reference that would otherwise have to perform a relatively expensive module resolution step,
+ * e.g. for cyclic import analysis. In cases the emitter is unable to definitively determine the
+ * imported source file or a computation would be required to actually determine the imported
+ * source file, then `'unknown'` should be returned. If the generated expression does not represent
+ * an import then `null` should be used.
+ */
+export declare type ImportedFile = ts.SourceFile | 'unknown' | null;
+/**
+ * Represents the emitted expression of a `Reference` that is valid in the source file it was
+ * emitted from.
+ */
+export interface EmittedReference {
+    /**
+     * The expression that refers to `Reference`.
+     */
+    expression: Expression;
+    /**
+     * The `ts.SourceFile` that is imported by `expression`. This is not necessarily the source file
+     * of the `Reference`'s declaration node, as the reference may have been rewritten through an
+     * alias export. It could also be `null` if `expression` is a local identifier, or `'unknown'` if
+     * the exact source file that is being imported is not known to the emitter.
+     */
+    importedFile: ImportedFile;
+}
 /**
  * A particular strategy for generating an expression which refers to a `Reference`.
  *
@@ -61,9 +88,10 @@ export interface ReferenceEmitStrategy {
      * @param ref the `Reference` for which to generate an expression
      * @param context the source file in which the `Expression` must be valid
      * @param importFlags a flag which controls whether imports should be generated or not
-     * @returns an `Expression` which refers to the `Reference`, or `null` if none can be generated
+     * @returns an `EmittedReference` which refers to the `Reference`, or `null` if none can be
+     *   generated
      */
-    emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags): Expression | null;
+    emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags): EmittedReference | null;
 }
 /**
  * Generates `Expression`s which refer to `Reference`s in a given context.
@@ -74,14 +102,27 @@ export interface ReferenceEmitStrategy {
 export declare class ReferenceEmitter {
     private strategies;
     constructor(strategies: ReferenceEmitStrategy[]);
-    emit(ref: Reference, context: ts.SourceFile, importFlags?: ImportFlags): Expression;
+    emit(ref: Reference, context: ts.SourceFile, importFlags?: ImportFlags): EmittedReference;
 }
 /**
  * A `ReferenceEmitStrategy` which will refer to declarations by any local `ts.Identifier`s, if
  * such identifiers are available.
  */
 export declare class LocalIdentifierStrategy implements ReferenceEmitStrategy {
-    emit(ref: Reference<ts.Node>, context: ts.SourceFile, importFlags: ImportFlags): Expression | null;
+    emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags): EmittedReference | null;
+}
+/**
+ * Represents the exported declarations from a module source file.
+ */
+interface ModuleExports {
+    /**
+     * The source file of the module.
+     */
+    module: ts.SourceFile;
+    /**
+     * The map of declarations to their exported name.
+     */
+    exportMap: Map<DeclarationNode, string>;
 }
 /**
  * A `ReferenceEmitStrategy` which will refer to declarations that come from `node_modules` using
@@ -103,10 +144,9 @@ export declare class AbsoluteModuleStrategy implements ReferenceEmitStrategy {
      */
     private moduleExportsCache;
     constructor(program: ts.Program, checker: ts.TypeChecker, moduleResolver: ModuleResolver, reflectionHost: ReflectionHost);
-    emit(ref: Reference<ts.Node>, context: ts.SourceFile, importFlags: ImportFlags): Expression | null;
-    private resolveImportName;
+    emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags): EmittedReference | null;
     private getExportsOfModule;
-    protected enumerateExportsOfModule(specifier: string, fromFile: string): Map<DeclarationNode, string> | null;
+    protected enumerateExportsOfModule(specifier: string, fromFile: string): ModuleExports | null;
 }
 /**
  * A `ReferenceEmitStrategy` which will refer to declarations via relative paths, provided they're
@@ -120,7 +160,7 @@ export declare class LogicalProjectStrategy implements ReferenceEmitStrategy {
     private reflector;
     private logicalFs;
     constructor(reflector: ReflectionHost, logicalFs: LogicalFileSystem);
-    emit(ref: Reference<ts.Node>, context: ts.SourceFile): Expression | null;
+    emit(ref: Reference, context: ts.SourceFile): EmittedReference | null;
 }
 /**
  * A `ReferenceEmitStrategy` which constructs relatives paths between `ts.SourceFile`s.
@@ -131,7 +171,7 @@ export declare class LogicalProjectStrategy implements ReferenceEmitStrategy {
 export declare class RelativePathStrategy implements ReferenceEmitStrategy {
     private reflector;
     constructor(reflector: ReflectionHost);
-    emit(ref: Reference<ts.Node>, context: ts.SourceFile): Expression | null;
+    emit(ref: Reference, context: ts.SourceFile): EmittedReference | null;
 }
 /**
  * A `ReferenceEmitStrategy` which uses a `UnifiedModulesHost` to generate absolute import
@@ -141,5 +181,6 @@ export declare class UnifiedModulesStrategy implements ReferenceEmitStrategy {
     private reflector;
     private unifiedModulesHost;
     constructor(reflector: ReflectionHost, unifiedModulesHost: UnifiedModulesHost);
-    emit(ref: Reference<ts.Node>, context: ts.SourceFile): Expression | null;
+    emit(ref: Reference, context: ts.SourceFile): EmittedReference | null;
 }
+export {};

package/src/ngtsc/imports/src/emitter.js

@@ -107,13 +107,19 @@
             // such a case, the reference's `identities` property would be `[foo]`, which would result in an
             // invalid emission of a free-standing `foo` identifier, rather than `exports.foo`.
             if (!typescript_1.isDeclaration(ref.node) && refSf === context) {
-                return new compiler_1.WrappedNodeExpr(ref.node);
+                return {
+                    expression: new compiler_1.WrappedNodeExpr(ref.node),
+                    importedFile: null,
+                };
             }
             // A Reference can have multiple identities in different files, so it may already have an
             // Identifier in the requested context file.
             var identifier = ref.getIdentityIn(context);
             if (identifier !== null) {
-                return new compiler_1.WrappedNodeExpr(identifier);
+                return {
+                    expression: new compiler_1.WrappedNodeExpr(identifier),
+                    importedFile: null,
+                };
             }
             else {
                 return null;
@@ -158,22 +164,17 @@
             }
             // Try to find the exported name of the declaration, if one is available.
             var _a = ref.bestGuessOwningModule, specifier = _a.specifier, resolutionContext = _a.resolutionContext;
-            var symbolName = this.resolveImportName(specifier, ref.node, resolutionContext);
-            if (symbolName === null) {
+            var exports = this.getExportsOfModule(specifier, resolutionContext);
+            if (exports === null || !exports.exportMap.has(ref.node)) {
                 // TODO(alxhub): make this error a ts.Diagnostic pointing at whatever caused this import to be
                 // triggered.
                 throw new Error("Symbol " + ref.debugName + " declared in " + typescript_1.getSourceFile(ref.node).fileName + " is not exported from " + specifier + " (import into " + context.fileName + ")");
             }
-            return new compiler_1.ExternalExpr(new compiler_1.ExternalReference(specifier, symbolName));
-        };
-        AbsoluteModuleStrategy.prototype.resolveImportName = function (moduleName, target, fromFile) {
-            var exports = this.getExportsOfModule(moduleName, fromFile);
-            if (exports !== null && exports.has(target)) {
-                return exports.get(target);
-            }
-            else {
-                return null;
-            }
+            var symbolName = exports.exportMap.get(ref.node);
+            return {
+                expression: new compiler_1.ExternalExpr(new compiler_1.ExternalReference(specifier, symbolName)),
+                importedFile: exports.module,
+            };
         };
         AbsoluteModuleStrategy.prototype.getExportsOfModule = function (moduleName, fromFile) {
             if (!this.moduleExportsCache.has(moduleName)) {
@@ -195,7 +196,7 @@
             exports.forEach(function (declaration, name) {
                 exportMap.set(declaration.node, name);
             });
-            return exportMap;
+            return { module: entryPointFile, exportMap: exportMap };
         };
         return AbsoluteModuleStrategy;
     }());
@@ -238,7 +239,10 @@
             // With both files expressed as LogicalProjectPaths, getting the module specifier as a relative
             // path is now straightforward.
             var moduleName = file_system_1.LogicalProjectPath.relativePathBetween(originPath, destPath);
-            return new compiler_1.ExternalExpr({ moduleName: moduleName, name: name });
+            return {
+                expression: new compiler_1.ExternalExpr({ moduleName: moduleName, name: name }),
+                importedFile: destSf,
+            };
         };
         return LogicalProjectStrategy;
     }());
@@ -258,7 +262,7 @@
             var relativePath = file_system_1.relative(file_system_1.dirname(file_system_1.absoluteFromSourceFile(context)), file_system_1.absoluteFromSourceFile(destSf));
             var moduleName = file_system_1.toRelativeImport(util_1.stripExtension(relativePath));
             var name = find_export_1.findExportedNameOfNode(ref.node, destSf, this.reflector);
-            return new compiler_1.ExternalExpr({ moduleName: moduleName, name: name });
+            return { expression: new compiler_1.ExternalExpr({ moduleName: moduleName, name: name }), importedFile: destSf };
         };
         return RelativePathStrategy;
     }());
@@ -279,10 +283,13 @@
                 return null;
             }
             var moduleName = this.unifiedModulesHost.fileNameToModuleName(destSf.fileName, context.fileName);
-            return new compiler_1.ExternalExpr({ moduleName: moduleName, name: name });
+            return {
+                expression: new compiler_1.ExternalExpr({ moduleName: moduleName, name: name }),
+                importedFile: destSf,
+            };
         };
         return UnifiedModulesStrategy;
     }());
     exports.UnifiedModulesStrategy = UnifiedModulesStrategy;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"emitter.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/imports/src/emitter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {Expression, ExternalExpr, ExternalReference, WrappedNodeExpr} from '@angular/compiler';\nimport * as ts from 'typescript';\n\nimport {UnifiedModulesHost} from '../../core/api';\nimport {absoluteFromSourceFile, dirname, LogicalFileSystem, LogicalProjectPath, relative, toRelativeImport} from '../../file_system';\nimport {stripExtension} from '../../file_system/src/util';\nimport {DeclarationNode, isConcreteDeclaration, ReflectionHost} from '../../reflection';\nimport {getSourceFile, isDeclaration, isTypeDeclaration, nodeNameForError} from '../../util/src/typescript';\n\nimport {findExportedNameOfNode} from './find_export';\nimport {Reference} from './references';\nimport {ModuleResolver} from './resolver';\n\n\n/**\n * Flags which alter the imports generated by the `ReferenceEmitter`.\n */\nexport enum ImportFlags {\n  None = 0x00,\n\n  /**\n   * Force the generation of a new import when generating a reference, even if an identifier already\n   * exists in the target file which could be used instead.\n   *\n   * This is sometimes required if there's a risk TypeScript might remove imports during emit.\n   */\n  ForceNewImport = 0x01,\n\n  /**\n   * Don't make use of any aliasing information when emitting a reference.\n   *\n   * This is sometimes required if emitting into a context where generated references will be fed\n   * into TypeScript and type-checked (such as in template type-checking).\n   */\n  NoAliasing = 0x02,\n\n  /**\n   * Indicates that an import to a type-only declaration is allowed.\n   *\n   * For references that occur in type-positions, the referred declaration may be a type-only\n   * declaration that is not retained during emit. Including this flag allows to emit references to\n   * type-only declarations as used in e.g. template type-checking.\n   */\n  AllowTypeImports = 0x04,\n}\n\n/**\n * A particular strategy for generating an expression which refers to a `Reference`.\n *\n * There are many potential ways a given `Reference` could be referred to in the context of a given\n * file. A local declaration could be available, the `Reference` could be importable via a relative\n * import within the project, or an absolute import into `node_modules` might be necessary.\n *\n * Different `ReferenceEmitStrategy` implementations implement specific logic for generating such\n * references. A single strategy (such as using a local declaration) may not always be able to\n * generate an expression for every `Reference` (for example, if no local identifier is available),\n * and may return `null` in such a case.\n */\nexport interface ReferenceEmitStrategy {\n  /**\n   * Emit an `Expression` which refers to the given `Reference` in the context of a particular\n   * source file, if possible.\n   *\n   * @param ref the `Reference` for which to generate an expression\n   * @param context the source file in which the `Expression` must be valid\n   * @param importFlags a flag which controls whether imports should be generated or not\n   * @returns an `Expression` which refers to the `Reference`, or `null` if none can be generated\n   */\n  emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags): Expression|null;\n}\n\n/**\n * Generates `Expression`s which refer to `Reference`s in a given context.\n *\n * A `ReferenceEmitter` uses one or more `ReferenceEmitStrategy` implementations to produce an\n * `Expression` which refers to a `Reference` in the context of a particular file.\n */\nexport class ReferenceEmitter {\n  constructor(private strategies: ReferenceEmitStrategy[]) {}\n\n  emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags = ImportFlags.None):\n      Expression {\n    for (const strategy of this.strategies) {\n      const emitted = strategy.emit(ref, context, importFlags);\n      if (emitted !== null) {\n        return emitted;\n      }\n    }\n    throw new Error(`Unable to write a reference to ${nodeNameForError(ref.node)} in ${\n        ref.node.getSourceFile().fileName} from ${context.fileName}`);\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which will refer to declarations by any local `ts.Identifier`s, if\n * such identifiers are available.\n */\nexport class LocalIdentifierStrategy implements ReferenceEmitStrategy {\n  emit(ref: Reference<ts.Node>, context: ts.SourceFile, importFlags: ImportFlags): Expression|null {\n    const refSf = getSourceFile(ref.node);\n\n    // If the emitter has specified ForceNewImport, then LocalIdentifierStrategy should not use a\n    // local identifier at all, *except* in the source file where the node is actually declared.\n    if (importFlags & ImportFlags.ForceNewImport && refSf !== context) {\n      return null;\n    }\n\n    // If referenced node is not an actual TS declaration (e.g. `class Foo` or `function foo() {}`,\n    // etc) and it is in the current file then just use it directly.\n    // This is important because the reference could be a property access (e.g. `exports.foo`). In\n    // such a case, the reference's `identities` property would be `[foo]`, which would result in an\n    // invalid emission of a free-standing `foo` identifier, rather than `exports.foo`.\n    if (!isDeclaration(ref.node) && refSf === context) {\n      return new WrappedNodeExpr(ref.node);\n    }\n\n    // A Reference can have multiple identities in different files, so it may already have an\n    // Identifier in the requested context file.\n    const identifier = ref.getIdentityIn(context);\n    if (identifier !== null) {\n      return new WrappedNodeExpr(identifier);\n    } else {\n      return null;\n    }\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which will refer to declarations that come from `node_modules` using\n * an absolute import.\n *\n * Part of this strategy involves looking at the target entry point and identifying the exported\n * name of the targeted declaration, as it might be different from the declared name (e.g. a\n * directive might be declared as FooDirImpl, but exported as FooDir). If no export can be found\n * which maps back to the original directive, an error is thrown.\n */\nexport class AbsoluteModuleStrategy implements ReferenceEmitStrategy {\n  /**\n   * A cache of the exports of specific modules, because resolving a module to its exports is a\n   * costly operation.\n   */\n  private moduleExportsCache = new Map<string, Map<DeclarationNode, string>|null>();\n\n  constructor(\n      protected program: ts.Program, protected checker: ts.TypeChecker,\n      protected moduleResolver: ModuleResolver, private reflectionHost: ReflectionHost) {}\n\n  emit(ref: Reference<ts.Node>, context: ts.SourceFile, importFlags: ImportFlags): Expression|null {\n    if (ref.bestGuessOwningModule === null) {\n      // There is no module name available for this Reference, meaning it was arrived at via a\n      // relative path.\n      return null;\n    } else if (!isDeclaration(ref.node)) {\n      // It's not possible to import something which isn't a declaration.\n      throw new Error(`Debug assert: unable to import a Reference to non-declaration of type ${\n          ts.SyntaxKind[ref.node.kind]}.`);\n    } else if ((importFlags & ImportFlags.AllowTypeImports) === 0 && isTypeDeclaration(ref.node)) {\n      throw new Error(`Importing a type-only declaration of type ${\n          ts.SyntaxKind[ref.node.kind]} in a value position is not allowed.`);\n    }\n\n    // Try to find the exported name of the declaration, if one is available.\n    const {specifier, resolutionContext} = ref.bestGuessOwningModule;\n    const symbolName = this.resolveImportName(specifier, ref.node, resolutionContext);\n    if (symbolName === null) {\n      // TODO(alxhub): make this error a ts.Diagnostic pointing at whatever caused this import to be\n      // triggered.\n      throw new Error(`Symbol ${ref.debugName} declared in ${\n          getSourceFile(ref.node).fileName} is not exported from ${specifier} (import into ${\n          context.fileName})`);\n    }\n\n    return new ExternalExpr(new ExternalReference(specifier, symbolName));\n  }\n\n  private resolveImportName(moduleName: string, target: DeclarationNode, fromFile: string): string\n      |null {\n    const exports = this.getExportsOfModule(moduleName, fromFile);\n    if (exports !== null && exports.has(target)) {\n      return exports.get(target)!;\n    } else {\n      return null;\n    }\n  }\n\n  private getExportsOfModule(moduleName: string, fromFile: string):\n      Map<DeclarationNode, string>|null {\n    if (!this.moduleExportsCache.has(moduleName)) {\n      this.moduleExportsCache.set(moduleName, this.enumerateExportsOfModule(moduleName, fromFile));\n    }\n    return this.moduleExportsCache.get(moduleName)!;\n  }\n\n  protected enumerateExportsOfModule(specifier: string, fromFile: string):\n      Map<DeclarationNode, string>|null {\n    // First, resolve the module specifier to its entry point, and get the ts.Symbol for it.\n    const entryPointFile = this.moduleResolver.resolveModule(specifier, fromFile);\n    if (entryPointFile === null) {\n      return null;\n    }\n\n    const exports = this.reflectionHost.getExportsOfModule(entryPointFile);\n    if (exports === null) {\n      return null;\n    }\n    const exportMap = new Map<DeclarationNode, string>();\n    exports.forEach((declaration, name) => {\n      exportMap.set(declaration.node, name);\n    });\n    return exportMap;\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which will refer to declarations via relative paths, provided they're\n * both in the logical project \"space\" of paths.\n *\n * This is trickier than it sounds, as the two files may be in different root directories in the\n * project. Simply calculating a file system relative path between the two is not sufficient.\n * Instead, `LogicalProjectPath`s are used.\n */\nexport class LogicalProjectStrategy implements ReferenceEmitStrategy {\n  constructor(private reflector: ReflectionHost, private logicalFs: LogicalFileSystem) {}\n\n  emit(ref: Reference<ts.Node>, context: ts.SourceFile): Expression|null {\n    const destSf = getSourceFile(ref.node);\n\n    // Compute the relative path from the importing file to the file being imported. This is done\n    // as a logical path computation, because the two files might be in different rootDirs.\n    const destPath = this.logicalFs.logicalPathOfSf(destSf);\n    if (destPath === null) {\n      // The imported file is not within the logical project filesystem.\n      return null;\n    }\n\n    const originPath = this.logicalFs.logicalPathOfSf(context);\n    if (originPath === null) {\n      throw new Error(\n          `Debug assert: attempt to import from ${context.fileName} but it's outside the program?`);\n    }\n\n    // There's no way to emit a relative reference from a file to itself.\n    if (destPath === originPath) {\n      return null;\n    }\n\n    const name = findExportedNameOfNode(ref.node, destSf, this.reflector);\n    if (name === null) {\n      // The target declaration isn't exported from the file it's declared in. This is an issue!\n      return null;\n    }\n\n    // With both files expressed as LogicalProjectPaths, getting the module specifier as a relative\n    // path is now straightforward.\n    const moduleName = LogicalProjectPath.relativePathBetween(originPath, destPath);\n    return new ExternalExpr({moduleName, name});\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which constructs relatives paths between `ts.SourceFile`s.\n *\n * This strategy can be used if there is no `rootDir`/`rootDirs` structure for the project which\n * necessitates the stronger logic of `LogicalProjectStrategy`.\n */\nexport class RelativePathStrategy implements ReferenceEmitStrategy {\n  constructor(private reflector: ReflectionHost) {}\n\n  emit(ref: Reference<ts.Node>, context: ts.SourceFile): Expression|null {\n    const destSf = getSourceFile(ref.node);\n    const relativePath =\n        relative(dirname(absoluteFromSourceFile(context)), absoluteFromSourceFile(destSf));\n    const moduleName = toRelativeImport(stripExtension(relativePath));\n\n    const name = findExportedNameOfNode(ref.node, destSf, this.reflector);\n    return new ExternalExpr({moduleName, name});\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which uses a `UnifiedModulesHost` to generate absolute import\n * references.\n */\nexport class UnifiedModulesStrategy implements ReferenceEmitStrategy {\n  constructor(private reflector: ReflectionHost, private unifiedModulesHost: UnifiedModulesHost) {}\n\n  emit(ref: Reference<ts.Node>, context: ts.SourceFile): Expression|null {\n    const destSf = getSourceFile(ref.node);\n    const name = findExportedNameOfNode(ref.node, destSf, this.reflector);\n    if (name === null) {\n      return null;\n    }\n\n    const moduleName =\n        this.unifiedModulesHost.fileNameToModuleName(destSf.fileName, context.fileName);\n\n    return new ExternalExpr({moduleName, name});\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"emitter.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/imports/src/emitter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {Expression, ExternalExpr, ExternalReference, WrappedNodeExpr} from '@angular/compiler';\nimport * as ts from 'typescript';\n\nimport {UnifiedModulesHost} from '../../core/api';\nimport {absoluteFromSourceFile, dirname, LogicalFileSystem, LogicalProjectPath, relative, toRelativeImport} from '../../file_system';\nimport {stripExtension} from '../../file_system/src/util';\nimport {DeclarationNode, ReflectionHost} from '../../reflection';\nimport {getSourceFile, isDeclaration, isTypeDeclaration, nodeNameForError} from '../../util/src/typescript';\n\nimport {findExportedNameOfNode} from './find_export';\nimport {Reference} from './references';\nimport {ModuleResolver} from './resolver';\n\n\n/**\n * Flags which alter the imports generated by the `ReferenceEmitter`.\n */\nexport enum ImportFlags {\n  None = 0x00,\n\n  /**\n   * Force the generation of a new import when generating a reference, even if an identifier already\n   * exists in the target file which could be used instead.\n   *\n   * This is sometimes required if there's a risk TypeScript might remove imports during emit.\n   */\n  ForceNewImport = 0x01,\n\n  /**\n   * Don't make use of any aliasing information when emitting a reference.\n   *\n   * This is sometimes required if emitting into a context where generated references will be fed\n   * into TypeScript and type-checked (such as in template type-checking).\n   */\n  NoAliasing = 0x02,\n\n  /**\n   * Indicates that an import to a type-only declaration is allowed.\n   *\n   * For references that occur in type-positions, the referred declaration may be a type-only\n   * declaration that is not retained during emit. Including this flag allows to emit references to\n   * type-only declarations as used in e.g. template type-checking.\n   */\n  AllowTypeImports = 0x04,\n}\n\n/**\n * An emitter strategy has the ability to indicate which `ts.SourceFile` is being imported by the\n * expression that it has generated. This information is useful for consumers of the emitted\n * reference that would otherwise have to perform a relatively expensive module resolution step,\n * e.g. for cyclic import analysis. In cases the emitter is unable to definitively determine the\n * imported source file or a computation would be required to actually determine the imported\n * source file, then `'unknown'` should be returned. If the generated expression does not represent\n * an import then `null` should be used.\n */\nexport type ImportedFile = ts.SourceFile|'unknown'|null;\n\n/**\n * Represents the emitted expression of a `Reference` that is valid in the source file it was\n * emitted from.\n */\nexport interface EmittedReference {\n  /**\n   * The expression that refers to `Reference`.\n   */\n  expression: Expression;\n\n  /**\n   * The `ts.SourceFile` that is imported by `expression`. This is not necessarily the source file\n   * of the `Reference`'s declaration node, as the reference may have been rewritten through an\n   * alias export. It could also be `null` if `expression` is a local identifier, or `'unknown'` if\n   * the exact source file that is being imported is not known to the emitter.\n   */\n  importedFile: ImportedFile;\n}\n\n/**\n * A particular strategy for generating an expression which refers to a `Reference`.\n *\n * There are many potential ways a given `Reference` could be referred to in the context of a given\n * file. A local declaration could be available, the `Reference` could be importable via a relative\n * import within the project, or an absolute import into `node_modules` might be necessary.\n *\n * Different `ReferenceEmitStrategy` implementations implement specific logic for generating such\n * references. A single strategy (such as using a local declaration) may not always be able to\n * generate an expression for every `Reference` (for example, if no local identifier is available),\n * and may return `null` in such a case.\n */\nexport interface ReferenceEmitStrategy {\n  /**\n   * Emit an `Expression` which refers to the given `Reference` in the context of a particular\n   * source file, if possible.\n   *\n   * @param ref the `Reference` for which to generate an expression\n   * @param context the source file in which the `Expression` must be valid\n   * @param importFlags a flag which controls whether imports should be generated or not\n   * @returns an `EmittedReference` which refers to the `Reference`, or `null` if none can be\n   *   generated\n   */\n  emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags): EmittedReference|null;\n}\n\n/**\n * Generates `Expression`s which refer to `Reference`s in a given context.\n *\n * A `ReferenceEmitter` uses one or more `ReferenceEmitStrategy` implementations to produce an\n * `Expression` which refers to a `Reference` in the context of a particular file.\n */\nexport class ReferenceEmitter {\n  constructor(private strategies: ReferenceEmitStrategy[]) {}\n\n  emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags = ImportFlags.None):\n      EmittedReference {\n    for (const strategy of this.strategies) {\n      const emitted = strategy.emit(ref, context, importFlags);\n      if (emitted !== null) {\n        return emitted;\n      }\n    }\n    throw new Error(`Unable to write a reference to ${nodeNameForError(ref.node)} in ${\n        ref.node.getSourceFile().fileName} from ${context.fileName}`);\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which will refer to declarations by any local `ts.Identifier`s, if\n * such identifiers are available.\n */\nexport class LocalIdentifierStrategy implements ReferenceEmitStrategy {\n  emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags): EmittedReference|null {\n    const refSf = getSourceFile(ref.node);\n\n    // If the emitter has specified ForceNewImport, then LocalIdentifierStrategy should not use a\n    // local identifier at all, *except* in the source file where the node is actually declared.\n    if (importFlags & ImportFlags.ForceNewImport && refSf !== context) {\n      return null;\n    }\n\n    // If referenced node is not an actual TS declaration (e.g. `class Foo` or `function foo() {}`,\n    // etc) and it is in the current file then just use it directly.\n    // This is important because the reference could be a property access (e.g. `exports.foo`). In\n    // such a case, the reference's `identities` property would be `[foo]`, which would result in an\n    // invalid emission of a free-standing `foo` identifier, rather than `exports.foo`.\n    if (!isDeclaration(ref.node) && refSf === context) {\n      return {\n        expression: new WrappedNodeExpr(ref.node),\n        importedFile: null,\n      };\n    }\n\n    // A Reference can have multiple identities in different files, so it may already have an\n    // Identifier in the requested context file.\n    const identifier = ref.getIdentityIn(context);\n    if (identifier !== null) {\n      return {\n        expression: new WrappedNodeExpr(identifier),\n        importedFile: null,\n      };\n    } else {\n      return null;\n    }\n  }\n}\n\n/**\n * Represents the exported declarations from a module source file.\n */\ninterface ModuleExports {\n  /**\n   * The source file of the module.\n   */\n  module: ts.SourceFile;\n\n  /**\n   * The map of declarations to their exported name.\n   */\n  exportMap: Map<DeclarationNode, string>;\n}\n\n/**\n * A `ReferenceEmitStrategy` which will refer to declarations that come from `node_modules` using\n * an absolute import.\n *\n * Part of this strategy involves looking at the target entry point and identifying the exported\n * name of the targeted declaration, as it might be different from the declared name (e.g. a\n * directive might be declared as FooDirImpl, but exported as FooDir). If no export can be found\n * which maps back to the original directive, an error is thrown.\n */\nexport class AbsoluteModuleStrategy implements ReferenceEmitStrategy {\n  /**\n   * A cache of the exports of specific modules, because resolving a module to its exports is a\n   * costly operation.\n   */\n  private moduleExportsCache = new Map<string, ModuleExports|null>();\n\n  constructor(\n      protected program: ts.Program, protected checker: ts.TypeChecker,\n      protected moduleResolver: ModuleResolver, private reflectionHost: ReflectionHost) {}\n\n  emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags): EmittedReference|null {\n    if (ref.bestGuessOwningModule === null) {\n      // There is no module name available for this Reference, meaning it was arrived at via a\n      // relative path.\n      return null;\n    } else if (!isDeclaration(ref.node)) {\n      // It's not possible to import something which isn't a declaration.\n      throw new Error(`Debug assert: unable to import a Reference to non-declaration of type ${\n          ts.SyntaxKind[ref.node.kind]}.`);\n    } else if ((importFlags & ImportFlags.AllowTypeImports) === 0 && isTypeDeclaration(ref.node)) {\n      throw new Error(`Importing a type-only declaration of type ${\n          ts.SyntaxKind[ref.node.kind]} in a value position is not allowed.`);\n    }\n\n    // Try to find the exported name of the declaration, if one is available.\n    const {specifier, resolutionContext} = ref.bestGuessOwningModule;\n    const exports = this.getExportsOfModule(specifier, resolutionContext);\n    if (exports === null || !exports.exportMap.has(ref.node)) {\n      // TODO(alxhub): make this error a ts.Diagnostic pointing at whatever caused this import to be\n      // triggered.\n      throw new Error(`Symbol ${ref.debugName} declared in ${\n          getSourceFile(ref.node).fileName} is not exported from ${specifier} (import into ${\n          context.fileName})`);\n    }\n    const symbolName = exports.exportMap.get(ref.node)!;\n\n    return {\n      expression: new ExternalExpr(new ExternalReference(specifier, symbolName)),\n      importedFile: exports.module,\n    };\n  }\n\n  private getExportsOfModule(moduleName: string, fromFile: string): ModuleExports|null {\n    if (!this.moduleExportsCache.has(moduleName)) {\n      this.moduleExportsCache.set(moduleName, this.enumerateExportsOfModule(moduleName, fromFile));\n    }\n    return this.moduleExportsCache.get(moduleName)!;\n  }\n\n  protected enumerateExportsOfModule(specifier: string, fromFile: string): ModuleExports|null {\n    // First, resolve the module specifier to its entry point, and get the ts.Symbol for it.\n    const entryPointFile = this.moduleResolver.resolveModule(specifier, fromFile);\n    if (entryPointFile === null) {\n      return null;\n    }\n\n    const exports = this.reflectionHost.getExportsOfModule(entryPointFile);\n    if (exports === null) {\n      return null;\n    }\n    const exportMap = new Map<DeclarationNode, string>();\n    exports.forEach((declaration, name) => {\n      exportMap.set(declaration.node, name);\n    });\n    return {module: entryPointFile, exportMap};\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which will refer to declarations via relative paths, provided they're\n * both in the logical project \"space\" of paths.\n *\n * This is trickier than it sounds, as the two files may be in different root directories in the\n * project. Simply calculating a file system relative path between the two is not sufficient.\n * Instead, `LogicalProjectPath`s are used.\n */\nexport class LogicalProjectStrategy implements ReferenceEmitStrategy {\n  constructor(private reflector: ReflectionHost, private logicalFs: LogicalFileSystem) {}\n\n  emit(ref: Reference, context: ts.SourceFile): EmittedReference|null {\n    const destSf = getSourceFile(ref.node);\n\n    // Compute the relative path from the importing file to the file being imported. This is done\n    // as a logical path computation, because the two files might be in different rootDirs.\n    const destPath = this.logicalFs.logicalPathOfSf(destSf);\n    if (destPath === null) {\n      // The imported file is not within the logical project filesystem.\n      return null;\n    }\n\n    const originPath = this.logicalFs.logicalPathOfSf(context);\n    if (originPath === null) {\n      throw new Error(\n          `Debug assert: attempt to import from ${context.fileName} but it's outside the program?`);\n    }\n\n    // There's no way to emit a relative reference from a file to itself.\n    if (destPath === originPath) {\n      return null;\n    }\n\n    const name = findExportedNameOfNode(ref.node, destSf, this.reflector);\n    if (name === null) {\n      // The target declaration isn't exported from the file it's declared in. This is an issue!\n      return null;\n    }\n\n    // With both files expressed as LogicalProjectPaths, getting the module specifier as a relative\n    // path is now straightforward.\n    const moduleName = LogicalProjectPath.relativePathBetween(originPath, destPath);\n    return {\n      expression: new ExternalExpr({moduleName, name}),\n      importedFile: destSf,\n    };\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which constructs relatives paths between `ts.SourceFile`s.\n *\n * This strategy can be used if there is no `rootDir`/`rootDirs` structure for the project which\n * necessitates the stronger logic of `LogicalProjectStrategy`.\n */\nexport class RelativePathStrategy implements ReferenceEmitStrategy {\n  constructor(private reflector: ReflectionHost) {}\n\n  emit(ref: Reference, context: ts.SourceFile): EmittedReference|null {\n    const destSf = getSourceFile(ref.node);\n    const relativePath =\n        relative(dirname(absoluteFromSourceFile(context)), absoluteFromSourceFile(destSf));\n    const moduleName = toRelativeImport(stripExtension(relativePath));\n\n    const name = findExportedNameOfNode(ref.node, destSf, this.reflector);\n    return {expression: new ExternalExpr({moduleName, name}), importedFile: destSf};\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which uses a `UnifiedModulesHost` to generate absolute import\n * references.\n */\nexport class UnifiedModulesStrategy implements ReferenceEmitStrategy {\n  constructor(private reflector: ReflectionHost, private unifiedModulesHost: UnifiedModulesHost) {}\n\n  emit(ref: Reference, context: ts.SourceFile): EmittedReference|null {\n    const destSf = getSourceFile(ref.node);\n    const name = findExportedNameOfNode(ref.node, destSf, this.reflector);\n    if (name === null) {\n      return null;\n    }\n\n    const moduleName =\n        this.unifiedModulesHost.fileNameToModuleName(destSf.fileName, context.fileName);\n\n    return {\n      expression: new ExternalExpr({moduleName, name}),\n      importedFile: destSf,\n    };\n  }\n}\n"]}

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

@@ -45,20 +45,6 @@ export interface DependencyTracker<T extends {
      * 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;
     /**
      * Record that the given file contains unresolvable dependencies.
      *

package/src/ngtsc/incremental/api.js

@@ -17,4 +17,4 @@
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,12 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/incremental/semantic_graph" />
+export { SemanticReference, SemanticSymbol } from './src/api';
+export { SemanticDepGraph, SemanticDepGraphUpdater } from './src/graph';
+export { areTypeParametersEqual, extractSemanticTypeParameters, SemanticTypeParameter } from './src/type_parameters';
+export { isArrayEqual, isReferenceEqual, isSetEqual, isSymbolEqual } from './src/util';

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

@@ -0,0 +1,34 @@
+/**
+ * @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", ["require", "exports", "@angular/compiler-cli/src/ngtsc/incremental/semantic_graph/src/api", "@angular/compiler-cli/src/ngtsc/incremental/semantic_graph/src/graph", "@angular/compiler-cli/src/ngtsc/incremental/semantic_graph/src/type_parameters", "@angular/compiler-cli/src/ngtsc/incremental/semantic_graph/src/util"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isSymbolEqual = exports.isSetEqual = exports.isReferenceEqual = exports.isArrayEqual = exports.extractSemanticTypeParameters = exports.areTypeParametersEqual = exports.SemanticDepGraphUpdater = exports.SemanticDepGraph = exports.SemanticSymbol = void 0;
+    var api_1 = require("@angular/compiler-cli/src/ngtsc/incremental/semantic_graph/src/api");
+    Object.defineProperty(exports, "SemanticSymbol", { enumerable: true, get: function () { return api_1.SemanticSymbol; } });
+    var graph_1 = require("@angular/compiler-cli/src/ngtsc/incremental/semantic_graph/src/graph");
+    Object.defineProperty(exports, "SemanticDepGraph", { enumerable: true, get: function () { return graph_1.SemanticDepGraph; } });
+    Object.defineProperty(exports, "SemanticDepGraphUpdater", { enumerable: true, get: function () { return graph_1.SemanticDepGraphUpdater; } });
+    var type_parameters_1 = require("@angular/compiler-cli/src/ngtsc/incremental/semantic_graph/src/type_parameters");
+    Object.defineProperty(exports, "areTypeParametersEqual", { enumerable: true, get: function () { return type_parameters_1.areTypeParametersEqual; } });
+    Object.defineProperty(exports, "extractSemanticTypeParameters", { enumerable: true, get: function () { return type_parameters_1.extractSemanticTypeParameters; } });
+    var util_1 = require("@angular/compiler-cli/src/ngtsc/incremental/semantic_graph/src/util");
+    Object.defineProperty(exports, "isArrayEqual", { enumerable: true, get: function () { return util_1.isArrayEqual; } });
+    Object.defineProperty(exports, "isReferenceEqual", { enumerable: true, get: function () { return util_1.isReferenceEqual; } });
+    Object.defineProperty(exports, "isSetEqual", { enumerable: true, get: function () { return util_1.isSetEqual; } });
+    Object.defineProperty(exports, "isSymbolEqual", { enumerable: true, get: function () { return util_1.isSymbolEqual; } });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvc3JjL25ndHNjL2luY3JlbWVudGFsL3NlbWFudGljX2dyYXBoL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7Ozs7OztJQUVILDBGQUE0RDtJQUFqQyxxR0FBQSxjQUFjLE9BQUE7SUFDekMsOEZBQXNFO0lBQTlELHlHQUFBLGdCQUFnQixPQUFBO0lBQUUsZ0hBQUEsdUJBQXVCLE9BQUE7SUFDakQsa0hBQW1IO0lBQTNHLHlIQUFBLHNCQUFzQixPQUFBO0lBQUUsZ0lBQUEsNkJBQTZCLE9BQUE7SUFDN0QsNEZBQXFGO0lBQTdFLG9HQUFBLFlBQVksT0FBQTtJQUFFLHdHQUFBLGdCQUFnQixPQUFBO0lBQUUsa0dBQUEsVUFBVSxPQUFBO0lBQUUscUdBQUEsYUFBYSxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCB7U2VtYW50aWNSZWZlcmVuY2UsIFNlbWFudGljU3ltYm9sfSBmcm9tICcuL3NyYy9hcGknO1xuZXhwb3J0IHtTZW1hbnRpY0RlcEdyYXBoLCBTZW1hbnRpY0RlcEdyYXBoVXBkYXRlcn0gZnJvbSAnLi9zcmMvZ3JhcGgnO1xuZXhwb3J0IHthcmVUeXBlUGFyYW1ldGVyc0VxdWFsLCBleHRyYWN0U2VtYW50aWNUeXBlUGFyYW1ldGVycywgU2VtYW50aWNUeXBlUGFyYW1ldGVyfSBmcm9tICcuL3NyYy90eXBlX3BhcmFtZXRlcnMnO1xuZXhwb3J0IHtpc0FycmF5RXF1YWwsIGlzUmVmZXJlbmNlRXF1YWwsIGlzU2V0RXF1YWwsIGlzU3ltYm9sRXF1YWx9IGZyb20gJy4vc3JjL3V0aWwnO1xuIl19

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

@@ -0,0 +1,98 @@
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/incremental/semantic_graph/src/api" />
+import { AbsoluteFsPath } from '../../../file_system';
+import { ClassDeclaration } from '../../../reflection';
+/**
+ * Represents a symbol that is recognizable across incremental rebuilds, which enables the captured
+ * metadata to be compared to the prior compilation. This allows for semantic understanding of
+ * the changes that have been made in a rebuild, which potentially enables more reuse of work
+ * from the prior compilation.
+ */
+export declare abstract class SemanticSymbol {
+    /**
+     * The declaration for this symbol.
+     */
+    readonly decl: ClassDeclaration;
+    /**
+     * The path of the file that declares this symbol.
+     */
+    readonly path: AbsoluteFsPath;
+    /**
+     * The identifier of this symbol, or null if no identifier could be determined. It should
+     * uniquely identify the symbol relative to `file`. This is typically just the name of a
+     * top-level class declaration, as that uniquely identifies the class within the file.
+     *
+     * If the identifier is null, then this symbol cannot be recognized across rebuilds. In that
+     * case, the symbol is always assumed to have semantically changed to guarantee a proper
+     * rebuild.
+     */
+    readonly identifier: string | null;
+    constructor(
+    /**
+     * The declaration for this symbol.
+     */
+    decl: ClassDeclaration);
+    /**
+     * Allows the symbol to be compared to the equivalent symbol in the previous compilation. The
+     * return value indicates whether the symbol has been changed in a way such that its public API
+     * is affected.
+     *
+     * This method determines whether a change to _this_ symbol require the symbols that
+     * use to this symbol to be re-emitted.
+     *
+     * Note: `previousSymbol` is obtained from the most recently succeeded compilation. Symbols of
+     * failed compilations are never provided.
+     *
+     * @param previousSymbol The symbol from a prior compilation.
+     */
+    abstract isPublicApiAffected(previousSymbol: SemanticSymbol): boolean;
+    /**
+     * Allows the symbol to determine whether its emit is affected. The equivalent symbol from a prior
+     * build is given, in addition to the set of symbols of which the public API has changed.
+     *
+     * This method determines whether a change to _other_ symbols, i.e. those present in
+     * `publicApiAffected`, should cause _this_ symbol to be re-emitted.
+     *
+     * @param previousSymbol The equivalent symbol from a prior compilation. Note that it may be a
+     * different type of symbol, if e.g. a Component was changed into a Directive with the same name.
+     * @param publicApiAffected The set of symbols of which the public API has changed.
+     */
+    isEmitAffected?(previousSymbol: SemanticSymbol, publicApiAffected: Set<SemanticSymbol>): boolean;
+    /**
+     * Similar to `isPublicApiAffected`, but here equivalent symbol from a prior compilation needs
+     * to be compared to see if the type-check block of components that use this symbol is affected.
+     *
+     * This method determines whether a change to _this_ symbol require the symbols that
+     * use to this symbol to have their type-check block regenerated.
+     *
+     * Note: `previousSymbol` is obtained from the most recently succeeded compilation. Symbols of
+     * failed compilations are never provided.
+     *
+     * @param previousSymbol The symbol from a prior compilation.
+     */
+    abstract isTypeCheckApiAffected(previousSymbol: SemanticSymbol): boolean;
+    /**
+     * Similar to `isEmitAffected`, but focused on the type-check block of this symbol. This method
+     * determines whether a change to _other_ symbols, i.e. those present in `typeCheckApiAffected`,
+     * should cause _this_ symbol's type-check block to be regenerated.
+     *
+     * @param previousSymbol The equivalent symbol from a prior compilation. Note that it may be a
+     * different type of symbol, if e.g. a Component was changed into a Directive with the same name.
+     * @param typeCheckApiAffected The set of symbols of which the type-check API has changed.
+     */
+    isTypeCheckBlockAffected?(previousSymbol: SemanticSymbol, typeCheckApiAffected: Set<SemanticSymbol>): boolean;
+}
+/**
+ * Represents a reference to a semantic symbol that has been emitted into a source file. The
+ * reference may refer to the symbol using a different name than the semantic symbol's declared
+ * name, e.g. in case a re-export under a different name was chosen by a reference emitter.
+ * Consequently, to know that an emitted reference is still valid not only requires that the
+ * semantic symbol is still valid, but also that the path by which the symbol is imported has not
+ * changed.
+ */
+export interface SemanticReference {
+    symbol: SemanticSymbol;
+    /**
+     * The path by which the symbol has been referenced.
+     */
+    importPath: string | null;
+}

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

@@ -0,0 +1,51 @@
+(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/api", ["require", "exports", "typescript", "@angular/compiler-cli/src/ngtsc/file_system"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SemanticSymbol = 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 file_system_1 = require("@angular/compiler-cli/src/ngtsc/file_system");
+    /**
+     * Represents a symbol that is recognizable across incremental rebuilds, which enables the captured
+     * metadata to be compared to the prior compilation. This allows for semantic understanding of
+     * the changes that have been made in a rebuild, which potentially enables more reuse of work
+     * from the prior compilation.
+     */
+    var SemanticSymbol = /** @class */ (function () {
+        function SemanticSymbol(
+        /**
+         * The declaration for this symbol.
+         */
+        decl) {
+            this.decl = decl;
+            this.path = file_system_1.absoluteFromSourceFile(decl.getSourceFile());
+            this.identifier = getSymbolIdentifier(decl);
+        }
+        return SemanticSymbol;
+    }());
+    exports.SemanticSymbol = SemanticSymbol;
+    function getSymbolIdentifier(decl) {
+        if (!ts.isSourceFile(decl.parent)) {
+            return null;
+        }
+        // If this is a top-level class declaration, the class name is used as unique identifier.
+        // Other scenarios are currently not supported and causes the symbol not to be identified
+        // across rebuilds, unless the declaration node has not changed.
+        return decl.name.text;
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler-cli/src/ngtsc/incremental/semantic_graph/src/api.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA;;;;;;OAMG;IACH,+BAAiC;IAEjC,2EAA4E;IAG5E;;;;;OAKG;IACH;QAiBE;QACI;;WAEG;QACa,IAAsB;YAAtB,SAAI,GAAJ,IAAI,CAAkB;YAExC,IAAI,CAAC,IAAI,GAAG,oCAAsB,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;YACzD,IAAI,CAAC,UAAU,GAAG,mBAAmB,CAAC,IAAI,CAAC,CAAC;QAC9C,CAAC;QAuDH,qBAAC;IAAD,CAAC,AAhFD,IAgFC;IAhFqB,wCAAc;IAmGpC,SAAS,mBAAmB,CAAC,IAAsB;QACjD,IAAI,CAAC,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;YACjC,OAAO,IAAI,CAAC;SACb;QAED,yFAAyF;QACzF,yFAAyF;QACzF,gEAAgE;QAChE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;IACxB,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 */\nimport * as ts from 'typescript';\n\nimport {absoluteFromSourceFile, AbsoluteFsPath} from '../../../file_system';\nimport {ClassDeclaration} from '../../../reflection';\n\n/**\n * Represents a symbol that is recognizable across incremental rebuilds, which enables the captured\n * metadata to be compared to the prior compilation. This allows for semantic understanding of\n * the changes that have been made in a rebuild, which potentially enables more reuse of work\n * from the prior compilation.\n */\nexport abstract class SemanticSymbol {\n  /**\n   * The path of the file that declares this symbol.\n   */\n  public readonly path: AbsoluteFsPath;\n\n  /**\n   * The identifier of this symbol, or null if no identifier could be determined. It should\n   * uniquely identify the symbol relative to `file`. This is typically just the name of a\n   * top-level class declaration, as that uniquely identifies the class within the file.\n   *\n   * If the identifier is null, then this symbol cannot be recognized across rebuilds. In that\n   * case, the symbol is always assumed to have semantically changed to guarantee a proper\n   * rebuild.\n   */\n  public readonly identifier: string|null;\n\n  constructor(\n      /**\n       * The declaration for this symbol.\n       */\n      public readonly decl: ClassDeclaration,\n  ) {\n    this.path = absoluteFromSourceFile(decl.getSourceFile());\n    this.identifier = getSymbolIdentifier(decl);\n  }\n\n  /**\n   * Allows the symbol to be compared to the equivalent symbol in the previous compilation. The\n   * return value indicates whether the symbol has been changed in a way such that its public API\n   * is affected.\n   *\n   * This method determines whether a change to _this_ symbol require the symbols that\n   * use to this symbol to be re-emitted.\n   *\n   * Note: `previousSymbol` is obtained from the most recently succeeded compilation. Symbols of\n   * failed compilations are never provided.\n   *\n   * @param previousSymbol The symbol from a prior compilation.\n   */\n  abstract isPublicApiAffected(previousSymbol: SemanticSymbol): boolean;\n\n  /**\n   * Allows the symbol to determine whether its emit is affected. The equivalent symbol from a prior\n   * build is given, in addition to the set of symbols of which the public API has changed.\n   *\n   * This method determines whether a change to _other_ symbols, i.e. those present in\n   * `publicApiAffected`, should cause _this_ symbol to be re-emitted.\n   *\n   * @param previousSymbol The equivalent symbol from a prior compilation. Note that it may be a\n   * different type of symbol, if e.g. a Component was changed into a Directive with the same name.\n   * @param publicApiAffected The set of symbols of which the public API has changed.\n   */\n  isEmitAffected?(previousSymbol: SemanticSymbol, publicApiAffected: Set<SemanticSymbol>): boolean;\n\n  /**\n   * Similar to `isPublicApiAffected`, but here equivalent symbol from a prior compilation needs\n   * to be compared to see if the type-check block of components that use this symbol is affected.\n   *\n   * This method determines whether a change to _this_ symbol require the symbols that\n   * use to this symbol to have their type-check block regenerated.\n   *\n   * Note: `previousSymbol` is obtained from the most recently succeeded compilation. Symbols of\n   * failed compilations are never provided.\n   *\n   * @param previousSymbol The symbol from a prior compilation.\n   */\n  abstract isTypeCheckApiAffected(previousSymbol: SemanticSymbol): boolean;\n\n  /**\n   * Similar to `isEmitAffected`, but focused on the type-check block of this symbol. This method\n   * determines whether a change to _other_ symbols, i.e. those present in `typeCheckApiAffected`,\n   * should cause _this_ symbol's type-check block to be regenerated.\n   *\n   * @param previousSymbol The equivalent symbol from a prior compilation. Note that it may be a\n   * different type of symbol, if e.g. a Component was changed into a Directive with the same name.\n   * @param typeCheckApiAffected The set of symbols of which the type-check API has changed.\n   */\n  isTypeCheckBlockAffected?\n      (previousSymbol: SemanticSymbol, typeCheckApiAffected: Set<SemanticSymbol>): boolean;\n}\n\n/**\n * Represents a reference to a semantic symbol that has been emitted into a source file. The\n * reference may refer to the symbol using a different name than the semantic symbol's declared\n * name, e.g. in case a re-export under a different name was chosen by a reference emitter.\n * Consequently, to know that an emitted reference is still valid not only requires that the\n * semantic symbol is still valid, but also that the path by which the symbol is imported has not\n * changed.\n */\nexport interface SemanticReference {\n  symbol: SemanticSymbol;\n\n  /**\n   * The path by which the symbol has been referenced.\n   */\n  importPath: string|null;\n}\n\nfunction getSymbolIdentifier(decl: ClassDeclaration): string|null {\n  if (!ts.isSourceFile(decl.parent)) {\n    return null;\n  }\n\n  // If this is a top-level class declaration, the class name is used as unique identifier.\n  // Other scenarios are currently not supported and causes the symbol not to be identified\n  // across rebuilds, unless the declaration node has not changed.\n  return decl.name.text;\n}\n"]}