Attribute Reference¶

This page catalogs every attribute Grammar-Kit recognizes. Attributes control parser generation, PSI class output, error recovery, and other code generation behaviors. They appear in the header block at the top of a .bnf file (global scope) or inline on individual rules (rule scope).

For an explanation of how attributes work, including scope rules and pattern-based targeting, see Attributes System.

Global Parser Attributes¶

These attributes configure the generated parser class and its runtime behavior. Set them in the grammar header block.

parserImports example¶

{
  parserImports=[
    "static com.sample.ExtraTokens.*"
    "static com.sample.MyHooks.*"
  ]
}

tokens example¶

{
  tokens = [
    id="regexp:\w+"       // regexp token
    string                // name only, no value
    PLUS_OP="+"           // simple text token
    SWITCH="switch"       // keyword token
  ]
}

Global PSI Attributes¶

These attributes control the structure and naming of generated PSI classes.

Global Generation Control¶

These attributes toggle entire categories of generated output.

Global Type Mapping¶

These attributes control element type and token type infrastructure.

Rule-Level Parsing Attributes¶

These attributes control how individual rules are parsed. Apply them inline on a rule or through a pattern in the header block.

pin and recoverWhile example¶

list ::= "(" items? ")" {pin=1}
private items ::= [!")" item (',' item) * ] {pin(".*")=1}
item ::= number {recoverWhile=item_recover}
private item_recover ::= !(")" | ",")

consumeTokenMethod example¶

{
  consumeTokenMethod(".*_recover")="consumeTokenFast"
  consumeTokenMethod(".*_expr")="consumeTokenFast"
}

Rule-Level PSI Attributes¶

These attributes shape the PSI class hierarchy and behavior for individual rules.

extends example¶

{
  extends(".*_expr")=expr
}
expr ::= add_expr | mul_expr | ref_expr | literal_expr
add_expr ::= expr '+' expr
mul_expr ::= expr '*' expr

methods example¶

sum_expr ::= expr '+' expr {
  methods=[
    left="/expr[0]"
    right="/expr[1]"
    op="/OP_PLUS"
    evaluate toString    // mix-ins from psiImplUtilClass
  ]
}

hooks example¶

{
  parserImports=["static com.intellij.lang.WhitespacesBinders.*"]
}
left_binder ::= ... { hooks=[leftBinder="GREEDY_LEFT_BINDER"] }
right_binder ::= ... { hooks=[rightBinder="GREEDY_RIGHT_BINDER"] }

The generate Attribute¶

The generate attribute is a list of fine-grained options that supersede several of the global generateXXX attributes. It provides centralized control over what the generator produces.

{
  generate=[psi="no" tokens="no" names="short"]
}

PSI options¶

Type options¶

Parser options¶

Generator options¶

Syntax-api-specific attributes¶

Use these when you enable syntax mode:

{
  generate=[parser-api="syntax"]
  syntaxElementTypeHolderClass="com.example.lang.MySyntaxTypes"
  syntaxParserUtilObject="com.example.lang.MyParserUtil"
  psiOutputPath="../jvm-module/gen"
}

Syntax mode is grammar-global. It changes parser output to Kotlin but leaves PSI output in Java.

Pattern-Based Attributes¶

Many attributes can target multiple rules using a regex pattern. The pattern appears in parentheses after the attribute name in the header block:

{
  extends(".*_expr")=expr
  pin(".*_list(?:_\d+)*")=1
  consumeTokenMethod(".*_recover")="consumeTokenFast"
  mixin("my_named")="com.sample.psi.impl.MyNamedImplMixin"
}

The regex matches against rule names. All matching rules receive the attribute value.