fix(cheatcodes): expectEmit(count: 0) should not fail on a different log (#11663)

* fix(cheatcodes): expectEmit(count: 0) should not fail on a different log

* nit

* nit

---------

Co-authored-by: grandizzy <[email protected]>

Author: yash-atreya

crates/cheatcodes/src/inspector.rs

@@ -1539,7 +1539,13 @@ impl Inspector<EthEvmContext<&mut dyn DatabaseExt>> for Cheatcodes {
 
             // Check if we have any leftover expected emits
             // First, if any emits were found at the root call, then we its ok and we remove them.
-            self.expected_emits.retain(|(expected, _)| expected.count > 0 && !expected.found);
+            // For count=0 expectations, NOT being found is success, so mark them as found
+            for (expected, _) in &mut self.expected_emits {
+                if expected.count == 0 && !expected.found {
+                    expected.found = true;
+                }
+            }
+            self.expected_emits.retain(|(expected, _)| !expected.found);
             // If not empty, we got mismatched emits
             if !self.expected_emits.is_empty() {
                 let msg = if outcome.result.is_ok() {

crates/cheatcodes/src/test/expect.rs

@@ -809,6 +809,26 @@ pub(crate) fn handle_expect_emit(
         return;
     }
 
+    // Check count=0 expectations against this log - fail immediately if violated
+    for (expected_emit, _) in &state.expected_emits {
+        if expected_emit.count == 0
+            && !expected_emit.found
+            && let Some(expected_log) = &expected_emit.log
+            && checks_topics_and_data(expected_emit.checks, expected_log, log)
+            // Check revert address 
+            && (expected_emit.address.is_none() || expected_emit.address == Some(log.address))
+        {
+            // This event was emitted but we expected it NOT to be (count=0)
+            // Fail immediately
+            interpreter.bytecode.set_action(InterpreterAction::new_return(
+                InstructionResult::Revert,
+                Error::encode("log emitted 1 time, expected 0"),
+                interpreter.gas,
+            ));
+            return;
+        }
+    }
+
     let should_fill_logs = state.expected_emits.iter().any(|(expected, _)| expected.log.is_none());
     let index_to_fill_or_check = if should_fill_logs {
         // If there's anything to fill, we start with the last event to match in the queue
@@ -820,11 +840,19 @@ pub(crate) fn handle_expect_emit(
             .unwrap_or(state.expected_emits.len())
             .saturating_sub(1)
     } else {
-        // Otherwise, if all expected logs are filled, we start to check any unmatched event
+        // if all expected logs are filled, check any unmatched event
         // in the declared order, so we start from the front (like a queue).
-        0
+        // Skip count=0 expectations as they are handled separately above
+        state.expected_emits.iter().position(|(emit, _)| !emit.found && emit.count > 0).unwrap_or(0)
     };
 
+    // If there are only count=0 expectations left, we can return early
+    if !should_fill_logs
+        && state.expected_emits.iter().all(|(emit, _)| emit.found || emit.count == 0)
+    {
+        return;
+    }
+
     let (mut event_to_fill_or_check, mut count_map) = state
         .expected_emits
         .remove(index_to_fill_or_check)
@@ -852,18 +880,13 @@ pub(crate) fn handle_expect_emit(
     // Increment/set `count` for `log.address` and `log.data`
     match count_map.entry(log.address) {
         Entry::Occupied(mut entry) => {
-            // Checks and inserts the log into the map.
-            // If the log doesn't pass the checks, it is ignored and `count` is not incremented.
             let log_count_map = entry.get_mut();
             log_count_map.insert(&log.data);
         }
         Entry::Vacant(entry) => {
             let mut log_count_map = LogCountMap::new(&event_to_fill_or_check);
-
             if log_count_map.satisfies_checks(&log.data) {
                 log_count_map.insert(&log.data);
-
-                // Entry is only inserted if it satisfies the checks.
                 entry.insert(log_count_map);
             }
         }
@@ -910,7 +933,6 @@ pub(crate) fn handle_expect_emit(
         }
 
         let expected_count = event_to_fill_or_check.count;
-
         match event_to_fill_or_check.address {
             Some(emitter) => count_map
                 .get(&emitter)

crates/forge/tests/cli/failure_assertions.rs

@@ -222,8 +222,8 @@ Suite result: FAILED. 0 passed; 15 failed; 0 skipped; [ELAPSED]
 [FAIL: log != expected log] testShouldFailCountEmitsFromAddress() ([GAS])
 [FAIL: log != expected log] testShouldFailCountLessEmits() ([GAS])
 [FAIL: log != expected Something] testShouldFailEmitSomethingElse() ([GAS])
-[FAIL: log emitted 1 times, expected 0] testShouldFailNoEmit() ([GAS])
-[FAIL: log emitted 1 times, expected 0] testShouldFailNoEmitFromAddress() ([GAS])
+[FAIL: log emitted 1 time, expected 0] testShouldFailNoEmit() ([GAS])
+[FAIL: log emitted 1 time, expected 0] testShouldFailNoEmitFromAddress() ([GAS])
 Suite result: FAILED. 0 passed; 5 failed; 0 skipped; [ELAPSED]
 ...
 "#,

crates/forge/tests/it/repros.rs

@@ -422,3 +422,6 @@ test_repro!(
 
 // https://github.com/foundry-rs/foundry/issues/11353
 test_repro!(11353);
+
+// https://github.com/foundry-rs/foundry/issues/11616
+test_repro!(11616);

testdata/default/repros/Issue11616.t.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity ^0.8.24;
+
+import "ds-test/test.sol";
+import "cheats/Vm.sol";
+
+contract Emit {
+    event A();
+    event B();
+
+    function emitB() public {
+        emit B();
+    }
+}
+
+contract Issue11616Test is DSTest {
+    Vm constant vm = Vm(HEVM_ADDRESS);
+    Emit public e;
+
+    function setUp() public {
+        e = new Emit();
+    }
+
+    function test_emitNotOk() public {
+        vm.expectEmit({count: 0});
+        emit Emit.A();
+        vm.expectEmit();
+        emit Emit.B();
+        e.emitB();
+    }
+}