import * as parser from '@babel/parser';

import generate from '@babel/generator';

import traverse, { NodePath } from '@babel/traverse';

import * as t from '@babel/types';

import { isIdentifier, Node } from '@babel/types';

import { OrderedSet } from './OrderedSet';

import { IScope } from '../types';

export class ParseError extends Error {

readonly expr: string | t.Expression;

readonly detail: unknown;

constructor(expr: string | t.Expression, detail: unknown) {

super(`Failed to parse expression "${typeof expr === 'string' ? expr : generate(expr)}"`);

this.expr = expr;

this.detail = detail;

Object.setPrototypeOf(this, new.target.prototype);

}

}

const MAYBE_EXPRESSIONS: {

[k in Node['type']]?: {

// fields: Array<keyof (Node & { type: k })>

fields: string[] | ((node: Node) => string[]);

};

} = {

ArrayExpression: { fields: ['elements'] },

AssignmentExpression: { fields: ['left', 'right'] },

BinaryExpression: { fields: ['left', 'right'] },

CallExpression: { fields: ['arguments', 'callee'] },

ConditionalExpression: { fields: ['test', 'consequent', 'alternate'] },

DoWhileStatement: { fields: ['test'] },

ExpressionStatement: { fields: ['expression'] },

ForInStatement: { fields: ['right'] },

ForStatement: { fields: ['init', 'test', 'update'] },

IfStatement: { fields: ['test'] },

LogicalExpression: { fields: ['left', 'right'] },

MemberExpression: {

fields: (node) => {

return node.type === 'MemberExpression' && node.computed

? ['object', 'property']

: ['object'];

},

},

NewExpression: { fields: ['callee', 'arguments'] },

ObjectMethod: {

fields: (node) => {

return node.type === 'ObjectMethod' && node.computed ? ['key'] : [];

},

},

ObjectProperty: {

fields: (node) => {

return node.type === 'ObjectProperty' && node.computed ? ['key', 'value'] : ['value'];

},

},

ReturnStatement: { fields: ['argument'] },

SequenceExpression: { fields: ['expressions'] },

ParenthesizedExpression: { fields: ['expression'] },

SwitchCase: { fields: ['test'] },

SwitchStatement: { fields: ['discriminant'] },

ThrowStatement: { fields: ['argument'] },

UnaryExpression: { fields: ['argument'] },

UpdateExpression: { fields: ['argument'] },

VariableDeclarator: { fields: ['init'] },

WhileStatement: { fields: ['test'] },

WithStatement: { fields: ['object'] },

AssignmentPattern: { fields: ['right'] },

ArrowFunctionExpression: { fields: ['body'] },

ClassExpression: { fields: ['superClass'] },

ClassDeclaration: { fields: ['superClass'] },

ExportDefaultDeclaration: { fields: ['declaration'] },

ForOfStatement: { fields: ['right'] },

ClassMethod: {

fields: (node) => {

return node.type === 'ClassMethod' && node.computed ? ['key'] : [];

},

},

SpreadElement: { fields: ['argument'] },

TaggedTemplateExpression: { fields: ['tag'] },

TemplateLiteral: { fields: ['expressions'] },

YieldExpression: { fields: ['argument'] },

AwaitExpression: { fields: ['argument'] },

OptionalMemberExpression: {

fields: (node) => {

return node.type === 'OptionalMemberExpression' && node.computed

? ['object', 'property']

: ['object'];

},

},

OptionalCallExpression: { fields: ['callee', 'arguments'] },

JSXSpreadAttribute: { fields: ['argument'] },

BindExpression: { fields: ['object', 'callee'] },

ClassProperty: {

fields: (node) => {

return node.type === 'ClassProperty' && node.computed ? ['key', 'value'] : ['value'];

},

},

PipelineTopicExpression: { fields: ['expression'] },

PipelineBareFunction: { fields: ['callee'] },

ClassPrivateProperty: { fields: ['value'] },

Decorator: { fields: ['expression'] },

TupleExpression: { fields: ['elements'] },

TSDeclareMethod: {

fields: (node) => {

return node.type === 'TSDeclareMethod' && node.computed ? ['key'] : [];

},

},

TSPropertySignature: {

fields: (node) => {

return node.type === 'TSPropertySignature' && node.computed

? ['key', 'initializer']

: ['initializer'];

},

},

TSMethodSignature: {

fields: (node) => {

return node.type === 'TSMethodSignature' && node.computed ? ['key'] : [];

},

},

TSAsExpression: { fields: ['expression'] },

TSTypeAssertion: { fields: ['expression'] },

TSEnumDeclaration: { fields: ['initializer'] },

TSEnumMember: { fields: ['initializer'] },

TSNonNullExpression: { fields: ['expression'] },

TSExportAssignment: { fields: ['expression'] },

};

export interface ParseExpressionGetGlobalVariablesOptions {

filter?: (varName: string) => boolean;

}

const CROSS_THIS_SCOPE_TYPE_NODE: {

[k in Node['type']]?: boolean;

} = {

ArrowFunctionExpression: false, // 箭头函数不跨越 this 的 scope

FunctionExpression: true,

FunctionDeclaration: true,

// FunctionTypeAnnotation: false, // 这是 TS 定义

// FunctionTypeParam: false, // 这是 TS 定义

ClassDeclaration: true,

ClassExpression: true,

ClassBody: true,

ClassImplements: true,

ClassMethod: true,

ClassPrivateMethod: true,

ClassProperty: true,

ClassPrivateProperty: true,

DeclareClass: true,

};

const JS_KEYWORDS = ['arguments', 'this', 'super'];

export function parseExpressionGetKeywords(expr: string | null | undefined): string[] {

if (!expr) {

return [];

}

try {

const keywordVars = new OrderedSet<string>();

const ast = parser.parse(`!(${expr});`, {

plugins: [

'jsx',

],

});

const addIdentifierIfNeeded = (x: Record<string, unknown> | number | null | undefined) => {

if (typeof x === 'object' && isIdentifier(x) && JS_KEYWORDS.includes(x.name)) {

keywordVars.add(x.name);

}

};

traverse(ast, {

enter(path) {

const { node } = path;

const expressionFields = MAYBE_EXPRESSIONS[node.type]?.fields;

if (expressionFields) {

(typeof expressionFields === 'function'

? expressionFields(node)

: expressionFields

).forEach((fieldName) => {

const fieldValue = node[fieldName as keyof typeof node];

if (typeof fieldValue === 'object') {

if (Array.isArray(fieldValue)) {

fieldValue.forEach((item: any) => {

addIdentifierIfNeeded(item);

});

} else {

addIdentifierIfNeeded(fieldValue as Record<string, unknown> | null);

}

}

});

}

},

});

return keywordVars.toArray().filter(Boolean);

} catch (e) {

throw new ParseError(expr, e);

}

}

export function parseExpressionGetGlobalVariables(

expr: string | null | undefined,

{ filter = () => true }: ParseExpressionGetGlobalVariablesOptions = {},

): string[] {

if (!expr) {

return [];

}

try {

const undeclaredVars = new OrderedSet<string>();

const ast = parser.parse(`!(${expr});`);

const addUndeclaredIdentifierIfNeeded = (

x: Record<string, unknown> | number | null | undefined,

path: NodePath<Node>,

) => {

if (typeof x === 'object' && isIdentifier(x) && !path.scope.hasBinding(x.name)) {

undeclaredVars.add(x.name);

}

};

traverse(ast, {

enter(path) {

const { node } = path;

const expressionFields = MAYBE_EXPRESSIONS[node.type]?.fields;

if (expressionFields) {

(typeof expressionFields === 'function'

? expressionFields(node)

: expressionFields

).forEach((fieldName) => {

const fieldValue = node[fieldName as keyof typeof node];

if (typeof fieldValue === 'object') {

if (Array.isArray(fieldValue)) {

fieldValue.forEach((item: any) => {

addUndeclaredIdentifierIfNeeded(item, path);

});

} else {

addUndeclaredIdentifierIfNeeded(fieldValue as Record<string, unknown> | null, path);

}

}

});

}

},

});

return undeclaredVars.toArray().filter(filter);

} catch (e) {

throw new ParseError(expr, e);

}

}

export function parseExpressionConvertThis2Context(

expr: string | t.Expression,

contextName = '__$$context',

localVariables: string[] = [],

): string {

if (!expr) {

return expr;

}

try {

const exprAst = typeof expr === 'string' ? parser.parseExpression(expr) : expr;

const exprWrapAst = t.expressionStatement(exprAst);

const fileAst = t.file(t.program([exprWrapAst]));

const localVariablesSet = new Set(localVariables);

let thisScopeLevel = CROSS_THIS_SCOPE_TYPE_NODE[exprAst.type] ? -1 : 0;

traverse(fileAst, {

enter(path) {

if (CROSS_THIS_SCOPE_TYPE_NODE[path.node.type]) {

thisScopeLevel++;

}

},

exit(path) {

if (CROSS_THIS_SCOPE_TYPE_NODE[path.node.type]) {

thisScopeLevel--;

}

},

MemberExpression(path) {

if (!path.isMemberExpression()) {

return;

}

const obj = path.get('object');

if (!obj.isThisExpression()) {

return;

}

// 处理局部变量

if (!path.node.computed) {

const prop = path.get('property');

if (prop.isIdentifier() && localVariablesSet.has(prop.node.name)) {

path.replaceWith(t.identifier(prop.node.name));

return;

}

}

// 替换 this (只在顶层替换)

if (thisScopeLevel <= 0) {

obj.replaceWith(t.identifier(contextName));

}

},

ThisExpression(path) {

if (!path.isThisExpression()) {

return;

}

// MemberExpression 中的 this.xxx 已经处理过了

if (path.parent.type === 'MemberExpression') {

return;

}

if (thisScopeLevel <= 0) {

path.replaceWith(t.identifier(contextName));

}

},

});

const { code } = generate(exprWrapAst.expression, { sourceMaps: false });

return code;

} catch (e) {

throw new ParseError(expr, e);

}

}

export function parseExpression(expr: string) {

try {

return parser.parseExpression(expr);

} catch (e) {

throw new ParseError(expr, e);

}

}

export function transformExpressionLocalRef(expr: string, scope: IScope) {

if (!expr) {

return expr;

}

if (!scope) {

throw new Error('transform expression without scope');

}

try {

const exprAst = typeof expr === 'string' ? parser.parseExpression(expr) : expr;

const exprWrapAst = t.expressionStatement(exprAst);

const fileAst = t.file(t.program([exprWrapAst]));

traverse(fileAst, {

MemberExpression(path) {

if (!path.isMemberExpression()) {

return;

}

const obj = path.get('object');

if (!obj.isThisExpression()) {

return;

}

// 查看是否存在引用 local 值

const prop = path.get('property');

let memberName = '';

if (!path.node.computed && prop.isIdentifier()) {

memberName = prop.node.name;

} else if (path.node.computed && prop.isStringLiteral()) {

memberName = prop.node.value;

}

if (memberName && scope.bindings && scope.bindings.hasBinding(memberName)) {

path.replaceWith(t.identifier(memberName));

}

},

});

const { code } = generate(exprWrapAst.expression, { sourceMaps: false });

return code;

} catch (e) {

throw new ParseError(expr, e);

// throw e;

}

}