docs: document tree-sitter parseable but unsupported structures

Added TODO sections in test files documenting structures that can be parsed
by tree-sitter but currently lack query pattern support:

- Python: f-strings, complex type annotations, pattern matching
- C++: virtual methods, field initializers, base class clauses
- Java: import declarations, field declarations with modifiers
- TSX: React hooks, context providers, event handlers

Added examples and clarifying comments to existing TODO sections.
Enhanced Java query patterns for better structure capture including
lambda expressions, field declarations, and type parameters.

Signed-off-by: Eric Wheeler <[email protected]>

Author: Eric Wheeler

src/services/tree-sitter/__tests__/parseSourceCodeDefinitions.cpp.test.ts

@@ -3,22 +3,27 @@ TODO: The following C++ structures can be parsed by tree-sitter but lack query s
 
 1. Virtual Methods:
    (field_declaration (virtual) type: (primitive_type) declarator: (function_declarator))
+   Example: virtual void method() = 0;
 
 2. Default Methods:
    (default_method_clause)
+   Example: virtual ~base_class_definition() = default;
 
 3. Field Initializer Lists:
    (field_initializer_list (field_initializer))
+   Example: constructor() : field1(value1), field2(value2) {}
 
 4. Base Class Clauses:
    (base_class_clause (access_specifier) (type_identifier))
+   Example: class derived : public base {}
 
 5. Type Aliases:
    (alias_declaration name: (type_identifier) type: (type_descriptor))
+   Example: using size_type = std::size_t;
 */
 
 import { describe, it, expect, beforeAll } from "@jest/globals"
-import { debugLog, testParseSourceCodeDefinitions } from "./helpers"
+import { testParseSourceCodeDefinitions } from "./helpers"
 import { cppQuery } from "../queries"
 import sampleCppContent from "./fixtures/sample-cpp"
 

src/services/tree-sitter/__tests__/parseSourceCodeDefinitions.go.test.ts

@@ -1,3 +1,22 @@
+/*
+TODO: The following structures can be parsed by tree-sitter but lack query support:
+
+1. Anonymous Functions (func_literal):
+   (func_literal parameters: (parameter_list) body: (block ...))
+   - Currently visible in goroutine and defer statements
+   - Would enable capturing lambda/closure definitions
+
+2. Map Types (map_type):
+   (map_type key: (type_identifier) value: (interface_type))
+   - Currently visible in struct field declarations
+   - Would enable capturing map type definitions
+
+3. Pointer Types (pointer_type):
+   (pointer_type (type_identifier))
+   - Currently visible in method receiver declarations
+   - Would enable capturing pointer type definitions
+*/
+
 import { describe, it, expect, beforeAll } from "@jest/globals"
 import sampleGoContent from "./fixtures/sample-go"
 import { testParseSourceCodeDefinitions } from "./helpers"

src/services/tree-sitter/__tests__/parseSourceCodeDefinitions.java.test.ts

@@ -1,9 +1,4 @@
 import { describe, expect, it, jest, beforeAll, beforeEach } from "@jest/globals"
-import { parseSourceCodeDefinitionsForFile } from ".."
-import * as fs from "fs/promises"
-import * as path from "path"
-import { fileExistsAtPath } from "../../../utils/fs"
-import { loadRequiredLanguageParsers } from "../languageParser"
 import { javaQuery } from "../queries"
 import { testParseSourceCodeDefinitions } from "./helpers"
 import sampleJavaContent from "./fixtures/sample-java"
@@ -13,9 +8,15 @@ TODO: The following structures can be parsed by tree-sitter but lack query suppo
 
 1. Import Declarations:
    (import_declaration (scoped_identifier))
+   - Tree-sitter successfully parses import statements but no query pattern exists
+   - Example from inspect output: 'import java.util.List;'
+   - Would enable capturing package dependencies and API usage
 
 2. Field Declarations:
    (field_declaration (modifiers) type: (type_identifier) declarator: (variable_declarator))
+   - Current query pattern needs enhancement to fully capture modifier information
+   - Example from inspect output: 'private static final int count = 0;'
+   - Would improve field visibility and mutability analysis
 */
 
 // Java test options
@@ -26,20 +27,6 @@ const testOptions = {
 	extKey: "java",
 }
 
-// Mock file system operations
-jest.mock("fs/promises")
-const mockedFs = jest.mocked(fs)
-
-// Mock loadRequiredLanguageParsers
-jest.mock("../languageParser", () => ({
-	loadRequiredLanguageParsers: jest.fn(),
-}))
-
-// Mock fileExistsAtPath to return true for our test paths
-jest.mock("../../../utils/fs", () => ({
-	fileExistsAtPath: jest.fn().mockImplementation(() => Promise.resolve(true)),
-}))
-
 describe("parseSourceCodeDefinitionsForFile with Java", () => {
 	let parseResult: string = ""
 

src/services/tree-sitter/__tests__/parseSourceCodeDefinitions.python.test.ts

@@ -1,3 +1,27 @@
+/*
+TODO: The following structures can be parsed by tree-sitter but lack query support:
+
+1. String Interpolation (f-strings):
+   (string (string_start) (interpolation expression: (identifier)) (string_content) (string_end))
+   Example: f"{result}: {param3}"
+
+2. Complex Type Annotations with Generics:
+   (type (generic_type (identifier) (type_parameter (type (generic_type)))))
+   Example: dict[str, Union[List[int], Dict[str, bool], Optional[ComplexType]]]
+
+3. Multiple Context Managers in With Statements:
+   (with_clause (with_item) (with_item) (with_item))
+   Example: with (open('file1.txt') as f1, open('file2.txt') as f2)
+
+4. Pattern Matching with As-Patterns:
+   (case_pattern (as_pattern (case_pattern (class_pattern)) (identifier)))
+   Example: case {"name": str() as name, "age": int() as age}
+
+5. Nested Function Definitions with Scope Modifiers:
+   (function_definition (block (function_definition (block (nonlocal_statement) (global_statement)))))
+   Example: Nested functions with nonlocal/global declarations
+*/
+
 import { describe, expect, it, beforeAll } from "@jest/globals"
 import { testParseSourceCodeDefinitions, debugLog } from "./helpers"
 import { samplePythonContent } from "./fixtures/sample-python"

src/services/tree-sitter/__tests__/parseSourceCodeDefinitions.tsx.test.ts

@@ -1,3 +1,36 @@
+/*
+TODO: The following structures can be parsed by tree-sitter but lack query support:
+
+1. React Hooks:
+   (call_expression
+     function: (member_expression
+       object: (identifier) @react
+       property: [(property_identifier) @hook_name]))
+   - Affects useState, useEffect, useRef, useCallback, useMemo
+   - Currently visible in parse tests but no query patterns exist
+
+2. Context Providers/Consumers:
+   (jsx_element
+     open_tag: (jsx_opening_element
+       name: (member_expression
+         object: (identifier) @context
+         property: [(property_identifier) @provider
+                   (property_identifier) @consumer])))
+   - Can be parsed as JSX elements but no specific capture patterns
+
+3. React Event Handlers:
+   (arrow_function
+     parameters: (formal_parameters
+       (required_parameter
+         pattern: (identifier)
+         type: (type_annotation
+           (generic_type
+             name: (nested_type_identifier
+               module: (identifier) @react
+               name: (type_identifier) @event_type)))))
+   - Parsed but no specific patterns for React synthetic events
+*/
+
 import { describe, expect, it, jest, beforeAll } from "@jest/globals"
 import { testParseSourceCodeDefinitions, mockedFs } from "./helpers"
 import sampleTsxContent from "./fixtures/sample-tsx"

src/services/tree-sitter/queries/java.ts

@@ -52,4 +52,22 @@ export default `
   (class_body
     (class_declaration
       name: (identifier) @name.definition.static_nested_class))) @definition.static_nested_class
+
+; Lambda expressions
+(lambda_expression) @definition.lambda
+
+; Field declarations
+(field_declaration
+  (modifiers)?
+  type: (_)
+  declarator: (variable_declarator
+    name: (identifier) @name.definition.field)) @definition.field
+
+; Import declarations
+(import_declaration
+  (scoped_identifier) @name.definition.import) @definition.import
+
+; Type parameters
+(type_parameters
+  (type_parameter) @name.definition.type_parameter) @definition.type_parameter
 `