C#: Support replacing invocations of generic methods in generic extensions.

Author: michaelnebel

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

@@ -4,6 +4,7 @@
 using System.IO;
 using System.Linq;
 using Microsoft.CodeAnalysis;
+using Semmle.Util;
 using Semmle.Extraction.CSharp.Entities;
 
 namespace Semmle.Extraction.CSharp
@@ -652,15 +653,33 @@ public static bool TryGetExtensionMethod(this IMethodSymbol method, out IMethodS
                     .FirstOrDefault(m => SymbolEqualityComparer.Default.Equals(m.AssociatedExtensionImplementation, method.ConstructedFrom));
 
                 var isFullyConstructed = method.IsBoundGenericMethod();
+                // TODO: We also need to handle generic methods in non-generic extension types.
                 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;
+                    try
+                    {
+                        // Use the type arguments from the constructed extension method to construct the extension type.
+                        var arguments = method.TypeArguments.ToArray();
+                        var (extensionTypeArguments, extensionMethodArguments) = arguments.SplitAt(extensionType.TypeParameters.Length);
+
+                        // Construct the extension type.
+                        var boundExtensionType = extensionType.Construct(extensionTypeArguments.ToArray());
+
+                        // Find the extension method declaration within the constructed extension type.
+                        var extensionDeclaration = boundExtensionType.GetMembers()
+                            .OfType<IMethodSymbol>()
+                            .First(c => SymbolEqualityComparer.Default.Equals(c.OriginalDefinition, unboundDeclaration));
+
+                        // If the extension declaration is unbound apply the remaning type arguments and construct it.
+                        declaration = extensionDeclaration.IsUnboundGenericMethod()
+                            ? extensionDeclaration.Construct(extensionMethodArguments.ToArray())
+                            : extensionDeclaration;
+                    }
+                    catch (Exception)
+                    {
+                        // If anything goes wrong, fall back to the unbound declaration.
+                        declaration = unboundDeclaration;
+                    }
                 }
                 else
                 {

csharp/extractor/Semmle.Util/IEnumerableExtensions.cs

@@ -119,5 +119,24 @@ public static int SequenceHash<T>(this IEnumerable<T> items) where T : notnull
         /// </summary>
         public static IEnumerable<T> WhereNotNull<T>(this IEnumerable<T?> items) where T : class =>
             items.Where(i => i is not null)!;
+
+        /// <summary>
+        /// Splits the sequence at the given index.
+        /// </summary>
+        public static (IEnumerable<T>, IEnumerable<T>) SplitAt<T>(this IEnumerable<T> items, int index)
+        {
+            var left = new List<T>();
+            var right = new List<T>();
+            var i = 0;
+            foreach (var item in items)
+            {
+                if (i < index)
+                    left.Add(item);
+                else
+                    right.Add(item);
+                i++;
+            }
+            return (left, right);
+        }
     }
 }