public static bool ResolveAt(Document doc, out ResolveResult resolveResult, out AstNode node, CancellationToken token = default(CancellationToken))
{
var parsedDocument = doc.ParsedDocument;
resolveResult = null;
node = null;
if (parsedDocument == null)
{
return(false);
}
var unit = parsedDocument.GetAst <SyntaxTree> ();
var parsedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile;
if (unit == null || parsedFile == null)
{
return(false);
}
try {
var location = RefactoringService.GetCorrectResolveLocation(doc, doc.Editor.Caret.Location);
resolveResult = ResolveAtLocation.Resolve(doc.Compilation, parsedFile, unit, location, out node, token);
if (resolveResult == null || node is Statement)
{
return(false);
}
} catch (OperationCanceledException) {
return(false);
} catch (Exception e) {
Console.WriteLine("Got resolver exception:" + e);
return(false);
}
return(true);
}
public static bool ResolveAt(Document doc, out ResolveResult resolveResult, out AstNode node, CancellationToken token = default(CancellationToken))
{
if (doc == null)
{
throw new ArgumentNullException("doc");
}
var editor = doc.Editor;
if (editor == null || editor.MimeType != "text/x-csharp")
{
node = null;
resolveResult = null;
return(false);
}
if (!InternalResolveAt(doc, out resolveResult, out node))
{
var location = RefactoringService.GetCorrectResolveLocation(doc, editor.Caret.Location);
resolveResult = GetHeuristicResult(doc, location, ref node);
if (resolveResult == null)
{
return(false);
}
}
var oce = node as ObjectCreateExpression;
if (oce != null)
{
node = oce.Type;
}
return(true);
}
public virtual void Run(RefactoringOptions options)
{
List <Change> changes = PerformChanges(options, null);
IProgressMonitor monitor = IdeApp.Workbench.ProgressMonitors.GetBackgroundProgressMonitor(Name, null);
RefactoringService.AcceptChanges(monitor, options.Dom, changes);
}
public static List <PossibleNamespace> GetPossibleNamespaces(Document doc, AstNode node, ref ResolveResult resolveResult)
{
if (doc == null)
{
throw new ArgumentNullException("doc");
}
if (node == null)
{
throw new ArgumentNullException("node");
}
var location = RefactoringService.GetCorrectResolveLocation(doc, doc.Editor.Caret.Location);
if (resolveResult == null || resolveResult.Type.FullName == "System.Void")
{
resolveResult = GetHeuristicResult(doc, location, ref node) ?? resolveResult;
}
var foundNamespaces = GetPossibleNamespaces(doc, node, resolveResult, location);
if (!(resolveResult is AmbiguousTypeResolveResult))
{
var usedNamespaces = RefactoringOptions.GetUsedNamespaces(doc, location);
foundNamespaces = foundNamespaces.Where(n => !usedNamespaces.Contains(n.Namespace));
}
var result = new List <PossibleNamespace> ();
foreach (var ns in foundNamespaces)
{
if (result.Any(n => n.Namespace == ns.Namespace))
{
continue;
}
result.Add(ns);
}
return(result);
}
public static List <string> GetResolveableNamespaces(RefactoringOptions options, out bool resolveDirect)
{
IReturnType returnType = null;
INRefactoryASTProvider astProvider = RefactoringService.GetASTProvider(DesktopService.GetMimeTypeForUri(options.Document.FileName));
if (options.ResolveResult != null && options.ResolveResult.ResolvedExpression != null)
{
if (astProvider != null)
{
returnType = astProvider.ParseTypeReference(options.ResolveResult.ResolvedExpression.Expression).ConvertToReturnType();
}
if (returnType == null)
{
returnType = DomReturnType.GetSharedReturnType(options.ResolveResult.ResolvedExpression.Expression);
}
}
List <string> namespaces;
if (options.ResolveResult is UnresolvedMemberResolveResult)
{
namespaces = new List <string> ();
UnresolvedMemberResolveResult unresolvedMemberResolveResult = options.ResolveResult as UnresolvedMemberResolveResult;
IType type = unresolvedMemberResolveResult.TargetResolveResult != null?options.Dom.GetType(unresolvedMemberResolveResult.TargetResolveResult.ResolvedType) : null;
if (type != null)
{
List <IType> allExtTypes = DomType.GetAccessibleExtensionTypes(options.Dom, null);
foreach (ExtensionMethod method in type.GetExtensionMethods(allExtTypes, unresolvedMemberResolveResult.MemberName))
{
string ns = method.OriginalMethod.DeclaringType.Namespace;
if (!namespaces.Contains(ns) && !options.Document.CompilationUnit.Usings.Any(u => u.Namespaces.Contains(ns)))
{
namespaces.Add(ns);
}
}
}
resolveDirect = false;
}
else
{
namespaces = new List <string> (options.Dom.ResolvePossibleNamespaces(returnType));
resolveDirect = true;
}
for (int i = 0; i < namespaces.Count; i++)
{
for (int j = i + 1; j < namespaces.Count; j++)
{
if (namespaces[j] == namespaces[i])
{
namespaces.RemoveAt(j);
j--;
}
}
}
return(namespaces);
}
public RefactoringPreviewDialog(ProjectDom ctx, List <Change> changes)
{
this.Build();
this.changes = changes;
treeviewPreview.Model = store;
TreeViewColumn column = new TreeViewColumn();
// pixbuf column
var pixbufCellRenderer = new CellRendererPixbuf();
column.PackStart(pixbufCellRenderer, false);
column.SetAttributes(pixbufCellRenderer, "pixbuf", pixbufColumn);
column.AddAttribute(pixbufCellRenderer, "visible", statusVisibleColumn);
// text column
CellRendererText cellRendererText = new CellRendererText();
column.PackStart(cellRendererText, false);
column.SetAttributes(cellRendererText, "text", textColumn);
column.AddAttribute(cellRendererText, "visible", statusVisibleColumn);
// location column
CellRendererText cellRendererText2 = new CellRendererText();
column.PackStart(cellRendererText2, false);
column.SetCellDataFunc(cellRendererText2, new TreeCellDataFunc(SetLocationTextData));
CellRendererDiff cellRendererDiff = new CellRendererDiff();
column.PackStart(cellRendererDiff, true);
column.SetCellDataFunc(cellRendererDiff, new TreeCellDataFunc(SetDiffCellData));
treeviewPreview.AppendColumn(column);
treeviewPreview.HeadersVisible = false;
buttonCancel.Clicked += delegate {
Destroy();
};
buttonOk.Clicked += delegate {
IProgressMonitor monitor = IdeApp.Workbench.ProgressMonitors.GetBackgroundProgressMonitor(this.Title, null);
RefactoringService.AcceptChanges(monitor, ctx, changes);
Destroy();
};
FillChanges();
Resize(IdeApp.Workbench.ActiveDocument.ActiveView.Control.Allocation.Width,
IdeApp.Workbench.ActiveDocument.ActiveView.Control.Allocation.Height);
}
public RefactoringPreviewDialog(IList <Change> changes)
{
this.Build();
this.changes = changes;
treeviewPreview.Model = store;
treeviewPreview.SearchColumn = -1; // disable the interactive search
TreeViewColumn column = new TreeViewColumn();
// pixbuf column
var pixbufCellRenderer = new CellRendererImage();
column.PackStart(pixbufCellRenderer, false);
column.SetAttributes(pixbufCellRenderer, "image", pixbufColumn);
column.AddAttribute(pixbufCellRenderer, "visible", statusVisibleColumn);
// text column
CellRendererText cellRendererText = new CellRendererText();
column.PackStart(cellRendererText, false);
column.SetAttributes(cellRendererText, "text", textColumn);
column.AddAttribute(cellRendererText, "visible", statusVisibleColumn);
// location column
CellRendererText cellRendererText2 = new CellRendererText();
column.PackStart(cellRendererText2, false);
column.SetCellDataFunc(cellRendererText2, new TreeCellDataFunc(SetLocationTextData));
CellRendererDiff cellRendererDiff = new CellRendererDiff();
column.PackStart(cellRendererDiff, true);
column.SetCellDataFunc(cellRendererDiff, new TreeCellDataFunc(SetDiffCellData));
treeviewPreview.AppendColumn(column);
treeviewPreview.HeadersVisible = false;
buttonCancel.Clicked += delegate {
Destroy();
};
buttonOk.Clicked += delegate {
ProgressMonitor monitor = IdeApp.Workbench.ProgressMonitors.GetBackgroundProgressMonitor(this.Title, null);
RefactoringService.AcceptChanges(monitor, changes);
Destroy();
};
FillChanges();
}
public static HashSet <PossibleNamespace> GetPossibleNamespaces(Document doc, AstNode node, ref ResolveResult resolveResult)
{
var location = RefactoringService.GetCorrectResolveLocation(doc, doc.Editor.Caret.Location);
if (resolveResult == null || resolveResult.Type.FullName == "System.Void")
{
resolveResult = GetHeuristicResult(doc, location, ref node) ?? resolveResult;
}
var foundNamespaces = GetPossibleNamespaces(doc, node, resolveResult, location);
if (!(resolveResult is AmbiguousTypeResolveResult))
{
var usedNamespaces = RefactoringOptions.GetUsedNamespaces(doc, location);
foundNamespaces = foundNamespaces.Where(n => !usedNamespaces.Contains(n.Namespace));
}
return(new HashSet <PossibleNamespace> (foundNamespaces));
}
public static bool ResolveAt(Document doc, out ResolveResult resolveResult, out AstNode node, CancellationToken token = default(CancellationToken))
{
if (!InternalResolveAt(doc, out resolveResult, out node))
{
var location = RefactoringService.GetCorrectResolveLocation(doc, doc.Editor.Caret.Location);
resolveResult = GetHeuristicResult(doc, location, ref node);
if (resolveResult == null)
{
return(false);
}
}
var oce = node as ObjectCreateExpression;
if (oce != null)
{
node = oce.Type;
}
return(true);
}
public INRefactoryASTProvider GetASTProvider()
{
return(RefactoringService.GetASTProvider(MimeType));
}
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 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();
}
}