TestQA/node_modules/escope/lib/scope.js

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.ClassScope = exports.ForScope = exports.FunctionScope = exports.SwitchScope = exports.BlockScope = exports.TDZScope = exports.WithScope = exports.CatchScope = exports.FunctionExpressionNameScope = exports.ModuleScope = exports.GlobalScope = undefined;

var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       Redistribution and use in source and binary forms, with or without
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       modification, are permitted provided that the following conditions are met:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Redistributions of source code must retain the above copyright
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           notice, this list of conditions and the following disclaimer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Redistributions in binary form must reproduce the above copyright
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           notice, this list of conditions and the following disclaimer in the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           documentation and/or other materials provided with the distribution.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     */

var _estraverse = require('estraverse');

var _es6Map = require('es6-map');

var _es6Map2 = _interopRequireDefault(_es6Map);

var _reference = require('./reference');

var _reference2 = _interopRequireDefault(_reference);

var _variable = require('./variable');

var _variable2 = _interopRequireDefault(_variable);

var _definition = require('./definition');

var _definition2 = _interopRequireDefault(_definition);

var _assert = require('assert');

var _assert2 = _interopRequireDefault(_assert);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function isStrictScope(scope, block, isMethodDefinition, useDirective) {
    var body, i, iz, stmt, expr;

    // When upper scope is exists and strict, inner scope is also strict.
    if (scope.upper && scope.upper.isStrict) {
        return true;
    }

    // ArrowFunctionExpression's scope is always strict scope.
    if (block.type === _estraverse.Syntax.ArrowFunctionExpression) {
        return true;
    }

    if (isMethodDefinition) {
        return true;
    }

    if (scope.type === 'class' || scope.type === 'module') {
        return true;
    }

    if (scope.type === 'block' || scope.type === 'switch') {
        return false;
    }

    if (scope.type === 'function') {
        if (block.type === _estraverse.Syntax.Program) {
            body = block;
        } else {
            body = block.body;
        }
    } else if (scope.type === 'global') {
        body = block;
    } else {
        return false;
    }

    // Search 'use strict' directive.
    if (useDirective) {
        for (i = 0, iz = body.body.length; i < iz; ++i) {
            stmt = body.body[i];
            if (stmt.type !== _estraverse.Syntax.DirectiveStatement) {
                break;
            }
            if (stmt.raw === '"use strict"' || stmt.raw === '\'use strict\'') {
                return true;
            }
        }
    } else {
        for (i = 0, iz = body.body.length; i < iz; ++i) {
            stmt = body.body[i];
            if (stmt.type !== _estraverse.Syntax.ExpressionStatement) {
                break;
            }
            expr = stmt.expression;
            if (expr.type !== _estraverse.Syntax.Literal || typeof expr.value !== 'string') {
                break;
            }
            if (expr.raw != null) {
                if (expr.raw === '"use strict"' || expr.raw === '\'use strict\'') {
                    return true;
                }
            } else {
                if (expr.value === 'use strict') {
                    return true;
                }
            }
        }
    }
    return false;
}

function registerScope(scopeManager, scope) {
    var scopes;

    scopeManager.scopes.push(scope);

    scopes = scopeManager.__nodeToScope.get(scope.block);
    if (scopes) {
        scopes.push(scope);
    } else {
        scopeManager.__nodeToScope.set(scope.block, [scope]);
    }
}

function shouldBeStatically(def) {
    return def.type === _variable2.default.ClassName || def.type === _variable2.default.Variable && def.parent.kind !== 'var';
}

/**
 * @class Scope
 */

var Scope = function () {
    function Scope(scopeManager, type, upperScope, block, isMethodDefinition) {
        _classCallCheck(this, Scope);

        /**
         * One of 'TDZ', 'module', 'block', 'switch', 'function', 'catch', 'with', 'function', 'class', 'global'.
         * @member {String} Scope#type
         */
        this.type = type;
        /**
        * The scoped {@link Variable}s of this scope, as <code>{ Variable.name
        * : Variable }</code>.
        * @member {Map} Scope#set
        */
        this.set = new _es6Map2.default();
        /**
         * The tainted variables of this scope, as <code>{ Variable.name :
         * boolean }</code>.
         * @member {Map} Scope#taints */
        this.taints = new _es6Map2.default();
        /**
         * Generally, through the lexical scoping of JS you can always know
         * which variable an identifier in the source code refers to. There are
         * a few exceptions to this rule. With 'global' and 'with' scopes you
         * can only decide at runtime which variable a reference refers to.
         * Moreover, if 'eval()' is used in a scope, it might introduce new
         * bindings in this or its parent scopes.
         * All those scopes are considered 'dynamic'.
         * @member {boolean} Scope#dynamic
         */
        this.dynamic = this.type === 'global' || this.type === 'with';
        /**
         * A reference to the scope-defining syntax node.
         * @member {esprima.Node} Scope#block
         */
        this.block = block;
        /**
        * The {@link Reference|references} that are not resolved with this scope.
        * @member {Reference[]} Scope#through
        */
        this.through = [];
        /**
        * The scoped {@link Variable}s of this scope. In the case of a
        * 'function' scope this includes the automatic argument <em>arguments</em> as
        * its first element, as well as all further formal arguments.
        * @member {Variable[]} Scope#variables
        */
        this.variables = [];
        /**
        * Any variable {@link Reference|reference} found in this scope. This
        * includes occurrences of local variables as well as variables from
        * parent scopes (including the global scope). For local variables
        * this also includes defining occurrences (like in a 'var' statement).
        * In a 'function' scope this does not include the occurrences of the
        * formal parameter in the parameter list.
        * @member {Reference[]} Scope#references
        */
        this.references = [];

        /**
        * For 'global' and 'function' scopes, this is a self-reference. For
        * other scope types this is the <em>variableScope</em> value of the
        * parent scope.
        * @member {Scope} Scope#variableScope
        */
        this.variableScope = this.type === 'global' || this.type === 'function' || this.type === 'module' ? this : upperScope.variableScope;
        /**
        * Whether this scope is created by a FunctionExpression.
        * @member {boolean} Scope#functionExpressionScope
        */
        this.functionExpressionScope = false;
        /**
        * Whether this is a scope that contains an 'eval()' invocation.
        * @member {boolean} Scope#directCallToEvalScope
        */
        this.directCallToEvalScope = false;
        /**
        * @member {boolean} Scope#thisFound
        */
        this.thisFound = false;

        this.__left = [];

        /**
        * Reference to the parent {@link Scope|scope}.
        * @member {Scope} Scope#upper
        */
        this.upper = upperScope;
        /**
        * Whether 'use strict' is in effect in this scope.
        * @member {boolean} Scope#isStrict
        */
        this.isStrict = isStrictScope(this, block, isMethodDefinition, scopeManager.__useDirective());

        /**
        * List of nested {@link Scope}s.
        * @member {Scope[]} Scope#childScopes
        */
        this.childScopes = [];
        if (this.upper) {
            this.upper.childScopes.push(this);
        }

        this.__declaredVariables = scopeManager.__declaredVariables;

        registerScope(scopeManager, this);
    }

    _createClass(Scope, [{
        key: '__shouldStaticallyClose',
        value: function __shouldStaticallyClose(scopeManager) {
            return !this.dynamic || scopeManager.__isOptimistic();
        }
    }, {
        key: '__shouldStaticallyCloseForGlobal',
        value: function __shouldStaticallyCloseForGlobal(ref) {
            // On global scope, let/const/class declarations should be resolved statically.
            var name = ref.identifier.name;
            if (!this.set.has(name)) {
                return false;
            }

            var variable = this.set.get(name);
            var defs = variable.defs;
            return defs.length > 0 && defs.every(shouldBeStatically);
        }
    }, {
        key: '__staticCloseRef',
        value: function __staticCloseRef(ref) {
            if (!this.__resolve(ref)) {
                this.__delegateToUpperScope(ref);
            }
        }
    }, {
        key: '__dynamicCloseRef',
        value: function __dynamicCloseRef(ref) {
            // notify all names are through to global
            var current = this;
            do {
                current.through.push(ref);
                current = current.upper;
            } while (current);
        }
    }, {
        key: '__globalCloseRef',
        value: function __globalCloseRef(ref) {
            // let/const/class declarations should be resolved statically.
            // others should be resolved dynamically.
            if (this.__shouldStaticallyCloseForGlobal(ref)) {
                this.__staticCloseRef(ref);
            } else {
                this.__dynamicCloseRef(ref);
            }
        }
    }, {
        key: '__close',
        value: function __close(scopeManager) {
            var closeRef;
            if (this.__shouldStaticallyClose(scopeManager)) {
                closeRef = this.__staticCloseRef;
            } else if (this.type !== 'global') {
                closeRef = this.__dynamicCloseRef;
            } else {
                closeRef = this.__globalCloseRef;
            }

            // Try Resolving all references in this scope.
            for (var i = 0, iz = this.__left.length; i < iz; ++i) {
                var ref = this.__left[i];
                closeRef.call(this, ref);
            }
            this.__left = null;

            return this.upper;
        }
    }, {
        key: '__resolve',
        value: function __resolve(ref) {
            var variable, name;
            name = ref.identifier.name;
            if (this.set.has(name)) {
                variable = this.set.get(name);
                variable.references.push(ref);
                variable.stack = variable.stack && ref.from.variableScope === this.variableScope;
                if (ref.tainted) {
                    variable.tainted = true;
                    this.taints.set(variable.name, true);
                }
                ref.resolved = variable;
                return true;
            }
            return false;
        }
    }, {
        key: '__delegateToUpperScope',
        value: function __delegateToUpperScope(ref) {
            if (this.upper) {
                this.upper.__left.push(ref);
            }
            this.through.push(ref);
        }
    }, {
        key: '__addDeclaredVariablesOfNode',
        value: function __addDeclaredVariablesOfNode(variable, node) {
            if (node == null) {
                return;
            }

            var variables = this.__declaredVariables.get(node);
            if (variables == null) {
                variables = [];
                this.__declaredVariables.set(node, variables);
            }
            if (variables.indexOf(variable) === -1) {
                variables.push(variable);
            }
        }
    }, {
        key: '__defineGeneric',
        value: function __defineGeneric(name, set, variables, node, def) {
            var variable;

            variable = set.get(name);
            if (!variable) {
                variable = new _variable2.default(name, this);
                set.set(name, variable);
                variables.push(variable);
            }

            if (def) {
                variable.defs.push(def);
                if (def.type !== _variable2.default.TDZ) {
                    this.__addDeclaredVariablesOfNode(variable, def.node);
                    this.__addDeclaredVariablesOfNode(variable, def.parent);
                }
            }
            if (node) {
                variable.identifiers.push(node);
            }
        }
    }, {
        key: '__define',
        value: function __define(node, def) {
            if (node && node.type === _estraverse.Syntax.Identifier) {
                this.__defineGeneric(node.name, this.set, this.variables, node, def);
            }
        }
    }, {
        key: '__referencing',
        value: function __referencing(node, assign, writeExpr, maybeImplicitGlobal, partial, init) {
            // because Array element may be null
            if (!node || node.type !== _estraverse.Syntax.Identifier) {
                return;
            }

            // Specially handle like `this`.
            if (node.name === 'super') {
                return;
            }

            var ref = new _reference2.default(node, this, assign || _reference2.default.READ, writeExpr, maybeImplicitGlobal, !!partial, !!init);
            this.references.push(ref);
            this.__left.push(ref);
        }
    }, {
        key: '__detectEval',
        value: function __detectEval() {
            var current;
            current = this;
            this.directCallToEvalScope = true;
            do {
                current.dynamic = true;
                current = current.upper;
            } while (current);
        }
    }, {
        key: '__detectThis',
        value: function __detectThis() {
            this.thisFound = true;
        }
    }, {
        key: '__isClosed',
        value: function __isClosed() {
            return this.__left === null;
        }

        /**
         * returns resolved {Reference}
         * @method Scope#resolve
         * @param {Esprima.Identifier} ident - identifier to be resolved.
         * @return {Reference}
         */

    }, {
        key: 'resolve',
        value: function resolve(ident) {
            var ref, i, iz;
            (0, _assert2.default)(this.__isClosed(), 'Scope should be closed.');
            (0, _assert2.default)(ident.type === _estraverse.Syntax.Identifier, 'Target should be identifier.');
            for (i = 0, iz = this.references.length; i < iz; ++i) {
                ref = this.references[i];
                if (ref.identifier === ident) {
                    return ref;
                }
            }
            return null;
        }

        /**
         * returns this scope is static
         * @method Scope#isStatic
         * @return {boolean}
         */

    }, {
        key: 'isStatic',
        value: function isStatic() {
            return !this.dynamic;
        }

        /**
         * returns this scope has materialized arguments
         * @method Scope#isArgumentsMaterialized
         * @return {boolean}
         */

    }, {
        key: 'isArgumentsMaterialized',
        value: function isArgumentsMaterialized() {
            return true;
        }

        /**
         * returns this scope has materialized `this` reference
         * @method Scope#isThisMaterialized
         * @return {boolean}
         */

    }, {
        key: 'isThisMaterialized',
        value: function isThisMaterialized() {
            return true;
        }
    }, {
        key: 'isUsedName',
        value: function isUsedName(name) {
            if (this.set.has(name)) {
                return true;
            }
            for (var i = 0, iz = this.through.length; i < iz; ++i) {
                if (this.through[i].identifier.name === name) {
                    return true;
                }
            }
            return false;
        }
    }]);

    return Scope;
}();

exports.default = Scope;

var GlobalScope = exports.GlobalScope = function (_Scope) {
    _inherits(GlobalScope, _Scope);

    function GlobalScope(scopeManager, block) {
        _classCallCheck(this, GlobalScope);

        var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(GlobalScope).call(this, scopeManager, 'global', null, block, false));

        _this.implicit = {
            set: new _es6Map2.default(),
            variables: [],
            /**
            * List of {@link Reference}s that are left to be resolved (i.e. which
            * need to be linked to the variable they refer to).
            * @member {Reference[]} Scope#implicit#left
            */
            left: []
        };
        return _this;
    }

    _createClass(GlobalScope, [{
        key: '__close',
        value: function __close(scopeManager) {
            var implicit = [];
            for (var i = 0, iz = this.__left.length; i < iz; ++i) {
                var ref = this.__left[i];
                if (ref.__maybeImplicitGlobal && !this.set.has(ref.identifier.name)) {
                    implicit.push(ref.__maybeImplicitGlobal);
                }
            }

            // create an implicit global variable from assignment expression
            for (var _i = 0, _iz = implicit.length; _i < _iz; ++_i) {
                var info = implicit[_i];
                this.__defineImplicit(info.pattern, new _definition2.default(_variable2.default.ImplicitGlobalVariable, info.pattern, info.node, null, null, null));
            }

            this.implicit.left = this.__left;

            return _get(Object.getPrototypeOf(GlobalScope.prototype), '__close', this).call(this, scopeManager);
        }
    }, {
        key: '__defineImplicit',
        value: function __defineImplicit(node, def) {
            if (node && node.type === _estraverse.Syntax.Identifier) {
                this.__defineGeneric(node.name, this.implicit.set, this.implicit.variables, node, def);
            }
        }
    }]);

    return GlobalScope;
}(Scope);

var ModuleScope = exports.ModuleScope = function (_Scope2) {
    _inherits(ModuleScope, _Scope2);

    function ModuleScope(scopeManager, upperScope, block) {
        _classCallCheck(this, ModuleScope);

        return _possibleConstructorReturn(this, Object.getPrototypeOf(ModuleScope).call(this, scopeManager, 'module', upperScope, block, false));
    }

    return ModuleScope;
}(Scope);

var FunctionExpressionNameScope = exports.FunctionExpressionNameScope = function (_Scope3) {
    _inherits(FunctionExpressionNameScope, _Scope3);

    function FunctionExpressionNameScope(scopeManager, upperScope, block) {
        _classCallCheck(this, FunctionExpressionNameScope);

        var _this3 = _possibleConstructorReturn(this, Object.getPrototypeOf(FunctionExpressionNameScope).call(this, scopeManager, 'function-expression-name', upperScope, block, false));

        _this3.__define(block.id, new _definition2.default(_variable2.default.FunctionName, block.id, block, null, null, null));
        _this3.functionExpressionScope = true;
        return _this3;
    }

    return FunctionExpressionNameScope;
}(Scope);

var CatchScope = exports.CatchScope = function (_Scope4) {
    _inherits(CatchScope, _Scope4);

    function CatchScope(scopeManager, upperScope, block) {
        _classCallCheck(this, CatchScope);

        return _possibleConstructorReturn(this, Object.getPrototypeOf(CatchScope).call(this, scopeManager, 'catch', upperScope, block, false));
    }

    return CatchScope;
}(Scope);

var WithScope = exports.WithScope = function (_Scope5) {
    _inherits(WithScope, _Scope5);

    function WithScope(scopeManager, upperScope, block) {
        _classCallCheck(this, WithScope);

        return _possibleConstructorReturn(this, Object.getPrototypeOf(WithScope).call(this, scopeManager, 'with', upperScope, block, false));
    }

    _createClass(WithScope, [{
        key: '__close',
        value: function __close(scopeManager) {
            if (this.__shouldStaticallyClose(scopeManager)) {
                return _get(Object.getPrototypeOf(WithScope.prototype), '__close', this).call(this, scopeManager);
            }

            for (var i = 0, iz = this.__left.length; i < iz; ++i) {
                var ref = this.__left[i];
                ref.tainted = true;
                this.__delegateToUpperScope(ref);
            }
            this.__left = null;

            return this.upper;
        }
    }]);

    return WithScope;
}(Scope);

var TDZScope = exports.TDZScope = function (_Scope6) {
    _inherits(TDZScope, _Scope6);

    function TDZScope(scopeManager, upperScope, block) {
        _classCallCheck(this, TDZScope);

        return _possibleConstructorReturn(this, Object.getPrototypeOf(TDZScope).call(this, scopeManager, 'TDZ', upperScope, block, false));
    }

    return TDZScope;
}(Scope);

var BlockScope = exports.BlockScope = function (_Scope7) {
    _inherits(BlockScope, _Scope7);

    function BlockScope(scopeManager, upperScope, block) {
        _classCallCheck(this, BlockScope);

        return _possibleConstructorReturn(this, Object.getPrototypeOf(BlockScope).call(this, scopeManager, 'block', upperScope, block, false));
    }

    return BlockScope;
}(Scope);

var SwitchScope = exports.SwitchScope = function (_Scope8) {
    _inherits(SwitchScope, _Scope8);

    function SwitchScope(scopeManager, upperScope, block) {
        _classCallCheck(this, SwitchScope);

        return _possibleConstructorReturn(this, Object.getPrototypeOf(SwitchScope).call(this, scopeManager, 'switch', upperScope, block, false));
    }

    return SwitchScope;
}(Scope);

var FunctionScope = exports.FunctionScope = function (_Scope9) {
    _inherits(FunctionScope, _Scope9);

    function FunctionScope(scopeManager, upperScope, block, isMethodDefinition) {
        _classCallCheck(this, FunctionScope);

        // section 9.2.13, FunctionDeclarationInstantiation.
        // NOTE Arrow functions never have an arguments objects.

        var _this9 = _possibleConstructorReturn(this, Object.getPrototypeOf(FunctionScope).call(this, scopeManager, 'function', upperScope, block, isMethodDefinition));

        if (_this9.block.type !== _estraverse.Syntax.ArrowFunctionExpression) {
            _this9.__defineArguments();
        }
        return _this9;
    }

    _createClass(FunctionScope, [{
        key: 'isArgumentsMaterialized',
        value: function isArgumentsMaterialized() {
            // TODO(Constellation)
            // We can more aggressive on this condition like this.
            //
            // function t() {
            //     // arguments of t is always hidden.
            //     function arguments() {
            //     }
            // }
            if (this.block.type === _estraverse.Syntax.ArrowFunctionExpression) {
                return false;
            }

            if (!this.isStatic()) {
                return true;
            }

            var variable = this.set.get('arguments');
            (0, _assert2.default)(variable, 'Always have arguments variable.');
            return variable.tainted || variable.references.length !== 0;
        }
    }, {
        key: 'isThisMaterialized',
        value: function isThisMaterialized() {
            if (!this.isStatic()) {
                return true;
            }
            return this.thisFound;
        }
    }, {
        key: '__defineArguments',
        value: function __defineArguments() {
            this.__defineGeneric('arguments', this.set, this.variables, null, null);
            this.taints.set('arguments', true);
        }
    }]);

    return FunctionScope;
}(Scope);

var ForScope = exports.ForScope = function (_Scope10) {
    _inherits(ForScope, _Scope10);

    function ForScope(scopeManager, upperScope, block) {
        _classCallCheck(this, ForScope);

        return _possibleConstructorReturn(this, Object.getPrototypeOf(ForScope).call(this, scopeManager, 'for', upperScope, block, false));
    }

    return ForScope;
}(Scope);

var ClassScope = exports.ClassScope = function (_Scope11) {
    _inherits(ClassScope, _Scope11);

    function ClassScope(scopeManager, upperScope, block) {
        _classCallCheck(this, ClassScope);

        return _possibleConstructorReturn(this, Object.getPrototypeOf(ClassScope).call(this, scopeManager, 'class', upperScope, block, false));
    }

    return ClassScope;
}(Scope);

/* vim: set sw=4 ts=4 et tw=80 : */
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["scope.js"],"names":[],"mappings":"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","file":"scope.js","sourcesContent":["/*\n  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>\n\n  Redistribution and use in source and binary forms, with or without\n  modification, are permitted provided that the following conditions are met:\n\n    * Redistributions of source code must retain the above copyright\n      notice, this list of conditions and the following disclaimer.\n    * Redistributions in binary form must reproduce the above copyright\n      notice, this list of conditions and the following disclaimer in the\n      documentation and/or other materials provided with the distribution.\n\n  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport { Syntax } from 'estraverse';\nimport Map from 'es6-map';\n\nimport Reference from './reference';\nimport Variable from './variable';\nimport Definition from './definition';\nimport assert from 'assert';\n\nfunction isStrictScope(scope, block, isMethodDefinition, useDirective) {\n    var body, i, iz, stmt, expr;\n\n    // When upper scope is exists and strict, inner scope is also strict.\n    if (scope.upper && scope.upper.isStrict) {\n        return true;\n    }\n\n    // ArrowFunctionExpression's scope is always strict scope.\n    if (block.type === Syntax.ArrowFunctionExpression) {\n        return true;\n    }\n\n    if (isMethodDefinition) {\n        return true;\n    }\n\n    if (scope.type === 'class' || scope.type === 'module') {\n        return true;\n    }\n\n    if (scope.type === 'block' || scope.type === 'switch') {\n        return false;\n    }\n\n    if (scope.type === 'function') {\n        if (block.type === Syntax.Program) {\n            body = block;\n        } else {\n            body = block.body;\n        }\n    } else if (scope.type === 'global') {\n        body = block;\n    } else {\n        return false;\n    }\n\n    // Search 'use strict' directive.\n    if (useDirective) {\n        for (i = 0, iz = body.body.length; i < iz; ++i) {\n            stmt = body.body[i];\n            if (stmt.type !== Syntax.DirectiveStatement) {\n                break;\n            }\n            if (stmt.raw === '\"use strict\"' || stmt.raw === '\\'use strict\\'') {\n                return true;\n            }\n        }\n    } else {\n        for (i = 0, iz = body.body.length; i < iz; ++i) {\n            stmt = body.body[i];\n            if (stmt.type !== Syntax.ExpressionStatement) {\n                break;\n            }\n            expr = stmt.expression;\n            if (expr.type !== Syntax.Literal || typeof expr.value !== 'string') {\n                break;\n            }\n            if (expr.raw != null) {\n                if (expr.raw === '\"use strict\"' || expr.raw === '\\'use strict\\'') {\n                    return true;\n                }\n            } else {\n                if (expr.value === 'use strict') {\n                    return true;\n                }\n            }\n        }\n    }\n    return false;\n}\n\nfunction registerScope(scopeManager, scope) {\n    var scopes;\n\n    scopeManager.scopes.push(scope);\n\n    scopes = scopeManager.__nodeToScope.get(scope.block);\n    if (scopes) {\n        scopes.push(scope);\n    } else {\n        scopeManager.__nodeToScope.set(scope.block, [ scope ]);\n    }\n}\n\nfunction shouldBeStatically(def) {\n    return (\n        (def.type === Variable.ClassName) ||\n        (def.type === Variable.Variable && def.parent.kind !== 'var')\n    );\n}\n\n/**\n * @class Scope\n */\nexport default class Scope {\n    constructor(scopeManager, type, upperScope, block, isMethodDefinition) {\n        /**\n         * One of 'TDZ', 'module', 'block', 'switch', 'function', 'catch', 'with', 'function', 'class', 'global'.\n         * @member {String} Scope#type\n         */\n        this.type = type;\n         /**\n         * The scoped {@link Variable}s of this scope, as <code>{ Variable.name\n         * : Variable }</code>.\n         * @member {Map} Scope#set\n         */\n        this.set = new Map();\n        /**\n         * The tainted variables of this scope, as <code>{ Variable.name :\n         * boolean }</code>.\n         * @member {Map} Scope#taints */\n        this.taints = new Map();\n        /**\n         * Generally, through the lexical scoping of JS you can always know\n         * which variable an identifier in the source code refers to. There are\n         * a few exceptions to this rule. With 'global' and 'with' scopes you\n         * can only decide at runtime which variable a reference refers to.\n         * Moreover, if 'eval()' is used in a scope, it might introduce new\n         * bindings in this or its parent scopes.\n         * All those scopes are considered 'dynamic'.\n         * @member {boolean} Scope#dynamic\n         */\n        this.dynamic = this.type === 'global' || this.type === 'with';\n        /**\n         * A reference to the scope-defining syntax node.\n         * @member {esprima.Node} Scope#block\n         */\n        this.block = block;\n         /**\n         * The {@link Reference|references} that are not resolved with this scope.\n         * @member {Reference[]} Scope#through\n         */\n        this.through = [];\n         /**\n         * The scoped {@link Variable}s of this scope. In the case of a\n         * 'function' scope this includes the automatic argument <em>arguments</em> as\n         * its first element, as well as all further formal arguments.\n         * @member {Variable[]} Scope#variables\n         */\n        this.variables = [];\n         /**\n         * Any variable {@link Reference|reference} found in this scope. This\n         * includes occurrences of local variables as well as variables from\n         * parent scopes (including the global scope). For local variables\n         * this also includes defining occurrences (like in a 'var' statement).\n         * In a 'function' scope this does not include the occurrences of the\n         * formal parameter in the parameter list.\n         * @member {Reference[]} Scope#references\n         */\n        this.references = [];\n\n         /**\n         * For 'global' and 'function' scopes, this is a self-reference. For\n         * other scope types this is the <em>variableScope</em> value of the\n         * parent scope.\n         * @member {Scope} Scope#variableScope\n         */\n        this.variableScope =\n            (this.type === 'global' || this.type === 'function' || this.type === 'module') ? this : upperScope.variableScope;\n         /**\n         * Whether this scope is created by a FunctionExpression.\n         * @member {boolean} Scope#functionExpressionScope\n         */\n        this.functionExpressionScope = false;\n         /**\n         * Whether this is a scope that contains an 'eval()' invocation.\n         * @member {boolean} Scope#directCallToEvalScope\n         */\n        this.directCallToEvalScope = false;\n         /**\n         * @member {boolean} Scope#thisFound\n         */\n        this.thisFound = false;\n\n        this.__left = [];\n\n         /**\n         * Reference to the parent {@link Scope|scope}.\n         * @member {Scope} Scope#upper\n         */\n        this.upper = upperScope;\n         /**\n         * Whether 'use strict' is in effect in this scope.\n         * @member {boolean} Scope#isStrict\n         */\n        this.isStrict = isStrictScope(this, block, isMethodDefinition, scopeManager.__useDirective());\n\n         /**\n         * List of nested {@link Scope}s.\n         * @member {Scope[]} Scope#childScopes\n         */\n        this.childScopes = [];\n        if (this.upper) {\n            this.upper.childScopes.push(this);\n        }\n\n        this.__declaredVariables = scopeManager.__declaredVariables;\n\n        registerScope(scopeManager, this);\n    }\n\n    __shouldStaticallyClose(scopeManager) {\n        return (!this.dynamic || scopeManager.__isOptimistic());\n    }\n\n    __shouldStaticallyCloseForGlobal(ref) {\n        // On global scope, let/const/class declarations should be resolved statically.\n        var name = ref.identifier.name;\n        if (!this.set.has(name)) {\n            return false;\n        }\n\n        var variable = this.set.get(name);\n        var defs = variable.defs;\n        return defs.length > 0 && defs.every(shouldBeStatically);\n    }\n\n    __staticCloseRef(ref) {\n        if (!this.__resolve(ref)) {\n            this.__delegateToUpperScope(ref);\n        }\n    }\n\n    __dynamicCloseRef(ref) {\n        // notify all names are through to global\n        let current = this;\n        do {\n            current.through.push(ref);\n            current = current.upper;\n        } while (current);\n    }\n\n    __globalCloseRef(ref) {\n        // let/const/class declarations should be resolved statically.\n        // others should be resolved dynamically.\n        if (this.__shouldStaticallyCloseForGlobal(ref)) {\n            this.__staticCloseRef(ref);\n        } else {\n            this.__dynamicCloseRef(ref);\n        }\n    }\n\n    __close(scopeManager) {\n        var closeRef;\n        if (this.__shouldStaticallyClose(scopeManager)) {\n            closeRef = this.__staticCloseRef;\n        } else if (this.type !== 'global') {\n            closeRef = this.__dynamicCloseRef;\n        } else {\n            closeRef = this.__globalCloseRef;\n        }\n\n        // Try Resolving all references in this scope.\n        for (let i = 0, iz = this.__left.length; i < iz; ++i) {\n            let ref = this.__left[i];\n            closeRef.call(this, ref);\n        }\n        this.__left = null;\n\n        return this.upper;\n    }\n\n    __resolve(ref) {\n        var variable, name;\n        name = ref.identifier.name;\n        if (this.set.has(name)) {\n            variable = this.set.get(name);\n            variable.references.push(ref);\n            variable.stack = variable.stack && ref.from.variableScope === this.variableScope;\n            if (ref.tainted) {\n                variable.tainted = true;\n                this.taints.set(variable.name, true);\n            }\n            ref.resolved = variable;\n            return true;\n        }\n        return false;\n    }\n\n    __delegateToUpperScope(ref) {\n        if (this.upper) {\n            this.upper.__left.push(ref);\n        }\n        this.through.push(ref);\n    }\n\n    __addDeclaredVariablesOfNode(variable, node) {\n        if (node == null) {\n            return;\n        }\n\n        var variables = this.__declaredVariables.get(node);\n        if (variables == null) {\n            variables = [];\n            this.__declaredVariables.set(node, variables);\n        }\n        if (variables.indexOf(variable) === -1) {\n            variables.push(variable);\n        }\n    }\n\n    __defineGeneric(name, set, variables, node, def) {\n        var variable;\n\n        variable = set.get(name);\n        if (!variable) {\n            variable = new Variable(name, this);\n            set.set(name, variable);\n            variables.push(variable);\n        }\n\n        if (def) {\n            variable.defs.push(def);\n            if (def.type !== Variable.TDZ) {\n                this.__addDeclaredVariablesOfNode(variable, def.node);\n                this.__addDeclaredVariablesOfNode(variable, def.parent);\n            }\n        }\n        if (node) {\n            variable.identifiers.push(node);\n        }\n    }\n\n    __define(node, def) {\n        if (node && node.type === Syntax.Identifier) {\n            this.__defineGeneric(\n                    node.name,\n                    this.set,\n                    this.variables,\n                    node,\n                    def);\n        }\n    }\n\n    __referencing(node, assign, writeExpr, maybeImplicitGlobal, partial, init) {\n        // because Array element may be null\n        if (!node || node.type !== Syntax.Identifier) {\n            return;\n        }\n\n        // Specially handle like `this`.\n        if (node.name === 'super') {\n            return;\n        }\n\n        let ref = new Reference(node, this, assign || Reference.READ, writeExpr, maybeImplicitGlobal, !!partial, !!init);\n        this.references.push(ref);\n        this.__left.push(ref);\n    }\n\n    __detectEval() {\n        var current;\n        current = this;\n        this.directCallToEvalScope = true;\n        do {\n            current.dynamic = true;\n            current = current.upper;\n        } while (current);\n    }\n\n    __detectThis() {\n        this.thisFound = true;\n    }\n\n    __isClosed() {\n        return this.__left === null;\n    }\n\n    /**\n     * returns resolved {Reference}\n     * @method Scope#resolve\n     * @param {Esprima.Identifier} ident - identifier to be resolved.\n     * @return {Reference}\n     */\n    resolve(ident) {\n        var ref, i, iz;\n        assert(this.__isClosed(), 'Scope should be closed.');\n        assert(ident.type === Syntax.Identifier, 'Target should be identifier.');\n        for (i = 0, iz = this.references.length; i < iz; ++i) {\n            ref = this.references[i];\n            if (ref.identifier === ident) {\n                return ref;\n            }\n        }\n        return null;\n    }\n\n    /**\n     * returns this scope is static\n     * @method Scope#isStatic\n     * @return {boolean}\n     */\n    isStatic() {\n        return !this.dynamic;\n    }\n\n    /**\n     * returns this scope has materialized arguments\n     * @method Scope#isArgumentsMaterialized\n     * @return {boolean}\n     */\n    isArgumentsMaterialized() {\n        return true;\n    }\n\n    /**\n     * returns this scope has materialized `this` reference\n     * @method Scope#isThisMaterialized\n     * @return {boolean}\n     */\n    isThisMaterialized() {\n        return true;\n    }\n\n    isUsedName(name) {\n        if (this.set.has(name)) {\n            return true;\n        }\n        for (var i = 0, iz = this.through.length; i < iz; ++i) {\n            if (this.through[i].identifier.name === name) {\n                return true;\n            }\n        }\n        return false;\n    }\n}\n\nexport class GlobalScope extends Scope {\n    constructor(scopeManager, block) {\n        super(scopeManager, 'global', null, block, false);\n        this.implicit = {\n            set: new Map(),\n            variables: [],\n            /**\n            * List of {@link Reference}s that are left to be resolved (i.e. which\n            * need to be linked to the variable they refer to).\n            * @member {Reference[]} Scope#implicit#left\n            */\n            left: []\n        };\n    }\n\n    __close(scopeManager) {\n        let implicit = [];\n        for (let i = 0, iz = this.__left.length; i < iz; ++i) {\n            let ref = this.__left[i];\n            if (ref.__maybeImplicitGlobal && !this.set.has(ref.identifier.name)) {\n                implicit.push(ref.__maybeImplicitGlobal);\n            }\n        }\n\n        // create an implicit global variable from assignment expression\n        for (let i = 0, iz = implicit.length; i < iz; ++i) {\n            let info = implicit[i];\n            this.__defineImplicit(info.pattern,\n                    new Definition(\n                        Variable.ImplicitGlobalVariable,\n                        info.pattern,\n                        info.node,\n                        null,\n                        null,\n                        null\n                    ));\n\n        }\n\n        this.implicit.left = this.__left;\n\n        return super.__close(scopeManager);\n    }\n\n    __defineImplicit(node, def) {\n        if (node && node.type === Syntax.Identifier) {\n            this.__defineGeneric(\n                    node.name,\n                    this.implicit.set,\n                    this.implicit.variables,\n                    node,\n                    def);\n        }\n    }\n}\n\nexport class ModuleScope extends Scope {\n    constructor(scopeManager, upperScope, block) {\n        super(scopeManager, 'module', upperScope, block, false);\n    }\n}\n\nexport class FunctionExpressionNameScope extends Scope {\n    constructor(scopeManager, upperScope, block) {\n        super(scopeManager, 'function-expression-name', upperScope, block, false);\n        this.__define(block.id,\n                new Definition(\n                    Variable.FunctionName,\n                    block.id,\n                    block,\n                    null,\n                    null,\n                    null\n                ));\n        this.functionExpressionScope = true;\n    }\n}\n\nexport class CatchScope extends Scope {\n    constructor(scopeManager, upperScope, block) {\n        super(scopeManager, 'catch', upperScope, block, false);\n    }\n}\n\nexport class WithScope extends Scope {\n    constructor(scopeManager, upperScope, block) {\n        super(scopeManager, 'with', upperScope, block, false);\n    }\n\n    __close(scopeManager) {\n        if (this.__shouldStaticallyClose(scopeManager)) {\n            return super.__close(scopeManager);\n        }\n\n        for (let i = 0, iz = this.__left.length; i < iz; ++i) {\n            let ref = this.__left[i];\n            ref.tainted = true;\n            this.__delegateToUpperScope(ref);\n        }\n        this.__left = null;\n\n        return this.upper;\n    }\n}\n\nexport class TDZScope extends Scope {\n    constructor(scopeManager, upperScope, block) {\n        super(scopeManager, 'TDZ', upperScope, block, false);\n    }\n}\n\nexport class BlockScope extends Scope {\n    constructor(scopeManager, upperScope, block) {\n        super(scopeManager, 'block', upperScope, block, false);\n    }\n}\n\nexport class SwitchScope extends Scope {\n    constructor(scopeManager, upperScope, block) {\n        super(scopeManager, 'switch', upperScope, block, false);\n    }\n}\n\nexport class FunctionScope extends Scope {\n    constructor(scopeManager, upperScope, block, isMethodDefinition) {\n        super(scopeManager, 'function', upperScope, block, isMethodDefinition);\n\n        // section 9.2.13, FunctionDeclarationInstantiation.\n        // NOTE Arrow functions never have an arguments objects.\n        if (this.block.type !== Syntax.ArrowFunctionExpression) {\n            this.__defineArguments();\n        }\n    }\n\n    isArgumentsMaterialized() {\n        // TODO(Constellation)\n        // We can more aggressive on this condition like this.\n        //\n        // function t() {\n        //     // arguments of t is always hidden.\n        //     function arguments() {\n        //     }\n        // }\n        if (this.block.type === Syntax.ArrowFunctionExpression) {\n            return false;\n        }\n\n        if (!this.isStatic()) {\n            return true;\n        }\n\n        let variable = this.set.get('arguments');\n        assert(variable, 'Always have arguments variable.');\n        return variable.tainted || variable.references.length  !== 0;\n    }\n\n    isThisMaterialized() {\n        if (!this.isStatic()) {\n            return true;\n        }\n        return this.thisFound;\n    }\n\n    __defineArguments() {\n        this.__defineGeneric(\n                'arguments',\n                this.set,\n                this.variables,\n                null,\n                null);\n        this.taints.set('arguments', true);\n    }\n}\n\nexport class ForScope extends Scope {\n    constructor(scopeManager, upperScope, block) {\n        super(scopeManager, 'for', upperScope, block, false);\n    }\n}\n\nexport class ClassScope extends Scope {\n    constructor(scopeManager, upperScope, block) {\n        super(scopeManager, 'class', upperScope, block, false);\n    }\n}\n\n/* vim: set sw=4 ts=4 et tw=80 : */\n"],"sourceRoot":"/source/"}