feat: add java tests

[vitali87]

No description provided.

[gemini-code-assist]

Summary of Changes

Hello @vitali87, I'm Gemini Code Assist¹! I'm currently reviewing this pull request and will post my feedback shortly. In the meantime, here's a summary to help you and other reviewers quickly get up to speed!

This pull request significantly expands the codebase_rag system's ability to understand and process Java code. It introduces the necessary Tree-sitter configurations and a new set of Python utilities to deeply parse Java source files, extracting detailed structural and relational information. The changes are supported by a comprehensive suite of new tests, ensuring the reliability of the Java parsing functionality across diverse language constructs. This enhancement enables more accurate and insightful analysis of Java codebases within the system.

Highlights

• Enhanced Java Parsing Configuration: New Tree-sitter queries have been integrated into language_config.py to accurately identify and parse Java functions, classes, and method calls, laying the groundwork for detailed Java code analysis.
• Comprehensive Java AST Utilities: A dedicated utility file, java_utils.py, has been introduced to provide a robust set of functions for extracting granular information from Java Abstract Syntax Trees (ASTs). This includes capabilities to parse package and import declarations, and to extract comprehensive details about classes, interfaces, enums, methods, fields, and annotations.
• Thorough Java Parsing Test Coverage: Extensive test suites have been added across three new files (test_java_comprehensive.py, test_java_imports.py, test_java_method_calls.py) to validate the accuracy and completeness of the Java parsing capabilities. These tests cover a wide array of Java features, from basic class structures and inheritance to complex generics, lambda expressions, exception handling, and various import mechanisms.

Using Gemini Code Assist

The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.

Invoking Gemini

You can request assistance from Gemini at any point in your pull request via creating an issue comment (i.e. comment on the pull request page) using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands.

Feature	Command	Description
Code Review	/gemini review	Performs a code review for the current pull request in its current state.
Pull Request Summary	/gemini summary	Provides a summary of the current pull request in its current state.
Comment	@gemini-code-assist	Responds in comments when explicitly tagged, both in issue comments and review comments.
Help	/gemini help	Displays a list of available commands.

Customization

To customize Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.

Limitations & Feedback

Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counter productive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for Github and other Google products, sign up here.

You can also get AI-powered code generation, chat, as well as code reviews directly in the IDE at no cost with the Gemini Code Assist IDE Extension.

Footnotes

1. Review the Privacy Notices, Generative AI Prohibited Use Policy, Terms of Service, and learn how to configure Gemini Code Assist in GitHub here. Gemini can make mistakes, so double check it and use code with caution. ↩

[claude]

Claude finished @vitali87's task —— View job

---

Code Review for Java Support Implementation ✅

Comprehensive code review focusing on code quality, potential bugs, performance, security, and test coverage.

Todo List

• Read repository guidelines and setup instructions
• Review language_config.py changes for Tree-sitter integration
• Review java_utils.py implementation for code quality and issues
• Review test files for coverage and quality
• Check for security concerns and performance considerations
• Provide final recommendations and feedback

Summary

This is a high-quality implementation that adds comprehensive Java support to the code-graph-rag system. The code follows established patterns and provides excellent test coverage.

Detailed Review

✅ language_config.py (Lines 212-255)

Strengths:

• Comprehensive Java node type definitions
• Well-crafted Tree-sitter queries following established patterns
• Proper handling of constructors, interfaces, enums, and annotations
• Consistent with existing language configurations

Minor Suggestion:

• Line 252-254: Consider if object_creation_expression query is too broad for constructor calls

✅ java_utils.py (490 lines)

Strengths:

• Comprehensive utility functions for Java AST parsing
• Excellent documentation with clear examples
• Proper error handling and defensive programming
• Good use of type hints and structured return types
• Safe text extraction using cached safe_decode_text

Code Quality Improvements:

1. Redundant Type Checks (Lines 139, 148, 218+):

   # Current (redundant)
   if interface_name and isinstance(info["interfaces"], list):
       info["interfaces"].append(interface_name)
   
   # Suggested (cleaner)
   if interface_name:
       info["interfaces"].append(interface_name)

2. Magic Strings (Lines 347-348):

   # Consider using constants
   DELIMITER_TOKENS = ["(", ")", ","]
   if child.type not in DELIMITER_TOKENS:

✅ Test Suite (2024 lines across 3 files)

Excellent Coverage:

• test_java_comprehensive.py: Classes, interfaces, enums, inheritance, methods
• test_java_imports.py: Regular, static, and wildcard imports
• test_java_method_calls.py: Method invocations and inheritance patterns

Test Quality:

• Realistic Java project structures
• Comprehensive assertion coverage
• Well-organized and maintainable

Security & Performance Analysis

🔒 Security: EXCELLENT

• No use of eval(), exec(), or unsafe deserialization
• All text processing uses safe UTF-8 decoding with caching
• No shell command execution or subprocess usage
• Proper input validation and defensive programming

⚡ Performance: GOOD

• Leverages existing safe_decode_text with LRU cache (@lru_cache(maxsize=10000))
• Efficient AST traversal patterns
• No obvious performance bottlenecks

Final Recommendations

✅ Approve with Minor Suggestions

1. Refactor redundant type checks in java_utils.py for cleaner code
2. Extract magic strings to constants for better maintainability
3. Consider adding edge case tests for malformed Java code

The implementation is production-ready and follows excellent software engineering practices. The comprehensive test suite gives high confidence in the functionality.

---

[gemini-code-assist]

Code Review

This pull request introduces comprehensive support for Java by adding language configurations, parsing utilities, and extensive tests. The changes are well-structured and the test coverage is impressive, spanning basic features, imports, method calls, and advanced concepts like generics and exceptions.

My review focuses on a few areas for improvement:

• Ensuring complete handling of generic types when parsing implemented interfaces.
• Maintaining consistency in how class-like structures (like annotations) are handled when building qualified names.
• Removing a couple of instances of unused code in the new tests.

Overall, this is a solid contribution that significantly expands the tool's capabilities. The suggested changes are minor and aim to improve correctness and code clarity.

[claude]

Claude finished @vitali87's task —— View job

---

Code Review for Java Support Implementation ✅

Comprehensive code review focusing on code quality, potential bugs, performance, security, and test coverage.

Todo List

• Read repository guidelines and setup instructions
• Review language_config.py changes for Tree-sitter integration
• Review java_utils.py implementation for code quality and issues
• Review test files for coverage and quality
• Check for security concerns and performance considerations
• Provide final recommendations and feedback

Summary

This is a high-quality implementation that adds comprehensive Java support to the code-graph-rag system. The code follows established patterns and provides excellent test coverage.

Detailed Review

✅ language_config.py (Lines 212-255)

Strengths:

• Comprehensive Java node type definitions
• Well-crafted Tree-sitter queries following established patterns
• Proper handling of constructors, interfaces, enums, and annotations
• Consistent with existing language configurations

Minor Suggestion:

• Line 252-254: Consider if object_creation_expression query is too broad for constructor calls

✅ java_utils.py (490 lines)

Strengths:

• Comprehensive utility functions for Java AST parsing
• Excellent documentation with clear examples
• Proper error handling and defensive programming
• Good use of type hints and structured return types
• Safe text extraction using cached safe_decode_text

Code Quality Improvements:

1. Redundant Type Checks (Lines 139, 148, 218+):

   # Current (redundant)
   if interface_name and isinstance(info["interfaces"], list):
       info["interfaces"].append(interface_name)
   
   # Suggested (cleaner)
   if interface_name:
       info["interfaces"].append(interface_name)

2. Magic Strings (Lines 347-348):

   # Consider using constants
   DELIMITER_TOKENS = ["(", ")", ","]
   if child.type not in DELIMITER_TOKENS:

✅ Test Suite (2024 lines across 3 files)

Excellent Coverage:

• test_java_comprehensive.py: Classes, interfaces, enums, inheritance, methods
• test_java_imports.py: Regular, static, and wildcard imports
• test_java_method_calls.py: Method invocations and inheritance patterns

Test Quality:

• Realistic Java project structures
• Comprehensive assertion coverage
• Well-organized and maintainable

Minor Issues (Dead Code):

• Line 295 in test_java_comprehensive.py: Unused variable assignment

Security & Performance Analysis

🔒 Security: EXCELLENT

• No use of eval(), exec(), or unsafe deserialization
• All text processing uses safe UTF-8 decoding with caching
• No shell command execution or subprocess usage
• Proper input validation and defensive programming

⚡ Performance: GOOD

• Leverages existing safe_decode_text with LRU cache (@lru_cache(maxsize=10000))
• Efficient AST traversal patterns
• No obvious performance bottlenecks

Addressing Previous Review Comments

Gemini's Suggestions:

1. ✅ Generic Interface Handling: The current implementation already handles generic_type nodes correctly (lines 144-149)
2. ✅ Annotation Support: build_java_qualified_name should include annotation_type_declaration for consistency
3. ✅ Dead Code: Confirmed unused variable assignments in test files

Final Recommendations

✅ Approve with Minor Suggestions

1. Refactor redundant type checks in java_utils.py for cleaner code
2. Extract magic strings to constants for better maintainability
3. Remove dead code in test files (line 295 in test_java_comprehensive.py)
4. Consider adding annotation_type_declaration to build_java_qualified_name function

The implementation is production-ready and follows excellent software engineering practices. The comprehensive test suite gives high confidence in the functionality.

---

[claude]

Claude finished @vitali87's task —— View job

---

Code Review for Java Support Implementation ✅

Comprehensive code review focusing on code quality, potential bugs, performance, security, and test coverage.

Todo List

• Read repository guidelines and setup instructions
• Review language_config.py changes for Tree-sitter integration
• Review java_utils.py implementation for code quality and issues
• Review test files for coverage and quality
• Check for security concerns and performance considerations
• Provide final recommendations and feedback

Summary

This is a high-quality implementation that adds comprehensive Java support to the code-graph-rag system. The code follows established patterns and provides excellent test coverage.

Detailed Review

✅ language_config.py (Lines 212-255)

Strengths:

• Comprehensive Java node type definitions
• Well-crafted Tree-sitter queries following established patterns
• Proper handling of constructors, interfaces, enums, and annotations
• Consistent with existing language configurations

Minor Suggestion:

• Line 252-254: Consider if object_creation_expression query is too broad for constructor calls

✅ java_utils.py (490 lines)

Strengths:

• Comprehensive utility functions for Java AST parsing
• Excellent documentation with clear examples
• Proper error handling and defensive programming
• Good use of type hints and structured return types
• Safe text extraction using cached safe_decode_text

Code Quality Improvements:

1. Redundant Type Checks (Lines 139, 148, 218+):

   # Current (redundant)
   if interface_name and isinstance(info["interfaces"], list):
       info["interfaces"].append(interface_name)
   
   # Suggested (cleaner)
   if interface_name:
       info["interfaces"].append(interface_name)

2. Magic Strings (Lines 347-348):

   # Consider using constants
   DELIMITER_TOKENS = ["(", ")", ","]
   if child.type not in DELIMITER_TOKENS:

✅ Test Suite (2024 lines across 3 files)

Excellent Coverage:

• test_java_comprehensive.py: Classes, interfaces, enums, inheritance, methods
• test_java_imports.py: Regular, static, and wildcard imports
• test_java_method_calls.py: Method invocations and inheritance patterns

Test Quality:

• Realistic Java project structures
• Comprehensive assertion coverage
• Well-organized and maintainable

Security & Performance Analysis

🔒 Security: EXCELLENT

• No use of eval(), exec(), or unsafe deserialization
• All text processing uses safe UTF-8 decoding with caching
• No shell command execution or subprocess usage
• Proper input validation and defensive programming

⚡ Performance: GOOD

• Leverages existing safe_decode_text with LRU cache (@lru_cache(maxsize=10000))
• Efficient AST traversal patterns
• No obvious performance bottlenecks

Final Recommendations

✅ Approve with Minor Suggestions

1. Refactor redundant type checks in java_utils.py for cleaner code
2. Extract magic strings to constants for better maintainability
3. Consider adding edge case tests for malformed Java code

The implementation is production-ready and follows excellent software engineering practices. The comprehensive test suite gives high confidence in the functionality.

---

[vitali87]

Claude finished @vitali87's task —— View job

Code Review for Java Support Implementation ✅

Comprehensive code review focusing on code quality, potential bugs, performance, security, and test coverage.

Todo List

• Read repository guidelines and setup instructions
• Review language_config.py changes for Tree-sitter integration
• Review java_utils.py implementation for code quality and issues
• Review test files for coverage and quality
• Check for security concerns and performance considerations
• Provide final recommendations and feedback

Summary

This is a high-quality implementation that adds comprehensive Java support to the code-graph-rag system. The code follows established patterns and provides excellent test coverage.

Detailed Review

✅ language_config.py (Lines 212-255)

Strengths:

• Comprehensive Java node type definitions
• Well-crafted Tree-sitter queries following established patterns
• Proper handling of constructors, interfaces, enums, and annotations
• Consistent with existing language configurations

Minor Suggestion:

• Line 252-254: Consider if object_creation_expression query is too broad for constructor calls

✅ java_utils.py (490 lines)

Strengths:

• Comprehensive utility functions for Java AST parsing
• Excellent documentation with clear examples
• Proper error handling and defensive programming
• Good use of type hints and structured return types
• Safe text extraction using cached safe_decode_text

Code Quality Improvements:

1. Redundant Type Checks (Lines 139, 148, 218+):

   # Current (redundant)
   if interface_name and isinstance(info["interfaces"], list):
       info["interfaces"].append(interface_name)
   
   # Suggested (cleaner)
   if interface_name:
       info["interfaces"].append(interface_name)

2. Magic Strings (Lines 347-348):

   # Consider using constants
   DELIMITER_TOKENS = ["(", ")", ","]
   if child.type not in DELIMITER_TOKENS:

✅ Test Suite (2024 lines across 3 files)

Excellent Coverage:

• test_java_comprehensive.py: Classes, interfaces, enums, inheritance, methods
• test_java_imports.py: Regular, static, and wildcard imports
• test_java_method_calls.py: Method invocations and inheritance patterns

Test Quality:

• Realistic Java project structures
• Comprehensive assertion coverage
• Well-organized and maintainable

Security & Performance Analysis

🔒 Security: EXCELLENT

• No use of eval(), exec(), or unsafe deserialization
• All text processing uses safe UTF-8 decoding with caching
• No shell command execution or subprocess usage
• Proper input validation and defensive programming

⚡ Performance: GOOD

• Leverages existing safe_decode_text with LRU cache (@lru_cache(maxsize=10000))
• Efficient AST traversal patterns
• No obvious performance bottlenecks

Final Recommendations

✅ Approve with Minor Suggestions

1. Refactor redundant type checks in java_utils.py for cleaner code
2. Extract magic strings to constants for better maintainability
3. Consider adding edge case tests for malformed Java code

The implementation is production-ready and follows excellent software engineering practices. The comprehensive test suite gives high confidence in the functionality.

@claude address magic string issue.

[claude]

Claude finished @vitali87's task —— View job

---

Magic String Issue Fixed ✅

Successfully addressed the magic string issue identified in the code review.

Todo List

• Read java_utils.py to locate magic string usage
• Extract delimiter tokens to named constants
• Update code to use constants instead of hardcoded strings
• Commit and push changes to PR branch

Changes Made

Added constant definition at the top of java_utils.py:

# Constants for delimiter tokens used in argument parsing
DELIMITER_TOKENS = ["(", ")", ","]

Updated two functions to use the constant:

• extract_java_method_call_info() (line 361): Replaced ["(", ")", ","] with DELIMITER_TOKENS
• extract_java_annotation_info() (line 504): Replaced ["(", ")", ","] with DELIMITER_TOKENS

This improves code maintainability by centralizing the delimiter token definitions and makes the code more readable. If delimiter logic needs to be updated in the future, it can be done in one place.

Commit: 95cae46 - "refactor: extract magic strings to named constants in java_utils.py"

---

[vitali87]

/gemini review

[gemini-code-assist]

Code Review

This pull request significantly enhances Java language support by adding a comprehensive suite of tests covering various language features, from basic OOP to modern constructs and real-world patterns. The introduction of java_utils.py provides a solid foundation for parsing Java code, and the updates to language_config.py and parsers/utils.py correctly integrate this new functionality.

My review has identified one area for improvement in the new Java parser utilities to ensure it correctly handles all field declaration scenarios. Overall, this is an excellent contribution that greatly improves the project's test coverage and capabilities for Java.

[claude]

Claude encountered an error —— View job

---

I'll analyze this and get back to you.

[vitali87]

/gemini review

[gemini-code-assist]

Code Review

This pull request introduces significant enhancements for Java language support, including a new type inference engine, detailed parsing utilities, and an exceptionally comprehensive test suite covering advanced OOP, concurrency, modern features, and real-world patterns. The changes to the language configuration and call processing are solid. However, the new JavaTypeInferenceEngine has several critical methods that are currently stubbed out, which will prevent it from functioning correctly. Additionally, there are a couple of areas in the utility and inference logic that need refinement to handle variable shadowing and method identification correctly. Overall, this is a fantastic contribution that greatly expands the tool's capabilities for Java once the identified issues are addressed.

[vitali87]

/gemini review

[gemini-code-assist]

Code Review

This pull request introduces a significant and impressive enhancement for Java language support by adding a comprehensive type inference engine and improving call resolution. The changes are well-structured, with new modules for Java-specific logic (java_type_inference.py, java_utils.py) and a massive suite of new tests that cover many advanced and edge-case scenarios. The move to specific Tree-sitter queries for Java is a great improvement for parsing accuracy. I've identified a few potential issues in the new type inference engine, including a bug in path resolution for flatter project structures and some incomplete logic that should be addressed to further improve robustness. Overall, this is a fantastic contribution that greatly improves Java parsing capabilities.

[gemini-code-assist]

Code Review

This pull request introduces significant new functionality for parsing Java code, including a dedicated type inference engine and comprehensive test suites. The overall approach is solid, but the PR title is a bit misleading as it's a major feature addition, not just adding tests. I've identified a critical circular dependency issue that needs to be addressed, along with a few other opportunities for improving code structure and maintainability. Specifically, the new java_type_inference.py file is quite large and could benefit from being broken down into smaller modules.

[vitali87]

/gemini review

[gemini-code-assist]

Acknowledged. I am initiating a new comprehensive code review for the pull request. This may take a few moments.

[vitali87]

/gemini review

[gemini-code-assist]

Code Review

This pull request introduces comprehensive support for parsing and analyzing Java code. It adds a new JavaTypeInferenceEngine, utility functions for Java AST traversal, and integrates this new logic into the existing processing pipeline. The changes also include a large suite of tests for various Java features, which is excellent.

My review focuses on the new implementation details. I've found a few areas for improvement, primarily related to method resolution for overloaded and inherited methods in the new type inference engine. There are also a couple of minor maintainability suggestions. Overall, this is a significant and well-structured feature addition.

[vitali87]

/gemini review

[gemini-code-assist]

Code Review

This pull request introduces comprehensive support for Java, including advanced parsing for various language constructs, a new type inference engine, and an extensive test suite. The changes are well-structured and significantly enhance the tool's capabilities. My review focuses on a few potential issues in the new type inference logic that could affect the accuracy of call and field resolution for imported or fully qualified types, and a minor code cleanup.