source: trip-planner-front/node_modules/@angular/compiler/src/expression_parser/parser.js

Last change on this file was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 185.8 KB
Line 
1/**
2 * @license
3 * Copyright Google LLC All Rights Reserved.
4 *
5 * Use of this source code is governed by an MIT-style license that can be
6 * found in the LICENSE file at https://angular.io/license
7 */
8(function (factory) {
9 if (typeof module === "object" && typeof module.exports === "object") {
10 var v = factory(require, exports);
11 if (v !== undefined) module.exports = v;
12 }
13 else if (typeof define === "function" && define.amd) {
14 define("@angular/compiler/src/expression_parser/parser", ["require", "exports", "tslib", "@angular/compiler/src/chars", "@angular/compiler/src/ml_parser/interpolation_config", "@angular/compiler/src/expression_parser/ast", "@angular/compiler/src/expression_parser/lexer"], factory);
15 }
16})(function (require, exports) {
17 "use strict";
18 Object.defineProperty(exports, "__esModule", { value: true });
19 exports._ParseAST = exports.IvyParser = exports.Parser = exports.TemplateBindingParseResult = exports.SplitInterpolation = void 0;
20 var tslib_1 = require("tslib");
21 var chars = require("@angular/compiler/src/chars");
22 var interpolation_config_1 = require("@angular/compiler/src/ml_parser/interpolation_config");
23 var ast_1 = require("@angular/compiler/src/expression_parser/ast");
24 var lexer_1 = require("@angular/compiler/src/expression_parser/lexer");
25 var SplitInterpolation = /** @class */ (function () {
26 function SplitInterpolation(strings, expressions, offsets) {
27 this.strings = strings;
28 this.expressions = expressions;
29 this.offsets = offsets;
30 }
31 return SplitInterpolation;
32 }());
33 exports.SplitInterpolation = SplitInterpolation;
34 var TemplateBindingParseResult = /** @class */ (function () {
35 function TemplateBindingParseResult(templateBindings, warnings, errors) {
36 this.templateBindings = templateBindings;
37 this.warnings = warnings;
38 this.errors = errors;
39 }
40 return TemplateBindingParseResult;
41 }());
42 exports.TemplateBindingParseResult = TemplateBindingParseResult;
43 var Parser = /** @class */ (function () {
44 function Parser(_lexer) {
45 this._lexer = _lexer;
46 this.errors = [];
47 this.simpleExpressionChecker = SimpleExpressionChecker;
48 }
49 Parser.prototype.parseAction = function (input, location, absoluteOffset, interpolationConfig) {
50 if (interpolationConfig === void 0) { interpolationConfig = interpolation_config_1.DEFAULT_INTERPOLATION_CONFIG; }
51 this._checkNoInterpolation(input, location, interpolationConfig);
52 var sourceToLex = this._stripComments(input);
53 var tokens = this._lexer.tokenize(this._stripComments(input));
54 var ast = new _ParseAST(input, location, absoluteOffset, tokens, sourceToLex.length, true, this.errors, input.length - sourceToLex.length)
55 .parseChain();
56 return new ast_1.ASTWithSource(ast, input, location, absoluteOffset, this.errors);
57 };
58 Parser.prototype.parseBinding = function (input, location, absoluteOffset, interpolationConfig) {
59 if (interpolationConfig === void 0) { interpolationConfig = interpolation_config_1.DEFAULT_INTERPOLATION_CONFIG; }
60 var ast = this._parseBindingAst(input, location, absoluteOffset, interpolationConfig);
61 return new ast_1.ASTWithSource(ast, input, location, absoluteOffset, this.errors);
62 };
63 Parser.prototype.checkSimpleExpression = function (ast) {
64 var checker = new this.simpleExpressionChecker();
65 ast.visit(checker);
66 return checker.errors;
67 };
68 Parser.prototype.parseSimpleBinding = function (input, location, absoluteOffset, interpolationConfig) {
69 if (interpolationConfig === void 0) { interpolationConfig = interpolation_config_1.DEFAULT_INTERPOLATION_CONFIG; }
70 var ast = this._parseBindingAst(input, location, absoluteOffset, interpolationConfig);
71 var errors = this.checkSimpleExpression(ast);
72 if (errors.length > 0) {
73 this._reportError("Host binding expression cannot contain " + errors.join(' '), input, location);
74 }
75 return new ast_1.ASTWithSource(ast, input, location, absoluteOffset, this.errors);
76 };
77 Parser.prototype._reportError = function (message, input, errLocation, ctxLocation) {
78 this.errors.push(new ast_1.ParserError(message, input, errLocation, ctxLocation));
79 };
80 Parser.prototype._parseBindingAst = function (input, location, absoluteOffset, interpolationConfig) {
81 // Quotes expressions use 3rd-party expression language. We don't want to use
82 // our lexer or parser for that, so we check for that ahead of time.
83 var quote = this._parseQuote(input, location, absoluteOffset);
84 if (quote != null) {
85 return quote;
86 }
87 this._checkNoInterpolation(input, location, interpolationConfig);
88 var sourceToLex = this._stripComments(input);
89 var tokens = this._lexer.tokenize(sourceToLex);
90 return new _ParseAST(input, location, absoluteOffset, tokens, sourceToLex.length, false, this.errors, input.length - sourceToLex.length)
91 .parseChain();
92 };
93 Parser.prototype._parseQuote = function (input, location, absoluteOffset) {
94 if (input == null)
95 return null;
96 var prefixSeparatorIndex = input.indexOf(':');
97 if (prefixSeparatorIndex == -1)
98 return null;
99 var prefix = input.substring(0, prefixSeparatorIndex).trim();
100 if (!lexer_1.isIdentifier(prefix))
101 return null;
102 var uninterpretedExpression = input.substring(prefixSeparatorIndex + 1);
103 var span = new ast_1.ParseSpan(0, input.length);
104 return new ast_1.Quote(span, span.toAbsolute(absoluteOffset), prefix, uninterpretedExpression, location);
105 };
106 /**
107 * Parse microsyntax template expression and return a list of bindings or
108 * parsing errors in case the given expression is invalid.
109 *
110 * For example,
111 * ```
112 * <div *ngFor="let item of items">
113 * ^ ^ absoluteValueOffset for `templateValue`
114 * absoluteKeyOffset for `templateKey`
115 * ```
116 * contains three bindings:
117 * 1. ngFor -> null
118 * 2. item -> NgForOfContext.$implicit
119 * 3. ngForOf -> items
120 *
121 * This is apparent from the de-sugared template:
122 * ```
123 * <ng-template ngFor let-item [ngForOf]="items">
124 * ```
125 *
126 * @param templateKey name of directive, without the * prefix. For example: ngIf, ngFor
127 * @param templateValue RHS of the microsyntax attribute
128 * @param templateUrl template filename if it's external, component filename if it's inline
129 * @param absoluteKeyOffset start of the `templateKey`
130 * @param absoluteValueOffset start of the `templateValue`
131 */
132 Parser.prototype.parseTemplateBindings = function (templateKey, templateValue, templateUrl, absoluteKeyOffset, absoluteValueOffset) {
133 var tokens = this._lexer.tokenize(templateValue);
134 var parser = new _ParseAST(templateValue, templateUrl, absoluteValueOffset, tokens, templateValue.length, false /* parseAction */, this.errors, 0 /* relative offset */);
135 return parser.parseTemplateBindings({
136 source: templateKey,
137 span: new ast_1.AbsoluteSourceSpan(absoluteKeyOffset, absoluteKeyOffset + templateKey.length),
138 });
139 };
140 Parser.prototype.parseInterpolation = function (input, location, absoluteOffset, interpolationConfig) {
141 if (interpolationConfig === void 0) { interpolationConfig = interpolation_config_1.DEFAULT_INTERPOLATION_CONFIG; }
142 var _a = this.splitInterpolation(input, location, interpolationConfig), strings = _a.strings, expressions = _a.expressions, offsets = _a.offsets;
143 if (expressions.length === 0)
144 return null;
145 var expressionNodes = [];
146 for (var i = 0; i < expressions.length; ++i) {
147 var expressionText = expressions[i].text;
148 var sourceToLex = this._stripComments(expressionText);
149 var tokens = this._lexer.tokenize(sourceToLex);
150 var ast = new _ParseAST(input, location, absoluteOffset, tokens, sourceToLex.length, false, this.errors, offsets[i] + (expressionText.length - sourceToLex.length))
151 .parseChain();
152 expressionNodes.push(ast);
153 }
154 return this.createInterpolationAst(strings.map(function (s) { return s.text; }), expressionNodes, input, location, absoluteOffset);
155 };
156 /**
157 * Similar to `parseInterpolation`, but treats the provided string as a single expression
158 * element that would normally appear within the interpolation prefix and suffix (`{{` and `}}`).
159 * This is used for parsing the switch expression in ICUs.
160 */
161 Parser.prototype.parseInterpolationExpression = function (expression, location, absoluteOffset) {
162 var sourceToLex = this._stripComments(expression);
163 var tokens = this._lexer.tokenize(sourceToLex);
164 var ast = new _ParseAST(expression, location, absoluteOffset, tokens, sourceToLex.length,
165 /* parseAction */ false, this.errors, 0)
166 .parseChain();
167 var strings = ['', '']; // The prefix and suffix strings are both empty
168 return this.createInterpolationAst(strings, [ast], expression, location, absoluteOffset);
169 };
170 Parser.prototype.createInterpolationAst = function (strings, expressions, input, location, absoluteOffset) {
171 var span = new ast_1.ParseSpan(0, input.length);
172 var interpolation = new ast_1.Interpolation(span, span.toAbsolute(absoluteOffset), strings, expressions);
173 return new ast_1.ASTWithSource(interpolation, input, location, absoluteOffset, this.errors);
174 };
175 /**
176 * Splits a string of text into "raw" text segments and expressions present in interpolations in
177 * the string.
178 * Returns `null` if there are no interpolations, otherwise a
179 * `SplitInterpolation` with splits that look like
180 * <raw text> <expression> <raw text> ... <raw text> <expression> <raw text>
181 */
182 Parser.prototype.splitInterpolation = function (input, location, interpolationConfig) {
183 if (interpolationConfig === void 0) { interpolationConfig = interpolation_config_1.DEFAULT_INTERPOLATION_CONFIG; }
184 var strings = [];
185 var expressions = [];
186 var offsets = [];
187 var i = 0;
188 var atInterpolation = false;
189 var extendLastString = false;
190 var interpStart = interpolationConfig.start, interpEnd = interpolationConfig.end;
191 while (i < input.length) {
192 if (!atInterpolation) {
193 // parse until starting {{
194 var start = i;
195 i = input.indexOf(interpStart, i);
196 if (i === -1) {
197 i = input.length;
198 }
199 var text = input.substring(start, i);
200 strings.push({ text: text, start: start, end: i });
201 atInterpolation = true;
202 }
203 else {
204 // parse from starting {{ to ending }} while ignoring content inside quotes.
205 var fullStart = i;
206 var exprStart = fullStart + interpStart.length;
207 var exprEnd = this._getInterpolationEndIndex(input, interpEnd, exprStart);
208 if (exprEnd === -1) {
209 // Could not find the end of the interpolation; do not parse an expression.
210 // Instead we should extend the content on the last raw string.
211 atInterpolation = false;
212 extendLastString = true;
213 break;
214 }
215 var fullEnd = exprEnd + interpEnd.length;
216 var text = input.substring(exprStart, exprEnd);
217 if (text.trim().length === 0) {
218 this._reportError('Blank expressions are not allowed in interpolated strings', input, "at column " + i + " in", location);
219 }
220 expressions.push({ text: text, start: fullStart, end: fullEnd });
221 offsets.push(exprStart);
222 i = fullEnd;
223 atInterpolation = false;
224 }
225 }
226 if (!atInterpolation) {
227 // If we are now at a text section, add the remaining content as a raw string.
228 if (extendLastString) {
229 var piece = strings[strings.length - 1];
230 piece.text += input.substring(i);
231 piece.end = input.length;
232 }
233 else {
234 strings.push({ text: input.substring(i), start: i, end: input.length });
235 }
236 }
237 return new SplitInterpolation(strings, expressions, offsets);
238 };
239 Parser.prototype.wrapLiteralPrimitive = function (input, location, absoluteOffset) {
240 var span = new ast_1.ParseSpan(0, input == null ? 0 : input.length);
241 return new ast_1.ASTWithSource(new ast_1.LiteralPrimitive(span, span.toAbsolute(absoluteOffset), input), input, location, absoluteOffset, this.errors);
242 };
243 Parser.prototype._stripComments = function (input) {
244 var i = this._commentStart(input);
245 return i != null ? input.substring(0, i).trim() : input;
246 };
247 Parser.prototype._commentStart = function (input) {
248 var outerQuote = null;
249 for (var i = 0; i < input.length - 1; i++) {
250 var char = input.charCodeAt(i);
251 var nextChar = input.charCodeAt(i + 1);
252 if (char === chars.$SLASH && nextChar == chars.$SLASH && outerQuote == null)
253 return i;
254 if (outerQuote === char) {
255 outerQuote = null;
256 }
257 else if (outerQuote == null && chars.isQuote(char)) {
258 outerQuote = char;
259 }
260 }
261 return null;
262 };
263 Parser.prototype._checkNoInterpolation = function (input, location, _a) {
264 var e_1, _b;
265 var start = _a.start, end = _a.end;
266 var startIndex = -1;
267 var endIndex = -1;
268 try {
269 for (var _c = tslib_1.__values(this._forEachUnquotedChar(input, 0)), _d = _c.next(); !_d.done; _d = _c.next()) {
270 var charIndex = _d.value;
271 if (startIndex === -1) {
272 if (input.startsWith(start)) {
273 startIndex = charIndex;
274 }
275 }
276 else {
277 endIndex = this._getInterpolationEndIndex(input, end, charIndex);
278 if (endIndex > -1) {
279 break;
280 }
281 }
282 }
283 }
284 catch (e_1_1) { e_1 = { error: e_1_1 }; }
285 finally {
286 try {
287 if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
288 }
289 finally { if (e_1) throw e_1.error; }
290 }
291 if (startIndex > -1 && endIndex > -1) {
292 this._reportError("Got interpolation (" + start + end + ") where expression was expected", input, "at column " + startIndex + " in", location);
293 }
294 };
295 /**
296 * Finds the index of the end of an interpolation expression
297 * while ignoring comments and quoted content.
298 */
299 Parser.prototype._getInterpolationEndIndex = function (input, expressionEnd, start) {
300 var e_2, _a;
301 try {
302 for (var _b = tslib_1.__values(this._forEachUnquotedChar(input, start)), _c = _b.next(); !_c.done; _c = _b.next()) {
303 var charIndex = _c.value;
304 if (input.startsWith(expressionEnd, charIndex)) {
305 return charIndex;
306 }
307 // Nothing else in the expression matters after we've
308 // hit a comment so look directly for the end token.
309 if (input.startsWith('//', charIndex)) {
310 return input.indexOf(expressionEnd, charIndex);
311 }
312 }
313 }
314 catch (e_2_1) { e_2 = { error: e_2_1 }; }
315 finally {
316 try {
317 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
318 }
319 finally { if (e_2) throw e_2.error; }
320 }
321 return -1;
322 };
323 /**
324 * Generator used to iterate over the character indexes of a string that are outside of quotes.
325 * @param input String to loop through.
326 * @param start Index within the string at which to start.
327 */
328 Parser.prototype._forEachUnquotedChar = function (input, start) {
329 var currentQuote, escapeCount, i, char;
330 return tslib_1.__generator(this, function (_a) {
331 switch (_a.label) {
332 case 0:
333 currentQuote = null;
334 escapeCount = 0;
335 i = start;
336 _a.label = 1;
337 case 1:
338 if (!(i < input.length)) return [3 /*break*/, 6];
339 char = input[i];
340 if (!(chars.isQuote(input.charCodeAt(i)) && (currentQuote === null || currentQuote === char) &&
341 escapeCount % 2 === 0)) return [3 /*break*/, 2];
342 currentQuote = currentQuote === null ? char : null;
343 return [3 /*break*/, 4];
344 case 2:
345 if (!(currentQuote === null)) return [3 /*break*/, 4];
346 return [4 /*yield*/, i];
347 case 3:
348 _a.sent();
349 _a.label = 4;
350 case 4:
351 escapeCount = char === '\\' ? escapeCount + 1 : 0;
352 _a.label = 5;
353 case 5:
354 i++;
355 return [3 /*break*/, 1];
356 case 6: return [2 /*return*/];
357 }
358 });
359 };
360 return Parser;
361 }());
362 exports.Parser = Parser;
363 var IvyParser = /** @class */ (function (_super) {
364 tslib_1.__extends(IvyParser, _super);
365 function IvyParser() {
366 var _this = _super !== null && _super.apply(this, arguments) || this;
367 _this.simpleExpressionChecker = IvySimpleExpressionChecker;
368 return _this;
369 }
370 return IvyParser;
371 }(Parser));
372 exports.IvyParser = IvyParser;
373 /** Describes a stateful context an expression parser is in. */
374 var ParseContextFlags;
375 (function (ParseContextFlags) {
376 ParseContextFlags[ParseContextFlags["None"] = 0] = "None";
377 /**
378 * A Writable context is one in which a value may be written to an lvalue.
379 * For example, after we see a property access, we may expect a write to the
380 * property via the "=" operator.
381 * prop
382 * ^ possible "=" after
383 */
384 ParseContextFlags[ParseContextFlags["Writable"] = 1] = "Writable";
385 })(ParseContextFlags || (ParseContextFlags = {}));
386 var _ParseAST = /** @class */ (function () {
387 function _ParseAST(input, location, absoluteOffset, tokens, inputLength, parseAction, errors, offset) {
388 this.input = input;
389 this.location = location;
390 this.absoluteOffset = absoluteOffset;
391 this.tokens = tokens;
392 this.inputLength = inputLength;
393 this.parseAction = parseAction;
394 this.errors = errors;
395 this.offset = offset;
396 this.rparensExpected = 0;
397 this.rbracketsExpected = 0;
398 this.rbracesExpected = 0;
399 this.context = ParseContextFlags.None;
400 // Cache of expression start and input indeces to the absolute source span they map to, used to
401 // prevent creating superfluous source spans in `sourceSpan`.
402 // A serial of the expression start and input index is used for mapping because both are stateful
403 // and may change for subsequent expressions visited by the parser.
404 this.sourceSpanCache = new Map();
405 this.index = 0;
406 }
407 _ParseAST.prototype.peek = function (offset) {
408 var i = this.index + offset;
409 return i < this.tokens.length ? this.tokens[i] : lexer_1.EOF;
410 };
411 Object.defineProperty(_ParseAST.prototype, "next", {
412 get: function () {
413 return this.peek(0);
414 },
415 enumerable: false,
416 configurable: true
417 });
418 Object.defineProperty(_ParseAST.prototype, "atEOF", {
419 /** Whether all the parser input has been processed. */
420 get: function () {
421 return this.index >= this.tokens.length;
422 },
423 enumerable: false,
424 configurable: true
425 });
426 Object.defineProperty(_ParseAST.prototype, "inputIndex", {
427 /**
428 * Index of the next token to be processed, or the end of the last token if all have been
429 * processed.
430 */
431 get: function () {
432 return this.atEOF ? this.currentEndIndex : this.next.index + this.offset;
433 },
434 enumerable: false,
435 configurable: true
436 });
437 Object.defineProperty(_ParseAST.prototype, "currentEndIndex", {
438 /**
439 * End index of the last processed token, or the start of the first token if none have been
440 * processed.
441 */
442 get: function () {
443 if (this.index > 0) {
444 var curToken = this.peek(-1);
445 return curToken.end + this.offset;
446 }
447 // No tokens have been processed yet; return the next token's start or the length of the input
448 // if there is no token.
449 if (this.tokens.length === 0) {
450 return this.inputLength + this.offset;
451 }
452 return this.next.index + this.offset;
453 },
454 enumerable: false,
455 configurable: true
456 });
457 Object.defineProperty(_ParseAST.prototype, "currentAbsoluteOffset", {
458 /**
459 * Returns the absolute offset of the start of the current token.
460 */
461 get: function () {
462 return this.absoluteOffset + this.inputIndex;
463 },
464 enumerable: false,
465 configurable: true
466 });
467 /**
468 * Retrieve a `ParseSpan` from `start` to the current position (or to `artificialEndIndex` if
469 * provided).
470 *
471 * @param start Position from which the `ParseSpan` will start.
472 * @param artificialEndIndex Optional ending index to be used if provided (and if greater than the
473 * natural ending index)
474 */
475 _ParseAST.prototype.span = function (start, artificialEndIndex) {
476 var endIndex = this.currentEndIndex;
477 if (artificialEndIndex !== undefined && artificialEndIndex > this.currentEndIndex) {
478 endIndex = artificialEndIndex;
479 }
480 // In some unusual parsing scenarios (like when certain tokens are missing and an `EmptyExpr` is
481 // being created), the current token may already be advanced beyond the `currentEndIndex`. This
482 // appears to be a deep-seated parser bug.
483 //
484 // As a workaround for now, swap the start and end indices to ensure a valid `ParseSpan`.
485 // TODO(alxhub): fix the bug upstream in the parser state, and remove this workaround.
486 if (start > endIndex) {
487 var tmp = endIndex;
488 endIndex = start;
489 start = tmp;
490 }
491 return new ast_1.ParseSpan(start, endIndex);
492 };
493 _ParseAST.prototype.sourceSpan = function (start, artificialEndIndex) {
494 var serial = start + "@" + this.inputIndex + ":" + artificialEndIndex;
495 if (!this.sourceSpanCache.has(serial)) {
496 this.sourceSpanCache.set(serial, this.span(start, artificialEndIndex).toAbsolute(this.absoluteOffset));
497 }
498 return this.sourceSpanCache.get(serial);
499 };
500 _ParseAST.prototype.advance = function () {
501 this.index++;
502 };
503 /**
504 * Executes a callback in the provided context.
505 */
506 _ParseAST.prototype.withContext = function (context, cb) {
507 this.context |= context;
508 var ret = cb();
509 this.context ^= context;
510 return ret;
511 };
512 _ParseAST.prototype.consumeOptionalCharacter = function (code) {
513 if (this.next.isCharacter(code)) {
514 this.advance();
515 return true;
516 }
517 else {
518 return false;
519 }
520 };
521 _ParseAST.prototype.peekKeywordLet = function () {
522 return this.next.isKeywordLet();
523 };
524 _ParseAST.prototype.peekKeywordAs = function () {
525 return this.next.isKeywordAs();
526 };
527 /**
528 * Consumes an expected character, otherwise emits an error about the missing expected character
529 * and skips over the token stream until reaching a recoverable point.
530 *
531 * See `this.error` and `this.skip` for more details.
532 */
533 _ParseAST.prototype.expectCharacter = function (code) {
534 if (this.consumeOptionalCharacter(code))
535 return;
536 this.error("Missing expected " + String.fromCharCode(code));
537 };
538 _ParseAST.prototype.consumeOptionalOperator = function (op) {
539 if (this.next.isOperator(op)) {
540 this.advance();
541 return true;
542 }
543 else {
544 return false;
545 }
546 };
547 _ParseAST.prototype.expectOperator = function (operator) {
548 if (this.consumeOptionalOperator(operator))
549 return;
550 this.error("Missing expected operator " + operator);
551 };
552 _ParseAST.prototype.prettyPrintToken = function (tok) {
553 return tok === lexer_1.EOF ? 'end of input' : "token " + tok;
554 };
555 _ParseAST.prototype.expectIdentifierOrKeyword = function () {
556 var n = this.next;
557 if (!n.isIdentifier() && !n.isKeyword()) {
558 if (n.isPrivateIdentifier()) {
559 this._reportErrorForPrivateIdentifier(n, 'expected identifier or keyword');
560 }
561 else {
562 this.error("Unexpected " + this.prettyPrintToken(n) + ", expected identifier or keyword");
563 }
564 return null;
565 }
566 this.advance();
567 return n.toString();
568 };
569 _ParseAST.prototype.expectIdentifierOrKeywordOrString = function () {
570 var n = this.next;
571 if (!n.isIdentifier() && !n.isKeyword() && !n.isString()) {
572 if (n.isPrivateIdentifier()) {
573 this._reportErrorForPrivateIdentifier(n, 'expected identifier, keyword or string');
574 }
575 else {
576 this.error("Unexpected " + this.prettyPrintToken(n) + ", expected identifier, keyword, or string");
577 }
578 return '';
579 }
580 this.advance();
581 return n.toString();
582 };
583 _ParseAST.prototype.parseChain = function () {
584 var exprs = [];
585 var start = this.inputIndex;
586 while (this.index < this.tokens.length) {
587 var expr = this.parsePipe();
588 exprs.push(expr);
589 if (this.consumeOptionalCharacter(chars.$SEMICOLON)) {
590 if (!this.parseAction) {
591 this.error('Binding expression cannot contain chained expression');
592 }
593 while (this.consumeOptionalCharacter(chars.$SEMICOLON)) {
594 } // read all semicolons
595 }
596 else if (this.index < this.tokens.length) {
597 this.error("Unexpected token '" + this.next + "'");
598 }
599 }
600 if (exprs.length == 0) {
601 // We have no expressions so create an empty expression that spans the entire input length
602 var artificialStart = this.offset;
603 var artificialEnd = this.offset + this.inputLength;
604 return new ast_1.EmptyExpr(this.span(artificialStart, artificialEnd), this.sourceSpan(artificialStart, artificialEnd));
605 }
606 if (exprs.length == 1)
607 return exprs[0];
608 return new ast_1.Chain(this.span(start), this.sourceSpan(start), exprs);
609 };
610 _ParseAST.prototype.parsePipe = function () {
611 var start = this.inputIndex;
612 var result = this.parseExpression();
613 if (this.consumeOptionalOperator('|')) {
614 if (this.parseAction) {
615 this.error('Cannot have a pipe in an action expression');
616 }
617 do {
618 var nameStart = this.inputIndex;
619 var nameId = this.expectIdentifierOrKeyword();
620 var nameSpan = void 0;
621 var fullSpanEnd = undefined;
622 if (nameId !== null) {
623 nameSpan = this.sourceSpan(nameStart);
624 }
625 else {
626 // No valid identifier was found, so we'll assume an empty pipe name ('').
627 nameId = '';
628 // However, there may have been whitespace present between the pipe character and the next
629 // token in the sequence (or the end of input). We want to track this whitespace so that
630 // the `BindingPipe` we produce covers not just the pipe character, but any trailing
631 // whitespace beyond it. Another way of thinking about this is that the zero-length name
632 // is assumed to be at the end of any whitespace beyond the pipe character.
633 //
634 // Therefore, we push the end of the `ParseSpan` for this pipe all the way up to the
635 // beginning of the next token, or until the end of input if the next token is EOF.
636 fullSpanEnd = this.next.index !== -1 ? this.next.index : this.inputLength + this.offset;
637 // The `nameSpan` for an empty pipe name is zero-length at the end of any whitespace
638 // beyond the pipe character.
639 nameSpan = new ast_1.ParseSpan(fullSpanEnd, fullSpanEnd).toAbsolute(this.absoluteOffset);
640 }
641 var args = [];
642 while (this.consumeOptionalCharacter(chars.$COLON)) {
643 args.push(this.parseExpression());
644 // If there are additional expressions beyond the name, then the artificial end for the
645 // name is no longer relevant.
646 }
647 result = new ast_1.BindingPipe(this.span(start), this.sourceSpan(start, fullSpanEnd), result, nameId, args, nameSpan);
648 } while (this.consumeOptionalOperator('|'));
649 }
650 return result;
651 };
652 _ParseAST.prototype.parseExpression = function () {
653 return this.parseConditional();
654 };
655 _ParseAST.prototype.parseConditional = function () {
656 var start = this.inputIndex;
657 var result = this.parseLogicalOr();
658 if (this.consumeOptionalOperator('?')) {
659 var yes = this.parsePipe();
660 var no = void 0;
661 if (!this.consumeOptionalCharacter(chars.$COLON)) {
662 var end = this.inputIndex;
663 var expression = this.input.substring(start, end);
664 this.error("Conditional expression " + expression + " requires all 3 expressions");
665 no = new ast_1.EmptyExpr(this.span(start), this.sourceSpan(start));
666 }
667 else {
668 no = this.parsePipe();
669 }
670 return new ast_1.Conditional(this.span(start), this.sourceSpan(start), result, yes, no);
671 }
672 else {
673 return result;
674 }
675 };
676 _ParseAST.prototype.parseLogicalOr = function () {
677 // '||'
678 var start = this.inputIndex;
679 var result = this.parseLogicalAnd();
680 while (this.consumeOptionalOperator('||')) {
681 var right = this.parseLogicalAnd();
682 result = new ast_1.Binary(this.span(start), this.sourceSpan(start), '||', result, right);
683 }
684 return result;
685 };
686 _ParseAST.prototype.parseLogicalAnd = function () {
687 // '&&'
688 var start = this.inputIndex;
689 var result = this.parseNullishCoalescing();
690 while (this.consumeOptionalOperator('&&')) {
691 var right = this.parseNullishCoalescing();
692 result = new ast_1.Binary(this.span(start), this.sourceSpan(start), '&&', result, right);
693 }
694 return result;
695 };
696 _ParseAST.prototype.parseNullishCoalescing = function () {
697 // '??'
698 var start = this.inputIndex;
699 var result = this.parseEquality();
700 while (this.consumeOptionalOperator('??')) {
701 var right = this.parseEquality();
702 result = new ast_1.Binary(this.span(start), this.sourceSpan(start), '??', result, right);
703 }
704 return result;
705 };
706 _ParseAST.prototype.parseEquality = function () {
707 // '==','!=','===','!=='
708 var start = this.inputIndex;
709 var result = this.parseRelational();
710 while (this.next.type == lexer_1.TokenType.Operator) {
711 var operator = this.next.strValue;
712 switch (operator) {
713 case '==':
714 case '===':
715 case '!=':
716 case '!==':
717 this.advance();
718 var right = this.parseRelational();
719 result = new ast_1.Binary(this.span(start), this.sourceSpan(start), operator, result, right);
720 continue;
721 }
722 break;
723 }
724 return result;
725 };
726 _ParseAST.prototype.parseRelational = function () {
727 // '<', '>', '<=', '>='
728 var start = this.inputIndex;
729 var result = this.parseAdditive();
730 while (this.next.type == lexer_1.TokenType.Operator) {
731 var operator = this.next.strValue;
732 switch (operator) {
733 case '<':
734 case '>':
735 case '<=':
736 case '>=':
737 this.advance();
738 var right = this.parseAdditive();
739 result = new ast_1.Binary(this.span(start), this.sourceSpan(start), operator, result, right);
740 continue;
741 }
742 break;
743 }
744 return result;
745 };
746 _ParseAST.prototype.parseAdditive = function () {
747 // '+', '-'
748 var start = this.inputIndex;
749 var result = this.parseMultiplicative();
750 while (this.next.type == lexer_1.TokenType.Operator) {
751 var operator = this.next.strValue;
752 switch (operator) {
753 case '+':
754 case '-':
755 this.advance();
756 var right = this.parseMultiplicative();
757 result = new ast_1.Binary(this.span(start), this.sourceSpan(start), operator, result, right);
758 continue;
759 }
760 break;
761 }
762 return result;
763 };
764 _ParseAST.prototype.parseMultiplicative = function () {
765 // '*', '%', '/'
766 var start = this.inputIndex;
767 var result = this.parsePrefix();
768 while (this.next.type == lexer_1.TokenType.Operator) {
769 var operator = this.next.strValue;
770 switch (operator) {
771 case '*':
772 case '%':
773 case '/':
774 this.advance();
775 var right = this.parsePrefix();
776 result = new ast_1.Binary(this.span(start), this.sourceSpan(start), operator, result, right);
777 continue;
778 }
779 break;
780 }
781 return result;
782 };
783 _ParseAST.prototype.parsePrefix = function () {
784 if (this.next.type == lexer_1.TokenType.Operator) {
785 var start = this.inputIndex;
786 var operator = this.next.strValue;
787 var result = void 0;
788 switch (operator) {
789 case '+':
790 this.advance();
791 result = this.parsePrefix();
792 return ast_1.Unary.createPlus(this.span(start), this.sourceSpan(start), result);
793 case '-':
794 this.advance();
795 result = this.parsePrefix();
796 return ast_1.Unary.createMinus(this.span(start), this.sourceSpan(start), result);
797 case '!':
798 this.advance();
799 result = this.parsePrefix();
800 return new ast_1.PrefixNot(this.span(start), this.sourceSpan(start), result);
801 }
802 }
803 return this.parseCallChain();
804 };
805 _ParseAST.prototype.parseCallChain = function () {
806 var start = this.inputIndex;
807 var result = this.parsePrimary();
808 while (true) {
809 if (this.consumeOptionalCharacter(chars.$PERIOD)) {
810 result = this.parseAccessMemberOrMethodCall(result, start, false);
811 }
812 else if (this.consumeOptionalOperator('?.')) {
813 result = this.consumeOptionalCharacter(chars.$LBRACKET) ?
814 this.parseKeyedReadOrWrite(result, start, true) :
815 this.parseAccessMemberOrMethodCall(result, start, true);
816 }
817 else if (this.consumeOptionalCharacter(chars.$LBRACKET)) {
818 result = this.parseKeyedReadOrWrite(result, start, false);
819 }
820 else if (this.consumeOptionalCharacter(chars.$LPAREN)) {
821 this.rparensExpected++;
822 var args = this.parseCallArguments();
823 this.rparensExpected--;
824 this.expectCharacter(chars.$RPAREN);
825 result = new ast_1.FunctionCall(this.span(start), this.sourceSpan(start), result, args);
826 }
827 else if (this.consumeOptionalOperator('!')) {
828 result = new ast_1.NonNullAssert(this.span(start), this.sourceSpan(start), result);
829 }
830 else {
831 return result;
832 }
833 }
834 };
835 _ParseAST.prototype.parsePrimary = function () {
836 var start = this.inputIndex;
837 if (this.consumeOptionalCharacter(chars.$LPAREN)) {
838 this.rparensExpected++;
839 var result = this.parsePipe();
840 this.rparensExpected--;
841 this.expectCharacter(chars.$RPAREN);
842 return result;
843 }
844 else if (this.next.isKeywordNull()) {
845 this.advance();
846 return new ast_1.LiteralPrimitive(this.span(start), this.sourceSpan(start), null);
847 }
848 else if (this.next.isKeywordUndefined()) {
849 this.advance();
850 return new ast_1.LiteralPrimitive(this.span(start), this.sourceSpan(start), void 0);
851 }
852 else if (this.next.isKeywordTrue()) {
853 this.advance();
854 return new ast_1.LiteralPrimitive(this.span(start), this.sourceSpan(start), true);
855 }
856 else if (this.next.isKeywordFalse()) {
857 this.advance();
858 return new ast_1.LiteralPrimitive(this.span(start), this.sourceSpan(start), false);
859 }
860 else if (this.next.isKeywordThis()) {
861 this.advance();
862 return new ast_1.ThisReceiver(this.span(start), this.sourceSpan(start));
863 }
864 else if (this.consumeOptionalCharacter(chars.$LBRACKET)) {
865 this.rbracketsExpected++;
866 var elements = this.parseExpressionList(chars.$RBRACKET);
867 this.rbracketsExpected--;
868 this.expectCharacter(chars.$RBRACKET);
869 return new ast_1.LiteralArray(this.span(start), this.sourceSpan(start), elements);
870 }
871 else if (this.next.isCharacter(chars.$LBRACE)) {
872 return this.parseLiteralMap();
873 }
874 else if (this.next.isIdentifier()) {
875 return this.parseAccessMemberOrMethodCall(new ast_1.ImplicitReceiver(this.span(start), this.sourceSpan(start)), start, false);
876 }
877 else if (this.next.isNumber()) {
878 var value = this.next.toNumber();
879 this.advance();
880 return new ast_1.LiteralPrimitive(this.span(start), this.sourceSpan(start), value);
881 }
882 else if (this.next.isString()) {
883 var literalValue = this.next.toString();
884 this.advance();
885 return new ast_1.LiteralPrimitive(this.span(start), this.sourceSpan(start), literalValue);
886 }
887 else if (this.next.isPrivateIdentifier()) {
888 this._reportErrorForPrivateIdentifier(this.next, null);
889 return new ast_1.EmptyExpr(this.span(start), this.sourceSpan(start));
890 }
891 else if (this.index >= this.tokens.length) {
892 this.error("Unexpected end of expression: " + this.input);
893 return new ast_1.EmptyExpr(this.span(start), this.sourceSpan(start));
894 }
895 else {
896 this.error("Unexpected token " + this.next);
897 return new ast_1.EmptyExpr(this.span(start), this.sourceSpan(start));
898 }
899 };
900 _ParseAST.prototype.parseExpressionList = function (terminator) {
901 var result = [];
902 do {
903 if (!this.next.isCharacter(terminator)) {
904 result.push(this.parsePipe());
905 }
906 else {
907 break;
908 }
909 } while (this.consumeOptionalCharacter(chars.$COMMA));
910 return result;
911 };
912 _ParseAST.prototype.parseLiteralMap = function () {
913 var keys = [];
914 var values = [];
915 var start = this.inputIndex;
916 this.expectCharacter(chars.$LBRACE);
917 if (!this.consumeOptionalCharacter(chars.$RBRACE)) {
918 this.rbracesExpected++;
919 do {
920 var keyStart = this.inputIndex;
921 var quoted = this.next.isString();
922 var key = this.expectIdentifierOrKeywordOrString();
923 keys.push({ key: key, quoted: quoted });
924 // Properties with quoted keys can't use the shorthand syntax.
925 if (quoted) {
926 this.expectCharacter(chars.$COLON);
927 values.push(this.parsePipe());
928 }
929 else if (this.consumeOptionalCharacter(chars.$COLON)) {
930 values.push(this.parsePipe());
931 }
932 else {
933 var span = this.span(keyStart);
934 var sourceSpan = this.sourceSpan(keyStart);
935 values.push(new ast_1.PropertyRead(span, sourceSpan, sourceSpan, new ast_1.ImplicitReceiver(span, sourceSpan), key));
936 }
937 } while (this.consumeOptionalCharacter(chars.$COMMA));
938 this.rbracesExpected--;
939 this.expectCharacter(chars.$RBRACE);
940 }
941 return new ast_1.LiteralMap(this.span(start), this.sourceSpan(start), keys, values);
942 };
943 _ParseAST.prototype.parseAccessMemberOrMethodCall = function (receiver, start, isSafe) {
944 var _this = this;
945 var nameStart = this.inputIndex;
946 var id = this.withContext(ParseContextFlags.Writable, function () {
947 var _a;
948 var id = (_a = _this.expectIdentifierOrKeyword()) !== null && _a !== void 0 ? _a : '';
949 if (id.length === 0) {
950 _this.error("Expected identifier for property access", receiver.span.end);
951 }
952 return id;
953 });
954 var nameSpan = this.sourceSpan(nameStart);
955 if (this.consumeOptionalCharacter(chars.$LPAREN)) {
956 var argumentStart = this.inputIndex;
957 this.rparensExpected++;
958 var args = this.parseCallArguments();
959 var argumentSpan = this.span(argumentStart, this.inputIndex).toAbsolute(this.absoluteOffset);
960 this.expectCharacter(chars.$RPAREN);
961 this.rparensExpected--;
962 var span = this.span(start);
963 var sourceSpan = this.sourceSpan(start);
964 return isSafe ?
965 new ast_1.SafeMethodCall(span, sourceSpan, nameSpan, receiver, id, args, argumentSpan) :
966 new ast_1.MethodCall(span, sourceSpan, nameSpan, receiver, id, args, argumentSpan);
967 }
968 else {
969 if (isSafe) {
970 if (this.consumeOptionalOperator('=')) {
971 this.error('The \'?.\' operator cannot be used in the assignment');
972 return new ast_1.EmptyExpr(this.span(start), this.sourceSpan(start));
973 }
974 else {
975 return new ast_1.SafePropertyRead(this.span(start), this.sourceSpan(start), nameSpan, receiver, id);
976 }
977 }
978 else {
979 if (this.consumeOptionalOperator('=')) {
980 if (!this.parseAction) {
981 this.error('Bindings cannot contain assignments');
982 return new ast_1.EmptyExpr(this.span(start), this.sourceSpan(start));
983 }
984 var value = this.parseConditional();
985 return new ast_1.PropertyWrite(this.span(start), this.sourceSpan(start), nameSpan, receiver, id, value);
986 }
987 else {
988 return new ast_1.PropertyRead(this.span(start), this.sourceSpan(start), nameSpan, receiver, id);
989 }
990 }
991 }
992 };
993 _ParseAST.prototype.parseCallArguments = function () {
994 if (this.next.isCharacter(chars.$RPAREN))
995 return [];
996 var positionals = [];
997 do {
998 positionals.push(this.parsePipe());
999 } while (this.consumeOptionalCharacter(chars.$COMMA));
1000 return positionals;
1001 };
1002 /**
1003 * Parses an identifier, a keyword, a string with an optional `-` in between,
1004 * and returns the string along with its absolute source span.
1005 */
1006 _ParseAST.prototype.expectTemplateBindingKey = function () {
1007 var result = '';
1008 var operatorFound = false;
1009 var start = this.currentAbsoluteOffset;
1010 do {
1011 result += this.expectIdentifierOrKeywordOrString();
1012 operatorFound = this.consumeOptionalOperator('-');
1013 if (operatorFound) {
1014 result += '-';
1015 }
1016 } while (operatorFound);
1017 return {
1018 source: result,
1019 span: new ast_1.AbsoluteSourceSpan(start, start + result.length),
1020 };
1021 };
1022 /**
1023 * Parse microsyntax template expression and return a list of bindings or
1024 * parsing errors in case the given expression is invalid.
1025 *
1026 * For example,
1027 * ```
1028 * <div *ngFor="let item of items; index as i; trackBy: func">
1029 * ```
1030 * contains five bindings:
1031 * 1. ngFor -> null
1032 * 2. item -> NgForOfContext.$implicit
1033 * 3. ngForOf -> items
1034 * 4. i -> NgForOfContext.index
1035 * 5. ngForTrackBy -> func
1036 *
1037 * For a full description of the microsyntax grammar, see
1038 * https://gist.github.com/mhevery/d3530294cff2e4a1b3fe15ff75d08855
1039 *
1040 * @param templateKey name of the microsyntax directive, like ngIf, ngFor,
1041 * without the *, along with its absolute span.
1042 */
1043 _ParseAST.prototype.parseTemplateBindings = function (templateKey) {
1044 var bindings = [];
1045 // The first binding is for the template key itself
1046 // In *ngFor="let item of items", key = "ngFor", value = null
1047 // In *ngIf="cond | pipe", key = "ngIf", value = "cond | pipe"
1048 bindings.push.apply(bindings, tslib_1.__spreadArray([], tslib_1.__read(this.parseDirectiveKeywordBindings(templateKey))));
1049 while (this.index < this.tokens.length) {
1050 // If it starts with 'let', then this must be variable declaration
1051 var letBinding = this.parseLetBinding();
1052 if (letBinding) {
1053 bindings.push(letBinding);
1054 }
1055 else {
1056 // Two possible cases here, either `value "as" key` or
1057 // "directive-keyword expression". We don't know which case, but both
1058 // "value" and "directive-keyword" are template binding key, so consume
1059 // the key first.
1060 var key = this.expectTemplateBindingKey();
1061 // Peek at the next token, if it is "as" then this must be variable
1062 // declaration.
1063 var binding = this.parseAsBinding(key);
1064 if (binding) {
1065 bindings.push(binding);
1066 }
1067 else {
1068 // Otherwise the key must be a directive keyword, like "of". Transform
1069 // the key to actual key. Eg. of -> ngForOf, trackBy -> ngForTrackBy
1070 key.source =
1071 templateKey.source + key.source.charAt(0).toUpperCase() + key.source.substring(1);
1072 bindings.push.apply(bindings, tslib_1.__spreadArray([], tslib_1.__read(this.parseDirectiveKeywordBindings(key))));
1073 }
1074 }
1075 this.consumeStatementTerminator();
1076 }
1077 return new TemplateBindingParseResult(bindings, [] /* warnings */, this.errors);
1078 };
1079 _ParseAST.prototype.parseKeyedReadOrWrite = function (receiver, start, isSafe) {
1080 var _this = this;
1081 return this.withContext(ParseContextFlags.Writable, function () {
1082 _this.rbracketsExpected++;
1083 var key = _this.parsePipe();
1084 if (key instanceof ast_1.EmptyExpr) {
1085 _this.error("Key access cannot be empty");
1086 }
1087 _this.rbracketsExpected--;
1088 _this.expectCharacter(chars.$RBRACKET);
1089 if (_this.consumeOptionalOperator('=')) {
1090 if (isSafe) {
1091 _this.error('The \'?.\' operator cannot be used in the assignment');
1092 }
1093 else {
1094 var value = _this.parseConditional();
1095 return new ast_1.KeyedWrite(_this.span(start), _this.sourceSpan(start), receiver, key, value);
1096 }
1097 }
1098 else {
1099 return isSafe ? new ast_1.SafeKeyedRead(_this.span(start), _this.sourceSpan(start), receiver, key) :
1100 new ast_1.KeyedRead(_this.span(start), _this.sourceSpan(start), receiver, key);
1101 }
1102 return new ast_1.EmptyExpr(_this.span(start), _this.sourceSpan(start));
1103 });
1104 };
1105 /**
1106 * Parse a directive keyword, followed by a mandatory expression.
1107 * For example, "of items", "trackBy: func".
1108 * The bindings are: ngForOf -> items, ngForTrackBy -> func
1109 * There could be an optional "as" binding that follows the expression.
1110 * For example,
1111 * ```
1112 * *ngFor="let item of items | slice:0:1 as collection".
1113 * ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^
1114 * keyword bound target optional 'as' binding
1115 * ```
1116 *
1117 * @param key binding key, for example, ngFor, ngIf, ngForOf, along with its
1118 * absolute span.
1119 */
1120 _ParseAST.prototype.parseDirectiveKeywordBindings = function (key) {
1121 var bindings = [];
1122 this.consumeOptionalCharacter(chars.$COLON); // trackBy: trackByFunction
1123 var value = this.getDirectiveBoundTarget();
1124 var spanEnd = this.currentAbsoluteOffset;
1125 // The binding could optionally be followed by "as". For example,
1126 // *ngIf="cond | pipe as x". In this case, the key in the "as" binding
1127 // is "x" and the value is the template key itself ("ngIf"). Note that the
1128 // 'key' in the current context now becomes the "value" in the next binding.
1129 var asBinding = this.parseAsBinding(key);
1130 if (!asBinding) {
1131 this.consumeStatementTerminator();
1132 spanEnd = this.currentAbsoluteOffset;
1133 }
1134 var sourceSpan = new ast_1.AbsoluteSourceSpan(key.span.start, spanEnd);
1135 bindings.push(new ast_1.ExpressionBinding(sourceSpan, key, value));
1136 if (asBinding) {
1137 bindings.push(asBinding);
1138 }
1139 return bindings;
1140 };
1141 /**
1142 * Return the expression AST for the bound target of a directive keyword
1143 * binding. For example,
1144 * ```
1145 * *ngIf="condition | pipe"
1146 * ^^^^^^^^^^^^^^^^ bound target for "ngIf"
1147 * *ngFor="let item of items"
1148 * ^^^^^ bound target for "ngForOf"
1149 * ```
1150 */
1151 _ParseAST.prototype.getDirectiveBoundTarget = function () {
1152 if (this.next === lexer_1.EOF || this.peekKeywordAs() || this.peekKeywordLet()) {
1153 return null;
1154 }
1155 var ast = this.parsePipe(); // example: "condition | async"
1156 var _a = ast.span, start = _a.start, end = _a.end;
1157 var value = this.input.substring(start, end);
1158 return new ast_1.ASTWithSource(ast, value, this.location, this.absoluteOffset + start, this.errors);
1159 };
1160 /**
1161 * Return the binding for a variable declared using `as`. Note that the order
1162 * of the key-value pair in this declaration is reversed. For example,
1163 * ```
1164 * *ngFor="let item of items; index as i"
1165 * ^^^^^ ^
1166 * value key
1167 * ```
1168 *
1169 * @param value name of the value in the declaration, "ngIf" in the example
1170 * above, along with its absolute span.
1171 */
1172 _ParseAST.prototype.parseAsBinding = function (value) {
1173 if (!this.peekKeywordAs()) {
1174 return null;
1175 }
1176 this.advance(); // consume the 'as' keyword
1177 var key = this.expectTemplateBindingKey();
1178 this.consumeStatementTerminator();
1179 var sourceSpan = new ast_1.AbsoluteSourceSpan(value.span.start, this.currentAbsoluteOffset);
1180 return new ast_1.VariableBinding(sourceSpan, key, value);
1181 };
1182 /**
1183 * Return the binding for a variable declared using `let`. For example,
1184 * ```
1185 * *ngFor="let item of items; let i=index;"
1186 * ^^^^^^^^ ^^^^^^^^^^^
1187 * ```
1188 * In the first binding, `item` is bound to `NgForOfContext.$implicit`.
1189 * In the second binding, `i` is bound to `NgForOfContext.index`.
1190 */
1191 _ParseAST.prototype.parseLetBinding = function () {
1192 if (!this.peekKeywordLet()) {
1193 return null;
1194 }
1195 var spanStart = this.currentAbsoluteOffset;
1196 this.advance(); // consume the 'let' keyword
1197 var key = this.expectTemplateBindingKey();
1198 var value = null;
1199 if (this.consumeOptionalOperator('=')) {
1200 value = this.expectTemplateBindingKey();
1201 }
1202 this.consumeStatementTerminator();
1203 var sourceSpan = new ast_1.AbsoluteSourceSpan(spanStart, this.currentAbsoluteOffset);
1204 return new ast_1.VariableBinding(sourceSpan, key, value);
1205 };
1206 /**
1207 * Consume the optional statement terminator: semicolon or comma.
1208 */
1209 _ParseAST.prototype.consumeStatementTerminator = function () {
1210 this.consumeOptionalCharacter(chars.$SEMICOLON) || this.consumeOptionalCharacter(chars.$COMMA);
1211 };
1212 /**
1213 * Records an error and skips over the token stream until reaching a recoverable point. See
1214 * `this.skip` for more details on token skipping.
1215 */
1216 _ParseAST.prototype.error = function (message, index) {
1217 if (index === void 0) { index = null; }
1218 this.errors.push(new ast_1.ParserError(message, this.input, this.locationText(index), this.location));
1219 this.skip();
1220 };
1221 _ParseAST.prototype.locationText = function (index) {
1222 if (index === void 0) { index = null; }
1223 if (index == null)
1224 index = this.index;
1225 return (index < this.tokens.length) ? "at column " + (this.tokens[index].index + 1) + " in" :
1226 "at the end of the expression";
1227 };
1228 /**
1229 * Records an error for an unexpected private identifier being discovered.
1230 * @param token Token representing a private identifier.
1231 * @param extraMessage Optional additional message being appended to the error.
1232 */
1233 _ParseAST.prototype._reportErrorForPrivateIdentifier = function (token, extraMessage) {
1234 var errorMessage = "Private identifiers are not supported. Unexpected private identifier: " + token;
1235 if (extraMessage !== null) {
1236 errorMessage += ", " + extraMessage;
1237 }
1238 this.error(errorMessage);
1239 };
1240 /**
1241 * Error recovery should skip tokens until it encounters a recovery point.
1242 *
1243 * The following are treated as unconditional recovery points:
1244 * - end of input
1245 * - ';' (parseChain() is always the root production, and it expects a ';')
1246 * - '|' (since pipes may be chained and each pipe expression may be treated independently)
1247 *
1248 * The following are conditional recovery points:
1249 * - ')', '}', ']' if one of calling productions is expecting one of these symbols
1250 * - This allows skip() to recover from errors such as '(a.) + 1' allowing more of the AST to
1251 * be retained (it doesn't skip any tokens as the ')' is retained because of the '(' begins
1252 * an '(' <expr> ')' production).
1253 * The recovery points of grouping symbols must be conditional as they must be skipped if
1254 * none of the calling productions are not expecting the closing token else we will never
1255 * make progress in the case of an extraneous group closing symbol (such as a stray ')').
1256 * That is, we skip a closing symbol if we are not in a grouping production.
1257 * - '=' in a `Writable` context
1258 * - In this context, we are able to recover after seeing the `=` operator, which
1259 * signals the presence of an independent rvalue expression following the `=` operator.
1260 *
1261 * If a production expects one of these token it increments the corresponding nesting count,
1262 * and then decrements it just prior to checking if the token is in the input.
1263 */
1264 _ParseAST.prototype.skip = function () {
1265 var n = this.next;
1266 while (this.index < this.tokens.length && !n.isCharacter(chars.$SEMICOLON) &&
1267 !n.isOperator('|') && (this.rparensExpected <= 0 || !n.isCharacter(chars.$RPAREN)) &&
1268 (this.rbracesExpected <= 0 || !n.isCharacter(chars.$RBRACE)) &&
1269 (this.rbracketsExpected <= 0 || !n.isCharacter(chars.$RBRACKET)) &&
1270 (!(this.context & ParseContextFlags.Writable) || !n.isOperator('='))) {
1271 if (this.next.isError()) {
1272 this.errors.push(new ast_1.ParserError(this.next.toString(), this.input, this.locationText(), this.location));
1273 }
1274 this.advance();
1275 n = this.next;
1276 }
1277 };
1278 return _ParseAST;
1279 }());
1280 exports._ParseAST = _ParseAST;
1281 var SimpleExpressionChecker = /** @class */ (function () {
1282 function SimpleExpressionChecker() {
1283 this.errors = [];
1284 }
1285 SimpleExpressionChecker.prototype.visitImplicitReceiver = function (ast, context) { };
1286 SimpleExpressionChecker.prototype.visitThisReceiver = function (ast, context) { };
1287 SimpleExpressionChecker.prototype.visitInterpolation = function (ast, context) { };
1288 SimpleExpressionChecker.prototype.visitLiteralPrimitive = function (ast, context) { };
1289 SimpleExpressionChecker.prototype.visitPropertyRead = function (ast, context) { };
1290 SimpleExpressionChecker.prototype.visitPropertyWrite = function (ast, context) { };
1291 SimpleExpressionChecker.prototype.visitSafePropertyRead = function (ast, context) { };
1292 SimpleExpressionChecker.prototype.visitMethodCall = function (ast, context) { };
1293 SimpleExpressionChecker.prototype.visitSafeMethodCall = function (ast, context) { };
1294 SimpleExpressionChecker.prototype.visitFunctionCall = function (ast, context) { };
1295 SimpleExpressionChecker.prototype.visitLiteralArray = function (ast, context) {
1296 this.visitAll(ast.expressions, context);
1297 };
1298 SimpleExpressionChecker.prototype.visitLiteralMap = function (ast, context) {
1299 this.visitAll(ast.values, context);
1300 };
1301 SimpleExpressionChecker.prototype.visitUnary = function (ast, context) { };
1302 SimpleExpressionChecker.prototype.visitBinary = function (ast, context) { };
1303 SimpleExpressionChecker.prototype.visitPrefixNot = function (ast, context) { };
1304 SimpleExpressionChecker.prototype.visitNonNullAssert = function (ast, context) { };
1305 SimpleExpressionChecker.prototype.visitConditional = function (ast, context) { };
1306 SimpleExpressionChecker.prototype.visitPipe = function (ast, context) {
1307 this.errors.push('pipes');
1308 };
1309 SimpleExpressionChecker.prototype.visitKeyedRead = function (ast, context) { };
1310 SimpleExpressionChecker.prototype.visitKeyedWrite = function (ast, context) { };
1311 SimpleExpressionChecker.prototype.visitAll = function (asts, context) {
1312 var _this = this;
1313 return asts.map(function (node) { return node.visit(_this, context); });
1314 };
1315 SimpleExpressionChecker.prototype.visitChain = function (ast, context) { };
1316 SimpleExpressionChecker.prototype.visitQuote = function (ast, context) { };
1317 SimpleExpressionChecker.prototype.visitSafeKeyedRead = function (ast, context) { };
1318 return SimpleExpressionChecker;
1319 }());
1320 /**
1321 * This class implements SimpleExpressionChecker used in View Engine and performs more strict checks
1322 * to make sure host bindings do not contain pipes. In View Engine, having pipes in host bindings is
1323 * not supported as well, but in some cases (like `!(value | async)`) the error is not triggered at
1324 * compile time. In order to preserve View Engine behavior, more strict checks are introduced for
1325 * Ivy mode only.
1326 */
1327 var IvySimpleExpressionChecker = /** @class */ (function (_super) {
1328 tslib_1.__extends(IvySimpleExpressionChecker, _super);
1329 function IvySimpleExpressionChecker() {
1330 var _this = _super !== null && _super.apply(this, arguments) || this;
1331 _this.errors = [];
1332 return _this;
1333 }
1334 IvySimpleExpressionChecker.prototype.visitPipe = function () {
1335 this.errors.push('pipes');
1336 };
1337 return IvySimpleExpressionChecker;
1338 }(ast_1.RecursiveAstVisitor));
1339});
1340//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parser.js","sourceRoot":"","sources":["../../../../../../../packages/compiler/src/expression_parser/parser.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as chars from '../chars';\nimport {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from '../ml_parser/interpolation_config';\n\nimport {AbsoluteSourceSpan, AST, AstVisitor, ASTWithSource, Binary, BindingPipe, Chain, Conditional, EmptyExpr, ExpressionBinding, FunctionCall, ImplicitReceiver, Interpolation, KeyedRead, KeyedWrite, LiteralArray, LiteralMap, LiteralMapKey, LiteralPrimitive, MethodCall, NonNullAssert, ParserError, ParseSpan, PrefixNot, PropertyRead, PropertyWrite, Quote, RecursiveAstVisitor, SafeKeyedRead, SafeMethodCall, SafePropertyRead, TemplateBinding, TemplateBindingIdentifier, ThisReceiver, Unary, VariableBinding} from './ast';\nimport {EOF, isIdentifier, Lexer, Token, TokenType} from './lexer';\n\nexport interface InterpolationPiece {\n  text: string;\n  start: number;\n  end: number;\n}\nexport class SplitInterpolation {\n  constructor(\n      public strings: InterpolationPiece[], public expressions: InterpolationPiece[],\n      public offsets: number[]) {}\n}\n\nexport class TemplateBindingParseResult {\n  constructor(\n      public templateBindings: TemplateBinding[], public warnings: string[],\n      public errors: ParserError[]) {}\n}\n\nexport class Parser {\n  private errors: ParserError[] = [];\n\n  constructor(private _lexer: Lexer) {}\n\n  simpleExpressionChecker = SimpleExpressionChecker;\n\n  parseAction(\n      input: string, location: string, absoluteOffset: number,\n      interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): ASTWithSource {\n    this._checkNoInterpolation(input, location, interpolationConfig);\n    const sourceToLex = this._stripComments(input);\n    const tokens = this._lexer.tokenize(this._stripComments(input));\n    const ast = new _ParseAST(\n                    input, location, absoluteOffset, tokens, sourceToLex.length, true, this.errors,\n                    input.length - sourceToLex.length)\n                    .parseChain();\n    return new ASTWithSource(ast, input, location, absoluteOffset, this.errors);\n  }\n\n  parseBinding(\n      input: string, location: string, absoluteOffset: number,\n      interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): ASTWithSource {\n    const ast = this._parseBindingAst(input, location, absoluteOffset, interpolationConfig);\n    return new ASTWithSource(ast, input, location, absoluteOffset, this.errors);\n  }\n\n  private checkSimpleExpression(ast: AST): string[] {\n    const checker = new this.simpleExpressionChecker();\n    ast.visit(checker);\n    return checker.errors;\n  }\n\n  parseSimpleBinding(\n      input: string, location: string, absoluteOffset: number,\n      interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): ASTWithSource {\n    const ast = this._parseBindingAst(input, location, absoluteOffset, interpolationConfig);\n    const errors = this.checkSimpleExpression(ast);\n    if (errors.length > 0) {\n      this._reportError(\n          `Host binding expression cannot contain ${errors.join(' ')}`, input, location);\n    }\n    return new ASTWithSource(ast, input, location, absoluteOffset, this.errors);\n  }\n\n  private _reportError(message: string, input: string, errLocation: string, ctxLocation?: string) {\n    this.errors.push(new ParserError(message, input, errLocation, ctxLocation));\n  }\n\n  private _parseBindingAst(\n      input: string, location: string, absoluteOffset: number,\n      interpolationConfig: InterpolationConfig): AST {\n    // Quotes expressions use 3rd-party expression language. We don't want to use\n    // our lexer or parser for that, so we check for that ahead of time.\n    const quote = this._parseQuote(input, location, absoluteOffset);\n\n    if (quote != null) {\n      return quote;\n    }\n\n    this._checkNoInterpolation(input, location, interpolationConfig);\n    const sourceToLex = this._stripComments(input);\n    const tokens = this._lexer.tokenize(sourceToLex);\n    return new _ParseAST(\n               input, location, absoluteOffset, tokens, sourceToLex.length, false, this.errors,\n               input.length - sourceToLex.length)\n        .parseChain();\n  }\n\n  private _parseQuote(input: string|null, location: string, absoluteOffset: number): AST|null {\n    if (input == null) return null;\n    const prefixSeparatorIndex = input.indexOf(':');\n    if (prefixSeparatorIndex == -1) return null;\n    const prefix = input.substring(0, prefixSeparatorIndex).trim();\n    if (!isIdentifier(prefix)) return null;\n    const uninterpretedExpression = input.substring(prefixSeparatorIndex + 1);\n    const span = new ParseSpan(0, input.length);\n    return new Quote(\n        span, span.toAbsolute(absoluteOffset), prefix, uninterpretedExpression, location);\n  }\n\n  /**\n   * Parse microsyntax template expression and return a list of bindings or\n   * parsing errors in case the given expression is invalid.\n   *\n   * For example,\n   * ```\n   *   <div *ngFor=\"let item of items\">\n   *         ^      ^ absoluteValueOffset for `templateValue`\n   *         absoluteKeyOffset for `templateKey`\n   * ```\n   * contains three bindings:\n   * 1. ngFor -> null\n   * 2. item -> NgForOfContext.$implicit\n   * 3. ngForOf -> items\n   *\n   * This is apparent from the de-sugared template:\n   * ```\n   *   <ng-template ngFor let-item [ngForOf]=\"items\">\n   * ```\n   *\n   * @param templateKey name of directive, without the * prefix. For example: ngIf, ngFor\n   * @param templateValue RHS of the microsyntax attribute\n   * @param templateUrl template filename if it's external, component filename if it's inline\n   * @param absoluteKeyOffset start of the `templateKey`\n   * @param absoluteValueOffset start of the `templateValue`\n   */\n  parseTemplateBindings(\n      templateKey: string, templateValue: string, templateUrl: string, absoluteKeyOffset: number,\n      absoluteValueOffset: number): TemplateBindingParseResult {\n    const tokens = this._lexer.tokenize(templateValue);\n    const parser = new _ParseAST(\n        templateValue, templateUrl, absoluteValueOffset, tokens, templateValue.length,\n        false /* parseAction */, this.errors, 0 /* relative offset */);\n    return parser.parseTemplateBindings({\n      source: templateKey,\n      span: new AbsoluteSourceSpan(absoluteKeyOffset, absoluteKeyOffset + templateKey.length),\n    });\n  }\n\n  parseInterpolation(\n      input: string, location: string, absoluteOffset: number,\n      interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): ASTWithSource|null {\n    const {strings, expressions, offsets} =\n        this.splitInterpolation(input, location, interpolationConfig);\n    if (expressions.length === 0) return null;\n\n    const expressionNodes: AST[] = [];\n\n    for (let i = 0; i < expressions.length; ++i) {\n      const expressionText = expressions[i].text;\n      const sourceToLex = this._stripComments(expressionText);\n      const tokens = this._lexer.tokenize(sourceToLex);\n      const ast = new _ParseAST(\n                      input, location, absoluteOffset, tokens, sourceToLex.length, false,\n                      this.errors, offsets[i] + (expressionText.length - sourceToLex.length))\n                      .parseChain();\n      expressionNodes.push(ast);\n    }\n\n    return this.createInterpolationAst(\n        strings.map(s => s.text), expressionNodes, input, location, absoluteOffset);\n  }\n\n  /**\n   * Similar to `parseInterpolation`, but treats the provided string as a single expression\n   * element that would normally appear within the interpolation prefix and suffix (`{{` and `}}`).\n   * This is used for parsing the switch expression in ICUs.\n   */\n  parseInterpolationExpression(expression: string, location: string, absoluteOffset: number):\n      ASTWithSource {\n    const sourceToLex = this._stripComments(expression);\n    const tokens = this._lexer.tokenize(sourceToLex);\n    const ast = new _ParseAST(\n                    expression, location, absoluteOffset, tokens, sourceToLex.length,\n                    /* parseAction */ false, this.errors, 0)\n                    .parseChain();\n    const strings = ['', ''];  // The prefix and suffix strings are both empty\n    return this.createInterpolationAst(strings, [ast], expression, location, absoluteOffset);\n  }\n\n  private createInterpolationAst(\n      strings: string[], expressions: AST[], input: string, location: string,\n      absoluteOffset: number): ASTWithSource {\n    const span = new ParseSpan(0, input.length);\n    const interpolation =\n        new Interpolation(span, span.toAbsolute(absoluteOffset), strings, expressions);\n    return new ASTWithSource(interpolation, input, location, absoluteOffset, this.errors);\n  }\n\n  /**\n   * Splits a string of text into \"raw\" text segments and expressions present in interpolations in\n   * the string.\n   * Returns `null` if there are no interpolations, otherwise a\n   * `SplitInterpolation` with splits that look like\n   *   <raw text> <expression> <raw text> ... <raw text> <expression> <raw text>\n   */\n  splitInterpolation(\n      input: string, location: string,\n      interpolationConfig: InterpolationConfig = DEFAULT_INTERPOLATION_CONFIG): SplitInterpolation {\n    const strings: InterpolationPiece[] = [];\n    const expressions: InterpolationPiece[] = [];\n    const offsets: number[] = [];\n    let i = 0;\n    let atInterpolation = false;\n    let extendLastString = false;\n    let {start: interpStart, end: interpEnd} = interpolationConfig;\n    while (i < input.length) {\n      if (!atInterpolation) {\n        // parse until starting {{\n        const start = i;\n        i = input.indexOf(interpStart, i);\n        if (i === -1) {\n          i = input.length;\n        }\n        const text = input.substring(start, i);\n        strings.push({text, start, end: i});\n\n        atInterpolation = true;\n      } else {\n        // parse from starting {{ to ending }} while ignoring content inside quotes.\n        const fullStart = i;\n        const exprStart = fullStart + interpStart.length;\n        const exprEnd = this._getInterpolationEndIndex(input, interpEnd, exprStart);\n        if (exprEnd === -1) {\n          // Could not find the end of the interpolation; do not parse an expression.\n          // Instead we should extend the content on the last raw string.\n          atInterpolation = false;\n          extendLastString = true;\n          break;\n        }\n        const fullEnd = exprEnd + interpEnd.length;\n\n        const text = input.substring(exprStart, exprEnd);\n        if (text.trim().length === 0) {\n          this._reportError(\n              'Blank expressions are not allowed in interpolated strings', input,\n              `at column ${i} in`, location);\n        }\n        expressions.push({text, start: fullStart, end: fullEnd});\n        offsets.push(exprStart);\n\n        i = fullEnd;\n        atInterpolation = false;\n      }\n    }\n    if (!atInterpolation) {\n      // If we are now at a text section, add the remaining content as a raw string.\n      if (extendLastString) {\n        const piece = strings[strings.length - 1];\n        piece.text += input.substring(i);\n        piece.end = input.length;\n      } else {\n        strings.push({text: input.substring(i), start: i, end: input.length});\n      }\n    }\n    return new SplitInterpolation(strings, expressions, offsets);\n  }\n\n  wrapLiteralPrimitive(input: string|null, location: string, absoluteOffset: number):\n      ASTWithSource {\n    const span = new ParseSpan(0, input == null ? 0 : input.length);\n    return new ASTWithSource(\n        new LiteralPrimitive(span, span.toAbsolute(absoluteOffset), input), input, location,\n        absoluteOffset, this.errors);\n  }\n\n  private _stripComments(input: string): string {\n    const i = this._commentStart(input);\n    return i != null ? input.substring(0, i).trim() : input;\n  }\n\n  private _commentStart(input: string): number|null {\n    let outerQuote: number|null = null;\n    for (let i = 0; i < input.length - 1; i++) {\n      const char = input.charCodeAt(i);\n      const nextChar = input.charCodeAt(i + 1);\n\n      if (char === chars.$SLASH && nextChar == chars.$SLASH && outerQuote == null) return i;\n\n      if (outerQuote === char) {\n        outerQuote = null;\n      } else if (outerQuote == null && chars.isQuote(char)) {\n        outerQuote = char;\n      }\n    }\n    return null;\n  }\n\n  private _checkNoInterpolation(input: string, location: string, {start, end}: InterpolationConfig):\n      void {\n    let startIndex = -1;\n    let endIndex = -1;\n\n    for (const charIndex of this._forEachUnquotedChar(input, 0)) {\n      if (startIndex === -1) {\n        if (input.startsWith(start)) {\n          startIndex = charIndex;\n        }\n      } else {\n        endIndex = this._getInterpolationEndIndex(input, end, charIndex);\n        if (endIndex > -1) {\n          break;\n        }\n      }\n    }\n\n    if (startIndex > -1 && endIndex > -1) {\n      this._reportError(\n          `Got interpolation (${start}${end}) where expression was expected`, input,\n          `at column ${startIndex} in`, location);\n    }\n  }\n\n  /**\n   * Finds the index of the end of an interpolation expression\n   * while ignoring comments and quoted content.\n   */\n  private _getInterpolationEndIndex(input: string, expressionEnd: string, start: number): number {\n    for (const charIndex of this._forEachUnquotedChar(input, start)) {\n      if (input.startsWith(expressionEnd, charIndex)) {\n        return charIndex;\n      }\n\n      // Nothing else in the expression matters after we've\n      // hit a comment so look directly for the end token.\n      if (input.startsWith('//', charIndex)) {\n        return input.indexOf(expressionEnd, charIndex);\n      }\n    }\n\n    return -1;\n  }\n\n  /**\n   * Generator used to iterate over the character indexes of a string that are outside of quotes.\n   * @param input String to loop through.\n   * @param start Index within the string at which to start.\n   */\n  private * _forEachUnquotedChar(input: string, start: number) {\n    let currentQuote: string|null = null;\n    let escapeCount = 0;\n    for (let i = start; i < input.length; i++) {\n      const char = input[i];\n      // Skip the characters inside quotes. Note that we only care about the outer-most\n      // quotes matching up and we need to account for escape characters.\n      if (chars.isQuote(input.charCodeAt(i)) && (currentQuote === null || currentQuote === char) &&\n          escapeCount % 2 === 0) {\n        currentQuote = currentQuote === null ? char : null;\n      } else if (currentQuote === null) {\n        yield i;\n      }\n      escapeCount = char === '\\\\' ? escapeCount + 1 : 0;\n    }\n  }\n}\n\nexport class IvyParser extends Parser {\n  override simpleExpressionChecker = IvySimpleExpressionChecker;\n}\n\n/** Describes a stateful context an expression parser is in. */\nenum ParseContextFlags {\n  None = 0,\n  /**\n   * A Writable context is one in which a value may be written to an lvalue.\n   * For example, after we see a property access, we may expect a write to the\n   * property via the \"=\" operator.\n   *   prop\n   *        ^ possible \"=\" after\n   */\n  Writable = 1,\n}\n\nexport class _ParseAST {\n  private rparensExpected = 0;\n  private rbracketsExpected = 0;\n  private rbracesExpected = 0;\n  private context = ParseContextFlags.None;\n\n  // Cache of expression start and input indeces to the absolute source span they map to, used to\n  // prevent creating superfluous source spans in `sourceSpan`.\n  // A serial of the expression start and input index is used for mapping because both are stateful\n  // and may change for subsequent expressions visited by the parser.\n  private sourceSpanCache = new Map<string, AbsoluteSourceSpan>();\n\n  index: number = 0;\n\n  constructor(\n      public input: string, public location: string, public absoluteOffset: number,\n      public tokens: Token[], public inputLength: number, public parseAction: boolean,\n      private errors: ParserError[], private offset: number) {}\n\n  peek(offset: number): Token {\n    const i = this.index + offset;\n    return i < this.tokens.length ? this.tokens[i] : EOF;\n  }\n\n  get next(): Token {\n    return this.peek(0);\n  }\n\n  /** Whether all the parser input has been processed. */\n  get atEOF(): boolean {\n    return this.index >= this.tokens.length;\n  }\n\n  /**\n   * Index of the next token to be processed, or the end of the last token if all have been\n   * processed.\n   */\n  get inputIndex(): number {\n    return this.atEOF ? this.currentEndIndex : this.next.index + this.offset;\n  }\n\n  /**\n   * End index of the last processed token, or the start of the first token if none have been\n   * processed.\n   */\n  get currentEndIndex(): number {\n    if (this.index > 0) {\n      const curToken = this.peek(-1);\n      return curToken.end + this.offset;\n    }\n    // No tokens have been processed yet; return the next token's start or the length of the input\n    // if there is no token.\n    if (this.tokens.length === 0) {\n      return this.inputLength + this.offset;\n    }\n    return this.next.index + this.offset;\n  }\n\n  /**\n   * Returns the absolute offset of the start of the current token.\n   */\n  get currentAbsoluteOffset(): number {\n    return this.absoluteOffset + this.inputIndex;\n  }\n\n  /**\n   * Retrieve a `ParseSpan` from `start` to the current position (or to `artificialEndIndex` if\n   * provided).\n   *\n   * @param start Position from which the `ParseSpan` will start.\n   * @param artificialEndIndex Optional ending index to be used if provided (and if greater than the\n   *     natural ending index)\n   */\n  span(start: number, artificialEndIndex?: number): ParseSpan {\n    let endIndex = this.currentEndIndex;\n    if (artificialEndIndex !== undefined && artificialEndIndex > this.currentEndIndex) {\n      endIndex = artificialEndIndex;\n    }\n\n    // In some unusual parsing scenarios (like when certain tokens are missing and an `EmptyExpr` is\n    // being created), the current token may already be advanced beyond the `currentEndIndex`. This\n    // appears to be a deep-seated parser bug.\n    //\n    // As a workaround for now, swap the start and end indices to ensure a valid `ParseSpan`.\n    // TODO(alxhub): fix the bug upstream in the parser state, and remove this workaround.\n    if (start > endIndex) {\n      const tmp = endIndex;\n      endIndex = start;\n      start = tmp;\n    }\n\n    return new ParseSpan(start, endIndex);\n  }\n\n  sourceSpan(start: number, artificialEndIndex?: number): AbsoluteSourceSpan {\n    const serial = `${start}@${this.inputIndex}:${artificialEndIndex}`;\n    if (!this.sourceSpanCache.has(serial)) {\n      this.sourceSpanCache.set(\n          serial, this.span(start, artificialEndIndex).toAbsolute(this.absoluteOffset));\n    }\n    return this.sourceSpanCache.get(serial)!;\n  }\n\n  advance() {\n    this.index++;\n  }\n\n  /**\n   * Executes a callback in the provided context.\n   */\n  private withContext<T>(context: ParseContextFlags, cb: () => T): T {\n    this.context |= context;\n    const ret = cb();\n    this.context ^= context;\n    return ret;\n  }\n\n  consumeOptionalCharacter(code: number): boolean {\n    if (this.next.isCharacter(code)) {\n      this.advance();\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  peekKeywordLet(): boolean {\n    return this.next.isKeywordLet();\n  }\n  peekKeywordAs(): boolean {\n    return this.next.isKeywordAs();\n  }\n\n  /**\n   * Consumes an expected character, otherwise emits an error about the missing expected character\n   * and skips over the token stream until reaching a recoverable point.\n   *\n   * See `this.error` and `this.skip` for more details.\n   */\n  expectCharacter(code: number) {\n    if (this.consumeOptionalCharacter(code)) return;\n    this.error(`Missing expected ${String.fromCharCode(code)}`);\n  }\n\n  consumeOptionalOperator(op: string): boolean {\n    if (this.next.isOperator(op)) {\n      this.advance();\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  expectOperator(operator: string) {\n    if (this.consumeOptionalOperator(operator)) return;\n    this.error(`Missing expected operator ${operator}`);\n  }\n\n  prettyPrintToken(tok: Token): string {\n    return tok === EOF ? 'end of input' : `token ${tok}`;\n  }\n\n  expectIdentifierOrKeyword(): string|null {\n    const n = this.next;\n    if (!n.isIdentifier() && !n.isKeyword()) {\n      if (n.isPrivateIdentifier()) {\n        this._reportErrorForPrivateIdentifier(n, 'expected identifier or keyword');\n      } else {\n        this.error(`Unexpected ${this.prettyPrintToken(n)}, expected identifier or keyword`);\n      }\n      return null;\n    }\n    this.advance();\n    return n.toString() as string;\n  }\n\n  expectIdentifierOrKeywordOrString(): string {\n    const n = this.next;\n    if (!n.isIdentifier() && !n.isKeyword() && !n.isString()) {\n      if (n.isPrivateIdentifier()) {\n        this._reportErrorForPrivateIdentifier(n, 'expected identifier, keyword or string');\n      } else {\n        this.error(\n            `Unexpected ${this.prettyPrintToken(n)}, expected identifier, keyword, or string`);\n      }\n      return '';\n    }\n    this.advance();\n    return n.toString() as string;\n  }\n\n  parseChain(): AST {\n    const exprs: AST[] = [];\n    const start = this.inputIndex;\n    while (this.index < this.tokens.length) {\n      const expr = this.parsePipe();\n      exprs.push(expr);\n\n      if (this.consumeOptionalCharacter(chars.$SEMICOLON)) {\n        if (!this.parseAction) {\n          this.error('Binding expression cannot contain chained expression');\n        }\n        while (this.consumeOptionalCharacter(chars.$SEMICOLON)) {\n        }  // read all semicolons\n      } else if (this.index < this.tokens.length) {\n        this.error(`Unexpected token '${this.next}'`);\n      }\n    }\n    if (exprs.length == 0) {\n      // We have no expressions so create an empty expression that spans the entire input length\n      const artificialStart = this.offset;\n      const artificialEnd = this.offset + this.inputLength;\n      return new EmptyExpr(\n          this.span(artificialStart, artificialEnd),\n          this.sourceSpan(artificialStart, artificialEnd));\n    }\n    if (exprs.length == 1) return exprs[0];\n    return new Chain(this.span(start), this.sourceSpan(start), exprs);\n  }\n\n  parsePipe(): AST {\n    const start = this.inputIndex;\n    let result = this.parseExpression();\n    if (this.consumeOptionalOperator('|')) {\n      if (this.parseAction) {\n        this.error('Cannot have a pipe in an action expression');\n      }\n\n      do {\n        const nameStart = this.inputIndex;\n        let nameId = this.expectIdentifierOrKeyword();\n        let nameSpan: AbsoluteSourceSpan;\n        let fullSpanEnd: number|undefined = undefined;\n        if (nameId !== null) {\n          nameSpan = this.sourceSpan(nameStart);\n        } else {\n          // No valid identifier was found, so we'll assume an empty pipe name ('').\n          nameId = '';\n\n          // However, there may have been whitespace present between the pipe character and the next\n          // token in the sequence (or the end of input). We want to track this whitespace so that\n          // the `BindingPipe` we produce covers not just the pipe character, but any trailing\n          // whitespace beyond it. Another way of thinking about this is that the zero-length name\n          // is assumed to be at the end of any whitespace beyond the pipe character.\n          //\n          // Therefore, we push the end of the `ParseSpan` for this pipe all the way up to the\n          // beginning of the next token, or until the end of input if the next token is EOF.\n          fullSpanEnd = this.next.index !== -1 ? this.next.index : this.inputLength + this.offset;\n\n          // The `nameSpan` for an empty pipe name is zero-length at the end of any whitespace\n          // beyond the pipe character.\n          nameSpan = new ParseSpan(fullSpanEnd, fullSpanEnd).toAbsolute(this.absoluteOffset);\n        }\n\n        const args: AST[] = [];\n        while (this.consumeOptionalCharacter(chars.$COLON)) {\n          args.push(this.parseExpression());\n\n          // If there are additional expressions beyond the name, then the artificial end for the\n          // name is no longer relevant.\n        }\n        result = new BindingPipe(\n            this.span(start), this.sourceSpan(start, fullSpanEnd), result, nameId, args, nameSpan);\n      } while (this.consumeOptionalOperator('|'));\n    }\n\n    return result;\n  }\n\n  parseExpression(): AST {\n    return this.parseConditional();\n  }\n\n  parseConditional(): AST {\n    const start = this.inputIndex;\n    const result = this.parseLogicalOr();\n\n    if (this.consumeOptionalOperator('?')) {\n      const yes = this.parsePipe();\n      let no: AST;\n      if (!this.consumeOptionalCharacter(chars.$COLON)) {\n        const end = this.inputIndex;\n        const expression = this.input.substring(start, end);\n        this.error(`Conditional expression ${expression} requires all 3 expressions`);\n        no = new EmptyExpr(this.span(start), this.sourceSpan(start));\n      } else {\n        no = this.parsePipe();\n      }\n      return new Conditional(this.span(start), this.sourceSpan(start), result, yes, no);\n    } else {\n      return result;\n    }\n  }\n\n  parseLogicalOr(): AST {\n    // '||'\n    const start = this.inputIndex;\n    let result = this.parseLogicalAnd();\n    while (this.consumeOptionalOperator('||')) {\n      const right = this.parseLogicalAnd();\n      result = new Binary(this.span(start), this.sourceSpan(start), '||', result, right);\n    }\n    return result;\n  }\n\n  parseLogicalAnd(): AST {\n    // '&&'\n    const start = this.inputIndex;\n    let result = this.parseNullishCoalescing();\n    while (this.consumeOptionalOperator('&&')) {\n      const right = this.parseNullishCoalescing();\n      result = new Binary(this.span(start), this.sourceSpan(start), '&&', result, right);\n    }\n    return result;\n  }\n\n  parseNullishCoalescing(): AST {\n    // '??'\n    const start = this.inputIndex;\n    let result = this.parseEquality();\n    while (this.consumeOptionalOperator('??')) {\n      const right = this.parseEquality();\n      result = new Binary(this.span(start), this.sourceSpan(start), '??', result, right);\n    }\n    return result;\n  }\n\n  parseEquality(): AST {\n    // '==','!=','===','!=='\n    const start = this.inputIndex;\n    let result = this.parseRelational();\n    while (this.next.type == TokenType.Operator) {\n      const operator = this.next.strValue;\n      switch (operator) {\n        case '==':\n        case '===':\n        case '!=':\n        case '!==':\n          this.advance();\n          const right = this.parseRelational();\n          result = new Binary(this.span(start), this.sourceSpan(start), operator, result, right);\n          continue;\n      }\n      break;\n    }\n    return result;\n  }\n\n  parseRelational(): AST {\n    // '<', '>', '<=', '>='\n    const start = this.inputIndex;\n    let result = this.parseAdditive();\n    while (this.next.type == TokenType.Operator) {\n      const operator = this.next.strValue;\n      switch (operator) {\n        case '<':\n        case '>':\n        case '<=':\n        case '>=':\n          this.advance();\n          const right = this.parseAdditive();\n          result = new Binary(this.span(start), this.sourceSpan(start), operator, result, right);\n          continue;\n      }\n      break;\n    }\n    return result;\n  }\n\n  parseAdditive(): AST {\n    // '+', '-'\n    const start = this.inputIndex;\n    let result = this.parseMultiplicative();\n    while (this.next.type == TokenType.Operator) {\n      const operator = this.next.strValue;\n      switch (operator) {\n        case '+':\n        case '-':\n          this.advance();\n          let right = this.parseMultiplicative();\n          result = new Binary(this.span(start), this.sourceSpan(start), operator, result, right);\n          continue;\n      }\n      break;\n    }\n    return result;\n  }\n\n  parseMultiplicative(): AST {\n    // '*', '%', '/'\n    const start = this.inputIndex;\n    let result = this.parsePrefix();\n    while (this.next.type == TokenType.Operator) {\n      const operator = this.next.strValue;\n      switch (operator) {\n        case '*':\n        case '%':\n        case '/':\n          this.advance();\n          let right = this.parsePrefix();\n          result = new Binary(this.span(start), this.sourceSpan(start), operator, result, right);\n          continue;\n      }\n      break;\n    }\n    return result;\n  }\n\n  parsePrefix(): AST {\n    if (this.next.type == TokenType.Operator) {\n      const start = this.inputIndex;\n      const operator = this.next.strValue;\n      let result: AST;\n      switch (operator) {\n        case '+':\n          this.advance();\n          result = this.parsePrefix();\n          return Unary.createPlus(this.span(start), this.sourceSpan(start), result);\n        case '-':\n          this.advance();\n          result = this.parsePrefix();\n          return Unary.createMinus(this.span(start), this.sourceSpan(start), result);\n        case '!':\n          this.advance();\n          result = this.parsePrefix();\n          return new PrefixNot(this.span(start), this.sourceSpan(start), result);\n      }\n    }\n    return this.parseCallChain();\n  }\n\n  parseCallChain(): AST {\n    const start = this.inputIndex;\n    let result = this.parsePrimary();\n    while (true) {\n      if (this.consumeOptionalCharacter(chars.$PERIOD)) {\n        result = this.parseAccessMemberOrMethodCall(result, start, false);\n\n      } else if (this.consumeOptionalOperator('?.')) {\n        result = this.consumeOptionalCharacter(chars.$LBRACKET) ?\n            this.parseKeyedReadOrWrite(result, start, true) :\n            this.parseAccessMemberOrMethodCall(result, start, true);\n      } else if (this.consumeOptionalCharacter(chars.$LBRACKET)) {\n        result = this.parseKeyedReadOrWrite(result, start, false);\n      } else if (this.consumeOptionalCharacter(chars.$LPAREN)) {\n        this.rparensExpected++;\n        const args = this.parseCallArguments();\n        this.rparensExpected--;\n        this.expectCharacter(chars.$RPAREN);\n        result = new FunctionCall(this.span(start), this.sourceSpan(start), result, args);\n\n      } else if (this.consumeOptionalOperator('!')) {\n        result = new NonNullAssert(this.span(start), this.sourceSpan(start), result);\n\n      } else {\n        return result;\n      }\n    }\n  }\n\n  parsePrimary(): AST {\n    const start = this.inputIndex;\n    if (this.consumeOptionalCharacter(chars.$LPAREN)) {\n      this.rparensExpected++;\n      const result = this.parsePipe();\n      this.rparensExpected--;\n      this.expectCharacter(chars.$RPAREN);\n      return result;\n\n    } else if (this.next.isKeywordNull()) {\n      this.advance();\n      return new LiteralPrimitive(this.span(start), this.sourceSpan(start), null);\n\n    } else if (this.next.isKeywordUndefined()) {\n      this.advance();\n      return new LiteralPrimitive(this.span(start), this.sourceSpan(start), void 0);\n\n    } else if (this.next.isKeywordTrue()) {\n      this.advance();\n      return new LiteralPrimitive(this.span(start), this.sourceSpan(start), true);\n\n    } else if (this.next.isKeywordFalse()) {\n      this.advance();\n      return new LiteralPrimitive(this.span(start), this.sourceSpan(start), false);\n\n    } else if (this.next.isKeywordThis()) {\n      this.advance();\n      return new ThisReceiver(this.span(start), this.sourceSpan(start));\n    } else if (this.consumeOptionalCharacter(chars.$LBRACKET)) {\n      this.rbracketsExpected++;\n      const elements = this.parseExpressionList(chars.$RBRACKET);\n      this.rbracketsExpected--;\n      this.expectCharacter(chars.$RBRACKET);\n      return new LiteralArray(this.span(start), this.sourceSpan(start), elements);\n\n    } else if (this.next.isCharacter(chars.$LBRACE)) {\n      return this.parseLiteralMap();\n\n    } else if (this.next.isIdentifier()) {\n      return this.parseAccessMemberOrMethodCall(\n          new ImplicitReceiver(this.span(start), this.sourceSpan(start)), start, false);\n\n    } else if (this.next.isNumber()) {\n      const value = this.next.toNumber();\n      this.advance();\n      return new LiteralPrimitive(this.span(start), this.sourceSpan(start), value);\n\n    } else if (this.next.isString()) {\n      const literalValue = this.next.toString();\n      this.advance();\n      return new LiteralPrimitive(this.span(start), this.sourceSpan(start), literalValue);\n\n    } else if (this.next.isPrivateIdentifier()) {\n      this._reportErrorForPrivateIdentifier(this.next, null);\n      return new EmptyExpr(this.span(start), this.sourceSpan(start));\n\n    } else if (this.index >= this.tokens.length) {\n      this.error(`Unexpected end of expression: ${this.input}`);\n      return new EmptyExpr(this.span(start), this.sourceSpan(start));\n    } else {\n      this.error(`Unexpected token ${this.next}`);\n      return new EmptyExpr(this.span(start), this.sourceSpan(start));\n    }\n  }\n\n  parseExpressionList(terminator: number): AST[] {\n    const result: AST[] = [];\n\n    do {\n      if (!this.next.isCharacter(terminator)) {\n        result.push(this.parsePipe());\n      } else {\n        break;\n      }\n    } while (this.consumeOptionalCharacter(chars.$COMMA));\n    return result;\n  }\n\n  parseLiteralMap(): LiteralMap {\n    const keys: LiteralMapKey[] = [];\n    const values: AST[] = [];\n    const start = this.inputIndex;\n    this.expectCharacter(chars.$LBRACE);\n    if (!this.consumeOptionalCharacter(chars.$RBRACE)) {\n      this.rbracesExpected++;\n      do {\n        const keyStart = this.inputIndex;\n        const quoted = this.next.isString();\n        const key = this.expectIdentifierOrKeywordOrString();\n        keys.push({key, quoted});\n\n        // Properties with quoted keys can't use the shorthand syntax.\n        if (quoted) {\n          this.expectCharacter(chars.$COLON);\n          values.push(this.parsePipe());\n        } else if (this.consumeOptionalCharacter(chars.$COLON)) {\n          values.push(this.parsePipe());\n        } else {\n          const span = this.span(keyStart);\n          const sourceSpan = this.sourceSpan(keyStart);\n          values.push(new PropertyRead(\n              span, sourceSpan, sourceSpan, new ImplicitReceiver(span, sourceSpan), key));\n        }\n      } while (this.consumeOptionalCharacter(chars.$COMMA));\n      this.rbracesExpected--;\n      this.expectCharacter(chars.$RBRACE);\n    }\n    return new LiteralMap(this.span(start), this.sourceSpan(start), keys, values);\n  }\n\n  parseAccessMemberOrMethodCall(receiver: AST, start: number, isSafe: boolean): AST {\n    const nameStart = this.inputIndex;\n    const id = this.withContext(ParseContextFlags.Writable, () => {\n      const id = this.expectIdentifierOrKeyword() ?? '';\n      if (id.length === 0) {\n        this.error(`Expected identifier for property access`, receiver.span.end);\n      }\n      return id;\n    });\n    const nameSpan = this.sourceSpan(nameStart);\n\n    if (this.consumeOptionalCharacter(chars.$LPAREN)) {\n      const argumentStart = this.inputIndex;\n      this.rparensExpected++;\n      const args = this.parseCallArguments();\n      const argumentSpan =\n          this.span(argumentStart, this.inputIndex).toAbsolute(this.absoluteOffset);\n\n      this.expectCharacter(chars.$RPAREN);\n      this.rparensExpected--;\n      const span = this.span(start);\n      const sourceSpan = this.sourceSpan(start);\n      return isSafe ?\n          new SafeMethodCall(span, sourceSpan, nameSpan, receiver, id, args, argumentSpan) :\n          new MethodCall(span, sourceSpan, nameSpan, receiver, id, args, argumentSpan);\n\n    } else {\n      if (isSafe) {\n        if (this.consumeOptionalOperator('=')) {\n          this.error('The \\'?.\\' operator cannot be used in the assignment');\n          return new EmptyExpr(this.span(start), this.sourceSpan(start));\n        } else {\n          return new SafePropertyRead(\n              this.span(start), this.sourceSpan(start), nameSpan, receiver, id);\n        }\n      } else {\n        if (this.consumeOptionalOperator('=')) {\n          if (!this.parseAction) {\n            this.error('Bindings cannot contain assignments');\n            return new EmptyExpr(this.span(start), this.sourceSpan(start));\n          }\n\n          const value = this.parseConditional();\n          return new PropertyWrite(\n              this.span(start), this.sourceSpan(start), nameSpan, receiver, id, value);\n        } else {\n          return new PropertyRead(this.span(start), this.sourceSpan(start), nameSpan, receiver, id);\n        }\n      }\n    }\n  }\n\n  parseCallArguments(): BindingPipe[] {\n    if (this.next.isCharacter(chars.$RPAREN)) return [];\n    const positionals: AST[] = [];\n    do {\n      positionals.push(this.parsePipe());\n    } while (this.consumeOptionalCharacter(chars.$COMMA));\n    return positionals as BindingPipe[];\n  }\n\n  /**\n   * Parses an identifier, a keyword, a string with an optional `-` in between,\n   * and returns the string along with its absolute source span.\n   */\n  expectTemplateBindingKey(): TemplateBindingIdentifier {\n    let result = '';\n    let operatorFound = false;\n    const start = this.currentAbsoluteOffset;\n    do {\n      result += this.expectIdentifierOrKeywordOrString();\n      operatorFound = this.consumeOptionalOperator('-');\n      if (operatorFound) {\n        result += '-';\n      }\n    } while (operatorFound);\n    return {\n      source: result,\n      span: new AbsoluteSourceSpan(start, start + result.length),\n    };\n  }\n\n  /**\n   * Parse microsyntax template expression and return a list of bindings or\n   * parsing errors in case the given expression is invalid.\n   *\n   * For example,\n   * ```\n   *   <div *ngFor=\"let item of items; index as i; trackBy: func\">\n   * ```\n   * contains five bindings:\n   * 1. ngFor -> null\n   * 2. item -> NgForOfContext.$implicit\n   * 3. ngForOf -> items\n   * 4. i -> NgForOfContext.index\n   * 5. ngForTrackBy -> func\n   *\n   * For a full description of the microsyntax grammar, see\n   * https://gist.github.com/mhevery/d3530294cff2e4a1b3fe15ff75d08855\n   *\n   * @param templateKey name of the microsyntax directive, like ngIf, ngFor,\n   * without the *, along with its absolute span.\n   */\n  parseTemplateBindings(templateKey: TemplateBindingIdentifier): TemplateBindingParseResult {\n    const bindings: TemplateBinding[] = [];\n\n    // The first binding is for the template key itself\n    // In *ngFor=\"let item of items\", key = \"ngFor\", value = null\n    // In *ngIf=\"cond | pipe\", key = \"ngIf\", value = \"cond | pipe\"\n    bindings.push(...this.parseDirectiveKeywordBindings(templateKey));\n\n    while (this.index < this.tokens.length) {\n      // If it starts with 'let', then this must be variable declaration\n      const letBinding = this.parseLetBinding();\n      if (letBinding) {\n        bindings.push(letBinding);\n      } else {\n        // Two possible cases here, either `value \"as\" key` or\n        // \"directive-keyword expression\". We don't know which case, but both\n        // \"value\" and \"directive-keyword\" are template binding key, so consume\n        // the key first.\n        const key = this.expectTemplateBindingKey();\n        // Peek at the next token, if it is \"as\" then this must be variable\n        // declaration.\n        const binding = this.parseAsBinding(key);\n        if (binding) {\n          bindings.push(binding);\n        } else {\n          // Otherwise the key must be a directive keyword, like \"of\". Transform\n          // the key to actual key. Eg. of -> ngForOf, trackBy -> ngForTrackBy\n          key.source =\n              templateKey.source + key.source.charAt(0).toUpperCase() + key.source.substring(1);\n          bindings.push(...this.parseDirectiveKeywordBindings(key));\n        }\n      }\n      this.consumeStatementTerminator();\n    }\n\n    return new TemplateBindingParseResult(bindings, [] /* warnings */, this.errors);\n  }\n\n  parseKeyedReadOrWrite(receiver: AST, start: number, isSafe: boolean): AST {\n    return this.withContext(ParseContextFlags.Writable, () => {\n      this.rbracketsExpected++;\n      const key = this.parsePipe();\n      if (key instanceof EmptyExpr) {\n        this.error(`Key access cannot be empty`);\n      }\n      this.rbracketsExpected--;\n      this.expectCharacter(chars.$RBRACKET);\n      if (this.consumeOptionalOperator('=')) {\n        if (isSafe) {\n          this.error('The \\'?.\\' operator cannot be used in the assignment');\n        } else {\n          const value = this.parseConditional();\n          return new KeyedWrite(this.span(start), this.sourceSpan(start), receiver, key, value);\n        }\n      } else {\n        return isSafe ? new SafeKeyedRead(this.span(start), this.sourceSpan(start), receiver, key) :\n                        new KeyedRead(this.span(start), this.sourceSpan(start), receiver, key);\n      }\n\n      return new EmptyExpr(this.span(start), this.sourceSpan(start));\n    });\n  }\n\n  /**\n   * Parse a directive keyword, followed by a mandatory expression.\n   * For example, \"of items\", \"trackBy: func\".\n   * The bindings are: ngForOf -> items, ngForTrackBy -> func\n   * There could be an optional \"as\" binding that follows the expression.\n   * For example,\n   * ```\n   *   *ngFor=\"let item of items | slice:0:1 as collection\".\n   *                    ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^\n   *               keyword    bound target   optional 'as' binding\n   * ```\n   *\n   * @param key binding key, for example, ngFor, ngIf, ngForOf, along with its\n   * absolute span.\n   */\n  private parseDirectiveKeywordBindings(key: TemplateBindingIdentifier): TemplateBinding[] {\n    const bindings: TemplateBinding[] = [];\n    this.consumeOptionalCharacter(chars.$COLON);  // trackBy: trackByFunction\n    const value = this.getDirectiveBoundTarget();\n    let spanEnd = this.currentAbsoluteOffset;\n    // The binding could optionally be followed by \"as\". For example,\n    // *ngIf=\"cond | pipe as x\". In this case, the key in the \"as\" binding\n    // is \"x\" and the value is the template key itself (\"ngIf\"). Note that the\n    // 'key' in the current context now becomes the \"value\" in the next binding.\n    const asBinding = this.parseAsBinding(key);\n    if (!asBinding) {\n      this.consumeStatementTerminator();\n      spanEnd = this.currentAbsoluteOffset;\n    }\n    const sourceSpan = new AbsoluteSourceSpan(key.span.start, spanEnd);\n    bindings.push(new ExpressionBinding(sourceSpan, key, value));\n    if (asBinding) {\n      bindings.push(asBinding);\n    }\n    return bindings;\n  }\n\n  /**\n   * Return the expression AST for the bound target of a directive keyword\n   * binding. For example,\n   * ```\n   *   *ngIf=\"condition | pipe\"\n   *          ^^^^^^^^^^^^^^^^ bound target for \"ngIf\"\n   *   *ngFor=\"let item of items\"\n   *                       ^^^^^ bound target for \"ngForOf\"\n   * ```\n   */\n  private getDirectiveBoundTarget(): ASTWithSource|null {\n    if (this.next === EOF || this.peekKeywordAs() || this.peekKeywordLet()) {\n      return null;\n    }\n    const ast = this.parsePipe();  // example: \"condition | async\"\n    const {start, end} = ast.span;\n    const value = this.input.substring(start, end);\n    return new ASTWithSource(ast, value, this.location, this.absoluteOffset + start, this.errors);\n  }\n\n  /**\n   * Return the binding for a variable declared using `as`. Note that the order\n   * of the key-value pair in this declaration is reversed. For example,\n   * ```\n   *   *ngFor=\"let item of items; index as i\"\n   *                              ^^^^^    ^\n   *                              value    key\n   * ```\n   *\n   * @param value name of the value in the declaration, \"ngIf\" in the example\n   * above, along with its absolute span.\n   */\n  private parseAsBinding(value: TemplateBindingIdentifier): TemplateBinding|null {\n    if (!this.peekKeywordAs()) {\n      return null;\n    }\n    this.advance();  // consume the 'as' keyword\n    const key = this.expectTemplateBindingKey();\n    this.consumeStatementTerminator();\n    const sourceSpan = new AbsoluteSourceSpan(value.span.start, this.currentAbsoluteOffset);\n    return new VariableBinding(sourceSpan, key, value);\n  }\n\n  /**\n   * Return the binding for a variable declared using `let`. For example,\n   * ```\n   *   *ngFor=\"let item of items; let i=index;\"\n   *           ^^^^^^^^           ^^^^^^^^^^^\n   * ```\n   * In the first binding, `item` is bound to `NgForOfContext.$implicit`.\n   * In the second binding, `i` is bound to `NgForOfContext.index`.\n   */\n  private parseLetBinding(): TemplateBinding|null {\n    if (!this.peekKeywordLet()) {\n      return null;\n    }\n    const spanStart = this.currentAbsoluteOffset;\n    this.advance();  // consume the 'let' keyword\n    const key = this.expectTemplateBindingKey();\n    let value: TemplateBindingIdentifier|null = null;\n    if (this.consumeOptionalOperator('=')) {\n      value = this.expectTemplateBindingKey();\n    }\n    this.consumeStatementTerminator();\n    const sourceSpan = new AbsoluteSourceSpan(spanStart, this.currentAbsoluteOffset);\n    return new VariableBinding(sourceSpan, key, value);\n  }\n\n  /**\n   * Consume the optional statement terminator: semicolon or comma.\n   */\n  private consumeStatementTerminator() {\n    this.consumeOptionalCharacter(chars.$SEMICOLON) || this.consumeOptionalCharacter(chars.$COMMA);\n  }\n\n  /**\n   * Records an error and skips over the token stream until reaching a recoverable point. See\n   * `this.skip` for more details on token skipping.\n   */\n  error(message: string, index: number|null = null) {\n    this.errors.push(new ParserError(message, this.input, this.locationText(index), this.location));\n    this.skip();\n  }\n\n  private locationText(index: number|null = null) {\n    if (index == null) index = this.index;\n    return (index < this.tokens.length) ? `at column ${this.tokens[index].index + 1} in` :\n                                          `at the end of the expression`;\n  }\n\n  /**\n   * Records an error for an unexpected private identifier being discovered.\n   * @param token Token representing a private identifier.\n   * @param extraMessage Optional additional message being appended to the error.\n   */\n  private _reportErrorForPrivateIdentifier(token: Token, extraMessage: string|null) {\n    let errorMessage =\n        `Private identifiers are not supported. Unexpected private identifier: ${token}`;\n    if (extraMessage !== null) {\n      errorMessage += `, ${extraMessage}`;\n    }\n    this.error(errorMessage);\n  }\n\n  /**\n   * Error recovery should skip tokens until it encounters a recovery point.\n   *\n   * The following are treated as unconditional recovery points:\n   *   - end of input\n   *   - ';' (parseChain() is always the root production, and it expects a ';')\n   *   - '|' (since pipes may be chained and each pipe expression may be treated independently)\n   *\n   * The following are conditional recovery points:\n   *   - ')', '}', ']' if one of calling productions is expecting one of these symbols\n   *     - This allows skip() to recover from errors such as '(a.) + 1' allowing more of the AST to\n   *       be retained (it doesn't skip any tokens as the ')' is retained because of the '(' begins\n   *       an '(' <expr> ')' production).\n   *       The recovery points of grouping symbols must be conditional as they must be skipped if\n   *       none of the calling productions are not expecting the closing token else we will never\n   *       make progress in the case of an extraneous group closing symbol (such as a stray ')').\n   *       That is, we skip a closing symbol if we are not in a grouping production.\n   *   - '=' in a `Writable` context\n   *     - In this context, we are able to recover after seeing the `=` operator, which\n   *       signals the presence of an independent rvalue expression following the `=` operator.\n   *\n   * If a production expects one of these token it increments the corresponding nesting count,\n   * and then decrements it just prior to checking if the token is in the input.\n   */\n  private skip() {\n    let n = this.next;\n    while (this.index < this.tokens.length && !n.isCharacter(chars.$SEMICOLON) &&\n           !n.isOperator('|') && (this.rparensExpected <= 0 || !n.isCharacter(chars.$RPAREN)) &&\n           (this.rbracesExpected <= 0 || !n.isCharacter(chars.$RBRACE)) &&\n           (this.rbracketsExpected <= 0 || !n.isCharacter(chars.$RBRACKET)) &&\n           (!(this.context & ParseContextFlags.Writable) || !n.isOperator('='))) {\n      if (this.next.isError()) {\n        this.errors.push(\n            new ParserError(this.next.toString()!, this.input, this.locationText(), this.location));\n      }\n      this.advance();\n      n = this.next;\n    }\n  }\n}\n\nclass SimpleExpressionChecker implements AstVisitor {\n  errors: string[] = [];\n\n  visitImplicitReceiver(ast: ImplicitReceiver, context: any) {}\n\n  visitThisReceiver(ast: ThisReceiver, context: any) {}\n\n  visitInterpolation(ast: Interpolation, context: any) {}\n\n  visitLiteralPrimitive(ast: LiteralPrimitive, context: any) {}\n\n  visitPropertyRead(ast: PropertyRead, context: any) {}\n\n  visitPropertyWrite(ast: PropertyWrite, context: any) {}\n\n  visitSafePropertyRead(ast: SafePropertyRead, context: any) {}\n\n  visitMethodCall(ast: MethodCall, context: any) {}\n\n  visitSafeMethodCall(ast: SafeMethodCall, context: any) {}\n\n  visitFunctionCall(ast: FunctionCall, context: any) {}\n\n  visitLiteralArray(ast: LiteralArray, context: any) {\n    this.visitAll(ast.expressions, context);\n  }\n\n  visitLiteralMap(ast: LiteralMap, context: any) {\n    this.visitAll(ast.values, context);\n  }\n\n  visitUnary(ast: Unary, context: any) {}\n\n  visitBinary(ast: Binary, context: any) {}\n\n  visitPrefixNot(ast: PrefixNot, context: any) {}\n\n  visitNonNullAssert(ast: NonNullAssert, context: any) {}\n\n  visitConditional(ast: Conditional, context: any) {}\n\n  visitPipe(ast: BindingPipe, context: any) {\n    this.errors.push('pipes');\n  }\n\n  visitKeyedRead(ast: KeyedRead, context: any) {}\n\n  visitKeyedWrite(ast: KeyedWrite, context: any) {}\n\n  visitAll(asts: any[], context: any): any[] {\n    return asts.map(node => node.visit(this, context));\n  }\n\n  visitChain(ast: Chain, context: any) {}\n\n  visitQuote(ast: Quote, context: any) {}\n\n  visitSafeKeyedRead(ast: SafeKeyedRead, context: any) {}\n}\n\n/**\n * This class implements SimpleExpressionChecker used in View Engine and performs more strict checks\n * to make sure host bindings do not contain pipes. In View Engine, having pipes in host bindings is\n * not supported as well, but in some cases (like `!(value | async)`) the error is not triggered at\n * compile time. In order to preserve View Engine behavior, more strict checks are introduced for\n * Ivy mode only.\n */\nclass IvySimpleExpressionChecker extends RecursiveAstVisitor implements SimpleExpressionChecker {\n  errors: string[] = [];\n\n  override visitPipe() {\n    this.errors.push('pipes');\n  }\n}\n"]}
Note: See TracBrowser for help on using the repository browser.