0
# JavaParser Core
1
2
JavaParser Core is a comprehensive Java parsing library that provides complete support for parsing Java source code from Java 1.0 through Java 21. It offers advanced analysis functionalities including AST generation, symbol resolution, type solving, and code transformation utilities, making it essential for code analysis tools, IDEs, static analysis frameworks, and code generation systems.
3
4
## Package Information
5
6
- **Package Name**: javaparser-core
7
- **Package Type**: maven
8
- **Group ID**: com.github.javaparser
9
- **Language**: Java
10
- **Installation**:
11
```xml
12
<dependency>
13
<groupId>com.github.javaparser</groupId>
14
<artifactId>javaparser-core</artifactId>
15
<version>3.27.0</version>
16
</dependency>
17
```
18
19
## Core Imports
20
21
```java
22
import com.github.javaparser.StaticJavaParser;
23
import com.github.javaparser.ast.CompilationUnit;
24
import com.github.javaparser.ast.Node;
25
import com.github.javaparser.ast.visitor.VoidVisitor;
26
import com.github.javaparser.ast.visitor.GenericVisitor;
27
```
28
29
## Basic Usage
30
31
```java
32
import com.github.javaparser.StaticJavaParser;
33
import com.github.javaparser.ast.CompilationUnit;
34
import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
35
36
// Parse Java source code
37
String code = """
38
public class Example {
39
public void hello() {
40
System.out.println("Hello World");
41
}
42
}
43
""";
44
45
CompilationUnit cu = StaticJavaParser.parse(code);
46
47
// Find all class declarations
48
List<ClassOrInterfaceDeclaration> classes = cu.findAll(ClassOrInterfaceDeclaration.class);
49
for (ClassOrInterfaceDeclaration cls : classes) {
50
System.out.println("Found class: " + cls.getNameAsString());
51
}
52
53
// Use visitor pattern to analyze AST
54
cu.accept(new VoidVisitorAdapter<Void>() {
55
@Override
56
public void visit(MethodDeclaration n, Void arg) {
57
System.out.println("Method: " + n.getNameAsString());
58
super.visit(n, arg);
59
}
60
}, null);
61
```
62
63
## Architecture
64
65
JavaParser Core is built around several key components:
66
67
- **Parsing Engine**: High-performance parser built with JavaCC supporting all Java language versions
68
- **AST Model**: Complete Abstract Syntax Tree representation with over 100 node types
69
- **Visitor Pattern**: Flexible traversal and analysis through GenericVisitor and VoidVisitor interfaces
70
- **Symbol Resolution**: Advanced type analysis and symbol resolution capabilities
71
- **Code Generation**: Pretty printing and various output formats (Java, XML, DOT)
72
- **Configuration System**: Comprehensive parser configuration for language levels and behavior
73
- **Metamodel**: Reflection-like API for introspecting AST structure
74
75
## Capabilities
76
77
### Core Parsing
78
79
The fundamental parsing functionality for converting Java source code into Abstract Syntax Trees. Supports all Java language constructs from Java 1.0 through Java 21.
80
81
```java { .api }
82
// Simple static parsing methods
83
public static CompilationUnit parse(String code);
84
public static CompilationUnit parse(File file) throws FileNotFoundException;
85
public static CompilationUnit parse(InputStream in);
86
87
// Expression parsing
88
public static <T extends Expression> T parseExpression(String expression);
89
public static Statement parseStatement(String statement);
90
public static Type parseType(String type);
91
```
92
93
[Core Parsing](./parsing.md)
94
95
### AST Navigation and Manipulation
96
97
Complete Abstract Syntax Tree model with navigation, search, and modification capabilities. All AST nodes extend the base Node class with common functionality.
98
99
```java { .api }
100
// Base Node functionality
101
public abstract class Node {
102
public <R, A> R accept(GenericVisitor<R, A> v, A arg);
103
public <A> void accept(VoidVisitor<A> v, A arg);
104
public <T> List<T> findAll(Class<T> clazz);
105
public Optional<Node> getParentNode();
106
public boolean replace(Node node);
107
public boolean remove();
108
public Node clone();
109
}
110
111
// Root compilation unit
112
public class CompilationUnit extends Node {
113
public NodeList<TypeDeclaration<?>> getTypes();
114
public NodeList<ImportDeclaration> getImports();
115
public Optional<PackageDeclaration> getPackageDeclaration();
116
}
117
```
118
119
[AST Navigation](./ast-navigation.md)
120
121
### Visitor Pattern
122
123
Flexible traversal and analysis of AST nodes using the visitor pattern. Supports both generic visitors that return values and void visitors for side effects.
124
125
```java { .api }
126
public interface GenericVisitor<R, A> {
127
R visit(CompilationUnit n, A arg);
128
R visit(ClassOrInterfaceDeclaration n, A arg);
129
R visit(MethodDeclaration n, A arg);
130
// ... visit methods for all AST node types
131
}
132
133
public interface VoidVisitor<A> {
134
void visit(CompilationUnit n, A arg);
135
void visit(ClassOrInterfaceDeclaration n, A arg);
136
void visit(MethodDeclaration n, A arg);
137
// ... visit methods for all AST node types
138
}
139
```
140
141
[Visitor Pattern](./visitors.md)
142
143
### Code Generation and Printing
144
145
Convert AST nodes back to formatted Java source code, XML representation, or graph visualization formats.
146
147
```java { .api }
148
public class PrettyPrinter implements ConfigurablePrinter {
149
public String print(Node node);
150
}
151
152
public class XmlPrinter {
153
public String print(Node node);
154
}
155
156
public class DotPrinter {
157
public String print(Node node);
158
}
159
```
160
161
[Code Generation](./printing.md)
162
163
### Symbol Resolution and Type Analysis
164
165
Advanced symbol resolution for resolving references to their declarations and performing type analysis.
166
167
```java { .api }
168
public interface SymbolResolver {
169
<T> T resolveDeclaration(Node node, Class<T> resultClass);
170
}
171
172
public interface TypeSolver {
173
SymbolReference<ResolvedReferenceTypeDeclaration> tryToSolveType(String name);
174
}
175
176
public class ParserConfiguration {
177
public ParserConfiguration setSymbolResolver(SymbolResolver symbolResolver);
178
}
179
```
180
181
[Symbol Resolution](./symbol-resolution.md)
182
183
### Parser Configuration
184
185
Comprehensive configuration system for controlling parsing behavior, language level support, and feature enabling.
186
187
```java { .api }
188
public class ParserConfiguration {
189
public ParserConfiguration setLanguageLevel(LanguageLevel languageLevel);
190
public ParserConfiguration setCharacterEncoding(Charset characterEncoding);
191
public ParserConfiguration setStoreTokens(boolean storeTokens);
192
public ParserConfiguration setSymbolResolver(SymbolResolver symbolResolver);
193
194
public enum LanguageLevel {
195
JAVA_1_0, JAVA_1_1, JAVA_1_2, JAVA_1_3, JAVA_1_4,
196
JAVA_5, JAVA_6, JAVA_7, JAVA_8, JAVA_9, JAVA_10,
197
JAVA_11, JAVA_12, JAVA_13, JAVA_14, JAVA_15, JAVA_16,
198
JAVA_17, JAVA_18, JAVA_19, JAVA_20, JAVA_21, CURRENT
199
}
200
}
201
```
202
203
[Parser Configuration](./configuration.md)
204
205
### AST Serialization
206
207
Convert AST nodes to and from JSON format for storage, transmission, and persistence. Enables distributed processing and analysis pipelines.
208
209
```java { .api }
210
public class JavaParserJsonSerializer {
211
public String serialize(Node node);
212
public void serialize(Node node, OutputStream out) throws IOException;
213
}
214
215
public class JavaParserJsonDeserializer {
216
public Node deserialize(String json) throws JsonProcessingException;
217
public <T extends Node> T deserialize(String json, Class<T> nodeType) throws JsonProcessingException;
218
}
219
```
220
221
[AST Serialization](./serialization.md)
222
223
## Common Types
224
225
```java { .api }
226
// Parse result with error handling
227
public class ParseResult<T> {
228
public Optional<T> getResult();
229
public List<Problem> getProblems();
230
public boolean isSuccessful();
231
}
232
233
// Position and range information
234
public class Position {
235
public int line;
236
public int column;
237
public Position(int line, int column);
238
}
239
240
public class Range {
241
public Position begin;
242
public Position end;
243
public Range(Position begin, Position end);
244
}
245
246
// Observable list for AST nodes
247
public class NodeList<T> extends ArrayList<T> implements Observable {
248
// Standard List interface plus observable functionality
249
}
250
251
// Data key for attaching metadata to nodes
252
public abstract class DataKey<T> {
253
public static <T> DataKey<T> create();
254
}
255
256
// Token range information
257
public class TokenRange {
258
public JavaToken getBegin();
259
public JavaToken getEnd();
260
}
261
262
// Java token information
263
public class JavaToken {
264
public int getKind();
265
public String getText();
266
public Optional<Range> getRange();
267
}
268
269
// Tree traversal strategies
270
public enum TreeTraversal {
271
PREORDER, POSTORDER, BREADTHFIRST, PARENTS, DIRECT_CHILDREN
272
}
273
274
// Modifier keywords
275
public enum Modifier.Keyword {
276
PUBLIC, PRIVATE, PROTECTED, STATIC, FINAL, ABSTRACT, SYNCHRONIZED,
277
NATIVE, STRICTFP, TRANSIENT, VOLATILE, DEFAULT, SEALED, NON_SEALED
278
}
279
```