Adjust unit tests to InvocationResolveResult changes.

ICSharpCode.NRefactory.CSharp/.gitignore

@@ -0,0 +1,3 @@
+
+bin/
+obj/

ICSharpCode.NRefactory.CSharp/ICSharpCode.NRefactory.CSharp.csproj

@@ -27,7 +27,7 @@
     <DebugSymbols>true</DebugSymbols>
     <DebugType>Full</DebugType>
     <Optimize>False</Optimize>
-    <CheckForOverflowUnderflow>True</CheckForOverflowUnderflow>
+    <CheckForOverflowUnderflow>False</CheckForOverflowUnderflow>
     <DefineConstants>DEBUG;TRACE;FULL_AST</DefineConstants>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">

ICSharpCode.NRefactory.CSharp/Resolver/OverloadResolution.cs

@@ -764,7 +764,21 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		
 		public CSharpInvocationResolveResult CreateResolveResult(ResolveResult targetResolveResult)
 		{
-			throw new NotImplementedException();
+			IParameterizedMember member = GetBestCandidateWithSubstitutedTypeArguments();
+			if (member == null)
+				throw new InvalidOperationException();
+			
+			return new CSharpInvocationResolveResult(
+				targetResolveResult,
+				member,
+				member.EntityType == EntityType.Constructor ? member.DeclaringType : member.ReturnType.Resolve(context),
+				GetArgumentsWithConversions(),
+				this.BestCandidateErrors,
+				this.IsExtensionMethodInvocation,
+				this.BestCandidateIsExpandedForm,
+				member is ILiftedOperator,
+				isDelegateInvocation: false,
+				argumentToParameterMap: this.GetArgumentToParameterMap());
 		}
 	}
 }

ICSharpCode.NRefactory.Tests/CSharp/Resolver/AttributeTests.cs

@@ -56,7 +56,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		public void AttributeConstructor1()
 		{
 			string program = "using System; [$LoaderOptimization(3)$] class Test { }";
-			var mrr = Resolve<InvocationResolveResult>(program);
+			var mrr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.AreEqual("System.LoaderOptimizationAttribute..ctor", mrr.Member.FullName);
 			Assert.AreEqual("System.Byte", mrr.Member.Parameters[0].Type.Resolve(context).FullName);
 		}
@@ -65,7 +65,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		public void AttributeConstructor2()
 		{
 			string program = "using System; [$LoaderOptimization(LoaderOptimization.NotSpecified)$] class Test { }";
-			var mrr = Resolve<InvocationResolveResult>(program);
+			var mrr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.AreEqual("System.LoaderOptimizationAttribute..ctor", mrr.Member.FullName);
 			Assert.AreEqual("System.LoaderOptimization", mrr.Member.Parameters[0].Type.Resolve(context).FullName);
 		}
@@ -75,7 +75,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			string program = "using System; [$Obsolete$] class Test {}";
 			
-			var result = Resolve<InvocationResolveResult>(program);
+			var result = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.AreEqual("System.ObsoleteAttribute..ctor", result.Member.FullName);
 		}
 		

ICSharpCode.NRefactory.Tests/CSharp/Resolver/BinaryOperatorTests.cs

@@ -534,7 +534,7 @@ class Test {
 	}
 }
 ";
-			var irr = Resolve<InvocationResolveResult>(program);
+			var irr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.IsTrue(irr.IsError); // cannot convert from A to S
 			Assert.AreEqual("A.op_Addition", irr.Member.FullName);
 			Assert.AreEqual("S", irr.Type.ReflectionName);

ICSharpCode.NRefactory.Tests/CSharp/Resolver/ExtensionMethodTests.cs

@@ -51,25 +51,25 @@ namespace XN {
 ";
 			InvocationResolveResult mrr;
 			
-			mrr = Resolve<InvocationResolveResult>(program.Replace("$", "$a.F(1)$"));
+			mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$a.F(1)$"));
 			Assert.AreEqual("XN.XC.F", mrr.Member.FullName);
 			Assert.AreEqual("System.Int32", mrr.Member.Parameters[1].Type.Resolve(context).FullName);
 			
-			mrr = Resolve<InvocationResolveResult>(program.Replace("$", "$a.F(\"text\")$"));
+			mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$a.F(\"text\")$"));
 			Assert.AreEqual("XN.XC.F", mrr.Member.FullName);
 			Assert.AreEqual("System.String", mrr.Member.Parameters[1].Type.Resolve(context).FullName);
 			
-			mrr = Resolve<InvocationResolveResult>(program.Replace("$", "$b.F(1)$"));
+			mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$b.F(1)$"));
 			Assert.AreEqual("B.F", mrr.Member.FullName);
 			
-			mrr = Resolve<InvocationResolveResult>(program.Replace("$", "$b.F(\"text\")$"));
+			mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$b.F(\"text\")$"));
 			Assert.AreEqual("XN.XC.F", mrr.Member.FullName);
 			Assert.AreEqual("System.String", mrr.Member.Parameters[1].Type.Resolve(context).FullName);
 			
-			mrr = Resolve<InvocationResolveResult>(program.Replace("$", "$c.F(1)$"));
+			mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$c.F(1)$"));
 			Assert.AreEqual("C.F", mrr.Member.FullName);
 			
-			mrr = Resolve<InvocationResolveResult>(program.Replace("$", "$c.F(\"text\")$"));
+			mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$c.F(\"text\")$"));
 			Assert.AreEqual("C.F", mrr.Member.FullName);
 		}
 		
@@ -88,16 +88,16 @@ public static class XC {
 	public static IEnumerable<T> Filter<T>(this IEnumerable<T> source, Predicate<T> predicate) { throw new NotImplementedException(); }
 }
 ";
-			InvocationResolveResult mrr;
+			CSharpInvocationResolveResult mrr;
 			
-			mrr = Resolve<InvocationResolveResult>(program.Replace("$", "$\"text\".ToInt32()$"));
+			mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$\"text\".ToInt32()$"));
 			Assert.AreEqual("XC.ToInt32", mrr.Member.FullName);
 			
-			mrr = Resolve<InvocationResolveResult>(program.Replace("$", "$args.Slice(1, 2)$"));
+			mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$args.Slice(1, 2)$"));
 			Assert.AreEqual("XC.Slice", mrr.Member.FullName);
 			Assert.AreEqual("System.String[]", mrr.Type.ReflectionName);
 			
-			mrr = Resolve<InvocationResolveResult>(program.Replace("$", "$args.Filter(delegate { return true; })$"));
+			mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$args.Filter(delegate { return true; })$"));
 			Assert.AreEqual("XC.Filter", mrr.Member.FullName);
 			Assert.AreEqual("System.Collections.Generic.IEnumerable`1[[System.String]]", mrr.Type.ReflectionName);
 		}

ICSharpCode.NRefactory.Tests/CSharp/Resolver/InvocationTests.cs

@@ -41,7 +41,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 	}
 }
 ";
-			InvocationResolveResult result = Resolve<InvocationResolveResult>(program);
+			InvocationResolveResult result = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.AreEqual("A.TargetMethod", result.Member.FullName);
 			Assert.AreEqual("System.Int32", result.Type.ReflectionName);
 		}
@@ -82,7 +82,7 @@ class B : A {
 	}
 }
 ";
-			InvocationResolveResult result = Resolve<InvocationResolveResult>(program);
+			InvocationResolveResult result = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.AreEqual("B.GetRandomNumber", result.Member.FullName);
 		}
 		
@@ -102,7 +102,7 @@ class B : A {
 	}
 }
 ";
-			InvocationResolveResult result = Resolve<InvocationResolveResult>(program);
+			InvocationResolveResult result = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.AreEqual("B.GetRandomNumber", result.Member.FullName);
 		}
 		
@@ -119,7 +119,7 @@ class B : A {
 	}
 }
 ";
-			InvocationResolveResult result = Resolve<InvocationResolveResult>(program);
+			InvocationResolveResult result = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.AreEqual("A.TargetMethod", result.Member.FullName);
 			Assert.AreEqual("System.Int32", result.Type.ReflectionName);
 		}
@@ -217,10 +217,10 @@ class Program {
 	static void T(ref int y) {}
 }";
 			
-			InvocationResolveResult mrr = Resolve<InvocationResolveResult>(program.Replace("T(a)", "$T(a)$"));
+			InvocationResolveResult mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("T(a)", "$T(a)$"));
 			Assert.IsFalse(mrr.Member.Parameters[0].IsRef);
 			
-			mrr = Resolve<InvocationResolveResult>(program.Replace("T(ref a)", "$T(ref a)$"));
+			mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("T(ref a)", "$T(ref a)$"));
 			Assert.IsTrue(mrr.Member.Parameters[0].IsRef);
 		}
 		
@@ -236,7 +236,7 @@ class Program {
 class DerivedClass : BaseClass {
 	public void Test(object a) { }
 }";
-			InvocationResolveResult mrr = Resolve<InvocationResolveResult>(program);
+			InvocationResolveResult mrr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName);
 		}
 		
@@ -251,7 +251,7 @@ class Test {
 		$d.Method(3)$;
 	}
 }";
-			InvocationResolveResult mrr = Resolve<InvocationResolveResult>(program);
+			InvocationResolveResult mrr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.AreEqual("IDerived.Method", mrr.Member.FullName);
 		}
 		
@@ -267,10 +267,10 @@ class Test {
 class DerivedClass : BaseClass {
 	public void Test(string a) { }
 }";
-			InvocationResolveResult mrr = Resolve<InvocationResolveResult>(program);
+			InvocationResolveResult mrr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.AreEqual("BaseClass.Test", mrr.Member.FullName);
 			
-			mrr = Resolve<InvocationResolveResult>(program.Replace("(3)", "(\"3\")"));
+			mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("(3)", "(\"3\")"));
 			Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName);
 		}
 		
@@ -291,7 +291,7 @@ class DerivedClass : MiddleClass {
 	public override void Test(int a) { }
 }";
 			
-			InvocationResolveResult mrr = Resolve<InvocationResolveResult>(program);
+			InvocationResolveResult mrr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.AreEqual("MiddleClass.Test", mrr.Member.FullName);
 		}
 		
@@ -299,7 +299,7 @@ class DerivedClass : MiddleClass {
 		public void SubstituteClassAndMethodTypeParametersAtOnce()
 		{
 			string program = @"class C<X> { static void M<T>(X a, T b) { $C<T>.M(b, a)$; } }";
-			var rr = Resolve<InvocationResolveResult>(program);
+			var rr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.IsFalse(rr.IsError);
 			
 			var m = (SpecializedMethod)rr.Member;
@@ -367,7 +367,7 @@ class A {
 }";
 			// IBase.Method is "hidden" because ILeft.Method is also applicable,
 			// so IRight.Method is unambiguously the chosen overload.
-			var rr = Resolve<InvocationResolveResult>(program);
+			var rr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.IsFalse(rr.IsError);
 			Assert.AreEqual("IRight.Method", rr.Member.FullName);
 		}
@@ -384,7 +384,7 @@ interface IBoth : IRight, ILeft {}
 class A {
  	void Test(IBoth x) { $x.Method(1)$; }
 }";
-			var rr = Resolve<InvocationResolveResult>(program);
+			var rr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.IsFalse(rr.IsError);
 			Assert.AreEqual("IRight.Method", rr.Member.FullName);
 		}
@@ -402,7 +402,7 @@ interface IBoth : ILeft, IRight {}
 class A {
 	void Test(IBoth x) { $x.Method(1)$; }
 }";
-			var rr = Resolve<InvocationResolveResult>(program);
+			var rr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.IsFalse(rr.IsError);
 			Assert.AreEqual("ILeft.Method", rr.Member.FullName);
 		}
@@ -420,7 +420,7 @@ interface IBoth : ILeft, IRight {}
 class A {
 	void Test(IBoth x) { $x.Method(1)$; }
 }";
-			var rr = Resolve<InvocationResolveResult>(program);
+			var rr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.IsFalse(rr.IsError);
 			Assert.AreEqual("ILeft.Method", rr.Member.FullName);
 		}
@@ -438,7 +438,7 @@ interface IBoth : IRight, ILeft {}
 class A {
 	void Test(IBoth x) { $x.Method(1)$; }
 }";
-			var rr = Resolve<InvocationResolveResult>(program);
+			var rr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.IsFalse(rr.IsError);
 			Assert.AreEqual("IBase`1[[System.Int64]]", rr.Member.DeclaringType.ReflectionName);
 		}
@@ -456,7 +456,7 @@ interface IBoth : IRight, ILeft {}
 class A {
 	void Test(IBoth x) { $x.Method(1)$; }
 }";
-			var rr = Resolve<InvocationResolveResult>(program);
+			var rr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.IsFalse(rr.IsError);
 			Assert.AreEqual("IBase`1[[System.Int64]]", rr.Member.DeclaringType.ReflectionName);
 		}
@@ -471,7 +471,7 @@ interface IBoth : ILeft, IRight {}
 class A {
 	void Test(IBoth x) { $x.Method(null)$; }
 }";
-			var rr = Resolve<InvocationResolveResult>(program);
+			var rr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.IsFalse(rr.IsError);
 			Assert.AreEqual("ILeft.Method", rr.Member.FullName);
 		}

ICSharpCode.NRefactory.Tests/CSharp/Resolver/LambdaTests.cs

@@ -369,7 +369,7 @@ class TestClass {
 		$list.ConvertAll(x => (int)x)$;
 	}
 }";
-			var rr = Resolve<InvocationResolveResult>(program);
+			var rr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.IsFalse(rr.IsError);
 			SpecializedMethod m = (SpecializedMethod)rr.Member;
 			Assert.AreEqual("System.Int32", m.TypeArguments[0].ReflectionName);

ICSharpCode.NRefactory.Tests/CSharp/Resolver/LinqTests.cs

@@ -101,7 +101,7 @@ class TestClass {
 	}
 }
 ";
-			var rr = Resolve<InvocationResolveResult>(program);
+			var rr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.AreEqual("System.Linq.Enumerable.Select", rr.Member.FullName);
 			Assert.AreEqual("System.Collections.Generic.IEnumerable", rr.Type.FullName);
 			Assert.AreEqual("System.Int32", ((ParameterizedType)rr.Type).TypeArguments[0].FullName);
@@ -117,7 +117,7 @@ class TestClass { static void M() {
 class XYZ {
 	public int Select<U>(Func<string, U> f) { return 42; }
 }";
-			var rr = Resolve<InvocationResolveResult>(program);
+			var rr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.AreEqual("XYZ.Select", rr.Member.FullName);
 			Assert.AreEqual("System.Int32", rr.Type.FullName);
 		}
@@ -304,12 +304,12 @@ class XYZ
 	public int GroupJoin(IEnumerable<string> f, Func<string, object> key1, Func<string, object> key2, Func<string, int, int> s) { return 0; }
 	public decimal GroupJoin(IEnumerable<string> f, Func<string, object> key1, Func<string, object> key2, Func<string, string, string> s) { return 0; }
 }";
-			var rr = Resolve<InvocationResolveResult>(program);
+			var rr = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.IsFalse(rr.IsError);
 			Assert.AreEqual("GroupJoin", rr.Member.Name);
 			Assert.AreEqual("System.Decimal", rr.Type.FullName);
 			
-			rr = Resolve<InvocationResolveResult>(program.Replace("g.ToUpper()", "g.CompareTo(42)"));
+			rr = Resolve<CSharpInvocationResolveResult>(program.Replace("g.ToUpper()", "g.CompareTo(42)"));
 			Assert.IsFalse(rr.IsError);
 			Assert.AreEqual("GroupJoin", rr.Member.Name);
 			Assert.AreEqual("System.Int32", rr.Type.FullName);

ICSharpCode.NRefactory.Tests/CSharp/Resolver/NameLookupTests.cs

@@ -425,7 +425,7 @@ class TestClass {
 ";
 			TypeResolveResult trr = Resolve<TypeResolveResult>(program.Replace("COL a", "$COL$ a"));
 			Assert.AreEqual("System.Collections.ArrayList", trr.Type.FullName, "COL");
-			ResolveResult rr = Resolve<InvocationResolveResult>(program.Replace("new COL()", "$new COL()$"));
+			ResolveResult rr = Resolve<CSharpInvocationResolveResult>(program.Replace("new COL()", "$new COL()$"));
 			Assert.AreEqual("System.Collections.ArrayList", rr.Type.FullName, "a");
 		}
 		
@@ -560,7 +560,7 @@ class TestClass {
 			trr = Resolve<TypeResolveResult>(program.Replace("$", "$global::XX.XX$"));
 			Assert.AreEqual("XX.XX", trr.Type.FullName);
 			
-			InvocationResolveResult mrr = Resolve<InvocationResolveResult>(program.Replace("$", "$XX.Test()$"));
+			InvocationResolveResult mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$XX.Test()$"));
 			Assert.AreEqual("XX.XX.Test", mrr.Member.FullName);
 		}
 		
@@ -672,7 +672,7 @@ namespace A {
 	class BaseClass {
 		public static string Test() {}
 	}";
-			MemberResolveResult mrr = Resolve<InvocationResolveResult>(program.Replace("$", "$BaseClass.Test()$"));
+			MemberResolveResult mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$BaseClass.Test()$"));
 			Assert.AreEqual("BaseClass.Test", mrr.Member.FullName);
 			
 			mrr = Resolve<MemberResolveResult>(program.Replace("$", "$Test$"));
@@ -682,7 +682,7 @@ namespace A {
 			Assert.AreEqual("DerivedClass.Test", mrr.Member.FullName);
 			
 			// returns BaseClass.Test because DerivedClass.Test is not invocable
-			mrr = Resolve<InvocationResolveResult>(program.Replace("$", "$DerivedClass.Test()$"));
+			mrr = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$DerivedClass.Test()$"));
 			Assert.AreEqual("BaseClass.Test", mrr.Member.FullName);
 		}
 		

ICSharpCode.NRefactory.Tests/CSharp/Resolver/ObjectCreationTests.cs

@@ -36,7 +36,7 @@ class A {
 	}
 }
 ";
-			InvocationResolveResult result = Resolve<InvocationResolveResult>(program);
+			var result = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.AreEqual("System.Collections.Generic.List..ctor", result.Member.FullName);
 			
 			Assert.AreEqual("System.Collections.Generic.List`1[[System.String]]", result.Type.ReflectionName);
@@ -83,16 +83,16 @@ class A {
 	A(double dblVal) {}
 }
 ";
-			InvocationResolveResult result = Resolve<InvocationResolveResult>(program.Replace("$", "$new A()$"));
+			var result = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$new A()$"));
 			Assert.IsFalse(result.Member.IsStatic, "new A() is static");
 			Assert.AreEqual(0, result.Member.Parameters.Count, "new A() parameter count");
 			Assert.AreEqual("A", result.Type.FullName);
 			
-			result = Resolve<InvocationResolveResult>(program.Replace("$", "$new A(10)$"));
+			result = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$new A(10)$"));
 			Assert.AreEqual(1, result.Member.Parameters.Count, "new A(10) parameter count");
 			Assert.AreEqual("intVal", result.Member.Parameters[0].Name, "new A(10) parameter");
 			
-			result = Resolve<InvocationResolveResult>(program.Replace("$", "$new A(11.1)$"));
+			result = Resolve<CSharpInvocationResolveResult>(program.Replace("$", "$new A(11.1)$"));
 			Assert.AreEqual(1, result.Member.Parameters.Count, "new A(11.1) parameter count");
 			Assert.AreEqual("dblVal", result.Member.Parameters[0].Name, "new A(11.1) parameter");
 		}
@@ -106,7 +106,7 @@ class A {
 	}
 }
 ";
-			InvocationResolveResult result = Resolve<InvocationResolveResult>(program);
+			var result = Resolve<CSharpInvocationResolveResult>(program);
 			Assert.AreEqual("A", result.Type.ReflectionName);
 			Assert.AreEqual(0, result.Member.Parameters.Count);
 		}

ICSharpCode.NRefactory.Tests/CSharp/Resolver/ResolveAtLocationTests.cs

@@ -50,7 +50,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		[Test]
 		public void MethodInvocation()
 		{
-			var rr = ResolveAtLocation<InvocationResolveResult>(@"using System;
+			var rr = ResolveAtLocation<CSharpInvocationResolveResult>(@"using System;
 class A { void M() {
 	Console.W$riteLine(1);
 }}");

ICSharpCode.NRefactory.VB/Visitors/CSharpToVBConverterVisitor.cs

@@ -169,7 +169,7 @@ namespace ICSharpCode.NRefactory.VB.Visitors
 		
 		public AstNode VisitBaseReferenceExpression(CSharp.BaseReferenceExpression baseReferenceExpression, object data)
 		{
-			InstanceExpression result = new InstanceExpression(InstanceExpressionType.MyBase, ConvertLocation(baseReferenceExpression.StartLocation));
+			InstanceExpression result = new InstanceExpression(InstanceExpressionType.MyBase, baseReferenceExpression.StartLocation);
 			
 			return EndNode(baseReferenceExpression, result);
 		}
@@ -599,7 +599,7 @@ namespace ICSharpCode.NRefactory.VB.Visitors
 		
 		public AstNode VisitThisReferenceExpression(CSharp.ThisReferenceExpression thisReferenceExpression, object data)
 		{
-			InstanceExpression result = new InstanceExpression(InstanceExpressionType.Me, ConvertLocation(thisReferenceExpression.StartLocation));
+			InstanceExpression result = new InstanceExpression(InstanceExpressionType.Me, thisReferenceExpression.StartLocation);
 			return EndNode(thisReferenceExpression, result);
 		}
 		
@@ -2162,7 +2162,7 @@ namespace ICSharpCode.NRefactory.VB.Visitors
 		
 		public AstNode VisitIdentifier(CSharp.Identifier identifier, object data)
 		{
-			var ident = new Identifier(identifier.Name, ConvertLocation(identifier.StartLocation));
+			var ident = new Identifier(identifier.Name, identifier.StartLocation);
 			
 			return EndNode(identifier, ident);
 		}
@@ -2181,12 +2181,6 @@ namespace ICSharpCode.NRefactory.VB.Visitors
 			}
 		}
 		
-		[Obsolete]
-		TextLocation ConvertLocation(TextLocation location)
-		{
-			return location;
-		}
-		
 		T EndNode<T>(CSharp.AstNode node, T result) where T : VB.AstNode
 		{
 			if (result != null) {

ICSharpCode.NRefactory/ICSharpCode.NRefactory.csproj

@@ -35,7 +35,7 @@
     <DebugType>Full</DebugType>
     <Optimize>False</Optimize>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <CheckForOverflowUnderflow>False</CheckForOverflowUnderflow>
+    <CheckForOverflowUnderflow>True</CheckForOverflowUnderflow>
     <DebugSymbols>true</DebugSymbols>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">