264 lines
9.0 KiB
JavaScript
264 lines
9.0 KiB
JavaScript
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports._replaceWith = _replaceWith;
|
|
exports.replaceExpressionWithStatements = replaceExpressionWithStatements;
|
|
exports.replaceInline = replaceInline;
|
|
exports.replaceWith = replaceWith;
|
|
exports.replaceWithMultiple = replaceWithMultiple;
|
|
exports.replaceWithSourceString = replaceWithSourceString;
|
|
var _codeFrame = require("@babel/code-frame");
|
|
var _index = require("../index.js");
|
|
var _index2 = require("./index.js");
|
|
var _cache = require("../cache.js");
|
|
var _modification = require("./modification.js");
|
|
var _parser = require("@babel/parser");
|
|
var _t = require("@babel/types");
|
|
var _context = require("./context.js");
|
|
const {
|
|
FUNCTION_TYPES,
|
|
arrowFunctionExpression,
|
|
assignmentExpression,
|
|
awaitExpression,
|
|
blockStatement,
|
|
buildUndefinedNode,
|
|
callExpression,
|
|
cloneNode,
|
|
conditionalExpression,
|
|
expressionStatement,
|
|
getBindingIdentifiers,
|
|
identifier,
|
|
inheritLeadingComments,
|
|
inheritTrailingComments,
|
|
inheritsComments,
|
|
isBlockStatement,
|
|
isEmptyStatement,
|
|
isExpression,
|
|
isExpressionStatement,
|
|
isIfStatement,
|
|
isProgram,
|
|
isStatement,
|
|
isVariableDeclaration,
|
|
removeComments,
|
|
returnStatement,
|
|
sequenceExpression,
|
|
validate,
|
|
yieldExpression
|
|
} = _t;
|
|
function replaceWithMultiple(nodes) {
|
|
var _getCachedPaths;
|
|
_context.resync.call(this);
|
|
const verifiedNodes = _modification._verifyNodeList.call(this, nodes);
|
|
inheritLeadingComments(verifiedNodes[0], this.node);
|
|
inheritTrailingComments(verifiedNodes[verifiedNodes.length - 1], this.node);
|
|
(_getCachedPaths = (0, _cache.getCachedPaths)(this)) == null || _getCachedPaths.delete(this.node);
|
|
this.node = this.container[this.key] = null;
|
|
const paths = this.insertAfter(nodes);
|
|
if (this.node) {
|
|
this.requeue();
|
|
} else {
|
|
this.remove();
|
|
}
|
|
return paths;
|
|
}
|
|
function replaceWithSourceString(replacement) {
|
|
_context.resync.call(this);
|
|
let ast;
|
|
try {
|
|
replacement = `(${replacement})`;
|
|
ast = (0, _parser.parse)(replacement);
|
|
} catch (err) {
|
|
const loc = err.loc;
|
|
if (loc) {
|
|
err.message += " - make sure this is an expression.\n" + (0, _codeFrame.codeFrameColumns)(replacement, {
|
|
start: {
|
|
line: loc.line,
|
|
column: loc.column + 1
|
|
}
|
|
});
|
|
err.code = "BABEL_REPLACE_SOURCE_ERROR";
|
|
}
|
|
throw err;
|
|
}
|
|
const expressionAST = ast.program.body[0].expression;
|
|
_index.default.removeProperties(expressionAST);
|
|
return this.replaceWith(expressionAST);
|
|
}
|
|
function replaceWith(replacementPath) {
|
|
_context.resync.call(this);
|
|
if (this.removed) {
|
|
throw new Error("You can't replace this node, we've already removed it");
|
|
}
|
|
let replacement = replacementPath instanceof _index2.default ? replacementPath.node : replacementPath;
|
|
if (!replacement) {
|
|
throw new Error("You passed `path.replaceWith()` a falsy node, use `path.remove()` instead");
|
|
}
|
|
if (this.node === replacement) {
|
|
return [this];
|
|
}
|
|
if (this.isProgram() && !isProgram(replacement)) {
|
|
throw new Error("You can only replace a Program root node with another Program node");
|
|
}
|
|
if (Array.isArray(replacement)) {
|
|
throw new Error("Don't use `path.replaceWith()` with an array of nodes, use `path.replaceWithMultiple()`");
|
|
}
|
|
if (typeof replacement === "string") {
|
|
throw new Error("Don't use `path.replaceWith()` with a source string, use `path.replaceWithSourceString()`");
|
|
}
|
|
let nodePath = "";
|
|
if (this.isNodeType("Statement") && isExpression(replacement)) {
|
|
if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement) && !this.parentPath.isExportDefaultDeclaration()) {
|
|
replacement = expressionStatement(replacement);
|
|
nodePath = "expression";
|
|
}
|
|
}
|
|
if (this.isNodeType("Expression") && isStatement(replacement)) {
|
|
if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement)) {
|
|
return this.replaceExpressionWithStatements([replacement]);
|
|
}
|
|
}
|
|
const oldNode = this.node;
|
|
if (oldNode) {
|
|
inheritsComments(replacement, oldNode);
|
|
removeComments(oldNode);
|
|
}
|
|
_replaceWith.call(this, replacement);
|
|
this.type = replacement.type;
|
|
_context.setScope.call(this);
|
|
this.requeue();
|
|
return [nodePath ? this.get(nodePath) : this];
|
|
}
|
|
function _replaceWith(node) {
|
|
var _getCachedPaths2;
|
|
if (!this.container) {
|
|
throw new ReferenceError("Container is falsy");
|
|
}
|
|
if (this.inList) {
|
|
validate(this.parent, this.key, [node]);
|
|
} else {
|
|
validate(this.parent, this.key, node);
|
|
}
|
|
this.debug(`Replace with ${node == null ? void 0 : node.type}`);
|
|
(_getCachedPaths2 = (0, _cache.getCachedPaths)(this)) == null || _getCachedPaths2.set(node, this).delete(this.node);
|
|
this.node = this.container[this.key] = node;
|
|
}
|
|
function replaceExpressionWithStatements(nodes) {
|
|
_context.resync.call(this);
|
|
const declars = [];
|
|
const nodesAsSingleExpression = gatherSequenceExpressions(nodes, declars);
|
|
if (nodesAsSingleExpression) {
|
|
for (const id of declars) this.scope.push({
|
|
id
|
|
});
|
|
return this.replaceWith(nodesAsSingleExpression)[0].get("expressions");
|
|
}
|
|
const functionParent = this.getFunctionParent();
|
|
const isParentAsync = functionParent == null ? void 0 : functionParent.node.async;
|
|
const isParentGenerator = functionParent == null ? void 0 : functionParent.node.generator;
|
|
const container = arrowFunctionExpression([], blockStatement(nodes));
|
|
this.replaceWith(callExpression(container, []));
|
|
const callee = this.get("callee");
|
|
callee.get("body").scope.hoistVariables(id => this.scope.push({
|
|
id
|
|
}));
|
|
const completionRecords = callee.getCompletionRecords();
|
|
for (const path of completionRecords) {
|
|
if (!path.isExpressionStatement()) continue;
|
|
const loop = path.findParent(path => path.isLoop());
|
|
if (loop) {
|
|
let uid = loop.getData("expressionReplacementReturnUid");
|
|
if (!uid) {
|
|
uid = callee.scope.generateDeclaredUidIdentifier("ret");
|
|
callee.get("body").pushContainer("body", returnStatement(cloneNode(uid)));
|
|
loop.setData("expressionReplacementReturnUid", uid);
|
|
} else {
|
|
uid = identifier(uid.name);
|
|
}
|
|
path.get("expression").replaceWith(assignmentExpression("=", cloneNode(uid), path.node.expression));
|
|
} else {
|
|
path.replaceWith(returnStatement(path.node.expression));
|
|
}
|
|
}
|
|
callee.arrowFunctionToExpression();
|
|
const newCallee = callee;
|
|
const needToAwaitFunction = isParentAsync && _index.default.hasType(this.get("callee.body").node, "AwaitExpression", FUNCTION_TYPES);
|
|
const needToYieldFunction = isParentGenerator && _index.default.hasType(this.get("callee.body").node, "YieldExpression", FUNCTION_TYPES);
|
|
if (needToAwaitFunction) {
|
|
newCallee.set("async", true);
|
|
if (!needToYieldFunction) {
|
|
this.replaceWith(awaitExpression(this.node));
|
|
}
|
|
}
|
|
if (needToYieldFunction) {
|
|
newCallee.set("generator", true);
|
|
this.replaceWith(yieldExpression(this.node, true));
|
|
}
|
|
return newCallee.get("body.body");
|
|
}
|
|
function gatherSequenceExpressions(nodes, declars) {
|
|
const exprs = [];
|
|
let ensureLastUndefined = true;
|
|
for (const node of nodes) {
|
|
if (!isEmptyStatement(node)) {
|
|
ensureLastUndefined = false;
|
|
}
|
|
if (isExpression(node)) {
|
|
exprs.push(node);
|
|
} else if (isExpressionStatement(node)) {
|
|
exprs.push(node.expression);
|
|
} else if (isVariableDeclaration(node)) {
|
|
if (node.kind !== "var") return;
|
|
for (const declar of node.declarations) {
|
|
const bindings = getBindingIdentifiers(declar);
|
|
for (const key of Object.keys(bindings)) {
|
|
declars.push(cloneNode(bindings[key]));
|
|
}
|
|
if (declar.init) {
|
|
exprs.push(assignmentExpression("=", declar.id, declar.init));
|
|
}
|
|
}
|
|
ensureLastUndefined = true;
|
|
} else if (isIfStatement(node)) {
|
|
const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], declars) : buildUndefinedNode();
|
|
const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], declars) : buildUndefinedNode();
|
|
if (!consequent || !alternate) return;
|
|
exprs.push(conditionalExpression(node.test, consequent, alternate));
|
|
} else if (isBlockStatement(node)) {
|
|
const body = gatherSequenceExpressions(node.body, declars);
|
|
if (!body) return;
|
|
exprs.push(body);
|
|
} else if (isEmptyStatement(node)) {
|
|
if (nodes.indexOf(node) === 0) {
|
|
ensureLastUndefined = true;
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
if (ensureLastUndefined) exprs.push(buildUndefinedNode());
|
|
if (exprs.length === 1) {
|
|
return exprs[0];
|
|
} else {
|
|
return sequenceExpression(exprs);
|
|
}
|
|
}
|
|
function replaceInline(nodes) {
|
|
_context.resync.call(this);
|
|
if (Array.isArray(nodes)) {
|
|
if (Array.isArray(this.container)) {
|
|
nodes = _modification._verifyNodeList.call(this, nodes);
|
|
const paths = _modification._containerInsertAfter.call(this, nodes);
|
|
this.remove();
|
|
return paths;
|
|
} else {
|
|
return this.replaceWithMultiple(nodes);
|
|
}
|
|
} else {
|
|
return this.replaceWith(nodes);
|
|
}
|
|
}
|
|
|
|
//# sourceMappingURL=replacement.js.map
|