From 26a09f08cf1ed43c640879f23fdad56c5c9282f7 Mon Sep 17 00:00:00 2001
From: HelenHuang <LinHuang@pollex.com.tw>
Date: 星期四, 09 六月 2022 15:02:38 +0800
Subject: [PATCH] TODO#139884 Banner 1 文案調整
---
PAMapp/node_modules/regenerator-transform/src/emit.js | 163 +++++++++++++++++++++++++++++++++--------------------
1 files changed, 101 insertions(+), 62 deletions(-)
diff --git a/PAMapp/node_modules/regenerator-transform/src/emit.js b/PAMapp/node_modules/regenerator-transform/src/emit.js
index 5c9e830..67b9538 100644
--- a/PAMapp/node_modules/regenerator-transform/src/emit.js
+++ b/PAMapp/node_modules/regenerator-transform/src/emit.js
@@ -764,6 +764,10 @@
break;
+ case "ClassDeclaration":
+ self.emit(self.explodeClass(path));
+ break;
+
default:
throw new Error(
"unknown Statement of type " +
@@ -900,6 +904,50 @@
this.emitAssign(this.contextProperty("prev"), loc);
};
+
+// In order to save the rest of explodeExpression from a combinatorial
+// trainwreck of special cases, explodeViaTempVar is responsible for
+// deciding when a subexpression needs to be "exploded," which is my
+// very technical term for emitting the subexpression as an assignment
+// to a temporary variable and the substituting the temporary variable
+// for the original subexpression. Think of exploded view diagrams, not
+// Michael Bay movies. The point of exploding subexpressions is to
+// control the precise order in which the generated code realizes the
+// side effects of those subexpressions.
+Ep.explodeViaTempVar = function(tempVar, childPath, hasLeapingChildren, ignoreChildResult) {
+ assert.ok(
+ !ignoreChildResult || !tempVar,
+ "Ignoring the result of a child expression but forcing it to " +
+ "be assigned to a temporary variable?"
+ );
+ const t = util.getTypes();
+
+ let result = this.explodeExpression(childPath, ignoreChildResult);
+
+ if (ignoreChildResult) {
+ // Side effects already emitted above.
+
+ } else if (tempVar || (hasLeapingChildren &&
+ !t.isLiteral(result))) {
+ // If tempVar was provided, then the result will always be assigned
+ // to it, even if the result does not otherwise need to be assigned
+ // to a temporary variable. When no tempVar is provided, we have
+ // the flexibility to decide whether a temporary variable is really
+ // necessary. Unfortunately, in general, a temporary variable is
+ // required whenever any child contains a yield expression, since it
+ // is difficult to prove (at all, let alone efficiently) whether
+ // this result would evaluate to the same value before and after the
+ // yield (see #206). One narrow case where we can prove it doesn't
+ // matter (and thus we do not need a temporary variable) is when the
+ // result in question is a Literal value.
+ result = this.emitAssign(
+ tempVar || this.makeTempVar(),
+ result
+ );
+ }
+ return result;
+};
+
Ep.explodeExpression = function(path, ignoreResult) {
const t = util.getTypes();
let expr = path.node;
@@ -917,9 +965,8 @@
t.assertExpression(expr);
if (ignoreResult) {
self.emit(expr);
- } else {
- return expr;
}
+ return expr;
}
// If the expression does not contain a leap, then we either emit the
@@ -934,48 +981,6 @@
// side effects relative to the leaping child(ren).
let hasLeapingChildren = meta.containsLeap.onlyChildren(expr);
- // In order to save the rest of explodeExpression from a combinatorial
- // trainwreck of special cases, explodeViaTempVar is responsible for
- // deciding when a subexpression needs to be "exploded," which is my
- // very technical term for emitting the subexpression as an assignment
- // to a temporary variable and the substituting the temporary variable
- // for the original subexpression. Think of exploded view diagrams, not
- // Michael Bay movies. The point of exploding subexpressions is to
- // control the precise order in which the generated code realizes the
- // side effects of those subexpressions.
- function explodeViaTempVar(tempVar, childPath, ignoreChildResult) {
- assert.ok(
- !ignoreChildResult || !tempVar,
- "Ignoring the result of a child expression but forcing it to " +
- "be assigned to a temporary variable?"
- );
-
- let result = self.explodeExpression(childPath, ignoreChildResult);
-
- if (ignoreChildResult) {
- // Side effects already emitted above.
-
- } else if (tempVar || (hasLeapingChildren &&
- !t.isLiteral(result))) {
- // If tempVar was provided, then the result will always be assigned
- // to it, even if the result does not otherwise need to be assigned
- // to a temporary variable. When no tempVar is provided, we have
- // the flexibility to decide whether a temporary variable is really
- // necessary. Unfortunately, in general, a temporary variable is
- // required whenever any child contains a yield expression, since it
- // is difficult to prove (at all, let alone efficiently) whether
- // this result would evaluate to the same value before and after the
- // yield (see #206). One narrow case where we can prove it doesn't
- // matter (and thus we do not need a temporary variable) is when the
- // result in question is a Literal value.
- result = self.emitAssign(
- tempVar || self.makeTempVar(),
- result
- );
- }
- return result;
- }
-
// If ignoreResult is true, then we must take full responsibility for
// emitting the expression with all its side effects, and we should not
// return a result.
@@ -985,7 +990,7 @@
return finish(t.memberExpression(
self.explodeExpression(path.get("object")),
expr.computed
- ? explodeViaTempVar(null, path.get("property"))
+ ? self.explodeViaTempVar(null, path.get("property"), hasLeapingChildren)
: expr.property,
expr.computed
));
@@ -1011,15 +1016,16 @@
// expression, then we must be careful that the object of the
// member expression still gets bound to `this` for the call.
- let newObject = explodeViaTempVar(
+ let newObject = self.explodeViaTempVar(
// Assign the exploded callee.object expression to a temporary
// variable so that we can use it twice without reevaluating it.
self.makeTempVar(),
- calleePath.get("object")
+ calleePath.get("object"),
+ hasLeapingChildren
);
let newProperty = calleePath.node.computed
- ? explodeViaTempVar(null, calleePath.get("property"))
+ ? self.explodeViaTempVar(null, calleePath.get("property"), hasLeapingChildren)
: calleePath.node.property;
injectFirstArg = newObject;
@@ -1039,7 +1045,7 @@
}
} else {
- newCallee = explodeViaTempVar(null, calleePath);
+ newCallee = self.explodeViaTempVar(null, calleePath, hasLeapingChildren);
if (t.isMemberExpression(newCallee)) {
// If the callee was not previously a MemberExpression, then the
@@ -1058,7 +1064,7 @@
}
if (hasLeapingArgs) {
- newArgs = argsPath.map(argPath => explodeViaTempVar(null, argPath));
+ newArgs = argsPath.map(argPath => self.explodeViaTempVar(null, argPath, hasLeapingChildren));
if (injectFirstArg) newArgs.unshift(injectFirstArg);
newArgs = newArgs.map(arg => t.cloneDeep(arg));
@@ -1070,9 +1076,9 @@
case "NewExpression":
return finish(t.newExpression(
- explodeViaTempVar(null, path.get("callee")),
- path.get("arguments").map(function(argPath) {
- return explodeViaTempVar(null, argPath);
+ self.explodeViaTempVar(null, path.get("callee"), hasLeapingChildren),
+ path.get("arguments").map(function(argPath) {
+ return self.explodeViaTempVar(null, argPath, hasLeapingChildren);
})
));
@@ -1082,7 +1088,7 @@
if (propPath.isObjectProperty()) {
return t.objectProperty(
propPath.node.key,
- explodeViaTempVar(null, propPath.get("value")),
+ self.explodeViaTempVar(null, propPath.get("value"), hasLeapingChildren),
propPath.node.computed
);
} else {
@@ -1096,10 +1102,10 @@
path.get("elements").map(function(elemPath) {
if (elemPath.isSpreadElement()) {
return t.spreadElement(
- explodeViaTempVar(null, elemPath.get("argument"))
+ self.explodeViaTempVar(null, elemPath.get("argument"), hasLeapingChildren)
);
} else {
- return explodeViaTempVar(null, elemPath);
+ return self.explodeViaTempVar(null, elemPath, hasLeapingChildren);
}
})
));
@@ -1124,7 +1130,7 @@
result = self.makeTempVar();
}
- let left = explodeViaTempVar(result, path.get("left"));
+ let left = self.explodeViaTempVar(result, path.get("left"), hasLeapingChildren);
if (expr.operator === "&&") {
self.jumpIfNot(left, after);
@@ -1133,7 +1139,7 @@
self.jumpIf(left, after);
}
- explodeViaTempVar(result, path.get("right"), ignoreResult);
+ self.explodeViaTempVar(result, path.get("right"), hasLeapingChildren, ignoreResult);
self.mark(after);
@@ -1150,11 +1156,11 @@
result = self.makeTempVar();
}
- explodeViaTempVar(result, path.get("consequent"), ignoreResult);
+ self.explodeViaTempVar(result, path.get("consequent"), hasLeapingChildren, ignoreResult);
self.jump(after);
self.mark(elseLoc);
- explodeViaTempVar(result, path.get("alternate"), ignoreResult);
+ self.explodeViaTempVar(result, path.get("alternate"), hasLeapingChildren, ignoreResult);
self.mark(after);
@@ -1172,8 +1178,8 @@
case "BinaryExpression":
return finish(t.binaryExpression(
expr.operator,
- explodeViaTempVar(null, path.get("left")),
- explodeViaTempVar(null, path.get("right"))
+ self.explodeViaTempVar(null, path.get("left"), hasLeapingChildren),
+ self.explodeViaTempVar(null, path.get("right"), hasLeapingChildren)
));
case "AssignmentExpression":
@@ -1254,9 +1260,42 @@
return self.contextProperty("sent");
+ case "ClassExpression":
+ return finish(self.explodeClass(path));
+
default:
throw new Error(
"unknown Expression of type " +
JSON.stringify(expr.type));
}
};
+
+Ep.explodeClass = function(path) {
+ const explodingChildren = [];
+
+ if (path.node.superClass) {
+ explodingChildren.push(path.get("superClass"));
+ }
+
+ path.get("body.body").forEach(member => {
+ if (member.node.computed) {
+ explodingChildren.push(member.get("key"));
+ }
+ });
+
+ const hasLeapingChildren = explodingChildren.some(
+ child => meta.containsLeap(child));
+
+ for (let i = 0; i < explodingChildren.length; i++) {
+ const child = explodingChildren[i];
+ const isLast = i === explodingChildren.length - 1;
+
+ if (isLast) {
+ child.replaceWith(this.explodeExpression(child));
+ } else {
+ child.replaceWith(this.explodeViaTempVar(null, child, hasLeapingChildren));
+ }
+ }
+
+ return path.node;
+};
--
Gitblit v1.8.0