Merge branch 'master' into bug802073

136 files changed, 2687 insertions, 2519 deletions

diff --git a/main/src/addins/AspNet/WebForms/WebFormsToolboxNode.cs b/main/src/addins/AspNet/WebForms/WebFormsToolboxNode.cs
index 0a0ec73240..cb553fe696 100644
--- a/main/src/addins/AspNet/WebForms/WebFormsToolboxNode.cs
+++ b/main/src/addins/AspNet/WebForms/WebFormsToolboxNode.cs
@@ -129,7 +129,7 @@ namespace MonoDevelop.AspNet.WebForms
 			if (cls == null)
 				return tag;
 
-			var ed = document.GetContent<WebFormsEditorExtension> ();
+			var ed = document.GetContent<WebFormsEditorExtension> (true);
 			if (ed == null)
 				return tag;
 
diff --git a/main/src/addins/CSharpBinding/CSharpBinding.csproj b/main/src/addins/CSharpBinding/CSharpBinding.csproj
index 080a716769..2027c0db24 100644
--- a/main/src/addins/CSharpBinding/CSharpBinding.csproj
+++ b/main/src/addins/CSharpBinding/CSharpBinding.csproj
@@ -238,7 +238,6 @@
     <Compile Include="Util\PortingExtensions.cs" />
     <Compile Include="MonoDevelop.CSharp.Completion\CompletionProvider\FormatItemCompletionProvider.cs" />
     <Compile Include="MonoDevelop.CSharp.Completion\CompletionProvider\CastCompletionProvider.cs" />
-    <Compile Include="MonoDevelop.CSharp.Completion\CompletionProvider\RegexCompletionProvider.cs" />
     <Compile Include="MonoDevelop.CSharp.Refactoring\CSharpSnippetInfoService.cs" />
     <Compile Include="MonoDevelop.CSharp.Completion\ParameterUtil.cs" />
     <Compile Include="MonoDevelop.CSharp.Completion\CompletionProvider\DelegateCompletionProvider.cs" />
@@ -291,6 +290,7 @@
     <Compile Include="MonoDevelop.CSharp.Debugger\RoslynDebugInfoProvider.cs" />
     <Compile Include="MonoDevelop.CSharp.Refactoring\CommandArgsFactories.cs" />
     <Compile Include="MonoDevelop.CSharp.Debugger\DebuggerCompletionController.cs" />
+    <Compile Include="MonoDevelop.CSharp.ClassOutline\CSharpOutlineTextEditorExtensionProvider.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="MonoDevelop.CSharp.CodeRefactorings\ConvertToEnum\ConvertToEnumCodeRefactoringProvider.cs" />
diff --git a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.ClassOutline/CSharpOutlineTextEditorExtension.cs b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.ClassOutline/CSharpOutlineTextEditorExtension.cs
index d4f471de04..09d51c74e1 100644
--- a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.ClassOutline/CSharpOutlineTextEditorExtension.cs
+++ b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.ClassOutline/CSharpOutlineTextEditorExtension.cs
@@ -31,19 +31,16 @@ using System.Collections.Generic;
 using Gtk;
 
 using MonoDevelop.Core;
-using MonoDevelop.Ide.Gui.Content;
 using MonoDevelop.Ide;
 using MonoDevelop.Components;
 using MonoDevelop.Components.Docking;
-using MonoDevelop.Ide.TypeSystem;
 using MonoDevelop.DesignerSupport;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Text;
-using Microsoft.CodeAnalysis.CSharp;
 using MonoDevelop.Projects;
 using MonoDevelop.Ide.Editor.Extension;
 using MonoDevelop.Ide.Editor;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.CSharp;
 
 namespace MonoDevelop.CSharp.ClassOutline
 {
@@ -67,7 +64,7 @@ namespace MonoDevelop.CSharp.ClassOutline
 		MonoDevelop.Ide.Gui.Components.PadTreeView outlineTreeView;
 		TreeStore outlineTreeStore;
 		TreeModelSort outlineTreeModelSort;
-		Widget[] toolbarWidgets;
+		Widget [] toolbarWidgets;
 
 		OutlineNodeComparer comparer;
 		OutlineSettings settings;
@@ -76,6 +73,18 @@ namespace MonoDevelop.CSharp.ClassOutline
 		bool disposed;
 		bool outlineReady;
 
+		Document providedAnalysisDocument;
+
+
+		public CSharpOutlineTextEditorExtension ()
+		{
+			// does nothing, but is here for legacy editor support
+		}
+
+		public CSharpOutlineTextEditorExtension (Document document)
+		{
+			providedAnalysisDocument = document;
+		}
 
 		public override bool IsValidInContext (DocumentContext context)
 		{
@@ -109,9 +118,9 @@ namespace MonoDevelop.CSharp.ClassOutline
 			if (outlineTreeView != null)
 				return outlineTreeView;
 
-			outlineTreeStore = new TreeStore (typeof(object));
+			outlineTreeStore = new TreeStore (typeof (object));
 			outlineTreeModelSort = new TreeModelSort (outlineTreeStore);
-			
+
 			settings = OutlineSettings.Load ();
 			comparer = new OutlineNodeComparer (new AstAmbience (IdeApp.TypeSystemService.Workspace.Options), settings, outlineTreeModelSort);
 
@@ -141,7 +150,7 @@ namespace MonoDevelop.CSharp.ClassOutline
 			outlineTreeView.Selection.Changed += delegate {
 				JumpToDeclaration (false);
 			};
-			
+
 			outlineTreeView.RowActivated += delegate {
 				JumpToDeclaration (true);
 			};
@@ -155,17 +164,17 @@ namespace MonoDevelop.CSharp.ClassOutline
 			sw.ShowAll ();
 			return sw;
 		}
-		
+
 		IEnumerable<Widget> IOutlinedDocument.GetToolbarWidgets ()
 		{
 			if (toolbarWidgets != null)
 				return toolbarWidgets;
-			
+
 			var groupToggleButton = new ToggleButton {
 				Image = new ImageView (Ide.Gui.Stock.GroupByCategory, IconSize.Menu),
 				TooltipText = GettextCatalog.GetString ("Group entries by type"),
 				Active = settings.IsGrouped,
-			};	
+			};
 			groupToggleButton.Toggled += delegate {
 				if (groupToggleButton.Active == settings.IsGrouped)
 					return;
@@ -177,7 +186,7 @@ namespace MonoDevelop.CSharp.ClassOutline
 				Image = new ImageView (Ide.Gui.Stock.SortAlphabetically, IconSize.Menu),
 				TooltipText = GettextCatalog.GetString ("Sort entries alphabetically"),
 				Active = settings.IsSorted,
-			};	
+			};
 			sortAlphabeticallyToggleButton.Toggled += delegate {
 				if (sortAlphabeticallyToggleButton.Active == settings.IsSorted)
 					return;
@@ -197,15 +206,15 @@ namespace MonoDevelop.CSharp.ClassOutline
 					}
 				}
 			};
-			
-			return toolbarWidgets = new Widget[] {
+
+			return toolbarWidgets = new Widget [] {
 				groupToggleButton,
 				sortAlphabeticallyToggleButton,
 				new VSeparator (),
 				preferencesButton,
 			};
 		}
-		
+
 		void JumpToDeclaration (bool focusEditor)
 		{
 			if (!outlineReady)
@@ -217,6 +226,18 @@ namespace MonoDevelop.CSharp.ClassOutline
 			var o = outlineTreeStore.GetValue (IsSorting () ? outlineTreeModelSort.ConvertIterToChildIter (iter) : iter, 0);
 
 			var syntaxNode = o as SyntaxNode;
+
+			// if we can do it the "new" way, let's just do that ...
+			if (providedAnalysisDocument != null) {
+				var workspace = providedAnalysisDocument.Project.Solution.Workspace;
+				var navigationService = workspace.Services.GetService<Microsoft.CodeAnalysis.Navigation.IDocumentNavigationService> ();
+
+				navigationService.TryNavigateToSpan (workspace, providedAnalysisDocument.Id, syntaxNode?.Span ?? ((SyntaxTrivia)o).FullSpan);
+
+				return;
+			}
+
+			// ... and fallback to the legacy way if not
 			if (syntaxNode != null) {
 				Editor.CaretOffset = syntaxNode.SpanStart;
 			} else {
@@ -282,7 +303,7 @@ namespace MonoDevelop.CSharp.ClassOutline
 		uint refillOutlineStoreId;
 		async void UpdateDocumentOutline (object sender, EventArgs args)
 		{
-			var analysisDocument = DocumentContext.AnalysisDocument;
+			var analysisDocument = this.providedAnalysisDocument ?? DocumentContext?.AnalysisDocument;
 			if (analysisDocument == null)
 				return;
 			lastCU = await analysisDocument.GetSemanticModelAsync ();
@@ -302,7 +323,7 @@ namespace MonoDevelop.CSharp.ClassOutline
 				refillOutlineStoreId = 0;
 				return false;
 			}
-			
+
 			outlineReady = false;
 			outlineTreeStore.Clear ();
 			if (lastCU != null) {
@@ -338,7 +359,7 @@ namespace MonoDevelop.CSharp.ClassOutline
 				this.curIter = curIter;
 			}
 
-			TreeIter Append (object node) 
+			TreeIter Append (object node)
 			{
 				if (!curIter.Equals (TreeIter.Zero))
 					return store.AppendValues (curIter, node);
@@ -487,7 +508,7 @@ namespace MonoDevelop.CSharp.ClassOutline
 			var root = parsedDocument.SyntaxTree.GetRoot ();
 
 			var visitor = new TreeVisitor (store, parent);
-			visitor.Visit (root); 
+			visitor.Visit (root);
 		}
 
 		void UpdateSorting ()
diff --git a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.ClassOutline/CSharpOutlineTextEditorExtensionProvider.cs b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.ClassOutline/CSharpOutlineTextEditorExtensionProvider.cs
new file mode 100644
index 0000000000..dc5daa54e1
--- /dev/null
+++ b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.ClassOutline/CSharpOutlineTextEditorExtensionProvider.cs
@@ -0,0 +1,40 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+//
+// 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.ComponentModel.Composition;
+using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Utilities;
+using MonoDevelop.CSharp.ClassOutline;
+using MonoDevelop.TextEditor;
+
+namespace MonoDevelop.CSharp
+{
+	[Export (typeof (IEditorContentProvider))]
+	[ContentType (ContentTypeNames.CSharpContentType)]
+	[TextViewRole (PredefinedTextViewRoles.PrimaryDocument)]
+	class CSharpOutlineTextEditorExtensionProvider : EditorContentInstanceProvider<CSharpOutlineTextEditorExtension>
+	{
+		protected override CSharpOutlineTextEditorExtension CreateInstance (ITextView view) => new CSharpOutlineTextEditorExtension (view.TextSnapshot.GetOpenDocumentInCurrentContextWithChanges ());
+	}
+}
diff --git a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Completion/CompletionProvider/ProtocolMemberCompletionProvider.cs b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Completion/CompletionProvider/ProtocolMemberCompletionProvider.cs
index 1d1264f4d3..e707916017 100644
--- a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Completion/CompletionProvider/ProtocolMemberCompletionProvider.cs
+++ b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Completion/CompletionProvider/ProtocolMemberCompletionProvider.cs
@@ -151,13 +151,14 @@ namespace MonoDevelop.CSharp.Completion.Provider
 				var region = lastRegion == null ? null
 					: new CodeGeneratorBodyRegion (lastRegion.StartOffset - trimStart, lastRegion.EndOffset - trimStart);
 
+				var inlineDescription = GettextCatalog.GetString ("Implement protocol member");
 				pDict = pDict.Add ("InsertionText", sb.ToString ());
-				pDict = pDict.Add ("DescriptionMarkup", "- <span foreground=\"darkgray\" size='small'>" + GettextCatalog.GetString ("Implement protocol member") + "</span>");
+				pDict = pDict.Add ("DescriptionMarkup", "- <span foreground=\"darkgray\" size='small'>" + inlineDescription + "</span>");
 				pDict = pDict.Add ("Description", await GenerateQuickInfo (semanticModel, position, m, cancellationToken));
 				pDict = pDict.Add ("DeclarationBegin", declarationBegin.ToString());
 
 				var tags = ImmutableArray<string>.Empty.Add ("NewMethod");
-				var completionData = CompletionItem.Create (m.Name, sortText: m.ToSignatureDisplayString (), properties: pDict, rules: ProtocolCompletionRules, tags: tags);
+				var completionData = CompletionItem.Create (m.Name, sortText: m.ToSignatureDisplayString (), properties: pDict, rules: ProtocolCompletionRules, tags: tags, inlineDescription: inlineDescription);
 				context.AddItem (completionData);
 			}
 		}
diff --git a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Completion/CompletionProvider/RegexCompletionProvider.cs b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Completion/CompletionProvider/RegexCompletionProvider.cs
deleted file mode 100644
index fe297249b1..0000000000
--- a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Completion/CompletionProvider/RegexCompletionProvider.cs
+++ /dev/null
@@ -1,212 +0,0 @@
-//
-// RegexContextHandler.cs
-//
-// Author:
-//       Mike Krüger <mkrueger@xamarin.com>
-//
-// Copyright (c) 2015 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;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using System.Threading.Tasks;
-using ICSharpCode.NRefactory6.CSharp;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Completion;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Extensions;
-using Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Shared.Extensions;
-using Microsoft.CodeAnalysis.Text;
-using MonoDevelop.Core;
-using MonoDevelop.Ide.TypeSystem;
-
-namespace MonoDevelop.CSharp.Completion.Provider
-{
-	[ExportCompletionProvider ("RegexCompletionProvider", LanguageNames.CSharp)]
-	class RegexCompletionProvider : CommonCompletionProvider
-	{
-		internal static bool IsRegexMatchMethod (SymbolInfo symbolInfo)
-		{
-			var symbol = symbolInfo.Symbol;
-			if (symbol == null)
-				return false;
-			return IsRegexType (symbol.ContainingType) && symbol.IsStatic && (symbol.Name == "IsMatch" || symbol.Name == "Match" || symbol.Name == "Matches");
-		}
-
-		internal static bool IsRegexConstructor (SymbolInfo symbolInfo)
-		{
-			return symbolInfo.Symbol?.ContainingType is INamedTypeSymbol && IsRegexType (symbolInfo.Symbol.ContainingType);
-		}
-
-		internal static bool IsRegexType (INamedTypeSymbol containingType)
-		{
-			return containingType != null && containingType.Name == "Regex" && containingType.ContainingNamespace.GetFullName () == "System.Text.RegularExpressions";
-		}
-
-		public override bool ShouldTriggerCompletion (SourceText text, int position, CompletionTrigger trigger, Microsoft.CodeAnalysis.Options.OptionSet options)
-		{
-			return trigger.Character == '\\';
-		}
-
-		public override async Task ProvideCompletionsAsync (Microsoft.CodeAnalysis.Completion.CompletionContext context)
-		{
-			try {
-				var document = context.Document;
-				var position = context.Position;
-				var cancellationToken = context.CancellationToken;
-
-				var semanticModel = await document.GetSemanticModelForSpanAsync (new TextSpan (position, 0), cancellationToken).ConfigureAwait (false);
-
-				var workspace = document.Project.Solution.Workspace;
-				var ctx = CSharpSyntaxContext.CreateContext (workspace, semanticModel, position, cancellationToken);
-				if (context.Trigger.Character == '\\') {
-					if (ctx.TargetToken.Parent != null && ctx.TargetToken.Parent.Parent != null &&
-					ctx.TargetToken.Parent.Parent.IsKind (SyntaxKind.Argument)) {
-						var argument = ctx.TargetToken.Parent.Parent as ArgumentSyntax;
-
-						var symbolInfo = semanticModel.GetSymbolInfo (ctx.TargetToken.Parent.Parent.Parent.Parent);
-						if (symbolInfo.Symbol == null)
-							return;
-
-						if (IsRegexMatchMethod (symbolInfo)) {
-							if (((ArgumentListSyntax)argument.Parent).Arguments [1] != argument)
-								return;
-							AddFormatCompletionData (context, argument.Expression.ToString () [0] == '@');
-							return;
-						}
-						if (IsRegexConstructor (symbolInfo)) {
-							if (((ArgumentListSyntax)argument.Parent).Arguments [0] != argument)
-								return;
-							AddFormatCompletionData (context, argument.Expression.ToString () [0] == '@');
-							return;
-						}
-					}
-				} else {
-					if (ctx.TargetToken.Parent is MemberAccessExpressionSyntax ma) {
-						var symbolInfo = semanticModel.GetSymbolInfo (ma.Expression);
-						var typeInfo = semanticModel.GetTypeInfo (ma.Expression);
-						var type = typeInfo.Type;
-						if (type != null && type.Name == "Match" && type.ContainingNamespace.GetFullName () == "System.Text.RegularExpressions") {
-							foreach (var grp in GetGroups (ctx, symbolInfo.Symbol)) {
-								context.AddItem (FormatItemCompletionProvider.CreateCompletionItem ("Groups[\"" + grp + "\"]", null, null));
-							}
-						}
-					}
-				}
-			} catch (OperationCanceledException) {
-				throw;
-			} catch (Exception e) {
-				LoggingService.LogError ("Exception in RegexCompletionProvider", e);
-			}
-		}
-
-		IEnumerable<string> GetGroups (CSharpSyntaxContext ctx, ISymbol symbol)
-		{
-			var root = ctx.SyntaxTree.GetRoot ();
-			foreach (var decl in symbol.DeclaringSyntaxReferences) {
-				Optional<object> val = null;
-
-				var node = root.FindNode (decl.Span) as VariableDeclaratorSyntax;
-				if (node == null)
-					continue;
-				var invocation = node.Initializer.Value as InvocationExpressionSyntax;
-				var invocationSymbol = ctx.SemanticModel.GetSymbolInfo (invocation).Symbol;
-				if (invocationSymbol.Name == "Match" && IsRegexType (invocationSymbol.ContainingType)) {
-					if (invocation.ArgumentList.Arguments.Count == 1) {
-						var memberAccess = invocation.Expression as MemberAccessExpressionSyntax;
-						if (memberAccess == null)
-							continue;
-						var target = ctx.SemanticModel.GetSymbolInfo (memberAccess.Expression).Symbol;
-						if (target.DeclaringSyntaxReferences.Length == 0)
-							continue;
-						var targetNode = root.FindNode (target.DeclaringSyntaxReferences.First ().Span) as VariableDeclaratorSyntax;
-						if (targetNode == null)
-							continue;
-						var objectCreation = targetNode.Initializer.Value as ObjectCreationExpressionSyntax;
-						if (objectCreation == null || objectCreation.ArgumentList.OpenParenToken.IsMissing)
-							continue;
-						var targetNodeSymbol = ctx.SemanticModel.GetSymbolInfo (objectCreation).Symbol;
-						if (IsRegexType (targetNodeSymbol.ContainingType)) {
-							if (objectCreation.ArgumentList.Arguments.Count < 1)
-								continue;
-							val = ctx.SemanticModel.GetConstantValue (objectCreation.ArgumentList.Arguments [0].Expression);
-						}
-					} else {
-						if (invocation.ArgumentList.Arguments.Count < 2)
-							continue;
-						val = ctx.SemanticModel.GetConstantValue (invocation.ArgumentList.Arguments [1].Expression);
-					}
-
-					if (!val.HasValue)
-						continue;
-					var str = val.Value.ToString ();
-					int idx = -1;
-					while ((idx = str.IndexOf ("(?<", idx + 1, StringComparison.Ordinal)) >= 0) {
-						var closingIndex = str.IndexOf (">", idx, StringComparison.Ordinal);
-						if (closingIndex >= idx) {
-							yield return str.Substring (idx + 3, closingIndex - idx - 3);
-							idx = closingIndex - 1;
-						}
-					}
-				}
-			}
-		}
-
-		static readonly CompletionItem [] verbatimFormatItems =  {
-			FormatItemCompletionProvider.CreateCompletionItem("d", "Digit character", null),
-			FormatItemCompletionProvider.CreateCompletionItem("D", "Non-digit character", null),
-			FormatItemCompletionProvider.CreateCompletionItem("b", "Word boundary", null),
-			FormatItemCompletionProvider.CreateCompletionItem("B", "Non-word boundary", null),
-			FormatItemCompletionProvider.CreateCompletionItem("w", "Word character", null),
-			FormatItemCompletionProvider.CreateCompletionItem("W", "Non-word character", null),
-			FormatItemCompletionProvider.CreateCompletionItem("s", "White-space character", null),
-			FormatItemCompletionProvider.CreateCompletionItem("S", "Non-white-space character", null),
-			FormatItemCompletionProvider.CreateCompletionItem("A", "Start boundary", null),
-			FormatItemCompletionProvider.CreateCompletionItem("Z", "End boundary", null),
-			FormatItemCompletionProvider.CreateCompletionItem("k<name>", "Named backreference", null),
-			FormatItemCompletionProvider.CreateCompletionItem("P{name}", "Negative unicode category or unicode block", null),
-			FormatItemCompletionProvider.CreateCompletionItem("p{name}", "Unicode category or unicode block", null)
-		};
-
-		static readonly CompletionItem [] formatItems =  {
-			FormatItemCompletionProvider.CreateCompletionItem("\\d", "Digit character", null),
-			FormatItemCompletionProvider.CreateCompletionItem("\\D", "Non-digit character", null),
-			FormatItemCompletionProvider.CreateCompletionItem("\\b", "Word boundary", null),
-			FormatItemCompletionProvider.CreateCompletionItem("\\B", "Non-word boundary", null),
-			FormatItemCompletionProvider.CreateCompletionItem("\\w", "Word character", null),
-			FormatItemCompletionProvider.CreateCompletionItem("\\W", "Non-word character", null),
-			FormatItemCompletionProvider.CreateCompletionItem("\\s", "White-space character", null),
-			FormatItemCompletionProvider.CreateCompletionItem("\\S", "Non-white-space character", null),
-			FormatItemCompletionProvider.CreateCompletionItem("\\A", "Start boundary", null),
-			FormatItemCompletionProvider.CreateCompletionItem("\\Z", "End boundary", null),
-			FormatItemCompletionProvider.CreateCompletionItem("\\k<name>", "Named backreference", null),
-			FormatItemCompletionProvider.CreateCompletionItem("\\P{name}", "Negative unicode category or unicode block", null),
-			FormatItemCompletionProvider.CreateCompletionItem("\\p{name}", "Unicode category or unicode block", null)
-		};
-
-		void AddFormatCompletionData (Microsoft.CodeAnalysis.Completion.CompletionContext context, bool isVerbatimString)
-		{
-			context.AddItems (isVerbatimString ? verbatimFormatItems : formatItems);
-		}
-	}
-}
\ No newline at end of file
diff --git a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Formatting/CSharpFormatter.cs b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Formatting/CSharpFormatter.cs
index 41ce9a98f3..9b3b4ca8e4 100644
--- a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Formatting/CSharpFormatter.cs
+++ b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Formatting/CSharpFormatter.cs
@@ -49,6 +49,7 @@ using Microsoft.CodeAnalysis.Options;
 using MonoDevelop.CSharp.OptionProvider;
 using Microsoft.VisualStudio.CodingConventions;
 using System.Linq;
+using System.Collections.Immutable;
 
 namespace MonoDevelop.CSharp.Formatting
 {
@@ -88,7 +89,7 @@ namespace MonoDevelop.CSharp.Formatting
 				if (formattingService == null || !formattingService.SupportsFormatSelection)
 					return;
 
-				var formattingRules = new List<IFormattingRule> ();
+				var formattingRules = new List<AbstractFormattingRule> ();
 				formattingRules.Add (ContainedDocumentPreserveFormattingRule.Instance);
 				formattingRules.AddRange (Formatter.GetDefaultFormattingRules (document));
 
@@ -170,7 +171,12 @@ namespace MonoDevelop.CSharp.Formatting
 				if (codingConventionsSnapshot != null) {
 					var editorConfigPersistence = option.Option.StorageLocations.OfType<IEditorConfigStorageLocation> ().SingleOrDefault ();
 					if (editorConfigPersistence != null) {
-						var allRawConventions = codingConventionsSnapshot.AllRawConventions;
+						
+						var tempRawConventions = codingConventionsSnapshot.AllRawConventions;
+						// HACK: temporarly map our old Dictionary<string, object> to a Dictionary<string, string>. This will go away in a future commit.
+						// see https://github.com/dotnet/roslyn/commit/6a5be42f026f8d0432cfe8ee7770ff8f6be01bd6#diff-626aa9dd2f6e07eafa8eac7ddb0eb291R34
+						var allRawConventions = ImmutableDictionary.CreateRange (tempRawConventions.Select (c => Roslyn.Utilities.KeyValuePairUtil.Create (c.Key, c.Value.ToString ())));
+
 						try {
 							var underlyingOption = underlyingOptions.GetOption (option);
 							if (editorConfigPersistence.TryGetOption (underlyingOption, allRawConventions, option.Option.Type, out value))
diff --git a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Formatting/CSharpTextPasteHandler.PasteFormattingRule.cs b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Formatting/CSharpTextPasteHandler.PasteFormattingRule.cs
index 5d97b17d75..4aa8eedc6a 100644
--- a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Formatting/CSharpTextPasteHandler.PasteFormattingRule.cs
+++ b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Formatting/CSharpTextPasteHandler.PasteFormattingRule.cs
@@ -35,7 +35,7 @@ namespace MonoDevelop.CSharp.Formatting
 	{
 		class PasteFormattingRule : AbstractFormattingRule
 		{
-			public override AdjustNewLinesOperation GetAdjustNewLinesOperation (SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)
+			public override AdjustNewLinesOperation GetAdjustNewLinesOperation (SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, in NextGetAdjustNewLinesOperation nextOperation)
 			{
 				if (currentToken.Parent != null) {
 					var currentTokenParentParent = currentToken.Parent.Parent;
diff --git a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Navigation/FindDerivedSymbolsHandler.cs b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Navigation/FindDerivedSymbolsHandler.cs
index 044d1b2c39..1817574614 100644
--- a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Navigation/FindDerivedSymbolsHandler.cs
+++ b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Navigation/FindDerivedSymbolsHandler.cs
@@ -105,7 +105,7 @@ namespace MonoDevelop.CSharp.Refactoring
 			foreach (var project in currentSolution.Projects) {
 				var comp = await project.GetCompilationAsync (token).ConfigureAwait (false);
 				foreach (var i in comp.GetAllTypesInMainAssembly (token).Where (t => t.TypeKind == TypeKind.Interface)) {
-					if (i.AllInterfaces.Any (t => t.InheritsFromOrEqualsIgnoringConstruction (type)))
+					if (i.AllInterfaces.Any (t => t.InheritsFromOrImplementsOrEqualsIgnoringConstruction (type)))
 						result.Add (i);
 				}
 			}
diff --git a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.OptionProvider/CSharpDocumentOptionsProvider.cs b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.OptionProvider/CSharpDocumentOptionsProvider.cs
index 8b00629572..0ff4f59c7f 100644
--- a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.OptionProvider/CSharpDocumentOptionsProvider.cs
+++ b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.OptionProvider/CSharpDocumentOptionsProvider.cs
@@ -39,6 +39,7 @@ using MonoDevelop.Core;
 using System.Linq;
 using MonoDevelop.Ide.Editor;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 
 namespace MonoDevelop.CSharp.OptionProvider
 {
@@ -98,7 +99,12 @@ namespace MonoDevelop.CSharp.OptionProvider
 				if (codingConventionsSnapshot != null) {
 					var editorConfigPersistence = option.Option.StorageLocations.OfType<IEditorConfigStorageLocation> ().SingleOrDefault ();
 					if (editorConfigPersistence != null) {
-						var allRawConventions = codingConventionsSnapshot.AllRawConventions;
+
+						var tempRawConventions = codingConventionsSnapshot.AllRawConventions;
+						// HACK: temporarly map our old Dictionary<string, object> to a Dictionary<string, string>. This will go away in a future commit.
+						// see https://github.com/dotnet/roslyn/commit/6a5be42f026f8d0432cfe8ee7770ff8f6be01bd6#diff-626aa9dd2f6e07eafa8eac7ddb0eb291R34
+						var allRawConventions = ImmutableDictionary.CreateRange (tempRawConventions.Select (c => Roslyn.Utilities.KeyValuePairUtil.Create (c.Key, c.Value.ToString ())));
+
 						try {
 							var underlyingOption = Policy.OptionSet.GetOption (option);
 							if (editorConfigPersistence.TryGetOption (underlyingOption, allRawConventions, option.Option.Type, out value))
diff --git a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.OptionProvider/OptionProviderFactory.cs b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.OptionProvider/OptionProviderFactory.cs
index 05dc2a4cb1..b10358ea09 100644
--- a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.OptionProvider/OptionProviderFactory.cs
+++ b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.OptionProvider/OptionProviderFactory.cs
@@ -33,7 +33,7 @@ namespace MonoDevelop.CSharp.OptionProvider
 	[Export (typeof (IDocumentOptionsProviderFactory))]
 	class EditorConfigDocumentOptionsProviderFactory : IDocumentOptionsProviderFactory
 	{
-		public IDocumentOptionsProvider Create (Workspace workspace)
+		public IDocumentOptionsProvider TryCreate (Workspace workspace)
 		{
 			return new CSharpDocumentOptionsProvider ();
 		}
diff --git a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.OptionProvider/StyleViewModel.cs b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.OptionProvider/StyleViewModel.cs
index fb6b549f1e..07f1b77919 100644
--- a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.OptionProvider/StyleViewModel.cs
+++ b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.OptionProvider/StyleViewModel.cs
@@ -1229,9 +1229,9 @@ class C
 			CodeStyleItems.Add (new BooleanCodeStyleOptionViewModel (CodeStyleOptions.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, GettextCatalog.GetString("For member access expressions"), s_intrinsicPreviewMemberAccessTrue, s_intrinsicPreviewMemberAccessFalse, this, optionSet, predefinedTypesGroupTitle, predefinedTypesPreferences));
 
 			// Use var
-			CodeStyleItems.Add (new BooleanCodeStyleOptionViewModel (CSharpCodeStyleOptions.UseImplicitTypeForIntrinsicTypes, GettextCatalog.GetString("For built-in types"), s_varForIntrinsicsPreviewTrue, s_varForIntrinsicsPreviewFalse, this, optionSet, varGroupTitle, typeStylePreferences));
-			CodeStyleItems.Add (new BooleanCodeStyleOptionViewModel (CSharpCodeStyleOptions.UseImplicitTypeWhereApparent, GettextCatalog.GetString("When variable type is apparent"), s_varWhereApparentPreviewTrue, s_varWhereApparentPreviewFalse, this, optionSet, varGroupTitle, typeStylePreferences));
-			CodeStyleItems.Add (new BooleanCodeStyleOptionViewModel (CSharpCodeStyleOptions.UseImplicitTypeWherePossible, GettextCatalog.GetString("Elsewhere"), s_varWherePossiblePreviewTrue, s_varWherePossiblePreviewFalse, this, optionSet, varGroupTitle, typeStylePreferences));
+			CodeStyleItems.Add (new BooleanCodeStyleOptionViewModel (CSharpCodeStyleOptions.VarForBuiltInTypes, GettextCatalog.GetString("For built-in types"), s_varForIntrinsicsPreviewTrue, s_varForIntrinsicsPreviewFalse, this, optionSet, varGroupTitle, typeStylePreferences));
+			CodeStyleItems.Add (new BooleanCodeStyleOptionViewModel (CSharpCodeStyleOptions.VarWhenTypeIsApparent, GettextCatalog.GetString("When variable type is apparent"), s_varWhereApparentPreviewTrue, s_varWhereApparentPreviewFalse, this, optionSet, varGroupTitle, typeStylePreferences));
+			CodeStyleItems.Add (new BooleanCodeStyleOptionViewModel (CSharpCodeStyleOptions.VarElsewhere, GettextCatalog.GetString("Elsewhere"), s_varWherePossiblePreviewTrue, s_varWherePossiblePreviewFalse, this, optionSet, varGroupTitle, typeStylePreferences));
 
 			// Code block
 			AddBracesOptions (optionSet, codeBlockPreferencesGroupTitle);
diff --git a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Refactoring/RefactoryCommands.cs b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Refactoring/RefactoryCommands.cs
index c4e41946bf..4c937b0a95 100644
--- a/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Refactoring/RefactoryCommands.cs
+++ b/main/src/addins/CSharpBinding/MonoDevelop.CSharp.Refactoring/RefactoryCommands.cs
@@ -77,7 +77,7 @@ namespace MonoDevelop.CSharp.Refactoring
 	{
 		protected override void Update (CommandInfo info)
 		{
-			info.Enabled = TryGetDocument (out var doc, out var _) && IsSortAndRemoveImportsSupported (doc);
+			info.Enabled = TryGetDocument (out var doc, out var uiDoc) && IsSortAndRemoveImportsSupported (doc, uiDoc.GetContent<Microsoft.VisualStudio.Text.ITextBuffer> ());	
 		}
 
 		protected override void Run ()
@@ -86,7 +86,7 @@ namespace MonoDevelop.CSharp.Refactoring
 				SortAndRemoveUnusedImports (doc, CancellationToken.None).Ignore ();
 		}
 
-		internal static bool IsSortAndRemoveImportsSupported (Document document)
+		internal static bool IsSortAndRemoveImportsSupported (Document document, Microsoft.VisualStudio.Text.ITextBuffer textBuffer)
 		{
 			var workspace = document.Project.Solution.Workspace;
 
@@ -98,7 +98,7 @@ namespace MonoDevelop.CSharp.Refactoring
 				return false;
 			}
 
-			return workspace.Services.GetService<IDocumentSupportsFeatureService> ().SupportsRefactorings (document);
+			return workspace.Services.GetService<ITextBufferSupportsFeatureService> ().SupportsRefactorings (textBuffer);
 		}
 
 		internal static async Task SortAndRemoveUnusedImports (Document originalDocument, CancellationToken cancellationToken)
@@ -148,7 +148,8 @@ namespace MonoDevelop.CSharp.Refactoring
 				}));
 			}
 
-			bool isSortAndRemoveUsingsSupported = RemoveAndSortUsingsHandler.IsSortAndRemoveImportsSupported (analysisDocument);
+			bool isSortAndRemoveUsingsSupported = RemoveAndSortUsingsHandler.IsSortAndRemoveImportsSupported (analysisDocument, doc.GetContent<Microsoft.VisualStudio.Text.ITextBuffer>());
+
 			if (isSortAndRemoveUsingsSupported) {
 				var sortAndRemoveImportsInfo = IdeApp.CommandService.GetCommandInfo (Commands.SortAndRemoveImports);
 				sortAndRemoveImportsInfo.Enabled = true;
diff --git a/main/src/addins/CSharpBinding/MonoDevelop.Ide.Completion.Presentation/ContainedDocumentPreserveFormattingRule.cs b/main/src/addins/CSharpBinding/MonoDevelop.Ide.Completion.Presentation/ContainedDocumentPreserveFormattingRule.cs
index 84f4e2e352..bf0e58fbbc 100644
--- a/main/src/addins/CSharpBinding/MonoDevelop.Ide.Completion.Presentation/ContainedDocumentPreserveFormattingRule.cs
+++ b/main/src/addins/CSharpBinding/MonoDevelop.Ide.Completion.Presentation/ContainedDocumentPreserveFormattingRule.cs
@@ -6,12 +6,12 @@ namespace MonoDevelop.Ide.Completion.Presentation
 {

 	internal class ContainedDocumentPreserveFormattingRule : AbstractFormattingRule

 	{

-		public static readonly IFormattingRule Instance = new ContainedDocumentPreserveFormattingRule ();

+		public static readonly AbstractFormattingRule Instance = new ContainedDocumentPreserveFormattingRule ();

 

 		private static readonly AdjustSpacesOperation s_preserveSpace = FormattingOperations.CreateAdjustSpacesOperation (0, AdjustSpacesOption.PreserveSpaces);

 		private static readonly AdjustNewLinesOperation s_preserveLine = FormattingOperations.CreateAdjustNewLinesOperation (0, AdjustNewLinesOption.PreserveLines);

 

-		public override AdjustSpacesOperation GetAdjustSpacesOperation (SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustSpacesOperation> nextOperation)

+		public override AdjustSpacesOperation GetAdjustSpacesOperation (SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, in NextGetAdjustSpacesOperation nextOperation)

 		{

 			var operation = base.GetAdjustSpacesOperation (previousToken, currentToken, optionSet, nextOperation);

 			if (operation != null) {

@@ -21,7 +21,7 @@ namespace MonoDevelop.Ide.Completion.Presentation
 			return operation;

 		}

 

-		public override AdjustNewLinesOperation GetAdjustNewLinesOperation (SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, NextOperation<AdjustNewLinesOperation> nextOperation)

+		public override AdjustNewLinesOperation GetAdjustNewLinesOperation (SyntaxToken previousToken, SyntaxToken currentToken, OptionSet optionSet, in NextGetAdjustNewLinesOperation nextOperation)
 		{

 			var operation = base.GetAdjustNewLinesOperation (previousToken, currentToken, optionSet, nextOperation);

 			if (operation != null) {

diff --git a/main/src/addins/CSharpBinding/MonoDevelop.Ide.Completion.Presentation/MonoDevelopContainedDocument.cs b/main/src/addins/CSharpBinding/MonoDevelop.Ide.Completion.Presentation/MonoDevelopContainedDocument.cs
index 49d0e87afd..2d0898d430 100644
--- a/main/src/addins/CSharpBinding/MonoDevelop.Ide.Completion.Presentation/MonoDevelopContainedDocument.cs
+++ b/main/src/addins/CSharpBinding/MonoDevelop.Ide.Completion.Presentation/MonoDevelopContainedDocument.cs
@@ -628,11 +628,11 @@ namespace MonoDevelop.Ide.Completion.Presentation
 		}

 

 		private void AdjustIndentationForSpan (

-			Document document, ITextEdit edit, TextSpan visibleSpan, IFormattingRule baseIndentationRule, OptionSet options)

+			Document document, ITextEdit edit, TextSpan visibleSpan, AbstractFormattingRule baseIndentationRule, OptionSet options)

 		{

 			var root = document.GetSyntaxRootSynchronously (CancellationToken.None);

 

-			using (var rulePool = SharedPools.Default<List<IFormattingRule>> ().GetPooledObject ())

+			using (var rulePool = SharedPools.Default<List<AbstractFormattingRule>> ().GetPooledObject ())

 			using (var spanPool = SharedPools.Default<List<TextSpan>> ().GetPooledObject ()) {

 				var venusFormattingRules = rulePool.Object;

 				var visibleSpans = spanPool.Object;

diff --git a/main/src/addins/CSharpBinding/MonoDevelop.Ide.Completion.Presentation/MonoDevelopFormattingRuleFactoryServiceFactory.cs b/main/src/addins/CSharpBinding/MonoDevelop.Ide.Completion.Presentation/MonoDevelopFormattingRuleFactoryServiceFactory.cs
index 7ae4b9ad25..3550a3ef2b 100644
--- a/main/src/addins/CSharpBinding/MonoDevelop.Ide.Completion.Presentation/MonoDevelopFormattingRuleFactoryServiceFactory.cs
+++ b/main/src/addins/CSharpBinding/MonoDevelop.Ide.Completion.Presentation/MonoDevelopFormattingRuleFactoryServiceFactory.cs
@@ -24,7 +24,7 @@ namespace MonoDevelop.Ide.Completion.Presentation
 

 		private sealed class Factory : IHostDependentFormattingRuleFactoryService

 		{

-			private readonly IFormattingRule _noopRule = new NoOpFormattingRule ();

+			private readonly AbstractFormattingRule _noopRule = NoOpFormattingRule.Instance;

 

 			public bool ShouldUseBaseIndentation (Document document)

 			{

@@ -43,7 +43,7 @@ namespace MonoDevelop.Ide.Completion.Presentation
 				return (containedDocument != null);

 			}

 

-			public IFormattingRule CreateRule (Document document, int position)

+			public AbstractFormattingRule CreateRule (Document document, int position)

 			{

 				MonoDevelopContainedDocument containedDocument = MonoDevelopContainedDocument.FromDocument (document);

 				if (containedDocument == null)

diff --git a/main/src/addins/CSharpBinding/MonoDevelop.Ide.Completion.Presentation/RoslynCompletionPresenterSession.ICompletionPresenterSession.cs b/main/src/addins/CSharpBinding/MonoDevelop.Ide.Completion.Presentation/RoslynCompletionPresenterSession.ICompletionPresenterSession.cs
index 3c1bf75307..52d8c60502 100644
--- a/main/src/addins/CSharpBinding/MonoDevelop.Ide.Completion.Presentation/RoslynCompletionPresenterSession.ICompletionPresenterSession.cs
+++ b/main/src/addins/CSharpBinding/MonoDevelop.Ide.Completion.Presentation/RoslynCompletionPresenterSession.ICompletionPresenterSession.cs
@@ -26,7 +26,7 @@ namespace MonoDevelop.Ide.Completion.Presentation
 		public static RoslynCompletionPresenterSession Instance { get; private set; }
 
 
-		void ICompletionPresenterSession.PresentItems (ITrackingSpan triggerSpan, IList<CompletionItem> items, CompletionItem selectedItem, CompletionItem suggestionModeItem, bool suggestionMode, bool isSoftSelected, ImmutableArray<CompletionItemFilter> completionItemFilters, string filterText)
+		void ICompletionPresenterSession.PresentItems (ITextSnapshot textSnapshot, ITrackingSpan triggerSpan, IList<CompletionItem> items, CompletionItem selectedItem, CompletionItem suggestionModeItem, bool suggestionMode, bool isSoftSelected, ImmutableArray<CompletionItemFilter> completionItemFilters, string filterText)
 		{
 			if (!opened) {
 				Open (triggerSpan, items, selectedItem, suggestionModeItem, suggestionMode, isSoftSelected);
diff --git a/main/src/addins/ChangeLogAddIn/ChangeLogAddIn.cs b/main/src/addins/ChangeLogAddIn/ChangeLogAddIn.cs
index 9a877796cb..028f26b3ea 100644
--- a/main/src/addins/ChangeLogAddIn/ChangeLogAddIn.cs
+++ b/main/src/addins/ChangeLogAddIn/ChangeLogAddIn.cs
@@ -82,7 +82,7 @@ namespace MonoDevelop.ChangeLogAddIn
 		
 		static void InsertEntry(Document document)
 		{
-			var textBuffer = document.GetContent<TextEditor>();					
+			var textBuffer = document.GetContent<TextEditor>(true);					
 			if (textBuffer == null) return;
 
 			string changeLogFileName = document.FileName;
diff --git a/main/src/addins/MacPlatform/MacInterop/Carbon.cs b/main/src/addins/MacPlatform/MacInterop/Carbon.cs
index 18737fc02d..ec03d52ff3 100644
--- a/main/src/addins/MacPlatform/MacInterop/Carbon.cs
+++ b/main/src/addins/MacPlatform/MacInterop/Carbon.cs
@@ -219,16 +219,15 @@ namespace MonoDevelop.MacInterop
 		public static void SetProcessName (string name)
 		{
 			try {
-				ProcessSerialNumber psn;
-				if (GetCurrentProcess (out psn) == 0)
+				if (GetCurrentProcess (out ProcessSerialNumber psn) == 0)
 					CPSSetProcessName (ref psn, name);
 			} catch {} //EntryPointNotFoundException?
 		}
 		
 		struct ProcessSerialNumber {
 #pragma warning disable 0169
-			ulong highLongOfPSN;
-			ulong lowLongOfPSN;
+			uint highLongOfPSN;
+			uint lowLongOfPSN;
 #pragma warning restore 0169
 		}
 		
diff --git a/main/src/addins/MacPlatform/MacPlatform.cs b/main/src/addins/MacPlatform/MacPlatform.cs
index 4b30f9f5a1..d60c4f79c8 100644
--- a/main/src/addins/MacPlatform/MacPlatform.cs
+++ b/main/src/addins/MacPlatform/MacPlatform.cs
@@ -1,4 +1,4 @@
-//
+//
 // MacPlatformService.cs
 //
 // Author:
@@ -235,6 +235,55 @@ namespace MonoDevelop.MacIntegration
 			}
 		}
 
+		const string FoundationLib = "/System/Library/Frameworks/Foundation.framework/Versions/Current/Foundation";
+
+		delegate void NSUncaughtExceptionHandler (IntPtr exception);
+
+		static readonly NSUncaughtExceptionHandler uncaughtHandler = HandleUncaughtException;
+		static NSUncaughtExceptionHandler oldHandler;
+
+		static void HandleUncaughtException(IntPtr exceptionPtr)
+		{
+			// It's non-null guaranteed by objc.
+			Debug.Assert (exceptionPtr != IntPtr.Zero);
+
+			var nsException = ObjCRuntime.Runtime.GetNSObject<NSException> (exceptionPtr);
+			try {
+				throw new MarshalledObjCException (nsException);
+			} catch (MarshalledObjCException e) {
+				LoggingService.LogFatalError ("Unhandled ObjC Exception", e);
+				// Is there a way to figure out if it's going to crash us? Maybe check MarshalObjectiveCExceptionMode and MarshalManagedExceptionMode?
+			}
+
+			// Invoke the default xamarin.mac one, so if it bubbles up an exception, the caller receives it.
+			oldHandler?.Invoke (exceptionPtr);
+		}
+
+		sealed class MarshalledObjCException : ObjCException
+		{
+			public MarshalledObjCException (NSException exception) : base (exception)
+			{
+				const BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.SetField;
+
+				var trace = new [] { new StackTrace (true), };
+				//// Otherwise exception stacktrace is not gathered.
+				typeof (Exception)
+					.InvokeMember ("captured_traces", flags, null, this, new object [] { trace });
+			}
+		}
+
+		[DllImport (FoundationLib)]
+		static extern void NSSetUncaughtExceptionHandler (NSUncaughtExceptionHandler handler);
+
+		[DllImport (FoundationLib)]
+		static extern NSUncaughtExceptionHandler NSGetUncaughtExceptionHandler ();
+
+		static void RegisterUncaughtExceptionHandler ()
+		{
+			oldHandler = NSGetUncaughtExceptionHandler ();
+			NSSetUncaughtExceptionHandler (uncaughtHandler);
+		}
+
 		public override Xwt.Toolkit LoadNativeToolkit ()
 		{
 			var path = Path.GetDirectoryName (GetType ().Assembly.Location);
@@ -247,6 +296,7 @@ namespace MonoDevelop.MacIntegration
 			loaded.RegisterBackend<Xwt.Backends.IWindowBackend, ThemedMacWindowBackend> ();
 			loaded.RegisterBackend<Xwt.Backends.IAlertDialogBackend, ThemedMacAlertDialogBackend> ();
 
+			RegisterUncaughtExceptionHandler ();
 
 			// We require Xwt.Mac to initialize MonoMac before we can execute any code using MonoMac
 			timer.Trace ("Installing App Event Handlers");
@@ -401,11 +451,17 @@ namespace MonoDevelop.MacIntegration
 			return map;
 		}
 
+		string currentCommandMenuPath, currentAppMenuPath;
+
 		public override bool SetGlobalMenu (CommandManager commandManager, string commandMenuAddinPath, string appMenuAddinPath)
 		{
 			if (setupFail)
 				return false;
 
+			// avoid reinitialization of the same menu structure
+			if (initedApp == true && currentCommandMenuPath == commandMenuAddinPath && currentAppMenuPath == appMenuAddinPath)
+				return true;
+
 			try {
 				InitApp (commandManager);
 
@@ -431,6 +487,9 @@ namespace MonoDevelop.MacIntegration
 				// Assign the main menu after loading the items. Otherwise a weird application menu appears.
 				if (NSApplication.SharedApplication.MainMenu == null)
 					NSApplication.SharedApplication.MainMenu = rootMenu;
+
+				currentCommandMenuPath = commandMenuAddinPath;
+				currentAppMenuPath = appMenuAddinPath;
 			} catch (Exception ex) {
 				try {
 					var m = NSApplication.SharedApplication.MainMenu;
@@ -482,16 +541,18 @@ namespace MonoDevelop.MacIntegration
 
 			initedApp = true;
 
-			IdeApp.Workbench.RootWindow.DeleteEvent += HandleDeleteEvent;
+			IdeApp.Initialized += (s, e) => {
+				IdeApp.Workbench.RootWindow.DeleteEvent += HandleDeleteEvent;
 
-			if (MacSystemInformation.OsVersion >= MacSystemInformation.Lion) {
-				IdeApp.Workbench.RootWindow.Realized += (sender, args) => {
-					var win = GtkQuartz.GetWindow ((Gtk.Window) sender);
-					win.CollectionBehavior |= NSWindowCollectionBehavior.FullScreenPrimary;
-					if (MacSystemInformation.OsVersion >= MacSystemInformation.Sierra)
-						win.TabbingMode = NSWindowTabbingMode.Disallowed;
-				};
-			}
+				if (MacSystemInformation.OsVersion >= MacSystemInformation.Lion) {
+					IdeApp.Workbench.RootWindow.Realized += (sender, args) => {
+						var win = GtkQuartz.GetWindow ((Gtk.Window)sender);
+						win.CollectionBehavior |= NSWindowCollectionBehavior.FullScreenPrimary;
+						if (MacSystemInformation.OsVersion >= MacSystemInformation.Sierra)
+							win.TabbingMode = NSWindowTabbingMode.Disallowed;
+					};
+				}
+			};
 
 			PatchGtkTheme ();
 			NSNotificationCenter.DefaultCenter.AddObserver (NSCell.ControlTintChangedNotification, notif => Core.Runtime.RunInMainThread (
@@ -639,7 +700,7 @@ namespace MonoDevelop.MacIntegration
 					GLib.Idle.Add (delegate {
 						Ide.WelcomePage.WelcomePageService.HideWelcomePageOrWindow ();
 						var trackTTC = IdeStartupTracker.StartupTracker.StartTimeToCodeLoadTimer ();
-						IdeApp.OpenFiles (e.Documents.Select (
+						IdeApp.OpenFilesAsync (e.Documents.Select (
 							doc => new FileOpenInformation (doc.Key, null, doc.Value, 1, OpenDocumentOptions.DefaultInternal)),
 							null
 						).ContinueWith ((result) => {
@@ -661,7 +722,7 @@ namespace MonoDevelop.MacIntegration
 						var trackTTC = IdeStartupTracker.StartupTracker.StartTimeToCodeLoadTimer ();
 						// Open files via the monodevelop:// URI scheme, compatible with the
 						// common TextMate scheme: http://blog.macromates.com/2007/the-textmate-url-scheme/
-						IdeApp.OpenFiles (e.Urls.Select (url => {
+						IdeApp.OpenFilesAsync (e.Urls.Select (url => {
 							try {
 								var uri = new Uri (url);
 								if (uri.Host != "open")
@@ -1033,12 +1094,25 @@ namespace MonoDevelop.MacIntegration
 			return false;
 		}
 
+		bool CheckIfTopWindowIsWorkbench ()
+		{
+			foreach (var window in Gtk.Window.ListToplevels ()) {
+				if (!window.HasToplevelFocus) {
+					continue;
+				}
+				if (window is DefaultWorkbench) {
+					return true;
+				}
+			}
+			return false;
+		}
+
 		public override Window GetFocusedTopLevelWindow ()
 		{
 			if (NSApplication.SharedApplication.KeyWindow != null) {
-				if (IdeApp.Workbench.RootWindow.Visible) {
+				if (IdeApp.Workbench?.RootWindow?.Visible == true) {
 					//if is a docking window then return the current root window
-					if (HasAnyDockWindowFocused ()) {
+					if (CheckIfTopWindowIsWorkbench () || HasAnyDockWindowFocused ()) {
 						return MessageService.RootWindow;
 					}
 				}
@@ -1284,7 +1358,7 @@ namespace MonoDevelop.MacIntegration
 
 			public MacMemoryMonitor ()
 			{
-				DispatchSource = new DispatchSource.MemoryPressure (notificationFlags, DispatchQueue.DefaultGlobalQueue);
+				DispatchSource = new DispatchSource.MemoryPressure (notificationFlags, DispatchQueue.MainQueue);
 				DispatchSource.SetEventHandler (() => {
 					var metadata = CreateMemoryMetadata (DispatchSource.PressureFlags);
 
diff --git a/main/src/addins/MacPlatform/MacTelemetryDetails.cs b/main/src/addins/MacPlatform/MacTelemetryDetails.cs
index 4b2630c153..36df20d29b 100644
--- a/main/src/addins/MacPlatform/MacTelemetryDetails.cs
+++ b/main/src/addins/MacPlatform/MacTelemetryDetails.cs
@@ -25,10 +25,14 @@
 // THE SOFTWARE.
 
 using System;
+using System.Collections.Generic;
+using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
+using AppKit;
 using CoreFoundation;
+using CoreGraphics;
 using Foundation;
 using MonoDevelop.Components;
 using MonoDevelop.Core;
@@ -48,6 +52,9 @@ namespace MacPlatform
 		PlatformHardDriveMediaType osType;
 		TimeSpan sinceLogin;
 
+		ScreenDetails[] screens;
+		GraphicsDetails[] graphicsDetails;
+
 		internal MacTelemetryDetails ()
 		{
 		}
@@ -67,6 +74,23 @@ namespace MacPlatform
 
 			result.osType = GetMediaType ("/");
 
+			var screenList = new List<ScreenDetails>();
+			foreach (var s in NSScreen.Screens)
+			{
+				var details = new ScreenDetails {
+					PointWidth = (float)s.Frame.Width,
+					PointHeight = (float)s.Frame.Height,
+					BackingScaleFactor = (float)s.BackingScaleFactor,
+					PixelWidth = (float)(s.Frame.Width * s.BackingScaleFactor),
+					PixelHeight = (float)(s.Frame.Height * s.BackingScaleFactor)
+				};
+
+				screenList.Add (details);
+			}
+			result.screens = screenList.ToArray ();
+
+			result.graphicsDetails = GetGraphicsDetails ();
+
 			try {
 				var login = GetLoginTime ();
 				if (login != DateTimeOffset.MinValue) {
@@ -112,6 +136,153 @@ namespace MacPlatform
 
 		public PlatformHardDriveMediaType HardDriveOsMediaType => osType;
 
+		public ScreenDetails [] Screens => screens;
+
+		public GraphicsDetails[] GPU => graphicsDetails;
+
+		static GraphicsDetails[] GetGraphicsDetails ()
+		{
+			var matchingDict = IOServiceMatching ("IOService");
+			var success = IOServiceGetMatchingServices (kIOMasterPortDefault, matchingDict, out var iter);
+			if (success != kIOReturnSuccess) {
+				return Array.Empty<GraphicsDetails> ();
+			}
+
+			var gpus = new List<GraphicsDetails> ();
+
+			for (uint regEntry; IOIteratorIsValid (iter) != 0; IOObjectRelease (regEntry)) {
+				regEntry = IOIteratorNext (iter);
+				if (regEntry == 0) {
+					break;
+				}
+
+				if (!TryIORegistrySearch (regEntry, "IOName", false, out var name) || name != "display") {
+					continue;
+				}
+
+				if (!TryIORegistrySearch (regEntry, "model", true, out var modelValue)) {
+					continue;
+				}
+
+				if (!TryGetMemoryValue (regEntry, out string memoryValue)) {
+					continue;
+				}
+
+				var details = new GraphicsDetails () {
+					Model = modelValue,
+					Memory = memoryValue
+				};
+				gpus.Add (details);
+
+				IOObjectRelease (regEntry);
+			}
+
+			IOObjectRelease (iter);
+
+			return gpus.ToArray ();
+		}
+
+		static bool TryGetMemoryValue (uint regEntry, out string size)
+		{
+			if (TryIORegistrySearch (regEntry, "VRAM,totalsize", true, out var byteSize) && long.TryParse (byteSize, out var bytes)) {
+				size = (bytes / 1024 / 1024).ToString ();
+				return true;
+			}
+
+			if (TryIORegistrySearch (regEntry, "VRAM,totalMB", true, out size)) {
+				return true;
+			}
+
+			uint success = IORegistryEntryGetChildIterator (regEntry, "IOService", out var childIter);
+			if (success != kIOReturnSuccess) {
+				return false;
+			}
+
+			for (uint childEntry; IOIteratorIsValid (childIter) != kIOReturnSuccess; IOObjectRelease (childEntry)) {
+				// Intel seems to put the total vram here
+				childEntry = IOIteratorNext (childIter);
+				if (childEntry == 0) {
+					return false;
+				}
+
+				if (TryIORegistrySearch (childEntry, "VRAM,totalMB", true, out size)) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		static Lazy<ObjCRuntime.Class> nsDataClass = new Lazy<ObjCRuntime.Class> (() => new ObjCRuntime.Class (typeof (NSData)));
+		static bool TryIORegistrySearch (uint regEntry, string key, bool recurse, out string result, bool inBytes = false)
+		{
+			using (var keyHandle = new NSString (key)) {
+				var namePtr = IORegistryEntrySearchCFProperty (regEntry, "IOService", keyHandle.Handle, IntPtr.Zero, recurse ? 0x1 : 0x0);
+				if (namePtr == IntPtr.Zero) {
+					result = null;
+					return false;
+				}
+
+				result = GetValueForNSObject (namePtr);
+				return result != null;
+			}
+		}
+
+		static string GetValueForNSObject (IntPtr obj)
+		{
+			using (var value = ObjCRuntime.Runtime.GetNSObject<NSObject> (obj, true)) {
+				if (!value.IsKindOfClass (nsDataClass.Value)) {
+					return value.ToString ();
+				}
+
+				var data = ObjCRuntime.Runtime.GetINativeObject<NSData> (obj, false);
+				if (data == null) {
+					return value.ToString ();
+				}
+
+				nuint detectedEncoding = NSString.DetectStringEncoding (data, new EncodingDetectionOptions {
+					EncodingDetectionAllowLossy = false,
+					EncodingDetectionUseOnlySuggestedEncodings = true,
+					EncodingDetectionSuggestedEncodings = new NSStringEncoding [] {
+						NSStringEncoding.UTF8,
+						NSStringEncoding.Unicode,
+						NSStringEncoding.ASCIIStringEncoding
+					},
+				}, out string convertedString, out bool isLossy);
+
+				if (convertedString == null) {
+					return null;
+				}
+
+				if (convertedString.Length > 0 && detectedEncoding != 0 && !isLossy) {
+					return convertedString;
+				}
+
+				if (TryGetNumberValueFromNSObject (data, out var numberString)) {
+					return numberString;
+				}
+
+				return value.ToString ();
+			}
+		}
+
+		static bool TryGetNumberValueFromNSObject (NSData data, out string numberString)
+		{
+			numberString = null;
+
+			if (data.Length == 4) {
+				uint x = unchecked((uint)Marshal.ReadInt32 (data.Bytes));
+				numberString = x.ToString ();
+			}
+
+			if (data.Length == 8) {
+				uint x = unchecked((uint)Marshal.ReadInt64 (data.Bytes));
+				numberString = x.ToString ();
+			}
+
+			return numberString != null;
+		}
+
 		static PlatformHardDriveMediaType GetMediaType (string path)
 		{
 			IntPtr diskHandle = IntPtr.Zero;
@@ -160,7 +331,7 @@ namespace MacPlatform
 		[DllImport ("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation", EntryPoint="CFRelease")]
 		static extern void CFReleaseInternal (IntPtr cfRef);
 
-		static void CFRelease (IntPtr cfRef)
+		internal static void CFRelease (IntPtr cfRef)
 		{
 			if (cfRef != IntPtr.Zero)
 				CFReleaseInternal (cfRef);
@@ -183,11 +354,29 @@ namespace MacPlatform
 			return dt;
 		}
 
+		const uint kIOMasterPortDefault = 0;
+		const uint kIOReturnSuccess = 0;
+
+		[DllImport ("/System/Library/Frameworks/IOKit.framework/IOKit")]
+		internal extern static IntPtr IOServiceMatching (string serviceName);
+
+		[DllImport ("/System/Library/Frameworks/IOKit.framework/IOKit")]
+		internal extern static uint IOServiceGetMatchingServices (uint masterPort, IntPtr matchingDict, out uint existing);
+
+		[DllImport ("/System/Library/Frameworks/IOKit.framework/IOKit")]
+		internal extern static uint IORegistryEntryGetChildIterator (uint service, string plane, out uint existing);
+
+		[DllImport ("/System/Library/Frameworks/IOKit.framework/IOKit")]
+		internal extern static uint IOIteratorNext (uint iterator);
+
+		[DllImport ("/System/Library/Frameworks/IOKit.framework/IOKit")]
+		internal extern static int IOIteratorIsValid (uint iterator);
+
 		[DllImport ("/System/Library/Frameworks/IOKit.framework/IOKit")]
-		extern static IntPtr IORegistryEntrySearchCFProperty(uint service, string plane, IntPtr key, IntPtr allocator, int options);
+		internal extern static IntPtr IORegistryEntrySearchCFProperty(uint service, string plane, IntPtr key, IntPtr allocator, int options);
 
 		[DllImport ("/System/Library/Frameworks/IOKit.framework/IOKit")]
-		extern static int IOObjectRelease (uint handle);
+		internal extern static int IOObjectRelease (uint handle);
 
 		[DllImport ("/System/Library/Frameworks/DiskArbitration.framework/DiskArbitration")]
 		extern static IntPtr DADiskCreateFromVolumePath (IntPtr allocator, IntPtr sessionRef, IntPtr pathRef);
diff --git a/main/src/addins/MacPlatform/MainToolbar/ButtonBar.cs b/main/src/addins/MacPlatform/MainToolbar/ButtonBar.cs
index 3de41d8472..eebf2b700e 100644
--- a/main/src/addins/MacPlatform/MainToolbar/ButtonBar.cs
+++ b/main/src/addins/MacPlatform/MainToolbar/ButtonBar.cs
@@ -213,8 +213,13 @@ namespace MonoDevelop.MacIntegration.MainToolbar
 			LoadIcon (button);
 			if (button.Enabled != IsEnabled (idx))
 				SetEnabled (button.Enabled, idx);
-			if (button.Tooltip != Cell.GetToolTip (idx))
-				Cell.SetToolTip (button.Tooltip, idx);
+
+			if (button.Tooltip != Cell.GetToolTip (idx)) {
+				// SetToolTip is missing NullAllowed
+				// https://github.com/xamarin/xamarin-macios/issues/6044
+				Cell.SetToolTip (button.Tooltip ?? string.Empty, idx);
+			}
+
 			if (button.Title != GetLabel (idx))
 				SetLabel (button.Title, idx);
 			SetNeedsDisplay ();
diff --git a/main/src/addins/MacPlatform/MainToolbar/StatusBar.cs b/main/src/addins/MacPlatform/MainToolbar/StatusBar.cs
index a07bde11ef..ba3761b28b 100644
--- a/main/src/addins/MacPlatform/MainToolbar/StatusBar.cs
+++ b/main/src/addins/MacPlatform/MainToolbar/StatusBar.cs
@@ -473,7 +473,7 @@ namespace MonoDevelop.MacIntegration.MainToolbar
 	}
 
 	[Register]
-	class StatusBar : NSFocusButton, MonoDevelop.Ide.StatusBar
+	class StatusBar : NSFocusButton, MonoDevelop.Ide.ITestableStatusBar
 	{
 		public enum MessageType
 		{
@@ -725,6 +725,10 @@ namespace MonoDevelop.MacIntegration.MainToolbar
 			}
 		}
 
+		// Used by AutoTest.
+		string [] ITestableStatusBar.CurrentIcons => statusIcons.Select (x => x.ToolTip).ToArray ();
+		string ITestableStatusBar.CurrentText => text;
+
 		readonly List<StatusIcon> statusIcons = new List<StatusIcon> ();
 
 		// Xamarin.Mac has a bug where NSView.NextKeyView cannot be set to null
@@ -742,9 +746,6 @@ namespace MonoDevelop.MacIntegration.MainToolbar
 			void_objc_msgSend_IntPtr (parent.Handle, setNextKeyViewSelector, nextKeyView != null ? nextKeyView.Handle : IntPtr.Zero);
 		}
 
-		// Used by AutoTest.
-		internal string[] StatusIcons => statusIcons.Select(x => x.ToolTip).ToArray ();
-
 		internal void RemoveStatusIcon (StatusIcon icon)
 		{
 			// For keyboard focus the icons are the reverse of the order they're stored in the list
diff --git a/main/src/addins/MonoDevelop.AspNetCore/MonoDevelop.AspNetCore.Dialogs/PublishToFolderDialog.cs b/main/src/addins/MonoDevelop.AspNetCore/MonoDevelop.AspNetCore.Dialogs/PublishToFolderDialog.cs
index bf1cec9d1b..5e4124b5be 100644
--- a/main/src/addins/MonoDevelop.AspNetCore/MonoDevelop.AspNetCore.Dialogs/PublishToFolderDialog.cs
+++ b/main/src/addins/MonoDevelop.AspNetCore/MonoDevelop.AspNetCore.Dialogs/PublishToFolderDialog.cs
@@ -35,7 +35,7 @@ namespace MonoDevelop.AspNetCore.Dialogs
 				Configuration = project.GetActiveConfiguration ();
 
 			var defaultDirectory = Path.Combine (BinBaseUri.ToString (), Configuration,
-								project.TargetFramework.Id.GetShortFrameworkName (),
+								project.TargetFramework.Id.ShortName,
 								"publish");
 
 			if (uriKind == UriKind.Relative)
@@ -161,7 +161,7 @@ namespace MonoDevelop.AspNetCore.Dialogs
 			if (cmd == Command.Ok) {
 				publishCommandItem.Profile = new ProjectPublishProfile {
 					PublishUrl = pathEntry.Text,
-					TargetFramework = publishCommandItem.Project.TargetFramework.Id.GetShortFrameworkName (),
+					TargetFramework = publishCommandItem.Project.TargetFramework.Id.ShortName,
 					LastUsedBuildConfiguration = defaultDirectoryResolver.Configuration,
 					LastUsedPlatform = publishCommandItem.Project.GetActivePlatform ()
 				};
diff --git a/main/src/addins/MonoDevelop.AspNetCore/MonoDevelop.AspNetCore/AspNetCoreExecutionCommand.cs b/main/src/addins/MonoDevelop.AspNetCore/MonoDevelop.AspNetCore/AspNetCoreExecutionCommand.cs
index 76b286de1f..7262dfa195 100644
--- a/main/src/addins/MonoDevelop.AspNetCore/MonoDevelop.AspNetCore/AspNetCoreExecutionCommand.cs
+++ b/main/src/addins/MonoDevelop.AspNetCore/MonoDevelop.AspNetCore/AspNetCoreExecutionCommand.cs
@@ -28,33 +28,16 @@ using MonoDevelop.DotNetCore;
 
 namespace MonoDevelop.AspNetCore
 {
-	class AspNetCoreExecutionCommand : ProcessExecutionCommand
+	class AspNetCoreExecutionCommand : DotNetCoreExecutionCommand
 	{
 		public AspNetCoreExecutionCommand (string directory, string outputPath, string arguments)
+			: base (directory, outputPath, arguments)
 		{
-			WorkingDirectory = directory;
-			OutputPath = outputPath;
-			DotNetArguments = arguments;
-
-			Command = DotNetCoreRuntime.FileName;
-			Arguments = string.Format ("\"{0}\" {1}", outputPath, arguments);
 		}
 
-		public string OutputPath { get; private set; }
-		public string DotNetArguments { get; private set; }
-
-		public bool PauseConsoleOutput { get; set; }
-		public bool ExternalConsole { get; set; }
-		public bool LaunchBrowser { get; set; }
-		public string LaunchURL { get; set; }
 		// Since we are now supporting more than one url, we added this property
 		// so that it contains the raw value of AppUrl
 		// which might provide more than one url i.e. https://localhost:5000;http://localhost:5001
 		public string ApplicationURLs { get; set; }
-		// This is only kept for compatibility with debugger and should contain just
-		// the url that is going to be launched i.e. https://localhost:5000
-		public string ApplicationURL { get; set; }
-
-		public PipeTransportSettings PipeTransport { get; set; }
 	}
 }
diff --git a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/AssemblyBrowserViewContent.cs b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/AssemblyBrowserViewContent.cs
index 36051d5fcb..2e2740eea2 100644
--- a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/AssemblyBrowserViewContent.cs
+++ b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/AssemblyBrowserViewContent.cs
@@ -194,17 +194,6 @@ namespace MonoDevelop.AssemblyBrowser
 				foreach (var project in Ide.IdeApp.ProjectOperations.CurrentSelectedSolution.GetAllProjects ()) {
 					try {
 						Widget.AddProject (project, false);
-						var netProject = project as DotNetProject;
-						if (netProject == null)
-							continue;
-						foreach (var file in await netProject.GetReferencedAssemblies (ConfigurationSelector.Default, false)) {
-							if (!System.IO.File.Exists (file.FilePath))
-								continue;
-							if (!alreadyAdded.Add (file.FilePath))
-								continue;
-							var loader = Widget.AddReferenceByFileName (file.FilePath);
-							allTasks.Add (loader.LoadingTask);
-						}
 					} catch (Exception e) {
 						LoggingService.LogError ("Error while adding project " + project.Name + " to the tree.", e);
 					}
diff --git a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/AssemblyBrowserWidget.cs b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/AssemblyBrowserWidget.cs
index 575048df31..fc47e392e0 100644
--- a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/AssemblyBrowserWidget.cs
+++ b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/AssemblyBrowserWidget.cs
@@ -817,7 +817,7 @@ namespace MonoDevelop.AssemblyBrowser
 		internal void SetReferencedSegments (List<ReferenceSegment> refs)
 		{
 			ReferencedSegments = refs;
-			if (ReferencedSegments == null)
+			if (ReferencedSegments == null || IsDestroyed)
 				return;
 			foreach (var _seg in refs) {
 				var seg = _seg;
@@ -879,17 +879,20 @@ namespace MonoDevelop.AssemblyBrowser
 			case 0:
 				inspectEditor.Options = assemblyBrowserEditorOptions;
 				this.inspectEditor.MimeType = "text/x-csharp";
-				SetReferencedSegments (builder.Decompile (inspectEditor, nav, new DecompileFlags { PublicOnly = PublicApiOnly, MethodBodies = false }));
+				builder.DecompileAsync (inspectEditor, nav, new DecompileFlags { PublicOnly = PublicApiOnly, MethodBodies = false })
+					.ContinueWith (l => SetReferencedSegments (l.Result), Runtime.MainTaskScheduler);
 				break;
 			case 1:
 				inspectEditor.Options = assemblyBrowserEditorOptions;
 				this.inspectEditor.MimeType = "text/x-ilasm";
-				SetReferencedSegments (builder.Disassemble (inspectEditor, nav));
+				builder.DisassembleAsync (inspectEditor, nav)
+					.ContinueWith (l => SetReferencedSegments (l.Result), Runtime.MainTaskScheduler);
 				break;
 			case 2:
 				inspectEditor.Options = assemblyBrowserEditorOptions;
 				this.inspectEditor.MimeType = "text/x-csharp";
-				SetReferencedSegments (builder.Decompile (inspectEditor, nav, new DecompileFlags { PublicOnly = PublicApiOnly, MethodBodies = true }));
+				builder.DecompileAsync (inspectEditor, nav, new DecompileFlags { PublicOnly = PublicApiOnly, MethodBodies = true })
+					.ContinueWith (l => SetReferencedSegments (l.Result), Runtime.MainTaskScheduler);
 				break;
 			default:
 				inspectEditor.Options = assemblyBrowserEditorOptions;
@@ -1070,9 +1073,12 @@ namespace MonoDevelop.AssemblyBrowser
 			} while (nav.MoveNext ());
 			nav.MoveToParent ();
 		}
-		
+
+		public bool IsDestroyed { get; private set; }
+
 		protected override void OnDestroyed ()
 		{
+			IsDestroyed = true;
 			ClearReferenceSegment ();
 			searchTokenSource.Cancel ();
 
@@ -1140,56 +1146,51 @@ namespace MonoDevelop.AssemblyBrowser
 			
 			return AddReferenceByFileName (assemblyFile, expand, querySearch);
 		}
-		object assemblyLoadingLock = new object ();
 
 		internal AssemblyLoader AddReferenceByFileName (string fileName, bool expand = false, bool querySearch = true)
 		{
-			lock (assemblyLoadingLock) {
-				foreach (var def in definitions) {
-					if (FilePath.PathComparer.Equals (fileName, def.FileName))
-						return def;
-				}
-				if (!File.Exists (fileName))
-					return null;
-				var result = new AssemblyLoader (this, fileName);
-				definitions = definitions.Add (result);
-				result.LoadingTask = result.LoadingTask.ContinueWith (task => {
-					Application.Invoke ((o, args) => {
-						if (definitions.Count == 0)
+			foreach (var def in definitions) {
+				if (FilePath.PathComparer.Equals (fileName, def.FileName))
+					return def;
+			}
+			if (!File.Exists (fileName))
+				return null;
+			var result = new AssemblyLoader (this, fileName);
+			definitions = definitions.Add (result);
+			result.LoadingTask = result.LoadingTask.ContinueWith (task => {
+				Application.Invoke ((o, args) => {
+					if (TreeView == null || definitions.Count == 0)
+						return;
+					var fullName = result.Assembly.FullName;
+
+					// filter duplicate assemblies, can happen on opening the same assembly at different locations.
+					foreach (var d in definitions) {
+						if (!d.IsLoaded || d == result)
+							continue;
+						if (d.Assembly.FullName == fullName) {
+							definitions = definitions.Remove (result);
+							LoggingService.LogInfo ("AssemblyBrowser: Loaded duplicate assembly : " + fullName); // Write a log info in case that happens, shouldn't happen often.
 							return;
-						var fullName = result.Assembly.FullName;
-
-						// filter duplicate assemblies, can happen on opening the same assembly at different locations.
-						lock (assemblyLoadingLock) {
-							foreach (var d in definitions) {
-								if (!d.AssemblyTask.IsCompleted || d == result)
-									continue;
-								if (d.Assembly.FullName == fullName) {
-									definitions = definitions.Remove (result);
-									LoggingService.LogInfo ("AssemblyBrowser: Loaded duplicate assembly : " + fullName); // Write a log info in case that happens, shouldn't happen often.
-									return;
-								}
-							}
 						}
-
-						try {
-							ITreeBuilder builder;
-							if (definitions.Count + projects.Count == 1) {
-								builder = TreeView.LoadTree (result);
-							} else {
-								builder = TreeView.AddChild (result, false);
-							}
-							if (TreeView.GetSelectedNode () == null)
-								builder.Selected = builder.Expanded = expand;
-						} catch (Exception e) {
-							LoggingService.LogError ("Error while adding assembly to the assembly list", e);
+					}
+						
+					try {
+						ITreeBuilder builder;
+						if (definitions.Count + projects.Count == 1) {
+							builder = TreeView.LoadTree (result);
+						} else {
+							builder = TreeView.AddChild (result, false);
 						}
-					});
-					return task.Result;
-				}
-				);
-				return result;
+						if (TreeView.GetSelectedNode () == null)
+							builder.Selected = builder.Expanded = expand;
+					} catch (Exception e) {
+						LoggingService.LogError ("Error while adding assembly to the assembly list", e);
+					}
+				});
+				return task.Result;
 			}
+			);
+			return result;
 		}
 		
 		public void AddProject (Project project, bool selectReference = true)
@@ -1250,22 +1251,20 @@ namespace MonoDevelop.AssemblyBrowser
 		}
 		#endregion
 
-		internal void EnsureDefinitionsLoaded (ImmutableList<AssemblyLoader> definitions)
+		internal void EnsureDefinitionsLoaded (ImmutableList<AssemblyLoader> ensuredDefinitions)
 		{
-			if (definitions == null)
-				throw new ArgumentNullException (nameof (definitions));
-			lock (assemblyLoadingLock) {
-				foreach (var def in definitions) {
-					if (!this.definitions.Contains (def)) {
-						this.definitions = this.definitions.Add (def);
-						Application.Invoke ((o, args) => {
-							if (definitions.Count + projects.Count == 1) {
-								TreeView.LoadTree (def.LoadingTask.Result);
-							} else {
-								TreeView.AddChild (def.LoadingTask.Result);
-							}
-						});
-					}
+			if (ensuredDefinitions == null)
+				throw new ArgumentNullException (nameof (ensuredDefinitions));
+			foreach (var def in ensuredDefinitions) {
+				if (!definitions.Contains (def)) {
+					definitions = definitions.Add (def);
+					Application.Invoke ((o, args) => {
+						if (ensuredDefinitions.Count + projects.Count == 1) {
+							TreeView.LoadTree (def.LoadingTask.Result);
+						} else {
+							TreeView.AddChild (def.LoadingTask.Result);
+						}
+					});
 				}
 			}
 		}
diff --git a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/AssemblyLoader.cs b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/AssemblyLoader.cs
index 4f132fb1e1..31d7aed461 100644
--- a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/AssemblyLoader.cs
+++ b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/AssemblyLoader.cs
@@ -34,7 +34,7 @@ using System.Collections.Generic;
 using ICSharpCode.Decompiler.Metadata;
 using System.Reflection.Metadata;
 using System.Linq;
-
+using ICSharpCode.Decompiler.TypeSystem.Implementation;
 
 namespace MonoDevelop.AssemblyBrowser
 {
@@ -83,16 +83,21 @@ namespace MonoDevelop.AssemblyBrowser
 
 		DecompilerTypeSystem decompilerTypeSystem;
 		public DecompilerTypeSystem DecompilerTypeSystem { 
-			get { 
-				if (decompilerTypeSystem == null) {
-					decompilerTypeSystem = new DecompilerTypeSystem (Assembly, new AssemblyResolver (widget));
-				}
-				return decompilerTypeSystem; 
+			get {
+				LoadTypeSystem (Assembly);
+				return decompilerTypeSystem;
 			}
 		}
 
+		void LoadTypeSystem (PEFile peFile)
+		{
+			decompilerTypeSystem = new DecompilerTypeSystem (peFile, new AssemblyResolver (Assembly, widget));
+		}
+
 		public Error Error { get; internal set; }
 
+		public bool IsLoaded { get; private set; }
+
 		public AssemblyLoader (AssemblyBrowserWidget widget, string fileName)
 		{
 			if (widget == null)
@@ -116,28 +121,57 @@ namespace MonoDevelop.AssemblyBrowser
 					Error = new Error(e.Message);
 					assemblyDefinitionTaskSource.SetResult (null);
 					return null;
-				}
+				} finally { IsLoaded = true; }
 			});
 		}
 
+		ICompilation typeSystem;
+
+		public ICompilation GetMinimalTypeSystem ()
+		{
+			if (typeSystem != null)
+				return typeSystem;
+			var assembly = Assembly;
+			if (assembly == null)
+				return null;
+			return typeSystem = new SimpleCompilation (assembly.WithOptions (TypeSystemOptions.Default | TypeSystemOptions.Uncached | TypeSystemOptions.KeepModifiers), MinimalCorlib.Instance);
+		}
+
+		class MyUniversalAssemblyResolver : UniversalAssemblyResolver
+		{
+			public MyUniversalAssemblyResolver (string mainAssemblyFileName, bool throwOnError, string targetFramework) : base (mainAssemblyFileName, throwOnError, targetFramework)
+			{
+			}
+		}
 		class AssemblyResolver : IAssemblyResolver
 		{
+			readonly PEFile assembly;
 			readonly AssemblyBrowserWidget widget;
-			public AssemblyResolver (AssemblyBrowserWidget widget)
+
+			public AssemblyResolver (PEFile assembly, AssemblyBrowserWidget widget)
 			{
+				this.assembly = assembly;
 				this.widget = widget;
 			}
 
 			public PEFile Resolve (IAssemblyReference reference)
 			{
-				var loader = widget.AddReferenceByAssemblyName (reference.FullName);
-				return loader != null ? loader.Assembly : null;
+				try {
+					var targetFramework = assembly.Reader.DetectTargetFrameworkId () ?? "";
+					var resolver = new MyUniversalAssemblyResolver (assembly.FileName, false, targetFramework);
+					var fileName = resolver.FindAssemblyFile (reference);
+					if (fileName != null && File.Exists (fileName))
+						return widget.AddReferenceByFileName (fileName)?.Assembly;
+				} catch (Exception e) {
+					LoggingService.LogInternalError ($"Error while resolving assembly {reference.FullName} for {assembly.FileName}.", e);
+				}
+
+				return widget.AddReferenceByAssemblyName (reference.FullName)?.Assembly;
 			}
 
 			public PEFile ResolveModule (PEFile mainModule, string moduleName)
 			{
-				var loader = widget.AddReferenceByFileName (mainModule.FileName);
-				return loader != null ? loader.Assembly : null;
+				return widget.AddReferenceByFileName (mainModule.FileName)?.Assembly;
 			}
 		}
 
diff --git a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/IAssemblyBrowserNodeBuilder.cs b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/IAssemblyBrowserNodeBuilder.cs
index c897e4ea03..ed64391944 100644
--- a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/IAssemblyBrowserNodeBuilder.cs
+++ b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/IAssemblyBrowserNodeBuilder.cs
@@ -31,13 +31,14 @@ using MonoDevelop.Ide.Gui.Pads;
 using MonoDevelop.Ide.Gui.Components;
 using System.Collections.Generic;
 using MonoDevelop.Ide.Editor;
+using System.Threading.Tasks;
 
 namespace MonoDevelop.AssemblyBrowser
 {
 	interface IAssemblyBrowserNodeBuilder
 	{
-		List<ReferenceSegment> Disassemble (TextEditor data, ITreeNavigator navigator);
-		List<ReferenceSegment> Decompile (TextEditor data, ITreeNavigator navigator, DecompileFlags flags);
+		Task<List<ReferenceSegment>> DisassembleAsync (TextEditor data, ITreeNavigator navigator);
+		Task<List<ReferenceSegment>> DecompileAsync (TextEditor data, ITreeNavigator navigator, DecompileFlags flags);
 	}
 
 	class DecompileFlags
diff --git a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/AssemblyBrowserTypeNodeBuilder.cs b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/AssemblyBrowserTypeNodeBuilder.cs
index 5cc13e4663..9e9ed85e07 100644
--- a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/AssemblyBrowserTypeNodeBuilder.cs
+++ b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/AssemblyBrowserTypeNodeBuilder.cs
@@ -32,6 +32,8 @@ using MonoDevelop.Core;
 using MonoDevelop.Projects;
 using MonoDevelop.Ide.TypeSystem;
 using ICSharpCode.Decompiler.CSharp.OutputVisitor;
+using System.Threading.Tasks;
+using System.Collections.Generic;
 
 namespace MonoDevelop.AssemblyBrowser
 {
@@ -42,6 +44,7 @@ namespace MonoDevelop.AssemblyBrowser
 			private set; 
 		}
 		readonly static CSharpAmbience ambience = new CSharpAmbience ();
+		public static readonly Task<List<ReferenceSegment>> EmptyReferenceSegmentTask = Task.FromResult (new List<ReferenceSegment> ());
 
 		protected CSharpAmbience Ambience {
 			get {
diff --git a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/AssemblyNodeBuilder.cs b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/AssemblyNodeBuilder.cs
index 9d7082ce06..0e2c3fd73a 100644
--- a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/AssemblyNodeBuilder.cs
+++ b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/AssemblyNodeBuilder.cs
@@ -38,6 +38,7 @@ using System.IO;
 using MonoDevelop.Ide.Editor;
 using ICSharpCode.Decompiler.TypeSystem;
 using ICSharpCode.Decompiler.Metadata;
+using System.Threading.Tasks;
 
 namespace MonoDevelop.AssemblyBrowser
 {
@@ -85,25 +86,25 @@ namespace MonoDevelop.AssemblyBrowser
 
 		public override void BuildChildNodes (ITreeBuilder treeBuilder, object dataObject)
 		{
-			var compilationUnit = (AssemblyLoader)dataObject;
-			if (compilationUnit.Error != null) {
-				treeBuilder.AddChild (compilationUnit.Error);
+			var assemblyLoader = (AssemblyLoader)dataObject;
+			if (assemblyLoader.Error != null) {
+				treeBuilder.AddChild (assemblyLoader.Error);
 				return;
 			}
-			if (compilationUnit.Assembly == null)
+			if (assemblyLoader.Assembly == null)
 				return;
-			var references = new AssemblyReferenceFolder (compilationUnit.Assembly);
+			var references = new AssemblyReferenceFolder (assemblyLoader.Assembly);
 			if (references.AssemblyReferences.Any () || references.ModuleReferences.Any ())
 				treeBuilder.AddChild (references);
 
-			var resources = new AssemblyResourceFolder (compilationUnit.Assembly);
+			var resources = new AssemblyResourceFolder (assemblyLoader.Assembly);
 			if (resources.Resources.Any ())
 				treeBuilder.AddChild (resources);
 			
 			var namespaces = new Dictionary<string, NamespaceData> ();
 			bool publicOnly = Widget.PublicApiOnly;
-			
-			foreach (var type in compilationUnit.DecompilerTypeSystem.MainModule.TypeDefinitions) {
+
+			foreach (var type in assemblyLoader.GetMinimalTypeSystem ().MainModule.TopLevelTypeDefinitions) {
 				string namespaceName = string.IsNullOrEmpty (type.Namespace) ? "" : type.Namespace;
 				if (!namespaces.ContainsKey (namespaceName))
 					namespaces [namespaceName] = new NamespaceData (namespaceName);
@@ -125,7 +126,7 @@ namespace MonoDevelop.AssemblyBrowser
 		public override bool HasChildNodes (ITreeBuilder builder, object dataObject)
 		{
 			var compilationUnit = (AssemblyLoader)dataObject;
-			return compilationUnit.DecompilerTypeSystem?.MainModule.TypeDefinitions.Any () == true || compilationUnit.Error != null;
+			return compilationUnit.Assembly.Metadata.TypeDefinitions.Count > 0 || compilationUnit.Error != null;
 		}
 		
 		public override int CompareObjects (ITreeNavigator thisNode, ITreeNavigator otherNode)
@@ -162,22 +163,22 @@ namespace MonoDevelop.AssemblyBrowser
 			result.AppendLine ();
 		}
 		
-		public List<ReferenceSegment> Disassemble (TextEditor data, ITreeNavigator navigator)
+		public Task<List<ReferenceSegment>> DisassembleAsync (TextEditor data, ITreeNavigator navigator)
 		{
 			var assemblyLoader = (AssemblyLoader)navigator.DataItem;
 			var compilationUnit = assemblyLoader.Assembly;
 			if (compilationUnit == null) {
 				LoggingService.LogError ("Can't get cecil object for assembly:" + assemblyLoader.Assembly.FullName);
-				return new List<ReferenceSegment> ();
+				return Task.FromResult (new List<ReferenceSegment> ());
 			}
-			return MethodDefinitionNodeBuilder.Disassemble (data, rd => rd.WriteAssemblyHeader (compilationUnit));
+			return MethodDefinitionNodeBuilder.DisassembleAsync (data, rd => rd.WriteAssemblyHeader (compilationUnit));
 		}
 		
 		
-		public List<ReferenceSegment> Decompile (TextEditor data, ITreeNavigator navigator, DecompileFlags flags)
+		public Task<List<ReferenceSegment>> DecompileAsync (TextEditor data, ITreeNavigator navigator, DecompileFlags flags)
 		{
 			var assemblyLoader = (AssemblyLoader)navigator.DataItem;
-			return MethodDefinitionNodeBuilder.Decompile (data, MethodDefinitionNodeBuilder.GetAssemblyLoader (navigator), b => 
+			return MethodDefinitionNodeBuilder.DecompileAsync (data, MethodDefinitionNodeBuilder.GetAssemblyLoader (navigator), b => 
 				b.DecompileModuleAndAssemblyAttributes(), flags: flags);
 		}
 
diff --git a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/EventDefinitionNodeBuilder.cs b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/EventDefinitionNodeBuilder.cs
index 73d18de102..04ad6d5cc8 100644
--- a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/EventDefinitionNodeBuilder.cs
+++ b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/EventDefinitionNodeBuilder.cs
@@ -39,6 +39,7 @@ using ICSharpCode.Decompiler.TypeSystem;
 using MonoDevelop.Ide.Editor;
 using ICSharpCode.Decompiler.CSharp;
 using MonoDevelop.Core;
+using System.Threading.Tasks;
 
 namespace MonoDevelop.AssemblyBrowser
 {
@@ -91,24 +92,24 @@ namespace MonoDevelop.AssemblyBrowser
 		{
 			return false;
 		}
-		
+
 		#region IAssemblyBrowserNodeBuilder
-		List<ReferenceSegment> IAssemblyBrowserNodeBuilder.Disassemble (TextEditor data, ITreeNavigator navigator)
+		Task<List<ReferenceSegment>> IAssemblyBrowserNodeBuilder.DisassembleAsync (TextEditor data, ITreeNavigator navigator)
 		{
 			if (MethodDefinitionNodeBuilder.HandleSourceCodeEntity (navigator, data)) 
-				return null;
+				return EmptyReferenceSegmentTask;
 			var evt = (IEvent)navigator.DataItem;
-			return MethodDefinitionNodeBuilder.Disassemble (data, rd => rd.DisassembleEvent (evt.ParentModule.PEFile, (System.Reflection.Metadata.EventDefinitionHandle)evt.MetadataToken));
+			return MethodDefinitionNodeBuilder.DisassembleAsync (data, rd => rd.DisassembleEvent (evt.ParentModule.PEFile, (System.Reflection.Metadata.EventDefinitionHandle)evt.MetadataToken));
 		}
-		
-		List<ReferenceSegment> IAssemblyBrowserNodeBuilder.Decompile (TextEditor data, ITreeNavigator navigator, DecompileFlags flags)
+
+		Task<List<ReferenceSegment>> IAssemblyBrowserNodeBuilder.DecompileAsync (TextEditor data, ITreeNavigator navigator, DecompileFlags flags)
 		{
 			if (MethodDefinitionNodeBuilder.HandleSourceCodeEntity (navigator, data)) 
-				return null;
+				return EmptyReferenceSegmentTask;
 			var evt = navigator.DataItem as IEvent;
 			if (evt == null)
-				return null;
-			return MethodDefinitionNodeBuilder.Decompile (data, MethodDefinitionNodeBuilder.GetAssemblyLoader (navigator), b => b.Decompile (evt.MetadataToken), flags: flags);
+				return EmptyReferenceSegmentTask;
+			return MethodDefinitionNodeBuilder.DecompileAsync (data, MethodDefinitionNodeBuilder.GetAssemblyLoader (navigator), b => b.Decompile (evt.MetadataToken), flags: flags);
 		}
 
 		#endregion
diff --git a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/FieldDefinitionNodeBuilder.cs b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/FieldDefinitionNodeBuilder.cs
index ba1a8df22f..c7c0709264 100644
--- a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/FieldDefinitionNodeBuilder.cs
+++ b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/FieldDefinitionNodeBuilder.cs
@@ -28,6 +28,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using ICSharpCode.Decompiler.TypeSystem;
 using MonoDevelop.Core;
 using MonoDevelop.Ide.Editor;
@@ -72,24 +73,25 @@ namespace MonoDevelop.AssemblyBrowser
 
 		#region IAssemblyBrowserNodeBuilder
 
-		List<ReferenceSegment> IAssemblyBrowserNodeBuilder.Disassemble (TextEditor data, ITreeNavigator navigator)
+
+		Task<List<ReferenceSegment>> IAssemblyBrowserNodeBuilder.DisassembleAsync (TextEditor data, ITreeNavigator navigator)
 		{
 			if (MethodDefinitionNodeBuilder.HandleSourceCodeEntity (navigator, data)) 
-				return null;
+				return EmptyReferenceSegmentTask;
 			var field = (IField)navigator.DataItem;
 			if (field == null)
-				return null;
-			return MethodDefinitionNodeBuilder.Disassemble (data, rd => rd.DisassembleField (field.ParentModule.PEFile, (System.Reflection.Metadata.FieldDefinitionHandle)field.MetadataToken));
+				return EmptyReferenceSegmentTask;
+			return MethodDefinitionNodeBuilder.DisassembleAsync (data, rd => rd.DisassembleField (field.ParentModule.PEFile, (System.Reflection.Metadata.FieldDefinitionHandle)field.MetadataToken));
 		}
-		
-		List<ReferenceSegment> IAssemblyBrowserNodeBuilder.Decompile (TextEditor data, ITreeNavigator navigator, DecompileFlags flags)
+
+		Task<List<ReferenceSegment>> IAssemblyBrowserNodeBuilder.DecompileAsync (TextEditor data, ITreeNavigator navigator, DecompileFlags flags)
 		{
 			if (MethodDefinitionNodeBuilder.HandleSourceCodeEntity (navigator, data)) 
-				return null;
+				return EmptyReferenceSegmentTask;
 			var field = (IField)navigator.DataItem;
 			if (field == null)
-				return null;
-			return MethodDefinitionNodeBuilder.Decompile (data, MethodDefinitionNodeBuilder.GetAssemblyLoader (navigator), b => b.Decompile (field.MetadataToken), flags: flags);
+				return EmptyReferenceSegmentTask;
+			return MethodDefinitionNodeBuilder.DecompileAsync (data, MethodDefinitionNodeBuilder.GetAssemblyLoader (navigator), b => b.Decompile (field.MetadataToken), flags: flags);
 		}
 
 		#endregion
diff --git a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/MethodDefinitionNodeBuilder.cs b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/MethodDefinitionNodeBuilder.cs
index e2795211f3..81b1fa822b 100644
--- a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/MethodDefinitionNodeBuilder.cs
+++ b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/MethodDefinitionNodeBuilder.cs
@@ -30,6 +30,7 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Threading;
+using System.Threading.Tasks;
 using ICSharpCode.Decompiler;
 using ICSharpCode.Decompiler.CSharp;
 using ICSharpCode.Decompiler.CSharp.OutputVisitor;
@@ -123,26 +124,38 @@ namespace MonoDevelop.AssemblyBrowser
 		}
 
 
-		public static List<ReferenceSegment> Decompile (TextEditor data, AssemblyLoader assemblyLoader, Func<CSharpDecompiler, SyntaxTree> decompile, DecompilerSettings settings = null, DecompileFlags flags = null)
+		public static async Task<List<ReferenceSegment>> DecompileAsync (TextEditor data, AssemblyLoader assemblyLoader, Func<CSharpDecompiler, SyntaxTree> decompile, DecompilerSettings settings = null, DecompileFlags flags = null)
 		{
-			settings = settings ?? GetDecompilerSettings (data, publicOnly: flags.PublicOnly);
-			var csharpDecompiler = assemblyLoader.CSharpDecompiler;
-			try {
-				var syntaxTree = decompile (csharpDecompiler);
-				if (!flags.MethodBodies) {
-					MethodBodyRemoveVisitor.RemoveMethodBodies (syntaxTree);
+			if (data == null) 
+				throw new ArgumentNullException (nameof (data));
+			if (assemblyLoader == null) 
+				throw new ArgumentNullException (nameof (assemblyLoader));
+
+			return await Task.Run (async delegate {
+				settings = settings ?? GetDecompilerSettings (data, publicOnly: flags.PublicOnly);
+				var csharpDecompiler = assemblyLoader.CSharpDecompiler;
+				try {
+					var syntaxTree = decompile (csharpDecompiler);
+					if (!flags.MethodBodies) {
+						MethodBodyRemoveVisitor.RemoveMethodBodies (syntaxTree);
+					}
+					return await Runtime.RunInMainThread (delegate {
+						if (data.IsDisposed)
+							return new List<ReferenceSegment> ();
+						var output = new ColoredCSharpFormatter (data);
+						TokenWriter tokenWriter = new TextTokenWriter (output, settings, csharpDecompiler.TypeSystem) { FoldBraces = settings.FoldBraces };
+						var formattingPolicy = settings.CSharpFormattingOptions;
+						syntaxTree.AcceptVisitor (new CSharpOutputVisitor (tokenWriter, formattingPolicy));
+						output.SetDocumentData ();
+						return output.ReferencedSegments;
+					});
+				} catch (Exception e) {
+					await Runtime.RunInMainThread (delegate {
+						data.InsertText (data.Length, "/* decompilation failed: \n" + e + " */");
+					});
 				}
-
-				var output = new ColoredCSharpFormatter (data);
-				TokenWriter tokenWriter = new TextTokenWriter (output, settings, csharpDecompiler.TypeSystem) { FoldBraces = settings.FoldBraces };
-				var formattingPolicy = settings.CSharpFormattingOptions;
-				syntaxTree.AcceptVisitor (new CSharpOutputVisitor (tokenWriter, formattingPolicy));
-				output.SetDocumentData ();
-				return output.ReferencedSegments;
-			} catch (Exception e) {
-				data.InsertText (data.Length, "/* decompilation failed: \n" + e + " */");
-			}
-			return null;
+				return new List<ReferenceSegment> ();
+			});
 		}
 
 		internal static string GetAttributes (IEnumerable<IAttribute> attributes)
@@ -160,14 +173,14 @@ namespace MonoDevelop.AssemblyBrowser
 			return result.ToString ();
 		}
 		
-		public List<ReferenceSegment> Decompile (TextEditor data, ITreeNavigator navigator, DecompileFlags flags)
+		public Task<List<ReferenceSegment>> DecompileAsync (TextEditor data, ITreeNavigator navigator, DecompileFlags flags)
 		{
 			if (HandleSourceCodeEntity (navigator, data)) 
 				return null;
 			var cecilMethod = (IMethod)navigator.DataItem;
 			if (cecilMethod == null)
 				return null;
-			return MethodDefinitionNodeBuilder.Decompile (data, MethodDefinitionNodeBuilder.GetAssemblyLoader (navigator), b => b.Decompile (cecilMethod.MetadataToken), flags: flags);
+			return MethodDefinitionNodeBuilder.DecompileAsync (data, MethodDefinitionNodeBuilder.GetAssemblyLoader (navigator), b => b.Decompile (cecilMethod.MetadataToken), flags: flags);
 		}
 		
 		static void AppendLink (StringBuilder sb, string link, string text)
@@ -179,14 +192,14 @@ namespace MonoDevelop.AssemblyBrowser
 			sb.Append ("</a></u></span>");
 		}
 		
-		public static List<ReferenceSegment> Disassemble (TextEditor data, Action<ReflectionDisassembler> setData)
+		public static Task<List<ReferenceSegment>> DisassembleAsync (TextEditor data, Action<ReflectionDisassembler> setData)
 		{
 			var source = new CancellationTokenSource ();
 			var output = new ColoredCSharpFormatter (data);
 			var disassembler = new ReflectionDisassembler (output, source.Token);
 			setData (disassembler);
 			output.SetDocumentData ();
-			return output.ReferencedSegments;
+			return Task.FromResult (output.ReferencedSegments);
 		}
 		
 		internal static bool HandleSourceCodeEntity (ITreeNavigator navigator, TextEditor data)
@@ -201,14 +214,14 @@ namespace MonoDevelop.AssemblyBrowser
 						return true;*/
 			return false;
 		}
-		
-		List<ReferenceSegment> IAssemblyBrowserNodeBuilder.Disassemble (TextEditor data, ITreeNavigator navigator)
+
+		Task<List<ReferenceSegment>> IAssemblyBrowserNodeBuilder.DisassembleAsync (TextEditor data, ITreeNavigator navigator)
 		{
 			if (HandleSourceCodeEntity (navigator, data)) 
-				return null;
+				return EmptyReferenceSegmentTask;
 			if (!(navigator.DataItem is IMethod cecilMethod))
-				return null;
-			return Disassemble (data, rd => rd.DisassembleMethod (cecilMethod.ParentModule.PEFile, (System.Reflection.Metadata.MethodDefinitionHandle)cecilMethod.MetadataToken));
+				return EmptyReferenceSegmentTask;
+			return DisassembleAsync (data, rd => rd.DisassembleMethod (cecilMethod.ParentModule.PEFile, (System.Reflection.Metadata.MethodDefinitionHandle)cecilMethod.MetadataToken));
 		}
 
 		#endregion
diff --git a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/PropertyDefinitionNodeBuilder.cs b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/PropertyDefinitionNodeBuilder.cs
index 0e5f701693..a492f70dbb 100644
--- a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/PropertyDefinitionNodeBuilder.cs
+++ b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/PropertyDefinitionNodeBuilder.cs
@@ -39,6 +39,7 @@ using ICSharpCode.Decompiler.TypeSystem;
 using MonoDevelop.Ide.TypeSystem;
 using MonoDevelop.Ide.Editor;
 using MonoDevelop.Core;
+using System.Threading.Tasks;
 
 namespace MonoDevelop.AssemblyBrowser
 {
@@ -87,25 +88,25 @@ namespace MonoDevelop.AssemblyBrowser
 		{
 			return false;
 		}
-		
-		
+
+
 		#region IAssemblyBrowserNodeBuilder
 
-		List<ReferenceSegment> IAssemblyBrowserNodeBuilder.Disassemble (TextEditor data, ITreeNavigator navigator)
+		Task<List<ReferenceSegment>> IAssemblyBrowserNodeBuilder.DisassembleAsync (TextEditor data, ITreeNavigator navigator)
 		{
 			if (MethodDefinitionNodeBuilder.HandleSourceCodeEntity (navigator, data)) 
-				return null;
+				return EmptyReferenceSegmentTask;
 			var property = (IProperty)navigator.DataItem;
-			return MethodDefinitionNodeBuilder.Disassemble (data, rd => rd.DisassembleProperty (property.ParentModule.PEFile, (System.Reflection.Metadata.PropertyDefinitionHandle)property.MetadataToken));
+			return MethodDefinitionNodeBuilder.DisassembleAsync (data, rd => rd.DisassembleProperty (property.ParentModule.PEFile, (System.Reflection.Metadata.PropertyDefinitionHandle)property.MetadataToken));
 		}
 
-		List<ReferenceSegment> IAssemblyBrowserNodeBuilder.Decompile (TextEditor data, ITreeNavigator navigator, DecompileFlags flags)
+		Task<List<ReferenceSegment>> IAssemblyBrowserNodeBuilder.DecompileAsync (TextEditor data, ITreeNavigator navigator, DecompileFlags flags)
 		{
 			if (MethodDefinitionNodeBuilder.HandleSourceCodeEntity (navigator, data)) 
-				return null;
+				return EmptyReferenceSegmentTask;
 			if (!(navigator.DataItem is IProperty property))
-				return null;
-			return MethodDefinitionNodeBuilder.Decompile (data, MethodDefinitionNodeBuilder.GetAssemblyLoader (navigator), b => b.Decompile (property.MetadataToken), flags: flags);
+				return EmptyReferenceSegmentTask;
+			return MethodDefinitionNodeBuilder.DecompileAsync (data, MethodDefinitionNodeBuilder.GetAssemblyLoader (navigator), b => b.Decompile (property.MetadataToken), flags: flags);
 		}
 		#endregion
 
diff --git a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/TypeDefinitionNodeBuilder.cs b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/TypeDefinitionNodeBuilder.cs
index 902fe8c08d..b875def8f7 100644
--- a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/TypeDefinitionNodeBuilder.cs
+++ b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Cecil/TypeDefinitionNodeBuilder.cs
@@ -44,6 +44,7 @@ using ICSharpCode.Decompiler.CSharp.OutputVisitor;
 using System.Security;
 using ICSharpCode.Decompiler.CSharp.Syntax;
 using ICSharpCode.Decompiler.CSharp;
+using System.Threading.Tasks;
 
 namespace MonoDevelop.AssemblyBrowser
 {
@@ -166,15 +167,15 @@ namespace MonoDevelop.AssemblyBrowser
 			return "";
 		}
 		
-		public List<ReferenceSegment> Disassemble (TextEditor data, ITreeNavigator navigator)
+		public Task<List<ReferenceSegment>> DisassembleAsync (TextEditor data, ITreeNavigator navigator)
 		{
 			if (MethodDefinitionNodeBuilder.HandleSourceCodeEntity (navigator, data)) 
-				return null;
+				return EmptyReferenceSegmentTask;
 			var type = (ITypeDefinition)navigator.DataItem;
 			if (type == null)
-				return null;
+				return EmptyReferenceSegmentTask;
 
-			return MethodDefinitionNodeBuilder.Disassemble (data, rd => rd.DisassembleType (type.ParentModule.PEFile, (System.Reflection.Metadata.TypeDefinitionHandle)type.MetadataToken));
+			return MethodDefinitionNodeBuilder.DisassembleAsync (data, rd => rd.DisassembleType (type.ParentModule.PEFile, (System.Reflection.Metadata.TypeDefinitionHandle)type.MetadataToken));
 		}
 
 		internal static DecompilerSettings CreateDecompilerSettings (bool publicOnly, MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy codePolicy)
@@ -193,16 +194,16 @@ namespace MonoDevelop.AssemblyBrowser
 			};
 		}
 
-		public List<ReferenceSegment> Decompile (TextEditor data, ITreeNavigator navigator, DecompileFlags flags)
+		public Task<List<ReferenceSegment>> DecompileAsync (TextEditor data, ITreeNavigator navigator, DecompileFlags flags)
 		{
 			if (MethodDefinitionNodeBuilder.HandleSourceCodeEntity (navigator, data)) 
-				return null;
+				return EmptyReferenceSegmentTask;
 			var type = (ITypeDefinition)navigator.DataItem;
 			if (type == null)
-				return null;
+				return EmptyReferenceSegmentTask;
 			var settings = MethodDefinitionNodeBuilder.GetDecompilerSettings (data, flags.PublicOnly);
 			// CSharpLanguage.Instance.DecompileType (type, output, settings);
-			return MethodDefinitionNodeBuilder.Decompile (
+			return MethodDefinitionNodeBuilder.DecompileAsync (
 				data, 
 				MethodDefinitionNodeBuilder.GetAssemblyLoader (navigator), 
 				builder => builder.Decompile (type.MetadataToken), flags: flags);
diff --git a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/NamespaceBuilder.cs b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/NamespaceBuilder.cs
index 7d82a9e52e..89c848dc27 100644
--- a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/NamespaceBuilder.cs
+++ b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/NamespaceBuilder.cs
@@ -34,6 +34,7 @@ using MonoDevelop.Ide.Gui.Components;
 using System.Collections.Generic;
 using MonoDevelop.Core;
 using MonoDevelop.Ide.Editor;
+using System.Threading.Tasks;
 
 namespace MonoDevelop.AssemblyBrowser
 {
@@ -101,18 +102,18 @@ namespace MonoDevelop.AssemblyBrowser
 		
 		#region IAssemblyBrowserNodeBuilder
 
-		public List<ReferenceSegment> Disassemble (TextEditor data, ITreeNavigator navigator)
+		public Task<List<ReferenceSegment>> DisassembleAsync (TextEditor data, ITreeNavigator navigator)
 		{
 		//	bool publicOnly = Widget.PublicApiOnly;
 			NamespaceData ns = (NamespaceData)navigator.DataItem;
 			
 			data.Text = "// " + ns.Name;
-			return null;
+			return EmptyReferenceSegmentTask;
 		}
 		
-		public List<ReferenceSegment> Decompile (TextEditor data, ITreeNavigator navigator, DecompileFlags flags)
+		public Task<List<ReferenceSegment>> DecompileAsync (TextEditor data, ITreeNavigator navigator, DecompileFlags flags)
 		{
-			return Disassemble (data, navigator);
+			return DisassembleAsync (data, navigator);
 		}
 		#endregion
 	}
diff --git a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Roslyn/RoslynMemberNodeBuilder.cs b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Roslyn/RoslynMemberNodeBuilder.cs
index be4f1a47a8..57b2f79562 100644
--- a/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Roslyn/RoslynMemberNodeBuilder.cs
+++ b/main/src/addins/MonoDevelop.AssemblyBrowser/MonoDevelop.AssemblyBrowser/TreeNodes/Roslyn/RoslynMemberNodeBuilder.cs
@@ -32,6 +32,7 @@ using MonoDevelop.Ide.Gui.Components;
 using MonoDevelop.Ide.Gui.Pads;
 using MonoDevelop.Ide.TypeSystem;
 using MonoDevelop.Core;
+using System.Threading.Tasks;
 
 namespace MonoDevelop.AssemblyBrowser
 {
@@ -79,20 +80,18 @@ namespace MonoDevelop.AssemblyBrowser
 			return 4;
 		}
 
-		public List<ReferenceSegment> Decompile (TextEditor data, ITreeNavigator navigator, DecompileFlags flags)
+		public Task<List<ReferenceSegment>> DecompileAsync (TextEditor data, ITreeNavigator navigator, DecompileFlags flags)
 		{
-			return Disassemble (data, navigator);
+			return DisassembleAsync (data, navigator);
 		}
 
-		static readonly List<ReferenceSegment> emptyReferences = new List<ReferenceSegment> ();
-
-		public List<ReferenceSegment> Disassemble (TextEditor data, ITreeNavigator navigator)
+		public Task<List<ReferenceSegment>> DisassembleAsync (TextEditor data, ITreeNavigator navigator)
 		{
 			var symbol = navigator.DataItem as ISymbol;
 			if (symbol == null) {
 				data.Text = "// DataItem is no symbol " + navigator.DataItem; // should never happen
 				LoggingService.LogError ("DataItem is no symbol " + navigator.DataItem);
-				return emptyReferences;
+				return AssemblyBrowserTypeNodeBuilder.EmptyReferenceSegmentTask;
 			}
 			var location = symbol.Locations [0];
 			if (location.IsInSource) {
@@ -107,7 +106,7 @@ namespace MonoDevelop.AssemblyBrowser
 				data.Text = "// Error: Symbol " + symbol.MetadataName + " is not in source."; // should never happen
 				LoggingService.LogError ("Symbol " + symbol.MetadataName + " is not in source.");
 			}
-			return emptyReferences;
+			return AssemblyBrowserTypeNodeBuilder.EmptyReferenceSegmentTask;
 		}
 
 
diff --git a/main/src/addins/MonoDevelop.Autotools/MakefileData.cs b/main/src/addins/MonoDevelop.Autotools/MakefileData.cs
index 3a092218be..f82e9abe77 100644
--- a/main/src/addins/MonoDevelop.Autotools/MakefileData.cs
+++ b/main/src/addins/MonoDevelop.Autotools/MakefileData.cs
@@ -1426,7 +1426,7 @@ namespace MonoDevelop.Autotools
 
 			List<string> files = new List<string> ();
 			foreach (ProjectFile pf in OwnerProject.Files) {
-				if (pf.Subtype != Subtype.Code)
+				if (pf.Subtype != Subtype.Code && pf.Subtype != Subtype.Designer)
 					continue;
 				if (IsFileExcluded (pf.FilePath))
 					continue;
diff --git a/main/src/addins/MonoDevelop.Autotools/SimpleProjectMakefileHandler.cs b/main/src/addins/MonoDevelop.Autotools/SimpleProjectMakefileHandler.cs
index 04956c63e2..1eeae4a276 100644
--- a/main/src/addins/MonoDevelop.Autotools/SimpleProjectMakefileHandler.cs
+++ b/main/src/addins/MonoDevelop.Autotools/SimpleProjectMakefileHandler.cs
@@ -152,7 +152,7 @@ namespace MonoDevelop.Autotools
 					{
 						case BuildAction.Compile:
 							
-							if ( projectFile.Subtype != Subtype.Code ) continue;
+							if (projectFile.Subtype != Subtype.Code && projectFile.Subtype != Subtype.Designer) continue;
 							files.AppendFormat ( "\\\n\t{0} ", MakefileData.ToMakefilePath (pfpath));
 							break;
 
diff --git a/main/src/addins/MonoDevelop.Debugger.VSCodeDebugProtocol/MonoDevelop.Debugger.VsCodeDebugProtocol/VSCodeDebuggerSession.cs b/main/src/addins/MonoDevelop.Debugger.VSCodeDebugProtocol/MonoDevelop.Debugger.VsCodeDebugProtocol/VSCodeDebuggerSession.cs
index c48f1599d3..2d195f82cf 100644
--- a/main/src/addins/MonoDevelop.Debugger.VSCodeDebugProtocol/MonoDevelop.Debugger.VsCodeDebugProtocol/VSCodeDebuggerSession.cs
+++ b/main/src/addins/MonoDevelop.Debugger.VSCodeDebugProtocol/MonoDevelop.Debugger.VsCodeDebugProtocol/VSCodeDebuggerSession.cs
@@ -100,6 +100,37 @@ namespace MonoDevelop.Debugger.VsCodeDebugProtocol
 			return threads;
 		}
 
+		public override bool CanSetNextStatement {
+			get { return true; }
+		}
+
+		protected override void OnSetNextStatement (long threadId, string fileName, int line, int column)
+		{
+			var source = new Source { Name = Path.GetFileName (fileName), Path = fileName };
+			var request = new GotoTargetsRequest (source, line) { Column = column };
+			var response = protocolClient.SendRequestSync (request);
+			GotoTarget target = null;
+
+			foreach (var location in response.Targets) {
+				if (location.Line <= line && location.EndLine >= line && location.Column <= column && location.EndColumn >= column) {
+					// exact match for location
+					target = location;
+					break;
+				}
+
+				if (target == null) {
+					// closest match so far...
+					target = location;
+				}
+			}
+
+			if (target == null)
+				throw new NotImplementedException ();
+
+			protocolClient.SendRequestSync (new GotoRequest ((int) threadId, target.Id));
+			RaiseStopEvent ();
+		}
+
 		Dictionary<BreakEvent, BreakEventInfo> breakpoints = new Dictionary<BreakEvent, BreakEventInfo> ();
 
 		protected override BreakEventInfo OnInsertBreakEvent (BreakEvent breakEvent)
@@ -142,7 +173,7 @@ namespace MonoDevelop.Debugger.VsCodeDebugProtocol
 
 		protected override void OnNextInstruction ()
 		{
-			protocolClient.SendRequestSync (new NextRequest (currentThreadId));
+			protocolClient.SendRequestSync (new StepInRequest (currentThreadId));
 		}
 
 		protected override void OnNextLine ()
@@ -283,6 +314,39 @@ namespace MonoDevelop.Debugger.VsCodeDebugProtocol
 			return sb.ToString();
 		}
 
+		bool? EvaluateCondition (int frameId, string exp)
+		{
+			var response = protocolClient.SendRequestSync (new EvaluateRequest (exp, frameId)).Result;
+
+			if (bool.TryParse (response, out var result))
+				return result;
+
+			OnDebuggerOutput (false, $"The condition for an exception catchpoint failed to execute. The condition was '{exp}'. The error returned was '{response}'.\n");
+
+			return null;
+		}
+
+		bool ShouldStopOnExceptionCatchpoint (Catchpoint catchpoint, int frameId)
+		{
+			if (!catchpoint.Enabled)
+				return false;
+
+			// global:: is necessary if the exception type is contained in current namespace,
+			// and it also contains a class with the same name as the namespace itself.
+			// Example: "Tests.Tests" and "Tests.TestException"
+			var qualifiedExceptionType = catchpoint.ExceptionName.Contains ("::") ? catchpoint.ExceptionName : $"global::{catchpoint.ExceptionName}";
+
+			if (catchpoint.IncludeSubclasses) {
+				if (EvaluateCondition (frameId, $"$exception is {qualifiedExceptionType}") == false)
+					return false;
+			} else {
+				if (EvaluateCondition (frameId, $"$exception.GetType() == typeof({qualifiedExceptionType})") == false)
+					return false;
+			}
+
+			return string.IsNullOrWhiteSpace (catchpoint.ConditionExpression) || EvaluateCondition (frameId, catchpoint.ConditionExpression) != false;
+		}
+
 		protected void HandleEvent (object sender, EventReceivedEventArgs obj)
 		{
 			Task.Run (() => {
@@ -320,6 +384,30 @@ namespace MonoDevelop.Debugger.VsCodeDebugProtocol
 						args = new TargetEventArgs (TargetEventType.TargetStopped);
 						break;
 					case StoppedEvent.ReasonValue.Exception:
+						stackFrame = null;
+						var backtrace = GetThreadBacktrace (body.ThreadId ?? -1);
+						if (Options.ProjectAssembliesOnly) {
+							// We can't evaluate expressions in external code frames, the debugger will hang
+							for (int i = 0; i < backtrace.FrameCount; i++) {
+								var frame = stackFrame = (VsCodeStackFrame)backtrace.GetFrame (i);
+								if (!frame.IsExternalCode) {
+									stackFrame = frame;
+									break;
+								}
+							}
+							if (stackFrame == null) {
+								OnContinue ();
+								return;
+							}
+						} else {
+							// It's OK to evaluate expressions in external code
+							stackFrame = (VsCodeStackFrame)backtrace.GetFrame (0);
+						}
+
+						if (!breakpoints.Select (b => b.Key).OfType<Catchpoint> ().Any (c => ShouldStopOnExceptionCatchpoint (c, stackFrame.frameId))) {
+							OnContinue ();
+							return;
+						}
 						args = new TargetEventArgs (TargetEventType.ExceptionThrown);
 						break;
 					default:
diff --git a/main/src/addins/MonoDevelop.Debugger.VSCodeDebugProtocol/MonoDevelop.Debugger.VsCodeDebugProtocol/VsCodeBacktrace.cs b/main/src/addins/MonoDevelop.Debugger.VSCodeDebugProtocol/MonoDevelop.Debugger.VsCodeDebugProtocol/VsCodeBacktrace.cs
index 28344c4949..9a7c611876 100644
--- a/main/src/addins/MonoDevelop.Debugger.VSCodeDebugProtocol/MonoDevelop.Debugger.VsCodeDebugProtocol/VsCodeBacktrace.cs
+++ b/main/src/addins/MonoDevelop.Debugger.VSCodeDebugProtocol/MonoDevelop.Debugger.VsCodeDebugProtocol/VsCodeBacktrace.cs
@@ -1,9 +1,12 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
+using System.Collections.Generic;
+
 using Microsoft.VisualStudio.Shared.VSCodeDebugProtocol.Messages;
+
 using Mono.Debugging.Backend;
 using Mono.Debugging.Client;
+
 using VsFormat = Microsoft.VisualStudio.Shared.VSCodeDebugProtocol.Messages.StackFrameFormat;
 
 namespace MonoDevelop.Debugger.VsCodeDebugProtocol
diff --git a/main/src/addins/MonoDevelop.Debugger.VSCodeDebugProtocol/MonoDevelop.Debugger.VsCodeDebugProtocol/VsCodeObjectSource.cs b/main/src/addins/MonoDevelop.Debugger.VSCodeDebugProtocol/MonoDevelop.Debugger.VsCodeDebugProtocol/VsCodeObjectSource.cs
index d98418ec98..19c8c4fa77 100644
--- a/main/src/addins/MonoDevelop.Debugger.VSCodeDebugProtocol/MonoDevelop.Debugger.VsCodeDebugProtocol/VsCodeObjectSource.cs
+++ b/main/src/addins/MonoDevelop.Debugger.VSCodeDebugProtocol/MonoDevelop.Debugger.VsCodeDebugProtocol/VsCodeObjectSource.cs
@@ -1,45 +1,280 @@
 using System;
 using System.Linq;
+using System.Text;
+using System.Globalization;
+
 using Microsoft.VisualStudio.Shared.VSCodeDebugProtocol.Messages;
+
 using Mono.Debugging.Backend;
 using Mono.Debugging.Client;
+using Mono.Debugging.Evaluation;
 
 namespace MonoDevelop.Debugger.VsCodeDebugProtocol
 {
 	class VSCodeObjectSource : IObjectValueSource
 	{
+		const VariablePresentationHint.AttributesValue ConstantReadOnlyStatic = VariablePresentationHint.AttributesValue.Constant | VariablePresentationHint.AttributesValue.ReadOnly | VariablePresentationHint.AttributesValue.Static;
+		static readonly char[] CommaDotOrSquareEndBracket = { ',', '.', ']' };
+		static readonly char[] CommaOrSquareEndBracket = { ',', ']' };
+		static readonly char[] LessThanOrSquareBracket = { '<', '[' };
 
-		int parentVariablesReference;
-		int variablesReference;
-		int frameId;
-		VSCodeDebuggerSession vsCodeDebuggerSession;
-		ObjectValue [] objValChildren;
-		readonly string name;
+		ObjectValue[] objValChildren;
+
+		readonly VSCodeDebuggerSession vsCodeDebuggerSession;
+		readonly int parentVariablesReference;
+		readonly ObjectValueFlags flags;
+		readonly int variablesReference;
+		readonly int frameId;
 		readonly string evalName;
+		readonly string display;
+		readonly string name;
 		readonly string type;
 		readonly string val;
 
+		static string GetActualTypeName (string type)
+		{
+			int startIndex;
+
+			if (type == null)
+				return string.Empty;
+
+			if ((startIndex = type.IndexOf (" {", StringComparison.Ordinal)) != -1) {
+				// The type is boxed. The string between the {}'s is the actual type name.
+				int endIndex = type.LastIndexOf ('}');
+
+				startIndex += 2;
+
+				if (endIndex > startIndex)
+					return type.Substring (startIndex, endIndex - startIndex);
+			}
+
+			return type;
+		}
+
+		static string GetFixedVariableName (string name)
+		{
+			// Check for a type attribute and strip it off.
+			var index = name.LastIndexOf (" [", StringComparison.Ordinal);
+
+			if (index != -1)
+				return name.Remove (index);
+
+			return name;
+		}
+
+		static bool IsMultiDimensionalArray (string type, out int arrayIndexer)
+		{
+			int index = type.IndexOfAny (LessThanOrSquareBracket);
+
+			arrayIndexer = -1;
+
+			if (index == -1)
+				return false;
+
+			if (type[index] == '<') {
+				int depth = 1;
+
+				index++;
+				while (index < type.Length && depth > 0) {
+					switch (type[index++]) {
+					case '<': depth++; break;
+					case '>': depth--; break;
+					}
+				}
+
+				if (index >= type.Length || type[index] != '[')
+					return false;
+			}
+
+			arrayIndexer = index++;
+
+			return index < type.Length && type[index] == ',';
+		}
+
+		// Note: displayType will often have spaces after commas
+		string GetFixedValue (string value, string canonType, string displayType)
+		{
+			int arrayIndex;
+
+			if (IsMultiDimensionalArray (displayType, out arrayIndex)) {
+				var arrayType = displayType.Substring (0, arrayIndex);
+				var prefix = $"{{{arrayType}[";
+
+				if (value.StartsWith (prefix, StringComparison.Ordinal)) {
+					var compacted = new StringBuilder (prefix.Replace (", ", ","));
+					int index = prefix.Length;
+
+					while (index < value.Length) {
+						int endIndex = value.IndexOfAny (CommaDotOrSquareEndBracket, index);
+						string number;
+
+						if (endIndex == -1)
+							return value;
+
+						if (endIndex + 1 < value.Length && value[endIndex] == '.' && value[endIndex + 1] == '.') {
+							int min, max;
+
+							number = value.Substring (index, endIndex - index);
+
+							if (!int.TryParse (number, NumberStyles.Integer, CultureInfo.InvariantCulture, out min))
+								return value;
+
+							index = endIndex + 2;
+
+							if ((endIndex = value.IndexOfAny (CommaOrSquareEndBracket, index)) == -1)
+								return value;
+
+							number = value.Substring (index, endIndex - index);
+
+							if (!int.TryParse (number, NumberStyles.Integer, CultureInfo.InvariantCulture, out max))
+								return value;
+
+							compacted.Append (((max - min) + 1).ToString (CultureInfo.InvariantCulture));
+						} else {
+							compacted.Append (value, index, endIndex - index);
+						}
+
+						compacted.Append (value[endIndex]);
+						index = endIndex + 1;
+
+						if (value[endIndex] == ']')
+							break;
+
+						if (index < value.Length && value[index] == ' ')
+							index++;
+					}
+
+					compacted.Append ('}');
+
+					return compacted.ToString ();
+				}
+			} else if (canonType == "char") {
+				int startIndex = value.IndexOf ('\'');
+
+				if (startIndex != -1)
+					return value.Substring (startIndex);
+			} else {
+				var request = new EvaluateRequest ($"typeof ({displayType}).IsEnum") { FrameId = frameId };
+				var result = vsCodeDebuggerSession.protocolClient.SendRequestSync (request);
+
+				if (result.Result.Equals ("true", StringComparison.OrdinalIgnoreCase)) {
+					int endIndex = value.IndexOf (" | ", StringComparison.Ordinal);
+
+					if (endIndex != -1) {
+						// The value a bitwise-or'd set of enum values
+						var expanded = new StringBuilder ();
+						int index = 0;
+
+						while (index < value.Length) {
+							endIndex = value.IndexOf (" | ", index, StringComparison.Ordinal);
+							string enumValue;
+
+							if (endIndex != -1)
+								enumValue = value.Substring (index, endIndex - index);
+							else if (index > 0)
+								enumValue = value.Substring (index);
+							else
+								enumValue = value;
+
+							expanded.Append (canonType).Append ('.').Append (enumValue);
+
+							if (endIndex == -1)
+								break;
+
+							expanded.Append (" | ");
+							index = endIndex + 3;
+						}
+
+						return expanded.ToString ();
+					}
+
+					return canonType + "." + value;
+				}
+			}
+
+			return value;
+		}
+
+		static bool IsCSError (int code, string message, string value, out string newValue)
+		{
+			var prefix = string.Format (CultureInfo.InvariantCulture, "error CS{0:D4}: '", code);
+
+			newValue = null;
+
+			if (value == null || !value.StartsWith (prefix, StringComparison.Ordinal))
+				return false;
+
+			int startIndex = prefix.Length;
+			int index = startIndex;
+
+			while (index < value.Length && value[index] != '\'')
+				index++;
+
+			newValue = value.Substring (startIndex, index - startIndex);
+			index++;
+
+			if (index >= value.Length || value[index] != ' ')
+				return false;
+
+			index++;
+
+			if (index + message.Length != value.Length)
+				return false;
+
+			return string.CompareOrdinal (value, index, message, 0, message.Length) == 0;
+		}
 
 		public VSCodeObjectSource (VSCodeDebuggerSession vsCodeDebuggerSession, int variablesReference, int parentVariablesReference, string name, string type, string evalName, int frameId, string val)
 		{
-			this.type = type ?? string.Empty;
-			this.frameId = frameId;
-			this.evalName = evalName;
-			var indexOfType = name.LastIndexOf (" [", StringComparison.Ordinal);
-			if (indexOfType != -1)
-				name = name.Remove (indexOfType);
-			this.name = name;
 			this.vsCodeDebuggerSession = vsCodeDebuggerSession;
-			this.variablesReference = variablesReference;
 			this.parentVariablesReference = parentVariablesReference;
-			this.val = val;
+			this.variablesReference = variablesReference;
+			this.evalName = evalName;
+			this.frameId = frameId;
+
+			if (type == null) {
+				if (IsCSError (118, "is a namespace but is used like a variable", val, out string ns)) {
+					this.display = this.name = this.val = ns;
+					this.flags = ObjectValueFlags.Namespace;
+					this.type = "<namespace>";
+					return;
+				}
+
+				if (IsCSError (119, "is a type, which is not valid in the given context", val, out string vtype)) {
+					if (name.StartsWith ("global::", StringComparison.Ordinal))
+						vtype = name.Substring ("global::".Length);
+
+					this.display = this.name = this.val = ObjectValueAdaptor.GetCSharpTypeName (vtype);
+					this.flags = ObjectValueFlags.Type;
+					this.type = "<type>";
+					return;
+				}
+			}
+
+			var actualType = GetActualTypeName (type);
+
+			this.flags = parentVariablesReference > 0 ? ObjectValueFlags.None : ObjectValueFlags.ReadOnly;
+			this.type = actualType.Replace (", ", ",");
+			this.name = GetFixedVariableName (name);
+
+			if (actualType != "void")
+				this.val = GetFixedValue (val, this.type, actualType);
+			else
+				this.val = "No return value.";
+			this.display = val;
+
+			if (this.name[0] == '[')
+				flags |= ObjectValueFlags.ArrayElement;
+
+			if (type == null || val == $"'{this.name}' threw an exception of type '{this.type}'")
+				flags |= ObjectValueFlags.Error;
 		}
 
-		public ObjectValue [] GetChildren (ObjectPath path, int index, int count, EvaluationOptions options)
+		public ObjectValue[] GetChildren (ObjectPath path, int index, int count, EvaluationOptions options)
 		{
 			if (objValChildren == null) {
 				if (variablesReference <= 0) {
-					objValChildren = new ObjectValue [0];
+					objValChildren = new ObjectValue[0];
 				} else {
 					using (var timer = vsCodeDebuggerSession.EvaluationStats.StartTimer ()) {
 						var children = vsCodeDebuggerSession.protocolClient.SendRequestSync (new VariablesRequest (
@@ -82,27 +317,30 @@ namespace MonoDevelop.Debugger.VsCodeDebugProtocol
 
 		public object GetRawValue (ObjectPath path, EvaluationOptions options)
 		{
-			string val = null;
+			string rawValue = null;
+
 			using (var timer = vsCodeDebuggerSession.EvaluationStats.StartTimer ()) {
-				val = vsCodeDebuggerSession.protocolClient.SendRequestSync (new EvaluateRequest (evalName) { FrameId = frameId }).Result;
+				rawValue = vsCodeDebuggerSession.protocolClient.SendRequestSync (new EvaluateRequest (evalName) { FrameId = frameId }).Result;
 				timer.Success = true;
 			}
-			if (val.StartsWith ("\"", StringComparison.Ordinal))
+
+			if (rawValue.StartsWith ("\"", StringComparison.Ordinal)) {
 				if (options.ChunkRawStrings)
-					return new RawValueString (new RawString (val));
-				else
-					return val.Remove (val.Length - 1).Remove (0, 1);
-			else
-				throw new NotImplementedException ();
+					return new RawValueString (new RawString (rawValue));
+
+				return rawValue.Substring (1, rawValue.Length - 2);
+			}
+
+			throw new NotImplementedException ();
 		}
 
 		public ObjectValue GetValue (ObjectPath path, EvaluationOptions options)
 		{
 			if (val == "null")
-				return ObjectValue.CreateNullObject (this, name, type, parentVariablesReference > 0 ? ObjectValueFlags.None : ObjectValueFlags.ReadOnly);
+				return ObjectValue.CreateNullObject (this, name, type, flags);
 			if (variablesReference == 0)//This is some kind of primitive...
-				return ObjectValue.CreatePrimitive (this, new ObjectPath (name), type, new EvaluationResult (val), parentVariablesReference > 0 ? ObjectValueFlags.None : ObjectValueFlags.ReadOnly);
-			return ObjectValue.CreateObject (this, new ObjectPath (name), type, new EvaluationResult (val), parentVariablesReference > 0 ? ObjectValueFlags.None : ObjectValueFlags.ReadOnly, null);
+				return ObjectValue.CreatePrimitive (this, new ObjectPath (name), type, new EvaluationResult (val, display), flags);
+			return ObjectValue.CreateObject (this, new ObjectPath (name), type, new EvaluationResult (val, display), flags, null);
 		}
 
 		public void SetRawValue (ObjectPath path, object value, EvaluationOptions options)
diff --git a/main/src/addins/MonoDevelop.Debugger.VSCodeDebugProtocol/MonoDevelop.Debugger.VsCodeDebugProtocol/VsCodeStackFrame.cs b/main/src/addins/MonoDevelop.Debugger.VSCodeDebugProtocol/MonoDevelop.Debugger.VsCodeDebugProtocol/VsCodeStackFrame.cs
index 833ab92c89..09930da9ee 100644
--- a/main/src/addins/MonoDevelop.Debugger.VSCodeDebugProtocol/MonoDevelop.Debugger.VsCodeDebugProtocol/VsCodeStackFrame.cs
+++ b/main/src/addins/MonoDevelop.Debugger.VSCodeDebugProtocol/MonoDevelop.Debugger.VsCodeDebugProtocol/VsCodeStackFrame.cs
@@ -1,7 +1,11 @@
 using System;
 using System.Linq;
+
 using Microsoft.VisualStudio.Shared.VSCodeDebugProtocol.Messages;
+
 using Mono.Debugging.Client;
+
+using VsStackFrame = Microsoft.VisualStudio.Shared.VSCodeDebugProtocol.Messages.StackFrame;
 using VsFormat = Microsoft.VisualStudio.Shared.VSCodeDebugProtocol.Messages.StackFrameFormat;
 
 namespace MonoDevelop.Debugger.VsCodeDebugProtocol
@@ -33,14 +37,19 @@ namespace MonoDevelop.Debugger.VsCodeDebugProtocol
 			return null;
 		}
 
+		static SourceLocation GetSourceLocation (VsStackFrame frame)
+		{
+			return new SourceLocation (frame.Name, frame.Source?.Path, frame.Line, frame.Column, frame.EndLine ?? -1, frame.EndColumn ?? -1, GetHashBytes (frame.Source));
+		}
+
 		VsFormat format;
 		readonly int threadId;
 		readonly int frameIndex;
 		internal readonly int frameId;
 		string fullStackframeText;
 
-		public VsCodeStackFrame (VsFormat format, int threadId, int frameIndex, Microsoft.VisualStudio.Shared.VSCodeDebugProtocol.Messages.StackFrame frame)
-			: base (0, new SourceLocation (frame.Name, frame.Source?.Path, frame.Line, frame.Column, frame.EndLine ?? -1, frame.EndColumn ?? -1, GetHashBytes (frame.Source)), GetLanguage (frame.Source?.Path))
+		public VsCodeStackFrame (VsFormat format, int threadId, int frameIndex, VsStackFrame frame)
+			: base (0, GetSourceLocation (frame), GetLanguage (frame.Source?.Path))
 		{
 			this.format = format;
 			this.threadId = threadId;
diff --git a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.Tests/DebugTests.MonoDevelop.cs b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.Tests/DebugTests.MonoDevelop.cs
index 5e9a098fd6..0bafdcd00f 100644
--- a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.Tests/DebugTests.MonoDevelop.cs
+++ b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.Tests/DebugTests.MonoDevelop.cs
@@ -1,142 +1,155 @@
-using System;

-using System.IO;

-using System.Linq;

-using Mono.Debugging.Client;

-using MonoDevelop.Core;

-using MonoDevelop.Core.Assemblies;

-using MonoDevelop.Core.Execution;

-using MonoDevelop.Debugger;

-using NUnit.Framework;

-

-using MDTextFile = MonoDevelop.Projects.Text.TextFile;

-using System.Diagnostics;

-

-namespace Mono.Debugging.Tests

-{

-	public abstract partial class DebugTests

-	{

-		DebuggerEngine engine;

-		TargetRuntime runtime;

-

-		static bool testProjectReady;

-

-		partial void SetUpPartial()

-		{

-			foreach (var e in DebuggingService.GetDebuggerEngines ()) {

-				if (e.Id == EngineId) {

-					engine = e;

-					break;

-				}

-			}

-			if (engine == null)

-				Assert.Ignore ("Engine not found: {0}", EngineId);

-

-			if (!testProjectReady) {

-				testProjectReady = true;

-				var packagesConfig = Path.Combine (TargetProjectSourceDir, "packages.config");

-				var packagesDir = Path.Combine (TargetProjectSourceDir, "packages");

-				Process.Start ("nuget", $"restore \"{packagesConfig}\" -PackagesDirectory \"{packagesDir}\"").WaitForExit ();

-				Process.Start ("msbuild", "\"" + TargetProjectSourceDir + "\"").WaitForExit ();

-			}

-		}

-

-		partial void TearDownPartial ()

-		{

-		}

-

-		protected string TargetExeDirectory

-		{

-			get {

-				FilePath path = TargetProjectSourceDir;

-				return path.Combine ("bin", "Debug");

-			}

-		}

-

-		protected string TargetProjectSourceDir

-		{

-			get {

-				FilePath path = Path.GetDirectoryName (GetType ().Assembly.Location);

-				return path.Combine ("DebuggerTestProjects", TestAppProjectDirName);

-			}

-		}

-

-		protected DebuggerSession CreateSession (string test, string engineId)

-		{

-			switch (engineId) {

-				case "MonoDevelop.Debugger.Win32":

-					runtime = Runtime.SystemAssemblyService.GetTargetRuntime ("MS.NET");

-					break;

-				case "Mono.Debugger.Soft":

-					runtime = Runtime.SystemAssemblyService.GetTargetRuntimes ()

-						.OfType<MonoTargetRuntime> ()

-						.OrderByDescending ((o) => {

-							//Attempt to find latest version of Mono registred in IDE and use that for unit tests

-							if (string.IsNullOrWhiteSpace (o.Version) || o.Version == "Unknown")

-								return new Version (0, 0, 0, 0);

-							int indexOfBeforeDetails = o.Version.IndexOf (" (", StringComparison.Ordinal);

-							string hopefullyVersion;

+using System;
+using System.IO;
+using System.Linq;
+using System.Diagnostics;
+
+using Mono.Debugging.Client;
+using MonoDevelop.Core;
+using MonoDevelop.Core.Assemblies;
+using MonoDevelop.Core.Execution;
+using MonoDevelop.Debugger;
+
+using NUnit.Framework;
+
+using MDTextFile = MonoDevelop.Projects.Text.TextFile;
+
+namespace Mono.Debugging.Tests
+{
+	public abstract partial class DebugTests
+	{
+		static bool testProjectReady;
+
+		DebuggerEngine engine;
+		TargetRuntime runtime;
+
+		protected virtual string TestAppProjectDirName {
+			get { return "MonoDevelop.Debugger.Tests.TestApp"; }
+		}
+
+		protected virtual string TestAppExeName {
+			get { return TestAppProjectDirName + ".exe"; }
+		}
+
+		partial void SetUpPartial ()
+		{
+			engine = DebuggingService.GetDebuggerEngines ().FirstOrDefault (e => e.Id == EngineId);
+
+			if (engine == null)
+				Assert.Ignore ("Engine not found: {0}", EngineId);
+
+			if (!testProjectReady) {
+				testProjectReady = true;
+				var packagesConfig = Path.Combine (TargetProjectSourceDir, "packages.config");
+				var packagesDir = Path.Combine (TargetProjectSourceDir, "packages");
+
+				if (File.Exists (packagesConfig)) {
+					Process.Start ("nuget", $"restore \"{packagesConfig}\" -PackagesDirectory \"{packagesDir}\"").WaitForExit ();
+				} else {
+					var projFile = Path.Combine (TargetProjectSourceDir, TestAppProjectDirName + ".csproj");
+
+					Process.Start ("nuget", $"restore \"{projFile}\" -PackagesDirectory \"{packagesDir}\"").WaitForExit ();
+				}
+
+				Process.Start ("msbuild", "\"" + TargetProjectSourceDir + "\"").WaitForExit ();
+			}
+		}
+
+		partial void TearDownPartial ()
+		{
+		}
+
+		protected string TargetExeDirectory {
+			get {
+				return Path.Combine (TargetProjectSourceDir, "bin", "Debug");
+			}
+		}
+
+		protected string TargetProjectSourceDir {
+			get {
+				var path = Path.GetDirectoryName (GetType ().Assembly.Location);
+
+				return Path.Combine (path, "DebuggerTestProjects", TestAppProjectDirName);
+			}
+		}
+
+		protected virtual DebuggerSession CreateSession (string test, string engineId)
+		{
+			switch (engineId) {
+				case "MonoDevelop.Debugger.Win32":
+					runtime = Runtime.SystemAssemblyService.GetTargetRuntime ("MS.NET");
+					break;
+				case "Mono.Debugger.Soft":
+					runtime = Runtime.SystemAssemblyService.GetTargetRuntimes ()
+						.OfType<MonoTargetRuntime> ()
+						.OrderByDescending ((o) => {
+							//Attempt to find latest version of Mono registred in IDE and use that for unit tests
+							if (string.IsNullOrWhiteSpace (o.Version) || o.Version == "Unknown")
+								return new Version (0, 0, 0, 0);
+
+							int indexOfBeforeDetails = o.Version.IndexOf (" (", StringComparison.Ordinal);
+
+							string hopefullyVersion;
 							if (indexOfBeforeDetails != -1)
 								hopefullyVersion = o.Version.Remove (indexOfBeforeDetails);
 							else
 								hopefullyVersion = o.Version;
-							Version version;

-							if (Version.TryParse (hopefullyVersion, out version)) {

-								return version;

-							} else {

-								return new Version (0, 0, 0, 0);

-							}

-						}).FirstOrDefault ();

-					break;

-				default:

-					runtime = Runtime.SystemAssemblyService.DefaultRuntime;

-					break;

-			}

-

-			if (runtime == null) {

-				Assert.Ignore ("Runtime not found for: {0}", engineId);

-			}

-

-			Console.WriteLine ("Target Runtime: " + runtime.DisplayRuntimeName + " " + runtime.Version + " " + (IntPtr.Size == 8 ? "64bit" : "32bit"));

-

-			// main/build/tests

-			var exe = TargetExePath;

-

-			var cmd = new DotNetExecutionCommand ();

-			cmd.TargetRuntime = runtime;

-			cmd.Command = exe;

-			cmd.Arguments = test;

-

-			if (Platform.IsWindows) {

-				var monoRuntime = runtime as MonoTargetRuntime;

-				if (monoRuntime != null) {

-					var psi = new System.Diagnostics.ProcessStartInfo (Path.Combine (monoRuntime.Prefix, "bin", "pdb2mdb.bat"), exe);

-					psi.UseShellExecute = false;

-					psi.CreateNoWindow = true;

-					System.Diagnostics.Process.Start (psi).WaitForExit ();

-				}

-			}

-			return engine.CreateSession ();

-		}

-

-		protected DebuggerStartInfo CreateStartInfo (string test, string engineId)

-		{

-			var cmd = new DotNetExecutionCommand {

-				TargetRuntime = runtime,

-				Command = TargetExePath,

-				Arguments = test

-			};

-			var dsi = engine.CreateDebuggerStartInfo (cmd);

-			return dsi;

-		}

-

-		/// <summary>

-		/// Reads file from given path

-		/// </summary>

-		/// <param name="sourcePath"></param>

-		/// <returns></returns>

-		public static ITextFile ReadFile (string sourcePath)

-		{

-			return new TextFile(MDTextFile.ReadFile (sourcePath));

-		}

-	}

-}
\ No newline at end of file
+
+							if (Version.TryParse (hopefullyVersion, out var version))
+								return version;
+
+							return new Version (0, 0, 0, 0);
+						}).FirstOrDefault ();
+					break;
+				default:
+					runtime = Runtime.SystemAssemblyService.DefaultRuntime;
+					break;
+			}
+
+			if (runtime == null)
+				Assert.Ignore ("Runtime not found for: {0}", engineId);
+
+			Console.WriteLine ("Target Runtime: " + runtime.DisplayRuntimeName + " " + runtime.Version + " " + (IntPtr.Size == 8 ? "64bit" : "32bit"));
+
+			// main/build/tests
+			var exe = TargetExePath;
+
+			var cmd = new DotNetExecutionCommand ();
+			cmd.TargetRuntime = runtime;
+			cmd.Command = exe;
+			cmd.Arguments = test;
+
+			if (Platform.IsWindows) {
+				var monoRuntime = runtime as MonoTargetRuntime;
+				if (monoRuntime != null) {
+					var psi = new ProcessStartInfo (Path.Combine (monoRuntime.Prefix, "bin", "pdb2mdb.bat"), exe);
+					psi.UseShellExecute = false;
+					psi.CreateNoWindow = true;
+					Process.Start (psi).WaitForExit ();
+				}
+			}
+
+			return engine.CreateSession ();
+		}
+
+		protected DebuggerStartInfo CreateStartInfo (string test, string engineId)
+		{
+			var cmd = new DotNetExecutionCommand {
+				TargetRuntime = runtime,
+				Command = TargetExePath,
+				Arguments = test
+			};
+			var dsi = engine.CreateDebuggerStartInfo (cmd);
+			return dsi;
+		}
+
+		/// <summary>
+		/// Reads file from given path
+		/// </summary>
+		/// <param name="sourcePath"></param>
+		/// <returns></returns>
+		public static ITextFile ReadFile (string sourcePath)
+		{
+			return new TextFile (MDTextFile.ReadFile (sourcePath));
+		}
+	}
+}
diff --git a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.Tests/MonoDevelop.Debugger.Tests.csproj b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.Tests/MonoDevelop.Debugger.Tests.csproj
index d25737367e..66a368f365 100644
--- a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.Tests/MonoDevelop.Debugger.Tests.csproj
+++ b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.Tests/MonoDevelop.Debugger.Tests.csproj
@@ -17,6 +17,8 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="..\..\..\..\external\debugger-libs\UnitTests\Mono.Debugging.Tests\Shared\*.cs" />
+    <Compile Include="..\..\..\..\external\debugger-libs\UnitTests\Mono.Debugging.Tests\Shared\Sdb\*.cs" />
+    <Compile Include="..\..\..\..\external\debugger-libs\UnitTests\Mono.Debugging.Tests\Shared\Win32\*.cs" />
     <Compile Include="DebugTests.MonoDevelop.cs" />
     <Compile Include="TextFile.cs" />
   </ItemGroup>
diff --git a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.VSTextView/BreakpointManager.cs b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.VSTextView/BreakpointManager.cs
index 44991e0ccb..f3f690e450 100644
--- a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.VSTextView/BreakpointManager.cs
+++ b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.VSTextView/BreakpointManager.cs
@@ -10,22 +10,30 @@ namespace MonoDevelop.Debugger
 	class BreakpointManager
 	{
 		private ITextBuffer textBuffer;
-		private readonly string file;
+		private readonly ITextDocument textDocument;
 
 		public BreakpointManager (ITextBuffer textBuffer)
 		{
 			this.textBuffer = textBuffer;
-			file = textBuffer.GetFilePathOrNull ();
-			if (file == null) {
+			if (textBuffer.Properties.TryGetProperty (typeof (ITextDocument), out textDocument) && textDocument.FilePath != null) {
+				textDocument.FileActionOccurred += TextDocument_FileActionOccurred;
+			} else {
 				LoggingService.LogWarning ("Failed to get filename of textbuffer, breakpoints integration will not work.");
 				return;
 			}
 			textBuffer.Changed += TextBuffer_Changed;
 			DebuggingService.Breakpoints.Changed += OnBreakpointsChanged;
 			DebuggingService.Breakpoints.BreakpointStatusChanged += OnBreakpointsChanged;
+			DebuggingService.Breakpoints.BreakpointModified += OnBreakpointsChanged;
 			OnBreakpointsChanged (null, null);
 		}
 
+		private void TextDocument_FileActionOccurred (object sender, TextDocumentFileActionEventArgs e)
+		{
+			if (e.FileActionType == FileActionTypes.DocumentRenamed)
+				OnBreakpointsChanged (null, null);
+		}
+
 		void TextBuffer_Changed (object sender, TextContentChangedEventArgs e)
 		{
 			foreach (var breakpoint in breakpoints.Values) {
@@ -55,7 +63,7 @@ namespace MonoDevelop.Debugger
 			var snapshot = textBuffer.CurrentSnapshot;
 			var newBreakpoints = new Dictionary<Breakpoint, ManagerBreakpoint> ();
 			bool needsUpdate = false;
-			foreach (var breakpoint in DebuggingService.Breakpoints.GetBreakpointsAtFile (file)) {
+			foreach (var breakpoint in DebuggingService.Breakpoints.GetBreakpointsAtFile (textDocument.FilePath)) {
 				if (breakpoint.Line > snapshot.LineCount)
 					continue;
 				if (eventArgs is BreakpointEventArgs breakpointEventArgs && breakpointEventArgs.Breakpoint == breakpoint)
@@ -93,6 +101,9 @@ namespace MonoDevelop.Debugger
 			textBuffer.Changed -= TextBuffer_Changed;
 			DebuggingService.Breakpoints.Changed -= OnBreakpointsChanged;
 			DebuggingService.Breakpoints.BreakpointStatusChanged -= OnBreakpointsChanged;
+			DebuggingService.Breakpoints.BreakpointModified -= OnBreakpointsChanged;
+			if (textDocument != null)
+				textDocument.FileActionOccurred -= TextDocument_FileActionOccurred;
 		}
 
 		public IEnumerable<BreakpointSpan> GetBreakpoints (ITextSnapshot snapshot)
diff --git a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.VSTextView/QuickInfo/DebuggerQuickInfoSource.cs b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.VSTextView/QuickInfo/DebuggerQuickInfoSource.cs
index fb9f3f915a..0405f60bdf 100644
--- a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.VSTextView/QuickInfo/DebuggerQuickInfoSource.cs
+++ b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.VSTextView/QuickInfo/DebuggerQuickInfoSource.cs
@@ -6,6 +6,7 @@ using Microsoft.VisualStudio.Text;
 using MonoDevelop.Core;
 using Microsoft.VisualStudio.Text.Editor;
 using Gtk;
+using MonoDevelop.Ide.Gui.Documents;
 
 namespace MonoDevelop.Debugger.VSTextView.QuickInfo
 {
@@ -15,6 +16,7 @@ namespace MonoDevelop.Debugger.VSTextView.QuickInfo
 		readonly ITextBuffer textBuffer;
 		DebugValueWindow window;
 		ITextView lastView;
+		DocumentView lastDocumentView;
 
 		public DebuggerQuickInfoSource (DebuggerQuickInfoSourceProvider provider, ITextBuffer textBuffer)
 		{
@@ -28,8 +30,7 @@ namespace MonoDevelop.Debugger.VSTextView.QuickInfo
 		void CurrentFrameChanged (object sender, EventArgs e)
 		{
 			if (window != null) {
-				window.Destroy ();
-				window = null;
+				DestroyWindow ();
 			}
 		}
 
@@ -39,8 +40,7 @@ namespace MonoDevelop.Debugger.VSTextView.QuickInfo
 				return;
 			var debuggerSession = window.Tree.Frame?.DebuggerSession;
 			if (debuggerSession == null || debuggerSession == sender) {
-				window.Destroy ();
-				window = null;
+				DestroyWindow ();
 			}
 		}
 
@@ -121,6 +121,10 @@ namespace MonoDevelop.Debugger.VSTextView.QuickInfo
 				Ide.IdeApp.CommandService.RegisterTopWindow (window);
 				var bounds = view.TextViewLines.GetCharacterBounds (point);
 				view.LayoutChanged += LayoutChanged;
+#if CLOSE_ON_FOCUS_LOST
+				view.LostAggregateFocus += View_LostAggregateFocus;
+#endif
+				RegisterForHiddenAsync (view).Ignore ();
 				window.LeaveNotifyEvent += LeaveNotifyEvent;
 #if MAC
 				var cocoaView = ((ICocoaTextView)view);
@@ -135,6 +139,31 @@ namespace MonoDevelop.Debugger.VSTextView.QuickInfo
 			return null;
 		}
 
+		private async Task RegisterForHiddenAsync (ITextView view)
+		{
+			if (view.Properties.TryGetProperty<FileDocumentController> (typeof (DocumentController), out var documentController)) {
+				lastDocumentView = await documentController.GetDocumentView ();
+				lastDocumentView.ContentHidden += DocumentView_ContentHidden;
+			}
+		}
+
+		private void DocumentView_ContentHidden (object sender, EventArgs e)
+		{
+			DestroyWindow ();
+		}
+#if CLOSE_ON_FOCUS_LOST
+		private void View_LostAggregateFocus (object sender, EventArgs e)
+		{
+#if MAC
+			var nsWindow = MacInterop.GtkQuartz.GetWindow (window);
+			if (nsWindow == AppKit.NSApplication.SharedApplication.KeyWindow)
+				return;
+			DestroyWindow ();
+#else
+			throw new NotImplementedException ();
+#endif
+		}
+#endif
 		private void LayoutChanged (object sender, TextViewLayoutChangedEventArgs e)
 		{
 			if (e.OldViewState.ViewportLeft != e.NewViewState.ViewportLeft ||
@@ -161,8 +190,15 @@ namespace MonoDevelop.Debugger.VSTextView.QuickInfo
 			}
 			if (lastView != null) {
 				lastView.LayoutChanged -= LayoutChanged;
+#if CLOSE_ON_FOCUS_LOST
+				lastView.LostAggregateFocus -= View_LostAggregateFocus;
+#endif
 				lastView = null;
 			}
+			if (lastDocumentView != null) {
+				lastDocumentView.ContentHidden -= DocumentView_ContentHidden;
+				lastDocumentView = null;
+			}
 		}
 	}
 }
diff --git a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.VSTextView/Tags/AbstractCurrentStatementTagger.cs b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.VSTextView/Tags/AbstractCurrentStatementTagger.cs
index db3cc43c7c..800c7590fc 100644
--- a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.VSTextView/Tags/AbstractCurrentStatementTagger.cs
+++ b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.VSTextView/Tags/AbstractCurrentStatementTagger.cs
@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using Microsoft.VisualStudio.Text;

 using Microsoft.VisualStudio.Text.Tagging;

 using MonoDevelop.Debugger;

-using MonoDevelop.Ide.Editor;

 using MonoDevelop.Ide;

 using Mono.Debugging.Client;
 using MonoDevelop.Core;
@@ -15,7 +14,7 @@ namespace MonoDevelop.Debugger
 	{
 		private readonly ITextBuffer textBuffer;
 		private readonly T tag;
-		private readonly string filePath;
+		private readonly ITextDocument textDocument;
 		private readonly bool isGreen;
 		private ITextSnapshot snapshotAtStartOfDebugging;
 
@@ -23,7 +22,7 @@ namespace MonoDevelop.Debugger
 		{
 			this.textBuffer = textBuffer;
 			this.snapshotAtStartOfDebugging = textBuffer.CurrentSnapshot;
-			this.filePath = textBuffer.GetFilePathOrNull ();
+			textBuffer.Properties.TryGetProperty (typeof (ITextDocument), out textDocument);
 			this.tag = tag;
 			this.isGreen = isGreen;

 			DebuggingService.CurrentFrameChanged += OnDebuggerCurrentStatementChanged;

@@ -68,8 +67,8 @@ namespace MonoDevelop.Debugger
 
 		SourceLocation CheckLocationIsInFile (SourceLocation location)

 		{

-			if (!string.IsNullOrEmpty (filePath) && location != null && !string.IsNullOrEmpty (location.FileName)

-				&& ((FilePath)location.FileName).FullPath == ((FilePath)filePath).FullPath)

+			if (!string.IsNullOrEmpty (textDocument?.FilePath) && location != null && !string.IsNullOrEmpty (location.FileName)

+				&& ((FilePath)location.FileName).FullPath == ((FilePath)textDocument.FilePath).FullPath)

 				return location;

 			return null;

 		}

diff --git a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.csproj b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.csproj
index abd7d5b2c8..12b7e203fb 100644
--- a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.csproj
+++ b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger.csproj
@@ -66,6 +66,11 @@
       <Name>Mono.Debugging</Name>
       <Private>False</Private>
     </ProjectReference>
+    <ProjectReference Include="..\MacPlatform\MacPlatform.csproj" Condition="$(HaveXamarinMac) == 'true'">
+      <Project>{50D6768C-C072-4E79-AFC5-C1C40767EF45}</Project>
+      <Name>MacPlatform</Name>
+      <Private>False</Private>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AssemblyInfo.cs" />
diff --git a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger/DebugCommands.cs b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger/DebugCommands.cs
index 809cad7646..c864b6ff54 100644
--- a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger/DebugCommands.cs
+++ b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger/DebugCommands.cs
@@ -336,7 +336,7 @@ namespace MonoDevelop.Debugger
 			var breakpoints = DebuggingService.Breakpoints;
 			Breakpoint bp;
 
-			var textView = IdeApp.Workbench.ActiveDocument.GetContent<ITextView> ();
+			var textView = IdeApp.Workbench.ActiveDocument.GetContent<ITextView> (true);
 			var (caretLine, caretColumn) = textView.MDCaretLineAndColumn ();
 			var point = textView.Caret.Position.BufferPosition;
 
@@ -354,7 +354,7 @@ namespace MonoDevelop.Debugger
 		{
 			info.Visible = DebuggingService.IsFeatureSupported (DebuggerFeatures.Breakpoints);
 			info.Enabled = IdeApp.Workbench.ActiveDocument != null &&
-					IdeApp.Workbench.ActiveDocument.GetContent<ITextView> () != null &&
+					IdeApp.Workbench.ActiveDocument.GetContent<ITextView> (true) != null &&
 					IdeApp.Workbench.ActiveDocument.FileName != FilePath.Null &&
 					!DebuggingService.Breakpoints.IsReadOnly;
 		}
@@ -367,7 +367,7 @@ namespace MonoDevelop.Debugger
 			var breakpoints = DebuggingService.Breakpoints;
 
 			lock (breakpoints) {
-				foreach (var bp in breakpoints.GetBreakpointsAtFileLine (IdeApp.Workbench.ActiveDocument.FileName, IdeApp.Workbench.ActiveDocument.GetContent<ITextView> ().MDCaretLine ()))
+				foreach (var bp in breakpoints.GetBreakpointsAtFileLine (IdeApp.Workbench.ActiveDocument.FileName, IdeApp.Workbench.ActiveDocument.GetContent<ITextView> (true).MDCaretLine ()))
 					bp.Enabled = !bp.Enabled;
 			}
 		}
@@ -378,11 +378,11 @@ namespace MonoDevelop.Debugger
 
 			info.Visible = DebuggingService.IsFeatureSupported (DebuggerFeatures.Breakpoints);
 			if (IdeApp.Workbench.ActiveDocument != null && 
-			    IdeApp.Workbench.ActiveDocument.GetContent<ITextView> () != null &&
+			    IdeApp.Workbench.ActiveDocument.GetContent<ITextView> (true) != null &&
 			    IdeApp.Workbench.ActiveDocument.FileName != FilePath.Null &&
 			    !breakpoints.IsReadOnly) {
 				lock (breakpoints) {
-					var bpInLine = breakpoints.GetBreakpointsAtFileLine (IdeApp.Workbench.ActiveDocument.FileName, IdeApp.Workbench.ActiveDocument.GetContent<ITextView> ().MDCaretLine());
+					var bpInLine = breakpoints.GetBreakpointsAtFileLine (IdeApp.Workbench.ActiveDocument.FileName, IdeApp.Workbench.ActiveDocument.GetContent<ITextView> (true).MDCaretLine());
 					info.Enabled = bpInLine.Count > 0;
 					info.Text = GettextCatalog.GetString ("Disable Breakpoint");
 					foreach (var bp in bpInLine) {
@@ -463,7 +463,7 @@ namespace MonoDevelop.Debugger
 			lock (breakpoints) {
 				IEnumerable<Breakpoint> brs = breakpoints.GetBreakpointsAtFileLine (
 					IdeApp.Workbench.ActiveDocument.FileName,
-					IdeApp.Workbench.ActiveDocument.GetContent<ITextView> ().MDCaretLine ());
+					IdeApp.Workbench.ActiveDocument.GetContent<ITextView> (true).MDCaretLine ());
 
 				List<Breakpoint> list = new List<Breakpoint> (brs);
 				foreach (Breakpoint bp in list)
@@ -477,11 +477,11 @@ namespace MonoDevelop.Debugger
 
 			info.Visible = DebuggingService.IsFeatureSupported (DebuggerFeatures.Breakpoints);
 			if (IdeApp.Workbench.ActiveDocument != null && 
-			    IdeApp.Workbench.ActiveDocument.GetContent<ITextView> () != null &&
+			    IdeApp.Workbench.ActiveDocument.GetContent<ITextView> (true) != null &&
 			    IdeApp.Workbench.ActiveDocument.FileName != FilePath.Null &&
 			    !breakpoints.IsReadOnly) {
 				lock (breakpoints)
-					info.Enabled = breakpoints.GetBreakpointsAtFileLine (IdeApp.Workbench.ActiveDocument.FileName, IdeApp.Workbench.ActiveDocument.GetContent<ITextView> ().MDCaretLine ()).Count > 0;
+					info.Enabled = breakpoints.GetBreakpointsAtFileLine (IdeApp.Workbench.ActiveDocument.FileName, IdeApp.Workbench.ActiveDocument.GetContent<ITextView> (true).MDCaretLine ()).Count > 0;
 			} else {
 				info.Enabled = false;
 			}
@@ -552,8 +552,8 @@ namespace MonoDevelop.Debugger
 	{
 		protected override void Run ()
 		{
-			if (!IdeApp.Workbench.RootWindow.Visible) {
-				IdeApp.Workbench.RootWindow.Show ();
+			if (!IdeApp.Workbench.Visible) {
+				IdeApp.Workbench.Show ();
 			}
 			var breakpointsPad = IdeApp.Workbench.Pads.FirstOrDefault (p => p.Id == "MonoDevelop.Debugger.BreakpointPad");
 			if (breakpointsPad != null) {
@@ -572,7 +572,7 @@ namespace MonoDevelop.Debugger
 		protected override void Run ()
 		{
 			var doc = IdeApp.Workbench.ActiveDocument;
-			var textView = doc.GetContent<ITextView> ();
+			var textView = doc.GetContent<ITextView> (true);
 			var (caretLine, caretColumn) = textView.MDCaretLineAndColumn ();
 			if (DebuggingService.IsPaused) {
 				DebuggingService.RunToCursor (doc.FileName, caretLine, caretColumn);
@@ -599,7 +599,7 @@ namespace MonoDevelop.Debugger
 
 			var doc = IdeApp.Workbench.ActiveDocument;
 
-			if (doc?.GetContent<ITextView> () != null && doc.FileName != FilePath.Null) {
+			if (doc?.GetContent<ITextView> (true) != null && doc.FileName != FilePath.Null) {
 				var target = DebugHandler.GetRunTarget ();
 				if (target != null && IdeApp.ProjectOperations.CanDebug (target)) {
 					info.Enabled = true;
@@ -620,7 +620,7 @@ namespace MonoDevelop.Debugger
 			lock (breakpoints) {
 				brs = breakpoints.GetBreakpointsAtFileLine (
 					IdeApp.Workbench.ActiveDocument.FileName,
-					IdeApp.Workbench.ActiveDocument.GetContent<ITextView> ().MDCaretLine ());
+					IdeApp.Workbench.ActiveDocument.GetContent<ITextView> (true).MDCaretLine ());
 			}
 
 			if (brs.Count > 0) {
@@ -635,11 +635,11 @@ namespace MonoDevelop.Debugger
 
 			info.Visible = DebuggingService.IsFeatureSupported (DebuggerFeatures.Breakpoints);
 			if (IdeApp.Workbench.ActiveDocument != null && 
-			    IdeApp.Workbench.ActiveDocument.GetContent<ITextView> () != null &&
+			    IdeApp.Workbench.ActiveDocument.GetContent<ITextView> (true) != null &&
 			    IdeApp.Workbench.ActiveDocument.FileName != FilePath.Null &&
 			    !breakpoints.IsReadOnly) {
 				lock (breakpoints)
-					info.Enabled = breakpoints.GetBreakpointsAtFileLine (IdeApp.Workbench.ActiveDocument.FileName, IdeApp.Workbench.ActiveDocument.GetContent<ITextView> ().MDCaretLine ()).Count > 0;
+					info.Enabled = breakpoints.GetBreakpointsAtFileLine (IdeApp.Workbench.ActiveDocument.FileName, IdeApp.Workbench.ActiveDocument.GetContent<ITextView> (true).MDCaretLine ()).Count > 0;
 			} else {
 				info.Enabled = false;
 			}
@@ -650,7 +650,7 @@ namespace MonoDevelop.Debugger
 	{
 		protected override void Run ()
 		{
-			var textView = IdeApp.Workbench.ActiveDocument.GetContent<ITextView> ();
+			var textView = IdeApp.Workbench.ActiveDocument.GetContent<ITextView> (true);
 			if (textView != null) {
 				var viewPrimitives = MonoDevelop.Ide.Composition.CompositionManager.GetExport<IEditorPrimitivesFactoryService> ().Value.GetViewPrimitives (textView);
 				var selectedText = viewPrimitives.Selection.GetText ();
@@ -711,7 +711,7 @@ namespace MonoDevelop.Debugger
 		{
 			var doc = IdeApp.Workbench.ActiveDocument;
 
-			if (doc != null && doc.FileName != FilePath.Null && doc.GetContent<ITextView> () != null && DebuggingService.IsDebuggingSupported) {
+			if (doc != null && doc.FileName != FilePath.Null && doc.GetContent<ITextView> (true) != null && DebuggingService.IsDebuggingSupported) {
 				info.Enabled = DebuggingService.IsPaused && DebuggingService.DebuggerSession.CanSetNextStatement;
 				info.Visible = DebuggingService.IsPaused;
 			} else {
@@ -725,7 +725,7 @@ namespace MonoDevelop.Debugger
 			var doc = IdeApp.Workbench.ActiveDocument;
 
 			try {
-				var (caretLine, caretColumn) = doc.GetContent<ITextView> ().MDCaretLineAndColumn ();
+				var (caretLine, caretColumn) = doc.GetContent<ITextView> (true).MDCaretLineAndColumn ();
 				DebuggingService.SetNextStatement (doc.FileName, caretLine, caretColumn);
 			} catch (Exception e) {
 				if (e is NotSupportedException || e.InnerException is NotSupportedException) {
diff --git a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger/DebuggingService.cs b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger/DebuggingService.cs
index b338b7e708..0bb071737d 100644
--- a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger/DebuggingService.cs
+++ b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger/DebuggingService.cs
@@ -112,6 +112,15 @@ namespace MonoDevelop.Debugger
 				evaluators = null;
 			});
 			IdeApp.Exiting += IdeApp_Exiting;
+			FileService.FileRenamed += FileService_FileRenamed;
+			FileService.FileMoved += FileService_FileRenamed;
+		}
+
+		private static void FileService_FileRenamed (object sender, FileCopyEventArgs e)
+		{
+			foreach (var file in e) {
+				breakpoints.FileRenamed (file.SourceFile, file.TargetFile);
+			}
 		}
 
 		static void IdeApp_Exiting (object sender, ExitEventArgs args)
@@ -289,7 +298,8 @@ namespace MonoDevelop.Debugger
 		public static bool ShowBreakpointProperties (ref BreakEvent bp, BreakpointType breakpointType = BreakpointType.Location)
 		{
 			using (var dlg = new BreakpointPropertiesDialog (bp, breakpointType)) {
-				Xwt.Command response = dlg.Run ();
+				Xwt.WindowFrame parentWindow = Xwt.Toolkit.CurrentEngine.WrapWindow (IdeApp.Workbench.RootWindow);
+				Xwt.Command response = dlg.Run (parentWindow);
 				if (bp == null)
 					bp = dlg.GetBreakEvent ();
 				return response == Xwt.Command.Ok;
@@ -1375,7 +1385,7 @@ namespace MonoDevelop.Debugger
 
 		static Microsoft.CodeAnalysis.ISymbol GetLanguageItem (MonoDevelop.Ide.Gui.Document document, SourceLocation sourceLocation, string identifier)
 		{
-			var textBuffer = document.GetContent<ITextBuffer> ();
+			var textBuffer = document.GetContent<ITextBuffer> (true);
 			if (textBuffer == null)
 				return null;
 
@@ -1417,7 +1427,7 @@ namespace MonoDevelop.Debugger
 			Document doc = IdeApp.Workbench.GetDocument (location.FileName);
 			if (doc != null) {
 				Microsoft.CodeAnalysis.ISymbol rr = null;
-				if (doc.GetContent<ITextEditorResolver> () is ITextEditorResolver textEditorResolver) {
+				if (doc.GetContent<ITextEditorResolver> (true) is ITextEditorResolver textEditorResolver) {
 					rr = textEditorResolver.GetLanguageItem (doc.Editor.LocationToOffset (location.Line, 1), identifier);
 				} else {
 					rr = GetLanguageItem (doc, location, identifier);
@@ -1459,7 +1469,7 @@ namespace MonoDevelop.Debugger
 			Document doc = IdeApp.Workbench.GetDocument (frame.SourceLocation.FileName);
 			if (doc == null)
 				return null;
-			var completionProvider = doc.GetContent<IDebuggerCompletionProvider> ();
+			var completionProvider = doc.GetContent<IDebuggerCompletionProvider> (true);
 			if (completionProvider == null)
 				return null;
 			return completionProvider.GetExpressionCompletionData (exp, frame, token);
diff --git a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger/Extensions.cs b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger/Extensions.cs
index 1364ab3939..9a53376ecc 100644
--- a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger/Extensions.cs
+++ b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger/Extensions.cs
@@ -65,8 +65,8 @@ namespace MonoDevelop.Debugger
 
 		public static AsyncOperation DebugApplication (this ProjectOperations opers, string executableFile, string args, string workingDir, IDictionary<string,string> envVars)
 		{
-			if (!IdeApp.Workbench.RootWindow.Visible) {
-				IdeApp.Workbench.RootWindow.Show ();
+			if (!IdeApp.Workbench.Visible) {
+				IdeApp.Workbench.Show ();
 			}
 
 			var monitor = IdeApp.Workbench.ProgressMonitors.GetRunProgressMonitor (System.IO.Path.GetFileName (executableFile));
@@ -83,8 +83,8 @@ namespace MonoDevelop.Debugger
 
 		public static AsyncOperation AttachToProcess (this ProjectOperations opers, DebuggerEngine debugger, ProcessInfo proc)
 		{
-			if (!IdeApp.Workbench.RootWindow.Visible) {
-				IdeApp.Workbench.RootWindow.Show ();
+			if (!IdeApp.Workbench.Visible) {
+				IdeApp.Workbench.Show ();
 			}
 
 			var oper = DebuggingService.AttachToProcess (debugger, proc);
diff --git a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger/NoSourceView.cs b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger/NoSourceView.cs
index e74956d6b9..c2fbbfff1a 100644
--- a/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger/NoSourceView.cs
+++ b/main/src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger/NoSourceView.cs
@@ -90,7 +90,7 @@ namespace MonoDevelop.Debugger
 				labelDisassembly.Markup = GettextCatalog.GetString ("View disassembly in the {0}", "<a href=\"clicked\">" + GettextCatalog.GetString ("Disassembly Tab") + "</a>");
 				labelDisassembly.LinkClicked += (sender, e) => {
 					DebuggingService.ShowDisassembly ();
-					this.WorkbenchWindow.Document.Close (false).Ignore ();
+					Document.Close (false).Ignore ();
 				};
 				box.PackStart (labelDisassembly);
 			}
@@ -135,7 +135,7 @@ namespace MonoDevelop.Debugger
 
 						var doc = await IdeApp.Workbench.OpenDocument (newFilePath, null, sf.SourceLocation.Line, 1, OpenDocumentOptions.Debugger);
 						if (doc != null) {
-							await this.WorkbenchWindow.Document.Close (false);
+							await Document.Close (false);
 						}
 					}
 				} else {
diff --git a/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport.Toolbox/CodeTemplateToolboxProvider.cs b/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport.Toolbox/CodeTemplateToolboxProvider.cs
index cb226c3a63..aba738b675 100644
--- a/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport.Toolbox/CodeTemplateToolboxProvider.cs
+++ b/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport.Toolbox/CodeTemplateToolboxProvider.cs
@@ -29,26 +29,40 @@
 using System;
 using MonoDevelop.Ide.CodeTemplates;
 using MonoDevelop.Ide;
-using MonoDevelop.Ide.Gui.Content;
-using MonoDevelop.Ide.Editor;
-using MonoDevelop.Ide.Gui;
 using MonoDevelop.Ide.Gui.Documents;
+using System.Collections.Generic;
+using MonoDevelop.Core;
 
 namespace MonoDevelop.DesignerSupport.Toolbox
 {
-	
+
 	public class CodeTemplateToolboxProvider : IToolboxDynamicProvider
 	{
-		static string category = MonoDevelop.Core.GettextCatalog.GetString ("Text Snippets");
+		static string category = GettextCatalog.GetString ("Text Snippets");
+
+		readonly FilePath filePath;
+
+		public CodeTemplateToolboxProvider ()
+		{
+		}
 
-		public System.Collections.Generic.IEnumerable<ItemToolboxNode> GetDynamicItems (IToolboxConsumer consumer)
+		public CodeTemplateToolboxProvider (FilePath filePath)
 		{
-			// TOTEST
-			if (!(consumer is FileDocumentController content) || !consumer.IsTextView ()) {
-				yield break;

+			this.filePath = filePath;
+		}
+
+		public IEnumerable<ItemToolboxNode> GetDynamicItems (IToolboxConsumer consumer)
+		{
+			var file = filePath;
+
+			if (file.IsNullOrEmpty) {
+				if (!(consumer is FileDocumentController content) || !consumer.IsTextEditor (out var _)) {
+					yield break;
+				}
+				file = content.FilePath;
 			}
 
-			foreach (CodeTemplate ct in CodeTemplateService.GetCodeTemplatesForFile (content.FilePath)) {
+			foreach (CodeTemplate ct in CodeTemplateService.GetCodeTemplatesForFile (file)) {
 				if (ct.CodeTemplateContext != CodeTemplateContext.Standard)
 					continue;
 				yield return new TemplateToolboxNode (ct) {
diff --git a/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport.Toolbox/MacToolboxWidget.cs b/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport.Toolbox/MacToolboxWidget.cs
index e52c52eb18..eff82d18aa 100644
--- a/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport.Toolbox/MacToolboxWidget.cs
+++ b/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport.Toolbox/MacToolboxWidget.cs
@@ -256,13 +256,16 @@ namespace MonoDevelop.DesignerSupport.Toolbox
 
 		public override void MouseDown (NSEvent theEvent)
 		{
+			// MouseDownActivated needs to be called before logic activating toolbox item
+			// because MacToolbox uses this event to focus GTK widget that hosts MacToolboxWidget
+			// resulting into stealing focus from toolbox consumer that gains focus when toolbox item is activated
+			MouseDownActivated?.Invoke (theEvent);
+
 			collectionViewDelegate.IsLastSelectionFromMouseDown = true;
 			base.MouseDown (theEvent);
 			if (SelectedItem != null && theEvent.ClickCount > 1) {
 				OnActivateSelectedItem (EventArgs.Empty);
 			}
-
-			MouseDownActivated?.Invoke (theEvent);
 		}
 
 		public void RedrawItems (bool invalidates, bool reloads)
diff --git a/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport.Toolbox/Styles.cs b/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport.Toolbox/Styles.cs
index 14fa27fa49..3cdff448bc 100644
--- a/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport.Toolbox/Styles.cs
+++ b/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport.Toolbox/Styles.cs
@@ -20,6 +20,18 @@ namespace MonoDevelop.DesignerSupport
 		public static NSColor HeaderBorderBackgroundColor { get; private set; }

 

 		public static NSColor ToolbarBackgroundColor { get; private set; }

+

+		public static PropertyPadStyle PropertyPad { get; private set; }

+

+		// Used for the property panel in Xamarin.PropertyEditing

+		public class PropertyPadStyle
+		{
+			public NSColor Checkerboard0 { get; internal set; }
+			public NSColor Checkerboard1 { get; internal set; }
+			public NSColor ValueBlockBackgroundColor { get; internal set; }
+			public NSColor TabBorderColor { get; internal set; }
+			public NSColor PanelTabBackground { get; internal set; }
+		}

 
 		static Styles ()

 		{

@@ -35,14 +47,30 @@ namespace MonoDevelop.DesignerSupport
 				LabelSelectedForegroundColor = NSColor.Highlight;

 				ToolbarBackgroundColor = NSColor.White;

 				CellBackgroundSelectedColor = NSColor.FromRgb (0.36f, 0.54f, 0.90f);

+

+				PropertyPad = new PropertyPadStyle {
+					Checkerboard0 = NSColor.FromRgb (255, 255, 255),
+					Checkerboard1 = NSColor.FromRgb (217, 217, 217),
+					PanelTabBackground = NSColor.FromRgb (248, 247, 248),
+					TabBorderColor = NSColor.FromRgba (0, 0, 0, 25),
+					ValueBlockBackgroundColor = NSColor.FromRgba (0, 0, 0, 20)
+				};
 			} else {

 				CellBackgroundSelectedColor = NSColor.FromRgb (0.38f, 0.55f, 0.91f);

 				HeaderBackgroundColor = NSColor.FromRgb (0.29f, 0.29f, 0.29f);

 				HeaderBorderBackgroundColor = NSColor.FromRgb (0.29f, 0.29f, 0.29f);

 				LabelSelectedForegroundColor = NSColor.SelectedText;

 				ToolbarBackgroundColor = NSColor.FromRgb (0.25f, 0.25f, 0.25f);
+
+				PropertyPad = new PropertyPadStyle {
+					Checkerboard0 = NSColor.FromRgb (38, 38, 38),
+					Checkerboard1 = NSColor.FromRgb (0, 0, 0),
+					PanelTabBackground = NSColor.FromRgb (85, 85, 85),
+					TabBorderColor = NSColor.FromRgba (255, 255, 255, 0),
+					ValueBlockBackgroundColor = NSColor.FromRgba (255, 255, 255, 25)
+				};
 			}
 		}

 	}
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport.csproj b/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport.csproj
index bcace16332..49a2f0ca08 100644
--- a/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport.csproj
+++ b/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport.csproj
@@ -144,6 +144,7 @@
     <Compile Include="MonoDevelop.DesignerSupport\IPropertyPad.cs" />
     <Compile Include="MonoDevelop.DesignerSupport\NativePropertyEditors\PropertyInfo\FlagDescriptorPropertyInfo.cs" />
     <Compile Include="MonoDevelop.DesignerSupport\NativePropertyEditors\PropertyPadItem.cs" />
+    <Compile Include="MonoDevelop.DesignerSupport\MonoDevelopHostResourceProvider.cs" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="MonoDevelop.DesignerSupport.addin.xml" />
diff --git a/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport/MacPropertyGrid.cs b/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport/MacPropertyGrid.cs
index d3838d0b55..3232c62145 100644
--- a/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport/MacPropertyGrid.cs
+++ b/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport/MacPropertyGrid.cs
@@ -67,7 +67,7 @@ namespace MonoDevelop.DesignerSupport
 			Spacing = 10;
 			Distribution = NSStackViewDistribution.Fill;
 
-			propertyEditorPanel = new MacPropertyEditorPanel ();
+			propertyEditorPanel = new MacPropertyEditorPanel (new MonoDevelopHostResourceProvider ());
 
 			scrollView = new NSScrollView () {
 				HasVerticalScroller = true,
@@ -153,6 +153,12 @@ namespace MonoDevelop.DesignerSupport
 	{
 		public EventHandler Focused;
 
+		public MacPropertyEditorPanel (MonoDevelopHostResourceProvider hostResources)
+			: base (hostResources)
+		{
+
+		}
+
 		public override bool BecomeFirstResponder ()
 		{
 			Focused?.Invoke (this, EventArgs.Empty);
diff --git a/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport/MonoDevelopHostResourceProvider.cs b/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport/MonoDevelopHostResourceProvider.cs
new file mode 100644
index 0000000000..e730dacf41
--- /dev/null
+++ b/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport/MonoDevelopHostResourceProvider.cs
@@ -0,0 +1,68 @@
+
+/* 
+ * MonoDevelopHostResourceProvider.cs: The pad that holds the MD property grid. Can also 
+ * hold custom grid widgets.
+ *
+ * Copyright (C) 2019 Microsoft, Corp
+ *
+ * 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.
+ */
+
+#if MAC
+using AppKit;
+using MonoDevelop.Components;
+using MonoDevelop.Ide;
+using Xamarin.PropertyEditing.Mac;
+using static Xamarin.PropertyEditing.Mac.NamedResources;
+
+namespace MonoDevelop.DesignerSupport
+{
+	internal class MonoDevelopHostResourceProvider : HostResourceProvider
+	{
+		public MonoDevelopHostResourceProvider ()
+		{
+			CurrentAppearance = NSAppearance.GetAppearance (IdeApp.Preferences.UserInterfaceTheme == Theme.Dark ? NSAppearance.NameDarkAqua : NSAppearance.NameAqua);
+		}
+
+		public override NSColor GetNamedColor (string name)
+		{
+			switch (name) {
+			case Checkerboard0Color:
+				return Styles.PropertyPad.Checkerboard0;
+			case Checkerboard1Color:
+				return Styles.PropertyPad.Checkerboard1;
+			case DescriptionLabelColor:
+				return NSColor.SecondaryLabelColor;
+			case ForegroundColor:
+				return (HslColor)Ide.Gui.Styles.BaseForegroundColor;
+			case PadBackgroundColor:
+				return (HslColor)Ide.Gui.Styles.PadBackground;
+			case PanelTabBackground:
+				return Styles.PropertyPad.PanelTabBackground;
+			case TabBorderColor:
+				return Styles.PropertyPad.TabBorderColor;
+			case ValueBlockBackgroundColor:
+				return Styles.PropertyPad.ValueBlockBackgroundColor;
+			}
+			return base.GetNamedColor (name);
+		}
+	}
+}
+#endif
\ No newline at end of file
diff --git a/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport/ToolboxService.cs b/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport/ToolboxService.cs
index a50f32043d..98ba0b08d5 100644
--- a/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport/ToolboxService.cs
+++ b/main/src/addins/MonoDevelop.DesignerSupport/MonoDevelop.DesignerSupport/ToolboxService.cs
@@ -414,7 +414,7 @@ namespace MonoDevelop.DesignerSupport
 		Document oldActiveDoc =  null;
 		SolutionFolderItem oldProject = null;
 		bool configChanged;
-		IToolboxDynamicProvider viewProvider = null;
+		List<IToolboxDynamicProvider> viewProviders = new List<IToolboxDynamicProvider> ();
 		
 		void onActiveDocChanged (object o, EventArgs e)
 		{
@@ -436,28 +436,29 @@ namespace MonoDevelop.DesignerSupport
 		
 		void OnContentChanged (object sender, EventArgs args)
 		{
-			if (viewProvider != null) {
+			foreach (var viewProvider in viewProviders) {
 				this.dynamicProviders.Remove (viewProvider);
 				viewProvider.ItemsChanged -= OnProviderItemsChanged;
 			}
-			
+			viewProviders.Clear ();
+
 			//only treat active ViewContent as a Toolbox consumer if it implements IToolboxConsumer
 			if (IdeApp.Workbench.ActiveDocument != null) {
 				CurrentConsumer = IdeApp.Workbench.ActiveDocument.GetContent<IToolboxConsumer> (true);
-				viewProvider    = IdeApp.Workbench.ActiveDocument.GetContent<IToolboxDynamicProvider> (true);
-				customizer = IdeApp.Workbench.ActiveDocument.GetContent<IToolboxCustomizer> (true);
-				if (viewProvider != null)  {
-					this.dynamicProviders.Add (viewProvider);
+				foreach (var viewProvider in IdeApp.Workbench.ActiveDocument.GetContents<IToolboxDynamicProvider> ()) {
+					viewProviders.Add (viewProvider);
+					dynamicProviders.Add (viewProvider);
 					viewProvider.ItemsChanged += OnProviderItemsChanged;
-					OnToolboxContentsChanged ();
 				}
+				customizer = IdeApp.Workbench.ActiveDocument.GetContent<IToolboxCustomizer> (true);
+				if (viewProviders.Count > 0)
+					OnToolboxContentsChanged ();
 			} else {
 				CurrentConsumer = null;
-				viewProvider = null;
 				customizer = null;
 			}
 		}
-		
+
 		//changing project settings could cause the toolbox contents to change
 		void onProjectConfigChanged (object sender, EventArgs args)
 		{
diff --git a/main/src/addins/MonoDevelop.DotNetCore/DotNetCoreDownloadUrl.cs b/main/src/addins/MonoDevelop.DotNetCore/DotNetCoreDownloadUrl.cs
new file mode 100644
index 0000000000..9aaceaf86b
--- /dev/null
+++ b/main/src/addins/MonoDevelop.DotNetCore/DotNetCoreDownloadUrl.cs
@@ -0,0 +1,54 @@
+//
+// DotNetCoreDownloadUrl.cs
+//
+// Author:
+//       Rodrigo Moya <rodrigo.moya@xamarin.com>
+//
+// Copyright (c) 2019 
+//
+// 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;
+namespace MonoDevelop.DotNetCore
+{
+	static class DotNetCoreDownloadUrl
+	{
+		static readonly string BaseDotNetCoreDownloadUrl = "https://aka.ms/vs/mac/install-netcore{0}";
+
+		public static string GetDotNetCoreDownloadUrl (string version = "")
+		{
+			if (string.IsNullOrEmpty (version))
+				return string.Format (BaseDotNetCoreDownloadUrl, string.Empty);
+
+			if (DotNetCoreVersion.TryParse (version, out var dotNetCoreVersion)) {
+				return GetDotNetCoreDownloadUrl (dotNetCoreVersion);
+			}
+
+			return "https://dotnet.microsoft.com/download";
+		}
+
+		public static string GetDotNetCoreDownloadUrl (DotNetCoreVersion version)
+		{
+			//special case for 2.0, 3.0, ..
+			if (version.Minor == 0)
+				return string.Format (BaseDotNetCoreDownloadUrl, version.Major);
+
+			return string.Format (BaseDotNetCoreDownloadUrl, $"{version.Major}{version.Minor}");
+		}
+	}
+}
diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.Templating/DotNetCoreProjectTemplateWizard.cs b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.Templating/DotNetCoreProjectTemplateWizard.cs
index 0935ab5f0b..0ffb098bd9 100644
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.Templating/DotNetCoreProjectTemplateWizard.cs
+++ b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.Templating/DotNetCoreProjectTemplateWizard.cs
@@ -28,6 +28,7 @@ using System.Collections.Generic;
 using System.Linq;
 using MonoDevelop.Core.Assemblies;
 using MonoDevelop.Ide.Templates;
+using MonoDevelop.Projects;
 
 namespace MonoDevelop.DotNetCore.Templating
 {
@@ -155,7 +156,7 @@ namespace MonoDevelop.DotNetCore.Templating
 
 			var highestFramework = DotNetCoreProjectSupportedTargetFrameworks.GetNetCoreAppTargetFrameworks ().FirstOrDefault ();
 			if (highestFramework != null) {
-				Parameters ["framework"] = highestFramework.Id.GetShortFrameworkName ();
+				Parameters ["framework"] = highestFramework.Id.ShortName;
 			} else {
 				Parameters ["framework"] = "netcoreapp1.1";
 			}
diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.Templating/DotNetCoreProjectTemplateWizardPage.cs b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.Templating/DotNetCoreProjectTemplateWizardPage.cs
index 765fb36b14..8d87500de2 100644
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.Templating/DotNetCoreProjectTemplateWizardPage.cs
+++ b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.Templating/DotNetCoreProjectTemplateWizardPage.cs
@@ -30,6 +30,7 @@ using MonoDevelop.Core;
 using MonoDevelop.Core.Assemblies;
 using MonoDevelop.DotNetCore.Gui;
 using MonoDevelop.Ide.Templates;
+using MonoDevelop.Projects;
 
 namespace MonoDevelop.DotNetCore.Templating
 {
@@ -104,7 +105,7 @@ namespace MonoDevelop.DotNetCore.Templating
 		{
 			var framework = targetFrameworks [selectedTargetFrameworkIndex];
 
-			wizard.Parameters ["Framework"] = framework.Id.GetShortFrameworkName ();
+			wizard.Parameters ["Framework"] = framework.Id.ShortName;
 
 			foreach (var param in parameters) {
 				wizard.Parameters [param] = "false";
diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.Tests/MonoDevelop.DotNetCore.Tests.csproj b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.Tests/MonoDevelop.DotNetCore.Tests.csproj
index 95d8150c4b..70fbc9b701 100644
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.Tests/MonoDevelop.DotNetCore.Tests.csproj
+++ b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.Tests/MonoDevelop.DotNetCore.Tests.csproj
@@ -19,7 +19,6 @@
   <ItemGroup>
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="MonoDevelop.DotNetCore.Tests\DotNetCoreProjectTests.cs" />
-    <Compile Include="MonoDevelop.DotNetCore.Tests\DotNetCoreMSBuildProjectTests.cs" />
     <Compile Include="MonoDevelop.DotNetCore.Tests\DotNetCoreVersionTests.cs" />
     <Compile Include="MonoDevelop.DotNetCore.Tests\DotNetCoreSdkTests.cs" />
     <Compile Include="MonoDevelop.DotNetCore.Tests\DotNetCoreProjectTemplateTests.cs" />
diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.Tests/MonoDevelop.DotNetCore.Tests/DotNetCoreMSBuildProjectTests.cs b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.Tests/MonoDevelop.DotNetCore.Tests/DotNetCoreMSBuildProjectTests.cs
deleted file mode 100644
index bd7cf6e50d..0000000000
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.Tests/MonoDevelop.DotNetCore.Tests/DotNetCoreMSBuildProjectTests.cs
+++ /dev/null
@@ -1,568 +0,0 @@
-//
-// DotNetCoreMSBuildProjectTests.cs
-//
-// Author:
-//       Matt Ward <matt.ward@xamarin.com>
-//
-// Copyright (c) 2017 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.Linq;
-using MonoDevelop.Core.Assemblies;
-using MonoDevelop.Projects.MSBuild;
-using NUnit.Framework;
-
-namespace MonoDevelop.DotNetCore.Tests
-{
-	[TestFixture]
-	class DotNetCoreMSBuildProjectTests
-	{
-		DotNetCoreMSBuildProject project;
-		MSBuildProject msbuildProject;
-
-		void CreateMSBuildProject (string xml, string fileName = @"MyProject.csproj")
-		{
-			msbuildProject = new MSBuildProject ();
-			msbuildProject.FileName = fileName;
-			msbuildProject.LoadXml (xml);
-
-			project = new DotNetCoreMSBuildProject ();
-		}
-
-		void AddGlobalPropertyToMSBuildProject (string name, string value, string defaultValue = null)
-		{
-			msbuildProject
-				.GetGlobalPropertyGroup ()
-				.SetValue (name, value, defaultValue);
-		}
-
-		string GetPropertyValueFromMSBuildProject (string name)
-		{
-			return msbuildProject
-				.GetGlobalPropertyGroup ()
-				.GetValue (name);
-		}
-
-		bool MSBuildProjectHasGlobalProperty (string name)
-		{
-			return msbuildProject
-				.GetGlobalPropertyGroup ()
-				.HasProperty (name);
-		}
-
-		void ReadProject (string frameworkMoniker = ".NETCoreApp,Version=v1.0")
-		{
-			var moniker = TargetFrameworkMoniker.Parse (frameworkMoniker);
-			project.ReadProjectHeader (msbuildProject);
-			project.ReadProject (msbuildProject, moniker);
-		}
-
-		void WriteProject (string frameworkMoniker = ".NETCoreApp,Version=v1.0")
-		{
-			var moniker = TargetFrameworkMoniker.Parse (frameworkMoniker);
-			project.WriteProject (msbuildProject, moniker);
-		}
-
-		[Test]
-		public void ReadProject_ToolsVersionDefined ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\" ToolsVersion=\"15.0\">\r\n" +
-				"</Project>");
-
-			ReadProject ();
-			project.HasSdk = true;
-
-			Assert.AreEqual ("15.0", project.ToolsVersion);
-			Assert.IsFalse (project.IsOutputTypeDefined);
-			Assert.IsTrue (project.HasSdk);
-		}
-
-		[Test]
-		public void ReadProject_OutputTypeDefined ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\" ToolsVersion=\"15.0\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <OutputType>Exe</OutputType>\r\n" +
-				"      <TargetFramework>netcoreapp1.0</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			msbuildProject.Evaluate ();
-
-			ReadProject ();
-
-			Assert.IsTrue (project.IsOutputTypeDefined);
-			Assert.AreEqual ("netcoreapp1.0", project.TargetFrameworks.Single ());
-		}
-
-		[Test]
-		public void ReadProject_ExplicityReferences ()
-		{
-			CreateMSBuildProject (
-				"<Project ToolsVersion=\"15.0\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <OutputType>Exe</OutputType>\r\n" +
-				"      <TargetFramework>netcoreapp1.0</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				" <Import Sdk=\"Microsoft.NET.Sdk\" Project=\"Sdk.targets\" />" +
-				"</Project>");
-			msbuildProject.Evaluate ();
-
-			ReadProject ();
-
-			Assert.That (msbuildProject.GetReferencedSDKs (), Is.Not.Empty);
-		}
-
-		[Test]
-		public void WriteProject_ProjectGuidAddedAndToolsVersionChanged_ProjectGuidIsRemovedAndToolsVersionReset ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\" ToolsVersion=\"15.0\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <TargetFramework>netcoreapp1.0</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			ReadProject ();
-
-			msbuildProject.ToolsVersion = "4.0";
-			AddGlobalPropertyToMSBuildProject ("ProjectGuid", "{111}");
-			WriteProject ();
-
-			Assert.AreEqual ("15.0", msbuildProject.ToolsVersion);
-			Assert.IsFalse (MSBuildProjectHasGlobalProperty ("ProjectGuid"));
-		}
-
-		[Test]
-		public void WriteProject_OutputTypeLibraryIsAdded_OutputTypeIsRemoved ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\" ToolsVersion=\"15.0\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <TargetFramework>netcoreapp1.0</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			ReadProject ();
-
-			msbuildProject.ToolsVersion = "4.0";
-			AddGlobalPropertyToMSBuildProject ("OutputType", "Library");
-			WriteProject ();
-
-			Assert.IsFalse (MSBuildProjectHasGlobalProperty ("OutputType"));
-		}
-
-		[Test]
-		public void WriteProject_OutputTypeLibraryIsDefinedWhenRead_OutputTypeIsNotRemoved ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\" ToolsVersion=\"15.0\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <OutputType>Exe</OutputType>\r\n" +
-				"      <TargetFramework>netcoreapp1.0</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			ReadProject ();
-
-			WriteProject ();
-
-			Assert.IsTrue (MSBuildProjectHasGlobalProperty ("OutputType"));
-		}
-
-		[Test]
-		public void WriteProject_DefaultTargetsAdded_DefaultTargetsIsSetToNull ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\" ToolsVersion=\"15.0\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <OutputType>Exe</OutputType>\r\n" +
-				"      <TargetFramework>netcoreapp1.0</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			ReadProject ();
-			msbuildProject.DefaultTargets = "Build";
-
-			WriteProject ();
-
-			Assert.IsNull (msbuildProject.DefaultTargets);
-		}
-
-		[Test]
-		public void WriteProject_DescriptionAdded_RemovedOnWritingSinceDefaultIsUsed ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\" ToolsVersion=\"15.0\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <OutputType>Exe</OutputType>\r\n" +
-				"      <TargetFramework>netcoreapp1.0</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			ReadProject ();
-			AddGlobalPropertyToMSBuildProject ("Description", "Package Description", string.Empty);
-
-			WriteProject ();
-
-			Assert.IsFalse (MSBuildProjectHasGlobalProperty ("Description"));
-		}
-
-		[Test]
-		public void WriteProject_DescriptionInOriginalProjectFile_NotRemovedOnWriting ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\" ToolsVersion=\"15.0\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <OutputType>Exe</OutputType>\r\n" +
-				"      <TargetFramework>netcoreapp1.0</TargetFramework>\r\n" +
-				"      <Description>Test</Description>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			ReadProject ();
-
-			WriteProject ();
-
-			Assert.IsTrue (MSBuildProjectHasGlobalProperty ("Description"));
-		}
-
-		[Test]
-		public void WriteProject_DescriptionNotInOriginalProjectFileAndNonDefaultValueUsed_NotRemovedOnWriting ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\" ToolsVersion=\"15.0\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <OutputType>Exe</OutputType>\r\n" +
-				"      <TargetFramework>netcoreapp1.0</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			ReadProject ();
-			AddGlobalPropertyToMSBuildProject ("Description", "Test", string.Empty);
-
-			WriteProject ();
-
-			Assert.AreEqual ("Test", GetPropertyValueFromMSBuildProject ("Description"));
-		}
-
-		[Test]
-		public void WriteProject_TargetFrameworkInformationAdded_RemovedOnWriting ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\" ToolsVersion=\"15.0\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <OutputType>Exe</OutputType>\r\n" +
-				"      <TargetFramework>netcoreapp1.0</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			ReadProject ();
-			AddGlobalPropertyToMSBuildProject ("TargetFrameworkVersion", "1.0");
-			AddGlobalPropertyToMSBuildProject ("TargetFrameworkIdentifier", ".NETCoreApp");
-
-			WriteProject ();
-
-			Assert.IsFalse (MSBuildProjectHasGlobalProperty ("TargetFrameworkVersion"));
-			Assert.IsFalse (MSBuildProjectHasGlobalProperty ("TargetFrameworkIdentifier"));
-		}
-
-		[Test]
-		public void WriteProject_AssemblyNameAndRootNamespaceAddedButSameAsProjectName_RemovedOnWriting ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\" ToolsVersion=\"15.0\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <OutputType>Exe</OutputType>\r\n" +
-				"      <TargetFramework>netcoreapp1.0</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>",
-				"Test.csproj"
-			);
-			ReadProject ();
-			AddGlobalPropertyToMSBuildProject ("AssemblyName", "Test");
-			AddGlobalPropertyToMSBuildProject ("RootNamespace", "Test");
-
-			WriteProject ();
-
-			Assert.IsFalse (MSBuildProjectHasGlobalProperty ("AssemblyName"));
-			Assert.IsFalse (MSBuildProjectHasGlobalProperty ("RootNamespace"));
-		}
-
-		[Test]
-		public void WriteProject_AssemblyNameAndRootNamespaceInOriginalProjectFile_NotRemovedOnWriting ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\" ToolsVersion=\"15.0\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <OutputType>Exe</OutputType>\r\n" +
-				"      <TargetFramework>netcoreapp1.0</TargetFramework>\r\n" +
-				"      <AssemblyName>Test</AssemblyName>\r\n" +
-				"      <RootNamespace>Test</RootNamespace>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			ReadProject ();
-
-			WriteProject ();
-
-			Assert.IsTrue (MSBuildProjectHasGlobalProperty ("AssemblyName"));
-			Assert.IsTrue (MSBuildProjectHasGlobalProperty ("RootNamespace"));
-		}
-
-		[Test]
-		public void WriteProject_SdkProjectHasToolsVersionSetAfterReading_ToolsVersionRemovedOnWriting ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <OutputType>Exe</OutputType>\r\n" +
-				"      <TargetFramework>netcoreapp1.0</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			ReadProject ();
-			project.HasSdk = true;
-			msbuildProject.ToolsVersion = "4.0";
-
-			WriteProject ();
-
-			Assert.IsNull (msbuildProject.ToolsVersion);
-		}
-
-		[Test]
-		public void WriteProject_NewProjectReferenceAddedWithNameAndProjectMetadata_ProjectReferenceSavedWithJustIncludeNotNameAndProject ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <OutputType>Exe</OutputType>\r\n" +
-				"      <TargetFramework>netcoreapp1.0</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			ReadProject ();
-			project.HasSdk = true;
-			var projectReferenceItem = msbuildProject.AddNewItem ("ProjectReference", @"Lib\Lib.csproj");
-			projectReferenceItem.Metadata.SetValue ("Name", "Lib");
-			projectReferenceItem.Metadata.SetValue ("Project", "{F109E7DF-F561-4CD6-A46E-CFB27A8B6F2C}");
-
-			WriteProject ();
-
-			var projectReferenceSaved = msbuildProject.GetAllItems ()
-				.FirstOrDefault (item => item.Name == "ProjectReference");
-
-			Assert.IsFalse (projectReferenceSaved.Metadata.HasProperty ("Name"));
-			Assert.IsFalse (projectReferenceSaved.Metadata.HasProperty ("Project"));
-			Assert.AreEqual (@"Lib\Lib.csproj", projectReferenceSaved.Include);
-		}
-
-		[Test]
-		public void WriteProject_TargetFrameworkVersionChanged_TargetFrameworkUpdated ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <OutputType>Exe</OutputType>\r\n" +
-				"      <TargetFramework>netcoreapp1.0</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			msbuildProject.Evaluate ();
-			ReadProject ();
-			project.HasSdk = true;
-
-			WriteProject (".NETCoreApp,Version=v1.1");
-
-			string savedFramework = msbuildProject.GetGlobalPropertyGroup ()
-				.GetValue ("TargetFramework");
-			Assert.AreEqual ("netcoreapp1.1", savedFramework);
-		}
-
-		[Test]
-		public void WriteProject_TargetFrameworkVersionChangedThenChangedBackAgain_OriginalTargetFrameworkUsedInProject ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <OutputType>Exe</OutputType>\r\n" +
-				"      <TargetFramework>netcoreapp1.0</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			msbuildProject.Evaluate ();
-			ReadProject ();
-			project.HasSdk = true;
-
-			WriteProject (".NETCoreApp,Version=v1.1");
-			WriteProject (".NETCoreApp,Version=v1.0");
-
-			string savedFramework = msbuildProject.GetGlobalPropertyGroup ()
-				.GetValue ("TargetFramework");
-			Assert.AreEqual ("netcoreapp1.0", savedFramework);
-		}
-
-		[Test]
-		public void WriteProject_NetStandardTargetFrameworkVersionChanged_TargetFrameworkUpdated ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <OutputType>Exe</OutputType>\r\n" +
-				"      <TargetFramework>netstandard1.0</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			msbuildProject.Evaluate ();
-			ReadProject (".NET Standard,Version=v1.0");
-			project.HasSdk = true;
-
-			WriteProject (".NETStandard,Version=v1.6");
-
-			string savedFramework = msbuildProject.GetGlobalPropertyGroup ()
-				.GetValue ("TargetFramework");
-			Assert.AreEqual ("netstandard1.6", savedFramework);
-		}
-
-		[Test]
-		public void WriteProject_NetFrameworkVersionChanged_TargetFrameworkUpdated ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <OutputType>Exe</OutputType>\r\n" +
-				"      <TargetFramework>net45</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			msbuildProject.Evaluate ();
-			ReadProject ();
-			project.HasSdk = true;
-
-			WriteProject (".NETFramework,Version=v4.6");
-
-			string savedFramework = msbuildProject.GetGlobalPropertyGroup ()
-				.GetValue ("TargetFramework");
-			Assert.AreEqual ("net46", savedFramework);
-		}
-
-		[Test]
-		public void WriteProject_ProjectDefinesMultipleTargetFrameworksAndTargetFrameworkVersionChanged_TargetFrameworksUpdated ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <OutputType>Exe</OutputType>\r\n" +
-				"      <TargetFrameworks>netcoreapp1.0;net45</TargetFrameworks>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			msbuildProject.Evaluate ();
-			ReadProject ();
-			project.HasSdk = true;
-
-			WriteProject (".NETCoreApp,Version=v1.1");
-
-			string savedFramework = msbuildProject.GetGlobalPropertyGroup ()
-				 .GetValue ("TargetFrameworks");
-			Assert.AreEqual ("netcoreapp1.1;net45", savedFramework);
-		}
-
-		[Test]
-		public void WriteProject_AssemblyNameAndRootNamespaceAddedDifferentToProjectName_AssemblyNameAndRootNamespaceSaved ()
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\" ToolsVersion=\"15.0\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"      <OutputType>Exe</OutputType>\r\n" +
-				"      <TargetFramework>netcoreapp1.0</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>",
-			"MyProject.csproj");
-			ReadProject ();
-			AddGlobalPropertyToMSBuildProject ("AssemblyName", "NewAssemblyName");
-			AddGlobalPropertyToMSBuildProject ("RootNamespace", "NewRootNamespace");
-
-			WriteProject ();
-
-			Assert.AreEqual ("NewAssemblyName", GetPropertyValueFromMSBuildProject ("AssemblyName"));
-			Assert.AreEqual ("NewRootNamespace", GetPropertyValueFromMSBuildProject ("RootNamespace"));
-		}
-
-		[TestCase ("netcoreapp1.0", ".NETCoreApp,Version=v1.0")]
-		[TestCase ("netcoreapp10", ".NETCoreApp,Version=v1.0")]
-		[TestCase ("NetCoreApp1.0", ".NETCoreApp,Version=v1.0")]
-		[TestCase ("net461", ".NETFramework,Version=v4.6.1")]
-		[TestCase ("net4.6.1", ".NETFramework,Version=v4.6.1")]
-		[TestCase ("Net461", ".NETFramework,Version=v4.6.1")]
-		[TestCase ("NET461", ".NETFramework,Version=v4.6.1")]
-		[TestCase ("netstandard2.0", ".NETStandard,Version=v2.0")]
-		[TestCase ("netstandard20", ".NETStandard,Version=v2.0")]
-		[TestCase ("NetStandard2.0", ".NETStandard,Version=v2.0")]
-		[TestCase ("tizen40", "Tizen,Version=v4.0")]
-		[TestCase ("tizen4.0", "Tizen,Version=v4.0")]
-		[TestCase ("Tizen4.0", "Tizen,Version=v4.0")]
-		public void WriteProject_ProjectTargetFrameworkUnchanged_TargetFrameworkPropertyNotModified (
-			string shortFrameworkName,
-			string fullFrameworkName)
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"    <TargetFramework>" + shortFrameworkName + "</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			msbuildProject.Evaluate ();
-			ReadProject (fullFrameworkName);
-
-			WriteProject (fullFrameworkName);
-
-			string savedFramework = msbuildProject.GetGlobalPropertyGroup ()
-				.GetValue ("TargetFramework");
-			Assert.AreEqual (shortFrameworkName, savedFramework);
-		}
-
-		[TestCase ("netcoreapp1.0", ".NETCoreApp,Version=v1.0", ".NETCoreApp,Version=v1.1", "netcoreapp1.1")]
-		[TestCase ("netcoreapp10", ".NETCoreApp,Version=v1.0", ".NETCoreApp,Version=v1.1", "netcoreapp11")]
-		[TestCase ("NetCoreApp1.0", ".NETCoreApp,Version=v1.0", ".NETCoreApp,Version=v1.1", "NetCoreApp1.1")]
-		[TestCase ("net461", ".NETFramework,Version=v4.6.1", ".NETFramework,Version=v4.7.1", "net471")]
-		[TestCase ("net4.6.1", ".NETFramework,Version=v4.6.1", ".NETFramework,Version=v4.7.1", "net4.7.1")]
-		[TestCase ("Net461", ".NETFramework,Version=v4.6.1", ".NETFramework,Version=v4.7.1", "Net471")]
-		[TestCase ("NET461", ".NETFramework,Version=v4.6.1", ".NETFramework,Version=v4.7.1", "NET471")]
-		[TestCase ("netstandard2.0", ".NETStandard,Version=v2.0", ".NETStandard,Version=v1.1", "netstandard1.1")]
-		[TestCase ("netstandard20", ".NETStandard,Version=v2.0", ".NETStandard,Version=v1.1", "netstandard11")]
-		[TestCase ("NetStandard2.0", ".NETStandard,Version=v2.0", ".NETStandard,Version=v1.1", "NetStandard1.1")]
-		[TestCase ("tizen40", "Tizen,Version=v4.0", "Tizen,Version=v4.1", "tizen41")]
-		[TestCase ("tizen4.0", "Tizen,Version=v4.0", "Tizen,Version=v4.1", "tizen4.1")]
-		[TestCase ("Tizen4.0", "Tizen,Version=v4.0", "Tizen,Version=v4.1", "Tizen4.1")]
-
-		// Changing the target framework name should not happen in practice.
-		[TestCase ("netcoreapp1.0", ".NETCoreApp,Version=v1.0", ".NETFramework,Version=v4.6.1", "net461")] // Use default dotted version format for .NETFramework
-		[TestCase ("net461", ".NETFramework,Version=v4.6.1", ".NETCoreApp,Version=v1.1", "netcoreapp1.1")] // Use default dotted format for .NET Core.
-		[TestCase ("netcoreapp1.0", ".NETCoreApp,Version=v1.0", ".NETStandard,Version=v1.1", "netstandard1.1")]
-		[TestCase ("netcoreapp10", ".NETCoreApp,Version=v1.0", ".NETStandard,Version=v1.0", "netstandard1.0")]
-		public void WriteProject_ProjectTargetFrameworkChanged_TargetFrameworkPropertyModified (
-			string shortFrameworkName,
-			string originalFullFrameworkName,
-			string finalFullFrameworkName,
-			string expectedShortFrameworkName)
-		{
-			CreateMSBuildProject (
-				"<Project Sdk=\"Microsoft.NET.Sdk\">\r\n" +
-				"  <PropertyGroup>\r\n" +
-				"    <TargetFramework>" + shortFrameworkName + "</TargetFramework>\r\n" +
-				"  </PropertyGroup>\r\n" +
-				"</Project>");
-			msbuildProject.Evaluate ();
-			ReadProject (originalFullFrameworkName);
-
-			WriteProject (finalFullFrameworkName);
-
-			string savedFramework = msbuildProject.GetGlobalPropertyGroup ()
-				.GetValue ("TargetFramework");
-			Assert.AreEqual (expectedShortFrameworkName, savedFramework);
-		}
-	}
-}
diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.csproj b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.csproj
index 15bd741d79..d6c62da66e 100644
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.csproj
+++ b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore.csproj
@@ -27,14 +27,8 @@
     <Compile Include="MonoDevelop.DotNetCore\DotNetCoreExecutionHandler.cs" />
     <Compile Include="MonoDevelop.DotNetCore.Templating\DotNetCoreProjectTemplateWizard.cs" />
     <Compile Include="MonoDevelop.DotNetCore\DotNetCoreNotInstalledDialog.cs" />
-    <Compile Include="MonoDevelop.DotNetCore\DotNetCoreProjectFileRenamedHandler.cs" />
-    <Compile Include="MonoDevelop.DotNetCore\DotNetCoreProjectReloadMonitor.cs" />
-    <Compile Include="MonoDevelop.DotNetCore\DotNetCoreProjectReader.cs" />
-    <Compile Include="MonoDevelop.DotNetCore\MSBuildProjectExtensions.cs" />
     <Compile Include="MonoDevelop.DotNetCore\DotNetCoreSdkPaths.cs" />
-    <Compile Include="MonoDevelop.DotNetCore\DotNetCoreMSBuildProject.cs" />
     <Compile Include="MonoDevelop.DotNetCore\DotNetCoreCanReferenceProjectExtension.cs" />
-    <Compile Include="MonoDevelop.DotNetCore\DotNetCoreProjectBuilderMaintainer.cs" />
     <Compile Include="MonoDevelop.DotNetCore\DotNetCliToolReference.cs" />
     <Compile Include="MonoDevelop.DotNetCore\DotNetCoreRuntimeOptionsPanel.cs" />
     <Compile Include="MonoDevelop.DotNetCore.Gui\DotNetCoreRuntimeOptionsPanelWidget.cs" />
@@ -46,7 +40,6 @@
     <Compile Include="MonoDevelop.DotNetCore\DummyMSBuildOptionsPanel.cs" />
     <Compile Include="MonoDevelop.DotNetCore\TargetFrameworkMonikerExtensions.cs" />
     <Compile Include="MonoDevelop.DotNetCore\FilePathExtensions.cs" />
-    <Compile Include="MonoDevelop.DotNetCore\MSBuildPropertyGroupExtensions.cs" />
     <Compile Include="MonoDevelop.DotNetCore.NodeBuilders\ProjectDependenciesNode.cs" />
     <Compile Include="MonoDevelop.DotNetCore\ProjectReferenceExtensions.cs" />
     <Compile Include="MonoDevelop.DotNetCore.NodeBuilders\ProjectDependenciesNodeBuilder.cs" />
@@ -86,7 +79,6 @@
     <Compile Include="MonoDevelop.DotNetCore.Gui\GtkDotNetCoreProjectTemplateWizardPageWidget.cs" />
     <Compile Include="gtk-gui\MonoDevelop.DotNetCore.Gui.GtkDotNetCoreProjectTemplateWizardPageWidget.cs" />
     <Compile Include="MonoDevelop.DotNetCore\MSBuildSdksPathGlobalPropertyProvider.cs" />
-    <Compile Include="MonoDevelop.DotNetCore\DotNetCoreShortTargetFramework.cs" />
     <Compile Include="MonoDevelop.DotNetCore.Templating\DotNetCoreProjectTemplateStringTagProvider.cs" />
     <Compile Include="MonoDevelop.DotNetCore.Gui\DotNetCoreSdkLocationPanel.cs" />
     <Compile Include="MonoDevelop.DotNetCore.Gui\DotNetCoreSdkLocationWidget.cs" />
@@ -96,6 +88,8 @@
     <Compile Include="MonoDevelop.DotNetCore\MonoRuntimeInfoExtensions.cs" />
     <Compile Include="MonoDevelop.DotNetCore.NodeBuilders\PackageDependencyInfo.cs" />
     <Compile Include="MonoDevelop.DotNetCore\DotNetCliWatch.cs" />
+    <Compile Include="DotNetCoreDownloadUrl.cs" />
+    <Compile Include="MonoDevelop.DotNetCore\FrameworkReference.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\..\external\mono-addins\Mono.Addins\Mono.Addins.csproj">
diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreMSBuildProject.cs b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreMSBuildProject.cs
deleted file mode 100644
index 0034e373fd..0000000000
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreMSBuildProject.cs
+++ /dev/null
@@ -1,177 +0,0 @@
-//
-// DotNetCoreMSBuildProject.cs
-//
-// Author:
-//       Matt Ward <matt.ward@xamarin.com>
-//
-// Copyright (c) 2017 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;
-using System.Collections.Generic;
-using System.Linq;
-using MonoDevelop.Core.Assemblies;
-using MonoDevelop.PackageManagement;
-using MonoDevelop.Projects;
-using MonoDevelop.Projects.MSBuild;
-
-namespace MonoDevelop.DotNetCore
-{
-	class DotNetCoreMSBuildProject
-	{
-		List<string> targetFrameworks;
-		bool hasRootNamespace;
-		bool hasAssemblyName;
-		bool hasDescription;
-		CompileTarget defaultCompileTarget = CompileTarget.Library;
-		TargetFrameworkMoniker targetFrameworkMoniker;
-
-		public string ToolsVersion { get; private set; }
-		public bool IsOutputTypeDefined { get; private set; }
-
-		public IEnumerable<string> TargetFrameworks => targetFrameworks;
-
-		public bool HasSdk { get; set; }
-
-		public bool HasToolsVersion () => !string.IsNullOrEmpty (ToolsVersion);
-
-		public CompileTarget DefaultCompileTarget => defaultCompileTarget;
-
-		/// <summary>
-		/// Ensure MSBuildProject has ToolsVersion set to 15.0 so the correct
-		/// MSBuild targets are imported.
-		/// </summary>
-		public void ReadProjectHeader (MSBuildProject project)
-		{
-			ToolsVersion = project.ToolsVersion;
-			if (!HasToolsVersion ())
-				project.ToolsVersion = "15.0";
-		}
-
-		public void ReadProject (MSBuildProject project, TargetFrameworkMoniker framework)
-		{
-			IsOutputTypeDefined = project.IsOutputTypeDefined ();
-			targetFrameworks = project.GetTargetFrameworks ().ToList ();
-			hasRootNamespace = project.HasGlobalProperty ("RootNamespace");
-			hasAssemblyName = project.HasGlobalProperty ("AssemblyName");
-			hasDescription = project.HasGlobalProperty ("Description");
-
-			targetFrameworkMoniker = framework;
-
-			ReadDefaultCompileTarget (project);
-		}
-
-		public void WriteProject (MSBuildProject project, TargetFrameworkMoniker framework)
-		{
-			var globalPropertyGroup = project.GetGlobalPropertyGroup ();
-			globalPropertyGroup.RemoveProperty ("ProjectGuid");
-			globalPropertyGroup.RemoveProperty ("TargetFrameworkIdentifier");
-			globalPropertyGroup.RemoveProperty ("TargetFrameworkVersion");
-
-			if (!IsOutputTypeDefined)
-				RemoveOutputTypeIfHasDefaultValue (project, globalPropertyGroup);
-
-			RemoveMSBuildProjectNameDerivedProperties (globalPropertyGroup);
-
-			if (!hasDescription)
-				globalPropertyGroup.RemovePropertyIfHasDefaultValue ("Description", "Package Description");
-
-			project.DefaultTargets = null;
-
-			project.RemoveExtraProjectReferenceMetadata ();
-
-			UpdateTargetFramework (project, framework);
-
-			if (HasToolsVersion ())
-				project.ToolsVersion = ToolsVersion;
-
-			if (HasSdk) {
-				project.ToolsVersion = ToolsVersion;
-			}
-		}
-
-		static void RemoveOutputTypeIfHasDefaultValue (MSBuildProject project, MSBuildPropertyGroup globalPropertyGroup)
-		{
-			string outputType = project.EvaluatedProperties.GetValue ("OutputType");
-			if (string.IsNullOrEmpty (outputType)) {
-				globalPropertyGroup.RemoveProperty ("OutputType");
-			} else {
-				globalPropertyGroup.RemovePropertyIfHasDefaultValue ("OutputType", outputType);
-			}
-		}
-
-		void RemoveMSBuildProjectNameDerivedProperties (MSBuildPropertyGroup globalPropertyGroup)
-		{
-			string msbuildProjectName = globalPropertyGroup.ParentProject.FileName.FileNameWithoutExtension;
-
-			if (!hasAssemblyName)
-				globalPropertyGroup.RemovePropertyIfHasDefaultValue ("AssemblyName", msbuildProjectName);
-
-			if (!hasRootNamespace)
-				globalPropertyGroup.RemovePropertyIfHasDefaultValue ("RootNamespace", msbuildProjectName);
-		}
-
-		void UpdateTargetFramework (MSBuildProject project, TargetFrameworkMoniker framework)
-		{
-			if (targetFrameworkMoniker == framework)
-				return;
-
-			string shortFrameworkName = null;
-			DotNetCoreShortTargetFramework shortFramework = null;
-
-			string existingFramework = targetFrameworks.FirstOrDefault ();
-			bool identifiersMatch = targetFrameworkMoniker.Identifier == framework.Identifier;
-
-			if (identifiersMatch && DotNetCoreShortTargetFramework.TryParse (existingFramework, out shortFramework)) {
-				shortFramework.Update (framework);
-				shortFrameworkName = shortFramework.ToString ();
-			} else {
-				shortFrameworkName = framework.GetShortFrameworkName ();
-			}
-
-			if (existingFramework == shortFrameworkName)
-				return;
-
-			if (targetFrameworks.Count == 0)
-				targetFrameworks.Add (shortFrameworkName);
-			else
-				targetFrameworks[0] = shortFrameworkName;
-
-			targetFrameworkMoniker = framework;
-			project.UpdateTargetFrameworks (targetFrameworks);
-		}
-
-		public void AddKnownItemAttributes (MSBuildProject project)
-		{
-			if (HasSdk)
-				ProjectPackageReference.AddKnownItemAttributes (project);
-		}
-
-		public void ReadDefaultCompileTarget (MSBuildProject project)
-		{
-			string outputType = project.EvaluatedProperties.GetValue ("OutputType");
-			if (!string.IsNullOrEmpty (outputType)) {
-				if (!Enum.TryParse (outputType, out defaultCompileTarget)) {
-					defaultCompileTarget = CompileTarget.Library;
-				}
-			}
-		}
-	}
-}
diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreNotInstalledDialog.cs b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreNotInstalledDialog.cs
index d87327f1f4..9fb149f4f3 100644
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreNotInstalledDialog.cs
+++ b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreNotInstalledDialog.cs
@@ -33,33 +33,11 @@ namespace MonoDevelop.DotNetCore
 {
 	class DotNetCoreNotInstalledDialog : IDisposable
 	{
-		static readonly string DotNetCoreDownloadUrl = "https://aka.ms/vs/mac/install-netcore{0}";
-
-		public static string GetDotNetCoreDownloadUrl (string version = "")
-		{
-			if (string.IsNullOrEmpty (version))
-				return string.Format (DotNetCoreDownloadUrl, string.Empty);
-
-			//special case for 2.0, 3.0, ..
-			if (version.EndsWith (".0", StringComparison.InvariantCulture))
-				version = version.Replace (".0", string.Empty);
-
-			return string.Format (DotNetCoreDownloadUrl, version.Replace (".", string.Empty));
-		}
-
 		static readonly string defaultMessage = GettextCatalog.GetString (".NET Core SDK is not installed. This is required to build and run .NET Core projects.");
 
-		public static string GetDotNetCoreMessage (string currentPath, string version = "")
-		{
-			if (string.IsNullOrEmpty (version))
-				return GettextCatalog.GetString ("The version of the .NET Core SDK currently installed ({0}) is not supported and continuing to use it may result in a broken tooling experience.", currentPath);
-
-			return GettextCatalog.GetString (".NET Core {0} SDK is not installed. This is required to build and run .NET Core {0} projects.", version);
-		}
-
 		GenericMessage message;
 		AlertButton downloadButton;
-		string downloadUrl = DotNetCoreDownloadUrl;
+		string downloadUrl = DotNetCoreDownloadUrl.GetDotNetCoreDownloadUrl ();
 
 		public DotNetCoreNotInstalledDialog ()
 		{
@@ -95,10 +73,10 @@ namespace MonoDevelop.DotNetCore
 		public void Show ()
 		{
 			if (IsUnsupportedVersion || IsNetStandard) //for .net standard we'll show generic message
-				Message = GetDotNetCoreMessage (CurrentDotNetCorePath);
+				Message = DotNetCoreSdk.GetNotSupportedVersionMessage ();
 			else {
-				Message = GetDotNetCoreMessage (CurrentDotNetCorePath, RequiredDotNetCoreVersion.OriginalString);
-				downloadUrl = GetDotNetCoreDownloadUrl (RequiredDotNetCoreVersion.OriginalString);
+				Message = DotNetCoreSdk.GetNotSupportedVersionMessage (RequiredDotNetCoreVersion.OriginalString);
+				downloadUrl = DotNetCoreDownloadUrl.GetDotNetCoreDownloadUrl (RequiredDotNetCoreVersion);
 			}
 
 			MessageService.GenericAlert (message);
diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreProjectExtension.cs b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreProjectExtension.cs
index 5d29e5b033..984c13692c 100644
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreProjectExtension.cs
+++ b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreProjectExtension.cs
@@ -25,7 +25,6 @@
 // THE SOFTWARE.
 
 using System;
-using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
@@ -37,22 +36,24 @@ using MonoDevelop.PackageManagement.Commands;
 using MonoDevelop.Projects;
 using MonoDevelop.Projects.MSBuild;
 using MonoDevelop.Ide;
-using System.Collections.Immutable;
 
 namespace MonoDevelop.DotNetCore
 {
 	[ExportProjectModelExtension]
-	public class DotNetCoreProjectExtension: DotNetProjectExtension
+	public class DotNetCoreProjectExtension: SdkProjectExtension
 	{
 		const string ShownDotNetCoreSdkInstalledExtendedPropertyName = "DotNetCore.ShownDotNetCoreSdkNotInstalledDialog";
 		const string GlobalJsonPathExtendedPropertyName = "DotNetCore.GlobalJsonPath";
 
-		DotNetCoreMSBuildProject dotNetCoreMSBuildProject = new DotNetCoreMSBuildProject ();
 		DotNetCoreSdkPaths sdkPaths;
 
 		public DotNetCoreProjectExtension ()
 		{
-			DotNetCoreProjectReloadMonitor.Initialize ();
+			try {
+				DotNetCoreSdk.EnsureInitialized ();
+			} catch (Exception ex) {
+				LoggingService.LogInternalError ("DotNetCoreProjectExtension sdk initialization failed", ex);
+			}
 		}
 
 		void FileService_FileChanged (object sender, FileEventArgs e)
@@ -70,30 +71,30 @@ namespace MonoDevelop.DotNetCore
 
 		protected override bool SupportsObject (WorkspaceObject item)
 		{
-			return DotNetCoreSupportsObject(item) && !IsWebProject ((DotNetProject)item);
+			return DotNetCoreSupportsObject (item) && !IsWebProject ((DotNetProject)item);
 		}
 
 		protected bool DotNetCoreSupportsObject (WorkspaceObject item)
 		{
-			return base.SupportsObject (item) && IsSdkProject ((DotNetProject)item);
+			return base.SupportsObject (item) && HasSupportedFramework ((DotNetProject)item);
 		}
 
-		protected override bool OnGetSupportsFramework (TargetFramework framework)
+		/// <summary>
+		/// Cannot check TargetFramework property since it may not be set.
+		/// Currently support .NET Core and .NET Standard.
+		/// </summary>
+		bool HasSupportedFramework (DotNetProject project)
 		{
-			// Allow all SDK style projects to be loaded even if the framework is unknown.
-			// A PackageReference may define the target framework with an imported MSBuild file.
-			return true;
+			string framework = project.MSBuildProject.EvaluatedProperties.GetValue ("TargetFrameworkIdentifier");
+			if (framework != null)
+				return framework == ".NETCoreApp" || framework == ".NETStandard";
+
+			return false;
 		}
 
-		/// <summary>
-		/// Currently this project extension is enabled for all SDK style projects and
-		/// not just for .NET Core and .NET Standard projects. SDK project support
-		/// should be separated out from this extension so it can be enabled only for
-		/// .NET Core and .NET Standard projects.
-		/// </summary>
-		bool IsSdkProject (DotNetProject project)
+		protected override bool OnGetSupportsFramework (TargetFramework framework)
 		{
-			return project.MSBuildProject.GetReferencedSDKs ().Length > 0;
+			return framework.IsNetCoreApp () || framework.IsNetStandard ();
 		}
 
 		protected override bool OnGetCanReferenceProject (DotNetProject targetProject, out string reason)
@@ -118,38 +119,6 @@ namespace MonoDevelop.DotNetCore
 			return DotNetCoreFrameworkCompatibility.CanReferenceNetStandardProject (Project.TargetFramework.Id, targetProject);
 		}
 
-		protected override void OnReadProjectHeader (ProgressMonitor monitor, MSBuildProject msproject)
-		{
-			// Do not read the project header when re-evaluating to prevent the
-			// ToolsVersion that was initially read from the project being changed.
-			if (!Project.IsReevaluating)
-				dotNetCoreMSBuildProject.ReadProjectHeader (msproject);
-			base.OnReadProjectHeader (monitor, msproject);
-		}
-
-		protected override void OnReadProject (ProgressMonitor monitor, MSBuildProject msproject)
-		{
-			dotNetCoreMSBuildProject.AddKnownItemAttributes (Project.MSBuildProject);
-
-			base.OnReadProject (monitor, msproject);
-
-			dotNetCoreMSBuildProject.ReadProject (msproject, Project.TargetFramework.Id);
-
-			if (!dotNetCoreMSBuildProject.IsOutputTypeDefined)
-				Project.CompileTarget = dotNetCoreMSBuildProject.DefaultCompileTarget;
-
-			Project.UseAdvancedGlobSupport = true;
-			Project.UseDefaultMetadataForExcludedExpandedItems = true;
-			Project.UseFileWatcher = true;
-		}
-
-		protected override void OnWriteProject (ProgressMonitor monitor, MSBuildProject msproject)
-		{
-			base.OnWriteProject (monitor, msproject);
-
-			dotNetCoreMSBuildProject.WriteProject (msproject, Project.TargetFramework.Id);
-		}
-
 		protected override ExecutionCommand OnCreateExecutionCommand (ConfigurationSelector configSel, DotNetProjectConfiguration configuration, ProjectRunConfiguration runConfiguration)
 		{
 			if (Project.TargetFramework.IsNetCoreApp ()) {
@@ -183,7 +152,7 @@ namespace MonoDevelop.DotNetCore
 
 		FilePath GetOutputDirectory (DotNetProjectConfiguration configuration)
 		{
-			string targetFramework = dotNetCoreMSBuildProject.TargetFrameworks.FirstOrDefault ();
+			string targetFramework = TargetFrameworks.FirstOrDefault ();
 			FilePath outputDirectory = configuration.OutputDirectory;
 
 			if (outputDirectory.IsAbsolute)
@@ -206,7 +175,6 @@ namespace MonoDevelop.DotNetCore
 		protected FilePath GetOutputFileName (DotNetProjectConfiguration configuration)
 		{
 			FilePath outputDirectory = GetOutputDirectory (configuration);
-			string assemblyName = Project.Name;
 			return outputDirectory.Combine (configuration.OutputAssembly + ".dll");
 		}
 
@@ -287,31 +255,14 @@ namespace MonoDevelop.DotNetCore
 			}
 		}
 
-		/// <summary>
-		/// Cannot use SolutionItemExtension.OnModified. It does not seem to be called.
-		/// </summary>
-		protected void OnProjectModified (object sender, SolutionItemModifiedEventArgs args)
-		{
-			if (Project.Loading)
-				return;
-
-			var fileNameChange = args.LastOrDefault (arg => arg.Hint == "FileName");
-			if (fileNameChange != null) {
-				DotNetCoreProjectFileRenamedHandler.OnProjectFileRenamed (Project);
-			}
-		}
-
 		protected override void OnItemReady ()
 		{
 			base.OnItemReady ();
-			Project.Modified += OnProjectModified;
 			FileService.FileChanged += FileService_FileChanged;
-			 
+
 			if (!IdeApp.IsInitialized)
 				return;
 
-			PackageManagementServices.ProjectTargetFrameworkMonitor.ProjectTargetFrameworkChanged += ProjectTargetFrameworkChanged;
-
 			if (HasSdk && !IsDotNetCoreSdkInstalled ()) {
 				ShowDotNetCoreNotInstalledDialog (sdkPaths.IsUnsupportedSdkVersion);
 			}
@@ -359,31 +310,11 @@ namespace MonoDevelop.DotNetCore
 
 		public override void Dispose ()
 		{
-			Project.Modified -= OnProjectModified;
 			FileService.FileChanged -= FileService_FileChanged;
 
-			if (IdeApp.IsInitialized)
-				PackageManagementServices.ProjectTargetFrameworkMonitor.ProjectTargetFrameworkChanged -= ProjectTargetFrameworkChanged;
-
 			base.Dispose ();
 		}
 
-		/// <summary>
-		/// This event is fired after the project is saved. Runs a restore if the project was
-		/// not reloaded.
-		/// </summary>
-		void ProjectTargetFrameworkChanged (object sender, ProjectTargetFrameworkChangedEventArgs e)
-		{
-			if (e.IsReload || e.Project.Name != this.Project.Name) {
-				// Ignore. A restore will occur on reload elsewhere.
-				return;
-			}
-
-			// Need to re-evaluate before restoring to ensure the implicit package references are correct after
-			// the target framework has changed.
-			DetectSDK (true);
-		}
-
 		protected override Task<BuildResult> OnClean (ProgressMonitor monitor, ConfigurationSelector configuration, OperationContext operationContext)
 		{
 			BuildResult result = CheckCanRunCleanOrBuild ();
@@ -404,10 +335,6 @@ namespace MonoDevelop.DotNetCore
 
 		BuildResult CheckCanRunCleanOrBuild ()
 		{
-			if (ProjectNeedsRestore ()) {
-				return CreateNuGetRestoreRequiredBuildResult ();
-			}
-
 			if (!Project.TargetFramework.Id.IsNetStandardOrNetCoreApp ()) {
 				return null;
 			}
@@ -418,21 +345,6 @@ namespace MonoDevelop.DotNetCore
 			return null;
 		}
 
-		bool ProjectNeedsRestore ()
-		{
-			if (Project.NuGetAssetsFileExists () &&
-				(HasSdk || Project.DotNetCoreNuGetMSBuildFilesExist ())) {
-				return false;
-			}
-
-			return true;
-		}
-
-		BuildResult CreateNuGetRestoreRequiredBuildResult ()
-		{
-			return CreateBuildError (GettextCatalog.GetString ("NuGet packages need to be restored before building. NuGet MSBuild targets are missing and are needed for building. The NuGet MSBuild targets are generated when the NuGet packages are restored."));
-		}
-
 		BuildResult CreateBuildError (string message)
 		{
 			var result = new BuildResult ();
@@ -456,22 +368,14 @@ namespace MonoDevelop.DotNetCore
 		string GetDotNetCoreSdkRequiredBuildErrorMessage (bool isUnsupportedVersion, TargetFramework targetFramework)
 		{
 			string message;
-			string downloadUrl;
 
 			if (isUnsupportedVersion) {
-				message = DotNetCoreNotInstalledDialog.GetDotNetCoreMessage (sdkPaths.MSBuildSDKsPath);
-				downloadUrl = DotNetCoreNotInstalledDialog.GetDotNetCoreDownloadUrl ();
+				message = DotNetCoreSdk.GetNotSupportedVersionMessage ();
 			} else {
-				message = DotNetCoreNotInstalledDialog.GetDotNetCoreMessage (targetFramework.Id.Version);
-				downloadUrl = DotNetCoreNotInstalledDialog.GetDotNetCoreDownloadUrl (targetFramework.Id.Version);
+				message = DotNetCoreSdk.GetNotSupportedVersionMessage (targetFramework.Id.Version);
 			}
 
-			return $"{message} {downloadUrl}";
-		}
-
-		protected override void OnBeginLoad ()
-		{
-			base.OnBeginLoad ();
+			return message;
 		}
 
 		public bool HasSdk => Project.MSBuildProject.GetReferencedSDKs ().Length > 0;
@@ -494,103 +398,6 @@ namespace MonoDevelop.DotNetCore
 
 			var referencedSdks = project.GetReferencedSDKs ();
 			sdkPaths = DotNetCoreSdk.FindSdkPaths (referencedSdks);
-			dotNetCoreMSBuildProject.HasSdk = referencedSdks.Length > 0;
-		}
-		protected override async Task<ImmutableArray<ProjectFile>> OnGetSourceFiles (ProgressMonitor monitor, ConfigurationSelector configuration)
-		{
-			var sourceFiles = await base.OnGetSourceFiles (monitor, configuration);
-
-			return AddMissingProjectFiles (sourceFiles, configuration);
-		}
-
-		ImmutableArray<ProjectFile> AddMissingProjectFiles (ImmutableArray<ProjectFile> files, ConfigurationSelector configuration)
-		{
-			ImmutableArray<ProjectFile>.Builder missingFiles = null;
-			foreach (ProjectFile existingFile in Project.Files.Where (file => file.BuildAction == BuildAction.Compile)) {
-				if (!files.Any (file => file.FilePath == existingFile.FilePath)) {
-					if (missingFiles == null)
-						missingFiles = ImmutableArray.CreateBuilder<ProjectFile> ();
-					missingFiles.Add (existingFile);
-				}
-			}
-
-			// Ensure generated assembly info file is available to type system. It is created in the obj
-			// directory and is excluded from the project with a wildcard exclude but the type system needs it to
-			// ensure the project's assembly information is correct to prevent diagnostic errors.
-			var generatedAssemblyInfoFile = GetGeneratedAssemblyInfoFile (configuration);
-			if (generatedAssemblyInfoFile != null) {
-				if (missingFiles == null)
-					missingFiles = ImmutableArray.CreateBuilder<ProjectFile> ();
-				missingFiles.Add (generatedAssemblyInfoFile);
-			}
-
-			if (missingFiles == null)
-				return files;
-
-			missingFiles.Capacity = missingFiles.Count + files.Length;
-			missingFiles.AddRange (files);
-			return missingFiles.MoveToImmutable ();
-		}
-
-		ProjectFile GetGeneratedAssemblyInfoFile (ConfigurationSelector configuration)
-		{
-			var projectConfig = configuration.GetConfiguration (Project) as ProjectConfiguration;
-			if (projectConfig == null)
-				return null;
-
-			bool generateAssemblyInfo = projectConfig.Properties.GetValue ("GenerateAssemblyInfo", true);
-			FilePath assemblyInfoFile = projectConfig.Properties.GetPathValue ("GeneratedAssemblyInfoFile");
-
-			if (generateAssemblyInfo && assemblyInfoFile.IsNotNull)
-				return new ProjectFile (assemblyInfoFile, BuildAction.Compile);
-			return null;
-		}
-
-		protected override void OnSetFormat (MSBuildFileFormat format)
-		{
-			// Do not call base class since the solution's FileFormat will be used which is
-			// VS 2012 and this will set the ToolsVersion to "4.0" which we are preventing.
-			// Setting the ToolsVersion to "4.0" can cause the MSBuild tasks such as
-			// ResolveAssemblyReferences to fail for .NET Core projects when the project
-			// xml is generated in memory for the project builder at the same time as the
-			// project file is being saved.
-		}
-
-		/// <summary>
-		/// Shared projects can trigger a reference change during re-evaluation so do not
-		/// restore if the project is being re-evaluated. Otherwise this could cause the
-		/// restore to be run repeatedly.
-		/// </summary>
-		protected override void OnReferenceAddedToProject (ProjectReferenceEventArgs e)
-		{
-			base.OnReferenceAddedToProject (e);
-
-			if (!IsLoadingOrReevaluating ())
-				RestoreNuGetPackages ();
-		}
-
-		/// <summary>
-		/// Shared projects can trigger a reference change during re-evaluation so do not
-		/// restore if the project is being re-evaluated. Otherwise this could cause the
-		/// restore to be run repeatedly.
-		/// </summary>
-		protected override void OnReferenceRemovedFromProject (ProjectReferenceEventArgs e)
-		{
-			base.OnReferenceRemovedFromProject (e);
-
-			if (!IsLoadingOrReevaluating ())
-				RestoreNuGetPackages ();
-		}
-
-		bool IsLoadingOrReevaluating ()
-		{
-			return Project.Loading || Project.IsReevaluating;
-		}
-
-		void RestoreNuGetPackages ()
-		{
-			Runtime.AssertMainThread ();
-			RestorePackagesInProjectHandler.Run (Project);
 		}
 
 		public bool IsDotNetCoreSdkInstalled ()
@@ -607,186 +414,9 @@ namespace MonoDevelop.DotNetCore
 			return false;
 		}
 
-		bool IsFSharpSdkProject ()
-		{
-			if (HasSdk) {
-				var sdks = Project.MSBuildProject.GetReferencedSDKs ();
-				for (var i = 0; i < sdks.Length; i++) {
-					if (sdks [i].Contains ("FSharp"))
-						return true;
-				}
-			}
-			return false;
-		}
-
-		/// <summary>
-		/// Handle a new project being created and added to a new solution. In this case
-		/// the NuGet packages should be restored. Need to avoid running a restore when
-		/// a solution is being opened so check that project's parent solution is open in
-		/// the IDE.
-		/// </summary>
-		protected override void OnBoundToSolution ()
-		{
-			base.OnBoundToSolution ();
-
-			if (Project.Loading)
-				return;
-
-			if (!IdeApp.IsInitialized)
-				return;
-
-			if (IdeApp.ProjectOperations.CurrentSelectedSolution != Project.ParentSolution)
-				return;
-
-			if (ProjectNeedsRestore ())
-				RestorePackagesInProjectHandler.Run (Project);
-		}
-
-		protected override bool OnGetSupportsImportedItem (IMSBuildItemEvaluated buildItem)
-		{
-			if (!BuildAction.DotNetActions.Contains (buildItem.Name))
-				return false;
-
-			if (IsFSharpSdkProject ()) {
-				// Ignore imported F# files. F# files are defined in the main project.
-				// This prevents duplicate F# files when a new project is first created.
-				if (buildItem.Include.EndsWith (".fs", StringComparison.OrdinalIgnoreCase))
-					return false;
-			}
-
-			if (IsFromSharedProject (buildItem))
-				return false;
-
-			// HACK: Remove any imported items that are not in the EvaluatedItems
-			// This may happen if a condition excludes the item. All items passed to the
-			// OnGetSupportsImportedItem are from the EvaluatedItemsIgnoringCondition
-			return Project.MSBuildProject.EvaluatedItems
-				.Any (item => item.IsImported && item.Name == buildItem.Name && item.Include == buildItem.Include);
-		}
-
-		/// <summary>
-		/// Checks that the project has the HasSharedItems property set to true and the SharedGUID
-		/// property in its global property group. Otherwise it is not considered to be a shared project.
-		/// </summary>
-		bool IsFromSharedProject (IMSBuildItemEvaluated buildItem)
-		{
-			var globalGroup = buildItem?.SourceItem?.ParentProject?.GetGlobalPropertyGroup ();
-			return globalGroup?.GetValue<bool> ("HasSharedItems") == true &&
-				globalGroup?.HasProperty ("SharedGUID") == true;
-		}
-
 		protected override ProjectRunConfiguration OnCreateRunConfiguration (string name)
 		{
 			return new DotNetCoreRunConfiguration (name, IsWeb);
 		}
-
-		/// <summary>
-		/// HACK: Hide certain files that are currently being added to the Solution window.
-		/// </summary>
-		protected override void OnItemsAdded (IEnumerable<ProjectItem> objs)
-		{
-			if (Project.Loading) {
-				UpdateHiddenFiles (objs.OfType<ProjectFile> ());
-			}
-			base.OnItemsAdded (objs);
-		}
-
-		void UpdateHiddenFiles (IEnumerable<ProjectFile> files)
-		{
-			foreach (var file in files) {
-				if (file.FilePath.ShouldBeHidden ())
-					file.Flags = ProjectItemFlags.Hidden;
-			}
-		}
-
-		protected override async Task OnReevaluateProject (ProgressMonitor monitor)
-		{
-			await base.OnReevaluateProject (monitor);
-			UpdateHiddenFiles (Project.Files);
-		}
-
-		/// <summary>
-		/// Returns all transitive references.
-		/// </summary>
-		protected override async Task<List<AssemblyReference>> OnGetReferences (
-			ConfigurationSelector configuration,
-			System.Threading.CancellationToken token)
-		{
-			var references = new List<AssemblyReference> ();
-
-			var traversedProjects = new HashSet<string> ();
-			traversedProjects.Add (Project.ItemId);
-
-			await GetTransitiveAssemblyReferences (traversedProjects, references, configuration, true, token);
-
-			return references;
-		}
-
-		/// <summary>
-		/// Recursively gets all transitive project references for .NET Core projects
-		/// and if includeNonProjectReferences is true also returns non project
-		/// assembly references.
-		/// 
-		/// Calling base.OnGetReferences returns the directly referenced projects and
-		/// also all transitive references which are not project references.
-		/// 
-		/// includeNonProjectReferences should be set to false when getting the
-		/// assembly references for referenced projects since the assembly references
-		/// from OnGetReferences already contains any transitive references which are
-		/// not projects.
-		/// </summary>
-		async Task GetTransitiveAssemblyReferences (
-			HashSet<string> traversedProjects,
-			List<AssemblyReference> references,
-			ConfigurationSelector configuration,
-			bool includeNonProjectReferences,
-			System.Threading.CancellationToken token)
-		{
-			foreach (var reference in await base.OnGetReferences (configuration, token)) {
-				if (!reference.IsProjectReference) {
-					if (includeNonProjectReferences) {
-						references.Add (reference);
-					}
-					continue;
-				}
-
-				// Project references with ReferenceOutputAssembly false should be
-				// added but there is no need to check any further since there will not
-				// any transitive project references.
-				if (!reference.ReferenceOutputAssembly) {
-					references.Add (reference);
-					continue;
-				}
-
-				var project = reference.GetReferencedItem (Project.ParentSolution) as DotNetProject;
-				if (project == null)
-					continue;
-
-				if (traversedProjects.Contains (project.ItemId))
-					continue;
-
-				references.Add (reference);
-				traversedProjects.Add (project.ItemId);
-
-				var extension = project.AsFlavor<DotNetCoreProjectExtension> ();
-				if (extension != null)
-					await extension.GetTransitiveAssemblyReferences (traversedProjects, references, configuration, false, token);
-			}
-		}
-
-		/// <summary>
-		/// ASP.NET Core projects have different build actions if the file is in the wwwroot folder.
-		/// It also uses Content build actions for *.json, *.config and *.cshtml files. To support
-		/// this the default file globs for the file are found and the MSBuild item name is returned.
-		/// </summary>
-		protected override string OnGetDefaultBuildAction (string fileName)
-		{
-			string include = MSBuildProjectService.ToMSBuildPath (Project.ItemDirectory, fileName);
-			var globItems = Project.MSBuildProject.FindGlobItemsIncludingFile (include).ToList ();
-			if (globItems.Count == 1)
-				return globItems [0].Name;
-
-			return base.OnGetDefaultBuildAction (fileName);
-		}
 	}
 }
diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreProjectReader.cs b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreProjectReader.cs
deleted file mode 100644
index b8ef91ce9d..0000000000
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreProjectReader.cs
+++ /dev/null
@@ -1,112 +0,0 @@
-//
-// DotNetCoreProjectReader.cs
-//
-// Author:
-//       Matt Ward <matt.ward@xamarin.com>
-//
-// Copyright (c) 2016 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;
-using System.IO;
-using System.Threading.Tasks;
-using System.Xml;
-using MonoDevelop.Core;
-using MonoDevelop.Projects;
-using MonoDevelop.Projects.MSBuild;
-
-namespace MonoDevelop.DotNetCore
-{
-	class DotNetCoreProjectReader : WorkspaceObjectReader
-	{
-		public override bool CanRead (FilePath file, Type expectedType)
-		{
-			if (!expectedType.IsAssignableFrom (typeof(SolutionItem)))
-				return false;
-
-			if (file.HasSupportedDotNetCoreProjectFileExtension ())
-				return IsDotNetCoreProjectFile (file);
-
-			return false;
-		}
-
-		/// <summary>
-		/// Check the Project element contains an Sdk and ToolsVersion attribute.
-		/// </summary>
-		static bool IsDotNetCoreProjectFile (FilePath file)
-		{
-			return GetDotNetCoreSdk (file) != null;
-		}
-
-		/// <summary>
-		/// Returns the first Sdk property defined by the project, if any exists
-		/// </summary>
-		public static string GetDotNetCoreSdk (FilePath file)
-		{
-			try {
-				// A .NET Core project can define an sdk in any of the following ways
-				// 1) An Sdk attribute on the Project node
-				// 2) An Sdk node as a child of the Project node
-				// 3) An Sdk attribute on any Import node
-				var document = new XmlDocument ();
-				document.Load (new StreamReader (file));
-				XmlNode projectNode = document.SelectSingleNode ("/Project");
-				if (projectNode != null) {
-					XmlAttribute sdkAttr = projectNode.Attributes ["Sdk"];
-					if (sdkAttr != null) {
-						// Found an Sdk definition on the root Project node
-						return sdkAttr.Value;

-					}
-
-					var childSdkNode = projectNode.SelectSingleNode ("Sdk");
-					if (childSdkNode != null) {
-						var name = childSdkNode.Attributes ["Name"];
-						if (name != null) {
-							// Found an Sdk definition on an Sdk node
-							return name.Value;
-						}
-					}
-
-					foreach (XmlNode importNode in projectNode.SelectNodes ("//Import")) {
-						sdkAttr = importNode.Attributes ["Sdk"];
-						if (sdkAttr != null) {
-							return sdkAttr.Value;
-						}
-					}
-				}
-			} catch {
-				// Ignore
-			}
-			return null;
-		}
-
-		public override Task<SolutionItem> LoadSolutionItem (ProgressMonitor monitor, SolutionLoadContext ctx, string fileName, MSBuildFileFormat expectedFormat, string typeGuid, string itemGuid)
-		{
-			return Task.Run (() => {
-				if (CanRead (fileName, typeof(SolutionItem))) {
-					DotNetCoreSdk.EnsureInitialized ();
-					return MSBuildProjectService.LoadItem (monitor, fileName, MSBuildFileFormat.VS2012, typeGuid, itemGuid, ctx);
-				}
-
-				throw new NotSupportedException ();
-			});
-		}
-	}
-}
diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreSdk.cs b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreSdk.cs
index d206c4ac13..60028713d4 100644
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreSdk.cs
+++ b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreSdk.cs
@@ -179,5 +179,26 @@ namespace MonoDevelop.DotNetCore
 		{
 			SdkRootPath = path;
 		}
+
+		internal static string GetNotSupportedVersionMessage (string version = "")
+		{
+			string GetMessage (DotNetCoreVersion currentVersion)
+			{
+				return GettextCatalog.GetString ("NET Core {0}.{1} SDK version {2} is not compatible with this version of Visual Studio for Mac. Install the latest update to the .NET Core {0}.{1} SDK by visiting {3}.", currentVersion.Major, currentVersion.Minor, currentVersion.ToString (), DotNetCoreDownloadUrl.GetDotNetCoreDownloadUrl (currentVersion));
+			}
+
+			var installedVersion = Versions.OrderByDescending (x => x).FirstOrDefault ();
+			if (installedVersion != null) {
+				if (installedVersion < DotNetCoreVersion.MinimumSupportedSdkVersion) {
+					return GetMessage (installedVersion);
+				} else if (installedVersion.Major == 2 && installedVersion.Minor == 2 && installedVersion < DotNetCoreVersion.MinimumSupportedSdkVersion22) {
+					return GetMessage (installedVersion);
+				} else if (installedVersion.Major == 3 && installedVersion < DotNetCoreVersion.MinimumSupportedSdkVersion30) {
+					return GetMessage (installedVersion);
+				}
+			}
+
+			return GettextCatalog.GetString (".NET Core {0} SDK is required to build this application, and is not installed. Install the latest update to the .NET Core {0} SDK by visiting {1}.", version, DotNetCoreDownloadUrl.GetDotNetCoreDownloadUrl (version));
+		}
 	}
 }
diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreSdkPaths.cs b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreSdkPaths.cs
index a538afaf1a..f94a982cb6 100644
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreSdkPaths.cs
+++ b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreSdkPaths.cs
@@ -134,9 +134,7 @@ namespace MonoDevelop.DotNetCore
 			if (Exist) {
 				IsUnsupportedSdkVersion = !CheckIsSupportedSdkVersion (SdksParentDirectory);
 				Exist = !IsUnsupportedSdkVersion;
-			} else {
-				IsUnsupportedSdkVersion = true;
-			}
+			} 
 		}
 
 		public bool IsUnsupportedSdkVersion { get; private set; }
diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreShortTargetFramework.cs b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreShortTargetFramework.cs
deleted file mode 100644
index 6e982ab1f7..0000000000
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreShortTargetFramework.cs
+++ /dev/null
@@ -1,100 +0,0 @@
-//
-// DotNetCoreShortTargetFramework.cs
-//
-// Author:
-//       Matt Ward <matt.ward@microsoft.com>
-//
-// Copyright (c) 2018 Microsoft
-//
-// 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;
-using MonoDevelop.Core.Assemblies;
-
-namespace MonoDevelop.DotNetCore
-{
-	class DotNetCoreShortTargetFramework
-	{
-		DotNetCoreShortTargetFramework ()
-		{
-		}
-
-		public string Identifier { get; private set; }
-		public string Version { get; private set; }
-		public string OriginalString { get; private set; }
-
-		public override string ToString ()
-		{
-			return $"{Identifier}{Version}";
-		}
-
-		/// <summary>
-		/// Parse the specified short target framework. Logic is based on:
-		/// https://github.com/dotnet/sdk/blob/cfe8ff3c4e51c473ae75ca32d1c7a62043e96990/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.TargetFrameworkInference.targets#L50
-		/// </summary>
-		public static DotNetCoreShortTargetFramework Parse (string input)
-		{
-			if (string.IsNullOrEmpty (input))
-				throw new ArgumentException (".NET Core short target framework cannot be null or an empty string.", nameof (input));
-
-			if (input.Contains (","))
-				throw new ArgumentException (".NET Core short target framework cannot contain ','.", nameof (input));
-
-			if (input.Contains ("+"))
-				throw new ArgumentException (".NET Core short target framework cannot contain '+'.", nameof (input));
-
-			string identifier = input.TrimEnd ('.', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9');
-			string version = input.Substring (identifier.Length);
-
-			return new DotNetCoreShortTargetFramework {
-				Identifier = identifier,
-				OriginalString = input,
-				Version = version
-			};
-		}
-
-		public static bool TryParse (string input, out DotNetCoreShortTargetFramework framework)
-		{
-			framework = null;
-
-			if (string.IsNullOrEmpty (input))
-				return false;
-
-			if (input.Contains (",") || input.Contains ("+"))
-				return false;
-
-			framework = Parse (input);
-
-			return true;
-		}
-
-		public void Update (TargetFrameworkMoniker framework)
-		{
-			UpdateVersion (framework.Version);
-		}
-
-		void UpdateVersion (string newVersion)
-		{
-			if (Version.Contains (".")) {
-				Version = newVersion;
-			} else {
-				Version = newVersion.Replace (".", string.Empty);
-			}
-		}
-	}
-}
diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreVersion.cs b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreVersion.cs
index d06d8a0637..4b8f3463ce 100644
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreVersion.cs
+++ b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreVersion.cs
@@ -26,15 +26,16 @@
 
 using System;
 using System.IO;
+using System.Linq;
 using MonoDevelop.Core;
 
 namespace MonoDevelop.DotNetCore
 {
 	class DotNetCoreVersion : IEquatable<DotNetCoreVersion>, IComparable, IComparable<DotNetCoreVersion>
 	{
-		static readonly DotNetCoreVersion MinimumSupportedSdkVersion = new DotNetCoreVersion (2, 1, 602);
-		static readonly DotNetCoreVersion MinimumSupportedSdkVersion22 = new DotNetCoreVersion (2, 2, 202);
-		static readonly DotNetCoreVersion MinimumSupportedSdkVersion30 = new DotNetCoreVersion (3, 0, 100) {
+		internal static readonly DotNetCoreVersion MinimumSupportedSdkVersion = new DotNetCoreVersion (2, 1, 602);
+		internal static readonly DotNetCoreVersion MinimumSupportedSdkVersion22 = new DotNetCoreVersion (2, 2, 202);
+		internal static readonly DotNetCoreVersion MinimumSupportedSdkVersion30 = new DotNetCoreVersion (3, 0, 100) {
 			ReleaseLabel = "preview3-010431",
 			IsPrerelease = true
 		};
diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/MSBuildPropertyGroupExtensions.cs b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/FrameworkReference.cs
index 8717f2d4a9..8e400aaf35 100644
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/MSBuildPropertyGroupExtensions.cs
+++ b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/FrameworkReference.cs
@@ -1,10 +1,10 @@
-//
-// MSBuildPropertyGroupExtensions.cs
+//
+// FrameworkReference.cs
 //
 // Author:
-//       Matt Ward <matt.ward@xamarin.com>
+//       Matt Ward <matt.ward@microsoft.com>
 //
-// Copyright (c) 2017 Xamarin Inc. (http://xamarin.com)
+// Copyright (c) 2019 Microsoft
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -24,23 +24,17 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-using MonoDevelop.Projects.MSBuild;
+using MonoDevelop.Projects;
 
 namespace MonoDevelop.DotNetCore
 {
-	static class MSBuildPropertyGroupExtensions
+	/// <summary>
+	/// FrameworkReference is a set of known framework assemblies that are versioned
+	/// with the project's TargetFramework. Introduced with .NET Core 3.0
+	/// https://github.com/dotnet/designs/pull/50
+	/// </summary>
+	[ExportProjectItemType ("FrameworkReference")]
+	class FrameworkReference : ProjectItem
 	{
-		public static void RemovePropertyIfHasDefaultValue (
-			this MSBuildPropertyGroup propertyGroup,
-			string propertyName,
-			string defaultPropertyValue)
-		{
-			if (!propertyGroup.HasProperty (propertyName))
-				return;
-
-			if (propertyGroup.GetValue (propertyName) == defaultPropertyValue) {
-				propertyGroup.RemoveProperty (propertyName);
-			}
-		}
 	}
 }
diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/MSBuildProjectExtensions.cs b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/MSBuildProjectExtensions.cs
deleted file mode 100644
index 9c50031d57..0000000000
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/MSBuildProjectExtensions.cs
+++ /dev/null
@@ -1,96 +0,0 @@
-//
-// MSBuildProjectExtensions.cs
-//
-// Author:
-//       Matt Ward <matt.ward@xamarin.com>
-//
-// Copyright (c) 2016 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 MonoDevelop.Projects.MSBuild;
-
-namespace MonoDevelop.DotNetCore
-{
-	static class MSBuildProjectExtensions
-	{
-		public static bool IsOutputTypeDefined (this MSBuildProject project)
-		{
-			return project.HasGlobalProperty ("OutputType");
-		}
-
-		public static bool HasGlobalProperty (this MSBuildProject project, string name)
-		{
-			var globalPropertyGroup = project.GetGlobalPropertyGroup ();
-			if (globalPropertyGroup != null)
-				return globalPropertyGroup.HasProperty (name);
-
-			return false;
-		}
-
-		public static IEnumerable<string> GetTargetFrameworks (this MSBuildProject project)
-		{
-			var properties = project.EvaluatedProperties;
-			if (properties != null) {
-				string targetFramework = properties.GetValue ("TargetFramework");
-				if (targetFramework != null) {
-					return new [] { targetFramework };
-				}
-
-				string targetFrameworks = properties.GetValue ("TargetFrameworks");
-				if (targetFrameworks != null) {
-					return targetFrameworks.Split (';');
-				}
-			}
-
-			return new string[0];
-		}
-
-		public static void UpdateTargetFrameworks (this MSBuildProject project, IEnumerable<string> targetFrameworks)
-		{
-			var globalPropertyGroup = project.GetGlobalPropertyGroup ();
-			if (targetFrameworks.Count () > 1) {
-				string value = string.Join (";", targetFrameworks);
-				globalPropertyGroup.SetValue ("TargetFrameworks", value);
-			} else {
-				globalPropertyGroup.SetValue ("TargetFramework", targetFrameworks.FirstOrDefault ());
-			}
-		}
-
-		public static bool ImportExists (this MSBuildProject project, string importedProjectFile)
-		{
-			return project.GetImport (importedProjectFile) != null;
-		}
-
-		/// <summary>
-		/// Remove Name and Project from project references.
-		/// </summary>
-		public static void RemoveExtraProjectReferenceMetadata (this MSBuildProject project)
-		{
-			foreach (MSBuildItem item in project.GetAllItems ()) {
-				if (item.Name == "ProjectReference") {
-					item.Metadata.RemoveProperty ("Name");
-					item.Metadata.RemoveProperty ("Project");
-				}
-			}
-		}
-	}
-}
diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/TargetFrameworkMonikerExtensions.cs b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/TargetFrameworkMonikerExtensions.cs
index c49a937ebe..4e25698a1d 100644
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/TargetFrameworkMonikerExtensions.cs
+++ b/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/TargetFrameworkMonikerExtensions.cs
@@ -30,33 +30,6 @@ namespace MonoDevelop.DotNetCore
 {
 	static class TargetFrameworkMonikerExtensions
 	{
-		public static string GetShortFrameworkName (this TargetFrameworkMoniker framework)
-		{
-			if (framework.IsNetFramework ())
-				return GetShortNetFrameworkName (framework);
-
-			string identifier = GetShortFrameworkIdentifier (framework);
-			return identifier + framework.Version;
-		}
-
-		public static string GetShortFrameworkIdentifier (this TargetFrameworkMoniker framework)
-		{
-			if (string.IsNullOrEmpty (framework.Identifier))
-				return string.Empty;
-
-			string shortFrameworkIdentifier = framework.Identifier;
-
-			if (shortFrameworkIdentifier[0] == '.')
-				shortFrameworkIdentifier = shortFrameworkIdentifier.Substring (1);
-
-			return shortFrameworkIdentifier.ToLower ();
-		}
-
-		static string GetShortNetFrameworkName (TargetFrameworkMoniker framework)
-		{
-			return "net" + framework.Version.Replace (".", string.Empty);
-		}
-
 		public static bool IsNetFramework (this TargetFrameworkMoniker framework)
 		{
 			return framework.Identifier == ".NETFramework";
diff --git a/main/src/addins/MonoDevelop.DotNetCore/Properties/MonoDevelop.DotNetCore.addin.xml b/main/src/addins/MonoDevelop.DotNetCore/Properties/MonoDevelop.DotNetCore.addin.xml
index f79b5f284f..ec5531c06f 100644
--- a/main/src/addins/MonoDevelop.DotNetCore/Properties/MonoDevelop.DotNetCore.addin.xml
+++ b/main/src/addins/MonoDevelop.DotNetCore/Properties/MonoDevelop.DotNetCore.addin.xml
@@ -1159,10 +1159,6 @@
  		<NodeBuilder class="MonoDevelop.DotNetCore.ProjXNodeBuilderExtension" />
 	</Extension>
 
-	<Extension path="/MonoDevelop/ProjectModel/WorkspaceObjectReaders">
-		<Class id="DotNetCoreProjectReader" class="MonoDevelop.DotNetCore.DotNetCoreProjectReader" />
-	</Extension>
-
 	<ExtensionPoint path="/MonoDevelop/DotNetCore/ContextMenu/ProjectPad/PackageDependency">
 		<ExtensionNodeSet id="MonoDevelop.Components.Commands.ItemSet"/>
 	</ExtensionPoint>
diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Refactoring/NuGetPackageServicesProxy.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Refactoring/NuGetPackageServicesProxy.cs
index dede056437..03b3924ef9 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Refactoring/NuGetPackageServicesProxy.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Refactoring/NuGetPackageServicesProxy.cs
@@ -132,13 +132,19 @@ namespace MonoDevelop.PackageManagement.Refactoring
 			});
 		}
 
-		public async Task<IEnumerable<(string PackageName, string Version, int Rank)>> FindPackagesWithAssemblyAsync (string source, string assemblyName, CancellationToken cancellationToken)
+		/// <summary>
+		/// Find packages for a given assembly name.
+		/// 
+		/// NOTE: This method is known to be called from the threadpool, while the UI thread is blocking.
+		/// Therefore, it must be thread-safe and not defer to and then block other threads.
+		/// </summary>
+		public Task<IEnumerable<(string PackageName, string Version, int Rank)>> FindPackagesWithAssemblyAsync (string source, string assemblyName, CancellationToken cancellationToken)
 		{
 			var result = new List<(string PackageName, string Version, int Rank)> ();
-			if (assemblyName == "System.ValueTuple" && await IsOfficialNuGetPackageSource (source).ConfigureAwait (false)) {
+			if (assemblyName == "System.ValueTuple" && IsOfficialNuGetPackageSource (source)) {
 				result.Add (("System.ValueTuple", "4.3.0", 1)); 
 			}
-			return result;
+			return Task.FromResult<IEnumerable<(string PackageName, string Version, int Rank)>> (result);
 		}
 
 		public Task<IEnumerable<(string PackageName, string TypeName, string Version, int Rank, ImmutableArray<string> ContainingNamespaceNames)>> FindPackagesWithTypeAsync (string source, string name, int arity, CancellationToken cancellationToken)
@@ -153,14 +159,22 @@ namespace MonoDevelop.PackageManagement.Refactoring
 			return Task.FromResult ((IEnumerable<(string AssemblyName, string TypeName, ImmutableArray<string> ContainingNamespaceNames)>)result);
 		}
 
+
+		/// <summary>
+		/// Get the installed versions of a given package.
+		/// 
+		/// NOTE: This method is known to be called from the threadpool, while the UI thread is blocking.
+		/// Therefore, it must be thread-safe and not defer to and then block other threads.
+		/// </summary>
 		public ImmutableArray<string> GetInstalledVersions (string packageName)
 		{
-			return Runtime.RunInMainThread (async delegate {
+			// The UI thread may already be blocking when this is called, so defer to threadpool instead of UI thread.
+			return Task.Run (async () => {
 				var solutionManager = PackageManagementServices.Workspace.GetSolutionManager (IdeApp.ProjectOperations.CurrentSelectedSolution);
 				var versions = await solutionManager.GetInstalledVersions (packageName).ConfigureAwait (false);
 				var versionStrings = versions.Select (version => version.ToFullString ()).ToArray ();
 				return ImmutableArray.Create (versionStrings);
-			}).WaitAndGetResult (default (CancellationToken));
+			}).WaitAndGetResult ();
 		}
 
 		public IEnumerable<Project> GetProjectsWithInstalledPackage (Solution solution, string packageName, string version)
@@ -198,19 +212,23 @@ namespace MonoDevelop.PackageManagement.Refactoring
 			return provider.GetRepositories ();
 		}
 
-		Task<bool> IsOfficialNuGetPackageSource (string source)
+		/// <summary>
+		/// Determine if a given source is the official nuget.org package source.
+		/// 
+		/// NOTE: This method is known to be called from the threadpool, while the UI thread is blocking.
+		/// Therefore, it must be thread-safe and not defer to and then block other threads.
+		/// </summary>
+		bool IsOfficialNuGetPackageSource (string source)
 		{
-			return Runtime.RunInMainThread (() => {
-				var matchedRepository = GetSourceRepositories ()
-					.FirstOrDefault (repository => repository.PackageSource.Name == source);
+			var matchedRepository = GetSourceRepositories ()
+				.FirstOrDefault (repository => repository.PackageSource.Name == source);
 
-				if (matchedRepository != null) {
-					string host = matchedRepository.PackageSource.SourceUri.Host;
-					return host.EndsWith ("nuget.org", StringComparison.OrdinalIgnoreCase);
-				}
+			if (matchedRepository != null) {
+				string host = matchedRepository.PackageSource.SourceUri.Host;
+				return host.EndsWith ("nuget.org", StringComparison.OrdinalIgnoreCase);
+			}
 
-				return false;
-			});
+			return false;
 		}
 	}
 }
diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests.Helpers/FakePackageSearchMetadata.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests.Helpers/FakePackageSearchMetadata.cs
index b6238b4b3f..51b3d14ad3 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests.Helpers/FakePackageSearchMetadata.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests.Helpers/FakePackageSearchMetadata.cs
@@ -75,6 +75,8 @@ namespace MonoDevelop.PackageManagement.Tests.Helpers
 
 		public LicenseMetadata LicenseMetadata { get; set; }
 
+		public Uri PackageDetailsUrl { get; set; }
+
 		public Task<IEnumerable<VersionInfo>> GetVersionsAsync ()
 		{
 			throw new NotImplementedException ();
diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests.Helpers/FakeProject.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests.Helpers/FakeProject.cs
index 8252531871..daaad6b346 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests.Helpers/FakeProject.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests.Helpers/FakeProject.cs
@@ -40,6 +40,7 @@ namespace MonoDevelop.PackageManagement.Tests.Helpers
 		public FilePath BaseIntermediateOutputPath { get; set; }

 		public ISolution ParentSolution { get; set; }

 		public IDictionary ExtendedProperties { get; set; }

+		public bool IsReevaluating { get; set; }

 

 		List<string> flavorGuids;

 

diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests.Helpers/TestableDotNetCoreNuGetProject.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests.Helpers/TestableDotNetCoreNuGetProject.cs
index 5d5c2b9fe6..019dc28b05 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests.Helpers/TestableDotNetCoreNuGetProject.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests.Helpers/TestableDotNetCoreNuGetProject.cs
@@ -39,9 +39,15 @@ namespace MonoDevelop.PackageManagement.Tests.Helpers
 
 		public bool IsSaved { get; set; }
 
+		public bool CallBaseSaveProject { get; set; }
+
 		public override Task SaveProject ()
 		{
 			IsSaved = true;
+
+			if (CallBaseSaveProject)
+				return base.SaveProject ();
+
 			return Task.FromResult (0);
 		}
 
diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests.csproj b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests.csproj
index 56d4affa52..25d8ffd69f 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests.csproj
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests.csproj
@@ -25,7 +25,7 @@
     <Reference Include="System.Net.Http" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="NuGet.PackageManagement" Version="5.0.2" PrivateAssets="runtime" />
+    <PackageReference Include="NuGet.PackageManagement" Version="5.1.0" PrivateAssets="runtime" />
     <PackageReference Include="Castle.Core" Version="4.2.1" PrivateAssets="runtime" />
     <PackageReference Include="Moq" Version="4.7.145" PrivateAssets="runtime" />
     <!-- Ensure .NET 4.7.2's System.Net.Http is used not the one from this NuGet package -->
diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests/DotNetCoreNuGetProjectTests.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests/DotNetCoreNuGetProjectTests.cs
index 27afa5accb..cee0d870dc 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests/DotNetCoreNuGetProjectTests.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests/DotNetCoreNuGetProjectTests.cs
@@ -28,6 +28,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using MonoDevelop.Core;
 using MonoDevelop.PackageManagement.Tests.Helpers;
 using MonoDevelop.Projects;
 using NuGet.Frameworks;
@@ -84,10 +85,15 @@ namespace MonoDevelop.PackageManagement.Tests
 
 		Task<bool> InstallPackageAsync (string packageId, string version)
 		{
+			var installationContext = CreateInstallationContext ();
+			return InstallPackageAsync (packageId, version, installationContext);
+		}
+
+		Task<bool> InstallPackageAsync (string packageId, string version, BuildIntegratedInstallationContext installationContext)
+		{
 			var packageIdentity = new PackageIdentity (packageId, NuGetVersion.Parse (version));
 			var versionRange = new VersionRange (packageIdentity.Version);
 
-			var installationContext = CreateInstallationContext ();
 			return project.InstallPackageAsync (packageId, versionRange, context, installationContext, CancellationToken.None);
 		}
 
@@ -353,7 +359,7 @@ namespace MonoDevelop.PackageManagement.Tests
 				Assert.AreEqual (projectFile, projectSpec.RestoreMetadata.ProjectPath);
 				Assert.AreEqual (projectFile, projectSpec.RestoreMetadata.ProjectUniqueName);
 				Assert.AreSame (projectSpec, dependencyGraphCacheContext.PackageSpecCache [projectFile]);
-				Assert.AreEqual ("bundlerminifier.core-netcoreapp2.2-[2.9.406, )", dotNetCliToolSpec.Name);
+				Assert.AreEqual ("bundlerminifier.core-netcoreapp2.1-[2.9.406, )", dotNetCliToolSpec.Name);
 				Assert.AreEqual (projectFile, dotNetCliToolSpec.RestoreMetadata.ProjectPath);
 				Assert.AreSame (dotNetCliToolSpec, dependencyGraphCacheContext.PackageSpecCache [dotNetCliToolSpec.Name]);
 			}
@@ -590,5 +596,222 @@ namespace MonoDevelop.PackageManagement.Tests
 			Assert.IsNull (dotNetCoreProject.MSBuildProject);
 			Assert.IsFalse (result);
 		}
+
+		[Test]
+		public async Task InstallPackageAsync_MultiTargetPartialInstall_PackageReferenceAddedWithCondition ()
+		{
+			CreateNuGetProject ();
+			FilePath projectDirectory = Util.CreateTmpDir ("MultiTargetInstallTest");
+			dotNetProject.FileName = projectDirectory.Combine ("MultiTargetTest.csproj");
+			project.CallBaseSaveProject = true;
+
+			var successfulFrameworks = new NuGetFramework[] {
+				NuGetFramework.Parse ("net472"),
+			};
+
+			var unsuccessfulFrameworks = new NuGetFramework [] {
+				NuGetFramework.Parse ("netstandard1.5")
+			};
+
+			var originalFrameworks = new Dictionary<NuGetFramework, string> ();
+
+			var installationContext = new BuildIntegratedInstallationContext (
+				successfulFrameworks,
+				unsuccessfulFrameworks,
+				originalFrameworks);
+
+			bool result = await InstallPackageAsync ("TestPackage", "2.6.1", installationContext);
+
+			var packageReference = dotNetProject
+				.MSBuildProject
+				.GetAllItems ()
+				.SingleOrDefault (item => item.Include == "TestPackage");
+
+			Assert.AreEqual ("'$(TargetFramework)' == 'net472'", packageReference.ParentGroup.Condition);
+			Assert.AreEqual ("2.6.1", packageReference.Metadata.GetValue ("Version"));
+			Assert.IsFalse (packageReference.Metadata.HasProperty ("IncludeAssets"));
+			Assert.IsFalse (packageReference.Metadata.HasProperty ("PrivateAssets"));
+			Assert.IsTrue (result);
+			Assert.IsTrue (project.IsSaved);
+		}
+
+		[Test]
+		public async Task InstallPackageAsync_MultiTargetPartialInstallNonStandardOriginalFramework_OriginalFrameworkUsedInCondition ()
+		{
+			CreateNuGetProject ();
+			FilePath projectDirectory = Util.CreateTmpDir ("MultiTargetInstallTest");
+			dotNetProject.FileName = projectDirectory.Combine ("MultiTargetTest.csproj");
+			project.CallBaseSaveProject = true;
+
+			var net472Framework = NuGetFramework.Parse ("net472");
+
+			var successfulFrameworks = new NuGetFramework [] {
+				net472Framework
+			};
+
+			var unsuccessfulFrameworks = new NuGetFramework [] {
+				NuGetFramework.Parse ("netstandard1.5")
+			};
+
+			var originalFrameworks = new Dictionary<NuGetFramework, string> ();
+			originalFrameworks [net472Framework] = ".NETFramework4.7.2";
+
+			var installationContext = new BuildIntegratedInstallationContext (
+				successfulFrameworks,
+				unsuccessfulFrameworks,
+				originalFrameworks);
+
+			bool result = await InstallPackageAsync ("TestPackage", "2.6.1", installationContext);
+
+			var packageReference = dotNetProject
+				.MSBuildProject
+				.GetAllItems ()
+				.SingleOrDefault (item => item.Include == "TestPackage");
+
+			Assert.AreEqual ("'$(TargetFramework)' == '.NETFramework4.7.2'", packageReference.ParentGroup.Condition);
+			Assert.AreEqual (packageReference.Metadata.GetValue ("Version"), "2.6.1");
+			Assert.IsTrue (result);
+			Assert.IsTrue (project.IsSaved);
+		}
+
+		[Test]
+		public async Task InstallPackageAsync_MultiTargetPartialInstallPrivateAndIncludeAssets_PackageReferenceHasAssetInfo ()
+		{
+			CreateNuGetProject ();
+			FilePath projectDirectory = Util.CreateTmpDir ("MultiTargetInstallTest");
+			dotNetProject.FileName = projectDirectory.Combine ("MultiTargetTest.csproj");
+			project.CallBaseSaveProject = true;
+
+			var successfulFrameworks = new NuGetFramework [] {
+				NuGetFramework.Parse ("net472"),
+			};
+
+			var unsuccessfulFrameworks = new NuGetFramework [] {
+				NuGetFramework.Parse ("netstandard1.5")
+			};
+
+			var originalFrameworks = new Dictionary<NuGetFramework, string> ();
+
+			var installationContext = new BuildIntegratedInstallationContext (
+				successfulFrameworks,
+				unsuccessfulFrameworks,
+				originalFrameworks);
+
+			installationContext.IncludeType = LibraryIncludeFlags.Runtime |
+				LibraryIncludeFlags.Build |
+				LibraryIncludeFlags.Native |
+				LibraryIncludeFlags.ContentFiles |
+				LibraryIncludeFlags.Analyzers;
+
+			installationContext.SuppressParent = LibraryIncludeFlags.All;
+
+			bool result = await InstallPackageAsync ("TestPackage", "2.6.1", installationContext);
+
+			var packageReference = dotNetProject
+				.MSBuildProject
+				.GetAllItems ()
+				.SingleOrDefault (item => item.Include == "TestPackage");
+
+			Assert.AreEqual ("'$(TargetFramework)' == 'net472'", packageReference.ParentGroup.Condition);
+			Assert.AreEqual ("2.6.1", packageReference.Metadata.GetValue ("Version"));
+			Assert.AreEqual ("runtime; build; native; contentfiles; analyzers", packageReference.Metadata.GetValue ("IncludeAssets"));
+			Assert.AreEqual ("all", packageReference.Metadata.GetValue ("PrivateAssets"));
+			Assert.IsTrue (result);
+			Assert.IsTrue (project.IsSaved);
+		}
+
+		[Test]
+		public async Task InstallPackageAsync_MultiTargetPartialInstallTwice_PackageReferenceAddedToSameItemGroup ()
+		{
+			CreateNuGetProject ();
+			FilePath projectDirectory = Util.CreateTmpDir ("MultiTargetInstallTest");
+			dotNetProject.FileName = projectDirectory.Combine ("MultiTargetTest.csproj");
+			project.CallBaseSaveProject = true;
+
+			var successfulFrameworks = new NuGetFramework [] {
+				NuGetFramework.Parse ("net472"),
+			};
+
+			var unsuccessfulFrameworks = new NuGetFramework [] {
+				NuGetFramework.Parse ("netstandard1.5")
+			};
+
+			var originalFrameworks = new Dictionary<NuGetFramework, string> ();
+
+			var installationContext = new BuildIntegratedInstallationContext (
+				successfulFrameworks,
+				unsuccessfulFrameworks,
+				originalFrameworks);
+
+			bool firstInstallResult = await InstallPackageAsync ("TestPackage", "2.6.1", installationContext);
+			var packageReference = dotNetProject
+				.MSBuildProject
+				.GetAllItems ()
+				.SingleOrDefault (item => item.Include == "TestPackage");
+
+			// Update.
+			bool result = await InstallPackageAsync ("AnotherTestPackage", "3.0.1", installationContext);
+
+			var secondPackageReference = dotNetProject
+				.MSBuildProject
+				.GetAllItems ()
+				.FirstOrDefault (item => item.Include == "AnotherTestPackage");
+
+			Assert.AreEqual ("'$(TargetFramework)' == 'net472'", packageReference.ParentGroup.Condition);
+			Assert.AreEqual ("2.6.1", packageReference.Metadata.GetValue ("Version"));
+			Assert.IsTrue (firstInstallResult);
+			Assert.AreEqual ("'$(TargetFramework)' == 'net472'", secondPackageReference.ParentGroup.Condition);
+			Assert.AreEqual ("3.0.1", secondPackageReference.Metadata.GetValue ("Version"));
+			Assert.AreEqual (packageReference.ParentGroup, secondPackageReference.ParentGroup);
+			Assert.IsTrue (result);
+			Assert.IsTrue (project.IsSaved);
+		}
+
+		[Test]
+		public async Task InstallPackageAsync_MultiTargetPartialUpdate_PackageReferenceUpdated ()
+		{
+			CreateNuGetProject ();
+			FilePath projectDirectory = Util.CreateTmpDir ("MultiTargetInstallTest");
+			dotNetProject.FileName = projectDirectory.Combine ("MultiTargetTest.csproj");
+			project.CallBaseSaveProject = true;
+
+			var successfulFrameworks = new NuGetFramework [] {
+				NuGetFramework.Parse ("net472"),
+			};
+
+			var unsuccessfulFrameworks = new NuGetFramework [] {
+				NuGetFramework.Parse ("netstandard1.5")
+			};
+
+			var originalFrameworks = new Dictionary<NuGetFramework, string> ();
+
+			var installationContext = new BuildIntegratedInstallationContext (
+				successfulFrameworks,
+				unsuccessfulFrameworks,
+				originalFrameworks);
+
+			bool firstInstallResult = await InstallPackageAsync ("TestPackage", "2.6.1", installationContext);
+
+			var packageReference = dotNetProject
+				.MSBuildProject
+				.GetAllItems ()
+				.SingleOrDefault (item => item.Include == "TestPackage");
+			Assert.AreEqual ("2.6.1", packageReference.Metadata.GetValue ("Version"));
+
+			bool result = await InstallPackageAsync ("TestPackage", "3.0.1", installationContext);
+
+			var updatedPackageReference = dotNetProject
+				.MSBuildProject
+				.GetAllItems ()
+				.FirstOrDefault (item => item.Include == "TestPackage");
+
+			Assert.AreEqual ("'$(TargetFramework)' == 'net472'", packageReference.ParentGroup.Condition);
+			Assert.AreEqual ("3.0.1", packageReference.Metadata.GetValue ("Version"));
+			Assert.IsTrue (firstInstallResult);
+			Assert.AreEqual ("'$(TargetFramework)' == 'net472'", updatedPackageReference.ParentGroup.Condition);
+			Assert.AreEqual ("3.0.1", updatedPackageReference.Metadata.GetValue ("Version"));
+			Assert.IsTrue (result);
+			Assert.IsTrue (project.IsSaved);
+		}
 	}
 }
diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests/PackageSourceViewModelTests.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests/PackageSourceViewModelTests.cs
index 7a4d32e87a..fed2ffadd6 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests/PackageSourceViewModelTests.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests/PackageSourceViewModelTests.cs
@@ -152,6 +152,24 @@ namespace MonoDevelop.PackageManagement.Tests
 			PackageSource updatedPackageSource = viewModel.GetPackageSource ();

 			Assert.IsTrue (updatedPackageSource.IsEnabled);

 		}

+

+		/// <summary>
+		/// This ensures that credentials can be saved to the NuGet.Config file with NuGet 5. Originally
+		/// the url was used which was then used as the element name in the packageSourceCredentials section.
+		/// </summary>

+		[Test]

+		public void Credentials_UserNameAndPasswordSet_CredentialsSourceUsesPackageSourceNameNotUrl ()
+		{
+			packageSource = new PackageSource ("https://nuget.org", "PackageSourceName");
+			CreateViewModel (packageSource);
+			viewModel.UserName = "UserName";
+			viewModel.Password = "Password";
+
+			PackageSource updatedPackageSource = viewModel.GetPackageSource ();
+
+			Assert.AreEqual ("PackageSourceName", updatedPackageSource.Credentials.Source);
+			Assert.AreEqual ("UserName", updatedPackageSource.Credentials.Username);
+		}

 	}

 }

 

diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests/ProjectTargetFrameworkMonitorTests.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests/ProjectTargetFrameworkMonitorTests.cs
index b4c9c976a6..ae76574408 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests/ProjectTargetFrameworkMonitorTests.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.Tests/MonoDevelop.PackageManagement.Tests/ProjectTargetFrameworkMonitorTests.cs
@@ -398,6 +398,20 @@ namespace MonoDevelop.PackageManagement.Tests
 

 			Assert.AreEqual (0, eventArgs.Count);

 		}

+

+		[Test]

+		public void ProjectTargetFrameworkChanged_ProjectIsReevaluating_EventDoesNotFire ()

+		{

+			CreateProjectTargetFrameworkMonitor ();

+			FakeDotNetProject project = LoadSolutionWithOneProject ();

+			CaptureProjectTargetFrameworkChangedEvents ();

+

+			project.IsReevaluating = true;

+			project.RaiseModifiedEvent (project, targetFrameworkPropertyName);

+			project.RaiseSavedEvent ();

+

+			Assert.AreEqual (0, eventArgs.Count);

+		}

 	}

 }

 

diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.addin.xml b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.addin.xml
index d3c12f8c7c..78d79d92b0 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.addin.xml
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.addin.xml
@@ -168,6 +168,7 @@
 

 	<Extension path="/MonoDevelop/ProjectModel/ProjectModelExtensions">

 		<Class class="MonoDevelop.PackageManagement.PackageManagementMSBuildExtension" />

+		<Class class="MonoDevelop.PackageManagement.PackageManagementSdkProjectExtension" />

 	</Extension>

 	<!--

 	<Extension path="/MonoDevelop/Refactoring/CodeDiagnosticProvider">

diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.csproj b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.csproj
index 115221ac63..e796284874 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.csproj
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement.csproj
@@ -26,8 +26,8 @@
     <Reference Include="System.ComponentModel.Composition" />
     <Reference Include="System.Runtime.Serialization" />
     <Reference Include="WindowsBase" />
-    <PackageReference Include="NuGet.PackageManagement" Version="5.0.2" PrivateAssets="runtime" />
-    <PackageReference Include="NuGet.Indexing" Version="5.0.2" PrivateAssets="runtime" />
+    <PackageReference Include="NuGet.PackageManagement" Version="5.1.0" PrivateAssets="runtime" />
+    <PackageReference Include="NuGet.Indexing" Version="5.1.0" PrivateAssets="runtime" />
     <!-- Ensure .NET 4.7.2's System.Net.Http is used not the one from this NuGet package -->
     <PackageReference Include="System.Net.Http" Version="4.3.3" ExcludeAssets="all" />
     <!-- Ensure .NET 4.7.2's System.IO.Compression is used not the one from this NuGet package -->
@@ -341,6 +341,12 @@
     <Compile Include="MonoDevelop.PackageManagement\ExceptionExtensions.cs" />
     <Compile Include="MonoDevelop.PackageManagement\DependencyGraphSpecExtensions.cs" />
     <Compile Include="MonoDevelop.PackageManagement\PackageSpecExtensions.cs" />
+    <Compile Include="MonoDevelop.PackageManagement\ConditionalPackageReferenceHandler.cs" />
+    <Compile Include="MonoDevelop.PackageManagement\IPropertySetExtensions.cs" />
+    <Compile Include="MonoDevelop.PackageManagement\PackageManagementSdkProjectExtension.cs" />
+    <Compile Include="MonoDevelop.PackageManagement\SdkProjectReloadMonitor.cs" />
+    <Compile Include="MonoDevelop.PackageManagement\SdkProjectBuilderMaintainer.cs" />
+    <Compile Include="MonoDevelop.PackageManagement\SdkProjectFileRenamedHandler.cs" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="MonoDevelop.PackageManagement.addin.xml" />
@@ -445,7 +451,6 @@
       <Link>NuGet-LICENSE.txt</Link>
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
-    <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
     <InternalsVisibleTo Include="MonoDevelop.DotNetCore" />
diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/ConditionalPackageReferenceHandler.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/ConditionalPackageReferenceHandler.cs
new file mode 100644
index 0000000000..d816d65dd6
--- /dev/null
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/ConditionalPackageReferenceHandler.cs
@@ -0,0 +1,126 @@
+//
+// ConditionalPackageReferenceHandler.cs
+//
+// Author:
+//       Matt Ward <matt.ward@microsoft.com>
+//
+// Copyright (c) 2019 Microsoft
+//
+// 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;
+using System.Linq;
+using MonoDevelop.Projects.MSBuild;
+using NuGet.Frameworks;
+using NuGet.LibraryModel;
+using NuGet.Packaging.Core;
+using NuGet.ProjectManagement;
+
+namespace MonoDevelop.PackageManagement
+{
+	class ConditionalPackageReferenceHandler : IDisposable
+	{
+		PackageIdentity packageIdentity;
+		INuGetProjectContext context;
+		BuildIntegratedInstallationContext installationContext;
+
+		public ConditionalPackageReferenceHandler ()
+		{
+			PackageManagementMSBuildExtension.ConditionalPackageReferenceHandler = this;
+		}
+
+		public void Dispose ()
+		{
+			PackageManagementMSBuildExtension.ConditionalPackageReferenceHandler = null;
+		}
+
+		public void AddConditionalPackageReference (
+			PackageIdentity packageIdentity,
+			INuGetProjectContext context,
+			BuildIntegratedInstallationContext installationContext)
+		{
+			this.packageIdentity = packageIdentity;
+			this.context = context;
+			this.installationContext = installationContext;
+		}
+
+		public void UpdateProject (MSBuildProject project)
+		{
+			foreach (NuGetFramework framework in installationContext.SuccessfulFrameworks) {
+
+				MSBuildItem packageReference = AddPackageReference (project, framework);
+
+				if (installationContext.IncludeType != LibraryIncludeFlags.All &&
+					installationContext.SuppressParent != LibraryIncludeFlagUtils.DefaultSuppressParent) {
+					packageReference.Metadata.SetMetadataValue (ProjectItemProperties.IncludeAssets, installationContext.IncludeType);
+					packageReference.Metadata.SetMetadataValue (ProjectItemProperties.PrivateAssets, installationContext.SuppressParent);
+				}
+			}
+		}
+
+		MSBuildItem AddPackageReference (MSBuildProject project, NuGetFramework framework)
+		{
+			string originalFramework;
+			if (!installationContext.OriginalFrameworks.TryGetValue (framework, out originalFramework)) {
+				originalFramework = framework.GetShortFolderName ();
+			}
+
+			MSBuildItemGroup itemGroup = GetOrAddItemGroup (project, originalFramework);
+			MSBuildItem packageReference = GetOrAddPackageReference (itemGroup);
+
+			packageReference.Metadata.SetValue ("Version", packageIdentity.Version.ToNormalizedString ());
+
+			return packageReference;
+		}
+
+		static MSBuildItemGroup GetOrAddItemGroup (MSBuildProject project, string originalFramework)
+		{
+			string condition = string.Format ("'$(TargetFramework)' == '{0}'", originalFramework);
+
+			MSBuildItemGroup itemGroup = project
+				.ItemGroups
+				.FirstOrDefault (item => StringComparer.OrdinalIgnoreCase.Equals (item.Condition, condition));
+
+			if (itemGroup == null) {
+				itemGroup = project.AddNewItemGroup ();
+				itemGroup.Condition = condition;
+			}
+
+			return itemGroup;
+		}
+
+		MSBuildItem GetOrAddPackageReference (MSBuildItemGroup itemGroup)
+		{
+			MSBuildItem packageReference = itemGroup
+				.Items
+				.FirstOrDefault (item => IsPackageReferenceMatch (item));
+
+			if (packageReference == null)
+				packageReference = itemGroup.AddNewItem ("PackageReference", packageIdentity.Id);
+
+			return packageReference;
+		}
+
+		bool IsPackageReferenceMatch (MSBuildItem item)
+		{
+			return item.Name == "PackageReference" &&
+				StringComparer.OrdinalIgnoreCase.Equals (item.Include, packageIdentity.Id);
+		}
+	}
+}
diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/DotNetCoreNuGetProject.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/DotNetCoreNuGetProject.cs
index d59cf2783b..960a0d69ed 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/DotNetCoreNuGetProject.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/DotNetCoreNuGetProject.cs
@@ -161,6 +161,10 @@ namespace MonoDevelop.PackageManagement
 		{
 			var packageIdentity = new PackageIdentity (packageId, range.MinVersion);
 
+			if (installationContext.SuccessfulFrameworks.Any () && installationContext.UnsuccessfulFrameworks.Any ()) {
+				return await AddConditionalPackageReference (packageIdentity, nuGetProjectContext, installationContext);
+			}
+
 			bool added = await Runtime.RunInMainThread (() => {
 				return AddPackageReference (packageIdentity, nuGetProjectContext, installationContext);
 			});
@@ -172,6 +176,18 @@ namespace MonoDevelop.PackageManagement
 			return added;
 		}
 
+		async Task<bool> AddConditionalPackageReference (
+			PackageIdentity packageIdentity,
+			INuGetProjectContext context,
+			BuildIntegratedInstallationContext installationContext)
+		{
+			using (var handler = new ConditionalPackageReferenceHandler ()) {
+				handler.AddConditionalPackageReference (packageIdentity, context, installationContext);
+				await SaveProject ();
+			}
+			return true;
+		}
+
 		bool AddPackageReference (PackageIdentity packageIdentity, INuGetProjectContext context, BuildIntegratedInstallationContext installationContext)
 		{
 			ProjectPackageReference packageReference = project.GetPackageReference (packageIdentity, matchVersion: false);
diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/DotNetProjectExtensions.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/DotNetProjectExtensions.cs
index 96d1fbc177..dcc1d5a80b 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/DotNetProjectExtensions.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/DotNetProjectExtensions.cs
@@ -212,17 +212,6 @@ namespace MonoDevelop.PackageManagement
 			return File.Exists (assetsFile);

 		}

 

-		public static bool DotNetCoreNuGetMSBuildFilesExist (this DotNetProject project)

-		{

-			var baseDirectory = project.BaseIntermediateOutputPath;

-			string projectFileName = project.FileName.FileName;

-			string propsFileName = baseDirectory.Combine (projectFileName + ".nuget.g.props");

-			string targetsFileName = baseDirectory.Combine (projectFileName + ".nuget.g.targets");

-

-			return File.Exists (propsFileName) &&

-				File.Exists (targetsFileName);

-		}

-

 		/// <summary>

 		/// If a NuGet package is installed into a .NET Core project then all .NET Core projects that

 		/// reference this project need to have their reference information updated. This allows the

diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/FilePathExtensions.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/FilePathExtensions.cs
index 2172dd2c29..17aad70c6d 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/FilePathExtensions.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/FilePathExtensions.cs
@@ -64,6 +64,11 @@ namespace MonoDevelop.PackageManagement
 

 			return IsPackagesConfigFileName (filePath) || IsProjectJsonFileName (filePath);

 		}

+

+		public static bool HasSupportedDotNetCoreProjectFileExtension (this FilePath file)

+		{

+			return file.HasExtension (".csproj") || file.HasExtension (".fsproj") || file.HasExtension (".vbproj");

+		}

 	}

 }

 

diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/IProject.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/IProject.cs
index 64003896e4..29b72d440f 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/IProject.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/IProject.cs
@@ -42,6 +42,7 @@ namespace MonoDevelop.PackageManagement
 		IDictionary ExtendedProperties { get; }

 		IEnumerable<string> FlavorGuids { get; }

 		IMSBuildEvaluatedPropertyCollection EvaluatedProperties { get; }

+		bool IsReevaluating { get; }

 

 		Task SaveAsync ();

 	}

diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/IPropertySetExtensions.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/IPropertySetExtensions.cs
new file mode 100644
index 0000000000..2d3c00bf7d
--- /dev/null
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/IPropertySetExtensions.cs
@@ -0,0 +1,41 @@
+//
+// IPropertySetExtensions.cs
+//
+// Author:
+//       Matt Ward <matt.ward@microsoft.com>
+//
+// Copyright (c) 2019 Microsoft
+//
+// 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 MonoDevelop.Projects;
+using NuGet.Common;
+using NuGet.LibraryModel;
+
+namespace MonoDevelop.PackageManagement
+{
+	static class IPropertySetExtensions
+	{
+		internal static void SetMetadataValue (this IPropertySet propertySet, string name, LibraryIncludeFlags flags)
+		{
+			string value = MSBuildStringUtility.Convert (LibraryIncludeFlagUtils.GetFlagString (flags));
+			propertySet.SetValue (name, value);
+		}
+	}
+}
diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/PackageManagementMSBuildExtension.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/PackageManagementMSBuildExtension.cs
index 01d38693b3..cda0c14427 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/PackageManagementMSBuildExtension.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/PackageManagementMSBuildExtension.cs
@@ -38,6 +38,7 @@ namespace MonoDevelop.PackageManagement
 		public static EnsureNuGetPackageBuildImportsTargetUpdater Updater;

 		public static NuGetPackageNewImportsHandler NewImportsHandler;

 		public static NuGetPackageForcedImportsRemover ForcedImportsRemover;

+		public static ConditionalPackageReferenceHandler ConditionalPackageReferenceHandler;

 		public static Task PackageRestoreTask;

 

 		protected override void OnWriteProject (ProgressMonitor monitor, MSBuildProject msproject)

@@ -62,6 +63,11 @@ namespace MonoDevelop.PackageManagement
 			if (importsHandler != null) {

 				importsHandler.UpdateProject (msproject);

 			}

+

+			ConditionalPackageReferenceHandler packageReferenceHandler = ConditionalPackageReferenceHandler;

+			if (packageReferenceHandler != null) {

+				packageReferenceHandler.UpdateProject (msproject);

+			}

 		}

 

 		protected override Task<BuildResult> OnBuild (ProgressMonitor monitor, ConfigurationSelector configuration, OperationContext operationContext)
diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/PackageManagementSdkProjectExtension.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/PackageManagementSdkProjectExtension.cs
new file mode 100644
index 0000000000..b41dcc9dcf
--- /dev/null
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/PackageManagementSdkProjectExtension.cs
@@ -0,0 +1,190 @@
+//
+// PackageManagementSdkProjectExtension.cs
+//
+// Author:
+//       Matt Ward <matt.ward@microsoft.com>
+//
+// Copyright (c) 2019 Microsoft
+//
+// 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.Linq;
+using System.Threading.Tasks;
+using MonoDevelop.Core;
+using MonoDevelop.Ide;
+using MonoDevelop.PackageManagement.Commands;
+using MonoDevelop.Projects;
+
+namespace MonoDevelop.PackageManagement
+{
+	class PackageManagementSdkProjectExtension : SdkProjectExtension
+	{
+		bool itemReady;
+
+		public PackageManagementSdkProjectExtension ()
+		{
+			SdkProjectReloadMonitor.Initialize ();
+		}
+
+		protected override void OnItemReady ()
+		{
+			base.OnItemReady ();
+			itemReady = true;
+
+			if (IdeApp.IsInitialized)
+				PackageManagementServices.ProjectTargetFrameworkMonitor.ProjectTargetFrameworkChanged += ProjectTargetFrameworkChanged;
+		}
+
+		public override void Dispose ()
+		{
+			if (IdeApp.IsInitialized)
+				PackageManagementServices.ProjectTargetFrameworkMonitor.ProjectTargetFrameworkChanged -= ProjectTargetFrameworkChanged;
+
+			base.Dispose ();
+		}
+
+		/// <summary>
+		/// This event is fired after the project is saved. Runs a restore if the project was
+		/// not reloaded.
+		/// </summary>
+		void ProjectTargetFrameworkChanged (object sender, ProjectTargetFrameworkChangedEventArgs e)
+		{
+			if (e.IsReload || e.Project.Name != Project.Name) {
+				// Ignore. A restore will occur on reload elsewhere.
+				return;
+			}
+
+			// Need to re-evaluate before restoring to ensure the implicit package references are correct after
+			// the target framework has changed.
+			RestorePackagesInProjectHandler.Run (Project, restoreTransitiveProjectReferences: true, reevaluateBeforeRestore: true);
+		}
+
+		protected override void OnModified (SolutionItemModifiedEventArgs args)
+		{
+			base.OnModified (args);
+
+			if (Project.Loading || !itemReady)
+				return;
+
+			var fileNameChange = args.LastOrDefault (arg => arg.Hint == "FileName");
+			if (fileNameChange != null) {
+				SdkProjectFileRenamedHandler.OnProjectFileRenamed (Project);
+			}
+		}
+
+		/// <summary>
+		/// Handle a new project being created and added to a new solution. In this case
+		/// the NuGet packages should be restored. Need to avoid running a restore when
+		/// a solution is being opened so check that project's parent solution is open in
+		/// the IDE.
+		/// </summary>
+		protected override void OnBoundToSolution ()
+		{
+			base.OnBoundToSolution ();
+
+			if (Project.Loading)
+				return;
+
+			if (!IdeApp.IsInitialized)
+				return;
+
+			if (IdeApp.ProjectOperations.CurrentSelectedSolution != Project.ParentSolution)
+				return;
+
+			if (!Project.NuGetAssetsFileExists ())
+				RestorePackagesInProjectHandler.Run (Project);
+		}
+
+		BuildResult CreateNuGetRestoreRequiredBuildResult ()
+		{
+			return CreateBuildError (GettextCatalog.GetString ("NuGet packages need to be restored before building. NuGet MSBuild targets are missing and are needed for building. The NuGet MSBuild targets are generated when the NuGet packages are restored."));
+		}
+
+		BuildResult CreateBuildError (string message)
+		{
+			var result = new BuildResult ();
+			result.SourceTarget = Project;
+			result.AddError (message);
+			return result;
+		}
+
+		protected override Task<BuildResult> OnClean (ProgressMonitor monitor, ConfigurationSelector configuration, OperationContext operationContext)
+		{
+			BuildResult result = CheckCanRunCleanOrBuild ();
+			if (result != null) {
+				return Task.FromResult (result);
+			}
+			return base.OnClean (monitor, configuration, operationContext);
+		}
+
+		protected override Task<BuildResult> OnBuild (ProgressMonitor monitor, ConfigurationSelector configuration, OperationContext operationContext)
+		{
+			BuildResult result = CheckCanRunCleanOrBuild ();
+			if (result != null) {
+				return Task.FromResult (result);
+			}
+			return base.OnBuild (monitor, configuration, operationContext);
+		}
+
+		BuildResult CheckCanRunCleanOrBuild ()
+		{
+			if (!Project.NuGetAssetsFileExists ()) {
+				return CreateNuGetRestoreRequiredBuildResult ();
+			}
+			return null;
+		}
+
+		/// <summary>
+		/// Shared projects can trigger a reference change during re-evaluation so do not
+		/// restore if the project is being re-evaluated. Otherwise this could cause the
+		/// restore to be run repeatedly.
+		/// </summary>
+		protected override void OnReferenceAddedToProject (ProjectReferenceEventArgs e)
+		{
+			base.OnReferenceAddedToProject (e);
+
+			if (!IsLoadingOrReevaluating ())
+				RestoreNuGetPackages ();
+		}
+
+		/// <summary>
+		/// Shared projects can trigger a reference change during re-evaluation so do not
+		/// restore if the project is being re-evaluated. Otherwise this could cause the
+		/// restore to be run repeatedly.
+		/// </summary>
+		protected override void OnReferenceRemovedFromProject (ProjectReferenceEventArgs e)
+		{
+			base.OnReferenceRemovedFromProject (e);
+
+			if (!IsLoadingOrReevaluating ())
+				RestoreNuGetPackages ();
+		}
+
+		bool IsLoadingOrReevaluating ()
+		{
+			return Project.Loading || Project.IsReevaluating;
+		}
+
+		void RestoreNuGetPackages ()
+		{
+			Runtime.AssertMainThread ();
+			RestorePackagesInProjectHandler.Run (Project);
+		}
+	}
+}
diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/PackageSourceViewModel.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/PackageSourceViewModel.cs
index 5db63d2494..04a4f53dfc 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/PackageSourceViewModel.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/PackageSourceViewModel.cs
@@ -63,7 +63,7 @@ namespace MonoDevelop.PackageManagement
 		{

 			if (HasUserName () || HasPassword ()) {

 				return PackageSourceCredential.FromUserInput (

-					Source,

+					Name,

 					UserName ?? string.Empty,

 					Password ?? string.Empty,

 					storePasswordInClearText: false,
diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/ProjectPackageReference.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/ProjectPackageReference.cs
index 92a0c7481d..21ce4693a4 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/ProjectPackageReference.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/ProjectPackageReference.cs
@@ -157,8 +157,7 @@ namespace MonoDevelop.PackageManagement
 
 		internal void SetMetadataValue (string name, LibraryIncludeFlags flags)
 		{
-			string value = MSBuildStringUtility.Convert (LibraryIncludeFlagUtils.GetFlagString (flags));
-			Metadata.SetValue (name, value);
+			Metadata.SetMetadataValue (name, flags);
 		}
 	}
 }
diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/ProjectProxy.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/ProjectProxy.cs
index 28487b190d..28ad624105 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/ProjectProxy.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/ProjectProxy.cs
@@ -74,6 +74,10 @@ namespace MonoDevelop.PackageManagement
 			get { return project.MSBuildProject?.EvaluatedProperties; }

 		}

 

+		public bool IsReevaluating {
+			get { return project.IsReevaluating; }
+		}

+

 		public async Task SaveAsync ()

 		{

 			using (var monitor = new ProgressMonitor ()) {

diff --git a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/ProjectTargetFrameworkMonitor.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/ProjectTargetFrameworkMonitor.cs
index dc7332d648..f38eac52d4 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/ProjectTargetFrameworkMonitor.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/ProjectTargetFrameworkMonitor.cs
@@ -108,6 +108,16 @@ namespace MonoDevelop.PackageManagement
 

 		void ProjectModified (object sender, ProjectModifiedEventArgs e)

 		{

+			if (e.Project.IsReevaluating) {
+				// Ignore target framework changes if the project is re-evaluating. We are only
+				// interested in target framework changes made by the user in project options
+				// or when editing the project file.
+				// Sdk style Xamarin.Mac projects sometimes switch the target framework from
+				// .NET to Xamarin.Mac during re-evaluation. The XamMac2ProjectFlavor may change
+				// the target framework when the project file is reloaded during re-evaluation.
+				return;
+			}

+

 			if (e.IsTargetFramework ()) {

 				e.Project.Saved += ProjectSaved;

 			}

diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreProjectBuilderMaintainer.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/SdkProjectBuilderMaintainer.cs
index 6d2e63c70d..6a23554120 100644
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreProjectBuilderMaintainer.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/SdkProjectBuilderMaintainer.cs
@@ -1,5 +1,5 @@
 //
-// DotNetCoreProjectBuilderMaintainer.cs
+// SdkProjectBuilderMaintainer.cs
 //
 // Author:
 //       Matt Ward <matt.ward@xamarin.com>
@@ -25,13 +25,12 @@
 // THE SOFTWARE.
 
 using System.Collections.Generic;
-using MonoDevelop.PackageManagement;
-using MonoDevelop.Projects;
 using System.Linq;
+using MonoDevelop.Projects;
 
-namespace MonoDevelop.DotNetCore
+namespace MonoDevelop.PackageManagement
 {
-	class DotNetCoreProjectBuilderMaintainer
+	class SdkProjectBuilderMaintainer
 	{
 		/// <summary>
 		/// If the target framework of the project has changed then non .NET Core projects
@@ -43,22 +42,22 @@ namespace MonoDevelop.DotNetCore
 		public static void OnProjectReload (ProjectReloadedEventArgs reloadEventArgs)
 		{
 			var reloadedProject = reloadEventArgs.NewProject.DotNetProject;
-			foreach (var project in GetAllNonDotNetCoreProjectsReferencingProject (reloadedProject)) {
+			foreach (var project in GetAllNonSdkProjectsReferencingProject (reloadedProject)) {
 				project.ReloadProjectBuilder ();
 			}
 		}
 
-		static IEnumerable<DotNetProject> GetAllNonDotNetCoreProjects (Solution parentSolution)
+		static IEnumerable<DotNetProject> GetAllNonSdkProjects (Solution parentSolution)
 		{
 			return parentSolution.GetAllDotNetProjects ()
-				.Where (project => !project.HasFlavor<DotNetCoreProjectExtension> ());
+				.Where (project => !project.HasFlavor<SdkProjectExtension> ());
 		}
 
-		static IEnumerable<DotNetProject> GetAllNonDotNetCoreProjectsReferencingProject (DotNetProject dotNetCoreProject)
+		static IEnumerable<DotNetProject> GetAllNonSdkProjectsReferencingProject (DotNetProject dotNetCoreProject)
 		{
-			foreach (DotNetProject project in GetAllNonDotNetCoreProjects (dotNetCoreProject.ParentSolution)) {
+			foreach (DotNetProject project in GetAllNonSdkProjects (dotNetCoreProject.ParentSolution)) {
 				foreach (ProjectReference projectReference in project.References) {
-					if (projectReference.IsProjectReference ()) {
+					if (projectReference.ReferenceType == ReferenceType.Project) {
 						Project resolvedProject = projectReference.ResolveProject (project.ParentSolution);
 						if (resolvedProject == dotNetCoreProject) {
 							yield return project;
diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreProjectFileRenamedHandler.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/SdkProjectFileRenamedHandler.cs
index 526274188a..0aac2f1a5e 100644
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreProjectFileRenamedHandler.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/SdkProjectFileRenamedHandler.cs
@@ -1,5 +1,5 @@
 //
-// DotNetCoreProjectFileRenamedHandler.cs
+// SdkProjectFileRenamedHandler.cs
 //
 // Author:
 //       Matt Ward <matt.ward@xamarin.com>
@@ -25,12 +25,11 @@
 // THE SOFTWARE.
 
 using MonoDevelop.Projects;
-using MonoDevelop.PackageManagement;
 using MonoDevelop.PackageManagement.Commands;
 
-namespace MonoDevelop.DotNetCore
+namespace MonoDevelop.PackageManagement
 {
-	static class DotNetCoreProjectFileRenamedHandler
+	static class SdkProjectFileRenamedHandler
 	{
 		public static void OnProjectFileRenamed (DotNetProject project)
 		{
diff --git a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreProjectReloadMonitor.cs b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/SdkProjectReloadMonitor.cs
index 637d0a6f84..10ce5ea9e3 100644
--- a/main/src/addins/MonoDevelop.DotNetCore/MonoDevelop.DotNetCore/DotNetCoreProjectReloadMonitor.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/MonoDevelop.PackageManagement/SdkProjectReloadMonitor.cs
@@ -1,5 +1,5 @@
 //
-// DotNetCoreProjectReloadMonitor.cs
+// SdkProjectReloadMonitor.cs
 //
 // Author:
 //       Matt Ward <matt.ward@xamarin.com>
@@ -30,17 +30,16 @@ using System.Linq;
 using System.Threading.Tasks;
 using MonoDevelop.Core;
 using MonoDevelop.Ide;
-using MonoDevelop.PackageManagement;
 using MonoDevelop.PackageManagement.Commands;
 using MonoDevelop.Projects;
 
-namespace MonoDevelop.DotNetCore
+namespace MonoDevelop.PackageManagement
 {
-	class DotNetCoreProjectReloadMonitor
+	class SdkProjectReloadMonitor
 	{
-		static readonly DotNetCoreProjectReloadMonitor monitor = new DotNetCoreProjectReloadMonitor ();
+		static readonly SdkProjectReloadMonitor reloadMonitor = new SdkProjectReloadMonitor ();
 
-		DotNetCoreProjectReloadMonitor ()
+		SdkProjectReloadMonitor ()
 		{
 			if (IdeApp.IsInitialized) {
 				PackageManagementServices.ProjectService.ProjectReloaded += ProjectReloaded;
@@ -56,26 +55,26 @@ namespace MonoDevelop.DotNetCore
 		{
 			Runtime.AssertMainThread ();
 			try {
-				if (IsDotNetCoreProjectReloaded (e.NewProject)) {
-					OnDotNetCoreProjectReloaded (e);
+				if (IsSdkProjectReloaded (e.NewProject)) {
+					OnSdkProjectReloaded (e);
 				}
 			} catch (Exception ex) {
 				LoggingService.LogError ("DotNetCoreProjectReloadMonitor error", ex);
 			}
 		}
 
-		bool IsDotNetCoreProjectReloaded (IDotNetProject project)
+		bool IsSdkProjectReloaded (IDotNetProject project)
 		{
 			// Ignore reloads when NuGet package restore is running.
 			if (PackageManagementServices.BackgroundPackageActionRunner.IsRunning)
 				return false;
 
-			return project.DotNetProject.HasFlavor<DotNetCoreProjectExtension> ();
+			return project.DotNetProject.HasFlavor<SdkProjectExtension> ();
 		}
 
-		void OnDotNetCoreProjectReloaded (ProjectReloadedEventArgs e)
+		void OnSdkProjectReloaded (ProjectReloadedEventArgs e)
 		{
-			DotNetCoreProjectBuilderMaintainer.OnProjectReload (e);
+			SdkProjectBuilderMaintainer.OnProjectReload (e);
 			RestorePackagesInProjectHandler.Run (e.NewProject.DotNetProject, restoreTransitiveProjectReferences: true);
 		}
 
@@ -144,7 +143,7 @@ namespace MonoDevelop.DotNetCore
 			using (ProgressMonitor monitor = IdeApp.Workbench.ProgressMonitors.GetProjectLoadProgressMonitor (true)) {
 				foreach (var project in projectsToReload) {
 					var reloadedProject = (await project.ParentFolder.ReloadItem (monitor, project)) as DotNetProject;
-					if (reloadedProject != null && reloadedProject.HasFlavor<DotNetCoreProjectExtension> ()) {
+					if (reloadedProject != null && reloadedProject.HasFlavor<SdkProjectExtension> ()) {
 						reloadedProjects.Add (reloadedProject);
 					}
 				}
diff --git a/main/src/addins/MonoDevelop.PackageManagement/NuGet.PackageManagement.UI/MultiSourcePackageFeed.cs b/main/src/addins/MonoDevelop.PackageManagement/NuGet.PackageManagement.UI/MultiSourcePackageFeed.cs
index 0bbfac51d0..ce7ce482b5 100644
--- a/main/src/addins/MonoDevelop.PackageManagement/NuGet.PackageManagement.UI/MultiSourcePackageFeed.cs
+++ b/main/src/addins/MonoDevelop.PackageManagement/NuGet.PackageManagement.UI/MultiSourcePackageFeed.cs
@@ -239,18 +239,29 @@ namespace NuGet.PackageManagement.UI
 			if (_logger == null)

 			{

 				// observe the task exception when no UI logger provided.

-				Trace.WriteLine(ExceptionUtilities.DisplayMessage(task.Exception));

+				Trace.WriteLine(DisplayMessage(task.Exception));

 				return;

 			}

 

 			// UI logger only can be engaged from the main thread

 			MonoDevelop.Core.Runtime.RunInMainThread(() =>

 			{

-				var errorMessage = ExceptionUtilities.DisplayMessage(task.Exception);

+				var errorMessage = DisplayMessage(task.Exception);

 				_logger.Log(

 					ProjectManagement.MessageLevel.Error,

 					$"[{state.ToString()}] {errorMessage}");

-			});

+			}).Ignore();

+		}

+

+		static string DisplayMessage(Exception ex)
+		{

+			string errorMessage = ExceptionUtilities.DisplayMessage(ex);

+

+			// NSUrlSessionHandler exceptions contain curly braces {} in the UserInfo part of the message so

+			// to avoid a FormatException we need to escape these.

+			return errorMessage

+				.Replace("{", "{{")

+				.Replace("}", "}}");

 		}

 	}

 }

diff --git a/main/src/addins/MonoDevelop.Packaging/MonoDevelop.Packaging/ProjectHasNuGetMetadataCondition.cs b/main/src/addins/MonoDevelop.Packaging/MonoDevelop.Packaging/ProjectHasNuGetMetadataCondition.cs
index 4271fc2ca9..a1ff5c467a 100644
--- a/main/src/addins/MonoDevelop.Packaging/MonoDevelop.Packaging/ProjectHasNuGetMetadataCondition.cs
+++ b/main/src/addins/MonoDevelop.Packaging/MonoDevelop.Packaging/ProjectHasNuGetMetadataCondition.cs
@@ -25,6 +25,7 @@
 // THE SOFTWARE.
 
 using Mono.Addins;
+using MonoDevelop.Core;
 using MonoDevelop.Ide;
 using MonoDevelop.Projects;
 
@@ -34,12 +35,12 @@ namespace MonoDevelop.Packaging
 	{
 		public ProjectHasNuGetMetadataCondition ()
 		{
-			IdeApp.ProjectOperations.CurrentProjectChanged += delegate { NotifyChanged (); };
+			Runtime.ServiceProvider.WhenServiceInitialized<ProjectOperations> ((s) => s.CurrentProjectChanged += delegate { NotifyChanged (); });
 		}
 
 		public override bool Evaluate (NodeElement conditionNode)
 		{
-			var project = IdeApp.ProjectOperations.CurrentSelectedProject as DotNetProject;
+			var project = Runtime.ServiceProvider.PeekService<ProjectOperations> ()?.CurrentSelectedProject as DotNetProject;
 			if (project is PackagingProject) {
 				return true;
 			} else if (project != null) {
diff --git a/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.AnalysisCore/Gui/ResultsEditorExtension.cs b/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.AnalysisCore/Gui/ResultsEditorExtension.cs
index 3db1c4740a..36398008a6 100644
--- a/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.AnalysisCore/Gui/ResultsEditorExtension.cs
+++ b/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.AnalysisCore/Gui/ResultsEditorExtension.cs
@@ -259,20 +259,26 @@ namespace MonoDevelop.AnalysisCore.Gui
 		}
 
 		const int MaxCacheSize = 10;
-		Queue<List<IGenericTextSegmentMarker>> listCache = new Queue<List<IGenericTextSegmentMarker>> ();
+		readonly Queue<List<IGenericTextSegmentMarker>> listCache = new Queue<List<IGenericTextSegmentMarker>> ();
+		readonly object listCacheLock = new object ();
 
 		List<IGenericTextSegmentMarker> GetCachedList ()
 		{
-			if (listCache.Count == 0)
-				return new List<IGenericTextSegmentMarker> ();
-			return listCache.Dequeue ();
+			lock (listCacheLock) {
+				if (listCache.Count == 0)
+					return new List<IGenericTextSegmentMarker> ();
+				return listCache.Dequeue () ?? new List<IGenericTextSegmentMarker> ();
+			}
 		}
 
 		void PutBackCachedList (List<IGenericTextSegmentMarker> list)
 		{
-			list.Clear ();
-			if (listCache.Count < MaxCacheSize)
-				listCache.Enqueue (list);
+			lock (listCacheLock) {
+				if (listCache.Count < MaxCacheSize) {
+					list.Clear ();
+					listCache.Enqueue (list);
+				}
+			}
 		}
 
 		class ResultsUpdater
@@ -285,11 +291,11 @@ namespace MonoDevelop.AnalysisCore.Gui
 			List<IGenericTextSegmentMarker> oldMarkers;
 
 			int curResult = 0;
-			IReadOnlyList<Result> results;
+			readonly IReadOnlyList<Result> results;
 
-			List<IGenericTextSegmentMarker> newMarkers;
-			ImmutableArray<QuickTask>.Builder builder;
-			object id;
+			readonly List<IGenericTextSegmentMarker> newMarkers;
+			readonly ImmutableArray<QuickTask>.Builder builder;
+			readonly object id;
 
 			public ResultsUpdater (ResultsEditorExtension ext, IReadOnlyList<Result> results, object resultsId, CancellationToken cancellationToken)
 			{
@@ -308,13 +314,17 @@ namespace MonoDevelop.AnalysisCore.Gui
 				builder = ImmutableArray<QuickTask>.Empty.ToBuilder ();
 				this.results = results;
 				newMarkers = ext.GetCachedList ();
-				Debug.Assert (newMarkers != null);
 			}
 
 			public void Update ()
 			{
 				if (cancellationToken.IsCancellationRequested)
 					return;
+				if (newMarkers == null) {
+					// should never happen.
+					LoggingService.LogError ("Error in ResultsEditorExtension : newMarkers == null.");
+					return;
+				}
 				if (id != null)
 					lock (ext.tasks) {
 						ext.tasks.Remove (id);
diff --git a/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.AnalysisCore/MonoDevelopWorkspaceDiagnosticAnalyzerProviderService.cs b/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.AnalysisCore/MonoDevelopWorkspaceDiagnosticAnalyzerProviderService.cs
index ab7b58b896..42a457c36c 100644
--- a/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.AnalysisCore/MonoDevelopWorkspaceDiagnosticAnalyzerProviderService.cs
+++ b/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.AnalysisCore/MonoDevelopWorkspaceDiagnosticAnalyzerProviderService.cs
@@ -87,7 +87,7 @@ namespace MonoDevelop.AnalysisCore
 						//addin assemblies that reference roslyn
 						default:
 							var refAsm = asm.GetReferencedAssemblies ();
-							if (refAsm.Any (a => a.Name == diagnosticAnalyzerAssembly) && refAsm.Any (a => a.Name == "MonoDevelop.Ide"))
+							if (refAsm.Any (a => a.Name == diagnosticAnalyzerAssembly))
 								break;
 							continue;
 						}
diff --git a/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.CodeActions/CodeActionEditorExtension.cs b/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.CodeActions/CodeActionEditorExtension.cs
index 3da12a678e..e175ef29fc 100644
--- a/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.CodeActions/CodeActionEditorExtension.cs
+++ b/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.CodeActions/CodeActionEditorExtension.cs
@@ -145,6 +145,12 @@ namespace MonoDevelop.CodeActions
 			return Task.Run (async delegate {
 				try {
 					var root = await ad.GetSyntaxRootAsync (cancellationToken);
+					if (root == null) {
+						// WebEditorRoslynWorkspace adds .json, .css, .html etc. files to the workspace
+						// but they don't support syntax trees or semantic model
+						return CodeActionContainer.Empty;
+					}
+
 					if (root.Span.End < span.End) {
 						LoggingService.LogError ($"Error in GetCurrentFixesAsync span {span.Start}/{span.Length} not inside syntax root {root.Span.End} document length {Editor.Length}.");
 						return CodeActionContainer.Empty;
diff --git a/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.Refactoring.SignatureChange/SignatureChangeOptionService.cs b/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.Refactoring.SignatureChange/SignatureChangeOptionService.cs
index 20fcc0982e..f4744d9adc 100644
--- a/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.Refactoring.SignatureChange/SignatureChangeOptionService.cs
+++ b/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.Refactoring.SignatureChange/SignatureChangeOptionService.cs
@@ -50,7 +50,7 @@ namespace MonoDevelop.Refactoring.SignatureChange
 
 				return new ChangeSignatureOptionsResult {
 					IsCancelled = false,
-					UpdatedSignature = new Microsoft.CodeAnalysis.ChangeSignature.SignatureChange (parameters, ParameterConfiguration.Create (dialog.ParameterList, parameters.ThisParameter != null))
+					UpdatedSignature = new Microsoft.CodeAnalysis.ChangeSignature.SignatureChange (parameters, ParameterConfiguration.Create (dialog.ParameterList, parameters.ThisParameter != null, -1))
 				};
 			} catch (Exception ex) {
 				LoggingService.LogError ("Error while signature changing.", ex);
diff --git a/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.Refactoring.addin.xml b/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.Refactoring.addin.xml
index 48ee77a37a..d23ffc5f7b 100644
--- a/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.Refactoring.addin.xml
+++ b/main/src/addins/MonoDevelop.Refactoring/MonoDevelop.Refactoring.addin.xml
@@ -1,3 +1,4 @@
+
 <ExtensionModel>
 	<Runtime>
 		<Import assembly="RefactoringEssentials.dll" />
@@ -62,6 +63,11 @@
 				 		shortcut="Ctrl|F12"
 				 		macShortcut=""/>
 			
+		<Command id = "MonoDevelop.Refactoring.Navigate.GotoBaseMember"
+				 		_label = "Go to Base Member"
+				 		shortcut=""
+				 		macShortcut=""/>
+			
 		<Command id = "MonoDevelop.Refactoring.RefactoryCommands.FindReferences"
 					_label = "_Find References" 
 					shortcut = "Shift|F12"
diff --git a/main/src/addins/MonoDevelop.SourceEditor2/Mono.TextEditor/Gui/MonoTextEditor.ITextView.cs b/main/src/addins/MonoDevelop.SourceEditor2/Mono.TextEditor/Gui/MonoTextEditor.ITextView.cs
index b023ce67f4..61f7ca3b4a 100644
--- a/main/src/addins/MonoDevelop.SourceEditor2/Mono.TextEditor/Gui/MonoTextEditor.ITextView.cs
+++ b/main/src/addins/MonoDevelop.SourceEditor2/Mono.TextEditor/Gui/MonoTextEditor.ITextView.cs
@@ -405,8 +405,7 @@ namespace Mono.TextEditor
 		/// </remarks>

 		private void SubscribeToEvents ()

 		{

-			if (IdeApp.IsInitialized)

-				IdeApp.Workbench.ActiveDocumentChanged += Workbench_ActiveDocumentChanged;

+			IdeServices.DocumentManager.ActiveDocumentChanged += Workbench_ActiveDocumentChanged;

 		}

 

 		void Workbench_ActiveDocumentChanged (object sender, EventArgs e)

@@ -416,8 +415,7 @@ namespace Mono.TextEditor
 

 		private void UnsubscribeFromEvents ()

 		{

-			if (IdeApp.IsInitialized)

-				IdeApp.Workbench.ActiveDocumentChanged -= Workbench_ActiveDocumentChanged;

+			IdeServices.DocumentManager.ActiveDocumentChanged -= Workbench_ActiveDocumentChanged;

 		}

 

 		static readonly string[] allowedTextViewCreationListeners = {

@@ -498,7 +496,7 @@ namespace Mono.TextEditor
 #endif

 

 			if (!isClosed) {

-				bool newHasAggregateFocus = ((IdeApp.Workbench.ActiveDocument?.Editor?.Implementation as MonoDevelop.SourceEditor.SourceEditorView)?.TextEditor == this);

+				bool newHasAggregateFocus = ((IdeServices.DocumentManager.ActiveDocument?.Editor?.Implementation as MonoDevelop.SourceEditor.SourceEditorView)?.TextEditor == this);

 				if (newHasAggregateFocus != hasAggregateFocus) {

 					hasAggregateFocus = newHasAggregateFocus;

 

diff --git a/main/src/addins/MonoDevelop.SourceEditor2/Mono.TextEditor/Gui/TextViewMargin.cs b/main/src/addins/MonoDevelop.SourceEditor2/Mono.TextEditor/Gui/TextViewMargin.cs
index 2d4fbecaed..6754d0b0ce 100644
--- a/main/src/addins/MonoDevelop.SourceEditor2/Mono.TextEditor/Gui/TextViewMargin.cs
+++ b/main/src/addins/MonoDevelop.SourceEditor2/Mono.TextEditor/Gui/TextViewMargin.cs
@@ -138,18 +138,11 @@ namespace Mono.TextEditor
 
 			public TextViewMarginAccessibilityProxy ()
 			{
-				Accessible = AccessibilityElementProxy.TextElementProxy ();
-				Accessible.Contents = GetContents;
-				Accessible.InsertionPointLineNumber = GetInsertionPointLineNumber;
-				Accessible.NumberOfCharacters = GetNumberOfCharacters;
-				Accessible.FrameForRange = GetFrameForRange;
-				Accessible.LineForIndex = GetLineForIndex;
-				Accessible.RangeForLine = GetRangeForLine;
-				Accessible.StringForRange = GetStringForRange;
-				Accessible.RangeForIndex = GetRangeForIndex;
-				Accessible.StyleRangeForIndex = GetStyleRangeForIndex;
-				Accessible.RangeForPosition = GetRangeForPosition;
-				Accessible.GetVisibleCharacterRange = GetVisibleCharacterRange;
+#if MAC
+				Accessible = AccessibilityElementProxy.TextElementProxy (GetContents, GetNumberOfCharacters, GetInsertionPointLineNumber, GetFrameForRange, GetLineForIndex, GetRangeForLine, GetStringForRange, GetRangeForIndex, GetStyleRangeForIndex, GetRangeForPosition, GetVisibleCharacterRange);
+#else
+				Accessible = AccessibilityElementProxy.TextElementProxy();
+#endif
 			}
 
 			public void Dispose ()
@@ -1168,8 +1161,8 @@ namespace Mono.TextEditor
 								if (textEditor.preeditOffset < end)
 									end += (int)preeditLength;
 							}
-							var si = TranslateToUTF8Index (lineText, (uint)(startIndex + start - chunk.Offset), ref curIndex, ref byteIndex);
-							var ei = TranslateToUTF8Index (lineText, (uint)(startIndex + end - chunk.Offset), ref curIndex, ref byteIndex);
+							var si = TranslateToUTF8Index (lineText, (uint)Math.Min (startIndex + start - chunk.Offset, lineText.Length), ref curIndex, ref byteIndex);
+							var ei = TranslateToUTF8Index (lineText, (uint)Math.Min (startIndex + end - chunk.Offset, lineText.Length), ref curIndex, ref byteIndex);
 							var color = (Cairo.Color)EditorTheme.GetForeground (chunkStyle);
 							foreach (var marker in markers) {
 								var chunkMarker = marker as IChunkMarker;
@@ -1200,8 +1193,8 @@ namespace Mono.TextEditor
 								if (textEditor.preeditOffset < end)
 									end += (int)preeditLength;
 							}
-							var si = TranslateToUTF8Index (lineText, (uint)(startIndex + start - chunk.Offset), ref curIndex, ref byteIndex);
-							var ei = TranslateToUTF8Index (lineText, (uint)(startIndex + end - chunk.Offset), ref curIndex, ref byteIndex);
+							var si = TranslateToUTF8Index (lineText, (uint)Math.Min (startIndex + start - chunk.Offset, lineText.Length), ref curIndex, ref byteIndex);
+							var ei = TranslateToUTF8Index (lineText, (uint)Math.Min (startIndex + end - chunk.Offset, lineText.Length), ref curIndex, ref byteIndex);
 							var color = (Cairo.Color)EditorTheme.GetForeground (chunkStyle);
 							foreach (var marker in markers) {
 								var chunkMarker = marker as IChunkMarker;
@@ -1216,8 +1209,8 @@ namespace Mono.TextEditor
 							wrapper.SelectionEndIndex = (int)ei;
 						});
 
-						var translatedStartIndex = TranslateToUTF8Index (lineText, (uint)startIndex, ref curChunkIndex, ref byteChunkIndex);
-						var translatedEndIndex = TranslateToUTF8Index (lineText, (uint)endIndex, ref curChunkIndex, ref byteChunkIndex);
+						var translatedStartIndex = TranslateToUTF8Index (lineText, (uint)Math.Min (startIndex, lineText.Length), ref curChunkIndex, ref byteChunkIndex);
+						var translatedEndIndex = TranslateToUTF8Index (lineText, (uint)Math.Min (endIndex, lineText.Length), ref curChunkIndex, ref byteChunkIndex);
 
 						if (chunkStyle.FontWeight != Xwt.Drawing.FontWeight.Normal)
 							atts.AddWeightAttribute ((Pango.Weight)chunkStyle.FontWeight, translatedStartIndex, translatedEndIndex);
@@ -1231,8 +1224,8 @@ namespace Mono.TextEditor
 				}
 				if (containsPreedit) {
 					var byteLength = Encoding.UTF8.GetByteCount (textEditor.preeditString);
-					var si = TranslateToUTF8Index (lineText, (uint)(textEditor.preeditOffset - offset), ref curIndex, ref byteIndex);
-					var ei = TranslateToUTF8Index (lineText, (uint)(textEditor.preeditOffset - offset + byteLength), ref curIndex, ref byteIndex);
+					var si = TranslateToUTF8Index (lineText, (uint)Math.Min (textEditor.preeditOffset - offset, lineText.Length), ref curIndex, ref byteIndex);
+					var ei = TranslateToUTF8Index (lineText, (uint)Math.Min (textEditor.preeditOffset - offset + byteLength, lineText.Length), ref curIndex, ref byteIndex);
 
 					if (textEditor.GetTextEditorData ().IsCaretInVirtualLocation) {
 						uint len = (uint)textEditor.GetTextEditorData ().GetIndentationString (textEditor.Caret.Location).Length;
diff --git a/main/src/addins/MonoDevelop.SourceEditor2/MonoDevelop.SourceEditor/SourceEditorView.cs b/main/src/addins/MonoDevelop.SourceEditor2/MonoDevelop.SourceEditor/SourceEditorView.cs
index bcc0972ace..fcebf8dd30 100644
--- a/main/src/addins/MonoDevelop.SourceEditor2/MonoDevelop.SourceEditor/SourceEditorView.cs
+++ b/main/src/addins/MonoDevelop.SourceEditor2/MonoDevelop.SourceEditor/SourceEditorView.cs
@@ -1,4 +1,4 @@
-// SourceEditorView.cs
+// SourceEditorView.cs
 //
 // Author:
 //   Mike Krüger <mkrueger@novell.com>
@@ -87,6 +87,7 @@ namespace MonoDevelop.SourceEditor
 		bool writeAccessChecked;
 		TaskService taskService;
 		TextEditorService textEditorService;
+		CodeTemplateToolboxProvider codeTemplateToolboxProvider;
 
 		internal BreakpointStore Breakpoints => breakpoints;
 
@@ -343,6 +344,7 @@ namespace MonoDevelop.SourceEditor
 		{
 			Document.FileName = ContentName;
 			UpdateMimeType (Document.FileName);
+			codeTemplateToolboxProvider = new CodeTemplateToolboxProvider (contentName);
 			ContentNameChanged?.Invoke (this, EventArgs.Empty);
 		}
 
@@ -862,6 +864,9 @@ namespace MonoDevelop.SourceEditor
 				RunFirstTimeFoldUpdate (text);
 				*/
 			Document.InformLoadComplete ();
+
+			// Now that the editor has been completely loaded, ask ITextView to update the aggregated focus status
+			widget.TextEditor.QueueAggregateFocusCheck ();
 		}
 
 		protected virtual string ProcessLoadText (string text)
@@ -2417,6 +2422,8 @@ namespace MonoDevelop.SourceEditor
 			var c = GetContent (type);
 			if (c != null)
 				yield return c;
+			if (type == typeof (IToolboxDynamicProvider) && codeTemplateToolboxProvider != null)
+				yield return codeTemplateToolboxProvider;
 		}
 
 		#region widget command handlers
@@ -3424,6 +3431,12 @@ namespace MonoDevelop.SourceEditor
 			return TextEditor.GetLineHeight (line);
 		}
 
+		void ITextEditorImpl.SetNotDirtyState ()
+		{
+			TextEditor.Document.SetNotDirtyState ();
+		}
+
+
 		public bool DeleteDynamicItem (ItemToolboxNode node) => ClipboardRingService.DeleteItem (node);
 
 		public bool CanDeleteDynamicItem (ItemToolboxNode node) => ClipboardRingService.GetToolboxItems ().Contains (node);
@@ -3438,7 +3451,7 @@ namespace MonoDevelop.SourceEditor
 
 		public bool IsDirty {
 			get => isDirty;
-			private set {
+			set {
 				if (isDirty != value) {
 					isDirty = value;
 					DirtyChanged?.Invoke (this, EventArgs.Empty);
diff --git a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/CocoaTextViewContent.cs b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/CocoaTextViewContent.cs
index 309a6d14b2..39afc1a5fb 100644
--- a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/CocoaTextViewContent.cs
+++ b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/CocoaTextViewContent.cs
@@ -20,22 +20,21 @@
 // THE SOFTWARE.
 
 using System;
+using System.Collections.Generic;
 using System.ComponentModel.Composition;
-
 using AppKit;
-using ObjCRuntime;
-
 using Microsoft.CodeAnalysis.Classification;
 using Microsoft.VisualStudio.Text.Classification;
 using Microsoft.VisualStudio.Text.Editor;
 using Microsoft.VisualStudio.Utilities;
-
 using MonoDevelop.Components;
 using MonoDevelop.Core;
 using MonoDevelop.Core.FeatureConfiguration;
+using MonoDevelop.DesignerSupport.Toolbox;
+using MonoDevelop.Ide;
 using MonoDevelop.Ide.Commands;
-using MonoDevelop.Projects;
 using MonoDevelop.Ide.Gui.Documents;
+using ObjCRuntime;
 
 namespace MonoDevelop.TextEditor
 {
@@ -69,7 +68,9 @@ namespace MonoDevelop.TextEditor
 		}
 	}
 
-	class CocoaTextViewContent : TextViewContent<ICocoaTextView, CocoaTextViewImports>
+	class CocoaTextViewContent :
+		TextViewContent<ICocoaTextView, CocoaTextViewImports>,
+		IToolboxDynamicProvider
 	{
 		ICocoaTextViewHost textViewHost;
 		NSView textViewHostControl;
@@ -78,6 +79,8 @@ namespace MonoDevelop.TextEditor
 		static readonly Lazy<bool> useLegacyGtkNSViewHost = new Lazy<bool> (
 			() => FeatureSwitchService.IsFeatureEnabled ("LegacyGtkNSViewHost").GetValueOrDefault ());
 
+		public event EventHandler ItemsChanged;
+
 		abstract class GtkNSViewHostControl : Control
 		{
 			public Gtk.Widget GtkView { get; protected set; }
@@ -207,10 +210,15 @@ namespace MonoDevelop.TextEditor
 			}
 
 			TextView.Properties.AddProperty (typeof (Gtk.Widget), embeddedControl.GtkView);
-
+			TextBuffer.ContentTypeChanged += TextBuffer_ContentTypeChanged;
 			return embeddedControl;
 		}
 
+		private void TextBuffer_ContentTypeChanged (object sender, Microsoft.VisualStudio.Text.ContentTypeChangedEventArgs e)
+		{
+			ItemsChanged?.Invoke (this, EventArgs.Empty);
+		}
+
 		protected override void OnGrabFocus (DocumentView view)
 		{
 			embeddedControl.GrabFocus ();
@@ -219,8 +227,9 @@ namespace MonoDevelop.TextEditor
 
 		protected override void OnDispose ()
 		{
+			if (TextBuffer != null)
+				TextBuffer.ContentTypeChanged -= TextBuffer_ContentTypeChanged;
 			base.OnDispose ();
-
 			if (textViewHost != null) {
 				textViewHost.Close ();
 				textViewHost = null;
@@ -261,6 +270,20 @@ namespace MonoDevelop.TextEditor
 			}
 		}
 
+		static string category = GettextCatalog.GetString ("Text Snippets");
+		public IEnumerable<ItemToolboxNode> GetDynamicItems (IToolboxConsumer consumer)
+		{
+			var contentType = TextView?.TextBuffer?.ContentType;
+			if (contentType == null)
+				yield break;
+			foreach (var template in Imports.ExpansionManager.EnumerateExpansions (contentType, false, null, true, false)) {
+				yield return new SnippetToolboxNode (template) {
+					Category = category,
+					Icon = ImageService.GetIcon ("md-template", Gtk.IconSize.Menu)
+				};
+			}
+		}
+
 		sealed class TextFinderAction : Foundation.NSObject, INSValidatedUserInterfaceItem
 		{
 			public static readonly TextFinderAction ShowFindInterface
diff --git a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/CocoaTextViewImports.cs b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/CocoaTextViewImports.cs
index beda56eaa0..31dbfc7df9 100644
--- a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/CocoaTextViewImports.cs
+++ b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/CocoaTextViewImports.cs
@@ -21,6 +21,7 @@
 

 using System.ComponentModel.Composition;
 using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Text.Editor.Expansion;
 
 namespace MonoDevelop.TextEditor
 {
@@ -29,5 +30,8 @@ namespace MonoDevelop.TextEditor
 	{
 		[Import]
 		public ICocoaTextEditorFactoryService TextEditorFactoryService { get; set; }
+
+		[Import]
+		public IExpansionManager ExpansionManager { get; set; }
 	}
 }
\ No newline at end of file
diff --git a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/MonoDevelop.TextEditor.Cocoa.csproj b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/MonoDevelop.TextEditor.Cocoa.csproj
index fd118c89ff..9fadf1562f 100644
--- a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/MonoDevelop.TextEditor.Cocoa.csproj
+++ b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/MonoDevelop.TextEditor.Cocoa.csproj
@@ -64,24 +64,32 @@
     <ProjectReference Include="$(VSEditorCoreDirectory)src\Editor\Text\Impl\GlyphMargin\GlyphMarginImpl.csproj" Private="True" />
     <ProjectReference Include="$(VSEditorCoreDirectory)src\Editor\Text\Impl\Structure\StructureImpl.csproj" Private="true" />
     <ProjectReference Include="$(VSEditorCoreDirectory)src\Editor\Text\Impl\UrlTagger\UrlTagger.csproj" Private="true" />
+    <ProjectReference Include="$(VSEditorCoreDirectory)src\Editor\Text\Impl\DragDrop\DragDropImpl.csproj" Private="True" />
+    <ProjectReference Include="$(VSEditorCoreDirectory)src\Editor\Text\Impl\ChangeTagger\ChangeTagger.csproj" Private="True" />
+    <Reference Include="MonoDevelop.DesignerSupport">
+      <HintPath>..\..\..\..\build\AddIns\MonoDevelop.DesignerSupport\MonoDevelop.DesignerSupport.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
   </ItemGroup>
   <ItemGroup>
     <IncludeCopyLocal Include="Microsoft.CodeAnalysis.EditorFeatures.Cocoa.dll" />
     <IncludeCopyLocal Include="Microsoft.VisualStudio.Language.NavigateTo.Interfaces.dll" />
-		<IncludeCopyLocal Include="Microsoft.VisualStudio.Logic.Text.Navigation.NavigationProviders.dll" />
+    <IncludeCopyLocal Include="Microsoft.VisualStudio.Logic.Text.Navigation.NavigationProviders.dll" />
     <IncludeCopyLocal Include="Microsoft.VisualStudio.UI.Controls.macOS.dll" />
-		<IncludeCopyLocal Include="Microsoft.VisualStudio.Text.Find.Implementation.dll" />
-		<IncludeCopyLocal Include="Microsoft.VisualStudio.Language.StandardClassification.Implementation.dll" />
-		<IncludeCopyLocal Include="Microsoft.VisualStudio.Text.Formatting.RtfBuilderService.Implementation.dll" />
-		<IncludeCopyLocal Include="Microsoft.VisualStudio.Text.Structure.dll" />
-		<IncludeCopyLocal Include="Microsoft.VisualStudio.UI.Text.AdornmentLibrary.ToolTip.Implementation.dll" />
-		<IncludeCopyLocal Include="Microsoft.VisualStudio.UI.Text.Cocoa.View.Implementation.dll" />
-		<IncludeCopyLocal Include="Microsoft.VisualStudio.UI.Text.TextAndAdornmentSequencer.Implementation.dll" />
-		<IncludeCopyLocal Include="Microsoft.VisualStudio.UI.Text.Wpf.Classification.Implementation.dll" />
-		<IncludeCopyLocal Include="Microsoft.VisualStudio.UI.Text.Wpf.GlyphMargin.Implementation.dll" />
-		<IncludeCopyLocal Include="Microsoft.VisualStudio.UI.Text.AdornmentLibrary.VisibleWhitespace.Implementation.dll" />
-		<IncludeCopyLocal Include="Microsoft.VisualStudio.UI.Text.CurrentLineHighlighter.Implementation.dll" />
-		<IncludeCopyLocal Include="Microsoft.VisualStudio.Logic.Text.UrlTagger.Implementation.dll" />
+    <IncludeCopyLocal Include="Microsoft.VisualStudio.Text.Find.Implementation.dll" />
+    <IncludeCopyLocal Include="Microsoft.VisualStudio.Language.StandardClassification.Implementation.dll" />
+    <IncludeCopyLocal Include="Microsoft.VisualStudio.Text.Formatting.RtfBuilderService.Implementation.dll" />
+    <IncludeCopyLocal Include="Microsoft.VisualStudio.Text.Structure.dll" />
+    <IncludeCopyLocal Include="Microsoft.VisualStudio.UI.Text.AdornmentLibrary.ToolTip.Implementation.dll" />
+    <IncludeCopyLocal Include="Microsoft.VisualStudio.UI.Text.Cocoa.View.Implementation.dll" />
+    <IncludeCopyLocal Include="Microsoft.VisualStudio.UI.Text.TextAndAdornmentSequencer.Implementation.dll" />
+    <IncludeCopyLocal Include="Microsoft.VisualStudio.UI.Text.Wpf.Classification.Implementation.dll" />
+    <IncludeCopyLocal Include="Microsoft.VisualStudio.UI.Text.Wpf.GlyphMargin.Implementation.dll" />
+    <IncludeCopyLocal Include="Microsoft.VisualStudio.UI.Text.AdornmentLibrary.VisibleWhitespace.Implementation.dll" />
+    <IncludeCopyLocal Include="Microsoft.VisualStudio.UI.Text.CurrentLineHighlighter.Implementation.dll" />
+    <IncludeCopyLocal Include="Microsoft.VisualStudio.Logic.Text.UrlTagger.Implementation.dll" />
+    <IncludeCopyLocal Include="Microsoft.VisualStudio.UI.Text.Cocoa.DragDrop.Implementation.dll" />
+    <IncludeCopyLocal Include="Microsoft.VisualStudio.Logic.Text.ChangeTagger.Implementation.dll" />
   </ItemGroup>
   <ItemGroup>
     <None Remove="icons\vs-find-replace-close-16.png" />
diff --git a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/Properties/MonoDevelop.TextEditor.Cocoa.addin.xml b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/Properties/MonoDevelop.TextEditor.Cocoa.addin.xml
index 42dfacd78c..dde25b78b0 100644
--- a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/Properties/MonoDevelop.TextEditor.Cocoa.addin.xml
+++ b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/Properties/MonoDevelop.TextEditor.Cocoa.addin.xml
@@ -1,4 +1,4 @@
-<ExtensionModel>
+<ExtensionModel>
 	<Runtime>
 		<Import assembly="../../../bin/Microsoft.VisualStudio.CoreUtilityImplementation.dll" />
 		<Import assembly="../../../bin/Microsoft.VisualStudio.Language.Implementation.dll" />
@@ -44,6 +44,8 @@
 		<Assembly file="Microsoft.VisualStudio.UI.Text.TextAndAdornmentSequencer.Implementation.dll" />
 		<Assembly file="Microsoft.VisualStudio.UI.Text.Wpf.Classification.Implementation.dll" />
 		<Assembly file="Microsoft.VisualStudio.UI.Text.Wpf.GlyphMargin.Implementation.dll" />
+		<Assembly file="Microsoft.VisualStudio.UI.Text.Cocoa.DragDrop.Implementation.dll" />
+		<Assembly file="Microsoft.VisualStudio.Logic.Text.ChangeTagger.Implementation.dll" />
 		<Assembly file="MonoDevelop.TextEditor.Cocoa.dll" />
 		<!-- these are coming from vs-editor-core (Cocoa implementations) -->
 		<Assembly file="../../../bin/Microsoft.VisualStudio.CoreUtilityImplementation.dll" />
@@ -87,5 +89,7 @@
 		<Map id="MonoDevelop.Ide.Commands.SearchCommands.FindNext" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.FindNextCommandArgs" />
 		<Map id="MonoDevelop.Ide.Commands.SearchCommands.FindPrevious" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.FindPreviousCommandArgs" />
 		<Map id="MonoDevelop.Ide.Commands.SearchCommands.Replace" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.ReplaceCommandArgs" />
+		<Map id="MonoDevelop.Refactoring.Navigate.GotoBaseMember" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.Navigation.GoToBaseMemberCommandArgs" />
+		<Map id="MonoDevelop.Ide.Commands.SearchCommands.GotoLineNumber" argsType="Microsoft.VisualStudio.Text.Extras.GoToLine.GoToLineCommandArgs" />
 	</Extension>
 </ExtensionModel>
\ No newline at end of file
diff --git a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/SnippetsInToolbox/SnippetToolboxNode.cs b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/SnippetsInToolbox/SnippetToolboxNode.cs
new file mode 100644
index 0000000000..5c20af6d02
--- /dev/null
+++ b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Cocoa/SnippetsInToolbox/SnippetToolboxNode.cs
@@ -0,0 +1,75 @@
+using System;
+using System.ComponentModel;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Text.Editor.Commanding;
+using Microsoft.VisualStudio.Text.Editor.Commanding.Commands;
+using Microsoft.VisualStudio.Text.Editor.Expansion;
+using MonoDevelop.Core;
+using MonoDevelop.DesignerSupport.Toolbox;
+using MonoDevelop.Ide.CodeTemplates;
+using MonoDevelop.Ide.Composition;
+using MonoDevelop.Ide.Gui;
+
+namespace MonoDevelop.TextEditor
+{
+	[Serializable]
+	public class SnippetToolboxNode : ItemToolboxNode, ITextToolboxNode
+	{
+		static IExpansionServiceProvider expansionServiceProvider = CompositionManager.Instance.GetExportedValue<IExpansionServiceProvider> ();
+		static IEditorCommandHandlerServiceFactory commandDispatchFactory = CompositionManager.Instance.GetExportedValue<IEditorCommandHandlerServiceFactory> ();
+
+		public override string Name {
+			get {
+				return Template.Snippet.Shortcut;
+			}
+			set {
+				Template.Snippet.Shortcut = value;
+			}
+		}
+
+		public override string Description {
+			get {
+				return Template.Snippet.Description;
+			}
+			set {
+				Template.Snippet.Description = value;
+			}
+		}
+
+		public string Code {
+			get { return Template.Snippet.Code; }
+			set { Template.Snippet.Code = value; }
+		}
+
+		public ExpansionTemplate Template { get; set; }
+
+		public string GetDragPreview (Document document)
+		{
+			return Template.Snippet.Shortcut;
+		}
+
+		public bool IsCompatibleWith (Document document)
+		{
+			return true;
+		}
+
+		public void InsertAtCaret (Document document)
+		{
+			var textView = document.GetContent<ITextView> ();
+			textView.Properties.AddProperty (typeof (ExpansionTemplate), Template);
+			try {
+				commandDispatchFactory.GetService (textView).Execute ((t, b) => new InsertSnippetCommandArgs (t, b), null);
+			} finally {
+				textView.Properties.RemoveProperty (typeof (ExpansionTemplate));
+			}
+			((ICocoaTextView) textView).VisualElement.Window?.MakeKeyWindow ();
+		}
+
+		public SnippetToolboxNode (ExpansionTemplate template)
+		{
+			this.Template = template;
+			ItemFilters.Add (new ToolboxItemFilterAttribute ("text/plain", ToolboxItemFilterType.Allow));
+		}
+	}
+}
diff --git a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Wpf/MonoDevelop.TextEditor.Wpf.csproj b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Wpf/MonoDevelop.TextEditor.Wpf.csproj
index 5824ff02ac..b170f100d4 100644
--- a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Wpf/MonoDevelop.TextEditor.Wpf.csproj
+++ b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Wpf/MonoDevelop.TextEditor.Wpf.csproj
@@ -30,6 +30,7 @@
   <ItemGroup>
     <IncludeCopyLocal Include="DiagnosticMargin.dll" />
     <IncludeCopyLocal Include="Microsoft.VisualStudio.Text.Extras.dll" />
+    <IncludeCopyLocal Include="Microsoft.VisualStudio.InteractiveWindow.dll" />
   </ItemGroup>
   <ItemGroup>
     <Page Include="**\*.xaml">
diff --git a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Wpf/Properties/MonoDevelop.TextEditor.Wpf.addin.xml b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Wpf/Properties/MonoDevelop.TextEditor.Wpf.addin.xml
index 8048c10499..0d5f5e5df1 100644
--- a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Wpf/Properties/MonoDevelop.TextEditor.Wpf.addin.xml
+++ b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor.Wpf/Properties/MonoDevelop.TextEditor.Wpf.addin.xml
@@ -1,6 +1,7 @@
 <ExtensionModel>
 	<Runtime>
 		<Import assembly="MonoDevelop.TextEditor.Wpf.dll"/>
+		<Import assembly="../../../bin/Microsoft.VisualStudio.InteractiveWindow.dll" />
 		<Import assembly="../../../bin/Microsoft.VisualStudio.Language.NavigateTo.Interfaces.dll" />
 		<Import assembly="../../../bin/Microsoft.VisualStudio.Text.Internal.dll" />
 		<Import assembly="Microsoft.VisualStudio.Text.Extras.dll" />
diff --git a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/Properties/MonoDevelop.TextEditor.addin.xml b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/Properties/MonoDevelop.TextEditor.addin.xml
index f2c8641b30..7f0ce20b6f 100644
--- a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/Properties/MonoDevelop.TextEditor.addin.xml
+++ b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/Properties/MonoDevelop.TextEditor.addin.xml
@@ -1,4 +1,4 @@
-<ExtensionModel>
+<ExtensionModel>
 	<!-- Extension points -->
 
 	<ExtensionPoint path = "/MonoDevelop/TextEditor/ContextMenu/Editor" name = "Editor context menu">
@@ -52,7 +52,42 @@
 		<Assembly file="MonoDevelop.TextEditor.dll"/>
 	</Extension>
 
+	<Extension path="/MonoDevelop/Ide/Commands">
+		<Category _name="Text Editor" id="TextEditor">
+			<Command id="MonoDevelop.Ide.Commands.TextEditorCommands.InsertNextMatchingCaret"
+					_label="Insert next matching caret"
+					shortcut="Shift+Alt+."
+					macShortcut="Shift+Alt+."/>
+			<Command id="MonoDevelop.Ide.Commands.TextEditorCommands.InsertAllMatchingCarets"
+					_label="Insert carets at all matching"
+					shortcut="Shift+Alt+;"
+					macShortcut="Shift+Alt+;"/>
+			<Command id="MonoDevelop.Ide.Commands.TextEditorCommands.RemoveLastSecondaryCaret"
+					_label="Remove last caret"
+					shortcut="Shift+Alt+,"
+					macShortcut="Shift+Alt+,"/>
+			<Command id="MonoDevelop.Ide.Commands.TextEditorCommands.MoveLastCaretDown"
+					_label="Move last caret down"
+					shortcut="Shift+Alt+/"
+					macShortcut="Shift+Alt+/"/>
+			<Command id="MonoDevelop.Ide.Commands.TextEditorCommands.RotatePrimaryCaretNext"
+					_label="Rotate primary caret down"
+					shortcut=""
+					macShortcut=""/>
+			<Command id="MonoDevelop.Ide.Commands.TextEditorCommands.RotatePrimaryCaretPrevious"
+					_label="Rotate primary caret up"
+					shortcut=""
+					macShortcut=""/>
+		</Category>
+	</Extension>
+
 	<Extension path = "/MonoDevelop/TextEditor/CommandMapping">
+		<Map id="MonoDevelop.Ide.Commands.TextEditorCommands.InsertAllMatchingCarets" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.InsertAllMatchingCaretsCommandArgs"/>
+		<Map id="MonoDevelop.Ide.Commands.TextEditorCommands.InsertNextMatchingCaret" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.InsertNextMatchingCaretCommandArgs"/>
+		<Map id="MonoDevelop.Ide.Commands.TextEditorCommands.RemoveLastSecondaryCaret" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.RemoveLastSecondaryCaretCommandArgs"/>
+		<Map id="MonoDevelop.Ide.Commands.TextEditorCommands.MoveLastCaretDown" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.MoveLastCaretDownCommandArgs"/>
+		<Map id="MonoDevelop.Ide.Commands.TextEditorCommands.RotatePrimaryCaretNext" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.RotatePrimaryCaretNextCommandArgs"/>
+		<Map id="MonoDevelop.Ide.Commands.TextEditorCommands.RotatePrimaryCaretPrevious" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.RotatePrimaryCaretPreviousCommandArgs"/>
 		<Map id="MonoDevelop.Ide.Commands.EditCommands.Copy" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.CopyCommandArgs" />
 		<Map id="MonoDevelop.Ide.Commands.EditCommands.Cut" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.CutCommandArgs" />
 		<Map id="MonoDevelop.Ide.Commands.EditCommands.Paste" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.PasteCommandArgs" />
@@ -63,7 +98,7 @@
 
 		<Map id="MonoDevelop.Ide.Commands.EditCommands.AddCodeComment" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.CommentSelectionCommandArgs" />
 		<Map id="MonoDevelop.Ide.Commands.EditCommands.RemoveCodeComment" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.UncommentSelectionCommandArgs" />
-		<Map id="MonoDevelop.Ide.Commands.EditCommands.ToggleCodeComment" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.ToggleCommentSelectionCommandArgs" />
+		<Map id="MonoDevelop.Ide.Commands.EditCommands.ToggleCodeComment" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.ToggleLineCommentCommandArgs" />
 
 		<Map id="MonoDevelop.Ide.Commands.TextEditorCommands.InsertTab" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.TabKeyCommandArgs" />
 		<Map id="MonoDevelop.Ide.Commands.TextEditorCommands.RemoveTab" argsType="Microsoft.VisualStudio.Text.Editor.Commanding.Commands.BackTabKeyCommandArgs" />
@@ -182,6 +217,7 @@
 		<SeparatorItem id = "Separator0" />
 		<CommandItem id = "MonoDevelop.Refactoring.RefactoryCommands.GotoDeclaration" />
 		<CommandItem id = "MonoDevelop.Refactoring.RefactoryCommands.GotoImplementation" />
+		<CommandItem id = "MonoDevelop.Refactoring.Navigate.GotoBaseMember" />
 		<CommandItem id = "MonoDevelop.Refactoring.RefactoryCommands.FindReferences" />
 		<SeparatorItem id = "Separator1" />
 		<CommandItem id = "MonoDevelop.Ide.Commands.EditCommands.Cut" />
diff --git a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/TextViewContent.Commands.cs b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/TextViewContent.Commands.cs
index 17e4edcfbd..19c1c5f799 100644
--- a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/TextViewContent.Commands.cs
+++ b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/TextViewContent.Commands.cs
@@ -185,14 +185,24 @@ namespace MonoDevelop.TextEditor
 			CommandManager.ToCommandId (SearchCommands.FindNext),
 			CommandManager.ToCommandId (SearchCommands.FindPrevious),
 			CommandManager.ToCommandId (SearchCommands.FindNextSelection),
-			CommandManager.ToCommandId (SearchCommands.FindPrevious)
+			CommandManager.ToCommandId (SearchCommands.FindPrevious),
+			"MonoDevelop.Ide.Commands.TextEditorCommands.InsertNextMatchingCaret",
+			"MonoDevelop.Ide.Commands.TextEditorCommands.InsertAllMatchingCarets",
+			"MonoDevelop.Ide.Commands.TextEditorCommands.RemoveLastSecondaryCaret",
+			"MonoDevelop.Ide.Commands.TextEditorCommands.MoveLastCaretDown",
+			"MonoDevelop.Ide.Commands.TextEditorCommands.RotatePrimaryCaretNext",
+			"MonoDevelop.Ide.Commands.TextEditorCommands.RotatePrimaryCaretPrevious"
 		};
 
 		bool CanHandleCommand (object commandId)
 		{
-			var findPresenter = Imports.FindPresenterFactory?.TryGetFindPresenter (TextView);
-			if (findPresenter != null && findPresenter.IsFocused)
-				return commandsSupportedWhenFindPresenterIsFocused.Contains (commandId);
+			// check TextView for null because of https://devdiv.visualstudio.com/DevDiv/_workitems/edit/890051
+			if (TextView is ITextView textView) {
+				var findPresenter = Imports.FindPresenterFactory?.TryGetFindPresenter (textView);
+				if (findPresenter != null && findPresenter.IsFocused) {
+					return commandsSupportedWhenFindPresenterIsFocused.Contains (commandId);
+				}
+			}
 
 			return true;
 		}
diff --git a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/TextViewContent.Toolbox.cs b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/TextViewContent.Toolbox.cs
new file mode 100644
index 0000000000..284b30f028
--- /dev/null
+++ b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/TextViewContent.Toolbox.cs
@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using Gdk;
+using Gtk;
+using Microsoft.VisualStudio.Text.Editor;
+using MonoDevelop.DesignerSupport.Toolbox;
+
+namespace MonoDevelop.TextEditor
+{
+	partial class TextViewContent<TView, TImports> :
+		IToolboxConsumer

+	{
+		TargetEntry [] IToolboxConsumer.DragTargets { get; } = new TargetEntry [0];
+
+		ToolboxItemFilterAttribute [] IToolboxConsumer.ToolboxFilterAttributes { get; } = new ToolboxItemFilterAttribute [0];
+
+		string IToolboxConsumer.DefaultItemDomain => "Text";
+
+		void IToolboxConsumer.ConsumeItem (ItemToolboxNode item)
+		{
+			if (item is ITextToolboxNode tn) {
+				tn.InsertAtCaret (this.Document);
+#if !WINDOWS
+				((ITextView3)TextView).Focus ();
+#endif
+			}
+		}
+
+		bool IToolboxConsumer.CustomFilterSupports (ItemToolboxNode item)
+		{
+			return false;
+		}
+
+		void IToolboxConsumer.DragItem (ItemToolboxNode item, Widget source, DragContext ctx)
+		{
+		}
+	}
+}
diff --git a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/TextViewContent.cs b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/TextViewContent.cs
index 26fcb5f2f9..4a46c93df7 100644
--- a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/TextViewContent.cs
+++ b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/TextViewContent.cs
@@ -310,7 +310,6 @@ namespace MonoDevelop.TextEditor
 				AutoSave.RemoveAutoSaveFile (FilePath);
 
 			UnsubscribeFromEvents ();
-			TextDocument?.Dispose ();
 
 			if (policyContainer != null)
 				policyContainer.PolicyChanged -= PolicyChanged;
@@ -484,7 +483,7 @@ namespace MonoDevelop.TextEditor
 			if (warnOverwrite) {
 				warnOverwrite = false;
 				DismissInfoBar ();
-				WorkbenchWindow.ShowNotification = false;
+				ShowNotification = false;
 			}
 
 			if (reloading) {
@@ -614,7 +613,7 @@ namespace MonoDevelop.TextEditor
 
 				warnOverwrite = false;
 				DismissInfoBar ();
-				WorkbenchWindow.ShowNotification = false;
+				ShowNotification = false;
 			}
 
 			if (!string.IsNullOrEmpty (FilePath))
@@ -709,7 +708,7 @@ namespace MonoDevelop.TextEditor
 				actions.Add (new InfoBarAction (GetButtonString (GettextCatalog.GetString ("_Ignore all")), IgnoreAll));
 			}
 
-			WorkbenchWindow.ShowNotification = true;
+			ShowNotification = true;
 			warnOverwrite = true;
 			MarkDirty ();
 
@@ -730,7 +729,7 @@ namespace MonoDevelop.TextEditor
 						return;
 
 					Load (true);
-					WorkbenchWindow.ShowNotification = false;
+					ShowNotification = false;
 				} catch (Exception ex) {
 					MessageService.ShowError ("Could not reload the file.", ex);
 				} finally {
@@ -742,7 +741,7 @@ namespace MonoDevelop.TextEditor
 			{
 				if (isDisposed)
 					return;
-				WorkbenchWindow.ShowNotification = false;
+				ShowNotification = false;
 				DismissInfoBar ();
 			}
 
diff --git a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/TextViewDisplayBinding.cs b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/TextViewDisplayBinding.cs
index 097d8a5d5c..fb77973838 100644
--- a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/TextViewDisplayBinding.cs
+++ b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/TextViewDisplayBinding.cs
@@ -28,6 +28,7 @@ using MonoDevelop.Ide.Editor;
 using MonoDevelop.Ide.Gui;
 using MonoDevelop.Ide.Gui.Documents;
 using MonoDevelop.Projects;
+using MonoDevelop.Core.FeatureConfiguration;
 
 namespace MonoDevelop.TextEditor
 {
@@ -44,7 +45,7 @@ namespace MonoDevelop.TextEditor
 				yield break;
 			}
 
-			if (modelDescriptor.FilePath == null || !(IsSupportedFileExtension (modelDescriptor.FilePath) || IsSupportedAndroidFileName (modelDescriptor.FilePath, modelDescriptor.Owner))) {
+			if (modelDescriptor.FilePath == null || !(IsSupportedFileExtension (modelDescriptor.FilePath) || IsSupportedDesignerFileName (modelDescriptor.FilePath, modelDescriptor.Owner))) {
 				yield break;
 			}
 
@@ -57,7 +58,7 @@ namespace MonoDevelop.TextEditor
 				supported = IdeServices.DesktopService.GetMimeTypeIsText (modelDescriptor.MimeType);
 
 			if (supported)
-				yield return new DocumentControllerDescription (GettextCatalog.GetString ("New Editor Preview"), true, DocumentControllerRole.Source);
+				yield return new DocumentControllerDescription (GettextCatalog.GetString ("New Source Code Editor"), true, DocumentControllerRole.Source);
 		}
 
 		static HashSet<string> supportedFileExtensions = new HashSet<string> (StringComparer.OrdinalIgnoreCase) {
@@ -68,8 +69,7 @@ namespace MonoDevelop.TextEditor
 			//".html",
 			//".js",
 			//".json",
-			//".ts",
-			//".xaml"
+			//".ts"
 		};
 
 		bool IsSupportedFileExtension (FilePath fileName)
@@ -77,11 +77,17 @@ namespace MonoDevelop.TextEditor
 			return supportedFileExtensions.Contains (fileName.Extension);
 		}
 
-		bool IsSupportedAndroidFileName (FilePath fileName, WorkspaceObject ownerProject)
+		bool IsSupportedDesignerFileName (FilePath fileName, WorkspaceObject ownerProject)
 		{
-			// disable Android XML for now
-			return false;
+			if (!FeatureSwitchService.IsFeatureEnabled ("DesignersNewEditor").GetValueOrDefault ())
+				return false;
+
+			return fileName.HasExtension (".xaml")
+				|| IsSupportedAndroidFileName (fileName, ownerProject);
+		}
 
+		bool IsSupportedAndroidFileName (FilePath fileName, WorkspaceObject ownerProject)
+		{
 			// We only care about .xml and .axml files that are marked as AndroidResource
 			if (!(fileName.HasExtension (".xml") || fileName.HasExtension (".axml")))
 				return false;
diff --git a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/ThemeToClassification.cs b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/ThemeToClassification.cs
index c8ba386408..a8a27b1492 100644
--- a/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/ThemeToClassification.cs
+++ b/main/src/addins/MonoDevelop.TextEditor/MonoDevelop.TextEditor/ThemeToClassification.cs
@@ -208,6 +208,8 @@ namespace MonoDevelop.TextEditor
 			CreateResourceDictionary (editorFormat, defaultSettings, "Block Structure Adornments", EditorThemeColors.IndentationGuide);
 			CreateResourceDictionary (editorFormat, defaultSettings, "NavigableSymbolFormat", EditorThemeColors.Link, EditorFormatDefinition.ForegroundColorId);
 			CreateResourceDictionary (editorFormat, defaultSettings, "urlformat", EditorThemeColors.Link, EditorFormatDefinition.ForegroundColorId);
+			CreateResourceDictionary (editorFormat, defaultSettings, "Track Changes before save", EditorThemeColors.QuickDiffDirty);
+			CreateResourceDictionary (editorFormat, defaultSettings, "Track Changes after save", EditorThemeColors.QuickDiffChanged);
 			CreateInlineEditField (editorFormat, defaultSettings, "RoslynRenameFieldBackgroundAndBorderTag");
 			CreateInlineEditField (editorFormat, defaultSettings, "ExpansionFieldBackgroundAndBorderTag");
 			foreach (var mapping in mappings) {
diff --git a/main/src/addins/MonoDevelop.UnitTesting/Services/UnitTestService.cs b/main/src/addins/MonoDevelop.UnitTesting/Services/UnitTestService.cs
index 04c3715e09..ba945712a3 100644
--- a/main/src/addins/MonoDevelop.UnitTesting/Services/UnitTestService.cs
+++ b/main/src/addins/MonoDevelop.UnitTesting/Services/UnitTestService.cs
@@ -50,6 +50,7 @@ namespace MonoDevelop.UnitTesting
 	{
 		static ArrayList providers = new ArrayList ();
 		static UnitTest[] rootTests = Array.Empty<UnitTest> ();
+		static bool packageEventsInitialized;
 
 		static UnitTestService ()
 		{
@@ -61,11 +62,16 @@ namespace MonoDevelop.UnitTesting
 			IdeApp.Workspace.ItemRemovedFromSolution += OnItemsChangedInSolution;
 			IdeApp.Workspace.ReferenceAddedToProject += OnReferenceChangedInProject;
 			IdeApp.Workspace.ReferenceRemovedFromProject += OnReferenceChangedInProject;
-
-			PackageManagementServices.ProjectOperations.PackageReferenceAdded += ProjectOperations_PackageReferencesModified;
-			PackageManagementServices.ProjectOperations.PackageReferenceRemoved += ProjectOperations_PackageReferencesModified;
-			PackageManagementServices.ProjectOperations.PackagesRestored += ProjectOperations_PackageReferencesModified;
-
+			
+			IdeApp.Workspace.FirstWorkspaceItemOpened += (s,a) => {
+				if (!packageEventsInitialized) {
+					packageEventsInitialized = true;
+					PackageManagementServices.ProjectOperations.PackageReferenceAdded += ProjectOperations_PackageReferencesModified;
+					PackageManagementServices.ProjectOperations.PackageReferenceRemoved += ProjectOperations_PackageReferencesModified;
+					PackageManagementServices.ProjectOperations.PackagesRestored += ProjectOperations_PackageReferencesModified;
+				}
+			};
+			
 			Mono.Addins.AddinManager.AddExtensionNodeHandler ("/MonoDevelop/UnitTesting/TestProviders", OnExtensionChange);
 
 			RebuildTests ();
diff --git a/main/src/addins/PerformanceDiagnostics/PerformanceDiagnostics/Commands.cs b/main/src/addins/PerformanceDiagnostics/PerformanceDiagnostics/Commands.cs
index 852c472a20..31deb100b5 100644
--- a/main/src/addins/PerformanceDiagnostics/PerformanceDiagnostics/Commands.cs
+++ b/main/src/addins/PerformanceDiagnostics/PerformanceDiagnostics/Commands.cs
@@ -43,7 +43,7 @@ namespace PerformanceDiagnosticsAddIn
 		{
 			var dialog = new OpenFileDialog (GettextCatalog.GetString ("Sample file output"), MonoDevelop.Components.FileChooserAction.Open);
 			if (dialog.Run ())
-				UIThreadMonitor.ConvertJITAddressesToMethodNames (dialog.SelectedFile, "External");
+				MonoDevelop.Utilities.SampleProfiler.ConvertJITAddressesToMethodNames (Options.OutputPath, dialog.SelectedFile, "External");
 		}
 	}
 
diff --git a/main/src/addins/PerformanceDiagnostics/PerformanceDiagnostics/UIThreadMonitor.cs b/main/src/addins/PerformanceDiagnostics/PerformanceDiagnostics/UIThreadMonitor.cs
index 894fee35d9..4983bed7e8 100644
--- a/main/src/addins/PerformanceDiagnostics/PerformanceDiagnostics/UIThreadMonitor.cs
+++ b/main/src/addins/PerformanceDiagnostics/PerformanceDiagnostics/UIThreadMonitor.cs
@@ -16,11 +16,11 @@ using System.Threading.Tasks;
 
 namespace PerformanceDiagnosticsAddIn
 {
-	public class UIThreadMonitor
+	public class UIThreadMonitor : MonoDevelop.Utilities.SampleProfiler
 	{
 		public static UIThreadMonitor Instance { get; } = new UIThreadMonitor ();
 
-		UIThreadMonitor ()
+		UIThreadMonitor () : base (Options.OutputPath)
 		{
 			IdeApp.Exited += IdeAppExited;
 		}
@@ -28,7 +28,7 @@ namespace PerformanceDiagnosticsAddIn
 		void IdeAppExited (object sender, EventArgs e)
 		{
 			try {
-				Instance.Stop ();
+				Stop ();
 			} catch (Exception ex) {
 				LoggingService.LogError ("UIThreadMonitor stop error.", ex);
 			}
@@ -69,44 +69,6 @@ namespace PerformanceDiagnosticsAddIn
 			}
 		}
 
-		TimeSpan forceProfileTime = TimeSpan.Zero;
-
-		public bool ToggleProfilingChecked => sampleProcessPid != -1;
-
-		int sampleProcessPid = -1;
-		public void ToggleProfiling ()
-		{
-			if (sampleProcessPid != -1) {
-				Mono.Unix.Native.Syscall.kill (sampleProcessPid, Mono.Unix.Native.Signum.SIGINT);
-				sampleProcessPid = -1;
-				return;
-			}
-
-			var outputFilePath = Path.GetTempFileName ();
-			var startInfo = new ProcessStartInfo ("sample");
-			startInfo.UseShellExecute = false;
-			startInfo.Arguments = $"{Process.GetCurrentProcess ().Id} 10000 -file {outputFilePath}";
-			var sampleProcess = Process.Start (startInfo);
-			sampleProcess.EnableRaisingEvents = true;
-			sampleProcess.Exited += delegate {
-				ConvertJITAddressesToMethodNames (outputFilePath, "Profile");
-			};
-			sampleProcessPid = sampleProcess.Id;
-		}
-
-		public void Profile (int seconds)
-		{
-			var outputFilePath = Path.GetTempFileName ();
-			var startInfo = new ProcessStartInfo ("sample");
-			startInfo.UseShellExecute = false;
-			startInfo.Arguments = $"{Process.GetCurrentProcess ().Id} {seconds} -file {outputFilePath}";
-			var sampleProcess = Process.Start (startInfo);
-			sampleProcess.EnableRaisingEvents = true;
-			sampleProcess.Exited += delegate {
-				ConvertJITAddressesToMethodNames (outputFilePath, "Profile");
-			};
-		}
-
 		public bool IsListening { get; private set; }
 		public bool IsSampling { get; private set; }
 		public string HangFileName { get; set; }
@@ -120,8 +82,8 @@ namespace PerformanceDiagnosticsAddIn
 			}
 			if (sample) {
 				if (!(Environment.GetEnvironmentVariable ("MONO_DEBUG")?.Contains ("disable_omit_fp") ?? false)) {
-					MessageService.ShowWarning ("Set environment variable",
-												$@"It is highly recommended to set environment variable ""MONO_DEBUG"" to ""disable_omit_fp"" and restart {BrandingService.ApplicationName} to have better results.");
+					var msg = $@"It is highly recommended to set environment variable ""MONO_DEBUG"" to ""disable_omit_fp"" and restart {BrandingService.ApplicationName} to have better results.";
+					MessageService.ShowWarning ("Set environment variable", msg);
 				}
 			}
 			IsListening = true;
@@ -190,7 +152,7 @@ namespace PerformanceDiagnosticsAddIn
 			var process = (Process)param;
 			while (!process.HasExited) {
 				var fileName = process.StandardOutput.ReadLine ();
-				ConvertJITAddressesToMethodNames (fileName, "UIThreadHang");
+				ConvertJITAddressesToMethodNames (Options.OutputPath, fileName, "UIThreadHang");
 			}
 		}
 
@@ -208,44 +170,6 @@ namespace PerformanceDiagnosticsAddIn
 			listener = null;
 		}
 
-		internal static void ConvertJITAddressesToMethodNames (string fileName, string profilingType)
-		{
-			// sample line to replace:
-			// ???  (in <unknown binary>)  [0x103648455]
-			var rx = new Regex (@"\?\?\?  \(in <unknown binary>\)  \[0x([0-9a-f]+)\]", RegexOptions.Compiled);
-
-
-			if (File.Exists (fileName) && new FileInfo (fileName).Length > 0) {
-				Directory.CreateDirectory (Options.OutputPath);
-				var outputFilename = Path.Combine (Options.OutputPath, $"{BrandingService.ApplicationName}_{profilingType}_{DateTime.Now:yyyy-MM-dd__HH-mm-ss}.txt");
-
-				using (var sr = new StreamReader (fileName))
-				using (var sw = new StreamWriter (outputFilename)) {
-					string line;
-					while ((line = sr.ReadLine ()) != null) {
-
-						var match = rx.Match (line);
-						if (match.Success) {
-							var offset = long.Parse (match.Groups [1].Value, NumberStyles.HexNumber);
-
-							if (!methodsCache.TryGetValue (offset, out var pmipMethodName)) {
-								pmipMethodName = mono_pmip (offset)?.TrimStart ();
-								if (pmipMethodName != null)
-									pmipMethodName = PmipParser.ToSample (pmipMethodName, offset);
-								methodsCache.Add (offset, pmipMethodName);
-							}
-
-							if (pmipMethodName != null) {
-								line = line.Remove (match.Index, match.Length);
-								line = line.Insert (match.Index, pmipMethodName);
-							}
-						}
-						sw.WriteLine (line);
-					}
-				}
-			}
-		}
-
 		static class PmipParser
 		{
 			// pmip output:
diff --git a/main/src/addins/VersionControl/MonoDevelop.VersionControl.Git/MonoDevelop.VersionControl.Git/Commands.cs b/main/src/addins/VersionControl/MonoDevelop.VersionControl.Git/MonoDevelop.VersionControl.Git/Commands.cs
index 98da21d536..7bc17bf516 100644
--- a/main/src/addins/VersionControl/MonoDevelop.VersionControl.Git/MonoDevelop.VersionControl.Git/Commands.cs
+++ b/main/src/addins/VersionControl/MonoDevelop.VersionControl.Git/MonoDevelop.VersionControl.Git/Commands.cs
@@ -122,7 +122,7 @@ namespace MonoDevelop.VersionControl.Git
 	{
 		protected override void Run ()
 		{
-			GitService.ShowConfigurationDialog (Repository);
+			GitService.ShowConfigurationDialog (Repository.VersionControlSystem, Repository.RootPath, Repository.Url);
 		}
 	}
 
diff --git a/main/src/addins/VersionControl/MonoDevelop.VersionControl.Git/MonoDevelop.VersionControl.Git/GitConfigurationDialog.cs b/main/src/addins/VersionControl/MonoDevelop.VersionControl.Git/MonoDevelop.VersionControl.Git/GitConfigurationDialog.cs
index 66ee4e45a9..071359a4cb 100644
--- a/main/src/addins/VersionControl/MonoDevelop.VersionControl.Git/MonoDevelop.VersionControl.Git/GitConfigurationDialog.cs
+++ b/main/src/addins/VersionControl/MonoDevelop.VersionControl.Git/MonoDevelop.VersionControl.Git/GitConfigurationDialog.cs
@@ -37,15 +37,15 @@ namespace MonoDevelop.VersionControl.Git
 {
 	partial class GitConfigurationDialog : Gtk.Dialog
 	{
-		readonly GitRepository repo;
+		GitRepository repo;
 		readonly ListStore storeBranches;
 		readonly ListStore storeTags;
 		readonly TreeStore storeRemotes;
 
-		public GitConfigurationDialog (GitRepository repo)
+		public GitConfigurationDialog (VersionControlSystem vcs, string repoPath, string repoUrl)
 		{
 			this.Build ();
-			this.repo = repo;
+			this.repo = new GitRepository (vcs, repoPath, repoUrl, false);
 			this.HasSeparator = false;
 
 			this.UseNativeContextMenus ();
@@ -69,7 +69,8 @@ namespace MonoDevelop.VersionControl.Git
 					buttonRemoveBranch.Sensitive = buttonEditBranch.Sensitive = buttonSetDefaultBranch.Sensitive = listBranches.Selection.GetSelected (out it);
 				if (!anythingSelected)
 						return;
-
+				if (repo == null || repo.IsDisposed)
+					return;
 				string currentBranch = repo.GetCurrentBranch ();
 				var b = (Branch) storeBranches.GetValue (it, 0);
 				buttonRemoveBranch.Sensitive = b.FriendlyName != currentBranch;
@@ -166,6 +167,15 @@ namespace MonoDevelop.VersionControl.Git
 			}
 		}
 
+		protected override void OnDestroyed ()
+		{
+			base.OnDestroyed ();
+			if (this.repo != null) {
+				this.repo.Dispose ();
+				this.repo = null;
+			}
+		}
+
 		protected virtual void OnButtonAddBranchClicked (object sender, EventArgs e)
 		{
 			var dlg = new EditBranchDialog (repo);
diff --git a/main/src/addins/VersionControl/MonoDevelop.VersionControl.Git/MonoDevelop.VersionControl.Git/GitRepository.cs b/main/src/addins/VersionControl/MonoDevelop.VersionControl.Git/MonoDevelop.VersionControl.Git/GitRepository.cs
index 49a7a80c88..3b22615cab 100644
--- a/main/src/addins/VersionControl/MonoDevelop.VersionControl.Git/MonoDevelop.VersionControl.Git/GitRepository.cs
+++ b/main/src/addins/VersionControl/MonoDevelop.VersionControl.Git/MonoDevelop.VersionControl.Git/GitRepository.cs
@@ -67,8 +67,9 @@ namespace MonoDevelop.VersionControl.Git
 
 				rootRepository = value;
 
-				InitScheduler ();
-				InitFileWatcher (false);
+				InitScheduler (); 
+                if (this.watchGitLockfiles)
+					InitFileWatcher (false);
 			}
 		}
 
@@ -79,19 +80,27 @@ namespace MonoDevelop.VersionControl.Git
 		ConcurrentExclusiveSchedulerPair scheduler;
 		TaskFactory blockingOperationFactory;
 		TaskFactory readingOperationFactory;
+		readonly bool watchGitLockfiles;
 
 		public GitRepository ()
 		{
 			Url = "git://";
 		}
 
-		public GitRepository (VersionControlSystem vcs, FilePath path, string url) : base (vcs)
+		internal GitRepository (VersionControlSystem vcs, FilePath path, string url, bool watchGitLockfiles) : base (vcs)
 		{
 			RootRepository = new LibGit2Sharp.Repository (path);
 			RootPath = RootRepository.Info.WorkingDirectory;
 			Url = url;
+			this.watchGitLockfiles = watchGitLockfiles;
+
+			if (this.watchGitLockfiles && watcher == null)
+				InitFileWatcher ();
+		}
+
+		public GitRepository (VersionControlSystem vcs, FilePath path, string url) : this (vcs, path, url, true)
+		{
 
-			InitFileWatcher ();
 		}
 
 		void InitScheduler ()
diff --git a/main/src/addins/VersionControl/MonoDevelop.VersionControl.Git/MonoDevelop.VersionControl.Git/GitService.cs b/main/src/addins/VersionControl/MonoDevelop.VersionControl.Git/MonoDevelop.VersionControl.Git/GitService.cs
index 5ca708d42d..0b32ab2750 100644
--- a/main/src/addins/VersionControl/MonoDevelop.VersionControl.Git/MonoDevelop.VersionControl.Git/GitService.cs
+++ b/main/src/addins/VersionControl/MonoDevelop.VersionControl.Git/MonoDevelop.VersionControl.Git/GitService.cs
@@ -78,9 +78,9 @@ namespace MonoDevelop.VersionControl.Git
 			}
 		}
 
-		public static void ShowConfigurationDialog (GitRepository repo)
+		public static void ShowConfigurationDialog (VersionControlSystem vcs, string repoPath, string repoUrl)
 		{
-			using (var dlg = new GitConfigurationDialog (repo))
+			using (var dlg = new GitConfigurationDialog (vcs, repoPath, repoUrl))
 				MessageService.ShowCustomDialog (dlg);
 		}
 
diff --git a/main/src/addins/VersionControl/MonoDevelop.VersionControl/MonoDevelop.VersionControl/Commands.cs b/main/src/addins/VersionControl/MonoDevelop.VersionControl/MonoDevelop.VersionControl/Commands.cs
index 979d97cb97..f738a4c9f9 100644
--- a/main/src/addins/VersionControl/MonoDevelop.VersionControl/MonoDevelop.VersionControl/Commands.cs
+++ b/main/src/addins/VersionControl/MonoDevelop.VersionControl/MonoDevelop.VersionControl/Commands.cs
@@ -1,4 +1,4 @@
-
+
 using MonoDevelop.Components.Commands;
 using MonoDevelop.Projects;
 using MonoDevelop.Ide;
@@ -243,27 +243,47 @@ namespace MonoDevelop.VersionControl
 		}
 	}
 
-	class CurrentFileViewHandler<T> : FileVersionControlCommandHandler
+	abstract class CurrentFileViewHandler<T> : FileVersionControlCommandHandler
 	{
+		protected bool CanRunCommand { get => IdeApp.Workbench.ActiveDocument?.GetContent<VersionControlDocumentController> () != null; }
+
 		protected override bool RunCommand (VersionControlItemList items, bool test)
 		{
-			if (test)
-				return true;
-
-			IdeApp.Workbench.ActiveDocument?.GetContent<VersionControlDocumentController> ()?.ShowDiffView ();
-			return true;
+			return CanRunCommand;
 		}
 	}
 
 	class CurrentFileDiffHandler : CurrentFileViewHandler<IDiffView>
 	{
+		protected override bool RunCommand (VersionControlItemList items, bool test)
+		{
+			if (test)
+				return CanRunCommand;
+			IdeApp.Workbench.ActiveDocument?.GetContent<VersionControlDocumentController> ()?.ShowDiffView ();
+			return true;
+		}
 	}
-	
+
 	class CurrentFileBlameHandler : CurrentFileViewHandler<IBlameView>
 	{
+		protected override bool RunCommand (VersionControlItemList items, bool test)
+		{
+			if (test)
+				return CanRunCommand;
+			IdeApp.Workbench.ActiveDocument?.GetContent<VersionControlDocumentController> ()?.ShowBlameView ();
+			return true;
+		}
+
 	}
-	
+
 	class CurrentFileLogHandler : CurrentFileViewHandler<ILogView>
 	{
+		protected override bool RunCommand (VersionControlItemList items, bool test)
+		{
+			if (test)
+				return CanRunCommand;
+			IdeApp.Workbench.ActiveDocument?.GetContent<VersionControlDocumentController> ()?.ShowLogView ();
+			return true;
+		}
 	}
 }
diff --git a/main/src/addins/VersionControl/MonoDevelop.VersionControl/MonoDevelop.VersionControl/RevertCommand.cs b/main/src/addins/VersionControl/MonoDevelop.VersionControl/MonoDevelop.VersionControl/RevertCommand.cs
index ad545d43d2..d509a972e4 100644
--- a/main/src/addins/VersionControl/MonoDevelop.VersionControl/MonoDevelop.VersionControl/RevertCommand.cs
+++ b/main/src/addins/VersionControl/MonoDevelop.VersionControl/MonoDevelop.VersionControl/RevertCommand.cs
@@ -26,7 +26,7 @@ namespace MonoDevelop.VersionControl
 				if (test)
 					return items.All (i => i.VersionInfo.CanRevert);
 
-				if (MessageService.AskQuestion (GettextCatalog.GetString ("Are you sure you want to revert the changes done in the selected files?"), 
+				if (MessageService.AskQuestion (GettextCatalog.GetString ("Are you sure you want to revert the changes made in the selected files?"), 
 				                                GettextCatalog.GetString ("All changes made to the selected files will be permanently lost."),
 				                                AlertButton.Cancel, AlertButton.Revert) != AlertButton.Revert)
 					return false;