feat: refactoring project

node_modules/eslint-scope/lib/referencer.js

@@ -21,28 +21,23 @@
   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-"use strict";
 
-/* eslint-disable no-underscore-dangle */
-/* eslint-disable no-undefined */
+import estraverse from "estraverse";
+import esrecurse from "esrecurse";
+import Reference from "./reference.js";
+import Variable from "./variable.js";
+import PatternVisitor from "./pattern-visitor.js";
+import { Definition, ParameterDefinition } from "./definition.js";
+import { assert } from "./assert.js";
 
-const Syntax = require("estraverse").Syntax;
-const esrecurse = require("esrecurse");
-const Reference = require("./reference");
-const Variable = require("./variable");
-const PatternVisitor = require("./pattern-visitor");
-const definition = require("./definition");
-const assert = require("assert");
-
-const ParameterDefinition = definition.ParameterDefinition;
-const Definition = definition.Definition;
+const { Syntax } = estraverse;
 
 /**
  * Traverse identifier in pattern
- * @param {Object} options - options
- * @param {pattern} rootPattern - root pattern
- * @param {Refencer} referencer - referencer
- * @param {callback} callback - callback
+ * @param {Object} options options
+ * @param {pattern} rootPattern root pattern
+ * @param {Refencer} referencer referencer
+ * @param {callback} callback callback
  * @returns {void}
  */
 function traverseIdentifierInPattern(options, rootPattern, referencer, callback) {
@@ -53,7 +48,7 @@ function traverseIdentifierInPattern(options, rootPattern, referencer, callback)
     visitor.visit(rootPattern);
 
     // Process the right hand nodes recursively.
-    if (referencer !== null && referencer !== undefined) {
+    if (referencer !== null && referencer !== void 0) {
         visitor.rightHandNodes.forEach(referencer.visit, referencer);
     }
 }
@@ -64,6 +59,9 @@ function traverseIdentifierInPattern(options, rootPattern, referencer, callback)
 // FIXME: Now, we don't create module environment, because the context is
 // implementation dependent.
 
+/**
+ * Visitor for import specifiers.
+ */
 class Importer extends esrecurse.Visitor {
     constructor(declaration, referencer) {
         super(null, referencer.options);
@@ -110,7 +108,9 @@ class Importer extends esrecurse.Visitor {
     }
 }
 
-// Referencing variables and creating bindings.
+/**
+ * Referencing variables and creating bindings.
+ */
 class Referencer extends esrecurse.Visitor {
     constructor(options, scopeManager) {
         super(null, options);
@@ -209,8 +209,8 @@ class Referencer extends esrecurse.Visitor {
 
         /**
          * Visit pattern callback
-         * @param {pattern} pattern - pattern
-         * @param {Object} info - info
+         * @param {pattern} pattern pattern
+         * @param {Object} info info
          * @returns {void}
          */
         function visitPatternCallback(pattern, info) {
@@ -274,8 +274,6 @@ class Referencer extends esrecurse.Visitor {
                 ));
         }
 
-        this.visit(node.superClass);
-
         this.scopeManager.__nestClassScope(node);
 
         if (node.id) {
@@ -286,6 +284,8 @@ class Referencer extends esrecurse.Visitor {
                     node
                 ));
         }
+
+        this.visit(node.superClass);
         this.visit(node.body);
 
         this.close(node);
@@ -395,7 +395,7 @@ class Referencer extends esrecurse.Visitor {
             this.currentScope().__define(pattern,
                 new Definition(
                     Variable.CatchClause,
-                    node.param,
+                    pattern,
                     node,
                     null,
                     null,
@@ -411,7 +411,7 @@ class Referencer extends esrecurse.Visitor {
     Program(node) {
         this.scopeManager.__nestGlobalScope(node);
 
-        if (this.scopeManager.__isNodejsScope()) {
+        if (this.scopeManager.isGlobalReturn()) {
 
             // Force strictness of GlobalScope to false when using node.js scope.
             this.currentScope().isStrict = false;
@@ -434,6 +434,12 @@ class Referencer extends esrecurse.Visitor {
         this.currentScope().__referencing(node);
     }
 
+    // eslint-disable-next-line class-methods-use-this -- Desired as instance method
+    PrivateIdentifier() {
+
+        // Do nothing.
+    }
+
     UpdateExpression(node) {
         if (PatternVisitor.isPattern(node.argument)) {
             this.currentScope().__referencing(node.argument, Reference.RW, null);
@@ -453,13 +459,34 @@ class Referencer extends esrecurse.Visitor {
         this.visitProperty(node);
     }
 
+    PropertyDefinition(node) {
+        const { computed, key, value } = node;
+
+        if (computed) {
+            this.visit(key);
+        }
+        if (value) {
+            this.scopeManager.__nestClassFieldInitializerScope(value);
+            this.visit(value);
+            this.close(value);
+        }
+    }
+
+    StaticBlock(node) {
+        this.scopeManager.__nestClassStaticBlockScope(node);
+
+        this.visitChildren(node);
+
+        this.close(node);
+    }
+
     MethodDefinition(node) {
         this.visitProperty(node);
     }
 
-    BreakStatement() {} // eslint-disable-line class-methods-use-this
+    BreakStatement() {} // eslint-disable-line class-methods-use-this -- Desired as instance method
 
-    ContinueStatement() {} // eslint-disable-line class-methods-use-this
+    ContinueStatement() {} // eslint-disable-line class-methods-use-this -- Desired as instance method
 
     LabeledStatement(node) {
         this.visit(node.body);
@@ -618,12 +645,12 @@ class Referencer extends esrecurse.Visitor {
         this.visit(local);
     }
 
-    MetaProperty() { // eslint-disable-line class-methods-use-this
+    MetaProperty() { // eslint-disable-line class-methods-use-this -- Desired as instance method
 
         // do nothing.
     }
 }
 
-module.exports = Referencer;
+export default Referencer;
 
 /* vim: set sw=4 ts=4 et tw=80 : */