/* public override void ImplementMembers (RefactorerContext ctx, IType cls,
* IEnumerable<KeyValuePair<IMember,IReturnType>> members,
* string foldingRegionName)
* {
* base.ImplementMembers (ctx, cls, FixGenericImpl (ctx, cls, members), foldingRegionName);
* }
* static Ambience amb = new MonoDevelop.CSharpBinding.CSharpAmbience ();
* // Workaround for bug in the code generator. Generic private implementation types are not generated correctly when they are generic.
* IEnumerable<KeyValuePair<IMember,IReturnType>> FixGenericImpl (RefactorerContext ctx, IType cls, IEnumerable<KeyValuePair<IMember,IReturnType>> members)
* {
* foreach (KeyValuePair<IMember,IReturnType> kvp in members) {
* if (kvp.Value == null) {
* yield return kvp;
* continue;
* }
*
* string tn = amb.GetString (kvp.Value, OutputFlags.IncludeGenerics | OutputFlags.UseFullName | OutputFlags.UseIntrinsicTypeNames);
* Console.WriteLine ("tn :" + tn);
* yield return new KeyValuePair<IMember,IReturnType> (kvp.Key, new DomReturnType (tn));
* }
* }*/
static void SetContext(IEnumerable <MemberReference> references, RefactorerContext ctx)
{
foreach (MemberReference r in references)
{
r.SetContext(ctx);
}
}
public override void PerformChange(IProgressMonitor monitor, RefactorerContext rctx)
{
if (rctx == null)
{
throw new InvalidOperationException("Refactory context not available.");
}
TextEditorData textEditorData = this.TextEditorData;
if (textEditorData == null)
{
IEditableTextFile file = rctx.GetFile(FileName);
if (file != null)
{
if (RemovedChars > 0)
{
file.DeleteText(Offset, RemovedChars);
}
if (!string.IsNullOrEmpty(InsertedText))
{
file.InsertText(Offset, InsertedText);
}
rctx.Save();
}
}
else if (textEditorData != null)
{
int charsInserted = textEditorData.Replace(Offset, RemovedChars, InsertedText);
if (MoveCaretToReplace)
{
textEditorData.Caret.Offset = Offset + charsInserted;
}
}
}
public override int AddFoldingRegion(RefactorerContext ctx, IType cls, string regionName)
{
IEditableTextFile buffer = ctx.GetFile(cls.CompilationUnit.FileName);
int pos = GetNewMethodPosition(buffer, cls);
string eolMarker = Environment.NewLine;
if (cls.SourceProject != null)
{
TextStylePolicy policy = cls.SourceProject.Policies.Get <TextStylePolicy> ();
if (policy != null)
{
eolMarker = policy.GetEolMarker();
}
}
int line, col;
buffer.GetLineColumnFromPosition(pos, out line, out col);
string indent = buffer.GetText(buffer.GetPositionFromLineColumn(line, 1), pos);
string pre = "#region " + regionName + eolMarker;
string post = indent + "#endregion" + eolMarker;
buffer.InsertText(pos, pre + post);
return(pos + pre.Length);
}
public override IClass RenameClass(RefactorerContext ctx, IClass cls, string newName)
{
IEditableTextFile file = ctx.GetFile(cls.Region.FileName);
if (file == null)
{
return(null);
}
int pos1 = file.GetPositionFromLineColumn(cls.Region.BeginLine, cls.Region.BeginColumn);
int pos2 = file.GetPositionFromLineColumn(cls.Region.EndLine, cls.Region.EndColumn);
string txt = file.GetText(pos1, pos2);
Regex targetExp = new Regex(@"\sclass\s*(" + cls.Name + @")\s", RegexOptions.Multiline);
Match match = targetExp.Match(" " + txt + " ");
if (!match.Success)
{
return(null);
}
int pos = pos1 + match.Groups [1].Index - 1;
file.DeleteText(pos, cls.Name.Length);
file.InsertText(pos, newName);
return(GetGeneratedClass(ctx, file, cls));
}
public override void PerformChange(IProgressMonitor monitor, RefactorerContext rctx)
{
FileService.RenameFile(OldName, NewName);
if (rctx.ParserContext.Project != null)
{
IdeApp.ProjectOperations.Save(rctx.ParserContext.Project);
}
}
public override DomLocation CompleteStatement(RefactorerContext ctx, string fileName, DomLocation caretLocation)
{
IEditableTextFile file = ctx.GetFile(fileName);
int pos = file.GetPositionFromLineColumn(caretLocation.Line + 1, 1);
StringBuilder line = new StringBuilder();
int lineNr = caretLocation.Line + 1, column = 1, maxColumn = 1, lastPos = pos;
while (lineNr == caretLocation.Line + 1)
{
maxColumn = column;
lastPos = pos;
line.Append(file.GetCharAt(pos));
pos++;
file.GetLineColumnFromPosition(pos, out lineNr, out column);
}
string trimmedline = line.ToString().Trim();
string indent = line.ToString().Substring(0, line.Length - line.ToString().TrimStart(' ', '\t').Length);
if (trimmedline.EndsWith(";") || trimmedline.EndsWith("{"))
{
return(caretLocation);
}
if (trimmedline.StartsWith("if") ||
trimmedline.StartsWith("while") ||
trimmedline.StartsWith("switch") ||
trimmedline.StartsWith("for") ||
trimmedline.StartsWith("foreach"))
{
if (!trimmedline.EndsWith(")"))
{
file.InsertText(lastPos, " () {" + Environment.NewLine + indent + TextEditorProperties.IndentString + Environment.NewLine + indent + "}");
caretLocation.Column = maxColumn + 1;
}
else
{
file.InsertText(lastPos, " {" + Environment.NewLine + indent + TextEditorProperties.IndentString + Environment.NewLine + indent + "}");
caretLocation.Column = indent.Length + 1;
caretLocation.Line++;
}
}
else if (trimmedline.StartsWith("do"))
{
file.InsertText(lastPos, " {" + Environment.NewLine + indent + TextEditorProperties.IndentString + Environment.NewLine + indent + "} while ();");
caretLocation.Column = indent.Length + 1;
caretLocation.Line++;
}
else
{
file.InsertText(lastPos, ";" + Environment.NewLine + indent);
caretLocation.Column = indent.Length;
caretLocation.Line++;
}
return(caretLocation);
}
public override void AddGlobalNamespaceImport(RefactorerContext ctx, string fileName, string nsName)
{
IEditableTextFile file = ctx.GetFile(fileName);
int pos = 0;
ParsedDocument parsedDocument = parser.Parse(ctx.ParserContext, fileName, file.Text);
StringBuilder text = new StringBuilder();
if (parsedDocument.CompilationUnit != null)
{
IUsing lastUsing = null;
foreach (IUsing u in parsedDocument.CompilationUnit.Usings)
{
if (u.IsFromNamespace)
{
break;
}
lastUsing = u;
}
if (lastUsing != null)
{
pos = file.GetPositionFromLineColumn(lastUsing.Region.End.Line, lastUsing.Region.End.Column);
}
}
if (pos != 0)
{
text.AppendLine();
}
text.Append("using ");
text.Append(nsName);
text.Append(";");
if (file is Mono.TextEditor.ITextEditorDataProvider)
{
Mono.TextEditor.TextEditorData data = ((Mono.TextEditor.ITextEditorDataProvider)file).GetTextEditorData();
if (pos == 0)
{
text.Append(data.EolMarker);
}
int caretOffset = data.Caret.Offset;
int insertedChars = data.Insert(pos, text.ToString());
if (pos < caretOffset)
{
data.Caret.Offset = caretOffset + insertedChars;
}
}
else
{
if (pos == 0)
{
text.AppendLine();
}
file.InsertText(pos, text.ToString());
}
}
public override DomLocation CompleteStatement(RefactorerContext ctx, string fileName, DomLocation caretLocation)
{
var provider = ctx.GetFile(fileName) as ITextEditorDataProvider;
if (provider == null)
{
return(caretLocation);
}
var file = provider.GetTextEditorData();
var line = file.GetLine(caretLocation.Line);
var maxColumn = line.EditableLength;
var lastPos = line.Offset + line.EditableLength;
string trimmedline = file.GetLineText(caretLocation.Line, false).Trim();
string indent = file.GetLineIndent(line);
if (trimmedline.EndsWith(";") || trimmedline.EndsWith("{"))
{
return(caretLocation);
}
if (trimmedline.StartsWith("if") ||
trimmedline.StartsWith("while") ||
trimmedline.StartsWith("switch") ||
trimmedline.StartsWith("for") ||
trimmedline.StartsWith("foreach"))
{
if (!trimmedline.EndsWith(")"))
{
file.Insert(lastPos, " () {" + file.EolMarker + indent + TextEditorProperties.IndentString + file.EolMarker + indent + "}");
caretLocation.Column = maxColumn + 1;
}
else
{
file.Insert(lastPos, " {" + file.EolMarker + indent + TextEditorProperties.IndentString + file.EolMarker + indent + "}");
caretLocation.Column = maxColumn + 1;
caretLocation.Line++;
}
}
else if (trimmedline.StartsWith("do"))
{
file.Insert(lastPos, " {" + file.EolMarker + indent + TextEditorProperties.IndentString + file.EolMarker + indent + "} while ();");
caretLocation.Column = indent.Length + 1;
caretLocation.Line++;
}
else
{
file.Insert(lastPos, ";" + file.EolMarker + indent);
caretLocation.Column = indent.Length;
caretLocation.Line++;
}
return(caretLocation);
}
public override IMember ImplementMember(RefactorerContext ctx, IType cls, IMember member, IReturnType privateImplementationType)
{
if (privateImplementationType != null)
{
// Workaround for bug in the code generator. Generic private implementation types are not generated correctly when they are generic.
Ambience amb = new CSharpAmbience();
string tn = amb.GetString(privateImplementationType, OutputFlags.IncludeGenerics | OutputFlags.UseFullName | OutputFlags.UseIntrinsicTypeNames);
privateImplementationType = new DomReturnType(tn);
}
return(base.ImplementMember(ctx, cls, member, privateImplementationType));
}
public override IEnumerable <MemberReference> FindClassReferences(RefactorerContext ctx, string fileName, IType cls, bool includeXmlComment)
{
IEditableTextFile file = ctx.GetFile(fileName);
NRefactoryResolver resolver = new NRefactoryResolver(ctx.ParserContext, cls.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, null, fileName);
FindMemberAstVisitor visitor = new FindMemberAstVisitor(resolver, file, cls);
visitor.IncludeXmlDocumentation = includeXmlComment;
visitor.RunVisitor();
SetContext(visitor.FoundReferences, ctx);
return(visitor.FoundReferences);
}
//TODO
//static CodeStatement ThrowNewNotImplementedException ()
//{
// CodeExpression expr = new CodeSnippetExpression ("new NotImplementedException ()");
// return new CodeThrowExceptionStatement (expr);
//}
//
//public override IMember AddMember (RefactorerContext ctx, IType cls, CodeTypeMember member)
//{
// if (member is CodeMemberProperty) {
// CodeMemberProperty prop = (CodeMemberProperty) member;
// if (prop.HasGet && prop.GetStatements.Count == 0)
// prop.GetStatements.Add (ThrowNewNotImplementedException ());
// if (prop.HasSet && prop.SetStatements.Count == 0)
// prop.SetStatements.Add (ThrowNewNotImplementedException ());
// } else if (member is CodeMemberMethod) {
// CodeMemberMethod method = (CodeMemberMethod) member;
// if (method.Statements.Count == 0)
// method.Statements.Add (ThrowNewNotImplementedException ());
// }
//
// return base.AddMember (ctx, cls, member);
//}
protected override void EncapsulateFieldImpGetSet(RefactorerContext ctx, IType cls, IField field, CodeMemberProperty prop)
{
if (prop.HasGet && prop.GetStatements.Count == 0)
{
prop.GetStatements.Add(new CodeSnippetExpression("return " + field.Name));
}
if (prop.HasSet && prop.SetStatements.Count == 0)
{
prop.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(field.Name), new CodeVariableReferenceExpression("value")));
}
}
public override IEnumerable <MemberReference> FindParameterReferences(RefactorerContext ctx, string fileName, IParameter param, bool includeXmlComment)
{
NRefactoryResolver resolver = new NRefactoryResolver(ctx.ParserContext, param.DeclaringMember.DeclaringType.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, null, fileName);
resolver.CallingMember = param.DeclaringMember;
FindMemberAstVisitor visitor = new FindMemberAstVisitor(resolver, ctx.GetFile(fileName), param);
visitor.IncludeXmlDocumentation = includeXmlComment;
visitor.RunVisitor();
SetContext(visitor.FoundReferences, ctx);
return(visitor.FoundReferences);
}
public override IEnumerable <MemberReference> FindVariableReferences(RefactorerContext ctx, string fileName, LocalVariable var)
{
//System.Console.WriteLine("Find variable references !!!");
// ParsedDocument parsedDocument = ProjectDomService.ParseFile (fileName);
NRefactoryResolver resolver = new NRefactoryResolver(ctx.ParserContext, var.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, null, fileName);
resolver.CallingMember = var.DeclaringMember;
FindMemberAstVisitor visitor = new FindMemberAstVisitor(resolver, ctx.GetFile(fileName), var);
visitor.RunVisitor();
SetContext(visitor.FoundReferences, ctx);
return(visitor.FoundReferences);
}
public override IEnumerable <MemberReference> FindVariableReferences(RefactorerContext ctx, string fileName, LocalVariable var)
{
var editor = ((Mono.TextEditor.ITextEditorDataProvider)ctx.GetFile(fileName)).GetTextEditorData();
NRefactoryResolver resolver = new NRefactoryResolver(ctx.ParserContext, var.CompilationUnit, ICSharpCode.OldNRefactory.SupportedLanguage.CSharp, editor, fileName);
resolver.CallingMember = var.DeclaringMember;
FindMemberAstVisitor visitor = new FindMemberAstVisitor(editor.Document, var);
visitor.RunVisitor(resolver);
SetContext(visitor.FoundReferences, ctx);
return(visitor.FoundReferences);
}
public override IEnumerable <MemberReference> FindMemberReferences(RefactorerContext ctx, string fileName, IType cls, IMember member, bool includeXmlComment)
{
ParsedDocument parsedDocument = parser.Parse(cls.SourceProjectDom, fileName, ctx.GetFile(fileName).Text);
NRefactoryResolver resolver = new NRefactoryResolver(ctx.ParserContext, parsedDocument.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, null, fileName);
resolver.SetupParsedCompilationUnit(parser.LastUnit);
resolver.CallingMember = member;
FindMemberAstVisitor visitor = new FindMemberAstVisitor(resolver, ctx.GetFile(fileName), member);
visitor.IncludeXmlDocumentation = includeXmlComment;
visitor.RunVisitor();
SetContext(visitor.FoundReferences, ctx);
return(visitor.FoundReferences);
}
public override IEnumerable <MemberReference> FindClassReferences(RefactorerContext ctx, string fileName, IType cls, bool includeXmlComment)
{
var editor = ((Mono.TextEditor.ITextEditorDataProvider)ctx.GetFile(fileName)).GetTextEditorData();
var doc = ProjectDomService.GetParsedDocument(ctx.ParserContext, fileName);
if (doc == null || doc.CompilationUnit == null)
{
return(null);
}
NRefactoryResolver resolver = new NRefactoryResolver(ctx.ParserContext, doc.CompilationUnit, ICSharpCode.OldNRefactory.SupportedLanguage.CSharp, editor, fileName);
FindMemberAstVisitor visitor = new FindMemberAstVisitor(editor.Document, cls);
visitor.IncludeXmlDocumentation = includeXmlComment;
visitor.RunVisitor(resolver);
SetContext(visitor.FoundReferences, ctx);
return(visitor.FoundReferences);
}
public static void AcceptChanges(IProgressMonitor monitor, ProjectDom dom, List <Change> changes, MonoDevelop.Projects.Text.ITextFileProvider fileProvider)
{
RefactorerContext rctx = new RefactorerContext(dom, fileProvider, null);
RenameHandler handler = new RenameHandler(changes);
FileService.FileRenamed += handler.FileRename;
for (int i = 0; i < changes.Count; i++)
{
changes[i].PerformChange(monitor, rctx);
TextReplaceChange replaceChange = changes[i] as TextReplaceChange;
if (replaceChange == null)
{
continue;
}
for (int j = i + 1; j < changes.Count; j++)
{
TextReplaceChange change = changes[j] as TextReplaceChange;
if (change == null)
{
continue;
}
if (replaceChange.Offset >= 0 && change.Offset >= 0 && replaceChange.FileName == change.FileName)
{
if (replaceChange.Offset < change.Offset)
{
change.Offset -= replaceChange.RemovedChars;
if (!string.IsNullOrEmpty(replaceChange.InsertedText))
{
change.Offset += replaceChange.InsertedText.Length;
}
}
else if (replaceChange.Offset < change.Offset + change.RemovedChars)
{
change.RemovedChars -= replaceChange.RemovedChars;
change.Offset = replaceChange.Offset + replaceChange.InsertedText.Length;
}
}
}
}
FileService.FileRenamed -= handler.FileRename;
TextReplaceChange.FinishRefactoringOperation();
}
public abstract void PerformChange(IProgressMonitor monitor, RefactorerContext rctx);
public override void PerformChange(IProgressMonitor monitor, RefactorerContext rctx)
{
Console.WriteLine("SAVE !!!!");
IdeApp.ProjectOperations.Save(this.Project);
}
public override void PerformChange(IProgressMonitor monitor, RefactorerContext rctx)
{
IdeApp.Workbench.OpenDocument(FileName);
}
public override void PerformChange(IProgressMonitor monitor, RefactorerContext rctx)
{
File.WriteAllText(FileName, Content);
rctx.ParserContext.Project.AddFile(FileName);
IdeApp.ProjectOperations.Save(rctx.ParserContext.Project);
}
public override IType RenameClass(RefactorerContext ctx, IType cls, string newName)
{
IEditableTextFile file;
int pos, begin, end;
Match match;
Regex expr;
string txt;
foreach (IType pclass in cls.Parts)
{
if (pclass.BodyRegion.IsEmpty || (file = ctx.GetFile(pclass.CompilationUnit.FileName)) == null)
{
continue;
}
begin = file.GetPositionFromLineColumn(pclass.BodyRegion.Start.Line, pclass.BodyRegion.Start.Column);
end = file.GetPositionFromLineColumn(pclass.BodyRegion.End.Line, pclass.BodyRegion.End.Column);
if (begin == -1 || end == -1)
{
continue;
}
txt = file.GetText(begin, end);
switch (cls.ClassType)
{
case ClassType.Interface:
expr = new Regex(@"\sinterface\s*(" + cls.Name + @")(\s|:)", RegexOptions.Multiline);
break;
case ClassType.Struct:
expr = new Regex(@"\sstruct\s*(" + cls.Name + @")(\s|:)", RegexOptions.Multiline);
break;
case ClassType.Enum:
expr = new Regex(@"\senum\s*(" + cls.Name + @")(\s|:)", RegexOptions.Multiline);
break;
default:
expr = new Regex(@"\sclass\s*(" + cls.Name + @")(\s|:)", RegexOptions.Multiline);
break;
}
match = expr.Match(" " + txt + " ");
if (!match.Success)
{
continue;
}
pos = begin + match.Groups [1].Index - 1;
file.DeleteText(pos, cls.Name.Length);
file.InsertText(pos, newName);
}
file = ctx.GetFile(cls.CompilationUnit.FileName);
return(GetGeneratedClass(ctx, file, cls));
}
public override MemberReferenceCollection FindMemberReferences(RefactorerContext ctx, string fileName, IClass cls, IMember member)
{
return(null);
}
public override void AddLocalNamespaceImport(RefactorerContext ctx, string fileName, string nsName, DomLocation caretLocation)
{
IEditableTextFile file = ctx.GetFile(fileName);
int pos = 0;
ParsedDocument parsedDocument = parser.Parse(ctx.ParserContext, fileName, file.Text);
StringBuilder text = new StringBuilder();
string indent = "";
if (parsedDocument.CompilationUnit != null)
{
IUsing containingUsing = null;
foreach (IUsing u in parsedDocument.CompilationUnit.Usings)
{
if (u.IsFromNamespace && u.Region.Contains(caretLocation))
{
containingUsing = u;
}
}
if (containingUsing != null)
{
indent = GetLineIndent(file, containingUsing.Region.Start.Line);
IUsing lastUsing = null;
foreach (IUsing u in parsedDocument.CompilationUnit.Usings)
{
if (u == containingUsing)
{
continue;
}
if (containingUsing.Region.Contains(u.Region))
{
if (u.IsFromNamespace)
{
break;
}
lastUsing = u;
}
}
if (lastUsing != null)
{
pos = file.GetPositionFromLineColumn(lastUsing.Region.End.Line, lastUsing.Region.End.Column);
}
else
{
pos = file.GetPositionFromLineColumn(containingUsing.ValidRegion.Start.Line, containingUsing.ValidRegion.Start.Column);
// search line end
while (pos < file.Length)
{
char ch = file.GetCharAt(pos);
if (ch == '\n')
{
if (file.GetCharAt(pos + 1) == '\r')
{
pos++;
}
break;
}
else if (ch == '\r')
{
break;
}
pos++;
}
}
}
else
{
AddGlobalNamespaceImport(ctx, fileName, nsName);
return;
}
}
if (pos != 0)
{
text.AppendLine();
}
text.Append(indent);
text.Append("\t");
text.Append("using ");
text.Append(nsName);
text.Append(";");
if (file is Mono.TextEditor.ITextEditorDataProvider)
{
Mono.TextEditor.TextEditorData data = ((Mono.TextEditor.ITextEditorDataProvider)file).GetTextEditorData();
if (pos == 0)
{
text.Append(data.EolMarker);
}
int caretOffset = data.Caret.Offset;
int insertedChars = data.Insert(pos, text.ToString());
if (pos < caretOffset)
{
data.Caret.Offset = caretOffset + insertedChars;
}
}
else
{
if (pos == 0)
{
text.AppendLine();
}
file.InsertText(pos, text.ToString());
}
}
