@angular/language-service 11.1.0-next.5 → 11.1.2

package/bundles/ivy.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v11.1.0-next.5
+ * @license Angular v11.1.2
  * Copyright Google LLC All Rights Reserved.
  * License: MIT
  */
@@ -827,6 +827,10 @@ 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
      */
+    // Stores the default value of `emitDistinctChangesOnly` when the `emitDistinctChangesOnly` is not
+    // explicitly set. This value will be changed to `true` in v12.
+    // TODO(misko): switch the default in v12 to `true`. See: packages/core/src/metadata/di.ts
+    const emitDistinctChangesOnlyDefaultValue = false;
     var ViewEncapsulation;
     (function (ViewEncapsulation) {
         ViewEncapsulation[ViewEncapsulation["Emulated"] = 0] = "Emulated";
@@ -2655,8 +2659,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     Identifiers$1.definePipe = { name: 'ɵɵdefinePipe', moduleName: CORE$1 };
     Identifiers$1.queryRefresh = { name: 'ɵɵqueryRefresh', moduleName: CORE$1 };
     Identifiers$1.viewQuery = { name: 'ɵɵviewQuery', moduleName: CORE$1 };
-    Identifiers$1.staticViewQuery = { name: 'ɵɵstaticViewQuery', moduleName: CORE$1 };
-    Identifiers$1.staticContentQuery = { name: 'ɵɵstaticContentQuery', moduleName: CORE$1 };
     Identifiers$1.loadQuery = { name: 'ɵɵloadQuery', moduleName: CORE$1 };
     Identifiers$1.contentQuery = { name: 'ɵɵcontentQuery', moduleName: CORE$1 };
     Identifiers$1.NgOnChangesFeature = { name: 'ɵɵNgOnChangesFeature', moduleName: CORE$1 };
@@ -9355,7 +9357,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 this._advance();
                 selfClosing = false;
             }
-            const end = this._peek.sourceSpan.start;
+            const end = this._peek.sourceSpan.fullStart;
             const span = new ParseSourceSpan(startTagToken.sourceSpan.start, end, startTagToken.sourceSpan.fullStart);
             // Create a separate `startSpan` because `span` will be modified when there is an `end` span.
             const startSpan = new ParseSourceSpan(startTagToken.sourceSpan.start, end, startTagToken.sourceSpan.fullStart);
@@ -9687,8 +9689,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
         parseInterpolation(value, sourceSpan) {
             const sourceInfo = sourceSpan.start.toString();
+            const absoluteOffset = sourceSpan.fullStart.offset;
             try {
-                const ast = this._exprParser.parseInterpolation(value, sourceInfo, sourceSpan.start.offset, this._interpolationConfig);
+                const ast = this._exprParser.parseInterpolation(value, sourceInfo, absoluteOffset, this._interpolationConfig);
                 if (ast)
                     this._reportExpressionParserErrors(ast.errors, sourceSpan);
                 this._checkPipes(ast, sourceSpan);
@@ -9696,7 +9699,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
             catch (e) {
                 this._reportError(`${e}`, sourceSpan);
-                return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo, sourceSpan.start.offset);
+                return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo, absoluteOffset);
             }
         }
         /**
@@ -9706,8 +9709,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
          */
         parseInterpolationExpression(expression, sourceSpan) {
             const sourceInfo = sourceSpan.start.toString();
+            const absoluteOffset = sourceSpan.start.offset;
             try {
-                const ast = this._exprParser.parseInterpolationExpression(expression, sourceInfo, sourceSpan.start.offset);
+                const ast = this._exprParser.parseInterpolationExpression(expression, sourceInfo, absoluteOffset);
                 if (ast)
                     this._reportExpressionParserErrors(ast.errors, sourceSpan);
                 this._checkPipes(ast, sourceSpan);
@@ -9715,7 +9719,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
             catch (e) {
                 this._reportError(`${e}`, sourceSpan);
-                return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo, sourceSpan.start.offset);
+                return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo, absoluteOffset);
             }
         }
         /**
@@ -9795,6 +9799,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         targetProps, keySpan) {
             if (isAnimationLabel(name)) {
                 name = name.substring(1);
+                if (keySpan !== undefined) {
+                    keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
+                }
                 if (value) {
                     this._reportError(`Assigning animation triggers via @prop="exp" attributes with an expression is invalid.` +
                         ` Use property bindings (e.g. [@prop]="exp") or use an attribute without a value (e.g. @prop) instead.`, sourceSpan, ParseErrorLevel.ERROR);
@@ -9816,10 +9823,16 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             if (name.startsWith(ANIMATE_PROP_PREFIX)) {
                 isAnimationProp = true;
                 name = name.substring(ANIMATE_PROP_PREFIX.length);
+                if (keySpan !== undefined) {
+                    keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + ANIMATE_PROP_PREFIX.length, keySpan.end.offset));
+                }
             }
             else if (isAnimationLabel(name)) {
                 isAnimationProp = true;
                 name = name.substring(1);
+                if (keySpan !== undefined) {
+                    keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
+                }
             }
             if (isAnimationProp) {
                 this._parseAnimation(name, expression, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps);
@@ -9926,6 +9939,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
             if (isAnimationLabel(name)) {
                 name = name.substr(1);
+                if (keySpan !== undefined) {
+                    keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
+                }
                 this._parseAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan);
             }
             else {
@@ -11340,13 +11356,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     }
                     const fullEnd = exprEnd + interpEnd.length;
                     const text = input.substring(exprStart, exprEnd);
-                    if (text.trim().length > 0) {
-                        expressions.push({ text, start: fullStart, end: fullEnd });
-                    }
-                    else {
+                    if (text.trim().length === 0) {
                         this._reportError('Blank expressions are not allowed in interpolated strings', input, `at column ${i} in`, location);
-                        expressions.push({ text: '$implicit', start: fullStart, end: fullEnd });
                     }
+                    expressions.push({ text, start: fullStart, end: fullEnd });
                     offsets.push(exprStart);
                     i = fullEnd;
                     atInterpolation = false;
@@ -11529,13 +11542,25 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         get currentAbsoluteOffset() {
             return this.absoluteOffset + this.inputIndex;
         }
-        span(start) {
-            return new ParseSpan(start, this.currentEndIndex);
+        /**
+         * Retrieve a `ParseSpan` from `start` to the current position (or to `artificialEndIndex` if
+         * provided).
+         *
+         * @param start Position from which the `ParseSpan` will start.
+         * @param artificialEndIndex Optional ending index to be used if provided (and if greater than the
+         *     natural ending index)
+         */
+        span(start, artificialEndIndex) {
+            let endIndex = this.currentEndIndex;
+            if (artificialEndIndex !== undefined && artificialEndIndex > this.currentEndIndex) {
+                endIndex = artificialEndIndex;
+            }
+            return new ParseSpan(start, endIndex);
         }
-        sourceSpan(start) {
-            const serial = `${start}@${this.inputIndex}`;
+        sourceSpan(start, artificialEndIndex) {
+            const serial = `${start}@${this.inputIndex}:${artificialEndIndex}`;
             if (!this.sourceSpanCache.has(serial)) {
-                this.sourceSpanCache.set(serial, this.span(start).toAbsolute(this.absoluteOffset));
+                this.sourceSpanCache.set(serial, this.span(start, artificialEndIndex).toAbsolute(this.absoluteOffset));
             }
             return this.sourceSpanCache.get(serial);
         }
@@ -11598,7 +11623,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             const n = this.next;
             if (!n.isIdentifier() && !n.isKeyword()) {
                 this.error(`Unexpected ${this.prettyPrintToken(n)}, expected identifier or keyword`);
-                return '';
+                return null;
             }
             this.advance();
             return n.toString();
@@ -11629,8 +11654,12 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     this.error(`Unexpected token '${this.next}'`);
                 }
             }
-            if (exprs.length == 0)
-                return new EmptyExpr(this.span(start), this.sourceSpan(start));
+            if (exprs.length == 0) {
+                // We have no expressions so create an empty expression that spans the entire input length
+                const artificialStart = this.offset;
+                const artificialEnd = this.offset + this.inputLength;
+                return new EmptyExpr(this.span(artificialStart, artificialEnd), this.sourceSpan(artificialStart, artificialEnd));
+            }
             if (exprs.length == 1)
                 return exprs[0];
             return new Chain(this.span(start), this.sourceSpan(start), exprs);
@@ -11643,15 +11672,36 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 }
                 do {
                     const nameStart = this.inputIndex;
-                    const name = this.expectIdentifierOrKeyword();
-                    const nameSpan = this.sourceSpan(nameStart);
+                    let nameId = this.expectIdentifierOrKeyword();
+                    let nameSpan;
+                    let fullSpanEnd = undefined;
+                    if (nameId !== null) {
+                        nameSpan = this.sourceSpan(nameStart);
+                    }
+                    else {
+                        // No valid identifier was found, so we'll assume an empty pipe name ('').
+                        nameId = '';
+                        // However, there may have been whitespace present between the pipe character and the next
+                        // token in the sequence (or the end of input). We want to track this whitespace so that
+                        // the `BindingPipe` we produce covers not just the pipe character, but any trailing
+                        // whitespace beyond it. Another way of thinking about this is that the zero-length name
+                        // is assumed to be at the end of any whitespace beyond the pipe character.
+                        //
+                        // Therefore, we push the end of the `ParseSpan` for this pipe all the way up to the
+                        // beginning of the next token, or until the end of input if the next token is EOF.
+                        fullSpanEnd = this.next.index !== -1 ? this.next.index : this.inputLength + this.offset;
+                        // The `nameSpan` for an empty pipe name is zero-length at the end of any whitespace
+                        // beyond the pipe character.
+                        nameSpan = new ParseSpan(fullSpanEnd, fullSpanEnd).toAbsolute(this.absoluteOffset);
+                    }
                     const args = [];
                     while (this.consumeOptionalCharacter($COLON)) {
                         args.push(this.parseExpression());
+                        // If there are additional expressions beyond the name, then the artificial end for the
+                        // name is no longer relevant.
                     }
                     const { start } = result.span;
-                    result =
-                        new BindingPipe(this.span(start), this.sourceSpan(start), result, name, args, nameSpan);
+                    result = new BindingPipe(this.span(start), this.sourceSpan(start, fullSpanEnd), result, nameId, args, nameSpan);
                 } while (this.consumeOptionalOperator('|'));
             }
             return result;
@@ -11940,7 +11990,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             const start = receiver.span.start;
             const nameStart = this.inputIndex;
             const id = this.withContext(ParseContextFlags.Writable, () => {
-                const id = this.expectIdentifierOrKeyword();
+                var _a;
+                const id = (_a = this.expectIdentifierOrKeyword()) !== null && _a !== void 0 ? _a : '';
                 if (id.length === 0) {
                     this.error(`Expected identifier for property access`, receiver.span.end);
                 }
@@ -16169,12 +16220,21 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
     }
     function prepareQueryParams(query, constantPool) {
-        const parameters = [getQueryPredicate(query, constantPool), literal(query.descendants)];
+        const parameters = [getQueryPredicate(query, constantPool), literal(toQueryFlags(query))];
         if (query.read) {
             parameters.push(query.read);
         }
         return parameters;
     }
+    /**
+     * Translates query flags into `TQueryFlags` type in packages/core/src/render3/interfaces/query.ts
+     * @param query
+     */
+    function toQueryFlags(query) {
+        return (query.descendants ? 1 /* descendants */ : 0 /* none */) |
+            (query.static ? 2 /* isStatic */ : 0 /* none */) |
+            (query.emitDistinctChangesOnly ? 4 /* emitDistinctChangesOnly */ : 0 /* none */);
+    }
     function convertAttributesToExpressions(attributes) {
         const values = [];
         for (let key of Object.getOwnPropertyNames(attributes)) {
@@ -16189,9 +16249,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         const updateStatements = [];
         const tempAllocator = temporaryAllocator(updateStatements, TEMPORARY_NAME);
         for (const query of queries) {
-            const queryInstruction = query.static ? Identifiers$1.staticContentQuery : Identifiers$1.contentQuery;
             // creation, e.g. r3.contentQuery(dirIndex, somePredicate, true, null);
-            createStatements.push(importExpr(queryInstruction)
+            createStatements.push(importExpr(Identifiers$1.contentQuery)
                 .callFn([variable('dirIndex'), ...prepareQueryParams(query, constantPool)])
                 .toStmt());
             // update, e.g. (r3.queryRefresh(tmp = r3.loadQuery()) && (ctx.someDir = tmp));
@@ -16257,9 +16316,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         const updateStatements = [];
         const tempAllocator = temporaryAllocator(updateStatements, TEMPORARY_NAME);
         viewQueries.forEach((query) => {
-            const queryInstruction = query.static ? Identifiers$1.staticViewQuery : Identifiers$1.viewQuery;
             // creation, e.g. r3.viewQuery(somePredicate, true);
-            const queryDefinition = importExpr(queryInstruction).callFn(prepareQueryParams(query, constantPool));
+            const queryDefinition = importExpr(Identifiers$1.viewQuery).callFn(prepareQueryParams(query, constantPool));
             createStatements.push(queryDefinition.toStmt());
             // update, e.g. (r3.queryRefresh(tmp = r3.loadQuery()) && (ctx.someDir = tmp));
             const temporary = tempAllocator();
@@ -16738,10 +16796,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     };
     function convertToR3QueryMetadata(facade) {
         return Object.assign(Object.assign({}, facade), { predicate: Array.isArray(facade.predicate) ? facade.predicate :
-                new WrappedNodeExpr(facade.predicate), read: facade.read ? new WrappedNodeExpr(facade.read) : null, static: facade.static });
+                new WrappedNodeExpr(facade.predicate), read: facade.read ? new WrappedNodeExpr(facade.read) : null, static: facade.static, emitDistinctChangesOnly: facade.emitDistinctChangesOnly });
     }
     function convertQueryDeclarationToMetadata(declaration) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         return {
             propertyName: declaration.propertyName,
             first: (_a = declaration.first) !== null && _a !== void 0 ? _a : false,
@@ -16750,6 +16808,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             descendants: (_b = declaration.descendants) !== null && _b !== void 0 ? _b : false,
             read: declaration.read ? new WrappedNodeExpr(declaration.read) : null,
             static: (_c = declaration.static) !== null && _c !== void 0 ? _c : false,
+            emitDistinctChangesOnly: (_d = declaration.emitDistinctChangesOnly) !== null && _d !== void 0 ? _d : true,
         };
     }
     function convertDirectiveFacadeToMetadata(facade) {
@@ -16952,7 +17011,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.1.0-next.5');
+    const VERSION$1 = new Version('11.1.2');
 
     /**
      * @license
@@ -17609,7 +17668,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      */
     function createDirectiveDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
-        definitionMap.set('version', literal('11.1.0-next.5'));
+        definitionMap.set('version', literal('11.1.2'));
         // e.g. `type: MyDirective`
         definitionMap.set('type', meta.internalType);
         // e.g. `selector: 'some-dir'`
@@ -17649,6 +17708,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             meta.set('first', literal(true));
         }
         meta.set('predicate', Array.isArray(query.predicate) ? asLiteral(query.predicate) : query.predicate);
+        if (!query.emitDistinctChangesOnly) {
+            // `emitDistinctChangesOnly` is special because in future we expect it to be `true`. For this
+            // reason the absence should be interpreted as `true`.
+            meta.set('emitDistinctChangesOnly', literal(false));
+        }
         if (query.descendants) {
             meta.set('descendants', literal(true));
         }
@@ -21052,7 +21116,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.1.0-next.5');
+    const VERSION$2 = new Version('11.1.2');
 
     /**
      * @license
@@ -21244,7 +21308,34 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
          * An injectable already has a `ɵprov` property.
          */
         ErrorCode[ErrorCode["INJECTABLE_DUPLICATE_PROV"] = 9001] = "INJECTABLE_DUPLICATE_PROV";
+        // 10XXX error codes are reserved for diagnostics with category
+        // `ts.DiagnosticCategory.Suggestion`. These diagnostics are generated by
+        // language service.
+        /**
+         * Suggest users to enable `strictTemplates` to make use of full capabilities
+         * provided by Angular language service.
+         */
+        ErrorCode[ErrorCode["SUGGEST_STRICT_TEMPLATES"] = 10001] = "SUGGEST_STRICT_TEMPLATES";
     })(ErrorCode || (ErrorCode = {}));
+    /**
+     * @internal
+     * Base URL for the error details page.
+     * Keep this value in sync with a similar const in
+     * `packages/core/src/render3/error_code.ts`.
+     */
+    const ERROR_DETAILS_PAGE_BASE_URL = 'https://angular.io/errors';
+    /**
+     * @internal
+     * Contains a set of error messages that have detailed guides at angular.io.
+     * Full list of available error guides can be found at https://angular.io/errors
+     */
+    const COMPILER_ERRORS_WITH_GUIDES = new Set([
+        ErrorCode.DECORATOR_ARG_NOT_LITERAL,
+        ErrorCode.PARAM_MISSING_TOKEN,
+        ErrorCode.SCHEMA_INVALID_ELEMENT,
+        ErrorCode.SCHEMA_INVALID_ATTRIBUTE,
+        ErrorCode.MISSING_REFERENCE_TARGET,
+    ]);
     /**
      * @internal
      */
@@ -25399,6 +25490,18 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 }
             }
         }
+        updateResources(clazz) {
+            if (!this.reflector.isClass(clazz) || !this.classes.has(clazz)) {
+                return;
+            }
+            const record = this.classes.get(clazz);
+            for (const trait of record.traits) {
+                if (trait.state !== TraitState.Resolved || trait.handler.updateResources === undefined) {
+                    continue;
+                }
+                trait.handler.updateResources(clazz, trait.analysis, trait.resolution);
+            }
+        }
         compile(clazz, constantPool) {
             const original = ts$1.getOriginalNode(clazz);
             if (!this.reflector.isClass(clazz) || !this.reflector.isClass(original) ||
@@ -28101,6 +28204,7 @@ Either add the @Injectable() decorator to '${provider.node.name
         let read = null;
         // The default value for descendants is true for every decorator except @ContentChildren.
         let descendants = name !== 'ContentChildren';
+        let emitDistinctChangesOnly = emitDistinctChangesOnlyDefaultValue;
         if (args.length === 2) {
             const optionsExpr = unwrapExpression(args[1]);
             if (!ts$1.isObjectLiteralExpression(optionsExpr)) {
@@ -28118,6 +28222,14 @@ Either add the @Injectable() decorator to '${provider.node.name
                 }
                 descendants = descendantsValue;
             }
+            if (options.has('emitDistinctChangesOnly')) {
+                const emitDistinctChangesOnlyExpr = options.get('emitDistinctChangesOnly');
+                const emitDistinctChangesOnlyValue = evaluator.evaluate(emitDistinctChangesOnlyExpr);
+                if (typeof emitDistinctChangesOnlyValue !== 'boolean') {
+                    throw createValueHasWrongTypeError(emitDistinctChangesOnlyExpr, emitDistinctChangesOnlyValue, `@${name} options.emitDistinctChangesOnlys must be a boolean`);
+                }
+                emitDistinctChangesOnly = emitDistinctChangesOnlyValue;
+            }
             if (options.has('static')) {
                 const staticValue = evaluator.evaluate(options.get('static'));
                 if (typeof staticValue !== 'boolean') {
@@ -28137,6 +28249,7 @@ Either add the @Injectable() decorator to '${provider.node.name
             descendants,
             read,
             static: isStatic,
+            emitDistinctChangesOnly,
         };
     }
     function extractQueriesFromDecorator(queryData, reflector, evaluator, isCore) {
@@ -28528,24 +28641,13 @@ Either add the @Injectable() decorator to '${provider.node.name
                 template = preanalyzed;
             }
             else {
-                // The template was not already parsed. Either there's a templateUrl, or an inline template.
-                if (component.has('templateUrl')) {
-                    const templateUrlExpr = component.get('templateUrl');
-                    const templateUrl = this.evaluator.evaluate(templateUrlExpr);
-                    if (typeof templateUrl !== 'string') {
-                        throw createValueHasWrongTypeError(templateUrlExpr, templateUrl, 'templateUrl must be a string');
-                    }
-                    const resourceUrl = this.resourceLoader.resolve(templateUrl, containingFile);
-                    template = this._extractExternalTemplate(node, component, templateUrlExpr, resourceUrl);
-                }
-                else {
-                    // Expect an inline template to be present.
-                    template = this._extractInlineTemplate(node, decorator, component, containingFile);
-                }
+                const templateDecl = this.parseTemplateDeclaration(decorator, component, containingFile);
+                template = this.extractTemplate(node, templateDecl);
             }
-            const templateResource = template.isInline ?
-                { path: null, expression: component.get('template') } :
-                { path: absoluteFrom(template.templateUrl), expression: template.sourceMapping.node };
+            const templateResource = template.isInline ? { path: null, expression: component.get('template') } : {
+                path: absoluteFrom(template.declaration.resolvedTemplateUrl),
+                expression: template.sourceMapping.node
+            };
             // Figure out the set of styles. The ordering here is important: external resources (styleUrls)
             // precede inline styles, and styles defined in the template override styles defined in the
             // component.
@@ -28565,9 +28667,11 @@ Either add the @Injectable() decorator to '${provider.node.name
                     }
                 }
             }
+            let inlineStyles = null;
             if (component.has('styles')) {
                 const litStyles = parseFieldArrayValue(component, 'styles', this.evaluator);
                 if (litStyles !== null) {
+                    inlineStyles = [...litStyles];
                     if (styles === null) {
                         styles = litStyles;
                     }
@@ -28607,6 +28711,8 @@ Either add the @Injectable() decorator to '${provider.node.name
                     template,
                     providersRequiringFactory,
                     viewProvidersRequiringFactory,
+                    inlineStyles,
+                    styleUrls,
                     resources: {
                         styles: styleResources,
                         template: templateResource,
@@ -28775,6 +28881,33 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
             return { data };
         }
+        updateResources(node, analysis) {
+            const containingFile = node.getSourceFile().fileName;
+            // If the template is external, re-parse it.
+            const templateDecl = analysis.template.declaration;
+            if (!templateDecl.isInline) {
+                analysis.template = this.extractTemplate(node, templateDecl);
+            }
+            // Update any external stylesheets and rebuild the combined 'styles' list.
+            // TODO(alxhub): write tests for styles when the primary compiler uses the updateResources path
+            let styles = [];
+            if (analysis.styleUrls !== null) {
+                for (const styleUrl of analysis.styleUrls) {
+                    const resolvedStyleUrl = this.resourceLoader.resolve(styleUrl, containingFile);
+                    const styleText = this.resourceLoader.load(resolvedStyleUrl);
+                    styles.push(styleText);
+                }
+            }
+            if (analysis.inlineStyles !== null) {
+                for (const styleText of analysis.inlineStyles) {
+                    styles.push(styleText);
+                }
+            }
+            for (const styleText of analysis.template.styles) {
+                styles.push(styleText);
+            }
+            analysis.meta.styles = styles;
+        }
         compileFull(node, analysis, resolution, pool) {
             if (analysis.template.errors !== null && analysis.template.errors.length > 0) {
                 return [];
@@ -28881,7 +29014,8 @@ Either add the @Injectable() decorator to '${provider.node.name
                 // URLs to resolve.
                 if (templatePromise !== undefined) {
                     return templatePromise.then(() => {
-                        const template = this._extractExternalTemplate(node, component, templateUrlExpr, resourceUrl);
+                        const templateDecl = this.parseTemplateDeclaration(decorator, component, containingFile);
+                        const template = this.extractTemplate(node, templateDecl);
                         this.preanalyzeTemplateCache.set(node, template);
                         return template;
                     });
@@ -28891,125 +29025,157 @@ Either add the @Injectable() decorator to '${provider.node.name
                 }
             }
             else {
-                const template = this._extractInlineTemplate(node, decorator, component, containingFile);
+                const templateDecl = this.parseTemplateDeclaration(decorator, component, containingFile);
+                const template = this.extractTemplate(node, templateDecl);
                 this.preanalyzeTemplateCache.set(node, template);
                 return Promise.resolve(template);
             }
         }
-        _extractExternalTemplate(node, component, templateUrlExpr, resourceUrl) {
-            const templateStr = this.resourceLoader.load(resourceUrl);
-            if (this.depTracker !== null) {
-                this.depTracker.addResourceDependency(node.getSourceFile(), absoluteFrom(resourceUrl));
-            }
-            const template = this._parseTemplate(component, templateStr, /* templateLiteral */ null, sourceMapUrl(resourceUrl), 
-            /* templateRange */ undefined, 
-            /* escapedString */ false);
-            return Object.assign(Object.assign({}, template), { sourceMapping: {
-                    type: 'external',
-                    componentClass: node,
-                    node: templateUrlExpr,
-                    template: templateStr,
-                    templateUrl: resourceUrl,
-                } });
-        }
-        _extractInlineTemplate(node, decorator, component, containingFile) {
-            if (!component.has('template')) {
-                throw new FatalDiagnosticError(ErrorCode.COMPONENT_MISSING_TEMPLATE, Decorator.nodeForError(decorator), 'component is missing a template');
-            }
-            const templateExpr = component.get('template');
-            let templateStr;
-            let templateLiteral = null;
-            let templateUrl = '';
-            let templateRange = undefined;
-            let sourceMapping;
-            let escapedString = false;
-            // We only support SourceMaps for inline templates that are simple string literals.
-            if (ts$1.isStringLiteral(templateExpr) || ts$1.isNoSubstitutionTemplateLiteral(templateExpr)) {
-                // the start and end of the `templateExpr` node includes the quotation marks, which we
-                // must
-                // strip
-                templateRange = getTemplateRange(templateExpr);
-                templateStr = templateExpr.getSourceFile().text;
-                templateLiteral = templateExpr;
-                templateUrl = containingFile;
-                escapedString = true;
-                sourceMapping = {
-                    type: 'direct',
-                    node: templateExpr,
-                };
-            }
-            else {
-                const resolvedTemplate = this.evaluator.evaluate(templateExpr);
-                if (typeof resolvedTemplate !== 'string') {
-                    throw createValueHasWrongTypeError(templateExpr, resolvedTemplate, 'template must be a string');
-                }
-                templateStr = resolvedTemplate;
-                sourceMapping = {
-                    type: 'indirect',
-                    node: templateExpr,
-                    componentClass: node,
-                    template: templateStr,
-                };
-            }
-            const template = this._parseTemplate(component, templateStr, templateLiteral, templateUrl, templateRange, escapedString);
-            return Object.assign(Object.assign({}, template), { sourceMapping });
-        }
-        _parseTemplate(component, templateStr, templateLiteral, templateUrl, templateRange, escapedString) {
-            let preserveWhitespaces = this.defaultPreserveWhitespaces;
-            if (component.has('preserveWhitespaces')) {
-                const expr = component.get('preserveWhitespaces');
-                const value = this.evaluator.evaluate(expr);
-                if (typeof value !== 'boolean') {
-                    throw createValueHasWrongTypeError(expr, value, 'preserveWhitespaces must be a boolean');
+        extractTemplate(node, template) {
+            if (template.isInline) {
+                let templateStr;
+                let templateLiteral = null;
+                let templateUrl = '';
+                let templateRange = null;
+                let sourceMapping;
+                let escapedString = false;
+                // We only support SourceMaps for inline templates that are simple string literals.
+                if (ts$1.isStringLiteral(template.expression) ||
+                    ts$1.isNoSubstitutionTemplateLiteral(template.expression)) {
+                    // the start and end of the `templateExpr` node includes the quotation marks, which we must
+                    // strip
+                    templateRange = getTemplateRange(template.expression);
+                    templateStr = template.expression.getSourceFile().text;
+                    templateLiteral = template.expression;
+                    templateUrl = template.templateUrl;
+                    escapedString = true;
+                    sourceMapping = {
+                        type: 'direct',
+                        node: template.expression,
+                    };
                 }
-                preserveWhitespaces = value;
-            }
-            let interpolationConfig = DEFAULT_INTERPOLATION_CONFIG;
-            if (component.has('interpolation')) {
-                const expr = component.get('interpolation');
-                const value = this.evaluator.evaluate(expr);
-                if (!Array.isArray(value) || value.length !== 2 ||
-                    !value.every(element => typeof element === 'string')) {
-                    throw createValueHasWrongTypeError(expr, value, 'interpolation must be an array with 2 elements of string type');
+                else {
+                    const resolvedTemplate = this.evaluator.evaluate(template.expression);
+                    if (typeof resolvedTemplate !== 'string') {
+                        throw createValueHasWrongTypeError(template.expression, resolvedTemplate, 'template must be a string');
+                    }
+                    templateStr = resolvedTemplate;
+                    sourceMapping = {
+                        type: 'indirect',
+                        node: template.expression,
+                        componentClass: node,
+                        template: templateStr,
+                    };
                 }
-                interpolationConfig = InterpolationConfig.fromArray(value);
+                return Object.assign(Object.assign({}, this._parseTemplate(template, templateStr, templateRange, escapedString)), { sourceMapping, declaration: template });
             }
+            else {
+                const templateStr = this.resourceLoader.load(template.resolvedTemplateUrl);
+                if (this.depTracker !== null) {
+                    this.depTracker.addResourceDependency(node.getSourceFile(), absoluteFrom(template.resolvedTemplateUrl));
+                }
+                return Object.assign(Object.assign({}, this._parseTemplate(template, templateStr, /* templateRange */ null, 
+                /* escapedString */ false)), { sourceMapping: {
+                        type: 'external',
+                        componentClass: node,
+                        // TODO(alxhub): TS in g3 is unable to make this inference on its own, so cast it here
+                        // until g3 is able to figure this out.
+                        node: template.templateUrlExpression,
+                        template: templateStr,
+                        templateUrl: template.resolvedTemplateUrl,
+                    }, declaration: template });
+            }
+        }
+        _parseTemplate(template, templateStr, templateRange, escapedString) {
             // We always normalize line endings if the template has been escaped (i.e. is inline).
             const i18nNormalizeLineEndingsInICUs = escapedString || this.i18nNormalizeLineEndingsInICUs;
-            const isInline = component.has('template');
-            const parsedTemplate = parseTemplate(templateStr, templateUrl, {
-                preserveWhitespaces,
-                interpolationConfig,
-                range: templateRange,
+            const parsedTemplate = parseTemplate(templateStr, template.sourceMapUrl, {
+                preserveWhitespaces: template.preserveWhitespaces,
+                interpolationConfig: template.interpolationConfig,
+                range: templateRange !== null && templateRange !== void 0 ? templateRange : undefined,
                 escapedString,
                 enableI18nLegacyMessageIdFormat: this.enableI18nLegacyMessageIdFormat,
                 i18nNormalizeLineEndingsInICUs,
-                isInline,
+                isInline: template.isInline,
             });
             // Unfortunately, the primary parse of the template above may not contain accurate source map
             // information. If used directly, it would result in incorrect code locations in template
-            // errors, etc. There are two main problems:
+            // errors, etc. There are three main problems:
             //
             // 1. `preserveWhitespaces: false` annihilates the correctness of template source mapping, as
             //    the whitespace transformation changes the contents of HTML text nodes before they're
             //    parsed into Angular expressions.
-            // 2. By default, the template parser strips leading trivia characters (like spaces, tabs, and
+            // 2. `preserveLineEndings: false` causes growing misalignments in templates that use '\r\n'
+            //    line endings, by normalizing them to '\n'.
+            // 3. By default, the template parser strips leading trivia characters (like spaces, tabs, and
             //    newlines). This also destroys source mapping information.
             //
             // In order to guarantee the correctness of diagnostics, templates are parsed a second time
             // with the above options set to preserve source mappings.
-            const { nodes: diagNodes } = parseTemplate(templateStr, templateUrl, {
+            const { nodes: diagNodes } = parseTemplate(templateStr, template.sourceMapUrl, {
                 preserveWhitespaces: true,
-                interpolationConfig,
-                range: templateRange,
+                preserveLineEndings: true,
+                interpolationConfig: template.interpolationConfig,
+                range: templateRange !== null && templateRange !== void 0 ? templateRange : undefined,
                 escapedString,
                 enableI18nLegacyMessageIdFormat: this.enableI18nLegacyMessageIdFormat,
                 i18nNormalizeLineEndingsInICUs,
                 leadingTriviaChars: [],
-                isInline,
+                isInline: template.isInline,
             });
-            return Object.assign(Object.assign({}, parsedTemplate), { diagNodes, template: templateLiteral !== null ? new WrappedNodeExpr(templateLiteral) : templateStr, templateUrl,
-                isInline, file: new ParseSourceFile(templateStr, templateUrl) });
+            return Object.assign(Object.assign({}, parsedTemplate), { diagNodes, template: template.isInline ? new WrappedNodeExpr(template.expression) : templateStr, templateUrl: template.resolvedTemplateUrl, isInline: template.isInline, file: new ParseSourceFile(templateStr, template.resolvedTemplateUrl) });
+        }
+        parseTemplateDeclaration(decorator, component, containingFile) {
+            let preserveWhitespaces = this.defaultPreserveWhitespaces;
+            if (component.has('preserveWhitespaces')) {
+                const expr = component.get('preserveWhitespaces');
+                const value = this.evaluator.evaluate(expr);
+                if (typeof value !== 'boolean') {
+                    throw createValueHasWrongTypeError(expr, value, 'preserveWhitespaces must be a boolean');
+                }
+                preserveWhitespaces = value;
+            }
+            let interpolationConfig = DEFAULT_INTERPOLATION_CONFIG;
+            if (component.has('interpolation')) {
+                const expr = component.get('interpolation');
+                const value = this.evaluator.evaluate(expr);
+                if (!Array.isArray(value) || value.length !== 2 ||
+                    !value.every(element => typeof element === 'string')) {
+                    throw createValueHasWrongTypeError(expr, value, 'interpolation must be an array with 2 elements of string type');
+                }
+                interpolationConfig = InterpolationConfig.fromArray(value);
+            }
+            if (component.has('templateUrl')) {
+                const templateUrlExpr = component.get('templateUrl');
+                const templateUrl = this.evaluator.evaluate(templateUrlExpr);
+                if (typeof templateUrl !== 'string') {
+                    throw createValueHasWrongTypeError(templateUrlExpr, templateUrl, 'templateUrl must be a string');
+                }
+                const resourceUrl = this.resourceLoader.resolve(templateUrl, containingFile);
+                return {
+                    isInline: false,
+                    interpolationConfig,
+                    preserveWhitespaces,
+                    templateUrl,
+                    templateUrlExpression: templateUrlExpr,
+                    resolvedTemplateUrl: resourceUrl,
+                    sourceMapUrl: sourceMapUrl(resourceUrl),
+                };
+            }
+            else if (component.has('template')) {
+                return {
+                    isInline: true,
+                    interpolationConfig,
+                    preserveWhitespaces,
+                    expression: component.get('template'),
+                    templateUrl: containingFile,
+                    resolvedTemplateUrl: containingFile,
+                    sourceMapUrl: containingFile,
+                };
+            }
+            else {
+                throw new FatalDiagnosticError(ErrorCode.COMPONENT_MISSING_TEMPLATE, Decorator.nodeForError(decorator), 'component is missing a template');
+            }
         }
         _expressionToImportedFile(expr, origin) {
             if (!(expr instanceof ExternalExpr)) {
@@ -31252,6 +31418,12 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.cache.set(resolvedUrl, result);
             return result;
         }
+        /**
+         * Invalidate the entire resource cache.
+         */
+        invalidate() {
+            this.cache.clear();
+        }
         /**
          * Attempt to resolve `url` in the context of `fromFile`, while respecting the rootDirs
          * option from the tsconfig. First, normalize the file name.
@@ -36547,12 +36719,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             const shimData = this.pendingShimForComponent(ref.node);
             const templateId = fileData.sourceManager.getTemplateId(ref.node);
             const templateDiagnostics = [];
-            const sfPath = absoluteFromSourceFile(ref.node.getSourceFile());
-            const overrideTemplate = this.host.getTemplateOverride(sfPath, ref.node);
-            if (overrideTemplate !== null) {
-                template = overrideTemplate.nodes;
-                parseErrors = overrideTemplate.errors;
-            }
             if (parseErrors !== null) {
                 templateDiagnostics.push(...this.getTemplateDiagnostics(parseErrors, templateId, sourceMapping));
             }
@@ -37459,38 +37625,22 @@ Either add the @Injectable() decorator to '${provider.node.name
             /**
              * Stores directives and pipes that are in scope for each component.
              *
-             * Unlike other caches, the scope of a component is not affected by its template, so this
-             * cache does not need to be invalidate if the template is overridden. It will be destroyed when
-             * the `ts.Program` changes and the `TemplateTypeCheckerImpl` as a whole is destroyed and
-             * replaced.
+             * Unlike other caches, the scope of a component is not affected by its template. It will be
+             * destroyed when the `ts.Program` changes and the `TemplateTypeCheckerImpl` as a whole is
+             * destroyed and replaced.
              */
             this.scopeCache = new Map();
             /**
              * Stores potential element tags for each component (a union of DOM tags as well as directive
              * tags).
              *
-             * Unlike other caches, the scope of a component is not affected by its template, so this
-             * cache does not need to be invalidate if the template is overridden. It will be destroyed when
-             * the `ts.Program` changes and the `TemplateTypeCheckerImpl` as a whole is destroyed and
-             * replaced.
+             * Unlike other caches, the scope of a component is not affected by its template. It will be
+             * destroyed when the `ts.Program` changes and the `TemplateTypeCheckerImpl` as a whole is
+             * destroyed and replaced.
              */
             this.elementTagCache = new Map();
             this.isComplete = false;
         }
-        resetOverrides() {
-            for (const fileRecord of this.state.values()) {
-                if (fileRecord.templateOverrides !== null) {
-                    fileRecord.templateOverrides = null;
-                    fileRecord.shimData.clear();
-                    fileRecord.isComplete = false;
-                }
-            }
-            // Ideally only those components with overridden templates would have their caches invalidated,
-            // but the `TemplateTypeCheckerImpl` does not track the class for components with overrides. As
-            // a quick workaround, clear the entire cache instead.
-            this.completionCache.clear();
-            this.symbolBuilderCache.clear();
-        }
         getTemplate(component) {
             const { data } = this.getLatestComponentState(component);
             if (data === null) {
@@ -37527,28 +37677,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
             return { data, tcb, shimPath };
         }
-        overrideComponentTemplate(component, template) {
-            const { nodes, errors } = parseTemplate(template, 'override.html', {
-                preserveWhitespaces: true,
-                leadingTriviaChars: [],
-            });
-            const filePath = absoluteFromSourceFile(component.getSourceFile());
-            const fileRecord = this.getFileData(filePath);
-            const id = fileRecord.sourceManager.getTemplateId(component);
-            if (fileRecord.templateOverrides === null) {
-                fileRecord.templateOverrides = new Map();
-            }
-            fileRecord.templateOverrides.set(id, { nodes, errors });
-            // Clear data for the shim in question, so it'll be regenerated on the next request.
-            const shimFile = this.typeCheckingStrategy.shimPathForComponent(component);
-            fileRecord.shimData.delete(shimFile);
-            fileRecord.isComplete = false;
-            this.isComplete = false;
-            // Overriding a component's template invalidates its cached results.
-            this.completionCache.delete(component);
-            this.symbolBuilderCache.delete(component);
-            return { nodes, errors };
-        }
         isTrackedTypeCheckFile(filePath) {
             return this.getFileAndShimRecordsForPath(filePath) !== null;
         }
@@ -37648,6 +37776,20 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
             return engine.getExpressionCompletionLocation(ast);
         }
+        invalidateClass(clazz) {
+            this.completionCache.delete(clazz);
+            this.symbolBuilderCache.delete(clazz);
+            this.scopeCache.delete(clazz);
+            this.elementTagCache.delete(clazz);
+            const sf = clazz.getSourceFile();
+            const sfPath = absoluteFromSourceFile(sf);
+            const shimPath = this.typeCheckingStrategy.shimPathForComponent(clazz);
+            const fileData = this.getFileData(sfPath);
+            const templateId = fileData.sourceManager.getTemplateId(clazz);
+            fileData.shimData.delete(shimPath);
+            fileData.isComplete = false;
+            this.isComplete = false;
+        }
         getOrCreateCompletionEngine(component) {
             if (this.completionCache.has(component)) {
                 return this.completionCache.get(component);
@@ -37664,18 +37806,13 @@ Either add the @Injectable() decorator to '${provider.node.name
             const sfPath = absoluteFromSourceFile(sf);
             if (this.state.has(sfPath)) {
                 const existingResults = this.state.get(sfPath);
-                if (existingResults.templateOverrides !== null) {
-                    // Cannot adopt prior results if template overrides have been requested.
-                    return;
-                }
                 if (existingResults.isComplete) {
                     // All data for this file has already been generated, so no need to adopt anything.
                     return;
                 }
             }
             const previousResults = this.priorBuild.priorTypeCheckingResultsFor(sf);
-            if (previousResults === null || !previousResults.isComplete ||
-                previousResults.templateOverrides !== null) {
+            if (previousResults === null || !previousResults.isComplete) {
                 return;
             }
             this.state.set(sfPath, previousResults);
@@ -37766,7 +37903,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             if (!this.state.has(path)) {
                 this.state.set(path, {
                     hasInlines: false,
-                    templateOverrides: null,
                     sourceManager: new TemplateSourceManager(),
                     isComplete: false,
                     shimData: new Map(),
@@ -37919,17 +38055,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             // The component needs to be checked unless the shim which would contain it already exists.
             return !fileData.shimData.has(shimPath);
         }
-        getTemplateOverride(sfPath, node) {
-            const fileData = this.impl.getFileData(sfPath);
-            if (fileData.templateOverrides === null) {
-                return null;
-            }
-            const templateId = fileData.sourceManager.getTemplateId(node);
-            if (fileData.templateOverrides.has(templateId)) {
-                return fileData.templateOverrides.get(templateId);
-            }
-            return null;
-        }
         recordShimData(sfPath, data) {
             const fileData = this.impl.getFileData(sfPath);
             fileData.shimData.set(data.path, data);
@@ -37969,17 +38094,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             // Only need to generate a TCB for the class if no shim exists for it currently.
             return !this.fileData.shimData.has(shimPath);
         }
-        getTemplateOverride(sfPath, node) {
-            this.assertPath(sfPath);
-            if (this.fileData.templateOverrides === null) {
-                return null;
-            }
-            const templateId = this.fileData.sourceManager.getTemplateId(node);
-            if (this.fileData.templateOverrides.has(templateId)) {
-                return this.fileData.templateOverrides.get(templateId);
-            }
-            return null;
-        }
         recordShimData(sfPath, data) {
             this.assertPath(sfPath);
             // Previous type-checking state may have required the use of inlines (assuming they were
@@ -38033,6 +38147,61 @@ 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
      */
+    /**
+     * Discriminant type for a `CompilationTicket`.
+     */
+    var CompilationTicketKind;
+    (function (CompilationTicketKind) {
+        CompilationTicketKind[CompilationTicketKind["Fresh"] = 0] = "Fresh";
+        CompilationTicketKind[CompilationTicketKind["IncrementalTypeScript"] = 1] = "IncrementalTypeScript";
+        CompilationTicketKind[CompilationTicketKind["IncrementalResource"] = 2] = "IncrementalResource";
+    })(CompilationTicketKind || (CompilationTicketKind = {}));
+    /**
+     * Create a `CompilationTicket` for a brand new compilation, using no prior state.
+     */
+    function freshCompilationTicket(tsProgram, options, incrementalBuildStrategy, typeCheckingProgramStrategy, enableTemplateTypeChecker, usePoisonedData) {
+        return {
+            kind: CompilationTicketKind.Fresh,
+            tsProgram,
+            options,
+            incrementalBuildStrategy,
+            typeCheckingProgramStrategy,
+            enableTemplateTypeChecker,
+            usePoisonedData,
+        };
+    }
+    /**
+     * 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) {
+        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);
+        }
+        const newDriver = IncrementalDriver.reconcile(oldProgram, oldDriver, newProgram, modifiedResourceFiles);
+        return {
+            kind: CompilationTicketKind.IncrementalTypeScript,
+            enableTemplateTypeChecker: oldCompiler.enableTemplateTypeChecker,
+            usePoisonedData: oldCompiler.usePoisonedData,
+            options: oldCompiler.options,
+            incrementalBuildStrategy,
+            typeCheckingProgramStrategy,
+            newDriver,
+            oldProgram,
+            newProgram,
+        };
+    }
+    function resourceChangeTicket(compiler, modifiedResourceFiles) {
+        return {
+            kind: CompilationTicketKind.IncrementalResource,
+            compiler,
+            modifiedResourceFiles,
+        };
+    }
     /**
      * The heart of the Angular Ivy compiler.
      *
@@ -38046,12 +38215,13 @@ Either add the @Injectable() decorator to '${provider.node.name
      * See the README.md for more information.
      */
     class NgCompiler {
-        constructor(adapter, options, tsProgram, typeCheckingProgramStrategy, incrementalStrategy, enableTemplateTypeChecker, usePoisonedData, oldProgram = null, perfRecorder = NOOP_PERF_RECORDER) {
+        constructor(adapter, options, tsProgram, typeCheckingProgramStrategy, incrementalStrategy, incrementalDriver, enableTemplateTypeChecker, usePoisonedData, perfRecorder = NOOP_PERF_RECORDER) {
             this.adapter = adapter;
             this.options = options;
             this.tsProgram = tsProgram;
             this.typeCheckingProgramStrategy = typeCheckingProgramStrategy;
             this.incrementalStrategy = incrementalStrategy;
+            this.incrementalDriver = incrementalDriver;
             this.enableTemplateTypeChecker = enableTemplateTypeChecker;
             this.usePoisonedData = usePoisonedData;
             this.perfRecorder = perfRecorder;
@@ -38095,31 +38265,55 @@ Either add the @Injectable() decorator to '${provider.node.name
                 new ModuleResolver(tsProgram, this.options, this.adapter, moduleResolutionCache);
             this.resourceManager = new AdapterResourceLoader(adapter, this.options);
             this.cycleAnalyzer = new CycleAnalyzer(new ImportGraph(this.moduleResolver));
-            let modifiedResourceFiles = null;
-            if (this.adapter.getModifiedResourceFiles !== undefined) {
-                modifiedResourceFiles = this.adapter.getModifiedResourceFiles() || null;
-            }
-            if (oldProgram === null) {
-                this.incrementalDriver = IncrementalDriver.fresh(tsProgram);
-            }
-            else {
-                const oldDriver = this.incrementalStrategy.getIncrementalDriver(oldProgram);
-                if (oldDriver !== null) {
-                    this.incrementalDriver =
-                        IncrementalDriver.reconcile(oldProgram, oldDriver, tsProgram, modifiedResourceFiles);
-                }
-                else {
-                    // A previous ts.Program was used to create the current one, but it wasn't from an
-                    // `NgCompiler`. That doesn't hurt anything, but the Angular analysis will have to start
-                    // from a fresh state.
-                    this.incrementalDriver = IncrementalDriver.fresh(tsProgram);
-                }
-            }
             this.incrementalStrategy.setIncrementalDriver(this.incrementalDriver, tsProgram);
             this.ignoreForDiagnostics =
                 new Set(tsProgram.getSourceFiles().filter(sf => this.adapter.isShim(sf)));
             this.ignoreForEmit = this.adapter.ignoreForEmit;
         }
+        /**
+         * 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.
+         */
+        static fromTicket(ticket, adapter, perfRecorder) {
+            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);
+                case CompilationTicketKind.IncrementalTypeScript:
+                    return new NgCompiler(adapter, ticket.options, ticket.newProgram, ticket.typeCheckingProgramStrategy, ticket.incrementalBuildStrategy, ticket.newDriver, ticket.enableTemplateTypeChecker, ticket.usePoisonedData, perfRecorder);
+                case CompilationTicketKind.IncrementalResource:
+                    const compiler = ticket.compiler;
+                    compiler.updateWithChangedResources(ticket.modifiedResourceFiles);
+                    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);
+                }
+                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;
+                }
+                this.compilation.templateTypeChecker.invalidateClass(clazz);
+            }
+        }
         /**
          * Get the resource dependencies of a file.
          *
@@ -38133,7 +38327,7 @@ Either add the @Injectable() decorator to '${provider.node.name
          * Get all Angular-related diagnostics for this compilation.
          */
         getDiagnostics() {
-            return [...this.getNonTemplateDiagnostics(), ...this.getTemplateDiagnostics()];
+            return this.addMessageTextDetails([...this.getNonTemplateDiagnostics(), ...this.getTemplateDiagnostics()]);
         }
         /**
          * Get all Angular-related diagnostics for this compilation.
@@ -38141,10 +38335,22 @@ Either add the @Injectable() decorator to '${provider.node.name
          * If a `ts.SourceFile` is passed, only diagnostics related to that file are returned.
          */
         getDiagnosticsForFile(file, optimizeFor) {
-            return [
+            return this.addMessageTextDetails([
                 ...this.getNonTemplateDiagnostics().filter(diag => diag.file === file),
                 ...this.getTemplateDiagnosticsForFile(file, optimizeFor)
-            ];
+            ]);
+        }
+        /**
+         * Add Angular.io error guide links to diagnostics for this compilation.
+         */
+        addMessageTextDetails(diagnostics) {
+            return diagnostics.map(diag => {
+                if (diag.code && COMPILER_ERRORS_WITH_GUIDES.has(ngErrorCode(diag.code))) {
+                    return Object.assign(Object.assign({}, diag), { messageText: diag.messageText +
+                            `. Find more at ${ERROR_DETAILS_PAGE_BASE_URL}/NG${ngErrorCode(diag.code)}` });
+                }
+                return diag;
+            });
         }
         /**
          * Get all setup-related diagnostics for this compilation.
@@ -38734,7 +38940,7 @@ Either add the @Injectable() decorator to '${provider.node.name
     }
     /**
      * Since "strictTemplates" is a true superset of type checking capabilities compared to
-     * "strictTemplateTypeCheck", it is required that the latter is not explicitly disabled if the
+     * "fullTemplateTypeCheck", it is required that the latter is not explicitly disabled if the
      * former is enabled.
      */
     function verifyCompatibleTypeCheckOptions(options) {
@@ -39328,9 +39534,6 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
     function isTypeScriptFile(fileName) {
         return fileName.endsWith('.ts');
     }
-    function isExternalTemplate(fileName) {
-        return !isTypeScriptFile(fileName);
-    }
     function isWithin(position, span) {
         let start, end;
         if (span instanceof ParseSourceSpan) {
@@ -39345,6 +39548,31 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         // like ¦start and end¦ where ¦ is the cursor.
         return start <= position && position <= end;
     }
+    /**
+     * For a given location in a shim file, retrieves the corresponding file url for the template and
+     * the span in the template.
+     */
+    function getTemplateLocationFromShimLocation(templateTypeChecker, shimPath, positionInShimFile) {
+        const mapping = templateTypeChecker.getTemplateMappingAtShimLocation({ shimPath, positionInShimFile });
+        if (mapping === null) {
+            return null;
+        }
+        const { templateSourceMapping, span } = mapping;
+        let templateUrl;
+        if (templateSourceMapping.type === 'direct') {
+            templateUrl = absoluteFromSourceFile(templateSourceMapping.node.getSourceFile());
+        }
+        else if (templateSourceMapping.type === 'external') {
+            templateUrl = absoluteFrom(templateSourceMapping.templateUrl);
+        }
+        else {
+            // This includes indirect mappings, which are difficult to map directly to the code
+            // location. Diagnostics similarly return a synthetic template string for this case rather
+            // than a real location.
+            return null;
+        }
+        return { templateUrl, span };
+    }
 
     /**
      * @license
@@ -39361,7 +39589,12 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             this.ignoreForEmit = new Set();
             this.factoryTracker = null; // no .ngfactory shims
             this.unifiedModulesHost = null; // only used in Bazel
-            this.templateVersion = new Map();
+            /**
+             * Map of resource filenames to the version of the file last read via `readResource`.
+             *
+             * Used to implement `getModifiedResourceFiles`.
+             */
+            this.lastReadResourceVersion = new Map();
             this.rootDirs = getRootDirs(this, project.getCompilationSettings());
         }
         isShim(sf) {
@@ -39379,6 +39612,14 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         getCanonicalFileName(fileName) {
             return this.project.projectService.toCanonicalFileName(fileName);
         }
+        /**
+         * Return the real path of a symlink. This method is required in order to
+         * resolve symlinks in node_modules.
+         */
+        realpath(path) {
+            var _a, _b, _c;
+            return (_c = (_b = (_a = this.project).realpath) === null || _b === void 0 ? void 0 : _b.call(_a, path)) !== null && _c !== void 0 ? _c : path;
+        }
         /**
          * readResource() is an Angular-specific method for reading files that are not
          * managed by the TS compiler host, namely templates and stylesheets.
@@ -39401,13 +39642,17 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                 throw new Error(`Failed to get script snapshot while trying to read ${fileName}`);
             }
             const version = this.project.getScriptVersion(fileName);
-            this.templateVersion.set(fileName, version);
+            this.lastReadResourceVersion.set(fileName, version);
             return snapshot.getText(0, snapshot.getLength());
         }
-        isTemplateDirty(fileName) {
-            const lastVersion = this.templateVersion.get(fileName);
-            const latestVersion = this.project.getScriptVersion(fileName);
-            return lastVersion !== latestVersion;
+        getModifiedResourceFiles() {
+            const modifiedFiles = new Set();
+            for (const [fileName, oldVersion] of this.lastReadResourceVersion) {
+                if (this.project.getScriptVersion(fileName) !== oldVersion) {
+                    modifiedFiles.add(fileName);
+                }
+            }
+            return modifiedFiles.size > 0 ? modifiedFiles : undefined;
         }
     }
     /**
@@ -39487,46 +39732,27 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             this.lastKnownProgram = null;
         }
         getOrCreate() {
+            var _a;
             const program = this.programStrategy.getProgram();
-            if (this.compiler === null || program !== this.lastKnownProgram) {
-                this.compiler = new NgCompiler(this.adapter, // like compiler host
-                this.options, // angular compiler options
-                program, this.programStrategy, this.incrementalStrategy, true, // enableTemplateTypeChecker
-                true, // usePoisonedData
-                this.lastKnownProgram, undefined);
-                this.lastKnownProgram = program;
-            }
-            return this.compiler;
-        }
-        /**
-         * Create a new instance of the Ivy compiler if the program has changed since
-         * the last time the compiler was instantiated. If the program has not changed,
-         * return the existing instance.
-         * @param fileName override the template if this is an external template file
-         * @param options angular compiler options
-         */
-        getOrCreateWithChangedFile(fileName) {
-            const compiler = this.getOrCreate();
-            if (isExternalTemplate(fileName)) {
-                this.overrideTemplate(fileName, compiler);
+            const modifiedResourceFiles = (_a = this.adapter.getModifiedResourceFiles()) !== null && _a !== void 0 ? _a : new Set();
+            if (this.compiler !== null && program === this.lastKnownProgram) {
+                if (modifiedResourceFiles.size > 0) {
+                    // Only resource files have changed since the last NgCompiler was created.
+                    const ticket = resourceChangeTicket(this.compiler, modifiedResourceFiles);
+                    this.compiler = NgCompiler.fromTicket(ticket, this.adapter);
+                }
+                return this.compiler;
             }
-            return compiler;
-        }
-        overrideTemplate(fileName, compiler) {
-            if (!this.adapter.isTemplateDirty(fileName)) {
-                return;
+            let ticket;
+            if (this.compiler === null || this.lastKnownProgram === null) {
+                ticket = freshCompilationTicket(program, this.options, this.incrementalStrategy, this.programStrategy, true, true);
             }
-            // 1. Get the latest snapshot
-            const latestTemplate = this.adapter.readResource(fileName);
-            // 2. Find all components that use the template
-            const ttc = compiler.getTemplateTypeChecker();
-            const components = compiler.getComponentsWithTemplateFile(fileName);
-            // 3. Update component template
-            for (const component of components) {
-                if (ts.isClassDeclaration(component)) {
-                    ttc.overrideComponentTemplate(component, latestTemplate);
-                }
+            else {
+                ticket = incrementalFromCompilerTicket(this.compiler, program, this.incrementalStrategy, this.programStrategy, modifiedResourceFiles);
             }
+            this.compiler = NgCompiler.fromTicket(ticket, this.adapter);
+            this.lastKnownProgram = program;
+            return this.compiler;
         }
         registerLastKnownProgram() {
             this.lastKnownProgram = this.programStrategy.getProgram();
@@ -40137,12 +40363,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                 return undefined;
             }
             const { componentContext, templateContext } = completions;
-            let replacementSpan = undefined;
-            // Non-empty nodes get replaced with the completion.
-            if (!(this.node instanceof EmptyExpr || this.node instanceof LiteralPrimitive ||
-                this.node instanceof BoundEvent)) {
-                replacementSpan = makeReplacementSpanFromAst(this.node);
-            }
+            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);
@@ -40473,6 +40694,11 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         };
     }
     function makeReplacementSpanFromAst(node) {
+        if ((node instanceof EmptyExpr || node instanceof LiteralPrimitive ||
+            node instanceof BoundEvent)) {
+            // empty nodes do not replace any existing text
+            return undefined;
+        }
         return {
             start: node.nameSpan.start,
             length: node.nameSpan.end - node.nameSpan.start,
@@ -40872,15 +41098,20 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                 case SymbolKind.Reference: {
                     const definitions = [];
                     if (symbol.declaration !== node) {
-                        definitions.push({
-                            name: symbol.declaration.name,
-                            containerName: '',
-                            containerKind: ts$1.ScriptElementKind.unknown,
-                            kind: ts$1.ScriptElementKind.variableElement,
-                            textSpan: getTextSpanOfNode(symbol.declaration),
-                            contextSpan: toTextSpan(symbol.declaration.sourceSpan),
-                            fileName: symbol.declaration.sourceSpan.start.file.url,
-                        });
+                        const shimLocation = symbol.kind === SymbolKind.Variable ? symbol.localVarLocation :
+                            symbol.referenceVarLocation;
+                        const mapping = getTemplateLocationFromShimLocation(this.compiler.getTemplateTypeChecker(), shimLocation.shimPath, shimLocation.positionInShimFile);
+                        if (mapping !== null) {
+                            definitions.push({
+                                name: symbol.declaration.name,
+                                containerName: '',
+                                containerKind: ts$1.ScriptElementKind.unknown,
+                                kind: ts$1.ScriptElementKind.variableElement,
+                                textSpan: getTextSpanOfNode(symbol.declaration),
+                                contextSpan: toTextSpan(symbol.declaration.sourceSpan),
+                                fileName: mapping.templateUrl,
+                            });
+                        }
                     }
                     if (symbol.kind === SymbolKind.Variable) {
                         definitions.push(...this.getDefinitionsForSymbols({ shimLocation: symbol.initializerLocation }));
@@ -41403,29 +41634,14 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                 // return references to the parameter in the template itself.
                 return null;
             }
-            // TODO(atscott): Determine how to consistently resolve paths. i.e. with the project serverHost
-            // or LSParseConfigHost in the adapter. We should have a better defined way to normalize paths.
-            const mapping = templateTypeChecker.getTemplateMappingAtShimLocation({
-                shimPath: absoluteFrom(shimReferenceEntry.fileName),
-                positionInShimFile: shimReferenceEntry.textSpan.start,
-            });
+            // TODO(atscott): Determine how to consistently resolve paths. i.e. with the project
+            // serverHost or LSParseConfigHost in the adapter. We should have a better defined way to
+            // normalize paths.
+            const mapping = getTemplateLocationFromShimLocation(templateTypeChecker, absoluteFrom(shimReferenceEntry.fileName), shimReferenceEntry.textSpan.start);
             if (mapping === null) {
                 return null;
             }
-            const { templateSourceMapping, span } = mapping;
-            let templateUrl;
-            if (templateSourceMapping.type === 'direct') {
-                templateUrl = absoluteFromSourceFile(templateSourceMapping.node.getSourceFile());
-            }
-            else if (templateSourceMapping.type === 'external') {
-                templateUrl = absoluteFrom(templateSourceMapping.templateUrl);
-            }
-            else {
-                // This includes indirect mappings, which are difficult to map directly to the code location.
-                // Diagnostics similarly return a synthetic template string for this case rather than a real
-                // location.
-                return null;
-            }
+            const { span, templateUrl } = mapping;
             return Object.assign(Object.assign({}, shimReferenceEntry), { fileName: templateUrl, textSpan: toTextSpan(span) });
         }
     }
@@ -41439,6 +41655,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
      */
     class LanguageService {
         constructor(project, tsLS) {
+            this.project = project;
             this.tsLS = tsLS;
             this.parseConfigHost = new LSParseConfigHost(project.projectService.host);
             this.options = parseNgCompilerOptions(project, this.parseConfigHost);
@@ -41452,7 +41669,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             return this.options;
         }
         getSemanticDiagnostics(fileName) {
-            const compiler = this.compilerFactory.getOrCreateWithChangedFile(fileName);
+            const compiler = this.compilerFactory.getOrCreate();
             const ttc = compiler.getTemplateTypeChecker();
             const diagnostics = [];
             if (isTypeScriptFile(fileName)) {
@@ -41474,19 +41691,19 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             return diagnostics;
         }
         getDefinitionAndBoundSpan(fileName, position) {
-            const compiler = this.compilerFactory.getOrCreateWithChangedFile(fileName);
+            const compiler = this.compilerFactory.getOrCreate();
             const results = new DefinitionBuilder(this.tsLS, compiler).getDefinitionAndBoundSpan(fileName, position);
             this.compilerFactory.registerLastKnownProgram();
             return results;
         }
         getTypeDefinitionAtPosition(fileName, position) {
-            const compiler = this.compilerFactory.getOrCreateWithChangedFile(fileName);
+            const compiler = this.compilerFactory.getOrCreate();
             const results = new DefinitionBuilder(this.tsLS, compiler).getTypeDefinitionsAtPosition(fileName, position);
             this.compilerFactory.registerLastKnownProgram();
             return results;
         }
         getQuickInfoAtPosition(fileName, position) {
-            const compiler = this.compilerFactory.getOrCreateWithChangedFile(fileName);
+            const compiler = this.compilerFactory.getOrCreate();
             const templateInfo = getTemplateInfoAtPosition(fileName, position, compiler);
             if (templateInfo === undefined) {
                 return undefined;
@@ -41506,13 +41723,13 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             return results;
         }
         getReferencesAtPosition(fileName, position) {
-            const compiler = this.compilerFactory.getOrCreateWithChangedFile(fileName);
+            const compiler = this.compilerFactory.getOrCreate();
             const results = new ReferenceBuilder(this.strategy, this.tsLS, compiler).get(fileName, position);
             this.compilerFactory.registerLastKnownProgram();
             return results;
         }
         getCompletionBuilder(fileName, position) {
-            const compiler = this.compilerFactory.getOrCreateWithChangedFile(fileName);
+            const compiler = this.compilerFactory.getOrCreate();
             const templateInfo = getTemplateInfoAtPosition(fileName, position, compiler);
             if (templateInfo === undefined) {
                 return null;
@@ -41555,6 +41772,28 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             this.compilerFactory.registerLastKnownProgram();
             return result;
         }
+        getCompilerOptionsDiagnostics() {
+            const project = this.project;
+            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;
+        }
         watchConfigFile(project) {
             // TODO: Check the case when the project is disposed. An InferredProject
             // could be disposed when a tsconfig.json is added to the workspace,
@@ -41755,6 +41994,20 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                 return (_a = tsLS.getCompletionEntrySymbol(fileName, position, name, source)) !== null && _a !== void 0 ? _a : ngLS.getCompletionEntrySymbol(fileName, position, name);
             }
         }
+        /**
+         * Gets global diagnostics related to the program configuration and compiler options.
+         */
+        function getCompilerOptionsDiagnostics() {
+            const diagnostics = [];
+            if (!angularOnly) {
+                diagnostics.push(...tsLS.getCompilerOptionsDiagnostics());
+            }
+            diagnostics.push(...ngLS.getCompilerOptionsDiagnostics());
+            return diagnostics;
+        }
+        function getTcb(fileName, position) {
+            return undefined;
+        }
         return Object.assign(Object.assign({}, tsLS), { getSemanticDiagnostics,
             getTypeDefinitionAtPosition,
             getQuickInfoAtPosition,
@@ -41763,7 +42016,9 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             findRenameLocations,
             getCompletionsAtPosition,
             getCompletionEntryDetails,
-            getCompletionEntrySymbol });
+            getCompletionEntrySymbol,
+            getCompilerOptionsDiagnostics,
+            getTcb });
     }
     function getExternalFiles(project) {
         if (!project.hasRoots()) {