Rename after

Author: GrahamTheCoder

CodeConverter/CSharp/AdditionalDeclaration.cs

@@ -23,23 +23,5 @@ public AdditionalDeclaration(string prefix, ExpressionSyntax initializer, TypeSy
         }
 
         public IdentifierNameSyntax IdentifierName => SyntaxFactory.IdentifierName(Id).WithAdditionalAnnotations(HoistedNodeState.Annotation);
-
-
-        public static IEnumerable<StatementSyntax> ReplaceNames(IEnumerable<StatementSyntax> csNodes, Dictionary<string, string> newNames)
-        {
-            csNodes = csNodes.Select(csNode => ReplaceNames(csNode, newNames)).ToList();
-            return csNodes;
-        }
-
-        public static T ReplaceNames<T>(T csNode, Dictionary<string, string> newNames) where T: SyntaxNode
-        {
-            return csNode.ReplaceNodes(csNode.GetAnnotatedNodes(HoistedNodeState.Annotation), (_, withReplaced) => {
-                var idns = (IdentifierNameSyntax)withReplaced;
-                if (newNames.TryGetValue(idns.Identifier.ValueText, out var newName)) {
-                    return idns.WithoutAnnotations(HoistedNodeState.Annotation).WithIdentifier(SyntaxFactory.Identifier(newName));
-                }
-                return idns;
-            });
-        }
     }
 }

CodeConverter/CSharp/DeclarationNodeVisitor.cs

@@ -555,7 +555,7 @@ private IEnumerable<MemberDeclarationSyntax> CreateAdditionalLocalMembers(Syntax
 
             // This should probably use a unique name like in MethodBodyVisitor - a collision is far less likely here
             var newNames = declarationInfo.ToDictionary(l => l.Id, l => l.Prefix);
-            var newInitializer = AdditionalDeclaration.ReplaceNames(v.Initializer.Value, newNames);
+            var newInitializer = HoistedNodeState.ReplaceNames(v.Initializer.Value, newNames);
 
             var body = SyntaxFactory.Block(localVars.Concat(SyntaxFactory.ReturnStatement(newInitializer).Yield()));
             // Method calls in initializers must be static in C# - Supporting this is #281

CodeConverter/CSharp/ExpressionNodeVisitor.cs

@@ -930,15 +930,13 @@ private async Task<InvocationExpressionSyntax> HoistAndCallLocalFunction(VBSynta
 
             var statements = await _additionalLocals.CreateLocals(invocation, new[] { callAndStoreResult }, generatedNames, _semanticModel);
 
-            var localFuncId = SyntaxFactory.IdentifierName(localFuncName);
-
             var block = SyntaxFactory.Block(
                 statements.Concat(SyntaxFactory.ReturnStatement(SyntaxFactory.IdentifierName(retVariableName)).Yield())
             );
-            var localFunction = SyntaxFactory.LocalFunctionStatement(CommonConversions.GetTypeSyntax(invocationSymbol.ReturnType),
-                localFuncId.Identifier).WithBody(block);
-            _additionalLocals.Hoist(new HoistedStatement(localFunction));
-            return SyntaxFactory.InvocationExpression(localFuncId, SyntaxFactory.ArgumentList());
+            var returnType = CommonConversions.GetTypeSyntax(invocationSymbol.ReturnType);
+            
+            var localFunc = _additionalLocals.Hoist(new HoistedLocalFunction(localFuncName, returnType, block));
+            return SyntaxFactory.InvocationExpression(localFunc.TempIdentifier, SyntaxFactory.ArgumentList());
         }
 
         private bool RequiresLocalFunction(VBSyntax.InvocationExpressionSyntax invocation, IMethodSymbol invocationSymbol)

CodeConverter/CSharp/HoistedLocalFunction.cs

@@ -0,0 +1,27 @@
+using System;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace ICSharpCode.CodeConverter.CSharp
+{
+    internal class HoistedLocalFunction : IHoistedNode
+    {
+        private readonly TypeSyntax _returnType;
+        private readonly BlockSyntax _block;
+
+        public string Id { get; }
+        public string Prefix { get; }
+
+        public HoistedLocalFunction(string localFuncName, TypeSyntax returnType, BlockSyntax block)
+        {
+            Id = $"hs{Guid.NewGuid().ToString("N")}";
+            Prefix = localFuncName;
+            _returnType = returnType;
+            _block = block;
+        }
+
+        public IdentifierNameSyntax TempIdentifier => SyntaxFactory.IdentifierName(Id).WithAdditionalAnnotations(HoistedNodeState.Annotation);
+        public LocalFunctionStatementSyntax LocalFunction(string functionName) => SyntaxFactory.LocalFunctionStatement(_returnType, SyntaxFactory.Identifier(functionName)).WithBody(_block);
+    }
+}

CodeConverter/CSharp/HoistedNodeState.cs

@@ -8,6 +8,8 @@
 using CS = Microsoft.CodeAnalysis.CSharp;
 using ICSharpCode.CodeConverter.Shared;
 using System;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.CSharp;
 
 namespace ICSharpCode.CodeConverter.CSharp
 {
@@ -57,15 +59,26 @@ public IReadOnlyCollection<AdditionalAssignment> GetPostAssignments()
             return _hoistedNodesPerScope.Peek().OfType<AdditionalAssignment>().ToArray();
         }
 
-        public IReadOnlyCollection<HoistedStatement> GetStatements()
+        public IReadOnlyCollection<HoistedLocalFunction> GetStatements()
         {
-            return _hoistedNodesPerScope.Peek().OfType<HoistedStatement>().ToArray();
+            return _hoistedNodesPerScope.Peek().OfType<HoistedLocalFunction>().ToArray();
         }
 
-        public async Task<SyntaxList<CS.Syntax.StatementSyntax>> CreateLocals(VBasic.VisualBasicSyntaxNode vbNode, IEnumerable<CS.Syntax.StatementSyntax> csNodes, HashSet<string> generatedNames, SemanticModel semanticModel)
+        public SyntaxList<StatementSyntax> CreateStatements(VBasic.VisualBasicSyntaxNode vbNode, IEnumerable<StatementSyntax> statements, HashSet<string> generatedNames, SemanticModel semanticModel)
         {
-            var preDeclarations = new List<CS.Syntax.StatementSyntax>();
-            var postAssignments = new List<CS.Syntax.StatementSyntax>();
+            var localFunctions = GetStatements(); 
+            var newNames = localFunctions.ToDictionary(f => f.Id, f =>
+                NameGenerator.GetUniqueVariableNameInScope(semanticModel, generatedNames, vbNode, f.Prefix)
+            );
+            statements = ReplaceNames(statements, newNames);
+            var functions = localFunctions.Select(f => f.LocalFunction(newNames[f.Id]));
+            return SyntaxFactory.List(functions.Concat(statements));
+        }
+
+        public async Task<SyntaxList<StatementSyntax>> CreateLocals(VBasic.VisualBasicSyntaxNode vbNode, IEnumerable<StatementSyntax> csNodes, HashSet<string> generatedNames, SemanticModel semanticModel)
+        {
+            var preDeclarations = new List<StatementSyntax>();
+            var postAssignments = new List<StatementSyntax>();
 
             var additionalDeclarationInfo = GetDeclarations();
             var newNames = additionalDeclarationInfo.ToDictionary(l => l.Id, l =>
@@ -82,9 +95,26 @@ public IReadOnlyCollection<HoistedStatement> GetStatements()
                 postAssignments.Add(CS.SyntaxFactory.ExpressionStatement(assign));
             }
 
-            var statementsWithUpdatedIds = AdditionalDeclaration.ReplaceNames(preDeclarations.Concat(csNodes).Concat(postAssignments), newNames);
+            var statementsWithUpdatedIds = ReplaceNames(preDeclarations.Concat(csNodes).Concat(postAssignments), newNames);
 
             return CS.SyntaxFactory.List(statementsWithUpdatedIds);
         }
+
+        public static IEnumerable<StatementSyntax> ReplaceNames(IEnumerable<StatementSyntax> csNodes, Dictionary<string, string> newNames)
+        {
+            csNodes = csNodes.Select(csNode => ReplaceNames(csNode, newNames)).ToList();
+            return csNodes;
+        }
+
+        public static T ReplaceNames<T>(T csNode, Dictionary<string, string> newNames) where T : SyntaxNode
+        {
+            return csNode.ReplaceNodes(csNode.GetAnnotatedNodes(Annotation), (_, withReplaced) => {
+                var idns = (IdentifierNameSyntax)withReplaced;
+                if (newNames.TryGetValue(idns.Identifier.ValueText, out var newName)) {
+                    return idns.WithoutAnnotations(Annotation).WithIdentifier(CS.SyntaxFactory.Identifier(newName));
+                }
+                return idns;
+            });
+        }
     }
 }

CodeConverter/CSharp/HoistedNodeStateVisitor.cs

@@ -46,7 +46,7 @@ private async Task<SyntaxList<StatementSyntax>> AddLocalVariables(VBasic.VisualB
             try {
                 var csNodes = await _wrappedVisitor.Visit(node);
                 var statements = await _additionalLocals.CreateLocals(node, csNodes, _generatedNames, _semanticModel);
-                return statements.InsertRange(0, _additionalLocals.GetStatements().Select(s => s.Statement));
+                return _additionalLocals.CreateStatements(node, statements, _generatedNames, _semanticModel);
             } finally {
                 _additionalLocals.PopScope();
             }

CodeConverter/CSharp/HoistedStatement.cs

@@ -322,9 +322,9 @@ public LambdaExpressionSyntax ConvertLambdaExpression(CSS.AnonymousFunctionExpre
             return CreateLambdaExpression(singleLineExpressionKind, multiLineExpressionKind, header, statements, endBlock);
 
         }
-        StatementSyntax GetStatementSyntax(VisualBasicSyntaxNode node, Func<ExpressionSyntax, StatementSyntax> create) {
-            if (node is StatementSyntax)
-                return (StatementSyntax)node;
+
+        private StatementSyntax GetStatementSyntax(VisualBasicSyntaxNode node, Func<ExpressionSyntax, StatementSyntax> create) {
+            if (node is StatementSyntax syntax) return syntax;
             return create(node as ExpressionSyntax);
         }
 

CodeConverter/VB/CommonConversions.cs

@@ -398,9 +398,9 @@ public void UsesRef(bool someBool, int someInt)
         int argvrbTst3 = Prop;
         bool c = TakesRef(ref argvrbTst3);
         Prop = argvrbTst3; // Requires variable before, and to assign back after
-        bool localTakesRef1() { int argvrbTst = Prop; var ret = TakesRef(ref argvrbTst); Prop = argvrbTst; return ret; }
+        bool localTakesRef() { int argvrbTst = Prop; var ret = TakesRef(ref argvrbTst); Prop = argvrbTst; return ret; }
 
-        bool localTakesRef2() { int argvrbTst = 3; var ret = TakesRef(ref argvrbTst); return ret; }
+        bool localTakesRef1() { int argvrbTst = 3; var ret = TakesRef(ref argvrbTst); return ret; }
 
         if (16 > someInt || TakesRef(ref someInt)) // Convert directly
         {
@@ -410,7 +410,7 @@ public void UsesRef(bool someBool, int someInt)
         {
             someInt += 1;
         }
-        else if (localTakesRef2()) // Requires variable before, and to assign back after (in local function)
+        else if (localTakesRef()) // Requires variable before, and to assign back after (in local function)
         {
             someInt -= 2;
         }