From c18429a408caeb933e20d4db6a2d92a4a97a2004 Mon Sep 17 00:00:00 2001 From: Robert Andersson Date: Sat, 5 Oct 2024 19:47:37 +0200 Subject: [PATCH 01/11] Use scope function --- .../Extensions/NotNullEvaluationExtensions.cs | 33 +++++++++++++------ .../Generations/AttributeExpressionValue.cs | 31 +++++++++++------ 2 files changed, 44 insertions(+), 20 deletions(-) diff --git a/src/DynamoDBGenerator.SourceGenerator/Extensions/NotNullEvaluationExtensions.cs b/src/DynamoDBGenerator.SourceGenerator/Extensions/NotNullEvaluationExtensions.cs index 62d8559f..57ba70bd 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Extensions/NotNullEvaluationExtensions.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Extensions/NotNullEvaluationExtensions.cs @@ -31,18 +31,31 @@ private static string CreateException(in string accessPattern) return $"throw {Constants.DynamoDBGenerator.ExceptionHelper.NullExceptionMethod}(nameof({accessPattern}));"; } - public static string NotNullIfStatement(this ITypeSymbol typeSymbol, in string accessPattern, in string truthy) + public static IEnumerable NotNullIfStatement(this ITypeSymbol typeSymbol, string accessPattern, string truthy) + { + return NotNullIfStatement(typeSymbol, accessPattern, new string[] { truthy }); + } + public static IEnumerable NotNullIfStatement(this ITypeSymbol typeSymbol, string accessPattern, IEnumerable truthy) { if (Expression(typeSymbol, accessPattern) is not { } expression) - return truthy; - - var ifClause = $"if ({expression}) {{ {truthy} }}"; - return typeSymbol.NullableAnnotation switch { - NullableAnnotation.None or NullableAnnotation.Annotated => ifClause, - NullableAnnotation.NotAnnotated => $"{ifClause} else {{ {CreateException(in accessPattern)} }}", - _ => throw new ArgumentOutOfRangeException(typeSymbol.ToDisplayString()) - }; + foreach (var x in truthy) + yield return x; + } + else + { + var ifClause = $"if ({expression})".CreateScope(truthy); + var enumerable = typeSymbol.NullableAnnotation switch + { + NullableAnnotation.None or NullableAnnotation.Annotated => ifClause, + NullableAnnotation.NotAnnotated => ifClause.Concat("else".CreateScope(CreateException(in accessPattern))), + _ => throw new ArgumentOutOfRangeException(typeSymbol.ToDisplayString()) + }; + + foreach (var element in enumerable) + yield return element; + } + } @@ -72,4 +85,4 @@ public static string NotNullIfStatement(this ITypeSymbol typeSymbol, in string a } -} \ No newline at end of file +} diff --git a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs index 3f6c61f0..5df16717 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs @@ -58,15 +58,8 @@ MarshallerOptions options var yields = enumerable.Concat( dataMembers - .Select(x => - { - var accessPattern = $"entity.{x.DDB.DataMember.Name}"; - return x.IsUnknown - ? $"if (_{x.DDB.DataMember.Name}.IsValueCreated) {x.DDB.DataMember.Type.NotNullIfStatement(accessPattern, $"foreach (var x in ({x.DDB.DataMember.Name} as {x.AttributeInterfaceName}).{Constants.DynamoDBGenerator.Marshaller.AttributeExpressionValueTrackerAccessedValues}({accessPattern})) {{ yield return x; }}")}" - : $"if ({x.ValueRef}.IsValueCreated) {x.DDB.DataMember.Type.NotNullIfStatement(accessPattern, $"yield return new ({x.ValueRef}.Value, {Marshaller.InvokeMarshallerMethod(x.DDB.DataMember.Type, $"entity.{x.DDB.DataMember.Name}", $"\"{x.DDB.DataMember.Name}\"", options, MarshallerOptions.FieldReference)} ?? {AttributeValueUtilityFactory.Null});")}"; - } - ) - .Append($"if ({self}.IsValueCreated) yield return new ({self}.Value, {Marshaller.InvokeMarshallerMethod(typeSymbol, "entity", $"\"{structName}\"", options, MarshallerOptions.FieldReference)} ?? {AttributeValueUtilityFactory.Null});") + .SelectMany(x => YieldSelector(x, options)) + .Append($"if ({self}.IsValueCreated) yield return new ({self}.Value, {Marshaller.InvokeMarshallerMethod(typeSymbol, "entity", $"\"{structName}\"", options, MarshallerOptions.FieldReference)} ?? {AttributeValueUtilityFactory.Null});") ); foreach (var yield in @@ -76,6 +69,24 @@ MarshallerOptions options yield return $"public override string ToString() => {self}.Value;"; } + + private static IEnumerable YieldSelector((bool IsUnknown, DynamoDbDataMember DDB, string ValueRef, string AttributeReference, string AttributeInterfaceName) x, MarshallerOptions options) + { + var accessPattern = $"entity.{x.DDB.DataMember.Name}"; + + if (x.IsUnknown) + { + var @foreach = x.DDB.DataMember.Type.NotNullIfStatement( + accessPattern, + $"foreach (var x in ({x.DDB.DataMember.Name} as {x.AttributeInterfaceName}).{Constants.DynamoDBGenerator.Marshaller.AttributeExpressionValueTrackerAccessedValues}({accessPattern}))".CreateScope("yield return x;") + ); + + return $"if (_{x.DDB.DataMember.Name}.IsValueCreated)".CreateScope(@foreach); + } + + return $"if ({x.ValueRef}.IsValueCreated)".CreateScope(x.DDB.DataMember.Type.NotNullIfStatement(accessPattern, $"yield return new ({x.ValueRef}.Value, {Marshaller.InvokeMarshallerMethod(x.DDB.DataMember.Type, $"entity.{x.DDB.DataMember.Name}", $"\"{x.DDB.DataMember.Name}\"", options, MarshallerOptions.FieldReference)} ?? {AttributeValueUtilityFactory.Null});")); + + } internal static IEnumerable CreateExpressionAttributeValue(IEnumerable arguments, Func> getDynamoDbProperties, MarshallerOptions options) { // Using _comparer can double classes when there's a None nullable property mixed with a nullable property @@ -123,4 +134,4 @@ internal static (IEnumerable method, string typeName) RootSignature(ITyp $"return new {typeName}(incrementer.GetNext, {MarshallerOptions.FieldReference});" ), typeName); } -} \ No newline at end of file +} From e29fd06f4da8177d38263d1703ae6ff7546af560 Mon Sep 17 00:00:00 2001 From: Robert Andersson Date: Sat, 5 Oct 2024 19:52:28 +0200 Subject: [PATCH 02/11] Remove unused methods --- .../Extensions/StringExtensions.cs | 33 +------------------ 1 file changed, 1 insertion(+), 32 deletions(-) diff --git a/src/DynamoDBGenerator.SourceGenerator/Extensions/StringExtensions.cs b/src/DynamoDBGenerator.SourceGenerator/Extensions/StringExtensions.cs index 2871bed8..71281dc2 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Extensions/StringExtensions.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Extensions/StringExtensions.cs @@ -2,37 +2,6 @@ namespace DynamoDBGenerator.SourceGenerator.Extensions; public static class StringExtensions { - - private static readonly IDictionary IndentCache = new Dictionary - { - {0, ""}, - {1, " "}, - {2, " "}, - {3, " "}, - {4, " "} - }; - - private static string Indent(int level) - { - if (IndentCache.TryGetValue(level, out var indent)) return indent; - - indent = new string(' ', level * 4); - IndentCache[level] = indent; - - return indent; - } - public static IEnumerable CreateScope(this string header, IEnumerable content, int indentLevel) - { - var indent = Indent(indentLevel); - - yield return $"{indent}{header}"; - yield return string.Intern($"{indent}{{"); - - foreach (var s in content) - yield return $"{Indent(indentLevel + 1)}{s}"; - - yield return string.Intern($"{indent}}}"); - } public static IEnumerable CreateScope(this string header, IEnumerable content) { yield return header; @@ -81,4 +50,4 @@ public static string ToAlphaNumericMethodName(this string txt) return new string(arr, 0, index); } -} \ No newline at end of file +} From e10f115fd8626bedf44ca51d68e92b587d4fbf7d Mon Sep 17 00:00:00 2001 From: Robert Andersson Date: Sat, 5 Oct 2024 20:02:49 +0200 Subject: [PATCH 03/11] Use same reference --- .../Generations/AttributeExpressionValue.cs | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs index 5df16717..7b550678 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs @@ -21,7 +21,7 @@ MarshallerOptions options const string self = "_self"; var constructorFieldAssignments = dataMembers .Select(x => x.IsUnknown - ? $"_{x.DDB.DataMember.Name} = new (() => new {x.AttributeReference}({ValueProvider}, {MarshallerOptions.ParamReference}));" + ? $"{x.ValueRef} = new (() => new {x.AttributeReference}({ValueProvider}, {MarshallerOptions.ParamReference}));" : $"{x.ValueRef} = new ({ValueProvider});") .Append($"{self} = new({ValueProvider});") .Append($"{MarshallerOptions.FieldReference} = {MarshallerOptions.ParamReference};"); @@ -33,8 +33,8 @@ MarshallerOptions options { if (fieldDeclaration.IsUnknown) { - yield return $"private readonly Lazy<{fieldDeclaration.AttributeReference}> _{fieldDeclaration.DDB.DataMember.Name};"; - yield return $"public {fieldDeclaration.AttributeReference} {fieldDeclaration.DDB.DataMember.Name} => _{fieldDeclaration.DDB.DataMember.Name}.Value;"; + yield return $"private readonly Lazy<{fieldDeclaration.AttributeReference}> {fieldDeclaration.ValueRef};"; + yield return $"public {fieldDeclaration.AttributeReference} {fieldDeclaration.DDB.DataMember.Name} => {fieldDeclaration.ValueRef}.Value;"; } else { @@ -81,7 +81,7 @@ private static IEnumerable YieldSelector((bool IsUnknown, DynamoDbDataMe $"foreach (var x in ({x.DDB.DataMember.Name} as {x.AttributeInterfaceName}).{Constants.DynamoDBGenerator.Marshaller.AttributeExpressionValueTrackerAccessedValues}({accessPattern}))".CreateScope("yield return x;") ); - return $"if (_{x.DDB.DataMember.Name}.IsValueCreated)".CreateScope(@foreach); + return $"if ({x.ValueRef}.IsValueCreated)".CreateScope(@foreach); } return $"if ({x.ValueRef}.IsValueCreated)".CreateScope(x.DDB.DataMember.Type.NotNullIfStatement(accessPattern, $"yield return new ({x.ValueRef}.Value, {Marshaller.InvokeMarshallerMethod(x.DDB.DataMember.Type, $"entity.{x.DDB.DataMember.Name}", $"\"{x.DDB.DataMember.Name}\"", options, MarshallerOptions.FieldReference)} ?? {AttributeValueUtilityFactory.Null});")); @@ -106,8 +106,7 @@ private static CodeFactory CreateStruct(ITypeSymbol typeSymbol, Func { return ( - IsUnknown: !options.IsConvertable(x.DataMember.Type) && - x.DataMember.Type.TypeIdentifier() is UnknownType, + IsUnknown: !options.IsConvertable(x.DataMember.Type) && x.DataMember.Type.TypeIdentifier() is UnknownType, DDB: x, ValueRef: $"_{x.DataMember.Name}ValueRef", AttributeReference: TypeName(x.DataMember.Type), From 395a98ec7230b7ddb527cf8b8be41f0355cf39c2 Mon Sep 17 00:00:00 2001 From: Robert Andersson Date: Sat, 5 Oct 2024 22:47:41 +0200 Subject: [PATCH 04/11] Use private method for both overloads --- .../Extensions/NotNullEvaluationExtensions.cs | 24 +++++++++++++++---- 1 file changed, 20 insertions(+), 4 deletions(-) diff --git a/src/DynamoDBGenerator.SourceGenerator/Extensions/NotNullEvaluationExtensions.cs b/src/DynamoDBGenerator.SourceGenerator/Extensions/NotNullEvaluationExtensions.cs index 57ba70bd..7efb48ca 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Extensions/NotNullEvaluationExtensions.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Extensions/NotNullEvaluationExtensions.cs @@ -33,18 +33,34 @@ private static string CreateException(in string accessPattern) public static IEnumerable NotNullIfStatement(this ITypeSymbol typeSymbol, string accessPattern, string truthy) { - return NotNullIfStatement(typeSymbol, accessPattern, new string[] { truthy }); + return NotNullIfStatement(typeSymbol, accessPattern, obj: truthy); } public static IEnumerable NotNullIfStatement(this ITypeSymbol typeSymbol, string accessPattern, IEnumerable truthy) + { + return NotNullIfStatement(typeSymbol, accessPattern, obj: truthy); + } + + private static IEnumerable NotNullIfStatement(this ITypeSymbol typeSymbol, string accessPattern, object obj) { if (Expression(typeSymbol, accessPattern) is not { } expression) { - foreach (var x in truthy) - yield return x; + if(obj is string single) + yield return single; + else if(obj is IEnumerable truthies) + foreach (var x in truthies) + yield return x; + else + throw new NotImplementedException($"Method '{nameof(NotNullIfStatement)}' could not determine type '{obj.GetType().Name}'"); } else { - var ifClause = $"if ({expression})".CreateScope(truthy); + + var ifClause = obj switch + { + string single => $"if ({expression})".CreateScope(single), + IEnumerable multiple => $"if ({expression})".CreateScope(multiple), + _ => throw new NotImplementedException($"Method '{nameof(NotNullIfStatement)}' could not determine type '{obj.GetType().Name}'") + }; var enumerable = typeSymbol.NullableAnnotation switch { NullableAnnotation.None or NullableAnnotation.Annotated => ifClause, From deafddd4ba88ed1f38de44b673e773d90ab8ce73 Mon Sep 17 00:00:00 2001 From: Robert Andersson Date: Sat, 5 Oct 2024 22:51:47 +0200 Subject: [PATCH 05/11] Use switch expression --- .../Generations/AttributeExpressionValue.cs | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs index 7b550678..93d5483f 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs @@ -46,15 +46,13 @@ MarshallerOptions options const string param = "entity"; - var enumerable = Enumerable.Empty(); - if (typeSymbol.IsNullable()) - { - enumerable = $"if ({param} is null)".CreateScope($"yield return new ({self}.Value, {AttributeValueUtilityFactory.Null});", "yield break;"); - } - else if (typeSymbol.IsReferenceType) + + var enumerable = typeSymbol switch { - enumerable = $"if ({param} is null)".CreateScope($"throw {ExceptionHelper.NullExceptionMethod}(\"{structName}\");"); - } + var x when x.IsNullable() => $"if ({param} is null)".CreateScope($"yield return new ({self}.Value, {AttributeValueUtilityFactory.Null});", "yield break;"), + var x when x.IsReferenceType => $"if ({param} is null)".CreateScope($"throw {ExceptionHelper.NullExceptionMethod}(\"{structName}\");"), + _ => Enumerable.Empty() + }; var yields = enumerable.Concat( dataMembers From c31a1727649e198dc1ddc60c60c8ea9bb1d5a18b Mon Sep 17 00:00:00 2001 From: Robert Andersson Date: Sat, 5 Oct 2024 23:44:14 +0200 Subject: [PATCH 06/11] Make code more fluent --- .../Extensions/StringExtensions.cs | 7 +++++- .../Generations/AttributeExpressionValue.cs | 23 ++++++++----------- 2 files changed, 16 insertions(+), 14 deletions(-) diff --git a/src/DynamoDBGenerator.SourceGenerator/Extensions/StringExtensions.cs b/src/DynamoDBGenerator.SourceGenerator/Extensions/StringExtensions.cs index 71281dc2..e8448c02 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Extensions/StringExtensions.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Extensions/StringExtensions.cs @@ -2,6 +2,11 @@ namespace DynamoDBGenerator.SourceGenerator.Extensions; public static class StringExtensions { + public static IEnumerable ScopeTo(this IEnumerable content, string header) + { + return CreateScope(header, content); + } + public static IEnumerable CreateScope(this string header, IEnumerable content) { yield return header; @@ -22,7 +27,7 @@ public static IEnumerable CreateScope(this string header, string content yield return "}"; } - + public static IEnumerable CreateScope(this string header, string content, string second) { yield return header; diff --git a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs index 93d5483f..afce4da6 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs @@ -47,22 +47,20 @@ MarshallerOptions options const string param = "entity"; - var enumerable = typeSymbol switch + var yields = (typeSymbol switch { var x when x.IsNullable() => $"if ({param} is null)".CreateScope($"yield return new ({self}.Value, {AttributeValueUtilityFactory.Null});", "yield break;"), var x when x.IsReferenceType => $"if ({param} is null)".CreateScope($"throw {ExceptionHelper.NullExceptionMethod}(\"{structName}\");"), _ => Enumerable.Empty() - }; - - var yields = enumerable.Concat( - dataMembers + }) + .Concat(dataMembers .SelectMany(x => YieldSelector(x, options)) .Append($"if ({self}.IsValueCreated) yield return new ({self}.Value, {Marshaller.InvokeMarshallerMethod(typeSymbol, "entity", $"\"{structName}\"", options, MarshallerOptions.FieldReference)} ?? {AttributeValueUtilityFactory.Null});") - ); + ) + .ScopeTo($"IEnumerable> {interfaceName}.{Constants.DynamoDBGenerator.Marshaller.AttributeExpressionValueTrackerAccessedValues}({typeSymbol.Representation().annotated} entity)"); + - foreach (var yield in - $"IEnumerable> {interfaceName}.{Constants.DynamoDBGenerator.Marshaller.AttributeExpressionValueTrackerAccessedValues}({typeSymbol.Representation().annotated} entity)" - .CreateScope(yields)) + foreach (var yield in yields) yield return yield; yield return $"public override string ToString() => {self}.Value;"; @@ -74,12 +72,11 @@ private static IEnumerable YieldSelector((bool IsUnknown, DynamoDbDataMe if (x.IsUnknown) { - var @foreach = x.DDB.DataMember.Type.NotNullIfStatement( + return x.DDB.DataMember.Type.NotNullIfStatement( accessPattern, $"foreach (var x in ({x.DDB.DataMember.Name} as {x.AttributeInterfaceName}).{Constants.DynamoDBGenerator.Marshaller.AttributeExpressionValueTrackerAccessedValues}({accessPattern}))".CreateScope("yield return x;") - ); - - return $"if ({x.ValueRef}.IsValueCreated)".CreateScope(@foreach); + ) + .ScopeTo($"if ({x.ValueRef}.IsValueCreated)"); } return $"if ({x.ValueRef}.IsValueCreated)".CreateScope(x.DDB.DataMember.Type.NotNullIfStatement(accessPattern, $"yield return new ({x.ValueRef}.Value, {Marshaller.InvokeMarshallerMethod(x.DDB.DataMember.Type, $"entity.{x.DDB.DataMember.Name}", $"\"{x.DDB.DataMember.Name}\"", options, MarshallerOptions.FieldReference)} ?? {AttributeValueUtilityFactory.Null});")); From 904a753b48f48f71974321d008208040dae6e65c Mon Sep 17 00:00:00 2001 From: Robert Andersson Date: Sat, 12 Oct 2024 16:15:53 +0200 Subject: [PATCH 07/11] WIP --- .../Extensions/StringExtensions.cs | 45 +++++++++++++++++++ .../Generations/AttributeExpressionName.cs | 27 ++++++----- .../Generations/AttributeExpressionValue.cs | 2 +- .../Types/DataMember.cs | 14 ++++-- 4 files changed, 70 insertions(+), 18 deletions(-) diff --git a/src/DynamoDBGenerator.SourceGenerator/Extensions/StringExtensions.cs b/src/DynamoDBGenerator.SourceGenerator/Extensions/StringExtensions.cs index e8448c02..8685a1f9 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Extensions/StringExtensions.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Extensions/StringExtensions.cs @@ -2,6 +2,51 @@ namespace DynamoDBGenerator.SourceGenerator.Extensions; public static class StringExtensions { + public static string ToCamelCaseFromPascal(this string str, [System.Runtime.CompilerServices.CallerMemberName] string? memberName = null) + { + return ToCamelCaseFromPascal(str.AsSpan(), memberName).ToString(); + } + + public static string ToPrivateFieldFromPascal(this string str, [System.Runtime.CompilerServices.CallerMemberName] string? memberName = null) + { + return ToPrivateFieldFromPascal(str.AsSpan(), memberName).ToString(); + } + + public static ReadOnlySpan ToPrivateFieldFromPascal(this ReadOnlySpan span, [System.Runtime.CompilerServices.CallerMemberName] string? memberName = null) + { + if (span.Length is 0) + throw new ArgumentException($"Null or Empty string was provided from '{memberName}'"); + + var array = new char[span.Length + 1]; + + array[0] = '_'; + array[1] = Char.ToLowerInvariant(span[0]); + + // Skip first element since we handled it manually. + for (var i = 1; i < span.Length; i++) + array[i + 1] = span[i]; + + return array; + } + public static ReadOnlySpan ToCamelCaseFromPascal(this ReadOnlySpan span, [System.Runtime.CompilerServices.CallerMemberName] string? memberName = null) + { + if (span.Length is 0) + throw new ArgumentException($"Null or Empty string was provided from '{memberName}'"); + + if (char.IsLower(span[0])) + return span; + + var array = new char[span.Length]; + + array[0] = Char.ToLowerInvariant(span[0]); + + // Skip first element since we handled it manually. + for (var i = 1; i < span.Length; i++) + array[i] = span[i]; + + return array; + } + public static IEnumerable ScopeTo(this IEnumerable content, string header) { return CreateScope(header, content); diff --git a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionName.cs b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionName.cs index 013de6e1..135602d9 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionName.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionName.cs @@ -24,7 +24,7 @@ internal static IEnumerable CreateClasses(IEnumerable TypeContent( ITypeSymbol typeSymbol, - (bool IsUnknown, DynamoDbDataMember DDB, string IfBranchAlias, string DbRef, string NameRef, string AttributeReference, string AttributeInterfaceName)[] dataMembers, + (bool IsUnknown, DynamoDbDataMember DDB, string DbRef, string AttributeReference, string AttributeInterfaceName)[] dataMembers, string structName) { const string self = "_self"; @@ -33,8 +33,8 @@ private static IEnumerable TypeContent( { var ternaryExpressionName = $"{ConstructorAttributeName} is null ? {@$"""#{x.DDB.AttributeName}"""}: {@$"$""{{{ConstructorAttributeName}}}.#{x.DDB.AttributeName}"""}"; return x.IsUnknown - ? $"{x.NameRef} = new (() => new {x.AttributeReference}({ternaryExpressionName}, {ConstructorSetName}));" - : $"{x.NameRef} = new (() => {ternaryExpressionName});"; + ? $"{x.DDB.DataMember.PrivateField} = new (() => new {x.AttributeReference}({ternaryExpressionName}, {ConstructorSetName}));" + : $"{x.DDB.DataMember.PrivateField} = new (() => {ternaryExpressionName});"; }) .Append($"{SetFieldName} = {ConstructorSetName};") .Append($@"{self} = new(() => {ConstructorAttributeName} ?? throw new NotImplementedException(""Root element AttributeExpressionName reference.""));"); @@ -46,13 +46,13 @@ private static IEnumerable TypeContent( { if (fieldDeclaration.IsUnknown) { - yield return $"private readonly Lazy<{fieldDeclaration.AttributeReference}> {fieldDeclaration.NameRef};"; - yield return $"public {fieldDeclaration.AttributeReference} {fieldDeclaration.DDB.DataMember.Name} => {fieldDeclaration.NameRef}.Value;"; + yield return $"private readonly Lazy<{fieldDeclaration.AttributeReference}> {fieldDeclaration.DDB.DataMember.PrivateField};"; + yield return $"public {fieldDeclaration.AttributeReference} {fieldDeclaration.DDB.DataMember.Name} => {fieldDeclaration.DDB.DataMember.PrivateField}.Value;"; } else { - yield return $"private readonly Lazy {fieldDeclaration.NameRef};"; - yield return $"public string {fieldDeclaration.DDB.DataMember.Name} => {fieldDeclaration.NameRef}.Value;"; + yield return $"private readonly Lazy {fieldDeclaration.DDB.DataMember.PrivateField};"; + yield return $"public string {fieldDeclaration.DDB.DataMember.Name} => {fieldDeclaration.DDB.DataMember.PrivateField}.Value;"; } } @@ -69,19 +69,20 @@ private static IEnumerable TypeContent( yield return $"public override string ToString() => {self}.Value;"; } - private static IEnumerable YieldSelector((bool IsUnknown, DynamoDbDataMember DDB, string IfBranchAlias, string DbRef, string NameRef, string AttributeReference, string AttributeInterfaceName) x) + private static IEnumerable YieldSelector((bool IsUnknown, DynamoDbDataMember DDB, string DbRef, string AttributeReference, string AttributeInterfaceName) x) { + var camelCase = x.DDB.DataMember.CamelCase; if (x.IsUnknown) { - var scope = $@"if (new KeyValuePair(""{x.DbRef}"", ""{x.DDB.AttributeName}"") is var {x.IfBranchAlias} && {SetFieldName}.Add({x.IfBranchAlias}))" - .CreateScope($"yield return {x.IfBranchAlias};") + var scope = $@"if (new KeyValuePair(""{x.DbRef}"", ""{x.DDB.AttributeName}"") is var {camelCase} && {SetFieldName}.Add({camelCase}))" + .CreateScope($"yield return {camelCase};") .Concat($"foreach (var x in ({x.DDB.DataMember.Name} as {x.AttributeInterfaceName}).{AttributeExpressionNameTrackerInterfaceAccessedNames}())".CreateScope("yield return x;")); - return $"if ({x.NameRef}.IsValueCreated)".CreateScope(scope); + return $"if ({x.DDB.DataMember.PrivateField}.IsValueCreated)".CreateScope(scope); } else { - return $@"if ({x.NameRef}.IsValueCreated && new KeyValuePair(""{x.DbRef}"", ""{x.DDB.AttributeName}"") is var {x.IfBranchAlias} && {SetFieldName}.Add({x.IfBranchAlias}))".CreateScope($"yield return {x.IfBranchAlias};"); + return $@"if ({x.DDB.DataMember.PrivateField}.IsValueCreated && new KeyValuePair(""{x.DbRef}"", ""{x.DDB.AttributeName}"") is var {camelCase} && {SetFieldName}.Add({camelCase}))".CreateScope($"yield return {camelCase};"); } } @@ -91,9 +92,7 @@ private static CodeFactory CreateStruct(ITypeSymbol typeSymbol, Func ( IsUnknown: !options.IsConvertable(x.DataMember.Type) && x.DataMember.Type.TypeIdentifier() is UnknownType, DDB: x, - IfBranchAlias: $"__{x.DataMember.Name}__", DbRef: $"#{x.AttributeName}", - NameRef: $"_{x.DataMember.Name}NameRef", AttributeReference: TypeName(x.DataMember.Type), AttributeInterfaceName: AttributeExpressionNameTrackerInterface )) diff --git a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs index afce4da6..949bde98 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs @@ -103,7 +103,7 @@ private static CodeFactory CreateStruct(ITypeSymbol typeSymbol, Func" diff --git a/src/DynamoDBGenerator.SourceGenerator/Types/DataMember.cs b/src/DynamoDBGenerator.SourceGenerator/Types/DataMember.cs index 0ae9398a..3f204d41 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Types/DataMember.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Types/DataMember.cs @@ -1,3 +1,4 @@ +using DynamoDBGenerator.SourceGenerator.Extensions; using Microsoft.CodeAnalysis; namespace DynamoDBGenerator.SourceGenerator.Types; @@ -13,11 +14,14 @@ private DataMember(in ISymbol symbol, in string fieldName, in ITypeSymbol type, Type = type; BaseSymbol = symbol; IsAssignable = isAssignable; + + PrivateField = fieldName.ToPrivateFieldFromPascal(); + CamelCase = fieldName.ToCamelCaseFromPascal(); } public static DataMember FromField(in IFieldSymbol fieldSymbol) { - var symbol = (ISymbol) fieldSymbol; + var symbol = (ISymbol)fieldSymbol; var name = fieldSymbol.Name; var type = fieldSymbol.Type; @@ -26,7 +30,7 @@ public static DataMember FromField(in IFieldSymbol fieldSymbol) public static DataMember FromProperty(in IPropertySymbol property) { - var symbol = (ISymbol) property; + var symbol = (ISymbol)property; var name = property.Name; var type = property.Type; @@ -43,9 +47,13 @@ public static DataMember FromProperty(in IPropertySymbol property) /// public string Name { get; } + + public string PrivateField { get; } + public string CamelCase { get; } + /// /// The type of the data member. /// public ITypeSymbol Type { get; } public bool IsAssignable { get; } -} \ No newline at end of file +} From 8fe85e7127eebaa4c397912a0d4c4b1901c8806f Mon Sep 17 00:00:00 2001 From: Robert Andersson Date: Sat, 12 Oct 2024 22:43:23 +0200 Subject: [PATCH 08/11] Reuse properties --- .../Generations/AttributeExpressionValue.cs | 23 +++++++++---------- 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs index 949bde98..ab355b49 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs @@ -12,7 +12,7 @@ public static class AttributeExpressionValue private const string ValueProvider = "valueIdProvider"; private static IEnumerable TypeContents( ITypeSymbol typeSymbol, - (bool IsUnknown, DynamoDbDataMember DDB, string ValueRef, string AttributeReference, string AttributeInterfaceName)[] dataMembers, + (bool IsUnknown, DynamoDbDataMember DDB, string AttributeReference, string AttributeInterfaceName)[] dataMembers, string structName, string interfaceName, MarshallerOptions options @@ -21,8 +21,8 @@ MarshallerOptions options const string self = "_self"; var constructorFieldAssignments = dataMembers .Select(x => x.IsUnknown - ? $"{x.ValueRef} = new (() => new {x.AttributeReference}({ValueProvider}, {MarshallerOptions.ParamReference}));" - : $"{x.ValueRef} = new ({ValueProvider});") + ? $"{x.DDB.DataMember.PrivateField} = new (() => new {x.AttributeReference}({ValueProvider}, {MarshallerOptions.ParamReference}));" + : $"{x.DDB.DataMember.PrivateField} = new ({ValueProvider});") .Append($"{self} = new({ValueProvider});") .Append($"{MarshallerOptions.FieldReference} = {MarshallerOptions.ParamReference};"); foreach (var fieldAssignment in $"public {structName}(Func {ValueProvider}, {MarshallerOptions.Name} options)".CreateScope(constructorFieldAssignments)) @@ -33,13 +33,13 @@ MarshallerOptions options { if (fieldDeclaration.IsUnknown) { - yield return $"private readonly Lazy<{fieldDeclaration.AttributeReference}> {fieldDeclaration.ValueRef};"; - yield return $"public {fieldDeclaration.AttributeReference} {fieldDeclaration.DDB.DataMember.Name} => {fieldDeclaration.ValueRef}.Value;"; + yield return $"private readonly Lazy<{fieldDeclaration.AttributeReference}> {fieldDeclaration.DDB.DataMember.PrivateField};"; + yield return $"public {fieldDeclaration.AttributeReference} {fieldDeclaration.DDB.DataMember.Name} => {fieldDeclaration.DDB.DataMember.PrivateField}.Value;"; } else { - yield return $"private readonly Lazy {fieldDeclaration.ValueRef};"; - yield return $"public string {fieldDeclaration.DDB.DataMember.Name} => {fieldDeclaration.ValueRef}.Value;"; + yield return $"private readonly Lazy {fieldDeclaration.DDB.DataMember.PrivateField};"; + yield return $"public string {fieldDeclaration.DDB.DataMember.Name} => {fieldDeclaration.DDB.DataMember.PrivateField}.Value;"; } } yield return $"private readonly Lazy {self};"; @@ -66,7 +66,7 @@ MarshallerOptions options yield return $"public override string ToString() => {self}.Value;"; } - private static IEnumerable YieldSelector((bool IsUnknown, DynamoDbDataMember DDB, string ValueRef, string AttributeReference, string AttributeInterfaceName) x, MarshallerOptions options) + private static IEnumerable YieldSelector((bool IsUnknown, DynamoDbDataMember DDB, string AttributeReference, string AttributeInterfaceName) x, MarshallerOptions options) { var accessPattern = $"entity.{x.DDB.DataMember.Name}"; @@ -76,10 +76,10 @@ private static IEnumerable YieldSelector((bool IsUnknown, DynamoDbDataMe accessPattern, $"foreach (var x in ({x.DDB.DataMember.Name} as {x.AttributeInterfaceName}).{Constants.DynamoDBGenerator.Marshaller.AttributeExpressionValueTrackerAccessedValues}({accessPattern}))".CreateScope("yield return x;") ) - .ScopeTo($"if ({x.ValueRef}.IsValueCreated)"); + .ScopeTo($"if ({x.DDB.DataMember.PrivateField}.IsValueCreated)"); } - return $"if ({x.ValueRef}.IsValueCreated)".CreateScope(x.DDB.DataMember.Type.NotNullIfStatement(accessPattern, $"yield return new ({x.ValueRef}.Value, {Marshaller.InvokeMarshallerMethod(x.DDB.DataMember.Type, $"entity.{x.DDB.DataMember.Name}", $"\"{x.DDB.DataMember.Name}\"", options, MarshallerOptions.FieldReference)} ?? {AttributeValueUtilityFactory.Null});")); + return $"if ({x.DDB.DataMember.PrivateField}.IsValueCreated)".CreateScope(x.DDB.DataMember.Type.NotNullIfStatement(accessPattern, $"yield return new ({x.DDB.DataMember.PrivateField}.Value, {Marshaller.InvokeMarshallerMethod(x.DDB.DataMember.Type, $"entity.{x.DDB.DataMember.Name}", $"\"{x.DDB.DataMember.Name}\"", options, MarshallerOptions.FieldReference)} ?? {AttributeValueUtilityFactory.Null});")); } internal static IEnumerable CreateExpressionAttributeValue(IEnumerable arguments, Func> getDynamoDbProperties, MarshallerOptions options) @@ -95,7 +95,7 @@ private static CodeFactory CreateStruct(ITypeSymbol typeSymbol, Func() : fn(typeSymbol) .Select(x => @@ -103,7 +103,6 @@ private static CodeFactory CreateStruct(ITypeSymbol typeSymbol, Func" From 7dc3cf3db5242b3b3874e410fc4143c722c31e3d Mon Sep 17 00:00:00 2001 From: Robert Andersson Date: Fri, 18 Oct 2024 15:31:29 +0200 Subject: [PATCH 09/11] Rename properties; --- .../Generations/AttributeExpressionName.cs | 18 +++++++++--------- .../Generations/AttributeExpressionValue.cs | 16 ++++++++-------- .../Types/DataMember.cs | 8 ++++---- 3 files changed, 21 insertions(+), 21 deletions(-) diff --git a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionName.cs b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionName.cs index 135602d9..f84a0e14 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionName.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionName.cs @@ -33,8 +33,8 @@ private static IEnumerable TypeContent( { var ternaryExpressionName = $"{ConstructorAttributeName} is null ? {@$"""#{x.DDB.AttributeName}"""}: {@$"$""{{{ConstructorAttributeName}}}.#{x.DDB.AttributeName}"""}"; return x.IsUnknown - ? $"{x.DDB.DataMember.PrivateField} = new (() => new {x.AttributeReference}({ternaryExpressionName}, {ConstructorSetName}));" - : $"{x.DDB.DataMember.PrivateField} = new (() => {ternaryExpressionName});"; + ? $"{x.DDB.DataMember.NameAsPrivateField} = new (() => new {x.AttributeReference}({ternaryExpressionName}, {ConstructorSetName}));" + : $"{x.DDB.DataMember.NameAsPrivateField} = new (() => {ternaryExpressionName});"; }) .Append($"{SetFieldName} = {ConstructorSetName};") .Append($@"{self} = new(() => {ConstructorAttributeName} ?? throw new NotImplementedException(""Root element AttributeExpressionName reference.""));"); @@ -46,13 +46,13 @@ private static IEnumerable TypeContent( { if (fieldDeclaration.IsUnknown) { - yield return $"private readonly Lazy<{fieldDeclaration.AttributeReference}> {fieldDeclaration.DDB.DataMember.PrivateField};"; - yield return $"public {fieldDeclaration.AttributeReference} {fieldDeclaration.DDB.DataMember.Name} => {fieldDeclaration.DDB.DataMember.PrivateField}.Value;"; + yield return $"private readonly Lazy<{fieldDeclaration.AttributeReference}> {fieldDeclaration.DDB.DataMember.NameAsPrivateField};"; + yield return $"public {fieldDeclaration.AttributeReference} {fieldDeclaration.DDB.DataMember.Name} => {fieldDeclaration.DDB.DataMember.NameAsPrivateField}.Value;"; } else { - yield return $"private readonly Lazy {fieldDeclaration.DDB.DataMember.PrivateField};"; - yield return $"public string {fieldDeclaration.DDB.DataMember.Name} => {fieldDeclaration.DDB.DataMember.PrivateField}.Value;"; + yield return $"private readonly Lazy {fieldDeclaration.DDB.DataMember.NameAsPrivateField};"; + yield return $"public string {fieldDeclaration.DDB.DataMember.Name} => {fieldDeclaration.DDB.DataMember.NameAsPrivateField}.Value;"; } } @@ -72,17 +72,17 @@ private static IEnumerable TypeContent( private static IEnumerable YieldSelector((bool IsUnknown, DynamoDbDataMember DDB, string DbRef, string AttributeReference, string AttributeInterfaceName) x) { - var camelCase = x.DDB.DataMember.CamelCase; + var camelCase = x.DDB.DataMember.NameAsCamelCase; if (x.IsUnknown) { var scope = $@"if (new KeyValuePair(""{x.DbRef}"", ""{x.DDB.AttributeName}"") is var {camelCase} && {SetFieldName}.Add({camelCase}))" .CreateScope($"yield return {camelCase};") .Concat($"foreach (var x in ({x.DDB.DataMember.Name} as {x.AttributeInterfaceName}).{AttributeExpressionNameTrackerInterfaceAccessedNames}())".CreateScope("yield return x;")); - return $"if ({x.DDB.DataMember.PrivateField}.IsValueCreated)".CreateScope(scope); + return $"if ({x.DDB.DataMember.NameAsPrivateField}.IsValueCreated)".CreateScope(scope); } else { - return $@"if ({x.DDB.DataMember.PrivateField}.IsValueCreated && new KeyValuePair(""{x.DbRef}"", ""{x.DDB.AttributeName}"") is var {camelCase} && {SetFieldName}.Add({camelCase}))".CreateScope($"yield return {camelCase};"); + return $@"if ({x.DDB.DataMember.NameAsPrivateField}.IsValueCreated && new KeyValuePair(""{x.DbRef}"", ""{x.DDB.AttributeName}"") is var {camelCase} && {SetFieldName}.Add({camelCase}))".CreateScope($"yield return {camelCase};"); } } diff --git a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs index ab355b49..648ce669 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs @@ -21,8 +21,8 @@ MarshallerOptions options const string self = "_self"; var constructorFieldAssignments = dataMembers .Select(x => x.IsUnknown - ? $"{x.DDB.DataMember.PrivateField} = new (() => new {x.AttributeReference}({ValueProvider}, {MarshallerOptions.ParamReference}));" - : $"{x.DDB.DataMember.PrivateField} = new ({ValueProvider});") + ? $"{x.DDB.DataMember.NameAsPrivateField} = new (() => new {x.AttributeReference}({ValueProvider}, {MarshallerOptions.ParamReference}));" + : $"{x.DDB.DataMember.NameAsPrivateField} = new ({ValueProvider});") .Append($"{self} = new({ValueProvider});") .Append($"{MarshallerOptions.FieldReference} = {MarshallerOptions.ParamReference};"); foreach (var fieldAssignment in $"public {structName}(Func {ValueProvider}, {MarshallerOptions.Name} options)".CreateScope(constructorFieldAssignments)) @@ -33,13 +33,13 @@ MarshallerOptions options { if (fieldDeclaration.IsUnknown) { - yield return $"private readonly Lazy<{fieldDeclaration.AttributeReference}> {fieldDeclaration.DDB.DataMember.PrivateField};"; - yield return $"public {fieldDeclaration.AttributeReference} {fieldDeclaration.DDB.DataMember.Name} => {fieldDeclaration.DDB.DataMember.PrivateField}.Value;"; + yield return $"private readonly Lazy<{fieldDeclaration.AttributeReference}> {fieldDeclaration.DDB.DataMember.NameAsPrivateField};"; + yield return $"public {fieldDeclaration.AttributeReference} {fieldDeclaration.DDB.DataMember.Name} => {fieldDeclaration.DDB.DataMember.NameAsPrivateField}.Value;"; } else { - yield return $"private readonly Lazy {fieldDeclaration.DDB.DataMember.PrivateField};"; - yield return $"public string {fieldDeclaration.DDB.DataMember.Name} => {fieldDeclaration.DDB.DataMember.PrivateField}.Value;"; + yield return $"private readonly Lazy {fieldDeclaration.DDB.DataMember.NameAsPrivateField};"; + yield return $"public string {fieldDeclaration.DDB.DataMember.Name} => {fieldDeclaration.DDB.DataMember.NameAsPrivateField}.Value;"; } } yield return $"private readonly Lazy {self};"; @@ -76,10 +76,10 @@ private static IEnumerable YieldSelector((bool IsUnknown, DynamoDbDataMe accessPattern, $"foreach (var x in ({x.DDB.DataMember.Name} as {x.AttributeInterfaceName}).{Constants.DynamoDBGenerator.Marshaller.AttributeExpressionValueTrackerAccessedValues}({accessPattern}))".CreateScope("yield return x;") ) - .ScopeTo($"if ({x.DDB.DataMember.PrivateField}.IsValueCreated)"); + .ScopeTo($"if ({x.DDB.DataMember.NameAsPrivateField}.IsValueCreated)"); } - return $"if ({x.DDB.DataMember.PrivateField}.IsValueCreated)".CreateScope(x.DDB.DataMember.Type.NotNullIfStatement(accessPattern, $"yield return new ({x.DDB.DataMember.PrivateField}.Value, {Marshaller.InvokeMarshallerMethod(x.DDB.DataMember.Type, $"entity.{x.DDB.DataMember.Name}", $"\"{x.DDB.DataMember.Name}\"", options, MarshallerOptions.FieldReference)} ?? {AttributeValueUtilityFactory.Null});")); + return $"if ({x.DDB.DataMember.NameAsPrivateField}.IsValueCreated)".CreateScope(x.DDB.DataMember.Type.NotNullIfStatement(accessPattern, $"yield return new ({x.DDB.DataMember.NameAsPrivateField}.Value, {Marshaller.InvokeMarshallerMethod(x.DDB.DataMember.Type, $"entity.{x.DDB.DataMember.Name}", $"\"{x.DDB.DataMember.Name}\"", options, MarshallerOptions.FieldReference)} ?? {AttributeValueUtilityFactory.Null});")); } internal static IEnumerable CreateExpressionAttributeValue(IEnumerable arguments, Func> getDynamoDbProperties, MarshallerOptions options) diff --git a/src/DynamoDBGenerator.SourceGenerator/Types/DataMember.cs b/src/DynamoDBGenerator.SourceGenerator/Types/DataMember.cs index 3f204d41..28785234 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Types/DataMember.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Types/DataMember.cs @@ -15,8 +15,8 @@ private DataMember(in ISymbol symbol, in string fieldName, in ITypeSymbol type, BaseSymbol = symbol; IsAssignable = isAssignable; - PrivateField = fieldName.ToPrivateFieldFromPascal(); - CamelCase = fieldName.ToCamelCaseFromPascal(); + NameAsPrivateField = fieldName.ToPrivateFieldFromPascal(); + NameAsCamelCase = fieldName.ToCamelCaseFromPascal(); } public static DataMember FromField(in IFieldSymbol fieldSymbol) @@ -48,8 +48,8 @@ public static DataMember FromProperty(in IPropertySymbol property) public string Name { get; } - public string PrivateField { get; } - public string CamelCase { get; } + public string NameAsPrivateField { get; } + public string NameAsCamelCase { get; } /// /// The type of the data member. From 119419e1c5c676f1d50abf663d6eec252e63c5d7 Mon Sep 17 00:00:00 2001 From: Robert Andersson Date: Fri, 18 Oct 2024 15:34:34 +0200 Subject: [PATCH 10/11] Rename _self -> _this --- .../Generations/AttributeExpressionName.cs | 2 +- .../Generations/AttributeExpressionValue.cs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionName.cs b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionName.cs index f84a0e14..c9f30ae1 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionName.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionName.cs @@ -27,7 +27,7 @@ private static IEnumerable TypeContent( (bool IsUnknown, DynamoDbDataMember DDB, string DbRef, string AttributeReference, string AttributeInterfaceName)[] dataMembers, string structName) { - const string self = "_self"; + const string self = "_this"; var constructorFieldAssignments = dataMembers .Select(x => { diff --git a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs index 648ce669..27ed7444 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Generations/AttributeExpressionValue.cs @@ -18,7 +18,7 @@ private static IEnumerable TypeContents( MarshallerOptions options ) { - const string self = "_self"; + const string self = "_this"; var constructorFieldAssignments = dataMembers .Select(x => x.IsUnknown ? $"{x.DDB.DataMember.NameAsPrivateField} = new (() => new {x.AttributeReference}({ValueProvider}, {MarshallerOptions.ParamReference}));" From 828fcdc3f7e615012b49473d1a65fddfe6313bed Mon Sep 17 00:00:00 2001 From: Robert Andersson Date: Fri, 18 Oct 2024 15:43:16 +0200 Subject: [PATCH 11/11] Add missing space --- .../Generations/KeyMarshaller.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/DynamoDBGenerator.SourceGenerator/Generations/KeyMarshaller.cs b/src/DynamoDBGenerator.SourceGenerator/Generations/KeyMarshaller.cs index f81ed572..d13d3084 100644 --- a/src/DynamoDBGenerator.SourceGenerator/Generations/KeyMarshaller.cs +++ b/src/DynamoDBGenerator.SourceGenerator/Generations/KeyMarshaller.cs @@ -24,7 +24,7 @@ private static IEnumerable CreateAssignment(string validateReference, st .Concat($"else if ({keyReference} is null) ".CreateScope($@"throw {ExceptionHelper.KeysArgumentNullExceptionMethod}(""{dataMember.DataMember.Name}"", ""{keyReference}"");")) .Concat("else".CreateScope($@"throw {ExceptionHelper.KeysInvalidConversionExceptionMethod}(""{dataMember.DataMember.Name}"", ""{keyReference}"", {keyReference}, ""{expectedType}"");")); - return $"if({validateReference})".CreateScope(innerContent); + return $"if ({validateReference})".CreateScope(innerContent); } private static IEnumerable MethodBody(ITypeSymbol typeSymbol, Func> fn, MarshallerOptions options) @@ -120,4 +120,4 @@ private static CodeFactory StaticAttributeValueDictionaryKeys(ITypeSymbol typeSy return new CodeFactory(code); } -} \ No newline at end of file +}