Merge master to master-vs-deps

azure-pipelines-integration.yml

@@ -18,7 +18,7 @@ jobs:
 - job: VS_Integration
   pool:
     name: NetCorePublic-Pool
-    queue: buildpool.windows.10.amd64.vs2019.pre.open
+    queue: $(queueName)
   strategy:
     maxParallel: 4
     matrix:

azure-pipelines-official.yml

@@ -170,7 +170,10 @@ stages:
       condition: and(succeeded(), eq(variables['PRNumber'], 'default'))
 
     # Publish OptProf configuration files
+    # The env variable is required to enable cross account access using PAT (dnceng -> devdiv)
     - task: ms-vscs-artifact.build-tasks.artifactDropTask-1.artifactDropTask@0
+      env:
+        ARTIFACTSERVICES_DROP_PAT: $(_DevDivDropAccessToken)
       inputs:
         dropServiceURI: 'https://devdiv.artifacts.visualstudio.com'
         buildNumber: 'ProfilingInputs/DevDiv/$(Build.Repository.Name)/$(SourceBranchName)/$(Build.BuildNumber)'
@@ -224,17 +227,22 @@ stages:
       inputs:
         DropName: $(VisualStudio.DropName)
         DropFolder: 'artifacts\VSSetup\$(BuildConfiguration)\Insertion'
+        AccessToken: $(_DevDivDropAccessToken)
       condition: succeeded()
 
     # Publish insertion packages to CoreXT store.
     - task: NuGetCommand@2
       displayName: Publish CoreXT Packages 
       inputs:
         command: push
-        feedsToUse: config
         packagesToPush: '$(Build.SourcesDirectory)\artifacts\VSSetup\$(BuildConfiguration)\DevDivPackages\**\*.nupkg'
-        publishVstsFeed: '97a41293-2972-4f48-8c0e-05493ae82010'
         allowPackageConflicts: true
+        ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+          feedsToUse: config
+          publishVstsFeed: '97a41293-2972-4f48-8c0e-05493ae82010'
+        ${{ if eq(variables['System.TeamProject'], 'internal') }}:
+          nuGetFeedType: external
+          publishFeedCredentials: 'DevDiv - VS package feed'
       condition: succeeded()
 
     # Publish an artifact that the RoslynInsertionTool is able to find by its name.
@@ -272,8 +280,12 @@ stages:
       publishUsingPipelines: true
       dependsOn:	
         - OfficialBuild
-      queue:
-        name: Hosted VS2017
+      ${{ if eq(variables['System.TeamProject'], 'DevDiv') }}:
+        queue:
+          name: Hosted VS2017
+      ${{ if eq(variables['System.TeamProject'], 'internal') }}:
+        pool:
+          vmImage: vs2017-win2016
 
 # We need to skip post-build stages for PR validation build, but it can only be identified by 
 # the runtime variable 'PRNumber', thus this dummy stage. Also the dummy job is required

eng/build.ps1

@@ -358,7 +358,6 @@ function TestUsingOptimizedRunner() {
   $args += " --logs `"$LogDir`""
   $args += " --secondaryLogs `"$secondaryLogDir`""
   $args += " --tfm net472"
-  $args += " --html"
 
   if ($testDesktop -or $testIOperation) {
     if ($test32) {
@@ -371,6 +370,7 @@ function TestUsingOptimizedRunner() {
     # integration tests in CI.
     if ($ci) {
       $dlls += @(Get-Item (GetProjectOutputBinary "Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests.dll"))
+      $args += " --retry"
     }
 
     $dlls += @(Get-ChildItem -Recurse -Include "*.IntegrationTests.dll" $binDir)

src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs

@@ -19,6 +19,7 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.InlineHints;
 using Microsoft.CodeAnalysis.LanguageServices;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.Text;
@@ -82,7 +83,7 @@ public static InlineHintsTag Create(
             bool classify)
         {
             return new InlineHintsTag(
-                CreateElement(hint.DisplayParts, textView, span, format, formatMap, taggerProvider.TypeMap, classify),
+                CreateElement(hint.DisplayParts, textView, format, formatMap, taggerProvider.TypeMap, classify),
                 textView, span, hint, taggerProvider);
         }
 
@@ -105,7 +106,6 @@ public async Task<IReadOnlyCollection<object>> CreateDescriptionAsync(Cancellati
         private static FrameworkElement CreateElement(
             ImmutableArray<TaggedText> taggedTexts,
             IWpfTextView textView,
-            SnapshotSpan span,
             TextFormattingRunProperties format,
             IClassificationFormatMap formatMap,
             ClassificationTypeMap typeMap,
@@ -126,7 +126,9 @@ private static FrameworkElement CreateElement(
                 VerticalAlignment = VerticalAlignment.Center,
             };
 
-            foreach (var taggedText in taggedTexts)
+            var (trimmedTexts, leftPadding, rightPadding) = Trim(taggedTexts);
+
+            foreach (var taggedText in trimmedTexts)
             {
                 var run = new Run(taggedText.ToVisibleDisplayString(includeLeftToRightMarker: true));
 
@@ -144,9 +146,10 @@ private static FrameworkElement CreateElement(
             // height. Gets foreground/background colors from the options menu. The margin is the distance from the 
             // adornment to the text and pushing the adornment upwards to create a separation when on a specific line
 
-            // If the tag is followed by a space, just create a normal border (as there will already be a buffer to the right).
-            // If not, then pad the right a little so the tag doesn't feel too cramped with the following text.
-            var right = span.End < span.Snapshot.Length && char.IsWhiteSpace(span.End.GetChar()) ? 0 : 5;
+            // If the tag is started or followed by a space, we trim that off but represent the space as buffer on hte
+            // left or right side.
+            var left = leftPadding * 5;
+            var right = rightPadding * 5;
 
             var border = new Border
             {
@@ -155,7 +158,7 @@ private static FrameworkElement CreateElement(
                 CornerRadius = new CornerRadius(2),
                 Height = textView.LineHeight - (0.25 * textView.LineHeight),
                 HorizontalAlignment = HorizontalAlignment.Center,
-                Margin = new Thickness(left: 0, top: -0.20 * textView.LineHeight, right, bottom: 0),
+                Margin = new Thickness(left, top: -0.20 * textView.LineHeight, right, bottom: 0),
                 Padding = new Thickness(1),
 
                 // Need to set SnapsToDevicePixels and UseLayoutRounding to avoid unnecessary reformatting
@@ -174,6 +177,41 @@ private static FrameworkElement CreateElement(
             return border;
         }
 
+        private static (ImmutableArray<TaggedText> texts, int leftPadding, int rightPadding) Trim(ImmutableArray<TaggedText> taggedTexts)
+        {
+            using var _ = ArrayBuilder<TaggedText>.GetInstance(out var result);
+            var leftPadding = 0;
+            var rightPadding = 0;
+
+            if (taggedTexts.Length == 1)
+            {
+                var first = taggedTexts.First();
+
+                var trimStart = first.Text.TrimStart();
+                var trimBoth = trimStart.TrimEnd();
+                result.Add(new TaggedText(first.Tag, trimBoth));
+                leftPadding = first.Text.Length - trimStart.Length;
+                rightPadding = trimStart.Length - trimBoth.Length;
+            }
+            else if (taggedTexts.Length >= 2)
+            {
+                var first = taggedTexts.First();
+                var trimStart = first.Text.TrimStart();
+                result.Add(new TaggedText(first.Tag, trimStart));
+                leftPadding = first.Text.Length - trimStart.Length;
+
+                for (var i = 1; i < taggedTexts.Length - 1; i++)
+                    result.Add(taggedTexts[i]);
+
+                var last = taggedTexts.Last();
+                var trimEnd = last.Text.TrimEnd();
+                result.Add(new TaggedText(last.Tag, trimEnd));
+                rightPadding = last.Text.Length - trimEnd.Length;
+            }
+
+            return (result.ToImmutable(), leftPadding, rightPadding);
+        }
+
         /// <summary>
         /// Determines if the border is being moused over and shows the info accordingly
         /// </summary>

src/EditorFeatures/Core/Implementation/IntelliSense/SignatureHelp/Controller.Session_ComputeModel.cs

@@ -12,6 +12,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.LanguageServices;
@@ -65,6 +66,13 @@ private async Task<Model> ComputeModelInBackgroundAsync(
                             return currentModel;
                         }
 
+                        // Let LSP handle signature help in the cloud scenario
+                        var workspaceContextService = document.Project.Solution.Workspace.Services.GetRequiredService<IWorkspaceContextService>();
+                        if (workspaceContextService.IsCloudEnvironmentClient())
+                        {
+                            return null;
+                        }
+
                         if (triggerInfo.TriggerReason == SignatureHelpTriggerReason.RetriggerCommand)
                         {
                             if (currentModel == null)

src/EditorFeatures/Core/InlineHints/InlineHintsDataTaggerProvider.cs

@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.Composition;
+using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
@@ -36,6 +37,14 @@ internal class InlineHintsDataTaggerProvider : AsynchronousViewTaggerProvider<In
 
         protected override SpanTrackingMode SpanTrackingMode => SpanTrackingMode.EdgeInclusive;
 
+        /// <summary>
+        /// We want to make sure that if the user edits the space that the tag exists in that it goes away and they
+        /// don't see stale tags sticking around in random locations until the next update.  A good example of when this
+        /// is desirable is 'cut line'. If the tags aren't removed, then the line will be gone but the tags will remain
+        /// at whatever points the tracking spans moved them to.
+        /// </summary>
+        protected override TaggerTextChangeBehavior TextChangeBehavior => TaggerTextChangeBehavior.RemoveTagsThatIntersectEdits;
+
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
         [ImportingConstructor]
         public InlineHintsDataTaggerProvider(
@@ -92,6 +101,10 @@ protected override async Task ProduceTagsAsync(TaggerContext<InlineHintDataTag>
             var hints = await service.GetInlineHintsAsync(document, snapshotSpan.Span.ToTextSpan(), cancellationToken).ConfigureAwait(false);
             foreach (var hint in hints)
             {
+                // If we don't have any text to actually show the user, then don't make a tag.
+                if (hint.DisplayParts.Sum(p => p.ToString().Length) == 0)
+                    continue;
+
                 context.AddTag(new TagSpan<InlineHintDataTag>(
                     hint.Span.ToSnapshotSpan(snapshotSpan.Snapshot),
                     new InlineHintDataTag(hint)));

src/EditorFeatures/Core/Shared/Utilities/IThreadingContext.cs

@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System;
 using System.Threading;
 using System.Threading.Tasks;

src/EditorFeatures/Core/Shared/Utilities/ThreadingContext.cs

@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System;
 using System.Composition;
 using System.Threading;

src/VisualStudio/Core/Def/Implementation/Workspace/VisualStudioTaskSchedulerProvider.cs → src/EditorFeatures/Core/Shared/Utilities/ThreadingContextTaskSchedulerProvider.cs

@@ -2,28 +2,30 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Composition;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.VisualStudio.Threading;
+using Roslyn.Utilities;
 
-namespace Microsoft.VisualStudio.LanguageServices.Implementation
+namespace Microsoft.CodeAnalysis.Editor.Shared.Utilities
 {
-    [ExportWorkspaceService(typeof(ITaskSchedulerProvider), ServiceLayer.Host), Shared]
-    internal sealed class VisualStudioTaskSchedulerProvider : ITaskSchedulerProvider
+    [ExportWorkspaceService(typeof(ITaskSchedulerProvider), ServiceLayer.Editor), Shared]
+    internal sealed class ThreadingContextTaskSchedulerProvider : ITaskSchedulerProvider
     {
         public TaskScheduler CurrentContextScheduler { get; }
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public VisualStudioTaskSchedulerProvider(IThreadingContext threadingContext)
-            => CurrentContextScheduler = new JoinableTaskFactoryTaskScheduler(threadingContext.JoinableTaskFactory);
+        public ThreadingContextTaskSchedulerProvider(IThreadingContext threadingContext)
+        {
+            CurrentContextScheduler = threadingContext.HasMainThread
+                ? new JoinableTaskFactoryTaskScheduler(threadingContext.JoinableTaskFactory)
+                : TaskScheduler.Default;
+        }
 
         private sealed class JoinableTaskFactoryTaskScheduler : TaskScheduler
         {
@@ -34,7 +36,8 @@ public JoinableTaskFactoryTaskScheduler(JoinableTaskFactory joinableTaskFactory)
 
             public override int MaximumConcurrencyLevel => 1;
 
-            protected override IEnumerable<Task> GetScheduledTasks() => null;
+            protected override IEnumerable<Task> GetScheduledTasks()
+                => SpecializedCollections.EmptyEnumerable<Task>();
 
             protected override void QueueTask(Task task)
             {

src/EditorFeatures/Test2/InlineHints/AbstractInlineHintsTests.vb

@@ -25,7 +25,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.InlineHints
                 Dim inlineHints = Await tagService.GetInlineHintsAsync(document, New Text.TextSpan(0, snapshot.Length), New CancellationToken())
 
                 Dim producedTags = From hint In inlineHints
-                                   Select hint.DisplayParts.GetFullText() + hint.Span.ToString
+                                   Select hint.DisplayParts.GetFullText().TrimEnd() + hint.Span.ToString
 
                 ValidateSpans(hostDocument, producedTags)
             End Using

src/EditorFeatures/Test2/InlineHints/CSharpInlineTypeHintsTests.vb

@@ -36,7 +36,7 @@ class A
 {
     void Main() 
     {
-        var {|int:|}i = 0;
+        var {|int :|}i = 0;
     }
 }
                     </Document>
@@ -76,7 +76,7 @@ class A
 {
     void Main() 
     {
-        var ({|int:|}i, {|string:|}j) = (0, "");
+        var ({|int :|}i, {|string :|}j) = (0, "");
     }
 }
                     </Document>
@@ -96,7 +96,7 @@ class A
 {
     void Main(string[] args) 
     {
-        foreach (var {|string:|}j in args) {}
+        foreach (var {|string :|}j in args) {}
     }
 }
                     </Document>
@@ -156,7 +156,7 @@ class A
 {
     void Main(string[] args) 
     {
-        if (args is { Length: var {|int:|}goo }) { }
+        if (args is { Length: var {|int :|}goo }) { }
     }
 }
                     </Document>
@@ -217,7 +217,7 @@ class A
 {
     void Main(string[] args) 
     {
-        args.Where({|string:|}a => a.Length > 0);
+        args.Where({|string :|}a => a.Length > 0);
     }
 }
                     </Document>
@@ -238,7 +238,7 @@ class A
 {
     void Main(string[] args) 
     {
-        args.Where(({|string:|}a) => a.Length > 0);
+        args.Where(({|string :|}a) => a.Length > 0);
     }
 }
                     </Document>
@@ -279,7 +279,7 @@ class A
 {
     void Main(string[] args) 
     {
-        if (int.TryParse("", out var {|int:|}x))
+        if (int.TryParse("", out var {|int :|}x))
         {
         }
     }

src/EditorFeatures/TestUtilities/Diagnostics/DiagnosticTaggerWrapper.cs

@@ -97,11 +97,13 @@ public void Dispose()
 
         public async Task WaitForTags()
         {
-            await _listenerProvider.GetWaiter(FeatureAttribute.Workspace).ExpeditedWaitAsync();
-            await _listenerProvider.GetWaiter(FeatureAttribute.SolutionCrawler).ExpeditedWaitAsync();
-            await _listenerProvider.GetWaiter(FeatureAttribute.DiagnosticService).ExpeditedWaitAsync();
-            await _listenerProvider.GetWaiter(FeatureAttribute.ErrorSquiggles).ExpeditedWaitAsync();
-            await _listenerProvider.GetWaiter(FeatureAttribute.Classification).ExpeditedWaitAsync();
+            await _listenerProvider.WaitAllDispatcherOperationAndTasksAsync(
+                _workspace,
+                FeatureAttribute.Workspace,
+                FeatureAttribute.SolutionCrawler,
+                FeatureAttribute.DiagnosticService,
+                FeatureAttribute.ErrorSquiggles,
+                FeatureAttribute.Classification);
         }
     }
 }