linting for astwalker done

libs/remix-astwalker/.eslintrc

@@ -2,7 +2,8 @@
     "extends": "../../.eslintrc", 
     "rules": {
         "@typescript-eslint/no-explicit-any": "off",
-        "@typescript-eslint/prefer-namespace-keyword": "off"
+        "@typescript-eslint/prefer-namespace-keyword": "off",
+        "no-unused-vars": "off"
     }, 
     "ignorePatterns": ["!**/*"] 
 }

libs/remix-astwalker/src/astWalker.ts

-import { EventEmitter } from "events";
-import { Node, AstNode } from "./index";
+import { EventEmitter } from 'events'
+import { Node, AstNode } from './index'
 
 export declare interface AstWalker {
   new(): EventEmitter;
 }
 
-const isObject = function(obj: any): boolean {
-  return obj != null && obj.constructor.name === "Object"
+const isObject = function (obj: any): boolean {
+  return obj != null && obj.constructor.name === 'Object'
 }
 
-export function isAstNode(node: Record<string, unknown>): boolean {
+export function isAstNode (node: Record<string, unknown>): boolean {
   return (
     isObject(node) &&
     'id' in node &&
@@ -18,7 +18,7 @@ export function isAstNode(node: Record<string, unknown>): boolean {
   )
 }
 
-export function isYulAstNode(node: Record<string, unknown>): boolean {
+export function isYulAstNode (node: Record<string, unknown>): boolean {
   return (
     isObject(node) &&
     'nodeType' in node &&
@@ -26,7 +26,6 @@ export function isYulAstNode(node: Record<string, unknown>): boolean {
   )
 }
 
-
 /**
  * Crawl the given AST through the function walk(ast, callback)
  */
@@ -41,7 +40,7 @@ export function isYulAstNode(node: Record<string, unknown>): boolean {
  * If no event for the current type, children are visited.
  */
 export class AstWalker extends EventEmitter {
-  manageCallback(
+  manageCallback (
     node: AstNode,
     callback: Record<string, unknown> | Function // eslint-disable-line @typescript-eslint/ban-types
   ): any {
@@ -51,23 +50,23 @@ export class AstWalker extends EventEmitter {
     // return that.
     if (node) {
       if ((node).name in callback) {
-        return callback[(node).name](node);
+        return callback[(node).name](node)
       } else {
-        return callback["*"](node);
+        return callback['*'](node)
       }
     }
     if (<AstNode>node) {
       if ((<AstNode>node).nodeType in callback) {
         /* istanbul ignore next */
-        return callback[(<AstNode>node).nodeType](node);
+        return callback[(<AstNode>node).nodeType](node)
       } else {
         /* istanbul ignore next */
-        return callback["*"](node);
+        return callback['*'](node)
       }
     }
   }
 
-  normalizeNodes(nodes: AstNode[]): AstNode[] {
+  normalizeNodes (nodes: AstNode[]): AstNode[] {
     // Remove null, undefined and empty elements if any
     nodes = nodes.filter(e => e)
 
@@ -76,34 +75,33 @@ export class AstWalker extends EventEmitter {
     nodes.forEach(x => {
       if (Array.isArray(x)) objNodes.push(...x)
       else objNodes.push(x)
-    });
+    })
 
     // Filter duplicate nodes using id field
     const normalizedNodes = []
     objNodes.forEach((element) => {
       const firstIndex = normalizedNodes.findIndex(e => e.id === element.id)
-      if(firstIndex == -1) normalizedNodes.push(element)
+      if (firstIndex === -1) normalizedNodes.push(element)
     })
     return normalizedNodes
   }
 
-  getASTNodeChildren(ast: AstNode): AstNode[] {
-
-    let nodes = ast.nodes             // for ContractDefinition
-              || ast.body             // for FunctionDefinition, ModifierDefinition, WhileStatement, DoWhileStatement, ForStatement
-              || ast.statements       // for Block, YulBlock
-              || ast.members          // for StructDefinition, EnumDefinition
-              || ast.overrides        // for OverrideSpecifier
-              || ast.parameters       // for ParameterList, EventDefinition
-              || ast.declarations     // for VariableDeclarationStatement
-              || ast.expression       // for Return, ExpressionStatement, FunctionCall, FunctionCallOptions, MemberAccess
-              || ast.components       // for TupleExpression
-              || ast.subExpression    // for UnaryOperation
-              || ast.eventCall        // for EmitStatement
-              || []
+  getASTNodeChildren (ast: AstNode): AstNode[] {
+    let nodes = ast.nodes || // for ContractDefinition
+              ast.body || // for FunctionDefinition, ModifierDefinition, WhileStatement, DoWhileStatement, ForStatement
+              ast.statements || // for Block, YulBlock
+              ast.members || // for StructDefinition, EnumDefinition
+              ast.overrides || // for OverrideSpecifier
+              ast.parameters || // for ParameterList, EventDefinition
+              ast.declarations || // for VariableDeclarationStatement
+              ast.expression || // for Return, ExpressionStatement, FunctionCall, FunctionCallOptions, MemberAccess
+              ast.components || // for TupleExpression
+              ast.subExpression || // for UnaryOperation
+              ast.eventCall || // for EmitStatement
+              []
 
     // If 'nodes' is not an array, convert it into one, for example: ast.body
-    if(nodes && !Array.isArray(nodes)) {
+    if (nodes && !Array.isArray(nodes)) {
       const tempArr = []
       tempArr.push(nodes)
       nodes = tempArr
@@ -112,14 +110,14 @@ export class AstWalker extends EventEmitter {
     // To break object referencing
     nodes = [...nodes]
 
-    if(ast.nodes && ast.baseContracts?.length) { // for ContractDefinition
+    if (ast.nodes && ast.baseContracts?.length) { // for ContractDefinition
       nodes.push(...ast.baseContracts)
     } else if (ast.body && ast.overrides && ast.parameters && ast.returnParameters && ast.modifiers) { // for FunctionDefinition
       nodes.push(ast.overrides)
       nodes.push(ast.parameters)
       nodes.push(ast.returnParameters)
       nodes.push(ast.modifiers)
-    } else if(ast.typeName) { // for VariableDeclaration, NewExpression, ElementaryTypeNameExpression
+    } else if (ast.typeName) { // for VariableDeclaration, NewExpression, ElementaryTypeNameExpression
       nodes.push(ast.typeName)
     } else if (ast.body && ast.overrides && ast.parameters) { // for ModifierDefinition
       nodes.push(ast.overrides)
@@ -167,7 +165,7 @@ export class AstWalker extends EventEmitter {
       nodes.push(ast.arguments ? ast.arguments : ast.options)
     } else if (ast.baseExpression && (ast.indexExpression || (ast.startExpression && ast.endExpression))) { // for IndexAccess, IndexRangeAccess
       nodes.push(ast.baseExpression)
-        if(ast.indexExpression) nodes.push(ast.indexExpression)
+      if (ast.indexExpression) nodes.push(ast.indexExpression)
       else {
         nodes.push(ast.startExpression)
         nodes.push(ast.endExpression)
@@ -177,52 +175,53 @@ export class AstWalker extends EventEmitter {
   }
 
   // eslint-disable-next-line @typescript-eslint/ban-types, @typescript-eslint/explicit-module-boundary-types
-  walk(ast: AstNode, callback?: Function | Record<string, unknown>) {
+  walk (ast: AstNode, callback?: Function | Record<string, unknown>) {
     if (ast) {
       const children: AstNode[] = this.getASTNodeChildren(ast)
       if (callback) {
         if (callback instanceof Function) {
-          callback = Object({ "*": callback });
+          callback = Object({ '*': callback })
+        }
+        if (!('*' in callback)) {
+          callback['*'] = function () {
+            return true
           }
-        if (!("*" in callback)) {
-          callback["*"] = function() {
-            return true;
-          };
         }
         if (this.manageCallback(ast, callback) && children?.length) {
           for (const k in children) {
-            const child = children[k];
-            this.walk(child, callback);
+            const child = children[k]
+            this.walk(child, callback)
           }
         }
       } else {
         if (children?.length) {
           for (const k in children) {
-              const child = children[k];
-              this.emit("node", child);
-              this.walk(child);
+            const child = children[k]
+            this.emit('node', child)
+            this.walk(child)
           }
         }
       }
     }
   }
+
   // eslint-disable-next-line @typescript-eslint/ban-types, @typescript-eslint/explicit-module-boundary-types
-  walkFullInternal(ast: AstNode, callback: Function) {
+  walkFullInternal (ast: AstNode, callback: Function) {
     if (isAstNode(ast) || isYulAstNode(ast)) {
       // console.log(`XXX id ${ast.id}, nodeType: ${ast.nodeType}, src: ${ast.src}`);
-      callback(ast);
+      callback(ast)
       for (const k of Object.keys(ast)) {
         // Possible optimization:
         // if (k in ['id', 'src', 'nodeType']) continue;
-        const astItem = ast[k];
+        const astItem = ast[k]
         if (Array.isArray(astItem)) {
           for (const child of astItem) {
             if (child) {
-              this.walkFullInternal(child, callback);
+              this.walkFullInternal(child, callback)
             }
           }
         } else {
-          this.walkFullInternal(astItem, callback);
+          this.walkFullInternal(astItem, callback)
         }
       }
     }
@@ -230,19 +229,19 @@ export class AstWalker extends EventEmitter {
 
   // Normalizes parameter callback and calls walkFullInternal
   // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  walkFull(ast: AstNode, callback: any) {
-    if (isAstNode(ast) || isYulAstNode(ast)) return this.walkFullInternal(ast, callback);
+  walkFull (ast: AstNode, callback: any) {
+    if (isAstNode(ast) || isYulAstNode(ast)) return this.walkFullInternal(ast, callback)
   }
 
   // eslint-disable-next-line @typescript-eslint/ban-types, @typescript-eslint/explicit-module-boundary-types
-  walkAstList(sourcesList: Node, cb?: Function) {
+  walkAstList (sourcesList: Node, cb?: Function) {
     if (cb) {
       if (sourcesList.ast) {
-        this.walk(sourcesList.ast, cb);
+        this.walk(sourcesList.ast, cb)
       }
     } else {
       if (sourcesList.ast) {
-        this.walk(sourcesList.ast);
+        this.walk(sourcesList.ast)
       }
     }
   }

libs/remix-astwalker/src/sourceMappings.ts

-import { isAstNode, isYulAstNode, AstWalker } from './astWalker';
-import { AstNode, LineColPosition, LineColRange, Location } from "./types";
-import { util } from "@remix-project/remix-lib";
+import { isAstNode, isYulAstNode, AstWalker } from './astWalker'
+import { AstNode, LineColPosition, LineColRange, Location } from './types'
+import { util } from '@remix-project/remix-lib'
 
 export declare interface SourceMappings {
   // eslint-disable-next-line @typescript-eslint/no-misused-new
@@ -12,12 +12,12 @@ export declare interface SourceMappings {
  *
  * @param offset  The character offset to convert.
  */
-export function lineColPositionFromOffset(offset: number, lineBreaks: Array<number>): LineColPosition {
-  let line: number = util.findLowerBound(offset, lineBreaks);
+export function lineColPositionFromOffset (offset: number, lineBreaks: Array<number>): LineColPosition {
+  let line: number = util.findLowerBound(offset, lineBreaks)
   if (lineBreaks[line] !== offset) {
-    line += 1;
+    line += 1
   }
-  const beginColumn = line === 0 ? 0 : (lineBreaks[line - 1] + 1);
+  const beginColumn = line === 0 ? 0 : (lineBreaks[line - 1] + 1)
   return <LineColPosition>{
     line: line + 1,
     character: (offset - beginColumn) + 1
@@ -30,11 +30,11 @@ export function lineColPositionFromOffset(offset: number, lineBreaks: Array<numb
  *
  * @param astNode  The object to convert.
  */
-export function sourceLocationFromAstNode(astNode: AstNode): Location | null {
+export function sourceLocationFromAstNode (astNode: AstNode): Location | null {
   if (isAstNode(astNode) && isYulAstNode(astNode) && astNode.src) {
     return sourceLocationFromSrc(astNode.src)
   }
-  return null;
+  return null
 }
 
 /**
@@ -45,7 +45,7 @@ export function sourceLocationFromAstNode(astNode: AstNode): Location | null {
  * @param src  A solc "src" field.
  * @returns {Location}
  */
-export function sourceLocationFromSrc(src: string): Location {
+export function sourceLocationFromSrc (src: string): Location {
   const split = src.split(':')
   return <Location>{
     start: parseInt(split[0], 10),
@@ -59,20 +59,19 @@ export function sourceLocationFromSrc(src: string): Location {
  * includng "src' information.
  */
 export class SourceMappings {
-
   readonly source: string;
   readonly lineBreaks: Array<number>;
 
-  constructor(source: string) {
-    this.source = source;
+  constructor (source: string) {
+    this.source = source
 
     // Create a list of line offsets which will be used to map between
     // character offset and line/column positions.
-    const lineBreaks: Array<number> = [];
+    const lineBreaks: Array<number> = []
     for (let pos = source.indexOf('\n'); pos >= 0; pos = source.indexOf('\n', pos + 1)) {
       lineBreaks.push(pos)
     }
-    this.lineBreaks = lineBreaks;
+    this.lineBreaks = lineBreaks
   };
 
   /**
@@ -81,23 +80,23 @@ export class SourceMappings {
    * @param astNodeType  Type of node to return or null.
    * @param position     Character offset where AST node should be located.
    */
-  nodesAtPosition(astNodeType: string | null, position: Location, ast: AstNode): Array<AstNode> {
+  nodesAtPosition (astNodeType: string | null, position: Location, ast: AstNode): Array<AstNode> {
     const astWalker = new AstWalker()
-    const found: Array<AstNode> = [];
+    const found: Array<AstNode> = []
 
-    const callback = function(node: AstNode): boolean {
-      const nodeLocation = sourceLocationFromAstNode(node);
+    const callback = function (node: AstNode): boolean {
+      const nodeLocation = sourceLocationFromAstNode(node)
       if (nodeLocation &&
-        nodeLocation.start == position.start &&
-        nodeLocation.length == position.length) {
+        nodeLocation.start === position.start &&
+        nodeLocation.length === position.length) {
         if (!astNodeType || astNodeType === node.nodeType) {
           found.push(node)
         }
       }
-      return true;
+      return true
     }
-    astWalker.walkFull(ast, callback);
-    return found;
+    astWalker.walkFull(ast, callback)
+    return found
   }
 
   /**
@@ -106,25 +105,25 @@ export class SourceMappings {
    * @param astNodeType   nodeType that a found ASTNode must be. Use "null" if any ASTNode can match.
    * @param sourceLocation "src" location that the AST node must match.
    */
-  findNodeAtSourceLocation(astNodeType: string | undefined, sourceLocation: Location, ast: AstNode | null): AstNode | null {
+  findNodeAtSourceLocation (astNodeType: string | undefined, sourceLocation: Location, ast: AstNode | null): AstNode | null {
     const astWalker = new AstWalker()
-    let found = null;
+    let found = null
     /* FIXME: Looking at AST walker code,
        I don't understand a need to return a boolean. */
-    const callback = function(node: AstNode) {
-      const nodeLocation = sourceLocationFromAstNode(node);
+    const callback = function (node: AstNode) {
+      const nodeLocation = sourceLocationFromAstNode(node)
       if (nodeLocation &&
-        nodeLocation.start == sourceLocation.start &&
-        nodeLocation.length == sourceLocation.length) {
-        if (astNodeType == undefined || astNodeType === node.nodeType) {
-          found = node;
+        nodeLocation.start === sourceLocation.start &&
+        nodeLocation.length === sourceLocation.length) {
+        if (astNodeType === undefined || astNodeType === node.nodeType) {
+          found = node
         }
       }
-      return true;
+      return true
     }
 
-    astWalker.walkFull(ast, callback);
-    return found;
+    astWalker.walkFull(ast, callback)
+    return found
   }
 
   /**
@@ -132,8 +131,8 @@ export class SourceMappings {
    *
    * @param src  Solc "src" object containing attributes {source} and {length}.
    */
-  srcToLineColumnRange(src: string): LineColRange {
-    const sourceLocation = sourceLocationFromSrc(src);
+  srcToLineColumnRange (src: string): LineColRange {
+    const sourceLocation = sourceLocationFromSrc(src)
     if (sourceLocation.start >= 0 && sourceLocation.length >= 0) {
       return <LineColRange>{
         start: lineColPositionFromOffset(sourceLocation.start, this.lineBreaks),
@@ -146,5 +145,4 @@ export class SourceMappings {
       }
     }
   }
-
 }