void FindReferences(object sender, EventArgs e)
{
MenuCommand item = (MenuCommand)sender;
IMember member = (IMember)item.Tag;
string memberName = member.DeclaringType.Name + "." + member.Name;
using (AsynchronousWaitDialog monitor = AsynchronousWaitDialog.ShowWaitDialog("${res:SharpDevelop.Refactoring.FindReferences}"))
{
FindReferencesAndRenameHelper.ShowAsSearchResults(StringParser.Parse("${res:SharpDevelop.Refactoring.ReferencesTo}",
new string[, ] {
{ "Name", memberName }
}),
RefactoringService.FindReferences(member, monitor));
}
}
void FindReferences(object sender, EventArgs e)
{
MenuCommand item = (MenuCommand)sender;
IClass c = (IClass)item.Tag;
using (AsynchronousWaitDialog monitor = AsynchronousWaitDialog.ShowWaitDialog("${res:SharpDevelop.Refactoring.FindReferences}"))
{
FindReferencesAndRenameHelper.ShowAsSearchResults(
StringParser.Parse("${res:SharpDevelop.Refactoring.ReferencesTo}",
new string[, ] {
{ "Name", c.Name }
}),
RefactoringService.FindReferences(c, monitor)
);
}
}
public ToolStripItem[] BuildSubmenu(Codon codon, object owner)
{
MenuCommand cmd;
IClass c;
ClassNode classNode = owner as ClassNode;
if (classNode != null)
{
c = classNode.Class;
}
else
{
ClassBookmark bookmark = (ClassBookmark)owner;
c = bookmark.Class;
}
ParserService.ParseCurrentViewContent();
c = c.ProjectContent.GetClass(c.FullyQualifiedName, c.TypeParameters.Count, c.ProjectContent.Language, GetClassOptions.LookForInnerClass);
c = GetCurrentPart(c);
if (c == null)
{
return(new ToolStripMenuItem[0]);
}
List <ToolStripItem> list = new List <ToolStripItem>();
// "Go to base" for classes is not that useful as it is faster to click the base class in the editor.
// Also, we have "Find base classes" which shows all base classes.
// if (c.BaseTypes.Count > 0) {
// list.Add(new MenuSeparator());
// cmd = new MenuCommand("${res:SharpDevelop.Refactoring.GoToBaseCommand}", GoToBase);
// cmd.Tag = c;
// list.Add(cmd);
// }
cmd = FindReferencesAndRenameHelper.MakeFindReferencesMenuCommand(FindReferences);
cmd.Tag = c;
list.Add(cmd);
list.AddIfNotNull(MakeFindBaseClassesItem(c));
list.AddIfNotNull(MakeFindDerivedClassesItem(c));
return(list.ToArray());
}
void ConvertToAutomaticProperty(ITextEditor editor, IProperty property, IField fieldDef, Ast.PropertyDeclaration astProp)
{
CodeGenerator codeGen = property.DeclaringType.ProjectContent.Language.CodeGenerator;
int fieldStartOffset = editor.Document.PositionToOffset(fieldDef.Region.BeginLine, fieldDef.Region.BeginColumn);
int fieldEndOffset = editor.Document.PositionToOffset(fieldDef.Region.EndLine, fieldDef.Region.EndColumn);
int startOffset = editor.Document.PositionToOffset(property.Region.BeginLine, property.Region.BeginColumn);
int endOffset = editor.Document.PositionToOffset(property.BodyRegion.EndLine, property.BodyRegion.EndColumn);
ITextAnchor startAnchor = editor.Document.CreateAnchor(startOffset);
ITextAnchor endAnchor = editor.Document.CreateAnchor(endOffset);
if (astProp.HasGetRegion)
{
astProp.GetRegion.Block = null;
}
if (!astProp.HasSetRegion)
{
astProp.SetRegion = new Ast.PropertySetRegion(null, null);
astProp.SetRegion.Modifier = CodeGenerator.ConvertModifier(fieldDef.Modifiers, new ClassFinder(fieldDef))
& (Ast.Modifiers.Private | Ast.Modifiers.Internal | Ast.Modifiers.Protected | Ast.Modifiers.Public);
}
Ast.FieldDeclaration f = ParseMember <Ast.FieldDeclaration>(Path.GetExtension(editor.FileName),
GetMemberText(fieldDef, editor));
astProp.Initializer = f.Fields.First().Initializer;
if (astProp.HasSetRegion)
{
astProp.SetRegion.Block = null;
}
using (AsynchronousWaitDialog monitor = AsynchronousWaitDialog.ShowWaitDialog("${res:SharpDevelop.Refactoring.ConvertToAutomaticProperty}")) {
var refs = RefactoringService.FindReferences(fieldDef, monitor);
using (editor.Document.OpenUndoGroup()) {
FindReferencesAndRenameHelper.RenameReferences(refs, property.Name);
editor.Document.Remove(fieldStartOffset, fieldEndOffset - fieldStartOffset);
editor.Document.Replace(startAnchor.Offset, endAnchor.Offset - startAnchor.Offset, codeGen.GenerateCode(astProp, ""));
}
}
}
protected override void RunImpl(ITextEditor editor, int offset, ResolveResult symbol)
{
var classUnderCaret = GetClass(symbol);
if (classUnderCaret != null)
{
FindReferencesAndRenameHelper.RunFindReferences(classUnderCaret);
return;
}
var memberUnderCaret = GetMember(symbol);
if (memberUnderCaret != null)
{
FindReferencesAndRenameHelper.RunFindReferences(memberUnderCaret);
return;
}
if (symbol is LocalResolveResult)
{
FindReferencesAndRenameHelper.RunFindReferences((LocalResolveResult)symbol);
}
}
public override void Run()
{
var selectedItem = GetSelectedItems().FirstOrDefault();
if (selectedItem != null)
{
IClass c = GetClassFromName(selectedItem.FullyQualifiedClassName);
if (c != null)
{
IMember member = GetMemberFromName(c, selectedItem.MethodName, selectedItem.Parameters);
string memberName = member.DeclaringType.Name + "." + member.Name;
using (AsynchronousWaitDialog monitor = AsynchronousWaitDialog.ShowWaitDialog("${res:SharpDevelop.Refactoring.FindReferences}"))
{
FindReferencesAndRenameHelper.ShowAsSearchResults(StringParser.Parse("${res:SharpDevelop.Refactoring.ReferencesTo}",
new string[, ] {
{ "Name", memberName }
}),
RefactoringService.FindReferences(member, monitor));
}
}
}
}
void OnPropertyGridPropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName == "Name")
{
if (!propertyGridView.PropertyGrid.IsNameCorrect)
{
return;
}
// get the XAML file
OpenedFile fileName = this.Files.Where(f => f.FileName.ToString().EndsWith(".xaml")).FirstOrDefault();
if (fileName == null)
{
return;
}
// parse the XAML file
ParseInformation info = ParserService.ParseFile(fileName.FileName.ToString());
if (info == null || info.CompilationUnit == null)
{
return;
}
if (info.CompilationUnit.Classes.Count != 1)
{
return;
}
// rename the member
IMember member = info.CompilationUnit.Classes[0].AllMembers
.Where(m => m.Name == propertyGridView.PropertyGrid.OldName).FirstOrDefault();
if (member != null)
{
FindReferencesAndRenameHelper.RenameMember(member, propertyGridView.PropertyGrid.Name);
}
}
}
void AddImplementInterfaceCommandItems(List <ToolStripItem> subItems, IClass c, bool explicitImpl)
{
CodeGenerator codeGen = c.ProjectContent.Language.CodeGenerator;
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList;
foreach (IReturnType rt in c.BaseTypes)
{
IClass interf = rt.GetUnderlyingClass();
if (interf != null && interf.ClassType == ClassType.Interface)
{
IReturnType rtCopy = rt; // copy for access by anonymous method
EventHandler eh = delegate {
TextEditorDocument d = new TextEditorDocument(FindReferencesAndRenameHelper.GetDocument(c));
if (d != null)
{
codeGen.ImplementInterface(rtCopy, d, explicitImpl, c);
}
ParserService.ParseCurrentViewContent();
};
subItems.Add(new MenuCommand(ambience.Convert(interf), eh));
}
}
}
public System.Windows.Forms.ToolStripItem[] BuildSubmenu(Codon codon, object owner)
{
List <ToolStripItem> resultItems = new List <ToolStripItem>();
IClass c = ClassBookmarkSubmenuBuilder.GetClass(owner);
if (c == null)
{
return(new ToolStripMenuItem[0]);
}
LanguageProperties language = c.ProjectContent.Language;
if (!FindReferencesAndRenameHelper.IsReadOnly(c))
{
AddRenameCommand(c, resultItems);
if (language.RefactoringProvider.SupportsExtractInterface)
{
AddExtractInterfaceCommand(c, resultItems);
}
}
return(resultItems.ToArray());
}
void Rename(object sender, EventArgs e)
{
MenuCommand item = (MenuCommand)sender;
FindReferencesAndRenameHelper.RenameMember((IMember)item.Tag);
}
void ExtractInterface(object sender, EventArgs e)
{
MenuCommand item = (MenuCommand)sender;
FindReferencesAndRenameHelper.ExtractInterface((IClass)item.Tag);
}
void Rename(object sender, EventArgs e)
{
MenuCommand item = (MenuCommand)sender;
FindReferencesAndRenameHelper.RenameClass((IClass)item.Tag);
}
public ToolStripItem[] BuildSubmenu(Codon codon, object owner)
{
MenuCommand cmd;
IClass c;
ClassNode classNode = owner as ClassNode;
if (classNode != null)
{
c = classNode.Class;
}
else
{
ClassBookmark bookmark = (ClassBookmark)owner;
c = bookmark.Class;
}
ParserService.ParseCurrentViewContent();
c = c.ProjectContent.GetClass(c.FullyQualifiedName, c.TypeParameters.Count);
if (c == null)
{
return(new ToolStripMenuItem[0]);
}
LanguageProperties language = c.ProjectContent.Language;
List <ToolStripItem> list = new List <ToolStripItem>();
if (!FindReferencesAndRenameHelper.IsReadOnly(c))
{
if (c.DeclaringType == null &&
!c.BodyRegion.IsEmpty &&
!c.Name.Equals(Path.GetFileNameWithoutExtension(c.CompilationUnit.FileName),
StringComparison.InvariantCultureIgnoreCase))
{
// File name does not match class name
string correctFileName = Path.Combine(Path.GetDirectoryName(c.CompilationUnit.FileName),
c.Name + Path.GetExtension(c.CompilationUnit.FileName));
if (FileUtility.IsValidFileName(correctFileName) &&
Path.IsPathRooted(correctFileName) &&
!File.Exists(correctFileName))
{
if (c.CompilationUnit.Classes.Count == 1)
{
// Rename file to ##
cmd = new MenuCommand(StringParser.Parse("${res:SharpDevelop.Refactoring.RenameFileTo}", new string[, ] {
{ "FileName", Path.GetFileName(correctFileName) }
}),
delegate {
FileService.RenameFile(c.CompilationUnit.FileName, correctFileName, false);
if (c.ProjectContent.Project != null)
{
((IProject)c.ProjectContent.Project).Save();
}
});
list.Add(cmd);
}
else if (language.RefactoringProvider.SupportsCreateNewFileLikeExisting && language.RefactoringProvider.SupportsGetFullCodeRangeForType)
{
// Move class to file ##
cmd = new MenuCommand(StringParser.Parse("${res:SharpDevelop.Refactoring.MoveClassToFile}", new string[, ] {
{ "FileName", Path.GetFileName(correctFileName) }
}),
delegate {
MoveClassToFile(c, correctFileName);
});
list.Add(cmd);
}
}
}
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.RenameCommand}", Rename);
cmd.Tag = c;
list.Add(cmd);
}
if (c.BaseTypes.Count > 0)
{
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.GoToBaseCommand}", GoToBase);
cmd.Tag = c;
list.Add(cmd);
if (c.ClassType != ClassType.Interface && !FindReferencesAndRenameHelper.IsReadOnly(c))
{
AddImplementInterfaceCommands(c, list);
}
}
if (!c.IsSealed && !c.IsStatic)
{
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.FindDerivedClassesCommand}", FindDerivedClasses);
cmd.Tag = c;
list.Add(cmd);
}
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.FindReferencesCommand}", FindReferences);
cmd.Tag = c;
list.Add(cmd);
return(list.ToArray());
}
/// <summary>
/// Finds all references to resources (except the definition) using the specified
/// <see cref="IResourceReferenceFinder"/> object.
/// </summary>
/// <param name="finder">The <see cref="IResourceReferenceFinder"/> to use to find resource references.</param>
/// <param name="monitor">An object implementing <see cref="IProgressMonitor"/> to report the progress of the operation. Can be <c>null</c>.</param>
/// <param name="scope">The scope which should be searched.</param>
/// <returns>A list of references to resources.</returns>
public static List <Reference> FindReferences(IResourceReferenceFinder finder, IProgressMonitor monitor, SearchScope scope)
{
if (finder == null)
{
throw new ArgumentNullException("finder");
}
if (ParserService.LoadSolutionProjectsThreadRunning)
{
if (monitor != null)
{
monitor.ShowingDialog = true;
}
MessageService.ShowMessage("${res:SharpDevelop.Refactoring.LoadSolutionProjectsThreadRunning}");
if (monitor != null)
{
monitor.ShowingDialog = false;
}
return(null);
}
DateTime startTime = DateTime.UtcNow;
List <Reference> references = new List <Reference>();
try {
NRefactoryAstCacheService.EnableCache();
ICollection <string> files = GetPossibleFiles(scope);
if (monitor != null)
{
monitor.BeginTask("${res:SharpDevelop.Refactoring.FindingReferences}", files.Count, true);
}
foreach (string fileName in files)
{
if (monitor != null && monitor.IsCancelled)
{
return(null);
}
IDocument doc = null;
try {
// The following line throws an exception if the file does not exist.
// But the file may be in an unsaved view content (which would be found by GetDocumentInformation),
// so we cannot simply loop on !File.Exists(...).
doc = FindReferencesAndRenameHelper.GetDocumentInformation(fileName).CreateDocument();
} catch (FileNotFoundException) {
}
if (doc == null)
{
if (monitor != null)
{
++monitor.WorkDone;
}
continue;
}
string fileContent = doc.TextContent;
if (String.IsNullOrEmpty(fileContent))
{
if (monitor != null)
{
++monitor.WorkDone;
}
continue;
}
int pos = -1;
while ((pos = finder.GetNextPossibleOffset(fileName, fileContent, pos)) >= 0)
{
TextLocation docPos = doc.OffsetToPosition(pos);
ResourceResolveResult rrr = ResourceResolverService.Resolve(fileName, doc, docPos.Y, docPos.X, null);
if (rrr != null && rrr.ResourceFileContent != null)
{
if (finder.IsReferenceToResource(rrr))
{
if (rrr.Key != null)
{
// The actual location of the key string may be after 'pos' because
// the resolvers may find an expression just before it.
string keyString = rrr.Key;
int keyPos = fileContent.IndexOf(keyString, pos, StringComparison.OrdinalIgnoreCase);
if (keyPos < pos)
{
// The key may be escaped in some way in the document.
// Try using the code generator to find this out.
keyPos = FindStringLiteral(fileName, fileContent, rrr.Key, pos, out keyString);
}
if (keyPos < pos)
{
if (monitor != null)
{
monitor.ShowingDialog = true;
}
MessageService.ShowWarning("ResourceToolkit: The key '" + rrr.Key + "' could not be located at the resolved position in the file '" + fileName + "'.");
if (monitor != null)
{
monitor.ShowingDialog = false;
}
}
else
{
references.Add(new Reference(fileName, keyPos, keyString.Length, keyString, rrr));
}
}
else
{
references.Add(new Reference(fileName, pos, 0, null, rrr));
}
}
}
}
if (monitor != null)
{
++monitor.WorkDone;
}
}
LoggingService.Info("ResourceToolkit: FindReferences finished in " + (DateTime.UtcNow - startTime).TotalSeconds.ToString(System.Globalization.CultureInfo.CurrentCulture) + "s");
} finally {
NRefactoryAstCacheService.DisableCache();
if (monitor != null)
{
monitor.Done();
}
}
return(references);
}
/// <summary>
/// Renames all references to a resource including the definition.
/// </summary>
/// <param name="rrr">The resource to be renamed.</param>
/// <param name="newKey">The new name of the resource key.</param>
/// <param name="monitor">An object implementing <see cref="IProgressMonitor"/> to report the progress of the operation. Can be <c>null</c>.</param>
public static void Rename(ResourceResolveResult rrr, string newKey, IProgressMonitor monitor)
{
// Prevent duplicate key names
if (rrr.ResourceFileContent.ContainsKey(newKey))
{
if (monitor != null)
{
monitor.ShowingDialog = true;
}
MessageService.ShowWarning("${res:Hornung.ResourceToolkit.EditStringResourceDialog.DuplicateKey}");
if (monitor != null)
{
monitor.ShowingDialog = false;
}
return;
}
List <Reference> references = FindReferences(rrr.FileName, rrr.Key, monitor);
if (references == null)
{
return;
}
if (monitor != null)
{
monitor.BeginTask(null, 0, false);
}
try {
// rename definition (if present)
if (rrr.ResourceFileContent.ContainsKey(rrr.Key))
{
rrr.ResourceFileContent.RenameKey(rrr.Key, newKey);
}
else
{
if (monitor != null)
{
monitor.ShowingDialog = true;
}
MessageService.ShowWarning("${res:Hornung.ResourceToolkit.RenameKeyDefinitionNotFoundWarning}");
if (monitor != null)
{
monitor.ShowingDialog = false;
}
}
} catch (Exception ex) {
if (monitor != null)
{
monitor.ShowingDialog = true;
}
MessageService.ShowWarningFormatted("${res:Hornung.ResourceToolkit.ErrorProcessingResourceFile}" + Environment.NewLine + ex.Message, rrr.ResourceFileContent.FileName);
if (monitor != null)
{
monitor.ShowingDialog = false;
}
if (monitor != null)
{
monitor.Done();
}
// Do not rename the references when renaming the definition failed.
return;
}
// rename references
// FIXME: RenameReferences does not enforce escaping rules. May be a problem if someone uses double-quotes in the new resource key name.
FindReferencesAndRenameHelper.RenameReferences(references, newKey);
// rename definitions in localized resource files
foreach (KeyValuePair <string, IResourceFileContent> entry in ResourceFileContentRegistry.GetLocalizedContents(rrr.FileName))
{
try {
if (entry.Value.ContainsKey(rrr.Key))
{
entry.Value.RenameKey(rrr.Key, newKey);
}
} catch (Exception ex) {
if (monitor != null)
{
monitor.ShowingDialog = true;
}
MessageService.ShowWarningFormatted("${res:Hornung.ResourceToolkit.ErrorProcessingResourceFile}" + Environment.NewLine + ex.Message, entry.Value.FileName);
if (monitor != null)
{
monitor.ShowingDialog = false;
}
}
}
if (monitor != null)
{
monitor.Done();
}
}
public ToolStripItem[] BuildSubmenu(Codon codon, object owner)
{
MenuCommand cmd;
IMember member;
MemberNode memberNode = owner as MemberNode;
if (memberNode != null)
{
member = memberNode.Member;
}
else
{
ClassMemberBookmark bookmark = (ClassMemberBookmark)owner;
member = bookmark.Member;
}
IMethod method = member as IMethod;
List <ToolStripItem> list = new List <ToolStripItem>();
bool canGenerateCode =
member.DeclaringType.ProjectContent.Language.CodeGenerator != null &&
!FindReferencesAndRenameHelper.IsReadOnly(member.DeclaringType);
if (method == null || !method.IsConstructor)
{
if (!FindReferencesAndRenameHelper.IsReadOnly(member.DeclaringType) &&
!(member is IProperty && ((IProperty)member).IsIndexer))
{
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.RenameCommand}", Rename);
cmd.Tag = member;
list.Add(cmd);
}
}
if (member.IsOverride)
{
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.GoToBaseClassCommand}", GoToBase);
cmd.Tag = member;
list.Add(cmd);
}
if (member.IsVirtual || member.IsAbstract || (member.IsOverride && !member.DeclaringType.IsSealed))
{
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.FindOverridesCommand}", FindOverrides);
cmd.Tag = member;
list.Add(cmd);
}
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.FindReferencesCommand}", FindReferences);
cmd.Tag = member;
list.Add(cmd);
if (member is IField && member.DeclaringType.ClassType != ClassType.Enum)
{
IProperty foundProperty = FindReferencesAndRenameHelper.FindProperty(member as IField);
if (foundProperty != null)
{
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.GoToProperty}", GotoTagMember);
cmd.Tag = foundProperty;
list.Add(cmd);
}
else
{
if (canGenerateCode)
{
if (member.IsReadonly)
{
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.CreateProperty}", CreateGetter);
cmd.Tag = member;
list.Add(cmd);
}
else
{
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.CreateGetter}", CreateGetter);
cmd.Tag = member;
list.Add(cmd);
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.CreateProperty}", CreateProperty);
cmd.Tag = member;
list.Add(cmd);
}
}
}
}
if (member is IProperty)
{
if (((IProperty)member).CanSet && canGenerateCode)
{
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.CreateChangedEvent}", CreateChangedEvent);
cmd.Tag = member;
list.Add(cmd);
}
}
if (member is IEvent)
{
if (canGenerateCode)
{
cmd = new MenuCommand("${res:SharpDevelop.Refactoring.CreateOnEventMethod}", CreateOnEventMethod);
cmd.Tag = member;
list.Add(cmd);
}
}
return(list.ToArray());
}
public override void Execute(EditorContext context)
{
FindReferencesAndRenameHelper.MoveClassToFile(ClassAtCaret.Class, ClassAtCaret.CorrectClassFileName);
}
void GotoTagMember(object sender, EventArgs e)
{
FindReferencesAndRenameHelper.JumpToDefinition((IMember)(sender as MenuCommand).Tag);
}
