diff options
Diffstat (limited to 'node_modules/@babel/traverse/lib/scope')
| -rw-r--r-- | node_modules/@babel/traverse/lib/scope/binding.js | 71 | ||||
| -rw-r--r-- | node_modules/@babel/traverse/lib/scope/index.js | 1006 | ||||
| -rw-r--r-- | node_modules/@babel/traverse/lib/scope/lib/renamer.js | 130 |
3 files changed, 1207 insertions, 0 deletions
diff --git a/node_modules/@babel/traverse/lib/scope/binding.js b/node_modules/@babel/traverse/lib/scope/binding.js new file mode 100644 index 00000000..d19f1168 --- /dev/null +++ b/node_modules/@babel/traverse/lib/scope/binding.js @@ -0,0 +1,71 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +class Binding { + constructor({ + identifier, + scope, + path, + kind + }) { + this.identifier = identifier; + this.scope = scope; + this.path = path; + this.kind = kind; + this.constantViolations = []; + this.constant = true; + this.referencePaths = []; + this.referenced = false; + this.references = 0; + this.clearValue(); + } + + deoptValue() { + this.clearValue(); + this.hasDeoptedValue = true; + } + + setValue(value) { + if (this.hasDeoptedValue) return; + this.hasValue = true; + this.value = value; + } + + clearValue() { + this.hasDeoptedValue = false; + this.hasValue = false; + this.value = null; + } + + reassign(path) { + this.constant = false; + + if (this.constantViolations.indexOf(path) !== -1) { + return; + } + + this.constantViolations.push(path); + } + + reference(path) { + if (this.referencePaths.indexOf(path) !== -1) { + return; + } + + this.referenced = true; + this.references++; + this.referencePaths.push(path); + } + + dereference() { + this.references--; + this.referenced = !!this.references; + } + +} + +exports.default = Binding;
\ No newline at end of file diff --git a/node_modules/@babel/traverse/lib/scope/index.js b/node_modules/@babel/traverse/lib/scope/index.js new file mode 100644 index 00000000..4c200ba6 --- /dev/null +++ b/node_modules/@babel/traverse/lib/scope/index.js @@ -0,0 +1,1006 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +function _includes() { + const data = _interopRequireDefault(require("lodash/includes")); + + _includes = function _includes() { + return data; + }; + + return data; +} + +function _repeat() { + const data = _interopRequireDefault(require("lodash/repeat")); + + _repeat = function _repeat() { + return data; + }; + + return data; +} + +var _renamer = _interopRequireDefault(require("./lib/renamer")); + +var _index = _interopRequireDefault(require("../index")); + +function _defaults() { + const data = _interopRequireDefault(require("lodash/defaults")); + + _defaults = function _defaults() { + return data; + }; + + return data; +} + +var _binding = _interopRequireDefault(require("./binding")); + +function _globals() { + const data = _interopRequireDefault(require("globals")); + + _globals = function _globals() { + return data; + }; + + return data; +} + +function t() { + const data = _interopRequireWildcard(require("@babel/types")); + + t = function t() { + return data; + }; + + return data; +} + +var _cache = require("../cache"); + +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 }; } + +function gatherNodeParts(node, parts) { + if (t().isModuleDeclaration(node)) { + if (node.source) { + gatherNodeParts(node.source, parts); + } else if (node.specifiers && node.specifiers.length) { + var _arr = node.specifiers; + + for (var _i = 0; _i < _arr.length; _i++) { + const specifier = _arr[_i]; + gatherNodeParts(specifier, parts); + } + } else if (node.declaration) { + gatherNodeParts(node.declaration, parts); + } + } else if (t().isModuleSpecifier(node)) { + gatherNodeParts(node.local, parts); + } else if (t().isMemberExpression(node)) { + gatherNodeParts(node.object, parts); + gatherNodeParts(node.property, parts); + } else if (t().isIdentifier(node)) { + parts.push(node.name); + } else if (t().isLiteral(node)) { + parts.push(node.value); + } else if (t().isCallExpression(node)) { + gatherNodeParts(node.callee, parts); + } else if (t().isObjectExpression(node) || t().isObjectPattern(node)) { + var _arr2 = node.properties; + + for (var _i2 = 0; _i2 < _arr2.length; _i2++) { + const prop = _arr2[_i2]; + gatherNodeParts(prop.key || prop.argument, parts); + } + } else if (t().isPrivateName(node)) { + gatherNodeParts(node.id, parts); + } else if (t().isThisExpression(node)) { + parts.push("this"); + } else if (t().isSuper(node)) { + parts.push("super"); + } +} + +const collectorVisitor = { + For(path) { + var _arr3 = t().FOR_INIT_KEYS; + + for (var _i3 = 0; _i3 < _arr3.length; _i3++) { + const key = _arr3[_i3]; + const declar = path.get(key); + + if (declar.isVar()) { + const parentScope = path.scope.getFunctionParent() || path.scope.getProgramParent(); + parentScope.registerBinding("var", declar); + } + } + }, + + Declaration(path) { + if (path.isBlockScoped()) return; + + if (path.isExportDeclaration() && path.get("declaration").isDeclaration()) { + return; + } + + const parent = path.scope.getFunctionParent() || path.scope.getProgramParent(); + parent.registerDeclaration(path); + }, + + ReferencedIdentifier(path, state) { + state.references.push(path); + }, + + ForXStatement(path, state) { + const left = path.get("left"); + + if (left.isPattern() || left.isIdentifier()) { + state.constantViolations.push(path); + } + }, + + ExportDeclaration: { + exit(path) { + const node = path.node, + scope = path.scope; + const declar = node.declaration; + + if (t().isClassDeclaration(declar) || t().isFunctionDeclaration(declar)) { + const id = declar.id; + if (!id) return; + const binding = scope.getBinding(id.name); + if (binding) binding.reference(path); + } else if (t().isVariableDeclaration(declar)) { + var _arr4 = declar.declarations; + + for (var _i4 = 0; _i4 < _arr4.length; _i4++) { + const decl = _arr4[_i4]; + const ids = t().getBindingIdentifiers(decl); + + for (const name in ids) { + const binding = scope.getBinding(name); + if (binding) binding.reference(path); + } + } + } + } + + }, + + LabeledStatement(path) { + path.scope.getProgramParent().addGlobal(path.node); + path.scope.getBlockParent().registerDeclaration(path); + }, + + AssignmentExpression(path, state) { + state.assignments.push(path); + }, + + UpdateExpression(path, state) { + state.constantViolations.push(path); + }, + + UnaryExpression(path, state) { + if (path.node.operator === "delete") { + state.constantViolations.push(path); + } + }, + + BlockScoped(path) { + let scope = path.scope; + if (scope.path === path) scope = scope.parent; + scope.getBlockParent().registerDeclaration(path); + }, + + ClassDeclaration(path) { + const id = path.node.id; + if (!id) return; + const name = id.name; + path.scope.bindings[name] = path.scope.getBinding(name); + }, + + Block(path) { + const paths = path.get("body"); + var _arr5 = paths; + + for (var _i5 = 0; _i5 < _arr5.length; _i5++) { + const bodyPath = _arr5[_i5]; + + if (bodyPath.isFunctionDeclaration()) { + path.scope.getBlockParent().registerDeclaration(bodyPath); + } + } + } + +}; +let uid = 0; + +class Scope { + constructor(path) { + const node = path.node; + + const cached = _cache.scope.get(node); + + if (cached && cached.path === path) { + return cached; + } + + _cache.scope.set(node, this); + + this.uid = uid++; + this.block = node; + this.path = path; + this.labels = new Map(); + } + + get parent() { + const parent = this.path.findParent(p => p.isScope()); + return parent && parent.scope; + } + + get parentBlock() { + return this.path.parent; + } + + get hub() { + return this.path.hub; + } + + traverse(node, opts, state) { + (0, _index.default)(node, opts, this, state, this.path); + } + + generateDeclaredUidIdentifier(name) { + const id = this.generateUidIdentifier(name); + this.push({ + id + }); + return t().cloneNode(id); + } + + generateUidIdentifier(name) { + return t().identifier(this.generateUid(name)); + } + + generateUid(name = "temp") { + name = t().toIdentifier(name).replace(/^_+/, "").replace(/[0-9]+$/g, ""); + let uid; + let i = 0; + + do { + uid = this._generateUid(name, i); + i++; + } while (this.hasLabel(uid) || this.hasBinding(uid) || this.hasGlobal(uid) || this.hasReference(uid)); + + const program = this.getProgramParent(); + program.references[uid] = true; + program.uids[uid] = true; + return uid; + } + + _generateUid(name, i) { + let id = name; + if (i > 1) id += i; + return `_${id}`; + } + + generateUidBasedOnNode(parent, defaultName) { + let node = parent; + + if (t().isAssignmentExpression(parent)) { + node = parent.left; + } else if (t().isVariableDeclarator(parent)) { + node = parent.id; + } else if (t().isObjectProperty(node) || t().isObjectMethod(node)) { + node = node.key; + } + + const parts = []; + gatherNodeParts(node, parts); + let id = parts.join("$"); + id = id.replace(/^_/, "") || defaultName || "ref"; + return this.generateUid(id.slice(0, 20)); + } + + generateUidIdentifierBasedOnNode(parent, defaultName) { + return t().identifier(this.generateUidBasedOnNode(parent, defaultName)); + } + + isStatic(node) { + if (t().isThisExpression(node) || t().isSuper(node)) { + return true; + } + + if (t().isIdentifier(node)) { + const binding = this.getBinding(node.name); + + if (binding) { + return binding.constant; + } else { + return this.hasBinding(node.name); + } + } + + return false; + } + + maybeGenerateMemoised(node, dontPush) { + if (this.isStatic(node)) { + return null; + } else { + const id = this.generateUidIdentifierBasedOnNode(node); + + if (!dontPush) { + this.push({ + id + }); + return t().cloneNode(id); + } + + return id; + } + } + + checkBlockScopedCollisions(local, kind, name, id) { + if (kind === "param") return; + if (local.kind === "local") return; + if (kind === "hoisted" && local.kind === "let") return; + const duplicate = kind === "let" || local.kind === "let" || local.kind === "const" || local.kind === "module" || local.kind === "param" && (kind === "let" || kind === "const"); + + if (duplicate) { + throw this.hub.file.buildCodeFrameError(id, `Duplicate declaration "${name}"`, TypeError); + } + } + + rename(oldName, newName, block) { + const binding = this.getBinding(oldName); + + if (binding) { + newName = newName || this.generateUidIdentifier(oldName).name; + return new _renamer.default(binding, oldName, newName).rename(block); + } + } + + _renameFromMap(map, oldName, newName, value) { + if (map[oldName]) { + map[newName] = value; + map[oldName] = null; + } + } + + dump() { + const sep = (0, _repeat().default)("-", 60); + console.log(sep); + let scope = this; + + do { + console.log("#", scope.block.type); + + for (const name in scope.bindings) { + const binding = scope.bindings[name]; + console.log(" -", name, { + constant: binding.constant, + references: binding.references, + violations: binding.constantViolations.length, + kind: binding.kind + }); + } + } while (scope = scope.parent); + + console.log(sep); + } + + toArray(node, i) { + const file = this.hub.file; + + if (t().isIdentifier(node)) { + const binding = this.getBinding(node.name); + + if (binding && binding.constant && binding.path.isGenericType("Array")) { + return node; + } + } + + if (t().isArrayExpression(node)) { + return node; + } + + if (t().isIdentifier(node, { + name: "arguments" + })) { + return t().callExpression(t().memberExpression(t().memberExpression(t().memberExpression(t().identifier("Array"), t().identifier("prototype")), t().identifier("slice")), t().identifier("call")), [node]); + } + + let helperName; + const args = [node]; + + if (i === true) { + helperName = "toConsumableArray"; + } else if (i) { + args.push(t().numericLiteral(i)); + helperName = "slicedToArray"; + } else { + helperName = "toArray"; + } + + return t().callExpression(file.addHelper(helperName), args); + } + + hasLabel(name) { + return !!this.getLabel(name); + } + + getLabel(name) { + return this.labels.get(name); + } + + registerLabel(path) { + this.labels.set(path.node.label.name, path); + } + + registerDeclaration(path) { + if (path.isFlow()) return; + + if (path.isLabeledStatement()) { + this.registerLabel(path); + } else if (path.isFunctionDeclaration()) { + this.registerBinding("hoisted", path.get("id"), path); + } else if (path.isVariableDeclaration()) { + const declarations = path.get("declarations"); + var _arr6 = declarations; + + for (var _i6 = 0; _i6 < _arr6.length; _i6++) { + const declar = _arr6[_i6]; + this.registerBinding(path.node.kind, declar); + } + } else if (path.isClassDeclaration()) { + this.registerBinding("let", path); + } else if (path.isImportDeclaration()) { + const specifiers = path.get("specifiers"); + var _arr7 = specifiers; + + for (var _i7 = 0; _i7 < _arr7.length; _i7++) { + const specifier = _arr7[_i7]; + this.registerBinding("module", specifier); + } + } else if (path.isExportDeclaration()) { + const declar = path.get("declaration"); + + if (declar.isClassDeclaration() || declar.isFunctionDeclaration() || declar.isVariableDeclaration()) { + this.registerDeclaration(declar); + } + } else { + this.registerBinding("unknown", path); + } + } + + buildUndefinedNode() { + if (this.hasBinding("undefined")) { + return t().unaryExpression("void", t().numericLiteral(0), true); + } else { + return t().identifier("undefined"); + } + } + + registerConstantViolation(path) { + const ids = path.getBindingIdentifiers(); + + for (const name in ids) { + const binding = this.getBinding(name); + if (binding) binding.reassign(path); + } + } + + registerBinding(kind, path, bindingPath = path) { + if (!kind) throw new ReferenceError("no `kind`"); + + if (path.isVariableDeclaration()) { + const declarators = path.get("declarations"); + + for (var _iterator = declarators, _isArray = Array.isArray(_iterator), _i8 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i8 >= _iterator.length) break; + _ref = _iterator[_i8++]; + } else { + _i8 = _iterator.next(); + if (_i8.done) break; + _ref = _i8.value; + } + + const declar = _ref; + this.registerBinding(kind, declar); + } + + return; + } + + const parent = this.getProgramParent(); + const ids = path.getBindingIdentifiers(true); + + for (const name in ids) { + var _arr8 = ids[name]; + + for (var _i9 = 0; _i9 < _arr8.length; _i9++) { + const id = _arr8[_i9]; + const local = this.getOwnBinding(name); + + if (local) { + if (local.identifier === id) continue; + this.checkBlockScopedCollisions(local, kind, name, id); + } + + parent.references[name] = true; + + if (local) { + this.registerConstantViolation(bindingPath); + } else { + this.bindings[name] = new _binding.default({ + identifier: id, + scope: this, + path: bindingPath, + kind: kind + }); + } + } + } + } + + addGlobal(node) { + this.globals[node.name] = node; + } + + hasUid(name) { + let scope = this; + + do { + if (scope.uids[name]) return true; + } while (scope = scope.parent); + + return false; + } + + hasGlobal(name) { + let scope = this; + + do { + if (scope.globals[name]) return true; + } while (scope = scope.parent); + + return false; + } + + hasReference(name) { + let scope = this; + + do { + if (scope.references[name]) return true; + } while (scope = scope.parent); + + return false; + } + + isPure(node, constantsOnly) { + if (t().isIdentifier(node)) { + const binding = this.getBinding(node.name); + if (!binding) return false; + if (constantsOnly) return binding.constant; + return true; + } else if (t().isClass(node)) { + if (node.superClass && !this.isPure(node.superClass, constantsOnly)) { + return false; + } + + return this.isPure(node.body, constantsOnly); + } else if (t().isClassBody(node)) { + for (var _iterator2 = node.body, _isArray2 = Array.isArray(_iterator2), _i10 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) { + var _ref2; + + if (_isArray2) { + if (_i10 >= _iterator2.length) break; + _ref2 = _iterator2[_i10++]; + } else { + _i10 = _iterator2.next(); + if (_i10.done) break; + _ref2 = _i10.value; + } + + const method = _ref2; + if (!this.isPure(method, constantsOnly)) return false; + } + + return true; + } else if (t().isBinary(node)) { + return this.isPure(node.left, constantsOnly) && this.isPure(node.right, constantsOnly); + } else if (t().isArrayExpression(node)) { + var _arr9 = node.elements; + + for (var _i11 = 0; _i11 < _arr9.length; _i11++) { + const elem = _arr9[_i11]; + if (!this.isPure(elem, constantsOnly)) return false; + } + + return true; + } else if (t().isObjectExpression(node)) { + var _arr10 = node.properties; + + for (var _i12 = 0; _i12 < _arr10.length; _i12++) { + const prop = _arr10[_i12]; + if (!this.isPure(prop, constantsOnly)) return false; + } + + return true; + } else if (t().isClassMethod(node)) { + if (node.computed && !this.isPure(node.key, constantsOnly)) return false; + if (node.kind === "get" || node.kind === "set") return false; + return true; + } else if (t().isProperty(node)) { + if (node.computed && !this.isPure(node.key, constantsOnly)) return false; + return this.isPure(node.value, constantsOnly); + } else if (t().isUnaryExpression(node)) { + return this.isPure(node.argument, constantsOnly); + } else if (t().isTaggedTemplateExpression(node)) { + return t().matchesPattern(node.tag, "String.raw") && !this.hasBinding("String", true) && this.isPure(node.quasi, constantsOnly); + } else if (t().isTemplateLiteral(node)) { + var _arr11 = node.expressions; + + for (var _i13 = 0; _i13 < _arr11.length; _i13++) { + const expression = _arr11[_i13]; + if (!this.isPure(expression, constantsOnly)) return false; + } + + return true; + } else { + return t().isPureish(node); + } + } + + setData(key, val) { + return this.data[key] = val; + } + + getData(key) { + let scope = this; + + do { + const data = scope.data[key]; + if (data != null) return data; + } while (scope = scope.parent); + } + + removeData(key) { + let scope = this; + + do { + const data = scope.data[key]; + if (data != null) scope.data[key] = null; + } while (scope = scope.parent); + } + + init() { + if (!this.references) this.crawl(); + } + + crawl() { + const path = this.path; + this.references = Object.create(null); + this.bindings = Object.create(null); + this.globals = Object.create(null); + this.uids = Object.create(null); + this.data = Object.create(null); + + if (path.isLoop()) { + var _arr12 = t().FOR_INIT_KEYS; + + for (var _i14 = 0; _i14 < _arr12.length; _i14++) { + const key = _arr12[_i14]; + const node = path.get(key); + if (node.isBlockScoped()) this.registerBinding(node.node.kind, node); + } + } + + if (path.isFunctionExpression() && path.has("id")) { + if (!path.get("id").node[t().NOT_LOCAL_BINDING]) { + this.registerBinding("local", path.get("id"), path); + } + } + + if (path.isClassExpression() && path.has("id")) { + if (!path.get("id").node[t().NOT_LOCAL_BINDING]) { + this.registerBinding("local", path); + } + } + + if (path.isFunction()) { + const params = path.get("params"); + + for (var _iterator3 = params, _isArray3 = Array.isArray(_iterator3), _i15 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) { + var _ref3; + + if (_isArray3) { + if (_i15 >= _iterator3.length) break; + _ref3 = _iterator3[_i15++]; + } else { + _i15 = _iterator3.next(); + if (_i15.done) break; + _ref3 = _i15.value; + } + + const param = _ref3; + this.registerBinding("param", param); + } + } + + if (path.isCatchClause()) { + this.registerBinding("let", path); + } + + const parent = this.getProgramParent(); + if (parent.crawling) return; + const state = { + references: [], + constantViolations: [], + assignments: [] + }; + this.crawling = true; + path.traverse(collectorVisitor, state); + this.crawling = false; + + for (var _iterator4 = state.assignments, _isArray4 = Array.isArray(_iterator4), _i16 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) { + var _ref4; + + if (_isArray4) { + if (_i16 >= _iterator4.length) break; + _ref4 = _iterator4[_i16++]; + } else { + _i16 = _iterator4.next(); + if (_i16.done) break; + _ref4 = _i16.value; + } + + const path = _ref4; + const ids = path.getBindingIdentifiers(); + let programParent; + + for (const name in ids) { + if (path.scope.getBinding(name)) continue; + programParent = programParent || path.scope.getProgramParent(); + programParent.addGlobal(ids[name]); + } + + path.scope.registerConstantViolation(path); + } + + for (var _iterator5 = state.references, _isArray5 = Array.isArray(_iterator5), _i17 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) { + var _ref5; + + if (_isArray5) { + if (_i17 >= _iterator5.length) break; + _ref5 = _iterator5[_i17++]; + } else { + _i17 = _iterator5.next(); + if (_i17.done) break; + _ref5 = _i17.value; + } + + const ref = _ref5; + const binding = ref.scope.getBinding(ref.node.name); + + if (binding) { + binding.reference(ref); + } else { + ref.scope.getProgramParent().addGlobal(ref.node); + } + } + + for (var _iterator6 = state.constantViolations, _isArray6 = Array.isArray(_iterator6), _i18 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) { + var _ref6; + + if (_isArray6) { + if (_i18 >= _iterator6.length) break; + _ref6 = _iterator6[_i18++]; + } else { + _i18 = _iterator6.next(); + if (_i18.done) break; + _ref6 = _i18.value; + } + + const path = _ref6; + path.scope.registerConstantViolation(path); + } + } + + push(opts) { + let path = this.path; + + if (!path.isBlockStatement() && !path.isProgram()) { + path = this.getBlockParent().path; + } + + if (path.isSwitchStatement()) { + path = (this.getFunctionParent() || this.getProgramParent()).path; + } + + if (path.isLoop() || path.isCatchClause() || path.isFunction()) { + path.ensureBlock(); + path = path.get("body"); + } + + const unique = opts.unique; + const kind = opts.kind || "var"; + const blockHoist = opts._blockHoist == null ? 2 : opts._blockHoist; + const dataKey = `declaration:${kind}:${blockHoist}`; + let declarPath = !unique && path.getData(dataKey); + + if (!declarPath) { + const declar = t().variableDeclaration(kind, []); + declar._blockHoist = blockHoist; + + var _path$unshiftContaine = path.unshiftContainer("body", [declar]); + + declarPath = _path$unshiftContaine[0]; + if (!unique) path.setData(dataKey, declarPath); + } + + const declarator = t().variableDeclarator(opts.id, opts.init); + declarPath.node.declarations.push(declarator); + this.registerBinding(kind, declarPath.get("declarations").pop()); + } + + getProgramParent() { + let scope = this; + + do { + if (scope.path.isProgram()) { + return scope; + } + } while (scope = scope.parent); + + throw new Error("Couldn't find a Program"); + } + + getFunctionParent() { + let scope = this; + + do { + if (scope.path.isFunctionParent()) { + return scope; + } + } while (scope = scope.parent); + + return null; + } + + getBlockParent() { + let scope = this; + + do { + if (scope.path.isBlockParent()) { + return scope; + } + } while (scope = scope.parent); + + throw new Error("We couldn't find a BlockStatement, For, Switch, Function, Loop or Program..."); + } + + getAllBindings() { + const ids = Object.create(null); + let scope = this; + + do { + (0, _defaults().default)(ids, scope.bindings); + scope = scope.parent; + } while (scope); + + return ids; + } + + getAllBindingsOfKind() { + const ids = Object.create(null); + var _arr13 = arguments; + + for (var _i19 = 0; _i19 < _arr13.length; _i19++) { + const kind = _arr13[_i19]; + let scope = this; + + do { + for (const name in scope.bindings) { + const binding = scope.bindings[name]; + if (binding.kind === kind) ids[name] = binding; + } + + scope = scope.parent; + } while (scope); + } + + return ids; + } + + bindingIdentifierEquals(name, node) { + return this.getBindingIdentifier(name) === node; + } + + getBinding(name) { + let scope = this; + + do { + const binding = scope.getOwnBinding(name); + if (binding) return binding; + } while (scope = scope.parent); + } + + getOwnBinding(name) { + return this.bindings[name]; + } + + getBindingIdentifier(name) { + const info = this.getBinding(name); + return info && info.identifier; + } + + getOwnBindingIdentifier(name) { + const binding = this.bindings[name]; + return binding && binding.identifier; + } + + hasOwnBinding(name) { + return !!this.getOwnBinding(name); + } + + hasBinding(name, noGlobals) { + if (!name) return false; + if (this.hasOwnBinding(name)) return true; + if (this.parentHasBinding(name, noGlobals)) return true; + if (this.hasUid(name)) return true; + if (!noGlobals && (0, _includes().default)(Scope.globals, name)) return true; + if (!noGlobals && (0, _includes().default)(Scope.contextVariables, name)) return true; + return false; + } + + parentHasBinding(name, noGlobals) { + return this.parent && this.parent.hasBinding(name, noGlobals); + } + + moveBindingTo(name, scope) { + const info = this.getBinding(name); + + if (info) { + info.scope.removeOwnBinding(name); + info.scope = scope; + scope.bindings[name] = info; + } + } + + removeOwnBinding(name) { + delete this.bindings[name]; + } + + removeBinding(name) { + const info = this.getBinding(name); + + if (info) { + info.scope.removeOwnBinding(name); + } + + let scope = this; + + do { + if (scope.uids[name]) { + scope.uids[name] = false; + } + } while (scope = scope.parent); + } + +} + +exports.default = Scope; +Scope.globals = Object.keys(_globals().default.builtin); +Scope.contextVariables = ["arguments", "undefined", "Infinity", "NaN"];
\ No newline at end of file diff --git a/node_modules/@babel/traverse/lib/scope/lib/renamer.js b/node_modules/@babel/traverse/lib/scope/lib/renamer.js new file mode 100644 index 00000000..47016e47 --- /dev/null +++ b/node_modules/@babel/traverse/lib/scope/lib/renamer.js @@ -0,0 +1,130 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _binding = _interopRequireDefault(require("../binding")); + +function _helperSplitExportDeclaration() { + const data = _interopRequireDefault(require("@babel/helper-split-export-declaration")); + + _helperSplitExportDeclaration = function _helperSplitExportDeclaration() { + 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 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)) { + path.skip(); + } + }, + + "AssignmentExpression|Declaration"(path, state) { + 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 = t().identifier(this.oldName); + path.node._blockHoist = 3; + path.replaceWith(t().variableDeclaration("let", [t().variableDeclarator(t().identifier(this.newName), t().toExpression(path.node))])); + } + + maybeConvertFromClassFunctionExpression(path) { + return; + if (!path.isFunctionExpression() && !path.isClassExpression()) return; + if (this.binding.kind !== "local") return; + path.node.id = t().identifier(this.oldName); + this.binding.scope.parent.push({ + id: t().identifier(this.newName) + }); + path.replaceWith(t().assignmentExpression("=", t().identifier(this.newName), path.node)); + } + + rename(block) { + const binding = this.binding, + oldName = this.oldName, + newName = this.newName; + const scope = binding.scope, + path = binding.path; + const parentDeclar = path.find(path => path.isDeclaration() || path.isFunctionExpression() || path.isClassExpression()); + + if (parentDeclar) { + this.maybeConvertFromExportDeclaration(parentDeclar); + } + + scope.traverse(block || scope.block, renameVisitor, this); + + if (!block) { + scope.removeOwnBinding(oldName); + scope.bindings[newName] = binding; + this.binding.identifier.name = newName; + } + + if (binding.type === "hoisted") {} + + if (parentDeclar) { + this.maybeConvertFromClassFunctionDeclaration(parentDeclar); + this.maybeConvertFromClassFunctionExpression(parentDeclar); + } + } + +} + +exports.default = Renamer;
\ No newline at end of file |