javaparser

Converts Java source code into a complete Abstract Syntax Tree using a recursive descent parser that handles Java language features from version 1.0 through Java 25 including preview features. The parser generates a hierarchical node structure (CompilationUnit → ClassOrInterfaceDeclaration → MethodDeclaration, etc.) that preserves all syntactic information including comments, annotations, and modifiers. The parsing pipeline tokenizes input, applies grammar rules, and constructs typed AST nodes that can be traversed and manipulated programmatically.

Provides visitor pattern implementations (GenericVisitor, ModifierVisitor, VoidVisitor) that enable traversal and transformation of the AST without modifying the node classes themselves. The visitor pattern allows developers to define custom logic that executes on specific node types (e.g., MethodDeclaration, FieldDeclaration) as the tree is walked. ModifierVisitor enables in-place AST transformation by returning modified nodes, while VoidVisitor supports side-effect operations like analysis and reporting.

Extracts and analyzes Java annotations from AST nodes, providing access to annotation values, targets, and metadata. Developers can query annotations on classes, methods, fields, and parameters, and extract annotation values (strings, numbers, arrays, nested annotations) for use in code analysis and generation. This enables tools to leverage annotation-driven development patterns and extract configuration from annotated code.

Resolves method calls and field accesses to their definitions by analyzing method signatures, parameter types, and inheritance hierarchies to determine which overloaded method is being invoked. The resolution system handles method overloading, varargs, type erasure, and inheritance-based method lookup (including interface default methods). It returns ResolvedMethodDeclaration objects that provide access to the method's signature, return type, and declaring class.

Preserves original source formatting, whitespace, and comments during parsing and AST manipulation through a lexical preservation system that tracks token positions and associates comments with AST nodes. When the AST is modified and pretty-printed, the original formatting is maintained where possible, and comments are reattached to their corresponding code elements. This is critical for tools that need to preserve developer intent and code style during transformations.

Resolves Java symbols (types, methods, fields, variables) to their definitions across multiple compilation units using a context-based resolution system (javaparser-symbol-solver-core). The symbol solver uses type resolvers (ReflectionTypeSolver, JavaParserTypeSolver, CombinedTypeSolver) to locate symbol definitions in the classpath, source code, or runtime reflection. It performs type inference on expressions and method calls, handling generics, inheritance hierarchies, and method overloading to determine the exact symbol being referenced.

Generates Java source code from AST structures using a builder pattern API (CompilationUnitBuilder, ClassOrInterfaceBuilder, MethodBuilder, etc.) that constructs AST nodes programmatically without parsing. Developers can fluently build AST hierarchies by chaining builder methods, then pretty-print the resulting AST to Java source code. This enables code generation tools to create Java code dynamically based on templates, configurations, or runtime decisions.

Serializes parsed AST structures to JSON format and deserializes JSON back into AST objects through the javaparser-core-serialization module. This enables AST persistence, transmission over networks, and integration with tools that work with JSON representations of code structure. The serialization preserves all AST node information including types, positions, and metadata.

Converts AST structures back to formatted Java source code using a configurable pretty printer that supports custom indentation, line breaks, and spacing rules. The pretty printer traverses the AST and generates source code that respects the original formatting when lexical preservation is enabled, or applies default formatting rules otherwise. Developers can customize output through PrettyPrinterConfiguration to enforce code style standards.

Uses a metamodel specification (javaparser-core-metamodel-generator) to automatically generate AST node classes, visitor implementations, and serialization code, enabling rapid adaptation to new Java language features without manual coding. The metamodel describes the structure of each AST node type (fields, relationships, constraints), and code generators produce the corresponding Java classes, ensuring consistency and reducing maintenance burden.

Analyzes entire Java projects by parsing multiple compilation units and resolving symbols across file boundaries using a project-aware symbol solver. The JavaParserTypeSolver indexes source directories and enables symbol resolution that spans the entire codebase, allowing tools to understand cross-file dependencies, inheritance hierarchies, and method call chains. This enables project-wide refactoring and analysis without processing files in isolation.

Resolves Java generic type parameters to their concrete types through a constraint-solving system that handles type bounds, wildcards, and inheritance hierarchies. When analyzing code like `List<String>` or method calls with generic parameters, the symbol solver infers the concrete type arguments by analyzing type constraints from assignments, method signatures, and inheritance relationships. This enables accurate type information for generic code.