Merge pull request #571 from icsharpcode/issue/569/winforms-names

Winforms control names

Author: GrahamTheCoder

CodeConverter/CSharp/AdditionalInitializers.cs

@@ -5,19 +5,18 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using ExpressionSyntax = Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax;
 
 namespace ICSharpCode.CodeConverter.CSharp
 {
-    public class AdditionalInitializers
+    internal class AdditionalInitializers
     {
         public AdditionalInitializers(bool shouldAddTypeWideInitToThisPart)
         {
             ShouldAddTypeWideInitToThisPart = shouldAddTypeWideInitToThisPart;
         }
 
-        public List<(ExpressionSyntax Field, SyntaxKind AssignmentKind, ExpressionSyntax Initializer)> AdditionalStaticInitializers { get; } = new List<(ExpressionSyntax, SyntaxKind, ExpressionSyntax)>();
-        public List<(ExpressionSyntax Field, SyntaxKind AssignmentKind, ExpressionSyntax Initializer)> AdditionalInstanceInitializers { get; } = new List<(ExpressionSyntax, SyntaxKind, ExpressionSyntax)>();
+        public List<Assignment> AdditionalStaticInitializers { get; } = new List<Assignment>();
+        public List<Assignment> AdditionalInstanceInitializers { get; } = new List<Assignment>();
         public bool ShouldAddTypeWideInitToThisPart { get; }
 
         public IReadOnlyCollection<MemberDeclarationSyntax> WithAdditionalInitializers(ITypeSymbol parentType,
@@ -40,7 +39,7 @@ public IReadOnlyCollection<MemberDeclarationSyntax> WithAdditionalInitializers(I
         }
 
         private List<MemberDeclarationSyntax> WithAdditionalInitializers(List<MemberDeclarationSyntax> convertedMembers,
-            SyntaxToken convertIdentifier, IReadOnlyCollection<(ExpressionSyntax Field, SyntaxKind AssignmentKind, ExpressionSyntax Initializer)> additionalInitializers,
+            SyntaxToken convertIdentifier, IReadOnlyCollection<Assignment> additionalInitializers,
             SyntaxTokenList modifiers, IEnumerable<ConstructorDeclarationSyntax> constructorsEnumerable, bool addConstructor, bool addedConstructorRequiresInitializeComponent)
         {
             if (!additionalInitializers.Any() && (!addConstructor || !addedConstructorRequiresInitializeComponent)) return convertedMembers;
@@ -64,17 +63,23 @@ private List<MemberDeclarationSyntax> WithAdditionalInitializers(List<MemberDecl
         }
 
         private ConstructorDeclarationSyntax WithAdditionalInitializers(ConstructorDeclarationSyntax oldConstructor,
-            IReadOnlyCollection<(ExpressionSyntax Field, SyntaxKind AssignmentKind, ExpressionSyntax Initializer)> additionalConstructorAssignments)
+            IReadOnlyCollection<Assignment> additionalConstructorAssignments)
         {
-            var initializerStatements = additionalConstructorAssignments.Select(assignment =>
-                SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(
-                    assignment.AssignmentKind, assignment.Field, assignment.Initializer))
-            ).ToList();
+            var preInitializerStatements = CreateAssignmentStatement(additionalConstructorAssignments.Where(x => !x.PostAssignment));
+            var postInitializerStatements = CreateAssignmentStatement(additionalConstructorAssignments.Where(x => x.PostAssignment));
             var oldConstructorBody = oldConstructor.Body ?? SyntaxFactory.Block(SyntaxFactory.ExpressionStatement(oldConstructor.ExpressionBody.Expression));
             var newConstructor = oldConstructor.WithBody(oldConstructorBody.WithStatements(
-                oldConstructorBody.Statements.InsertRange(0, initializerStatements)));
+                oldConstructorBody.Statements.InsertRange(0, preInitializerStatements).AddRange(postInitializerStatements)));
 
             return newConstructor;
         }
+
+        private static List<ExpressionStatementSyntax> CreateAssignmentStatement(IEnumerable<Assignment> additionalConstructorAssignments)
+        {
+            return additionalConstructorAssignments.Select(assignment =>
+                            SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(
+                                assignment.AssignmentKind, assignment.Field, assignment.Initializer))
+                        ).ToList();
+        }
     }
 }

CodeConverter/CSharp/Assignment.cs

@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace ICSharpCode.CodeConverter.CSharp
+{
+    internal struct Assignment
+    {
+        public ExpressionSyntax Field;
+        public SyntaxKind AssignmentKind;
+        public ExpressionSyntax Initializer;
+        public bool PostAssignment;
+
+        public Assignment(ExpressionSyntax field, SyntaxKind assignmentKind, ExpressionSyntax initializer, bool postAssignment = false)
+        {
+            Field = field;
+            AssignmentKind = assignmentKind;
+            Initializer = initializer;
+            PostAssignment = postAssignment;
+        }
+
+        public override bool Equals(object obj) => obj is Assignment other &&
+                   (other.Field, other.AssignmentKind, other.Initializer, other.PostAssignment).Equals((Field, AssignmentKind, Initializer, PostAssignment));
+
+
+        public override int GetHashCode() => (Field, AssignmentKind, Initializer, PostAssignment).GetHashCode();
+
+        public void Deconstruct(out ExpressionSyntax field, out SyntaxKind assignmentKind, out ExpressionSyntax initializer)
+        {
+            field = Field;
+            assignmentKind = AssignmentKind;
+            initializer = Initializer;
+        }
+
+        public static implicit operator Assignment((ExpressionSyntax Field, SyntaxKind AssignmentKind, ExpressionSyntax Initializer) value)
+        {
+            return new Assignment(value.Field, value.AssignmentKind, value.Initializer);
+        }
+    }
+}

CodeConverter/CSharp/CommonConversions.cs

@@ -283,7 +283,7 @@ public SyntaxToken ConvertIdentifier(SyntaxToken id, bool isAttribute = false, S
                         text = 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 (MustInlinePropertyWithEventsAccess(id.Parent, idSymbol)) {
+                    } else if (WinformsConversions.MustInlinePropertyWithEventsAccess(id.Parent, idSymbol)) {
                         // For C# Winforms designer, we need to use direct field access - see other usage of MustInlinePropertyWithEventsAccess
                         text = "_" + text;
                     }
@@ -317,20 +317,6 @@ private static string WithDeclarationCasing(SyntaxToken id, ISymbol idSymbol, st
             return text;
         }
 
-        /// <remarks>
-        /// Co-ordinates inlining property events, see <see cref="MethodBodyExecutableStatementVisitor.GetPostAssignmentStatements"/>
-        /// Also see usages of IsDesignerGeneratedTypeWithInitializeComponent
-        /// </remarks>
-        public static bool MustInlinePropertyWithEventsAccess(SyntaxNode anyNodePossiblyWithinMethod, ISymbol potentialPropertySymbol)
-        {
-            return InMethodCalledInitializeComponent(anyNodePossiblyWithinMethod) && potentialPropertySymbol is IPropertySymbol prop && prop.IsWithEvents;
-        }
-
-        public static bool InMethodCalledInitializeComponent(SyntaxNode anyNodePossiblyWithinMethod)
-        {
-            return anyNodePossiblyWithinMethod.GetAncestor<VBSyntax.MethodBlockSyntax>()?.SubOrFunctionStatement.Identifier.Text == "InitializeComponent";
-        }
-
         public static SyntaxToken CsEscapedIdentifier(string text)
         {
             if (SyntaxFacts.GetKeywordKind(text) != CSSyntaxKind.None) text = "@" + text;

CodeConverter/CSharp/DeclarationNodeVisitor.cs

@@ -206,11 +206,17 @@ private async Task<IEnumerable<MemberDeclarationSyntax>> ConvertMembersAsync(VBS
             var requiresInitializeComponent = namedTypeSymbol.IsDesignerGeneratedTypeWithInitializeComponent(_vbCompilation);
 
             if (shouldAddTypeWideInitToThisPart) {
-                var constructorFieldInitializersFromOtherParts = GetConstructorFieldInitializersFromOtherParts(namedTypeSymbol);
+                var otherPartsOfType = GetAllPartsOfType(parentType, namedTypeSymbol).ToArray();
+                var constructorFieldInitializersFromOtherParts = otherPartsOfType
+                    .Where(t => (!Equals(t.Type.SyntaxTree.FilePath, _semanticModel.SyntaxTree.FilePath) || !t.Type.Span.Equals(parentType.Span)))
+                    .SelectMany(r => GetFieldsIdentifiersWithInitializer(r.Type, r.SemanticModel));
                 additionalInitializers.AdditionalInstanceInitializers.AddRange(constructorFieldInitializersFromOtherParts);
                 if (requiresInitializeComponent) {
                     // Constructor event handlers not required since they'll be inside InitializeComponent - see other use of IsDesignerGeneratedTypeWithInitializeComponent
-                    directlyConvertedMembers = directlyConvertedMembers.Concat(methodsWithHandles.CreateDelegatingMethodsRequiredByInitializeComponent());
+                    directlyConvertedMembers = directlyConvertedMembers
+                        .Concat(methodsWithHandles.CreateDelegatingMethodsRequiredByInitializeComponent());
+                    additionalInitializers.AdditionalInstanceInitializers
+                        .AddRange(WinformsConversions.GetNameAssignments(otherPartsOfType));
                 } else {
                     additionalInitializers.AdditionalInstanceInitializers.AddRange(methodsWithHandles.GetConstructorEventHandlers());
                 }
@@ -231,24 +237,23 @@ async Task<MemberDeclarationSyntax[]> GetDirectlyConvertedMembers(AdditionalInit
             }
         }
 
-        private IEnumerable<(ExpressionSyntax, CSSyntaxKind SimpleAssignmentExpression, ExpressionSyntax)> GetConstructorFieldInitializersFromOtherParts(ITypeSymbol parentType)
+        private IEnumerable<(VBSyntax.TypeBlockSyntax Type, SemanticModel SemanticModel)> GetAllPartsOfType(VBSyntax.TypeBlockSyntax parentTypeBlock, ITypeSymbol parentType)
         {
             return parentType.DeclaringSyntaxReferences
-                .Where(r => !Equals(r.SyntaxTree.FilePath, _semanticModel.SyntaxTree.FilePath))
-                .Select(t => (Type: t.GetSyntax().Parent as VBSyntax.TypeBlockSyntax, SemanticModel: _vbCompilation.GetSemanticModel(t.SyntaxTree)))
-                .Where(t => t.Type != null)
-                .SelectMany(r => GetFieldsIdentifiersWithInitializer(r.Type, r.SemanticModel));
+                            .Select(t => t.GetSyntax().Parent as VBSyntax.TypeBlockSyntax)
+                            .Where(t => t != null)
+                            .Select(t => (Type: t, SemanticModel: _vbCompilation.GetSemanticModel(t.SyntaxTree)));
         }
 
-        private IEnumerable<(ExpressionSyntax, CSSyntaxKind SimpleAssignmentExpression, ExpressionSyntax)> GetFieldsIdentifiersWithInitializer(VBSyntax.TypeBlockSyntax tbs, SemanticModel semanticModel)
+        private IEnumerable<Assignment> GetFieldsIdentifiersWithInitializer(VBSyntax.TypeBlockSyntax tbs, SemanticModel semanticModel)
         {
             return tbs.Members.OfType<VBSyntax.FieldDeclarationSyntax>()
                 .SelectMany(f => f.Declarators.SelectMany(d => d.Names.Select(n => (n, d.Initializer))))
                 .Where(f => !semanticModel.IsDefinitelyStatic(f.n, f.Initializer?.Value))
                 .Select(f => CreateInitializer(f));
         }
 
-        private (ExpressionSyntax, CSSyntaxKind SimpleAssignmentExpression, ExpressionSyntax) CreateInitializer((VBSyntax.ModifiedIdentifierSyntax n, VBSyntax.EqualsValueSyntax Initializer) f)
+        private Assignment CreateInitializer((VBSyntax.ModifiedIdentifierSyntax n, VBSyntax.EqualsValueSyntax Initializer) f)
         {
             var csId = CommonConversions.ConvertIdentifier(f.n.Identifier);
             string initializerFunctionName = CommonConversions.GetInitialValueFunctionName(f.n);

CodeConverter/CSharp/ExpressionNodeVisitor.cs

@@ -276,13 +276,9 @@ public override async Task<CSharpSyntaxNode> VisitLiteralExpression(VBasic.Synta
 
             var val = node.Token.Value;
             var text = node.Token.Text;
-            if (node.Parent is VBSyntax.AssignmentStatementSyntax assignment && CommonConversions.InMethodCalledInitializeComponent(node.Parent) &&
-                assignment.Left is VBSyntax.MemberAccessExpressionSyntax maes && !(maes.Expression is VBSyntax.MeExpressionSyntax) &&
-                maes.Name.ToString() == "Name" &&
-                val is string valStr) {
-                    // Update name so field is regenerated correctly by winforms designer
-                    val = "_" + valStr;
-                    text = "\"_" + valStr + "\"";
+            if (WinformsConversions.ShouldPrefixAssignedNameWithUnderscore(node.Parent as VBSyntax.AssignmentStatementSyntax) && val is string valStr) {
+                val = "_" + valStr;
+                text = "\"_" + valStr + "\"";
             }
 
             return CommonConversions.Literal(val, text, convertedType);

CodeConverter/CSharp/MethodWithHandles.cs

@@ -11,7 +11,7 @@
 
 namespace ICSharpCode.CodeConverter.CSharp
 {
-    public class MethodWithHandles
+    internal class MethodWithHandles
     {
         private IdentifierNameSyntax _methodId;
         private readonly SyntaxGenerator _csSyntaxGenerator;
@@ -173,10 +173,10 @@ private static ExpressionSyntax MemberAccess(ExpressionSyntax eventSource, (Synt
                             eventSource, SyntaxFactory.IdentifierName(e.EventSymbolName));
         }
 
-        public IEnumerable<(ExpressionSyntax EventField, SyntaxKind AssignmentKind, ExpressionSyntax HandlerId)> GetConstructorEventHandlers()
+        public IEnumerable<Assignment> GetConstructorEventHandlers()
         {
             return HandledClassEventCSharpIds.Select(e =>
-                (MemberAccess(SyntaxFactory.IdentifierName(e.EventContainerName), e), SyntaxKind.AddAssignmentExpression, Invocable(_methodId, e.ParametersToDiscard))
+                new Assignment(MemberAccess(SyntaxFactory.IdentifierName(e.EventContainerName), e), SyntaxKind.AddAssignmentExpression, Invocable(_methodId, e.ParametersToDiscard))
             );
         }
 

CodeConverter/CSharp/MethodsWithHandles.cs

@@ -47,7 +47,7 @@ public IEnumerable<MemberDeclarationSyntax> GetDeclarationsForFieldBackedPropert
         /// </summary>
         public SyntaxList<StatementSyntax> GetPostAssignmentStatements(Microsoft.CodeAnalysis.VisualBasic.Syntax.AssignmentStatementSyntax node, ISymbol potentialPropertySymbol)
         {
-            if (CommonConversions.MustInlinePropertyWithEventsAccess(node, potentialPropertySymbol))
+            if (WinformsConversions.MustInlinePropertyWithEventsAccess(node, potentialPropertySymbol))
             {
                 var fieldName = SyntaxFactory.IdentifierName("_" + potentialPropertySymbol.Name);
                 var handledMethods = _handledMethodsFromPropertyWithEventName[potentialPropertySymbol.Name].ToArray();
@@ -67,7 +67,7 @@ public IEnumerable<StatementSyntax> GetInitializeComponentClassEventHandlers()
             return _methodWithHandleses.SelectMany(m => m.GetInitializeComponentClassEventHandlers()).ToArray();
         }
 
-        public (ExpressionSyntax EventField, SyntaxKind AssignmentKind, ExpressionSyntax HandlerId)[] GetConstructorEventHandlers()
+        public Assignment[] GetConstructorEventHandlers()
         {
             return _methodWithHandleses.SelectMany(m => m.GetConstructorEventHandlers()).ToArray();
         }

CodeConverter/CSharp/WinformsConversions.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ICSharpCode.CodeConverter.Util;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using VBasic = Microsoft.CodeAnalysis.VisualBasic;
+using VBSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax;
+
+namespace ICSharpCode.CodeConverter.CSharp
+{
+    internal static class WinformsConversions
+    {
+        /// <remarks>
+        /// Co-ordinates inlining property events, see <see cref="MethodBodyExecutableStatementVisitor.GetPostAssignmentStatements"/>
+        /// Also see usages of IsDesignerGeneratedTypeWithInitializeComponent
+        /// </remarks>
+        public static bool MustInlinePropertyWithEventsAccess(SyntaxNode anyNodePossiblyWithinMethod, ISymbol potentialPropertySymbol)
+        {
+            return InMethodCalledInitializeComponent(anyNodePossiblyWithinMethod) && potentialPropertySymbol is IPropertySymbol prop && prop.IsWithEvents;
+        }
+
+        public static bool InMethodCalledInitializeComponent(SyntaxNode anyNodePossiblyWithinMethod)
+        {
+            var methodBlockSyntax = anyNodePossiblyWithinMethod.GetAncestor<VBSyntax.MethodBlockSyntax>();
+            return IsInitializeComponent(methodBlockSyntax);
+        }
+
+        private static bool IsInitializeComponent(VBSyntax.MethodBlockSyntax methodBlockSyntax)
+        {
+            return methodBlockSyntax?.SubOrFunctionStatement.Identifier.Text == "InitializeComponent";
+        }
+
+        /// <summary>
+        /// We replace a field with a property to handle event subscription, so need to update the name so the winforms designer regenerates the file correctly in future
+        /// </summary>
+        /// <returns></returns>
+        public static bool ShouldPrefixAssignedNameWithUnderscore(VBSyntax.StatementSyntax statementOrNull)
+        {
+            return statementOrNull is VBSyntax.AssignmentStatementSyntax assignment && InMethodCalledInitializeComponent(assignment) &&
+                            assignment.Left is VBSyntax.MemberAccessExpressionSyntax maes &&
+                                !(maes.Expression is VBSyntax.MeExpressionSyntax) &&
+                            maes.Name.ToString() == "Name";
+        }
+
+        private static T LastOrDefaultDescendant<T>(this VBasic.VisualBasicSyntaxNode syntaxNode) {
+            return syntaxNode.DescendantNodes().OfType<T>().LastOrDefault();
+        }
+
+        internal static IEnumerable<Assignment> GetNameAssignments((VBSyntax.TypeBlockSyntax Type, SemanticModel SemanticModel)[] otherPartsOfType)
+        {
+            return otherPartsOfType.SelectMany(typePart => 
+                typePart.Type.Members.OfType<VBSyntax.MethodBlockSyntax>()
+                    .Where(IsInitializeComponent)
+                    .SelectMany(GetAssignments)
+            );
+        }
+
+        private static IEnumerable<Assignment> GetAssignments(VBSyntax.MethodBlockSyntax initializeComponent)
+        {
+            return initializeComponent.Statements
+                .OfType<VBSyntax.AssignmentStatementSyntax>()
+                .Where(ShouldPrefixAssignedNameWithUnderscore)
+                .Select(s => (s.Left as VBSyntax.MemberAccessExpressionSyntax)?.Expression.LastOrDefaultDescendant<VBSyntax.IdentifierNameSyntax>())
+                .Where(s => s != null)
+                .Select(id => {
+                    var nameAccess = ValidSyntaxFactory.MemberAccess(SyntaxFactory.IdentifierName("_" + id.Identifier.Text), "Name");
+                    var originalRuntimeNameToRestore = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(id.Identifier.Text));
+                    return new Assignment(nameAccess, SyntaxKind.SimpleAssignmentExpression, originalRuntimeNameToRestore, true);
+                });
+        }
+    }
+}

Tests/CSharp/MemberTests/EventMemberTests.cs

@@ -525,6 +525,7 @@ public partial class TestHandlesAdded
     public TestHandlesAdded()
     {
         InitializeComponent();
+        _POW_btnV2DBM.Name = ""POW_btnV2DBM"";
     }
 
     public void InitializeComponent()