Error in ANTLR4 when parsing for EOF - antlr

Question

I am new to ANTLR (any version) and I am just getting started writing my first grammar file. I'm using the IntelliJ IDE with the ANTLR plugin (v1.6).
My grammar is
grammar TestGrammar;
testfile : message+ EOF;
message : timestamp WS id (NL | EOF);
timestamp : NumericLiteral;
id : NumericLiteral;
NumericLiteral : INTEGER | DECIMAL;
INTEGER : [+-]? [0-9]+;
DECIMAL : [+-]? [0-9]* '.' [0-9]+;
EXPONENT : [eE] [+-]? [0-9]+;
WS: (' ' | '\t')+;
NL: '\r'? '\n';
When I apply the simple test input
123 1231
123 1312
The data is correctly parsed, but I get an error in the IntelliJ preview window.
"extraneous input '<EOF>' expecting {<EOF>, NL}"
What have I done wrong? The EOF seems to be correctly detected... If I add a NL on the last line then the file is parsed correctly but I need to make sure that a final NL is optional.
Additional detail for the format:
We are reverse engineering a data format so I will be honest and say that we don't really know what the constraints are going to be! Our current understanding is that:
Each message must be on its own row
Allow empty lines between messages
Don't require a new line at the end of the file
We have seen evidence of files following these patterns so we know that they are valid input.

Answer 1

In your grammar you explicitly states that a 'new line' must end a line. The question here is: Is the 'new line' at the end of a message part of the language? The same question occurs about white spaces. Are they part of the language? If not, you can skip them:
WS: (' ' | '\t') -> skip;
NL: '\r'? '\n' -> skip;
Then, you can simplify your message rule:
message: timestamp id;
If you really need to keep the end of lines:
NL: '\r'? '\n';
And you add this token as optional at the end of your message rule:
message: timestamp id NL?;
This will work with your example, but will fail for:
123 1231
123 1312
The \n between the two lines will produce an error. The solution that seems the most promising is the first one (skip NL and WS with the simplified message rule) BUT, this entry will be matched as OK:
123 1231 123 1312
It will produce two message rule context.
To sum up, in your example, in order to give you the best way of building your grammar we must know the constraints of your input language.
< EDIT >
Regarding your comments, there is two solutions. Either you are sure your files are well formed and the idea is to extract the information of the file without constraints or you are in a dynamic where you have to be sure the input files conforms to the grammar (in order to also remove "bad files").
I'm pretty sure you are in the first case (as you said you are performing reverse engineering), so you probably want to create a CST from your file to extract information. In that case, considering your input files are always well formed, you don't need to bother about checking if NL are present at the end of messages (by construction, files always have one message by line). In this case, you can skip everything you don't need. The grammar became:
grammar TestGrammar;
testfile : message+ EOF;
message : timestamp id;
timestamp : NumericLiteral;
id : NumericLiteral;
NumericLiteral : INTEGER | DECIMAL;
INTEGER : [+-]? [0-9]+;
DECIMAL : [+-]? [0-9]* '.' [0-9]+;
EXPONENT : [eE] [+-]? [0-9]+;
WS: (' ' | '\t')+ -> skip;
NL: '\r'? '\n' -> skip;
This grammar will recognize
123 1231
123 1312
as well as
123 1231
(as many as \n you want between them)
123 1312
but also
123 1231 123 1312 (-> this will produce two messages as expected)
However, if your input files could be not well formed, with this grammar, you will not be able to exclude them. If you need to ensure that only one message is present by line, you should go with a slightly modified version of the grammar proposed by Raz Friman here:
grammar TestGrammar;
testfile : (message? NL)* message EOF;
message : timestamp id;
timestamp : NumericLiteral;
id : NumericLiteral;
WS: [\t ]+ -> skip;
NL: '\r'? '\n';
NumericLiteral : INTEGER | DECIMAL;
INTEGER : [+-]? [0-9]+;
DECIMAL : [+-]? [0-9]* '.' [0-9]+;
EXPONENT : [eE] [+-]? [0-9]+;
With this grammar:
123 1231
(as many as \n you want between them)
123 1312
will be recognized whereas:
123 1231 123 1312
will throw an error.

Answer 2

If you need to ensure the constraints of the Newlines, you can make the root file check for a final "message" rule and then apply the EOF rule.
The grammar for this is posted below:
testfile : (message NL)* message EOF;
message : timestamp id;
timestamp : NumericLiteral;
id : NumericLiteral;
WS: [\t ]+ -> channel(HIDDEN);
NL: '\r'? '\n';
NumericLiteral : INTEGER | DECIMAL;
INTEGER : [+-]? [0-9]+;
DECIMAL : [+-]? [0-9]* '.' [0-9]+;
EXPONENT : [eE] [+-]? [0-9]+;