Merge master to master-vs-deps

src/EditorFeatures/CSharp/Formatting/CSharpEditorFormattingService.cs

@@ -12,8 +12,6 @@
 using Microsoft.CodeAnalysis.CSharp.Indentation;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Utilities;
-using Microsoft.CodeAnalysis.Editor.CSharp.Formatting.Indentation;
-using Microsoft.CodeAnalysis.Editor.Implementation.Formatting.Indentation;
 using Microsoft.CodeAnalysis.Editor.Shared.Options;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Formatting;

src/EditorFeatures/CSharpTest/Formatting/Indentation/CSharpFormatterTestsBase.cs

@@ -7,10 +7,6 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Indentation;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Editor.CSharp.Formatting.Indentation;
-using Microsoft.CodeAnalysis.Editor.Implementation.Formatting.Indentation;
-using Microsoft.CodeAnalysis.Editor.Implementation.SmartIndent;
-using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Formatting;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Utilities;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
@@ -21,13 +17,7 @@
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
 using Microsoft.VisualStudio.Text;
-using Microsoft.VisualStudio.Text.Editor;
-using Microsoft.VisualStudio.Text.Editor.Commanding.Commands;
-using Microsoft.VisualStudio.Text.Operations;
-using Microsoft.VisualStudio.Text.Projection;
-using Moq;
 using Xunit;
-using static Microsoft.CodeAnalysis.Formatting.FormattingOptions;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Formatting.Indentation
 {
@@ -44,9 +34,6 @@ public class CSharpFormatterTestsBase : CoreFormatterTestsBase
         internal override string GetLanguageName()
             => LanguageNames.CSharp;
 
-        internal override AbstractSmartTokenFormatterCommandHandler CreateSmartTokenFormatterCommandHandler(ITextUndoHistoryRegistry registry, IEditorOperationsFactoryService operations)
-            => new SmartTokenFormatterCommandHandler(registry, operations);
-
         protected static async Task<int> GetSmartTokenFormatterIndentationWorkerAsync(
             TestWorkspace workspace,
             ITextBuffer buffer,

src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterEnterOnTokenTests.cs

@@ -1367,7 +1367,7 @@ private async Task AssertIndentUsingSmartTokenFormatterAsync(
                 Assert.True(
                     CSharpIndentationService.ShouldUseSmartTokenFormatterInsteadOfIndenter(
                         Formatter.GetDefaultFormattingRules(workspace, root.Language),
-                        root, line.AsTextLine(), await document.GetOptionsAsync(), CancellationToken.None));
+                        root, line.AsTextLine(), await document.GetOptionsAsync(), out _));
 
                 var actualIndentation = await GetSmartTokenFormatterIndentationWorkerAsync(workspace, buffer, indentationLine, ch);
                 Assert.Equal(expectedIndentation.Value, actualIndentation);
@@ -1397,7 +1397,7 @@ private async Task AssertIndentNotUsingSmartTokenFormatterButUsingIndenterAsync(
                 Assert.False(
                     CSharpIndentationService.ShouldUseSmartTokenFormatterInsteadOfIndenter(
                         Formatter.GetDefaultFormattingRules(workspace, root.Language),
-                        root, line.AsTextLine(), await document.GetOptionsAsync(), CancellationToken.None));
+                        root, line.AsTextLine(), await document.GetOptionsAsync(), out _));
 
                 TestIndentation(
                     workspace, indentationLine,

src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartIndenterTests.cs

@@ -115,7 +115,7 @@ class Class
             AssertSmartIndent(
                 code,
                 indentationLine: 6,
-                expectedIndentation: null,
+                expectedIndentation: 0,
                 expectedBlankLineIndentation: 0,
                 indentStyle: IndentStyle.None);
         }
@@ -410,15 +410,10 @@ void Method()
                 code,
                 indentationLine: 6,
                 expectedIndentation: 12);
-
-            // This is the line after the method call. ISynchronousIndentationService will bail in
-            // this case as it thinks this is a case for "smart formatting".  However,
-            // IBlankLineIndentationService appropriately picks 8 columns as the location to indent
-            // to.
             AssertSmartIndent(
                 code,
                 indentationLine: 7,
-                expectedIndentation: null,
+                expectedIndentation: 4,
                 expectedBlankLineIndentation: 8);
         }
 

src/EditorFeatures/CSharpTest/Formatting/Indentation/SmartTokenFormatterFormatRangeTests.cs

@@ -5,12 +5,10 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Indentation;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Utilities;
-using Microsoft.CodeAnalysis.Editor.CSharp.Formatting.Indentation;
 using Microsoft.CodeAnalysis.Editor.Implementation.Formatting;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Utilities;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
@@ -22,7 +20,6 @@
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Editor.Commanding.Commands;
-using Microsoft.VisualStudio.Text.Operations;
 using Roslyn.Test.Utilities;
 using Xunit;
 

src/EditorFeatures/CSharpTest/MakeLocalFunctionStatic/MakeLocalFunctionStaticTests.cs

@@ -176,6 +176,222 @@ static async Task<int> fibonacci(int n)
         }
     }
 }",
+parseOptions: CSharp8ParseOptions);
+        }
+
+        [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsMakeLocalFunctionStatic)]
+        [InlineData("")]
+        [InlineData("\r\n")]
+        [InlineData("\r\n\r\n")]
+        public async Task TestLeadingTriviaAfterSemicolon(string leadingTrivia)
+        {
+            await TestInRegularAndScriptAsync(
+$@"using System;
+
+class C
+{{
+    void M()
+    {{
+        int x;{leadingTrivia}
+        int [||]fibonacci(int n)
+        {{
+            return n <= 1 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+        }}
+    }}
+}}",
+@"using System;
+
+class C
+{
+    void M()
+    {
+        int x;
+
+        static int fibonacci(int n)
+        {
+            return n <= 1 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+        }
+    }
+}",
+parseOptions: CSharp8ParseOptions);
+        }
+
+        [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsMakeLocalFunctionStatic)]
+        [InlineData("")]
+        [InlineData("\r\n")]
+        [InlineData("\r\n\r\n")]
+        public async Task TestLeadingTriviaAfterOpenBrace(string leadingTrivia)
+        {
+            await TestInRegularAndScriptAsync(
+$@"using System;
+
+class C
+{{
+    void M()
+    {{{leadingTrivia}
+        int [||]fibonacci(int n)
+        {{
+            return n <= 1 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+        }}
+    }}
+}}",
+@"using System;
+
+class C
+{
+    void M()
+    {
+        static int fibonacci(int n)
+        {
+            return n <= 1 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+        }
+    }
+}",
+parseOptions: CSharp8ParseOptions);
+        }
+
+        [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsMakeLocalFunctionStatic)]
+        [InlineData("")]
+        [InlineData("\r\n")]
+        [InlineData("\r\n\r\n")]
+        public async Task TestLeadingTriviaAfterLocalFunction(string leadingTrivia)
+        {
+            await TestInRegularAndScriptAsync(
+$@"using System;
+
+class C
+{{
+    void M()
+    {{
+        bool otherFunction()
+        {{
+            return true;
+        }}{leadingTrivia}
+        int [||]fibonacci(int n)
+        {{
+            return n <= 1 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+        }}
+    }}
+}}",
+@"using System;
+
+class C
+{
+    void M()
+    {
+        bool otherFunction()
+        {
+            return true;
+        }
+
+        static int fibonacci(int n)
+        {
+            return n <= 1 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+        }
+    }
+}",
+parseOptions: CSharp8ParseOptions);
+        }
+
+        [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsMakeLocalFunctionStatic)]
+        [InlineData("")]
+        [InlineData("\r\n")]
+        [InlineData("\r\n\r\n")]
+        public async Task TestLeadingTriviaAfterExpressionBodyLocalFunction(string leadingTrivia)
+        {
+            await TestInRegularAndScriptAsync(
+$@"using System;
+
+class C
+{{
+    void M()
+    {{
+        bool otherFunction() => true;{leadingTrivia}
+        int [||]fibonacci(int n) => n <= 1 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+    }}
+}}",
+@"using System;
+
+class C
+{
+    void M()
+    {
+        bool otherFunction() => true;
+
+        static int fibonacci(int n) => n <= 1 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+    }
+}",
+parseOptions: CSharp8ParseOptions);
+        }
+
+        [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsMakeLocalFunctionStatic)]
+        [InlineData("")]
+        [InlineData("\r\n")]
+        [InlineData("\r\n\r\n")]
+        public async Task TestLeadingTriviaAfterComment(string leadingTrivia)
+        {
+            await TestInRegularAndScriptAsync(
+$@"using System;
+
+class C
+{{
+    void M()
+    {{
+        //Local function comment{leadingTrivia}
+        int [||]fibonacci(int n)
+        {{
+            return n <= 1 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+        }}
+    }}
+}}",
+$@"using System;
+
+class C
+{{
+    void M()
+    {{
+        //Local function comment{leadingTrivia}
+        static int fibonacci(int n)
+        {{
+            return n <= 1 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+        }}
+    }}
+}}",
+parseOptions: CSharp8ParseOptions);
+        }
+
+        [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsMakeLocalFunctionStatic)]
+        [InlineData("\r\n")]
+        [InlineData("\r\n\r\n")]
+        public async Task TestLeadingTriviaBeforeComment(string leadingTrivia)
+        {
+            await TestInRegularAndScriptAsync(
+$@"using System;
+
+class C
+{{
+    void M()
+    {{{leadingTrivia}
+        //Local function comment
+        int [||]fibonacci(int n)
+        {{
+            return n <= 1 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+        }}
+    }}
+}}",
+$@"using System;
+
+class C
+{{
+    void M()
+    {{{leadingTrivia}
+        //Local function comment
+        static int fibonacci(int n)
+        {{
+            return n <= 1 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+        }}
+    }}
+}}",
 parseOptions: CSharp8ParseOptions);
         }
     }