Help improving Java/Groovy like custom DSL

[palexdev]

I'm writing a little custom DSL for executing Java code with reflection and deserialize a tree structure. I'm planning on using this to build UIs from files.
I desperately need help improving it, ANTLR is very hard, and I had to make some compromises to make it work.
Here's my grammar:

grammar UI;

//================================================================================
// PARSER
//================================================================================

// Entry Point
document:
  dependencies?
  imports?
  root = node
  EOF;

// Metadata
dependencies:
  ('@dependencies' | '@deps') LBRACE (STRING COMMA?)+ RBRACE;

imports:
  '@imports' LBRACE (STRING COMMA?)+ RBRACE;

// Node and Properties
node:
  name (COLON COLON constructor)? (LBRACE factory? (methodsChain | property | node)* RBRACE)?;

constructor:
  LPAREN args RPAREN;

factory:
  ('@factory' | '@builder') COLON methodsChain;

property:
  IDENTIFIER (COLON | EQUALS | PLUSEQUALS) type;

args:
  type (COMMA type)*;

// Methods
method:
  IDENTIFIER LPAREN args? RPAREN;

methodsChain:
  (name | THIS) (DOT method)+;

// Type of values
type:
    node
  | collection
  | keywords
  | methodsChain
  | fieldVal
  | BOOLEAN
  | CHAR
  | STRING
  | INTEGER
  | HEXADECIMAL
  | BINARY
  | OCTAL
  | FLOAT
  | DOUBLE
  | NAN
  | INFINITY;

collectionType:
    '@arrayOf'
  | '@listOf'
  | '@mapOf';

collection:
  collectionType LPAREN args RPAREN;

keywords:
  THIS | NULL;

fieldVal:
  (name | THIS) (RARROW | COLON COLON) IDENTIFIER;

// Support for fully qualified names
name:
  IDENTIFIER (DOT IDENTIFIER)*;

//================================================================================
// LEXER
//================================================================================

// Symbols
EQUALS    : '=';
PLUSEQUALS: '+=';
LPAREN    : '(';
RPAREN    : ')';
LBRACE    : '{';
RBRACE    : '}';
LBRACK    : '[';
RBRACK    : ']';
RARROW    : '->';
COLON     : ':';
SEMI      : ';';
COMMA     : ',';
DOT       : '.';

// Comments and Whitespace
COMMENTS: '#' ~[\r\n]* -> channel(HIDDEN); // Ignore comments, ~[\r\n]* matches any sequence of characters excluding newlines
WS: [ \t\r\n\u000C]+ -> channel(HIDDEN); // Ignore whitespaces

// Keywords
THIS: 'this';
BOOLEAN: 'true' | 'false';
INFINITY: ('Infinity' | '-Infinity');                                    // Matches positive and negative infinity
NAN: 'NaN';                                                              // Matches NaN
NULL: 'null';

// Types - String and Character Literals
CHAR: '\'' ( ~['\\\r\n] | '\\' . ) '\'';                                 // Single-quoted character literals, including escape sequences.
STRING: ('\'' (~[\r\n'] | '\\' .)* '\'' | '"' (~[\r\n"] | '\\' .)* '"'); // Matches both single-quoted and double-quoted strings with escape sequences.

// Types - Integers
INTEGER: Digit+;                                                         // Matches decimal integers
HEXADECIMAL: '0x' [0-9a-fA-F]+;                                          // Matches hexadecimal integers (e.g., 0x1F)
BINARY: '0b' [01]+;                                                      // Matches binary integers (e.g., 0b1011)
OCTAL: '0' [0-7]+;                                                       // Matches octal integers (e.g., 0755)

// Types - Floating-point
FLOAT: Digit+ '.' Digit+ ([eE] Digit+)? [fF];                      // Explicit floating-point (e.g., 3.14f, 1.23e10f)
DOUBLE: Digit+ '.' Digit+ ([eE] Digit+)?;                          // Regular double (e.g., 3.14)

// Identifiers
IDENTIFIER: Letter LetterOrDigit*;

fragment Letter:
    [a-zA-Z$_]                         // these are the "java letters" below 0x7F
    | ~[\u0000-\u007F\uD800-\uDBFF]    // covers all characters above 0x7F which are not a surrogate
    | [\uD800-\uDBFF] [\uDC00-\uDFFF]; // covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF

fragment Digit: [+-]?[0-9];

fragment LetterOrDigit: Letter | Digit;

Issues:

1. I had to prefix certain strings with @ rather than . because otherwise I would get the error 'no viable alternative at input' for doing something like this:

ANode {
  Foo.builder() # Expected to be a methodsChain, seems to clash with the factory rule
  # Same would happen for .deps, arrayOf, etc...
}

This is the most confusing issue
2) I had to distinguish static fields from static methods by using either -> or :: for fieldVal. I don't get this, either. Methods are expected to have parentheses, which distinguishes them from fields
3) Both for methodsChain and fieldVal that are part of the current node/object (not static) I must specify the this keyword. It would be great to have it implicit

[palexdev]

After losing half a day rewriting the grammar from scratch, I found some workarounds to make this dumb tool recognize the rules as I wanted. Here's the updated parser:

// Document metadata
dependencies:
  ('.deps {' | '.dependencies {') STRING (COMMA STRING)* RBRACE;

imports:
  '.imports {' STRING (COMMA STRING)* RBRACE;

// Entry Point
document:
  dependencies?
  imports?
  root = node
  EOF;

node:
  IDENTIFIER (DOT IDENTIFIER)* constructor?
  LBRACE
  factory? (methodsChain | property | node)*
  RBRACE;

constructor:
  COLON COLON LPAREN args RPAREN;

factory:
  ('.factory:' | '.builder:') methodsChain;

property:
  IDENTIFIER (COLON | EQUALS | PLUSEQUALS) type;

field:
  (THIS | IDENTIFIER) (DOT IDENTIFIER)+;

method:
  IDENTIFIER LPAREN args RPAREN;

methodsChain:
   (THIS | (IDENTIFIER (DOT IDENTIFIER)*)) (DOT method)+;

array:
  IDENTIFIER (DOT IDENTIFIER)* LBRACK args RBRACK;

collection:
  ctype = ('listOf {' | 'mapOf {' | 'setOf {')
  args
  RBRACE;

keywords:
  THIS | NULL;

type:
    node
  | keywords
  | field
  | methodsChain
  | array
  | collection
  | BOOLEAN
  | CHAR
  | STRING
  | INTEGER
  | HEXADECIMAL
  | BINARY
  | OCTAL
  | FLOAT
  | DOUBLE
  | NAN
  | INFINITY;

args:
  (type COMMA?)*;

1. Metadata starts again with ., but in the string literal I added either { or : to fool ANTLR
   In my opinion, something like this '.imports' LBRACE (STRING COMMA?)+ RBRACE and this'.imports {' (STRING COMMA?)+ RBRACE is exactly the same thing and there is no reason for ANTLR to parse it differently. Either a bug or a design flaw
2. I don't know exactly what change made this possible, but now I can write static methods and fields with just the ., no more -> or :: required
3. I still need the this keyword for instance fields and methods, but to be honest this does not bother me that much, so it's ok

[palexdev]

UP