protected override async Task UpdateAsync(CommandArrayInfo info, CancellationToken cancelToken)
{
var editor = IdeApp.Workbench.ActiveDocument?.Editor;
var ext = editor?.GetContent <CodeActionEditorExtension> ();
if (ext == null)
{
return;
}
var quickFixMenu = new CommandInfoSet();
quickFixMenu.Text = GettextCatalog.GetString("Quick Fix");
quickFixMenu.CommandInfos.Add(new CommandInfo(GettextCatalog.GetString("Loading..."), false, false), null);
info.Add(quickFixMenu);
try {
var menu = await CodeFixMenuService.CreateFixMenu(editor, ext.GetCurrentFixes(), cancelToken);
quickFixMenu.CommandInfos.Clear();
foreach (var item in menu.Items)
{
AddItem(quickFixMenu, item);
}
if (menu.Items.Count == 0)
{
quickFixMenu.CommandInfos.Add(new CommandInfo(GettextCatalog.GetString("No code fixes available"), false, false), null);
}
} catch (OperationCanceledException) {
} catch (Exception e) {
LoggingService.LogError("Error while creating quick fix menu.", e);
quickFixMenu.CommandInfos.Clear();
quickFixMenu.CommandInfos.Add(new CommandInfo(GettextCatalog.GetString("No code fixes available"), false, false), null);
}
}
void AddItem(CommandArrayInfo cis, CodeFixMenuEntry item)
{
if (item == CodeFixMenuEntry.Separator)
{
if (cis.Count == 0)
{
return;
}
cis.AddSeparator();
}
else if (item is CodeFixMenu)
{
var menu = (CodeFixMenu)item;
var submenu = new CommandInfoSet {
Text = menu.Label
};
foreach (var subItem in menu.Items)
{
AddItem(submenu.CommandInfos, subItem);
}
cis.Add(submenu, item.Action);
}
else
{
var info = new CommandInfo(item.Label);
info.Enabled = item.Action != null;
cis.Add(info, item.Action);
}
}
/// <summary>
/// The Update method is used to determine if the command can run within the current context.
///
/// Note that we have overriden the Update which provides a CommandArrayInfo object; in the
/// manifest we provided 'array' to the type attribute. This specifies to the command engine that
/// this command provides multiple choices that the user can execute.
///
/// We provide a CommandInfoSet object into the provided CommandArrayInfo to specify all the choices
/// are user can make when running our command; we provide multiple 'CommandInfos' to specify what the user
/// can execute.
/// </summary>
/// <param name="info">Info.</param>
protected override void Update(CommandArrayInfo info)
{
if (PropertyService.HasValue(PropertyKeys.TranslationApiPropertyKey) == false)
{
return; // Can't run
}
var doc = IdeApp.Workbench.ActiveDocument;
var editor = doc.Editor;
if (doc != null &&
editor != null)
{
var loc = editor.CaretLocation;
Microsoft.CodeAnalysis.SyntaxToken token;
if (SyntaxTokenHelper.ResolveSyntaxToken(doc, loc, out token))
{
var commandSet = new CommandInfoSet();
commandSet.CommandInfos.Add(new CommandInfo("English"), new TranslationSetting("en", token));
commandSet.CommandInfos.Add(new CommandInfo("German"), new TranslationSetting("de", token));
commandSet.CommandInfos.Add(new CommandInfo("Spanish"), new TranslationSetting("es", token));
commandSet.CommandInfos.Add(new CommandInfo("French"), new TranslationSetting("fr", token));
info.Add(commandSet);
}
}
}
protected override void Update(CommandArrayInfo ainfo)
{
var doc = IdeApp.Workbench.ActiveDocument;
if (doc == null || doc.FileName == FilePath.Null || doc.ParsedDocument == null)
{
return;
}
ResolveResult resolveResult;
AstNode node;
if (!ResolveAt(doc, out resolveResult, out node))
{
return;
}
var resolveMenu = new CommandInfoSet();
resolveMenu.Text = GettextCatalog.GetString("Resolve");
var possibleNamespaces = GetPossibleNamespaces(doc, node, resolveResult);
bool addUsing = !(resolveResult is AmbiguousTypeResolveResult);
if (addUsing)
{
foreach (string ns in possibleNamespaces)
{
var info = resolveMenu.CommandInfos.Add(
string.Format("using {0};", ns),
new System.Action(new AddImport(doc, resolveResult, ns, true).Run)
);
info.Icon = MonoDevelop.Ide.Gui.Stock.AddNamespace;
}
}
bool resolveDirect = !(resolveResult is UnknownMemberResolveResult);
if (resolveDirect)
{
if (resolveMenu.CommandInfos.Count > 0)
{
resolveMenu.CommandInfos.AddSeparator();
}
if (node is ObjectCreateExpression)
{
node = ((ObjectCreateExpression)node).Type;
}
foreach (string ns in possibleNamespaces)
{
resolveMenu.CommandInfos.Add(string.Format("{0}", ns + "." + doc.Editor.GetTextBetween(node.StartLocation, node.EndLocation)), new System.Action(new AddImport(doc, resolveResult, ns, false).Run));
}
}
if (resolveMenu.CommandInfos.Count > 0)
{
ainfo.Insert(0, resolveMenu);
}
}
protected override void Update(CommandArrayInfo info)
{
for (int i = 0; i < IdeApp.Workbench.Pads.Count; i++)
{
Pad pad = IdeApp.Workbench.Pads[i];
CommandInfo ci = new CommandInfo(pad.Title);
ci.Icon = pad.Icon;
ci.UseMarkup = true;
ci.Description = GettextCatalog.GetString("Show {0}", pad.Title);
ci.Checked = pad.Visible;
ActionCommand cmd = IdeApp.CommandService.GetActionCommand("Pad|" + pad.Id);
if (cmd != null)
{
ci.AccelKey = cmd.AccelKey;
}
CommandArrayInfo list = info;
if (pad.Categories != null)
{
for (int j = 0; j < pad.Categories.Length; j++)
{
bool found = false;
for (int k = list.Count - 1; k >= 0; k--)
{
if (list[k].Text == pad.Categories[j] && list[k] is CommandInfoSet)
{
list = ((CommandInfoSet)list[k]).CommandInfos;
found = true;
break;
}
}
if (!found)
{
CommandInfoSet set = new CommandInfoSet();
set.Text = pad.Categories[j];
set.Description = GettextCatalog.GetString("Show {0}", set.Text);
list.Add(set);
list = set.CommandInfos;
}
}
}
for (int j = list.Count - 1; j >= 0; j--)
{
if (!(list[j] is CommandInfoSet))
{
list.Insert(j + 1, ci, pad);
pad = null;
break;
}
}
if (pad != null)
{
list.Insert(0, ci, pad);
}
}
}
CommandInfoSet CreateCommandInfoSet(CodeFixMenu menu)
{
var cis = new CommandInfoSet();
cis.Text = menu.Label;
foreach (var item in menu.Items)
{
AddItem(cis.CommandInfos, item);
}
return(cis);
}
void AddItem(CommandInfoSet cis, CodeFixMenuEntry item)
{
if (item == CodeFixMenuEntry.Separator)
{
if (cis.CommandInfos.Count == 0)
{
return;
}
cis.CommandInfos.AddSeparator();
}
else
{
cis.CommandInfos.Add(new CommandInfo(item.Label), item.Action);
}
}
protected override void Update(CommandArrayInfo ainfo)
{
var doc = IdeApp.Workbench.ActiveDocument;
if (doc == null || doc.FileName == FilePath.Null || doc.ParsedDocument == null)
{
return;
}
ResolveResult resolveResult;
AstNode node;
if (!ResolveAt(doc, out resolveResult, out node))
{
var location = RefactoringService.GetCorrectResolveLocation(doc, doc.Editor.Caret.Location);
resolveResult = GetHeuristicResult(doc, location, ref node);
if (resolveResult == null)
{
return;
}
}
var resolveMenu = new CommandInfoSet();
resolveMenu.Text = GettextCatalog.GetString("Resolve");
var possibleNamespaces = GetPossibleNamespaces(doc, node, ref resolveResult);
bool addUsing = !(resolveResult is AmbiguousTypeResolveResult);
if (addUsing)
{
foreach (var t in possibleNamespaces.Where(tp => tp.IsAccessibleWithGlobalUsing))
{
string ns = t.Namespace;
var reference = t.Reference;
var info = resolveMenu.CommandInfos.Add(
t.GetImportText(),
new System.Action(new AddImport(doc, resolveResult, ns, reference, true, node).Run)
);
info.Icon = MonoDevelop.Ide.Gui.Stock.AddNamespace;
}
}
bool resolveDirect = !(resolveResult is UnknownMemberResolveResult);
if (resolveDirect)
{
if (resolveMenu.CommandInfos.Count > 0)
{
resolveMenu.CommandInfos.AddSeparator();
}
if (node is ObjectCreateExpression)
{
node = ((ObjectCreateExpression)node).Type;
}
foreach (var t in possibleNamespaces)
{
string ns = t.Namespace;
var reference = t.Reference;
resolveMenu.CommandInfos.Add(t.GetInsertNamespaceText(doc.Editor.GetTextBetween(node.StartLocation, node.EndLocation)), new System.Action(new AddImport(doc, resolveResult, ns, reference, false, node).Run));
}
}
if (resolveMenu.CommandInfos.Count > 0)
{
ainfo.Insert(0, resolveMenu);
}
}
protected override async Task UpdateAsync(CommandArrayInfo ainfo, CancellationToken cancelToken)
{
if (!TryGetDocument(out var analysisDocument, out var doc))
{
return;
}
var semanticModel = await analysisDocument.GetSemanticModelAsync(cancelToken);
if (semanticModel == null)
{
return;
}
var info = await RefactoringSymbolInfo.GetSymbolInfoAsync(doc.DocumentContext, doc.Editor, cancelToken);
var ext = doc.GetContent <CodeActionEditorExtension> ();
bool canRename = RenameHandler.CanRename(info.Symbol ?? info.DeclaredSymbol);
if (canRename)
{
ainfo.Add(IdeApp.CommandService.GetCommandInfo(MonoDevelop.Ide.Commands.EditCommands.Rename), new Action(async delegate {
await new MonoDevelop.Refactoring.Rename.RenameRefactoring().Rename(info.Symbol ?? info.DeclaredSymbol);
}));
}
bool isSortAndRemoveUsingsSupported = RemoveAndSortUsingsHandler.IsSortAndRemoveImportsSupported(analysisDocument, doc.GetContent <Microsoft.VisualStudio.Text.ITextBuffer>());
if (isSortAndRemoveUsingsSupported)
{
var sortAndRemoveImportsInfo = IdeApp.CommandService.GetCommandInfo(Commands.SortAndRemoveImports);
sortAndRemoveImportsInfo.Enabled = true;
ainfo.Add(sortAndRemoveImportsInfo, new Action(async delegate {
await RemoveAndSortUsingsHandler.SortAndRemoveUnusedImports(analysisDocument, cancelToken);
}));
}
var gotoDeclarationSymbol = info.Symbol;
if (gotoDeclarationSymbol == null && info.DeclaredSymbol != null && info.DeclaredSymbol.Locations.Length > 1)
{
gotoDeclarationSymbol = info.DeclaredSymbol;
}
if (IdeApp.ProjectOperations.CanJumpToDeclaration(gotoDeclarationSymbol) || gotoDeclarationSymbol == null && IdeApp.ProjectOperations.CanJumpToDeclaration(info.CandidateSymbols.FirstOrDefault()))
{
var type = (gotoDeclarationSymbol ?? info.CandidateSymbols.FirstOrDefault()) as INamedTypeSymbol;
if (type != null && type.Locations.Length > 1)
{
var declSet = new CommandInfoSet();
declSet.Text = GettextCatalog.GetString("_Go to Declaration");
foreach (var part in type.Locations)
{
var loc = part.GetLineSpan();
declSet.CommandInfos.Add(string.Format(GettextCatalog.GetString("{0}, Line {1}"), FormatFileName(part.SourceTree.FilePath), loc.StartLinePosition.Line + 1), new Action(() => IdeApp.ProjectOperations.JumpTo(type, part, doc.Owner)));
}
ainfo.Add(declSet);
}
else
{
ainfo.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.GotoDeclaration), new Action(() => GotoDeclarationHandler.Run(doc)));
}
}
if (info.DeclaredSymbol != null && GotoBaseDeclarationHandler.CanGotoBase(info.DeclaredSymbol))
{
ainfo.Add(GotoBaseDeclarationHandler.GetDescription(info.DeclaredSymbol), new Action(() => GotoBaseDeclarationHandler.GotoBase(doc, info.DeclaredSymbol).Ignore()));
}
var sym = info.Symbol ?? info.DeclaredSymbol;
if (doc.DocumentContext.HasProject && sym != null)
{
ainfo.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.FindReferences), new System.Action(() => {
if (sym.Kind == SymbolKind.Local || sym.Kind == SymbolKind.Parameter || sym.Kind == SymbolKind.TypeParameter)
{
FindReferencesHandler.FindRefs(new [] { SymbolAndProjectId.Create(sym, analysisDocument.Project.Id) }, analysisDocument.Project.Solution).Ignore();
}
else
{
RefactoringService.FindReferencesAsync(FindReferencesHandler.FilterSymbolForFindReferences(sym).GetDocumentationCommentId()).Ignore();
}
}));
try {
if (Microsoft.CodeAnalysis.FindSymbols.SymbolFinder.FindSimilarSymbols(sym, semanticModel.Compilation).Count() > 1)
{
ainfo.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.FindAllReferences), new System.Action(() => RefactoringService.FindAllReferencesAsync(FindReferencesHandler.FilterSymbolForFindReferences(sym).GetDocumentationCommentId())));
}
} catch (Exception) {
// silently ignore roslyn bug.
}
}
}
protected override void Update(CommandArrayInfo ainfo)
{
var doc = IdeApp.Workbench.ActiveDocument;
if (doc == null || doc.FileName == FilePath.Null)
{
return;
}
var parsedDocument = doc.ParsedDocument;
if (parsedDocument == null || parsedDocument.IsInvalid)
{
return;
}
ResolveResult resolveResult;
object item = GetItem(doc, out resolveResult);
bool added = false;
var options = new RefactoringOptions(doc)
{
ResolveResult = resolveResult,
SelectedItem = item
};
var ciset = new CommandInfoSet();
ciset.Text = GettextCatalog.GetString("Refactor");
bool canRename;
if (item is IVariable || item is IParameter)
{
canRename = true;
}
else if (item is ITypeDefinition)
{
canRename = !((ITypeDefinition)item).Region.IsEmpty;
}
else if (item is IType)
{
canRename = ((IType)item).Kind == TypeKind.TypeParameter;
}
else if (item is IMember)
{
canRename = !((IMember)item).Region.IsEmpty;
}
else if (item is INamespace)
{
canRename = true;
}
else
{
canRename = false;
}
if (canRename)
{
ciset.CommandInfos.Add(IdeApp.CommandService.GetCommandInfo(MonoDevelop.Ide.Commands.EditCommands.Rename), new Action(delegate {
new MonoDevelop.Refactoring.Rename.RenameHandler().Start(null);
}));
added = true;
}
foreach (var refactoring in RefactoringService.Refactorings)
{
if (refactoring.IsValid(options))
{
CommandInfo info = new CommandInfo(refactoring.GetMenuDescription(options));
info.AccelKey = refactoring.AccelKey;
ciset.CommandInfos.Add(info, new Action(new RefactoringOperationWrapper(refactoring, options).Operation));
}
}
var refactoringInfo = doc.Annotation <RefactoringDocumentInfo> ();
if (refactoringInfo == null)
{
refactoringInfo = new RefactoringDocumentInfo();
doc.AddAnnotation(refactoringInfo);
}
var loc = doc.Editor.Caret.Location;
bool first = true;
if (refactoringInfo.lastDocument != doc.ParsedDocument || loc != lastLocation)
{
if (QuickTaskStrip.EnableFancyFeatures)
{
var ext = doc.GetContent <CodeActionEditorExtension> ();
refactoringInfo.validActions = ext != null?ext.GetCurrentFixes() : null;
}
else
{
refactoringInfo.validActions = RefactoringService.GetValidActions(doc, loc).Result;
}
lastLocation = loc;
refactoringInfo.lastDocument = doc.ParsedDocument;
}
if (refactoringInfo.validActions != null && refactoringInfo.lastDocument != null && refactoringInfo.lastDocument.CreateRefactoringContext != null)
{
var context = refactoringInfo.lastDocument.CreateRefactoringContext(doc, CancellationToken.None);
foreach (var fix_ in refactoringInfo.validActions.OrderByDescending(i => Tuple.Create(CodeActionEditorExtension.IsAnalysisOrErrorFix(i), (int)i.Severity, CodeActionEditorExtension.GetUsage(i.IdString))))
{
if (CodeActionEditorExtension.IsAnalysisOrErrorFix(fix_))
{
continue;
}
var fix = fix_;
if (first)
{
first = false;
if (ciset.CommandInfos.Count > 0)
{
ciset.CommandInfos.AddSeparator();
}
}
ciset.CommandInfos.Add(fix.Title, new Action(() => RefactoringService.ApplyFix(fix, context)));
}
}
if (ciset.CommandInfos.Count > 0)
{
ainfo.Add(ciset, null);
added = true;
}
if (IdeApp.ProjectOperations.CanJumpToDeclaration(item))
{
var type = item as IType;
if (type != null && type.GetDefinition().Parts.Count > 1)
{
var declSet = new CommandInfoSet();
declSet.Text = GettextCatalog.GetString("_Go to Declaration");
var ct = type.GetDefinition();
foreach (var part in ct.Parts)
{
declSet.CommandInfos.Add(string.Format(GettextCatalog.GetString("{0}, Line {1}"), FormatFileName(part.Region.FileName), part.Region.BeginLine), new System.Action(new JumpTo(part).Run));
}
ainfo.Add(declSet);
}
else
{
ainfo.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.GotoDeclaration), new System.Action(new JumpTo(item).Run));
}
added = true;
}
if (item is IMember)
{
var member = (IMember)item;
if (member.IsOverride || member.ImplementedInterfaceMembers.Any())
{
ainfo.Add(GettextCatalog.GetString("Go to _Base Symbol"), new System.Action(new GotoBase(member).Run));
added = true;
}
}
if (!(item is IMethod && ((IMethod)item).SymbolKind == SymbolKind.Operator) && (item is IEntity || item is ITypeParameter || item is IVariable || item is INamespace))
{
ainfo.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.FindReferences), new System.Action(new FindRefs(item, false).Run));
if (doc.HasProject && HasOverloads(doc.Project.ParentSolution, item))
{
ainfo.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.FindAllReferences), new System.Action(new FindRefs(item, true).Run));
}
added = true;
}
if (item is IMember)
{
var member = (IMember)item;
if (member.IsVirtual || member.IsAbstract || member.DeclaringType.Kind == TypeKind.Interface)
{
var handler = new FindDerivedSymbolsHandler(doc, member);
if (handler.IsValid)
{
ainfo.Add(GettextCatalog.GetString("Find Derived Symbols"), new System.Action(handler.Run));
added = true;
}
}
}
if (item is IMember)
{
var member = (IMember)item;
if (member.SymbolKind == SymbolKind.Method || member.SymbolKind == SymbolKind.Indexer)
{
var findMemberOverloadsHandler = new FindMemberOverloadsHandler(doc, member);
if (findMemberOverloadsHandler.IsValid)
{
ainfo.Add(GettextCatalog.GetString("Find Member Overloads"), new System.Action(findMemberOverloadsHandler.Run));
added = true;
}
}
}
if (item is ITypeDefinition)
{
ITypeDefinition cls = (ITypeDefinition)item;
foreach (var bc in cls.DirectBaseTypes)
{
if (bc != null && bc.GetDefinition() != null && bc.GetDefinition().Kind != TypeKind.Interface /* TODO: && IdeApp.ProjectOperations.CanJumpToDeclaration (bc)*/)
{
ainfo.Add(GettextCatalog.GetString("Go to _Base"), new System.Action(new GotoBase((ITypeDefinition)item).Run));
break;
}
}
if ((cls.Kind == TypeKind.Class && !cls.IsSealed) || cls.Kind == TypeKind.Interface)
{
ainfo.Add(cls.Kind != TypeKind.Interface ? GettextCatalog.GetString("Find _derived classes") : GettextCatalog.GetString("Find _implementor classes"), new System.Action(new FindDerivedClasses(cls).Run));
}
ainfo.Add(GettextCatalog.GetString("Find Extension Methods"), new System.Action(new FindExtensionMethodHandler(doc, cls).Run));
added = true;
}
if (added)
{
ainfo.AddSeparator();
}
}
static void BuildDynamicSubMenu(IntPtr rootMenu, IntPtr parentMenu, ushort index, uint macCmdID, CommandInfoSet cinfoSet)
{
IntPtr menuRef = HIToolbox.CreateMenu(idSeq++, GetCleanCommandText(cinfoSet), MenuAttributes.CondenseSeparators);
objectsToDestroyOnMenuClose.Add(new DestructableMenu(menuRef));
HIToolbox.CheckResult(HIToolbox.SetMenuItemHierarchicalMenu(parentMenu, index, menuRef));
ushort count = (ushort)cinfoSet.CommandInfos.Count;
for (ushort i = 1, j = 0; i <= count; i++)
{
CommandInfo ci = cinfoSet.CommandInfos[j++];
if (ci.IsArraySeparator)
{
HIToolbox.AppendMenuSeparator(menuRef);
}
else
{
HIToolbox.AppendMenuItem(menuRef, ci.Text, 0, macCmdID);
UpdateMenuItem(rootMenu, menuRef, ref i, ref count, macCmdID, ci);
objectsToDestroyOnMenuClose.Add(ci.DataItem);
uint refcon = (uint)objectsToDestroyOnMenuClose.Count;
HIToolbox.SetMenuItemReferenceConstant(new HIMenuItem(menuRef, i), refcon);
}
}
}
protected override void Update(CommandArrayInfo ainfo)
{
var doc = IdeApp.Workbench.ActiveDocument;
if (doc == null || doc.FileName == FilePath.Null || doc.ParsedDocument == null)
{
return;
}
var semanticModel = doc.ParsedDocument.GetAst <SemanticModel> ();
if (semanticModel == null)
{
return;
}
var task = RefactoringSymbolInfo.GetSymbolInfoAsync(doc, doc.Editor);
if (!task.Wait(2000))
{
return;
}
var info = task.Result;
bool added = false;
var ext = doc.GetContent <CodeActionEditorExtension> ();
//if (ext != null) {
// var fixMenu = CreateFixMenu (doc.Editor, doc, semanticModel, ext.GetCurrentFixes ());
// if (fixMenu.CommandInfos.Count > 0) {
// ainfo.Add (fixMenu, null);
// added = true;
// }
//}
var ciset = new CommandInfoSet();
ciset.Text = GettextCatalog.GetString("Refactor");
bool canRename = RenameHandler.CanRename(info.Symbol ?? info.DeclaredSymbol);
if (canRename)
{
ciset.CommandInfos.Add(IdeApp.CommandService.GetCommandInfo(MonoDevelop.Ide.Commands.EditCommands.Rename), new Action(async delegate {
await new MonoDevelop.Refactoring.Rename.RenameRefactoring().Rename(info.Symbol ?? info.DeclaredSymbol);
}));
added = true;
}
bool first = true;
//if (ext != null) {
// foreach (var fix in ext.GetCurrentFixes ().CodeRefactoringActions) {
// if (added & first && ciset.CommandInfos.Count > 0)
// ciset.CommandInfos.AddSeparator ();
// var info2 = new CommandInfo (fix.CodeAction.Title);
// ciset.CommandInfos.Add (info2, new Action (async () => await new CodeActionEditorExtension.ContextActionRunner (fix.CodeAction, doc.Editor, doc).Run ()));
// added = true;
// first = false;
// }
//}
if (ciset.CommandInfos.Count > 0)
{
ainfo.Add(ciset, null);
added = true;
}
var gotoDeclarationSymbol = info.Symbol;
if (gotoDeclarationSymbol == null && info.DeclaredSymbol != null && info.DeclaredSymbol.Locations.Length > 1)
{
gotoDeclarationSymbol = info.DeclaredSymbol;
}
if (IdeApp.ProjectOperations.CanJumpToDeclaration(gotoDeclarationSymbol) || gotoDeclarationSymbol == null && IdeApp.ProjectOperations.CanJumpToDeclaration(info.CandidateSymbols.FirstOrDefault()))
{
var type = (gotoDeclarationSymbol ?? info.CandidateSymbols.FirstOrDefault()) as INamedTypeSymbol;
if (type != null && type.Locations.Length > 1)
{
var declSet = new CommandInfoSet();
declSet.Text = GettextCatalog.GetString("_Go to Declaration");
foreach (var part in type.Locations)
{
var loc = part.GetLineSpan();
declSet.CommandInfos.Add(string.Format(GettextCatalog.GetString("{0}, Line {1}"), FormatFileName(part.SourceTree.FilePath), loc.StartLinePosition.Line + 1), new Action(() => IdeApp.ProjectOperations.JumpTo(type, part, doc.Project)));
}
ainfo.Add(declSet);
}
else
{
ainfo.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.GotoDeclaration), new Action(() => GotoDeclarationHandler.Run(doc)));
}
added = true;
}
if (info.DeclaredSymbol != null && GotoBaseDeclarationHandler.CanGotoBase(info.DeclaredSymbol))
{
ainfo.Add(GotoBaseDeclarationHandler.GetDescription(info.DeclaredSymbol), new Action(() => GotoBaseDeclarationHandler.GotoBase(doc, info.DeclaredSymbol)));
added = true;
}
var sym = info.Symbol ?? info.DeclaredSymbol;
if (doc.HasProject && sym != null)
{
ainfo.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.FindReferences), new System.Action(() => {
if (sym.Kind == SymbolKind.Local || sym.Kind == SymbolKind.Parameter || sym.Kind == SymbolKind.TypeParameter)
{
FindReferencesHandler.FindRefs(sym);
}
else
{
RefactoringService.FindReferencesAsync(FindReferencesHandler.FilterSymbolForFindReferences(sym).GetDocumentationCommentId());
}
}));
try {
if (Microsoft.CodeAnalysis.FindSymbols.SymbolFinder.FindSimilarSymbols(sym, semanticModel.Compilation).Count() > 1)
{
ainfo.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.FindAllReferences), new System.Action(() => RefactoringService.FindAllReferencesAsync(FindReferencesHandler.FilterSymbolForFindReferences(sym).GetDocumentationCommentId())));
}
} catch (Exception) {
// silently ignore roslyn bug.
}
}
added = true;
}
protected override void Update(CommandArrayInfo info)
{
if (caps.Update())
{
if (caps.resultResolutionAttempt != LooseResolution.NodeResolutionAttempt.RawSymbolLookup)
{
var refactoringMenu = new CommandInfoSet {
Text = GettextCatalog.GetString("Refactoring")
};
if (caps.lastResults.Any(t => t is DSymbol && DRenameRefactoring.CanRenameNode((t as DSymbol).Definition)))
{
refactoringMenu.CommandInfos.Add(IdeApp.CommandService.GetCommandInfo(EditCommands.Rename), new Action(caps.RenameSymbol));
}
if (refactoringMenu.CommandInfos.Count > 0)
{
info.Add(refactoringMenu);
}
info.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.GotoDeclaration), new Action(caps.GotoDeclaration));
info.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.FindReferences), new Action(() => caps.FindReferences(false)));
if (caps.lastResults.Any(t => t is DSymbol && (t as DSymbol).Definition.Parent is DClassLike))
{
info.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.FindAllReferences), new Action(() => caps.FindReferences(true)));
}
if (caps.lastResults.Any(t => {
var ds = DResolver.StripMemberSymbols(t);
return(ds is ClassType || ds is InterfaceType);
}))
{
info.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.FindDerivedClasses), new Action(caps.FindDerivedClasses));
}
}
else
{
var importSymbolMenu = new CommandInfoSet {
Text = GettextCatalog.GetString("Resolve")
};
foreach (var m in caps.GetImportableModulesForLastResults())
{
importSymbolMenu.CommandInfos.Add(new CommandInfo {
Text = "import " + AbstractNode.GetNodePath(m, true) + ";",
Icon = MonoDevelop.Ide.Gui.Stock.AddNamespace
}, new object[] { RefactoryCommands.ImportSymbol, m });
}
if (importSymbolMenu.CommandInfos.Count > 0)
{
importSymbolMenu.CommandInfos.AddSeparator();
var alreadyAddedItems = new List <DModule> ();
foreach (var t in caps.lastResults)
{
var n = DResolver.GetResultMember(t, true);
if (n == null)
{
continue;
}
var m = n.NodeRoot as DModule;
if (m != null && !alreadyAddedItems.Contains(m))
{
alreadyAddedItems.Add(m);
importSymbolMenu.CommandInfos.Add(new CommandInfo {
Text = AbstractNode.GetNodePath(n, true)
}, new object[] { RefactoryCommands.QuickFix, n });
}
}
// To explicitly show the Ctrl+Alt+Space hint.
importSymbolMenu.CommandInfos.AddSeparator();
importSymbolMenu.CommandInfos.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.ImportSymbol), new Action(caps.TryImportMissingSymbol));
info.Add(importSymbolMenu);
}
}
}
if (SortImportsCommandHandler.CanSortImports(caps.lastDoc))
{
info.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.SortImports), new Action(() => SortImportsCommandHandler.SortImports(caps.lastDoc)));
}
}
public static void PopulateInfos(CommandArrayInfo infos, Document doc, IEnumerable <FixableResult> results)
{
//FIXME: ellipsize long messages
int mnemonic = 1;
var codeActionExtension = doc.GetContent <CodeActionEditorExtension> ();
var fixes = codeActionExtension.GetCurrentFixes();
if (fixes != null)
{
foreach (var _fix in fixes.Where(CodeActionWidget.IsAnalysisOrErrorFix))
{
var fix = _fix;
if (fix is AnalysisContextActionProvider.AnalysisCodeAction)
{
continue;
}
var escapedLabel = fix.Title.Replace("_", "__");
var label = (mnemonic <= 10)
? "_" + (mnemonic++ % 10).ToString() + " " + escapedLabel
: " " + escapedLabel;
infos.Add(label, fix);
}
}
foreach (var result in results)
{
bool firstAction = true;
foreach (var action in GetActions(doc, result))
{
if (firstAction)
{
//FIXME: make this header item insensitive but not greyed out
infos.Add(new CommandInfo(result.Message.Replace("_", "__"), false, false)
{
Icon = GetIcon(result.Level)
}, null);
firstAction = false;
}
var escapedLabel = action.Label.Replace("_", "__");
var label = (mnemonic <= 10)
? "_" + (mnemonic++ % 10).ToString() + " " + escapedLabel
: " " + escapedLabel;
infos.Add(label, action);
}
if (result.HasOptionsDialog)
{
var declSet = new CommandInfoSet();
declSet.Text = GettextCatalog.GetString("_Options for \"{0}\"", result.OptionsTitle);
bool hasBatchFix = false;
foreach (var fix in result.Fixes.OfType <IAnalysisFixAction> ().Where(f => f.SupportsBatchFix))
{
hasBatchFix = true;
var title = string.Format(GettextCatalog.GetString("Apply in file: {0}"), fix.Label);
declSet.CommandInfos.Add(title, new System.Action(fix.BatchFix));
}
if (hasBatchFix)
{
declSet.CommandInfos.AddSeparator();
}
var ir = result as InspectorResults;
if (ir != null)
{
var inspector = ir.Inspector;
if (inspector.CanSuppressWithAttribute)
{
declSet.CommandInfos.Add(GettextCatalog.GetString("_Suppress with attribute"), new System.Action(delegate {
inspector.SuppressWithAttribute(doc, ir.Region);
}));
}
if (inspector.CanDisableWithPragma)
{
declSet.CommandInfos.Add(GettextCatalog.GetString("_Suppress with #pragma"), new System.Action(delegate {
inspector.DisableWithPragma(doc, ir.Region);
}));
}
if (inspector.CanDisableOnce)
{
declSet.CommandInfos.Add(GettextCatalog.GetString("_Disable once with comment"), new System.Action(delegate {
inspector.DisableOnce(doc, ir.Region);
}));
}
if (inspector.CanDisableAndRestore)
{
declSet.CommandInfos.Add(GettextCatalog.GetString("Disable _and restore with comments"), new System.Action(delegate {
inspector.DisableAndRestore(doc, ir.Region);
}));
}
}
declSet.CommandInfos.Add(GettextCatalog.GetString("_Configure inspection"), result);
infos.Add(declSet);
}
}
}
public static void PopulateInfos(CommandArrayInfo infos, Document doc, IEnumerable <FixableResult> results)
{
//FIXME: ellipsize long messages
int mnemonic = 1;
foreach (var result in results)
{
bool firstAction = true;
foreach (var action in GetActions(doc, result))
{
if (firstAction)
{
//FIXME: make this header item insensitive but not greyed out
infos.Add(new CommandInfo(result.Message.Replace("_", "__"), false, false)
{
Icon = GetIcon(result.Level)
}, null);
firstAction = false;
}
var escapedLabel = action.Label.Replace("_", "__");
var label = (mnemonic <= 10)
? "_" + (mnemonic++ % 10).ToString() + " " + escapedLabel
: " " + escapedLabel;
infos.Add(label, action);
}
if (result.HasOptionsDialog)
{
var declSet = new CommandInfoSet();
declSet.Text = GettextCatalog.GetString("_Options for \"{0}\"", result.OptionsTitle);
var ir = result as InspectorResults;
if (ir != null)
{
var inspector = ir.Inspector;
if (inspector.CanSuppressWithAttribute)
{
declSet.CommandInfos.Add(GettextCatalog.GetString("_Suppress with attribute"), new System.Action(delegate {
inspector.SuppressWithAttribute(doc, ir.Region);
}));
}
if (inspector.CanDisableWithPragma)
{
declSet.CommandInfos.Add(GettextCatalog.GetString("_Suppress with #pragma"), new System.Action(delegate {
inspector.DisableWithPragma(doc, ir.Region);
}));
}
if (inspector.CanDisableOnce)
{
declSet.CommandInfos.Add(GettextCatalog.GetString("_Disable once with comment"), new System.Action(delegate {
inspector.DisableOnce(doc, ir.Region);
}));
}
if (inspector.CanDisableAndRestore)
{
declSet.CommandInfos.Add(GettextCatalog.GetString("Disable _and restore with comments"), new System.Action(delegate {
inspector.DisableAndRestore(doc, ir.Region);
}));
}
}
declSet.CommandInfos.Add(GettextCatalog.GetString("_Configure inspection severity"), result);
infos.Add(declSet);
}
}
}
protected override void Update(CommandArrayInfo info)
{
string group;
var lastListGroup = new Dictionary <CommandArrayInfo, string>();
var descFormat = GettextCatalog.GetString("Show {0}");
foreach (Pad pad in IdeApp.Workbench.Pads.OrderBy(p => p.Group, StringComparer.InvariantCultureIgnoreCase))
{
CommandInfo ci = new CommandInfo(pad.Title);
ci.Icon = pad.Icon;
ci.UseMarkup = true;
ci.Description = string.Format(descFormat, pad.Title);
// We only want these commands enabled if the main window is visible
ci.Enabled = IdeApp.Workbench.RootWindow.Visible;
ActionCommand cmd = IdeApp.CommandService.GetActionCommand("Pad|" + pad.Id);
if (cmd != null)
{
ci.AccelKey = cmd.AccelKey;
}
CommandArrayInfo list = info;
if (pad.Categories != null)
{
for (int j = 0; j < pad.Categories.Length; j++)
{
bool found = false;
for (int k = list.Count - 1; k >= 0; k--)
{
if (list[k].Text == pad.Categories[j] && list[k] is CommandInfoSet)
{
list = ((CommandInfoSet)list[k]).CommandInfos;
found = true;
break;
}
}
if (!found)
{
CommandInfoSet set = new CommandInfoSet();
set.Text = pad.Categories[j];
set.Description = string.Format(descFormat, set.Text);
list.Add(set);
list = set.CommandInfos;
}
}
}
int atIndex = 0;
for (int j = list.Count - 1; j >= 0; j--)
{
if (!(list [j] is CommandInfoSet))
{
atIndex = j + 1;
break;
}
}
list.Insert(atIndex, ci, pad);
lastListGroup.TryGetValue(list, out group);
if (group != pad.Group)
{
lastListGroup [list] = pad.Group;
if (atIndex > 0)
{
CommandInfo sep = new CommandInfo("-");
sep.IsArraySeparator = true;
list.Insert(atIndex, sep, null);
}
}
}
}
static CommandInfoSet CreateFixMenu(TextEditor editor, DocumentContext ctx, SemanticModel semanticModel, CodeActionContainer container)
{
if (editor == null)
{
throw new ArgumentNullException(nameof(editor));
}
if (ctx == null)
{
throw new ArgumentNullException(nameof(ctx));
}
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
var result = new CommandInfoSet();
result.Text = GettextCatalog.GetString("Fix");
foreach (var diagnostic in container.CodeFixActions)
{
var info = new CommandInfo(diagnostic.CodeAction.Title);
result.CommandInfos.Add(info, new Action(async() => await new CodeActionEditorExtension.ContextActionRunner(diagnostic.CodeAction, editor, ctx).Run()));
}
bool firstDiagnosticOption = result.CommandInfos.Count != 0;
var warningsAtCaret = semanticModel
.GetDiagnostics(new TextSpan(editor.CaretOffset, 0))
.Where(diag => diag.Severity == DiagnosticSeverity.Warning).ToList();
foreach (var warning in warningsAtCaret)
{
if (firstDiagnosticOption)
{
result.CommandInfos.AddSeparator();
firstDiagnosticOption = false;
}
var label = GettextCatalog.GetString("_Options for \"{0}\"", warning.Descriptor.Title);
var subMenu = new CommandInfoSet();
subMenu.Text = label;
var info = new CommandInfo(GettextCatalog.GetString("_Suppress with #pragma"));
subMenu.CommandInfos.Add(info, new Action(async delegate {
var fixes = await CSharpSuppressionFixProvider.Instance.GetSuppressionsAsync(ctx.AnalysisDocument, new TextSpan(editor.CaretOffset, 0), new [] { warning }, default(CancellationToken)).ConfigureAwait(false);
foreach (var f in fixes)
{
CodeDiagnosticDescriptor.RunAction(ctx, f.Action, default(CancellationToken));
}
}));
result.CommandInfos.Add(subMenu);
}
foreach (var fix in container.DiagnosticsAtCaret)
{
var inspector = BuiltInCodeDiagnosticProvider.GetCodeDiagnosticDescriptor(fix.Id);
if (inspector == null)
{
continue;
}
if (firstDiagnosticOption)
{
result.CommandInfos.AddSeparator();
firstDiagnosticOption = false;
}
var label = GettextCatalog.GetString("_Options for \"{0}\"", fix.GetMessage());
var subMenu = new CommandInfoSet();
subMenu.Text = label;
// if (inspector.CanSuppressWithAttribute) {
// var menuItem = new FixMenuEntry (GettextCatalog.GetString ("_Suppress with attribute"),
// delegate {
//
// inspector.SuppressWithAttribute (Editor, DocumentContext, GetTextSpan (fix.Item2));
// });
// subMenu.Add (menuItem);
// }
if (inspector.CanDisableWithPragma)
{
var info = new CommandInfo(GettextCatalog.GetString("_Suppress with #pragma"));
subMenu.CommandInfos.Add(info, new Action(() => inspector.DisableWithPragma(editor, ctx, fix)));
info = new CommandInfo(GettextCatalog.GetString("_Suppress with file"));
subMenu.CommandInfos.Add(info, new Action(() => inspector.DisableWithFile(editor, ctx, fix)));
}
var configInfo = new CommandInfo(GettextCatalog.GetString("_Configure Rule"));
subMenu.CommandInfos.Add(configInfo, new Action(() => {
IdeApp.Workbench.ShowGlobalPreferencesDialog(null, "C#", dialog => {
var panel = dialog.GetPanel <CodeIssuePanel> ("C#");
if (panel == null)
{
return;
}
panel.Widget.SelectCodeIssue(inspector.IdString);
});
}));
foreach (var fix2 in container.CodeFixActions)
{
var provider = fix2.Diagnostic.GetCodeFixProvider().GetFixAllProvider();
if (provider == null)
{
continue;
}
if (!provider.GetSupportedFixAllScopes().Contains(FixAllScope.Document))
{
continue;
}
var subMenu2 = new CommandInfoSet();
subMenu2.Text = GettextCatalog.GetString("Fix all");
var diagnosticAnalyzer = fix2.Diagnostic.GetCodeDiagnosticDescriptor(LanguageNames.CSharp).GetProvider();
if (!diagnosticAnalyzer.SupportedDiagnostics.Contains(fix.Descriptor))
{
continue;
}
var info = new CommandInfo(GettextCatalog.GetString("In _Document"));
subMenu2.CommandInfos.Add(info, new Action(async delegate {
var fixAllDiagnosticProvider = new CodeActionEditorExtension.FixAllDiagnosticProvider(diagnosticAnalyzer.SupportedDiagnostics.Select(d => d.Id).ToImmutableHashSet(), async(Microsoft.CodeAnalysis.Document doc, ImmutableHashSet <string> diagnostics, CancellationToken token) => {
var model = await doc.GetSemanticModelAsync(token);
var compilationWithAnalyzer = model.Compilation.WithAnalyzers(new [] { diagnosticAnalyzer }.ToImmutableArray(), null, token);
return(await compilationWithAnalyzer.GetAnalyzerSemanticDiagnosticsAsync(model, null, token));
}, (arg1, arg2, arg3, arg4) => {
return(Task.FromResult((IEnumerable <Diagnostic>) new Diagnostic [] { }));
});
var ctx2 = new FixAllContext(
ctx.AnalysisDocument,
fix2.Diagnostic.GetCodeFixProvider(),
FixAllScope.Document,
fix2.CodeAction.EquivalenceKey,
diagnosticAnalyzer.SupportedDiagnostics.Select(d => d.Id),
fixAllDiagnosticProvider,
default(CancellationToken)
);
var fixAll = await provider.GetFixAsync(ctx2);
using (var undo = editor.OpenUndoGroup()) {
CodeDiagnosticDescriptor.RunAction(ctx, fixAll, default(CancellationToken));
}
}));
subMenu.CommandInfos.Add(subMenu2);
}
result.CommandInfos.Add(subMenu);
}
return(result);
}
