@angular/language-service 11.2.7 → 11.2.11

package/bundles/ivy.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v11.2.7
+ * @license Angular v11.2.11
  * Copyright Google LLC All Rights Reserved.
  * License: MIT
  */
@@ -6697,6 +6697,21 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * 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
      */
+    /**
+     * This is an R3 `Node`-like wrapper for a raw `html.Comment` node. We do not currently
+     * require the implementation of a visitor for Comments as they are only collected at
+     * the top-level of the R3 AST, and only if `Render3ParseOptions['collectCommentNodes']`
+     * is true.
+     */
+    class Comment {
+        constructor(value, sourceSpan) {
+            this.value = value;
+            this.sourceSpan = sourceSpan;
+        }
+        visit(_visitor) {
+            throw new Error('visit() not implemented for Comment');
+        }
+    }
     class Text {
         constructor(value, sourceSpan) {
             this.value = value;
@@ -11518,7 +11533,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return visitor.visitElement(this, context);
         }
     }
-    class Comment {
+    class Comment$1 {
         constructor(value, sourceSpan) {
             this.value = value;
             this.sourceSpan = sourceSpan;
@@ -12548,7 +12563,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             const text = this._advanceIf(TokenType.RAW_TEXT);
             this._advanceIf(TokenType.COMMENT_END);
             const value = text != null ? text.parts[0].trim() : null;
-            this._addToParent(new Comment(value, token.sourceSpan));
+            this._addToParent(new Comment$1(value, token.sourceSpan));
         }
         _consumeExpansion(token) {
             const switchValue = this._advance();
@@ -13756,7 +13771,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             if (isEmptyExpression(value)) {
                 return null;
             }
-            name = normalizePropName(name);
+            // CSS custom properties are case-sensitive so we shouldn't normalize them.
+            // See: https://www.w3.org/TR/css-variables-1/#defining-variables
+            if (!isCssCustomProperty(name)) {
+                name = hyphenate(name);
+            }
             const { property, hasOverrideFlag, suffix: bindingSuffix } = parseProperty(name);
             suffix = typeof suffix === 'string' && suffix.length !== 0 ? suffix : bindingSuffix;
             const entry = { name: property, suffix: suffix, value, sourceSpan, hasOverrideFlag };
@@ -14101,8 +14120,12 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 return Identifiers$1.stylePropInterpolateV;
         }
     }
-    function normalizePropName(prop) {
-        return hyphenate(prop);
+    /**
+     * Checks whether property name is a custom CSS property.
+     * See: https://www.w3.org/TR/css-variables-1
+     */
+    function isCssCustomProperty(name) {
+        return name.startsWith('--');
     }
 
     /**
@@ -16220,26 +16243,33 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         EVENT: { start: '(', end: ')' },
     };
     const TEMPLATE_ATTR_PREFIX$1 = '*';
-    function htmlAstToRender3Ast(htmlNodes, bindingParser) {
-        const transformer = new HtmlAstToIvyAst(bindingParser);
+    function htmlAstToRender3Ast(htmlNodes, bindingParser, options) {
+        const transformer = new HtmlAstToIvyAst(bindingParser, options);
         const ivyNodes = visitAll$1(transformer, htmlNodes);
         // Errors might originate in either the binding parser or the html to ivy transformer
         const allErrors = bindingParser.errors.concat(transformer.errors);
-        return {
+        const result = {
             nodes: ivyNodes,
             errors: allErrors,
             styleUrls: transformer.styleUrls,
             styles: transformer.styles,
-            ngContentSelectors: transformer.ngContentSelectors,
+            ngContentSelectors: transformer.ngContentSelectors
         };
+        if (options.collectCommentNodes) {
+            result.commentNodes = transformer.commentNodes;
+        }
+        return result;
     }
     class HtmlAstToIvyAst {
-        constructor(bindingParser) {
+        constructor(bindingParser, options) {
             this.bindingParser = bindingParser;
+            this.options = options;
             this.errors = [];
             this.styles = [];
             this.styleUrls = [];
             this.ngContentSelectors = [];
+            // This array will be populated if `Render3ParseOptions['collectCommentNodes']` is true
+            this.commentNodes = [];
             this.inI18nBlock = false;
         }
         // HTML visitor
@@ -16408,6 +16438,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return null;
         }
         visitComment(comment) {
+            if (this.options.collectCommentNodes) {
+                this.commentNodes.push(new Comment(comment.value || '', comment.sourceSpan));
+            }
             return null;
         }
         // convert view engine `ParsedProperty` to a format suitable for IVY
@@ -16599,7 +16632,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         return node instanceof Text$2 && node.value.trim().length == 0;
     }
     function isCommentNode(node) {
-        return node instanceof Comment;
+        return node instanceof Comment$1;
     }
     function textContents(node) {
         if (node.children.length !== 1 || !(node.children[0] instanceof Text$2)) {
@@ -19176,7 +19209,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         const parseResult = htmlParser.parse(template, templateUrl, Object.assign(Object.assign({ leadingTriviaChars: LEADING_TRIVIA_CHARS }, options), { tokenizeExpansionForms: true }));
         if (!options.alwaysAttemptHtmlToR3AstConversion && parseResult.errors &&
             parseResult.errors.length > 0) {
-            return {
+            const parsedTemplate = {
                 interpolationConfig,
                 preserveWhitespaces,
                 template,
@@ -19188,6 +19221,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 styles: [],
                 ngContentSelectors: []
             };
+            if (options.collectCommentNodes) {
+                parsedTemplate.commentNodes = [];
+            }
+            return parsedTemplate;
         }
         let rootNodes = parseResult.rootNodes;
         // process i18n meta information (scan attributes, generate ids)
@@ -19198,7 +19235,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         const i18nMetaResult = i18nMetaVisitor.visitAllWithErrors(rootNodes);
         if (!options.alwaysAttemptHtmlToR3AstConversion && i18nMetaResult.errors &&
             i18nMetaResult.errors.length > 0) {
-            return {
+            const parsedTemplate = {
                 interpolationConfig,
                 preserveWhitespaces,
                 template,
@@ -19210,6 +19247,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 styles: [],
                 ngContentSelectors: []
             };
+            if (options.collectCommentNodes) {
+                parsedTemplate.commentNodes = [];
+            }
+            return parsedTemplate;
         }
         rootNodes = i18nMetaResult.rootNodes;
         if (!preserveWhitespaces) {
@@ -19222,9 +19263,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 rootNodes = visitAll$1(new I18nMetaVisitor(interpolationConfig, /* keepI18nAttrs */ false), rootNodes);
             }
         }
-        const { nodes, errors, styleUrls, styles, ngContentSelectors } = htmlAstToRender3Ast(rootNodes, bindingParser);
+        const { nodes, errors, styleUrls, styles, ngContentSelectors, commentNodes } = htmlAstToRender3Ast(rootNodes, bindingParser, { collectCommentNodes: !!options.collectCommentNodes });
         errors.push(...parseResult.errors, ...i18nMetaResult.errors);
-        return {
+        const parsedTemplate = {
             interpolationConfig,
             preserveWhitespaces,
             errors: errors.length > 0 ? errors : null,
@@ -19236,6 +19277,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             styles,
             ngContentSelectors
         };
+        if (options.collectCommentNodes) {
+            parsedTemplate.commentNodes = commentNodes;
+        }
+        return parsedTemplate;
     }
     const elementRegistry = new DomElementSchemaRegistry();
     /**
@@ -20354,7 +20399,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * 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
      */
-    const VERSION$1 = new Version('11.2.7');
+    const VERSION$1 = new Version('11.2.11');
 
     /**
      * @license
@@ -21011,7 +21056,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      */
     function createDirectiveDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
-        definitionMap.set('version', literal('11.2.7'));
+        definitionMap.set('version', literal('11.2.11'));
         // e.g. `type: MyDirective`
         definitionMap.set('type', meta.internalType);
         // e.g. `selector: 'some-dir'`
@@ -21232,7 +21277,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      */
     function createPipeDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
-        definitionMap.set('version', literal('11.2.7'));
+        definitionMap.set('version', literal('11.2.11'));
         definitionMap.set('ngImport', importExpr(Identifiers$1.core));
         // e.g. `type: MyPipe`
         definitionMap.set('type', meta.internalType);
@@ -21264,7 +21309,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * 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
      */
-    const VERSION$2 = new Version('11.2.7');
+    const VERSION$2 = new Version('11.2.11');
 
     /**
      * @license
@@ -21414,6 +21459,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
          * Raised when a directive/pipe is part of the declarations of two or more NgModules.
          */
         ErrorCode[ErrorCode["NGMODULE_DECLARATION_NOT_UNIQUE"] = 6007] = "NGMODULE_DECLARATION_NOT_UNIQUE";
+        /**
+         * Not actually raised by the compiler, but reserved for documentation of a View Engine error when
+         * a View Engine build depends on an Ivy-compiled NgModule.
+         */
+        ErrorCode[ErrorCode["NGMODULE_VE_DEPENDENCY_ON_IVY_LIB"] = 6999] = "NGMODULE_VE_DEPENDENCY_ON_IVY_LIB";
         /**
          * An element name failed validation against the DOM schema.
          */
@@ -21659,6 +21709,16 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function isAssignment(node) {
         return ts$1.isBinaryExpression(node) && node.operatorToken.kind === ts$1.SyntaxKind.EqualsToken;
     }
+    /**
+     * Obtains the non-redirected source file for `sf`.
+     */
+    function toUnredirectedSourceFile(sf) {
+        const redirectInfo = sf.redirectInfo;
+        if (redirectInfo === undefined) {
+            return sf;
+        }
+        return redirectInfo.unredirected;
+    }
 
     /**
      * @license
@@ -22167,6 +22227,22 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * 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
      */
+    const DefaultImportDeclaration = Symbol('DefaultImportDeclaration');
+    /**
+     * Attaches a default import declaration to `expr` to indicate the dependency of `expr` on the
+     * default import.
+     */
+    function attachDefaultImportDeclaration(expr, importDecl) {
+        expr[DefaultImportDeclaration] = importDecl;
+    }
+    /**
+     * Obtains the default import declaration that `expr` depends on, or `null` if there is no such
+     * dependency.
+     */
+    function getDefaultImportDeclaration(expr) {
+        var _a;
+        return (_a = expr[DefaultImportDeclaration]) !== null && _a !== void 0 ? _a : null;
+    }
     /**
      * TypeScript has trouble with generating default imports inside of transformers for some module
      * formats. The issue is that for the statement:
@@ -22199,47 +22275,25 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      */
     class DefaultImportTracker {
         constructor() {
-            /**
-             * A `Map` which tracks the `Map` of default import `ts.Identifier`s to their
-             * `ts.ImportDeclaration`s. These declarations are not guaranteed to be used.
-             */
-            this.sourceFileToImportMap = new Map();
             /**
              * A `Map` which tracks the `Set` of `ts.ImportDeclaration`s for default imports that were used in
              * a given `ts.SourceFile` and need to be preserved.
              */
             this.sourceFileToUsedImports = new Map();
         }
-        recordImportedIdentifier(id, decl) {
-            const sf = getSourceFile(id);
-            if (!this.sourceFileToImportMap.has(sf)) {
-                this.sourceFileToImportMap.set(sf, new Map());
-            }
-            this.sourceFileToImportMap.get(sf).set(id, decl);
-        }
-        recordUsedIdentifier(id) {
-            const sf = getSourceFile(id);
-            if (!this.sourceFileToImportMap.has(sf)) {
-                // The identifier's source file has no registered default imports at all.
-                return;
-            }
-            const identiferToDeclaration = this.sourceFileToImportMap.get(sf);
-            if (!identiferToDeclaration.has(id)) {
-                // The identifier isn't from a registered default import.
-                return;
-            }
-            const decl = identiferToDeclaration.get(id);
+        recordUsedImport(importDecl) {
+            const sf = getSourceFile(importDecl);
             // Add the default import declaration to the set of used import declarations for the file.
             if (!this.sourceFileToUsedImports.has(sf)) {
                 this.sourceFileToUsedImports.set(sf, new Set());
             }
-            this.sourceFileToUsedImports.get(sf).add(decl);
+            this.sourceFileToUsedImports.get(sf).add(importDecl);
         }
         /**
          * Get a `ts.TransformerFactory` which will preserve default imports that were previously marked
          * as used.
          *
-         * This transformer must run after any other transformers which call `recordUsedIdentifier`.
+         * This transformer must run after any other transformers which call `recordUsedImport`.
          */
         importPreservingTransformer() {
             return (context) => {
@@ -22294,7 +22348,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             });
             // Save memory - there's no need to keep these around once the transform has run for the given
             // file.
-            this.sourceFileToImportMap.delete(originalSf);
             this.sourceFileToUsedImports.delete(originalSf);
             return ts$1.updateSourceFileNode(sf, statements);
         }
@@ -25492,6 +25545,417 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
     }
 
+    /**
+     * @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
+     */
+    /**
+     * A phase of compilation for which time is tracked in a distinct bucket.
+     */
+    var PerfPhase;
+    (function (PerfPhase) {
+        /**
+         * The "default" phase which tracks time not spent in any other phase.
+         */
+        PerfPhase[PerfPhase["Unaccounted"] = 0] = "Unaccounted";
+        /**
+         * Time spent setting up the compiler, before a TypeScript program is created.
+         *
+         * This includes operations like configuring the `ts.CompilerHost` and any wrappers.
+         */
+        PerfPhase[PerfPhase["Setup"] = 1] = "Setup";
+        /**
+         * Time spent in `ts.createProgram`, including reading and parsing `ts.SourceFile`s in the
+         * `ts.CompilerHost`.
+         *
+         * This might be an incremental program creation operation.
+         */
+        PerfPhase[PerfPhase["TypeScriptProgramCreate"] = 2] = "TypeScriptProgramCreate";
+        /**
+         * Time spent reconciling the contents of an old `ts.Program` with the new incremental one.
+         *
+         * Only present in incremental compilations.
+         */
+        PerfPhase[PerfPhase["Reconciliation"] = 3] = "Reconciliation";
+        /**
+         * Time spent updating an `NgCompiler` instance with a resource-only change.
+         *
+         * Only present in incremental compilations where the change was resource-only.
+         */
+        PerfPhase[PerfPhase["ResourceUpdate"] = 4] = "ResourceUpdate";
+        /**
+         * Time spent calculating the plain TypeScript diagnostics (structural and semantic).
+         */
+        PerfPhase[PerfPhase["TypeScriptDiagnostics"] = 5] = "TypeScriptDiagnostics";
+        /**
+         * Time spent in Angular analysis of individual classes in the program.
+         */
+        PerfPhase[PerfPhase["Analysis"] = 6] = "Analysis";
+        /**
+         * Time spent in Angular global analysis (synthesis of analysis information into a complete
+         * understanding of the program).
+         */
+        PerfPhase[PerfPhase["Resolve"] = 7] = "Resolve";
+        /**
+         * Time spent building the import graph of the program in order to perform cycle detection.
+         */
+        PerfPhase[PerfPhase["CycleDetection"] = 8] = "CycleDetection";
+        /**
+         * Time spent generating the text of Type Check Blocks in order to perform template type checking.
+         */
+        PerfPhase[PerfPhase["TcbGeneration"] = 9] = "TcbGeneration";
+        /**
+         * Time spent updating the `ts.Program` with new Type Check Block code.
+         */
+        PerfPhase[PerfPhase["TcbUpdateProgram"] = 10] = "TcbUpdateProgram";
+        /**
+         * Time spent by TypeScript performing its emit operations, including downleveling and writing
+         * output files.
+         */
+        PerfPhase[PerfPhase["TypeScriptEmit"] = 11] = "TypeScriptEmit";
+        /**
+         * Time spent by Angular performing code transformations of ASTs as they're about to be emitted.
+         *
+         * This includes the actual code generation step for templates, and occurs during the emit phase
+         * (but is tracked separately from `TypeScriptEmit` time).
+         */
+        PerfPhase[PerfPhase["Compile"] = 12] = "Compile";
+        /**
+         * Time spent performing a `TemplateTypeChecker` autocompletion operation.
+         */
+        PerfPhase[PerfPhase["TtcAutocompletion"] = 13] = "TtcAutocompletion";
+        /**
+         * Time spent computing template type-checking diagnostics.
+         */
+        PerfPhase[PerfPhase["TtcDiagnostics"] = 14] = "TtcDiagnostics";
+        /**
+         * Time spent getting a `Symbol` from the `TemplateTypeChecker`.
+         */
+        PerfPhase[PerfPhase["TtcSymbol"] = 15] = "TtcSymbol";
+        /**
+         * Time spent by the Angular Language Service calculating a "get references" or a renaming
+         * operation.
+         */
+        PerfPhase[PerfPhase["LsReferencesAndRenames"] = 16] = "LsReferencesAndRenames";
+        /**
+         * Time spent by the Angular Language Service calculating a "quick info" operation.
+         */
+        PerfPhase[PerfPhase["LsQuickInfo"] = 17] = "LsQuickInfo";
+        /**
+         * Time spent by the Angular Language Service calculating a "get type definition" or "get
+         * definition" operation.
+         */
+        PerfPhase[PerfPhase["LsDefinition"] = 18] = "LsDefinition";
+        /**
+         * Time spent by the Angular Language Service calculating a "get completions" (AKA autocomplete)
+         * operation.
+         */
+        PerfPhase[PerfPhase["LsCompletions"] = 19] = "LsCompletions";
+        /**
+         * Time spent by the Angular Language Service calculating a "view template typecheck block"
+         * operation.
+         */
+        PerfPhase[PerfPhase["LsTcb"] = 20] = "LsTcb";
+        /**
+         * Time spent by the Angular Language Service calculating diagnostics.
+         */
+        PerfPhase[PerfPhase["LsDiagnostics"] = 21] = "LsDiagnostics";
+        /**
+         * Time spent by the Angular Language Service calculating a "get component locations for template"
+         * operation.
+         */
+        PerfPhase[PerfPhase["LsComponentLocations"] = 22] = "LsComponentLocations";
+        /**
+         * Tracks the number of `PerfPhase`s, and must appear at the end of the list.
+         */
+        PerfPhase[PerfPhase["LAST"] = 23] = "LAST";
+    })(PerfPhase || (PerfPhase = {}));
+    /**
+     * Represents some occurrence during compilation, and is tracked with a counter.
+     */
+    var PerfEvent;
+    (function (PerfEvent) {
+        /**
+         * Counts the number of `.d.ts` files in the program.
+         */
+        PerfEvent[PerfEvent["InputDtsFile"] = 0] = "InputDtsFile";
+        /**
+         * Counts the number of non-`.d.ts` files in the program.
+         */
+        PerfEvent[PerfEvent["InputTsFile"] = 1] = "InputTsFile";
+        /**
+         * An `@Component` class was analyzed.
+         */
+        PerfEvent[PerfEvent["AnalyzeComponent"] = 2] = "AnalyzeComponent";
+        /**
+         * An `@Directive` class was analyzed.
+         */
+        PerfEvent[PerfEvent["AnalyzeDirective"] = 3] = "AnalyzeDirective";
+        /**
+         * An `@Injectable` class was analyzed.
+         */
+        PerfEvent[PerfEvent["AnalyzeInjectable"] = 4] = "AnalyzeInjectable";
+        /**
+         * An `@NgModule` class was analyzed.
+         */
+        PerfEvent[PerfEvent["AnalyzeNgModule"] = 5] = "AnalyzeNgModule";
+        /**
+         * An `@Pipe` class was analyzed.
+         */
+        PerfEvent[PerfEvent["AnalyzePipe"] = 6] = "AnalyzePipe";
+        /**
+         * A trait was analyzed.
+         *
+         * In theory, this should be the sum of the `Analyze` counters for each decorator type.
+         */
+        PerfEvent[PerfEvent["TraitAnalyze"] = 7] = "TraitAnalyze";
+        /**
+         * A trait had a prior analysis available from an incremental program, and did not need to be
+         * re-analyzed.
+         */
+        PerfEvent[PerfEvent["TraitReuseAnalysis"] = 8] = "TraitReuseAnalysis";
+        /**
+         * A `ts.SourceFile` directly changed between the prior program and a new incremental compilation.
+         */
+        PerfEvent[PerfEvent["SourceFilePhysicalChange"] = 9] = "SourceFilePhysicalChange";
+        /**
+         * A `ts.SourceFile` did not physically changed, but according to the file dependency graph, has
+         * logically changed between the prior program and a new incremental compilation.
+         */
+        PerfEvent[PerfEvent["SourceFileLogicalChange"] = 10] = "SourceFileLogicalChange";
+        /**
+         * A `ts.SourceFile` has not logically changed and all of its analysis results were thus available
+         * for reuse.
+         */
+        PerfEvent[PerfEvent["SourceFileReuseAnalysis"] = 11] = "SourceFileReuseAnalysis";
+        /**
+         * A Type Check Block (TCB) was generated.
+         */
+        PerfEvent[PerfEvent["GenerateTcb"] = 12] = "GenerateTcb";
+        /**
+         * A Type Check Block (TCB) could not be generated because inlining was disabled, and the block
+         * would've required inlining.
+         */
+        PerfEvent[PerfEvent["SkipGenerateTcbNoInline"] = 13] = "SkipGenerateTcbNoInline";
+        /**
+         * A `.ngtypecheck.ts` file could be reused from the previous program and did not need to be
+         * regenerated.
+         */
+        PerfEvent[PerfEvent["ReuseTypeCheckFile"] = 14] = "ReuseTypeCheckFile";
+        /**
+         * The template type-checking program required changes and had to be updated in an incremental
+         * step.
+         */
+        PerfEvent[PerfEvent["UpdateTypeCheckProgram"] = 15] = "UpdateTypeCheckProgram";
+        /**
+         * The compiler was able to prove that a `ts.SourceFile` did not need to be re-emitted.
+         */
+        PerfEvent[PerfEvent["EmitSkipSourceFile"] = 16] = "EmitSkipSourceFile";
+        /**
+         * A `ts.SourceFile` was emitted.
+         */
+        PerfEvent[PerfEvent["EmitSourceFile"] = 17] = "EmitSourceFile";
+        /**
+         * Tracks the number of `PrefEvent`s, and must appear at the end of the list.
+         */
+        PerfEvent[PerfEvent["LAST"] = 18] = "LAST";
+    })(PerfEvent || (PerfEvent = {}));
+    /**
+     * Represents a checkpoint during compilation at which the memory usage of the compiler should be
+     * recorded.
+     */
+    var PerfCheckpoint;
+    (function (PerfCheckpoint) {
+        /**
+         * The point at which the `PerfRecorder` was created, and ideally tracks memory used before any
+         * compilation structures are created.
+         */
+        PerfCheckpoint[PerfCheckpoint["Initial"] = 0] = "Initial";
+        /**
+         * The point just after the `ts.Program` has been created.
+         */
+        PerfCheckpoint[PerfCheckpoint["TypeScriptProgramCreate"] = 1] = "TypeScriptProgramCreate";
+        /**
+         * The point just before Angular analysis starts.
+         *
+         * In the main usage pattern for the compiler, TypeScript diagnostics have been calculated at this
+         * point, so the `ts.TypeChecker` has fully ingested the current program, all `ts.Type` structures
+         * and `ts.Symbol`s have been created.
+         */
+        PerfCheckpoint[PerfCheckpoint["PreAnalysis"] = 2] = "PreAnalysis";
+        /**
+         * The point just after Angular analysis completes.
+         */
+        PerfCheckpoint[PerfCheckpoint["Analysis"] = 3] = "Analysis";
+        /**
+         * The point just after Angular resolution is complete.
+         */
+        PerfCheckpoint[PerfCheckpoint["Resolve"] = 4] = "Resolve";
+        /**
+         * The point just after Type Check Blocks (TCBs) have been generated.
+         */
+        PerfCheckpoint[PerfCheckpoint["TtcGeneration"] = 5] = "TtcGeneration";
+        /**
+         * The point just after the template type-checking program has been updated with any new TCBs.
+         */
+        PerfCheckpoint[PerfCheckpoint["TtcUpdateProgram"] = 6] = "TtcUpdateProgram";
+        /**
+         * The point just before emit begins.
+         *
+         * In the main usage pattern for the compiler, all template type-checking diagnostics have been
+         * requested at this point.
+         */
+        PerfCheckpoint[PerfCheckpoint["PreEmit"] = 7] = "PreEmit";
+        /**
+         * The point just after the program has been fully emitted.
+         */
+        PerfCheckpoint[PerfCheckpoint["Emit"] = 8] = "Emit";
+        /**
+         * Tracks the number of `PerfCheckpoint`s, and must appear at the end of the list.
+         */
+        PerfCheckpoint[PerfCheckpoint["LAST"] = 9] = "LAST";
+    })(PerfCheckpoint || (PerfCheckpoint = {}));
+
+    /**
+     * @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 mark() {
+        return process.hrtime();
+    }
+    function timeSinceInMicros(mark) {
+        const delta = process.hrtime(mark);
+        return (delta[0] * 1000000) + Math.floor(delta[1] / 1000);
+    }
+
+    /**
+     * @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
+     */
+    /**
+     * A `PerfRecorder` that actively tracks performance statistics.
+     */
+    class ActivePerfRecorder {
+        constructor(zeroTime) {
+            this.zeroTime = zeroTime;
+            this.currentPhase = PerfPhase.Unaccounted;
+            this.currentPhaseEntered = this.zeroTime;
+            this.counters = Array(PerfEvent.LAST).fill(0);
+            this.phaseTime = Array(PerfPhase.LAST).fill(0);
+            this.bytes = Array(PerfCheckpoint.LAST).fill(0);
+            // Take an initial memory snapshot before any other compilation work begins.
+            this.memory(PerfCheckpoint.Initial);
+        }
+        /**
+         * Creates an `ActivePerfRecoder` with its zero point set to the current time.
+         */
+        static zeroedToNow() {
+            return new ActivePerfRecorder(mark());
+        }
+        reset() {
+            this.counters = Array(PerfEvent.LAST).fill(0);
+            this.phaseTime = Array(PerfPhase.LAST).fill(0);
+            this.bytes = Array(PerfCheckpoint.LAST).fill(0);
+            this.zeroTime = mark();
+            this.currentPhase = PerfPhase.Unaccounted;
+            this.currentPhaseEntered = this.zeroTime;
+        }
+        memory(after) {
+            this.bytes[after] = process.memoryUsage().heapUsed;
+        }
+        phase(phase) {
+            const previous = this.currentPhase;
+            this.phaseTime[this.currentPhase] += timeSinceInMicros(this.currentPhaseEntered);
+            this.currentPhase = phase;
+            this.currentPhaseEntered = mark();
+            return previous;
+        }
+        inPhase(phase, fn) {
+            const previousPhase = this.phase(phase);
+            try {
+                return fn();
+            }
+            finally {
+                this.phase(previousPhase);
+            }
+        }
+        eventCount(counter, incrementBy = 1) {
+            this.counters[counter] += incrementBy;
+        }
+        /**
+         * Return the current performance metrics as a serializable object.
+         */
+        finalize() {
+            // Track the last segment of time spent in `this.currentPhase` in the time array.
+            this.phase(PerfPhase.Unaccounted);
+            const results = {
+                events: {},
+                phases: {},
+                memory: {},
+            };
+            for (let i = 0; i < this.phaseTime.length; i++) {
+                if (this.phaseTime[i] > 0) {
+                    results.phases[PerfPhase[i]] = this.phaseTime[i];
+                }
+            }
+            for (let i = 0; i < this.phaseTime.length; i++) {
+                if (this.counters[i] > 0) {
+                    results.events[PerfEvent[i]] = this.counters[i];
+                }
+            }
+            for (let i = 0; i < this.bytes.length; i++) {
+                if (this.bytes[i] > 0) {
+                    results.memory[PerfCheckpoint[i]] = this.bytes[i];
+                }
+            }
+            return results;
+        }
+    }
+    /**
+     * A `PerfRecorder` that delegates to a target `PerfRecorder` which can be updated later.
+     *
+     * `DelegatingPerfRecorder` is useful when a compiler class that needs a `PerfRecorder` can outlive
+     * the current compilation. This is true for most compiler classes as resource-only changes reuse
+     * the same `NgCompiler` for a new compilation.
+     */
+    class DelegatingPerfRecorder {
+        constructor(target) {
+            this.target = target;
+        }
+        eventCount(counter, incrementBy) {
+            this.target.eventCount(counter, incrementBy);
+        }
+        phase(phase) {
+            return this.target.phase(phase);
+        }
+        inPhase(phase, fn) {
+            // Note: this doesn't delegate to `this.target.inPhase` but instead is implemented manually here
+            // to avoid adding an additional frame of noise to the stack when debugging.
+            const previousPhase = this.target.phase(phase);
+            try {
+                return fn();
+            }
+            finally {
+                this.target.phase(previousPhase);
+            }
+        }
+        memory(after) {
+            this.target.memory(after);
+        }
+        reset() {
+            this.target.reset();
+        }
+    }
+
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -25742,6 +26206,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 for (const priorRecord of priorWork) {
                     this.adopt(priorRecord);
                 }
+                this.perf.eventCount(PerfEvent.SourceFileReuseAnalysis);
+                this.perf.eventCount(PerfEvent.TraitReuseAnalysis, priorWork.length);
                 // Skip the rest of analysis, as this file's prior traits are being reused.
                 return;
             }
@@ -25945,6 +26411,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             if (trait.state !== TraitState.Pending) {
                 throw new Error(`Attempt to analyze trait of ${clazz.name.text} in state ${TraitState[trait.state]} (expected DETECTED)`);
             }
+            this.perf.eventCount(PerfEvent.TraitAnalyze);
             // Attempt analysis. This could fail with a `FatalDiagnosticError`; catch it if it does.
             let result;
             try {
@@ -26083,7 +26550,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     // Cannot compile a trait that is not resolved, or had any errors in its declaration.
                     continue;
                 }
-                const compileSpan = this.perf.start('compileClass', original);
                 // `trait.resolution` is non-null asserted here because TypeScript does not recognize that
                 // `Readonly<unknown>` is nullable (as `unknown` itself is nullable) due to the way that
                 // `Readonly` works.
@@ -26097,7 +26563,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                         trait.handler.compileFull(clazz, trait.analysis, trait.resolution, constantPool);
                 }
                 const compileMatchRes = compileRes;
-                this.perf.stop(compileSpan);
                 if (Array.isArray(compileMatchRes)) {
                     for (const result of compileMatchRes) {
                         if (!res.some(r => r.name === result.name)) {
@@ -26262,7 +26727,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             this.imports = imports;
             this.downlevelTaggedTemplates = options.downlevelTaggedTemplates === true;
             this.downlevelVariableDeclarations = options.downlevelVariableDeclarations === true;
-            this.recordWrappedNodeExpr = options.recordWrappedNodeExpr || (() => { });
+            this.recordWrappedNode = options.recordWrappedNode || (() => { });
         }
         visitDeclareVarStmt(stmt, context) {
             var _a;
@@ -26490,7 +26955,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             throw new Error('Method not implemented.');
         }
         visitWrappedNodeExpr(ast, _context) {
-            this.recordWrappedNodeExpr(ast.node);
+            this.recordWrappedNode(ast);
             return ast.node;
         }
         visitTypeofExpr(ast, context) {
@@ -27349,11 +27814,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      */
     const NO_DECORATORS = new Set();
     const CLOSURE_FILE_OVERVIEW_REGEXP = /\s+@fileoverview\s+/i;
-    function ivyTransformFactory(compilation, reflector, importRewriter, defaultImportRecorder, isCore, isClosureCompilerEnabled) {
-        const recordWrappedNodeExpr = createRecorderFn(defaultImportRecorder);
+    function ivyTransformFactory(compilation, reflector, importRewriter, defaultImportTracker, perf, isCore, isClosureCompilerEnabled) {
+        const recordWrappedNode = createRecorderFn(defaultImportTracker);
         return (context) => {
             return (file) => {
-                return transformIvySourceFile(compilation, context, reflector, importRewriter, file, isCore, isClosureCompilerEnabled, recordWrappedNodeExpr);
+                return perf.inPhase(PerfPhase.Compile, () => transformIvySourceFile(compilation, context, reflector, importRewriter, file, isCore, isClosureCompilerEnabled, recordWrappedNode));
             };
         };
     }
@@ -27384,13 +27849,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * compilation results (provided as an argument).
      */
     class IvyTransformationVisitor extends Visitor {
-        constructor(compilation, classCompilationMap, reflector, importManager, recordWrappedNodeExpr, isClosureCompilerEnabled, isCore) {
+        constructor(compilation, classCompilationMap, reflector, importManager, recordWrappedNode, isClosureCompilerEnabled, isCore) {
             super();
             this.compilation = compilation;
             this.classCompilationMap = classCompilationMap;
             this.reflector = reflector;
             this.importManager = importManager;
-            this.recordWrappedNodeExpr = recordWrappedNodeExpr;
+            this.recordWrappedNode = recordWrappedNode;
             this.isClosureCompilerEnabled = isClosureCompilerEnabled;
             this.isCore = isCore;
         }
@@ -27405,7 +27870,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             const members = [...node.members];
             for (const field of this.classCompilationMap.get(node)) {
                 // Translate the initializer for the field into TS nodes.
-                const exprNode = translateExpression(field.initializer, this.importManager, { recordWrappedNodeExpr: this.recordWrappedNodeExpr });
+                const exprNode = translateExpression(field.initializer, this.importManager, { recordWrappedNode: this.recordWrappedNode });
                 // Create a static property declaration for the new field.
                 const property = ts$1.createProperty(undefined, [ts$1.createToken(ts$1.SyntaxKind.StaticKeyword)], field.name, undefined, undefined, exprNode);
                 if (this.isClosureCompilerEnabled) {
@@ -27417,7 +27882,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     /* hasTrailingNewLine */ false);
                 }
                 field.statements
-                    .map(stmt => translateStatement(stmt, this.importManager, { recordWrappedNodeExpr: this.recordWrappedNodeExpr }))
+                    .map(stmt => translateStatement(stmt, this.importManager, { recordWrappedNode: this.recordWrappedNode }))
                     .forEach(stmt => statements.push(stmt));
                 members.push(property);
             }
@@ -27521,7 +27986,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     /**
      * A transformer which operates on ts.SourceFiles and applies changes from an `IvyCompilation`.
      */
-    function transformIvySourceFile(compilation, context, reflector, importRewriter, file, isCore, isClosureCompilerEnabled, recordWrappedNodeExpr) {
+    function transformIvySourceFile(compilation, context, reflector, importRewriter, file, isCore, isClosureCompilerEnabled, recordWrappedNode) {
         const constantPool = new ConstantPool(isClosureCompilerEnabled);
         const importManager = new ImportManager(importRewriter);
         // The transformation process consists of 2 steps:
@@ -27538,13 +28003,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         visit(file, compilationVisitor, context);
         // Step 2. Scan through the AST again and perform transformations based on Ivy compilation
         // results obtained at Step 1.
-        const transformationVisitor = new IvyTransformationVisitor(compilation, compilationVisitor.classCompilationMap, reflector, importManager, recordWrappedNodeExpr, isClosureCompilerEnabled, isCore);
+        const transformationVisitor = new IvyTransformationVisitor(compilation, compilationVisitor.classCompilationMap, reflector, importManager, recordWrappedNode, isClosureCompilerEnabled, isCore);
         let sf = visit(file, transformationVisitor, context);
         // Generate the constant statements first, as they may involve adding additional imports
         // to the ImportManager.
         const downlevelTranslatedCode = getLocalizeCompileTarget(context) < ts$1.ScriptTarget.ES2015;
         const constants = constantPool.statements.map(stmt => translateStatement(stmt, importManager, {
-            recordWrappedNodeExpr,
+            recordWrappedNode,
             downlevelTaggedTemplates: downlevelTranslatedCode,
             downlevelVariableDeclarations: downlevelTranslatedCode,
         }));
@@ -27618,10 +28083,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function isFromAngularCore(decorator) {
         return decorator.import !== null && decorator.import.from === '@angular/core';
     }
-    function createRecorderFn(defaultImportRecorder) {
-        return expr => {
-            if (ts$1.isIdentifier(expr)) {
-                defaultImportRecorder.recordUsedIdentifier(expr);
+    function createRecorderFn(defaultImportTracker) {
+        return node => {
+            const importDecl = getDefaultImportDeclaration(node);
+            if (importDecl !== null) {
+                defaultImportTracker.recordUsedImport(importDecl);
             }
         };
     }
@@ -27716,7 +28182,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      * 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 getConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore) {
+    function getConstructorDependencies(clazz, reflector, isCore) {
         const deps = [];
         const errors = [];
         let ctorParams = reflector.getConstructorParameters(clazz);
@@ -27729,7 +28195,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
         }
         ctorParams.forEach((param, idx) => {
-            let token = valueReferenceToExpression(param.typeValueReference, defaultImportRecorder);
+            let token = valueReferenceToExpression(param.typeValueReference);
             let attribute = null;
             let optional = false, self = false, skipSelf = false, host = false;
             let resolved = R3ResolvedDependencyType.Token;
@@ -27796,16 +28262,16 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return { deps: null, errors };
         }
     }
-    function valueReferenceToExpression(valueRef, defaultImportRecorder) {
+    function valueReferenceToExpression(valueRef) {
         if (valueRef.kind === 2 /* UNAVAILABLE */) {
             return null;
         }
         else if (valueRef.kind === 0 /* LOCAL */) {
-            if (defaultImportRecorder !== null && valueRef.defaultImportStatement !== null &&
-                ts$1.isIdentifier(valueRef.expression)) {
-                defaultImportRecorder.recordImportedIdentifier(valueRef.expression, valueRef.defaultImportStatement);
+            const expr = new WrappedNodeExpr(valueRef.expression);
+            if (valueRef.defaultImportStatement !== null) {
+                attachDefaultImportDeclaration(expr, valueRef.defaultImportStatement);
             }
-            return new WrappedNodeExpr(valueRef.expression);
+            return expr;
         }
         else {
             let importExpr = new ExternalExpr({ moduleName: valueRef.moduleName, name: valueRef.importedName });
@@ -27836,8 +28302,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return 'invalid';
         }
     }
-    function getValidConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore) {
-        return validateConstructorDependencies(clazz, getConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore));
+    function getValidConstructorDependencies(clazz, reflector, isCore) {
+        return validateConstructorDependencies(clazz, getConstructorDependencies(clazz, reflector, isCore));
     }
     /**
      * Validate that `ConstructorDeps` does not have any invalid dependencies and convert them into the
@@ -28345,7 +28811,7 @@ Either add the @Injectable() decorator to '${provider.node.name
      * If no such metadata is present, this function returns `null`. Otherwise, the call is returned
      * as a `Statement` for inclusion along with the class.
      */
-    function generateSetClassMetadataCall(clazz, reflection, defaultImportRecorder, isCore, annotateForClosureCompiler) {
+    function generateSetClassMetadataCall(clazz, reflection, isCore, annotateForClosureCompiler) {
         if (!reflection.isClass(clazz)) {
             return null;
         }
@@ -28372,7 +28838,7 @@ Either add the @Injectable() decorator to '${provider.node.name
         let metaCtorParameters = new LiteralExpr(null);
         const classCtorParameters = reflection.getConstructorParameters(clazz);
         if (classCtorParameters !== null) {
-            const ctorParameters = classCtorParameters.map(param => ctorParameterToMetadata(param, defaultImportRecorder, isCore));
+            const ctorParameters = classCtorParameters.map(param => ctorParameterToMetadata(param, isCore));
             metaCtorParameters = new FunctionExpr([], [
                 new ReturnStatement(new LiteralArrayExpr(ctorParameters)),
             ]);
@@ -28409,11 +28875,11 @@ Either add the @Injectable() decorator to '${provider.node.name
     /**
      * Convert a reflected constructor parameter to metadata.
      */
-    function ctorParameterToMetadata(param, defaultImportRecorder, isCore) {
+    function ctorParameterToMetadata(param, isCore) {
         // Parameters sometimes have a type that can be referenced. If so, then use it, otherwise
         // its type is undefined.
         const type = param.typeValueReference.kind !== 2 /* UNAVAILABLE */ ?
-            valueReferenceToExpression(param.typeValueReference, defaultImportRecorder) :
+            valueReferenceToExpression(param.typeValueReference) :
             new LiteralExpr(undefined);
         const mapEntries = [
             { key: 'type', value: type, quoted: false },
@@ -28600,18 +29066,18 @@ Either add the @Injectable() decorator to '${provider.node.name
         return isSymbolEqual(current, previous);
     }
     class DirectiveDecoratorHandler {
-        constructor(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, defaultImportRecorder, injectableRegistry, isCore, semanticDepGraphUpdater, annotateForClosureCompiler, compileUndecoratedClassesWithAngularFeatures) {
+        constructor(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, injectableRegistry, isCore, semanticDepGraphUpdater, annotateForClosureCompiler, compileUndecoratedClassesWithAngularFeatures, perf) {
             this.reflector = reflector;
             this.evaluator = evaluator;
             this.metaRegistry = metaRegistry;
             this.scopeRegistry = scopeRegistry;
             this.metaReader = metaReader;
-            this.defaultImportRecorder = defaultImportRecorder;
             this.injectableRegistry = injectableRegistry;
             this.isCore = isCore;
             this.semanticDepGraphUpdater = semanticDepGraphUpdater;
             this.annotateForClosureCompiler = annotateForClosureCompiler;
             this.compileUndecoratedClassesWithAngularFeatures = compileUndecoratedClassesWithAngularFeatures;
+            this.perf = perf;
             this.precedence = HandlerPrecedence.PRIMARY;
             this.name = DirectiveDecoratorHandler.name;
         }
@@ -28638,7 +29104,8 @@ Either add the @Injectable() decorator to '${provider.node.name
             if (this.compileUndecoratedClassesWithAngularFeatures === false && decorator === null) {
                 return { diagnostics: [getUndecoratedClassWithAngularFeaturesDiagnostic(node)] };
             }
-            const directiveResult = extractDirectiveMetadata(node, decorator, this.reflector, this.evaluator, this.defaultImportRecorder, this.isCore, flags, this.annotateForClosureCompiler);
+            this.perf.eventCount(PerfEvent.AnalyzeDirective);
+            const directiveResult = extractDirectiveMetadata(node, decorator, this.reflector, this.evaluator, this.isCore, flags, this.annotateForClosureCompiler);
             if (directiveResult === undefined) {
                 return {};
             }
@@ -28652,7 +29119,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                     inputs: directiveResult.inputs,
                     outputs: directiveResult.outputs,
                     meta: analysis,
-                    metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.defaultImportRecorder, this.isCore, this.annotateForClosureCompiler),
+                    metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.isCore, this.annotateForClosureCompiler),
                     baseClass: readBaseClass$1(node, this.reflector, this.evaluator),
                     typeCheckMeta: extractDirectiveTypeCheckMeta(node, directiveResult.inputs, this.reflector),
                     providersRequiringFactory,
@@ -28735,7 +29202,7 @@ Either add the @Injectable() decorator to '${provider.node.name
      * appear in the declarations of an `NgModule` and additional verification is done when processing
      * the module.
      */
-    function extractDirectiveMetadata(clazz, decorator, reflector, evaluator, defaultImportRecorder, isCore, flags, annotateForClosureCompiler, defaultSelector = null) {
+    function extractDirectiveMetadata(clazz, decorator, reflector, evaluator, isCore, flags, annotateForClosureCompiler, defaultSelector = null) {
         let directive;
         if (decorator === null || decorator.args === null || decorator.args.length === 0) {
             directive = new Map();
@@ -28813,7 +29280,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
             exportAs = resolved.split(',').map(part => part.trim());
         }
-        const rawCtorDeps = getConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore);
+        const rawCtorDeps = getConstructorDependencies(clazz, reflector, isCore);
         let ctorDeps;
         // Non-abstract directives (those with a selector) require valid constructor dependencies, whereas
         // abstract directives are allowed to have invalid dependencies, given that a subclass may call
@@ -29235,7 +29702,7 @@ Either add the @Injectable() decorator to '${provider.node.name
      * Compiles @NgModule annotations to ngModuleDef fields.
      */
     class NgModuleDecoratorHandler {
-        constructor(reflector, evaluator, metaReader, metaRegistry, scopeRegistry, referencesRegistry, isCore, routeAnalyzer, refEmitter, factoryTracker, defaultImportRecorder, annotateForClosureCompiler, injectableRegistry, localeId) {
+        constructor(reflector, evaluator, metaReader, metaRegistry, scopeRegistry, referencesRegistry, isCore, routeAnalyzer, refEmitter, factoryTracker, annotateForClosureCompiler, injectableRegistry, perf, localeId) {
             this.reflector = reflector;
             this.evaluator = evaluator;
             this.metaReader = metaReader;
@@ -29246,9 +29713,9 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.routeAnalyzer = routeAnalyzer;
             this.refEmitter = refEmitter;
             this.factoryTracker = factoryTracker;
-            this.defaultImportRecorder = defaultImportRecorder;
             this.annotateForClosureCompiler = annotateForClosureCompiler;
             this.injectableRegistry = injectableRegistry;
+            this.perf = perf;
             this.localeId = localeId;
             this.precedence = HandlerPrecedence.PRIMARY;
             this.name = NgModuleDecoratorHandler.name;
@@ -29270,6 +29737,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
         }
         analyze(node, decorator) {
+            this.perf.eventCount(PerfEvent.AnalyzeNgModule);
             const name = node.name.text;
             if (decorator.args === null || decorator.args.length > 1) {
                 throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, Decorator.nodeForError(decorator), `Incorrect number of arguments to @NgModule decorator`);
@@ -29422,7 +29890,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                     schemas: schemas,
                     mod: ngModuleDef,
                     inj: ngInjectorDef,
-                    deps: getValidConstructorDependencies(node, this.reflector, this.defaultImportRecorder, this.isCore),
+                    deps: getValidConstructorDependencies(node, this.reflector, this.isCore),
                     declarations: declarationRefs,
                     rawDeclarations,
                     imports: importRefs,
@@ -29431,7 +29899,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                     providersRequiringFactory: rawProviders ?
                         resolveProvidersRequiringFactory(rawProviders, this.reflector, this.evaluator) :
                         null,
-                    metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.defaultImportRecorder, this.isCore, this.annotateForClosureCompiler),
+                    metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.isCore, this.annotateForClosureCompiler),
                     factorySymbolName: node.name.text,
                 },
             };
@@ -29762,7 +30230,7 @@ Either add the @Injectable() decorator to '${provider.node.name
      * `DecoratorHandler` which handles the `@Component` annotation.
      */
     class ComponentDecoratorHandler {
-        constructor(reflector, evaluator, metaRegistry, metaReader, scopeReader, scopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, resourceLoader, rootDirs, defaultPreserveWhitespaces, i18nUseExternalIds, enableI18nLegacyMessageIdFormat, usePoisonedData, i18nNormalizeLineEndingsInICUs, moduleResolver, cycleAnalyzer, cycleHandlingStrategy, refEmitter, defaultImportRecorder, depTracker, injectableRegistry, semanticDepGraphUpdater, annotateForClosureCompiler) {
+        constructor(reflector, evaluator, metaRegistry, metaReader, scopeReader, scopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, resourceLoader, rootDirs, defaultPreserveWhitespaces, i18nUseExternalIds, enableI18nLegacyMessageIdFormat, usePoisonedData, i18nNormalizeLineEndingsInICUs, moduleResolver, cycleAnalyzer, cycleHandlingStrategy, refEmitter, depTracker, injectableRegistry, semanticDepGraphUpdater, annotateForClosureCompiler, perf) {
             this.reflector = reflector;
             this.evaluator = evaluator;
             this.metaRegistry = metaRegistry;
@@ -29783,11 +30251,11 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.cycleAnalyzer = cycleAnalyzer;
             this.cycleHandlingStrategy = cycleHandlingStrategy;
             this.refEmitter = refEmitter;
-            this.defaultImportRecorder = defaultImportRecorder;
             this.depTracker = depTracker;
             this.injectableRegistry = injectableRegistry;
             this.semanticDepGraphUpdater = semanticDepGraphUpdater;
             this.annotateForClosureCompiler = annotateForClosureCompiler;
+            this.perf = perf;
             this.literalCache = new Map();
             this.elementSchemaRegistry = new DomElementSchemaRegistry();
             /**
@@ -29833,9 +30301,16 @@ Either add the @Injectable() decorator to '${provider.node.name
             const meta = this._resolveLiteral(decorator);
             const component = reflectObjectLiteral(meta);
             const containingFile = node.getSourceFile().fileName;
-            const resolveStyleUrl = (styleUrl, nodeForError, resourceType) => {
-                const resourceUrl = this._resolveResourceOrThrow(styleUrl, containingFile, nodeForError, resourceType);
-                return this.resourceLoader.preload(resourceUrl);
+            const resolveStyleUrl = (styleUrl) => {
+                try {
+                    const resourceUrl = this.resourceLoader.resolve(styleUrl, containingFile);
+                    return this.resourceLoader.preload(resourceUrl);
+                }
+                catch (_a) {
+                    // Don't worry about failures to preload. We can handle this problem during analysis by
+                    // producing a diagnostic.
+                    return undefined;
+                }
             };
             // A Promise that waits for the template and all <link>ed styles within it to be preloaded.
             const templateAndTemplateStyleResources = this._preloadAndParseTemplate(node, decorator, component, containingFile)
@@ -29843,9 +30318,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                 if (template === null) {
                     return undefined;
                 }
-                const nodeForError = getTemplateDeclarationNodeForError(template.declaration);
-                return Promise
-                    .all(template.styleUrls.map(styleUrl => resolveStyleUrl(styleUrl, nodeForError, 1 /* StylesheetFromTemplate */)))
+                return Promise.all(template.styleUrls.map(styleUrl => resolveStyleUrl(styleUrl)))
                     .then(() => undefined);
             });
             // Extract all the styleUrls in the decorator.
@@ -29860,18 +30333,21 @@ Either add the @Injectable() decorator to '${provider.node.name
                 return Promise
                     .all([
                     templateAndTemplateStyleResources,
-                    ...componentStyleUrls.map(styleUrl => resolveStyleUrl(styleUrl.url, styleUrl.nodeForError, 2 /* StylesheetFromDecorator */))
+                    ...componentStyleUrls.map(styleUrl => resolveStyleUrl(styleUrl.url))
                 ])
                     .then(() => undefined);
             }
         }
         analyze(node, decorator, flags = HandlerFlags.NONE) {
             var _a;
+            this.perf.eventCount(PerfEvent.AnalyzeComponent);
             const containingFile = node.getSourceFile().fileName;
             this.literalCache.delete(decorator);
+            let diagnostics;
+            let isPoisoned = false;
             // @Component inherits @Directive, so begin by extracting the @Directive metadata and building
             // on it.
-            const directiveResult = extractDirectiveMetadata(node, decorator, this.reflector, this.evaluator, this.defaultImportRecorder, this.isCore, flags, this.annotateForClosureCompiler, this.elementSchemaRegistry.getDefaultComponentElementName());
+            const directiveResult = extractDirectiveMetadata(node, decorator, this.reflector, this.evaluator, this.isCore, flags, this.annotateForClosureCompiler, this.elementSchemaRegistry.getDefaultComponentElementName());
             if (directiveResult === undefined) {
                 // `extractDirectiveMetadata` returns undefined when the @Directive has `jit: true`. In this
                 // case, compilation of the decorator is skipped. Returning an empty object signifies
@@ -29936,14 +30412,23 @@ Either add the @Injectable() decorator to '${provider.node.name
                 ...this._extractComponentStyleUrls(component), ...this._extractTemplateStyleUrls(template)
             ];
             for (const styleUrl of styleUrls) {
-                const resourceType = styleUrl.source === 2 /* StylesheetFromDecorator */ ?
-                    2 /* StylesheetFromDecorator */ :
-                    1 /* StylesheetFromTemplate */;
-                const resourceUrl = this._resolveResourceOrThrow(styleUrl.url, containingFile, styleUrl.nodeForError, resourceType);
-                const resourceStr = this.resourceLoader.load(resourceUrl);
-                styles.push(resourceStr);
-                if (this.depTracker !== null) {
-                    this.depTracker.addResourceDependency(node.getSourceFile(), absoluteFrom(resourceUrl));
+                try {
+                    const resourceUrl = this.resourceLoader.resolve(styleUrl.url, containingFile);
+                    const resourceStr = this.resourceLoader.load(resourceUrl);
+                    styles.push(resourceStr);
+                    if (this.depTracker !== null) {
+                        this.depTracker.addResourceDependency(node.getSourceFile(), absoluteFrom(resourceUrl));
+                    }
+                }
+                catch (_b) {
+                    if (diagnostics === undefined) {
+                        diagnostics = [];
+                    }
+                    const resourceType = styleUrl.source === 2 /* StylesheetFromDecorator */ ?
+                        2 /* StylesheetFromDecorator */ :
+                        1 /* StylesheetFromTemplate */;
+                    diagnostics.push(this.makeResourceNotFoundError(styleUrl.url, styleUrl.nodeForError, resourceType)
+                        .toDiagnostic());
                 }
             }
             let inlineStyles = null;
@@ -29976,7 +30461,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                         // analyzed and the full compilation scope for the component can be realized.
                         animations, viewProviders: wrappedViewProviders, i18nUseExternalIds: this.i18nUseExternalIds, relativeContextFilePath }),
                     typeCheckMeta: extractDirectiveTypeCheckMeta(node, inputs, this.reflector),
-                    metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.defaultImportRecorder, this.isCore, this.annotateForClosureCompiler),
+                    metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.isCore, this.annotateForClosureCompiler),
                     template,
                     providersRequiringFactory,
                     viewProvidersRequiringFactory,
@@ -29986,8 +30471,9 @@ Either add the @Injectable() decorator to '${provider.node.name
                         styles: styleResources,
                         template: templateResource,
                     },
-                    isPoisoned: false,
+                    isPoisoned,
                 },
+                diagnostics,
             };
             if (changeDetection !== null) {
                 output.analysis.meta.changeDetection = changeDetection;
@@ -30216,12 +30702,15 @@ Either add the @Injectable() decorator to '${provider.node.name
             let styles = [];
             if (analysis.styleUrls !== null) {
                 for (const styleUrl of analysis.styleUrls) {
-                    const resourceType = styleUrl.source === 2 /* StylesheetFromDecorator */ ?
-                        2 /* StylesheetFromDecorator */ :
-                        1 /* StylesheetFromTemplate */;
-                    const resolvedStyleUrl = this._resolveResourceOrThrow(styleUrl.url, containingFile, styleUrl.nodeForError, resourceType);
-                    const styleText = this.resourceLoader.load(resolvedStyleUrl);
-                    styles.push(styleText);
+                    try {
+                        const resolvedStyleUrl = this.resourceLoader.resolve(styleUrl.url, containingFile);
+                        const styleText = this.resourceLoader.load(resolvedStyleUrl);
+                        styles.push(styleText);
+                    }
+                    catch (e) {
+                        // Resource resolve failures should already be in the diagnostics list from the analyze
+                        // stage. We do not need to do anything with them when updating resources.
+                    }
                 }
             }
             if (analysis.inlineStyles !== null) {
@@ -30343,8 +30832,15 @@ Either add the @Injectable() decorator to '${provider.node.name
             const styleUrlsExpr = component.get('styleUrls');
             if (styleUrlsExpr !== undefined && ts$1.isArrayLiteralExpression(styleUrlsExpr)) {
                 for (const expression of stringLiteralElements(styleUrlsExpr)) {
-                    const resourceUrl = this._resolveResourceOrThrow(expression.text, containingFile, expression, 2 /* StylesheetFromDecorator */);
-                    styles.add({ path: absoluteFrom(resourceUrl), expression });
+                    try {
+                        const resourceUrl = this.resourceLoader.resolve(expression.text, containingFile);
+                        styles.add({ path: absoluteFrom(resourceUrl), expression });
+                    }
+                    catch (_a) {
+                        // Errors in style resource extraction do not need to be handled here. We will produce
+                        // diagnostics for each one that fails in the analysis, after we evaluate the `styleUrls`
+                        // expression to determine _all_ style resources, not just the string literals.
+                    }
                 }
             }
             const stylesExpr = component.get('styles');
@@ -30363,20 +30859,25 @@ Either add the @Injectable() decorator to '${provider.node.name
                 if (typeof templateUrl !== 'string') {
                     throw createValueHasWrongTypeError(templateUrlExpr, templateUrl, 'templateUrl must be a string');
                 }
-                const resourceUrl = this._resolveResourceOrThrow(templateUrl, containingFile, templateUrlExpr, 0 /* Template */);
-                const templatePromise = this.resourceLoader.preload(resourceUrl);
-                // If the preload worked, then actually load and parse the template, and wait for any style
-                // URLs to resolve.
-                if (templatePromise !== undefined) {
-                    return templatePromise.then(() => {
-                        const templateDecl = this.parseTemplateDeclaration(decorator, component, containingFile);
-                        const template = this.extractTemplate(node, templateDecl);
-                        this.preanalyzeTemplateCache.set(node, template);
-                        return template;
-                    });
+                try {
+                    const resourceUrl = this.resourceLoader.resolve(templateUrl, containingFile);
+                    const templatePromise = this.resourceLoader.preload(resourceUrl);
+                    // If the preload worked, then actually load and parse the template, and wait for any style
+                    // URLs to resolve.
+                    if (templatePromise !== undefined) {
+                        return templatePromise.then(() => {
+                            const templateDecl = this.parseTemplateDeclaration(decorator, component, containingFile);
+                            const template = this.extractTemplate(node, templateDecl);
+                            this.preanalyzeTemplateCache.set(node, template);
+                            return template;
+                        });
+                    }
+                    else {
+                        return Promise.resolve(null);
+                    }
                 }
-                else {
-                    return Promise.resolve(null);
+                catch (e) {
+                    throw this.makeResourceNotFoundError(templateUrl, templateUrlExpr, 0 /* Template */);
                 }
             }
             else {
@@ -30508,16 +31009,21 @@ Either add the @Injectable() decorator to '${provider.node.name
                 if (typeof templateUrl !== 'string') {
                     throw createValueHasWrongTypeError(templateUrlExpr, templateUrl, 'templateUrl must be a string');
                 }
-                const resourceUrl = this._resolveResourceOrThrow(templateUrl, containingFile, templateUrlExpr, 0 /* Template */);
-                return {
-                    isInline: false,
-                    interpolationConfig,
-                    preserveWhitespaces,
-                    templateUrl,
-                    templateUrlExpression: templateUrlExpr,
-                    resolvedTemplateUrl: resourceUrl,
-                    sourceMapUrl: sourceMapUrl(resourceUrl),
-                };
+                try {
+                    const resourceUrl = this.resourceLoader.resolve(templateUrl, containingFile);
+                    return {
+                        isInline: false,
+                        interpolationConfig,
+                        preserveWhitespaces,
+                        templateUrl,
+                        templateUrlExpression: templateUrlExpr,
+                        resolvedTemplateUrl: resourceUrl,
+                        sourceMapUrl: sourceMapUrl(resourceUrl),
+                    };
+                }
+                catch (e) {
+                    throw this.makeResourceNotFoundError(templateUrl, templateUrlExpr, 0 /* Template */);
+                }
             }
             else if (component.has('template')) {
                 return {
@@ -30570,30 +31076,20 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
             this.cycleAnalyzer.recordSyntheticImport(origin, imported);
         }
-        /**
-         * Resolve the url of a resource relative to the file that contains the reference to it.
-         *
-         * Throws a FatalDiagnosticError when unable to resolve the file.
-         */
-        _resolveResourceOrThrow(file, basePath, nodeForError, resourceType) {
-            try {
-                return this.resourceLoader.resolve(file, basePath);
-            }
-            catch (e) {
-                let errorText;
-                switch (resourceType) {
-                    case 0 /* Template */:
-                        errorText = `Could not find template file '${file}'.`;
-                        break;
-                    case 1 /* StylesheetFromTemplate */:
-                        errorText = `Could not find stylesheet file '${file}' linked from the template.`;
-                        break;
-                    case 2 /* StylesheetFromDecorator */:
-                        errorText = `Could not find stylesheet file '${file}'.`;
-                        break;
-                }
-                throw new FatalDiagnosticError(ErrorCode.COMPONENT_RESOURCE_NOT_FOUND, nodeForError, errorText);
+        makeResourceNotFoundError(file, nodeForError, resourceType) {
+            let errorText;
+            switch (resourceType) {
+                case 0 /* Template */:
+                    errorText = `Could not find template file '${file}'.`;
+                    break;
+                case 1 /* StylesheetFromTemplate */:
+                    errorText = `Could not find stylesheet file '${file}' linked from the template.`;
+                    break;
+                case 2 /* StylesheetFromDecorator */:
+                    errorText = `Could not find stylesheet file '${file}'.`;
+                    break;
             }
+            return new FatalDiagnosticError(ErrorCode.COMPONENT_RESOURCE_NOT_FOUND, nodeForError, errorText);
         }
         _extractTemplateStyleUrls(template) {
             if (template.styleUrls === null) {
@@ -30661,7 +31157,7 @@ Either add the @Injectable() decorator to '${provider.node.name
      * Adapts the `compileIvyInjectable` compiler for `@Injectable` decorators to the Ivy compiler.
      */
     class InjectableDecoratorHandler {
-        constructor(reflector, defaultImportRecorder, isCore, strictCtorDeps, injectableRegistry, 
+        constructor(reflector, isCore, strictCtorDeps, injectableRegistry, perf, 
         /**
          * What to do if the injectable already contains a ɵprov property.
          *
@@ -30670,10 +31166,10 @@ Either add the @Injectable() decorator to '${provider.node.name
          */
         errorOnDuplicateProv = true) {
             this.reflector = reflector;
-            this.defaultImportRecorder = defaultImportRecorder;
             this.isCore = isCore;
             this.strictCtorDeps = strictCtorDeps;
             this.injectableRegistry = injectableRegistry;
+            this.perf = perf;
             this.errorOnDuplicateProv = errorOnDuplicateProv;
             this.precedence = HandlerPrecedence.SHARED;
             this.name = InjectableDecoratorHandler.name;
@@ -30695,13 +31191,14 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
         }
         analyze(node, decorator) {
+            this.perf.eventCount(PerfEvent.AnalyzeInjectable);
             const meta = extractInjectableMetadata(node, decorator, this.reflector);
             const decorators = this.reflector.getDecoratorsOfDeclaration(node);
             return {
                 analysis: {
                     meta,
-                    ctorDeps: extractInjectableCtorDeps(node, meta, decorator, this.reflector, this.defaultImportRecorder, this.isCore, this.strictCtorDeps),
-                    metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.defaultImportRecorder, this.isCore),
+                    ctorDeps: extractInjectableCtorDeps(node, meta, decorator, this.reflector, this.isCore, this.strictCtorDeps),
+                    metadataStmt: generateSetClassMetadataCall(node, this.reflector, this.isCore),
                     // Avoid generating multiple factories if a class has
                     // more Angular decorators, apart from Injectable.
                     needsFactory: !decorators ||
@@ -30843,7 +31340,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             throw new FatalDiagnosticError(ErrorCode.DECORATOR_ARITY_WRONG, decorator.args[2], 'Too many arguments to @Injectable');
         }
     }
-    function extractInjectableCtorDeps(clazz, meta, decorator, reflector, defaultImportRecorder, isCore, strictCtorDeps) {
+    function extractInjectableCtorDeps(clazz, meta, decorator, reflector, isCore, strictCtorDeps) {
         if (decorator.args === null) {
             throw new FatalDiagnosticError(ErrorCode.DECORATOR_NOT_CALLED, Decorator.nodeForError(decorator), '@Injectable must be called');
         }
@@ -30858,15 +31355,16 @@ Either add the @Injectable() decorator to '${provider.node.name
             // constructor signature does not work for DI then a factory definition (ɵfac) that throws is
             // generated.
             if (strictCtorDeps) {
-                ctorDeps = getValidConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore);
+                ctorDeps = getValidConstructorDependencies(clazz, reflector, isCore);
             }
             else {
-                ctorDeps = unwrapConstructorDependencies(getConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore));
+                ctorDeps =
+                    unwrapConstructorDependencies(getConstructorDependencies(clazz, reflector, isCore));
             }
             return ctorDeps;
         }
         else if (decorator.args.length === 1) {
-            const rawCtorDeps = getConstructorDependencies(clazz, reflector, defaultImportRecorder, isCore);
+            const rawCtorDeps = getConstructorDependencies(clazz, reflector, isCore);
             if (strictCtorDeps && meta.useValue === undefined && meta.useExisting === undefined &&
                 meta.useClass === undefined && meta.useFactory === undefined) {
                 // Since use* was not provided, validate the deps according to strictCtorDeps.
@@ -30950,14 +31448,14 @@ Either add the @Injectable() decorator to '${provider.node.name
         }
     }
     class PipeDecoratorHandler {
-        constructor(reflector, evaluator, metaRegistry, scopeRegistry, defaultImportRecorder, injectableRegistry, isCore) {
+        constructor(reflector, evaluator, metaRegistry, scopeRegistry, injectableRegistry, isCore, perf) {
             this.reflector = reflector;
             this.evaluator = evaluator;
             this.metaRegistry = metaRegistry;
             this.scopeRegistry = scopeRegistry;
-            this.defaultImportRecorder = defaultImportRecorder;
             this.injectableRegistry = injectableRegistry;
             this.isCore = isCore;
+            this.perf = perf;
             this.precedence = HandlerPrecedence.PRIMARY;
             this.name = PipeDecoratorHandler.name;
         }
@@ -30978,6 +31476,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
         }
         analyze(clazz, decorator) {
+            this.perf.eventCount(PerfEvent.AnalyzePipe);
             const name = clazz.name.text;
             const type = wrapTypeReference(this.reflector, clazz);
             const internalType = new WrappedNodeExpr(this.reflector.getInternalNameOfClass(clazz));
@@ -31017,10 +31516,10 @@ Either add the @Injectable() decorator to '${provider.node.name
                         internalType,
                         typeArgumentCount: this.reflector.getGenericArityOfClass(clazz) || 0,
                         pipeName,
-                        deps: getValidConstructorDependencies(clazz, this.reflector, this.defaultImportRecorder, this.isCore),
+                        deps: getValidConstructorDependencies(clazz, this.reflector, this.isCore),
                         pure,
                     },
-                    metadataStmt: generateSetClassMetadataCall(clazz, this.reflector, this.defaultImportRecorder, this.isCore),
+                    metadataStmt: generateSetClassMetadataCall(clazz, this.reflector, this.isCore),
                 },
             };
         }
@@ -31156,8 +31655,9 @@ Either add the @Injectable() decorator to '${provider.node.name
      * dependencies within the same program are tracked; imports into packages on NPM are not.
      */
     class ImportGraph {
-        constructor(checker) {
+        constructor(checker, perf) {
             this.checker = checker;
+            this.perf = perf;
             this.map = new Map();
         }
         /**
@@ -31233,25 +31733,27 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
         }
         scanImports(sf) {
-            const imports = new Set();
-            // Look through the source file for import and export statements.
-            for (const stmt of sf.statements) {
-                if ((!ts$1.isImportDeclaration(stmt) && !ts$1.isExportDeclaration(stmt)) ||
-                    stmt.moduleSpecifier === undefined) {
-                    continue;
-                }
-                const symbol = this.checker.getSymbolAtLocation(stmt.moduleSpecifier);
-                if (symbol === undefined || symbol.valueDeclaration === undefined) {
-                    // No symbol could be found to skip over this import/export.
-                    continue;
-                }
-                const moduleFile = symbol.valueDeclaration;
-                if (ts$1.isSourceFile(moduleFile) && isLocalFile(moduleFile)) {
-                    // Record this local import.
-                    imports.add(moduleFile);
+            return this.perf.inPhase(PerfPhase.CycleDetection, () => {
+                const imports = new Set();
+                // Look through the source file for import and export statements.
+                for (const stmt of sf.statements) {
+                    if ((!ts$1.isImportDeclaration(stmt) && !ts$1.isExportDeclaration(stmt)) ||
+                        stmt.moduleSpecifier === undefined) {
+                        continue;
+                    }
+                    const symbol = this.checker.getSymbolAtLocation(stmt.moduleSpecifier);
+                    if (symbol === undefined || symbol.valueDeclaration === undefined) {
+                        // No symbol could be found to skip over this import/export.
+                        continue;
+                    }
+                    const moduleFile = symbol.valueDeclaration;
+                    if (ts$1.isSourceFile(moduleFile) && isLocalFile(moduleFile)) {
+                        // Record this local import.
+                        imports.add(moduleFile);
+                    }
                 }
-            }
-            return imports;
+                return imports;
+            });
         }
     }
     function isLocalFile(sf) {
@@ -31613,103 +32115,108 @@ Either add the @Injectable() decorator to '${provider.node.name
          * The previous build's `BuildState` is reconciled with the new program's changes, and the results
          * are merged into the new build's `PendingBuildState`.
          */
-        static reconcile(oldProgram, oldDriver, newProgram, modifiedResourceFiles) {
-            // Initialize the state of the current build based on the previous one.
-            let state;
-            if (oldDriver.state.kind === BuildStateKind.Pending) {
-                // The previous build never made it past the pending state. Reuse it as the starting state for
-                // this build.
-                state = oldDriver.state;
-            }
-            else {
-                let priorGraph = null;
-                if (oldDriver.state.lastGood !== null) {
-                    priorGraph = oldDriver.state.lastGood.semanticDepGraph;
-                }
-                // The previous build was successfully analyzed. `pendingEmit` is the only state carried
-                // forward into this build.
-                state = {
-                    kind: BuildStateKind.Pending,
-                    pendingEmit: oldDriver.state.pendingEmit,
-                    pendingTypeCheckEmit: oldDriver.state.pendingTypeCheckEmit,
-                    changedResourcePaths: new Set(),
-                    changedTsPaths: new Set(),
-                    lastGood: oldDriver.state.lastGood,
-                    semanticDepGraphUpdater: new SemanticDepGraphUpdater(priorGraph),
-                };
-            }
-            // Merge the freshly modified resource files with any prior ones.
-            if (modifiedResourceFiles !== null) {
-                for (const resFile of modifiedResourceFiles) {
-                    state.changedResourcePaths.add(absoluteFrom(resFile));
-                }
-            }
-            // Next, process the files in the new program, with a couple of goals:
-            // 1) Determine which TS files have changed, if any, and merge them into `changedTsFiles`.
-            // 2) Produce a list of TS files which no longer exist in the program (they've been deleted
-            //    since the previous compilation). These need to be removed from the state tracking to avoid
-            //    leaking memory.
-            // All files in the old program, for easy detection of changes.
-            const oldFiles = new Set(oldProgram.getSourceFiles());
-            // Assume all the old files were deleted to begin with. Only TS files are tracked.
-            const deletedTsPaths = new Set(tsOnlyFiles(oldProgram).map(sf => sf.fileName));
-            for (const newFile of newProgram.getSourceFiles()) {
-                if (!newFile.isDeclarationFile) {
-                    // This file exists in the new program, so remove it from `deletedTsPaths`.
-                    deletedTsPaths.delete(newFile.fileName);
-                }
-                if (oldFiles.has(newFile)) {
-                    // This file hasn't changed; no need to look at it further.
-                    continue;
-                }
-                // The file has changed since the last successful build. The appropriate reaction depends on
-                // what kind of file it is.
-                if (!newFile.isDeclarationFile) {
-                    // It's a .ts file, so track it as a change.
-                    state.changedTsPaths.add(newFile.fileName);
+        static reconcile(oldProgram, oldDriver, newProgram, modifiedResourceFiles, perf) {
+            return perf.inPhase(PerfPhase.Reconciliation, () => {
+                // Initialize the state of the current build based on the previous one.
+                let state;
+                if (oldDriver.state.kind === BuildStateKind.Pending) {
+                    // The previous build never made it past the pending state. Reuse it as the starting state
+                    // for this build.
+                    state = oldDriver.state;
                 }
                 else {
-                    // It's a .d.ts file. Currently the compiler does not do a great job of tracking
-                    // dependencies on .d.ts files, so bail out of incremental builds here and do a full build.
-                    // This usually only happens if something in node_modules changes.
-                    return IncrementalDriver.fresh(newProgram);
-                }
-            }
-            // The next step is to remove any deleted files from the state.
-            for (const filePath of deletedTsPaths) {
-                state.pendingEmit.delete(filePath);
-                state.pendingTypeCheckEmit.delete(filePath);
-                // Even if the file doesn't exist in the current compilation, it still might have been changed
-                // in a previous one, so delete it from the set of changed TS files, just in case.
-                state.changedTsPaths.delete(filePath);
-            }
-            // Now, changedTsPaths contains physically changed TS paths. Use the previous program's logical
-            // dependency graph to determine logically changed files.
-            const depGraph = new FileDependencyGraph();
-            // If a previous compilation exists, use its dependency graph to determine the set of logically
-            // changed files.
-            let logicalChanges = null;
-            if (state.lastGood !== null) {
-                // Extract the set of logically changed files. At the same time, this operation populates the
-                // current (fresh) dependency graph with information about those files which have not
-                // logically changed.
-                logicalChanges = depGraph.updateWithPhysicalChanges(state.lastGood.depGraph, state.changedTsPaths, deletedTsPaths, state.changedResourcePaths);
-                for (const fileName of state.changedTsPaths) {
-                    logicalChanges.add(fileName);
-                }
-                // Any logically changed files need to be re-emitted. Most of the time this would happen
-                // regardless because the new dependency graph would _also_ identify the file as stale.
-                // However there are edge cases such as removing a component from an NgModule without adding
-                // it to another one, where the previous graph identifies the file as logically changed, but
-                // the new graph (which does not have that edge) fails to identify that the file should be
-                // re-emitted.
-                for (const change of logicalChanges) {
-                    state.pendingEmit.add(change);
-                    state.pendingTypeCheckEmit.add(change);
+                    let priorGraph = null;
+                    if (oldDriver.state.lastGood !== null) {
+                        priorGraph = oldDriver.state.lastGood.semanticDepGraph;
+                    }
+                    // The previous build was successfully analyzed. `pendingEmit` is the only state carried
+                    // forward into this build.
+                    state = {
+                        kind: BuildStateKind.Pending,
+                        pendingEmit: oldDriver.state.pendingEmit,
+                        pendingTypeCheckEmit: oldDriver.state.pendingTypeCheckEmit,
+                        changedResourcePaths: new Set(),
+                        changedTsPaths: new Set(),
+                        lastGood: oldDriver.state.lastGood,
+                        semanticDepGraphUpdater: new SemanticDepGraphUpdater(priorGraph),
+                    };
                 }
-            }
-            // `state` now reflects the initial pending state of the current compilation.
-            return new IncrementalDriver(state, depGraph, logicalChanges);
+                // Merge the freshly modified resource files with any prior ones.
+                if (modifiedResourceFiles !== null) {
+                    for (const resFile of modifiedResourceFiles) {
+                        state.changedResourcePaths.add(absoluteFrom(resFile));
+                    }
+                }
+                // Next, process the files in the new program, with a couple of goals:
+                // 1) Determine which TS files have changed, if any, and merge them into `changedTsFiles`.
+                // 2) Produce a list of TS files which no longer exist in the program (they've been deleted
+                //    since the previous compilation). These need to be removed from the state tracking to
+                //    avoid leaking memory.
+                // All files in the old program, for easy detection of changes.
+                const oldFiles = new Set(oldProgram.getSourceFiles().map(toUnredirectedSourceFile));
+                // Assume all the old files were deleted to begin with. Only TS files are tracked.
+                const deletedTsPaths = new Set(tsOnlyFiles(oldProgram).map(sf => sf.fileName));
+                for (const possiblyRedirectedNewFile of newProgram.getSourceFiles()) {
+                    const newFile = toUnredirectedSourceFile(possiblyRedirectedNewFile);
+                    if (!newFile.isDeclarationFile) {
+                        // This file exists in the new program, so remove it from `deletedTsPaths`.
+                        deletedTsPaths.delete(newFile.fileName);
+                    }
+                    if (oldFiles.has(newFile)) {
+                        // This file hasn't changed; no need to look at it further.
+                        continue;
+                    }
+                    // The file has changed since the last successful build. The appropriate reaction depends on
+                    // what kind of file it is.
+                    if (!newFile.isDeclarationFile) {
+                        // It's a .ts file, so track it as a change.
+                        state.changedTsPaths.add(newFile.fileName);
+                    }
+                    else {
+                        // It's a .d.ts file. Currently the compiler does not do a great job of tracking
+                        // dependencies on .d.ts files, so bail out of incremental builds here and do a full
+                        // build. This usually only happens if something in node_modules changes.
+                        return IncrementalDriver.fresh(newProgram);
+                    }
+                }
+                // The next step is to remove any deleted files from the state.
+                for (const filePath of deletedTsPaths) {
+                    state.pendingEmit.delete(filePath);
+                    state.pendingTypeCheckEmit.delete(filePath);
+                    // Even if the file doesn't exist in the current compilation, it still might have been
+                    // changed in a previous one, so delete it from the set of changed TS files, just in case.
+                    state.changedTsPaths.delete(filePath);
+                }
+                perf.eventCount(PerfEvent.SourceFilePhysicalChange, state.changedTsPaths.size);
+                // Now, changedTsPaths contains physically changed TS paths. Use the previous program's
+                // logical dependency graph to determine logically changed files.
+                const depGraph = new FileDependencyGraph();
+                // If a previous compilation exists, use its dependency graph to determine the set of
+                // logically changed files.
+                let logicalChanges = null;
+                if (state.lastGood !== null) {
+                    // Extract the set of logically changed files. At the same time, this operation populates
+                    // the current (fresh) dependency graph with information about those files which have not
+                    // logically changed.
+                    logicalChanges = depGraph.updateWithPhysicalChanges(state.lastGood.depGraph, state.changedTsPaths, deletedTsPaths, state.changedResourcePaths);
+                    perf.eventCount(PerfEvent.SourceFileLogicalChange, logicalChanges.size);
+                    for (const fileName of state.changedTsPaths) {
+                        logicalChanges.add(fileName);
+                    }
+                    // Any logically changed files need to be re-emitted. Most of the time this would happen
+                    // regardless because the new dependency graph would _also_ identify the file as stale.
+                    // However there are edge cases such as removing a component from an NgModule without adding
+                    // it to another one, where the previous graph identifies the file as logically changed, but
+                    // the new graph (which does not have that edge) fails to identify that the file should be
+                    // re-emitted.
+                    for (const change of logicalChanges) {
+                        state.pendingEmit.add(change);
+                        state.pendingTypeCheckEmit.add(change);
+                    }
+                }
+                // `state` now reflects the initial pending state of the current compilation.
+                return new IncrementalDriver(state, depGraph, logicalChanges);
+            });
         }
         static fresh(program) {
             // Initialize the set of files which need to be emitted to the set of all TS files in the
@@ -32394,29 +32901,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             node.modifiers.some(mod => mod.kind === ts$1.SyntaxKind.StaticKeyword);
     }
 
-    const NOOP_PERF_RECORDER = {
-        enabled: false,
-        mark: (name, node, category, detail) => { },
-        start: (name, node, category, detail) => {
-            return 0;
-        },
-        stop: (span) => { },
-    };
-
-    /**
-     * @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 PerfLogEventType;
-    (function (PerfLogEventType) {
-        PerfLogEventType[PerfLogEventType["SPAN_OPEN"] = 0] = "SPAN_OPEN";
-        PerfLogEventType[PerfLogEventType["SPAN_CLOSE"] = 1] = "SPAN_CLOSE";
-        PerfLogEventType[PerfLogEventType["MARK"] = 2] = "MARK";
-    })(PerfLogEventType || (PerfLogEventType = {}));
-
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -32454,7 +32938,7 @@ Either add the @Injectable() decorator to '${provider.node.name
         resolve(url, fromFile) {
             let resolvedUrl = null;
             if (this.adapter.resourceNameToFileName) {
-                resolvedUrl = this.adapter.resourceNameToFileName(url, fromFile);
+                resolvedUrl = this.adapter.resourceNameToFileName(url, fromFile, (url, fromFile) => this.fallbackResolve(url, fromFile));
             }
             else {
                 resolvedUrl = this.fallbackResolve(url, fromFile);
@@ -34242,56 +34726,63 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.data = data;
             this.shimPath = shimPath;
             /**
-             * Cache of `GlobalCompletion`s for various levels of the template, including the root template
-             * (`null`).
+             * Cache of completions for various levels of the template, including the root template (`null`).
+             * Memoizes `getTemplateContextCompletions`.
              */
-            this.globalCompletionCache = new Map();
+            this.templateContextCache = new Map();
             this.expressionCompletionCache = new Map();
-        }
-        /**
-         * Get global completions within the given template context - either a `TmplAstTemplate` embedded
-         * view, or `null` for the root template context.
-         */
-        getGlobalCompletions(context) {
-            if (this.globalCompletionCache.has(context)) {
-                return this.globalCompletionCache.get(context);
-            }
             // Find the component completion expression within the TCB. This looks like: `ctx. /* ... */;`
             const globalRead = findFirstMatchingNode(this.tcb, {
                 filter: ts$1.isPropertyAccessExpression,
                 withExpressionIdentifier: ExpressionIdentifier.COMPONENT_COMPLETION
             });
-            if (globalRead === null) {
-                return null;
-            }
-            const completion = {
-                componentContext: {
+            if (globalRead !== null) {
+                this.componentContext = {
                     shimPath: this.shimPath,
                     // `globalRead.name` is an empty `ts.Identifier`, so its start position immediately follows
                     // the `.` in `ctx.`. TS autocompletion APIs can then be used to access completion results
                     // for the component context.
                     positionInShimFile: globalRead.name.getStart(),
-                },
-                templateContext: new Map(),
-            };
-            // The bound template already has details about the references and variables in scope in the
-            // `context` template - they just need to be converted to `Completion`s.
-            for (const node of this.data.boundTarget.getEntitiesInTemplateScope(context)) {
-                if (node instanceof Reference) {
-                    completion.templateContext.set(node.name, {
-                        kind: CompletionKind.Reference,
-                        node,
-                    });
-                }
-                else {
-                    completion.templateContext.set(node.name, {
-                        kind: CompletionKind.Variable,
-                        node,
-                    });
+                };
+            }
+            else {
+                this.componentContext = null;
+            }
+        }
+        /**
+         * Get global completions within the given template context and AST node.
+         *
+         * @param context the given template context - either a `TmplAstTemplate` embedded view, or `null`
+         *     for the root
+         * template context.
+         * @param node the given AST node
+         */
+        getGlobalCompletions(context, node) {
+            if (this.componentContext === null) {
+                return null;
+            }
+            const templateContext = this.getTemplateContextCompletions(context);
+            if (templateContext === null) {
+                return null;
+            }
+            let nodeContext = null;
+            if (node instanceof EmptyExpr) {
+                const nodeLocation = findFirstMatchingNode(this.tcb, {
+                    filter: ts$1.isIdentifier,
+                    withSpan: node.sourceSpan,
+                });
+                if (nodeLocation !== null) {
+                    nodeContext = {
+                        shimPath: this.shimPath,
+                        positionInShimFile: nodeLocation.getStart(),
+                    };
                 }
             }
-            this.globalCompletionCache.set(context, completion);
-            return completion;
+            return {
+                componentContext: this.componentContext,
+                templateContext,
+                nodeContext,
+            };
         }
         getExpressionCompletionLocation(expr) {
             if (this.expressionCompletionCache.has(expr)) {
@@ -34336,6 +34827,34 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.expressionCompletionCache.set(expr, res);
             return res;
         }
+        /**
+         * Get global completions within the given template context - either a `TmplAstTemplate` embedded
+         * view, or `null` for the root context.
+         */
+        getTemplateContextCompletions(context) {
+            if (this.templateContextCache.has(context)) {
+                return this.templateContextCache.get(context);
+            }
+            const templateContext = new Map();
+            // The bound template already has details about the references and variables in scope in the
+            // `context` template - they just need to be converted to `Completion`s.
+            for (const node of this.data.boundTarget.getEntitiesInTemplateScope(context)) {
+                if (node instanceof Reference) {
+                    templateContext.set(node.name, {
+                        kind: CompletionKind.Reference,
+                        node,
+                    });
+                }
+                else {
+                    templateContext.set(node.name, {
+                        kind: CompletionKind.Variable,
+                        node,
+                    });
+                }
+            }
+            this.templateContextCache.set(context, templateContext);
+            return templateContext;
+        }
     }
 
     /**
@@ -34665,12 +35184,6 @@ Either add the @Injectable() decorator to '${provider.node.name
         }
         return false;
     }
-    function checkIfGenericTypesAreUnbound(node) {
-        if (node.typeParameters === undefined) {
-            return true;
-        }
-        return node.typeParameters.every(param => param.constraint === undefined);
-    }
     function isAccessExpression(node) {
         return ts$1.isPropertyAccessExpression(node) || ts$1.isElementAccessExpression(node);
     }
@@ -34890,6 +35403,136 @@ Either add the @Injectable() decorator to '${provider.node.name
         }
     }
 
+    /**
+     * @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
+     */
+    /**
+     * Indicates whether a particular component requires an inline type check block.
+     *
+     * This is not a boolean state as inlining might only be required to get the best possible
+     * type-checking, but the component could theoretically still be checked without it.
+     */
+    var TcbInliningRequirement;
+    (function (TcbInliningRequirement) {
+        /**
+         * There is no way to type check this component without inlining.
+         */
+        TcbInliningRequirement[TcbInliningRequirement["MustInline"] = 0] = "MustInline";
+        /**
+         * Inlining should be used due to the component's generic bounds, but a non-inlining fallback
+         * method can be used if that's not possible.
+         */
+        TcbInliningRequirement[TcbInliningRequirement["ShouldInlineForGenericBounds"] = 1] = "ShouldInlineForGenericBounds";
+        /**
+         * There is no requirement for this component's TCB to be inlined.
+         */
+        TcbInliningRequirement[TcbInliningRequirement["None"] = 2] = "None";
+    })(TcbInliningRequirement || (TcbInliningRequirement = {}));
+    function requiresInlineTypeCheckBlock(node, usedPipes, reflector) {
+        // In order to qualify for a declared TCB (not inline) two conditions must be met:
+        // 1) the class must be exported
+        // 2) it must not have contextual generic type bounds
+        if (!checkIfClassIsExported(node)) {
+            // Condition 1 is false, the class is not exported.
+            return TcbInliningRequirement.MustInline;
+        }
+        else if (!checkIfGenericTypeBoundsAreContextFree(node, reflector)) {
+            // Condition 2 is false, the class has constrained generic types. It should be checked with an
+            // inline TCB if possible, but can potentially use fallbacks to avoid inlining if not.
+            return TcbInliningRequirement.ShouldInlineForGenericBounds;
+        }
+        else if (Array.from(usedPipes.values())
+            .some(pipeRef => !checkIfClassIsExported(pipeRef.node))) {
+            // If one of the pipes used by the component is not exported, a non-inline TCB will not be able
+            // to import it, so this requires an inline TCB.
+            return TcbInliningRequirement.MustInline;
+        }
+        else {
+            return TcbInliningRequirement.None;
+        }
+    }
+    /** Maps a shim position back to a template location. */
+    function getTemplateMapping(shimSf, position, resolver, isDiagnosticRequest) {
+        const node = getTokenAtPosition(shimSf, position);
+        const sourceLocation = findSourceLocation(node, shimSf, isDiagnosticRequest);
+        if (sourceLocation === null) {
+            return null;
+        }
+        const mapping = resolver.getSourceMapping(sourceLocation.id);
+        const span = resolver.toParseSourceSpan(sourceLocation.id, sourceLocation.span);
+        if (span === null) {
+            return null;
+        }
+        // TODO(atscott): Consider adding a context span by walking up from `node` until we get a
+        // different span.
+        return { sourceLocation, templateSourceMapping: mapping, span };
+    }
+    function findTypeCheckBlock(file, id, isDiagnosticRequest) {
+        for (const stmt of file.statements) {
+            if (ts$1.isFunctionDeclaration(stmt) && getTemplateId$1(stmt, file, isDiagnosticRequest) === id) {
+                return stmt;
+            }
+        }
+        return null;
+    }
+    /**
+     * Traverses up the AST starting from the given node to extract the source location from comments
+     * that have been emitted into the TCB. If the node does not exist within a TCB, or if an ignore
+     * marker comment is found up the tree (and this is part of a diagnostic request), this function
+     * returns null.
+     */
+    function findSourceLocation(node, sourceFile, isDiagnosticsRequest) {
+        // Search for comments until the TCB's function declaration is encountered.
+        while (node !== undefined && !ts$1.isFunctionDeclaration(node)) {
+            if (hasIgnoreForDiagnosticsMarker(node, sourceFile) && isDiagnosticsRequest) {
+                // There's an ignore marker on this node, so the diagnostic should not be reported.
+                return null;
+            }
+            const span = readSpanComment(node, sourceFile);
+            if (span !== null) {
+                // Once the positional information has been extracted, search further up the TCB to extract
+                // the unique id that is attached with the TCB's function declaration.
+                const id = getTemplateId$1(node, sourceFile, isDiagnosticsRequest);
+                if (id === null) {
+                    return null;
+                }
+                return { id, span };
+            }
+            node = node.parent;
+        }
+        return null;
+    }
+    function getTemplateId$1(node, sourceFile, isDiagnosticRequest) {
+        // Walk up to the function declaration of the TCB, the file information is attached there.
+        while (!ts$1.isFunctionDeclaration(node)) {
+            if (hasIgnoreForDiagnosticsMarker(node, sourceFile) && isDiagnosticRequest) {
+                // There's an ignore marker on this node, so the diagnostic should not be reported.
+                return null;
+            }
+            node = node.parent;
+            // Bail once we have reached the root.
+            if (node === undefined) {
+                return null;
+            }
+        }
+        const start = node.getFullStart();
+        return ts$1.forEachLeadingCommentRange(sourceFile.text, start, (pos, end, kind) => {
+            if (kind !== ts$1.SyntaxKind.MultiLineCommentTrivia) {
+                return null;
+            }
+            const commentText = sourceFile.text.substring(pos + 2, end - 2);
+            return commentText;
+        }) || null;
+    }
+    function checkIfGenericTypeBoundsAreContextFree(node, reflector) {
+        // Generic type parameters are considered context free if they can be emitted into any context.
+        return new TypeParameterEmitter(node.typeParameters, reflector).canEmit();
+    }
+
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -35054,10 +35697,6 @@ Either add the @Injectable() decorator to '${provider.node.name
         // emitted into a different context.
         return !checkIfGenericTypeBoundsAreContextFree(node, host);
     }
-    function checkIfGenericTypeBoundsAreContextFree(node, reflector) {
-        // Generic type parameters are considered context free if they can be emitted into any context.
-        return new TypeParameterEmitter(node.typeParameters, reflector).canEmit();
-    }
     /**
      * Add a default `= any` to type parameters that don't have a default value already.
      *
@@ -35366,109 +36005,6 @@ Either add the @Injectable() decorator to '${provider.node.name
         return Object.assign(Object.assign({}, makeDiagnostic(code, node, messageText, relatedInformation)), { componentFile: node.getSourceFile(), templateId });
     }
 
-    /**
-     * @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 requiresInlineTypeCheckBlock(node, usedPipes) {
-        // In order to qualify for a declared TCB (not inline) two conditions must be met:
-        // 1) the class must be exported
-        // 2) it must not have constrained generic types
-        if (!checkIfClassIsExported(node)) {
-            // Condition 1 is false, the class is not exported.
-            return true;
-        }
-        else if (!checkIfGenericTypesAreUnbound(node)) {
-            // Condition 2 is false, the class has constrained generic types
-            return true;
-        }
-        else if (Array.from(usedPipes.values())
-            .some(pipeRef => !checkIfClassIsExported(pipeRef.node))) {
-            // If one of the pipes used by the component is not exported, a non-inline TCB will not be able
-            // to import it, so this requires an inline TCB.
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    /** Maps a shim position back to a template location. */
-    function getTemplateMapping(shimSf, position, resolver, isDiagnosticRequest) {
-        const node = getTokenAtPosition(shimSf, position);
-        const sourceLocation = findSourceLocation(node, shimSf, isDiagnosticRequest);
-        if (sourceLocation === null) {
-            return null;
-        }
-        const mapping = resolver.getSourceMapping(sourceLocation.id);
-        const span = resolver.toParseSourceSpan(sourceLocation.id, sourceLocation.span);
-        if (span === null) {
-            return null;
-        }
-        // TODO(atscott): Consider adding a context span by walking up from `node` until we get a
-        // different span.
-        return { sourceLocation, templateSourceMapping: mapping, span };
-    }
-    function findTypeCheckBlock(file, id, isDiagnosticRequest) {
-        for (const stmt of file.statements) {
-            if (ts$1.isFunctionDeclaration(stmt) && getTemplateId$1(stmt, file, isDiagnosticRequest) === id) {
-                return stmt;
-            }
-        }
-        return null;
-    }
-    /**
-     * Traverses up the AST starting from the given node to extract the source location from comments
-     * that have been emitted into the TCB. If the node does not exist within a TCB, or if an ignore
-     * marker comment is found up the tree (and this is part of a diagnostic request), this function
-     * returns null.
-     */
-    function findSourceLocation(node, sourceFile, isDiagnosticsRequest) {
-        // Search for comments until the TCB's function declaration is encountered.
-        while (node !== undefined && !ts$1.isFunctionDeclaration(node)) {
-            if (hasIgnoreForDiagnosticsMarker(node, sourceFile) && isDiagnosticsRequest) {
-                // There's an ignore marker on this node, so the diagnostic should not be reported.
-                return null;
-            }
-            const span = readSpanComment(node, sourceFile);
-            if (span !== null) {
-                // Once the positional information has been extracted, search further up the TCB to extract
-                // the unique id that is attached with the TCB's function declaration.
-                const id = getTemplateId$1(node, sourceFile, isDiagnosticsRequest);
-                if (id === null) {
-                    return null;
-                }
-                return { id, span };
-            }
-            node = node.parent;
-        }
-        return null;
-    }
-    function getTemplateId$1(node, sourceFile, isDiagnosticRequest) {
-        // Walk up to the function declaration of the TCB, the file information is attached there.
-        while (!ts$1.isFunctionDeclaration(node)) {
-            if (hasIgnoreForDiagnosticsMarker(node, sourceFile) && isDiagnosticRequest) {
-                // There's an ignore marker on this node, so the diagnostic should not be reported.
-                return null;
-            }
-            node = node.parent;
-            // Bail once we have reached the root.
-            if (node === undefined) {
-                return null;
-            }
-        }
-        const start = node.getFullStart();
-        return ts$1.forEachLeadingCommentRange(sourceFile.text, start, (pos, end, kind) => {
-            if (kind !== ts$1.SyntaxKind.MultiLineCommentTrivia) {
-                return null;
-            }
-            const commentText = sourceFile.text.substring(pos + 2, end - 2);
-            return commentText;
-        }) || null;
-    }
-
     /**
      * @license
      * Copyright Google LLC All Rights Reserved.
@@ -35613,7 +36149,9 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
             // The `EmptyExpr` doesn't have a dedicated method on `AstVisitor`, so it's special cased here.
             if (ast instanceof EmptyExpr) {
-                return UNDEFINED;
+                const res = ts$1.factory.createIdentifier('undefined');
+                addParseSpanInfo(res, ast.sourceSpan);
+                return res;
             }
             // First attempt to let any custom resolution logic provide a translation for the given node.
             const resolved = this.maybeResolve(ast);
@@ -35977,6 +36515,32 @@ Either add the @Injectable() decorator to '${provider.node.name
      * 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
      */
+    /**
+     * Controls how generics for the component context class will be handled during TCB generation.
+     */
+    var TcbGenericContextBehavior;
+    (function (TcbGenericContextBehavior) {
+        /**
+         * References to generic parameter bounds will be emitted via the `TypeParameterEmitter`.
+         *
+         * The caller must verify that all parameter bounds are emittable in order to use this mode.
+         */
+        TcbGenericContextBehavior[TcbGenericContextBehavior["UseEmitter"] = 0] = "UseEmitter";
+        /**
+         * Generic parameter declarations will be copied directly from the `ts.ClassDeclaration` of the
+         * component class.
+         *
+         * The caller must only use the generated TCB code in a context where such copies will still be
+         * valid, such as an inline type check block.
+         */
+        TcbGenericContextBehavior[TcbGenericContextBehavior["CopyClassNodes"] = 1] = "CopyClassNodes";
+        /**
+         * Any generic parameters for the component context class will be set to `any`.
+         *
+         * Produces a less useful type, but is always safe to use.
+         */
+        TcbGenericContextBehavior[TcbGenericContextBehavior["FallbackToAny"] = 2] = "FallbackToAny";
+    })(TcbGenericContextBehavior || (TcbGenericContextBehavior = {}));
     /**
      * Given a `ts.ClassDeclaration` for a component, and metadata regarding that component, compose a
      * "type check block" function.
@@ -35998,15 +36562,39 @@ Either add the @Injectable() decorator to '${provider.node.name
      * and bindings.
      * @param oobRecorder used to record errors regarding template elements which could not be correctly
      * translated into types during TCB generation.
+     * @param genericContextBehavior controls how generic parameters (especially parameters with generic
+     * bounds) will be referenced from the generated TCB code.
      */
-    function generateTypeCheckBlock(env, ref, name, meta, domSchemaChecker, oobRecorder) {
+    function generateTypeCheckBlock(env, ref, name, meta, domSchemaChecker, oobRecorder, genericContextBehavior) {
         const tcb = new Context$1(env, domSchemaChecker, oobRecorder, meta.id, meta.boundTarget, meta.pipes, meta.schemas);
         const scope = Scope$1.forNodes(tcb, null, tcb.boundTarget.target.template, /* guard */ null);
         const ctxRawType = env.referenceType(ref);
         if (!ts$1.isTypeReferenceNode(ctxRawType)) {
             throw new Error(`Expected TypeReferenceNode when referencing the ctx param for ${ref.debugName}`);
         }
-        const paramList = [tcbCtxParam(ref.node, ctxRawType.typeName, env.config.useContextGenericType)];
+        let typeParameters = undefined;
+        let typeArguments = undefined;
+        if (ref.node.typeParameters !== undefined) {
+            if (!env.config.useContextGenericType) {
+                genericContextBehavior = TcbGenericContextBehavior.FallbackToAny;
+            }
+            switch (genericContextBehavior) {
+                case TcbGenericContextBehavior.UseEmitter:
+                    // Guaranteed to emit type parameters since we checked that the class has them above.
+                    typeParameters = new TypeParameterEmitter(ref.node.typeParameters, env.reflector)
+                        .emit(typeRef => env.referenceType(typeRef));
+                    typeArguments = typeParameters.map(param => ts$1.factory.createTypeReferenceNode(param.name));
+                    break;
+                case TcbGenericContextBehavior.CopyClassNodes:
+                    typeParameters = [...ref.node.typeParameters];
+                    typeArguments = typeParameters.map(param => ts$1.factory.createTypeReferenceNode(param.name));
+                    break;
+                case TcbGenericContextBehavior.FallbackToAny:
+                    typeArguments = ref.node.typeParameters.map(() => ts$1.factory.createKeywordTypeNode(ts$1.SyntaxKind.AnyKeyword));
+                    break;
+            }
+        }
+        const paramList = [tcbCtxParam(ref.node, ctxRawType.typeName, typeArguments)];
         const scopeStatements = scope.render();
         const innerBody = ts$1.createBlock([
             ...env.getPreludeStatements(),
@@ -36020,7 +36608,7 @@ Either add the @Injectable() decorator to '${provider.node.name
         /* modifiers */ undefined, 
         /* asteriskToken */ undefined, 
         /* name */ name, 
-        /* typeParameters */ env.config.useContextGenericType ? ref.node.typeParameters : undefined, 
+        /* typeParameters */ env.config.useContextGenericType ? typeParameters : undefined, 
         /* parameters */ paramList, 
         /* type */ undefined, 
         /* body */ body);
@@ -37389,26 +37977,11 @@ Either add the @Injectable() decorator to '${provider.node.name
         }
     }
     /**
-     * Create the `ctx` parameter to the top-level TCB function.
-     *
-     * This is a parameter with a type equivalent to the component type, with all generic type
-     * parameters listed (without their generic bounds).
+     * Create the `ctx` parameter to the top-level TCB function, with the given generic type arguments.
      */
-    function tcbCtxParam(node, name, useGenericType) {
-        let typeArguments = undefined;
-        // Check if the component is generic, and pass generic type parameters if so.
-        if (node.typeParameters !== undefined) {
-            if (useGenericType) {
-                typeArguments =
-                    node.typeParameters.map(param => ts$1.createTypeReferenceNode(param.name, undefined));
-            }
-            else {
-                typeArguments =
-                    node.typeParameters.map(() => ts$1.createKeywordTypeNode(ts$1.SyntaxKind.AnyKeyword));
-            }
-        }
-        const type = ts$1.createTypeReferenceNode(name, typeArguments);
-        return ts$1.createParameter(
+    function tcbCtxParam(node, name, typeArguments) {
+        const type = ts$1.factory.createTypeReferenceNode(name, typeArguments);
+        return ts$1.factory.createParameterDeclaration(
         /* decorators */ undefined, 
         /* modifiers */ undefined, 
         /* dotDotDotToken */ undefined, 
@@ -37719,9 +38292,9 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.nextTcbId = 1;
             this.tcbStatements = [];
         }
-        addTypeCheckBlock(ref, meta, domSchemaChecker, oobRecorder) {
+        addTypeCheckBlock(ref, meta, domSchemaChecker, oobRecorder, genericContextBehavior) {
             const fnId = ts$1.createIdentifier(`_tcb${this.nextTcbId++}`);
-            const fn = generateTypeCheckBlock(this, ref, fnId, meta, domSchemaChecker, oobRecorder);
+            const fn = generateTypeCheckBlock(this, ref, fnId, meta, domSchemaChecker, oobRecorder, genericContextBehavior);
             this.tcbStatements.push(fn);
         }
         render(removeComments) {
@@ -37780,7 +38353,7 @@ Either add the @Injectable() decorator to '${provider.node.name
      * type checked.
      */
     class TypeCheckContextImpl {
-        constructor(config, compilerHost, componentMappingStrategy, refEmitter, reflector, host, inlining) {
+        constructor(config, compilerHost, componentMappingStrategy, refEmitter, reflector, host, inlining, perf) {
             this.config = config;
             this.compilerHost = compilerHost;
             this.componentMappingStrategy = componentMappingStrategy;
@@ -37788,6 +38361,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.reflector = reflector;
             this.host = host;
             this.inlining = inlining;
+            this.perf = perf;
             this.fileMap = new Map();
             /**
              * A `Map` of `ts.SourceFile`s that the context has seen to the operations (additions of methods
@@ -37852,15 +38426,17 @@ Either add the @Injectable() decorator to '${provider.node.name
                 boundTarget,
                 templateDiagnostics,
             });
-            const tcbRequiresInline = requiresInlineTypeCheckBlock(ref.node, pipes);
+            const inliningRequirement = requiresInlineTypeCheckBlock(ref.node, pipes, this.reflector);
             // If inlining is not supported, but is required for either the TCB or one of its directive
             // dependencies, then exit here with an error.
-            if (this.inlining === InliningMode.Error && tcbRequiresInline) {
+            if (this.inlining === InliningMode.Error &&
+                inliningRequirement === TcbInliningRequirement.MustInline) {
                 // This template cannot be supported because the underlying strategy does not support inlining
                 // and inlining would be required.
                 // Record diagnostics to indicate the issues with this template.
                 shimData.oobRecorder.requiresInlineTcb(templateId, ref.node);
                 // Checking this template would be unsupported, so don't try.
+                this.perf.eventCount(PerfEvent.SkipGenerateTcbNoInline);
                 return;
             }
             const meta = {
@@ -37869,14 +38445,24 @@ Either add the @Injectable() decorator to '${provider.node.name
                 pipes,
                 schemas,
             };
-            if (tcbRequiresInline) {
+            this.perf.eventCount(PerfEvent.GenerateTcb);
+            if (inliningRequirement !== TcbInliningRequirement.None &&
+                this.inlining === InliningMode.InlineOps) {
                 // This class didn't meet the requirements for external type checking, so generate an inline
                 // TCB for the class.
                 this.addInlineTypeCheckBlock(fileData, shimData, ref, meta);
             }
+            else if (inliningRequirement === TcbInliningRequirement.ShouldInlineForGenericBounds &&
+                this.inlining === InliningMode.Error) {
+                // It's suggested that this TCB should be generated inline due to the component's generic
+                // bounds, but inlining is not supported by the current environment. Use a non-inline type
+                // check block, but fall back to `any` generic parameters since the generic bounds can't be
+                // referenced in that context. This will infer a less useful type for the component, but allow
+                // for type-checking it in an environment where that would not be possible otherwise.
+                shimData.file.addTypeCheckBlock(ref, meta, shimData.domSchemaChecker, shimData.oobRecorder, TcbGenericContextBehavior.FallbackToAny);
+            }
             else {
-                // The class can be type-checked externally as normal.
-                shimData.file.addTypeCheckBlock(ref, meta, shimData.domSchemaChecker, shimData.oobRecorder);
+                shimData.file.addTypeCheckBlock(ref, meta, shimData.domSchemaChecker, shimData.oobRecorder, TcbGenericContextBehavior.UseEmitter);
             }
         }
         /**
@@ -37966,7 +38552,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                 this.opMap.set(sf, []);
             }
             const ops = this.opMap.get(sf);
-            ops.push(new TcbOp$1(ref, tcbMeta, this.config, this.reflector, shimData.domSchemaChecker, shimData.oobRecorder));
+            ops.push(new InlineTcbOp(ref, tcbMeta, this.config, this.reflector, shimData.domSchemaChecker, shimData.oobRecorder));
             fileData.hasInlines = true;
         }
         pendingShimForComponent(node) {
@@ -38009,9 +38595,9 @@ Either add the @Injectable() decorator to '${provider.node.name
         }
     }
     /**
-     * A type check block operation which produces type check code for a particular component.
+     * A type check block operation which produces inline type check code for a particular component.
      */
-    class TcbOp$1 {
+    class InlineTcbOp {
         constructor(ref, meta, config, reflector, domSchemaChecker, oobRecorder) {
             this.ref = ref;
             this.meta = meta;
@@ -38029,7 +38615,9 @@ Either add the @Injectable() decorator to '${provider.node.name
         execute(im, sf, refEmitter, printer) {
             const env = new Environment(this.config, im, refEmitter, this.reflector, sf);
             const fnName = ts$1.createIdentifier(`_tcb_${this.ref.node.pos}`);
-            const fn = generateTypeCheckBlock(env, this.ref, fnName, this.meta, this.domSchemaChecker, this.oobRecorder);
+            // Inline TCBs should copy any generic type parameter nodes directly, as the TCB code is inlined
+            // into the class in a context where that will always be legal.
+            const fn = generateTypeCheckBlock(env, this.ref, fnName, this.meta, this.domSchemaChecker, this.oobRecorder, TcbGenericContextBehavior.CopyClassNodes);
             return printer.printNode(ts$1.EmitHint.Unspecified, fn, sf);
         }
     }
@@ -38685,7 +39273,7 @@ Either add the @Injectable() decorator to '${provider.node.name
      * `ProgramTypeCheckAdapter` for generation of template type-checking code.
      */
     class TemplateTypeCheckerImpl {
-        constructor(originalProgram, typeCheckingStrategy, typeCheckAdapter, config, refEmitter, reflector, compilerHost, priorBuild, componentScopeReader, typeCheckScopeRegistry) {
+        constructor(originalProgram, typeCheckingStrategy, typeCheckAdapter, config, refEmitter, reflector, compilerHost, priorBuild, componentScopeReader, typeCheckScopeRegistry, perf) {
             this.originalProgram = originalProgram;
             this.typeCheckingStrategy = typeCheckingStrategy;
             this.typeCheckAdapter = typeCheckAdapter;
@@ -38696,6 +39284,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.priorBuild = priorBuild;
             this.componentScopeReader = componentScopeReader;
             this.typeCheckScopeRegistry = typeCheckScopeRegistry;
+            this.perf = perf;
             this.state = new Map();
             /**
              * Stores the `CompletionEngine` which powers autocompletion for each component class.
@@ -38807,65 +39396,69 @@ Either add the @Injectable() decorator to '${provider.node.name
                     this.ensureAllShimsForOneFile(sf);
                     break;
             }
-            const sfPath = absoluteFromSourceFile(sf);
-            const fileRecord = this.state.get(sfPath);
-            const typeCheckProgram = this.typeCheckingStrategy.getProgram();
-            const diagnostics = [];
-            if (fileRecord.hasInlines) {
-                const inlineSf = getSourceFileOrError(typeCheckProgram, sfPath);
-                diagnostics.push(...typeCheckProgram.getSemanticDiagnostics(inlineSf).map(diag => convertDiagnostic(diag, fileRecord.sourceManager)));
-            }
-            for (const [shimPath, shimRecord] of fileRecord.shimData) {
+            return this.perf.inPhase(PerfPhase.TtcDiagnostics, () => {
+                const sfPath = absoluteFromSourceFile(sf);
+                const fileRecord = this.state.get(sfPath);
+                const typeCheckProgram = this.typeCheckingStrategy.getProgram();
+                const diagnostics = [];
+                if (fileRecord.hasInlines) {
+                    const inlineSf = getSourceFileOrError(typeCheckProgram, sfPath);
+                    diagnostics.push(...typeCheckProgram.getSemanticDiagnostics(inlineSf).map(diag => convertDiagnostic(diag, fileRecord.sourceManager)));
+                }
+                for (const [shimPath, shimRecord] of fileRecord.shimData) {
+                    const shimSf = getSourceFileOrError(typeCheckProgram, shimPath);
+                    diagnostics.push(...typeCheckProgram.getSemanticDiagnostics(shimSf).map(diag => convertDiagnostic(diag, fileRecord.sourceManager)));
+                    diagnostics.push(...shimRecord.genesisDiagnostics);
+                    for (const templateData of shimRecord.templates.values()) {
+                        diagnostics.push(...templateData.templateDiagnostics);
+                    }
+                }
+                return diagnostics.filter((diag) => diag !== null);
+            });
+        }
+        getDiagnosticsForComponent(component) {
+            this.ensureShimForComponent(component);
+            return this.perf.inPhase(PerfPhase.TtcDiagnostics, () => {
+                const sf = component.getSourceFile();
+                const sfPath = absoluteFromSourceFile(sf);
+                const shimPath = this.typeCheckingStrategy.shimPathForComponent(component);
+                const fileRecord = this.getFileData(sfPath);
+                if (!fileRecord.shimData.has(shimPath)) {
+                    return [];
+                }
+                const templateId = fileRecord.sourceManager.getTemplateId(component);
+                const shimRecord = fileRecord.shimData.get(shimPath);
+                const typeCheckProgram = this.typeCheckingStrategy.getProgram();
+                const diagnostics = [];
+                if (shimRecord.hasInlines) {
+                    const inlineSf = getSourceFileOrError(typeCheckProgram, sfPath);
+                    diagnostics.push(...typeCheckProgram.getSemanticDiagnostics(inlineSf).map(diag => convertDiagnostic(diag, fileRecord.sourceManager)));
+                }
                 const shimSf = getSourceFileOrError(typeCheckProgram, shimPath);
                 diagnostics.push(...typeCheckProgram.getSemanticDiagnostics(shimSf).map(diag => convertDiagnostic(diag, fileRecord.sourceManager)));
                 diagnostics.push(...shimRecord.genesisDiagnostics);
                 for (const templateData of shimRecord.templates.values()) {
                     diagnostics.push(...templateData.templateDiagnostics);
                 }
-            }
-            return diagnostics.filter((diag) => diag !== null);
-        }
-        getDiagnosticsForComponent(component) {
-            this.ensureShimForComponent(component);
-            const sf = component.getSourceFile();
-            const sfPath = absoluteFromSourceFile(sf);
-            const shimPath = this.typeCheckingStrategy.shimPathForComponent(component);
-            const fileRecord = this.getFileData(sfPath);
-            if (!fileRecord.shimData.has(shimPath)) {
-                return [];
-            }
-            const templateId = fileRecord.sourceManager.getTemplateId(component);
-            const shimRecord = fileRecord.shimData.get(shimPath);
-            const typeCheckProgram = this.typeCheckingStrategy.getProgram();
-            const diagnostics = [];
-            if (shimRecord.hasInlines) {
-                const inlineSf = getSourceFileOrError(typeCheckProgram, sfPath);
-                diagnostics.push(...typeCheckProgram.getSemanticDiagnostics(inlineSf).map(diag => convertDiagnostic(diag, fileRecord.sourceManager)));
-            }
-            const shimSf = getSourceFileOrError(typeCheckProgram, shimPath);
-            diagnostics.push(...typeCheckProgram.getSemanticDiagnostics(shimSf).map(diag => convertDiagnostic(diag, fileRecord.sourceManager)));
-            diagnostics.push(...shimRecord.genesisDiagnostics);
-            for (const templateData of shimRecord.templates.values()) {
-                diagnostics.push(...templateData.templateDiagnostics);
-            }
-            return diagnostics.filter((diag) => diag !== null && diag.templateId === templateId);
+                return diagnostics.filter((diag) => diag !== null && diag.templateId === templateId);
+            });
         }
         getTypeCheckBlock(component) {
             return this.getLatestComponentState(component).tcb;
         }
-        getGlobalCompletions(context, component) {
+        getGlobalCompletions(context, component, node) {
             const engine = this.getOrCreateCompletionEngine(component);
             if (engine === null) {
                 return null;
             }
-            return engine.getGlobalCompletions(context);
+            return this.perf.inPhase(PerfPhase.TtcAutocompletion, () => engine.getGlobalCompletions(context, node));
         }
         getExpressionCompletionLocation(ast, component) {
             const engine = this.getOrCreateCompletionEngine(component);
             if (engine === null) {
                 return null;
             }
-            return engine.getExpressionCompletionLocation(ast);
+            return this.perf.inPhase(PerfPhase.TtcAutocompletion, () => engine.getExpressionCompletionLocation(ast));
         }
         invalidateClass(clazz) {
             this.completionCache.delete(clazz);
@@ -38906,43 +39499,48 @@ Either add the @Injectable() decorator to '${provider.node.name
             if (previousResults === null || !previousResults.isComplete) {
                 return;
             }
+            this.perf.eventCount(PerfEvent.ReuseTypeCheckFile);
             this.state.set(sfPath, previousResults);
         }
         ensureAllShimsForAllFiles() {
             if (this.isComplete) {
                 return;
             }
-            const host = new WholeProgramTypeCheckingHost(this);
-            const ctx = this.newContext(host);
-            for (const sf of this.originalProgram.getSourceFiles()) {
-                if (sf.isDeclarationFile || isShim(sf)) {
-                    continue;
+            this.perf.inPhase(PerfPhase.TcbGeneration, () => {
+                const host = new WholeProgramTypeCheckingHost(this);
+                const ctx = this.newContext(host);
+                for (const sf of this.originalProgram.getSourceFiles()) {
+                    if (sf.isDeclarationFile || isShim(sf)) {
+                        continue;
+                    }
+                    this.maybeAdoptPriorResultsForFile(sf);
+                    const sfPath = absoluteFromSourceFile(sf);
+                    const fileData = this.getFileData(sfPath);
+                    if (fileData.isComplete) {
+                        continue;
+                    }
+                    this.typeCheckAdapter.typeCheck(sf, ctx);
+                    fileData.isComplete = true;
                 }
+                this.updateFromContext(ctx);
+                this.isComplete = true;
+            });
+        }
+        ensureAllShimsForOneFile(sf) {
+            this.perf.inPhase(PerfPhase.TcbGeneration, () => {
                 this.maybeAdoptPriorResultsForFile(sf);
                 const sfPath = absoluteFromSourceFile(sf);
                 const fileData = this.getFileData(sfPath);
                 if (fileData.isComplete) {
-                    continue;
+                    // All data for this file is present and accounted for already.
+                    return;
                 }
+                const host = new SingleFileTypeCheckingHost(sfPath, fileData, this.typeCheckingStrategy, this);
+                const ctx = this.newContext(host);
                 this.typeCheckAdapter.typeCheck(sf, ctx);
                 fileData.isComplete = true;
-            }
-            this.updateFromContext(ctx);
-            this.isComplete = true;
-        }
-        ensureAllShimsForOneFile(sf) {
-            this.maybeAdoptPriorResultsForFile(sf);
-            const sfPath = absoluteFromSourceFile(sf);
-            const fileData = this.getFileData(sfPath);
-            if (fileData.isComplete) {
-                // All data for this file is present and accounted for already.
-                return;
-            }
-            const host = new SingleFileTypeCheckingHost(sfPath, fileData, this.typeCheckingStrategy, this);
-            const ctx = this.newContext(host);
-            this.typeCheckAdapter.typeCheck(sf, ctx);
-            fileData.isComplete = true;
-            this.updateFromContext(ctx);
+                this.updateFromContext(ctx);
+            });
         }
         ensureShimForComponent(component) {
             const sf = component.getSourceFile();
@@ -38962,7 +39560,7 @@ Either add the @Injectable() decorator to '${provider.node.name
         newContext(host) {
             const inlining = this.typeCheckingStrategy.supportsInlineOperations ? InliningMode.InlineOps :
                 InliningMode.Error;
-            return new TypeCheckContextImpl(this.config, this.compilerHost, this.typeCheckingStrategy, this.refEmitter, this.reflector, host, inlining);
+            return new TypeCheckContextImpl(this.config, this.compilerHost, this.typeCheckingStrategy, this.refEmitter, this.reflector, host, inlining, this.perf);
         }
         /**
          * Remove any shim data that depends on inline operations applied to the type-checking program.
@@ -38987,8 +39585,14 @@ Either add the @Injectable() decorator to '${provider.node.name
         }
         updateFromContext(ctx) {
             const updates = ctx.finalize();
-            this.typeCheckingStrategy.updateFiles(updates, UpdateMode.Incremental);
-            this.priorBuild.recordSuccessfulTypeCheck(this.state);
+            return this.perf.inPhase(PerfPhase.TcbUpdateProgram, () => {
+                if (updates.size > 0) {
+                    this.perf.eventCount(PerfEvent.UpdateTypeCheckProgram);
+                }
+                this.typeCheckingStrategy.updateFiles(updates, UpdateMode.Incremental);
+                this.priorBuild.recordSuccessfulTypeCheck(this.state);
+                this.perf.memory(PerfCheckpoint.TtcUpdateProgram);
+            });
         }
         getFileData(path) {
             if (!this.state.has(path)) {
@@ -39006,7 +39610,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             if (builder === null) {
                 return null;
             }
-            return builder.getSymbol(node);
+            return this.perf.inPhase(PerfPhase.TtcSymbol, () => builder.getSymbol(node));
         }
         getOrCreateSymbolBuilder(component) {
             if (this.symbolBuilderCache.has(component)) {
@@ -39265,7 +39869,7 @@ Either add the @Injectable() decorator to '${provider.node.name
     /**
      * Create a `CompilationTicket` for a brand new compilation, using no prior state.
      */
-    function freshCompilationTicket(tsProgram, options, incrementalBuildStrategy, typeCheckingProgramStrategy, enableTemplateTypeChecker, usePoisonedData) {
+    function freshCompilationTicket(tsProgram, options, incrementalBuildStrategy, typeCheckingProgramStrategy, perfRecorder, enableTemplateTypeChecker, usePoisonedData) {
         return {
             kind: CompilationTicketKind.Fresh,
             tsProgram,
@@ -39274,21 +39878,25 @@ Either add the @Injectable() decorator to '${provider.node.name
             typeCheckingProgramStrategy,
             enableTemplateTypeChecker,
             usePoisonedData,
+            perfRecorder: perfRecorder !== null && perfRecorder !== void 0 ? perfRecorder : ActivePerfRecorder.zeroedToNow(),
         };
     }
     /**
      * Create a `CompilationTicket` as efficiently as possible, based on a previous `NgCompiler`
      * instance and a new `ts.Program`.
      */
-    function incrementalFromCompilerTicket(oldCompiler, newProgram, incrementalBuildStrategy, typeCheckingProgramStrategy, modifiedResourceFiles) {
+    function incrementalFromCompilerTicket(oldCompiler, newProgram, incrementalBuildStrategy, typeCheckingProgramStrategy, modifiedResourceFiles, perfRecorder) {
         const oldProgram = oldCompiler.getNextProgram();
         const oldDriver = oldCompiler.incrementalStrategy.getIncrementalDriver(oldProgram);
         if (oldDriver === null) {
             // No incremental step is possible here, since no IncrementalDriver was found for the old
             // program.
-            return freshCompilationTicket(newProgram, oldCompiler.options, incrementalBuildStrategy, typeCheckingProgramStrategy, oldCompiler.enableTemplateTypeChecker, oldCompiler.usePoisonedData);
+            return freshCompilationTicket(newProgram, oldCompiler.options, incrementalBuildStrategy, typeCheckingProgramStrategy, perfRecorder, oldCompiler.enableTemplateTypeChecker, oldCompiler.usePoisonedData);
+        }
+        if (perfRecorder === null) {
+            perfRecorder = ActivePerfRecorder.zeroedToNow();
         }
-        const newDriver = IncrementalDriver.reconcile(oldProgram, oldDriver, newProgram, modifiedResourceFiles);
+        const newDriver = IncrementalDriver.reconcile(oldProgram, oldDriver, newProgram, modifiedResourceFiles, perfRecorder);
         return {
             kind: CompilationTicketKind.IncrementalTypeScript,
             enableTemplateTypeChecker: oldCompiler.enableTemplateTypeChecker,
@@ -39299,6 +39907,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             newDriver,
             oldProgram,
             newProgram,
+            perfRecorder,
         };
     }
     function resourceChangeTicket(compiler, modifiedResourceFiles) {
@@ -39306,6 +39915,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             kind: CompilationTicketKind.IncrementalResource,
             compiler,
             modifiedResourceFiles,
+            perfRecorder: ActivePerfRecorder.zeroedToNow(),
         };
     }
     /**
@@ -39321,7 +39931,7 @@ Either add the @Injectable() decorator to '${provider.node.name
      * See the README.md for more information.
      */
     class NgCompiler {
-        constructor(adapter, options, tsProgram, typeCheckingProgramStrategy, incrementalStrategy, incrementalDriver, enableTemplateTypeChecker, usePoisonedData, perfRecorder = NOOP_PERF_RECORDER) {
+        constructor(adapter, options, tsProgram, typeCheckingProgramStrategy, incrementalStrategy, incrementalDriver, enableTemplateTypeChecker, usePoisonedData, livePerfRecorder) {
             this.adapter = adapter;
             this.options = options;
             this.tsProgram = tsProgram;
@@ -39330,7 +39940,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.incrementalDriver = incrementalDriver;
             this.enableTemplateTypeChecker = enableTemplateTypeChecker;
             this.usePoisonedData = usePoisonedData;
-            this.perfRecorder = perfRecorder;
+            this.livePerfRecorder = livePerfRecorder;
             /**
              * Lazily evaluated state of the compilation.
              *
@@ -39350,6 +39960,13 @@ Either add the @Injectable() decorator to '${provider.node.name
              * This is set by (and memoizes) `getNonTemplateDiagnostics`.
              */
             this.nonTemplateDiagnostics = null;
+            /**
+             * `NgCompiler` can be reused for multiple compilations (for resource-only changes), and each
+             * new compilation uses a fresh `PerfRecorder`. Thus, classes created with a lifespan of the
+             * `NgCompiler` use a `DelegatingPerfRecorder` so the `PerfRecorder` they write to can be updated
+             * with each fresh compilation.
+             */
+            this.delegatingPerfRecorder = new DelegatingPerfRecorder(this.perfRecorder);
             this.constructionDiagnostics.push(...this.adapter.constructionDiagnostics);
             const incompatibleTypeCheckOptionsDiagnostic = verifyCompatibleTypeCheckOptions(this.options);
             if (incompatibleTypeCheckOptionsDiagnostic !== null) {
@@ -39360,9 +39977,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.entryPoint =
                 adapter.entryPoint !== null ? getSourceFileOrNull(tsProgram, adapter.entryPoint) : null;
             const moduleResolutionCache = ts$1.createModuleResolutionCache(this.adapter.getCurrentDirectory(), 
-            // Note: this used to be an arrow-function closure. However, JS engines like v8 have some
-            // strange behaviors with retaining the lexical scope of the closure. Even if this function
-            // doesn't retain a reference to `this`, if other closures in the constructor here reference
+            // doen't retain a reference to `this`, if other closures in the constructor here reference
             // `this` internally then a closure created here would retain them. This can cause major
             // memory leak issues since the `moduleResolutionCache` is a long-lived object and finds its
             // way into all kinds of places inside TS internal objects.
@@ -39370,55 +39985,75 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.moduleResolver =
                 new ModuleResolver(tsProgram, this.options, this.adapter, moduleResolutionCache);
             this.resourceManager = new AdapterResourceLoader(adapter, this.options);
-            this.cycleAnalyzer = new CycleAnalyzer(new ImportGraph(tsProgram.getTypeChecker()));
+            this.cycleAnalyzer =
+                new CycleAnalyzer(new ImportGraph(tsProgram.getTypeChecker(), this.delegatingPerfRecorder));
             this.incrementalStrategy.setIncrementalDriver(this.incrementalDriver, tsProgram);
             this.ignoreForDiagnostics =
                 new Set(tsProgram.getSourceFiles().filter(sf => this.adapter.isShim(sf)));
             this.ignoreForEmit = this.adapter.ignoreForEmit;
+            let dtsFileCount = 0;
+            let nonDtsFileCount = 0;
+            for (const sf of tsProgram.getSourceFiles()) {
+                if (sf.isDeclarationFile) {
+                    dtsFileCount++;
+                }
+                else {
+                    nonDtsFileCount++;
+                }
+            }
+            livePerfRecorder.eventCount(PerfEvent.InputDtsFile, dtsFileCount);
+            livePerfRecorder.eventCount(PerfEvent.InputTsFile, nonDtsFileCount);
         }
         /**
          * Convert a `CompilationTicket` into an `NgCompiler` instance for the requested compilation.
          *
          * Depending on the nature of the compilation request, the `NgCompiler` instance may be reused
          * from a previous compilation and updated with any changes, it may be a new instance which
-         * incrementally reuses state from a previous compilation, or it may represent a fresh compilation
-         * entirely.
+         * incrementally reuses state from a previous compilation, or it may represent a fresh
+         * compilation entirely.
          */
-        static fromTicket(ticket, adapter, perfRecorder) {
+        static fromTicket(ticket, adapter) {
             switch (ticket.kind) {
                 case CompilationTicketKind.Fresh:
-                    return new NgCompiler(adapter, ticket.options, ticket.tsProgram, ticket.typeCheckingProgramStrategy, ticket.incrementalBuildStrategy, IncrementalDriver.fresh(ticket.tsProgram), ticket.enableTemplateTypeChecker, ticket.usePoisonedData, perfRecorder);
+                    return new NgCompiler(adapter, ticket.options, ticket.tsProgram, ticket.typeCheckingProgramStrategy, ticket.incrementalBuildStrategy, IncrementalDriver.fresh(ticket.tsProgram), ticket.enableTemplateTypeChecker, ticket.usePoisonedData, ticket.perfRecorder);
                 case CompilationTicketKind.IncrementalTypeScript:
-                    return new NgCompiler(adapter, ticket.options, ticket.newProgram, ticket.typeCheckingProgramStrategy, ticket.incrementalBuildStrategy, ticket.newDriver, ticket.enableTemplateTypeChecker, ticket.usePoisonedData, perfRecorder);
+                    return new NgCompiler(adapter, ticket.options, ticket.newProgram, ticket.typeCheckingProgramStrategy, ticket.incrementalBuildStrategy, ticket.newDriver, ticket.enableTemplateTypeChecker, ticket.usePoisonedData, ticket.perfRecorder);
                 case CompilationTicketKind.IncrementalResource:
                     const compiler = ticket.compiler;
-                    compiler.updateWithChangedResources(ticket.modifiedResourceFiles);
+                    compiler.updateWithChangedResources(ticket.modifiedResourceFiles, ticket.perfRecorder);
                     return compiler;
             }
         }
-        updateWithChangedResources(changedResources) {
-            if (this.compilation === null) {
-                // Analysis hasn't happened yet, so no update is necessary - any changes to resources will be
-                // captured by the inital analysis pass itself.
-                return;
-            }
-            this.resourceManager.invalidate();
-            const classesToUpdate = new Set();
-            for (const resourceFile of changedResources) {
-                for (const templateClass of this.getComponentsWithTemplateFile(resourceFile)) {
-                    classesToUpdate.add(templateClass);
+        get perfRecorder() {
+            return this.livePerfRecorder;
+        }
+        updateWithChangedResources(changedResources, perfRecorder) {
+            this.livePerfRecorder = perfRecorder;
+            this.delegatingPerfRecorder.target = perfRecorder;
+            perfRecorder.inPhase(PerfPhase.ResourceUpdate, () => {
+                if (this.compilation === null) {
+                    // Analysis hasn't happened yet, so no update is necessary - any changes to resources will
+                    // be captured by the inital analysis pass itself.
+                    return;
                 }
-                for (const styleClass of this.getComponentsWithStyleFile(resourceFile)) {
-                    classesToUpdate.add(styleClass);
+                this.resourceManager.invalidate();
+                const classesToUpdate = new Set();
+                for (const resourceFile of changedResources) {
+                    for (const templateClass of this.getComponentsWithTemplateFile(resourceFile)) {
+                        classesToUpdate.add(templateClass);
+                    }
+                    for (const styleClass of this.getComponentsWithStyleFile(resourceFile)) {
+                        classesToUpdate.add(styleClass);
+                    }
                 }
-            }
-            for (const clazz of classesToUpdate) {
-                this.compilation.traitCompiler.updateResources(clazz);
-                if (!ts$1.isClassDeclaration(clazz)) {
-                    continue;
+                for (const clazz of classesToUpdate) {
+                    this.compilation.traitCompiler.updateResources(clazz);
+                    if (!ts$1.isClassDeclaration(clazz)) {
+                        continue;
+                    }
+                    this.compilation.templateTypeChecker.invalidateClass(clazz);
                 }
-                this.compilation.templateTypeChecker.invalidateClass(clazz);
-            }
+            });
         }
         /**
          * Get the resource dependencies of a file.
@@ -39525,29 +40160,23 @@ Either add the @Injectable() decorator to '${provider.node.name
                 if (this.compilation !== null) {
                     return;
                 }
-                this.compilation = this.makeCompilation();
-                const analyzeSpan = this.perfRecorder.start('analyze');
-                const promises = [];
-                for (const sf of this.tsProgram.getSourceFiles()) {
-                    if (sf.isDeclarationFile) {
-                        continue;
-                    }
-                    const analyzeFileSpan = this.perfRecorder.start('analyzeFile', sf);
-                    let analysisPromise = this.compilation.traitCompiler.analyzeAsync(sf);
-                    this.scanForMwp(sf);
-                    if (analysisPromise === undefined) {
-                        this.perfRecorder.stop(analyzeFileSpan);
-                    }
-                    else if (this.perfRecorder.enabled) {
-                        analysisPromise = analysisPromise.then(() => this.perfRecorder.stop(analyzeFileSpan));
-                    }
-                    if (analysisPromise !== undefined) {
-                        promises.push(analysisPromise);
+                yield this.perfRecorder.inPhase(PerfPhase.Analysis, () => __awaiter(this, void 0, void 0, function* () {
+                    this.compilation = this.makeCompilation();
+                    const promises = [];
+                    for (const sf of this.tsProgram.getSourceFiles()) {
+                        if (sf.isDeclarationFile) {
+                            continue;
+                        }
+                        let analysisPromise = this.compilation.traitCompiler.analyzeAsync(sf);
+                        this.scanForMwp(sf);
+                        if (analysisPromise !== undefined) {
+                            promises.push(analysisPromise);
+                        }
                     }
-                }
-                yield Promise.all(promises);
-                this.perfRecorder.stop(analyzeSpan);
-                this.resolveCompilation(this.compilation.traitCompiler);
+                    yield Promise.all(promises);
+                    this.perfRecorder.memory(PerfCheckpoint.Analysis);
+                    this.resolveCompilation(this.compilation.traitCompiler);
+                }));
             });
         }
         /**
@@ -39557,9 +40186,7 @@ Either add the @Injectable() decorator to '${provider.node.name
          */
         listLazyRoutes(entryRoute) {
             if (entryRoute) {
-                // Note:
-                // This resolution step is here to match the implementation of the old `AotCompilerHost` (see
-                // https://github.com/angular/angular/blob/50732e156/packages/compiler-cli/src/transformers/compiler_host.ts#L175-L188).
+                // htts://github.com/angular/angular/blob/50732e156/packages/compiler-cli/src/transformers/compiler_host.ts#L175-L188).
                 //
                 // `@angular/cli` will always call this API with an absolute path, so the resolution step is
                 // not necessary, but keeping it backwards compatible in case someone else is using the API.
@@ -39600,10 +40227,11 @@ Either add the @Injectable() decorator to '${provider.node.name
             else {
                 importRewriter = new NoopImportRewriter();
             }
+            const defaultImportTracker = new DefaultImportTracker();
             const before = [
-                ivyTransformFactory(compilation.traitCompiler, compilation.reflector, importRewriter, compilation.defaultImportTracker, compilation.isCore, this.closureCompilerEnabled),
+                ivyTransformFactory(compilation.traitCompiler, compilation.reflector, importRewriter, defaultImportTracker, this.delegatingPerfRecorder, compilation.isCore, this.closureCompilerEnabled),
                 aliasTransformFactory(compilation.traitCompiler.exportStatements),
-                compilation.defaultImportTracker.importPreservingTransformer(),
+                defaultImportTracker.importPreservingTransformer(),
             ];
             const afterDeclarations = [];
             if (compilation.dtsTransforms !== null) {
@@ -39637,25 +40265,27 @@ Either add the @Injectable() decorator to '${provider.node.name
             return this.compilation;
         }
         analyzeSync() {
-            const analyzeSpan = this.perfRecorder.start('analyze');
-            this.compilation = this.makeCompilation();
-            for (const sf of this.tsProgram.getSourceFiles()) {
-                if (sf.isDeclarationFile) {
-                    continue;
+            this.perfRecorder.inPhase(PerfPhase.Analysis, () => {
+                this.compilation = this.makeCompilation();
+                for (const sf of this.tsProgram.getSourceFiles()) {
+                    if (sf.isDeclarationFile) {
+                        continue;
+                    }
+                    this.compilation.traitCompiler.analyzeSync(sf);
+                    this.scanForMwp(sf);
                 }
-                const analyzeFileSpan = this.perfRecorder.start('analyzeFile', sf);
-                this.compilation.traitCompiler.analyzeSync(sf);
-                this.scanForMwp(sf);
-                this.perfRecorder.stop(analyzeFileSpan);
-            }
-            this.perfRecorder.stop(analyzeSpan);
-            this.resolveCompilation(this.compilation.traitCompiler);
+                this.perfRecorder.memory(PerfCheckpoint.Analysis);
+                this.resolveCompilation(this.compilation.traitCompiler);
+            });
         }
         resolveCompilation(traitCompiler) {
-            traitCompiler.resolve();
-            // At this point, analysis is complete and the compiler can now calculate which files need to
-            // be emitted, so do that.
-            this.incrementalDriver.recordSuccessfulAnalysis(traitCompiler);
+            this.perfRecorder.inPhase(PerfPhase.Resolve, () => {
+                traitCompiler.resolve();
+                // At this point, analysis is complete and the compiler can now calculate which files need to
+                // be emitted, so do that.
+                this.incrementalDriver.recordSuccessfulAnalysis(traitCompiler);
+                this.perfRecorder.memory(PerfCheckpoint.Resolve);
+            });
         }
         get fullTemplateTypeCheck() {
             // Determine the strictness level of type checking based on compiler options. As
@@ -39779,7 +40409,6 @@ Either add the @Injectable() decorator to '${provider.node.name
         getTemplateDiagnostics() {
             const compilation = this.ensureAnalyzed();
             // Get the diagnostics.
-            const typeCheckSpan = this.perfRecorder.start('typeCheckDiagnostics');
             const diagnostics = [];
             for (const sf of this.tsProgram.getSourceFiles()) {
                 if (sf.isDeclarationFile || this.adapter.isShim(sf)) {
@@ -39788,7 +40417,6 @@ Either add the @Injectable() decorator to '${provider.node.name
                 diagnostics.push(...compilation.templateTypeChecker.getDiagnosticsForFile(sf, OptimizeFor.WholeProgram));
             }
             const program = this.typeCheckingProgramStrategy.getProgram();
-            this.perfRecorder.stop(typeCheckSpan);
             this.incrementalStrategy.setIncrementalDriver(this.incrementalDriver, program);
             this.nextProgram = program;
             return diagnostics;
@@ -39796,13 +40424,11 @@ Either add the @Injectable() decorator to '${provider.node.name
         getTemplateDiagnosticsForFile(sf, optimizeFor) {
             const compilation = this.ensureAnalyzed();
             // Get the diagnostics.
-            const typeCheckSpan = this.perfRecorder.start('typeCheckDiagnostics');
             const diagnostics = [];
             if (!sf.isDeclarationFile && !this.adapter.isShim(sf)) {
                 diagnostics.push(...compilation.templateTypeChecker.getDiagnosticsForFile(sf, optimizeFor));
             }
             const program = this.typeCheckingProgramStrategy.getProgram();
-            this.perfRecorder.stop(typeCheckSpan);
             this.incrementalStrategy.setIncrementalDriver(this.incrementalDriver, program);
             this.nextProgram = program;
             return diagnostics;
@@ -39910,7 +40536,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             const dtsTransforms = new DtsTransformRegistry();
             const mwpScanner = new ModuleWithProvidersScanner(reflector, evaluator, refEmitter);
             const isCore = isAngularCorePackage(this.tsProgram);
-            const defaultImportTracker = new DefaultImportTracker();
             const resourceRegistry = new ResourceRegistry();
             const compilationMode = this.options.compilationMode === 'partial' ? CompilationMode.PARTIAL : CompilationMode.FULL;
             // Cycles are handled in full compilation mode by "remote scoping".
@@ -39921,20 +40546,20 @@ Either add the @Injectable() decorator to '${provider.node.name
                 1 /* Error */;
             // Set up the IvyCompilation, which manages state for the Ivy transformer.
             const handlers = [
-                new ComponentDecoratorHandler(reflector, evaluator, metaRegistry, metaReader, scopeReader, scopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, this.resourceManager, this.adapter.rootDirs, this.options.preserveWhitespaces || false, this.options.i18nUseExternalIds !== false, this.options.enableI18nLegacyMessageIdFormat !== false, this.usePoisonedData, this.options.i18nNormalizeLineEndingsInICUs, this.moduleResolver, this.cycleAnalyzer, cycleHandlingStrategy, refEmitter, defaultImportTracker, this.incrementalDriver.depGraph, injectableRegistry, semanticDepGraphUpdater, this.closureCompilerEnabled),
+                new ComponentDecoratorHandler(reflector, evaluator, metaRegistry, metaReader, scopeReader, scopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, this.resourceManager, this.adapter.rootDirs, this.options.preserveWhitespaces || false, this.options.i18nUseExternalIds !== false, this.options.enableI18nLegacyMessageIdFormat !== false, this.usePoisonedData, this.options.i18nNormalizeLineEndingsInICUs, this.moduleResolver, this.cycleAnalyzer, cycleHandlingStrategy, refEmitter, this.incrementalDriver.depGraph, injectableRegistry, semanticDepGraphUpdater, this.closureCompilerEnabled, this.delegatingPerfRecorder),
                 // TODO(alxhub): understand why the cast here is necessary (something to do with `null`
                 // not being assignable to `unknown` when wrapped in `Readonly`).
                 // clang-format off
-                new DirectiveDecoratorHandler(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, defaultImportTracker, injectableRegistry, isCore, semanticDepGraphUpdater, this.closureCompilerEnabled, compileUndecoratedClassesWithAngularFeatures),
+                new DirectiveDecoratorHandler(reflector, evaluator, metaRegistry, scopeRegistry, metaReader, injectableRegistry, isCore, semanticDepGraphUpdater, this.closureCompilerEnabled, compileUndecoratedClassesWithAngularFeatures, this.delegatingPerfRecorder),
                 // clang-format on
                 // Pipe handler must be before injectable handler in list so pipe factories are printed
                 // before injectable factories (so injectable factories can delegate to them)
-                new PipeDecoratorHandler(reflector, evaluator, metaRegistry, scopeRegistry, defaultImportTracker, injectableRegistry, isCore),
-                new InjectableDecoratorHandler(reflector, defaultImportTracker, isCore, this.options.strictInjectionParameters || false, injectableRegistry),
-                new NgModuleDecoratorHandler(reflector, evaluator, metaReader, metaRegistry, scopeRegistry, referencesRegistry, isCore, routeAnalyzer, refEmitter, this.adapter.factoryTracker, defaultImportTracker, this.closureCompilerEnabled, injectableRegistry, this.options.i18nInLocale),
+                new PipeDecoratorHandler(reflector, evaluator, metaRegistry, scopeRegistry, injectableRegistry, isCore, this.delegatingPerfRecorder),
+                new InjectableDecoratorHandler(reflector, isCore, this.options.strictInjectionParameters || false, injectableRegistry, this.delegatingPerfRecorder),
+                new NgModuleDecoratorHandler(reflector, evaluator, metaReader, metaRegistry, scopeRegistry, referencesRegistry, isCore, routeAnalyzer, refEmitter, this.adapter.factoryTracker, this.closureCompilerEnabled, injectableRegistry, this.delegatingPerfRecorder, this.options.i18nInLocale),
             ];
-            const traitCompiler = new TraitCompiler(handlers, reflector, this.perfRecorder, this.incrementalDriver, this.options.compileNonExportedClasses !== false, compilationMode, dtsTransforms, semanticDepGraphUpdater);
-            const templateTypeChecker = new TemplateTypeCheckerImpl(this.tsProgram, this.typeCheckingProgramStrategy, traitCompiler, this.getTypeCheckingConfig(), refEmitter, reflector, this.adapter, this.incrementalDriver, scopeRegistry, typeCheckScopeRegistry);
+            const traitCompiler = new TraitCompiler(handlers, reflector, this.delegatingPerfRecorder, this.incrementalDriver, this.options.compileNonExportedClasses !== false, compilationMode, dtsTransforms, semanticDepGraphUpdater);
+            const templateTypeChecker = new TemplateTypeCheckerImpl(this.tsProgram, this.typeCheckingProgramStrategy, traitCompiler, this.getTypeCheckingConfig(), refEmitter, reflector, this.adapter, this.incrementalDriver, scopeRegistry, typeCheckScopeRegistry, this.delegatingPerfRecorder);
             return {
                 isCore,
                 traitCompiler,
@@ -39946,7 +40571,6 @@ Either add the @Injectable() decorator to '${provider.node.name
                 mwpScanner,
                 metaReader,
                 typeCheckScopeRegistry,
-                defaultImportTracker,
                 aliasingHost,
                 refEmitter,
                 templateTypeChecker,
@@ -40127,24 +40751,30 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         };
     }
     function getExtendedConfigPath(configFile, extendsValue, host, fs) {
-        let extendedConfigPath = null;
+        const result = getExtendedConfigPathWorker(configFile, extendsValue, host, fs);
+        if (result !== null) {
+            return result;
+        }
+        // Try to resolve the paths with a json extension append a json extension to the file in case if
+        // it is missing and the resolution failed. This is to replicate TypeScript behaviour, see:
+        // https://github.com/microsoft/TypeScript/blob/294a5a7d784a5a95a8048ee990400979a6bc3a1c/src/compiler/commandLineParser.ts#L2806
+        return getExtendedConfigPathWorker(configFile, `${extendsValue}.json`, host, fs);
+    }
+    function getExtendedConfigPathWorker(configFile, extendsValue, host, fs) {
         if (extendsValue.startsWith('.') || fs.isRooted(extendsValue)) {
-            extendedConfigPath = host.resolve(host.dirname(configFile), extendsValue);
-            extendedConfigPath = host.extname(extendedConfigPath) ?
-                extendedConfigPath :
-                absoluteFrom(`${extendedConfigPath}.json`);
+            const extendedConfigPath = host.resolve(host.dirname(configFile), extendsValue);
+            if (host.exists(extendedConfigPath)) {
+                return extendedConfigPath;
+            }
         }
         else {
             const parseConfigHost = createParseConfigHost(host, fs);
             // Path isn't a rooted or relative path, resolve like a module.
             const { resolvedModule, } = ts$1.nodeModuleNameResolver(extendsValue, configFile, { moduleResolution: ts$1.ModuleResolutionKind.NodeJs, resolveJsonModule: true }, parseConfigHost);
             if (resolvedModule) {
-                extendedConfigPath = absoluteFrom(resolvedModule.resolvedFileName);
+                return absoluteFrom(resolvedModule.resolvedFileName);
             }
         }
-        if (extendedConfigPath !== null && host.exists(extendedConfigPath)) {
-            return extendedConfigPath;
-        }
         return null;
     }
 
@@ -40515,7 +41145,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
      */
     function toAttributeString(attribute) {
         var _a, _b;
-        if (attribute instanceof BoundEvent) {
+        if (attribute instanceof BoundEvent || attribute instanceof BoundAttribute) {
             return `[${attribute.name}]`;
         }
         else {
@@ -40693,6 +41323,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
      * 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
      */
+    const PRE_COMPILED_STYLE_EXTENSIONS = ['.scss', '.sass', '.less', '.styl'];
     class LanguageServiceAdapter {
         constructor(project) {
             this.project = project;
@@ -40709,6 +41340,22 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             this.lastReadResourceVersion = new Map();
             this.rootDirs = getRootDirs(this, project.getCompilationSettings());
         }
+        resourceNameToFileName(url, fromFile, fallbackResolve) {
+            var _a;
+            // If we are trying to resolve a `.css` file, see if we can find a pre-compiled file with the
+            // same name instead. That way, we can provide go-to-definition for the pre-compiled files which
+            // would generally be the desired behavior.
+            if (url.endsWith('.css')) {
+                const styleUrl = path.resolve(fromFile, '..', url);
+                for (const ext of PRE_COMPILED_STYLE_EXTENSIONS) {
+                    const precompiledFileUrl = styleUrl.replace(/\.css$/, ext);
+                    if (this.fileExists(precompiledFileUrl)) {
+                        return precompiledFileUrl;
+                    }
+                }
+            }
+            return (_a = fallbackResolve === null || fallbackResolve === void 0 ? void 0 : fallbackResolve(url, fromFile)) !== null && _a !== void 0 ? _a : null;
+        }
         isShim(sf) {
             return isShim(sf);
         }
@@ -40853,14 +41500,20 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                     const ticket = resourceChangeTicket(this.compiler, modifiedResourceFiles);
                     this.compiler = NgCompiler.fromTicket(ticket, this.adapter);
                 }
+                else {
+                    // The previous NgCompiler is being reused, but we still want to reset its performance
+                    // tracker to capture only the operations that are needed to service the current request.
+                    this.compiler.perfRecorder.reset();
+                }
                 return this.compiler;
             }
             let ticket;
             if (this.compiler === null || this.lastKnownProgram === null) {
-                ticket = freshCompilationTicket(program, this.options, this.incrementalStrategy, this.programStrategy, true, true);
+                ticket = freshCompilationTicket(program, this.options, this.incrementalStrategy, this.programStrategy, 
+                /* perfRecorder */ null, true, true);
             }
             else {
-                ticket = incrementalFromCompilerTicket(this.compiler, program, this.incrementalStrategy, this.programStrategy, modifiedResourceFiles);
+                ticket = incrementalFromCompilerTicket(this.compiler, program, this.incrementalStrategy, this.programStrategy, modifiedResourceFiles, /* perfRecorder */ null);
             }
             this.compiler = NgCompiler.fromTicket(ticket, this.adapter);
             this.lastKnownProgram = program;
@@ -41762,17 +42415,17 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
          * Get completions for a property expression in a global context (e.g. `{{y|}}`).
          */
         getGlobalPropertyExpressionCompletion(options) {
-            const completions = this.templateTypeChecker.getGlobalCompletions(this.template, this.component);
+            const completions = this.templateTypeChecker.getGlobalCompletions(this.template, this.component, this.node);
             if (completions === null) {
                 return undefined;
             }
-            const { componentContext, templateContext } = completions;
+            const { componentContext, templateContext, nodeContext: astContext } = completions;
             const replacementSpan = makeReplacementSpanFromAst(this.node);
             // Merge TS completion results with results from the template scope.
             let entries = [];
-            const tsLsCompletions = this.tsLS.getCompletionsAtPosition(componentContext.shimPath, componentContext.positionInShimFile, options);
-            if (tsLsCompletions !== undefined) {
-                for (const tsCompletion of tsLsCompletions.entries) {
+            const componentCompletions = this.tsLS.getCompletionsAtPosition(componentContext.shimPath, componentContext.positionInShimFile, options);
+            if (componentCompletions !== undefined) {
+                for (const tsCompletion of componentCompletions.entries) {
                     // Skip completions that are shadowed by a template entity definition.
                     if (templateContext.has(tsCompletion.name)) {
                         continue;
@@ -41783,6 +42436,20 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                         replacementSpan }));
                 }
             }
+            // Merge TS completion results with results from the ast context.
+            if (astContext !== null) {
+                const nodeCompletions = this.tsLS.getCompletionsAtPosition(astContext.shimPath, astContext.positionInShimFile, options);
+                if (nodeCompletions !== undefined) {
+                    for (const tsCompletion of nodeCompletions.entries) {
+                        if (this.isValidNodeContextCompletion(tsCompletion)) {
+                            entries.push(Object.assign(Object.assign({}, tsCompletion), { 
+                                // Substitute the TS completion's `replacementSpan` (which uses offsets within the
+                                // TCB) with the `replacementSpan` within the template source.
+                                replacementSpan }));
+                        }
+                    }
+                }
+            }
             for (const [name, entity] of templateContext) {
                 entries.push({
                     name,
@@ -41808,7 +42475,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
          * `{{y|}}`).
          */
         getGlobalPropertyExpressionCompletionDetails(entryName, formatOptions, preferences) {
-            const completions = this.templateTypeChecker.getGlobalCompletions(this.template, this.component);
+            const completions = this.templateTypeChecker.getGlobalCompletions(this.template, this.component, this.node);
             if (completions === null) {
                 return undefined;
             }
@@ -41841,7 +42508,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
          * `{{y|}}`).
          */
         getGlobalPropertyExpressionCompletionSymbol(entryName) {
-            const completions = this.templateTypeChecker.getGlobalCompletions(this.template, this.component);
+            const completions = this.templateTypeChecker.getGlobalCompletions(this.template, this.component, this.node);
             if (completions === null) {
                 return undefined;
             }
@@ -42113,6 +42780,24 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                 isNewIdentifierLocation: false,
             };
         }
+        /**
+         * From the AST node of the cursor position, include completion of string literals, number
+         * literals, `true`, `false`, `null`, and `undefined`.
+         */
+        isValidNodeContextCompletion(completion) {
+            if (completion.kind === ts$1.ScriptElementKind.string) {
+                // 'string' kind includes both string literals and number literals
+                return true;
+            }
+            if (completion.kind === ts$1.ScriptElementKind.keyword) {
+                return completion.name === 'true' || completion.name === 'false' ||
+                    completion.name === 'null';
+            }
+            if (completion.kind === ts$1.ScriptElementKind.variableElement) {
+                return completion.name === 'undefined';
+            }
+            return false;
+        }
     }
     function makeReplacementSpanFromParseSourceSpan(span) {
         return {
@@ -42664,43 +43349,50 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             this.ttc = this.compiler.getTemplateTypeChecker();
         }
         getRenameInfo(filePath, position) {
-            const templateInfo = getTemplateInfoAtPosition(filePath, position, this.compiler);
-            // We could not get a template at position so we assume the request came from outside the
-            // template.
-            if (templateInfo === undefined) {
-                return this.tsLS.getRenameInfo(filePath, position);
-            }
-            const allTargetDetails = this.getTargetDetailsAtTemplatePosition(templateInfo, position);
-            if (allTargetDetails === null) {
-                return { canRename: false, localizedErrorMessage: 'Could not find template node at position.' };
-            }
-            const { templateTarget } = allTargetDetails[0];
-            const templateTextAndSpan = getRenameTextAndSpanAtPosition(templateTarget, position);
-            if (templateTextAndSpan === null) {
-                return { canRename: false, localizedErrorMessage: 'Could not determine template node text.' };
-            }
-            const { text, span } = templateTextAndSpan;
-            return {
-                canRename: true,
-                displayName: text,
-                fullDisplayName: text,
-                triggerSpan: span,
-            };
+            return this.compiler.perfRecorder.inPhase(PerfPhase.LsReferencesAndRenames, () => {
+                const templateInfo = getTemplateInfoAtPosition(filePath, position, this.compiler);
+                // We could not get a template at position so we assume the request came from outside the
+                // template.
+                if (templateInfo === undefined) {
+                    return this.tsLS.getRenameInfo(filePath, position);
+                }
+                const allTargetDetails = this.getTargetDetailsAtTemplatePosition(templateInfo, position);
+                if (allTargetDetails === null) {
+                    return {
+                        canRename: false,
+                        localizedErrorMessage: 'Could not find template node at position.',
+                    };
+                }
+                const { templateTarget } = allTargetDetails[0];
+                const templateTextAndSpan = getRenameTextAndSpanAtPosition(templateTarget, position);
+                if (templateTextAndSpan === null) {
+                    return { canRename: false, localizedErrorMessage: 'Could not determine template node text.' };
+                }
+                const { text, span } = templateTextAndSpan;
+                return {
+                    canRename: true,
+                    displayName: text,
+                    fullDisplayName: text,
+                    triggerSpan: span,
+                };
+            });
         }
         findRenameLocations(filePath, position) {
             this.ttc.generateAllTypeCheckBlocks();
-            const templateInfo = getTemplateInfoAtPosition(filePath, position, this.compiler);
-            // We could not get a template at position so we assume the request came from outside the
-            // template.
-            if (templateInfo === undefined) {
-                const requestNode = this.getTsNodeAtPosition(filePath, position);
-                if (requestNode === null) {
-                    return undefined;
+            return this.compiler.perfRecorder.inPhase(PerfPhase.LsReferencesAndRenames, () => {
+                const templateInfo = getTemplateInfoAtPosition(filePath, position, this.compiler);
+                // We could not get a template at position so we assume the request came from outside the
+                // template.
+                if (templateInfo === undefined) {
+                    const requestNode = this.getTsNodeAtPosition(filePath, position);
+                    if (requestNode === null) {
+                        return undefined;
+                    }
+                    const requestOrigin = { kind: RequestKind.TypeScript, requestNode };
+                    return this.findRenameLocationsAtTypescriptPosition(filePath, position, requestOrigin);
                 }
-                const requestOrigin = { kind: RequestKind.TypeScript, requestNode };
-                return this.findRenameLocationsAtTypescriptPosition(filePath, position, requestOrigin);
-            }
-            return this.findRenameLocationsAtTemplatePosition(templateInfo, position);
+                return this.findRenameLocationsAtTemplatePosition(templateInfo, position);
+            });
         }
         findRenameLocationsAtTemplatePosition(templateInfo, position) {
             const allTargetDetails = this.getTargetDetailsAtTemplatePosition(templateInfo, position);
@@ -42735,52 +43427,56 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             return (_a = findTightestNode(sf, position)) !== null && _a !== void 0 ? _a : null;
         }
         findRenameLocationsAtTypescriptPosition(filePath, position, requestOrigin) {
-            let originalNodeText;
-            if (requestOrigin.kind === RequestKind.TypeScript) {
-                originalNodeText = requestOrigin.requestNode.getText();
-            }
-            else {
-                const templateNodeText = getRenameTextAndSpanAtPosition(requestOrigin.requestNode, requestOrigin.position);
-                if (templateNodeText === null) {
-                    return undefined;
+            return this.compiler.perfRecorder.inPhase(PerfPhase.LsReferencesAndRenames, () => {
+                let originalNodeText;
+                if (requestOrigin.kind === RequestKind.TypeScript) {
+                    originalNodeText = requestOrigin.requestNode.getText();
                 }
-                originalNodeText = templateNodeText.text;
-            }
-            const locations = this.tsLS.findRenameLocations(filePath, position, /*findInStrings*/ false, /*findInComments*/ false);
-            if (locations === undefined) {
-                return undefined;
-            }
-            const entries = new Map();
-            for (const location of locations) {
-                // TODO(atscott): Determine if a file is a shim file in a more robust way and make the API
-                // available in an appropriate location.
-                if (this.ttc.isTrackedTypeCheckFile(absoluteFrom(location.fileName))) {
-                    const entry = this.convertToTemplateDocumentSpan(location, this.ttc, originalNodeText);
-                    // There is no template node whose text matches the original rename request. Bail on
-                    // renaming completely rather than providing incomplete results.
-                    if (entry === null) {
+                else {
+                    const templateNodeText = getRenameTextAndSpanAtPosition(requestOrigin.requestNode, requestOrigin.position);
+                    if (templateNodeText === null) {
                         return undefined;
                     }
-                    entries.set(createLocationKey(entry), entry);
+                    originalNodeText = templateNodeText.text;
                 }
-                else {
-                    // Ensure we only allow renaming a TS result with matching text
-                    const refNode = this.getTsNodeAtPosition(location.fileName, location.textSpan.start);
-                    if (refNode === null || refNode.getText() !== originalNodeText) {
-                        return undefined;
+                const locations = this.tsLS.findRenameLocations(filePath, position, /*findInStrings*/ false, /*findInComments*/ false);
+                if (locations === undefined) {
+                    return undefined;
+                }
+                const entries = new Map();
+                for (const location of locations) {
+                    // TODO(atscott): Determine if a file is a shim file in a more robust way and make the API
+                    // available in an appropriate location.
+                    if (this.ttc.isTrackedTypeCheckFile(absoluteFrom(location.fileName))) {
+                        const entry = this.convertToTemplateDocumentSpan(location, this.ttc, originalNodeText);
+                        // There is no template node whose text matches the original rename request. Bail on
+                        // renaming completely rather than providing incomplete results.
+                        if (entry === null) {
+                            return undefined;
+                        }
+                        entries.set(createLocationKey(entry), entry);
+                    }
+                    else {
+                        // Ensure we only allow renaming a TS result with matching text
+                        const refNode = this.getTsNodeAtPosition(location.fileName, location.textSpan.start);
+                        if (refNode === null || refNode.getText() !== originalNodeText) {
+                            return undefined;
+                        }
+                        entries.set(createLocationKey(location), location);
                     }
-                    entries.set(createLocationKey(location), location);
                 }
-            }
-            return Array.from(entries.values());
+                return Array.from(entries.values());
+            });
         }
         getReferencesAtPosition(filePath, position) {
             this.ttc.generateAllTypeCheckBlocks();
-            const templateInfo = getTemplateInfoAtPosition(filePath, position, this.compiler);
-            if (templateInfo === undefined) {
-                return this.getReferencesAtTypescriptPosition(filePath, position);
-            }
-            return this.getReferencesAtTemplatePosition(templateInfo, position);
+            return this.compiler.perfRecorder.inPhase(PerfPhase.LsReferencesAndRenames, () => {
+                const templateInfo = getTemplateInfoAtPosition(filePath, position, this.compiler);
+                if (templateInfo === undefined) {
+                    return this.getReferencesAtTypescriptPosition(filePath, position);
+                }
+                return this.getReferencesAtTemplatePosition(templateInfo, position);
+            });
         }
         getReferencesAtTemplatePosition(templateInfo, position) {
             const allTargetDetails = this.getTargetDetailsAtTemplatePosition(templateInfo, position);
@@ -43021,49 +43717,52 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             return this.options;
         }
         getSemanticDiagnostics(fileName) {
-            const compiler = this.compilerFactory.getOrCreate();
-            const ttc = compiler.getTemplateTypeChecker();
-            const diagnostics = [];
-            if (isTypeScriptFile(fileName)) {
-                const program = compiler.getNextProgram();
-                const sourceFile = program.getSourceFile(fileName);
-                if (sourceFile) {
-                    const ngDiagnostics = compiler.getDiagnosticsForFile(sourceFile, OptimizeFor.SingleFile);
-                    // There are several kinds of diagnostics returned by `NgCompiler` for a source file:
-                    //
-                    // 1. Angular-related non-template diagnostics from decorated classes within that file.
-                    // 2. Template diagnostics for components with direct inline templates (a string literal).
-                    // 3. Template diagnostics for components with indirect inline templates (templates computed
-                    //    by expression).
-                    // 4. Template diagnostics for components with external templates.
-                    //
-                    // When showing diagnostics for a TS source file, we want to only include kinds 1 and 2 -
-                    // those diagnostics which are reported at a location within the TS file itself. Diagnostics
-                    // for external templates will be shown when editing that template file (the `else` block)
-                    // below.
-                    //
-                    // Currently, indirect inline template diagnostics (kind 3) are not shown at all by the
-                    // Language Service, because there is no sensible location in the user's code for them. Such
-                    // templates are an edge case, though, and should not be common.
-                    //
-                    // TODO(alxhub): figure out a good user experience for indirect template diagnostics and
-                    // show them from within the Language Service.
-                    diagnostics.push(...ngDiagnostics.filter(diag => diag.file !== undefined && diag.file.fileName === sourceFile.fileName));
+            return this.withCompilerAndPerfTracing(PerfPhase.LsDiagnostics, (compiler) => {
+                const ttc = compiler.getTemplateTypeChecker();
+                const diagnostics = [];
+                if (isTypeScriptFile(fileName)) {
+                    const program = compiler.getNextProgram();
+                    const sourceFile = program.getSourceFile(fileName);
+                    if (sourceFile) {
+                        const ngDiagnostics = compiler.getDiagnosticsForFile(sourceFile, OptimizeFor.SingleFile);
+                        // There are several kinds of diagnostics returned by `NgCompiler` for a source file:
+                        //
+                        // 1. Angular-related non-template diagnostics from decorated classes within that
+                        // file.
+                        // 2. Template diagnostics for components with direct inline templates (a string
+                        // literal).
+                        // 3. Template diagnostics for components with indirect inline templates (templates
+                        // computed
+                        //    by expression).
+                        // 4. Template diagnostics for components with external templates.
+                        //
+                        // When showing diagnostics for a TS source file, we want to only include kinds 1 and
+                        // 2 - those diagnostics which are reported at a location within the TS file itself.
+                        // Diagnostics for external templates will be shown when editing that template file
+                        // (the `else` block) below.
+                        //
+                        // Currently, indirect inline template diagnostics (kind 3) are not shown at all by
+                        // the Language Service, because there is no sensible location in the user's code for
+                        // them. Such templates are an edge case, though, and should not be common.
+                        //
+                        // TODO(alxhub): figure out a good user experience for indirect template diagnostics
+                        // and show them from within the Language Service.
+                        diagnostics.push(...ngDiagnostics.filter(diag => diag.file !== undefined && diag.file.fileName === sourceFile.fileName));
+                    }
                 }
-            }
-            else {
-                const components = compiler.getComponentsWithTemplateFile(fileName);
-                for (const component of components) {
-                    if (ts.isClassDeclaration(component)) {
-                        diagnostics.push(...ttc.getDiagnosticsForComponent(component));
+                else {
+                    const components = compiler.getComponentsWithTemplateFile(fileName);
+                    for (const component of components) {
+                        if (ts.isClassDeclaration(component)) {
+                            diagnostics.push(...ttc.getDiagnosticsForComponent(component));
+                        }
                     }
                 }
-            }
-            this.compilerFactory.registerLastKnownProgram();
-            return diagnostics;
+                return diagnostics;
+            });
         }
         getDefinitionAndBoundSpan(fileName, position) {
-            return this.withCompiler((compiler) => {
+            return this.withCompilerAndPerfTracing(PerfPhase.LsDefinition, (compiler) => {
                 if (!isInAngularContext(compiler.getNextProgram(), fileName, position)) {
                     return undefined;
                 }
@@ -43072,7 +43771,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             });
         }
         getTypeDefinitionAtPosition(fileName, position) {
-            return this.withCompiler((compiler) => {
+            return this.withCompilerAndPerfTracing(PerfPhase.LsDefinition, (compiler) => {
                 if (!isTemplateContext(compiler.getNextProgram(), fileName, position)) {
                     return undefined;
                 }
@@ -43081,56 +43780,57 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             });
         }
         getQuickInfoAtPosition(fileName, position) {
-            return this.withCompiler((compiler) => {
-                if (!isTemplateContext(compiler.getNextProgram(), fileName, position)) {
-                    return undefined;
-                }
-                const templateInfo = getTemplateInfoAtPosition(fileName, position, compiler);
-                if (templateInfo === undefined) {
-                    return undefined;
-                }
-                const positionDetails = getTargetAtPosition(templateInfo.template, position);
-                if (positionDetails === null) {
-                    return undefined;
-                }
-                // Because we can only show 1 quick info, just use the bound attribute if the target is a two
-                // way binding. We may consider concatenating additional display parts from the other target
-                // nodes or representing the two way binding in some other manner in the future.
-                const node = positionDetails.context.kind === TargetNodeKind.TwoWayBindingContext ?
-                    positionDetails.context.nodes[0] :
-                    positionDetails.context.node;
-                return new QuickInfoBuilder(this.tsLS, compiler, templateInfo.component, node).get();
+            return this.withCompilerAndPerfTracing(PerfPhase.LsQuickInfo, (compiler) => {
+                return this.getQuickInfoAtPositionImpl(fileName, position, compiler);
             });
         }
+        getQuickInfoAtPositionImpl(fileName, position, compiler) {
+            if (!isTemplateContext(compiler.getNextProgram(), fileName, position)) {
+                return undefined;
+            }
+            const templateInfo = getTemplateInfoAtPosition(fileName, position, compiler);
+            if (templateInfo === undefined) {
+                return undefined;
+            }
+            const positionDetails = getTargetAtPosition(templateInfo.template, position);
+            if (positionDetails === null) {
+                return undefined;
+            }
+            // Because we can only show 1 quick info, just use the bound attribute if the target is a two
+            // way binding. We may consider concatenating additional display parts from the other target
+            // nodes or representing the two way binding in some other manner in the future.
+            const node = positionDetails.context.kind === TargetNodeKind.TwoWayBindingContext ?
+                positionDetails.context.nodes[0] :
+                positionDetails.context.node;
+            return new QuickInfoBuilder(this.tsLS, compiler, templateInfo.component, node).get();
+        }
         getReferencesAtPosition(fileName, position) {
-            const compiler = this.compilerFactory.getOrCreate();
-            const results = new ReferencesAndRenameBuilder(this.strategy, this.tsLS, compiler)
-                .getReferencesAtPosition(fileName, position);
-            this.compilerFactory.registerLastKnownProgram();
-            return results;
+            return this.withCompilerAndPerfTracing(PerfPhase.LsReferencesAndRenames, (compiler) => {
+                return new ReferencesAndRenameBuilder(this.strategy, this.tsLS, compiler)
+                    .getReferencesAtPosition(fileName, position);
+            });
         }
         getRenameInfo(fileName, position) {
-            var _a, _b, _c;
-            const compiler = this.compilerFactory.getOrCreate();
-            const renameInfo = new ReferencesAndRenameBuilder(this.strategy, this.tsLS, compiler)
-                .getRenameInfo(absoluteFrom(fileName), position);
-            if (!renameInfo.canRename) {
-                return renameInfo;
-            }
-            const quickInfo = (_a = this.getQuickInfoAtPosition(fileName, position)) !== null && _a !== void 0 ? _a : this.tsLS.getQuickInfoAtPosition(fileName, position);
-            const kind = (_b = quickInfo === null || quickInfo === void 0 ? void 0 : quickInfo.kind) !== null && _b !== void 0 ? _b : ts.ScriptElementKind.unknown;
-            const kindModifiers = (_c = quickInfo === null || quickInfo === void 0 ? void 0 : quickInfo.kindModifiers) !== null && _c !== void 0 ? _c : ts.ScriptElementKind.unknown;
-            return Object.assign(Object.assign({}, renameInfo), { kind, kindModifiers });
+            return this.withCompilerAndPerfTracing(PerfPhase.LsReferencesAndRenames, (compiler) => {
+                var _a, _b, _c;
+                const renameInfo = new ReferencesAndRenameBuilder(this.strategy, this.tsLS, compiler)
+                    .getRenameInfo(absoluteFrom(fileName), position);
+                if (!renameInfo.canRename) {
+                    return renameInfo;
+                }
+                const quickInfo = (_a = this.getQuickInfoAtPositionImpl(fileName, position, compiler)) !== null && _a !== void 0 ? _a : this.tsLS.getQuickInfoAtPosition(fileName, position);
+                const kind = (_b = quickInfo === null || quickInfo === void 0 ? void 0 : quickInfo.kind) !== null && _b !== void 0 ? _b : ts.ScriptElementKind.unknown;
+                const kindModifiers = (_c = quickInfo === null || quickInfo === void 0 ? void 0 : quickInfo.kindModifiers) !== null && _c !== void 0 ? _c : ts.ScriptElementKind.unknown;
+                return Object.assign(Object.assign({}, renameInfo), { kind, kindModifiers });
+            });
         }
         findRenameLocations(fileName, position) {
-            const compiler = this.compilerFactory.getOrCreate();
-            const results = new ReferencesAndRenameBuilder(this.strategy, this.tsLS, compiler)
-                .findRenameLocations(fileName, position);
-            this.compilerFactory.registerLastKnownProgram();
-            return results;
+            return this.withCompilerAndPerfTracing(PerfPhase.LsReferencesAndRenames, (compiler) => {
+                return new ReferencesAndRenameBuilder(this.strategy, this.tsLS, compiler)
+                    .findRenameLocations(fileName, position);
+            });
         }
-        getCompletionBuilder(fileName, position) {
-            const compiler = this.compilerFactory.getOrCreate();
+        getCompletionBuilder(fileName, position, compiler) {
             const templateInfo = getTemplateInfoAtPosition(fileName, position, compiler);
             if (templateInfo === undefined) {
                 return null;
@@ -43147,23 +43847,26 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             return new CompletionBuilder(this.tsLS, compiler, templateInfo.component, node, positionDetails, isTypeScriptFile(fileName));
         }
         getCompletionsAtPosition(fileName, position, options) {
-            return this.withCompiler((compiler) => {
-                if (!isTemplateContext(compiler.getNextProgram(), fileName, position)) {
-                    return undefined;
-                }
-                const builder = this.getCompletionBuilder(fileName, position);
-                if (builder === null) {
-                    return undefined;
-                }
-                return builder.getCompletionsAtPosition(options);
+            return this.withCompilerAndPerfTracing(PerfPhase.LsCompletions, (compiler) => {
+                return this.getCompletionsAtPositionImpl(fileName, position, options, compiler);
             });
         }
+        getCompletionsAtPositionImpl(fileName, position, options, compiler) {
+            if (!isTemplateContext(compiler.getNextProgram(), fileName, position)) {
+                return undefined;
+            }
+            const builder = this.getCompletionBuilder(fileName, position, compiler);
+            if (builder === null) {
+                return undefined;
+            }
+            return builder.getCompletionsAtPosition(options);
+        }
         getCompletionEntryDetails(fileName, position, entryName, formatOptions, preferences) {
-            return this.withCompiler((compiler) => {
+            return this.withCompilerAndPerfTracing(PerfPhase.LsCompletions, (compiler) => {
                 if (!isTemplateContext(compiler.getNextProgram(), fileName, position)) {
                     return undefined;
                 }
-                const builder = this.getCompletionBuilder(fileName, position);
+                const builder = this.getCompletionBuilder(fileName, position, compiler);
                 if (builder === null) {
                     return undefined;
                 }
@@ -43171,11 +43874,11 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             });
         }
         getCompletionEntrySymbol(fileName, position, entryName) {
-            return this.withCompiler((compiler) => {
+            return this.withCompilerAndPerfTracing(PerfPhase.LsCompletions, (compiler) => {
                 if (!isTemplateContext(compiler.getNextProgram(), fileName, position)) {
                     return undefined;
                 }
-                const builder = this.getCompletionBuilder(fileName, position);
+                const builder = this.getCompletionBuilder(fileName, position, compiler);
                 if (builder === null) {
                     return undefined;
                 }
@@ -43185,7 +43888,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             });
         }
         getTcb(fileName, position) {
-            return this.withCompiler(compiler => {
+            return this.withCompilerAndPerfTracing(PerfPhase.LsTcb, compiler => {
                 const templateInfo = getTemplateInfoAtPosition(fileName, position, compiler);
                 if (templateInfo === undefined) {
                     return undefined;
@@ -43225,10 +43928,31 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                 };
             });
         }
-        withCompiler(p) {
+        /**
+         * Provides an instance of the `NgCompiler` and traces perf results. Perf results are logged only
+         * if the log level is verbose or higher. This method is intended to be called once per public
+         * method call.
+         *
+         * Here is an example of the log output.
+         *
+         * Perf 245  [16:16:39.353] LanguageService#getQuickInfoAtPosition(): {"events":{},"phases":{
+         * "Unaccounted":379,"TtcSymbol":4},"memory":{}}
+         *
+         * Passing name of caller instead of using `arguments.caller` because 'caller', 'callee', and
+         * 'arguments' properties may not be accessed in strict mode.
+         *
+         * @param phase the `PerfPhase` to execute the `p` callback in
+         * @param p callback to be run synchronously with an instance of the `NgCompiler` as argument
+         * @return the result of running the `p` callback
+         */
+        withCompilerAndPerfTracing(phase, p) {
             const compiler = this.compilerFactory.getOrCreate();
-            const result = p(compiler);
+            const result = compiler.perfRecorder.inPhase(phase, () => p(compiler));
             this.compilerFactory.registerLastKnownProgram();
+            const logger = this.project.projectService.logger;
+            if (logger.hasLevel(ts.server.LogLevel.verbose)) {
+                logger.perftrc(`LanguageService#${PerfPhase[phase]}: ${JSON.stringify(compiler.perfRecorder.finalize())}`);
+            }
             return result;
         }
         getCompilerOptionsDiagnostics() {
@@ -43236,22 +43960,23 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             if (!(project instanceof ts.server.ConfiguredProject)) {
                 return [];
             }
-            const diagnostics = [];
-            const configSourceFile = ts.readJsonConfigFile(project.getConfigFilePath(), (path) => project.readFile(path));
-            if (!this.options.strictTemplates && !this.options.fullTemplateTypeCheck) {
-                diagnostics.push({
-                    messageText: 'Some language features are not available. ' +
-                        'To access all features, enable `strictTemplates` in `angularCompilerOptions`.',
-                    category: ts.DiagnosticCategory.Suggestion,
-                    code: ngErrorCode(ErrorCode.SUGGEST_STRICT_TEMPLATES),
-                    file: configSourceFile,
-                    start: undefined,
-                    length: undefined,
-                });
-            }
-            const compiler = this.compilerFactory.getOrCreate();
-            diagnostics.push(...compiler.getOptionDiagnostics());
-            return diagnostics;
+            return this.withCompilerAndPerfTracing(PerfPhase.LsDiagnostics, (compiler) => {
+                const diagnostics = [];
+                const configSourceFile = ts.readJsonConfigFile(project.getConfigFilePath(), (path) => project.readFile(path));
+                if (!this.options.strictTemplates && !this.options.fullTemplateTypeCheck) {
+                    diagnostics.push({
+                        messageText: 'Some language features are not available. ' +
+                            'To access all features, enable `strictTemplates` in `angularCompilerOptions`.',
+                        category: ts.DiagnosticCategory.Suggestion,
+                        code: ngErrorCode(ErrorCode.SUGGEST_STRICT_TEMPLATES),
+                        file: configSourceFile,
+                        start: undefined,
+                        length: undefined,
+                    });
+                }
+                diagnostics.push(...compiler.getOptionDiagnostics());
+                return diagnostics;
+            });
         }
         watchConfigFile(project) {
             // TODO: Check the case when the project is disposed. An InferredProject