C#: Static extension methods in extension types should also have their call target replaced.

Author: michaelnebel

csharp/extractor/Semmle.Extraction.CSharp/CodeAnalysisExtensions/SymbolExtensions.cs

@@ -5,6 +5,7 @@
 using System.Linq;
 using Microsoft.CodeAnalysis;
 using Semmle.Extraction.CSharp.Entities;
+using Semmle.Extraction.CSharp.Entities.Statements;
 
 namespace Semmle.Extraction.CSharp
 {
@@ -631,8 +632,30 @@ public static bool IsSourceDeclaration(this IParameterSymbol parameter)
         /// Return true if this method is a compiler-generated extension method.
         /// </summary>
         public static bool IsCompilerGeneratedExtensionMethod(this IMethodSymbol method) =>
-            method.IsImplicitlyDeclared && method.IsExtensionMethod;
+            method.TryGetExtensionMethod(out _);
 
+        /// <summary>
+        /// Returns true if this method is a compiler-generated extension method,
+        /// and outputs the original extension method declaration.
+        /// </summary>
+        public static bool TryGetExtensionMethod(this IMethodSymbol method, out IMethodSymbol? declaration)
+        {
+            declaration = null;
+            if (method.IsImplicitlyDeclared && method.ContainingSymbol is INamedTypeSymbol containingType)
+            {
+                // Extension types are declared within the same type as the generated
+                // extension method implementation.
+                var extensions = containingType.GetMembers()
+                    .OfType<INamedTypeSymbol>()
+                    .Where(t => t.IsExtension);
+                // Find the original extension method that maps to this implementation (if any).
+                declaration = extensions.SelectMany(e => e.GetMembers())
+                    .OfType<IMethodSymbol>()
+                    .FirstOrDefault(m => SymbolEqualityComparer.Default.Equals(m.AssociatedExtensionImplementation, method));
+                return declaration is not null;
+            }
+            return false;
+        }
         /// <summary>
         /// Gets the base type of `symbol`. Unlike `symbol.BaseType`, this excludes effective base
         /// types of type parameters as well as `object` base types.

csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Invocation.cs

@@ -124,19 +124,9 @@ public IMethodSymbol? TargetSymbol
                     var method = symbol as IMethodSymbol;
                     // Case for compiler-generated extension methods.
                     if (method is not null &&
-                        method.IsCompilerGeneratedExtensionMethod() &&
-                        method.ContainingSymbol is INamedTypeSymbol containingType)
+                        method.TryGetExtensionMethod(out var original))
                     {
-                        // Extension types are declared within the same type as the generated
-                        // extension method implementation.
-                        var extensions = containingType.GetMembers()
-                            .OfType<INamedTypeSymbol>()
-                            .Where(t => t.IsExtension);
-                        // Find the original extension method that maps to this implementation (if any).
-                        var original = extensions.SelectMany(e => e.GetMembers())
-                            .OfType<IMethodSymbol>()
-                            .FirstOrDefault(m => SymbolEqualityComparer.Default.Equals(m.AssociatedExtensionImplementation, method));
-                        return original ?? method;
+                        return original;
                     }
 
                     return method;