From 8013bb868c5270a135f1701c49903d9e516e50fc Mon Sep 17 00:00:00 2001
From: Terence Parr <parrt@antlr.org>
Date: Wed, 15 Feb 2012 18:28:34 -0800
Subject: [PATCH 1/9] stash; got lost of visitor stuff working

---
 .../antlr/v4/runtime/ParserRuleContext.java   |  4 +-
 .../v4/runtime/tree/ParseTreeVisitor.java     | 27 +++++++
 tool/playground/ABaseVisitor.java             | 11 +++
 tool/playground/AVisitor.java                 | 11 +++
 tool/playground/TestVisitor.java              | 79 +++++++++++++++++++
 .../v4/tool/templates/codegen/Java/Java.stg   |  2 +
 6 files changed, 133 insertions(+), 1 deletion(-)
 create mode 100644 runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeVisitor.java
 create mode 100644 tool/playground/ABaseVisitor.java
 create mode 100644 tool/playground/AVisitor.java
 create mode 100644 tool/playground/TestVisitor.java

diff --git a/runtime/Java/src/org/antlr/v4/runtime/ParserRuleContext.java b/runtime/Java/src/org/antlr/v4/runtime/ParserRuleContext.java
index 70dac3a32e..ec112740eb 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/ParserRuleContext.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/ParserRuleContext.java
@@ -34,6 +34,7 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 import org.antlr.v4.runtime.misc.Nullable;
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.ParseTreeListener;
+import org.antlr.v4.runtime.tree.ParseTreeVisitor;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -131,10 +132,11 @@ public ParserRuleContext(@Nullable ParserRuleContext<Symbol> parent, int stateNu
 		this(parent, parent!=null ? parent.s : -1 /* invoking state */, stateNumber);
 	}
 
-	// Double dispatch methods
+	// Double dispatch methods for listeners and visitors
 
 	public void enterRule(ParseTreeListener<Symbol> listener) { }
 	public void exitRule(ParseTreeListener<Symbol> listener) { }
+	public <T,V extends ParseTreeVisitor<T>> T dispatch(V visitor) { visitor.visitChildren(this); return null; }
 
 	/** Does not set parent link; other add methods do */
 	public void addChild(TerminalNode<Symbol> t) {
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeVisitor.java b/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeVisitor.java
new file mode 100644
index 0000000000..9ad8eabaee
--- /dev/null
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeVisitor.java
@@ -0,0 +1,27 @@
+package org.antlr.v4.runtime.tree;
+
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.Token;
+
+/** T is return type of visit methods. Use T=Void for no return type. */
+public class ParseTreeVisitor<T> {
+	public T visit(ParserRuleContext<?> ctx) {
+		return ctx.dispatch(this);
+	}
+
+	/** Visit all rule, nonleaf children */
+	public <Symbol> void visitChildren(ParserRuleContext<Symbol> ctx) {
+		for (ParseTree c : ctx.children) {
+			if ( c instanceof ParseTree.RuleNode) {
+				ParseTree.RuleNode r = (ParseTree.RuleNode)c;
+				ParserRuleContext<Symbol> rctx = (ParserRuleContext<Symbol>)r.getRuleContext();
+				rctx.dispatch(this);
+			}
+		}
+	}
+
+//  Don't need to visit tokens. each visit() method deals with it's leaf children
+//	public T visit(Token t) {
+//		return null;
+//	}
+}
diff --git a/tool/playground/ABaseVisitor.java b/tool/playground/ABaseVisitor.java
new file mode 100644
index 0000000000..b20971e549
--- /dev/null
+++ b/tool/playground/ABaseVisitor.java
@@ -0,0 +1,11 @@
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.tree.ParseTreeVisitor;
+
+public class ABaseVisitor<T> extends ParseTreeVisitor<T> implements AVisitor<T> {
+	public T visit(AParser.MultContext ctx) { return null; }
+	public T visit(AParser.ParensContext ctx) { return null; }
+	public T visit(AParser.eContext ctx) { return null; }
+	public T visit(AParser.sContext ctx) { return null; }
+	public T visit(AParser.AddContext ctx) { return null; }
+	public T visit(AParser.IntContext ctx) { return null; }
+}
diff --git a/tool/playground/AVisitor.java b/tool/playground/AVisitor.java
new file mode 100644
index 0000000000..5f0af723d7
--- /dev/null
+++ b/tool/playground/AVisitor.java
@@ -0,0 +1,11 @@
+import org.antlr.v4.runtime.ParserRuleContext;
+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 visit(Token t);
+}
diff --git a/tool/playground/TestVisitor.java b/tool/playground/TestVisitor.java
new file mode 100644
index 0000000000..31fbabfd8d
--- /dev/null
+++ b/tool/playground/TestVisitor.java
@@ -0,0 +1,79 @@
+/*
+ [The "BSD license"]
+ Copyright (c) 2011 Terence Parr
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+ 3. The name of the author may not be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ 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.ParseTreeVisitor;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
+
+public class TestVisitor {
+	public static class MyVisitor extends ParseTreeVisitor<Integer> implements AVisitor<Integer> {
+		@Override
+		public Integer visit(AParser.AddContext ctx) {
+			return ctx.e(0).dispatch(this) + ctx.e(1).dispatch(this);
+		}
+
+		@Override
+		public Integer visit(AParser.IntContext ctx) {
+			return Integer.valueOf(ctx.INT().getText());
+		}
+
+		@Override
+		public Integer visit(AParser.MultContext ctx) {
+			return ctx.e(0).dispatch(this) * ctx.e(1).dispatch(this);
+		}
+
+		@Override
+		public Integer visit(AParser.ParensContext ctx) {
+			return ctx.e().dispatch(this);
+		}
+
+		@Override
+		public Integer visit(AParser.sContext ctx) {
+			return ctx.e().dispatch(this);
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		ALexer lexer = new ALexer(new ANTLRFileStream(args[0]));
+		CommonTokenStream tokens = new CommonTokenStream(lexer);
+		AParser p = new AParser(tokens);
+		p.setBuildParseTree(true);
+		ParserRuleContext<Token> t = p.s();
+		System.out.println("tree = "+t.toStringTree(p));
+
+		MyVisitor visitor = new MyVisitor();
+		Integer result = visitor.visit(t);
+//		Integer result = t.dispatch(visitor);
+		System.out.println("result from tree walk = " + result);
+	}
+}
+
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 5c0d27bba6..c7719732ad 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
@@ -551,6 +551,7 @@ public static class <s.name> extends <superClass><if(interfaces)> implements <in
 	}
 <endif>
 	<visitorDispatchMethods; separator="\n">
+        public \<T, V extends <parser.grammarName>Visitor\<T>\> T dispatch(V visitor) { return visitor.visit(this); }
 	<extensionMembers; separator="\n">
 }
 >>
@@ -561,6 +562,7 @@ public static class <s.name> extends <currentRule.name>Context {
 	<getters:{g | <g>}; separator="\n">
 	public <s.name>(<currentRule.name>Context ctx) { copyFrom(ctx); }
 	<visitorDispatchMethods; separator="\n">
+        public \<T, V extends <parser.grammarName>Visitor\<T>\> T dispatch(V visitor) { return visitor.visit(this); }
 }
 >>
 

From baf62685ab1ade1bec904b53c5195ace9e30ded3 Mon Sep 17 00:00:00 2001
From: Terence Parr <parrt@antlr.org>
Date: Thu, 16 Feb 2012 10:27:56 -0800
Subject: [PATCH 2/9] snapshot

---
 .../antlr/v4/runtime/ParserRuleContext.java   |  2 +-
 tool/playground/AVisitor.java                 |  1 -
 tool/playground/TestVisitor.java              |  4 ++--
 .../v4/tool/templates/codegen/Java/Java.stg   | 20 ++++++++++++-------
 .../codegen/model/ListenerDispatchMethod.java | 20 +++++++++++++++++++
 .../v4/codegen/model/decl/StructDecl.java     | 10 +++++-----
 6 files changed, 41 insertions(+), 16 deletions(-)
 create mode 100644 tool/src/org/antlr/v4/codegen/model/ListenerDispatchMethod.java

diff --git a/runtime/Java/src/org/antlr/v4/runtime/ParserRuleContext.java b/runtime/Java/src/org/antlr/v4/runtime/ParserRuleContext.java
index ec112740eb..531956edeb 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/ParserRuleContext.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/ParserRuleContext.java
@@ -136,7 +136,7 @@ public ParserRuleContext(@Nullable ParserRuleContext<Symbol> parent, int stateNu
 
 	public void enterRule(ParseTreeListener<Symbol> listener) { }
 	public void exitRule(ParseTreeListener<Symbol> listener) { }
-	public <T,V extends ParseTreeVisitor<T>> T dispatch(V visitor) { visitor.visitChildren(this); return null; }
+	public <T> T dispatch(ParseTreeVisitor<? extends T> visitor) { visitor.visitChildren(this); return null; }
 
 	/** Does not set parent link; other add methods do */
 	public void addChild(TerminalNode<Symbol> t) {
diff --git a/tool/playground/AVisitor.java b/tool/playground/AVisitor.java
index 5f0af723d7..358bc5a0f0 100644
--- a/tool/playground/AVisitor.java
+++ b/tool/playground/AVisitor.java
@@ -7,5 +7,4 @@ public interface AVisitor<T> {
 	T visit(AParser.sContext ctx);
 	T visit(AParser.AddContext ctx);
 	T visit(AParser.IntContext ctx);
-//	T visit(Token t);
 }
diff --git a/tool/playground/TestVisitor.java b/tool/playground/TestVisitor.java
index 31fbabfd8d..8d39973de8 100644
--- a/tool/playground/TestVisitor.java
+++ b/tool/playground/TestVisitor.java
@@ -48,7 +48,8 @@ public Integer visit(AParser.IntContext ctx) {
 
 		@Override
 		public Integer visit(AParser.MultContext ctx) {
-			return ctx.e(0).dispatch(this) * ctx.e(1).dispatch(this);
+//			return ctx.e(0).dispatch(this) * ctx.e(1).dispatch(this);
+			return visit(ctx.e(0)) * visit(ctx.e(1));
 		}
 
 		@Override
@@ -76,4 +77,3 @@ public static void main(String[] args) throws Exception {
 		System.out.println("result from tree walk = " + result);
 	}
 }
-
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 c7719732ad..32fa834b36 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
@@ -533,7 +533,7 @@ ListLabelName(label)		  ::= "<label>"
 CaptureNextToken(d) ::= "<d.varName> = _input.LT(1);"
 CaptureNextTokenType(d) ::= "<d.varName> = _input.LA(1);"
 
-StructDecl(s,attrs,getters,visitorDispatchMethods,interfaces,extensionMembers,
+StructDecl(s,attrs,getters,dispatchMethods,interfaces,extensionMembers,
            superClass={ParserRuleContext\<<InputSymbolType()>>}) ::= <<
 public static class <s.name> extends <superClass><if(interfaces)> implements <interfaces; separator=", "><endif> {
 	<attrs:{a | <a>}; separator="\n">
@@ -550,29 +550,35 @@ public static class <s.name> extends <superClass><if(interfaces)> implements <in
 		<s.attrs:{a | this.<a.name> = ctx.<a.name>;}; separator="\n">
 	}
 <endif>
-	<visitorDispatchMethods; separator="\n">
-        public \<T, V extends <parser.grammarName>Visitor\<T>\> T dispatch(V visitor) { return visitor.visit(this); }
+	<dispatchMethods; separator="\n">
 	<extensionMembers; separator="\n">
 }
 >>
 
-AltLabelStructDecl(s,attrs,getters,visitorDispatchMethods) ::= <<
+AltLabelStructDecl(s,attrs,getters,dispatchMethods) ::= <<
 public static class <s.name> extends <currentRule.name>Context {
 	<attrs:{a | <a>}; separator="\n">
 	<getters:{g | <g>}; separator="\n">
 	public <s.name>(<currentRule.name>Context ctx) { copyFrom(ctx); }
-	<visitorDispatchMethods; separator="\n">
-        public \<T, V extends <parser.grammarName>Visitor\<T>\> T dispatch(V visitor) { return visitor.visit(this); }
+	<dispatchMethods; separator="\n">
 }
 >>
 
-VisitorDispatchMethod(method) ::= <<
+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);
 }
 >>
 
+VisitorDispatchMethod() ::= <<
+@Override
+public \<T> T dispatch(ParseTreeVisitor\<? extends T> visitor) { 
+    if ( listener instanceof <parser.grammarName>Visitor ) return ((<parser.grammarName>Visitor\<T>)visitor).visit(this);
+    else return null;
+}
+>>
+
 AttributeDecl(d) ::= "public <d.decl>;"
 
 /** If we don't know location of label def x, use this template */
diff --git a/tool/src/org/antlr/v4/codegen/model/ListenerDispatchMethod.java b/tool/src/org/antlr/v4/codegen/model/ListenerDispatchMethod.java
new file mode 100644
index 0000000000..5b241eb015
--- /dev/null
+++ b/tool/src/org/antlr/v4/codegen/model/ListenerDispatchMethod.java
@@ -0,0 +1,20 @@
+package org.antlr.v4.codegen.model;
+
+import org.antlr.v4.codegen.OutputModelFactory;
+import org.antlr.v4.misc.Triple;
+import org.antlr.v4.tool.Rule;
+import org.antlr.v4.tool.ast.AltAST;
+
+import java.util.List;
+
+public class ListenerDispatchMethod extends OutputModelObject {
+	public String listenerName = "Rule";
+	public boolean isEnter;
+
+	public ListenerDispatchMethod(OutputModelFactory factory, Rule r, boolean isEnter) {
+		super(factory);
+		this.isEnter = isEnter;
+		List<Triple<Integer,AltAST,String>> label = r.getAltLabels();
+		if ( label!=null ) listenerName = label.get(0).c;
+	}
+}
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 4ecac29dcb..afb9cbdebb 100644
--- a/tool/src/org/antlr/v4/codegen/model/decl/StructDecl.java
+++ b/tool/src/org/antlr/v4/codegen/model/decl/StructDecl.java
@@ -32,7 +32,7 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 import org.antlr.v4.codegen.OutputModelFactory;
 import org.antlr.v4.codegen.model.ModelElement;
 import org.antlr.v4.codegen.model.OutputModelObject;
-import org.antlr.v4.codegen.model.VisitorDispatchMethod;
+import org.antlr.v4.codegen.model.ListenerDispatchMethod;
 import org.antlr.v4.runtime.misc.OrderedHashSet;
 import org.antlr.v4.tool.Attribute;
 import org.antlr.v4.tool.Rule;
@@ -50,7 +50,7 @@ public class StructDecl extends Decl {
 	@ModelElement public OrderedHashSet<Decl> attrs = new OrderedHashSet<Decl>();
 	@ModelElement public OrderedHashSet<Decl> getters = new OrderedHashSet<Decl>();
 	@ModelElement public Collection<Attribute> ctorAttrs;
-	@ModelElement public List<VisitorDispatchMethod> visitorDispatchMethods;
+	@ModelElement public List<ListenerDispatchMethod> dispatchMethods;
 	@ModelElement public List<OutputModelObject> interfaces;
 	@ModelElement public List<OutputModelObject> extensionMembers;
 
@@ -61,9 +61,9 @@ public StructDecl(OutputModelFactory factory, Rule r) {
 	}
 
 	public void addVisitorDispatchMethods(Rule r) {
-		visitorDispatchMethods = new ArrayList<VisitorDispatchMethod>();
-		visitorDispatchMethods.add(new VisitorDispatchMethod(factory, r, true));
-		visitorDispatchMethods.add(new VisitorDispatchMethod(factory, r, false));
+		dispatchMethods = new ArrayList<ListenerDispatchMethod>();
+		dispatchMethods.add(new ListenerDispatchMethod(factory, r, true));
+		dispatchMethods.add(new ListenerDispatchMethod(factory, r, false));
 	}
 
 	public void addDecl(Decl d) {

From 4a374dab602e58536d4b451fff260792ef2f5e40 Mon Sep 17 00:00:00 2001
From: Terence Parr <parrt@antlr.org>
Date: Thu, 16 Feb 2012 11:04:04 -0800
Subject: [PATCH 3/9] got visitors generated

---
 .../antlr/v4/runtime/ParserRuleContext.java   | 18 +++------
 .../v4/runtime/tree/ParseTreeVisitor.java     | 10 +----
 tool/playground/AVisitor.java                 |  5 +--
 tool/playground/TestE.java                    |  2 +-
 tool/playground/TestVisitor.java              | 17 ++++----
 .../v4/tool/templates/codegen/Java/Java.stg   | 18 +++++++--
 .../org/antlr/v4/codegen/CodeGenPipeline.java |  1 +
 .../org/antlr/v4/codegen/CodeGenerator.java   | 39 +++++++++++++++----
 .../v4/codegen/OutputModelController.java     | 27 ++++++-------
 .../v4/codegen/model/DispatchMethod.java      |  9 +++++
 .../codegen/model/ListenerDispatchMethod.java | 12 +-----
 .../codegen/model/VisitorDispatchMethod.java  | 15 +------
 .../antlr/v4/codegen/model/VisitorFile.java   | 37 ++++++++++++++++++
 .../model/decl/AltLabelStructDecl.java        |  7 ++++
 .../v4/codegen/model/decl/StructDecl.java     | 27 ++++++-------
 15 files changed, 144 insertions(+), 100 deletions(-)
 create mode 100644 tool/src/org/antlr/v4/codegen/model/DispatchMethod.java
 create mode 100644 tool/src/org/antlr/v4/codegen/model/VisitorFile.java

diff --git a/runtime/Java/src/org/antlr/v4/runtime/ParserRuleContext.java b/runtime/Java/src/org/antlr/v4/runtime/ParserRuleContext.java
index 531956edeb..c3bdc86348 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/ParserRuleContext.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/ParserRuleContext.java
@@ -28,17 +28,11 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  */
 package org.antlr.v4.runtime;
 
-import org.antlr.v4.runtime.atn.ATN;
-import org.antlr.v4.runtime.atn.ATNState;
-import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.runtime.misc.Nullable;
-import org.antlr.v4.runtime.tree.ParseTree;
-import org.antlr.v4.runtime.tree.ParseTreeListener;
-import org.antlr.v4.runtime.tree.ParseTreeVisitor;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import org.antlr.v4.runtime.atn.*;
+import org.antlr.v4.runtime.misc.*;
+import org.antlr.v4.runtime.tree.*;
+
+import java.util.*;
 
 /** A rule invocation record for parsing and tree parsing.
  *
@@ -136,7 +130,7 @@ public ParserRuleContext(@Nullable ParserRuleContext<Symbol> parent, int stateNu
 
 	public void enterRule(ParseTreeListener<Symbol> listener) { }
 	public void exitRule(ParseTreeListener<Symbol> listener) { }
-	public <T> T dispatch(ParseTreeVisitor<? extends T> visitor) { visitor.visitChildren(this); return null; }
+	public <T> T accept(ParseTreeVisitor<? extends T> visitor) { visitor.visitChildren(this); return null; }
 
 	/** Does not set parent link; other add methods do */
 	public void addChild(TerminalNode<Symbol> t) {
diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeVisitor.java b/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeVisitor.java
index 9ad8eabaee..c77131a471 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeVisitor.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeVisitor.java
@@ -1,12 +1,11 @@
 package org.antlr.v4.runtime.tree;
 
 import org.antlr.v4.runtime.ParserRuleContext;
-import org.antlr.v4.runtime.Token;
 
 /** T is return type of visit methods. Use T=Void for no return type. */
 public class ParseTreeVisitor<T> {
 	public T visit(ParserRuleContext<?> ctx) {
-		return ctx.dispatch(this);
+		return ctx.accept(this);
 	}
 
 	/** Visit all rule, nonleaf children */
@@ -15,13 +14,8 @@ public <Symbol> void visitChildren(ParserRuleContext<Symbol> ctx) {
 			if ( c instanceof ParseTree.RuleNode) {
 				ParseTree.RuleNode r = (ParseTree.RuleNode)c;
 				ParserRuleContext<Symbol> rctx = (ParserRuleContext<Symbol>)r.getRuleContext();
-				rctx.dispatch(this);
+				visit(rctx);
 			}
 		}
 	}
-
-//  Don't need to visit tokens. each visit() method deals with it's leaf children
-//	public T visit(Token t) {
-//		return null;
-//	}
 }
diff --git a/tool/playground/AVisitor.java b/tool/playground/AVisitor.java
index 358bc5a0f0..5badbd2754 100644
--- a/tool/playground/AVisitor.java
+++ b/tool/playground/AVisitor.java
@@ -1,10 +1,7 @@
-import org.antlr.v4.runtime.ParserRuleContext;
-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);
-}
+}
\ No newline at end of file
diff --git a/tool/playground/TestE.java b/tool/playground/TestE.java
index 02791e0c77..476cbb29f5 100644
--- a/tool/playground/TestE.java
+++ b/tool/playground/TestE.java
@@ -3,7 +3,7 @@
 public class TestE {
     public static void main(String[] args) throws Exception {
         CharStream input = new ANTLRFileStream(args[0]);
-        E lex = new E(input);
+        ELexer lex = new ELexer(input);
         CommonTokenStream tokens = new CommonTokenStream(lex);
         tokens.fill();
         for (Object t : tokens.getTokens()) System.out.println(t);
diff --git a/tool/playground/TestVisitor.java b/tool/playground/TestVisitor.java
index 8d39973de8..734e6bc6ab 100644
--- a/tool/playground/TestVisitor.java
+++ b/tool/playground/TestVisitor.java
@@ -27,18 +27,14 @@ 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.*;
 import org.antlr.v4.runtime.tree.ParseTreeVisitor;
-import org.antlr.v4.runtime.tree.ParseTreeWalker;
 
 public class TestVisitor {
 	public static class MyVisitor extends ParseTreeVisitor<Integer> implements AVisitor<Integer> {
 		@Override
 		public Integer visit(AParser.AddContext ctx) {
-			return ctx.e(0).dispatch(this) + ctx.e(1).dispatch(this);
+			return ctx.e(0).accept(this) + ctx.e(1).accept(this);
 		}
 
 		@Override
@@ -48,18 +44,19 @@ public Integer visit(AParser.IntContext ctx) {
 
 		@Override
 		public Integer visit(AParser.MultContext ctx) {
-//			return ctx.e(0).dispatch(this) * ctx.e(1).dispatch(this);
+//			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) {
-			return ctx.e().dispatch(this);
+			return ctx.e().accept(this);
 		}
 
 		@Override
 		public Integer visit(AParser.sContext ctx) {
-			return ctx.e().dispatch(this);
+			return visit(ctx.e());
+			//return ctx.e().accept(this);
 		}
 	}
 
@@ -73,7 +70,7 @@ public static void main(String[] args) throws Exception {
 
 		MyVisitor visitor = new MyVisitor();
 		Integer result = visitor.visit(t);
-//		Integer result = t.dispatch(visitor);
+//		Integer result = t.accept(visitor);
 		System.out.println("result from tree walk = " + result);
 	}
 }
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 32fa834b36..545a722275 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
@@ -56,6 +56,18 @@ public class <file.grammarName>BaseListener implements <file.grammarName>Listene
 }
 >>
 
+VisitorFile(file, header) ::= <<
+<header>
+import org.antlr.v4.runtime.tree.*;
+import org.antlr.v4.runtime.Token;
+
+public interface <file.grammarName>Visitor\<T> {
+	<file.visitorNames:{lname |
+T visit(<file.parserName>.<lname>Context ctx);}; separator="\n">
+}
+>>
+
+
 Parser(parser, funcs, atn, sempredFuncs, superclass) ::= <<
 <Parser_(ctor="parser_ctor", ...)>
 >>
@@ -571,10 +583,10 @@ public void <if(method.isEnter)>enter<else>exit<endif>Rule(ParseTreeListener\<<I
 }
 >>
 
-VisitorDispatchMethod() ::= <<
+VisitorDispatchMethod(method) ::= <<
 @Override
-public \<T> T dispatch(ParseTreeVisitor\<? extends T> visitor) { 
-    if ( listener instanceof <parser.grammarName>Visitor ) return ((<parser.grammarName>Visitor\<T>)visitor).visit(this);
+public \<T> T accept(ParseTreeVisitor\<? extends T> visitor) { 
+    if ( visitor instanceof <parser.grammarName>Visitor ) return ((<parser.grammarName>Visitor\<T>)visitor).visit(this);
     else return null;
 }
 >>
diff --git a/tool/src/org/antlr/v4/codegen/CodeGenPipeline.java b/tool/src/org/antlr/v4/codegen/CodeGenPipeline.java
index 1c2bc481d4..fd08c81c99 100644
--- a/tool/src/org/antlr/v4/codegen/CodeGenPipeline.java
+++ b/tool/src/org/antlr/v4/codegen/CodeGenPipeline.java
@@ -48,6 +48,7 @@ public void process() {
 			gen.writeRecognizer(gen.generateParser());
 			if ( g.tool.gen_listener) {
 				gen.writeListener(gen.generateListener());
+				gen.writeVisitor(gen.generateVisitor());
 				gen.writeBlankListener(gen.generateBlankListener());
 			}
 			gen.writeHeaderFile();
diff --git a/tool/src/org/antlr/v4/codegen/CodeGenerator.java b/tool/src/org/antlr/v4/codegen/CodeGenerator.java
index 76e824aaf0..22ff0d3106 100644
--- a/tool/src/org/antlr/v4/codegen/CodeGenerator.java
+++ b/tool/src/org/antlr/v4/codegen/CodeGenerator.java
@@ -33,16 +33,12 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 import org.antlr.v4.codegen.model.OutputModelObject;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.misc.NotNull;
-import org.antlr.v4.tool.ErrorType;
-import org.antlr.v4.tool.Grammar;
+import org.antlr.v4.tool.*;
 import org.stringtemplate.v4.*;
 
-import java.io.IOException;
-import java.io.Writer;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.util.HashMap;
-import java.util.Map;
+import java.io.*;
+import java.lang.reflect.*;
+import java.util.*;
 
 /** General controller for code gen.  Can instantiate sub generator(s).
  */
@@ -173,6 +169,19 @@ public ST generateListener() {
 		return st;
 	}
 
+	public ST generateVisitor() {
+		OutputModelFactory factory = new ParserFactory(this);
+
+		OutputModelController controller = new OutputModelController(factory);
+		factory.setController(controller);
+
+		OutputModelObject visitorModel = controller.buildVisitorOutputModel();
+
+		OutputModelWalker walker = new OutputModelWalker(tool, templates);
+		ST st = walker.walk(visitorModel);
+		return st;
+	}
+
 	public ST generateBlankListener() {
 		OutputModelFactory factory = new ParserFactory(this);
 
@@ -230,6 +239,10 @@ public void writeBlankListener(ST outputFileST) {
 		target.genFile(g,outputFileST, getBlankListenerFileName());
 	}
 
+	public void writeVisitor(ST outputFileST) {
+		target.genFile(g,outputFileST, getVisitorFileName());
+	}
+
 	public void writeHeaderFile() {
 		String fileName = getHeaderFileName();
 		if ( fileName==null ) return;
@@ -309,6 +322,16 @@ public String getListenerFileName() {
 		return listenerName+extST.render();
 	}
 
+	/** A given grammar T, return the visitor name such as
+	 *  TVisitor.java, if we're using the Java target.
+ 	 */
+	public String getVisitorFileName() {
+		assert g.name != null;
+		ST extST = templates.getInstanceOf("codeFileExtension");
+		String listenerName = g.name + "Visitor";
+		return listenerName+extST.render();
+	}
+
 	/** A given grammar T, return a blank listener implementation
 	 *  such as BlankTListener.java, if we're using the Java target.
  	 */
diff --git a/tool/src/org/antlr/v4/codegen/OutputModelController.java b/tool/src/org/antlr/v4/codegen/OutputModelController.java
index 619267da3b..c68613f316 100644
--- a/tool/src/org/antlr/v4/codegen/OutputModelController.java
+++ b/tool/src/org/antlr/v4/codegen/OutputModelController.java
@@ -33,22 +33,12 @@ 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.parse.ANTLRParser;
-import org.antlr.v4.parse.GrammarASTAdaptor;
-import org.antlr.v4.tool.Alternative;
-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.BlockAST;
-import org.antlr.v4.tool.ast.GrammarAST;
-import org.antlr.v4.tool.ast.PredAST;
-import org.stringtemplate.v4.ST;
-import org.stringtemplate.v4.STGroup;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Stack;
+import org.antlr.v4.parse.*;
+import org.antlr.v4.tool.*;
+import org.antlr.v4.tool.ast.*;
+import org.stringtemplate.v4.*;
+
+import java.util.*;
 
 /** This receives events from SourceGenTriggers.g and asks factory to do work.
  *  Then runs extensions in order on resulting SrcOps to get final list.
@@ -123,6 +113,11 @@ public OutputModelObject buildBlankListenerOutputModel() {
 		return new BaseListenerFile(delegate, gen.getBlankListenerFileName());
 	}
 
+	public OutputModelObject buildVisitorOutputModel() {
+		CodeGenerator gen = delegate.getGenerator();
+		return new VisitorFile(delegate, gen.getVisitorFileName());
+	}
+
 	public ParserFile parserFile(String fileName) {
 		ParserFile f = delegate.parserFile(fileName);
 		for (CodeGeneratorExtension ext : extensions) f = ext.parserFile(f);
diff --git a/tool/src/org/antlr/v4/codegen/model/DispatchMethod.java b/tool/src/org/antlr/v4/codegen/model/DispatchMethod.java
new file mode 100644
index 0000000000..799220ab9d
--- /dev/null
+++ b/tool/src/org/antlr/v4/codegen/model/DispatchMethod.java
@@ -0,0 +1,9 @@
+package org.antlr.v4.codegen.model;
+
+import org.antlr.v4.codegen.OutputModelFactory;
+
+public class DispatchMethod extends OutputModelObject {
+	public DispatchMethod(OutputModelFactory factory) {
+		super(factory);
+	}
+}
diff --git a/tool/src/org/antlr/v4/codegen/model/ListenerDispatchMethod.java b/tool/src/org/antlr/v4/codegen/model/ListenerDispatchMethod.java
index 5b241eb015..c35be77ffe 100644
--- a/tool/src/org/antlr/v4/codegen/model/ListenerDispatchMethod.java
+++ b/tool/src/org/antlr/v4/codegen/model/ListenerDispatchMethod.java
@@ -1,20 +1,12 @@
 package org.antlr.v4.codegen.model;
 
 import org.antlr.v4.codegen.OutputModelFactory;
-import org.antlr.v4.misc.Triple;
-import org.antlr.v4.tool.Rule;
-import org.antlr.v4.tool.ast.AltAST;
 
-import java.util.List;
-
-public class ListenerDispatchMethod extends OutputModelObject {
-	public String listenerName = "Rule";
+public class ListenerDispatchMethod extends DispatchMethod {
 	public boolean isEnter;
 
-	public ListenerDispatchMethod(OutputModelFactory factory, Rule r, boolean isEnter) {
+	public ListenerDispatchMethod(OutputModelFactory factory, boolean isEnter) {
 		super(factory);
 		this.isEnter = isEnter;
-		List<Triple<Integer,AltAST,String>> label = r.getAltLabels();
-		if ( label!=null ) listenerName = label.get(0).c;
 	}
 }
diff --git a/tool/src/org/antlr/v4/codegen/model/VisitorDispatchMethod.java b/tool/src/org/antlr/v4/codegen/model/VisitorDispatchMethod.java
index 19c954fd12..71cc671c83 100644
--- a/tool/src/org/antlr/v4/codegen/model/VisitorDispatchMethod.java
+++ b/tool/src/org/antlr/v4/codegen/model/VisitorDispatchMethod.java
@@ -1,20 +1,9 @@
 package org.antlr.v4.codegen.model;
 
 import org.antlr.v4.codegen.OutputModelFactory;
-import org.antlr.v4.misc.Triple;
-import org.antlr.v4.tool.Rule;
-import org.antlr.v4.tool.ast.AltAST;
 
-import java.util.List;
-
-public class VisitorDispatchMethod extends OutputModelObject {
-	public String listenerName = "Rule";
-	public boolean isEnter;
-
-	public VisitorDispatchMethod(OutputModelFactory factory, Rule r, boolean isEnter) {
+public class VisitorDispatchMethod extends DispatchMethod {
+	public VisitorDispatchMethod(OutputModelFactory factory) {
 		super(factory);
-		this.isEnter = isEnter;
-		List<Triple<Integer,AltAST,String>> label = r.getAltLabels();
-		if ( label!=null ) listenerName = label.get(0).c;
 	}
 }
diff --git a/tool/src/org/antlr/v4/codegen/model/VisitorFile.java b/tool/src/org/antlr/v4/codegen/model/VisitorFile.java
new file mode 100644
index 0000000000..ee571c0aee
--- /dev/null
+++ b/tool/src/org/antlr/v4/codegen/model/VisitorFile.java
@@ -0,0 +1,37 @@
+package org.antlr.v4.codegen.model;
+
+import org.antlr.v4.codegen.OutputModelFactory;
+import org.antlr.v4.misc.Triple;
+import org.antlr.v4.tool.*;
+import org.antlr.v4.tool.ast.*;
+
+import java.util.*;
+
+public class VisitorFile extends OutputFile {
+	public String grammarName;
+	public String parserName;
+	public Set<String> visitorNames = new HashSet<String>();
+
+	@ModelElement public Action header;
+
+	public VisitorFile(OutputModelFactory factory, String fileName) {
+		super(factory, fileName);
+		Grammar g = factory.getGrammar();
+		parserName = g.getRecognizerName();
+		grammarName = g.name;
+		for (Rule r : g.rules.values()) {
+			List<Triple<Integer,AltAST,String>> labels = r.getAltLabels();
+			if ( labels!=null ) {
+				for (Triple<Integer,AltAST,String> pair : labels) {
+					visitorNames.add(pair.c);
+				}
+			}
+			else {
+				// if labels, must label all. no need for generic rule visitor then
+				visitorNames.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 6fe985471e..b027cb1ba6 100644
--- a/tool/src/org/antlr/v4/codegen/model/decl/AltLabelStructDecl.java
+++ b/tool/src/org/antlr/v4/codegen/model/decl/AltLabelStructDecl.java
@@ -30,6 +30,7 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 package org.antlr.v4.codegen.model.decl;
 
 import org.antlr.v4.codegen.OutputModelFactory;
+import org.antlr.v4.codegen.model.VisitorDispatchMethod;
 import org.antlr.v4.tool.Rule;
 
 /** A StructDecl to handle a -> label on alt */
@@ -46,6 +47,12 @@ public AltLabelStructDecl(OutputModelFactory factory, Rule r,
 			.getInstanceOf("RuleContextNameSuffix").render();
 	}
 
+	@Override
+	public void addDispatchMethods(Rule r) {
+		super.addDispatchMethods(r);
+		dispatchMethods.add(new VisitorDispatchMethod(factory));
+	}
+
 	@Override
 	public int hashCode() {
 		return name.hashCode();
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 afb9cbdebb..a4ebcfa5ab 100644
--- a/tool/src/org/antlr/v4/codegen/model/decl/StructDecl.java
+++ b/tool/src/org/antlr/v4/codegen/model/decl/StructDecl.java
@@ -30,40 +30,37 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 package org.antlr.v4.codegen.model.decl;
 
 import org.antlr.v4.codegen.OutputModelFactory;
-import org.antlr.v4.codegen.model.ModelElement;
-import org.antlr.v4.codegen.model.OutputModelObject;
-import org.antlr.v4.codegen.model.ListenerDispatchMethod;
+import org.antlr.v4.codegen.model.*;
 import org.antlr.v4.runtime.misc.OrderedHashSet;
-import org.antlr.v4.tool.Attribute;
-import org.antlr.v4.tool.Rule;
+import org.antlr.v4.tool.*;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
+import java.util.*;
 
 /** This object models the structure holding all of the parameters,
  *  return values, local variables, and labels associated with a rule.
  */
 public class StructDecl extends Decl {
-	public String superClass;
 	public boolean provideCopyFrom;
 	@ModelElement public OrderedHashSet<Decl> attrs = new OrderedHashSet<Decl>();
 	@ModelElement public OrderedHashSet<Decl> getters = new OrderedHashSet<Decl>();
 	@ModelElement public Collection<Attribute> ctorAttrs;
-	@ModelElement public List<ListenerDispatchMethod> dispatchMethods;
+	@ModelElement public List<? super DispatchMethod> dispatchMethods;
 	@ModelElement public List<OutputModelObject> interfaces;
 	@ModelElement public List<OutputModelObject> extensionMembers;
 
 	public StructDecl(OutputModelFactory factory, Rule r) {
 		super(factory, factory.getGenerator().target.getRuleFunctionContextStructName(r));
-		addVisitorDispatchMethods(r);
+		addDispatchMethods(r);
 		provideCopyFrom = r.hasAltSpecificContexts();
 	}
 
-	public void addVisitorDispatchMethods(Rule r) {
-		dispatchMethods = new ArrayList<ListenerDispatchMethod>();
-		dispatchMethods.add(new ListenerDispatchMethod(factory, r, true));
-		dispatchMethods.add(new ListenerDispatchMethod(factory, r, false));
+	public void addDispatchMethods(Rule r) {
+		dispatchMethods = new ArrayList<DispatchMethod>();
+		dispatchMethods.add(new ListenerDispatchMethod(factory, true));
+		dispatchMethods.add(new ListenerDispatchMethod(factory, false));
+		if ( !r.hasAltSpecificContexts() ) {
+			dispatchMethods.add(new VisitorDispatchMethod(factory));
+		}
 	}
 
 	public void addDecl(Decl d) {

From 646b22b9ec25ee5c0c763f850dd055bdab17dc85 Mon Sep 17 00:00:00 2001
From: Terence Parr <parrt@antlr.org>
Date: Thu, 16 Feb 2012 13:36:07 -0800
Subject: [PATCH 4/9] snapshot

---
 .../v4/runtime/tree/ParseTreeVisitor.java     |  7 +++-
 tool/playground/ABaseVisitor.java             | 15 ++++---
 tool/playground/AVisitor.java                 |  3 ++
 tool/playground/TestVisitor.java              |  2 +-
 .../v4/tool/templates/codegen/Java/Java.stg   | 10 +++++
 .../org/antlr/v4/codegen/CodeGenPipeline.java |  3 +-
 .../org/antlr/v4/codegen/CodeGenerator.java   | 41 +++++++++++++++----
 .../v4/codegen/OutputModelController.java     |  9 +++-
 .../v4/codegen/model/BaseVisitorFile.java     |  9 ++++
 .../antlr/v4/codegen/model/ListenerFile.java  |  1 -
 10 files changed, 79 insertions(+), 21 deletions(-)
 create mode 100644 tool/src/org/antlr/v4/codegen/model/BaseVisitorFile.java

diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeVisitor.java b/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeVisitor.java
index c77131a471..5dd260312a 100644
--- a/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeVisitor.java
+++ b/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeVisitor.java
@@ -8,7 +8,12 @@ public T visit(ParserRuleContext<?> ctx) {
 		return ctx.accept(this);
 	}
 
-	/** Visit all rule, nonleaf children */
+	/** Visit all rule, nonleaf children. Not useful if you are using T as
+	 *  non-Void.  This returns nothing, losing all computations from below.
+	 *  But handy if you are just walking the tree with a visitor and only
+	 *  care about some nodes.  The ParserRuleContext.accept() method
+	 *  walks all children by default; i.e., calls this method.
+	 */
 	public <Symbol> void visitChildren(ParserRuleContext<Symbol> ctx) {
 		for (ParseTree c : ctx.children) {
 			if ( c instanceof ParseTree.RuleNode) {
diff --git a/tool/playground/ABaseVisitor.java b/tool/playground/ABaseVisitor.java
index b20971e549..aa3159fbc1 100644
--- a/tool/playground/ABaseVisitor.java
+++ b/tool/playground/ABaseVisitor.java
@@ -1,11 +1,10 @@
+import org.antlr.v4.runtime.tree.*;
 import org.antlr.v4.runtime.Token;
-import org.antlr.v4.runtime.tree.ParseTreeVisitor;
 
 public class ABaseVisitor<T> extends ParseTreeVisitor<T> implements AVisitor<T> {
-	public T visit(AParser.MultContext ctx) { return null; }
-	public T visit(AParser.ParensContext ctx) { return null; }
-	public T visit(AParser.eContext ctx) { return null; }
-	public T visit(AParser.sContext ctx) { return null; }
-	public T visit(AParser.AddContext ctx) { return null; }
-	public T visit(AParser.IntContext ctx) { return null; }
-}
+	public T visit(AParser.MultContext ctx) { visitChildren(ctx); return null; }
+	public T visit(AParser.ParensContext ctx) { visitChildren(ctx); return null; }
+	public T visit(AParser.sContext ctx) { visitChildren(ctx); return null; }
+	public T visit(AParser.AddContext ctx) { visitChildren(ctx); return null; }
+	public T visit(AParser.IntContext ctx) { visitChildren(ctx); return null; }
+}
\ No newline at end of file
diff --git a/tool/playground/AVisitor.java b/tool/playground/AVisitor.java
index 5badbd2754..5730fa2d6b 100644
--- a/tool/playground/AVisitor.java
+++ b/tool/playground/AVisitor.java
@@ -1,3 +1,6 @@
+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);
diff --git a/tool/playground/TestVisitor.java b/tool/playground/TestVisitor.java
index 734e6bc6ab..6d7e240cb5 100644
--- a/tool/playground/TestVisitor.java
+++ b/tool/playground/TestVisitor.java
@@ -31,7 +31,7 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 import org.antlr.v4.runtime.tree.ParseTreeVisitor;
 
 public class TestVisitor {
-	public static class MyVisitor extends ParseTreeVisitor<Integer> implements AVisitor<Integer> {
+	public static class MyVisitor extends ABaseVisitor<Integer> implements AVisitor<Integer> {
 		@Override
 		public Integer visit(AParser.AddContext ctx) {
 			return ctx.e(0).accept(this) + ctx.e(1).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 545a722275..6fd56d759f 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
@@ -67,6 +67,16 @@ T visit(<file.parserName>.<lname>Context ctx);}; separator="\n">
 }
 >>
 
+BaseVisitorFile(file, header) ::= <<
+<header>
+import org.antlr.v4.runtime.tree.*;
+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">
+}
+>>
 
 Parser(parser, funcs, atn, sempredFuncs, superclass) ::= <<
 <Parser_(ctor="parser_ctor", ...)>
diff --git a/tool/src/org/antlr/v4/codegen/CodeGenPipeline.java b/tool/src/org/antlr/v4/codegen/CodeGenPipeline.java
index fd08c81c99..d89443fcd3 100644
--- a/tool/src/org/antlr/v4/codegen/CodeGenPipeline.java
+++ b/tool/src/org/antlr/v4/codegen/CodeGenPipeline.java
@@ -48,8 +48,9 @@ public void process() {
 			gen.writeRecognizer(gen.generateParser());
 			if ( g.tool.gen_listener) {
 				gen.writeListener(gen.generateListener());
+				gen.writeBaseListener(gen.generateBaseListener());
 				gen.writeVisitor(gen.generateVisitor());
-				gen.writeBlankListener(gen.generateBlankListener());
+				gen.writeBaseVisitor(gen.generateBaseVisitor());
 			}
 			gen.writeHeaderFile();
 		}
diff --git a/tool/src/org/antlr/v4/codegen/CodeGenerator.java b/tool/src/org/antlr/v4/codegen/CodeGenerator.java
index 22ff0d3106..eaf9cba065 100644
--- a/tool/src/org/antlr/v4/codegen/CodeGenerator.java
+++ b/tool/src/org/antlr/v4/codegen/CodeGenerator.java
@@ -182,16 +182,29 @@ public ST generateVisitor() {
 		return st;
 	}
 
-	public ST generateBlankListener() {
+	public ST generateBaseListener() {
 		OutputModelFactory factory = new ParserFactory(this);
 
 		OutputModelController controller = new OutputModelController(factory);
 		factory.setController(controller);
 
-		OutputModelObject blankModel = controller.buildBlankListenerOutputModel();
+		OutputModelObject baseModel = controller.buildBaseListenerOutputModel();
 
 		OutputModelWalker walker = new OutputModelWalker(tool, templates);
-		ST st = walker.walk(blankModel);
+		ST st = walker.walk(baseModel);
+		return st;
+	}
+
+	public ST generateBaseVisitor() {
+		OutputModelFactory factory = new ParserFactory(this);
+
+		OutputModelController controller = new OutputModelController(factory);
+		factory.setController(controller);
+
+		OutputModelObject baseModel = controller.buildBaseVisitorOutputModel();
+
+		OutputModelWalker walker = new OutputModelWalker(tool, templates);
+		ST st = walker.walk(baseModel);
 		return st;
 	}
 
@@ -235,14 +248,18 @@ public void writeListener(ST outputFileST) {
 		target.genFile(g,outputFileST, getListenerFileName());
 	}
 
-	public void writeBlankListener(ST outputFileST) {
-		target.genFile(g,outputFileST, getBlankListenerFileName());
+	public void writeBaseListener(ST outputFileST) {
+		target.genFile(g,outputFileST, getBaseListenerFileName());
 	}
 
 	public void writeVisitor(ST outputFileST) {
 		target.genFile(g,outputFileST, getVisitorFileName());
 	}
 
+	public void writeBaseVisitor(ST outputFileST) {
+		target.genFile(g,outputFileST, getBaseVisitorFileName());
+	}
+
 	public void writeHeaderFile() {
 		String fileName = getHeaderFileName();
 		if ( fileName==null ) return;
@@ -333,15 +350,25 @@ public String getVisitorFileName() {
 	}
 
 	/** A given grammar T, return a blank listener implementation
-	 *  such as BlankTListener.java, if we're using the Java target.
+	 *  such as TBaseListener.java, if we're using the Java target.
  	 */
-	public String getBlankListenerFileName() {
+	public String getBaseListenerFileName() {
 		assert g.name != null;
 		ST extST = templates.getInstanceOf("codeFileExtension");
 		String listenerName = g.name + "BaseListener";
 		return listenerName+extST.render();
 	}
 
+	/** A given grammar T, return a blank listener implementation
+	 *  such as TBaseListener.java, if we're using the Java target.
+ 	 */
+	public String getBaseVisitorFileName() {
+		assert g.name != null;
+		ST extST = templates.getInstanceOf("codeFileExtension");
+		String listenerName = g.name + "BaseVisitor";
+		return listenerName+extST.render();
+	}
+
 	/** What is the name of the vocab file generated for this grammar?
 	 *  Returns null if no .tokens file should be generated.
 	 */
diff --git a/tool/src/org/antlr/v4/codegen/OutputModelController.java b/tool/src/org/antlr/v4/codegen/OutputModelController.java
index c68613f316..9827eaf85e 100644
--- a/tool/src/org/antlr/v4/codegen/OutputModelController.java
+++ b/tool/src/org/antlr/v4/codegen/OutputModelController.java
@@ -108,9 +108,9 @@ public OutputModelObject buildListenerOutputModel() {
 		return new ListenerFile(delegate, gen.getListenerFileName());
 	}
 
-	public OutputModelObject buildBlankListenerOutputModel() {
+	public OutputModelObject buildBaseListenerOutputModel() {
 		CodeGenerator gen = delegate.getGenerator();
-		return new BaseListenerFile(delegate, gen.getBlankListenerFileName());
+		return new BaseListenerFile(delegate, gen.getBaseListenerFileName());
 	}
 
 	public OutputModelObject buildVisitorOutputModel() {
@@ -118,6 +118,11 @@ public OutputModelObject buildVisitorOutputModel() {
 		return new VisitorFile(delegate, gen.getVisitorFileName());
 	}
 
+	public OutputModelObject buildBaseVisitorOutputModel() {
+		CodeGenerator gen = delegate.getGenerator();
+		return new BaseVisitorFile(delegate, gen.getBaseVisitorFileName());
+	}
+
 	public ParserFile parserFile(String fileName) {
 		ParserFile f = delegate.parserFile(fileName);
 		for (CodeGeneratorExtension ext : extensions) f = ext.parserFile(f);
diff --git a/tool/src/org/antlr/v4/codegen/model/BaseVisitorFile.java b/tool/src/org/antlr/v4/codegen/model/BaseVisitorFile.java
new file mode 100644
index 0000000000..0d8d1ab284
--- /dev/null
+++ b/tool/src/org/antlr/v4/codegen/model/BaseVisitorFile.java
@@ -0,0 +1,9 @@
+package org.antlr.v4.codegen.model;
+
+import org.antlr.v4.codegen.OutputModelFactory;
+
+public class BaseVisitorFile extends VisitorFile {
+	public BaseVisitorFile(OutputModelFactory factory, String fileName) {
+		super(factory, fileName);
+	}
+}
diff --git a/tool/src/org/antlr/v4/codegen/model/ListenerFile.java b/tool/src/org/antlr/v4/codegen/model/ListenerFile.java
index 5461d26fa5..dda76c16be 100644
--- a/tool/src/org/antlr/v4/codegen/model/ListenerFile.java
+++ b/tool/src/org/antlr/v4/codegen/model/ListenerFile.java
@@ -14,7 +14,6 @@ public class ListenerFile extends OutputFile {
 	public String grammarName;
 	public String parserName;
 	public Set<String> listenerNames = new HashSet<String>();
-//	public List<String> ruleNames = new ArrayList<String>();
 
 	@ModelElement public Action header;
 

From 100b5302014643d44669028e6dca6338edcf8f60 Mon Sep 17 00:00:00 2001
From: Terence Parr <parrt@antlr.org>
Date: Thu, 16 Feb 2012 17:14:41 -0800
Subject: [PATCH 5/9] report errors with too few alt labels or redef of alt
 label

---
 tool/playground/A.g4                          |  6 +++
 tool/playground/ABaseVisitor.java             |  6 +--
 tool/playground/AVisitor.java                 |  6 +--
 .../v4/semantics/BasicSemanticChecks.java     | 43 +++++++++++++++++--
 tool/src/org/antlr/v4/tool/ErrorType.java     |  4 +-
 tool/src/org/antlr/v4/tool/ast/RuleAST.java   | 13 +++++-
 6 files changed, 64 insertions(+), 14 deletions(-)

diff --git a/tool/playground/A.g4 b/tool/playground/A.g4
index 9c2d6ea73d..ce79583fc5 100644
--- a/tool/playground/A.g4
+++ b/tool/playground/A.g4
@@ -8,5 +8,11 @@ e : e '*' e 		-> Mult
   | '(' e ')'		-> Parens
   ;
 
+x : A -> Foo
+  | B
+  ;
+
+y : Y -> Mult ;
+
 INT : [0-9]+ ;
 WS : [ \t\n]+ -> skip ;
diff --git a/tool/playground/ABaseVisitor.java b/tool/playground/ABaseVisitor.java
index aa3159fbc1..355023fd63 100644
--- a/tool/playground/ABaseVisitor.java
+++ b/tool/playground/ABaseVisitor.java
@@ -1,10 +1,10 @@
-import org.antlr.v4.runtime.tree.*;
-import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.tree.ParseTreeVisitor;
 
 public class ABaseVisitor<T> extends ParseTreeVisitor<T> implements AVisitor<T> {
 	public T visit(AParser.MultContext ctx) { visitChildren(ctx); return null; }
 	public T visit(AParser.ParensContext ctx) { visitChildren(ctx); return null; }
 	public T visit(AParser.sContext ctx) { visitChildren(ctx); return null; }
+	public T visit(AParser.FooContext ctx) { visitChildren(ctx); return null; }
 	public T visit(AParser.AddContext ctx) { visitChildren(ctx); return null; }
 	public T visit(AParser.IntContext ctx) { visitChildren(ctx); return null; }
-}
\ No newline at end of file
+}
diff --git a/tool/playground/AVisitor.java b/tool/playground/AVisitor.java
index 5730fa2d6b..4bd72a0f0b 100644
--- a/tool/playground/AVisitor.java
+++ b/tool/playground/AVisitor.java
@@ -1,10 +1,8 @@
-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.FooContext ctx);
 	T visit(AParser.AddContext ctx);
 	T visit(AParser.IntContext ctx);
-}
\ No newline at end of file
+}
diff --git a/tool/src/org/antlr/v4/semantics/BasicSemanticChecks.java b/tool/src/org/antlr/v4/semantics/BasicSemanticChecks.java
index cea367831f..d39b46cf0d 100644
--- a/tool/src/org/antlr/v4/semantics/BasicSemanticChecks.java
+++ b/tool/src/org/antlr/v4/semantics/BasicSemanticChecks.java
@@ -40,10 +40,7 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 import org.stringtemplate.v4.misc.MultiMap;
 
 import java.io.File;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 
 /** No side-effects except for setting options into the appropriate node.
  *  TODO:  make the side effects into a separate pass this
@@ -242,6 +239,44 @@ 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();
+		for (int i=0; i< nalts; i++) {
+			AltAST altAST = (AltAST)blk.getChild(i);
+			if ( altAST.altLabel!=null ) {
+				System.out.println("alt label "+altAST.altLabel);
+				ruleToAltLabels.map(rule.getRuleName(), altAST.altLabel);
+				String altLabel = altAST.altLabel.getText();
+				String prevRuleForLabel = altLabelToRuleName.get(altLabel);
+				if ( prevRuleForLabel!=null ) {
+					g.tool.errMgr.grammarError(ErrorType.ALT_LABEL_REDEF,
+											   g.fileName, rule.getToken(),
+											   altLabel,
+											   rule.getRuleName(),
+											   prevRuleForLabel);
+				}
+				else {
+					altLabelToRuleName.put(altLabel, rule.getRuleName());
+				}
+			}
+		}
+		System.out.println(rule.getRuleName()+" has "+ nalts +" alts");
+		List<GrammarAST> altLabels = ruleToAltLabels.get(rule.getRuleName());
+		int numAltLabels = 0;
+		if ( altLabels!=null ) numAltLabels = altLabels.size();
+		System.out.println("labels="+altLabels);
+		if ( numAltLabels>0 && nalts != numAltLabels ) {
+			g.tool.errMgr.grammarError(ErrorType.RULE_WITH_TOO_FEW_ALT_LABELS,
+									   g.fileName, rule.getToken(), rule.getRuleName());
+		}
+	}
+
 	// Routines to do the actual work of checking issues with a grammar.
 	// They are triggered by the visitor methods above.
 
diff --git a/tool/src/org/antlr/v4/tool/ErrorType.java b/tool/src/org/antlr/v4/tool/ErrorType.java
index af37575091..4b9f831b7e 100644
--- a/tool/src/org/antlr/v4/tool/ErrorType.java
+++ b/tool/src/org/antlr/v4/tool/ErrorType.java
@@ -139,7 +139,9 @@ public enum ErrorType {
 	ALL_OPS_NEED_SAME_ASSOC(118, "all operators of alt <arg> of left-recursive rule must have same associativity", ErrorSeverity.WARNING),
 	LEFT_RECURSION_CYCLES(119, "The following sets of rules are mutually left-recursive <arg:{c| [<c:{r|<r.name>}; separator=\", \">]}; separator=\" and \">", ErrorSeverity.ERROR),
 	MODE_NOT_IN_LEXER(120, "lexical modes are only allowed in lexer grammars", ErrorSeverity.ERROR),
-    CANNOT_FIND_ATTRIBUTE_NAME_IN_DECL(121, "cannot find an attribute name in attribute declaration", ErrorSeverity.ERROR),
+	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),
 	/** Documentation comment is unterminated */
     //UNTERMINATED_DOC_COMMENT(, "", ErrorSeverity.ERROR),
 
diff --git a/tool/src/org/antlr/v4/tool/ast/RuleAST.java b/tool/src/org/antlr/v4/tool/ast/RuleAST.java
index 5f47220180..257492538d 100644
--- a/tool/src/org/antlr/v4/tool/ast/RuleAST.java
+++ b/tool/src/org/antlr/v4/tool/ast/RuleAST.java
@@ -34,8 +34,6 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 import org.antlr.v4.parse.ANTLRParser;
 
 public class RuleAST extends GrammarASTWithOptions {
-
-
 	public RuleAST(GrammarAST node) {
 		super(node);
 	}
@@ -43,6 +41,17 @@ public RuleAST(GrammarAST node) {
 	public RuleAST(Token t) { super(t); }
     public RuleAST(int type) { super(type); }
 
+	public boolean isLexerRule() {
+		String name = getRuleName();
+		return name!=null && Character.isUpperCase(name.charAt(0));
+	}
+
+	public String getRuleName() {
+		GrammarAST nameNode = (GrammarAST)getChild(0);
+		if ( nameNode!=null ) return nameNode.getText();
+		return null;
+	}
+
 	@Override
 	public Tree dupNode() { return new RuleAST(this); }
 

From d00ec9d2274abf0b5efb39baa67d4eed7a2f664c Mon Sep 17 00:00:00 2001
From: Terence Parr <parrt@antlr.org>
Date: Thu, 16 Feb 2012 17:31:30 -0800
Subject: [PATCH 6/9] got -no prefix options working. rm'd dup error from
 toolError(); rm dbg print

---
 tool/playground/A.g4                                 |  6 ------
 tool/playground/AVisitor.java                        |  6 ++++--
 tool/src/org/antlr/v4/Tool.java                      |  7 ++++++-
 tool/src/org/antlr/v4/codegen/CodeGenPipeline.java   |  4 +++-
 .../org/antlr/v4/semantics/BasicSemanticChecks.java  |  3 ---
 tool/src/org/antlr/v4/tool/ErrorManager.java         | 12 ++++++++----
 tool/src/org/antlr/v4/tool/ErrorType.java            |  3 ++-
 7 files changed, 23 insertions(+), 18 deletions(-)

diff --git a/tool/playground/A.g4 b/tool/playground/A.g4
index ce79583fc5..9c2d6ea73d 100644
--- a/tool/playground/A.g4
+++ b/tool/playground/A.g4
@@ -8,11 +8,5 @@ e : e '*' e 		-> Mult
   | '(' e ')'		-> Parens
   ;
 
-x : A -> Foo
-  | B
-  ;
-
-y : Y -> Mult ;
-
 INT : [0-9]+ ;
 WS : [ \t\n]+ -> skip ;
diff --git a/tool/playground/AVisitor.java b/tool/playground/AVisitor.java
index 4bd72a0f0b..5730fa2d6b 100644
--- a/tool/playground/AVisitor.java
+++ b/tool/playground/AVisitor.java
@@ -1,8 +1,10 @@
+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.FooContext ctx);
 	T visit(AParser.AddContext ctx);
 	T visit(AParser.IntContext ctx);
-}
+}
\ No newline at end of file
diff --git a/tool/src/org/antlr/v4/Tool.java b/tool/src/org/antlr/v4/Tool.java
index b7a11c82d1..34172f8f3e 100644
--- a/tool/src/org/antlr/v4/Tool.java
+++ b/tool/src/org/antlr/v4/Tool.java
@@ -186,8 +186,10 @@ protected void handleArgs() {
 				grammarFiles.add(arg);
 				continue;
 			}
+			boolean found = false;
 			for (Option o : optionDefs) {
 				if ( arg.equals(o.name) ) {
+					found = true;
 					String argValue = null;
 					if ( o.argType==OptionArgType.STRING ) {
 						argValue = args[i];
@@ -198,7 +200,7 @@ protected void handleArgs() {
 					try {
 						Field f = c.getField(o.fieldName);
 						if ( argValue==null ) {
-							if ( o.fieldName.startsWith("-no-") ) f.setBoolean(this, false);
+							if ( arg.startsWith("-no-") ) f.setBoolean(this, false);
 							else f.setBoolean(this, true);
 						}
 						else f.set(this, argValue);
@@ -208,6 +210,9 @@ protected void handleArgs() {
 					}
 				}
 			}
+			if ( !found ) {
+				errMgr.toolError(ErrorType.INVALID_CMDLINE_ARG, arg);
+			}
 		}
 		if ( outputDirectory!=null ) {
 			if (outputDirectory.endsWith("/") ||
diff --git a/tool/src/org/antlr/v4/codegen/CodeGenPipeline.java b/tool/src/org/antlr/v4/codegen/CodeGenPipeline.java
index d89443fcd3..6b2286738f 100644
--- a/tool/src/org/antlr/v4/codegen/CodeGenPipeline.java
+++ b/tool/src/org/antlr/v4/codegen/CodeGenPipeline.java
@@ -46,9 +46,11 @@ public void process() {
 		}
 		else {
 			gen.writeRecognizer(gen.generateParser());
-			if ( g.tool.gen_listener) {
+			if ( g.tool.gen_listener ) {
 				gen.writeListener(gen.generateListener());
 				gen.writeBaseListener(gen.generateBaseListener());
+			}
+			if ( g.tool.gen_visitor ) {
 				gen.writeVisitor(gen.generateVisitor());
 				gen.writeBaseVisitor(gen.generateBaseVisitor());
 			}
diff --git a/tool/src/org/antlr/v4/semantics/BasicSemanticChecks.java b/tool/src/org/antlr/v4/semantics/BasicSemanticChecks.java
index d39b46cf0d..137326bbfb 100644
--- a/tool/src/org/antlr/v4/semantics/BasicSemanticChecks.java
+++ b/tool/src/org/antlr/v4/semantics/BasicSemanticChecks.java
@@ -250,7 +250,6 @@ public void finishRule(RuleAST rule, GrammarAST ID, GrammarAST block) {
 		for (int i=0; i< nalts; i++) {
 			AltAST altAST = (AltAST)blk.getChild(i);
 			if ( altAST.altLabel!=null ) {
-				System.out.println("alt label "+altAST.altLabel);
 				ruleToAltLabels.map(rule.getRuleName(), altAST.altLabel);
 				String altLabel = altAST.altLabel.getText();
 				String prevRuleForLabel = altLabelToRuleName.get(altLabel);
@@ -266,11 +265,9 @@ public void finishRule(RuleAST rule, GrammarAST ID, GrammarAST block) {
 				}
 			}
 		}
-		System.out.println(rule.getRuleName()+" has "+ nalts +" alts");
 		List<GrammarAST> altLabels = ruleToAltLabels.get(rule.getRuleName());
 		int numAltLabels = 0;
 		if ( altLabels!=null ) numAltLabels = altLabels.size();
-		System.out.println("labels="+altLabels);
 		if ( numAltLabels>0 && nalts != numAltLabels ) {
 			g.tool.errMgr.grammarError(ErrorType.RULE_WITH_TOO_FEW_ALT_LABELS,
 									   g.fileName, rule.getToken(), rule.getRuleName());
diff --git a/tool/src/org/antlr/v4/tool/ErrorManager.java b/tool/src/org/antlr/v4/tool/ErrorManager.java
index 8f6a884e76..1d5d09ad9c 100644
--- a/tool/src/org/antlr/v4/tool/ErrorManager.java
+++ b/tool/src/org/antlr/v4/tool/ErrorManager.java
@@ -30,11 +30,16 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 package org.antlr.v4.tool;
 
 import org.antlr.v4.Tool;
-import org.stringtemplate.v4.*;
-import org.stringtemplate.v4.misc.*;
+import org.stringtemplate.v4.ST;
+import org.stringtemplate.v4.STErrorListener;
+import org.stringtemplate.v4.STGroup;
+import org.stringtemplate.v4.STGroupFile;
+import org.stringtemplate.v4.misc.ErrorBuffer;
+import org.stringtemplate.v4.misc.STMessage;
 
 import java.net.URL;
-import java.util.*;
+import java.util.Collection;
+import java.util.Locale;
 
 public class ErrorManager {
 	public static final String FORMATS_DIR = "org/antlr/v4/tool/templates/messages/formats/";
@@ -190,7 +195,6 @@ public static void internalError(String error) {
 	public void toolError(ErrorType errorType, Object... args) {
 		ToolMessage msg = new ToolMessage(errorType, args);
 		emit(errorType, msg);
-		tool.error(msg);
 	}
 
 	public void toolError(ErrorType errorType, Throwable e, Object... args) {
diff --git a/tool/src/org/antlr/v4/tool/ErrorType.java b/tool/src/org/antlr/v4/tool/ErrorType.java
index 4b9f831b7e..94ecfbef43 100644
--- a/tool/src/org/antlr/v4/tool/ErrorType.java
+++ b/tool/src/org/antlr/v4/tool/ErrorType.java
@@ -43,8 +43,9 @@ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 public enum ErrorType {
     INVALID(0, "<INVALID>", ErrorSeverity.ERROR),
 
+	// Tool errors
 	CANNOT_WRITE_FILE(1, "cannot write file <arg>: <arg2>", ErrorSeverity.ERROR),
-//	CANNOT_CLOSE_FILE(2, "cannot close file <arg>", ErrorSeverity.ERROR),
+	INVALID_CMDLINE_ARG(2, "unknown command-line option <arg>", ErrorSeverity.ERROR),
 	CANNOT_FIND_TOKENS_FILE(3, "cannot find tokens file <arg>", ErrorSeverity.ERROR),
 	ERROR_READING_TOKENS_FILE(4, "cannot find tokens file <arg>: <arg2>", ErrorSeverity.ERROR),
 	DIR_NOT_FOUND(5, "directory not found: <arg>", ErrorSeverity.ERROR),

From c098e5c72964f0fff7d14a57f27d6ce133692667 Mon Sep 17 00:00:00 2001
From: Terence Parr <parrt@antlr.org>
Date: Thu, 16 Feb 2012 17:31:59 -0800
Subject: [PATCH 7/9] rm file

---
 tool/playground/ABaseVisitor.java | 10 ----------
 1 file changed, 10 deletions(-)
 delete mode 100644 tool/playground/ABaseVisitor.java

diff --git a/tool/playground/ABaseVisitor.java b/tool/playground/ABaseVisitor.java
deleted file mode 100644
index 355023fd63..0000000000
--- a/tool/playground/ABaseVisitor.java
+++ /dev/null
@@ -1,10 +0,0 @@
-import org.antlr.v4.runtime.tree.ParseTreeVisitor;
-
-public class ABaseVisitor<T> extends ParseTreeVisitor<T> implements AVisitor<T> {
-	public T visit(AParser.MultContext ctx) { visitChildren(ctx); return null; }
-	public T visit(AParser.ParensContext ctx) { visitChildren(ctx); return null; }
-	public T visit(AParser.sContext ctx) { visitChildren(ctx); return null; }
-	public T visit(AParser.FooContext ctx) { visitChildren(ctx); return null; }
-	public T visit(AParser.AddContext ctx) { visitChildren(ctx); return null; }
-	public T visit(AParser.IntContext ctx) { visitChildren(ctx); return null; }
-}

From 44c0c8ca5ef5db5f9a47e87a51452e8c1e5f90e1 Mon Sep 17 00:00:00 2001
From: Terence Parr <parrt@antlr.org>
Date: Thu, 16 Feb 2012 17:45:57 -0800
Subject: [PATCH 8/9] dont gen visitor unless -visitor option

---
 .../org/antlr/v4/codegen/model/decl/AltLabelStructDecl.java   | 4 +++-
 tool/src/org/antlr/v4/codegen/model/decl/StructDecl.java      | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

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 b027cb1ba6..54ca3bc0c1 100644
--- a/tool/src/org/antlr/v4/codegen/model/decl/AltLabelStructDecl.java
+++ b/tool/src/org/antlr/v4/codegen/model/decl/AltLabelStructDecl.java
@@ -50,7 +50,9 @@ public AltLabelStructDecl(OutputModelFactory factory, Rule r,
 	@Override
 	public void addDispatchMethods(Rule r) {
 		super.addDispatchMethods(r);
-		dispatchMethods.add(new VisitorDispatchMethod(factory));
+		if ( factory.getGrammar().tool.gen_visitor ) {
+			dispatchMethods.add(new VisitorDispatchMethod(factory));
+		}
 	}
 
 	@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 a4ebcfa5ab..0c3e2bef5b 100644
--- a/tool/src/org/antlr/v4/codegen/model/decl/StructDecl.java
+++ b/tool/src/org/antlr/v4/codegen/model/decl/StructDecl.java
@@ -58,7 +58,7 @@ public void addDispatchMethods(Rule r) {
 		dispatchMethods = new ArrayList<DispatchMethod>();
 		dispatchMethods.add(new ListenerDispatchMethod(factory, true));
 		dispatchMethods.add(new ListenerDispatchMethod(factory, false));
-		if ( !r.hasAltSpecificContexts() ) {
+		if ( factory.getGrammar().tool.gen_visitor && !r.hasAltSpecificContexts() ) {
 			dispatchMethods.add(new VisitorDispatchMethod(factory));
 		}
 	}

From c6fd89728797ea8b7fdcdbdfc5f8c1833d662eeb Mon Sep 17 00:00:00 2001
From: Terence Parr <parrt@antlr.org>
Date: Sat, 18 Feb 2012 12:40:47 -0800
Subject: [PATCH 9/9] altered naming scheme for listeners/visitors

* 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
---
 CHANGES.txt                                   |   8 ++
 tool/playground/A.g4                          |  10 +-
 tool/playground/AVisitor.java                 |  13 +-
 tool/playground/TestA.java                    | 115 ++++++++++++++----
 tool/playground/TestVisitor.java              |  14 +--
 .../v4/tool/templates/codegen/Java/Java.stg   |  56 ++++-----
 .../LeftRecursiveRuleTransformer.java         |  10 +-
 .../org/antlr/v4/codegen/CodeGenerator.java   |   1 +
 .../v4/codegen/OutputModelController.java     |   5 +-
 tool/src/org/antlr/v4/codegen/Target.java     |  15 ++-
 .../antlr/v4/codegen/model/ListenerFile.java  |   5 +-
 .../model/decl/AltLabelStructDecl.java        |   5 +-
 .../v4/codegen/model/decl/StructDecl.java     |  13 +-
 tool/src/org/antlr/v4/misc/Utils.java         |  12 +-
 .../v4/semantics/BasicSemanticChecks.java     |  40 +++---
 .../org/antlr/v4/semantics/RuleCollector.java |  39 +++---
 .../antlr/v4/semantics/SemanticPipeline.java  |  21 ++--
 tool/src/org/antlr/v4/tool/ErrorType.java     |   1 +
 18 files changed, 240 insertions(+), 143 deletions(-)

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),