Checker: cfg-gate: detect enclosing block scope

The cfg-gate checker walked backwards from `use` lines looking for `#[cfg(target_os = "macos")]`, but stopped at any code line that didn't end with `{`. This caused false positives for `use` statements inside cfg-gated functions when other code lines (e.g. another `use`) appeared between the opening brace and the flagged line.

Split hasMacOSCfgAttribute into two phases: (1) check for direct attributes above the line, (2) find the enclosing block via brace depth tracking and recursively check if it's cfg-gated.

Author: vdavid

apps/desktop/src-tauri/src/lib.rs

@@ -109,9 +109,9 @@ mod stubs;
 
 use menu::{
     CLOSE_TAB_ID, CommandScope, EDIT_COPY_ID, EDIT_CUT_ID, EDIT_PASTE_ID, MenuState, SHOW_HIDDEN_FILES_ID,
-    SORT_ASCENDING_ID, SORT_BY_CREATED_ID, SORT_BY_EXTENSION_ID, SORT_BY_MODIFIED_ID, SORT_BY_NAME_ID,
-    SORT_BY_SIZE_ID, SORT_DESCENDING_ID, TAB_CLOSE_ID, TAB_CLOSE_OTHERS_ID, TAB_PIN_ID, VIEW_MODE_BRIEF_ID,
-    VIEW_MODE_FULL_ID, VIEWER_WORD_WRAP_ID, ViewMode, menu_id_to_command,
+    SORT_ASCENDING_ID, SORT_BY_CREATED_ID, SORT_BY_EXTENSION_ID, SORT_BY_MODIFIED_ID, SORT_BY_NAME_ID, SORT_BY_SIZE_ID,
+    SORT_DESCENDING_ID, TAB_CLOSE_ID, TAB_CLOSE_OTHERS_ID, TAB_PIN_ID, VIEW_MODE_BRIEF_ID, VIEW_MODE_FULL_ID,
+    VIEWER_WORD_WRAP_ID, ViewMode, menu_id_to_command,
 };
 use tauri::{Emitter, Manager};
 

scripts/check/checks/desktop-rust-cfg-gate.go

@@ -265,43 +265,60 @@ var attrLinePattern = regexp.MustCompile(`^\s*#\[`)
 // to check if any preceding attribute contains target_os = "macos" (and not negated with not(...)).
 // Also handles `use` statements inside cfg-gated blocks (e.g., inside a #[cfg(target_os = "macos")] fn).
 func hasMacOSCfgAttribute(lines []string, lineIdx int) bool {
+	// Phase 1: Check for cfg attributes directly above this line (no code lines in between).
+	if hasDirectCfgAttribute(lines, lineIdx) {
+		return true
+	}
+
+	// Phase 2: Find the enclosing block via brace tracking and check if it's cfg-gated.
+	return isInsideCfgGatedBlock(lines, lineIdx)
+}
+
+// hasDirectCfgAttribute checks whether a macOS cfg attribute appears directly above lineIdx,
+// separated only by blank lines and other attributes.
+func hasDirectCfgAttribute(lines []string, lineIdx int) bool {
 	for j := lineIdx - 1; j >= 0; j-- {
 		trimmed := strings.TrimSpace(lines[j])
 
-		// Skip blank lines
 		if trimmed == "" {
 			continue
 		}
 
-		// If this is an attribute line (starts with #[), check it
 		if attrLinePattern.MatchString(lines[j]) {
-			// This attribute might be multi-line. Collect the full attribute text.
 			attrText := collectAttribute(lines, j)
 			if isMacOSGateAttribute(attrText) {
 				return true
 			}
-			// It's an attribute but not a macOS gate — keep walking (there could be stacked attributes)
 			continue
 		}
 
-		// If we hit a line that's part of a multi-line attribute (doesn't start with #[
-		// but looks like attribute content — e.g., ends with )] or contains attribute-like content),
-		// skip it. We handle multi-line attributes by collecting from the #[ opener.
 		if isAttributeContinuation(trimmed) {
 			continue
 		}
 
-		// Hit a non-blank, non-attribute line. If it ends with '{', it could be a
-		// function/block/impl opening that's itself cfg-gated (e.g., #[cfg(target_os = "macos")] fn foo() {).
-		// Recursively check the attributes above this enclosing block.
-		if strings.HasSuffix(trimmed, "{") {
-			if hasMacOSCfgAttribute(lines, j) {
-				return true
-			}
+		// Hit a code line — no direct cfg attribute
+		break
+	}
+	return false
+}
+
+// isInsideCfgGatedBlock walks backwards from lineIdx, tracking brace depth, to find the
+// enclosing block opener. If found, it recursively checks whether that block is cfg-gated.
+func isInsideCfgGatedBlock(lines []string, lineIdx int) bool {
+	braceDepth := 0
+	for j := lineIdx - 1; j >= 0; j-- {
+		trimmed := strings.TrimSpace(lines[j])
+		if trimmed == "" {
+			continue
 		}
 
-		// Stop walking — this is a regular code line
-		break
+		braceDepth += strings.Count(trimmed, "}") - strings.Count(trimmed, "{")
+
+		if braceDepth < 0 {
+			// Found an unmatched '{' — this is the enclosing block.
+			// Check if it (or its enclosing scope) has a macOS cfg gate.
+			return hasMacOSCfgAttribute(lines, j)
+		}
 	}
 	return false
 }

scripts/check/checks/desktop-rust-cfg-gate_test.go

@@ -946,6 +946,20 @@ use core_foundation::base;`, "\n")
 	}
 }
 
+func TestHasMacOSCfgAttribute_CodeLinesBetweenBraceAndUse(t *testing.T) {
+	lines := strings.Split(`#[cfg(target_os = "macos")]
+fn macos_only() {
+    use objc2::sel;
+    use core_foundation::base;
+}`, "\n")
+
+	// Line 3 is "use core_foundation::base;". There's another use statement (line 2) between
+	// it and the opening brace (line 1). The checker should still find the enclosing cfg gate.
+	if !hasMacOSCfgAttribute(lines, 3) {
+		t.Error("expected true for use inside cfg-gated block with intervening code lines")
+	}
+}
+
 func TestHasMacOSCfgAttribute_NestedBlock(t *testing.T) {
 	lines := strings.Split(`#[cfg(target_os = "macos")]
 impl Foo {