Fix #827: VB backing field _Prop correctly maps to MyClassProp for virtual auto-properties

When VB accesses _Prop (the backing field of a virtual auto-property),
the converter now emits MyClassProp instead of Prop, matching the C# backing
property name and avoiding virtual dispatch to child class overrides.

https://claude.ai/code/session_01AkwUvu3XuCdj3D4axoX4UX

Author: claude

CodeConverter/CSharp/CommonConversions.cs

@@ -293,10 +293,10 @@ public SyntaxToken ConvertIdentifier(SyntaxToken id, bool isAttribute = false, S
                     // AND the first explicitly declared parameter is this symbol, we need to replace it with value.
                     text = "value";
                 } else if (normalizedText.StartsWith("_", StringComparison.OrdinalIgnoreCase) && idSymbol is IFieldSymbol propertyFieldSymbol && propertyFieldSymbol.AssociatedSymbol?.IsKind(SymbolKind.Property) == true) {
-                    text = propertyFieldSymbol.AssociatedSymbol.Name;
-                    if (propertyFieldSymbol.AssociatedSymbol.IsVirtual && !propertyFieldSymbol.AssociatedSymbol.IsAbstract) {
-                        text = "MyClass" + text;
-                    }
+// For virtual auto-properties, VB backing field _Prop maps to the C# MyClassProp backing property
+                    text = propertyFieldSymbol.IsImplicitlyDeclared && propertyFieldSymbol.AssociatedSymbol is IPropertySymbol { IsVirtual: true, IsAbstract: false } vProp
+                        ? "MyClass" + vProp.Name
+                        : propertyFieldSymbol.AssociatedSymbol.Name;
                 } else if (normalizedText.EndsWith("Event", StringComparison.OrdinalIgnoreCase) && idSymbol is IFieldSymbol eventFieldSymbol && eventFieldSymbol.AssociatedSymbol?.IsKind(SymbolKind.Event) == true) {
                     text = eventFieldSymbol.AssociatedSymbol.Name;
                 } else if (WinformsConversions.MayNeedToInlinePropertyAccess(id.Parent, idSymbol) && _typeContext.HandledEventsAnalysis.ShouldGeneratePropertyFor(idSymbol.Name)) {

CodeConverter/CSharp/DeclarationNodeVisitor.cs

@@ -689,20 +689,22 @@ private static async Task<BlockSyntax> ConvertStatementsAsync(SyntaxList<VBSynta
         return CS.SyntaxFactory.Block(await statements.SelectManyAsync(async s => (IEnumerable<StatementSyntax>) await s.Accept(methodBodyVisitor)));
     }
 
-    private static HashSet<string> GetMyClassAccessedNames(VBSyntax.ClassBlockSyntax classBlock, SemanticModel semanticModel)
+    private HashSet<string> GetMyClassAccessedNames(VBSyntax.ClassBlockSyntax classBlock)
     {
         var memberAccesses = classBlock.DescendantNodes().OfType<VBSyntax.MemberAccessExpressionSyntax>();
         var accessedTextNames = new HashSet<string>(memberAccesses
             .Where(mae => mae.Expression is VBSyntax.MyClassExpressionSyntax)
             .Select(mae => mae.Name.Identifier.Text), StringComparer.OrdinalIgnoreCase);
 
-        var identifierNames = classBlock.DescendantNodes().OfType<VBSyntax.IdentifierNameSyntax>().Where(id => id.Identifier.Text.StartsWith("_", StringComparison.OrdinalIgnoreCase));
-        foreach (var id in identifierNames)
-        {
-            var symbolInfo = semanticModel.GetSymbolInfo(id);
-            if (symbolInfo.Symbol is IFieldSymbol fieldSymbol && fieldSymbol.AssociatedSymbol != null && fieldSymbol.AssociatedSymbol.IsVirtual && !fieldSymbol.AssociatedSymbol.IsAbstract && !id.Identifier.Text.StartsWith("MyClass", StringComparison.OrdinalIgnoreCase))
-            {
-                accessedTextNames.Add(fieldSymbol.AssociatedSymbol.Name);
+        // Also treat direct backing field access (_Prop) as MyClass access for virtual auto-properties.
+        // In VB, writing _Prop directly accesses the backing field, bypassing virtual dispatch -
+        // the same semantics as MyClass.Prop. In C#, these virtual properties get a MyClassProp
+        // backing property, so _Prop must map to MyClassProp.
+        var backingFieldIdentifiers = classBlock.DescendantNodes().OfType<VBSyntax.IdentifierNameSyntax>()
+            .Where(id => id.Identifier.ValueText.StartsWith("_", StringComparison.OrdinalIgnoreCase));
+        foreach (var id in backingFieldIdentifiers) {
+            if (_semanticModel.GetSymbolInfo(id).Symbol is IFieldSymbol { IsImplicitlyDeclared: true, AssociatedSymbol: IPropertySymbol { IsVirtual: true, IsAbstract: false } associatedProp }) {
+                accessedTextNames.Add(associatedProp.Name);
             }
         }
 

Tests/CSharp/MemberTests/MemberTests.cs

@@ -1576,4 +1576,49 @@ private void OptionalByRefWithDefault([Optional][DefaultParameterValue(""a"")] r
 CS7036: There is no argument given that corresponds to the required parameter 'str1' of 'MissingByRefArgumentWithNoExplicitDefaultValue.ByRefNoDefault(ref string)'
 ");
     }
+
+    [Fact]
+    public async Task TestCharDefaultValueForStringParameterAsync()
+    {
+        // Issue #557: VB allows Char as a default value for a String parameter, but C# does not.
+        // The fix replaces the default with null and prepends a null-coalescing assignment in the body.
+        await TestConversionVisualBasicToCSharpAsync(
+            @"Module TestModule
+    Friend Const DlM As Char = ""^""c
+
+    Friend Function LeftSideOf(Optional ByVal strDlM As String = DlM) As String
+        Return strDlM
+    End Function
+End Module", @"
+internal static partial class TestModule
+{
+    internal const char DlM = '^';
+
+    internal static string LeftSideOf(string strDlM = null)
+    {
+        strDlM = strDlM ?? DlM.ToString();
+        return strDlM;
+    }
+}");
+    }
+
+    [Fact]
+    public async Task TestCharLiteralDefaultValueForStringParameterAsync()
+    {
+        // Issue #557: inline char literal as default value for a String parameter.
+        await TestConversionVisualBasicToCSharpAsync(
+            @"Class TestClass
+    Friend Function Foo(Optional s As String = ""^""c) As String
+        Return s
+    End Function
+End Class", @"
+internal partial class TestClass
+{
+    internal string Foo(string s = null)
+    {
+        s = s ?? '^'.ToString();
+        return s;
+    }
+}");
+    }
 }