fix: add -arch flag to GCC flags to prevent argument loss on macOS ARM (#674)

* fix: add -arch flag to GCC flags to prevent argument loss

On macOS, cc/gcc are Apple Clang and pass -arch arm64, but Bear
classifies them as GCC. Since -arch was only defined in CLANG_FLAGS,
the GCC parser treated -arch as an unknown standalone flag and
misclassified the following argument (e.g. arm64) as a source file,
which was then silently dropped from compile_commands.json.

This caused clangd to report: Invalid arch name '-arch -Wall'

Add -arch and -arch_only to GCC_FLAGS so the parser correctly consumes
the flag-value pair regardless of which interpreter handles the command.

Fixes #673

* fix: lint issue

Author: thisalihassan

bear/src/semantic/interpreters/compilers/gcc.rs

@@ -406,6 +406,11 @@ pub static GCC_FLAGS: std::sync::LazyLock<Vec<FlagRule>> = std::sync::LazyLock::
             ArgumentKind::Other(PassEffect::Configures(CompilerPass::Assembling)),
         ),
         // Other/unclassified options
+        FlagRule::new(
+            FlagPattern::Exactly("-arch", 1),
+            ArgumentKind::Other(PassEffect::Configures(CompilerPass::Compiling)),
+        ),
+        FlagRule::new(FlagPattern::Exactly("-arch_only", 1), ArgumentKind::Other(PassEffect::None)),
         FlagRule::new(FlagPattern::Exactly("-ansi", 0), ArgumentKind::Other(PassEffect::None)),
         FlagRule::new(FlagPattern::Exactly("-aux-info", 1), ArgumentKind::Other(PassEffect::None)),
         // Compilation options
@@ -1484,4 +1489,38 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn test_arch_flag_preserves_argument() {
+        let interpreter = GccInterpreter::new();
+
+        // On macOS, cc/gcc are Apple Clang and pass -arch arm64.
+        // The -arch flag takes one argument; both must be preserved.
+        let execution =
+            create_execution("cc", vec!["cc", "-arch", "arm64", "-Wall", "-O2", "-c", "hello.c"], "/project");
+
+        let result = interpreter.recognize(&execution).unwrap();
+
+        if let Command::Compiler(cmd) = result {
+            // -arch arm64 must be recognised as a single two-token flag
+            let arch_arg = cmd.arguments.iter().find(|a| {
+                let tokens = a.as_arguments(&|p| Cow::Borrowed(p));
+                tokens.len() == 2 && tokens[0] == "-arch" && tokens[1] == "arm64"
+            });
+            assert!(arch_arg.is_some(), "-arch arm64 should be captured as a single argument pair");
+            assert_eq!(
+                arch_arg.unwrap().kind(),
+                ArgumentKind::Other(PassEffect::Configures(CompilerPass::Compiling))
+            );
+
+            // arm64 must NOT appear as a source file
+            let bad_source = cmd.arguments.iter().any(|a| {
+                let tokens = a.as_arguments(&|p| Cow::Borrowed(p));
+                tokens.len() == 1 && tokens[0] == "arm64"
+            });
+            assert!(!bad_source, "arm64 must not be misclassified as a source file");
+        } else {
+            panic!("Expected compiler command");
+        }
+    }
 }