fix(vdev): match grouped dropped-event calls syntactically

Require the canonical struct receiver and cover unrelated comments, types, strings, and method calls with regression tests.

Environment: Datadog workspace

Author: ArunPiduguDD

vdev/src/commands/check/events.rs

@@ -381,9 +381,14 @@ static RE_EMIT_DROPPED: LazyLock<Regex> = LazyLock::new(|| {
     Regex::new(r"(?:emit|register)!\([ \t\r\n]*ComponentEventsDropped(?:[^A-Za-z0-9_]|$)").unwrap()
 });
 
-fn emits_component_events_dropped(source: &str) -> bool {
-    RE_EMIT_DROPPED.is_match(source)
-        || (source.contains("ComponentEventsDropped") && source.contains(".emit_with_group("))
+fn is_grouped_drop_call(call: &syn::ExprMethodCall) -> bool {
+    let mut receiver = call.receiver.as_ref();
+    while let syn::Expr::Paren(paren) = receiver {
+        receiver = &paren.expr;
+    }
+    call.method == "emit_with_group"
+        && matches!(receiver, syn::Expr::Struct(event)
+            if event.path.segments.last().is_some_and(|segment| segment.ident == "ComponentEventsDropped"))
 }
 
 /// `emit!(EventName)` / `register!(Path::EventName)` use-counting regex,
@@ -737,7 +742,7 @@ impl<'ast> Visit<'ast> for Scanner<'_> {
                     "InternalEventHandle" => event.impl_event_handle = true,
                     _ => {}
                 }
-                if emits_component_events_dropped(&raw_block) {
+                if RE_EMIT_DROPPED.is_match(&raw_block) {
                     event.emits_component_events_dropped = true;
                 }
                 self.impl_stack.push(ImplCtx { event_name });
@@ -752,6 +757,18 @@ impl<'ast> Visit<'ast> for Scanner<'_> {
         visit::visit_item_impl(self, node);
     }
 
+    fn visit_expr_method_call(&mut self, node: &'ast syn::ExprMethodCall) {
+        if is_grouped_drop_call(node)
+            && let Some(ctx) = self.impl_stack.last()
+        {
+            self.events
+                .entry(ctx.event_name.clone())
+                .or_default()
+                .emits_component_events_dropped = true;
+        }
+        visit::visit_expr_method_call(self, node);
+    }
+
     fn visit_macro(&mut self, node: &'ast syn::Macro) {
         let name = node
             .path
@@ -760,8 +777,8 @@ impl<'ast> Visit<'ast> for Scanner<'_> {
             .map(|s| s.ident.to_string())
             .unwrap_or_default();
 
-        // Use-counting, ComponentEventsDropped detection, and the
-        // log-message format check all run via a separate raw-source pass
+        // Use-counting, emit!/register! ComponentEventsDropped detection, and
+        // the log-message format check run via a separate raw-source pass
         // because `syn` does not descend into the bodies of arbitrary
         // `tokio::select!` / `cfg_if!` / etc. macro invocations.
 
@@ -884,7 +901,9 @@ impl Scanner<'_> {
             // Component-events-dropped emission.
             if expr.contains("emit ! (ComponentEventsDropped")
                 || expr.contains("register ! (ComponentEventsDropped")
-                || (expr.contains("ComponentEventsDropped") && expr.contains(". emit_with_group ("))
+                || syn::parse_str::<syn::Expr>(expr).is_ok_and(|expr| {
+                    matches!(expr, syn::Expr::MethodCall(call) if is_grouped_drop_call(&call))
+                })
             {
                 event.emits_component_events_dropped = true;
             }
@@ -1264,17 +1283,58 @@ mod tests {
         assert_eq!(split_comma_args(input), vec![input.to_string()]);
     }
 
+    fn scan_dropped_event(body: &str) -> Event {
+        let source = format!(
+            "struct TestEventsDropped; impl InternalEvent for TestEventsDropped {{ fn emit(self) {{ {body} }} }}"
+        );
+        let file = syn::parse_file(&source).expect("parse event");
+        let mut events = HashMap::new();
+        Scanner {
+            events: &mut events,
+            path_str: "src/internal_events/test.rs".into(),
+            in_internal_events_dir: true,
+            skip_dropped_for_file: false,
+            text: &source,
+            impl_stack: Vec::new(),
+        }
+        .visit_file(&file);
+        let mut event = events.remove("TestEventsDropped").expect("scanned event");
+        event.uses = 1;
+        event
+    }
+
     #[test]
     fn recognizes_component_events_dropped_emit_with_group() {
-        let source = r#"
-            ComponentEventsDropped::<INTENTIONAL> {
-                count: 1,
-                reason: "discarded",
-            }
-            .emit_with_group(group);
-        "#;
+        for body in [
+            r#"ComponentEventsDropped::<INTENTIONAL> { count: 1, reason: "discarded" }
+                .emit_with_group(group);"#,
+            r#"(vector_lib::internal_event::ComponentEventsDropped::<INTENTIONAL> {
+                count: 1, reason: "discarded",
+            }).emit_with_group(group);"#,
+        ] {
+            let event = scan_dropped_event(body);
+            assert!(event.emits_component_events_dropped, "{body}");
+            assert!(run("TestEventsDropped", event).is_empty());
+        }
+    }
 
-        assert!(emits_component_events_dropped(source));
+    #[test]
+    fn unrelated_group_calls_do_not_bypass_dropped_event_validation() {
+        for body in [
+            "// ComponentEventsDropped\nother.emit_with_group(group);",
+            "let _: Option<ComponentEventsDropped> = None; other.emit_with_group(group);",
+            r#"let _ = "ComponentEventsDropped { count: 1 }.emit_with_group(group)";
+                other.emit_with_group(group);"#,
+            "let _ = ComponentEventsDropped { count: 1 }; other.emit_with_group(group);",
+        ] {
+            let event = scan_dropped_event(body);
+            assert!(!event.emits_component_events_dropped, "{body}");
+            let reports = run("TestEventsDropped", event);
+            assert!(reports.iter().any(|report| report.contains("MUST log")));
+            assert!(reports.iter().any(|report| report.contains(&format!(
+                "This event MUST increment counter \"{METRIC_NAME_EVENTS_DROPPED}\"."
+            ))));
+        }
     }
 
     #[test]