< Summary

Information
Class: NexusLabs.Needlr.Generators.CodeGen.FactoryCodeGenerator
Assembly: NexusLabs.Needlr.Generators
File(s): /home/runner/work/needlr/needlr/src/NexusLabs.Needlr.Generators/CodeGen/FactoryCodeGenerator.cs
Line coverage
96%
Covered lines: 152
Uncovered lines: 6
Coverable lines: 158
Total lines: 311
Line coverage: 96.2%
Branch coverage
92%
Covered branches: 48
Total branches: 52
Branch coverage: 92.3%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
GetParameterBaseName(...)25%10428.57%
GetParameterIdentifierName(...)100%11100%
GetInjectableNamesByType(...)100%66100%
GenerateFactoryInterface(...)100%66100%
GenerateFactoryImplementation(...)100%1010100%
GenerateFuncRegistration(...)90%101095%
GenerateFactoryInterfacesSource(...)100%44100%
GenerateFactoriesSource(...)100%1212100%

File(s)

/home/runner/work/needlr/needlr/src/NexusLabs.Needlr.Generators/CodeGen/FactoryCodeGenerator.cs

#LineLine coverage
 1// Copyright (c) NexusLabs. All rights reserved.
 2// Licensed under the MIT License.
 3
 4using System;
 5using System.Collections.Generic;
 6using System.Linq;
 7using System.Text;
 8
 9using NexusLabs.Needlr.Generators.Models;
 10
 11namespace NexusLabs.Needlr.Generators.CodeGen;
 12
 13/// <summary>
 14/// Generates factory interfaces and implementations for [GenerateFactory] attributed types.
 15/// </summary>
 16internal static class FactoryCodeGenerator
 17{
 18    private static string GetParameterBaseName(TypeDiscoveryHelper.ConstructorParameterInfo parameter)
 19    {
 46120        if (!string.IsNullOrWhiteSpace(parameter.ParameterName))
 46121            return parameter.ParameterName!;
 22
 023        var typeName = GeneratorHelpers.GetShortTypeName(parameter.TypeName);
 024        var genericStart = typeName.IndexOf('<');
 025        if (genericStart >= 0)
 026            typeName = typeName.Substring(0, genericStart);
 27
 028        return GeneratorHelpers.ToCamelCase(typeName);
 29    }
 30
 31    private static string GetParameterIdentifierName(TypeDiscoveryHelper.ConstructorParameterInfo parameter)
 32    {
 40833        return GeneratorHelpers.EscapeIdentifier(GetParameterBaseName(parameter));
 34    }
 35
 36    private static Dictionary<string, string> GetInjectableNamesByType(
 37        IEnumerable<TypeDiscoveryHelper.ConstructorParameterInfo> parameters)
 38    {
 4339        var namesByType = new Dictionary<string, string>(StringComparer.Ordinal);
 4340        var usedNames = new HashSet<string>(StringComparer.Ordinal);
 41
 16442        foreach (var parameter in parameters)
 43        {
 3944            if (namesByType.ContainsKey(parameter.TypeName))
 45                continue;
 46
 3947            var baseName = GetParameterBaseName(parameter);
 3948            var uniqueName = baseName;
 8249            for (var suffix = 2; !usedNames.Add(uniqueName); suffix++)
 250                uniqueName = baseName + suffix;
 51
 3952            namesByType.Add(parameter.TypeName, uniqueName);
 53        }
 54
 4355        return namesByType;
 56    }
 57
 58    internal static void GenerateFactoryInterface(StringBuilder builder, DiscoveredFactory factory, BreadcrumbWriter bre
 59    {
 8660        var factoryName = $"I{factory.SimpleTypeName}Factory";
 61
 8662        builder.AppendLine("/// <summary>");
 8663        builder.AppendLine($"/// Factory interface for creating instances of <see cref=\"{factory.TypeName}\"/>.");
 8664        builder.AppendLine("/// </summary>");
 8665        builder.AppendLine("[global::System.CodeDom.Compiler.GeneratedCodeAttribute(\"NexusLabs.Needlr.Generators\", \"1
 8666        builder.AppendLine($"public interface {factoryName}");
 8667        builder.AppendLine("{");
 68
 69        // Generate Create method for each constructor
 36470        foreach (var ctor in factory.Constructors)
 71        {
 9672            var runtimeParamList = string.Join(", ", ctor.RuntimeParameters.Select(p =>
 20473                $"{p.TypeName} {GetParameterIdentifierName(p)}"));
 74
 9675            builder.AppendLine($"    /// <summary>Creates a new instance of {factory.SimpleTypeName}.</summary>");
 76
 77            // Add <param> tags for documented runtime parameters
 40878            foreach (var param in ctor.RuntimeParameters)
 79            {
 10880                if (!string.IsNullOrWhiteSpace(param.DocumentationComment))
 81                {
 1482                    var paramName = GetParameterBaseName(param);
 1483                    var escapedDoc = GeneratorHelpers.EscapeXmlContent(param.DocumentationComment!);
 1484                    builder.AppendLine($"    /// <param name=\"{paramName}\">{escapedDoc}</param>");
 85                }
 86            }
 87
 9688            builder.AppendLine($"    {factory.ReturnTypeName} Create({runtimeParamList});");
 89        }
 90
 8691        builder.AppendLine("}");
 8692    }
 93
 94    internal static void GenerateFactoryImplementation(StringBuilder builder, DiscoveredFactory factory, BreadcrumbWrite
 95    {
 4396        var factoryInterfaceName = $"I{factory.SimpleTypeName}Factory";
 4397        var factoryImplName = $"{factory.SimpleTypeName}Factory";
 98
 4399        var allInjectableParams = factory.Constructors
 48100            .SelectMany(c => c.InjectableParameters)
 44101            .GroupBy(p => p.TypeName)
 39102            .Select(g => g.First())
 43103            .ToList();
 43104        var injectableNamesByType = GetInjectableNamesByType(allInjectableParams);
 105
 43106        builder.AppendLine("/// <summary>");
 43107        builder.AppendLine($"/// Factory implementation for creating instances of <see cref=\"{factory.TypeName}\"/>.");
 43108        builder.AppendLine("/// </summary>");
 43109        builder.AppendLine("[global::System.CodeDom.Compiler.GeneratedCodeAttribute(\"NexusLabs.Needlr.Generators\", \"1
 43110        builder.AppendLine($"internal sealed class {factoryImplName} : {factoryInterfaceName}");
 43111        builder.AppendLine("{");
 112
 113        // Fields for injectable dependencies
 164114        foreach (var param in allInjectableParams)
 115        {
 39116            var fieldName = "_" + injectableNamesByType[param.TypeName];
 39117            builder.AppendLine($"    private readonly {param.TypeName} {fieldName};");
 118        }
 119
 43120        builder.AppendLine();
 121
 122        // Constructor
 43123        var ctorParams = string.Join(
 43124            ", ",
 43125            allInjectableParams.Select(p =>
 82126                $"{p.TypeName} {GeneratorHelpers.EscapeIdentifier(injectableNamesByType[p.TypeName])}"));
 43127        builder.AppendLine($"    public {factoryImplName}({ctorParams})");
 43128        builder.AppendLine("    {");
 164129        foreach (var param in allInjectableParams)
 130        {
 39131            var parameterName = injectableNamesByType[param.TypeName];
 39132            var fieldName = "_" + parameterName;
 39133            var paramName = GeneratorHelpers.EscapeIdentifier(parameterName);
 39134            builder.AppendLine($"        {fieldName} = {paramName};");
 135        }
 43136        builder.AppendLine("    }");
 43137        builder.AppendLine();
 138
 139        // Create methods for each constructor
 182140        foreach (var ctor in factory.Constructors)
 141        {
 48142            var runtimeParamList = string.Join(", ", ctor.RuntimeParameters.Select(p =>
 102143                $"{p.TypeName} {GetParameterIdentifierName(p)}"));
 144
 48145            builder.AppendLine($"    public {factory.ReturnTypeName} Create({runtimeParamList})");
 48146            builder.AppendLine("    {");
 48147            builder.Append($"        return new {factory.TypeName}(");
 148
 149            // Build constructor arguments as named arguments (paramName: value) rather
 150            // than positionally. A generated constructor's parameter order follows field
 151            // declaration order and need not match this injectable-then-runtime grouping,
 152            // so binding by name is required for correctness regardless of which order
 153            // the target constructor was declared or generated in.
 48154            var allArgs = new List<string>();
 184155            foreach (var inj in ctor.InjectableParameters)
 156            {
 44157                var fieldName = "_" + injectableNamesByType[inj.TypeName];
 44158                var argName = GetParameterIdentifierName(inj);
 44159                allArgs.Add($"{argName}: {fieldName}");
 160            }
 204161            foreach (var rt in ctor.RuntimeParameters)
 162            {
 54163                var paramName = GetParameterIdentifierName(rt);
 54164                allArgs.Add($"{paramName}: {paramName}");
 165            }
 166
 48167            builder.Append(string.Join(", ", allArgs));
 48168            builder.AppendLine(");");
 48169            builder.AppendLine("    }");
 170        }
 171
 43172        builder.AppendLine("}");
 43173    }
 174
 175    internal static void GenerateFuncRegistration(StringBuilder builder, DiscoveredFactory factory, FactoryDiscoveryHelp
 176    {
 177        // Build Func<TRuntime..., TReturn> type - uses ReturnTypeName (interface if generic attribute used)
 98178        var runtimeTypes = string.Join(", ", ctor.RuntimeParameters.Select(p => p.TypeName));
 46179        var funcType = $"Func<{runtimeTypes}, {factory.ReturnTypeName}>";
 180
 181        // Build the lambda
 46182        var runtimeParams = string.Join(", ", ctor.RuntimeParameters.Select(GetParameterIdentifierName));
 183
 46184        builder.AppendLine($"{indent}services.AddSingleton<{funcType}>(sp =>");
 46185        builder.AppendLine($"{indent}    ({runtimeParams}) => new {factory.TypeName}(");
 186
 187        // Build constructor call arguments as named arguments — see the matching
 188        // comment in GenerateFactoryImplementation for why positional binding is unsafe
 189        // here.
 46190        var allArgs = new List<string>();
 180191        foreach (var inj in ctor.InjectableParameters)
 192        {
 44193            var argName = GetParameterIdentifierName(inj);
 44194            if (inj.IsKeyed)
 195            {
 0196                allArgs.Add($"{argName}: sp.GetRequiredKeyedService<{inj.TypeName}>(\"{GeneratorHelpers.EscapeStringLite
 197            }
 198            else
 199            {
 44200                allArgs.Add($"{argName}: sp.GetRequiredService<{inj.TypeName}>()");
 201            }
 202        }
 196203        foreach (var rt in ctor.RuntimeParameters)
 204        {
 52205            var paramName = GetParameterIdentifierName(rt);
 52206            allArgs.Add($"{paramName}: {paramName}");
 207        }
 208
 284209        for (int i = 0; i < allArgs.Count; i++)
 210        {
 96211            var arg = allArgs[i];
 96212            var isLast = i == allArgs.Count - 1;
 96213            builder.AppendLine($"{indent}        {arg}{(isLast ? ")" : ",")}");
 214        }
 46215        builder.AppendLine($"{indent});");
 46216    }
 217
 218    /// <summary>
 219    /// Generates the interface declarations shared by semantic discovery and final output.
 220    /// </summary>
 221    internal static string GenerateFactoryInterfacesSource(IReadOnlyList<DiscoveredFactory> factories, string assemblyNa
 222    {
 88223        var builder = new StringBuilder();
 88224        builder.AppendLine($"namespace {GeneratorHelpers.SanitizeIdentifier(assemblyName)}.Generated;");
 88225        builder.AppendLine();
 226
 352227        foreach (var factory in factories)
 228        {
 88229            if (factory.GenerateInterface)
 230            {
 86231                GenerateFactoryInterface(builder, factory, breadcrumbs, projectDirectory);
 86232                builder.AppendLine();
 233            }
 234        }
 235
 88236        return builder.ToString();
 237    }
 238
 239    /// <summary>
 240    /// Generates factory interfaces, implementations, and the registration helper.
 241    /// </summary>
 242    internal static string GenerateFactoriesSource(IReadOnlyList<DiscoveredFactory> factories, string assemblyName, Brea
 243    {
 45244        var builder = new StringBuilder();
 45245        var safeAssemblyName = GeneratorHelpers.SanitizeIdentifier(assemblyName);
 246
 45247        breadcrumbs.WriteFileHeader(builder, assemblyName, "Needlr Generated Factories");
 45248        builder.AppendLine("#nullable enable");
 45249        builder.AppendLine();
 45250        builder.AppendLine("using System;");
 45251        builder.AppendLine();
 45252        builder.AppendLine("using Microsoft.Extensions.DependencyInjection;");
 45253        builder.AppendLine();
 45254        builder.Append(GenerateFactoryInterfacesSource(factories, assemblyName, breadcrumbs, projectDirectory));
 255
 180256        foreach (var factory in factories)
 257        {
 45258            if (factory.GenerateInterface)
 259            {
 43260                GenerateFactoryImplementation(builder, factory, breadcrumbs, projectDirectory);
 43261                builder.AppendLine();
 262            }
 263        }
 264
 265        // Generate the registration helper
 45266        builder.AppendLine("/// <summary>");
 45267        builder.AppendLine("/// Helper class for registering factory types.");
 45268        builder.AppendLine("/// </summary>");
 45269        builder.AppendLine("[global::System.CodeDom.Compiler.GeneratedCodeAttribute(\"NexusLabs.Needlr.Generators\", \"1
 45270        builder.AppendLine("public static class FactoryRegistrations");
 45271        builder.AppendLine("{");
 45272        builder.AppendLine("    /// <summary>");
 45273        builder.AppendLine("    /// Registers all generated factories.");
 45274        builder.AppendLine("    /// </summary>");
 45275        builder.AppendLine("    /// <param name=\"services\">The service collection to register to.</param>");
 45276        builder.AppendLine("    public static void RegisterFactories(IServiceCollection services)");
 45277        builder.AppendLine("    {");
 278
 180279        foreach (var factory in factories)
 280        {
 45281            breadcrumbs.WriteInlineComment(builder, "        ", $"Factory for {factory.SimpleTypeName}");
 282
 283            // Register Func<> for each constructor
 45284            if (factory.GenerateFunc)
 285            {
 174286                foreach (var ctor in factory.Constructors)
 287                {
 46288                    GenerateFuncRegistration(builder, factory, ctor, "        ");
 289                }
 290            }
 291
 292            // Register interface factory
 45293            if (factory.GenerateInterface)
 294            {
 43295                var factoryInterfaceName = $"I{factory.SimpleTypeName}Factory";
 43296                var factoryImplName = $"{factory.SimpleTypeName}Factory";
 43297                builder.AppendLine($"        services.AddSingleton<global::{safeAssemblyName}.Generated.{factoryInterfac
 298            }
 299        }
 300
 45301        builder.AppendLine("    }");
 45302        builder.AppendLine();
 45303        builder.AppendLine("    /// <summary>");
 45304        builder.AppendLine("    /// Gets the number of factory types generated at compile time.");
 45305        builder.AppendLine("    /// </summary>");
 45306        builder.AppendLine($"    public static int Count => {GeneratorHelpers.Literal(factories.Count)};");
 45307        builder.AppendLine("}");
 308
 45309        return builder.ToString();
 310    }
 311}