Support default values in fluent methods (#5)

* fix: address minor warnings

* feat(FluentMethod): support default parameter values

Author: m31coding

src/ExampleProject/ExampleProject.csproj

@@ -8,12 +8,13 @@
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="M31.FluentApi" Version="1.0.0" PrivateAssets="all" />
+      <ProjectReference Include="..\M31.FluentApi\M31.FluentApi.csproj"/>
+      <ProjectReference Include="..\M31.FluentApi.Generator\M31.FluentApi.Generator.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer"/>
     </ItemGroup>
 
   <PropertyGroup>
     <CompilerGeneratedFilesOutputPath>$(BaseIntermediateOutputPath)Generated</CompilerGeneratedFilesOutputPath>
     <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
   </PropertyGroup>
 
-</Project>
+</Project>

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

@@ -60,7 +60,7 @@ internal CodeBuilder Append(string? code)
         if (code is not null)
         {
             InsertNewLines();
-            stringBuilder.Append(code!);
+            stringBuilder.Append(code);
         }
 
         return this;

src/M31.FluentApi.Generator/CodeGeneration/CodeBoardActors/MethodCreation/Collections/CollectionMethodCreator.cs

@@ -28,7 +28,7 @@ internal CollectionMethodCreator(
             : methodCreator.CreateMethod(symbolInfo, collectionAttributeInfo.WithItems);
     }
 
-    internal BuilderMethod? CreateWithItemsParamsMethod(MethodCreator methodCreator)
+    internal BuilderMethod CreateWithItemsParamsMethod(MethodCreator methodCreator)
     {
         Parameter parameter = new Parameter($"params {genericTypeArgument}[]", symbolInfo.NameInCamelCase);
         return methodCreator.CreateMethodWithComputedValue(

src/M31.FluentApi.Generator/CodeGeneration/CodeBoardActors/MethodCreation/FluentMethods.cs

@@ -19,7 +19,7 @@ internal FluentMethods(MethodSymbolInfo symbolInfo, FluentMethodAttributeInfo me
     public BuilderMethods CreateBuilderMethods(MethodCreator methodCreator)
     {
         List<Parameter> parameters = SymbolInfo.ParameterInfos
-            .Select(i => new Parameter(i.TypeForCodeGeneration, i.ParameterName)).ToList();
+            .Select(i => new Parameter(i.TypeForCodeGeneration, i.ParameterName, i.DefaultValue)).ToList();
 
         BuilderMethod builderMethod =
             methodCreator.BuilderMethodFactory.CreateBuilderMethod(

src/M31.FluentApi.Generator/CodeGeneration/CodeBoardElements/ParameterSymbolInfo.cs

@@ -4,22 +4,29 @@ namespace M31.FluentApi.Generator.CodeGeneration.CodeBoardElements;
 
 internal class ParameterSymbolInfo
 {
-    internal ParameterSymbolInfo(string parameterName, string typeForCodeGeneration, bool isNullable)
+    internal ParameterSymbolInfo(
+        string parameterName,
+        string typeForCodeGeneration,
+        bool isNullable,
+        string? defaultValue)
     {
         ParameterName = parameterName;
         TypeForCodeGeneration = typeForCodeGeneration;
         IsNullable = isNullable;
+        DefaultValue = defaultValue;
     }
 
     internal string ParameterName { get; }
     internal string TypeForCodeGeneration { get; }
     internal bool IsNullable { get; }
+    internal string? DefaultValue { get; }
 
     protected bool Equals(ParameterSymbolInfo other)
     {
         return ParameterName == other.ParameterName &&
                TypeForCodeGeneration == other.TypeForCodeGeneration &&
-               IsNullable == other.IsNullable;
+               IsNullable == other.IsNullable &&
+               DefaultValue == other.DefaultValue;
     }
 
     public override bool Equals(object? obj)
@@ -32,6 +39,6 @@ public override bool Equals(object? obj)
 
     public override int GetHashCode()
     {
-        return new HashCode().Add(ParameterName, TypeForCodeGeneration, IsNullable);
+        return new HashCode().Add(ParameterName, TypeForCodeGeneration, IsNullable, DefaultValue);
     }
 }

src/M31.FluentApi.Generator/Commons/HashCode.cs

@@ -42,6 +42,19 @@ internal HashCode Add<T1, T2, T3>(T1 value1, T2 value2, T3 value3)
         return this;
     }
 
+    internal HashCode Add<T1, T2, T3, T4>(T1 value1, T2 value2, T3 value3, T4 value4)
+    {
+        unchecked
+        {
+            hash = hash * 23 + value1?.GetHashCode() ?? 0;
+            hash = hash * 23 + value2?.GetHashCode() ?? 0;
+            hash = hash * 23 + value3?.GetHashCode() ?? 0;
+            hash = hash * 23 + value4?.GetHashCode() ?? 0;
+        }
+
+        return this;
+    }
+
     internal HashCode AddSequence<T>(IEnumerable<T> items)
     {
         unchecked

src/M31.FluentApi.Generator/SourceGenerators/SymbolInfoCreator.cs

@@ -87,6 +87,37 @@ private static ParameterSymbolInfo CreateParameterSymbolInfo(IParameterSymbol pa
         return new ParameterSymbolInfo(
             parameterSymbol.Name,
             CodeTypeExtractor.GetTypeForCodeGeneration(parameterSymbol.Type),
-            parameterSymbol.NullableAnnotation == NullableAnnotation.Annotated);
+            parameterSymbol.NullableAnnotation == NullableAnnotation.Annotated,
+            GetDefaultValueAsCode(parameterSymbol));
+    }
+
+    private static string? GetDefaultValueAsCode(IParameterSymbol parameterSymbol)
+    {
+        if (!parameterSymbol.HasExplicitDefaultValue)
+        {
+            return null;
+        }
+
+        if (parameterSymbol.ExplicitDefaultValue == null && parameterSymbol.Type.IsReferenceType)
+        {
+            return "null";
+        }
+
+        if (parameterSymbol.ExplicitDefaultValue == null && parameterSymbol.Type.IsValueType)
+        {
+            return "default";
+        }
+
+        if (parameterSymbol.ExplicitDefaultValue == null &&
+            parameterSymbol.Type is { IsReferenceType: false, IsValueType: false }) // unconstrained type parameter
+        {
+            return "default";
+        }
+
+        return parameterSymbol.ExplicitDefaultValue! switch
+        {
+            string s => $"\"{s}\"",
+            { } o => o.ToString(),
+        };
     }
 }

src/M31.FluentApi.Tests/AnalyzerAndCodeFixes/DiagnosticsDuringGenerationTests.cs

@@ -5,9 +5,6 @@
 using Microsoft.CodeAnalysis;
 using Xunit;
 using static M31.FluentApi.Tests.AnalyzerAndCodeFixes.Helpers.TestSourceCodeReader;
-using Verifier = M31.FluentApi.Tests.AnalyzerAndCodeFixes.Helpers.AnalyzerAndCodeFixVerifier<
-    M31.FluentApi.Generator.SourceAnalyzers.FluentApiAnalyzer,
-    M31.FluentApi.Generator.SourceAnalyzers.FluentApiCodeFixProvider>;
 
 namespace M31.FluentApi.Tests.AnalyzerAndCodeFixes;
 

src/M31.FluentApi.Tests/CodeGeneration/Helpers/TestDataProvider.cs

@@ -16,6 +16,7 @@ internal class TestDataProvider : IEnumerable<object[]>
             new object[] { "Abstract", "DefaultFluentMethodNameClass", "Student" },
             new object[] { "Abstract", "FluentDefaultMemberClass", "Student" },
             new object[] { "Abstract", "FluentMethodClass", "Student" },
+            new object[] { "Abstract", "FluentMethodDefaultValuesClass", "Student" },
             new object[] { "Abstract", "FluentNullableClass", "Student" },
             new object[] { "Abstract", "FluentNullableNoNullableAnnotationClass", "Student" },
             new object[] { "Abstract", "FluentNullableNoNullableAnnotationPrivateSetClass", "Student" },

src/M31.FluentApi.Tests/CodeGeneration/TestClasses/Abstract/FluentMethodDefaultValuesClass/CreateStudent.expected.txt

@@ -0,0 +1,93 @@
+// <auto-generated/>
+// This code was generated by the library M31.FluentAPI.
+// Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
+
+#nullable enable
+
+using System;
+using M31.FluentApi.Attributes;
+
+namespace M31.FluentApi.Tests.CodeGeneration.TestClasses.Abstract.FluentMethodDefaultValuesClass;
+
+public class CreateStudent : CreateStudent.IWithLastName, CreateStudent.IBornOn, CreateStudent.IEnrolledIn, CreateStudent.IInSemester, CreateStudent.IWithNumberOfPassedExams, CreateStudent.IWithNumberOfFailedExams
+{
+    private readonly Student student;
+
+    private CreateStudent()
+    {
+        student = new Student();
+    }
+
+    public static IWithLastName WithFirstName(string firstName = "Alice")
+    {
+        CreateStudent createStudent = new CreateStudent();
+        createStudent.student.WithFirstName(firstName);
+        return createStudent;
+    }
+
+    public IBornOn WithLastName(string? lastName = null)
+    {
+        student.WithLastName(lastName);
+        return this;
+    }
+
+    public IEnrolledIn BornOn(System.DateOnly date = default)
+    {
+        student.BornOn(date);
+        return this;
+    }
+
+    public IInSemester EnrolledIn(System.DateOnly date = default)
+    {
+        student.EnrolledIn(date);
+        return this;
+    }
+
+    public IWithNumberOfPassedExams InSemester(int semester = 3)
+    {
+        student.InSemester(semester);
+        return this;
+    }
+
+    public IWithNumberOfFailedExams WithNumberOfPassedExams(int? numberOfPassedExams = default)
+    {
+        student.WithNumberOfPassedExams(numberOfPassedExams);
+        return this;
+    }
+
+    public Student WithNumberOfFailedExams(int? numberOfFailedExams = default)
+    {
+        student.WithNumberOfFailedExams(numberOfFailedExams);
+        return student;
+    }
+
+    public interface IWithLastName
+    {
+        IBornOn WithLastName(string? lastName = null);
+    }
+
+    public interface IBornOn
+    {
+        IEnrolledIn BornOn(System.DateOnly date = default);
+    }
+
+    public interface IEnrolledIn
+    {
+        IInSemester EnrolledIn(System.DateOnly date = default);
+    }
+
+    public interface IInSemester
+    {
+        IWithNumberOfPassedExams InSemester(int semester = 3);
+    }
+
+    public interface IWithNumberOfPassedExams
+    {
+        IWithNumberOfFailedExams WithNumberOfPassedExams(int? numberOfPassedExams = default);
+    }
+
+    public interface IWithNumberOfFailedExams
+    {
+        Student WithNumberOfFailedExams(int? numberOfFailedExams = default);
+    }
+}