@angular/language-service 11.1.2 → 11.2.0

package/bundles/ivy.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v11.1.2
+ * @license Angular v11.2.0
  * Copyright Google LLC All Rights Reserved.
  * License: MIT
  */
@@ -11665,6 +11665,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return new Chain(this.span(start), this.sourceSpan(start), exprs);
         }
         parsePipe() {
+            const start = this.inputIndex;
             let result = this.parseExpression();
             if (this.consumeOptionalOperator('|')) {
                 if (this.parseAction) {
@@ -11700,7 +11701,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                         // 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, fullSpanEnd), result, nameId, args, nameSpan);
                 } while (this.consumeOptionalOperator('|'));
             }
@@ -11732,26 +11732,27 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
         parseLogicalOr() {
             // '||'
+            const start = this.inputIndex;
             let result = this.parseLogicalAnd();
             while (this.consumeOptionalOperator('||')) {
                 const right = this.parseLogicalAnd();
-                const { start } = result.span;
                 result = new Binary(this.span(start), this.sourceSpan(start), '||', result, right);
             }
             return result;
         }
         parseLogicalAnd() {
             // '&&'
+            const start = this.inputIndex;
             let result = this.parseEquality();
             while (this.consumeOptionalOperator('&&')) {
                 const right = this.parseEquality();
-                const { start } = result.span;
                 result = new Binary(this.span(start), this.sourceSpan(start), '&&', result, right);
             }
             return result;
         }
         parseEquality() {
             // '==','!=','===','!=='
+            const start = this.inputIndex;
             let result = this.parseRelational();
             while (this.next.type == TokenType$1.Operator) {
                 const operator = this.next.strValue;
@@ -11762,7 +11763,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     case '!==':
                         this.advance();
                         const right = this.parseRelational();
-                        const { start } = result.span;
                         result = new Binary(this.span(start), this.sourceSpan(start), operator, result, right);
                         continue;
                 }
@@ -11772,6 +11772,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
         parseRelational() {
             // '<', '>', '<=', '>='
+            const start = this.inputIndex;
             let result = this.parseAdditive();
             while (this.next.type == TokenType$1.Operator) {
                 const operator = this.next.strValue;
@@ -11782,7 +11783,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     case '>=':
                         this.advance();
                         const right = this.parseAdditive();
-                        const { start } = result.span;
                         result = new Binary(this.span(start), this.sourceSpan(start), operator, result, right);
                         continue;
                 }
@@ -11792,6 +11792,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
         parseAdditive() {
             // '+', '-'
+            const start = this.inputIndex;
             let result = this.parseMultiplicative();
             while (this.next.type == TokenType$1.Operator) {
                 const operator = this.next.strValue;
@@ -11800,7 +11801,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     case '-':
                         this.advance();
                         let right = this.parseMultiplicative();
-                        const { start } = result.span;
                         result = new Binary(this.span(start), this.sourceSpan(start), operator, result, right);
                         continue;
                 }
@@ -11810,6 +11810,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
         parseMultiplicative() {
             // '*', '%', '/'
+            const start = this.inputIndex;
             let result = this.parsePrefix();
             while (this.next.type == TokenType$1.Operator) {
                 const operator = this.next.strValue;
@@ -11819,7 +11820,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     case '/':
                         this.advance();
                         let right = this.parsePrefix();
-                        const { start } = result.span;
                         result = new Binary(this.span(start), this.sourceSpan(start), operator, result, right);
                         continue;
                 }
@@ -11850,14 +11850,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return this.parseCallChain();
         }
         parseCallChain() {
+            const start = this.inputIndex;
             let result = this.parsePrimary();
-            const resultStart = result.span.start;
             while (true) {
                 if (this.consumeOptionalCharacter($PERIOD)) {
-                    result = this.parseAccessMemberOrMethodCall(result, false);
+                    result = this.parseAccessMemberOrMethodCall(result, start, false);
                 }
                 else if (this.consumeOptionalOperator('?.')) {
-                    result = this.parseAccessMemberOrMethodCall(result, true);
+                    result = this.parseAccessMemberOrMethodCall(result, start, true);
                 }
                 else if (this.consumeOptionalCharacter($LBRACKET)) {
                     this.withContext(ParseContextFlags.Writable, () => {
@@ -11870,11 +11870,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                         this.expectCharacter($RBRACKET);
                         if (this.consumeOptionalOperator('=')) {
                             const value = this.parseConditional();
-                            result = new KeyedWrite(this.span(resultStart), this.sourceSpan(resultStart), result, key, value);
+                            result = new KeyedWrite(this.span(start), this.sourceSpan(start), result, key, value);
                         }
                         else {
-                            result =
-                                new KeyedRead(this.span(resultStart), this.sourceSpan(resultStart), result, key);
+                            result = new KeyedRead(this.span(start), this.sourceSpan(start), result, key);
                         }
                     });
                 }
@@ -11883,11 +11882,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     const args = this.parseCallArguments();
                     this.rparensExpected--;
                     this.expectCharacter($RPAREN);
-                    result =
-                        new FunctionCall(this.span(resultStart), this.sourceSpan(resultStart), result, args);
+                    result = new FunctionCall(this.span(start), this.sourceSpan(start), result, args);
                 }
                 else if (this.consumeOptionalOperator('!')) {
-                    result = new NonNullAssert(this.span(resultStart), this.sourceSpan(resultStart), result);
+                    result = new NonNullAssert(this.span(start), this.sourceSpan(start), result);
                 }
                 else {
                     return result;
@@ -11934,7 +11932,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 return this.parseLiteralMap();
             }
             else if (this.next.isIdentifier()) {
-                return this.parseAccessMemberOrMethodCall(new ImplicitReceiver(this.span(start), this.sourceSpan(start)), false);
+                return this.parseAccessMemberOrMethodCall(new ImplicitReceiver(this.span(start), this.sourceSpan(start)), start, false);
             }
             else if (this.next.isNumber()) {
                 const value = this.next.toNumber();
@@ -11986,8 +11984,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
             return new LiteralMap(this.span(start), this.sourceSpan(start), keys, values);
         }
-        parseAccessMemberOrMethodCall(receiver, isSafe = false) {
-            const start = receiver.span.start;
+        parseAccessMemberOrMethodCall(receiver, start, isSafe = false) {
             const nameStart = this.inputIndex;
             const id = this.withContext(ParseContextFlags.Writable, () => {
                 var _a;
@@ -13220,6 +13217,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             else if (identifier.length === 0) {
                 this.reportError(`Reference does not have a name`, sourceSpan);
             }
+            else if (references.some(reference => reference.name === identifier)) {
+                this.reportError(`Reference "#${identifier}" is defined more than once`, sourceSpan);
+            }
             references.push(new Reference(identifier, value, sourceSpan, keySpan, valueSpan));
         }
         parseAssignmentEvent(name, expression, sourceSpan, valueSpan, targetMatchableAttrs, boundEvents, keySpan) {
@@ -17011,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.2');
+    const VERSION$1 = new Version('11.2.0');
 
     /**
      * @license
@@ -17668,7 +17668,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
      */
     function createDirectiveDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
-        definitionMap.set('version', literal('11.1.2'));
+        definitionMap.set('version', literal('11.2.0'));
         // e.g. `type: MyDirective`
         definitionMap.set('type', meta.internalType);
         // e.g. `selector: 'some-dir'`
@@ -21116,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.2');
+    const VERSION$2 = new Version('11.2.0');
 
     /**
      * @license
@@ -21212,6 +21212,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
          * has been discovered.
          */
         ErrorCode[ErrorCode["UNDECORATED_CLASS_USING_ANGULAR_FEATURES"] = 2007] = "UNDECORATED_CLASS_USING_ANGULAR_FEATURES";
+        /**
+         * Raised when an component cannot resolve an external resource, such as a template or a style
+         * sheet.
+         */
+        ErrorCode[ErrorCode["COMPONENT_RESOURCE_NOT_FOUND"] = 2008] = "COMPONENT_RESOURCE_NOT_FOUND";
         ErrorCode[ErrorCode["SYMBOL_NOT_EXPORTED"] = 3001] = "SYMBOL_NOT_EXPORTED";
         ErrorCode[ErrorCode["SYMBOL_EXPORTED_UNDER_DIFFERENT_NAME"] = 3002] = "SYMBOL_EXPORTED_UNDER_DIFFERENT_NAME";
         ErrorCode[ErrorCode["CONFIG_FLAT_MODULE_NO_INDEX"] = 4001] = "CONFIG_FLAT_MODULE_NO_INDEX";
@@ -28558,31 +28563,35 @@ Either add the @Injectable() decorator to '${provider.node.name
             const meta = this._resolveLiteral(decorator);
             const component = reflectObjectLiteral(meta);
             const containingFile = node.getSourceFile().fileName;
-            // Convert a styleUrl string into a Promise to preload it.
-            const resolveStyleUrl = (styleUrl) => {
-                const resourceUrl = this.resourceLoader.resolve(styleUrl, containingFile);
-                const promise = this.resourceLoader.preload(resourceUrl);
-                return promise || Promise.resolve();
+            const resolveStyleUrl = (styleUrl, nodeForError, resourceType) => {
+                const resourceUrl = this._resolveResourceOrThrow(styleUrl, containingFile, nodeForError, resourceType);
+                return this.resourceLoader.preload(resourceUrl);
             };
             // 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).then(template => {
+            const templateAndTemplateStyleResources = this._preloadAndParseTemplate(node, decorator, component, containingFile)
+                .then((template) => {
                 if (template === null) {
                     return undefined;
                 }
-                else {
-                    return Promise.all(template.styleUrls.map(resolveStyleUrl)).then(() => undefined);
-                }
+                const nodeForError = getTemplateDeclarationNodeForError(template.declaration);
+                return Promise
+                    .all(template.styleUrls.map(styleUrl => resolveStyleUrl(styleUrl, nodeForError, 1 /* StylesheetFromTemplate */)))
+                    .then(() => undefined);
             });
             // Extract all the styleUrls in the decorator.
-            const styleUrls = this._extractStyleUrls(component, []);
-            if (styleUrls === null) {
+            const componentStyleUrls = this._extractComponentStyleUrls(component);
+            if (componentStyleUrls === null) {
                 // A fast path exists if there are no styleUrls, to just wait for
                 // templateAndTemplateStyleResources.
                 return templateAndTemplateStyleResources;
             }
             else {
                 // Wait for both the template and all styleUrl resources to resolve.
-                return Promise.all([templateAndTemplateStyleResources, ...styleUrls.map(resolveStyleUrl)])
+                return Promise
+                    .all([
+                    templateAndTemplateStyleResources,
+                    ...componentStyleUrls.map(styleUrl => resolveStyleUrl(styleUrl.url, styleUrl.nodeForError, 2 /* StylesheetFromDecorator */))
+                ])
                     .then(() => undefined);
             }
         }
@@ -28651,20 +28660,20 @@ Either add the @Injectable() decorator to '${provider.node.name
             // 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.
-            let styles = null;
+            let styles = [];
             const styleResources = this._extractStyleResources(component, containingFile);
-            const styleUrls = this._extractStyleUrls(component, template.styleUrls);
-            if (styleUrls !== null) {
-                if (styles === null) {
-                    styles = [];
-                }
-                for (const styleUrl of styleUrls) {
-                    const resourceUrl = this.resourceLoader.resolve(styleUrl, containingFile);
-                    const resourceStr = this.resourceLoader.load(resourceUrl);
-                    styles.push(resourceStr);
-                    if (this.depTracker !== null) {
-                        this.depTracker.addResourceDependency(node.getSourceFile(), absoluteFrom(resourceUrl));
-                    }
+            const styleUrls = [
+                ...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));
                 }
             }
             let inlineStyles = null;
@@ -28672,21 +28681,11 @@ Either add the @Injectable() decorator to '${provider.node.name
                 const litStyles = parseFieldArrayValue(component, 'styles', this.evaluator);
                 if (litStyles !== null) {
                     inlineStyles = [...litStyles];
-                    if (styles === null) {
-                        styles = litStyles;
-                    }
-                    else {
-                        styles.push(...litStyles);
-                    }
+                    styles.push(...litStyles);
                 }
             }
             if (template.styles.length > 0) {
-                if (styles === null) {
-                    styles = template.styles;
-                }
-                else {
-                    styles.push(...template.styles);
-                }
+                styles.push(...template.styles);
             }
             const encapsulation = this._resolveEnumValue(component, 'encapsulation', 'ViewEncapsulation') || 0;
             const changeDetection = this._resolveEnumValue(component, 'changeDetection', 'ChangeDetectionStrategy');
@@ -28702,7 +28701,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                     meta: Object.assign(Object.assign({}, metadata), { template: {
                             nodes: template.nodes,
                             ngContentSelectors: template.ngContentSelectors,
-                        }, encapsulation, interpolation: (_a = template.interpolationConfig) !== null && _a !== void 0 ? _a : DEFAULT_INTERPOLATION_CONFIG, styles: styles || [], 
+                        }, encapsulation, interpolation: (_a = template.interpolationConfig) !== null && _a !== void 0 ? _a : DEFAULT_INTERPOLATION_CONFIG, styles,
                         // These will be replaced during the compilation step, after all `NgModule`s have been
                         // analyzed and the full compilation scope for the component can be realized.
                         animations, viewProviders: wrappedViewProviders, i18nUseExternalIds: this.i18nUseExternalIds, relativeContextFilePath }),
@@ -28893,7 +28892,10 @@ Either add the @Injectable() decorator to '${provider.node.name
             let styles = [];
             if (analysis.styleUrls !== null) {
                 for (const styleUrl of analysis.styleUrls) {
-                    const resolvedStyleUrl = this.resourceLoader.resolve(styleUrl, containingFile);
+                    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);
                 }
@@ -28966,16 +28968,45 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
             return resolved;
         }
-        _extractStyleUrls(component, extraUrls) {
+        _extractComponentStyleUrls(component) {
             if (!component.has('styleUrls')) {
-                return extraUrls.length > 0 ? extraUrls : null;
+                return [];
             }
-            const styleUrlsExpr = component.get('styleUrls');
-            const styleUrls = this.evaluator.evaluate(styleUrlsExpr);
-            if (!Array.isArray(styleUrls) || !styleUrls.every(url => typeof url === 'string')) {
-                throw createValueHasWrongTypeError(styleUrlsExpr, styleUrls, 'styleUrls must be an array of strings');
+            return this._extractStyleUrlsFromExpression(component.get('styleUrls'));
+        }
+        _extractStyleUrlsFromExpression(styleUrlsExpr) {
+            const styleUrls = [];
+            if (ts$1.isArrayLiteralExpression(styleUrlsExpr)) {
+                for (const styleUrlExpr of styleUrlsExpr.elements) {
+                    if (ts$1.isSpreadElement(styleUrlExpr)) {
+                        styleUrls.push(...this._extractStyleUrlsFromExpression(styleUrlExpr.expression));
+                    }
+                    else {
+                        const styleUrl = this.evaluator.evaluate(styleUrlExpr);
+                        if (typeof styleUrl !== 'string') {
+                            throw createValueHasWrongTypeError(styleUrlExpr, styleUrl, 'styleUrl must be a string');
+                        }
+                        styleUrls.push({
+                            url: styleUrl,
+                            source: 2 /* StylesheetFromDecorator */,
+                            nodeForError: styleUrlExpr,
+                        });
+                    }
+                }
+            }
+            else {
+                const evaluatedStyleUrls = this.evaluator.evaluate(styleUrlsExpr);
+                if (!isStringArray(evaluatedStyleUrls)) {
+                    throw createValueHasWrongTypeError(styleUrlsExpr, evaluatedStyleUrls, 'styleUrls must be an array of strings');
+                }
+                for (const styleUrl of evaluatedStyleUrls) {
+                    styleUrls.push({
+                        url: styleUrl,
+                        source: 2 /* StylesheetFromDecorator */,
+                        nodeForError: styleUrlsExpr,
+                    });
+                }
             }
-            styleUrls.push(...extraUrls);
             return styleUrls;
         }
         _extractStyleResources(component, containingFile) {
@@ -28988,7 +29019,7 @@ 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.resourceLoader.resolve(expression.text, containingFile);
+                    const resourceUrl = this._resolveResourceOrThrow(expression.text, containingFile, expression, 2 /* StylesheetFromDecorator */);
                     styles.add({ path: absoluteFrom(resourceUrl), expression });
                 }
             }
@@ -29008,7 +29039,7 @@ 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.resourceLoader.resolve(templateUrl, containingFile);
+                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.
@@ -29151,7 +29182,7 @@ 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.resourceLoader.resolve(templateUrl, containingFile);
+                const resourceUrl = this._resolveResourceOrThrow(templateUrl, containingFile, templateUrlExpr, 0 /* Template */);
                 return {
                     isInline: false,
                     interpolationConfig,
@@ -29199,6 +29230,38 @@ 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);
+            }
+        }
+        _extractTemplateStyleUrls(template) {
+            if (template.styleUrls === null) {
+                return [];
+            }
+            const nodeForError = getTemplateDeclarationNodeForError(template.declaration);
+            return template.styleUrls.map(url => ({ url, source: 1 /* StylesheetFromTemplate */, nodeForError }));
+        }
     }
     function getTemplateRange(templateExpr) {
         const startPos = templateExpr.getStart() + 1;
@@ -29221,6 +29284,22 @@ Either add the @Injectable() decorator to '${provider.node.name
             return resourceUrl;
         }
     }
+    /** Determines if the result of an evaluation is a string array. */
+    function isStringArray(resolvedValue) {
+        return Array.isArray(resolvedValue) && resolvedValue.every(elem => typeof elem === 'string');
+    }
+    /** Determines the node to use for debugging purposes for the given TemplateDeclaration. */
+    function getTemplateDeclarationNodeForError(declaration) {
+        // TODO(zarend): Change this to if/else when that is compatible with g3. This uses a switch
+        // because if/else fails to compile on g3. That is because g3 compiles this in non-strict mode
+        // where type inference does not work correctly.
+        switch (declaration.isInline) {
+            case true:
+                return declaration.expression;
+            case false:
+                return declaration.templateUrlExpression;
+        }
+    }
 
     /**
      * @license
@@ -34061,8 +34140,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.typeCtorStatements = [];
             this.pipeInsts = new Map();
             this.pipeInstStatements = [];
-            this.outputHelperIdent = null;
-            this.helperStatements = [];
         }
         /**
          * Get an expression referring to a type constructor for the given directive.
@@ -34122,85 +34199,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             this.pipeInsts.set(ref.node, pipeInstId);
             return pipeInstId;
         }
-        /**
-         * Declares a helper function to be able to cast directive outputs of type `EventEmitter<T>` to
-         * have an accurate `subscribe()` method that properly carries over the generic type `T` into the
-         * listener function passed as argument to `subscribe`. This is done to work around a typing
-         * deficiency in `EventEmitter.subscribe`, where the listener function is typed as any.
-         */
-        declareOutputHelper() {
-            if (this.outputHelperIdent !== null) {
-                return this.outputHelperIdent;
-            }
-            const outputHelperIdent = ts$1.createIdentifier('_outputHelper');
-            const genericTypeDecl = ts$1.createTypeParameterDeclaration('T');
-            const genericTypeRef = ts$1.createTypeReferenceNode('T', /* typeParameters */ undefined);
-            const eventEmitter = this.referenceExternalType('@angular/core', 'EventEmitter', [new ExpressionType(new WrappedNodeExpr(genericTypeRef))]);
-            // Declare a type that has a `subscribe` method that carries over type `T` as parameter
-            // into the callback. The below code generates the following type literal:
-            // `{subscribe(cb: (event: T) => any): void;}`
-            const observableLike = ts$1.createTypeLiteralNode([ts$1.createMethodSignature(
-                /* typeParameters */ undefined, 
-                /* parameters */ [ts$1.createParameter(
-                    /* decorators */ undefined, 
-                    /* modifiers */ undefined, 
-                    /* dotDotDotToken */ undefined, 
-                    /* name */ 'cb', 
-                    /* questionToken */ undefined, 
-                    /* type */
-                    ts$1.createFunctionTypeNode(
-                    /* typeParameters */ undefined, 
-                    /* parameters */ [ts$1.createParameter(
-                        /* decorators */ undefined, 
-                        /* modifiers */ undefined, 
-                        /* dotDotDotToken */ undefined, 
-                        /* name */ 'event', 
-                        /* questionToken */ undefined, 
-                        /* type */ genericTypeRef)], 
-                    /* type */ ts$1.createKeywordTypeNode(ts$1.SyntaxKind.AnyKeyword)))], 
-                /* type */ ts$1.createKeywordTypeNode(ts$1.SyntaxKind.VoidKeyword), 
-                /* name */ 'subscribe', 
-                /* questionToken */ undefined)]);
-            // Declares the first signature of `_outputHelper` that matches arguments of type
-            // `EventEmitter`, to convert them into `observableLike` defined above. The following
-            // statement is generated:
-            // `declare function _outputHelper<T>(output: EventEmitter<T>): observableLike;`
-            this.helperStatements.push(ts$1.createFunctionDeclaration(
-            /* decorators */ undefined, 
-            /* modifiers */ [ts$1.createModifier(ts$1.SyntaxKind.DeclareKeyword)], 
-            /* asteriskToken */ undefined, 
-            /* name */ outputHelperIdent, 
-            /* typeParameters */ [genericTypeDecl], 
-            /* parameters */ [ts$1.createParameter(
-                /* decorators */ undefined, 
-                /* modifiers */ undefined, 
-                /* dotDotDotToken */ undefined, 
-                /* name */ 'output', 
-                /* questionToken */ undefined, 
-                /* type */ eventEmitter)], 
-            /* type */ observableLike, 
-            /* body */ undefined));
-            // Declares the second signature of `_outputHelper` that matches all other argument types,
-            // i.e. ensures type identity for output types other than `EventEmitter`. This corresponds
-            // with the following statement:
-            // `declare function _outputHelper<T>(output: T): T;`
-            this.helperStatements.push(ts$1.createFunctionDeclaration(
-            /* decorators */ undefined, 
-            /* modifiers */ [ts$1.createModifier(ts$1.SyntaxKind.DeclareKeyword)], 
-            /* asteriskToken */ undefined, 
-            /* name */ outputHelperIdent, 
-            /* typeParameters */ [genericTypeDecl], 
-            /* parameters */ [ts$1.createParameter(
-                /* decorators */ undefined, 
-                /* modifiers */ undefined, 
-                /* dotDotDotToken */ undefined, 
-                /* name */ 'output', 
-                /* questionToken */ undefined, 
-                /* type */ genericTypeRef)], 
-            /* type */ genericTypeRef, 
-            /* body */ undefined));
-            return this.outputHelperIdent = outputHelperIdent;
-        }
         /**
          * Generate a `ts.Expression` that references the given node.
          *
@@ -34242,7 +34240,6 @@ Either add the @Injectable() decorator to '${provider.node.name
         }
         getPreludeStatements() {
             return [
-                ...this.helperStatements,
                 ...this.pipeInstStatements,
                 ...this.typeCtorStatements,
             ];
@@ -35717,16 +35714,8 @@ Either add the @Injectable() decorator to '${provider.node.name
                     // For strict checking of directive events, generate a call to the `subscribe` method
                     // on the directive's output field to let type information flow into the handler function's
                     // `$event` parameter.
-                    //
-                    // Note that the `EventEmitter<T>` type from '@angular/core' that is typically used for
-                    // outputs has a typings deficiency in its `subscribe` method. The generic type `T` is not
-                    // carried into the handler function, which is vital for inference of the type of `$event`.
-                    // As a workaround, the directive's field is passed into a helper function that has a
-                    // specially crafted set of signatures, to effectively cast `EventEmitter<T>` to something
-                    // that has a `subscribe` method that properly carries the `T` into the handler function.
                     const handler = tcbCreateEventHandler(output, this.tcb, this.scope, 0 /* Infer */);
-                    const outputHelper = ts$1.createCall(this.tcb.env.declareOutputHelper(), undefined, [outputField]);
-                    const subscribeFn = ts$1.createPropertyAccess(outputHelper, 'subscribe');
+                    const subscribeFn = ts$1.createPropertyAccess(outputField, 'subscribe');
                     const call = ts$1.createCall(subscribeFn, /* typeArguments */ undefined, [handler]);
                     addParseSpanInfo(call, output.sourceSpan);
                     this.scope.addStatement(ts$1.createExpressionStatement(call));
@@ -36634,9 +36623,6 @@ Either add the @Injectable() decorator to '${provider.node.name
                 '\n\n';
             const printer = ts$1.createPrinter();
             source += '\n';
-            for (const stmt of this.helperStatements) {
-                source += printer.printNode(ts$1.EmitHint.Unspecified, stmt, this.contextFile) + '\n';
-            }
             for (const stmt of this.pipeInstStatements) {
                 source += printer.printNode(ts$1.EmitHint.Unspecified, stmt, this.contextFile) + '\n';
             }
@@ -37248,7 +37234,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                 return null;
             }
             // Outputs in the TCB look like one of the two:
-            // * _outputHelper(_t1["outputField"]).subscribe(handler);
+            // * _t1["outputField"].subscribe(handler);
             // * _t1.addEventListener(handler);
             // Even with strict null checks disabled, we still produce the access as a separate statement
             // so that it can be found here.
@@ -39303,7 +39289,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
     }
     function toTextSpan(span) {
         let start, end;
-        if (span instanceof AbsoluteSourceSpan) {
+        if (span instanceof AbsoluteSourceSpan || span instanceof ParseSpan) {
             start = span.start;
             end = span.end;
         }
@@ -41051,7 +41037,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             const definitions = [];
             for (const definitionMeta of definitionMetas) {
                 // The `$event` of event handlers would point to the $event parameter in the shim file, as in
-                // `_outputHelper(_t3["x"]).subscribe(function ($event): any { $event }) ;`
+                // `_t3["x"].subscribe(function ($event): any { $event }) ;`
                 // If we wanted to return something for this, it would be more appropriate for something like
                 // `getTypeDefinition`.
                 if (isDollarEvent(definitionMeta.node)) {
@@ -41487,37 +41473,173 @@ 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
      */
-    class ReferenceBuilder {
+    function toFilePosition(shimLocation) {
+        return { fileName: shimLocation.shimPath, position: shimLocation.positionInShimFile };
+    }
+    var RequestKind;
+    (function (RequestKind) {
+        RequestKind[RequestKind["Template"] = 0] = "Template";
+        RequestKind[RequestKind["TypeScript"] = 1] = "TypeScript";
+    })(RequestKind || (RequestKind = {}));
+    class ReferencesAndRenameBuilder {
         constructor(strategy, tsLS, compiler) {
             this.strategy = strategy;
             this.tsLS = tsLS;
             this.compiler = compiler;
             this.ttc = this.compiler.getTemplateTypeChecker();
         }
-        get(filePath, position) {
+        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,
+            };
+        }
+        findRenameLocations(filePath, position) {
             this.ttc.generateAllTypeCheckBlocks();
             const templateInfo = getTemplateInfoAtPosition(filePath, position, this.compiler);
-            return templateInfo !== undefined ?
-                this.getReferencesAtTemplatePosition(templateInfo, position) :
-                this.getReferencesAtTypescriptPosition(filePath, position);
+            // 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);
+            }
+            return this.findRenameLocationsAtTemplatePosition(templateInfo, position);
         }
-        getReferencesAtTemplatePosition({ template, component }, position) {
-            var _a, _b, _c, _d, _e, _f, _g, _h;
+        findRenameLocationsAtTemplatePosition(templateInfo, position) {
+            const allTargetDetails = this.getTargetDetailsAtTemplatePosition(templateInfo, position);
+            if (allTargetDetails === null) {
+                return undefined;
+            }
+            const allRenameLocations = [];
+            for (const targetDetails of allTargetDetails) {
+                const requestOrigin = {
+                    kind: RequestKind.Template,
+                    requestNode: targetDetails.templateTarget,
+                    position,
+                };
+                for (const location of targetDetails.typescriptLocations) {
+                    const locations = this.findRenameLocationsAtTypescriptPosition(location.fileName, location.position, requestOrigin);
+                    // If we couldn't find rename locations for _any_ result, we should not allow renaming to
+                    // proceed instead of having a partially complete rename.
+                    if (locations === undefined) {
+                        return undefined;
+                    }
+                    allRenameLocations.push(...locations);
+                }
+            }
+            return allRenameLocations.length > 0 ? allRenameLocations : undefined;
+        }
+        getTsNodeAtPosition(filePath, position) {
+            var _a;
+            const sf = this.strategy.getProgram().getSourceFile(filePath);
+            if (!sf) {
+                return null;
+            }
+            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;
+                }
+                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) {
+                        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);
+                }
+            }
+            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);
+        }
+        getReferencesAtTemplatePosition(templateInfo, position) {
+            const allTargetDetails = this.getTargetDetailsAtTemplatePosition(templateInfo, position);
+            if (allTargetDetails === null) {
+                return undefined;
+            }
+            const allReferences = [];
+            for (const targetDetails of allTargetDetails) {
+                for (const location of targetDetails.typescriptLocations) {
+                    const refs = this.getReferencesAtTypescriptPosition(location.fileName, location.position);
+                    if (refs !== undefined) {
+                        allReferences.push(...refs);
+                    }
+                }
+            }
+            return allReferences.length > 0 ? allReferences : undefined;
+        }
+        getTargetDetailsAtTemplatePosition({ template, component }, position) {
             // Find the AST node in the template at the position.
             const positionDetails = getTargetAtPosition(template, position);
             if (positionDetails === null) {
-                return undefined;
+                return null;
             }
             const nodes = positionDetails.context.kind === TargetNodeKind.TwoWayBindingContext ?
                 positionDetails.context.nodes :
                 [positionDetails.context.node];
-            const references = [];
+            const details = [];
             for (const node of nodes) {
                 // Get the information about the TCB at the template position.
                 const symbol = this.ttc.getSymbolOfNode(node, component);
                 if (symbol === null) {
                     continue;
                 }
+                const templateTarget = node;
                 switch (symbol.kind) {
                     case SymbolKind.Directive:
                     case SymbolKind.Template:
@@ -41526,7 +41648,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                         break;
                     case SymbolKind.Element: {
                         const matches = getDirectiveMatchesForElementTag(symbol.templateNode, symbol.directives);
-                        references.push(...(_a = this.getReferencesForDirectives(matches)) !== null && _a !== void 0 ? _a : []);
+                        details.push({ typescriptLocations: this.getPositionsForDirectives(matches), templateTarget });
                         break;
                     }
                     case SymbolKind.DomBinding: {
@@ -41534,116 +41656,170 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                         // have a shim location. This means we can't match dom bindings to their lib.dom
                         // reference, but we can still see if they match to a directive.
                         if (!(node instanceof TextAttribute) && !(node instanceof BoundAttribute)) {
-                            break;
+                            return null;
                         }
                         const directives = getDirectiveMatchesForAttribute(node.name, symbol.host.templateNode, symbol.host.directives);
-                        references.push(...(_b = this.getReferencesForDirectives(directives)) !== null && _b !== void 0 ? _b : []);
+                        details.push({
+                            typescriptLocations: this.getPositionsForDirectives(directives),
+                            templateTarget,
+                        });
                         break;
                     }
                     case SymbolKind.Reference: {
-                        const { shimPath, positionInShimFile } = symbol.referenceVarLocation;
-                        references.push(...(_c = this.getReferencesAtTypescriptPosition(shimPath, positionInShimFile)) !== null && _c !== void 0 ? _c : []);
+                        details.push({
+                            typescriptLocations: [toFilePosition(symbol.referenceVarLocation)],
+                            templateTarget,
+                        });
                         break;
                     }
                     case SymbolKind.Variable: {
-                        const { positionInShimFile: initializerPosition, shimPath } = symbol.initializerLocation;
-                        const localVarPosition = symbol.localVarLocation.positionInShimFile;
-                        if ((node instanceof Variable)) {
-                            if (node.valueSpan !== undefined && isWithin(position, node.valueSpan)) {
+                        if ((templateTarget instanceof Variable)) {
+                            if (templateTarget.valueSpan !== undefined &&
+                                isWithin(position, templateTarget.valueSpan)) {
                                 // In the valueSpan of the variable, we want to get the reference of the initializer.
-                                references.push(...(_d = this.getReferencesAtTypescriptPosition(shimPath, initializerPosition)) !== null && _d !== void 0 ? _d : []);
+                                details.push({
+                                    typescriptLocations: [toFilePosition(symbol.initializerLocation)],
+                                    templateTarget,
+                                });
                             }
-                            else if (isWithin(position, node.keySpan)) {
+                            else if (isWithin(position, templateTarget.keySpan)) {
                                 // In the keySpan of the variable, we want to get the reference of the local variable.
-                                references.push(...(_e = this.getReferencesAtTypescriptPosition(shimPath, localVarPosition)) !== null && _e !== void 0 ? _e : []);
+                                details.push({
+                                    typescriptLocations: [toFilePosition(symbol.localVarLocation)],
+                                    templateTarget,
+                                });
                             }
                         }
                         else {
-                            // If the templateNode is not the `TmplAstVariable`, it must be a usage of the variable
-                            // somewhere in the template.
-                            references.push(...(_f = this.getReferencesAtTypescriptPosition(shimPath, localVarPosition)) !== null && _f !== void 0 ? _f : []);
+                            // If the templateNode is not the `TmplAstVariable`, it must be a usage of the
+                            // variable somewhere in the template.
+                            details.push({
+                                typescriptLocations: [toFilePosition(symbol.localVarLocation)],
+                                templateTarget,
+                            });
                         }
                         break;
                     }
                     case SymbolKind.Input:
                     case SymbolKind.Output: {
-                        // TODO(atscott): Determine how to handle when the binding maps to several inputs/outputs
-                        const { shimPath, positionInShimFile } = symbol.bindings[0].shimLocation;
-                        references.push(...(_g = this.getReferencesAtTypescriptPosition(shimPath, positionInShimFile)) !== null && _g !== void 0 ? _g : []);
+                        details.push({
+                            typescriptLocations: symbol.bindings.map(binding => toFilePosition(binding.shimLocation)),
+                            templateTarget,
+                        });
                         break;
                     }
                     case SymbolKind.Pipe:
                     case SymbolKind.Expression: {
-                        const { shimPath, positionInShimFile } = symbol.shimLocation;
-                        references.push(...(_h = this.getReferencesAtTypescriptPosition(shimPath, positionInShimFile)) !== null && _h !== void 0 ? _h : []);
+                        details.push({ typescriptLocations: [toFilePosition(symbol.shimLocation)], templateTarget });
                         break;
                     }
                 }
             }
-            if (references.length === 0) {
-                return undefined;
-            }
-            return references;
+            return details.length > 0 ? details : null;
         }
-        getReferencesForDirectives(directives) {
-            const allDirectiveRefs = [];
+        getPositionsForDirectives(directives) {
+            const allDirectives = [];
             for (const dir of directives.values()) {
                 const dirClass = dir.tsSymbol.valueDeclaration;
                 if (dirClass === undefined || !ts$1.isClassDeclaration(dirClass) ||
                     dirClass.name === undefined) {
                     continue;
                 }
-                const dirFile = dirClass.getSourceFile().fileName;
-                const dirPosition = dirClass.name.getStart();
-                const directiveRefs = this.getReferencesAtTypescriptPosition(dirFile, dirPosition);
-                if (directiveRefs !== undefined) {
-                    allDirectiveRefs.push(...directiveRefs);
-                }
+                const { fileName } = dirClass.getSourceFile();
+                const position = dirClass.name.getStart();
+                allDirectives.push({ fileName, position });
             }
-            return allDirectiveRefs.length > 0 ? allDirectiveRefs : undefined;
+            return allDirectives;
         }
         getReferencesAtTypescriptPosition(fileName, position) {
             const refs = this.tsLS.getReferencesAtPosition(fileName, position);
             if (refs === undefined) {
                 return undefined;
             }
-            const entries = [];
+            const entries = new Map();
             for (const ref of refs) {
                 if (this.ttc.isTrackedTypeCheckFile(absoluteFrom(ref.fileName))) {
-                    const entry = this.convertToTemplateReferenceEntry(ref, this.ttc);
+                    const entry = this.convertToTemplateDocumentSpan(ref, this.ttc);
                     if (entry !== null) {
-                        entries.push(entry);
+                        entries.set(createLocationKey(entry), entry);
                     }
                 }
                 else {
-                    entries.push(ref);
+                    entries.set(createLocationKey(ref), ref);
                 }
             }
-            return entries;
+            return Array.from(entries.values());
         }
-        convertToTemplateReferenceEntry(shimReferenceEntry, templateTypeChecker) {
-            const sf = this.strategy.getProgram().getSourceFile(shimReferenceEntry.fileName);
+        convertToTemplateDocumentSpan(shimDocumentSpan, templateTypeChecker, requiredNodeText) {
+            const sf = this.strategy.getProgram().getSourceFile(shimDocumentSpan.fileName);
             if (sf === undefined) {
                 return null;
             }
-            const tcbNode = findTightestNode(sf, shimReferenceEntry.textSpan.start);
+            const tcbNode = findTightestNode(sf, shimDocumentSpan.textSpan.start);
             if (tcbNode === undefined ||
                 hasExpressionIdentifier(sf, tcbNode, ExpressionIdentifier.EVENT_PARAMETER)) {
-                // If the reference result is the $event parameter in the subscribe/addEventListener function
-                // in the TCB, we want to filter this result out of the references. We really only want to
-                // return references to the parameter in the template itself.
+                // If the reference result is the $event parameter in the subscribe/addEventListener
+                // function in the TCB, we want to filter this result out of the references. We really only
+                // want to 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 = getTemplateLocationFromShimLocation(templateTypeChecker, absoluteFrom(shimReferenceEntry.fileName), shimReferenceEntry.textSpan.start);
+            const mapping = getTemplateLocationFromShimLocation(templateTypeChecker, absoluteFrom(shimDocumentSpan.fileName), shimDocumentSpan.textSpan.start);
             if (mapping === null) {
                 return null;
             }
             const { span, templateUrl } = mapping;
-            return Object.assign(Object.assign({}, shimReferenceEntry), { fileName: templateUrl, textSpan: toTextSpan(span) });
+            if (requiredNodeText !== undefined && span.toString() !== requiredNodeText) {
+                return null;
+            }
+            return Object.assign(Object.assign({}, shimDocumentSpan), { fileName: templateUrl, textSpan: toTextSpan(span) });
+        }
+    }
+    function getRenameTextAndSpanAtPosition(node, position) {
+        if (node instanceof BoundAttribute || node instanceof TextAttribute ||
+            node instanceof BoundEvent) {
+            if (node.keySpan === undefined) {
+                return null;
+            }
+            return { text: node.name, span: toTextSpan(node.keySpan) };
+        }
+        else if (node instanceof Variable || node instanceof Reference) {
+            if (isWithin(position, node.keySpan)) {
+                return { text: node.keySpan.toString(), span: toTextSpan(node.keySpan) };
+            }
+            else if (node.valueSpan && isWithin(position, node.valueSpan)) {
+                return { text: node.valueSpan.toString(), span: toTextSpan(node.valueSpan) };
+            }
+        }
+        if (node instanceof BindingPipe) {
+            // TODO(atscott): Add support for renaming pipes
+            return null;
         }
+        if (node instanceof PropertyRead || node instanceof MethodCall || node instanceof PropertyWrite ||
+            node instanceof SafePropertyRead || node instanceof SafeMethodCall) {
+            return { text: node.name, span: toTextSpan(node.nameSpan) };
+        }
+        else if (node instanceof LiteralPrimitive) {
+            const span = toTextSpan(node.sourceSpan);
+            const text = node.value;
+            if (typeof text === 'string') {
+                // The span of a string literal includes the quotes but they should be removed for renaming.
+                span.start += 1;
+                span.length -= 2;
+            }
+            return { text, span };
+        }
+        return null;
+    }
+    /**
+     * Creates a "key" for a rename/reference location by concatenating file name, span start, and span
+     * length. This allows us to de-duplicate template results when an item may appear several times
+     * in the TCB but map back to the same template location.
+     */
+    function createLocationKey(ds) {
+        return ds.fileName + ds.textSpan.start + ds.textSpan.length;
     }
 
     /**
@@ -41724,7 +41900,28 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         }
         getReferencesAtPosition(fileName, position) {
             const compiler = this.compilerFactory.getOrCreate();
-            const results = new ReferenceBuilder(this.strategy, this.tsLS, compiler).get(fileName, position);
+            const results = new ReferencesAndRenameBuilder(this.strategy, this.tsLS, compiler)
+                .getReferencesAtPosition(fileName, position);
+            this.compilerFactory.registerLastKnownProgram();
+            return results;
+        }
+        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 });
+        }
+        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;
         }
@@ -41772,6 +41969,53 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             this.compilerFactory.registerLastKnownProgram();
             return result;
         }
+        getTcb(fileName, position) {
+            return this.withCompiler(compiler => {
+                const templateInfo = getTemplateInfoAtPosition(fileName, position, compiler);
+                if (templateInfo === undefined) {
+                    return undefined;
+                }
+                const tcb = compiler.getTemplateTypeChecker().getTypeCheckBlock(templateInfo.component);
+                if (tcb === null) {
+                    return undefined;
+                }
+                const sf = tcb.getSourceFile();
+                let selections = [];
+                const target = getTargetAtPosition(templateInfo.template, position);
+                if (target !== null) {
+                    let selectionSpans;
+                    if ('nodes' in target.context) {
+                        selectionSpans = target.context.nodes.map(n => n.sourceSpan);
+                    }
+                    else {
+                        selectionSpans = [target.context.node.sourceSpan];
+                    }
+                    const selectionNodes = selectionSpans
+                        .map(s => findFirstMatchingNode(tcb, {
+                        withSpan: s,
+                        filter: (node) => true,
+                    }))
+                        .filter((n) => n !== null);
+                    selections = selectionNodes.map(n => {
+                        return {
+                            start: n.getStart(sf),
+                            length: n.getEnd() - n.getStart(sf),
+                        };
+                    });
+                }
+                return {
+                    fileName: sf.fileName,
+                    content: sf.getFullText(),
+                    selections,
+                };
+            });
+        }
+        withCompiler(p) {
+            const compiler = this.compilerFactory.getOrCreate();
+            const result = p(compiler);
+            this.compilerFactory.registerLastKnownProgram();
+            return result;
+        }
         getCompilerOptionsDiagnostics() {
             const project = this.project;
             if (!(project instanceof ts.server.ConfiguredProject)) {
@@ -41961,8 +42205,16 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             return ngLS.getReferencesAtPosition(fileName, position);
         }
         function findRenameLocations(fileName, position, findInStrings, findInComments, providePrefixAndSuffixTextForRename) {
-            // TODO(atscott): implement
-            return undefined;
+            // Most operations combine results from all extensions. However, rename locations are exclusive
+            // (results from only one extension are used) so our rename locations are a superset of the TS
+            // rename locations. As a result, we do not check the `angularOnly` flag here because we always
+            // want to include results at TS locations as well as locations in templates.
+            return ngLS.findRenameLocations(fileName, position);
+        }
+        function getRenameInfo(fileName, position) {
+            // See the comment in `findRenameLocations` explaining why we don't check the `angularOnly`
+            // flag.
+            return ngLS.getRenameInfo(fileName, position);
         }
         function getCompletionsAtPosition(fileName, position, options) {
             var _a;
@@ -42006,7 +42258,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             return diagnostics;
         }
         function getTcb(fileName, position) {
-            return undefined;
+            return ngLS.getTcb(fileName, position);
         }
         return Object.assign(Object.assign({}, tsLS), { getSemanticDiagnostics,
             getTypeDefinitionAtPosition,
@@ -42014,11 +42266,12 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             getDefinitionAndBoundSpan,
             getReferencesAtPosition,
             findRenameLocations,
+            getRenameInfo,
             getCompletionsAtPosition,
             getCompletionEntryDetails,
             getCompletionEntrySymbol,
-            getCompilerOptionsDiagnostics,
-            getTcb });
+            getTcb,
+            getCompilerOptionsDiagnostics });
     }
     function getExternalFiles(project) {
         if (!project.hasRoots()) {