import includes from "lodash/includes";

import repeat from "lodash/repeat";

import Renamer from "./lib/renamer";

import type NodePath from "../path";

import traverse from "../index";

import defaults from "lodash/defaults";

import Binding from "./binding";

import globals from "globals";

import * as t from "@babel/types";

import { scope as scopeCache } from "../cache";

// Recursively gathers the identifying names of a node.

function gatherNodeParts(node: Object, parts: Array) {

}

//

const collectorVisitor = {

For(path) {

},

Declaration(path) {

},

ReferencedIdentifier(path, state) {

state.references.push(path);

},

ForXStatement(path, state) {

},

ExportDeclaration: {

exit(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) {

},

BlockScoped(path) {

},

ClassDeclaration(path) {

},

Block(path) {

},

};

let uid = 0;

export default class Scope {

}

/**

* Possibly generate a memoised identifier if it is not static and has consequences.

*/

maybeGenerateMemoised(node: Object, dontPush?: boolean): ?Object {

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: string, name: string, id: Object) {

// ignore parameters

if (kind === "param") return;

// Ignore existing binding if it's the name of the current function or

// class expression

if (local.kind === "local") return;

const duplicate =

// don't allow duplicate bindings to exist alongside

kind === "let" ||

local.kind === "let" ||

local.kind === "const" ||

local.kind === "module" ||

// don't allow a local of param with a kind of let

(local.kind === "param" && (kind === "let" || kind === "const"));

if (duplicate) {

throw this.hub.buildError(

id,

`Duplicate declaration "${name}"`,

TypeError,

);

}

}

rename(oldName: string, newName: string, block?) {

const binding = this.getBinding(oldName);

if (binding) {

newName = newName || this.generateUidIdentifier(oldName).name;

return new Renamer(binding, oldName, newName).rename(block);

}

}

_renameFromMap(map, oldName, newName, value) {

if (map[oldName]) {

map[newName] = value;

map[oldName] = null;

}

}

dump() {

const sep = repeat("-", 60);

console.log(sep);

let scope = this;

do {

console.log("#", scope.block.type);

for (const name of Object.keys(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: Object, i?: number) {

if (t.isIdentifier(node)) {

}

/**

* Set some arbitrary data on the current scope.

*/

setData(key, val) {

}

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);

// ForStatement - left, init

if (path.isLoop()) {

for (const key of (t.FOR_INIT_KEYS: Array<string>)) {

const node = path.get(key);

if (node.isBlockScoped()) this.registerBinding(node.node.kind, node);

}

}

// FunctionExpression - id

if (path.isFunctionExpression() && path.has("id")) {

if (!path.get("id").node[t.NOT_LOCAL_BINDING]) {

this.registerBinding("local", path.get("id"), path);

}

}

// Class

if (path.isClassExpression() && path.has("id")) {

if (!path.get("id").node[t.NOT_LOCAL_BINDING]) {

this.registerBinding("local", path);

}

}

// Function - params, rest

if (path.isFunction()) {

const params: Array<NodePath> = path.get("params");

for (const param of params) {

this.registerBinding("param", param);

}

}

// CatchClause - param

if (path.isCatchClause()) {

this.registerBinding("let", path);

}

// Program

const parent = this.getProgramParent();

if (parent.crawling) return;

const state = {

references: [],

constantViolations: [],

assignments: [],

};

this.crawling = true;

path.traverse(collectorVisitor, state);

this.crawling = false;

// register assignments

for (const path of state.assignments) {

// register undeclared bindings as globals

const ids = path.getBindingIdentifiers();

let programParent;

for (const name of Object.keys(ids)) {

if (path.scope.getBinding(name)) continue;

programParent = programParent || path.scope.getProgramParent();

programParent.addGlobal(ids[name]);

}

// register as constant violation

path.scope.registerConstantViolation(path);

}

// register references

for (const ref of state.references) {

const binding = ref.scope.getBinding(ref.node.name);

if (binding) {

binding.reference(ref);

} else {

ref.scope.getProgramParent().addGlobal(ref.node);

}

}

// register constant violations

for (const path of state.constantViolations) {

path.scope.registerConstantViolation(path);

}

}

push(opts: {

id: Object,

init: ?Object,

unique: ?boolean,

_blockHoist: ?number,

kind: "var" | "let",

}) {

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;

[declarPath] = path.unshiftContainer("body", [declar]);

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());

}

/**

* Walk up to the top of the scope tree and get the `Program`.

*/

getProgramParent() {

let scope = this;

do {

if (scope.path.isProgram()) {

return scope;

}

} while ((scope = scope.parent));

throw new Error("Couldn't find a Program");

}

/**

* Walk up the scope tree until we hit either a Function or return null.

*/

getFunctionParent() {

let scope = this;

do {

if (scope.path.isFunctionParent()) {

return scope;

}

} while ((scope = scope.parent));

return null;

}

/**

* Walk up the scope tree until we hit either a BlockStatement/Loop/Program/Function/Switch or reach the

* very top and hit Program.

*/

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...",

);

}

/**

* Walks the scope tree and gathers **all** bindings.

*/

getAllBindings(): Object {

const ids = Object.create(null);

let scope = this;

do {

defaults(ids, scope.bindings);

scope = scope.parent;

} while (scope);

return ids;

}

/**

* Walks the scope tree and gathers all declarations of `kind`.

*/

getAllBindingsOfKind(): Object {

const ids = Object.create(null);

for (const kind of (arguments: Array)) {

let scope = this;

do {

for (const name of Object.keys(scope.bindings)) {

const binding = scope.bindings[name];

if (binding.kind === kind) ids[name] = binding;

}

scope = scope.parent;

} while (scope);

}

return ids;

}

bindingIdentifierEquals(name: string, node: Object): boolean {

return this.getBindingIdentifier(name) === node;

}

getBinding(name: string) {

let scope = this;

do {

const binding = scope.getOwnBinding(name);

if (binding) return binding;

} while ((scope = scope.parent));

}

getOwnBinding(name: string) {

return this.bindings[name];

}

getBindingIdentifier(name: string) {

const info = this.getBinding(name);

return info && info.identifier;

}

getOwnBindingIdentifier(name: string) {

const binding = this.bindings[name];

return binding && binding.identifier;

}

hasOwnBinding(name: string) {

return !!this.getOwnBinding(name);

}

hasBinding(name: string, noGlobals?) {

}

/**

* Move a binding of `name` to another `scope`.

*/

moveBindingTo(name, scope) {

const info = this.getBinding(name);

}

}

removeOwnBinding(name: string) {

delete this.bindings[name];

}

removeBinding(name: string) {

// clear literal binding

const info = this.getBinding(name);

if (info) {

info.scope.removeOwnBinding(name);

}

// clear uids with this name - https://github.com/babel/babel/issues/2101

let scope = this;

do {

if (scope.uids[name]) {

scope.uids[name] = false;

}

} while ((scope = scope.parent));

}

}