Add support for nested IDs

Author: andrewlock

README.md

@@ -44,7 +44,7 @@ Version 0.x of this library used the helper library [CodeGeneration.Roslyn](http
 
 ### Bug Fixes
 
-* Some converters had incorrect implementations, such as in ([#26](https://github.com/andrewlock/StronglyTypedId/issues/24)). These have been addressed in version 1.x.
+* Some converters had incorrect implementations, such as in ([#24](https://github.com/andrewlock/StronglyTypedId/issues/24)). These have been addressed in version 1.x.
 * Better null handling has been added for the `String` backing type, handling issues such as [#32](https://github.com/andrewlock/StronglyTypedId/issues/32).
 * The code is marked as auto generated, to avoid errors such as #CS1591 as described in [#27](https://github.com/andrewlock/StronglyTypedId/issues/27)
 * An error deserializing nullable StronglyTypedIds with Newtonsoft.Json [#36](https://github.com/andrewlock/StronglyTypedId/issues/36)
@@ -179,7 +179,7 @@ The StronglyTypedId NuGet package is a .NET Standard 2.0 package.
 
 You must be using the .NET 6+ SDK (though you can compile for other target frameworks like .NET Core 2.1 and .NET Framework 4.8)
 
-The `struct`s you decorate with the `StronglyTypedId` attribute must be marked `partial`, and cannot be nested inside another class.
+The `struct`s you decorate with the `StronglyTypedId` attribute must be marked `partial`.
 
 ## Credits
 [Credits]: #credits

build/Build.cs

@@ -119,6 +119,12 @@ class Build : NukeBuild
                 TestsDirectory / "StronglyTypedIds.Nuget.Attributes.IntegrationTests",
             };
 
+            if (!string.IsNullOrEmpty(PackagesDirectory))
+            {
+                DeleteDirectory(PackagesDirectory / "stronglytypedid");
+                DeleteDirectory(PackagesDirectory / "stronglytypedid.attributes");
+            }
+
             DotNetRestore(s => s
                 .When(!string.IsNullOrEmpty(PackagesDirectory), x => x.SetPackageDirectory(PackagesDirectory))
                 .SetConfigFile(RootDirectory / "NuGet.integration-tests.config")

src/StronglyTypedIds/Diagnostics/NestedTypeDiagnostic.cs

@@ -0,0 +1,17 @@
+namespace StronglyTypedIds;
+
+internal class ParentClass
+{
+    public ParentClass(string keyword, string name, string constraints, ParentClass? child)
+    {
+        Keyword = keyword;
+        Name = name;
+        Constraints = constraints;
+        Child = child;
+    }
+
+    public ParentClass? Child { get; }
+    public string Keyword { get; }
+    public string Name { get; }
+    public string Constraints { get; }
+}

src/StronglyTypedIds/ParentClass.cs

@@ -84,13 +84,13 @@ public static bool IsAttributeTargetForGeneration(SyntaxNode node)
         return null;
     }
 
-    public static List<(string Name, string NameSpace, StronglyTypedIdConfiguration Config)> GetTypesToGenerate(
+    public static List<(string Name, string NameSpace, StronglyTypedIdConfiguration Config, ParentClass? Parent)> GetTypesToGenerate(
         Compilation compilation,
         ImmutableArray<StructDeclarationSyntax> targets,
         Action<Diagnostic> reportDiagnostic,
         CancellationToken ct)
     {
-        var idsToGenerate = new List<(string Name, string NameSpace, StronglyTypedIdConfiguration Config)>();
+        var idsToGenerate = new List<(string Name, string NameSpace, StronglyTypedIdConfiguration Config, ParentClass? Parent)>();
         INamedTypeSymbol? idAttribute = compilation.GetTypeByMetadataName(StronglyTypedIdAttribute);
         if (idAttribute == null)
         {
@@ -226,15 +226,11 @@ public static bool IsAttributeTargetForGeneration(SyntaxNode node)
                 reportDiagnostic(NotPartialDiagnostic.Create(structDeclarationSyntax));
             }
 
-            if (structSymbol.ContainingType is not null)
-            {
-                reportDiagnostic(NestedTypeDiagnostic.Create(structDeclarationSyntax));
-            }
-
-            string nameSpace = structSymbol.ContainingNamespace.IsGlobalNamespace ? string.Empty : structSymbol.ContainingNamespace.ToString();
+            string nameSpace = GetNameSpace(structDeclarationSyntax);
+            var parentClass = GetParentClasses(structDeclarationSyntax);
             var name = structSymbol.Name;
 
-            idsToGenerate.Add((Name: name, NameSpace: nameSpace, Config: config.Value));
+            idsToGenerate.Add((Name: name, NameSpace: nameSpace, Config: config.Value, Parent: parentClass));
         }
 
         return idsToGenerate;
@@ -370,4 +366,58 @@ public static bool IsAttributeTargetForGeneration(SyntaxNode node)
 
         return null;
     }
+
+    private static string GetNameSpace(StructDeclarationSyntax structSymbol)
+    {
+        // determine the namespace the struct is declared in, if any
+        SyntaxNode? potentialNamespaceParent = structSymbol.Parent;
+        while (potentialNamespaceParent != null &&
+               potentialNamespaceParent is not NamespaceDeclarationSyntax
+               && potentialNamespaceParent is not FileScopedNamespaceDeclarationSyntax)
+        {
+            potentialNamespaceParent = potentialNamespaceParent.Parent;
+        }
+
+        if (potentialNamespaceParent is BaseNamespaceDeclarationSyntax namespaceParent)
+        {
+            string nameSpace = namespaceParent.Name.ToString();
+            while (true)
+            {
+                if(namespaceParent.Parent is not NamespaceDeclarationSyntax namespaceParentParent)
+                {
+                    break;
+                }
+
+                namespaceParent = namespaceParentParent;
+                nameSpace = $"{namespaceParent.Name}.{nameSpace}";
+            }
+
+            return nameSpace;
+        }
+        return string.Empty;
+    }
+
+    private static ParentClass? GetParentClasses(StructDeclarationSyntax structSymbol)
+    {
+        TypeDeclarationSyntax? parentIdClass = structSymbol.Parent as TypeDeclarationSyntax;
+        ParentClass? parentClass = null;
+
+        while (parentIdClass != null && IsAllowedKind(parentIdClass.Kind()))
+        {
+            parentClass = new ParentClass(
+                keyword: parentIdClass.Keyword.ValueText,
+                name: parentIdClass.Identifier.ToString() + parentIdClass.TypeParameterList,
+                constraints: parentIdClass.ConstraintClauses.ToString(),
+                child: parentClass);
+
+            parentIdClass = (parentIdClass.Parent as TypeDeclarationSyntax);
+        }
+
+        return parentClass;
+
+        static bool IsAllowedKind(SyntaxKind kind) =>
+            kind == SyntaxKind.ClassDeclaration ||
+            kind == SyntaxKind.StructDeclaration ||
+            kind == SyntaxKind.RecordDeclaration;
+    }
 }

src/StronglyTypedIds/Parser.cs

@@ -10,14 +10,16 @@ internal static class SourceGenerationHelper
         public static string CreateId(
             string idNamespace,
             string idName,
+            ParentClass? parentClass,
             StronglyTypedIdConverter converters,
             StronglyTypedIdBackingType backingType,
             StronglyTypedIdImplementations implementations)
-            => CreateId(idNamespace, idName, converters, backingType, implementations, null);
+            => CreateId(idNamespace, idName, parentClass, converters, backingType, implementations, null);
 
         public static string CreateId(
             string idNamespace,
             string idName,
+            ParentClass? parentClass,
             StronglyTypedIdConverter converters,
             StronglyTypedIdBackingType backingType,
             StronglyTypedIdImplementations implementations,
@@ -33,12 +35,13 @@ public static string CreateId(
                 _ => throw new ArgumentException("Unknown backing type: " + backingType, nameof(backingType)),
             };
 
-            return CreateId(idNamespace, idName, converters, implementations, resources, sb);
+            return CreateId(idNamespace, idName, parentClass, converters, implementations, resources, sb);
         }
 
         static string CreateId(
             string idNamespace,
             string idName,
+            ParentClass? parentClass,
             StronglyTypedIdConverter converters,
             StronglyTypedIdImplementations implementations,
             EmbeddedSources.ResourceCollection resources,
@@ -70,6 +73,8 @@ static string CreateId(
             var useIEquatable = implementations.IsSet(StronglyTypedIdImplementations.IEquatable);
             var useIComparable = implementations.IsSet(StronglyTypedIdImplementations.IComparable);
 
+            var parentsCount = 0;
+
             sb ??= new StringBuilder();
             sb.Append(resources.Header);
 
@@ -87,6 +92,21 @@ static string CreateId(
 {");
             }
 
+            while (parentClass is not null)
+            {
+                sb
+                    .Append("    partial ")
+                    .Append(parentClass.Keyword)
+                    .Append(' ')
+                    .Append(parentClass.Name)
+                    .Append(' ')
+                    .Append(parentClass.Constraints)
+                    .AppendLine(@"
+    {");
+                parentsCount++;
+                parentClass = parentClass.Child;
+            }
+
             if (useNewtonsoftJson)
             {
                 sb.AppendLine(EmbeddedSources.NewtonsoftJsonAttributeSource);
@@ -139,6 +159,12 @@ static string CreateId(
 
             sb.Replace("TESTID", idName);
             sb.AppendLine(@"    }");
+
+            for (int i = 0; i < parentsCount; i++)
+            {
+                sb.AppendLine(@"    }");
+            }
+
             if (hasNamespace)
             {
                 sb.Append('}').AppendLine();

src/StronglyTypedIds/SourceGenerationHelper.cs

@@ -58,7 +58,7 @@ static void Execute(
                 return;
             }
 
-            List<(string Name, string NameSpace, StronglyTypedIdConfiguration Config)> idsToGenerate =
+            List<(string Name, string NameSpace, StronglyTypedIdConfiguration Config, ParentClass? Parent)> idsToGenerate =
                 Parser.GetTypesToGenerate(compilation, structs, context.ReportDiagnostic, context.CancellationToken);
 
             if (idsToGenerate.Count > 0)
@@ -72,6 +72,7 @@ static void Execute(
                     var result = SourceGenerationHelper.CreateId(
                         idToGenerate.NameSpace,
                         idToGenerate.Name,
+                        idToGenerate.Parent,
                         values.Converters,
                         values.BackingType,
                         values.Implementations,

src/StronglyTypedIds/StronglyTypedIdGenerator.cs

@@ -0,0 +1,13 @@
+using StronglyTypedIds.IntegrationTests.Types;
+using Xunit;
+
+namespace StronglyTypedIds.IntegrationTests;
+
+public class NestedIdTests
+{
+    [Fact]
+    public void CanCreateNestedId()
+    {
+        var id = SomeType<object>.NestedType<string, int>.MoreNesting.VeryNestedId.New();
+    }
+}

test/StronglyTypedIds.IntegrationTests/NestedIdTests.cs

@@ -26,4 +26,16 @@ public partial struct BothJsonDefaultId { }
 
     [StronglyTypedId(converters: StronglyTypedIdConverter.EfCoreValueConverter)]
     public partial struct EfCoreDefaultId { }
+
+    public partial class SomeType<T> where T : new()
+    {
+        public partial record NestedType<TKey, TValue>
+        {
+            public partial struct MoreNesting
+            {
+                [StronglyTypedId]
+                public partial struct VeryNestedId {}
+            }
+        }
+    }
 }