Update to NRefactory commit 6837c57.

6837c57 Fix .NET 4.5 configuration.
0831ca2 Fix potential NullReferenceExceptions.
6d0ca7d Improved 'CS0618UsageOfObsoleteMemberIssue'.
cf1d410 Added CS0618UsageOfObsoleteMemberIssue.
15473ce Fixed Issue icsharpcode/NRefactory#372 'False positive in "Convert to |= expression issue"'.
e3d3917 Merge branch 'master' into erik-kallen-failing-test-mcs-16997
ba066e7 Updated mcs.
1d486ca Merge branch 'failing-test-mcs-16997' of github.com:erik-kallen/NRefactory into erik-kallen-failing-test-mcs-16997
bc83643 Merge pull request icsharpcode/NRefactory#369 from erik-kallen/anonymous-type-inherited-methods-bug
afec9f4 Remove implicit conversion from AstType to Expression.
570d0e1 CS0029InvalidConversionIssue: fields and local variables don't have a "return type", just a "type".
d9741f8 Swap actions in "The parameter '{0}' cannot be resolved" issue -- I think fixing an incorrect parameter name is the more common usecase.
d9121c4 Add ConvertSymbol() to TypeSystemAstBuilder and IAmbience.
ae68a95 Merge changes from SharpDevelop repository.
5487b2b Fixed null reference exception.
f1d2068 Fixed completion bug.
7d71b8f Fixed code completion bug.
f4fcc5d Fixed completion unit test.
284cfbf Fixed failing completion test.
6286e7c Also consider property getter/setter invocations in DoNotCallOverridableMethodsInConstructorIssue
4c5a047 added two failing code completion tests
571dd02 Fix CS0126 and CS0127 issues with async methods.
1240a5f Don't show "Field can be make readonly" for mutable structs
2cf57d9 Fixed bug in 'ExtractMethodAction'.
bfc6060 Fixed possible null reference in ConvertAnonymousDelegateToLambdaAction.
be458be Fixed bug in 'ConvertToAutoPropertyIssue'.
3552c47 Removed debug code.
13f8a1d Added indent support for the banner style.
d16dd0e Added indentation support for nextlineshifted 1&2 brace styles.
e867a35 Merge pull request icsharpcode/NRefactory#370 from mono-soc-2013/MateY-IndentEngine
e5db800 Small issue with scope.
e24561e Issue with continuation delta.
e0cfbd4 TestMethodContinuationCase3
fa6d1e1 Added failing method continuation test.
e4f8b23 Fixed formatting bug.
c5e3865 Fixed formatting bug.
7a187f1 Fixed a wrapping bug.
eed2858 Improved lambda parameter recognition.
9913aa2 Fixed bug in SegmentTrackingTokenWriter.
2a07aa9 Added test for the parser null ref exception.
ba1bdc7 Fixed bug invoking inherited methods (eg. ToString()) on anonymous types
578c9ae Fixed some issues in redundant unsafe context issue
67aada4 Failing test for https://bugzilla.xamarin.com/show_bug.cgi?id=16997
0f7b386 Fixed potential null reference exception in the C# parser.
3e88747 Fixed bug in ConvertToStaticTypeIssue
55ee1fd Fixed bug in format method recognition.

src/AddIns/Analysis/CodeQuality/Engine/AssemblyAnalyzer.cs

@@ -404,7 +404,7 @@ namespace ICSharpCode.CodeQuality.Engine
 					return Resolve(reference);
 				} catch (AssemblyResolutionException are) {
 					LoggingService.DebugFormatted("CQA: Skipping assembly reference: {0}\r\nException:\r\n{1}", reference, are);
-					TaskService.Add(new SDTask(null, are.Message, 0, 0, TaskType.Warning));
+					TaskService.Add(new SDTask(null, are.Message, 0, 0, SharpDevelop.TaskType.Warning));
 					return null;
 				}
 			}

src/AddIns/Analysis/CodeQuality/Utils/Extensions.cs

@@ -81,7 +81,7 @@ namespace ICSharpCode.CodeQuality
 		
 		public static string PrintFullName(this IEntity entity)
 		{
-			return amb.ConvertEntity(entity);
+			return amb.ConvertSymbol(entity);
 		}
 	}
 }

src/AddIns/Analysis/Profiler/Frontend/AddIn/Src/Commands/DomMenuCommand.cs

@@ -54,7 +54,7 @@ namespace ICSharpCode.Profiler.AddIn.Commands
 				matchWithSameParameterCount = method;
 				bool isCorrect = true;
 				for (int i = 0; i < method.Parameters.Count; i++) {
-					if (parameters[i] != ambience.ConvertVariable(method.Parameters[i])) {
+					if (parameters[i] != ambience.ConvertSymbol(method.Parameters[i])) {
 						isCorrect = false;
 						break;
 					}

src/AddIns/BackendBindings/CSharpBinding/Project/CSharpBinding.addin

@@ -204,6 +204,7 @@
 		<Class class = "ICSharpCode.NRefactory.CSharp.Refactoring.CS0127ReturnMustNotBeFollowedByAnyExpression" />
 		<Class class = "ICSharpCode.NRefactory.CSharp.Refactoring.CS0152DuplicateCaseLabelValueIssue" />
 		<Class class = "ICSharpCode.NRefactory.CSharp.Refactoring.CS0183ExpressionIsAlwaysOfProvidedTypeIssue" />
+		<Class class = "ICSharpCode.NRefactory.CSharp.Refactoring.CS0618UsageOfObsoleteMemberIssue" />
 		<Class class = "ICSharpCode.NRefactory.CSharp.Refactoring.CS0659ClassOverrideEqualsWithoutGetHashCode" />
 		<Class class = "ICSharpCode.NRefactory.CSharp.Refactoring.CS0759RedundantPartialMethodIssue" />
 		<Class class = "ICSharpCode.NRefactory.CSharp.Refactoring.CS1573ParameterHasNoMatchingParamTagIssue" />

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Completion/CSharpInsightItem.cs

@@ -56,7 +56,7 @@ namespace CSharpBinding.Completion
 			ambience.ConversionFlags = ConversionFlags.StandardConversionFlags;
 			var stringBuilder = new StringBuilder();
 			var formatter = new ParameterHighlightingOutputFormatter(stringBuilder, highlightedParameterIndex);
-			ambience.ConvertEntity(Method, formatter, FormattingOptionsFactory.CreateSharpDevelop());
+			ambience.ConvertSymbol(Method, formatter, FormattingOptionsFactory.CreateSharpDevelop());
 			
 			var documentation = XmlDocumentationElement.Get(Method);
 			ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList;

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Completion/OverrideCompletionData.cs

@@ -34,7 +34,7 @@ namespace CSharpBinding.Completion
 			this.contextAtCaret = contextAtCaret;
 			var ambience = new CSharpAmbience();
 			ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList | ConversionFlags.ShowParameterList | ConversionFlags.ShowParameterNames;
-			this.CompletionText = ambience.ConvertEntity(m);
+			this.CompletionText = ambience.ConvertSymbol(m);
 		}
 		
 		public override void Complete(CompletionContext context)

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Refactoring/FieldWrapper.cs

@@ -36,7 +36,7 @@ namespace CSharpBinding.Refactoring
 				ConversionFlags.ShowReturnType
 				| ConversionFlags.ShowModifiers
 				| ConversionFlags.ShowAccessibility;
-			this.text = ambience.ConvertEntity(member);
+			this.text = ambience.ConvertSymbol(member);
 		}
 		
 		public bool IsIncluded

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Refactoring/PropertyOrFieldWrapper.cs

@@ -35,7 +35,7 @@ namespace CSharpBinding.Refactoring
 				ConversionFlags.ShowReturnType
 				| ConversionFlags.ShowModifiers
 				| ConversionFlags.ShowAccessibility;
-			this.text = ambience.ConvertEntity(member);
+			this.text = ambience.ConvertSymbol(member);
 		}
 		
 		public bool IsIncluded

src/AddIns/BackendBindings/XamlBinding/XamlBinding/XamlCompletionItem.cs

@@ -200,7 +200,7 @@ namespace ICSharpCode.XamlBinding
 				if (headerText == null) {
 					IAmbience ambience = AmbienceService.GetCurrentAmbience();
 					ambience.ConversionFlags = ConversionFlags.StandardConversionFlags;
-					headerText = ambience.ConvertEntity(ctor);
+					headerText = ambience.ConvertSymbol(ctor);
 					headerText = headerText.Insert(headerText.LastIndexOf(')'), (ctor.Parameters.Count > 0 ? ", " : "") + "Named Parameters ...");
 				}
 				return headerText;

src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/ContextActions/GoToEntityAction.cs

@@ -20,7 +20,7 @@ namespace ICSharpCode.AvalonEdit.AddIn.ContextActions
 			var ambience = AmbienceService.GetCurrentAmbience();
 			ambience.ConversionFlags = ConversionFlags.ShowDeclaringType | ConversionFlags.ShowTypeParameterList;
 			return new ContextActionViewModel {
-				Action = new GoToEntityAction(entity, ambience.ConvertEntity(entity)),
+				Action = new GoToEntityAction(entity, ambience.ConvertSymbol(entity)),
 				Image = CompletionImage.GetImage(entity),
 				Comment = string.Format("(in {0})", entity.Namespace),
 				ChildActions = childActions

src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/QuickClassBrowser.cs

@@ -42,7 +42,7 @@ namespace ICSharpCode.AvalonEdit.AddIn
 				if (resolvedDefinition != null) {
 					var ambience = compilation.GetAmbience();
 					ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList | ConversionFlags.ShowDeclaringType;
-					this.text = ambience.ConvertEntity(resolvedDefinition);
+					this.text = ambience.ConvertSymbol(resolvedDefinition);
 				} else {
 					this.text = typeDef.Name;
 				}
@@ -54,7 +54,7 @@ namespace ICSharpCode.AvalonEdit.AddIn
 				this.IsInSamePart = true;
 				this.entity = member.UnresolvedMember;
 				ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList | ConversionFlags.ShowParameterList | ConversionFlags.ShowParameterNames;
-				text = ambience.ConvertEntity(member);
+				text = ambience.ConvertSymbol(member);
 				image = CompletionImage.GetImage(member);
 			}
 			

src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/XmlDoc/XmlDocTooltipProvider.cs

@@ -32,7 +32,7 @@ namespace ICSharpCode.AvalonEdit.AddIn.XmlDoc
 				e.SetToolTip(CreateTooltip(mrr.Member));
 			} else if (lrr != null) {
 				var ambience = AmbienceService.GetCurrentAmbience();
-				e.SetToolTip(ambience.ConvertVariable(lrr.Variable));
+				e.SetToolTip(ambience.ConvertSymbol(lrr.Variable));
 			}
 		}
 		

src/AddIns/DisplayBindings/WpfDesign/WpfDesign.AddIn/Src/WpfViewContent.cs

@@ -159,7 +159,7 @@ namespace ICSharpCode.WpfDesign.AddIn
 			tasks.Clear();
 			
 			foreach (XamlError error in xamlErrorService.Errors) {
-				var task = new SDTask(PrimaryFile.FileName, error.Message, error.Column - 1, error.Line, TaskType.Error);
+				var task = new SDTask(PrimaryFile.FileName, error.Message, error.Column - 1, error.Line, SharpDevelop.TaskType.Error);
 				tasks.Add(task);
 				TaskService.Add(task);
 			}

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeActions/ConvertAnonymousDelegateToLambdaAction.cs

@@ -42,6 +42,8 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			Expression convertExpression = null;
 
 			var stmt = node.Body.Statements.FirstOrDefault();
+			if (stmt == null)
+				return null;
 			if (stmt.GetNextSibling(s => s.Role == BlockStatement.StatementRole) == null) {
 				var exprStmt = stmt as ExpressionStatement;
 				if (exprStmt != null) {

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeActions/ConvertEqualityOperatorToEqualsAction.cs

@@ -76,10 +76,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 		{
 			var rr = context.Resolver.GetResolverStateBefore(bOp).LookupSimpleNameOrTypeName("Equals", emptyTypes, NameLookupMode.Expression) as MethodGroupResolveResult;
 			if (rr == null || rr.IsError || HasDifferentEqualsMethod (rr.Methods)) {
-				return new MemberReferenceExpression(
-					new PrimitiveType ("object"),
-					"Equals"
-				);
+				return new PrimitiveType ("object").Member("Equals");
 			}
 			return new IdentifierExpression("Equals");
 		}

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeActions/CreateChangedEventAction.cs

@@ -56,7 +56,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				var methodDeclaration = CreateEventInvocatorAction.CreateEventInvocator (context, type, eventDeclaration, eventDeclaration.Variables.First (), resolvedType.GetDelegateInvokeMethod (), false);
 				var stmt = new ExpressionStatement (new InvocationExpression (
 					new IdentifierExpression (methodDeclaration.Name),
-					new MemberReferenceExpression (context.CreateShortType("System", "EventArgs"), "Empty")
+					context.CreateShortType("System", "EventArgs").Member("Empty")
 				));
 				script.InsertWithCursor(
 					context.TranslateString("Create event invocator"),

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeActions/ExtractMethod/ExtractMethodAction.cs

@@ -32,6 +32,7 @@ using ICSharpCode.NRefactory.CSharp.Analysis;
 using System.Threading;
 using ICSharpCode.NRefactory.TypeSystem;
 using System.Threading.Tasks;
+using Mono.CSharp;
 
 namespace ICSharpCode.NRefactory.CSharp.Refactoring.ExtractMethod
 {
@@ -56,6 +57,8 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring.ExtractMethod
 			foreach (var node in selected) {
 				if (!(node is Statement) && !(node is Comment) && !(node is NewLineNode) && !(node is PreProcessorDirective))
 					yield break;
+				if (node.DescendantNodesAndSelf().Any(n => n is YieldBreakStatement || n is YieldReturnStatement))
+					yield break;
 			}
 			var action = CreateFromStatements (context, new List<AstNode> (selected));
 			if (action != null)

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeActions/GenerateSwitchLabelsAction.cs

@@ -56,7 +56,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 							continue;
 						newSwitch.SwitchSections.Add(new SwitchSection() {
 							CaseLabels = {
-								new CaseLabel(new MemberReferenceExpression(target.Clone(), field.Name))
+								new CaseLabel(target.Clone().Member(field.Name))
 							},
 							Statements = {
 								new BreakStatement()
@@ -95,7 +95,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 					foreach (var field in missingFields) {
 						script.InsertAfter(insertNode, new SwitchSection() {
 							CaseLabels =  {
-								new CaseLabel(new MemberReferenceExpression(target.Clone(), field.Name))
+								new CaseLabel(target.Clone().Member(field.Name))
 							},
 							Statements =  {
 								new BreakStatement()

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeActions/IntroduceFormatItemAction.cs

@@ -39,7 +39,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 	[ContextAction("Introduce format item", Description = "Creates a string.format call with the selection as parameter.")]
 	public class IntroduceFormatItemAction : CodeActionProvider
 	{
-		readonly static MemberReferenceExpression PrototypeFormatReference = new MemberReferenceExpression (new PrimitiveType ("string"), "Format");
+		readonly static MemberReferenceExpression PrototypeFormatReference = new PrimitiveType ("string").Member("Format");
 		
 		public override IEnumerable<CodeAction> GetActions(RefactoringContext context)
 		{

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeActions/ReplaceEmptyStringAction.cs

@@ -39,7 +39,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				yield break;
 			}
 			yield return new CodeAction(context.TranslateString("Use string.Empty"), script => {
-				script.Replace(expr, new MemberReferenceExpression (new PrimitiveType ("string"), "Empty"));
+				script.Replace(expr, new PrimitiveType ("string").Member("Empty"));
 			}, expr);
 		}
 		

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeActions/UseStringFormatAction.cs

@@ -54,8 +54,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			yield return new CodeAction(context.TranslateString("Use 'string.Format()'"),
 			                             script => {
 				var stringType = new PrimitiveType("string");
-				var formatInvocation = new InvocationExpression(
-					new MemberReferenceExpression(stringType, "Format"));
+				var formatInvocation = stringType.Invoke("Format");
 				var formatLiteral = new PrimitiveExpression("");
 				var counter = 0;
 				var arguments = new List<Expression>();

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Custom/CompilerErrors/CS0029InvalidConversionIssue.cs

@@ -149,7 +149,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 					var fd = expression.Parent.Parent as FieldDeclaration;
 					if (fd != null) {
 						fixes.Add(new CodeAction(
-							ctx.TranslateString("Change field return type"), 
+							ctx.TranslateString("Change field type"), 
 							script => {
 								script.Replace(fd.ReturnType, ctx.CreateTypeSystemAstBuilder(fd).ConvertType(rr.Type));
 							}, 
@@ -160,7 +160,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 					var lc =  expression.Parent.Parent as VariableDeclarationStatement;
 					if (lc != null) {
 						fixes.Add(new CodeAction(
-							ctx.TranslateString("Fix local return type"), 
+							ctx.TranslateString("Change local variable type"), 
 							script => {
 								script.Replace(lc.Type, new SimpleType("var"));
 							}, 

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Custom/CompilerErrors/CS0126ReturnMustBeFollowedByAnyExpression.cs

@@ -48,21 +48,29 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 		{
 			entityNode = returnStatement.GetParent(p => p is LambdaExpression || p is AnonymousMethodExpression || !(p is Accessor) && p is EntityDeclaration);
 			if (entityNode == null)
-				return null;
+				return SpecialType.UnknownType;
 			if (entityNode is EntityDeclaration) {
 				var rr = ctx.Resolve(entityNode) as MemberResolveResult;
 				if (rr == null)
-					return null;
+					return SpecialType.UnknownType;
+				if (((EntityDeclaration)entityNode).HasModifier(Modifiers.Async))
+					return TaskType.UnpackTask(ctx.Compilation, rr.Member.ReturnType);
 				return rr.Member.ReturnType;
 			}
+			bool isAsync = false;
+			if (entityNode is LambdaExpression)
+				isAsync = ((LambdaExpression)entityNode).IsAsync;
+			if (entityNode is AnonymousMethodExpression)
+				isAsync = ((AnonymousMethodExpression)entityNode).IsAsync;
 			foreach (var type in TypeGuessing.GetValidTypes(ctx.Resolver, entityNode)) {
 				if (type.Kind != TypeKind.Delegate)
 					continue;
 				var invoke = type.GetDelegateInvokeMethod();
-				if (invoke != null && !invoke.ReturnType.IsKnownType(KnownTypeCode.Void))
-					return invoke.ReturnType;
+				if (invoke != null) {
+					return isAsync ? TaskType.UnpackTask(ctx.Compilation, invoke.ReturnType) : invoke.ReturnType;
+				}
 			}
-			return null;
+			return SpecialType.UnknownType;
 		}
 
 
@@ -149,8 +157,10 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 						return;
 					AstNode entityNode;
 					var rr = GetRequestedReturnType (ctx, returnStatement, out entityNode);
+					if (rr.Kind == TypeKind.Void)
+						return;
 					var actions = new List<CodeAction>();
-					if (rr != null) {
+					if (rr.Kind != TypeKind.Unknown) {
 						actions.Add(new CodeAction(ctx.TranslateString("Return default value"), script => {
 							Expression p;
 							if (rr.IsKnownType(KnownTypeCode.Boolean)) {

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Custom/CompilerErrors/CS0127ReturnMustNotBeFollowedByAnyExpression.cs

@@ -45,71 +45,15 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 
 		class GatherVisitor : GatherVisitorBase<CS0127ReturnMustNotBeFollowedByAnyExpression>
 		{
-			bool skip;
-
 			public GatherVisitor (BaseRefactoringContext ctx) : base (ctx)
 			{
 			}
 
-			static bool AnonymousMethodMayReturnNonVoid(BaseRefactoringContext ctx, Expression anonymousMethodExpression)
-			{
-				foreach (var type in TypeGuessing.GetValidTypes(ctx.Resolver, anonymousMethodExpression)) {
-					if (type.Kind != TypeKind.Delegate)
-						continue;
-					var invoke = type.GetDelegateInvokeMethod();
-					if (invoke != null && !invoke.ReturnType.IsKnownType(KnownTypeCode.Void))
-						return true;
-				}
-				return false;
-			}
-
-			public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
-			{
-				var primitiveType = methodDeclaration.ReturnType as PrimitiveType;
-				if (primitiveType == null || primitiveType.Keyword != "void")
-					return;
-				base.VisitMethodDeclaration(methodDeclaration);
-			}
-
-			public override void VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration)
-			{
-			}
-
-			public override void VisitAccessor(Accessor accessor)
-			{
-				if (accessor.Role == PropertyDeclaration.SetterRole || 
-				    accessor.Role == IndexerDeclaration.SetterRole )
-				base.VisitAccessor(accessor);
-			}
-	
-				
-			public override void VisitCustomEventDeclaration(CustomEventDeclaration eventDeclaration)
-			{
-			}
-
-			public override void VisitAnonymousMethodExpression(AnonymousMethodExpression anonymousMethodExpression)
-			{
-				bool old = skip;
-				skip = AnonymousMethodMayReturnNonVoid(ctx, anonymousMethodExpression);
-				base.VisitAnonymousMethodExpression(anonymousMethodExpression);
-				skip = old;
-			}
-
-			public override void VisitLambdaExpression(LambdaExpression lambdaExpression)
-			{
-				bool old = skip;
-				skip = AnonymousMethodMayReturnNonVoid(ctx, lambdaExpression);
-				base.VisitLambdaExpression(lambdaExpression);
-				skip = old;
-			}
-
 			public override void VisitReturnStatement(ReturnStatement returnStatement)
 			{
 				base.VisitReturnStatement(returnStatement);
-				if (skip)
-					return;
 
-				if (!returnStatement.Expression.IsNull) {
+				if (ctx.GetExpectedType(returnStatement.Expression).Kind == TypeKind.Void) {
 					var actions = new List<CodeAction>();
 					actions.Add(new CodeAction(ctx.TranslateString("Remove returned expression"), script => {
 						script.Replace(returnStatement, new ReturnStatement());

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Custom/CompilerErrors/CS0618UsageOfObsoleteMemberIssue.cs

@@ -0,0 +1,110 @@
+//
+// CS0618UsageOfObsoleteMemberIssue.cs
+//
+// Author:
+//       Mike Krüger <mkrueger@xamarin.com>
+//
+// Copyright (c) 2014 Xamarin Inc. (http://xamarin.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System.Collections.Generic;
+using System.Linq;
+using ICSharpCode.NRefactory.TypeSystem;
+using ICSharpCode.NRefactory.Refactoring;
+using ICSharpCode.NRefactory.CSharp.Refactoring;
+using ICSharpCode.NRefactory.PatternMatching;
+using Mono.CSharp;
+using ICSharpCode.NRefactory.Semantics;
+
+namespace ICSharpCode.NRefactory.CSharp.Refactoring
+{
+	[IssueDescription ("CS0618: Member is obsolete",
+		Description = "CS0618: Member is obsolete",
+		Category = IssueCategories.CompilerWarnings,
+		Severity = Severity.Warning,
+		PragmaWarning = 618)]
+	public class CS0618UsageOfObsoleteMemberIssue : GatherVisitorCodeIssueProvider
+	{
+		protected override IGatherVisitor CreateVisitor(BaseRefactoringContext context)
+		{
+			return new GatherVisitor(context);
+		}
+
+		class GatherVisitor : GatherVisitorBase<CS0618UsageOfObsoleteMemberIssue>
+		{
+			public GatherVisitor(BaseRefactoringContext ctx) : base(ctx)
+			{
+			}
+
+			void Check(ResolveResult rr, AstNode nodeToMark)
+			{
+				if (rr == null || rr.IsError)
+					return;
+				IMember member = null;
+				var memberRR = rr as MemberResolveResult;
+				if (memberRR != null)
+					member = memberRR.Member;
+
+				var operatorRR = rr as OperatorResolveResult;
+				if (operatorRR != null)
+					member = operatorRR.UserDefinedOperatorMethod;
+
+				if (member == null)
+					return;
+
+				var attr = member.Attributes.FirstOrDefault(a => a.AttributeType.Name == "ObsoleteAttribute" && a.AttributeType.Namespace == "System");
+				if (attr == null)
+					return;
+				AddIssue(new CodeIssue(nodeToMark, string.Format(ctx.TranslateString("'{0}' is obsolete"), member.FullName)));
+			}
+
+			public override void VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression)
+			{
+				base.VisitMemberReferenceExpression(memberReferenceExpression);
+				Check(ctx.Resolve(memberReferenceExpression), memberReferenceExpression.MemberNameToken);
+			}
+
+			public override void VisitInvocationExpression(InvocationExpression invocationExpression)
+			{
+				base.VisitInvocationExpression(invocationExpression);
+				Check(ctx.Resolve(invocationExpression), invocationExpression.Target);
+			}
+
+			public override void VisitIdentifierExpression(IdentifierExpression identifierExpression)
+			{
+				base.VisitIdentifierExpression(identifierExpression);
+				Check(ctx.Resolve(identifierExpression), identifierExpression);
+			}
+
+			public override void VisitIndexerExpression(IndexerExpression indexerExpression)
+			{
+				base.VisitIndexerExpression(indexerExpression);
+				Check(ctx.Resolve(indexerExpression), indexerExpression);
+			}
+
+			public override void VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression)
+			{
+				base.VisitBinaryOperatorExpression(binaryOperatorExpression);
+				Check(ctx.Resolve(binaryOperatorExpression), binaryOperatorExpression.OperatorToken);
+			}
+		}
+	}
+}
+

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Custom/ConvertIfToAndExpressionIssue.cs

@@ -80,6 +80,8 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 						if (initializer != null && target is IdentifierExpression && ((IdentifierExpression)target).Identifier != initializer.Name)
 							return;
 						var expr = match.Get<Expression>("condition").Single();
+						if (!ConvertIfToOrExpressionIssue.CheckTarget(target, expr))
+							return;
 						AddIssue(new CodeIssue(
 							ifElseStatement.IfToken,
 							ctx.TranslateString("Convert to '&&' expresssion"),
@@ -106,6 +108,8 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 						return;
 					} else {
 						var expr = match.Get<Expression>("condition").Single();
+						if (!ConvertIfToOrExpressionIssue.CheckTarget(target, expr))
+							return;
 						AddIssue(new CodeIssue(
 							ifElseStatement.IfToken,
 							ctx.TranslateString("Convert to '&=' expresssion"),

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Custom/LockThisIssue.cs

@@ -294,7 +294,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 
 			static MemberReferenceExpression CreateMethodImplReferenceNode(MethodImplOptions option, AstType methodImplOptionsType)
 			{
-				return new MemberReferenceExpression(methodImplOptionsType.Clone(), Enum.GetName(typeof(MethodImplOptions), option));
+				return methodImplOptionsType.Clone().Member(Enum.GetName(typeof(MethodImplOptions), option));
 			}
 
 			bool IsMethodSynchronizedAttribute(Attribute attribute)

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Synced/CodeQuality/DoNotCallOverridableMethodsInConstructorIssue.cs

@@ -34,7 +34,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 	                  Description = "Warns about calls to virtual member functions occuring in the constructor.",
 	                  Category = IssueCategories.CodeQualityIssues,
 	                  Severity = Severity.Warning,
-                      AnalysisDisableKeyword = "DoNotCallOverridableMethodsInConstructor")]
+	                  AnalysisDisableKeyword = "DoNotCallOverridableMethodsInConstructor")]
 	public class DoNotCallOverridableMethodsInConstructorIssue : CodeIssueProvider
 	{
 		public override IEnumerable<CodeIssue> GetIssues(BaseRefactoringContext context, string subIssue)
@@ -61,7 +61,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 					return;
 				bool oldIsSealedType = isSealedType;
 				isSealedType = typeDeclaration.Modifiers.HasFlag(Modifiers.Sealed);
-			    CallFinder.CurrentType = typeDeclaration;
+				CallFinder.CurrentType = typeDeclaration;
 				base.VisitTypeDeclaration(typeDeclaration);
 				isSealedType = oldIsSealedType;
 			}
@@ -115,44 +115,38 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 		class VirtualCallFinderVisitor: GatherVisitorBase<DoNotCallOverridableMethodsInConstructorIssue>
 		{
 			readonly BaseRefactoringContext context;
-            public TypeDeclaration CurrentType;
+			public TypeDeclaration CurrentType;
 			public VirtualCallFinderVisitor(BaseRefactoringContext context) : base(context)
 			{
 				this.context = context;
 			}
 
-		    
+			public override void VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression)
+			{
+				base.VisitMemberReferenceExpression(memberReferenceExpression);
+				var targetMember = context.Resolve(memberReferenceExpression) as MemberResolveResult;
+				if (targetMember != null && targetMember.IsVirtualCall && targetMember.TargetResult is ThisResolveResult) {
+					CreateIssue(memberReferenceExpression);
+				}
+			}
 
-		    public override void VisitInvocationExpression(InvocationExpression invocationExpression)
+			public override void VisitInvocationExpression(InvocationExpression invocationExpression)
 			{
 				base.VisitInvocationExpression(invocationExpression);
-				if (!IsCallDependentOnCurrentInstance(invocationExpression))
-					// Call within current class scope without 'this' or 'base'
-					return;
 				var targetMethod = context.Resolve(invocationExpression) as InvocationResolveResult;
-				if (targetMethod == null)
-					return;
-				if (targetMethod.IsVirtualCall) {
-					if (targetMethod.Member.DeclaringType.Kind == ICSharpCode.NRefactory.TypeSystem.TypeKind.Delegate)
-						return;
-					AddIssue(new CodeIssue(invocationExpression,
-                             context.TranslateString("Virtual member call in constructor"),
-                             new CodeAction(string.Format(context.TranslateString("Make class '{0}' sealed"), CurrentType.Name),
-                             script => script.ChangeModifier(CurrentType, CurrentType.Modifiers | Modifiers.Sealed), 
-							invocationExpression)));
+				if (targetMethod != null && targetMethod.IsVirtualCall && targetMethod.TargetResult is ThisResolveResult) {
+					CreateIssue(invocationExpression);
 				}
 			}
 
-			bool IsCallDependentOnCurrentInstance(InvocationExpression invocationExpression)
+			void CreateIssue(AstNode node)
 			{
-				if (invocationExpression.Target is IdentifierExpression)
-					// Call within current class scope without 'this' or 'base'
-					return true;
-				var expression = invocationExpression.Target as MemberReferenceExpression;
-				if (expression == null || expression.Target is ThisReferenceExpression)
-					// Call within current class scope using 'this' or 'base'
-					return true;
-				return false;
+				AddIssue(new CodeIssue(
+					node,
+					context.TranslateString("Virtual member call in constructor"),
+					new CodeAction(string.Format(context.TranslateString("Make class '{0}' sealed"), CurrentType.Name),
+					               script => script.ChangeModifier(CurrentType, CurrentType.Modifiers | Modifiers.Sealed),
+					               node)));
 			}
 			
 			public override void VisitLambdaExpression(LambdaExpression lambdaExpression)

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Synced/CodeQuality/NotResolvedInTextIssue.cs

@@ -216,6 +216,14 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 					if (guessName != null) {
 
 						var actions = new List<CodeAction>();
+						
+						actions.Add(new CodeAction (
+							string.Format(context.TranslateString("Replace with '\"{0}\"'."), guessName),
+							script => {
+								script.Replace(paramNode, new PrimitiveExpression(guessName));
+							}, paramNode
+						)); 
+
 						if (canAddParameterName) {
 							actions.Add(new CodeAction(
 								string.Format(context.TranslateString("Add '\"{0}\"' parameter."), guessName),
@@ -229,13 +237,6 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 							)); 
 						}
 
-						actions.Add(new CodeAction (
-							string.Format(context.TranslateString("Replace with '\"{0}\"'."), guessName),
-							script => {
-								script.Replace(paramNode, new PrimitiveExpression(guessName));
-							}, paramNode
-						)); 
-
 						AddIssue(new CodeIssue(
 							paramNode,
 							string.Format(context.TranslateString("The parameter '{0}' can't be resolved"), paramName),

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Synced/Opportunities/ConvertToAutoPropertyIssue.cs

@@ -59,7 +59,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 
 			bool IsValidField(IField field)
 			{
-				if (field == null || field.Attributes.Count > 0)
+				if (field == null || field.Attributes.Count > 0 || field.IsVolatile)
 					return false;
 				foreach (var m in typeStack.Peek().Members.OfType<FieldDeclaration>()) {
 					foreach (var i in m.Variables) {

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Synced/Opportunities/ConvertToStaticTypeIssue.cs

@@ -66,7 +66,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 					return;
 				if (!typeDeclaration.Members.Any() || typeDeclaration.HasModifier(Modifiers.Abstract) || typeDeclaration.HasModifier(Modifiers.Partial))
 					return;
-				if (typeDeclaration.Members.Any(f => !f.HasModifier(Modifiers.Static) && !f.HasModifier(Modifiers.Const)))
+				if (typeDeclaration.Members.Where(m => !(m is TypeDeclaration)).Any(f => !f.HasModifier(Modifiers.Static) && !f.HasModifier(Modifiers.Const)))
 					return;
 				var rr = ctx.Resolve(typeDeclaration);
 				if (rr.IsError || rr.Type.GetMembers().Any(IsMainMethod))

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Synced/PracticesAndImprovements/ConvertIfToOrExpressionIssue.cs

@@ -43,6 +43,14 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			return new GatherVisitor(context);
 		}
 
+		internal static bool CheckTarget(Expression target, Expression expr)
+		{
+			return !target.DescendantNodesAndSelf().Any(
+				n => (n is IdentifierExpression || n is MemberReferenceExpression) && 
+				expr.DescendantNodesAndSelf().Any(n2 => ((INode)n).IsMatch(n2))
+			);
+		}
+
 		class GatherVisitor : GatherVisitorBase<ConvertIfToOrExpressionIssue>
 		{
 			public GatherVisitor (BaseRefactoringContext ctx) : base (ctx)
@@ -83,6 +91,8 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 						if (initializer == null || !(target is IdentifierExpression) || ((IdentifierExpression)target).Identifier != initializer.Name)
 							return;
 						var expr = match.Get<Expression>("condition").Single();
+						if (!CheckTarget(target, expr))
+							return;
 						AddIssue(new CodeIssue(
 							ifElseStatement.IfToken,
 							ctx.TranslateString("Convert to '||' expresssion"),
@@ -103,6 +113,8 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 						return;
 					} else {
 						var expr = match.Get<Expression>("condition").Single();
+						if (!CheckTarget(target, expr))
+							return;
 						AddIssue(new CodeIssue(
 							ifElseStatement.IfToken,
 							ctx.TranslateString("Convert to '|=' expresssion"),

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Synced/PracticesAndImprovements/FieldCanBeMadeReadOnlyIssue.cs

@@ -88,8 +88,17 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 						continue;
 					var variable = fieldDeclaration.Variables.First();
 					var rr = ctx.Resolve(fieldDeclaration.ReturnType);
-					if ((rr.Type.IsReferenceType.HasValue && !rr.Type.IsReferenceType.Value) && (ctx.Resolve (variable.Initializer) is ConstantResolveResult))
-						continue;
+					if (rr.Type.IsReferenceType == false) {
+						// Value type:
+						var def = rr.Type.GetDefinition();
+						if (def != null && def.KnownTypeCode == KnownTypeCode.None) {
+							// user-defined value type -- might be mutable
+							continue;
+						} else if (ctx.Resolve (variable.Initializer) is ConstantResolveResult) {
+							// handled by ConvertToConstantIssue
+							continue;
+						}
+					}
 
 					var mr = ctx.Resolve(variable) as MemberResolveResult;
 					if (mr == null)

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Synced/PracticesAndImprovements/MemberCanBeMadeStaticIssue.cs

@@ -185,10 +185,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			                                                           Script fscript)
 			{
 				if (fnode is MemberReferenceExpression) {
-					var memberReference = new MemberReferenceExpression(
-						fctx.CreateShortType(rr.Member.DeclaringType),
-						rr.Member.Name
-					);
+					var memberReference = fctx.CreateShortType(rr.Member.DeclaringType).Member(rr.Member.Name);
 					fscript.Replace(fnode, memberReference);
 				} else {
 					var invoke = fnode as InvocationExpression;
@@ -196,10 +193,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 						return;
 					if ((invoke.Target is MemberReferenceExpression))
 						return;
-					var memberReference = new MemberReferenceExpression(
-						fctx.CreateShortType(rr.Member.DeclaringType),
-						rr.Member.Name
-					);
+					var memberReference = fctx.CreateShortType(rr.Member.DeclaringType).Member(rr.Member.Name);
 					fscript.Replace(invoke.Target, memberReference);
 				}
 			}

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Synced/PracticesAndImprovements/ReferenceEqualsWithValueTypeIssue.cs

@@ -73,8 +73,8 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 					              script => script.Replace(invocationExpression, new PrimitiveExpression(false)), invocationExpression);
 
 				var action2 = new CodeAction(ctx.TranslateString("Use Equals()"),
-					              script => script.Replace(invocationExpression.Target, new MemberReferenceExpression(
-						              new PrimitiveType("object"), "Equals")), invocationExpression);
+					              script => script.Replace(invocationExpression.Target,
+						              new PrimitiveType("object").Member("Equals")), invocationExpression);
 
 				AddIssue(new CodeIssue(invocationExpression,
 					ctx.TranslateString("'Object.ReferenceEquals' is always false because it is called with value type"),

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Synced/PracticesAndImprovements/ReplaceWithStringIsNullOrEmptyIssue.cs

@@ -51,7 +51,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				new Choice {
 					PatternHelper.CommutativeOperatorWithOptionalParentheses (new Backreference ("str"), BinaryOperatorType.Equality, new PrimitiveExpression ("")),
 					PatternHelper.CommutativeOperatorWithOptionalParentheses (new Backreference ("str"), BinaryOperatorType.Equality,
-				                                       new MemberReferenceExpression(new PrimitiveType("string"), "Empty")),
+				                                       new PrimitiveType("string").Member("Empty")),
 					PatternHelper.CommutativeOperatorWithOptionalParentheses (
 						new MemberReferenceExpression (new Backreference ("str"), "Length"),
 						BinaryOperatorType.Equality,
@@ -64,7 +64,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				new Choice {
 					PatternHelper.CommutativeOperatorWithOptionalParentheses (new AnyNode ("str"), BinaryOperatorType.Equality, new PrimitiveExpression ("")),
 					PatternHelper.CommutativeOperatorWithOptionalParentheses (new AnyNode ("str"), BinaryOperatorType.Equality,
-				                                       new MemberReferenceExpression(new PrimitiveType("string"), "Empty"))
+				                                       new PrimitiveType("string").Member("Empty"))
 				},
 				BinaryOperatorType.ConditionalOr,
 				PatternHelper.CommutativeOperator(new Backreference ("str"), BinaryOperatorType.Equality, new NullReferenceExpression ())
@@ -80,7 +80,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				new Choice {
 					PatternHelper.CommutativeOperatorWithOptionalParentheses (new Backreference ("str"), BinaryOperatorType.InEquality, new PrimitiveExpression ("")),
 					PatternHelper.CommutativeOperatorWithOptionalParentheses (new Backreference ("str"), BinaryOperatorType.InEquality,
-				                                   	   new MemberReferenceExpression(new PrimitiveType("string"), "Empty")),
+				                                   	   new PrimitiveType("string").Member("Empty")),
 					PatternHelper.CommutativeOperatorWithOptionalParentheses (
 						new MemberReferenceExpression (new Backreference ("str"), "Length"),
 						BinaryOperatorType.InEquality,
@@ -98,7 +98,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				new Choice {
 					PatternHelper.CommutativeOperatorWithOptionalParentheses (new AnyNode ("str"), BinaryOperatorType.InEquality, new PrimitiveExpression ("")),
 					PatternHelper.CommutativeOperatorWithOptionalParentheses (new AnyNode ("str"), BinaryOperatorType.Equality,
-				                                   	   new MemberReferenceExpression(new PrimitiveType("string"), "Empty"))
+				                                   	   new PrimitiveType("string").Member("Empty"))
 				},
 				BinaryOperatorType.ConditionalAnd,
 				PatternHelper.CommutativeOperatorWithOptionalParentheses(new Backreference ("str"), BinaryOperatorType.InEquality, new NullReferenceExpression ())

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Synced/PracticesAndImprovements/StringCompareToIsCultureSpecificIssue.cs

@@ -84,8 +84,8 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				var astBuilder = ctx.CreateTypeSystemAstBuilder(invocationExpression);
 				var newArgument = astBuilder.ConvertType(new TopLevelTypeName("System", "StringComparison")).Member(ordinal);
 
-				var newInvocation = new InvocationExpression(
-					new MemberReferenceExpression(new PrimitiveType("string"), "Compare"),
+				var newInvocation = new PrimitiveType("string").Invoke(
+					"Compare",
 					mr.Target.Clone(),
 					invocationExpression.Arguments.First().Clone(),
 					newArgument

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/CodeIssues/Synced/RedundanciesInCode/RedundantUnsafeContextIssue.cs

@@ -61,6 +61,11 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 					this.InUnsafeContext = inUnsafeContext;
 					this.UseUnsafeConstructs = false;
 				}
+
+				public override string ToString()
+				{
+					return string.Format("[UnsafeState: InUnsafeContext={0}, UseUnsafeConstructs={1}]", InUnsafeContext, UseUnsafeConstructs);
+				}
 			}
 
 			readonly Stack<UnsafeState> unsafeStateStack = new Stack<UnsafeState> ();
@@ -81,16 +86,13 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				base.VisitTypeDeclaration(typeDeclaration);
 
 				var state = unsafeStateStack.Pop();
-				unsafeIsRedundant |= typeDeclaration.HasModifier(Modifiers.Unsafe) && !state.UseUnsafeConstructs;
-
+				unsafeIsRedundant = typeDeclaration.HasModifier(Modifiers.Unsafe) && !state.UseUnsafeConstructs;
 				if (unsafeIsRedundant) {
 					AddIssue(new CodeIssue(
 						typeDeclaration.ModifierTokens.First (t => t.Modifier == Modifiers.Unsafe),
 						ctx.TranslateString("'unsafe' modifier is redundant."), 
 						ctx.TranslateString("Remove redundant 'unsafe' modifier"), 
-						script => {
-							script.ChangeModifier (typeDeclaration, typeDeclaration.Modifiers & ~Modifiers.Unsafe);
-						}
+						script => script.ChangeModifier(typeDeclaration, typeDeclaration.Modifiers & ~Modifiers.Unsafe)
 					) { IssueMarker = IssueMarker.GrayOut });
 				}
 			}
@@ -111,6 +113,13 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			public override void VisitFixedStatement(FixedStatement fixedStatement)
 			{
 				base.VisitFixedStatement(fixedStatement);
+
+				unsafeStateStack.Peek().UseUnsafeConstructs = true;
+			}
+
+			public override void VisitSizeOfExpression(SizeOfExpression sizeOfExpression)
+			{
+				base.VisitSizeOfExpression(sizeOfExpression);
 				unsafeStateStack.Peek().UseUnsafeConstructs = true;
 			}
 

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp.Refactoring/ICSharpCode.NRefactory.CSharp.Refactoring.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>10.0.0</ProductVersion>
+    <ProductVersion>8.0.30703</ProductVersion>
     <SchemaVersion>2.0</SchemaVersion>
     <ProjectGuid>{2A705FC6-1A9E-4941-9E47-254D79F2D9D5}</ProjectGuid>
     <OutputType>Library</OutputType>
@@ -424,6 +424,7 @@
     <Compile Include="CodeIssues\TODO\RedundantTypeArgumentsOfMethodIssue.cs" />
     <Compile Include="CodeIssues\Synced\PracticesAndImprovements\PossibleMistakenCallToGetTypeIssue.cs" />
     <Compile Include="CodeIssues\Uncategorized\RedundantNotNullAttributeInNonNullableTypeIssue.cs" />
+    <Compile Include="CodeIssues\Custom\CompilerErrors\CS0618UsageOfObsoleteMemberIssue.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <ItemGroup>

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Analysis/SemanticHighlightingVisitor.cs

@@ -319,7 +319,9 @@ namespace ICSharpCode.NRefactory.CSharp.Analysis
 						return;
 					}
 
-					if (invocationRR.Arguments.Count > 1 && CSharpCompletionEngine.FormatItemMethods.Contains(invocationRR.Member.FullName)) {
+					Expression fmtArgumets;
+					IList<Expression> args;
+					if (invocationRR.Arguments.Count > 1 && FormatStringHelper.TryGetFormattingParameters(invocationRR, invocationExpression, out fmtArgumets, out args, null)) {
 						var expr = invocationExpression.Arguments.First() as PrimitiveExpression; 
 						if (expr != null)
 							HighlightStringFormatItems(expr);
@@ -407,6 +409,8 @@ namespace ICSharpCode.NRefactory.CSharp.Analysis
 		bool CheckInterfaceImplementation (EntityDeclaration entityDeclaration)
 		{
 			var result = resolver.Resolve (entityDeclaration, cancellationToken) as MemberResolveResult;
+			if (result == null)
+				return false;
 			if (result.Member.ImplementedInterfaceMembers.Count == 0) {
 				Colorize (entityDeclaration.NameToken, syntaxErrorColor);
 				return false;

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Ast/AstType.cs

@@ -275,10 +275,5 @@ namespace ICSharpCode.NRefactory.CSharp
 			}
 			return type;
 		}
-
-		public static implicit operator Expression (AstType type)
-		{
-			return new TypeReferenceExpression(type);
-		}
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Ast/Expressions/MemberReferenceExpression.cs

@@ -93,7 +93,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		
 		public MemberReferenceExpression (Expression target, string memberName, params AstType[] arguments) : this (target, memberName, (IEnumerable<AstType>)arguments)
 		{
-		}	
+		}
 		
 		public override void AcceptVisitor (IAstVisitor visitor)
 		{

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs

@@ -389,13 +389,6 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			return null;
 		}
 
-		internal static readonly string[] FormatItemMethods = {
-			"System.String.Format",
-			"System.Console.Write",
-			"System.Console.WriteLine",
-			"System.IO.StringWriter.Write",
-			"System.IO.StringWriter.WriteLine"
-		};
 		static readonly DateTime curDate = DateTime.Now;
 
 		IEnumerable<ICompletionData> GenerateNumberFormatitems(bool isFloatingPoint)
@@ -553,11 +546,13 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 				return Enumerable.Empty<ICompletionData>();
 
 			var resolveResult = ResolveExpression(new ExpressionResult(invoke, unit));
-			var invokeResult = resolveResult.Result as InvocationResolveResult;
+			var invokeResult = resolveResult.Result as CSharpInvocationResolveResult;
 			if (invokeResult == null)
 				return Enumerable.Empty<ICompletionData>();
 
-			if (FormatItemMethods.Contains(invokeResult.Member.FullName)) {
+			Expression fmtArgumets;
+			IList<Expression> args;
+			if (FormatStringHelper.TryGetFormattingParameters(invokeResult, invoke, out fmtArgumets, out args, null)) {
 				return GenerateNumberFormatitems(false)
 					.Concat(GenerateDateTimeFormatitems())
 					.Concat(GenerateTimeSpanFormatitems())
@@ -1016,6 +1011,11 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 						if (identifierStart.Node is AstType && identifierStart.Node.Parent is CatchClause) {
 							return HandleCatchClauseType(identifierStart);
 						}
+
+						var pDecl = identifierStart.Node as ParameterDeclaration;
+						if (pDecl != null && pDecl.Parent is LambdaExpression) {
+							return null;
+						}
 					}
 
 
@@ -1072,13 +1072,12 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 					// Handle foreach (type name _
 					if (n is IdentifierExpression) {
 						var prev = n.GetPrevNode() as ForeachStatement;
+						while (prev != null && prev.EmbeddedStatement is ForeachStatement)
+							prev = (ForeachStatement)prev.EmbeddedStatement;
 						if (prev != null && prev.InExpression.IsNull) {
-							if (controlSpace) {
-								if (IncludeKeywordsInCompletionList)
-									contextList.AddCustom("in");
-								return contextList.Result;
-							}
-							return null;
+							if (IncludeKeywordsInCompletionList)
+								contextList.AddCustom("in");
+							return contextList.Result;
 						}
 					}
 					// Handle object/enumerable initialzer expressions: "new O () { P$"
@@ -1540,7 +1539,6 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			ifvisitor.End();
 			if (!ifvisitor.IsValid)
 				return null;
-
 			// namespace name case
 			var ns = node as NamespaceDeclaration;
 			if (ns != null) {
@@ -2611,7 +2609,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			return true;
 		}
 
-		string AddDelegateHandlers(CompletionDataWrapper completionList, IType delegateType, bool addSemicolon = true, bool addDefault = true)
+		string AddDelegateHandlers(CompletionDataWrapper completionList, IType delegateType, bool addSemicolon = true, bool addDefault = true, string optDelegateName = null)
 		{
 			IMethod delegateMethod = delegateType.GetDelegateInvokeMethod();
 			PossibleDelegates.Add(delegateMethod);
@@ -2642,6 +2640,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			var builder = new TypeSystemAstBuilder(state);
 
 			for (int k = 0; k < delegateMethod.Parameters.Count; k++) {
+
 				if (k > 0) {
 					sb.Append(", ");
 					sbWithoutTypes.Append(", ");
@@ -2702,6 +2701,11 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 				}
 
 			}
+
+			string varName = "Handle" + delegateType.Name + optDelegateName;
+			completionList.Add(factory.CreateEventCreationCompletionData(varName, delegateType, null, signature, currentMember, currentType));
+
+
 			/*			 TODO:Make factory method out of it.
 			// It's  needed to temporarly disable inserting auto matching bracket because the anonymous delegates are selectable with '('
 			// otherwise we would end up with () => )
@@ -2867,9 +2871,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			if (resolvedType.Kind == TypeKind.Delegate) {
 				if (addedDelegates.Contains(resolvedType.ReflectionName))
 					return;
-				string parameterDefinition = AddDelegateHandlers(result, resolvedType, false);
-				string varName = "Handle" + method.Parameters [parameter].Type.Name + method.Parameters [parameter].Name;
-				result.Result.Add(factory.CreateEventCreationCompletionData(varName, resolvedType, null, parameterDefinition, currentMember, currentType));
+				AddDelegateHandlers(result, resolvedType, false, true, method.Parameters [parameter].Name);
 			}
 		}
 
@@ -3235,7 +3237,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 						} else {
 							tref = baseUnit.GetNodeAt<Expression>(location); 
 							if (tref == null) {
-								tref = memberType.Clone();
+								tref = new TypeReferenceExpression(memberType.Clone());
 								memberType.Parent.AddChild(tref, Roles.Expression);
 							}
 							if (tref is ObjectCreateExpression) {
@@ -3385,7 +3387,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 
 			// try lambda 
 			if (expr == null) {
-				baseUnit = ParseStub(") => {}", false);
+				baseUnit = ParseStub("foo) => {}", false);
 				expr = baseUnit.GetNodeAt<ParameterDeclaration>(
 					location.Line,
 					location.Column

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Formatter/FormattingVisitor_Expressions.cs

@@ -354,10 +354,10 @@ namespace ICSharpCode.NRefactory.CSharp
 					}
 					curIndent.Pop();
 				} else {
-
 					if (!doAlignToFirstArgument) {
 						curIndent.Push(IndentType.Continuation);
 						foreach (var arg in arguments.Take (argumentStart)) {
+							FixStatementIndentation(arg.StartLocation);
 							arg.AcceptVisitor(this);
 						}
 						foreach (var arg in arguments.Skip (argumentStart)) {
@@ -451,14 +451,14 @@ namespace ICSharpCode.NRefactory.CSharp
 				ForceSpacesAfter(invocationExpression.LParToken, policy.SpaceBetweenEmptyMethodCallParentheses);
 				ForceSpacesBefore(invocationExpression.RParToken, policy.SpaceBetweenEmptyMethodCallParentheses);
 			}
-
+			bool popIndent = false;
 			if (invocationExpression.Target is MemberReferenceExpression) {
 				var mt = (MemberReferenceExpression)invocationExpression.Target;
 				if (mt.Target is InvocationExpression) {
 					if (DoWrap(policy.ChainedMethodCallWrapping, mt.DotToken, 2)) {
-						curIndent.Push(IndentType.Continuation);
+						curIndent.Push(IndentType.Block);
+						popIndent = true;
 						FixStatementIndentation(mt.DotToken.StartLocation);
-						curIndent.Pop();
 					} else {
 						if (policy.ChainedMethodCallWrapping == Wrapping.DoNotWrap)
 							ForceSpacesBeforeRemoveNewLines(mt.DotToken, false);
@@ -466,6 +466,8 @@ namespace ICSharpCode.NRefactory.CSharp
 				}
 			}
 			FormatArguments(invocationExpression);
+			if (popIndent)
+				curIndent.Pop();
 		}
 
 		public override void VisitIndexerExpression(IndexerExpression indexerExpression)

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Formatter/FormattingVisitor_Statements.cs

@@ -157,6 +157,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				}
 				node.AcceptVisitor(this);
 			}
+			nextStatementIndent = null;
 			if (pushed)
 				curIndent.Pop();
 			if (beginBraceAction != null && endBraceAction != null) {

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Formatter/FormattingVisitor_TypeMembers.cs

@@ -139,6 +139,7 @@ namespace ICSharpCode.NRefactory.CSharp
 									goto case PropertyFormatting.ForceNewLine;
 								nextStatementIndent = " ";
 								VisitBlockWithoutFixingBraces(accessor.Body, policy.IndentBlocks);
+								nextStatementIndent = null;
 								if (!oneLine)
 									ForceSpacesBeforeRemoveNewLines(accessor.Body.RBraceToken, true);
 								break;
@@ -272,6 +273,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					} else {
 						nextStatementIndent = " ";
 						VisitBlockWithoutFixingBraces(eventDeclaration.AddAccessor.Body, policy.IndentBlocks);
+						nextStatementIndent = null;
 					}
 				}
 			}
@@ -286,6 +288,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					} else {
 						nextStatementIndent = " ";
 						VisitBlockWithoutFixingBraces(eventDeclaration.RemoveAccessor.Body, policy.IndentBlocks);
+						nextStatementIndent = null;
 					}
 				}
 			}

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/IndentEngine/IndentState.cs

@@ -196,6 +196,9 @@ namespace ICSharpCode.NRefactory.CSharp
 			// replace ThisLineIndent with NextLineIndent if the newLineChar is pushed
 			if (ch == Engine.newLineChar)
 			{
+				var delta = Engine.textEditorOptions.ContinuationIndent;
+				while (NextLineIndent.CurIndent - ThisLineIndent.CurIndent > delta &&
+					   NextLineIndent.PopIf(IndentType.Continuation)) ;
 				ThisLineIndent = NextLineIndent.Clone();
 			}
 		}
@@ -480,6 +483,11 @@ namespace ICSharpCode.NRefactory.CSharp
 		/// </summary>
 		public bool IsEqualCharPushed;
 
+		/// <summary>
+		///     The indentation of the previous line.
+		/// </summary>
+		public int PreviousLineIndent;
+
 		/// <summary>
 		///     True if the dot member (e.g. method invocation) indentation has
 		///     been handled in the current statement.
@@ -507,6 +515,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			IsEqualCharPushed = prototype.IsEqualCharPushed;
 			IsMemberReferenceDotHandled = prototype.IsMemberReferenceDotHandled;
 			LastBlockIndent = prototype.LastBlockIndent;
+			PreviousLineIndent = prototype.PreviousLineIndent;
 		}
 
 		public override void Push(char ch)
@@ -562,6 +571,9 @@ namespace ICSharpCode.NRefactory.CSharp
 					IsMemberReferenceDotHandled = true;
 
 					ThisLineIndent.RemoveAlignment();
+					while (ThisLineIndent.CurIndent > PreviousLineIndent && 
+					       ThisLineIndent.PopIf(IndentType.Continuation)) ;
+
 					ThisLineIndent.Push(IndentType.Continuation);
 					NextLineIndent = ThisLineIndent.Clone();
 				}
@@ -571,6 +583,10 @@ namespace ICSharpCode.NRefactory.CSharp
 				// try to capture ': base(...)', ': this(...)' and inherit statements when they are on a new line
 				ThisLineIndent.Push(IndentType.Continuation);
 			}
+			else if (ch == Engine.newLineChar)
+			{
+				PreviousLineIndent = ThisLineIndent.CurIndent;
+			}
 
 			if (Engine.wordToken.ToString() == "else")
 			{
@@ -625,6 +641,14 @@ namespace ICSharpCode.NRefactory.CSharp
 			{
 				ThisLineIndent.RemoveAlignment();
 				ThisLineIndent.PopTry();
+				BraceStyle style;
+				if (TryGetBraceStyle(this.CurrentBody, out style)) {
+					if (style == BraceStyle.NextLineShifted ||
+						style == BraceStyle.NextLineShifted2||
+						style == BraceStyle.BannerStyle) {
+						ThisLineIndent.Push(IndentType.Block);
+					}
+				}
 			}
 
 			base.OnExit();
@@ -859,77 +883,84 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			switch (braceStyle)
 			{
+				case BraceStyle.NextLineShifted:
+					ThisLineIndent.Push(IndentType.Block);
+					NextLineIndent.Push(IndentType.Block);
+					break;
 				case BraceStyle.DoNotChange:
 				case BraceStyle.EndOfLine:
 				case BraceStyle.EndOfLineWithoutSpace:
 				case BraceStyle.NextLine:
-				case BraceStyle.NextLineShifted:
 				case BraceStyle.BannerStyle:
 					NextLineIndent.Push(IndentType.Block);
 					break;
 				case BraceStyle.NextLineShifted2:
+					ThisLineIndent.Push(IndentType.Block);
 					NextLineIndent.Push(IndentType.DoubleBlock);
 					break;
 			}
 		}
 
-		/// <summary>
-		///     Pushes a new level of indentation depending on the given
-		///     <paramref name="body"/>.
-		/// </summary>
-		void AddIndentation(Body body)
+		bool TryGetBraceStyle (Body body, out BraceStyle style)
 		{
+			style = BraceStyle.DoNotChange;
 			switch (body)
 			{
 				case Body.None:
-					if (Engine.formattingOptions.IndentBlocks)
-						NextLineIndent.Push(IndentType.Block);
-					else
-						NextLineIndent.Push(IndentType.Empty);
-					break;
+					if (!Engine.formattingOptions.IndentBlocks)
+						return false;
+					style = BraceStyle.NextLine;
+					return true;
 				case Body.Namespace:
-					if (Engine.formattingOptions.IndentNamespaceBody)
-						AddIndentation(Engine.formattingOptions.NamespaceBraceStyle);
-					else
-						NextLineIndent.Push(IndentType.Empty);
-					break;
+					if (!Engine.formattingOptions.IndentNamespaceBody)
+						return false;
+					style = Engine.formattingOptions.NamespaceBraceStyle;
+					return true;
 				case Body.Class:
-					if (Engine.formattingOptions.IndentClassBody)
-						AddIndentation(Engine.formattingOptions.ClassBraceStyle);
-					else
-						NextLineIndent.Push(IndentType.Empty);
-					break;
+					if (!Engine.formattingOptions.IndentClassBody)
+						return false;
+					style = Engine.formattingOptions.ClassBraceStyle;
+					return true;
 				case Body.Struct:
-					if (Engine.formattingOptions.IndentStructBody)
-						AddIndentation(Engine.formattingOptions.StructBraceStyle);
-					else
-						NextLineIndent.Push(IndentType.Empty);
-					break;
+					if (!Engine.formattingOptions.IndentStructBody)
+						return false;
+					style = Engine.formattingOptions.StructBraceStyle;
+					return true;
 				case Body.Interface:
-					if (Engine.formattingOptions.IndentInterfaceBody)
-						AddIndentation(Engine.formattingOptions.InterfaceBraceStyle);
-					else
-						NextLineIndent.Push(IndentType.Empty);
-					break;
+					if (!Engine.formattingOptions.IndentInterfaceBody)
+						return false;
+					style = Engine.formattingOptions.InterfaceBraceStyle;
+					return true;
 				case Body.Enum:
-					if (Engine.formattingOptions.IndentEnumBody)
-						AddIndentation(Engine.formattingOptions.EnumBraceStyle);
-					else
-						NextLineIndent.Push(IndentType.Empty);
-					break;
+					if (!Engine.formattingOptions.IndentEnumBody)
+						return false;
+					style = Engine.formattingOptions.EnumBraceStyle;
+					return true;
 				case Body.Switch:
-					if (Engine.formattingOptions.IndentSwitchBody)
-						AddIndentation(Engine.formattingOptions.StatementBraceStyle);
-					else
-						NextLineIndent.Push(IndentType.Empty);
-					break;
+					if (!Engine.formattingOptions.IndentSwitchBody)
+						return false;
+					style = Engine.formattingOptions.StatementBraceStyle;
+					return true;
 				case Body.Try:
 				case Body.Catch:
 				case Body.Finally:
-					AddIndentation(Engine.formattingOptions.StatementBraceStyle);
-					break;
-				default:
-					throw new ArgumentOutOfRangeException();
+					style = Engine.formattingOptions.StatementBraceStyle;
+					return true;
+			}
+			return false;
+		}
+
+		/// <summary>
+		///     Pushes a new level of indentation depending on the given
+		///     <paramref name="body"/>.
+		/// </summary>
+		void AddIndentation(Body body)
+		{
+			BraceStyle style;
+			if (TryGetBraceStyle (body, out style)) {
+				AddIndentation(style);
+			} else {
+				NextLineIndent.Push(IndentType.Empty);
 			}
 		}
 

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpAmbience.cs

@@ -30,29 +30,43 @@ namespace ICSharpCode.NRefactory.CSharp
 	{
 		public ConversionFlags ConversionFlags { get; set; }
 		
-		#region ConvertEntity
+		#region ConvertSymbol
+		[Obsolete("Use ConvertSymbol() instead")]
 		public string ConvertEntity(IEntity entity)
 		{
-			if (entity == null)
-				throw new ArgumentNullException("entity");
+			return ConvertSymbol(entity);
+		}
+		
+		public string ConvertSymbol(ISymbol symbol)
+		{
+			if (symbol == null)
+				throw new ArgumentNullException("symbol");
 			
 			StringWriter writer = new StringWriter();
-			ConvertEntity(entity, new TextWriterTokenWriter(writer), FormattingOptionsFactory.CreateMono ());
+			ConvertSymbol(symbol, new TextWriterTokenWriter(writer), FormattingOptionsFactory.CreateMono ());
 			return writer.ToString();
 		}
 		
+		[Obsolete("Use ConvertSymbol() instead")]
 		public void ConvertEntity(IEntity entity, TokenWriter writer, CSharpFormattingOptions formattingPolicy)
 		{
-			if (entity == null)
-				throw new ArgumentNullException("entity");
+			ConvertSymbol(entity, writer, formattingPolicy);
+		}
+		
+		public void ConvertSymbol(ISymbol symbol, TokenWriter writer, CSharpFormattingOptions formattingPolicy)
+		{
+			if (symbol == null)
+				throw new ArgumentNullException("symbol");
 			if (writer == null)
 				throw new ArgumentNullException("writer");
 			if (formattingPolicy == null)
-				throw new ArgumentNullException("options");
+				throw new ArgumentNullException("formattingPolicy");
 			
 			TypeSystemAstBuilder astBuilder = CreateAstBuilder();
-			EntityDeclaration node = astBuilder.ConvertEntity(entity);
-			PrintModifiers(node.Modifiers, writer);
+			AstNode node = astBuilder.ConvertSymbol(symbol);
+			EntityDeclaration entityDecl = node as EntityDeclaration;
+			if (entityDecl != null)
+				PrintModifiers(entityDecl.Modifiers, writer);
 			
 			if ((ConversionFlags & ConversionFlags.ShowDefinitionKeyword) == ConversionFlags.ShowDefinitionKeyword) {
 				if (node is TypeDeclaration) {
@@ -79,6 +93,9 @@ namespace ICSharpCode.NRefactory.CSharp
 				} else if (node is EventDeclaration) {
 					writer.WriteKeyword(EventDeclaration.EventKeywordRole, "event");
 					writer.Space();
+				} else if (node is NamespaceDeclaration) {
+					writer.WriteKeyword(Roles.NamespaceKeyword, "namespace");
+					writer.Space();
 				}
 			}
 			
@@ -90,13 +107,15 @@ namespace ICSharpCode.NRefactory.CSharp
 				}
 			}
 			
-			if (entity is ITypeDefinition)
-				WriteTypeDeclarationName((ITypeDefinition)entity, writer, formattingPolicy);
+			if (symbol is ITypeDefinition)
+				WriteTypeDeclarationName((ITypeDefinition)symbol, writer, formattingPolicy);
+			else if (symbol is IMember)
+				WriteMemberDeclarationName((IMember)symbol, writer, formattingPolicy);
 			else
-				WriteMemberDeclarationName((IMember)entity, writer, formattingPolicy);
+				writer.WriteIdentifier(Identifier.Create(symbol.Name));
 			
-			if ((ConversionFlags & ConversionFlags.ShowParameterList) == ConversionFlags.ShowParameterList && HasParameters(entity)) {
-				writer.WriteToken(entity.SymbolKind == SymbolKind.Indexer ? Roles.LBracket : Roles.LPar, entity.SymbolKind == SymbolKind.Indexer ? "[" : "(");
+			if ((ConversionFlags & ConversionFlags.ShowParameterList) == ConversionFlags.ShowParameterList && HasParameters(symbol)) {
+				writer.WriteToken(symbol.SymbolKind == SymbolKind.Indexer ? Roles.LBracket : Roles.LPar, symbol.SymbolKind == SymbolKind.Indexer ? "[" : "(");
 				bool first = true;
 				foreach (var param in node.GetChildrenByRole(Roles.Parameter)) {
 					if (first) {
@@ -107,11 +126,11 @@ namespace ICSharpCode.NRefactory.CSharp
 					}
 					param.AcceptVisitor(new CSharpOutputVisitor(writer, formattingPolicy));
 				}
-				writer.WriteToken(entity.SymbolKind == SymbolKind.Indexer ? Roles.RBracket : Roles.RPar, entity.SymbolKind == SymbolKind.Indexer ? "]" : ")");
+				writer.WriteToken(symbol.SymbolKind == SymbolKind.Indexer ? Roles.RBracket : Roles.RPar, symbol.SymbolKind == SymbolKind.Indexer ? "]" : ")");
 			}
 			
 			if ((ConversionFlags & ConversionFlags.ShowBody) == ConversionFlags.ShowBody && !(node is TypeDeclaration)) {
-				IProperty property = entity as IProperty;
+				IProperty property = symbol as IProperty;
 				if (property != null) {
 					writer.Space();
 					writer.WriteToken(Roles.LBrace, "{");
@@ -133,7 +152,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			}
 		}
 		
-		bool HasParameters(IEntity e)
+		static bool HasParameters(ISymbol e)
 		{
 			switch (e.SymbolKind) {
 				case SymbolKind.TypeDefinition:
@@ -167,7 +186,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			if (typeDef.DeclaringTypeDefinition != null) {
 				WriteTypeDeclarationName(typeDef.DeclaringTypeDefinition, writer, formattingPolicy);
 				writer.WriteToken(Roles.Dot, ".");
-			} else if ((ConversionFlags & ConversionFlags.UseFullyQualifiedMemberNames) == ConversionFlags.UseFullyQualifiedMemberNames) {
+			} else if ((ConversionFlags & ConversionFlags.UseFullyQualifiedEntityNames) == ConversionFlags.UseFullyQualifiedEntityNames) {
 				WriteQualifiedName(typeDef.Namespace, writer, formattingPolicy);
 				writer.WriteToken(Roles.Dot, ".");
 			}
@@ -265,7 +284,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				throw new ArgumentNullException("type");
 			
 			TypeSystemAstBuilder astBuilder = CreateAstBuilder();
-			astBuilder.AlwaysUseShortTypeNames = (ConversionFlags & ConversionFlags.UseFullyQualifiedMemberNames) != ConversionFlags.UseFullyQualifiedMemberNames;
+			astBuilder.AlwaysUseShortTypeNames = (ConversionFlags & ConversionFlags.UseFullyQualifiedEntityNames) != ConversionFlags.UseFullyQualifiedEntityNames;
 			AstType astType = astBuilder.ConvertType(type);
 			return astType.ToString();
 		}
@@ -273,7 +292,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		public void ConvertType(IType type, TokenWriter writer, CSharpFormattingOptions formattingPolicy)
 		{
 			TypeSystemAstBuilder astBuilder = CreateAstBuilder();
-			astBuilder.AlwaysUseShortTypeNames = (ConversionFlags & ConversionFlags.UseFullyQualifiedMemberNames) != ConversionFlags.UseFullyQualifiedMemberNames;
+			astBuilder.AlwaysUseShortTypeNames = (ConversionFlags & ConversionFlags.UseFullyQualifiedEntityNames) != ConversionFlags.UseFullyQualifiedEntityNames;
 			AstType astType = astBuilder.ConvertType(type);
 			astType.AcceptVisitor(new CSharpOutputVisitor(writer, formattingPolicy));
 		}

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/OutputVisitor/CodeDomConvertVisitor.cs

@@ -27,7 +27,6 @@ using ICSharpCode.NRefactory.CSharp.TypeSystem;
 using ICSharpCode.NRefactory.PatternMatching;
 using ICSharpCode.NRefactory.Semantics;
 using ICSharpCode.NRefactory.TypeSystem;
-using Mono.CSharp;
 
 namespace ICSharpCode.NRefactory.CSharp
 {

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/CSharpParser.cs

@@ -1494,8 +1494,8 @@ namespace ICSharpCode.NRefactory.CSharp
 				var result = new DoWhileStatement();
 				var location = LocationsBag.GetLocations(doStatement);
 				result.AddChild(new CSharpTokenNode(Convert(doStatement.loc), DoWhileStatement.DoKeywordRole), DoWhileStatement.DoKeywordRole);
-				if (doStatement.EmbeddedStatement != null)
-					result.AddChild((Statement)doStatement.EmbeddedStatement.Accept(this), Roles.EmbeddedStatement);
+				if (doStatement.Statement != null)
+					result.AddChild((Statement)doStatement.Statement.Accept(this), Roles.EmbeddedStatement);
 				if (location != null)
 					result.AddChild(new CSharpTokenNode(Convert(location [0]), DoWhileStatement.WhileKeywordRole), DoWhileStatement.WhileKeywordRole);
 				if (location != null && location.Count > 1)
@@ -2811,14 +2811,17 @@ namespace ICSharpCode.NRefactory.CSharp
 						} else {
 							parent = ArrayInitializerExpression.CreateSingleElementInitializer();
 						}
-						for (int i = 0; i < collectionInit.Arguments.Count; i++) {
-							var arg = collectionInit.Arguments [i] as CollectionElementInitializer.ElementInitializerArgument;
-							if (arg == null)
-								continue;
-							parent.AddChild(
-								(Expression)arg.Expr.Accept(this),
-								Roles.Expression
-							);
+
+						if (collectionInit.Arguments != null) {
+							for (int i = 0; i < collectionInit.Arguments.Count; i++) {
+								var arg = collectionInit.Arguments [i] as CollectionElementInitializer.ElementInitializerArgument;
+								if (arg == null || arg.Expr == null)
+									continue;
+								parent.AddChild(
+									(Expression)arg.Expr.Accept(this),
+									Roles.Expression
+								);
+							}
 						}
 
 						if (!collectionInit.IsSingle) {

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/anonymous.cs

@@ -215,6 +215,11 @@ namespace Mono.CSharp {
 				hoisted_this.EmitAssign (ec, source, false, false);
 			}
 
+			protected override bool DoFlowAnalysis (FlowAnalysisContext fc)
+			{
+				return false;
+			}
+
 			protected override void CloneTo (CloneContext clonectx, Statement target)
 			{
 				// Nothing to clone
@@ -1345,13 +1350,6 @@ namespace Mono.CSharp {
 			if (!DoResolveParameters (ec))
 				return null;
 
-#if !STATIC
-			// FIXME: The emitted code isn't very careful about reachability
-			// so, ensure we have a 'ret' at the end
-			BlockContext bc = ec as BlockContext;
-			if (bc != null && bc.CurrentBranching != null && bc.CurrentBranching.CurrentUsageVector.IsUnreachable)
-				bc.NeedReturnLabel ();
-#endif
 			return this;
 		}
 
@@ -1527,12 +1525,28 @@ namespace Mono.CSharp {
 			}
 
 			var bc = ec as BlockContext;
-			if (bc != null)
+
+			if (bc != null) {
 				aec.AssignmentInfoOffset = bc.AssignmentInfoOffset;
+				aec.EnclosingLoop = bc.EnclosingLoop;
+				aec.EnclosingLoopOrSwitch = bc.EnclosingLoopOrSwitch;
+				aec.Switch = bc.Switch;
+			}
 
 			var errors = ec.Report.Errors;
 
-			bool res = Block.Resolve (ec.CurrentBranching, aec, null);
+			bool res = Block.Resolve (aec);
+
+			if (res && errors == ec.Report.Errors) {
+				MarkReachable (new Reachability ());
+
+				if (!CheckReachableExit (ec.Report)) {
+					return null;
+				}
+
+				if (bc != null)
+					bc.AssignmentInfoOffset = aec.AssignmentInfoOffset;
+			}
 
 			if (am != null && am.ReturnTypeInference != null) {
 				am.ReturnTypeInference.FixAllTypes (ec);
@@ -1563,6 +1577,47 @@ namespace Mono.CSharp {
 			return false;
 		}
 
+		bool CheckReachableExit (Report report)
+		{
+			if (block.HasReachableClosingBrace && ReturnType.Kind != MemberKind.Void) {
+				// FIXME: Flow-analysis on MoveNext generated code
+				if (!IsIterator) {
+					report.Error (1643, StartLocation,
+							"Not all code paths return a value in anonymous method of type `{0}'", GetSignatureForError ());
+
+					return false;
+				}
+			}
+
+			return true;
+		}
+
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			// We are reachable, mark block body reachable too
+			MarkReachable (new Reachability ());
+
+			CheckReachableExit (fc.Report);
+
+			var das = fc.BranchDefiniteAssignment ();
+			var prev_pb = fc.ParametersBlock;
+			fc.ParametersBlock = Block;
+			var da_ontrue = fc.DefiniteAssignmentOnTrue;
+			var da_onfalse = fc.DefiniteAssignmentOnFalse;
+
+			block.FlowAnalysis (fc);
+
+			fc.ParametersBlock = prev_pb;
+			fc.DefiniteAssignment = das;
+			fc.DefiniteAssignmentOnTrue = da_ontrue;
+			fc.DefiniteAssignmentOnFalse = da_onfalse;
+		}
+
+		public override void MarkReachable (Reachability rc)
+		{
+			block.MarkReachable (rc);
+		}
+
 		public void SetHasThisAccess ()
 		{
 			ExplicitBlock b = block;

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/argument.cs

@@ -127,6 +127,29 @@ namespace Mono.CSharp
 			return this;
 		}
 
+		public void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			if (ArgType == AType.Out) {
+				var vr = Expr as VariableReference;
+				if (vr != null) {
+					if (vr.VariableInfo != null)
+						fc.SetVariableAssigned (vr.VariableInfo);
+
+					return;
+				}
+
+				var fe = Expr as FieldExpr;
+				if (fe != null) {
+					fe.SetFieldAssigned (fc);
+					return;
+				}
+
+				return;
+			}
+
+			Expr.FlowAnalysis (fc);
+		}
+
 		public string GetSignatureForError ()
 		{
 			if (Expr.eclass == ExprClass.MethodGroup)
@@ -152,18 +175,16 @@ namespace Mono.CSharp
 
 		public void Resolve (ResolveContext ec)
 		{
-//			using (ec.With (ResolveContext.Options.DoFlowAnalysis, true)) {
-				// Verify that the argument is readable
-				if (ArgType != AType.Out)
-					Expr = Expr.Resolve (ec);
+			// Verify that the argument is readable
+			if (ArgType != AType.Out)
+				Expr = Expr.Resolve (ec);
 
-				// Verify that the argument is writeable
-				if (Expr != null && IsByRef)
-					Expr = Expr.ResolveLValue (ec, EmptyExpression.OutAccess);
+			// Verify that the argument is writeable
+			if (Expr != null && IsByRef)
+				Expr = Expr.ResolveLValue (ec, EmptyExpression.OutAccess);
 
-				if (Expr == null)
-					Expr = ErrorExpression.Instance;
-//			}
+			if (Expr == null)
+				Expr = ErrorExpression.Instance;
 		}
 	}
 
@@ -476,6 +497,29 @@ namespace Mono.CSharp
 			return null;
 		}
 
+		public void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			bool has_out = false;
+			foreach (var arg in args) {
+				if (arg.ArgType == Argument.AType.Out) {
+					has_out = true;
+					continue;
+				}
+
+				arg.FlowAnalysis (fc);
+			}
+
+			if (!has_out)
+				return;
+
+			foreach (var arg in args) {
+				if (arg.ArgType != Argument.AType.Out)
+					continue;
+
+				arg.FlowAnalysis (fc);
+			}
+		}
+
 		public List<Argument>.Enumerator GetEnumerator ()
 		{
 			return args.GetEnumerator ();

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/assembly.cs

@@ -54,6 +54,7 @@ namespace Mono.CSharp
 		bool is_cls_compliant;
 		bool wrap_non_exception_throws;
 		bool wrap_non_exception_throws_custom;
+		bool has_user_debuggable;
 
 		protected ModuleContainer module;
 		readonly string name;
@@ -366,6 +367,8 @@ namespace Mono.CSharp
 				vi_copyright = a.GetString ();
 			} else if (a.Type == pa.AssemblyTrademark) {
 				vi_trademark = a.GetString ();
+			} else if (a.Type == pa.Debuggable) {
+				has_user_debuggable = true;
 			}
 
 			SetCustomAttribute (ctor, cdata);
@@ -473,6 +476,17 @@ namespace Mono.CSharp
 			}
 
 			if (!IsSatelliteAssembly) {
+				if (!has_user_debuggable && Compiler.Settings.GenerateDebugInfo) {
+					var pa = module.PredefinedAttributes.Debuggable;
+					if (pa.IsDefined) {
+						var modes = System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints;
+						if (!Compiler.Settings.Optimize)
+							modes |= System.Diagnostics.DebuggableAttribute.DebuggingModes.DisableOptimizations;
+
+						pa.EmitAttribute (Builder, modes);
+					}
+				}
+
 				if (!wrap_non_exception_throws_custom) {
 					PredefinedAttribute pa = module.PredefinedAttributes.RuntimeCompatibility;
 					if (pa.IsDefined && pa.ResolveBuilder ()) {

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/assign.cs

@@ -363,7 +363,7 @@ namespace Mono.CSharp {
 			return this;
 		}
 
-#if NET_4_0 || MONODROID
+#if NET_4_0 || MOBILE_DYNAMIC
 		public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
 		{
 			var tassign = target as IDynamicAssign;
@@ -417,6 +417,14 @@ namespace Mono.CSharp {
 			Emit (ec, true);
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			source.FlowAnalysis (fc);
+
+			if (target is ArrayAccess || target is IndexerExpr || target is PropertyExpr)
+				target.FlowAnalysis (fc);
+		}
+
 		protected override void CloneTo (CloneContext clonectx, Expression t)
 		{
 			Assign _target = (Assign) t;
@@ -470,6 +478,32 @@ namespace Mono.CSharp {
 		{
 			return visitor.Visit (this);
 		}
+
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			base.FlowAnalysis (fc);
+
+			var vr = target as VariableReference;
+			if (vr != null) {
+				if (vr.VariableInfo != null)
+					fc.SetVariableAssigned (vr.VariableInfo);
+
+				return;
+			}
+
+			var fe = target as FieldExpr;
+			if (fe != null) {
+				fe.SetFieldAssigned (fc);
+				return;
+			}
+		}
+
+		public override void MarkReachable (Reachability rc)
+		{
+			var es = source as ExpressionStatement;
+			if (es != null)
+				es.MarkReachable (rc);
+		}
 	}
 
 	public class RuntimeExplicitAssign : Assign
@@ -526,20 +560,21 @@ namespace Mono.CSharp {
 		// share same constructor (block) for expression trees resolve but
 		// they have they own resolve scope
 		//
-		sealed class FieldInitializerContext : ResolveContext
+		sealed class FieldInitializerContext : BlockContext
 		{
-			ExplicitBlock ctor_block;
+			readonly ExplicitBlock ctor_block;
 
-			public FieldInitializerContext (IMemberContext mc, ResolveContext constructorContext)
-				: base (mc, Options.FieldInitializerScope | Options.ConstructorScope)
+			public FieldInitializerContext (IMemberContext mc, BlockContext constructorContext)
+				: base (mc, null, constructorContext.ReturnType)
 			{
+				flags |= Options.FieldInitializerScope | Options.ConstructorScope;
 				this.ctor_block = constructorContext.CurrentBlock.Explicit;
 			}
 
 			public override ExplicitBlock ConstructorBlock {
-				get {
-					return ctor_block;
-				}
+			    get {
+			        return ctor_block;
+			    }
 			}
 		}
 
@@ -557,21 +592,25 @@ namespace Mono.CSharp {
 				((FieldExpr)target).InstanceExpression = new CompilerGeneratedThis (mc.CurrentType, expression.Location);
 		}
 
+		public int AssignmentOffset { get; private set; }
+
 		public override Location StartLocation {
 			get {
 				return loc;
 			}
 		}
 
-		protected override Expression DoResolve (ResolveContext ec)
+		protected override Expression DoResolve (ResolveContext rc)
 		{
 			// Field initializer can be resolved (fail) many times
 			if (source == null)
 				return null;
 
+			var bc = (BlockContext) rc;
 			if (resolved == null) {
-				var ctx = new FieldInitializerContext (mc, ec);
+				var ctx = new FieldInitializerContext (mc, bc);
 				resolved = base.DoResolve (ctx) as ExpressionStatement;
+				AssignmentOffset = ctx.AssignmentInfoOffset - bc.AssignmentInfoOffset;
 			}
 
 			return resolved;
@@ -598,6 +637,11 @@ namespace Mono.CSharp {
 			else
 				base.EmitStatement (ec);
 		}
+
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			source.FlowAnalysis (fc);
+		}
 		
 		public bool IsDefaultInitializer {
 			get {
@@ -791,6 +835,12 @@ namespace Mono.CSharp {
 			return base.DoResolve (ec);
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			target.FlowAnalysis (fc);
+			source.FlowAnalysis (fc);
+		}
+
 		protected override Expression ResolveConversions (ResolveContext ec)
 		{
 			//

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/async.cs

@@ -71,8 +71,19 @@ namespace Mono.CSharp
 			return true;
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			stmt.Expr.FlowAnalysis (fc);
+
+			stmt.RegisterResumePoint ();
+		}
+
 		protected override Expression DoResolve (ResolveContext rc)
 		{
+			if (rc.HasSet (ResolveContext.Options.FinallyScope)) {
+				rc.Report.Error (1984, loc,  "The `await' operator cannot be used in the body of a finally clause");
+			}
+
 			if (rc.HasSet (ResolveContext.Options.LockScope)) {
 				rc.Report.Error (1996, loc,
 					"The `await' operator cannot be used in the body of a lock statement");
@@ -121,6 +132,12 @@ namespace Mono.CSharp
 			stmt.EmitStatement (ec);
 		}
 
+		public override void MarkReachable (Reachability rc)
+		{
+			base.MarkReachable (rc);
+			stmt.MarkReachable (rc);
+		}
+
 		public override object Accept (StructuralVisitor visitor)
 		{
 			return visitor.Visit (this);
@@ -181,6 +198,7 @@ namespace Mono.CSharp
 		public AwaitStatement (Expression expr, Location loc)
 			: base (expr, loc)
 		{
+			unwind_protect = true;
 		}
 
 		#region Properties
@@ -312,6 +330,10 @@ namespace Mono.CSharp
 				return false;
 			}
 
+			if (bc.HasSet (ResolveContext.Options.CatchScope)) {
+				bc.Report.Error (1985, loc, "The `await' operator cannot be used in the body of a catch clause");
+			}
+
 			if (!base.Resolve (bc))
 				return false;
 
@@ -369,6 +391,47 @@ namespace Mono.CSharp
 		}
 	}
 
+	class AsyncInitializerStatement : StatementExpression
+	{
+		public AsyncInitializerStatement (AsyncInitializer expr)
+			: base (expr)
+		{
+		}
+
+		protected override bool DoFlowAnalysis (FlowAnalysisContext fc)
+		{
+			base.DoFlowAnalysis (fc);
+
+			var init = (AsyncInitializer) Expr;
+			var res = !init.Block.HasReachableClosingBrace;
+			var storey = (AsyncTaskStorey) init.Storey;
+
+			if (storey.ReturnType.IsGenericTask)
+				return res;
+
+			return true;
+		}
+
+		public override Reachability MarkReachable (Reachability rc)
+		{
+			if (!rc.IsUnreachable)
+				reachable = true;
+
+			var init = (AsyncInitializer) Expr;
+			rc = init.Block.MarkReachable (rc);
+
+			var storey = (AsyncTaskStorey) init.Storey;
+
+			//
+			// Explicit return is required for Task<T> state machine
+			//
+			if (storey.ReturnType != null && storey.ReturnType.IsGenericTask)
+				return rc;
+
+		    return Reachability.CreateUnreachable ();
+		}
+	}
+
 	public class AsyncInitializer : StateMachineInitializer
 	{
 		TypeInferenceContext return_inference;
@@ -404,14 +467,15 @@ namespace Mono.CSharp
 
 		#endregion
 
-		protected override BlockContext CreateBlockContext (ResolveContext rc)
+		protected override BlockContext CreateBlockContext (BlockContext bc)
 		{
-			var ctx = base.CreateBlockContext (rc);
-			var lambda = rc.CurrentAnonymousMethod as LambdaMethod;
+			var ctx = base.CreateBlockContext (bc);
+			var lambda = bc.CurrentAnonymousMethod as LambdaMethod;
 			if (lambda != null)
 				return_inference = lambda.ReturnTypeInference;
 
-			ctx.StartFlowBranching (this, rc.CurrentBranching);
+			ctx.Set (ResolveContext.Options.TryScope);
+
 			return ctx;
 		}
 
@@ -432,6 +496,13 @@ namespace Mono.CSharp
 			storey.EmitInitializer (ec);
 			ec.Emit (OpCodes.Ret);
 		}
+
+		public override void MarkReachable (Reachability rc)
+		{
+			//
+			// Reachability has been done in AsyncInitializerStatement
+			//
+		}
 	}
 
 	class AsyncTaskStorey : StateMachine

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/attribute.cs

@@ -283,7 +283,8 @@ namespace Mono.CSharp {
 		/// </summary>
 		void ResolveAttributeType (bool comparisonOnly)
 		{
-			SessionReportPrinter resolve_printer = new SessionReportPrinter ();
+			var resolve_printer = new SessionReportPrinter ();
+			SessionReportPrinter secondary_printer = null;
 			ReportPrinter prev_recorder = Report.SetPrinter (resolve_printer);
 
 			bool t1_is_attr = false;
@@ -296,20 +297,25 @@ namespace Mono.CSharp {
 
 			try {
 				t1 = expression.ResolveAsType (context);
-				if (t1 != null)
-					t1_is_attr = t1.IsAttribute;
-
 				resolve_printer.EndSession ();
 
+				if (t1 != null && resolve_printer.ErrorsCount == 0)
+					t1_is_attr = t1.IsAttribute;
+
 				if (nameEscaped) {
 					t2 = null;
 				} else {
 					expanded = (ATypeNameExpression) expression.Clone (null);
 					expanded.Name += "Attribute";
 
+					secondary_printer = new SessionReportPrinter ();
+					Report.SetPrinter (secondary_printer);
 					t2 = expanded.ResolveAsType (context);
-					if (t2 != null)
+					secondary_printer.EndSession ();
+					if (t2 != null && secondary_printer.ErrorsCount == 0)
 						t2_is_attr = t2.IsAttribute;
+
+					secondary_printer.EndSession ();
 				}
 			} finally {
 				context.Module.Compiler.Report.SetPrinter (prev_recorder);
@@ -340,17 +346,25 @@ namespace Mono.CSharp {
 
 			resolve_error = true;
 
-			if (t1 != null) {
-				resolve_printer.Merge (prev_recorder);
+			if (t1 != null) {	
+				if (resolve_printer.IsEmpty) {
+					Report.SymbolRelatedToPreviousError (t1);
+					Report.Error (616, Location, "`{0}': is not an attribute class", t1.GetSignatureForError ());
+				} else {
+					resolve_printer.Merge (prev_recorder);
+				}
 
-				Report.SymbolRelatedToPreviousError (t1);
-				Report.Error (616, Location, "`{0}': is not an attribute class", t1.GetSignatureForError ());
 				return;
 			}
 
 			if (t2 != null) {
-				Report.SymbolRelatedToPreviousError (t2);
-				Report.Error (616, Location, "`{0}': is not an attribute class", t2.GetSignatureForError ());
+				if (secondary_printer.IsEmpty) {
+					Report.SymbolRelatedToPreviousError (t2);
+					Report.Error (616, Location, "`{0}': is not an attribute class", t2.GetSignatureForError ());
+				} else {
+					secondary_printer.Merge (prev_recorder);
+				}
+
 				return;
 			}
 
@@ -1670,6 +1684,7 @@ namespace Mono.CSharp {
 		public readonly PredefinedAttribute UnmanagedFunctionPointer;
 		public readonly PredefinedDebuggerBrowsableAttribute DebuggerBrowsable;
 		public readonly PredefinedAttribute DebuggerStepThrough;
+		public readonly PredefinedDebuggableAttribute Debuggable;
 
 		// New in .NET 3.5
 		public readonly PredefinedAttribute Extension;
@@ -1737,6 +1752,7 @@ namespace Mono.CSharp {
 			UnmanagedFunctionPointer = new PredefinedAttribute (module, "System.Runtime.InteropServices", "UnmanagedFunctionPointerAttribute");
 			DebuggerBrowsable = new PredefinedDebuggerBrowsableAttribute (module, "System.Diagnostics", "DebuggerBrowsableAttribute");
 			DebuggerStepThrough = new PredefinedAttribute (module, "System.Diagnostics", "DebuggerStepThroughAttribute");
+			Debuggable = new PredefinedDebuggableAttribute (module, "System.Diagnostics", "DebuggableAttribute");
 
 			Extension = new PredefinedAttribute (module, "System.Runtime.CompilerServices", "ExtensionAttribute");
 
@@ -1897,6 +1913,40 @@ namespace Mono.CSharp {
 		}
 	}
 
+	public class PredefinedDebuggableAttribute : PredefinedAttribute
+	{
+		public PredefinedDebuggableAttribute (ModuleContainer module, string ns, string name)
+			: base (module, ns, name)
+		{
+		}
+
+		public void EmitAttribute (AssemblyBuilder builder, System.Diagnostics.DebuggableAttribute.DebuggingModes modes)
+		{
+			var atype = module.PredefinedAttributes.Debuggable;
+			if (!atype.Define ())
+				return;
+
+			MethodSpec ctor = null;
+			foreach (MethodSpec m in MemberCache.FindMembers (atype.TypeSpec, CSharp.Constructor.ConstructorName, true)) {
+				if (m.Parameters.Count != 1)
+					continue;
+
+				if (m.Parameters.Types[0].Kind == MemberKind.Enum) {
+					ctor = m;
+				}
+			}
+
+			if (ctor == null)
+				return;
+
+			AttributeEncoder encoder = new AttributeEncoder ();
+			encoder.Encode ((int) modes);
+			encoder.EncodeEmptyNamedArguments ();
+
+			builder.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), encoder.ToArray ());
+		}
+	}
+
 	public class PredefinedDecimalAttribute : PredefinedAttribute
 	{
 		public PredefinedDecimalAttribute (ModuleContainer module, string ns, string name)

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/class.cs

@@ -13,6 +13,7 @@
 //
 
 using System;
+using System.Linq;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using System.Security;
@@ -698,6 +699,12 @@ namespace Mono.CSharp
 			}
 		}
 
+		bool ITypeDefinition.IsCyclicTypeForwarder {
+			get {
+				return false;
+			}
+		}
+
 		//
 		// Returns true for secondary partial containers
 		//
@@ -1014,6 +1021,7 @@ namespace Mono.CSharp
 					if (!has_complex_initializer && fi.IsDefaultInitializer)
 						continue;
 
+					ec.AssignmentInfoOffset += fi.AssignmentOffset;
 					ec.CurrentBlock.AddScopeStatement (new StatementExpression (init [i]));
 				}
 
@@ -1035,6 +1043,7 @@ namespace Mono.CSharp
 				if (fi.IsDefaultInitializer && ec.Module.Compiler.Settings.Optimize)
 					continue;
 
+				ec.AssignmentInfoOffset += fi.AssignmentOffset;
 				ec.CurrentBlock.AddScopeStatement (new StatementExpression (s));
 			}
 		}
@@ -2400,8 +2409,6 @@ namespace Mono.CSharp
 		//
 		// Public function used to locate types.
 		//
-		// Set 'ignore_cs0104' to true if you want to ignore cs0104 errors.
-		//
 		// Returns: Type or null if they type can not be found.
 		//
 		public override FullNamedExpression LookupNamespaceOrType (string name, int arity, LookupMode mode, Location loc)
@@ -2768,6 +2775,17 @@ namespace Mono.CSharp
 			}
 		}
 
+		public override void GetCompletionStartingWith (string prefix, List<string> results)
+		{
+			base.GetCompletionStartingWith (prefix, results);
+
+			var bt = base_type;
+			while (bt != null) {
+				results.AddRange (MemberCache.GetCompletitionMembers (this, bt, prefix).Where (l => l.IsStatic).Select (l => l.Name));
+				bt = bt.BaseType;
+			}
+		}
+
 		protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class)
 		{
 			var ifaces = base.ResolveBaseTypes (out base_class);

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/codegen.cs

@@ -968,10 +968,6 @@ namespace Mono.CSharp
 
 		public void Emit (EmitContext ec, MethodSpec method, Arguments Arguments, Location loc)
 		{
-			// Speed up the check by not doing it on not allowed targets
-			if (method.ReturnType.Kind == MemberKind.Void && method.IsConditionallyExcluded (ec.MemberContext))
-				return;
-
 			EmitPredefined (ec, method, Arguments, loc);
 		}
 

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/complete.cs

@@ -114,32 +114,22 @@ namespace Mono.CSharp {
 			var sn = expr as SimpleName;
 			const ResolveFlags flags = ResolveFlags.VariableOrValue | ResolveFlags.Type;
 
-			//
-			// Resolve the expression with flow analysis turned off, we'll do the definite
-			// assignment checks later.  This is because we don't know yet what the expression
-			// will resolve to - it may resolve to a FieldExpr and in this case we must do the
-			// definite assignment check on the actual field and not on the whole struct.
-			//
-			using (rc.Set (ResolveContext.Options.OmitStructFlowAnalysis)) {
-				if (sn != null) {
-					expr = sn.LookupNameExpression (rc, MemberLookupRestrictions.ReadAccess | MemberLookupRestrictions.ExactArity);
-
-					//
-					// Resolve expression which does have type set as we need expression type
-					// with disable flow analysis as we don't know whether left side expression
-					// is used as variable or type
-					//
-					if (expr is VariableReference || expr is ConstantExpr || expr is Linq.TransparentMemberAccess) {
-						using (rc.With (ResolveContext.Options.DoFlowAnalysis, false)) {
-							expr = expr.Resolve (rc);
-						}
-					} else if (expr is TypeParameterExpr) {
-						expr.Error_UnexpectedKind (rc, flags, sn.Location);
-						expr = null;
-					}
-				} else {
-					expr = expr.Resolve (rc, flags);
+			if (sn != null) {
+				expr = sn.LookupNameExpression (rc, MemberLookupRestrictions.ReadAccess | MemberLookupRestrictions.ExactArity);
+
+				//
+				// Resolve expression which does have type set as we need expression type
+				// with disable flow analysis as we don't know whether left side expression
+				// is used as variable or type
+				//
+				if (expr is VariableReference || expr is ConstantExpr || expr is Linq.TransparentMemberAccess) {
+					expr = expr.Resolve (rc);
+				} else if (expr is TypeParameterExpr) {
+					expr.Error_UnexpectedKind (rc, flags, sn.Location);
+					expr = null;
 				}
+			} else {
+				expr = expr.Resolve (rc, flags);
 			}
 
 			if (expr == null)

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/context.cs

@@ -69,8 +69,6 @@ namespace Mono.CSharp
 	//
 	public class BlockContext : ResolveContext
 	{
-		FlowBranching current_flow_branching;
-
 		readonly TypeSpec return_type;
 
 		//
@@ -99,6 +97,9 @@ namespace Mono.CSharp
 			if (rc.HasSet (ResolveContext.Options.CheckedScope))
 				flags |= ResolveContext.Options.CheckedScope;
 
+			if (!rc.ConstantCheckState)
+				flags &= ~Options.ConstantCheckState;
+
 			if (rc.IsInProbingMode)
 				flags |= ResolveContext.Options.ProbingMode;
 
@@ -112,124 +113,17 @@ namespace Mono.CSharp
 				flags |= ResolveContext.Options.BaseInitializer;
 		}
 
-		public override FlowBranching CurrentBranching {
-			get { return current_flow_branching; }
-		}
+		public ExceptionStatement CurrentTryBlock { get; set; }
 
-		public TypeSpec ReturnType {
-			get { return return_type; }
-		}
+		public LoopStatement EnclosingLoop { get; set; }
 
-		public bool IsUnreachable {
-			get {
-				return HasSet (Options.UnreachableScope);
-			}
-			set {
-				flags = value ? flags | Options.UnreachableScope : flags & ~Options.UnreachableScope;
-			}
-		}
+		public LoopStatement EnclosingLoopOrSwitch { get; set; }
 
-		public bool UnreachableReported {
-			get {
-				return HasSet (Options.UnreachableReported);
-			}
-			set {
-				flags = value ? flags | Options.UnreachableReported : flags & ~Options.UnreachableScope;
-			}
-		}
-
-		// <summary>
-		//   Starts a new code branching.  This inherits the state of all local
-		//   variables and parameters from the current branching.
-		// </summary>
-		public FlowBranching StartFlowBranching (FlowBranching.BranchingType type, Location loc)
-		{
-			current_flow_branching = FlowBranching.CreateBranching (CurrentBranching, type, null, loc);
-			return current_flow_branching;
-		}
-
-		// <summary>
-		//   Starts a new code branching for block `block'.
-		// </summary>
-		public FlowBranching StartFlowBranching (Block block)
-		{
-			Set (Options.DoFlowAnalysis);
+		public Switch Switch { get; set; }
 
-			current_flow_branching = FlowBranching.CreateBranching (
-				CurrentBranching, FlowBranching.BranchingType.Block, block, block.StartLocation);
-			return current_flow_branching;
-		}
-
-		public FlowBranchingTryCatch StartFlowBranching (TryCatch stmt)
-		{
-			FlowBranchingTryCatch branching = new FlowBranchingTryCatch (CurrentBranching, stmt);
-			current_flow_branching = branching;
-			return branching;
-		}
-
-		public FlowBranchingTryFinally StartFlowBranching (TryFinallyBlock stmt)
-		{
-			FlowBranchingTryFinally branching = new FlowBranchingTryFinally (CurrentBranching, stmt);
-			current_flow_branching = branching;
-			return branching;
-		}
-
-		public FlowBranchingLabeled StartFlowBranching (LabeledStatement stmt)
-		{
-			FlowBranchingLabeled branching = new FlowBranchingLabeled (CurrentBranching, stmt);
-			current_flow_branching = branching;
-			return branching;
-		}
-
-		public FlowBranchingIterator StartFlowBranching (Iterator iterator, FlowBranching parent)
-		{
-			FlowBranchingIterator branching = new FlowBranchingIterator (parent, iterator);
-			current_flow_branching = branching;
-			return branching;
-		}
-
-		public FlowBranchingAsync StartFlowBranching (AsyncInitializer asyncBody, FlowBranching parent)
-		{
-			var branching = new FlowBranchingAsync (parent, asyncBody);
-			current_flow_branching = branching;
-			return branching;
-		}
-
-		public FlowBranchingToplevel StartFlowBranching (ParametersBlock stmt, FlowBranching parent)
-		{
-			FlowBranchingToplevel branching = new FlowBranchingToplevel (parent, stmt);
-			current_flow_branching = branching;
-			return branching;
-		}
-
-		// <summary>
-		//   Ends a code branching.  Merges the state of locals and parameters
-		//   from all the children of the ending branching.
-		// </summary>
-		public bool EndFlowBranching ()
-		{
-			FlowBranching old = current_flow_branching;
-			current_flow_branching = current_flow_branching.Parent;
-
-			FlowBranching.UsageVector vector = current_flow_branching.MergeChild (old);
-			return vector.IsUnreachable;
-		}
-
-		// <summary>
-		//   Kills the current code branching.  This throws away any changed state
-		//   information and should only be used in case of an error.
-		// </summary>
-		// FIXME: this is evil
-		public void KillFlowBranching ()
-		{
-			current_flow_branching = current_flow_branching.Parent;
-		}
-
-#if !STATIC
-		public void NeedReturnLabel ()
-		{
+		public TypeSpec ReturnType {
+			get { return return_type; }
 		}
-#endif
 	}
 
 	//
@@ -290,20 +184,9 @@ namespace Mono.CSharp
 
 			LockScope = 1 << 13,
 
-			UnreachableScope = 1 << 14,
+			TryScope = 1 << 14,
 
-			UnreachableReported = 1 << 15,
-
-			/// <summary>
-			///   Whether control flow analysis is enabled
-			/// </summary>
-			DoFlowAnalysis = 1 << 20,
-
-			/// <summary>
-			///   Whether control flow analysis is disabled on structs
-			///   (only meaningful when DoFlowAnalysis is set)
-			/// </summary>
-			OmitStructFlowAnalysis = 1 << 21,
+			TryWithCatchScope = 1 << 15,
 
 			///
 			/// Indicates the current context is in probing mode, no errors are reported. 
@@ -372,11 +255,6 @@ namespace Mono.CSharp
 
 		public readonly IMemberContext MemberContext;
 
-		/// <summary>
-		///   If this is non-null, points to the current switch statement
-		/// </summary>
-		public Switch Switch;
-
 		public ResolveContext (IMemberContext mc)
 		{
 			if (mc == null)
@@ -416,10 +294,6 @@ namespace Mono.CSharp
 			}
 		}
 
-		public virtual FlowBranching CurrentBranching {
-			get { return null; }
-		}
-
 		//
 		// The current iterator
 		//
@@ -443,10 +317,6 @@ namespace Mono.CSharp
 			get { return (flags & Options.ConstantCheckState) != 0; }
 		}
 
-		public bool DoFlowAnalysis {
-			get { return (flags & Options.DoFlowAnalysis) != 0; }
-		}
-
 		public bool IsInProbingMode {
 			get {
 				return (flags & Options.ProbingMode) != 0;
@@ -480,7 +350,7 @@ namespace Mono.CSharp
 
 		public bool IsVariableCapturingRequired {
 			get {
-				return !IsInProbingMode && (CurrentBranching == null || !CurrentBranching.CurrentUsageVector.IsUnreachable);
+				return !IsInProbingMode;
 			}
 		}
 
@@ -490,10 +360,6 @@ namespace Mono.CSharp
 			}
 		}
 
-		public bool OmitStructFlowAnalysis {
-			get { return (flags & Options.OmitStructFlowAnalysis) != 0; }
-		}
-
 		public Report Report {
 			get {
 				return Module.Compiler.Report;
@@ -573,6 +439,72 @@ namespace Mono.CSharp
 		#endregion
 	}
 
+	public class FlowAnalysisContext
+	{
+		readonly CompilerContext ctx;
+
+		public FlowAnalysisContext (CompilerContext ctx, ParametersBlock parametersBlock, int definiteAssignmentLength)
+		{
+			this.ctx = ctx;
+			this.ParametersBlock = parametersBlock;
+
+			DefiniteAssignment = definiteAssignmentLength == 0 ?
+				DefiniteAssignmentBitSet.Empty :
+				new DefiniteAssignmentBitSet (definiteAssignmentLength);
+		}
+
+		public DefiniteAssignmentBitSet DefiniteAssignment { get; set; }
+
+		public DefiniteAssignmentBitSet DefiniteAssignmentOnTrue { get; set; }
+
+		public DefiniteAssignmentBitSet DefiniteAssignmentOnFalse { get; set; }
+
+		public List<LabeledStatement> LabelStack { get; set; }
+
+		public ParametersBlock ParametersBlock { get; set; }
+
+		public Report Report {
+			get {
+				return ctx.Report;
+			}
+		}
+
+		public DefiniteAssignmentBitSet SwitchInitialDefinitiveAssignment { get; set; }
+
+		public TryFinally TryFinally { get; set; }
+
+		public bool UnreachableReported { get; set; }
+
+		public DefiniteAssignmentBitSet BranchDefiniteAssignment ()
+		{
+			var dat = DefiniteAssignment;
+			if (dat != DefiniteAssignmentBitSet.Empty)
+				DefiniteAssignment = new DefiniteAssignmentBitSet (dat);
+			return dat;
+		}
+
+		public bool IsDefinitelyAssigned (VariableInfo variable)
+		{
+			return variable.IsAssigned (DefiniteAssignment);
+		}
+
+		public bool IsStructFieldDefinitelyAssigned (VariableInfo variable, string name)
+		{
+			return variable.IsStructFieldAssigned (DefiniteAssignment, name);
+		}
+
+		public void SetVariableAssigned (VariableInfo variable, bool generatedAssignment = false)
+		{
+			variable.SetAssigned (DefiniteAssignment, generatedAssignment);
+		}
+
+		public void SetStructFieldAssigned (VariableInfo variable, string name)
+		{
+			variable.SetStructFieldAssigned (DefiniteAssignment, name);
+		}
+	}
+
+
 	//
 	// This class is used during the Statement.Clone operation
 	// to remap objects that have been cloned.
@@ -686,8 +618,12 @@ namespace Mono.CSharp
 
 			string path;
 			if (!Path.IsPathRooted (name)) {
-				string root = Path.GetDirectoryName (comp_unit.SourceFile.FullPathName);
-				path = Path.Combine (root, name);
+				var loc = comp_unit.SourceFile;
+				string root = Path.GetDirectoryName (loc.FullPathName);
+				path = Path.GetFullPath (Path.Combine (root, name));
+				var dir = Path.GetDirectoryName (loc.Name);
+				if (!string.IsNullOrEmpty (dir))
+					name = Path.Combine (dir, name);
 			} else
 				path = name;
 

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/convert.cs

@@ -2201,7 +2201,7 @@ namespace Mono.CSharp {
 				target = TypeManager.GetTypeArguments (target_type) [0];
 				e = ExplicitConversionCore (ec, expr, target, loc);
 				if (e != null)
-					return Nullable.Wrap.Create (e, target_type);
+					return TypeSpec.IsReferenceType (expr.Type) ? new UnboxCast (expr, target_type) : Nullable.Wrap.Create (e, target_type);
 			} else if (expr_type.IsNullableType) {
 				e = ImplicitBoxingConversion (expr, Nullable.NullableInfo.GetUnderlyingType (expr_type), target_type);
 				if (e != null)

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/cs-parser.jay

@@ -141,7 +141,7 @@ namespace Mono.CSharp
 		//
 		LocationsBag lbag;
 		List<Tuple<Modifiers, Location>> mod_locations;
-		Location parameterModifierLocation, savedLocation, savedOpenLocation, savedCloseLocation, savedEventAssignLocation;
+		Location parameterModifierLocation, savedLocation, savedEventAssignLocation;
 		Location savedAttrParenOpenLocation, savedAttrParenCloseLocation, savedOperatorLocation;
 		Stack<List<Location>> locationListStack = new Stack<List<Location>> (); // used for type parameters
 		Stack<Location> opt_intoStack = new Stack<Location> ();
@@ -2664,6 +2664,8 @@ enum_declaration
 	  }
 	  opt_enum_member_declarations
 	  {
+		lexer.parsing_modifiers = true;
+	  
 	  	// here will be evaluated after CLOSE_BLACE is consumed.
 		if (doc_support)
 			Lexer.doc_state = XmlCommentState.Allowed;
@@ -6078,12 +6080,12 @@ try_statement
 	  }
 	| TRY block FINALLY block
 	  {
-		$$ = new TryFinally ((Statement) $2, (Block) $4, GetLocation ($1));
+		$$ = new TryFinally ((Statement) $2, (ExplicitBlock) $4, GetLocation ($1));
 		lbag.AddStatement ($$, GetLocation ($3));
 	  }
 	| TRY block catch_clauses FINALLY block
 	  {
-		$$ = new TryFinally (new TryCatch ((Block) $2, (List<Catch>) $3, GetLocation ($1), true), (Block) $5, GetLocation ($1));
+		$$ = new TryFinally (new TryCatch ((Block) $2, (List<Catch>) $3, GetLocation ($1), true), (ExplicitBlock) $5, GetLocation ($1));
 		lbag.AddStatement ($$, GetLocation ($4));
 	  }
 	| TRY block error
@@ -6123,12 +6125,12 @@ opt_identifier
 catch_clause 
 	: CATCH block
 	  {
-		$$ = new Catch ((Block) $2, GetLocation ($1));
+		$$ = new Catch ((ExplicitBlock) $2, GetLocation ($1));
 	  }
 	| CATCH open_parens_any type opt_identifier CLOSE_PARENS
 	  {
 		start_block (GetLocation ($2));
-		var c = new Catch (current_block, GetLocation ($1));
+		var c = new Catch ((ExplicitBlock) current_block, GetLocation ($1));
 		c.TypeExpression = (FullNamedExpression) $3;
 
 		if ($4 != null) {

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/delegate.cs

@@ -532,7 +532,7 @@ namespace Mono.CSharp {
 				}
 			}
 
-			TypeSpec rt = delegate_method.ReturnType;
+			TypeSpec rt = method_group.BestCandidateReturnType;
 			if (rt.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
 				rt = ec.BuiltinTypes.Object;
 
@@ -541,7 +541,7 @@ namespace Mono.CSharp {
 				Error_ConversionFailed (ec, delegate_method, ret_expr);
 			}
 
-			if (delegate_method.IsConditionallyExcluded (ec)) {
+			if (method_group.IsConditionallyExcluded) {
 				ec.Report.SymbolRelatedToPreviousError (delegate_method);
 				MethodOrOperator m = delegate_method.MemberDefinition as MethodOrOperator;
 				if (m != null && m.IsPartialDefinition) {
@@ -681,6 +681,25 @@ namespace Mono.CSharp {
 
 			return false;
 		}
+		
+		bool HasMvar ()
+		{
+			if (ContainsMethodTypeParameter (type))
+				return false;
+
+			var best = method_group.BestCandidate;
+			if (ContainsMethodTypeParameter (best.DeclaringType))
+				return false;
+
+			if (best.TypeArguments != null) {
+				foreach (var ta in best.TypeArguments) {
+					if (ContainsMethodTypeParameter (ta))
+						return false;
+				}
+			}
+
+			return true;
+		}
 
 		protected override Expression DoResolve (ResolveContext ec)
 		{
@@ -700,10 +719,7 @@ namespace Mono.CSharp {
 			//
 			// Cannot easily cache types with MVAR
 			//
-			if (ContainsMethodTypeParameter (type))
-				return expr;
-
-			if (ContainsMethodTypeParameter (method_group.BestCandidate.DeclaringType))
+			if (!HasMvar ())
 				return expr;
 
 			//
@@ -828,6 +844,13 @@ namespace Mono.CSharp {
 			return CreateExpressionFactoryCall (ec, "Invoke", args);
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			InstanceExpr.FlowAnalysis (fc);
+			if (arguments != null)
+				arguments.FlowAnalysis (fc);
+		}
+
 		protected override Expression DoResolve (ResolveContext ec)
 		{		
 			TypeSpec del_type = InstanceExpr.Type;

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/driver.cs

@@ -332,6 +332,7 @@ namespace Mono.CSharp
 			tr.Start (TimeReporter.TimerType.CreateTypeTotal);
 			module.CreateContainer ();
 			importer.AddCompiledAssembly (assembly);
+			references_loader.CompiledAssembly = assembly;
 			tr.Stop (TimeReporter.TimerType.CreateTypeTotal);
 
 			references_loader.LoadReferences (module);

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/dynamic.cs

@@ -13,7 +13,7 @@ using System;
 using System.Linq;
 using SLE = System.Linq.Expressions;
 
-#if NET_4_0 || MONODROID
+#if NET_4_0 || MOBILE_DYNAMIC
 using System.Dynamic;
 #endif
 
@@ -63,7 +63,7 @@ namespace Mono.CSharp
 	//
 	public class RuntimeValueExpression : Expression, IDynamicAssign, IMemoryLocation
 	{
-#if !NET_4_0 && !MONODROID
+#if !NET_4_0 && !MOBILE_DYNAMIC
 		public class DynamicMetaObject
 		{
 			public TypeSpec RuntimeType;
@@ -146,7 +146,7 @@ namespace Mono.CSharp
 			return base.MakeExpression (ctx);
 #else
 
-#if NET_4_0 || MONODROID
+#if NET_4_0 || MOBILE_DYNAMIC
 				if (type.IsStruct && !obj.Expression.Type.IsValueType)
 					return SLE.Expression.Unbox (obj.Expression, type.GetMetaInfo ());
 
@@ -181,7 +181,7 @@ namespace Mono.CSharp
 			return this;
 		}
 
-#if NET_4_0 || MONODROID
+#if NET_4_0 || MOBILE_DYNAMIC
 		public override SLE.Expression MakeExpression (BuilderContext ctx)
 		{
 #if STATIC
@@ -450,6 +450,14 @@ namespace Mono.CSharp
 				d.PrepareEmit ();
 
 				site.AddTypeContainer (d);
+
+				//
+				// Add new container to inflated site container when the
+				// member cache already exists
+				//
+				if (site.CurrentType is InflatedTypeSpec && index > 0)
+					site.CurrentType.MemberCache.AddMember (d.CurrentType);
+
 				del_type = new TypeExpression (d.CurrentType, loc);
 				if (targs_for_instance != null) {
 					del_type_instance_access = null;
@@ -532,6 +540,11 @@ namespace Mono.CSharp
 			}
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			arguments.FlowAnalysis (fc);
+		}
+
 		public static MemberAccess GetBinderNamespace (Location loc)
 		{
 			return new MemberAccess (new MemberAccess (
@@ -612,6 +625,11 @@ namespace Mono.CSharp
 				stmt.Emit (ec);
 			}
 		}
+
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			invoke.FlowAnalysis (fc);
+		}
 	}
 
 	class DynamicConversion : DynamicExpressionStatement, IDynamicBinder

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/ecore.cs

@@ -712,13 +712,20 @@ namespace Mono.CSharp {
 		{
 			var ctors = MemberCache.FindMembers (type, Constructor.ConstructorName, true);
 			if (ctors == null) {
-				rc.Report.SymbolRelatedToPreviousError (type);
-				if (type.IsStruct) {
+				switch (type.Kind) {
+				case MemberKind.Struct:
+					rc.Report.SymbolRelatedToPreviousError (type);
 					// Report meaningful error for struct as they always have default ctor in C# context
 					OverloadResolver.Error_ConstructorMismatch (rc, type, args == null ? 0 : args.Count, loc);
-				} else {
+					break;
+				case MemberKind.MissingType:
+				case MemberKind.InternalCompilerType:
+					break;
+				default:
+					rc.Report.SymbolRelatedToPreviousError (type);
 					rc.Report.Error (143, loc, "The class `{0}' has no constructors defined",
 						type.GetSignatureForError ());
+					break;
 				}
 
 				return null;
@@ -923,6 +930,10 @@ namespace Mono.CSharp {
 			ec.Report.Error (1944, loc, "An expression tree cannot contain an unsafe pointer operation");
 		}
 
+		public virtual void FlowAnalysis (FlowAnalysisContext fc)
+		{
+		}
+
 		/// <summary>
 		///   Returns an expression that can be used to invoke operator true
 		///   on the expression if it exists.
@@ -1047,7 +1058,7 @@ namespace Mono.CSharp {
 		//
 		// Converts `source' to an int, uint, long or ulong.
 		//
-		protected Expression ConvertExpressionToArrayIndex (ResolveContext ec, Expression source)
+		protected Expression ConvertExpressionToArrayIndex (ResolveContext ec, Expression source, bool pointerArray = false)
 		{
 			var btypes = ec.BuiltinTypes;
 
@@ -1074,6 +1085,9 @@ namespace Mono.CSharp {
 				}
 			}
 
+			if (pointerArray)
+				return converted;
+
 			//
 			// Only positive constants are allowed at compile time
 			//
@@ -1175,6 +1189,10 @@ namespace Mono.CSharp {
 	/// </summary>
 	public abstract class ExpressionStatement : Expression
 	{
+		public virtual void MarkReachable (Reachability rc)
+		{
+		}
+
 		public ExpressionStatement ResolveStatement (BlockContext ec)
 		{
 			Expression e = Resolve (ec);
@@ -1182,7 +1200,7 @@ namespace Mono.CSharp {
 				return null;
 
 			ExpressionStatement es = e as ExpressionStatement;
-			if (es == null)
+			if (es == null || e is AnonymousMethodBody)
 				Error_InvalidExpressionStatement (ec);
 
 			//
@@ -1310,6 +1328,11 @@ namespace Mono.CSharp {
 			child.Emit (ec);
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			child.FlowAnalysis (fc);
+		}
+
 		public override SLE.Expression MakeExpression (BuilderContext ctx)
 		{
 #if STATIC
@@ -2141,6 +2164,11 @@ namespace Mono.CSharp {
 			{
 				stm.EmitStatement (ec);
 			}
+
+			public override void FlowAnalysis (FlowAnalysisContext fc)
+			{
+				stm.FlowAnalysis (fc);
+			}
 		}
 
 		readonly Expression expr, orig_expr;
@@ -2244,6 +2272,11 @@ namespace Mono.CSharp {
 			expr.EmitBranchable (ec, target, on_true);
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			expr.FlowAnalysis (fc);
+		}
+
 		public override SLE.Expression MakeExpression (BuilderContext ctx)
 		{
 			return orig_expr.MakeExpression (ctx);
@@ -2339,7 +2372,38 @@ namespace Mono.CSharp {
 		{
 			throw new InternalErrorException ("Missing Resolve call");
 		}
+	}
 
+	public class UnreachableExpression : Expression
+	{
+		public UnreachableExpression (Expression expr)
+		{
+			this.loc = expr.Location;
+		}
+
+		public override Expression CreateExpressionTree (ResolveContext ec)
+		{
+			// TODO: is it ok
+			throw new NotImplementedException ();
+		}
+
+		protected override Expression DoResolve (ResolveContext rc)
+		{
+			throw new NotSupportedException ();
+		}
+
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			fc.Report.Warning (429, 4, loc, "Unreachable expression code detected");
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+		}
+
+		public override void EmitBranchable (EmitContext ec, Label target, bool on_true)
+		{
+		}
 	}
 
 	//
@@ -2470,14 +2534,7 @@ namespace Mono.CSharp {
 
 		protected override Expression DoResolve (ResolveContext rc)
 		{
-			var e = SimpleNameResolve (rc, null);
-
-			var fe = e as FieldExpr;
-			if (fe != null) {
-				fe.VerifyAssignedStructField (rc, null);
-			}
-
-			return e;
+			return SimpleNameResolve (rc, null);
 		}
 
 		public override Expression DoResolveLValue (ResolveContext ec, Expression right_side)
@@ -3167,6 +3224,12 @@ namespace Mono.CSharp {
 				member.GetSignatureForError (), qualifier.GetSignatureForError (), rc.CurrentType.GetSignatureForError ());
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			if (InstanceExpression != null)
+				InstanceExpression.FlowAnalysis (fc);
+		}
+
 		public bool ResolveInstanceExpression (ResolveContext rc, Expression rhs)
 		{
 			if (!ResolveInstanceExpressionCore (rc, rhs))
@@ -3188,7 +3251,11 @@ namespace Mono.CSharp {
 						rc.Report.Error (1648, loc, "Members of readonly field `{0}' cannot be modified (except in a constructor or a variable initializer)",
 							fexpr.GetSignatureForError ());
 					}
-				} else if (InstanceExpression is PropertyExpr || InstanceExpression is IndexerExpr || InstanceExpression is Invocation) {
+
+					return true;
+				}
+
+				if (InstanceExpression is PropertyExpr || InstanceExpression is IndexerExpr || InstanceExpression is Invocation) {
 					if (rc.CurrentInitializerVariable != null) {
 						rc.Report.Error (1918, loc, "Members of value type `{0}' cannot be assigned using a property `{1}' object initializer",
 							InstanceExpression.Type.GetSignatureForError (), InstanceExpression.GetSignatureForError ());
@@ -3197,6 +3264,18 @@ namespace Mono.CSharp {
 							"Cannot modify a value type return value of `{0}'. Consider storing the value in a temporary variable",
 							InstanceExpression.GetSignatureForError ());
 					}
+
+					return true;
+				}
+
+				var lvr = InstanceExpression as LocalVariableReference;
+				if (lvr != null) {
+
+					if (!lvr.local_info.IsReadonly)
+						return true;
+
+					rc.Report.Error (1654, loc, "Cannot assign to members of `{0}' because it is a `{1}'",
+						InstanceExpression.GetSignatureForError (), lvr.local_info.GetReadOnlyContext ());
 				}
 			}
 
@@ -3253,15 +3332,7 @@ namespace Mono.CSharp {
 						DeclaringType.GetSignatureForError (), rc.CurrentType.GetSignatureForError ());
 				}
 
-				InstanceExpression = new This (loc);
-				if (this is FieldExpr && rc.CurrentBlock.ParametersBlock.TopBlock.ThisVariable != null) {
-					using (rc.Set (ResolveContext.Options.OmitStructFlowAnalysis)) {
-						InstanceExpression = InstanceExpression.Resolve (rc);
-					}
-				} else {
-					InstanceExpression = InstanceExpression.Resolve (rc);
-				}
-
+				InstanceExpression = new This (loc).Resolve (rc);
 				return false;
 			}
 
@@ -3269,29 +3340,17 @@ namespace Mono.CSharp {
 			if (me != null) {
 				me.ResolveInstanceExpressionCore (rc, rhs);
 
-				// Using this check to detect probing instance expression resolve
-				if (!rc.OmitStructFlowAnalysis) {
-					var fe = me as FieldExpr;
-					if (fe != null && fe.IsMarshalByRefAccess (rc)) {
-						rc.Report.SymbolRelatedToPreviousError (me.DeclaringType);
-						rc.Report.Warning (1690, 1, loc,
-							"Cannot call methods, properties, or indexers on `{0}' because it is a value type member of a marshal-by-reference class",
-							me.GetSignatureForError ());
-					}
+				var fe = me as FieldExpr;
+				if (fe != null && fe.IsMarshalByRefAccess (rc)) {
+					rc.Report.SymbolRelatedToPreviousError (me.DeclaringType);
+					rc.Report.Warning (1690, 1, loc,
+						"Cannot call methods, properties, or indexers on `{0}' because it is a value type member of a marshal-by-reference class",
+						me.GetSignatureForError ());
 				}
 
 				return true;
 			}
 
-			//
-			// Run member-access postponed check once we know that
-			// the expression is not field expression which is the only
-			// expression which can use uninitialized this
-			//
-			if (InstanceExpression is This && !(this is FieldExpr) && rc.CurrentBlock.ParametersBlock.TopBlock.ThisVariable != null) {
-				((This)InstanceExpression).CheckStructThisDefiniteAssignment (rc);
-			}
-
 			//
 			// Additional checks for l-value member access
 			//
@@ -3506,6 +3565,8 @@ namespace Mono.CSharp {
 	/// </summary>
 	public class MethodGroupExpr : MemberExpr, OverloadResolver.IBaseMembersProvider
 	{
+		static readonly MemberSpec[] Excluded = new MemberSpec[0];
+
 		protected IList<MemberSpec> Methods;
 		MethodSpec best_candidate;
 		TypeSpec best_candidate_return;
@@ -3555,6 +3616,12 @@ namespace Mono.CSharp {
 			}
 		}
 
+		public bool IsConditionallyExcluded {
+			get {
+				return Methods == Excluded;
+			}
+		}
+
 		public override bool IsInstance {
 			get {
 				if (best_candidate != null)
@@ -3624,7 +3691,7 @@ namespace Mono.CSharp {
 				return null;
 			}
 
-			if (best_candidate.IsConditionallyExcluded (ec))
+			if (IsConditionallyExcluded)
 				ec.Report.Error (765, loc,
 					"Partial methods with only a defining declaration or removed conditional methods cannot be used in an expression tree");
 			
@@ -3749,6 +3816,10 @@ namespace Mono.CSharp {
 				ErrorIsInaccesible (ec, best_candidate.GetSignatureForError (), loc);
 			}
 
+			// Speed up the check by not doing it on disallowed targets
+			if (best_candidate_return.Kind == MemberKind.Void && best_candidate.IsConditionallyExcluded (ec))
+				Methods = Excluded;
+
 			return this;
 		}
 
@@ -5685,18 +5756,14 @@ namespace Mono.CSharp {
 					// "a.b" is initialized, not whether the whole struct "a" is initialized.
 
 					if (lvalue_instance) {
-						using (ec.With (ResolveContext.Options.DoFlowAnalysis, false)) {
-							bool out_access = rhs == EmptyExpression.OutAccess || rhs == EmptyExpression.LValueMemberOutAccess;
+						bool out_access = rhs == EmptyExpression.OutAccess || rhs == EmptyExpression.LValueMemberOutAccess;
 
-							Expression right_side =
-								out_access ? EmptyExpression.LValueMemberOutAccess : EmptyExpression.LValueMemberAccess;
+						Expression right_side =
+							out_access ? EmptyExpression.LValueMemberOutAccess : EmptyExpression.LValueMemberAccess;
 
-							InstanceExpression = InstanceExpression.ResolveLValue (ec, right_side);
-						}
+						InstanceExpression = InstanceExpression.ResolveLValue (ec, right_side);
 					} else {
-						using (ec.With (ResolveContext.Options.DoFlowAnalysis, false)) {
-							InstanceExpression = InstanceExpression.Resolve (ec, ResolveFlags.VariableOrValue);
-						}
+						InstanceExpression = InstanceExpression.Resolve (ec, ResolveFlags.VariableOrValue);
 					}
 
 					if (InstanceExpression == null)
@@ -5709,10 +5776,6 @@ namespace Mono.CSharp {
 			var fb = spec as FixedFieldSpec;
 			IVariableReference var = InstanceExpression as IVariableReference;
 
-			if (lvalue_instance && var != null && var.VariableInfo != null) {
-				var.VariableInfo.SetStructFieldAssigned (ec, Name);
-			}
-
 			if (fb != null) {
 				IFixedExpression fe = InstanceExpression as IFixedExpression;
 				if (!ec.HasSet (ResolveContext.Options.FixedInitializerScope) && (fe == null || !fe.IsFixed)) {
@@ -5736,15 +5799,50 @@ namespace Mono.CSharp {
 			//
 			if (var != null && var.VariableInfo != null && InstanceExpression.Type.IsStruct) {
 				variable_info = var.VariableInfo.GetStructFieldInfo (Name);
-				if (rhs != null && variable_info != null)
-					variable_info.SetStructFieldAssigned (ec, Name);
 			}
 
 			eclass = ExprClass.Variable;
 			return this;
 		}
 
-		public void VerifyAssignedStructField (ResolveContext rc, Expression rhs)
+		public void SetFieldAssigned (FlowAnalysisContext fc)
+		{
+			if (!IsInstance)
+				return;
+
+			bool lvalue_instance = spec.DeclaringType.IsStruct;
+			if (lvalue_instance) {
+				var var = InstanceExpression as IVariableReference;
+				if (var != null && var.VariableInfo != null) {
+					fc.SetStructFieldAssigned (var.VariableInfo, Name);
+				}
+			}
+
+			var fe = InstanceExpression as FieldExpr;
+			if (fe != null || lvalue_instance) {
+				if (fe == null)
+					return;
+
+				/*
+				while (fe.InstanceExpression is FieldExpr) {
+					fe = (FieldExpr) fe.InstanceExpression;
+					if (!fe.Spec.DeclaringType.IsStruct)
+						continue;
+
+					if (fe.VariableInfo != null && fc.IsStructFieldDefinitelyAssigned (fe.VariableInfo, fe.Name)) {
+						fc.Report.Warning (1060, 1, fe.loc, "Use of possibly unassigned field `{0}'", fe.Name);
+					}
+				}
+
+				fe.InstanceExpression.FlowAnalysis (fc);
+				*/
+			} else {
+				InstanceExpression.FlowAnalysis (fc);
+			}
+		}
+
+
+		public void VerifyAssignedStructField (FlowAnalysisContext fc)
 		{
 			var fe = this;
 
@@ -5753,14 +5851,8 @@ namespace Mono.CSharp {
 				if (var != null) {
 					var vi = var.VariableInfo;
 
-					if (vi != null && !vi.IsStructFieldAssigned (rc, fe.Name) && (rhs == null || !fe.type.IsStruct)) {
-						if (rhs != null) {
-							rc.Report.Warning (1060, 1, fe.loc, "Use of possibly unassigned field `{0}'", fe.Name);
-						} else {
-							rc.Report.Error (170, fe.loc, "Use of possibly unassigned field `{0}'", fe.Name);
-						}
-
-						return;
+					if (vi != null && !fc.IsStructFieldDefinitelyAssigned (vi, fe.Name) && !fe.type.IsStruct) {
+						fc.Report.Warning (1060, 1, fe.loc, "Use of possibly unassigned field `{0}'", fe.Name);
 					}
 				}
 
@@ -5798,7 +5890,6 @@ namespace Mono.CSharp {
 					rc.Report.Error (1649, loc, "Members of readonly field `{0}' cannot be passed ref or out (except in a constructor)",
 						GetSignatureForError ());
 				}
-
 				return null;
 			}
 
@@ -5864,6 +5955,23 @@ namespace Mono.CSharp {
 			return this;
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			var var = InstanceExpression as IVariableReference;
+			if (var != null) {
+				var vi = var.VariableInfo;
+				if (vi != null && !fc.IsStructFieldDefinitelyAssigned (vi, Name)) {
+					fc.Report.Error (170, loc, "Use of possibly unassigned field `{0}'", Name);
+					return;
+				}
+
+				if (TypeSpec.IsValueType (InstanceExpression.Type))
+					return;
+			}
+
+			base.FlowAnalysis (fc);
+		}
+
 		public override int GetHashCode ()
 		{
 			return spec.GetHashCode ();
@@ -6422,6 +6530,8 @@ namespace Mono.CSharp {
 
 				if (expr != this)
 					return expr.ResolveLValue (ec, right_side);
+			} else {
+				ResolveInstanceExpression (ec, right_side);
 			}
 
 			if (!ResolveSetter (ec))
@@ -6731,6 +6841,11 @@ namespace Mono.CSharp {
 				DoEmit (ec);
 			}
 
+			protected override bool DoFlowAnalysis (FlowAnalysisContext fc)
+			{
+				return false;
+			}
+
 			protected override void CloneTo (CloneContext clonectx, Statement target)
 			{
 				// Nothing
@@ -6832,10 +6947,6 @@ namespace Mono.CSharp {
 		public override VariableInfo VariableInfo {
 			get { return null; }
 		}
-
-		public override void VerifyDefiniteAssignment (ResolveContext rc)
-		{
-		}
 	}
 
 	/// 
@@ -6906,7 +7017,12 @@ namespace Mono.CSharp {
 		{
 			return null;
 		}
-		
+
+		protected override bool DoFlowAnalysis(FlowAnalysisContext fc)
+		{
+			return false;
+		}
+
 		public override object Accept (Mono.CSharp.StructuralVisitor visitor)
 		{
 			return visitor.Visit (this);

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/eval.cs

@@ -367,8 +367,14 @@ namespace Mono.CSharp
 				if (parser == null){
 					return null;
 				}
-				
-				Class parser_result = parser.InteractiveResult;
+
+				Class host = parser.InteractiveResult;
+
+				var base_class_imported = importer.ImportType (base_class);
+				var baseclass_list = new List<FullNamedExpression> (1) {
+					new TypeExpression (base_class_imported, host.Location)
+				};
+				host.SetBaseTypes (baseclass_list);
 
 #if NET_4_0
 				var access = AssemblyBuilderAccess.RunAndCollect;
@@ -380,13 +386,15 @@ namespace Mono.CSharp
 				module.SetDeclaringAssembly (a);
 
 				// Need to setup MemberCache
-				parser_result.CreateContainer ();
+				host.CreateContainer ();
+				// Need to setup base type
+				host.DefineContainer ();
 
-				var method = parser_result.Members[0] as Method;
+				var method = host.Members[0] as Method;
 				BlockContext bc = new BlockContext (method, method.Block, ctx.BuiltinTypes.Void);
 
 				try {
-					method.Block.Resolve (null, bc, method);
+					method.Block.Resolve (bc, method);
 				} catch (CompletionResult cr) {
 					prefix = cr.BaseText;
 					return cr.Result;
@@ -1035,9 +1043,7 @@ namespace Mono.CSharp
 		static public string help {
 			get {
 				return "Static methods:\n" +
-#if !NET_2_1
 					"  Describe (object);       - Describes the object's type\n" +
-#endif
 					"  LoadPackage (package);   - Loads the given Package (like -pkg:FILE)\n" +
 					"  LoadAssembly (assembly); - Loads the given assembly (like -r:ASSEMBLY)\n" +
 					"  ShowVars ();             - Shows defined local variables.\n" +

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/expression.cs

@@ -83,6 +83,11 @@ namespace Mono.CSharp
 			call.EmitPredefined (ec, oper, arguments, loc);
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			arguments.FlowAnalysis (fc);
+		}
+
 		public override SLE.Expression MakeExpression (BuilderContext ctx)
 		{
 #if STATIC
@@ -572,6 +577,31 @@ namespace Mono.CSharp
 			Expr.EmitSideEffect (ec);
 		}
 
+		public static void Error_Ambiguous (ResolveContext rc, string oper, TypeSpec type, Location loc)
+		{
+			rc.Report.Error (35, loc, "Operator `{0}' is ambiguous on an operand of type `{1}'",
+				oper, type.GetSignatureForError ());
+		}
+
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			if (Oper == Operator.AddressOf) {
+				var vr = Expr as VariableReference;
+				if (vr != null && vr.VariableInfo != null)
+					fc.SetVariableAssigned (vr.VariableInfo);
+
+				return;
+			}
+
+			Expr.FlowAnalysis (fc);
+
+			if (Oper == Operator.LogicalNot) {
+				var temp = fc.DefiniteAssignmentOnTrue;
+				fc.DefiniteAssignmentOnTrue = fc.DefiniteAssignmentOnFalse;
+				fc.DefiniteAssignmentOnFalse = temp;
+			}
+		}
+
 		//
 		// Converts operator to System.Linq.Expressions.ExpressionType enum name
 		//
@@ -627,7 +657,7 @@ namespace Mono.CSharp
 				return is_checked ? SLE.Expression.NegateChecked (expr) : SLE.Expression.Negate (expr);
 			case Operator.LogicalNot:
 				return SLE.Expression.Not (expr);
-#if NET_4_0 || MONODROID
+#if NET_4_0 || MOBILE_DYNAMIC
 			case Operator.OnesComplement:
 				return SLE.Expression.OnesComplement (expr);
 #endif
@@ -757,8 +787,7 @@ namespace Mono.CSharp
 				int result = OverloadResolver.BetterTypeConversion (ec, best_expr.Type, t);
 				if (result == 0) {
 					if ((oper_expr is UserOperatorCall || oper_expr is UserCast) && (best_expr is UserOperatorCall || best_expr is UserCast)) {
-						ec.Report.Error (35, loc, "Operator `{0}' is ambiguous on an operand of type `{1}'",
-							OperName (Oper), expr.Type.GetSignatureForError ());
+						Error_Ambiguous (ec, OperName (Oper), expr.Type, loc);
 					} else {
 						Error_OperatorCannotBeApplied (ec, loc, OperName (Oper), expr.Type);
 					}
@@ -1199,14 +1228,33 @@ namespace Mono.CSharp
 
 					source = operation;
 				} else {
+					Expression best_source = null;
 					foreach (var t in ec.BuiltinTypes.OperatorsUnaryMutator) {
 						source = Convert.ImplicitUserConversion (ec, operation, t, loc);
 
 						// LAMESPEC: It should error on ambiguous operators but that would make us incompatible
-						if (source != null) {
-							break;
+						if (source == null)
+							continue;
+
+						if (best_source == null) {
+							best_source = source;
+							continue;
 						}
+
+						var better = OverloadResolver.BetterTypeConversion (ec, best_source.Type, source.Type);
+						if (better == 1)
+							continue;
+
+						if (better == 2) {
+							best_source = source;
+							continue;
+						}
+
+						Unary.Error_Ambiguous (ec, OperName (mode), type, loc);
+						break;
 					}
+
+					source = best_source;
 				}
 
 				// ++/-- on enum types
@@ -1274,6 +1322,11 @@ namespace Mono.CSharp
 			EmitCode (ec, false);
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			expr.FlowAnalysis (fc);
+		}
+
 		//
 		// Converts operator to System.Linq.Expressions.ExpressionType enum name
 		//
@@ -1287,7 +1340,7 @@ namespace Mono.CSharp
 		}
 
 
-#if NET_4_0 || MONODROID
+#if NET_4_0 || MOBILE_DYNAMIC
 		public override SLE.Expression MakeExpression (BuilderContext ctx)
 		{
 			var target = ((RuntimeValueExpression) expr).MetaObject.Expression;
@@ -1296,6 +1349,11 @@ namespace Mono.CSharp
 		}
 #endif
 
+		public static string OperName (Mode oper)
+		{
+			return (oper & Mode.IsDecrement) != 0 ? "--" : "++";
+		}
+
 		protected override void CloneTo (CloneContext clonectx, Expression t)
 		{
 			UnaryMutator target = (UnaryMutator) t;
@@ -1367,6 +1425,11 @@ namespace Mono.CSharp
 			return this;
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			expr.FlowAnalysis (fc);
+		}
+
 		protected abstract string OperatorName { get; }
 
 		protected override void CloneTo (CloneContext clonectx, Expression t)
@@ -1859,7 +1922,7 @@ namespace Mono.CSharp
 			temp_storage.Release (ec);
 		}
 
-#if (NET_4_0 || MONODROID) && !STATIC
+#if (NET_4_0 || MOBILE_DYNAMIC) && !STATIC
 		public override SLE.Expression MakeExpression (BuilderContext ctx)
 		{
 			return SLE.Expression.Default (type.GetMetaInfo ());
@@ -2518,6 +2581,49 @@ namespace Mono.CSharp
 			Error_OperatorCannotBeApplied (ec, left, right, OperName (oper), loc);
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			if ((oper & Operator.LogicalMask) == 0) {
+				left.FlowAnalysis (fc);
+				right.FlowAnalysis (fc);
+				return;
+			}
+
+			//
+			// Optimized version when on-true/on-false data are not needed
+			//
+			bool set_on_true_false;
+			if (fc.DefiniteAssignmentOnTrue == null && fc.DefiniteAssignmentOnFalse == null) {
+				fc.DefiniteAssignmentOnFalse = fc.DefiniteAssignmentOnTrue = fc.DefiniteAssignment;
+				set_on_true_false = false;
+			} else {
+				set_on_true_false = true;
+			}
+
+			left.FlowAnalysis (fc);
+			var left_fc = fc.DefiniteAssignment;
+			var left_fc_ontrue = fc.DefiniteAssignmentOnTrue;
+			var left_fc_onfalse = fc.DefiniteAssignmentOnFalse;
+
+			fc.DefiniteAssignmentOnTrue = fc.DefiniteAssignmentOnFalse = fc.DefiniteAssignment = new DefiniteAssignmentBitSet (
+				oper == Operator.LogicalOr ? left_fc_onfalse : left_fc_ontrue);
+			right.FlowAnalysis (fc);
+			fc.DefiniteAssignment = left_fc;
+
+			if (!set_on_true_false) {
+				fc.DefiniteAssignmentOnFalse = fc.DefiniteAssignmentOnTrue = null;
+				return;
+			}
+
+			if (oper == Operator.LogicalOr) {
+				fc.DefiniteAssignmentOnTrue = new DefiniteAssignmentBitSet (left_fc_ontrue);
+				fc.DefiniteAssignmentOnFalse = left_fc_onfalse | fc.DefiniteAssignmentOnFalse;
+			} else {
+				fc.DefiniteAssignmentOnTrue = left_fc_ontrue | fc.DefiniteAssignmentOnTrue;
+				fc.DefiniteAssignmentOnFalse = new DefiniteAssignmentBitSet (left_fc_onfalse);
+			}
+		}
+
 		//
 		// Converts operator to System.Linq.Expressions.ExpressionType enum name
 		//
@@ -4890,6 +4996,11 @@ namespace Mono.CSharp
 			}
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			arguments.FlowAnalysis (fc);
+		}
+
 		public override SLE.Expression MakeExpression (BuilderContext ctx)
 		{
 			if (arguments.Count != 2)
@@ -5259,32 +5370,8 @@ namespace Mono.CSharp
 		protected override Expression DoResolve (ResolveContext ec)
 		{
 			expr = expr.Resolve (ec);
-
-			//
-			// Unreachable code needs different resolve path. For instance for await
-			// expression to not generate unreachable resumable statement
-			//
-			Constant c = expr as Constant;
-			if (c != null && ec.CurrentBranching != null) {
-				bool unreachable = ec.CurrentBranching.CurrentUsageVector.IsUnreachable;
-
-				if (c.IsDefaultValue) {
-					ec.CurrentBranching.CurrentUsageVector.IsUnreachable = true;
-					true_expr = true_expr.Resolve (ec);
-					ec.CurrentBranching.CurrentUsageVector.IsUnreachable = unreachable;
-
-					false_expr = false_expr.Resolve (ec);
-				} else {
-					true_expr = true_expr.Resolve (ec);
-
-					ec.CurrentBranching.CurrentUsageVector.IsUnreachable = true;
-					false_expr = false_expr.Resolve (ec);
-					ec.CurrentBranching.CurrentUsageVector.IsUnreachable = unreachable;
-				}
-			} else {
-				true_expr = true_expr.Resolve (ec);
-				false_expr = false_expr.Resolve (ec);
-			}
+			true_expr = true_expr.Resolve (ec);
+			false_expr = false_expr.Resolve (ec);
 
 			if (true_expr == null || false_expr == null || expr == null)
 				return null;
@@ -5345,8 +5432,9 @@ namespace Mono.CSharp
 						true_type.GetSignatureForError (), false_type.GetSignatureForError ());
 					return null;
 				}
-			}			
+			}
 
+			Constant c = expr as Constant;
 			if (c != null) {
 				bool is_false = c.IsDefaultValue;
 
@@ -5392,6 +5480,28 @@ namespace Mono.CSharp
 			ec.MarkLabel (end_target);
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			fc.DefiniteAssignmentOnTrue = fc.DefiniteAssignmentOnFalse = fc.DefiniteAssignment;
+
+			expr.FlowAnalysis (fc);
+			var da_true = fc.DefiniteAssignmentOnTrue;
+			var da_false = fc.DefiniteAssignmentOnFalse;
+
+			fc.DefiniteAssignment = new DefiniteAssignmentBitSet (da_true);
+			true_expr.FlowAnalysis (fc);
+			var true_fc = fc.DefiniteAssignment;
+
+			fc.DefiniteAssignment = new DefiniteAssignmentBitSet (da_false);
+			false_expr.FlowAnalysis (fc);
+
+			fc.DefiniteAssignment &= true_fc;
+			if (fc.DefiniteAssignmentOnTrue != null)
+				fc.DefiniteAssignmentOnTrue = fc.DefiniteAssignment;
+			if (fc.DefiniteAssignmentOnFalse != null)
+				fc.DefiniteAssignmentOnFalse = fc.DefiniteAssignment;
+		}
+
 		protected override void CloneTo (CloneContext clonectx, Expression t)
 		{
 			Conditional target = (Conditional) t;
@@ -5414,7 +5524,6 @@ namespace Mono.CSharp
 		#region Abstract
 		public abstract HoistedVariable GetHoistedVariable (AnonymousExpression ae);
 		public abstract void SetHasAddressTaken ();
-		public abstract void VerifyDefiniteAssignment (ResolveContext rc);
 
 		public abstract bool IsLockedByStatement { get; set; }
 
@@ -5647,17 +5756,17 @@ namespace Mono.CSharp
 
 		#endregion
 
-		public override void VerifyDefiniteAssignment (ResolveContext rc)
+		public override void FlowAnalysis (FlowAnalysisContext fc)
 		{
 			VariableInfo variable_info = VariableInfo;
 			if (variable_info == null)
 				return;
 
-			if (variable_info.IsAssigned (rc))
+			if (fc.IsDefinitelyAssigned (variable_info))
 				return;
 
-			rc.Report.Error (165, loc, "Use of unassigned local variable `{0}'", Name);
-			variable_info.SetAssigned (rc);
+			fc.Report.Error (165, loc, "Use of unassigned local variable `{0}'", Name);
+			variable_info.SetAssigned (fc.DefiniteAssignment, true);
 		}
 
 		public override void SetHasAddressTaken ()
@@ -5694,8 +5803,6 @@ namespace Mono.CSharp
 		{
 			local_info.SetIsUsed ();
 
-			VerifyDefiniteAssignment (ec);
-
 			DoResolveBase (ec);
 			return this;
 		}
@@ -5710,22 +5817,22 @@ namespace Mono.CSharp
 				local_info.SetIsUsed ();
 
 			if (local_info.IsReadonly && !ec.HasAny (ResolveContext.Options.FieldInitializerScope | ResolveContext.Options.UsingInitializerScope)) {
-				int code;
-				string msg;
-				if (rhs == EmptyExpression.OutAccess) {
-					code = 1657; msg = "Cannot pass `{0}' as a ref or out argument because it is a `{1}'";
-				} else if (rhs == EmptyExpression.LValueMemberAccess) {
-					code = 1654; msg = "Cannot assign to members of `{0}' because it is a `{1}'";
-				} else if (rhs == EmptyExpression.LValueMemberOutAccess) {
-					code = 1655; msg = "Cannot pass members of `{0}' as ref or out arguments because it is a `{1}'";
-				} else if (rhs == EmptyExpression.UnaryAddress) {
-					code = 459; msg = "Cannot take the address of {1} `{0}'";
+				if (rhs == EmptyExpression.LValueMemberAccess) {
+					// CS1654 already reported
 				} else {
-					code = 1656; msg = "Cannot assign to `{0}' because it is a `{1}'";
+					int code;
+					string msg;
+					if (rhs == EmptyExpression.OutAccess) {
+						code = 1657; msg = "Cannot pass `{0}' as a ref or out argument because it is a `{1}'";
+					} else if (rhs == EmptyExpression.LValueMemberOutAccess) {
+						code = 1655; msg = "Cannot pass members of `{0}' as ref or out arguments because it is a `{1}'";
+					} else if (rhs == EmptyExpression.UnaryAddress) {
+						code = 459; msg = "Cannot take the address of {1} `{0}'";
+					} else {
+						code = 1656; msg = "Cannot assign to `{0}' because it is a `{1}'";
+					}
+					ec.Report.Error (code, loc, msg, Name, local_info.GetReadOnlyContext ());
 				}
-				ec.Report.Error (code, loc, msg, Name, local_info.GetReadOnlyContext ());
-			} else if (VariableInfo != null) {
-				VariableInfo.SetAssigned (ec);
 			}
 
 			if (eclass == ExprClass.Unresolved)
@@ -5850,15 +5957,6 @@ namespace Mono.CSharp
 			Parameter.HasAddressTaken = true;
 		}
 
-		void SetAssigned (ResolveContext ec)
-		{
-			if (Parameter.HoistedVariant != null)
-				Parameter.HoistedVariant.IsAssigned = true;
-
-			if (HasOutModifier && ec.DoFlowAnalysis)
-				ec.CurrentBranching.SetAssigned (VariableInfo);
-		}
-
 		bool DoResolveBase (ResolveContext ec)
 		{
 			if (eclass != ExprClass.Unresolved)
@@ -5924,7 +6022,6 @@ namespace Mono.CSharp
 			if (!DoResolveBase (ec))
 				return null;
 
-			VerifyDefiniteAssignment (ec);
 			return this;
 		}
 
@@ -5933,21 +6030,23 @@ namespace Mono.CSharp
 			if (!DoResolveBase (ec))
 				return null;
 
-			SetAssigned (ec);
+			if (Parameter.HoistedVariant != null)
+				Parameter.HoistedVariant.IsAssigned = true;
+
 			return base.DoResolveLValue (ec, right_side);
 		}
 
-		public override void VerifyDefiniteAssignment (ResolveContext rc)
+		public override void FlowAnalysis (FlowAnalysisContext fc)
 		{
 			VariableInfo variable_info = VariableInfo;
 			if (variable_info == null)
 				return;
 
-			if (variable_info.IsAssigned (rc))
+			if (fc.IsDefinitelyAssigned (variable_info))
 				return;
 
-			rc.Report.Error (269, loc, "Use of unassigned out parameter `{0}'", Name);
-			variable_info.SetAssigned (rc);
+			fc.Report.Error (269, loc, "Use of unassigned out parameter `{0}'", Name);
+			fc.SetVariableAssigned (variable_info);
 		}
 	}
 	
@@ -6215,6 +6314,17 @@ namespace Mono.CSharp
 			return mg.OverloadResolve (ec, ref arguments, null, OverloadResolver.Restrictions.None);
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			if (mg.IsConditionallyExcluded)
+				return;
+
+			mg.FlowAnalysis (fc);
+
+			if (arguments != null)
+				arguments.FlowAnalysis (fc);
+		}
+
 		public override string GetSignatureForError ()
 		{
 			return mg.GetSignatureForError ();
@@ -6255,6 +6365,9 @@ namespace Mono.CSharp
 
 		public override void Emit (EmitContext ec)
 		{
+			if (mg.IsConditionallyExcluded)
+				return;
+
 			mg.EmitCall (ec, arguments);
 		}
 		
@@ -6646,6 +6759,12 @@ namespace Mono.CSharp
 				ec.Emit (OpCodes.Pop);
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			if (arguments != null)
+				arguments.FlowAnalysis (fc);
+		}
+
 		public void AddressOf (EmitContext ec, AddressOp mode)
 		{
 			EmitAddressOf (ec, mode);
@@ -6805,6 +6924,11 @@ namespace Mono.CSharp
 		{
 			throw new InternalErrorException ("Missing Resolve call");
 		}
+
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			throw new InternalErrorException ("Missing Resolve call");
+		}
 		
 		public override object Accept (StructuralVisitor visitor)
 		{
@@ -7070,6 +7194,17 @@ namespace Mono.CSharp
 			ec.Report.Error (248, loc, "Cannot create an array with a negative size");
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			foreach (var arg in arguments)
+				arg.FlowAnalysis (fc);
+
+			if (array_data != null) {
+				foreach (var ad in array_data)
+					ad.FlowAnalysis (fc);
+			}
+		}
+
 		bool InitializersContainAwait ()
 		{
 			if (array_data == null)
@@ -7309,7 +7444,7 @@ namespace Mono.CSharp
 			return data;
 		}
 
-#if NET_4_0 || MONODROID
+#if NET_4_0 || MOBILE_DYNAMIC
 		public override SLE.Expression MakeExpression (BuilderContext ctx)
 		{
 #if STATIC
@@ -7714,7 +7849,7 @@ namespace Mono.CSharp
 
 		#endregion
 
-		public void CheckStructThisDefiniteAssignment (ResolveContext rc)
+		void CheckStructThisDefiniteAssignment (FlowAnalysisContext fc)
 		{
 			//
 			// It's null for all cases when we don't need to check `this'
@@ -7723,13 +7858,10 @@ namespace Mono.CSharp
 			if (variable_info == null)
 				return;
 
-			if (rc.OmitStructFlowAnalysis)
+			if (fc.IsDefinitelyAssigned (variable_info))
 				return;
 
-			if (!variable_info.IsAssigned (rc)) {
-				rc.Report.Error (188, loc,
-					"The `this' object cannot be used before all of its fields are assigned to");
-			}
+			fc.Report.Error (188, loc, "The `this' object cannot be used before all of its fields are assigned to");
 		}
 
 		protected virtual void Error_ThisNotAvailable (ResolveContext ec)
@@ -7745,6 +7877,11 @@ namespace Mono.CSharp
 			}
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			CheckStructThisDefiniteAssignment (fc);
+		}
+
 		public override HoistedVariable GetHoistedVariable (AnonymousExpression ae)
 		{
 			if (ae == null)
@@ -7802,9 +7939,6 @@ namespace Mono.CSharp
 		protected override Expression DoResolve (ResolveContext ec)
 		{
 			ResolveBase (ec);
-
-			CheckStructThisDefiniteAssignment (ec);
-
 			return this;
 		}
 
@@ -7813,9 +7947,6 @@ namespace Mono.CSharp
 			if (eclass == ExprClass.Unresolved)
 				ResolveBase (ec);
 
-			if (variable_info != null)
-				variable_info.SetAssigned (ec);
-
 			if (type.IsClass){
 				if (right_side == EmptyExpression.UnaryAddress)
 					ec.Report.Error (459, loc, "Cannot take the address of `this' because it is read-only");
@@ -7851,12 +7982,6 @@ namespace Mono.CSharp
 		{
 			// Nothing
 		}
-
-		public override void VerifyDefiniteAssignment (ResolveContext rc)
-		{
-		
-		}
-
 		
 		public override object Accept (StructuralVisitor visitor)
 		{
@@ -8643,50 +8768,25 @@ namespace Mono.CSharp
 
 		protected override Expression DoResolve (ResolveContext rc)
 		{
-			var e = DoResolveName (rc, null);
-
-			if (!rc.OmitStructFlowAnalysis) {
-				var fe = e as FieldExpr;
-				if (fe != null) {
-					fe.VerifyAssignedStructField (rc, null);
-				}
-			}
+			var e = LookupNameExpression (rc, MemberLookupRestrictions.ReadAccess);
+			if (e != null)
+				e = e.Resolve (rc, ResolveFlags.VariableOrValue | ResolveFlags.Type | ResolveFlags.MethodGroup);
 
 			return e;
 		}
 
 		public override Expression DoResolveLValue (ResolveContext rc, Expression rhs)
 		{
-			var e = DoResolveName (rc, rhs);
-
-			if (!rc.OmitStructFlowAnalysis) {
-				var fe = e as FieldExpr;
-				if (fe != null && fe.InstanceExpression is FieldExpr) {
-					fe = (FieldExpr) fe.InstanceExpression;
-					fe.VerifyAssignedStructField (rc, rhs);
-				}
-			}
+			var e = LookupNameExpression (rc, MemberLookupRestrictions.None);
 
-			return e;
-		}
-
-		Expression DoResolveName (ResolveContext rc, Expression right_side)
-		{
-			Expression e = LookupNameExpression (rc, right_side == null ? MemberLookupRestrictions.ReadAccess : MemberLookupRestrictions.None);
-			if (e == null)
+			if (e is TypeExpr) {
+				e.Error_UnexpectedKind (rc, ResolveFlags.VariableOrValue, loc);
 				return null;
-
-			if (right_side != null) {
-				if (e is TypeExpr) {
-					e.Error_UnexpectedKind (rc, ResolveFlags.VariableOrValue, loc);
-					return null;
-				}
-
-				e = e.ResolveLValue (rc, right_side);
-			} else {
-				e = e.Resolve (rc, ResolveFlags.VariableOrValue | ResolveFlags.Type | ResolveFlags.MethodGroup);
 			}
 
+			if (e != null)
+				e = e.ResolveLValue (rc, rhs);
+
 			return e;
 		}
 
@@ -8711,32 +8811,22 @@ namespace Mono.CSharp
 			var sn = expr as SimpleName;
 			const ResolveFlags flags = ResolveFlags.VariableOrValue | ResolveFlags.Type;
 
-			//
-			// Resolve the expression with flow analysis turned off, we'll do the definite
-			// assignment checks later.  This is because we don't know yet what the expression
-			// will resolve to - it may resolve to a FieldExpr and in this case we must do the
-			// definite assignment check on the actual field and not on the whole struct.
-			//
-			using (rc.Set (ResolveContext.Options.OmitStructFlowAnalysis)) {
-				if (sn != null) {
-					expr = sn.LookupNameExpression (rc, MemberLookupRestrictions.ReadAccess | MemberLookupRestrictions.ExactArity);
+			if (sn != null) {
+				expr = sn.LookupNameExpression (rc, MemberLookupRestrictions.ReadAccess | MemberLookupRestrictions.ExactArity);
 
-					//
-					// Resolve expression which does have type set as we need expression type
-					// with disable flow analysis as we don't know whether left side expression
-					// is used as variable or type
-					//
-					if (expr is VariableReference || expr is ConstantExpr || expr is Linq.TransparentMemberAccess) {
-						using (rc.With (ResolveContext.Options.DoFlowAnalysis, false)) {
-							expr = expr.Resolve (rc);
-						}
-					} else if (expr is TypeParameterExpr) {
-						expr.Error_UnexpectedKind (rc, flags, sn.Location);
-						expr = null;
-					}
-				} else {
-					expr = expr.Resolve (rc, flags);
+				//
+				// Resolve expression which does have type set as we need expression type
+				// with disable flow analysis as we don't know whether left side expression
+				// is used as variable or type
+				//
+				if (expr is VariableReference || expr is ConstantExpr || expr is Linq.TransparentMemberAccess) {
+					expr = expr.Resolve (rc);
+				} else if (expr is TypeParameterExpr) {
+					expr.Error_UnexpectedKind (rc, flags, sn.Location);
+					expr = null;
 				}
+			} else {
+				expr = expr.Resolve (rc, flags);
 			}
 
 			if (expr == null)
@@ -8764,16 +8854,6 @@ namespace Mono.CSharp
 				if (me != null)
 					me.ResolveInstanceExpression (rc, null);
 
-				//
-				// Run defined assigned checks on expressions resolved with
-				// disabled flow-analysis
-				//
-				if (sn != null) {
-					var vr = expr as VariableReference;
-					if (vr != null)
-						vr.VerifyDefiniteAssignment (rc);
-				}
-
 				Arguments args = new Arguments (1);
 				args.Add (new Argument (expr));
 				return new DynamicMemberBinder (Name, args, loc);
@@ -8804,16 +8884,6 @@ namespace Mono.CSharp
 								emg.SetTypeArguments (rc, targs);
 							}
 
-							//
-							// Run defined assigned checks on expressions resolved with
-							// disabled flow-analysis
-							//
-							if (sn != null && !errorMode) {
-								var vr = expr as VariableReference;
-								if (vr != null)
-									vr.VerifyDefiniteAssignment (rc);
-							}
-
 							// TODO: it should really skip the checks bellow
 							return emg.Resolve (rc);
 						}
@@ -8886,16 +8956,6 @@ namespace Mono.CSharp
 				me.SetTypeArguments (rc, targs);
 			}
 
-			//
-			// Run defined assigned checks on expressions resolved with
-			// disabled flow-analysis
-			//
-			if (sn != null && !(me is FieldExpr && TypeSpec.IsValueType (expr_type))) {
-				var vr = expr as VariableReference;
-				if (vr != null)
-					vr.VerifyDefiniteAssignment (rc);
-			}
-
 			return me;
 		}
 
@@ -9108,6 +9168,11 @@ namespace Mono.CSharp
 				Expr.EmitBranchable (ec, target, on_true);
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			Expr.FlowAnalysis (fc);
+		}
+
 		public override SLE.Expression MakeExpression (BuilderContext ctx)
 		{
 			using (ctx.With (BuilderContext.Options.CheckedScope, true)) {
@@ -9180,6 +9245,11 @@ namespace Mono.CSharp
 				Expr.EmitBranchable (ec, target, on_true);
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			Expr.FlowAnalysis (fc);
+		}
+
 		protected override void CloneTo (CloneContext clonectx, Expression t)
 		{
 			UnCheckedExpr target = (UnCheckedExpr) t;
@@ -9263,17 +9333,24 @@ namespace Mono.CSharp
 			return CreateExpressionFactoryCall (ec, "ArrayIndex", args);
 		}
 
-		Expression MakePointerAccess (ResolveContext ec, TypeSpec type)
+		Expression MakePointerAccess (ResolveContext rc, TypeSpec type)
 		{
 			if (Arguments.Count != 1){
-				ec.Report.Error (196, loc, "A pointer must be indexed by only one value");
+				rc.Report.Error (196, loc, "A pointer must be indexed by only one value");
 				return null;
 			}
 
-			if (Arguments [0] is NamedArgument)
-				Error_NamedArgument ((NamedArgument) Arguments[0], ec.Report);
+			var arg = Arguments[0];
+			if (arg is NamedArgument)
+				Error_NamedArgument ((NamedArgument) arg, rc.Report);
+
+			var index = arg.Expr.Resolve (rc);
+			if (index == null)
+				return null;
+
+			index = ConvertExpressionToArrayIndex (rc, index, true);
 
-			Expression p = new PointerArithmetic (Binary.Operator.Addition, Expr, Arguments [0].Expr.Resolve (ec), type, loc);
+			Expression p = new PointerArithmetic (Binary.Operator.Addition, Expr, index, type, loc);
 			return new Indirection (p, loc);
 		}
 		
@@ -9318,6 +9395,12 @@ namespace Mono.CSharp
 			Report.Error (1742, na.Location, "An element access expression cannot use named argument");
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			Expr.FlowAnalysis (fc);
+			Arguments.FlowAnalysis (fc);
+		}
+
 		public override string GetSignatureForError ()
 		{
 			return Expr.GetSignatureForError ();
@@ -9420,6 +9503,11 @@ namespace Mono.CSharp
 			ec.Report.Warning (251, 2, loc, "Indexing an array with a negative index (array indices always start at zero)");
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			ea.FlowAnalysis (fc);
+		}
+
 		//
 		// Load the array arguments into the stack.
 		//
@@ -9557,7 +9645,7 @@ namespace Mono.CSharp
 
 		public SLE.Expression MakeAssignExpression (BuilderContext ctx, Expression source)
 		{
-#if NET_4_0 || MONODROID
+#if NET_4_0 || MOBILE_DYNAMIC
 			return SLE.Expression.ArrayAccess (ea.Expr.MakeExpression (ctx), MakeExpressionArguments (ctx));
 #else
 			throw new NotImplementedException ();
@@ -9717,6 +9805,13 @@ namespace Mono.CSharp
 			}
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			// TODO: Check the order
+			base.FlowAnalysis (fc);
+			arguments.FlowAnalysis (fc);
+		}
+
 		public override string GetSignatureForError ()
 		{
 			return best_candidate.GetSignatureForError ();
@@ -9729,7 +9824,7 @@ namespace Mono.CSharp
 #else
 			var value = new[] { source.MakeExpression (ctx) };
 			var args = Arguments.MakeExpression (arguments, ctx).Concat (value);
-#if NET_4_0 || MONODROID
+#if NET_4_0 || MOBILE_DYNAMIC
 			return SLE.Expression.Block (
 					SLE.Expression.Call (InstanceExpression.MakeExpression (ctx), (MethodInfo) Setter.GetMetaInfo (), args),
 					value [0]);
@@ -9874,8 +9969,8 @@ namespace Mono.CSharp
 		{
 			base.Emit (ec);
 
-			var context_type = ec.CurrentType;
-			if (context_type.IsStruct) {
+			if (type == ec.Module.Compiler.BuiltinTypes.ValueType) {
+				var context_type = ec.CurrentType;
 				ec.Emit (OpCodes.Ldobj, context_type);
 				ec.Emit (OpCodes.Box, context_type);
 			}
@@ -10142,6 +10237,11 @@ namespace Mono.CSharp
 			ec.Emit (OpCodes.Call, method);
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			source.FlowAnalysis (fc);
+		}
+
 		public override string GetSignatureForError ()
 		{
 			return TypeManager.CSharpSignature (method);
@@ -10858,6 +10958,12 @@ namespace Mono.CSharp
 				e.EmitStatement (ec);
 			}
 		}
+
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			foreach (var initializer in initializers)
+				initializer.FlowAnalysis (fc);
+		}
 	}
 	
 	//
@@ -11052,6 +11158,12 @@ namespace Mono.CSharp
 			return instance;
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			base.FlowAnalysis (fc);
+			initializers.FlowAnalysis (fc);
+		}
+
 		public override object Accept (StructuralVisitor visitor)
 		{
 			return visitor.Visit (this);

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/generic.cs

@@ -492,6 +492,12 @@ namespace Mono.CSharp {
 			}
 		}
 
+		bool ITypeDefinition.IsCyclicTypeForwarder {
+			get {
+				return false;
+			}
+		}
+
 		public string Name {
 			get {
 				return MemberName.Name;
@@ -2150,7 +2156,7 @@ namespace Mono.CSharp {
 		public virtual bool Resolve (IMemberContext ec)
 		{
 			if (atypes != null)
-			    return atypes.Length != 0;
+			    return true;
 
 			int count = args.Count;
 			bool ok = true;
@@ -2181,7 +2187,7 @@ namespace Mono.CSharp {
 			}
 
 			if (!ok)
-				atypes = TypeSpec.EmptyTypes;
+				atypes = null;
 
 			return ok;
 		}
@@ -2916,7 +2922,6 @@ namespace Mono.CSharp {
 		readonly TypeSpec[] tp_args;
 		readonly TypeSpec[] fixed_types;
 		readonly List<BoundInfo>[] bounds;
-		bool failed;
 
 		// TODO MemberCache: Could it be TypeParameterSpec[] ??
 		public TypeInferenceContext (TypeSpec[] typeArguments)
@@ -3135,9 +3140,6 @@ namespace Mono.CSharp {
 			if (fixed_types[i] != null)
 				throw new InternalErrorException ("Type argument has been already fixed");
 
-			if (failed)
-				return false;
-
 			var candidates = bounds [i];
 			if (candidates == null)
 				return false;
@@ -3461,10 +3463,9 @@ namespace Mono.CSharp {
 						}
 
 						//
-						// This should always cause type inference failure
+						// Break when candidate arguments are ambiguous
 						//
-						failed = true;
-						return 1;
+						return 0;
 					}
 
 					//

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/import.cs

@@ -75,15 +75,24 @@ namespace Mono.CSharp
 				return flags != null;
 			}
 
+			IList<CustomAttributeData> GetCustomAttributes ()
+			{
+				var mi = provider as MemberInfo;
+				if (mi != null)
+					return CustomAttributeData.GetCustomAttributes (mi);
+
+				var pi = provider as ParameterInfo;
+				if (pi != null)
+					return CustomAttributeData.GetCustomAttributes (pi);
+
+				provider = null;
+				return null;
+			}
+
 			void ReadAttribute ()
 			{
-				IList<CustomAttributeData> cad;
-				if (provider is MemberInfo) {
-					cad = CustomAttributeData.GetCustomAttributes ((MemberInfo) provider);
-				} else if (provider is ParameterInfo) {
-					cad = CustomAttributeData.GetCustomAttributes ((ParameterInfo) provider);
-				} else {
-					provider = null;
+				var cad = GetCustomAttributes ();
+				if (cad == null) {
 					return;
 				}
 
@@ -493,7 +502,7 @@ namespace Mono.CSharp
 				} else if (i == 0 && method.IsStatic && (parent.Modifiers & Modifiers.METHOD_EXTENSION) != 0 &&
 					HasAttribute (CustomAttributeData.GetCustomAttributes (method), "ExtensionAttribute", CompilerServicesNamespace)) {
 					mod = Parameter.Modifier.This;
-					types[i] = ImportType (p.ParameterType);
+					types[i] = ImportType (p.ParameterType, new DynamicTypeReader (p));
 				} else {
 					types[i] = ImportType (p.ParameterType, new DynamicTypeReader (p));
 
@@ -1150,6 +1159,14 @@ namespace Mono.CSharp
 				throw new NotImplementedException ("Unknown element type " + type.ToString ());
 			}
 
+			TypeSpec compiled_type;
+			if (compiled_types.TryGetValue (type, out compiled_type)) {
+				if (compiled_type.BuiltinType == BuiltinTypeSpec.Type.Object && dtype.IsDynamicObject ())
+					return module.Compiler.BuiltinTypes.Dynamic;
+
+				return compiled_type;
+			}
+
 			return CreateType (type, dtype, true);
 		}
 
@@ -1798,6 +1815,16 @@ namespace Mono.CSharp
 			}
 		}
 
+		bool ITypeDefinition.IsCyclicTypeForwarder {
+			get {
+#if STATIC
+				return ((MetaType) provider).__IsCyclicTypeForwarder;
+#else
+				return false;
+#endif
+			}
+		}
+
 		public override string Name {
 			get {
 				if (name == null) {
@@ -1919,20 +1946,24 @@ namespace Mono.CSharp
 				if (caller.Kind != MemberKind.MissingType)
 					report.SymbolRelatedToPreviousError (caller);
 
-				if (t.MemberDefinition.DeclaringAssembly == ctx.Module.DeclaringAssembly) {
+				var definition = t.MemberDefinition;
+				if (definition.DeclaringAssembly == ctx.Module.DeclaringAssembly) {
 					report.Error (1683, loc,
 						"Reference to type `{0}' claims it is defined in this assembly, but it is not defined in source or any added modules",
 						name);
-				} else if (t.MemberDefinition.DeclaringAssembly.IsMissing) {
-					if (t.MemberDefinition.IsTypeForwarder) {
+				} else if (definition.DeclaringAssembly.IsMissing) {
+					if (definition.IsTypeForwarder) {
 						report.Error (1070, loc,
 							"The type `{0}' has been forwarded to an assembly that is not referenced. Consider adding a reference to assembly `{1}'",
-							name, t.MemberDefinition.DeclaringAssembly.FullName);
+							name, definition.DeclaringAssembly.FullName);
 					} else {
 						report.Error (12, loc,
 							"The type `{0}' is defined in an assembly that is not referenced. Consider adding a reference to assembly `{1}'",
-							name, t.MemberDefinition.DeclaringAssembly.FullName);
+							name, definition.DeclaringAssembly.FullName);
 					}
+				} else if (definition.IsTypeForwarder) {
+					report.Error (731, loc, "The type forwarder for type `{0}' in assembly `{1}' has circular dependency",
+						name, definition.DeclaringAssembly.FullName);
 				} else {
 					report.Error (1684, loc,
 						"Reference to type `{0}' claims it is defined assembly `{1}', but it could not be found",
@@ -2231,6 +2262,12 @@ namespace Mono.CSharp
 			}
 		}
 
+		bool ITypeDefinition.IsCyclicTypeForwarder {
+			get {
+				return false;
+			}
+		}
+
 		public string Namespace {
 			get {
 				return null;

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/iterators.cs

@@ -29,7 +29,8 @@ namespace Mono.CSharp
 		protected bool unwind_protect;
 		protected T machine_initializer;
 		int resume_pc;
-		
+		ExceptionStatement inside_try_block;
+
 		protected YieldStatement (Expression expr, Location l)
 		{
 			this.expr = expr;
@@ -51,6 +52,15 @@ namespace Mono.CSharp
 			machine_initializer.InjectYield (ec, expr, resume_pc, unwind_protect, resume_point);
 		}
 
+		protected override bool DoFlowAnalysis (FlowAnalysisContext fc)
+		{
+			expr.FlowAnalysis (fc);
+
+			RegisterResumePoint ();
+
+			return false;
+		}
+
 		public override bool Resolve (BlockContext bc)
 		{
 			expr = expr.Resolve (bc);
@@ -58,12 +68,20 @@ namespace Mono.CSharp
 				return false;
 
 			machine_initializer = bc.CurrentAnonymousMethod as T;
-
-			if (!bc.CurrentBranching.CurrentUsageVector.IsUnreachable)
-				unwind_protect = bc.CurrentBranching.AddResumePoint (this, this, out resume_pc);
-
+			inside_try_block = bc.CurrentTryBlock;
 			return true;
 		}
+
+		public void RegisterResumePoint ()
+		{
+			if (inside_try_block == null) {
+				resume_pc = machine_initializer.AddResumePoint (this);
+			} else {
+				resume_pc = inside_try_block.AddResumePoint (this, resume_pc, machine_initializer);
+				unwind_protect = true;
+				inside_try_block = null;
+			}
+		}
 	}
 
 	public class Yield : YieldStatement<Iterator>
@@ -73,14 +91,19 @@ namespace Mono.CSharp
 		{
 		}
 
-		public static bool CheckContext (ResolveContext ec, Location loc)
+		public static bool CheckContext (BlockContext bc, Location loc)
 		{
-			if (!ec.CurrentAnonymousMethod.IsIterator) {
-				ec.Report.Error (1621, loc,
+			if (!bc.CurrentAnonymousMethod.IsIterator) {
+				bc.Report.Error (1621, loc,
 					"The yield statement cannot be used inside anonymous method blocks");
 				return false;
 			}
 
+			if (bc.HasSet (ResolveContext.Options.FinallyScope)) {
+				bc.Report.Error (1625, loc, "Cannot yield in the body of a finally clause");
+				return false;
+			}
+
 			return true;
 		}
 
@@ -89,6 +112,14 @@ namespace Mono.CSharp
 			if (!CheckContext (bc, loc))
 				return false;
 
+			if (bc.HasAny (ResolveContext.Options.TryWithCatchScope)) {
+				bc.Report.Error (1626, loc, "Cannot yield a value in the body of a try block with a catch clause");
+			}
+
+			if (bc.HasSet (ResolveContext.Options.CatchScope)) {
+				bc.Report.Error (1631, loc, "Cannot yield a value in the body of a catch clause");
+			}
+
 			if (!base.Resolve (bc))
 				return false;
 
@@ -117,9 +148,10 @@ namespace Mono.CSharp
 			loc = l;
 		}
 
-		public override void Error_FinallyClause (Report Report)
-		{
-			Report.Error (1625, loc, "Cannot yield in the body of a finally clause");
+		protected override bool IsLocalExit {
+			get {
+				return false;
+			}
 		}
 
 		protected override void CloneTo (CloneContext clonectx, Statement target)
@@ -127,16 +159,27 @@ namespace Mono.CSharp
 			throw new NotSupportedException ();
 		}
 
-		protected override bool DoResolve (BlockContext ec)
+		protected override bool DoResolve (BlockContext bc)
 		{
-			iterator = ec.CurrentIterator;
-			return Yield.CheckContext (ec, loc);
+			iterator = bc.CurrentIterator;
+			return Yield.CheckContext (bc, loc);
 		}
 
 		protected override void DoEmit (EmitContext ec)
 		{
 			iterator.EmitYieldBreak (ec, unwind_protect);
 		}
+
+		protected override bool DoFlowAnalysis (FlowAnalysisContext fc)
+		{
+			return true;
+		}
+
+		public override Reachability MarkReachable (Reachability rc)
+		{
+			base.MarkReachable (rc);
+			return Reachability.CreateUnreachable ();
+		}
 		
 		public override object Accept (StructuralVisitor visitor)
 		{
@@ -265,7 +308,6 @@ namespace Mono.CSharp
 					if (new_storey != null)
 						new_storey = Convert.ImplicitConversionRequired (ec, new_storey, host_method.MemberType, loc);
 
-					ec.CurrentBranching.CurrentUsageVector.Goto ();
 					return true;
 				}
 
@@ -293,10 +335,21 @@ namespace Mono.CSharp
 					new_storey.Emit (ec);
 					ec.Emit (OpCodes.Ret);
 				}
+
+				protected override bool DoFlowAnalysis (FlowAnalysisContext fc)
+				{
+					throw new NotImplementedException ();
+				}
+
+				public override Reachability MarkReachable (Reachability rc)
+				{
+					base.MarkReachable (rc);
+					return Reachability.CreateUnreachable ();
+				}
 			}
 
 			GetEnumeratorMethod (IteratorStorey host, FullNamedExpression returnType, MemberName name)
-				: base (host, null, returnType, Modifiers.DEBUGGER_HIDDEN, name)
+				: base (host, null, returnType, Modifiers.DEBUGGER_HIDDEN, name, ToplevelBlock.Flags.CompilerGenerated | ToplevelBlock.Flags.NoFlowAnalysis)
 			{
 			}
 
@@ -310,7 +363,6 @@ namespace Mono.CSharp
 				var m = new GetEnumeratorMethod (host, returnType, name);
 				var stmt = statement ?? new GetEnumeratorStatement (host, m);
 				m.block.AddStatement (stmt);
-				m.block.IsCompilerGenerated = true;
 				return m;
 			}
 		}
@@ -342,16 +394,20 @@ namespace Mono.CSharp
 					ec.CurrentAnonymousMethod = iterator;
 					iterator.EmitDispose (ec);
 				}
+
+				protected override bool DoFlowAnalysis (FlowAnalysisContext fc)
+				{
+					throw new NotImplementedException ();
+				}
 			}
 
 			public DisposeMethod (IteratorStorey host)
 				: base (host, null, new TypeExpression (host.Compiler.BuiltinTypes.Void, host.Location), Modifiers.PUBLIC | Modifiers.DEBUGGER_HIDDEN,
-					new MemberName ("Dispose", host.Location))
+					new MemberName ("Dispose", host.Location), ToplevelBlock.Flags.CompilerGenerated | ToplevelBlock.Flags.NoFlowAnalysis)
 			{
 				host.Members.Add (this);
 
 				Block.AddStatement (new DisposeMethodStatement (host.Iterator));
-				Block.IsCompilerGenerated = true;
 			}
 		}
 
@@ -546,9 +602,8 @@ namespace Mono.CSharp
 
 			var name = new MemberName ("Current", null, explicit_iface, Location);
 
-			ToplevelBlock get_block = new ToplevelBlock (Compiler, Location) {
-				IsCompilerGenerated = true
-			};
+			ToplevelBlock get_block = new ToplevelBlock (Compiler, ParametersCompiled.EmptyReadOnlyParameters, Location,
+				Block.Flags.CompilerGenerated | Block.Flags.NoFlowAnalysis);
 			get_block.AddStatement (new Return (new DynamicFieldExpr (CurrentField, Location), Location));
 				
 			Property current = new Property (this, type, Modifiers.DEBUGGER_HIDDEN | Modifiers.COMPILER_GENERATED, name, null);
@@ -567,9 +622,8 @@ namespace Mono.CSharp
 				ParametersCompiled.EmptyReadOnlyParameters, null);
 			Members.Add (reset);
 
-			reset.Block = new ToplevelBlock (Compiler, Location) {
-				IsCompilerGenerated = true
-			};
+			reset.Block = new ToplevelBlock (Compiler, reset.ParameterInfo, Location,
+				Block.Flags.CompilerGenerated | Block.Flags.NoFlowAnalysis);
 
 			TypeSpec ex_type = Module.PredefinedTypes.NotSupportedException.Resolve ();
 			if (ex_type == null)
@@ -590,12 +644,13 @@ namespace Mono.CSharp
 	{
 		readonly StateMachineInitializer expr;
 
-		public StateMachineMethod (StateMachine host, StateMachineInitializer expr, FullNamedExpression returnType, Modifiers mod, MemberName name)
+		public StateMachineMethod (StateMachine host, StateMachineInitializer expr, FullNamedExpression returnType,
+			Modifiers mod, MemberName name, ToplevelBlock.Flags blockFlags)
 			: base (host, returnType, mod | Modifiers.COMPILER_GENERATED,
 			  name, ParametersCompiled.EmptyReadOnlyParameters, null)
 		{
 			this.expr = expr;
-			Block = new ToplevelBlock (host.Compiler, ParametersCompiled.EmptyReadOnlyParameters, Location.Null);
+			Block = new ToplevelBlock (host.Compiler, ParametersCompiled.EmptyReadOnlyParameters, Location.Null, blockFlags);
 		}
 
 		public override EmitContext CreateEmitContext (ILGenerator ig, SourceMethodBuilder sourceMethod)
@@ -642,6 +697,21 @@ namespace Mono.CSharp
 				// Don't create sequence point
 				DoEmit (ec);
 			}
+
+			protected override bool DoFlowAnalysis (FlowAnalysisContext fc)
+			{
+				return state_machine.ReturnType.Kind != MemberKind.Void;
+			}
+
+			public override Reachability MarkReachable (Reachability rc)
+			{
+				base.MarkReachable (rc);
+
+				if (state_machine.ReturnType.Kind != MemberKind.Void)
+					rc = Reachability.CreateUnreachable ();
+
+				return rc;
+			}
 		}
 
 		public readonly TypeDefinition Host;
@@ -706,34 +776,33 @@ namespace Mono.CSharp
 			throw new NotSupportedException ("ET");
 		}
 
-		protected virtual BlockContext CreateBlockContext (ResolveContext rc)
+		protected virtual BlockContext CreateBlockContext (BlockContext bc)
 		{
-			var ctx = new BlockContext (rc, block, ((BlockContext) rc).ReturnType);
+			var ctx = new BlockContext (bc, block, bc.ReturnType);
 			ctx.CurrentAnonymousMethod = this;
+
+			ctx.AssignmentInfoOffset = bc.AssignmentInfoOffset;
+			ctx.EnclosingLoop = bc.EnclosingLoop;
+			ctx.EnclosingLoopOrSwitch = bc.EnclosingLoopOrSwitch;
+			ctx.Switch = bc.Switch;
+
 			return ctx;
 		}
 
-		protected override Expression DoResolve (ResolveContext ec)
+		protected override Expression DoResolve (ResolveContext rc)
 		{
-			var ctx = CreateBlockContext (ec);
+			var bc = (BlockContext) rc;
+			var ctx = CreateBlockContext (bc);
 
 			Block.Resolve (ctx);
 
-			//
-			// Explicit return is required for Task<T> state machine
-			//
-			var task_storey = storey as AsyncTaskStorey;
-			if (task_storey == null || (task_storey.ReturnType != null && !task_storey.ReturnType.IsGenericTask))
-				ctx.CurrentBranching.CurrentUsageVector.Goto ();
-
-			ctx.EndFlowBranching ();
-
-			if (!ec.IsInProbingMode) {
-				var move_next = new StateMachineMethod (storey, this, new TypeExpression (ReturnType, loc), Modifiers.PUBLIC, new MemberName ("MoveNext", loc));
+			if (!rc.IsInProbingMode) {
+				var move_next = new StateMachineMethod (storey, this, new TypeExpression (ReturnType, loc), Modifiers.PUBLIC, new MemberName ("MoveNext", loc), 0);
 				move_next.Block.AddStatement (new MoveNextBodyStatement (this));
 				storey.AddEntryMethod (move_next);
 			}
 
+			bc.AssignmentInfoOffset = ctx.AssignmentInfoOffset;
 			eclass = ExprClass.Value;
 			return this;
 		}
@@ -936,6 +1005,11 @@ namespace Mono.CSharp
 				throw new NotSupportedException ();
 			}
 
+			protected override bool DoFlowAnalysis (FlowAnalysisContext fc)
+			{
+				throw new NotSupportedException ();
+			}
+
 			protected override void DoEmit (EmitContext ec)
 			{
 				//
@@ -985,8 +1059,8 @@ namespace Mono.CSharp
 				Modifiers.COMPILER_GENERATED, new MemberName (CompilerGeneratedContainer.MakeName (null, null, "Finally", finally_hosts_counter++), loc),
 				ParametersCompiled.EmptyReadOnlyParameters, null);
 
-			method.Block = new ToplevelBlock (method.Compiler, method.ParameterInfo, loc);
-			method.Block.IsCompilerGenerated = true;
+			method.Block = new ToplevelBlock (method.Compiler, method.ParameterInfo, loc,
+				ToplevelBlock.Flags.CompilerGenerated | ToplevelBlock.Flags.NoFlowAnalysis);
 			method.Block.AddStatement (new TryFinallyBlockProxyStatement (this, block));
 
 			// Cannot it add to storey because it'd be emitted before nested
@@ -1097,13 +1171,6 @@ namespace Mono.CSharp
 			ec.MarkLabel (resume_point);
 		}
 
-		protected override BlockContext CreateBlockContext (ResolveContext rc)
-		{
-			var bc = base.CreateBlockContext (rc);
-			bc.StartFlowBranching (this, rc.CurrentBranching);
-			return bc;
-		}
-
 		public static void CreateIterator (IMethodData method, TypeDefinition parent, Modifiers modifiers)
 		{
 			bool is_enumerable;

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/linq.cs

@@ -836,9 +836,8 @@ namespace Mono.CSharp.Linq
 		}
 
 		public QueryBlock (Block parent, Location start)
-			: base (parent, ParametersCompiled.EmptyReadOnlyParameters, start)
+			: base (parent, ParametersCompiled.EmptyReadOnlyParameters, start, Flags.CompilerGenerated)
 		{
-			flags |= Flags.CompilerGenerated;
 		}
 
 		public void AddRangeVariable (RangeVariable variable)

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/location.cs

@@ -222,7 +222,7 @@ namespace Mono.CSharp
 		// </summary>
 		static public void Initialize (List<SourceFile> files)
 		{
-#if NET_4_0 || MONODROID
+#if NET_4_0 || MOBILE_DYNAMIC
 			source_list.AddRange (files);
 #else
 			source_list.AddRange (files.ToArray ());

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/membercache.cs

@@ -464,6 +464,7 @@ namespace Mono.CSharp {
 			IList<MemberSpec> applicable;
 			TypeSpec best_match = null;
 			do {
+#if !FULL_AOT_RUNTIME
 				// TODO: Don't know how to handle this yet
 				// When resolving base type of nested type, parent type must have
 				// base type resolved to scan full hierarchy correctly
@@ -472,6 +473,7 @@ namespace Mono.CSharp {
 				var tc = container.MemberDefinition as TypeContainer;
 				if (tc != null)
 					tc.DefineContainer ();
+#endif
 
 				if (container.MemberCacheTypes.member_hash.TryGetValue (name, out applicable)) {
 					for (int i = applicable.Count - 1; i >= 0; i--) {

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/method.cs

@@ -205,6 +205,8 @@ namespace Mono.CSharp {
 		TypeSpec[] targs;
 		TypeParameterSpec[] constraints;
 
+		public static readonly MethodSpec Excluded = new MethodSpec (MemberKind.Method, InternalType.FakeInternalType, null, null, ParametersCompiled.EmptyReadOnlyParameters, 0);
+
 		public MethodSpec (MemberKind kind, TypeSpec declaringType, IMethodDefinition details, TypeSpec returnType,
 			AParametersCollection parameters, Modifiers modifiers)
 			: base (kind, declaringType, details, modifiers)
@@ -1464,7 +1466,7 @@ namespace Mono.CSharp {
 				} else {
 					//
 					// It is legal to have "this" initializers that take no arguments
-					// in structs, they are just no-ops.
+					// in structs
 					//
 					// struct D { public D (int a) : this () {}
 					//
@@ -1485,9 +1487,17 @@ namespace Mono.CSharp {
 
 		public override void Emit (EmitContext ec)
 		{
-			// It can be null for static initializers
-			if (base_ctor == null)
+			//
+			// It can be null for struct initializers or System.Object
+			//
+			if (base_ctor == null) {
+				if (type == ec.BuiltinTypes.Object)
+					return;
+
+				ec.Emit (OpCodes.Ldarg_0);
+				ec.Emit (OpCodes.Initobj, type);
 				return;
+			}
 			
 			var call = new CallEmitter ();
 			call.InstanceExpression = new CompilerGeneratedThis (type, loc); 
@@ -1498,6 +1508,12 @@ namespace Mono.CSharp {
 		{
 			Emit (ec);
 		}
+
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			if (argument_list != null)
+				argument_list.FlowAnalysis (fc);
+		}
 	}
 
 	public class ConstructorBaseInitializer : ConstructorInitializer {
@@ -1742,7 +1758,7 @@ namespace Mono.CSharp {
 					}
 				}
 
-				if (block.Resolve (null, bc, this)) {
+				if (block.Resolve (bc, this)) {
 					debug_builder = Parent.CreateMethodSymbolEntry ();
 					EmitContext ec = new EmitContext (this, ConstructorBuilder.GetILGenerator (), bc.ReturnType, debug_builder);
 					ec.With (EmitContext.Options.ConstructorScope, true);
@@ -2131,7 +2147,7 @@ namespace Mono.CSharp {
 			ToplevelBlock block = method.Block;
 			if (block != null) {
 				BlockContext bc = new BlockContext (method, block, method.ReturnType);
-				if (block.Resolve (null, bc, method)) {
+				if (block.Resolve (bc, method)) {
 					debug_builder = member.Parent.CreateMethodSymbolEntry ();
 					EmitContext ec = method.CreateEmitContext (MethodBuilder.GetILGenerator (), debug_builder);
 

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/namespace.cs

@@ -353,11 +353,20 @@ namespace Mono.CSharp {
 					}
 
 					if (best.MemberDefinition.IsImported && ts.MemberDefinition.IsImported) {
+						if (ts.Kind == MemberKind.MissingType)
+							continue;
+
+						if (best.Kind == MemberKind.MissingType) {
+							best = ts;
+							continue;
+						}
+
 						if (mode == LookupMode.Normal) {
 							ctx.Module.Compiler.Report.SymbolRelatedToPreviousError (best);
 							ctx.Module.Compiler.Report.SymbolRelatedToPreviousError (ts);
 							ctx.Module.Compiler.Report.Error (433, loc, "The imported type `{0}' is defined multiple times", ts.GetSignatureForError ());
 						}
+
 						break;
 					}
 

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/nullable.cs

@@ -201,6 +201,11 @@ namespace Mono.CSharp.Nullable
 			return uw != null && expr.Equals (uw.expr);
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			expr.FlowAnalysis (fc);
+		}
+
 		public Expression Original {
 			get {
 				return expr;
@@ -480,6 +485,11 @@ namespace Mono.CSharp.Nullable
 			ec.MarkLabel (end_label);
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			expr.FlowAnalysis (fc);
+		}
+
 		public void AddressOf (EmitContext ec, AddressOp mode)
 		{
 			unwrap.AddressOf (ec, mode);
@@ -1008,6 +1018,11 @@ namespace Mono.CSharp.Nullable
 			ec.MarkLabel (end_label);
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			Binary.FlowAnalysis (fc);
+		}
+
 		public override SLE.Expression MakeExpression (BuilderContext ctx)
 		{
 			return Binary.MakeExpression (ctx, Left, Right);
@@ -1221,6 +1236,14 @@ namespace Mono.CSharp.Nullable
 			ec.MarkLabel (end_label);
 		}
 
+		public override void FlowAnalysis (FlowAnalysisContext fc)
+		{
+			left.FlowAnalysis (fc);
+			var left_da = fc.BranchDefiniteAssignment ();
+			right.FlowAnalysis (fc);
+			fc.DefiniteAssignment = left_da;
+		}
+
 		protected override void CloneTo (CloneContext clonectx, Expression t)
 		{
 			NullCoalescingOperator target = (NullCoalescingOperator) t;

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/outline.cs

@@ -29,8 +29,6 @@
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 
-#if !NET_2_1
-
 using System;
 using System.Reflection;
 using System.Collections;
@@ -90,7 +88,9 @@ public class Outline {
 			OutlineParams (method.GetParameters ());
 			o.Write (")");
 
+#if NET_2_0
 			WriteGenericConstraints (t.GetGenericArguments ());
+#endif			
 	
 			o.WriteLine (";"); 
 			return;
@@ -119,9 +119,9 @@ public class Outline {
 			if (underlyingType != typeof (int))
 				o.Write (" : {0}", FormatType (underlyingType));
 		}
-
+#if NET_2_0
 		WriteGenericConstraints (t.GetGenericArguments ());
-
+#endif		
 		o.WriteLine (" {");
 		o.Indent++;
 
@@ -396,11 +396,15 @@ public class Outline {
 		}
 
 		o.Write (mi.Name);
+#if NET_2_0
 		o.Write (FormatGenericParams (mi.GetGenericArguments ()));
+#endif
 		o.Write (" (");
 		OutlineParams (mi.GetParameters ());
 		o.Write (")");
+#if NET_2_0
 		WriteGenericConstraints (mi.GetGenericArguments ());
+#endif
 		o.Write (";");
 	}
 	
@@ -559,6 +563,7 @@ public class Outline {
                 }
 	}
 
+#if NET_2_0
 	string FormatGenericParams (Type [] args)
 	{
 		StringBuilder sb = new StringBuilder ();
@@ -574,6 +579,7 @@ public class Outline {
 		sb.Append (">");
 		return sb.ToString ();
 	}
+#endif
 
 	// TODO: fine tune this so that our output is less verbose. We need to figure
 	// out a way to do this while not making things confusing.
@@ -673,7 +679,9 @@ public class Outline {
 	void GetTypeName (StringBuilder sb, Type t)
 	{
 		sb.Append (RemoveGenericArity (t.Name));
+#if NET_2_0
 		sb.Append (FormatGenericParams (t.GetGenericArguments ()));
+#endif
 	}
 
 	string GetFullName (Type t)
@@ -685,10 +693,12 @@ public class Outline {
 
 	void GetFullName_recursed (StringBuilder sb, Type t, bool recursed)
 	{
+#if NET_2_0
 		if (t.IsGenericParameter) {
 			sb.Append (t.Name);
 			return;
 		}
+#endif
 
 		if (t.DeclaringType != null) {
 			GetFullName_recursed (sb, t.DeclaringType, true);
@@ -706,6 +716,7 @@ public class Outline {
 		GetTypeName (sb, t);
 	}
 
+#if NET_2_0
 	void WriteGenericConstraints (Type [] args)
 	{
 
@@ -761,6 +772,7 @@ public class Outline {
 			}
 		}
 	}
+#endif
  
 	string OperatorFromName (string name)
 	{
@@ -1024,5 +1036,3 @@ public class Comparer : IComparer  {
 	}
 }
 }
-
-#endif

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/reflection.cs

@@ -219,7 +219,7 @@ namespace Mono.CSharp
 		//
 		public bool Create (AppDomain domain, AssemblyBuilderAccess access)
 		{
-#if STATIC
+#if STATIC || FULL_AOT_RUNTIME
 			throw new NotSupportedException ();
 #else
 			ResolveAssemblySecurityAttributes ();

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/support.cs

@@ -37,7 +37,7 @@ namespace Mono.CSharp {
 			return System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode (obj);
 		}
 	}
-#if !NET_4_0 && !MONODROID
+#if !NET_4_0 && !MOBILE_DYNAMIC
 	public class Tuple<T1, T2> : IEquatable<Tuple<T1, T2>>
 	{
 		public Tuple (T1 item1, T2 item2)

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Parser/mcs/typespec.cs

@@ -1416,6 +1416,7 @@ namespace Mono.CSharp
 		bool IsPartial { get; }
 		bool IsComImport { get; }
 		bool IsTypeForwarder { get; }
+		bool IsCyclicTypeForwarder { get; }
 		int TypeParametersCount { get; }
 		TypeParameterSpec[] TypeParameters { get; }
 
@@ -1487,6 +1488,12 @@ namespace Mono.CSharp
 			}
 		}
 
+		bool ITypeDefinition.IsCyclicTypeForwarder {
+			get {
+				return false;
+			}
+		}
+
 		public override string Name {
 			get {
 				return name;
@@ -1617,6 +1624,12 @@ namespace Mono.CSharp
 			}
 		}
 
+		bool ITypeDefinition.IsCyclicTypeForwarder {
+			get {
+				return false;
+			}
+		}
+
 		public override string Name {
 			get {
 				throw new NotSupportedException ();

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Refactoring/Script.cs

@@ -492,7 +492,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			{
 				int startOffset = stringWriter.GetStringBuilder ().Length;
 				int endOffset = startOffset + (identifier.Name ?? "").Length + (identifier.IsVerbatim ? 1 : 0);
-				NewSegments.Add(new KeyValuePair<AstNode, Segment>(identifier, new Segment(startOffset, endOffset)));
+				NewSegments.Add(new KeyValuePair<AstNode, Segment>(identifier, new Segment(startOffset, endOffset - startOffset)));
 				base.WriteIdentifier (identifier);
 			}
 			

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Refactoring/TypeGuessing.cs

@@ -68,14 +68,21 @@ namespace ICSharpCode.NRefactory.CSharp
 				}
 				foreach (var extMethods in targetResult.GetExtensionMethods ()) {
 					foreach (var extMethod in extMethods) {
-						if (index + 1 < extMethod.Parameters.Count) {
-							if (extMethod.Parameters [index + 1].IsParams) {
-								var arrayType = extMethod.Parameters [index + 1].Type as ArrayType;
+						IType[] inferredTypes;
+						var m = extMethod;
+						if (CSharpResolver.IsEligibleExtensionMethod(targetResult.TargetType, extMethod, true, out inferredTypes)) {
+							if (inferredTypes != null)
+								m = extMethod.Specialize(new TypeParameterSubstitution(null, inferredTypes));
+						}
+
+						int correctedIndex = index + 1;
+						if (correctedIndex < m.Parameters.Count) {
+							if (m.Parameters [correctedIndex].IsParams) {
+								var arrayType = m.Parameters [correctedIndex].Type as ArrayType;
 								if (arrayType != null)
 									yield return arrayType.ElementType;
 							}
-
-							yield return extMethod.Parameters [index + 1].Type;
+							yield return m.Parameters [correctedIndex].Type;
 						}
 					}
 				}

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Refactoring/TypeSystemAstBuilder.cs

@@ -559,6 +559,27 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 		#endregion
 		
 		#region Convert Entity
+		public AstNode ConvertSymbol(ISymbol symbol)
+		{
+			if (symbol == null)
+				throw new ArgumentNullException("symbol");
+			switch (symbol.SymbolKind) {
+				case SymbolKind.Namespace:
+					return ConvertNamespaceDeclaration((INamespace)symbol);
+				case SymbolKind.Variable:
+					return ConvertVariable((IVariable)symbol);
+				case SymbolKind.Parameter:
+					return ConvertParameter((IParameter)symbol);
+				case SymbolKind.TypeParameter:
+					return ConvertTypeParameter((ITypeParameter)symbol);
+				default:
+					IEntity entity = symbol as IEntity;
+					if (entity != null)
+						return ConvertEntity(entity);
+					throw new ArgumentException("Invalid value for SymbolKind: " + symbol.SymbolKind);
+			}
+		}
+		
 		public EntityDeclaration ConvertEntity(IEntity entity)
 		{
 			if (entity == null)
@@ -582,6 +603,9 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 					return ConvertConstructor((IMethod)entity);
 				case SymbolKind.Destructor:
 					return ConvertDestructor((IMethod)entity);
+				case SymbolKind.Accessor:
+					IMethod accessor = (IMethod)entity;
+					return ConvertAccessor(accessor, accessor.AccessorOwner != null ? accessor.AccessorOwner.Accessibility : Accessibility.None);
 				default:
 					throw new ArgumentException("Invalid value for SymbolKind: " + entity.SymbolKind);
 			}
@@ -944,5 +968,10 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			return decl;
 		}
 		#endregion
+		
+		NamespaceDeclaration ConvertNamespaceDeclaration(INamespace ns)
+		{
+			return new NamespaceDeclaration(ns.FullName);
+		}
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs

@@ -359,7 +359,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// </summary>
 		void ResolveAndProcessConversion(Expression expr, IType targetType)
 		{
-			if (targetType.Kind == TypeKind.Unknown || targetType.Kind == TypeKind.Void) {
+			if (targetType.Kind == TypeKind.Unknown) {
 				// no need to resolve the expression right now
 				Scan(expr);
 			} else {
@@ -2163,7 +2163,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				Analyze();
 				IType unpackedReturnType = isAsync ? visitor.UnpackTask(returnType) : returnType;
 				Log.WriteLine("Applying return type {0} to explicitly-typed lambda {1}", unpackedReturnType, this.LambdaExpression);
-				if (unpackedReturnType.Kind != TypeKind.Void) {
+				if (unpackedReturnType.Kind != TypeKind.Void || body is BlockStatement) {
 					for (int i = 0; i < returnExpressions.Count; i++) {
 						visitor.ProcessConversion(returnExpressions[i], returnValues[i], unpackedReturnType);
 					}
@@ -2502,7 +2502,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				}
 				
 				Log.WriteLine("Applying return type {0} to implicitly-typed lambda {1}", returnType, lambda.LambdaExpression);
-				if (returnType.Kind != TypeKind.Void) {
+				if (returnType.Kind != TypeKind.Void || lambda.BodyExpression is Statement) {
 					for (int i = 0; i < returnExpressions.Count; i++) {
 						visitor.ProcessConversion(returnExpressions[i], returnValues[i], returnType);
 					}
@@ -2697,7 +2697,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				// can be converted to delegates with void return type.
 				// This holds for both async and regular lambdas.
 				return isValidAsVoidMethod;
-			} else if (isAsync && IsTask(returnType) && returnType.TypeParameterCount == 0) {
+			} else if (isAsync && TaskType.IsTask(returnType) && returnType.TypeParameterCount == 0) {
 				// Additionally, async lambdas with the above property can be converted to non-generic Task.
 				return isValidAsVoidMethod;
 			} else {
@@ -2705,7 +2705,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					return isEndpointUnreachable;
 				if (isAsync) {
 					// async lambdas must return Task<T>
-					if (!(IsTask(returnType) && returnType.TypeParameterCount == 1))
+					if (!(TaskType.IsTask(returnType) && returnType.TypeParameterCount == 1))
 						return false;
 					// unpack Task<T> for testing the implicit conversions
 					returnType = ((ParameterizedType)returnType).GetTypeArgument(0);
@@ -2718,34 +2718,9 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		
-		/// <summary>
-		/// Gets the T in Task&lt;T&gt;.
-		/// Returns void for non-generic Task.
-		/// Any other type is returned unmodified.
-		/// </summary>
 		IType UnpackTask(IType type)
 		{
-			if (!IsTask(type))
-				return type;
-			if (type.TypeParameterCount == 0)
-				return resolver.Compilation.FindType(KnownTypeCode.Void);
-			else
-				return ((ParameterizedType)type).GetTypeArgument(0);
-		}
-		
-		/// <summary>
-		/// Gets whether the specified type is Task or Task&lt;T&gt;.
-		/// </summary>
-		static bool IsTask(IType type)
-		{
-			ITypeDefinition def = type.GetDefinition();
-			if (def != null) {
-				if (def.KnownTypeCode == KnownTypeCode.Task)
-					return true;
-				if (def.KnownTypeCode == KnownTypeCode.TaskOfT)
-					return type is ParameterizedType;
-			}
-			return false;
+			return TaskType.UnpackTask(resolver.Compilation, type);
 		}
 		
 		sealed class AnalyzeLambdaVisitor : DepthFirstAstVisitor
@@ -3035,7 +3010,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			if (resolverEnabled && !resolver.IsWithinLambdaExpression && resolver.CurrentMember != null) {
 				IType type = resolver.CurrentMember.ReturnType;
-				if (IsTask(type)) {
+				if (TaskType.IsTask(type)) {
 					var methodDecl = returnStatement.Ancestors.OfType<EntityDeclaration>().FirstOrDefault();
 					if (methodDecl != null && (methodDecl.Modifiers & Modifiers.Async) == Modifiers.Async)
 						type = UnpackTask(type);

src/Libraries/NRefactory/ICSharpCode.NRefactory.CSharp/TypeSystem/TypeSystemConvertVisitor.cs

@@ -1006,7 +1006,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 			public override ConstantExpression VisitPrimitiveExpression(PrimitiveExpression primitiveExpression)
 			{
 				object val = interningProvider.InternValue(primitiveExpression.Value);
-				TypeCode typeCode = Type.GetTypeCode(val.GetType());
+				TypeCode typeCode = (val == null ? TypeCode.Object : Type.GetTypeCode(val.GetType()));
 				return interningProvider.Intern(
 					new PrimitiveConstantExpression(typeCode.ToTypeReference(), val));
 			}

src/Libraries/NRefactory/ICSharpCode.NRefactory.Demo/CSDemo.cs

@@ -213,11 +213,18 @@ namespace ICSharpCode.NRefactory.Demo
 			ICompilation compilation = project.CreateCompilation();
 			
 			ResolveResult result;
+			IType expectedType = null;
+			Conversion conversion = null;
 			if (csharpTreeView.SelectedNode != null) {
 				var selectedNode = (AstNode)csharpTreeView.SelectedNode.Tag;
 				CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, unresolvedFile);
 				result = resolver.Resolve(selectedNode);
 				// CSharpAstResolver.Resolve() never returns null
+				Expression expr = selectedNode as Expression;
+				if (expr != null) {
+					expectedType = resolver.GetExpectedType(expr);
+					conversion = resolver.GetConversion(expr);
+				}
 			} else {
 				TextLocation location = GetTextLocation(csharpCodeTextBox, csharpCodeTextBox.SelectionStart);
 				result = ResolveAtLocation.Resolve(compilation, unresolvedFile, syntaxTree, location);
@@ -226,8 +233,14 @@ namespace ICSharpCode.NRefactory.Demo
 					return;
 				}
 			}
-			using (var dlg = new SemanticTreeDialog(result))
+			using (var dlg = new SemanticTreeDialog()) {
+				dlg.AddRoot("Resolve() = ", result);
+				if (expectedType != null)
+					dlg.AddRoot("GetExpectedType() = ", expectedType);
+				if (conversion != null)
+					dlg.AddRoot("GetConversion() = ", conversion);
 				dlg.ShowDialog();
+			}
 		}
 		
 		void CSharpCodeTextBoxKeyDown(object sender, KeyEventArgs e)

src/Libraries/NRefactory/ICSharpCode.NRefactory.Demo/SemanticTreeDialog.cs

@@ -32,14 +32,17 @@ namespace ICSharpCode.NRefactory.Demo
 	/// </summary>
 	public partial class SemanticTreeDialog : Form
 	{
-		public SemanticTreeDialog(ResolveResult rr)
+		public SemanticTreeDialog()
 		{
 			//
 			// The InitializeComponent() call is required for Windows Forms designer support.
 			//
 			InitializeComponent();
-			
-			var rootNode = MakeObjectNode("Resolve() = ", rr);
+		}
+		
+		public void AddRoot(string prefix, object obj)
+		{
+			var rootNode = MakeObjectNode(prefix, obj);
 			rootNode.Expand();
 			treeView.Nodes.Add(rootNode);
 		}

src/Libraries/NRefactory/ICSharpCode.NRefactory.IKVM/ICSharpCode.NRefactory.IKVM.csproj

@@ -21,6 +21,7 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <ConsolePause>false</ConsolePause>
+	<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>full</DebugType>
@@ -29,6 +30,27 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <ConsolePause>false</ConsolePause>
+	<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'net_4_5_Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug</OutputPath>
+    <DefineConstants>DEBUG;</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <ConsolePause>false</ConsolePause>
+	<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'net_4_5_Release|AnyCPU' ">
+    <DebugType>full</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release</OutputPath>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <ConsolePause>false</ConsolePause>
+	<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
@@ -57,4 +79,4 @@
       <Name>ICSharpCode.NRefactory</Name>
     </ProjectReference>
   </ItemGroup>
-</Project>
+</Project>

src/Libraries/NRefactory/ICSharpCode.NRefactory.Tests/CSharp/Analysis/SemanticHighlightingTests.cs

@@ -420,6 +420,25 @@ partial class Test
 }
 ", inactiveCodeColor);
 		}
+	
+
+		/// <summary>
+		/// Bug 17011 - XS does not recognize StringBuilder::AppendFormat 
+		/// </summary>
+		[Test]
+		public void TestBug17011()
+		{
+			TestColor (@"
+using System.Text;
+
+class TestClass
+{
+	void Foo(StringBuilder sb)
+	{
+		sb.AppendFormat(""${0} ${1}"", 1, 2);
+	}
+}", stringFormatItemColor);
+		}
 	}
 }
 

src/Libraries/NRefactory/ICSharpCode.NRefactory.Tests/CSharp/CSharpAmbienceTests.cs

@@ -48,8 +48,8 @@ namespace ICSharpCode.NRefactory.CSharp
 		public void GenericType()
 		{
 			var typeDef = compilation.FindType(typeof(Dictionary<,>)).GetDefinition();
-			ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedMemberNames | ConversionFlags.ShowTypeParameterList;
-			string result = ambience.ConvertEntity(typeDef);
+			ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedEntityNames | ConversionFlags.ShowTypeParameterList;
+			string result = ambience.ConvertSymbol(typeDef);
 			
 			Assert.AreEqual("System.Collections.Generic.Dictionary<TKey, TValue>", result);
 		}
@@ -59,7 +59,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			var typeDef = compilation.FindType(typeof(Dictionary<,>)).GetDefinition();
 			ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList;
-			string result = ambience.ConvertEntity(typeDef);
+			string result = ambience.ConvertSymbol(typeDef);
 			
 			Assert.AreEqual("Dictionary<TKey, TValue>", result);
 		}
@@ -68,8 +68,8 @@ namespace ICSharpCode.NRefactory.CSharp
 		public void SimpleType()
 		{
 			var typeDef = compilation.FindType(typeof(Object)).GetDefinition();
-			ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedMemberNames | ConversionFlags.ShowTypeParameterList;
-			string result = ambience.ConvertEntity(typeDef);
+			ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedEntityNames | ConversionFlags.ShowTypeParameterList;
+			string result = ambience.ConvertSymbol(typeDef);
 			
 			Assert.AreEqual("System.Object", result);
 		}
@@ -78,8 +78,8 @@ namespace ICSharpCode.NRefactory.CSharp
 		public void SimpleTypeDefinition()
 		{
 			var typeDef = compilation.FindType(typeof(Object)).GetDefinition();
-			ambience.ConversionFlags = ConversionFlags.All & ~(ConversionFlags.UseFullyQualifiedTypeNames | ConversionFlags.UseFullyQualifiedMemberNames);
-			string result = ambience.ConvertEntity(typeDef);
+			ambience.ConversionFlags = ConversionFlags.All & ~(ConversionFlags.UseFullyQualifiedEntityNames);
+			string result = ambience.ConvertSymbol(typeDef);
 			
 			Assert.AreEqual("public class Object", result);
 		}
@@ -88,8 +88,8 @@ namespace ICSharpCode.NRefactory.CSharp
 		public void SimpleTypeDefinitionWithoutModifiers()
 		{
 			var typeDef = compilation.FindType(typeof(Object)).GetDefinition();
-			ambience.ConversionFlags = ConversionFlags.All & ~(ConversionFlags.UseFullyQualifiedTypeNames | ConversionFlags.UseFullyQualifiedMemberNames | ConversionFlags.ShowModifiers | ConversionFlags.ShowAccessibility);
-			string result = ambience.ConvertEntity(typeDef);
+			ambience.ConversionFlags = ConversionFlags.All & ~(ConversionFlags.UseFullyQualifiedEntityNames | ConversionFlags.ShowModifiers | ConversionFlags.ShowAccessibility);
+			string result = ambience.ConvertSymbol(typeDef);
 			
 			Assert.AreEqual("class Object", result);
 		}
@@ -99,7 +99,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			var typeDef = compilation.FindType(typeof(List<>)).GetDefinition();
 			ambience.ConversionFlags = ConversionFlags.All;
-			string result = ambience.ConvertEntity(typeDef);
+			string result = ambience.ConvertSymbol(typeDef);
 			
 			Assert.AreEqual("public class System.Collections.Generic.List<T>", result);
 		}
@@ -109,7 +109,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			var typeDef = compilation.FindType(typeof(IEnumerable<>)).GetDefinition();
 			ambience.ConversionFlags = ConversionFlags.All;
-			string result = ambience.ConvertEntity(typeDef);
+			string result = ambience.ConvertSymbol(typeDef);
 			
 			Assert.AreEqual("public interface System.Collections.Generic.IEnumerable<out T>", result);
 		}
@@ -119,7 +119,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			var typeDef = compilation.FindType(typeof(Object)).GetDefinition();
 			ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList;
-			string result = ambience.ConvertEntity(typeDef);
+			string result = ambience.ConvertSymbol(typeDef);
 			
 			Assert.AreEqual("Object", result);
 		}
@@ -128,8 +128,8 @@ namespace ICSharpCode.NRefactory.CSharp
 		public void GenericTypeWithNested()
 		{
 			var typeDef = compilation.FindType(typeof(List<>.Enumerator)).GetDefinition();
-			ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedTypeNames | ConversionFlags.UseFullyQualifiedMemberNames | ConversionFlags.ShowTypeParameterList;
-			string result = ambience.ConvertEntity(typeDef);
+			ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedEntityNames | ConversionFlags.ShowTypeParameterList;
+			string result = ambience.ConvertSymbol(typeDef);
 			
 			Assert.AreEqual("System.Collections.Generic.List<T>.Enumerator", result);
 		}
@@ -139,7 +139,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			var typeDef = compilation.FindType(typeof(List<>.Enumerator)).GetDefinition();
 			ambience.ConversionFlags = ConversionFlags.ShowDeclaringType | ConversionFlags.ShowTypeParameterList;
-			string result = ambience.ConvertEntity(typeDef);
+			string result = ambience.ConvertSymbol(typeDef);
 			
 			Assert.AreEqual("List<T>.Enumerator", result);
 		}
@@ -152,7 +152,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			var func = compilation.FindType(typeof(Func<,>)).GetDefinition();
 			ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList;
 			
-			Assert.AreEqual("Func<in T, out TResult>", ambience.ConvertEntity(func));
+			Assert.AreEqual("Func<in T, out TResult>", ambience.ConvertSymbol(func));
 		}
 		
 		[Test]
@@ -160,7 +160,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			var func = compilation.FindType(typeof(Func<,>)).GetDefinition();
 			ambience.ConversionFlags = ConversionFlags.All;
-			Assert.AreEqual("public delegate TResult System.Func<in T, out TResult>(T arg);", ambience.ConvertEntity(func));
+			Assert.AreEqual("public delegate TResult System.Func<in T, out TResult>(T arg);", ambience.ConvertSymbol(func));
 		}
 		#endregion
 		
@@ -170,7 +170,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			var field = compilation.FindType(typeof(CSharpAmbienceTests.Program)).GetFields(f => f.Name == "test").Single();
 			ambience.ConversionFlags = ConversionFlags.All;
-			string result = ambience.ConvertEntity(field);
+			string result = ambience.ConvertSymbol(field);
 			
 			Assert.AreEqual("private int ICSharpCode.NRefactory.CSharp.CSharpAmbienceTests.Program.test;", result);
 		}
@@ -180,7 +180,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			var field = compilation.FindType(typeof(CSharpAmbienceTests.Program)).GetFields(f => f.Name == "TEST2").Single();
 			ambience.ConversionFlags = ConversionFlags.All;
-			string result = ambience.ConvertEntity(field);
+			string result = ambience.ConvertSymbol(field);
 			
 			Assert.AreEqual("private const int ICSharpCode.NRefactory.CSharp.CSharpAmbienceTests.Program.TEST2;", result);
 		}
@@ -190,7 +190,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			var field = compilation.FindType(typeof(CSharpAmbienceTests.Program)).GetFields(f => f.Name == "test").Single();
 			ambience.ConversionFlags = ConversionFlags.All & ~(ConversionFlags.ShowDeclaringType | ConversionFlags.ShowModifiers | ConversionFlags.ShowAccessibility);
-			string result = ambience.ConvertEntity(field);
+			string result = ambience.ConvertSymbol(field);
 			
 			Assert.AreEqual("int test;", result);
 		}
@@ -202,7 +202,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			var ev = compilation.FindType(typeof(CSharpAmbienceTests.Program)).GetEvents(f => f.Name == "ProgramChanged").Single();
 			ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.ShowDeclaringType;
-			string result = ambience.ConvertEntity(ev);
+			string result = ambience.ConvertSymbol(ev);
 			
 			Assert.AreEqual("public event EventHandler Program.ProgramChanged;", result);
 		}
@@ -212,7 +212,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			var ev = compilation.FindType(typeof(CSharpAmbienceTests.Program)).GetEvents(f => f.Name == "SomeEvent").Single();
 			ambience.ConversionFlags = ConversionFlags.StandardConversionFlags;
-			string result = ambience.ConvertEntity(ev);
+			string result = ambience.ConvertSymbol(ev);
 			
 			Assert.AreEqual("public event EventHandler SomeEvent;", result);
 		}
@@ -224,7 +224,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			var prop = compilation.FindType(typeof(CSharpAmbienceTests.Program)).GetProperties(p => p.Name == "Test").Single();
 			ambience.ConversionFlags = ConversionFlags.StandardConversionFlags;
-			string result = ambience.ConvertEntity(prop);
+			string result = ambience.ConvertSymbol(prop);
 			
 			Assert.AreEqual("public int Test { get; set; }", result);
 		}
@@ -234,7 +234,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			var prop = compilation.FindType(typeof(CSharpAmbienceTests.Program)).GetProperties(p => p.IsIndexer).Single();
 			ambience.ConversionFlags = ConversionFlags.StandardConversionFlags;
-			string result = ambience.ConvertEntity(prop);
+			string result = ambience.ConvertSymbol(prop);
 			
 			Assert.AreEqual("public int this[int index] { get; }", result);
 		}

src/Libraries/NRefactory/ICSharpCode.NRefactory.Tests/CSharp/CodeActions/ExtractMethodTests.cs

@@ -610,6 +610,24 @@ class TestClass
 	{
 		NewMethod ();
 	}
+}");
+		}
+
+		/// <summary>
+		/// Bug 11948 - Extract method incorrectly extracts code that contains yield return
+		/// </summary>
+		[Test]
+		public void TestBug11948()
+		{
+			TestWrongContext<ExtractMethodAction>(@"class TestClass
+{
+	int member = 5;
+	IEnumerable<int> TestMethod ()
+	{
+		int i = 5;
+		<-yield return i;->
+		Console.WriteLine (i);
+	}
 }");
 		}
 	}

src/Libraries/NRefactory/ICSharpCode.NRefactory.Tests/CSharp/CodeCompletion/CodeCompletionCSharpTests.cs

@@ -28,6 +28,7 @@
 
 using System;
 using NUnit.Framework;
+using System.Linq;
 
 namespace ICSharpCode.NRefactory.CSharp.CodeCompletion
 {
@@ -342,6 +343,28 @@ public class TestMyLongName
 			Assert.IsNotNull (provider.Find ("name"), "name 'name' not found.");
 		}
 
-		
+		[Test()]
+		public void TestMethodCreationCompletionWithLambda ()
+		{
+			CompletionDataList provider = CodeCompletionBugTests.CreateProvider (
+@"
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+class Test
+{
+	public void TestMethod (string[] args)
+	{
+		$args.FirstOrDefault(d$
+	}
+}
+");
+			Assert.IsNotNull (provider, "provider == null");
+			Assert.IsNotNull (provider.Find ("delegate"), "completion item 'delegate' not found!");
+			Assert.IsNotNull (provider.Find ("async delegate"), "completion item 'async delegate' not found!");
+			Assert.IsNotNull (provider.Find ("(string arg)"), "completion item '(string arg)' not found!");
+			Assert.IsNotNull (provider.Find ("HandleFunc"), "completion item 'HandleFuncpredicate' not found!");
+		}
 	}
 }

src/Libraries/NRefactory/ICSharpCode.NRefactory.Tests/CSharp/CodeCompletion/KeywordTests.cs

@@ -577,6 +577,43 @@ if (o as $s$
 				Assert.IsNotNull (provider.Find ("string"), "keyword 'string' not found.");
 			});
 		}
+
+		[Test]
+		public void ForeachInKeyword ()
+		{
+			CodeCompletionBugTests.CombinedProviderTest (
+				@"using System;
+class Test
+{
+	public static void Main (string[] args)
+	{
+		$foreach (var foo i$
+	}
+}
+", (provider) => {
+					Assert.IsNotNull (provider, "provider == null");
+					Assert.IsNotNull (provider.Find ("in"), "keyword 'in' not found.");
+				});
+		}
+
+		[Test]
+		public void ForeachInKeyword_NestedCase ()
+		{
+			CodeCompletionBugTests.CombinedProviderTest (
+				@"using System;
+class Test
+{
+	public static void Main (string[] args)
+	{
+		$foreach (var foo in args)
+			foreach (var c i$
+	}
+}
+", (provider) => {
+					Assert.IsNotNull (provider, "provider == null");
+					Assert.IsNotNull (provider.Find ("in"), "keyword 'in' not found.");
+				});
+		}
 	}
 }
 

src/Libraries/NRefactory/ICSharpCode.NRefactory.Tests/CSharp/CodeCompletion/NameContextTests.cs

@@ -289,6 +289,23 @@ class Foo
 
 		}
 
+		[Test]
+		public void TestBug16491Case2 ()
+		{
+			CodeCompletionBugTests.CombinedProviderTest (@"
+using System;
+using System.IO;
+
+class Foo
+{
+	public static void Main (string[] args)
+	{
+		new Action<int, int> ((x$, y$)
+	}
+}
+", provider => Assert.AreEqual(0, provider.Count, "provider needs to be empty"));
+
+		}
 	}
 }
 

src/Libraries/NRefactory/ICSharpCode.NRefactory.Tests/CSharp/CodeCompletion/ObjectInitializerTests.cs

@@ -746,6 +746,25 @@ class C : S
 			});
 			
 		}
+		
+		[Test]
+		public void TestUnfinishedDictionaryInitializer()
+		{
+			CodeCompletionBugTests.CombinedProviderTest(
+@"class Test
+{
+	public static void Main(string [] args)
+	{
+		var dict = new Dictionary<char, char> {
+			{ a$
+		}
+	}
+}
+",
+				provider => {
+					Assert.IsNotNull(provider.Find("args"), "'args' not found.");
+				});
+		}
 	}
 }
 

src/Libraries/NRefactory/ICSharpCode.NRefactory.Tests/CSharp/CodeIssues/CS0126ReturnMustBeFollowedByAnyExpressionTestes.cs

@@ -330,6 +330,63 @@ class Test
 	}
 }");
 		}
+		
+		[Test]
+		public void TestAsyncMethod_Void()
+		{
+			var input = @"using System;
+using System.Threading.Tasks;
+
+class Test
+{
+	public async void M()
+	{
+		return;
+	}
+}";
+
+			TestRefactoringContext context;
+			var issues = GetIssues (new CS0126ReturnMustBeFollowedByAnyExpression (), input, out context);
+			Assert.AreEqual (0, issues.Count);
+		}
+		
+		[Test]
+		public void TestAsyncMethod_Task()
+		{
+			var input = @"using System;
+using System.Threading.Tasks;
+
+class Test
+{
+	public async Task M()
+	{
+		return;
+	}
+}";
+
+			TestRefactoringContext context;
+			var issues = GetIssues (new CS0126ReturnMustBeFollowedByAnyExpression (), input, out context);
+			Assert.AreEqual (0, issues.Count);
+		}
+		
+		[Test]
+		public void TestAsyncMethod_TaskOfInt()
+		{
+			var input = @"using System;
+using System.Threading.Tasks;
+
+class Test
+{
+	public async Task<int> M()
+	{
+		return;
+	}
+}";
+
+			TestRefactoringContext context;
+			var issues = GetIssues (new CS0126ReturnMustBeFollowedByAnyExpression (), input, out context);
+			Assert.AreEqual (1, issues.Count);
+		}
 	}
 }