fix: 2 TDD bugs — comment braces in function detection, duplicate LSP symbols

- function_chunker.rs: Skip braces inside line comments (// and #)
  when tracking brace depth. Previously `// }` in a comment would
  prematurely terminate function boundary detection.
- symbol_index.rs: Use else-if between DocumentSymbol and
  SymbolInformation format detection to prevent pushing the same
  symbol twice when both selectionRange and location fields exist.

983 tests pass.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: haasonsaas

src/core/function_chunker.rs

@@ -251,17 +251,30 @@ fn find_function_end(lines: &[&str], start: usize, language: &str) -> usize {
             lines.len().saturating_sub(1)
         }
         _ => {
-            // Brace-based languages — skip braces inside string literals
+            // Brace-based languages — skip braces inside string literals and comments
             let mut depth = 0i32;
             let mut found_open = false;
             for (i, line) in lines.iter().enumerate().skip(start) {
                 let mut in_double_quote = false;
                 let mut in_single_quote = false;
                 let mut escaped = false;
+                let mut prev_ch = '\0';
                 for ch in line.chars() {
                     if escaped {
                         escaped = false;
-                    } else if (in_double_quote || in_single_quote) && ch == '\\' {
+                        prev_ch = ch;
+                        continue;
+                    }
+                    // Skip line comments: // in most languages, # in Python/Ruby/Shell
+                    if !in_double_quote && !in_single_quote {
+                        if ch == '/' && prev_ch == '/' {
+                            break; // rest of line is a comment
+                        }
+                        if ch == '#' && !in_double_quote && !in_single_quote {
+                            break; // rest of line is a comment
+                        }
+                    }
+                    if (in_double_quote || in_single_quote) && ch == '\\' {
                         escaped = true;
                     } else if ch == '"' && !in_single_quote {
                         in_double_quote = !in_double_quote;
@@ -275,6 +288,7 @@ fn find_function_end(lines: &[&str], start: usize, language: &str) -> usize {
                             depth -= 1;
                         }
                     }
+                    prev_ch = ch;
                 }
                 if found_open && depth <= 0 {
                     return i;
@@ -967,4 +981,41 @@ fn next_func() {
             "Function should end at line 0 (braces balanced on same line with escaped backslash)"
         );
     }
+
+    // ── Bug: closing brace in line comment breaks function detection ──
+    //
+    // find_function_end tracks braces inside string literals but ignores
+    // braces in line comments (// and #). A comment like `// }` causes
+    // premature function termination.
+
+    #[test]
+    fn test_find_function_end_brace_in_line_comment() {
+        let lines: Vec<&str> = vec![
+            "fn foo() {",            // line 0: open brace
+            "    let x = 1; // }",   // line 1: closing brace in comment
+            "    println!(\"ok\");", // line 2
+            "}",                     // line 3: actual close
+        ];
+        let end = find_function_end(&lines, 0, "rs");
+        assert_eq!(
+            end, 3,
+            "Brace in line comment should be ignored; function ends at line 3"
+        );
+    }
+
+    #[test]
+    fn test_find_function_end_hash_comment() {
+        let lines: Vec<&str> = vec![
+            "function foo() {", // line 0: opening brace
+            "    x = 1  # }",   // line 1: brace in hash comment
+            "    y = 2",        // line 2
+            "}",                // line 3: actual close
+        ];
+        // Use a brace-based language to test hash comment detection
+        let end = find_function_end(&lines, 0, "rb");
+        assert_eq!(
+            end, 3,
+            "Brace in # comment should be ignored; function ends at line 3"
+        );
+    }
 }

src/core/symbol_index.rs

@@ -1140,6 +1140,7 @@ fn extract_lsp_symbols(result: &Value) -> Vec<LspSymbol> {
 
 fn collect_lsp_symbol(value: &Value, symbols: &mut Vec<LspSymbol>) {
     if let Some(obj) = value.as_object() {
+        // DocumentSymbol format: selectionRange or range on the object itself
         if let (Some(name), Some(range)) = (
             obj.get("name").and_then(|v| v.as_str()),
             extract_range(obj.get("selectionRange").or_else(|| obj.get("range"))),
@@ -1148,9 +1149,8 @@ fn collect_lsp_symbol(value: &Value, symbols: &mut Vec<LspSymbol>) {
                 name: name.to_string(),
                 range,
             });
-        }
-
-        if let Some(location) = obj.get("location") {
+        } else if let Some(location) = obj.get("location") {
+            // SymbolInformation format: range inside a location object
             if let (Some(name), Some(range)) = (
                 obj.get("name").and_then(|v| v.as_str()),
                 extract_range(location.get("range")),
@@ -1272,4 +1272,58 @@ mod tests {
         assert!(candidates.contains(&PathBuf::from("src/lib.rs")));
         assert!(candidates.contains(&PathBuf::from("src/lib.py")));
     }
+
+    // ── Bug: collect_lsp_symbol pushes duplicate when both formats present ──
+    //
+    // LSP responses can include both selectionRange (DocumentSymbol) and
+    // location (SymbolInformation) fields. The old code had two separate
+    // `if` blocks, causing the same symbol to be pushed twice.
+
+    #[test]
+    fn test_collect_lsp_symbol_no_duplicate() {
+        use serde_json::json;
+        let value = json!({
+            "name": "MyFunc",
+            "selectionRange": {
+                "start": { "line": 5, "character": 0 },
+                "end": { "line": 5, "character": 10 }
+            },
+            "location": {
+                "uri": "file:///test.rs",
+                "range": {
+                    "start": { "line": 5, "character": 0 },
+                    "end": { "line": 20, "character": 0 }
+                }
+            }
+        });
+        let mut symbols = Vec::new();
+        collect_lsp_symbol(&value, &mut symbols);
+        assert_eq!(
+            symbols.len(),
+            1,
+            "Symbol with both selectionRange and location should only be pushed once"
+        );
+        assert_eq!(symbols[0].name, "MyFunc");
+    }
+
+    #[test]
+    fn test_collect_lsp_symbol_location_fallback() {
+        use serde_json::json;
+        // SymbolInformation format: no selectionRange or range, only location
+        let value = json!({
+            "name": "MyVar",
+            "location": {
+                "uri": "file:///test.rs",
+                "range": {
+                    "start": { "line": 10, "character": 0 },
+                    "end": { "line": 10, "character": 5 }
+                }
+            }
+        });
+        let mut symbols = Vec::new();
+        collect_lsp_symbol(&value, &mut symbols);
+        assert_eq!(symbols.len(), 1);
+        assert_eq!(symbols[0].name, "MyVar");
+        assert_eq!(symbols[0].range, (11, 11)); // 0-based to 1-based
+    }
 }