TODO

* Set up continuous integration (ci.inria.fr)...
  Check that Menhir builds (and the test pass)
  with multiple versions of OCaml.

* Add a command line option to control how "MenhirLib" should be named in the
  generated code. (Suggested by Gabriel Scherer.)

* Incremental API: expose a function `lookahead` of type `'a env -> token option`.

* Think about implementing Adams and Might's technique for intersecting
  a grammar with a tree automaton. (As a preprocessing step. Think about
  the interaction with parameterized symbols and with %inline.)
  See also de Souza Amorim, Steindorfer & Visser.

* Update the dune demos to work with a recent dune.

* Work of Frédéric on concrete syntax trees.
  - Produce a definition of the specific type of CSTs for this grammar.
    (Before expansion.)
  - Produce a grammar where the semantic actions build CSTs.
  - Define a generic (internal) type of CSTs and
    produce a function that maps generic CSTs to specific CSTs.
  - "Uninliner" : map CSTs for the expanded grammar
    back to CSTs for the source grammar?
  - "Unparsing" : map an arbitrary CST to one that can be printed
    and re-parsed identically, while inserting a minimal number of
    "parentheses". Ideally, with a static guarantee of success,
    and in linear time.

* allow a rule of the form "foo == bar" as sugar for "foo: bar { $1 }"?
  (Allow parameters. Allow several alternatives on the right-hand side,
  as long as each alternative has length 1.) (Frédéric Bour.)
  (Gabriel Scherer, "A suggestion for a more expressive production syntax.")
    https://sympa.inria.fr/sympa/arc/menhir/2017-05/msg00003.html
  (Always parenthesize production groups that share a semantic action?)
  (Or just disallow them?)

* Allow the generated types (token, etc.) to be annotated with OCaml
  attributes such as [@@deriving show].

* Send CompCert pull request using the new API (current_state_number)
  and MenhirLib.ErrorReports where possible.

* Menhir's Web page should be folded back into the git repo's README.

* Move more of ErrorReports from CompCert to MenhirLib.
  In [show], might want to apply [shorten] to the output of [f].

* Clean up the calc-inspection demo, which uses an undocumented/unfinished
  approach to error reporting.

* clean up this TODO file! and use gitlab issues for known bugs?

* Contribute ocamlbuild or dune rules for dealing with .messages files.

* Does ocamlbuild have support for --only-tokens and --external-tokens?
  If not, contribute it (demos/calc-param).

* Complete the implementation of --only-preprocess-for-ocamlyacc.
  Currently, the position keywords ($startpos, etc.) are not supported.
  Translate them to calls to the Parsing module.
  Document this command.

* The documentation says not to use _i,
  but --only-preprocess produces it.
  Should we avoid producing it?
  Should we check that it is not used?

* Possible extensions to the inspection API:
  - offer a way of mapping an initial state (number) back to its nonterminal symbol
  - expose the number of states (useful for memoisation).
  - expose the number of productions.
  - expose an isomorphism between token and xtoken = exists 'a. ('a terminal * 'a)
      T.token2terminal, T.token2value offer one direction (token -> xtoken)
      the other direction would have to be generated

* explain how to simulate inherited attributes in the manual
  (cf. post by David Chemouil on mailing list)

* Look for "artificial dependency" and remove them.
  Make sure every module is explicitly called.

* If the right-hand side of a production provably generates the empty
  language, remove this production. (Must remove it explicitly, otherwise
  we lose the property that errors are detected as early as possible.
  Also, this avoids triggering the detection of epsilon-cycles, which
  assumes that all symbols are inhabited.)
  Currently we warn about nonterminals that generate the empty language.
  Maybe we need a %void annotation when this is intended?
  Document this trick: the empty language can be defined by "void: void"
  and can be used as an actual parameter in parameterized definitions.
  This allows making extensible definitions and instantiating them with
  "no extension".

* --compile-errors could warn about messages wider than 80 columns
                   could also warn statically about out-of-range $i?

* Implement --copy-errors to copy error messages from one .messages
  file to another (for those states that exist in both files).
  Or --merge-errors which merges two .messages file,
  recognizing the default message as irrelevant.
  (Gabriel Scherer.)

* Add a facility to produce a set of *valid* sentences that reach *every*
  (reachable) state of the automaton. Also, a set of valid sentences that
  exercise *every* production. This could be useful in regression testing,
  says Frédéric Bour.

* Dans les avantages de Menhir versus ocamlyacc (dans la doc et
  sur la page Web), ajouter le back-end Coq, l'API incrémentale
  et l'API d'inspection, les règles anonymes, la gestion fine des
  erreurs de syntaxe... Indiquer qu'avec %inline+symboles paramétrés+règles anonymes
  on va en fait beaucoup plus loin que LR(1), à condition que la grammaire
  après macro-expansion soit encore LR(1).

* Document the fact that (ocaml)yacc and Menhir do not have the same
  behavior concerning default reductions (one performs the default
  reduction *before* calling the lexer, the other does it the other
  way around). The difference is observable only when the semantic
  action has a side effect which influences the lexer (i.e., only
  when there is a "lexer hack").

* Pénible que l'API d'inspection ne donne pas accès
  à l'état courant lorsque la pile est vide (état initial donc).
  Pourrait-on exposer cet état? Polymorphe? incoming_symbol
  devrait alors produire une option. Et le cas Nil du type
  stream devrait contenir l'état initial...
  attention, car si on lui applique la fonction items, on va
  obtenir un item spécial S' -> S # qui va poser problème.
  Exposer l'état initial avec un type différent lr1initial?
  Ou alors, exposer juste le symbole de départ correspondant?
  Mais comment le retrouver?

* Allow %token PLUS "+"
  as a definition of "+" as syntactic sugar for PLUS
  (Check what Bison allows, and follow it.)
  This could be desugared on the fly in the fancy parser
  (although it would then be impossible to print the sugared grammar).
  (Suggested by Perry Metzger.)

* autoriser %token FOO [@unused]
  équivalent à --unused-token FOO sur la ligne de commande.
  Add an analogous mechanism for nonterminals that are known
  to be unreachable.

* Produce well-chosen (predictable) names for anonymous rules?

* Standard library: add more list forms (left-recursive lists,
  flexible lists, etc.)

* Define [print_checkpoint].
  Define a printer that shows the states in the stack.

* Documenter la différence de philosophie avec Denny & Malloy à propos
  des conflits (cf. email à Laurence Tratt).

* Add demos/calc-coq to show how the Coq back-end is used.

* Simplify the demos by assuming that Menhir is already installed.
  Remove find-menhir.sh.
  Update [make check].

* allow the user to choose the type of "source code intervals" that are stored
  in the stack (instead of imposing a pair of locations, $startpos and $endpos)
  and to choose how intervals are combined.

* write a specialized version of PackedIntArray.get to the .ml file,
  for added performance. (Suggested by Frédéric Bour.)

* On pourrait rendre moins restrictif le critère qui garantit la terminaison
  de l'expansion des non-terminaux paramétrés. Il suffirait de vérifier que
  les paramètres effectifs sont toujours des atomes (symboles terminaux ou
  non-terminaux), non? (Jacques-Henri.)

* Reconnaître les directives # n "foo" dans le fichier .mly et en tenir
  compte dans les locations.

* BUG: message de Valentin Gatien-Baron du 09/01/2010: le bug de --explain
  est-il bien le bug connu? peut-on le corriger? ne suffirait-il pas de
  passer sous silence les conflits qui ont lieu dans une partie inaccessible
  de l'automate?

* Implémenter un test de détection de boucles. Si la grammaire contient une
  boucle, elle est infiniment ambiguë. Pour le test, calculer tous les
  nullables, ajouter une production unité A -> B dès qu'il existe une
  production A -> alpha B beta avec alpha et beta nullables, et regarder
  ensuite s'il existe un cycle de productions unité.

* Permettre une trace avec autre chose que fprintf stderr. Cela permettrait
  au programmeur (par exemple) de décider à runtime s'il veut afficher ou
  non la trace. (En mode --trace.) Et si possible, donner accès depuis
  l'extérieur à la fonction print_token qui est engendrée.

* Offer a way of annotating the generated type definitions ([token],
  ['a terminal], ['a nonterminal], etc.) with OCaml attributes, such
  as [@@deriving show]. (Suggested by Perry Metzger.)

* (petit) BUG: --follow-construction n'affiche pas le contenu des états
  initiaux (r0)

* Préserver dirname/ dans les directives #line émises.

* BUG: Boris (1.- bouclage parser sur une entrée erronée 2.- une lecture
  trop loin dans le stream, également liée à error).

* éviter "Warning: 22 conflicts ..." car emacs prend "Warning" pour un
  nom de fichier; d'après Damien, il devrait suffire que la phrase après
  les deux points ne commence pas par un nombre.

* si une variable est inutilisée dans une action sémantique, le
  warning est affiché dans le code produit.

* BUG: solving a shift/reduce conflict in favor of reduction can
  cut a path that was required in order to explain another conflict.
  (see e.g. belloeil.mly) (et le reduced_parser.mly d'Adrien Guatto)
  (also check the parser.mly sent by Andrej Bauer on 2016/01/21)
  Or just give up on explaining the conflict in this case.

* BUG: cutdown.mly

* dans le dump de l'automate, rajouter les transitions qui ont
  ete supprimees par resolution de conflits. Afficher aussi les
  réductions par défaut?

* Ideally, [PartialGrammar] should avoid renaming the parameters of
  a rule, when there is no need to do so. The renamed parameter is
  visible in sort unification error messages and in messages about
  duplicate formal parameters (test/bad/duplicate-formal.mly).

* Create a clean functor out of LRijkstra.
  - Must use Cmly_api instead of Grammar
    (or must cleanly document its minimum requirements)
  - Must not perform any side effects
  - Must produce reachability information about pairs (s, z)
  On top of that, implement a GRAMMAR -> GRAMMAR transformation
  that removes all "don't care" entries in the reduction table.
  Then, implement partition refinement for a union of n GRAMMARs (?)
  as a way of testing whether two LR(1) automata (whose LR(0) skeleta
  are identical) are equivalent.

* Quand on est dans un état d'erreur et qu'on tente une réduction
  (car elle est activée dans l'état courant), si l'action sémantique
  fait $syntaxerror, on va apparemment boucler (on rattrape l'exception
  et on se retrouve en mode gestion d'erreur dans le même état; cf. bug
  rapporté par Gabriel Scherer sur la grammaire d'OCaml, OCaml 0007847).
  On pourrait détecter ce cas et le traiter spécialement?