“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.default = void 0;

var _binding = _interopRequireDefault(require(“../binding”));

var _helperSplitExportDeclaration = _interopRequireDefault(require(“@babel/helper-split-export-declaration”));

var t = _interopRequireWildcard(require(“@babel/types”));

function _getRequireWildcardCache() { if (typeof WeakMap !== “function”) return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj = obj; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } 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,
    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);
    }
  }

  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;