or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

ast-navigation.mdconfiguration.mdindex.mdparsing.mdprinting.mdserialization.mdsymbol-resolution.mdvisitors.md
tile.json

tessl/maven-com-github-javaparser--javaparser-core

A comprehensive Java parsing library providing complete support for parsing Java source code from Java 1.0 through Java 21 with advanced analysis functionalities.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/com.github.javaparser/javaparser-core@3.27.x

To install, run

npx @tessl/cli install tessl/maven-com-github-javaparser--javaparser-core@3.27.0

index.mddocs/

JavaParser Core

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.

Package Information

  • Package Name: javaparser-core
  • Package Type: maven
  • Group ID: com.github.javaparser
  • Language: Java
  • Installation: 
    <dependency>
    <groupId>com.github.javaparser</groupId>
    <artifactId>javaparser-core</artifactId>
    <version>3.27.0</version>
</dependency>

Core Imports

import com.github.javaparser.StaticJavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.Node;
import com.github.javaparser.ast.visitor.VoidVisitor;
import com.github.javaparser.ast.visitor.GenericVisitor;

Basic Usage

import com.github.javaparser.StaticJavaParser;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;

// Parse Java source code
String code = """
    public class Example {
        public void hello() {
            System.out.println("Hello World");
        }
    }
    """;

CompilationUnit cu = StaticJavaParser.parse(code);

// Find all class declarations
List<ClassOrInterfaceDeclaration> classes = cu.findAll(ClassOrInterfaceDeclaration.class);
for (ClassOrInterfaceDeclaration cls : classes) {
    System.out.println("Found class: " + cls.getNameAsString());
}

// Use visitor pattern to analyze AST
cu.accept(new VoidVisitorAdapter<Void>() {
    @Override
    public void visit(MethodDeclaration n, Void arg) {
        System.out.println("Method: " + n.getNameAsString());
        super.visit(n, arg);
    }
}, null);

Architecture

JavaParser Core is built around several key components:

  • Parsing Engine: High-performance parser built with JavaCC supporting all Java language versions
  • AST Model: Complete Abstract Syntax Tree representation with over 100 node types
  • Visitor Pattern: Flexible traversal and analysis through GenericVisitor and VoidVisitor interfaces
  • Symbol Resolution: Advanced type analysis and symbol resolution capabilities
  • Code Generation: Pretty printing and various output formats (Java, XML, DOT)
  • Configuration System: Comprehensive parser configuration for language levels and behavior
  • Metamodel: Reflection-like API for introspecting AST structure

Capabilities

Core Parsing

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.

// Simple static parsing methods
public static CompilationUnit parse(String code);
public static CompilationUnit parse(File file) throws FileNotFoundException;
public static CompilationUnit parse(InputStream in);

// Expression parsing
public static <T extends Expression> T parseExpression(String expression);
public static Statement parseStatement(String statement);
public static Type parseType(String type);

Core Parsing

AST Navigation and Manipulation

Complete Abstract Syntax Tree model with navigation, search, and modification capabilities. All AST nodes extend the base Node class with common functionality.

// Base Node functionality
public abstract class Node {
    public <R, A> R accept(GenericVisitor<R, A> v, A arg);
    public <A> void accept(VoidVisitor<A> v, A arg);
    public <T> List<T> findAll(Class<T> clazz);
    public Optional<Node> getParentNode();
    public boolean replace(Node node);
    public boolean remove();
    public Node clone();
}

// Root compilation unit
public class CompilationUnit extends Node {
    public NodeList<TypeDeclaration<?>> getTypes();
    public NodeList<ImportDeclaration> getImports();
    public Optional<PackageDeclaration> getPackageDeclaration();
}

AST Navigation

Visitor Pattern

Flexible traversal and analysis of AST nodes using the visitor pattern. Supports both generic visitors that return values and void visitors for side effects.

public interface GenericVisitor<R, A> {
    R visit(CompilationUnit n, A arg);
    R visit(ClassOrInterfaceDeclaration n, A arg);
    R visit(MethodDeclaration n, A arg);
    // ... visit methods for all AST node types
}

public interface VoidVisitor<A> {
    void visit(CompilationUnit n, A arg);
    void visit(ClassOrInterfaceDeclaration n, A arg);
    void visit(MethodDeclaration n, A arg);
    // ... visit methods for all AST node types
}

Visitor Pattern

Code Generation and Printing

Convert AST nodes back to formatted Java source code, XML representation, or graph visualization formats.

public class PrettyPrinter implements ConfigurablePrinter {
    public String print(Node node);
}

public class XmlPrinter {
    public String print(Node node);
}

public class DotPrinter {
    public String print(Node node);
}

Code Generation

Symbol Resolution and Type Analysis

Advanced symbol resolution for resolving references to their declarations and performing type analysis.

public interface SymbolResolver {
    <T> T resolveDeclaration(Node node, Class<T> resultClass);
}

public interface TypeSolver {
    SymbolReference<ResolvedReferenceTypeDeclaration> tryToSolveType(String name);
}

public class ParserConfiguration {
    public ParserConfiguration setSymbolResolver(SymbolResolver symbolResolver);
}

Symbol Resolution

Parser Configuration

Comprehensive configuration system for controlling parsing behavior, language level support, and feature enabling.

public class ParserConfiguration {
    public ParserConfiguration setLanguageLevel(LanguageLevel languageLevel);
    public ParserConfiguration setCharacterEncoding(Charset characterEncoding);
    public ParserConfiguration setStoreTokens(boolean storeTokens);
    public ParserConfiguration setSymbolResolver(SymbolResolver symbolResolver);
    
    public enum LanguageLevel {
        JAVA_1_0, JAVA_1_1, JAVA_1_2, JAVA_1_3, JAVA_1_4,
        JAVA_5, JAVA_6, JAVA_7, JAVA_8, JAVA_9, JAVA_10,
        JAVA_11, JAVA_12, JAVA_13, JAVA_14, JAVA_15, JAVA_16,
        JAVA_17, JAVA_18, JAVA_19, JAVA_20, JAVA_21, CURRENT
    }
}

Parser Configuration

AST Serialization

Convert AST nodes to and from JSON format for storage, transmission, and persistence. Enables distributed processing and analysis pipelines.

public class JavaParserJsonSerializer {
    public String serialize(Node node);
    public void serialize(Node node, OutputStream out) throws IOException;
}

public class JavaParserJsonDeserializer {
    public Node deserialize(String json) throws JsonProcessingException;
    public <T extends Node> T deserialize(String json, Class<T> nodeType) throws JsonProcessingException;
}

AST Serialization

Common Types

// Parse result with error handling
public class ParseResult<T> {
    public Optional<T> getResult();
    public List<Problem> getProblems();
    public boolean isSuccessful();
}

// Position and range information
public class Position {
    public int line;
    public int column;
    public Position(int line, int column);
}

public class Range {
    public Position begin;
    public Position end;
    public Range(Position begin, Position end);
}

// Observable list for AST nodes
public class NodeList<T> extends ArrayList<T> implements Observable {
    // Standard List interface plus observable functionality
}

// Data key for attaching metadata to nodes
public abstract class DataKey<T> {
    public static <T> DataKey<T> create();
}

// Token range information
public class TokenRange {
    public JavaToken getBegin();
    public JavaToken getEnd();
}

// Java token information
public class JavaToken {
    public int getKind();
    public String getText();
    public Optional<Range> getRange();
}

// Tree traversal strategies
public enum TreeTraversal {
    PREORDER, POSTORDER, BREADTHFIRST, PARENTS, DIRECT_CHILDREN
}

// Modifier keywords
public enum Modifier.Keyword {
    PUBLIC, PRIVATE, PROTECTED, STATIC, FINAL, ABSTRACT, SYNCHRONIZED,
    NATIVE, STRICTFP, TRANSIENT, VOLATILE, DEFAULT, SEALED, NON_SEALED
}