private LanguageServerOptions CreateLanguageServerOptions() { var opts = new LanguageServerOptions(this); opts.Load(); return(opts); }
public void Configure(LanguageServerOptions options) => options.ObserveCodeLens( (@params, observer, capability, cancellationToken) => { observer.OnNext( new[] { new CodeLens { Command = new Command { Name = "CodeLens 1" } }, } ); observer.OnNext( new[] { new CodeLens { Command = new Command { Name = "CodeLens 2" } }, } ); observer.OnNext( new[] { new CodeLens { Command = new Command { Name = "CodeLens 3" } }, } ); observer.OnCompleted(); }, (_, _) => new CodeLensRegistrationOptions() );
static async Task Main(string[] args) { var options = new LanguageServerOptions() .WithInput(Console.OpenStandardInput()) .WithOutput(Console.OpenStandardOutput()) .WithLoggerFactory(new LoggerFactory()) .AddDefaultLoggingProvider() .WithMinimumLogLevel(LogLevel.Trace) .WithServices(ConfigureServices) .WithHandler <TextDocumentSyncHandler>() .OnInitialize((s, _) => { var serviceProvider = (s as LanguageServer).Services; var bufferManager = serviceProvider.GetService <BufferManager>(); var diagnosticsHandler = serviceProvider.GetService <DiagnosticsHandler>(); // Hook up diagnostics bufferManager.BufferUpdated += (__, x) => diagnosticsHandler.PublishDiagnostics(x.Uri, bufferManager.GetBuffer(x.Uri)); return(Task.CompletedTask); }); var server = await LanguageServer.From(options); await server.WaitForExit; }
public LanguageServerOptionsControl(IServiceProvider serviceProvider) { _serviceProvider = serviceProvider; _options = _serviceProvider?.GetPythonToolsService().LanguageServerOptions; InitializeComponent(); UpdateSettings(); }
private void ConfigureServer(LanguageServerOptions options) { options.WithContentModifiedSupport(true); options.OnCompletion(async(x, ct) => { await Task.Delay(50000, ct); return(new CompletionList()); }, new CompletionRegistrationOptions()); options.OnDidChangeTextDocument(async x => { await Task.Delay(20); }, new TextDocumentChangeRegistrationOptions()); }
public static LanguageServerOptions WithDafnyLanguageServer(this LanguageServerOptions options, IConfiguration configuration) { return(options .WithDafnyLanguage() .WithDafnyWorkspace(configuration) .WithDafnyHandlers() .OnInitialize(InitializeAsync) .OnStarted(StartedAsync)); }
private void ServerOptionsAction(LanguageServerOptions obj) { obj.OnMoniker( _request, (_, _) => new MonikerRegistrationOptions() { DocumentSelector = DocumentSelector.ForLanguage("csharp"), } ); }
public static LanguageServerOptions WithDafnyLanguageServer(this LanguageServerOptions options, IConfiguration configuration) { return(options .WithDafnyLanguage() .WithDafnyWorkspace(configuration) .WithDafnyHandlers() .OnInitialize(Initialize) .OnStarted(Started) .WithMaximumRequestTimeout(System.TimeSpan.FromMilliseconds(600000))); }
private void ConfigureServer(LanguageServerOptions options) { options.OnRequest("keepalive", (ct) => Task.FromResult(true)); options.WithLink("keepalive", "ka"); options.WithLink("throw", "t"); options.OnRequest("throw", async ct => { throw new NotSupportedException(); return(Task.CompletedTask); }); }
/// <summary> /// Registers all handlers necessary to provide the language server integration of dafny. /// </summary> /// <param name="options">The language server where the handlers should be registered to.</param> /// <returns>The language server enriched with the dafny handlers.</returns> public static LanguageServerOptions WithDafnyHandlers(this LanguageServerOptions options) { return(options .WithHandler <DafnyTextDocumentHandler>() .WithHandler <DafnyDocumentSymbolHandler>() .WithHandler <DafnyHoverHandler>() .WithHandler <DafnyDefinitionHandler>() .WithHandler <DafnyCompletionHandler>() .WithHandler <DafnySignatureHelpHandler>() .WithHandler <DafnyCounterExampleHandler>()); }
private void ConfigureServer(LanguageServerOptions options) { options.OnInitialize((server, request, token) => { server.Window.LogInfo("OnInitialize"); return(Task.CompletedTask); }); options.OnInitialized((server, request, response, token) => { server.Window.LogInfo("OnInitialized"); return(Task.CompletedTask); }); }
/// <summary> /// Registers all handlers necessary to provide the language server integration of dafny. /// </summary> /// <param name="options">The language server where the handlers should be registered to.</param> /// <returns>The language server enriched with the dafny handlers.</returns> public static LanguageServerOptions WithDafnyHandlers(this LanguageServerOptions options) { return(options .WithHandler <DafnyTextDocumentHandler>() // TODO Disabled since its functionallity cannot be observed in VS Code (yet). //.WithHandler<DafnyDocumentSymbolHandler>() .WithHandler <DafnyHoverHandler>() .WithHandler <DafnyDefinitionHandler>() .WithHandler <DafnyCompletionHandler>() .WithHandler <DafnySignatureHelpHandler>() .WithHandler <DafnyCounterExampleHandler>()); }
/// <summary> /// Used for inject the test host for unit testing /// </summary> /// <param name="input"></param> /// <param name="output"></param> /// <param name="configureServer"></param> /// <param name="cancellationTokenSource"></param> internal LanguageServerHost( Stream input, Stream output, Action <LanguageServerOptions> configureServer, CancellationTokenSource cancellationTokenSource) { _options = new LanguageServerOptions() .WithInput(input) .WithOutput(output) .WithServices(ConfigureServices); configureServer(_options); _cancellationTokenSource = cancellationTokenSource; }
public void Configure(LanguageServerOptions options) => options.ObserveSemanticTokensFull( (@params, observer, arg3) => { observer.OnNext(new SemanticTokensPartialResult() { Data = new[] { 0 }.ToImmutableArray() }); observer.OnNext(new SemanticTokensPartialResult() { Data = new[] { 0, 1 }.ToImmutableArray() }); observer.OnNext(new SemanticTokensPartialResult() { Data = new[] { 0, 1, 2 }.ToImmutableArray() }); observer.OnCompleted(); }, (_, _) => new SemanticTokensRegistrationOptions() );
private void ConfigureServer(LanguageServerOptions options) { options.OnCompletion( (@params, token) => Task.FromResult(new CompletionList()), registrationOptions: new CompletionRegistrationOptions() { DocumentSelector = DocumentSelector.ForLanguage("csharp"), ResolveProvider = false, TriggerCharacters = new Container <string>("a", "b"), AllCommitCharacters = new Container <string>("1", "2"), }); options.OnSemanticTokens( (builder, @params, ct) => { return(Task.CompletedTask); }, (@params, token) => { return(Task.FromResult(new SemanticTokensDocument(new SemanticTokensLegend()))); }, new SemanticTokensRegistrationOptions()); }
public LanguageServerHost( Stream input, Stream output, CommandLineApplication application, CancellationTokenSource cancellationTokenSource) { _loggerFactory = new LoggerFactory(); _logger = _loggerFactory.CreateLogger <LanguageServerHost>(); _options = new LanguageServerOptions() .WithInput(input) .WithOutput(output) .WithLoggerFactory(_loggerFactory) .AddDefaultLoggingProvider() .OnInitialize(Initialize) .WithMinimumLogLevel(application.LogLevel) .WithServices(services => _services = services); _application = application; _cancellationTokenSource = cancellationTokenSource; }
public LanguageServerHost( Stream input, Stream output, CommandLineApplication application, CancellationTokenSource cancellationTokenSource) { _options = new LanguageServerOptions() .WithInput(input) .WithOutput(output) .ConfigureLogging(x => x .AddLanguageProtocolLogging() // .SetMinimumLevel(application.LogLevel) ) .OnInitialize(Initialize) .WithServices(ConfigureServices); _application = application; _cancellationTokenSource = cancellationTokenSource; }
public static void ConfigureLanguageServer(LanguageServerOptions options, Action <ILoggingBuilder> configureLoggingAction = null) { // Hack to circumvent OmniSharp bug: https://github.com/OmniSharp/csharp-language-server-protocol/issues/609 options.Services.AddSingleton <IReceiver, RhetosJsonRpcReceiver>(); options .WithHandler <TextDocumentHandler>() .WithHandler <RhetosHoverHandler>() .WithHandler <RhetosSignatureHelpHandler>() .WithHandler <RhetosCompletionHandler>() .WithUnhandledExceptionHandler(UnhandledExceptionHandler) .WithServices(ConfigureServices) .OnInitialize(OnInitializeAsync) .OnInitialized(OnInitializedAsync); if (configureLoggingAction != null) { options.ConfigureLogging(configureLoggingAction); } }
public LanguageServerHost( Stream input, Stream output, CommandLineApplication application, CancellationTokenSource cancellationTokenSource, Action <ILoggingBuilder> configureLogging = null) { _options = new LanguageServerOptions() .WithInput(input) .WithOutput(output) // initializeParams from the client won't be arriving yet, configure with app loglevel .ConfigureLogging(GetLogBuilderAction(configureLogging, application.LogLevel)) .OnInitialize(Initialize) .OnInitialized(Initialized) .WithServices(ConfigureServices); _application = application; _cancellationTokenSource = cancellationTokenSource; _configureLogging = configureLogging; }
static async Task Main(string[] args) { //System.Diagnostics.Debugger.Launch(); //while (!System.Diagnostics.Debugger.IsAttached) //{ // await Task.Delay(100); //} var options = new LanguageServerOptions() .WithInput(Console.OpenStandardInput()) .WithOutput(Console.OpenStandardOutput()) .WithLoggerFactory(new LoggerFactory()) .AddDefaultLoggingProvider() .WithMinimumLogLevel(LogLevel.Trace) .WithHandler <TextDocumentHandler>(); options.OnInitialize(Delegate); var server = await LanguageServer.From(options); await server.WaitForExit; }
private void ConfigureServerWithDelegateCodeLens(LanguageServerOptions options) { options.OnCodeLens((@params, observer, capability, cancellationToken) => { observer.OnNext(new [] { new CodeLens() { Command = new Command() { Name = "CodeLens 1" } }, }); observer.OnNext(new [] { new CodeLens() { Command = new Command() { Name = "CodeLens 2" } }, }); observer.OnNext(new [] { new CodeLens() { Command = new Command() { Name = "CodeLens 3" } }, }); observer.OnCompleted(); }, new CodeLensRegistrationOptions() { // DocumentSelector = DocumentSelector.ForPattern("**/*.cs") }); }
private void ConfigureServer(LanguageServerOptions options) { }
public void Configure(LanguageServerOptions options) => options.AddHandler <InnerCodeLensHandler>();
protected virtual void ConfigureServerInputOutput(PipeReader clientOutput, PipeWriter serverInput, LanguageServerOptions options) => options.WithInput(clientOutput).WithOutput(serverInput);
public ActionDelegateData() { { var baseOptions = new LanguageServerOptions().WithPipe(new Pipe()); void BaseDelegate(LanguageServerOptions o) { o.WithPipe(new Pipe()); } var serviceProvider = new ServiceCollection().BuildServiceProvider(); Add(new ActionDelegate("create (server): options", () => LanguageServer.Create(baseOptions))); Add(new ActionDelegate("create (server): options, serviceProvider", () => LanguageServer.Create(baseOptions, serviceProvider))); Add(new ActionDelegate("create (server): action", () => LanguageServer.Create(BaseDelegate))); Add(new ActionDelegate("create (server): action, serviceProvider", () => LanguageServer.Create(BaseDelegate, serviceProvider))); Add(new ActionDelegate("from (server): options", () => LanguageServer.From(baseOptions))); Add(new ActionDelegate("from (server): options, cancellationToken", () => LanguageServer.From(baseOptions, CancellationToken.None))); Add( new ActionDelegate( "from (server): options, serviceProvider, cancellationToken", () => LanguageServer.From(baseOptions, serviceProvider, CancellationToken.None) ) ); Add(new ActionDelegate("from (server): options, serviceProvider", () => LanguageServer.From(baseOptions, serviceProvider))); Add(new ActionDelegate("from (server): action", () => LanguageServer.From(BaseDelegate))); Add(new ActionDelegate("from (server): action, cancellationToken", () => LanguageServer.From(BaseDelegate, CancellationToken.None))); Add( new ActionDelegate( "from (server): action, serviceProvider, cancellationToken", () => LanguageServer.From(BaseDelegate, serviceProvider, CancellationToken.None) ) ); Add(new ActionDelegate("from (server): action, serviceProvider", () => LanguageServer.From(BaseDelegate, serviceProvider))); } { var baseOptions = new LanguageClientOptions().WithPipe(new Pipe()); void BaseDelegate(LanguageClientOptions o) { o.WithPipe(new Pipe()); } var serviceProvider = new ServiceCollection().BuildServiceProvider(); Add(new ActionDelegate("create (client): options", () => LanguageClient.Create(baseOptions))); Add(new ActionDelegate("create (client): options, serviceProvider", () => LanguageClient.Create(baseOptions, serviceProvider))); Add(new ActionDelegate("create (client): action", () => LanguageClient.Create(BaseDelegate))); Add(new ActionDelegate("create (client): action, serviceProvider", () => LanguageClient.Create(BaseDelegate, serviceProvider))); Add(new ActionDelegate("from (client): options", () => LanguageClient.From(baseOptions))); Add(new ActionDelegate("from (client): options, cancellationToken", () => LanguageClient.From(baseOptions, CancellationToken.None))); Add( new ActionDelegate( "from (client): options, serviceProvider, cancellationToken", () => LanguageClient.From(baseOptions, serviceProvider, CancellationToken.None) ) ); Add(new ActionDelegate("from (client): options, serviceProvider", () => LanguageClient.From(baseOptions, serviceProvider))); Add(new ActionDelegate("from (client): action", () => LanguageClient.From(BaseDelegate))); Add(new ActionDelegate("from (client): action, cancellationToken", () => LanguageClient.From(BaseDelegate, CancellationToken.None))); Add( new ActionDelegate( "from (client): action, serviceProvider, cancellationToken", () => LanguageClient.From(BaseDelegate, serviceProvider, CancellationToken.None) ) ); Add(new ActionDelegate("from (client): action, serviceProvider", () => LanguageClient.From(BaseDelegate, serviceProvider))); } }
private void ConfigureServer(LanguageServerOptions options) => options.WithConfigurationSection("mysection").WithConfigurationSection("othersection");
private void ConfigureServerWithClassCodeLens(LanguageServerOptions options) { options.AddHandler <InnerCodeLensHandler>(); }
private void ConfigureServer(LanguageServerOptions options) { options.OnCodeAction(@params => Task.FromResult(new CommandOrCodeActionContainer()), (capability, capabilities) => new CodeActionRegistrationOptions()); }
private void ConfigureServer(LanguageServerOptions options) { // options.OnCodeLens() }
private LanguageServerOptions AddRequests(LanguageServerOptions options) { // Pathmap creation is seperated into 2 requests, 'pathmapFromClipboard' and 'pathmapApply'. // Pathmap generation request. options.OnRequest <object, string>("pathmapFromClipboard", _ => Task <string> .Run(() => { // Create the error handler for pathmap parser. ServerPathmapHandler error = new ServerPathmapHandler(); // Get the pathmap. 'map' will be null if there is an error. try { Pathmap map = Pathmap.ImportFromCSV(Clipboard.GetText(), error); if (map == null) { return(error.Message); } else { lastMap = map; return("success"); } } catch (Exception ex) { return(ex.Message); } })); // Pathmap save request. options.OnRequest <Newtonsoft.Json.Linq.JToken>("pathmapApply", uriToken => Task.Run(() => { // Save 'lastMap' to a file. string result = lastMap.ExportAsJSON(); string output = uriToken["path"].ToObject <string>().Trim('/'); using (var stream = new StreamWriter(output)) stream.Write(result); })); // Pathmap editor request. options.OnRequest <PathmapDocument, bool>("pathmapEditor", (editFileToken) => Task <bool> .Run(() => { DeltinScript compile; if (editFileToken.Text == null) { string editor = Extras.CombinePathWithDotNotation(null, "!PathfindEditor.del"); compile = new DeltinScript(new TranslateSettings(editor) { OutputLanguage = ConfigurationHandler.OutputLanguage }); } else { compile = Editor.Generate(editFileToken.File, Pathmap.ImportFromText(editFileToken.Text), ConfigurationHandler.OutputLanguage); } Clipboard.SetText(compile.WorkshopCode); return(true); })); // semantic tokens options.OnRequest <Newtonsoft.Json.Linq.JToken, SemanticToken[]>("semanticTokens", (uriToken) => Task <SemanticToken[]> .Run(async() => { await DocumentHandler.WaitForParse(); SemanticToken[] tokens = LastParse?.ScriptFromUri(new Uri(uriToken["fsPath"].ToObject <string>()))?.GetSemanticTokens(); return(tokens ?? new SemanticToken[0]); })); // debugger start options.OnRequest <object>("debugger.start", args => Task.Run(() => { _debugger.Start(); return(new object()); })); // debugger stop options.OnRequest <object>("debugger.stop", args => Task.Run(() => { _debugger.Stop(); return(new object()); })); // debugger scopes options.OnRequest <ScopesArgs, DBPScope[]>("debugger.scopes", args => Task <DBPScope[]> .Run(() => { try { if (_debugger.VariableCollection != null) { return(_debugger.VariableCollection.GetScopes(args)); } } catch (Exception ex) { DebuggerException(ex); } return(new DBPScope[0]); })); // debugger variables options.OnRequest <VariablesArgs, DBPVariable[]>("debugger.variables", args => Task <DBPVariable[]> .Run(() => { try { if (_debugger.VariableCollection != null) { return(_debugger.VariableCollection.GetVariables(args)); } } catch (Exception ex) { DebuggerException(ex); } return(new DBPVariable[0]); })); // debugger evaluate options.OnRequest <EvaluateArgs, EvaluateResponse>("debugger.evaluate", args => Task <EvaluateResponse> .Run(() => { try { return(_debugger.VariableCollection?.Evaluate(args)); } catch (Exception ex) { DebuggerException(ex); return(EvaluateResponse.Empty); } })); // Decompile insert options.OnRequest <DecompileResult>("decompile.insert", () => Task <DecompileResult> .Run(() => { try { var tte = new ConvertTextToElement(Clipboard.GetText()); var workshop = tte.Get(); var code = new WorkshopDecompiler(workshop, new OmitLobbySettingsResolver(), new CodeFormattingOptions()).Decompile(); return(new DecompileResult(tte, code)); } catch (Exception ex) { return(new DecompileResult(ex)); } })); // Decompile file options.OnRequest <DecompileFileArgs, DecompileResult>("decompile.file", args => Task.Run <DecompileResult>(() => { try { // Parse the workshop code. var tte = new ConvertTextToElement(Clipboard.GetText()); var workshop = tte.Get(); // Decompile the parsed workshop code. var workshopToCode = new WorkshopDecompiler(workshop, new FileLobbySettingsResolver(args.File, workshop.LobbySettings), new CodeFormattingOptions()); var code = workshopToCode.Decompile(); var result = new DecompileResult(tte, code); // Only create the decompile was successful. if (result.Success) { // Create the file. using (var writer = File.CreateText(args.File)) // Write the code to the file. writer.Write(code); } return(result); } catch (Exception ex) { return(new DecompileResult(ex)); } })); return(options); }