@futpib/parser 1.0.4 → 1.0.6

package/build/javaParser.js

@@ -0,0 +1,1538 @@
+import { setParserName } from './parser.js';
+import { unescapeJavaString } from './stringEscapes.js';
+import { createUnionParser } from './unionParser.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+import { createDisjunctionParser } from './disjunctionParser.js';
+import { createArrayParser } from './arrayParser.js';
+import { createOptionalParser } from './optionalParser.js';
+import { createRegExpParser } from './regexpParser.js';
+import { createSeparatedNonEmptyArrayParser } from './separatedNonEmptyArrayParser.js';
+import { createObjectParser } from './objectParser.js';
+// Whitespace (spaces, tabs, newlines)
+const javaWhitespaceParser = promiseCompose(createRegExpParser(/\s+/), match => match[0]);
+const javaOptionalWhitespaceParser = promiseCompose(createRegExpParser(/\s*/), match => match[0]);
+// Line comment: // ...
+const javaLineCommentParser = promiseCompose(createRegExpParser(/\/\/[^\n]*/), match => match[0]);
+// Block comment: /* ... */
+// TODO: proper nested comment handling if needed
+const javaBlockCommentParser = promiseCompose(createRegExpParser(/\/\*[\s\S]*?\*\//), match => match[0]);
+// Comment (line or block)
+const javaCommentParser = createUnionParser([
+    javaLineCommentParser,
+    javaBlockCommentParser,
+]);
+// Whitespace or comment
+const javaWhitespaceOrCommentParser = createUnionParser([
+    javaWhitespaceParser,
+    javaCommentParser,
+]);
+// Optional whitespace/comments (skippable)
+const javaSkippableParser = createArrayParser(javaWhitespaceOrCommentParser);
+// Identifier: valid Java identifier
+const javaIdentifierParser = promiseCompose(createRegExpParser(/[a-zA-Z_$][a-zA-Z0-9_$]*/), match => match[0]);
+setParserName(javaIdentifierParser, 'javaIdentifierParser');
+// SimpleName: single identifier wrapped in SimpleName node
+const javaSimpleNameParser = createObjectParser({
+    type: 'SimpleName',
+    identifier: javaIdentifierParser,
+});
+setParserName(javaSimpleNameParser, 'javaSimpleNameParser');
+// Name: qualified name as nested structure (e.g., com.example.Foo)
+// Result is { type: 'Name', identifier: 'Foo', qualifier: { type: 'Name', identifier: 'example', qualifier: { type: 'Name', identifier: 'com' } } }
+const javaNameParser = promiseCompose(createSeparatedNonEmptyArrayParser(javaIdentifierParser, promiseCompose(createTupleParser([
+    javaOptionalWhitespaceParser,
+    createExactSequenceParser('.'),
+    javaOptionalWhitespaceParser,
+]), () => '.')), parts => {
+    // Build nested Name structure from left to right
+    // parts = ['com', 'example', 'Foo'] -> nested with 'Foo' at top
+    let result = { type: 'Name', identifier: parts[0] };
+    for (let i = 1; i < parts.length; i++) {
+        result = { type: 'Name', identifier: parts[i], qualifier: result };
+    }
+    return result;
+});
+setParserName(javaNameParser, 'javaNameParser');
+// Qualified name: com.example.Foo (legacy format with flat parts array)
+const javaQualifiedNameParser = promiseCompose(createSeparatedNonEmptyArrayParser(javaIdentifierParser, promiseCompose(createTupleParser([
+    javaOptionalWhitespaceParser,
+    createExactSequenceParser('.'),
+    javaOptionalWhitespaceParser,
+]), () => '.')), parts => ({ parts }));
+setParserName(javaQualifiedNameParser, 'javaQualifiedNameParser');
+const javaAnnotationParser = createObjectParser({
+    _at: createExactSequenceParser('@'),
+    type: 'MarkerAnnotationExpr',
+    name: javaNameParser,
+});
+setParserName(javaAnnotationParser, 'javaAnnotationParser');
+// Annotations with trailing whitespace
+const javaAnnotationsParser = createArrayParser(promiseCompose(createTupleParser([
+    javaAnnotationParser,
+    javaSkippableParser,
+]), ([annotation]) => annotation));
+const javaPackageDeclarationParserNew = createObjectParser({
+    annotations: javaAnnotationsParser,
+    _package: createExactSequenceParser('package'),
+    _ws1: javaWhitespaceParser,
+    type: 'PackageDeclaration',
+    name: javaNameParser,
+    _ws2: javaOptionalWhitespaceParser,
+    _semi: createExactSequenceParser(';'),
+});
+// Legacy package declaration parser (still using old annotation format)
+const javaPackageDeclarationParser = promiseCompose(createTupleParser([
+    javaAnnotationsParser,
+    createExactSequenceParser('package'),
+    javaWhitespaceParser,
+    javaQualifiedNameParser,
+    javaOptionalWhitespaceParser,
+    createExactSequenceParser(';'),
+]), ([annotations, , , name]) => ({ annotations, name }));
+setParserName(javaPackageDeclarationParser, 'javaPackageDeclarationParser');
+// Import declaration: import [static] com.example.Foo[.*];
+const javaImportDeclarationParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('import'),
+    javaWhitespaceParser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        createExactSequenceParser('static'),
+        javaWhitespaceParser,
+    ]), () => true)),
+    javaNameParser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        javaOptionalWhitespaceParser,
+        createExactSequenceParser('.'),
+        javaOptionalWhitespaceParser,
+        createExactSequenceParser('*'),
+    ]), () => true)),
+    javaOptionalWhitespaceParser,
+    createExactSequenceParser(';'),
+]), ([, , isStatic, name, isAsterisk]) => ({
+    type: 'ImportDeclaration',
+    isStatic: isStatic ?? false,
+    isAsterisk: isAsterisk ?? false,
+    name,
+}));
+setParserName(javaImportDeclarationParser, 'javaImportDeclarationParser');
+// Modifier keywords
+const javaModifierKeywordParser = createDisjunctionParser([
+    promiseCompose(createExactSequenceParser('public'), () => 'PUBLIC'),
+    promiseCompose(createExactSequenceParser('protected'), () => 'PROTECTED'),
+    promiseCompose(createExactSequenceParser('private'), () => 'PRIVATE'),
+    promiseCompose(createExactSequenceParser('static'), () => 'STATIC'),
+    promiseCompose(createExactSequenceParser('final'), () => 'FINAL'),
+    promiseCompose(createExactSequenceParser('abstract'), () => 'ABSTRACT'),
+    promiseCompose(createExactSequenceParser('synchronized'), () => 'SYNCHRONIZED'),
+    promiseCompose(createExactSequenceParser('native'), () => 'NATIVE'),
+    promiseCompose(createExactSequenceParser('transient'), () => 'TRANSIENT'),
+    promiseCompose(createExactSequenceParser('volatile'), () => 'VOLATILE'),
+    promiseCompose(createExactSequenceParser('strictfp'), () => 'STRICTFP'),
+    promiseCompose(createExactSequenceParser('default'), () => 'DEFAULT'),
+    promiseCompose(createExactSequenceParser('sealed'), () => 'SEALED'),
+    promiseCompose(createExactSequenceParser('non-sealed'), () => 'NON_SEALED'),
+]);
+const javaModifierParser = createObjectParser({
+    type: 'Modifier',
+    keyword: javaModifierKeywordParser,
+});
+setParserName(javaModifierParser, 'javaModifierParser');
+const javaPrimitiveTypeParser = createDisjunctionParser([
+    promiseCompose(createExactSequenceParser('boolean'), () => ({ type: 'PrimitiveType', type_: 'BOOLEAN', annotations: [] })),
+    promiseCompose(createExactSequenceParser('byte'), () => ({ type: 'PrimitiveType', type_: 'BYTE', annotations: [] })),
+    promiseCompose(createExactSequenceParser('char'), () => ({ type: 'PrimitiveType', type_: 'CHAR', annotations: [] })),
+    promiseCompose(createExactSequenceParser('double'), () => ({ type: 'PrimitiveType', type_: 'DOUBLE', annotations: [] })),
+    promiseCompose(createExactSequenceParser('float'), () => ({ type: 'PrimitiveType', type_: 'FLOAT', annotations: [] })),
+    promiseCompose(createExactSequenceParser('int'), () => ({ type: 'PrimitiveType', type_: 'INT', annotations: [] })),
+    promiseCompose(createExactSequenceParser('long'), () => ({ type: 'PrimitiveType', type_: 'LONG', annotations: [] })),
+    promiseCompose(createExactSequenceParser('short'), () => ({ type: 'PrimitiveType', type_: 'SHORT', annotations: [] })),
+]);
+setParserName(javaPrimitiveTypeParser, 'javaPrimitiveTypeParser');
+const javaVoidTypeParser = createObjectParser({
+    _void: createExactSequenceParser('void'),
+    type: 'VoidType',
+    annotations: [],
+});
+setParserName(javaVoidTypeParser, 'javaVoidTypeParser');
+// Forward declaration for recursive type parsing
+let javaTypeParser;
+const javaWildcardTypeParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('?'),
+    javaSkippableParser,
+    createOptionalParser(createUnionParser([
+        promiseCompose(createTupleParser([
+            createExactSequenceParser('extends'),
+            javaSkippableParser,
+            (ctx) => javaTypeParser(ctx),
+        ]), ([, , type]) => ({ extendedType: type })),
+        promiseCompose(createTupleParser([
+            createExactSequenceParser('super'),
+            javaSkippableParser,
+            (ctx) => javaTypeParser(ctx),
+        ]), ([, , type]) => ({ superType: type })),
+    ])),
+]), ([, , bounds]) => ({
+    type: 'WildcardType',
+    annotations: [],
+    ...(bounds ?? {}),
+}));
+setParserName(javaWildcardTypeParser, 'javaWildcardTypeParser');
+// Type argument: either a type or a wildcard
+const javaTypeArgumentParser = createUnionParser([
+    javaWildcardTypeParser,
+    (ctx) => javaTypeParser(ctx),
+]);
+setParserName(javaTypeArgumentParser, 'javaTypeArgumentParser');
+// Type arguments: <T, U, V> or <?, ? extends Foo>
+const javaTypeArgumentsParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('<'),
+    javaSkippableParser,
+    createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        javaTypeArgumentParser,
+        javaSkippableParser,
+    ]), ([type]) => type), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        javaSkippableParser,
+    ]), () => ',')),
+    javaSkippableParser,
+    createExactSequenceParser('>'),
+]), ([, , types]) => types);
+setParserName(javaTypeArgumentsParser, 'javaTypeArgumentsParser');
+const javaTypeParameterParser = promiseCompose(createTupleParser([
+    javaSimpleNameParser,
+    javaSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        createExactSequenceParser('extends'),
+        javaSkippableParser,
+        createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+            (ctx) => javaTypeParser(ctx),
+            javaSkippableParser,
+        ]), ([type]) => type), promiseCompose(createTupleParser([
+            createExactSequenceParser('&'),
+            javaSkippableParser,
+        ]), () => '&')),
+    ]), ([, , bounds]) => bounds)),
+]), ([name, , typeBound]) => ({
+    type: 'TypeParameter',
+    annotations: [], // TODO: parse type parameter annotations
+    name,
+    typeBound: typeBound ?? [],
+}));
+setParserName(javaTypeParameterParser, 'javaTypeParameterParser');
+// Type parameters: <T>, <T, U>, <T extends Foo>
+const javaTypeParametersParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('<'),
+    javaSkippableParser,
+    createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        javaTypeParameterParser,
+        javaSkippableParser,
+    ]), ([param]) => param), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        javaSkippableParser,
+    ]), () => ',')),
+    javaSkippableParser,
+    createExactSequenceParser('>'),
+]), ([, , params]) => params);
+setParserName(javaTypeParametersParser, 'javaTypeParametersParser');
+// ClassOrInterfaceType: Foo, List<T>, Outer.Inner, Map<K, V>
+// Forward declaration for recursive scope
+let javaClassOrInterfaceTypeParser;
+// Parser for a single type segment (name with optional type arguments)
+const javaTypeSegmentParser = promiseCompose(createTupleParser([
+    javaSimpleNameParser,
+    javaSkippableParser,
+    createOptionalParser(javaTypeArgumentsParser),
+]), ([name, , typeArguments]) => ({
+    name,
+    ...(typeArguments ? { typeArguments } : {}),
+}));
+setParserName(javaTypeSegmentParser, 'javaTypeSegmentParser');
+// Full ClassOrInterfaceType with optional scope: Outer.Inner or just Foo
+javaClassOrInterfaceTypeParser = promiseCompose(createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+    javaTypeSegmentParser,
+    javaSkippableParser,
+]), ([segment]) => segment), promiseCompose(createTupleParser([
+    createExactSequenceParser('.'),
+    javaSkippableParser,
+]), () => '.')), (segments) => {
+    // Build the type from segments: [Outer, Inner] -> { scope: Outer, name: Inner }
+    let result;
+    for (const segment of segments) {
+        if (result === undefined) {
+            result = {
+                type: 'ClassOrInterfaceType',
+                name: segment.name,
+                ...(segment.typeArguments ? { typeArguments: segment.typeArguments } : {}),
+                annotations: [],
+            };
+        }
+        else {
+            result = {
+                type: 'ClassOrInterfaceType',
+                scope: result,
+                name: segment.name,
+                ...(segment.typeArguments ? { typeArguments: segment.typeArguments } : {}),
+                annotations: [],
+            };
+        }
+    }
+    return result;
+});
+setParserName(javaClassOrInterfaceTypeParser, 'javaClassOrInterfaceTypeParser');
+// Base type (without array brackets)
+const javaBaseTypeParser = createDisjunctionParser([
+    javaPrimitiveTypeParser,
+    javaVoidTypeParser,
+    javaClassOrInterfaceTypeParser,
+]);
+// Array brackets
+const javaArrayBracketsParser = createArrayParser(promiseCompose(createTupleParser([
+    javaSkippableParser,
+    createExactSequenceParser('['),
+    javaSkippableParser,
+    createExactSequenceParser(']'),
+]), () => []));
+// Full type with optional array brackets
+javaTypeParser = promiseCompose(createTupleParser([
+    javaBaseTypeParser,
+    javaArrayBracketsParser,
+]), ([baseType, brackets]) => {
+    let result = baseType;
+    for (const _ of brackets) {
+        result = {
+            type: 'ArrayType',
+            componentType: result,
+            origin: 'TYPE',
+            annotations: [],
+        };
+    }
+    return result;
+});
+setParserName(javaTypeParser, 'javaTypeParser');
+// Modifiers with trailing whitespace
+const javaModifiersParser = createArrayParser(promiseCompose(createTupleParser([
+    javaModifierParser,
+    javaSkippableParser,
+]), ([modifier]) => modifier));
+// Skip balanced braces (for skipping method/block bodies)
+const javaSkipBalancedBracesParser = promiseCompose(createRegExpParser(/\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\}/), match => match[0]);
+const javaParameterParser = promiseCompose(createTupleParser([
+    javaAnnotationsParser,
+    javaModifiersParser,
+    javaTypeParser,
+    javaSkippableParser,
+    createOptionalParser(createExactSequenceParser('...')), // varargs
+    javaSkippableParser,
+    javaSimpleNameParser,
+]), ([annotations, modifiers, type_, , varArgs, , name]) => ({
+    type: 'Parameter',
+    modifiers,
+    annotations,
+    type_,
+    isVarArgs: varArgs !== undefined,
+    varArgsAnnotations: [],
+    name,
+}));
+setParserName(javaParameterParser, 'javaParameterParser');
+// Parameter list: (param1, param2, ...)
+const javaParameterListParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('('),
+    javaSkippableParser,
+    createOptionalParser(createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        javaParameterParser,
+        javaSkippableParser,
+    ]), ([param]) => param), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        javaSkippableParser,
+    ]), () => ','))),
+    javaSkippableParser,
+    createExactSequenceParser(')'),
+]), ([, , params]) => params ?? []);
+setParserName(javaParameterListParser, 'javaParameterListParser');
+// Throws clause: throws Exception1, Exception2
+const javaThrowsClauseParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('throws'),
+    javaWhitespaceParser,
+    createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        javaClassOrInterfaceTypeParser,
+        javaSkippableParser,
+    ]), ([type]) => type), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        javaSkippableParser,
+    ]), () => ',')),
+]), ([, , types]) => types);
+setParserName(javaThrowsClauseParser, 'javaThrowsClauseParser');
+// Implements clause: implements Interface1, Interface2
+const javaImplementsClauseParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('implements'),
+    javaWhitespaceParser,
+    createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        javaClassOrInterfaceTypeParser,
+        javaSkippableParser,
+    ]), ([type]) => type), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        javaSkippableParser,
+    ]), () => ',')),
+]), ([, , types]) => types);
+setParserName(javaImplementsClauseParser, 'javaImplementsClauseParser');
+// Extends clause: extends Parent
+const javaExtendsClauseParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('extends'),
+    javaWhitespaceParser,
+    createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        javaClassOrInterfaceTypeParser,
+        javaSkippableParser,
+    ]), ([type]) => type), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        javaSkippableParser,
+    ]), () => ',')),
+]), ([, , types]) => types);
+setParserName(javaExtendsClauseParser, 'javaExtendsClauseParser');
+// Forward declaration - will be defined after expression parsers
+let javaStatementParser;
+let javaBlockStmtParserWithStatements;
+// Simple block parser that skips content (used during initial parsing)
+const javaBlockStmtParser = createObjectParser({
+    _content: javaSkipBalancedBracesParser,
+    type: 'BlockStmt',
+    statements: [], // Will be replaced by javaBlockStmtParserWithStatements
+});
+setParserName(javaBlockStmtParser, 'javaBlockStmtParser');
+const javaMethodDeclarationParser = promiseCompose(createTupleParser([
+    javaAnnotationsParser,
+    javaModifiersParser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        javaTypeParametersParser,
+        javaSkippableParser,
+    ]), ([params]) => params)),
+    javaTypeParser,
+    javaSkippableParser,
+    javaSimpleNameParser,
+    javaSkippableParser,
+    javaParameterListParser,
+    javaSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        javaThrowsClauseParser,
+        javaSkippableParser,
+    ]), ([throws]) => throws)),
+    createUnionParser([
+        (ctx) => javaBlockStmtParserWithStatements(ctx),
+        promiseCompose(createExactSequenceParser(';'), () => undefined),
+    ]),
+]), ([annotations, modifiers, typeParameters, type_, , name, , parameters, , thrownExceptions, body]) => ({
+    type: 'MethodDeclaration',
+    modifiers,
+    annotations,
+    typeParameters: typeParameters ?? [],
+    type_,
+    name,
+    parameters,
+    thrownExceptions: thrownExceptions ?? [],
+    ...(body ? { body } : {}),
+}));
+setParserName(javaMethodDeclarationParser, 'javaMethodDeclarationParser');
+// Expression parsers
+// Forward declaration for recursive expression parsing
+let javaExpressionParser;
+const javaNameExprParser = createObjectParser({
+    type: 'NameExpr',
+    name: javaSimpleNameParser,
+});
+setParserName(javaNameExprParser, 'javaNameExprParser');
+const javaStringLiteralExprParser = promiseCompose(createRegExpParser(/"(?:[^"\\]|\\.)*"/), match => ({
+    type: 'StringLiteralExpr',
+    value: unescapeJavaString(match[0].slice(1, -1)),
+}));
+setParserName(javaStringLiteralExprParser, 'javaStringLiteralExprParser');
+const javaIntegerLiteralExprParser = promiseCompose(createRegExpParser(/(?:0x[0-9a-fA-F]+|0b[01]+|0[0-7]*|[1-9][0-9]*)[lL]?/), match => ({
+    type: 'IntegerLiteralExpr',
+    value: match[0],
+}));
+setParserName(javaIntegerLiteralExprParser, 'javaIntegerLiteralExprParser');
+const javaNullLiteralExprParser = createObjectParser({
+    _null: createExactSequenceParser('null'),
+    type: 'NullLiteralExpr',
+});
+setParserName(javaNullLiteralExprParser, 'javaNullLiteralExprParser');
+const javaBooleanLiteralExprParser = createUnionParser([
+    promiseCompose(createExactSequenceParser('true'), () => ({ type: 'BooleanLiteralExpr', value: true })),
+    promiseCompose(createExactSequenceParser('false'), () => ({ type: 'BooleanLiteralExpr', value: false })),
+]);
+setParserName(javaBooleanLiteralExprParser, 'javaBooleanLiteralExprParser');
+const javaTypeExprParser = createObjectParser({
+    type: 'TypeExpr',
+    type_: javaClassOrInterfaceTypeParser,
+});
+setParserName(javaTypeExprParser, 'javaTypeExprParser');
+const javaMethodReferenceExprParser = createObjectParser({
+    type: 'MethodReferenceExpr',
+    scope: javaTypeExprParser,
+    _ws1: javaSkippableParser,
+    _colons: createExactSequenceParser('::'),
+    _ws2: javaSkippableParser,
+    identifier: javaIdentifierParser,
+});
+setParserName(javaMethodReferenceExprParser, 'javaMethodReferenceExprParser');
+// Argument list: (arg1, arg2, ...)
+const javaArgumentListParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('('),
+    javaSkippableParser,
+    createOptionalParser(createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        (ctx) => javaExpressionParser(ctx),
+        javaSkippableParser,
+    ]), ([expr]) => expr), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        javaSkippableParser,
+    ]), () => ','))),
+    javaSkippableParser,
+    createExactSequenceParser(')'),
+]), ([, , args]) => args ?? []);
+setParserName(javaArgumentListParser, 'javaArgumentListParser');
+// Simple method call without scope: foo(args)
+const javaSimpleMethodCallExprParser = createObjectParser({
+    type: 'MethodCallExpr',
+    name: javaSimpleNameParser,
+    _ws1: javaSkippableParser,
+    arguments: javaArgumentListParser,
+});
+setParserName(javaSimpleMethodCallExprParser, 'javaSimpleMethodCallExprParser');
+// ObjectCreationExpr: new ClassName(args) or new ClassName<>(args) (diamond)
+const javaObjectCreationExprParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('new'),
+    javaWhitespaceParser, // Must have whitespace after 'new' to avoid matching 'newFoo()' as method call
+    javaClassOrInterfaceTypeParser,
+    javaSkippableParser,
+    // Optional diamond operator <>
+    createOptionalParser(promiseCompose(createTupleParser([
+        createExactSequenceParser('<'),
+        javaSkippableParser,
+        createExactSequenceParser('>'),
+        javaSkippableParser,
+    ]), () => true)),
+    javaArgumentListParser,
+]), ([, , type_, , diamond, args]) => ({
+    type: 'ObjectCreationExpr',
+    type_: diamond ? {
+        ...type_,
+        typeArguments: [], // Diamond means empty type arguments
+    } : type_,
+    arguments: args,
+}));
+setParserName(javaObjectCreationExprParser, 'javaObjectCreationExprParser');
+const javaThisExprParser = createObjectParser({
+    _this: createExactSequenceParser('this'),
+    type: 'ThisExpr',
+});
+setParserName(javaThisExprParser, 'javaThisExprParser');
+// Forward declaration - will be defined later after primary expressions
+let javaCastExprParser;
+const javaEnclosedExprParser = createObjectParser({
+    _open: createExactSequenceParser('('),
+    _ws1: javaSkippableParser,
+    type: 'EnclosedExpr',
+    inner: (ctx) => javaExpressionParser(ctx),
+    _ws2: javaSkippableParser,
+    _close: createExactSequenceParser(')'),
+});
+setParserName(javaEnclosedExprParser, 'javaEnclosedExprParser');
+// Lambda parameter (can be just identifier or Type identifier)
+const javaLambdaParameterParser = promiseCompose(createTupleParser([
+    createOptionalParser(promiseCompose(createTupleParser([
+        javaTypeParser,
+        javaWhitespaceParser,
+    ]), ([type_]) => type_)),
+    javaSimpleNameParser,
+]), ([type_, name]) => ({
+    type: 'Parameter',
+    annotations: [],
+    modifiers: [],
+    isVarArgs: false,
+    varArgsAnnotations: [],
+    name,
+    type_: type_ ?? { type: 'UnknownType', annotations: [] },
+}));
+setParserName(javaLambdaParameterParser, 'javaLambdaParameterParser');
+// Lambda expression: (params) -> body or x -> body
+// LambdaExpr with parenthesized parameters
+const javaLambdaWithParensParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('('),
+    javaSkippableParser,
+    createOptionalParser(createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        javaLambdaParameterParser,
+        javaSkippableParser,
+    ]), ([param]) => param), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        javaSkippableParser,
+    ]), () => ','))),
+    createExactSequenceParser(')'),
+    javaSkippableParser,
+    createExactSequenceParser('->'),
+    javaSkippableParser,
+    createDisjunctionParser([
+        (ctx) => javaBlockStmtParserWithStatements(ctx), // Block body
+        (ctx) => javaExpressionParser(ctx), // Expression body
+    ]),
+]), ([, , params, , , , , body]) => ({
+    type: 'LambdaExpr',
+    parameters: params ?? [],
+    // Wrap expression body in ExpressionStmt to match javaparser format
+    body: body && typeof body === 'object' && 'type' in body && body.type === 'BlockStmt'
+        ? body
+        : { type: 'ExpressionStmt', expression: body },
+    isEnclosingParameters: true,
+}));
+setParserName(javaLambdaWithParensParser, 'javaLambdaWithParensParser');
+// Lambda with single identifier parameter (no parens): x -> body
+const javaLambdaSingleParamParser = promiseCompose(createTupleParser([
+    javaSimpleNameParser,
+    javaSkippableParser,
+    createExactSequenceParser('->'),
+    javaSkippableParser,
+    createDisjunctionParser([
+        (ctx) => javaBlockStmtParserWithStatements(ctx), // Block body
+        (ctx) => javaExpressionParser(ctx), // Expression body
+    ]),
+]), ([param, , , , body]) => ({
+    type: 'LambdaExpr',
+    parameters: [{
+            type: 'Parameter',
+            annotations: [],
+            modifiers: [],
+            isVarArgs: false,
+            varArgsAnnotations: [],
+            name: param,
+            type_: { type: 'UnknownType', annotations: [] },
+        }],
+    // Wrap expression body in ExpressionStmt to match javaparser format
+    body: body && typeof body === 'object' && 'type' in body && body.type === 'BlockStmt'
+        ? body
+        : { type: 'ExpressionStmt', expression: body },
+    isEnclosingParameters: false,
+}));
+setParserName(javaLambdaSingleParamParser, 'javaLambdaSingleParamParser');
+// Primary expression (without method calls chained)
+const javaPrimaryExprParser = createDisjunctionParser([
+    javaStringLiteralExprParser,
+    javaIntegerLiteralExprParser,
+    javaNullLiteralExprParser,
+    javaBooleanLiteralExprParser,
+    javaThisExprParser, // this - must come before NameExpr
+    javaObjectCreationExprParser, // new Foo() - must come before NameExpr
+    javaMethodReferenceExprParser,
+    javaSimpleMethodCallExprParser, // foo() - must come before NameExpr
+    (ctx) => javaCastExprParser(ctx), // Cast - must come before enclosed
+    javaLambdaWithParensParser, // (x, y) -> expr - must come before enclosed
+    javaEnclosedExprParser, // (expr) - parenthesized expressions
+    javaLambdaSingleParamParser, // x -> expr - must come before NameExpr
+    javaNameExprParser, // Must be last since it matches any identifier
+]);
+setParserName(javaPrimaryExprParser, 'javaPrimaryExprParser');
+// Helper to convert a NameExpr to a ClassOrInterfaceType for ClassExpr
+function nameExprToType(expr) {
+    if (expr && typeof expr === 'object' && 'type' in expr) {
+        if (expr.type === 'NameExpr') {
+            const nameExpr = expr;
+            return {
+                type: 'ClassOrInterfaceType',
+                name: nameExpr.name,
+                annotations: [],
+            };
+        }
+        if (expr.type === 'FieldAccessExpr') {
+            const fieldAccess = expr;
+            return {
+                type: 'ClassOrInterfaceType',
+                scope: nameExprToType(fieldAccess.scope),
+                name: fieldAccess.name,
+                annotations: [],
+            };
+        }
+    }
+    return expr;
+}
+// Expression with optional member access chain: expr.field, expr.method(args), expr::method, expr[index]
+const javaMemberAccessExprParser = promiseCompose(createTupleParser([
+    javaPrimaryExprParser,
+    createArrayParser(createDisjunctionParser([
+        // Method reference: ::identifier
+        promiseCompose(createTupleParser([
+            javaSkippableParser,
+            createExactSequenceParser('::'),
+            javaSkippableParser,
+            javaIdentifierParser,
+        ]), ([, , , identifier]) => ({ type: 'methodReference', identifier })),
+        // Array access: [index]
+        promiseCompose(createTupleParser([
+            javaSkippableParser,
+            createExactSequenceParser('['),
+            javaSkippableParser,
+            (ctx) => javaExpressionParser(ctx),
+            javaSkippableParser,
+            createExactSequenceParser(']'),
+        ]), ([, , , index]) => ({ type: 'arrayAccess', index })),
+        // Class literal: .class
+        promiseCompose(createTupleParser([
+            javaSkippableParser,
+            createExactSequenceParser('.'),
+            javaSkippableParser,
+            createExactSequenceParser('class'),
+        ]), () => ({ type: 'classLiteral' })),
+        // Field access or method call: .name[(args)]
+        promiseCompose(createTupleParser([
+            javaSkippableParser,
+            createExactSequenceParser('.'),
+            javaSkippableParser,
+            javaSimpleNameParser,
+            javaSkippableParser,
+            createOptionalParser(javaArgumentListParser),
+        ]), ([, , , name, , args]) => ({ type: 'member', name, arguments: args })),
+    ])),
+]), ([primary, members]) => {
+    let result = primary;
+    for (const member of members) {
+        if (member.type === 'methodReference') {
+            result = {
+                type: 'MethodReferenceExpr',
+                scope: result,
+                identifier: member.identifier,
+            };
+        }
+        else if (member.type === 'arrayAccess') {
+            result = {
+                type: 'ArrayAccessExpr',
+                name: result,
+                index: member.index,
+            };
+        }
+        else if (member.type === 'classLiteral') {
+            // Convert the scope to a type for ClassExpr
+            result = {
+                type: 'ClassExpr',
+                type_: nameExprToType(result),
+            };
+        }
+        else if (member.arguments !== undefined) {
+            result = {
+                type: 'MethodCallExpr',
+                scope: result,
+                name: member.name,
+                arguments: member.arguments,
+            };
+        }
+        else {
+            result = {
+                type: 'FieldAccessExpr',
+                scope: result,
+                name: member.name,
+            };
+        }
+    }
+    return result;
+});
+setParserName(javaMemberAccessExprParser, 'javaMemberAccessExprParser');
+// Postfix expression: expr++ or expr--
+const javaPostfixExprParser = promiseCompose(createTupleParser([
+    javaMemberAccessExprParser,
+    createOptionalParser(createDisjunctionParser([
+        promiseCompose(createExactSequenceParser('++'), () => 'POSTFIX_INCREMENT'),
+        promiseCompose(createExactSequenceParser('--'), () => 'POSTFIX_DECREMENT'),
+    ])),
+]), ([expr, operator]) => {
+    if (operator) {
+        return {
+            type: 'UnaryExpr',
+            operator,
+            expression: expr,
+        };
+    }
+    return expr;
+});
+setParserName(javaPostfixExprParser, 'javaPostfixExprParser');
+// Define cast expression: (Type) expr
+javaCastExprParser = createObjectParser({
+    _open: createExactSequenceParser('('),
+    _ws1: javaSkippableParser,
+    type: 'CastExpr',
+    type_: javaTypeParser,
+    _ws2: javaSkippableParser,
+    _close: createExactSequenceParser(')'),
+    _ws3: javaSkippableParser,
+    expression: javaMemberAccessExprParser,
+});
+setParserName(javaCastExprParser, 'javaCastExprParser');
+const javaUnaryExprParser = createDisjunctionParser([
+    // Pre-increment/decrement: ++x, --x
+    promiseCompose(createTupleParser([
+        createDisjunctionParser([
+            promiseCompose(createExactSequenceParser('++'), () => 'PREFIX_INCREMENT'),
+            promiseCompose(createExactSequenceParser('--'), () => 'PREFIX_DECREMENT'),
+        ]),
+        javaSkippableParser,
+        (ctx) => javaUnaryExprParser(ctx),
+    ]), ([operator, , expression]) => ({
+        type: 'UnaryExpr',
+        operator,
+        expression,
+    })),
+    // Unary minus, plus, not
+    promiseCompose(createTupleParser([
+        createDisjunctionParser([
+            promiseCompose(createExactSequenceParser('-'), () => 'MINUS'),
+            promiseCompose(createExactSequenceParser('+'), () => 'PLUS'),
+            promiseCompose(createExactSequenceParser('!'), () => 'LOGICAL_COMPLEMENT'),
+        ]),
+        javaSkippableParser,
+        (ctx) => javaUnaryExprParser(ctx), // Recursive for --x, !!x, etc.
+    ]), ([operator, , expression]) => ({
+        type: 'UnaryExpr',
+        operator,
+        expression,
+    })),
+    // Non-unary (postfix/primary/member access)
+    javaPostfixExprParser,
+]);
+setParserName(javaUnaryExprParser, 'javaUnaryExprParser');
+// Multiplicative operator (*, /, %)
+const javaMultiplicativeOperatorParser = createDisjunctionParser([
+    promiseCompose(createExactSequenceParser('*'), () => 'MULTIPLY'),
+    promiseCompose(createExactSequenceParser('/'), () => 'DIVIDE'),
+    promiseCompose(createExactSequenceParser('%'), () => 'REMAINDER'),
+]);
+// Multiplicative expression
+const javaMultiplicativeExprParser = promiseCompose(createTupleParser([
+    javaUnaryExprParser,
+    createArrayParser(promiseCompose(createTupleParser([
+        javaSkippableParser,
+        javaMultiplicativeOperatorParser,
+        javaSkippableParser,
+        javaUnaryExprParser,
+    ]), ([, operator, , right]) => ({ operator, right }))),
+]), ([left, operations]) => {
+    let result = left;
+    for (const op of operations) {
+        result = {
+            type: 'BinaryExpr',
+            left: result,
+            right: op.right,
+            operator: op.operator,
+        };
+    }
+    return result;
+});
+setParserName(javaMultiplicativeExprParser, 'javaMultiplicativeExprParser');
+// Additive operator (+, -)
+const javaAdditiveOperatorParser = createDisjunctionParser([
+    promiseCompose(createExactSequenceParser('+'), () => 'PLUS'),
+    promiseCompose(createExactSequenceParser('-'), () => 'MINUS'),
+]);
+// Additive expression (handles string concatenation and arithmetic)
+const javaAdditiveExprParser = promiseCompose(createTupleParser([
+    javaMultiplicativeExprParser,
+    createArrayParser(promiseCompose(createTupleParser([
+        javaSkippableParser,
+        javaAdditiveOperatorParser,
+        javaSkippableParser,
+        javaUnaryExprParser,
+    ]), ([, operator, , right]) => ({ operator, right }))),
+]), ([left, operations]) => {
+    let result = left;
+    for (const op of operations) {
+        result = {
+            type: 'BinaryExpr',
+            left: result,
+            right: op.right,
+            operator: op.operator,
+        };
+    }
+    return result;
+});
+setParserName(javaAdditiveExprParser, 'javaAdditiveExprParser');
+// Relational expression with instanceof
+const javaRelationalExprParser = promiseCompose(createTupleParser([
+    javaAdditiveExprParser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        javaSkippableParser,
+        createExactSequenceParser('instanceof'),
+        javaWhitespaceParser,
+        javaTypeParser,
+    ]), ([, , , type_]) => ({ type: 'instanceof', type_ }))),
+]), ([expr, instanceOf]) => {
+    if (instanceOf) {
+        return {
+            type: 'InstanceOfExpr',
+            expression: expr,
+            type_: instanceOf.type_,
+        };
+    }
+    return expr;
+});
+setParserName(javaRelationalExprParser, 'javaRelationalExprParser');
+// Comparison operator
+const javaComparisonOperatorParser = createDisjunctionParser([
+    promiseCompose(createExactSequenceParser('<='), () => 'LESS_EQUALS'),
+    promiseCompose(createExactSequenceParser('>='), () => 'GREATER_EQUALS'),
+    promiseCompose(createExactSequenceParser('=='), () => 'EQUALS'),
+    promiseCompose(createExactSequenceParser('!='), () => 'NOT_EQUALS'),
+    promiseCompose(createExactSequenceParser('<'), () => 'LESS'),
+    promiseCompose(createExactSequenceParser('>'), () => 'GREATER'),
+]);
+// Comparison expression (relational and equality)
+const javaComparisonExprParser = promiseCompose(createTupleParser([
+    javaRelationalExprParser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        javaSkippableParser,
+        javaComparisonOperatorParser,
+        javaSkippableParser,
+        javaRelationalExprParser,
+    ]), ([, operator, , right]) => ({ operator, right }))),
+]), ([left, comparison]) => {
+    if (comparison) {
+        return {
+            type: 'BinaryExpr',
+            left,
+            right: comparison.right,
+            operator: comparison.operator,
+        };
+    }
+    return left;
+});
+setParserName(javaComparisonExprParser, 'javaComparisonExprParser');
+// Logical AND expression
+const javaLogicalAndExprParser = promiseCompose(createTupleParser([
+    javaComparisonExprParser,
+    createArrayParser(promiseCompose(createTupleParser([
+        javaSkippableParser,
+        createExactSequenceParser('&&'),
+        javaSkippableParser,
+        javaComparisonExprParser,
+    ]), ([, , , right]) => right)),
+]), ([left, rights]) => {
+    let result = left;
+    for (const right of rights) {
+        result = {
+            type: 'BinaryExpr',
+            left: result,
+            right,
+            operator: 'AND',
+        };
+    }
+    return result;
+});
+setParserName(javaLogicalAndExprParser, 'javaLogicalAndExprParser');
+// Logical OR expression
+const javaLogicalOrExprParser = promiseCompose(createTupleParser([
+    javaLogicalAndExprParser,
+    createArrayParser(promiseCompose(createTupleParser([
+        javaSkippableParser,
+        createExactSequenceParser('||'),
+        javaSkippableParser,
+        javaLogicalAndExprParser,
+    ]), ([, , , right]) => right)),
+]), ([left, rights]) => {
+    let result = left;
+    for (const right of rights) {
+        result = {
+            type: 'BinaryExpr',
+            left: result,
+            right,
+            operator: 'OR',
+        };
+    }
+    return result;
+});
+setParserName(javaLogicalOrExprParser, 'javaLogicalOrExprParser');
+const javaTernaryExprParser = promiseCompose(createTupleParser([
+    javaLogicalOrExprParser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        javaSkippableParser,
+        createExactSequenceParser('?'),
+        javaSkippableParser,
+        (ctx) => javaTernaryExprParser(ctx), // thenExpr can be another ternary
+        javaSkippableParser,
+        createExactSequenceParser(':'),
+        javaSkippableParser,
+        (ctx) => javaTernaryExprParser(ctx), // elseExpr can be another ternary
+    ]), ([, , , thenExpr, , , , elseExpr]) => ({ thenExpr, elseExpr }))),
+]), ([condition, ternary]) => {
+    if (ternary) {
+        return {
+            type: 'ConditionalExpr',
+            condition,
+            thenExpr: ternary.thenExpr,
+            elseExpr: ternary.elseExpr,
+        };
+    }
+    return condition;
+});
+setParserName(javaTernaryExprParser, 'javaTernaryExprParser');
+// Assignment operator
+const javaAssignOperatorParser = createDisjunctionParser([
+    promiseCompose(createExactSequenceParser('='), () => 'ASSIGN'),
+    promiseCompose(createExactSequenceParser('+='), () => 'PLUS'),
+    promiseCompose(createExactSequenceParser('-='), () => 'MINUS'),
+    promiseCompose(createExactSequenceParser('*='), () => 'MULTIPLY'),
+    promiseCompose(createExactSequenceParser('/='), () => 'DIVIDE'),
+]);
+// Expression with optional assignment
+javaExpressionParser = promiseCompose(createTupleParser([
+    javaTernaryExprParser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        javaSkippableParser,
+        javaAssignOperatorParser,
+        javaSkippableParser,
+        (ctx) => javaExpressionParser(ctx), // Recursive for chained assignment
+    ]), ([, operator, , value]) => ({ operator, value }))),
+]), ([target, assignment]) => {
+    if (assignment) {
+        return {
+            type: 'AssignExpr',
+            target,
+            value: assignment.value,
+            operator: assignment.operator,
+        };
+    }
+    return target;
+});
+setParserName(javaExpressionParser, 'javaExpressionParser');
+// Skip balanced expression (fallback for complex initializers we can't parse yet)
+const javaSkipInitializerParser = createObjectParser({
+    _content: createRegExpParser(/[^,;{}]+/),
+    type: 'UnparsedExpr',
+});
+// Expression parser with fallback
+const javaInitializerExprParser = createDisjunctionParser([
+    javaExpressionParser,
+    javaSkipInitializerParser,
+]);
+const javaReturnStmtParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('return'),
+    javaSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        javaExpressionParser,
+        javaSkippableParser,
+    ]), ([expr]) => expr)),
+    createExactSequenceParser(';'),
+]), ([, , expression]) => ({
+    type: 'ReturnStmt',
+    ...(expression ? { expression } : {}),
+}));
+setParserName(javaReturnStmtParser, 'javaReturnStmtParser');
+const javaThrowStmtParser = createObjectParser({
+    _throw: createExactSequenceParser('throw'),
+    _ws1: javaSkippableParser,
+    type: 'ThrowStmt',
+    expression: javaExpressionParser,
+    _ws2: javaSkippableParser,
+    _semi: createExactSequenceParser(';'),
+});
+setParserName(javaThrowStmtParser, 'javaThrowStmtParser');
+const javaExpressionStmtParser = createObjectParser({
+    type: 'ExpressionStmt',
+    expression: javaExpressionParser,
+    _ws1: javaSkippableParser,
+    _semi: createExactSequenceParser(';'),
+});
+setParserName(javaExpressionStmtParser, 'javaExpressionStmtParser');
+const javaIfStmtParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('if'),
+    javaSkippableParser,
+    createExactSequenceParser('('),
+    javaSkippableParser,
+    javaExpressionParser,
+    javaSkippableParser,
+    createExactSequenceParser(')'),
+    javaSkippableParser,
+    (ctx) => javaStatementParser(ctx),
+    createOptionalParser(promiseCompose(createTupleParser([
+        javaSkippableParser,
+        createExactSequenceParser('else'),
+        javaSkippableParser,
+        (ctx) => javaStatementParser(ctx),
+    ]), ([, , , elseStmt]) => elseStmt)),
+]), ([, , , , condition, , , , thenStmt, elseStmt]) => ({
+    type: 'IfStmt',
+    condition,
+    thenStmt,
+    ...(elseStmt ? { elseStmt } : {}),
+}));
+setParserName(javaIfStmtParser, 'javaIfStmtParser');
+// Define the block statement parser with actual statements
+javaBlockStmtParserWithStatements = createObjectParser({
+    _open: createExactSequenceParser('{'),
+    _ws1: javaSkippableParser,
+    type: 'BlockStmt',
+    statements: createArrayParser(promiseCompose(createTupleParser([
+        (ctx) => javaStatementParser(ctx),
+        javaSkippableParser,
+    ]), ([stmt]) => stmt)),
+    _close: createExactSequenceParser('}'),
+});
+setParserName(javaBlockStmtParserWithStatements, 'javaBlockStmtParserWithStatements');
+const javaVariableDeclarationExprParser = promiseCompose(createTupleParser([
+    javaAnnotationsParser,
+    javaModifiersParser,
+    javaTypeParser,
+    javaSkippableParser,
+    createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        javaSimpleNameParser,
+        javaSkippableParser,
+        createOptionalParser(promiseCompose(createTupleParser([
+            createExactSequenceParser('='),
+            javaSkippableParser,
+            javaExpressionParser,
+        ]), ([, , init]) => init)),
+    ]), ([name, , initializer]) => ({ name, initializer })), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        javaSkippableParser,
+    ]), () => ',')),
+]), ([annotations, modifiers, type_, , variables]) => ({
+    type: 'VariableDeclarationExpr',
+    modifiers,
+    annotations,
+    variables: variables.map(v => ({
+        type: 'VariableDeclarator',
+        name: v.name,
+        type_,
+        ...(v.initializer ? { initializer: v.initializer } : {}),
+    })),
+}));
+setParserName(javaVariableDeclarationExprParser, 'javaVariableDeclarationExprParser');
+const javaLocalVarDeclStmtParser = createObjectParser({
+    type: 'ExpressionStmt',
+    expression: javaVariableDeclarationExprParser,
+    _ws1: javaSkippableParser,
+    _semi: createExactSequenceParser(';'),
+});
+setParserName(javaLocalVarDeclStmtParser, 'javaLocalVarDeclStmtParser');
+const javaForStmtParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('for'),
+    javaSkippableParser,
+    createExactSequenceParser('('),
+    javaSkippableParser,
+    // Initialization: can be variable declaration or expression list
+    createOptionalParser(createDisjunctionParser([
+        javaVariableDeclarationExprParser,
+        javaExpressionParser,
+    ])),
+    javaSkippableParser,
+    createExactSequenceParser(';'),
+    javaSkippableParser,
+    // Condition
+    createOptionalParser(javaExpressionParser),
+    javaSkippableParser,
+    createExactSequenceParser(';'),
+    javaSkippableParser,
+    // Update: expression list (comma-separated)
+    createOptionalParser(createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        javaExpressionParser,
+        javaSkippableParser,
+    ]), ([expr]) => expr), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        javaSkippableParser,
+    ]), () => ','))),
+    javaSkippableParser,
+    createExactSequenceParser(')'),
+    javaSkippableParser,
+    (ctx) => javaStatementParser(ctx),
+]), ([, , , , init, , , , condition, , , , update, , , , body]) => ({
+    type: 'ForStmt',
+    initialization: init ? [init] : [],
+    ...(condition ? { compare: condition } : {}),
+    update: update ?? [],
+    body,
+}));
+setParserName(javaForStmtParser, 'javaForStmtParser');
+const javaForEachStmtParser = createObjectParser({
+    _for: createExactSequenceParser('for'),
+    _ws1: javaSkippableParser,
+    _open: createExactSequenceParser('('),
+    _ws2: javaSkippableParser,
+    type: 'ForEachStmt',
+    variable: javaVariableDeclarationExprParser,
+    _ws3: javaSkippableParser,
+    _colon: createExactSequenceParser(':'),
+    _ws4: javaSkippableParser,
+    iterable: javaExpressionParser,
+    _ws5: javaSkippableParser,
+    _close: createExactSequenceParser(')'),
+    _ws6: javaSkippableParser,
+    body: (ctx) => javaStatementParser(ctx),
+});
+setParserName(javaForEachStmtParser, 'javaForEachStmtParser');
+const javaExplicitConstructorInvocationStmtParser = promiseCompose(createTupleParser([
+    createDisjunctionParser([
+        promiseCompose(createExactSequenceParser('this'), () => true),
+        promiseCompose(createExactSequenceParser('super'), () => false),
+    ]),
+    javaSkippableParser,
+    createExactSequenceParser('('),
+    javaSkippableParser,
+    createOptionalParser(createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        javaExpressionParser,
+        javaSkippableParser,
+    ]), ([expr]) => expr), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        javaSkippableParser,
+    ]), () => ','))),
+    createExactSequenceParser(')'),
+    javaSkippableParser,
+    createExactSequenceParser(';'),
+]), ([isThis, , , , args]) => ({
+    type: 'ExplicitConstructorInvocationStmt',
+    isThis,
+    arguments: args ?? [],
+}));
+setParserName(javaExplicitConstructorInvocationStmtParser, 'javaExplicitConstructorInvocationStmtParser');
+const javaCatchClauseParser = createObjectParser({
+    _catch: createExactSequenceParser('catch'),
+    _ws1: javaSkippableParser,
+    _open: createExactSequenceParser('('),
+    _ws2: javaSkippableParser,
+    type: 'CatchClause',
+    parameter: javaParameterParser,
+    _ws3: javaSkippableParser,
+    _close: createExactSequenceParser(')'),
+    _ws4: javaSkippableParser,
+    body: (ctx) => javaBlockStmtParserWithStatements(ctx),
+});
+setParserName(javaCatchClauseParser, 'javaCatchClauseParser');
+const javaTryStmtParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('try'),
+    javaSkippableParser,
+    // Optional resources for try-with-resources: try (Resource r = ...)
+    createOptionalParser(promiseCompose(createTupleParser([
+        createExactSequenceParser('('),
+        javaSkippableParser,
+        createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+            javaVariableDeclarationExprParser,
+            javaSkippableParser,
+        ]), ([resource]) => resource), promiseCompose(createTupleParser([
+            createExactSequenceParser(';'),
+            javaSkippableParser,
+        ]), () => ';')),
+        // Optional trailing semicolon
+        createOptionalParser(createExactSequenceParser(';')),
+        javaSkippableParser,
+        createExactSequenceParser(')'),
+        javaSkippableParser,
+    ]), ([, , resources]) => resources)),
+    (ctx) => javaBlockStmtParserWithStatements(ctx),
+    javaSkippableParser,
+    createArrayParser(promiseCompose(createTupleParser([
+        javaCatchClauseParser,
+        javaSkippableParser,
+    ]), ([clause]) => clause)),
+    createOptionalParser(promiseCompose(createTupleParser([
+        createExactSequenceParser('finally'),
+        javaSkippableParser,
+        (ctx) => javaBlockStmtParserWithStatements(ctx),
+    ]), ([, , block]) => block)),
+]), ([, , resources, tryBlock, , catchClauses, finallyBlock]) => ({
+    type: 'TryStmt',
+    resources: resources ?? [],
+    tryBlock,
+    catchClauses,
+    ...(finallyBlock ? { finallyBlock } : {}),
+}));
+setParserName(javaTryStmtParser, 'javaTryStmtParser');
+const javaSwitchEntryParser = createDisjunctionParser([
+    // case expression:
+    promiseCompose(createTupleParser([
+        createExactSequenceParser('case'),
+        javaSkippableParser,
+        javaExpressionParser,
+        javaSkippableParser,
+        createExactSequenceParser(':'),
+        javaSkippableParser,
+        // Parse statements until we hit another case/default or closing brace
+        createArrayParser(promiseCompose(createTupleParser([
+            (ctx) => javaStatementParser(ctx),
+            javaSkippableParser,
+        ]), ([stmt]) => stmt)),
+    ]), ([, , expr, , , , statements]) => ({
+        type: 'SwitchEntry',
+        isDefault: false,
+        labels: [expr],
+        statements,
+        type_: 'STATEMENT_GROUP',
+    })),
+    // default:
+    promiseCompose(createTupleParser([
+        createExactSequenceParser('default'),
+        javaSkippableParser,
+        createExactSequenceParser(':'),
+        javaSkippableParser,
+        // Parse statements until we hit another case/default or closing brace
+        createArrayParser(promiseCompose(createTupleParser([
+            (ctx) => javaStatementParser(ctx),
+            javaSkippableParser,
+        ]), ([stmt]) => stmt)),
+    ]), ([, , , , statements]) => ({
+        type: 'SwitchEntry',
+        isDefault: true,
+        labels: [],
+        statements,
+        type_: 'STATEMENT_GROUP',
+    })),
+]);
+setParserName(javaSwitchEntryParser, 'javaSwitchEntryParser');
+const javaSwitchStmtParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('switch'),
+    javaSkippableParser,
+    createExactSequenceParser('('),
+    javaSkippableParser,
+    javaExpressionParser,
+    javaSkippableParser,
+    createExactSequenceParser(')'),
+    javaSkippableParser,
+    createExactSequenceParser('{'),
+    javaSkippableParser,
+    createArrayParser(promiseCompose(createTupleParser([
+        javaSwitchEntryParser,
+        javaSkippableParser,
+    ]), ([entry]) => entry)),
+    createExactSequenceParser('}'),
+]), ([, , , , selector, , , , , , entries]) => ({
+    type: 'SwitchStmt',
+    selector,
+    entries,
+}));
+setParserName(javaSwitchStmtParser, 'javaSwitchStmtParser');
+// Statement parser - combines all statement types
+javaStatementParser = createDisjunctionParser([
+    javaReturnStmtParser,
+    javaThrowStmtParser,
+    javaIfStmtParser,
+    javaForEachStmtParser, // Must come before ForStmt (both start with 'for')
+    javaForStmtParser,
+    javaTryStmtParser,
+    javaSwitchStmtParser,
+    javaExplicitConstructorInvocationStmtParser, // Must come before expression statement
+    javaBlockStmtParserWithStatements,
+    javaLocalVarDeclStmtParser, // Local variable declarations
+    javaExpressionStmtParser, // Must be last since it's most general
+]);
+setParserName(javaStatementParser, 'javaStatementParser');
+const javaFieldDeclarationParser = promiseCompose(createTupleParser([
+    javaAnnotationsParser,
+    javaModifiersParser,
+    javaTypeParser,
+    javaSkippableParser,
+    createSeparatedNonEmptyArrayParser(promiseCompose(createTupleParser([
+        javaSimpleNameParser,
+        javaSkippableParser,
+        createOptionalParser(promiseCompose(createTupleParser([
+            createExactSequenceParser('='),
+            javaSkippableParser,
+            javaInitializerExprParser,
+        ]), ([, , init]) => init)),
+    ]), ([name, , initializer]) => ({ name, initializer })), promiseCompose(createTupleParser([
+        createExactSequenceParser(','),
+        javaSkippableParser,
+    ]), () => ',')),
+    javaSkippableParser,
+    createExactSequenceParser(';'),
+]), ([annotations, modifiers, type_, , variables]) => ({
+    type: 'FieldDeclaration',
+    modifiers,
+    annotations,
+    variables: variables.map(v => ({
+        type: 'VariableDeclarator',
+        name: v.name,
+        type_,
+        ...(v.initializer ? { initializer: v.initializer } : {}),
+    })),
+}));
+setParserName(javaFieldDeclarationParser, 'javaFieldDeclarationParser');
+const javaConstructorDeclarationParser = promiseCompose(createTupleParser([
+    javaAnnotationsParser,
+    javaModifiersParser,
+    // Constructor name (same as class name)
+    javaSimpleNameParser,
+    javaSkippableParser,
+    javaParameterListParser,
+    javaSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([
+        javaThrowsClauseParser,
+        javaSkippableParser,
+    ]), ([throws]) => throws)),
+    (ctx) => javaBlockStmtParserWithStatements(ctx),
+]), ([annotations, modifiers, name, , parameters, , thrownExceptions, body]) => ({
+    type: 'ConstructorDeclaration',
+    modifiers,
+    annotations,
+    typeParameters: [],
+    name,
+    parameters,
+    thrownExceptions: thrownExceptions ?? [],
+    body,
+}));
+setParserName(javaConstructorDeclarationParser, 'javaConstructorDeclarationParser');
+// We need to try method first because field declaration also starts with modifiers + type + name
+// But constructors don't have a return type, so we try constructor after field fails
+// Note: javaBodyDeclarationParser is reassigned later to include nested type declarations
+let javaBodyDeclarationParser = createDisjunctionParser([
+    javaMethodDeclarationParser,
+    javaConstructorDeclarationParser,
+    javaFieldDeclarationParser,
+]);
+setParserName(javaBodyDeclarationParser, 'javaBodyDeclarationParser');
+// Class body: { member1 member2 ... }
+const javaClassBodyParser = promiseCompose(createTupleParser([
+    createExactSequenceParser('{'),
+    javaSkippableParser,
+    createArrayParser(promiseCompose(createTupleParser([
+        (ctx) => javaBodyDeclarationParser(ctx), // Use function to pick up reassigned value
+        javaSkippableParser,
+    ]), ([member]) => member)),
+    createExactSequenceParser('}'),
+]), ([, , members]) => members);
+const javaClassDeclarationParser = promiseCompose(createTupleParser([
+    javaSkippableParser, // Skip leading comments (e.g., javadoc)
+    javaAnnotationsParser,
+    javaModifiersParser,
+    createExactSequenceParser('class'),
+    javaSkippableParser,
+    javaSimpleNameParser,
+    javaSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([javaTypeParametersParser, javaSkippableParser]), ([params]) => params)),
+    createOptionalParser(promiseCompose(createTupleParser([javaExtendsClauseParser, javaSkippableParser]), ([types]) => types)),
+    createOptionalParser(promiseCompose(createTupleParser([javaImplementsClauseParser, javaSkippableParser]), ([types]) => types)),
+    // TODO: permits clause
+    javaClassBodyParser,
+]), ([, annotations, modifiers, , , name, , typeParameters, extendedTypes, implementedTypes, members]) => ({
+    type: 'ClassOrInterfaceDeclaration',
+    modifiers,
+    annotations,
+    name,
+    isInterface: false,
+    typeParameters: typeParameters ?? [],
+    extendedTypes: extendedTypes ?? [],
+    implementedTypes: implementedTypes ?? [],
+    permittedTypes: [],
+    members,
+}));
+setParserName(javaClassDeclarationParser, 'javaClassDeclarationParser');
+const javaInterfaceDeclarationParser = promiseCompose(createTupleParser([
+    javaSkippableParser, // Skip leading comments (e.g., javadoc)
+    javaAnnotationsParser,
+    javaModifiersParser,
+    createExactSequenceParser('interface'),
+    javaSkippableParser,
+    javaSimpleNameParser,
+    javaSkippableParser,
+    createOptionalParser(promiseCompose(createTupleParser([javaTypeParametersParser, javaSkippableParser]), ([params]) => params)),
+    createOptionalParser(promiseCompose(createTupleParser([javaExtendsClauseParser, javaSkippableParser]), ([types]) => types)),
+    // TODO: permits clause
+    javaClassBodyParser,
+]), ([, annotations, modifiers, , , name, , typeParameters, extendedTypes, members]) => ({
+    type: 'ClassOrInterfaceDeclaration',
+    modifiers,
+    annotations,
+    name,
+    isInterface: true,
+    typeParameters: typeParameters ?? [],
+    extendedTypes: extendedTypes ?? [],
+    implementedTypes: [],
+    permittedTypes: [],
+    members,
+}));
+setParserName(javaInterfaceDeclarationParser, 'javaInterfaceDeclarationParser');
+// Enum declaration
+const javaEnumDeclarationParser = promiseCompose(createTupleParser([
+    javaSkippableParser, // Skip leading comments
+    javaAnnotationsParser,
+    javaModifiersParser,
+    createExactSequenceParser('enum'),
+    javaSkippableParser,
+    javaSimpleNameParser,
+    javaSkippableParser,
+    // TODO: implements clause
+    // TODO: parse enum entries and members
+    javaSkipBalancedBracesParser, // Skip body for now
+]), ([, annotations, modifiers, , , name]) => ({
+    type: 'EnumDeclaration',
+    modifiers,
+    annotations,
+    name,
+    implementedTypes: [],
+    entries: [],
+    members: [],
+}));
+setParserName(javaEnumDeclarationParser, 'javaEnumDeclarationParser');
+// Record declaration
+const javaRecordDeclarationParser = promiseCompose(createTupleParser([
+    javaAnnotationsParser,
+    javaModifiersParser,
+    createExactSequenceParser('record'),
+    javaSkippableParser,
+    javaIdentifierParser,
+    javaSkippableParser,
+    // TODO: type parameters
+    // TODO: record components (required)
+    // TODO: implements clause
+    javaSkipBalancedBracesParser, // Skip body for now
+]), ([annotations, modifiers, , , name]) => ({
+    type: 'record',
+    annotations,
+    modifiers,
+    name,
+}));
+setParserName(javaRecordDeclarationParser, 'javaRecordDeclarationParser');
+// Annotation type declaration
+const javaAnnotationDeclarationParser = promiseCompose(createTupleParser([
+    javaAnnotationsParser,
+    javaModifiersParser,
+    createExactSequenceParser('@'),
+    javaOptionalWhitespaceParser,
+    createExactSequenceParser('interface'),
+    javaSkippableParser,
+    javaIdentifierParser,
+    javaSkippableParser,
+    javaSkipBalancedBracesParser, // Skip body for now
+]), ([annotations, modifiers, , , , , name]) => ({
+    type: 'annotation',
+    annotations,
+    modifiers,
+    name,
+}));
+setParserName(javaAnnotationDeclarationParser, 'javaAnnotationDeclarationParser');
+// Type declaration (any kind)
+const javaTypeDeclarationParser = createDisjunctionParser([
+    javaAnnotationDeclarationParser, // Must come before class (both start with annotations/modifiers)
+    javaClassDeclarationParser,
+    javaInterfaceDeclarationParser,
+    javaEnumDeclarationParser,
+    javaRecordDeclarationParser,
+]);
+// Now reassign javaBodyDeclarationParser to include nested type declarations
+javaBodyDeclarationParser = createDisjunctionParser([
+    javaMethodDeclarationParser,
+    javaConstructorDeclarationParser,
+    javaFieldDeclarationParser,
+    javaClassDeclarationParser, // Nested class
+    javaInterfaceDeclarationParser, // Nested interface
+    javaEnumDeclarationParser, // Nested enum
+]);
+setParserName(javaBodyDeclarationParser, 'javaBodyDeclarationParser');
+setParserName(javaTypeDeclarationParser, 'javaTypeDeclarationParser');
+// Compilation unit (top-level)
+export const javaCompilationUnitParser = createObjectParser({
+    type: 'CompilationUnit',
+    _ws1: javaSkippableParser,
+    packageDeclaration: createOptionalParser(promiseCompose(createTupleParser([
+        javaPackageDeclarationParserNew,
+        javaSkippableParser,
+    ]), ([pkg]) => pkg)),
+    imports: createArrayParser(promiseCompose(createTupleParser([
+        javaImportDeclarationParser,
+        javaSkippableParser,
+    ]), ([imp]) => imp)),
+    types: createArrayParser(promiseCompose(createTupleParser([
+        javaTypeDeclarationParser,
+        javaSkippableParser,
+    ]), ([type]) => type)),
+    _ws2: javaSkippableParser,
+});
+setParserName(javaCompilationUnitParser, 'javaCompilationUnitParser');