Wednesday, November 18, 2015

My favorite category of paper is the "cute trick" paper, where the author describes a programming trick that is both easy to implement and much better than the naive approach. One of my favorite cute trick papers is Clinton L. Jeffrey's 2003 ACM TOPLAS paper, Generating LR Syntax Error Messages from Examples. The abstract explains the idea:

LR parser generators are powerful and well-understood, but the parsers they generate are not
suited to provide good error messages. Many compilers incur extensive modifications to the source
grammar to produce useful syntax error messages. Interpreting the parse state (and input token) at
the time of error is a nonintrusive alternative that does not entangle the error recovery mechanism
in error message production. Unfortunately, every change to the grammar may significantly alter
the mapping from parse states to diagnostic messages, creating a maintenance problem.

Merr is a tool that allows a compiler writer to associate diagnostic messages with syntax errors
by example, avoiding the need to add error productions to the grammar or interpret integer parse
states. From a specification of errors and messages, Merr runs the compiler on each example error
to obtain the relevant parse state and input token, and generates a yyerror() function that maps
parse states and input tokens to diagnostic messages. Merr enables useful syntax error messages
in LR-based compilers in a manner that is robust in the presence of grammar changes.

Basically, you can take a list of syntactically incorrect programs and error messages for them, and the tool will run the parser to figure out which state the LR automaton will get stuck in for each broken program, and then ensure that whenever you hit that state, you report the error message you wrote. I like this idea an awful lot, because it means that even if you use the full power of LR parsing, you still have a better error message story than any other approach, including hand-coded recursive descent!

Given an LR(1) automaton, what are the states in which an error can be detected? For each
such “error state”, what is a minimal input sentence that causes an error in this state? We propose
an algorithm that answers these questions. Such an algorithm allows building a collection of pairs
of an erroneous input sentence and a diagnostic message, ensuring that this collection covers every
error state, and maintaining this property as the grammar evolves. We report on an application
of this technique to the CompCert ISO C99 parser, and discuss its strengths and limitations.

Basically, in Jeffrey's approach, you write broken programs and their error messages, and Pottier has woroked out an algorithm to generate a covering set of broken programs. Even more excitingly, Pottier has implemented this idea in a production parser generator --- the most recent version of his Menhir parser generator.

So now there's no excuse for using parser combinators, since they offer worse runtime performance and worse error messages! :)