public override async Task <LSP.VSReferenceItem[]> HandleRequestAsync(
ReferenceParams referenceParams,
ClientCapabilities clientCapabilities,
string?clientName,
CancellationToken cancellationToken)
{
Debug.Assert(clientCapabilities.HasVisualStudioLspCapability());
var document = SolutionProvider.GetDocument(referenceParams.TextDocument, clientName);
if (document == null)
{
return(Array.Empty <LSP.VSReferenceItem>());
}
var findUsagesService = document.GetRequiredLanguageService <IFindUsagesLSPService>();
var position = await document.GetPositionFromLinePositionAsync(
ProtocolConversions.PositionToLinePosition(referenceParams.Position), cancellationToken).ConfigureAwait(false);
var context = new FindUsagesLSPContext(
referenceParams.PartialResultToken, document, position, _metadataAsSourceFileService, cancellationToken);
// Finds the references for the symbol at the specific position in the document, reporting them via streaming to the LSP client.
await findUsagesService.FindReferencesAsync(document, position, context).ConfigureAwait(false);
await context.OnCompletedAsync().ConfigureAwait(false);
// The results have already been reported to the client, so we don't need to return anything here.
return(Array.Empty <LSP.VSReferenceItem>());
}
public Task <TResponseType> ExecuteAsync <TRequestType, TResponseType>(
bool mutatesSolutionState,
IRequestHandler <TRequestType, TResponseType> handler,
TRequestType request,
ClientCapabilities clientCapabilities,
string?clientName,
CancellationToken requestCancellationToken) where TRequestType : class
{
// Create a task completion source that will represent the processing of this request to the caller
var completion = new TaskCompletionSource <TResponseType>();
// Note: If the queue is not accepting any more items then TryEnqueue below will fail.
var textDocument = handler.GetTextDocumentIdentifier(request);
var item = new QueueItem(mutatesSolutionState, clientCapabilities, clientName, textDocument,
callbackAsync: async(context, cancellationToken) =>
{
// Check if cancellation was requested while this was waiting in the queue
if (cancellationToken.IsCancellationRequested)
{
completion.SetCanceled();
// Tell the queue to ignore any mutations from this request, not that we've given it a chance
// to make any
return(false);
}
try
{
var result = await handler.HandleRequestAsync(request, context, cancellationToken).ConfigureAwait(false);
completion.SetResult(result);
// Tell the queue that this was successful so that mutations (if any) can be applied
return(true);
}
catch (OperationCanceledException ex)
{
completion.TrySetCanceled(ex.CancellationToken);
}
catch (Exception exception)
{
// Pass the exception to the task completion source, so the caller of the ExecuteAsync method can observe but
// don't let it escape from this callback, so it doesn't affect the queue processing.
completion.SetException(exception);
}
// Tell the queue to ignore any mutations from this request
return(false);
}, requestCancellationToken);
var didEnqueue = _queue.TryEnqueue(item);
// If the queue has been shut down the enqueue will fail, so we just fault the task immediately.
// The queue itself is threadsafe (_queue.TryEnqueue and _queue.Complete use the same lock).
if (!didEnqueue)
{
completion.SetException(new InvalidOperationException("Server was requested to shut down."));
}
return(completion.Task);
}
public override ServerCapabilities GetCapabilities(ClientCapabilities clientCapabilities)
{
var serverCapabilities = new VSServerCapabilities();
// If the LSP editor feature flag is enabled advertise support for LSP features here so they are available locally and remote.
var isLspEditorEnabled = Workspace.Services.GetRequiredService <IExperimentationService>().IsExperimentEnabled(VisualStudioWorkspaceContextService.LspEditorFeatureFlagName);
if (isLspEditorEnabled)
{
serverCapabilities = (VSServerCapabilities)_defaultCapabilitiesProvider.GetCapabilities(clientCapabilities);
}
else
{
// Even if the flag is off, we want to include text sync capabilities.
serverCapabilities.TextDocumentSync = new TextDocumentSyncOptions
{
Change = TextDocumentSyncKind.Incremental,
OpenClose = true,
};
}
serverCapabilities.SupportsDiagnosticRequests = Workspace.IsPullDiagnostics(InternalDiagnosticsOptions.NormalDiagnosticMode);
// This capability is always enabled as we provide cntrl+Q VS search only via LSP in ever scenario.
serverCapabilities.WorkspaceSymbolProvider = true;
// This capability prevents NavigateTo (cntrl+,) from using LSP symbol search when the server also supports WorkspaceSymbolProvider.
// Since WorkspaceSymbolProvider=true always to allow cntrl+Q VS search to function, we set DisableGoToWorkspaceSymbols=true
// when not running the experimental LSP editor. This ensures NavigateTo uses the existing editor APIs.
// However, when the experimental LSP editor is enabled we want LSP to power NavigateTo, so we set DisableGoToWorkspaceSymbols=false.
serverCapabilities.DisableGoToWorkspaceSymbols = !isLspEditorEnabled;
return(serverCapabilities);
}
void connection_Closed(object sender, EventArgs e)
{
if (!GetActiveSockets().Any())
{
try
{
_sessionManager.ReportSessionEnded(Session.Id);
}
catch (Exception ex)
{
_logger.ErrorException("Error reporting session ended.", ex);
}
}
else
{
var capabilities = new ClientCapabilities
{
PlayableMediaTypes = Session.PlayableMediaTypes,
SupportedCommands = Session.SupportedCommands,
SupportsMediaControl = SupportsMediaControl
};
_sessionManager.ReportCapabilities(Session.Id, capabilities);
}
}
/// <summary>
/// Closes the connection.
/// </summary>
/// <returns></returns>
public async Task CloseAsync()
{
if (this.isDisposed || this.State == XmppTransportState.Closed || this.State == XmppTransportState.Closing)
{
return;
}
try
{
await SoftCloseAsync().ConfigureAwait(false);
}
catch
{
}
finally
{
this.DisposeSubscriptions();
this.transport = null;
this.saslMechanism = null;
this.connectionString = null;
this.userAddress = null;
this.people = null;
this.activity = null;
this.capabilities = null;
this.personalEventing = null;
this.presence = null;
this.serverCapabilities = null;
this.serverFeatures = ServerFeatures.None;
this.ReleaseSubjects();
}
}
// Internal for testing
internal Task <ResponseType?> ExecuteRequestAsync <RequestType, ResponseType>(
string methodName,
RequestType request,
ClientCapabilities clientCapabilities,
CancellationToken cancellationToken) where RequestType : class
{
if (string.IsNullOrEmpty(methodName))
{
throw new ArgumentException("Invalid method name", nameof(methodName));
}
if (request is null)
{
throw new ArgumentNullException(nameof(request));
}
if (!_requestHandlers.TryGetValue(methodName, out var lazyHandler))
{
throw new InvalidOperationException($"Request handler not found for method {methodName}");
}
var handler = (IRequestHandler <RequestType, ResponseType>)lazyHandler.Value;
return(handler.HandleRequestAsync(request, clientCapabilities, cancellationToken));
}
protected override void ConfigureClientCapabilities(ClientCapabilities clientCapabilities)
{
clientCapabilities.TextDocument.FoldingRange =
new Supports <FoldingRangeCapability>(true, new FoldingRangeCapability {
LineFoldingOnly = false
});
}
public async Task <TResult> HandleRequestAsync(TParams requestParams, ClientCapabilities clientCapabilities, CancellationToken cancellationToken)
{
// Temporary till IProgress serialization is fixed
var token = Guid.NewGuid().ToString(); // request.PartialResultToken.Id
return(await HandleRequestAsync(requestParams, clientCapabilities, token, cancellationToken).ConfigureAwait(false));
}
public void GH162_TextDocumentSync_Should_Work_With_WillSave_Or_WillSaveWaitUntil()
{
var textDocumentSyncHandler =
TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"), "csharp");
var willSaveTextDocumentHandler = Substitute.For <IWillSaveTextDocumentHandler>();
var willSaveWaitUntilTextDocumentHandler = Substitute.For <IWillSaveWaitUntilTextDocumentHandler>();
var didSaveTextDocumentHandler = Substitute.For <IDidSaveTextDocumentHandler>();
var collection =
new SharedHandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, new TextDocumentIdentifiers())
{
textDocumentSyncHandler, willSaveTextDocumentHandler, willSaveWaitUntilTextDocumentHandler,
didSaveTextDocumentHandler
};
var provider = new ClientCapabilityProvider(collection, true);
var capabilities = new ClientCapabilities()
{
TextDocument = new TextDocumentClientCapabilities()
{
Synchronization = new SynchronizationCapability()
{
DidSave = true,
DynamicRegistration = false,
WillSave = true,
WillSaveWaitUntil = true
},
}
};
provider.HasStaticHandler(capabilities.TextDocument.Synchronization).Should().BeTrue();
}
public void SaveCapabilities(string deviceId, ClientCapabilities capabilities)
{
using (WriteLock.Write())
{
using (var connection = CreateConnection())
{
connection.RunInTransaction(db =>
{
using (var statement = db.PrepareStatement("update devices set Capabilities=@Capabilities where Id=@Id"))
{
statement.TryBind("@Id", deviceId);
if (capabilities == null)
{
statement.TryBindNull("@Capabilities");
}
else
{
statement.TryBind("@Capabilities", _json.SerializeToString(capabilities));
}
statement.MoveNext();
}
}, TransactionMode);
}
}
}
public Initialize_Params(int processId, string rootUri, ClientCapabilities capabilities, string initializationOptions)
{
this.processId = processId;
this.rootUri = rootUri;
this.capabilities = capabilities;
this.initializationOptions = initializationOptions;
}
public async Task <Hover> HandleRequestAsync(Solution solution, TextDocumentPositionParams request,
ClientCapabilities clientCapabilities, CancellationToken cancellationToken, bool keepThreadContext = false)
{
var document = solution.GetDocumentFromURI(request.TextDocument.Uri);
if (document == null)
{
return(null);
}
var position = await document.GetPositionFromLinePositionAsync(ProtocolConversions.PositionToLinePosition(request.Position), cancellationToken).ConfigureAwait(keepThreadContext);
var quickInfoService = document.Project.LanguageServices.GetService <QuickInfoService>();
var info = await quickInfoService.GetQuickInfoAsync(document, position, cancellationToken).ConfigureAwait(keepThreadContext);
if (info == null)
{
return(null);
}
var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(keepThreadContext);
return(new Hover
{
Range = ProtocolConversions.TextSpanToRange(info.Span, text),
Contents = new MarkupContent
{
Kind = MarkupKind.Markdown,
Value = GetMarkdownString(info)
}
});
/// <summary>
/// Disposes the specified disposing.
/// </summary>
/// <param name="disposing">if set to <c>true</c> [disposing].</param>
private void Dispose(bool disposing)
{
if (!this.isDisposed)
{
if (disposing)
{
// Release managed resources here
this.CloseAsync().GetAwaiter().GetResult();
}
// Call the appropriate methods to clean up
// unmanaged resources here.
// If disposing is false,
// only the following code is executed.
this.connectionString = null;
this.userAddress = null;
this.saslMechanism = null;
this.people = null;
this.activity = null;
this.capabilities = null;
this.personalEventing = null;
this.presence = null;
this.serverCapabilities = null;
this.serverFeatures = ServerFeatures.None;
this.state = XmppTransportState.Closed;
this.CloseTransport();
this.DisposeSubscriptions();
this.ReleaseSubjects();
}
this.isDisposed = true;
}
public static (IQueueItem, Task <TResponseType?>) Create(
bool mutatesSolutionState,
bool requiresLSPSolution,
ClientCapabilities clientCapabilities,
string?clientName,
string methodName,
TextDocumentIdentifier?textDocument,
TRequestType request,
IRequestHandler <TRequestType, TResponseType> handler,
Guid activityId,
ILspLogger logger,
RequestTelemetryLogger telemetryLogger,
CancellationToken cancellationToken)
{
var queueItem = new QueueItem <TRequestType, TResponseType>(
mutatesSolutionState,
requiresLSPSolution,
clientCapabilities,
clientName,
methodName,
textDocument,
request,
handler,
activityId,
logger,
telemetryLogger,
cancellationToken);
return(queueItem, queueItem._completionSource.Task);
}
public override ServerCapabilities GetCapabilities(ClientCapabilities clientCapabilities)
{
var experimentationService = Workspace.Services.GetRequiredService <IExperimentationService>();
var isLspExperimentEnabled = experimentationService.IsExperimentEnabled(StringConstants.EnableLspIntelliSense);
return(isLspExperimentEnabled ? XamlCapabilities.Current : XamlCapabilities.None);
}
public QueueItem(
bool mutatesSolutionState,
bool requiresLSPSolution,
ClientCapabilities clientCapabilities,
string?clientName,
string methodName,
TextDocumentIdentifier?textDocument,
TRequestType request,
IRequestHandler <TRequestType, TResponseType> handler,
Guid activityId,
ILspLogger logger,
RequestTelemetryLogger telemetryLogger,
CancellationToken cancellationToken)
{
_completionSource = new TaskCompletionSource <TResponseType?>();
// Set the tcs state to cancelled if the token gets cancelled outside of our callback (for example the server shutting down).
cancellationToken.Register(() => _completionSource.TrySetCanceled(cancellationToken));
Metrics = new RequestMetrics(methodName, telemetryLogger);
_handler = handler;
_logger = logger;
_request = request;
ActivityId = activityId;
MutatesSolutionState = mutatesSolutionState;
RequiresLSPSolution = requiresLSPSolution;
ClientCapabilities = clientCapabilities;
ClientName = clientName;
MethodName = methodName;
TextDocument = textDocument;
}
public ConnectionManager(ILogger logger,
ICredentialProvider credentialProvider,
INetworkConnection networkConnectivity,
IServerLocator serverDiscovery,
string applicationName,
string applicationVersion,
IDevice device,
ClientCapabilities clientCapabilities,
ICryptographyProvider cryptographyProvider,
Func <IClientWebSocket> webSocketFactory = null,
ILocalAssetManager localAssetManager = null)
{
_credentialProvider = credentialProvider;
_networkConnectivity = networkConnectivity;
_logger = logger;
_serverDiscovery = serverDiscovery;
_httpClient = AsyncHttpClientFactory.Create(logger);
ClientCapabilities = clientCapabilities;
_webSocketFactory = webSocketFactory;
_cryptographyProvider = cryptographyProvider;
_localAssetManager = localAssetManager;
Device = device;
ApplicationVersion = applicationVersion;
ApplicationName = applicationName;
ApiClients = new Dictionary <string, IApiClient>(StringComparer.OrdinalIgnoreCase);
SaveLocalCredentials = true;
Device.ResumeFromSleep += Device_ResumeFromSleep;
var jsonSerializer = new NewtonsoftJsonSerializer();
_connectService = new ConnectService(jsonSerializer, _logger, _httpClient, _cryptographyProvider, applicationName, applicationVersion);
}
public async Task <DocumentHighlight[]> HandleRequestAsync(Solution solution, TextDocumentPositionParams request,
ClientCapabilities clientCapabilities, CancellationToken cancellationToken)
{
var document = solution.GetDocumentFromURI(request.TextDocument.Uri);
if (document == null)
{
return(Array.Empty <DocumentHighlight>());
}
var documentHighlightService = document.Project.LanguageServices.GetService <IDocumentHighlightsService>();
var position = await document.GetPositionFromLinePositionAsync(ProtocolConversions.PositionToLinePosition(request.Position), cancellationToken).ConfigureAwait(false);
var highlights = await documentHighlightService.GetDocumentHighlightsAsync(
document,
position,
ImmutableHashSet.Create(document),
cancellationToken).ConfigureAwait(false);
if (!highlights.IsDefaultOrEmpty)
{
// LSP requests are only for a single document. So just get the highlights for the requested document.
var highlightsForDocument = highlights.FirstOrDefault(h => h.Document.Id == document.Id);
var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
return(highlightsForDocument.HighlightSpans.Select(h => new DocumentHighlight
{
Range = ProtocolConversions.TextSpanToRange(h.TextSpan, text),
Kind = ProtocolConversions.HighlightSpanKindToDocumentHighlightKind(h.Kind),
}).ToArray());
}
return(Array.Empty <DocumentHighlight>());
}
public void Should_Handle_Mixed_Capabilities()
{
var textDocumentSyncHandler =
TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"), "csharp");
var codeActionHandler = Substitute.For <ICodeActionHandler>();
var definitionHandler = Substitute.For <IDefinitionHandler>();
var typeDefinitionHandler = Substitute.For <ITypeDefinitionHandler>();
var collection =
new SharedHandlerCollection(SupportedCapabilitiesFixture.AlwaysTrue, new TextDocumentIdentifiers())
{
textDocumentSyncHandler, codeActionHandler, definitionHandler, typeDefinitionHandler
};
var provider = new ClientCapabilityProvider(collection, true);
var capabilities = new ClientCapabilities()
{
TextDocument = new TextDocumentClientCapabilities()
{
CodeAction = new Supports <CodeActionCapability>(true, new CodeActionCapability()
{
DynamicRegistration = false,
}),
TypeDefinition = new Supports <TypeDefinitionCapability>(true, new TypeDefinitionCapability()
{
DynamicRegistration = true,
})
}
};
provider.GetStaticOptions(capabilities.TextDocument.CodeAction)
.Get <ICodeActionOptions, CodeActionOptions>(CodeActionOptions.Of).Should().NotBeNull();
provider.HasStaticHandler(capabilities.TextDocument.Definition).Should().BeTrue();
provider.HasStaticHandler(capabilities.TextDocument.TypeDefinition).Should().BeFalse();
}
public async Task <FoldingRange[]> HandleRequestAsync(Solution solution, FoldingRangeParams request,
ClientCapabilities clientCapabilities, CancellationToken cancellationToken)
{
var foldingRanges = ArrayBuilder <FoldingRange> .GetInstance();
var document = solution.GetDocumentFromURI(request.TextDocument.Uri);
if (document == null)
{
return(foldingRanges.ToArrayAndFree());
}
var blockStructureService = document.Project.LanguageServices.GetService <BlockStructureService>();
if (blockStructureService == null)
{
return(foldingRanges.ToArrayAndFree());
}
var blockStructure = await blockStructureService.GetBlockStructureAsync(document, cancellationToken).ConfigureAwait(false);
if (blockStructure == null)
{
return(foldingRanges.ToArrayAndFree());
}
var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
foreach (var span in blockStructure.Spans)
{
if (!span.IsCollapsible)
{
continue;
}
var linePositionSpan = text.Lines.GetLinePositionSpan(span.TextSpan);
// TODO - Figure out which blocks should be returned as a folding range (and what kind).
// https://github.com/dotnet/roslyn/projects/45#card-20049168
var foldingRangeKind = span.Type switch
{
BlockTypes.Comment => (FoldingRangeKind?)FoldingRangeKind.Comment,
BlockTypes.Imports => FoldingRangeKind.Imports,
BlockTypes.PreprocessorRegion => FoldingRangeKind.Region,
_ => null,
};
foldingRanges.Add(new FoldingRange()
{
StartLine = linePositionSpan.Start.Line,
StartCharacter = linePositionSpan.Start.Character,
EndLine = linePositionSpan.End.Line,
EndCharacter = linePositionSpan.End.Character,
Kind = foldingRangeKind
});
}
return(foldingRanges.ToArrayAndFree());
}
/// <summary>
/// Best attempt to determine if the hosting client supports a specific protocol version
///
/// ClientCapabilities are new as of 3.0, but the field existsed before so it's possible
/// it could be passed as an empty object
/// </summary>
/// <param name="capabilities">The capabilities.</param>
/// <returns>ClientVersion.</returns>
public static ClientVersion GetClientVersion(this ClientCapabilities capabilities)
{
if (capabilities == null || (capabilities.TextDocument == null && capabilities.Workspace == null))
{
return(ClientVersion.Lsp2);
}
return(ClientVersion.Lsp3);
}
public RequestContext(Solution solution, ClientCapabilities clientCapabilities, string?clientName, Document?document, IDocumentChangeTracker documentChangeTracker)
{
Document = document;
Solution = solution;
ClientCapabilities = clientCapabilities;
ClientName = clientName;
_documentChangeTracker = documentChangeTracker;
}
public RequestContext(Solution solution, ClientCapabilities clientCapabilities, string?clientName, Document?document, Action <Solution>?solutionUpdater)
{
Document = document;
Solution = solution;
_solutionUpdater = solutionUpdater;
ClientCapabilities = clientCapabilities;
ClientName = clientName;
}
public static RequestContext Create(
bool requiresLSPSolution,
TextDocumentIdentifier?textDocument,
string?clientName,
ILspLogger _logger,
ClientCapabilities clientCapabilities,
ILspWorkspaceRegistrationService lspWorkspaceRegistrationService,
Dictionary <Workspace, (Solution workspaceSolution, Solution lspSolution)>?solutionCache,
public ServerSync(IConnectionManager connectionManager, ILogger logger, ILocalAssetManager localAssetManager, IFileTransferManager fileTransferManager, ClientCapabilities clientCapabilities)
{
_connectionManager = connectionManager;
_fileTransferManager = fileTransferManager;
_clientCapabilities = clientCapabilities;
_logger = logger;
_localAssetManager = localAssetManager;
}
private void RegisterCapabilities(ClientCapabilities capabilities)
{
capabilities.Window ??= new WindowClientCapabilities();
capabilities.Window.WorkDoneProgress = _collection.ContainsHandler(typeof(IProgressHandler));
capabilities.Workspace ??= new WorkspaceClientCapabilities();
capabilities.Workspace.Configuration = _collection.ContainsHandler(typeof(IConfigurationHandler));
capabilities.Workspace.Symbol = UseOrTryAndFindCapability(capabilities.Workspace.Symbol);
capabilities.Workspace.ExecuteCommand = UseOrTryAndFindCapability(capabilities.Workspace.ExecuteCommand);
capabilities.Workspace.ApplyEdit = _collection.ContainsHandler(typeof(IApplyWorkspaceEditHandler));
capabilities.Workspace.WorkspaceEdit = UseOrTryAndFindCapability(capabilities.Workspace.WorkspaceEdit);
capabilities.Workspace.WorkspaceFolders = _collection.ContainsHandler(typeof(IWorkspaceFoldersHandler));
capabilities.Workspace.DidChangeConfiguration =
UseOrTryAndFindCapability(capabilities.Workspace.DidChangeConfiguration);
capabilities.Workspace.DidChangeWatchedFiles =
UseOrTryAndFindCapability(capabilities.Workspace.DidChangeWatchedFiles);
capabilities.TextDocument ??= new TextDocumentClientCapabilities();
capabilities.TextDocument.Synchronization =
UseOrTryAndFindCapability(capabilities.TextDocument.Synchronization);
capabilities.TextDocument.Completion = UseOrTryAndFindCapability(capabilities.TextDocument.Completion);
capabilities.TextDocument.Hover = UseOrTryAndFindCapability(capabilities.TextDocument.Hover);
capabilities.TextDocument.SignatureHelp =
UseOrTryAndFindCapability(capabilities.TextDocument.SignatureHelp);
capabilities.TextDocument.References = UseOrTryAndFindCapability(capabilities.TextDocument.References);
capabilities.TextDocument.DocumentHighlight =
UseOrTryAndFindCapability(capabilities.TextDocument.DocumentHighlight);
capabilities.TextDocument.DocumentSymbol =
UseOrTryAndFindCapability(capabilities.TextDocument.DocumentSymbol);
capabilities.TextDocument.Formatting = UseOrTryAndFindCapability(capabilities.TextDocument.Formatting);
capabilities.TextDocument.RangeFormatting =
UseOrTryAndFindCapability(capabilities.TextDocument.RangeFormatting);
capabilities.TextDocument.OnTypeFormatting =
UseOrTryAndFindCapability(capabilities.TextDocument.OnTypeFormatting);
capabilities.TextDocument.Definition = UseOrTryAndFindCapability(capabilities.TextDocument.Definition);
capabilities.TextDocument.Declaration = UseOrTryAndFindCapability(capabilities.TextDocument.Declaration);
capabilities.TextDocument.CodeAction = UseOrTryAndFindCapability(capabilities.TextDocument.CodeAction);
capabilities.TextDocument.CodeLens = UseOrTryAndFindCapability(capabilities.TextDocument.CodeLens);
capabilities.TextDocument.DocumentLink = UseOrTryAndFindCapability(capabilities.TextDocument.DocumentLink);
capabilities.TextDocument.Rename = UseOrTryAndFindCapability(capabilities.TextDocument.Rename);
capabilities.TextDocument.TypeDefinition =
UseOrTryAndFindCapability(capabilities.TextDocument.TypeDefinition);
capabilities.TextDocument.Implementation =
UseOrTryAndFindCapability(capabilities.TextDocument.Implementation);
capabilities.TextDocument.ColorProvider =
UseOrTryAndFindCapability(capabilities.TextDocument.ColorProvider);
capabilities.TextDocument.FoldingRange = UseOrTryAndFindCapability(capabilities.TextDocument.FoldingRange);
capabilities.TextDocument.SelectionRange =
UseOrTryAndFindCapability(capabilities.TextDocument.SelectionRange);
capabilities.TextDocument.PublishDiagnostics =
UseOrTryAndFindCapability(capabilities.TextDocument.PublishDiagnostics);
#pragma warning disable 618
capabilities.TextDocument.CallHierarchy =
UseOrTryAndFindCapability(capabilities.TextDocument.CallHierarchy);
capabilities.TextDocument.SemanticTokens =
UseOrTryAndFindCapability(capabilities.TextDocument.SemanticTokens);
#pragma warning restore 618
}
public LinkedEditingRangeRegistrationOptions GetRegistrationOptions(
LinkedEditingRangeClientCapabilities capability,
ClientCapabilities clientCapabilities)
{
return(new LinkedEditingRangeRegistrationOptions
{
DocumentSelector = RazorDefaults.Selector
});
}
public QueueItem(bool mutatesSolutionState, ClientCapabilities clientCapabilities, string?clientName, TextDocumentIdentifier?textDocument, Func <RequestContext, CancellationToken, Task> callbackAsync, CancellationToken cancellationToken)
{
MutatesSolutionState = mutatesSolutionState;
ClientCapabilities = clientCapabilities;
ClientName = clientName;
TextDocument = textDocument;
CallbackAsync = callbackAsync;
CancellationToken = cancellationToken;
}
public static bool HasCompletionListCommitCharactersCapability(this ClientCapabilities clientCapabilities)
{
if (!TryGetVSCompletionListSetting(clientCapabilities, out var completionListSetting))
{
return(false);
}
return(completionListSetting.CommitCharacters);
}
public static bool HasVisualStudioLspCapability(this ClientCapabilities clientCapabilities)
{
if (clientCapabilities is VSClientCapabilities vsClientCapabilities)
{
return(vsClientCapabilities.SupportsVisualStudioExtensions);
}
return(false);
}
public void ShouldUseFormDataStrategyToCreateFormData()
{
var dummyEndpoint = new MockEndpoint(new HttpResponseMessage());
var client = new HttpClient {Channel = dummyEndpoint};
var clientCapabilities = new ClientCapabilities(client);
var mockFormDataStrategy = MockRepository.GenerateMock<IFormDataStrategy>();
mockFormDataStrategy.Expect(s => s.CreateFormData(PreviousResponse, StateVariables, clientCapabilities)).Return(new StringContent(string.Empty));
var dummyFormStrategy = MockRepository.GenerateStub<IForm>();
dummyFormStrategy.Expect(f => f.GetFormInfo(PreviousResponse)).Return(DummyFormInfo);
dummyFormStrategy.Expect(f => f.GetFormDataStrategy(PreviousResponse)).Return(mockFormDataStrategy);
var submitForm = new SubmitForm(dummyFormStrategy);
submitForm.Execute(PreviousResponse, StateVariables, clientCapabilities);
mockFormDataStrategy.VerifyAllExpectations();
}
/// <summary>
/// Set the status of the contact list owner (the client).
/// </summary>
/// <remarks>You can only set the status _after_ SignedIn event. Otherwise you won't receive online notifications from other clients or the connection is closed by the server.</remarks>
internal void SetPresenceStatus(
PresenceStatus newStatus,
ClientCapabilities newLocalIMCaps, ClientCapabilitiesEx newLocalIMCapsex,
ClientCapabilities newLocalPECaps, ClientCapabilitiesEx newLocalPECapsex,
string newEPName,
PersonalMessage newPSM,
bool forcePEservice)
{
if (IsSignedIn == false)
throw new MSNPSharpException("Can't set status. You must wait for the SignedIn event before you can set an initial status.");
if (newStatus == PresenceStatus.Offline)
{
SignoutFrom(MachineGuid);
return;
}
bool setAll = (Owner.Status == PresenceStatus.Offline);
if (setAll || forcePEservice ||
newStatus != Owner.Status ||
newLocalIMCaps != Owner.LocalEndPointIMCapabilities ||
newLocalIMCapsex != Owner.LocalEndPointIMCapabilitiesEx ||
newLocalPECaps != Owner.LocalEndPointPECapabilities ||
newLocalPECapsex != Owner.LocalEndPointPECapabilitiesEx ||
newEPName != Owner.EpName)
{
XmlDocument xmlDoc = new XmlDocument();
XmlElement userElement = xmlDoc.CreateElement("user");
// s.IM (Status, CurrentMedia)
if (setAll || forcePEservice ||
newStatus != Owner.Status)
{
XmlElement service = xmlDoc.CreateElement("s");
service.SetAttribute("n", ServiceShortNames.IM.ToString());
service.InnerXml =
"<Status>" + ParseStatus(newStatus) + "</Status>" +
"<CurrentMedia>" + MSNHttpUtility.XmlEncode(newPSM.CurrentMedia) + "</CurrentMedia>";
userElement.AppendChild(service);
// Don't call Owner.Status = newStatus.
}
// s.PE (UserTileLocation, FriendlyName, PSM, Scene, ColorScheme)
if (setAll ||
forcePEservice)
{
XmlElement service = xmlDoc.CreateElement("s");
service.SetAttribute("n", ServiceShortNames.PE.ToString());
service.InnerXml = newPSM.Payload;
userElement.AppendChild(service);
// Don't set owner.PersonalMessage here. It is replaced (with a new reference) when NFY PUT received.
}
// sep.IM (Capabilities)
if (setAll ||
newLocalIMCaps != Owner.LocalEndPointIMCapabilities ||
newLocalIMCapsex != Owner.LocalEndPointIMCapabilitiesEx)
{
ClientCapabilities localIMCaps = setAll ? ClientCapabilities.DefaultIM : newLocalIMCaps;
ClientCapabilitiesEx localIMCapsEx = setAll ? ClientCapabilitiesEx.DefaultIM : newLocalIMCapsex;
XmlElement sep = xmlDoc.CreateElement("sep");
sep.SetAttribute("n", ServiceShortNames.IM.ToString());
XmlElement capabilities = xmlDoc.CreateElement("Capabilities");
capabilities.InnerText = ((long)localIMCaps).ToString() + ":" + ((long)localIMCapsEx).ToString();
sep.AppendChild(capabilities);
userElement.AppendChild(sep);
// Don't call Owner.LocalEndPointIMCapabilities. It is recursive call to this method.
}
// sep.PE (Capabilities)
if (setAll ||
newLocalPECaps != Owner.LocalEndPointPECapabilities ||
newLocalPECapsex != Owner.LocalEndPointPECapabilitiesEx)
{
ClientCapabilities localPECaps = setAll ? ClientCapabilities.DefaultPE : newLocalPECaps;
ClientCapabilitiesEx localPECapsEx = setAll ? ClientCapabilitiesEx.DefaultPE : newLocalPECapsex;
XmlElement sep = xmlDoc.CreateElement("sep");
sep.SetAttribute("n", ServiceShortNames.PE.ToString());
XmlElement VER = xmlDoc.CreateElement("VER");
VER.InnerText = Credentials.ClientInfo.MessengerClientName + ":" + Credentials.ClientInfo.MessengerClientBuildVer;
sep.AppendChild(VER);
XmlElement TYP = xmlDoc.CreateElement("TYP");
TYP.InnerText = "1";
sep.AppendChild(TYP);
XmlElement capabilities = xmlDoc.CreateElement("Capabilities");
capabilities.InnerText = ((long)localPECaps).ToString() + ":" + ((long)localPECapsEx).ToString();
sep.AppendChild(capabilities);
userElement.AppendChild(sep);
// Don't call Owner.LocalEndPointPECapabilities. It is recursive call to this method.
}
// sep.PD (EpName, State)
if (setAll ||
newEPName != Owner.EpName ||
newStatus != Owner.Status)
{
XmlElement sep = xmlDoc.CreateElement("sep");
sep.SetAttribute("n", ServiceShortNames.PD.ToString());
XmlElement clientType = xmlDoc.CreateElement("ClientType");
clientType.InnerText = "1";
sep.AppendChild(clientType);
XmlElement epName = xmlDoc.CreateElement("EpName");
epName.InnerText = MSNHttpUtility.XmlEncode(newEPName);
sep.AppendChild(epName);
XmlElement idle = xmlDoc.CreateElement("Idle");
idle.InnerText = ((newStatus == PresenceStatus.Idle) ? "true" : "false");
sep.AppendChild(idle);
XmlElement state = xmlDoc.CreateElement("State");
state.InnerText = ParseStatus(newStatus);
sep.AppendChild(state);
userElement.AppendChild(sep);
// Don't set Owner.EpName. It is recursive call to this method.
}
if (userElement.HasChildNodes)
{
string xml = userElement.OuterXml;
string me = ((int)Owner.ClientType).ToString() + ":" + Owner.Account;
MultiMimeMessage mmMessage = new MultiMimeMessage(me, me);
mmMessage.RoutingHeaders[MIMERoutingHeaders.From][MIMERoutingHeaders.EPID] = NSMessageHandler.MachineGuid.ToString("B").ToLowerInvariant();
mmMessage.Stream = 1;
mmMessage.ReliabilityHeaders[MIMEReliabilityHeaders.Flags] = "ACK";
mmMessage.ContentKey = MIMEContentHeaders.Publication;
mmMessage.ContentHeaders[MIMEContentHeaders.URI] = "/user";
mmMessage.ContentHeaders[MIMEContentHeaders.ContentType] = "application/user+xml";
mmMessage.InnerBody = System.Text.Encoding.UTF8.GetBytes(xml);
NSMessage nsMessage = new NSMessage("PUT");
nsMessage.InnerMessage = mmMessage;
MessageProcessor.SendMessage(nsMessage);
}
}
}
