Seeking a sanity check - embedded newlines

[The-Futurist]

I'm trying to define the basis for a grammar in which statements are terminated by either Newline or Semicolon yet at the same time tolerate (perhaps multiple adjacent) embedded Newline characters (like what Julia does for example).

I got something that works but want to get an opinion by people with more grammar/Antlr expertise. This is the grammar for a trivial "language" just to test the parsing strategy. (this has been through several iterations and refinements recently).

grammar Julia;

// Parser rules

source: (newlines? statement? (statement_separator statement)* ) fileEnd;
statement:  (scope_statement | path_statement | struct_statement) ;
scope_statement:  scope_keyword newlines? identifier  ;
path_statement: path_keyword newlines? identifier (newlines? DOT newlines? identifier)*    ;
struct_statement: struct_keyword newlines? identifier member_separator struct_member_list newlines? end    ;
fileEnd: newlines? EOF ;
statement_separator : (SEMICOLON | NEWLINE)+   ;
member_separator : COMMA  ;
struct_member_list: struct_member+ ;
struct_member:  newlines? identifier newlines? typename member_separator  ;
newlines: NEWLINE+ ;
identifier: SCOPE | PATH | IDENTIFIER ;
typename: BYTE | WORD | DWORD | QWORD | TEXT ;
end: END ;
struct_keyword: STRUCT ;
scope_keyword: SCOPE  ;
path_keyword: PATH ;

// Lexer rules
SCOPE: 'scope';
PATH: 'path';
STRUCT: 'struct';

BYTE: 'byte';
WORD: 'word';
DWORD: 'dword';
QWORD: 'qword';
TEXT: 'text';

END: 'end';
DOT: '.';
SEMICOLON: ';'; 
COMMA: ',';
NUMBER: [0-9]+ ('.' [0-9]+)?;
IDENTIFIER: [a-z]+;
NEWLINE: ('\r' '\n'); 
WS: [ \t]+ -> skip;

and this is a sample input (very simple language, just to test the parsing)

scope 

scopea

scope 

scopeb;

scope scopec ;
;;

path 

a.b.

c.d.f;

;;

;

scope lastscope ; path path.scope 

;


struct mapping ,
    counter dword,    message text,
    status qword,
    end   ; 
    
    struct 
    
    mapping    ,
    counter dword,    message text,
    status qword,
    end

as you can see embedded newlines are defined by the rule "newlines" and I can insert this between the terms of each grammar rule as I see fit. The statement_separator is defined to be any mix of Newline/Semicolon and consumes any number of these it finds (to prevent them being seen at the start of a next statement).

But:

1. Is this a dumb way to do it, is there a neater way that I'm unaware of?
2. The "newlines" nodes appear in the final parse tree and although they can be ignored during tree processing it would be neater if they simply were never seen at all.
3. Does this actually work, might there be some input I've not yet considered that would fail to parse?