Assign names back to their originals - fixes #569

GrahamTheCoder · GrahamTheCoder · commit dffec189b5f1 · 2020-05-10T11:38:16.000+01:00
diff --git a/CodeConverter/CSharp/AdditionalInitializers.cs b/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();
+        }
     }
 }
diff --git a/CodeConverter/CSharp/Assignment.cs b/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);
+        }
+    }
+}
diff --git a/CodeConverter/CSharp/DeclarationNodeVisitor.cs b/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);
diff --git a/CodeConverter/CSharp/MethodWithHandles.cs b/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))
             );
         }
 
diff --git a/CodeConverter/CSharp/MethodsWithHandles.cs b/CodeConverter/CSharp/MethodsWithHandles.cs
@@ -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();
         }
diff --git a/CodeConverter/CSharp/WinformsConversions.cs b/CodeConverter/CSharp/WinformsConversions.cs
@@ -1,6 +1,10 @@
-﻿using System.Linq;
+﻿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
@@ -18,7 +22,13 @@ public static bool MustInlinePropertyWithEventsAccess(SyntaxNode anyNodePossibly
 
         public static bool InMethodCalledInitializeComponent(SyntaxNode anyNodePossiblyWithinMethod)
         {
-            return anyNodePossiblyWithinMethod.GetAncestor<VBSyntax.MethodBlockSyntax>()?.SubOrFunctionStatement.Identifier.Text == "InitializeComponent";
+            var methodBlockSyntax = anyNodePossiblyWithinMethod.GetAncestor<VBSyntax.MethodBlockSyntax>();
+            return IsInitializeComponent(methodBlockSyntax);
+        }
+
+        private static bool IsInitializeComponent(VBSyntax.MethodBlockSyntax methodBlockSyntax)
+        {
+            return methodBlockSyntax?.SubOrFunctionStatement.Identifier.Text == "InitializeComponent";
         }
 
         /// <summary>
@@ -32,5 +42,32 @@ 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);
+                });
+        }
     }
 }
diff --git a/Tests/CSharp/MemberTests/EventMemberTests.cs b/Tests/CSharp/MemberTests/EventMemberTests.cs
@@ -525,6 +525,7 @@ public partial class TestHandlesAdded
     public TestHandlesAdded()
     {
         InitializeComponent();
+        _POW_btnV2DBM.Name = ""POW_btnV2DBM"";
     }
 
     public void InitializeComponent()
diff --git a/Tests/TestData/MultiFileCharacterization/VBToCSResults/ConvertWholeSolution/WindowsAppVb/Folder/FolderForm.cs b/Tests/TestData/MultiFileCharacterization/VBToCSResults/ConvertWholeSolution/WindowsAppVb/Folder/FolderForm.cs
@@ -12,6 +12,22 @@ public partial class FolderForm
         public FolderForm()
         {
             InitializeComponent();
+            _ToolStrip1.Name = "ToolStrip1";
+            _ToolStripButton1.Name = "ToolStripButton1";
+            _ToolStripButton2.Name = "ToolStripButton2";
+            _ToolStripButton3.Name = "ToolStripButton3";
+            _ToolStripButton4.Name = "ToolStripButton4";
+            _ToolStripButton5.Name = "ToolStripButton5";
+            _ToolStripButton6.Name = "ToolStripButton6";
+            _ToolStripButton7.Name = "ToolStripButton7";
+            _ToolStripButton8.Name = "ToolStripButton8";
+            _ToolStripButton9.Name = "ToolStripButton9";
+            _ToolStripButton10.Name = "ToolStripButton10";
+            _ToolStripButton11.Name = "ToolStripButton11";
+            _ToolStripButton12.Name = "ToolStripButton12";
+            _ToolStripButton13.Name = "ToolStripButton13";
+            _ToolStripButton14.Name = "ToolStripButton14";
+            _ToolStripButton15.Name = "ToolStripButton15";
         }
 
         private void FolderForm_Load(object sender, EventArgs e)
diff --git a/Tests/TestData/MultiFileCharacterization/VBToCSResults/ConvertWholeSolution/WindowsAppVb/WinformsDesignerTest.cs b/Tests/TestData/MultiFileCharacterization/VBToCSResults/ConvertWholeSolution/WindowsAppVb/WinformsDesignerTest.cs
@@ -8,6 +8,9 @@ public partial class WinformsDesignerTest
         public WinformsDesignerTest()
         {
             InitializeComponent();
+            _Button1.Name = "Button1";
+            _CheckBox1.Name = "CheckBox1";
+            _Button2.Name = "Button2";
         }
 
         private void Button1_Click(object sender, EventArgs e)

Original file line number	Diff line number	Diff line change
`@@ -5,19 +5,18 @@`
`5`	`5`	`using Microsoft.CodeAnalysis;`
`6`	`6`	`using Microsoft.CodeAnalysis.CSharp;`
`7`	`7`	`using Microsoft.CodeAnalysis.CSharp.Syntax;`
`8`		`-using ExpressionSyntax = Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax;`
`9`	`8`
`10`	`9`	`namespace ICSharpCode.CodeConverter.CSharp`
`11`	`10`	`{`
`12`		`- public class AdditionalInitializers`
	`11`	`+ internal class AdditionalInitializers`
`13`	`12`	`{`
`14`	`13`	`public AdditionalInitializers(bool shouldAddTypeWideInitToThisPart)`
`15`	`14`	`{`
`16`	`15`	`ShouldAddTypeWideInitToThisPart = shouldAddTypeWideInitToThisPart;`
`17`	`16`	`}`
`18`	`17`
`19`		`- public List<(ExpressionSyntax Field, SyntaxKind AssignmentKind, ExpressionSyntax Initializer)> AdditionalStaticInitializers { get; } = new List<(ExpressionSyntax, SyntaxKind, ExpressionSyntax)>();`
`20`		`- public List<(ExpressionSyntax Field, SyntaxKind AssignmentKind, ExpressionSyntax Initializer)> AdditionalInstanceInitializers { get; } = new List<(ExpressionSyntax, SyntaxKind, ExpressionSyntax)>();`
	`18`	`+ public List<Assignment> AdditionalStaticInitializers { get; } = new List<Assignment>();`
	`19`	`+ public List<Assignment> AdditionalInstanceInitializers { get; } = new List<Assignment>();`
`21`	`20`	`public bool ShouldAddTypeWideInitToThisPart { get; }`
`22`	`21`
`23`	`22`	`public IReadOnlyCollection<MemberDeclarationSyntax> WithAdditionalInitializers(ITypeSymbol parentType,`
`@@ -40,7 +39,7 @@ public IReadOnlyCollection<MemberDeclarationSyntax> WithAdditionalInitializers(I`
`40`	`39`	`}`
`41`	`40`
`42`	`41`	`private List<MemberDeclarationSyntax> WithAdditionalInitializers(List<MemberDeclarationSyntax> convertedMembers,`
`43`		`- SyntaxToken convertIdentifier, IReadOnlyCollection<(ExpressionSyntax Field, SyntaxKind AssignmentKind, ExpressionSyntax Initializer)> additionalInitializers,`
	`42`	`+ SyntaxToken convertIdentifier, IReadOnlyCollection<Assignment> additionalInitializers,`
`44`	`43`	`SyntaxTokenList modifiers, IEnumerable<ConstructorDeclarationSyntax> constructorsEnumerable, bool addConstructor, bool addedConstructorRequiresInitializeComponent)`
`45`	`44`	`{`
`46`	`45`	`if (!additionalInitializers.Any() && (!addConstructor \|\| !addedConstructorRequiresInitializeComponent)) return convertedMembers;`
`@@ -64,17 +63,23 @@ private List<MemberDeclarationSyntax> WithAdditionalInitializers(List<MemberDecl`
`64`	`63`	`}`
`65`	`64`
`66`	`65`	`private ConstructorDeclarationSyntax WithAdditionalInitializers(ConstructorDeclarationSyntax oldConstructor,`
`67`		`- IReadOnlyCollection<(ExpressionSyntax Field, SyntaxKind AssignmentKind, ExpressionSyntax Initializer)> additionalConstructorAssignments)`
	`66`	`+ IReadOnlyCollection<Assignment> additionalConstructorAssignments)`
`68`	`67`	`{`
`69`		`- var initializerStatements = additionalConstructorAssignments.Select(assignment =>`
`70`		`- SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(`
`71`		`- assignment.AssignmentKind, assignment.Field, assignment.Initializer))`
`72`		`- ).ToList();`
	`68`	`+ var preInitializerStatements = CreateAssignmentStatement(additionalConstructorAssignments.Where(x => !x.PostAssignment));`
	`69`	`+ var postInitializerStatements = CreateAssignmentStatement(additionalConstructorAssignments.Where(x => x.PostAssignment));`
`73`	`70`	`var oldConstructorBody = oldConstructor.Body ?? SyntaxFactory.Block(SyntaxFactory.ExpressionStatement(oldConstructor.ExpressionBody.Expression));`
`74`	`71`	`var newConstructor = oldConstructor.WithBody(oldConstructorBody.WithStatements(`
`75`		`- oldConstructorBody.Statements.InsertRange(0, initializerStatements)));`
	`72`	`+ oldConstructorBody.Statements.InsertRange(0, preInitializerStatements).AddRange(postInitializerStatements)));`
`76`	`73`
`77`	`74`	`return newConstructor;`
`78`	`75`	`}`
	`76`	`+`
	`77`	`+ private static List<ExpressionStatementSyntax> CreateAssignmentStatement(IEnumerable<Assignment> additionalConstructorAssignments)`
	`78`	`+ {`
	`79`	`+ return additionalConstructorAssignments.Select(assignment =>`
	`80`	`+ SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(`
	`81`	`+ assignment.AssignmentKind, assignment.Field, assignment.Initializer))`
	`82`	`+ ).ToList();`
	`83`	`+ }`
`79`	`84`	`}`
`80`	`85`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@`
`11`	`11`
`12`	`12`	`namespace ICSharpCode.CodeConverter.CSharp`
`13`	`13`	`{`
`14`		`- public class MethodWithHandles`
	`14`	`+ internal class MethodWithHandles`
`15`	`15`	`{`
`16`	`16`	`private IdentifierNameSyntax _methodId;`
`17`	`17`	`private readonly SyntaxGenerator _csSyntaxGenerator;`
`@@ -173,10 +173,10 @@ private static ExpressionSyntax MemberAccess(ExpressionSyntax eventSource, (Synt`
`173`	`173`	`eventSource, SyntaxFactory.IdentifierName(e.EventSymbolName));`
`174`	`174`	`}`
`175`	`175`
`176`		`- public IEnumerable<(ExpressionSyntax EventField, SyntaxKind AssignmentKind, ExpressionSyntax HandlerId)> GetConstructorEventHandlers()`
	`176`	`+ public IEnumerable<Assignment> GetConstructorEventHandlers()`
`177`	`177`	`{`
`178`	`178`	`return HandledClassEventCSharpIds.Select(e =>`
`179`		`- (MemberAccess(SyntaxFactory.IdentifierName(e.EventContainerName), e), SyntaxKind.AddAssignmentExpression, Invocable(_methodId, e.ParametersToDiscard))`
	`179`	`+ new Assignment(MemberAccess(SyntaxFactory.IdentifierName(e.EventContainerName), e), SyntaxKind.AddAssignmentExpression, Invocable(_methodId, e.ParametersToDiscard))`
`180`	`180`	`);`
`181`	`181`	`}`
`182`	`182`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ public IEnumerable<StatementSyntax> GetInitializeComponentClassEventHandlers()`
`67`	`67`	`return _methodWithHandleses.SelectMany(m => m.GetInitializeComponentClassEventHandlers()).ToArray();`
`68`	`68`	`}`
`69`	`69`
`70`		`- public (ExpressionSyntax EventField, SyntaxKind AssignmentKind, ExpressionSyntax HandlerId)[] GetConstructorEventHandlers()`
	`70`	`+ public Assignment[] GetConstructorEventHandlers()`
`71`	`71`	`{`
`72`	`72`	`return _methodWithHandleses.SelectMany(m => m.GetConstructorEventHandlers()).ToArray();`
`73`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -525,6 +525,7 @@ public partial class TestHandlesAdded`
`525`	`525`	`public TestHandlesAdded()`
`526`	`526`	`{`
`527`	`527`	`InitializeComponent();`
	`528`	`+ _POW_btnV2DBM.Name = ""POW_btnV2DBM"";`
`528`	`529`	`}`
`529`	`530`
`530`	`531`	`public void InitializeComponent()`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,9 @@ public partial class WinformsDesignerTest`
`8`	`8`	`public WinformsDesignerTest()`
`9`	`9`	`{`
`10`	`10`	`InitializeComponent();`
	`11`	`+ _Button1.Name = "Button1";`
	`12`	`+ _CheckBox1.Name = "CheckBox1";`
	`13`	`+ _Button2.Name = "Button2";`
`11`	`14`	`}`
`12`	`15`
`13`	`16`	`private void Button1_Click(object sender, EventArgs e)`