Add snapshot tests for module level events

crates/analyzer/tests/analysis.rs

@@ -130,6 +130,7 @@ test_analysis! { create_contract, "features/create_contract.fe"}
 test_analysis! { create_contract_from_init, "features/create_contract_from_init.fe"}
 test_analysis! { empty, "features/empty.fe"}
 test_analysis! { events, "features/events.fe"}
+test_analysis! { module_level_events, "features/module_level_events.fe"}
 test_analysis! { external_contract, "features/external_contract.fe"}
 test_analysis! { for_loop_with_break, "features/for_loop_with_break.fe"}
 test_analysis! { for_loop_with_continue, "features/for_loop_with_continue.fe"}
@@ -237,12 +238,11 @@ fn build_snapshot(file_store: &FileStore, module: items::ModuleId, db: &dyn Anal
             )],
             Item::Type(TypeDef::Struct(struct_)) => [
                 label_in_non_overlapping_groups(
-                &struct_
-                    .fields(db)
-                    .values()
-                    .map(|field| (field.data(db).ast.span, field.typ(db).unwrap()))
-                    .collect::<Vec<_>>(),
-
+                    &struct_
+                        .fields(db)
+                        .values()
+                        .map(|field| (field.data(db).ast.span, field.typ(db).unwrap()))
+                        .collect::<Vec<_>>(),
                 ),
                 struct_
                     .functions(db)
@@ -278,11 +278,10 @@ fn build_snapshot(file_store: &FileStore, module: items::ModuleId, db: &dyn Anal
             Item::Function(id) => function_diagnostics(*id, db),
             Item::Constant(id) => vec![build_display_diagnostic(id.span(db), &id.typ(db).unwrap())],
 
-
             // Events can't be defined at the module level yet.
-            Item::Event(_)
+            Item::Event(id) => event_diagnostics(*id, db),
             // Built-in stuff
-            | Item::Type(TypeDef::Primitive(_))
+            Item::Type(TypeDef::Primitive(_))
             | Item::GenericType(_)
             | Item::BuiltinFunction(_)
             | Item::Intrinsic(_)

crates/analyzer/tests/snapshots/analysis__module_level_events.snap

@@ -0,0 +1,109 @@
+---
+source: crates/analyzer/tests/analysis.rs
+expression: "build_snapshot(&files, module_id, &db)"
+
+---
+note: 
+  ┌─ features/module_level_events.fe:2:5
+  │
+2 │     idx sum: u256
+  │     ^^^^^^^^^^^^^ u256
+
+note: 
+  ┌─ features/module_level_events.fe:4:5
+  │  
+4 │ ╭     pub fn add(a: u256, b: u256) -> u256:
+5 │ │         let sum: u256 = a + b
+6 │ │         emit Added(sum=sum)
+7 │ │         return a + b
+  │ ╰────────────────────^ attributes hash: 10094331793610550579
+  │  
+  = FunctionSignature {
+        self_decl: None,
+        params: [
+            FunctionParam {
+                name: "a",
+                typ: Ok(
+                    Base(
+                        Numeric(
+                            U256,
+                        ),
+                    ),
+                ),
+            },
+            FunctionParam {
+                name: "b",
+                typ: Ok(
+                    Base(
+                        Numeric(
+                            U256,
+                        ),
+                    ),
+                ),
+            },
+        ],
+        return_type: Ok(
+            Base(
+                Numeric(
+                    U256,
+                ),
+            ),
+        ),
+    }
+
+note: 
+  ┌─ features/module_level_events.fe:5:18
+  │
+5 │         let sum: u256 = a + b
+  │                  ^^^^ u256
+
+note: 
+  ┌─ features/module_level_events.fe:5:25
+  │
+5 │         let sum: u256 = a + b
+  │                         ^   ^ u256: Value
+  │                         │    
+  │                         u256: Value
+
+note: 
+  ┌─ features/module_level_events.fe:5:25
+  │
+5 │         let sum: u256 = a + b
+  │                         ^^^^^ u256: Value
+6 │         emit Added(sum=sum)
+  │                        ^^^ u256: Value
+7 │         return a + b
+  │                ^   ^ u256: Value
+  │                │    
+  │                u256: Value
+
+note: 
+  ┌─ features/module_level_events.fe:7:16
+  │
+7 │         return a + b
+  │                ^^^^^ u256: Value
+
+note: 
+  ┌─ features/module_level_events.fe:6:9
+  │
+6 │         emit Added(sum=sum)
+  │         ^^^^^^^^^^^^^^^^^^^ attributes hash: 3277580564244611338
+  │
+  = Event {
+        name: "Added",
+        fields: [
+            EventField {
+                name: "sum",
+                typ: Ok(
+                    Base(
+                        Numeric(
+                            U256,
+                        ),
+                    ),
+                ),
+                is_indexed: true,
+            },
+        ],
+    }
+
+

crates/lowering/tests/lowering.rs

@@ -76,5 +76,6 @@ test_file! { module_fn, "lowering/module_fn.fe" }
 test_file! { struct_fn, "lowering/struct_fn.fe" }
 test_file! { ternary, "lowering/ternary.fe" }
 test_file! { and_or, "lowering/and_or.fe" }
+test_file! { module_level_events, "lowering/module_level_events.fe" }
 // TODO: the analyzer rejects lowered nested tuples.
 // test_file!(array_tuple, "lowering/array_tuple.fe");

crates/lowering/tests/snapshots/lowering__module_level_events.snap

@@ -0,0 +1,13 @@
+---
+source: crates/lowering/tests/lowering.rs
+expression: lowered_code
+
+---
+event Added:
+    idx sum: u256
+
+contract Adder:
+    pub fn add(a: u256, b: u256) -> u256:
+        let sum: u256 = a + b
+        emit Added(sum=sum)
+        return a + b

crates/parser/tests/cases/parse_ast.rs

@@ -227,3 +227,13 @@ contract GuestBook:
     pub fn get_msg(self, addr: address) -> BookMsg:
         return self.guest_book[addr]
 "# }
+
+test_parse! { module_level_event, module::parse_module, r#"
+event Added:
+    idx sum: u256
+contract Adder:
+    pub fn add(a: u256, b: u256) -> u256:
+        let sum: u256 = a + b
+        emit Added(sum=sum)
+        return a + b
+"# }