cst/lib/plugins/scopes/Variable.js

JavaScript CST Implementation

'use strict';

Object.defineProperty(exports, '__esModule', {
    value: true
});

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

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

var Variable = (function () {
    function Variable(_ref) {
        var name = _ref.name;
        var type = _ref.type;
        var scope = _ref.scope;
        return (function () {
            _classCallCheck(this, Variable);

            this._name = name;
            this._type = type;
            this._scope = scope;
            this._definitions = new Set();
            this._references = new Set();
        }).apply(this, arguments);
    }

    _createClass(Variable, [{
        key: '_addDefinition',
        value: function _addDefinition(definition) {
            definition._variable = this;
            this._definitions.add(definition);
        }
    }, {
        key: '_addReference',
        value: function _addReference(reference) {
            reference._variable = this;
            this._references.add(reference);
        }
    }, {
        key: '_removeDefinition',
        value: function _removeDefinition(definition) {
            this._definitions['delete'](definition);
        }
    }, {
        key: '_removeReference',
        value: function _removeReference(reference) {
            this._references['delete'](reference);
        }
    }, {
        key: '_transferReferences',
        value: function _transferReferences(variable) {
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = this._references[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    var reference = _step.value;

                    this._references['delete'](reference);
                    variable._references.add(reference);
                    reference._variable = variable;
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator['return']) {
                        _iterator['return']();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }
        }
    }, {
        key: 'name',
        get: function get() {
            return this._name;
        }
    }, {
        key: 'type',
        get: function get() {
            return this._type;
        }
    }, {
        key: 'definitions',
        get: function get() {
            return Array.from(this._definitions);
        }
    }, {
        key: 'references',
        get: function get() {
            return Array.from(this._references);
        }
    }]);

    return Variable;
})();

exports['default'] = Variable;
module.exports = exports['default'];