ControlCplusControlV
diff --git a/‎crates/abi/src/utils.rs‎
Lines changed: 3 additions & 3 deletions b/‎crates/abi/src/utils.rs‎
Lines changed: 3 additions & 3 deletions
diff --git a/‎crates/analyzer/src/namespace/types.rs‎
Lines changed: 5 additions & 0 deletions b/‎crates/analyzer/src/namespace/types.rs‎
Lines changed: 5 additions & 0 deletions
diff --git a/‎crates/analyzer/src/traversal/functions.rs‎
Lines changed: 27 additions & 1 deletion b/‎crates/analyzer/src/traversal/functions.rs‎
Lines changed: 27 additions & 1 deletion
diff --git a/‎crates/analyzer/tests/errors.rs‎
Lines changed: 2 additions & 0 deletions b/‎crates/analyzer/tests/errors.rs‎
Lines changed: 2 additions & 0 deletions
@@ -2,16 +2,16 @@ use fe_common::utils::keccak;
 
 /// Formats the name and fields and calculates the 32 byte keccak256 value of
 /// the signature.
-pub fn event_topic(name: &str, fields: Vec<String>) -> String {
+pub fn event_topic(name: &str, fields: &[String]) -> String {
     sign_event_or_func(name, fields, 32)
 }
 /// Formats the name and params and calculates the 4 byte keccak256 value of the
 /// signature.
-pub fn func_selector(name: &str, params: Vec<String>) -> String {
+pub fn func_selector(name: &str, params: &[String]) -> String {
     sign_event_or_func(name, params, 4)
 }
 
-fn sign_event_or_func(name: &str, params: Vec<String>, size: usize) -> String {
+fn sign_event_or_func(name: &str, params: &[String], size: usize) -> String {
     let signature = format!("{}({})", name, params.join(","));
     keccak::partial(signature.as_bytes(), size)
 }
@@ -220,6 +220,11 @@ impl Struct {
             .map(|(_, typ)| typ)
     }
 
+    /// Return the types of all fields
+    pub fn get_field_types(&self) -> Vec<FixedSize> {
+        self.fields.iter().cloned().map(|(_, typ)| typ).collect()
+    }
+
     /// Return the index of the given field name
     pub fn get_field_index(&self, name: &str) -> Option<usize> {
         self.fields.iter().position(|(field, _)| field == name)
 
@@ -233,7 +233,7 @@ fn func_stmt(
         Assert { .. } => assert(scope, context, stmt),
         Expr { .. } => expr(scope, context, stmt),
         Pass => Ok(()),
-        Revert { .. } => Ok(()),
+        Revert { .. } => revert(scope, context, stmt),
         Break | Continue => {
             loop_flow_statement(scope, context, stmt);
             Ok(())
@@ -439,6 +439,32 @@ fn assert(
     unreachable!()
 }
 
+fn revert(
+    scope: Shared<BlockScope>,
+    context: &mut Context,
+    stmt: &Node<fe::FuncStmt>,
+) -> Result<(), FatalError> {
+    if let fe::FuncStmt::Revert { error } = &stmt.kind {
+        if let Some(error_expr) = error {
+            let error_attributes = expressions::expr(Rc::clone(&scope), context, error_expr, None)?;
+            if !matches!(error_attributes.typ, Type::Struct(_)) {
+                context.error(
+                    "`revert` error must be a struct",
+                    error_expr.span,
+                    format!(
+                        "this has type `{}`; expected a struct",
+                        error_attributes.typ
+                    ),
+                );
+            }
+        }
+
+        return Ok(());
+    }
+
+    unreachable!()
+}
+
 fn func_return(
     scope: Shared<BlockScope>,
     context: &mut Context,
 
@@ -187,6 +187,8 @@ test_file! { return_call_to_fn_with_param_type_mismatch }
 test_file! { return_call_to_fn_without_return }
 test_file! { return_from_init }
 test_file! { return_lt_mixed_types }
+
+test_stmt! { revert_reason_not_stuct, "revert 1" }
 test_file! { strict_boolean_if_else }
 test_file! { struct_call_bad_args }
 test_file! { struct_call_without_kw_args }
Original file line number	Diff line number	Diff line change
`@@ -2,16 +2,16 @@ use fe_common::utils::keccak;`
`2`	`2`
`3`	`3`	`/// Formats the name and fields and calculates the 32 byte keccak256 value of`
`4`	`4`	`/// the signature.`
`5`		`-pub fn event_topic(name: &str, fields: Vec<String>) -> String {`
	`5`	`+pub fn event_topic(name: &str, fields: &[String]) -> String {`
`6`	`6`	`sign_event_or_func(name, fields, 32)`
`7`	`7`	`}`
`8`	`8`	`/// Formats the name and params and calculates the 4 byte keccak256 value of the`
`9`	`9`	`/// signature.`
`10`		`-pub fn func_selector(name: &str, params: Vec<String>) -> String {`
	`10`	`+pub fn func_selector(name: &str, params: &[String]) -> String {`
`11`	`11`	`sign_event_or_func(name, params, 4)`
`12`	`12`	`}`
`13`	`13`
`14`		`-fn sign_event_or_func(name: &str, params: Vec<String>, size: usize) -> String {`
	`14`	`+fn sign_event_or_func(name: &str, params: &[String], size: usize) -> String {`
`15`	`15`	`let signature = format!("{}({})", name, params.join(","));`
`16`	`16`	`keccak::partial(signature.as_bytes(), size)`
`17`	`17`	`}`