Use full path

Author: inputfalken

src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs

@@ -27,7 +27,7 @@ MarshallerOptions options
                 : $"{x.DDB.DataMember.NameAsPrivateField} = new ({ValueProvider});")
             .Append($"{self} = new({ValueProvider});")
             .Append($"{MarshallerOptions.FieldReference} = {MarshallerOptions.ParamReference};");
-        foreach (var fieldAssignment in $"public {structName}(Func<string> {ValueProvider}, {MarshallerOptions.Name} options)".CreateScope(constructorFieldAssignments))
+        foreach (var fieldAssignment in $"public {structName}(Func<string> {ValueProvider}, {options.FullName} options)".CreateScope(constructorFieldAssignments))
             yield return fieldAssignment;
 
         yield return MarshallerOptions.FieldDeclaration;

src/DynamoDBGenerator.SourceGenerator/Generations/Marshalling/Keys.cs

@@ -152,7 +152,7 @@ private static CodeFactory StaticAttributeValueDictionaryKeys(ITypeSymbol typeSy
             Func<ITypeSymbol, DynamoDbDataMember[]> fn, MarshallerOptions options)
         {
             var code =
-                $"public static Dictionary<string, AttributeValue> {MethodName(typeSymbol)}({MarshallerOptions.Name} {MarshallerOptions.ParamReference}, object? {PkReference}, object? {RkReference}, bool {EnforcePkReference}, bool {EnforceRkReference}, string? index = null)"
+                $"public static Dictionary<string, AttributeValue> {MethodName(typeSymbol)}({options.FullName} {MarshallerOptions.ParamReference}, object? {PkReference}, object? {RkReference}, bool {EnforcePkReference}, bool {EnforceRkReference}, string? index = null)"
                     .CreateScope(MethodBody(typeSymbol, fn, options));
 
             return new CodeFactory(code);

src/DynamoDBGenerator.SourceGenerator/Generations/Marshalling/Marshaller.cs

@@ -51,7 +51,7 @@ private static CodeFactory CreateDictionaryMethod(ITypeSymbol typeSymbol, Func<I
                 .Append($"return {DictionaryReference};"));
 
         var code =
-            $"public static Dictionary<string, AttributeValue>{(isNullable ? '?' : null)} {GetSerializationMethodName(typeSymbol)}({typeSymbol.Representation().annotated} {ParamReference}, {MarshallerOptions.Name} {MarshallerOptions.ParamReference}, string? {DataMember} = null)"
+            $"public static Dictionary<string, AttributeValue>{(isNullable ? '?' : null)} {GetSerializationMethodName(typeSymbol)}({typeSymbol.Representation().annotated} {ParamReference}, {options.FullName} {MarshallerOptions.ParamReference}, string? {DataMember} = null)"
                 .CreateScope(body);
 
         return new CodeFactory(code, properties.Select(y => y.Type));
@@ -81,19 +81,19 @@ private static CodeFactory CreateMethod(ITypeSymbol type, Func<ITypeSymbol, Dyna
             {
                 { IsValueType: true } => type switch
                 {
-                    { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T } => CreateSignature(type)
+                    { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T } => CreateSignature(type, options)
                         .CreateScope($"return {ParamReference} is not null ? {conversion} : null;")
                         .ToConversion(),
-                    _ => CreateSignature(type)
+                    _ => CreateSignature(type, options)
                         .CreateScope($"return {conversion};")
                         .ToConversion()
                 },
                 { IsReferenceType: true } => type switch
                 {
-                    { NullableAnnotation: NullableAnnotation.None or NullableAnnotation.Annotated } => CreateSignature(type)
+                    { NullableAnnotation: NullableAnnotation.None or NullableAnnotation.Annotated } => CreateSignature(type, options)
                         .CreateScope($"return {ParamReference} is not null ? {conversion} : null;")
                         .ToConversion(),
-                    _ => CreateSignature(type)
+                    _ => CreateSignature(type, options)
                         .CreateScope($"return {ParamReference} is not null ? {conversion} : throw {ExceptionHelper.NullExceptionMethod}({DataMember});")
                         .ToConversion()
                 },
@@ -103,7 +103,7 @@ private static CodeFactory CreateMethod(ITypeSymbol type, Func<ITypeSymbol, Dyna
 
         return type.TypeIdentifier() switch
         {
-            SingleGeneric singleGeneric when CreateSignature(singleGeneric.TypeSymbol) is var signature => singleGeneric.Type switch
+            SingleGeneric singleGeneric when CreateSignature(singleGeneric.TypeSymbol, options) is var signature => singleGeneric.Type switch
             {
                 SingleGeneric.SupportedType.Nullable => signature
                     .CreateScope($"return {ParamReference} is not null ? {InvokeMarshallerMethod(singleGeneric.T, $"{ParamReference}.Value", DataMember, options)} : null;")
@@ -133,7 +133,7 @@ SingleGeneric.SupportedType.Set when singleGeneric.T.IsNumeric()
             },
             KeyValueGeneric {TKey.SpecialType: not SpecialType.System_String} keyValueGeneric => throw new ArgumentException("Only strings are supported for for TKey",
                 UncoveredConversionException(keyValueGeneric, nameof(CreateMethod))),
-            KeyValueGeneric keyValueGeneric when CreateSignature(keyValueGeneric.TypeSymbol) is var signature => keyValueGeneric.Type switch
+            KeyValueGeneric keyValueGeneric when CreateSignature(keyValueGeneric.TypeSymbol, options) is var signature => keyValueGeneric.Type switch
             {
                 KeyValueGeneric.SupportedType.Dictionary => signature
                     .CreateScope($"return {ParamReference} is not null ? {AttributeValueUtilityFactory.FromDictionary}({ParamReference}, {MarshallerOptions.ParamReference}, {DataMember}, static (a, o, d) => {InvokeMarshallerMethod(keyValueGeneric.TValue, "a", "d", options, "o")}{(keyValueGeneric.TValue.IsNullable() ? $" ?? {AttributeValueUtilityFactory.Null}" : null)}) : {Else(keyValueGeneric)};")
@@ -149,11 +149,11 @@ SingleGeneric.SupportedType.Set when singleGeneric.T.IsNumeric()
         };
 
     }
-    private static string CreateSignature(ITypeSymbol typeSymbol)
+    private static string CreateSignature(ITypeSymbol typeSymbol, MarshallerOptions options)
     {
         return typeSymbol.IsNullable()
-            ? $"public static AttributeValue? {GetSerializationMethodName(typeSymbol)}({typeSymbol.Representation().annotated} {ParamReference}, {MarshallerOptions.Name} {MarshallerOptions.ParamReference}, string? {DataMember} = null)"
-            : $"public static AttributeValue {GetSerializationMethodName(typeSymbol)}({typeSymbol.Representation().annotated} {ParamReference}, {MarshallerOptions.Name} {MarshallerOptions.ParamReference}, string? {DataMember} = null)";
+            ? $"public static AttributeValue? {GetSerializationMethodName(typeSymbol)}({typeSymbol.Representation().annotated} {ParamReference}, {options.FullName} {MarshallerOptions.ParamReference}, string? {DataMember} = null)"
+            : $"public static AttributeValue {GetSerializationMethodName(typeSymbol)}({typeSymbol.Representation().annotated} {ParamReference}, {options.FullName} {MarshallerOptions.ParamReference}, string? {DataMember} = null)";
     }
 
     private static string Else(TypeIdentifier typeIdentifier)

src/DynamoDBGenerator.SourceGenerator/Generations/UnMarshaller.cs

@@ -1,5 +1,3 @@
-using System.Collections;
-using System.Collections.Immutable;
 using DynamoDBGenerator.SourceGenerator.Extensions;
 using DynamoDBGenerator.SourceGenerator.Types;
 using Microsoft.CodeAnalysis;
@@ -13,7 +11,7 @@ public static class UnMarshaller
     private const string DataMember = "dataMember";
     private const string Dict = "dict";
     private static readonly Func<ITypeSymbol, string> GetDeserializationMethodName = TypeExtensions.SuffixedTypeSymbolNameFactory("_U", SymbolEqualityComparer.IncludeNullability);
-    private const string UnMarshallerClass = $"_{Constants.DynamoDBGenerator.Marshaller.UnmarshalMethodName}_";
+    private const string UnMarshallerClass = $"_{Marshaller.UnmarshalMethodName}_";
     private const string Value = "attributeValue";
     private static IEnumerable<(bool useParentheses, IEnumerable<string> assignments)> Assignments(ITypeSymbol type, (DynamoDbDataMember DDB, string MethodCall, string Name)[] assignments)
     {
@@ -66,7 +64,7 @@ private static CodeFactory CreateCode(ITypeSymbol type, Func<ITypeSymbol, Dynamo
                         .Prepend(type.IsTupleType ? "return" : $"return new {typeName.annotated.TrimEnd('?')}")
                 );
 
-        var method = $"public static {typeName.annotated} {GetDeserializationMethodName(type)}(Dictionary<string, AttributeValue>? {Dict}, {MarshallerOptions.Name} {MarshallerOptions.ParamReference}, string? {DataMember} = null)".CreateScope(blockBody);
+        var method = $"public static {typeName.annotated} {GetDeserializationMethodName(type)}(Dictionary<string, AttributeValue>? {Dict}, {options.FullName} {MarshallerOptions.ParamReference}, string? {DataMember} = null)".CreateScope(blockBody);
 
         return new CodeFactory(method, assignments.Select(x => x.DDB.DataMember.Type));
 
@@ -78,18 +76,18 @@ private static CodeFactory CreateMethod(ITypeSymbol type, Func<ITypeSymbol, Dyna
         if (options.TryReadConversion(type, Value) is {} conversion)
         {
             if (type.IsNullable())
-                return CreateSignature(type)
+                return CreateSignature(type, options)
                     .CreateScope($"return {Value} is not null ? ({conversion}) : null;")
                     .ToConversion();
 
-            return CreateSignature(type)
+            return CreateSignature(type, options)
                 .CreateScope($"return {Value} is not null && ({conversion}) is {{ }} x ? x : throw {ExceptionHelper.NullExceptionMethod}({DataMember});")
                 .ToConversion();
         }
 
         return type.TypeIdentifier() switch
         {
-            SingleGeneric singleGeneric when CreateSignature(singleGeneric.TypeSymbol) is var signature => singleGeneric.Type switch
+            SingleGeneric singleGeneric when CreateSignature(singleGeneric.TypeSymbol, options) is var signature => singleGeneric.Type switch
             {
                 SingleGeneric.SupportedType.Nullable => signature
                     .CreateScope($"return {Value} is not null and {{ NULL: false }} ? {InvokeUnmarshallMethod(singleGeneric.T, Value, DataMember, options)} : null;")
@@ -116,7 +114,7 @@ SingleGeneric.SupportedType.Set when singleGeneric.T.IsNumeric() => signature
             },
             KeyValueGeneric {TKey.SpecialType: not SpecialType.System_String} keyValueGeneric => throw new ArgumentException("Only strings are supported for for TKey",
                 UncoveredConversionException(keyValueGeneric, nameof(CreateMethod))),
-            KeyValueGeneric keyValueGeneric when CreateSignature(keyValueGeneric.TypeSymbol) is var signature => keyValueGeneric.Type switch
+            KeyValueGeneric keyValueGeneric when CreateSignature(keyValueGeneric.TypeSymbol, options) is var signature => keyValueGeneric.Type switch
             {
                 KeyValueGeneric.SupportedType.Dictionary => signature
                     .CreateScope($"return {Value} is {{ M: {{ }} x }} ? {AttributeValueUtilityFactory.ToDictionary}(x, {MarshallerOptions.ParamReference}, {DataMember}, static (a, o, d) => {InvokeUnmarshallMethod(keyValueGeneric.TValue, "a", "d", options, "o")}) : {Else(keyValueGeneric.TypeSymbol)};")
@@ -133,9 +131,9 @@ SingleGeneric.SupportedType.Set when singleGeneric.T.IsNumeric() => signature
 
     }
 
-    private static string CreateSignature(ITypeSymbol typeSymbol)
+    private static string CreateSignature(ITypeSymbol typeSymbol, MarshallerOptions options)
     {
-        return $"public static {typeSymbol.Representation().annotated} {GetDeserializationMethodName(typeSymbol)}(AttributeValue? {Value}, {MarshallerOptions.Name} {MarshallerOptions.ParamReference}, string? {DataMember} = null)";
+        return $"public static {typeSymbol.Representation().annotated} {GetDeserializationMethodName(typeSymbol)}(AttributeValue? {Value}, {options.FullName} {MarshallerOptions.ParamReference}, string? {DataMember} = null)";
     }
     private static IEnumerable<string> CreateTypeContents(IEnumerable<DynamoDBMarshallerArguments> arguments,
         Func<ITypeSymbol, DynamoDbDataMember[]> getDynamoDbProperties, MarshallerOptions options)
@@ -196,7 +194,7 @@ private static IEnumerable<string> ObjectAssignmentBlock(bool useParentheses, IE
 
     internal static IEnumerable<string> RootSignature(ITypeSymbol typeSymbol, string rootTypeName)
     {
-        return $"public {rootTypeName} {Constants.DynamoDBGenerator.Marshaller.UnmarshalMethodName}(Dictionary<{nameof(String)}, {Constants.AWSSDK_DynamoDBv2.AttributeValue}> entity)".CreateScope(
+        return $"public {rootTypeName} {Marshaller.UnmarshalMethodName}(Dictionary<{nameof(String)}, {Constants.AWSSDK_DynamoDBv2.AttributeValue}> entity)".CreateScope(
             "ArgumentNullException.ThrowIfNull(entity);",
             $"return {UnMarshallerClass}.{GetDeserializationMethodName(typeSymbol)}(entity, {MarshallerOptions.FieldReference});");
     }

src/DynamoDBGenerator.SourceGenerator/MarshallerFactory.cs

@@ -22,7 +22,7 @@ private static IEnumerable<string> CreateImplementations(IEnumerable<DynamoDBMar
             var entityTypeName = argument.AnnotatedEntityType;
             var argumentTypeName = argument.AnnotatedArgumentType;
 
-            var constructor = $"public {argument.ImplementationName}({MarshallerOptions.Name} {MarshallerOptions.ParamReference})"
+            var constructor = $"public {argument.ImplementationName}({options.FullName} {MarshallerOptions.ParamReference})"
                 .CreateScope($"{MarshallerOptions.FieldReference} = {MarshallerOptions.ParamReference};", $"{Marshaller.KeyMarshaller.PrimaryKeyMarshallerReference} = {Marshaller.KeyMarshaller.AssignmentRoot(argument.EntityTypeSymbol)};");
             var interfaceImplementation = constructor
                 .Concat(Marshaller.RootSignature(argument.EntityTypeSymbol, entityTypeName))
@@ -40,7 +40,7 @@ private static IEnumerable<string> CreateImplementations(IEnumerable<DynamoDBMar
             {
                 {} arg =>
                     $"public static {Interface}<{entityTypeName}, {argumentTypeName}, {nameTrackerTypeName}, {valueTrackerTypeName}> {argument.AccessName} {{ get; }} = new {argument.ImplementationName}({arg});",
-                null => $"public static {Interface}<{entityTypeName}, {argumentTypeName}, {nameTrackerTypeName}, {valueTrackerTypeName}> {argument.AccessName}({MarshallerOptions.Name} options) => new {argument.ImplementationName}(options);"
+                null => $"public static {Interface}<{entityTypeName}, {argumentTypeName}, {nameTrackerTypeName}, {valueTrackerTypeName}> {argument.AccessName}({options.FullName} options) => new {argument.ImplementationName}(options);"
             };
 
             foreach (var s in classImplementation)

src/DynamoDBGenerator.SourceGenerator/Types/MarshallerOptions.cs

@@ -9,13 +9,13 @@ public readonly struct MarshallerOptions
     private readonly INamedTypeSymbol _convertersType;
     private readonly int _enumStrategy;
     // TODO name needs to take namespace etc into account in order to make it accessible from the outside.
-    public const string Name = "MarshallerOptions";
+    private const string TypeName = "MarshallerOptions";
     public const string FieldReference = "_options";
     public const string ParamReference = "options";
     private const string ConvertersProperty = "Converters";
-    public const string FieldDeclaration = $"private readonly {Name} {FieldReference};";
+    public const string FieldDeclaration = $"private readonly {TypeName} {FieldReference};";
     private readonly string _converterFullPath;
-    private readonly string _optionsFullPath;
+    public string FullName { get; }
 
 
     private MarshallerOptions(
@@ -29,17 +29,14 @@ int enumStrategy
         _convertersType = convertersType;
         _enumStrategy = enumStrategy;
         _converterFullPath = _convertersType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
-        _optionsFullPath =
-            $"{originalType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)}.{Name}";
+        FullName = $"{originalType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)}.{TypeName}";
     }
 
     public string? TryInstantiate()
     {
         if (_convertersType.InstanceConstructors.Length is 0 ||
             _convertersType.InstanceConstructors.All(x => x.Parameters.Length is 0))
-        {
-            return $"new {_optionsFullPath}(new {_converterFullPath}())";
-        }
+            return $"new {FullName}(new {_converterFullPath}())";
 
         return null;
     }
@@ -101,11 +98,11 @@ public IEnumerable<string> ClassDeclaration
     {
         get
         {
-            var body = $"public {Name} ({_converterFullPath} converters)"
+            var body = $"public {TypeName} ({_converterFullPath} converters)"
                 .CreateScope($"{ConvertersProperty} = converters;")
                 .Append($"public {_converterFullPath} {ConvertersProperty} {{ get; }}");
 
-            return $"public sealed class {Name}".CreateScope(body);
+            return $"public sealed class {TypeName}".CreateScope(body);
         }
     }