Unbreak task completion and add tests

Fixes #150

MonoDevelop.MSBuild.Tests.Editor/Completion/MSBuildCompletionTests.cs

@@ -61,6 +61,36 @@ public async Task ProjectChildElementBracketCompletion ()
 			result.AssertContains ("<!--");
 		}
 
+		[Test]
+		public async Task TaskCompletion ()
+		{
+			var result = await this.GetCompletionContext (@"<Project><Target><$");
+
+			result.AssertContains ("<Message");
+			result.AssertContains ("<Exec");
+			result.AssertContains ("<Csc");
+		}
+
+		[Test]
+		public async Task TaskParameterCompletion ()
+		{
+			var result = await this.GetCompletionContext (@"<Project><Target><Message $");
+
+			result.AssertContains ("Importance");
+			result.AssertContains ("Text");
+			result.AssertContains ("HelpKeyword");
+			result.AssertContains ("Condition");
+		}
+
+		[Test]
+		public async Task TaskOutputCompletion ()
+		{
+			var result = await this.GetCompletionContext (@"<Project><Target><Csc><Output TaskParameter=""$");
+
+			result.AssertContains ("OutputAssembly");
+			result.AssertContains ("OutputRefAssembly");
+		}
+
 		[Test]
 		public async Task InferredItems ()
 		{

MonoDevelop.MSBuild.Tests.Editor/MSBuildFindReferencesTests.cs

@@ -29,7 +29,7 @@ public class MSBuildFindReferencesTests
 			var logger = TestLoggerFactory.CreateLogger (testMethodName);
 			var doc = MSBuildTestHelpers.CreateEmptyDocument ();
 			var parseContext = new MSBuildParserContext (
-				new TestMSBuildEnvironment (), null, null, null, "test.csproj", new PropertyValueCollector (false), null, logger, null, default);
+				new NullMSBuildEnvironment (), null, null, null, "test.csproj", new PropertyValueCollector (false), null, logger, null, default);
 			doc.Build (xdoc, parseContext);
 
 			var functionTypeProvider = new RoslynFunctionTypeProvider (null, parseContext.Logger);

MonoDevelop.MSBuild.Tests.Editor/Mocks/TestMSBuildEnvironment.cs

@@ -3,10 +3,22 @@
 
 using System.ComponentModel.Composition;
 
+using Microsoft.Extensions.Logging;
+
+using MonoDevelop.MSBuild.Editor.Completion;
+using MonoDevelop.MSBuild.SdkResolution;
+
 namespace MonoDevelop.MSBuild.Tests.Editor.Mocks
 {
+	// Subclass CurrentProcessMSBuildEnvironment so we get real value for ToolsPath, allowing .tasks and .overridetasks to be found by tests
 	[Export (typeof (IMSBuildEnvironment))]
-	class TestMSBuildEnvironment : NullMSBuildEnvironment
+	[method: ImportingConstructor]
+	class TestMSBuildEnvironment (MSBuildEnvironmentLogger environmentLogger) : CurrentProcessMSBuildEnvironment(environmentLogger.Logger)
 	{
+		// However, suppress resolution of Microsoft.NET.SDK so tests don't use the SDK fallback.
+		// The SDK fallback substantially slows down the tests and is not necessary for the tests,
+		// and different versions of the SDK may introduce unexpected values from inference.
+		public override SdkInfo ResolveSdk ((string name, string version, string minimumVersion) sdk, string projectFile, string solutionPath, ILogger logger = null)
+			=> null;
 	}
 }

MonoDevelop.MSBuild/CurrentProcessMSBuildEnvironment.cs

@@ -54,7 +54,7 @@ public CurrentProcessMSBuildEnvironment (ILogger logger)
 		public IReadOnlyDictionary<string, string[]> ProjectImportSearchPaths { get; }
 
 		//FIXME: caching should be specific to the (projectFile, string solutionPath) pair
-		public SdkInfo ResolveSdk (
+		public virtual SdkInfo ResolveSdk (
 			(string name, string version, string minimumVersion) sdk, string projectFile, string solutionPath, ILogger logger = null)
 		{
 			var sdkRef = new SdkReference (sdk.name, sdk.version, sdk.minimumVersion);

MonoDevelop.MSBuild/Language/Syntax/MSBuildAttributeSyntax.cs

@@ -1,12 +1,14 @@
 // Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 
 using MonoDevelop.MSBuild.Language.Typesystem;
 
 namespace MonoDevelop.MSBuild.Language.Syntax
 {
+	[DebuggerDisplay("MSBuildAttributeSyntax ({SyntaxKind,nq})")]
 	public class MSBuildAttributeSyntax : MSBuildSyntax
 	{
 		public MSBuildAttributeSyntax (

MonoDevelop.MSBuild/Language/Syntax/MSBuildElementSyntax.cs

@@ -4,14 +4,15 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 
-using MonoDevelop.Xml.Dom;
-
 using MonoDevelop.MSBuild.Language.Typesystem;
+using MonoDevelop.Xml.Dom;
 
 namespace MonoDevelop.MSBuild.Language.Syntax
 {
+	[DebuggerDisplay("MSBuildElementSyntax ({SyntaxKind,nq})")]
 	public class MSBuildElementSyntax : MSBuildSyntax
 	{
 		MSBuildElementSyntax[] children = Array.Empty<MSBuildElementSyntax> ();
@@ -189,19 +190,19 @@ static MSBuildElementSyntax ()
 			ItemDefinition = AddBuiltin ("ItemDefinition", ElementDescriptions.ItemDefinition, MSBuildSyntaxKind.ItemDefinition, isAbstract: true); // docs don't treat this as distinct from Item in ItemGroup
 			ItemDefinitionGroup = AddBuiltin ("ItemDefinitionGroup", ElementDescriptions.ItemDefinitionGroup, MSBuildSyntaxKind.ItemDefinitionGroup, helpUrl: HelpUrls.Element_ItemDefinitionGroup);
 			ItemGroup = AddBuiltin ("ItemGroup", ElementDescriptions.ItemGroup, MSBuildSyntaxKind.ItemGroup, helpUrl: HelpUrls.Element_ItemGroup);
-			Metadata = AddBuiltin ("Metadata", ElementDescriptions.Metadata, MSBuildSyntaxKind.Metadata, MSBuildValueKind.Unknown, true, helpUrl: HelpUrls.Element_Metadata);
+			Metadata = AddBuiltin ("Metadata", ElementDescriptions.Metadata, MSBuildSyntaxKind.Metadata, MSBuildValueKind.Unknown, isAbstract: true, helpUrl: HelpUrls.Element_Metadata);
 			OnError = AddBuiltin ("OnError", ElementDescriptions.OnError, MSBuildSyntaxKind.OnError, helpUrl: HelpUrls.Element_OnError);
 			Otherwise = AddBuiltin ("Otherwise", ElementDescriptions.Otherwise, MSBuildSyntaxKind.Otherwise, helpUrl: HelpUrls.Element_Otherwise);
 			Output = AddBuiltin ("Output", ElementDescriptions.Output, MSBuildSyntaxKind.Output, helpUrl: HelpUrls.Element_Output);
 			Parameter = AddBuiltin ("Parameter", ElementDescriptions.Parameter, MSBuildSyntaxKind.Parameter, isAbstract: true, helpUrl: HelpUrls.Element_Parameter);
 			ParameterGroup = AddBuiltin ("ParameterGroup", ElementDescriptions.ParameterGroup, MSBuildSyntaxKind.ParameterGroup, helpUrl: HelpUrls.Element_ParameterGroup);
 			Project = AddBuiltin ("Project", ElementDescriptions.Project, MSBuildSyntaxKind.Project, helpUrl: HelpUrls.Element_Project);
 			ProjectExtensions = AddBuiltin ("ProjectExtensions", ElementDescriptions.ProjectExtensions, MSBuildSyntaxKind.ProjectExtensions, MSBuildValueKind.Data, helpUrl: HelpUrls.Element_ProjectExtensions);
-			Property = AddBuiltin ("Property", ElementDescriptions.Property, MSBuildSyntaxKind.Property, MSBuildValueKind.Unknown, true, helpUrl: HelpUrls.Element_Property);
+			Property = AddBuiltin ("Property", ElementDescriptions.Property, MSBuildSyntaxKind.Property, MSBuildValueKind.Unknown, isAbstract: true, helpUrl: HelpUrls.Element_Property);
 			PropertyGroup = AddBuiltin ("PropertyGroup", ElementDescriptions.PropertyGroup, MSBuildSyntaxKind.PropertyGroup, helpUrl: HelpUrls.Element_PropertyGroup);
 			Sdk = AddBuiltin ("Sdk", ElementDescriptions.Sdk, MSBuildSyntaxKind.Sdk, helpUrl: HelpUrls.Element_Sdk);
 			Target = AddBuiltin ("Target", ElementDescriptions.Target, MSBuildSyntaxKind.Target, helpUrl: HelpUrls.Element_Target);
-			Task = AddBuiltin ("AbstractTask", ElementDescriptions.Task, MSBuildSyntaxKind.Task, helpUrl: HelpUrls.Element_Task);
+			Task = AddBuiltin ("AbstractTask", ElementDescriptions.Task, MSBuildSyntaxKind.Task, isAbstract:true, helpUrl: HelpUrls.Element_Task);
 			TaskBody = AddBuiltin ("Task", ElementDescriptions.TaskBody, MSBuildSyntaxKind.TaskBody, helpUrl: HelpUrls.Element_TaskBody);
 			UsingTask = AddBuiltin ("UsingTask", ElementDescriptions.UsingTask, MSBuildSyntaxKind.UsingTask, helpUrl: HelpUrls.Element_UsingTask);
 			When = AddBuiltin ("When", ElementDescriptions.When, MSBuildSyntaxKind.When, helpUrl: HelpUrls.Element_When);