public Task <Reference[]> FindReferences(ReferencesParams @params, CancellationToken cancellationToken)
{
var uri = @params.textDocument.uri;
_log?.Log(TraceEventType.Verbose, $"References in {uri} at {@params.position}");
return(new ReferenceSource(Services).FindAllReferencesAsync(uri, @params.position, ReferenceSearchOptions.All, cancellationToken));
}
public Task <DocumentHighlight[]> DocumentHighlight(ReferencesParams @params, CancellationToken cancellationToken)
{
var uri = @params.textDocument.uri;
_log?.Log(TraceEventType.Verbose, $"Document highlight in {uri} at {@params.position}");
return(new DocumentHighlightSource(Services).DocumentHighlightAsync(uri, @params.position, cancellationToken));
}
public async Task <Reference[]> FindReferences(ReferencesParams @params, CancellationToken cancellationToken)
{
var uri = @params.textDocument.uri;
_log?.Log(TraceEventType.Verbose, $"References in {uri} at {@params.position}");
return(Array.Empty <Reference>());
}
protected async Task HandleReferencesRequest(
ReferencesParams referencesParams,
EditorSession editorSession,
RequestContext <Location[], object> requestContext)
{
ScriptFile scriptFile =
editorSession.Workspace.GetFile(
referencesParams.Uri);
SymbolReference foundSymbol =
editorSession.LanguageService.FindSymbolAtLocation(
scriptFile,
referencesParams.Position.Line + 1,
referencesParams.Position.Character + 1);
FindReferencesResult referencesResult =
await editorSession.LanguageService.FindReferencesOfSymbol(
foundSymbol,
editorSession.Workspace.ExpandScriptReferences(scriptFile));
Location[] referenceLocations = null;
if (referencesResult != null)
{
referenceLocations =
referencesResult
.FoundReferences
.Select(r =>
{
return(new Location
{
Uri = new Uri(r.FilePath).AbsoluteUri,
Range = GetRangeFromScriptRegion(r.ScriptRegion)
});
})
.ToArray();
}
else
{
referenceLocations = new Location[0];
}
await requestContext.SendResult(referenceLocations);
}
public virtual Task <Reference[]> FindReferences(ReferencesParams @params, CancellationToken cancellationToken) => throw new NotImplementedException();
private IEnumerable <Reference> GetModuleReferences(IPythonProjectEntry entry, PythonAst tree, BufferVersion version, ReferencesParams @params)
{
if ([email protected]?.includeDeclaration == true)
{
return(Enumerable.Empty <Reference>());
}
var index = tree.LocationToIndex(@params.position);
var w = new ImportedModuleNameWalker(entry, index, tree);
tree.Walk(w);
if (w.ImportedType != null)
{
@params._expr = w.ImportedType.Name;
return(Enumerable.Empty <Reference>());
}
var modulesNamesInRange = w.ImportedModules.Where(m => {
var start = tree.LocationToIndex(m.SourceSpan.Start);
var end = tree.LocationToIndex(m.SourceSpan.End);
return(start <= index && index < end);
}).ToArray();
if (modulesNamesInRange.Length == 0)
{
return(Enumerable.Empty <Reference>());
}
var refs = new List <Reference>();
foreach (var n in modulesNamesInRange)
{
if (Analyzer.Modules.TryGetImportedModule(n.Name, out var modRef) && modRef.AnalysisModule != null)
{
// Return a module reference
refs.AddRange(modRef.AnalysisModule.Locations
.Select(l => new Reference {
uri = l.DocumentUri,
range = l.Span,
_version = version?.Version,
_kind = ReferenceKind.Definition
})
.ToArray());
}
}
return(refs);
}
public override async Task <Reference[]> FindReferences(ReferencesParams @params, CancellationToken cancellationToken)
{
await WaitForCompleteAnalysisAsync(cancellationToken);
var uri = @params.textDocument.uri;
ProjectFiles.GetEntry(@params.textDocument, @params._version, out var entry, out var tree);
TraceMessage($"References in {uri} at {@params.position}");
var analysis = entry != null ? await entry.GetAnalysisAsync(50, cancellationToken) : null;
if (analysis == null)
{
TraceMessage($"No analysis found for {uri}");
return(Array.Empty <Reference>());
}
tree = GetParseTree(entry, uri, cancellationToken, out var version);
var modRefs = GetModuleReferences(entry, tree, version, @params);
IEnumerable <IAnalysisVariable> result;
if (!string.IsNullOrEmpty(@params._expr))
{
TraceMessage($"Getting references for {@params._expr}");
result = analysis.GetVariables(@params._expr, @params.position);
}
else
{
var finder = new ExpressionFinder(tree, GetExpressionOptions.FindDefinition);
if (finder.GetExpression(@params.position) is Expression expr)
{
TraceMessage($"Getting references for {expr.ToCodeString(tree, CodeFormattingOptions.Traditional)}");
result = analysis.GetVariables(expr, @params.position);
}
else
{
TraceMessage($"No references found in {uri} at {@params.position}");
result = Enumerable.Empty <IAnalysisVariable>();
}
}
var filtered = result.Where(v => v.Type != VariableType.None);
if (!(@params.context?.includeDeclaration ?? false))
{
filtered = filtered.Where(v => v.Type != VariableType.Definition);
}
if (!(@params.context?._includeValues ?? false))
{
filtered = filtered.Where(v => v.Type != VariableType.Value);
}
var res = filtered.Select(v => new Reference {
uri = v.Location.DocumentUri,
range = v.Location.Span,
_kind = ToReferenceKind(v.Type),
_version = version?.Version
})
.Concat(modRefs)
.GroupBy(r => r, ReferenceComparer.Instance)
.Select(g => g.OrderByDescending(r => (SourceLocation)r.range.end).ThenBy(r => (int?)r._kind ?? int.MaxValue).First())
.ToArray();
return(res);
}
private static async Task HandleReferencesRequest(
ReferencesParams referencesParams,
RequestContext <Location[]> requestContext)
{
await Task.FromResult(true);
}
