feat: unsafe accessors (#48)

* chore: migration to .NET 8

* test: ThreePrivateMembersClass with UnsafeAccessor

* fix: remove requires reflection

* wip: use unsafe accessor

* fix: publiclyWritable

* wip: unsafe accessor

* fix: ThreePrivateMembersClass test

* test: failing PrivateFluentMethodClass test

* feat: InnerBodyForMethodGenerator

* test: FluentReturnMultiStepPrivateMethodsClass

* test: PrivateConstructorClass

* test: GenericClassPrivateConstructor

* test: ThreeMemberRecordPrimaryConstructor

* test: CanExecuteThreeMemberRecordPrimaryConstructor

* fix: ThreeMemberRecordPrimaryConstructor expected

* test: ThreeMemberRecordPrimaryConstructor

* fix: equality tests

* test: GenericClassPrivateDefaultConstructor

* wip: UsageTests

* test: add GenericClassPrivateConstructor failing usage test

* wip: enabled tests

* chore: upgrade to .NET 10

* chore(M31.FluentApi.Tests): update nuget packages

* test: ParameterAnnotationsPublicConstructorClass / ParameterAnnotationsPrivateConstructorClass

* chore: address warnings

* test: PrivateFluentMethodNullableParameterClass

* refactor: extract CreateParameters method

* test: PrivateFluentMethodParameterModifiersClass

* test: PrivateReadonlyFieldClass (wip)

* test: PrivateReadonlyFieldClass

* test: PrivateUnderscoreFieldClass

* test: PrivateFieldClass

* test: PredicatePrivateFieldClass

* test: InheritedRecord (wip)

* fix: InheritedRecord: CreateStudent.expected.txt

* test: InheritedRecord

* test: InheritedClassPrivateSetters

* test: GetPrivateInitPropertyClass

* test: CollectionNullableArrayClass

* test: ContinueWithAfterCompoundClass

* test: ContinueWithOfOverloadedMethodClass

* test: ContinueWithSelfClass

* test: CommentedMethodsClass

* test: CommentedPropertiesClassAdvanced

* test: FluentNullableNoNullableAnnotationPrivateSetClass

* test: PublicReadonlyFieldClass

* test: PartialClass

* test: TryBreakFluentApiClass1

* test: TryBreakFluentApiClass2

* test: DocumentedStudentClass

* test: Student

* test: ThreeMemberStruct

* usage test: ContinueWithInForkClass

* test: move usage tests

* usage tests: migrated all tests

* fix: declaring class name

* test: GenericOverloadedPrivateMethodClass

* test: write expected

* test: GenericClassWithGenericMethods

* fix: test method names

* test: PrivateConstructorClassWithParams

* fix: remove todo

* fix: exlamation mark in set methods

* chore: add example and story book project

* chore: suppress warnings

* chore: mention UnsafeAccessors

* chore: 2.0.0 and changelog

Author: m31coding

CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [2.0.0] - 2025-12-30
+
+### Changed
+
+- Generated code now requires .NET 10 instead of .NET 6
+- UnsafeAccessors are used instead of reflection for setting private properties and fields

README.md

@@ -26,6 +26,11 @@ Accompanying blog post: [www.m31coding.com>blog>fluent-api](https://www.m31codin
 - Support for returning arbitrary types
 - Support for inheritance, generics, and partial classes
 
+## Prerequisites
+
+- v1.x.x: .NET 6
+- v2.x.x: .NET 10
+
 ## Installing via NuGet
 
 Install the latest version of the package `M31.FluentApi` via your IDE or use the package manager console:
@@ -37,7 +42,7 @@ PM> Install-Package M31.FluentApi
 A package reference will be added to your `csproj` file. Moreover, since this library provides code via source code generation, consumers of your project don't need the reference to `M31.FluentApi`. Therefore, it is recommended to use the `PrivateAssets` metadata tag:
 
 ```xml
-<PackageReference Include="M31.FluentApi" Version="1.12.0" PrivateAssets="all"/>
+<PackageReference Include="M31.FluentApi" Version="2.0.0" PrivateAssets="all"/>
 ```
 
 If you would like to examine the generated code, you may emit it by adding the following lines to your `csproj` file:
@@ -112,7 +117,7 @@ public class Student
 
 ![fluent-api-usage](https://raw.githubusercontent.com/m31coding/M31.FluentAPI/main/media/fluent-api.gif)
 
-You may have a look at the generated code for this example: [CreateStudent.g.cs](src/M31.FluentApi.Tests/CodeGeneration/TestClasses/StudentClass/CreateStudent.g.cs). Note that if you use private members or properties with a private set accessor, as it is the case in this example, the generated code will use reflection to set the properties.
+You may have a look at the generated code for this example: [CreateStudent.g.cs](src/M31.FluentApi.Tests/CodeGeneration/TestClasses/StudentClass/CreateStudent.g.cs). Note that if you use private members or properties with a private set accessor, as it is the case in this example, the generated code will use UnsafeAccessors to set the properties.
 
 ## Attributes
 

src/ExampleProject/ExampleProject.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>

src/M31.FluentApi.Generator/CodeBuilding/Class.cs

@@ -4,6 +4,7 @@ internal class Class : ICode
 {
     private readonly List<Field> fields;
     private readonly List<Method> methods;
+    private readonly List<MethodSignature> methodSignatures;
     private readonly List<Property> properties;
     private readonly List<string> interfaces;
     private readonly List<ICode> definitions;
@@ -15,6 +16,7 @@ internal Class(string name)
         Modifiers = new Modifiers();
         fields = new List<Field>();
         methods = new List<Method>();
+        methodSignatures = new List<MethodSignature>();
         properties = new List<Property>();
         interfaces = new List<string>();
         definitions = new List<ICode>();
@@ -26,6 +28,7 @@ internal Class(string name)
     internal Modifiers Modifiers { get; }
     internal IReadOnlyCollection<Field> Fields => fields;
     internal IReadOnlyCollection<Method> Methods => methods;
+    internal IReadOnlyCollection<MethodSignature> MethodSignatures => methodSignatures;
     internal IReadOnlyCollection<Property> Properties => properties;
     internal IReadOnlyCollection<string> Interfaces => interfaces;
     internal IReadOnlyCollection<ICode> Definitions => definitions;
@@ -55,6 +58,11 @@ internal void AddMethod(Method method)
         methods.Add(method);
     }
 
+    internal void AddMethodSignature(MethodSignature methodSignature)
+    {
+        methodSignatures.Add(methodSignature);
+    }
+
     internal void AddProperty(Property property)
     {
         properties.Add(property);
@@ -113,6 +121,7 @@ public CodeBuilder AppendCode(CodeBuilder codeBuilder)
             .BlankLine()
             .AppendWithBlankLines(methods)
             .AppendWithBlankLines(definitions)
+            .AppendWithBlankLines(methodSignatures)
             .CloseBlock();
     }
 }

src/M31.FluentApi.Generator/CodeBuilding/Interface.cs

@@ -22,7 +22,7 @@ internal Interface(string accessModifier, string name)
 
     internal void AddMethodSignature(CommentedMethodSignature methodSignature)
     {
-        if (!methodSignature.MethodSignature.IsSignatureForInterface)
+        if (!methodSignature.MethodSignature.IsStandaloneSignature)
         {
             throw new ArgumentException("Expected a stand-alone method signature.");
         }

src/M31.FluentApi.Generator/CodeBuilding/Method.cs

@@ -19,6 +19,7 @@ internal Method(MethodComments methodComments, MethodSignature methodSignature,
     internal MethodComments MethodComments { get; }
     internal MethodSignature MethodSignature { get; }
     internal MethodBody MethodBody { get; }
+    internal bool IsConstructor => MethodSignature.IsConstructor;
 
     internal void AddCommentLine(string commentLine)
     {

src/M31.FluentApi.Generator/CodeBuilding/MethodSignature.cs

@@ -6,35 +6,37 @@ private MethodSignature(
         string? returnType,
         string methodName,
         string? explicitInterfacePrefix,
-        bool isSignatureForInterface)
+        bool isStandaloneSignature)
     {
         ReturnType = returnType;
         MethodName = methodName;
         ExplicitInterfacePrefix = explicitInterfacePrefix;
-        IsSignatureForInterface = isSignatureForInterface;
+        IsStandaloneSignature = isStandaloneSignature;
         Generics = new Generics();
         Parameters = new Parameters();
         Modifiers = new Modifiers();
+        Attributes = new List<string>();
     }
 
-    private MethodSignature(MethodSignature methodSignature, bool isSignatureForInterface)
+    private MethodSignature(MethodSignature methodSignature, bool isStandaloneSignature)
     {
         ReturnType = methodSignature.ReturnType;
         MethodName = methodSignature.MethodName;
         ExplicitInterfacePrefix = methodSignature.ExplicitInterfacePrefix;
-        IsSignatureForInterface = isSignatureForInterface;
+        IsStandaloneSignature = isStandaloneSignature;
         Generics = new Generics(methodSignature.Generics);
         Parameters = new Parameters(methodSignature.Parameters);
         Modifiers = new Modifiers(methodSignature.Modifiers);
+        Attributes = new List<string>(methodSignature.Attributes);
     }
 
     internal static MethodSignature Create(
         string returnType,
         string methodName,
         string? prefix,
-        bool isSignatureForInterface)
+        bool isStandaloneSignature)
     {
-        return new MethodSignature(returnType, methodName, prefix, isSignatureForInterface);
+        return new MethodSignature(returnType, methodName, prefix, isStandaloneSignature);
     }
 
     internal static MethodSignature CreateConstructorSignature(string className)
@@ -45,12 +47,14 @@ internal static MethodSignature CreateConstructorSignature(string className)
     internal string? ReturnType { get; }
     internal string MethodName { get; }
     internal string? ExplicitInterfacePrefix { get; }
-    internal bool IsSignatureForInterface { get; }
+    internal bool IsStandaloneSignature { get; }
     internal Generics Generics { get; }
     internal Parameters Parameters { get; }
     internal Modifiers Modifiers { get; }
-    internal bool IsSignatureForMethodBody => !IsSignatureForInterface;
+    internal List<string> Attributes { get; }
+    internal bool IsSignatureForMethodBody => !IsStandaloneSignature;
     internal bool IsExplicitInterfaceImplementation => ExplicitInterfacePrefix != null;
+    internal bool IsConstructor => ReturnType == null;
 
     internal void AddGenericParameter(string parameter, IEnumerable<string> constraints)
     {
@@ -72,6 +76,11 @@ internal void AddModifiers(params string[] modifiers)
         Modifiers.Add(modifiers);
     }
 
+    internal void AddAttribute(string attribute)
+    {
+        Attributes.Add(attribute);
+    }
+
     internal MethodSignature ToSignatureForInterface()
     {
         return new MethodSignature(this, true);
@@ -85,8 +94,11 @@ internal MethodSignature ToSignatureForMethodBody()
     public CodeBuilder AppendCode(CodeBuilder codeBuilder)
     {
         codeBuilder
+            .AppendLines(Attributes)
             .StartLine()
-            .Append(Modifiers, IsSignatureForMethodBody && !IsExplicitInterfaceImplementation)
+            .Append(
+                Modifiers,
+                Modifiers.Contains("extern") || (IsSignatureForMethodBody && !IsExplicitInterfaceImplementation))
             .Append($"{ReturnType} ", ReturnType != null)
             .Append($"{ExplicitInterfacePrefix}.", IsSignatureForMethodBody && IsExplicitInterfaceImplementation)
             .Append(MethodName)
@@ -96,15 +108,15 @@ public CodeBuilder AppendCode(CodeBuilder codeBuilder)
 
         if (Generics.Constraints.Count == 0 || (IsSignatureForMethodBody && IsExplicitInterfaceImplementation))
         {
-            return codeBuilder.Append(IsSignatureForInterface ? ";" : null).EndLine();
+            return codeBuilder.Append(IsStandaloneSignature ? ";" : null).EndLine();
         }
         else
         {
             return codeBuilder
                 .EndLine()
                 .Indent()
                 .Append(Generics.Constraints)
-                .Append(IsSignatureForInterface ? ";" : null)
+                .Append(IsStandaloneSignature ? ";" : null)
                 .EndLine()
                 .Unindent();
         }

src/M31.FluentApi.Generator/CodeGeneration/CodeBoardActors/BuilderMethodsGeneration/BuilderStepMethod.cs

@@ -50,16 +50,7 @@ private MethodSignature CreateMethodSignature(
 
         MethodSignature signature = MethodSignature.Create(returnType, MethodName, explicitInterfacePrefix, false);
         signature.AddModifiers(modifiers);
-
-        if (GenericInfo != null)
-        {
-            foreach (GenericTypeParameter genericTypeParameter in GenericInfo.Parameters)
-            {
-                signature.AddGenericParameter(
-                    genericTypeParameter.ParameterName,
-                    genericTypeParameter.Constraints.GetConstraintsForCodeGeneration());
-            }
-        }
+        CodeBuildingHelpers.AddGenericParameters(signature, GenericInfo);
 
         foreach (Parameter parameter in Parameters)
         {

src/M31.FluentApi.Generator/CodeGeneration/CodeBoardActors/Commons/BuilderMethodFactory.cs

@@ -85,15 +85,7 @@ internal BuilderMethod CreateBuilderMethod(
         string methodName,
         bool respectReturnType)
     {
-        List<Parameter> parameters = methodSymbolInfo.ParameterInfos
-            .Select(i => new Parameter(
-                i.TypeForCodeGeneration,
-                i.ParameterName,
-                i.DefaultValue,
-                i.GenericTypeParameterPosition,
-                new ParameterAnnotations(i.ParameterKinds)))
-            .ToList();
-
+        List<Parameter> parameters = CodeBuildingHelpers.CreateParameters(methodSymbolInfo.ParameterInfos);
         string? returnTypeToRespect = respectReturnType ? methodSymbolInfo.ReturnType : null;
 
         List<string> BuildBodyCode(

src/M31.FluentApi.Generator/CodeGeneration/CodeBoardActors/Commons/CodeBuildingHelpers.cs

@@ -0,0 +1,35 @@
+using M31.FluentApi.Generator.CodeBuilding;
+using M31.FluentApi.Generator.CodeGeneration.CodeBoardElements;
+using M31.FluentApi.Generator.SourceGenerators.Generics;
+
+namespace M31.FluentApi.Generator.CodeGeneration.CodeBoardActors.Commons;
+
+internal static class CodeBuildingHelpers
+{
+    internal static void AddGenericParameters(MethodSignature methodSignature, GenericInfo? genericInfo)
+    {
+        if (genericInfo == null)
+        {
+            return;
+        }
+
+        foreach (GenericTypeParameter genericTypeParameter in genericInfo.Parameters)
+        {
+            methodSignature.AddGenericParameter(
+                genericTypeParameter.ParameterName,
+                genericTypeParameter.Constraints.GetConstraintsForCodeGeneration());
+        }
+    }
+
+    internal static List<Parameter> CreateParameters(IReadOnlyCollection<ParameterSymbolInfo> parameterInfos)
+    {
+        return parameterInfos
+            .Select(i => new Parameter(
+                i.TypeForCodeGeneration,
+                i.ParameterName,
+                i.DefaultValue,
+                i.GenericTypeParameterPosition,
+                new ParameterAnnotations(i.ParameterKinds)))
+            .ToList();
+    }
+}