Diffusion Open Access Compliance Check Tool (OACCT) (paginated-inlines) Browse

rOACCT/node_modules/babel-traverse/lib/path/replacement.js
f646e1f695a7paginated-inlines

replacement.js
View Options

			"use strict";

			exports.__esModule = true;

			var _getIterator2 = require("babel-runtime/core-js/get-iterator");

			var _getIterator3 = _interopRequireDefault(_getIterator2);

			exports.replaceWithMultiple = replaceWithMultiple;
			exports.replaceWithSourceString = replaceWithSourceString;
			exports.replaceWith = replaceWith;
			exports._replaceWith = _replaceWith;
			exports.replaceExpressionWithStatements = replaceExpressionWithStatements;
			exports.replaceInline = replaceInline;

			var _babelCodeFrame = require("babel-code-frame");

			var _babelCodeFrame2 = _interopRequireDefault(_babelCodeFrame);

			var _index = require("../index");

			var _index2 = _interopRequireDefault(_index);

			var _index3 = require("./index");

			var _index4 = _interopRequireDefault(_index3);

			var _babylon = require("babylon");

			var _babelTypes = require("babel-types");

			var t = _interopRequireWildcard(_babelTypes);

			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)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

			function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

			var hoistVariablesVisitor = {
			Function: function Function(path) {
			path.skip();
			},
			VariableDeclaration: function VariableDeclaration(path) {
			if (path.node.kind !== "var") return;

			var bindings = path.getBindingIdentifiers();
			for (var key in bindings) {
			path.scope.push({ id: bindings[key] });
			}

			var exprs = [];

			for (var _iterator = path.node.declarations, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
			var _ref;

			if (_isArray) {
			if (_i >= _iterator.length) break;
			_ref = _iterator[_i++];
			} else {
			_i = _iterator.next();
			if (_i.done) break;
			_ref = _i.value;
			}

			var declar = _ref;

			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;
			this.insertAfter(nodes);

			if (this.node) {
			this.requeue();
			} else {
			this.remove();
			}
			}

			function replaceWithSourceString(replacement) {
			this.resync();

			try {
			replacement = "(" + replacement + ")";
			replacement = (0, _babylon.parse)(replacement);
			} catch (err) {
			var loc = err.loc;
			if (loc) {
			err.message += " - make sure this is an expression.";
			err.message += "\n" + (0, _babelCodeFrame2.default)(replacement, loc.line, loc.column + 1);
			}
			throw err;
			}

			replacement = replacement.program.body[0].expression;
			_index2.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 _index4.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;
			}

			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()`");
			}

			if (this.isNodeType("Statement") && t.isExpression(replacement)) {
			if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement) && !this.parentPath.isExportDefaultDeclaration()) {
			replacement = t.expressionStatement(replacement);
			}
			}

			if (this.isNodeType("Expression") && t.isStatement(replacement)) {
			if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement)) {
			return this.replaceExpressionWithStatements([replacement]);
			}
			}

			var oldNode = this.node;
			if (oldNode) {
			t.inheritsComments(replacement, oldNode);
			t.removeComments(oldNode);
			}

			this._replaceWith(replacement);
			this.type = replacement.type;

			this.setScope();

			this.requeue();
			}

			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(function () {
			return "Replace with " + (node && node.type);
			});

			this.node = this.container[this.key] = node;
			}

			function replaceExpressionWithStatements(nodes) {
			this.resync();

			var toSequenceExpression = t.toSequenceExpression(nodes, this.scope);

			if (t.isSequenceExpression(toSequenceExpression)) {
			var exprs = toSequenceExpression.expressions;

			if (exprs.length >= 2 && this.parentPath.isExpressionStatement()) {
			this._maybePopFromStatements(exprs);
			}

			if (exprs.length === 1) {
			this.replaceWith(exprs[0]);
			} else {
			this.replaceWith(toSequenceExpression);
			}
			} else if (toSequenceExpression) {
			this.replaceWith(toSequenceExpression);
			} else {
			var container = t.functionExpression(null, [], t.blockStatement(nodes));
			container.shadow = true;

			this.replaceWith(t.callExpression(container, []));
			this.traverse(hoistVariablesVisitor);

			var completionRecords = this.get("callee").getCompletionRecords();
			for (var _iterator2 = completionRecords, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) {
			var _ref2;

			if (_isArray2) {
			if (_i2 >= _iterator2.length) break;
			_ref2 = _iterator2[_i2++];
			} else {
			_i2 = _iterator2.next();
			if (_i2.done) break;
			_ref2 = _i2.value;
			}

			var path = _ref2;

			if (!path.isExpressionStatement()) continue;

			var loop = path.findParent(function (path) {
			return path.isLoop();
			});
			if (loop) {
			var uid = loop.getData("expressionReplacementReturnUid");

			if (!uid) {
			var callee = this.get("callee");
			uid = callee.scope.generateDeclaredUidIdentifier("ret");
			callee.get("body").pushContainer("body", t.returnStatement(uid));
			loop.setData("expressionReplacementReturnUid", uid);
			} else {
			uid = t.identifier(uid.name);
			}

			path.get("expression").replaceWith(t.assignmentExpression("=", uid, path.node.expression));
			} else {
			path.replaceWith(t.returnStatement(path.node.expression));
			}
			}

			return this.node;
			}
			}

			function replaceInline(nodes) {
			this.resync();

			if (Array.isArray(nodes)) {
			if (Array.isArray(this.container)) {
			nodes = this._verifyNodeList(nodes);
			this._containerInsertAfter(nodes);
			return this.remove();
			} else {
			return this.replaceWithMultiple(nodes);
			}
			} else {
			return this.replaceWith(nodes);
			}
			}