# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Formatter for Emboss source files.

This module exports a single function, format_emboss_parse_tree(), which
pretty-prints an Emboss parse tree.
"""

from __future__ import print_function

import collections
import itertools

from compiler.front_end import module_ir
from compiler.front_end import tokenizer
from compiler.util import parser_types


class Config(collections.namedtuple('Config',
                                    ['indent_width', 'show_line_types'])):
  """Configuration for formatting."""

  def __new__(cls, indent_width=2, show_line_types=False):
    return super(cls, Config).__new__(cls, indent_width, show_line_types)


class _Row(collections.namedtuple('Row', ['name', 'columns', 'indent'])):
  """Structured contents of a single line."""

  def __new__(cls, name, columns=None, indent=0):
    return super(cls, _Row).__new__(cls, name, tuple(columns or []), indent)


class _Block(collections.namedtuple('Block', ['prefix', 'header', 'body'])):
  """Structured block of multiple lines."""

  def __new__(cls, prefix, header, body):
    assert header
    return super(cls, _Block).__new__(cls, prefix, header, body)


# Map of productions to their formatters.
_formatters = {}


def format_emboss_parse_tree(parse_tree, config, used_productions=None):
  """Formats Emboss source code.

  Arguments:
      parse_tree: A parse tree of an Emboss source file.
      config: A Config tuple with formatting options.
      used_productions: An optional set to which all used productions will be
          added.  Intended for use by test code to ensure full production
          coverage.

  Returns:
      A string of the reformatted source text.
  """
  if hasattr(parse_tree, 'children'):
    parsed_children = [format_emboss_parse_tree(child, config, used_productions)
                       for child in parse_tree.children]
    args = parsed_children + [config]
    if used_productions is not None:
      used_productions.add(parse_tree.production)
    return _formatters[parse_tree.production](*args)
  else:
    assert isinstance(parse_tree, parser_types.Token), str(parse_tree)
    return parse_tree.text


def sanity_check_format_result(formatted_text, original_text):
  """Checks that the given texts are equivalent."""
  # The texts are considered equivalent if they tokenize to the same token
  # stream, except that:
  #
  # Multiple consecutive newline tokens are equivalent to a single newline
  # token.
  #
  # Extra newline tokens at the start of the stream should be ignored.
  #
  # Whitespace at the start or end of a token should be ignored.  This matters
  # for documentation and comment tokens, which may have had trailing whitespace
  # in the original text, and for indent tokens, which may contain a different
  # number of space and/or tab characters.
  original_tokens, errors = tokenizer.tokenize(original_text, '')
  if errors:
    return ['BUG: original text is not tokenizable: {!r}'.format(errors)]

  formatted_tokens, errors = tokenizer.tokenize(formatted_text, '')
  if errors:
    return ['BUG: formatted text is not tokenizable: {!r}'.format(errors)]

  o_tokens = _collapse_newline_tokens(original_tokens)
  f_tokens = _collapse_newline_tokens(formatted_tokens)
  for i in range(len(o_tokens)):
    if (o_tokens[i].symbol != f_tokens[i].symbol or
        o_tokens[i].text.strip() != f_tokens[i].text.strip()):
      return ['BUG: Symbol {} differs: {!r} vs {!r}'.format(i, o_tokens[i],
                                                            f_tokens[i])]
  return []


def _collapse_newline_tokens(token_list):
  r"""Collapses multiple consecutive "\\n" tokens into a single newline."""
  result = []
  for symbol, group in itertools.groupby(token_list, lambda x: x.symbol):
    if symbol == '"\\n"':
      # Skip all newlines if they are at the start, otherwise add a single
      # newline for each consecutive run of newlines.
      if result:
        result.append(list(group)[0])
    else:
      result.extend(group)
  return result


def _indent_row(row):
  """Adds one level of indent to the given row, returning a new row."""
  assert isinstance(row, _Row), repr(row)
  return _Row(name=row.name,
              columns=row.columns,
              indent=row.indent + 1)


def _indent_rows(rows):
  """Adds one level of indent to the given rows, returning a new list."""
  return list(map(_indent_row, rows))


def _indent_blocks(blocks):
  """Adds one level of indent to the given blocks, returning a new list."""
  return [_Block(prefix=_indent_rows(block.prefix),
                 header=_indent_row(block.header),
                 body=_indent_rows(block.body))
          for block in blocks]


def _intersperse(interspersed, sections):
  """Intersperses `interspersed` between non-empty `sections`."""
  result = []
  for section in sections:
    if section:
      if result:
        result.extend(interspersed)
      result.extend(section)
  return result


def _should_add_blank_lines(blocks):
  """Returns true if blank lines should be added between blocks."""
  other_non_empty_lines = 0
  last_non_empty_lines = 0
  for block in blocks:
    last_non_empty_lines = len([line for line in
                                block.body + block.prefix
                                if line.columns])
    other_non_empty_lines += last_non_empty_lines
  # Vertical spaces should be added if there are more interior
  # non-empty-non-header lines than header lines.
  return len(blocks) <= other_non_empty_lines - last_non_empty_lines


def _columnize(blocks, indent_width, indent_columns=1):
  """Aligns columns in the header rows of the given blocks.

  The `indent_columns` argument is used to determine how many columns should be
  indented.  With `indent_columns == 1`, the result would be:

  AA     BB  CC
    AAA  BBB  CCC
  A      B    C

  With `indent_columns == 2`:

  AA   BB     CC
    AAA  BBB  CCC
  A    B      C

  With `indent_columns == 1`, only the first column is indented compared to
  surrounding rows; with `indent_columns == 2`, both the first and second
  columns are indented.

  Arguments:
      blocks: A list of _Blocks to columnize.
      indent_width: The number of spaces per level of indent.
      indent_columns: The number of columns to indent.

  Returns:
      A list of _Rows of the prefix, header, and body _Rows of each block, where
      the header _Rows of each type have had their columns aligned.
  """
  single_width_separators = {'enum-value': {0, 1}, 'field': {0}}
  # For each type of row, figure out how many characters each column needs.
  row_types = collections.defaultdict(
      lambda: collections.defaultdict(lambda: 0))
  for block in blocks:
    max_lengths = row_types[block.header.name]
    for i in range(len(block.header.columns)):
      if i == indent_columns - 1:
        adjustment = block.header.indent * indent_width
      else:
        adjustment = 0
      max_lengths[i] = max(max_lengths[i],
                           len(block.header.columns[i]) + adjustment)

  assert len(row_types) < 3

  # Then, for each row, actually columnize it.
  result = []
  for block in blocks:
    columns = []
    for i in range(len(block.header.columns)):
      column_width = row_types[block.header.name][i]
      if column_width == 0:
        # Zero-width columns are entirely omitted, including their column
        # separators.
        pass
      else:
        if i == indent_columns - 1:
          # This function only performs the right padding for each column.
          # Since the left padding for indent will be added later, the
          # corresponding space needs to be removed from the right padding of
          # the first column.
          column_width -= block.header.indent * indent_width
        if i in single_width_separators.get(block.header.name, []):
          # Only one space around the "=" in enum values and between the start
          # and size in field locations.
          column_width += 1
        else:
          column_width += 2
      columns.append(block.header.columns[i].ljust(column_width))
    result.append(block.prefix + [_Row(block.header.name,
                                       [''.join(columns).rstrip()],
                                       block.header.indent)] + block.body)
  return result


def _indent_blanks_and_comments(rows):
  """Indents blank and comment lines to match the next non-blank line."""
  result = []
  previous_indent = 0
  for row in reversed(rows):
    if not ''.join(row.columns) or row.name == 'comment':
      result.append(_Row(row.name, row.columns, previous_indent))
    else:
      result.append(row)
      previous_indent = row.indent
  return reversed(result)


def _add_blank_rows_on_dedent(rows):
  """Adds blank rows before dedented lines, where needed."""
  result = []
  previous_indent = 0
  previous_row_was_blank = True
  for row in rows:
    row_is_blank = not ''.join(row.columns)
    found_dedent = previous_indent > row.indent
    if found_dedent and not previous_row_was_blank and not row_is_blank:
      result.append(_Row('dedent-space', [], row.indent))
    result.append(row)
    previous_indent = row.indent
    previous_row_was_blank = row_is_blank
  return result


def _render_row_to_text(row, indent_width):
  assert len(row.columns) < 2, '{!r}'.format(row)
  text = ' ' * indent_width * row.indent
  text += ''.join(row.columns)
  return text.rstrip()


def _render_rows_to_text(rows, indent_width, show_line_types):
  max_row_name_len = max([0] + [len(row.name) for row in rows])
  flattened_rows = []
  for row in rows:
    row_text = _render_row_to_text(row, indent_width)
    if show_line_types:
      row_text = row.name.ljust(max_row_name_len) + '|' + row_text
    flattened_rows.append(row_text)
  return '\n'.join(flattened_rows + [''])


def _check_productions():
  """Asserts that the productions in this module match those in module_ir."""
  productions_ok = True
  for production in module_ir.PRODUCTIONS:
    if production not in _formatters:
      productions_ok = False
      print('@_formats({!r})'.format(str(production)))

  for production in _formatters:
    if production not in module_ir.PRODUCTIONS:
      productions_ok = False
      print('not @_formats({!r})'.format(str(production)))

  assert productions_ok, 'Grammar mismatch.'


def _formats_with_config(production_text):
  """Marks a function as a formatter requiring a config argument."""
  production = parser_types.Production.parse(production_text)

  def formats(f):
    assert production not in _formatters, production
    _formatters[production] = f
    return f

  return formats


def _formats(production_text):
  """Marks a function as the formatter for a particular production."""

  def strip_config_argument(f):
    _formats_with_config(production_text)(lambda *a, **kw: f(*a[:-1], **kw))
    return f

  return strip_config_argument


################################################################################
# From here to the end of the file are functions which recursively format an
# Emboss parse tree.
#
# The format_parse_tree() function will call formatters, bottom-up, for the
# entire parse tree.  Each formatter will be called with the results of the
# formatters for each child node.  (The "formatter" for leaf nodes is the
# original text of the token.)
#
# Formatters can be roughly divided into three types:
#
# The _module formatter is the top-level formatter.  It handles final rendering
# into text, and returns a string.
#
# Formatters for productions that are at least one full line return lists of
# _Rows.  The production 'attribute-line' falls into this category, but
# 'attribute' does not.  This form allows parallel constructs in separate lines
# to be lined up column-wise, even when there are intervening lines that should
# not be lined up -- for example, the types and names of struct fields will be
# aligned, even if there are documentation, comment, or attribute lines mixed
# in.
#
# Formatters for productions that are smaller than one full line just return
# strings.


@_formats_with_config('module -> comment-line* doc-line* import-line*'
                      '          attribute-line* type-definition*')
def _module(comments, docs, imports, attributes, types, config):
  """Performs top-level formatting for an Emboss source file."""

  # The top-level sections other than types should be separated by single lines.
  header_rows = _intersperse(
      [_Row('section-break')],
      [_strip_empty_leading_trailing_comment_lines(comments), docs, imports,
       attributes])

  # Top-level types should be separated by double lines from themselves and from
  # the header rows.
  rows = _intersperse(
      [_Row('top-type-separator'), _Row('top-type-separator')],
      [header_rows] + types)

  # Final fixups.
  rows = _indent_blanks_and_comments(rows)
  rows = _add_blank_rows_on_dedent(rows)
  return _render_rows_to_text(rows, config.indent_width, config.show_line_types)


@_formats('doc-line -> doc Comment? eol')
def _doc_line(doc, comment, eol):
  assert not comment, 'Comment should not be possible on the same line as doc.'
  return [_Row('doc', [doc])] + eol


@_formats('import-line -> "import" string-constant "as" snake-word Comment?'
          '               eol')
def _import_line(import_, filename, as_, name, comment, eol):
  return [_Row('import', ['{} {} {} {}  {}'.format(
      import_, filename, as_, name, comment)])] + eol


@_formats('attribute-line -> attribute Comment? eol')
def _attribute_line(attribute, comment, eol):
  return [_Row('attribute', ['{}  {}'.format(attribute, comment)])] + eol


@_formats('attribute -> "[" attribute-context? "$default"? snake-word ":"'
          '             attribute-value "]"')
def _attribute(open_, context, default, name, colon, value, close):
  return ''.join([open_,
                  _concatenate_with_spaces(context, default, name + colon,
                                           value),
                  close])


@_formats('parameter-definition -> snake-name ":" type')
def _parameter_definition(name, colon, type_specifier):
  return '{}{} {}'.format(name, colon, type_specifier)


@_formats('type-definition* -> type-definition type-definition*')
def _type_defitinions(definition, definitions):
  return [definition] + definitions


@_formats('bits -> "bits" type-name delimited-parameter-definition-list? ":"'
          '        Comment? eol bits-body')
@_formats('struct -> "struct" type-name delimited-parameter-definition-list?'
          '          ":" Comment? eol struct-body')
def _structure_type(struct, name, parameters, colon, comment, eol, body):
  return ([_Row('type-header',
                ['{} {}{}{}  {}'.format(
                    struct, name, parameters, colon, comment)])] +
          eol + body)


@_formats('enum -> "enum" type-name ":" Comment? eol enum-body')
@_formats('external -> "external" type-name ":" Comment? eol external-body')
def _type(struct, name, colon, comment, eol, body):
  return ([_Row('type-header',
                ['{} {}{}  {}'.format(struct, name, colon, comment)])] +
          eol + body)


@_formats_with_config('bits-body -> Indent doc-line* attribute-line*'
                      '             type-definition* bits-field-block Dedent')
@_formats_with_config(
    'struct-body -> Indent doc-line* attribute-line*'
    '               type-definition* struct-field-block Dedent')
def _structure_body(indent, docs, attributes, type_definitions, fields, dedent,
                    config):
  del indent, dedent  # Unused.
  spacing = [_Row('field-separator')] if _should_add_blank_lines(fields) else []
  columnized_fields = _columnize(fields, config.indent_width, indent_columns=2)
  return _indent_rows(_intersperse(
      spacing, [docs, attributes] + type_definitions + columnized_fields))


@_formats('field-location -> expression "[" "+" expression "]"')
def _field_location(start, open_bracket, plus, size, close_bracket):
  return [start, open_bracket + plus + size + close_bracket]


@_formats('anonymous-bits-field-block -> conditional-anonymous-bits-field-block'
          '                              anonymous-bits-field-block')
@_formats('anonymous-bits-field-block -> unconditional-anonymous-bits-field'
          '                              anonymous-bits-field-block')
@_formats('bits-field-block -> conditional-bits-field-block bits-field-block')
@_formats('bits-field-block -> unconditional-bits-field bits-field-block')
@_formats('struct-field-block -> conditional-struct-field-block'
          '                      struct-field-block')
@_formats('struct-field-block -> unconditional-struct-field struct-field-block')
@_formats('unconditional-anonymous-bits-field* ->'
          '    unconditional-anonymous-bits-field'
          '    unconditional-anonymous-bits-field*')
@_formats('unconditional-anonymous-bits-field+ ->'
          '    unconditional-anonymous-bits-field'
          '    unconditional-anonymous-bits-field*')
@_formats('unconditional-bits-field* -> unconditional-bits-field'
          '                             unconditional-bits-field*')
@_formats('unconditional-bits-field+ -> unconditional-bits-field'
          '                             unconditional-bits-field*')
@_formats('unconditional-struct-field* -> unconditional-struct-field'
          '                               unconditional-struct-field*')
@_formats('unconditional-struct-field+ -> unconditional-struct-field'
          '                               unconditional-struct-field*')
def _structure_block(field, block):
  """Prepends field to block."""
  return field + block


@_formats('virtual-field -> "let" snake-name "=" expression Comment? eol'
          '                 field-body?')
def _virtual_field(let_keyword, name, equals, value, comment, eol, body):
  # This formatting doesn't look the best when there are blocks of several
  # virtual fields next to each other, but works pretty well when they're
  # intermixed with physical fields.  It's probably good enough for now, since
  # there aren't (yet) any virtual fields in real .embs, and will probably only
  # be a few in the near future.
  return [_Block([],
                 _Row('virtual-field',
                      [_concatenate_with(
                          '  ',
                          _concatenate_with_spaces(let_keyword, name, equals,
                                                   value),
                          comment)]),
                 eol + body)]


@_formats('field -> field-location type snake-name abbreviation?'
          '         attribute* doc? Comment? eol field-body?')
def _unconditional_field(location, type_, name, abbreviation, attributes, doc,
                         comment, eol, body):
  return [_Block([],
                 _Row('field',
                      location + [type_,
                                  _concatenate_with_spaces(name, abbreviation),
                                  attributes, doc, comment]),
                 eol + body)]


@_formats('field-body -> Indent doc-line* attribute-line* Dedent')
def _field_body(indent, docs, attributes, dedent):
  del indent, dedent  # Unused
  return _indent_rows(docs + attributes)


@_formats('anonymous-bits-field-definition ->'
          '    field-location "bits" ":" Comment? eol anonymous-bits-body')
def _inline_bits(location, bits, colon, comment, eol, body):
  # Even though an anonymous bits field technically defines a new, anonymous
  # type, conceptually it's more like defining a bunch of fields on the
  # surrounding type, so it is treated as an inline list of blocks, instead of
  # being separately formatted.
  header_row = _Row('field', [location[0], location[1] + '  ' + bits + colon,
                              '', '', '', '', comment])
  return ([_Block([], header_row, eol + body.header_lines)] +
          body.field_blocks)


@_formats('inline-enum-field-definition ->'
          '    field-location "enum" snake-name abbreviation? ":" Comment? eol'
          '    enum-body')
@_formats(
    'inline-struct-field-definition ->'
    '    field-location "struct" snake-name abbreviation? ":" Comment? eol'
    '    struct-body')
@_formats('inline-bits-field-definition ->'
          '    field-location "bits" snake-name abbreviation? ":" Comment? eol'
          '    bits-body')
def _inline_type(location, keyword, name, abbreviation, colon, comment, eol,
                 body):
  """Formats an inline type in a struct or bits."""
  header_row = _Row(
      'field', location + [keyword,
                           _concatenate_with_spaces(name, abbreviation) + colon,
                           '', '', comment])
  return [_Block([], header_row, eol + body)]


@_formats('conditional-struct-field-block -> "if" expression ":" Comment? eol'
          '                                  Indent unconditional-struct-field+'
          '                                  Dedent')
@_formats('conditional-bits-field-block -> "if" expression ":" Comment? eol'
          '                                Indent unconditional-bits-field+'
          '                                Dedent')
@_formats('conditional-anonymous-bits-field-block ->'
          '    "if" expression ":" Comment? eol'
          '    Indent unconditional-anonymous-bits-field+ Dedent')
def _conditional_field(if_, condition, colon, comment, eol, indent, body,
                       dedent):
  """Formats an `if` construct."""
  del indent, dedent  # Unused
  # The body of an 'if' should be columnized with the surrounding blocks, so
  # much like an inline 'bits', its body is treated as an inline list of blocks.
  header_row = _Row('if',
                    ['{} {}{}  {}'.format(if_, condition, colon, comment)])
  indented_body = _indent_blocks(body)
  assert indented_body, 'Expected body of if condition.'
  return [_Block([header_row] + eol + indented_body[0].prefix,
                 indented_body[0].header,
                 indented_body[0].body)] + indented_body[1:]


_InlineBitsBodyType = collections.namedtuple('InlineBitsBodyType',
                                             ['header_lines', 'field_blocks'])


@_formats('anonymous-bits-body ->'
          '    Indent attribute-line* anonymous-bits-field-block Dedent')
def _inline_bits_body(indent, attributes, fields, dedent):
  del indent, dedent  # Unused
  return _InlineBitsBodyType(header_lines=_indent_rows(attributes),
                             field_blocks=_indent_blocks(fields))


@_formats_with_config(
    'enum-body -> Indent doc-line* attribute-line* enum-value+'
    '             Dedent')
def _enum_body(indent, docs, attributes, values, dedent, config):
  del indent, dedent  # Unused
  spacing = [_Row('value-separator')] if _should_add_blank_lines(values) else []
  columnized_values = _columnize(values, config.indent_width)
  return _indent_rows(_intersperse(spacing,
                                   [docs, attributes] + columnized_values))


@_formats('enum-value* -> enum-value enum-value*')
@_formats('enum-value+ -> enum-value enum-value*')
def _enum_values(value, block):
  return value + block


@_formats('enum-value -> constant-name "=" expression doc? Comment? eol'
          '              enum-value-body?')
def _enum_value(name, equals, value, docs, comment, eol, body):
  return [_Block([], _Row('enum-value', [name, equals, value, docs, comment]),
                 eol + body)]


@_formats('enum-value-body -> Indent doc-line* Dedent')
def _enum_value_body(indent, docs, dedent):
  del indent, dedent  # Unused
  return _indent_rows(docs)


@_formats('external-body -> Indent doc-line* attribute-line* Dedent')
def _external_body(indent, docs, attributes, dedent):
  del indent, dedent  # Unused
  return _indent_rows(_intersperse([_Row('section-break')], [docs, attributes]))


@_formats('comment-line -> Comment? "\\n"')
def _comment_line(comment, eol):
  del eol  # Unused
  if comment:
    return [_Row('comment', [comment])]
  else:
    return [_Row('comment')]


@_formats('eol -> "\\n" comment-line*')
def _eol(eol, comments):
  del eol  # Unused
  return _strip_empty_leading_trailing_comment_lines(comments)


def _strip_empty_leading_trailing_comment_lines(comments):
  first_non_empty_line = None
  last_non_empty_line = None
  for i in range(len(comments)):
    if comments[i].columns:
      if first_non_empty_line is None:
        first_non_empty_line = i
      last_non_empty_line = i
  if first_non_empty_line is None:
    return []
  else:
    return comments[first_non_empty_line:last_non_empty_line + 1]


@_formats('attribute-line* -> ')
@_formats('anonymous-bits-field-block -> ')
@_formats('bits-field-block -> ')
@_formats('comment-line* -> ')
@_formats('doc-line* -> ')
@_formats('enum-value* -> ')
@_formats('enum-value-body? -> ')
@_formats('field-body? -> ')
@_formats('import-line* -> ')
@_formats('struct-field-block -> ')
@_formats('type-definition* -> ')
@_formats('unconditional-anonymous-bits-field* -> ')
@_formats('unconditional-bits-field* -> ')
@_formats('unconditional-struct-field* -> ')
def _empty_list():
  return []


@_formats('abbreviation? -> ')
@_formats('additive-expression-right* -> ')
@_formats('and-expression-right* -> ')
@_formats('argument-list -> ')
@_formats('array-length-specifier* -> ')
@_formats('attribute* -> ')
@_formats('attribute-context? -> ')
@_formats('comma-then-expression* -> ')
@_formats('Comment? -> ')
@_formats('"$default"? -> ')
@_formats('delimited-argument-list? -> ')
@_formats('delimited-parameter-definition-list? -> ')
@_formats('doc? -> ')
@_formats('equality-expression-right* -> ')
@_formats('equality-or-greater-expression-right* -> ')
@_formats('equality-or-less-expression-right* -> ')
@_formats('field-reference-tail* -> ')
@_formats('or-expression-right* -> ')
@_formats('parameter-definition-list -> ')
@_formats('parameter-definition-list-tail* -> ')
@_formats('times-expression-right* -> ')
@_formats('type-size-specifier? -> ')
def _empty_string():
  return ''


@_formats('abbreviation? -> abbreviation')
@_formats('additive-operator -> "-"')
@_formats('additive-operator -> "+"')
@_formats('and-operator -> "&&"')
@_formats('attribute-context? -> attribute-context')
@_formats('attribute-value -> expression')
@_formats('attribute-value -> string-constant')
@_formats('boolean-constant -> BooleanConstant')
@_formats('bottom-expression -> boolean-constant')
@_formats('bottom-expression -> builtin-reference')
@_formats('bottom-expression -> constant-reference')
@_formats('bottom-expression -> field-reference')
@_formats('bottom-expression -> numeric-constant')
@_formats('builtin-field-word -> "$max_size_in_bits"')
@_formats('builtin-field-word -> "$max_size_in_bytes"')
@_formats('builtin-field-word -> "$min_size_in_bits"')
@_formats('builtin-field-word -> "$min_size_in_bytes"')
@_formats('builtin-field-word -> "$size_in_bits"')
@_formats('builtin-field-word -> "$size_in_bytes"')
@_formats('builtin-reference -> builtin-word')
@_formats('builtin-word -> "$is_statically_sized"')
@_formats('builtin-word -> "$static_size_in_bits"')
@_formats('choice-expression -> logical-expression')
@_formats('Comment? -> Comment')
@_formats('comparison-expression -> additive-expression')
@_formats('constant-name -> constant-word')
@_formats('constant-reference -> constant-reference-tail')
@_formats('constant-reference-tail -> constant-word')
@_formats('constant-word -> ShoutyWord')
@_formats('"$default"? -> "$default"')
@_formats('delimited-argument-list? -> delimited-argument-list')
@_formats('doc? -> doc')
@_formats('doc -> Documentation')
@_formats('enum-value-body? -> enum-value-body')
@_formats('equality-operator -> "=="')
@_formats('equality-or-greater-expression-right -> equality-expression-right')
@_formats('equality-or-greater-expression-right -> greater-expression-right')
@_formats('equality-or-less-expression-right -> equality-expression-right')
@_formats('equality-or-less-expression-right -> less-expression-right')
@_formats('expression -> choice-expression')
@_formats('field-body? -> field-body')
@_formats('function-name -> "$lower_bound"')
@_formats('function-name -> "$present"')
@_formats('function-name -> "$max"')
@_formats('function-name -> "$upper_bound"')
@_formats('greater-operator -> ">="')
@_formats('greater-operator -> ">"')
@_formats('inequality-operator -> "!="')
@_formats('less-operator -> "<="')
@_formats('less-operator -> "<"')
@_formats('logical-expression -> and-expression')
@_formats('logical-expression -> comparison-expression')
@_formats('logical-expression -> or-expression')
@_formats('multiplicative-operator -> "*"')
@_formats('negation-expression -> bottom-expression')
@_formats('numeric-constant -> Number')
@_formats('or-operator -> "||"')
@_formats('snake-name -> snake-word')
@_formats('snake-reference -> builtin-field-word')
@_formats('snake-reference -> snake-word')
@_formats('snake-word -> SnakeWord')
@_formats('string-constant -> String')
@_formats('type-definition -> bits')
@_formats('type-definition -> enum')
@_formats('type-definition -> external')
@_formats('type-definition -> struct')
@_formats('type-name -> type-word')
@_formats('type-reference-tail -> type-word')
@_formats('type-reference -> type-reference-tail')
@_formats('type-size-specifier? -> type-size-specifier')
@_formats('type-word -> CamelWord')
@_formats('unconditional-anonymous-bits-field -> field')
@_formats('unconditional-anonymous-bits-field -> inline-bits-field-definition')
@_formats('unconditional-anonymous-bits-field -> inline-enum-field-definition')
@_formats('unconditional-bits-field -> unconditional-anonymous-bits-field')
@_formats('unconditional-bits-field -> virtual-field')
@_formats('unconditional-struct-field -> anonymous-bits-field-definition')
@_formats('unconditional-struct-field -> field')
@_formats('unconditional-struct-field -> inline-bits-field-definition')
@_formats('unconditional-struct-field -> inline-enum-field-definition')
@_formats('unconditional-struct-field -> inline-struct-field-definition')
@_formats('unconditional-struct-field -> virtual-field')
def _identity(x):
  return x


@_formats('argument-list -> expression comma-then-expression*')
@_formats('times-expression -> negation-expression times-expression-right*')
@_formats('type -> type-reference delimited-argument-list? type-size-specifier?'
          '        array-length-specifier*')
@_formats('array-length-specifier -> "[" expression "]"')
@_formats('array-length-specifier* -> array-length-specifier'
          '                           array-length-specifier*')
@_formats('type-size-specifier -> ":" numeric-constant')
@_formats('attribute-context -> "(" snake-word ")"')
@_formats('constant-reference -> snake-reference "." constant-reference-tail')
@_formats('constant-reference-tail -> type-word "." constant-reference-tail')
@_formats('constant-reference-tail -> type-word "." snake-reference')
@_formats('type-reference-tail -> type-word "." type-reference-tail')
@_formats('field-reference -> snake-reference field-reference-tail*')
@_formats('abbreviation -> "(" snake-word ")"')
@_formats('additive-expression-right -> additive-operator times-expression')
@_formats('additive-expression-right* -> additive-expression-right'
          '                              additive-expression-right*')
@_formats('additive-expression -> times-expression additive-expression-right*')
@_formats('array-length-specifier -> "[" "]"')
@_formats('delimited-argument-list -> "(" argument-list ")"')
@_formats('delimited-parameter-definition-list? ->'
          '    delimited-parameter-definition-list')
@_formats('delimited-parameter-definition-list ->'
          '    "(" parameter-definition-list ")"')
@_formats('parameter-definition-list -> parameter-definition'
          '                             parameter-definition-list-tail*')
@_formats('parameter-definition-list-tail* -> parameter-definition-list-tail'
          '                                   parameter-definition-list-tail*')
@_formats('times-expression-right -> multiplicative-operator'
          '                          negation-expression')
@_formats('times-expression-right* -> times-expression-right'
          '                           times-expression-right*')
@_formats('field-reference-tail -> "." snake-reference')
@_formats('field-reference-tail* -> field-reference-tail field-reference-tail*')
@_formats('negation-expression -> additive-operator bottom-expression')
@_formats('type-reference -> snake-word "." type-reference-tail')
@_formats('bottom-expression -> "(" expression ")"')
@_formats('bottom-expression -> function-name "(" argument-list ")"')
@_formats('comma-then-expression* -> comma-then-expression'
          '                          comma-then-expression*')
@_formats('or-expression-right* -> or-expression-right or-expression-right*')
@_formats('less-expression-right-list -> equality-expression-right*'
          '                              less-expression-right'
          '                              equality-or-less-expression-right*')
@_formats('or-expression-right+ -> or-expression-right or-expression-right*')
@_formats('and-expression -> comparison-expression and-expression-right+')
@_formats('comparison-expression -> additive-expression'
          '                         greater-expression-right-list')
@_formats('comparison-expression -> additive-expression'
          '                         equality-expression-right+')
@_formats('or-expression -> comparison-expression or-expression-right+')
@_formats('equality-expression-right+ -> equality-expression-right'
          '                              equality-expression-right*')
@_formats('and-expression-right* -> and-expression-right and-expression-right*')
@_formats('equality-or-greater-expression-right* ->'
          '    equality-or-greater-expression-right'
          '    equality-or-greater-expression-right*')
@_formats('and-expression-right+ -> and-expression-right and-expression-right*')
@_formats('equality-or-less-expression-right* ->'
          '    equality-or-less-expression-right'
          '    equality-or-less-expression-right*')
@_formats('equality-expression-right* -> equality-expression-right'
          '                              equality-expression-right*')
@_formats('greater-expression-right-list ->'
          '    equality-expression-right* greater-expression-right'
          '    equality-or-greater-expression-right*')
@_formats('comparison-expression -> additive-expression'
          '                         less-expression-right-list')
def _concatenate(*elements):
  """Concatenates all arguments with no delimiters."""
  return ''.join(elements)


@_formats('equality-expression-right -> equality-operator additive-expression')
@_formats('less-expression-right -> less-operator additive-expression')
@_formats('greater-expression-right -> greater-operator additive-expression')
@_formats('or-expression-right -> or-operator comparison-expression')
@_formats('and-expression-right -> and-operator comparison-expression')
def _concatenate_with_prefix_spaces(*elements):
  return ''.join(' ' + element for element in elements if element)


@_formats('attribute* -> attribute attribute*')
@_formats('comma-then-expression -> "," expression')
@_formats('comparison-expression -> additive-expression inequality-operator'
          '                         additive-expression')
@_formats('choice-expression -> logical-expression "?" logical-expression'
          '                                        ":" logical-expression')
@_formats('parameter-definition-list-tail -> "," parameter-definition')
def _concatenate_with_spaces(*elements):
  return _concatenate_with(' ', *elements)


def _concatenate_with(joiner, *elements):
  return joiner.join(element for element in elements if element)


@_formats('attribute-line* -> attribute-line attribute-line*')
@_formats('comment-line* -> comment-line comment-line*')
@_formats('doc-line* -> doc-line doc-line*')
@_formats('import-line* -> import-line import-line*')
def _concatenate_lists(head, tail):
  return head + tail


_check_productions()