Merge pull request #21220 from michaelnebel/csharp14/extension

C# 14: Support `extension` types.

Author: michaelnebel

csharp/downgrades/178a7e6cf335486d33d4e49543148e3f57f04a9a/old.dbscheme

@@ -0,0 +1,3 @@
+description: Remove the relation `extension_receiver_type` and remove the `extension_type` type kind.
+compatibility: backwards
+extension_receiver_type.rel: delete

csharp/downgrades/178a7e6cf335486d33d4e49543148e3f57f04a9a/semmlecode.csharp.dbscheme

@@ -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
@@ -164,6 +165,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;
@@ -275,6 +277,20 @@ private static void BuildFunctionPointerTypeId(this IFunctionPointerTypeSymbol f
         public static IEnumerable<IFieldSymbol?> GetTupleElementsMaybeNull(this INamedTypeSymbol type) =>
             type.TupleElements;
 
+        private static void BuildExtensionTypeId(this INamedTypeSymbol named, Context cx, EscapingTextWriter trapFile)
+        {
+            trapFile.Write("extension(");
+            if (named.ExtensionMarkerName is not null)
+            {
+                trapFile.Write(named.ExtensionMarkerName);
+            }
+            else
+            {
+                trapFile.Write("unknown");
+            }
+            trapFile.Write(")");
+        }
+
         private static void BuildQualifierAndName(INamedTypeSymbol named, Context cx, EscapingTextWriter trapFile, ISymbol symbolBeingDefined)
         {
             if (named.ContainingType is not null)
@@ -289,8 +305,18 @@ private static void BuildQualifierAndName(INamedTypeSymbol named, Context cx, Es
                 named.ContainingNamespace.BuildNamespace(cx, trapFile);
             }
 
-            var name = named.IsFileLocal ? named.MetadataName : named.Name;
-            trapFile.Write(name);
+            if (named.IsFileLocal)
+            {
+                trapFile.Write(named.MetadataName);
+            }
+            else if (named.IsExtension)
+            {
+                named.BuildExtensionTypeId(cx, trapFile);
+            }
+            else
+            {
+                trapFile.Write(named.Name);
+            }
         }
 
         private static void BuildTupleId(INamedTypeSymbol named, Context cx, EscapingTextWriter trapFile, ISymbol symbolBeingDefined)
@@ -391,6 +417,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;
@@ -465,6 +492,20 @@ public static void BuildFunctionPointerSignature(IFunctionPointerTypeSymbol funp
         private static void BuildFunctionPointerTypeDisplayName(this IFunctionPointerTypeSymbol funptr, Context cx, TextWriter trapFile) =>
             BuildFunctionPointerSignature(funptr, trapFile, s => s.BuildDisplayName(cx, trapFile));
 
+        private static void BuildExtensionTypeDisplayName(this INamedTypeSymbol named, Context cx, TextWriter trapFile)
+        {
+            trapFile.Write("extension(");
+            if (named.ExtensionParameter?.Type is ITypeSymbol type)
+            {
+                type.BuildDisplayName(cx, trapFile);
+            }
+            else
+            {
+                trapFile.Write("unknown");
+            }
+            trapFile.Write(")");
+        }
+
         private static void BuildNamedTypeDisplayName(this INamedTypeSymbol namedType, Context cx, TextWriter trapFile, bool constructUnderlyingTupleType)
         {
             if (!constructUnderlyingTupleType && namedType.IsTupleType)
@@ -484,6 +525,12 @@ private static void BuildNamedTypeDisplayName(this INamedTypeSymbol namedType, C
                 return;
             }
 
+            if (namedType.IsExtension)
+            {
+                namedType.BuildExtensionTypeDisplayName(cx, trapFile);
+                return;
+            }
+
             if (namedType.IsAnonymousType)
             {
                 namedType.BuildAnonymousName(cx, trapFile);
@@ -596,6 +643,84 @@ 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.TryGetExtensionMethod() is not null;
+
+        /// <summary>
+        /// Returns the extension method corresponding to this compiler-generated extension method, if it exists.
+        /// </summary>
+        public static IMethodSymbol? TryGetExtensionMethod(this IMethodSymbol method)
+        {
+            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 (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.ConstructedFrom));
+
+                var isFullyConstructed = method.IsBoundGenericMethod();
+                if (isFullyConstructed && unboundDeclaration?.ContainingType is INamedTypeSymbol extensionType)
+                {
+                    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.IsUnboundGenericType()
+                            ? extensionType.Construct(extensionTypeArguments.ToArray())
+                            : extensionType;
+
+                        // 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.
+                        return extensionDeclaration.IsUnboundGenericMethod()
+                            ? extensionDeclaration.Construct(extensionMethodArguments.ToArray())
+                            : extensionDeclaration;
+                    }
+                    catch
+                    {
+                        // If anything goes wrong, fall back to the unbound declaration.
+                        return unboundDeclaration;
+                    }
+                }
+                else
+                {
+                    return unboundDeclaration;
+                }
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Returns true if this method is an unbound generic method.
+        /// </summary>
+        public static bool IsUnboundGenericMethod(this IMethodSymbol method) =>
+            method.IsGenericMethod && SymbolEqualityComparer.Default.Equals(method.ConstructedFrom, method);
+
+        /// <summary>
+        /// Returns true if this method is a bound generic method.
+        /// </summary>
+        public static bool IsBoundGenericMethod(this IMethodSymbol method) => method.IsGenericMethod && !method.IsUnboundGenericMethod();
+
+        /// <summary>
+        /// Returns true if this type is an unbound generic type.
+        /// </summary>
+        public static bool IsUnboundGenericType(this INamedTypeSymbol type) =>
+            type.IsGenericType && SymbolEqualityComparer.Default.Equals(type.ConstructedFrom, type);
+
         /// <summary>
         /// Gets the base type of `symbol`. Unlike `symbol.BaseType`, this excludes effective base
         /// types of type parameters as well as `object` base types.
@@ -692,5 +817,35 @@ public static bool ShouldExtractSymbol(this ISymbol symbol)
         /// </summary>
         public static IEnumerable<T> ExtractionCandidates<T>(this IEnumerable<T> symbols) where T : ISymbol =>
             symbols.Where(symbol => symbol.ShouldExtractSymbol());
+
+        /// <summary>
+        /// Returns the parameter kind for this parameter symbol, e.g. `ref`, `out`, `params`, etc.
+        /// </summary>
+        public static Parameter.Kind GetParameterKind(this IParameterSymbol parameter)
+        {
+            switch (parameter.RefKind)
+            {
+                case RefKind.Out:
+                    return Parameter.Kind.Out;
+                case RefKind.Ref:
+                    return Parameter.Kind.Ref;
+                case RefKind.In:
+                    return Parameter.Kind.In;
+                case RefKind.RefReadOnlyParameter:
+                    return Parameter.Kind.RefReadOnly;
+                default:
+                    if (parameter.IsParams)
+                        return Parameter.Kind.Params;
+
+                    if (parameter.Ordinal == 0)
+                    {
+                        if (parameter.ContainingSymbol is IMethodSymbol method && method.IsExtensionMethod)
+                        {
+                            return Parameter.Kind.This;
+                        }
+                    }
+                    return Parameter.Kind.None;
+            }
+        }
     }
 }

csharp/downgrades/178a7e6cf335486d33d4e49543148e3f57f04a9a/upgrade.properties

@@ -54,22 +54,6 @@ public string DebugContents
             }
         }
 
-        protected static void WriteLocationToTrap<T1>(Action<T1, Location> writeAction, T1 entity, Location l)
-        {
-            if (l is not EmptyLocation)
-            {
-                writeAction(entity, l);
-            }
-        }
-
-        protected static void WriteLocationsToTrap<T1>(Action<T1, Location> writeAction, T1 entity, IEnumerable<Location> locations)
-        {
-            foreach (var loc in locations)
-            {
-                WriteLocationToTrap(writeAction, entity, loc);
-            }
-        }
-
         public override bool NeedsPopulation { get; }
 
         public override int GetHashCode() => Symbol is null ? 0 : Symbol.GetHashCode();

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

@@ -32,32 +32,6 @@ protected void PopulateAttributes()
                 Attribute.ExtractAttributes(Context, Symbol, this);
         }
 
-        protected void PopulateNullability(TextWriter trapFile, AnnotatedTypeSymbol type)
-        {
-            var n = NullabilityEntity.Create(Context, Nullability.Create(type));
-            if (!type.HasObliviousNullability())
-            {
-                trapFile.type_nullability(this, n);
-            }
-        }
-
-        protected void PopulateRefKind(TextWriter trapFile, RefKind kind)
-        {
-            switch (kind)
-            {
-                case RefKind.Out:
-                    trapFile.type_annotation(this, Kinds.TypeAnnotation.Out);
-                    break;
-                case RefKind.Ref:
-                    trapFile.type_annotation(this, Kinds.TypeAnnotation.Ref);
-                    break;
-                case RefKind.RefReadOnly:
-                case RefKind.RefReadOnlyParameter:
-                    trapFile.type_annotation(this, Kinds.TypeAnnotation.ReadonlyRef);
-                    break;
-            }
-        }
-
         protected void PopulateScopedKind(TextWriter trapFile, ScopedKind kind)
         {
             switch (kind)

csharp/extractor/Semmle.Extraction.CSharp/Entities/Base/CachedEntity.cs

@@ -1,6 +1,8 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using Microsoft.CodeAnalysis;
+using Semmle.Extraction.CSharp.Entities;
 
 namespace Semmle.Extraction.CSharp
 {
@@ -24,7 +26,7 @@ public virtual void WriteQuotedId(EscapingTextWriter trapFile)
             trapFile.WriteUnescaped('\"');
         }
 
-        public abstract Location? ReportingLocation { get; }
+        public abstract Microsoft.CodeAnalysis.Location? ReportingLocation { get; }
 
         public abstract TrapStackBehaviour TrapStackBehaviour { get; }
 
@@ -65,6 +67,48 @@ public string GetDebugLabel()
         }
 #endif
 
+        protected void PopulateRefKind(TextWriter trapFile, RefKind kind)
+        {
+            switch (kind)
+            {
+                case RefKind.Out:
+                    trapFile.type_annotation(this, Kinds.TypeAnnotation.Out);
+                    break;
+                case RefKind.Ref:
+                    trapFile.type_annotation(this, Kinds.TypeAnnotation.Ref);
+                    break;
+                case RefKind.RefReadOnly:
+                case RefKind.RefReadOnlyParameter:
+                    trapFile.type_annotation(this, Kinds.TypeAnnotation.ReadonlyRef);
+                    break;
+            }
+        }
+
+        protected void PopulateNullability(TextWriter trapFile, AnnotatedTypeSymbol type)
+        {
+            var n = NullabilityEntity.Create(Context, Nullability.Create(type));
+            if (!type.HasObliviousNullability())
+            {
+                trapFile.type_nullability(this, n);
+            }
+        }
+
+        protected static void WriteLocationToTrap<T1>(Action<T1, Entities.Location> writeAction, T1 entity, Entities.Location l)
+        {
+            if (l is not EmptyLocation)
+            {
+                writeAction(entity, l);
+            }
+        }
+
+        protected static void WriteLocationsToTrap<T1>(Action<T1, Entities.Location> writeAction, T1 entity, IEnumerable<Entities.Location> locations)
+        {
+            foreach (var loc in locations)
+            {
+                WriteLocationToTrap(writeAction, entity, loc);
+            }
+        }
+
         public override string ToString() => Label.ToString();
     }
 }