Feature/563 source generator should respect the accessibility of the partial struct that it is assigned to (#581)

* Added the ability to override the accessibility.

* Updated the source generator to respect the accessibility of the type.

* Updated README and version number

Author: mwadams

GitVersion.yml

@@ -20,5 +20,5 @@ branches:
     - feature
     - support
     - hotfix
-next-version: "4.2"
+next-version: "4.3"
 

README.md

@@ -404,6 +404,31 @@ Benchmark suites for various components.
 
 The Source Generator which generates types from Json Schema.
 
+## V4.3.0 Updates
+
+### Type Accessibility using the Source Generator
+
+The source generator now respects the accessibility of the model type.
+
+For example
+
+```csharp
+[JsonSchemaTypeGenerator("../test.json#/$defs/FlimFlam")]
+internal readonly partial struct FlimFlam
+{
+}
+```
+
+Any nested types will be generated with `public` accessibility.
+
+Only `internal` and `public` are supported. The source generator will fail for an unsupported accessiblity declaration.
+
+You can override the default accessibility for all generated types with a build property:
+
+`<CorvusJsonSchemaDefaultAccessibility>Internal</CorvusJsonSchemaDefaultAccessibility>`
+
+Note that you can still generate code that will not compile if you incorrectly mix-and-match `public` and `internal`. It is your responsibility to ensure that your types have compatible accessibility.
+
 ## V4.2.0 Updates
 
 ### Breaking change

Solutions/Corvus.Json.CodeGeneration.CSharp/Corvus.Json.CodeGeneration/CSharp/CSharpLanguageProvider.cs

@@ -245,6 +245,12 @@ public void SetNamesBeforeSubschema(TypeDeclaration typeDeclaration, string fall
                 typeDeclaration.SetDotnetNamespace(ns);
             }
 
+            // Set the accessibility, if it has been explicitly overridden
+            if (typeName.Accessibility is GeneratedTypeAccessibility accessibility)
+            {
+                typeDeclaration.SetDotnetAccessibility(accessibility);
+            }
+
             return;
         }
 
@@ -539,7 +545,8 @@ private IEnumerable<INameHeuristic> GetOrderedNameAfterSubschemaHeuristics()
     /// <param name="reference">The reference to the schema.</param>
     /// <param name="dotnetTypeName">The .NET type name to use.</param>
     /// <param name="dotnetNamespace">The (optional) .NET namespace to use.</param>
-    public readonly struct NamedType(JsonReference reference, string dotnetTypeName, string? dotnetNamespace = null)
+    /// <param name="accessibility">The (optional) accessibility for the type.</param>
+    public readonly struct NamedType(JsonReference reference, string dotnetTypeName, string? dotnetNamespace = null, GeneratedTypeAccessibility? accessibility = null)
     {
         /// <summary>
         /// Gets the reference to schema with an explicit name.
@@ -560,6 +567,25 @@ public readonly struct NamedType(JsonReference reference, string dotnetTypeName,
         /// as a child of its parent.
         /// </remarks>
         internal string? DotnetNamespace { get; } = dotnetNamespace;
+
+        /// <summary>
+        /// Gets the (optional) accessibility to use for the type.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// Providing a value for this property will ensure that the type is generated
+        /// with the given accessibility.
+        /// </para>
+        /// <para>
+        /// Any types for which this is the parent will inherit the accessibility of this
+        /// type. However, care must be taken not to reference/expose types which have
+        /// a more restricted accessibility than the type itself.
+        /// </para>
+        /// <para>You should consider using <see cref="Options.DefaultAccessibility"/>
+        /// to set the accessibility for all generated types rather overriding a specific type.
+        /// </para>
+        /// </remarks>
+        internal GeneratedTypeAccessibility? Accessibility { get; } = accessibility;
     }
 
     /// <summary>
@@ -595,6 +621,7 @@ public readonly struct Namespace(JsonReference baseUri, string dotnetNamespace)
     /// <param name="useImplicitOperatorString">If true, then the string conversion will be implicit.</param>
     /// <param name="lineEndSequence">The line-end sequence. Defaults to <c>\r\n</c>.</param>
     /// <param name="addExplicitUsings">If true, then the generated files will include using statements for the standard implicit usings. You should use this when your project does not use implicit usings.</param>
+    /// <param name="defaultAccessibility">Defines the accessibility of the generated types. Defaults to <see cref="GeneratedTypeAccessibility.Public"/>.</param>
     public class Options(
         string defaultNamespace,
         NamedType[]? namedTypes = null,
@@ -606,7 +633,8 @@ public class Options(
         string fileExtension = ".cs",
         bool useImplicitOperatorString = false,
         string lineEndSequence = "\r\n",
-        bool addExplicitUsings = false)
+        bool addExplicitUsings = false,
+        GeneratedTypeAccessibility defaultAccessibility = GeneratedTypeAccessibility.Public)
     {
         private readonly FrozenDictionary<string, NamedType> namedTypeMap = namedTypes?.ToFrozenDictionary(kvp => kvp.Reference, kvp => kvp) ?? FrozenDictionary<string, NamedType>.Empty;
         private readonly FrozenDictionary<string, string> namespaceMap = namespaces?.ToFrozenDictionary(kvp => kvp.BaseUri, kvp => kvp.DotnetNamespace) ?? FrozenDictionary<string, string>.Empty;
@@ -664,6 +692,11 @@ public class Options(
         /// </remarks>
         internal bool AddExplicitUsings { get; } = addExplicitUsings;
 
+        /// <summary>
+        /// Gets the default accessibility of the generated types.
+        /// </summary>
+        internal GeneratedTypeAccessibility DefaultAccessibility { get; } = defaultAccessibility;
+
         /// <summary>
         /// Gets the namespace for the base URI.
         /// </summary>

Solutions/Corvus.Json.CodeGeneration.CSharp/Corvus.Json.CodeGeneration/CSharp/CodeFileBuilders/ArrayPartial.cs

@@ -52,7 +52,8 @@ public CodeGenerator EmitFile(CodeGenerator generator, TypeDeclaration typeDecla
                     .BeginTypeDeclarationNesting(typeDeclaration)
                         .AppendDocumentation(typeDeclaration)
                         .AppendDotnet80OrGreaterCollectionBuilderAttribute(typeDeclaration)
-                        .BeginPublicReadonlyPartialStructDeclaration(
+                        .BeginReadonlyPartialStructDeclaration(
+                            typeDeclaration.DotnetAccessibility(),
                             typeDeclaration.DotnetTypeName(),
                             interfaces:
                             [

Solutions/Corvus.Json.CodeGeneration.CSharp/Corvus.Json.CodeGeneration/CSharp/CodeFileBuilders/BooleanPartial.cs

@@ -49,7 +49,8 @@ public CodeGenerator EmitFile(CodeGenerator generator, TypeDeclaration typeDecla
                     .AppendLine()
                     .BeginTypeDeclarationNesting(typeDeclaration)
                         .AppendDocumentation(typeDeclaration)
-                        .BeginPublicReadonlyPartialStructDeclaration(
+                        .BeginReadonlyPartialStructDeclaration(
+                            typeDeclaration.DotnetAccessibility(),
                             typeDeclaration.DotnetTypeName(),
                             interfaces:
                                 [

Solutions/Corvus.Json.CodeGeneration.CSharp/Corvus.Json.CodeGeneration/CSharp/CodeFileBuilders/CorePartial.cs

@@ -47,7 +47,8 @@ public CodeGenerator EmitFile(CodeGenerator generator, TypeDeclaration typeDecla
                 .BeginTypeDeclarationNesting(typeDeclaration)
                     .AppendDocumentation(typeDeclaration)
                     .AppendJsonConverterAttribute(typeDeclaration)
-                    .BeginPublicReadonlyPartialStructDeclaration(
+                    .BeginReadonlyPartialStructDeclaration(
+                        typeDeclaration.DotnetAccessibility(),
                         typeDeclaration.DotnetTypeName(),
                         interfaces: [
                             JsonAnyType(typeDeclaration)

Solutions/Corvus.Json.CodeGeneration.CSharp/Corvus.Json.CodeGeneration/CSharp/CodeFileBuilders/NumberPartial.cs

@@ -50,7 +50,8 @@ public CodeGenerator EmitFile(CodeGenerator generator, TypeDeclaration typeDecla
                     .AppendLine()
                     .BeginTypeDeclarationNesting(typeDeclaration)
                         .AppendDocumentation(typeDeclaration)
-                        .BeginPublicReadonlyPartialStructDeclaration(
+                        .BeginReadonlyPartialStructDeclaration(
+                            typeDeclaration.DotnetAccessibility(),
                             typeDeclaration.DotnetTypeName(),
                             interfaces:
                                 [

Solutions/Corvus.Json.CodeGeneration.CSharp/Corvus.Json.CodeGeneration/CSharp/CodeFileBuilders/ObjectPartial.cs

@@ -51,7 +51,8 @@ public CodeGenerator EmitFile(CodeGenerator generator, TypeDeclaration typeDecla
                     .AppendLine()
                     .BeginTypeDeclarationNesting(typeDeclaration)
                         .AppendDocumentation(typeDeclaration)
-                        .BeginPublicReadonlyPartialStructDeclaration(
+                        .BeginReadonlyPartialStructDeclaration(
+                            typeDeclaration.DotnetAccessibility(),
                             typeDeclaration.DotnetTypeName(),
                             interfaces:
                             [

Solutions/Corvus.Json.CodeGeneration.CSharp/Corvus.Json.CodeGeneration/CSharp/CodeFileBuilders/StringPartial.cs

@@ -50,7 +50,8 @@ public CodeGenerator EmitFile(CodeGenerator generator, TypeDeclaration typeDecla
                     .AppendLine()
                     .BeginTypeDeclarationNesting(typeDeclaration)
                         .AppendDocumentation(typeDeclaration)
-                        .BeginPublicReadonlyPartialStructDeclaration(
+                        .BeginReadonlyPartialStructDeclaration(
+                            typeDeclaration.DotnetAccessibility(),
                             typeDeclaration.DotnetTypeName(),
                             interfaces:
                                 [

Solutions/Corvus.Json.CodeGeneration.CSharp/Corvus.Json.CodeGeneration/CSharp/CodeFileBuilders/ValidatePartial.cs

@@ -42,12 +42,14 @@ public CodeGenerator EmitFile(CodeGenerator generator, TypeDeclaration typeDecla
                         new("global::System.Threading.Tasks", addExplicitUsings),
                         "System.Runtime.CompilerServices",
                         "System.Text.Json",
-                        RequiresRegularExressions(typeDeclaration) ? "System.Text.RegularExpressions" : ConditionalCodeSpecification.DoNotEmit,
+                        RequiresRegularExpressions(typeDeclaration) ? "System.Text.RegularExpressions" : ConditionalCodeSpecification.DoNotEmit,
                         new("Corvus.Json", EmitIfNotCorvusJsonExtendedType(typeDeclaration)))
                     .AppendLine()
                     .BeginTypeDeclarationNesting(typeDeclaration)
                         .AppendDocumentation(typeDeclaration)
-                        .BeginPublicReadonlyPartialStructDeclaration(typeDeclaration.DotnetTypeName());
+                        .BeginReadonlyPartialStructDeclaration(
+                            typeDeclaration.DotnetAccessibility(),
+                            typeDeclaration.DotnetTypeName());
 
             // This is a core type
             if (typeDeclaration.IsCorvusJsonExtendedType())
@@ -85,7 +87,7 @@ static FrameworkType EmitIfNotCorvusJsonExtendedType(TypeDeclaration typeDeclara
         }
     }
 
-    private static bool RequiresRegularExressions(TypeDeclaration typeDeclaration)
+    private static bool RequiresRegularExpressions(TypeDeclaration typeDeclaration)
     {
         return typeDeclaration.ValidationRegularExpressions() is IReadOnlyDictionary<IValidationRegexProviderKeyword, IReadOnlyList<string>> regexes && regexes.Count != 0;
     }

Solutions/Corvus.Json.CodeGeneration.CSharp/Corvus.Json.CodeGeneration/CSharp/CodeGeneratorExtensions.cs

@@ -3695,7 +3695,8 @@ public static CodeGenerator BeginTypeDeclarationNesting(
             generator
                 .AppendSeparatorLine()
                 .AppendDocumentation(parent)
-                .BeginPublicReadonlyPartialStructDeclaration(
+                .BeginReadonlyPartialStructDeclaration(
+                    parent.DotnetAccessibility(),
                     parent.DotnetTypeName());
         }
 
@@ -3990,11 +3991,13 @@ public static CodeGenerator GenericTypeOf(
     /// Emits the start of a partial struct declaration.
     /// </summary>
     /// <param name="generator">The generator to which to append the beginning of the struct declaration.</param>
+    /// <param name="accessibility">The accessibility for the generated type.</param>
     /// <param name="dotnetTypeName">The .NET type name for the partial struct.</param>
     /// <param name="interfaces">Interfaces to implement.</param>
     /// <returns>A reference to the generator having completed the operation.</returns>
-    public static CodeGenerator BeginPublicReadonlyPartialStructDeclaration(
+    public static CodeGenerator BeginReadonlyPartialStructDeclaration(
         this CodeGenerator generator,
+        GeneratedTypeAccessibility accessibility,
         string dotnetTypeName,
         ConditionalCodeSpecification[]? interfaces = null)
     {
@@ -4003,9 +4006,16 @@ public static CodeGenerator BeginPublicReadonlyPartialStructDeclaration(
             return generator;
         }
 
+        string accessibilityString = accessibility switch
+        {
+            GeneratedTypeAccessibility.Public => "public",
+            GeneratedTypeAccessibility.Internal => "internal",
+            _ => throw new ArgumentOutOfRangeException(nameof(accessibility)),
+        };
+
         generator.ReserveNameIfNotReserved(dotnetTypeName);
         generator
-            .AppendIndent("public readonly partial struct ")
+            .AppendIndent(accessibilityString, " readonly partial struct ")
             .AppendLine(dotnetTypeName);
 
         if (interfaces is ConditionalCodeSpecification[] conditionalSpecifications)

Solutions/Corvus.Json.CodeGeneration.CSharp/Corvus.Json.CodeGeneration/CSharp/GeneratedTypeAccessibility.cs

@@ -0,0 +1,21 @@
+// <copyright file="GeneratedTypeAccessibility.cs" company="Endjin Limited">
+// Copyright (c) Endjin Limited. All rights reserved.
+// </copyright>
+
+namespace Corvus.Json.CodeGeneration.CSharp;
+
+/// <summary>
+/// Defines the accessibility of the generated types.
+/// </summary>
+public enum GeneratedTypeAccessibility
+{
+    /// <summary>
+    /// The generated types should be <see langword="public"/>.
+    /// </summary>
+    Public,
+
+    /// <summary>
+    /// The generated types should be <see langword="internal"/>.
+    /// </summary>
+    Internal,
+}

Solutions/Corvus.Json.CodeGeneration.CSharp/Corvus.Json.CodeGeneration/CSharp/TypeDeclarationExtensions.cs

@@ -24,6 +24,8 @@ public static class TypeDeclarationExtensions
     private const string PreferredBinaryJsonNumberKindKey = "CSharp_LanguageProvider_PreferredBinaryJsonNumberKind";
     private const string UseImplicitOperatorStringKey = "CSharp_LanguageProvider_UseImplicitOperatorString";
     private const string AddExplicitUsingsKey = "CSharp_LanguageProvider_AddExplicitUsings";
+    private const string DefaultAccessibilityKey = "CSharp_LanguageProvider_DefaultAccessibilityKey";
+    private const string AccessibilityKey = "CSharp_LanguageProvider_AccessibilityKey";
 
     /// <summary>
     /// Sets the relevant metadata from the <see cref="CSharpLanguageProvider.Options"/>.
@@ -36,6 +38,7 @@ public static void SetCSharpOptions(this TypeDeclaration typeDeclaration, CSharp
         typeDeclaration.SetMetadata(OptionalAsNullableKey, options.OptionalAsNullable);
         typeDeclaration.SetMetadata(UseImplicitOperatorStringKey, options.UseImplicitOperatorString);
         typeDeclaration.SetMetadata(AddExplicitUsingsKey, options.AddExplicitUsings);
+        typeDeclaration.SetMetadata(DefaultAccessibilityKey, options.DefaultAccessibility);
     }
 
     /// <summary>
@@ -602,6 +605,49 @@ public static TypeDeclaration SetDotnetNamespace(this TypeDeclaration typeDeclar
         return typeDeclaration;
     }
 
+    /// <summary>
+    /// Sets the .NET accessibility.
+    /// </summary>
+    /// <param name="typeDeclaration">The type declaration.</param>
+    /// <param name="accessibility">The <see cref="GeneratedTypeAccessibility"/>.</param>
+    /// <returns>A reference to the type declaration after the operation has completed.</returns>
+    public static TypeDeclaration SetDotnetAccessibility(this TypeDeclaration typeDeclaration, GeneratedTypeAccessibility accessibility)
+    {
+        typeDeclaration.SetMetadata(AccessibilityKey, accessibility);
+        return typeDeclaration;
+    }
+
+    /// <summary>
+    /// Gets the .NET accessibility.
+    /// </summary>
+    /// <param name="typeDeclaration">The type declaration.</param>
+    /// <returns>
+    /// The <see cref="GeneratedTypeAccessibility"/> for the type. If this has been set explicitly, it will return the accessibility for this type.
+    /// If it has a <c>Parent</c>, it will be <see cref="GeneratedTypeAccessibility.Public"/>. Otherwise, it will fall back to the default accessibility
+    /// for the code generation context (which defaults to <see cref="GeneratedTypeAccessibility.Public"/>).
+    /// </returns>
+    public static GeneratedTypeAccessibility DotnetAccessibility(this TypeDeclaration typeDeclaration)
+    {
+        if (typeDeclaration.TryGetMetadata(AccessibilityKey, out GeneratedTypeAccessibility? typeAccessibility) &&
+            typeAccessibility is GeneratedTypeAccessibility value)
+        {
+            return value;
+        }
+
+        if (typeDeclaration.Parent() is not null)
+        {
+            return GeneratedTypeAccessibility.Public;
+        }
+
+        if (typeDeclaration.TryGetMetadata(DefaultAccessibilityKey, out GeneratedTypeAccessibility? defaultTypeAccessibility) &&
+            defaultTypeAccessibility is GeneratedTypeAccessibility defaultValue)
+        {
+            return defaultValue;
+        }
+
+        return GeneratedTypeAccessibility.Public;
+    }
+
     /// <summary>
     /// Sets the .NET type name.
     /// </summary>

Solutions/Corvus.Json.SourceGenerator/Corvus.Json.SourceGenerator.props

@@ -5,6 +5,7 @@
         <CompilerVisibleProperty Include="CorvusJsonSchemaUseOptionalNameHeuristics" />
         <CompilerVisibleProperty Include="CorvusJsonSchemaAlwaysAssertFormat" />
         <CompilerVisibleProperty Include="CorvusJsonSchemaDisabledNamingHeuristics" />
+        <CompilerVisibleProperty Include="CorvusJsonSchemaDefaultAccessibility" />
     </ItemGroup>
 
     <PropertyGroup>