C#: Replace calls to constructed generic extensions methods with calls to constructed extensions from extension types (if possible).

Author: michaelnebel

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

@@ -5,7 +5,6 @@
 using System.Linq;
 using Microsoft.CodeAnalysis;
 using Semmle.Extraction.CSharp.Entities;
-using Semmle.Extraction.CSharp.Entities.Statements;
 
 namespace Semmle.Extraction.CSharp
 {
@@ -647,14 +646,36 @@ public static bool TryGetExtensionMethod(this IMethodSymbol method, out IMethodS
                 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())
+                // Find the (possibly unbound) original extension method that maps to this implementation (if any).
+                var unboundDeclaration = extensions.SelectMany(e => e.GetMembers())
                     .OfType<IMethodSymbol>()
-                    .FirstOrDefault(m => SymbolEqualityComparer.Default.Equals(m.AssociatedExtensionImplementation, method));
-                return declaration is not null;
+                    .FirstOrDefault(m => SymbolEqualityComparer.Default.Equals(m.AssociatedExtensionImplementation, method.ConstructedFrom));
+
+                var isFullyConstructed = method.IsBoundGenericMethod();
+                if (isFullyConstructed && unboundDeclaration?.ContainingType is INamedTypeSymbol extensionType && extensionType.IsGenericType)
+                {
+                    // Use the type arguments from the constructed extension method to construct the extension type.
+                    var arguments = method.TypeArguments.ToArray();
+                    var boundExtensionType = extensionType.Construct(arguments);
+                    var boundDeclaration = boundExtensionType.GetMembers()
+                        .OfType<IMethodSymbol>()
+                        .FirstOrDefault(c => SymbolEqualityComparer.Default.Equals(c.OriginalDefinition, unboundDeclaration));
+                    declaration = boundDeclaration;
+                }
+                else
+                {
+                    declaration = unboundDeclaration;
+                }
+
             }
-            return false;
+            return declaration is not null;
         }
+
+        public static bool IsUnboundGenericMethod(this IMethodSymbol method) =>
+            method.IsGenericMethod && SymbolEqualityComparer.Default.Equals(method.ConstructedFrom, method);
+
+        public static bool IsBoundGenericMethod(this IMethodSymbol method) => method.IsGenericMethod && !IsUnboundGenericMethod(method);
+
         /// <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/Method.cs

@@ -321,9 +321,9 @@ public static void AddExplicitInterfaceQualifierToId(Context cx, EscapingTextWri
         /// <summary>
         /// Whether this method has unbound type parameters.
         /// </summary>
-        public bool IsUnboundGeneric => IsGeneric && SymbolEqualityComparer.Default.Equals(Symbol.ConstructedFrom, Symbol);
+        public bool IsUnboundGeneric => Symbol.IsUnboundGenericMethod();
 
-        public bool IsBoundGeneric => IsGeneric && !IsUnboundGeneric;
+        public bool IsBoundGeneric => Symbol.IsBoundGenericMethod();
 
         protected IMethodSymbol ConstructedFromSymbol => Symbol.ConstructedFrom;