|
public AcceptVisitor ( |
||
| visitor | ||
| data | object | |
| return | bool | |
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 ExtractMethodForm(MethodDeclaration declaration, Func<IOutputAstVisitor> generator)
{
//
// The InitializeComponent() call is required for Windows Forms designer support.
//
InitializeComponent();
SetTranslation(this);
this.declaration = declaration;
this.generator = generator;
IOutputAstVisitor visitor = this.generator.Invoke();
body = declaration.Body;
declaration.Body = new BlockStatement();
declaration.AcceptVisitor(visitor, null);
this.txtName.Text = this.declaration.Name;
this.txtPreview.Text = visitor.Text;
this.txtName.SelectAll();
}
protected void CreateReturnStatement(MethodDeclaration newMethod, List<VariableDeclaration> possibleReturnValues)
{
HasReturnStatementVisitor hrsv = new HasReturnStatementVisitor();
newMethod.AcceptVisitor(hrsv, null);
if (hrsv.HasReturn) {
if (this.parentNode is MethodDeclaration)
newMethod.TypeReference = (this.parentNode as MethodDeclaration).TypeReference;
if (this.parentNode is PropertyDeclaration)
newMethod.TypeReference = (this.parentNode as PropertyDeclaration).TypeReference;
if (this.parentNode is OperatorDeclaration)
newMethod.TypeReference = (this.parentNode as OperatorDeclaration).TypeReference;
} else {
if (possibleReturnValues.Count > 0) {
newMethod.TypeReference = possibleReturnValues[possibleReturnValues.Count - 1].TypeReference;
newMethod.Body.Children.Add(new ReturnStatement(new IdentifierExpression(possibleReturnValues[possibleReturnValues.Count - 1].Name)));
this.returnedVariable = possibleReturnValues[possibleReturnValues.Count - 1];
} else {
newMethod.TypeReference = new TypeReference("System.Void", true);
this.returnedVariable = null;
}
}
}
private MethodDeclaration MakePermutation(MethodDeclaration right, IEnumerable<PrimExpSet> prim_groups)
{
ResetNameCount();
right = right.DeepCopy();
var rights_primitives = right.AllPrimitiveExpressions();
foreach (var prim_grp in prim_groups)
{
var param_name = NextName();
var typeRef = new TypeReference(prim_grp.ValueType.FullName);
right.Parameters.Add(new ParameterDeclarationExpression(typeRef, param_name));
var replacer = new PrimitiveReplacer();
foreach (var pos in prim_grp.Positions)
{
replacer.AddReplacement(rights_primitives[pos], new IdentifierExpression(param_name));
}
right.AcceptVisitor(replacer, null);
}
return right;
}
IEnumerable<Variable> FromParameters(MethodDeclaration newMethod)
{
if (parentNode is ParametrizedNode) {
foreach (ParameterDeclarationExpression pde in (parentNode as ParametrizedNode).Parameters) {
FindReferenceVisitor frv = new FindReferenceVisitor(CSharpNameComparer, pde.ParameterName, newMethod.Body.StartLocation, newMethod.Body.EndLocation);
newMethod.AcceptVisitor(frv, null);
if (frv.Identifiers.Count > 0) {
pde.ParamModifier &= ~(ParameterModifiers.Params);
if (parentNode is MethodDeclaration) {
yield return new Variable((parentNode as MethodDeclaration).Body, pde);
} else if (parentNode is ConstructorDeclaration) {
yield return new Variable((parentNode as ConstructorDeclaration).Body, pde);
} else if (parentNode is PropertyDeclaration) {
var p = parentNode as PropertyDeclaration;
yield return new Variable(p.BodyStart, p.BodyEnd, pde);
} else {
throw new NotSupportedException("not supported!");
}
}
}
}
if (parentNode is PropertyDeclaration && IsInSetter(parentNode as PropertyDeclaration)) {
PropertyDeclaration pd = parentNode as PropertyDeclaration;
yield return new Variable(
new LocalLookupVariable(
"value", pd.TypeReference,
pd.SetRegion.StartLocation, pd.SetRegion.EndLocation,
false, false, null, null, false
)
);
}
}
bool HasReferencesInSelection(MethodDeclaration newMethod, Variable variable)
{
FindReferenceVisitor frv = new FindReferenceVisitor(CSharpNameComparer, variable.Name,
newMethod.Body.StartLocation, newMethod.Body.EndLocation);
newMethod.AcceptVisitor(frv, null);
return frv.Identifiers.Count > 0;
}
IEnumerable<Variable> FromParameters(MethodDeclaration newMethod)
{
foreach (ParameterDeclarationExpression pde in parentNode.Parameters) {
FindReferenceVisitor frv = new FindReferenceVisitor(CSharpNameComparer, pde.ParameterName, newMethod.Body.StartLocation, newMethod.Body.EndLocation);
newMethod.AcceptVisitor(frv, null);
if (frv.Identifiers.Count > 0) {
pde.ParamModifier &= ~(ParameterModifiers.Params);
if (parentNode is MethodDeclaration) {
yield return new Variable((parentNode as MethodDeclaration).Body, pde);
} else {
throw new NotSupportedException("not supported!");
}
}
}
}
protected static bool HasAssignment(MethodDeclaration method, Variable variable)
{
HasAssignmentsVisitor hav = new HasAssignmentsVisitor(variable.Name, variable.Type, variable.StartPos, variable.EndPos);
method.AcceptVisitor(hav, null);
return hav.HasAssignment;
}
protected ErrorKind CheckForJumpInstructions(MethodDeclaration method)
{
FindJumpInstructionsVisitor fjiv = new FindJumpInstructionsVisitor(method);
method.AcceptVisitor(fjiv, null);
return fjiv.DoCheck();
}
protected static bool CheckForJumpInstructions(MethodDeclaration method, ISelection selection)
{
FindJumpInstructionsVisitor fjiv = new FindJumpInstructionsVisitor(method, selection);
method.AcceptVisitor(fjiv, null);
return fjiv.IsOk;
}