fix type errors

Author: frangio

package-lock.json

@@ -42,7 +42,7 @@
     "lodash": "^4.17.20",
     "minimatch": "^6.0.0",
     "minimist": "^1.2.5",
-    "solidity-ast": "^0.4.48"
+    "solidity-ast": "^0.4.49"
   },
   "devDependencies": {
     "@types/lodash": "^4.14.165",

package.json

@@ -1,5 +1,5 @@
 import { ContractDefinition } from 'solidity-ast';
-import { findAll, astDereferencer, ASTDereferencer } from 'solidity-ast/utils';
+import { findAll, astDereferencer, ASTDereferencer, ASTDereferencerError } from 'solidity-ast/utils';
 import { NodeType, NodeTypeMap } from 'solidity-ast/node';
 
 import { SolcOutput } from './solc/input-output';
@@ -12,26 +12,10 @@ export class ASTResolver {
   }
 
   resolveContract(id: number): ContractDefinition | undefined {
-    try {
-      return this.resolveNode('ContractDefinition', id);
-    } catch (e) {
-      if (e instanceof ASTResolverError) {
-        return undefined;
-      } else {
-        throw e;
-      }
-    }
+    return this.tryResolveNode('ContractDefinition', id);
   }
 
   resolveNode<T extends NodeType>(nodeType: T, id: number): NodeTypeMap[T] {
-    const node = this.tryResolveNode(nodeType, id);
-    if (node === undefined) {
-      throw new ASTResolverError(nodeType);
-    }
-    return node;
-  }
-
-  tryResolveNode<T extends NodeType>(nodeType: T, id: number): NodeTypeMap[T] | undefined {
     const { node, sourceUnit } = this.deref.withSourceUnit(nodeType, id);
     const source = sourceUnit.absolutePath;
     if (this.exclude?.(source)) {
@@ -40,10 +24,18 @@ export class ASTResolver {
       return node;
     }
   }
-}
 
-export class ASTResolverError extends Error {
-  constructor(nodeType: NodeType) {
-    super(`Can't find required ${nodeType}`);
+  tryResolveNode<T extends NodeType>(nodeType: T, id: number): NodeTypeMap[T] | undefined {
+    try {
+      return this.resolveNode(nodeType, id);
+    } catch (e) {
+      if (e instanceof ASTDereferencerError) {
+        return undefined;
+      } else {
+        throw e;
+      }
+    }
   }
 }
+
+export const ASTResolverError = ASTDereferencerError;

src/ast-resolver.ts

@@ -61,12 +61,12 @@ export function* addStorageGaps(
   }
 }
 
-function isStorageVariable(varDecl: VariableDeclaration): boolean {
+function isStorageVariable(varDecl: VariableDeclaration, resolver: ASTResolver): boolean {
   switch (varDecl.mutability) {
     case 'constant':
       return false;
     case 'immutable':
-      return !hasOverride(varDecl, 'state-variable-immutable');
+      return !hasOverride(varDecl, 'state-variable-immutable', resolver);
     default:
       return true;
   }
@@ -114,7 +114,7 @@ function getContractSlotCount(
 
   // don't use `findAll` here, we don't want to go recursive
   for (const varDecl of contractNode.nodes.filter(isNodeType('VariableDeclaration'))) {
-    if (isStorageVariable(varDecl)) {
+    if (isStorageVariable(varDecl, resolver)) {
       // try get type details
       const typeIdentifier = decodeTypeIdentifier(varDecl.typeDescriptions.typeIdentifier ?? '');
 

src/transformations/add-storage-gaps.ts

@@ -1,19 +1,20 @@
 import { SourceUnit } from 'solidity-ast';
 import { findAll } from 'solidity-ast/utils';
 import { getNodeBounds } from '../solc/ast-utils';
+import { TransformerTools } from '../transform';
 import { hasConstructorOverride, hasOverride } from '../utils/upgrades-overrides';
 
 import { Transformation } from './type';
 
-export function* removeStateVarInits(sourceUnit: SourceUnit): Generator<Transformation> {
+export function* removeStateVarInits(sourceUnit: SourceUnit, { resolver }: TransformerTools): Generator<Transformation> {
   for (const contractNode of findAll('ContractDefinition', sourceUnit)) {
     if (hasConstructorOverride(contractNode)) {
       continue;
     }
 
     for (const varDecl of findAll('VariableDeclaration', contractNode)) {
       if (varDecl.stateVariable && varDecl.value && !varDecl.constant) {
-        if (hasOverride(varDecl, 'state-variable-assignment')) {
+        if (hasOverride(varDecl, 'state-variable-assignment', resolver)) {
           continue;
         }
 

src/transformations/purge-var-inits.ts

@@ -1,14 +1,15 @@
 import { SourceUnit } from 'solidity-ast';
 import { findAll } from 'solidity-ast/utils';
 import { getNodeBounds } from '../solc/ast-utils';
+import { TransformerTools } from '../transform';
 import { hasOverride } from '../utils/upgrades-overrides';
 
 import { Transformation } from './type';
 
-export function* removeImmutable(sourceUnit: SourceUnit): Generator<Transformation> {
+export function* removeImmutable(sourceUnit: SourceUnit, { resolver }: TransformerTools): Generator<Transformation> {
   for (const varDecl of findAll('VariableDeclaration', sourceUnit)) {
     if (varDecl.mutability === 'immutable') {
-      if (hasOverride(varDecl, 'state-variable-immutable')) {
+      if (hasOverride(varDecl, 'state-variable-immutable', resolver)) {
         continue;
       }
 

src/transformations/remove-immutable.ts

@@ -95,7 +95,7 @@ export function* transformConstructor(
       varInitNodes,
       modifiers,
       emptyUnchained: emptyConstructor,
-    } = getInitializerItems(contractNode);
+    } = getInitializerItems(contractNode, resolver);
 
     const initializer = (
       helper: TransformHelper,

src/transformations/transform-constructor.ts

@@ -203,7 +203,7 @@ export function buildSuperCallsForChain(
 
     const args = parentArgsValues.get(parentNode) ?? [];
 
-    if (args.length || !getInitializerItems(parentNode).emptyUnchained) {
+    if (args.length || !getInitializerItems(parentNode, resolver).emptyUnchained) {
       // TODO: we have to use the name in the lexical context and not necessarily
       // the original contract name
       linearizedCtorCalls.push(buildSuperCall(args, parentNode.name, helper));

src/transformations/utils/build-super-calls-for-chain.ts

@@ -1,13 +1,14 @@
 import { ContractDefinition } from 'solidity-ast';
 import { findAll } from 'solidity-ast/utils';
+import { ASTResolver } from '../../ast-resolver';
 import { getConstructor } from '../../solc/ast-utils';
 import { hasOverride } from '../../utils/upgrades-overrides';
 
-export function getInitializerItems(contract: ContractDefinition) {
+export function getInitializerItems(contract: ContractDefinition, resolver: ASTResolver) {
   const constructorNode = getConstructor(contract);
 
   const varInitNodes = [...findAll('VariableDeclaration', contract)].filter(
-    v => v.stateVariable && v.value && !v.constant && !hasOverride(v, 'state-variable-assignment'),
+    v => v.stateVariable && v.value && !v.constant && !hasOverride(v, 'state-variable-assignment', resolver),
   );
 
   const modifiers =

src/transformations/utils/get-initializer-items.ts

@@ -62,5 +62,5 @@ function getOwnOverrides(node: Node): ValidationErrorKind[] {
 
 export function hasConstructorOverride(contract: ContractDefinition): boolean {
   const ctor = getConstructor(contract);
-  return ctor ? hasOverride(ctor, 'constructor') : false;
+  return ctor ? getOwnOverrides(ctor).includes('constructor') : false;
 }