diff options
Diffstat (limited to 'node_modules/@babel/traverse/lib/path/replacement.js')
| -rw-r--r-- | node_modules/@babel/traverse/lib/path/replacement.js | 273 |
1 files changed, 273 insertions, 0 deletions
diff --git a/node_modules/@babel/traverse/lib/path/replacement.js b/node_modules/@babel/traverse/lib/path/replacement.js new file mode 100644 index 00000000..011eb312 --- /dev/null +++ b/node_modules/@babel/traverse/lib/path/replacement.js @@ -0,0 +1,273 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.replaceWithMultiple = replaceWithMultiple; +exports.replaceWithSourceString = replaceWithSourceString; +exports.replaceWith = replaceWith; +exports._replaceWith = _replaceWith; +exports.replaceExpressionWithStatements = replaceExpressionWithStatements; +exports.replaceInline = replaceInline; + +function _codeFrame() { + const data = require("@babel/code-frame"); + + _codeFrame = function _codeFrame() { + return data; + }; + + return data; +} + +var _index = _interopRequireDefault(require("../index")); + +var _index2 = _interopRequireDefault(require("./index")); + +function _babylon() { + const data = require("babylon"); + + _babylon = function _babylon() { + return data; + }; + + return data; +} + +function t() { + const data = _interopRequireWildcard(require("@babel/types")); + + t = function t() { + return data; + }; + + return data; +} + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const hoistVariablesVisitor = { + Function(path) { + path.skip(); + }, + + VariableDeclaration(path) { + if (path.node.kind !== "var") return; + const bindings = path.getBindingIdentifiers(); + + for (const key in bindings) { + path.scope.push({ + id: bindings[key] + }); + } + + const exprs = []; + var _arr = path.node.declarations; + + for (var _i = 0; _i < _arr.length; _i++) { + const declar = _arr[_i]; + + if (declar.init) { + exprs.push(t().expressionStatement(t().assignmentExpression("=", declar.id, declar.init))); + } + } + + path.replaceWithMultiple(exprs); + } + +}; + +function replaceWithMultiple(nodes) { + this.resync(); + nodes = this._verifyNodeList(nodes); + t().inheritLeadingComments(nodes[0], this.node); + t().inheritTrailingComments(nodes[nodes.length - 1], 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) { + this.resync(); + + try { + replacement = `(${replacement})`; + replacement = (0, _babylon().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; + } + + replacement = replacement.program.body[0].expression; + + _index.default.removeProperties(replacement); + + return this.replaceWith(replacement); +} + +function replaceWith(replacement) { + this.resync(); + + if (this.removed) { + throw new Error("You can't replace this node, we've already removed it"); + } + + if (replacement instanceof _index2.default) { + replacement = replacement.node; + } + + 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() && !t().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") && t().isExpression(replacement)) { + if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement) && !this.parentPath.isExportDefaultDeclaration()) { + replacement = t().expressionStatement(replacement); + nodePath = "expression"; + } + } + + if (this.isNodeType("Expression") && t().isStatement(replacement)) { + if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement)) { + return this.replaceExpressionWithStatements([replacement]); + } + } + + const oldNode = this.node; + + if (oldNode) { + t().inheritsComments(replacement, oldNode); + t().removeComments(oldNode); + } + + this._replaceWith(replacement); + + this.type = replacement.type; + this.setScope(); + this.requeue(); + return [nodePath ? this.get(nodePath) : this]; +} + +function _replaceWith(node) { + if (!this.container) { + throw new ReferenceError("Container is falsy"); + } + + if (this.inList) { + t().validate(this.parent, this.key, [node]); + } else { + t().validate(this.parent, this.key, node); + } + + this.debug(`Replace with ${node && node.type}`); + this.node = this.container[this.key] = node; +} + +function replaceExpressionWithStatements(nodes) { + this.resync(); + const toSequenceExpression = t().toSequenceExpression(nodes, this.scope); + + if (toSequenceExpression) { + return this.replaceWith(toSequenceExpression)[0].get("expressions"); + } + + const container = t().arrowFunctionExpression([], t().blockStatement(nodes)); + this.replaceWith(t().callExpression(container, [])); + this.traverse(hoistVariablesVisitor); + const completionRecords = this.get("callee").getCompletionRecords(); + + for (var _iterator = completionRecords, _isArray = Array.isArray(_iterator), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i2 >= _iterator.length) break; + _ref = _iterator[_i2++]; + } else { + _i2 = _iterator.next(); + if (_i2.done) break; + _ref = _i2.value; + } + + const path = _ref; + if (!path.isExpressionStatement()) continue; + const loop = path.findParent(path => path.isLoop()); + + if (loop) { + let uid = loop.getData("expressionReplacementReturnUid"); + + if (!uid) { + const callee = this.get("callee"); + uid = callee.scope.generateDeclaredUidIdentifier("ret"); + callee.get("body").pushContainer("body", t().returnStatement(t().cloneNode(uid))); + loop.setData("expressionReplacementReturnUid", uid); + } else { + uid = t().identifier(uid.name); + } + + path.get("expression").replaceWith(t().assignmentExpression("=", t().cloneNode(uid), path.node.expression)); + } else { + path.replaceWith(t().returnStatement(path.node.expression)); + } + } + + const callee = this.get("callee"); + callee.arrowFunctionToExpression(); + return callee.get("body.body"); +} + +function replaceInline(nodes) { + this.resync(); + + if (Array.isArray(nodes)) { + if (Array.isArray(this.container)) { + nodes = this._verifyNodeList(nodes); + + const paths = this._containerInsertAfter(nodes); + + this.remove(); + return paths; + } else { + return this.replaceWithMultiple(nodes); + } + } else { + return this.replaceWith(nodes); + } +}
\ No newline at end of file |