Fixed Lexer bug (both C#/VB): OverflowException was thrown when dot was at end of expression.

Fixed Lexer bug (C#): OverflowException was thrown when integer literal was at end of expression.
Added unit tests for literals.

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@77 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/Libraries/NRefactory/Project/NRefactory.csproj

@@ -4,7 +4,7 @@
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <ProductVersion>8.0.41115</ProductVersion>
     <SchemaVersion>2.0</SchemaVersion>
-    <ProjectGuid>{3A9AE6AA-BC07-4A2F-972C-581E3AE2F195}</ProjectGuid>
+    <ProjectGuid>{3a9ae6aa-bc07-4a2f-972c-581e3ae2f195}</ProjectGuid>
     <RootNamespace>NewProject</RootNamespace>
     <AssemblyName>ICSharpCode.NRefactory</AssemblyName>
     <OutputTarget>Library</OutputTarget>
@@ -18,7 +18,7 @@
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>True</DebugSymbols>
-    <Optimize>True</Optimize>
+    <Optimize>False</Optimize>
     <AllowUnsafeBlocks>False</AllowUnsafeBlocks>
     <CheckForOverflowUnderflow>True</CheckForOverflowUnderflow>
     <DefineConstants>TEST</DefineConstants>

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

@@ -129,6 +129,7 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 		
 		Token ReadDigit(char ch, int x)
 		{
+			unchecked { // prevent exception when Peek() = -1 is cast to char
 				int y = line;
 				++col;
 				sb.Length = 0;
@@ -337,6 +338,7 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 				token.next = nextToken;
 				return token;
 			}
+		}
 		
 		Token ReadString()
 		{
@@ -631,8 +633,7 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 					switch (reader.Peek()) {
 						case '<':
 							reader.Read();
-							if (reader.Peek() != -1) {
-								switch ((char)reader.Peek()) {
+							switch (reader.Peek()) {
 								case '=':
 									reader.Read();
 									col += 2;
@@ -641,7 +642,6 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 									++col;
 									break;
 							}
-							}
 							return new Token(Tokens.ShiftLeft, x, y);
 						case '=':
 							reader.Read();
@@ -686,7 +686,9 @@ namespace ICSharpCode.NRefactory.Parser.CSharp
 				case ',':
 					return new Token(Tokens.Comma, x, y);
 				case '.':
-					if (Char.IsDigit((char)reader.Peek())) {
+					// Prevent OverflowException when Peek returns -1
+					int tmp = reader.Peek();
+					if (tmp > 0 && Char.IsDigit((char)tmp)) {
 						 col -= 2;
 						 return ReadDigit('.', col + 1);
 					}

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

@@ -220,7 +220,7 @@ namespace ICSharpCode.NRefactory.Parser.VB
 						if (s.Length != 1) {
 							errors.Error(line, col, String.Format("Chars can only have Length 1 "));
 						}
-						return new Token(Tokens.LiteralCharacter, x, y, '"' + s  + "\"C", s[0].ToString());
+						return new Token(Tokens.LiteralCharacter, x, y, '"' + s  + "\"C", s[0]);
 					}
 					return new Token(Tokens.LiteralString, x, y, '"' + s + '"', s);
 				}
@@ -325,7 +325,7 @@ namespace ICSharpCode.NRefactory.Parser.VB
 				}
 			}
 			
-			if (reader.Peek() != -1 && "%&SIL".IndexOf(Char.ToUpper((char)reader.Peek())) != -1 || ishex || isokt) {
+			if (reader.Peek() != -1 && ("%&SIL".IndexOf(Char.ToUpper((char)reader.Peek())) != -1 || ishex || isokt)) {
 				ch = (char)reader.Peek();
 				sb.Append(ch); 
 				ch = Char.ToUpper(ch);
@@ -370,9 +370,9 @@ namespace ICSharpCode.NRefactory.Parser.VB
 				}
 			}
 			Token nextToken = null; // if we accedently read a 'dot'
-			if (!isdouble && reader.Peek() != -1 && reader.Peek() == '.') { // read floating point number
+			if (!isdouble && reader.Peek() == '.') { // read floating point number
 				reader.Read();
-				if (Char.IsDigit((char)reader.Peek())) {
+				if (reader.Peek() != -1 && Char.IsDigit((char)reader.Peek())) {
 					isdouble = true; // double is default
 					if (ishex || isokt) {
 						errors.Error(line, col, String.Format("No hexadecimal or oktadecimal floating point values allowed"));
@@ -662,7 +662,9 @@ namespace ICSharpCode.NRefactory.Parser.VB
 				case ',':
 					return new Token(Tokens.Comma, x, y);
 				case '.':
-					if (Char.IsDigit((char)reader.Peek())) {
+					// Prevent OverflowException when Peek returns -1
+					int tmp = reader.Peek();
+					if (tmp > 0 && Char.IsDigit((char)tmp)) {
 						 --col;
 						 return ReadDigit('.', col);
 					}

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

@@ -0,0 +1,78 @@
+using System;
+using System.IO;
+using NUnit.Framework;
+using ICSharpCode.NRefactory.Parser;
+using ICSharpCode.NRefactory.Parser.CSharp;
+using ICSharpCode.NRefactory.PrettyPrinter;
+
+namespace ICSharpCode.NRefactory.Tests.Lexer.CSharp
+{
+	[TestFixture]
+	public sealed class NumberLexerTests
+	{
+		ILexer GenerateLexer(StringReader sr)
+		{
+			return ParserFactory.CreateLexer(SupportedLanguages.CSharp, sr);
+		}
+		
+		Token GetSingleToken(string text)
+		{
+			ILexer lexer = GenerateLexer(new StringReader(text));
+			Token t = lexer.NextToken();
+			Assert.AreEqual(Tokens.EOF, lexer.NextToken().kind, "Tokens.EOF");
+			return t;
+		}
+		
+		void CheckToken(string text, object val)
+		{
+			Token t = GetSingleToken(text);
+			Assert.AreEqual(Tokens.Literal, t.kind, "Tokens.Literal");
+			Assert.IsNotNull(t.literalValue, "literalValue is null");
+			Assert.AreEqual(val, t.literalValue, "literalValue");
+		}
+		
+		[Test]
+		public void TestSingleDigit()
+		{
+			CheckToken("5", 5);
+		}
+		
+		[Test]
+		public void TestZero()
+		{
+			CheckToken("0", 0);
+		}
+		
+		[Test]
+		public void TestInteger()
+		{
+			CheckToken("66", 66);
+		}
+		
+		[Test]
+		public void TestOctalInteger()
+		{
+			CheckToken("077", 077);
+			CheckToken("056", 056);
+		}
+		
+		[Test]
+		public void TestHexadecimalInteger()
+		{
+			CheckToken("0x99F", 0x99F);
+			CheckToken("0xAB1f", 0xAB1f);
+		}
+		
+		[Test]
+		public void TestDouble()
+		{
+			CheckToken("1.0", 1.0);
+		}
+		
+		[Test]
+		public void TestFloat()
+		{
+			CheckToken("1.0f", 1.0f);
+		}
+	}
+}

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

@@ -0,0 +1,86 @@
+using System;
+using System.IO;
+using NUnit.Framework;
+using ICSharpCode.NRefactory.Parser;
+using ICSharpCode.NRefactory.Parser.VB;
+using ICSharpCode.NRefactory.PrettyPrinter;
+
+namespace ICSharpCode.NRefactory.Tests.Lexer.VB
+{
+	[TestFixture]
+	public sealed class LiteralsTests
+	{
+		ILexer GenerateLexer(StringReader sr)
+		{
+			return ParserFactory.CreateLexer(SupportedLanguages.VBNet, sr);
+		}
+		
+		Token GetSingleToken(string text)
+		{
+			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");
+			return t;
+		}
+		
+		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, t.literalValue, "literalValue");
+		}
+		
+		[Test]
+		public void TestSingleDigit()
+		{
+			CheckToken("5", Tokens.LiteralInteger, 5);
+		}
+		
+		[Test]
+		public void TestZero()
+		{
+			CheckToken("0", Tokens.LiteralInteger, 0);
+		}
+		
+		[Test]
+		public void TestInteger()
+		{
+			CheckToken("15", Tokens.LiteralInteger, 15);
+			CheckToken("8581", Tokens.LiteralInteger, 8581);
+		}
+		
+		[Test]
+		public void TestHexadecimalInteger()
+		{
+			CheckToken("&H10", Tokens.LiteralInteger, 0x10);
+			CheckToken("&H10&", Tokens.LiteralInteger, 0x10);
+			CheckToken("&h3ff&", Tokens.LiteralInteger, 0x3ff);
+		}
+		
+		[Test]
+		public void TestStringLiterals()
+		{
+			CheckToken("\"\"", Tokens.LiteralString, "");
+			CheckToken("\"Hello, World!\"", Tokens.LiteralString, "Hello, World!");
+			CheckToken("\"\"\"\"", Tokens.LiteralString, "\"");
+		}
+		
+		[Test]
+		public void TestCharacterLiterals()
+		{
+			CheckToken("\" \"c", Tokens.LiteralCharacter, ' ');
+			CheckToken("\"!\"c", Tokens.LiteralCharacter, '!');
+			CheckToken("\"\"\"\"c", Tokens.LiteralCharacter, '"');
+		}
+		
+		/*
+		 * TODO : Test the following:
+		public const int LiteralDouble        = 6;
+		public const int LiteralSingle        = 7;
+		public const int LiteralDecimal       = 8;
+		public const int LiteralDate          = 9;
+		 */
+	}
+}

src/Libraries/NRefactory/Test/NRefactoryTests.csproj

@@ -1,4 +1,4 @@
-<Project DefaultTargets="Build" xmlns:Conversion="urn:Conversion" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
@@ -8,20 +8,10 @@
     <RootNamespace>ICSharpCode.NRefactory.Tests</RootNamespace>
     <AssemblyName>ICSharpCode.NRefactory.Tests</AssemblyName>
     <OutputTarget>Library</OutputTarget>
-    <ApplicationIcon>
-    </ApplicationIcon>
     <WarningLevel>4</WarningLevel>
-    <NoWarn>
-    </NoWarn>
-    <StartupObject>
-    </StartupObject>
     <NoStdLib>False</NoStdLib>
     <NoConfig>False</NoConfig>
     <RunPostBuildEvent>OnSuccessfulBuild</RunPostBuildEvent>
-    <PreBuildEvent>
-    </PreBuildEvent>
-    <PostBuildEvent>
-    </PostBuildEvent>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>True</DebugSymbols>
@@ -37,220 +27,118 @@
     <Optimize>True</Optimize>
     <AllowUnsafeBlocks>False</AllowUnsafeBlocks>
     <CheckForOverflowUnderflow>False</CheckForOverflowUnderflow>
-    <DefineConstants>
-    </DefineConstants>
     <OutputPath>..\..\..\..\bin\</OutputPath>
     <TreatWarningsAsErrors>True</TreatWarningsAsErrors>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="System">
-    </Reference>
-    <Reference Include="System.Data">
-    </Reference>
-    <Reference Include="System.Drawing">
-    </Reference>
-    <Reference Include="System.Windows.Forms">
-    </Reference>
-    <Reference Include="System.Xml">
-    </Reference>
-    <Reference Include="nunit.framework, Version=2.2.0.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77">
-    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml" />
+    <Reference Include="nunit.framework, Version=2.2.0.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Main.cs">
-    </Compile>
-    <Compile Include="AssemblyInfo.cs">
-    </Compile>
-    <Compile Include="Lexer\CSharp\LexerTest.cs">
-    </Compile>
-    <Compile Include="General\UnitTest.cs">
-    </Compile>
-    <Compile Include="Parser\GlobalScope\AttributeSectionTests.cs">
-    </Compile>
-    <Compile Include="Output\CSharp\CSharpOutputTest.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\PrimitiveExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\ParenthesizedExpressionTest.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\ThisReferenceExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\BaseReferenceExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\IdentifierExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\GlobalScope\NamespaceDeclarationTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\AssignmentExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\BinaryOperatorExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\UnaryOperatorExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\CastExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\FieldReferenceExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\InvocationExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\TypeOfExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\ArrayCreateExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\ObjectCreateExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\GlobalScope\DelegateDeclarationTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\CheckedExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\UncheckedExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\ConditionalExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\PointerReferenceExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\IndexerExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\SizeOfExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\StackAllocExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\GlobalScope\UsingDeclarationTests.cs">
-    </Compile>
-    <Compile Include="Parser\GlobalScope\TypeDeclarationTests.cs">
-    </Compile>
-    <Compile Include="Parser\TypeLevel\ConstructorDeclarationTests.cs">
-    </Compile>
-    <Compile Include="Parser\TypeLevel\EventDeclarationTests.cs">
-    </Compile>
-    <Compile Include="Parser\TypeLevel\FieldDeclarationTests.cs">
-    </Compile>
-    <Compile Include="Parser\TypeLevel\MethodDeclarationTests.cs">
-    </Compile>
-    <Compile Include="Parser\TypeLevel\PropertyDeclarationTests.cs">
-    </Compile>
-    <Compile Include="Parser\TypeLevel\DestructorDeclarationTests.cs">
-    </Compile>
-    <Compile Include="Parser\TypeLevel\IndexerDeclarationTests.cs">
-    </Compile>
-    <Compile Include="Parser\TypeLevel\OperatorDeclarationTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\BlockStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\BreakStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\ContinueStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\EmptyStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\DoLoopStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\ForeachStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\ForStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\GotoStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\IfElseStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\LabelStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\LocalVariableDeclarationTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\LockStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\ReturnStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\StatementExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\SwitchStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\ThrowStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\TryCatchStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\CheckedStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\UncheckedStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\UnsafeStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\FixedStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\GotoCaseStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\UsingStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\ClassReferenceExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\Expressions\TypeOfIsExpressionTests.cs">
-    </Compile>
-    <Compile Include="Parser\ParseUtilCSharp.cs">
-    </Compile>
-    <Compile Include="Parser\ParseUtilVBNet.cs">
-    </Compile>
-    <Compile Include="Parser\GlobalScope\OptionDeclarationTests.cs">
-    </Compile>
-    <Compile Include="Parser\TypeLevel\DeclareDeclarationTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\AddHandlerStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\EndStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\EraseStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\ErrorStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\ForNextStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\OnErrorStatementTest.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\RaiseEventStatementTest.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\ReDimStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\RemoveHandlerStatement.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\ResumeStatement.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\StopStatementTests.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\WithStatementTests.cs">
-    </Compile>
-    <Compile Include="Lexer\VBNet\LexerTests.cs">
-    </Compile>
-    <Compile Include="Output\CodeDOM\CodeDOMPrimitiveExpressionTest.cs">
-    </Compile>
-    <Compile Include="Output\CodeDOM\CodeDOMParenthesizedExpressionTest.cs">
-    </Compile>
-    <Compile Include="Parser\Statements\YieldStatementTests.cs">
-    </Compile>
+    <Compile Include="Main.cs" />
+    <Compile Include="AssemblyInfo.cs" />
+    <Compile Include="Lexer\CSharp\LexerTest.cs" />
+    <Compile Include="General\UnitTest.cs" />
+    <Compile Include="Parser\GlobalScope\AttributeSectionTests.cs" />
+    <Compile Include="Output\CSharp\CSharpOutputTest.cs" />
+    <Compile Include="Parser\Expressions\PrimitiveExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\ParenthesizedExpressionTest.cs" />
+    <Compile Include="Parser\Expressions\ThisReferenceExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\BaseReferenceExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\IdentifierExpressionTests.cs" />
+    <Compile Include="Parser\GlobalScope\NamespaceDeclarationTests.cs" />
+    <Compile Include="Parser\Expressions\AssignmentExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\BinaryOperatorExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\UnaryOperatorExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\CastExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\FieldReferenceExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\InvocationExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\TypeOfExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\ArrayCreateExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\ObjectCreateExpressionTests.cs" />
+    <Compile Include="Parser\GlobalScope\DelegateDeclarationTests.cs" />
+    <Compile Include="Parser\Expressions\CheckedExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\UncheckedExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\ConditionalExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\PointerReferenceExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\IndexerExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\SizeOfExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\StackAllocExpressionTests.cs" />
+    <Compile Include="Parser\GlobalScope\UsingDeclarationTests.cs" />
+    <Compile Include="Parser\GlobalScope\TypeDeclarationTests.cs" />
+    <Compile Include="Parser\TypeLevel\ConstructorDeclarationTests.cs" />
+    <Compile Include="Parser\TypeLevel\EventDeclarationTests.cs" />
+    <Compile Include="Parser\TypeLevel\FieldDeclarationTests.cs" />
+    <Compile Include="Parser\TypeLevel\MethodDeclarationTests.cs" />
+    <Compile Include="Parser\TypeLevel\PropertyDeclarationTests.cs" />
+    <Compile Include="Parser\TypeLevel\DestructorDeclarationTests.cs" />
+    <Compile Include="Parser\TypeLevel\IndexerDeclarationTests.cs" />
+    <Compile Include="Parser\TypeLevel\OperatorDeclarationTests.cs" />
+    <Compile Include="Parser\Statements\BlockStatementTests.cs" />
+    <Compile Include="Parser\Statements\BreakStatementTests.cs" />
+    <Compile Include="Parser\Statements\ContinueStatementTests.cs" />
+    <Compile Include="Parser\Statements\EmptyStatementTests.cs" />
+    <Compile Include="Parser\Statements\DoLoopStatementTests.cs" />
+    <Compile Include="Parser\Statements\ForeachStatementTests.cs" />
+    <Compile Include="Parser\Statements\ForStatementTests.cs" />
+    <Compile Include="Parser\Statements\GotoStatementTests.cs" />
+    <Compile Include="Parser\Statements\IfElseStatementTests.cs" />
+    <Compile Include="Parser\Statements\LabelStatementTests.cs" />
+    <Compile Include="Parser\Statements\LocalVariableDeclarationTests.cs" />
+    <Compile Include="Parser\Statements\LockStatementTests.cs" />
+    <Compile Include="Parser\Statements\ReturnStatementTests.cs" />
+    <Compile Include="Parser\Statements\StatementExpressionTests.cs" />
+    <Compile Include="Parser\Statements\SwitchStatementTests.cs" />
+    <Compile Include="Parser\Statements\ThrowStatementTests.cs" />
+    <Compile Include="Parser\Statements\TryCatchStatementTests.cs" />
+    <Compile Include="Parser\Statements\CheckedStatementTests.cs" />
+    <Compile Include="Parser\Statements\UncheckedStatementTests.cs" />
+    <Compile Include="Parser\Statements\UnsafeStatementTests.cs" />
+    <Compile Include="Parser\Statements\FixedStatementTests.cs" />
+    <Compile Include="Parser\Statements\GotoCaseStatementTests.cs" />
+    <Compile Include="Parser\Statements\UsingStatementTests.cs" />
+    <Compile Include="Parser\Expressions\ClassReferenceExpressionTests.cs" />
+    <Compile Include="Parser\Expressions\TypeOfIsExpressionTests.cs" />
+    <Compile Include="Parser\ParseUtilCSharp.cs" />
+    <Compile Include="Parser\ParseUtilVBNet.cs" />
+    <Compile Include="Parser\GlobalScope\OptionDeclarationTests.cs" />
+    <Compile Include="Parser\TypeLevel\DeclareDeclarationTests.cs" />
+    <Compile Include="Parser\Statements\AddHandlerStatementTests.cs" />
+    <Compile Include="Parser\Statements\EndStatementTests.cs" />
+    <Compile Include="Parser\Statements\EraseStatementTests.cs" />
+    <Compile Include="Parser\Statements\ErrorStatementTests.cs" />
+    <Compile Include="Parser\Statements\ForNextStatementTests.cs" />
+    <Compile Include="Parser\Statements\OnErrorStatementTest.cs" />
+    <Compile Include="Parser\Statements\RaiseEventStatementTest.cs" />
+    <Compile Include="Parser\Statements\ReDimStatementTests.cs" />
+    <Compile Include="Parser\Statements\RemoveHandlerStatement.cs" />
+    <Compile Include="Parser\Statements\ResumeStatement.cs" />
+    <Compile Include="Parser\Statements\StopStatementTests.cs" />
+    <Compile Include="Parser\Statements\WithStatementTests.cs" />
+    <Compile Include="Lexer\VBNet\LexerTests.cs" />
+    <Compile Include="Output\CodeDOM\CodeDOMPrimitiveExpressionTest.cs" />
+    <Compile Include="Output\CodeDOM\CodeDOMParenthesizedExpressionTest.cs" />
+    <Compile Include="Parser\Statements\YieldStatementTests.cs" />
+    <Compile Include="Lexer\CSharp\NumberLexerTest.cs" />
+    <Compile Include="Lexer\VBNet\LiteralsTests.cs" />
   </ItemGroup>
   <ItemGroup>
-    <Folder Include="General\">
-    </Folder>
-    <Folder Include="Lexer\">
-    </Folder>
-    <Folder Include="Lexer\CSharp\">
-    </Folder>
-    <Folder Include="Lexer\VBNet\">
-    </Folder>
-    <Folder Include="Parser\">
-    </Folder>
-    <Folder Include="Output\">
-    </Folder>
-    <Folder Include="Output\CSharp\">
-    </Folder>
-    <Folder Include="Output\CodeDOM\">
-    </Folder>
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\Src\NRefactory.csproj">
+    <Folder Include="General\" />
+    <Folder Include="Lexer\" />
+    <Folder Include="Lexer\CSharp\" />
+    <Folder Include="Lexer\VBNet\" />
+    <Folder Include="Parser\" />
+    <Folder Include="Output\" />
+    <Folder Include="Output\CSharp\" />
+    <Folder Include="Output\CodeDOM\" />
+    <ProjectReference Include="..\Project\NRefactory.csproj">
       <Project>{3a9ae6aa-bc07-4a2f-972c-581e3ae2f195}</Project>
-      <Package>{00000000-0000-0000-0000-000000000000}</Package>
       <Name>ICSharpCode.NRefactory</Name>
     </ProjectReference>
   </ItemGroup>
-  <Import Project="$(MSBuildBinPath)\Microsoft.CSHARP.Targets">
-  </Import>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSHARP.Targets" />
 </Project>

src/Libraries/NRefactory/Test/NRefactoryTests.csproj.user

@@ -1,14 +1,4 @@
-<Project DefaultTargets="Build" xmlns:Conversion="urn:Conversion" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <StartProgram>
-    </StartProgram>
-    <StartArguments>
-    </StartArguments>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <StartProgram>
-    </StartProgram>
-    <StartArguments>
-    </StartArguments>
-  </PropertyGroup>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' " />
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' " />
 </Project>

src/Libraries/NRefactory/Test/Parser/GlobalScope/TypeDeclarationTests.cs

@@ -157,6 +157,22 @@ public abstract class MyClass : MyBase, Interface1, My.Test.Interface2
 			
 			Assert.AreEqual("TestClass", td.Name);
 			Assert.AreEqual(Types.Class, td.Type);
+			Assert.AreEqual(1, td.StartLocation.Y, "start line");
+			Assert.AreEqual(2, td.EndLocation.Y, "end line");
+//			Assert.IsFalse(td.IsPartialType);
+		}
+		
+		[Test]
+		public void VBNetSimpleClassTypeDeclarationWithoutLastNewLineTest()
+		{
+			string program = "Class TestClass\n" +
+			                 "End Class";
+			TypeDeclaration td = (TypeDeclaration)ParseUtilVBNet.ParseGlobal(program, typeof(TypeDeclaration));
+			
+			Assert.AreEqual("TestClass", td.Name);
+			Assert.AreEqual(Types.Class, td.Type);
+			Assert.AreEqual(1, td.StartLocation.Y, "start line");
+			Assert.AreEqual(2, td.EndLocation.Y, "end line");
 //			Assert.IsFalse(td.IsPartialType);
 		}
 		

src/Main/Base/Project/ICSharpCode.SharpDevelop.csproj

@@ -16,7 +16,7 @@
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>True</DebugSymbols>
-    <Optimize>True</Optimize>
+    <Optimize>False</Optimize>
     <CheckForOverflowUnderflow>True</CheckForOverflowUnderflow>
     <OutputPath>..\..\..\..\bin\</OutputPath>
     <TreatWarningsAsErrors>True</TreatWarningsAsErrors>

src/Main/Base/Project/Src/TextEditor/Gui/Editor/InsightWindow/IndexerInsightDataProvider.cs

@@ -55,39 +55,32 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			this.textArea = textArea;
 			initialOffset = textArea.Caret.Offset;
 			
-			// TODO: Change this for the new resolver, or better merge IndexerInsight and MethodInsight.
-			
-			/*
 			IExpressionFinder expressionFinder = ParserService.GetExpressionFinder(fileName);
 			string word = expressionFinder == null ? TextUtilities.GetExpressionBeforeOffset(textArea, textArea.Caret.Offset) : expressionFinder.FindExpression(textArea.Document.TextContent, textArea.Caret.Offset - 1);
-						
-			string methodObject = word;
+			word = word.Trim();
 			
 			// the parser works with 1 based coordinates
 			int caretLineNumber = document.GetLineNumberForOffset(textArea.Caret.Offset) + 1;
-			int caretColumn          = textArea.Caret.Offset - document.GetLineSegment(caretLineNumber - 1).Offset + 1;
-			ResolveResult results = ParserService.Resolve(methodObject,
-			                                              caretLineNumber,
-			                                              caretColumn,
-			                                              fileName,
-			                                              document.TextContent);
-			if (results != null && results.Type != null) {
-				foreach (IClass c in results.Type.ClassInheritanceTree) {
-					foreach (IIndexer indexer in c.Indexer) {
-						methods.Add(indexer);
-					}
+			int caretColumn     = textArea.Caret.Offset - document.GetLineSegment(caretLineNumber).Offset + 1;
+			
+			ResolveResult result = ParserService.Resolve(word, caretLineNumber, caretColumn, fileName, document.TextContent);
+			if (result == null)
+				return;
+			IReturnType type = result.ResolvedType;
+			if (type == null)
+				return;
+			IProjectContent projectContent = ParserService.CurrentProjectContent;
+			if (projectContent == null)
+				return;
+			IClass c = projectContent.GetClass(type.FullyQualifiedName);
+			bool canViewProtected = c.IsTypeInInheritanceTree(result.CallingClass);
+			if (c == null)
+				return;
+			foreach (IIndexer i in c.Indexer) {
+				if (i.IsAccessible(result.CallingClass, canViewProtected)) {
+					methods.Add(i);
 				}
-//				foreach (object o in results.ResolveContents) {
-//					if (o is IClass) {
-//						foreach (IClass c in ((IClass)o).ClassInheritanceTree) {
-//							foreach (IIndexer indexer in c.Indexer) {
-//								methods.Add(indexer);
-//							}
-//						}
-//					}
-//				}
 			}
-			*/
 		}
 		
 		public bool CaretOffsetChanged()

src/Main/Base/Project/Src/TextEditor/Gui/Editor/InsightWindow/MethodInsightDataProvider.cs

@@ -30,9 +30,6 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 		TextArea textArea  = null;
 		List<IMethod>    methods  = new List<IMethod>();
 		
-		int caretLineNumber;
-		int caretColumn;
-		
 		public int InsightDataCount {
 			get {
 				return methods.Count;
@@ -64,8 +61,8 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			word = word.Trim();
 			
 			// the parser works with 1 based coordinates
-			caretLineNumber      = document.GetLineNumberForOffset(textArea.Caret.Offset) + 1;
-			caretColumn          = textArea.Caret.Offset - document.GetLineSegment(caretLineNumber).Offset + 1;
+			int caretLineNumber = document.GetLineNumberForOffset(textArea.Caret.Offset) + 1;
+			int caretColumn     = textArea.Caret.Offset - document.GetLineSegment(caretLineNumber).Offset + 1;
 			
 			bool constructorInsight = false;
 			if (word.ToLower().StartsWith("new ")) {

src/Main/Base/Test/NRefactoryResolverTests.cs

@@ -131,7 +131,6 @@ End Class
 			Assert.AreEqual("System.String", result.ResolvedType.FullyQualifiedName);
 		}
 		
-		
 		// Issue SD-265
 		[Test]
 		public void VBNetStaticMembersonObjectTest()
@@ -141,7 +140,8 @@ End Class
 		Dim a As String
 		
 	End Sub
-End Class";
+End Class
+";
 			ResolveResult result = ResolveVB(program, "a", 4, 24);
 			Assert.IsNotNull(result, "result");
 			ArrayList arr = result.GetCompletionData(lastPC);
@@ -164,7 +164,8 @@ End Class";
 		Dim t As String()
 		
 	End Sub
-End Module";
+End Module
+";
 			ResolveResult result = ResolveVB(program, "t", 4, 24);
 			Assert.IsNotNull(result, "result");
 			Assert.IsTrue(result is LocalResolveResult, "result is LocalResolveResult");
@@ -208,5 +209,33 @@ End Module";
 			}
 			Assert.Fail("private field not visible from inner class");
 		}
+		
+		[Test]
+		public void InheritedInterfaceResolveTest()
+		{
+			string program = @"class A {
+	void Method(IInterface1 a) {
+		
+	}
+}
+interface IInterface1 : IInterface2 {
+	void Method1();
+}
+interface IInterface2 {
+	void Method2();
+}
+";
+			ResolveResult result = Resolve(program, "a", 3, 24);
+			Assert.IsNotNull(result, "result");
+			Assert.IsTrue(result is LocalResolveResult, "result is LocalResolveResult");
+			ArrayList arr = result.GetCompletionData(lastPC);
+			Assert.IsNotNull(arr, "arr");
+			Assert.AreEqual(2, arr.Count, "Number of CC results");
+			foreach (IMethod m in arr) {
+				if (m.Name == "Method2")
+					return;
+			}
+			Assert.Fail("Method2 not found");
+		}
 	}
 }