source: trip-planner-front/node_modules/@angular/compiler/src/compiler_util/expression_converter.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: 130.5 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/compiler_util/expression_converter", ["require", "exports", "tslib", "@angular/compiler/src/expression_parser/ast", "@angular/compiler/src/identifiers", "@angular/compiler/src/output/output_ast", "@angular/compiler/src/parse_util"], factory);
15 }
16})(function (require, exports) {
17 "use strict";
18 Object.defineProperty(exports, "__esModule", { value: true });
19 exports.BuiltinFunctionCall = exports.convertUpdateArguments = exports.convertPropertyBinding = exports.BindingForm = exports.ConvertPropertyBindingResult = exports.convertPropertyBindingBuiltins = exports.convertActionBinding = exports.ConvertActionBindingResult = exports.EventHandlerVars = void 0;
20 var tslib_1 = require("tslib");
21 var cdAst = require("@angular/compiler/src/expression_parser/ast");
22 var identifiers_1 = require("@angular/compiler/src/identifiers");
23 var o = require("@angular/compiler/src/output/output_ast");
24 var parse_util_1 = require("@angular/compiler/src/parse_util");
25 var EventHandlerVars = /** @class */ (function () {
26 function EventHandlerVars() {
27 }
28 EventHandlerVars.event = o.variable('$event');
29 return EventHandlerVars;
30 }());
31 exports.EventHandlerVars = EventHandlerVars;
32 var ConvertActionBindingResult = /** @class */ (function () {
33 function ConvertActionBindingResult(
34 /**
35 * Render2 compatible statements,
36 */
37 stmts,
38 /**
39 * Variable name used with render2 compatible statements.
40 */
41 allowDefault) {
42 this.stmts = stmts;
43 this.allowDefault = allowDefault;
44 /**
45 * This is bit of a hack. It converts statements which render2 expects to statements which are
46 * expected by render3.
47 *
48 * Example: `<div click="doSomething($event)">` will generate:
49 *
50 * Render3:
51 * ```
52 * const pd_b:any = ((<any>ctx.doSomething($event)) !== false);
53 * return pd_b;
54 * ```
55 *
56 * but render2 expects:
57 * ```
58 * return ctx.doSomething($event);
59 * ```
60 */
61 // TODO(misko): remove this hack once we no longer support ViewEngine.
62 this.render3Stmts = stmts.map(function (statement) {
63 if (statement instanceof o.DeclareVarStmt && statement.name == allowDefault.name &&
64 statement.value instanceof o.BinaryOperatorExpr) {
65 var lhs = statement.value.lhs;
66 return new o.ReturnStatement(lhs.value);
67 }
68 return statement;
69 });
70 }
71 return ConvertActionBindingResult;
72 }());
73 exports.ConvertActionBindingResult = ConvertActionBindingResult;
74 /**
75 * Converts the given expression AST into an executable output AST, assuming the expression is
76 * used in an action binding (e.g. an event handler).
77 */
78 function convertActionBinding(localResolver, implicitReceiver, action, bindingId, interpolationFunction, baseSourceSpan, implicitReceiverAccesses, globals) {
79 if (!localResolver) {
80 localResolver = new DefaultLocalResolver(globals);
81 }
82 var actionWithoutBuiltins = convertPropertyBindingBuiltins({
83 createLiteralArrayConverter: function (argCount) {
84 // Note: no caching for literal arrays in actions.
85 return function (args) { return o.literalArr(args); };
86 },
87 createLiteralMapConverter: function (keys) {
88 // Note: no caching for literal maps in actions.
89 return function (values) {
90 var entries = keys.map(function (k, i) { return ({
91 key: k.key,
92 value: values[i],
93 quoted: k.quoted,
94 }); });
95 return o.literalMap(entries);
96 };
97 },
98 createPipeConverter: function (name) {
99 throw new Error("Illegal State: Actions are not allowed to contain pipes. Pipe: " + name);
100 }
101 }, action);
102 var visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId, interpolationFunction, baseSourceSpan, implicitReceiverAccesses);
103 var actionStmts = [];
104 flattenStatements(actionWithoutBuiltins.visit(visitor, _Mode.Statement), actionStmts);
105 prependTemporaryDecls(visitor.temporaryCount, bindingId, actionStmts);
106 if (visitor.usesImplicitReceiver) {
107 localResolver.notifyImplicitReceiverUse();
108 }
109 var lastIndex = actionStmts.length - 1;
110 var preventDefaultVar = null;
111 if (lastIndex >= 0) {
112 var lastStatement = actionStmts[lastIndex];
113 var returnExpr = convertStmtIntoExpression(lastStatement);
114 if (returnExpr) {
115 // Note: We need to cast the result of the method call to dynamic,
116 // as it might be a void method!
117 preventDefaultVar = createPreventDefaultVar(bindingId);
118 actionStmts[lastIndex] =
119 preventDefaultVar.set(returnExpr.cast(o.DYNAMIC_TYPE).notIdentical(o.literal(false)))
120 .toDeclStmt(null, [o.StmtModifier.Final]);
121 }
122 }
123 return new ConvertActionBindingResult(actionStmts, preventDefaultVar);
124 }
125 exports.convertActionBinding = convertActionBinding;
126 function convertPropertyBindingBuiltins(converterFactory, ast) {
127 return convertBuiltins(converterFactory, ast);
128 }
129 exports.convertPropertyBindingBuiltins = convertPropertyBindingBuiltins;
130 var ConvertPropertyBindingResult = /** @class */ (function () {
131 function ConvertPropertyBindingResult(stmts, currValExpr) {
132 this.stmts = stmts;
133 this.currValExpr = currValExpr;
134 }
135 return ConvertPropertyBindingResult;
136 }());
137 exports.ConvertPropertyBindingResult = ConvertPropertyBindingResult;
138 var BindingForm;
139 (function (BindingForm) {
140 // The general form of binding expression, supports all expressions.
141 BindingForm[BindingForm["General"] = 0] = "General";
142 // Try to generate a simple binding (no temporaries or statements)
143 // otherwise generate a general binding
144 BindingForm[BindingForm["TrySimple"] = 1] = "TrySimple";
145 // Inlines assignment of temporaries into the generated expression. The result may still
146 // have statements attached for declarations of temporary variables.
147 // This is the only relevant form for Ivy, the other forms are only used in ViewEngine.
148 BindingForm[BindingForm["Expression"] = 2] = "Expression";
149 })(BindingForm = exports.BindingForm || (exports.BindingForm = {}));
150 /**
151 * Converts the given expression AST into an executable output AST, assuming the expression
152 * is used in property binding. The expression has to be preprocessed via
153 * `convertPropertyBindingBuiltins`.
154 */
155 function convertPropertyBinding(localResolver, implicitReceiver, expressionWithoutBuiltins, bindingId, form, interpolationFunction) {
156 if (!localResolver) {
157 localResolver = new DefaultLocalResolver();
158 }
159 var visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId, interpolationFunction);
160 var outputExpr = expressionWithoutBuiltins.visit(visitor, _Mode.Expression);
161 var stmts = getStatementsFromVisitor(visitor, bindingId);
162 if (visitor.usesImplicitReceiver) {
163 localResolver.notifyImplicitReceiverUse();
164 }
165 if (visitor.temporaryCount === 0 && form == BindingForm.TrySimple) {
166 return new ConvertPropertyBindingResult([], outputExpr);
167 }
168 else if (form === BindingForm.Expression) {
169 return new ConvertPropertyBindingResult(stmts, outputExpr);
170 }
171 var currValExpr = createCurrValueExpr(bindingId);
172 stmts.push(currValExpr.set(outputExpr).toDeclStmt(o.DYNAMIC_TYPE, [o.StmtModifier.Final]));
173 return new ConvertPropertyBindingResult(stmts, currValExpr);
174 }
175 exports.convertPropertyBinding = convertPropertyBinding;
176 /**
177 * Given some expression, such as a binding or interpolation expression, and a context expression to
178 * look values up on, visit each facet of the given expression resolving values from the context
179 * expression such that a list of arguments can be derived from the found values that can be used as
180 * arguments to an external update instruction.
181 *
182 * @param localResolver The resolver to use to look up expressions by name appropriately
183 * @param contextVariableExpression The expression representing the context variable used to create
184 * the final argument expressions
185 * @param expressionWithArgumentsToExtract The expression to visit to figure out what values need to
186 * be resolved and what arguments list to build.
187 * @param bindingId A name prefix used to create temporary variable names if they're needed for the
188 * arguments generated
189 * @returns An array of expressions that can be passed as arguments to instruction expressions like
190 * `o.importExpr(R3.propertyInterpolate).callFn(result)`
191 */
192 function convertUpdateArguments(localResolver, contextVariableExpression, expressionWithArgumentsToExtract, bindingId) {
193 var visitor = new _AstToIrVisitor(localResolver, contextVariableExpression, bindingId, undefined);
194 var outputExpr = expressionWithArgumentsToExtract.visit(visitor, _Mode.Expression);
195 if (visitor.usesImplicitReceiver) {
196 localResolver.notifyImplicitReceiverUse();
197 }
198 var stmts = getStatementsFromVisitor(visitor, bindingId);
199 // Removing the first argument, because it was a length for ViewEngine, not Ivy.
200 var args = outputExpr.args.slice(1);
201 if (expressionWithArgumentsToExtract instanceof cdAst.Interpolation) {
202 // If we're dealing with an interpolation of 1 value with an empty prefix and suffix, reduce the
203 // args returned to just the value, because we're going to pass it to a special instruction.
204 var strings = expressionWithArgumentsToExtract.strings;
205 if (args.length === 3 && strings[0] === '' && strings[1] === '') {
206 // Single argument interpolate instructions.
207 args = [args[1]];
208 }
209 else if (args.length >= 19) {
210 // 19 or more arguments must be passed to the `interpolateV`-style instructions, which accept
211 // an array of arguments
212 args = [o.literalArr(args)];
213 }
214 }
215 return { stmts: stmts, args: args };
216 }
217 exports.convertUpdateArguments = convertUpdateArguments;
218 function getStatementsFromVisitor(visitor, bindingId) {
219 var stmts = [];
220 for (var i = 0; i < visitor.temporaryCount; i++) {
221 stmts.push(temporaryDeclaration(bindingId, i));
222 }
223 return stmts;
224 }
225 function convertBuiltins(converterFactory, ast) {
226 var visitor = new _BuiltinAstConverter(converterFactory);
227 return ast.visit(visitor);
228 }
229 function temporaryName(bindingId, temporaryNumber) {
230 return "tmp_" + bindingId + "_" + temporaryNumber;
231 }
232 function temporaryDeclaration(bindingId, temporaryNumber) {
233 return new o.DeclareVarStmt(temporaryName(bindingId, temporaryNumber));
234 }
235 function prependTemporaryDecls(temporaryCount, bindingId, statements) {
236 for (var i = temporaryCount - 1; i >= 0; i--) {
237 statements.unshift(temporaryDeclaration(bindingId, i));
238 }
239 }
240 var _Mode;
241 (function (_Mode) {
242 _Mode[_Mode["Statement"] = 0] = "Statement";
243 _Mode[_Mode["Expression"] = 1] = "Expression";
244 })(_Mode || (_Mode = {}));
245 function ensureStatementMode(mode, ast) {
246 if (mode !== _Mode.Statement) {
247 throw new Error("Expected a statement, but saw " + ast);
248 }
249 }
250 function ensureExpressionMode(mode, ast) {
251 if (mode !== _Mode.Expression) {
252 throw new Error("Expected an expression, but saw " + ast);
253 }
254 }
255 function convertToStatementIfNeeded(mode, expr) {
256 if (mode === _Mode.Statement) {
257 return expr.toStmt();
258 }
259 else {
260 return expr;
261 }
262 }
263 var _BuiltinAstConverter = /** @class */ (function (_super) {
264 tslib_1.__extends(_BuiltinAstConverter, _super);
265 function _BuiltinAstConverter(_converterFactory) {
266 var _this = _super.call(this) || this;
267 _this._converterFactory = _converterFactory;
268 return _this;
269 }
270 _BuiltinAstConverter.prototype.visitPipe = function (ast, context) {
271 var _this = this;
272 var args = tslib_1.__spreadArray([ast.exp], tslib_1.__read(ast.args)).map(function (ast) { return ast.visit(_this, context); });
273 return new BuiltinFunctionCall(ast.span, ast.sourceSpan, args, this._converterFactory.createPipeConverter(ast.name, args.length));
274 };
275 _BuiltinAstConverter.prototype.visitLiteralArray = function (ast, context) {
276 var _this = this;
277 var args = ast.expressions.map(function (ast) { return ast.visit(_this, context); });
278 return new BuiltinFunctionCall(ast.span, ast.sourceSpan, args, this._converterFactory.createLiteralArrayConverter(ast.expressions.length));
279 };
280 _BuiltinAstConverter.prototype.visitLiteralMap = function (ast, context) {
281 var _this = this;
282 var args = ast.values.map(function (ast) { return ast.visit(_this, context); });
283 return new BuiltinFunctionCall(ast.span, ast.sourceSpan, args, this._converterFactory.createLiteralMapConverter(ast.keys));
284 };
285 return _BuiltinAstConverter;
286 }(cdAst.AstTransformer));
287 var _AstToIrVisitor = /** @class */ (function () {
288 function _AstToIrVisitor(_localResolver, _implicitReceiver, bindingId, interpolationFunction, baseSourceSpan, implicitReceiverAccesses) {
289 this._localResolver = _localResolver;
290 this._implicitReceiver = _implicitReceiver;
291 this.bindingId = bindingId;
292 this.interpolationFunction = interpolationFunction;
293 this.baseSourceSpan = baseSourceSpan;
294 this.implicitReceiverAccesses = implicitReceiverAccesses;
295 this._nodeMap = new Map();
296 this._resultMap = new Map();
297 this._currentTemporary = 0;
298 this.temporaryCount = 0;
299 this.usesImplicitReceiver = false;
300 }
301 _AstToIrVisitor.prototype.visitUnary = function (ast, mode) {
302 var op;
303 switch (ast.operator) {
304 case '+':
305 op = o.UnaryOperator.Plus;
306 break;
307 case '-':
308 op = o.UnaryOperator.Minus;
309 break;
310 default:
311 throw new Error("Unsupported operator " + ast.operator);
312 }
313 return convertToStatementIfNeeded(mode, new o.UnaryOperatorExpr(op, this._visit(ast.expr, _Mode.Expression), undefined, this.convertSourceSpan(ast.span)));
314 };
315 _AstToIrVisitor.prototype.visitBinary = function (ast, mode) {
316 var op;
317 switch (ast.operation) {
318 case '+':
319 op = o.BinaryOperator.Plus;
320 break;
321 case '-':
322 op = o.BinaryOperator.Minus;
323 break;
324 case '*':
325 op = o.BinaryOperator.Multiply;
326 break;
327 case '/':
328 op = o.BinaryOperator.Divide;
329 break;
330 case '%':
331 op = o.BinaryOperator.Modulo;
332 break;
333 case '&&':
334 op = o.BinaryOperator.And;
335 break;
336 case '||':
337 op = o.BinaryOperator.Or;
338 break;
339 case '==':
340 op = o.BinaryOperator.Equals;
341 break;
342 case '!=':
343 op = o.BinaryOperator.NotEquals;
344 break;
345 case '===':
346 op = o.BinaryOperator.Identical;
347 break;
348 case '!==':
349 op = o.BinaryOperator.NotIdentical;
350 break;
351 case '<':
352 op = o.BinaryOperator.Lower;
353 break;
354 case '>':
355 op = o.BinaryOperator.Bigger;
356 break;
357 case '<=':
358 op = o.BinaryOperator.LowerEquals;
359 break;
360 case '>=':
361 op = o.BinaryOperator.BiggerEquals;
362 break;
363 case '??':
364 return this.convertNullishCoalesce(ast, mode);
365 default:
366 throw new Error("Unsupported operation " + ast.operation);
367 }
368 return convertToStatementIfNeeded(mode, new o.BinaryOperatorExpr(op, this._visit(ast.left, _Mode.Expression), this._visit(ast.right, _Mode.Expression), undefined, this.convertSourceSpan(ast.span)));
369 };
370 _AstToIrVisitor.prototype.visitChain = function (ast, mode) {
371 ensureStatementMode(mode, ast);
372 return this.visitAll(ast.expressions, mode);
373 };
374 _AstToIrVisitor.prototype.visitConditional = function (ast, mode) {
375 var value = this._visit(ast.condition, _Mode.Expression);
376 return convertToStatementIfNeeded(mode, value.conditional(this._visit(ast.trueExp, _Mode.Expression), this._visit(ast.falseExp, _Mode.Expression), this.convertSourceSpan(ast.span)));
377 };
378 _AstToIrVisitor.prototype.visitPipe = function (ast, mode) {
379 throw new Error("Illegal state: Pipes should have been converted into functions. Pipe: " + ast.name);
380 };
381 _AstToIrVisitor.prototype.visitFunctionCall = function (ast, mode) {
382 var convertedArgs = this.visitAll(ast.args, _Mode.Expression);
383 var fnResult;
384 if (ast instanceof BuiltinFunctionCall) {
385 fnResult = ast.converter(convertedArgs);
386 }
387 else {
388 fnResult = this._visit(ast.target, _Mode.Expression)
389 .callFn(convertedArgs, this.convertSourceSpan(ast.span));
390 }
391 return convertToStatementIfNeeded(mode, fnResult);
392 };
393 _AstToIrVisitor.prototype.visitImplicitReceiver = function (ast, mode) {
394 ensureExpressionMode(mode, ast);
395 this.usesImplicitReceiver = true;
396 return this._implicitReceiver;
397 };
398 _AstToIrVisitor.prototype.visitThisReceiver = function (ast, mode) {
399 return this.visitImplicitReceiver(ast, mode);
400 };
401 _AstToIrVisitor.prototype.visitInterpolation = function (ast, mode) {
402 ensureExpressionMode(mode, ast);
403 var args = [o.literal(ast.expressions.length)];
404 for (var i = 0; i < ast.strings.length - 1; i++) {
405 args.push(o.literal(ast.strings[i]));
406 args.push(this._visit(ast.expressions[i], _Mode.Expression));
407 }
408 args.push(o.literal(ast.strings[ast.strings.length - 1]));
409 if (this.interpolationFunction) {
410 return this.interpolationFunction(args);
411 }
412 return ast.expressions.length <= 9 ?
413 o.importExpr(identifiers_1.Identifiers.inlineInterpolate).callFn(args) :
414 o.importExpr(identifiers_1.Identifiers.interpolate).callFn([
415 args[0], o.literalArr(args.slice(1), undefined, this.convertSourceSpan(ast.span))
416 ]);
417 };
418 _AstToIrVisitor.prototype.visitKeyedRead = function (ast, mode) {
419 var leftMostSafe = this.leftMostSafeNode(ast);
420 if (leftMostSafe) {
421 return this.convertSafeAccess(ast, leftMostSafe, mode);
422 }
423 else {
424 return convertToStatementIfNeeded(mode, this._visit(ast.receiver, _Mode.Expression).key(this._visit(ast.key, _Mode.Expression)));
425 }
426 };
427 _AstToIrVisitor.prototype.visitKeyedWrite = function (ast, mode) {
428 var obj = this._visit(ast.receiver, _Mode.Expression);
429 var key = this._visit(ast.key, _Mode.Expression);
430 var value = this._visit(ast.value, _Mode.Expression);
431 if (obj === this._implicitReceiver) {
432 this._localResolver.maybeRestoreView();
433 }
434 return convertToStatementIfNeeded(mode, obj.key(key).set(value));
435 };
436 _AstToIrVisitor.prototype.visitLiteralArray = function (ast, mode) {
437 throw new Error("Illegal State: literal arrays should have been converted into functions");
438 };
439 _AstToIrVisitor.prototype.visitLiteralMap = function (ast, mode) {
440 throw new Error("Illegal State: literal maps should have been converted into functions");
441 };
442 _AstToIrVisitor.prototype.visitLiteralPrimitive = function (ast, mode) {
443 // For literal values of null, undefined, true, or false allow type interference
444 // to infer the type.
445 var type = ast.value === null || ast.value === undefined || ast.value === true || ast.value === true ?
446 o.INFERRED_TYPE :
447 undefined;
448 return convertToStatementIfNeeded(mode, o.literal(ast.value, type, this.convertSourceSpan(ast.span)));
449 };
450 _AstToIrVisitor.prototype._getLocal = function (name, receiver) {
451 var _a;
452 if (((_a = this._localResolver.globals) === null || _a === void 0 ? void 0 : _a.has(name)) && receiver instanceof cdAst.ThisReceiver) {
453 return null;
454 }
455 return this._localResolver.getLocal(name);
456 };
457 _AstToIrVisitor.prototype.visitMethodCall = function (ast, mode) {
458 if (ast.receiver instanceof cdAst.ImplicitReceiver &&
459 !(ast.receiver instanceof cdAst.ThisReceiver) && ast.name === '$any') {
460 var args = this.visitAll(ast.args, _Mode.Expression);
461 if (args.length != 1) {
462 throw new Error("Invalid call to $any, expected 1 argument but received " + (args.length || 'none'));
463 }
464 return args[0].cast(o.DYNAMIC_TYPE, this.convertSourceSpan(ast.span));
465 }
466 var leftMostSafe = this.leftMostSafeNode(ast);
467 if (leftMostSafe) {
468 return this.convertSafeAccess(ast, leftMostSafe, mode);
469 }
470 else {
471 var args = this.visitAll(ast.args, _Mode.Expression);
472 var prevUsesImplicitReceiver = this.usesImplicitReceiver;
473 var result = null;
474 var receiver = this._visit(ast.receiver, _Mode.Expression);
475 if (receiver === this._implicitReceiver) {
476 var varExpr = this._getLocal(ast.name, ast.receiver);
477 if (varExpr) {
478 // Restore the previous "usesImplicitReceiver" state since the implicit
479 // receiver has been replaced with a resolved local expression.
480 this.usesImplicitReceiver = prevUsesImplicitReceiver;
481 result = varExpr.callFn(args);
482 this.addImplicitReceiverAccess(ast.name);
483 }
484 }
485 if (result == null) {
486 result = receiver.callMethod(ast.name, args, this.convertSourceSpan(ast.span));
487 }
488 return convertToStatementIfNeeded(mode, result);
489 }
490 };
491 _AstToIrVisitor.prototype.visitPrefixNot = function (ast, mode) {
492 return convertToStatementIfNeeded(mode, o.not(this._visit(ast.expression, _Mode.Expression)));
493 };
494 _AstToIrVisitor.prototype.visitNonNullAssert = function (ast, mode) {
495 return convertToStatementIfNeeded(mode, o.assertNotNull(this._visit(ast.expression, _Mode.Expression)));
496 };
497 _AstToIrVisitor.prototype.visitPropertyRead = function (ast, mode) {
498 var leftMostSafe = this.leftMostSafeNode(ast);
499 if (leftMostSafe) {
500 return this.convertSafeAccess(ast, leftMostSafe, mode);
501 }
502 else {
503 var result = null;
504 var prevUsesImplicitReceiver = this.usesImplicitReceiver;
505 var receiver = this._visit(ast.receiver, _Mode.Expression);
506 if (receiver === this._implicitReceiver) {
507 result = this._getLocal(ast.name, ast.receiver);
508 if (result) {
509 // Restore the previous "usesImplicitReceiver" state since the implicit
510 // receiver has been replaced with a resolved local expression.
511 this.usesImplicitReceiver = prevUsesImplicitReceiver;
512 this.addImplicitReceiverAccess(ast.name);
513 }
514 }
515 if (result == null) {
516 result = receiver.prop(ast.name);
517 }
518 return convertToStatementIfNeeded(mode, result);
519 }
520 };
521 _AstToIrVisitor.prototype.visitPropertyWrite = function (ast, mode) {
522 var receiver = this._visit(ast.receiver, _Mode.Expression);
523 var prevUsesImplicitReceiver = this.usesImplicitReceiver;
524 var varExpr = null;
525 if (receiver === this._implicitReceiver) {
526 var localExpr = this._getLocal(ast.name, ast.receiver);
527 if (localExpr) {
528 if (localExpr instanceof o.ReadPropExpr) {
529 // If the local variable is a property read expression, it's a reference
530 // to a 'context.property' value and will be used as the target of the
531 // write expression.
532 varExpr = localExpr;
533 // Restore the previous "usesImplicitReceiver" state since the implicit
534 // receiver has been replaced with a resolved local expression.
535 this.usesImplicitReceiver = prevUsesImplicitReceiver;
536 this.addImplicitReceiverAccess(ast.name);
537 }
538 else {
539 // Otherwise it's an error.
540 var receiver_1 = ast.name;
541 var value = (ast.value instanceof cdAst.PropertyRead) ? ast.value.name : undefined;
542 throw new Error("Cannot assign value \"" + value + "\" to template variable \"" + receiver_1 + "\". Template variables are read-only.");
543 }
544 }
545 }
546 // If no local expression could be produced, use the original receiver's
547 // property as the target.
548 if (varExpr === null) {
549 varExpr = receiver.prop(ast.name);
550 }
551 return convertToStatementIfNeeded(mode, varExpr.set(this._visit(ast.value, _Mode.Expression)));
552 };
553 _AstToIrVisitor.prototype.visitSafePropertyRead = function (ast, mode) {
554 return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);
555 };
556 _AstToIrVisitor.prototype.visitSafeMethodCall = function (ast, mode) {
557 return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);
558 };
559 _AstToIrVisitor.prototype.visitSafeKeyedRead = function (ast, mode) {
560 return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);
561 };
562 _AstToIrVisitor.prototype.visitAll = function (asts, mode) {
563 var _this = this;
564 return asts.map(function (ast) { return _this._visit(ast, mode); });
565 };
566 _AstToIrVisitor.prototype.visitQuote = function (ast, mode) {
567 throw new Error("Quotes are not supported for evaluation!\n Statement: " + ast.uninterpretedExpression + " located at " + ast.location);
568 };
569 _AstToIrVisitor.prototype._visit = function (ast, mode) {
570 var result = this._resultMap.get(ast);
571 if (result)
572 return result;
573 return (this._nodeMap.get(ast) || ast).visit(this, mode);
574 };
575 _AstToIrVisitor.prototype.convertSafeAccess = function (ast, leftMostSafe, mode) {
576 // If the expression contains a safe access node on the left it needs to be converted to
577 // an expression that guards the access to the member by checking the receiver for blank. As
578 // execution proceeds from left to right, the left most part of the expression must be guarded
579 // first but, because member access is left associative, the right side of the expression is at
580 // the top of the AST. The desired result requires lifting a copy of the left part of the
581 // expression up to test it for blank before generating the unguarded version.
582 // Consider, for example the following expression: a?.b.c?.d.e
583 // This results in the ast:
584 // .
585 // / \
586 // ?. e
587 // / \
588 // . d
589 // / \
590 // ?. c
591 // / \
592 // a b
593 // The following tree should be generated:
594 //
595 // /---- ? ----\
596 // / | \
597 // a /--- ? ---\ null
598 // / | \
599 // . . null
600 // / \ / \
601 // . c . e
602 // / \ / \
603 // a b . d
604 // / \
605 // . c
606 // / \
607 // a b
608 //
609 // Notice that the first guard condition is the left hand of the left most safe access node
610 // which comes in as leftMostSafe to this routine.
611 var guardedExpression = this._visit(leftMostSafe.receiver, _Mode.Expression);
612 var temporary = undefined;
613 if (this.needsTemporaryInSafeAccess(leftMostSafe.receiver)) {
614 // If the expression has method calls or pipes then we need to save the result into a
615 // temporary variable to avoid calling stateful or impure code more than once.
616 temporary = this.allocateTemporary();
617 // Preserve the result in the temporary variable
618 guardedExpression = temporary.set(guardedExpression);
619 // Ensure all further references to the guarded expression refer to the temporary instead.
620 this._resultMap.set(leftMostSafe.receiver, temporary);
621 }
622 var condition = guardedExpression.isBlank();
623 // Convert the ast to an unguarded access to the receiver's member. The map will substitute
624 // leftMostNode with its unguarded version in the call to `this.visit()`.
625 if (leftMostSafe instanceof cdAst.SafeMethodCall) {
626 this._nodeMap.set(leftMostSafe, new cdAst.MethodCall(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.nameSpan, leftMostSafe.receiver, leftMostSafe.name, leftMostSafe.args, leftMostSafe.argumentSpan));
627 }
628 else if (leftMostSafe instanceof cdAst.SafeKeyedRead) {
629 this._nodeMap.set(leftMostSafe, new cdAst.KeyedRead(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.receiver, leftMostSafe.key));
630 }
631 else {
632 this._nodeMap.set(leftMostSafe, new cdAst.PropertyRead(leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.nameSpan, leftMostSafe.receiver, leftMostSafe.name));
633 }
634 // Recursively convert the node now without the guarded member access.
635 var access = this._visit(ast, _Mode.Expression);
636 // Remove the mapping. This is not strictly required as the converter only traverses each node
637 // once but is safer if the conversion is changed to traverse the nodes more than once.
638 this._nodeMap.delete(leftMostSafe);
639 // If we allocated a temporary, release it.
640 if (temporary) {
641 this.releaseTemporary(temporary);
642 }
643 // Produce the conditional
644 return convertToStatementIfNeeded(mode, condition.conditional(o.NULL_EXPR, access));
645 };
646 _AstToIrVisitor.prototype.convertNullishCoalesce = function (ast, mode) {
647 var left = this._visit(ast.left, _Mode.Expression);
648 var right = this._visit(ast.right, _Mode.Expression);
649 var temporary = this.allocateTemporary();
650 this.releaseTemporary(temporary);
651 // Generate the following expression. It is identical to how TS
652 // transpiles binary expressions with a nullish coalescing operator.
653 // let temp;
654 // (temp = a) !== null && temp !== undefined ? temp : b;
655 return convertToStatementIfNeeded(mode, temporary.set(left)
656 .notIdentical(o.NULL_EXPR)
657 .and(temporary.notIdentical(o.literal(undefined)))
658 .conditional(temporary, right));
659 };
660 // Given an expression of the form a?.b.c?.d.e then the left most safe node is
661 // the (a?.b). The . and ?. are left associative thus can be rewritten as:
662 // ((((a?.c).b).c)?.d).e. This returns the most deeply nested safe read or
663 // safe method call as this needs to be transformed initially to:
664 // a == null ? null : a.c.b.c?.d.e
665 // then to:
666 // a == null ? null : a.b.c == null ? null : a.b.c.d.e
667 _AstToIrVisitor.prototype.leftMostSafeNode = function (ast) {
668 var _this = this;
669 var visit = function (visitor, ast) {
670 return (_this._nodeMap.get(ast) || ast).visit(visitor);
671 };
672 return ast.visit({
673 visitUnary: function (ast) {
674 return null;
675 },
676 visitBinary: function (ast) {
677 return null;
678 },
679 visitChain: function (ast) {
680 return null;
681 },
682 visitConditional: function (ast) {
683 return null;
684 },
685 visitFunctionCall: function (ast) {
686 return null;
687 },
688 visitImplicitReceiver: function (ast) {
689 return null;
690 },
691 visitThisReceiver: function (ast) {
692 return null;
693 },
694 visitInterpolation: function (ast) {
695 return null;
696 },
697 visitKeyedRead: function (ast) {
698 return visit(this, ast.receiver);
699 },
700 visitKeyedWrite: function (ast) {
701 return null;
702 },
703 visitLiteralArray: function (ast) {
704 return null;
705 },
706 visitLiteralMap: function (ast) {
707 return null;
708 },
709 visitLiteralPrimitive: function (ast) {
710 return null;
711 },
712 visitMethodCall: function (ast) {
713 return visit(this, ast.receiver);
714 },
715 visitPipe: function (ast) {
716 return null;
717 },
718 visitPrefixNot: function (ast) {
719 return null;
720 },
721 visitNonNullAssert: function (ast) {
722 return null;
723 },
724 visitPropertyRead: function (ast) {
725 return visit(this, ast.receiver);
726 },
727 visitPropertyWrite: function (ast) {
728 return null;
729 },
730 visitQuote: function (ast) {
731 return null;
732 },
733 visitSafeMethodCall: function (ast) {
734 return visit(this, ast.receiver) || ast;
735 },
736 visitSafePropertyRead: function (ast) {
737 return visit(this, ast.receiver) || ast;
738 },
739 visitSafeKeyedRead: function (ast) {
740 return visit(this, ast.receiver) || ast;
741 }
742 });
743 };
744 // Returns true of the AST includes a method or a pipe indicating that, if the
745 // expression is used as the target of a safe property or method access then
746 // the expression should be stored into a temporary variable.
747 _AstToIrVisitor.prototype.needsTemporaryInSafeAccess = function (ast) {
748 var _this = this;
749 var visit = function (visitor, ast) {
750 return ast && (_this._nodeMap.get(ast) || ast).visit(visitor);
751 };
752 var visitSome = function (visitor, ast) {
753 return ast.some(function (ast) { return visit(visitor, ast); });
754 };
755 return ast.visit({
756 visitUnary: function (ast) {
757 return visit(this, ast.expr);
758 },
759 visitBinary: function (ast) {
760 return visit(this, ast.left) || visit(this, ast.right);
761 },
762 visitChain: function (ast) {
763 return false;
764 },
765 visitConditional: function (ast) {
766 return visit(this, ast.condition) || visit(this, ast.trueExp) || visit(this, ast.falseExp);
767 },
768 visitFunctionCall: function (ast) {
769 return true;
770 },
771 visitImplicitReceiver: function (ast) {
772 return false;
773 },
774 visitThisReceiver: function (ast) {
775 return false;
776 },
777 visitInterpolation: function (ast) {
778 return visitSome(this, ast.expressions);
779 },
780 visitKeyedRead: function (ast) {
781 return false;
782 },
783 visitKeyedWrite: function (ast) {
784 return false;
785 },
786 visitLiteralArray: function (ast) {
787 return true;
788 },
789 visitLiteralMap: function (ast) {
790 return true;
791 },
792 visitLiteralPrimitive: function (ast) {
793 return false;
794 },
795 visitMethodCall: function (ast) {
796 return true;
797 },
798 visitPipe: function (ast) {
799 return true;
800 },
801 visitPrefixNot: function (ast) {
802 return visit(this, ast.expression);
803 },
804 visitNonNullAssert: function (ast) {
805 return visit(this, ast.expression);
806 },
807 visitPropertyRead: function (ast) {
808 return false;
809 },
810 visitPropertyWrite: function (ast) {
811 return false;
812 },
813 visitQuote: function (ast) {
814 return false;
815 },
816 visitSafeMethodCall: function (ast) {
817 return true;
818 },
819 visitSafePropertyRead: function (ast) {
820 return false;
821 },
822 visitSafeKeyedRead: function (ast) {
823 return false;
824 }
825 });
826 };
827 _AstToIrVisitor.prototype.allocateTemporary = function () {
828 var tempNumber = this._currentTemporary++;
829 this.temporaryCount = Math.max(this._currentTemporary, this.temporaryCount);
830 return new o.ReadVarExpr(temporaryName(this.bindingId, tempNumber));
831 };
832 _AstToIrVisitor.prototype.releaseTemporary = function (temporary) {
833 this._currentTemporary--;
834 if (temporary.name != temporaryName(this.bindingId, this._currentTemporary)) {
835 throw new Error("Temporary " + temporary.name + " released out of order");
836 }
837 };
838 /**
839 * Creates an absolute `ParseSourceSpan` from the relative `ParseSpan`.
840 *
841 * `ParseSpan` objects are relative to the start of the expression.
842 * This method converts these to full `ParseSourceSpan` objects that
843 * show where the span is within the overall source file.
844 *
845 * @param span the relative span to convert.
846 * @returns a `ParseSourceSpan` for the given span or null if no
847 * `baseSourceSpan` was provided to this class.
848 */
849 _AstToIrVisitor.prototype.convertSourceSpan = function (span) {
850 if (this.baseSourceSpan) {
851 var start = this.baseSourceSpan.start.moveBy(span.start);
852 var end = this.baseSourceSpan.start.moveBy(span.end);
853 var fullStart = this.baseSourceSpan.fullStart.moveBy(span.start);
854 return new parse_util_1.ParseSourceSpan(start, end, fullStart);
855 }
856 else {
857 return null;
858 }
859 };
860 /** Adds the name of an AST to the list of implicit receiver accesses. */
861 _AstToIrVisitor.prototype.addImplicitReceiverAccess = function (name) {
862 if (this.implicitReceiverAccesses) {
863 this.implicitReceiverAccesses.add(name);
864 }
865 };
866 return _AstToIrVisitor;
867 }());
868 function flattenStatements(arg, output) {
869 if (Array.isArray(arg)) {
870 arg.forEach(function (entry) { return flattenStatements(entry, output); });
871 }
872 else {
873 output.push(arg);
874 }
875 }
876 var DefaultLocalResolver = /** @class */ (function () {
877 function DefaultLocalResolver(globals) {
878 this.globals = globals;
879 }
880 DefaultLocalResolver.prototype.notifyImplicitReceiverUse = function () { };
881 DefaultLocalResolver.prototype.maybeRestoreView = function () { };
882 DefaultLocalResolver.prototype.getLocal = function (name) {
883 if (name === EventHandlerVars.event.name) {
884 return EventHandlerVars.event;
885 }
886 return null;
887 };
888 return DefaultLocalResolver;
889 }());
890 function createCurrValueExpr(bindingId) {
891 return o.variable("currVal_" + bindingId); // fix syntax highlighting: `
892 }
893 function createPreventDefaultVar(bindingId) {
894 return o.variable("pd_" + bindingId);
895 }
896 function convertStmtIntoExpression(stmt) {
897 if (stmt instanceof o.ExpressionStatement) {
898 return stmt.expr;
899 }
900 else if (stmt instanceof o.ReturnStatement) {
901 return stmt.value;
902 }
903 return null;
904 }
905 var BuiltinFunctionCall = /** @class */ (function (_super) {
906 tslib_1.__extends(BuiltinFunctionCall, _super);
907 function BuiltinFunctionCall(span, sourceSpan, args, converter) {
908 var _this = _super.call(this, span, sourceSpan, null, args) || this;
909 _this.converter = converter;
910 return _this;
911 }
912 return BuiltinFunctionCall;
913 }(cdAst.FunctionCall));
914 exports.BuiltinFunctionCall = BuiltinFunctionCall;
915});
916//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"expression_converter.js","sourceRoot":"","sources":["../../../../../../../packages/compiler/src/compiler_util/expression_converter.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 cdAst from '../expression_parser/ast';\nimport {Identifiers} from '../identifiers';\nimport * as o from '../output/output_ast';\nimport {ParseSourceSpan} from '../parse_util';\n\nexport class EventHandlerVars {\n  static event = o.variable('$event');\n}\n\nexport interface LocalResolver {\n  getLocal(name: string): o.Expression|null;\n  notifyImplicitReceiverUse(): void;\n  globals?: Set<string>;\n  maybeRestoreView(): void;\n}\n\nexport class ConvertActionBindingResult {\n  /**\n   * Store statements which are render3 compatible.\n   */\n  render3Stmts: o.Statement[];\n  constructor(\n      /**\n       * Render2 compatible statements,\n       */\n      public stmts: o.Statement[],\n      /**\n       * Variable name used with render2 compatible statements.\n       */\n      public allowDefault: o.ReadVarExpr) {\n    /**\n     * This is bit of a hack. It converts statements which render2 expects to statements which are\n     * expected by render3.\n     *\n     * Example: `<div click=\"doSomething($event)\">` will generate:\n     *\n     * Render3:\n     * ```\n     * const pd_b:any = ((<any>ctx.doSomething($event)) !== false);\n     * return pd_b;\n     * ```\n     *\n     * but render2 expects:\n     * ```\n     * return ctx.doSomething($event);\n     * ```\n     */\n    // TODO(misko): remove this hack once we no longer support ViewEngine.\n    this.render3Stmts = stmts.map((statement: o.Statement) => {\n      if (statement instanceof o.DeclareVarStmt && statement.name == allowDefault.name &&\n          statement.value instanceof o.BinaryOperatorExpr) {\n        const lhs = statement.value.lhs as o.CastExpr;\n        return new o.ReturnStatement(lhs.value);\n      }\n      return statement;\n    });\n  }\n}\n\nexport type InterpolationFunction = (args: o.Expression[]) => o.Expression;\n\n/**\n * Converts the given expression AST into an executable output AST, assuming the expression is\n * used in an action binding (e.g. an event handler).\n */\nexport function convertActionBinding(\n    localResolver: LocalResolver|null, implicitReceiver: o.Expression, action: cdAst.AST,\n    bindingId: string, interpolationFunction?: InterpolationFunction,\n    baseSourceSpan?: ParseSourceSpan, implicitReceiverAccesses?: Set<string>,\n    globals?: Set<string>): ConvertActionBindingResult {\n  if (!localResolver) {\n    localResolver = new DefaultLocalResolver(globals);\n  }\n  const actionWithoutBuiltins = convertPropertyBindingBuiltins(\n      {\n        createLiteralArrayConverter: (argCount: number) => {\n          // Note: no caching for literal arrays in actions.\n          return (args: o.Expression[]) => o.literalArr(args);\n        },\n        createLiteralMapConverter: (keys: {key: string, quoted: boolean}[]) => {\n          // Note: no caching for literal maps in actions.\n          return (values: o.Expression[]) => {\n            const entries = keys.map((k, i) => ({\n                                       key: k.key,\n                                       value: values[i],\n                                       quoted: k.quoted,\n                                     }));\n            return o.literalMap(entries);\n          };\n        },\n        createPipeConverter: (name: string) => {\n          throw new Error(`Illegal State: Actions are not allowed to contain pipes. Pipe: ${name}`);\n        }\n      },\n      action);\n\n  const visitor = new _AstToIrVisitor(\n      localResolver, implicitReceiver, bindingId, interpolationFunction, baseSourceSpan,\n      implicitReceiverAccesses);\n  const actionStmts: o.Statement[] = [];\n  flattenStatements(actionWithoutBuiltins.visit(visitor, _Mode.Statement), actionStmts);\n  prependTemporaryDecls(visitor.temporaryCount, bindingId, actionStmts);\n\n  if (visitor.usesImplicitReceiver) {\n    localResolver.notifyImplicitReceiverUse();\n  }\n\n  const lastIndex = actionStmts.length - 1;\n  let preventDefaultVar: o.ReadVarExpr = null!;\n  if (lastIndex >= 0) {\n    const lastStatement = actionStmts[lastIndex];\n    const returnExpr = convertStmtIntoExpression(lastStatement);\n    if (returnExpr) {\n      // Note: We need to cast the result of the method call to dynamic,\n      // as it might be a void method!\n      preventDefaultVar = createPreventDefaultVar(bindingId);\n      actionStmts[lastIndex] =\n          preventDefaultVar.set(returnExpr.cast(o.DYNAMIC_TYPE).notIdentical(o.literal(false)))\n              .toDeclStmt(null, [o.StmtModifier.Final]);\n    }\n  }\n  return new ConvertActionBindingResult(actionStmts, preventDefaultVar);\n}\n\nexport interface BuiltinConverter {\n  (args: o.Expression[]): o.Expression;\n}\n\nexport interface BuiltinConverterFactory {\n  createLiteralArrayConverter(argCount: number): BuiltinConverter;\n  createLiteralMapConverter(keys: {key: string, quoted: boolean}[]): BuiltinConverter;\n  createPipeConverter(name: string, argCount: number): BuiltinConverter;\n}\n\nexport function convertPropertyBindingBuiltins(\n    converterFactory: BuiltinConverterFactory, ast: cdAst.AST): cdAst.AST {\n  return convertBuiltins(converterFactory, ast);\n}\n\nexport class ConvertPropertyBindingResult {\n  constructor(public stmts: o.Statement[], public currValExpr: o.Expression) {}\n}\n\nexport enum BindingForm {\n  // The general form of binding expression, supports all expressions.\n  General,\n\n  // Try to generate a simple binding (no temporaries or statements)\n  // otherwise generate a general binding\n  TrySimple,\n\n  // Inlines assignment of temporaries into the generated expression. The result may still\n  // have statements attached for declarations of temporary variables.\n  // This is the only relevant form for Ivy, the other forms are only used in ViewEngine.\n  Expression,\n}\n\n/**\n * Converts the given expression AST into an executable output AST, assuming the expression\n * is used in property binding. The expression has to be preprocessed via\n * `convertPropertyBindingBuiltins`.\n */\nexport function convertPropertyBinding(\n    localResolver: LocalResolver|null, implicitReceiver: o.Expression,\n    expressionWithoutBuiltins: cdAst.AST, bindingId: string, form: BindingForm,\n    interpolationFunction?: InterpolationFunction): ConvertPropertyBindingResult {\n  if (!localResolver) {\n    localResolver = new DefaultLocalResolver();\n  }\n  const visitor =\n      new _AstToIrVisitor(localResolver, implicitReceiver, bindingId, interpolationFunction);\n  const outputExpr: o.Expression = expressionWithoutBuiltins.visit(visitor, _Mode.Expression);\n  const stmts: o.Statement[] = getStatementsFromVisitor(visitor, bindingId);\n\n  if (visitor.usesImplicitReceiver) {\n    localResolver.notifyImplicitReceiverUse();\n  }\n\n  if (visitor.temporaryCount === 0 && form == BindingForm.TrySimple) {\n    return new ConvertPropertyBindingResult([], outputExpr);\n  } else if (form === BindingForm.Expression) {\n    return new ConvertPropertyBindingResult(stmts, outputExpr);\n  }\n\n  const currValExpr = createCurrValueExpr(bindingId);\n  stmts.push(currValExpr.set(outputExpr).toDeclStmt(o.DYNAMIC_TYPE, [o.StmtModifier.Final]));\n  return new ConvertPropertyBindingResult(stmts, currValExpr);\n}\n\n/**\n * Given some expression, such as a binding or interpolation expression, and a context expression to\n * look values up on, visit each facet of the given expression resolving values from the context\n * expression such that a list of arguments can be derived from the found values that can be used as\n * arguments to an external update instruction.\n *\n * @param localResolver The resolver to use to look up expressions by name appropriately\n * @param contextVariableExpression The expression representing the context variable used to create\n * the final argument expressions\n * @param expressionWithArgumentsToExtract The expression to visit to figure out what values need to\n * be resolved and what arguments list to build.\n * @param bindingId A name prefix used to create temporary variable names if they're needed for the\n * arguments generated\n * @returns An array of expressions that can be passed as arguments to instruction expressions like\n * `o.importExpr(R3.propertyInterpolate).callFn(result)`\n */\nexport function convertUpdateArguments(\n    localResolver: LocalResolver, contextVariableExpression: o.Expression,\n    expressionWithArgumentsToExtract: cdAst.AST, bindingId: string) {\n  const visitor =\n      new _AstToIrVisitor(localResolver, contextVariableExpression, bindingId, undefined);\n  const outputExpr: o.InvokeFunctionExpr =\n      expressionWithArgumentsToExtract.visit(visitor, _Mode.Expression);\n\n  if (visitor.usesImplicitReceiver) {\n    localResolver.notifyImplicitReceiverUse();\n  }\n\n  const stmts = getStatementsFromVisitor(visitor, bindingId);\n\n  // Removing the first argument, because it was a length for ViewEngine, not Ivy.\n  let args = outputExpr.args.slice(1);\n  if (expressionWithArgumentsToExtract instanceof cdAst.Interpolation) {\n    // If we're dealing with an interpolation of 1 value with an empty prefix and suffix, reduce the\n    // args returned to just the value, because we're going to pass it to a special instruction.\n    const strings = expressionWithArgumentsToExtract.strings;\n    if (args.length === 3 && strings[0] === '' && strings[1] === '') {\n      // Single argument interpolate instructions.\n      args = [args[1]];\n    } else if (args.length >= 19) {\n      // 19 or more arguments must be passed to the `interpolateV`-style instructions, which accept\n      // an array of arguments\n      args = [o.literalArr(args)];\n    }\n  }\n  return {stmts, args};\n}\n\nfunction getStatementsFromVisitor(visitor: _AstToIrVisitor, bindingId: string) {\n  const stmts: o.Statement[] = [];\n  for (let i = 0; i < visitor.temporaryCount; i++) {\n    stmts.push(temporaryDeclaration(bindingId, i));\n  }\n  return stmts;\n}\n\nfunction convertBuiltins(converterFactory: BuiltinConverterFactory, ast: cdAst.AST): cdAst.AST {\n  const visitor = new _BuiltinAstConverter(converterFactory);\n  return ast.visit(visitor);\n}\n\nfunction temporaryName(bindingId: string, temporaryNumber: number): string {\n  return `tmp_${bindingId}_${temporaryNumber}`;\n}\n\nfunction temporaryDeclaration(bindingId: string, temporaryNumber: number): o.Statement {\n  return new o.DeclareVarStmt(temporaryName(bindingId, temporaryNumber));\n}\n\nfunction prependTemporaryDecls(\n    temporaryCount: number, bindingId: string, statements: o.Statement[]) {\n  for (let i = temporaryCount - 1; i >= 0; i--) {\n    statements.unshift(temporaryDeclaration(bindingId, i));\n  }\n}\n\nenum _Mode {\n  Statement,\n  Expression\n}\n\nfunction ensureStatementMode(mode: _Mode, ast: cdAst.AST) {\n  if (mode !== _Mode.Statement) {\n    throw new Error(`Expected a statement, but saw ${ast}`);\n  }\n}\n\nfunction ensureExpressionMode(mode: _Mode, ast: cdAst.AST) {\n  if (mode !== _Mode.Expression) {\n    throw new Error(`Expected an expression, but saw ${ast}`);\n  }\n}\n\nfunction convertToStatementIfNeeded(mode: _Mode, expr: o.Expression): o.Expression|o.Statement {\n  if (mode === _Mode.Statement) {\n    return expr.toStmt();\n  } else {\n    return expr;\n  }\n}\n\nclass _BuiltinAstConverter extends cdAst.AstTransformer {\n  constructor(private _converterFactory: BuiltinConverterFactory) {\n    super();\n  }\n  override visitPipe(ast: cdAst.BindingPipe, context: any): any {\n    const args = [ast.exp, ...ast.args].map(ast => ast.visit(this, context));\n    return new BuiltinFunctionCall(\n        ast.span, ast.sourceSpan, args,\n        this._converterFactory.createPipeConverter(ast.name, args.length));\n  }\n  override visitLiteralArray(ast: cdAst.LiteralArray, context: any): any {\n    const args = ast.expressions.map(ast => ast.visit(this, context));\n    return new BuiltinFunctionCall(\n        ast.span, ast.sourceSpan, args,\n        this._converterFactory.createLiteralArrayConverter(ast.expressions.length));\n  }\n  override visitLiteralMap(ast: cdAst.LiteralMap, context: any): any {\n    const args = ast.values.map(ast => ast.visit(this, context));\n\n    return new BuiltinFunctionCall(\n        ast.span, ast.sourceSpan, args, this._converterFactory.createLiteralMapConverter(ast.keys));\n  }\n}\n\nclass _AstToIrVisitor implements cdAst.AstVisitor {\n  private _nodeMap = new Map<cdAst.AST, cdAst.AST>();\n  private _resultMap = new Map<cdAst.AST, o.Expression>();\n  private _currentTemporary: number = 0;\n  public temporaryCount: number = 0;\n  public usesImplicitReceiver: boolean = false;\n\n  constructor(\n      private _localResolver: LocalResolver, private _implicitReceiver: o.Expression,\n      private bindingId: string, private interpolationFunction: InterpolationFunction|undefined,\n      private baseSourceSpan?: ParseSourceSpan, private implicitReceiverAccesses?: Set<string>) {}\n\n  visitUnary(ast: cdAst.Unary, mode: _Mode): any {\n    let op: o.UnaryOperator;\n    switch (ast.operator) {\n      case '+':\n        op = o.UnaryOperator.Plus;\n        break;\n      case '-':\n        op = o.UnaryOperator.Minus;\n        break;\n      default:\n        throw new Error(`Unsupported operator ${ast.operator}`);\n    }\n\n    return convertToStatementIfNeeded(\n        mode,\n        new o.UnaryOperatorExpr(\n            op, this._visit(ast.expr, _Mode.Expression), undefined,\n            this.convertSourceSpan(ast.span)));\n  }\n\n  visitBinary(ast: cdAst.Binary, mode: _Mode): any {\n    let op: o.BinaryOperator;\n    switch (ast.operation) {\n      case '+':\n        op = o.BinaryOperator.Plus;\n        break;\n      case '-':\n        op = o.BinaryOperator.Minus;\n        break;\n      case '*':\n        op = o.BinaryOperator.Multiply;\n        break;\n      case '/':\n        op = o.BinaryOperator.Divide;\n        break;\n      case '%':\n        op = o.BinaryOperator.Modulo;\n        break;\n      case '&&':\n        op = o.BinaryOperator.And;\n        break;\n      case '||':\n        op = o.BinaryOperator.Or;\n        break;\n      case '==':\n        op = o.BinaryOperator.Equals;\n        break;\n      case '!=':\n        op = o.BinaryOperator.NotEquals;\n        break;\n      case '===':\n        op = o.BinaryOperator.Identical;\n        break;\n      case '!==':\n        op = o.BinaryOperator.NotIdentical;\n        break;\n      case '<':\n        op = o.BinaryOperator.Lower;\n        break;\n      case '>':\n        op = o.BinaryOperator.Bigger;\n        break;\n      case '<=':\n        op = o.BinaryOperator.LowerEquals;\n        break;\n      case '>=':\n        op = o.BinaryOperator.BiggerEquals;\n        break;\n      case '??':\n        return this.convertNullishCoalesce(ast, mode);\n      default:\n        throw new Error(`Unsupported operation ${ast.operation}`);\n    }\n\n    return convertToStatementIfNeeded(\n        mode,\n        new o.BinaryOperatorExpr(\n            op, this._visit(ast.left, _Mode.Expression), this._visit(ast.right, _Mode.Expression),\n            undefined, this.convertSourceSpan(ast.span)));\n  }\n\n  visitChain(ast: cdAst.Chain, mode: _Mode): any {\n    ensureStatementMode(mode, ast);\n    return this.visitAll(ast.expressions, mode);\n  }\n\n  visitConditional(ast: cdAst.Conditional, mode: _Mode): any {\n    const value: o.Expression = this._visit(ast.condition, _Mode.Expression);\n    return convertToStatementIfNeeded(\n        mode,\n        value.conditional(\n            this._visit(ast.trueExp, _Mode.Expression), this._visit(ast.falseExp, _Mode.Expression),\n            this.convertSourceSpan(ast.span)));\n  }\n\n  visitPipe(ast: cdAst.BindingPipe, mode: _Mode): any {\n    throw new Error(\n        `Illegal state: Pipes should have been converted into functions. Pipe: ${ast.name}`);\n  }\n\n  visitFunctionCall(ast: cdAst.FunctionCall, mode: _Mode): any {\n    const convertedArgs = this.visitAll(ast.args, _Mode.Expression);\n    let fnResult: o.Expression;\n    if (ast instanceof BuiltinFunctionCall) {\n      fnResult = ast.converter(convertedArgs);\n    } else {\n      fnResult = this._visit(ast.target!, _Mode.Expression)\n                     .callFn(convertedArgs, this.convertSourceSpan(ast.span));\n    }\n    return convertToStatementIfNeeded(mode, fnResult);\n  }\n\n  visitImplicitReceiver(ast: cdAst.ImplicitReceiver, mode: _Mode): any {\n    ensureExpressionMode(mode, ast);\n    this.usesImplicitReceiver = true;\n    return this._implicitReceiver;\n  }\n\n  visitThisReceiver(ast: cdAst.ThisReceiver, mode: _Mode): any {\n    return this.visitImplicitReceiver(ast, mode);\n  }\n\n  visitInterpolation(ast: cdAst.Interpolation, mode: _Mode): any {\n    ensureExpressionMode(mode, ast);\n    const args = [o.literal(ast.expressions.length)];\n    for (let i = 0; i < ast.strings.length - 1; i++) {\n      args.push(o.literal(ast.strings[i]));\n      args.push(this._visit(ast.expressions[i], _Mode.Expression));\n    }\n    args.push(o.literal(ast.strings[ast.strings.length - 1]));\n\n    if (this.interpolationFunction) {\n      return this.interpolationFunction(args);\n    }\n    return ast.expressions.length <= 9 ?\n        o.importExpr(Identifiers.inlineInterpolate).callFn(args) :\n        o.importExpr(Identifiers.interpolate).callFn([\n          args[0], o.literalArr(args.slice(1), undefined, this.convertSourceSpan(ast.span))\n        ]);\n  }\n\n  visitKeyedRead(ast: cdAst.KeyedRead, mode: _Mode): any {\n    const leftMostSafe = this.leftMostSafeNode(ast);\n    if (leftMostSafe) {\n      return this.convertSafeAccess(ast, leftMostSafe, mode);\n    } else {\n      return convertToStatementIfNeeded(\n          mode,\n          this._visit(ast.receiver, _Mode.Expression).key(this._visit(ast.key, _Mode.Expression)));\n    }\n  }\n\n  visitKeyedWrite(ast: cdAst.KeyedWrite, mode: _Mode): any {\n    const obj: o.Expression = this._visit(ast.receiver, _Mode.Expression);\n    const key: o.Expression = this._visit(ast.key, _Mode.Expression);\n    const value: o.Expression = this._visit(ast.value, _Mode.Expression);\n\n    if (obj === this._implicitReceiver) {\n      this._localResolver.maybeRestoreView();\n    }\n\n    return convertToStatementIfNeeded(mode, obj.key(key).set(value));\n  }\n\n  visitLiteralArray(ast: cdAst.LiteralArray, mode: _Mode): any {\n    throw new Error(`Illegal State: literal arrays should have been converted into functions`);\n  }\n\n  visitLiteralMap(ast: cdAst.LiteralMap, mode: _Mode): any {\n    throw new Error(`Illegal State: literal maps should have been converted into functions`);\n  }\n\n  visitLiteralPrimitive(ast: cdAst.LiteralPrimitive, mode: _Mode): any {\n    // For literal values of null, undefined, true, or false allow type interference\n    // to infer the type.\n    const type =\n        ast.value === null || ast.value === undefined || ast.value === true || ast.value === true ?\n        o.INFERRED_TYPE :\n        undefined;\n    return convertToStatementIfNeeded(\n        mode, o.literal(ast.value, type, this.convertSourceSpan(ast.span)));\n  }\n\n  private _getLocal(name: string, receiver: cdAst.AST): o.Expression|null {\n    if (this._localResolver.globals?.has(name) && receiver instanceof cdAst.ThisReceiver) {\n      return null;\n    }\n\n    return this._localResolver.getLocal(name);\n  }\n\n  visitMethodCall(ast: cdAst.MethodCall, mode: _Mode): any {\n    if (ast.receiver instanceof cdAst.ImplicitReceiver &&\n        !(ast.receiver instanceof cdAst.ThisReceiver) && ast.name === '$any') {\n      const args = this.visitAll(ast.args, _Mode.Expression) as any[];\n      if (args.length != 1) {\n        throw new Error(\n            `Invalid call to $any, expected 1 argument but received ${args.length || 'none'}`);\n      }\n      return (args[0] as o.Expression).cast(o.DYNAMIC_TYPE, this.convertSourceSpan(ast.span));\n    }\n\n    const leftMostSafe = this.leftMostSafeNode(ast);\n    if (leftMostSafe) {\n      return this.convertSafeAccess(ast, leftMostSafe, mode);\n    } else {\n      const args = this.visitAll(ast.args, _Mode.Expression);\n      const prevUsesImplicitReceiver = this.usesImplicitReceiver;\n      let result: any = null;\n      const receiver = this._visit(ast.receiver, _Mode.Expression);\n      if (receiver === this._implicitReceiver) {\n        const varExpr = this._getLocal(ast.name, ast.receiver);\n        if (varExpr) {\n          // Restore the previous \"usesImplicitReceiver\" state since the implicit\n          // receiver has been replaced with a resolved local expression.\n          this.usesImplicitReceiver = prevUsesImplicitReceiver;\n          result = varExpr.callFn(args);\n          this.addImplicitReceiverAccess(ast.name);\n        }\n      }\n      if (result == null) {\n        result = receiver.callMethod(ast.name, args, this.convertSourceSpan(ast.span));\n      }\n      return convertToStatementIfNeeded(mode, result);\n    }\n  }\n\n  visitPrefixNot(ast: cdAst.PrefixNot, mode: _Mode): any {\n    return convertToStatementIfNeeded(mode, o.not(this._visit(ast.expression, _Mode.Expression)));\n  }\n\n  visitNonNullAssert(ast: cdAst.NonNullAssert, mode: _Mode): any {\n    return convertToStatementIfNeeded(\n        mode, o.assertNotNull(this._visit(ast.expression, _Mode.Expression)));\n  }\n\n  visitPropertyRead(ast: cdAst.PropertyRead, mode: _Mode): any {\n    const leftMostSafe = this.leftMostSafeNode(ast);\n    if (leftMostSafe) {\n      return this.convertSafeAccess(ast, leftMostSafe, mode);\n    } else {\n      let result: any = null;\n      const prevUsesImplicitReceiver = this.usesImplicitReceiver;\n      const receiver = this._visit(ast.receiver, _Mode.Expression);\n      if (receiver === this._implicitReceiver) {\n        result = this._getLocal(ast.name, ast.receiver);\n        if (result) {\n          // Restore the previous \"usesImplicitReceiver\" state since the implicit\n          // receiver has been replaced with a resolved local expression.\n          this.usesImplicitReceiver = prevUsesImplicitReceiver;\n          this.addImplicitReceiverAccess(ast.name);\n        }\n      }\n      if (result == null) {\n        result = receiver.prop(ast.name);\n      }\n      return convertToStatementIfNeeded(mode, result);\n    }\n  }\n\n  visitPropertyWrite(ast: cdAst.PropertyWrite, mode: _Mode): any {\n    const receiver: o.Expression = this._visit(ast.receiver, _Mode.Expression);\n    const prevUsesImplicitReceiver = this.usesImplicitReceiver;\n\n    let varExpr: o.ReadPropExpr|null = null;\n    if (receiver === this._implicitReceiver) {\n      const localExpr = this._getLocal(ast.name, ast.receiver);\n      if (localExpr) {\n        if (localExpr instanceof o.ReadPropExpr) {\n          // If the local variable is a property read expression, it's a reference\n          // to a 'context.property' value and will be used as the target of the\n          // write expression.\n          varExpr = localExpr;\n          // Restore the previous \"usesImplicitReceiver\" state since the implicit\n          // receiver has been replaced with a resolved local expression.\n          this.usesImplicitReceiver = prevUsesImplicitReceiver;\n          this.addImplicitReceiverAccess(ast.name);\n        } else {\n          // Otherwise it's an error.\n          const receiver = ast.name;\n          const value = (ast.value instanceof cdAst.PropertyRead) ? ast.value.name : undefined;\n          throw new Error(`Cannot assign value \"${value}\" to template variable \"${\n              receiver}\". Template variables are read-only.`);\n        }\n      }\n    }\n    // If no local expression could be produced, use the original receiver's\n    // property as the target.\n    if (varExpr === null) {\n      varExpr = receiver.prop(ast.name);\n    }\n    return convertToStatementIfNeeded(mode, varExpr.set(this._visit(ast.value, _Mode.Expression)));\n  }\n\n  visitSafePropertyRead(ast: cdAst.SafePropertyRead, mode: _Mode): any {\n    return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);\n  }\n\n  visitSafeMethodCall(ast: cdAst.SafeMethodCall, mode: _Mode): any {\n    return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);\n  }\n\n  visitSafeKeyedRead(ast: cdAst.SafeKeyedRead, mode: _Mode): any {\n    return this.convertSafeAccess(ast, this.leftMostSafeNode(ast), mode);\n  }\n\n  visitAll(asts: cdAst.AST[], mode: _Mode): any {\n    return asts.map(ast => this._visit(ast, mode));\n  }\n\n  visitQuote(ast: cdAst.Quote, mode: _Mode): any {\n    throw new Error(`Quotes are not supported for evaluation!\n        Statement: ${ast.uninterpretedExpression} located at ${ast.location}`);\n  }\n\n  private _visit(ast: cdAst.AST, mode: _Mode): any {\n    const result = this._resultMap.get(ast);\n    if (result) return result;\n    return (this._nodeMap.get(ast) || ast).visit(this, mode);\n  }\n\n  private convertSafeAccess(\n      ast: cdAst.AST, leftMostSafe: cdAst.SafeMethodCall|cdAst.SafePropertyRead|cdAst.SafeKeyedRead,\n      mode: _Mode): any {\n    // If the expression contains a safe access node on the left it needs to be converted to\n    // an expression that guards the access to the member by checking the receiver for blank. As\n    // execution proceeds from left to right, the left most part of the expression must be guarded\n    // first but, because member access is left associative, the right side of the expression is at\n    // the top of the AST. The desired result requires lifting a copy of the left part of the\n    // expression up to test it for blank before generating the unguarded version.\n\n    // Consider, for example the following expression: a?.b.c?.d.e\n\n    // This results in the ast:\n    //         .\n    //        / \\\n    //       ?.   e\n    //      /  \\\n    //     .    d\n    //    / \\\n    //   ?.  c\n    //  /  \\\n    // a    b\n\n    // The following tree should be generated:\n    //\n    //        /---- ? ----\\\n    //       /      |      \\\n    //     a   /--- ? ---\\  null\n    //        /     |     \\\n    //       .      .     null\n    //      / \\    / \\\n    //     .  c   .   e\n    //    / \\    / \\\n    //   a   b  .   d\n    //         / \\\n    //        .   c\n    //       / \\\n    //      a   b\n    //\n    // Notice that the first guard condition is the left hand of the left most safe access node\n    // which comes in as leftMostSafe to this routine.\n\n    let guardedExpression = this._visit(leftMostSafe.receiver, _Mode.Expression);\n    let temporary: o.ReadVarExpr = undefined!;\n    if (this.needsTemporaryInSafeAccess(leftMostSafe.receiver)) {\n      // If the expression has method calls or pipes then we need to save the result into a\n      // temporary variable to avoid calling stateful or impure code more than once.\n      temporary = this.allocateTemporary();\n\n      // Preserve the result in the temporary variable\n      guardedExpression = temporary.set(guardedExpression);\n\n      // Ensure all further references to the guarded expression refer to the temporary instead.\n      this._resultMap.set(leftMostSafe.receiver, temporary);\n    }\n    const condition = guardedExpression.isBlank();\n\n    // Convert the ast to an unguarded access to the receiver's member. The map will substitute\n    // leftMostNode with its unguarded version in the call to `this.visit()`.\n    if (leftMostSafe instanceof cdAst.SafeMethodCall) {\n      this._nodeMap.set(\n          leftMostSafe,\n          new cdAst.MethodCall(\n              leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.nameSpan,\n              leftMostSafe.receiver, leftMostSafe.name, leftMostSafe.args,\n              leftMostSafe.argumentSpan));\n    } else if (leftMostSafe instanceof cdAst.SafeKeyedRead) {\n      this._nodeMap.set(\n          leftMostSafe,\n          new cdAst.KeyedRead(\n              leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.receiver, leftMostSafe.key));\n    } else {\n      this._nodeMap.set(\n          leftMostSafe,\n          new cdAst.PropertyRead(\n              leftMostSafe.span, leftMostSafe.sourceSpan, leftMostSafe.nameSpan,\n              leftMostSafe.receiver, leftMostSafe.name));\n    }\n\n    // Recursively convert the node now without the guarded member access.\n    const access = this._visit(ast, _Mode.Expression);\n\n    // Remove the mapping. This is not strictly required as the converter only traverses each node\n    // once but is safer if the conversion is changed to traverse the nodes more than once.\n    this._nodeMap.delete(leftMostSafe);\n\n    // If we allocated a temporary, release it.\n    if (temporary) {\n      this.releaseTemporary(temporary);\n    }\n\n    // Produce the conditional\n    return convertToStatementIfNeeded(mode, condition.conditional(o.NULL_EXPR, access));\n  }\n\n  private convertNullishCoalesce(ast: cdAst.Binary, mode: _Mode): any {\n    const left: o.Expression = this._visit(ast.left, _Mode.Expression);\n    const right: o.Expression = this._visit(ast.right, _Mode.Expression);\n    const temporary = this.allocateTemporary();\n    this.releaseTemporary(temporary);\n\n    // Generate the following expression. It is identical to how TS\n    // transpiles binary expressions with a nullish coalescing operator.\n    // let temp;\n    // (temp = a) !== null && temp !== undefined ? temp : b;\n    return convertToStatementIfNeeded(\n        mode,\n        temporary.set(left)\n            .notIdentical(o.NULL_EXPR)\n            .and(temporary.notIdentical(o.literal(undefined)))\n            .conditional(temporary, right));\n  }\n\n  // Given an expression of the form a?.b.c?.d.e then the left most safe node is\n  // the (a?.b). The . and ?. are left associative thus can be rewritten as:\n  // ((((a?.c).b).c)?.d).e. This returns the most deeply nested safe read or\n  // safe method call as this needs to be transformed initially to:\n  //   a == null ? null : a.c.b.c?.d.e\n  // then to:\n  //   a == null ? null : a.b.c == null ? null : a.b.c.d.e\n  private leftMostSafeNode(ast: cdAst.AST): cdAst.SafePropertyRead|cdAst.SafeMethodCall\n      |cdAst.SafeKeyedRead {\n    const visit = (visitor: cdAst.AstVisitor, ast: cdAst.AST): any => {\n      return (this._nodeMap.get(ast) || ast).visit(visitor);\n    };\n    return ast.visit({\n      visitUnary(ast: cdAst.Unary) {\n        return null;\n      },\n      visitBinary(ast: cdAst.Binary) {\n        return null;\n      },\n      visitChain(ast: cdAst.Chain) {\n        return null;\n      },\n      visitConditional(ast: cdAst.Conditional) {\n        return null;\n      },\n      visitFunctionCall(ast: cdAst.FunctionCall) {\n        return null;\n      },\n      visitImplicitReceiver(ast: cdAst.ImplicitReceiver) {\n        return null;\n      },\n      visitThisReceiver(ast: cdAst.ThisReceiver) {\n        return null;\n      },\n      visitInterpolation(ast: cdAst.Interpolation) {\n        return null;\n      },\n      visitKeyedRead(ast: cdAst.KeyedRead) {\n        return visit(this, ast.receiver);\n      },\n      visitKeyedWrite(ast: cdAst.KeyedWrite) {\n        return null;\n      },\n      visitLiteralArray(ast: cdAst.LiteralArray) {\n        return null;\n      },\n      visitLiteralMap(ast: cdAst.LiteralMap) {\n        return null;\n      },\n      visitLiteralPrimitive(ast: cdAst.LiteralPrimitive) {\n        return null;\n      },\n      visitMethodCall(ast: cdAst.MethodCall) {\n        return visit(this, ast.receiver);\n      },\n      visitPipe(ast: cdAst.BindingPipe) {\n        return null;\n      },\n      visitPrefixNot(ast: cdAst.PrefixNot) {\n        return null;\n      },\n      visitNonNullAssert(ast: cdAst.NonNullAssert) {\n        return null;\n      },\n      visitPropertyRead(ast: cdAst.PropertyRead) {\n        return visit(this, ast.receiver);\n      },\n      visitPropertyWrite(ast: cdAst.PropertyWrite) {\n        return null;\n      },\n      visitQuote(ast: cdAst.Quote) {\n        return null;\n      },\n      visitSafeMethodCall(ast: cdAst.SafeMethodCall) {\n        return visit(this, ast.receiver) || ast;\n      },\n      visitSafePropertyRead(ast: cdAst.SafePropertyRead) {\n        return visit(this, ast.receiver) || ast;\n      },\n      visitSafeKeyedRead(ast: cdAst.SafeKeyedRead) {\n        return visit(this, ast.receiver) || ast;\n      }\n    });\n  }\n\n  // Returns true of the AST includes a method or a pipe indicating that, if the\n  // expression is used as the target of a safe property or method access then\n  // the expression should be stored into a temporary variable.\n  private needsTemporaryInSafeAccess(ast: cdAst.AST): boolean {\n    const visit = (visitor: cdAst.AstVisitor, ast: cdAst.AST): boolean => {\n      return ast && (this._nodeMap.get(ast) || ast).visit(visitor);\n    };\n    const visitSome = (visitor: cdAst.AstVisitor, ast: cdAst.AST[]): boolean => {\n      return ast.some(ast => visit(visitor, ast));\n    };\n    return ast.visit({\n      visitUnary(ast: cdAst.Unary): boolean {\n        return visit(this, ast.expr);\n      },\n      visitBinary(ast: cdAst.Binary): boolean {\n        return visit(this, ast.left) || visit(this, ast.right);\n      },\n      visitChain(ast: cdAst.Chain) {\n        return false;\n      },\n      visitConditional(ast: cdAst.Conditional): boolean {\n        return visit(this, ast.condition) || visit(this, ast.trueExp) || visit(this, ast.falseExp);\n      },\n      visitFunctionCall(ast: cdAst.FunctionCall) {\n        return true;\n      },\n      visitImplicitReceiver(ast: cdAst.ImplicitReceiver) {\n        return false;\n      },\n      visitThisReceiver(ast: cdAst.ThisReceiver) {\n        return false;\n      },\n      visitInterpolation(ast: cdAst.Interpolation) {\n        return visitSome(this, ast.expressions);\n      },\n      visitKeyedRead(ast: cdAst.KeyedRead) {\n        return false;\n      },\n      visitKeyedWrite(ast: cdAst.KeyedWrite) {\n        return false;\n      },\n      visitLiteralArray(ast: cdAst.LiteralArray) {\n        return true;\n      },\n      visitLiteralMap(ast: cdAst.LiteralMap) {\n        return true;\n      },\n      visitLiteralPrimitive(ast: cdAst.LiteralPrimitive) {\n        return false;\n      },\n      visitMethodCall(ast: cdAst.MethodCall) {\n        return true;\n      },\n      visitPipe(ast: cdAst.BindingPipe) {\n        return true;\n      },\n      visitPrefixNot(ast: cdAst.PrefixNot) {\n        return visit(this, ast.expression);\n      },\n      visitNonNullAssert(ast: cdAst.PrefixNot) {\n        return visit(this, ast.expression);\n      },\n      visitPropertyRead(ast: cdAst.PropertyRead) {\n        return false;\n      },\n      visitPropertyWrite(ast: cdAst.PropertyWrite) {\n        return false;\n      },\n      visitQuote(ast: cdAst.Quote) {\n        return false;\n      },\n      visitSafeMethodCall(ast: cdAst.SafeMethodCall) {\n        return true;\n      },\n      visitSafePropertyRead(ast: cdAst.SafePropertyRead) {\n        return false;\n      },\n      visitSafeKeyedRead(ast: cdAst.SafeKeyedRead) {\n        return false;\n      }\n    });\n  }\n\n  private allocateTemporary(): o.ReadVarExpr {\n    const tempNumber = this._currentTemporary++;\n    this.temporaryCount = Math.max(this._currentTemporary, this.temporaryCount);\n    return new o.ReadVarExpr(temporaryName(this.bindingId, tempNumber));\n  }\n\n  private releaseTemporary(temporary: o.ReadVarExpr) {\n    this._currentTemporary--;\n    if (temporary.name != temporaryName(this.bindingId, this._currentTemporary)) {\n      throw new Error(`Temporary ${temporary.name} released out of order`);\n    }\n  }\n\n  /**\n   * Creates an absolute `ParseSourceSpan` from the relative `ParseSpan`.\n   *\n   * `ParseSpan` objects are relative to the start of the expression.\n   * This method converts these to full `ParseSourceSpan` objects that\n   * show where the span is within the overall source file.\n   *\n   * @param span the relative span to convert.\n   * @returns a `ParseSourceSpan` for the given span or null if no\n   * `baseSourceSpan` was provided to this class.\n   */\n  private convertSourceSpan(span: cdAst.ParseSpan) {\n    if (this.baseSourceSpan) {\n      const start = this.baseSourceSpan.start.moveBy(span.start);\n      const end = this.baseSourceSpan.start.moveBy(span.end);\n      const fullStart = this.baseSourceSpan.fullStart.moveBy(span.start);\n      return new ParseSourceSpan(start, end, fullStart);\n    } else {\n      return null;\n    }\n  }\n\n  /** Adds the name of an AST to the list of implicit receiver accesses. */\n  private addImplicitReceiverAccess(name: string) {\n    if (this.implicitReceiverAccesses) {\n      this.implicitReceiverAccesses.add(name);\n    }\n  }\n}\n\nfunction flattenStatements(arg: any, output: o.Statement[]) {\n  if (Array.isArray(arg)) {\n    (<any[]>arg).forEach((entry) => flattenStatements(entry, output));\n  } else {\n    output.push(arg);\n  }\n}\n\nclass DefaultLocalResolver implements LocalResolver {\n  constructor(public globals?: Set<string>) {}\n  notifyImplicitReceiverUse(): void {}\n  maybeRestoreView(): void {}\n  getLocal(name: string): o.Expression|null {\n    if (name === EventHandlerVars.event.name) {\n      return EventHandlerVars.event;\n    }\n    return null;\n  }\n}\n\nfunction createCurrValueExpr(bindingId: string): o.ReadVarExpr {\n  return o.variable(`currVal_${bindingId}`);  // fix syntax highlighting: `\n}\n\nfunction createPreventDefaultVar(bindingId: string): o.ReadVarExpr {\n  return o.variable(`pd_${bindingId}`);\n}\n\nfunction convertStmtIntoExpression(stmt: o.Statement): o.Expression|null {\n  if (stmt instanceof o.ExpressionStatement) {\n    return stmt.expr;\n  } else if (stmt instanceof o.ReturnStatement) {\n    return stmt.value;\n  }\n  return null;\n}\n\nexport class BuiltinFunctionCall extends cdAst.FunctionCall {\n  constructor(\n      span: cdAst.ParseSpan, sourceSpan: cdAst.AbsoluteSourceSpan, args: cdAst.AST[],\n      public converter: BuiltinConverter) {\n    super(span, sourceSpan, null, args);\n  }\n}\n"]}
Note: See TracBrowser for help on using the repository browser.