Lines Matching refs:expression

6 function expressionToConstant(expression, options) {  argument
9     function toConstant(expression) {  argument
12         if (b.isArrayExpression(expression)) {
14             for (var i = 0; constant && i < expression.elements.length; i++) {
15                 var element = expression.elements[i];
31         if (b.isBinaryExpression(expression)) {
32             var left = toConstant(expression.left);
33             var right = toConstant(expression.right);
34             return constant && binaryOperation_1["default"](expression.operator, left, right);
36         if (b.isBooleanLiteral(expression)) {
37             return expression.value;
39         if (b.isCallExpression(expression)) {
41             for (var i = 0; constant && i < expression.arguments.length; i++) {
42                 var arg = expression.arguments[i];
58             if (b.isMemberExpression(expression.callee)) {
59                 var object = toConstant(expression.callee.object);
64                 var member = expression.callee.computed
65                     ? toConstant(expression.callee.property)
66                     : b.isIdentifier(expression.callee.property)
67                         ? expression.callee.property.name
69                 if (member === undefined && !expression.callee.computed) {
79                 var callee = toConstant(expression.callee);
85         if (b.isConditionalExpression(expression)) {
86             var test = toConstant(expression.test);
88                 ? toConstant(expression.consequent)
89                 : toConstant(expression.alternate);
91         if (b.isIdentifier(expression)) {
93                 {}.hasOwnProperty.call(options.constants, expression.name)) {
94                 return options.constants[expression.name];
97         if (b.isLogicalExpression(expression)) {
98             var left = toConstant(expression.left);
99             var right = toConstant(expression.right);
100             if (constant && expression.operator === '&&') {
103             if (constant && expression.operator === '||') {
107         if (b.isMemberExpression(expression)) {
108             var object = toConstant(expression.object);
113             var member = expression.computed
114                 ? toConstant(expression.property)
115                 : b.isIdentifier(expression.property)
116                     ? expression.property.name
118             if (member === undefined && !expression.computed) {
127         if (b.isNullLiteral(expression)) {
130         if (b.isNumericLiteral(expression)) {
131             return expression.value;
133         if (b.isObjectExpression(expression)) {
135             for (var i = 0; constant && i < expression.properties.length; i++) {
136                 var property = expression.properties[i];
173         if (b.isParenthesizedExpression(expression)) {
174             return toConstant(expression.expression);
176         if (b.isRegExpLiteral(expression)) {
177             return new RegExp(expression.pattern, expression.flags);
179         if (b.isSequenceExpression(expression)) {
180             for (var i = 0; i < expression.expressions.length - 1 && constant; i++) {
181                 toConstant(expression.expressions[i]);
183             return toConstant(expression.expressions[expression.expressions.length - 1]);
185         if (b.isStringLiteral(expression)) {
186             return expression.value;
189         if (b.isTemplateLiteral(expression)) {
191             for (var i = 0; i < expression.quasis.length; i++) {
192                 var quasi = expression.quasis[i];
194                 if (i < expression.expressions.length) {
195                     result_3 += '' + toConstant(expression.expressions[i]);
200         if (b.isUnaryExpression(expression)) {
201             var argument = toConstant(expression.argument);
205             switch (expression.operator) {
222     var result = toConstant(expression);