public async Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken token)
{
var(document, position) = _workspace.GetLogicalDocument(request);
var goToDefinitionService = document.GetLanguageService <IGoToDefinitionService>();
var definitions = await goToDefinitionService.FindDefinitionsAsync(document, position, token);
// TODO: Handle spans within embedded HLSL blocks; the TextSpan is currently relative to the start of the embedded block.
var locations = new List <LocationOrLocationLink>();
foreach (var definition in definitions)
{
var documentSpan = definition.SourceSpans[0];
var sourceSpan = documentSpan.SourceSpan;
locations.Add(new Location
{
Uri = Helpers.ToUri(sourceSpan.File.FilePath),
Range = sourceSpan.IsInRootFile
? Helpers.ToRange(document.SourceText, sourceSpan.Span)
: Helpers.ToRange(sourceSpan.File.Text, sourceSpan.Span)
});
}
return(locations);
}
public async Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
{
ScriptFile scriptFile =
_workspaceService.GetFile(
request.TextDocument.Uri.ToString());
SymbolReference foundSymbol =
_symbolsService.FindSymbolAtLocation(
scriptFile,
(int)request.Position.Line + 1,
(int)request.Position.Character + 1);
List <LocationOrLocationLink> definitionLocations = new List <LocationOrLocationLink>();
if (foundSymbol != null)
{
SymbolReference foundDefinition = await _symbolsService.GetDefinitionOfSymbolAsync(
scriptFile,
foundSymbol);
if (foundDefinition != null)
{
definitionLocations.Add(
new LocationOrLocationLink(
new Location
{
Uri = PathUtils.ToUri(foundDefinition.FilePath),
Range = GetRangeFromScriptRegion(foundDefinition.ScriptRegion)
}));
}
}
return(new LocationOrLocationLinks(definitionLocations));
}
public override Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
{
var context = this.compilationManager.GetCompilation(request.TextDocument.Uri);
if (context is null)
{
return(Task.FromResult(new LocationOrLocationLinks()));
}
var result = this.symbolResolver.ResolveSymbol(request.TextDocument.Uri, request.Position);
// No parent Symbol: ad hoc syntax matching
if (result is null)
{
return(HandleUnboundSymbolLocationAsync(request, context));
}
// Declared symbols: go to definition
else if (result.Symbol is DeclaredSymbol declaration)
{
return(HandleDeclaredDefinitionLocationAsync(request, result, declaration));
}
// Object property: currently only used for module param goto
else if (result.Origin is ObjectPropertySyntax objectPropertySyntax)
{
return(HandleObjectPropertyLocationAsync(request, result, context));
}
// Used for module (name), variable or resource property access
else if (result.Symbol is PropertySymbol)
{
return(HandlePropertyLocationAsync(request, result, context));
}
return(Task.FromResult(new LocationOrLocationLinks()));
}
public override Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
{
DafnyDocument?document;
if (!_documents.TryGetDocument(request.TextDocument, out document))
{
_logger.LogWarning("location requested for unloaded document {}", request.TextDocument.Uri);
return(Task.FromResult(new LocationOrLocationLinks()));
}
ILocalizableSymbol?symbol;
if (!document.SymbolTable.TryGetSymbolAt(request.Position, out symbol))
{
_logger.LogDebug("no symbol was found at {} in {}", request.Position, request.TextDocument);
return(Task.FromResult(new LocationOrLocationLinks()));
}
var location = GetLspLocation(document, symbol);
if (!location.HasValue)
{
_logger.LogDebug("failed to resolve the location of the symbol {} at {} in {}", symbol.Name, request.Position, request.TextDocument);
return(Task.FromResult(new LocationOrLocationLinks()));
}
return(Task.FromResult <LocationOrLocationLinks>(new[] { location.Value }));
}
protected virtual PXFieldState[] GetSlot(string name, DefinitionParams definitionParams, Type[] tables)
{
Definition def = PXDatabase.GetSlot <Definition, DefinitionParams>(
name, definitionParams, tables);
return(def == null ? null : def.Fields);
}
public override async Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
{
ScriptFile scriptFile = _workspaceService.GetFile(request.TextDocument.Uri);
SymbolReference foundSymbol =
SymbolsService.FindSymbolAtLocation(
scriptFile,
request.Position.Line + 1,
request.Position.Character + 1);
List <LocationOrLocationLink> definitionLocations = new List <LocationOrLocationLink>();
if (foundSymbol != null)
{
SymbolReference foundDefinition = await _symbolsService.GetDefinitionOfSymbolAsync(
scriptFile,
foundSymbol).ConfigureAwait(false);
if (foundDefinition != null)
{
definitionLocations.Add(
new LocationOrLocationLink(
new Location
{
Uri = DocumentUri.From(foundDefinition.FilePath),
Range = GetRangeFromScriptRegion(foundDefinition.ScriptRegion)
}));
}
}
return(new LocationOrLocationLinks(definitionLocations));
}
public Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
{
var doc = bufferManager.GetBuffer(request.TextDocument.Uri.AbsolutePath);
if (doc == null)
{
return(Task.FromResult <LocationOrLocationLinks>(null));
}
var identifier = doc.GetWordRangeAtPosition(request.Position);
var symbol = documentsManager.LookupSymbol(identifier);
if (symbol == null || symbol.Source == null || symbol.Source.LocalPath.Contains("DaedalusBuiltins"))
{
return(Task.FromResult <LocationOrLocationLinks>(null));
}
var symbolStart = new Position(symbol.Line - 1, symbol.Column);
var symbolEnd = new Position(symbol.Line - 1, symbol.Column + symbol.Name.Length);
var result = new LocationOrLocationLinks(new LocationOrLocationLink(new LocationLink
{
TargetRange = new OmniSharp.Extensions.LanguageServer.Protocol.Models.Range(symbolStart, symbolEnd),
TargetSelectionRange = new OmniSharp.Extensions.LanguageServer.Protocol.Models.Range(symbolStart, symbolEnd),
TargetUri = new Uri(symbol.Source.AbsoluteUri),
}));
return(Task.FromResult(result));
}
public override Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
{
var result = this.symbolResolver.ResolveSymbol(request.TextDocument.Uri, request.Position);
if (result == null)
{
return(Task.FromResult(new LocationOrLocationLinks()));
}
if (result.Symbol is PropertySymbol)
{
// TODO: Implement for PropertySymbol
return(Task.FromResult(new LocationOrLocationLinks()));
}
if (result.Symbol is DeclaredSymbol declaration)
{
return(Task.FromResult(new LocationOrLocationLinks(new LocationOrLocationLink(new LocationLink
{
// source of the link
OriginSelectionRange = result.Origin.ToRange(result.Context.LineStarts),
TargetUri = request.TextDocument.Uri,
// entire span of the variable
TargetRange = declaration.DeclaringSyntax.ToRange(result.Context.LineStarts),
// span of the variable name
TargetSelectionRange = declaration.NameSyntax.ToRange(result.Context.LineStarts)
}))));
}
return(Task.FromResult(new LocationOrLocationLinks()));
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
public async Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
//#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
List <LocationOrLocationLink> items = new List <LocationOrLocationLink>();
(var code, var lines, var tree) = bufferManager.Get(request.TextDocument.Uri.ToString());
int c = request.Position.Character;
int l = request.Position.Line;
router.Window.LogInfo("definition requested");
if (lines == null || tree == null)
{
return(items);
}
string token = lines[l][c].ToString();
if (lines[l][c].ToString().IsIdentifier())
{
for (int i = c + 1; i < lines[l].Length && lines[l][i].ToString().IsIdentifier(); i++)
{
token += lines[l][i];
}
for (int i = c - 1; i >= 0 && lines[l][i].ToString().IsIdentifier(); i--)
{
token = lines[l][i] + token;
}
}
else
{
return(items);
}
if (token.IsKeyword())
{
return(items);
}
//Context startOfSearch = FindContextAtLine(l, tree);
//if (startOfSearch == null) return items;
var def = FindDefinition(token, tree);
if (def == null)
{
return(items);
}
var start = DocumentHighlightHandler.GetPosition(code, def.Characters.Start);
var end = DocumentHighlightHandler.GetPosition(code, def.Characters.End);
router.Window.LogInfo("definition provided " + def);
return(new LocationOrLocationLinks(new Location()
{
Range = new Range(start, end), Uri = request.TextDocument.Uri
}));
}
public Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
{
if (sourceContainer.TryGetValue(request.TextDocument.Uri, out var sourceFile))
{
return(Task.Run(() => FindDefinition(sourceFile, Translator.Translate(request.Position))));
}
else
{
return(Task.FromResult(new LocationOrLocationLinks()));
}
}
public async Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
{
_router.Window.LogMessage(new LogMessageParams()
{
Type = MessageType.Log,
Message = "Go to definition request at line: " + (request.Position.Line + 1),
});
_threadManager.AssertBackgroundThread();
var document = await Task.Factory.StartNew(
() =>
{
_snapshotManager.TryResolveDocument(request.TextDocument.Uri.AbsolutePath, out var doc);
return(doc);
},
CancellationToken.None,
TaskCreationOptions.None,
_threadManager.ForegroundScheduler);
var syntaxTree = await document.GetSyntaxTreeAsync();
var child = syntaxTree.Root.GetNodeAt((int)request.Position.Line, (int)request.Position.Character);
if (child.Parent is MethodNode && (child is InputNode || child is OutputNode))
{
//var declaringTypeNode = FindDeclaringTypeNode(syntaxTree.Root, child.Content);
var declaringTypeNode = syntaxTree.Root.Messages.SingleOrDefault(c => c.Name == child.Content).NameNode;
if (declaringTypeNode != null)
{
var declaringTypeNodeLocation = new LocationOrLocationLink(
new Location()
{
Range = new Range(
new Position(declaringTypeNode.StartLine, declaringTypeNode.StartCol),
new Position(declaringTypeNode.EndLine, declaringTypeNode.EndCol)),
Uri = request.TextDocument.Uri,
});
var locations = new LocationOrLocationLinks(declaringTypeNodeLocation);
return(locations);
}
}
var emptyLocations = new LocationOrLocationLinks();
return(emptyLocations);
}
public Task <LocationOrLocations> Handle(DefinitionParams request, CancellationToken cancellationToken)
{
var navigator = new Navigator(injectionWorkspace);
var location = navigator.GetDefinition(request.TextDocument.Uri,
(int)request.Position.Line + 1, (int)request.Position.Character + 1);
if (location != null)
{
location.Range.Start.Line--;
location.Range.Start.Character--;
location.Range.End.Line--;
location.Range.End.Character--;
return(Task.FromResult(new LocationOrLocations(location)));
}
return(Task.FromResult(new LocationOrLocations(Array.Empty <Location>())));
}
public override Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
{
var context = this.compilationManager.GetCompilation(request.TextDocument.Uri);
if (context is null)
{
return(Task.FromResult(new LocationOrLocationLinks()));
}
var result = this.symbolResolver.ResolveSymbol(request.TextDocument.Uri, request.Position);
// No parent Symbol: ad hoc syntax matching
return(result switch
{
null => HandleUnboundSymbolLocationAsync(request, context),
{ Symbol : DeclaredSymbol declaration } => HandleDeclaredDefinitionLocationAsync(request, result, declaration),
public async Task <LocationOrLocationLinks> Handle(DefinitionParams definitionParams, CancellationToken token)
{
var links = _languageServer.LastParse?.ScriptFromUri(definitionParams.TextDocument.Uri)?.GetDefinitionLinks();
if (links == null)
{
return(new LocationOrLocationLinks());
}
links = links.Where(link => ((DocRange)link.OriginSelectionRange).IsInside(definitionParams.Position)).ToArray();
LocationOrLocationLink[] items = new LocationOrLocationLink[links.Length];
for (int i = 0; i < items.Length; i++)
{
items[i] = new LocationOrLocationLink(links[i]);
}
return(new LocationOrLocationLinks(items));
}
public async Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
{
_log.LogInformation(string.Format(Resources.LoggingMessages.request_handle, _method));
try
{
var uri = request.TextDocument.Uri;
var line = (int)request.Position.Line + 1;
var col = (int)request.Position.Character + 1;
var manager = _workspaceManager.GetFileRepository(request.TextDocument.Uri).SymbolTableManager;
IDefinitionsProvider provider = new DefinitionsProvider(manager);
return(await Task.Run(() => RunAndEvaluate(provider, uri, line, col), cancellationToken));
}
catch (Exception e)
{
HandleError(string.Format(Resources.LoggingMessages.request_error, _method), e);
return(null);
}
}
public Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
{
var hash = Hash.StringHash(request.TextDocument.Uri.GetFileSystemPath());
TreeSitter.FindDefinition(hash, request.Position.Line, request.Position.Character, out var defHash, out var origin, out var target, out var selection);
if (defHash != 0)
{
LocationLink link = new LocationLink();
link.TargetUri = DocumentUri.FromFileSystemPath(hashNamer.hashToName[defHash]);
link.OriginSelectionRange = ConvertRange(origin);
link.TargetRange = ConvertRange(target);
link.TargetSelectionRange = ConvertRange(selection);
LocationOrLocationLinks ll = new LocationOrLocationLinks(link);
return(Task.FromResult(ll));
}
return(Task.FromResult(new LocationOrLocationLinks()));
}
public Task <LocationOrLocations> Handle(DefinitionParams request, CancellationToken cancellationToken)
{
try
{
var scriptFile = _projectManager.GetScriptForFilePath(request.TextDocument.Uri.ToFilePath());
if (scriptFile == null)
{
return(Task.FromResult <LocationOrLocations>(null));
}
var identifier = scriptFile.Node.GetDescendantNodeOfTypeAtPosition <IdentifierNode>(request.Position.ToPosition());
if (identifier == null)
{
return(Task.FromResult <LocationOrLocations>(null));
}
var symbol = identifier.GetDeclaredOrReferencedSymbol();
if (symbol == null)
{
return(Task.FromResult <LocationOrLocations>(null));
}
var definitionFile = symbol.Script.Definition.GetScriptFile();
if (definitionFile == null)
{
return(Task.FromResult <LocationOrLocations>(null));
}
return(Task.FromResult(new LocationOrLocations(new Location()
{
Uri = PathUtilities.ToFileUri(symbol.Script.Definition.GetScriptFile().FilePath),
Range = symbol.Identifier.Range.ToRange()
})));
}
catch (Exception e)
{
_logger.LogWarning(e, "Error while handling request.");
}
return(Task.FromResult <LocationOrLocations>(null));
}
public override Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
{
var progress = ProgressManager.For(request, cancellationToken);
var work = ProgressManager.WorkDone(request, new WorkDoneProgressBegin
{
Title = "Resolve symbol definition location",
Message = "Begin resolving definition under caret"
});
var editorData = DResolverWrapper.CreateEditorData(request, cancellationToken);
var results = DResolverWrapper.ResolveHoveredCodeLoosely(editorData, out LooseResolution.NodeResolutionAttempt resolutionAttempt, out ISyntaxRegion syntaxRegion);
var result = new LocationOrLocationLinks(
results.Select(ExpressionTypeEvaluation.GetResultMember)
.Select(node => ToLocationOrLocationLink(node, Capability.LinkSupport, syntaxRegion)));
progress?.OnNext(new Container <LocationOrLocationLink>(result));
work.OnCompleted();
return(Task.FromResult(progress != null ? new LocationOrLocationLinks() : result));
}
public async Task <LocationOrLocations> Handle(DefinitionParams request, CancellationToken token)
{
var omnisharpRequest = new GotoDefinitionRequest()
{
FileName = FromUri(request.TextDocument.Uri),
Column = Convert.ToInt32(request.Position.Character),
Line = Convert.ToInt32(request.Position.Line)
};
var omnisharpResponse = await _definitionHandler.Handle(omnisharpRequest);
if (string.IsNullOrWhiteSpace(omnisharpResponse.FileName))
{
return(new LocationOrLocations());
}
return(new LocationOrLocations(new Location()
{
Uri = ToUri(omnisharpResponse.FileName),
Range = ToRange((omnisharpResponse.Column, omnisharpResponse.Line))
}));
public override async Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken token)
{
var omnisharpRequest = new GotoDefinitionRequest()
{
FileName = FromUri(request.TextDocument.Uri),
Column = Convert.ToInt32(request.Position.Character),
Line = Convert.ToInt32(request.Position.Line)
};
var omnisharpResponse = await _definitionHandler.Handle(omnisharpRequest);
if (omnisharpResponse.Definitions == null)
{
return(new LocationOrLocationLinks());
}
return(new LocationOrLocationLinks(omnisharpResponse.Definitions.Select <Definition, LocationOrLocationLink>(definition => new Location()
{
Uri = definition.Location.FileName,
Range = ToRange(definition.Location.Range)
})));
}
public override Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
{
var node = Workspace.GetNodeAt(request.TextDocument.Uri, request.Position);
Range range;
switch (node)
{
case Reference @ref:
range = @ref.Port.Span.ToRange();
break;
default:
return(Task.FromResult(new LocationOrLocationLinks()));
}
return(Task.FromResult(new LocationOrLocationLinks(new LocationOrLocationLink(new Location
{
Uri = request.TextDocument.Uri,
Range = range
}))));
}
public async override Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
{
var document = await documents.GetDocumentAsync(request.TextDocument);
if (document == null)
{
logger.LogWarning("location requested for unloaded document {DocumentUri}", request.TextDocument.Uri);
return(new LocationOrLocationLinks());
}
if (!document.SymbolTable.TryGetSymbolAt(request.Position, out var symbol))
{
logger.LogDebug("no symbol was found at {Position} in {Document}", request.Position, request.TextDocument);
return(new LocationOrLocationLinks());
}
var location = GetLspLocation(document, symbol);
if (location == null)
{
logger.LogDebug("failed to resolve the location of the symbol {SymbolName} at {Position} in {Document}",
symbol.Name, request.Position, request.TextDocument);
return(new LocationOrLocationLinks());
}
return(new[] { location });
}
ILocationContainer IWorker.Definition(string absFilename, long line, long column)
{
var param = new DefinitionParams();
return(CommonProcessingOfGoto(absFilename, line, column, param, (ITextDocumentPositionParams arg) => client_.Send.TextDocumentDefinition((DefinitionParams)arg)));
}
public async Task <LocationOrLocationLinks?> Handle(DefinitionParams request, CancellationToken cancellationToken)
#pragma warning restore CS8613 // Nullability of reference types in return type doesn't match implicitly implemented member.
{
_logger.LogInformation("Starting go-to-def endpoint request.");
if (request is null)
{
_logger.LogWarning("Request is null.");
throw new ArgumentNullException(nameof(request));
}
var documentSnapshot = await _projectSnapshotManagerDispatcher.RunOnDispatcherThreadAsync(() =>
{
var path = request.TextDocument.Uri.GetAbsoluteOrUNCPath();
_documentResolver.TryResolveDocument(path, out var documentSnapshot);
return(documentSnapshot);
}, cancellationToken).ConfigureAwait(false);
if (documentSnapshot is null)
{
_logger.LogWarning("Document snapshot is null for document.");
return(null);
}
if (!FileKinds.IsComponent(documentSnapshot.FileKind))
{
_logger.LogInformation($"FileKind '{documentSnapshot.FileKind}' is not a component type.");
return(null);
}
var codeDocument = await documentSnapshot.GetGeneratedOutputAsync().ConfigureAwait(false);
if (codeDocument.IsUnsupported())
{
_logger.LogInformation("Generated document is unsupported.");
return(null);
}
var originTagHelperBinding = await GetOriginTagHelperBindingAsync(documentSnapshot, codeDocument, request.Position, _logger).ConfigureAwait(false);
if (originTagHelperBinding is null)
{
_logger.LogInformation("Origin TagHelper binding is null.");
return(null);
}
var originTagDescriptor = originTagHelperBinding.Descriptors.FirstOrDefault(d => !d.IsAttributeDescriptor());
if (originTagDescriptor is null)
{
_logger.LogInformation("Origin TagHelper descriptor is null.");
return(null);
}
var originComponentDocumentSnapshot = await _componentSearchEngine.TryLocateComponentAsync(originTagDescriptor).ConfigureAwait(false);
if (originComponentDocumentSnapshot is null)
{
_logger.LogInformation("Origin TagHelper document snapshot is null.");
return(null);
}
_logger.LogInformation($"Definition found at file path: {originComponentDocumentSnapshot.FilePath}");
var originComponentUri = new UriBuilder
{
Path = originComponentDocumentSnapshot.FilePath,
Scheme = Uri.UriSchemeFile,
Host = string.Empty,
}.Uri;
return(new LocationOrLocationLinks(new[]
{
new LocationOrLocationLink(new Location
{
Uri = originComponentUri,
Range = new Range(new Position(0, 0), new Position(0, 0)),
}),
}));
}
public static Task <LocationOrLocationLinks> Definition(this ILanguageClientDocument mediator, DefinitionParams @params, CancellationToken cancellationToken = default)
{
return(mediator.SendRequest(@params, cancellationToken));
}
public abstract Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken);
public async Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
{
var documentPath = DocumentUri.GetFileSystemPath(request.TextDocument.Uri);
if (string.IsNullOrEmpty(documentPath))
{
return(new LocationOrLocationLinks());
}
var(rootScope, tc) = buffers.GetScope(documentPath);
if (rootScope == null)
{
return(new LocationOrLocationLinks());
}
var pos = (int)request.Position.Character;
var line = (int)request.Position.Line;
var scope = GetCurrentScope(rootScope, (int)request.Position.Character, (int)request.Position.Line, documentPath);
// System.Diagnostics.Debugger.Launch();
var node = FindNode(scope, pos, line, documentPath);
if (node == null)
{
return(new LocationOrLocationLinks());
}
switch (node)
{
case AST.VariableReference vr:
{
var ov = node.scope.GetVar(vr.variableName, node.token);
Scope.VariableDefinition vd;
if (!ov.IsOverloaded)
{
vd = ov.First;
}
else
{
vd = ov.variables[vr.overloadedIdx];
}
Token token = Token.Undefined;
if (vd.isFunctionParameter)
{
var function = node.scope.function;
var ts = function.typeString.functionTypeString;
var par = ts.parameters[vd.parameterIdx];
token = par.typeString.token;
}
else
{
token = vd.node.token;
}
var location = new Location()
{
Uri = DocumentUri.FromFileSystemPath(token.filename),
Range = new Range(
new Position(token.Line - 1, token.Pos - 1),
new Position(token.Line - 1, token.Pos - 1 + token.length)
)
};
return(new LocationOrLocationLinks(location));
}
case AST.CompoundLiteral cl:
{
var nd = GetElementType(tc.GetNodeType(node));
var tr = tc.GetTypeRoot(nd);
var token = tr.token;
if (token != Token.Undefined)
{
var location = new Location()
{
Uri = DocumentUri.FromFileSystemPath(token.filename),
Range = new Range(
new Position(token.Line - 1, token.Pos - 1),
new Position(token.Line - 1, token.Pos - 1 + token.length)
)
};
return(new LocationOrLocationLinks(location));
}
}
break;
case AST.FieldAccess fa:
{
if (fa.kind == AST.FieldAccess.AccessKind.Struct)
{
var nd = GetElementType(tc.GetNodeType(fa.left));
var tr = (AST.StructDeclaration)tc.GetTypeRoot(nd);
var field = tr.GetField(fa.fieldName);
var token = field.typeString.token;
if (token != Token.Undefined)
{
var location = new Location()
{
Uri = DocumentUri.FromFileSystemPath(token.filename),
Range = new Range(
new Position(token.Line - 1, token.Pos - 1),
new Position(token.Line - 1, token.Pos - 1 + token.length)
)
};
return(new LocationOrLocationLinks(location));
}
}
}
break;
case AST.TypeString ts:
{
var nd = GetElementType(tc.GetNodeType(ts));
var tr = tc.GetTypeRoot(nd);
if (tr != null && tr.token != Token.Undefined)
{
var token = tr.token;
var location = new Location()
{
Uri = DocumentUri.FromFileSystemPath(token.filename),
Range = new Range(
new Position(token.Line - 1, token.Pos - 1),
new Position(token.Line - 1, token.Pos - 1 + token.length)
)
};
return(new LocationOrLocationLinks(location));
}
}
break;
}
return(new LocationOrLocationLinks());
}
public async Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken)
{
if (request is null)
{
throw new ArgumentNullException(nameof(request));
}
var documentSnapshot = await Task.Factory.StartNew(() =>
{
var path = request.TextDocument.Uri.GetAbsoluteOrUNCPath();
_documentResolver.TryResolveDocument(path, out var documentSnapshot);
return(documentSnapshot);
}, cancellationToken, TaskCreationOptions.None, _foregroundDispatcher.ForegroundScheduler).ConfigureAwait(false);
if (documentSnapshot is null)
{
return(null);
}
if (!FileKinds.IsComponent(documentSnapshot.FileKind))
{
return(null);
}
var codeDocument = await documentSnapshot.GetGeneratedOutputAsync().ConfigureAwait(false);
if (codeDocument.IsUnsupported())
{
return(null);
}
var originTagHelperBinding = await GetOriginTagHelperBindingAsync(documentSnapshot, codeDocument, request.Position).ConfigureAwait(false);
if (originTagHelperBinding is null)
{
return(null);
}
var originTagDescriptor = originTagHelperBinding.Descriptors.FirstOrDefault(d => !d.IsAttributeDescriptor());
if (originTagDescriptor is null)
{
return(null);
}
var originComponentDocumentSnapshot = await _componentSearchEngine.TryLocateComponentAsync(originTagDescriptor).ConfigureAwait(false);
if (originComponentDocumentSnapshot is null)
{
return(null);
}
var originComponentUri = new UriBuilder
{
Path = originComponentDocumentSnapshot.FilePath,
Scheme = Uri.UriSchemeFile,
Host = string.Empty,
}.Uri;
return(new LocationOrLocationLinks(new[]
{
new LocationOrLocationLink(new Location
{
Uri = originComponentUri,
Range = new Range(new Position(0, 0), new Position(0, 0)),
}),
}));
}
public static Task <LocationOrLocations> Definition(this ILanguageClientDocument mediator, DefinitionParams @params)
{
return(mediator.SendRequest <DefinitionParams, LocationOrLocations>(DocumentNames.Definition, @params));
}
public override Task <LocationOrLocationLinks> Handle(DefinitionParams request, CancellationToken cancellationToken) => _handler.Invoke(request, cancellationToken);
