Merge pull request #6700 from mavasani/PrFeedback6690

Address remaining feedback from #6690

Author: mavasani

src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/OperatorOverloadsHaveNamedAlternates.cs

@@ -2,6 +2,7 @@
 
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.Linq;
 using Analyzer.Utilities;
 using Analyzer.Utilities.Extensions;
@@ -92,6 +93,8 @@ public override void Initialize(AnalysisContext context)
 
         private static void AnalyzeMethod(IMethodSymbol methodSymbol, SymbolAnalysisContext symbolContext)
         {
+            Debug.Assert(methodSymbol.MethodKind is MethodKind.UserDefinedOperator or MethodKind.Conversion);
+
             // FxCop compat: only analyze externally visible symbols by default.
             // Note all the descriptors/rules for this analyzer have the same ID and category and hence
             // will always have identical configured visibility.

src/NetAnalyzers/Core/Microsoft.CodeQuality.Analyzers/QualityGuidelines/UseLiteralsWhereAppropriate.cs

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Immutable;
 using System.Linq;
 using Analyzer.Utilities;
@@ -57,51 +58,53 @@ public override void Initialize(AnalysisContext context)
 
                 var constantIncompatibleTypes = builder.ToImmutable();
 
-                context.RegisterSymbolStartAction(context =>
+#pragma warning disable IDE0039 // Use local function
+                Action<OperationAnalysisContext> operationAction = context =>
                 {
-                    context.RegisterOperationAction(context =>
+                    var fieldInitializer = context.Operation as IFieldInitializerOperation;
+
+                    // Diagnostics are reported on the last initialized field to retain the previous FxCop behavior
+                    // Note all the descriptors/rules for this analyzer have the same ID and category and hence
+                    // will always have identical configured visibility.
+                    var lastField = fieldInitializer?.InitializedFields.LastOrDefault();
+                    var fieldInitializerValue = fieldInitializer?.Value;
+                    if (fieldInitializerValue == null ||
+                        lastField == null ||
+                        lastField.IsConst ||
+                        !lastField.IsReadOnly ||
+                        !fieldInitializerValue.ConstantValue.HasValue ||
+                        !context.Options.MatchesConfiguredVisibility(DefaultRule, lastField, context.Compilation, defaultRequiredVisibility: SymbolVisibilityGroup.Internal | SymbolVisibilityGroup.Private) ||
+                        !context.Options.MatchesConfiguredModifiers(DefaultRule, lastField, context.Compilation, defaultRequiredModifiers: SymbolModifiers.Static))
                     {
-                        var fieldInitializer = context.Operation as IFieldInitializerOperation;
-
-                        // Diagnostics are reported on the last initialized field to retain the previous FxCop behavior
-                        // Note all the descriptors/rules for this analyzer have the same ID and category and hence
-                        // will always have identical configured visibility.
-                        var lastField = fieldInitializer?.InitializedFields.LastOrDefault();
-                        var fieldInitializerValue = fieldInitializer?.Value;
-                        if (fieldInitializerValue == null ||
-                            lastField == null ||
-                            lastField.IsConst ||
-                            !lastField.IsReadOnly ||
-                            !fieldInitializerValue.ConstantValue.HasValue ||
-                            !context.Options.MatchesConfiguredVisibility(DefaultRule, lastField, context.Compilation, defaultRequiredVisibility: SymbolVisibilityGroup.Internal | SymbolVisibilityGroup.Private) ||
-                            !context.Options.MatchesConfiguredModifiers(DefaultRule, lastField, context.Compilation, defaultRequiredModifiers: SymbolModifiers.Static))
-                        {
-                            return;
-                        }
+                        return;
+                    }
+
+                    var initializerValue = fieldInitializerValue.ConstantValue.Value;
 
-                        var initializerValue = fieldInitializerValue.ConstantValue.Value;
+                    if (fieldInitializerValue.Kind == OperationKind.InterpolatedString &&
+                        !IsConstantInterpolatedStringSupported(fieldInitializerValue.Syntax.SyntaxTree.Options))
+                    {
+                        return;
+                    }
 
-                        if (fieldInitializerValue.Kind == OperationKind.InterpolatedString &&
-                            !IsConstantInterpolatedStringSupported(fieldInitializerValue.Syntax.SyntaxTree.Options))
+                    // Though null is const we don't fire the diagnostic to be FxCop Compact
+                    if (initializerValue != null &&
+                        !constantIncompatibleTypes.Contains(fieldInitializerValue.Type))
+                    {
+                        if (fieldInitializerValue.Type?.SpecialType == SpecialType.System_String &&
+                            ((string)initializerValue).Length == 0)
                         {
+                            context.ReportDiagnostic(lastField.CreateDiagnostic(EmptyStringRule, lastField.Name));
                             return;
                         }
 
-                        // Though null is const we don't fire the diagnostic to be FxCop Compact
-                        if (initializerValue != null &&
-                            !constantIncompatibleTypes.Contains(fieldInitializerValue.Type))
-                        {
-                            if (fieldInitializerValue.Type?.SpecialType == SpecialType.System_String &&
-                                ((string)initializerValue).Length == 0)
-                            {
-                                context.ReportDiagnostic(lastField.CreateDiagnostic(EmptyStringRule, lastField.Name));
-                                return;
-                            }
-
-                            context.ReportDiagnostic(lastField.CreateDiagnostic(DefaultRule, lastField.Name));
-                        }
-                    },
-                    OperationKind.FieldInitializer);
+                        context.ReportDiagnostic(lastField.CreateDiagnostic(DefaultRule, lastField.Name));
+                    }
+                };
+
+                context.RegisterSymbolStartAction(context =>
+                {
+                    context.RegisterOperationAction(operationAction, OperationKind.FieldInitializer);
                 }, SymbolKind.Field);
             });
         }

src/NetAnalyzers/VisualBasic/Microsoft.CodeQuality.Analyzers/ApiDesignGuidelines/BasicOverrideEqualsOnOverloadingOperatorEquals.vb

@@ -61,8 +61,9 @@ Namespace Microsoft.CodeQuality.VisualBasic.Analyzers.ApiDesignGuidelines
         End Sub
 
         Private Shared Function HasEqualityOperator(type As INamedTypeSymbol) As Boolean
-            For Each method In type.GetMembers().OfType(Of IMethodSymbol)
-                If method.MethodKind = MethodKind.UserDefinedOperator AndAlso
+            For Each member In type.GetMembers()
+                Dim method = TryCast(member, IMethodSymbol)
+                If method?.MethodKind = MethodKind.UserDefinedOperator AndAlso
                     CaseInsensitiveComparison.Equals(method.Name, WellKnownMemberNames.EqualityOperatorName) Then
 
                     Return True