InferType-changes

src/ast/ast.ts

@@ -25,7 +25,7 @@ import { printNode } from '../utils/astPrinter';
 import { TranspileFailedError } from '../utils/errors';
 import { createBlock } from '../utils/nodeTemplates';
 import { createImport } from '../utils/importFuncGenerator';
-import { safeGetNodeType } from '../utils/nodeTypeProcessing';
+import { safeGetNodeType, WarpInferType } from '../utils/nodeTypeProcessing';
 import { getContainingSourceUnit, isExternalCall } from '../utils/utils';
 import { CairoImportFunctionDefinition } from './cairoNodes';
 import { ParameterInfo } from '../export';
@@ -73,7 +73,7 @@ export class AST {
       'All contexts should be the same, otherwise they are from separate solc-typed-ast compiles and they will have no relationship to each other.',
     );
     this.context = roots[0].requiredContext;
-    this.inference = new InferType(compilerVersion);
+    this.inference = new WarpInferType(compilerVersion);
     assert(
       this.context.locate(this.tempId) === undefined,
       `Attempted to create an AST with a context that already has ${this.tempId} registered`,

src/cairoUtilFuncGen/calldata/calldataToMemory.ts

@@ -206,7 +206,7 @@ export class CallDataToMemoryGen extends StringIndexedFuncGen {
 
     const [copyCode, funcCalls] = structDef.vMembers.reduce(
       ([copyCode, funcCalls, offset], decl) => {
-        const type = safeGetNodeType(decl, this.ast.inference);
+        const type = generalizeType(safeGetNodeType(decl, this.ast.inference))[0];
 
         if (isReferenceType(type)) {
           const recursiveFunc = this.getOrCreateFuncDef(type);

src/cairoUtilFuncGen/memory/memoryToCalldata.ts

@@ -85,12 +85,13 @@ export class MemoryToCallDataGen extends StringIndexedFuncGen {
         `Copying ${printTypeNode(type)} from memory to calldata not implemented yet`,
       );
     };
+    const generalizedType = generalizeType(type)[0];
 
     return delegateBasedOnType<GeneratedFunctionInfo>(
-      type,
-      (type) => this.createDynamicArrayCopyFunction(type),
-      (type) => this.createStaticArrayCopyFunction(type),
-      (type) => this.createStructCopyFunction(type),
+      generalizedType,
+      (generalizedType) => this.createDynamicArrayCopyFunction(generalizedType),
+      (generalizedType) => this.createStaticArrayCopyFunction(generalizedType),
+      (generalizedType) => this.createStructCopyFunction(generalizedType),
       unexpectedTypeFunc,
       unexpectedTypeFunc,
     );

src/cairoUtilFuncGen/memory/memoryToStorage.ts

@@ -114,7 +114,7 @@ export class MemoryToStorageGen extends StringIndexedFuncGen {
     const funcName = `wm_to_storage_struct_${def.name}`;
 
     const [copyInstructions, funcsCalled] = this.generateTupleCopyInstructions(
-      def.vMembers.map((decl) => safeGetNodeType(decl, this.ast.inference)),
+      def.vMembers.map((decl) => generalizeType(safeGetNodeType(decl, this.ast.inference))[0]),
     );
     return {
       name: funcName,

src/cairoUtilFuncGen/storage/copyToStorage.ts

@@ -129,7 +129,9 @@ export class StorageToStorageGen extends StringIndexedFuncGen {
   }
 
   private createStructCopyFunction(def: StructDefinition): GeneratedFunctionInfo {
-    const members = def.vMembers.map((decl) => safeGetNodeType(decl, this.ast.inference));
+    const members = def.vMembers.map(
+      (decl) => generalizeType(safeGetNodeType(decl, this.ast.inference))[0],
+    );
     const [copyCode, funcsCalled] = members.reduce(
       ([copyCode, funcsCalled, offset], memberType) => {
         const width = CairoType.fromSol(

src/cairoUtilFuncGen/utils/encodeToFelt.ts

@@ -311,7 +311,7 @@ export class EncodeAsFelt extends StringIndexedFuncGenWithAuxiliar {
 
     const [encodeCode, encodeCalls] = type.definition.vMembers.reduce(
       ([encodeCode, encodeCalls], varDecl, index) => {
-        const varType = safeGetNodeType(varDecl, this.ast.inference);
+        const varType = generalizeType(safeGetNodeType(varDecl, this.ast.inference))[0];
         const [memberEncodeCode, memberEncodeCalls] = this.generateEncodeCode(
           varType,
           `member_${index}`,

src/passes/argBoundChecker.ts

@@ -7,6 +7,7 @@ import {
   FunctionCallKind,
   EnumDefinition,
   IntType,
+  generalizeType,
 } from 'solc-typed-ast';
 import { ASTMapper } from '../ast/mapper';
 import { isExternallyVisible } from '../utils/utils';
@@ -30,7 +31,7 @@ export class ArgBoundChecker extends ASTMapper {
   visitFunctionDefinition(node: FunctionDefinition, ast: AST): void {
     if (isExternallyVisible(node) && node.vBody !== undefined) {
       node.vParameters.vParameters.forEach((decl) => {
-        const type = safeGetNodeType(decl, ast.inference);
+        const type = generalizeType(safeGetNodeType(decl, ast.inference))[0];
         if (checkableType(type)) {
           const functionCall = ast.getUtilFuncGen(node).boundChecks.inputCheck.gen(decl, type);
           this.insertFunctionCall(node, functionCall, ast);

src/passes/export.ts

@@ -2,7 +2,6 @@ export * from './abiBuiltins';
 export * from './annotateImplicits';
 export * from './argBoundChecker';
 export * from './builtinHandler/export';
-export * from './bytesConverter';
 export * from './cairoStubProcessor';
 export * from './cairoUtilImporter';
 export * from './conditionalSplitter/export';

src/passes/implicitConversionToExplicit.ts

@@ -247,7 +247,12 @@ export class ImplicitConversionToExplicit extends ASTMapper {
   visitIndexAccess(node: IndexAccess, ast: AST): void {
     this.commonVisit(node, ast);
 
-    if (node.vIndexExpression === undefined) return;
+    if (
+      safeGetNodeType(node, ast.inference) instanceof TypeNameType ||
+      node.vIndexExpression === undefined
+    ) {
+      return;
+    }
 
     const [baseType, location] = generalizeType(
       safeGetNodeType(node.vBaseExpression, ast.inference),

src/passes/index.ts

@@ -3,7 +3,6 @@ export * from './annotateImplicits';
 export * from './argBoundChecker';
 export * from './builtinHandler';
 export * from './builtinHandler/require';
-export * from './bytesConverter';
 export * from './cairoStubProcessor';
 export * from './cairoUtilImporter';
 export * from './conditionalSplitter/conditionalSplitter';

src/passes/returnVariableInitializer.ts

@@ -1,4 +1,4 @@
-import { FunctionDefinition, VariableDeclarationStatement } from 'solc-typed-ast';
+import { FunctionDefinition, generalizeType, VariableDeclarationStatement } from 'solc-typed-ast';
 import { AST } from '../ast/ast';
 import { ASTMapper } from '../ast/mapper';
 import { cloneASTNode } from '../utils/cloning';
@@ -27,7 +27,7 @@ export class ReturnVariableInitializer extends ASTMapper {
           '',
           [newDecl.id],
           [newDecl],
-          getDefaultValue(safeGetNodeType(decl, ast.inference), newDecl, ast),
+          getDefaultValue(generalizeType(safeGetNodeType(decl, ast.inference))[0], newDecl, ast),
         );
         identifiers.forEach((identifier) => {
           identifier.referencedDeclaration = newDecl.id;

src/passes/staticArrayIndexer.ts

@@ -12,6 +12,7 @@ import {
   Mutability,
   PointerType,
   StateVariableVisibility,
+  TypeNameType,
   TypeNode,
   VariableDeclaration,
   VariableDeclarationStatement,
@@ -58,6 +59,8 @@ export class StaticArrayIndexer extends ASTMapper {
   }
 
   visitIndexAccess(node: IndexAccess, ast: AST): void {
+    if (safeGetNodeType(node, ast.inference) instanceof TypeNameType)
+      return this.commonVisit(node, ast);
     this.staticIndexToMemory(node, ast);
   }
 

src/passes/tupleFixes/tupleFlattener.ts

@@ -1,6 +1,7 @@
-import { TupleExpression } from 'solc-typed-ast';
+import { TupleExpression, TypeNameType } from 'solc-typed-ast';
 import { AST } from '../../ast/ast';
 import { ASTMapper } from '../../ast/mapper';
+import { safeGetNodeType } from '../../export';
 import { WillNotSupportError } from '../../utils/errors';
 
 export class TupleFlattener extends ASTMapper {
@@ -18,6 +19,9 @@ export class TupleFlattener extends ASTMapper {
       node.vOriginalComponents[0].typeString === node.typeString &&
       !node.isInlineArray
     ) {
+      if (safeGetNodeType(node.vOriginalComponents[0], ast.inference) instanceof TypeNameType) {
+        return this.commonVisit(node, ast);
+      }
       const parent = node.parent;
       ast.replaceNode(node, node.vOriginalComponents[0], parent);
       this.dispatchVisit(node.vOriginalComponents[0], ast);

src/passes/typeNameRemover.ts

@@ -17,7 +17,14 @@ import { safeGetNodeType } from '../utils/nodeTypeProcessing';
 export class TypeNameRemover extends ASTMapper {
   // Function to add passes that should have been run before this pass
   addInitialPassPrerequisites(): void {
-    const passKeys: Set<string> = new Set<string>([]);
+    const passKeys: Set<string> = new Set<string>([
+      // ABI Builtin needs to be handled first because some builtin
+      // functions like abi.decode uses TypeNames as arguments, otherwise,
+      // they will be removed before use
+      // Eg:
+      //     abi.decode(data, (uint[7][]));
+      'Abi',
+    ]);
     passKeys.forEach((key) => this.addPassPrerequisite(key));
   }