evaluator.js

/**
 * @license
 * Copyright Google Inc. All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
(function (factory) {
    if (typeof module === "object" && typeof module.exports === "object") {
        var v = factory(require, exports);
        if (v !== undefined) module.exports = v;
    }
    else if (typeof define === "function" && define.amd) {
        define("@angular/compiler-cli/src/metadata/evaluator", ["require", "exports", "tslib", "typescript", "@angular/compiler-cli/src/metadata/schema"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var tslib_1 = require("tslib");
    var ts = require("typescript");
    var schema_1 = require("@angular/compiler-cli/src/metadata/schema");
    // In TypeScript 2.1 the spread element kind was renamed.
    var spreadElementSyntaxKind = ts.SyntaxKind.SpreadElement || ts.SyntaxKind.SpreadElementExpression;
    function isMethodCallOf(callExpression, memberName) {
        var expression = callExpression.expression;
        if (expression.kind === ts.SyntaxKind.PropertyAccessExpression) {
            var propertyAccessExpression = expression;
            var name = propertyAccessExpression.name;
            if (name.kind == ts.SyntaxKind.Identifier) {
                return name.text === memberName;
            }
        }
        return false;
    }
    function isCallOf(callExpression, ident) {
        var expression = callExpression.expression;
        if (expression.kind === ts.SyntaxKind.Identifier) {
            var identifier = expression;
            return identifier.text === ident;
        }
        return false;
    }
    /* @internal */
    function recordMapEntry(entry, node, nodeMap, sourceFile) {
        if (!nodeMap.has(entry)) {
            nodeMap.set(entry, node);
            if (node &&
                (schema_1.isMetadataImportedSymbolReferenceExpression(entry) ||
                    schema_1.isMetadataImportDefaultReference(entry)) &&
                entry.line == null) {
                var info = sourceInfo(node, sourceFile);
                if (info.line != null)
                    entry.line = info.line;
                if (info.character != null)
                    entry.character = info.character;
            }
        }
        return entry;
    }
    exports.recordMapEntry = recordMapEntry;
    /**
     * ts.forEachChild stops iterating children when the callback return a truthy value.
     * This method inverts this to implement an `every` style iterator. It will return
     * true if every call to `cb` returns `true`.
     */
    function everyNodeChild(node, cb) {
        return !ts.forEachChild(node, function (node) { return !cb(node); });
    }
    function isPrimitive(value) {
        return Object(value) !== value;
    }
    exports.isPrimitive = isPrimitive;
    function isDefined(obj) {
        return obj !== undefined;
    }
    function getSourceFileOfNode(node) {
        while (node && node.kind != ts.SyntaxKind.SourceFile) {
            node = node.parent;
        }
        return node;
    }
    /* @internal */
    function sourceInfo(node, sourceFile) {
        if (node) {
            sourceFile = sourceFile || getSourceFileOfNode(node);
            if (sourceFile) {
                return ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
            }
        }
        return {};
    }
    exports.sourceInfo = sourceInfo;
    /* @internal */
    function errorSymbol(message, node, context, sourceFile) {
        var result = tslib_1.__assign({ __symbolic: 'error', message: message }, sourceInfo(node, sourceFile));
        if (context) {
            result.context = context;
        }
        return result;
    }
    exports.errorSymbol = errorSymbol;
    /**
     * Produce a symbolic representation of an expression folding values into their final value when
     * possible.
     */
    var Evaluator = /** @class */ (function () {
        function Evaluator(symbols, nodeMap, options, recordExport) {
            if (options === void 0) { options = {}; }
            this.symbols = symbols;
            this.nodeMap = nodeMap;
            this.options = options;
            this.recordExport = recordExport;
        }
        Evaluator.prototype.nameOf = function (node) {
            if (node && node.kind == ts.SyntaxKind.Identifier) {
                return node.text;
            }
            var result = node && this.evaluateNode(node);
            if (schema_1.isMetadataError(result) || typeof result === 'string') {
                return result;
            }
            else {
                return errorSymbol('Name expected', node, { received: (node && node.getText()) || '<missing>' });
            }
        };
        /**
         * Returns true if the expression represented by `node` can be folded into a literal expression.
         *
         * For example, a literal is always foldable. This means that literal expressions such as `1.2`
         * `"Some value"` `true` `false` are foldable.
         *
         * - An object literal is foldable if all the properties in the literal are foldable.
         * - An array literal is foldable if all the elements are foldable.
         * - A call is foldable if it is a call to a Array.prototype.concat or a call to CONST_EXPR.
         * - A property access is foldable if the object is foldable.
         * - A array index is foldable if index expression is foldable and the array is foldable.
         * - Binary operator expressions are foldable if the left and right expressions are foldable and
         *   it is one of '+', '-', '*', '/', '%', '||', and '&&'.
         * - An identifier is foldable if a value can be found for its symbol in the evaluator symbol
         *   table.
         */
        Evaluator.prototype.isFoldable = function (node) {
            return this.isFoldableWorker(node, new Map());
        };
        Evaluator.prototype.isFoldableWorker = function (node, folding) {
            var _this = this;
            if (node) {
                switch (node.kind) {
                    case ts.SyntaxKind.ObjectLiteralExpression:
                        return everyNodeChild(node, function (child) {
                            if (child.kind === ts.SyntaxKind.PropertyAssignment) {
                                var propertyAssignment = child;
                                return _this.isFoldableWorker(propertyAssignment.initializer, folding);
                            }
                            return false;
                        });
                    case ts.SyntaxKind.ArrayLiteralExpression:
                        return everyNodeChild(node, function (child) { return _this.isFoldableWorker(child, folding); });
                    case ts.SyntaxKind.CallExpression:
                        var callExpression = node;
                        // We can fold a <array>.concat(<v>).
                        if (isMethodCallOf(callExpression, 'concat') &&
                            arrayOrEmpty(callExpression.arguments).length === 1) {
                            var arrayNode = callExpression.expression.expression;
                            if (this.isFoldableWorker(arrayNode, folding) &&
                                this.isFoldableWorker(callExpression.arguments[0], folding)) {
                                // It needs to be an array.
                                var arrayValue = this.evaluateNode(arrayNode);
                                if (arrayValue && Array.isArray(arrayValue)) {
                                    return true;
                                }
                            }
                        }
                        // We can fold a call to CONST_EXPR
                        if (isCallOf(callExpression, 'CONST_EXPR') &&
                            arrayOrEmpty(callExpression.arguments).length === 1)
                            return this.isFoldableWorker(callExpression.arguments[0], folding);
                        return false;
                    case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
                    case ts.SyntaxKind.StringLiteral:
                    case ts.SyntaxKind.NumericLiteral:
                    case ts.SyntaxKind.NullKeyword:
                    case ts.SyntaxKind.TrueKeyword:
                    case ts.SyntaxKind.FalseKeyword:
                    case ts.SyntaxKind.TemplateHead:
                    case ts.SyntaxKind.TemplateMiddle:
                    case ts.SyntaxKind.TemplateTail:
                        return true;
                    case ts.SyntaxKind.ParenthesizedExpression:
                        var parenthesizedExpression = node;
                        return this.isFoldableWorker(parenthesizedExpression.expression, folding);
                    case ts.SyntaxKind.BinaryExpression:
                        var binaryExpression = node;
                        switch (binaryExpression.operatorToken.kind) {
                            case ts.SyntaxKind.PlusToken:
                            case ts.SyntaxKind.MinusToken:
                            case ts.SyntaxKind.AsteriskToken:
                            case ts.SyntaxKind.SlashToken:
                            case ts.SyntaxKind.PercentToken:
                            case ts.SyntaxKind.AmpersandAmpersandToken:
                            case ts.SyntaxKind.BarBarToken:
                                return this.isFoldableWorker(binaryExpression.left, folding) &&
                                    this.isFoldableWorker(binaryExpression.right, folding);
                            default:
                                return false;
                        }
                    case ts.SyntaxKind.PropertyAccessExpression:
                        var propertyAccessExpression = node;
                        return this.isFoldableWorker(propertyAccessExpression.expression, folding);
                    case ts.SyntaxKind.ElementAccessExpression:
                        var elementAccessExpression = node;
                        return this.isFoldableWorker(elementAccessExpression.expression, folding) &&
                            this.isFoldableWorker(elementAccessExpression.argumentExpression, folding);
                    case ts.SyntaxKind.Identifier:
                        var identifier = node;
                        var reference = this.symbols.resolve(identifier.text);
                        if (reference !== undefined && isPrimitive(reference)) {
                            return true;
                        }
                        break;
                    case ts.SyntaxKind.TemplateExpression:
                        var templateExpression = node;
                        return templateExpression.templateSpans.every(function (span) { return _this.isFoldableWorker(span.expression, folding); });
                }
            }
            return false;
        };
        /**
         * Produce a JSON serialiable object representing `node`. The foldable values in the expression
         * tree are folded. For example, a node representing `1 + 2` is folded into `3`.
         */
        Evaluator.prototype.evaluateNode = function (node, preferReference) {
            var _this = this;
            var t = this;
            var error;
            function recordEntry(entry, node) {
                if (t.options.substituteExpression) {
                    var newEntry = t.options.substituteExpression(entry, node);
                    if (t.recordExport && newEntry != entry && schema_1.isMetadataGlobalReferenceExpression(newEntry)) {
                        t.recordExport(newEntry.name, entry);
                    }
                    entry = newEntry;
                }
                return recordMapEntry(entry, node, t.nodeMap);
            }
            function isFoldableError(value) {
                return !t.options.verboseInvalidExpression && schema_1.isMetadataError(value);
            }
            var resolveName = function (name, preferReference) {
                var reference = _this.symbols.resolve(name, preferReference);
                if (reference === undefined) {
                    // Encode as a global reference. StaticReflector will check the reference.
                    return recordEntry({ __symbolic: 'reference', name: name }, node);
                }
                if (reference && schema_1.isMetadataSymbolicReferenceExpression(reference)) {
                    return recordEntry(tslib_1.__assign({}, reference), node);
                }
                return reference;
            };
            switch (node.kind) {
                case ts.SyntaxKind.ObjectLiteralExpression:
                    var obj_1 = {};
                    var quoted_1 = [];
                    ts.forEachChild(node, function (child) {
                        switch (child.kind) {
                            case ts.SyntaxKind.ShorthandPropertyAssignment:
                            case ts.SyntaxKind.PropertyAssignment:
                                var assignment = child;
                                if (assignment.name.kind == ts.SyntaxKind.StringLiteral) {
                                    var name_1 = assignment.name.text;
                                    quoted_1.push(name_1);
                                }
                                var propertyName = _this.nameOf(assignment.name);
                                if (isFoldableError(propertyName)) {
                                    error = propertyName;
                                    return true;
                                }
                                var propertyValue = isPropertyAssignment(assignment) ?
                                    _this.evaluateNode(assignment.initializer, /* preferReference */ true) :
                                    resolveName(propertyName, /* preferReference */ true);
                                if (isFoldableError(propertyValue)) {
                                    error = propertyValue;
                                    return true; // Stop the forEachChild.
                                }
                                else {
                                    obj_1[propertyName] = isPropertyAssignment(assignment) ?
                                        recordEntry(propertyValue, assignment.initializer) :
                                        propertyValue;
                                }
                        }
                    });
                    if (error)
                        return error;
                    if (this.options.quotedNames && quoted_1.length) {
                        obj_1['$quoted$'] = quoted_1;
                    }
                    return recordEntry(obj_1, node);
                case ts.SyntaxKind.ArrayLiteralExpression:
                    var arr_1 = [];
                    ts.forEachChild(node, function (child) {
                        var e_1, _a;
                        var value = _this.evaluateNode(child, /* preferReference */ true);
                        // Check for error
                        if (isFoldableError(value)) {
                            error = value;
                            return true; // Stop the forEachChild.
                        }
                        // Handle spread expressions
                        if (schema_1.isMetadataSymbolicSpreadExpression(value)) {
                            if (Array.isArray(value.expression)) {
                                try {
                                    for (var _b = tslib_1.__values(value.expression), _c = _b.next(); !_c.done; _c = _b.next()) {
                                        var spreadValue = _c.value;
                                        arr_1.push(spreadValue);
                                    }
                                }
                                catch (e_1_1) { e_1 = { error: e_1_1 }; }
                                finally {
                                    try {
                                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                                    }
                                    finally { if (e_1) throw e_1.error; }
                                }
                                return;
                            }
                        }
                        arr_1.push(value);
                    });
                    if (error)
                        return error;
                    return recordEntry(arr_1, node);
                case spreadElementSyntaxKind:
                    var spreadExpression = this.evaluateNode(node.expression);
                    return recordEntry({ __symbolic: 'spread', expression: spreadExpression }, node);
                case ts.SyntaxKind.CallExpression:
                    var callExpression = node;
                    if (isCallOf(callExpression, 'forwardRef') &&
                        arrayOrEmpty(callExpression.arguments).length === 1) {
                        var firstArgument = callExpression.arguments[0];
                        if (firstArgument.kind == ts.SyntaxKind.ArrowFunction) {
                            var arrowFunction = firstArgument;
                            return recordEntry(this.evaluateNode(arrowFunction.body), node);
                        }
                    }
                    var args = arrayOrEmpty(callExpression.arguments).map(function (arg) { return _this.evaluateNode(arg); });
                    if (this.isFoldable(callExpression)) {
                        if (isMethodCallOf(callExpression, 'concat')) {
                            var arrayValue = this.evaluateNode(callExpression.expression.expression);
                            if (isFoldableError(arrayValue))
                                return arrayValue;
                            return arrayValue.concat(args[0]);
                        }
                    }
                    // Always fold a CONST_EXPR even if the argument is not foldable.
                    if (isCallOf(callExpression, 'CONST_EXPR') &&
                        arrayOrEmpty(callExpression.arguments).length === 1) {
                        return recordEntry(args[0], node);
                    }
                    var expression = this.evaluateNode(callExpression.expression);
                    if (isFoldableError(expression)) {
                        return recordEntry(expression, node);
                    }
                    var result = { __symbolic: 'call', expression: expression };
                    if (args && args.length) {
                        result.arguments = args;
                    }
                    return recordEntry(result, node);
                case ts.SyntaxKind.NewExpression:
                    var newExpression = node;
                    var newArgs = arrayOrEmpty(newExpression.arguments).map(function (arg) { return _this.evaluateNode(arg); });
                    var newTarget = this.evaluateNode(newExpression.expression);
                    if (schema_1.isMetadataError(newTarget)) {
                        return recordEntry(newTarget, node);
                    }
                    var call = { __symbolic: 'new', expression: newTarget };
                    if (newArgs.length) {
                        call.arguments = newArgs;
                    }
                    return recordEntry(call, node);
                case ts.SyntaxKind.PropertyAccessExpression: {
                    var propertyAccessExpression = node;
                    var expression_1 = this.evaluateNode(propertyAccessExpression.expression);
                    if (isFoldableError(expression_1)) {
                        return recordEntry(expression_1, node);
                    }
                    var member = this.nameOf(propertyAccessExpression.name);
                    if (isFoldableError(member)) {
                        return recordEntry(member, node);
                    }
                    if (expression_1 && this.isFoldable(propertyAccessExpression.expression))
                        return expression_1[member];
                    if (schema_1.isMetadataModuleReferenceExpression(expression_1)) {
                        // A select into a module reference and be converted into a reference to the symbol
                        // in the module
                        return recordEntry({ __symbolic: 'reference', module: expression_1.module, name: member }, node);
                    }
                    return recordEntry({ __symbolic: 'select', expression: expression_1, member: member }, node);
                }
                case ts.SyntaxKind.ElementAccessExpression: {
                    var elementAccessExpression = node;
                    var expression_2 = this.evaluateNode(elementAccessExpression.expression);
                    if (isFoldableError(expression_2)) {
                        return recordEntry(expression_2, node);
                    }
                    if (!elementAccessExpression.argumentExpression) {
                        return recordEntry(errorSymbol('Expression form not supported', node), node);
                    }
                    var index = this.evaluateNode(elementAccessExpression.argumentExpression);
                    if (isFoldableError(expression_2)) {
                        return recordEntry(expression_2, node);
                    }
                    if (this.isFoldable(elementAccessExpression.expression) &&
                        this.isFoldable(elementAccessExpression.argumentExpression))
                        return expression_2[index];
                    return recordEntry({ __symbolic: 'index', expression: expression_2, index: index }, node);
                }
                case ts.SyntaxKind.Identifier:
                    var identifier = node;
                    var name = identifier.text;
                    return resolveName(name, preferReference);
                case ts.SyntaxKind.TypeReference:
                    var typeReferenceNode = node;
                    var typeNameNode_1 = typeReferenceNode.typeName;
                    var getReference = function (node) {
                        if (typeNameNode_1.kind === ts.SyntaxKind.QualifiedName) {
                            var qualifiedName = node;
                            var left_1 = _this.evaluateNode(qualifiedName.left);
                            if (schema_1.isMetadataModuleReferenceExpression(left_1)) {
                                return recordEntry({
                                    __symbolic: 'reference',
                                    module: left_1.module,
                                    name: qualifiedName.right.text
                                }, node);
                            }
                            // Record a type reference to a declared type as a select.
                            return { __symbolic: 'select', expression: left_1, member: qualifiedName.right.text };
                        }
                        else {
                            var identifier_1 = typeNameNode_1;
                            var symbol = _this.symbols.resolve(identifier_1.text);
                            if (isFoldableError(symbol) || schema_1.isMetadataSymbolicReferenceExpression(symbol)) {
                                return recordEntry(symbol, node);
                            }
                            return recordEntry(errorSymbol('Could not resolve type', node, { typeName: identifier_1.text }), node);
                        }
                    };
                    var typeReference = getReference(typeNameNode_1);
                    if (isFoldableError(typeReference)) {
                        return recordEntry(typeReference, node);
                    }
                    if (!schema_1.isMetadataModuleReferenceExpression(typeReference) &&
                        typeReferenceNode.typeArguments && typeReferenceNode.typeArguments.length) {
                        var args_1 = typeReferenceNode.typeArguments.map(function (element) { return _this.evaluateNode(element); });
                        // TODO: Remove typecast when upgraded to 2.0 as it will be correctly inferred.
                        // Some versions of 1.9 do not infer this correctly.
                        typeReference.arguments = args_1;
                    }
                    return recordEntry(typeReference, node);
                case ts.SyntaxKind.UnionType:
                    var unionType = node;
                    // Remove null and undefined from the list of unions.
                    var references = unionType.types
                        .filter(function (n) { return n.kind != ts.SyntaxKind.NullKeyword &&
                        n.kind != ts.SyntaxKind.UndefinedKeyword; })
                        .map(function (n) { return _this.evaluateNode(n); });
                    // The remmaining reference must be the same. If two have type arguments consider them
                    // different even if the type arguments are the same.
                    var candidate = null;
                    for (var i = 0; i < references.length; i++) {
                        var reference = references[i];
                        if (schema_1.isMetadataSymbolicReferenceExpression(reference)) {
                            if (candidate) {
                                if (reference.name == candidate.name &&
                                    reference.module == candidate.module && !reference.arguments) {
                                    candidate = reference;
                                }
                            }
                            else {
                                candidate = reference;
                            }
                        }
                        else {
                            return reference;
                        }
                    }
                    if (candidate)
                        return candidate;
                    break;
                case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
                case ts.SyntaxKind.StringLiteral:
                case ts.SyntaxKind.TemplateHead:
                case ts.SyntaxKind.TemplateTail:
                case ts.SyntaxKind.TemplateMiddle:
                    return node.text;
                case ts.SyntaxKind.NumericLiteral:
                    return parseFloat(node.text);
                case ts.SyntaxKind.AnyKeyword:
                    return recordEntry({ __symbolic: 'reference', name: 'any' }, node);
                case ts.SyntaxKind.StringKeyword:
                    return recordEntry({ __symbolic: 'reference', name: 'string' }, node);
                case ts.SyntaxKind.NumberKeyword:
                    return recordEntry({ __symbolic: 'reference', name: 'number' }, node);
                case ts.SyntaxKind.BooleanKeyword:
                    return recordEntry({ __symbolic: 'reference', name: 'boolean' }, node);
                case ts.SyntaxKind.ArrayType:
                    var arrayTypeNode = node;
                    return recordEntry({
                        __symbolic: 'reference',
                        name: 'Array',
                        arguments: [this.evaluateNode(arrayTypeNode.elementType)]
                    }, node);
                case ts.SyntaxKind.NullKeyword:
                    return null;
                case ts.SyntaxKind.TrueKeyword:
                    return true;
                case ts.SyntaxKind.FalseKeyword:
                    return false;
                case ts.SyntaxKind.ParenthesizedExpression:
                    var parenthesizedExpression = node;
                    return this.evaluateNode(parenthesizedExpression.expression);
                case ts.SyntaxKind.TypeAssertionExpression:
                    var typeAssertion = node;
                    return this.evaluateNode(typeAssertion.expression);
                case ts.SyntaxKind.PrefixUnaryExpression:
                    var prefixUnaryExpression = node;
                    var operand = this.evaluateNode(prefixUnaryExpression.operand);
                    if (isDefined(operand) && isPrimitive(operand)) {
                        switch (prefixUnaryExpression.operator) {
                            case ts.SyntaxKind.PlusToken:
                                return +operand;
                            case ts.SyntaxKind.MinusToken:
                                return -operand;
                            case ts.SyntaxKind.TildeToken:
                                return ~operand;
                            case ts.SyntaxKind.ExclamationToken:
                                return !operand;
                        }
                    }
                    var operatorText = void 0;
                    switch (prefixUnaryExpression.operator) {
                        case ts.SyntaxKind.PlusToken:
                            operatorText = '+';
                            break;
                        case ts.SyntaxKind.MinusToken:
                            operatorText = '-';
                            break;
                        case ts.SyntaxKind.TildeToken:
                            operatorText = '~';
                            break;
                        case ts.SyntaxKind.ExclamationToken:
                            operatorText = '!';
                            break;
                        default:
                            return undefined;
                    }
                    return recordEntry({ __symbolic: 'pre', operator: operatorText, operand: operand }, node);
                case ts.SyntaxKind.BinaryExpression:
                    var binaryExpression = node;
                    var left = this.evaluateNode(binaryExpression.left);
                    var right = this.evaluateNode(binaryExpression.right);
                    if (isDefined(left) && isDefined(right)) {
                        if (isPrimitive(left) && isPrimitive(right))
                            switch (binaryExpression.operatorToken.kind) {
                                case ts.SyntaxKind.BarBarToken:
                                    return left || right;
                                case ts.SyntaxKind.AmpersandAmpersandToken:
                                    return left && right;
                                case ts.SyntaxKind.AmpersandToken:
                                    return left & right;
                                case ts.SyntaxKind.BarToken:
                                    return left | right;
                                case ts.SyntaxKind.CaretToken:
                                    return left ^ right;
                                case ts.SyntaxKind.EqualsEqualsToken:
                                    return left == right;
                                case ts.SyntaxKind.ExclamationEqualsToken:
                                    return left != right;
                                case ts.SyntaxKind.EqualsEqualsEqualsToken:
                                    return left === right;
                                case ts.SyntaxKind.ExclamationEqualsEqualsToken:
                                    return left !== right;
                                case ts.SyntaxKind.LessThanToken:
                                    return left < right;
                                case ts.SyntaxKind.GreaterThanToken:
                                    return left > right;
                                case ts.SyntaxKind.LessThanEqualsToken:
                                    return left <= right;
                                case ts.SyntaxKind.GreaterThanEqualsToken:
                                    return left >= right;
                                case ts.SyntaxKind.LessThanLessThanToken:
                                    return left << right;
                                case ts.SyntaxKind.GreaterThanGreaterThanToken:
                                    return left >> right;
                                case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
                                    return left >>> right;
                                case ts.SyntaxKind.PlusToken:
                                    return left + right;
                                case ts.SyntaxKind.MinusToken:
                                    return left - right;
                                case ts.SyntaxKind.AsteriskToken:
                                    return left * right;
                                case ts.SyntaxKind.SlashToken:
                                    return left / right;
                                case ts.SyntaxKind.PercentToken:
                                    return left % right;
                            }
                        return recordEntry({
                            __symbolic: 'binop',
                            operator: binaryExpression.operatorToken.getText(),
                            left: left,
                            right: right
                        }, node);
                    }
                    break;
                case ts.SyntaxKind.ConditionalExpression:
                    var conditionalExpression = node;
                    var condition = this.evaluateNode(conditionalExpression.condition);
                    var thenExpression = this.evaluateNode(conditionalExpression.whenTrue);
                    var elseExpression = this.evaluateNode(conditionalExpression.whenFalse);
                    if (isPrimitive(condition)) {
                        return condition ? thenExpression : elseExpression;
                    }
                    return recordEntry({ __symbolic: 'if', condition: condition, thenExpression: thenExpression, elseExpression: elseExpression }, node);
                case ts.SyntaxKind.FunctionExpression:
                case ts.SyntaxKind.ArrowFunction:
                    return recordEntry(errorSymbol('Lambda not supported', node), node);
                case ts.SyntaxKind.TaggedTemplateExpression:
                    return recordEntry(errorSymbol('Tagged template expressions are not supported in metadata', node), node);
                case ts.SyntaxKind.TemplateExpression:
                    var templateExpression = node;
                    if (this.isFoldable(node)) {
                        return templateExpression.templateSpans.reduce(function (previous, current) { return previous + _this.evaluateNode(current.expression) +
                            _this.evaluateNode(current.literal); }, this.evaluateNode(templateExpression.head));
                    }
                    else {
                        return templateExpression.templateSpans.reduce(function (previous, current) {
                            var expr = _this.evaluateNode(current.expression);
                            var literal = _this.evaluateNode(current.literal);
                            if (isFoldableError(expr))
                                return expr;
                            if (isFoldableError(literal))
                                return literal;
                            if (typeof previous === 'string' && typeof expr === 'string' &&
                                typeof literal === 'string') {
                                return previous + expr + literal;
                            }
                            var result = expr;
                            if (previous !== '') {
                                result = { __symbolic: 'binop', operator: '+', left: previous, right: expr };
                            }
                            if (literal != '') {
                                result = { __symbolic: 'binop', operator: '+', left: result, right: literal };
                            }
                            return result;
                        }, this.evaluateNode(templateExpression.head));
                    }
                case ts.SyntaxKind.AsExpression:
                    var asExpression = node;
                    return this.evaluateNode(asExpression.expression);
                case ts.SyntaxKind.ClassExpression:
                    return { __symbolic: 'class' };
            }
            return recordEntry(errorSymbol('Expression form not supported', node), node);
        };
        return Evaluator;
    }());
    exports.Evaluator = Evaluator;
    function isPropertyAssignment(node) {
        return node.kind == ts.SyntaxKind.PropertyAssignment;
    }
    var empty = ts.createNodeArray();
    function arrayOrEmpty(v) {
        return v || empty;
    }
});
//# 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 Inc. 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\n        // Remove null and undefined from the list of unions.\n        const references = unionType.types\n                               .filter(\n                                   n => n.kind != ts.SyntaxKind.NullKeyword &&\n                                       n.kind != ts.SyntaxKind.UndefinedKeyword)\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}"]}