ErrorType (ANTLR 4 Tool 4.5.3 API)

java.lang.Object
- java.lang.Enum<ErrorType>
- - org.antlr.v4.tool.ErrorType

All Implemented Interfaces:

Serializable, Comparable<ErrorType>
```
public enum ErrorType
extends Enum<ErrorType>
```
A complex enumeration of all the error messages that the tool can issue.
When adding error messages, also add a description of the message to the Wiki with a location under the Wiki page Errors Reported by the ANTLR Tool.

Since:

4.0

Author:

Jim Idle <jimi@temporal-wave.com>, Terence Parr

Enum Constant Summary

Enum Constants
Enum Constant and Description
`ACTION_REDEFINITION` Compiler Error 94.
`ALL_OPS_NEED_SAME_ASSOC` Deprecated. This warning is no longer applicable with the current syntax for specifying associativity.
`ALT_LABEL_CONFLICTS_WITH_RULE` Compiler Error 124.
`ALT_LABEL_REDEF` Compiler Error 123.
`ARG_CONFLICTS_WITH_RULE` Compiler Error 138.
`ARG_CONFLICTS_WITH_TOKEN` Compiler Error 139.
`ASSIGNMENT_TO_LIST_LABEL` Compiler Error 135.
`ATTRIBUTE_IN_LEXER_ACTION` Compiler Error 128.
`BAD_OPTION_SET_SYNTAX` Compiler Error 9.
`CANNOT_CREATE_TARGET_GENERATOR` Compiler Error 31.
`CANNOT_FIND_ATTRIBUTE_NAME_IN_DECL` Compiler Error 121.
`CANNOT_FIND_IMPORTED_GRAMMAR` Compiler Error 110.
`CANNOT_FIND_TOKENS_FILE_GIVEN_ON_CMDLINE` Compiler Error 3.
`CANNOT_FIND_TOKENS_FILE_REFD_IN_GRAMMAR` Compiler Error 160.
`CANNOT_OPEN_FILE` Compiler Error 7.
`CANNOT_WRITE_FILE` Compiler Error 1.
`CHANNEL_CONFLICTS_WITH_COMMON_CONSTANTS` Compiler Error 172.
`CHANNEL_CONFLICTS_WITH_MODE` Compiler Error 162.
`CHANNEL_CONFLICTS_WITH_TOKEN` Compiler Error 161.
`CHANNELS_BLOCK_IN_COMBINED_GRAMMAR` Compiler Error 164.
`CHANNELS_BLOCK_IN_PARSER_GRAMMAR` Compiler Error 163.
`CODE_GEN_TEMPLATES_INCOMPLETE` Compiler Error 33.
`CODE_TEMPLATE_ARG_ISSUE` Compiler Error 32.
`DIR_NOT_FOUND` Compiler Error 5.
`EMPTY_STRINGS_NOT_ALLOWED` Compiler Error 174.
`EPSILON_CLOSURE` Compiler Error 153.
`EPSILON_LR_FOLLOW` Compiler Error 148.
`EPSILON_OPTIONAL` Compiler Warning 154.
`EPSILON_TOKEN` Compiler Warning 146.
`ERROR_READING_IMPORTED_GRAMMAR` Compiler Error 11.
`ERROR_READING_TOKENS_FILE` Compiler Error 4.
`EXPECTED_NON_GREEDY_WILDCARD_BLOCK` Compiler Warning 131.
`FILE_AND_GRAMMAR_NAME_DIFFER` Compiler Error 8.
`FRAGMENT_ACTION_IGNORED` Compiler Warning 158.
`ILLEGAL_OPTION` Compiler Warning 83.
`ILLEGAL_OPTION_VALUE` Compiler Warning 84.
`IMPLICIT_STRING_DEFINITION` Compiler Error 126.
`IMPLICIT_TOKEN_DEFINITION` Compiler Warning 125.
`IMPORT_NAME_CLASH` Compiler Error 113.
`INCOMPATIBLE_TOOL_AND_TEMPLATES` Compiler Error 35.
`INTERNAL_ERROR` Compiler Error 20.
`INVALID_CMDLINE_ARG` Compiler Error 2.
`INVALID_ESCAPE_SEQUENCE` Compiler Error 156.
`INVALID_IMPORT` Compiler Error 111.
`INVALID_LEXER_COMMAND` Compiler Error 149.
`INVALID_LITERAL_IN_LEXER_SET` Compiler Error 144.
`INVALID_RULE_PARAMETER_REF` Compiler Error 64.
`ISOLATED_RULE_REF` Compiler Error 67.
`LABEL_BLOCK_NOT_A_SET` Compiler Error 130.
`LABEL_CONFLICTS_WITH_ARG` Compiler Error 72.
`LABEL_CONFLICTS_WITH_LOCAL` Compiler Error 74.
`LABEL_CONFLICTS_WITH_RETVAL` Compiler Error 73.
`LABEL_CONFLICTS_WITH_RULE` Compiler Error 69.
`LABEL_CONFLICTS_WITH_TOKEN` Compiler Error 70.
`LABEL_TYPE_CONFLICT` Compiler Error 75.
`LEFT_RECURSION_CYCLES` Compiler Error 119.
`LEXER_ACTION_PLACEMENT_ISSUE` Deprecated. This error is no longer issued by ANTLR 4.2.
`LEXER_COMMAND_PLACEMENT_ISSUE` Compiler Error 133.
`LEXER_RULES_NOT_ALLOWED` Compiler Error 52.
`LOCAL_CONFLICTS_WITH_ARG` Compiler Error 142.
`LOCAL_CONFLICTS_WITH_RETVAL` Compiler Error 143.
`LOCAL_CONFLICTS_WITH_RULE` Compiler Error 140.
`LOCAL_CONFLICTS_WITH_TOKEN` Compiler Error 141.
`MISSING_CODE_GEN_TEMPLATES` Compiler Error 30.
`MISSING_LEXER_COMMAND_ARGUMENT` Compiler Error 150.
`MISSING_RULE_ARGS` Compiler Error 79.
`MODE_CONFLICTS_WITH_COMMON_CONSTANTS` Compiler Error 173.
`MODE_CONFLICTS_WITH_TOKEN` Compiler Error 170.
`MODE_NOT_IN_LEXER` Compiler Error 120.
`MODE_WITHOUT_RULES` Compiler Error 145.
`NO_MODEL_TO_TEMPLATE_MAPPING` Compiler Error 34.
`NO_NON_LR_ALTS` Compiler Error 147.
`NO_RULES` Compiler Error 99.
`NO_SUCH_GRAMMAR_SCOPE` Compiler Error 105.
`NO_SUCH_RULE_IN_SCOPE` Compiler Error 106.
`NONCONFORMING_LR_RULE`
`OPTIONS_IN_DELEGATE` Compiler Warning 109.
`OUTPUT_DIR_IS_FILE` Compiler Error 6.
`PARSER_RULE_REF_IN_LEXER_RULE` Compiler Error 160.
`PARSER_RULES_NOT_ALLOWED` Compiler Error 53.
`REPEATED_PREQUEL` Compiler Error 54.
`RESERVED_RULE_NAME` Compiler Error 159.
`RETVAL_CONFLICTS_WITH_ARG` Compiler Error 76.
`RETVAL_CONFLICTS_WITH_RULE` Compiler Error 136.
`RETVAL_CONFLICTS_WITH_TOKEN` Compiler Error 137.
`RULE_HAS_NO_ARGS` Compiler Error 80.
`RULE_REDEFINITION` Compiler Error 51.
`RULE_WITH_TOO_FEW_ALT_LABELS` Compiler Error 122.
`STRING_TEMPLATE_WARNING` Compiler Warning 22.
`SYNTAX_ERROR` Compiler Error 50.
`TOKEN_CONFLICTS_WITH_COMMON_CONSTANTS` Compiler Error 171.
`TOKEN_NAME_REASSIGNMENT` Compiler Warning 108.
`TOKEN_NAMES_MUST_START_UPPER` Compiler Error 60.
`TOKENS_FILE_SYNTAX_ERROR` Compiler Error 21.
`UNDEFINED_RULE_IN_NONLOCAL_REF` Compiler Error 57.
`UNDEFINED_RULE_REF` Compiler Error 56.
`UNKNOWN_ATTRIBUTE_IN_SCOPE` Compiler Error 66.
`UNKNOWN_LEXER_CONSTANT` Compiler Warning 155.
`UNKNOWN_RULE_ATTRIBUTE` Compiler Error 65.
`UNKNOWN_SIMPLE_ATTRIBUTE` Compiler Error 63.
`UNRECOGNIZED_ASSOC_OPTION` Compiler Warning 157.
`UNSUPPORTED_REFERENCE_IN_LEXER_SET` Compiler Error 134.
`UNTERMINATED_STRING_LITERAL` Compiler Error 152.
`UNWANTED_LEXER_COMMAND_ARGUMENT` Compiler Error 151.
`USE_OF_BAD_WORD` Compiler Error 134.
`V3_ASSIGN_IN_TOKENS` Compiler Error 203.
`V3_GATED_SEMPRED` Compiler Warning 204.
`V3_LEXER_LABEL` Compiler Warning 201.
`V3_SYNPRED` Compiler Error 205.
`V3_TOKENS_SYNTAX` Compiler Warning 202.
`V3_TREE_GRAMMAR` Compiler Error 200.
`WARNING_TREATED_AS_ERROR` Compiler Error 10.

Field Summary

Fields
Modifier and Type	Field and Description
`int`	`code` The error or warning number.
`String`	`msg` The error or warning message, in StringTemplate 4 format using `<` and `>` as the delimiters.
`ErrorSeverity`	`severity` The error severity.

Method Summary

Methods
Modifier and Type	Method and Description
`static ErrorType`	`valueOf(String name)` Returns the enum constant of this type with the specified name.
`static ErrorType[]`	`values()` Returns an array containing the constants of this enum type, in the order they are declared.

Methods inherited from class java.lang.Enum
clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Enum Constant Detail
  - CANNOT_WRITE_FILE
```
public static final ErrorType CANNOT_WRITE_FILE
```
    Compiler Error 1.
    cannot write file filename: reason
  - INVALID_CMDLINE_ARG
```
public static final ErrorType INVALID_CMDLINE_ARG
```
    Compiler Error 2.
    unknown command-line option option
  - CANNOT_FIND_TOKENS_FILE_GIVEN_ON_CMDLINE
```
public static final ErrorType CANNOT_FIND_TOKENS_FILE_GIVEN_ON_CMDLINE
```
    Compiler Error 3.
    cannot find tokens file filename
  - ERROR_READING_TOKENS_FILE
```
public static final ErrorType ERROR_READING_TOKENS_FILE
```
    Compiler Error 4.
    cannot find tokens file filename: reason
  - DIR_NOT_FOUND
```
public static final ErrorType DIR_NOT_FOUND
```
    Compiler Error 5.
    directory not found: directory
  - OUTPUT_DIR_IS_FILE
```
public static final ErrorType OUTPUT_DIR_IS_FILE
```
    Compiler Error 6.
    output directory is a file: filename
  - CANNOT_OPEN_FILE
```
public static final ErrorType CANNOT_OPEN_FILE
```
    Compiler Error 7.
    cannot find or open file: filename
  - FILE_AND_GRAMMAR_NAME_DIFFER
```
public static final ErrorType FILE_AND_GRAMMAR_NAME_DIFFER
```
    Compiler Error 8.
    grammar name name and file name filename differ
  - BAD_OPTION_SET_SYNTAX
```
public static final ErrorType BAD_OPTION_SET_SYNTAX
```
    Compiler Error 9.
    invalid -Dname=value syntax: syntax
  - WARNING_TREATED_AS_ERROR
```
public static final ErrorType WARNING_TREATED_AS_ERROR
```
    Compiler Error 10.
    warning treated as error
  - ERROR_READING_IMPORTED_GRAMMAR
```
public static final ErrorType ERROR_READING_IMPORTED_GRAMMAR
```
    Compiler Error 11.
    cannot find tokens file filename: reason
  - INTERNAL_ERROR
```
public static final ErrorType INTERNAL_ERROR
```
    Compiler Error 20.
    internal error: message
  - TOKENS_FILE_SYNTAX_ERROR
```
public static final ErrorType TOKENS_FILE_SYNTAX_ERROR
```
    Compiler Error 21.
    .tokens file syntax error filename: message
  - STRING_TEMPLATE_WARNING
```
public static final ErrorType STRING_TEMPLATE_WARNING
```
    Compiler Warning 22.
    template error: message
  - MISSING_CODE_GEN_TEMPLATES
```
public static final ErrorType MISSING_CODE_GEN_TEMPLATES
```
    Compiler Error 30.
    can't find code generation templates: group
  - CANNOT_CREATE_TARGET_GENERATOR
```
public static final ErrorType CANNOT_CREATE_TARGET_GENERATOR
```
    Compiler Error 31.
    ANTLR cannot generate language code as of version version
  - CODE_TEMPLATE_ARG_ISSUE
```
public static final ErrorType CODE_TEMPLATE_ARG_ISSUE
```
    Compiler Error 32.
    code generation template template has missing, misnamed, or incomplete arg list; missing field
  - CODE_GEN_TEMPLATES_INCOMPLETE
```
public static final ErrorType CODE_GEN_TEMPLATES_INCOMPLETE
```
    Compiler Error 33.
    missing code generation template template
  - NO_MODEL_TO_TEMPLATE_MAPPING
```
public static final ErrorType NO_MODEL_TO_TEMPLATE_MAPPING
```
    Compiler Error 34.
    no mapping to template name for output model class class
  - INCOMPATIBLE_TOOL_AND_TEMPLATES
```
public static final ErrorType INCOMPATIBLE_TOOL_AND_TEMPLATES
```
    Compiler Error 35.
    templates/target and tool aren't compatible
  - SYNTAX_ERROR
```
public static final ErrorType SYNTAX_ERROR
```
    Compiler Error 50.
    syntax error: message
  - RULE_REDEFINITION
```
public static final ErrorType RULE_REDEFINITION
```
    Compiler Error 51.
    rule rule redefinition; previous at line line
  - LEXER_RULES_NOT_ALLOWED
```
public static final ErrorType LEXER_RULES_NOT_ALLOWED
```
    Compiler Error 52.
    lexer rule rule not allowed in parser
  - PARSER_RULES_NOT_ALLOWED
```
public static final ErrorType PARSER_RULES_NOT_ALLOWED
```
    Compiler Error 53.
    parser rule rule not allowed in lexer
  - REPEATED_PREQUEL
```
public static final ErrorType REPEATED_PREQUEL
```
    Compiler Error 54.
    repeated grammar prequel spec (options, tokens, or import); please merge
  - UNDEFINED_RULE_REF
```
public static final ErrorType UNDEFINED_RULE_REF
```
    Compiler Error 56.
    reference to undefined rule: rule
    
    See Also:
    PARSER_RULE_REF_IN_LEXER_RULE
  - UNDEFINED_RULE_IN_NONLOCAL_REF
```
public static final ErrorType UNDEFINED_RULE_IN_NONLOCAL_REF
```
    Compiler Error 57.
    reference to undefined rule rule in non-local ref reference
  - TOKEN_NAMES_MUST_START_UPPER
```
public static final ErrorType TOKEN_NAMES_MUST_START_UPPER
```
    Compiler Error 60.
    token names must start with an uppercase letter: name
  - UNKNOWN_SIMPLE_ATTRIBUTE
```
public static final ErrorType UNKNOWN_SIMPLE_ATTRIBUTE
```
    Compiler Error 63.
    unknown attribute reference attribute in expression
  - INVALID_RULE_PARAMETER_REF
```
public static final ErrorType INVALID_RULE_PARAMETER_REF
```
    Compiler Error 64.
    parameter parameter of rule rule is not accessible in this scope: expression
  - UNKNOWN_RULE_ATTRIBUTE
```
public static final ErrorType UNKNOWN_RULE_ATTRIBUTE
```
    Compiler Error 65.
    unknown attribute attribute for rule rule in expression
  - UNKNOWN_ATTRIBUTE_IN_SCOPE
```
public static final ErrorType UNKNOWN_ATTRIBUTE_IN_SCOPE
```
    Compiler Error 66.
    attribute attribute isn't a valid property in expression
  - ISOLATED_RULE_REF
```
public static final ErrorType ISOLATED_RULE_REF
```
    Compiler Error 67.
    missing attribute access on rule reference rule in expression
  - LABEL_CONFLICTS_WITH_RULE
```
public static final ErrorType LABEL_CONFLICTS_WITH_RULE
```
    Compiler Error 69.
    label label conflicts with rule with same name
  - LABEL_CONFLICTS_WITH_TOKEN
```
public static final ErrorType LABEL_CONFLICTS_WITH_TOKEN
```
    Compiler Error 70.
    label label conflicts with token with same name
  - LABEL_CONFLICTS_WITH_ARG
```
public static final ErrorType LABEL_CONFLICTS_WITH_ARG
```
    Compiler Error 72.
    label label conflicts with parameter with same name
  - LABEL_CONFLICTS_WITH_RETVAL
```
public static final ErrorType LABEL_CONFLICTS_WITH_RETVAL
```
    Compiler Error 73.
    label label conflicts with return value with same name
  - LABEL_CONFLICTS_WITH_LOCAL
```
public static final ErrorType LABEL_CONFLICTS_WITH_LOCAL
```
    Compiler Error 74.
    label label conflicts with local with same name
  - LABEL_TYPE_CONFLICT
```
public static final ErrorType LABEL_TYPE_CONFLICT
```
    Compiler Error 75.
    label label type mismatch with previous definition: message
  - RETVAL_CONFLICTS_WITH_ARG
```
public static final ErrorType RETVAL_CONFLICTS_WITH_ARG
```
    Compiler Error 76.
    return value name conflicts with parameter with same name
  - MISSING_RULE_ARGS
```
public static final ErrorType MISSING_RULE_ARGS
```
    Compiler Error 79.
    missing arguments(s) on rule reference: rule
  - RULE_HAS_NO_ARGS
```
public static final ErrorType RULE_HAS_NO_ARGS
```
    Compiler Error 80.
    rule rule has no defined parameters
  - ILLEGAL_OPTION
```
public static final ErrorType ILLEGAL_OPTION
```
    Compiler Warning 83.
    unsupported option option
  - ILLEGAL_OPTION_VALUE
```
public static final ErrorType ILLEGAL_OPTION_VALUE
```
    Compiler Warning 84.
    unsupported option value name=value
  - ACTION_REDEFINITION
```
public static final ErrorType ACTION_REDEFINITION
```
    Compiler Error 94.
    redefinition of action action
  - NO_RULES
```
public static final ErrorType NO_RULES
```
    Compiler Error 99.
    This error may take any of the following forms.
    - grammar grammar has no rules
    - implicitly generated grammar grammar has no rules
  - NO_SUCH_GRAMMAR_SCOPE
```
public static final ErrorType NO_SUCH_GRAMMAR_SCOPE
```
    Compiler Error 105.
    reference to undefined grammar in rule reference: grammar.rule
  - NO_SUCH_RULE_IN_SCOPE
```
public static final ErrorType NO_SUCH_RULE_IN_SCOPE
```
    Compiler Error 106.
    rule rule is not defined in grammar grammar
  - TOKEN_NAME_REASSIGNMENT
```
public static final ErrorType TOKEN_NAME_REASSIGNMENT
```
    Compiler Warning 108.
    token name Token is already defined
  - OPTIONS_IN_DELEGATE
```
public static final ErrorType OPTIONS_IN_DELEGATE
```
    Compiler Warning 109.
    options ignored in imported grammar grammar
  - CANNOT_FIND_IMPORTED_GRAMMAR
```
public static final ErrorType CANNOT_FIND_IMPORTED_GRAMMAR
```
    Compiler Error 110.
    can't find or load grammar grammar from filename
  - INVALID_IMPORT
```
public static final ErrorType INVALID_IMPORT
```
    Compiler Error 111.
    grammartype grammar grammar1 cannot import grammartype grammar grammar2
  - IMPORT_NAME_CLASH
```
public static final ErrorType IMPORT_NAME_CLASH
```
    Compiler Error 113.
    grammartype grammar grammar1 and imported grammartype grammar grammar2 both generate recognizer
  - CANNOT_FIND_TOKENS_FILE_REFD_IN_GRAMMAR
```
public static final ErrorType CANNOT_FIND_TOKENS_FILE_REFD_IN_GRAMMAR
```
    Compiler Error 160.
    cannot find tokens file filename
  - ALL_OPS_NEED_SAME_ASSOC
```
@Deprecated
public static final ErrorType ALL_OPS_NEED_SAME_ASSOC
```
    Deprecated. This warning is no longer applicable with the current syntax for specifying associativity.
    
    Compiler Warning 118.
    all operators of alt alt of left-recursive rule must have same associativity
  - LEFT_RECURSION_CYCLES
```
public static final ErrorType LEFT_RECURSION_CYCLES
```
    Compiler Error 119.
    The following sets of rules are mutually left-recursive [rules]
  - MODE_NOT_IN_LEXER
```
public static final ErrorType MODE_NOT_IN_LEXER
```
    Compiler Error 120.
    lexical modes are only allowed in lexer grammars
  - CANNOT_FIND_ATTRIBUTE_NAME_IN_DECL
```
public static final ErrorType CANNOT_FIND_ATTRIBUTE_NAME_IN_DECL
```
    Compiler Error 121.
    cannot find an attribute name in attribute declaration
  - RULE_WITH_TOO_FEW_ALT_LABELS
```
public static final ErrorType RULE_WITH_TOO_FEW_ALT_LABELS
```
    Compiler Error 122.
    rule rule: must label all alternatives or none
  - ALT_LABEL_REDEF
```
public static final ErrorType ALT_LABEL_REDEF
```
    Compiler Error 123.
    rule alt label label redefined in rule rule1, originally in rule rule2
  - ALT_LABEL_CONFLICTS_WITH_RULE
```
public static final ErrorType ALT_LABEL_CONFLICTS_WITH_RULE
```
    Compiler Error 124.
    rule alt label label conflicts with rule rule
  - IMPLICIT_TOKEN_DEFINITION
```
public static final ErrorType IMPLICIT_TOKEN_DEFINITION
```
    Compiler Warning 125.
    implicit definition of token Token in parser
  - IMPLICIT_STRING_DEFINITION
```
public static final ErrorType IMPLICIT_STRING_DEFINITION
```
    Compiler Error 126.
    cannot create implicit token for string literal in non-combined grammar: literal
  - ATTRIBUTE_IN_LEXER_ACTION
```
public static final ErrorType ATTRIBUTE_IN_LEXER_ACTION
```
    Compiler Error 128.
    attribute references not allowed in lexer actions: expression
  - LABEL_BLOCK_NOT_A_SET
```
public static final ErrorType LABEL_BLOCK_NOT_A_SET
```
    Compiler Error 130.
    label label assigned to a block which is not a set
  - EXPECTED_NON_GREEDY_WILDCARD_BLOCK
```
public static final ErrorType EXPECTED_NON_GREEDY_WILDCARD_BLOCK
```
    Compiler Warning 131.
    This warning may take any of the following forms.
    - greedy block ()* contains wildcard; the non-greedy syntax ()*? may be preferred
    - greedy block ()+ contains wildcard; the non-greedy syntax ()+? may be preferred
  - LEXER_ACTION_PLACEMENT_ISSUE
```
@Deprecated
public static final ErrorType LEXER_ACTION_PLACEMENT_ISSUE
```
    Deprecated. This error is no longer issued by ANTLR 4.2.
    
    Compiler Error 132.
    action in lexer rule rule must be last element of single outermost alt
  - LEXER_COMMAND_PLACEMENT_ISSUE
```
public static final ErrorType LEXER_COMMAND_PLACEMENT_ISSUE
```
    Compiler Error 133.
    ->command in lexer rule rule must be last element of single outermost alt
  - USE_OF_BAD_WORD
```
public static final ErrorType USE_OF_BAD_WORD
```
    Compiler Error 134.
    symbol symbol conflicts with generated code in target language or runtime
    
    Note: This error has the same number as the unrelated error UNSUPPORTED_REFERENCE_IN_LEXER_SET.
  - UNSUPPORTED_REFERENCE_IN_LEXER_SET
```
public static final ErrorType UNSUPPORTED_REFERENCE_IN_LEXER_SET
```
    Compiler Error 134.
    rule reference rule is not currently supported in a set
    
    Note: This error has the same number as the unrelated error USE_OF_BAD_WORD.
  - ASSIGNMENT_TO_LIST_LABEL
```
public static final ErrorType ASSIGNMENT_TO_LIST_LABEL
```
    Compiler Error 135.
    cannot assign a value to list label label
  - RETVAL_CONFLICTS_WITH_RULE
```
public static final ErrorType RETVAL_CONFLICTS_WITH_RULE
```
    Compiler Error 136.
    return value name conflicts with rule with same name
  - RETVAL_CONFLICTS_WITH_TOKEN
```
public static final ErrorType RETVAL_CONFLICTS_WITH_TOKEN
```
    Compiler Error 137.
    return value name conflicts with token with same name
  - ARG_CONFLICTS_WITH_RULE
```
public static final ErrorType ARG_CONFLICTS_WITH_RULE
```
    Compiler Error 138.
    parameter parameter conflicts with rule with same name
  - ARG_CONFLICTS_WITH_TOKEN
```
public static final ErrorType ARG_CONFLICTS_WITH_TOKEN
```
    Compiler Error 139.
    parameter parameter conflicts with token with same name
  - LOCAL_CONFLICTS_WITH_RULE
```
public static final ErrorType LOCAL_CONFLICTS_WITH_RULE
```
    Compiler Error 140.
    local local conflicts with rule with same name
  - LOCAL_CONFLICTS_WITH_TOKEN
```
public static final ErrorType LOCAL_CONFLICTS_WITH_TOKEN
```
    Compiler Error 141.
    local local conflicts with rule token same name
  - LOCAL_CONFLICTS_WITH_ARG
```
public static final ErrorType LOCAL_CONFLICTS_WITH_ARG
```
    Compiler Error 142.
    local local conflicts with parameter with same name
  - LOCAL_CONFLICTS_WITH_RETVAL
```
public static final ErrorType LOCAL_CONFLICTS_WITH_RETVAL
```
    Compiler Error 143.
    local local conflicts with return value with same name
  - INVALID_LITERAL_IN_LEXER_SET
```
public static final ErrorType INVALID_LITERAL_IN_LEXER_SET
```
    Compiler Error 144.
    multi-character literals are not allowed in lexer sets: literal
  - MODE_WITHOUT_RULES
```
public static final ErrorType MODE_WITHOUT_RULES
```
    Compiler Error 145.
    lexer mode mode must contain at least one non-fragment rule
    
    Every lexer mode must contain at least one rule which is not declared with the fragment modifier.
  - EPSILON_TOKEN
```
public static final ErrorType EPSILON_TOKEN
```
    Compiler Warning 146.
    non-fragment lexer rule rule can match the empty string
    
    All non-fragment lexer rules must match at least one character.
    
    The following example shows this error.
```
 Whitespace : [ \t]+;  // ok
 Whitespace : [ \t];   // ok

 fragment WS : [ \t]*; // ok

 Whitespace : [ \t]*;  // error 146
 
```
  - NO_NON_LR_ALTS
```
public static final ErrorType NO_NON_LR_ALTS
```
    Compiler Error 147.
    left recursive rule rule must contain an alternative which is not left recursive
    
    Left-recursive rules must contain at least one alternative which is not left recursive.
    
    The following rule produces this error.
```
 // error 147:
 a : a ID
   | a INT
   ;
 
```
  - EPSILON_LR_FOLLOW
```
public static final ErrorType EPSILON_LR_FOLLOW
```
    Compiler Error 148.
    left recursive rule rule contains a left recursive alternative which can be followed by the empty string
    
    In left-recursive rules, all left-recursive alternatives must match at least one symbol following the recursive rule invocation.
    
    The following rule produces this error.
```
 a : ID    // ok        (alternative is not left recursive)
   | a INT // ok        (a must be follow by INT)
   | a ID? // error 148 (the ID following a is optional)
   ;
 
```
  - INVALID_LEXER_COMMAND
```
public static final ErrorType INVALID_LEXER_COMMAND
```
    Compiler Error 149.
    lexer command command does not exist or is not supported by the current target
    
    Each lexer command requires an explicit implementation in the target templates. This error indicates that the command was incorrectly written or is not supported by the current target.
    
    The following rule produces this error.
```
 X : 'foo' -> type(Foo);  // ok
 Y : 'foo' -> token(Foo); // error 149 (token is not a supported lexer command)
 
```
    Since:
    
    4.1
  - MISSING_LEXER_COMMAND_ARGUMENT
```
public static final ErrorType MISSING_LEXER_COMMAND_ARGUMENT
```
    Compiler Error 150.
    missing argument for lexer command command
    
    Some lexer commands require an argument.
    
    The following rule produces this error.
```
 X : 'foo' -> type(Foo); // ok
 Y : 'foo' -> type;      // error 150 (the type command requires an argument)
 
```
    Since:
    
    4.1
  - UNWANTED_LEXER_COMMAND_ARGUMENT
```
public static final ErrorType UNWANTED_LEXER_COMMAND_ARGUMENT
```
    Compiler Error 151.
    lexer command command does not take any arguments
    
    A lexer command which does not take parameters was invoked with an argument.
    
    The following rule produces this error.
```
 X : 'foo' -> popMode;    // ok
 Y : 'foo' -> popMode(A); // error 151 (the popMode command does not take an argument)
 
```
    Since:
    
    4.1
  - UNTERMINATED_STRING_LITERAL
```
public static final ErrorType UNTERMINATED_STRING_LITERAL
```
    Compiler Error 152.
    unterminated string literal
    
    The grammar contains an unterminated string literal.
    
    The following rule produces this error.
```
 x : 'x'; // ok
 y : 'y';  // error 152
 
```
    Since:
    
    4.1
  - EPSILON_CLOSURE
```
public static final ErrorType EPSILON_CLOSURE
```
    Compiler Error 153.
    rule rule contains a closure with at least one alternative that can match an empty string
    
    A rule contains a closure ((...)*) or positive closure ((...)+) around an empty alternative.
    
    The following rule produces this error.
```
 x  : ;
 y  : x+;                                // error 153
 z1 : ('foo' | 'bar'? 'bar2'?)*;         // error 153
 z2 : ('foo' | 'bar' 'bar2'? | 'bar2')*; // ok
 
```
    Since:
    
    4.1
  - EPSILON_OPTIONAL
```
public static final ErrorType EPSILON_OPTIONAL
```
    Compiler Warning 154.
    rule rule contains an optional block with at least one alternative that can match an empty string
    
    A rule contains an optional block ((...)?) around an empty alternative.
    
    The following rule produces this warning.
```
 x  : ;
 y  : x?;                                // warning 154
 z1 : ('foo' | 'bar'? 'bar2'?)?;         // warning 154
 z2 : ('foo' | 'bar' 'bar2'? | 'bar2')?; // ok
 
```
    Since:
    
    4.1
  - UNKNOWN_LEXER_CONSTANT
```
public static final ErrorType UNKNOWN_LEXER_CONSTANT
```
    Compiler Warning 155.
    rule rule contains a lexer command with an unrecognized constant value; lexer interpreters may produce incorrect output
    
    A lexer rule contains a standard lexer command, but the constant value argument for the command is an unrecognized string. As a result, the lexer command will be translated as a custom lexer action, preventing the command from executing in some interpreted modes. The output of the lexer interpreter may not match the output of the generated lexer.
    
    The following rule produces this warning.
```
 @members {
 public static final int CUSTOM = HIDDEN + 1;
 }

 X : 'foo' -> channel(HIDDEN);           // ok
 Y : 'bar' -> channel(CUSTOM);           // warning 155
 
```
    Since:
    
    4.2
  - INVALID_ESCAPE_SEQUENCE
```
public static final ErrorType INVALID_ESCAPE_SEQUENCE
```
    Compiler Error 156.
    invalid escape sequence
    
    The grammar contains a string literal with an invalid escape sequence.
    
    The following rule produces this error.
```
 x : 'x';  // ok
 y : '\u'; // error 156
 
```
    Since:
    
    4.2.1
  - UNRECOGNIZED_ASSOC_OPTION
```
public static final ErrorType UNRECOGNIZED_ASSOC_OPTION
```
    Compiler Warning 157.
    rule rule contains an assoc element option in an unrecognized location
    
    In ANTLR 4.2, the position of the assoc element option was moved from the operator terminal(s) to the alternative itself. This warning is reported when an assoc element option is specified on a grammar element that is not recognized by the current version of ANTLR, and as a result will simply be ignored.
    
    The following rule produces this warning.
```
 x : 'x'
   | x '+'<assoc=right> x   // warning 157
   |<assoc=right> x * x   // ok
   ;
 
```
    Since:
    
    4.2.1
  - FRAGMENT_ACTION_IGNORED
```
public static final ErrorType FRAGMENT_ACTION_IGNORED
```
    Compiler Warning 158.
    fragment rule rule contains an action or command which can never be executed
    
    A lexer rule which is marked with the fragment modifier contains an embedded action or lexer command. ANTLR lexers only execute commands and embedded actions located in the top-level matched rule. Since fragment rules can never be the top-level rule matched by a lexer, actions or commands placed in these rules can never be executed during the lexing process.
    
    The following rule produces this warning.
```
 X1 : 'x' -> more    // ok
    ;
 Y1 : 'x' {more();}  // ok
    ;
 fragment
 X2 : 'x' -> more    // warning 158
    ;
 fragment
 Y2 : 'x' {more();}  // warning 158
    ;
 
```
    Since:
    
    4.2.1
  - RESERVED_RULE_NAME
```
public static final ErrorType RESERVED_RULE_NAME
```
    Compiler Error 159.
    cannot declare a rule with reserved name rule
    
    A rule was declared with a reserved name.
    
    The following rule produces this error.
```
 EOF :  ' '   // error 159 (EOF is a reserved name)
     ;
 
```
    Since:
    
    4.2.1
  - PARSER_RULE_REF_IN_LEXER_RULE
```
public static final ErrorType PARSER_RULE_REF_IN_LEXER_RULE
```
    Compiler Error 160.
    reference to parser rule rule in lexer rule name
    
    See Also:
    UNDEFINED_RULE_REF
  - CHANNEL_CONFLICTS_WITH_TOKEN
```
public static final ErrorType CHANNEL_CONFLICTS_WITH_TOKEN
```
    Compiler Error 161.
    channel name conflicts with token with same name
  - CHANNEL_CONFLICTS_WITH_MODE
```
public static final ErrorType CHANNEL_CONFLICTS_WITH_MODE
```
    Compiler Error 162.
    channel name conflicts with mode with same name
  - CHANNELS_BLOCK_IN_PARSER_GRAMMAR
```
public static final ErrorType CHANNELS_BLOCK_IN_PARSER_GRAMMAR
```
    Compiler Error 163.
    custom channels are not supported in parser grammars
  - CHANNELS_BLOCK_IN_COMBINED_GRAMMAR
```
public static final ErrorType CHANNELS_BLOCK_IN_COMBINED_GRAMMAR
```
    Compiler Error 164.
    custom channels are not supported in combined grammars
  - NONCONFORMING_LR_RULE
```
public static final ErrorType NONCONFORMING_LR_RULE
```
  - MODE_CONFLICTS_WITH_TOKEN
```
public static final ErrorType MODE_CONFLICTS_WITH_TOKEN
```
    Compiler Error 170.
```
 mode M1;
 A1: 'a'; // ok
 mode M2;
 A2: 'a'; // ok
 M1: 'b'; // error 170
 
```
    mode name conflicts with token with same name
  - TOKEN_CONFLICTS_WITH_COMMON_CONSTANTS
```
public static final ErrorType TOKEN_CONFLICTS_WITH_COMMON_CONSTANTS
```
    Compiler Error 171.
    can not use or declare token with reserved name
    
    Reserved names: HIDDEN, DEFAULT_TOKEN_CHANNEL, SKIP, MORE, MAX_CHAR_VALUE, MIN_CHAR_VALUE.
    Can be used but cannot be declared: EOF
  - CHANNEL_CONFLICTS_WITH_COMMON_CONSTANTS
```
public static final ErrorType CHANNEL_CONFLICTS_WITH_COMMON_CONSTANTS
```
    Compiler Error 172.
    can not use or declare channel with reserved name
    
    Reserved names: DEFAULT_MODE, SKIP, MORE, EOF, MAX_CHAR_VALUE, MIN_CHAR_VALUE.
    Can be used but cannot be declared: HIDDEN, DEFAULT_TOKEN_CHANNEL
  - MODE_CONFLICTS_WITH_COMMON_CONSTANTS
```
public static final ErrorType MODE_CONFLICTS_WITH_COMMON_CONSTANTS
```
    Compiler Error 173.
    can not use or declare mode with reserved name
    
    Reserved names: HIDDEN, DEFAULT_TOKEN_CHANNEL, SKIP, MORE, MAX_CHAR_VALUE, MIN_CHAR_VALUE.
    Can be used and cannot declared: DEFAULT_MODE
  - EMPTY_STRINGS_NOT_ALLOWED
```
public static final ErrorType EMPTY_STRINGS_NOT_ALLOWED
```
    Compiler Error 174.
    empty strings not allowed
```
A: '''test''';
```
```
B: '';
```
```
C: 'test' '';
```
  - V3_TREE_GRAMMAR
```
public static final ErrorType V3_TREE_GRAMMAR
```
    Compiler Error 200.
    tree grammars are not supported in ANTLR 4
    
    This error message is provided as a compatibility notice for users migrating from ANTLR 3. ANTLR 4 does not support tree grammars, but instead offers automatically generated parse tree listeners and visitors as a more maintainable alternative.
  - V3_LEXER_LABEL
```
public static final ErrorType V3_LEXER_LABEL
```
    Compiler Warning 201.
    labels in lexer rules are not supported in ANTLR 4; actions cannot reference elements of lexical rules but you can use Lexer.getText() to get the entire text matched for the rule
    
    ANTLR 4 uses a DFA for recognition of entire tokens, resulting in faster and smaller lexers than ANTLR 3 produced. As a result, sub-rules referenced within lexer rules are not tracked independently, and cannot be assigned to labels.
  - V3_TOKENS_SYNTAX
```
public static final ErrorType V3_TOKENS_SYNTAX
```
    Compiler Warning 202.
    tokens {A; B;} syntax is now tokens {A, B} in ANTLR 4
    
    ANTLR 4 uses comma-separated token declarations in the tokens{} block. This warning appears when the tokens block is written using the ANTLR 3 syntax of semicolon-terminated token declarations.
    
    NOTE: ANTLR 4 does not allow a trailing comma to appear following the last token declared in the tokens{} block.
  - V3_ASSIGN_IN_TOKENS
```
public static final ErrorType V3_ASSIGN_IN_TOKENS
```
    Compiler Error 203.
    assignments in tokens{} are not supported in ANTLR 4; use lexical rule TokenName : LiteralValue; instead
    
    ANTLR 3 allowed literal tokens to be declared and assigned a value within the tokens{} block. ANTLR 4 no longer offers this syntax. When migrating a grammar from ANTLR 3 to ANTLR 4, any tokens with a literal value declared in the tokens{} block should be converted to standard lexer rules.
  - V3_GATED_SEMPRED
```
public static final ErrorType V3_GATED_SEMPRED
```
    Compiler Warning 204.
    {...}?=> explicitly gated semantic predicates are deprecated in ANTLR 4; use {...}? instead
    
    ANTLR 4 treats semantic predicates consistently in a manner similar to gated semantic predicates in ANTLR 3. When migrating a grammar from ANTLR 3 to ANTLR 4, all uses of the gated semantic predicate syntax can be safely converted to the standard semantic predicated syntax, which is the only form used by ANTLR 4.
  - V3_SYNPRED
```
public static final ErrorType V3_SYNPRED
```
    Compiler Error 205.
    (...)=> syntactic predicates are not supported in ANTLR 4
    
    ANTLR 4's improved lookahead algorithms do not require the use of syntactic predicates to disambiguate long lookahead sequences. The syntactic predicates should be removed when migrating a grammar from ANTLR 3 to ANTLR 4.
- Field Detail
  - msg
```
public final String msg
```
    The error or warning message, in StringTemplate 4 format using < and > as the delimiters. Arguments for the message may be referenced using the following names:
    - arg: The first template argument
    - arg2: The second template argument
    - arg3: The third template argument
    - verbose: true if verbose messages were requested; otherwise, false
    - exception: The exception which resulted in the error, if any.
    - stackTrace: The stack trace for the exception, when available.
  - code
```
public final int code
```
    The error or warning number.
    The code should be unique, and following its use in a release should not be altered or reassigned.
  - severity
```
public final ErrorSeverity severity
```
    The error severity.
- Method Detail
  - values
```
public static ErrorType[] values()
```
    Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:
```
for (ErrorType c : ErrorType.values())
    System.out.println(c);
```
    Returns:
    an array containing the constants of this enum type, in the order they are declared
  - valueOf
```
public static ErrorType valueOf(String name)
```
    Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
    
    Parameters:
    name - the name of the enum constant to be returned.
    
    Returns:
    the enum constant with the specified name
    
    Throws:
    
    IllegalArgumentException - if this enum type has no constant with the specified name
    
    NullPointerException - if the argument is null

Enum ErrorType

Enum Constant Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Enum

Methods inherited from class java.lang.Object

Enum Constant Detail

CANNOT_WRITE_FILE

INVALID_CMDLINE_ARG

CANNOT_FIND_TOKENS_FILE_GIVEN_ON_CMDLINE

ERROR_READING_TOKENS_FILE

DIR_NOT_FOUND

OUTPUT_DIR_IS_FILE

CANNOT_OPEN_FILE

FILE_AND_GRAMMAR_NAME_DIFFER

BAD_OPTION_SET_SYNTAX

WARNING_TREATED_AS_ERROR

ERROR_READING_IMPORTED_GRAMMAR

INTERNAL_ERROR

TOKENS_FILE_SYNTAX_ERROR

STRING_TEMPLATE_WARNING

MISSING_CODE_GEN_TEMPLATES

CANNOT_CREATE_TARGET_GENERATOR

CODE_TEMPLATE_ARG_ISSUE

CODE_GEN_TEMPLATES_INCOMPLETE

NO_MODEL_TO_TEMPLATE_MAPPING

INCOMPATIBLE_TOOL_AND_TEMPLATES

SYNTAX_ERROR

RULE_REDEFINITION

LEXER_RULES_NOT_ALLOWED

PARSER_RULES_NOT_ALLOWED

REPEATED_PREQUEL

UNDEFINED_RULE_REF

UNDEFINED_RULE_IN_NONLOCAL_REF

TOKEN_NAMES_MUST_START_UPPER

UNKNOWN_SIMPLE_ATTRIBUTE

INVALID_RULE_PARAMETER_REF

UNKNOWN_RULE_ATTRIBUTE

UNKNOWN_ATTRIBUTE_IN_SCOPE

ISOLATED_RULE_REF

LABEL_CONFLICTS_WITH_RULE

LABEL_CONFLICTS_WITH_TOKEN

LABEL_CONFLICTS_WITH_ARG

LABEL_CONFLICTS_WITH_RETVAL

LABEL_CONFLICTS_WITH_LOCAL

LABEL_TYPE_CONFLICT

RETVAL_CONFLICTS_WITH_ARG

MISSING_RULE_ARGS

RULE_HAS_NO_ARGS

ILLEGAL_OPTION

ILLEGAL_OPTION_VALUE

ACTION_REDEFINITION

NO_RULES

NO_SUCH_GRAMMAR_SCOPE

NO_SUCH_RULE_IN_SCOPE

TOKEN_NAME_REASSIGNMENT

OPTIONS_IN_DELEGATE

CANNOT_FIND_IMPORTED_GRAMMAR

INVALID_IMPORT

IMPORT_NAME_CLASH

CANNOT_FIND_TOKENS_FILE_REFD_IN_GRAMMAR

ALL_OPS_NEED_SAME_ASSOC

LEFT_RECURSION_CYCLES

MODE_NOT_IN_LEXER

CANNOT_FIND_ATTRIBUTE_NAME_IN_DECL

RULE_WITH_TOO_FEW_ALT_LABELS

ALT_LABEL_REDEF

ALT_LABEL_CONFLICTS_WITH_RULE

IMPLICIT_TOKEN_DEFINITION

IMPLICIT_STRING_DEFINITION

ATTRIBUTE_IN_LEXER_ACTION

LABEL_BLOCK_NOT_A_SET

EXPECTED_NON_GREEDY_WILDCARD_BLOCK

LEXER_ACTION_PLACEMENT_ISSUE

LEXER_COMMAND_PLACEMENT_ISSUE

USE_OF_BAD_WORD

UNSUPPORTED_REFERENCE_IN_LEXER_SET

ASSIGNMENT_TO_LIST_LABEL

RETVAL_CONFLICTS_WITH_RULE

RETVAL_CONFLICTS_WITH_TOKEN