Add style option (and UI) for preferring file scoped namespaces

src/Analyzers/Core/Analyzers/AbstractBuiltInCodeStyleDiagnosticAnalyzer_Core.cs

@@ -50,13 +50,13 @@ protected static DiagnosticDescriptor CreateDescriptorWithId(
             string id,
             EnforceOnBuild enforceOnBuild,
             LocalizableString title,
-            LocalizableString messageFormat,
+            LocalizableString? messageFormat = null,
             bool isUnnecessary = false,
             bool isConfigurable = true,
             LocalizableString? description = null)
 #pragma warning disable RS0030 // Do not used banned APIs
             => new(
-                    id, title, messageFormat,
+                    id, title, messageFormat ?? title,
                     DiagnosticCategory.Style,
                     DiagnosticSeverity.Hidden,
                     isEnabledByDefault: true,

src/Analyzers/Core/Analyzers/EnforceOnBuildValues.cs

@@ -26,6 +26,8 @@ internal static class EnforceOnBuildValues
         public const EnforceOnBuild InvalidSuppressMessageAttribute = /*IDE0076*/ EnforceOnBuild.HighlyRecommended;
         public const EnforceOnBuild LegacyFormatSuppressMessageAttribute = /*IDE0077*/ EnforceOnBuild.HighlyRecommended;
         public const EnforceOnBuild RemoveConfusingSuppressionForIsExpression = /*IDE0080*/ EnforceOnBuild.HighlyRecommended;
+        public const EnforceOnBuild UseRegularNamespace = /*IDE0160*/ EnforceOnBuild.HighlyRecommended;
+        public const EnforceOnBuild UseFileScopedNamespace = /*IDE0161*/ EnforceOnBuild.HighlyRecommended;
 
         /* EnforceOnBuild.Recommended */
         public const EnforceOnBuild UseThrowExpression = /*IDE0016*/ EnforceOnBuild.Recommended;

src/Analyzers/Core/Analyzers/IDEDiagnosticIds.cs

@@ -162,6 +162,9 @@ internal static class IDEDiagnosticIds
 
         public const string UseNullCheckOverTypeCheckDiagnosticId = "IDE0150";
 
+        public const string UseRegularNamespaceDiagnosticId = "IDE0160";
+        public const string UseFileScopedNamespaceDiagnosticId = "IDE0161";
+
         // Analyzer error Ids
         public const string AnalyzerChangedId = "IDE1001";
         public const string AnalyzerDependencyConflictId = "IDE1002";

src/Analyzers/Core/CodeFixes/PredefinedCodeFixProviderNames.cs

@@ -17,6 +17,7 @@ internal static class PredefinedCodeFixProviderNames
         public const string ChangeToYield = nameof(ChangeToYield);
         public const string ConvertToAsync = nameof(ConvertToAsync);
         public const string ConvertToIterator = nameof(ConvertToIterator);
+        public const string ConvertNamespace = nameof(ConvertNamespace);
         public const string CorrectNextControlVariable = nameof(CorrectNextControlVariable);
         public const string ConvertTypeOfToNameOf = nameof(ConvertTypeOfToNameOf);
         public const string RemoveDocCommentNode = nameof(RemoveDocCommentNode);

src/Features/CSharp/Portable/CSharpFeaturesResources.resx

@@ -628,4 +628,12 @@
   <data name="record_struct" xml:space="preserve">
     <value>record struct</value>
   </data>
+  <data name="Convert_to_file_scoped_namespace" xml:space="preserve">
+    <value>Convert to file-scoped namespace</value>
+    <comment>{Locked="namespace"} "namespace" is a C# keyword and should not be localized.</comment>
+  </data>
+  <data name="Convert_to_regular_namespace" xml:space="preserve">
+    <value>Convert to regular namespace</value>
+    <comment>{Locked="namespace"} "namespace" is a C# keyword and should not be localized.</comment>
+  </data>
 </root>

src/Features/CSharp/Portable/ConvertNamespace/ConvertNamespaceCodeFixProvider.cs

@@ -0,0 +1,70 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Immutable;
+using System.Composition;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+
+namespace Microsoft.CodeAnalysis.CSharp.ConvertNamespace
+{
+    [ExportCodeFixProvider(LanguageNames.CSharp, Name = PredefinedCodeFixProviderNames.ConvertNamespace), Shared]
+    internal class ConvertNamespaceCodeFixProvider : SyntaxEditorBasedCodeFixProvider
+    {
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public ConvertNamespaceCodeFixProvider()
+        {
+        }
+
+        internal override CodeFixCategory CodeFixCategory => CodeFixCategory.CodeStyle;
+        public override ImmutableArray<string> FixableDiagnosticIds
+            => ImmutableArray.Create(IDEDiagnosticIds.UseRegularNamespaceDiagnosticId, IDEDiagnosticIds.UseFileScopedNamespaceDiagnosticId);
+
+        public override Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            var diagnostic = context.Diagnostics.First();
+
+            var title = diagnostic.Id == IDEDiagnosticIds.UseFileScopedNamespaceDiagnosticId
+                ? CSharpFeaturesResources.Convert_to_file_scoped_namespace
+                : CSharpFeaturesResources.Convert_to_regular_namespace;
+
+            context.RegisterCodeFix(
+                new MyCodeAction(title, c => FixAsync(context.Document, diagnostic, c)),
+                context.Diagnostics);
+
+            return Task.CompletedTask;
+        }
+
+        protected override Task FixAllAsync(
+            Document document, ImmutableArray<Diagnostic> diagnostics,
+            SyntaxEditor editor, CancellationToken cancellationToken)
+        {
+            var diagnostic = diagnostics.First();
+
+            var namespaceDecl = (BaseNamespaceDeclarationSyntax)diagnostic.Location.FindNode(cancellationToken);
+            var converted = ConvertNamespaceHelper.Convert(namespaceDecl);
+
+            editor.ReplaceNode(namespaceDecl, converted);
+            return Task.CompletedTask;
+        }
+
+        private class MyCodeAction : CodeAction.DocumentChangeAction
+        {
+            public MyCodeAction(string title, Func<CancellationToken, Task<Document>> createChangedDocument)
+                : base(title, createChangedDocument, title)
+            {
+            }
+        }
+    }
+}

src/Features/CSharp/Portable/ConvertNamespace/ConvertNamespaceCodeRefactoringProvider.cs

@@ -0,0 +1,76 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Composition;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeRefactorings;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp.ConvertNamespace
+{
+    [ExportCodeRefactoringProvider(LanguageNames.CSharp), Shared]
+    internal class ConvertNamespaceCodeRefactoringProvider : CodeRefactoringProvider
+    {
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public ConvertNamespaceCodeRefactoringProvider()
+        {
+        }
+
+        public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
+        {
+            var (document, span, cancellationToken) = context;
+            if (!span.IsEmpty)
+                return;
+
+            var position = span.Start;
+            var root = (CompilationUnitSyntax)await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var token = root.FindToken(position);
+            var namespaceDecl = token.GetAncestor<BaseNamespaceDeclarationSyntax>();
+            if (namespaceDecl == null)
+                return;
+
+            if (!IsValidPosition(namespaceDecl, position))
+                return;
+
+            var optionSet = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+            var title =
+                ConvertNamespaceHelper.CanOfferUseRegular(optionSet, namespaceDecl, forAnalyzer: false) ? CSharpFeaturesResources.Convert_to_regular_namespace :
+                ConvertNamespaceHelper.CanOfferUseFileScoped(optionSet, root, namespaceDecl, forAnalyzer: false) ? CSharpFeaturesResources.Convert_to_file_scoped_namespace : null;
+            if (title == null)
+                return;
+
+            context.RegisterRefactoring(new MyCodeAction(
+                title, c => ConvertNamespaceHelper.ConvertAsync(document, namespaceDecl, c)));
+        }
+
+        private static bool IsValidPosition(BaseNamespaceDeclarationSyntax baseDeclaration, int position)
+        {
+            if (position < baseDeclaration.SpanStart)
+                return false;
+
+            if (baseDeclaration is FileScopedNamespaceDeclarationSyntax fileScopedNamespace)
+                return position <= fileScopedNamespace.SemicolonToken.Span.End;
+
+            if (baseDeclaration is NamespaceDeclarationSyntax namespaceDeclaration)
+                return position <= namespaceDeclaration.Name.Span.End;
+
+            throw ExceptionUtilities.UnexpectedValue(baseDeclaration.Kind());
+        }
+
+        private class MyCodeAction : CodeAction.DocumentChangeAction
+        {
+            public MyCodeAction(string title, Func<CancellationToken, Task<Document>> createChangedDocument)
+                : base(title, createChangedDocument, title)
+            {
+            }
+        }
+    }
+}

src/Features/CSharp/Portable/ConvertNamespace/ConvertNamespaceDiagnosticAnalyzer.cs

@@ -0,0 +1,86 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.CSharp.ConvertNamespace
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    internal class ConvertNamespaceDiagnosticAnalyzer : AbstractBuiltInCodeStyleDiagnosticAnalyzer
+    {
+        private static readonly DiagnosticDescriptor s_useRegularNamespaceDescriptor = CreateDescriptorWithId(
+            IDEDiagnosticIds.UseRegularNamespaceDiagnosticId,
+            EnforceOnBuildValues.UseRegularNamespace,
+            new LocalizableResourceString(nameof(CSharpFeaturesResources.Convert_to_regular_namespace), CSharpFeaturesResources.ResourceManager, typeof(CSharpFeaturesResources)));
+
+        private static readonly DiagnosticDescriptor s_useFileScopedNamespaceDescriptor = CreateDescriptorWithId(
+            IDEDiagnosticIds.UseFileScopedNamespaceDiagnosticId,
+            EnforceOnBuildValues.UseFileScopedNamespace,
+            new LocalizableResourceString(nameof(CSharpFeaturesResources.Convert_to_file_scoped_namespace), CSharpFeaturesResources.ResourceManager, typeof(CSharpFeaturesResources)));
+
+        private static readonly ImmutableDictionary<DiagnosticDescriptor, ILanguageSpecificOption> s_descriptors =
+            ImmutableDictionary<DiagnosticDescriptor, ILanguageSpecificOption>.Empty
+                .Add(s_useRegularNamespaceDescriptor, CSharpCodeStyleOptions.PreferFileScopedNamespace)
+                .Add(s_useFileScopedNamespaceDescriptor, CSharpCodeStyleOptions.PreferFileScopedNamespace);
+
+        public ConvertNamespaceDiagnosticAnalyzer()
+            : base(s_descriptors, LanguageNames.CSharp)
+        {
+        }
+
+        public sealed override DiagnosticAnalyzerCategory GetAnalyzerCategory()
+            => DiagnosticAnalyzerCategory.SemanticSpanAnalysis;
+
+        protected override void InitializeWorker(AnalysisContext context)
+            => context.RegisterSyntaxNodeAction(AnalyzeNamespace, SyntaxKind.NamespaceDeclaration, SyntaxKind.FileScopedNamespaceDeclaration);
+
+        private void AnalyzeNamespace(SyntaxNodeAnalysisContext context)
+        {
+            var options = context.Options;
+            var namespaceDeclaration = (BaseNamespaceDeclarationSyntax)context.Node;
+            var syntaxTree = namespaceDeclaration.SyntaxTree;
+
+            var cancellationToken = context.CancellationToken;
+            var root = (CompilationUnitSyntax)syntaxTree.GetRoot(cancellationToken);
+
+            var optionSet = options.GetAnalyzerOptionSet(syntaxTree, cancellationToken);
+
+            var diagnostic = AnalyzeNamespace(optionSet, root, namespaceDeclaration);
+            if (diagnostic != null)
+                context.ReportDiagnostic(diagnostic);
+        }
+
+        private static Diagnostic? AnalyzeNamespace(OptionSet optionSet, CompilationUnitSyntax root, BaseNamespaceDeclarationSyntax declaration)
+        {
+            var tree = declaration.SyntaxTree;
+            var preferFileScopedNamespace = optionSet.GetOption(CSharpCodeStyleOptions.PreferFileScopedNamespace);
+            var severity = preferFileScopedNamespace.Notification.Severity;
+
+            var descriptor =
+                ConvertNamespaceHelper.CanOfferUseRegular(optionSet, declaration, forAnalyzer: true) ? s_useRegularNamespaceDescriptor :
+                ConvertNamespaceHelper.CanOfferUseFileScoped(optionSet, root, declaration, forAnalyzer: true) ? s_useFileScopedNamespaceDescriptor : null;
+            if (descriptor == null)
+                return null;
+
+            // if the diagnostic is hidden, show it anywhere from the `namespace` keyword through the name.
+            // otherwise, if it's not hidden, just squiggle the name.
+            var diagnosticLocation = severity.WithDefaultSeverity(DiagnosticSeverity.Hidden) == ReportDiagnostic.Hidden
+                ? tree.GetLocation(TextSpan.FromBounds(declaration.SpanStart, declaration.Name.Span.End))
+                : declaration.Name.GetLocation();
+
+            return DiagnosticHelper.Create(
+                descriptor,
+                diagnosticLocation,
+                severity,
+                ImmutableArray.Create(declaration.GetLocation()),
+                ImmutableDictionary<string, string>.Empty);
+        }
+    }
+}