Update preferred code style

Author: sharwell

.editorconfig

@@ -6,14 +6,72 @@ insert_final_newline = true
 indent_style = space
 indent_size = 4
 
+# Non-private static fields are PascalCase
+dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.severity = silent
+dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.symbols = non_private_static_fields
+dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.style = non_private_static_field_style
+
+dotnet_naming_symbols.non_private_static_fields.applicable_kinds = field
+dotnet_naming_symbols.non_private_static_fields.applicable_accessibilities = public, protected, internal, protected internal, private protected
+dotnet_naming_symbols.non_private_static_fields.required_modifiers = static
+
+dotnet_naming_style.non_private_static_field_style.capitalization = pascal_case
+
+# Constants are PascalCase
+dotnet_naming_rule.constants_should_be_pascal_case.severity = silent
+dotnet_naming_rule.constants_should_be_pascal_case.symbols = constants
+dotnet_naming_rule.constants_should_be_pascal_case.style = constant_style
+
+dotnet_naming_symbols.constants.applicable_kinds = field, local
+dotnet_naming_symbols.constants.required_modifiers = const
+
+dotnet_naming_style.constant_style.capitalization = pascal_case
+
+# Fields are camelCase and start with _
+dotnet_naming_rule.instance_fields_should_be_camel_case.severity = silent
+dotnet_naming_rule.instance_fields_should_be_camel_case.symbols = instance_fields
+dotnet_naming_rule.instance_fields_should_be_camel_case.style = instance_field_style
+
+dotnet_naming_symbols.instance_fields.applicable_kinds = field
+
+dotnet_naming_style.instance_field_style.capitalization = camel_case
+dotnet_naming_style.instance_field_style.required_prefix = _
+
+# Locals and parameters are camelCase
+dotnet_naming_rule.locals_should_be_camel_case.severity = silent
+dotnet_naming_rule.locals_should_be_camel_case.symbols = locals_and_parameters
+dotnet_naming_rule.locals_should_be_camel_case.style = camel_case_style
+
+dotnet_naming_symbols.locals_and_parameters.applicable_kinds = parameter, local
+
+dotnet_naming_style.camel_case_style.capitalization = camel_case
+
+# Local functions are PascalCase
+dotnet_naming_rule.local_functions_should_be_pascal_case.severity = silent
+dotnet_naming_rule.local_functions_should_be_pascal_case.symbols = local_functions
+dotnet_naming_rule.local_functions_should_be_pascal_case.style = local_function_style
+
+dotnet_naming_symbols.local_functions.applicable_kinds = local_function
+
+dotnet_naming_style.local_function_style.capitalization = pascal_case
+
+# By default, name items with PascalCase
+dotnet_naming_rule.members_should_be_pascal_case.severity = silent
+dotnet_naming_rule.members_should_be_pascal_case.symbols = all_members
+dotnet_naming_rule.members_should_be_pascal_case.style = pascal_case_style
+
+dotnet_naming_symbols.all_members.applicable_kinds = *
+
+dotnet_naming_style.pascal_case_style.capitalization = pascal_case
+
 # Sort using and Import directives with System.* appearing first
 dotnet_sort_system_directives_first = true
 
-# Always use "this." and "Me." when applicable; let StyleCop Analyzers provide the warning and fix
-dotnet_style_qualification_for_field = true:none
-dotnet_style_qualification_for_property = true:none
-dotnet_style_qualification_for_method = true:none
-dotnet_style_qualification_for_event = true:none
+# Only use "this." and "Me." when required; let StyleCop Analyzers provide the warning and fix
+dotnet_style_qualification_for_field = false:none
+dotnet_style_qualification_for_property = false:none
+dotnet_style_qualification_for_method = false:none
+dotnet_style_qualification_for_event = false:none
 
 # Use language keywords where applicable; let StyleCop Analyzers provide the warning and fix
 dotnet_style_predefined_type_for_locals_parameters_members = true:none

DocumentationAnalyzers/DocumentationAnalyzers.CodeFixes/Helpers/CustomBatchFixAllProvider.cs

@@ -31,13 +31,13 @@ public override async Task<CodeAction> GetFixAsync(FixAllContext fixAllContext)
         {
             if (fixAllContext.Document != null)
             {
-                var documentsAndDiagnosticsToFixMap = await this.GetDocumentDiagnosticsToFixAsync(fixAllContext).ConfigureAwait(false);
-                return await this.GetFixAsync(documentsAndDiagnosticsToFixMap, fixAllContext).ConfigureAwait(false);
+                var documentsAndDiagnosticsToFixMap = await GetDocumentDiagnosticsToFixAsync(fixAllContext).ConfigureAwait(false);
+                return await GetFixAsync(documentsAndDiagnosticsToFixMap, fixAllContext).ConfigureAwait(false);
             }
             else
             {
-                var projectsAndDiagnosticsToFixMap = await this.GetProjectDiagnosticsToFixAsync(fixAllContext).ConfigureAwait(false);
-                return await this.GetFixAsync(projectsAndDiagnosticsToFixMap, fixAllContext).ConfigureAwait(false);
+                var projectsAndDiagnosticsToFixMap = await GetProjectDiagnosticsToFixAsync(fixAllContext).ConfigureAwait(false);
+                return await GetFixAsync(projectsAndDiagnosticsToFixMap, fixAllContext).ConfigureAwait(false);
             }
         }
 
@@ -61,14 +61,14 @@ public virtual async Task<CodeAction> GetFixAsync(
 
                     var document = documents[index];
                     fixesBag[index] = new List<CodeAction>();
-                    fixOperations.Add(this.AddDocumentFixesAsync(document, documentsAndDiagnosticsToFixMap[document], fixesBag[index].Add, fixAllContext));
+                    fixOperations.Add(AddDocumentFixesAsync(document, documentsAndDiagnosticsToFixMap[document], fixesBag[index].Add, fixAllContext));
                 }
 
                 await Task.WhenAll(fixOperations).ConfigureAwait(false);
 
                 if (fixesBag.Any(fixes => fixes.Count > 0))
                 {
-                    return await this.TryGetMergedFixAsync(fixesBag.SelectMany(i => i), fixAllContext).ConfigureAwait(false);
+                    return await TryGetMergedFixAsync(fixesBag.SelectMany(i => i), fixAllContext).ConfigureAwait(false);
                 }
             }
 
@@ -149,14 +149,14 @@ public virtual async Task<CodeAction> GetFixAsync(
                     index++;
                     var diagnostics = projectsAndDiagnosticsToFixMap[project];
                     fixesBag[index] = new List<CodeAction>();
-                    fixOperations.Add(this.AddProjectFixesAsync(project, diagnostics, fixesBag[index].Add, fixAllContext));
+                    fixOperations.Add(AddProjectFixesAsync(project, diagnostics, fixesBag[index].Add, fixAllContext));
                 }
 
                 await Task.WhenAll(fixOperations).ConfigureAwait(false);
 
                 if (fixesBag.Any(fixes => fixes.Count > 0))
                 {
-                    return await this.TryGetMergedFixAsync(fixesBag.SelectMany(i => i), fixAllContext).ConfigureAwait(false);
+                    return await TryGetMergedFixAsync(fixesBag.SelectMany(i => i), fixAllContext).ConfigureAwait(false);
                 }
             }
 
@@ -181,10 +181,10 @@ public virtual async Task<CodeAction> TryGetMergedFixAsync(IEnumerable<CodeActio
             }
 
             var solution = fixAllContext.Solution;
-            var newSolution = await this.TryMergeFixesAsync(solution, batchOfFixes, fixAllContext.CancellationToken).ConfigureAwait(false);
+            var newSolution = await TryMergeFixesAsync(solution, batchOfFixes, fixAllContext.CancellationToken).ConfigureAwait(false);
             if (newSolution != null && newSolution != solution)
             {
-                var title = this.GetFixAllTitle(fixAllContext);
+                var title = GetFixAllTitle(fixAllContext);
                 return CodeAction.Create(title, cancellationToken => Task.FromResult(newSolution));
             }
 

DocumentationAnalyzers/DocumentationAnalyzers.Status.Generator/DocumentationDiagnostic.cs

@@ -121,7 +121,7 @@ public static DocumentationDiagnostic FromJson(string value)
         /// </returns>
         public override string ToString()
         {
-            return this.Id + " " + this.Name;
+            return Id + " " + Name;
         }
 
         /// <summary>

DocumentationAnalyzers/DocumentationAnalyzers.Status.Generator/SolutionReader.cs

@@ -6,7 +6,6 @@ namespace DocumentationAnalyzers.Status.Generator
     using System;
     using System.Collections.Generic;
     using System.Collections.Immutable;
-    using System.IO;
     using System.Linq;
     using System.Reflection;
     using System.Text.RegularExpressions;
@@ -24,28 +23,28 @@ namespace DocumentationAnalyzers.Status.Generator
     /// </summary>
     public class SolutionReader
     {
-        private static Regex diagnosticPathRegex = new Regex(@"(?<type>[A-Za-z]+)Rules\\(?<name>[A-Za-z0-9]+)\.cs$");
-        private INamedTypeSymbol diagnosticAnalyzerTypeSymbol;
-        private INamedTypeSymbol noCodeFixAttributeTypeSymbol;
-
-        private Solution solution;
-        private Project analyzerProject;
-        private Project codeFixProject;
-        private MSBuildWorkspace workspace;
-        private Assembly analyzerAssembly;
-        private Assembly codeFixAssembly;
-        private Compilation analyzerCompilation;
-        private Compilation codeFixCompilation;
-        private ITypeSymbol booleanType;
-        private Type batchFixerType;
+        private static Regex _diagnosticPathRegex = new Regex(@"(?<type>[A-Za-z]+)Rules\\(?<name>[A-Za-z0-9]+)\.cs$");
+        private INamedTypeSymbol _diagnosticAnalyzerTypeSymbol;
+        private INamedTypeSymbol _noCodeFixAttributeTypeSymbol;
+
+        private Solution _solution;
+        private Project _analyzerProject;
+        private Project _codeFixProject;
+        private MSBuildWorkspace _workspace;
+        private Assembly _analyzerAssembly;
+        private Assembly _codeFixAssembly;
+        private Compilation _analyzerCompilation;
+        private Compilation _codeFixCompilation;
+        private ITypeSymbol _booleanType;
+        private Type _batchFixerType;
 
         private SolutionReader()
         {
             AppDomain.CurrentDomain.AssemblyResolve += (s, e) =>
             {
-                if (e.Name.Contains(this.AnalyzerProjectName))
+                if (e.Name.Contains(AnalyzerProjectName))
                 {
-                    return this.analyzerAssembly;
+                    return _analyzerAssembly;
                 }
 
                 return null;
@@ -74,7 +73,7 @@ public static async Task<SolutionReader> CreateAsync(string pathToSln, string an
             reader.SlnPath = pathToSln;
             reader.AnalyzerProjectName = analyzerProjectName;
             reader.CodeFixProjectName = codeFixProjectName;
-            reader.workspace = MSBuildWorkspace.Create();
+            reader._workspace = MSBuildWorkspace.Create();
 
             await reader.InitializeAsync().ConfigureAwait(false);
 
@@ -89,11 +88,11 @@ public async Task<ImmutableList<DocumentationDiagnostic>> GetDiagnosticsAsync()
         {
             var diagnostics = ImmutableList.CreateBuilder<DocumentationDiagnostic>();
 
-            var syntaxTrees = this.analyzerCompilation.SyntaxTrees;
+            var syntaxTrees = _analyzerCompilation.SyntaxTrees;
 
             foreach (var syntaxTree in syntaxTrees)
             {
-                var match = diagnosticPathRegex.Match(syntaxTree.FilePath);
+                var match = _diagnosticPathRegex.Match(syntaxTree.FilePath);
                 if (!match.Success)
                 {
                     continue;
@@ -104,7 +103,7 @@ public async Task<ImmutableList<DocumentationDiagnostic>> GetDiagnosticsAsync()
 
                 // Check if this syntax tree represents a diagnostic
                 SyntaxNode syntaxRoot = await syntaxTree.GetRootAsync().ConfigureAwait(false);
-                SemanticModel semanticModel = this.analyzerCompilation.GetSemanticModel(syntaxTree);
+                SemanticModel semanticModel = _analyzerCompilation.GetSemanticModel(syntaxTree);
                 SyntaxNode classSyntaxNode = syntaxRoot.DescendantNodes().FirstOrDefault(x => x.IsKind(SyntaxKind.ClassDeclaration));
 
                 if (classSyntaxNode == null)
@@ -114,7 +113,7 @@ public async Task<ImmutableList<DocumentationDiagnostic>> GetDiagnosticsAsync()
 
                 INamedTypeSymbol classSymbol = semanticModel.GetDeclaredSymbol(classSyntaxNode) as INamedTypeSymbol;
 
-                if (!this.InheritsFrom(classSymbol, this.diagnosticAnalyzerTypeSymbol))
+                if (!InheritsFrom(classSymbol, _diagnosticAnalyzerTypeSymbol))
                 {
                     continue;
                 }
@@ -126,12 +125,12 @@ public async Task<ImmutableList<DocumentationDiagnostic>> GetDiagnosticsAsync()
 
                 bool hasImplementation = HasImplementation(syntaxRoot);
 
-                IEnumerable<DiagnosticDescriptor> descriptorInfos = this.GetDescriptor(classSymbol);
+                IEnumerable<DiagnosticDescriptor> descriptorInfos = GetDescriptor(classSymbol);
 
                 foreach (var descriptorInfo in descriptorInfos)
                 {
-                    var (codeFixStatus, fixAllStatus) = this.GetCodeFixAndFixAllStatus(descriptorInfo.Id, classSymbol, out noCodeFixReason);
-                    string status = this.GetStatus(classSymbol, syntaxRoot, semanticModel, descriptorInfo);
+                    var (codeFixStatus, fixAllStatus) = GetCodeFixAndFixAllStatus(descriptorInfo.Id, classSymbol, out noCodeFixReason);
+                    string status = GetStatus(classSymbol, syntaxRoot, semanticModel, descriptorInfo);
                     if (descriptorInfo.CustomTags.Contains(WellKnownDiagnosticTags.NotConfigurable))
                     {
                         continue;
@@ -176,33 +175,33 @@ private static bool HasImplementation(SyntaxNode syntaxRoot)
 
         private async Task InitializeAsync()
         {
-            this.solution = await this.workspace.OpenSolutionAsync(this.SlnPath).ConfigureAwait(false);
+            _solution = await _workspace.OpenSolutionAsync(SlnPath).ConfigureAwait(false);
 
-            this.analyzerProject = this.solution.Projects.First(x => x.Name == this.AnalyzerProjectName || x.AssemblyName == this.AnalyzerProjectName);
-            this.analyzerCompilation = await this.analyzerProject.GetCompilationAsync().ConfigureAwait(false);
-            this.analyzerCompilation = this.analyzerCompilation.WithOptions(this.analyzerCompilation.Options.WithOutputKind(OutputKind.DynamicallyLinkedLibrary));
+            _analyzerProject = _solution.Projects.First(x => x.Name == AnalyzerProjectName || x.AssemblyName == AnalyzerProjectName);
+            _analyzerCompilation = await _analyzerProject.GetCompilationAsync().ConfigureAwait(false);
+            _analyzerCompilation = _analyzerCompilation.WithOptions(_analyzerCompilation.Options.WithOutputKind(OutputKind.DynamicallyLinkedLibrary));
 
-            this.codeFixProject = this.solution.Projects.First(x => x.Name == this.CodeFixProjectName || x.AssemblyName == this.CodeFixProjectName);
-            this.codeFixCompilation = await this.codeFixProject.GetCompilationAsync().ConfigureAwait(false);
-            this.codeFixCompilation = this.codeFixCompilation.WithOptions(this.codeFixCompilation.Options.WithOutputKind(OutputKind.DynamicallyLinkedLibrary));
+            _codeFixProject = _solution.Projects.First(x => x.Name == CodeFixProjectName || x.AssemblyName == CodeFixProjectName);
+            _codeFixCompilation = await _codeFixProject.GetCompilationAsync().ConfigureAwait(false);
+            _codeFixCompilation = _codeFixCompilation.WithOptions(_codeFixCompilation.Options.WithOutputKind(OutputKind.DynamicallyLinkedLibrary));
 
-            this.booleanType = this.analyzerCompilation.GetSpecialType(SpecialType.System_Boolean);
+            _booleanType = _analyzerCompilation.GetSpecialType(SpecialType.System_Boolean);
 
-            this.LoadAssemblies();
+            LoadAssemblies();
 
-            this.noCodeFixAttributeTypeSymbol = this.analyzerCompilation.GetTypeByMetadataName("DocumentationAnalyzers.NoCodeFixAttribute");
-            this.diagnosticAnalyzerTypeSymbol = this.analyzerCompilation.GetTypeByMetadataName(typeof(DiagnosticAnalyzer).FullName);
+            _noCodeFixAttributeTypeSymbol = _analyzerCompilation.GetTypeByMetadataName("DocumentationAnalyzers.NoCodeFixAttribute");
+            _diagnosticAnalyzerTypeSymbol = _analyzerCompilation.GetTypeByMetadataName(typeof(DiagnosticAnalyzer).FullName);
 
-            this.batchFixerType = this.codeFixAssembly.GetType("DocumentationAnalyzers.Helpers.CustomBatchFixAllProvider");
+            _batchFixerType = _codeFixAssembly.GetType("DocumentationAnalyzers.Helpers.CustomBatchFixAllProvider");
 
-            this.InitializeCodeFixTypes();
+            InitializeCodeFixTypes();
         }
 
         private void InitializeCodeFixTypes()
         {
-            var codeFixTypes = this.codeFixAssembly.GetTypes().Where(x => x.FullName.EndsWith("CodeFixProvider"));
+            var codeFixTypes = _codeFixAssembly.GetTypes().Where(x => x.FullName.EndsWith("CodeFixProvider"));
 
-            this.CodeFixProviders = ImmutableArray.Create(
+            CodeFixProviders = ImmutableArray.Create(
                 codeFixTypes
                 .Select(t => Activator.CreateInstance(t, true))
                 .OfType<CodeFixProvider>()
@@ -212,8 +211,8 @@ private void InitializeCodeFixTypes()
 
         private void LoadAssemblies()
         {
-            this.analyzerAssembly = this.GetAssembly(this.analyzerProject);
-            this.codeFixAssembly = this.GetAssembly(this.codeFixProject);
+            _analyzerAssembly = GetAssembly(_analyzerProject);
+            _codeFixAssembly = GetAssembly(_codeFixProject);
         }
 
         private Assembly GetAssembly(Project project)
@@ -261,7 +260,7 @@ private string GetStatus(INamedTypeSymbol classSymbol, SyntaxNode root, Semantic
 
                 // We use the fact that the only parameter that returns a boolean is the one we are interested in
                 var enabledByDefaultParameter = from argument in initializer.ArgumentList.Arguments
-                                                where Equals(model.GetTypeInfo(argument.Expression).Type, this.booleanType)
+                                                where Equals(model.GetTypeInfo(argument.Expression).Type, _booleanType)
                                                 select argument.Expression;
                 var parameter = enabledByDefaultParameter.FirstOrDefault();
                 string parameterString = parameter.ToString();
@@ -280,7 +279,7 @@ where Equals(model.GetTypeInfo(argument.Expression).Type, this.booleanType)
 
         private IEnumerable<DiagnosticDescriptor> GetDescriptor(INamedTypeSymbol classSymbol)
         {
-            var analyzer = (DiagnosticAnalyzer)Activator.CreateInstance(this.analyzerAssembly.GetType(classSymbol.ToString()));
+            var analyzer = (DiagnosticAnalyzer)Activator.CreateInstance(_analyzerAssembly.GetType(classSymbol.ToString()));
 
             // This currently only supports one diagnostic for each analyzer.
             return analyzer.SupportedDiagnostics;
@@ -295,7 +294,7 @@ private IEnumerable<DiagnosticDescriptor> GetDescriptor(INamedTypeSymbol classSy
 
             var noCodeFixAttribute = classSymbol
                 .GetAttributes()
-                .SingleOrDefault(x => Equals(x.AttributeClass, this.noCodeFixAttributeTypeSymbol));
+                .SingleOrDefault(x => Equals(x.AttributeClass, _noCodeFixAttributeTypeSymbol));
 
             bool hasCodeFix = noCodeFixAttribute == null;
             if (!hasCodeFix)
@@ -310,9 +309,9 @@ private IEnumerable<DiagnosticDescriptor> GetDescriptor(INamedTypeSymbol classSy
             else
             {
                 // Check if the code fix actually exists
-                var codeFixes = this.CodeFixProviders
+                var codeFixes = CodeFixProviders
                     .Where(x => x.FixableDiagnosticIds.Contains(diagnosticId))
-                    .Select(x => this.IsBatchFixer(x))
+                    .Select(x => IsBatchFixer(x))
                     .Where(x => x != null)
                     .Select(x => (bool)x).ToArray();
 
@@ -347,7 +346,7 @@ private IEnumerable<DiagnosticDescriptor> GetDescriptor(INamedTypeSymbol classSy
             }
             else
             {
-                return fixAllProvider.GetType() == this.batchFixerType;
+                return fixAllProvider.GetType() == _batchFixerType;
             }
         }