diff --git a/CHANGES.txt b/CHANGES.txt
index 28fbc2c9bd..82936d6771 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -1,5 +1,13 @@
 ANTLR v4 Honey Badger early access
 
+Feb 17, 2012
+
+* names changed. visit() -> visitX(). enter/exit() -> enter/exitX()
+* capitalizing automatically now. rule s -> SContext not sContext
+* no enter/exit method in generic rule context object if rule has alt labels, nor in interfaces.
+* dup labels allowed in same rule
+* label X or x illegal if rule x exists
+
 Feb 14, 2012
 
 * Fixed https://github.com/antlr/antlr4/issues/8 and lots of other little things.
diff --git a/tool/playground/A.g4 b/tool/playground/A.g4
index 9c2d6ea73d..c62a6be7c9 100644
--- a/tool/playground/A.g4
+++ b/tool/playground/A.g4
@@ -4,9 +4,17 @@ s : e ;
 
 e : e '*' e 		-> Mult
   | e '+' e 		-> Add
-  | INT        		-> Int
+  | INT        		-> primary
+  | ID        		-> primary
   | '(' e ')'		-> Parens
   ;
 
+/*
+primary : EEE;
+
+add : A ;
+*/
+
+ID : [a-z]+ ;
 INT : [0-9]+ ;
 WS : [ \t\n]+ -> skip ;
diff --git a/tool/playground/AVisitor.java b/tool/playground/AVisitor.java
index 5730fa2d6b..42686165fa 100644
--- a/tool/playground/AVisitor.java
+++ b/tool/playground/AVisitor.java
@@ -1,10 +1,7 @@
-import org.antlr.v4.runtime.tree.*;
-import org.antlr.v4.runtime.Token;
-
 public interface AVisitor<T> {
-	T visit(AParser.MultContext ctx);
-	T visit(AParser.ParensContext ctx);
-	T visit(AParser.sContext ctx);
-	T visit(AParser.AddContext ctx);
-	T visit(AParser.IntContext ctx);
+	T visitMult(AParser.MultContext ctx);
+	T visitParens(AParser.ParensContext ctx);
+	T visitS(AParser.SContext ctx);
+	T visitPrimary(AParser.PrimaryContext ctx);
+	T visitAdd(AParser.AddContext ctx);
 }
\ No newline at end of file
diff --git a/tool/playground/TestA.java b/tool/playground/TestA.java
index 5548162731..8798d31bf4 100644
--- a/tool/playground/TestA.java
+++ b/tool/playground/TestA.java
@@ -27,13 +27,9 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-import org.antlr.v4.runtime.ANTLRFileStream;
-import org.antlr.v4.runtime.CommonTokenStream;
-import org.antlr.v4.runtime.ParserRuleContext;
-import org.antlr.v4.runtime.Token;
-import org.antlr.v4.runtime.tree.ParseTreeWalker;
+import org.antlr.v4.runtime.*;
 
-import java.util.Stack;
+import java.io.*;
 
 public class TestA {
 	/** An example listener that uses a stack to store return values
@@ -66,45 +62,112 @@ public class TestA {
 	 *  Compare this to A2.g4, which adds a field to the context objects
 	 *  by using a "returns [int v]" on the expression rule.
 	 */
-	public static class Do extends ABaseListener {
-		Stack<Integer> results = new Stack<Integer>();
+//	public static class Do extends ABaseListener {
+//		Stack<Integer> results = new Stack<Integer>();
+//
+//		@Override
+//		public void exit(AParser.AddContext ctx) {
+//			results.push( results.pop() + results.pop() );
+//			System.out.println("Add: " + results.peek());
+//		}
+//
+//		@Override
+//		public void exit(AParser.IntContext ctx) {
+//			results.push( Integer.valueOf(ctx.INT().getText()) );
+//			System.out.println("Int: "+results.peek());
+//		}
+//
+//		@Override
+//		public void exit(AParser.MultContext ctx) {
+//			results.push( results.pop() * results.pop() );
+//			System.out.println("Mult: " + results.peek());
+//		}
+//
+//		@Override
+//		public void exit(AParser.ParensContext ctx) {
+//			// result already on stack
+//			System.out.println("Parens: "+results.peek());
+//		}
+//	}
+	public static class Tracer extends ABaseListener {
+		@Override
+		public void enterAdd(AParser.AddContext ctx) {
+			printMethodName(ctx);
+		}
+
+		@Override
+		public void enterEveryRule(ParserRuleContext<Token> ctx) {
+			printMethodName(ctx);
+		}
+
+		@Override
+		public void enterMult(AParser.MultContext ctx) {
+			printMethodName(ctx);
+		}
+
+		@Override
+		public void enterParens(AParser.ParensContext ctx) {
+			printMethodName(ctx);
+		}
 
 		@Override
-		public void exit(AParser.AddContext ctx) {
-			results.push( results.pop() + results.pop() );
-			System.out.println("Add: " + results.peek());
+		public void enterS(AParser.SContext ctx) {
+			printMethodName(ctx);
 		}
 
 		@Override
-		public void exit(AParser.IntContext ctx) {
-			results.push( Integer.valueOf(ctx.INT().getText()) );
-			System.out.println("Int: "+results.peek());
+		public void exitAdd(AParser.AddContext ctx) {
+			printMethodName(ctx);
 		}
 
 		@Override
-		public void exit(AParser.MultContext ctx) {
-			results.push( results.pop() * results.pop() );
-			System.out.println("Mult: " + results.peek());
+		public void exitMult(AParser.MultContext ctx) {
+			printMethodName(ctx);
 		}
 
 		@Override
-		public void exit(AParser.ParensContext ctx) {
-			// result already on stack
-			System.out.println("Parens: "+results.peek());
+		public void exitParens(AParser.ParensContext ctx) {
+			printMethodName(ctx);
+		}
+
+		@Override
+		public void exitS(AParser.SContext ctx) {
+			printMethodName(ctx);
+		}
+
+		@Override
+		public void exitEveryRule(ParserRuleContext<Token> ctx) {
+			printMethodName(ctx);
+		}
+
+		@Override
+		public void visitTerminal(ParserRuleContext<Token> ctx, Token symbol) {
+			printMethodName(ctx);
+		}
+
+		public void printMethodName(ParserRuleContext ctx) {
+			Throwable t = new Throwable();
+			StackTraceElement[] stack = t.getStackTrace();
+			String m = stack[1].getMethodName();
+			System.out.println(m+"("+ctx.getClass().getSimpleName()+")");
 		}
 	}
 	public static void main(String[] args) throws Exception {
-		ALexer lexer = new ALexer(new ANTLRFileStream(args[0]));
+		InputStream is = System.in;
+		if ( args.length>0 && args[0]!=null ) {
+			is = new FileInputStream(args[0]);
+		}
+		ALexer lexer = new ALexer(new ANTLRInputStream(is));
 		CommonTokenStream tokens = new CommonTokenStream(lexer);
 		AParser p = new AParser(tokens);
 		p.setBuildParseTree(true);
-		p.addParseListener(new Do());
+		p.addParseListener(new Tracer());
 		ParserRuleContext<Token> t = p.s();
 		System.out.println("tree = "+t.toStringTree(p));
 
-		ParseTreeWalker walker = new ParseTreeWalker();
-		Do doer = new Do();
-		walker.walk(doer, t);
-		System.out.println("result from tree walk = "+ doer.results.pop());
+//		ParseTreeWalker walker = new ParseTreeWalker();
+//		Do doer = new Do();
+//		walker.walk(doer, t);
+//		System.out.println("result from tree walk = "+ doer.results.pop());
 	}
 }
diff --git a/tool/playground/TestVisitor.java b/tool/playground/TestVisitor.java
index 6d7e240cb5..4fd8f71f3d 100644
--- a/tool/playground/TestVisitor.java
+++ b/tool/playground/TestVisitor.java
@@ -28,33 +28,27 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  */
 
 import org.antlr.v4.runtime.*;
-import org.antlr.v4.runtime.tree.ParseTreeVisitor;
 
 public class TestVisitor {
 	public static class MyVisitor extends ABaseVisitor<Integer> implements AVisitor<Integer> {
 		@Override
-		public Integer visit(AParser.AddContext ctx) {
+		public Integer visitAdd(AParser.AddContext ctx) {
 			return ctx.e(0).accept(this) + ctx.e(1).accept(this);
 		}
 
 		@Override
-		public Integer visit(AParser.IntContext ctx) {
-			return Integer.valueOf(ctx.INT().getText());
-		}
-
-		@Override
-		public Integer visit(AParser.MultContext ctx) {
+		public Integer visitMult(AParser.MultContext ctx) {
 //			return ctx.e(0).accept(this) * ctx.e(1).accept(this);
 			return visit(ctx.e(0)) * visit(ctx.e(1));
 		}
 
 		@Override
-		public Integer visit(AParser.ParensContext ctx) {
+		public Integer visitParens(AParser.ParensContext ctx) {
 			return ctx.e().accept(this);
 		}
 
 		@Override
-		public Integer visit(AParser.sContext ctx) {
+		public Integer visitS(AParser.SContext ctx) {
 			return visit(ctx.e());
 			//return ctx.e().accept(this);
 		}
diff --git a/tool/resources/org/antlr/v4/tool/templates/codegen/Java/Java.stg b/tool/resources/org/antlr/v4/tool/templates/codegen/Java/Java.stg
index 6fd56d759f..8896567ec0 100644
--- a/tool/resources/org/antlr/v4/tool/templates/codegen/Java/Java.stg
+++ b/tool/resources/org/antlr/v4/tool/templates/codegen/Java/Java.stg
@@ -34,8 +34,8 @@ import org.antlr.v4.runtime.Token;
 
 public interface <file.grammarName>Listener extends ParseTreeListener\<<InputSymbolType()>\> {
 	<file.listenerNames:{lname |
-void enter(<file.parserName>.<lname>Context ctx);
-void exit(<file.parserName>.<lname>Context ctx);}; separator="\n">
+void enter<lname; format="cap">(<file.parserName>.<lname; format="cap">Context ctx);
+void exit<lname; format="cap">(<file.parserName>.<lname; format="cap">Context ctx);}; separator="\n">
 }
 >>
 
@@ -47,8 +47,8 @@ import org.antlr.v4.runtime.Token;
 
 public class <file.grammarName>BaseListener implements <file.grammarName>Listener {
 	<file.listenerNames:{lname |
-@Override public void enter(<file.parserName>.<lname>Context ctx) { \}
-@Override public void exit(<file.parserName>.<lname>Context ctx) { \}}; separator="\n">
+@Override public void enter<lname; format="cap">(<file.parserName>.<lname; format="cap">Context ctx) { \}
+@Override public void exit<lname; format="cap">(<file.parserName>.<lname; format="cap">Context ctx) { \}}; separator="\n">
 
 	@Override public void enterEveryRule(ParserRuleContext\<<InputSymbolType()>\> ctx) { }
 	@Override public void exitEveryRule(ParserRuleContext\<<InputSymbolType()>\> ctx) { }
@@ -63,7 +63,7 @@ import org.antlr.v4.runtime.Token;
 
 public interface <file.grammarName>Visitor\<T> {
 	<file.visitorNames:{lname |
-T visit(<file.parserName>.<lname>Context ctx);}; separator="\n">
+T visit<lname; format="cap">(<file.parserName>.<lname; format="cap">Context ctx);}; separator="\n">
 }
 >>
 
@@ -74,7 +74,7 @@ import org.antlr.v4.runtime.Token;
 
 public class <file.grammarName>BaseVisitor\<T> extends ParseTreeVisitor\<T> implements <file.grammarName>Visitor\<T> {
 	<file.visitorNames:{lname |
-public T visit(<file.parserName>.<lname>Context ctx) { visitChildren(ctx); return null; \}}; separator="\n">
+public T visit<lname; format="cap">(<file.parserName>.<lname; format="cap">Context ctx) { visitChildren(ctx); return null; \}}; separator="\n">
 }
 >>
 
@@ -237,7 +237,7 @@ LeftRecursiveRuleFunction(currentRule,code,locals,ruleCtx,altLabelCtxs,
 >>
 
 CodeBlockForOuterMostAlt(currentOuterMostAltCodeBlock, locals, preamble, ops) ::= <<
-<if(currentOuterMostAltCodeBlock.altLabel)>_localctx = new <currentOuterMostAltCodeBlock.altLabel>Context(_localctx);<endif>
+<if(currentOuterMostAltCodeBlock.altLabel)>_localctx = new <currentOuterMostAltCodeBlock.altLabel; format="cap">Context(_localctx);<endif>
 enterOuterAlt(_localctx, <currentOuterMostAltCodeBlock.alt.altNum>);
 <CodeBlockForAlt(currentAltCodeBlock=currentOuterMostAltCodeBlock, ...)>
 >>
@@ -503,9 +503,9 @@ ThisRulePropertyRef_stop(r)	 ::= "_localctx.stop"
 ThisRulePropertyRef_text(r)	 ::= "_input.toString(_localctx.start, _input.LT(-1))"
 ThisRulePropertyRef_ctx(r)	 ::= "_localctx"
 
-NonLocalAttrRef(s)		 ::= "((<s.ruleName>Context)getInvokingContext(<s.ruleIndex>)).<s.name>"
+NonLocalAttrRef(s)		 ::= "((<s.ruleName; format=\"cap\">Context)getInvokingContext(<s.ruleIndex>)).<s.name>"
 SetNonLocalAttr(s, rhsChunks)	  ::=
-	"((<s.ruleName>Context)getInvokingContext(<s.ruleIndex>)).<s.name> = <rhsChunks>;"
+	"((<s.ruleName; format=\"cap\">Context)getInvokingContext(<s.ruleIndex>)).<s.name> = <rhsChunks>;"
 
 AddToLabelList(a) ::= "<ctx(a.label)>.<a.listName>.add(<labelref(a.label)>);"
 
@@ -526,17 +526,17 @@ public Token <t.name>(int i) {
 >>
 ContextRuleGetterDecl(r)       ::= <<
 public <r.ctxName> <r.name>() {
-    return (<r.ctxName>)getRuleContext(<r.ctxName>.class,0);
+    return getRuleContext(<r.ctxName>.class,0);
 }
 >>
 ContextRuleListGetterDecl(r)   ::= <<
 public List\<? extends <r.ctxName>\> <r.name>() {
-    return (List\<<r.ctxName>\>)getRuleContexts(<r.ctxName>.class);
+    return getRuleContexts(<r.ctxName>.class);
 }
 >>
 ContextRuleListIndexedGetterDecl(r)   ::= <<
 public <r.ctxName> <r.name>(int i) {
-    return (<r.ctxName>)getRuleContext(<r.ctxName>.class,i);
+    return getRuleContext(<r.ctxName>.class,i);
 }
 >>
 
@@ -555,21 +555,21 @@ ListLabelName(label)		  ::= "<label>"
 CaptureNextToken(d) ::= "<d.varName> = _input.LT(1);"
 CaptureNextTokenType(d) ::= "<d.varName> = _input.LA(1);"
 
-StructDecl(s,attrs,getters,dispatchMethods,interfaces,extensionMembers,
+StructDecl(struct,attrs,getters,dispatchMethods,interfaces,extensionMembers,
            superClass={ParserRuleContext\<<InputSymbolType()>>}) ::= <<
-public static class <s.name> extends <superClass><if(interfaces)> implements <interfaces; separator=", "><endif> {
+public static class <struct.name> extends <superClass><if(interfaces)> implements <interfaces; separator=", "><endif> {
 	<attrs:{a | <a>}; separator="\n">
 	<getters:{g | <g>}; separator="\n">
-	<if(s.ctorAttrs)>public <s.name>(ParserRuleContext\<<InputSymbolType()>\> parent, int state) { super(parent, state); }<endif>
-	public <s.name>(ParserRuleContext\<<InputSymbolType()>\> parent, int state<s.ctorAttrs:{a | , <a>}>) {
+	<if(struct.ctorAttrs)>public <struct.name>(ParserRuleContext\<<InputSymbolType()>\> parent, int state) { super(parent, state); }<endif>
+	public <struct.name>(ParserRuleContext\<<InputSymbolType()>\> parent, int state<struct.ctorAttrs:{a | , <a>}>) {
 		super(parent, state);
-		<s.ctorAttrs:{a | this.<a.name> = <a.name>;}; separator="\n">
+		<struct.ctorAttrs:{a | this.<a.name> = <a.name>;}; separator="\n">
 	}
-<if(s.provideCopyFrom)> <! don't need copy unless we have subclasses !>
-	public <s.name>() { }
-	public void copyFrom(<s.name> ctx) {
+<if(struct.provideCopyFrom)> <! don't need copy unless we have subclasses !>
+	public <struct.name>() { }
+	public void copyFrom(<struct.name> ctx) {
 		super.copyFrom(ctx);
-		<s.attrs:{a | this.<a.name> = ctx.<a.name>;}; separator="\n">
+		<struct.attrs:{a | this.<a.name> = ctx.<a.name>;}; separator="\n">
 	}
 <endif>
 	<dispatchMethods; separator="\n">
@@ -577,11 +577,11 @@ public static class <s.name> extends <superClass><if(interfaces)> implements <in
 }
 >>
 
-AltLabelStructDecl(s,attrs,getters,dispatchMethods) ::= <<
-public static class <s.name> extends <currentRule.name>Context {
+AltLabelStructDecl(struct,attrs,getters,dispatchMethods) ::= <<
+public static class <struct.name> extends <currentRule.name; format="cap">Context {
 	<attrs:{a | <a>}; separator="\n">
 	<getters:{g | <g>}; separator="\n">
-	public <s.name>(<currentRule.name>Context ctx) { copyFrom(ctx); }
+	public <struct.name>(<currentRule.name; format="cap">Context ctx) { copyFrom(ctx); }
 	<dispatchMethods; separator="\n">
 }
 >>
@@ -589,14 +589,14 @@ public static class <s.name> extends <currentRule.name>Context {
 ListenerDispatchMethod(method) ::= <<
 @Override
 public void <if(method.isEnter)>enter<else>exit<endif>Rule(ParseTreeListener\<<InputSymbolType()>\> listener) {
-	if ( listener instanceof <parser.grammarName>Listener ) ((<parser.grammarName>Listener)listener).<if(method.isEnter)>enter<else>exit<endif>(this);
+	if ( listener instanceof <parser.grammarName>Listener ) ((<parser.grammarName>Listener)listener).<if(method.isEnter)>enter<else>exit<endif><struct.derivedFromName; format="cap">(this);
 }
 >>
 
 VisitorDispatchMethod(method) ::= <<
 @Override
 public \<T> T accept(ParseTreeVisitor\<? extends T> visitor) { 
-    if ( visitor instanceof <parser.grammarName>Visitor ) return ((<parser.grammarName>Visitor\<T>)visitor).visit(this);
+    if ( visitor instanceof <parser.grammarName>Visitor ) return ((<parser.grammarName>Visitor\<T>)visitor).visit<struct.derivedFromName; format="cap">(this);
     else return null;
 }
 >>
@@ -626,9 +626,9 @@ _localctx.start = _prevctx.start;
 >>
 
 recRuleLabeledAltStartAction(ruleName, currentAltLabel, label) ::= <<
-_localctx = new <currentAltLabel>Context(new <ruleName>Context(_parentctx, _startState, _p));
+_localctx = new <currentAltLabel; format="cap">Context(new <ruleName; format="cap">Context(_parentctx, _startState, _p));
 _localctx.addChild(_prevctx);
-<if(label)>((<currentAltLabel>Context)_localctx).<label> = _prevctx;<endif>
+<if(label)>((<currentAltLabel; format="cap">Context)_localctx).<label> = _prevctx;<endif>
 pushNewRecursionContext(_localctx, RULE_<ruleName>);
 _localctx.start = _prevctx.start;
 >>
diff --git a/tool/src/org/antlr/v4/analysis/LeftRecursiveRuleTransformer.java b/tool/src/org/antlr/v4/analysis/LeftRecursiveRuleTransformer.java
index 742f391b4d..3f100f3834 100644
--- a/tool/src/org/antlr/v4/analysis/LeftRecursiveRuleTransformer.java
+++ b/tool/src/org/antlr/v4/analysis/LeftRecursiveRuleTransformer.java
@@ -31,14 +31,12 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 
 import org.antlr.runtime.*;
 import org.antlr.v4.Tool;
-import org.antlr.v4.misc.OrderedHashMap;
-import org.antlr.v4.misc.Pair;
+import org.antlr.v4.misc.*;
 import org.antlr.v4.parse.*;
 import org.antlr.v4.tool.*;
 import org.antlr.v4.tool.ast.*;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.util.*;
 
 /** Remove left-recursive rule refs, add precedence args to recursive rule refs.
  *  Rewrite rule so we can create ATN.
@@ -47,10 +45,10 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  */
 public class LeftRecursiveRuleTransformer {
 	public GrammarRootAST ast;
-	public List<Rule> rules;
+	public Collection<Rule> rules;
 	public Tool tool;
 
-	public LeftRecursiveRuleTransformer(GrammarRootAST ast, List<Rule> rules, Tool tool) {
+	public LeftRecursiveRuleTransformer(GrammarRootAST ast, Collection<Rule> rules, Tool tool) {
 		this.ast = ast;
 		this.rules = rules;
 		this.tool = tool;
diff --git a/tool/src/org/antlr/v4/codegen/CodeGenerator.java b/tool/src/org/antlr/v4/codegen/CodeGenerator.java
index eaf9cba065..418f7c8340 100644
--- a/tool/src/org/antlr/v4/codegen/CodeGenerator.java
+++ b/tool/src/org/antlr/v4/codegen/CodeGenerator.java
@@ -104,6 +104,7 @@ public void loadTemplates(String language) {
 		try {
 			templates = new STGroupFile(TEMPLATE_ROOT+"/"+language+"/"+language+".stg");
 			templates.registerRenderer(Integer.class, new NumberRenderer());
+			templates.registerRenderer(String.class, new StringRenderer());
 		}
 		catch (IllegalArgumentException iae) {
 			tool.errMgr.toolError(ErrorType.CANNOT_CREATE_TARGET_GENERATOR,
diff --git a/tool/src/org/antlr/v4/codegen/OutputModelController.java b/tool/src/org/antlr/v4/codegen/OutputModelController.java
index 9827eaf85e..b8894b2b94 100644
--- a/tool/src/org/antlr/v4/codegen/OutputModelController.java
+++ b/tool/src/org/antlr/v4/codegen/OutputModelController.java
@@ -33,6 +33,7 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 import org.antlr.v4.analysis.LeftRecursiveRuleAltInfo;
 import org.antlr.v4.codegen.model.*;
 import org.antlr.v4.codegen.model.decl.CodeBlock;
+import org.antlr.v4.misc.Utils;
 import org.antlr.v4.parse.*;
 import org.antlr.v4.tool.*;
 import org.antlr.v4.tool.ast.*;
@@ -213,7 +214,7 @@ public void buildLeftRecursiveRuleFunction(LeftRecursiveRule r, LeftRecursiveRul
 			LeftRecursiveRuleAltInfo altInfo = r.recPrimaryAlts.get(i);
 			if ( altInfo.altLabel==null ) continue;
 			ST altActionST = codegenTemplates.getInstanceOf("recRuleReplaceContext");
-			altActionST.add("ctxName", altInfo.altLabel);
+			altActionST.add("ctxName", Utils.capitalize(altInfo.altLabel));
 			Action altAction =
 				new Action(delegate, function.altLabelCtxs.get(altInfo.altLabel), altActionST);
 			CodeBlockForAlt alt = primaryAltsCode.get(i);
@@ -240,7 +241,7 @@ public void buildLeftRecursiveRuleFunction(LeftRecursiveRule r, LeftRecursiveRul
 			}
 			else {
 				altActionST = codegenTemplates.getInstanceOf("recRuleAltStartAction");
-				altActionST.add("ctxName", r.name);
+				altActionST.add("ctxName", Utils.capitalize(r.name));
 			}
 			altActionST.add("ruleName", r.name);
 			// add label of any lr ref we deleted
diff --git a/tool/src/org/antlr/v4/codegen/Target.java b/tool/src/org/antlr/v4/codegen/Target.java
index 871f288959..d0ea5973c4 100644
--- a/tool/src/org/antlr/v4/codegen/Target.java
+++ b/tool/src/org/antlr/v4/codegen/Target.java
@@ -30,11 +30,10 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 package org.antlr.v4.codegen;
 
 import org.antlr.v4.codegen.model.RuleFunction;
+import org.antlr.v4.misc.Utils;
 import org.antlr.v4.parse.ANTLRParser;
-import org.antlr.v4.runtime.Lexer;
-import org.antlr.v4.runtime.Token;
-import org.antlr.v4.tool.Grammar;
-import org.antlr.v4.tool.Rule;
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.tool.*;
 import org.antlr.v4.tool.ast.GrammarAST;
 import org.stringtemplate.v4.ST;
 
@@ -332,7 +331,11 @@ public String getRuleFunctionContextStructName(Rule r) {
 		if ( r.g.isLexer() ) {
 			return gen.templates.getInstanceOf("LexerRuleContext").render();
 		}
-		return r.name+gen.templates.getInstanceOf("RuleContextNameSuffix").render();
+		return Utils.capitalize(r.name)+gen.templates.getInstanceOf("RuleContextNameSuffix").render();
+	}
+
+	public String getAltLabelContextStructName(String label) {
+		return Utils.capitalize(label)+gen.templates.getInstanceOf("RuleContextNameSuffix").render();
 	}
 
 	/** If we know which actual function, we can provide the actual ctx type.
@@ -345,7 +348,7 @@ public String getRuleFunctionContextStructName(RuleFunction function) {
 		if ( r.g.isLexer() ) {
 			return gen.templates.getInstanceOf("LexerRuleContext").render();
 		}
-		return r.name+gen.templates.getInstanceOf("RuleContextNameSuffix").render();
+		return Utils.capitalize(r.name)+gen.templates.getInstanceOf("RuleContextNameSuffix").render();
 	}
 
 	// should be same for all refs to same token like $ID within single rule function
diff --git a/tool/src/org/antlr/v4/codegen/model/ListenerFile.java b/tool/src/org/antlr/v4/codegen/model/ListenerFile.java
index dda76c16be..3648db3ff6 100644
--- a/tool/src/org/antlr/v4/codegen/model/ListenerFile.java
+++ b/tool/src/org/antlr/v4/codegen/model/ListenerFile.java
@@ -24,12 +24,15 @@ public ListenerFile(OutputModelFactory factory, String fileName) {
 		grammarName = g.name;
 		for (Rule r : g.rules.values()) {
 			List<Triple<Integer,AltAST,String>> labels = r.getAltLabels();
-			listenerNames.add(r.name);
 			if ( labels!=null ) {
 				for (Triple<Integer,AltAST,String> pair : labels) {
 					listenerNames.add(pair.c);
 				}
 			}
+			else {
+				// only add rule context if no labels
+				listenerNames.add(r.name);
+			}
 		}
 		ActionAST ast = g.namedActions.get("header");
 		if ( ast!=null ) header = new Action(factory, ast);
diff --git a/tool/src/org/antlr/v4/codegen/model/decl/AltLabelStructDecl.java b/tool/src/org/antlr/v4/codegen/model/decl/AltLabelStructDecl.java
index 54ca3bc0c1..75308aeb4d 100644
--- a/tool/src/org/antlr/v4/codegen/model/decl/AltLabelStructDecl.java
+++ b/tool/src/org/antlr/v4/codegen/model/decl/AltLabelStructDecl.java
@@ -42,9 +42,8 @@ public AltLabelStructDecl(OutputModelFactory factory, Rule r,
 		super(factory, r);
 		this.altNum = altNum;
 		this.name = // override name set in super to the label ctx
-			label+
-			factory.getGenerator().templates
-			.getInstanceOf("RuleContextNameSuffix").render();
+			factory.getGenerator().target.getAltLabelContextStructName(label);
+		derivedFromName = label;
 	}
 
 	@Override
diff --git a/tool/src/org/antlr/v4/codegen/model/decl/StructDecl.java b/tool/src/org/antlr/v4/codegen/model/decl/StructDecl.java
index 0c3e2bef5b..c0a62e13b5 100644
--- a/tool/src/org/antlr/v4/codegen/model/decl/StructDecl.java
+++ b/tool/src/org/antlr/v4/codegen/model/decl/StructDecl.java
@@ -40,6 +40,7 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  *  return values, local variables, and labels associated with a rule.
  */
 public class StructDecl extends Decl {
+	public String derivedFromName; // rule name or label name
 	public boolean provideCopyFrom;
 	@ModelElement public OrderedHashSet<Decl> attrs = new OrderedHashSet<Decl>();
 	@ModelElement public OrderedHashSet<Decl> getters = new OrderedHashSet<Decl>();
@@ -51,15 +52,19 @@ public class StructDecl extends Decl {
 	public StructDecl(OutputModelFactory factory, Rule r) {
 		super(factory, factory.getGenerator().target.getRuleFunctionContextStructName(r));
 		addDispatchMethods(r);
+		derivedFromName = r.name;
 		provideCopyFrom = r.hasAltSpecificContexts();
 	}
 
 	public void addDispatchMethods(Rule r) {
 		dispatchMethods = new ArrayList<DispatchMethod>();
-		dispatchMethods.add(new ListenerDispatchMethod(factory, true));
-		dispatchMethods.add(new ListenerDispatchMethod(factory, false));
-		if ( factory.getGrammar().tool.gen_visitor && !r.hasAltSpecificContexts() ) {
-			dispatchMethods.add(new VisitorDispatchMethod(factory));
+		if ( !r.hasAltSpecificContexts() ) {
+			// no enter/exit for this ruleContext if rule has labels
+			dispatchMethods.add(new ListenerDispatchMethod(factory, true));
+			dispatchMethods.add(new ListenerDispatchMethod(factory, false));
+			if ( factory.getGrammar().tool.gen_visitor ) {
+				dispatchMethods.add(new VisitorDispatchMethod(factory));
+			}
 		}
 	}
 
diff --git a/tool/src/org/antlr/v4/misc/Utils.java b/tool/src/org/antlr/v4/misc/Utils.java
index 65f921c88d..01336f79f5 100644
--- a/tool/src/org/antlr/v4/misc/Utils.java
+++ b/tool/src/org/antlr/v4/misc/Utils.java
@@ -31,9 +31,7 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 
 import org.antlr.v4.tool.ast.GrammarAST;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
+import java.util.*;
 
 /** */
 public class Utils {
@@ -146,6 +144,14 @@ public static int[] toIntArray(List<Integer> list) {
 		return a;
 	}
 
+	public static String capitalize(String s) {
+		return Character.toUpperCase(s.charAt(0)) + s.substring(1);
+	}
+
+	public static String decapitalize(String s) {
+		return Character.toLowerCase(s.charAt(0)) + s.substring(1);
+	}
+
 	public static char[] toCharArray(List<Integer> data) {
 		if ( data==null ) return null;
 		char[] cdata = new char[data.size()];
diff --git a/tool/src/org/antlr/v4/semantics/BasicSemanticChecks.java b/tool/src/org/antlr/v4/semantics/BasicSemanticChecks.java
index 137326bbfb..1c324d75a3 100644
--- a/tool/src/org/antlr/v4/semantics/BasicSemanticChecks.java
+++ b/tool/src/org/antlr/v4/semantics/BasicSemanticChecks.java
@@ -31,11 +31,8 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 
 import org.antlr.runtime.Token;
 import org.antlr.v4.misc.Utils;
-import org.antlr.v4.parse.ANTLRParser;
-import org.antlr.v4.parse.GrammarTreeVisitor;
-import org.antlr.v4.tool.ErrorManager;
-import org.antlr.v4.tool.ErrorType;
-import org.antlr.v4.tool.Grammar;
+import org.antlr.v4.parse.*;
+import org.antlr.v4.tool.*;
 import org.antlr.v4.tool.ast.*;
 import org.stringtemplate.v4.misc.MultiMap;
 
@@ -139,10 +136,12 @@ public class BasicSemanticChecks extends GrammarTreeVisitor {
 		};
 
 	public Grammar g;
+	public RuleCollector ruleCollector;
 	public ErrorManager errMgr;
 
-	public BasicSemanticChecks(Grammar g) {
+	public BasicSemanticChecks(Grammar g, RuleCollector ruleCollector) {
 		this.g = g;
+		this.ruleCollector = ruleCollector;
 		this.errMgr = g.tool.errMgr;
 	}
 
@@ -239,38 +238,43 @@ public void elementOption(GrammarASTWithOptions elem, GrammarAST ID, GrammarAST
 //		}
 	}
 
-	Map<String,String> altLabelToRuleName = new HashMap<String, String>();
-
 	@Override
 	public void finishRule(RuleAST rule, GrammarAST ID, GrammarAST block) {
-		MultiMap<String,GrammarAST> ruleToAltLabels = new MultiMap<String, GrammarAST>();
 		if ( rule.isLexerRule() ) return;
 		BlockAST blk = (BlockAST)rule.getFirstChildWithType(BLOCK);
 		int nalts = blk.getChildCount();
+		GrammarAST idAST = (GrammarAST)rule.getChild(0);
 		for (int i=0; i< nalts; i++) {
 			AltAST altAST = (AltAST)blk.getChild(i);
 			if ( altAST.altLabel!=null ) {
-				ruleToAltLabels.map(rule.getRuleName(), altAST.altLabel);
 				String altLabel = altAST.altLabel.getText();
-				String prevRuleForLabel = altLabelToRuleName.get(altLabel);
-				if ( prevRuleForLabel!=null ) {
+				// first check that label doesn't conflict with a rule
+				// label X or x can't be rule x.
+				Rule r = ruleCollector.rules.get(Utils.decapitalize(altLabel));
+				if ( r!=null ) {
+					g.tool.errMgr.grammarError(ErrorType.ALT_LABEL_CONFLICTS_WITH_RULE,
+											   g.fileName, altAST.altLabel.token,
+											   altLabel,
+											   r.name);
+				}
+				// Now verify that label X or x doesn't conflict with label
+				// in another rule. altLabelToRuleName has both X and x mapped.
+				String prevRuleForLabel = ruleCollector.altLabelToRuleName.get(altLabel);
+				if ( prevRuleForLabel!=null && !prevRuleForLabel.equals(rule.getRuleName()) ) {
 					g.tool.errMgr.grammarError(ErrorType.ALT_LABEL_REDEF,
-											   g.fileName, rule.getToken(),
+											   g.fileName, altAST.altLabel.token,
 											   altLabel,
 											   rule.getRuleName(),
 											   prevRuleForLabel);
 				}
-				else {
-					altLabelToRuleName.put(altLabel, rule.getRuleName());
-				}
 			}
 		}
-		List<GrammarAST> altLabels = ruleToAltLabels.get(rule.getRuleName());
+		List<GrammarAST> altLabels = ruleCollector.ruleToAltLabels.get(rule.getRuleName());
 		int numAltLabels = 0;
 		if ( altLabels!=null ) numAltLabels = altLabels.size();
 		if ( numAltLabels>0 && nalts != numAltLabels ) {
 			g.tool.errMgr.grammarError(ErrorType.RULE_WITH_TOO_FEW_ALT_LABELS,
-									   g.fileName, rule.getToken(), rule.getRuleName());
+									   g.fileName, idAST.token, rule.getRuleName());
 		}
 	}
 
diff --git a/tool/src/org/antlr/v4/semantics/RuleCollector.java b/tool/src/org/antlr/v4/semantics/RuleCollector.java
index e9d051a3e3..b0d2c2bf51 100644
--- a/tool/src/org/antlr/v4/semantics/RuleCollector.java
+++ b/tool/src/org/antlr/v4/semantics/RuleCollector.java
@@ -30,25 +30,24 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 package org.antlr.v4.semantics;
 
 import org.antlr.v4.analysis.LeftRecursiveRuleAnalyzer;
-import org.antlr.v4.parse.GrammarTreeVisitor;
-import org.antlr.v4.parse.ScopeParser;
-import org.antlr.v4.tool.AttributeDict;
-import org.antlr.v4.tool.Grammar;
-import org.antlr.v4.tool.LeftRecursiveRule;
-import org.antlr.v4.tool.Rule;
-import org.antlr.v4.tool.ast.ActionAST;
-import org.antlr.v4.tool.ast.GrammarAST;
-import org.antlr.v4.tool.ast.RuleAST;
-
-import java.util.ArrayList;
-import java.util.List;
+import org.antlr.v4.misc.*;
+import org.antlr.v4.parse.*;
+import org.antlr.v4.tool.*;
+import org.antlr.v4.tool.ast.*;
+import org.stringtemplate.v4.misc.MultiMap;
+
+import java.util.*;
 
 public class RuleCollector extends GrammarTreeVisitor {
 	/** which grammar are we checking */
 	public Grammar g;
 
 	// stuff to collect. this is the output
-	public List<Rule> rules = new ArrayList<Rule>();
+	public OrderedHashMap<String, Rule> rules = new OrderedHashMap<String, Rule>();
+	public MultiMap<String,GrammarAST> ruleToAltLabels = new MultiMap<String, GrammarAST>();
+	public Map<String,String> altLabelToRuleName = new HashMap<String, String>();
+
+	public Rule currentRule;
 
 	public RuleCollector(Grammar g) { this.g = g; }
 
@@ -70,7 +69,7 @@ public void discoverRule(RuleAST rule, GrammarAST ID,
 		else {
 			r = new Rule(g, ID.getText(), rule, numAlts);
 		}
-		rules.add(r);
+		rules.put(r.name, r);
 
 		if ( arg!=null ) {
 			r.args = ScopeParser.parseTypedArgList(arg.getText(), g.tool.errMgr);
@@ -99,6 +98,16 @@ public void discoverRule(RuleAST rule, GrammarAST ID,
 		}
 	}
 
+	@Override
+	public void discoverOuterAlt(AltAST alt) {
+		if ( alt.altLabel!=null ) {
+			ruleToAltLabels.map(currentRuleName, alt.altLabel);
+			String altLabel = alt.altLabel.getText();
+			altLabelToRuleName.put(Utils.capitalize(altLabel), currentRuleName);
+			altLabelToRuleName.put(Utils.decapitalize(altLabel), currentRuleName);
+		}
+	}
+
 	@Override
 	public void discoverLexerRule(RuleAST rule, GrammarAST ID, List<GrammarAST> modifiers,
 								  GrammarAST block)
@@ -107,6 +116,6 @@ public void discoverLexerRule(RuleAST rule, GrammarAST ID, List<GrammarAST> modi
 		Rule r = new Rule(g, ID.getText(), rule, numAlts);
 		r.mode = currentModeName;
 		if ( modifiers.size()>0 ) r.modifiers = modifiers;
-		rules.add(r);
+		rules.put(r.name, r);
 	}
 }
diff --git a/tool/src/org/antlr/v4/semantics/SemanticPipeline.java b/tool/src/org/antlr/v4/semantics/SemanticPipeline.java
index 10b9b8892d..127733b5d1 100644
--- a/tool/src/org/antlr/v4/semantics/SemanticPipeline.java
+++ b/tool/src/org/antlr/v4/semantics/SemanticPipeline.java
@@ -31,13 +31,10 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 
 import org.antlr.v4.analysis.LeftRecursiveRuleTransformer;
 import org.antlr.v4.parse.ANTLRParser;
-import org.antlr.v4.tool.Grammar;
-import org.antlr.v4.tool.Rule;
+import org.antlr.v4.tool.*;
 import org.antlr.v4.tool.ast.GrammarAST;
 
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 
 /** Do as much semantic checking as we can and fill in grammar
  *  with rules, actions, and token definitions.
@@ -72,24 +69,24 @@ public SemanticPipeline(Grammar g) {
 	public void process() {
 		if ( g.ast==null ) return;
 
+		// COLLECT RULE OBJECTS
+		RuleCollector ruleCollector = new RuleCollector(g);
+		ruleCollector.process(g.ast);
+
 		// DO BASIC / EASY SEMANTIC CHECKS
-		BasicSemanticChecks basics = new BasicSemanticChecks(g);
+		BasicSemanticChecks basics = new BasicSemanticChecks(g, ruleCollector);
 		basics.process();
 
 		// don't continue if we get errors in this basic check
 		if ( false ) return;
 
-		// COLLECT RULE OBJECTS
-		RuleCollector ruleCollector = new RuleCollector(g);
-		ruleCollector.process(g.ast);
-
 		// TRANSFORM LEFT-RECURSIVE RULES
 		LeftRecursiveRuleTransformer lrtrans =
-			new LeftRecursiveRuleTransformer(g.ast, ruleCollector.rules, g.tool);
+			new LeftRecursiveRuleTransformer(g.ast, ruleCollector.rules.values(), g.tool);
 		lrtrans.translateLeftRecursiveRules();
 
 		// STORE RULES IN GRAMMAR
-		for (Rule r : ruleCollector.rules) {
+		for (Rule r : ruleCollector.rules.values()) {
 			g.defineRule(r);
 		}
 
diff --git a/tool/src/org/antlr/v4/tool/ErrorType.java b/tool/src/org/antlr/v4/tool/ErrorType.java
index 94ecfbef43..c1aeaae20f 100644
--- a/tool/src/org/antlr/v4/tool/ErrorType.java
+++ b/tool/src/org/antlr/v4/tool/ErrorType.java
@@ -143,6 +143,7 @@ public enum ErrorType {
 	CANNOT_FIND_ATTRIBUTE_NAME_IN_DECL(121, "cannot find an attribute name in attribute declaration", ErrorSeverity.ERROR),
 	RULE_WITH_TOO_FEW_ALT_LABELS(122, "rule <arg>: must label all alternatives or none", ErrorSeverity.ERROR),
 	ALT_LABEL_REDEF(123, "rule alt label <arg> redefined in rule <arg2>, originally in <arg3>", ErrorSeverity.ERROR),
+	ALT_LABEL_CONFLICTS_WITH_RULE(124, "rule alt label <arg> conflicts with rule <arg2>", ErrorSeverity.ERROR),
 	/** Documentation comment is unterminated */
     //UNTERMINATED_DOC_COMMENT(, "", ErrorSeverity.ERROR),