"use strict";
|
/**
|
* A note on `__proto__`:
|
*
|
* This file uses ordinary objects to track identifiers that are observed in
|
* the input source code. It creates these objects using `Object.create` so
|
* that the tracking objects have no prototype, allowing the `__proto__`
|
* property to be used to store a value *without* triggering the invocation of
|
* the built-in `Object.prototype.__proto__` accessor method. Some environments
|
* (e.g. PhantomJS) do not implement the correct semantics for property
|
* enumeration. In those environments, methods like `Object.keys` and Lodash's
|
* `values` do not include the property name. This file includes a number of
|
* branches which ensure that JSHint behaves consistently in those
|
* environments. The branches must be ignored by the test coverage verification
|
* system because the workaround is not necessary in the environment where
|
* coverage is verified (i.e. Node.js).
|
*/
|
|
var _ = require("lodash");
|
var events = require("events");
|
|
// Used to denote membership in lookup tables (a primitive value such as `true`
|
// would be silently rejected for the property name "__proto__" in some
|
// environments)
|
var marker = {};
|
|
/**
|
* A factory function for creating scope managers. A scope manager tracks
|
* bindings, detecting when variables are referenced (through "usages").
|
*
|
* @param {object} state - the global state object (see `state.js`)
|
* @param {Array} predefined - a set of binding names for built-in bindings
|
* provided by the environment
|
* @param {object} exported - a hash for binding names that are intended to be
|
* referenced in contexts beyond the current program
|
* code
|
* @param {object} declared - a hash for binding names that were defined as
|
* global bindings via linting configuration
|
*
|
* @returns {object} - a scope manager
|
*/
|
var scopeManager = function(state, predefined, exported, declared) {
|
|
var _current;
|
var _scopeStack = [];
|
|
function _newScope(type) {
|
_current = {
|
"(bindings)": Object.create(null),
|
"(usages)": Object.create(null),
|
"(labels)": Object.create(null),
|
"(parent)": _current,
|
"(type)": type,
|
"(params)": (type === "functionparams" || type === "catchparams") ? [] : null
|
};
|
_scopeStack.push(_current);
|
}
|
|
_newScope("global");
|
_current["(predefined)"] = predefined;
|
|
var _currentFunctBody = _current; // this is the block after the params = function
|
|
var usedPredefinedAndGlobals = Object.create(null);
|
var impliedGlobals = Object.create(null);
|
var unuseds = [];
|
var esModuleExports = [];
|
var emitter = new events.EventEmitter();
|
|
function warning(code, token) {
|
emitter.emit("warning", {
|
code: code,
|
token: token,
|
data: _.slice(arguments, 2)
|
});
|
}
|
|
function error(code, token) {
|
emitter.emit("warning", {
|
code: code,
|
token: token,
|
data: _.slice(arguments, 2)
|
});
|
}
|
|
function _setupUsages(bindingName) {
|
if (!_current["(usages)"][bindingName]) {
|
_current["(usages)"][bindingName] = {
|
"(modified)": [],
|
"(reassigned)": [],
|
"(tokens)": []
|
};
|
}
|
}
|
|
var _getUnusedOption = function(unused_opt) {
|
if (unused_opt === undefined) {
|
unused_opt = state.option.unused;
|
}
|
|
if (unused_opt === true) {
|
unused_opt = "last-param";
|
}
|
|
return unused_opt;
|
};
|
|
var _warnUnused = function(name, tkn, type, unused_opt) {
|
var line = tkn.line;
|
var chr = tkn.from;
|
var raw_name = tkn.raw_text || name;
|
|
unused_opt = _getUnusedOption(unused_opt);
|
|
var warnable_types = {
|
"vars": ["var"],
|
"last-param": ["var", "param"],
|
"strict": ["var", "param", "last-param"]
|
};
|
|
if (unused_opt) {
|
if (warnable_types[unused_opt] && warnable_types[unused_opt].indexOf(type) !== -1) {
|
warning("W098", { line: line, from: chr }, raw_name);
|
}
|
}
|
|
// inconsistent - see gh-1894
|
if (unused_opt || type === "var") {
|
unuseds.push({
|
name: name,
|
line: line,
|
character: chr
|
});
|
}
|
};
|
|
/**
|
* Check the current scope for unused identifiers
|
*/
|
function _checkForUnused() {
|
if (_current["(type)"] !== "functionparams") {
|
var currentBindings = _current["(bindings)"];
|
for (var bindingName in currentBindings) {
|
if (currentBindings[bindingName]["(type)"] !== "exception" &&
|
currentBindings[bindingName]["(unused)"]) {
|
_warnUnused(bindingName, currentBindings[bindingName]["(token)"], "var");
|
}
|
}
|
return;
|
}
|
|
// Check the current scope for unused parameters and issue warnings as
|
// necessary.
|
var params = _current["(params)"];
|
|
var param = params.pop();
|
var unused_opt;
|
|
while (param) {
|
var binding = _current["(bindings)"][param];
|
|
unused_opt = _getUnusedOption(state.funct["(unusedOption)"]);
|
|
// 'undefined' is a special case for the common pattern where `undefined`
|
// is used as a formal parameter name to defend against global
|
// re-assignment, e.g.
|
//
|
// (function(window, undefined) {
|
// })();
|
if (param === "undefined")
|
return;
|
|
if (binding["(unused)"]) {
|
_warnUnused(param, binding["(token)"], "param", state.funct["(unusedOption)"]);
|
} else if (unused_opt === "last-param") {
|
return;
|
}
|
|
param = params.pop();
|
}
|
}
|
|
/**
|
* Find the relevant binding's scope. The owning scope is located by first
|
* inspecting the current scope and then moving "downward" through the stack
|
* of scopes.
|
*
|
* @param {string} bindingName - the value of the identifier
|
*
|
* @returns {Object} - the scope in which the binding was found
|
*/
|
function _getBinding(bindingName) {
|
for (var i = _scopeStack.length - 1 ; i >= 0; --i) {
|
var scopeBindings = _scopeStack[i]["(bindings)"];
|
if (scopeBindings[bindingName]) {
|
return scopeBindings;
|
}
|
}
|
}
|
|
/**
|
* Determine if a given binding name has been referenced within the current
|
* function or any function defined within.
|
*
|
* @param {string} bindingName - the value of the identifier
|
*
|
* @returns {boolean}
|
*/
|
function usedSoFarInCurrentFunction(bindingName) {
|
for (var i = _scopeStack.length - 1; i >= 0; i--) {
|
var current = _scopeStack[i];
|
if (current["(usages)"][bindingName]) {
|
return current["(usages)"][bindingName];
|
}
|
if (current === _currentFunctBody) {
|
break;
|
}
|
}
|
return false;
|
}
|
|
function _checkOuterShadow(bindingName, token) {
|
|
// only check if shadow is outer
|
if (state.option.shadow !== "outer") {
|
return;
|
}
|
|
var isGlobal = _currentFunctBody["(type)"] === "global",
|
isNewFunction = _current["(type)"] === "functionparams";
|
|
var outsideCurrentFunction = !isGlobal;
|
for (var i = 0; i < _scopeStack.length; i++) {
|
var stackItem = _scopeStack[i];
|
|
if (!isNewFunction && _scopeStack[i + 1] === _currentFunctBody) {
|
outsideCurrentFunction = false;
|
}
|
if (outsideCurrentFunction && stackItem["(bindings)"][bindingName]) {
|
warning("W123", token, bindingName);
|
}
|
if (stackItem["(labels)"][bindingName]) {
|
warning("W123", token, bindingName);
|
}
|
}
|
}
|
|
function _latedefWarning(type, bindingName, token) {
|
var isFunction;
|
|
if (state.option.latedef) {
|
isFunction = type === "function" || type === "generator function" ||
|
type === "async function";
|
|
// if either latedef is strict and this is a function
|
// or this is not a function
|
if ((state.option.latedef === true && isFunction) || !isFunction) {
|
warning("W003", token, bindingName);
|
}
|
}
|
}
|
|
var scopeManagerInst = {
|
|
on: function(names, listener) {
|
names.split(" ").forEach(function(name) {
|
emitter.on(name, listener);
|
});
|
},
|
|
isPredefined: function(bindingName) {
|
return !this.has(bindingName) && _.has(_scopeStack[0]["(predefined)"], bindingName);
|
},
|
|
/**
|
* Create a new scope within the current scope. As the topmost value, the
|
* new scope will be interpreted as the current scope until it is
|
* exited--see the `unstack` method.
|
*
|
* @param {string} [type] - The type of the scope. Valid values are
|
* "functionparams", "catchparams" and
|
* "functionouter"
|
*/
|
stack: function(type) {
|
var previousScope = _current;
|
_newScope(type);
|
|
if (!type && previousScope["(type)"] === "functionparams") {
|
|
_current["(isFuncBody)"] = true;
|
_currentFunctBody = _current;
|
}
|
},
|
|
/**
|
* Valldate all binding references and declarations in the current scope
|
* and set the next scope on the stack as the active scope.
|
*/
|
unstack: function() {
|
// jshint proto: true
|
var subScope = _scopeStack.length > 1 ? _scopeStack[_scopeStack.length - 2] : null;
|
var isUnstackingFunctionBody = _current === _currentFunctBody,
|
isUnstackingFunctionParams = _current["(type)"] === "functionparams",
|
isUnstackingFunctionOuter = _current["(type)"] === "functionouter";
|
|
var i, j, isImmutable, isFunction;
|
var currentUsages = _current["(usages)"];
|
var currentBindings = _current["(bindings)"];
|
var usedBindingNameList = Object.keys(currentUsages);
|
|
// See comment, "A note on `__proto__`"
|
/* istanbul ignore if */
|
if (currentUsages.__proto__ && usedBindingNameList.indexOf("__proto__") === -1) {
|
usedBindingNameList.push("__proto__");
|
}
|
|
for (i = 0; i < usedBindingNameList.length; i++) {
|
var usedBindingName = usedBindingNameList[i];
|
|
var usage = currentUsages[usedBindingName];
|
var usedBinding = currentBindings[usedBindingName];
|
if (usedBinding) {
|
var usedBindingType = usedBinding["(type)"];
|
isImmutable = usedBindingType === "const" || usedBindingType === "import";
|
|
if (usedBinding["(useOutsideOfScope)"] && !state.option.funcscope) {
|
var usedTokens = usage["(tokens)"];
|
for (j = 0; j < usedTokens.length; j++) {
|
// Keep the consistency of https://github.com/jshint/jshint/issues/2409
|
if (usedBinding["(function)"] === usedTokens[j]["(function)"]) {
|
error("W038", usedTokens[j], usedBindingName);
|
}
|
}
|
}
|
|
// mark the binding used
|
_current["(bindings)"][usedBindingName]["(unused)"] = false;
|
|
// check for modifying a const
|
if (isImmutable && usage["(modified)"]) {
|
for (j = 0; j < usage["(modified)"].length; j++) {
|
error("E013", usage["(modified)"][j], usedBindingName);
|
}
|
}
|
|
isFunction = usedBindingType === "function" ||
|
usedBindingType === "generator function" ||
|
usedBindingType === "async function";
|
|
// check for re-assigning a function declaration
|
if ((isFunction || usedBindingType === "class") && usage["(reassigned)"]) {
|
for (j = 0; j < usage["(reassigned)"].length; j++) {
|
if (!usage["(reassigned)"][j].ignoreW021) {
|
warning("W021", usage["(reassigned)"][j], usedBindingName, usedBindingType);
|
}
|
}
|
}
|
continue;
|
}
|
|
if (subScope) {
|
var bindingType = this.bindingtype(usedBindingName);
|
isImmutable = bindingType === "const" ||
|
(bindingType === null && _scopeStack[0]["(predefined)"][usedBindingName] === false);
|
if (isUnstackingFunctionOuter && !isImmutable) {
|
if (!state.funct["(outerMutables)"]) {
|
state.funct["(outerMutables)"] = [];
|
}
|
state.funct["(outerMutables)"].push(usedBindingName);
|
}
|
|
// not exiting the global scope, so copy the usage down in case its an out of scope usage
|
if (!subScope["(usages)"][usedBindingName]) {
|
subScope["(usages)"][usedBindingName] = usage;
|
if (isUnstackingFunctionBody) {
|
subScope["(usages)"][usedBindingName]["(onlyUsedSubFunction)"] = true;
|
}
|
} else {
|
var subScopeUsage = subScope["(usages)"][usedBindingName];
|
subScopeUsage["(modified)"] = subScopeUsage["(modified)"].concat(usage["(modified)"]);
|
subScopeUsage["(tokens)"] = subScopeUsage["(tokens)"].concat(usage["(tokens)"]);
|
subScopeUsage["(reassigned)"] =
|
subScopeUsage["(reassigned)"].concat(usage["(reassigned)"]);
|
}
|
} else {
|
// this is exiting global scope, so we finalise everything here - we are at the end of the file
|
if (typeof _current["(predefined)"][usedBindingName] === "boolean") {
|
|
// remove the declared token, so we know it is used
|
delete declared[usedBindingName];
|
|
// note it as used so it can be reported
|
usedPredefinedAndGlobals[usedBindingName] = marker;
|
|
// check for re-assigning a read-only (set to false) predefined
|
if (_current["(predefined)"][usedBindingName] === false && usage["(reassigned)"]) {
|
for (j = 0; j < usage["(reassigned)"].length; j++) {
|
if (!usage["(reassigned)"][j].ignoreW020) {
|
warning("W020", usage["(reassigned)"][j]);
|
}
|
}
|
}
|
}
|
else {
|
// binding usage is not predefined and we have not found a declaration
|
// so report as undeclared
|
for (j = 0; j < usage["(tokens)"].length; j++) {
|
var undefinedToken = usage["(tokens)"][j];
|
// if its not a forgiven undefined (e.g. typof x)
|
if (!undefinedToken.forgiveUndef) {
|
// if undef is on and undef was on when the token was defined
|
if (state.option.undef && !undefinedToken.ignoreUndef) {
|
warning("W117", undefinedToken, usedBindingName);
|
}
|
if (impliedGlobals[usedBindingName]) {
|
impliedGlobals[usedBindingName].line.push(undefinedToken.line);
|
} else {
|
impliedGlobals[usedBindingName] = {
|
name: usedBindingName,
|
line: [undefinedToken.line]
|
};
|
}
|
}
|
}
|
}
|
}
|
}
|
|
// if exiting the global scope, we can warn about declared globals that haven't been used yet
|
if (!subScope) {
|
Object.keys(declared)
|
.forEach(function(bindingNotUsed) {
|
_warnUnused(bindingNotUsed, declared[bindingNotUsed], "var");
|
});
|
}
|
|
// If this is not a function boundary, transfer function-scoped bindings to
|
// the parent block (a rough simulation of variable hoisting). Previously
|
// existing bindings in the parent block should take precedence so that
|
// prior usages are not discarded.
|
if (subScope && !isUnstackingFunctionBody &&
|
!isUnstackingFunctionParams && !isUnstackingFunctionOuter) {
|
var bindingNames = Object.keys(currentBindings);
|
for (i = 0; i < bindingNames.length; i++) {
|
|
var defBindingName = bindingNames[i];
|
var defBinding = currentBindings[defBindingName];
|
|
if (!defBinding["(blockscoped)"] && defBinding["(type)"] !== "exception") {
|
var shadowed = subScope["(bindings)"][defBindingName];
|
|
// Do not overwrite a binding if it exists in the parent scope
|
// because it is shared by adjacent blocks. Copy the `unused`
|
// property so that any references found within the current block
|
// are counted toward that higher-level declaration.
|
if (shadowed) {
|
shadowed["(unused)"] &= defBinding["(unused)"];
|
|
// "Hoist" the variable to the parent block, decorating the binding
|
// so that future references, though technically valid, can be
|
// reported as "out-of-scope" in the absence of the `funcscope`
|
// option.
|
} else {
|
defBinding["(useOutsideOfScope)"] =
|
// Do not warn about out-of-scope usages in the global scope
|
_currentFunctBody["(type)"] !== "global" &&
|
// When a higher scope contains a binding for the binding, the
|
// binding is a re-declaration and should not prompt "used
|
// out-of-scope" warnings.
|
!this.funct.has(defBindingName, { excludeCurrent: true });
|
|
subScope["(bindings)"][defBindingName] = defBinding;
|
}
|
|
delete currentBindings[defBindingName];
|
}
|
}
|
}
|
|
_checkForUnused();
|
|
_scopeStack.pop();
|
if (isUnstackingFunctionBody) {
|
_currentFunctBody = _scopeStack[_.findLastIndex(_scopeStack, function(scope) {
|
// if function or if global (which is at the bottom so it will only return true if we call back)
|
return scope["(isFuncBody)"] || scope["(type)"] === "global";
|
})];
|
}
|
|
_current = subScope;
|
},
|
|
/**
|
* Add a function parameter to the current scope.
|
*
|
* @param {string} bindingName - the value of the identifier
|
* @param {Token} token
|
* @param {string} [type] - binding type; defaults to "param"
|
*/
|
addParam: function(bindingName, token, type) {
|
type = type || "param";
|
|
if (type === "exception") {
|
// if defined in the current function
|
var previouslyDefinedBindingType = this.funct.bindingtype(bindingName);
|
if (previouslyDefinedBindingType && previouslyDefinedBindingType !== "exception") {
|
// and has not been used yet in the current function scope
|
if (!state.option.node) {
|
warning("W002", state.tokens.next, bindingName);
|
}
|
}
|
|
if (state.isStrict() && (bindingName === "arguments" || bindingName === "eval")) {
|
warning("E008", token);
|
}
|
}
|
|
// The variable was declared in the current scope
|
if (_.has(_current["(bindings)"], bindingName)) {
|
_current["(bindings)"][bindingName].duplicated = true;
|
|
// The variable was declared in an outer scope
|
} else {
|
// if this scope has the variable defined, it's a re-definition error
|
_checkOuterShadow(bindingName, token);
|
|
_current["(bindings)"][bindingName] = {
|
"(type)" : type,
|
"(token)": token,
|
"(unused)": true };
|
|
_current["(params)"].push(bindingName);
|
}
|
|
if (_.has(_current["(usages)"], bindingName)) {
|
var usage = _current["(usages)"][bindingName];
|
// if its in a sub function it is not necessarily an error, just latedef
|
if (usage["(onlyUsedSubFunction)"]) {
|
_latedefWarning(type, bindingName, token);
|
} else {
|
// this is a clear illegal usage, but not a syntax error, so emit a
|
// warning and not an error
|
warning("W003", token, bindingName);
|
}
|
}
|
},
|
|
validateParams: function(isArrow) {
|
var isStrict = state.isStrict();
|
var currentFunctParamScope = _currentFunctBody["(parent)"];
|
// From ECMAScript 2017:
|
//
|
// > 14.1.2Static Semantics: Early Errors
|
// >
|
// > [...]
|
// > - It is a Syntax Error if IsSimpleParameterList of
|
// > FormalParameterList is false and BoundNames of FormalParameterList
|
// > contains any duplicate elements.
|
var isSimple = state.funct['(hasSimpleParams)'];
|
// Method definitions are defined in terms of UniqueFormalParameters, so
|
// they cannot support duplicate parameter names regardless of strict
|
// mode.
|
var isMethod = state.funct["(method)"];
|
|
if (!currentFunctParamScope["(params)"]) {
|
/* istanbul ignore next */
|
return;
|
}
|
|
currentFunctParamScope["(params)"].forEach(function(bindingName) {
|
var binding = currentFunctParamScope["(bindings)"][bindingName];
|
|
if (binding.duplicated) {
|
if (isStrict || isArrow || isMethod || !isSimple) {
|
warning("E011", binding["(token)"], bindingName);
|
} else if (state.option.shadow !== true) {
|
warning("W004", binding["(token)"], bindingName);
|
}
|
}
|
|
if (isStrict && (bindingName === "arguments" || bindingName === "eval")) {
|
warning("E008", binding["(token)"]);
|
}
|
});
|
},
|
|
getUsedOrDefinedGlobals: function() {
|
// jshint proto: true
|
var list = Object.keys(usedPredefinedAndGlobals);
|
|
// See comment, "A note on `__proto__`"
|
/* istanbul ignore if */
|
if (usedPredefinedAndGlobals.__proto__ === marker &&
|
list.indexOf("__proto__") === -1) {
|
list.push("__proto__");
|
}
|
|
return list;
|
},
|
|
/**
|
* Get an array of implied globals
|
*
|
* @returns {Array.<{ name: string, line: Array.<number>}>}
|
*/
|
getImpliedGlobals: function() {
|
// jshint proto: true
|
var values = _.values(impliedGlobals);
|
var hasProto = false;
|
|
// See comment, "A note on `__proto__`"
|
if (impliedGlobals.__proto__) {
|
hasProto = values.some(function(value) {
|
return value.name === "__proto__";
|
});
|
|
/* istanbul ignore if */
|
if (!hasProto) {
|
values.push(impliedGlobals.__proto__);
|
}
|
}
|
|
return values;
|
},
|
|
/**
|
* Get an array of objects describing unused bindings.
|
*
|
* @returns {Array<Object>}
|
*/
|
getUnuseds: function() {
|
return unuseds;
|
},
|
|
/**
|
* Determine if a given name has been defined in the current scope or any
|
* lower scope.
|
*
|
* @param {string} bindingName - the value of the identifier
|
*
|
* @return {boolean}
|
*/
|
has: function(bindingName) {
|
return Boolean(_getBinding(bindingName));
|
},
|
|
/**
|
* Retrieve binding described by `bindingName` or null
|
*
|
* @param {string} bindingName - the value of the identifier
|
*
|
* @returns {string|null} - the type of the binding or `null` if no such
|
* binding exists
|
*/
|
bindingtype: function(bindingName) {
|
var scopeBindings = _getBinding(bindingName);
|
if (scopeBindings) {
|
return scopeBindings[bindingName]["(type)"];
|
}
|
return null;
|
},
|
|
/**
|
* For the exported options, indicating a variable is used outside the file
|
*
|
* @param {string} bindingName - the value of the identifier
|
*/
|
addExported: function(bindingName) {
|
var globalBindings = _scopeStack[0]["(bindings)"];
|
if (_.has(declared, bindingName)) {
|
// remove the declared token, so we know it is used
|
delete declared[bindingName];
|
} else if (_.has(globalBindings, bindingName)) {
|
globalBindings[bindingName]["(unused)"] = false;
|
} else {
|
for (var i = 1; i < _scopeStack.length; i++) {
|
var scope = _scopeStack[i];
|
// if `scope.(type)` is not defined, it is a block scope
|
if (!scope["(type)"]) {
|
if (_.has(scope["(bindings)"], bindingName) &&
|
!scope["(bindings)"][bindingName]["(blockscoped)"]) {
|
scope["(bindings)"][bindingName]["(unused)"] = false;
|
return;
|
}
|
} else {
|
break;
|
}
|
}
|
exported[bindingName] = true;
|
}
|
},
|
|
/**
|
* Mark a binding as "exported" by an ES2015 module
|
*
|
* @param {string} bindingName - the value of the identifier
|
* @param {object} token
|
*/
|
setExported: function(localName, exportName) {
|
if (exportName) {
|
if (esModuleExports.indexOf(exportName.value) > -1) {
|
error("E069", exportName, exportName.value);
|
}
|
|
esModuleExports.push(exportName.value);
|
}
|
|
if (localName) {
|
this.block.use(localName.value, localName);
|
}
|
},
|
|
/**
|
* Mark a binding as "initialized." This is necessary to enforce the
|
* "temporal dead zone" (TDZ) of block-scoped bindings which are not
|
* hoisted.
|
*
|
* @param {string} bindingName - the value of the identifier
|
*/
|
initialize: function(bindingName) {
|
if (_current["(bindings)"][bindingName]) {
|
_current["(bindings)"][bindingName]["(initialized)"] = true;
|
}
|
},
|
|
/**
|
* Create a new binding and add it to the current scope. Delegates to the
|
* internal `block.add` or `func.add` methods depending on the type.
|
* Produces warnings and errors as necessary.
|
*
|
* @param {string} bindingName
|
* @param {Object} opts
|
* @param {String} opts.type - the type of the binding e.g. "param", "var",
|
* "let, "const", "import", "function",
|
* "generator function", "async function",
|
* "async generator function"
|
* @param {object} opts.token - the token pointing at the declaration
|
* @param {boolean} opts.initialized - whether the binding should be
|
* created in an "initialized" state.
|
*/
|
addbinding: function(bindingName, opts) {
|
|
var type = opts.type;
|
var token = opts.token;
|
var isblockscoped = type === "let" || type === "const" ||
|
type === "class" || type === "import" || type === "generator function" ||
|
type === "async function" || type === "async generator function";
|
var ishoisted = type === "function" || type === "generator function" ||
|
type === "async function" || type === "import";
|
var isexported = (isblockscoped ? _current : _currentFunctBody)["(type)"] === "global" &&
|
_.has(exported, bindingName);
|
|
// outer shadow check (inner is only on non-block scoped)
|
_checkOuterShadow(bindingName, token);
|
|
if (state.isStrict() && (bindingName === "arguments" || bindingName === "eval")) {
|
warning("E008", token);
|
}
|
|
if (isblockscoped) {
|
|
var declaredInCurrentScope = _current["(bindings)"][bindingName];
|
// for block scoped variables, params are seen in the current scope as the root function
|
// scope, so check these too.
|
if (!declaredInCurrentScope && _current === _currentFunctBody &&
|
_current["(type)"] !== "global") {
|
declaredInCurrentScope = !!_currentFunctBody["(parent)"]["(bindings)"][bindingName];
|
}
|
|
// if its not already defined (which is an error, so ignore) and is used in TDZ
|
if (!declaredInCurrentScope && _current["(usages)"][bindingName]) {
|
var usage = _current["(usages)"][bindingName];
|
// if its in a sub function it is not necessarily an error, just latedef
|
if (usage["(onlyUsedSubFunction)"] || ishoisted) {
|
_latedefWarning(type, bindingName, token);
|
} else if (!ishoisted) {
|
// this is a clear illegal usage for block scoped variables
|
warning("E056", token, bindingName, type);
|
}
|
}
|
|
// If this scope has already declared a binding with the same name,
|
// then this represents a redeclaration error if:
|
//
|
// 1. it is a "hoisted" block-scoped binding within a block. For
|
// instance: generator functions may be redeclared in the global
|
// scope but not within block statements
|
// 2. this is not a "hoisted" block-scoped binding
|
if (declaredInCurrentScope &&
|
(!ishoisted || (_current["(type)"] !== "global" || type === "import"))) {
|
warning("E011", token, bindingName);
|
}
|
else if (state.option.shadow === "outer") {
|
|
// if shadow is outer, for block scope we want to detect any shadowing within this function
|
if (scopeManagerInst.funct.has(bindingName)) {
|
warning("W004", token, bindingName);
|
}
|
}
|
|
scopeManagerInst.block.add(
|
bindingName, type, token, !isexported, opts.initialized
|
);
|
|
} else {
|
|
var declaredInCurrentFunctionScope = scopeManagerInst.funct.has(bindingName);
|
|
// check for late definition, ignore if already declared
|
if (!declaredInCurrentFunctionScope && usedSoFarInCurrentFunction(bindingName)) {
|
_latedefWarning(type, bindingName, token);
|
}
|
|
// defining with a var or a function when a block scope variable of the same name
|
// is in scope is an error
|
if (scopeManagerInst.funct.has(bindingName, { onlyBlockscoped: true })) {
|
warning("E011", token, bindingName);
|
} else if (state.option.shadow !== true) {
|
// now since we didn't get any block scope variables, test for var/function
|
// shadowing
|
if (declaredInCurrentFunctionScope && bindingName !== "__proto__") {
|
|
// see https://github.com/jshint/jshint/issues/2400
|
if (_currentFunctBody["(type)"] !== "global") {
|
warning("W004", token, bindingName);
|
}
|
}
|
}
|
|
scopeManagerInst.funct.add(bindingName, type, token, !isexported);
|
|
if (_currentFunctBody["(type)"] === "global" && !state.impliedClosure()) {
|
usedPredefinedAndGlobals[bindingName] = marker;
|
}
|
}
|
},
|
|
funct: {
|
/**
|
* Return the type of the provided binding given certain options
|
*
|
* @param {string} bindingName
|
* @param {Object=} [options]
|
* @param {boolean} [options.onlyBlockscoped] - only include block scoped
|
* bindings
|
* @param {boolean} [options.excludeParams] - exclude the param scope
|
* @param {boolean} [options.excludeCurrent] - exclude the current scope
|
*
|
* @returns {String}
|
*/
|
bindingtype: function(bindingName, options) {
|
var onlyBlockscoped = options && options.onlyBlockscoped;
|
var excludeParams = options && options.excludeParams;
|
var currentScopeIndex = _scopeStack.length - (options && options.excludeCurrent ? 2 : 1);
|
for (var i = currentScopeIndex; i >= 0; i--) {
|
var current = _scopeStack[i];
|
if (current["(bindings)"][bindingName] &&
|
(!onlyBlockscoped || current["(bindings)"][bindingName]["(blockscoped)"])) {
|
return current["(bindings)"][bindingName]["(type)"];
|
}
|
var scopeCheck = excludeParams ? _scopeStack[ i - 1 ] : current;
|
if (scopeCheck && scopeCheck["(type)"] === "functionparams") {
|
return null;
|
}
|
}
|
return null;
|
},
|
|
/**
|
* Determine whether a `break` statement label exists in the function
|
* scope.
|
*
|
* @param {string} labelName - the value of the identifier
|
*
|
* @returns {boolean}
|
*/
|
hasLabel: function(labelName) {
|
for (var i = _scopeStack.length - 1; i >= 0; i--) {
|
var current = _scopeStack[i];
|
|
if (current["(labels)"][labelName]) {
|
return true;
|
}
|
if (current["(type)"] === "functionparams") {
|
return false;
|
}
|
}
|
return false;
|
},
|
|
/**
|
* Determine if a given name has been defined in the current function
|
* scope.
|
*
|
* @param {string} bindingName - the value of the identifier
|
* @param {object} options - options as supported by the
|
* `funct.bindingtype` method
|
*
|
* @return {boolean}
|
*/
|
has: function(bindingName, options) {
|
return Boolean(this.bindingtype(bindingName, options));
|
},
|
|
/**
|
* Create a new function-scoped binding and add it to the current scope.
|
* See the `block.add` method for coresponding logic to create
|
* block-scoped bindings.
|
*
|
* @param {string} bindingName - the value of the identifier
|
* @param {string} type - the type of the binding; either "function" or
|
* "var"
|
* @param {object} tok - the token that triggered the definition
|
* @param {boolean} unused - `true` if the binding has not been
|
* referenced
|
*/
|
add: function(bindingName, type, tok, unused) {
|
_current["(bindings)"][bindingName] = {
|
"(type)" : type,
|
"(token)": tok,
|
"(blockscoped)": false,
|
"(function)": _currentFunctBody,
|
"(unused)": unused };
|
}
|
},
|
|
block: {
|
|
/**
|
* Determine whether the current block scope is the global scope.
|
*
|
* @returns Boolean
|
*/
|
isGlobal: function() {
|
return _current["(type)"] === "global";
|
},
|
|
/**
|
* Resolve a reference to a binding and mark the corresponding binding as
|
* "used."
|
*
|
* @param {string} bindingName - the value of the identifier
|
* @param {object} token - the token value that triggered the reference
|
*/
|
use: function(bindingName, token) {
|
// If the name resolves to a parameter of the current function, then do
|
// not store usage. This is because in cases such as the following:
|
//
|
// function(a) {
|
// var a;
|
// a = a;
|
// }
|
//
|
// the usage of `a` will resolve to the parameter, not to the unset
|
// variable binding.
|
var paramScope = _currentFunctBody["(parent)"];
|
if (paramScope && paramScope["(bindings)"][bindingName] &&
|
paramScope["(bindings)"][bindingName]["(type)"] === "param") {
|
|
// then check its not declared by a block scope variable
|
if (!scopeManagerInst.funct.has(bindingName,
|
{ excludeParams: true, onlyBlockscoped: true })) {
|
paramScope["(bindings)"][bindingName]["(unused)"] = false;
|
}
|
}
|
|
if (token && (state.ignored.W117 || state.option.undef === false)) {
|
token.ignoreUndef = true;
|
}
|
|
_setupUsages(bindingName);
|
|
_current["(usages)"][bindingName]["(onlyUsedSubFunction)"] = false;
|
|
if (token) {
|
token["(function)"] = _currentFunctBody;
|
_current["(usages)"][bindingName]["(tokens)"].push(token);
|
}
|
|
// Block-scoped bindings can't be used within their initializer due to
|
// "temporal dead zone" (TDZ) restrictions.
|
var binding = _current["(bindings)"][bindingName];
|
if (binding && binding["(blockscoped)"] && !binding["(initialized)"]) {
|
error("E056", token, bindingName, binding["(type)"]);
|
}
|
},
|
|
reassign: function(bindingName, token) {
|
token.ignoreW020 = state.ignored.W020;
|
token.ignoreW021 = state.ignored.W021;
|
|
this.modify(bindingName, token);
|
|
_current["(usages)"][bindingName]["(reassigned)"].push(token);
|
},
|
|
modify: function(bindingName, token) {
|
|
_setupUsages(bindingName);
|
|
_current["(usages)"][bindingName]["(onlyUsedSubFunction)"] = false;
|
_current["(usages)"][bindingName]["(modified)"].push(token);
|
},
|
|
/**
|
* Create a new block-scoped binding and add it to the current scope. See
|
* the `funct.add` method for coresponding logic to create
|
* function-scoped bindings.
|
*
|
* @param {string} bindingName - the value of the identifier
|
* @param {string} type - the type of the binding; one of "class",
|
* "const", "function", "import", or "let"
|
* @param {object} tok - the token that triggered the definition
|
* @param {boolean} unused - `true` if the binding has not been
|
* referenced
|
* @param {boolean} initialized - `true` if the binding has been
|
* initialized (as is the case with
|
* bindings created via `import`
|
* declarations)
|
*/
|
add: function(bindingName, type, tok, unused, initialized) {
|
_current["(bindings)"][bindingName] = {
|
"(type)" : type,
|
"(token)": tok,
|
"(initialized)": !!initialized,
|
"(blockscoped)": true,
|
"(unused)": unused };
|
},
|
|
addLabel: function(labelName, opts) {
|
var token = opts.token;
|
if (scopeManagerInst.funct.hasLabel(labelName)) {
|
warning("E011", token, labelName);
|
}
|
else if (state.option.shadow === "outer") {
|
if (scopeManagerInst.funct.has(labelName)) {
|
warning("W004", token, labelName);
|
} else {
|
_checkOuterShadow(labelName, token);
|
}
|
}
|
_current["(labels)"][labelName] = token;
|
}
|
}
|
};
|
return scopeManagerInst;
|
};
|
|
module.exports = scopeManager;
|
