public void GetMemberFromClassMemberBookmark()
{
MockMethod mockMethod = MockMethod.CreateMockMethodWithoutAnyAttributes();
mockMethod.Region = new DomRegion(1, 1);
ClassMemberBookmark bookmark = new ClassMemberBookmark(mockMethod);
Assert.IsTrue(Object.ReferenceEquals(mockMethod, TestableCondition.GetMember(bookmark)));
}
public static IMember GetMember(object caller)
{
ITestTreeView testTreeView = caller as ITestTreeView;
if (testTreeView != null)
{
return(testTreeView.SelectedMethod);
}
MemberNode memberNode = caller as MemberNode;
if (memberNode != null)
{
return(memberNode.Member);
}
else
{
ClassMemberBookmark mbookmark = caller as ClassMemberBookmark;
if (mbookmark != null)
{
return(mbookmark.Member);
}
}
return(null);
}
public ToolStripItem[] BuildSubmenu(Codon codon, object owner)
{
ToolStripMenuItem item;
TextEditorControl textEditorControl = (TextEditorControl)owner;
if (textEditorControl.FileName == null)
{
return(new ToolStripItem[0]);
}
List <ToolStripItem> resultItems = new List <ToolStripItem>();
TextArea textArea = textEditorControl.ActiveTextAreaControl.TextArea;
IDocument doc = textArea.Document;
int caretLine = textArea.Caret.Line;
// list of dotnet names that have definition bookmarks in this line
List <string> definitions = new List <string>();
// Include definitions (use the bookmarks which should already be present)
foreach (Bookmark mark in doc.BookmarkManager.Marks)
{
if (mark != null && mark.LineNumber == caretLine)
{
ClassMemberBookmark cmb = mark as ClassMemberBookmark;
ClassBookmark cb = mark as ClassBookmark;
IClass type = null;
if (cmb != null)
{
definitions.Add(cmb.Member.DotNetName);
item = new ToolStripMenuItem(MemberNode.GetText(cmb.Member),
ClassBrowserIconService.ImageList.Images[cmb.IconIndex]);
MenuService.AddItemsToMenu(item.DropDown.Items, mark, ClassMemberBookmark.ContextMenuPath);
resultItems.Add(item);
type = cmb.Member.DeclaringType;
}
else if (cb != null)
{
type = cb.Class;
}
if (type != null)
{
definitions.Add(type.DotNetName);
item = new ToolStripMenuItem(type.Name, ClassBrowserIconService.ImageList.Images[ClassBrowserIconService.GetIcon(type)]);
MenuService.AddItemsToMenu(item.DropDown.Items,
cb ?? new ClassBookmark(textArea.Document, type),
ClassBookmark.ContextMenuPath);
resultItems.Add(item);
}
}
}
// Include menu for member that has been clicked on
IExpressionFinder expressionFinder = ParserService.GetExpressionFinder(textEditorControl.FileName);
ExpressionResult expressionResult;
ResolveResult rr;
int insertIndex = resultItems.Count; // Insert items at this position to get the outermost expression first, followed by the inner expressions (if any).
expressionResult = FindFullExpressionAtCaret(textArea, expressionFinder);
repeatResolve:
rr = ResolveExpressionAtCaret(textArea, expressionResult);
item = null;
if (rr is MethodResolveResult)
{
item = MakeItem(definitions, ((MethodResolveResult)rr).GetMethodIfSingleOverload());
}
else if (rr is MemberResolveResult)
{
MemberResolveResult mrr = (MemberResolveResult)rr;
item = MakeItem(definitions, mrr.ResolvedMember);
if (RefactoringService.FixIndexerExpression(expressionFinder, ref expressionResult, mrr))
{
if (item != null)
{
resultItems.Insert(insertIndex, item);
}
// Include menu for the underlying expression of the
// indexer expression as well.
goto repeatResolve;
}
}
else if (rr is TypeResolveResult)
{
item = MakeItem(definitions, ((TypeResolveResult)rr).ResolvedClass);
}
else if (rr is LocalResolveResult)
{
item = MakeItem((LocalResolveResult)rr, caretLine + 1 == ((LocalResolveResult)rr).Field.Region.BeginLine);
insertIndex = 0; // Insert local variable menu item at the topmost position.
}
if (item != null)
{
resultItems.Insert(insertIndex, item);
}
// Include menu for current class and method
IMember callingMember = null;
if (rr != null)
{
callingMember = rr.CallingMember;
}
else
{
ParseInformation parseInfo = ParserService.GetParseInformation(textEditorControl.FileName);
if (parseInfo != null)
{
ICompilationUnit cu = parseInfo.MostRecentCompilationUnit;
if (cu != null)
{
IClass callingClass = cu.GetInnermostClass(caretLine + 1, textArea.Caret.Column + 1);
callingMember = GetCallingMember(callingClass, caretLine + 1, textArea.Caret.Column + 1);
}
}
}
if (callingMember != null)
{
item = MakeItem(definitions, callingMember);
if (item != null)
{
item.Text = StringParser.Parse("${res:SharpDevelop.Refactoring.CurrentMethod}: ") + callingMember.Name;
resultItems.Add(item);
}
}
if (resultItems.Count == 0)
{
return(new ToolStripItem[0]);
}
else
{
resultItems.Add(new MenuSeparator());
return(resultItems.ToArray());
}
}
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 Run()
{
IClass c;
IMember m;
MemberNode mn = this.Owner as MemberNode;
if (mn != null)
{
m = mn.Member;
c = m.DeclaringType;
}
else
{
ClassNode cn = this.Owner as ClassNode;
if (cn != null)
{
c = cn.Class;
m = null;
}
else
{
ClassMemberBookmark cmbm = this.Owner as ClassMemberBookmark;
if (cmbm != null)
{
m = cmbm.Member;
c = m.DeclaringType;
}
else
{
ClassBookmark cbm = this.Owner as ClassBookmark;
if (cbm != null)
{
c = cbm.Class;
m = null;
}
else
{
MessageService.ShowWarning("Reflector AddIn: Could not determine the class for the selected element. Owner: " + ((this.Owner == null) ? "<null>" : this.Owner.ToString()));
return;
}
}
}
}
if (c == null)
{
MessageService.ShowWarning("Reflector AddIn: Could not determine the class for the selected element (known owner). Owner: " + this.Owner.ToString());
return;
}
// Try to find the assembly which contains the resolved type
IProjectContent pc = c.ProjectContent;
ReflectionProjectContent rpc = pc as ReflectionProjectContent;
string assemblyLocation = null;
if (rpc != null)
{
assemblyLocation = rpc.AssemblyLocation;
}
else
{
IProject project = pc.Project as IProject;
if (project != null)
{
assemblyLocation = project.OutputAssemblyFullPath;
}
}
if (String.IsNullOrEmpty(assemblyLocation))
{
MessageService.ShowWarning("Reflector AddIn: Could not determine the assembly location for " + c.ToString() + ".");
return;
}
AbstractEntity entity = m as AbstractEntity;
if (entity == null)
{
entity = c as AbstractEntity;
}
if (entity != null)
{
LoggingService.Debug("ReflectorAddIn: Trying to go to " + entity.DocumentationTag + " in " + assemblyLocation);
ReflectorController.TryGoTo(assemblyLocation, entity);
}
}
public override void Run()
{
IClass c;
IMember m;
MemberNode mn = this.Owner as MemberNode;
if (mn != null)
{
m = mn.Member;
c = m.DeclaringType;
}
else
{
ClassNode cn = this.Owner as ClassNode;
if (cn != null)
{
c = cn.Class;
m = null;
}
else
{
ClassMemberBookmark cmbm = this.Owner as ClassMemberBookmark;
if (cmbm != null)
{
m = cmbm.Member;
c = m.DeclaringType;
}
else
{
ClassBookmark cbm = this.Owner as ClassBookmark;
if (cbm != null)
{
c = cbm.Class;
m = null;
}
else
{
MessageService.ShowWarning("ILSpy AddIn: Could not determine the class for the selected element. Owner: " + ((this.Owner == null) ? "<null>" : this.Owner.ToString()));
return;
}
}
}
}
if (c == null)
{
MessageService.ShowWarning("ILSpy AddIn: Could not determine the class for the selected element (known owner). Owner: " + this.Owner.ToString());
return;
}
AbstractEntity entity = m as AbstractEntity;
if (entity == null)
{
entity = c as AbstractEntity;
}
if (entity != null)
{
ILSpyController.TryGoTo(entity);
}
}
