From 03aecf047dcdb55ab7a8009ad37f0c1c77b6a8d0 Mon Sep 17 00:00:00 2001 From: Siegfried Pammer Date: Sun, 2 Mar 2025 11:30:57 +0100 Subject: [PATCH] Add VariableScope and rework AssignVariableNames step to support renaming parameters of nested ILFunctions in the future. --- .../TestCases/Pretty/DelegateConstruction.cs | 6 +- .../CSharp/ExpressionBuilder.cs | 7 +- .../CSharp/StatementBuilder.cs | 10 + .../IL/ControlFlow/AsyncAwaitDecompiler.cs | 1 + .../IL/ControlFlow/YieldReturnDecompiler.cs | 1 + ICSharpCode.Decompiler/IL/ILReader.cs | 4 + .../IL/Instructions/ILFunction.cs | 5 + .../IL/Transforms/AssignVariableNames.cs | 684 +++++++++++------- .../Util/CollectionExtensions.cs | 2 +- 9 files changed, 438 insertions(+), 282 deletions(-) diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/DelegateConstruction.cs b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/DelegateConstruction.cs index c87ca9a7d..fd76c9e23 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Pretty/DelegateConstruction.cs +++ b/ICSharpCode.Decompiler.Tests/TestCases/Pretty/DelegateConstruction.cs @@ -377,10 +377,10 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Pretty.DelegateConstruction public static void NameConflict2(int j) { List> list = new List>(); - for (int k = 0; k < 10; k++) + for (int i = 0; i < 10; i++) { - list.Add(delegate (int i) { - Console.WriteLine(i); + list.Add(delegate (int k) { + Console.WriteLine(k); }); } } diff --git a/ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs b/ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs index 63737a2d4..e95134ed4 100644 --- a/ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs +++ b/ICSharpCode.Decompiler/CSharp/ExpressionBuilder.cs @@ -2547,6 +2547,11 @@ namespace ICSharpCode.Decompiler.CSharp foreach (var parameter in parameters) { var pd = astBuilder.ConvertParameter(parameter); + if (variables.TryGetValue(i, out var v)) + { + pd.AddAnnotation(new ILVariableResolveResult(v, parameters[i].Type)); + pd.Name = v.Name; + } if (string.IsNullOrEmpty(pd.Name) && !pd.Type.IsArgList()) { // needs to be consistent with logic in ILReader.CreateILVarable(ParameterDefinition) @@ -2554,8 +2559,6 @@ namespace ICSharpCode.Decompiler.CSharp } if (settings.AnonymousTypes && parameter.Type.ContainsAnonymousType()) pd.Type = null; - if (variables.TryGetValue(i, out var v)) - pd.AddAnnotation(new ILVariableResolveResult(v, parameters[i].Type)); yield return pd; i++; } diff --git a/ICSharpCode.Decompiler/CSharp/StatementBuilder.cs b/ICSharpCode.Decompiler/CSharp/StatementBuilder.cs index 094a51355..d3f2f5069 100644 --- a/ICSharpCode.Decompiler/CSharp/StatementBuilder.cs +++ b/ICSharpCode.Decompiler/CSharp/StatementBuilder.cs @@ -1389,6 +1389,16 @@ namespace ICSharpCode.Decompiler.CSharp var astBuilder = exprBuilder.astBuilder; var method = (MethodDeclaration)astBuilder.ConvertEntity(function.ReducedMethod); + var variables = function.Variables.Where(v => v.Kind == VariableKind.Parameter).ToDictionary(v => v.Index); + + foreach (var (i, p) in method.Parameters.WithIndex()) + { + if (variables.TryGetValue(i, out var v)) + { + p.Name = v.Name; + } + } + if (function.Method.HasBody) { var nestedBuilder = new StatementBuilder( diff --git a/ICSharpCode.Decompiler/IL/ControlFlow/AsyncAwaitDecompiler.cs b/ICSharpCode.Decompiler/IL/ControlFlow/AsyncAwaitDecompiler.cs index 259367b2d..ff37d9a1e 100644 --- a/ICSharpCode.Decompiler/IL/ControlFlow/AsyncAwaitDecompiler.cs +++ b/ICSharpCode.Decompiler/IL/ControlFlow/AsyncAwaitDecompiler.cs @@ -1165,6 +1165,7 @@ namespace ICSharpCode.Decompiler.IL.ControlFlow function.MoveNextMethod = moveNextFunction.Method; function.SequencePointCandidates = moveNextFunction.SequencePointCandidates; function.CodeSize = moveNextFunction.CodeSize; + function.LocalVariableSignatureLength = moveNextFunction.LocalVariableSignatureLength; function.IsIterator = IsAsyncEnumerator; moveNextFunction.Variables.Clear(); moveNextFunction.ReleaseRef(); diff --git a/ICSharpCode.Decompiler/IL/ControlFlow/YieldReturnDecompiler.cs b/ICSharpCode.Decompiler/IL/ControlFlow/YieldReturnDecompiler.cs index dbea7d4cf..c5ef712bc 100644 --- a/ICSharpCode.Decompiler/IL/ControlFlow/YieldReturnDecompiler.cs +++ b/ICSharpCode.Decompiler/IL/ControlFlow/YieldReturnDecompiler.cs @@ -656,6 +656,7 @@ namespace ICSharpCode.Decompiler.IL.ControlFlow function.MoveNextMethod = moveNextFunction.Method; function.SequencePointCandidates = moveNextFunction.SequencePointCandidates; function.CodeSize = moveNextFunction.CodeSize; + function.LocalVariableSignatureLength = moveNextFunction.LocalVariableSignatureLength; // Copy-propagate temporaries holding a copy of 'this'. // This is necessary because the old (pre-Roslyn) C# compiler likes to store 'this' in temporary variables. diff --git a/ICSharpCode.Decompiler/IL/ILReader.cs b/ICSharpCode.Decompiler/IL/ILReader.cs index 2ec9da40a..226218e12 100644 --- a/ICSharpCode.Decompiler/IL/ILReader.cs +++ b/ICSharpCode.Decompiler/IL/ILReader.cs @@ -342,7 +342,10 @@ namespace ICSharpCode.Decompiler.IL if (index < 0) ilVar.Name = "this"; else if (string.IsNullOrWhiteSpace(name)) + { ilVar.Name = "P_" + index; + ilVar.HasGeneratedName = true; + } else ilVar.Name = name; return ilVar; @@ -706,6 +709,7 @@ namespace ICSharpCode.Decompiler.IL var function = new ILFunction(this.method, body.GetCodeSize(), this.genericContext, mainContainer, kind); function.Variables.AddRange(parameterVariables); function.Variables.AddRange(localVariables); + function.LocalVariableSignatureLength = localVariables.Length; Debug.Assert(stackVariables != null); function.Variables.AddRange(stackVariables); function.Variables.AddRange(variableByExceptionHandler.Values); diff --git a/ICSharpCode.Decompiler/IL/Instructions/ILFunction.cs b/ICSharpCode.Decompiler/IL/Instructions/ILFunction.cs index bbf0e6441..eb81ccbce 100644 --- a/ICSharpCode.Decompiler/IL/Instructions/ILFunction.cs +++ b/ICSharpCode.Decompiler/IL/Instructions/ILFunction.cs @@ -67,6 +67,11 @@ namespace ICSharpCode.Decompiler.IL /// public readonly ILVariableCollection Variables; + /// + /// Gets + /// + public int LocalVariableSignatureLength; + /// /// Gets the scope in which the local function is declared. /// Returns null, if this is not a local function. diff --git a/ICSharpCode.Decompiler/IL/Transforms/AssignVariableNames.cs b/ICSharpCode.Decompiler/IL/Transforms/AssignVariableNames.cs index c3ce39109..0d1acd261 100644 --- a/ICSharpCode.Decompiler/IL/Transforms/AssignVariableNames.cs +++ b/ICSharpCode.Decompiler/IL/Transforms/AssignVariableNames.cs @@ -18,6 +18,7 @@ using System; using System.Collections.Generic; +using System.Collections.Immutable; using System.Diagnostics; using System.Linq; using System.Reflection; @@ -25,6 +26,7 @@ using System.Reflection.Metadata; using Humanizer.Inflections; +using ICSharpCode.Decompiler.CSharp; using ICSharpCode.Decompiler.CSharp.OutputVisitor; using ICSharpCode.Decompiler.TypeSystem; using ICSharpCode.Decompiler.TypeSystem.Implementation; @@ -32,7 +34,7 @@ using ICSharpCode.Decompiler.Util; namespace ICSharpCode.Decompiler.IL.Transforms { - public class AssignVariableNames : IILTransform + public class AssignVariableNames : ILVisitor, IILTransform { static readonly Dictionary typeNameToVariableNameDict = new Dictionary { { "System.Boolean", "flag" }, @@ -53,52 +55,83 @@ namespace ICSharpCode.Decompiler.IL.Transforms }; ILTransformContext context; - List currentLowerCaseTypeOrMemberNames; - Dictionary reservedVariableNames; - HashSet loopCounters; const char maxLoopVariableName = 'n'; - int numDisplayClassLocals; - public void Run(ILFunction function, ILTransformContext context) + public class VariableScope { - this.context = context; + readonly ILTransformContext context; + readonly VariableScope parentScope; + readonly ILFunction function; + readonly Dictionary localFunctions = new(); + readonly Dictionary variableMapping = new(ILVariableEqualityComparer.Instance); + readonly string[] assignedLocalSignatureIndices; + + IImmutableSet currentLowerCaseTypeOrMemberNames; + Dictionary reservedVariableNames; + HashSet loopCounters; + int numDisplayClassLocals; + + public VariableScope(ILFunction function, ILTransformContext context, VariableScope parentScope = null) + { + this.function = function; + this.context = context; + this.parentScope = parentScope; + + numDisplayClassLocals = 0; + assignedLocalSignatureIndices = new string[function.LocalVariableSignatureLength]; + reservedVariableNames = new Dictionary(); + + // find all loop counters in the current function + loopCounters = new HashSet(); + foreach (var inst in TreeTraversal.PreOrder((ILInstruction)function, i => i.Children)) + { + if (inst is ILFunction && inst != function) + break; + if (inst is BlockContainer { Kind: ContainerKind.For, Blocks: [.., var incrementBlock] }) + { + foreach (var i in incrementBlock.Instructions) + { + if (HighLevelLoopTransform.MatchIncrement(i, out var variable)) + loopCounters.Add(variable); + } + } + } - reservedVariableNames = new Dictionary(); - currentLowerCaseTypeOrMemberNames = new List(); - var currentLowerCaseMemberNames = CollectAllLowerCaseMemberNames(function.Method.DeclaringTypeDefinition); - foreach (var name in currentLowerCaseMemberNames) - currentLowerCaseTypeOrMemberNames.Add(name); - var currentLowerCaseTypeNames = CollectAllLowerCaseTypeNames(function.Method.DeclaringTypeDefinition); - foreach (var name in currentLowerCaseTypeNames) - { - currentLowerCaseTypeOrMemberNames.Add(name); - AddExistingName(reservedVariableNames, name); - } - loopCounters = CollectLoopCounters(function); - foreach (var f in function.Descendants.OfType()) - { - if (f.Method != null) + // if this is the root scope, we also collect all lower-case type and member names + // and fixed parameter names to avoid conflicts when naming local variables. + if (parentScope == null) { - if (IsSetOrEventAccessor(f.Method) && f.Method.Parameters.Count > 0) + var currentLowerCaseTypeOrMemberNames = new HashSet(StringComparer.Ordinal); + foreach (var name in CollectAllLowerCaseMemberNames(function.Method.DeclaringTypeDefinition)) + currentLowerCaseTypeOrMemberNames.Add(name); + foreach (var name in CollectAllLowerCaseTypeNames(function.Method.DeclaringTypeDefinition)) { - for (int i = 0; i < f.Method.Parameters.Count - 1; i++) + currentLowerCaseTypeOrMemberNames.Add(name); + AddExistingName(reservedVariableNames, name); + } + this.currentLowerCaseTypeOrMemberNames = currentLowerCaseTypeOrMemberNames.ToImmutableHashSet(); + + // handle implicit parameters of set or event accessors + if (function.Method != null && IsSetOrEventAccessor(function.Method) && function.Parameters.Count > 0) + { + for (int i = 0; i < function.Method.Parameters.Count - 1; i++) { - AddExistingName(reservedVariableNames, f.Method.Parameters[i].Name); + AddExistingName(reservedVariableNames, function.Method.Parameters[i].Name); } - var lastParameter = f.Method.Parameters.Last(); - switch (f.Method.AccessorOwner) + var lastParameter = function.Method.Parameters.Last(); + switch (function.Method.AccessorOwner) { case IProperty prop: - if (f.Method.AccessorKind == MethodSemanticsAttributes.Setter) + if (function.Method.AccessorKind == MethodSemanticsAttributes.Setter) { if (prop.Parameters.Any(p => p.Name == "value")) { - f.Warnings.Add("Parameter named \"value\" already present in property signature!"); + function.Warnings.Add("Parameter named \"value\" already present in property signature!"); break; } - var variableForLastParameter = f.Variables.FirstOrDefault(v => v.Function == f + var variableForLastParameter = function.Variables.FirstOrDefault(v => v.Function == function && v.Kind == VariableKind.Parameter - && v.Index == f.Method.Parameters.Count - 1); + && v.Index == function.Method.Parameters.Count - 1); if (variableForLastParameter == null) { AddExistingName(reservedVariableNames, lastParameter.Name); @@ -114,11 +147,11 @@ namespace ICSharpCode.Decompiler.IL.Transforms } break; case IEvent ev: - if (f.Method.AccessorKind != MethodSemanticsAttributes.Raiser) + if (function.Method.AccessorKind != MethodSemanticsAttributes.Raiser) { - var variableForLastParameter = f.Variables.FirstOrDefault(v => v.Function == f + var variableForLastParameter = function.Variables.FirstOrDefault(v => v.Function == function && v.Kind == VariableKind.Parameter - && v.Index == f.Method.Parameters.Count - 1); + && v.Index == function.Method.Parameters.Count - 1); if (variableForLastParameter == null) { AddExistingName(reservedVariableNames, lastParameter.Name); @@ -140,183 +173,394 @@ namespace ICSharpCode.Decompiler.IL.Transforms } else { - foreach (var p in f.Method.Parameters) - AddExistingName(reservedVariableNames, p.Name); + var variables = function.Variables.Where(v => v.Kind == VariableKind.Parameter && v.Index >= 0).ToDictionary(v => v.Index); + foreach (var (i, p) in function.Parameters.WithIndex()) + { + string name = p.Name; + if (string.IsNullOrWhiteSpace(name) && p.Type != SpecialType.ArgList) + { + // needs to be consistent with logic in ILReader.CreateILVarable + name = "P_" + i; + } + if (variables.TryGetValue(i, out var v)) + variableMapping[v] = name; + AddExistingName(reservedVariableNames, name); + } + } + + static bool IsSetOrEventAccessor(IMethod method) + { + switch (method.AccessorKind) + { + case MethodSemanticsAttributes.Setter: + case MethodSemanticsAttributes.Adder: + case MethodSemanticsAttributes.Remover: + return true; + default: + return false; + } } } else { - foreach (var p in f.Variables.Where(v => v.Kind == VariableKind.Parameter)) - AddExistingName(reservedVariableNames, p.Name); + this.currentLowerCaseTypeOrMemberNames = parentScope.currentLowerCaseTypeOrMemberNames; + var variables = function.Variables.Where(v => v.Kind == VariableKind.Parameter).ToDictionary(v => v.Index); + + foreach (var (i, p) in function.Parameters.WithIndex()) + { + if (function.Kind is ILFunctionKind.Delegate or ILFunctionKind.ExpressionTree + && CSharpDecompiler.IsTransparentIdentifier(p.Name)) + { + AddExistingName(reservedVariableNames, p.Name); + if (variables.TryGetValue(i, out var v)) + variableMapping[v] = p.Name; + } + if (!parentScope.IsReservedVariableName(p.Name, out _)) + { + AddExistingName(reservedVariableNames, p.Name); + if (variables.TryGetValue(i, out var v)) + variableMapping[v] = p.Name; + } + } } } - numDisplayClassLocals = 0; - PerformAssignment(function); - } - static IEnumerable CollectAllLowerCaseMemberNames(ITypeDefinition type) - { - foreach (var item in type.GetMembers(m => IsLowerCase(m.Name))) - yield return item.Name; - } + public void Add(MethodDefinitionHandle localFunction, string name) + { + this.localFunctions[localFunction] = name; + } - static IEnumerable CollectAllLowerCaseTypeNames(ITypeDefinition type) - { - var ns = type.ParentModule.Compilation.GetNamespaceByFullName(type.Namespace); - foreach (var item in ns.Types) + public string TryGetExistingName(MethodDefinitionHandle localFunction) { - if (IsLowerCase(item.Name)) - yield return item.Name; + if (localFunctions.TryGetValue(localFunction, out var name)) + return name; + return parentScope?.TryGetExistingName(localFunction); } - } - static bool IsLowerCase(string name) - { - return name.Length > 0 && char.ToLower(name[0]) == name[0]; - } + public string TryGetExistingName(ILVariable v) + { + if (variableMapping.TryGetValue(v, out var name)) + return name; + return parentScope?.TryGetExistingName(v); + } - bool IsSetOrEventAccessor(IMethod method) - { - switch (method.AccessorKind) + public string TryGetExistingName(ILFunction function, int index) { - case MethodSemanticsAttributes.Setter: - case MethodSemanticsAttributes.Adder: - case MethodSemanticsAttributes.Remover: + if (this.function == function) + { + return this.assignedLocalSignatureIndices[index]; + } + else + { + return parentScope?.TryGetExistingName(function, index); + } + } + + public void AssignNameToLocalSignatureIndex(ILFunction function, int index, string name) + { + var scope = this; + while (scope != null && scope.function != function) + scope = scope.parentScope; + Debug.Assert(scope != null); + scope.assignedLocalSignatureIndices[index] = name; + } + + public bool IsReservedVariableName(string name, out int index) + { + if (reservedVariableNames.TryGetValue(name, out index)) return true; - default: - return false; + return parentScope?.IsReservedVariableName(name, out index) ?? false; } - } - void PerformAssignment(ILFunction function) - { - var localFunctionMapping = new Dictionary(); - var variableMapping = new Dictionary(ILVariableEqualityComparer.Instance); - var assignedLocalSignatureIndices = new Dictionary<(ILFunction, int), string>(); + public void ReserveVariableName(string name, int index = 1) + { + reservedVariableNames[name] = index; + } - foreach (var inst in function.Descendants) + public string NextDisplayClassLocal() { - if (inst is ILFunction { Kind: ILFunctionKind.LocalFunction } localFunction) + return parentScope?.NextDisplayClassLocal() ?? "CS$<>8__locals" + (numDisplayClassLocals++); + } + + public bool IsLoopCounter(ILVariable v) + { + return loopCounters.Contains(v) || (parentScope?.IsLoopCounter(v) == true); + } + + public string AssignName(ILVariable v) + { + // variable has no valid name + string newName = v.Name; + if (v.HasGeneratedName || !IsValidName(newName)) + { + // don't use the name from the debug symbols if it looks like a generated name + // generate a new one based on how the variable is used + newName = GenerateNameForVariable(v); + } + // use the existing name and update index appended to future conflicts + string nameWithoutNumber = SplitName(newName, out int newIndex); + if (IsReservedVariableName(nameWithoutNumber, out int lastUsedIndex)) { - // assign names to local functions - if (!LocalFunctionDecompiler.ParseLocalFunctionName(localFunction.Name, out _, out var newName) || !IsValidName(newName)) - newName = null; - if (newName == null) + if (v.Type.IsKnownType(KnownTypeCode.Int32) && IsLoopCounter(v)) { - string nameWithoutNumber = "f"; - if (!reservedVariableNames.TryGetValue(nameWithoutNumber, out int currentIndex)) + // special case for loop counters, + // we don't want them to be named i, i2, ..., but i, j, ... + newName = GenerateNameForVariable(v); + nameWithoutNumber = newName; + newIndex = 1; + } + } + if (IsReservedVariableName(nameWithoutNumber, out lastUsedIndex)) + { + // name without number was already used + if (newIndex > lastUsedIndex) + { + // new index is larger than last, so we can use it + } + else + { + // new index is smaller or equal, so we use the next value + newIndex = lastUsedIndex + 1; + } + // resolve conflicts by appending the index to the new name: + newName = nameWithoutNumber + newIndex.ToString(); + } + // update the last used index + ReserveVariableName(nameWithoutNumber, newIndex); + variableMapping.Add(v, newName); + return newName; + } + + string GenerateNameForVariable(ILVariable variable) + { + string proposedName = null; + if (variable.Type.IsKnownType(KnownTypeCode.Int32)) + { + // test whether the variable might be a loop counter + if (loopCounters.Contains(variable)) + { + // For loop variables, use i,j,k,l,m,n + for (char c = 'i'; c <= maxLoopVariableName; c++) + { + if (!IsReservedVariableName(c.ToString(), out _)) + { + proposedName = c.ToString(); + break; + } + } + } + } + // The ComponentResourceManager inside InitializeComponent must be named "resources", + // otherwise the WinForms designer won't load the Form. + if (CSharp.CSharpDecompiler.IsWindowsFormsInitializeComponentMethod(context.Function.Method) && variable.Type.FullName == "System.ComponentModel.ComponentResourceManager") + { + proposedName = "resources"; + } + if (string.IsNullOrEmpty(proposedName)) + { + var proposedNameForAddress = variable.AddressInstructions.OfType() + .Select(arg => arg.Parent is CallInstruction c ? c.GetParameter(arg.ChildIndex)?.Name : null) + .Where(arg => !string.IsNullOrWhiteSpace(arg)) + .Except(currentLowerCaseTypeOrMemberNames).ToList(); + if (proposedNameForAddress.Count > 0) + { + proposedName = proposedNameForAddress[0]; + } + } + if (string.IsNullOrEmpty(proposedName)) + { + var proposedNameForStores = new HashSet(); + foreach (var store in variable.StoreInstructions) + { + if (store is StLoc stloc) { - currentIndex = 1; + var name = GetNameFromInstruction(stloc.Value); + if (!currentLowerCaseTypeOrMemberNames.Contains(name)) + proposedNameForStores.Add(name); } - int count = Math.Max(1, currentIndex) + 1; - reservedVariableNames[nameWithoutNumber] = count; - if (count > 1) + else if (store is MatchInstruction match && match.SlotInfo == MatchInstruction.SubPatternsSlot) { - newName = nameWithoutNumber + count.ToString(); + var name = GetNameFromInstruction(match.TestedOperand); + if (!currentLowerCaseTypeOrMemberNames.Contains(name)) + proposedNameForStores.Add(name); } - else + else if (store is PinnedRegion pinnedRegion) { - newName = nameWithoutNumber; + var name = GetNameFromInstruction(pinnedRegion.Init); + if (!currentLowerCaseTypeOrMemberNames.Contains(name)) + proposedNameForStores.Add(name); } } - localFunction.Name = newName; - localFunction.ReducedMethod.Name = newName; - localFunctionMapping[(MethodDefinitionHandle)localFunction.ReducedMethod.MetadataToken] = newName; - } - else if (inst is IInstructionWithVariableOperand i) - { - var v = i.Variable; - // if there is already a valid name for the variable slot, just use it - if (variableMapping.TryGetValue(v, out string name)) + if (proposedNameForStores.Count == 1) { - v.Name = name; - continue; + proposedName = proposedNameForStores.Single(); } - switch (v.Kind) + } + if (string.IsNullOrEmpty(proposedName)) + { + var proposedNameForLoads = variable.LoadInstructions + .Select(arg => GetNameForArgument(arg.Parent, arg.ChildIndex)) + .Except(currentLowerCaseTypeOrMemberNames).ToList(); + if (proposedNameForLoads.Count == 1) { - case VariableKind.Parameter: - // Parameter names are handled in ILReader.CreateILVariable - // and CSharpDecompiler.FixParameterNames - break; - case VariableKind.InitializerTarget: // keep generated names - AddExistingName(reservedVariableNames, v.Name); - break; - case VariableKind.DisplayClassLocal: - v.Name = "CS$<>8__locals" + (numDisplayClassLocals++); - break; - case VariableKind.Local when v.Index != null: - if (assignedLocalSignatureIndices.TryGetValue((v.Function, v.Index.Value), out name)) - { - // make sure all local ILVariables that refer to the same slot in the locals signature - // are assigned the same name. - v.Name = name; - } - else - { - v.Name = AssignName(v, variableMapping); - // Remember the newly assigned name: - assignedLocalSignatureIndices.Add((v.Function, v.Index.Value), v.Name); - } - break; - default: - v.Name = AssignName(v, variableMapping); - break; + proposedName = proposedNameForLoads[0]; } } - else if (inst is (Call or LdFtn) and IInstructionWithMethodOperand m) + if (string.IsNullOrEmpty(proposedName) && variable.Kind == VariableKind.StackSlot) { - // update references to local functions - if (m.Method is LocalFunctionMethod lf - && localFunctionMapping.TryGetValue((MethodDefinitionHandle)lf.MetadataToken, out var name)) + var proposedNameForStoresFromNewObj = variable.StoreInstructions.OfType() + .Select(expr => GetNameByType(GuessType(variable.Type, expr.Value, context))) + .Except(currentLowerCaseTypeOrMemberNames).ToList(); + if (proposedNameForStoresFromNewObj.Count == 1) { - lf.Name = name; + proposedName = proposedNameForStoresFromNewObj[0]; } } + if (string.IsNullOrEmpty(proposedName)) + { + proposedName = GetNameByType(variable.Type); + } + + // for generated names remove number-suffixes + return SplitName(proposedName, out _); } } - string AssignName(ILVariable v, Dictionary variableMapping) + public void Run(ILFunction function, ILTransformContext context) + { + this.context = context; + function.AcceptVisitor(this, null); + } + + protected override Unit Default(ILInstruction inst, VariableScope context) { - // variable has no valid name - string newName = v.Name; - if (v.HasGeneratedName || !IsValidName(newName)) + foreach (var child in inst.Children) { - // don't use the name from the debug symbols if it looks like a generated name - // generate a new one based on how the variable is used - newName = GenerateNameForVariable(v); + child.AcceptVisitor(this, context); } - // use the existing name and update index appended to future conflicts - string nameWithoutNumber = SplitName(newName, out int newIndex); - if (reservedVariableNames.TryGetValue(nameWithoutNumber, out int lastUsedIndex)) + + if (inst is not IInstructionWithVariableOperand { Variable: var v }) + return default; + + // if there is already a valid name for the variable slot, just use it + string name = context.TryGetExistingName(v); + if (!string.IsNullOrEmpty(name)) { - if (v.Type.IsKnownType(KnownTypeCode.Int32) && loopCounters.Contains(v)) - { - // special case for loop counters, - // we don't want them to be named i, i2, ..., but i, j, ... - newName = GenerateNameForVariable(v); - nameWithoutNumber = newName; - newIndex = 1; - } + v.Name = name; + return default; } - if (reservedVariableNames.TryGetValue(nameWithoutNumber, out lastUsedIndex)) + + switch (v.Kind) { - // name without number was already used - if (newIndex > lastUsedIndex) - { - // new index is larger than last, so we can use it - } - else + case VariableKind.Parameter when !v.HasGeneratedName && v.Function.Kind == ILFunctionKind.TopLevelFunction: + // Parameter names of top-level functions are handled in ILReader.CreateILVariable + // and CSharpDecompiler.FixParameterNames + break; + case VariableKind.InitializerTarget: // keep generated names + case VariableKind.NamedArgument: + context.ReserveVariableName(v.Name); + break; + case VariableKind.DisplayClassLocal: + v.Name = context.NextDisplayClassLocal(); + break; + case VariableKind.Local when v.Index != null: + name = context.TryGetExistingName(v.Function, v.Index.Value); + if (name != null) + { + // make sure all local ILVariables that refer to the same slot in the locals signature + // are assigned the same name. + v.Name = name; + } + else + { + v.Name = context.AssignName(v); + context.AssignNameToLocalSignatureIndex(v.Function, v.Index.Value, v.Name); + } + break; + default: + v.Name = context.AssignName(v); + break; + } + + return default; + } + + protected internal override Unit VisitILFunction(ILFunction function, VariableScope context) + { + if (function.Kind == ILFunctionKind.LocalFunction) + { + // assign names to local functions + if (!LocalFunctionDecompiler.ParseLocalFunctionName(function.Name, out _, out var newName) || !IsValidName(newName)) + newName = null; + if (newName == null) { - // new index is smaller or equal, so we use the next value - newIndex = lastUsedIndex + 1; + string nameWithoutNumber = "f"; + if (!context.IsReservedVariableName(nameWithoutNumber, out int currentIndex)) + { + currentIndex = 1; + } + int count = Math.Max(1, currentIndex) + 1; + context.ReserveVariableName(nameWithoutNumber, count); + if (count > 1) + { + newName = nameWithoutNumber + count.ToString(); + } + else + { + newName = nameWithoutNumber; + } } - // resolve conflicts by appending the index to the new name: - newName = nameWithoutNumber + newIndex.ToString(); + function.Name = newName; + function.ReducedMethod.Name = newName; + context.Add((MethodDefinitionHandle)function.ReducedMethod.MetadataToken, newName); + } + + return base.VisitILFunction(function, new VariableScope(function, this.context, context)); + } + + protected internal override Unit VisitCall(Call inst, VariableScope context) + { + if (inst.Method is LocalFunctionMethod m) + { + string name = context.TryGetExistingName((MethodDefinitionHandle)m.MetadataToken); + if (!string.IsNullOrEmpty(name)) + m.Name = name; } - // update the last used index - reservedVariableNames[nameWithoutNumber] = newIndex; - variableMapping.Add(v, newName); - return newName; + + return base.VisitCall(inst, context); + } + + protected internal override Unit VisitLdFtn(LdFtn inst, VariableScope context) + { + if (inst.Method is LocalFunctionMethod m) + { + string name = context.TryGetExistingName((MethodDefinitionHandle)m.MetadataToken); + if (!string.IsNullOrEmpty(name)) + m.Name = name; + } + + return base.VisitLdFtn(inst, context); + } + + static IEnumerable CollectAllLowerCaseMemberNames(ITypeDefinition type) + { + foreach (var item in type.GetMembers(m => IsLowerCase(m.Name))) + yield return item.Name; + } + + static IEnumerable CollectAllLowerCaseTypeNames(ITypeDefinition type) + { + var ns = type.ParentModule.Compilation.GetNamespaceByFullName(type.Namespace); + foreach (var item in ns.Types) + { + if (IsLowerCase(item.Name)) + yield return item.Name; + } + } + + static bool IsLowerCase(string name) + { + return name.Length > 0 && char.ToLower(name[0]) == name[0]; } /// @@ -351,118 +595,6 @@ namespace ICSharpCode.Decompiler.IL.Transforms return true; } - HashSet CollectLoopCounters(ILFunction function) - { - var loopCounters = new HashSet(); - - foreach (BlockContainer possibleLoop in function.Descendants.OfType()) - { - if (possibleLoop.Kind != ContainerKind.For) - continue; - foreach (var inst in possibleLoop.Blocks.Last().Instructions) - { - if (HighLevelLoopTransform.MatchIncrement(inst, out var variable)) - loopCounters.Add(variable); - } - } - - return loopCounters; - } - - string GenerateNameForVariable(ILVariable variable) - { - string proposedName = null; - if (variable.Type.IsKnownType(KnownTypeCode.Int32)) - { - // test whether the variable might be a loop counter - if (loopCounters.Contains(variable)) - { - // For loop variables, use i,j,k,l,m,n - for (char c = 'i'; c <= maxLoopVariableName; c++) - { - if (!reservedVariableNames.ContainsKey(c.ToString())) - { - proposedName = c.ToString(); - break; - } - } - } - } - // The ComponentResourceManager inside InitializeComponent must be named "resources", - // otherwise the WinForms designer won't load the Form. - if (CSharp.CSharpDecompiler.IsWindowsFormsInitializeComponentMethod(context.Function.Method) && variable.Type.FullName == "System.ComponentModel.ComponentResourceManager") - { - proposedName = "resources"; - } - if (string.IsNullOrEmpty(proposedName)) - { - var proposedNameForAddress = variable.AddressInstructions.OfType() - .Select(arg => arg.Parent is CallInstruction c ? c.GetParameter(arg.ChildIndex)?.Name : null) - .Where(arg => !string.IsNullOrWhiteSpace(arg)) - .Except(currentLowerCaseTypeOrMemberNames).ToList(); - if (proposedNameForAddress.Count > 0) - { - proposedName = proposedNameForAddress[0]; - } - } - if (string.IsNullOrEmpty(proposedName)) - { - var proposedNameForStores = new HashSet(); - foreach (var store in variable.StoreInstructions) - { - if (store is StLoc stloc) - { - var name = GetNameFromInstruction(stloc.Value); - if (!currentLowerCaseTypeOrMemberNames.Contains(name)) - proposedNameForStores.Add(name); - } - else if (store is MatchInstruction match && match.SlotInfo == MatchInstruction.SubPatternsSlot) - { - var name = GetNameFromInstruction(match.TestedOperand); - if (!currentLowerCaseTypeOrMemberNames.Contains(name)) - proposedNameForStores.Add(name); - } - else if (store is PinnedRegion pinnedRegion) - { - var name = GetNameFromInstruction(pinnedRegion.Init); - if (!currentLowerCaseTypeOrMemberNames.Contains(name)) - proposedNameForStores.Add(name); - } - } - if (proposedNameForStores.Count == 1) - { - proposedName = proposedNameForStores.Single(); - } - } - if (string.IsNullOrEmpty(proposedName)) - { - var proposedNameForLoads = variable.LoadInstructions - .Select(arg => GetNameForArgument(arg.Parent, arg.ChildIndex)) - .Except(currentLowerCaseTypeOrMemberNames).ToList(); - if (proposedNameForLoads.Count == 1) - { - proposedName = proposedNameForLoads[0]; - } - } - if (string.IsNullOrEmpty(proposedName) && variable.Kind == VariableKind.StackSlot) - { - var proposedNameForStoresFromNewObj = variable.StoreInstructions.OfType() - .Select(expr => GetNameByType(GuessType(variable.Type, expr.Value, context))) - .Except(currentLowerCaseTypeOrMemberNames).ToList(); - if (proposedNameForStoresFromNewObj.Count == 1) - { - proposedName = proposedNameForStoresFromNewObj[0]; - } - } - if (string.IsNullOrEmpty(proposedName)) - { - proposedName = GetNameByType(variable.Type); - } - - // for generated names remove number-suffixes - return SplitName(proposedName, out _); - } - static string GetNameFromInstruction(ILInstruction inst) { switch (inst) @@ -663,7 +795,7 @@ namespace ICSharpCode.Decompiler.IL.Transforms return lowerCaseName; } - internal static IType GuessType(IType variableType, ILInstruction inst, ILTransformContext context) + static IType GuessType(IType variableType, ILInstruction inst, ILTransformContext context) { if (!variableType.IsKnownType(KnownTypeCode.Object)) return variableType; diff --git a/ICSharpCode.Decompiler/Util/CollectionExtensions.cs b/ICSharpCode.Decompiler/Util/CollectionExtensions.cs index 0d5febe9c..a88ac4376 100644 --- a/ICSharpCode.Decompiler/Util/CollectionExtensions.cs +++ b/ICSharpCode.Decompiler/Util/CollectionExtensions.cs @@ -225,7 +225,7 @@ namespace ICSharpCode.Decompiler.Util yield return func(index++, element); } - public static IEnumerable<(int, T)> WithIndex(this ICollection source) + public static IEnumerable<(int, T)> WithIndex(this IEnumerable source) { int index = 0; foreach (var item in source)