source: trip-planner-front/node_modules/@angular/compiler/src/constant_pool.js@ 6a3a178

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

initial commit
  • Property mode set to 100644
File size: 45.0 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/constant_pool", ["require", "exports", "tslib", "@angular/compiler/src/output/output_ast"], factory);
15 }
16})(function (require, exports) {
17 "use strict";
18 Object.defineProperty(exports, "__esModule", { value: true });
19 exports.ConstantPool = void 0;
20 var tslib_1 = require("tslib");
21 var o = require("@angular/compiler/src/output/output_ast");
22 var CONSTANT_PREFIX = '_c';
23 /**
24 * `ConstantPool` tries to reuse literal factories when two or more literals are identical.
25 * We determine whether literals are identical by creating a key out of their AST using the
26 * `KeyVisitor`. This constant is used to replace dynamic expressions which can't be safely
27 * converted into a key. E.g. given an expression `{foo: bar()}`, since we don't know what
28 * the result of `bar` will be, we create a key that looks like `{foo: <unknown>}`. Note
29 * that we use a variable, rather than something like `null` in order to avoid collisions.
30 */
31 var UNKNOWN_VALUE_KEY = o.variable('<unknown>');
32 /**
33 * Context to use when producing a key.
34 *
35 * This ensures we see the constant not the reference variable when producing
36 * a key.
37 */
38 var KEY_CONTEXT = {};
39 /**
40 * Generally all primitive values are excluded from the `ConstantPool`, but there is an exclusion
41 * for strings that reach a certain length threshold. This constant defines the length threshold for
42 * strings.
43 */
44 var POOL_INCLUSION_LENGTH_THRESHOLD_FOR_STRINGS = 50;
45 /**
46 * A node that is a place-holder that allows the node to be replaced when the actual
47 * node is known.
48 *
49 * This allows the constant pool to change an expression from a direct reference to
50 * a constant to a shared constant. It returns a fix-up node that is later allowed to
51 * change the referenced expression.
52 */
53 var FixupExpression = /** @class */ (function (_super) {
54 tslib_1.__extends(FixupExpression, _super);
55 function FixupExpression(resolved) {
56 var _this = _super.call(this, resolved.type) || this;
57 _this.resolved = resolved;
58 _this.original = resolved;
59 return _this;
60 }
61 FixupExpression.prototype.visitExpression = function (visitor, context) {
62 if (context === KEY_CONTEXT) {
63 // When producing a key we want to traverse the constant not the
64 // variable used to refer to it.
65 return this.original.visitExpression(visitor, context);
66 }
67 else {
68 return this.resolved.visitExpression(visitor, context);
69 }
70 };
71 FixupExpression.prototype.isEquivalent = function (e) {
72 return e instanceof FixupExpression && this.resolved.isEquivalent(e.resolved);
73 };
74 FixupExpression.prototype.isConstant = function () {
75 return true;
76 };
77 FixupExpression.prototype.fixup = function (expression) {
78 this.resolved = expression;
79 this.shared = true;
80 };
81 return FixupExpression;
82 }(o.Expression));
83 /**
84 * A constant pool allows a code emitter to share constant in an output context.
85 *
86 * The constant pool also supports sharing access to ivy definitions references.
87 */
88 var ConstantPool = /** @class */ (function () {
89 function ConstantPool(isClosureCompilerEnabled) {
90 if (isClosureCompilerEnabled === void 0) { isClosureCompilerEnabled = false; }
91 this.isClosureCompilerEnabled = isClosureCompilerEnabled;
92 this.statements = [];
93 this.literals = new Map();
94 this.literalFactories = new Map();
95 this.injectorDefinitions = new Map();
96 this.directiveDefinitions = new Map();
97 this.componentDefinitions = new Map();
98 this.pipeDefinitions = new Map();
99 this.nextNameIndex = 0;
100 }
101 ConstantPool.prototype.getConstLiteral = function (literal, forceShared) {
102 if ((literal instanceof o.LiteralExpr && !isLongStringLiteral(literal)) ||
103 literal instanceof FixupExpression) {
104 // Do no put simple literals into the constant pool or try to produce a constant for a
105 // reference to a constant.
106 return literal;
107 }
108 var key = this.keyOf(literal);
109 var fixup = this.literals.get(key);
110 var newValue = false;
111 if (!fixup) {
112 fixup = new FixupExpression(literal);
113 this.literals.set(key, fixup);
114 newValue = true;
115 }
116 if ((!newValue && !fixup.shared) || (newValue && forceShared)) {
117 // Replace the expression with a variable
118 var name_1 = this.freshName();
119 var definition = void 0;
120 var usage = void 0;
121 if (this.isClosureCompilerEnabled && isLongStringLiteral(literal)) {
122 // For string literals, Closure will **always** inline the string at
123 // **all** usages, duplicating it each time. For large strings, this
124 // unnecessarily bloats bundle size. To work around this restriction, we
125 // wrap the string in a function, and call that function for each usage.
126 // This tricks Closure into using inline logic for functions instead of
127 // string literals. Function calls are only inlined if the body is small
128 // enough to be worth it. By doing this, very large strings will be
129 // shared across multiple usages, rather than duplicating the string at
130 // each usage site.
131 //
132 // const myStr = function() { return "very very very long string"; };
133 // const usage1 = myStr();
134 // const usage2 = myStr();
135 definition = o.variable(name_1).set(new o.FunctionExpr([], // Params.
136 [
137 // Statements.
138 new o.ReturnStatement(literal),
139 ]));
140 usage = o.variable(name_1).callFn([]);
141 }
142 else {
143 // Just declare and use the variable directly, without a function call
144 // indirection. This saves a few bytes and avoids an unncessary call.
145 definition = o.variable(name_1).set(literal);
146 usage = o.variable(name_1);
147 }
148 this.statements.push(definition.toDeclStmt(o.INFERRED_TYPE, [o.StmtModifier.Final]));
149 fixup.fixup(usage);
150 }
151 return fixup;
152 };
153 ConstantPool.prototype.getDefinition = function (type, kind, ctx, forceShared) {
154 if (forceShared === void 0) { forceShared = false; }
155 var definitions = this.definitionsOf(kind);
156 var fixup = definitions.get(type);
157 var newValue = false;
158 if (!fixup) {
159 var property = this.propertyNameOf(kind);
160 fixup = new FixupExpression(ctx.importExpr(type).prop(property));
161 definitions.set(type, fixup);
162 newValue = true;
163 }
164 if ((!newValue && !fixup.shared) || (newValue && forceShared)) {
165 var name_2 = this.freshName();
166 this.statements.push(o.variable(name_2).set(fixup.resolved).toDeclStmt(o.INFERRED_TYPE, [o.StmtModifier.Final]));
167 fixup.fixup(o.variable(name_2));
168 }
169 return fixup;
170 };
171 ConstantPool.prototype.getLiteralFactory = function (literal) {
172 // Create a pure function that builds an array of a mix of constant and variable expressions
173 if (literal instanceof o.LiteralArrayExpr) {
174 var argumentsForKey = literal.entries.map(function (e) { return e.isConstant() ? e : UNKNOWN_VALUE_KEY; });
175 var key = this.keyOf(o.literalArr(argumentsForKey));
176 return this._getLiteralFactory(key, literal.entries, function (entries) { return o.literalArr(entries); });
177 }
178 else {
179 var expressionForKey = o.literalMap(literal.entries.map(function (e) { return ({
180 key: e.key,
181 value: e.value.isConstant() ? e.value : UNKNOWN_VALUE_KEY,
182 quoted: e.quoted
183 }); }));
184 var key = this.keyOf(expressionForKey);
185 return this._getLiteralFactory(key, literal.entries.map(function (e) { return e.value; }), function (entries) { return o.literalMap(entries.map(function (value, index) { return ({
186 key: literal.entries[index].key,
187 value: value,
188 quoted: literal.entries[index].quoted
189 }); })); });
190 }
191 };
192 ConstantPool.prototype._getLiteralFactory = function (key, values, resultMap) {
193 var _this = this;
194 var literalFactory = this.literalFactories.get(key);
195 var literalFactoryArguments = values.filter((function (e) { return !e.isConstant(); }));
196 if (!literalFactory) {
197 var resultExpressions = values.map(function (e, index) { return e.isConstant() ? _this.getConstLiteral(e, true) : o.variable("a" + index); });
198 var parameters = resultExpressions.filter(isVariable).map(function (e) { return new o.FnParam(e.name, o.DYNAMIC_TYPE); });
199 var pureFunctionDeclaration = o.fn(parameters, [new o.ReturnStatement(resultMap(resultExpressions))], o.INFERRED_TYPE);
200 var name_3 = this.freshName();
201 this.statements.push(o.variable(name_3).set(pureFunctionDeclaration).toDeclStmt(o.INFERRED_TYPE, [
202 o.StmtModifier.Final
203 ]));
204 literalFactory = o.variable(name_3);
205 this.literalFactories.set(key, literalFactory);
206 }
207 return { literalFactory: literalFactory, literalFactoryArguments: literalFactoryArguments };
208 };
209 /**
210 * Produce a unique name.
211 *
212 * The name might be unique among different prefixes if any of the prefixes end in
213 * a digit so the prefix should be a constant string (not based on user input) and
214 * must not end in a digit.
215 */
216 ConstantPool.prototype.uniqueName = function (prefix) {
217 return "" + prefix + this.nextNameIndex++;
218 };
219 ConstantPool.prototype.definitionsOf = function (kind) {
220 switch (kind) {
221 case 2 /* Component */:
222 return this.componentDefinitions;
223 case 1 /* Directive */:
224 return this.directiveDefinitions;
225 case 0 /* Injector */:
226 return this.injectorDefinitions;
227 case 3 /* Pipe */:
228 return this.pipeDefinitions;
229 }
230 };
231 ConstantPool.prototype.propertyNameOf = function (kind) {
232 switch (kind) {
233 case 2 /* Component */:
234 return 'ɵcmp';
235 case 1 /* Directive */:
236 return 'ɵdir';
237 case 0 /* Injector */:
238 return 'ɵinj';
239 case 3 /* Pipe */:
240 return 'ɵpipe';
241 }
242 };
243 ConstantPool.prototype.freshName = function () {
244 return this.uniqueName(CONSTANT_PREFIX);
245 };
246 ConstantPool.prototype.keyOf = function (expression) {
247 return expression.visitExpression(new KeyVisitor(), KEY_CONTEXT);
248 };
249 return ConstantPool;
250 }());
251 exports.ConstantPool = ConstantPool;
252 /**
253 * Visitor used to determine if 2 expressions are equivalent and can be shared in the
254 * `ConstantPool`.
255 *
256 * When the id (string) generated by the visitor is equal, expressions are considered equivalent.
257 */
258 var KeyVisitor = /** @class */ (function () {
259 function KeyVisitor() {
260 this.visitWrappedNodeExpr = invalid;
261 this.visitWriteVarExpr = invalid;
262 this.visitWriteKeyExpr = invalid;
263 this.visitWritePropExpr = invalid;
264 this.visitInvokeMethodExpr = invalid;
265 this.visitInvokeFunctionExpr = invalid;
266 this.visitTaggedTemplateExpr = invalid;
267 this.visitInstantiateExpr = invalid;
268 this.visitConditionalExpr = invalid;
269 this.visitNotExpr = invalid;
270 this.visitAssertNotNullExpr = invalid;
271 this.visitCastExpr = invalid;
272 this.visitFunctionExpr = invalid;
273 this.visitUnaryOperatorExpr = invalid;
274 this.visitBinaryOperatorExpr = invalid;
275 this.visitReadPropExpr = invalid;
276 this.visitReadKeyExpr = invalid;
277 this.visitCommaExpr = invalid;
278 this.visitLocalizedString = invalid;
279 }
280 KeyVisitor.prototype.visitLiteralExpr = function (ast) {
281 return "" + (typeof ast.value === 'string' ? '"' + ast.value + '"' : ast.value);
282 };
283 KeyVisitor.prototype.visitLiteralArrayExpr = function (ast, context) {
284 var _this = this;
285 return "[" + ast.entries.map(function (entry) { return entry.visitExpression(_this, context); }).join(',') + "]";
286 };
287 KeyVisitor.prototype.visitLiteralMapExpr = function (ast, context) {
288 var _this = this;
289 var mapKey = function (entry) {
290 var quote = entry.quoted ? '"' : '';
291 return "" + quote + entry.key + quote;
292 };
293 var mapEntry = function (entry) {
294 return mapKey(entry) + ":" + entry.value.visitExpression(_this, context);
295 };
296 return "{" + ast.entries.map(mapEntry).join(',');
297 };
298 KeyVisitor.prototype.visitExternalExpr = function (ast) {
299 return ast.value.moduleName ? "EX:" + ast.value.moduleName + ":" + ast.value.name :
300 "EX:" + ast.value.runtime.name;
301 };
302 KeyVisitor.prototype.visitReadVarExpr = function (node) {
303 return "VAR:" + node.name;
304 };
305 KeyVisitor.prototype.visitTypeofExpr = function (node, context) {
306 return "TYPEOF:" + node.expr.visitExpression(this, context);
307 };
308 return KeyVisitor;
309 }());
310 function invalid(arg) {
311 throw new Error("Invalid state: Visitor " + this.constructor.name + " doesn't handle " + arg.constructor.name);
312 }
313 function isVariable(e) {
314 return e instanceof o.ReadVarExpr;
315 }
316 function isLongStringLiteral(expr) {
317 return expr instanceof o.LiteralExpr && typeof expr.value === 'string' &&
318 expr.value.length >= POOL_INCLUSION_LENGTH_THRESHOLD_FOR_STRINGS;
319 }
320});
321//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constant_pool.js","sourceRoot":"","sources":["../../../../../../packages/compiler/src/constant_pool.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 o from './output/output_ast';\n\nconst CONSTANT_PREFIX = '_c';\n\n/**\n * `ConstantPool` tries to reuse literal factories when two or more literals are identical.\n * We determine whether literals are identical by creating a key out of their AST using the\n * `KeyVisitor`. This constant is used to replace dynamic expressions which can't be safely\n * converted into a key. E.g. given an expression `{foo: bar()}`, since we don't know what\n * the result of `bar` will be, we create a key that looks like `{foo: <unknown>}`. Note\n * that we use a variable, rather than something like `null` in order to avoid collisions.\n */\nconst UNKNOWN_VALUE_KEY = o.variable('<unknown>');\n\nexport const enum DefinitionKind {\n  Injector,\n  Directive,\n  Component,\n  Pipe\n}\n\n/**\n * Context to use when producing a key.\n *\n * This ensures we see the constant not the reference variable when producing\n * a key.\n */\nconst KEY_CONTEXT = {};\n\n/**\n * Generally all primitive values are excluded from the `ConstantPool`, but there is an exclusion\n * for strings that reach a certain length threshold. This constant defines the length threshold for\n * strings.\n */\nconst POOL_INCLUSION_LENGTH_THRESHOLD_FOR_STRINGS = 50;\n\n/**\n * A node that is a place-holder that allows the node to be replaced when the actual\n * node is known.\n *\n * This allows the constant pool to change an expression from a direct reference to\n * a constant to a shared constant. It returns a fix-up node that is later allowed to\n * change the referenced expression.\n */\nclass FixupExpression extends o.Expression {\n  private original: o.Expression;\n\n  // TODO(issue/24571): remove '!'.\n  shared!: boolean;\n\n  constructor(public resolved: o.Expression) {\n    super(resolved.type);\n    this.original = resolved;\n  }\n\n  override visitExpression(visitor: o.ExpressionVisitor, context: any): any {\n    if (context === KEY_CONTEXT) {\n      // When producing a key we want to traverse the constant not the\n      // variable used to refer to it.\n      return this.original.visitExpression(visitor, context);\n    } else {\n      return this.resolved.visitExpression(visitor, context);\n    }\n  }\n\n  override isEquivalent(e: o.Expression): boolean {\n    return e instanceof FixupExpression && this.resolved.isEquivalent(e.resolved);\n  }\n\n  override isConstant() {\n    return true;\n  }\n\n  fixup(expression: o.Expression) {\n    this.resolved = expression;\n    this.shared = true;\n  }\n}\n\n/**\n * A constant pool allows a code emitter to share constant in an output context.\n *\n * The constant pool also supports sharing access to ivy definitions references.\n */\nexport class ConstantPool {\n  statements: o.Statement[] = [];\n  private literals = new Map<string, FixupExpression>();\n  private literalFactories = new Map<string, o.Expression>();\n  private injectorDefinitions = new Map<any, FixupExpression>();\n  private directiveDefinitions = new Map<any, FixupExpression>();\n  private componentDefinitions = new Map<any, FixupExpression>();\n  private pipeDefinitions = new Map<any, FixupExpression>();\n\n  private nextNameIndex = 0;\n\n  constructor(private readonly isClosureCompilerEnabled: boolean = false) {}\n\n  getConstLiteral(literal: o.Expression, forceShared?: boolean): o.Expression {\n    if ((literal instanceof o.LiteralExpr && !isLongStringLiteral(literal)) ||\n        literal instanceof FixupExpression) {\n      // Do no put simple literals into the constant pool or try to produce a constant for a\n      // reference to a constant.\n      return literal;\n    }\n    const key = this.keyOf(literal);\n    let fixup = this.literals.get(key);\n    let newValue = false;\n    if (!fixup) {\n      fixup = new FixupExpression(literal);\n      this.literals.set(key, fixup);\n      newValue = true;\n    }\n\n    if ((!newValue && !fixup.shared) || (newValue && forceShared)) {\n      // Replace the expression with a variable\n      const name = this.freshName();\n      let definition: o.WriteVarExpr;\n      let usage: o.Expression;\n      if (this.isClosureCompilerEnabled && isLongStringLiteral(literal)) {\n        // For string literals, Closure will **always** inline the string at\n        // **all** usages, duplicating it each time. For large strings, this\n        // unnecessarily bloats bundle size. To work around this restriction, we\n        // wrap the string in a function, and call that function for each usage.\n        // This tricks Closure into using inline logic for functions instead of\n        // string literals. Function calls are only inlined if the body is small\n        // enough to be worth it. By doing this, very large strings will be\n        // shared across multiple usages, rather than duplicating the string at\n        // each usage site.\n        //\n        // const myStr = function() { return \"very very very long string\"; };\n        // const usage1 = myStr();\n        // const usage2 = myStr();\n        definition = o.variable(name).set(new o.FunctionExpr(\n            [],  // Params.\n            [\n              // Statements.\n              new o.ReturnStatement(literal),\n            ],\n            ));\n        usage = o.variable(name).callFn([]);\n      } else {\n        // Just declare and use the variable directly, without a function call\n        // indirection. This saves a few bytes and avoids an unncessary call.\n        definition = o.variable(name).set(literal);\n        usage = o.variable(name);\n      }\n\n      this.statements.push(definition.toDeclStmt(o.INFERRED_TYPE, [o.StmtModifier.Final]));\n      fixup.fixup(usage);\n    }\n\n    return fixup;\n  }\n\n  getDefinition(type: any, kind: DefinitionKind, ctx: OutputContext, forceShared: boolean = false):\n      o.Expression {\n    const definitions = this.definitionsOf(kind);\n    let fixup = definitions.get(type);\n    let newValue = false;\n    if (!fixup) {\n      const property = this.propertyNameOf(kind);\n      fixup = new FixupExpression(ctx.importExpr(type).prop(property));\n      definitions.set(type, fixup);\n      newValue = true;\n    }\n\n    if ((!newValue && !fixup.shared) || (newValue && forceShared)) {\n      const name = this.freshName();\n      this.statements.push(\n          o.variable(name).set(fixup.resolved).toDeclStmt(o.INFERRED_TYPE, [o.StmtModifier.Final]));\n      fixup.fixup(o.variable(name));\n    }\n    return fixup;\n  }\n\n  getLiteralFactory(literal: o.LiteralArrayExpr|o.LiteralMapExpr):\n      {literalFactory: o.Expression, literalFactoryArguments: o.Expression[]} {\n    // Create a pure function that builds an array of a mix of constant and variable expressions\n    if (literal instanceof o.LiteralArrayExpr) {\n      const argumentsForKey = literal.entries.map(e => e.isConstant() ? e : UNKNOWN_VALUE_KEY);\n      const key = this.keyOf(o.literalArr(argumentsForKey));\n      return this._getLiteralFactory(key, literal.entries, entries => o.literalArr(entries));\n    } else {\n      const expressionForKey = o.literalMap(\n          literal.entries.map(e => ({\n                                key: e.key,\n                                value: e.value.isConstant() ? e.value : UNKNOWN_VALUE_KEY,\n                                quoted: e.quoted\n                              })));\n      const key = this.keyOf(expressionForKey);\n      return this._getLiteralFactory(\n          key, literal.entries.map(e => e.value),\n          entries => o.literalMap(entries.map((value, index) => ({\n                                                key: literal.entries[index].key,\n                                                value,\n                                                quoted: literal.entries[index].quoted\n                                              }))));\n    }\n  }\n\n  private _getLiteralFactory(\n      key: string, values: o.Expression[], resultMap: (parameters: o.Expression[]) => o.Expression):\n      {literalFactory: o.Expression, literalFactoryArguments: o.Expression[]} {\n    let literalFactory = this.literalFactories.get(key);\n    const literalFactoryArguments = values.filter((e => !e.isConstant()));\n    if (!literalFactory) {\n      const resultExpressions = values.map(\n          (e, index) => e.isConstant() ? this.getConstLiteral(e, true) : o.variable(`a${index}`));\n      const parameters =\n          resultExpressions.filter(isVariable).map(e => new o.FnParam(e.name!, o.DYNAMIC_TYPE));\n      const pureFunctionDeclaration =\n          o.fn(parameters, [new o.ReturnStatement(resultMap(resultExpressions))], o.INFERRED_TYPE);\n      const name = this.freshName();\n      this.statements.push(\n          o.variable(name).set(pureFunctionDeclaration).toDeclStmt(o.INFERRED_TYPE, [\n            o.StmtModifier.Final\n          ]));\n      literalFactory = o.variable(name);\n      this.literalFactories.set(key, literalFactory);\n    }\n    return {literalFactory, literalFactoryArguments};\n  }\n\n  /**\n   * Produce a unique name.\n   *\n   * The name might be unique among different prefixes if any of the prefixes end in\n   * a digit so the prefix should be a constant string (not based on user input) and\n   * must not end in a digit.\n   */\n  uniqueName(prefix: string): string {\n    return `${prefix}${this.nextNameIndex++}`;\n  }\n\n  private definitionsOf(kind: DefinitionKind): Map<any, FixupExpression> {\n    switch (kind) {\n      case DefinitionKind.Component:\n        return this.componentDefinitions;\n      case DefinitionKind.Directive:\n        return this.directiveDefinitions;\n      case DefinitionKind.Injector:\n        return this.injectorDefinitions;\n      case DefinitionKind.Pipe:\n        return this.pipeDefinitions;\n    }\n  }\n\n  public propertyNameOf(kind: DefinitionKind): string {\n    switch (kind) {\n      case DefinitionKind.Component:\n        return 'ɵcmp';\n      case DefinitionKind.Directive:\n        return 'ɵdir';\n      case DefinitionKind.Injector:\n        return 'ɵinj';\n      case DefinitionKind.Pipe:\n        return 'ɵpipe';\n    }\n  }\n\n  private freshName(): string {\n    return this.uniqueName(CONSTANT_PREFIX);\n  }\n\n  private keyOf(expression: o.Expression) {\n    return expression.visitExpression(new KeyVisitor(), KEY_CONTEXT);\n  }\n}\n\nexport interface OutputContext {\n  genFilePath: string;\n  statements: o.Statement[];\n  constantPool: ConstantPool;\n  importExpr(reference: any, typeParams?: o.Type[]|null, useSummaries?: boolean): o.Expression;\n}\n\n/**\n * Visitor used to determine if 2 expressions are equivalent and can be shared in the\n * `ConstantPool`.\n *\n * When the id (string) generated by the visitor is equal, expressions are considered equivalent.\n */\nclass KeyVisitor implements o.ExpressionVisitor {\n  visitLiteralExpr(ast: o.LiteralExpr): string {\n    return `${typeof ast.value === 'string' ? '\"' + ast.value + '\"' : ast.value}`;\n  }\n\n  visitLiteralArrayExpr(ast: o.LiteralArrayExpr, context: object): string {\n    return `[${ast.entries.map(entry => entry.visitExpression(this, context)).join(',')}]`;\n  }\n\n  visitLiteralMapExpr(ast: o.LiteralMapExpr, context: object): string {\n    const mapKey = (entry: o.LiteralMapEntry) => {\n      const quote = entry.quoted ? '\"' : '';\n      return `${quote}${entry.key}${quote}`;\n    };\n    const mapEntry = (entry: o.LiteralMapEntry) =>\n        `${mapKey(entry)}:${entry.value.visitExpression(this, context)}`;\n    return `{${ast.entries.map(mapEntry).join(',')}`;\n  }\n\n  visitExternalExpr(ast: o.ExternalExpr): string {\n    return ast.value.moduleName ? `EX:${ast.value.moduleName}:${ast.value.name}` :\n                                  `EX:${ast.value.runtime.name}`;\n  }\n\n  visitReadVarExpr(node: o.ReadVarExpr) {\n    return `VAR:${node.name}`;\n  }\n\n  visitTypeofExpr(node: o.TypeofExpr, context: any): string {\n    return `TYPEOF:${node.expr.visitExpression(this, context)}`;\n  }\n\n  visitWrappedNodeExpr = invalid;\n  visitWriteVarExpr = invalid;\n  visitWriteKeyExpr = invalid;\n  visitWritePropExpr = invalid;\n  visitInvokeMethodExpr = invalid;\n  visitInvokeFunctionExpr = invalid;\n  visitTaggedTemplateExpr = invalid;\n  visitInstantiateExpr = invalid;\n  visitConditionalExpr = invalid;\n  visitNotExpr = invalid;\n  visitAssertNotNullExpr = invalid;\n  visitCastExpr = invalid;\n  visitFunctionExpr = invalid;\n  visitUnaryOperatorExpr = invalid;\n  visitBinaryOperatorExpr = invalid;\n  visitReadPropExpr = invalid;\n  visitReadKeyExpr = invalid;\n  visitCommaExpr = invalid;\n  visitLocalizedString = invalid;\n}\n\nfunction invalid<T>(this: o.ExpressionVisitor, arg: o.Expression|o.Statement): never {\n  throw new Error(\n      `Invalid state: Visitor ${this.constructor.name} doesn't handle ${arg.constructor.name}`);\n}\n\nfunction isVariable(e: o.Expression): e is o.ReadVarExpr {\n  return e instanceof o.ReadVarExpr;\n}\n\nfunction isLongStringLiteral(expr: o.Expression): boolean {\n  return expr instanceof o.LiteralExpr && typeof expr.value === 'string' &&\n      expr.value.length >= POOL_INCLUSION_LENGTH_THRESHOLD_FOR_STRINGS;\n}\n"]}
Note: See TracBrowser for help on using the repository browser.