Move to Roslyn's editorconfig support

.vscode/launch.json

@@ -5,7 +5,7 @@
   "version": "0.2.0",
   "configurations": [
     {
-      "name": "dotnet-format -f --check",
+      "name": "format -f --check",
       "type": "coreclr",
       "request": "launch",
       "preLaunchTask": "build",
@@ -15,15 +15,15 @@
         "-f",
         "-v",
         "diag",
-        "--check",
+        "--check"
       ],
       "cwd": "${workspaceFolder}/src",
       // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
       "console": "internalConsole",
       "stopAtEntry": false
     },
     {
-      "name": "dotnet-format format.sln --check",
+      "name": "format format.sln --check",
       "type": "coreclr",
       "request": "launch",
       "preLaunchTask": "build",

NuGet.config

@@ -5,7 +5,6 @@
     <add key="dotnet-eng" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/index.json" />
     <add key="roslyn" value="https://dotnet.myget.org/F/roslyn/api/v3/index.json" />
     <add key="roslyn-analyzers" value="https://dotnet.myget.org/F/roslyn-analyzers/api/v3/index.json" />
-    <add key="vs-editor" value="https://myget.org/F/vs-editor/api/v3/index.json" />
     <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
   </packageSources>
 </configuration>

eng/Versions.props

@@ -24,10 +24,12 @@
     <MicrosoftExtensionsDependencyInjectionVersion>$(MicrosoftExtensionsVersion)</MicrosoftExtensionsDependencyInjectionVersion>
     <MicrosoftExtensionsFileSystemGlobbingVersion>$(MicrosoftExtensionsVersion)</MicrosoftExtensionsFileSystemGlobbingVersion>
     <MicrosoftExtensionsLoggingVersion>$(MicrosoftExtensionsVersion)</MicrosoftExtensionsLoggingVersion>
-    <MicrosoftVisualStudioCodingConventionsVersion>1.1.20180503.2</MicrosoftVisualStudioCodingConventionsVersion>
     <MicrosoftCodeAnalysisAnalyzersVersion>3.0.0</MicrosoftCodeAnalysisAnalyzersVersion>
     <MicrosoftCodeAnalysisVersion>$(MicrosoftNETCoreCompilersPackageVersion)</MicrosoftCodeAnalysisVersion>
     <SystemTextJsonVersion>4.7.0</SystemTextJsonVersion>
+
+    <!-- Resolves the inability to load the NugetSdkResolver from the .NET 5 SDK -->
+    <NewtonsoftJsonVersion>12.0.2</NewtonsoftJsonVersion>
   </PropertyGroup>
   <PropertyGroup>
     <DiscoverEditorConfigFiles>true</DiscoverEditorConfigFiles>

eng/format-verifier.ps1

@@ -19,7 +19,7 @@ try {
 
     if ($stage -eq "prepare") {
         Write-Output "$(Get-Date) - Cloning $repoName."
-        git.exe clone $repo $repoPath
+        git.exe clone $repo $repoPath -b master --single-branch --no-tags
     }
 
     Set-Location $repoPath
@@ -56,7 +56,7 @@ try {
 
             if ($stage -eq "format-workspace") {
                 Write-Output "$(Get-Date) - $solutionFile - Formatting Workspace"
-                $output = dotnet.exe run -p "$currentLocation\src\dotnet-format.csproj" -c Release -- -w $solution -v d --dry-run | Out-String
+                $output = dotnet.exe run -p "$currentLocation\src\dotnet-format.csproj" -c Release -- $solution -v diag --check | Out-String
                 Write-Output $output.TrimEnd()
 
                 # Ignore CheckFailedExitCode since we don't expect these repos to be properly formatted.
@@ -77,7 +77,7 @@ try {
 
     if ($stage -eq "format-folder") {
         Write-Output "$(Get-Date) - $folderName - Formatting Folder"
-        $output = dotnet.exe run -p "$currentLocation\src\dotnet-format.csproj" -c Release -- -f $repoPath -v d --dry-run | Out-String
+        $output = dotnet.exe run -p "$currentLocation\src\dotnet-format.csproj" -c Release -- -f $repoPath -v diag --check | Out-String
         Write-Output $output.TrimEnd()
 
         # Ignore CheckFailedExitCode since we don't expect these repos to be properly formatted.

src/DocumentWithOptions.cs

@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Options;
+
+namespace Microsoft.CodeAnalysis.Tools
+{
+    internal struct DocumentWithOptions
+    {
+        public Document Document { get; }
+        public OptionSet OptionSet { get; }
+        public AnalyzerConfigOptions? AnalyzerConfigOptions { get; }
+
+        public DocumentWithOptions(Document document, OptionSet optionSet, AnalyzerConfigOptions? analyzerConfigOptions)
+        {
+            Document = document;
+            OptionSet = optionSet;
+            AnalyzerConfigOptions = analyzerConfigOptions;
+        }
+
+        public void Deconstruct(
+            out Document document,
+            out OptionSet optionSet,
+            out AnalyzerConfigOptions? analyzerConfigOptions)
+        {
+            document = Document;
+            optionSet = OptionSet;
+            analyzerConfigOptions = AnalyzerConfigOptions;
+        }
+    }
+}

src/Formatters/CharsetFormatter.cs

@@ -6,10 +6,10 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.Extensions.Logging;
-using Microsoft.VisualStudio.CodingConventions;
 
 namespace Microsoft.CodeAnalysis.Tools.Formatters
 {
@@ -23,15 +23,15 @@ internal sealed class CharsetFormatter : DocumentFormatter
         protected override Task<SourceText> FormatFileAsync(
             Document document,
             SourceText sourceText,
-            OptionSet options,
-            ICodingConventionsSnapshot codingConventions,
+            OptionSet optionSet,
+            AnalyzerConfigOptions? analyzerConfigOptions,
             FormatOptions formatOptions,
             ILogger logger,
             CancellationToken cancellationToken)
         {
             return Task.Run(() =>
             {
-                if (!TryGetCharset(codingConventions, out var encoding)
+                if (!TryGetCharset(analyzerConfigOptions, out var encoding)
                     || sourceText.Encoding?.Equals(encoding) == true
                     || IsEncodingEquivalent(sourceText, encoding))
                 {
@@ -67,9 +67,10 @@ private static byte[] GetEncodedBytes(string text, Encoding encoding)
             return stream.ToArray();
         }
 
-        private static bool TryGetCharset(ICodingConventionsSnapshot codingConventions, [NotNullWhen(true)] out Encoding? encoding)
+        private static bool TryGetCharset(AnalyzerConfigOptions? analyzerConfigOptions, [NotNullWhen(true)] out Encoding? encoding)
         {
-            if (codingConventions.TryGetConventionValue("charset", out string charsetOption))
+            if (analyzerConfigOptions is object &&
+                analyzerConfigOptions.TryGetValue("charset", out var charsetOption))
             {
                 encoding = GetCharset(charsetOption);
                 return true;

src/Formatters/DocumentFormatter.cs

@@ -6,10 +6,10 @@
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.Extensions.Logging;
-using Microsoft.VisualStudio.CodingConventions;
 
 namespace Microsoft.CodeAnalysis.Tools.Formatters
 {
@@ -25,7 +25,7 @@ internal abstract class DocumentFormatter : ICodeFormatter
         /// </summary>
         public async Task<Solution> FormatAsync(
             Solution solution,
-            ImmutableArray<(DocumentId, OptionSet, ICodingConventionsSnapshot)> formattableDocuments,
+            ImmutableArray<DocumentWithOptions> formattableDocuments,
             FormatOptions formatOptions,
             ILogger logger,
             List<FormattedFile> formattedFiles,
@@ -41,8 +41,8 @@ internal abstract class DocumentFormatter : ICodeFormatter
         protected abstract Task<SourceText> FormatFileAsync(
             Document document,
             SourceText sourceText,
-            OptionSet options,
-            ICodingConventionsSnapshot codingConventions,
+            OptionSet optionSet,
+            AnalyzerConfigOptions? analyzerConfigOptions,
             FormatOptions formatOptions,
             ILogger logger,
             CancellationToken cancellationToken);
@@ -52,20 +52,21 @@ internal abstract class DocumentFormatter : ICodeFormatter
         /// </summary>
         private ImmutableArray<(Document, Task<(SourceText originalText, SourceText? formattedText)>)> FormatFiles(
             Solution solution,
-            ImmutableArray<(DocumentId, OptionSet, ICodingConventionsSnapshot)> formattableDocuments,
+            ImmutableArray<DocumentWithOptions> formattableDocuments,
             FormatOptions formatOptions,
             ILogger logger,
             CancellationToken cancellationToken)
         {
             var formattedDocuments = ImmutableArray.CreateBuilder<(Document, Task<(SourceText originalText, SourceText? formattedText)>)>(formattableDocuments.Length);
 
-            foreach (var (documentId, options, codingConventions) in formattableDocuments)
+            foreach (var formattableDocument in formattableDocuments)
             {
-                var document = solution.GetDocument(documentId);
+                var document = solution.GetDocument(formattableDocument.Document.Id);
                 if (document is null)
                     continue;
 
-                var formatTask = Task.Run(async () => await GetFormattedSourceTextAsync(document, options, codingConventions, formatOptions, logger, cancellationToken).ConfigureAwait(false), cancellationToken);
+                var formatTask = Task.Run(async ()
+                    => await GetFormattedSourceTextAsync(document, formattableDocument.OptionSet, formattableDocument.AnalyzerConfigOptions, formatOptions, logger, cancellationToken).ConfigureAwait(false), cancellationToken);
 
                 formattedDocuments.Add((document, formatTask));
             }
@@ -78,14 +79,14 @@ internal abstract class DocumentFormatter : ICodeFormatter
         /// </summary>
         private async Task<(SourceText originalText, SourceText? formattedText)> GetFormattedSourceTextAsync(
             Document document,
-            OptionSet options,
-            ICodingConventionsSnapshot codingConventions,
+            OptionSet optionSet,
+            AnalyzerConfigOptions? analyzerConfigOptions,
             FormatOptions formatOptions,
             ILogger logger,
             CancellationToken cancellationToken)
         {
             var originalSourceText = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
-            var formattedSourceText = await FormatFileAsync(document, originalSourceText, options, codingConventions, formatOptions, logger, cancellationToken).ConfigureAwait(false);
+            var formattedSourceText = await FormatFileAsync(document, originalSourceText, optionSet, analyzerConfigOptions, formatOptions, logger, cancellationToken).ConfigureAwait(false);
 
             return !formattedSourceText.ContentEquals(originalSourceText) || !formattedSourceText.Encoding?.Equals(originalSourceText.Encoding) == true
                 ? (originalSourceText, formattedSourceText)

src/Formatters/EndOfLineFormatter.cs

@@ -4,10 +4,10 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.Extensions.Logging;
-using Microsoft.VisualStudio.CodingConventions;
 
 namespace Microsoft.CodeAnalysis.Tools.Formatters
 {
@@ -18,15 +18,15 @@ internal sealed class EndOfLineFormatter : DocumentFormatter
         protected override Task<SourceText> FormatFileAsync(
             Document document,
             SourceText sourceText,
-            OptionSet options,
-            ICodingConventionsSnapshot codingConventions,
+            OptionSet optionSet,
+            AnalyzerConfigOptions? analyzerConfigOptions,
             FormatOptions formatOptions,
             ILogger logger,
             CancellationToken cancellationToken)
         {
             return Task.Run(() =>
             {
-                if (!TryGetEndOfLine(codingConventions, out var endOfLine))
+                if (!TryGetEndOfLine(analyzerConfigOptions, out var endOfLine))
                 {
                     return sourceText;
                 }
@@ -58,9 +58,10 @@ internal sealed class EndOfLineFormatter : DocumentFormatter
             });
         }
 
-        public static bool TryGetEndOfLine(ICodingConventionsSnapshot codingConventions, [NotNullWhen(true)] out string? endOfLine)
+        public static bool TryGetEndOfLine(AnalyzerConfigOptions? analyzerConfigOptions, [NotNullWhen(true)] out string? endOfLine)
         {
-            if (codingConventions.TryGetConventionValue("end_of_line", out string endOfLineOption))
+            if (analyzerConfigOptions is object &&
+                analyzerConfigOptions.TryGetValue("end_of_line", out var endOfLineOption))
             {
                 endOfLine = GetEndOfLine(endOfLineOption);
                 return true;

src/Formatters/FinalNewlineFormatter.cs

@@ -4,10 +4,10 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.Extensions.Logging;
-using Microsoft.VisualStudio.CodingConventions;
 
 namespace Microsoft.CodeAnalysis.Tools.Formatters
 {
@@ -18,18 +18,20 @@ internal sealed class FinalNewlineFormatter : DocumentFormatter
         protected override async Task<SourceText> FormatFileAsync(
             Document document,
             SourceText sourceText,
-            OptionSet options,
-            ICodingConventionsSnapshot codingConventions,
+            OptionSet optionSet,
+            AnalyzerConfigOptions? analyzerConfigOptions,
             FormatOptions formatOptions,
             ILogger logger,
             CancellationToken cancellationToken)
         {
-            if (!codingConventions.TryGetConventionValue("insert_final_newline", out bool insertFinalNewline))
+            if (analyzerConfigOptions is null ||
+                !analyzerConfigOptions.TryGetValue("insert_final_newline", out var insertFinalNewlineValue) ||
+                !bool.TryParse(insertFinalNewlineValue, out var insertFinalNewline))
             {
                 return await document.GetTextAsync(cancellationToken);
             }
 
-            if (!EndOfLineFormatter.TryGetEndOfLine(codingConventions, out var endOfLine))
+            if (!EndOfLineFormatter.TryGetEndOfLine(analyzerConfigOptions, out var endOfLine))
             {
                 endOfLine = Environment.NewLine;
             }

src/Formatters/ICodeFormatter.cs

@@ -4,9 +4,7 @@
 using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.Options;
 using Microsoft.Extensions.Logging;
-using Microsoft.VisualStudio.CodingConventions;
 
 namespace Microsoft.CodeAnalysis.Tools.Formatters
 {
@@ -17,7 +15,7 @@ internal interface ICodeFormatter
         /// </summary>
         Task<Solution> FormatAsync(
             Solution solution,
-            ImmutableArray<(DocumentId, OptionSet, ICodingConventionsSnapshot)> formattableDocuments,
+            ImmutableArray<DocumentWithOptions> formattableDocuments,
             FormatOptions options,
             ILogger logger,
             List<FormattedFile> formattedFiles,

src/Formatters/WhitespaceFormatter.cs

@@ -1,14 +1,12 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
 
-using System.Buffers;
-using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.Extensions.Logging;
-using Microsoft.VisualStudio.CodingConventions;
 
 namespace Microsoft.CodeAnalysis.Tools.Formatters
 {
@@ -22,38 +20,38 @@ internal sealed class WhitespaceFormatter : DocumentFormatter
         protected override async Task<SourceText> FormatFileAsync(
             Document document,
             SourceText sourceText,
-            OptionSet options,
-            ICodingConventionsSnapshot codingConventions,
+            OptionSet optionSet,
+            AnalyzerConfigOptions? analyzerConfigOptions,
             FormatOptions formatOptions,
             ILogger logger,
             CancellationToken cancellationToken)
         {
             if (formatOptions.SaveFormattedFiles)
             {
-                return await GetFormattedDocument(document, options, cancellationToken);
+                return await GetFormattedDocument(document, optionSet, cancellationToken);
             }
             else
             {
-                return await GetFormattedDocumentWithDetailedChanges(document, sourceText, options, cancellationToken);
+                return await GetFormattedDocumentWithDetailedChanges(document, sourceText, optionSet, cancellationToken);
             }
         }
 
         /// <summary>
         /// Returns a formatted <see cref="SourceText"/> with a single <see cref="TextChange"/> that encompasses the entire document.
         /// </summary>
-        private static async Task<SourceText> GetFormattedDocument(Document document, OptionSet options, CancellationToken cancellationToken)
+        private static async Task<SourceText> GetFormattedDocument(Document document, OptionSet optionSet, CancellationToken cancellationToken)
         {
-            var formattedDocument = await Formatter.FormatAsync(document, options, cancellationToken).ConfigureAwait(false);
+            var formattedDocument = await Formatter.FormatAsync(document, optionSet, cancellationToken).ConfigureAwait(false);
             return await formattedDocument.GetTextAsync(cancellationToken).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Returns a formatted <see cref="SoureText"/> with multiple <see cref="TextChange"/>s for each formatting change.
         /// </summary>
-        private static async Task<SourceText> GetFormattedDocumentWithDetailedChanges(Document document, SourceText sourceText, OptionSet options, CancellationToken cancellationToken)
+        private static async Task<SourceText> GetFormattedDocumentWithDetailedChanges(Document document, SourceText sourceText, OptionSet optionSet, CancellationToken cancellationToken)
         {
             var root = await document.GetSyntaxRootAsync(cancellationToken);
-            var formattingTextChanges = Formatter.GetFormattedTextChanges(root, document.Project.Solution.Workspace, options, cancellationToken);
+            var formattingTextChanges = Formatter.GetFormattedTextChanges(root, document.Project.Solution.Workspace, optionSet, cancellationToken);
 
             return sourceText.WithChanges(formattingTextChanges);
         }