Filtered log calls with inaccessible parameters

Author: Sviatoslav Bychkov

src/AutoLoggerMessageGenerator.UnitTests/Filters/LogCallFilterTests.cs

@@ -17,16 +17,16 @@ public class AnotherObject
                                         public void LogInformation(string message, DateTime arg1) {}
                                         public void LogInformation2(string message, DateTime arg1) {}
                                      }
-                                     
+
                                      public void LogInformation(string message, DateTime arg1) {}
                                      public void LogSomething(string message, DateTime arg1) {}
                                      public void AnotherMethod(string message, DateTime arg1) {}
-                                     
+
                                      """;
         var sourceCode = $$"""
                          const string message = "Event received at: {EventTime}";
                          var eventTime = DateTime.Now;
- 
+
                          {{LoggerName}}.LogInformation(message, eventTime);
 
                          AnotherMethod(message, eventTime);
@@ -48,8 +48,39 @@ public void AnotherMethod(string message, DateTime arg1) {}
             var methodSymbol = (IMethodSymbol) semanticModel.GetSymbolInfo(c).Symbol!;
             return LogCallFilter.IsLoggerMethod(methodSymbol);
         }).ToArray();
-        
+
         invocationExpressions.Length.Should().Be(2);
         filteredInvocationExpressions.Length.Should().Be(1);
     }
+
+
+    [Fact]
+    public void Filter_WithInaccessibleClassAsParameter_ShouldExcludeLogCall()
+    {
+        const string additionalDeclarations = """
+                                              public class A
+                                              {
+                                                  private class B
+                                                  {
+                                                      public class C
+                                                      {
+                                                          public class D {}
+                                                      }
+                                                  }
+                                              }
+                                              """;
+
+        const string sourceCode = $$"""
+                                  var parameter = new A.B.C.D();
+                                  {{LoggerName}}.LogInformation("B class is private, so {this} argument is inaccessible as well", parameter);
+                                  """;
+        var (compilation, syntaxTree) = CompileSourceCode(sourceCode, additionalDeclarations);
+        var (invocationExpressionSyntax, methodSymbol, _) = FindLoggerMethodInvocation(compilation, syntaxTree);
+
+        var isLogCallInvocation = LogCallFilter.IsLogCallInvocation(invocationExpressionSyntax, CancellationToken.None);
+        var isLogCallMethod = LogCallFilter.IsLoggerMethod(methodSymbol);
+
+        isLogCallInvocation.Should().BeTrue();
+        isLogCallMethod.Should().BeFalse();
+    }
 }

src/AutoLoggerMessageGenerator/Filters/LogCallFilter.cs

@@ -21,20 +21,23 @@ internal static class LogCallFilter
         nameof(LoggerExtensions.LogCritical),
     ];
 
-    public static bool IsLoggerMethod(IMethodSymbol methodSymbol)
-    {
-        var containingType = methodSymbol.ContainingType;
-        return containingType != null &&
-               methodSymbol.ReceiverType?.Name is "ILogger" &&
-               methodSymbol.ReturnsVoid &&
-               methodSymbol.ContainingType.ToDisplayString() is $"{Constants.DefaultLoggingNamespace}.{ClassName}" &&
-               methodSymbol.IsExtensionMethod;
-    }
+    public static bool IsLoggerMethod(IMethodSymbol methodSymbol) =>
+        methodSymbol is { ContainingType: not null, ReceiverType.Name: "ILogger", ReturnsVoid: true } &&
+        methodSymbol.ContainingType.ToDisplayString() is $"{Constants.DefaultLoggingNamespace}.{ClassName}" &&
+        methodSymbol.IsExtensionMethod &&
+        methodSymbol.Parameters.All(c =>
+            c.Type.IsAnonymousType is not true && c.Type.TypeKind is not TypeKind.TypeParameter &&
+            RecursivelyCheckTypeAccessibility(c.Type)
+        );
 
     public static bool IsLogCallInvocation(SyntaxNode node, CancellationToken cts) =>
         !node.SyntaxTree.FilePath.EndsWith(".g.cs") &&
         node is InvocationExpressionSyntax { ArgumentList.Arguments.Count: > 0 } invocationExpression &&
         !cts.IsCancellationRequested &&
         invocationExpression.Expression.DescendantNodes()
             .Any(c => c is IdentifierNameSyntax identifierNameSyntax && LogMethodNames.Contains(identifierNameSyntax.Identifier.Text));
+
+    private static bool RecursivelyCheckTypeAccessibility(ITypeSymbol typeSymbol) =>
+        typeSymbol.DeclaredAccessibility is Accessibility.Friend or Accessibility.Public or Accessibility.Internal &&
+        (typeSymbol.ContainingType is null || RecursivelyCheckTypeAccessibility(typeSymbol.ContainingType));
 }