Fixed anonymous types with explicit property names.

Fixed type inference when lambda expression is used as argument to a constructor of a generic class.

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

src/Main/Base/Project/Src/Services/Debugger/DebuggerService.cs

@@ -417,6 +417,9 @@ namespace ICSharpCode.SharpDevelop.Debugging
 			}
 			if (result is MixedResolveResult)
 				return GetText(((MixedResolveResult)result).PrimaryResult, expression, out debuggerCanShowValue);
+			else if (result is DelegateCallResolveResult)
+				return GetText(((DelegateCallResolveResult)result).Target, expression, out debuggerCanShowValue);
+			
 			IAmbience ambience = AmbienceService.GetCurrentAmbience();
 			ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.UseFullyQualifiedMemberNames;
 			if (result is MemberResolveResult) {

src/Main/Base/Test/NRefactoryResolverTests.cs

@@ -2109,6 +2109,22 @@ class TestClass {
 			Assert.AreEqual("System.Int32", lrr.ResolvedType.DotNetName);
 		}
 		
+		[Test]
+		public void LambdaInGenericConstructorTest()
+		{
+			string program = @"using System;
+class TestClass {
+	static void Main() {
+		var t = new SomeClass<string>(i => Console.WriteLine(i));
+	}
+}
+class SomeClass<T> {
+	public SomeClass(Action<T> ac) { }
+}";
+			var lrr = Resolve<LocalResolveResult>(program, "i", 4, 33, ExpressionContext.Default);
+			Assert.AreEqual("System.String", lrr.ResolvedType.DotNetName);
+		}
+		
 		[Test]
 		public void IncompleteLambdaTest()
 		{

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/NRefactoryResolver/ResolveVisitor.cs

@@ -258,7 +258,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 					// call to constructor
 					return ResolveConstructorOverload(resolver.CallingClass, invocationExpression.Arguments);
 				} else if (invocationExpression.TargetObject is BaseReferenceExpression) {
-					return ResolveConstructorOverload(resolver.CallingClass.BaseClass, invocationExpression.Arguments);
+					return ResolveConstructorOverload(resolver.CallingClass.BaseType, invocationExpression.Arguments);
 				}
 			}
 			
@@ -430,7 +430,18 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		{
 			if (rt == null)
 				return null;
-			ResolveResult rr = ResolveConstructorOverload(rt.GetUnderlyingClass(), arguments);
+			
+			List<IMethod> methods = rt.GetMethods().Where(m => m.IsConstructor && !m.IsStatic).ToList();
+			IReturnType[] argumentTypes = arguments.Select<Expression, IReturnType>(ResolveType).ToArray();
+			bool resultIsAcceptable;
+			IMethod result = MemberLookupHelper.FindOverload(methods, argumentTypes, out resultIsAcceptable);
+			
+			if (result == null) {
+				IClass c = rt.GetUnderlyingClass();
+				if (c != null)
+					result = Constructor.CreateDefault(c);
+			}
+			ResolveResult rr = CreateMemberResolveResult(result);
 			if (rr != null)
 				rr.ResolvedType = rt;
 			return rr;
@@ -440,12 +451,8 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		{
 			if (c == null)
 				return null;
-
+			else
-			List<IMethod> methods = c.Methods.Where(m => m.IsConstructor && !m.IsStatic).ToList();
+				return ResolveConstructorOverload(c.DefaultReturnType, arguments);
-			IReturnType[] argumentTypes = arguments.Select<Expression, IReturnType>(ResolveType).ToArray();
-			bool resultIsAcceptable;
-			IMethod result = MemberLookupHelper.FindOverload(methods, argumentTypes, out resultIsAcceptable);
-			return CreateMemberResolveResult(result ?? Constructor.CreateDefault(c));
 		}
 		
 		DefaultClass CreateAnonymousTypeClass(CollectionInitializerExpression initializer)
@@ -454,9 +461,9 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			List<string> fieldNames = new List<string>();
 			
 			foreach (Expression expr in initializer.CreateExpressions) {
-				if (expr is AssignmentExpression) {
+				if (expr is NamedArgumentExpression) {
 					// use right part only
-					fieldTypes.Add( ResolveType(((AssignmentExpression)expr).Right) );
+					fieldTypes.Add( ResolveType(((NamedArgumentExpression)expr).Expression) );
 				} else {
 					fieldTypes.Add( ResolveType(expr) );
 				}
@@ -491,11 +498,9 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		{
 			if (expr is MemberReferenceExpression) {
 				return ((MemberReferenceExpression)expr).MemberName;
-			}
+			} else if (expr is NamedArgumentExpression) {
-			if (expr is AssignmentExpression) {
+				return ((NamedArgumentExpression)expr).Name;
-				expr = ((AssignmentExpression)expr).Left; // use left side if it is an IdentifierExpression
+			} else if (expr is IdentifierExpression) {
-			}
-			if (expr is IdentifierExpression) {
 				return ((IdentifierExpression)expr).Identifier;
 			} else {
 				return "?";