diff --git a/ICSharpCode.NRefactory.VB.Tests/General/UnitTest.cs b/ICSharpCode.NRefactory.VB.Tests/General/UnitTest.cs
index 1a2e605869..3dfc9c2aa8 100644
--- a/ICSharpCode.NRefactory.VB.Tests/General/UnitTest.cs
+++ b/ICSharpCode.NRefactory.VB.Tests/General/UnitTest.cs
@@ -58,10 +58,10 @@ namespace ICSharpCode.NRefactory.VB.Tests
 //		}
 		
 		[Test]
-		public void TestIAstVisitor()
+		public void TestIDomVisitor()
 		{
 			Type[] allTypes = typeof(AbstractNode).Assembly.GetTypes();
-			Type visitor = typeof(IAstVisitor);
+			Type visitor = typeof(IDomVisitor);
 			
 			foreach (Type type in allTypes) {
 				if (type.IsClass && !type.IsAbstract && !type.IsNested && type.GetInterface(typeof(INode).FullName) != null && !type.Name.StartsWith("Null")) {
@@ -79,10 +79,10 @@ namespace ICSharpCode.NRefactory.VB.Tests
 		}
 		
 		[Test]
-		public void TestAbstractASTVisitorVisitor()
+		public void TestAbstractDomVisitorVisitor()
 		{
 			Type[] allTypes = typeof(AbstractNode).Assembly.GetTypes();
-			Type visitor = typeof(AbstractAstVisitor);
+			Type visitor = typeof(AbstractDomVisitor);
 			
 			foreach (Type type in allTypes) {
 				if (type.IsClass && !type.IsAbstract && !type.IsNested && type.GetInterface(typeof(INode).FullName) != null && !type.Name.StartsWith("Null")) {
diff --git a/ICSharpCode.NRefactory.VB.Tests/Lexer/CustomLexerTests.cs b/ICSharpCode.NRefactory.VB.Tests/Lexer/CustomLexerTests.cs
index 3f39ed0bc8..ce697d143e 100644
--- a/ICSharpCode.NRefactory.VB.Tests/Lexer/CustomLexerTests.cs
+++ b/ICSharpCode.NRefactory.VB.Tests/Lexer/CustomLexerTests.cs
@@ -11,7 +11,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 	[TestFixture]
 	public class CustomLexerTests
 	{
-		ILexer GenerateLexer(StringReader sr)
+		VBLexer GenerateLexer(StringReader sr)
 		{
 			return ParserFactory.CreateLexer(sr);
 		}
@@ -19,7 +19,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void TestSingleEOLForMulitpleLines()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Stop\n\n\nEnd"));
+			VBLexer lexer = GenerateLexer(new StringReader("Stop\n\n\nEnd"));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Stop));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.End));
@@ -30,7 +30,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void TestSingleEOLForMulitpleLinesWithContinuation()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Stop\n _\n\nEnd"));
+			VBLexer lexer = GenerateLexer(new StringReader("Stop\n _\n\nEnd"));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Stop));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.End));
@@ -41,7 +41,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void EscapedIdentifier()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("[Stop]"));
+			VBLexer lexer = GenerateLexer(new StringReader("[Stop]"));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF));
@@ -50,7 +50,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void IdentifierWithTypeCharacter()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Stop$"));
+			VBLexer lexer = GenerateLexer(new StringReader("Stop$"));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF));
@@ -59,7 +59,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void ExclamationMarkIsTypeCharacter()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("a!=b"));
+			VBLexer lexer = GenerateLexer(new StringReader("a!=b"));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Assign));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier));
@@ -70,7 +70,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void ExclamationMarkIsTypeCharacter2()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("a! b"));
+			VBLexer lexer = GenerateLexer(new StringReader("a! b"));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL));
@@ -80,7 +80,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void ExclamationMarkIsIdentifier()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("a!b"));
+			VBLexer lexer = GenerateLexer(new StringReader("a!b"));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.ExclamationMark));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier));
@@ -91,7 +91,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void ExclamationMarkIsIdentifier2()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("a![b]"));
+			VBLexer lexer = GenerateLexer(new StringReader("a![b]"));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.ExclamationMark));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier));
@@ -102,7 +102,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void RemCommentTest()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("a rem b"));
+			VBLexer lexer = GenerateLexer(new StringReader("a rem b"));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.Identifier));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF));
@@ -111,7 +111,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void RemCommentTest2()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("REM c"));
+			VBLexer lexer = GenerateLexer(new StringReader("REM c"));
 			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF));
 		}
 	}
diff --git a/ICSharpCode.NRefactory.VB.Tests/Lexer/ImplicitLineContinuationTests.cs b/ICSharpCode.NRefactory.VB.Tests/Lexer/ImplicitLineContinuationTests.cs
index 685dd4f812..0c24c847f4 100644
--- a/ICSharpCode.NRefactory.VB.Tests/Lexer/ImplicitLineContinuationTests.cs
+++ b/ICSharpCode.NRefactory.VB.Tests/Lexer/ImplicitLineContinuationTests.cs
@@ -26,7 +26,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
     End Sub
 End Module";
 			
-			ILexer lexer = GenerateLexer(new StringReader(code));
+			VBLexer lexer = GenerateLexer(new StringReader(code));
 			
 			CheckTokens(lexer, Tokens.Module, Tokens.Identifier, Tokens.EOL,
 			            Tokens.Sub, Tokens.Identifier, Tokens.OpenParenthesis,
@@ -54,7 +54,7 @@ End Module";
 	End Sub
 End Module";
 			
-			ILexer lexer = GenerateLexer(new StringReader(code));
+			VBLexer lexer = GenerateLexer(new StringReader(code));
 			
 			CheckTokens(lexer, Tokens.Module, Tokens.Identifier, Tokens.EOL,
 			            Tokens.Sub, Tokens.Identifier, Tokens.EOL,
@@ -78,7 +78,7 @@ End Module";
 	End Sub
 End Module";
 			
-			ILexer lexer = GenerateLexer(new StringReader(code));
+			VBLexer lexer = GenerateLexer(new StringReader(code));
 			
 			CheckTokens(lexer, Tokens.Module, Tokens.Identifier, Tokens.EOL,
 			            Tokens.Sub, Tokens.Identifier, Tokens.EOL,
@@ -97,7 +97,7 @@ End Module";
 	End Sub
 End Module";
 			
-			ILexer lexer = GenerateLexer(new StringReader(code));
+			VBLexer lexer = GenerateLexer(new StringReader(code));
 			
 			CheckTokens(lexer, Tokens.Module, Tokens.Identifier, Tokens.EOL,
 			            Tokens.Sub, Tokens.Identifier, Tokens.EOL,
@@ -120,7 +120,7 @@ End Module";
 	End Sub
 End Module";
 			
-			ILexer lexer = GenerateLexer(new StringReader(code));
+			VBLexer lexer = GenerateLexer(new StringReader(code));
 			
 			CheckTokens(lexer, Tokens.Module, Tokens.Identifier, Tokens.EOL,
 			            Tokens.Sub, Tokens.Identifier, Tokens.EOL,
@@ -145,7 +145,7 @@ End Module";
   End Sub
 End Class";
 			
-			ILexer lexer = GenerateLexer(new StringReader(code));
+			VBLexer lexer = GenerateLexer(new StringReader(code));
 			
 			CheckTokens(
 				lexer, Tokens.Class, Tokens.Identifier, Tokens.EOL,
@@ -175,7 +175,7 @@ Public Class TestContinuation
     End Sub
 End Class";
 			
-			ILexer lexer = GenerateLexer(new StringReader(code));
+			VBLexer lexer = GenerateLexer(new StringReader(code));
 			
 			CheckTokens(
 				lexer, Tokens.LessThan, Tokens.Identifier, Tokens.GreaterThan,
@@ -198,7 +198,7 @@ End Class";
 			string code = "<Assembly: AssemblyTitle(\"My.UnitTests\")>" + Environment.NewLine +
 				"<Assembly: AssemblyDescription(\"\")>";
 			
-			ILexer lexer = GenerateLexer(new StringReader(code));
+			VBLexer lexer = GenerateLexer(new StringReader(code));
 			
 			CheckTokens(
 				lexer, Tokens.LessThan, Tokens.Assembly, Tokens.Colon,
@@ -211,12 +211,12 @@ End Class";
 		}
 		
 		#region Helpers
-		ILexer GenerateLexer(StringReader sr)
+		VBLexer GenerateLexer(StringReader sr)
 		{
 			return ParserFactory.CreateLexer(sr);
 		}
 		
-		void CheckTokens(ILexer lexer, params int[] tokens)
+		void CheckTokens(VBLexer lexer, params int[] tokens)
 		{
 			for (int i = 0; i < tokens.Length; i++) {
 				int token = tokens[i];
diff --git a/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerContextTests.cs b/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerContextTests.cs
index 6a9472f8ae..760c7372a2 100644
--- a/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerContextTests.cs
+++ b/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerContextTests.cs
@@ -554,7 +554,7 @@ exit Global
 		void RunTest(string code, string expectedOutput)
 		{
 			ExpressionFinder p = new ExpressionFinder();
-			ILexer lexer = ParserFactory.CreateLexer(new StringReader(code));
+			VBLexer lexer = ParserFactory.CreateLexer(new StringReader(code));
 			Token t;
 			
 			do {
diff --git a/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerPositionTests.cs b/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerPositionTests.cs
index e40153c007..f227c5c8ad 100644
--- a/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerPositionTests.cs
+++ b/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerPositionTests.cs
@@ -11,7 +11,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 	[TestFixture]
 	public class LexerPositionTests
 	{
-		ILexer GenerateLexer(string s)
+		VBLexer GenerateLexer(string s)
 		{
 			return ParserFactory.CreateLexer(new StringReader(s));
 		}
@@ -19,7 +19,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void TestNewLine()
 		{
-			ILexer l = GenerateLexer("public\nstatic");
+			VBLexer l = GenerateLexer("public\nstatic");
 			Token t = l.NextToken();
 			Assert.AreEqual(Tokens.Public, t.Kind);
 			Assert.AreEqual(new Location(1, 1), t.Location);
@@ -37,7 +37,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void TestCarriageReturnNewLine()
 		{
-			ILexer l = GenerateLexer("public\r\nstatic");
+			VBLexer l = GenerateLexer("public\r\nstatic");
 			Token t = l.NextToken();
 			Assert.AreEqual(Tokens.Public, t.Kind);
 			Assert.AreEqual(new Location(1, 1), t.Location);
@@ -55,7 +55,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void TestPositionOfEOF1()
 		{
-			ILexer l = GenerateLexer("public");
+			VBLexer l = GenerateLexer("public");
 			l.NextToken(); // public
 			Token t = l.NextToken();
 			Assert.AreEqual(Tokens.EOL, t.Kind);
@@ -71,7 +71,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void TestPositionOfEOF2()
 		{
-			ILexer l = GenerateLexer("public _\n ");
+			VBLexer l = GenerateLexer("public _\n ");
 			l.NextToken(); // public
 			Token t = l.NextToken();
 			Assert.AreEqual(Tokens.EOL, t.Kind);
diff --git a/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerTests.cs b/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerTests.cs
index 2f2192b3a3..b181f4851f 100644
--- a/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerTests.cs
+++ b/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerTests.cs
@@ -11,7 +11,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 	[TestFixture]
 	public sealed class LexerTests
 	{
-		ILexer GenerateLexer(StringReader sr)
+		VBLexer GenerateLexer(StringReader sr)
 		{
 			return ParserFactory.CreateLexer(sr);
 		}
@@ -19,1519 +19,1519 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void TestAssign()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("="));
+			VBLexer lexer = GenerateLexer(new StringReader("="));
 			Assert.AreEqual(Tokens.Assign, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestColon()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(":"));
+			VBLexer lexer = GenerateLexer(new StringReader(":"));
 			Assert.AreEqual(Tokens.Colon, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestComma()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(","));
+			VBLexer lexer = GenerateLexer(new StringReader(","));
 			Assert.AreEqual(Tokens.Comma, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestConcatString()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("&"));
+			VBLexer lexer = GenerateLexer(new StringReader("&"));
 			Assert.AreEqual(Tokens.ConcatString, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestDiv()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("/"));
+			VBLexer lexer = GenerateLexer(new StringReader("/"));
 			Assert.AreEqual(Tokens.Div, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestDivInteger()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("\\"));
+			VBLexer lexer = GenerateLexer(new StringReader("\\"));
 			Assert.AreEqual(Tokens.DivInteger, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestDot()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("."));
+			VBLexer lexer = GenerateLexer(new StringReader("."));
 			Assert.AreEqual(Tokens.Dot, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestTripleDot()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("..."));
+			VBLexer lexer = GenerateLexer(new StringReader("..."));
 			Assert.AreEqual(Tokens.TripleDot, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestDotAt()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(".@"));
+			VBLexer lexer = GenerateLexer(new StringReader(".@"));
 			Assert.AreEqual(Tokens.DotAt, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestExclamationMark()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("!"));
+			VBLexer lexer = GenerateLexer(new StringReader("!"));
 			Assert.AreEqual(Tokens.ExclamationMark, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestMinus()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("-"));
+			VBLexer lexer = GenerateLexer(new StringReader("-"));
 			Assert.AreEqual(Tokens.Minus, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestPlus()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("+"));
+			VBLexer lexer = GenerateLexer(new StringReader("+"));
 			Assert.AreEqual(Tokens.Plus, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestPower()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("^"));
+			VBLexer lexer = GenerateLexer(new StringReader("^"));
 			Assert.AreEqual(Tokens.Power, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestQuestionMark()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("?"));
+			VBLexer lexer = GenerateLexer(new StringReader("?"));
 			Assert.AreEqual(Tokens.QuestionMark, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestTimes()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("*"));
+			VBLexer lexer = GenerateLexer(new StringReader("*"));
 			Assert.AreEqual(Tokens.Times, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestOpenCurlyBrace()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("{"));
+			VBLexer lexer = GenerateLexer(new StringReader("{"));
 			Assert.AreEqual(Tokens.OpenCurlyBrace, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCloseCurlyBrace()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("}"));
+			VBLexer lexer = GenerateLexer(new StringReader("}"));
 			Assert.AreEqual(Tokens.CloseCurlyBrace, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestOpenParenthesis()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("("));
+			VBLexer lexer = GenerateLexer(new StringReader("("));
 			Assert.AreEqual(Tokens.OpenParenthesis, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCloseParenthesis()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(")"));
+			VBLexer lexer = GenerateLexer(new StringReader(")"));
 			Assert.AreEqual(Tokens.CloseParenthesis, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestGreaterThan()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(">"));
+			VBLexer lexer = GenerateLexer(new StringReader(">"));
 			Assert.AreEqual(Tokens.GreaterThan, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestLessThan()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("<"));
+			VBLexer lexer = GenerateLexer(new StringReader("<"));
 			Assert.AreEqual(Tokens.LessThan, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestNotEqual()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("<>"));
+			VBLexer lexer = GenerateLexer(new StringReader("<>"));
 			Assert.AreEqual(Tokens.NotEqual, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestGreaterEqual()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(">="));
+			VBLexer lexer = GenerateLexer(new StringReader(">="));
 			Assert.AreEqual(Tokens.GreaterEqual, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestLessEqual()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("<="));
+			VBLexer lexer = GenerateLexer(new StringReader("<="));
 			Assert.AreEqual(Tokens.LessEqual, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestShiftLeft()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("<<"));
+			VBLexer lexer = GenerateLexer(new StringReader("<<"));
 			Assert.AreEqual(Tokens.ShiftLeft, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestShiftRight()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(">>"));
+			VBLexer lexer = GenerateLexer(new StringReader(">>"));
 			Assert.AreEqual(Tokens.ShiftRight, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestPlusAssign()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("+="));
+			VBLexer lexer = GenerateLexer(new StringReader("+="));
 			Assert.AreEqual(Tokens.PlusAssign, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestPowerAssign()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("^="));
+			VBLexer lexer = GenerateLexer(new StringReader("^="));
 			Assert.AreEqual(Tokens.PowerAssign, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestMinusAssign()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("-="));
+			VBLexer lexer = GenerateLexer(new StringReader("-="));
 			Assert.AreEqual(Tokens.MinusAssign, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestTimesAssign()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("*="));
+			VBLexer lexer = GenerateLexer(new StringReader("*="));
 			Assert.AreEqual(Tokens.TimesAssign, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestDivAssign()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("/="));
+			VBLexer lexer = GenerateLexer(new StringReader("/="));
 			Assert.AreEqual(Tokens.DivAssign, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestDivIntegerAssign()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("\\="));
+			VBLexer lexer = GenerateLexer(new StringReader("\\="));
 			Assert.AreEqual(Tokens.DivIntegerAssign, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestShiftLeftAssign()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("<<="));
+			VBLexer lexer = GenerateLexer(new StringReader("<<="));
 			Assert.AreEqual(Tokens.ShiftLeftAssign, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestShiftRightAssign()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(">>="));
+			VBLexer lexer = GenerateLexer(new StringReader(">>="));
 			Assert.AreEqual(Tokens.ShiftRightAssign, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestConcatStringAssign()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("&="));
+			VBLexer lexer = GenerateLexer(new StringReader("&="));
 			Assert.AreEqual(Tokens.ConcatStringAssign, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestColonAssign()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(":="));
+			VBLexer lexer = GenerateLexer(new StringReader(":="));
 			Assert.AreEqual(Tokens.ColonAssign, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestAddHandler()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("AddHandler"));
+			VBLexer lexer = GenerateLexer(new StringReader("AddHandler"));
 			Assert.AreEqual(Tokens.AddHandler, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestAddressOf()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("AddressOf"));
+			VBLexer lexer = GenerateLexer(new StringReader("AddressOf"));
 			Assert.AreEqual(Tokens.AddressOf, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestAggregate()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Aggregate"));
+			VBLexer lexer = GenerateLexer(new StringReader("Aggregate"));
 			Assert.AreEqual(Tokens.Aggregate, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestAlias()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Alias"));
+			VBLexer lexer = GenerateLexer(new StringReader("Alias"));
 			Assert.AreEqual(Tokens.Alias, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestAnd()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("And"));
+			VBLexer lexer = GenerateLexer(new StringReader("And"));
 			Assert.AreEqual(Tokens.And, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestAndAlso()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("AndAlso"));
+			VBLexer lexer = GenerateLexer(new StringReader("AndAlso"));
 			Assert.AreEqual(Tokens.AndAlso, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestAnsi()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Ansi"));
+			VBLexer lexer = GenerateLexer(new StringReader("Ansi"));
 			Assert.AreEqual(Tokens.Ansi, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestAs()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("As"));
+			VBLexer lexer = GenerateLexer(new StringReader("As"));
 			Assert.AreEqual(Tokens.As, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestAscending()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Ascending"));
+			VBLexer lexer = GenerateLexer(new StringReader("Ascending"));
 			Assert.AreEqual(Tokens.Ascending, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestAssembly()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Assembly"));
+			VBLexer lexer = GenerateLexer(new StringReader("Assembly"));
 			Assert.AreEqual(Tokens.Assembly, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestAuto()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Auto"));
+			VBLexer lexer = GenerateLexer(new StringReader("Auto"));
 			Assert.AreEqual(Tokens.Auto, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestBinary()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Binary"));
+			VBLexer lexer = GenerateLexer(new StringReader("Binary"));
 			Assert.AreEqual(Tokens.Binary, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestBoolean()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Boolean"));
+			VBLexer lexer = GenerateLexer(new StringReader("Boolean"));
 			Assert.AreEqual(Tokens.Boolean, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestByRef()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("ByRef"));
+			VBLexer lexer = GenerateLexer(new StringReader("ByRef"));
 			Assert.AreEqual(Tokens.ByRef, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestBy()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("By"));
+			VBLexer lexer = GenerateLexer(new StringReader("By"));
 			Assert.AreEqual(Tokens.By, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestByte()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Byte"));
+			VBLexer lexer = GenerateLexer(new StringReader("Byte"));
 			Assert.AreEqual(Tokens.Byte, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestByVal()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("ByVal"));
+			VBLexer lexer = GenerateLexer(new StringReader("ByVal"));
 			Assert.AreEqual(Tokens.ByVal, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCall()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Call"));
+			VBLexer lexer = GenerateLexer(new StringReader("Call"));
 			Assert.AreEqual(Tokens.Call, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCase()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Case"));
+			VBLexer lexer = GenerateLexer(new StringReader("Case"));
 			Assert.AreEqual(Tokens.Case, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCatch()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Catch"));
+			VBLexer lexer = GenerateLexer(new StringReader("Catch"));
 			Assert.AreEqual(Tokens.Catch, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCBool()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("CBool"));
+			VBLexer lexer = GenerateLexer(new StringReader("CBool"));
 			Assert.AreEqual(Tokens.CBool, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCByte()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("CByte"));
+			VBLexer lexer = GenerateLexer(new StringReader("CByte"));
 			Assert.AreEqual(Tokens.CByte, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCChar()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("CChar"));
+			VBLexer lexer = GenerateLexer(new StringReader("CChar"));
 			Assert.AreEqual(Tokens.CChar, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCDate()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("CDate"));
+			VBLexer lexer = GenerateLexer(new StringReader("CDate"));
 			Assert.AreEqual(Tokens.CDate, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCDbl()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("CDbl"));
+			VBLexer lexer = GenerateLexer(new StringReader("CDbl"));
 			Assert.AreEqual(Tokens.CDbl, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCDec()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("CDec"));
+			VBLexer lexer = GenerateLexer(new StringReader("CDec"));
 			Assert.AreEqual(Tokens.CDec, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestChar()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Char"));
+			VBLexer lexer = GenerateLexer(new StringReader("Char"));
 			Assert.AreEqual(Tokens.Char, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCInt()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("CInt"));
+			VBLexer lexer = GenerateLexer(new StringReader("CInt"));
 			Assert.AreEqual(Tokens.CInt, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestClass()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Class"));
+			VBLexer lexer = GenerateLexer(new StringReader("Class"));
 			Assert.AreEqual(Tokens.Class, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCLng()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("CLng"));
+			VBLexer lexer = GenerateLexer(new StringReader("CLng"));
 			Assert.AreEqual(Tokens.CLng, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCObj()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("CObj"));
+			VBLexer lexer = GenerateLexer(new StringReader("CObj"));
 			Assert.AreEqual(Tokens.CObj, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCompare()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Compare"));
+			VBLexer lexer = GenerateLexer(new StringReader("Compare"));
 			Assert.AreEqual(Tokens.Compare, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestConst()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Const"));
+			VBLexer lexer = GenerateLexer(new StringReader("Const"));
 			Assert.AreEqual(Tokens.Const, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestContinue()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Continue"));
+			VBLexer lexer = GenerateLexer(new StringReader("Continue"));
 			Assert.AreEqual(Tokens.Continue, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCSByte()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("CSByte"));
+			VBLexer lexer = GenerateLexer(new StringReader("CSByte"));
 			Assert.AreEqual(Tokens.CSByte, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCShort()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("CShort"));
+			VBLexer lexer = GenerateLexer(new StringReader("CShort"));
 			Assert.AreEqual(Tokens.CShort, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCSng()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("CSng"));
+			VBLexer lexer = GenerateLexer(new StringReader("CSng"));
 			Assert.AreEqual(Tokens.CSng, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCStr()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("CStr"));
+			VBLexer lexer = GenerateLexer(new StringReader("CStr"));
 			Assert.AreEqual(Tokens.CStr, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCType()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("CType"));
+			VBLexer lexer = GenerateLexer(new StringReader("CType"));
 			Assert.AreEqual(Tokens.CType, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCUInt()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("CUInt"));
+			VBLexer lexer = GenerateLexer(new StringReader("CUInt"));
 			Assert.AreEqual(Tokens.CUInt, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCULng()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("CULng"));
+			VBLexer lexer = GenerateLexer(new StringReader("CULng"));
 			Assert.AreEqual(Tokens.CULng, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCUShort()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("CUShort"));
+			VBLexer lexer = GenerateLexer(new StringReader("CUShort"));
 			Assert.AreEqual(Tokens.CUShort, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestCustom()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Custom"));
+			VBLexer lexer = GenerateLexer(new StringReader("Custom"));
 			Assert.AreEqual(Tokens.Custom, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestDate()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Date"));
+			VBLexer lexer = GenerateLexer(new StringReader("Date"));
 			Assert.AreEqual(Tokens.Date, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestDecimal()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Decimal"));
+			VBLexer lexer = GenerateLexer(new StringReader("Decimal"));
 			Assert.AreEqual(Tokens.Decimal, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestDeclare()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Declare"));
+			VBLexer lexer = GenerateLexer(new StringReader("Declare"));
 			Assert.AreEqual(Tokens.Declare, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestDefault()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Default"));
+			VBLexer lexer = GenerateLexer(new StringReader("Default"));
 			Assert.AreEqual(Tokens.Default, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestDelegate()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Delegate"));
+			VBLexer lexer = GenerateLexer(new StringReader("Delegate"));
 			Assert.AreEqual(Tokens.Delegate, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestDescending()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Descending"));
+			VBLexer lexer = GenerateLexer(new StringReader("Descending"));
 			Assert.AreEqual(Tokens.Descending, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestDim()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Dim"));
+			VBLexer lexer = GenerateLexer(new StringReader("Dim"));
 			Assert.AreEqual(Tokens.Dim, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestDirectCast()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("DirectCast"));
+			VBLexer lexer = GenerateLexer(new StringReader("DirectCast"));
 			Assert.AreEqual(Tokens.DirectCast, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestDistinct()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Distinct"));
+			VBLexer lexer = GenerateLexer(new StringReader("Distinct"));
 			Assert.AreEqual(Tokens.Distinct, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestDo()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Do"));
+			VBLexer lexer = GenerateLexer(new StringReader("Do"));
 			Assert.AreEqual(Tokens.Do, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestDouble()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Double"));
+			VBLexer lexer = GenerateLexer(new StringReader("Double"));
 			Assert.AreEqual(Tokens.Double, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestEach()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Each"));
+			VBLexer lexer = GenerateLexer(new StringReader("Each"));
 			Assert.AreEqual(Tokens.Each, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestElse()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Else"));
+			VBLexer lexer = GenerateLexer(new StringReader("Else"));
 			Assert.AreEqual(Tokens.Else, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestElseIf()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("ElseIf"));
+			VBLexer lexer = GenerateLexer(new StringReader("ElseIf"));
 			Assert.AreEqual(Tokens.ElseIf, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestEnd()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("End"));
+			VBLexer lexer = GenerateLexer(new StringReader("End"));
 			Assert.AreEqual(Tokens.End, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestEndIf()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("EndIf"));
+			VBLexer lexer = GenerateLexer(new StringReader("EndIf"));
 			Assert.AreEqual(Tokens.EndIf, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestEnum()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Enum"));
+			VBLexer lexer = GenerateLexer(new StringReader("Enum"));
 			Assert.AreEqual(Tokens.Enum, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestEquals()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Equals"));
+			VBLexer lexer = GenerateLexer(new StringReader("Equals"));
 			Assert.AreEqual(Tokens.Equals, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestErase()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Erase"));
+			VBLexer lexer = GenerateLexer(new StringReader("Erase"));
 			Assert.AreEqual(Tokens.Erase, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestError()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Error"));
+			VBLexer lexer = GenerateLexer(new StringReader("Error"));
 			Assert.AreEqual(Tokens.Error, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestEvent()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Event"));
+			VBLexer lexer = GenerateLexer(new StringReader("Event"));
 			Assert.AreEqual(Tokens.Event, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestExit()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Exit"));
+			VBLexer lexer = GenerateLexer(new StringReader("Exit"));
 			Assert.AreEqual(Tokens.Exit, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestExplicit()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Explicit"));
+			VBLexer lexer = GenerateLexer(new StringReader("Explicit"));
 			Assert.AreEqual(Tokens.Explicit, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestFalse()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("False"));
+			VBLexer lexer = GenerateLexer(new StringReader("False"));
 			Assert.AreEqual(Tokens.False, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestFinally()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Finally"));
+			VBLexer lexer = GenerateLexer(new StringReader("Finally"));
 			Assert.AreEqual(Tokens.Finally, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestFor()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("For"));
+			VBLexer lexer = GenerateLexer(new StringReader("For"));
 			Assert.AreEqual(Tokens.For, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestFriend()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Friend"));
+			VBLexer lexer = GenerateLexer(new StringReader("Friend"));
 			Assert.AreEqual(Tokens.Friend, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestFrom()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("From"));
+			VBLexer lexer = GenerateLexer(new StringReader("From"));
 			Assert.AreEqual(Tokens.From, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestFunction()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Function"));
+			VBLexer lexer = GenerateLexer(new StringReader("Function"));
 			Assert.AreEqual(Tokens.Function, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestGet()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Get"));
+			VBLexer lexer = GenerateLexer(new StringReader("Get"));
 			Assert.AreEqual(Tokens.Get, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestGetType()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("GetType"));
+			VBLexer lexer = GenerateLexer(new StringReader("GetType"));
 			Assert.AreEqual(Tokens.GetType, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestGlobal()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Global"));
+			VBLexer lexer = GenerateLexer(new StringReader("Global"));
 			Assert.AreEqual(Tokens.Global, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestGoSub()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("GoSub"));
+			VBLexer lexer = GenerateLexer(new StringReader("GoSub"));
 			Assert.AreEqual(Tokens.GoSub, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestGoTo()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("GoTo"));
+			VBLexer lexer = GenerateLexer(new StringReader("GoTo"));
 			Assert.AreEqual(Tokens.GoTo, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestGroup()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Group"));
+			VBLexer lexer = GenerateLexer(new StringReader("Group"));
 			Assert.AreEqual(Tokens.Group, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestHandles()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Handles"));
+			VBLexer lexer = GenerateLexer(new StringReader("Handles"));
 			Assert.AreEqual(Tokens.Handles, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestIf()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("If"));
+			VBLexer lexer = GenerateLexer(new StringReader("If"));
 			Assert.AreEqual(Tokens.If, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestImplements()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Implements"));
+			VBLexer lexer = GenerateLexer(new StringReader("Implements"));
 			Assert.AreEqual(Tokens.Implements, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestImports()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Imports"));
+			VBLexer lexer = GenerateLexer(new StringReader("Imports"));
 			Assert.AreEqual(Tokens.Imports, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestIn()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("In"));
+			VBLexer lexer = GenerateLexer(new StringReader("In"));
 			Assert.AreEqual(Tokens.In, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestInfer()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Infer"));
+			VBLexer lexer = GenerateLexer(new StringReader("Infer"));
 			Assert.AreEqual(Tokens.Infer, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestInherits()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Inherits"));
+			VBLexer lexer = GenerateLexer(new StringReader("Inherits"));
 			Assert.AreEqual(Tokens.Inherits, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestInteger()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Integer"));
+			VBLexer lexer = GenerateLexer(new StringReader("Integer"));
 			Assert.AreEqual(Tokens.Integer, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestInterface()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Interface"));
+			VBLexer lexer = GenerateLexer(new StringReader("Interface"));
 			Assert.AreEqual(Tokens.Interface, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestInto()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Into"));
+			VBLexer lexer = GenerateLexer(new StringReader("Into"));
 			Assert.AreEqual(Tokens.Into, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestIs()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Is"));
+			VBLexer lexer = GenerateLexer(new StringReader("Is"));
 			Assert.AreEqual(Tokens.Is, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestIsNot()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("IsNot"));
+			VBLexer lexer = GenerateLexer(new StringReader("IsNot"));
 			Assert.AreEqual(Tokens.IsNot, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestJoin()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Join"));
+			VBLexer lexer = GenerateLexer(new StringReader("Join"));
 			Assert.AreEqual(Tokens.Join, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestKey()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Key"));
+			VBLexer lexer = GenerateLexer(new StringReader("Key"));
 			Assert.AreEqual(Tokens.Key, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestLet()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Let"));
+			VBLexer lexer = GenerateLexer(new StringReader("Let"));
 			Assert.AreEqual(Tokens.Let, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestLib()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Lib"));
+			VBLexer lexer = GenerateLexer(new StringReader("Lib"));
 			Assert.AreEqual(Tokens.Lib, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestLike()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Like"));
+			VBLexer lexer = GenerateLexer(new StringReader("Like"));
 			Assert.AreEqual(Tokens.Like, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestLong()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Long"));
+			VBLexer lexer = GenerateLexer(new StringReader("Long"));
 			Assert.AreEqual(Tokens.Long, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestLoop()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Loop"));
+			VBLexer lexer = GenerateLexer(new StringReader("Loop"));
 			Assert.AreEqual(Tokens.Loop, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestMe()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Me"));
+			VBLexer lexer = GenerateLexer(new StringReader("Me"));
 			Assert.AreEqual(Tokens.Me, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestMod()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Mod"));
+			VBLexer lexer = GenerateLexer(new StringReader("Mod"));
 			Assert.AreEqual(Tokens.Mod, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestModule()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Module"));
+			VBLexer lexer = GenerateLexer(new StringReader("Module"));
 			Assert.AreEqual(Tokens.Module, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestMustInherit()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("MustInherit"));
+			VBLexer lexer = GenerateLexer(new StringReader("MustInherit"));
 			Assert.AreEqual(Tokens.MustInherit, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestMustOverride()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("MustOverride"));
+			VBLexer lexer = GenerateLexer(new StringReader("MustOverride"));
 			Assert.AreEqual(Tokens.MustOverride, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestMyBase()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("MyBase"));
+			VBLexer lexer = GenerateLexer(new StringReader("MyBase"));
 			Assert.AreEqual(Tokens.MyBase, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestMyClass()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("MyClass"));
+			VBLexer lexer = GenerateLexer(new StringReader("MyClass"));
 			Assert.AreEqual(Tokens.MyClass, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestNamespace()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Namespace"));
+			VBLexer lexer = GenerateLexer(new StringReader("Namespace"));
 			Assert.AreEqual(Tokens.Namespace, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestNarrowing()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Narrowing"));
+			VBLexer lexer = GenerateLexer(new StringReader("Narrowing"));
 			Assert.AreEqual(Tokens.Narrowing, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestNew()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("New"));
+			VBLexer lexer = GenerateLexer(new StringReader("New"));
 			Assert.AreEqual(Tokens.New, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestNext()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Next"));
+			VBLexer lexer = GenerateLexer(new StringReader("Next"));
 			Assert.AreEqual(Tokens.Next, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestNot()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Not"));
+			VBLexer lexer = GenerateLexer(new StringReader("Not"));
 			Assert.AreEqual(Tokens.Not, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestNothing()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Nothing"));
+			VBLexer lexer = GenerateLexer(new StringReader("Nothing"));
 			Assert.AreEqual(Tokens.Nothing, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestNotInheritable()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("NotInheritable"));
+			VBLexer lexer = GenerateLexer(new StringReader("NotInheritable"));
 			Assert.AreEqual(Tokens.NotInheritable, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestNotOverridable()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("NotOverridable"));
+			VBLexer lexer = GenerateLexer(new StringReader("NotOverridable"));
 			Assert.AreEqual(Tokens.NotOverridable, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestObject()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Object"));
+			VBLexer lexer = GenerateLexer(new StringReader("Object"));
 			Assert.AreEqual(Tokens.Object, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestOf()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Of"));
+			VBLexer lexer = GenerateLexer(new StringReader("Of"));
 			Assert.AreEqual(Tokens.Of, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestOff()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Off"));
+			VBLexer lexer = GenerateLexer(new StringReader("Off"));
 			Assert.AreEqual(Tokens.Off, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestOn()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("On"));
+			VBLexer lexer = GenerateLexer(new StringReader("On"));
 			Assert.AreEqual(Tokens.On, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestOperator()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Operator"));
+			VBLexer lexer = GenerateLexer(new StringReader("Operator"));
 			Assert.AreEqual(Tokens.Operator, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestOption()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Option"));
+			VBLexer lexer = GenerateLexer(new StringReader("Option"));
 			Assert.AreEqual(Tokens.Option, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestOptional()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Optional"));
+			VBLexer lexer = GenerateLexer(new StringReader("Optional"));
 			Assert.AreEqual(Tokens.Optional, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestOr()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Or"));
+			VBLexer lexer = GenerateLexer(new StringReader("Or"));
 			Assert.AreEqual(Tokens.Or, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestOrder()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Order"));
+			VBLexer lexer = GenerateLexer(new StringReader("Order"));
 			Assert.AreEqual(Tokens.Order, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestOrElse()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("OrElse"));
+			VBLexer lexer = GenerateLexer(new StringReader("OrElse"));
 			Assert.AreEqual(Tokens.OrElse, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestOut()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Out"));
+			VBLexer lexer = GenerateLexer(new StringReader("Out"));
 			Assert.AreEqual(Tokens.Out, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestOverloads()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Overloads"));
+			VBLexer lexer = GenerateLexer(new StringReader("Overloads"));
 			Assert.AreEqual(Tokens.Overloads, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestOverridable()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Overridable"));
+			VBLexer lexer = GenerateLexer(new StringReader("Overridable"));
 			Assert.AreEqual(Tokens.Overridable, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestOverrides()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Overrides"));
+			VBLexer lexer = GenerateLexer(new StringReader("Overrides"));
 			Assert.AreEqual(Tokens.Overrides, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestParamArray()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("ParamArray"));
+			VBLexer lexer = GenerateLexer(new StringReader("ParamArray"));
 			Assert.AreEqual(Tokens.ParamArray, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestPartial()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Partial"));
+			VBLexer lexer = GenerateLexer(new StringReader("Partial"));
 			Assert.AreEqual(Tokens.Partial, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestPreserve()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Preserve"));
+			VBLexer lexer = GenerateLexer(new StringReader("Preserve"));
 			Assert.AreEqual(Tokens.Preserve, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestPrivate()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Private"));
+			VBLexer lexer = GenerateLexer(new StringReader("Private"));
 			Assert.AreEqual(Tokens.Private, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestProperty()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Property"));
+			VBLexer lexer = GenerateLexer(new StringReader("Property"));
 			Assert.AreEqual(Tokens.Property, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestProtected()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Protected"));
+			VBLexer lexer = GenerateLexer(new StringReader("Protected"));
 			Assert.AreEqual(Tokens.Protected, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestPublic()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Public"));
+			VBLexer lexer = GenerateLexer(new StringReader("Public"));
 			Assert.AreEqual(Tokens.Public, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestRaiseEvent()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("RaiseEvent"));
+			VBLexer lexer = GenerateLexer(new StringReader("RaiseEvent"));
 			Assert.AreEqual(Tokens.RaiseEvent, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestReadOnly()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("ReadOnly"));
+			VBLexer lexer = GenerateLexer(new StringReader("ReadOnly"));
 			Assert.AreEqual(Tokens.ReadOnly, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestReDim()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("ReDim"));
+			VBLexer lexer = GenerateLexer(new StringReader("ReDim"));
 			Assert.AreEqual(Tokens.ReDim, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestRemoveHandler()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("RemoveHandler"));
+			VBLexer lexer = GenerateLexer(new StringReader("RemoveHandler"));
 			Assert.AreEqual(Tokens.RemoveHandler, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestResume()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Resume"));
+			VBLexer lexer = GenerateLexer(new StringReader("Resume"));
 			Assert.AreEqual(Tokens.Resume, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestReturn()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Return"));
+			VBLexer lexer = GenerateLexer(new StringReader("Return"));
 			Assert.AreEqual(Tokens.Return, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestSByte()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("SByte"));
+			VBLexer lexer = GenerateLexer(new StringReader("SByte"));
 			Assert.AreEqual(Tokens.SByte, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestSelect()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Select"));
+			VBLexer lexer = GenerateLexer(new StringReader("Select"));
 			Assert.AreEqual(Tokens.Select, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestSet()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Set"));
+			VBLexer lexer = GenerateLexer(new StringReader("Set"));
 			Assert.AreEqual(Tokens.Set, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestShadows()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Shadows"));
+			VBLexer lexer = GenerateLexer(new StringReader("Shadows"));
 			Assert.AreEqual(Tokens.Shadows, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestShared()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Shared"));
+			VBLexer lexer = GenerateLexer(new StringReader("Shared"));
 			Assert.AreEqual(Tokens.Shared, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestShort()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Short"));
+			VBLexer lexer = GenerateLexer(new StringReader("Short"));
 			Assert.AreEqual(Tokens.Short, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestSingle()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Single"));
+			VBLexer lexer = GenerateLexer(new StringReader("Single"));
 			Assert.AreEqual(Tokens.Single, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestSkip()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Skip"));
+			VBLexer lexer = GenerateLexer(new StringReader("Skip"));
 			Assert.AreEqual(Tokens.Skip, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestStatic()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Static"));
+			VBLexer lexer = GenerateLexer(new StringReader("Static"));
 			Assert.AreEqual(Tokens.Static, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestStep()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Step"));
+			VBLexer lexer = GenerateLexer(new StringReader("Step"));
 			Assert.AreEqual(Tokens.Step, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestStop()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Stop"));
+			VBLexer lexer = GenerateLexer(new StringReader("Stop"));
 			Assert.AreEqual(Tokens.Stop, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestStrict()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Strict"));
+			VBLexer lexer = GenerateLexer(new StringReader("Strict"));
 			Assert.AreEqual(Tokens.Strict, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestString()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("String"));
+			VBLexer lexer = GenerateLexer(new StringReader("String"));
 			Assert.AreEqual(Tokens.String, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestStructure()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Structure"));
+			VBLexer lexer = GenerateLexer(new StringReader("Structure"));
 			Assert.AreEqual(Tokens.Structure, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestSub()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Sub"));
+			VBLexer lexer = GenerateLexer(new StringReader("Sub"));
 			Assert.AreEqual(Tokens.Sub, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestSyncLock()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("SyncLock"));
+			VBLexer lexer = GenerateLexer(new StringReader("SyncLock"));
 			Assert.AreEqual(Tokens.SyncLock, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestTake()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Take"));
+			VBLexer lexer = GenerateLexer(new StringReader("Take"));
 			Assert.AreEqual(Tokens.Take, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestText()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Text"));
+			VBLexer lexer = GenerateLexer(new StringReader("Text"));
 			Assert.AreEqual(Tokens.Text, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestThen()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Then"));
+			VBLexer lexer = GenerateLexer(new StringReader("Then"));
 			Assert.AreEqual(Tokens.Then, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestThrow()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Throw"));
+			VBLexer lexer = GenerateLexer(new StringReader("Throw"));
 			Assert.AreEqual(Tokens.Throw, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestTo()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("To"));
+			VBLexer lexer = GenerateLexer(new StringReader("To"));
 			Assert.AreEqual(Tokens.To, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestTrue()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("True"));
+			VBLexer lexer = GenerateLexer(new StringReader("True"));
 			Assert.AreEqual(Tokens.True, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestTry()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Try"));
+			VBLexer lexer = GenerateLexer(new StringReader("Try"));
 			Assert.AreEqual(Tokens.Try, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestTryCast()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("TryCast"));
+			VBLexer lexer = GenerateLexer(new StringReader("TryCast"));
 			Assert.AreEqual(Tokens.TryCast, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestTypeOf()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("TypeOf"));
+			VBLexer lexer = GenerateLexer(new StringReader("TypeOf"));
 			Assert.AreEqual(Tokens.TypeOf, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestUInteger()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("UInteger"));
+			VBLexer lexer = GenerateLexer(new StringReader("UInteger"));
 			Assert.AreEqual(Tokens.UInteger, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestULong()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("ULong"));
+			VBLexer lexer = GenerateLexer(new StringReader("ULong"));
 			Assert.AreEqual(Tokens.ULong, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestUnicode()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Unicode"));
+			VBLexer lexer = GenerateLexer(new StringReader("Unicode"));
 			Assert.AreEqual(Tokens.Unicode, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestUntil()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Until"));
+			VBLexer lexer = GenerateLexer(new StringReader("Until"));
 			Assert.AreEqual(Tokens.Until, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestUShort()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("UShort"));
+			VBLexer lexer = GenerateLexer(new StringReader("UShort"));
 			Assert.AreEqual(Tokens.UShort, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestUsing()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Using"));
+			VBLexer lexer = GenerateLexer(new StringReader("Using"));
 			Assert.AreEqual(Tokens.Using, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestVariant()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Variant"));
+			VBLexer lexer = GenerateLexer(new StringReader("Variant"));
 			Assert.AreEqual(Tokens.Variant, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestWend()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Wend"));
+			VBLexer lexer = GenerateLexer(new StringReader("Wend"));
 			Assert.AreEqual(Tokens.Wend, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestWhen()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("When"));
+			VBLexer lexer = GenerateLexer(new StringReader("When"));
 			Assert.AreEqual(Tokens.When, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestWhere()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Where"));
+			VBLexer lexer = GenerateLexer(new StringReader("Where"));
 			Assert.AreEqual(Tokens.Where, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestWhile()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("While"));
+			VBLexer lexer = GenerateLexer(new StringReader("While"));
 			Assert.AreEqual(Tokens.While, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestWidening()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Widening"));
+			VBLexer lexer = GenerateLexer(new StringReader("Widening"));
 			Assert.AreEqual(Tokens.Widening, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestWith()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("With"));
+			VBLexer lexer = GenerateLexer(new StringReader("With"));
 			Assert.AreEqual(Tokens.With, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestWithEvents()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("WithEvents"));
+			VBLexer lexer = GenerateLexer(new StringReader("WithEvents"));
 			Assert.AreEqual(Tokens.WithEvents, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestWriteOnly()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("WriteOnly"));
+			VBLexer lexer = GenerateLexer(new StringReader("WriteOnly"));
 			Assert.AreEqual(Tokens.WriteOnly, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestXor()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("Xor"));
+			VBLexer lexer = GenerateLexer(new StringReader("Xor"));
 			Assert.AreEqual(Tokens.Xor, lexer.NextToken().Kind);
 		}
 
 		[Test]
 		public void TestGetXmlNamespace()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("GetXmlNamespace"));
+			VBLexer lexer = GenerateLexer(new StringReader("GetXmlNamespace"));
 			Assert.AreEqual(Tokens.GetXmlNamespace, lexer.NextToken().Kind);
 		}
 	}
diff --git a/ICSharpCode.NRefactory.VB.Tests/Lexer/LiteralsTests.cs b/ICSharpCode.NRefactory.VB.Tests/Lexer/LiteralsTests.cs
index 5c697e0f97..c1f32fbaf3 100644
--- a/ICSharpCode.NRefactory.VB.Tests/Lexer/LiteralsTests.cs
+++ b/ICSharpCode.NRefactory.VB.Tests/Lexer/LiteralsTests.cs
@@ -11,14 +11,14 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 	[TestFixture]
 	public sealed class LiteralsTests
 	{
-		ILexer GenerateLexer(StringReader sr)
+		VBLexer GenerateLexer(StringReader sr)
 		{
 			return ParserFactory.CreateLexer(sr);
 		}
 		
 		Token GetSingleToken(string text)
 		{
-			ILexer lexer = GenerateLexer(new StringReader(text));
+			VBLexer lexer = GenerateLexer(new StringReader(text));
 			Token t = lexer.NextToken();
 			Assert.AreEqual(Tokens.EOL, lexer.NextToken().Kind, "Tokens.EOL");
 			Assert.AreEqual(Tokens.EOF, lexer.NextToken().Kind, "Tokens.EOF");
@@ -100,7 +100,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void TestIncompleteHexadecimal()
 		{
-			ILexer lexer = GenerateLexer(new StringReader("&H\r\nabc"));
+			VBLexer lexer = GenerateLexer(new StringReader("&H\r\nabc"));
 			Token t = lexer.NextToken();
 			Assert.AreEqual(Tokens.LiteralInteger, t.Kind);
 			Assert.AreEqual(0, (int)t.LiteralValue);
diff --git a/ICSharpCode.NRefactory.VB.Tests/Lexer/XmlModeLexerTests.cs b/ICSharpCode.NRefactory.VB.Tests/Lexer/XmlModeLexerTests.cs
index 82970dbfc3..e582bd2a1c 100644
--- a/ICSharpCode.NRefactory.VB.Tests/Lexer/XmlModeLexerTests.cs
+++ b/ICSharpCode.NRefactory.VB.Tests/Lexer/XmlModeLexerTests.cs
@@ -16,7 +16,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void TagWithContent()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement("Dim x = <Test>Hello World</Test>")));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Dim x = <Test>Hello World</Test>")));
 			
 			CheckHead(lexer);
 			
@@ -37,7 +37,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void HtmlText()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement("Dim x = <div><h1>Title</h1>" +
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Dim x = <div><h1>Title</h1>" +
 			                                                            "<p>test test <br /> test</p></div>")));
 			
 			CheckHead(lexer);
@@ -96,7 +96,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void XmlLiteralsExample1()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement("Dim xml = <menu>\n" +
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Dim xml = <menu>\n" +
 			                                                            "              <course name=\"appetizer\">\n" +
 			                                                            "                  <dish>Shrimp Cocktail</dish>\n" +
 			                                                            "                  <dish>Escargot</dish>\n" +
@@ -176,7 +176,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void SimpleXmlWithComments()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(@"Dim x = <?xml version=""1.0""?> <!-- Test file -->
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(@"Dim x = <?xml version=""1.0""?> <!-- Test file -->
 			                                                                      <Test>
 			                                                                        <!-- Test data -->
 			                                                                        <Data />
@@ -198,7 +198,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void SimpleEmptyTag()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement("Dim x = <Test />")));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Dim x = <Test />")));
 			
 			CheckHead(lexer);
 			
@@ -211,7 +211,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 		[Test]
 		public void SimpleTag()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement("Dim x = <Test></Test>")));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Dim x = <Test></Test>")));
 			
 			CheckHead(lexer);
 			
@@ -241,7 +241,7 @@ Class TestClass
 	End Sub
 End Class";
 			
-			ILexer lexer = GenerateLexer(new StringReader(code));
+			VBLexer lexer = GenerateLexer(new StringReader(code));
 			
 			CheckTokens(lexer, Tokens.Imports, Tokens.Identifier, Tokens.EOL,
 			            Tokens.Imports, Tokens.Identifier, Tokens.Dot, Tokens.Identifier, Tokens.EOL,
@@ -300,7 +300,7 @@ namespace DefaultNamespace
 			</template>
 			";
 			
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(xml)));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(xml)));
 			
 			CheckHead(lexer);
 			
@@ -346,7 +346,7 @@ namespace DefaultNamespace
                       </course>
                   </menu>";
 			
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(code)));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(code)));
 			
 			CheckHead(lexer);
 			
@@ -382,7 +382,7 @@ namespace DefaultNamespace
                                <name><%= MyName %></name>
                            </>";
 			
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(code)));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(code)));
 			
 			CheckHead(lexer);
 			
@@ -404,7 +404,7 @@ For Each item In childAxis
     Console.WriteLine(item.@name)
 Next";
 			
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(code)));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(code)));
 			
 			CheckHead(lexer);
 			
@@ -423,7 +423,7 @@ Next";
 		[Test]
 		public void GetXmlNamespace()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement("Dim name = GetXmlNamespace(x)")));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Dim name = GetXmlNamespace(x)")));
 			
 			CheckHead(lexer);
 			
@@ -436,7 +436,7 @@ Next";
 		[Test]
 		public void GetXmlNamespace2()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement("Dim name = GetXmlNamespace(db-name)")));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Dim name = GetXmlNamespace(db-name)")));
 			
 			CheckHead(lexer);
 			
@@ -450,7 +450,7 @@ Next";
 		[Test]
 		public void XmlInSelect()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement("Dim data = From x In list Select <test>x</test>")));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Dim data = From x In list Select <test>x</test>")));
 			
 			CheckHead(lexer);
 			
@@ -465,7 +465,7 @@ Next";
 		[Test]
 		public void IfExpressionTest()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement("Dim name = If(a <> 2, 4, 8)")));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Dim name = If(a <> 2, 4, 8)")));
 			
 			CheckHead(lexer);
 			
@@ -479,7 +479,7 @@ Next";
 		[Test]
 		public void IfStatementTest()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement("If a <> 2 Then Return")));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement("If a <> 2 Then Return")));
 			
 			CheckHead(lexer);
 			
@@ -493,7 +493,7 @@ Next";
 		[Test]
 		public void Bug1()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(@"Dim xml = <!-- test -->")));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(@"Dim xml = <!-- test -->")));
 			
 			CheckHead(lexer);
 			
@@ -505,7 +505,7 @@ Next";
 		[Test]
 		public void Bug2()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(@"Dim xml = <?xml?><Data /><!-- test -->")));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(@"Dim xml = <?xml?><Data /><!-- test -->")));
 			
 			CheckHead(lexer);
 			
@@ -519,7 +519,7 @@ Next";
 		[Test]
 		public void Bug3()
 		{
-			ILexer lexer = GenerateLexerForSnippet(new StringReader("New String() {}"), SnippetType.Expression);
+			VBLexer lexer = GenerateLexerForSnippet(new StringReader("New String() {}"), SnippetType.Expression);
 			
 			CheckTokens(lexer, Tokens.New, Tokens.String, Tokens.OpenParenthesis,
 			            Tokens.CloseParenthesis, Tokens.OpenCurlyBrace, Tokens.CloseCurlyBrace);
@@ -528,7 +528,7 @@ Next";
 		[Test]
 		public void Bug4()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(@"Dim x = From kvp As KeyValuePair(Of String, DataGridViewCellStyle) In styleCache.CellStyleCache _
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(@"Dim x = From kvp As KeyValuePair(Of String, DataGridViewCellStyle) In styleCache.CellStyleCache _
                             Select includeStyle(kvp.Key, kvp.Value)")));
 			
 			CheckHead(lexer);
@@ -545,7 +545,7 @@ Next";
 		[Test]
 		public void LessThanCheck()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(@"Dim xml = <!-- test --><Data")));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(@"Dim xml = <!-- test --><Data")));
 			
 			CheckHead(lexer);
 			
@@ -560,7 +560,7 @@ Next";
 		[Test]
 		public void MethodInvocation()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement("DoSomething(<Test />, True)")));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement("DoSomething(<Test />, True)")));
 			
 			CheckHead(lexer);
 			
@@ -574,7 +574,7 @@ Next";
 		[Test]
 		public void AddHandlerStatement()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement("AddHandler <Test />, True")));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement("AddHandler <Test />, True")));
 			
 			CheckHead(lexer);
 			
@@ -587,7 +587,7 @@ Next";
 		[Test]
 		public void AddHandlerStatement2()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement("AddHandler <x />, <y />")));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement("AddHandler <x />, <y />")));
 			
 			CheckHead(lexer);
 			
@@ -601,7 +601,7 @@ Next";
 		[Test]
 		public void RemoveHandlerStatement()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement("RemoveHandler <x />, <Data>5</Data>")));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement("RemoveHandler <x />, <Data>5</Data>")));
 			
 			CheckHead(lexer);
 			
@@ -617,7 +617,7 @@ Next";
 		[Test]
 		public void ErrorHandlingStatement()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement("On Error Resume Next\n" +
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement("On Error Resume Next\n" +
 			                                                            "On Error GoTo -1\n" +
 			                                                            "On Error GoTo 0\n" +
 			                                                            "On Error GoTo Test\n" +
@@ -652,7 +652,7 @@ Next <Test />, <Test />
 For Each <Test /> In <Test />
 Next <Test />";
 			
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
 			
 			CheckHead(lexer);
 			
@@ -676,7 +676,7 @@ Next <Test />";
 			string statement = @"While <Test />
 End While";
 			
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
 			
 			CheckHead(lexer);
 			
@@ -693,7 +693,7 @@ End While";
 			string statement = @"Do While <Test />
 Loop";
 			
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
 			
 			CheckHead(lexer);
 			
@@ -710,7 +710,7 @@ Loop";
 			string statement = @"Do
 Loop While <Test />";
 			
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
 			
 			CheckHead(lexer);
 			
@@ -727,7 +727,7 @@ Loop While <Test />";
 			string statement = @"Do Until <Test />
 Loop";
 			
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
 			
 			CheckHead(lexer);
 			
@@ -744,7 +744,7 @@ Loop";
 			string statement = @"Do
 Loop Until <Test />";
 			
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
 			
 			CheckHead(lexer);
 			
@@ -764,7 +764,7 @@ ElseIf <Test></Test> Then
 Else
 End If";
 			
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
 			
 			CheckHead(lexer);
 			
@@ -786,7 +786,7 @@ End If";
 	Case Else
 End Select";
 			
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
 			
 			CheckHead(lexer);
 			
@@ -810,7 +810,7 @@ End Select";
 	Finally
 End Try";
 			
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
 			
 			CheckHead(lexer);
 			
@@ -828,7 +828,7 @@ End Try";
 		[Test]
 		public void ThrowStatement()
 		{
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement("Throw <Test />")));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement("Throw <Test />")));
 			
 			CheckHead(lexer);
 			
@@ -859,7 +859,7 @@ Return
 Return 5
 Return <Test />";
 			
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
 			
 			CheckHead(lexer);
 			
@@ -893,7 +893,7 @@ Return <Test />";
 Erase <Test />, <Test />
 ReDim Preserve <Test />";
 			
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
 			
 			CheckHead(lexer);
 			
@@ -912,7 +912,7 @@ ReDim Preserve <Test />";
 			string statement = @"Using <Test />
 End Using";
 			
-			ILexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
+			VBLexer lexer = GenerateLexer(new StringReader(TestStatement(statement)));
 			
 			CheckHead(lexer);
 			
@@ -930,7 +930,7 @@ End Using";
                             Localizer.GetString(""Month"" & initParameters.SelectedDate.FirstDayOfPreviousMonth.Month) & "" "" &
                             initParameters.SelectedDate.FirstDayOfPreviousMonth.Year, .Value = New Date(2010, initParameters.SelectedDate.FirstDayOfPreviousMonth.Month, 1)}";
 			
-			ILexer lexer = GenerateLexerForSnippet(new StringReader(code), SnippetType.Expression);
+			VBLexer lexer = GenerateLexerForSnippet(new StringReader(code), SnippetType.Expression);
 			
 			CheckTokens(lexer, Tokens.New, Tokens.Identifier, Tokens.Dot, Tokens.Identifier,
 			            Tokens.With, Tokens.OpenCurlyBrace, Tokens.Dot, Tokens.Identifier, Tokens.Assign,
@@ -946,12 +946,12 @@ End Using";
 		#endregion
 		
 		#region Helpers
-		ILexer GenerateLexer(StringReader sr)
+		VBLexer GenerateLexer(StringReader sr)
 		{
 			return ParserFactory.CreateLexer(sr);
 		}
 		
-		ILexer GenerateLexerForSnippet(StringReader sr, SnippetType type)
+		VBLexer GenerateLexerForSnippet(StringReader sr, SnippetType type)
 		{
 			var lexer = ParserFactory.CreateLexer(sr);
 			lexer.SetInitialContext(type);
@@ -967,18 +967,18 @@ End Using";
 				"End Class";
 		}
 		
-		void CheckFoot(ILexer lexer)
+		void CheckFoot(VBLexer lexer)
 		{
 			CheckTokens(lexer, Tokens.EOL, Tokens.End, Tokens.Sub, Tokens.EOL, Tokens.End, Tokens.Class);
 		}
 		
-		void CheckHead(ILexer lexer)
+		void CheckHead(VBLexer lexer)
 		{
 			CheckTokens(lexer, Tokens.Class, Tokens.Identifier, Tokens.EOL,
 			            Tokens.Sub, Tokens.Identifier, Tokens.EOL);
 		}
 		
-		void CheckTokens(ILexer lexer, params int[] tokens)
+		void CheckTokens(VBLexer lexer, params int[] tokens)
 		{
 			for (int i = 0; i < tokens.Length; i++) {
 				int token = tokens[i];
diff --git a/ICSharpCode.NRefactory.VB.Tests/Parser/CheckParentVisitor.cs b/ICSharpCode.NRefactory.VB.Tests/Parser/CheckParentVisitor.cs
index 2b057e5d45..a244093271 100644
--- a/ICSharpCode.NRefactory.VB.Tests/Parser/CheckParentVisitor.cs
+++ b/ICSharpCode.NRefactory.VB.Tests/Parser/CheckParentVisitor.cs
@@ -12,7 +12,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
 	/// <summary>
 	/// Ensures that all nodes have the Parent property correctly set.
 	/// </summary>
-	public class CheckParentVisitor : NodeTrackingAstVisitor
+	public class CheckParentVisitor : NodeTrackingDomVisitor
 	{
 		Stack<INode> nodeStack = new Stack<INode>();
 		
diff --git a/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/ObjectCreateExpressionTests.cs b/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/ObjectCreateExpressionTests.cs
index 232799b031..416e716b61 100644
--- a/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/ObjectCreateExpressionTests.cs
+++ b/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/ObjectCreateExpressionTests.cs
@@ -66,7 +66,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Dom
 		[Test]
 		public void VBNetInvalidTypeArgumentListObjectCreateExpressionTest()
 		{
-			// this test was written because this bug caused the AbstractASTVisitor to crash
+			// this test was written because this bug caused the AbstractDomVisitor to crash
 			
 			InvocationExpression expr = ParseUtil.ParseExpression<InvocationExpression>("WriteLine(New SomeGenericType(Of Integer, )())", true);
 			Assert.IsTrue(expr.TargetObject is IdentifierExpression);
diff --git a/ICSharpCode.NRefactory.VB.Tests/Parser/LocationAssignmentCheckVisitor.cs b/ICSharpCode.NRefactory.VB.Tests/Parser/LocationAssignmentCheckVisitor.cs
index 0c853f2cb8..4b2bbd4646 100644
--- a/ICSharpCode.NRefactory.VB.Tests/Parser/LocationAssignmentCheckVisitor.cs
+++ b/ICSharpCode.NRefactory.VB.Tests/Parser/LocationAssignmentCheckVisitor.cs
@@ -8,7 +8,7 @@ using NUnit.Framework;
 
 namespace ICSharpCode.NRefactory.VB.Tests.Dom
 {
-	public class LocationAssignmentCheckVisitor : NodeTrackingAstVisitor
+	public class LocationAssignmentCheckVisitor : NodeTrackingDomVisitor
 	{
 		protected override void BeginVisit(INode node)
 		{
diff --git a/ICSharpCode.NRefactory.VB/Dom/AbstractNode.cs b/ICSharpCode.NRefactory.VB/Dom/AbstractNode.cs
index 24c713fa5f..113d12229a 100644
--- a/ICSharpCode.NRefactory.VB/Dom/AbstractNode.cs
+++ b/ICSharpCode.NRefactory.VB/Dom/AbstractNode.cs
@@ -35,9 +35,9 @@ namespace ICSharpCode.NRefactory.VB.Dom
 			children.Add(childNode);
 		}
 		
-		public abstract object AcceptVisitor(IAstVisitor visitor, object data);
+		public abstract object AcceptVisitor(IDomVisitor visitor, object data);
 		
-		public virtual object AcceptChildren(IAstVisitor visitor, object data)
+		public virtual object AcceptChildren(IDomVisitor visitor, object data)
 		{
 			foreach (INode child in children) {
 				Debug.Assert(child != null);
diff --git a/ICSharpCode.NRefactory.VB/Dom/General/BlockStatement.cs b/ICSharpCode.NRefactory.VB/Dom/General/BlockStatement.cs
index 93d71f4c48..2be9118cc9 100644
--- a/ICSharpCode.NRefactory.VB/Dom/General/BlockStatement.cs
+++ b/ICSharpCode.NRefactory.VB/Dom/General/BlockStatement.cs
@@ -15,7 +15,7 @@ namespace ICSharpCode.NRefactory.VB.Dom
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
+		public override object AcceptVisitor(IDomVisitor visitor, object data)
 		{
 			return visitor.VisitBlockStatement(this, data);
 		}
@@ -37,11 +37,11 @@ namespace ICSharpCode.NRefactory.VB.Dom
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
+		public override object AcceptVisitor(IDomVisitor visitor, object data)
 		{
 			return data;
 		}
-		public override object AcceptChildren(IAstVisitor visitor, object data)
+		public override object AcceptChildren(IDomVisitor visitor, object data)
 		{
 			return data;
 		}
diff --git a/ICSharpCode.NRefactory.VB/Dom/General/CompilationUnit.cs b/ICSharpCode.NRefactory.VB/Dom/General/CompilationUnit.cs
index 966cabc8c6..b40f061a28 100644
--- a/ICSharpCode.NRefactory.VB/Dom/General/CompilationUnit.cs
+++ b/ICSharpCode.NRefactory.VB/Dom/General/CompilationUnit.cs
@@ -11,7 +11,7 @@ namespace ICSharpCode.NRefactory.VB.Dom
 		// Children in C#: UsingAliasDeclaration, UsingDeclaration, AttributeSection, NamespaceDeclaration
 		// Children in VB: OptionStatements, ImportsStatement, AttributeSection, NamespaceDeclaration
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
+		public override object AcceptVisitor(IDomVisitor visitor, object data)
 		{
 			return visitor.VisitCompilationUnit(this, data);
 		}
diff --git a/ICSharpCode.NRefactory.VB/Dom/General/Expression.cs b/ICSharpCode.NRefactory.VB/Dom/General/Expression.cs
index d01beb49e4..09f39f5b52 100644
--- a/ICSharpCode.NRefactory.VB/Dom/General/Expression.cs
+++ b/ICSharpCode.NRefactory.VB/Dom/General/Expression.cs
@@ -90,7 +90,7 @@ namespace ICSharpCode.NRefactory.VB.Dom
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
+		public override object AcceptVisitor(IDomVisitor visitor, object data)
 		{
 			return null;
 		}
diff --git a/ICSharpCode.NRefactory.VB/Dom/General/LocalVariableDeclaration.cs b/ICSharpCode.NRefactory.VB/Dom/General/LocalVariableDeclaration.cs
index 1e944b8aa9..845d377437 100644
--- a/ICSharpCode.NRefactory.VB/Dom/General/LocalVariableDeclaration.cs
+++ b/ICSharpCode.NRefactory.VB/Dom/General/LocalVariableDeclaration.cs
@@ -83,7 +83,7 @@ namespace ICSharpCode.NRefactory.VB.Dom
 			return null;
 		}
 				
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
+		public override object AcceptVisitor(IDomVisitor visitor, object data)
 		{
 			return visitor.VisitLocalVariableDeclaration(this, data);
 		}
diff --git a/ICSharpCode.NRefactory.VB/Dom/General/PrimitiveExpression.cs b/ICSharpCode.NRefactory.VB/Dom/General/PrimitiveExpression.cs
index 38648a44bc..6e053d388d 100644
--- a/ICSharpCode.NRefactory.VB/Dom/General/PrimitiveExpression.cs
+++ b/ICSharpCode.NRefactory.VB/Dom/General/PrimitiveExpression.cs
@@ -36,7 +36,7 @@ namespace ICSharpCode.NRefactory.VB.Dom
 			this.StringValue = stringValue;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
+		public override object AcceptVisitor(IDomVisitor visitor, object data)
 		{
 			return visitor.VisitPrimitiveExpression(this, data);
 		}
diff --git a/ICSharpCode.NRefactory.VB/Dom/General/Statement.cs b/ICSharpCode.NRefactory.VB/Dom/General/Statement.cs
index 2653d6772b..1114a23ed2 100644
--- a/ICSharpCode.NRefactory.VB/Dom/General/Statement.cs
+++ b/ICSharpCode.NRefactory.VB/Dom/General/Statement.cs
@@ -49,7 +49,7 @@ namespace ICSharpCode.NRefactory.VB.Dom
 			get { return true; }
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
+		public override object AcceptVisitor(IDomVisitor visitor, object data)
 		{
 			return data;
 		}
diff --git a/ICSharpCode.NRefactory.VB/Dom/Generated.cs b/ICSharpCode.NRefactory.VB/Dom/Generated.cs
index 0f7fc756f6..a2daebfc81 100644
--- a/ICSharpCode.NRefactory.VB/Dom/Generated.cs
+++ b/ICSharpCode.NRefactory.VB/Dom/Generated.cs
@@ -44,7 +44,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			HandlerExpression = handlerExpression;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitAddHandlerStatement(this, data);
 		}
 		
@@ -71,7 +71,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			Expression = expression;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitAddressOfExpression(this, data);
 		}
 		
@@ -141,7 +141,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitArrayCreateExpression(this, data);
 		}
 		
@@ -193,7 +193,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			Right = right;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitAssignmentExpression(this, data);
 		}
 		
@@ -249,7 +249,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			NamedArguments = namedArguments;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitAttribute(this, data);
 		}
 		
@@ -325,7 +325,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			attributes = new List<Attribute>();
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitAttributeSection(this, data);
 		}
 		
@@ -339,7 +339,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 		public BaseReferenceExpression() {
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitBaseReferenceExpression(this, data);
 		}
 		
@@ -396,7 +396,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			Right = right;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitBinaryOperatorExpression(this, data);
 		}
 		
@@ -469,7 +469,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitCaseLabel(this, data);
 		}
 		
@@ -526,7 +526,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			CastType = castType;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitCastExpression(this, data);
 		}
 		
@@ -605,7 +605,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			condition = Expression.Null;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitCatchClause(this, data);
 		}
 		
@@ -620,7 +620,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 		public ClassReferenceExpression() {
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitClassReferenceExpression(this, data);
 		}
 		
@@ -656,7 +656,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitCollectionInitializerExpression(this, data);
 		}
 		
@@ -675,7 +675,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return null;
 		}
 		
@@ -739,7 +739,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitCollectionRangeVariable(this, data);
 		}
 		
@@ -758,7 +758,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return null;
 		}
 		
@@ -817,7 +817,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			FalseExpression = falseExpression;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitConditionalExpression(this, data);
 		}
 		
@@ -870,7 +870,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			body = BlockStatement.Null;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitConstructorDeclaration(this, data);
 		}
 		
@@ -920,7 +920,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitConstructorInitializer(this, data);
 		}
 		
@@ -939,7 +939,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return null;
 		}
 		
@@ -968,7 +968,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			ContinueType = continueType;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitContinueStatement(this, data);
 		}
 		
@@ -1035,7 +1035,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			Charset = charset;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitDeclareDeclaration(this, data);
 		}
 		
@@ -1063,7 +1063,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			TypeReference = typeReference;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitDefaultValueExpression(this, data);
 		}
 		
@@ -1128,7 +1128,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			templates = new List<TemplateDefinition>();
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitDelegateDeclaration(this, data);
 		}
 		
@@ -1168,7 +1168,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			Expression = expression;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitDirectionExpression(this, data);
 		}
 		
@@ -1220,7 +1220,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			ConditionPosition = conditionPosition;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitDoLoopStatement(this, data);
 		}
 		
@@ -1249,7 +1249,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			EmbeddedStatement = embeddedStatement;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitElseIfSection(this, data);
 		}
 		
@@ -1263,7 +1263,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 		public EndStatement() {
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitEndStatement(this, data);
 		}
 		
@@ -1293,7 +1293,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			Expressions = expressions;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitEraseStatement(this, data);
 		}
 		
@@ -1320,7 +1320,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			Expression = expression;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitErrorStatement(this, data);
 		}
 		
@@ -1341,7 +1341,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitEventAddRegion(this, data);
 		}
 		
@@ -1364,7 +1364,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return null;
 		}
 		
@@ -1510,7 +1510,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitEventDeclaration(this, data);
 		}
 		
@@ -1533,7 +1533,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitEventRaiseRegion(this, data);
 		}
 		
@@ -1556,7 +1556,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return null;
 		}
 		
@@ -1577,7 +1577,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitEventRemoveRegion(this, data);
 		}
 		
@@ -1600,7 +1600,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return null;
 		}
 		
@@ -1626,7 +1626,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			ExitType = exitType;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitExitStatement(this, data);
 		}
 		
@@ -1690,7 +1690,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitExpressionRangeVariable(this, data);
 		}
 		
@@ -1709,7 +1709,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return null;
 		}
 		
@@ -1736,7 +1736,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			Expression = expression;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitExpressionStatement(this, data);
 		}
 		
@@ -1762,7 +1762,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			name = "";
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitExternAliasDirective(this, data);
 		}
 		
@@ -1829,7 +1829,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			return null;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitFieldDeclaration(this, data);
 		}
 		
@@ -1903,7 +1903,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			NextExpression = nextExpression;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitForeachStatement(this, data);
 		}
 		
@@ -2007,7 +2007,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			loopVariableExpression = Expression.Null;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitForNextStatement(this, data);
 		}
 		
@@ -2034,7 +2034,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			Label = label;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitGotoStatement(this, data);
 		}
 		
@@ -2072,7 +2072,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			typeArguments = new List<TypeReference>();
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitIdentifierExpression(this, data);
 		}
 		
@@ -2163,7 +2163,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 				if (falseStatement != null) falseStatement.Parent = this;
 			}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitIfElseStatement(this, data);
 		}
 		
@@ -2203,7 +2203,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			MemberName = memberName;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitInterfaceImplementation(this, data);
 		}
 		
@@ -2247,7 +2247,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			Arguments = arguments;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitInvocationExpression(this, data);
 		}
 		
@@ -2273,7 +2273,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 			Label = label;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitLabelStatement(this, data);
 		}
 		
@@ -2340,7 +2340,7 @@ namespace ICSharpCode.NRefactory.VB.Dom {
 		
 public Location ExtendedEndLocation { get; set; }
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitLambdaExpression(this, data);
 		}
 		
@@ -2369,7 +2369,7 @@ public Location ExtendedEndLocation { get; set; }
 			EmbeddedStatement = embeddedStatement;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitLockStatement(this, data);
 		}
 		
@@ -2424,7 +2424,7 @@ public Location ExtendedEndLocation { get; set; }
 			Expression = expression;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitMemberInitializerExpression(this, data);
 		}
 		
@@ -2515,7 +2515,7 @@ public Location ExtendedEndLocation { get; set; }
 			typeArguments = new List<TypeReference>();
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitMemberReferenceExpression(this, data);
 		}
 		
@@ -2577,7 +2577,7 @@ public Location ExtendedEndLocation { get; set; }
 			templates = new List<TemplateDefinition>();
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitMethodDeclaration(this, data);
 		}
 		
@@ -2623,7 +2623,7 @@ public Location ExtendedEndLocation { get; set; }
 			Expression = expression;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitNamedArgumentExpression(this, data);
 		}
 		
@@ -2649,7 +2649,7 @@ public Location ExtendedEndLocation { get; set; }
 			Name = name;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitNamespaceDeclaration(this, data);
 		}
 		
@@ -2707,7 +2707,7 @@ public Location ExtendedEndLocation { get; set; }
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitObjectCreateExpression(this, data);
 		}
 		
@@ -2722,7 +2722,7 @@ public Location ExtendedEndLocation { get; set; }
 			EmbeddedStatement = embeddedStatement;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitOnErrorStatement(this, data);
 		}
 		
@@ -2764,7 +2764,7 @@ public Location ExtendedEndLocation { get; set; }
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitOperatorDeclaration(this, data);
 		}
 		
@@ -2804,7 +2804,7 @@ public Location ExtendedEndLocation { get; set; }
 			OptionValue = optionValue;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitOptionDeclaration(this, data);
 		}
 		
@@ -2895,7 +2895,7 @@ public Location ExtendedEndLocation { get; set; }
 			attributes = new List<AttributeSection>();
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitParameterDeclarationExpression(this, data);
 		}
 		
@@ -2960,7 +2960,7 @@ public Location ExtendedEndLocation { get; set; }
 			Expression = expression;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitParenthesizedExpression(this, data);
 		}
 		
@@ -3083,7 +3083,7 @@ public Location ExtendedEndLocation { get; set; }
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitPropertyDeclaration(this, data);
 		}
 		
@@ -3106,7 +3106,7 @@ public Location ExtendedEndLocation { get; set; }
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitPropertyGetRegion(this, data);
 		}
 		
@@ -3129,7 +3129,7 @@ public Location ExtendedEndLocation { get; set; }
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return null;
 		}
 		
@@ -3188,7 +3188,7 @@ public Location ExtendedEndLocation { get; set; }
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitPropertySetRegion(this, data);
 		}
 		
@@ -3211,7 +3211,7 @@ public Location ExtendedEndLocation { get; set; }
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return null;
 		}
 		
@@ -3237,7 +3237,7 @@ public Location ExtendedEndLocation { get; set; }
 			clauses = new List<QueryExpressionClause>();
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitQueryExpression(this, data);
 		}
 		
@@ -3288,7 +3288,7 @@ public Location ExtendedEndLocation { get; set; }
 			intoVariables = new List<ExpressionRangeVariable>();
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitQueryExpressionAggregateClause(this, data);
 		}
 		
@@ -3325,7 +3325,7 @@ public Location ExtendedEndLocation { get; set; }
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return null;
 		}
 		
@@ -3339,7 +3339,7 @@ public Location ExtendedEndLocation { get; set; }
 		public QueryExpressionDistinctClause() {
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitQueryExpressionDistinctClause(this, data);
 		}
 		
@@ -3371,7 +3371,7 @@ public Location ExtendedEndLocation { get; set; }
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitQueryExpressionFromClause(this, data);
 		}
 		
@@ -3390,7 +3390,7 @@ public Location ExtendedEndLocation { get; set; }
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return null;
 		}
 		
@@ -3430,7 +3430,7 @@ public Location ExtendedEndLocation { get; set; }
 			groupBy = Expression.Null;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitQueryExpressionGroupClause(this, data);
 		}
 		
@@ -3469,7 +3469,7 @@ public Location ExtendedEndLocation { get; set; }
 			intoVariables = new List<ExpressionRangeVariable>();
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitQueryExpressionGroupJoinVBClause(this, data);
 		}
 		
@@ -3519,7 +3519,7 @@ public Location ExtendedEndLocation { get; set; }
 			intoVariables = new List<ExpressionRangeVariable>();
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitQueryExpressionGroupVBClause(this, data);
 		}
 		
@@ -3585,7 +3585,7 @@ public Location ExtendedEndLocation { get; set; }
 			intoIdentifier = "";
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitQueryExpressionJoinClause(this, data);
 		}
 		
@@ -3626,7 +3626,7 @@ public Location ExtendedEndLocation { get; set; }
 			rightSide = Expression.Null;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitQueryExpressionJoinConditionVB(this, data);
 		}
 		
@@ -3684,7 +3684,7 @@ public Location ExtendedEndLocation { get; set; }
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitQueryExpressionJoinVBClause(this, data);
 		}
 		
@@ -3703,7 +3703,7 @@ public Location ExtendedEndLocation { get; set; }
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return null;
 		}
 		
@@ -3742,7 +3742,7 @@ public Location ExtendedEndLocation { get; set; }
 			expression = Expression.Null;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitQueryExpressionLetClause(this, data);
 		}
 		
@@ -3768,7 +3768,7 @@ public Location ExtendedEndLocation { get; set; }
 			variables = new List<ExpressionRangeVariable>();
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitQueryExpressionLetVBClause(this, data);
 		}
 		
@@ -3794,7 +3794,7 @@ public Location ExtendedEndLocation { get; set; }
 			orderings = new List<QueryExpressionOrdering>();
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitQueryExpressionOrderClause(this, data);
 		}
 		
@@ -3832,7 +3832,7 @@ public Location ExtendedEndLocation { get; set; }
 			criteria = Expression.Null;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitQueryExpressionOrdering(this, data);
 		}
 		
@@ -3870,7 +3870,7 @@ public Location ExtendedEndLocation { get; set; }
 			expression = Expression.Null;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitQueryExpressionPartitionVBClause(this, data);
 		}
 		
@@ -3897,7 +3897,7 @@ public Location ExtendedEndLocation { get; set; }
 			projection = Expression.Null;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitQueryExpressionSelectClause(this, data);
 		}
 		
@@ -3923,7 +3923,7 @@ public Location ExtendedEndLocation { get; set; }
 			variables = new List<ExpressionRangeVariable>();
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitQueryExpressionSelectVBClause(this, data);
 		}
 		
@@ -3950,7 +3950,7 @@ public Location ExtendedEndLocation { get; set; }
 			condition = Expression.Null;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitQueryExpressionWhereClause(this, data);
 		}
 		
@@ -3988,7 +3988,7 @@ public Location ExtendedEndLocation { get; set; }
 			Arguments = arguments;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitRaiseEventStatement(this, data);
 		}
 		
@@ -4026,7 +4026,7 @@ public Location ExtendedEndLocation { get; set; }
 			reDimClauses = new List<InvocationExpression>();
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitReDimStatement(this, data);
 		}
 		
@@ -4066,7 +4066,7 @@ public Location ExtendedEndLocation { get; set; }
 			HandlerExpression = handlerExpression;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitRemoveHandlerStatement(this, data);
 		}
 		
@@ -4108,7 +4108,7 @@ public Location ExtendedEndLocation { get; set; }
 			LabelName = labelName;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitResumeStatement(this, data);
 		}
 		
@@ -4135,7 +4135,7 @@ public Location ExtendedEndLocation { get; set; }
 			Expression = expression;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitReturnStatement(this, data);
 		}
 		
@@ -4149,7 +4149,7 @@ public Location ExtendedEndLocation { get; set; }
 		public StopStatement() {
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitStopStatement(this, data);
 		}
 		
@@ -4179,7 +4179,7 @@ public Location ExtendedEndLocation { get; set; }
 			SwitchLabels = switchLabels;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitSwitchSection(this, data);
 		}
 		
@@ -4218,7 +4218,7 @@ public Location ExtendedEndLocation { get; set; }
 			SwitchSections = switchSections;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitSwitchStatement(this, data);
 		}
 		
@@ -4273,7 +4273,7 @@ public Location ExtendedEndLocation { get; set; }
 			bases = new List<TypeReference>();
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitTemplateDefinition(this, data);
 		}
 		
@@ -4288,7 +4288,7 @@ public Location ExtendedEndLocation { get; set; }
 		public ThisReferenceExpression() {
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitThisReferenceExpression(this, data);
 		}
 		
@@ -4315,7 +4315,7 @@ public Location ExtendedEndLocation { get; set; }
 			Expression = expression;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitThrowStatement(this, data);
 		}
 		
@@ -4367,7 +4367,7 @@ public Location ExtendedEndLocation { get; set; }
 			FinallyBlock = finallyBlock;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitTryCatchStatement(this, data);
 		}
 		
@@ -4442,7 +4442,7 @@ public Location ExtendedEndLocation { get; set; }
 			bodyStartLocation = Location.Empty;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitTypeDeclaration(this, data);
 		}
 		
@@ -4470,7 +4470,7 @@ public Location ExtendedEndLocation { get; set; }
 			TypeReference = typeReference;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitTypeOfExpression(this, data);
 		}
 		
@@ -4510,7 +4510,7 @@ public Location ExtendedEndLocation { get; set; }
 			TypeReference = typeReference;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitTypeOfIsExpression(this, data);
 		}
 		
@@ -4537,7 +4537,7 @@ public Location ExtendedEndLocation { get; set; }
 			TypeReference = typeReference;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitTypeReferenceExpression(this, data);
 		}
 		
@@ -4581,7 +4581,7 @@ public Location ExtendedEndLocation { get; set; }
 			Op = op;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitUnaryOperatorExpression(this, data);
 		}
 		
@@ -4656,7 +4656,7 @@ public Location ExtendedEndLocation { get; set; }
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitUsing(this, data);
 		}
 		
@@ -4688,7 +4688,7 @@ public UsingDeclaration(string @namespace) : this(@namespace, TypeReference.Null
 		
 public UsingDeclaration(string @namespace, TypeReference alias) { usings = new List<Using>(1); usings.Add(new Using(@namespace, alias)); }
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitUsingDeclaration(this, data);
 		}
 		
@@ -4716,7 +4716,7 @@ public UsingDeclaration(string @namespace, TypeReference alias) { usings = new L
 			EmbeddedStatement = embeddedStatement;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitUsingStatement(this, data);
 		}
 		
@@ -4795,7 +4795,7 @@ public UsingDeclaration(string @namespace, TypeReference alias) { usings = new L
 			fixedArrayInitialization = Expression.Null;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitVariableDeclaration(this, data);
 		}
 		
@@ -4836,7 +4836,7 @@ public UsingDeclaration(string @namespace, TypeReference alias) { usings = new L
 			body = BlockStatement.Null;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitWithStatement(this, data);
 		}
 		
@@ -4904,7 +4904,7 @@ public UsingDeclaration(string @namespace, TypeReference alias) { usings = new L
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitXmlAttributeExpression(this, data);
 		}
 		
@@ -4943,7 +4943,7 @@ public UsingDeclaration(string @namespace, TypeReference alias) { usings = new L
 			Type = type;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitXmlContentExpression(this, data);
 		}
 		
@@ -4969,7 +4969,7 @@ public UsingDeclaration(string @namespace, TypeReference alias) { usings = new L
 			expressions = new List<XmlExpression>();
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitXmlDocumentExpression(this, data);
 		}
 		
@@ -5045,7 +5045,7 @@ public UsingDeclaration(string @namespace, TypeReference alias) { usings = new L
 			}
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitXmlElementExpression(this, data);
 		}
 		
@@ -5072,7 +5072,7 @@ public UsingDeclaration(string @namespace, TypeReference alias) { usings = new L
 			inlineVBExpression = Expression.Null;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitXmlEmbeddedExpression(this, data);
 		}
 		
@@ -5141,7 +5141,7 @@ public UsingDeclaration(string @namespace, TypeReference alias) { usings = new L
 			IsXmlIdentifier = isXmlIdentifier;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+		public override object AcceptVisitor(IDomVisitor visitor, object data) {
 			return visitor.VisitXmlMemberAccessExpression(this, data);
 		}
 		
diff --git a/ICSharpCode.NRefactory.VB/Dom/INode.cs b/ICSharpCode.NRefactory.VB/Dom/INode.cs
index 5e331c186d..2bfa181153 100644
--- a/ICSharpCode.NRefactory.VB/Dom/INode.cs
+++ b/ICSharpCode.NRefactory.VB/Dom/INode.cs
@@ -38,7 +38,7 @@ namespace ICSharpCode.NRefactory.VB.Dom
 		/// <param name="visitor">The visitor to accept</param>
 		/// <param name="data">Additional data for the visitor</param>
 		/// <returns>The paremeter <paramref name="data"/></returns>
-		object AcceptChildren(IAstVisitor visitor, object data);
+		object AcceptChildren(IDomVisitor visitor, object data);
 		
 		/// <summary>
 		/// Accept the visitor
@@ -46,6 +46,6 @@ namespace ICSharpCode.NRefactory.VB.Dom
 		/// <param name="visitor">The visitor to accept</param>
 		/// <param name="data">Additional data for the visitor</param>
 		/// <returns>The value the visitor returns after the visit</returns>
-		object AcceptVisitor(IAstVisitor visitor, object data);
+		object AcceptVisitor(IDomVisitor visitor, object data);
 	}
 }
diff --git a/ICSharpCode.NRefactory.VB/Dom/TypeReference.cs b/ICSharpCode.NRefactory.VB/Dom/TypeReference.cs
index 32933f4607..a3c82d0ee8 100644
--- a/ICSharpCode.NRefactory.VB/Dom/TypeReference.cs
+++ b/ICSharpCode.NRefactory.VB/Dom/TypeReference.cs
@@ -290,7 +290,7 @@ namespace ICSharpCode.NRefactory.VB.Dom
 		protected TypeReference()
 		{}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
+		public override object AcceptVisitor(IDomVisitor visitor, object data)
 		{
 			return visitor.VisitTypeReference(this, data);
 		}
@@ -360,7 +360,7 @@ namespace ICSharpCode.NRefactory.VB.Dom
 		{
 			return this;
 		}
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
+		public override object AcceptVisitor(IDomVisitor visitor, object data)
 		{
 			return null;
 		}
@@ -399,7 +399,7 @@ namespace ICSharpCode.NRefactory.VB.Dom
 			this.baseType = outerClass;
 		}
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
+		public override object AcceptVisitor(IDomVisitor visitor, object data)
 		{
 			return visitor.VisitInnerClassTypeReference(this, data);
 		}
diff --git a/ICSharpCode.NRefactory.VB/DomBuilder/ExpressionBuilder.cs b/ICSharpCode.NRefactory.VB/DomBuilder/ExpressionBuilder.cs
index 154ea01b98..5b832efb23 100644
--- a/ICSharpCode.NRefactory.VB/DomBuilder/ExpressionBuilder.cs
+++ b/ICSharpCode.NRefactory.VB/DomBuilder/ExpressionBuilder.cs
@@ -8,7 +8,7 @@ using ICSharpCode.NRefactory.VB.Dom;
 namespace ICSharpCode.NRefactory.VB.DomBuilder
 {
 	/// <summary>
-	/// Extension methods for NRefactory.Ast.Expression.
+	/// Extension methods for NRefactory.Dom.Expression.
 	/// </summary>
 	public static class ExpressionBuilder
 	{
diff --git a/ICSharpCode.NRefactory.VB/DomBuilder/StatementBuilder.cs b/ICSharpCode.NRefactory.VB/DomBuilder/StatementBuilder.cs
index c6352d8481..cf5225356f 100644
--- a/ICSharpCode.NRefactory.VB/DomBuilder/StatementBuilder.cs
+++ b/ICSharpCode.NRefactory.VB/DomBuilder/StatementBuilder.cs
@@ -8,7 +8,7 @@ using ICSharpCode.NRefactory.VB.Dom;
 namespace ICSharpCode.NRefactory.VB.DomBuilder
 {
 	/// <summary>
-	/// Extension methods for NRefactory.Ast.Expression.
+	/// Extension methods for NRefactory.Dom.Expression.
 	/// </summary>
 	public static class StatementBuilder
 	{
diff --git a/ICSharpCode.NRefactory.VB/ICSharpCode.NRefactory.VB.csproj b/ICSharpCode.NRefactory.VB/ICSharpCode.NRefactory.VB.csproj
index fc4cb596e6..52d8510108 100644
--- a/ICSharpCode.NRefactory.VB/ICSharpCode.NRefactory.VB.csproj
+++ b/ICSharpCode.NRefactory.VB/ICSharpCode.NRefactory.VB.csproj
@@ -55,17 +55,14 @@
     <Compile Include="Dom\INullable.cs" />
     <Compile Include="Dom\TypeReference.cs" />
     <Compile Include="EnvironmentInformationProvider.cs" />
-    <Compile Include="IAstVisitor.cs" />
-    <Compile Include="Lexer\AbstractLexer.cs" />
+    <Compile Include="IDomVisitor.cs" />
     <Compile Include="Lexer\Block.cs" />
     <Compile Include="Lexer\ExpressionFinder.cs" />
     <Compile Include="Lexer\ExpressionFinderState.cs" />
     <Compile Include="Lexer\Extensions.cs" />
-    <Compile Include="Lexer\ILexer.cs" />
     <Compile Include="Lexer\Keywords.cs" />
     <Compile Include="Lexer\LATextReader.cs" />
-    <Compile Include="Lexer\Lexer.cs" />
-    <Compile Include="Lexer\LexerMemento.cs" />
+    <Compile Include="Lexer\VBLexer.cs" />
     <Compile Include="Lexer\LookupTable.cs" />
     <Compile Include="Lexer\Parser.cs">
       <DependentUpon>ExpressionFinder.atg</DependentUpon>
@@ -101,13 +98,13 @@
     <Compile Include="PrettyPrinter\VBNet\VBNetPrettyPrintOptions.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SnippetParser.cs" />
-    <Compile Include="Visitors\AbstractAstTransformer.cs" />
-    <Compile Include="Visitors\AbstractASTVisitor.cs" />
+    <Compile Include="Visitors\AbstractDomTransformer.cs" />
+    <Compile Include="Visitors\AbstractDomVisitor.cs" />
     <Compile Include="Visitors\CodeDOMOutputVisitor.cs" />
     <Compile Include="Visitors\CodeDOMVerboseOutputGenerator.cs" />
     <Compile Include="Visitors\LookupTableVisitor.cs" />
-    <Compile Include="Visitors\NodeTrackingAstVisitor.cs" />
-    <Compile Include="Visitors\NotImplementedAstVisitor.cs" />
+    <Compile Include="Visitors\NodeTrackingDomVisitor.cs" />
+    <Compile Include="Visitors\NotImplementedDomVisitor.cs" />
     <Compile Include="Visitors\PrefixFieldsVisitor.cs" />
     <Compile Include="Visitors\RenameIdentifierVisitor.cs" />
     <Compile Include="Visitors\SetParentVisitor.cs" />
diff --git a/ICSharpCode.NRefactory.VB/IAstVisitor.cs b/ICSharpCode.NRefactory.VB/IDomVisitor.cs
similarity index 99%
rename from ICSharpCode.NRefactory.VB/IAstVisitor.cs
rename to ICSharpCode.NRefactory.VB/IDomVisitor.cs
index 46c4e0a9d7..f934f2d634 100644
--- a/ICSharpCode.NRefactory.VB/IAstVisitor.cs
+++ b/ICSharpCode.NRefactory.VB/IDomVisitor.cs
@@ -13,7 +13,7 @@ namespace ICSharpCode.NRefactory.VB {
 	using ICSharpCode.NRefactory.VB.Dom;
 	
 	
-	public interface IAstVisitor {
+	public interface IDomVisitor {
 		
 		object VisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data);
 		
diff --git a/ICSharpCode.NRefactory.VB/Lexer/AbstractLexer.cs b/ICSharpCode.NRefactory.VB/Lexer/AbstractLexer.cs
deleted file mode 100644
index 76a0554616..0000000000
--- a/ICSharpCode.NRefactory.VB/Lexer/AbstractLexer.cs
+++ /dev/null
@@ -1,386 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
-
-namespace ICSharpCode.NRefactory.VB.Parser
-{
-	/// <summary>
-	/// This is the base class for the C# and VB.NET lexer
-	/// </summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1708:IdentifiersShouldDifferByMoreThanCase")]
-	internal abstract class AbstractLexer : ILexer
-	{
-		LATextReader reader;
-		int col  = 1;
-		int line = 1;
-		
-		protected Errors errors = new Errors();
-		
-		protected Token lastToken = null;
-		protected Token curToken  = null;
-		protected Token peekToken = null;
-		
-		string[]  specialCommentTags = null;
-		protected Hashtable specialCommentHash  = null;
-		List<TagComment> tagComments  = new List<TagComment>();
-		protected StringBuilder sb              = new StringBuilder();
-		protected SpecialTracker specialTracker = new SpecialTracker();
-		
-		// used for the original value of strings (with escape sequences).
-		protected StringBuilder originalValue = new StringBuilder();
-		
-		public bool SkipAllComments { get; set; }
-		public bool EvaluateConditionalCompilation { get; set; }
-		public virtual IDictionary<string, object> ConditionalCompilationSymbols {
-			get { throw new NotSupportedException(); }
-		}
-		
-		protected static IEnumerable<string> GetSymbols (string symbols)
-		{
-			if (!string.IsNullOrEmpty(symbols)) {
-				foreach (string symbol in symbols.Split (';', ' ', '\t')) {
-					string s = symbol.Trim ();
-					if (s.Length == 0)
-						continue;
-					yield return s;
-				}
-			}
-		}
-		
-		public virtual void SetConditionalCompilationSymbols (string symbols)
-		{
-			throw new NotSupportedException ();
-		}
-		
-		protected int Line {
-			get {
-				return line;
-			}
-		}
-		protected int Col {
-			get {
-				return col;
-			}
-		}
-		
-		protected bool recordRead = false;
-		protected StringBuilder recordedText = new StringBuilder ();
-		
-		protected int ReaderRead()
-		{
-			int val = reader.Read();
-			if (recordRead && val >= 0)
-				recordedText.Append ((char)val);
-			if ((val == '\r' && reader.Peek() != '\n') || val == '\n') {
-				++line;
-				col = 1;
-				LineBreak();
-			} else if (val >= 0) {
-				col++;
-			}
-			return val;
-		}
-		
-		protected int ReaderPeek()
-		{
-			return reader.Peek();
-		}
-		
-		protected int ReaderPeek(int step)
-		{
-			return reader.Peek(step);
-		}
-		
-		protected void ReaderSkip(int steps)
-		{
-			for (int i = 0; i < steps; i++) {
-				ReaderRead();
-			}
-		}
-		
-		protected string ReaderPeekString(int length)
-		{
-			StringBuilder builder = new StringBuilder();
-			
-			for (int i = 0; i < length; i++) {
-				int peek = ReaderPeek(i);
-				if (peek != -1)
-					builder.Append((char)peek);
-			}
-			
-			return builder.ToString();
-		}
-		
-		public void SetInitialLocation(Location location)
-		{
-			if (lastToken != null || curToken != null || peekToken != null)
-				throw new InvalidOperationException();
-			this.line = location.Line;
-			this.col = location.Column;
-		}
-		
-		public Errors Errors {
-			get {
-				return errors;
-			}
-		}
-		
-		/// <summary>
-		/// Returns the comments that had been read and containing tag key words.
-		/// </summary>
-		public List<TagComment> TagComments {
-			get {
-				return tagComments;
-			}
-		}
-		
-		public SpecialTracker SpecialTracker {
-			get {
-				return specialTracker;
-			}
-		}
-		
-		/// <summary>
-		/// Special comment tags are tags like TODO, HACK or UNDONE which are read by the lexer and stored in <see cref="TagComments"/>.
-		/// </summary>
-		public string[] SpecialCommentTags {
-			get {
-				return specialCommentTags;
-			}
-			set {
-				specialCommentTags = value;
-				specialCommentHash = null;
-				if (specialCommentTags != null && specialCommentTags.Length > 0) {
-					specialCommentHash = new Hashtable();
-					foreach (string str in specialCommentTags) {
-						specialCommentHash.Add(str, null);
-					}
-				}
-			}
-		}
-		
-		/// <summary>
-		/// The current Token. <seealso cref="ICSharpCode.NRefactory.VB.Parser.Token"/>
-		/// </summary>
-		public Token Token {
-			get {
-//				Console.WriteLine("Call to Token");
-				return lastToken;
-			}
-		}
-		
-		/// <summary>
-		/// The next Token (The <see cref="Token"/> after <see cref="NextToken"/> call) . <seealso cref="ICSharpCode.NRefactory.VB.Parser.Token"/>
-		/// </summary>
-		public Token LookAhead {
-			get {
-//				Console.WriteLine("Call to LookAhead");
-				return curToken;
-			}
-		}
-		
-		/// <summary>
-		/// Constructor for the abstract lexer class.
-		/// </summary>
-		protected AbstractLexer(TextReader reader)
-		{
-			this.reader = new LATextReader(reader);
-		}
-		
-		protected AbstractLexer(TextReader reader, LexerMemento state)
-			: this(reader)
-		{
-			SetInitialLocation(new Location(state.Column, state.Line));
-			lastToken = new Token(state.PrevTokenKind, 0, 0);
-		}
-		
-		#region System.IDisposable interface implementation
-		public virtual void Dispose()
-		{
-			reader.Close();
-			reader = null;
-			errors = null;
-			lastToken = curToken = peekToken = null;
-			specialCommentHash = null;
-			tagComments = null;
-			sb = originalValue = null;
-		}
-		#endregion
-		
-		/// <summary>
-		/// Must be called before a peek operation.
-		/// </summary>
-		public void StartPeek()
-		{
-			peekToken = curToken;
-		}
-		
-		/// <summary>
-		/// Gives back the next token. A second call to Peek() gives the next token after the last call for Peek() and so on.
-		/// </summary>
-		/// <returns>An <see cref="Token"/> object.</returns>
-		public Token Peek()
-		{
-//			Console.WriteLine("Call to Peek");
-			if (peekToken.next == null) {
-				peekToken.next = Next();
-			}
-			peekToken = peekToken.next;
-			return peekToken;
-		}
-		
-		/// <summary>
-		/// Reads the next token and gives it back.
-		/// </summary>
-		/// <returns>An <see cref="Token"/> object.</returns>
-		public virtual Token NextToken()
-		{
-			if (curToken == null) {
-				curToken = Next();
-				//Console.WriteLine(ICSharpCode.NRefactory.VB.Parser.CSharp.Tokens.GetTokenString(curToken.kind) + " -- " + curToken.val + "(" + curToken.kind + ")");
-				return curToken;
-			}
-			
-			lastToken = curToken;
-			
-			if (curToken.next == null) {
-				curToken.next = Next();
-			}
-			
-			curToken  = curToken.next;
-			//Console.WriteLine(ICSharpCode.NRefactory.VB.Parser.CSharp.Tokens.GetTokenString(curToken.kind) + " -- " + curToken.val + "(" + curToken.kind + ")");
-			return curToken;
-		}
-		
-		protected abstract Token Next();
-		
-		protected static bool IsIdentifierPart(int ch)
-		{
-			if (ch == 95) return true;  // 95 = '_'
-			if (ch == -1) return false;
-			return char.IsLetterOrDigit((char)ch); // accept unicode letters
-		}
-		
-		protected static bool IsHex(char digit)
-		{
-			return Char.IsDigit(digit) || ('A' <= digit && digit <= 'F') || ('a' <= digit && digit <= 'f');
-		}
-		
-		protected int GetHexNumber(char digit)
-		{
-			if (Char.IsDigit(digit)) {
-				return digit - '0';
-			}
-			if ('A' <= digit && digit <= 'F') {
-				return digit - 'A' + 0xA;
-			}
-			if ('a' <= digit && digit <= 'f') {
-				return digit - 'a' + 0xA;
-			}
-			errors.Error(line, col, String.Format("Invalid hex number '" + digit + "'"));
-			return 0;
-		}
-		protected Location lastLineEnd = new Location (1, 1);
-		protected Location curLineEnd = new Location (1, 1);
-		protected void LineBreak ()
-		{
-			lastLineEnd = curLineEnd;
-			curLineEnd = new Location (col - 1, line);
-		}
-		protected bool HandleLineEnd(char ch)
-		{
-			// Handle MS-DOS or MacOS line ends.
-			if (ch == '\r') {
-				if (reader.Peek() == '\n') { // MS-DOS line end '\r\n'
-					ReaderRead(); // LineBreak (); called by ReaderRead ();
-					return true;
-				} else { // assume MacOS line end which is '\r'
-					LineBreak ();
-					return true;
-				}
-			}
-			if (ch == '\n') {
-				LineBreak ();
-				return true;
-			}
-			return false;
-		}
-		
-		protected void SkipToEndOfLine()
-		{
-			int nextChar;
-			while ((nextChar = reader.Read()) != -1) {
-				if (nextChar == '\r') {
-					if (reader.Peek() == '\n')
-						reader.Read();
-					nextChar = '\n';
-				}
-				if (nextChar == '\n') {
-					++line;
-					col = 1;
-					break;
-				}
-			}
-		}
-		
-		protected string ReadToEndOfLine()
-		{
-			sb.Length = 0;
-			int nextChar;
-			while ((nextChar = reader.Read()) != -1) {
-				char ch = (char)nextChar;
-				
-				if (nextChar == '\r') {
-					if (reader.Peek() == '\n')
-						reader.Read();
-					nextChar = '\n';
-				}
-				// Return read string, if EOL is reached
-				if (nextChar == '\n') {
-					++line;
-					col = 1;
-					return sb.ToString();
-				}
-				
-				sb.Append(ch);
-			}
-			
-			// Got EOF before EOL
-			string retStr = sb.ToString();
-			col += retStr.Length;
-			return retStr;
-		}
-		
-		/// <summary>
-		/// Skips to the end of the current code block.
-		/// For this, the lexer must have read the next token AFTER the token opening the
-		/// block (so that Lexer.Token is the block-opening token, not Lexer.LookAhead).
-		/// After the call, Lexer.LookAhead will be the block-closing token.
-		/// </summary>
-		public abstract void SkipCurrentBlock(int targetToken);
-		
-		public event EventHandler<SavepointEventArgs> SavepointReached;
-		
-		protected virtual void OnSavepointReached(SavepointEventArgs e)
-		{
-			if (SavepointReached != null) {
-				SavepointReached(this, e);
-			}
-		}
-		
-		public virtual LexerMemento Export()
-		{
-			throw new NotSupportedException();
-		}
-		
-		public virtual void SetInitialContext(SnippetType context)
-		{
-			throw new NotSupportedException();
-		}
-	}
-}
diff --git a/ICSharpCode.NRefactory.VB/Lexer/ILexer.cs b/ICSharpCode.NRefactory.VB/Lexer/ILexer.cs
deleted file mode 100644
index 11601f64c1..0000000000
--- a/ICSharpCode.NRefactory.VB/Lexer/ILexer.cs
+++ /dev/null
@@ -1,123 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections.Generic;
-
-namespace ICSharpCode.NRefactory.VB.Parser
-{
-	/// <summary>
-	/// Lexer interface
-	/// </summary>
-	public interface ILexer : IDisposable
-	{
-		/// <summary>
-		/// Sets the start line/column number. This method can be called only before the first token is read.
-		/// </summary>
-		void SetInitialLocation(Location location);
-		
-		/// <summary>
-		/// Sets the context of the lexer.
-		/// </summary>
-		void SetInitialContext(SnippetType context);
-		
-		Errors Errors {
-			get;
-		}
-		
-		/// <summary>
-		/// The current Token. <seealso cref="ICSharpCode.NRefactory.VB.Parser.Token"/>
-		/// </summary>
-		Token Token {
-			get;
-		}
-		
-		/// <summary>
-		/// The next Token (The <see cref="Token"/> after <see cref="NextToken"/> call) . <seealso cref="ICSharpCode.NRefactory.VB.Parser.Token"/>
-		/// </summary>
-		Token LookAhead {
-			get;
-		}
-		
-		/// <summary>
-		/// Special comment tags are tags like TODO, HACK or UNDONE which are read by the lexer and stored in <see cref="TagComments"/>.
-		/// </summary>
-		string[] SpecialCommentTags {
-			get;
-			set;
-		}
-		
-		/// <summary>
-		/// Gets/Sets if the lexer should skip adding comments to the special tracker. Set this
-		/// property to true to improve lexing performance.
-		/// </summary>
-		bool SkipAllComments {
-			get;
-			set;
-		}
-		
-		/// <summary>
-		/// Gets/Sets if the lexer should evaluate conditional compilation symbols.
-		/// </summary>
-		bool EvaluateConditionalCompilation { get; set; }
-		
-		/// <summary>
-		/// The dictionary with the conditional compilation symbols.
-		/// C# ignores the value (you can use null), it just cares whether a symbol is defined.
-		/// </summary>
-		IDictionary<string, object> ConditionalCompilationSymbols { get; }
-		
-		/// <summary>
-		/// Sets the conditional compilation symbols. 
-		/// </summary>
-		/// <param name="symbols">
-		/// A <see cref="System.String"/> containing the symbols. The symbols are separated by ';'.
-		/// </param>
-		void SetConditionalCompilationSymbols (string symbols);
-		
-		/// <summary>
-		/// Returns the comments that had been read and containing tag key words.
-		/// </summary>
-		List<TagComment> TagComments {
-			get;
-		}
-		
-		SpecialTracker SpecialTracker {
-			get;
-		}
-		
-		void StartPeek();
-		
-		/// <summary>
-		/// Gives back the next token. A second call to Peek() gives the next token after the last call for Peek() and so on.
-		/// </summary>
-		/// <returns>An <see cref="Token"/> object.</returns>
-		Token Peek();
-		
-		/// <summary>
-		/// Reads the next token and gives it back.
-		/// </summary>
-		/// <returns>An <see cref="Token"/> object.</returns>
-		Token NextToken();
-		
-		/// <summary>
-		/// Skips to the end of the current code block.
-		/// For this, the lexer must have read the next token AFTER the token opening the
-		/// block (so that Lexer.Token is the block-opening token, not Lexer.LookAhead).
-		/// After the call, Lexer.LookAhead will be the block-closing token.
-		/// </summary>
-		void SkipCurrentBlock(int targetToken);
-		
-		/// <summary>
-		/// Used to export the current state of the lexer. The exported state should be
-		/// complete, so that it is possible to reset the lexer to a previous state completely.
-		/// </summary>
-		LexerMemento Export();
-		
-		/// <summary>
-		/// Is fired by the lexer as soon as a savepoint is reached.
-		/// The Export-method can be used to retrieve the current state.
-		/// </summary>
-		event EventHandler<SavepointEventArgs> SavepointReached;
-	}
-}
diff --git a/ICSharpCode.NRefactory.VB/Lexer/LexerMemento.cs b/ICSharpCode.NRefactory.VB/Lexer/LexerMemento.cs
deleted file mode 100644
index 069474cabd..0000000000
--- a/ICSharpCode.NRefactory.VB/Lexer/LexerMemento.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-
-namespace ICSharpCode.NRefactory.VB.Parser
-{
-	public abstract class LexerMemento
-	{
-		public int Line { get; set; }
-		public int Column { get; set; }
-		public int PrevTokenKind { get; set; }
-	}
-}
diff --git a/ICSharpCode.NRefactory.VB/Lexer/SavepointEventArgs.cs b/ICSharpCode.NRefactory.VB/Lexer/SavepointEventArgs.cs
index 5aba7925bf..4c9cc88cc2 100644
--- a/ICSharpCode.NRefactory.VB/Lexer/SavepointEventArgs.cs
+++ b/ICSharpCode.NRefactory.VB/Lexer/SavepointEventArgs.cs
@@ -9,9 +9,9 @@ namespace ICSharpCode.NRefactory.VB.Parser
 	public class SavepointEventArgs : EventArgs
 	{
 		public Location SavepointLocation { get; private set; }
-		public LexerMemento State { get; private set; }
+		public VBLexerMemento State { get; private set; }
 		
-		public SavepointEventArgs(Location savepointLocation, LexerMemento state)
+		public SavepointEventArgs(Location savepointLocation, VBLexerMemento state)
 		{
 			this.SavepointLocation = savepointLocation;
 			this.State = state;
diff --git a/ICSharpCode.NRefactory.VB/Lexer/Lexer.cs b/ICSharpCode.NRefactory.VB/Lexer/VBLexer.cs
similarity index 81%
rename from ICSharpCode.NRefactory.VB/Lexer/Lexer.cs
rename to ICSharpCode.NRefactory.VB/Lexer/VBLexer.cs
index 6d81153ea3..a928942eb4 100644
--- a/ICSharpCode.NRefactory.VB/Lexer/Lexer.cs
+++ b/ICSharpCode.NRefactory.VB/Lexer/VBLexer.cs
@@ -2,6 +2,7 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
@@ -12,7 +13,7 @@ using System.Xml;
 
 namespace ICSharpCode.NRefactory.VB.Parser
 {
-	internal sealed class Lexer : AbstractLexer
+	public class VBLexer : IDisposable
 	{
 		bool lineEnd = true;
 		bool isAtLineBegin = false; // TODO: handle line begin, if neccessarry
@@ -25,24 +26,23 @@ namespace ICSharpCode.NRefactory.VB.Parser
 		
 		Stack<XmlModeInfo> xmlModeStack = new Stack<XmlModeInfo>();
 		
-		public Lexer(TextReader reader) : base(reader)
+		public VBLexer(TextReader reader)
 		{
+			reader = new LATextReader(reader);
 			ef = new ExpressionFinder();
 		}
 		
-		public Lexer(TextReader reader, LexerMemento state) : base(reader, state)
+		public VBLexer(TextReader reader, VBLexerMemento state) : this(reader)
 		{
-			if (!(state is VBLexerMemento))
-				throw new InvalidOperationException("state must be a VBLexerState");
-			
-			var vbState = state as VBLexerMemento;
-			ef = new ExpressionFinder(vbState.ExpressionFinder);
-			lineEnd = vbState.LineEnd;
-			isAtLineBegin = vbState.IsAtLineBegin;
-			encounteredLineContinuation = vbState.EncounteredLineContinuation;
-			misreadExclamationMarkAsTypeCharacter = vbState.MisreadExclamationMarkAsTypeCharacter;
-			xmlModeStack = new Stack<XmlModeInfo>(vbState.XmlModeInfoStack.Select(i => (XmlModeInfo)i.Clone()).Reverse());
-			inXmlMode = vbState.InXmlMode;
+			SetInitialLocation(new Location(state.Column, state.Line));
+			lastToken = new Token(state.PrevTokenKind, 0, 0);
+			ef = new ExpressionFinder(state.ExpressionFinder);
+			lineEnd = state.LineEnd;
+			isAtLineBegin = state.IsAtLineBegin;
+			encounteredLineContinuation = state.EncounteredLineContinuation;
+			misreadExclamationMarkAsTypeCharacter = state.MisreadExclamationMarkAsTypeCharacter;
+			xmlModeStack = new Stack<XmlModeInfo>(state.XmlModeInfoStack.Select(i => (XmlModeInfo)i.Clone()).Reverse());
+			inXmlMode = state.InXmlMode;
 		}
 		
 		Token NextInternal()
@@ -369,7 +369,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 		
 		Token prevToken;
 		
-		protected override Token Next()
+		Token Next()
 		{
 			Token t = NextInternal();
 			if (t.kind == Tokens.EOL) {
@@ -473,7 +473,11 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			return false;
 		}
 		
-		public override Token NextToken()
+		/// <summary>
+		/// Reads the next token.
+		/// </summary>
+		/// <returns>A <see cref="Token"/> object.</returns>
+		public Token NextToken()
 		{
 			if (curToken == null) { // first call of NextToken()
 				curToken = Next();
@@ -1132,10 +1136,16 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			return Char.ToUpper((char)ReaderPeek(), CultureInfo.InvariantCulture);
 		}
 		
-		public override void SkipCurrentBlock(int targetToken)
+		/// <summary>
+		/// Skips to the end of the current code block.
+		/// For this, the lexer must have read the next token AFTER the token opening the
+		/// block (so that Lexer.Token is the block-opening token, not Lexer.LookAhead).
+		/// After the call, Lexer.LookAhead will be the block-closing token.
+		/// </summary>
+		public void SkipCurrentBlock(int targetToken)
 		{
 			int lastKind = -1;
-			int kind = base.lastToken.kind;
+			int kind = lastToken.kind;
 			while (kind != Tokens.EOF &&
 			       !(lastKind == Tokens.End && kind == targetToken))
 			{
@@ -1145,12 +1155,12 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			}
 		}
 		
-		public override void SetInitialContext(SnippetType type)
+		public void SetInitialContext(SnippetType type)
 		{
 			ef.SetContext(type);
 		}
 		
-		public override LexerMemento Export()
+		public VBLexerMemento Export()
 		{
 			return new VBLexerMemento() {
 				Column = Col,
@@ -1165,5 +1175,315 @@ namespace ICSharpCode.NRefactory.VB.Parser
 				XmlModeInfoStack = new Stack<XmlModeInfo>(xmlModeStack.Select(i => (XmlModeInfo)i.Clone()).Reverse())
 			};
 		}
+		
+		LATextReader reader;
+		int col  = 1;
+		int line = 1;
+		
+		protected Errors errors = new Errors();
+		
+		protected Token lastToken = null;
+		protected Token curToken  = null;
+		protected Token peekToken = null;
+		
+		string[]  specialCommentTags = null;
+		protected Hashtable specialCommentHash  = null;
+		List<TagComment> tagComments  = new List<TagComment>();
+		protected StringBuilder sb              = new StringBuilder();
+		protected SpecialTracker specialTracker = new SpecialTracker();
+		
+		// used for the original value of strings (with escape sequences).
+		protected StringBuilder originalValue = new StringBuilder();
+		
+		public bool SkipAllComments { get; set; }
+		public bool EvaluateConditionalCompilation { get; set; }
+		public virtual IDictionary<string, object> ConditionalCompilationSymbols {
+			get { throw new NotSupportedException(); }
+		}
+		
+		protected static IEnumerable<string> GetSymbols (string symbols)
+		{
+			if (!string.IsNullOrEmpty(symbols)) {
+				foreach (string symbol in symbols.Split (';', ' ', '\t')) {
+					string s = symbol.Trim ();
+					if (s.Length == 0)
+						continue;
+					yield return s;
+				}
+			}
+		}
+		
+		public void SetConditionalCompilationSymbols (string symbols)
+		{
+			throw new NotSupportedException ();
+		}
+		
+		protected int Line {
+			get {
+				return line;
+			}
+		}
+		protected int Col {
+			get {
+				return col;
+			}
+		}
+		
+		protected bool recordRead = false;
+		protected StringBuilder recordedText = new StringBuilder ();
+		
+		protected int ReaderRead()
+		{
+			int val = reader.Read();
+			if (recordRead && val >= 0)
+				recordedText.Append ((char)val);
+			if ((val == '\r' && reader.Peek() != '\n') || val == '\n') {
+				++line;
+				col = 1;
+				LineBreak();
+			} else if (val >= 0) {
+				col++;
+			}
+			return val;
+		}
+		
+		protected int ReaderPeek()
+		{
+			return reader.Peek();
+		}
+		
+		protected int ReaderPeek(int step)
+		{
+			return reader.Peek(step);
+		}
+		
+		protected void ReaderSkip(int steps)
+		{
+			for (int i = 0; i < steps; i++) {
+				ReaderRead();
+			}
+		}
+		
+		protected string ReaderPeekString(int length)
+		{
+			StringBuilder builder = new StringBuilder();
+			
+			for (int i = 0; i < length; i++) {
+				int peek = ReaderPeek(i);
+				if (peek != -1)
+					builder.Append((char)peek);
+			}
+			
+			return builder.ToString();
+		}
+		
+		public void SetInitialLocation(Location location)
+		{
+			if (lastToken != null || curToken != null || peekToken != null)
+				throw new InvalidOperationException();
+			this.line = location.Line;
+			this.col = location.Column;
+		}
+		
+		public Errors Errors {
+			get {
+				return errors;
+			}
+		}
+		
+		/// <summary>
+		/// Returns the comments that had been read and containing tag key words.
+		/// </summary>
+		public List<TagComment> TagComments {
+			get {
+				return tagComments;
+			}
+		}
+		
+		public SpecialTracker SpecialTracker {
+			get {
+				return specialTracker;
+			}
+		}
+		
+		/// <summary>
+		/// Special comment tags are tags like TODO, HACK or UNDONE which are read by the lexer and stored in <see cref="TagComments"/>.
+		/// </summary>
+		public string[] SpecialCommentTags {
+			get {
+				return specialCommentTags;
+			}
+			set {
+				specialCommentTags = value;
+				specialCommentHash = null;
+				if (specialCommentTags != null && specialCommentTags.Length > 0) {
+					specialCommentHash = new Hashtable();
+					foreach (string str in specialCommentTags) {
+						specialCommentHash.Add(str, null);
+					}
+				}
+			}
+		}
+		
+		/// <summary>
+		/// The current Token. <seealso cref="ICSharpCode.NRefactory.VB.Parser.Token"/>
+		/// </summary>
+		public Token Token {
+			get {
+//				Console.WriteLine("Call to Token");
+				return lastToken;
+			}
+		}
+		
+		/// <summary>
+		/// The next Token (The <see cref="Token"/> after <see cref="NextToken"/> call) . <seealso cref="ICSharpCode.NRefactory.VB.Parser.Token"/>
+		/// </summary>
+		public Token LookAhead {
+			get {
+//				Console.WriteLine("Call to LookAhead");
+				return curToken;
+			}
+		}
+		
+		#region System.IDisposable interface implementation
+		public virtual void Dispose()
+		{
+			reader.Close();
+			reader = null;
+			errors = null;
+			lastToken = curToken = peekToken = null;
+			specialCommentHash = null;
+			tagComments = null;
+			sb = originalValue = null;
+		}
+		#endregion
+		
+		/// <summary>
+		/// Must be called before a peek operation.
+		/// </summary>
+		public void StartPeek()
+		{
+			peekToken = curToken;
+		}
+		
+		/// <summary>
+		/// Gives back the next token. A second call to Peek() gives the next token after the last call for Peek() and so on.
+		/// </summary>
+		/// <returns>An <see cref="Token"/> object.</returns>
+		public Token Peek()
+		{
+//			Console.WriteLine("Call to Peek");
+			if (peekToken.next == null) {
+				peekToken.next = Next();
+			}
+			peekToken = peekToken.next;
+			return peekToken;
+		}
+		
+		protected static bool IsIdentifierPart(int ch)
+		{
+			if (ch == 95) return true;  // 95 = '_'
+			if (ch == -1) return false;
+			return char.IsLetterOrDigit((char)ch); // accept unicode letters
+		}
+		
+		protected static bool IsHex(char digit)
+		{
+			return Char.IsDigit(digit) || ('A' <= digit && digit <= 'F') || ('a' <= digit && digit <= 'f');
+		}
+		
+		protected int GetHexNumber(char digit)
+		{
+			if (Char.IsDigit(digit)) {
+				return digit - '0';
+			}
+			if ('A' <= digit && digit <= 'F') {
+				return digit - 'A' + 0xA;
+			}
+			if ('a' <= digit && digit <= 'f') {
+				return digit - 'a' + 0xA;
+			}
+			errors.Error(line, col, String.Format("Invalid hex number '" + digit + "'"));
+			return 0;
+		}
+		protected Location lastLineEnd = new Location (1, 1);
+		protected Location curLineEnd = new Location (1, 1);
+		protected void LineBreak ()
+		{
+			lastLineEnd = curLineEnd;
+			curLineEnd = new Location (col - 1, line);
+		}
+		protected bool HandleLineEnd(char ch)
+		{
+			// Handle MS-DOS or MacOS line ends.
+			if (ch == '\r') {
+				if (reader.Peek() == '\n') { // MS-DOS line end '\r\n'
+					ReaderRead(); // LineBreak (); called by ReaderRead ();
+					return true;
+				} else { // assume MacOS line end which is '\r'
+					LineBreak ();
+					return true;
+				}
+			}
+			if (ch == '\n') {
+				LineBreak ();
+				return true;
+			}
+			return false;
+		}
+		
+		protected void SkipToEndOfLine()
+		{
+			int nextChar;
+			while ((nextChar = reader.Read()) != -1) {
+				if (nextChar == '\r') {
+					if (reader.Peek() == '\n')
+						reader.Read();
+					nextChar = '\n';
+				}
+				if (nextChar == '\n') {
+					++line;
+					col = 1;
+					break;
+				}
+			}
+		}
+		
+		protected string ReadToEndOfLine()
+		{
+			sb.Length = 0;
+			int nextChar;
+			while ((nextChar = reader.Read()) != -1) {
+				char ch = (char)nextChar;
+				
+				if (nextChar == '\r') {
+					if (reader.Peek() == '\n')
+						reader.Read();
+					nextChar = '\n';
+				}
+				// Return read string, if EOL is reached
+				if (nextChar == '\n') {
+					++line;
+					col = 1;
+					return sb.ToString();
+				}
+				
+				sb.Append(ch);
+			}
+			
+			// Got EOF before EOL
+			string retStr = sb.ToString();
+			col += retStr.Length;
+			return retStr;
+		}
+		
+		public event EventHandler<SavepointEventArgs> SavepointReached;
+		
+		protected virtual void OnSavepointReached(SavepointEventArgs e)
+		{
+			if (SavepointReached != null) {
+				SavepointReached(this, e);
+			}
+		}
 	}
 }
diff --git a/ICSharpCode.NRefactory.VB/Lexer/VBLexerMemento.cs b/ICSharpCode.NRefactory.VB/Lexer/VBLexerMemento.cs
index 26cfa350dc..148475ccd8 100644
--- a/ICSharpCode.NRefactory.VB/Lexer/VBLexerMemento.cs
+++ b/ICSharpCode.NRefactory.VB/Lexer/VBLexerMemento.cs
@@ -6,8 +6,11 @@ using System.Collections.Generic;
 
 namespace ICSharpCode.NRefactory.VB.Parser
 {
-	public sealed class VBLexerMemento : LexerMemento
+	public sealed class VBLexerMemento
 	{
+		public int Line { get; set; }
+		public int Column { get; set; }
+		public int PrevTokenKind { get; set; }
 		public bool LineEnd { get; set; }
 		public bool IsAtLineBegin { get; set; }
 		public bool MisreadExclamationMarkAsTypeCharacter { get; set; }
diff --git a/ICSharpCode.NRefactory.VB/Parser/VBParser.cs b/ICSharpCode.NRefactory.VB/Parser/VBParser.cs
index 31849f28c0..d08023e185 100644
--- a/ICSharpCode.NRefactory.VB/Parser/VBParser.cs
+++ b/ICSharpCode.NRefactory.VB/Parser/VBParser.cs
@@ -14,7 +14,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 {
 	public partial class VBParser
 	{
-		Lexer lexer;
+		VBLexer lexer;
 		Stack<INode> blockStack;
 		CompilationUnit compilationUnit;
 		int errDist = MinErrDist;
@@ -23,11 +23,11 @@ namespace ICSharpCode.NRefactory.VB.Parser
 		const int    MinErrDist   = 2;
 		const string ErrMsgFormat = "-- line {0} col {1}: {2}";  // 0=line, 1=column, 2=text
 		
-		public VBParser(ILexer lexer)
+		public VBParser(VBLexer lexer)
 		{
 			this.errors = lexer.Errors;
 			errors.SynErr = new ErrorCodeProc(SynErr);
-			this.lexer = (Lexer)lexer;
+			this.lexer = (VBLexer)lexer;
 			this.blockStack = new Stack<INode>();
 		}
 		
@@ -397,7 +397,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			}
 		}
 		
-		public ILexer Lexer {
+		public VBLexer Lexer {
 			get {
 				return lexer;
 			}
diff --git a/ICSharpCode.NRefactory.VB/ParserFactory.cs b/ICSharpCode.NRefactory.VB/ParserFactory.cs
index aa93d38646..1deba96cea 100644
--- a/ICSharpCode.NRefactory.VB/ParserFactory.cs
+++ b/ICSharpCode.NRefactory.VB/ParserFactory.cs
@@ -13,19 +13,19 @@ namespace ICSharpCode.NRefactory.VB
 	/// </summary>
 	public static class ParserFactory
 	{
-		public static Parser.ILexer CreateLexer(TextReader textReader)
+		public static VBLexer CreateLexer(TextReader textReader)
 		{
-			return new ICSharpCode.NRefactory.VB.Parser.Lexer(textReader);
+			return new ICSharpCode.NRefactory.VB.Parser.VBLexer(textReader);
 		}
 		
-		public static Parser.ILexer CreateLexer(TextReader textReader, LexerMemento state)
+		public static VBLexer CreateLexer(TextReader textReader, VBLexerMemento state)
 		{
-			return new ICSharpCode.NRefactory.VB.Parser.Lexer(textReader, state);
+			return new ICSharpCode.NRefactory.VB.Parser.VBLexer(textReader, state);
 		}
 		
 		public static VBParser CreateParser(TextReader textReader)
 		{
-			Parser.ILexer lexer = CreateLexer(textReader);
+			Parser.VBLexer lexer = CreateLexer(textReader);
 			return new ICSharpCode.NRefactory.VB.Parser.VBParser(lexer);
 		}
 		
diff --git a/ICSharpCode.NRefactory.VB/PrettyPrinter/IOutputAstVisitor.cs b/ICSharpCode.NRefactory.VB/PrettyPrinter/IOutputAstVisitor.cs
index 172c592bd0..e692fe1e91 100644
--- a/ICSharpCode.NRefactory.VB/PrettyPrinter/IOutputAstVisitor.cs
+++ b/ICSharpCode.NRefactory.VB/PrettyPrinter/IOutputAstVisitor.cs
@@ -7,10 +7,7 @@ using ICSharpCode.NRefactory.VB.Dom;
 
 namespace ICSharpCode.NRefactory.VB.PrettyPrinter
 {
-	/// <summary>
-	/// Description of IOutputASTVisitor.
-	/// </summary>
-	public interface IOutputAstVisitor : IAstVisitor
+	public interface IOutputDomVisitor : IDomVisitor
 	{
 		event Action<INode> BeforeNodeVisit;
 		event Action<INode> AfterNodeVisit;
@@ -30,6 +27,7 @@ namespace ICSharpCode.NRefactory.VB.PrettyPrinter
 			get;
 		}
 	}
+	
 	public interface IOutputFormatter
 	{
 		int IndentationLevel {
diff --git a/ICSharpCode.NRefactory.VB/PrettyPrinter/SpecialNodesInserter.cs b/ICSharpCode.NRefactory.VB/PrettyPrinter/SpecialNodesInserter.cs
index 9c9c0b3bbd..b1a8ee9bb0 100644
--- a/ICSharpCode.NRefactory.VB/PrettyPrinter/SpecialNodesInserter.cs
+++ b/ICSharpCode.NRefactory.VB/PrettyPrinter/SpecialNodesInserter.cs
@@ -131,7 +131,7 @@ namespace ICSharpCode.NRefactory.VB.PrettyPrinter
 		/// Make sure to call Finish() (or Dispose()) on the returned SpecialNodesInserter
 		/// when the output is finished.
 		/// </summary>
-		public static SpecialNodesInserter Install(IEnumerable<ISpecial> specials, IOutputAstVisitor outputVisitor)
+		public static SpecialNodesInserter Install(IEnumerable<ISpecial> specials, IOutputDomVisitor outputVisitor)
 		{
 			SpecialNodesInserter sni = new SpecialNodesInserter(specials, new SpecialOutputVisitor(outputVisitor.OutputFormatter));
 			outputVisitor.BeforeNodeVisit += sni.AcceptNodeStart;
diff --git a/ICSharpCode.NRefactory.VB/PrettyPrinter/VBNet/VBNetOutputVisitor.cs b/ICSharpCode.NRefactory.VB/PrettyPrinter/VBNet/VBNetOutputVisitor.cs
index 536987e4ab..86420bfc4e 100644
--- a/ICSharpCode.NRefactory.VB/PrettyPrinter/VBNet/VBNetOutputVisitor.cs
+++ b/ICSharpCode.NRefactory.VB/PrettyPrinter/VBNet/VBNetOutputVisitor.cs
@@ -15,7 +15,7 @@ using ICSharpCode.NRefactory.VB.Visitors;
 
 namespace ICSharpCode.NRefactory.VB.PrettyPrinter
 {
-	public sealed class VBNetOutputVisitor : NodeTrackingAstVisitor, IOutputAstVisitor
+	public sealed class VBNetOutputVisitor : NodeTrackingDomVisitor, IOutputDomVisitor
 	{
 		Errors                  errors             = new Errors();
 		VBNetOutputFormatter    outputFormatter;
@@ -36,7 +36,7 @@ namespace ICSharpCode.NRefactory.VB.PrettyPrinter
 			}
 		}
 		
-		AbstractPrettyPrintOptions IOutputAstVisitor.Options {
+		AbstractPrettyPrintOptions IOutputDomVisitor.Options {
 			get { return prettyPrintOptions; }
 		}
 		
@@ -89,7 +89,7 @@ namespace ICSharpCode.NRefactory.VB.PrettyPrinter
 			Error(node.GetType().Name + " is unsupported", node.StartLocation);
 		}
 		
-		#region ICSharpCode.NRefactory.Parser.IASTVisitor interface implementation
+		#region ICSharpCode.NRefactory.Parser.IDomVisitor interface implementation
 		public override object TrackedVisitCompilationUnit(CompilationUnit compilationUnit, object data)
 		{
 			compilationUnit.AcceptChildren(this, data);
diff --git a/ICSharpCode.NRefactory.VB/SnippetParser.cs b/ICSharpCode.NRefactory.VB/SnippetParser.cs
index fc91a137e5..d6273176e5 100644
--- a/ICSharpCode.NRefactory.VB/SnippetParser.cs
+++ b/ICSharpCode.NRefactory.VB/SnippetParser.cs
@@ -113,7 +113,7 @@ namespace ICSharpCode.NRefactory.VB
 			
 			public object UserData { get; set; }
 			
-			public object AcceptChildren(IAstVisitor visitor, object data)
+			public object AcceptChildren(IDomVisitor visitor, object data)
 			{
 				foreach (INode n in nodes) {
 					n.AcceptVisitor(visitor, data);
@@ -121,7 +121,7 @@ namespace ICSharpCode.NRefactory.VB
 				return null;
 			}
 			
-			public object AcceptVisitor(IAstVisitor visitor, object data)
+			public object AcceptVisitor(IDomVisitor visitor, object data)
 			{
 				return AcceptChildren(visitor, data);
 			}
diff --git a/ICSharpCode.NRefactory.VB/Visitors/AbstractAstTransformer.cs b/ICSharpCode.NRefactory.VB/Visitors/AbstractDomTransformer.cs
similarity index 99%
rename from ICSharpCode.NRefactory.VB/Visitors/AbstractAstTransformer.cs
rename to ICSharpCode.NRefactory.VB/Visitors/AbstractDomTransformer.cs
index fe91eda0a9..aa4a698def 100644
--- a/ICSharpCode.NRefactory.VB/Visitors/AbstractAstTransformer.cs
+++ b/ICSharpCode.NRefactory.VB/Visitors/AbstractDomTransformer.cs
@@ -16,15 +16,15 @@ namespace ICSharpCode.NRefactory.VB.Visitors {
 	
 	
 	/// <summary>
-	/// The AbstractAstTransformer will iterate through the whole AST,
-	/// just like the AbstractAstVisitor. However, the AbstractAstTransformer allows
-	/// you to modify the AST at the same time: It does not use 'foreach' internally,
+	/// The AbstractDomTransformer will iterate through the whole Dom,
+	/// just like the AbstractDomVisitor. However, the AbstractDomTransformer allows
+	/// you to modify the Dom at the same time: It does not use 'foreach' internally,
 	/// so you can add members to collections of parents of the current node (but
 	/// you cannot insert or delete items as that will make the index used invalid).
 	/// You can use the methods ReplaceCurrentNode and RemoveCurrentNode to replace
 	/// or remove the current node, totally independent from the type of the parent node.
 	/// </summary>
-	public abstract class AbstractAstTransformer : IAstVisitor {
+	public abstract class AbstractDomTransformer : IDomVisitor {
 		
 		private Stack<INode> nodeStack = new Stack<INode>();
 		
diff --git a/ICSharpCode.NRefactory.VB/Visitors/AbstractASTVisitor.cs b/ICSharpCode.NRefactory.VB/Visitors/AbstractDomVisitor.cs
similarity index 99%
rename from ICSharpCode.NRefactory.VB/Visitors/AbstractASTVisitor.cs
rename to ICSharpCode.NRefactory.VB/Visitors/AbstractDomVisitor.cs
index 7078b6d7b4..cd9a63afbe 100644
--- a/ICSharpCode.NRefactory.VB/Visitors/AbstractASTVisitor.cs
+++ b/ICSharpCode.NRefactory.VB/Visitors/AbstractDomVisitor.cs
@@ -15,7 +15,7 @@ namespace ICSharpCode.NRefactory.VB.Visitors {
 	using ICSharpCode.NRefactory.VB.Dom;
 	
 	
-	public abstract class AbstractAstVisitor : IAstVisitor {
+	public abstract class AbstractDomVisitor : IDomVisitor {
 		
 		public virtual object VisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data) {
 			Debug.Assert((addHandlerStatement != null));
diff --git a/ICSharpCode.NRefactory.VB/Visitors/CodeDOMOutputVisitor.cs b/ICSharpCode.NRefactory.VB/Visitors/CodeDOMOutputVisitor.cs
index 6542fb5bf4..965e9703b5 100644
--- a/ICSharpCode.NRefactory.VB/Visitors/CodeDOMOutputVisitor.cs
+++ b/ICSharpCode.NRefactory.VB/Visitors/CodeDOMOutputVisitor.cs
@@ -12,7 +12,7 @@ using ICSharpCode.NRefactory.VB.Dom;
 
 namespace ICSharpCode.NRefactory.VB.Visitors
 {
-	public class CodeDomVisitor : AbstractAstVisitor
+	public class CodeDomVisitor : AbstractDomVisitor
 	{
 		Stack<CodeNamespace>  namespaceDeclarations = new Stack<CodeNamespace>();
 		Stack<CodeTypeDeclaration> typeDeclarations = new Stack<CodeTypeDeclaration>();
@@ -174,7 +174,7 @@ namespace ICSharpCode.NRefactory.VB.Visitors
 			return attr;
 		}
 		
-		#region ICSharpCode.SharpRefactory.Parser.IASTVisitor interface implementation
+		#region ICSharpCode.SharpRefactory.Parser.IDomVisitor interface implementation
 		public override object VisitCompilationUnit(CompilationUnit compilationUnit, object data)
 		{
 			if (compilationUnit == null) {
diff --git a/ICSharpCode.NRefactory.VB/Visitors/LookupTableVisitor.cs b/ICSharpCode.NRefactory.VB/Visitors/LookupTableVisitor.cs
index 34692b61b2..97e6ed6a23 100644
--- a/ICSharpCode.NRefactory.VB/Visitors/LookupTableVisitor.cs
+++ b/ICSharpCode.NRefactory.VB/Visitors/LookupTableVisitor.cs
@@ -35,7 +35,7 @@ namespace ICSharpCode.NRefactory.VB.Visitors
 		
 	}
 	
-	public sealed class LookupTableVisitor : AbstractAstVisitor
+	public sealed class LookupTableVisitor : AbstractDomVisitor
 	{
 		Dictionary<string, List<LocalLookupVariable>> variables;
 		
diff --git a/ICSharpCode.NRefactory.VB/Visitors/NodeTrackingAstVisitor.cs b/ICSharpCode.NRefactory.VB/Visitors/NodeTrackingDomVisitor.cs
similarity index 99%
rename from ICSharpCode.NRefactory.VB/Visitors/NodeTrackingAstVisitor.cs
rename to ICSharpCode.NRefactory.VB/Visitors/NodeTrackingDomVisitor.cs
index bf54850c8d..79ed02e58c 100644
--- a/ICSharpCode.NRefactory.VB/Visitors/NodeTrackingAstVisitor.cs
+++ b/ICSharpCode.NRefactory.VB/Visitors/NodeTrackingDomVisitor.cs
@@ -14,8 +14,8 @@ namespace ICSharpCode.NRefactory.VB.Visitors {
 	
 	
 	/// <summary>
-	/// The NodeTrackingAstVisitor will iterate through the whole AST,
-	/// just like the AbstractAstVisitor, and calls the virtual methods
+	/// The NodeTrackingDomVisitor will iterate through the whole Dom,
+	/// just like the AbstractDomVisitor, and calls the virtual methods
 	/// BeginVisit and EndVisit for each node being visited.
 	/// </summary>
 	/// <remarks>
@@ -23,7 +23,7 @@ namespace ICSharpCode.NRefactory.VB.Visitors {
 	/// you want to visit child nodes using the default visiting behaviour,
 	/// use base.TrackedVisit(parentNode, data).
 	/// </remarks>
-	public abstract class NodeTrackingAstVisitor : AbstractAstVisitor {
+	public abstract class NodeTrackingDomVisitor : AbstractDomVisitor {
 		
 		protected virtual void BeginVisit(INode node) {
 		}
diff --git a/ICSharpCode.NRefactory.VB/Visitors/NotImplementedAstVisitor.cs b/ICSharpCode.NRefactory.VB/Visitors/NotImplementedDomVisitor.cs
similarity index 99%
rename from ICSharpCode.NRefactory.VB/Visitors/NotImplementedAstVisitor.cs
rename to ICSharpCode.NRefactory.VB/Visitors/NotImplementedDomVisitor.cs
index 05f8854a5f..33ca1cfc79 100644
--- a/ICSharpCode.NRefactory.VB/Visitors/NotImplementedAstVisitor.cs
+++ b/ICSharpCode.NRefactory.VB/Visitors/NotImplementedDomVisitor.cs
@@ -14,9 +14,9 @@ namespace ICSharpCode.NRefactory.VB.Visitors {
 	
 	
 	/// <summary>
-	/// IAstVisitor implementation that always throws NotImplementedExceptions.
+	/// IDomVisitor implementation that always throws NotImplementedExceptions.
 	/// </summary>
-	public class NotImplementedAstVisitor : IAstVisitor {
+	public class NotImplementedDomVisitor : IDomVisitor {
 		
 		public virtual object VisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data) {
 			throw new global::System.NotImplementedException("AddHandlerStatement");
diff --git a/ICSharpCode.NRefactory.VB/Visitors/PrefixFieldsVisitor.cs b/ICSharpCode.NRefactory.VB/Visitors/PrefixFieldsVisitor.cs
index 90519e4381..4b6a8f328a 100644
--- a/ICSharpCode.NRefactory.VB/Visitors/PrefixFieldsVisitor.cs
+++ b/ICSharpCode.NRefactory.VB/Visitors/PrefixFieldsVisitor.cs
@@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.VB.Visitors
 	/// <summary>
 	/// Prefixes the names of the specified fields with the prefix and replaces the use.
 	/// </summary>
-	public class PrefixFieldsVisitor : AbstractAstVisitor
+	public class PrefixFieldsVisitor : AbstractDomVisitor
 	{
 		List<VariableDeclaration> fields;
 		List<string> curBlock = new List<string>();
diff --git a/ICSharpCode.NRefactory.VB/Visitors/RenameIdentifierVisitor.cs b/ICSharpCode.NRefactory.VB/Visitors/RenameIdentifierVisitor.cs
index f6e014ac21..a4c9bf5530 100644
--- a/ICSharpCode.NRefactory.VB/Visitors/RenameIdentifierVisitor.cs
+++ b/ICSharpCode.NRefactory.VB/Visitors/RenameIdentifierVisitor.cs
@@ -6,7 +6,7 @@ using ICSharpCode.NRefactory.VB.Dom;
 
 namespace ICSharpCode.NRefactory.VB.Visitors
 {
-	class RenameIdentifierVisitor : AbstractAstVisitor
+	class RenameIdentifierVisitor : AbstractDomVisitor
 	{
 		protected StringComparer nameComparer;
 		protected string from, to;
diff --git a/ICSharpCode.NRefactory.VB/Visitors/SetParentVisitor.cs b/ICSharpCode.NRefactory.VB/Visitors/SetParentVisitor.cs
index 7087307f10..5835a55624 100644
--- a/ICSharpCode.NRefactory.VB/Visitors/SetParentVisitor.cs
+++ b/ICSharpCode.NRefactory.VB/Visitors/SetParentVisitor.cs
@@ -10,7 +10,7 @@ namespace ICSharpCode.NRefactory.VB.Visitors
 	/// <summary>
 	/// Sets the parent property on all nodes in the tree.
 	/// </summary>
-	public class SetParentVisitor : NodeTrackingAstVisitor
+	public class SetParentVisitor : NodeTrackingDomVisitor
 	{
 		Stack<INode> nodeStack = new Stack<INode>();
 		
diff --git a/ICSharpCode.NRefactory.VB/Visitors/SetRegionInclusionVisitor.cs b/ICSharpCode.NRefactory.VB/Visitors/SetRegionInclusionVisitor.cs
index 8de3ab3db0..ad6da8f0fe 100644
--- a/ICSharpCode.NRefactory.VB/Visitors/SetRegionInclusionVisitor.cs
+++ b/ICSharpCode.NRefactory.VB/Visitors/SetRegionInclusionVisitor.cs
@@ -13,7 +13,7 @@ namespace ICSharpCode.NRefactory.VB.Visitors
 	/// Parsers don't do this by default:
 	/// e.g. "a.Foo()" is InvocationExpression, its region includes only the "()" and it has a child MemberReferenceExpression, with region ".Foo".
 	/// </summary>
-	public class SetRegionInclusionVisitor : NodeTrackingAstVisitor
+	public class SetRegionInclusionVisitor : NodeTrackingDomVisitor
 	{
 		Stack<INode> parentNodes = new Stack<INode>();
 		
diff --git a/VBDomGenerator/AssemblyInfo.cs b/VBDomGenerator/AssemblyInfo.cs
index 79b1055f2f..de620a2271 100644
--- a/VBDomGenerator/AssemblyInfo.cs
+++ b/VBDomGenerator/AssemblyInfo.cs
@@ -10,7 +10,7 @@ using System.Runtime.CompilerServices;
 // change them to the information which is associated with the assembly
 // you compile.
 
-[assembly: AssemblyTitle("NRefactory AST Generator")]
+[assembly: AssemblyTitle("VB Dom Generator")]
 [assembly: AssemblyDescription("Parser and refactoring library for C# and VB.NET")]
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("ic#code")]
diff --git a/VBDomGenerator/Attributes.cs b/VBDomGenerator/Attributes.cs
index 3a492d00a5..0159cc0068 100644
--- a/VBDomGenerator/Attributes.cs
+++ b/VBDomGenerator/Attributes.cs
@@ -6,7 +6,7 @@ using System.CodeDom;
 using System.Reflection;
 using ICSharpCode.EasyCodeDom;
 
-namespace NRefactoryASTGenerator
+namespace VBDomGenerator
 {
 	public enum NullableImplementation
 	{
@@ -146,7 +146,7 @@ namespace NRefactoryASTGenerator
 				CodeMemberMethod method = new CodeMemberMethod();
 				method.Name = "AcceptVisitor";
 				method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
-				method.Parameters.Add(new CodeParameterDeclarationExpression("IAstVisitor", "visitor"));
+				method.Parameters.Add(new CodeParameterDeclarationExpression("IDomVisitor", "visitor"));
 				method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "data"));
 				method.ReturnType = new CodeTypeReference(typeof(object));
 				method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null)));
diff --git a/VBDomGenerator/Dom/Expressions.cs b/VBDomGenerator/Dom/Expressions.cs
index 8e8a3f540a..450a355cc0 100644
--- a/VBDomGenerator/Dom/Expressions.cs
+++ b/VBDomGenerator/Dom/Expressions.cs
@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace NRefactoryASTGenerator.Ast
+namespace VBDomGenerator.Dom
 {
 	[CustomImplementation]
 	abstract class Expression : AbstractNode, INullable {}
diff --git a/VBDomGenerator/Dom/GlobalLevel.cs b/VBDomGenerator/Dom/GlobalLevel.cs
index 033e737435..428e36b50c 100644
--- a/VBDomGenerator/Dom/GlobalLevel.cs
+++ b/VBDomGenerator/Dom/GlobalLevel.cs
@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace NRefactoryASTGenerator.Ast
+namespace VBDomGenerator.Dom
 {
 	[CustomImplementation, HasChildren]
 	class CompilationUnit : AbstractNode {}
diff --git a/VBDomGenerator/Dom/Node.cs b/VBDomGenerator/Dom/Node.cs
index bd791aeae1..4e57449d65 100644
--- a/VBDomGenerator/Dom/Node.cs
+++ b/VBDomGenerator/Dom/Node.cs
@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace NRefactoryASTGenerator.Ast
+namespace VBDomGenerator.Dom
 {
 	interface INode {}
 	interface INullable {}
diff --git a/VBDomGenerator/Dom/Statements.cs b/VBDomGenerator/Dom/Statements.cs
index a7f0a5a3a7..9792988ec4 100644
--- a/VBDomGenerator/Dom/Statements.cs
+++ b/VBDomGenerator/Dom/Statements.cs
@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace NRefactoryASTGenerator.Ast
+namespace VBDomGenerator.Dom
 {
 	[CustomImplementation]
 	abstract class Statement : AbstractNode, INullable {}
diff --git a/VBDomGenerator/Dom/TypeLevel.cs b/VBDomGenerator/Dom/TypeLevel.cs
index ee2a1abeb0..a60902c489 100644
--- a/VBDomGenerator/Dom/TypeLevel.cs
+++ b/VBDomGenerator/Dom/TypeLevel.cs
@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace NRefactoryASTGenerator.Ast
+namespace VBDomGenerator.Dom
 {
 	class VariableDeclaration : AbstractNode
 	{
diff --git a/VBDomGenerator/KeywordGenerator.cs b/VBDomGenerator/KeywordGenerator.cs
index 1b0444b278..7dbbc363f4 100644
--- a/VBDomGenerator/KeywordGenerator.cs
+++ b/VBDomGenerator/KeywordGenerator.cs
@@ -9,7 +9,7 @@ using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
 
-namespace NRefactoryASTGenerator
+namespace VBDomGenerator
 {
 	static class KeywordGenerator
 	{
@@ -106,7 +106,7 @@ namespace NRefactoryASTGenerator
 				writer.WriteLine("\t[TestFixture]");
 				writer.WriteLine("\tpublic sealed class LexerTests");
 				writer.WriteLine("\t{");
-				writer.WriteLine("\t\tILexer GenerateLexer(StringReader sr)");
+				writer.WriteLine("\t\tVBLexer GenerateLexer(StringReader sr)");
 				writer.WriteLine("\t\t{");
 				writer.WriteLine("\t\t\treturn ParserFactory.CreateLexer(sr);");
 				writer.WriteLine("\t\t}");
@@ -115,7 +115,7 @@ namespace NRefactoryASTGenerator
 					writer.WriteLine("\t\t[Test]");
 					writer.WriteLine("\t\tpublic void Test{0}()", specialChars.Keys.ElementAt(i));
 					writer.WriteLine("\t\t{");
-					writer.WriteLine("\t\t\tILexer lexer = GenerateLexer(new StringReader({0}));", specialChars.Values.ElementAt(i));
+					writer.WriteLine("\t\t\tVBLexer lexer = GenerateLexer(new StringReader({0}));", specialChars.Values.ElementAt(i));
 					writer.WriteLine("\t\t\tAssert.AreEqual(Tokens.{0}, lexer.NextToken().Kind);", specialChars.Keys.ElementAt(i));
 					writer.WriteLine("\t\t}");
 				}
@@ -126,7 +126,7 @@ namespace NRefactoryASTGenerator
 					writer.WriteLine("\t\t[Test]");
 					writer.WriteLine("\t\tpublic void Test{0}()", UpperCaseFirst(keyword));
 					writer.WriteLine("\t\t{");
-					writer.WriteLine("\t\t\tILexer lexer = GenerateLexer(new StringReader(\"{0}\"));", keyword);
+					writer.WriteLine("\t\t\tVBLexer lexer = GenerateLexer(new StringReader(\"{0}\"));", keyword);
 					writer.WriteLine("\t\t\tAssert.AreEqual(Tokens.{0}, lexer.NextToken().Kind);", UpperCaseFirst(keyword));
 					writer.WriteLine("\t\t}");
 				}
diff --git a/VBDomGenerator/Main.cs b/VBDomGenerator/Main.cs
index 4b78a99919..54ac9dd90d 100644
--- a/VBDomGenerator/Main.cs
+++ b/VBDomGenerator/Main.cs
@@ -7,10 +7,10 @@ using System.CodeDom;
 using System.Diagnostics;
 using System.Reflection;
 using System.IO;
-using NRefactoryASTGenerator.Ast;
+using VBDomGenerator.Dom;
 using ICSharpCode.EasyCodeDom;
 
-namespace NRefactoryASTGenerator
+namespace VBDomGenerator
 {
 	class MainClass
 	{
@@ -23,12 +23,12 @@ namespace NRefactoryASTGenerator
 			string directory = "../../../ICSharpCode.NRefactory.VB/Dom/";
 			string visitorsDir = "../../../ICSharpCode.NRefactory.VB/Visitors/";
 			
-			Debug.WriteLine("AST Generator running...");
+			Debug.WriteLine("DOM Generator running...");
 			if (!File.Exists(directory + "INode.cs")) {
 				Debug.WriteLine("did not find output directory");
 				return;
 			}
-			if (!File.Exists(visitorsDir + "AbstractAstTransformer.cs")) {
+			if (!File.Exists(visitorsDir + "AbstractDomTransformer.cs")) {
 				Debug.WriteLine("did not find visitor output directory");
 				return;
 			}
@@ -65,7 +65,7 @@ namespace NRefactoryASTGenerator
 						CodeMemberMethod method = new CodeMemberMethod();
 						method.Name = "AcceptVisitor";
 						method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
-						method.Parameters.Add(new CodeParameterDeclarationExpression("IAstVisitor", "visitor"));
+						method.Parameters.Add(new CodeParameterDeclarationExpression("IDomVisitor", "visitor"));
 						method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "data"));
 						method.ReturnType = new CodeTypeReference(typeof(object));
 						CodeExpression ex = new CodeVariableReferenceExpression("visitor");
@@ -98,11 +98,11 @@ namespace NRefactoryASTGenerator
 			cns = ccu.AddNamespace("ICSharpCode.NRefactory.VB");
 			cns.AddImport("System");
 			cns.AddImport("ICSharpCode.NRefactory.VB.Dom");
-			cns.Types.Add(CreateAstVisitorInterface(nodeTypes));
+			cns.Types.Add(CreateDomVisitorInterface(nodeTypes));
 			
 			using (StringWriter writer = new StringWriter()) {
 				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
-				File.WriteAllText(visitorsDir + "../IAstVisitor.cs", NormalizeNewLines(writer));
+				File.WriteAllText(visitorsDir + "../IDomVisitor.cs", NormalizeNewLines(writer));
 			}
 			
 			ccu = new CodeCompileUnit();
@@ -111,11 +111,11 @@ namespace NRefactoryASTGenerator
 			cns.AddImport("System.Collections.Generic");
 			cns.AddImport("System.Diagnostics");
 			cns.AddImport("ICSharpCode.NRefactory.VB.Dom");
-			cns.Types.Add(CreateAstVisitorClass(nodeTypes, false));
+			cns.Types.Add(CreateDomVisitorClass(nodeTypes, false));
 			
 			using (StringWriter writer = new StringWriter()) {
 				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
-				File.WriteAllText(visitorsDir + "AbstractAstVisitor.cs", NormalizeNewLines(writer));
+				File.WriteAllText(visitorsDir + "AbstractDomVisitor.cs", NormalizeNewLines(writer));
 			}
 			
 			ccu = new CodeCompileUnit();
@@ -124,38 +124,38 @@ namespace NRefactoryASTGenerator
 			cns.AddImport("System.Collections.Generic");
 			cns.AddImport("System.Diagnostics");
 			cns.AddImport("ICSharpCode.NRefactory.VB.Dom");
-			cns.Types.Add(CreateAstVisitorClass(nodeTypes, true));
+			cns.Types.Add(CreateDomVisitorClass(nodeTypes, true));
 			
 			using (StringWriter writer = new StringWriter()) {
 				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
-				File.WriteAllText(visitorsDir + "AbstractAstTransformer.cs", NormalizeNewLines(writer));
+				File.WriteAllText(visitorsDir + "AbstractDomTransformer.cs", NormalizeNewLines(writer));
 			}
 			
 			ccu = new CodeCompileUnit();
 			cns = ccu.AddNamespace("ICSharpCode.NRefactory.VB.Visitors");
 			cns.AddImport("System");
 			cns.AddImport("ICSharpCode.NRefactory.VB.Dom");
-			cns.Types.Add(CreateNodeTrackingAstVisitorClass(nodeTypes));
+			cns.Types.Add(CreateNodeTrackingDomVisitorClass(nodeTypes));
 			
 			using (StringWriter writer = new StringWriter()) {
 				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
 				// CodeDom cannot output "sealed", so we need to use this hack:
-				File.WriteAllText(visitorsDir + "NodeTrackingAstVisitor.cs",
+				File.WriteAllText(visitorsDir + "NodeTrackingDomVisitor.cs",
 				                  NormalizeNewLines(writer).Replace("public override object", "public sealed override object"));
 			}
 			
-			//NotImplementedAstVisitor
+			//NotImplementedDomVisitor
 			ccu = new CodeCompileUnit();
 			cns = ccu.AddNamespace("ICSharpCode.NRefactory.VB.Visitors");
 			cns.AddImport("System");
 			cns.AddImport("ICSharpCode.NRefactory.VB.Dom");
-			cns.Types.Add(CreateNotImplementedAstVisitorClass(nodeTypes));
+			cns.Types.Add(CreateNotImplementedDomVisitorClass(nodeTypes));
 			
 			using (StringWriter writer = new StringWriter()) {
 				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
-				File.WriteAllText(visitorsDir + "NotImplementedAstVisitor.cs", NormalizeNewLines(writer));
+				File.WriteAllText(visitorsDir + "NotImplementedDomVisitor.cs", NormalizeNewLines(writer));
 			}
-			Debug.WriteLine("AST Generator done!");
+			Debug.WriteLine("DOM Generator done!");
 			
 			Debug.WriteLine("start keyword list generation...");
 			
@@ -169,9 +169,9 @@ namespace NRefactoryASTGenerator
 			return string.Join(Environment.NewLine, writer.ToString().Split(lineEndings, StringSplitOptions.None));
 		}
 		
-		static CodeTypeDeclaration CreateAstVisitorInterface(List<Type> nodeTypes)
+		static CodeTypeDeclaration CreateDomVisitorInterface(List<Type> nodeTypes)
 		{
-			CodeTypeDeclaration td = new CodeTypeDeclaration("IAstVisitor");
+			CodeTypeDeclaration td = new CodeTypeDeclaration("IDomVisitor");
 			td.IsInterface = true;
 			
 			foreach (Type t in nodeTypes) {
@@ -184,17 +184,17 @@ namespace NRefactoryASTGenerator
 			return td;
 		}
 		
-		static CodeTypeDeclaration CreateAstVisitorClass(List<Type> nodeTypes, bool transformer)
+		static CodeTypeDeclaration CreateDomVisitorClass(List<Type> nodeTypes, bool transformer)
 		{
-			CodeTypeDeclaration td = new CodeTypeDeclaration(transformer ? "AbstractAstTransformer" : "AbstractAstVisitor");
+			CodeTypeDeclaration td = new CodeTypeDeclaration(transformer ? "AbstractDomTransformer" : "AbstractDomVisitor");
 			td.TypeAttributes = TypeAttributes.Public | TypeAttributes.Abstract;
-			td.BaseTypes.Add(new CodeTypeReference("IAstVisitor"));
+			td.BaseTypes.Add(new CodeTypeReference("IDomVisitor"));
 			
 			if (transformer) {
 				string comment =
-					"The AbstractAstTransformer will iterate through the whole AST,\n " +
-					"just like the AbstractAstVisitor. However, the AbstractAstTransformer allows\n " +
-					"you to modify the AST at the same time: It does not use 'foreach' internally,\n " +
+					"The AbstractDomTransformer will iterate through the whole Dom,\n " +
+					"just like the AbstractDomVisitor. However, the AbstractDomTransformer allows\n " +
+					"you to modify the Dom at the same time: It does not use 'foreach' internally,\n " +
 					"so you can add members to collections of parents of the current node (but\n " +
 					"you cannot insert or delete items as that will make the index used invalid).\n " +
 					"You can use the methods ReplaceCurrentNode and RemoveCurrentNode to replace\n " +
@@ -493,7 +493,7 @@ namespace NRefactoryASTGenerator
 					tr.TypeArguments.Add(ConvertType(subType));
 				}
 				return tr;
-			} else if (type.FullName.StartsWith("NRefactory") || type.FullName.StartsWith("System.Collections")) {
+			} else if (type.FullName.StartsWith("VBDom") || type.FullName.StartsWith("System.Collections")) {
 				if (type.Name == "Attribute")
 					return new CodeTypeReference("ICSharpCode.NRefactory.VB.Dom.Attribute");
 				return new CodeTypeReference(type.Name);
@@ -502,15 +502,15 @@ namespace NRefactoryASTGenerator
 			}
 		}
 		
-		static CodeTypeDeclaration CreateNodeTrackingAstVisitorClass(List<Type> nodeTypes)
+		static CodeTypeDeclaration CreateNodeTrackingDomVisitorClass(List<Type> nodeTypes)
 		{
-			CodeTypeDeclaration td = new CodeTypeDeclaration("NodeTrackingAstVisitor");
+			CodeTypeDeclaration td = new CodeTypeDeclaration("NodeTrackingDomVisitor");
 			td.TypeAttributes = TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Abstract;
-			td.BaseTypes.Add(new CodeTypeReference("AbstractAstVisitor"));
+			td.BaseTypes.Add(new CodeTypeReference("AbstractDomVisitor"));
 			
 			string comment = "<summary>\n " +
-				"The NodeTrackingAstVisitor will iterate through the whole AST,\n " +
-				"just like the AbstractAstVisitor, and calls the virtual methods\n " +
+				"The NodeTrackingDomVisitor will iterate through the whole Dom,\n " +
+				"just like the AbstractDomVisitor, and calls the virtual methods\n " +
 				"BeginVisit and EndVisit for each node being visited.\n " +
 				"</summary>";
 			td.Comments.Add(new CodeCommentStatement(comment, true));
@@ -562,14 +562,14 @@ namespace NRefactoryASTGenerator
 			return td;
 		}
 		
-		static CodeTypeDeclaration CreateNotImplementedAstVisitorClass(List<Type> nodeTypes)
+		static CodeTypeDeclaration CreateNotImplementedDomVisitorClass(List<Type> nodeTypes)
 		{
-			CodeTypeDeclaration td = new CodeTypeDeclaration("NotImplementedAstVisitor");
+			CodeTypeDeclaration td = new CodeTypeDeclaration("NotImplementedDomVisitor");
 			td.TypeAttributes = TypeAttributes.Public | TypeAttributes.Class;
-			td.BaseTypes.Add(new CodeTypeReference("IAstVisitor"));
+			td.BaseTypes.Add(new CodeTypeReference("IDomVisitor"));
 			
 			string comment = "<summary>\n " +
-				"IAstVisitor implementation that always throws NotImplementedExceptions.\n " +
+				"IDomVisitor implementation that always throws NotImplementedExceptions.\n " +
 				"</summary>";
 			td.Comments.Add(new CodeCommentStatement(comment, true));