Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: trip-planner-front/node_modules/@angular/compiler-cli/src/metadata/evaluator.js@ 188ee53

Last change on this file since 188ee53 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago
initial commit
Property mode set to `100644`
File size: 107.2 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-cli/src/metadata/evaluator", ["require", "exports", "tslib", "typescript", "@angular/compiler-cli/src/metadata/schema"], factory);
15	}
16	})(function (require, exports) {
17	"use strict";
18	Object.defineProperty(exports, "__esModule", { value: true });
19	exports.Evaluator = exports.errorSymbol = exports.sourceInfo = exports.isPrimitive = exports.recordMapEntry = void 0;
20	var tslib_1 = require("tslib");
21	var ts = require("typescript");
22	var schema_1 = require("@angular/compiler-cli/src/metadata/schema");
23	// In TypeScript 2.1 the spread element kind was renamed.
24	var spreadElementSyntaxKind = ts.SyntaxKind.SpreadElement \|\| ts.SyntaxKind.SpreadElementExpression;
25	function isMethodCallOf(callExpression, memberName) {
26	var expression = callExpression.expression;
27	if (expression.kind === ts.SyntaxKind.PropertyAccessExpression) {
28	var propertyAccessExpression = expression;
29	var name = propertyAccessExpression.name;
30	if (name.kind == ts.SyntaxKind.Identifier) {
31	return name.text === memberName;
32	}
33	}
34	return false;
35	}
36	function isCallOf(callExpression, ident) {
37	var expression = callExpression.expression;
38	if (expression.kind === ts.SyntaxKind.Identifier) {
39	var identifier = expression;
40	return identifier.text === ident;
41	}
42	return false;
43	}
44	/* @internal */
45	function recordMapEntry(entry, node, nodeMap, sourceFile) {
46	if (!nodeMap.has(entry)) {
47	nodeMap.set(entry, node);
48	if (node &&
49	(schema_1.isMetadataImportedSymbolReferenceExpression(entry) \|\|
50	schema_1.isMetadataImportDefaultReference(entry)) &&
51	entry.line == null) {
52	var info = sourceInfo(node, sourceFile);
53	if (info.line != null)
54	entry.line = info.line;
55	if (info.character != null)
56	entry.character = info.character;
57	}
58	}
59	return entry;
60	}
61	exports.recordMapEntry = recordMapEntry;
62	/**
63	* ts.forEachChild stops iterating children when the callback return a truthy value.
64	* This method inverts this to implement an `every` style iterator. It will return
65	* true if every call to `cb` returns `true`.
66	*/
67	function everyNodeChild(node, cb) {
68	return !ts.forEachChild(node, function (node) { return !cb(node); });
69	}
70	function isPrimitive(value) {
71	return Object(value) !== value;
72	}
73	exports.isPrimitive = isPrimitive;
74	function isDefined(obj) {
75	return obj !== undefined;
76	}
77	function getSourceFileOfNode(node) {
78	while (node && node.kind != ts.SyntaxKind.SourceFile) {
79	node = node.parent;
80	}
81	return node;
82	}
83	/* @internal */
84	function sourceInfo(node, sourceFile) {
85	if (node) {
86	sourceFile = sourceFile \|\| getSourceFileOfNode(node);
87	if (sourceFile) {
88	return ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
89	}
90	}
91	return {};
92	}
93	exports.sourceInfo = sourceInfo;
94	/* @internal */
95	function errorSymbol(message, node, context, sourceFile) {
96	var result = tslib_1.__assign({ __symbolic: 'error', message: message }, sourceInfo(node, sourceFile));
97	if (context) {
98	result.context = context;
99	}
100	return result;
101	}
102	exports.errorSymbol = errorSymbol;
103	/**
104	* Produce a symbolic representation of an expression folding values into their final value when
105	* possible.
106	*/
107	var Evaluator = /** @class */ (function () {
108	function Evaluator(symbols, nodeMap, options, recordExport) {
109	if (options === void 0) { options = {}; }
110	this.symbols = symbols;
111	this.nodeMap = nodeMap;
112	this.options = options;
113	this.recordExport = recordExport;
114	}
115	Evaluator.prototype.nameOf = function (node) {
116	if (node && node.kind == ts.SyntaxKind.Identifier) {
117	return node.text;
118	}
119	var result = node && this.evaluateNode(node);
120	if (schema_1.isMetadataError(result) \|\| typeof result === 'string') {
121	return result;
122	}
123	else {
124	return errorSymbol('Name expected', node, { received: (node && node.getText()) \|\| '<missing>' });
125	}
126	};
127	/**
128	* Returns true if the expression represented by `node` can be folded into a literal expression.
129	*
130	* For example, a literal is always foldable. This means that literal expressions such as `1.2`
131	* `"Some value"` `true` `false` are foldable.
132	*
133	* - An object literal is foldable if all the properties in the literal are foldable.
134	* - An array literal is foldable if all the elements are foldable.
135	* - A call is foldable if it is a call to a Array.prototype.concat or a call to CONST_EXPR.
136	* - A property access is foldable if the object is foldable.
137	* - A array index is foldable if index expression is foldable and the array is foldable.
138	* - Binary operator expressions are foldable if the left and right expressions are foldable and
139	* it is one of '+', '-', '*', '/', '%', '\|\|', and '&&'.
140	* - An identifier is foldable if a value can be found for its symbol in the evaluator symbol
141	* table.
142	*/
143	Evaluator.prototype.isFoldable = function (node) {
144	return this.isFoldableWorker(node, new Map());
145	};
146	Evaluator.prototype.isFoldableWorker = function (node, folding) {
147	var _this = this;
148	if (node) {
149	switch (node.kind) {
150	case ts.SyntaxKind.ObjectLiteralExpression:
151	return everyNodeChild(node, function (child) {
152	if (child.kind === ts.SyntaxKind.PropertyAssignment) {
153	var propertyAssignment = child;
154	return _this.isFoldableWorker(propertyAssignment.initializer, folding);
155	}
156	return false;
157	});
158	case ts.SyntaxKind.ArrayLiteralExpression:
159	return everyNodeChild(node, function (child) { return _this.isFoldableWorker(child, folding); });
160	case ts.SyntaxKind.CallExpression:
161	var callExpression = node;
162	// We can fold a <array>.concat(<v>).
163	if (isMethodCallOf(callExpression, 'concat') &&
164	arrayOrEmpty(callExpression.arguments).length === 1) {
165	var arrayNode = callExpression.expression.expression;
166	if (this.isFoldableWorker(arrayNode, folding) &&
167	this.isFoldableWorker(callExpression.arguments[0], folding)) {
168	// It needs to be an array.
169	var arrayValue = this.evaluateNode(arrayNode);
170	if (arrayValue && Array.isArray(arrayValue)) {
171	return true;
172	}
173	}
174	}
175	// We can fold a call to CONST_EXPR
176	if (isCallOf(callExpression, 'CONST_EXPR') &&
177	arrayOrEmpty(callExpression.arguments).length === 1)
178	return this.isFoldableWorker(callExpression.arguments[0], folding);
179	return false;
180	case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
181	case ts.SyntaxKind.StringLiteral:
182	case ts.SyntaxKind.NumericLiteral:
183	case ts.SyntaxKind.NullKeyword:
184	case ts.SyntaxKind.TrueKeyword:
185	case ts.SyntaxKind.FalseKeyword:
186	case ts.SyntaxKind.TemplateHead:
187	case ts.SyntaxKind.TemplateMiddle:
188	case ts.SyntaxKind.TemplateTail:
189	return true;
190	case ts.SyntaxKind.ParenthesizedExpression:
191	var parenthesizedExpression = node;
192	return this.isFoldableWorker(parenthesizedExpression.expression, folding);
193	case ts.SyntaxKind.BinaryExpression:
194	var binaryExpression = node;
195	switch (binaryExpression.operatorToken.kind) {
196	case ts.SyntaxKind.PlusToken:
197	case ts.SyntaxKind.MinusToken:
198	case ts.SyntaxKind.AsteriskToken:
199	case ts.SyntaxKind.SlashToken:
200	case ts.SyntaxKind.PercentToken:
201	case ts.SyntaxKind.AmpersandAmpersandToken:
202	case ts.SyntaxKind.BarBarToken:
203	return this.isFoldableWorker(binaryExpression.left, folding) &&
204	this.isFoldableWorker(binaryExpression.right, folding);
205	default:
206	return false;
207	}
208	case ts.SyntaxKind.PropertyAccessExpression:
209	var propertyAccessExpression = node;
210	return this.isFoldableWorker(propertyAccessExpression.expression, folding);
211	case ts.SyntaxKind.ElementAccessExpression:
212	var elementAccessExpression = node;
213	return this.isFoldableWorker(elementAccessExpression.expression, folding) &&
214	this.isFoldableWorker(elementAccessExpression.argumentExpression, folding);
215	case ts.SyntaxKind.Identifier:
216	var identifier = node;
217	var reference = this.symbols.resolve(identifier.text);
218	if (reference !== undefined && isPrimitive(reference)) {
219	return true;
220	}
221	break;
222	case ts.SyntaxKind.TemplateExpression:
223	var templateExpression = node;
224	return templateExpression.templateSpans.every(function (span) { return _this.isFoldableWorker(span.expression, folding); });
225	}
226	}
227	return false;
228	};
229	/**
230	* Produce a JSON serialiable object representing `node`. The foldable values in the expression
231	* tree are folded. For example, a node representing `1 + 2` is folded into `3`.
232	*/
233	Evaluator.prototype.evaluateNode = function (node, preferReference) {
234	var _this = this;
235	var t = this;
236	var error;
237	function recordEntry(entry, node) {
238	if (t.options.substituteExpression) {
239	var newEntry = t.options.substituteExpression(entry, node);
240	if (t.recordExport && newEntry != entry && schema_1.isMetadataGlobalReferenceExpression(newEntry)) {
241	t.recordExport(newEntry.name, entry);
242	}
243	entry = newEntry;
244	}
245	return recordMapEntry(entry, node, t.nodeMap);
246	}
247	function isFoldableError(value) {
248	return !t.options.verboseInvalidExpression && schema_1.isMetadataError(value);
249	}
250	var resolveName = function (name, preferReference) {
251	var reference = _this.symbols.resolve(name, preferReference);
252	if (reference === undefined) {
253	// Encode as a global reference. StaticReflector will check the reference.
254	return recordEntry({ __symbolic: 'reference', name: name }, node);
255	}
256	if (reference && schema_1.isMetadataSymbolicReferenceExpression(reference)) {
257	return recordEntry(tslib_1.__assign({}, reference), node);
258	}
259	return reference;
260	};
261	switch (node.kind) {
262	case ts.SyntaxKind.ObjectLiteralExpression:
263	var obj_1 = {};
264	var quoted_1 = [];
265	ts.forEachChild(node, function (child) {
266	switch (child.kind) {
267	case ts.SyntaxKind.ShorthandPropertyAssignment:
268	case ts.SyntaxKind.PropertyAssignment:
269	var assignment = child;
270	if (assignment.name.kind == ts.SyntaxKind.StringLiteral) {
271	var name_1 = assignment.name.text;
272	quoted_1.push(name_1);
273	}
274	var propertyName = _this.nameOf(assignment.name);
275	if (isFoldableError(propertyName)) {
276	error = propertyName;
277	return true;
278	}
279	var propertyValue = isPropertyAssignment(assignment) ?
280	_this.evaluateNode(assignment.initializer, /* preferReference */ true) :
281	resolveName(propertyName, /* preferReference */ true);
282	if (isFoldableError(propertyValue)) {
283	error = propertyValue;
284	return true; // Stop the forEachChild.
285	}
286	else {
287	obj_1[propertyName] = isPropertyAssignment(assignment) ?
288	recordEntry(propertyValue, assignment.initializer) :
289	propertyValue;
290	}
291	}
292	});
293	if (error)
294	return error;
295	if (this.options.quotedNames && quoted_1.length) {
296	obj_1['$quoted$'] = quoted_1;
297	}
298	return recordEntry(obj_1, node);
299	case ts.SyntaxKind.ArrayLiteralExpression:
300	var arr_1 = [];
301	ts.forEachChild(node, function (child) {
302	var e_1, _a;
303	var value = _this.evaluateNode(child, /* preferReference */ true);
304	// Check for error
305	if (isFoldableError(value)) {
306	error = value;
307	return true; // Stop the forEachChild.
308	}
309	// Handle spread expressions
310	if (schema_1.isMetadataSymbolicSpreadExpression(value)) {
311	if (Array.isArray(value.expression)) {
312	try {
313	for (var _b = tslib_1.__values(value.expression), _c = _b.next(); !_c.done; _c = _b.next()) {
314	var spreadValue = _c.value;
315	arr_1.push(spreadValue);
316	}
317	}
318	catch (e_1_1) { e_1 = { error: e_1_1 }; }
319	finally {
320	try {
321	if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
322	}
323	finally { if (e_1) throw e_1.error; }
324	}
325	return;
326	}
327	}
328	arr_1.push(value);
329	});
330	if (error)
331	return error;
332	return recordEntry(arr_1, node);
333	case spreadElementSyntaxKind:
334	var spreadExpression = this.evaluateNode(node.expression);
335	return recordEntry({ __symbolic: 'spread', expression: spreadExpression }, node);
336	case ts.SyntaxKind.CallExpression:
337	var callExpression = node;
338	if (isCallOf(callExpression, 'forwardRef') &&
339	arrayOrEmpty(callExpression.arguments).length === 1) {
340	var firstArgument = callExpression.arguments[0];
341	if (firstArgument.kind == ts.SyntaxKind.ArrowFunction) {
342	var arrowFunction = firstArgument;
343	return recordEntry(this.evaluateNode(arrowFunction.body), node);
344	}
345	}
346	var args = arrayOrEmpty(callExpression.arguments).map(function (arg) { return _this.evaluateNode(arg); });
347	if (this.isFoldable(callExpression)) {
348	if (isMethodCallOf(callExpression, 'concat')) {
349	var arrayValue = this.evaluateNode(callExpression.expression.expression);
350	if (isFoldableError(arrayValue))
351	return arrayValue;
352	return arrayValue.concat(args[0]);
353	}
354	}
355	// Always fold a CONST_EXPR even if the argument is not foldable.
356	if (isCallOf(callExpression, 'CONST_EXPR') &&
357	arrayOrEmpty(callExpression.arguments).length === 1) {
358	return recordEntry(args[0], node);
359	}
360	var expression = this.evaluateNode(callExpression.expression);
361	if (isFoldableError(expression)) {
362	return recordEntry(expression, node);
363	}
364	var result = { __symbolic: 'call', expression: expression };
365	if (args && args.length) {
366	result.arguments = args;
367	}
368	return recordEntry(result, node);
369	case ts.SyntaxKind.NewExpression:
370	var newExpression = node;
371	var newArgs = arrayOrEmpty(newExpression.arguments).map(function (arg) { return _this.evaluateNode(arg); });
372	var newTarget = this.evaluateNode(newExpression.expression);
373	if (schema_1.isMetadataError(newTarget)) {
374	return recordEntry(newTarget, node);
375	}
376	var call = { __symbolic: 'new', expression: newTarget };
377	if (newArgs.length) {
378	call.arguments = newArgs;
379	}
380	return recordEntry(call, node);
381	case ts.SyntaxKind.PropertyAccessExpression: {
382	var propertyAccessExpression = node;
383	var expression_1 = this.evaluateNode(propertyAccessExpression.expression);
384	if (isFoldableError(expression_1)) {
385	return recordEntry(expression_1, node);
386	}
387	var member = this.nameOf(propertyAccessExpression.name);
388	if (isFoldableError(member)) {
389	return recordEntry(member, node);
390	}
391	if (expression_1 && this.isFoldable(propertyAccessExpression.expression))
392	return expression_1[member];
393	if (schema_1.isMetadataModuleReferenceExpression(expression_1)) {
394	// A select into a module reference and be converted into a reference to the symbol
395	// in the module
396	return recordEntry({ __symbolic: 'reference', module: expression_1.module, name: member }, node);
397	}
398	return recordEntry({ __symbolic: 'select', expression: expression_1, member: member }, node);
399	}
400	case ts.SyntaxKind.ElementAccessExpression: {
401	var elementAccessExpression = node;
402	var expression_2 = this.evaluateNode(elementAccessExpression.expression);
403	if (isFoldableError(expression_2)) {
404	return recordEntry(expression_2, node);
405	}
406	if (!elementAccessExpression.argumentExpression) {
407	return recordEntry(errorSymbol('Expression form not supported', node), node);
408	}
409	var index = this.evaluateNode(elementAccessExpression.argumentExpression);
410	if (isFoldableError(expression_2)) {
411	return recordEntry(expression_2, node);
412	}
413	if (this.isFoldable(elementAccessExpression.expression) &&
414	this.isFoldable(elementAccessExpression.argumentExpression))
415	return expression_2[index];
416	return recordEntry({ __symbolic: 'index', expression: expression_2, index: index }, node);
417	}
418	case ts.SyntaxKind.Identifier:
419	var identifier = node;
420	var name = identifier.text;
421	return resolveName(name, preferReference);
422	case ts.SyntaxKind.TypeReference:
423	var typeReferenceNode = node;
424	var typeNameNode_1 = typeReferenceNode.typeName;
425	var getReference = function (node) {
426	if (typeNameNode_1.kind === ts.SyntaxKind.QualifiedName) {
427	var qualifiedName = node;
428	var left_1 = _this.evaluateNode(qualifiedName.left);
429	if (schema_1.isMetadataModuleReferenceExpression(left_1)) {
430	return recordEntry({
431	__symbolic: 'reference',
432	module: left_1.module,
433	name: qualifiedName.right.text
434	}, node);
435	}
436	// Record a type reference to a declared type as a select.
437	return { __symbolic: 'select', expression: left_1, member: qualifiedName.right.text };
438	}
439	else {
440	var identifier_1 = typeNameNode_1;
441	var symbol = _this.symbols.resolve(identifier_1.text);
442	if (isFoldableError(symbol) \|\| schema_1.isMetadataSymbolicReferenceExpression(symbol)) {
443	return recordEntry(symbol, node);
444	}
445	return recordEntry(errorSymbol('Could not resolve type', node, { typeName: identifier_1.text }), node);
446	}
447	};
448	var typeReference = getReference(typeNameNode_1);
449	if (isFoldableError(typeReference)) {
450	return recordEntry(typeReference, node);
451	}
452	if (!schema_1.isMetadataModuleReferenceExpression(typeReference) &&
453	typeReferenceNode.typeArguments && typeReferenceNode.typeArguments.length) {
454	var args_1 = typeReferenceNode.typeArguments.map(function (element) { return _this.evaluateNode(element); });
455	// TODO: Remove typecast when upgraded to 2.0 as it will be correctly inferred.
456	// Some versions of 1.9 do not infer this correctly.
457	typeReference.arguments = args_1;
458	}
459	return recordEntry(typeReference, node);
460	case ts.SyntaxKind.UnionType:
461	var unionType = node;
462	// Remove null and undefined from the list of unions.
463	var references = unionType.types
464	.filter(function (n) { return n.kind !== ts.SyntaxKind.UndefinedKeyword &&
465	!(ts.isLiteralTypeNode(n) && n.literal.kind === ts.SyntaxKind.NullKeyword); })
466	.map(function (n) { return _this.evaluateNode(n); });
467	// The remmaining reference must be the same. If two have type arguments consider them
468	// different even if the type arguments are the same.
469	var candidate = null;
470	for (var i = 0; i < references.length; i++) {
471	var reference = references[i];
472	if (schema_1.isMetadataSymbolicReferenceExpression(reference)) {
473	if (candidate) {
474	if (reference.name == candidate.name &&
475	reference.module == candidate.module && !reference.arguments) {
476	candidate = reference;
477	}
478	}
479	else {
480	candidate = reference;
481	}
482	}
483	else {
484	return reference;
485	}
486	}
487	if (candidate)
488	return candidate;
489	break;
490	case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
491	case ts.SyntaxKind.StringLiteral:
492	case ts.SyntaxKind.TemplateHead:
493	case ts.SyntaxKind.TemplateTail:
494	case ts.SyntaxKind.TemplateMiddle:
495	return node.text;
496	case ts.SyntaxKind.NumericLiteral:
497	return parseFloat(node.text);
498	case ts.SyntaxKind.AnyKeyword:
499	return recordEntry({ __symbolic: 'reference', name: 'any' }, node);
500	case ts.SyntaxKind.StringKeyword:
501	return recordEntry({ __symbolic: 'reference', name: 'string' }, node);
502	case ts.SyntaxKind.NumberKeyword:
503	return recordEntry({ __symbolic: 'reference', name: 'number' }, node);
504	case ts.SyntaxKind.BooleanKeyword:
505	return recordEntry({ __symbolic: 'reference', name: 'boolean' }, node);
506	case ts.SyntaxKind.ArrayType:
507	var arrayTypeNode = node;
508	return recordEntry({
509	__symbolic: 'reference',
510	name: 'Array',
511	arguments: [this.evaluateNode(arrayTypeNode.elementType)]
512	}, node);
513	case ts.SyntaxKind.NullKeyword:
514	return null;
515	case ts.SyntaxKind.TrueKeyword:
516	return true;
517	case ts.SyntaxKind.FalseKeyword:
518	return false;
519	case ts.SyntaxKind.ParenthesizedExpression:
520	var parenthesizedExpression = node;
521	return this.evaluateNode(parenthesizedExpression.expression);
522	case ts.SyntaxKind.TypeAssertionExpression:
523	var typeAssertion = node;
524	return this.evaluateNode(typeAssertion.expression);
525	case ts.SyntaxKind.PrefixUnaryExpression:
526	var prefixUnaryExpression = node;
527	var operand = this.evaluateNode(prefixUnaryExpression.operand);
528	if (isDefined(operand) && isPrimitive(operand)) {
529	switch (prefixUnaryExpression.operator) {
530	case ts.SyntaxKind.PlusToken:
531	return +operand;
532	case ts.SyntaxKind.MinusToken:
533	return -operand;
534	case ts.SyntaxKind.TildeToken:
535	return ~operand;
536	case ts.SyntaxKind.ExclamationToken:
537	return !operand;
538	}
539	}
540	var operatorText = void 0;
541	switch (prefixUnaryExpression.operator) {
542	case ts.SyntaxKind.PlusToken:
543	operatorText = '+';
544	break;
545	case ts.SyntaxKind.MinusToken:
546	operatorText = '-';
547	break;
548	case ts.SyntaxKind.TildeToken:
549	operatorText = '~';
550	break;
551	case ts.SyntaxKind.ExclamationToken:
552	operatorText = '!';
553	break;
554	default:
555	return undefined;
556	}
557	return recordEntry({ __symbolic: 'pre', operator: operatorText, operand: operand }, node);
558	case ts.SyntaxKind.BinaryExpression:
559	var binaryExpression = node;
560	var left = this.evaluateNode(binaryExpression.left);
561	var right = this.evaluateNode(binaryExpression.right);
562	if (isDefined(left) && isDefined(right)) {
563	if (isPrimitive(left) && isPrimitive(right))
564	switch (binaryExpression.operatorToken.kind) {
565	case ts.SyntaxKind.BarBarToken:
566	return left \|\| right;
567	case ts.SyntaxKind.AmpersandAmpersandToken:
568	return left && right;
569	case ts.SyntaxKind.AmpersandToken:
570	return left & right;
571	case ts.SyntaxKind.BarToken:
572	return left \| right;
573	case ts.SyntaxKind.CaretToken:
574	return left ^ right;
575	case ts.SyntaxKind.EqualsEqualsToken:
576	return left == right;
577	case ts.SyntaxKind.ExclamationEqualsToken:
578	return left != right;
579	case ts.SyntaxKind.EqualsEqualsEqualsToken:
580	return left === right;
581	case ts.SyntaxKind.ExclamationEqualsEqualsToken:
582	return left !== right;
583	case ts.SyntaxKind.LessThanToken:
584	return left < right;
585	case ts.SyntaxKind.GreaterThanToken:
586	return left > right;
587	case ts.SyntaxKind.LessThanEqualsToken:
588	return left <= right;
589	case ts.SyntaxKind.GreaterThanEqualsToken:
590	return left >= right;
591	case ts.SyntaxKind.LessThanLessThanToken:
592	return left << right;
593	case ts.SyntaxKind.GreaterThanGreaterThanToken:
594	return left >> right;
595	case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
596	return left >>> right;
597	case ts.SyntaxKind.PlusToken:
598	return left + right;
599	case ts.SyntaxKind.MinusToken:
600	return left - right;
601	case ts.SyntaxKind.AsteriskToken:
602	return left * right;
603	case ts.SyntaxKind.SlashToken:
604	return left / right;
605	case ts.SyntaxKind.PercentToken:
606	return left % right;
607	}
608	return recordEntry({
609	__symbolic: 'binop',
610	operator: binaryExpression.operatorToken.getText(),
611	left: left,
612	right: right
613	}, node);
614	}
615	break;
616	case ts.SyntaxKind.ConditionalExpression:
617	var conditionalExpression = node;
618	var condition = this.evaluateNode(conditionalExpression.condition);
619	var thenExpression = this.evaluateNode(conditionalExpression.whenTrue);
620	var elseExpression = this.evaluateNode(conditionalExpression.whenFalse);
621	if (isPrimitive(condition)) {
622	return condition ? thenExpression : elseExpression;
623	}
624	return recordEntry({ __symbolic: 'if', condition: condition, thenExpression: thenExpression, elseExpression: elseExpression }, node);
625	case ts.SyntaxKind.FunctionExpression:
626	case ts.SyntaxKind.ArrowFunction:
627	return recordEntry(errorSymbol('Lambda not supported', node), node);
628	case ts.SyntaxKind.TaggedTemplateExpression:
629	return recordEntry(errorSymbol('Tagged template expressions are not supported in metadata', node), node);
630	case ts.SyntaxKind.TemplateExpression:
631	var templateExpression = node;
632	if (this.isFoldable(node)) {
633	return templateExpression.templateSpans.reduce(function (previous, current) { return previous + _this.evaluateNode(current.expression) +
634	_this.evaluateNode(current.literal); }, this.evaluateNode(templateExpression.head));
635	}
636	else {
637	return templateExpression.templateSpans.reduce(function (previous, current) {
638	var expr = _this.evaluateNode(current.expression);
639	var literal = _this.evaluateNode(current.literal);
640	if (isFoldableError(expr))
641	return expr;
642	if (isFoldableError(literal))
643	return literal;
644	if (typeof previous === 'string' && typeof expr === 'string' &&
645	typeof literal === 'string') {
646	return previous + expr + literal;
647	}
648	var result = expr;
649	if (previous !== '') {
650	result = { __symbolic: 'binop', operator: '+', left: previous, right: expr };
651	}
652	if (literal != '') {
653	result = { __symbolic: 'binop', operator: '+', left: result, right: literal };
654	}
655	return result;
656	}, this.evaluateNode(templateExpression.head));
657	}
658	case ts.SyntaxKind.AsExpression:
659	var asExpression = node;
660	return this.evaluateNode(asExpression.expression);
661	case ts.SyntaxKind.ClassExpression:
662	return { __symbolic: 'class' };
663	}
664	return recordEntry(errorSymbol('Expression form not supported', node), node);
665	};
666	return Evaluator;
667	}());
668	exports.Evaluator = Evaluator;
669	function isPropertyAssignment(node) {
670	return node.kind == ts.SyntaxKind.PropertyAssignment;
671	}
672	var empty = ts.createNodeArray();
673	function arrayOrEmpty(v) {
674	return v \|\| empty;
675	}
676	});
677	//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"evaluator.js","sourceRoot":"","sources":["../../../../../../../packages/compiler-cli/src/metadata/evaluator.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 ts from 'typescript';\n\nimport {CollectorOptions} from './collector';\nimport {ClassMetadata, FunctionMetadata, InterfaceMetadata, isMetadataError, isMetadataGlobalReferenceExpression, isMetadataImportDefaultReference, isMetadataImportedSymbolReferenceExpression, isMetadataModuleReferenceExpression, isMetadataSymbolicReferenceExpression, isMetadataSymbolicSpreadExpression, MetadataEntry, MetadataError, MetadataImportedSymbolReferenceExpression, MetadataSourceLocationInfo, MetadataSymbolicCallExpression, MetadataValue} from './schema';\nimport {Symbols} from './symbols';\n\n\n\n// In TypeScript 2.1 the spread element kind was renamed.\nconst spreadElementSyntaxKind: ts.SyntaxKind =\n    (ts.SyntaxKind as any).SpreadElement || (ts.SyntaxKind as any).SpreadElementExpression;\n\nfunction isMethodCallOf(callExpression: ts.CallExpression, memberName: string): boolean {\n  const expression = callExpression.expression;\n  if (expression.kind === ts.SyntaxKind.PropertyAccessExpression) {\n    const propertyAccessExpression = <ts.PropertyAccessExpression>expression;\n    const name = propertyAccessExpression.name;\n    if (name.kind == ts.SyntaxKind.Identifier) {\n      return name.text === memberName;\n    }\n  }\n  return false;\n}\n\nfunction isCallOf(callExpression: ts.CallExpression, ident: string): boolean {\n  const expression = callExpression.expression;\n  if (expression.kind === ts.SyntaxKind.Identifier) {\n    const identifier = <ts.Identifier>expression;\n    return identifier.text === ident;\n  }\n  return false;\n}\n\n/* @internal */\nexport function recordMapEntry<T extends MetadataEntry>(\n    entry: T, node: ts.Node,\n    nodeMap: Map<MetadataValue|ClassMetadata|InterfaceMetadata|FunctionMetadata, ts.Node>,\n    sourceFile?: ts.SourceFile) {\n  if (!nodeMap.has(entry)) {\n    nodeMap.set(entry, node);\n    if (node &&\n        (isMetadataImportedSymbolReferenceExpression(entry) ||\n         isMetadataImportDefaultReference(entry)) &&\n        entry.line == null) {\n      const info = sourceInfo(node, sourceFile);\n      if (info.line != null) entry.line = info.line;\n      if (info.character != null) entry.character = info.character;\n    }\n  }\n  return entry;\n}\n\n/**\n * ts.forEachChild stops iterating children when the callback return a truthy value.\n * This method inverts this to implement an `every` style iterator. It will return\n * true if every call to `cb` returns `true`.\n */\nfunction everyNodeChild(node: ts.Node, cb: (node: ts.Node) => boolean) {\n  return !ts.forEachChild(node, node => !cb(node));\n}\n\nexport function isPrimitive(value: any): boolean {\n  return Object(value) !== value;\n}\n\nfunction isDefined(obj: any): boolean {\n  return obj !== undefined;\n}\n\n// import {propertyName as name} from 'place'\n// import {name} from 'place'\nexport interface ImportSpecifierMetadata {\n  name: string;\n  propertyName?: string;\n}\nexport interface ImportMetadata {\n  defaultName?: string;                      // import d from 'place'\n  namespace?: string;                        // import * as d from 'place'\n  namedImports?: ImportSpecifierMetadata[];  // import {a} from 'place'\n  from: string;                              // from 'place'\n}\n\n\nfunction getSourceFileOfNode(node: ts.Node|undefined): ts.SourceFile {\n  while (node && node.kind != ts.SyntaxKind.SourceFile) {\n    node = node.parent;\n  }\n  return <ts.SourceFile>node;\n}\n\n/* @internal */\nexport function sourceInfo(\n    node: ts.Node|undefined, sourceFile: ts.SourceFile|undefined): MetadataSourceLocationInfo {\n  if (node) {\n    sourceFile = sourceFile || getSourceFileOfNode(node);\n    if (sourceFile) {\n      return ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));\n    }\n  }\n  return {};\n}\n\n/* @internal */\nexport function errorSymbol(\n    message: string, node?: ts.Node, context?: {[name: string]: string},\n    sourceFile?: ts.SourceFile): MetadataError {\n  const result: MetadataError = {__symbolic: 'error', message, ...sourceInfo(node, sourceFile)};\n  if (context) {\n    result.context = context;\n  }\n  return result;\n}\n\n/**\n * Produce a symbolic representation of an expression folding values into their final value when\n * possible.\n */\nexport class Evaluator {\n  constructor(\n      private symbols: Symbols, private nodeMap: Map<MetadataEntry, ts.Node>,\n      private options: CollectorOptions = {},\n      private recordExport?: (name: string, value: MetadataValue) => void) {}\n\n  nameOf(node: ts.Node|undefined): string|MetadataError {\n    if (node && node.kind == ts.SyntaxKind.Identifier) {\n      return (<ts.Identifier>node).text;\n    }\n    const result = node && this.evaluateNode(node);\n    if (isMetadataError(result) || typeof result === 'string') {\n      return result;\n    } else {\n      return errorSymbol(\n          'Name expected', node, {received: (node && node.getText()) || '<missing>'});\n    }\n  }\n\n  /**\n   * Returns true if the expression represented by `node` can be folded into a literal expression.\n   *\n   * For example, a literal is always foldable. This means that literal expressions such as `1.2`\n   * `\"Some value\"` `true` `false` are foldable.\n   *\n   * - An object literal is foldable if all the properties in the literal are foldable.\n   * - An array literal is foldable if all the elements are foldable.\n   * - A call is foldable if it is a call to a Array.prototype.concat or a call to CONST_EXPR.\n   * - A property access is foldable if the object is foldable.\n   * - A array index is foldable if index expression is foldable and the array is foldable.\n   * - Binary operator expressions are foldable if the left and right expressions are foldable and\n   *   it is one of '+', '-', '*', '/', '%', '||', and '&&'.\n   * - An identifier is foldable if a value can be found for its symbol in the evaluator symbol\n   *   table.\n   */\n  public isFoldable(node: ts.Node): boolean {\n    return this.isFoldableWorker(node, new Map<ts.Node, boolean>());\n  }\n\n  private isFoldableWorker(node: ts.Node|undefined, folding: Map<ts.Node, boolean>): boolean {\n    if (node) {\n      switch (node.kind) {\n        case ts.SyntaxKind.ObjectLiteralExpression:\n          return everyNodeChild(node, child => {\n            if (child.kind === ts.SyntaxKind.PropertyAssignment) {\n              const propertyAssignment = <ts.PropertyAssignment>child;\n              return this.isFoldableWorker(propertyAssignment.initializer, folding);\n            }\n            return false;\n          });\n        case ts.SyntaxKind.ArrayLiteralExpression:\n          return everyNodeChild(node, child => this.isFoldableWorker(child, folding));\n        case ts.SyntaxKind.CallExpression:\n          const callExpression = <ts.CallExpression>node;\n          // We can fold a <array>.concat(<v>).\n          if (isMethodCallOf(callExpression, 'concat') &&\n              arrayOrEmpty(callExpression.arguments).length === 1) {\n            const arrayNode = (<ts.PropertyAccessExpression>callExpression.expression).expression;\n            if (this.isFoldableWorker(arrayNode, folding) &&\n                this.isFoldableWorker(callExpression.arguments[0], folding)) {\n              // It needs to be an array.\n              const arrayValue = this.evaluateNode(arrayNode);\n              if (arrayValue && Array.isArray(arrayValue)) {\n                return true;\n              }\n            }\n          }\n\n          // We can fold a call to CONST_EXPR\n          if (isCallOf(callExpression, 'CONST_EXPR') &&\n              arrayOrEmpty(callExpression.arguments).length === 1)\n            return this.isFoldableWorker(callExpression.arguments[0], folding);\n          return false;\n        case ts.SyntaxKind.NoSubstitutionTemplateLiteral:\n        case ts.SyntaxKind.StringLiteral:\n        case ts.SyntaxKind.NumericLiteral:\n        case ts.SyntaxKind.NullKeyword:\n        case ts.SyntaxKind.TrueKeyword:\n        case ts.SyntaxKind.FalseKeyword:\n        case ts.SyntaxKind.TemplateHead:\n        case ts.SyntaxKind.TemplateMiddle:\n        case ts.SyntaxKind.TemplateTail:\n          return true;\n        case ts.SyntaxKind.ParenthesizedExpression:\n          const parenthesizedExpression = <ts.ParenthesizedExpression>node;\n          return this.isFoldableWorker(parenthesizedExpression.expression, folding);\n        case ts.SyntaxKind.BinaryExpression:\n          const binaryExpression = <ts.BinaryExpression>node;\n          switch (binaryExpression.operatorToken.kind) {\n            case ts.SyntaxKind.PlusToken:\n            case ts.SyntaxKind.MinusToken:\n            case ts.SyntaxKind.AsteriskToken:\n            case ts.SyntaxKind.SlashToken:\n            case ts.SyntaxKind.PercentToken:\n            case ts.SyntaxKind.AmpersandAmpersandToken:\n            case ts.SyntaxKind.BarBarToken:\n              return this.isFoldableWorker(binaryExpression.left, folding) &&\n                  this.isFoldableWorker(binaryExpression.right, folding);\n            default:\n              return false;\n          }\n        case ts.SyntaxKind.PropertyAccessExpression:\n          const propertyAccessExpression = <ts.PropertyAccessExpression>node;\n          return this.isFoldableWorker(propertyAccessExpression.expression, folding);\n        case ts.SyntaxKind.ElementAccessExpression:\n          const elementAccessExpression = <ts.ElementAccessExpression>node;\n          return this.isFoldableWorker(elementAccessExpression.expression, folding) &&\n              this.isFoldableWorker(elementAccessExpression.argumentExpression, folding);\n        case ts.SyntaxKind.Identifier:\n          let identifier = <ts.Identifier>node;\n          let reference = this.symbols.resolve(identifier.text);\n          if (reference !== undefined && isPrimitive(reference)) {\n            return true;\n          }\n          break;\n        case ts.SyntaxKind.TemplateExpression:\n          const templateExpression = <ts.TemplateExpression>node;\n          return templateExpression.templateSpans.every(\n              span => this.isFoldableWorker(span.expression, folding));\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Produce a JSON serialiable object representing `node`. The foldable values in the expression\n   * tree are folded. For example, a node representing `1 + 2` is folded into `3`.\n   */\n  public evaluateNode(node: ts.Node, preferReference?: boolean): MetadataValue {\n    const t = this;\n    let error: MetadataError|undefined;\n\n    function recordEntry(entry: MetadataValue, node: ts.Node): MetadataValue {\n      if (t.options.substituteExpression) {\n        const newEntry = t.options.substituteExpression(entry, node);\n        if (t.recordExport && newEntry != entry && isMetadataGlobalReferenceExpression(newEntry)) {\n          t.recordExport(newEntry.name, entry);\n        }\n        entry = newEntry;\n      }\n      return recordMapEntry(entry, node, t.nodeMap);\n    }\n\n    function isFoldableError(value: any): value is MetadataError {\n      return !t.options.verboseInvalidExpression && isMetadataError(value);\n    }\n\n    const resolveName = (name: string, preferReference?: boolean): MetadataValue => {\n      const reference = this.symbols.resolve(name, preferReference);\n      if (reference === undefined) {\n        // Encode as a global reference. StaticReflector will check the reference.\n        return recordEntry({__symbolic: 'reference', name}, node);\n      }\n      if (reference && isMetadataSymbolicReferenceExpression(reference)) {\n        return recordEntry({...reference}, node);\n      }\n      return reference;\n    };\n\n    switch (node.kind) {\n      case ts.SyntaxKind.ObjectLiteralExpression:\n        let obj: {[name: string]: any} = {};\n        let quoted: string[] = [];\n        ts.forEachChild(node, child => {\n          switch (child.kind) {\n            case ts.SyntaxKind.ShorthandPropertyAssignment:\n            case ts.SyntaxKind.PropertyAssignment:\n              const assignment = <ts.PropertyAssignment|ts.ShorthandPropertyAssignment>child;\n              if (assignment.name.kind == ts.SyntaxKind.StringLiteral) {\n                const name = (assignment.name as ts.StringLiteral).text;\n                quoted.push(name);\n              }\n              const propertyName = this.nameOf(assignment.name);\n              if (isFoldableError(propertyName)) {\n                error = propertyName;\n                return true;\n              }\n              const propertyValue = isPropertyAssignment(assignment) ?\n                  this.evaluateNode(assignment.initializer, /* preferReference */ true) :\n                  resolveName(propertyName, /* preferReference */ true);\n              if (isFoldableError(propertyValue)) {\n                error = propertyValue;\n                return true;  // Stop the forEachChild.\n              } else {\n                obj[propertyName] = isPropertyAssignment(assignment) ?\n                    recordEntry(propertyValue, assignment.initializer) :\n                    propertyValue;\n              }\n          }\n        });\n        if (error) return error;\n        if (this.options.quotedNames && quoted.length) {\n          obj['$quoted$'] = quoted;\n        }\n        return recordEntry(obj, node);\n      case ts.SyntaxKind.ArrayLiteralExpression:\n        let arr: MetadataValue[] = [];\n        ts.forEachChild(node, child => {\n          const value = this.evaluateNode(child, /* preferReference */ true);\n\n          // Check for error\n          if (isFoldableError(value)) {\n            error = value;\n            return true;  // Stop the forEachChild.\n          }\n\n          // Handle spread expressions\n          if (isMetadataSymbolicSpreadExpression(value)) {\n            if (Array.isArray(value.expression)) {\n              for (const spreadValue of value.expression) {\n                arr.push(spreadValue);\n              }\n              return;\n            }\n          }\n\n          arr.push(value);\n        });\n        if (error) return error;\n        return recordEntry(arr, node);\n      case spreadElementSyntaxKind:\n        let spreadExpression = this.evaluateNode((node as any).expression);\n        return recordEntry({__symbolic: 'spread', expression: spreadExpression}, node);\n      case ts.SyntaxKind.CallExpression:\n        const callExpression = <ts.CallExpression>node;\n        if (isCallOf(callExpression, 'forwardRef') &&\n            arrayOrEmpty(callExpression.arguments).length === 1) {\n          const firstArgument = callExpression.arguments[0];\n          if (firstArgument.kind == ts.SyntaxKind.ArrowFunction) {\n            const arrowFunction = <ts.ArrowFunction>firstArgument;\n            return recordEntry(this.evaluateNode(arrowFunction.body), node);\n          }\n        }\n        const args = arrayOrEmpty(callExpression.arguments).map(arg => this.evaluateNode(arg));\n        if (this.isFoldable(callExpression)) {\n          if (isMethodCallOf(callExpression, 'concat')) {\n            const arrayValue = <MetadataValue[]>this.evaluateNode(\n                (<ts.PropertyAccessExpression>callExpression.expression).expression);\n            if (isFoldableError(arrayValue)) return arrayValue;\n            return arrayValue.concat(args[0]);\n          }\n        }\n        // Always fold a CONST_EXPR even if the argument is not foldable.\n        if (isCallOf(callExpression, 'CONST_EXPR') &&\n            arrayOrEmpty(callExpression.arguments).length === 1) {\n          return recordEntry(args[0], node);\n        }\n        const expression = this.evaluateNode(callExpression.expression);\n        if (isFoldableError(expression)) {\n          return recordEntry(expression, node);\n        }\n        let result: MetadataSymbolicCallExpression = {__symbolic: 'call', expression: expression};\n        if (args && args.length) {\n          result.arguments = args;\n        }\n        return recordEntry(result, node);\n      case ts.SyntaxKind.NewExpression:\n        const newExpression = <ts.NewExpression>node;\n        const newArgs = arrayOrEmpty(newExpression.arguments).map(arg => this.evaluateNode(arg));\n        const newTarget = this.evaluateNode(newExpression.expression);\n        if (isMetadataError(newTarget)) {\n          return recordEntry(newTarget, node);\n        }\n        const call: MetadataSymbolicCallExpression = {__symbolic: 'new', expression: newTarget};\n        if (newArgs.length) {\n          call.arguments = newArgs;\n        }\n        return recordEntry(call, node);\n      case ts.SyntaxKind.PropertyAccessExpression: {\n        const propertyAccessExpression = <ts.PropertyAccessExpression>node;\n        const expression = this.evaluateNode(propertyAccessExpression.expression);\n        if (isFoldableError(expression)) {\n          return recordEntry(expression, node);\n        }\n        const member = this.nameOf(propertyAccessExpression.name);\n        if (isFoldableError(member)) {\n          return recordEntry(member, node);\n        }\n        if (expression && this.isFoldable(propertyAccessExpression.expression))\n          return (<any>expression)[member];\n        if (isMetadataModuleReferenceExpression(expression)) {\n          // A select into a module reference and be converted into a reference to the symbol\n          // in the module\n          return recordEntry(\n              {__symbolic: 'reference', module: expression.module, name: member}, node);\n        }\n        return recordEntry({__symbolic: 'select', expression, member}, node);\n      }\n      case ts.SyntaxKind.ElementAccessExpression: {\n        const elementAccessExpression = <ts.ElementAccessExpression>node;\n        const expression = this.evaluateNode(elementAccessExpression.expression);\n        if (isFoldableError(expression)) {\n          return recordEntry(expression, node);\n        }\n        if (!elementAccessExpression.argumentExpression) {\n          return recordEntry(errorSymbol('Expression form not supported', node), node);\n        }\n        const index = this.evaluateNode(elementAccessExpression.argumentExpression);\n        if (isFoldableError(expression)) {\n          return recordEntry(expression, node);\n        }\n        if (this.isFoldable(elementAccessExpression.expression) &&\n            this.isFoldable(elementAccessExpression.argumentExpression))\n          return (<any>expression)[<string|number>index];\n        return recordEntry({__symbolic: 'index', expression, index}, node);\n      }\n      case ts.SyntaxKind.Identifier:\n        const identifier = <ts.Identifier>node;\n        const name = identifier.text;\n        return resolveName(name, preferReference);\n      case ts.SyntaxKind.TypeReference:\n        const typeReferenceNode = <ts.TypeReferenceNode>node;\n        const typeNameNode = typeReferenceNode.typeName;\n        const getReference: (typeNameNode: ts.Identifier|ts.QualifiedName) => MetadataValue =\n            node => {\n              if (typeNameNode.kind === ts.SyntaxKind.QualifiedName) {\n                const qualifiedName = <ts.QualifiedName>node;\n                const left = this.evaluateNode(qualifiedName.left);\n                if (isMetadataModuleReferenceExpression(left)) {\n                  return recordEntry(\n                      <MetadataImportedSymbolReferenceExpression>{\n                        __symbolic: 'reference',\n                        module: left.module,\n                        name: qualifiedName.right.text\n                      },\n                      node);\n                }\n                // Record a type reference to a declared type as a select.\n                return {__symbolic: 'select', expression: left, member: qualifiedName.right.text};\n              } else {\n                const identifier = <ts.Identifier>typeNameNode;\n                const symbol = this.symbols.resolve(identifier.text);\n                if (isFoldableError(symbol) || isMetadataSymbolicReferenceExpression(symbol)) {\n                  return recordEntry(symbol, node);\n                }\n                return recordEntry(\n                    errorSymbol('Could not resolve type', node, {typeName: identifier.text}), node);\n              }\n            };\n        const typeReference = getReference(typeNameNode);\n        if (isFoldableError(typeReference)) {\n          return recordEntry(typeReference, node);\n        }\n        if (!isMetadataModuleReferenceExpression(typeReference) &&\n            typeReferenceNode.typeArguments && typeReferenceNode.typeArguments.length) {\n          const args = typeReferenceNode.typeArguments.map(element => this.evaluateNode(element));\n          // TODO: Remove typecast when upgraded to 2.0 as it will be correctly inferred.\n          // Some versions of 1.9 do not infer this correctly.\n          (<MetadataImportedSymbolReferenceExpression>typeReference).arguments = args;\n        }\n        return recordEntry(typeReference, node);\n      case ts.SyntaxKind.UnionType:\n        const unionType = <ts.UnionTypeNode>node;\n        // Remove null and undefined from the list of unions.\n        const references =\n            unionType.types\n                .filter(\n                    n => n.kind !== ts.SyntaxKind.UndefinedKeyword &&\n                        !(ts.isLiteralTypeNode(n) && n.literal.kind === ts.SyntaxKind.NullKeyword))\n                .map(n => this.evaluateNode(n));\n\n        // The remmaining reference must be the same. If two have type arguments consider them\n        // different even if the type arguments are the same.\n        let candidate: any = null;\n        for (let i = 0; i < references.length; i++) {\n          const reference = references[i];\n          if (isMetadataSymbolicReferenceExpression(reference)) {\n            if (candidate) {\n              if ((reference as any).name == candidate.name &&\n                  (reference as any).module == candidate.module && !(reference as any).arguments) {\n                candidate = reference;\n              }\n            } else {\n              candidate = reference;\n            }\n          } else {\n            return reference;\n          }\n        }\n        if (candidate) return candidate;\n        break;\n      case ts.SyntaxKind.NoSubstitutionTemplateLiteral:\n      case ts.SyntaxKind.StringLiteral:\n      case ts.SyntaxKind.TemplateHead:\n      case ts.SyntaxKind.TemplateTail:\n      case ts.SyntaxKind.TemplateMiddle:\n        return (<ts.LiteralLikeNode>node).text;\n      case ts.SyntaxKind.NumericLiteral:\n        return parseFloat((<ts.LiteralExpression>node).text);\n      case ts.SyntaxKind.AnyKeyword:\n        return recordEntry({__symbolic: 'reference', name: 'any'}, node);\n      case ts.SyntaxKind.StringKeyword:\n        return recordEntry({__symbolic: 'reference', name: 'string'}, node);\n      case ts.SyntaxKind.NumberKeyword:\n        return recordEntry({__symbolic: 'reference', name: 'number'}, node);\n      case ts.SyntaxKind.BooleanKeyword:\n        return recordEntry({__symbolic: 'reference', name: 'boolean'}, node);\n      case ts.SyntaxKind.ArrayType:\n        const arrayTypeNode = <ts.ArrayTypeNode>node;\n        return recordEntry(\n            {\n              __symbolic: 'reference',\n              name: 'Array',\n              arguments: [this.evaluateNode(arrayTypeNode.elementType)]\n            },\n            node);\n      case ts.SyntaxKind.NullKeyword:\n        return null;\n      case ts.SyntaxKind.TrueKeyword:\n        return true;\n      case ts.SyntaxKind.FalseKeyword:\n        return false;\n      case ts.SyntaxKind.ParenthesizedExpression:\n        const parenthesizedExpression = <ts.ParenthesizedExpression>node;\n        return this.evaluateNode(parenthesizedExpression.expression);\n      case ts.SyntaxKind.TypeAssertionExpression:\n        const typeAssertion = <ts.TypeAssertion>node;\n        return this.evaluateNode(typeAssertion.expression);\n      case ts.SyntaxKind.PrefixUnaryExpression:\n        const prefixUnaryExpression = <ts.PrefixUnaryExpression>node;\n        const operand = this.evaluateNode(prefixUnaryExpression.operand);\n        if (isDefined(operand) && isPrimitive(operand)) {\n          switch (prefixUnaryExpression.operator) {\n            case ts.SyntaxKind.PlusToken:\n              return +(operand as any);\n            case ts.SyntaxKind.MinusToken:\n              return -(operand as any);\n            case ts.SyntaxKind.TildeToken:\n              return ~(operand as any);\n            case ts.SyntaxKind.ExclamationToken:\n              return !operand;\n          }\n        }\n        let operatorText: '+'|'-'|'~'|'!';\n        switch (prefixUnaryExpression.operator) {\n          case ts.SyntaxKind.PlusToken:\n            operatorText = '+';\n            break;\n          case ts.SyntaxKind.MinusToken:\n            operatorText = '-';\n            break;\n          case ts.SyntaxKind.TildeToken:\n            operatorText = '~';\n            break;\n          case ts.SyntaxKind.ExclamationToken:\n            operatorText = '!';\n            break;\n          default:\n            return undefined;\n        }\n        return recordEntry({__symbolic: 'pre', operator: operatorText, operand: operand}, node);\n      case ts.SyntaxKind.BinaryExpression:\n        const binaryExpression = <ts.BinaryExpression>node;\n        const left = this.evaluateNode(binaryExpression.left);\n        const right = this.evaluateNode(binaryExpression.right);\n        if (isDefined(left) && isDefined(right)) {\n          if (isPrimitive(left) && isPrimitive(right))\n            switch (binaryExpression.operatorToken.kind) {\n              case ts.SyntaxKind.BarBarToken:\n                return <any>left || <any>right;\n              case ts.SyntaxKind.AmpersandAmpersandToken:\n                return <any>left && <any>right;\n              case ts.SyntaxKind.AmpersandToken:\n                return <any>left & <any>right;\n              case ts.SyntaxKind.BarToken:\n                return <any>left | <any>right;\n              case ts.SyntaxKind.CaretToken:\n                return <any>left ^ <any>right;\n              case ts.SyntaxKind.EqualsEqualsToken:\n                return <any>left == <any>right;\n              case ts.SyntaxKind.ExclamationEqualsToken:\n                return <any>left != <any>right;\n              case ts.SyntaxKind.EqualsEqualsEqualsToken:\n                return <any>left === <any>right;\n              case ts.SyntaxKind.ExclamationEqualsEqualsToken:\n                return <any>left !== <any>right;\n              case ts.SyntaxKind.LessThanToken:\n                return <any>left < <any>right;\n              case ts.SyntaxKind.GreaterThanToken:\n                return <any>left > <any>right;\n              case ts.SyntaxKind.LessThanEqualsToken:\n                return <any>left <= <any>right;\n              case ts.SyntaxKind.GreaterThanEqualsToken:\n                return <any>left >= <any>right;\n              case ts.SyntaxKind.LessThanLessThanToken:\n                return (<any>left) << (<any>right);\n              case ts.SyntaxKind.GreaterThanGreaterThanToken:\n                return <any>left >> <any>right;\n              case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:\n                return <any>left >>> <any>right;\n              case ts.SyntaxKind.PlusToken:\n                return <any>left + <any>right;\n              case ts.SyntaxKind.MinusToken:\n                return <any>left - <any>right;\n              case ts.SyntaxKind.AsteriskToken:\n                return <any>left * <any>right;\n              case ts.SyntaxKind.SlashToken:\n                return <any>left / <any>right;\n              case ts.SyntaxKind.PercentToken:\n                return <any>left % <any>right;\n            }\n          return recordEntry(\n              {\n                __symbolic: 'binop',\n                operator: binaryExpression.operatorToken.getText(),\n                left: left,\n                right: right\n              },\n              node);\n        }\n        break;\n      case ts.SyntaxKind.ConditionalExpression:\n        const conditionalExpression = <ts.ConditionalExpression>node;\n        const condition = this.evaluateNode(conditionalExpression.condition);\n        const thenExpression = this.evaluateNode(conditionalExpression.whenTrue);\n        const elseExpression = this.evaluateNode(conditionalExpression.whenFalse);\n        if (isPrimitive(condition)) {\n          return condition ? thenExpression : elseExpression;\n        }\n        return recordEntry({__symbolic: 'if', condition, thenExpression, elseExpression}, node);\n      case ts.SyntaxKind.FunctionExpression:\n      case ts.SyntaxKind.ArrowFunction:\n        return recordEntry(errorSymbol('Lambda not supported', node), node);\n      case ts.SyntaxKind.TaggedTemplateExpression:\n        return recordEntry(\n            errorSymbol('Tagged template expressions are not supported in metadata', node), node);\n      case ts.SyntaxKind.TemplateExpression:\n        const templateExpression = <ts.TemplateExpression>node;\n        if (this.isFoldable(node)) {\n          return templateExpression.templateSpans.reduce(\n              (previous, current) => previous + <string>this.evaluateNode(current.expression) +\n                  <string>this.evaluateNode(current.literal),\n              this.evaluateNode(templateExpression.head));\n        } else {\n          return templateExpression.templateSpans.reduce((previous, current) => {\n            const expr = this.evaluateNode(current.expression);\n            const literal = this.evaluateNode(current.literal);\n            if (isFoldableError(expr)) return expr;\n            if (isFoldableError(literal)) return literal;\n            if (typeof previous === 'string' && typeof expr === 'string' &&\n                typeof literal === 'string') {\n              return previous + expr + literal;\n            }\n            let result = expr;\n            if (previous !== '') {\n              result = {__symbolic: 'binop', operator: '+', left: previous, right: expr};\n            }\n            if (literal != '') {\n              result = {__symbolic: 'binop', operator: '+', left: result, right: literal};\n            }\n            return result;\n          }, this.evaluateNode(templateExpression.head));\n        }\n      case ts.SyntaxKind.AsExpression:\n        const asExpression = <ts.AsExpression>node;\n        return this.evaluateNode(asExpression.expression);\n      case ts.SyntaxKind.ClassExpression:\n        return {__symbolic: 'class'};\n    }\n    return recordEntry(errorSymbol('Expression form not supported', node), node);\n  }\n}\n\nfunction isPropertyAssignment(node: ts.Node): node is ts.PropertyAssignment {\n  return node.kind == ts.SyntaxKind.PropertyAssignment;\n}\n\nconst empty = ts.createNodeArray<any>();\n\nfunction arrayOrEmpty<T extends ts.Node>(v: ts.NodeArray<T>|undefined): ts.NodeArray<T> {\n  return v || empty;\n}\n"]}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: