Add support for custom errors

Author: fvictorio

src/ASTBuilder.ts

@@ -705,6 +705,29 @@ export class ASTBuilder
     return this._addMeta(node, ctx)
   }
 
+  public visitCustomErrorDefinition(
+    ctx: SP.CustomErrorDefinitionContext
+  ): AST.CustomErrorDefinition & WithMeta {
+    const node: AST.CustomErrorDefinition = {
+      type: 'CustomErrorDefinition',
+      name: this._toText(ctx.identifier()),
+      parameters: this.visitParameterList(ctx.parameterList()),
+    }
+
+    return this._addMeta(node, ctx)
+  }
+
+  public visitRevertStatement(
+    ctx: SP.RevertStatementContext
+  ): AST.RevertStatement & WithMeta {
+    const node: AST.RevertStatement = {
+      type: 'RevertStatement',
+      revertCall: this.visitFunctionCall(ctx.functionCall()),
+    }
+
+    return this._addMeta(node, ctx)
+  }
+
   public visitFunctionCall(
     ctx: SP.FunctionCallContext
   ): AST.FunctionCall & WithMeta {

src/ast-types.ts

@@ -57,6 +57,8 @@ export const astNodeTypes = [
   'ModifierInvocation',
   'FunctionDefinition',
   'EventDefinition',
+  'CustomErrorDefinition',
+  'RevertStatement',
   'EnumValue',
   'EnumDefinition',
   'VariableDeclaration',
@@ -181,6 +183,15 @@ export interface FunctionDefinition extends BaseASTNode {
   isFallback: boolean
   isVirtual: boolean
 }
+export interface CustomErrorDefinition extends BaseASTNode {
+  type: 'CustomErrorDefinition'
+  name: string
+  parameters: VariableDeclaration[]
+}
+export interface RevertStatement extends BaseASTNode {
+  type: 'RevertStatement'
+  revertCall: FunctionCall
+}
 export interface EventDefinition extends BaseASTNode {
   type: 'EventDefinition'
   name: string
@@ -558,6 +569,7 @@ export type ASTNode =
   | ModifierInvocation
   | FunctionDefinition
   | EventDefinition
+  | CustomErrorDefinition
   | EnumValue
   | EnumDefinition
   | VariableDeclaration
@@ -659,6 +671,7 @@ export type Statement =
   | VariableDeclarationStatement
   | UncheckedStatement
   | TryStatement
+  | RevertStatement
 
 type ASTMap<U> = { [K in ASTNodeTypeString]: U extends { type: K } ? U : never };
 type ASTTypeMap = ASTMap<ASTNode>;

test/ast.ts

@@ -347,7 +347,7 @@ describe('AST', () => {
           isDeclaredConst: false,
           isIndexed: false,
           isImmutable: false,
-          storageLocation: null
+          storageLocation: null,
         },
       ],
       initialValue: null,
@@ -374,7 +374,7 @@ describe('AST', () => {
           isDeclaredConst: false,
           isIndexed: false,
           isImmutable: true,
-          storageLocation: null
+          storageLocation: null,
         },
       ],
       initialValue: null,
@@ -433,7 +433,7 @@ describe('AST', () => {
           isDeclaredConst: false,
           isIndexed: false,
           isImmutable: false,
-          storageLocation: null
+          storageLocation: null,
         },
       ],
       initialValue: null,
@@ -502,7 +502,7 @@ describe('AST', () => {
           isDeclaredConst: false,
           isIndexed: false,
           isImmutable: false,
-          storageLocation: null
+          storageLocation: null,
         },
       ],
       initialValue: null,
@@ -2254,7 +2254,7 @@ describe('AST', () => {
             type: 'DecimalNumber',
             value: '0',
           },
-          default: false
+          default: false,
         },
         {
           type: 'AssemblyCase',
@@ -2895,4 +2895,142 @@ describe('AST', () => {
       },
     })
   })
+
+  it('should support top-level custom errors', function () {
+    let ast: any = parser.parse('error MyCustomError();')
+    assert.deepEqual(ast.children[0], {
+      type: 'CustomErrorDefinition',
+      name: 'MyCustomError',
+      parameters: [],
+    })
+
+    ast = parser.parse('error MyCustomError(uint a);')
+    assert.deepEqual(ast.children[0], {
+      type: 'CustomErrorDefinition',
+      name: 'MyCustomError',
+      parameters: [
+        {
+          type: 'VariableDeclaration',
+          typeName: {
+            type: 'ElementaryTypeName',
+            name: 'uint',
+            stateMutability: null,
+          },
+          name: 'a',
+          isStateVar: false,
+          isIndexed: false,
+          expression: null,
+          storageLocation: null,
+        },
+      ],
+    })
+
+    ast = parser.parse('error MyCustomError(string);')
+    assert.deepEqual(ast.children[0], {
+      type: 'CustomErrorDefinition',
+      name: 'MyCustomError',
+      parameters: [
+        {
+          type: 'VariableDeclaration',
+          typeName: {
+            type: 'ElementaryTypeName',
+            name: 'string',
+            stateMutability: null,
+          },
+          name: null,
+          isStateVar: false,
+          isIndexed: false,
+          expression: null,
+          storageLocation: null,
+        },
+      ],
+    })
+  })
+
+  it('should support contract-level custom errors', function () {
+    let ast: any = parseNode('error MyCustomError();')
+    assert.deepEqual(ast, {
+      type: 'CustomErrorDefinition',
+      name: 'MyCustomError',
+      parameters: [],
+    })
+
+    ast = parseNode('error MyCustomError(uint a);')
+    assert.deepEqual(ast, {
+      type: 'CustomErrorDefinition',
+      name: 'MyCustomError',
+      parameters: [
+        {
+          type: 'VariableDeclaration',
+          typeName: {
+            type: 'ElementaryTypeName',
+            name: 'uint',
+            stateMutability: null,
+          },
+          name: 'a',
+          isStateVar: false,
+          isIndexed: false,
+          expression: null,
+          storageLocation: null,
+        },
+      ],
+    })
+
+    ast = parseNode('error MyCustomError(string);')
+    assert.deepEqual(ast, {
+      type: 'CustomErrorDefinition',
+      name: 'MyCustomError',
+      parameters: [
+        {
+          type: 'VariableDeclaration',
+          typeName: {
+            type: 'ElementaryTypeName',
+            name: 'string',
+            stateMutability: null,
+          },
+          name: null,
+          isStateVar: false,
+          isIndexed: false,
+          expression: null,
+          storageLocation: null,
+        },
+      ],
+    })
+  })
+
+  it('should support revert statements', function () {
+    let ast: any = parseStatement('revert MyCustomError();')
+    assert.deepEqual(ast, {
+      type: 'RevertStatement',
+      revertCall: {
+        arguments: [],
+        expression: {
+          name: 'MyCustomError',
+          type: 'Identifier',
+        },
+        names: [],
+        type: 'FunctionCall',
+      },
+    })
+
+    ast = parseStatement('revert MyCustomError(3);')
+    assert.deepEqual(ast, {
+      type: 'RevertStatement',
+      revertCall: {
+        arguments: [
+          {
+            number: '3',
+            subdenomination: null,
+            type: 'NumberLiteral',
+          },
+        ],
+        expression: {
+          name: 'MyCustomError',
+          type: 'Identifier',
+        },
+        names: [],
+        type: 'FunctionCall',
+      },
+    })
+  })
 })

test/test.sol

@@ -733,3 +733,19 @@ contract ArraySlices {
         address a3 = abi.decode(x[4:], (address));
     }
 }
+
+// custom errors
+
+error TopLevelCustomError();
+error TopLevelCustomErrorWithArg(uint x);
+error TopLevelCustomErrorArgWithoutName(string);
+
+contract CustomErrors {
+  error ContractCustomError();
+  error ContractCustomErrorWithArg(uint x);
+  error ContractCustomErrorArgWithoutName(string);
+
+  function throwCustomError() {
+    revert ContractCustomError();
+  }
+}