Merge pull request #138 from bkoelman/av1553-caller-arg-expr

Suppress AV1553 on [CallerArgumentExpression] usage

Author: bkoelman

src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer.Test/Specs/Maintainability/DoNotUseOptionalParameterWithDefaultValueNullSpecs.cs

@@ -1,4 +1,5 @@
 using System.Collections;
+using System.Runtime.CompilerServices;
 using CSharpGuidelinesAnalyzer.Rules.Maintainability;
 using CSharpGuidelinesAnalyzer.Test.TestDataBuilders;
 using Microsoft.CodeAnalysis.Diagnostics;
@@ -64,6 +65,24 @@ await VerifyGuidelineDiagnosticAsync(source,
             "Optional parameter 'p' of type 'string' has default value 'null'");
     }
 
+    [Fact]
+    internal async Task When_using_optional_string_parameter_with_default_null_with_CallerArgumentExpression_it_must_be_skipped()
+    {
+        // Arrange
+        ParsedSourceCode source = new TypeSourceCodeBuilder()
+            .Using(typeof(CallerArgumentExpressionAttribute).Namespace)
+            .InGlobalScope(@"
+                class C
+                {
+                    void M(object value, [CallerArgumentExpression(""value"")] string parameterName = null) => throw null;
+                }
+            ")
+            .Build();
+
+        // Act and assert
+        await VerifyGuidelineDiagnosticAsync(source);
+    }
+
     [Fact]
     internal async Task When_using_optional_List_of_int_parameter_with_default_null_it_must_be_reported()
     {

src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/KnownTypes.cs

@@ -101,6 +101,14 @@ public static INamedTypeSymbol SystemRuntimeCompilerServicesConfiguredValueTaskA
             return compilation.GetTypeByMetadataName("System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable");
         }
 
+        [CanBeNull]
+        public static INamedTypeSymbol SystemRuntimeCompilerServicesCallerArgumentExpressionAttribute([NotNull] Compilation compilation)
+        {
+            Guard.NotNull(compilation, nameof(compilation));
+
+            return compilation.GetTypeByMetadataName("System.Runtime.CompilerServices.CallerArgumentExpressionAttribute");
+        }
+
         [CanBeNull]
         public static INamedTypeSymbol SystemRuntimeCompilerServicesConfiguredValueTaskAwaitableT([NotNull] Compilation compilation)
         {

src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Maintainability/DoNotUseOptionalParameterWithDefaultValueNullAnalyzer.cs

@@ -31,8 +31,9 @@ public sealed class DoNotUseOptionalParameterWithDefaultValueNullAnalyzer : Diag
 
 #pragma warning disable RS1008 // Avoid storing per-compilation data into the fields of a diagnostic analyzer.
         [NotNull]
-        private static readonly Action<SyntaxNodeAnalysisContext, IList<INamedTypeSymbol>> AnalyzeParameterAction = (syntaxContext, taskTypes) =>
-            syntaxContext.SkipEmptyName(symbolContext => AnalyzeParameter(symbolContext, taskTypes));
+        private static readonly Action<SyntaxNodeAnalysisContext, IList<INamedTypeSymbol>, INamedTypeSymbol> AnalyzeParameterAction =
+            (syntaxContext, taskTypes, callerArgumentExpressionAttributeType) => syntaxContext.SkipEmptyName(symbolContext =>
+                AnalyzeParameter(symbolContext, taskTypes, callerArgumentExpressionAttributeType));
 #pragma warning restore RS1008 // Avoid storing per-compilation data into the fields of a diagnostic analyzer.
 
         [ItemNotNull]
@@ -50,7 +51,11 @@ private static void RegisterCompilationStart([NotNull] CompilationStartAnalysisC
         {
             IList<INamedTypeSymbol> taskTypes = ResolveTaskTypes(startContext.Compilation).ToList();
 
-            startContext.RegisterSyntaxNodeAction(context => AnalyzeParameterAction(context, taskTypes), SyntaxKind.Parameter);
+            INamedTypeSymbol callerArgumentExpressionAttributeType =
+                KnownTypes.SystemRuntimeCompilerServicesCallerArgumentExpressionAttribute(startContext.Compilation);
+
+            startContext.RegisterSyntaxNodeAction(context => AnalyzeParameterAction(context, taskTypes, callerArgumentExpressionAttributeType),
+                SyntaxKind.Parameter);
         }
 
         [NotNull]
@@ -72,11 +77,13 @@ private static IEnumerable<INamedTypeSymbol> ResolveTaskTypes([NotNull] Compilat
             }
         }
 
-        private static void AnalyzeParameter(SymbolAnalysisContext context, [NotNull] [ItemNotNull] IList<INamedTypeSymbol> taskTypes)
+        private static void AnalyzeParameter(SymbolAnalysisContext context, [NotNull] [ItemNotNull] IList<INamedTypeSymbol> taskTypes,
+            [CanBeNull] INamedTypeSymbol callerArgumentExpressionAttributeType)
         {
             var parameter = (IParameterSymbol)context.Symbol;
 
-            if (parameter.IsOptional && parameter.HasExplicitDefaultValue && parameter.ExplicitDefaultValue == null)
+            if (parameter.IsOptional && parameter.HasExplicitDefaultValue && parameter.ExplicitDefaultValue == null &&
+                !HasCallerArgumentExpressionAttribute(parameter, callerArgumentExpressionAttributeType))
             {
                 if (parameter.Type.IsOrImplementsIEnumerable() || IsTask(parameter.Type, taskTypes))
                 {
@@ -90,6 +97,13 @@ private static void AnalyzeParameter(SymbolAnalysisContext context, [NotNull] [I
             }
         }
 
+        private static bool HasCallerArgumentExpressionAttribute([NotNull] IParameterSymbol parameter,
+            [CanBeNull] INamedTypeSymbol callerArgumentExpressionAttributeType)
+        {
+            return callerArgumentExpressionAttributeType != null &&
+                parameter.GetAttributes().Any(attr => Equals(attr.AttributeClass, callerArgumentExpressionAttributeType));
+        }
+
         private static bool IsTask([NotNull] ITypeSymbol type, [NotNull] [ItemNotNull] IList<INamedTypeSymbol> taskTypes)
         {
             ITypeSymbol unwrappedType = type.UnwrapNullableValueType();