Core Parsing

/**
 * Parse a complete Java source file from string
 * @param code Java source code to parse
 * @return CompilationUnit representing the parsed code
 * @throws ParseProblemException if parsing fails
 */
public static CompilationUnit parse(String code);

/**
 * Parse a complete Java source file from File
 * @param file File containing Java source code
 * @return CompilationUnit representing the parsed code
 * @throws FileNotFoundException if file doesn't exist
 * @throws ParseProblemException if parsing fails
 */
public static CompilationUnit parse(File file) throws FileNotFoundException;

/**
 * Parse a complete Java source file from InputStream
 * @param in InputStream containing Java source code
 * @return CompilationUnit representing the parsed code
 * @throws ParseProblemException if parsing fails
 */
public static CompilationUnit parse(InputStream in);

/**
 * Parse Java source file from InputStream with encoding
 * @param in InputStream containing Java source code
 * @param encoding Character encoding of the source
 * @return CompilationUnit representing the parsed code
 * @throws ParseProblemException if parsing fails
 */
public static CompilationUnit parse(InputStream in, Charset encoding);

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

// Parse from string
String code = "public class Hello { public void world() {} }";
CompilationUnit cu = StaticJavaParser.parse(code);

// Parse from file
File javaFile = new File("Example.java");
CompilationUnit cu2 = StaticJavaParser.parse(javaFile);

// Parse from classpath resource
InputStream is = getClass().getResourceAsStream("/Example.java");
CompilationUnit cu3 = StaticJavaParser.parse(is);

/**
 * Parse a Java expression
 * @param expression String containing Java expression
 * @return Expression AST node
 * @throws ParseProblemException if parsing fails
 */
public static <T extends Expression> T parseExpression(String expression);

/**
 * Parse a Java statement
 * @param statement String containing Java statement
 * @return Statement AST node
 * @throws ParseProblemException if parsing fails
 */
public static Statement parseStatement(String statement);

/**
 * Parse a block statement
 * @param blockStatement String containing Java block statement
 * @return BlockStmt AST node
 * @throws ParseProblemException if parsing fails
 */
public static BlockStmt parseBlock(String blockStatement);

/**
 * Parse an import declaration
 * @param importDeclaration String containing import statement
 * @return ImportDeclaration AST node
 * @throws ParseProblemException if parsing fails
 */
public static ImportDeclaration parseImport(String importDeclaration);

// Parse expressions
BinaryExpr expr = StaticJavaParser.parseExpression("x + y * 2");
MethodCallExpr call = StaticJavaParser.parseExpression("obj.method(arg1, arg2)");
ObjectCreationExpr creation = StaticJavaParser.parseExpression("new ArrayList<>()");

// Parse statements
IfStmt ifStmt = StaticJavaParser.parseStatement("if (x > 0) return x;");
ForStmt forLoop = StaticJavaParser.parseStatement("for (int i = 0; i < 10; i++) {}");

// Parse blocks
BlockStmt block = StaticJavaParser.parseBlock("{ int x = 5; return x * 2; }");

// Parse imports
ImportDeclaration imp = StaticJavaParser.parseImport("import java.util.List;");

/**
 * Parse a Java type
 * @param type String containing type declaration
 * @return Type AST node
 * @throws ParseProblemException if parsing fails
 */
public static Type parseType(String type);

/**
 * Parse a class or interface type
 * @param type String containing class/interface type
 * @return ClassOrInterfaceType AST node
 * @throws ParseProblemException if parsing fails
 */
public static ClassOrInterfaceType parseClassOrInterfaceType(String type);

/**
 * Parse a method declaration
 * @param methodDeclaration String containing method declaration
 * @return MethodDeclaration AST node
 * @throws ParseProblemException if parsing fails
 */
public static MethodDeclaration parseMethodDeclaration(String methodDeclaration);

/**
 * Parse a method parameter
 * @param parameter String containing parameter declaration
 * @return Parameter AST node
 * @throws ParseProblemException if parsing fails
 */
public static Parameter parseParameter(String parameter);

/**
 * Parse a type declaration (class, interface, enum, annotation)
 * @param typeDeclaration String containing type declaration
 * @return TypeDeclaration AST node
 * @throws ParseProblemException if parsing fails
 */
public static TypeDeclaration<?> parseTypeDeclaration(String typeDeclaration);

// Parse types
PrimitiveType intType = StaticJavaParser.parseType("int");
ClassOrInterfaceType listType = StaticJavaParser.parseType("List<String>");
ArrayType arrayType = StaticJavaParser.parseType("String[]");

// Parse method declarations
MethodDeclaration method = StaticJavaParser.parseMethodDeclaration(
    "public String getName() { return name; }"
);

// Parse parameters
Parameter param = StaticJavaParser.parseParameter("final String name");

// Parse class declarations
ClassOrInterfaceDeclaration cls = StaticJavaParser.parseTypeDeclaration(
    "public class Example { private String field; }"
);

/**
 * JavaParser with configurable behavior
 */
public final class JavaParser {
    public JavaParser();
    public JavaParser(ParserConfiguration configuration);
    
    /**
     * Parse with error handling
     * @param code Java source code to parse
     * @return ParseResult with result and any problems
     */
    public ParseResult<CompilationUnit> parse(String code);
    
    /**
     * Parse expression with error handling
     * @param expression Java expression to parse
     * @return ParseResult with result and any problems
     */
    public <T extends Expression> ParseResult<T> parseExpression(String expression);
    
    /**
     * Parse statement with error handling
     * @param statement Java statement to parse
     * @return ParseResult with result and any problems
     */
    public ParseResult<Statement> parseStatement(String statement);
}

/**
 * Result of parsing operation with error information
 */
public class ParseResult<T> {
    /**
     * Get parsing result if successful
     * @return Optional containing result, empty if parsing failed
     */
    public Optional<T> getResult();
    
    /**
     * Get list of parsing problems/errors
     * @return List of problems encountered during parsing
     */
    public List<Problem> getProblems();
    
    /**
     * Check if parsing was successful
     * @return true if parsing succeeded without errors
     */
    public boolean isSuccessful();
}

import com.github.javaparser.JavaParser;
import com.github.javaparser.ParseResult;

JavaParser parser = new JavaParser();

// Parse with error handling
ParseResult<CompilationUnit> result = parser.parse("invalid java code");
if (result.isSuccessful()) {
    CompilationUnit cu = result.getResult().get();
    // Process successful parse
} else {
    List<Problem> problems = result.getProblems();
    for (Problem problem : problems) {
        System.err.println("Parse error: " + problem.getMessage());
    }
}

/**
 * Parse from classpath resource
 * @param path Classpath resource path
 * @return CompilationUnit representing the parsed code
 * @throws IOException if resource cannot be read
 * @throws ParseProblemException if parsing fails
 */
public static CompilationUnit parseResource(String path) throws IOException;

/**
 * Parse from classpath resource with encoding
 * @param path Classpath resource path
 * @param encoding Character encoding
 * @return CompilationUnit representing the parsed code
 * @throws IOException if resource cannot be read
 * @throws ParseProblemException if parsing fails
 */
public static CompilationUnit parseResource(String path, Charset encoding) throws IOException;

/**
 * Parse from file system path
 * @param path Path to Java source file
 * @return CompilationUnit representing the parsed code  
 * @throws IOException if file cannot be read
 * @throws ParseProblemException if parsing fails
 */
public static CompilationUnit parse(Path path) throws IOException;

/**
 * Parse from file system path with encoding
 * @param path Path to Java source file
 * @param encoding Character encoding
 * @return CompilationUnit representing the parsed code
 * @throws IOException if file cannot be read
 * @throws ParseProblemException if parsing fails
 */
public static CompilationUnit parse(Path path, Charset encoding) throws IOException;

import java.nio.file.Paths;
import java.nio.charset.StandardCharsets;

// Parse from classpath
CompilationUnit cu1 = StaticJavaParser.parseResource("/com/example/Example.java");

// Parse from file system
Path sourcePath = Paths.get("src/main/java/Example.java");
CompilationUnit cu2 = StaticJavaParser.parse(sourcePath);

// Parse with specific encoding
CompilationUnit cu3 = StaticJavaParser.parse(sourcePath, StandardCharsets.UTF_8);

/**
 * Parse an annotation expression
 * @param annotation String containing annotation
 * @return AnnotationExpr AST node
 * @throws ParseProblemException if parsing fails
 */
public static AnnotationExpr parseAnnotation(String annotation);

/**
 * Parse annotation body declaration (fields or methods)
 * @param body String containing annotation body declaration
 * @return BodyDeclaration AST node
 * @throws ParseProblemException if parsing fails
 */
public static BodyDeclaration<?> parseAnnotationBodyDeclaration(String body);

/**
 * Parse class or interface body declaration
 * @param body String containing body declaration
 * @return BodyDeclaration AST node
 * @throws ParseProblemException if parsing fails
 */
public static BodyDeclaration<?> parseBodyDeclaration(String body);

/**
 * Parse variable declaration expression
 * @param declaration String containing variable declaration
 * @return VariableDeclarationExpr AST node
 * @throws ParseProblemException if parsing fails
 */
public static VariableDeclarationExpr parseVariableDeclarationExpr(String declaration);

/**
 * Parse Javadoc content
 * @param content String containing Javadoc content
 * @return Javadoc AST node
 * @throws ParseProblemException if parsing fails
 */
public static Javadoc parseJavadoc(String content);

/**
 * Parse explicit constructor invocation (super/this calls)
 * @param statement String containing constructor invocation
 * @return ExplicitConstructorInvocationStmt AST node
 * @throws ParseProblemException if parsing fails
 */
public static ExplicitConstructorInvocationStmt parseExplicitConstructorInvocationStmt(String statement);

/**
 * Parse qualified name
 * @param qualifiedName String containing qualified name
 * @return Name AST node
 * @throws ParseProblemException if parsing fails
 */
public static Name parseName(String qualifiedName);

/**
 * Parse simple name
 * @param name String containing simple name
 * @return SimpleName AST node
 * @throws ParseProblemException if parsing fails
 */
public static SimpleName parseSimpleName(String name);

/**
 * Parse package declaration
 * @param packageDeclaration String containing package declaration
 * @return PackageDeclaration AST node
 * @throws ParseProblemException if parsing fails
 */
public static PackageDeclaration parsePackageDeclaration(String packageDeclaration);

/**
 * Parse module declaration (Java 9+)
 * @param moduleDeclaration String containing module declaration
 * @return ModuleDeclaration AST node
 * @throws ParseProblemException if parsing fails
 */
public static ModuleDeclaration parseModuleDeclaration(String moduleDeclaration);

/**
 * Parse module directive (Java 9+)
 * @param moduleDirective String containing module directive
 * @return ModuleDirective AST node
 * @throws ParseProblemException if parsing fails
 */
public static ModuleDirective parseModuleDirective(String moduleDirective);

/**
 * Parse type parameter
 * @param typeParameter String containing type parameter
 * @return TypeParameter AST node
 * @throws ParseProblemException if parsing fails
 */
public static TypeParameter parseTypeParameter(String typeParameter);

/**
 * Parse array initializer expression
 * @param arrayInitializerExpr String containing array initializer
 * @return ArrayInitializerExpr AST node
 * @throws ParseProblemException if parsing fails
 */
public static ArrayInitializerExpr parseArrayInitializerExpr(String arrayInitializerExpr);

// Parse annotations
AnnotationExpr annotation = StaticJavaParser.parseAnnotation("@Override");
AnnotationExpr paramAnnotation = StaticJavaParser.parseAnnotation("@NotNull(\"parameter cannot be null\")");

// Parse Javadoc
Javadoc javadoc = StaticJavaParser.parseJavadoc("This is a sample method\n@param x the input parameter\n@return the result");

// Parse module declarations
ModuleDeclaration module = StaticJavaParser.parseModuleDeclaration("module com.example { requires java.base; }");

// Parse type parameters
TypeParameter typeParam = StaticJavaParser.parseTypeParameter("T extends Comparable<T>");

// Parse variable declarations
VariableDeclarationExpr varDecl = StaticJavaParser.parseVariableDeclarationExpr("final String name = \"example\"");

/**
 * Exception thrown when parsing fails
 */
public class ParseProblemException extends RuntimeException {
    public List<Problem> getProblems();
}

/**
 * Individual parsing problem
 */
public class Problem {
    public String getMessage();
    public Optional<TokenRange> getLocation();
    public Problem.ProblemType getType();
    
    public enum ProblemType {
        ERROR, WARNING
    }
}