"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
value: true
|
});
|
exports.default = void 0;
|
|
var _binding = require("../binding");
|
|
var _helperSplitExportDeclaration = require("@babel/helper-split-export-declaration");
|
|
var _t = require("@babel/types");
|
|
const {
|
VISITOR_KEYS,
|
assignmentExpression,
|
identifier,
|
toExpression,
|
variableDeclaration,
|
variableDeclarator
|
} = _t;
|
const renameVisitor = {
|
ReferencedIdentifier({
|
node
|
}, state) {
|
if (node.name === state.oldName) {
|
node.name = state.newName;
|
}
|
},
|
|
Scope(path, state) {
|
if (!path.scope.bindingIdentifierEquals(state.oldName, state.binding.identifier)) {
|
skipAllButComputedMethodKey(path);
|
}
|
},
|
|
"AssignmentExpression|Declaration|VariableDeclarator"(path, state) {
|
if (path.isVariableDeclaration()) return;
|
const ids = path.getOuterBindingIdentifiers();
|
|
for (const name in ids) {
|
if (name === state.oldName) ids[name].name = state.newName;
|
}
|
}
|
|
};
|
|
class Renamer {
|
constructor(binding, oldName, newName) {
|
this.newName = newName;
|
this.oldName = oldName;
|
this.binding = binding;
|
}
|
|
maybeConvertFromExportDeclaration(parentDeclar) {
|
const maybeExportDeclar = parentDeclar.parentPath;
|
|
if (!maybeExportDeclar.isExportDeclaration()) {
|
return;
|
}
|
|
if (maybeExportDeclar.isExportDefaultDeclaration() && !maybeExportDeclar.get("declaration").node.id) {
|
return;
|
}
|
|
(0, _helperSplitExportDeclaration.default)(maybeExportDeclar);
|
}
|
|
maybeConvertFromClassFunctionDeclaration(path) {
|
return;
|
if (!path.isFunctionDeclaration() && !path.isClassDeclaration()) return;
|
if (this.binding.kind !== "hoisted") return;
|
path.node.id = identifier(this.oldName);
|
path.node._blockHoist = 3;
|
path.replaceWith(variableDeclaration("let", [variableDeclarator(identifier(this.newName), toExpression(path.node))]));
|
}
|
|
maybeConvertFromClassFunctionExpression(path) {
|
return;
|
if (!path.isFunctionExpression() && !path.isClassExpression()) return;
|
if (this.binding.kind !== "local") return;
|
path.node.id = identifier(this.oldName);
|
this.binding.scope.parent.push({
|
id: identifier(this.newName)
|
});
|
path.replaceWith(assignmentExpression("=", identifier(this.newName), path.node));
|
}
|
|
rename(block) {
|
const {
|
binding,
|
oldName,
|
newName
|
} = this;
|
const {
|
scope,
|
path
|
} = binding;
|
const parentDeclar = path.find(path => path.isDeclaration() || path.isFunctionExpression() || path.isClassExpression());
|
|
if (parentDeclar) {
|
const bindingIds = parentDeclar.getOuterBindingIdentifiers();
|
|
if (bindingIds[oldName] === binding.identifier) {
|
this.maybeConvertFromExportDeclaration(parentDeclar);
|
}
|
}
|
|
const blockToTraverse = block || scope.block;
|
|
if ((blockToTraverse == null ? void 0 : blockToTraverse.type) === "SwitchStatement") {
|
blockToTraverse.cases.forEach(c => {
|
scope.traverse(c, renameVisitor, this);
|
});
|
} else {
|
scope.traverse(blockToTraverse, renameVisitor, this);
|
}
|
|
if (!block) {
|
scope.removeOwnBinding(oldName);
|
scope.bindings[newName] = binding;
|
this.binding.identifier.name = newName;
|
}
|
|
if (parentDeclar) {
|
this.maybeConvertFromClassFunctionDeclaration(parentDeclar);
|
this.maybeConvertFromClassFunctionExpression(parentDeclar);
|
}
|
}
|
|
}
|
|
exports.default = Renamer;
|
|
function skipAllButComputedMethodKey(path) {
|
if (!path.isMethod() || !path.node.computed) {
|
path.skip();
|
return;
|
}
|
|
const keys = VISITOR_KEYS[path.type];
|
|
for (const key of keys) {
|
if (key !== "key") path.skipKey(key);
|
}
|
}
|
