mirror of
https://github.com/actions/setup-python.git
synced 2024-12-24 13:14:23 +00:00
258 lines
No EOL
6.9 KiB
JavaScript
258 lines
No EOL
6.9 KiB
JavaScript
"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 () {
|
|
return data;
|
|
};
|
|
|
|
return data;
|
|
}
|
|
|
|
var _index = _interopRequireDefault(require("../index"));
|
|
|
|
var _index2 = _interopRequireDefault(require("./index"));
|
|
|
|
function _parser() {
|
|
const data = require("@babel/parser");
|
|
|
|
_parser = function () {
|
|
return data;
|
|
};
|
|
|
|
return data;
|
|
}
|
|
|
|
function t() {
|
|
const data = _interopRequireWildcard(require("@babel/types"));
|
|
|
|
t = function () {
|
|
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 of Object.keys(bindings)) {
|
|
path.scope.push({
|
|
id: bindings[key]
|
|
});
|
|
}
|
|
|
|
const exprs = [];
|
|
|
|
for (const declar of path.node.declarations) {
|
|
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, _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;
|
|
}
|
|
|
|
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 (const path of completionRecords) {
|
|
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);
|
|
}
|
|
} |