Use PascalCase for record property names (#152)

Joshua Griffith · Joshua Griffith · commit e4aadd4da6c8 · 2026-01-29T14:38:38.000-06:00
Record positional parameters now use PascalCase per C# naming conventions instead of @lowerCamelCase. Keywords are prefixed with @ only when necessary. - Add property_name filter for record/enum variant fields - Update RecordTemplate.cs to use property_name - Update EnumTemplate.cs to use property_name for variant fields - Update destroy_fields macro to use property_name - Add regression test fixture for issue-152 Signed-off-by: Joshua Griffith <Joshua.Griffith@fnf.com>
diff --git a/bindgen/src/gen_cs/filters.rs b/bindgen/src/gen_cs/filters.rs
@@ -122,6 +122,11 @@ pub(super) fn var_name(nm: impl AsRef<str>) -> Result<String, askama::Error> {
     Ok(oracle().var_name(nm.as_ref()))
 }
 
+/// Get the idiomatic C# rendering of a property name (for record positional parameters).
+pub(super) fn property_name(nm: impl AsRef<str>) -> Result<String, askama::Error> {
+    Ok(oracle().property_name(nm.as_ref()))
+}
+
 /// Get the idiomatic C# rendering of an individual enum variant.
 pub(super) fn enum_variant(nm: &str) -> Result<String, askama::Error> {
     Ok(oracle().enum_variant_name(nm))
diff --git a/bindgen/src/gen_cs/mod.rs b/bindgen/src/gen_cs/mod.rs
@@ -335,6 +335,36 @@ impl CsCodeOracle {
         format!("@{}", nm.to_string().to_lower_camel_case())
     }
 
+    /// Get the idiomatic C# rendering of a property name (for record positional parameters).
+    /// Uses PascalCase per Microsoft naming conventions. Prefixes with @ only for C# keywords.
+    fn property_name(&self, nm: &str) -> String {
+        let name = nm.to_string().to_upper_camel_case();
+        if Self::is_csharp_keyword(&name) {
+            format!("@{}", name)
+        } else {
+            name
+        }
+    }
+
+    /// Check if a name is a C# keyword that requires an @ prefix.
+    fn is_csharp_keyword(name: &str) -> bool {
+        matches!(
+            name,
+            // C# reserved keywords (case-sensitive)
+            "Abstract" | "As" | "Base" | "Bool" | "Break" | "Byte" | "Case" | "Catch"
+            | "Char" | "Checked" | "Class" | "Const" | "Continue" | "Decimal" | "Default"
+            | "Delegate" | "Do" | "Double" | "Else" | "Enum" | "Event" | "Explicit"
+            | "Extern" | "False" | "Finally" | "Fixed" | "Float" | "For" | "Foreach"
+            | "Goto" | "If" | "Implicit" | "In" | "Int" | "Interface" | "Internal" | "Is"
+            | "Lock" | "Long" | "Namespace" | "New" | "Null" | "Object" | "Operator"
+            | "Out" | "Override" | "Params" | "Private" | "Protected" | "Public"
+            | "Readonly" | "Ref" | "Return" | "Sbyte" | "Sealed" | "Short" | "Sizeof"
+            | "Stackalloc" | "Static" | "String" | "Struct" | "Switch" | "This" | "Throw"
+            | "True" | "Try" | "Typeof" | "Uint" | "Ulong" | "Unchecked" | "Unsafe"
+            | "Ushort" | "Using" | "Virtual" | "Void" | "Volatile" | "While"
+        )
+    }
+
     /// Get the idiomatic C# rendering of an individual enum variant.
     fn enum_variant_name(&self, nm: &str) -> String {
         nm.to_string().to_upper_camel_case()
diff --git a/bindgen/templates/EnumTemplate.cs b/bindgen/templates/EnumTemplate.cs
@@ -49,7 +49,7 @@ public record {{ variant.name()|class_name(ci) }}: {{ type_name }} {}
     {% else -%}
     public record {{ variant.name()|class_name(ci) }} (
         {%- for field in variant.fields() %}
-        {%- let field_name = field.name()|or_pos_var(loop.index)|var_name %}
+        {%- let field_name = field.name()|or_pos_var(loop.index)|property_name %}
         {% call cs::enum_parameter_type_name(field|type_name(ci), variant.name()|class_name(ci)) %} {{ field_name }}{% if !loop.last %},{% endif %}
         {%- endfor %}
     ) : {{ type_name }} {}
@@ -98,7 +98,7 @@ public override int AllocationSize({{ type_name }} value) {
             case {{ type_name }}.{{ variant.name()|class_name(ci) }} variant_value:
                 return 4
                     {%- for field in variant.fields() %}
-                    {%- let field_name = field.name()|or_pos_var(loop.index)|var_name %}
+                    {%- let field_name = field.name()|or_pos_var(loop.index)|property_name %}
                     + {{ field|allocation_size_fn }}(variant_value.{{ field_name }})
                     {%- endfor %};
             {%- endfor %}
@@ -113,7 +113,7 @@ public override void Write({{ type_name }} value, BigEndianStream stream) {
             case {{ type_name }}.{{ variant.name()|class_name(ci) }} variant_value:
                 stream.WriteInt({{ loop.index }});
                 {%- for field in variant.fields() %}
-                {%- let field_name = field.name()|or_pos_var(loop.index)|var_name %}
+                {%- let field_name = field.name()|or_pos_var(loop.index)|property_name %}
                 {{ field|write_fn }}(variant_value.{{ field_name }}, stream);
                 {%- endfor %}
                 break;
diff --git a/bindgen/templates/RecordTemplate.cs b/bindgen/templates/RecordTemplate.cs
@@ -29,7 +29,7 @@
 {{ config.access_modifier() }} record {{ type_name }} (
     {%- for field in ordered_fields %}
     {%- call cs::docstring(field, 4) %}
-    {{ field|type_name(ci) }} {{ field.name()|var_name -}}
+    {{ field|type_name(ci) }} {{ field.name()|property_name -}}
     {%- match field.default_value() %}
         {%- when Some with(literal) %} = {{ literal|render_literal(field, ci) }}
         {%- else %}
@@ -50,21 +50,21 @@ class {{ rec|ffi_converter_name }}: FfiConverterRustBuffer<{{ type_name }}> {
     public override {{ type_name }} Read(BigEndianStream stream) {
         return new {{ type_name }}(
         {%- for field in rec.fields() %}
-            {{ field.name()|var_name }}: {{ field|read_fn }}(stream){% if !loop.last %},{% endif%}
+            {{ field.name()|property_name }}: {{ field|read_fn }}(stream){% if !loop.last %},{% endif%}
         {%- endfor %}
         );
     }
 
     public override int AllocationSize({{ type_name }} value) {
         return 0
         {%- for field in rec.fields() %}
-            + {{ field|allocation_size_fn }}(value.{{ field.name()|var_name }})
+            + {{ field|allocation_size_fn }}(value.{{ field.name()|property_name }})
         {%- endfor -%};
     }
 
     public override void Write({{ type_name }} value, BigEndianStream stream) {
         {%- for field in rec.fields() %}
-            {{ field|write_fn }}(value.{{ field.name()|var_name }}, stream);
+            {{ field|write_fn }}(value.{{ field.name()|property_name }}, stream);
         {%- endfor %}
     }
 }
diff --git a/bindgen/templates/macros.cs b/bindgen/templates/macros.cs
@@ -124,7 +124,7 @@
 {%- macro destroy_fields(member, prefix) %}
     FFIObjectUtil.DisposeAll(
         {%- for field in member.fields() %}
-            {{ prefix }}.{{ field.name()|var_name }}{% if !loop.last %},{% endif %}
+            {{ prefix }}.{{ field.name()|property_name }}{% if !loop.last %},{% endif %}
         {%- endfor %});
 {%- endmacro -%}
 
diff --git a/dotnet-tests/UniffiCS.BindingTests/OptionalParameterTests.cs b/dotnet-tests/UniffiCS.BindingTests/OptionalParameterTests.cs
@@ -12,15 +12,15 @@ public class OptionalParameterTests
     [Fact]
     public void OptionalParameter_CanBeOmitted()
     {
-        var person = new Person(isSpecial: false);
+        var person = new Person(IsSpecial: false);
         string message = Hello(person);
         Assert.Equal("Hello stranger!", message);
     }
 
     [Fact]
     public void OptionalParameter_CanBeSpecified()
     {
-        var person = new Person(name: "John Connor", isSpecial: false);
+        var person = new Person(Name: "John Connor", IsSpecial: false);
         string message = Hello(person);
         Assert.Equal("Hello John Connor!", message);
     }
diff --git a/dotnet-tests/UniffiCS.BindingTests/TestCoverall.cs b/dotnet-tests/UniffiCS.BindingTests/TestCoverall.cs
@@ -31,27 +31,27 @@ public void TestCreateSomeDict()
     {
         using (var d = CoverallMethods.CreateSomeDict())
         {
-            Assert.Equal("text", d.text);
-            Assert.Equal("maybe_text", d.maybeText);
-            Assert.True(d.aBool);
-            Assert.False(d.maybeABool);
-            Assert.Equal((byte)1, d.unsigned8);
-            Assert.Equal((byte)2, d.maybeUnsigned8);
-            Assert.Equal((ushort)3, d.unsigned16);
-            Assert.Equal((ushort)4, d.maybeUnsigned16);
-            Assert.Equal(18446744073709551615UL, d.unsigned64);
-            Assert.Equal(0ul, d.maybeUnsigned64);
-            Assert.Equal((sbyte)8, d.signed8);
-            Assert.Equal((sbyte)0, d.maybeSigned8);
-            Assert.Equal(9223372036854775807L, d.signed64);
-            Assert.Equal(0L, d.maybeSigned64);
-
-            Assert.Equal(1.2345f, d.float32);
-            Assert.Equal(22.0f / 7.0f, d.maybeFloat32);
-            Assert.Equal(0.0, d.float64);
-            Assert.Equal(1.0, d.maybeFloat64);
-
-            Assert.Equal("some_dict", d.coveralls!.GetName());
+            Assert.Equal("text", d.Text);
+            Assert.Equal("maybe_text", d.MaybeText);
+            Assert.True(d.ABool);
+            Assert.False(d.MaybeABool);
+            Assert.Equal((byte)1, d.Unsigned8);
+            Assert.Equal((byte)2, d.MaybeUnsigned8);
+            Assert.Equal((ushort)3, d.Unsigned16);
+            Assert.Equal((ushort)4, d.MaybeUnsigned16);
+            Assert.Equal(18446744073709551615UL, d.Unsigned64);
+            Assert.Equal(0ul, d.MaybeUnsigned64);
+            Assert.Equal((sbyte)8, d.Signed8);
+            Assert.Equal((sbyte)0, d.MaybeSigned8);
+            Assert.Equal(9223372036854775807L, d.Signed64);
+            Assert.Equal(0L, d.MaybeSigned64);
+
+            Assert.Equal(1.2345f, d.Float32);
+            Assert.Equal(22.0f / 7.0f, d.MaybeFloat32);
+            Assert.Equal(0.0, d.Float64);
+            Assert.Equal(1.0, d.MaybeFloat64);
+
+            Assert.Equal("some_dict", d.Coveralls!.GetName());
         }
     }
 
@@ -162,7 +162,7 @@ public void TestErrorValues()
 
             var complexError = CoverallMethods.GetComplexError(null);
             Assert.True(complexError is ComplexException.PermissionDenied);
-            Assert.Null(CoverallMethods.GetErrorDict(null).complexError);
+            Assert.Null(CoverallMethods.GetErrorDict(null).ComplexError);
         }
     }
 
@@ -378,14 +378,14 @@ public void TestStringUtil()
     public void TestDictWithDefaults()
     {
         var d = new DictWithDefaults();
-        Assert.Equal("default-value", d.name);
-        Assert.Equal(31UL, d.integer);
-        Assert.Null(d.category);
+        Assert.Equal("default-value", d.Name);
+        Assert.Equal(31UL, d.Integer);
+        Assert.Null(d.Category);
 
         var d1 = new DictWithDefaults("this", "that", 42UL);
-        Assert.Equal("this", d1.name);
-        Assert.Equal("that", d1.category);
-        Assert.Equal(42UL, d1.integer);
+        Assert.Equal("this", d1.Name);
+        Assert.Equal("that", d1.Category);
+        Assert.Equal(42UL, d1.Integer);
     }
 
     [Fact]
diff --git a/dotnet-tests/UniffiCS.BindingTests/TestCustomTypes.cs b/dotnet-tests/UniffiCS.BindingTests/TestCustomTypes.cs
@@ -14,15 +14,15 @@ public void CustomTypesWork()
     {
         var demo = CustomTypesMethods.GetCustomTypesDemo(null);
 
-        Assert.Equal("http://example.com/", demo.url);
-        Assert.Equal(123, demo.handle);
+        Assert.Equal("http://example.com/", demo.Url);
+        Assert.Equal(123, demo.Handle);
 
         // Change some data and ensure that the round-trip works
         demo = demo with
         {
-            url = "http://new.example.com/"
+            Url = "http://new.example.com/"
         };
-        demo = demo with { handle = 456 };
+        demo = demo with { Handle = 456 };
         Assert.Equal(demo, CustomTypesMethods.GetCustomTypesDemo(demo));
     }
 }
diff --git a/dotnet-tests/UniffiCS.BindingTests/TestCustomTypesBuiltin.cs b/dotnet-tests/UniffiCS.BindingTests/TestCustomTypesBuiltin.cs
@@ -22,19 +22,19 @@ public void CustomTypesWork()
 
     void AssertDemo(CustomTypesBuiltin demo)
     {
-        Assert.Equal("Hello, world!", demo.@string);
-        Assert.Equal(new List<String> { "Hello, world!" }, demo.array);
-        Assert.Equal(new Dictionary<String, String> { { "hello", "world" } }, demo.table);
-        Assert.True(demo.boolean);
-        Assert.Equal(SByte.MaxValue, demo.int8);
-        Assert.Equal(Int16.MaxValue, demo.int16);
-        Assert.Equal(Int32.MaxValue, demo.int32);
-        Assert.Equal(Int64.MaxValue, demo.int64);
-        Assert.Equal(Byte.MaxValue, demo.uint8);
-        Assert.Equal(UInt16.MaxValue, demo.uint16);
-        Assert.Equal(UInt32.MaxValue, demo.uint32);
-        Assert.Equal(UInt64.MaxValue, demo.uint64);
-        Assert.Equal(Single.MaxValue, demo.@float);
-        Assert.Equal(Double.MaxValue, demo.@double);
+        Assert.Equal("Hello, world!", demo.@String);
+        Assert.Equal(new List<String> { "Hello, world!" }, demo.Array);
+        Assert.Equal(new Dictionary<String, String> { { "hello", "world" } }, demo.Table);
+        Assert.True(demo.Boolean);
+        Assert.Equal(SByte.MaxValue, demo.Int8);
+        Assert.Equal(Int16.MaxValue, demo.Int16);
+        Assert.Equal(Int32.MaxValue, demo.Int32);
+        Assert.Equal(Int64.MaxValue, demo.Int64);
+        Assert.Equal(Byte.MaxValue, demo.Uint8);
+        Assert.Equal(UInt16.MaxValue, demo.Uint16);
+        Assert.Equal(UInt32.MaxValue, demo.Uint32);
+        Assert.Equal(UInt64.MaxValue, demo.Uint64);
+        Assert.Equal(Single.MaxValue, demo.@Float);
+        Assert.Equal(Double.MaxValue, demo.@Double);
     }
 }
diff --git a/dotnet-tests/UniffiCS.BindingTests/TestDocstring.cs b/dotnet-tests/UniffiCS.BindingTests/TestDocstring.cs
@@ -43,7 +43,7 @@ public void DocstringWorks()
         obj2.Test();
 
         var record = new RecordTest(123);
-        _ = record.test;
+        _ = record.Test;
 
         CallbackTest callback = new CallbackImpls();
         callback.Test();
diff --git a/dotnet-tests/UniffiCS.BindingTests/TestFutures.cs b/dotnet-tests/UniffiCS.BindingTests/TestFutures.cs
@@ -234,8 +234,8 @@ public async Task TestRecord() {
         for (int i = 0; i < 1000; i++) {
             await ReturnsImmediately(async () => {
                 var record = await FuturesMethods.NewMyRecord("foo", 42U);
-                Assert.Equal("foo", record.a);
-                Assert.Equal(42U, record.b);
+                Assert.Equal("foo", record.A);
+                Assert.Equal(42U, record.B);
             });
         }
     }
diff --git a/dotnet-tests/UniffiCS.BindingTests/TestIssue110.cs b/dotnet-tests/UniffiCS.BindingTests/TestIssue110.cs
@@ -12,6 +12,6 @@ public class ClassIssue110
     public void TestIssue110()
     {
         var @string = new Value.String("test");
-        Assert.Equal("test", @string.value);
+        Assert.Equal("test", @string.Value);
     }
 }
diff --git a/dotnet-tests/UniffiCS.BindingTests/TestIssue152.cs b/dotnet-tests/UniffiCS.BindingTests/TestIssue152.cs
@@ -0,0 +1,61 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+using uniffi.issue_152;
+
+namespace UniffiCS.BindingTests;
+
+public class ClassIssue152
+{
+    [Fact]
+    public void RecordPropertyNamesArePascalCase()
+    {
+        // Create a person using the constructor with PascalCase property names
+        var person = new Person(
+            FirstName: "John",
+            LastName: "Doe",
+            Age: 30
+        );
+
+        // Access properties using PascalCase (no @ prefix needed)
+        Assert.Equal("John", person.FirstName);
+        Assert.Equal("Doe", person.LastName);
+        Assert.Equal(30u, person.Age);
+    }
+
+    [Fact]
+    public void RecordRoundtripWorks()
+    {
+        // Create via helper function and verify round-trip
+        var person = Issue152Methods.CreatePerson("Jane", "Smith", 25);
+
+        Assert.Equal("Jane", person.FirstName);
+        Assert.Equal("Jane", Issue152Methods.GetFirstName(person));
+    }
+
+    [Fact]
+    public void KeywordFieldsUseAtPrefix()
+    {
+        // Fields that become C# keywords when PascalCased should have @ prefix
+        var fields = new KeywordFields(
+            @Event: "click",
+            @Class: "button",
+            Name: "submit"
+        );
+
+        // Access using @ prefix for keywords
+        Assert.Equal("click", fields.@Event);
+        Assert.Equal("button", fields.@Class);
+        Assert.Equal("submit", fields.Name);
+    }
+
+    [Fact]
+    public void KeywordFieldsRoundtripWorks()
+    {
+        var fields = Issue152Methods.CreateKeywordFields("hover", "link", "nav");
+
+        Assert.Equal("hover", fields.@Event);
+        Assert.Equal("hover", Issue152Methods.GetEvent(fields));
+    }
+}
diff --git a/dotnet-tests/UniffiCS.BindingTests/TestPositionalEnums.cs b/dotnet-tests/UniffiCS.BindingTests/TestPositionalEnums.cs
@@ -12,10 +12,10 @@ public class TestPositionalEnums
     public void PositionalEnumsWork()
     {
         var good = new PositionalEnum.GoodVariant("Hi good");
-        Assert.Equal("Hi good", good.v1);
-        
+        Assert.Equal("Hi good", good.V1);
+
         var nice = new PositionalEnum.NiceVariant(10, "Hi nice");
-        Assert.Equal(10, nice.v1);
-        Assert.Equal("Hi nice", nice.v2);
+        Assert.Equal(10, nice.V1);
+        Assert.Equal("Hi nice", nice.V2);
     }
 }
diff --git a/dotnet-tests/UniffiCS.BindingTests/TestRondpoint.cs b/dotnet-tests/UniffiCS.BindingTests/TestRondpoint.cs
diff --git a/dotnet-tests/UniffiCS.BindingTests/TestTodoList.cs b/dotnet-tests/UniffiCS.BindingTests/TestTodoList.cs
diff --git a/fixtures/Cargo.toml b/fixtures/Cargo.toml
diff --git a/fixtures/regressions/issue-152/Cargo.toml b/fixtures/regressions/issue-152/Cargo.toml
diff --git a/fixtures/regressions/issue-152/README.md b/fixtures/regressions/issue-152/README.md
diff --git a/fixtures/regressions/issue-152/src/lib.rs b/fixtures/regressions/issue-152/src/lib.rs
diff --git a/fixtures/src/lib.rs b/fixtures/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -12,15 +12,15 @@ public class OptionalParameterTests`
`12`	`12`	`[Fact]`
`13`	`13`	`public void OptionalParameter_CanBeOmitted()`
`14`	`14`	`{`
`15`		`- var person = new Person(isSpecial: false);`
	`15`	`+ var person = new Person(IsSpecial: false);`
`16`	`16`	`string message = Hello(person);`
`17`	`17`	`Assert.Equal("Hello stranger!", message);`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`[Fact]`
`21`	`21`	`public void OptionalParameter_CanBeSpecified()`
`22`	`22`	`{`
`23`		`- var person = new Person(name: "John Connor", isSpecial: false);`
	`23`	`+ var person = new Person(Name: "John Connor", IsSpecial: false);`
`24`	`24`	`string message = Hello(person);`
`25`	`25`	`Assert.Equal("Hello John Connor!", message);`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,15 +14,15 @@ public void CustomTypesWork()`
`14`	`14`	`{`
`15`	`15`	`var demo = CustomTypesMethods.GetCustomTypesDemo(null);`
`16`	`16`
`17`		`- Assert.Equal("http://example.com/", demo.url);`
`18`		`- Assert.Equal(123, demo.handle);`
	`17`	`+ Assert.Equal("http://example.com/", demo.Url);`
	`18`	`+ Assert.Equal(123, demo.Handle);`
`19`	`19`
`20`	`20`	`// Change some data and ensure that the round-trip works`
`21`	`21`	`demo = demo with`
`22`	`22`	`{`
`23`		`- url = "http://new.example.com/"`
	`23`	`+ Url = "http://new.example.com/"`
`24`	`24`	`};`
`25`		`- demo = demo with { handle = 456 };`
	`25`	`+ demo = demo with { Handle = 456 };`
`26`	`26`	`Assert.Equal(demo, CustomTypesMethods.GetCustomTypesDemo(demo));`
`27`	`27`	`}`
`28`	`28`	`}`