source: trip-planner-front/node_modules/@angular/compiler/esm2015/src/view_compiler/view_compiler.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: 141.4 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 */
8import { rendererTypeName, tokenReference, viewClassName } from '../compile_metadata';
9import { BindingForm, convertActionBinding, convertPropertyBinding, convertPropertyBindingBuiltins, EventHandlerVars } from '../compiler_util/expression_converter';
10import { ChangeDetectionStrategy } from '../core';
11import { Identifiers } from '../identifiers';
12import { LifecycleHooks } from '../lifecycle_reflector';
13import { isNgContainer } from '../ml_parser/tags';
14import * as o from '../output/output_ast';
15import { convertValueToOutputAst } from '../output/value_util';
16import { ElementAst, EmbeddedTemplateAst, NgContentAst, templateVisitAll } from '../template_parser/template_ast';
17import { componentFactoryResolverProviderDef, depDef, lifecycleHookToNodeFlag, providerDef } from './provider_compiler';
18const CLASS_ATTR = 'class';
19const STYLE_ATTR = 'style';
20const IMPLICIT_TEMPLATE_VAR = '$implicit';
21export class ViewCompileResult {
22 constructor(viewClassVar, rendererTypeVar) {
23 this.viewClassVar = viewClassVar;
24 this.rendererTypeVar = rendererTypeVar;
25 }
26}
27export class ViewCompiler {
28 constructor(_reflector) {
29 this._reflector = _reflector;
30 }
31 compileComponent(outputCtx, component, template, styles, usedPipes) {
32 let embeddedViewCount = 0;
33 let renderComponentVarName = undefined;
34 if (!component.isHost) {
35 const template = component.template;
36 const customRenderData = [];
37 if (template.animations && template.animations.length) {
38 customRenderData.push(new o.LiteralMapEntry('animation', convertValueToOutputAst(outputCtx, template.animations), true));
39 }
40 const renderComponentVar = o.variable(rendererTypeName(component.type.reference));
41 renderComponentVarName = renderComponentVar.name;
42 outputCtx.statements.push(renderComponentVar
43 .set(o.importExpr(Identifiers.createRendererType2).callFn([new o.LiteralMapExpr([
44 new o.LiteralMapEntry('encapsulation', o.literal(template.encapsulation), false),
45 new o.LiteralMapEntry('styles', styles, false),
46 new o.LiteralMapEntry('data', new o.LiteralMapExpr(customRenderData), false)
47 ])]))
48 .toDeclStmt(o.importType(Identifiers.RendererType2), [o.StmtModifier.Final, o.StmtModifier.Exported]));
49 }
50 const viewBuilderFactory = (parent) => {
51 const embeddedViewIndex = embeddedViewCount++;
52 return new ViewBuilder(this._reflector, outputCtx, parent, component, embeddedViewIndex, usedPipes, viewBuilderFactory);
53 };
54 const visitor = viewBuilderFactory(null);
55 visitor.visitAll([], template);
56 outputCtx.statements.push(...visitor.build());
57 return new ViewCompileResult(visitor.viewName, renderComponentVarName);
58 }
59}
60const LOG_VAR = o.variable('_l');
61const VIEW_VAR = o.variable('_v');
62const CHECK_VAR = o.variable('_ck');
63const COMP_VAR = o.variable('_co');
64const EVENT_NAME_VAR = o.variable('en');
65const ALLOW_DEFAULT_VAR = o.variable(`ad`);
66class ViewBuilder {
67 constructor(reflector, outputCtx, parent, component, embeddedViewIndex, usedPipes, viewBuilderFactory) {
68 this.reflector = reflector;
69 this.outputCtx = outputCtx;
70 this.parent = parent;
71 this.component = component;
72 this.embeddedViewIndex = embeddedViewIndex;
73 this.usedPipes = usedPipes;
74 this.viewBuilderFactory = viewBuilderFactory;
75 this.nodes = [];
76 this.purePipeNodeIndices = Object.create(null);
77 // Need Object.create so that we don't have builtin values...
78 this.refNodeIndices = Object.create(null);
79 this.variables = [];
80 this.children = [];
81 // TODO(tbosch): The old view compiler used to use an `any` type
82 // for the context in any embedded view. We keep this behaivor for now
83 // to be able to introduce the new view compiler without too many errors.
84 this.compType = this.embeddedViewIndex > 0 ?
85 o.DYNAMIC_TYPE :
86 o.expressionType(outputCtx.importExpr(this.component.type.reference));
87 this.viewName = viewClassName(this.component.type.reference, this.embeddedViewIndex);
88 }
89 visitAll(variables, astNodes) {
90 this.variables = variables;
91 // create the pipes for the pure pipes immediately, so that we know their indices.
92 if (!this.parent) {
93 this.usedPipes.forEach((pipe) => {
94 if (pipe.pure) {
95 this.purePipeNodeIndices[pipe.name] = this._createPipe(null, pipe);
96 }
97 });
98 }
99 if (!this.parent) {
100 this.component.viewQueries.forEach((query, queryIndex) => {
101 // Note: queries start with id 1 so we can use the number in a Bloom filter!
102 const queryId = queryIndex + 1;
103 const bindingType = query.first ? 0 /* First */ : 1 /* All */;
104 const flags = 134217728 /* TypeViewQuery */ | calcQueryFlags(query);
105 this.nodes.push(() => ({
106 sourceSpan: null,
107 nodeFlags: flags,
108 nodeDef: o.importExpr(Identifiers.queryDef).callFn([
109 o.literal(flags), o.literal(queryId),
110 new o.LiteralMapExpr([new o.LiteralMapEntry(query.propertyName, o.literal(bindingType), false)])
111 ])
112 }));
113 });
114 }
115 templateVisitAll(this, astNodes);
116 if (this.parent && (astNodes.length === 0 || needsAdditionalRootNode(astNodes))) {
117 // if the view is an embedded view, then we need to add an additional root node in some cases
118 this.nodes.push(() => ({
119 sourceSpan: null,
120 nodeFlags: 1 /* TypeElement */,
121 nodeDef: o.importExpr(Identifiers.anchorDef).callFn([
122 o.literal(0 /* None */), o.NULL_EXPR, o.NULL_EXPR, o.literal(0)
123 ])
124 }));
125 }
126 }
127 build(targetStatements = []) {
128 this.children.forEach((child) => child.build(targetStatements));
129 const { updateRendererStmts, updateDirectivesStmts, nodeDefExprs } = this._createNodeExpressions();
130 const updateRendererFn = this._createUpdateFn(updateRendererStmts);
131 const updateDirectivesFn = this._createUpdateFn(updateDirectivesStmts);
132 let viewFlags = 0 /* None */;
133 if (!this.parent && this.component.changeDetection === ChangeDetectionStrategy.OnPush) {
134 viewFlags |= 2 /* OnPush */;
135 }
136 const viewFactory = new o.DeclareFunctionStmt(this.viewName, [new o.FnParam(LOG_VAR.name)], [new o.ReturnStatement(o.importExpr(Identifiers.viewDef).callFn([
137 o.literal(viewFlags),
138 o.literalArr(nodeDefExprs),
139 updateDirectivesFn,
140 updateRendererFn,
141 ]))], o.importType(Identifiers.ViewDefinition), this.embeddedViewIndex === 0 ? [o.StmtModifier.Exported] : []);
142 targetStatements.push(viewFactory);
143 return targetStatements;
144 }
145 _createUpdateFn(updateStmts) {
146 let updateFn;
147 if (updateStmts.length > 0) {
148 const preStmts = [];
149 if (!this.component.isHost && o.findReadVarNames(updateStmts).has(COMP_VAR.name)) {
150 preStmts.push(COMP_VAR.set(VIEW_VAR.prop('component')).toDeclStmt(this.compType));
151 }
152 updateFn = o.fn([
153 new o.FnParam(CHECK_VAR.name, o.INFERRED_TYPE),
154 new o.FnParam(VIEW_VAR.name, o.INFERRED_TYPE)
155 ], [...preStmts, ...updateStmts], o.INFERRED_TYPE);
156 }
157 else {
158 updateFn = o.NULL_EXPR;
159 }
160 return updateFn;
161 }
162 visitNgContent(ast, context) {
163 // ngContentDef(ngContentIndex: number, index: number): NodeDef;
164 this.nodes.push(() => ({
165 sourceSpan: ast.sourceSpan,
166 nodeFlags: 8 /* TypeNgContent */,
167 nodeDef: o.importExpr(Identifiers.ngContentDef)
168 .callFn([o.literal(ast.ngContentIndex), o.literal(ast.index)])
169 }));
170 }
171 visitText(ast, context) {
172 // Static text nodes have no check function
173 const checkIndex = -1;
174 this.nodes.push(() => ({
175 sourceSpan: ast.sourceSpan,
176 nodeFlags: 2 /* TypeText */,
177 nodeDef: o.importExpr(Identifiers.textDef).callFn([
178 o.literal(checkIndex),
179 o.literal(ast.ngContentIndex),
180 o.literalArr([o.literal(ast.value)]),
181 ])
182 }));
183 }
184 visitBoundText(ast, context) {
185 const nodeIndex = this.nodes.length;
186 // reserve the space in the nodeDefs array
187 this.nodes.push(null);
188 const astWithSource = ast.value;
189 const inter = astWithSource.ast;
190 const updateRendererExpressions = inter.expressions.map((expr, bindingIndex) => this._preprocessUpdateExpression({ nodeIndex, bindingIndex, sourceSpan: ast.sourceSpan, context: COMP_VAR, value: expr }));
191 // Check index is the same as the node index during compilation
192 // They might only differ at runtime
193 const checkIndex = nodeIndex;
194 this.nodes[nodeIndex] = () => ({
195 sourceSpan: ast.sourceSpan,
196 nodeFlags: 2 /* TypeText */,
197 nodeDef: o.importExpr(Identifiers.textDef).callFn([
198 o.literal(checkIndex),
199 o.literal(ast.ngContentIndex),
200 o.literalArr(inter.strings.map(s => o.literal(s))),
201 ]),
202 updateRenderer: updateRendererExpressions
203 });
204 }
205 visitEmbeddedTemplate(ast, context) {
206 const nodeIndex = this.nodes.length;
207 // reserve the space in the nodeDefs array
208 this.nodes.push(null);
209 const { flags, queryMatchesExpr, hostEvents } = this._visitElementOrTemplate(nodeIndex, ast);
210 const childVisitor = this.viewBuilderFactory(this);
211 this.children.push(childVisitor);
212 childVisitor.visitAll(ast.variables, ast.children);
213 const childCount = this.nodes.length - nodeIndex - 1;
214 // anchorDef(
215 // flags: NodeFlags, matchedQueries: [string, QueryValueType][], ngContentIndex: number,
216 // childCount: number, handleEventFn?: ElementHandleEventFn, templateFactory?:
217 // ViewDefinitionFactory): NodeDef;
218 this.nodes[nodeIndex] = () => ({
219 sourceSpan: ast.sourceSpan,
220 nodeFlags: 1 /* TypeElement */ | flags,
221 nodeDef: o.importExpr(Identifiers.anchorDef).callFn([
222 o.literal(flags),
223 queryMatchesExpr,
224 o.literal(ast.ngContentIndex),
225 o.literal(childCount),
226 this._createElementHandleEventFn(nodeIndex, hostEvents),
227 o.variable(childVisitor.viewName),
228 ])
229 });
230 }
231 visitElement(ast, context) {
232 const nodeIndex = this.nodes.length;
233 // reserve the space in the nodeDefs array so we can add children
234 this.nodes.push(null);
235 // Using a null element name creates an anchor.
236 const elName = isNgContainer(ast.name) ? null : ast.name;
237 const { flags, usedEvents, queryMatchesExpr, hostBindings: dirHostBindings, hostEvents } = this._visitElementOrTemplate(nodeIndex, ast);
238 let inputDefs = [];
239 let updateRendererExpressions = [];
240 let outputDefs = [];
241 if (elName) {
242 const hostBindings = ast.inputs
243 .map((inputAst) => ({
244 context: COMP_VAR,
245 inputAst,
246 dirAst: null,
247 }))
248 .concat(dirHostBindings);
249 if (hostBindings.length) {
250 updateRendererExpressions =
251 hostBindings.map((hostBinding, bindingIndex) => this._preprocessUpdateExpression({
252 context: hostBinding.context,
253 nodeIndex,
254 bindingIndex,
255 sourceSpan: hostBinding.inputAst.sourceSpan,
256 value: hostBinding.inputAst.value
257 }));
258 inputDefs = hostBindings.map(hostBinding => elementBindingDef(hostBinding.inputAst, hostBinding.dirAst));
259 }
260 outputDefs = usedEvents.map(([target, eventName]) => o.literalArr([o.literal(target), o.literal(eventName)]));
261 }
262 templateVisitAll(this, ast.children);
263 const childCount = this.nodes.length - nodeIndex - 1;
264 const compAst = ast.directives.find(dirAst => dirAst.directive.isComponent);
265 let compRendererType = o.NULL_EXPR;
266 let compView = o.NULL_EXPR;
267 if (compAst) {
268 compView = this.outputCtx.importExpr(compAst.directive.componentViewType);
269 compRendererType = this.outputCtx.importExpr(compAst.directive.rendererType);
270 }
271 // Check index is the same as the node index during compilation
272 // They might only differ at runtime
273 const checkIndex = nodeIndex;
274 this.nodes[nodeIndex] = () => ({
275 sourceSpan: ast.sourceSpan,
276 nodeFlags: 1 /* TypeElement */ | flags,
277 nodeDef: o.importExpr(Identifiers.elementDef).callFn([
278 o.literal(checkIndex),
279 o.literal(flags),
280 queryMatchesExpr,
281 o.literal(ast.ngContentIndex),
282 o.literal(childCount),
283 o.literal(elName),
284 elName ? fixedAttrsDef(ast) : o.NULL_EXPR,
285 inputDefs.length ? o.literalArr(inputDefs) : o.NULL_EXPR,
286 outputDefs.length ? o.literalArr(outputDefs) : o.NULL_EXPR,
287 this._createElementHandleEventFn(nodeIndex, hostEvents),
288 compView,
289 compRendererType,
290 ]),
291 updateRenderer: updateRendererExpressions
292 });
293 }
294 _visitElementOrTemplate(nodeIndex, ast) {
295 let flags = 0 /* None */;
296 if (ast.hasViewContainer) {
297 flags |= 16777216 /* EmbeddedViews */;
298 }
299 const usedEvents = new Map();
300 ast.outputs.forEach((event) => {
301 const { name, target } = elementEventNameAndTarget(event, null);
302 usedEvents.set(elementEventFullName(target, name), [target, name]);
303 });
304 ast.directives.forEach((dirAst) => {
305 dirAst.hostEvents.forEach((event) => {
306 const { name, target } = elementEventNameAndTarget(event, dirAst);
307 usedEvents.set(elementEventFullName(target, name), [target, name]);
308 });
309 });
310 const hostBindings = [];
311 const hostEvents = [];
312 this._visitComponentFactoryResolverProvider(ast.directives);
313 ast.providers.forEach(providerAst => {
314 let dirAst = undefined;
315 ast.directives.forEach(localDirAst => {
316 if (localDirAst.directive.type.reference === tokenReference(providerAst.token)) {
317 dirAst = localDirAst;
318 }
319 });
320 if (dirAst) {
321 const { hostBindings: dirHostBindings, hostEvents: dirHostEvents } = this._visitDirective(providerAst, dirAst, ast.references, ast.queryMatches, usedEvents);
322 hostBindings.push(...dirHostBindings);
323 hostEvents.push(...dirHostEvents);
324 }
325 else {
326 this._visitProvider(providerAst, ast.queryMatches);
327 }
328 });
329 let queryMatchExprs = [];
330 ast.queryMatches.forEach((match) => {
331 let valueType = undefined;
332 if (tokenReference(match.value) ===
333 this.reflector.resolveExternalReference(Identifiers.ElementRef)) {
334 valueType = 0 /* ElementRef */;
335 }
336 else if (tokenReference(match.value) ===
337 this.reflector.resolveExternalReference(Identifiers.ViewContainerRef)) {
338 valueType = 3 /* ViewContainerRef */;
339 }
340 else if (tokenReference(match.value) ===
341 this.reflector.resolveExternalReference(Identifiers.TemplateRef)) {
342 valueType = 2 /* TemplateRef */;
343 }
344 if (valueType != null) {
345 queryMatchExprs.push(o.literalArr([o.literal(match.queryId), o.literal(valueType)]));
346 }
347 });
348 ast.references.forEach((ref) => {
349 let valueType = undefined;
350 if (!ref.value) {
351 valueType = 1 /* RenderElement */;
352 }
353 else if (tokenReference(ref.value) ===
354 this.reflector.resolveExternalReference(Identifiers.TemplateRef)) {
355 valueType = 2 /* TemplateRef */;
356 }
357 if (valueType != null) {
358 this.refNodeIndices[ref.name] = nodeIndex;
359 queryMatchExprs.push(o.literalArr([o.literal(ref.name), o.literal(valueType)]));
360 }
361 });
362 ast.outputs.forEach((outputAst) => {
363 hostEvents.push({ context: COMP_VAR, eventAst: outputAst, dirAst: null });
364 });
365 return {
366 flags,
367 usedEvents: Array.from(usedEvents.values()),
368 queryMatchesExpr: queryMatchExprs.length ? o.literalArr(queryMatchExprs) : o.NULL_EXPR,
369 hostBindings,
370 hostEvents: hostEvents
371 };
372 }
373 _visitDirective(providerAst, dirAst, refs, queryMatches, usedEvents) {
374 const nodeIndex = this.nodes.length;
375 // reserve the space in the nodeDefs array so we can add children
376 this.nodes.push(null);
377 dirAst.directive.queries.forEach((query, queryIndex) => {
378 const queryId = dirAst.contentQueryStartId + queryIndex;
379 const flags = 67108864 /* TypeContentQuery */ | calcQueryFlags(query);
380 const bindingType = query.first ? 0 /* First */ : 1 /* All */;
381 this.nodes.push(() => ({
382 sourceSpan: dirAst.sourceSpan,
383 nodeFlags: flags,
384 nodeDef: o.importExpr(Identifiers.queryDef).callFn([
385 o.literal(flags), o.literal(queryId),
386 new o.LiteralMapExpr([new o.LiteralMapEntry(query.propertyName, o.literal(bindingType), false)])
387 ]),
388 }));
389 });
390 // Note: the operation below might also create new nodeDefs,
391 // but we don't want them to be a child of a directive,
392 // as they might be a provider/pipe on their own.
393 // I.e. we only allow queries as children of directives nodes.
394 const childCount = this.nodes.length - nodeIndex - 1;
395 let { flags, queryMatchExprs, providerExpr, depsExpr } = this._visitProviderOrDirective(providerAst, queryMatches);
396 refs.forEach((ref) => {
397 if (ref.value && tokenReference(ref.value) === tokenReference(providerAst.token)) {
398 this.refNodeIndices[ref.name] = nodeIndex;
399 queryMatchExprs.push(o.literalArr([o.literal(ref.name), o.literal(4 /* Provider */)]));
400 }
401 });
402 if (dirAst.directive.isComponent) {
403 flags |= 32768 /* Component */;
404 }
405 const inputDefs = dirAst.inputs.map((inputAst, inputIndex) => {
406 const mapValue = o.literalArr([o.literal(inputIndex), o.literal(inputAst.directiveName)]);
407 // Note: it's important to not quote the key so that we can capture renames by minifiers!
408 return new o.LiteralMapEntry(inputAst.directiveName, mapValue, false);
409 });
410 const outputDefs = [];
411 const dirMeta = dirAst.directive;
412 Object.keys(dirMeta.outputs).forEach((propName) => {
413 const eventName = dirMeta.outputs[propName];
414 if (usedEvents.has(eventName)) {
415 // Note: it's important to not quote the key so that we can capture renames by minifiers!
416 outputDefs.push(new o.LiteralMapEntry(propName, o.literal(eventName), false));
417 }
418 });
419 let updateDirectiveExpressions = [];
420 if (dirAst.inputs.length || (flags & (262144 /* DoCheck */ | 65536 /* OnInit */)) > 0) {
421 updateDirectiveExpressions =
422 dirAst.inputs.map((input, bindingIndex) => this._preprocessUpdateExpression({
423 nodeIndex,
424 bindingIndex,
425 sourceSpan: input.sourceSpan,
426 context: COMP_VAR,
427 value: input.value
428 }));
429 }
430 const dirContextExpr = o.importExpr(Identifiers.nodeValue).callFn([VIEW_VAR, o.literal(nodeIndex)]);
431 const hostBindings = dirAst.hostProperties.map((inputAst) => ({
432 context: dirContextExpr,
433 dirAst,
434 inputAst,
435 }));
436 const hostEvents = dirAst.hostEvents.map((hostEventAst) => ({
437 context: dirContextExpr,
438 eventAst: hostEventAst,
439 dirAst,
440 }));
441 // Check index is the same as the node index during compilation
442 // They might only differ at runtime
443 const checkIndex = nodeIndex;
444 this.nodes[nodeIndex] = () => ({
445 sourceSpan: dirAst.sourceSpan,
446 nodeFlags: 16384 /* TypeDirective */ | flags,
447 nodeDef: o.importExpr(Identifiers.directiveDef).callFn([
448 o.literal(checkIndex),
449 o.literal(flags),
450 queryMatchExprs.length ? o.literalArr(queryMatchExprs) : o.NULL_EXPR,
451 o.literal(childCount),
452 providerExpr,
453 depsExpr,
454 inputDefs.length ? new o.LiteralMapExpr(inputDefs) : o.NULL_EXPR,
455 outputDefs.length ? new o.LiteralMapExpr(outputDefs) : o.NULL_EXPR,
456 ]),
457 updateDirectives: updateDirectiveExpressions,
458 directive: dirAst.directive.type,
459 });
460 return { hostBindings, hostEvents };
461 }
462 _visitProvider(providerAst, queryMatches) {
463 this._addProviderNode(this._visitProviderOrDirective(providerAst, queryMatches));
464 }
465 _visitComponentFactoryResolverProvider(directives) {
466 const componentDirMeta = directives.find(dirAst => dirAst.directive.isComponent);
467 if (componentDirMeta && componentDirMeta.directive.entryComponents.length) {
468 const { providerExpr, depsExpr, flags, tokenExpr } = componentFactoryResolverProviderDef(this.reflector, this.outputCtx, 8192 /* PrivateProvider */, componentDirMeta.directive.entryComponents);
469 this._addProviderNode({
470 providerExpr,
471 depsExpr,
472 flags,
473 tokenExpr,
474 queryMatchExprs: [],
475 sourceSpan: componentDirMeta.sourceSpan
476 });
477 }
478 }
479 _addProviderNode(data) {
480 // providerDef(
481 // flags: NodeFlags, matchedQueries: [string, QueryValueType][], token:any,
482 // value: any, deps: ([DepFlags, any] | any)[]): NodeDef;
483 this.nodes.push(() => ({
484 sourceSpan: data.sourceSpan,
485 nodeFlags: data.flags,
486 nodeDef: o.importExpr(Identifiers.providerDef).callFn([
487 o.literal(data.flags),
488 data.queryMatchExprs.length ? o.literalArr(data.queryMatchExprs) : o.NULL_EXPR,
489 data.tokenExpr, data.providerExpr, data.depsExpr
490 ])
491 }));
492 }
493 _visitProviderOrDirective(providerAst, queryMatches) {
494 let flags = 0 /* None */;
495 let queryMatchExprs = [];
496 queryMatches.forEach((match) => {
497 if (tokenReference(match.value) === tokenReference(providerAst.token)) {
498 queryMatchExprs.push(o.literalArr([o.literal(match.queryId), o.literal(4 /* Provider */)]));
499 }
500 });
501 const { providerExpr, depsExpr, flags: providerFlags, tokenExpr } = providerDef(this.outputCtx, providerAst);
502 return {
503 flags: flags | providerFlags,
504 queryMatchExprs,
505 providerExpr,
506 depsExpr,
507 tokenExpr,
508 sourceSpan: providerAst.sourceSpan
509 };
510 }
511 getLocal(name) {
512 if (name == EventHandlerVars.event.name) {
513 return EventHandlerVars.event;
514 }
515 let currViewExpr = VIEW_VAR;
516 for (let currBuilder = this; currBuilder; currBuilder = currBuilder.parent,
517 currViewExpr = currViewExpr.prop('parent').cast(o.DYNAMIC_TYPE)) {
518 // check references
519 const refNodeIndex = currBuilder.refNodeIndices[name];
520 if (refNodeIndex != null) {
521 return o.importExpr(Identifiers.nodeValue).callFn([currViewExpr, o.literal(refNodeIndex)]);
522 }
523 // check variables
524 const varAst = currBuilder.variables.find((varAst) => varAst.name === name);
525 if (varAst) {
526 const varValue = varAst.value || IMPLICIT_TEMPLATE_VAR;
527 return currViewExpr.prop('context').prop(varValue);
528 }
529 }
530 return null;
531 }
532 notifyImplicitReceiverUse() {
533 // Not needed in ViewEngine as ViewEngine walks through the generated
534 // expressions to figure out if the implicit receiver is used and needs
535 // to be generated as part of the pre-update statements.
536 }
537 maybeRestoreView() {
538 // Not necessary in ViewEngine, because view restoration is an Ivy concept.
539 }
540 _createLiteralArrayConverter(sourceSpan, argCount) {
541 if (argCount === 0) {
542 const valueExpr = o.importExpr(Identifiers.EMPTY_ARRAY);
543 return () => valueExpr;
544 }
545 const checkIndex = this.nodes.length;
546 this.nodes.push(() => ({
547 sourceSpan,
548 nodeFlags: 32 /* TypePureArray */,
549 nodeDef: o.importExpr(Identifiers.pureArrayDef).callFn([
550 o.literal(checkIndex),
551 o.literal(argCount),
552 ])
553 }));
554 return (args) => callCheckStmt(checkIndex, args);
555 }
556 _createLiteralMapConverter(sourceSpan, keys) {
557 if (keys.length === 0) {
558 const valueExpr = o.importExpr(Identifiers.EMPTY_MAP);
559 return () => valueExpr;
560 }
561 const map = o.literalMap(keys.map((e, i) => (Object.assign(Object.assign({}, e), { value: o.literal(i) }))));
562 const checkIndex = this.nodes.length;
563 this.nodes.push(() => ({
564 sourceSpan,
565 nodeFlags: 64 /* TypePureObject */,
566 nodeDef: o.importExpr(Identifiers.pureObjectDef).callFn([
567 o.literal(checkIndex),
568 map,
569 ])
570 }));
571 return (args) => callCheckStmt(checkIndex, args);
572 }
573 _createPipeConverter(expression, name, argCount) {
574 const pipe = this.usedPipes.find((pipeSummary) => pipeSummary.name === name);
575 if (pipe.pure) {
576 const checkIndex = this.nodes.length;
577 this.nodes.push(() => ({
578 sourceSpan: expression.sourceSpan,
579 nodeFlags: 128 /* TypePurePipe */,
580 nodeDef: o.importExpr(Identifiers.purePipeDef).callFn([
581 o.literal(checkIndex),
582 o.literal(argCount),
583 ])
584 }));
585 // find underlying pipe in the component view
586 let compViewExpr = VIEW_VAR;
587 let compBuilder = this;
588 while (compBuilder.parent) {
589 compBuilder = compBuilder.parent;
590 compViewExpr = compViewExpr.prop('parent').cast(o.DYNAMIC_TYPE);
591 }
592 const pipeNodeIndex = compBuilder.purePipeNodeIndices[name];
593 const pipeValueExpr = o.importExpr(Identifiers.nodeValue).callFn([compViewExpr, o.literal(pipeNodeIndex)]);
594 return (args) => callUnwrapValue(expression.nodeIndex, expression.bindingIndex, callCheckStmt(checkIndex, [pipeValueExpr].concat(args)));
595 }
596 else {
597 const nodeIndex = this._createPipe(expression.sourceSpan, pipe);
598 const nodeValueExpr = o.importExpr(Identifiers.nodeValue).callFn([VIEW_VAR, o.literal(nodeIndex)]);
599 return (args) => callUnwrapValue(expression.nodeIndex, expression.bindingIndex, nodeValueExpr.callMethod('transform', args));
600 }
601 }
602 _createPipe(sourceSpan, pipe) {
603 const nodeIndex = this.nodes.length;
604 let flags = 0 /* None */;
605 pipe.type.lifecycleHooks.forEach((lifecycleHook) => {
606 // for pipes, we only support ngOnDestroy
607 if (lifecycleHook === LifecycleHooks.OnDestroy) {
608 flags |= lifecycleHookToNodeFlag(lifecycleHook);
609 }
610 });
611 const depExprs = pipe.type.diDeps.map((diDep) => depDef(this.outputCtx, diDep));
612 // function pipeDef(
613 // flags: NodeFlags, ctor: any, deps: ([DepFlags, any] | any)[]): NodeDef
614 this.nodes.push(() => ({
615 sourceSpan,
616 nodeFlags: 16 /* TypePipe */,
617 nodeDef: o.importExpr(Identifiers.pipeDef).callFn([
618 o.literal(flags), this.outputCtx.importExpr(pipe.type.reference), o.literalArr(depExprs)
619 ])
620 }));
621 return nodeIndex;
622 }
623 /**
624 * For the AST in `UpdateExpression.value`:
625 * - create nodes for pipes, literal arrays and, literal maps,
626 * - update the AST to replace pipes, literal arrays and, literal maps with calls to check fn.
627 *
628 * WARNING: This might create new nodeDefs (for pipes and literal arrays and literal maps)!
629 */
630 _preprocessUpdateExpression(expression) {
631 return {
632 nodeIndex: expression.nodeIndex,
633 bindingIndex: expression.bindingIndex,
634 sourceSpan: expression.sourceSpan,
635 context: expression.context,
636 value: convertPropertyBindingBuiltins({
637 createLiteralArrayConverter: (argCount) => this._createLiteralArrayConverter(expression.sourceSpan, argCount),
638 createLiteralMapConverter: (keys) => this._createLiteralMapConverter(expression.sourceSpan, keys),
639 createPipeConverter: (name, argCount) => this._createPipeConverter(expression, name, argCount)
640 }, expression.value)
641 };
642 }
643 _createNodeExpressions() {
644 const self = this;
645 let updateBindingCount = 0;
646 const updateRendererStmts = [];
647 const updateDirectivesStmts = [];
648 const nodeDefExprs = this.nodes.map((factory, nodeIndex) => {
649 const { nodeDef, nodeFlags, updateDirectives, updateRenderer, sourceSpan } = factory();
650 if (updateRenderer) {
651 updateRendererStmts.push(...createUpdateStatements(nodeIndex, sourceSpan, updateRenderer, false));
652 }
653 if (updateDirectives) {
654 updateDirectivesStmts.push(...createUpdateStatements(nodeIndex, sourceSpan, updateDirectives, (nodeFlags & (262144 /* DoCheck */ | 65536 /* OnInit */)) > 0));
655 }
656 // We use a comma expression to call the log function before
657 // the nodeDef function, but still use the result of the nodeDef function
658 // as the value.
659 // Note: We only add the logger to elements / text nodes,
660 // so we don't generate too much code.
661 const logWithNodeDef = nodeFlags & 3 /* CatRenderNode */ ?
662 new o.CommaExpr([LOG_VAR.callFn([]).callFn([]), nodeDef]) :
663 nodeDef;
664 return o.applySourceSpanToExpressionIfNeeded(logWithNodeDef, sourceSpan);
665 });
666 return { updateRendererStmts, updateDirectivesStmts, nodeDefExprs };
667 function createUpdateStatements(nodeIndex, sourceSpan, expressions, allowEmptyExprs) {
668 const updateStmts = [];
669 const exprs = expressions.map(({ sourceSpan, context, value }) => {
670 const bindingId = `${updateBindingCount++}`;
671 const nameResolver = context === COMP_VAR ? self : null;
672 const { stmts, currValExpr } = convertPropertyBinding(nameResolver, context, value, bindingId, BindingForm.General);
673 updateStmts.push(...stmts.map((stmt) => o.applySourceSpanToStatementIfNeeded(stmt, sourceSpan)));
674 return o.applySourceSpanToExpressionIfNeeded(currValExpr, sourceSpan);
675 });
676 if (expressions.length || allowEmptyExprs) {
677 updateStmts.push(o.applySourceSpanToStatementIfNeeded(callCheckStmt(nodeIndex, exprs).toStmt(), sourceSpan));
678 }
679 return updateStmts;
680 }
681 }
682 _createElementHandleEventFn(nodeIndex, handlers) {
683 const handleEventStmts = [];
684 let handleEventBindingCount = 0;
685 handlers.forEach(({ context, eventAst, dirAst }) => {
686 const bindingId = `${handleEventBindingCount++}`;
687 const nameResolver = context === COMP_VAR ? this : null;
688 const { stmts, allowDefault } = convertActionBinding(nameResolver, context, eventAst.handler, bindingId);
689 const trueStmts = stmts;
690 if (allowDefault) {
691 trueStmts.push(ALLOW_DEFAULT_VAR.set(allowDefault.and(ALLOW_DEFAULT_VAR)).toStmt());
692 }
693 const { target: eventTarget, name: eventName } = elementEventNameAndTarget(eventAst, dirAst);
694 const fullEventName = elementEventFullName(eventTarget, eventName);
695 handleEventStmts.push(o.applySourceSpanToStatementIfNeeded(new o.IfStmt(o.literal(fullEventName).identical(EVENT_NAME_VAR), trueStmts), eventAst.sourceSpan));
696 });
697 let handleEventFn;
698 if (handleEventStmts.length > 0) {
699 const preStmts = [ALLOW_DEFAULT_VAR.set(o.literal(true)).toDeclStmt(o.BOOL_TYPE)];
700 if (!this.component.isHost && o.findReadVarNames(handleEventStmts).has(COMP_VAR.name)) {
701 preStmts.push(COMP_VAR.set(VIEW_VAR.prop('component')).toDeclStmt(this.compType));
702 }
703 handleEventFn = o.fn([
704 new o.FnParam(VIEW_VAR.name, o.INFERRED_TYPE),
705 new o.FnParam(EVENT_NAME_VAR.name, o.INFERRED_TYPE),
706 new o.FnParam(EventHandlerVars.event.name, o.INFERRED_TYPE)
707 ], [...preStmts, ...handleEventStmts, new o.ReturnStatement(ALLOW_DEFAULT_VAR)], o.INFERRED_TYPE);
708 }
709 else {
710 handleEventFn = o.NULL_EXPR;
711 }
712 return handleEventFn;
713 }
714 visitDirective(ast, context) { }
715 visitDirectiveProperty(ast, context) { }
716 visitReference(ast, context) { }
717 visitVariable(ast, context) { }
718 visitEvent(ast, context) { }
719 visitElementProperty(ast, context) { }
720 visitAttr(ast, context) { }
721}
722function needsAdditionalRootNode(astNodes) {
723 const lastAstNode = astNodes[astNodes.length - 1];
724 if (lastAstNode instanceof EmbeddedTemplateAst) {
725 return lastAstNode.hasViewContainer;
726 }
727 if (lastAstNode instanceof ElementAst) {
728 if (isNgContainer(lastAstNode.name) && lastAstNode.children.length) {
729 return needsAdditionalRootNode(lastAstNode.children);
730 }
731 return lastAstNode.hasViewContainer;
732 }
733 return lastAstNode instanceof NgContentAst;
734}
735function elementBindingDef(inputAst, dirAst) {
736 const inputType = inputAst.type;
737 switch (inputType) {
738 case 1 /* Attribute */:
739 return o.literalArr([
740 o.literal(1 /* TypeElementAttribute */), o.literal(inputAst.name),
741 o.literal(inputAst.securityContext)
742 ]);
743 case 0 /* Property */:
744 return o.literalArr([
745 o.literal(8 /* TypeProperty */), o.literal(inputAst.name),
746 o.literal(inputAst.securityContext)
747 ]);
748 case 4 /* Animation */:
749 const bindingType = 8 /* TypeProperty */ |
750 (dirAst && dirAst.directive.isComponent ? 32 /* SyntheticHostProperty */ :
751 16 /* SyntheticProperty */);
752 return o.literalArr([
753 o.literal(bindingType), o.literal('@' + inputAst.name), o.literal(inputAst.securityContext)
754 ]);
755 case 2 /* Class */:
756 return o.literalArr([o.literal(2 /* TypeElementClass */), o.literal(inputAst.name), o.NULL_EXPR]);
757 case 3 /* Style */:
758 return o.literalArr([
759 o.literal(4 /* TypeElementStyle */), o.literal(inputAst.name), o.literal(inputAst.unit)
760 ]);
761 default:
762 // This default case is not needed by TypeScript compiler, as the switch is exhaustive.
763 // However Closure Compiler does not understand that and reports an error in typed mode.
764 // The `throw new Error` below works around the problem, and the unexpected: never variable
765 // makes sure tsc still checks this code is unreachable.
766 const unexpected = inputType;
767 throw new Error(`unexpected ${unexpected}`);
768 }
769}
770function fixedAttrsDef(elementAst) {
771 const mapResult = Object.create(null);
772 elementAst.attrs.forEach(attrAst => {
773 mapResult[attrAst.name] = attrAst.value;
774 });
775 elementAst.directives.forEach(dirAst => {
776 Object.keys(dirAst.directive.hostAttributes).forEach(name => {
777 const value = dirAst.directive.hostAttributes[name];
778 const prevValue = mapResult[name];
779 mapResult[name] = prevValue != null ? mergeAttributeValue(name, prevValue, value) : value;
780 });
781 });
782 // Note: We need to sort to get a defined output order
783 // for tests and for caching generated artifacts...
784 return o.literalArr(Object.keys(mapResult).sort().map((attrName) => o.literalArr([o.literal(attrName), o.literal(mapResult[attrName])])));
785}
786function mergeAttributeValue(attrName, attrValue1, attrValue2) {
787 if (attrName == CLASS_ATTR || attrName == STYLE_ATTR) {
788 return `${attrValue1} ${attrValue2}`;
789 }
790 else {
791 return attrValue2;
792 }
793}
794function callCheckStmt(nodeIndex, exprs) {
795 if (exprs.length > 10) {
796 return CHECK_VAR.callFn([VIEW_VAR, o.literal(nodeIndex), o.literal(1 /* Dynamic */), o.literalArr(exprs)]);
797 }
798 else {
799 return CHECK_VAR.callFn([VIEW_VAR, o.literal(nodeIndex), o.literal(0 /* Inline */), ...exprs]);
800 }
801}
802function callUnwrapValue(nodeIndex, bindingIdx, expr) {
803 return o.importExpr(Identifiers.unwrapValue).callFn([
804 VIEW_VAR, o.literal(nodeIndex), o.literal(bindingIdx), expr
805 ]);
806}
807function elementEventNameAndTarget(eventAst, dirAst) {
808 if (eventAst.isAnimation) {
809 return {
810 name: `@${eventAst.name}.${eventAst.phase}`,
811 target: dirAst && dirAst.directive.isComponent ? 'component' : null
812 };
813 }
814 else {
815 return eventAst;
816 }
817}
818function calcQueryFlags(query) {
819 let flags = 0 /* None */;
820 // Note: We only make queries static that query for a single item and the user specifically
821 // set the to be static. This is because of backwards compatibility with the old view compiler...
822 if (query.first && query.static) {
823 flags |= 268435456 /* StaticQuery */;
824 }
825 else {
826 flags |= 536870912 /* DynamicQuery */;
827 }
828 if (query.emitDistinctChangesOnly) {
829 flags |= -2147483648 /* EmitDistinctChangesOnly */;
830 }
831 return flags;
832}
833export function elementEventFullName(target, name) {
834 return target ? `${target}:${name}` : name;
835}
836//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view_compiler.js","sourceRoot":"","sources":["../../../../../../../packages/compiler/src/view_compiler/view_compiler.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 {CompileDirectiveMetadata, CompilePipeSummary, CompileQueryMetadata, rendererTypeName, tokenReference, viewClassName} from '../compile_metadata';\nimport {CompileReflector} from '../compile_reflector';\nimport {BindingForm, BuiltinConverter, convertActionBinding, convertPropertyBinding, convertPropertyBindingBuiltins, EventHandlerVars, LocalResolver} from '../compiler_util/expression_converter';\nimport {OutputContext} from '../constant_pool';\nimport {ArgumentType, BindingFlags, ChangeDetectionStrategy, NodeFlags, QueryBindingType, QueryValueType, ViewFlags} from '../core';\nimport {AST, ASTWithSource, Interpolation} from '../expression_parser/ast';\nimport {Identifiers} from '../identifiers';\nimport {LifecycleHooks} from '../lifecycle_reflector';\nimport {isNgContainer} from '../ml_parser/tags';\nimport * as o from '../output/output_ast';\nimport {convertValueToOutputAst} from '../output/value_util';\nimport {ParseSourceSpan} from '../parse_util';\nimport {AttrAst, BoundDirectivePropertyAst, BoundElementPropertyAst, BoundEventAst, BoundTextAst, DirectiveAst, ElementAst, EmbeddedTemplateAst, NgContentAst, PropertyBindingType, ProviderAst, QueryMatch, ReferenceAst, TemplateAst, TemplateAstVisitor, templateVisitAll, TextAst, VariableAst} from '../template_parser/template_ast';\n\nimport {componentFactoryResolverProviderDef, depDef, lifecycleHookToNodeFlag, providerDef} from './provider_compiler';\n\nconst CLASS_ATTR = 'class';\nconst STYLE_ATTR = 'style';\nconst IMPLICIT_TEMPLATE_VAR = '$implicit';\n\nexport class ViewCompileResult {\n  constructor(public viewClassVar: string, public rendererTypeVar: string) {}\n}\n\nexport class ViewCompiler {\n  constructor(private _reflector: CompileReflector) {}\n\n  compileComponent(\n      outputCtx: OutputContext, component: CompileDirectiveMetadata, template: TemplateAst[],\n      styles: o.Expression, usedPipes: CompilePipeSummary[]): ViewCompileResult {\n    let embeddedViewCount = 0;\n\n    let renderComponentVarName: string = undefined!;\n    if (!component.isHost) {\n      const template = component.template !;\n      const customRenderData: o.LiteralMapEntry[] = [];\n      if (template.animations && template.animations.length) {\n        customRenderData.push(new o.LiteralMapEntry(\n            'animation', convertValueToOutputAst(outputCtx, template.animations), true));\n      }\n\n      const renderComponentVar = o.variable(rendererTypeName(component.type.reference));\n      renderComponentVarName = renderComponentVar.name!;\n      outputCtx.statements.push(\n          renderComponentVar\n              .set(o.importExpr(Identifiers.createRendererType2).callFn([new o.LiteralMapExpr([\n                new o.LiteralMapEntry('encapsulation', o.literal(template.encapsulation), false),\n                new o.LiteralMapEntry('styles', styles, false),\n                new o.LiteralMapEntry('data', new o.LiteralMapExpr(customRenderData), false)\n              ])]))\n              .toDeclStmt(\n                  o.importType(Identifiers.RendererType2),\n                  [o.StmtModifier.Final, o.StmtModifier.Exported]));\n    }\n\n    const viewBuilderFactory = (parent: ViewBuilder|null): ViewBuilder => {\n      const embeddedViewIndex = embeddedViewCount++;\n      return new ViewBuilder(\n          this._reflector, outputCtx, parent, component, embeddedViewIndex, usedPipes,\n          viewBuilderFactory);\n    };\n\n    const visitor = viewBuilderFactory(null);\n    visitor.visitAll([], template);\n\n    outputCtx.statements.push(...visitor.build());\n\n    return new ViewCompileResult(visitor.viewName, renderComponentVarName);\n  }\n}\n\ninterface ViewBuilderFactory {\n  (parent: ViewBuilder): ViewBuilder;\n}\n\ninterface UpdateExpression {\n  context: o.Expression;\n  nodeIndex: number;\n  bindingIndex: number;\n  sourceSpan: ParseSourceSpan;\n  value: AST;\n}\n\nconst LOG_VAR = o.variable('_l');\nconst VIEW_VAR = o.variable('_v');\nconst CHECK_VAR = o.variable('_ck');\nconst COMP_VAR = o.variable('_co');\nconst EVENT_NAME_VAR = o.variable('en');\nconst ALLOW_DEFAULT_VAR = o.variable(`ad`);\n\nclass ViewBuilder implements TemplateAstVisitor, LocalResolver {\n  private compType: o.Type;\n  private nodes: (() => {\n    sourceSpan: ParseSourceSpan | null,\n    nodeDef: o.Expression,\n    nodeFlags: NodeFlags,\n    updateDirectives?: UpdateExpression[],\n    updateRenderer?: UpdateExpression[]\n  })[] = [];\n  private purePipeNodeIndices: {[pipeName: string]: number} = Object.create(null);\n  // Need Object.create so that we don't have builtin values...\n  private refNodeIndices: {[refName: string]: number} = Object.create(null);\n  private variables: VariableAst[] = [];\n  private children: ViewBuilder[] = [];\n\n  public readonly viewName: string;\n\n  constructor(\n      private reflector: CompileReflector, private outputCtx: OutputContext,\n      private parent: ViewBuilder|null, private component: CompileDirectiveMetadata,\n      private embeddedViewIndex: number, private usedPipes: CompilePipeSummary[],\n      private viewBuilderFactory: ViewBuilderFactory) {\n    // TODO(tbosch): The old view compiler used to use an `any` type\n    // for the context in any embedded view. We keep this behaivor for now\n    // to be able to introduce the new view compiler without too many errors.\n    this.compType = this.embeddedViewIndex > 0 ?\n        o.DYNAMIC_TYPE :\n        o.expressionType(outputCtx.importExpr(this.component.type.reference))!;\n    this.viewName = viewClassName(this.component.type.reference, this.embeddedViewIndex);\n  }\n\n  visitAll(variables: VariableAst[], astNodes: TemplateAst[]) {\n    this.variables = variables;\n    // create the pipes for the pure pipes immediately, so that we know their indices.\n    if (!this.parent) {\n      this.usedPipes.forEach((pipe) => {\n        if (pipe.pure) {\n          this.purePipeNodeIndices[pipe.name] = this._createPipe(null, pipe);\n        }\n      });\n    }\n\n    if (!this.parent) {\n      this.component.viewQueries.forEach((query, queryIndex) => {\n        // Note: queries start with id 1 so we can use the number in a Bloom filter!\n        const queryId = queryIndex + 1;\n        const bindingType = query.first ? QueryBindingType.First : QueryBindingType.All;\n        const flags = NodeFlags.TypeViewQuery | calcQueryFlags(query);\n        this.nodes.push(() => ({\n                          sourceSpan: null,\n                          nodeFlags: flags,\n                          nodeDef: o.importExpr(Identifiers.queryDef).callFn([\n                            o.literal(flags), o.literal(queryId),\n                            new o.LiteralMapExpr([new o.LiteralMapEntry(\n                                query.propertyName, o.literal(bindingType), false)])\n                          ])\n                        }));\n      });\n    }\n    templateVisitAll(this, astNodes);\n    if (this.parent && (astNodes.length === 0 || needsAdditionalRootNode(astNodes))) {\n      // if the view is an embedded view, then we need to add an additional root node in some cases\n      this.nodes.push(() => ({\n                        sourceSpan: null,\n                        nodeFlags: NodeFlags.TypeElement,\n                        nodeDef: o.importExpr(Identifiers.anchorDef).callFn([\n                          o.literal(NodeFlags.None), o.NULL_EXPR, o.NULL_EXPR, o.literal(0)\n                        ])\n                      }));\n    }\n  }\n\n  build(targetStatements: o.Statement[] = []): o.Statement[] {\n    this.children.forEach((child) => child.build(targetStatements));\n\n    const {updateRendererStmts, updateDirectivesStmts, nodeDefExprs} =\n        this._createNodeExpressions();\n\n    const updateRendererFn = this._createUpdateFn(updateRendererStmts);\n    const updateDirectivesFn = this._createUpdateFn(updateDirectivesStmts);\n\n\n    let viewFlags = ViewFlags.None;\n    if (!this.parent && this.component.changeDetection === ChangeDetectionStrategy.OnPush) {\n      viewFlags |= ViewFlags.OnPush;\n    }\n    const viewFactory = new o.DeclareFunctionStmt(\n        this.viewName, [new o.FnParam(LOG_VAR.name!)],\n        [new o.ReturnStatement(o.importExpr(Identifiers.viewDef).callFn([\n          o.literal(viewFlags),\n          o.literalArr(nodeDefExprs),\n          updateDirectivesFn,\n          updateRendererFn,\n        ]))],\n        o.importType(Identifiers.ViewDefinition),\n        this.embeddedViewIndex === 0 ? [o.StmtModifier.Exported] : []);\n\n    targetStatements.push(viewFactory);\n    return targetStatements;\n  }\n\n  private _createUpdateFn(updateStmts: o.Statement[]): o.Expression {\n    let updateFn: o.Expression;\n    if (updateStmts.length > 0) {\n      const preStmts: o.Statement[] = [];\n      if (!this.component.isHost && o.findReadVarNames(updateStmts).has(COMP_VAR.name!)) {\n        preStmts.push(COMP_VAR.set(VIEW_VAR.prop('component')).toDeclStmt(this.compType));\n      }\n      updateFn = o.fn(\n          [\n            new o.FnParam(CHECK_VAR.name!, o.INFERRED_TYPE),\n            new o.FnParam(VIEW_VAR.name!, o.INFERRED_TYPE)\n          ],\n          [...preStmts, ...updateStmts], o.INFERRED_TYPE);\n    } else {\n      updateFn = o.NULL_EXPR;\n    }\n    return updateFn;\n  }\n\n  visitNgContent(ast: NgContentAst, context: any): any {\n    // ngContentDef(ngContentIndex: number, index: number): NodeDef;\n    this.nodes.push(() => ({\n                      sourceSpan: ast.sourceSpan,\n                      nodeFlags: NodeFlags.TypeNgContent,\n                      nodeDef: o.importExpr(Identifiers.ngContentDef)\n                                   .callFn([o.literal(ast.ngContentIndex), o.literal(ast.index)])\n                    }));\n  }\n\n  visitText(ast: TextAst, context: any): any {\n    // Static text nodes have no check function\n    const checkIndex = -1;\n    this.nodes.push(() => ({\n                      sourceSpan: ast.sourceSpan,\n                      nodeFlags: NodeFlags.TypeText,\n                      nodeDef: o.importExpr(Identifiers.textDef).callFn([\n                        o.literal(checkIndex),\n                        o.literal(ast.ngContentIndex),\n                        o.literalArr([o.literal(ast.value)]),\n                      ])\n                    }));\n  }\n\n  visitBoundText(ast: BoundTextAst, context: any): any {\n    const nodeIndex = this.nodes.length;\n    // reserve the space in the nodeDefs array\n    this.nodes.push(null!);\n\n    const astWithSource = <ASTWithSource>ast.value;\n    const inter = <Interpolation>astWithSource.ast;\n\n    const updateRendererExpressions = inter.expressions.map(\n        (expr, bindingIndex) => this._preprocessUpdateExpression(\n            {nodeIndex, bindingIndex, sourceSpan: ast.sourceSpan, context: COMP_VAR, value: expr}));\n\n    // Check index is the same as the node index during compilation\n    // They might only differ at runtime\n    const checkIndex = nodeIndex;\n\n    this.nodes[nodeIndex] = () => ({\n      sourceSpan: ast.sourceSpan,\n      nodeFlags: NodeFlags.TypeText,\n      nodeDef: o.importExpr(Identifiers.textDef).callFn([\n        o.literal(checkIndex),\n        o.literal(ast.ngContentIndex),\n        o.literalArr(inter.strings.map(s => o.literal(s))),\n      ]),\n      updateRenderer: updateRendererExpressions\n    });\n  }\n\n  visitEmbeddedTemplate(ast: EmbeddedTemplateAst, context: any): any {\n    const nodeIndex = this.nodes.length;\n    // reserve the space in the nodeDefs array\n    this.nodes.push(null!);\n\n    const {flags, queryMatchesExpr, hostEvents} = this._visitElementOrTemplate(nodeIndex, ast);\n\n    const childVisitor = this.viewBuilderFactory(this);\n    this.children.push(childVisitor);\n    childVisitor.visitAll(ast.variables, ast.children);\n\n    const childCount = this.nodes.length - nodeIndex - 1;\n\n    // anchorDef(\n    //   flags: NodeFlags, matchedQueries: [string, QueryValueType][], ngContentIndex: number,\n    //   childCount: number, handleEventFn?: ElementHandleEventFn, templateFactory?:\n    //   ViewDefinitionFactory): NodeDef;\n    this.nodes[nodeIndex] = () => ({\n      sourceSpan: ast.sourceSpan,\n      nodeFlags: NodeFlags.TypeElement | flags,\n      nodeDef: o.importExpr(Identifiers.anchorDef).callFn([\n        o.literal(flags),\n        queryMatchesExpr,\n        o.literal(ast.ngContentIndex),\n        o.literal(childCount),\n        this._createElementHandleEventFn(nodeIndex, hostEvents),\n        o.variable(childVisitor.viewName),\n      ])\n    });\n  }\n\n  visitElement(ast: ElementAst, context: any): any {\n    const nodeIndex = this.nodes.length;\n    // reserve the space in the nodeDefs array so we can add children\n    this.nodes.push(null!);\n\n    // Using a null element name creates an anchor.\n    const elName: string|null = isNgContainer(ast.name) ? null : ast.name;\n\n    const {flags, usedEvents, queryMatchesExpr, hostBindings: dirHostBindings, hostEvents} =\n        this._visitElementOrTemplate(nodeIndex, ast);\n\n    let inputDefs: o.Expression[] = [];\n    let updateRendererExpressions: UpdateExpression[] = [];\n    let outputDefs: o.Expression[] = [];\n    if (elName) {\n      const hostBindings: any[] = ast.inputs\n                                      .map((inputAst) => ({\n                                             context: COMP_VAR as o.Expression,\n                                             inputAst,\n                                             dirAst: null as any,\n                                           }))\n                                      .concat(dirHostBindings);\n      if (hostBindings.length) {\n        updateRendererExpressions =\n            hostBindings.map((hostBinding, bindingIndex) => this._preprocessUpdateExpression({\n              context: hostBinding.context,\n              nodeIndex,\n              bindingIndex,\n              sourceSpan: hostBinding.inputAst.sourceSpan,\n              value: hostBinding.inputAst.value\n            }));\n        inputDefs = hostBindings.map(\n            hostBinding => elementBindingDef(hostBinding.inputAst, hostBinding.dirAst));\n      }\n      outputDefs = usedEvents.map(\n          ([target, eventName]) => o.literalArr([o.literal(target), o.literal(eventName)]));\n    }\n\n    templateVisitAll(this, ast.children);\n\n    const childCount = this.nodes.length - nodeIndex - 1;\n\n    const compAst = ast.directives.find(dirAst => dirAst.directive.isComponent);\n    let compRendererType = o.NULL_EXPR as o.Expression;\n    let compView = o.NULL_EXPR as o.Expression;\n    if (compAst) {\n      compView = this.outputCtx.importExpr(compAst.directive.componentViewType);\n      compRendererType = this.outputCtx.importExpr(compAst.directive.rendererType);\n    }\n\n    // Check index is the same as the node index during compilation\n    // They might only differ at runtime\n    const checkIndex = nodeIndex;\n\n    this.nodes[nodeIndex] = () => ({\n      sourceSpan: ast.sourceSpan,\n      nodeFlags: NodeFlags.TypeElement | flags,\n      nodeDef: o.importExpr(Identifiers.elementDef).callFn([\n        o.literal(checkIndex),\n        o.literal(flags),\n        queryMatchesExpr,\n        o.literal(ast.ngContentIndex),\n        o.literal(childCount),\n        o.literal(elName),\n        elName ? fixedAttrsDef(ast) : o.NULL_EXPR,\n        inputDefs.length ? o.literalArr(inputDefs) : o.NULL_EXPR,\n        outputDefs.length ? o.literalArr(outputDefs) : o.NULL_EXPR,\n        this._createElementHandleEventFn(nodeIndex, hostEvents),\n        compView,\n        compRendererType,\n      ]),\n      updateRenderer: updateRendererExpressions\n    });\n  }\n\n  private _visitElementOrTemplate(nodeIndex: number, ast: {\n    hasViewContainer: boolean,\n    outputs: BoundEventAst[],\n    directives: DirectiveAst[],\n    providers: ProviderAst[],\n    references: ReferenceAst[],\n    queryMatches: QueryMatch[]\n  }): {\n    flags: NodeFlags,\n    usedEvents: [string|null, string][],\n    queryMatchesExpr: o.Expression,\n    hostBindings:\n        {context: o.Expression, inputAst: BoundElementPropertyAst, dirAst: DirectiveAst}[],\n    hostEvents: {context: o.Expression, eventAst: BoundEventAst, dirAst: DirectiveAst}[],\n  } {\n    let flags = NodeFlags.None;\n    if (ast.hasViewContainer) {\n      flags |= NodeFlags.EmbeddedViews;\n    }\n    const usedEvents = new Map<string, [string | null, string]>();\n    ast.outputs.forEach((event) => {\n      const {name, target} = elementEventNameAndTarget(event, null);\n      usedEvents.set(elementEventFullName(target, name), [target, name]);\n    });\n    ast.directives.forEach((dirAst) => {\n      dirAst.hostEvents.forEach((event) => {\n        const {name, target} = elementEventNameAndTarget(event, dirAst);\n        usedEvents.set(elementEventFullName(target, name), [target, name]);\n      });\n    });\n    const hostBindings:\n        {context: o.Expression, inputAst: BoundElementPropertyAst, dirAst: DirectiveAst}[] = [];\n    const hostEvents: {context: o.Expression, eventAst: BoundEventAst, dirAst: DirectiveAst}[] = [];\n    this._visitComponentFactoryResolverProvider(ast.directives);\n\n    ast.providers.forEach(providerAst => {\n      let dirAst: DirectiveAst = undefined!;\n      ast.directives.forEach(localDirAst => {\n        if (localDirAst.directive.type.reference === tokenReference(providerAst.token)) {\n          dirAst = localDirAst;\n        }\n      });\n      if (dirAst) {\n        const {hostBindings: dirHostBindings, hostEvents: dirHostEvents} =\n            this._visitDirective(providerAst, dirAst, ast.references, ast.queryMatches, usedEvents);\n        hostBindings.push(...dirHostBindings);\n        hostEvents.push(...dirHostEvents);\n      } else {\n        this._visitProvider(providerAst, ast.queryMatches);\n      }\n    });\n\n    let queryMatchExprs: o.Expression[] = [];\n    ast.queryMatches.forEach((match) => {\n      let valueType: QueryValueType = undefined!;\n      if (tokenReference(match.value) ===\n          this.reflector.resolveExternalReference(Identifiers.ElementRef)) {\n        valueType = QueryValueType.ElementRef;\n      } else if (\n          tokenReference(match.value) ===\n          this.reflector.resolveExternalReference(Identifiers.ViewContainerRef)) {\n        valueType = QueryValueType.ViewContainerRef;\n      } else if (\n          tokenReference(match.value) ===\n          this.reflector.resolveExternalReference(Identifiers.TemplateRef)) {\n        valueType = QueryValueType.TemplateRef;\n      }\n      if (valueType != null) {\n        queryMatchExprs.push(o.literalArr([o.literal(match.queryId), o.literal(valueType)]));\n      }\n    });\n    ast.references.forEach((ref) => {\n      let valueType: QueryValueType = undefined!;\n      if (!ref.value) {\n        valueType = QueryValueType.RenderElement;\n      } else if (\n          tokenReference(ref.value) ===\n          this.reflector.resolveExternalReference(Identifiers.TemplateRef)) {\n        valueType = QueryValueType.TemplateRef;\n      }\n      if (valueType != null) {\n        this.refNodeIndices[ref.name] = nodeIndex;\n        queryMatchExprs.push(o.literalArr([o.literal(ref.name), o.literal(valueType)]));\n      }\n    });\n    ast.outputs.forEach((outputAst) => {\n      hostEvents.push({context: COMP_VAR, eventAst: outputAst, dirAst: null!});\n    });\n\n    return {\n      flags,\n      usedEvents: Array.from(usedEvents.values()),\n      queryMatchesExpr: queryMatchExprs.length ? o.literalArr(queryMatchExprs) : o.NULL_EXPR,\n      hostBindings,\n      hostEvents: hostEvents\n    };\n  }\n\n  private _visitDirective(\n      providerAst: ProviderAst, dirAst: DirectiveAst, refs: ReferenceAst[],\n      queryMatches: QueryMatch[], usedEvents: Map<string, any>): {\n    hostBindings:\n        {context: o.Expression, inputAst: BoundElementPropertyAst, dirAst: DirectiveAst}[],\n    hostEvents: {context: o.Expression, eventAst: BoundEventAst, dirAst: DirectiveAst}[]\n  } {\n    const nodeIndex = this.nodes.length;\n    // reserve the space in the nodeDefs array so we can add children\n    this.nodes.push(null!);\n\n    dirAst.directive.queries.forEach((query, queryIndex) => {\n      const queryId = dirAst.contentQueryStartId + queryIndex;\n      const flags = NodeFlags.TypeContentQuery | calcQueryFlags(query);\n      const bindingType = query.first ? QueryBindingType.First : QueryBindingType.All;\n      this.nodes.push(() => ({\n                        sourceSpan: dirAst.sourceSpan,\n                        nodeFlags: flags,\n                        nodeDef: o.importExpr(Identifiers.queryDef).callFn([\n                          o.literal(flags), o.literal(queryId),\n                          new o.LiteralMapExpr([new o.LiteralMapEntry(\n                              query.propertyName, o.literal(bindingType), false)])\n                        ]),\n                      }));\n    });\n\n    // Note: the operation below might also create new nodeDefs,\n    // but we don't want them to be a child of a directive,\n    // as they might be a provider/pipe on their own.\n    // I.e. we only allow queries as children of directives nodes.\n    const childCount = this.nodes.length - nodeIndex - 1;\n\n    let {flags, queryMatchExprs, providerExpr, depsExpr} =\n        this._visitProviderOrDirective(providerAst, queryMatches);\n\n    refs.forEach((ref) => {\n      if (ref.value && tokenReference(ref.value) === tokenReference(providerAst.token)) {\n        this.refNodeIndices[ref.name] = nodeIndex;\n        queryMatchExprs.push(\n            o.literalArr([o.literal(ref.name), o.literal(QueryValueType.Provider)]));\n      }\n    });\n\n    if (dirAst.directive.isComponent) {\n      flags |= NodeFlags.Component;\n    }\n\n    const inputDefs = dirAst.inputs.map((inputAst, inputIndex) => {\n      const mapValue = o.literalArr([o.literal(inputIndex), o.literal(inputAst.directiveName)]);\n      // Note: it's important to not quote the key so that we can capture renames by minifiers!\n      return new o.LiteralMapEntry(inputAst.directiveName, mapValue, false);\n    });\n\n    const outputDefs: o.LiteralMapEntry[] = [];\n    const dirMeta = dirAst.directive;\n    Object.keys(dirMeta.outputs).forEach((propName) => {\n      const eventName = dirMeta.outputs[propName];\n      if (usedEvents.has(eventName)) {\n        // Note: it's important to not quote the key so that we can capture renames by minifiers!\n        outputDefs.push(new o.LiteralMapEntry(propName, o.literal(eventName), false));\n      }\n    });\n    let updateDirectiveExpressions: UpdateExpression[] = [];\n    if (dirAst.inputs.length || (flags & (NodeFlags.DoCheck | NodeFlags.OnInit)) > 0) {\n      updateDirectiveExpressions =\n          dirAst.inputs.map((input, bindingIndex) => this._preprocessUpdateExpression({\n            nodeIndex,\n            bindingIndex,\n            sourceSpan: input.sourceSpan,\n            context: COMP_VAR,\n            value: input.value\n          }));\n    }\n\n    const dirContextExpr =\n        o.importExpr(Identifiers.nodeValue).callFn([VIEW_VAR, o.literal(nodeIndex)]);\n    const hostBindings = dirAst.hostProperties.map((inputAst) => ({\n                                                     context: dirContextExpr,\n                                                     dirAst,\n                                                     inputAst,\n                                                   }));\n    const hostEvents = dirAst.hostEvents.map((hostEventAst) => ({\n                                               context: dirContextExpr,\n                                               eventAst: hostEventAst,\n                                               dirAst,\n                                             }));\n\n    // Check index is the same as the node index during compilation\n    // They might only differ at runtime\n    const checkIndex = nodeIndex;\n\n    this.nodes[nodeIndex] = () => ({\n      sourceSpan: dirAst.sourceSpan,\n      nodeFlags: NodeFlags.TypeDirective | flags,\n      nodeDef: o.importExpr(Identifiers.directiveDef).callFn([\n        o.literal(checkIndex),\n        o.literal(flags),\n        queryMatchExprs.length ? o.literalArr(queryMatchExprs) : o.NULL_EXPR,\n        o.literal(childCount),\n        providerExpr,\n        depsExpr,\n        inputDefs.length ? new o.LiteralMapExpr(inputDefs) : o.NULL_EXPR,\n        outputDefs.length ? new o.LiteralMapExpr(outputDefs) : o.NULL_EXPR,\n      ]),\n      updateDirectives: updateDirectiveExpressions,\n      directive: dirAst.directive.type,\n    });\n\n    return {hostBindings, hostEvents};\n  }\n\n  private _visitProvider(providerAst: ProviderAst, queryMatches: QueryMatch[]): void {\n    this._addProviderNode(this._visitProviderOrDirective(providerAst, queryMatches));\n  }\n\n  private _visitComponentFactoryResolverProvider(directives: DirectiveAst[]) {\n    const componentDirMeta = directives.find(dirAst => dirAst.directive.isComponent);\n    if (componentDirMeta && componentDirMeta.directive.entryComponents.length) {\n      const {providerExpr, depsExpr, flags, tokenExpr} = componentFactoryResolverProviderDef(\n          this.reflector, this.outputCtx, NodeFlags.PrivateProvider,\n          componentDirMeta.directive.entryComponents);\n      this._addProviderNode({\n        providerExpr,\n        depsExpr,\n        flags,\n        tokenExpr,\n        queryMatchExprs: [],\n        sourceSpan: componentDirMeta.sourceSpan\n      });\n    }\n  }\n\n  private _addProviderNode(data: {\n    flags: NodeFlags,\n    queryMatchExprs: o.Expression[],\n    providerExpr: o.Expression,\n    depsExpr: o.Expression,\n    tokenExpr: o.Expression,\n    sourceSpan: ParseSourceSpan\n  }) {\n    // providerDef(\n    //   flags: NodeFlags, matchedQueries: [string, QueryValueType][], token:any,\n    //   value: any, deps: ([DepFlags, any] | any)[]): NodeDef;\n    this.nodes.push(\n        () => ({\n          sourceSpan: data.sourceSpan,\n          nodeFlags: data.flags,\n          nodeDef: o.importExpr(Identifiers.providerDef).callFn([\n            o.literal(data.flags),\n            data.queryMatchExprs.length ? o.literalArr(data.queryMatchExprs) : o.NULL_EXPR,\n            data.tokenExpr, data.providerExpr, data.depsExpr\n          ])\n        }));\n  }\n\n  private _visitProviderOrDirective(providerAst: ProviderAst, queryMatches: QueryMatch[]): {\n    flags: NodeFlags,\n    tokenExpr: o.Expression,\n    sourceSpan: ParseSourceSpan,\n    queryMatchExprs: o.Expression[],\n    providerExpr: o.Expression,\n    depsExpr: o.Expression\n  } {\n    let flags = NodeFlags.None;\n    let queryMatchExprs: o.Expression[] = [];\n\n    queryMatches.forEach((match) => {\n      if (tokenReference(match.value) === tokenReference(providerAst.token)) {\n        queryMatchExprs.push(\n            o.literalArr([o.literal(match.queryId), o.literal(QueryValueType.Provider)]));\n      }\n    });\n    const {providerExpr, depsExpr, flags: providerFlags, tokenExpr} =\n        providerDef(this.outputCtx, providerAst);\n    return {\n      flags: flags | providerFlags,\n      queryMatchExprs,\n      providerExpr,\n      depsExpr,\n      tokenExpr,\n      sourceSpan: providerAst.sourceSpan\n    };\n  }\n\n  getLocal(name: string): o.Expression|null {\n    if (name == EventHandlerVars.event.name) {\n      return EventHandlerVars.event;\n    }\n    let currViewExpr: o.Expression = VIEW_VAR;\n    for (let currBuilder: ViewBuilder|null = this; currBuilder; currBuilder = currBuilder.parent,\n                          currViewExpr = currViewExpr.prop('parent').cast(o.DYNAMIC_TYPE)) {\n      // check references\n      const refNodeIndex = currBuilder.refNodeIndices[name];\n      if (refNodeIndex != null) {\n        return o.importExpr(Identifiers.nodeValue).callFn([currViewExpr, o.literal(refNodeIndex)]);\n      }\n\n      // check variables\n      const varAst = currBuilder.variables.find((varAst) => varAst.name === name);\n      if (varAst) {\n        const varValue = varAst.value || IMPLICIT_TEMPLATE_VAR;\n        return currViewExpr.prop('context').prop(varValue);\n      }\n    }\n    return null;\n  }\n\n  notifyImplicitReceiverUse(): void {\n    // Not needed in ViewEngine as ViewEngine walks through the generated\n    // expressions to figure out if the implicit receiver is used and needs\n    // to be generated as part of the pre-update statements.\n  }\n\n  maybeRestoreView(): void {\n    // Not necessary in ViewEngine, because view restoration is an Ivy concept.\n  }\n\n  private _createLiteralArrayConverter(sourceSpan: ParseSourceSpan, argCount: number):\n      BuiltinConverter {\n    if (argCount === 0) {\n      const valueExpr = o.importExpr(Identifiers.EMPTY_ARRAY);\n      return () => valueExpr;\n    }\n\n    const checkIndex = this.nodes.length;\n\n    this.nodes.push(() => ({\n                      sourceSpan,\n                      nodeFlags: NodeFlags.TypePureArray,\n                      nodeDef: o.importExpr(Identifiers.pureArrayDef).callFn([\n                        o.literal(checkIndex),\n                        o.literal(argCount),\n                      ])\n                    }));\n\n    return (args: o.Expression[]) => callCheckStmt(checkIndex, args);\n  }\n\n  private _createLiteralMapConverter(\n      sourceSpan: ParseSourceSpan, keys: {key: string, quoted: boolean}[]): BuiltinConverter {\n    if (keys.length === 0) {\n      const valueExpr = o.importExpr(Identifiers.EMPTY_MAP);\n      return () => valueExpr;\n    }\n\n    const map = o.literalMap(keys.map((e, i) => ({...e, value: o.literal(i)})));\n    const checkIndex = this.nodes.length;\n    this.nodes.push(() => ({\n                      sourceSpan,\n                      nodeFlags: NodeFlags.TypePureObject,\n                      nodeDef: o.importExpr(Identifiers.pureObjectDef).callFn([\n                        o.literal(checkIndex),\n                        map,\n                      ])\n                    }));\n\n    return (args: o.Expression[]) => callCheckStmt(checkIndex, args);\n  }\n\n  private _createPipeConverter(expression: UpdateExpression, name: string, argCount: number):\n      BuiltinConverter {\n    const pipe = this.usedPipes.find((pipeSummary) => pipeSummary.name === name)!;\n    if (pipe.pure) {\n      const checkIndex = this.nodes.length;\n      this.nodes.push(() => ({\n                        sourceSpan: expression.sourceSpan,\n                        nodeFlags: NodeFlags.TypePurePipe,\n                        nodeDef: o.importExpr(Identifiers.purePipeDef).callFn([\n                          o.literal(checkIndex),\n                          o.literal(argCount),\n                        ])\n                      }));\n\n      // find underlying pipe in the component view\n      let compViewExpr: o.Expression = VIEW_VAR;\n      let compBuilder: ViewBuilder = this;\n      while (compBuilder.parent) {\n        compBuilder = compBuilder.parent;\n        compViewExpr = compViewExpr.prop('parent').cast(o.DYNAMIC_TYPE);\n      }\n      const pipeNodeIndex = compBuilder.purePipeNodeIndices[name];\n      const pipeValueExpr: o.Expression =\n          o.importExpr(Identifiers.nodeValue).callFn([compViewExpr, o.literal(pipeNodeIndex)]);\n\n      return (args: o.Expression[]) => callUnwrapValue(\n                 expression.nodeIndex, expression.bindingIndex,\n                 callCheckStmt(checkIndex, [pipeValueExpr].concat(args)));\n    } else {\n      const nodeIndex = this._createPipe(expression.sourceSpan, pipe);\n      const nodeValueExpr =\n          o.importExpr(Identifiers.nodeValue).callFn([VIEW_VAR, o.literal(nodeIndex)]);\n\n      return (args: o.Expression[]) => callUnwrapValue(\n                 expression.nodeIndex, expression.bindingIndex,\n                 nodeValueExpr.callMethod('transform', args));\n    }\n  }\n\n  private _createPipe(sourceSpan: ParseSourceSpan|null, pipe: CompilePipeSummary): number {\n    const nodeIndex = this.nodes.length;\n    let flags = NodeFlags.None;\n    pipe.type.lifecycleHooks.forEach((lifecycleHook) => {\n      // for pipes, we only support ngOnDestroy\n      if (lifecycleHook === LifecycleHooks.OnDestroy) {\n        flags |= lifecycleHookToNodeFlag(lifecycleHook);\n      }\n    });\n\n    const depExprs = pipe.type.diDeps.map((diDep) => depDef(this.outputCtx, diDep));\n    // function pipeDef(\n    //   flags: NodeFlags, ctor: any, deps: ([DepFlags, any] | any)[]): NodeDef\n    this.nodes.push(\n        () => ({\n          sourceSpan,\n          nodeFlags: NodeFlags.TypePipe,\n          nodeDef: o.importExpr(Identifiers.pipeDef).callFn([\n            o.literal(flags), this.outputCtx.importExpr(pipe.type.reference), o.literalArr(depExprs)\n          ])\n        }));\n    return nodeIndex;\n  }\n\n  /**\n   * For the AST in `UpdateExpression.value`:\n   * - create nodes for pipes, literal arrays and, literal maps,\n   * - update the AST to replace pipes, literal arrays and, literal maps with calls to check fn.\n   *\n   * WARNING: This might create new nodeDefs (for pipes and literal arrays and literal maps)!\n   */\n  private _preprocessUpdateExpression(expression: UpdateExpression): UpdateExpression {\n    return {\n      nodeIndex: expression.nodeIndex,\n      bindingIndex: expression.bindingIndex,\n      sourceSpan: expression.sourceSpan,\n      context: expression.context,\n      value: convertPropertyBindingBuiltins(\n          {\n            createLiteralArrayConverter: (argCount: number) =>\n                this._createLiteralArrayConverter(expression.sourceSpan, argCount),\n            createLiteralMapConverter: (keys: {key: string, quoted: boolean}[]) =>\n                this._createLiteralMapConverter(expression.sourceSpan, keys),\n            createPipeConverter: (name: string, argCount: number) =>\n                this._createPipeConverter(expression, name, argCount)\n          },\n          expression.value)\n    };\n  }\n\n  private _createNodeExpressions(): {\n    updateRendererStmts: o.Statement[],\n    updateDirectivesStmts: o.Statement[],\n    nodeDefExprs: o.Expression[]\n  } {\n    const self = this;\n    let updateBindingCount = 0;\n    const updateRendererStmts: o.Statement[] = [];\n    const updateDirectivesStmts: o.Statement[] = [];\n    const nodeDefExprs = this.nodes.map((factory, nodeIndex) => {\n      const {nodeDef, nodeFlags, updateDirectives, updateRenderer, sourceSpan} = factory();\n      if (updateRenderer) {\n        updateRendererStmts.push(\n            ...createUpdateStatements(nodeIndex, sourceSpan, updateRenderer, false));\n      }\n      if (updateDirectives) {\n        updateDirectivesStmts.push(...createUpdateStatements(\n            nodeIndex, sourceSpan, updateDirectives,\n            (nodeFlags & (NodeFlags.DoCheck | NodeFlags.OnInit)) > 0));\n      }\n      // We use a comma expression to call the log function before\n      // the nodeDef function, but still use the result of the nodeDef function\n      // as the value.\n      // Note: We only add the logger to elements / text nodes,\n      // so we don't generate too much code.\n      const logWithNodeDef = nodeFlags & NodeFlags.CatRenderNode ?\n          new o.CommaExpr([LOG_VAR.callFn([]).callFn([]), nodeDef]) :\n          nodeDef;\n      return o.applySourceSpanToExpressionIfNeeded(logWithNodeDef, sourceSpan);\n    });\n    return {updateRendererStmts, updateDirectivesStmts, nodeDefExprs};\n\n    function createUpdateStatements(\n        nodeIndex: number, sourceSpan: ParseSourceSpan|null, expressions: UpdateExpression[],\n        allowEmptyExprs: boolean): o.Statement[] {\n      const updateStmts: o.Statement[] = [];\n      const exprs = expressions.map(({sourceSpan, context, value}) => {\n        const bindingId = `${updateBindingCount++}`;\n        const nameResolver = context === COMP_VAR ? self : null;\n        const {stmts, currValExpr} =\n            convertPropertyBinding(nameResolver, context, value, bindingId, BindingForm.General);\n        updateStmts.push(...stmts.map(\n            (stmt: o.Statement) => o.applySourceSpanToStatementIfNeeded(stmt, sourceSpan)));\n        return o.applySourceSpanToExpressionIfNeeded(currValExpr, sourceSpan);\n      });\n      if (expressions.length || allowEmptyExprs) {\n        updateStmts.push(o.applySourceSpanToStatementIfNeeded(\n            callCheckStmt(nodeIndex, exprs).toStmt(), sourceSpan));\n      }\n      return updateStmts;\n    }\n  }\n\n  private _createElementHandleEventFn(\n      nodeIndex: number,\n      handlers: {context: o.Expression, eventAst: BoundEventAst, dirAst: DirectiveAst}[]) {\n    const handleEventStmts: o.Statement[] = [];\n    let handleEventBindingCount = 0;\n    handlers.forEach(({context, eventAst, dirAst}) => {\n      const bindingId = `${handleEventBindingCount++}`;\n      const nameResolver = context === COMP_VAR ? this : null;\n      const {stmts, allowDefault} =\n          convertActionBinding(nameResolver, context, eventAst.handler, bindingId);\n      const trueStmts = stmts;\n      if (allowDefault) {\n        trueStmts.push(ALLOW_DEFAULT_VAR.set(allowDefault.and(ALLOW_DEFAULT_VAR)).toStmt());\n      }\n      const {target: eventTarget, name: eventName} = elementEventNameAndTarget(eventAst, dirAst);\n      const fullEventName = elementEventFullName(eventTarget, eventName);\n      handleEventStmts.push(o.applySourceSpanToStatementIfNeeded(\n          new o.IfStmt(o.literal(fullEventName).identical(EVENT_NAME_VAR), trueStmts),\n          eventAst.sourceSpan));\n    });\n    let handleEventFn: o.Expression;\n    if (handleEventStmts.length > 0) {\n      const preStmts: o.Statement[] =\n          [ALLOW_DEFAULT_VAR.set(o.literal(true)).toDeclStmt(o.BOOL_TYPE)];\n      if (!this.component.isHost && o.findReadVarNames(handleEventStmts).has(COMP_VAR.name!)) {\n        preStmts.push(COMP_VAR.set(VIEW_VAR.prop('component')).toDeclStmt(this.compType));\n      }\n      handleEventFn = o.fn(\n          [\n            new o.FnParam(VIEW_VAR.name!, o.INFERRED_TYPE),\n            new o.FnParam(EVENT_NAME_VAR.name!, o.INFERRED_TYPE),\n            new o.FnParam(EventHandlerVars.event.name!, o.INFERRED_TYPE)\n          ],\n          [...preStmts, ...handleEventStmts, new o.ReturnStatement(ALLOW_DEFAULT_VAR)],\n          o.INFERRED_TYPE);\n    } else {\n      handleEventFn = o.NULL_EXPR;\n    }\n    return handleEventFn;\n  }\n\n  visitDirective(ast: DirectiveAst, context: {usedEvents: Set<string>}): any {}\n  visitDirectiveProperty(ast: BoundDirectivePropertyAst, context: any): any {}\n  visitReference(ast: ReferenceAst, context: any): any {}\n  visitVariable(ast: VariableAst, context: any): any {}\n  visitEvent(ast: BoundEventAst, context: any): any {}\n  visitElementProperty(ast: BoundElementPropertyAst, context: any): any {}\n  visitAttr(ast: AttrAst, context: any): any {}\n}\n\nfunction needsAdditionalRootNode(astNodes: TemplateAst[]): boolean {\n  const lastAstNode = astNodes[astNodes.length - 1];\n  if (lastAstNode instanceof EmbeddedTemplateAst) {\n    return lastAstNode.hasViewContainer;\n  }\n\n  if (lastAstNode instanceof ElementAst) {\n    if (isNgContainer(lastAstNode.name) && lastAstNode.children.length) {\n      return needsAdditionalRootNode(lastAstNode.children);\n    }\n    return lastAstNode.hasViewContainer;\n  }\n\n  return lastAstNode instanceof NgContentAst;\n}\n\n\nfunction elementBindingDef(inputAst: BoundElementPropertyAst, dirAst: DirectiveAst): o.Expression {\n  const inputType = inputAst.type;\n  switch (inputType) {\n    case PropertyBindingType.Attribute:\n      return o.literalArr([\n        o.literal(BindingFlags.TypeElementAttribute), o.literal(inputAst.name),\n        o.literal(inputAst.securityContext)\n      ]);\n    case PropertyBindingType.Property:\n      return o.literalArr([\n        o.literal(BindingFlags.TypeProperty), o.literal(inputAst.name),\n        o.literal(inputAst.securityContext)\n      ]);\n    case PropertyBindingType.Animation:\n      const bindingType = BindingFlags.TypeProperty |\n          (dirAst && dirAst.directive.isComponent ? BindingFlags.SyntheticHostProperty :\n                                                    BindingFlags.SyntheticProperty);\n      return o.literalArr([\n        o.literal(bindingType), o.literal('@' + inputAst.name), o.literal(inputAst.securityContext)\n      ]);\n    case PropertyBindingType.Class:\n      return o.literalArr(\n          [o.literal(BindingFlags.TypeElementClass), o.literal(inputAst.name), o.NULL_EXPR]);\n    case PropertyBindingType.Style:\n      return o.literalArr([\n        o.literal(BindingFlags.TypeElementStyle), o.literal(inputAst.name), o.literal(inputAst.unit)\n      ]);\n    default:\n      // This default case is not needed by TypeScript compiler, as the switch is exhaustive.\n      // However Closure Compiler does not understand that and reports an error in typed mode.\n      // The `throw new Error` below works around the problem, and the unexpected: never variable\n      // makes sure tsc still checks this code is unreachable.\n      const unexpected: never = inputType;\n      throw new Error(`unexpected ${unexpected}`);\n  }\n}\n\n\nfunction fixedAttrsDef(elementAst: ElementAst): o.Expression {\n  const mapResult: {[key: string]: string} = Object.create(null);\n  elementAst.attrs.forEach(attrAst => {\n    mapResult[attrAst.name] = attrAst.value;\n  });\n  elementAst.directives.forEach(dirAst => {\n    Object.keys(dirAst.directive.hostAttributes).forEach(name => {\n      const value = dirAst.directive.hostAttributes[name];\n      const prevValue = mapResult[name];\n      mapResult[name] = prevValue != null ? mergeAttributeValue(name, prevValue, value) : value;\n    });\n  });\n  // Note: We need to sort to get a defined output order\n  // for tests and for caching generated artifacts...\n  return o.literalArr(Object.keys(mapResult).sort().map(\n      (attrName) => o.literalArr([o.literal(attrName), o.literal(mapResult[attrName])])));\n}\n\nfunction mergeAttributeValue(attrName: string, attrValue1: string, attrValue2: string): string {\n  if (attrName == CLASS_ATTR || attrName == STYLE_ATTR) {\n    return `${attrValue1} ${attrValue2}`;\n  } else {\n    return attrValue2;\n  }\n}\n\nfunction callCheckStmt(nodeIndex: number, exprs: o.Expression[]): o.Expression {\n  if (exprs.length > 10) {\n    return CHECK_VAR.callFn(\n        [VIEW_VAR, o.literal(nodeIndex), o.literal(ArgumentType.Dynamic), o.literalArr(exprs)]);\n  } else {\n    return CHECK_VAR.callFn(\n        [VIEW_VAR, o.literal(nodeIndex), o.literal(ArgumentType.Inline), ...exprs]);\n  }\n}\n\nfunction callUnwrapValue(nodeIndex: number, bindingIdx: number, expr: o.Expression): o.Expression {\n  return o.importExpr(Identifiers.unwrapValue).callFn([\n    VIEW_VAR, o.literal(nodeIndex), o.literal(bindingIdx), expr\n  ]);\n}\n\nfunction elementEventNameAndTarget(\n    eventAst: BoundEventAst, dirAst: DirectiveAst|null): {name: string, target: string|null} {\n  if (eventAst.isAnimation) {\n    return {\n      name: `@${eventAst.name}.${eventAst.phase}`,\n      target: dirAst && dirAst.directive.isComponent ? 'component' : null\n    };\n  } else {\n    return eventAst;\n  }\n}\n\nfunction calcQueryFlags(query: CompileQueryMetadata) {\n  let flags = NodeFlags.None;\n  // Note: We only make queries static that query for a single item and the user specifically\n  // set the to be static. This is because of backwards compatibility with the old view compiler...\n  if (query.first && query.static) {\n    flags |= NodeFlags.StaticQuery;\n  } else {\n    flags |= NodeFlags.DynamicQuery;\n  }\n  if (query.emitDistinctChangesOnly) {\n    flags |= NodeFlags.EmitDistinctChangesOnly;\n  }\n  return flags;\n}\n\nexport function elementEventFullName(target: string|null, name: string): string {\n  return target ? `${target}:${name}` : name;\n}\n"]}
Note: See TracBrowser for help on using the repository browser.