Lines Matching refs:expression

15   expression: b.Expression,
19   function toConstant(expression: b.Expression): any {
21     if (b.isArrayExpression(expression)) {
23       for (let i = 0; constant && i < expression.elements.length; i++) {
24         const element = expression.elements[i];
38     if (b.isBinaryExpression(expression)) {
39       const left = toConstant(expression.left);
40       const right = toConstant(expression.right);
41       return constant && binaryOperation(expression.operator, left, right);
43     if (b.isBooleanLiteral(expression)) {
44       return expression.value;
46     if (b.isCallExpression(expression)) {
48       for (let i = 0; constant && i < expression.arguments.length; i++) {
49         const arg = expression.arguments[i];
62       if (b.isMemberExpression(expression.callee)) {
63         const object = toConstant(expression.callee.object);
68         const member = expression.callee.computed
69           ? toConstant(expression.callee.property)
70           : b.isIdentifier(expression.callee.property)
71             ? expression.callee.property.name
73         if (member === undefined && !expression.callee.computed) {
81         const callee = toConstant(expression.callee);
86     if (b.isConditionalExpression(expression)) {
87       const test = toConstant(expression.test);
89         ? toConstant(expression.consequent)
90         : toConstant(expression.alternate);
92     if (b.isIdentifier(expression)) {
95         {}.hasOwnProperty.call(options.constants, expression.name)
97         return options.constants[expression.name];
100     if (b.isLogicalExpression(expression)) {
101       const left = toConstant(expression.left);
102       const right = toConstant(expression.right);
103       if (constant && expression.operator === '&&') {
106       if (constant && expression.operator === '||') {
110     if (b.isMemberExpression(expression)) {
111       const object = toConstant(expression.object);
116       const member = expression.computed
117         ? toConstant(expression.property)
118         : b.isIdentifier(expression.property)
119           ? expression.property.name
121       if (member === undefined && !expression.computed) {
129     if (b.isNullLiteral(expression)) {
132     if (b.isNumericLiteral(expression)) {
133       return expression.value;
135     if (b.isObjectExpression(expression)) {
137       for (let i = 0; constant && i < expression.properties.length; i++) {
138         const property = expression.properties[i];
169     if (b.isParenthesizedExpression(expression)) {
170       return toConstant(expression.expression);
172     if (b.isRegExpLiteral(expression)) {
173       return new RegExp(expression.pattern, expression.flags);
175     if (b.isSequenceExpression(expression)) {
176       for (let i = 0; i < expression.expressions.length - 1 && constant; i++) {
177         toConstant(expression.expressions[i]);
180         expression.expressions[expression.expressions.length - 1],
183     if (b.isStringLiteral(expression)) {
184       return expression.value;
187     if (b.isTemplateLiteral(expression)) {
189       for (let i = 0; i < expression.quasis.length; i++) {
190         const quasi = expression.quasis[i];
192         if (i < expression.expressions.length) {
193           result += '' + toConstant(expression.expressions[i]);
198     if (b.isUnaryExpression(expression)) {
199       const argument = toConstant(expression.argument);
203       switch (expression.operator) {
220   const result = toConstant(expression);