@angular/language-service 13.0.0-next.3 → 13.0.0-next.7

package/bundles/ivy.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v13.0.0-next.3
+ * @license Angular v13.0.0-next.7
  * Copyright Google LLC All Rights Reserved.
  * License: MIT
  */
@@ -1193,9 +1193,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         key(index, type, sourceSpan) {
             return new ReadKeyExpr(this, index, type, sourceSpan);
         }
-        callMethod(name, params, sourceSpan) {
-            return new InvokeMethodExpr(this, name, params, null, sourceSpan);
-        }
         callFn(params, sourceSpan, pure) {
             return new InvokeFunctionExpr(this, params, null, sourceSpan, pure);
         }
@@ -1397,31 +1394,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         BuiltinMethod[BuiltinMethod["SubscribeObservable"] = 1] = "SubscribeObservable";
         BuiltinMethod[BuiltinMethod["Bind"] = 2] = "Bind";
     })(BuiltinMethod || (BuiltinMethod = {}));
-    class InvokeMethodExpr extends Expression {
-        constructor(receiver, method, args, type, sourceSpan) {
-            super(type, sourceSpan);
-            this.receiver = receiver;
-            this.args = args;
-            if (typeof method === 'string') {
-                this.name = method;
-                this.builtin = null;
-            }
-            else {
-                this.name = null;
-                this.builtin = method;
-            }
-        }
-        isEquivalent(e) {
-            return e instanceof InvokeMethodExpr && this.receiver.isEquivalent(e.receiver) &&
-                this.name === e.name && this.builtin === e.builtin && areAllEquivalent(this.args, e.args);
-        }
-        isConstant() {
-            return false;
-        }
-        visitExpression(visitor, context) {
-            return visitor.visitInvokeMethodExpr(this, context);
-        }
-    }
     class InvokeFunctionExpr extends Expression {
         constructor(fn, args, type, sourceSpan, pure = false) {
             super(type, sourceSpan);
@@ -2298,7 +2270,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             this.visitWriteVarExpr = invalid;
             this.visitWriteKeyExpr = invalid;
             this.visitWritePropExpr = invalid;
-            this.visitInvokeMethodExpr = invalid;
             this.visitInvokeFunctionExpr = invalid;
             this.visitTaggedTemplateExpr = invalid;
             this.visitInstantiateExpr = invalid;
@@ -4395,21 +4366,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
             return null;
         }
-        visitInvokeMethodExpr(expr, ctx) {
-            expr.receiver.visitExpression(this, ctx);
-            let name = expr.name;
-            if (expr.builtin != null) {
-                name = this.getBuiltinMethodName(expr.builtin);
-                if (name == null) {
-                    // some builtins just mean to skip the call.
-                    return null;
-                }
-            }
-            ctx.print(expr, `.${name}(`);
-            this.visitAllExpressions(expr.args, ctx, `,`);
-            ctx.print(expr, `)`);
-            return null;
-        }
         visitInvokeFunctionExpr(expr, ctx) {
             expr.fn.visitExpression(this, ctx);
             ctx.print(expr, `(`);
@@ -5051,7 +5007,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         return createFactoryFunction(unwrappedType);
     }
     function createFactoryFunction(type) {
-        return fn([new FnParam('t', DYNAMIC_TYPE)], [new ReturnStatement(type.callMethod('ɵfac', [variable('t')]))]);
+        return fn([new FnParam('t', DYNAMIC_TYPE)], [new ReturnStatement(type.prop('ɵfac').callFn([variable('t')]))]);
     }
 
     /**
@@ -6384,38 +6340,15 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return visitor.visitNonNullAssert(this, context);
         }
     }
-    class MethodCall extends ASTWithName {
-        constructor(span, sourceSpan, nameSpan, receiver, name, args, argumentSpan) {
-            super(span, sourceSpan, nameSpan);
-            this.receiver = receiver;
-            this.name = name;
-            this.args = args;
-            this.argumentSpan = argumentSpan;
-        }
-        visit(visitor, context = null) {
-            return visitor.visitMethodCall(this, context);
-        }
-    }
-    class SafeMethodCall extends ASTWithName {
-        constructor(span, sourceSpan, nameSpan, receiver, name, args, argumentSpan) {
-            super(span, sourceSpan, nameSpan);
+    class Call extends AST {
+        constructor(span, sourceSpan, receiver, args, argumentSpan) {
+            super(span, sourceSpan);
             this.receiver = receiver;
-            this.name = name;
             this.args = args;
             this.argumentSpan = argumentSpan;
         }
         visit(visitor, context = null) {
-            return visitor.visitSafeMethodCall(this, context);
-        }
-    }
-    class FunctionCall extends AST {
-        constructor(span, sourceSpan, target, args) {
-            super(span, sourceSpan);
-            this.target = target;
-            this.args = args;
-        }
-        visit(visitor, context = null) {
-            return visitor.visitFunctionCall(this, context);
+            return visitor.visitCall(this, context);
         }
     }
     /**
@@ -6501,12 +6434,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             this.visit(ast.exp, context);
             this.visitAll(ast.args, context);
         }
-        visitFunctionCall(ast, context) {
-            if (ast.target) {
-                this.visit(ast.target, context);
-            }
-            this.visitAll(ast.args, context);
-        }
         visitImplicitReceiver(ast, context) { }
         visitThisReceiver(ast, context) { }
         visitInterpolation(ast, context) {
@@ -6528,10 +6455,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             this.visitAll(ast.values, context);
         }
         visitLiteralPrimitive(ast, context) { }
-        visitMethodCall(ast, context) {
-            this.visit(ast.receiver, context);
-            this.visitAll(ast.args, context);
-        }
         visitPrefixNot(ast, context) {
             this.visit(ast.expression, context);
         }
@@ -6548,14 +6471,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         visitSafePropertyRead(ast, context) {
             this.visit(ast.receiver, context);
         }
-        visitSafeMethodCall(ast, context) {
-            this.visit(ast.receiver, context);
-            this.visitAll(ast.args, context);
-        }
         visitSafeKeyedRead(ast, context) {
             this.visit(ast.receiver, context);
             this.visit(ast.key, context);
         }
+        visitCall(ast, context) {
+            this.visit(ast.receiver, context);
+            this.visitAll(ast.args, context);
+        }
         visitQuote(ast, context) { }
         // This is not part of the AstVisitor interface, just a helper method
         visitAll(asts, context) {
@@ -6586,15 +6509,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         visitSafePropertyRead(ast, context) {
             return new SafePropertyRead(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name);
         }
-        visitMethodCall(ast, context) {
-            return new MethodCall(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name, this.visitAll(ast.args), ast.argumentSpan);
-        }
-        visitSafeMethodCall(ast, context) {
-            return new SafeMethodCall(ast.span, ast.sourceSpan, ast.nameSpan, ast.receiver.visit(this), ast.name, this.visitAll(ast.args), ast.argumentSpan);
-        }
-        visitFunctionCall(ast, context) {
-            return new FunctionCall(ast.span, ast.sourceSpan, ast.target.visit(this), this.visitAll(ast.args));
-        }
         visitLiteralArray(ast, context) {
             return new LiteralArray(ast.span, ast.sourceSpan, this.visitAll(ast.expressions));
         }
@@ -6632,6 +6546,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         visitKeyedWrite(ast, context) {
             return new KeyedWrite(ast.span, ast.sourceSpan, ast.receiver.visit(this), ast.key.visit(this), ast.value.visit(this));
         }
+        visitCall(ast, context) {
+            return new Call(ast.span, ast.sourceSpan, ast.receiver.visit(this), this.visitAll(ast.args), ast.argumentSpan);
+        }
         visitAll(asts) {
             const res = [];
             for (let i = 0; i < asts.length; ++i) {
@@ -6689,30 +6606,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
             return ast;
         }
-        visitMethodCall(ast, context) {
-            const receiver = ast.receiver.visit(this);
-            const args = this.visitAll(ast.args);
-            if (receiver !== ast.receiver || args !== ast.args) {
-                return new MethodCall(ast.span, ast.sourceSpan, ast.nameSpan, receiver, ast.name, args, ast.argumentSpan);
-            }
-            return ast;
-        }
-        visitSafeMethodCall(ast, context) {
-            const receiver = ast.receiver.visit(this);
-            const args = this.visitAll(ast.args);
-            if (receiver !== ast.receiver || args !== ast.args) {
-                return new SafeMethodCall(ast.span, ast.sourceSpan, ast.nameSpan, receiver, ast.name, args, ast.argumentSpan);
-            }
-            return ast;
-        }
-        visitFunctionCall(ast, context) {
-            const target = ast.target && ast.target.visit(this);
-            const args = this.visitAll(ast.args);
-            if (target !== ast.target || args !== ast.args) {
-                return new FunctionCall(ast.span, ast.sourceSpan, target, args);
-            }
-            return ast;
-        }
         visitLiteralArray(ast, context) {
             const expressions = this.visitAll(ast.expressions);
             if (expressions !== ast.expressions) {
@@ -6815,6 +6708,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
             return ast;
         }
+        visitCall(ast, context) {
+            const receiver = ast.receiver.visit(this);
+            const args = this.visitAll(ast.args);
+            if (receiver !== ast.receiver || args !== ast.args) {
+                return new Call(ast.span, ast.sourceSpan, receiver, args, ast.argumentSpan);
+            }
+            return ast;
+        }
         visitQuote(ast, context) {
             return ast;
         }
@@ -7341,18 +7242,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         visitPipe(ast, mode) {
             throw new Error(`Illegal state: Pipes should have been converted into functions. Pipe: ${ast.name}`);
         }
-        visitFunctionCall(ast, mode) {
-            const convertedArgs = this.visitAll(ast.args, _Mode.Expression);
-            let fnResult;
-            if (ast instanceof BuiltinFunctionCall) {
-                fnResult = ast.converter(convertedArgs);
-            }
-            else {
-                fnResult = this._visit(ast.target, _Mode.Expression)
-                    .callFn(convertedArgs, this.convertSourceSpan(ast.span));
-            }
-            return convertToStatementIfNeeded(mode, fnResult);
-        }
         visitImplicitReceiver(ast, mode) {
             ensureExpressionMode(mode, ast);
             this.usesImplicitReceiver = true;
@@ -7417,40 +7306,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
             return this._localResolver.getLocal(name);
         }
-        visitMethodCall(ast, mode) {
-            if (ast.receiver instanceof ImplicitReceiver &&
-                !(ast.receiver instanceof ThisReceiver) && ast.name === '$any') {
-                const args = this.visitAll(ast.args, _Mode.Expression);
-                if (args.length != 1) {
-                    throw new Error(`Invalid call to $any, expected 1 argument but received ${args.length || 'none'}`);
-                }
-                return args[0].cast(DYNAMIC_TYPE, this.convertSourceSpan(ast.span));
-            }
-            const leftMostSafe = this.leftMostSafeNode(ast);
-            if (leftMostSafe) {
-                return this.convertSafeAccess(ast, leftMostSafe, mode);
-            }
-            else {
-                const args = this.visitAll(ast.args, _Mode.Expression);
-                const prevUsesImplicitReceiver = this.usesImplicitReceiver;
-                let result = null;
-                const receiver = this._visit(ast.receiver, _Mode.Expression);
-                if (receiver === this._implicitReceiver) {
-                    const varExpr = this._getLocal(ast.name, ast.receiver);
-                    if (varExpr) {
-                        // Restore the previous "usesImplicitReceiver" state since the implicit
-                        // receiver has been replaced with a resolved local expression.
-                        this.usesImplicitReceiver = prevUsesImplicitReceiver;
-                        result = varExpr.callFn(args);
-                        this.addImplicitReceiverAccess(ast.name);
-                    }
-                }
-                if (result == null) {
-                    result = receiver.callMethod(ast.name, args, this.convertSourceSpan(ast.span));
-                }
-                return convertToStatementIfNeeded(mode, result);
-            }
-        }
         visitPrefixNot(ast, mode) {
             return convertToStatementIfNeeded(mode, not(this._visit(ast.expression, _Mode.Expression)));
         }
@@ -7476,7 +7331,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     }
                 }
                 if (result == null) {
-                    result = receiver.prop(ast.name);
+                    result = receiver.prop(ast.name, this.convertSourceSpan(ast.span));
                 }
                 return convertToStatementIfNeeded(mode, result);
             }
@@ -7509,16 +7364,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             // If no local expression could be produced, use the original receiver's
             // property as the target.
             if (varExpr === null) {
-                varExpr = receiver.prop(ast.name);
+                varExpr = receiver.prop(ast.name, this.convertSourceSpan(ast.span));
             }
             return convertToStatementIfNeeded(mode, varExpr.set(this._visit(ast.value, _Mode.Expression)));
         }
         visitSafePropertyRead(ast, mode) {
             return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);
         }
-        visitSafeMethodCall(ast, mode) {
-            return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);
-        }
         visitSafeKeyedRead(ast, mode) {
             return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);
         }
@@ -7529,6 +7381,29 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             throw new Error(`Quotes are not supported for evaluation!
         Statement: ${ast.uninterpretedExpression} located at ${ast.location}`);
         }
+        visitCall(ast, mode) {
+            const convertedArgs = this.visitAll(ast.args, _Mode.Expression);
+            if (ast instanceof BuiltinFunctionCall) {
+                return convertToStatementIfNeeded(mode, ast.converter(convertedArgs));
+            }
+            const receiver = ast.receiver;
+            if (receiver instanceof PropertyRead &&
+                receiver.receiver instanceof ImplicitReceiver &&
+                !(receiver.receiver instanceof ThisReceiver) && receiver.name === '$any') {
+                if (convertedArgs.length !== 1) {
+                    throw new Error(`Invalid call to $any, expected 1 argument but received ${convertedArgs.length || 'none'}`);
+                }
+                return convertedArgs[0]
+                    .cast(DYNAMIC_TYPE, this.convertSourceSpan(ast.span));
+            }
+            const leftMostSafe = this.leftMostSafeNode(ast);
+            if (leftMostSafe) {
+                return this.convertSafeAccess(ast, leftMostSafe, mode);
+            }
+            const call = this._visit(receiver, _Mode.Expression)
+                .callFn(convertedArgs, this.convertSourceSpan(ast.span));
+            return convertToStatementIfNeeded(mode, call);
+        }
         _visit(ast, mode) {
             const result = this._resultMap.get(ast);
             if (result)
@@ -7585,10 +7460,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             const condition = guardedExpression.isBlank();
             // Convert the ast to an unguarded access to the receiver's member. The map will substitute
             // leftMostNode with its unguarded version in the call to `this.visit()`.
-            if (leftMostSafe instanceof SafeMethodCall) {
-                this._nodeMap.set(leftMostSafe, new MethodCall(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.nameSpan, leftMostSafe.receiver, leftMostSafe.name, leftMostSafe.args, leftMostSafe.argumentSpan));
-            }
-            else if (leftMostSafe instanceof SafeKeyedRead) {
+            if (leftMostSafe instanceof SafeKeyedRead) {
                 this._nodeMap.set(leftMostSafe, new KeyedRead(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.receiver, leftMostSafe.key));
             }
             else {
@@ -7644,8 +7516,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 visitConditional(ast) {
                     return null;
                 },
-                visitFunctionCall(ast) {
-                    return null;
+                visitCall(ast) {
+                    return visit(this, ast.receiver);
                 },
                 visitImplicitReceiver(ast) {
                     return null;
@@ -7671,9 +7543,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 visitLiteralPrimitive(ast) {
                     return null;
                 },
-                visitMethodCall(ast) {
-                    return visit(this, ast.receiver);
-                },
                 visitPipe(ast) {
                     return null;
                 },
@@ -7692,9 +7561,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 visitQuote(ast) {
                     return null;
                 },
-                visitSafeMethodCall(ast) {
-                    return visit(this, ast.receiver) || ast;
-                },
                 visitSafePropertyRead(ast) {
                     return visit(this, ast.receiver) || ast;
                 },
@@ -7726,7 +7592,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 visitConditional(ast) {
                     return visit(this, ast.condition) || visit(this, ast.trueExp) || visit(this, ast.falseExp);
                 },
-                visitFunctionCall(ast) {
+                visitCall(ast) {
                     return true;
                 },
                 visitImplicitReceiver(ast) {
@@ -7753,9 +7619,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 visitLiteralPrimitive(ast) {
                     return false;
                 },
-                visitMethodCall(ast) {
-                    return true;
-                },
                 visitPipe(ast) {
                     return true;
                 },
@@ -7774,9 +7637,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 visitQuote(ast) {
                     return false;
                 },
-                visitSafeMethodCall(ast) {
-                    return true;
-                },
                 visitSafePropertyRead(ast) {
                     return false;
                 },
@@ -7861,9 +7721,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
         return null;
     }
-    class BuiltinFunctionCall extends FunctionCall {
+    class BuiltinFunctionCall extends Call {
         constructor(span, sourceSpan, args, converter) {
-            super(span, sourceSpan, null, args);
+            super(span, sourceSpan, new EmptyExpr(span, sourceSpan), args, null);
             this.converter = converter;
         }
     }
@@ -8443,7 +8303,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     const _polyfillHostRe = /-shadowcsshost/gim;
     const _colonHostRe = /:host/gim;
     const _colonHostContextRe = /:host-context/gim;
-    const _commentRe = /\/\*\s*[\s\S]*?\*\//g;
+    const _commentRe = /\/\*[\s\S]*?\*\//g;
     function stripComments(input) {
         return input.replace(_commentRe, '');
     }
@@ -8654,9 +8514,10 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
     }
     class Text$2 extends NodeWithI18n {
-        constructor(value, sourceSpan, i18n) {
+        constructor(value, sourceSpan, tokens, i18n) {
             super(sourceSpan, i18n);
             this.value = value;
+            this.tokens = tokens;
         }
         visit(visitor, context) {
             return visitor.visitText(this, context);
@@ -8687,12 +8548,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
     }
     class Attribute extends NodeWithI18n {
-        constructor(name, value, sourceSpan, keySpan, valueSpan, i18n) {
+        constructor(name, value, sourceSpan, keySpan, valueSpan, valueTokens, i18n) {
             super(sourceSpan, i18n);
             this.name = name;
             this.value = value;
             this.keySpan = keySpan;
             this.valueSpan = valueSpan;
+            this.valueTokens = valueTokens;
         }
         visit(visitor, context) {
             return visitor.visitAttribute(this, context);
@@ -10884,38 +10746,6 @@ 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
      */
-    var TokenType;
-    (function (TokenType) {
-        TokenType[TokenType["TAG_OPEN_START"] = 0] = "TAG_OPEN_START";
-        TokenType[TokenType["TAG_OPEN_END"] = 1] = "TAG_OPEN_END";
-        TokenType[TokenType["TAG_OPEN_END_VOID"] = 2] = "TAG_OPEN_END_VOID";
-        TokenType[TokenType["TAG_CLOSE"] = 3] = "TAG_CLOSE";
-        TokenType[TokenType["INCOMPLETE_TAG_OPEN"] = 4] = "INCOMPLETE_TAG_OPEN";
-        TokenType[TokenType["TEXT"] = 5] = "TEXT";
-        TokenType[TokenType["ESCAPABLE_RAW_TEXT"] = 6] = "ESCAPABLE_RAW_TEXT";
-        TokenType[TokenType["RAW_TEXT"] = 7] = "RAW_TEXT";
-        TokenType[TokenType["COMMENT_START"] = 8] = "COMMENT_START";
-        TokenType[TokenType["COMMENT_END"] = 9] = "COMMENT_END";
-        TokenType[TokenType["CDATA_START"] = 10] = "CDATA_START";
-        TokenType[TokenType["CDATA_END"] = 11] = "CDATA_END";
-        TokenType[TokenType["ATTR_NAME"] = 12] = "ATTR_NAME";
-        TokenType[TokenType["ATTR_QUOTE"] = 13] = "ATTR_QUOTE";
-        TokenType[TokenType["ATTR_VALUE"] = 14] = "ATTR_VALUE";
-        TokenType[TokenType["DOC_TYPE"] = 15] = "DOC_TYPE";
-        TokenType[TokenType["EXPANSION_FORM_START"] = 16] = "EXPANSION_FORM_START";
-        TokenType[TokenType["EXPANSION_CASE_VALUE"] = 17] = "EXPANSION_CASE_VALUE";
-        TokenType[TokenType["EXPANSION_CASE_EXP_START"] = 18] = "EXPANSION_CASE_EXP_START";
-        TokenType[TokenType["EXPANSION_CASE_EXP_END"] = 19] = "EXPANSION_CASE_EXP_END";
-        TokenType[TokenType["EXPANSION_FORM_END"] = 20] = "EXPANSION_FORM_END";
-        TokenType[TokenType["EOF"] = 21] = "EOF";
-    })(TokenType || (TokenType = {}));
-    class Token {
-        constructor(type, parts, sourceSpan) {
-            this.type = type;
-            this.parts = parts;
-            this.sourceSpan = sourceSpan;
-        }
-    }
     class TokenError extends ParseError {
         constructor(errorMsg, tokenType, span) {
             super(span, errorMsg);
@@ -11022,14 +10852,16 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                         }
                     }
                     else if (!(this._tokenizeIcu && this._tokenizeExpansionForm())) {
-                        this._consumeText();
+                        // In (possibly interpolated) text the end of the text is given by `isTextEnd()`, while
+                        // the premature end of an interpolation is given by the start of a new HTML element.
+                        this._consumeWithInterpolation(5 /* TEXT */, 8 /* INTERPOLATION */, () => this._isTextEnd(), () => this._isTagStart());
                     }
                 }
                 catch (e) {
                     this.handleError(e);
                 }
             }
-            this._beginToken(TokenType.EOF);
+            this._beginToken(24 /* EOF */);
             this._endToken([]);
         }
         /**
@@ -11068,7 +10900,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             if (this._currentTokenType === null) {
                 throw new TokenError('Programming error - attempted to end a token which has no token type', null, this._cursor.getSpan(this._currentTokenStart));
             }
-            const token = new Token(this._currentTokenType, parts, this._cursor.getSpan(this._currentTokenStart, this._leadingTriviaCodePoints));
+            const token = {
+                type: this._currentTokenType,
+                parts,
+                sourceSpan: (end !== null && end !== void 0 ? end : this._cursor).getSpan(this._currentTokenStart, this._leadingTriviaCodePoints),
+            };
             this.tokens.push(token);
             this._currentTokenStart = null;
             this._currentTokenType = null;
@@ -11161,19 +10997,15 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 this._cursor.advance();
             }
         }
-        _readChar(decodeEntities) {
-            if (decodeEntities && this._cursor.peek() === $AMPERSAND) {
-                return this._decodeEntity();
-            }
-            else {
-                // Don't rely upon reading directly from `_input` as the actual char value
-                // may have been generated from an escape sequence.
-                const char = String.fromCodePoint(this._cursor.peek());
-                this._cursor.advance();
-                return char;
-            }
+        _readChar() {
+            // Don't rely upon reading directly from `_input` as the actual char value
+            // may have been generated from an escape sequence.
+            const char = String.fromCodePoint(this._cursor.peek());
+            this._cursor.advance();
+            return char;
         }
-        _decodeEntity() {
+        _consumeEntity(textTokenType) {
+            this._beginToken(9 /* ENCODED_ENTITY */);
             const start = this._cursor.clone();
             this._cursor.advance();
             if (this._attemptCharCode($HASH)) {
@@ -11191,7 +11023,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 this._cursor.advance();
                 try {
                     const charCode = parseInt(strNum, isHex ? 16 : 10);
-                    return String.fromCharCode(charCode);
+                    this._endToken([String.fromCharCode(charCode), this._cursor.getChars(start)]);
                 }
                 catch (_a) {
                     throw this._createError(_unknownEntityErrorMsg(this._cursor.getChars(start)), this._cursor.getSpan());
@@ -11201,20 +11033,25 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 const nameStart = this._cursor.clone();
                 this._attemptCharCodeUntilFn(isNamedEntityEnd);
                 if (this._cursor.peek() != $SEMICOLON) {
+                    // No semicolon was found so abort the encoded entity token that was in progress, and treat
+                    // this as a text token
+                    this._beginToken(textTokenType, start);
                     this._cursor = nameStart;
-                    return '&';
+                    this._endToken(['&']);
                 }
-                const name = this._cursor.getChars(nameStart);
-                this._cursor.advance();
-                const char = NAMED_ENTITIES[name];
-                if (!char) {
-                    throw this._createError(_unknownEntityErrorMsg(name), this._cursor.getSpan(start));
+                else {
+                    const name = this._cursor.getChars(nameStart);
+                    this._cursor.advance();
+                    const char = NAMED_ENTITIES[name];
+                    if (!char) {
+                        throw this._createError(_unknownEntityErrorMsg(name), this._cursor.getSpan(start));
+                    }
+                    this._endToken([char, `&${name};`]);
                 }
-                return char;
             }
         }
-        _consumeRawText(decodeEntities, endMarkerPredicate) {
-            this._beginToken(decodeEntities ? TokenType.ESCAPABLE_RAW_TEXT : TokenType.RAW_TEXT);
+        _consumeRawText(consumeEntities, endMarkerPredicate) {
+            this._beginToken(consumeEntities ? 6 /* ESCAPABLE_RAW_TEXT */ : 7 /* RAW_TEXT */);
             const parts = [];
             while (true) {
                 const tagCloseStart = this._cursor.clone();
@@ -11223,30 +11060,38 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 if (foundEndMarker) {
                     break;
                 }
-                parts.push(this._readChar(decodeEntities));
+                if (consumeEntities && this._cursor.peek() === $AMPERSAND) {
+                    this._endToken([this._processCarriageReturns(parts.join(''))]);
+                    parts.length = 0;
+                    this._consumeEntity(6 /* ESCAPABLE_RAW_TEXT */);
+                    this._beginToken(6 /* ESCAPABLE_RAW_TEXT */);
+                }
+                else {
+                    parts.push(this._readChar());
+                }
             }
-            return this._endToken([this._processCarriageReturns(parts.join(''))]);
+            this._endToken([this._processCarriageReturns(parts.join(''))]);
         }
         _consumeComment(start) {
-            this._beginToken(TokenType.COMMENT_START, start);
+            this._beginToken(10 /* COMMENT_START */, start);
             this._requireCharCode($MINUS);
             this._endToken([]);
             this._consumeRawText(false, () => this._attemptStr('-->'));
-            this._beginToken(TokenType.COMMENT_END);
+            this._beginToken(11 /* COMMENT_END */);
             this._requireStr('-->');
             this._endToken([]);
         }
         _consumeCdata(start) {
-            this._beginToken(TokenType.CDATA_START, start);
+            this._beginToken(12 /* CDATA_START */, start);
             this._requireStr('CDATA[');
             this._endToken([]);
             this._consumeRawText(false, () => this._attemptStr(']]>'));
-            this._beginToken(TokenType.CDATA_END);
+            this._beginToken(13 /* CDATA_END */);
             this._requireStr(']]>');
             this._endToken([]);
         }
         _consumeDocType(start) {
-            this._beginToken(TokenType.DOC_TYPE, start);
+            this._beginToken(18 /* DOC_TYPE */, start);
             const contentStart = this._cursor.clone();
             this._attemptUntilChar($GT);
             const content = this._cursor.getChars(contentStart);
@@ -11300,12 +11145,12 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 if (e instanceof _ControlFlowError) {
                     if (openTagToken) {
                         // We errored before we could close the opening tag, so it is incomplete.
-                        openTagToken.type = TokenType.INCOMPLETE_TAG_OPEN;
+                        openTagToken.type = 4 /* INCOMPLETE_TAG_OPEN */;
                     }
                     else {
                         // When the start tag is invalid, assume we want a "<" as text.
                         // Back to back text tokens are merged at the end.
-                        this._beginToken(TokenType.TEXT, start);
+                        this._beginToken(5 /* TEXT */, start);
                         this._endToken(['<']);
                     }
                     return;
@@ -11320,8 +11165,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 this._consumeRawTextWithTagClose(prefix, tagName, true);
             }
         }
-        _consumeRawTextWithTagClose(prefix, tagName, decodeEntities) {
-            this._consumeRawText(decodeEntities, () => {
+        _consumeRawTextWithTagClose(prefix, tagName, consumeEntities) {
+            this._consumeRawText(consumeEntities, () => {
                 if (!this._attemptCharCode($LT))
                     return false;
                 if (!this._attemptCharCode($SLASH))
@@ -11332,13 +11177,13 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 this._attemptCharCodeUntilFn(isNotWhitespace);
                 return this._attemptCharCode($GT);
             });
-            this._beginToken(TokenType.TAG_CLOSE);
+            this._beginToken(3 /* TAG_CLOSE */);
             this._requireCharCodeUntilFn(code => code === $GT, 3);
             this._cursor.advance(); // Consume the `>`
             this._endToken([prefix, tagName]);
         }
         _consumeTagOpenStart(start) {
-            this._beginToken(TokenType.TAG_OPEN_START, start);
+            this._beginToken(0 /* TAG_OPEN_START */, start);
             const parts = this._consumePrefixAndName();
             return this._endToken(parts);
         }
@@ -11347,44 +11192,38 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             if (attrNameStart === $SQ || attrNameStart === $DQ) {
                 throw this._createError(_unexpectedCharacterErrorMsg(attrNameStart), this._cursor.getSpan());
             }
-            this._beginToken(TokenType.ATTR_NAME);
+            this._beginToken(14 /* ATTR_NAME */);
             const prefixAndName = this._consumePrefixAndName();
             this._endToken(prefixAndName);
         }
         _consumeAttributeValue() {
-            let value;
             if (this._cursor.peek() === $SQ || this._cursor.peek() === $DQ) {
-                this._beginToken(TokenType.ATTR_QUOTE);
                 const quoteChar = this._cursor.peek();
-                this._cursor.advance();
-                this._endToken([String.fromCodePoint(quoteChar)]);
-                this._beginToken(TokenType.ATTR_VALUE);
-                const parts = [];
-                while (this._cursor.peek() !== quoteChar) {
-                    parts.push(this._readChar(true));
-                }
-                value = parts.join('');
-                this._endToken([this._processCarriageReturns(value)]);
-                this._beginToken(TokenType.ATTR_QUOTE);
-                this._cursor.advance();
-                this._endToken([String.fromCodePoint(quoteChar)]);
+                this._consumeQuote(quoteChar);
+                // In an attribute then end of the attribute value and the premature end to an interpolation
+                // are both triggered by the `quoteChar`.
+                const endPredicate = () => this._cursor.peek() === quoteChar;
+                this._consumeWithInterpolation(16 /* ATTR_VALUE_TEXT */, 17 /* ATTR_VALUE_INTERPOLATION */, endPredicate, endPredicate);
+                this._consumeQuote(quoteChar);
             }
             else {
-                this._beginToken(TokenType.ATTR_VALUE);
-                const valueStart = this._cursor.clone();
-                this._requireCharCodeUntilFn(isNameEnd, 1);
-                value = this._cursor.getChars(valueStart);
-                this._endToken([this._processCarriageReturns(value)]);
+                const endPredicate = () => isNameEnd(this._cursor.peek());
+                this._consumeWithInterpolation(16 /* ATTR_VALUE_TEXT */, 17 /* ATTR_VALUE_INTERPOLATION */, endPredicate, endPredicate);
             }
         }
+        _consumeQuote(quoteChar) {
+            this._beginToken(15 /* ATTR_QUOTE */);
+            this._requireCharCode(quoteChar);
+            this._endToken([String.fromCodePoint(quoteChar)]);
+        }
         _consumeTagOpenEnd() {
-            const tokenType = this._attemptCharCode($SLASH) ? TokenType.TAG_OPEN_END_VOID : TokenType.TAG_OPEN_END;
+            const tokenType = this._attemptCharCode($SLASH) ? 2 /* TAG_OPEN_END_VOID */ : 1 /* TAG_OPEN_END */;
             this._beginToken(tokenType);
             this._requireCharCode($GT);
             this._endToken([]);
         }
         _consumeTagClose(start) {
-            this._beginToken(TokenType.TAG_CLOSE, start);
+            this._beginToken(3 /* TAG_CLOSE */, start);
             this._attemptCharCodeUntilFn(isNotWhitespace);
             const prefixAndName = this._consumePrefixAndName();
             this._attemptCharCodeUntilFn(isNotWhitespace);
@@ -11392,11 +11231,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             this._endToken(prefixAndName);
         }
         _consumeExpansionFormStart() {
-            this._beginToken(TokenType.EXPANSION_FORM_START);
+            this._beginToken(19 /* EXPANSION_FORM_START */);
             this._requireCharCode($LBRACE);
             this._endToken([]);
-            this._expansionCaseStack.push(TokenType.EXPANSION_FORM_START);
-            this._beginToken(TokenType.RAW_TEXT);
+            this._expansionCaseStack.push(19 /* EXPANSION_FORM_START */);
+            this._beginToken(7 /* RAW_TEXT */);
             const condition = this._readUntil($COMMA);
             const normalizedCondition = this._processCarriageReturns(condition);
             if (this._i18nNormalizeLineEndingsInICUs) {
@@ -11412,59 +11251,139 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
             this._requireCharCode($COMMA);
             this._attemptCharCodeUntilFn(isNotWhitespace);
-            this._beginToken(TokenType.RAW_TEXT);
+            this._beginToken(7 /* RAW_TEXT */);
             const type = this._readUntil($COMMA);
             this._endToken([type]);
             this._requireCharCode($COMMA);
             this._attemptCharCodeUntilFn(isNotWhitespace);
         }
         _consumeExpansionCaseStart() {
-            this._beginToken(TokenType.EXPANSION_CASE_VALUE);
+            this._beginToken(20 /* EXPANSION_CASE_VALUE */);
             const value = this._readUntil($LBRACE).trim();
             this._endToken([value]);
             this._attemptCharCodeUntilFn(isNotWhitespace);
-            this._beginToken(TokenType.EXPANSION_CASE_EXP_START);
+            this._beginToken(21 /* EXPANSION_CASE_EXP_START */);
             this._requireCharCode($LBRACE);
             this._endToken([]);
             this._attemptCharCodeUntilFn(isNotWhitespace);
-            this._expansionCaseStack.push(TokenType.EXPANSION_CASE_EXP_START);
+            this._expansionCaseStack.push(21 /* EXPANSION_CASE_EXP_START */);
         }
         _consumeExpansionCaseEnd() {
-            this._beginToken(TokenType.EXPANSION_CASE_EXP_END);
+            this._beginToken(22 /* EXPANSION_CASE_EXP_END */);
             this._requireCharCode($RBRACE);
             this._endToken([]);
             this._attemptCharCodeUntilFn(isNotWhitespace);
             this._expansionCaseStack.pop();
         }
         _consumeExpansionFormEnd() {
-            this._beginToken(TokenType.EXPANSION_FORM_END);
+            this._beginToken(23 /* EXPANSION_FORM_END */);
             this._requireCharCode($RBRACE);
             this._endToken([]);
             this._expansionCaseStack.pop();
         }
-        _consumeText() {
-            const start = this._cursor.clone();
-            this._beginToken(TokenType.TEXT, start);
+        /**
+         * Consume a string that may contain interpolation expressions.
+         *
+         * The first token consumed will be of `tokenType` and then there will be alternating
+         * `interpolationTokenType` and `tokenType` tokens until the `endPredicate()` returns true.
+         *
+         * If an interpolation token ends prematurely it will have no end marker in its `parts` array.
+         *
+         * @param textTokenType the kind of tokens to interleave around interpolation tokens.
+         * @param interpolationTokenType the kind of tokens that contain interpolation.
+         * @param endPredicate a function that should return true when we should stop consuming.
+         * @param endInterpolation a function that should return true if there is a premature end to an
+         *     interpolation expression - i.e. before we get to the normal interpolation closing marker.
+         */
+        _consumeWithInterpolation(textTokenType, interpolationTokenType, endPredicate, endInterpolation) {
+            this._beginToken(textTokenType);
             const parts = [];
-            do {
+            while (!endPredicate()) {
+                const current = this._cursor.clone();
                 if (this._interpolationConfig && this._attemptStr(this._interpolationConfig.start)) {
-                    parts.push(this._interpolationConfig.start);
-                    this._inInterpolation = true;
+                    this._endToken([this._processCarriageReturns(parts.join(''))], current);
+                    parts.length = 0;
+                    this._consumeInterpolation(interpolationTokenType, current, endInterpolation);
+                    this._beginToken(textTokenType);
                 }
-                else if (this._interpolationConfig && this._inInterpolation &&
-                    this._attemptStr(this._interpolationConfig.end)) {
-                    parts.push(this._interpolationConfig.end);
-                    this._inInterpolation = false;
+                else if (this._cursor.peek() === $AMPERSAND) {
+                    this._endToken([this._processCarriageReturns(parts.join(''))]);
+                    parts.length = 0;
+                    this._consumeEntity(textTokenType);
+                    this._beginToken(textTokenType);
                 }
                 else {
-                    parts.push(this._readChar(true));
+                    parts.push(this._readChar());
                 }
-            } while (!this._isTextEnd());
+            }
             // It is possible that an interpolation was started but not ended inside this text token.
             // Make sure that we reset the state of the lexer correctly.
             this._inInterpolation = false;
             this._endToken([this._processCarriageReturns(parts.join(''))]);
         }
+        /**
+         * Consume a block of text that has been interpreted as an Angular interpolation.
+         *
+         * @param interpolationTokenType the type of the interpolation token to generate.
+         * @param interpolationStart a cursor that points to the start of this interpolation.
+         * @param prematureEndPredicate a function that should return true if the next characters indicate
+         *     an end to the interpolation before its normal closing marker.
+         */
+        _consumeInterpolation(interpolationTokenType, interpolationStart, prematureEndPredicate) {
+            const parts = [];
+            this._beginToken(interpolationTokenType, interpolationStart);
+            parts.push(this._interpolationConfig.start);
+            // Find the end of the interpolation, ignoring content inside quotes.
+            const expressionStart = this._cursor.clone();
+            let inQuote = null;
+            let inComment = false;
+            while (this._cursor.peek() !== $EOF &&
+                (prematureEndPredicate === null || !prematureEndPredicate())) {
+                const current = this._cursor.clone();
+                if (this._isTagStart()) {
+                    // We are starting what looks like an HTML element in the middle of this interpolation.
+                    // Reset the cursor to before the `<` character and end the interpolation token.
+                    // (This is actually wrong but here for backward compatibility).
+                    this._cursor = current;
+                    parts.push(this._getProcessedChars(expressionStart, current));
+                    this._endToken(parts);
+                    return;
+                }
+                if (inQuote === null) {
+                    if (this._attemptStr(this._interpolationConfig.end)) {
+                        // We are not in a string, and we hit the end interpolation marker
+                        parts.push(this._getProcessedChars(expressionStart, current));
+                        parts.push(this._interpolationConfig.end);
+                        this._endToken(parts);
+                        return;
+                    }
+                    else if (this._attemptStr('//')) {
+                        // Once we are in a comment we ignore any quotes
+                        inComment = true;
+                    }
+                }
+                const char = this._cursor.peek();
+                this._cursor.advance();
+                if (char === $BACKSLASH) {
+                    // Skip the next character because it was escaped.
+                    this._cursor.advance();
+                }
+                else if (char === inQuote) {
+                    // Exiting the current quoted string
+                    inQuote = null;
+                }
+                else if (!inComment && inQuote === null && isQuote(char)) {
+                    // Entering a new quoted string
+                    inQuote = char;
+                }
+            }
+            // We hit EOF without finding a closing interpolation marker
+            parts.push(this._getProcessedChars(expressionStart, this._cursor));
+            this._endToken(parts);
+        }
+        _getProcessedChars(start, end) {
+            return this._processCarriageReturns(end.getChars(start));
+        }
         _isTextEnd() {
             if (this._isTagStart() || this._cursor.peek() === $EOF) {
                 return true;
@@ -11507,12 +11426,12 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         _isInExpansionCase() {
             return this._expansionCaseStack.length > 0 &&
                 this._expansionCaseStack[this._expansionCaseStack.length - 1] ===
-                    TokenType.EXPANSION_CASE_EXP_START;
+                    21 /* EXPANSION_CASE_EXP_START */;
         }
         _isInExpansionForm() {
             return this._expansionCaseStack.length > 0 &&
                 this._expansionCaseStack[this._expansionCaseStack.length - 1] ===
-                    TokenType.EXPANSION_FORM_START;
+                    19 /* EXPANSION_FORM_START */;
         }
         isExpansionFormStart() {
             if (this._cursor.peek() !== $LBRACE) {
@@ -11559,7 +11478,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         let lastDstToken = undefined;
         for (let i = 0; i < srcTokens.length; i++) {
             const token = srcTokens[i];
-            if (lastDstToken && lastDstToken.type === TokenType.TEXT && token.type === TokenType.TEXT) {
+            if ((lastDstToken && lastDstToken.type === 5 /* TEXT */ && token.type === 5 /* TEXT */) ||
+                (lastDstToken && lastDstToken.type === 16 /* ATTR_VALUE_TEXT */ &&
+                    token.type === 16 /* ATTR_VALUE_TEXT */)) {
                 lastDstToken.parts[0] += token.parts[0];
                 lastDstToken.sourceSpan.end = token.sourceSpan.end;
             }
@@ -11852,28 +11773,28 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             this._advance();
         }
         build() {
-            while (this._peek.type !== TokenType.EOF) {
-                if (this._peek.type === TokenType.TAG_OPEN_START ||
-                    this._peek.type === TokenType.INCOMPLETE_TAG_OPEN) {
+            while (this._peek.type !== 24 /* EOF */) {
+                if (this._peek.type === 0 /* TAG_OPEN_START */ ||
+                    this._peek.type === 4 /* INCOMPLETE_TAG_OPEN */) {
                     this._consumeStartTag(this._advance());
                 }
-                else if (this._peek.type === TokenType.TAG_CLOSE) {
+                else if (this._peek.type === 3 /* TAG_CLOSE */) {
                     this._consumeEndTag(this._advance());
                 }
-                else if (this._peek.type === TokenType.CDATA_START) {
+                else if (this._peek.type === 12 /* CDATA_START */) {
                     this._closeVoidElement();
                     this._consumeCdata(this._advance());
                 }
-                else if (this._peek.type === TokenType.COMMENT_START) {
+                else if (this._peek.type === 10 /* COMMENT_START */) {
                     this._closeVoidElement();
                     this._consumeComment(this._advance());
                 }
-                else if (this._peek.type === TokenType.TEXT || this._peek.type === TokenType.RAW_TEXT ||
-                    this._peek.type === TokenType.ESCAPABLE_RAW_TEXT) {
+                else if (this._peek.type === 5 /* TEXT */ || this._peek.type === 7 /* RAW_TEXT */ ||
+                    this._peek.type === 6 /* ESCAPABLE_RAW_TEXT */) {
                     this._closeVoidElement();
                     this._consumeText(this._advance());
                 }
-                else if (this._peek.type === TokenType.EXPANSION_FORM_START) {
+                else if (this._peek.type === 19 /* EXPANSION_FORM_START */) {
                     this._consumeExpansion(this._advance());
                 }
                 else {
@@ -11899,11 +11820,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
         _consumeCdata(_startToken) {
             this._consumeText(this._advance());
-            this._advanceIf(TokenType.CDATA_END);
+            this._advanceIf(13 /* CDATA_END */);
         }
         _consumeComment(token) {
-            const text = this._advanceIf(TokenType.RAW_TEXT);
-            this._advanceIf(TokenType.COMMENT_END);
+            const text = this._advanceIf(7 /* RAW_TEXT */);
+            this._advanceIf(11 /* COMMENT_END */);
             const value = text != null ? text.parts[0].trim() : null;
             this._addToParent(new Comment$1(value, token.sourceSpan));
         }
@@ -11912,14 +11833,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             const type = this._advance();
             const cases = [];
             // read =
-            while (this._peek.type === TokenType.EXPANSION_CASE_VALUE) {
+            while (this._peek.type === 20 /* EXPANSION_CASE_VALUE */) {
                 const expCase = this._parseExpansionCase();
                 if (!expCase)
                     return; // error
                 cases.push(expCase);
             }
             // read the final }
-            if (this._peek.type !== TokenType.EXPANSION_FORM_END) {
+            if (this._peek.type !== 23 /* EXPANSION_FORM_END */) {
                 this.errors.push(TreeError.create(null, this._peek.sourceSpan, `Invalid ICU message. Missing '}'.`));
                 return;
             }
@@ -11930,7 +11851,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         _parseExpansionCase() {
             const value = this._advance();
             // read {
-            if (this._peek.type !== TokenType.EXPANSION_CASE_EXP_START) {
+            if (this._peek.type !== 21 /* EXPANSION_CASE_EXP_START */) {
                 this.errors.push(TreeError.create(null, this._peek.sourceSpan, `Invalid ICU message. Missing '{'.`));
                 return null;
             }
@@ -11940,7 +11861,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             if (!exp)
                 return null;
             const end = this._advance();
-            exp.push(new Token(TokenType.EOF, [], end.sourceSpan));
+            exp.push({ type: 24 /* EOF */, parts: [], sourceSpan: end.sourceSpan });
             // parse everything in between { and }
             const expansionCaseParser = new _TreeBuilder(exp, this.getTagDefinition);
             expansionCaseParser.build();
@@ -11954,14 +11875,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
         _collectExpansionExpTokens(start) {
             const exp = [];
-            const expansionFormStack = [TokenType.EXPANSION_CASE_EXP_START];
+            const expansionFormStack = [21 /* EXPANSION_CASE_EXP_START */];
             while (true) {
-                if (this._peek.type === TokenType.EXPANSION_FORM_START ||
-                    this._peek.type === TokenType.EXPANSION_CASE_EXP_START) {
+                if (this._peek.type === 19 /* EXPANSION_FORM_START */ ||
+                    this._peek.type === 21 /* EXPANSION_CASE_EXP_START */) {
                     expansionFormStack.push(this._peek.type);
                 }
-                if (this._peek.type === TokenType.EXPANSION_CASE_EXP_END) {
-                    if (lastOnStack(expansionFormStack, TokenType.EXPANSION_CASE_EXP_START)) {
+                if (this._peek.type === 22 /* EXPANSION_CASE_EXP_END */) {
+                    if (lastOnStack(expansionFormStack, 21 /* EXPANSION_CASE_EXP_START */)) {
                         expansionFormStack.pop();
                         if (expansionFormStack.length === 0)
                             return exp;
@@ -11971,8 +11892,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                         return null;
                     }
                 }
-                if (this._peek.type === TokenType.EXPANSION_FORM_END) {
-                    if (lastOnStack(expansionFormStack, TokenType.EXPANSION_FORM_START)) {
+                if (this._peek.type === 23 /* EXPANSION_FORM_END */) {
+                    if (lastOnStack(expansionFormStack, 19 /* EXPANSION_FORM_START */)) {
                         expansionFormStack.pop();
                     }
                     else {
@@ -11980,7 +11901,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                         return null;
                     }
                 }
-                if (this._peek.type === TokenType.EOF) {
+                if (this._peek.type === 24 /* EOF */) {
                     this.errors.push(TreeError.create(null, start.sourceSpan, `Invalid ICU message. Missing '}'.`));
                     return null;
                 }
@@ -11988,16 +11909,38 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
         }
         _consumeText(token) {
+            const tokens = [token];
+            const startSpan = token.sourceSpan;
             let text = token.parts[0];
             if (text.length > 0 && text[0] === '\n') {
                 const parent = this._getParentElement();
                 if (parent != null && parent.children.length === 0 &&
                     this.getTagDefinition(parent.name).ignoreFirstLf) {
                     text = text.substring(1);
+                    tokens[0] = { type: token.type, sourceSpan: token.sourceSpan, parts: [text] };
+                }
+            }
+            while (this._peek.type === 8 /* INTERPOLATION */ || this._peek.type === 5 /* TEXT */ ||
+                this._peek.type === 9 /* ENCODED_ENTITY */) {
+                token = this._advance();
+                tokens.push(token);
+                if (token.type === 8 /* INTERPOLATION */) {
+                    // For backward compatibility we decode HTML entities that appear in interpolation
+                    // expressions. This is arguably a bug, but it could be a considerable breaking change to
+                    // fix it. It should be addressed in a larger project to refactor the entire parser/lexer
+                    // chain after View Engine has been removed.
+                    text += token.parts.join('').replace(/&([^;]+);/g, decodeEntity);
+                }
+                else if (token.type === 9 /* ENCODED_ENTITY */) {
+                    text += token.parts[0];
+                }
+                else {
+                    text += token.parts.join('');
                 }
             }
             if (text.length > 0) {
-                this._addToParent(new Text$2(text, token.sourceSpan));
+                const endSpan = token.sourceSpan;
+                this._addToParent(new Text$2(text, new ParseSourceSpan(startSpan.start, endSpan.end, startSpan.fullStart, startSpan.details), tokens));
             }
         }
         _closeVoidElement() {
@@ -12009,14 +11952,14 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         _consumeStartTag(startTagToken) {
             const [prefix, name] = startTagToken.parts;
             const attrs = [];
-            while (this._peek.type === TokenType.ATTR_NAME) {
+            while (this._peek.type === 14 /* ATTR_NAME */) {
                 attrs.push(this._consumeAttr(this._advance()));
             }
             const fullName = this._getElementFullName(prefix, name, this._getParentElement());
             let selfClosing = false;
             // Note: There could have been a tokenizer error
             // so that we don't get a token for the end tag...
-            if (this._peek.type === TokenType.TAG_OPEN_END_VOID) {
+            if (this._peek.type === 2 /* TAG_OPEN_END_VOID */) {
                 this._advance();
                 selfClosing = true;
                 const tagDef = this.getTagDefinition(fullName);
@@ -12024,7 +11967,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     this.errors.push(TreeError.create(fullName, startTagToken.sourceSpan, `Only void and foreign elements can be self closed "${startTagToken.parts[1]}"`));
                 }
             }
-            else if (this._peek.type === TokenType.TAG_OPEN_END) {
+            else if (this._peek.type === 1 /* TAG_OPEN_END */) {
                 this._advance();
                 selfClosing = false;
             }
@@ -12039,7 +11982,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 // element start tag also represents the end tag.
                 this._popElement(fullName, span);
             }
-            else if (startTagToken.type === TokenType.INCOMPLETE_TAG_OPEN) {
+            else if (startTagToken.type === 4 /* INCOMPLETE_TAG_OPEN */) {
                 // We already know the opening tag is not complete, so it is unlikely it has a corresponding
                 // close tag. Let's optimistically parse it as a full element and emit an error.
                 this._popElement(fullName, null);
@@ -12094,24 +12037,53 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
         _consumeAttr(attrName) {
             const fullName = mergeNsAndName(attrName.parts[0], attrName.parts[1]);
-            let end = attrName.sourceSpan.end;
-            let value = '';
-            let valueSpan = undefined;
-            if (this._peek.type === TokenType.ATTR_QUOTE) {
+            let attrEnd = attrName.sourceSpan.end;
+            // Consume any quote
+            if (this._peek.type === 15 /* ATTR_QUOTE */) {
                 this._advance();
             }
-            if (this._peek.type === TokenType.ATTR_VALUE) {
-                const valueToken = this._advance();
-                value = valueToken.parts[0];
-                end = valueToken.sourceSpan.end;
-                valueSpan = valueToken.sourceSpan;
+            // Consume the attribute value
+            let value = '';
+            const valueTokens = [];
+            let valueStartSpan = undefined;
+            let valueEnd = undefined;
+            // NOTE: We need to use a new variable `nextTokenType` here to hide the actual type of
+            // `_peek.type` from TS. Otherwise TS will narrow the type of `_peek.type` preventing it from
+            // being able to consider `ATTR_VALUE_INTERPOLATION` as an option. This is because TS is not
+            // able to see that `_advance()` will actually mutate `_peek`.
+            const nextTokenType = this._peek.type;
+            if (nextTokenType === 16 /* ATTR_VALUE_TEXT */) {
+                valueStartSpan = this._peek.sourceSpan;
+                valueEnd = this._peek.sourceSpan.end;
+                while (this._peek.type === 16 /* ATTR_VALUE_TEXT */ ||
+                    this._peek.type === 17 /* ATTR_VALUE_INTERPOLATION */ ||
+                    this._peek.type === 9 /* ENCODED_ENTITY */) {
+                    const valueToken = this._advance();
+                    valueTokens.push(valueToken);
+                    if (valueToken.type === 17 /* ATTR_VALUE_INTERPOLATION */) {
+                        // For backward compatibility we decode HTML entities that appear in interpolation
+                        // expressions. This is arguably a bug, but it could be a considerable breaking change to
+                        // fix it. It should be addressed in a larger project to refactor the entire parser/lexer
+                        // chain after View Engine has been removed.
+                        value += valueToken.parts.join('').replace(/&([^;]+);/g, decodeEntity);
+                    }
+                    else if (valueToken.type === 9 /* ENCODED_ENTITY */) {
+                        value += valueToken.parts[0];
+                    }
+                    else {
+                        value += valueToken.parts.join('');
+                    }
+                    valueEnd = attrEnd = valueToken.sourceSpan.end;
+                }
             }
-            if (this._peek.type === TokenType.ATTR_QUOTE) {
+            // Consume any quote
+            if (this._peek.type === 15 /* ATTR_QUOTE */) {
                 const quoteToken = this._advance();
-                end = quoteToken.sourceSpan.end;
+                attrEnd = quoteToken.sourceSpan.end;
             }
-            const keySpan = new ParseSourceSpan(attrName.sourceSpan.start, attrName.sourceSpan.end);
-            return new Attribute(fullName, value, new ParseSourceSpan(attrName.sourceSpan.start, end, attrName.sourceSpan.fullStart), keySpan, valueSpan);
+            const valueSpan = valueStartSpan && valueEnd &&
+                new ParseSourceSpan(valueStartSpan.start, valueEnd, valueStartSpan.fullStart);
+            return new Attribute(fullName, value, new ParseSourceSpan(attrName.sourceSpan.start, attrEnd, attrName.sourceSpan.fullStart), attrName.sourceSpan, valueSpan, valueTokens.length > 0 ? valueTokens : undefined, undefined);
         }
         _getParentElement() {
             return this._elementStack.length > 0 ? this._elementStack[this._elementStack.length - 1] : null;
@@ -12142,6 +12114,23 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function lastOnStack(stack, element) {
         return stack.length > 0 && stack[stack.length - 1] === element;
     }
+    /**
+     * Decode the `entity` string, which we believe is the contents of an HTML entity.
+     *
+     * If the string is not actually a valid/known entity then just return the original `match` string.
+     */
+    function decodeEntity(match, entity) {
+        if (NAMED_ENTITIES[entity] !== undefined) {
+            return NAMED_ENTITIES[entity] || match;
+        }
+        if (/^#x[a-f0-9]+$/i.test(entity)) {
+            return String.fromCodePoint(parseInt(entity.slice(2), 16));
+        }
+        if (/^#\d+$/.test(entity)) {
+            return String.fromCodePoint(parseInt(entity.slice(1), 10));
+        }
+        return match;
+    }
 
     /**
      * @license
@@ -12217,7 +12206,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             const hasExpansionSibling = context &&
                 (context.prev instanceof Expansion || context.next instanceof Expansion);
             if (isNotBlank || hasExpansionSibling) {
-                return new Text$2(replaceNgsp(text.value).replace(WS_REPLACE_REGEXP, ' '), text.sourceSpan, text.i18n);
+                // Process the whitespace in the tokens of this Text node
+                const tokens = text.tokens.map(token => token.type === 5 /* TEXT */ ? createWhitespaceProcessedTextToken(token) : token);
+                // Process the whitespace of the value of this Text node
+                const value = processWhitespace(text.value);
+                return new Text$2(value, text.sourceSpan, tokens, text.i18n);
             }
             return null;
         }
@@ -12231,6 +12224,12 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return expansionCase;
         }
     }
+    function createWhitespaceProcessedTextToken({ type, parts, sourceSpan }) {
+        return { type, parts: [processWhitespace(parts[0])], sourceSpan };
+    }
+    function processWhitespace(text) {
+        return replaceNgsp(text).replace(WS_REPLACE_REGEXP, ' ');
+    }
     function visitAllWithSiblings(visitor, nodes) {
         const result = [];
         nodes.forEach((ast, i) => {
@@ -13481,7 +13480,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
      */
-    var TokenType$1;
+    var TokenType;
     (function (TokenType) {
         TokenType[TokenType["Character"] = 0] = "Character";
         TokenType[TokenType["Identifier"] = 1] = "Identifier";
@@ -13491,7 +13490,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         TokenType[TokenType["Operator"] = 5] = "Operator";
         TokenType[TokenType["Number"] = 6] = "Number";
         TokenType[TokenType["Error"] = 7] = "Error";
-    })(TokenType$1 || (TokenType$1 = {}));
+    })(TokenType || (TokenType = {}));
     const KEYWORDS = ['var', 'let', 'as', 'null', 'undefined', 'true', 'false', 'if', 'else', 'this'];
     class Lexer {
         tokenize(text) {
@@ -13505,7 +13504,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return tokens;
         }
     }
-    class Token$1 {
+    class Token {
         constructor(index, end, type, numValue, strValue) {
             this.index = index;
             this.end = end;
@@ -13514,64 +13513,64 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             this.strValue = strValue;
         }
         isCharacter(code) {
-            return this.type == TokenType$1.Character && this.numValue == code;
+            return this.type == TokenType.Character && this.numValue == code;
         }
         isNumber() {
-            return this.type == TokenType$1.Number;
+            return this.type == TokenType.Number;
         }
         isString() {
-            return this.type == TokenType$1.String;
+            return this.type == TokenType.String;
         }
         isOperator(operator) {
-            return this.type == TokenType$1.Operator && this.strValue == operator;
+            return this.type == TokenType.Operator && this.strValue == operator;
         }
         isIdentifier() {
-            return this.type == TokenType$1.Identifier;
+            return this.type == TokenType.Identifier;
         }
         isPrivateIdentifier() {
-            return this.type == TokenType$1.PrivateIdentifier;
+            return this.type == TokenType.PrivateIdentifier;
         }
         isKeyword() {
-            return this.type == TokenType$1.Keyword;
+            return this.type == TokenType.Keyword;
         }
         isKeywordLet() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'let';
+            return this.type == TokenType.Keyword && this.strValue == 'let';
         }
         isKeywordAs() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'as';
+            return this.type == TokenType.Keyword && this.strValue == 'as';
         }
         isKeywordNull() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'null';
+            return this.type == TokenType.Keyword && this.strValue == 'null';
         }
         isKeywordUndefined() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'undefined';
+            return this.type == TokenType.Keyword && this.strValue == 'undefined';
         }
         isKeywordTrue() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'true';
+            return this.type == TokenType.Keyword && this.strValue == 'true';
         }
         isKeywordFalse() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'false';
+            return this.type == TokenType.Keyword && this.strValue == 'false';
         }
         isKeywordThis() {
-            return this.type == TokenType$1.Keyword && this.strValue == 'this';
+            return this.type == TokenType.Keyword && this.strValue == 'this';
         }
         isError() {
-            return this.type == TokenType$1.Error;
+            return this.type == TokenType.Error;
         }
         toNumber() {
-            return this.type == TokenType$1.Number ? this.numValue : -1;
+            return this.type == TokenType.Number ? this.numValue : -1;
         }
         toString() {
             switch (this.type) {
-                case TokenType$1.Character:
-                case TokenType$1.Identifier:
-                case TokenType$1.Keyword:
-                case TokenType$1.Operator:
-                case TokenType$1.PrivateIdentifier:
-                case TokenType$1.String:
-                case TokenType$1.Error:
+                case TokenType.Character:
+                case TokenType.Identifier:
+                case TokenType.Keyword:
+                case TokenType.Operator:
+                case TokenType.PrivateIdentifier:
+                case TokenType.String:
+                case TokenType.Error:
                     return this.strValue;
-                case TokenType$1.Number:
+                case TokenType.Number:
                     return this.numValue.toString();
                 default:
                     return null;
@@ -13579,30 +13578,30 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
     }
     function newCharacterToken(index, end, code) {
-        return new Token$1(index, end, TokenType$1.Character, code, String.fromCharCode(code));
+        return new Token(index, end, TokenType.Character, code, String.fromCharCode(code));
     }
     function newIdentifierToken(index, end, text) {
-        return new Token$1(index, end, TokenType$1.Identifier, 0, text);
+        return new Token(index, end, TokenType.Identifier, 0, text);
     }
     function newPrivateIdentifierToken(index, end, text) {
-        return new Token$1(index, end, TokenType$1.PrivateIdentifier, 0, text);
+        return new Token(index, end, TokenType.PrivateIdentifier, 0, text);
     }
     function newKeywordToken(index, end, text) {
-        return new Token$1(index, end, TokenType$1.Keyword, 0, text);
+        return new Token(index, end, TokenType.Keyword, 0, text);
     }
     function newOperatorToken(index, end, text) {
-        return new Token$1(index, end, TokenType$1.Operator, 0, text);
+        return new Token(index, end, TokenType.Operator, 0, text);
     }
     function newStringToken(index, end, text) {
-        return new Token$1(index, end, TokenType$1.String, 0, text);
+        return new Token(index, end, TokenType.String, 0, text);
     }
     function newNumberToken(index, end, n) {
-        return new Token$1(index, end, TokenType$1.Number, n, '');
+        return new Token(index, end, TokenType.Number, n, '');
     }
     function newErrorToken(index, end, message) {
-        return new Token$1(index, end, TokenType$1.Error, 0, message);
+        return new Token(index, end, TokenType.Error, 0, message);
     }
-    const EOF = new Token$1(-1, -1, TokenType$1.Character, 0, '');
+    const EOF = new Token(-1, -1, TokenType.Character, 0, '');
     class _Scanner {
         constructor(input) {
             this.input = input;
@@ -14509,7 +14508,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             // '==','!=','===','!=='
             const start = this.inputIndex;
             let result = this.parseRelational();
-            while (this.next.type == TokenType$1.Operator) {
+            while (this.next.type == TokenType.Operator) {
                 const operator = this.next.strValue;
                 switch (operator) {
                     case '==':
@@ -14529,7 +14528,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             // '<', '>', '<=', '>='
             const start = this.inputIndex;
             let result = this.parseAdditive();
-            while (this.next.type == TokenType$1.Operator) {
+            while (this.next.type == TokenType.Operator) {
                 const operator = this.next.strValue;
                 switch (operator) {
                     case '<':
@@ -14549,7 +14548,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             // '+', '-'
             const start = this.inputIndex;
             let result = this.parseMultiplicative();
-            while (this.next.type == TokenType$1.Operator) {
+            while (this.next.type == TokenType.Operator) {
                 const operator = this.next.strValue;
                 switch (operator) {
                     case '+':
@@ -14567,7 +14566,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             // '*', '%', '/'
             const start = this.inputIndex;
             let result = this.parsePrefix();
-            while (this.next.type == TokenType$1.Operator) {
+            while (this.next.type == TokenType.Operator) {
                 const operator = this.next.strValue;
                 switch (operator) {
                     case '*':
@@ -14583,7 +14582,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return result;
         }
         parsePrefix() {
-            if (this.next.type == TokenType$1.Operator) {
+            if (this.next.type == TokenType.Operator) {
                 const start = this.inputIndex;
                 const operator = this.next.strValue;
                 let result;
@@ -14609,22 +14608,24 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             let result = this.parsePrimary();
             while (true) {
                 if (this.consumeOptionalCharacter($PERIOD)) {
-                    result = this.parseAccessMemberOrMethodCall(result, start, false);
+                    result = this.parseAccessMemberOrCall(result, start, false);
                 }
                 else if (this.consumeOptionalOperator('?.')) {
                     result = this.consumeOptionalCharacter($LBRACKET) ?
                         this.parseKeyedReadOrWrite(result, start, true) :
-                        this.parseAccessMemberOrMethodCall(result, start, true);
+                        this.parseAccessMemberOrCall(result, start, true);
                 }
                 else if (this.consumeOptionalCharacter($LBRACKET)) {
                     result = this.parseKeyedReadOrWrite(result, start, false);
                 }
                 else if (this.consumeOptionalCharacter($LPAREN)) {
+                    const argumentStart = this.inputIndex;
                     this.rparensExpected++;
                     const args = this.parseCallArguments();
+                    const argumentSpan = this.span(argumentStart, this.inputIndex).toAbsolute(this.absoluteOffset);
                     this.rparensExpected--;
                     this.expectCharacter($RPAREN);
-                    result = new FunctionCall(this.span(start), this.sourceSpan(start), result, args);
+                    result = new Call(this.span(start), this.sourceSpan(start), result, args, argumentSpan);
                 }
                 else if (this.consumeOptionalOperator('!')) {
                     result = new NonNullAssert(this.span(start), this.sourceSpan(start), result);
@@ -14674,7 +14675,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)), start, false);
+                return this.parseAccessMemberOrCall(new ImplicitReceiver(this.span(start), this.sourceSpan(start)), start, false);
             }
             else if (this.next.isNumber()) {
                 const value = this.next.toNumber();
@@ -14742,17 +14743,41 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             }
             return new LiteralMap(this.span(start), this.sourceSpan(start), keys, values);
         }
-        parseAccessMemberOrMethodCall(receiver, start, isSafe) {
+        parseAccessMemberOrCall(readReceiver, start, isSafe) {
             const nameStart = this.inputIndex;
             const id = this.withContext(ParseContextFlags.Writable, () => {
                 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);
+                    this.error(`Expected identifier for property access`, readReceiver.span.end);
                 }
                 return id;
             });
             const nameSpan = this.sourceSpan(nameStart);
+            let receiver;
+            if (isSafe) {
+                if (this.consumeOptionalOperator('=')) {
+                    this.error('The \'?.\' operator cannot be used in the assignment');
+                    receiver = new EmptyExpr(this.span(start), this.sourceSpan(start));
+                }
+                else {
+                    receiver = new SafePropertyRead(this.span(start), this.sourceSpan(start), nameSpan, readReceiver, id);
+                }
+            }
+            else {
+                if (this.consumeOptionalOperator('=')) {
+                    if (!this.parseAction) {
+                        this.error('Bindings cannot contain assignments');
+                        return new EmptyExpr(this.span(start), this.sourceSpan(start));
+                    }
+                    const value = this.parseConditional();
+                    receiver = new PropertyWrite(this.span(start), this.sourceSpan(start), nameSpan, readReceiver, id, value);
+                }
+                else {
+                    receiver =
+                        new PropertyRead(this.span(start), this.sourceSpan(start), nameSpan, readReceiver, id);
+                }
+            }
             if (this.consumeOptionalCharacter($LPAREN)) {
                 const argumentStart = this.inputIndex;
                 this.rparensExpected++;
@@ -14762,34 +14787,9 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 this.rparensExpected--;
                 const span = this.span(start);
                 const sourceSpan = this.sourceSpan(start);
-                return isSafe ?
-                    new SafeMethodCall(span, sourceSpan, nameSpan, receiver, id, args, argumentSpan) :
-                    new MethodCall(span, sourceSpan, nameSpan, receiver, id, args, argumentSpan);
-            }
-            else {
-                if (isSafe) {
-                    if (this.consumeOptionalOperator('=')) {
-                        this.error('The \'?.\' operator cannot be used in the assignment');
-                        return new EmptyExpr(this.span(start), this.sourceSpan(start));
-                    }
-                    else {
-                        return new SafePropertyRead(this.span(start), this.sourceSpan(start), nameSpan, receiver, id);
-                    }
-                }
-                else {
-                    if (this.consumeOptionalOperator('=')) {
-                        if (!this.parseAction) {
-                            this.error('Bindings cannot contain assignments');
-                            return new EmptyExpr(this.span(start), this.sourceSpan(start));
-                        }
-                        const value = this.parseConditional();
-                        return new PropertyWrite(this.span(start), this.sourceSpan(start), nameSpan, receiver, id, value);
-                    }
-                    else {
-                        return new PropertyRead(this.span(start), this.sourceSpan(start), nameSpan, receiver, id);
-                    }
-                }
+                return new Call(span, sourceSpan, receiver, args, argumentSpan);
             }
+            return receiver;
         }
         parseCallArguments() {
             if (this.next.isCharacter($RPAREN))
@@ -15085,9 +15085,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         visitPropertyRead(ast, context) { }
         visitPropertyWrite(ast, context) { }
         visitSafePropertyRead(ast, context) { }
-        visitMethodCall(ast, context) { }
-        visitSafeMethodCall(ast, context) { }
-        visitFunctionCall(ast, context) { }
+        visitCall(ast, context) { }
         visitLiteralArray(ast, context) {
             this.visitAll(ast.expressions, context);
         }
@@ -16515,11 +16513,15 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             return context.visitNodeFn(el, node);
         }
         visitAttribute(attribute, context) {
-            const node = this._visitTextWithInterpolation(attribute.value, attribute.valueSpan || attribute.sourceSpan, context, attribute.i18n);
+            const node = attribute.valueTokens === undefined || attribute.valueTokens.length === 1 ?
+                new Text$1(attribute.value, attribute.valueSpan || attribute.sourceSpan) :
+                this._visitTextWithInterpolation(attribute.valueTokens, attribute.valueSpan || attribute.sourceSpan, context, attribute.i18n);
             return context.visitNodeFn(attribute, node);
         }
         visitText(text, context) {
-            const node = this._visitTextWithInterpolation(text.value, text.sourceSpan, context, text.i18n);
+            const node = text.tokens.length === 1 ?
+                new Text$1(text.value, text.sourceSpan) :
+                this._visitTextWithInterpolation(text.tokens, text.sourceSpan, context, text.i18n);
             return context.visitNodeFn(text, node);
         }
         visitComment(comment, context) {
@@ -16558,61 +16560,58 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             throw new Error('Unreachable code');
         }
         /**
-         * Split the, potentially interpolated, text up into text and placeholder pieces.
+         * Convert, text and interpolated tokens up into text and placeholder pieces.
          *
-         * @param text The potentially interpolated string to be split.
+         * @param tokens The text and interpolated tokens.
          * @param sourceSpan The span of the whole of the `text` string.
          * @param context The current context of the visitor, used to compute and store placeholders.
          * @param previousI18n Any i18n metadata associated with this `text` from a previous pass.
          */
-        _visitTextWithInterpolation(text, sourceSpan, context, previousI18n) {
-            const { strings, expressions } = this._expressionParser.splitInterpolation(text, sourceSpan.start.toString(), this._interpolationConfig);
-            // No expressions, return a single text.
-            if (expressions.length === 0) {
-                return new Text$1(text, sourceSpan);
-            }
+        _visitTextWithInterpolation(tokens, sourceSpan, context, previousI18n) {
             // Return a sequence of `Text` and `Placeholder` nodes grouped in a `Container`.
             const nodes = [];
-            for (let i = 0; i < strings.length - 1; i++) {
-                this._addText(nodes, strings[i], sourceSpan);
-                this._addPlaceholder(nodes, context, expressions[i], sourceSpan);
+            // We will only create a container if there are actually interpolations,
+            // so this flag tracks that.
+            let hasInterpolation = false;
+            for (const token of tokens) {
+                switch (token.type) {
+                    case 8 /* INTERPOLATION */:
+                    case 17 /* ATTR_VALUE_INTERPOLATION */:
+                        hasInterpolation = true;
+                        const expression = token.parts[1];
+                        const baseName = extractPlaceholderName(expression) || 'INTERPOLATION';
+                        const phName = context.placeholderRegistry.getPlaceholderName(baseName, expression);
+                        context.placeholderToContent[phName] = {
+                            text: token.parts.join(''),
+                            sourceSpan: token.sourceSpan
+                        };
+                        nodes.push(new Placeholder(expression, phName, token.sourceSpan));
+                        break;
+                    default:
+                        if (token.parts[0].length > 0) {
+                            // This token is text or an encoded entity.
+                            // If it is following on from a previous text node then merge it into that node
+                            // Otherwise, if it is following an interpolation, then add a new node.
+                            const previous = nodes[nodes.length - 1];
+                            if (previous instanceof Text$1) {
+                                previous.value += token.parts[0];
+                                previous.sourceSpan = new ParseSourceSpan(previous.sourceSpan.start, token.sourceSpan.end, previous.sourceSpan.fullStart, previous.sourceSpan.details);
+                            }
+                            else {
+                                nodes.push(new Text$1(token.parts[0], token.sourceSpan));
+                            }
+                        }
+                        break;
+                }
             }
-            // The last index contains no expression
-            this._addText(nodes, strings[strings.length - 1], sourceSpan);
-            // Whitespace removal may have invalidated the interpolation source-spans.
-            reusePreviousSourceSpans(nodes, previousI18n);
-            return new Container(nodes, sourceSpan);
-        }
-        /**
-         * Create a new `Text` node from the `textPiece` and add it to the `nodes` collection.
-         *
-         * @param nodes The nodes to which the created `Text` node should be added.
-         * @param textPiece The text and relative span information for this `Text` node.
-         * @param interpolationSpan The span of the whole interpolated text.
-         */
-        _addText(nodes, textPiece, interpolationSpan) {
-            if (textPiece.text.length > 0) {
-                // No need to add empty strings
-                const stringSpan = getOffsetSourceSpan(interpolationSpan, textPiece);
-                nodes.push(new Text$1(textPiece.text, stringSpan));
+            if (hasInterpolation) {
+                // Whitespace removal may have invalidated the interpolation source-spans.
+                reusePreviousSourceSpans(nodes, previousI18n);
+                return new Container(nodes, sourceSpan);
+            }
+            else {
+                return nodes[0];
             }
-        }
-        /**
-         * Create a new `Placeholder` node from the `expression` and add it to the `nodes` collection.
-         *
-         * @param nodes The nodes to which the created `Text` node should be added.
-         * @param context The current context of the visitor, used to compute and store placeholders.
-         * @param expression The expression text and relative span information for this `Placeholder`
-         *     node.
-         * @param interpolationSpan The span of the whole interpolated text.
-         */
-        _addPlaceholder(nodes, context, expression, interpolationSpan) {
-            const sourceSpan = getOffsetSourceSpan(interpolationSpan, expression);
-            const baseName = extractPlaceholderName(expression.text) || 'INTERPOLATION';
-            const phName = context.placeholderRegistry.getPlaceholderName(baseName, expression.text);
-            const text = this._interpolationConfig.start + expression.text + this._interpolationConfig.end;
-            context.placeholderToContent[phName] = { text, sourceSpan };
-            nodes.push(new Placeholder(expression.text, phName, sourceSpan));
         }
     }
     /**
@@ -16634,7 +16633,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         }
         if (previousI18n instanceof Container) {
             // The `previousI18n` is a `Container`, which means that this is a second i18n extraction pass
-            // after whitespace has been removed from the AST ndoes.
+            // after whitespace has been removed from the AST nodes.
             assertEquivalentNodes(previousI18n.children, nodes);
             // Reuse the source-spans from the first pass.
             for (let i = 0; i < nodes.length; i++) {
@@ -16663,12 +16662,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             throw new Error('The types of the i18n message children changed between first and second pass.');
         }
     }
-    /**
-     * Create a new `ParseSourceSpan` from the `sourceSpan`, offset by the `start` and `end` values.
-     */
-    function getOffsetSourceSpan(sourceSpan, { start, end }) {
-        return new ParseSourceSpan(sourceSpan.fullStart.moveBy(start), sourceSpan.fullStart.moveBy(end));
-    }
     const _CUSTOM_PH_EXP = /\/\/[\s\S]*i18n[\s\S]*\([\s\S]*ph[\s\S]*=[\s\S]*("|')([\s\S]*?)\1[\s\S]*\)/g;
     function extractPlaceholderName(input) {
         return input.split(_CUSTOM_PH_EXP)[2];
@@ -16988,7 +16981,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 context[context.length - 1].text += text.value;
             }
             else {
-                context.push(new LiteralPiece(text.value, text.sourceSpan));
+                const sourceSpan = new ParseSourceSpan(text.sourceSpan.fullStart, text.sourceSpan.end, text.sourceSpan.fullStart, text.sourceSpan.details);
+                context.push(new LiteralPiece(text.value, sourceSpan));
             }
         }
         visitContainer(container, context) {
@@ -17032,7 +17026,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function getSourceSpan(message) {
         const startNode = message.nodes[0];
         const endNode = message.nodes[message.nodes.length - 1];
-        return new ParseSourceSpan(startNode.sourceSpan.start, endNode.sourceSpan.end, startNode.sourceSpan.fullStart, startNode.sourceSpan.details);
+        return new ParseSourceSpan(startNode.sourceSpan.fullStart, endNode.sourceSpan.end, startNode.sourceSpan.fullStart, startNode.sourceSpan.details);
     }
     /**
      * Convert the list of serialized MessagePieces into two arrays.
@@ -18266,11 +18260,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             const convertedArgs = isVarLength ?
                 this.visitAll([new LiteralArray(pipe.span, pipe.sourceSpan, args)]) :
                 this.visitAll(args);
-            const pipeBindExpr = new FunctionCall(pipe.span, pipe.sourceSpan, target, [
+            const pipeBindExpr = new Call(pipe.span, pipe.sourceSpan, target, [
                 new LiteralPrimitive(pipe.span, pipe.sourceSpan, slot),
                 new LiteralPrimitive(pipe.span, pipe.sourceSpan, pureFunctionSlot),
                 ...convertedArgs,
-            ]);
+            ], null);
             this._pipeBindExprs.push(pipeBindExpr);
             return pipeBindExpr;
         }
@@ -19065,7 +19059,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                 return fn([], [new ReturnStatement(list)]);
             case 2 /* ClosureResolved */:
                 // directives: function () { return [MyDir].map(ng.resolveForwardRef); }
-                const resolvedList = list.callMethod('map', [importExpr(Identifiers.resolveForwardRef)]);
+                const resolvedList = list.prop('map').callFn([importExpr(Identifiers.resolveForwardRef)]);
                 return fn([], [new ReturnStatement(resolvedList)]);
         }
     }
@@ -19938,7 +19932,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('13.0.0-next.3');
+    const VERSION$1 = new Version('13.0.0-next.7');
 
     /**
      * @license
@@ -20436,14 +20430,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             this.maybeMap(context, ast, ast.name);
             return super.visitPropertyWrite(ast, context);
         }
-        visitMethodCall(ast, context) {
-            this.maybeMap(context, ast, ast.name);
-            return super.visitMethodCall(ast, context);
-        }
-        visitSafeMethodCall(ast, context) {
-            this.maybeMap(context, ast, ast.name);
-            return super.visitSafeMethodCall(ast, context);
-        }
         maybeMap(scope, ast, name) {
             // If the receiver of the expression isn't the `ImplicitReceiver`, this isn't the root of an
             // `AST` expression that maps to a `Variable` or `Reference`.
@@ -20577,7 +20563,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function compileDeclareClassMetadata(metadata) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-        definitionMap.set('version', literal('13.0.0-next.3'));
+        definitionMap.set('version', literal('13.0.0-next.7'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', metadata.type);
         definitionMap.set('decorators', metadata.decorators);
@@ -20617,7 +20603,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createDirectiveDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-        definitionMap.set('version', literal('13.0.0-next.3'));
+        definitionMap.set('version', literal('13.0.0-next.7'));
         // e.g. `type: MyDirective`
         definitionMap.set('type', meta.internalType);
         // e.g. `selector: 'some-dir'`
@@ -20834,7 +20820,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function compileDeclareFactoryFunction(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-        definitionMap.set('version', literal('13.0.0-next.3'));
+        definitionMap.set('version', literal('13.0.0-next.7'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         definitionMap.set('deps', compileDependencies(meta.deps));
@@ -20876,7 +20862,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createInjectableDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-        definitionMap.set('version', literal('13.0.0-next.3'));
+        definitionMap.set('version', literal('13.0.0-next.7'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         // Only generate providedIn property if it has a non-null value
@@ -20955,7 +20941,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createInjectorDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-        definitionMap.set('version', literal('13.0.0-next.3'));
+        definitionMap.set('version', literal('13.0.0-next.7'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         definitionMap.set('providers', meta.providers);
@@ -20992,7 +20978,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createNgModuleDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-        definitionMap.set('version', literal('13.0.0-next.3'));
+        definitionMap.set('version', literal('13.0.0-next.7'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         definitionMap.set('type', meta.internalType);
         // We only generate the keys in the metadata if the arrays contain values.
@@ -21050,7 +21036,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
     function createPipeDefinitionMap(meta) {
         const definitionMap = new DefinitionMap();
         definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$6));
-        definitionMap.set('version', literal('13.0.0-next.3'));
+        definitionMap.set('version', literal('13.0.0-next.7'));
         definitionMap.set('ngImport', importExpr(Identifiers.core));
         // e.g. `type: MyPipe`
         definitionMap.set('type', meta.internalType);
@@ -21082,7 +21068,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('13.0.0-next.3');
+    const VERSION$2 = new Version('13.0.0-next.7');
 
     /**
      * @license
@@ -21294,6 +21280,15 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
          * ```
          */
         ErrorCode[ErrorCode["INVALID_BANANA_IN_BOX"] = 8101] = "INVALID_BANANA_IN_BOX";
+        /**
+         * The left side of a nullish coalescing operation is not nullable.
+         *
+         * ```
+         * {{ foo ?? bar }}
+         * ```
+         * When the type of foo doesn't include `null` or `undefined`.
+         */
+        ErrorCode[ErrorCode["NULLISH_COALESCING_NOT_NULLABLE"] = 8102] = "NULLISH_COALESCING_NOT_NULLABLE";
         /**
          * The template type-checking engine would need to generate an inline type check block for a
          * component, but the current type-checking environment doesn't support it.
@@ -23210,11 +23205,11 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         getAdjacentNameOfClass(clazz) {
             return clazz.name;
         }
-        isStaticallyExported(clazz) {
-            // First check if there's an `export` modifier directly on the class declaration.
-            let topLevel = clazz;
-            if (ts$1.isVariableDeclaration(clazz) && ts$1.isVariableDeclarationList(clazz.parent)) {
-                topLevel = clazz.parent.parent;
+        isStaticallyExported(decl) {
+            // First check if there's an `export` modifier directly on the declaration.
+            let topLevel = decl;
+            if (ts$1.isVariableDeclaration(decl) && ts$1.isVariableDeclarationList(decl.parent)) {
+                topLevel = decl.parent.parent;
             }
             if (topLevel.modifiers !== undefined &&
                 topLevel.modifiers.some(modifier => modifier.kind === ts$1.SyntaxKind.ExportKeyword)) {
@@ -23233,8 +23228,8 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             if (topLevel.parent === undefined || !ts$1.isSourceFile(topLevel.parent)) {
                 return false;
             }
-            const localExports = this.getLocalExportedClassesOfSourceFile(clazz.getSourceFile());
-            return localExports.has(clazz);
+            const localExports = this.getLocalExportedDeclarationsOfSourceFile(decl.getSourceFile());
+            return localExports.has(decl);
         }
         getDirectImportOfIdentifier(id) {
             const symbol = this.checker.getSymbolAtLocation(id);
@@ -23437,16 +23432,16 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             };
         }
         /**
-         * Get the set of classes declared in `file` which are exported.
+         * Get the set of declarations declared in `file` which are exported.
          */
-        getLocalExportedClassesOfSourceFile(file) {
+        getLocalExportedDeclarationsOfSourceFile(file) {
             const cacheSf = file;
-            if (cacheSf[LocalExportedClasses] !== undefined) {
+            if (cacheSf[LocalExportedDeclarations] !== undefined) {
                 // TS does not currently narrow symbol-keyed fields, hence the non-null assert is needed.
-                return cacheSf[LocalExportedClasses];
+                return cacheSf[LocalExportedDeclarations];
             }
             const exportSet = new Set();
-            cacheSf[LocalExportedClasses] = exportSet;
+            cacheSf[LocalExportedDeclarations] = exportSet;
             const sfSymbol = this.checker.getSymbolAtLocation(cacheSf);
             if (sfSymbol === undefined || sfSymbol.exports === undefined) {
                 return exportSet;
@@ -23471,8 +23466,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
                     exportedSymbol = this.checker.getAliasedSymbol(exportedSymbol);
                 }
                 if (exportedSymbol.valueDeclaration !== undefined &&
-                    exportedSymbol.valueDeclaration.getSourceFile() === file &&
-                    this.isClass(exportedSymbol.valueDeclaration)) {
+                    exportedSymbol.valueDeclaration.getSourceFile() === file) {
                     exportSet.add(exportedSymbol.valueDeclaration);
                 }
                 item = iter.next();
@@ -23631,7 +23625,7 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             (decl.propertyName !== undefined ? decl.propertyName : decl.name).text :
             originalId.text;
     }
-    const LocalExportedClasses = Symbol('LocalExportedClasses');
+    const LocalExportedDeclarations = Symbol('LocalExportedDeclarations');
 
     /**
      * @license
@@ -26858,11 +26852,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
             const target = this.factory.createPropertyAccess(expr.receiver.visitExpression(this, context), expr.name);
             return this.factory.createAssignment(target, expr.value.visitExpression(this, context));
         }
-        visitInvokeMethodExpr(ast, context) {
-            const target = ast.receiver.visitExpression(this, context);
-            return this.setSourceMapRange(this.factory.createCallExpression(ast.name !== null ? this.factory.createPropertyAccess(target, ast.name) : target, ast.args.map(arg => arg.visitExpression(this, context)), 
-            /* pure */ false), ast.sourceSpan);
-        }
         visitInvokeFunctionExpr(ast, context) {
             return this.setSourceMapRange(this.factory.createCallExpression(ast.fn.visitExpression(this, context), ast.args.map(arg => arg.visitExpression(this, context)), ast.pure), ast.sourceSpan);
         }
@@ -27157,9 +27146,6 @@ define(['exports', 'typescript/lib/tsserverlibrary', 'os', 'typescript', 'fs', '
         visitWritePropExpr(expr, context) {
             throw new Error('Method not implemented.');
         }
-        visitInvokeMethodExpr(ast, context) {
-            throw new Error('Method not implemented.');
-        }
         visitInvokeFunctionExpr(ast, context) {
             throw new Error('Method not implemented.');
         }
@@ -32868,10 +32854,6 @@ Either add the @Injectable() decorator to '${provider.node.name
         visit(ast) {
             ast.visit(this);
         }
-        visitMethodCall(ast, context) {
-            this.visitIdentifier(ast, IdentifierKind.Method);
-            super.visitMethodCall(ast, context);
-        }
         visitPropertyRead(ast, context) {
             this.visitIdentifier(ast, IdentifierKind.Property);
             super.visitPropertyRead(ast, context);
@@ -34992,15 +34974,14 @@ Either add the @Injectable() decorator to '${provider.node.name
             }
             // Completion works inside property reads and method calls.
             let tsExpr = null;
-            if (expr instanceof PropertyRead || expr instanceof MethodCall ||
-                expr instanceof PropertyWrite) {
+            if (expr instanceof PropertyRead || expr instanceof PropertyWrite) {
                 // Non-safe navigation operations are trivial: `foo.bar` or `foo.bar()`
                 tsExpr = findFirstMatchingNode(this.tcb, {
                     filter: ts$1.isPropertyAccessExpression,
                     withSpan: expr.nameSpan,
                 });
             }
-            else if (expr instanceof SafePropertyRead || expr instanceof SafeMethodCall) {
+            else if (expr instanceof SafePropertyRead) {
                 // Safe navigation operations are a little more complex, and involve a ternary. Completion
                 // happens in the "true" case of the ternary.
                 const ternaryExpr = findFirstMatchingNode(this.tcb, {
@@ -35011,11 +34992,10 @@ Either add the @Injectable() decorator to '${provider.node.name
                     return null;
                 }
                 const whenTrue = ternaryExpr.expression.whenTrue;
-                if (expr instanceof SafePropertyRead && ts$1.isPropertyAccessExpression(whenTrue)) {
+                if (ts$1.isPropertyAccessExpression(whenTrue)) {
                     tsExpr = whenTrue;
                 }
-                else if (expr instanceof SafeMethodCall && ts$1.isCallExpression(whenTrue) &&
-                    ts$1.isPropertyAccessExpression(whenTrue.expression)) {
+                else if (ts$1.isCallExpression(whenTrue) && ts$1.isPropertyAccessExpression(whenTrue.expression)) {
                     tsExpr = whenTrue.expression;
                 }
             }
@@ -35524,15 +35504,20 @@ Either add the @Injectable() decorator to '${provider.node.name
                     resolutionContext: type.getSourceFile().fileName,
                 };
             }
-            // If no owning module is known, the reference needs to be exported to be able to emit an import
+            // The declaration needs to be exported as a top-level export to be able to emit an import
             // statement for it. If the declaration is not exported, null is returned to prevent emit.
-            if (owningModule === null && !this.isStaticallyExported(declaration.node)) {
+            if (!this.isTopLevelExport(declaration.node)) {
                 return null;
             }
             return new Reference$1(declaration.node, owningModule);
         }
-        isStaticallyExported(decl) {
-            return isNamedClassDeclaration(decl) && this.reflector.isStaticallyExported(decl);
+        isTopLevelExport(decl) {
+            if (decl.parent === undefined || !ts$1.isSourceFile(decl.parent)) {
+                // The declaration has to exist at the top-level, as the reference emitters are not capable of
+                // generating imports to classes declared in a namespace.
+                return false;
+            }
+            return this.reflector.isStaticallyExported(decl);
         }
         isLocalTypeParameter(decl) {
             // Checking for local type parameters only occurs during resolution of type parameters, so it is
@@ -36414,13 +36399,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             addParseSpanInfo(node, ast.sourceSpan);
             return node;
         }
-        visitFunctionCall(ast) {
-            const receiver = wrapForDiagnostics(this.translate(ast.target));
-            const args = ast.args.map(expr => this.translate(expr));
-            const node = ts$1.createCall(receiver, undefined, args);
-            addParseSpanInfo(node, ast.sourceSpan);
-            return node;
-        }
         visitImplicitReceiver(ast) {
             throw new Error('Method not implemented.');
         }
@@ -36483,15 +36461,6 @@ Either add the @Injectable() decorator to '${provider.node.name
             addParseSpanInfo(node, ast.sourceSpan);
             return node;
         }
-        visitMethodCall(ast) {
-            const receiver = wrapForDiagnostics(this.translate(ast.receiver));
-            const method = ts$1.createPropertyAccess(receiver, ast.name);
-            addParseSpanInfo(method, ast.nameSpan);
-            const args = ast.args.map(expr => this.translate(expr));
-            const node = ts$1.createCall(method, undefined, args);
-            addParseSpanInfo(node, ast.sourceSpan);
-            return node;
-        }
         visitNonNullAssert(ast) {
             const expr = wrapForDiagnostics(this.translate(ast.expression));
             const node = ts$1.createNonNullExpression(expr);
@@ -36541,33 +36510,6 @@ Either add the @Injectable() decorator to '${provider.node.name
         visitQuote(ast) {
             return NULL_AS_ANY;
         }
-        visitSafeMethodCall(ast) {
-            // See the comments in SafePropertyRead above for an explanation of the cases here.
-            let node;
-            const receiver = wrapForDiagnostics(this.translate(ast.receiver));
-            const args = ast.args.map(expr => this.translate(expr));
-            if (this.config.strictSafeNavigationTypes) {
-                // "a?.method(...)" becomes (null as any ? a!.method(...) : undefined)
-                const method = ts$1.createPropertyAccess(ts$1.createNonNullExpression(receiver), ast.name);
-                addParseSpanInfo(method, ast.nameSpan);
-                const call = ts$1.createCall(method, undefined, args);
-                node = ts$1.createParen(ts$1.createConditional(NULL_AS_ANY, call, UNDEFINED));
-            }
-            else if (VeSafeLhsInferenceBugDetector.veWillInferAnyFor(ast)) {
-                // "a?.method(...)" becomes (a as any).method(...)
-                const method = ts$1.createPropertyAccess(tsCastToAny(receiver), ast.name);
-                addParseSpanInfo(method, ast.nameSpan);
-                node = ts$1.createCall(method, undefined, args);
-            }
-            else {
-                // "a?.method(...)" becomes (a!.method(...) as any)
-                const method = ts$1.createPropertyAccess(ts$1.createNonNullExpression(receiver), ast.name);
-                addParseSpanInfo(method, ast.nameSpan);
-                node = tsCastToAny(ts$1.createCall(method, undefined, args));
-            }
-            addParseSpanInfo(node, ast.sourceSpan);
-            return node;
-        }
         visitSafePropertyRead(ast) {
             let node;
             const receiver = wrapForDiagnostics(this.translate(ast.receiver));
@@ -36624,6 +36566,33 @@ Either add the @Injectable() decorator to '${provider.node.name
             addParseSpanInfo(node, ast.sourceSpan);
             return node;
         }
+        visitCall(ast) {
+            const args = ast.args.map(expr => this.translate(expr));
+            const expr = wrapForDiagnostics(this.translate(ast.receiver));
+            let node;
+            // Safe property/keyed reads will produce a ternary whose value is nullable.
+            // We have to generate a similar ternary around the call.
+            if (ast.receiver instanceof SafePropertyRead || ast.receiver instanceof SafeKeyedRead) {
+                if (this.config.strictSafeNavigationTypes) {
+                    // "a?.method(...)" becomes (null as any ? a!.method(...) : undefined)
+                    const call = ts$1.createCall(ts$1.createNonNullExpression(expr), undefined, args);
+                    node = ts$1.createParen(ts$1.createConditional(NULL_AS_ANY, call, UNDEFINED));
+                }
+                else if (VeSafeLhsInferenceBugDetector.veWillInferAnyFor(ast)) {
+                    // "a?.method(...)" becomes (a as any).method(...)
+                    node = ts$1.createCall(tsCastToAny(expr), undefined, args);
+                }
+                else {
+                    // "a?.method(...)" becomes (a!.method(...) as any)
+                    node = tsCastToAny(ts$1.createCall(ts$1.createNonNullExpression(expr), undefined, args));
+                }
+            }
+            else {
+                node = ts$1.createCall(expr, undefined, args);
+            }
+            addParseSpanInfo(node, ast.sourceSpan);
+            return node;
+        }
     }
     /**
      * Checks whether View Engine will infer a type of 'any' for the left-hand side of a safe navigation
@@ -36641,7 +36610,7 @@ Either add the @Injectable() decorator to '${provider.node.name
     class VeSafeLhsInferenceBugDetector {
         static veWillInferAnyFor(ast) {
             const visitor = VeSafeLhsInferenceBugDetector.SINGLETON;
-            return ast instanceof SafeKeyedRead ? ast.receiver.visit(visitor) : ast.receiver.visit(visitor);
+            return ast instanceof Call ? ast.visit(visitor) : ast.receiver.visit(visitor);
         }
         visitUnary(ast) {
             return ast.expr.visit(this);
@@ -36655,7 +36624,7 @@ Either add the @Injectable() decorator to '${provider.node.name
         visitConditional(ast) {
             return ast.condition.visit(this) || ast.trueExp.visit(this) || ast.falseExp.visit(this);
         }
-        visitFunctionCall(ast) {
+        visitCall(ast) {
             return true;
         }
         visitImplicitReceiver(ast) {
@@ -36682,9 +36651,6 @@ Either add the @Injectable() decorator to '${provider.node.name
         visitLiteralPrimitive(ast) {
             return false;
         }
-        visitMethodCall(ast) {
-            return true;
-        }
         visitPipe(ast) {
             return true;
         }
@@ -36703,9 +36669,6 @@ Either add the @Injectable() decorator to '${provider.node.name
         visitQuote(ast) {
             return false;
         }
-        visitSafeMethodCall(ast) {
-            return true;
-        }
         visitSafePropertyRead(ast) {
             return false;
         }
@@ -38287,15 +38250,15 @@ Either add the @Injectable() decorator to '${provider.node.name
             else if (ast instanceof ImplicitReceiver) {
                 // AST instances representing variables and references look very similar to property reads
                 // or method calls from the component context: both have the shape
-                // PropertyRead(ImplicitReceiver, 'propName') or MethodCall(ImplicitReceiver, 'methodName').
+                // PropertyRead(ImplicitReceiver, 'propName') or Call(ImplicitReceiver, 'methodName').
                 //
-                // `translate` will first try to `resolve` the outer PropertyRead/MethodCall. If this works,
+                // `translate` will first try to `resolve` the outer PropertyRead/Call. If this works,
                 // it's because the `BoundTarget` found an expression target for the whole expression, and
                 // therefore `translate` will never attempt to `resolve` the ImplicitReceiver of that
-                // PropertyRead/MethodCall.
+                // PropertyRead/Call.
                 //
                 // Therefore if `resolve` is called on an `ImplicitReceiver`, it's because no outer
-                // PropertyRead/MethodCall resolved to a variable or reference, and therefore this is a
+                // PropertyRead/Call resolved to a variable or reference, and therefore this is a
                 // property read or method call on the component context itself.
                 return ts$1.createIdentifier('ctx');
             }
@@ -38326,11 +38289,12 @@ Either add the @Injectable() decorator to '${provider.node.name
                 addParseSpanInfo(result, ast.sourceSpan);
                 return result;
             }
-            else if (ast instanceof MethodCall && ast.receiver instanceof ImplicitReceiver &&
-                !(ast.receiver instanceof ThisReceiver)) {
+            else if (ast instanceof Call &&
+                (ast.receiver instanceof PropertyRead || ast.receiver instanceof SafePropertyRead) &&
+                !(ast.receiver.receiver instanceof ThisReceiver)) {
                 // Resolve the special `$any(expr)` syntax to insert a cast of the argument to type `any`.
                 // `$any(expr)` -> `expr as any`
-                if (ast.name === '$any' && ast.args.length === 1) {
+                if (ast.receiver.name === '$any' && ast.args.length === 1) {
                     const expr = this.translate(ast.args[0]);
                     const exprAsAny = ts$1.createAsExpression(expr, ts$1.createKeywordTypeNode(ts$1.SyntaxKind.AnyKeyword));
                     const result = ts$1.createParen(exprAsAny);
@@ -38346,7 +38310,7 @@ Either add the @Injectable() decorator to '${provider.node.name
                     return null;
                 }
                 const method = wrapForDiagnostics(receiver);
-                addParseSpanInfo(method, ast.nameSpan);
+                addParseSpanInfo(method, ast.receiver.nameSpan);
                 const args = ast.args.map(arg => this.translate(arg));
                 const node = ts$1.createCall(method, undefined, args);
                 addParseSpanInfo(node, ast.sourceSpan);
@@ -39471,11 +39435,15 @@ Either add the @Injectable() decorator to '${provider.node.name
             if (expressionTarget !== null) {
                 return this.getSymbol(expressionTarget);
             }
-            // The `name` part of a `PropertyWrite` and `MethodCall` does not have its own
+            let withSpan = expression.sourceSpan;
+            // The `name` part of a `PropertyWrite` and a non-safe `Call` does not have its own
             // AST so there is no way to retrieve a `Symbol` for just the `name` via a specific node.
-            const withSpan = (expression instanceof PropertyWrite || expression instanceof MethodCall) ?
-                expression.nameSpan :
-                expression.sourceSpan;
+            if (expression instanceof PropertyWrite) {
+                withSpan = expression.nameSpan;
+            }
+            else if (expression instanceof Call && expression.receiver instanceof PropertyRead) {
+                withSpan = expression.receiver.nameSpan;
+            }
             let node = null;
             // Property reads in templates usually map to a `PropertyAccessExpression`
             // (e.g. `ctx.foo`) so try looking for one first.
@@ -39497,9 +39465,10 @@ Either add the @Injectable() decorator to '${provider.node.name
             // - If our expression is a pipe binding ("a | test:b:c"), we want the Symbol for the
             // `transform` on the pipe.
             // - Otherwise, we retrieve the symbol for the node itself with no special considerations
-            if ((expression instanceof SafePropertyRead || expression instanceof SafeMethodCall) &&
+            if ((expression instanceof SafePropertyRead ||
+                (expression instanceof Call && expression.receiver instanceof SafePropertyRead)) &&
                 ts$1.isConditionalExpression(node)) {
-                const whenTrueSymbol = (expression instanceof SafeMethodCall && ts$1.isCallExpression(node.whenTrue)) ?
+                const whenTrueSymbol = (expression instanceof Call && ts$1.isCallExpression(node.whenTrue)) ?
                     this.getSymbolOfTsNode(node.whenTrue.expression) :
                     this.getSymbolOfTsNode(node.whenTrue);
                 if (whenTrueSymbol === null) {
@@ -40165,12 +40134,11 @@ Either add the @Injectable() decorator to '${provider.node.name
      */
     class ExtendedTemplateCheckerImpl {
         constructor(templateTypeChecker, typeChecker, templateChecks) {
-            this.templateTypeChecker = templateTypeChecker;
-            this.typeChecker = typeChecker;
             this.templateChecks = templateChecks;
+            this.ctx = { templateTypeChecker: templateTypeChecker, typeChecker: typeChecker };
         }
         getDiagnosticsForComponent(component) {
-            const template = this.templateTypeChecker.getTemplate(component);
+            const template = this.ctx.templateTypeChecker.getTemplate(component);
             // Skip checks if component has no template. This can happen if the user writes a
             // `@Component()` but doesn't add the template, could happen in the language service
             // when users are in the middle of typing code.
@@ -40178,66 +40146,100 @@ Either add the @Injectable() decorator to '${provider.node.name
                 return [];
             }
             const diagnostics = [];
-            const ctx = {
-                templateTypeChecker: this.templateTypeChecker,
-                typeChecker: this.typeChecker,
-                component
-            };
             for (const check of this.templateChecks) {
-                diagnostics.push(...deduplicateDiagnostics(check.run(ctx, template)));
+                diagnostics.push(...check.run(this.ctx, component, template));
             }
             return diagnostics;
         }
     }
-    // Filter out duplicated diagnostics, this is possible due to the way the compiler
-    // handles desugaring and produces `AST`s. Ex.
-    //
-    // ```
-    // <div *ngIf="true" (foo)="bar">test</div>
-    // ```
-    //
-    // Would result in the following AST:
-    //
-    // ```
-    // Template {
-    //   outputs: [
-    //    BoundEvent {
-    //      name: 'foo',
-    //      /.../
-    //    }
-    //   ],
-    //   children: [
-    //     Element {
-    //       outputs: [
-    //         BoundEvent {
-    //           name: 'foo',
-    //           /.../
-    //         }
-    //       ]
-    //     }
-    //   ],
-    //   /.../
-    // }
-    // ```
-    //
-    // In this case a duplicated diagnostic could be generated for the output `foo`.
-    // TODO(danieltrevino): handle duplicated diagnostics when they are being generated
-    // to avoid extra work (could be directly in the visitor).
-    // https://github.com/angular/angular/pull/42984#discussion_r684823926
-    function deduplicateDiagnostics(diagnostics) {
-        const result = [];
-        for (const newDiag of diagnostics) {
-            const isDuplicateDiag = result.some(existingDiag => areDiagnosticsEqual(newDiag, existingDiag));
-            if (!isDuplicateDiag) {
-                result.push(newDiag);
-            }
+
+    /**
+     * @license
+     * Copyright Google LLC All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    /**
+     * This abstract class provides a base implementation for the run method.
+     */
+    class TemplateCheckWithVisitor {
+        /**
+         * Base implementation for run function, visits all nodes in template and calls
+         * `visitNode()` for each one.
+         */
+        run(ctx, component, template) {
+            const visitor = new TemplateVisitor$1(ctx, component, this);
+            return visitor.getDiagnostics(template);
         }
-        return result;
     }
-    function areDiagnosticsEqual(first, second) {
-        var _a, _b;
-        return ((_a = first.file) === null || _a === void 0 ? void 0 : _a.fileName) === ((_b = second.file) === null || _b === void 0 ? void 0 : _b.fileName) && first.start === second.start &&
-            first.length === second.length && first.code === second.code;
+    /**
+     * Visits all nodes in a template (TmplAstNode and AST) and calls `visitNode` for each one.
+     */
+    class TemplateVisitor$1 extends RecursiveAstVisitor {
+        constructor(ctx, component, check) {
+            super();
+            this.ctx = ctx;
+            this.component = component;
+            this.check = check;
+            this.diagnostics = [];
+        }
+        visit(node, context) {
+            this.diagnostics.push(...this.check.visitNode(this.ctx, this.component, node));
+            node.visit(this);
+        }
+        visitAllNodes(nodes) {
+            for (const node of nodes) {
+                this.visit(node);
+            }
+        }
+        visitAst(ast) {
+            if (ast instanceof ASTWithSource) {
+                ast = ast.ast;
+            }
+            this.visit(ast);
+        }
+        visitElement(element) {
+            this.visitAllNodes(element.attributes);
+            this.visitAllNodes(element.inputs);
+            this.visitAllNodes(element.outputs);
+            this.visitAllNodes(element.references);
+            this.visitAllNodes(element.children);
+        }
+        visitTemplate(template) {
+            this.visitAllNodes(template.attributes);
+            if (template.tagName === 'ng-template') {
+                // Only visit input/outputs/templateAttrs if this isn't an inline template node
+                // generated for a structural directive (like `<div *ngIf></div>`). These nodes
+                // would be visited when the underlying element of an inline template node is processed.
+                this.visitAllNodes(template.inputs);
+                this.visitAllNodes(template.outputs);
+                this.visitAllNodes(template.templateAttrs);
+            }
+            this.visitAllNodes(template.variables);
+            this.visitAllNodes(template.references);
+            this.visitAllNodes(template.children);
+        }
+        visitContent(content) { }
+        visitVariable(variable) { }
+        visitReference(reference) { }
+        visitTextAttribute(attribute) { }
+        visitBoundAttribute(attribute) {
+            this.visitAst(attribute.value);
+        }
+        visitBoundEvent(attribute) {
+            this.visitAst(attribute.handler);
+        }
+        visitText(text) { }
+        visitBoundText(text) {
+            this.visitAst(text.value);
+        }
+        visitIcu(icu) { }
+        getDiagnostics(template) {
+            this.diagnostics = [];
+            this.visitAllNodes(template);
+            return this.diagnostics;
+        }
     }
 
     /**
@@ -40252,42 +40254,63 @@ Either add the @Injectable() decorator to '${provider.node.name
      * Parentheses should be inside the brackets "[()]".
      * Will return diagnostic information when "([])" is found.
      */
-    class InvalidBananaInBoxCheck {
+    class InvalidBananaInBoxCheck extends TemplateCheckWithVisitor {
         constructor() {
-            this.code = 8101;
+            super(...arguments);
+            this.code = ErrorCode.INVALID_BANANA_IN_BOX;
         }
-        run(ctx, template) {
-            const visitor = new BananaVisitor(ctx);
-            return visitor.getDiagnostics(template);
+        visitNode(ctx, component, node) {
+            if (!(node instanceof BoundEvent))
+                return [];
+            const name = node.name;
+            if (!name.startsWith('[') || !name.endsWith(']'))
+                return [];
+            const boundSyntax = node.sourceSpan.toString();
+            const expectedBoundSyntax = boundSyntax.replace(`(${name})`, `[(${name.slice(1, -1)})]`);
+            const diagnostic = ctx.templateTypeChecker.makeTemplateDiagnostic(component, node.sourceSpan, ts$1.DiagnosticCategory.Warning, ErrorCode.INVALID_BANANA_IN_BOX, `In the two-way binding syntax the parentheses should be inside the brackets, ex. '${expectedBoundSyntax}'. 
+        Find more at https://angular.io/guide/two-way-binding`);
+            return [diagnostic];
         }
     }
-    class BananaVisitor extends RecursiveVisitor {
-        constructor(ctx) {
-            super();
-            this.ctx = ctx;
-            this.diagnostics = [];
+
+    /**
+     * @license
+     * Copyright Google LLC All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    /**
+     * Ensures the left side of a nullish coalescing operation is nullable.
+     * Returns diagnostics for the cases where the operator is useless.
+     * This check should only be use if `strictNullChecks` is enabled,
+     * otherwise it would produce inaccurate results.
+     */
+    class NullishCoalescingNotNullableCheck extends TemplateCheckWithVisitor {
+        constructor() {
+            super(...arguments);
+            this.code = ErrorCode.NULLISH_COALESCING_NOT_NULLABLE;
         }
-        /**
-         * Check for outputs with names surrounded in brackets "[]".
-         * The syntax '([foo])="bar"' would be interpreted as an @Output()
-         * with name '[foo]'. Just like '(foo)="bar"' would have the name 'foo'.
-         * Generate diagnostic information for the cases found.
-         */
-        visitBoundEvent(boundEvent) {
-            const name = boundEvent.name;
-            if (name.startsWith('[') && name.endsWith(']')) {
-                const boundSyntax = boundEvent.sourceSpan.toString();
-                const expectedBoundSyntax = boundSyntax.replace(`(${name})`, `[(${name.slice(1, -1)})]`);
-                this.diagnostics.push(this.ctx.templateTypeChecker.makeTemplateDiagnostic(this.ctx.component, boundEvent.sourceSpan, ts$1.DiagnosticCategory.Warning, ErrorCode.INVALID_BANANA_IN_BOX, `In the two-way binding syntax the parentheses should be inside the brackets, ex. '${expectedBoundSyntax}'. 
-                Find more at https://angular.io/guide/two-way-binding`));
+        visitNode(ctx, component, node) {
+            if (!(node instanceof Binary) || node.operation !== '??')
+                return [];
+            const symbolLeft = ctx.templateTypeChecker.getSymbolOfNode(node.left, component);
+            if (symbolLeft === null || symbolLeft.kind !== SymbolKind.Expression) {
+                return [];
             }
-        }
-        getDiagnostics(template) {
-            this.diagnostics = [];
-            for (const node of template) {
-                node.visit(this);
+            const typeLeft = symbolLeft.tsType;
+            // If the left operand's type is different from its non-nullable self, then it must
+            // contain a null or undefined so this nullish coalescing operator is useful. No diagnostic to
+            // report.
+            if (typeLeft.getNonNullableType() !== typeLeft)
+                return [];
+            const symbol = ctx.templateTypeChecker.getSymbolOfNode(node, component);
+            if (symbol.kind !== SymbolKind.Expression) {
+                return [];
             }
-            return this.diagnostics;
+            const span = ctx.templateTypeChecker.getTemplateMappingAtShimLocation(symbol.shimLocation).span;
+            const diagnostic = ctx.templateTypeChecker.makeTemplateDiagnostic(component, span, ts$1.DiagnosticCategory.Warning, ErrorCode.NULLISH_COALESCING_NOT_NULLABLE, `The left side of this nullish coalescing operation does not include 'null' or 'undefined' in its type, therefore the '??' operator can be safely removed.`);
+            return [diagnostic];
         }
     }
 
@@ -41074,6 +41097,9 @@ Either add the @Injectable() decorator to '${provider.node.name
             });
             const templateTypeChecker = new TemplateTypeCheckerImpl(this.inputProgram, notifyingDriver, traitCompiler, this.getTypeCheckingConfig(), refEmitter, reflector, this.adapter, this.incrementalCompilation, scopeRegistry, typeCheckScopeRegistry, this.delegatingPerfRecorder);
             const templateChecks = [new InvalidBananaInBoxCheck()];
+            if (this.options.strictNullChecks) {
+                templateChecks.push(new NullishCoalescingNotNullableCheck());
+            }
             const extendedTemplateChecker = new ExtendedTemplateCheckerImpl(templateTypeChecker, checker, templateChecks);
             return {
                 isCore,
@@ -41591,11 +41617,10 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         if (isTemplateNodeWithKeyAndValue(node)) {
             return toTextSpan(node.keySpan);
         }
-        else if (node instanceof PropertyWrite || node instanceof MethodCall ||
-            node instanceof BindingPipe || node instanceof PropertyRead) {
-            // The `name` part of a `PropertyWrite`, `MethodCall`, and `BindingPipe` does not
-            // have its own AST so there is no way to retrieve a `Symbol` for just the `name` via a specific
-            // node.
+        else if (node instanceof PropertyWrite || node instanceof BindingPipe ||
+            node instanceof PropertyRead) {
+            // The `name` part of a `PropertyWrite` and `BindingPipe` does not have its own AST
+            // so there is no way to retrieve a `Symbol` for just the `name` via a specific node.
             return toTextSpan(node.nameSpan);
         }
         else {
@@ -42498,7 +42523,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
     var TargetNodeKind;
     (function (TargetNodeKind) {
         TargetNodeKind[TargetNodeKind["RawExpression"] = 0] = "RawExpression";
-        TargetNodeKind[TargetNodeKind["MethodCallExpressionInArgContext"] = 1] = "MethodCallExpressionInArgContext";
+        TargetNodeKind[TargetNodeKind["CallExpressionInArgContext"] = 1] = "CallExpressionInArgContext";
         TargetNodeKind[TargetNodeKind["RawTemplateNode"] = 2] = "RawTemplateNode";
         TargetNodeKind[TargetNodeKind["ElementInTagContext"] = 3] = "ElementInTagContext";
         TargetNodeKind[TargetNodeKind["ElementInBodyContext"] = 4] = "ElementInBodyContext";
@@ -42544,10 +42569,9 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         }
         // Given the candidate node, determine the full targeted context.
         let nodeInContext;
-        if ((candidate instanceof MethodCall || candidate instanceof SafeMethodCall) &&
-            isWithin(position, candidate.argumentSpan)) {
+        if (candidate instanceof Call && isWithin(position, candidate.argumentSpan)) {
             nodeInContext = {
-                kind: TargetNodeKind.MethodCallExpressionInArgContext,
+                kind: TargetNodeKind.CallExpressionInArgContext,
                 node: candidate,
             };
         }
@@ -42950,8 +42974,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
          * expressions.
          */
         isPropertyExpressionCompletion() {
-            return this.node instanceof PropertyRead || this.node instanceof MethodCall ||
-                this.node instanceof SafePropertyRead || this.node instanceof SafeMethodCall ||
+            return this.node instanceof PropertyRead || this.node instanceof SafePropertyRead ||
                 this.node instanceof PropertyWrite || this.node instanceof EmptyExpr ||
                 // BoundEvent nodes only count as property completions if in an EventValue context.
                 (this.node instanceof BoundEvent && this.nodeContext === CompletionNodeContext.EventValue);
@@ -42975,7 +42998,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                 }
                 const replacementSpan = makeReplacementSpanFromAst(this.node);
                 if (!(this.node.receiver instanceof ImplicitReceiver) &&
-                    (options === null || options === void 0 ? void 0 : options.includeCompletionsWithInsertText) &&
+                    !(this.node instanceof SafePropertyRead) && (options === null || options === void 0 ? void 0 : options.includeCompletionsWithInsertText) &&
                     options.includeAutomaticOptionalChainCompletions !== false) {
                     const symbol = this.templateTypeChecker.getSymbolOfNode(this.node.receiver, this.component);
                     if ((symbol === null || symbol === void 0 ? void 0 : symbol.kind) === SymbolKind.Expression) {
@@ -43705,9 +43728,8 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
                 return { text: node.valueSpan.toString(), span: toTextSpan(node.valueSpan) };
             }
         }
-        if (node instanceof PropertyRead || node instanceof MethodCall || node instanceof PropertyWrite ||
-            node instanceof SafePropertyRead || node instanceof SafeMethodCall ||
-            node instanceof BindingPipe) {
+        if (node instanceof PropertyRead || node instanceof PropertyWrite ||
+            node instanceof SafePropertyRead || node instanceof BindingPipe) {
             return { text: node.name, span: toTextSpan(node.nameSpan) };
         }
         else if (node instanceof LiteralPrimitive) {
@@ -44046,19 +44068,27 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
      * found in the LICENSE file at https://angular.io/license
      */
     class QuickInfoBuilder {
-        constructor(tsLS, compiler, component, node) {
+        constructor(tsLS, compiler, component, node, parent) {
             this.tsLS = tsLS;
             this.compiler = compiler;
             this.component = component;
             this.node = node;
+            this.parent = parent;
             this.typeChecker = this.compiler.getCurrentProgram().getTypeChecker();
         }
         get() {
             const symbol = this.compiler.getTemplateTypeChecker().getSymbolOfNode(this.node, this.component);
-            if (symbol === null) {
-                return isDollarAny(this.node) ? createDollarAnyQuickInfo(this.node) : undefined;
+            if (symbol !== null) {
+                return this.getQuickInfoForSymbol(symbol);
+            }
+            if (isDollarAny(this.node)) {
+                return createDollarAnyQuickInfo(this.node);
+            }
+            // If the cursor lands on the receiver of a method call, we have to look
+            // at the entire call in order to figure out if it's a call to `$any`.
+            if (this.parent !== null && isDollarAny(this.parent) && this.parent.receiver === this.node) {
+                return createDollarAnyQuickInfo(this.parent);
             }
-            return this.getQuickInfoForSymbol(symbol);
         }
         getQuickInfoForSymbol(symbol) {
             switch (symbol.kind) {
@@ -44181,11 +44211,13 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         return a.text === b.text && a.kind === b.kind;
     }
     function isDollarAny(node) {
-        return node instanceof MethodCall && node.receiver instanceof ImplicitReceiver &&
-            !(node.receiver instanceof ThisReceiver) && node.name === '$any' && node.args.length === 1;
+        return node instanceof Call && node.receiver instanceof PropertyRead &&
+            node.receiver.receiver instanceof ImplicitReceiver &&
+            !(node.receiver.receiver instanceof ThisReceiver) && node.receiver.name === '$any' &&
+            node.args.length === 1;
     }
     function createDollarAnyQuickInfo(node) {
-        return createQuickInfo('$any', DisplayInfoKind.METHOD, getTextSpanOfNode(node), 
+        return createQuickInfo('$any', DisplayInfoKind.METHOD, getTextSpanOfNode(node.receiver), 
         /** containerName */ undefined, 'any', [{
                 kind: SYMBOL_TEXT,
                 text: 'function to cast an expression to the `any` type',
@@ -44560,7 +44592,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             return undefined;
         }
         if (targetInfo.context.kind !== TargetNodeKind.RawExpression &&
-            targetInfo.context.kind !== TargetNodeKind.MethodCallExpressionInArgContext) {
+            targetInfo.context.kind !== TargetNodeKind.CallExpressionInArgContext) {
             // Signature completions are only available in expressions.
             return undefined;
         }
@@ -44569,38 +44601,37 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             return undefined;
         }
         // Determine a shim position to use in the request to the TypeScript Language Service.
-        // Additionally, extract the `MethodCall` or `SafeMethodCall` node for which signature help is
-        // being queried, as this is needed to construct the correct span for the results later.
+        // Additionally, extract the `Call` node for which signature help is being queried, as this
+        // is needed to construct the correct span for the results later.
         let shimPosition;
         let expr;
         switch (targetInfo.context.kind) {
             case TargetNodeKind.RawExpression:
                 // For normal expressions, just use the primary TCB position of the expression.
                 shimPosition = symbol.shimLocation.positionInShimFile;
-                // Walk up the parents of this expression and try to find a `MethodCall` or `SafeMethodCall`
-                // for which signature information is being fetched.
+                // Walk up the parents of this expression and try to find a
+                // `Call` for which signature information is being fetched.
                 let callExpr = null;
                 const parents = targetInfo.context.parents;
                 for (let i = parents.length - 1; i >= 0; i--) {
                     const parent = parents[i];
-                    if (parent instanceof MethodCall || parent instanceof SafeMethodCall) {
+                    if (parent instanceof Call) {
                         callExpr = parent;
                         break;
                     }
                 }
-                // If no MethodCall or SafeMethodCall node could be found, then this query cannot be safely
+                // If no Call node could be found, then this query cannot be safely
                 // answered as a correct span for the results will not be obtainable.
                 if (callExpr === null) {
                     return undefined;
                 }
                 expr = callExpr;
                 break;
-            case TargetNodeKind.MethodCallExpressionInArgContext:
-                // The `Symbol` points to a `MethodCall` or `SafeMethodCall` expression in the TCB (where it
-                // will be represented as a `ts.CallExpression`) *and* the template position was within the
-                // argument list of the method call. This happens when there was no narrower expression inside
-                // the argument list that matched the template position, such as when the call has no
-                // arguments: `foo(|)`.
+            case TargetNodeKind.CallExpressionInArgContext:
+                // The `Symbol` points to a `Call` expression in the TCB (where it will be represented as a
+                // `ts.CallExpression`) *and* the template position was within the argument list of the method
+                // call. This happens when there was no narrower expression inside the argument list that
+                // matched the template position, such as when the call has no arguments: `foo(|)`.
                 //
                 // The `Symbol`'s shim position is to the start of the call expression (`|foo()`) and
                 // therefore wouldn't return accurate signature help from the TS language service. For that, a
@@ -44636,8 +44667,7 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
         }
         // The TS language service results are almost returnable as-is. However, they contain an
         // `applicableSpan` which marks the entire argument list, and that span is in the context of the
-        // TCB's `ts.CallExpression`. It needs to be replaced with the span for the `MethodCall` (or
-        // `SafeMethodCall`) argument list.
+        // TCB's `ts.CallExpression`. It needs to be replaced with the span for the `Call` argument list.
         return Object.assign(Object.assign({}, res), { applicableSpan: {
                 start: expr.argumentSpan.start,
                 length: expr.argumentSpan.end - expr.argumentSpan.start,
@@ -44752,7 +44782,8 @@ https://v9.angular.io/guide/template-typecheck#template-type-checking`,
             const node = positionDetails.context.kind === TargetNodeKind.TwoWayBindingContext ?
                 positionDetails.context.nodes[0] :
                 positionDetails.context.node;
-            return new QuickInfoBuilder(this.tsLS, compiler, templateInfo.component, node).get();
+            return new QuickInfoBuilder(this.tsLS, compiler, templateInfo.component, node, positionDetails.parent)
+                .get();
         }
         getReferencesAtPosition(fileName, position) {
             return this.withCompilerAndPerfTracing(PerfPhase.LsReferencesAndRenames, (compiler) => {