public BackgroundDocumentGenerator( ForegroundDispatcher foregroundDispatcher, DocumentVersionCache documentVersionCache, ILanguageServer router, ILoggerFactory loggerFactory) { if (foregroundDispatcher == null) { throw new ArgumentNullException(nameof(foregroundDispatcher)); } if (documentVersionCache == null) { throw new ArgumentNullException(nameof(documentVersionCache)); } if (router == null) { throw new ArgumentNullException(nameof(router)); } if (loggerFactory == null) { throw new ArgumentNullException(nameof(loggerFactory)); } _foregroundDispatcher = foregroundDispatcher; _documentVersionCache = documentVersionCache; _router = router; _logger = loggerFactory.CreateLogger <BackgroundDocumentGenerator>(); _work = new Dictionary <string, DocumentSnapshot>(StringComparer.Ordinal); }
public async Task InitializeAsync() { var(client, server) = await Initialize(new TConfigureClient().Configure, new TConfigureServer().Configure); Client = client; Server = server; }
private static Task StartedAsync(ILanguageServer server, CancellationToken cancellationToken) { // TODO this currently only sent to get rid of the "Server answer pending" of the VSCode plugin. server.SendNotification("serverStarted", DafnyVersion); server.SendNotification("dafnyLanguageServerVersionReceived", DafnyVersion); return(Task.CompletedTask); }
public RazorDiagnosticsPublisher( ForegroundDispatcher foregroundDispatcher, ILanguageServer languageServer, ILoggerFactory loggerFactory) { if (foregroundDispatcher == null) { throw new ArgumentNullException(nameof(foregroundDispatcher)); } if (languageServer == null) { throw new ArgumentNullException(nameof(languageServer)); } if (loggerFactory == null) { throw new ArgumentNullException(nameof(loggerFactory)); } _foregroundDispatcher = foregroundDispatcher; _languageServer = languageServer; _publishedDiagnostics = new Dictionary <string, IReadOnlyList <RazorDiagnostic> >(FilePathComparer.Instance); _work = new Dictionary <string, DocumentSnapshot>(FilePathComparer.Instance); _logger = loggerFactory.CreateLogger <RazorDiagnosticsPublisher>(); }
public static void ShowWarning(this ILanguageServer mediator, string message) { mediator.ShowMessage(new ShowMessageParams() { Type = MessageType.Warning, Message = message }); }
/// <summary> /// Create a <see cref="LanguageClient" /> connected to the test's <see cref="PipeServerProcess" />. /// </summary> /// <returns> /// The <see cref="LanguageClient" />. /// </returns> protected async Task<(ILanguageClient client, ILanguageServer server)> Initialize( Action<LanguageClientOptions> clientOptionsAction, Action<LanguageServerOptions> serverOptionsAction ) { var clientPipe = new Pipe(); var serverPipe = new Pipe(); _client = LanguageClient.PreInit( options => { options.WithServices(services => services.AddSingleton(LoggerFactory)); options.WithInput(serverPipe.Reader).WithOutput(clientPipe.Writer); options.WithRootPath(WorkspaceRoot); clientOptionsAction(options); } ); Disposal.Add(_client); _server = Server.LanguageServer.PreInit( options => { options.WithServices(services => services.AddSingleton(LoggerFactory)); options.WithInput(clientPipe.Reader).WithOutput(serverPipe.Writer); serverOptionsAction(options); } ); Disposal.Add(_server); await Task.WhenAll( _client.Initialize(CancellationToken), _server.Initialize(CancellationToken) ); return ( _client, _server ); }
public static void CancelRequest(this ILanguageServer mediator, long id) { mediator.SendNotification <CancelParams>("$/cancelRequest", new CancelParams() { Id = id }); }
public CompletionHandler(ILanguageServer router, TextDocumentBuffer bufferManager, DocumentMetadataProvider metadataProvider, ILogger <CompletionHandler> logger) { _router = router; _bufferManager = bufferManager; _metadataProvider = metadataProvider; _logger = logger; }
public OmniSharpCodeActionHandler( Mef.IRequestHandler <GetCodeActionsRequest, GetCodeActionsResponse> getActionsHandler, Mef.IRequestHandler <RunCodeActionRequest, RunCodeActionResponse> runActionHandler, DocumentSelector documentSelector, ISerializer serializer, ILanguageServer server, DocumentVersions documentVersions) : base(new CodeActionRegistrationOptions() { DocumentSelector = documentSelector, CodeActionKinds = new Container <CodeActionKind>( CodeActionKind.SourceOrganizeImports, CodeActionKind.Refactor, CodeActionKind.RefactorExtract), }) { _getActionsHandler = getActionsHandler; _runActionHandler = runActionHandler; _serializer = serializer; _server = server; _documentVersions = documentVersions; _executeCommandRegistrationOptions = new ExecuteCommandRegistrationOptions() { Commands = new Container <string>("omnisharp/executeCodeAction"), }; }
/// <summary> /// Create a new language-server event sink. /// </summary> /// <param name="languageServer"> /// The language server to which events will be logged. /// </param> /// <param name="levelSwitch"> /// The <see cref="LoggingLevelSwitch"/> that controls logging. /// </param> public LanguageServerLoggingSink(ILanguageServer languageServer, LoggingLevelSwitch levelSwitch) { if (languageServer == null) { throw new ArgumentNullException(nameof(languageServer)); } if (levelSwitch == null) { throw new ArgumentNullException(nameof(levelSwitch)); } _languageServer = languageServer; _levelSwitch = levelSwitch; if (_languageServer is LanguageServer realLanguageServer) { realLanguageServer.Shutdown += shutDownRequested => { Log.CloseAndFlush(); _hasServerShutDown = true; }; } }
public DefaultTagHelperCompletionService( RazorTagHelperCompletionService razorCompletionService, HtmlFactsService htmlFactsService, TagHelperFactsService tagHelperFactsService, ILanguageServer languageServer) { if (razorCompletionService is null) { throw new ArgumentNullException(nameof(razorCompletionService)); } if (htmlFactsService is null) { throw new ArgumentNullException(nameof(htmlFactsService)); } if (tagHelperFactsService is null) { throw new ArgumentNullException(nameof(tagHelperFactsService)); } if (languageServer is null) { throw new ArgumentNullException(nameof(languageServer)); } _razorTagHelperCompletionService = razorCompletionService; _htmlFactsService = htmlFactsService; _tagHelperFactsService = tagHelperFactsService; LanguageServer = languageServer; }
private async Task InitializeAsync(Stream input, Stream output) { var documentSelector = new DocumentSelector( LanguageNames.AllLanguages .Select(x => new DocumentFilter { Language = x.ToLowerInvariant() })); _server = await OmniSharp.Extensions.LanguageServer.Server.LanguageServer.From(options => options .WithInput(input) .WithOutput(output) .ConfigureLogging(x => x .AddSerilog(_logger) .AddLanguageProtocolLogging() .SetMinimumLevel(_minLogLevel)) .AddHandler(new TextDocumentSyncHandler(_workspace, documentSelector)) .AddHandler(new CompletionHandler(_workspace, documentSelector)) .AddHandler(new DefinitionHandler(_workspace, documentSelector)) .AddHandler(new WorkspaceSymbolsHandler(_workspace)) .AddHandler(new DocumentHighlightHandler(_workspace, documentSelector)) .AddHandler(new DocumentSymbolsHandler(_workspace, documentSelector)) .AddHandler(new HoverHandler(_workspace, documentSelector)) .AddHandler(new SignatureHelpHandler(_workspace, documentSelector))); var diagnosticService = _workspace.Services.GetService <IDiagnosticService>(); _diagnosticNotifier = new DiagnosticNotifier(_server, diagnosticService); }
private static Task InitializeAsync(ILanguageServer server, InitializeParams request, CancellationToken cancellationToken) { var logger = server.GetRequiredService <ILogger <Program> >(); logger.LogTrace("initializing service"); return(Task.CompletedTask); }
private async Task InitializeAsync(Stream input, Stream output) { _server = await OmniSharp.Extensions.LanguageServer.Server.LanguageServer.From(options => options .WithInput(input) .WithOutput(output) .WithLoggerFactory(_loggerFactory) .OnInitialized(OnInitialized)); var diagnosticService = _workspace.Services.GetService <IDiagnosticService>(); _diagnosticNotifier = new DiagnosticNotifier(_server, diagnosticService); var documentSelector = new DocumentSelector( LanguageNames.AllLanguages .Select(x => new DocumentFilter { Language = x.ToLowerInvariant() })); var registrationOptions = new TextDocumentRegistrationOptions { DocumentSelector = documentSelector }; _server.AddHandlers( new TextDocumentSyncHandler(_workspace, registrationOptions), new CompletionHandler(_workspace, registrationOptions), new DefinitionHandler(_workspace, registrationOptions), new WorkspaceSymbolsHandler(_workspace), new DocumentHighlightHandler(_workspace, registrationOptions), new DocumentSymbolsHandler(_workspace, registrationOptions), new HoverHandler(_workspace, registrationOptions), new SignatureHelpHandler(_workspace, registrationOptions)); }
public static void LogInfo(this ILanguageServer mediator, string message) { mediator.LogMessage(new LogMessageParams() { Type = MessageType.Info, Message = message }); }
public DefaultRazorFormattingService( RazorDocumentMappingService documentMappingService, FilePathNormalizer filePathNormalizer, ILanguageServer server, ILoggerFactory loggerFactory) { if (documentMappingService is null) { throw new ArgumentNullException(nameof(documentMappingService)); } if (filePathNormalizer is null) { throw new ArgumentNullException(nameof(filePathNormalizer)); } if (server is null) { throw new ArgumentNullException(nameof(server)); } if (loggerFactory is null) { throw new ArgumentNullException(nameof(loggerFactory)); } _server = server; _csharpFormatter = new CSharpFormatter(documentMappingService, server, filePathNormalizer); _htmlFormatter = new HtmlFormatter(server, filePathNormalizer); _logger = loggerFactory.CreateLogger <DefaultRazorFormattingService>(); }
public DefaultRazorFormattingService( IEnumerable <RazorFormatOnTypeProvider> formatOnTypeProviders, RazorDocumentMappingService documentMappingService, FilePathNormalizer filePathNormalizer, ILanguageServer server, ILoggerFactory loggerFactory) { if (documentMappingService is null) { throw new ArgumentNullException(nameof(documentMappingService)); } if (filePathNormalizer is null) { throw new ArgumentNullException(nameof(filePathNormalizer)); } if (server is null) { throw new ArgumentNullException(nameof(server)); } if (loggerFactory is null) { throw new ArgumentNullException(nameof(loggerFactory)); } _formatOnTypeProviders = formatOnTypeProviders.ToList(); _formatOnTypeTriggerCharacters = _formatOnTypeProviders.Select(provider => provider.TriggerCharacter).ToList(); _server = server; _csharpFormatter = new CSharpFormatter(documentMappingService, server, filePathNormalizer); _htmlFormatter = new HtmlFormatter(server, filePathNormalizer); _logger = loggerFactory.CreateLogger <DefaultRazorFormattingService>(); }
/// <summary> /// Construct a new AnalysisService. /// </summary> /// <param name="loggerFactory">Logger factory to create logger instances with.</param> /// <param name="languageServer">The LSP language server for notifications.</param> /// <param name="configurationService">The configuration service to query for configurations.</param> /// <param name="workspaceService">The workspace service for file handling within a workspace.</param> public AnalysisService( ILoggerFactory loggerFactory, ILanguageServer languageServer, ConfigurationService configurationService, WorkspaceService workspaceService) { _loggerFactory = loggerFactory; _logger = loggerFactory.CreateLogger <AnalysisService>(); _languageServer = languageServer; _configurationService = configurationService; _workplaceService = workspaceService; _analysisDelayMillis = 750; _mostRecentCorrectionsByFile = new ConcurrentDictionary <ScriptFile, CorrectionTableEntry>(); _analysisEngineLazy = new Lazy <PssaCmdletAnalysisEngine>(InstantiateAnalysisEngine); _pssaSettingsFilePath = null; _azureRmVersion = "6.13.1"; _azVersion = "4.6.1"; powerShell = System.Management.Automation.PowerShell.Create() .AddScript("Set-ExecutionPolicy -ExecutionPolicy Unrestricted -Scope Process") .AddScript("Register-PSRepository -Name PSGallery -SourceLocation https://www.powershellgallery.com/api/v2/ -InstallationPolicy Trusted") .AddScript(@"Install-Module -Name Az.Tools.Migration -Repository PSGallery") .AddScript("$azSpec = Get-AzUpgradeCmdletSpec -ModuleName \"Az\" -ModuleVersion \"" + _azVersion + "\"") .AddScript("$azureRMSpec = Get-AzUpgradeCmdletSpec -ModuleName \"AzureRM\" -ModuleVersion \"" + _azureRmVersion + "\""); powerShell.Invoke(); }
public static void CancelRequest(this ILanguageServer mediator, long id) { mediator.SendNotification(GeneralNames.CancelRequest, new CancelParams() { Id = id }); }
public EditorOperationsService( WorkspaceService workspaceService, ILanguageServer languageServer) { this._workspaceService = workspaceService; this._languageServer = languageServer; }
public static Task InitializedAsync(this ILanguageServer languageServer, CancellationToken cancellationToken) { var type = typeof(OmniSharp.Extensions.LanguageServer.Server.LanguageServer); var method = type.GetMethod("Initialize", BindingFlags.NonPublic | BindingFlags.Instance); var task = (Task)method.Invoke(languageServer, new object[] { cancellationToken }); return(task); }
public CustomViewFeatureBase( ILanguageServer languageServer, ILogger logger) { this.viewIndex = new Dictionary <Guid, TView>(); this.languageServer = languageServer; this.logger = logger; }
/// <summary> /// Creates a new instance of the ConsoleServicePSHostUserInterface /// class with the given IConsoleHost implementation. /// </summary> /// <param name="powerShellContext"></param> public ProtocolPSHostUserInterface( ILanguageServer languageServer, PowerShellContextService powerShellContext, ILogger logger) : base(powerShellContext, new SimplePSHostRawUserInterface(logger), logger) { _languageServer = languageServer; }
async Task IOnLanguageServerStarted.OnStarted(ILanguageServer server, CancellationToken cancellationToken) { IsSupported = server.ClientSettings?.Capabilities?.Workspace?.WorkspaceFolders.IsSupported == true; if (IsSupported) { await Refresh().LastOrDefaultAsync().ToTask(cancellationToken); } }
/// <summary> /// Create the application logger. /// </summary> /// <param name="componentContext"> /// The current component context. /// </param> /// <returns> /// The logger. /// </returns> private static ILogger CreateLogger(IComponentContext componentContext) { if (componentContext == null) { throw new ArgumentNullException(nameof(componentContext)); } Configuration configuration = componentContext.Resolve <Configuration>(); ConfigureSeq(configuration.Logging.Seq); // Override default log level. bool debug = true; if (debug) { configuration.Logging.LevelSwitch.MinimumLevel = LogEventLevel.Debug; configuration.Logging.Seq.LevelSwitch.MinimumLevel = LogEventLevel.Debug; } ILanguageServer languageServer = componentContext.Resolve <ILanguageServer>(); var loggerConfiguration = new LoggerConfiguration() .MinimumLevel.Verbose() .Enrich.WithCurrentActivityId() .Enrich.WithDemystifiedStackTraces() .Enrich.FromLogContext(); if (!String.IsNullOrWhiteSpace(configuration.Logging.Seq.Url)) { loggerConfiguration = loggerConfiguration.WriteTo.Seq(configuration.Logging.Seq.Url, apiKey: configuration.Logging.Seq.ApiKey, controlLevelSwitch: configuration.Logging.Seq.LevelSwitch ); } string logFilePath = ".\\logs\\log.txt"; if (!String.IsNullOrWhiteSpace(logFilePath)) { loggerConfiguration = loggerConfiguration.WriteTo.File( path: logFilePath, levelSwitch: configuration.Logging.LevelSwitch, outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level}/{Operation}] {Message}{NewLine}{Exception}", flushToDiskInterval: TimeSpan.FromSeconds(1) ); } loggerConfiguration = loggerConfiguration.WriteTo.LanguageServer(languageServer, configuration.Logging.LevelSwitch); ILogger logger = loggerConfiguration.CreateLogger(); Log.Logger = logger; logger.Verbose("Logger initialised."); return(logger); }
public DidChangeConfigurationProvider(ILanguageServer server, Action <IConfigurationBuilder> configurationBuilderAction) { _server = server; var builder = new ConfigurationBuilder() .Add(new DidChangeConfigurationSource(this)); configurationBuilderAction(builder); _configuration = builder.Build() as ConfigurationRoot; }
public async Task InitializeAsync(ILanguageServer server) { var documents = await server.SendRequest <IEnumerable <TextDocumentItem> >(GetAllDocumentsMethod); foreach (var doc in documents) { this.DocumentAdded(doc.Uri.AbsolutePath, new ThrowTextLoader()); } }
public EditorOperationsService( WorkspaceService workspaceService, PowerShellContextService powerShellContextService, ILanguageServer languageServer) { _workspaceService = workspaceService; _powerShellContextService = powerShellContextService; _languageServer = languageServer; }
public TestRazorDiagnosticsPublisher( ForegroundDispatcher foregroundDispatcher, ILanguageServer languageServer, ILoggerFactory loggerFactory) : base(foregroundDispatcher, languageServer, loggerFactory) { // The diagnostics publisher by default will wait 2 seconds until publishing diagnostics. For testing purposes we redcuce // the amount of time we wait for diagnostic publishing because we have more concrete control of the timer and its lifecycle. _publishDelay = TimeSpan.FromMilliseconds(1); }
public ProjectHost(ProgramOptions options, IServiceProvider serviceProvider, ILanguageServer languageServer, ILogger <ProjectHost> logger) { _logger = logger; _name = options.Name; _languageServer = languageServer; _program = serviceProvider.CreateInstance <PapyrusProgram>(options); _program.OnScriptFileChanged += HandleScriptFileChanged; }