public override TooltipItem GetItem (Mono.TextEditor.TextEditor editor, int offset)
{
var doc = IdeApp.Workbench.ActiveDocument;
if (doc == null || doc.ParsedDocument == null)
return null;
var unit = doc.ParsedDocument.GetAst<SyntaxTree> ();
if (unit == null)
return null;
var file = doc.ParsedDocument.ParsedFile as CSharpUnresolvedFile;
if (file == null)
return null;
ResolveResult result;
AstNode node;
var loc = editor.OffsetToLocation (offset);
if (!doc.TryResolveAt (loc, out result, out node)) {
if (node is CSharpTokenNode) {
int startOffset2 = editor.LocationToOffset (node.StartLocation);
int endOffset2 = editor.LocationToOffset (node.EndLocation);
return new TooltipItem (new ToolTipData (unit, result, node, null), startOffset2, endOffset2 - startOffset2);
}
return null;
}
if (node == lastNode)
return lastResult;
var resolver = new CSharpAstResolver (doc.Compilation, unit, file);
resolver.ApplyNavigator (new NodeListResolveVisitorNavigator (node), CancellationToken.None);
var hoverNode = node.GetNodeAt (loc) ?? node;
int startOffset = editor.LocationToOffset (hoverNode.StartLocation);
int endOffset = editor.LocationToOffset (hoverNode.EndLocation);
return lastResult = new TooltipItem (new ToolTipData (unit, result, node, resolver), startOffset, endOffset - startOffset);
}
public ResolveResult GetLanguageItem (MonoDevelop.Ide.Gui.Document doc, int offset, string expression)
{
if (offset < 0) {
return null;
}
var parsedDocument = doc.ParsedDocument;
if (parsedDocument == null)
return null;
var data = doc.Editor;
var loc = data.OffsetToLocation (offset);
var unit = parsedDocument.GetAst<SyntaxTree> ();
var parsedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile;
if (unit == null || parsedFile == null) {
return null;
}
var node = unit.GetNodeAt (loc);
if (node == null) {
return null;
}
var resolver = new CSharpAstResolver (doc.Compilation, unit, parsedFile);
resolver.ApplyNavigator (new NodeListResolveVisitorNavigator (node), CancellationToken.None);
var state = resolver.GetResolverStateBefore (node, CancellationToken.None);
return state.LookupSimpleNameOrTypeName (expression, new List<IType> (), NameLookupMode.Expression);
}
/// <summary>
/// Finds all references in the given file.
/// </summary>
/// <param name="searchScopes">The search scopes for which to look.</param>
/// <param name="unresolvedFile">The type system representation of the file being searched.</param>
/// <param name="syntaxTree">The syntax tree of the file being searched.</param>
/// <param name="compilation">The compilation for the project that contains the file.</param>
/// <param name="callback">Callback used to report the references that were found.</param>
/// <param name="cancellationToken">CancellationToken that may be used to cancel the operation.</param>
public void FindReferencesInFile(IList<IFindReferenceSearchScope> searchScopes, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree,
ICompilation compilation, FoundReferenceCallback callback, CancellationToken cancellationToken)
{
if (searchScopes == null)
throw new ArgumentNullException("searchScopes");
if (syntaxTree == null)
throw new ArgumentNullException("syntaxTree");
if (compilation == null)
throw new ArgumentNullException("compilation");
if (callback == null)
throw new ArgumentNullException("callback");
if (searchScopes.Count == 0)
return;
var navigators = new IResolveVisitorNavigator[searchScopes.Count];
for (int i = 0; i < navigators.Length; i++) {
navigators[i] = searchScopes[i].GetNavigator(compilation, callback);
}
IResolveVisitorNavigator combinedNavigator;
if (searchScopes.Count == 1) {
combinedNavigator = navigators[0];
} else {
combinedNavigator = new CompositeResolveVisitorNavigator(navigators);
}
cancellationToken.ThrowIfCancellationRequested();
combinedNavigator = new DetectSkippableNodesNavigator(combinedNavigator, syntaxTree);
cancellationToken.ThrowIfCancellationRequested();
CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, unresolvedFile);
resolver.ApplyNavigator(combinedNavigator, cancellationToken);
foreach (var n in navigators) {
var frn = n as FindReferenceNavigator;
if (frn != null)
frn.NavigatorDone(resolver, cancellationToken);
}
}
bool TypeChangeResolvesCorrectly(ParameterDeclaration parameter, AstNode rootNode, IType type)
{
MethodResolveCount++;
var resolver = ctx.GetResolverStateBefore(rootNode);
resolver = resolver.AddVariable(new DefaultParameter(type, parameter.Name));
var astResolver = new CSharpAstResolver(resolver, rootNode, ctx.UnresolvedFile);
var validator = new TypeChangeValidationNavigator();
astResolver.ApplyNavigator(validator, ctx.CancellationToken);
return !validator.FoundErrors;
}