public async Task Handle_ResolvesLanguageRequest_CSharp()
{
// Arrange
var documentPath = "C:/path/to/document.cshtml";
var codeDocument = CreateCodeDocumentWithCSharpProjection(
"@",
"/* CSharp */",
new[] { new SourceMapping(new SourceSpan(0, 1), new SourceSpan(0, 12)) });
var documentResolver = CreateDocumentResolver(documentPath, codeDocument);
var languageEndpoint = new RazorLanguageEndpoint(Dispatcher, documentResolver, DocumentVersionCache, LoggerFactory);
var request = new RazorLanguageQueryParams()
{
Uri = new Uri(documentPath),
Position = new Position(0, 1),
};
// Act
var response = await Task.Run(() => languageEndpoint.Handle(request, default));
// Assert
Assert.Equal(RazorLanguageKind.CSharp, response.Kind);
Assert.Equal(0, response.Position.Line);
Assert.Equal(1, response.Position.Character);
Assert.Equal(1337, response.HostDocumentVersion);
}
public async Task <RazorLanguageQueryResponse> Handle(RazorLanguageQueryParams request, CancellationToken cancellationToken)
{
long documentVersion = -1;
DocumentSnapshot documentSnapshot = null;
await Task.Factory.StartNew(() =>
{
_documentResolver.TryResolveDocument(request.Uri.AbsolutePath, out documentSnapshot);
if (!_documentVersionCache.TryGetDocumentVersion(documentSnapshot, out documentVersion))
{
Debug.Fail("Document should always be available here.");
}
return(documentSnapshot);
}, CancellationToken.None, TaskCreationOptions.None, _foregroundDispatcher.ForegroundScheduler);
var codeDocument = await documentSnapshot.GetGeneratedOutputAsync();
var sourceText = await documentSnapshot.GetTextAsync();
var linePosition = new LinePosition((int)request.Position.Line, (int)request.Position.Character);
var hostDocumentIndex = sourceText.Lines.GetPosition(linePosition);
var responsePosition = request.Position;
if (codeDocument.IsUnsupported())
{
// All language queries on unsupported documents return Html. This is equivalent to what pre-VSCode Razor was capable of.
return(new RazorLanguageQueryResponse()
{
Kind = RazorLanguageKind.Html,
Position = responsePosition,
PositionIndex = hostDocumentIndex,
HostDocumentVersion = documentVersion,
});
}
var syntaxTree = codeDocument.GetSyntaxTree();
var classifiedSpans = syntaxTree.GetClassifiedSpans();
var tagHelperSpans = syntaxTree.GetTagHelperSpans();
var languageKind = GetLanguageKind(classifiedSpans, tagHelperSpans, hostDocumentIndex);
var responsePositionIndex = hostDocumentIndex;
if (languageKind == RazorLanguageKind.CSharp)
{
if (TryGetCSharpProjectedPosition(codeDocument, hostDocumentIndex, out var projectedPosition, out var projectedIndex))
{
// For C# locations, we attempt to return the corresponding position
// within the projected document
responsePosition = projectedPosition;
responsePositionIndex = projectedIndex;
}
else
{
// It no longer makes sense to think of this location as C#, since it doesn't
// correspond to any position in the projected document. This should not happen
// since there should be source mappings for all the C# spans.
languageKind = RazorLanguageKind.Razor;
responsePositionIndex = hostDocumentIndex;
}
}
public async Task <RazorLanguageQueryResponse> Handle(RazorLanguageQueryParams request, CancellationToken cancellationToken)
{
var documentUri = request.Uri.GetAbsoluteOrUNCPath();
var info = await TryGetDocumentSnapshotAndVersionAsync(documentUri, cancellationToken).ConfigureAwait(false);
if (info is null)
{
_logger.LogError("Failed to get the document snapshot '{documentUri}', could not map to document ranges.", documentUri);
throw new InvalidOperationException($"Unable to resolve document {request.Uri.GetAbsoluteOrUNCPath()}.");
}
var(documentSnapshot, documentVersion) = info;
var codeDocument = await documentSnapshot.GetGeneratedOutputAsync();
var sourceText = await documentSnapshot.GetTextAsync();
var linePosition = new LinePosition(request.Position.Line, request.Position.Character);
var hostDocumentIndex = sourceText.Lines.GetPosition(linePosition);
var responsePosition = request.Position;
if (codeDocument.IsUnsupported())
{
// All language queries on unsupported documents return Html. This is equivalent to what pre-VSCode Razor was capable of.
return(new RazorLanguageQueryResponse()
{
Kind = RazorLanguageKind.Html,
Position = responsePosition,
PositionIndex = hostDocumentIndex,
HostDocumentVersion = documentVersion,
});
}
var responsePositionIndex = hostDocumentIndex;
var languageKind = _documentMappingService.GetLanguageKind(codeDocument, hostDocumentIndex);
if (languageKind == RazorLanguageKind.CSharp)
{
if (_documentMappingService.TryMapToProjectedDocumentPosition(codeDocument, hostDocumentIndex, out var projectedPosition, out var projectedIndex))
{
// For C# locations, we attempt to return the corresponding position
// within the projected document
responsePosition = projectedPosition;
responsePositionIndex = projectedIndex;
}
else
{
// It no longer makes sense to think of this location as C#, since it doesn't
// correspond to any position in the projected document. This should not happen
// since there should be source mappings for all the C# spans.
languageKind = RazorLanguageKind.Razor;
responsePositionIndex = hostDocumentIndex;
}
}
public async Task Handle_ResolvesLanguageRequest_Html()
{
// Arrange
var documentPath = "C:/path/to/document.cshtml";
var codeDocument = CreateCodeDocument("<s");
var documentResolver = CreateDocumentResolver(documentPath, codeDocument);
var languageEndpoint = new RazorLanguageEndpoint(Dispatcher, documentResolver, DocumentVersionCache, LoggerFactory);
var request = new RazorLanguageQueryParams()
{
Uri = new Uri(documentPath),
Position = new Position(0, 2),
};
// Act
var response = await Task.Run(() => languageEndpoint.Handle(request, default));
// Assert
Assert.Equal(RazorLanguageKind.Html, response.Kind);
Assert.Equal(request.Position, response.Position);
Assert.Equal(1337, response.HostDocumentVersion);
}
public async Task Handle_ResolvesLanguageRequest_Razor()
{
// Arrange
var documentPath = "C:/path/to/document.cshtml";
var codeDocument = CreateCodeDocument("@{}");
var documentResolver = CreateDocumentResolver(documentPath, codeDocument);
var languageEndpoint = new RazorLanguageEndpoint(Dispatcher, documentResolver, DocumentVersionCache, MappingService, Mock.Of <RazorFormattingService>(MockBehavior.Strict), LoggerFactory);
var request = new RazorLanguageQueryParams()
{
Uri = new Uri(documentPath),
Position = new Position(0, 1),
};
// Act
var response = await Task.Run(() => languageEndpoint.Handle(request, default));
// Assert
Assert.Equal(RazorLanguageKind.Razor, response.Kind);
Assert.Equal(request.Position, response.Position);
Assert.Equal(1337, response.HostDocumentVersion);
}
public async Task <RazorLanguageQueryResponse> Handle(RazorLanguageQueryParams request, CancellationToken cancellationToken)
{
int?documentVersion = null;
DocumentSnapshot documentSnapshot = null;
await _projectSnapshotManagerDispatcher.RunOnDispatcherThreadAsync(() =>
{
_documentResolver.TryResolveDocument(request.Uri.GetAbsoluteOrUNCPath(), out documentSnapshot);
Debug.Assert(documentSnapshot != null, "Failed to get the document snapshot, could not map to document ranges.");
if (!_documentVersionCache.TryGetDocumentVersion(documentSnapshot, out documentVersion))
{
// This typically happens for closed documents.
documentVersion = null;
}
return(documentSnapshot);
}, cancellationToken).ConfigureAwait(false);
var codeDocument = await documentSnapshot.GetGeneratedOutputAsync();
var sourceText = await documentSnapshot.GetTextAsync();
var linePosition = new LinePosition(request.Position.Line, request.Position.Character);
var hostDocumentIndex = sourceText.Lines.GetPosition(linePosition);
var responsePosition = request.Position;
if (codeDocument.IsUnsupported())
{
// All language queries on unsupported documents return Html. This is equivalent to what pre-VSCode Razor was capable of.
return(new RazorLanguageQueryResponse()
{
Kind = RazorLanguageKind.Html,
Position = responsePosition,
PositionIndex = hostDocumentIndex,
HostDocumentVersion = documentVersion,
});
}
var responsePositionIndex = hostDocumentIndex;
var languageKind = _documentMappingService.GetLanguageKind(codeDocument, hostDocumentIndex);
if (languageKind == RazorLanguageKind.CSharp)
{
if (_documentMappingService.TryMapToProjectedDocumentPosition(codeDocument, hostDocumentIndex, out var projectedPosition, out var projectedIndex))
{
// For C# locations, we attempt to return the corresponding position
// within the projected document
responsePosition = projectedPosition;
responsePositionIndex = projectedIndex;
}
else
{
// It no longer makes sense to think of this location as C#, since it doesn't
// correspond to any position in the projected document. This should not happen
// since there should be source mappings for all the C# spans.
languageKind = RazorLanguageKind.Razor;
responsePositionIndex = hostDocumentIndex;
}
}
