-
-
Notifications
You must be signed in to change notification settings - Fork 5.6k
/
buildOptimizedSequenceExpression.ts
74 lines (64 loc) 路 2.13 KB
/
buildOptimizedSequenceExpression.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
import { types as t } from "@babel/core";
import type { NodePath } from "@babel/traverse";
// tries to optimize sequence expressions in the format
// (a = b, (c => c + e)(a))
// to
// (a = b, a + e)
type Options = {
call: t.CallExpression | t.AwaitExpression;
path: NodePath<t.BinaryExpression & { operator: "|>" }>;
placeholder: t.Identifier;
};
function isConciseArrowExpression(
node: t.Node,
): node is t.ArrowFunctionExpression & { body: t.Expression } {
return (
t.isArrowFunctionExpression(node) &&
t.isExpression(node.body) &&
!node.async
);
}
const buildOptimizedSequenceExpression = ({
call,
path,
placeholder,
}: Options) => {
// @ts-expect-error AwaitExpression does not have callee property
const { callee: calledExpression } = call;
// pipelineLeft must not be a PrivateName
const pipelineLeft = path.node.left as t.Expression;
const assign = t.assignmentExpression(
"=",
t.cloneNode(placeholder),
pipelineLeft,
);
const expressionIsArrow = isConciseArrowExpression(calledExpression);
if (expressionIsArrow) {
let param;
let optimizeArrow = true;
const { params } = calledExpression;
if (params.length === 1 && t.isIdentifier(params[0])) {
param = params[0];
} else if (params.length > 0) {
optimizeArrow = false;
}
if (optimizeArrow && !param) {
// fixme: arrow function with 1 pattern argument will also go into this branch
// Arrow function with 0 arguments
return t.sequenceExpression([pipelineLeft, calledExpression.body]);
} else if (param) {
path.scope.push({ id: t.cloneNode(placeholder) });
path.get("right").scope.rename(param.name, placeholder.name);
return t.sequenceExpression([assign, calledExpression.body]);
}
} else if (t.isIdentifier(calledExpression, { name: "eval" })) {
const evalSequence = t.sequenceExpression([
t.numericLiteral(0),
calledExpression,
]);
(call as t.CallExpression).callee = evalSequence;
}
path.scope.push({ id: t.cloneNode(placeholder) });
return t.sequenceExpression([assign, call]);
};
export default buildOptimizedSequenceExpression;