New Cairo Gen

.eslintrc.json

@@ -16,7 +16,10 @@
     "eqeqeq": "error",
     "no-unused-vars": "off",
     "unicorn/filename-case": ["error", { "case": "camelCase" }],
-    "@typescript-eslint/no-unused-vars": ["error", { "argsIgnorePattern": "^_" }],
+    "@typescript-eslint/no-unused-vars": [
+      "error",
+      { "argsIgnorePattern": "^_", "varsIgnorePattern": "^_" }
+    ],
     "@typescript-eslint/ban-ts-comment": ["error", { "ts-ignore": "allow-with-description" }]
   }
 }

docs/i18n/vi/docusaurus-plugin-content-docs/current/features/cairo_stubs.mdx

@@ -9,7 +9,7 @@ The system works in the following way:
 
 1. To start a Cairo Block add your Cairo code above a Solidity function with 3 forward slashes at the beginning of each line and the phrase `warp-cairo` at the top.
 2. The user then uses a number of MACROS to interact with the transpiled contract.
-3. The Soldiity function will then be replaced with the Cario function that is above it.
+3. The Solidity function will then be replaced with the Cairo function that is above it.
 
 The following MACROS are supported:
 

exampleContracts/internalFunctions.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.6;
+
+contract WARP {
+  function f(
+    uint256 x,
+    uint8 y,
+    uint8 z
+  ) internal pure returns (bytes memory) {
+    return abi.encode(x, y, z);
+  }
+}

src/ast/ast.ts

@@ -25,9 +25,11 @@ import { printNode } from '../utils/astPrinter';
 import { TranspileFailedError } from '../utils/errors';
 import { Implicits } from '../utils/implicits';
 import { createBlock } from '../utils/nodeTemplates';
+import { createImportFuncDefinition } from '../utils/importFuncGenerator';
 import { safeGetNodeType } from '../utils/nodeTypeProcessing';
-import { getContainingSourceUnit, isExternalCall, mergeImports } from '../utils/utils';
-import { CairoFunctionDefinition } from './cairoNodes';
+import { getContainingSourceUnit, isExternalCall } from '../utils/utils';
+import { CairoFunctionDefinition, CairoImportFunctionDefinition } from './cairoNodes';
+import { ParameterInfo } from '../export';
 
 /*
  A centralised store of information required for transpilation, a reference
@@ -54,8 +56,6 @@ export class AST {
   private cairoUtilFuncGen: Map<number, CairoUtilFuncGen> = new Map();
 
   context: ASTContext;
-  // node requiring cairo import -> file to import from -> symbols to import
-  imports: Map<ASTNode, Map<string, Set<string>>> = new Map();
   public inference: InferType;
 
   readonly tempId = -1;
@@ -81,16 +81,6 @@ export class AST {
     );
   }
 
-  copyRegisteredImports(oldNode: ASTNode, newNode: ASTNode): void {
-    this.imports.set(
-      newNode,
-      mergeImports(
-        this.imports.get(oldNode) ?? new Map<string, Set<string>>(),
-        this.imports.get(newNode) ?? new Map<string, Set<string>>(),
-      ),
-    );
-  }
-
   extractToConstant(
     node: Expression,
     vType: TypeName,
@@ -175,20 +165,6 @@ export class AST {
     return containingFunction.implicits;
   }
 
-  getImports(sourceUnit: SourceUnit): Map<string, Set<string>> {
-    assert(
-      this.roots.includes(sourceUnit),
-      `Tried to get imports associated with ${printNode(
-        sourceUnit,
-      )}, which is not one of the roots of the AST`,
-    );
-    const reachableNodeImports = sourceUnit
-      .getChildren(true)
-      .map((node) => this.imports.get(node) ?? new Map<string, Set<string>>());
-    const utilFunctionImports = this.getUtilFuncGen(sourceUnit)?.getImports();
-    return mergeImports(utilFunctionImports, ...reachableNodeImports);
-  }
-
   getUtilFuncGen(node: ASTNode): CairoUtilFuncGen {
     const sourceUnit = node instanceof SourceUnit ? node : getContainingSourceUnit(node);
     const gen = this.cairoUtilFuncGen.get(sourceUnit.id);
@@ -298,12 +274,15 @@ export class AST {
     return child.id;
   }
 
-  registerImport(node: ASTNode, location: string, name: string): void {
-    const nodeImports = this.imports.get(node) ?? new Map<string, Set<string>>();
-    const fileImports = nodeImports.get(location) ?? new Set<string>();
-    fileImports.add(name);
-    nodeImports.set(location, fileImports);
-    this.imports.set(node, nodeImports);
+  registerImport(
+    node: ASTNode,
+    location: string,
+    name: string,
+    inputs: ParameterInfo[],
+    outputs: ParameterInfo[],
+    options?: { acceptsRawDarray?: boolean; acceptsUnpackedStructArray?: boolean },
+  ): CairoImportFunctionDefinition {
+    return createImportFuncDefinition(location, name, node, this, inputs, outputs, options);
   }
 
   removeStatement(statement: Statement): void {
@@ -317,19 +296,9 @@ export class AST {
   }
 
   // Reference notes/astnodetypes.ts for exact restrictions on what can safely be replaced with what
-  replaceNode(
-    oldNode: Expression,
-    newNode: Expression,
-    parent?: ASTNode,
-    copyImports?: boolean,
-  ): number;
-  replaceNode(
-    oldNode: Statement,
-    newNode: Statement,
-    parent?: ASTNode,
-    copyImports?: boolean,
-  ): number;
-  replaceNode(oldNode: ASTNode, newNode: ASTNode, parent?: ASTNode, copyImports = true): number {
+  replaceNode(oldNode: Expression, newNode: Expression, parent?: ASTNode): number;
+  replaceNode(oldNode: Statement, newNode: Statement, parent?: ASTNode): number;
+  replaceNode(oldNode: ASTNode, newNode: ASTNode, parent?: ASTNode): number {
     if (oldNode === newNode) {
       console.log(`WARNING: Attempted to replace node ${printNode(oldNode)} with itself`);
       return oldNode.id;
@@ -355,9 +324,6 @@ export class AST {
     replaceNode(oldNode, newNode, parent);
     this.context.unregister(oldNode);
     this.setContextRecursive(newNode);
-    if (copyImports) {
-      this.copyRegisteredImports(oldNode, newNode);
-    }
     return newNode.id;
   }
 

src/ast/cairoNodes/cairoBlockFunctionDefinition.ts

@@ -0,0 +1,37 @@
+import {
+  FunctionKind,
+  FunctionStateMutability,
+  FunctionVisibility,
+  ParameterList,
+} from 'solc-typed-ast';
+import { FunctionStubKind } from './cairoFunctionDefinition';
+import { CairoRawStringFunctionDefinition } from './cairoRawStringFunctionDefinition';
+
+export class CairoBlockFunctionDefinition extends CairoRawStringFunctionDefinition {
+  constructor(
+    id: number,
+    src: string,
+    scope: number,
+    kind: FunctionKind,
+    name: string,
+    visibility: FunctionVisibility,
+    stateMutability: FunctionStateMutability,
+    parameters: ParameterList,
+    returnParameters: ParameterList,
+    rawStringDefinition: string,
+  ) {
+    super(
+      id,
+      src,
+      scope,
+      kind,
+      name,
+      visibility,
+      stateMutability,
+      parameters,
+      returnParameters,
+      FunctionStubKind.FunctionDefStub,
+      rawStringDefinition,
+    );
+  }
+}

src/ast/cairoNodes/cairoFunctionDefinition.ts

@@ -13,17 +13,18 @@ import {
 import { Implicits } from '../../utils/implicits';
 
 /*
- An extension of FunctionDefinition to track which implicit arguments are used
+ An extension of FunctionDefinition to track which implicit arguments are used.
  Additionally we often use function stubs for instances where we want to be able
  to insert function during transpilation where it wouldn't make sense to include
  their body in the AST. For example, stubs are used for warplib functions, and
- those generated to handle memory and storage processing. Marking a CairoFunctionDefintion
- as a stub tells the CairoWriter not to print it
+ those generated to handle memory and storage processing. Marking a CairoFunctionDefinition
+ as a stub tells the CairoWriter not to print it.
 */
 
 export enum FunctionStubKind {
   None,
   FunctionDefStub,
+  StorageDefStub,
   StructDefStub,
 }
 

src/ast/cairoNodes/cairoGeneratedFunctionDefinition.ts

@@ -0,0 +1,54 @@
+import {
+  FunctionDefinition,
+  FunctionKind,
+  FunctionStateMutability,
+  FunctionVisibility,
+  ParameterList,
+} from 'solc-typed-ast';
+import { FunctionStubKind } from './cairoFunctionDefinition';
+import { CairoRawStringFunctionDefinition } from './cairoRawStringFunctionDefinition';
+
+export class CairoGeneratedFunctionDefinition extends CairoRawStringFunctionDefinition {
+  /**
+   * List of function defintions called by the generated function
+   */
+  public functionsCalled: FunctionDefinition[];
+
+  constructor(
+    id: number,
+    src: string,
+    scope: number,
+    kind: FunctionKind,
+    name: string,
+    visibility: FunctionVisibility,
+    stateMutability: FunctionStateMutability,
+    parameters: ParameterList,
+    returnParameters: ParameterList,
+    functionStubKind: FunctionStubKind,
+    rawStringDefinition: string,
+    functionsCalled: FunctionDefinition[],
+    acceptsRawDArray = false,
+    acceptsUnpackedStructArray = false,
+  ) {
+    super(
+      id,
+      src,
+      scope,
+      kind,
+      name,
+      visibility,
+      stateMutability,
+      parameters,
+      returnParameters,
+      functionStubKind,
+      rawStringDefinition,
+      acceptsRawDArray,
+      acceptsUnpackedStructArray,
+    );
+    this.functionsCalled = removeRepeatedFunction(functionsCalled);
+  }
+}
+
+function removeRepeatedFunction(functionsCalled: FunctionDefinition[]) {
+  return [...new Set(functionsCalled)];
+}

src/ast/cairoNodes/cairoImportFunctionDefinition.ts

@@ -0,0 +1,45 @@
+import {
+  FunctionKind,
+  FunctionStateMutability,
+  FunctionVisibility,
+  ParameterList,
+} from 'solc-typed-ast';
+import { CairoFunctionDefinition, FunctionStubKind } from './cairoFunctionDefinition';
+import { Implicits } from '../../utils/implicits';
+
+export class CairoImportFunctionDefinition extends CairoFunctionDefinition {
+  path: string;
+  constructor(
+    id: number,
+    src: string,
+    scope: number,
+    name: string,
+    path: string,
+    implicits: Set<Implicits>,
+    parameters: ParameterList,
+    returnParameters: ParameterList,
+    stubKind: FunctionStubKind,
+    acceptsRawDArray = false,
+    acceptsUnpackedStructArray = false,
+  ) {
+    super(
+      id,
+      src,
+      scope,
+      FunctionKind.Function,
+      name,
+      false,
+      FunctionVisibility.Internal,
+      FunctionStateMutability.NonPayable,
+      false,
+      parameters,
+      returnParameters,
+      [],
+      implicits,
+      stubKind,
+      acceptsRawDArray,
+      acceptsUnpackedStructArray,
+    );
+    this.path = path;
+  }
+}

src/ast/cairoNodes/cairoRawStringFunctionDefinition.ts

@@ -0,0 +1,51 @@
+import {
+  FunctionKind,
+  FunctionStateMutability,
+  FunctionVisibility,
+  ParameterList,
+} from 'solc-typed-ast';
+import { CairoFunctionDefinition, FunctionStubKind } from './cairoFunctionDefinition';
+import { getRawCairoFunctionInfo } from '../../utils/cairoParsing';
+
+export class CairoRawStringFunctionDefinition extends CairoFunctionDefinition {
+  rawStringDefinition: string;
+  constructor(
+    id: number,
+    src: string,
+    scope: number,
+    kind: FunctionKind,
+    name: string,
+    visibility: FunctionVisibility,
+    stateMutability: FunctionStateMutability,
+    parameters: ParameterList,
+    returnParameters: ParameterList,
+    functionSutbKind: FunctionStubKind,
+    rawStringDefinition: string,
+    acceptsRawDArray = false,
+    acceptsUnpackedStructArray = false,
+  ) {
+    super(
+      id,
+      src,
+      scope,
+      kind,
+      name,
+      false, // Virtual
+      visibility,
+      stateMutability,
+      false, // IsConstructor
+      parameters,
+      returnParameters,
+      [], // Modifier Invocation
+      functionSutbKind === FunctionStubKind.FunctionDefStub
+        ? new Set(getRawCairoFunctionInfo(rawStringDefinition).implicits)
+        : functionSutbKind === FunctionStubKind.StorageDefStub
+        ? new Set(['pedersen_ptr'])
+        : new Set(),
+      functionSutbKind,
+      acceptsRawDArray,
+      acceptsUnpackedStructArray,
+    );
+    this.rawStringDefinition = rawStringDefinition;
+  }
+}

src/ast/cairoNodes/index.ts

@@ -1,4 +1,6 @@
 export * from './cairoAssert';
 export * from './cairoContract';
+export * from './cairoGeneratedFunctionDefinition';
 export * from './cairoFunctionDefinition';
+export * from './cairoImportFunctionDefinition';
 export * from './cairoTempVarStatement';

src/ast/visitor.ts

@@ -73,6 +73,7 @@ import {
 } from './cairoNodes';
 
 import { AST } from './ast';
+import { CairoGeneratedFunctionDefinition } from './cairoNodes/cairoGeneratedFunctionDefinition';
 
 /*
  Visits every node in a tree in depth first order, calling visitT for each T extends ASTNode
@@ -120,6 +121,8 @@ export abstract class ASTVisitor<T> {
     else if (node instanceof Literal) res = this.visitLiteral(node, ast);
     else if (node instanceof TupleExpression) res = this.visitTupleExpression(node, ast);
     else if (node instanceof UnaryOperation) res = this.visitUnaryOperation(node, ast);
+    else if (node instanceof CairoGeneratedFunctionDefinition)
+      res = this.visitCairoGeneratedFunctionDefinition(node, ast);
     else if (node instanceof CairoFunctionDefinition)
       res = this.visitCairoFunctionDefinition(node, ast);
     else if (node instanceof CairoTempVarStatement) res = this.visitCairoTempVar(node, ast);
@@ -169,6 +172,9 @@ export abstract class ASTVisitor<T> {
   visitCairoFunctionDefinition(node: CairoFunctionDefinition, ast: AST): T {
     return this.visitFunctionDefinition(node, ast);
   }
+  visitCairoGeneratedFunctionDefinition(node: CairoGeneratedFunctionDefinition, ast: AST): T {
+    return this.visitCairoFunctionDefinition(node, ast);
+  }
   visitCairoTempVar(node: CairoTempVarStatement, ast: AST): T {
     return this.commonVisit(node, ast);
   }