public static void RenameConflicting(ParametrizedNode method)
{
// variable name => case sensitive variable name
// value is null if there are multiple casings for the variable -> the variable is conflicting
Dictionary <string, string> caseInsensitive = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
LookupTableVisitor ltv = new LookupTableVisitor(SupportedLanguage.CSharp);
method.AcceptVisitor(ltv, null);
// add method name to caseInsensitive
AddVariableToDict(caseInsensitive, method.Name, true);
// add method parameters to caseInsensitive
foreach (ParameterDeclarationExpression pde in method.Parameters)
{
AddVariableToDict(caseInsensitive, pde.ParameterName, true);
}
// add local variables to caseInsensitive
foreach (KeyValuePair <string, List <LocalLookupVariable> > var in ltv.Variables)
{
AddVariableToDict(caseInsensitive, var.Key, true);
}
// add used identifiers to caseInsensitive
FindIdentifiersVisitor fvv = new FindIdentifiersVisitor();
method.AcceptVisitor(fvv, null);
foreach (KeyValuePair <string, string> pair in fvv.usedIdentifiers)
{
AddVariableToDict(caseInsensitive, pair.Key, false);
}
int index = 0;
foreach (ParameterDeclarationExpression pde in method.Parameters)
{
if (caseInsensitive[pde.ParameterName] == null)
{
RenameVariable(method, pde.ParameterName, ref index);
}
}
foreach (KeyValuePair <string, List <LocalLookupVariable> > var in ltv.Variables)
{
if (caseInsensitive[var.Key] == null)
{
RenameVariable(method, var.Key, ref index);
}
}
}
public static void RenameConflicting(ParametrizedNode method)
{
// variable name => case sensitive variable name
// value is null if there are multiple casings for the variable -> the variable is conflicting
Dictionary<string, string> caseInsensitive = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
LookupTableVisitor ltv = new LookupTableVisitor(SupportedLanguage.CSharp);
method.AcceptVisitor(ltv, null);
// add method parameters to caseInsensitive
foreach (ParameterDeclarationExpression pde in method.Parameters) {
AddVariableToDict(caseInsensitive, pde.ParameterName, true);
}
// add local variables to caseInsensitive
foreach (KeyValuePair<string, List<LocalLookupVariable>> var in ltv.Variables) {
AddVariableToDict(caseInsensitive, var.Key, true);
}
// add used identifiers to caseInsensitive
FindIdentifiersVisitor fvv = new FindIdentifiersVisitor();
method.AcceptVisitor(fvv, null);
foreach (KeyValuePair<string, string> pair in fvv.usedIdentifiers) {
AddVariableToDict(caseInsensitive, pair.Key, false);
}
int index = 0;
foreach (ParameterDeclarationExpression pde in method.Parameters) {
if (caseInsensitive[pde.ParameterName] == null) {
RenameVariable(method, pde.ParameterName, ref index);
}
}
foreach (KeyValuePair<string, List<LocalLookupVariable>> var in ltv.Variables) {
if (caseInsensitive[var.Key] == null) {
RenameVariable(method, var.Key, ref index);
}
}
}
// protected Dom.IMember GetParentMember(ICSharpCode.TextEditor.TextEditorControl textEditor, TextLocation location)
// {
// return GetParentMember(textEditor, location.Line, location.Column);
// }
// protected Dom.IMember GetParentMember(ICSharpCode.TextEditor.TextEditorControl textEditor, int line, int column)
// {
// Dom.ParseInformation parseInfo = ParserService.GetParseInformation(textEditor.FileName);
// if (parseInfo != null) {
// Dom.IClass c = parseInfo.MostRecentCompilationUnit.GetInnermostClass(line, column);
// if (c != null) {
// foreach (Dom.IMember member in c.Properties) {
// if (member.BodyRegion.IsInside(line, column)) {
// return member;
// }
// }
// foreach (Dom.IMember member in c.Methods) {
// if (member.BodyRegion.IsInside(line, column)) {
// return member;
// }
// }
// }
// }
//
// return null;
// }
// protected ParametrizedNode GetParentMember(int startLine, int startColumn, int endLine, int endColumn)
// {
// using (IParser parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, new StringReader(this.currentDocument.TextContent))) {
// parser.Parse();
//
// if (parser.Errors.Count > 0) {
// MessageService.ShowError(null, parser.Errors.ErrorOutput);
// return null;
// }
//
// FindMemberVisitor fmv = new FindMemberVisitor(startColumn, startLine, endColumn, endLine);
//
// parser.CompilationUnit.AcceptVisitor(fmv, null);
//
// return fmv.Member;
// }
// }
protected static bool HasOccurrencesAfter(StringComparer nameComparer, ParametrizedNode member, Location location, string name, Location start, Location end)
{
FindReferenceVisitor frv = new FindReferenceVisitor(nameComparer, name, start, end);
member.AcceptVisitor(frv, null);
foreach (IdentifierExpression identifier in frv.Identifiers)
{
if (identifier.StartLocation > location)
{
return(true);
}
}
return(false);
}
// public override bool Extract(MethodDeclaration md, Window window, List<INode> children)
public bool Extract(ParametrizedNode parentNode, Window window, List <INode> children)
{
this.currentSelection = new MySelection(children.GetRange(window.Top, window.Size));
// this.start = new Location(this.currentSelection.StartPosition.Column + 1, this.currentSelection.StartPosition.Line + 1);
// this.end = new Location(this.currentSelection.EndPosition.Column + 1, this.currentSelection.EndPosition.Line + 1);
this.start = this.currentSelection.StartPosition;
this.end = this.currentSelection.EndPosition;
this.parentNode = parentNode;
MethodDeclaration newMethod = new MethodDeclaration();
// Initialise new method
newMethod.Body = GetBlock(currentSelection.Nodes);
newMethod.Body.StartLocation = new Location(0, 0);
List <VariableDeclaration> possibleReturnValues = new List <VariableDeclaration>();
List <VariableDeclaration> otherReturnValues = new List <VariableDeclaration>();
if (!CheckForJumpInstructions(newMethod, this.currentSelection))
{
return(false);
}
newMethod.Modifier = parentNode.Modifier;
newMethod.Modifier &= ~(Modifiers.Internal | Modifiers.Protected | Modifiers.Private | Modifiers.Public | Modifiers.Override);
LookupTableVisitor ltv = new LookupTableVisitor(SupportedLanguage.CSharp);
parentNode.AcceptVisitor(ltv, null);
var variablesList = (from list in ltv.Variables.Values
from item in list
select new Variable(item)).Where(v => !(v.StartPos > end || v.EndPos < start) && HasReferencesInSelection(currentSelection, v)).Union(FromParameters(newMethod)).Select(va => ResolveVariable(va));
foreach (var variable in variablesList)
{
bool hasOccurrencesAfter = HasOccurrencesAfter(CSharpNameComparer, this.parentNode, end, variable.Name, variable.StartPos, variable.EndPos);
bool isInitialized = (variable.Initializer != null) ? !variable.Initializer.IsNull : false;
bool hasAssignment = HasAssignment(newMethod, variable);
if (IsInSel(variable.StartPos, this.currentSelection) && hasOccurrencesAfter)
{
possibleReturnValues.Add(new VariableDeclaration(variable.Name, variable.Initializer, variable.Type));
otherReturnValues.Add(new VariableDeclaration(variable.Name, variable.Initializer, variable.Type));
}
if (!(IsInSel(variable.StartPos, this.currentSelection) || IsInSel(variable.EndPos, this.currentSelection)))
{
ParameterDeclarationExpression newParam = null;
if ((hasOccurrencesAfter && isInitialized) || variable.WasRefParam)
{
newParam = new ParameterDeclarationExpression(variable.Type, variable.Name, ParameterModifiers.Ref);
}
else
{
if ((hasOccurrencesAfter && hasAssignment) || variable.WasOutParam)
{
newParam = new ParameterDeclarationExpression(variable.Type, variable.Name, ParameterModifiers.Out);
}
else
{
if (!hasOccurrencesAfter)
{
newParam = new ParameterDeclarationExpression(variable.Type, variable.Name, ParameterModifiers.None);
}
else
{
if (!hasOccurrencesAfter && !isInitialized)
{
newMethod.Body.Children.Insert(0, new LocalVariableDeclaration(new VariableDeclaration(variable.Name, variable.Initializer, variable.Type)));
}
else
{
newParam = new ParameterDeclarationExpression(variable.Type, variable.Name, ParameterModifiers.In);
}
}
}
}
if (newParam != null)
{
newMethod.Parameters.Add(newParam);
}
}
}
List <VariableDeclaration> paramsAsVarDecls = new List <VariableDeclaration>();
this.beforeCallDeclarations = new List <LocalVariableDeclaration>();
for (int i = 0; i < otherReturnValues.Count - 1; i++)
{
VariableDeclaration varDecl = otherReturnValues[i];
paramsAsVarDecls.Add(varDecl);
ParameterDeclarationExpression p = new ParameterDeclarationExpression(varDecl.TypeReference, varDecl.Name);
p.ParamModifier = ParameterModifiers.Out;
if (!newMethod.Parameters.Contains(p))
{
newMethod.Parameters.Add(p);
}
else
{
this.beforeCallDeclarations.Add(new LocalVariableDeclaration(varDecl));
}
}
CreateReturnStatement(newMethod, possibleReturnValues);
newMethod.Name = "NewMethod";
this.extractedMethod = newMethod;
return(true);
}
