Incomplete support for C# 14 Extension Members

This commit at least generates compilable code but it doesn't yet tie extension members to their extended type.

Author: lemonmojo

Generator/Beyond.NET.CodeGenerator/Collectors/MemberCollector.cs

@@ -79,6 +79,12 @@ out Dictionary<MemberInfo, string> unsupportedMembers
                     continue;
                 }
 
+                if (memberInfo.GetCustomAttribute<System.Runtime.CompilerServices.ExtensionMarkerAttribute>() is not null) {
+                    unsupportedMembers[memberInfo] = "Has extension marker";
+
+                    continue;
+                }
+
                 if (isInterface)
                 {
                     if (memberInfo is MethodInfo { IsAbstract: true, IsStatic: true })
@@ -157,6 +163,24 @@ Dictionary<MemberInfo, string> unsupportedMembers
                 CollectEvent((EventInfo)memberInfo, collectedMembers, unsupportedMembers);
 
                 break;
+            // case MemberTypes.NestedType:
+            //     // TODO: This might be useful to retrieve a mapping from a C# 14 extension type to the extended type
+            //     if (memberInfo.GetCustomAttribute<System.Runtime.CompilerServices.ExtensionAttribute>() is not null &&
+            //         memberInfo is TypeInfo typeInfo) {
+            //         var nestedType = typeInfo.DeclaredNestedTypes.FirstOrDefault();
+            //
+            //         if (nestedType is not null &&
+            //             nestedType.GetMember("<Extension>$").FirstOrDefault() is MethodInfo extensionMember) {
+            //             var extensionType = typeInfo.AsType();
+            //             var extensionTargetType = extensionMember.GetParameters().FirstOrDefault()?.ParameterType;
+            //
+            //             // TODO: Store this mapping somewhere so that we can refer to it later on
+            //
+            //             Console.WriteLine("TODO");
+            //         }
+            //     }
+            //
+            //     break;
             default:
                 unsupportedMembers[memberInfo] = $"Unsupported member type: {memberType}";
 
@@ -351,4 +375,4 @@ out string? unsupportedReason
 
         return true;
     }
-}
+}

Generator/Beyond.NET.CodeGenerator/Collectors/TypeCollector.cs

@@ -395,6 +395,11 @@ out string? unsupportedReason
             return false;
         }
 
+        if (type.IsSpecialName) {
+            unsupportedReason = "Has special name (maybe C# 14 extension type?)";
+            return false;
+        }
+
         bool isNullableValueType = type.IsNullableValueType(out Type? nullableValueType);
 
         // Only nullable structs, not primitives or enums are currently supported

Generator/Beyond.NET.CodeGenerator/Extensions/TypeExtensions.cs

@@ -318,4 +318,4 @@ Type interfaceType
 
         return false;
     }
-}
+}

Generator/Beyond.NET.CodeGenerator/Syntax/C/CTypeSyntaxWriter.cs

@@ -307,7 +307,7 @@ public string WriteMembers(Type type, State state, ISyntaxWriterConfiguration? c
         string fullTypeName = type.GetFullNameOrName();
 
         bool isDelegate = type.IsDelegate();
-
+    
         sb.AppendLine(
             Builder.PragmaMark()
                 .Separator()
@@ -592,4 +592,4 @@ out ICSyntaxWriter? syntaxWriter
 
         return syntaxWriter;
     }
-}
+}

Generator/Beyond.NET.CodeGenerator/Syntax/GeneratedMember.cs

@@ -40,4 +40,9 @@ out string? generatedName
 
         return generatedName;
     }
-}
+
+    public override string ToString()
+    {
+        return Member?.ToString() ?? MemberKind.ToString();
+    }
+}

Generator/Beyond.NET.CodeGenerator/Syntax/State.cs

@@ -136,6 +136,8 @@ public IEnumerable<GeneratedMember> GetGeneratedMembersThatAreExtensions()
                 continue;
             }
 
+            // TODO: This doesn't work for C# 14 extensions as they don't have the System.Runtime.CompilerServices.ExtensionAttribute
+            // Instead, they seem to emit some additional nested type which we maybe could use to retrieve the mapping between extension type and extended type. There's also a new attribute: System.Runtime.CompilerServices.ExtensionMarkerAttribute
             if (declaringType.IsGenericType ||
                 declaringType.IsNested ||
                 !declaringType.IsSealed ||
@@ -154,4 +156,4 @@ public IEnumerable<GeneratedMember> GetGeneratedMembersThatAreExtensions()
 
         return extensionMembers;
     }
-}
+}

Samples/Beyond.NET.Sample.Managed/Source/NestedTypeTests.cs

@@ -0,0 +1,9 @@
+namespace Beyond.NET.Sample.Source;
+
+public class NestedTypeTests
+{
+    public class MyNestedType
+    {
+        public static bool PrettyLonelyAroundHere => true;
+    }
+}

Samples/Beyond.NET.Sample.Managed/Source/Person.cs

@@ -115,7 +115,7 @@ string lastName
     /// <summary>
     /// Creates a Person named "John Doe" who is 50 years old.
     /// </summary>
-    /// <returns>Your new John New</returns>
+    /// <returns>Your new John Doe</returns>
     public static Person MakeJohnDoe() => new("John", "Doe", 50);
 
     /// <summary>

Samples/Beyond.NET.Sample.Managed/Source/Person_Extensions.cs

@@ -19,4 +19,38 @@ out Address? address
 
         return address is not null;
     }
-}
+
+    extension(Person person)
+    {
+        /// <summary>
+        /// Creates a Person named "Jane Doe" who is 50 years old.
+        /// Implemented as a .NET 10 static extension method.
+        /// </summary>
+        /// <returns>Your new Jane Doe</returns>
+        public static Person MakeJaneDoe() => new("Jane", "Doe", 50);
+
+
+        /// <summary>
+        /// Increases the target person's age by 1.
+        /// Implemented as a .NET 10 extension method.
+        /// </summary>
+        public void CelerbrateBirthday()
+        {
+            person.IncreaseAge(1);
+        }
+
+        /// <summary>
+        /// The getter returns `true` if the target person's nice level is `NotNice` or "lower". When `true` is passed to the setter, it sets the person's nice level to `NotNice`, when `false` it doesn't do anything.
+        /// Implemented as a .NET 10 extension property.
+        /// </summary>
+        public bool IsMean
+        {
+            get => person.NiceLevel <= NiceLevels.NotNice;
+            set {
+                if (value) {
+                    person.NiceLevel = NiceLevels.NotNice;
+                }
+            }
+        }
+    }
+}

Samples/Beyond.NET.Sample.Swift/Tests/TestClasses/PersonTests.swift

@@ -334,4 +334,14 @@ final class PersonTests: XCTestCase {
 
         XCTAssertEqual(2, numberOfChildrenAfterDaugther)
     }
+    
+    func testPersonExtensions() throws {
+        // TODO: Support for C# 14 extension methods is incomplete!
+        
+        let janeDoe = try Beyond_NET_Sample_Person_Extensions.makeJaneDoe()
+        try XCTAssertEqual(janeDoe.fullName.string(), "Jane Doe")
+        
+//        let janeDoe = try Beyond_NET_Sample_Person.makeJaneDoe()
+//        try XCTAssertEqual(janeDoe.fullName.string(), "Jane Doe")
+    }
 }