C#: Extractor support for extension blocks.

Author: michaelnebel

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

@@ -164,6 +164,7 @@ public static void BuildTypeId(this ITypeSymbol type, Context cx, EscapingTextWr
                     case TypeKind.Enum:
                     case TypeKind.Delegate:
                     case TypeKind.Error:
+                    case TypeKind.Extension:
                         var named = (INamedTypeSymbol)type;
                         named.BuildNamedTypeId(cx, trapFile, symbolBeingDefined, constructUnderlyingTupleType);
                         return;
@@ -391,6 +392,7 @@ public static void BuildDisplayName(this ITypeSymbol type, Context cx, TextWrite
                     case TypeKind.Enum:
                     case TypeKind.Delegate:
                     case TypeKind.Error:
+                    case TypeKind.Extension:
                         var named = (INamedTypeSymbol)type;
                         named.BuildNamedTypeDisplayName(cx, trapFile, constructUnderlyingTupleType);
                         return;
@@ -484,6 +486,14 @@ private static void BuildNamedTypeDisplayName(this INamedTypeSymbol namedType, C
                 return;
             }
 
+            if (namedType.IsExtension)
+            {
+                var type = namedType.ExtensionParameter?.Type.Name;
+                var name = $"extension({type})";
+                trapFile.Write(TrapExtensions.EncodeString(name));
+                return;
+            }
+
             if (namedType.IsAnonymousType)
             {
                 namedType.BuildAnonymousName(cx, trapFile);
@@ -596,6 +606,12 @@ public static bool IsSourceDeclaration(this IParameterSymbol parameter)
             return true;
         }
 
+        /// <summary>
+        /// Return true if this method is a compiler-generated extension method.
+        /// </summary>
+        public static bool IsCompilerGeneratedExtensionMethod(this IMethodSymbol method) =>
+            method.IsImplicitlyDeclared && method.IsExtensionMethod;
+
         /// <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/Base/CachedSymbol.cs

@@ -107,7 +107,7 @@ public virtual IEnumerable<Location> Locations
         /// Bind comments to this symbol.
         /// Comments are only bound to source declarations.
         /// </summary>
-        protected void BindComments()
+        protected virtual void BindComments()
         {
             if (!Symbol.IsImplicitlyDeclared && IsSourceDeclaration && Symbol.FromSource())
                 Context.BindComments(this, FullLocation);

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

@@ -119,8 +119,28 @@ public IMethodSymbol? TargetSymbol
             {
                 var si = SymbolInfo;
 
-                if (si.Symbol is not null)
-                    return si.Symbol as IMethodSymbol;
+                if (si.Symbol is ISymbol symbol)
+                {
+                    var method = symbol as IMethodSymbol;
+                    // Case for compiler-generated extension methods.
+                    if (method is not null &&
+                        method.IsCompilerGeneratedExtensionMethod() &&
+                        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).
+                        var original = extensions.SelectMany(e => e.GetMembers())
+                            .OfType<IMethodSymbol>()
+                            .FirstOrDefault(m => SymbolEqualityComparer.Default.Equals(m.AssociatedExtensionImplementation, method));
+                        return original ?? method;
+                    }
+
+                    return method;
+                }
 
                 if (si.CandidateReason == CandidateReason.OverloadResolutionFailure)
                 {

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

@@ -16,7 +16,19 @@ protected Method(Context cx, IMethodSymbol init)
 
         protected void PopulateParameters()
         {
+            var positionOffset = 0;
             var originalMethod = OriginalDefinition;
+
+            // Synthesize implicit parameter for extension methods declared using extension(...) syntax.
+            if (Symbol.ContainingSymbol is INamedTypeSymbol type &&
+                type.IsExtension && !string.IsNullOrEmpty(type.ExtensionParameter?.Name) &&
+                Symbol.AssociatedExtensionImplementation is IMethodSymbol associated)
+            {
+                // TODO: Check that this works for generics as well. We might need to also take
+                ImplicitExtensionParameter.Create(Context, this);
+                positionOffset++;
+            }
+
             IEnumerable<IParameterSymbol> parameters = Symbol.Parameters;
             IEnumerable<IParameterSymbol> originalParameters = originalMethod.Symbol.Parameters;
 

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

@@ -23,7 +23,11 @@ protected OrdinaryMethod(Context cx, IMethodSymbol init)
                 ? Symbol.ContainingType.GetSymbolLocation()
                 : BodyDeclaringSymbol.GetSymbolLocation();
 
-        public override bool NeedsPopulation => base.NeedsPopulation || IsCompilerGeneratedDelegate();
+        public override bool NeedsPopulation =>
+            (base.NeedsPopulation || IsCompilerGeneratedDelegate()) &&
+            // Exclude compiler-generated extension methods. A call to such a method
+            // is replaced by a call to the defining extension method.
+            !Symbol.IsCompilerGeneratedExtensionMethod();
 
         public override void Populate(TextWriter trapFile)
         {

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

@@ -7,16 +7,25 @@
 
 namespace Semmle.Extraction.CSharp.Entities
 {
-    internal class Parameter : CachedSymbol<IParameterSymbol>, IExpressionParentEntity
+    // Marker interface for parameter entities.
+    public interface IParameterEntity : IEntity { }
+    internal class Parameter : CachedSymbol<IParameterSymbol>, IExpressionParentEntity, IParameterEntity
     {
         protected IEntity? Parent { get; set; }
         protected Parameter Original { get; }
+        private int PositionOffset { get; set; }
 
-        protected Parameter(Context cx, IParameterSymbol init, IEntity? parent, Parameter? original)
+        private Parameter(Context cx, IParameterSymbol init, IEntity? parent, Parameter? original, int positionOffset)
             : base(cx, init)
         {
             Parent = parent;
             Original = original ?? this;
+            PositionOffset = positionOffset;
+        }
+
+        protected Parameter(Context cx, IParameterSymbol init, IEntity? parent, Parameter? original)
+            : this(cx, init, parent, original, 0)
+        {
         }
 
         public override Microsoft.CodeAnalysis.Location ReportingLocation => Symbol.GetSymbolLocation();
@@ -32,7 +41,7 @@ public enum Kind
             RefReadOnly = 6
         }
 
-        protected virtual int Ordinal => Symbol.Ordinal;
+        protected virtual int Ordinal => Symbol.Ordinal + PositionOffset;
 
         private Kind ParamKind
         {
@@ -55,30 +64,35 @@ private Kind ParamKind
                         if (Ordinal == 0)
                         {
                             if (Symbol.ContainingSymbol is IMethodSymbol method && method.IsExtensionMethod)
+                            {
                                 return Kind.This;
+                            }
                         }
                         return Kind.None;
                 }
             }
         }
 
-        public static Parameter Create(Context cx, IParameterSymbol param, IEntity parent, Parameter? original = null)
+        public static Parameter Create(Context cx, IParameterSymbol param, IEntity parent, Parameter? original = null, int positionOffset = 0)
         {
             var cachedSymbol = cx.GetPossiblyCachedParameterSymbol(param);
-            return ParameterFactory.Instance.CreateEntity(cx, cachedSymbol, (cachedSymbol, parent, original));
+            return ParameterFactory.Instance.CreateEntity(cx, cachedSymbol, (cachedSymbol, parent, original, positionOffset));
         }
 
         public static Parameter Create(Context cx, IParameterSymbol param)
         {
             var cachedSymbol = cx.GetPossiblyCachedParameterSymbol(param);
-            return ParameterFactory.Instance.CreateEntity(cx, cachedSymbol, (cachedSymbol, null, null));
+            return ParameterFactory.Instance.CreateEntity(cx, cachedSymbol, (cachedSymbol, null, null, 0));
         }
 
         public override void WriteId(EscapingTextWriter trapFile)
         {
             if (Parent is null)
                 Parent = Method.Create(Context, Symbol.ContainingSymbol as IMethodSymbol);
 
+            if (Parent is null && Symbol.ContainingSymbol is INamedTypeSymbol type && type.IsExtension)
+                Parent = Type.Create(Context, type);
+
             if (Parent is null)
                 throw new InternalError(Symbol, "Couldn't get parent of symbol.");
 
@@ -194,11 +208,11 @@ Symbol.ContainingSymbol is IMethodSymbol ms &&
             return syntax?.Default;
         }
 
-        private class ParameterFactory : CachedEntityFactory<(IParameterSymbol, IEntity?, Parameter?), Parameter>
+        private class ParameterFactory : CachedEntityFactory<(IParameterSymbol, IEntity?, Parameter?, int), Parameter>
         {
             public static ParameterFactory Instance { get; } = new ParameterFactory();
 
-            public override Parameter Create(Context cx, (IParameterSymbol, IEntity?, Parameter?) init) => new Parameter(cx, init.Item1, init.Item2, init.Item3);
+            public override Parameter Create(Context cx, (IParameterSymbol, IEntity?, Parameter?, int) init) => new Parameter(cx, init.Item1, init.Item2, init.Item3, init.Item4);
         }
 
         public override TrapStackBehaviour TrapStackBehaviour => TrapStackBehaviour.OptionalLabel;
@@ -243,6 +257,111 @@ private class VarargsTypeFactory : CachedEntityFactory<string?, VarargsType>
         }
     }
 
+    /// <summary>
+    /// Synthetic parameter for extension methods declared using the extensions 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
+    /// to populate the database.
+    /// </summary>
+    internal class ImplicitExtensionParameter : Parameter
+    {
+        private Method ExtensionMethod { get; init; }
+
+        private ImplicitExtensionParameter(Context cx, Method method)
+#nullable disable warnings
+            : base(cx, method.Symbol.AssociatedExtensionImplementation.Parameters[0], method, null)
+        {
+            ExtensionMethod = method;
+        }
+#nullable restore warnings
+
+        protected override int Ordinal => 0;
+
+        private Kind ParamKind
+        {
+            get
+            {
+                switch (Symbol.RefKind)
+                {
+                    case RefKind.Ref:
+                        return Kind.Ref;
+                    case RefKind.In:
+                        return Kind.In;
+                    case RefKind.RefReadOnlyParameter:
+                        return Kind.RefReadOnly;
+                    default:
+                        return Kind.None;
+                }
+            }
+        }
+
+        private string Name => Symbol.Name;
+
+        public override bool IsSourceDeclaration => ExtensionMethod.Symbol.IsSourceDeclaration();
+
+        /// <summary>
+        /// Bind comments to this symbol.
+        /// Comments are only bound to source declarations.
+        /// </summary>
+        protected override void BindComments()
+        {
+            if (IsSourceDeclaration && Symbol.FromSource())
+                Context.BindComments(this, FullLocation);
+        }
+
+        public override void Populate(TextWriter trapFile)
+        {
+            PopulateAttributes();
+            PopulateNullability(trapFile, Symbol.GetAnnotatedType());
+            PopulateRefKind(trapFile, Symbol.RefKind);
+
+            var type = Type.Create(Context, Symbol.Type);
+            trapFile.@params(this, Name, type.TypeRef, Ordinal, ParamKind, Parent!, this);
+
+            if (Context.OnlyScaffold)
+            {
+                return;
+            }
+
+            if (Context.ExtractLocation(Symbol))
+            {
+                var locations = Context.GetLocations(Symbol);
+                WriteLocationsToTrap(trapFile.param_location, this, locations);
+            }
+
+            if (!IsSourceDeclaration || !Symbol.FromSource())
+                return;
+
+            BindComments();
+
+            if (IsSourceDeclaration)
+            {
+                foreach (var syntax in Symbol.DeclaringSyntaxReferences
+                    .Select(d => d.GetSyntax())
+                    .OfType<ParameterSyntax>()
+                    .Where(s => s.Type is not null))
+                {
+                    TypeMention.Create(Context, syntax.Type!, this, type);
+                }
+            }
+        }
+
+        public static ImplicitExtensionParameter Create(Context cx, Method method) => ImplicitExtensionParameterFactory.Instance.CreateEntity(cx, typeof(ImplicitExtensionParameter), method);
+
+        private class ImplicitExtensionParameterFactory : CachedEntityFactory<Method, ImplicitExtensionParameter>
+        {
+            public static ImplicitExtensionParameterFactory Instance { get; } = new ImplicitExtensionParameterFactory();
+
+            public override ImplicitExtensionParameter Create(Context cx, Method init) => new ImplicitExtensionParameter(cx, init);
+        }
+
+
+    }
+
     internal class VarargsParam : Parameter
     {
 #nullable disable warnings

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

@@ -103,6 +103,7 @@ 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/Type.cs

@@ -105,6 +105,7 @@ public Kinds.TypeKind GetTypeKind(Context cx, bool constructUnderlyingTupleType)
                         case TypeKind.Pointer: return Kinds.TypeKind.POINTER;
                         case TypeKind.FunctionPointer: return Kinds.TypeKind.FUNCTION_POINTER;
                         case TypeKind.Error: return Kinds.TypeKind.UNKNOWN;
+                        case TypeKind.Extension: return Kinds.TypeKind.EXTENSION;
                         default:
                             cx.ModelError(Symbol, $"Unhandled type kind '{Symbol.TypeKind}'");
                             return Kinds.TypeKind.UNKNOWN;
@@ -366,7 +367,7 @@ private class DelegateTypeParameter : Parameter
             private DelegateTypeParameter(Context cx, IParameterSymbol init, IEntity parent, Parameter? original)
                 : base(cx, init, parent, original) { }
 
-            public static new DelegateTypeParameter Create(Context cx, IParameterSymbol param, IEntity parent, Parameter? original = null) =>
+            public static DelegateTypeParameter Create(Context cx, IParameterSymbol param, IEntity parent, Parameter? original = null) =>
                // We need to use a different cache key than `param` to avoid mixing up
                // `DelegateTypeParameter`s and `Parameter`s
                DelegateTypeParameterFactory.Instance.CreateEntity(cx, (typeof(DelegateTypeParameter), new SymbolEqualityWrapper(param)), (param, parent, original));

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

@@ -68,6 +68,7 @@ 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.Extraction.CSharp/Kinds/TypeKind.cs

@@ -38,5 +38,6 @@ public enum TypeKind
         TUPLE = 32,
         FUNCTION_POINTER = 33,
         INLINE_ARRAY = 34,
+        EXTENSION = 35
     }
 }