Add "public ResolveResult Body { get; }" to LambdaResolveResult.

ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpOutputVisitor.cs

@@ -2418,7 +2418,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			} else if (childNode is OptionalNode) {
 				VisitOptionalNode((OptionalNode)childNode, data);
 			} else {
-				throw new InvalidOperationException ("Unknown node type in pattern");
+				WritePrimitiveValue(childNode);
 			}
 		}
 		#endregion

ICSharpCode.NRefactory.CSharp/Resolver/LambdaResolveResult.cs

@@ -73,5 +73,16 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// otherwise returns <see cref="Conversion.None"/>.
 		/// </returns>
 		public abstract Conversion IsValid(IType[] parameterTypes, IType returnType, Conversions conversions);
+		
+		/// <summary>
+		/// Gets the resolve result for the lambda body.
+		/// Returns a resolve result for 'void' for statement lambdas.
+		/// </summary>
+		public abstract ResolveResult Body { get; }
+		
+		public override IEnumerable<ResolveResult> GetChildResults()
+		{
+			return new [] { this.Body };
+		}
 	}
 }

ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs

@@ -1700,10 +1700,21 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				get { return body.Parent; }
 			}
 			
-			internal override AstNode Body {
+			internal override AstNode BodyExpression {
 				get { return body; }
 			}
 			
+			public override ResolveResult Body {
+				get {
+					if (body is Expression) {
+						Analyze();
+						if (returnValues.Count == 1)
+							return returnValues[0];
+					}
+					return visitor.voidResult;
+				}
+			}
+			
 			public ExplicitlyTypedLambda(IList<IParameter> parameters, bool isAnonymousMethod, bool isAsync, CSharpResolver storedContext, ResolveVisitor visitor, AstNode body)
 			{
 				this.parameters = parameters;
@@ -1833,6 +1844,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			readonly List<IParameter> parameters = new List<IParameter>();
 			
 			internal LambdaTypeHypothesis winningHypothesis;
+			internal ResolveResult bodyResult;
 			internal readonly ResolveVisitor parentVisitor;
 			
 			internal override bool IsUndecided {
@@ -1848,7 +1860,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				}
 			}
 			
-			internal override AstNode Body {
+			internal override AstNode BodyExpression {
 				get {
 					if (selectClause != null)
 						return selectClause.Expression;
@@ -1857,11 +1869,16 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				}
 			}
 			
+			public override ResolveResult Body {
+				get { return bodyResult; }
+			}
+			
 			private ImplicitlyTypedLambda(ResolveVisitor parentVisitor)
 			{
 				this.parentVisitor = parentVisitor;
 				this.storedContext = parentVisitor.resolver.Clone();
 				this.parsedFile = parentVisitor.parsedFile;
+				this.bodyResult = parentVisitor.voidResult;
 			}
 			
 			public ImplicitlyTypedLambda(LambdaExpression lambda, ResolveVisitor parentVisitor)
@@ -2043,7 +2060,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					}
 				}
 				
-				visitor.AnalyzeLambda(lambda.Body, lambda.IsAsync, out success, out isValidAsVoidMethod, out inferredReturnType, out returnExpressions, out returnValues);
+				visitor.AnalyzeLambda(lambda.BodyExpression, lambda.IsAsync, out success, out isValidAsVoidMethod, out inferredReturnType, out returnExpressions, out returnValues);
 				visitor.resolver.PopBlock();
 				Log.Unindent();
 				Log.WriteLine("Finished analyzing " + ToString());
@@ -2081,6 +2098,9 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					throw new InvalidOperationException("Trying to merge conflicting hypotheses");
 				
 				lambda.winningHypothesis = this;
+				if (lambda.BodyExpression is Expression && returnValues.Count == 1) {
+					lambda.bodyResult = returnValues[0];
+				}
 				
 				Log.WriteLine("Applying return type {0} to implicitly-typed lambda {1}", returnType, lambda.LambdaExpression);
 				if (lambda.IsAsync)
@@ -2111,7 +2131,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					b.Append(lambda.Parameters[i].Name);
 				}
 				b.Append(") => ");
-				b.Append(lambda.Body.ToString());
+				b.Append(lambda.BodyExpression.ToString());
 				b.Append(']');
 				return b.ToString();
 			}
@@ -2123,7 +2143,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			internal abstract bool IsUndecided { get; }
 			internal abstract AstNode LambdaExpression { get; }
-			internal abstract AstNode Body { get; }
+			internal abstract AstNode BodyExpression { get; }
 			
 			internal abstract void EnforceMerge(ResolveVisitor parentVisitor);
 		}
@@ -2925,6 +2945,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				get { return true; }
 			}
 			
+			public override ResolveResult Body {
+				get { return bodyExpression; }
+			}
+			
 			public override IType GetInferredReturnType(IType[] parameterTypes)
 			{
 				return bodyExpression.Type;

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

@@ -240,6 +240,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				get { return false; }
 			}
 			
+			public override ResolveResult Body {
+				get { throw new NotImplementedException(); }
+			}
+			
 			public override IType GetInferredReturnType(IType[] parameterTypes)
 			{
 				return inferredReturnType;

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

@@ -179,6 +179,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				get { return false; }
 			}
 			
+			public override ResolveResult Body {
+				get { throw new NotImplementedException(); }
+			}
+			
 			public override IType GetInferredReturnType(IType[] parameterTypes)
 			{
 				Assert.AreEqual(expectedParameterTypes, parameterTypes, "Parameters types passed to " + this);

ICSharpCode.NRefactory/PatternMatching/Match.cs

@@ -83,7 +83,7 @@ namespace ICSharpCode.NRefactory.PatternMatching
 			return false;
 		}
 		
-		internal void Add(string groupName, INode node)
+		public void Add(string groupName, INode node)
 		{
 			if (groupName != null && node != null) {
 				results.Add(new KeyValuePair<string, INode>(groupName, node));