C#: Minor improvements to the extractor changes.

Author: michaelnebel

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

@@ -692,7 +692,7 @@ public static bool TryGetExtensionMethod(this IMethodSymbol method, out IMethodS
                             ? extensionDeclaration.Construct(extensionMethodArguments.ToArray())
                             : extensionDeclaration;
                     }
-                    catch (Exception)
+                    catch
                     {
                         // If anything goes wrong, fall back to the unbound declaration.
                         declaration = unboundDeclaration;

csharp/extractor/Semmle.Extraction.CSharp/Entities/Method.cs

@@ -14,7 +14,7 @@ internal abstract class Method : CachedSymbol<IMethodSymbol>, IExpressionParentE
         protected Method(Context cx, IMethodSymbol init)
             : base(cx, init) { }
 
-        private IParameter? SyntheticParameter { get; set; }
+        private SyntheticExtensionParameter? SyntheticParameter { get; set; }
 
         private int SynthesizeExtensionParameter()
         {
@@ -24,7 +24,7 @@ private int SynthesizeExtensionParameter()
                 !string.IsNullOrEmpty(parameter.Name) && !Symbol.IsStatic)
             {
                 var originalSyntheticParam = OriginalDefinition.SyntheticParameter;
-                SyntheticParameter = ImplicitExtensionParameter.Create(Context, this, parameter, originalSyntheticParam);
+                SyntheticParameter = SyntheticExtensionParameter.Create(Context, this, parameter, originalSyntheticParam);
                 return 1;
             }
 

csharp/extractor/Semmle.Extraction.CSharp/Entities/Parameter.cs

@@ -258,22 +258,22 @@ private class VarargsTypeFactory : CachedEntityFactory<string?, VarargsType>
     }
 
     /// <summary>
-    /// Synthetic parameter for extension methods declared using the extensions syntax.
+    /// Synthetic parameter for extension methods declared using the extension syntax.
     /// That is, we add a synthetic parameter s to IsValid in the following example:
     /// extension(string s) {
     ///   public bool IsValid() { ... }
     /// }
     ///
-    /// Note, that we use the characteristics of the parameter of the associated (compiler generated) extension method
+    /// Note, that we use the characteristics of the parameter of the extension type
     /// to populate the database.
     /// </summary>
-    internal class ImplicitExtensionParameter : FreshEntity, IParameter
+    internal class SyntheticExtensionParameter : FreshEntity, IParameter
     {
         private Method ExtensionMethod { get; }
         private IParameterSymbol ExtensionParameter { get; }
-        private IParameter Original { get; }
+        private SyntheticExtensionParameter Original { get; }
 
-        private ImplicitExtensionParameter(Context cx, Method method, IParameterSymbol parameter, IParameter? original) : base(cx)
+        private SyntheticExtensionParameter(Context cx, Method method, IParameterSymbol parameter, SyntheticExtensionParameter? original) : base(cx)
         {
             ExtensionMethod = method;
             ExtensionParameter = parameter;
@@ -341,9 +341,6 @@ protected override void Populate(TextWriter trapFile)
                 WriteLocationsToTrap(trapFile.param_location, this, locations);
             }
 
-            if (!IsSourceDeclaration || !ExtensionParameter.FromSource())
-                return;
-
             BindComments();
 
             if (IsSourceDeclaration)
@@ -358,9 +355,9 @@ protected override void Populate(TextWriter trapFile)
             }
         }
 
-        public static ImplicitExtensionParameter Create(Context cx, Method method, IParameterSymbol parameter, IParameter? original)
+        public static SyntheticExtensionParameter Create(Context cx, Method method, IParameterSymbol parameter, SyntheticExtensionParameter? original)
         {
-            var p = new ImplicitExtensionParameter(cx, method, parameter, original);
+            var p = new SyntheticExtensionParameter(cx, method, parameter, original);
             p.TryPopulate();
             return p;
         }

csharp/extractor/Semmle.Extraction.CSharp/Entities/Property.cs

@@ -103,7 +103,6 @@ public override void Populate(TextWriter trapFile)
                         trapFile.expr_access(access, this);
                         if (!Symbol.IsStatic)
                         {
-                            // TODO: What about the containing type for extensions?
                             This.CreateImplicit(Context, Symbol.ContainingType, Location, access, -1);
                         }
                     });

csharp/extractor/Semmle.Extraction.CSharp/Entities/Types/NamedType.cs

@@ -100,7 +100,7 @@ public override void Populate(TextWriter trapFile)
                 if (!string.IsNullOrEmpty(parameter.Name))
                 {
                     var originalType = OriginalDefinition;
-                    // In case the this is constructed generic, we also need to create the unbound parameter.
+                    // In case this is a constructed generic, we also need to create the unbound parameter.
                     var originalParameter = SymbolEqualityComparer.Default.Equals(Symbol, originalType.Symbol.ExtensionParameter) || originalType.Symbol.ExtensionParameter is null
                         ? null
                         : Parameter.Create(Context, originalType.Symbol.ExtensionParameter, originalType);

csharp/extractor/Semmle.Extraction.CSharp/Entities/UserOperator.cs

@@ -68,7 +68,6 @@ public override Type ContainingType
         /// <returns></returns>
         private bool IsImplicitOperator(out ITypeSymbol containingType)
         {
-            // TODO: Do we need to handle extension operators here?
             containingType = Symbol.ContainingType;
             if (containingType is not null)
             {

csharp/extractor/Semmle.Util/IEnumerableExtensions.cs

@@ -131,9 +131,13 @@ public static (IEnumerable<T>, IEnumerable<T>) SplitAt<T>(this IEnumerable<T> it
             foreach (var item in items)
             {
                 if (i < index)
+                {
                     left.Add(item);
+                }
                 else
+                {
                     right.Add(item);
+                }
                 i++;
             }
             return (left, right);