Escape reserved words during grammar generation, fixes antlr#1070 (@p…

…arrt version)

Deprecate USE_OF_BAD_WORD

runtime-testsuite/resources/org/antlr/v4/test/runtime/descriptors/LexerExec/ReservedWordsEscaping.txt

@@ -0,0 +1,23 @@
+[notes]
+https://github.com/antlr/antlr4/issues/1070
+
+[type]
+Lexer
+
+[grammar]
+lexer grammar L;
+
+channels { break }
+
+A: 'a' -> mode(for);
+
+mode for;
+B: 'b' -> channel(break);
+
+[input]
+ab
+
+[output]
+[@0,0:0='a',<1>,1:0]
+[@1,1:1='b',<2>,channel=2,1:1]
+[@2,2:1='<EOF>',<-1>,1:2]

runtime-testsuite/resources/org/antlr/v4/test/runtime/descriptors/ParserExec/ReservedWordsEscaping.txt

@@ -0,0 +1,36 @@
+[notes]
+https://github.com/antlr/antlr4/issues/1070
+
+[type]
+Parser
+
+[grammar]
+grammar if;
+
+root
+    : {0==0}? continue+ {<writeln("$text")>}
+    ;
+
+continue
+    : for for?                      #else
+    | break=BREAK BREAK+ (for | IF) #class
+    | if+=IF if+=IF*                #int
+    | continue CONTINUE             #static
+    ;
+
+for: FOR;
+FOR: 'for_';
+BREAK: 'break_';
+IF: 'if_';
+CONTINUE: 'continue_';
+
+[start]
+root
+
+[input]
+for_for_break_break_for_if_if_for_continue_
+
+[output]
+"""for_for_break_break_for_if_if_for_continue_
+"""
+

tool/resources/org/antlr/v4/tool/templates/codegen/Cpp/Cpp.stg

@@ -57,9 +57,9 @@ public:
   };
 <endif>
 
-<if (rest(lexer.modes))>
+<if (rest(lexer.runtimeModeNames))>
   enum {
-    <rest(lexer.modes): {m | <m> = <i>}; separator=", ", wrap, anchor>
+    <rest(lexer.runtimeModeNames): {m | <m> = <i>}; separator=", ", wrap, anchor>
   };
 <endif>
 
@@ -190,7 +190,7 @@ std::vector\<std::string> <lexer.name>::_ruleNames = {
 };
 
 std::vector\<std::string> <lexer.name>::_channelNames = {
-  "DEFAULT_TOKEN_CHANNEL", "HIDDEN"<if (lexer.channels)>, <lexer.channels: {c | "<c>"}; separator = ", ", wrap, anchor><endif>
+  "DEFAULT_TOKEN_CHANNEL", "HIDDEN"<if (lexer.channelNames)>, <lexer.channelNames: {c | "<c>"}; separator = ", ", wrap, anchor><endif>
 };
 
 std::vector\<std::string> <lexer.name>::_modeNames = {
@@ -264,7 +264,7 @@ public:
 
 <if (parser.rules)>
   enum {
-    <parser.rules: {r | Rule<r.name; format="cap"> = <r.index>}; separator=", ", wrap, anchor>
+    <parser.rules: {r | Rule<r.escapedName; format="cap"> = <r.index>}; separator=", ", wrap, anchor>
   };
 <endif>
 

tool/resources/org/antlr/v4/tool/templates/codegen/Dart/Dart.stg

@@ -193,7 +193,7 @@ Parser(parser, funcs, atn, sempredFuncs, superClass) ::= <<
 Parser_(parser, funcs, atn, sempredFuncs, ctor, superClass) ::= <<
 <if(namedActions.definitions)><namedActions.definitions><endif>
 <if(parser.rules)>
-const int <parser.rules:{r | RULE_<r.name> = <r.index>}; separator=", ", wrap, anchor>;
+const int <parser.rules:{r | RULE_<r.escapedName> = <r.index>}; separator=", ", wrap, anchor>;
 <endif>
 class <parser.name> extends <superClass; null="Parser"> {
   static final checkVersion = () => RuntimeMetaData.checkVersion('<file.ANTLRVersion>', RuntimeMetaData.VERSION);
@@ -810,14 +810,14 @@ class <lexer.name> extends <superClass; null="Lexer"> {
   static const int
     <lexer.channels:{c | <c> = <lexer.channels.(c)>}; separator=", ", wrap, anchor>;
   <endif>
-  <if(rest(lexer.modes))>
+  <if(rest(lexer.runtimeModeNames))>
   static const int
-    <rest(lexer.modes):{m | <m> = <i>}; separator=", ", wrap, anchor>;
+    <rest(lexer.runtimeModeNames):{m | <m> = <i>}; separator=", ", wrap, anchor>;
   <endif>
 
   @override
   final List\<String> channelNames = [
-    'DEFAULT_TOKEN_CHANNEL', 'HIDDEN'<if (lexer.channels)>, <lexer.channels:{c| '<c>'}; separator=", ", wrap, anchor><endif>
+    'DEFAULT_TOKEN_CHANNEL', 'HIDDEN'<if (lexer.channelNames)>, <lexer.channelNames:{c| '<c>'}; separator=", ", wrap, anchor><endif>
   ];
 
   @override

tool/resources/org/antlr/v4/tool/templates/codegen/Go/Go.stg

@@ -225,12 +225,12 @@ const <parser.name>EOF = antlr.TokenEOF
 
 // <parser.name> rules.
 const (
-	<parser.rules:{r | <parser.name>RULE_<r.name> = <r.index>}; separator="\n">
+	<parser.rules:{r | <parser.name>RULE_<r.escapedName> = <r.index>}; separator="\n">
 )
 <elseif(parser.rules)>
 
-// <parser.name>RULE_<first(parser.rules).name> is the <parser.name> rule.
-const <parser.name>RULE_<first(parser.rules).name> = <first(parser.rules).index>
+// <parser.name>RULE_<first(parser.rules).escapedName> is the <parser.name> rule.
+const <parser.name>RULE_<first(parser.rules).escapedName> = <first(parser.rules).index>
 <endif>
 
 <if(funcs)>
@@ -1411,11 +1411,11 @@ var serializedLexerAtn []uint16
 
 
 var lexerChannelNames = []string{
-	"DEFAULT_TOKEN_CHANNEL", "HIDDEN"<if (lexer.channels)>, <lexer.channels:{c | "<c>"}; separator=", ", wrap><endif>,
+	"DEFAULT_TOKEN_CHANNEL", "HIDDEN"<if (lexer.channelNames)>, <lexer.channelNames:{c | "<c>"}; separator=", ", wrap><endif>,
 }
 
 var lexerModeNames = []string{
-	<lexer.modes:{m | "<m>"}; separator=", ", wrap>,
+	<lexer.runtimeModeNames:{m | "<m>"}; separator=", ", wrap>,
 }
 
 <if(lexer.literalNames)>
@@ -1502,17 +1502,17 @@ const (
 const <lexer.name><first(lexer.channels)> = <lexer.channels.(first(lexer.channels))>
 <endif>
 
-<if(rest(rest(lexer.modes)))>
+<if(rest(rest(lexer.runtimeModeNames)))>
 
 // <lexer.name> modes.
 const (
-	<first(rest(lexer.modes)):{m | <lexer.name><m> = iota + 1}>
-	<rest(rest(lexer.modes)):{m | <lexer.name><m>}; separator="\n">
+	<first(rest(lexer.runtimeModeNames)):{m | <lexer.name><m> = iota + 1}>
+	<rest(rest(lexer.runtimeModeNames)):{m | <lexer.name><m>}; separator="\n">
 )
-<elseif(rest(lexer.modes))>
+<elseif(rest(lexer.runtimeModeNames))>
 
-// <lexer.name><first(rest(lexer.modes))> is the <lexer.name> mode.
-const <lexer.name><first(rest(lexer.modes))> = 1
+// <lexer.name><first(rest(lexer.runtimeModeNames))> is the <lexer.name> mode.
+const <lexer.name><first(rest(lexer.runtimeModeNames))> = 1
 <endif>
 <if(namedActions.members)>
 

tool/resources/org/antlr/v4/tool/templates/codegen/Java/Java.stg

@@ -236,7 +236,7 @@ public class <parser.name> extends <superClass; null="Parser"> {
 	<endif>
 	<if(parser.rules)>
 	public static final int
-		<parser.rules:{r | RULE_<r.name> = <r.index>}; separator=", ", wrap, anchor>;
+		<parser.rules:{r | RULE_<r.escapedName> = <r.index>}; separator=", ", wrap, anchor>;
 	<endif>
 	private static String[] makeRuleNames() {
 		return new String[] {
@@ -913,12 +913,12 @@ public class <lexer.name> extends <superClass; null="Lexer"> {
 	public static final int
 		<lexer.channels:{c | <c>=<lexer.channels.(c)>}; separator=", ", wrap, anchor>;
 	<endif>
-	<if(rest(lexer.modes))>
+	<if(rest(lexer.runtimeModeNames))>
 	public static final int
-		<rest(lexer.modes):{m | <m>=<i>}; separator=", ", wrap, anchor>;
+		<rest(lexer.runtimeModeNames):{m | <m>=<i>}; separator=", ", wrap, anchor>;
 	<endif>
 	public static String[] channelNames = {
-		"DEFAULT_TOKEN_CHANNEL", "HIDDEN"<if (lexer.channels)>, <lexer.channels:{c| "<c>"}; separator=", ", wrap, anchor><endif>
+		"DEFAULT_TOKEN_CHANNEL", "HIDDEN"<if (lexer.channelNames)>, <lexer.channelNames:{c| "<c>"}; separator=", ", wrap, anchor><endif>
 	};
 
 	public static String[] modeNames = {

tool/resources/org/antlr/v4/tool/templates/codegen/JavaScript/JavaScript.stg

@@ -163,7 +163,7 @@ export default class <parser.name> extends <superClass; null="antlr4.Parser"> {
 <endif>
 
 <if(parser.rules)>
-<parser.rules:{r | <parser.name>.RULE_<r.name> = <r.index>;}; separator="\n", wrap, anchor>
+<parser.rules:{r | <parser.name>.RULE_<r.escapedName> = <r.index>;}; separator="\n", wrap, anchor>
 <endif>
 
 <funcs:{f | <ruleContexts(f)>}; separator="\n">
@@ -800,7 +800,7 @@ const decisionsToDFA = atn.decisionToState.map( (ds, index) => new antlr4.dfa.DF
 export default class <lexer.name> extends <if(superClass)><superClass><else>antlr4.Lexer<endif> {
 
     static grammarFileName = "<lexer.grammarFileName>";
-    static channelNames = [ "DEFAULT_TOKEN_CHANNEL", "HIDDEN"<if (lexer.channels)>, <lexer.channels:{c| "<c>"}; separator=", ", wrap, anchor><endif> ];
+    static channelNames = [ "DEFAULT_TOKEN_CHANNEL", "HIDDEN"<if (lexer.channelNames)>, <lexer.channelNames:{c| "<c>"}; separator=", ", wrap, anchor><endif> ];
 	static modeNames = [ <lexer.modes:{m| "<m>"}; separator=", ", wrap, anchor> ];
 	static literalNames = [ <lexer.literalNames:{t | <t>}; null="null", separator=", ", wrap, anchor> ];
 	static symbolicNames = [ <lexer.symbolicNames:{t | <t>}; null="null", separator=", ", wrap, anchor> ];
@@ -826,8 +826,8 @@ export default class <lexer.name> extends <if(superClass)><superClass><else>antl
 <lexer.channels:{c| <lexer.name>.<c> = <lexer.channels.(c)>;}; separator="\n">
 
 <endif>
-<if(rest(lexer.modes))>
-<rest(lexer.modes):{m| <lexer.name>.<m> = <i>;}; separator="\n">
+<if(rest(lexer.runtimeModeNames))>
+<rest(lexer.runtimeModeNames):{m| <lexer.name>.<m> = <i>;}; separator="\n">
 
 <endif>
 

tool/resources/org/antlr/v4/tool/templates/codegen/PHP/PHP.stg

@@ -243,7 +243,7 @@ namespace<if(file.genPackage)> <file.genPackage><endif> {
 		<endif>
 
 		<if(parser.rules)>
-		public const <parser.rules:{r | RULE_<r.name> = <r.index>}; separator=", ", wrap, anchor>;
+		public const <parser.rules:{r | RULE_<r.escapedName> = <r.index>}; separator=", ", wrap, anchor>;
 		<endif>
 
 		/**
@@ -1091,15 +1091,15 @@ namespace<if(lexerFile.genPackage)> <lexerFile.genPackage><endif> {
 		public const <lexer.channels:{c | <c> = <lexer.channels.(c)>}; separator=", ", wrap, anchor>;
 		<endif>
 
-		<if(rest(lexer.modes))>
-		public const <rest(lexer.modes):{m | <m>=<i>}; separator=", ", wrap, anchor>;
+		<if(rest(lexer.runtimeModeNames))>
+		public const <rest(lexer.runtimeModeNames):{m | <m>=<i>}; separator=", ", wrap, anchor>;
 		<endif>
 
 		/**
 		 * @var array\<string>
 		 */
 		public const CHANNEL_NAMES = [
-			'DEFAULT_TOKEN_CHANNEL', 'HIDDEN'<if (lexer.channels)>, <lexer.channels:{c| '<c>'}; separator=", ", wrap, anchor><endif>
+			'DEFAULT_TOKEN_CHANNEL', 'HIDDEN'<if (lexer.channelNames)>, <lexer.channelNames:{c| '<c>'}; separator=", ", wrap, anchor><endif>
 		];
 
 		/**

tool/resources/org/antlr/v4/tool/templates/codegen/Python2/Python2.stg

@@ -133,7 +133,7 @@ class <parser.name> ( <if(superClass)><superClass><else>Parser<endif> ):
     symbolicNames = [ <parser.symbolicNames:{t | u<t>}; null="u\"\<INVALID>\"", separator=", ", wrap, anchor> ]
 
     <if(parser.rules)>
-    <parser.rules:{r | RULE_<r.name> = <r.index>}; separator="\n", wrap, anchor>
+    <parser.rules:{r | RULE_<r.escapedName> = <r.index>}; separator="\n", wrap, anchor>
     <endif>
 
     ruleNames =  [ <parser.ruleNames:{r | u"<r>"}; separator=", ", wrap, anchor> ]
@@ -773,15 +773,15 @@ class <lexer.name>(<if(superClass)><superClass><else>Lexer<endif>):
     <lexer.channels:{c| <c> = <lexer.channels.(c)>}; separator="\n">
 
 <endif>
-<if(rest(lexer.modes))>
-    <rest(lexer.modes):{m| <m> = <i>}; separator="\n">
+<if(rest(lexer.runtimeModeNames))>
+    <rest(lexer.runtimeModeNames):{m| <m> = <i>}; separator="\n">
 
 <endif>
     <if(lexer.tokens)>
     <lexer.tokens:{k | <k> = <lexer.tokens.(k)>}; separator="\n", wrap, anchor>
     <endif>
 
-    channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN"<if (lexer.channels)>, <lexer.channels:{c| u"<c>"}; separator=", ", wrap, anchor><endif> ]
+    channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN"<if (lexer.channelNames)>, <lexer.channelNames:{c| u"<c>"}; separator=", ", wrap, anchor><endif> ]
 
     modeNames = [ <lexer.modes:{m| u"<m>"}; separator=", ", wrap, anchor> ]
 

tool/resources/org/antlr/v4/tool/templates/codegen/Python3/Python3.stg

@@ -146,7 +146,7 @@ class <parser.name> ( <if(superClass)><superClass><else>Parser<endif> ):
     symbolicNames = [ <parser.symbolicNames:{t | <t>}; null="\"\<INVALID>\"", separator=", ", wrap, anchor> ]
 
     <if(parser.rules)>
-    <parser.rules:{r | RULE_<r.name> = <r.index>}; separator="\n", wrap, anchor>
+    <parser.rules:{r | RULE_<r.escapedName> = <r.index>}; separator="\n", wrap, anchor>
     <endif>
 
     ruleNames =  [ <parser.ruleNames:{r | "<r>"}; separator=", ", wrap, anchor> ]
@@ -787,15 +787,15 @@ class <lexer.name>(<if(superClass)><superClass><else>Lexer<endif>):
     <lexer.channels:{c| <c> = <lexer.channels.(c)>}; separator="\n">
 
 <endif>
-<if(rest(lexer.modes))>
-    <rest(lexer.modes):{m| <m> = <i>}; separator="\n">
+<if(rest(lexer.runtimeModeNames))>
+    <rest(lexer.runtimeModeNames):{m| <m> = <i>}; separator="\n">
 
 <endif>
     <if(lexer.tokens)>
     <lexer.tokens:{k | <k> = <lexer.tokens.(k)>}; separator="\n", wrap, anchor>
     <endif>
 
-    channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN"<if (lexer.channels)>, <lexer.channels:{c| u"<c>"}; separator=", ", wrap, anchor><endif> ]
+    channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN"<if (lexer.channelNames)>, <lexer.channelNames:{c| u"<c>"}; separator=", ", wrap, anchor><endif> ]
 
     modeNames = [ <lexer.modes:{m| "<m>"}; separator=", ", wrap, anchor> ]
 

tool/resources/org/antlr/v4/tool/templates/codegen/Swift/Swift.stg

@@ -399,7 +399,7 @@ RuleFunction(currentRule,args,code,locals,ruleCtx,altLabelCtxs,namedActions,fina
 <if(currentRule.modifiers)><currentRule.modifiers:{f | <f> }><else> <accessLevelOpenOK(parser)> func <endif><currentRule.name>(<if(first(args))>_ <endif><args; separator=", _">) throws -> <currentRule.ctxType> {
 	var _localctx: <currentRule.ctxType>
 	_localctx = <currentRule.ctxType>(_ctx, getState()<currentRule.args:{a | , <a.name>}>)
-	try enterRule(_localctx, <currentRule.startState>, <parser.name>.RULE_<currentRule.name>)
+	try enterRule(_localctx, <currentRule.startState>, <parser.name>.RULE_<currentRule.nameForConcat>)
 	<namedActions.init>
 	<locals; separator="\n">
 	defer {
@@ -446,7 +446,7 @@ private func <currentRule.name>(_ _p<args:{a | , <a>}>: Int) throws -> <currentR
 	_localctx = <currentRule.ctxType>(_ctx, _parentState<currentRule.args:{a | , <a.name>}>)
 	var _prevctx: <currentRule.ctxType> = _localctx
 	let _startState: Int = <currentRule.startState>
-	try enterRecursionRule(_localctx, <currentRule.startState>, <parser.name>.RULE_<currentRule.name>, _p)
+	try enterRecursionRule(_localctx, <currentRule.startState>, <parser.name>.RULE_<currentRule.nameForConcat>, _p)
 	<namedActions.init>
 	<locals; separator="\n">
 	defer {
@@ -866,12 +866,12 @@ StructDecl(struct,ctorAttrs,attrs,getters,dispatchMethods,interfaces,extensionMe
 >>
 
 AltLabelStructDecl(struct,attrs,getters,dispatchMethods) ::= <<
-<accessLevelNotOpen(parser)> class <struct.name>: <currentRule.name; format="cap">Context {
+<accessLevelNotOpen(parser)> class <struct.name>: <currentRule.nameForConcat; format="cap">Context {
 	<attrs:{a | <accessLevelNotOpen(parser)> var <a>}; separator="\n">
 	<getters:{g | <g>}; separator="\n">
 
 	<accessLevelNotOpen(parser)>
-	init(_ ctx: <currentRule.name; format="cap">Context) {
+	init(_ ctx: <currentRule.nameForConcat; format="cap">Context) {
 		super.init()
 		copyFrom(ctx)
 	}
@@ -989,13 +989,13 @@ Lexer(lexer, atn, actionFuncs, sempredFuncs, superClass) ::= <<
 	<accessLevelNotOpen(lexer)>
 	static let <lexer.channels:{k | <k>=<lexer.channels.(k)>}; separator=", ", wrap, anchor>
 	<endif>
-	<if(rest(lexer.modes))>
+	<if(rest(lexer.runtimeModeNames))>
 	<accessLevelNotOpen(lexer)>
-	static let <rest(lexer.modes):{m| <m>=<i>}; separator=", ", wrap, anchor>
+	static let <rest(lexer.runtimeModeNames):{m| <m>=<i>}; separator=", ", wrap, anchor>
 	<endif>
 	<accessLevelNotOpen(lexer)>
 	static let channelNames: [String] = [
-		"DEFAULT_TOKEN_CHANNEL", "HIDDEN"<if (lexer.channels)>, <lexer.channels:{c| "<c>"}; separator=", ", wrap, anchor><endif>
+		"DEFAULT_TOKEN_CHANNEL", "HIDDEN"<if (lexer.channelNames)>, <lexer.channelNames:{c| "<c>"}; separator=", ", wrap, anchor><endif>
 	]
 
 	<accessLevelNotOpen(lexer)>