public IEnumerable<MethodDeclaration> FindCandidatesViaRefactoringPermutations(TargetInfo left, MethodDeclaration right) { right = right.DeepCopy(); /* * Steps to change one to match the other. * Get the lookup table for left. * Get the lookup table for right. * Loop through left, renaming the corresponding right var as you go (don't worry about collisions yet). * Compare. * * This is essentially a normalization of one to the other. */ Dictionary<string, List<LocalLookupVariable>> left_table = left.GetLookupTableWithParams(); Dictionary<string, List<LocalLookupVariable>> right_table = right.GetLookupTableWithParams(); if (left_table.Keys.Count == right_table.Keys.Count) { IDictionary<string, string> renames = new Dictionary<string, string>(); for (int i = 0; i < left_table.Count; i++) { var left_var_name = left_table.Keys.ToArray()[i]; var right_var_name = right_table.Keys.ToArray()[i]; // current name => new name renames.Add(right_var_name, left_var_name); } RenameLocalVariableRefactoring r = new RenameLocalVariableRefactoring(renames); right.AcceptVisitor(r, null); yield return right; } }
public IEnumerable<CloneDesc> FindCandidatesViaRefactoringPermutations(TargetInfo left, CloneDesc refactoredPermy) { MethodDeclaration right = refactoredPermy.PermutatedMethod; var permutations = FindCandidatesViaRefactoringPermutations(left, right); return permutations.Select(x => new CloneDesc(x, refactoredPermy, new QuickFixInfo(refactoredPermy.ReplacementInvocationInfo, left.CloneContainer.Parameters.Select(x1 => x1.ParameterName as object).ToList())) { ReplacementInvocation = refactoredPermy.ReplacementInvocation }); }
public IEnumerable<CloneDesc> FindCandidatesViaRefactoringPermutations(TargetInfo left, CloneDesc refactoredPermy) { MethodDeclaration right = refactoredPermy.PermutatedMethod; // HEURISTIC: This refactoring will not change the node count, so don't bother if they don't already match. if(right.Body.CountNodes() != left.Target.Body.CountNodes()) // if(!right.MatchesIgnorePrimitives(left.Target)) yield break; // HEURISTIC: No point in adding any more parameters than the target method has. int parms_to_add = left.Target.Parameters.Count - right.Parameters.Count; if (parms_to_add > 0) { var md = FindCandidates(right, parms_to_add); foreach (var h in md) { yield return new CloneDesc(h.md, refactoredPermy, new QuickFixInfo(refactoredPermy.ReplacementInvocationInfo, refactoredPermy.ReplacementInvocationInfo.LiteralParams.Concat(h.parameters).ToList())) { ReplacementInvocation = AddParms(refactoredPermy.ReplacementInvocation, h.parameters) }; } } }