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;
}
