NRefactory: Fixed end position of multiline tokens.

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/branches/3.0@3715 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/BackendBindings/VBNetBinding/Project/Src/FormattingStrategy/VBNetFormattingStrategy.cs

@@ -387,12 +387,12 @@ namespace VBNetBinding.FormattingStrategy
 			Token currentToken = null;
 			Token prevToken = null;
 			
-			while ((currentToken = lexer.NextToken()).kind != Tokens.EOF) {
+			while ((currentToken = lexer.NextToken()).Kind != Tokens.EOF) {
 				if (prevToken == null)
 					prevToken = currentToken;
 				
 				if (IsBlockStart(lexer, currentToken, prevToken)) {
-					if ((tokens.Count > 0 && tokens.Peek().kind != Tokens.Interface) || IsDeclaration(currentToken.kind))
+					if ((tokens.Count > 0 && tokens.Peek().Kind != Tokens.Interface) || IsDeclaration(currentToken.Kind))
 						tokens.Push(currentToken);
 				}
 				
@@ -422,12 +422,12 @@ namespace VBNetBinding.FormattingStrategy
 			int diff = 0;
 			
 			foreach (Token t in missingEnds) {
-				if (!IsSingleLine(t.line, textArea)) {
-					if (IsMatchingStatement(t, statement) && ((diff = lineNr - t.line + 1) > -1)) {
+				if (!IsSingleLine(t.Location.Line, textArea)) {
+					if (IsMatchingStatement(t, statement) && ((diff = lineNr - t.Location.Line + 1) > -1)) {
 						if (closest == null) {
 							closest = t;
 						} else {
-							if (diff < lineNr - closest.line + 1)
+							if (diff < lineNr - closest.Location.Line + 1)
 								closest = t;
 						}
 					}
@@ -457,13 +457,13 @@ namespace VBNetBinding.FormattingStrategy
 		
 		bool IsMatchingEnd(Token begin, Token end)
 		{
-			if (begin.kind == end.kind)
+			if (begin.Kind == end.Kind)
 				return true;
 			
-			if (begin.kind == Tokens.For && end.kind == Tokens.Next)
+			if (begin.Kind == Tokens.For && end.Kind == Tokens.Next)
 				return true;
 			
-			if (begin.kind == Tokens.Do && end.kind == Tokens.Loop)
+			if (begin.Kind == Tokens.Do && end.Kind == Tokens.Loop)
 				return true;
 			
 			return false;
@@ -473,14 +473,14 @@ namespace VBNetBinding.FormattingStrategy
 		{
 			// funktioniert noch nicht!
 			
-			if (token.val == "For" && statement.EndStatement == "Next")
+			if (token.Kind == Tokens.For && statement.EndStatement == "Next")
 				return true;
 			
-			if (token.val == "Do" && statement.EndStatement.StartsWith("Loop"))
+			if (token.Kind == Tokens.Do && statement.EndStatement.StartsWith("Loop"))
 				return true;
 			
-			bool empty = !string.IsNullOrEmpty(token.val);
-			bool match = statement.EndStatement.IndexOf(token.val, StringComparison.InvariantCultureIgnoreCase) != -1;
+			bool empty = !string.IsNullOrEmpty(token.Value);
+			bool match = statement.EndStatement.IndexOf(token.Value, StringComparison.InvariantCultureIgnoreCase) != -1;
 			
 			return empty && match;
 		}
@@ -531,86 +531,86 @@ namespace VBNetBinding.FormattingStrategy
 			Token currentToken = null;
 			Token prevToken = null;
 			
-			while ((currentToken = lexer.NextToken()).kind != Tokens.EOF) {
+			while ((currentToken = lexer.NextToken()).Kind != Tokens.EOF) {
 				if (prevToken == null)
 					prevToken = currentToken;
 				
-				if (currentToken.kind == Tokens.MustOverride)
+				if (currentToken.Kind == Tokens.MustOverride)
 					isMustOverride = true;
 				
-				if (currentToken.kind == Tokens.Delegate)
+				if (currentToken.Kind == Tokens.Delegate)
 					isDelegate = true;
 				
-				if (currentToken.kind == Tokens.Declare)
+				if (currentToken.Kind == Tokens.Declare)
 					isDeclare = true;
 				
-				if (currentToken.kind == Tokens.EOL)
+				if (currentToken.Kind == Tokens.EOL)
 					isDelegate = isDeclare = isMustOverride = false;
 				
 				if (IsSpecialCase(currentToken, prevToken)) {
-					ApplyToRange(textArea, ref indentation, oldLine, currentToken.line - 1, begin, end);
+					ApplyToRange(textArea, ref indentation, oldLine, currentToken.Location.Line - 1, begin, end);
 					indentation--;
-					ApplyToRange(textArea, ref indentation, currentToken.line - 1, currentToken.line, begin, end);
+					ApplyToRange(textArea, ref indentation, currentToken.Location.Line - 1, currentToken.Location.Line, begin, end);
 					indentation++;
 					
-					oldLine = currentToken.line;
+					oldLine = currentToken.Location.Line;
 				}
 				
 				if (IsBlockEnd(currentToken, prevToken)) {
-					ApplyToRange(textArea, ref indentation, oldLine, currentToken.line - 1, begin, end);
+					ApplyToRange(textArea, ref indentation, oldLine, currentToken.Location.Line - 1, begin, end);
 					
-					if (currentToken.kind == Tokens.Interface)
+					if (currentToken.Kind == Tokens.Interface)
 						inInterface = false;
 					
 					if (!inInterface && !isMustOverride && !isDeclare && !isDelegate) {
 						indentation--;
 						
-						if (currentToken.kind == Tokens.Select)
+						if (currentToken.Kind == Tokens.Select)
 							indentation--;
 					}
 					
-					oldLine = currentToken.line - 1;
+					oldLine = currentToken.Location.Line - 1;
 				}
 				
 				if (IsBlockStart(lexer, currentToken, prevToken)) {
-					ApplyToRange(textArea, ref indentation, oldLine, currentToken.line, begin, end);
+					ApplyToRange(textArea, ref indentation, oldLine, currentToken.Location.Line, begin, end);
 					
 					if (!inInterface && !isMustOverride && !isDeclare && !isDelegate) {
 						indentation++;
 						
-						if (currentToken.kind == Tokens.Select)
+						if (currentToken.Kind == Tokens.Select)
 							indentation++;
 					}
 					
-					if (currentToken.kind == Tokens.Interface)
+					if (currentToken.Kind == Tokens.Interface)
 						inInterface = true;
 					
-					oldLine = currentToken.line;
+					oldLine = currentToken.Location.Line;
 				}
 				
 				prevToken = currentToken;
 			}
 			
 			// do last indent step
-			ApplyToRange(textArea, ref indentation, oldLine, prevToken.line, begin, end);
+			ApplyToRange(textArea, ref indentation, oldLine, prevToken.Location.Line, begin, end);
 			
 			return indentation;
 		}
 		
 		bool IsBlockStart(ILexer lexer, Token current, Token prev)
 		{
-			if (blockTokens.Contains(current.kind)) {
-				if (current.kind == Tokens.If) {
-					if (prev.kind != Tokens.EOL)
+			if (blockTokens.Contains(current.Kind)) {
+				if (current.Kind == Tokens.If) {
+					if (prev.Kind != Tokens.EOL)
 						return false;
 					
 					lexer.StartPeek();
 					
 					Token currentToken = null;
 					
-					while ((currentToken = lexer.Peek()).kind != Tokens.EOL) {
-						if (currentToken.kind == Tokens.Then) {
-							if (lexer.Peek().kind == Tokens.EOL)
+					while ((currentToken = lexer.Peek()).Kind != Tokens.EOL) {
+						if (currentToken.Kind == Tokens.Then) {
+							if (lexer.Peek().Kind == Tokens.EOL)
 								return true;
 							else
 								return false;
@@ -618,47 +618,47 @@ namespace VBNetBinding.FormattingStrategy
 					}
 				}
 				
-				if (current.kind == Tokens.Function) {
+				if (current.Kind == Tokens.Function) {
 					lexer.StartPeek();
 					
-					if (lexer.Peek().kind == Tokens.OpenParenthesis)
+					if (lexer.Peek().Kind == Tokens.OpenParenthesis)
 						return false;
 				}
 				
-				if (current.kind == Tokens.With && prev.kind != Tokens.EOL)
+				if (current.Kind == Tokens.With && prev.Kind != Tokens.EOL)
 					return false;
 				
-				if (current.kind == Tokens.While && (prev.kind == Tokens.Skip || prev.kind == Tokens.Take))
+				if (current.Kind == Tokens.While && (prev.Kind == Tokens.Skip || prev.Kind == Tokens.Take))
 					return false;
 				
-				if (current.kind == Tokens.Select && prev.kind != Tokens.EOL)
+				if (current.Kind == Tokens.Select && prev.Kind != Tokens.EOL)
 					return false;
 				
-				if (current.kind == Tokens.Class || current.kind == Tokens.Structure) {
+				if (current.Kind == Tokens.Class || current.Kind == Tokens.Structure) {
 					lexer.StartPeek();
 					
 					Token t = lexer.Peek();
 					
-					if (t.kind == Tokens.CloseParenthesis || t.kind == Tokens.CloseCurlyBrace || t.kind == Tokens.Comma)
+					if (t.Kind == Tokens.CloseParenthesis || t.Kind == Tokens.CloseCurlyBrace || t.Kind == Tokens.Comma)
 						return false;
 				}
 				
-				if (current.kind == Tokens.Module) {
+				if (current.Kind == Tokens.Module) {
 					lexer.StartPeek();
 					
 					Token t = lexer.Peek();
 					
-					if (t.kind == Tokens.Colon)
+					if (t.Kind == Tokens.Colon)
 						return false;
 				}
 				
-				if (prev.kind == Tokens.End ||
-				    prev.kind == Tokens.Loop ||
-				    prev.kind == Tokens.Exit ||
-				    prev.kind == Tokens.Continue ||
-				    prev.kind == Tokens.Resume ||
-				    prev.kind == Tokens.GoTo ||
-				    prev.kind == Tokens.Do)
+				if (prev.Kind == Tokens.End ||
+				    prev.Kind == Tokens.Loop ||
+				    prev.Kind == Tokens.Exit ||
+				    prev.Kind == Tokens.Continue ||
+				    prev.Kind == Tokens.Resume ||
+				    prev.Kind == Tokens.GoTo ||
+				    prev.Kind == Tokens.Do)
 					return false;
 				else
 					return true;
@@ -669,18 +669,18 @@ namespace VBNetBinding.FormattingStrategy
 		
 		bool IsBlockEnd(Token current, Token prev)
 		{
-			if (current.kind == Tokens.Next) {
-				if (prev.kind == Tokens.Resume)
+			if (current.Kind == Tokens.Next) {
+				if (prev.Kind == Tokens.Resume)
 					return false;
 				else
 					return true;
 			}
 			
-			if (current.kind == Tokens.Loop)
+			if (current.Kind == Tokens.Loop)
 				return true;
 			
-			if (blockTokens.Contains(current.kind)) {
-				if (prev.kind == Tokens.End)
+			if (blockTokens.Contains(current.Kind)) {
+				if (prev.Kind == Tokens.End)
 					return true;
 				else
 					return false;
@@ -691,11 +691,11 @@ namespace VBNetBinding.FormattingStrategy
 		
 		bool IsSpecialCase(Token current, Token prev)
 		{
-			switch (current.kind) {
+			switch (current.Kind) {
 				case Tokens.Else:
 					return true;
 				case Tokens.Case:
-					if (prev.kind == Tokens.Select)
+					if (prev.Kind == Tokens.Select)
 						return false;
 					else
 						return true;

src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetCompletionBinding.cs

@@ -110,33 +110,33 @@ namespace VBNetBinding
 		{
 			string lineText = editor.Document.GetText(curLine.Offset, curLine.Length);
 			ILexer lexer = ParserFactory.CreateLexer(SupportedLanguage.VBNet, new System.IO.StringReader(lineText));
-			if (lexer.NextToken().kind != VBTokens.Dim)
+			if (lexer.NextToken().Kind != VBTokens.Dim)
 				return false;
-			if (lexer.NextToken().kind != VBTokens.Identifier)
+			if (lexer.NextToken().Kind != VBTokens.Identifier)
 				return false;
-			if (lexer.NextToken().kind != VBTokens.As)
+			if (lexer.NextToken().Kind != VBTokens.As)
 				return false;
 			Token t1 = lexer.NextToken();
-			if (t1.kind != VBTokens.QuestionMark)
+			if (t1.Kind != VBTokens.QuestionMark)
 				return false;
 			Token t2 = lexer.NextToken();
-			if (t2.kind != VBTokens.Assign)
+			if (t2.Kind != VBTokens.Assign)
 				return false;
-			string expr = lineText.Substring(t2.col);
+			string expr = lineText.Substring(t2.Location.Column);
 			LoggingService.Debug("DeclarationTypeInference: >" + expr + "<");
 			ResolveResult rr = ParserService.Resolve(new ExpressionResult(expr),
 			                                         editor.ActiveTextAreaControl.Caret.Line + 1,
-			                                         t2.col, editor.FileName,
+			                                         t2.Location.Column, editor.FileName,
 			                                         editor.Document.TextContent);
 			if (rr != null && rr.ResolvedType != null) {
-				ClassFinder context = new ClassFinder(ParserService.GetParseInformation(editor.FileName), editor.ActiveTextAreaControl.Caret.Line, t1.col);
+				ClassFinder context = new ClassFinder(ParserService.GetParseInformation(editor.FileName), editor.ActiveTextAreaControl.Caret.Line, t1.Location.Column);
 				VBNetAmbience ambience = new VBNetAmbience();
 				if (CodeGenerator.CanUseShortTypeName(rr.ResolvedType, context))
 					ambience.ConversionFlags = ConversionFlags.None;
 				else
 					ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedTypeNames;
 				string typeName = ambience.Convert(rr.ResolvedType);
-				editor.Document.Replace(curLine.Offset + t1.col - 1, 1, typeName);
+				editor.Document.Replace(curLine.Offset + t1.Location.Column - 1, 1, typeName);
 				editor.ActiveTextAreaControl.Caret.Column += typeName.Length - 1;
 				return true;
 			}

src/Libraries/NRefactory/Project/Src/Lexer/AbstractLexer.cs

@@ -42,7 +42,7 @@ namespace ICSharpCode.NRefactory.Parser
 		
 		public bool SkipAllComments { get; set; }
 		public bool EvaluateConditionalCompilation { get; set; }
-		public virtual IDictionary<string, object> ConditionalCompilationSymbols { 
+		public virtual IDictionary<string, object> ConditionalCompilationSymbols {
 			get { throw new NotSupportedException(); }
 		}
 		
@@ -59,7 +59,12 @@ namespace ICSharpCode.NRefactory.Parser
 		protected int ReaderRead()
 		{
 			++col;
-			return reader.Read();
+			int val = reader.Read();
+			if ((val == '\r' && reader.Peek() != '\n') || val == '\n') {
+				++line;
+				col = 1;
+			}
+			return val;
 		}
 		protected int ReaderPeek()
 		{
@@ -226,35 +231,32 @@ namespace ICSharpCode.NRefactory.Parser
 			return 0;
 		}
 		
-		bool WasLineEnd(char ch)
+		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'
-					ch = (char)reader.Read();
-					++col;
+					ReaderRead();
+					return true;
 				} else { // assume MacOS line end which is '\r'
-					ch = '\n';
+					return true;
 				}
 			}
 			return ch == '\n';
 		}
 		
-		protected bool HandleLineEnd(char ch)
-		{
-			if (WasLineEnd(ch)) {
-				++line;
-				col = 1;
-				return true;
-			}
-			return false;
-		}
-		
 		protected void SkipToEndOfLine()
 		{
 			int nextChar;
 			while ((nextChar = reader.Read()) != -1) {
-				if (HandleLineEnd((char)nextChar)) {
+				if (nextChar == '\r') {
+					if (reader.Peek() == '\n')
+						reader.Read();
+					nextChar = '\n';
+				}
+				if (nextChar == '\n') {
+					++line;
+					col = 1;
 					break;
 				}
 			}
@@ -267,8 +269,15 @@ namespace ICSharpCode.NRefactory.Parser
 			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 (HandleLineEnd(ch)) {
+				if (nextChar == '\n') {
+					++line;
+					col = 1;
 					return sb.ToString();
 				}
 				

src/Libraries/NRefactory/Project/Src/Lexer/CSharp/Lexer.cs

@@ -76,6 +76,7 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 								bool canBeKeyword;
 								token = new Token(Tokens.Identifier, x - 1, y, ReadIdent(ch, out canBeKeyword));
 							} else {
+								HandleLineEnd(ch);
 								errors.Error(y, x, String.Format("Unexpected char in Lexer.Next() : {0}", ch));
 								continue;
 							}
@@ -408,8 +409,8 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 					} else {
 						sb.Append(ch);
 					}
-				} else if (ch == '\n') {
-					HandleLineEnd(ch); // ensure line numbers are still correct after the error
+				} else if (HandleLineEnd(ch)) {
+					// call HandleLineEnd to ensure line numbers are still correct after the error
 					errors.Error(y, x, String.Format("No new line is allowed inside a string literal"));
 					break;
 				} else {
@@ -430,8 +431,7 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 			sb.Length            = 0;
 			originalValue.Length = 0;
 			originalValue.Append("@\"");
-			int x = Col - 2; // @ and " already read
-			int y = Line;
+			Location startLocation = new Location(Col - 2, Line); // @ and " already read
 			int nextChar;
 			while ((nextChar = ReaderRead()) != -1) {
 				char ch = (char)nextChar;
@@ -454,13 +454,13 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 			}
 			
 			if (nextChar == -1) {
-				errors.Error(y, x, String.Format("End of file reached inside verbatim string literal"));
+				errors.Error(startLocation.Line, startLocation.Column, String.Format("End of file reached inside verbatim string literal"));
 			}
 			
-			return new Token(Tokens.Literal, x, y, originalValue.ToString(), sb.ToString(), LiteralFormat.VerbatimStringLiteral);
+			return new Token(Tokens.Literal, startLocation, new Location(Col, Line), originalValue.ToString(), sb.ToString(), LiteralFormat.VerbatimStringLiteral);
 		}
 		
-		char[] escapeSequenceBuffer = new char[12];
+		readonly char[] escapeSequenceBuffer = new char[12];
 		
 		/// <summary>
 		/// reads an escape sequence

src/Libraries/NRefactory/Project/Src/Lexer/Token.cs

@@ -23,21 +23,37 @@ namespace ICSharpCode.NRefactory.Parser
 	
 	public class Token
 	{
-		public int kind;
+		internal readonly int kind;
 		
-		public int col;
-		public int line;
+		internal readonly int col;
+		internal readonly int line;
 		
-		public LiteralFormat literalFormat;
-		public object literalValue;
-		public string val;
+		internal readonly LiteralFormat literalFormat;
+		internal readonly object literalValue;
+		internal readonly string val;
 		internal Token next;
+		readonly Location endLocation;
+		
+		public int Kind {
+			get { return kind; }
+		}
+		
+		public LiteralFormat LiteralFormat {
+			get { return literalFormat; }
+		}
+		
+		public object LiteralValue {
+			get { return literalValue; }
+		}
+		
+		public string Value {
+			get { return val; }
+		}
 		
 		public Location EndLocation {
-			get {
-				return new Location(val == null ? col + 1 : col + val.Length, line);
-			}
+			get { return endLocation; }
 		}
+		
 		public Location Location {
 			get {
 				return new Location(col, line);
@@ -58,13 +74,20 @@ namespace ICSharpCode.NRefactory.Parser
 			this.col          = col;
 			this.line         = line;
 			this.val          = val;
+			this.endLocation  = new Location(col + (string.IsNullOrEmpty(val) ? 1 : val.Length), line);
+		}
+		
+		internal Token(int kind, int x, int y, string val, object literalValue, LiteralFormat literalFormat)
+			: this(kind, new Location(x, y), new Location(x + val.Length, y), val, literalValue, literalFormat)
+		{
 		}
 		
-		public Token(int kind, int col, int line, string val, object literalValue, LiteralFormat literalFormat)
+		public Token(int kind, Location startLocation, Location endLocation, string val, object literalValue, LiteralFormat literalFormat)
 		{
 			this.kind         = kind;
-			this.col          = col;
-			this.line         = line;
+			this.col          = startLocation.Column;
+			this.line         = startLocation.Line;
+			this.endLocation = endLocation;
 			this.val          = val;
 			this.literalValue = literalValue;
 			this.literalFormat = literalFormat;
@@ -72,10 +95,10 @@ namespace ICSharpCode.NRefactory.Parser
 		
 		public override string ToString()
 		{
-			return string.Format("[C# {0}/VB {1} line={2} col={3} val={4}]",
+			return string.Format("[C# {0}/VB {1} Location={3} EndLocation={4} val={5}]",
 			                     CSharp.Tokens.GetTokenString(kind),
 			                     VB.Tokens.GetTokenString(kind),
-			                     line, col, val);
+			                     Location, EndLocation, val);
 			
 		}
 	}

src/Libraries/NRefactory/Project/Src/Lexer/VBNet/Lexer.cs

@@ -57,20 +57,21 @@ namespace ICSharpCode.NRefactory.Parser.VB
 				return new Token(Tokens.ExclamationMark, Col - 1, Line);
 			}
 			unchecked {
-				int nextChar;
-				while ((nextChar = ReaderRead()) != -1) {
+				while (true) {
+					Location startLocation = new Location(Col, Line);
+					int nextChar = ReaderRead();
+					if (nextChar == -1)
+						return new Token(Tokens.EOF);
 					char ch = (char)nextChar;
 					if (Char.IsWhiteSpace(ch)) {
-						int x = Col - 1;
-						int y = Line;
 						if (HandleLineEnd(ch)) {
 							if (lineEnd) {
 								// second line end before getting to a token
 								// -> here was a blank line
-								specialTracker.AddEndOfLine(new Location(x, y));
+								specialTracker.AddEndOfLine(startLocation);
 							} else {
 								lineEnd = true;
-								return new Token(Tokens.EOL, x, y);
+								return new Token(Tokens.EOL, startLocation, new Location(Col, Line), null, null, LiteralFormat.None);
 							}
 						}
 						continue;
@@ -228,8 +229,6 @@ namespace ICSharpCode.NRefactory.Parser.VB
 					}
 					errors.Error(Line, Col, String.Format("Unknown char({0}) which can't be read", ch));
 				}
-				
-				return new Token(Tokens.EOF);
 			}
 		}
 		

src/Libraries/NRefactory/Project/Src/Parser/CSharp/cs.ATG

@@ -1874,7 +1874,7 @@ PrimaryExpr<out Expression pexpr>
 		| "ushort" (. val = "System.UInt16"; .)
 		| "void" (. val = "System.Void"; .)
 		)
-		MemberAccess<out pexpr, new TypeReferenceExpression(new TypeReference(val, true)) { StartLocation = t.Location, EndLocation = t.EndLocation } >
+		(. pexpr = new TypeReferenceExpression(new TypeReference(val, true)) { StartLocation = t.Location, EndLocation = t.EndLocation }; .)
 		
 		/*--- this access: */
 	|	"this"                              (. pexpr = new ThisReferenceExpression(); .)
@@ -1947,7 +1947,6 @@ MemberAccess<out Expression expr, Expression target>
 				target = new TypeReferenceExpression(type) { StartLocation = t.Location, EndLocation = t.EndLocation };
 			}
 		}
-		t.val = ""; // required for TypeReferenceExpressionTests.StandaloneIntReferenceExpression hack
 	.)
 	"."
 	Identifier

src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs

@@ -3897,14 +3897,9 @@ out val);
 #line  1684 "VBNET.ATG" 
 					val = "System.Object"; 
 				} else SynErr(257);
-				Expect(16);
-
-#line  1685 "VBNET.ATG" 
-				t.val = ""; 
-				Identifier();
 
 #line  1685 "VBNET.ATG" 
-				pexpr = new MemberReferenceExpression(new TypeReferenceExpression(new TypeReference(val, true)), t.val); 
+				pexpr = new TypeReferenceExpression(new TypeReference(val, true)); 
 				break;
 			}
 			case 139: {

src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG

@@ -1682,7 +1682,7 @@ SimpleNonInvocationExpression<out Expression pexpr>
 				]
 		|	(. string val = String.Empty; .)
 			( PrimitiveTypeName<out val> | "Object" (. val = "System.Object"; .) )
-			"." (. t.val = ""; .) Identifier (. pexpr = new MemberReferenceExpression(new TypeReferenceExpression(new TypeReference(val, true)), t.val); .)
+			(. pexpr = new TypeReferenceExpression(new TypeReference(val, true)); .)
 		|	"Me"							(. pexpr = new ThisReferenceExpression(); .)
 		|	(. Expression retExpr = null; .)
 			( "MyBase"										(. retExpr = new BaseReferenceExpression(); .)

src/Libraries/NRefactory/Test/Lexer/CSharp/CustomLexerTests.cs

@@ -26,20 +26,20 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.CSharp
 		public void TestEmptyBlock()
 		{
 			ILexer lexer = GenerateLexer(new StringReader("{}+"));
-			Assert.AreEqual(Tokens.OpenCurlyBrace, lexer.NextToken().kind);
-			Assert.AreEqual(Tokens.CloseCurlyBrace, lexer.NextToken().kind);
-			Assert.AreEqual(Tokens.Plus, lexer.NextToken().kind);
-			Assert.AreEqual(Tokens.EOF, lexer.NextToken().kind);
+			Assert.AreEqual(Tokens.OpenCurlyBrace, lexer.NextToken().Kind);
+			Assert.AreEqual(Tokens.CloseCurlyBrace, lexer.NextToken().Kind);
+			Assert.AreEqual(Tokens.Plus, lexer.NextToken().Kind);
+			Assert.AreEqual(Tokens.EOF, lexer.NextToken().Kind);
 		}
 		
 		void CheckIdentifier(string text, string actualIdentifier)
 		{
 			ILexer lexer = GenerateLexer(new StringReader(text));
 			Token t = lexer.NextToken();
-			Assert.AreEqual(Tokens.Identifier, t.kind);
-			Assert.AreEqual(actualIdentifier, t.val);
+			Assert.AreEqual(Tokens.Identifier, t.Kind);
+			Assert.AreEqual(actualIdentifier, t.Value);
 			t = lexer.NextToken();
-			Assert.AreEqual(Tokens.EOF, t.kind);
+			Assert.AreEqual(Tokens.EOF, t.Kind);
 			Assert.AreEqual("", lexer.Errors.ErrorOutput);
 		}
 		
@@ -48,9 +48,9 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.CSharp
 		{
 			ILexer lexer = GenerateLexer(new StringReader("yield"));
 			Token t = lexer.NextToken();
-			Assert.AreEqual(Tokens.Yield, t.kind);
-			Assert.IsTrue(Tokens.IdentifierTokens[t.kind]);
-			Assert.AreEqual("yield", t.val);
+			Assert.AreEqual(Tokens.Yield, t.Kind);
+			Assert.IsTrue(Tokens.IdentifierTokens[t.Kind]);
+			Assert.AreEqual("yield", t.Value);
 		}
 		
 		[Test]
@@ -99,24 +99,24 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.CSharp
 		public void TestSkippedEmptyBlock()
 		{
 			ILexer lexer = GenerateLexer(new StringReader("{}+"));
-			Assert.AreEqual(Tokens.OpenCurlyBrace, lexer.NextToken().kind);
+			Assert.AreEqual(Tokens.OpenCurlyBrace, lexer.NextToken().Kind);
 			lexer.NextToken();
 			lexer.SkipCurrentBlock(Tokens.CloseCurlyBrace);
-			Assert.AreEqual(Tokens.CloseCurlyBrace, lexer.LookAhead.kind);
-			Assert.AreEqual(Tokens.Plus, lexer.NextToken().kind);
-			Assert.AreEqual(Tokens.EOF, lexer.NextToken().kind);
+			Assert.AreEqual(Tokens.CloseCurlyBrace, lexer.LookAhead.Kind);
+			Assert.AreEqual(Tokens.Plus, lexer.NextToken().Kind);
+			Assert.AreEqual(Tokens.EOF, lexer.NextToken().Kind);
 		}
 		
 		[Test]
 		public void TestSkippedNonEmptyBlock()
 		{
 			ILexer lexer = GenerateLexer(new StringReader("{ TestMethod('}'); /* }}} */ while(1) {break;} }+"));
-			Assert.AreEqual(Tokens.OpenCurlyBrace, lexer.NextToken().kind);
+			Assert.AreEqual(Tokens.OpenCurlyBrace, lexer.NextToken().Kind);
 			lexer.NextToken();
 			lexer.SkipCurrentBlock(Tokens.CloseCurlyBrace);
-			Assert.AreEqual(Tokens.CloseCurlyBrace, lexer.LookAhead.kind);
-			Assert.AreEqual(Tokens.Plus, lexer.NextToken().kind);
-			Assert.AreEqual(Tokens.EOF, lexer.NextToken().kind);
+			Assert.AreEqual(Tokens.CloseCurlyBrace, lexer.LookAhead.Kind);
+			Assert.AreEqual(Tokens.Plus, lexer.NextToken().Kind);
+			Assert.AreEqual(Tokens.EOF, lexer.NextToken().Kind);
 		}
 		
 		[Test]
@@ -124,32 +124,32 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.CSharp
 		{
 			ILexer lexer = GenerateLexer(new StringReader("{ TestMethod(\"}\"); // }}}\n" +
 			                                              "while(1) {break;} }+"));
-			Assert.AreEqual(Tokens.OpenCurlyBrace, lexer.NextToken().kind);
+			Assert.AreEqual(Tokens.OpenCurlyBrace, lexer.NextToken().Kind);
 			lexer.NextToken();
 			lexer.StartPeek();
 			lexer.Peek();
 			lexer.Peek();
 			lexer.Peek();
 			lexer.SkipCurrentBlock(Tokens.CloseCurlyBrace);
-			Assert.AreEqual(Tokens.CloseCurlyBrace, lexer.LookAhead.kind);
-			Assert.AreEqual(Tokens.Plus, lexer.NextToken().kind);
-			Assert.AreEqual(Tokens.EOF, lexer.NextToken().kind);
+			Assert.AreEqual(Tokens.CloseCurlyBrace, lexer.LookAhead.Kind);
+			Assert.AreEqual(Tokens.Plus, lexer.NextToken().Kind);
+			Assert.AreEqual(Tokens.EOF, lexer.NextToken().Kind);
 		}
 		
 		[Test]
 		public void TestSkippedEmptyBlockWithPeek()
 		{
 			ILexer lexer = GenerateLexer(new StringReader("{}+"));
-			Assert.AreEqual(Tokens.OpenCurlyBrace, lexer.NextToken().kind);
+			Assert.AreEqual(Tokens.OpenCurlyBrace, lexer.NextToken().Kind);
 			lexer.NextToken();
 			lexer.StartPeek();
 			lexer.Peek();
 			lexer.Peek();
 			lexer.Peek();
 			lexer.SkipCurrentBlock(Tokens.CloseCurlyBrace);
-			Assert.AreEqual(Tokens.CloseCurlyBrace, lexer.LookAhead.kind);
-			Assert.AreEqual(Tokens.Plus, lexer.NextToken().kind);
-			Assert.AreEqual(Tokens.EOF, lexer.NextToken().kind);
+			Assert.AreEqual(Tokens.CloseCurlyBrace, lexer.LookAhead.Kind);
+			Assert.AreEqual(Tokens.Plus, lexer.NextToken().Kind);
+			Assert.AreEqual(Tokens.EOF, lexer.NextToken().Kind);
 		}
 	}
 }

src/Libraries/NRefactory/Test/Lexer/CSharp/LexerPositionTests.cs

@@ -40,12 +40,31 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.CSharp
 		}
 		
 		[Test]
-		public void TestReturn()
+		public void TestNewLine()
 		{
 			ILexer l = GenerateLexer("public\nstatic");
 			Token t = l.NextToken();
+			Assert.AreEqual(Tokens.Public, t.Kind);
+			Assert.AreEqual(new Location(1, 1), t.Location);
+			Assert.AreEqual(new Location(7, 1), t.EndLocation);
 			t = l.NextToken();
+			Assert.AreEqual(Tokens.Static, t.Kind);
 			Assert.AreEqual(new Location(1, 2), t.Location);
+			Assert.AreEqual(new Location(7, 2), t.EndLocation);
+		}
+		
+		[Test]
+		public void TestCarriageReturnNewLine()
+		{
+			ILexer l = GenerateLexer("public\r\nstatic");
+			Token t = l.NextToken();
+			Assert.AreEqual(Tokens.Public, t.Kind);
+			Assert.AreEqual(new Location(1, 1), t.Location);
+			Assert.AreEqual(new Location(7, 1), t.EndLocation);
+			t = l.NextToken();
+			Assert.AreEqual(Tokens.Static, t.Kind);
+			Assert.AreEqual(new Location(1, 2), t.Location);
+			Assert.AreEqual(new Location(7, 2), t.EndLocation);
 		}
 		
 		[Test]
@@ -150,7 +169,7 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.CSharp
 			ILexer l = GenerateLexer("<<=");
 			Token t = l.NextToken();
 			Assert.AreEqual(new Location(1, 1), t.Location);
-			Assert.AreEqual(Tokens.EOF, l.NextToken().kind);
+			Assert.AreEqual(Tokens.EOF, l.NextToken().Kind);
 		}
 		
 		[Test]
@@ -161,9 +180,58 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.CSharp
 			ILexer l = GenerateLexer("'\r\nvoid");
 			Token t = l.NextToken();
 			// the incomplete char literal should not generate a token
-			Assert.AreEqual(Tokens.Void, t.kind);
+			Assert.AreEqual(Tokens.Void, t.Kind);
 			Assert.AreEqual(new Location(1, 2), t.Location);
-			Assert.AreEqual(Tokens.EOF, l.NextToken().kind);
+			Assert.AreEqual(Tokens.EOF, l.NextToken().Kind);
+		}
+		
+		[Test]
+		public void TestPositionMissingEndApostrophe()
+		{
+			// see SD2-1469
+			// the expression finder requires correct positions even when there are syntax errors
+			ILexer l = GenerateLexer("'a\nvoid");
+			Token t = l.NextToken();
+			Assert.AreEqual(Tokens.Literal, t.Kind);
+			Assert.AreEqual(new Location(1, 1), t.Location);
+			t = l.NextToken();
+			Assert.AreEqual(Tokens.Void, t.Kind);
+			Assert.AreEqual(new Location(1, 2), t.Location);
+			Assert.AreEqual(Tokens.EOF, l.NextToken().Kind);
+		}
+		
+		[Test]
+		public void TestPositionLineBreakAfterAt()
+		{
+			// the expression finder requires correct positions even when there are syntax errors
+			ILexer l = GenerateLexer("@\nvoid");
+			Token t = l.NextToken();
+			Assert.AreEqual(Tokens.Void, t.Kind);
+			Assert.AreEqual(new Location(1, 2), t.Location);
+			Assert.AreEqual(Tokens.EOF, l.NextToken().Kind);
+		}
+		
+		[Test]
+		public void TestPositionLineBreakInsideString()
+		{
+			// the expression finder requires correct positions even when there are syntax errors
+			ILexer l = GenerateLexer("\"\nvoid");
+			Token t = l.NextToken();
+			Assert.AreEqual(Tokens.Literal, t.Kind);
+			Assert.AreEqual(new Location(1, 1), t.Location);
+			t = l.NextToken();
+			Assert.AreEqual(Tokens.Void, t.Kind);
+			Assert.AreEqual(new Location(1, 2), t.Location);
+			Assert.AreEqual(Tokens.EOF, l.NextToken().Kind);
+		}
+		
+		[Test]
+		public void MultilineString()
+		{
+			ILexer l = GenerateLexer("@\"\r\n\"");
+			Token t = l.NextToken();
+			Assert.AreEqual(new Location(1, 1), t.Location);
+			Assert.AreEqual(new Location(2, 2), t.EndLocation);
 		}
 	}
 }

src/Libraries/NRefactory/Test/Lexer/CSharp/NumberLexerTest.cs

@@ -26,7 +26,7 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.CSharp
 		{
 			ILexer lexer = GenerateLexer(new StringReader(text));
 			Token t = lexer.NextToken();
-			Assert.AreEqual(Tokens.EOF, lexer.NextToken().kind, "Tokens.EOF");
+			Assert.AreEqual(Tokens.EOF, lexer.NextToken().Kind, "Tokens.EOF");
 			Assert.AreEqual("", lexer.Errors.ErrorOutput);
 			return t;
 		}
@@ -34,11 +34,11 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.CSharp
 		void CheckToken(string text, object val)
 		{
 			Token t = GetSingleToken(text);
-			Assert.AreEqual(Tokens.Literal, t.kind, "Tokens.Literal");
-			Assert.AreEqual(text, t.val, "value");
-			Assert.IsNotNull(t.literalValue, "literalValue is null");
-			Assert.AreEqual(val.GetType(), t.literalValue.GetType(), "literalValue.GetType()");
-			Assert.AreEqual(val, t.literalValue, "literalValue");
+			Assert.AreEqual(Tokens.Literal, t.Kind, "Tokens.Literal");
+			Assert.AreEqual(text, t.Value, "value");
+			Assert.IsNotNull(t.LiteralValue, "literalValue is null");
+			Assert.AreEqual(val.GetType(), t.LiteralValue.GetType(), "literalValue.GetType()");
+			Assert.AreEqual(val, t.LiteralValue, "literalValue");
 		}
 		
 		[Test]
@@ -152,19 +152,19 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.CSharp
 			// ensure that line numbers are correct after newline in string
 			ILexer l = GenerateLexer(new StringReader("\"\n\"\n;"));
 			Token t = l.NextToken();
-			Assert.AreEqual(Tokens.Literal, t.kind);
+			Assert.AreEqual(Tokens.Literal, t.Kind);
 			Assert.AreEqual(new Location(1, 1), t.Location);
 			
 			t = l.NextToken();
-			Assert.AreEqual(Tokens.Literal, t.kind);
+			Assert.AreEqual(Tokens.Literal, t.Kind);
 			Assert.AreEqual(new Location(1, 2), t.Location);
 			
 			t = l.NextToken();
-			Assert.AreEqual(Tokens.Semicolon, t.kind);
+			Assert.AreEqual(Tokens.Semicolon, t.Kind);
 			Assert.AreEqual(new Location(1, 3), t.Location);
 			
 			t = l.NextToken();
-			Assert.AreEqual(Tokens.EOF, t.kind);
+			Assert.AreEqual(Tokens.EOF, t.Kind);
 		}
 		
 		[Test]

src/Libraries/NRefactory/Test/Lexer/CSharp/PreprocessingTests.cs

@@ -33,8 +33,8 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.CSharp
 			ILexer lexer = GenerateLexer(text);
 			Token token;
 			while ((token = lexer.NextToken()) != null) {
-				list.Add(token.kind);
-				if (token.kind == Tokens.EOF)
+				list.Add(token.Kind);
+				if (token.Kind == Tokens.EOF)
 					break;
 			}
 			Assert.AreEqual("", lexer.Errors.ErrorOutput);
@@ -149,7 +149,7 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.CSharp
 	,";
 			Assert.AreEqual(new int[] { Tokens.Semicolon, Tokens.Comma, Tokens.EOF }, GetTokenKinds(program));
 			ILexer lexer = GenerateLexer(program);
-			while (lexer.NextToken().kind != Tokens.EOF);
+			while (lexer.NextToken().Kind != Tokens.EOF);
 			List<ISpecial> specials = lexer.SpecialTracker.RetrieveSpecials();
 			
 			Assert.IsTrue(specials[0] is BlankLine);

src/Libraries/NRefactory/Test/Lexer/VBNet/CustomLexerTests.cs

@@ -25,99 +25,99 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.VB
 		public void TestSingleEOLForMulitpleLines()
 		{
 			ILexer 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));
-			Assert.That(lexer.NextToken().kind, Is.EqualTo(Tokens.EOL));
-			Assert.That(lexer.NextToken().kind, Is.EqualTo(Tokens.EOF));
+			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));
+			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL));
+			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF));
 		}
 		
 		[Test]
 		public void TestSingleEOLForMulitpleLinesWithContinuation()
 		{
 			ILexer 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));
-			Assert.That(lexer.NextToken().kind, Is.EqualTo(Tokens.EOL));
-			Assert.That(lexer.NextToken().kind, Is.EqualTo(Tokens.EOF));
+			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));
+			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL));
+			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF));
 		}
 		
 		[Test]
 		public void EscapedIdentifier()
 		{
 			ILexer 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));
+			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));
 		}
 		
 		[Test]
 		public void IdentifierWithTypeCharacter()
 		{
 			ILexer 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));
+			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));
 		}
 		
 		[Test]
 		public void ExclamationMarkIsTypeCharacter()
 		{
 			ILexer 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));
-			Assert.That(lexer.NextToken().kind, Is.EqualTo(Tokens.EOL));
-			Assert.That(lexer.NextToken().kind, Is.EqualTo(Tokens.EOF));
+			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));
+			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL));
+			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF));
 		}
 		
 		[Test]
 		public void ExclamationMarkIsTypeCharacter2()
 		{
 			ILexer 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));
-			Assert.That(lexer.NextToken().kind, Is.EqualTo(Tokens.EOF));
+			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));
+			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF));
 		}
 		
 		[Test]
 		public void ExclamationMarkIsIdentifier()
 		{
 			ILexer 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));
-			Assert.That(lexer.NextToken().kind, Is.EqualTo(Tokens.EOL));
-			Assert.That(lexer.NextToken().kind, Is.EqualTo(Tokens.EOF));
+			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));
+			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL));
+			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF));
 		}
 		
 		[Test]
 		public void ExclamationMarkIsIdentifier2()
 		{
 			ILexer 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));
-			Assert.That(lexer.NextToken().kind, Is.EqualTo(Tokens.EOL));
-			Assert.That(lexer.NextToken().kind, Is.EqualTo(Tokens.EOF));
+			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));
+			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOL));
+			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF));
 		}
 		
 		[Test]
 		public void RemCommentTest()
 		{
 			ILexer 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));
+			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));
 		}
 		
 		[Test]
 		public void RemCommentTest2()
 		{
 			ILexer lexer = GenerateLexer(new StringReader("REM c"));
-			Assert.That(lexer.NextToken().kind, Is.EqualTo(Tokens.EOF));
+			Assert.That(lexer.NextToken().Kind, Is.EqualTo(Tokens.EOF));
 		}
 	}
 }

src/Libraries/NRefactory/Test/Lexer/VBNet/LexerPositionTests.cs

@@ -5,6 +5,7 @@
 //     <version>$Revision$</version>
 // </file>
 
+using ICSharpCode.NRefactory.Parser.VB;
 using System;
 using System.IO;
 using ICSharpCode.NRefactory.Parser;
@@ -21,79 +22,39 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.VB
 		}
 		
 		[Test]
-		public void Test1()
-		{
-			ILexer l = GenerateLexer("public");
-			Token t = l.NextToken();
-			Assert.AreEqual(new Location(1, 1), t.Location);
-		}
-		[Test]
-		public void Test2()
-		{
-			ILexer l = GenerateLexer("public static");
-			Token t = l.NextToken();
-			t = l.NextToken();
-			Assert.AreEqual(new Location(8, 1), t.Location);
-		}
-		[Test]
-		public void TestReturn()
+		public void TestNewLine()
 		{
 			ILexer l = GenerateLexer("public\nstatic");
 			Token t = l.NextToken();
+			Assert.AreEqual(Tokens.Public, t.Kind);
+			Assert.AreEqual(new Location(1, 1), t.Location);
+			Assert.AreEqual(new Location(7, 1), t.EndLocation);
 			t = l.NextToken();
+			Assert.AreEqual(Tokens.EOL, t.Kind);
+			Assert.AreEqual(new Location(7, 1), t.Location);
+			Assert.AreEqual(new Location(1, 2), t.EndLocation);
 			t = l.NextToken();
+			Assert.AreEqual(Tokens.Static, t.Kind);
 			Assert.AreEqual(new Location(1, 2), t.Location);
+			Assert.AreEqual(new Location(7, 2), t.EndLocation);
 		}
+		
 		[Test]
-		public void TestSpace()
-		{
-			ILexer l = GenerateLexer("  public");
-			Token t = l.NextToken();
-			Assert.AreEqual(new Location(3, 1), t.Location);
-		}
-		[Test]
-		public void TestOctNumber()
-		{
-			ILexer l = GenerateLexer("0142");
-			Token t = l.NextToken();
-			Assert.AreEqual(new Location(1, 1), t.Location);
-		}
-		[Test]
-		public void TestFloationPointNumber()
+		public void TestCarriageReturnNewLine()
 		{
-			ILexer l = GenerateLexer("0.142 public");
+			ILexer l = GenerateLexer("public\r\nstatic");
 			Token t = l.NextToken();
+			Assert.AreEqual(Tokens.Public, t.Kind);
 			Assert.AreEqual(new Location(1, 1), t.Location);
+			Assert.AreEqual(new Location(7, 1), t.EndLocation);
 			t = l.NextToken();
+			Assert.AreEqual(Tokens.EOL, t.Kind);
 			Assert.AreEqual(new Location(7, 1), t.Location);
-		}
-		[Test]
-		public void TestNoFloationPointNumber()
-		{
-			ILexer l = GenerateLexer("5.a");
-			Token t = l.NextToken();
-			Assert.AreEqual(new Location(1, 1), t.Location);
-			t = l.NextToken();
-			Assert.AreEqual(new Location(2, 1), t.Location);
-			t = l.NextToken();
-			Assert.AreEqual(new Location(3, 1), t.Location);
-		}
-		[Test]
-		public void TestNumber()
-		{
-			ILexer l = GenerateLexer("142\nstatic");
-			Token t = l.NextToken();
-			t = l.NextToken();
+			Assert.AreEqual(new Location(1, 2), t.EndLocation);
 			t = l.NextToken();
+			Assert.AreEqual(Tokens.Static, t.Kind);
 			Assert.AreEqual(new Location(1, 2), t.Location);
-		}
-		[Test]
-		public void TestNumber2()
-		{
-			ILexer l = GenerateLexer("14 static");
-			Token t = l.NextToken();
-			t = l.NextToken();
-			Assert.AreEqual(new Location(4, 1), t.Location);
+			Assert.AreEqual(new Location(7, 2), t.EndLocation);
 		}
 	}
 }

src/Libraries/NRefactory/Test/Lexer/VBNet/LiteralsTests.cs

@@ -26,8 +26,8 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.VB
 		{
 			ILexer 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");
+			Assert.AreEqual(Tokens.EOL, lexer.NextToken().Kind, "Tokens.EOL");
+			Assert.AreEqual(Tokens.EOF, lexer.NextToken().Kind, "Tokens.EOF");
 			Assert.AreEqual("", lexer.Errors.ErrorOutput);
 			return t;
 		}
@@ -35,10 +35,10 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.VB
 		void CheckToken(string text, int tokenType, object val)
 		{
 			Token t = GetSingleToken(text);
-			Assert.AreEqual(tokenType, t.kind, "Tokens.Literal");
-			Assert.IsNotNull(t.literalValue, "literalValue is null");
-			Assert.AreEqual(val.GetType(), t.literalValue.GetType(), "literalValue.GetType()");
-			Assert.AreEqual(val, t.literalValue, "literalValue");
+			Assert.AreEqual(tokenType, t.Kind, "Tokens.Literal");
+			Assert.IsNotNull(t.LiteralValue, "literalValue is null");
+			Assert.AreEqual(val.GetType(), t.LiteralValue.GetType(), "literalValue.GetType()");
+			Assert.AreEqual(val, t.LiteralValue, "literalValue");
 		}
 		
 		[Test]
@@ -100,12 +100,12 @@ namespace ICSharpCode.NRefactory.Tests.Lexer.VB
 		{
 			ILexer lexer = GenerateLexer(new StringReader("&H\r\nabc"));
 			Token t = lexer.NextToken();
-			Assert.AreEqual(Tokens.LiteralInteger, t.kind);
-			Assert.AreEqual(0, (int)t.literalValue);
-			Assert.AreEqual(Tokens.EOL, lexer.NextToken().kind, "Tokens.EOL (1)");
-			Assert.AreEqual(Tokens.Identifier, lexer.NextToken().kind, "Tokens.Identifier");
-			Assert.AreEqual(Tokens.EOL, lexer.NextToken().kind, "Tokens.EOL (2)");
-			Assert.AreEqual(Tokens.EOF, lexer.NextToken().kind, "Tokens.EOF");
+			Assert.AreEqual(Tokens.LiteralInteger, t.Kind);
+			Assert.AreEqual(0, (int)t.LiteralValue);
+			Assert.AreEqual(Tokens.EOL, lexer.NextToken().Kind, "Tokens.EOL (1)");
+			Assert.AreEqual(Tokens.Identifier, lexer.NextToken().Kind, "Tokens.Identifier");
+			Assert.AreEqual(Tokens.EOL, lexer.NextToken().Kind, "Tokens.EOL (2)");
+			Assert.AreEqual(Tokens.EOF, lexer.NextToken().Kind, "Tokens.EOF");
 			Assert.AreNotEqual("", lexer.Errors.ErrorOutput);
 		}
 		

src/Libraries/NRefactory/Test/Parser/Expressions/TypeReferenceExpressionTests.cs

@@ -53,12 +53,8 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		[Test]
 		public void StandaloneIntReferenceExpression()
 		{
-			// this is propably not what really should be returned for a standalone int
-			// reference, but it has to stay consistent because NRefactoryResolver depends
-			// on this trick.
-			MemberReferenceExpression fre = ParseUtilCSharp.ParseExpression<MemberReferenceExpression>("int", true);
-			Assert.AreEqual("", fre.MemberName);
-			Assert.AreEqual("System.Int32", ((TypeReferenceExpression)fre.TargetObject).TypeReference.Type);
+			TypeReferenceExpression tre = ParseUtilCSharp.ParseExpression<TypeReferenceExpression>("int");
+			Assert.AreEqual("System.Int32", tre.TypeReference.Type);
 		}
 		#endregion
 		
@@ -74,12 +70,8 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		[Test]
 		public void VBStandaloneIntReferenceExpression()
 		{
-			// this is propably not what really should be returned for a standalone int
-			// reference, but it has to stay consistent because NRefactoryResolver depends
-			// on this trick.
-			MemberReferenceExpression fre = ParseUtilVBNet.ParseExpression<MemberReferenceExpression>("inTeGer", true);
-			Assert.AreEqual("", fre.MemberName);
-			Assert.AreEqual("System.Int32", ((TypeReferenceExpression)fre.TargetObject).TypeReference.Type);
+			TypeReferenceExpression tre = ParseUtilVBNet.ParseExpression<TypeReferenceExpression>("inTeGer");
+			Assert.AreEqual("System.Int32", tre.TypeReference.Type);
 		}
 		
 		[Test]
@@ -93,12 +85,8 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 		[Test]
 		public void VBStandaloneObjectReferenceExpression()
 		{
-			// this is propably not what really should be returned for a standalone int
-			// reference, but it has to stay consistent because NRefactoryResolver depends
-			// on this trick.
-			MemberReferenceExpression fre = ParseUtilVBNet.ParseExpression<MemberReferenceExpression>("obJeCt", true);
-			Assert.AreEqual("", fre.MemberName);
-			Assert.AreEqual("System.Object", ((TypeReferenceExpression)fre.TargetObject).TypeReference.Type);
+			TypeReferenceExpression tre = ParseUtilVBNet.ParseExpression<TypeReferenceExpression>("obJect");
+			Assert.AreEqual("System.Object", tre.TypeReference.Type);
 		}
 		#endregion
 	}

src/Main/Base/Project/Src/TextEditor/Gui/Editor/NRefactoryCodeCompletionBinding.cs

@@ -121,14 +121,14 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 					InspectedCall call = new InspectedCall(Location.Empty, null);
 					call.parent = call;
 					while ((token = lexer.NextToken()) != null
-					       && token.kind != eofToken
+					       && token.Kind != eofToken
 					       && token.Location < cursorLocation)
 					{
-						if (token.kind == commaToken) {
+						if (token.Kind == commaToken) {
 							call.commas.Add(token.Location);
-						} else if (token.kind == openParensToken || token.kind == openBracketToken || token.kind == openBracesToken) {
+						} else if (token.Kind == openParensToken || token.Kind == openBracketToken || token.Kind == openBracesToken) {
 							call = new InspectedCall(token.Location, call);
-						} else if (token.kind == closeParensToken || token.kind == closeBracketToken || token.kind == closeBracesToken) {
+						} else if (token.Kind == closeParensToken || token.Kind == closeBracketToken || token.Kind == closeBracesToken) {
 							call = call.parent;
 						}
 					}

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/CSharp/ExpressionFinder.cs

@@ -382,14 +382,14 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 				lastError = new Location(errorCol, errorLine);
 			};
 			while ((token = lexer.NextToken()) != null) {
-				if (token.kind == Tokens.EOF) break;
+				if (token.Kind == Tokens.EOF) break;
 				
 				if (targetPosition <= token.Location) {
 					break;
 				}
 				ApplyToken(token);
 				if (targetPosition <= token.EndLocation) {
-					if (token.kind == Tokens.Literal) {
+					if (token.Kind == Tokens.Literal) {
 						// do not return string literal as expression if offset was inside the literal,
 						// or if it was at the end of the literal when the literal was not terminated correctly.
 						if (targetPosition < token.EndLocation || lastError == token.Location) {
@@ -398,11 +398,11 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 					}
 					break;
 				}
-				lastToken = token.kind;
+				lastToken = token.Kind;
 			}
 			
 			int tokenOffset;
-			if (token == null || token.kind == Tokens.EOF)
+			if (token == null || token.Kind == Tokens.EOF)
 				tokenOffset = text.Length;
 			else
 				tokenOffset = LocationToOffset(token.Location);
@@ -428,11 +428,11 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 		
 		void TrackCurrentFrameAndExpression(Token token)
 		{
-			while (frame.bracketType == '<' && !Tokens.ValidInsideTypeName[token.kind]) {
+			while (frame.bracketType == '<' && !Tokens.ValidInsideTypeName[token.Kind]) {
 				frame.type = FrameType.Popped;
 				frame = frame.parent;
 			}
-			switch (token.kind) {
+			switch (token.Kind) {
 				case Tokens.OpenCurlyBrace:
 					frame.lastExpressionStart = Location.Empty;
 					frame = new Frame(frame, '{');
@@ -504,14 +504,14 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 					// let the current expression continue
 					break;
 				default:
-					if (Tokens.IdentifierTokens[token.kind]) {
+					if (Tokens.IdentifierTokens[token.Kind]) {
 						if (lastToken != Tokens.Dot && lastToken != Tokens.DoubleColon && lastToken != Tokens.Pointer) {
 							if (Tokens.ValidInsideTypeName[lastToken]) {
 								frame.SetDefaultContext();
 							}
 							frame.lastExpressionStart = token.Location;
 						}
-					} else if (Tokens.SimpleTypeName[token.kind] || Tokens.ExpressionStart[token.kind] || token.kind == Tokens.Literal) {
+					} else if (Tokens.SimpleTypeName[token.Kind] || Tokens.ExpressionStart[token.Kind] || token.Kind == Tokens.Literal) {
 						frame.lastExpressionStart = token.Location;
 					} else {
 						frame.lastExpressionStart = Location.Empty;
@@ -524,15 +524,15 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 		void TrackCurrentContext(Token token)
 		{
 			if (frame.state == FrameState.ObjectCreation) {
-				if (token.kind == Tokens.CloseParenthesis) {
+				if (token.Kind == Tokens.CloseParenthesis) {
 					if (frame.context.IsObjectCreation) {
 						frame.context = ExpressionContext.Default;
 						frame.lastExpressionStart = frame.lastNewTokenStart;
 					}
 					// keep frame.state
-				} else if (token.kind == Tokens.GreaterThan
-				           || token.kind == Tokens.DoubleColon || token.kind == Tokens.Dot
-				           || Tokens.SimpleTypeName[token.kind])
+				} else if (token.Kind == Tokens.GreaterThan
+				           || token.Kind == Tokens.DoubleColon || token.Kind == Tokens.Dot
+				           || Tokens.SimpleTypeName[token.Kind])
 				{
 					// keep frame.state == FrameState.ObjectCreationInType
 				} else {
@@ -540,13 +540,13 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 					frame.ResetCurlyChildType();
 				}
 			} else if (frame.state == FrameState.UsingNamespace) {
-				if (token.kind != Tokens.Identifier && token.kind != Tokens.Dot && token.kind != Tokens.DoubleColon) {
+				if (token.Kind != Tokens.Identifier && token.Kind != Tokens.Dot && token.Kind != Tokens.DoubleColon) {
 					frame.state = FrameState.Normal;
 					frame.SetDefaultContext();
 				}
 			}
 			
-			switch (token.kind) {
+			switch (token.Kind) {
 				case Tokens.Using:
 					if (frame.type == FrameType.Global) {
 						frame.state = FrameState.UsingNamespace;
@@ -727,12 +727,12 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 					frame.parenthesisChildType = FrameType.TypeReference;
 					break;
 				default:
-					if (Tokens.SimpleTypeName[token.kind]) {
+					if (Tokens.SimpleTypeName[token.Kind]) {
 						if (frame.type == FrameType.Interface || frame.type == FrameType.TypeDecl) {
 							if (frame.state == FrameState.Normal) {
 								frame.state = FrameState.FieldDecl;
 								frame.curlyChildType = FrameType.Property;
-							} else if (frame.state == FrameState.FieldDecl && Tokens.IdentifierTokens[token.kind]) {
+							} else if (frame.state == FrameState.FieldDecl && Tokens.IdentifierTokens[token.Kind]) {
 								frame.state = FrameState.FieldDeclAfterIdentifier;
 							}
 							if (frame.state != FrameState.ObjectCreation) {
@@ -801,7 +801,7 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 			
 			Token token;
 			while ((token = lexer.NextToken()) != null) {
-				if (token.kind == Tokens.EOF) break;
+				if (token.Kind == Tokens.EOF) break;
 				
 				if (state == SEARCHING_OFFSET) {
 					if (targetPosition < token.Location) {
@@ -834,15 +834,15 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 						resultStartOffset = lastExpressionStartOffset;
 					if (resultFrame.type == FrameType.Popped ||
 					    lastExpressionStartOffset != resultStartOffset ||
-					    token.kind == Tokens.Dot || token.kind == Tokens.DoubleColon || token.kind == Tokens.Pointer)
+					    token.Kind == Tokens.Dot || token.Kind == Tokens.DoubleColon || token.Kind == Tokens.Pointer)
 					{
 						
 						// now we can change the context based on the next token
-						if (frame == resultFrame && Tokens.IdentifierTokens[token.kind]) {
+						if (frame == resultFrame && Tokens.IdentifierTokens[token.Kind]) {
 							// the expression got aborted because of an identifier. This means the
 							// expression was a type reference
 							resultContext = ExpressionContext.Type;
-						} else if (resultFrame.bracketType == '<' && token.kind == Tokens.GreaterThan) {
+						} else if (resultFrame.bracketType == '<' && token.Kind == Tokens.GreaterThan) {
 							// expression was a type argument
 							resultContext = ExpressionContext.Type;
 							return MakeResult(text, resultStartOffset, resultEndOffset, resultContext);
@@ -856,7 +856,7 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 						}
 					}
 				}
-				lastToken = token.kind;
+				lastToken = token.Kind;
 			}
 			// offset is behind all tokens -> cannot find any expression
 			return new ExpressionResult(null, frame.context);
@@ -875,18 +875,18 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 			int lastValidPos = 0;
 			Token token;
 			while ((token = lexer.NextToken()) != null) {
-				if (token.kind == Tokens.EOF) break;
+				if (token.Kind == Tokens.EOF) break;
 				
 				if (frame.parent == null) {
-					if (token.kind == Tokens.Dot || token.kind == Tokens.DoubleColon || token.kind == Tokens.Pointer
-					    || token.kind == Tokens.OpenParenthesis || token.kind == Tokens.OpenSquareBracket)
+					if (token.Kind == Tokens.Dot || token.Kind == Tokens.DoubleColon || token.Kind == Tokens.Pointer
+					    || token.Kind == Tokens.OpenParenthesis || token.Kind == Tokens.OpenSquareBracket)
 					{
 						lastValidPos = LocationToOffset(token.Location);
 					}
 				}
 				ApplyToken(token);
 				
-				lastToken = token.kind;
+				lastToken = token.Kind;
 			}
 			return expression.Substring(0, lastValidPos);
 		}

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Refactoring/NRefactoryRefactoringProvider.cs

@@ -667,13 +667,13 @@ namespace ICSharpCode.SharpDevelop.Dom.Refactoring
 			int attribStart = csharp ? NR.Parser.CSharp.Tokens.OpenSquareBracket : NR.Parser.VB.Tokens.LessThan;
 			int attribEnd = csharp ? NR.Parser.CSharp.Tokens.CloseSquareBracket : NR.Parser.VB.Tokens.GreaterThan;
 			
-			while (t.kind != eof) {
-				if (t.kind == attribStart)
+			while (t.Kind != eof) {
+				if (t.Kind == attribStart)
 					stack.Push(lastPos);
 				if (t.EndLocation.Y >= type.Region.BeginLine)
 					break;
 				lastPos = t.EndLocation;
-				if (t.kind == attribEnd && stack.Count > 0)
+				if (t.Kind == attribEnd && stack.Count > 0)
 					lastPos = stack.Pop();
 				t = lexer.NextToken();
 			}
@@ -681,7 +681,7 @@ namespace ICSharpCode.SharpDevelop.Dom.Refactoring
 			stack = null;
 			
 			// Skip until end of type
-			while (t.kind != eof) {
+			while (t.Kind != eof) {
 				if (t.EndLocation.Y > type.BodyRegion.EndLine)
 					break;
 				t = lexer.NextToken();