public DnxProjectSystem(OmnisharpWorkspace workspace, IOmnisharpEnvironment env, IOptions <OmniSharpOptions> optionsAccessor, ILoggerFactory loggerFactory, IMetadataFileReferenceCache metadataFileReferenceCache, IApplicationLifetime lifetime, IFileSystemWatcher watcher, IEventEmitter emitter, DnxContext context) { _workspace = workspace; _env = env; _logger = loggerFactory.CreateLogger <DnxProjectSystem>(); _metadataFileReferenceCache = metadataFileReferenceCache; _options = optionsAccessor.Options; _dnxPaths = new DnxPaths(env, _options, loggerFactory); _designTimeHostManager = new DesignTimeHostManager(loggerFactory, _dnxPaths); _packagesRestoreTool = new PackagesRestoreTool(_options, loggerFactory, emitter, context, _dnxPaths); _context = context; _watcher = watcher; _emitter = emitter; _directoryEnumerator = new DirectoryEnumerator(loggerFactory); lifetime.ApplicationStopping.Register(OnShutdown); }
public CSharpDiagnosticWorkerWithAnalyzers( OmniSharpWorkspace workspace, [ImportMany] IEnumerable <ICodeActionProvider> providers, ILoggerFactory loggerFactory, DiagnosticEventForwarder forwarder, OmniSharpOptions options) { _logger = loggerFactory.CreateLogger <CSharpDiagnosticWorkerWithAnalyzers>(); _providers = providers.ToImmutableArray(); _workQueue = new AnalyzerWorkQueue(loggerFactory, timeoutForPendingWorkMs: options.RoslynExtensionsOptions.DocumentAnalysisTimeoutMs * 3); _forwarder = forwarder; _options = options; _workspace = workspace; _workspaceAnalyzerOptionsConstructor = Assembly .Load("Microsoft.CodeAnalysis.Features") .GetType("Microsoft.CodeAnalysis.Diagnostics.WorkspaceAnalyzerOptions") .GetConstructor(new Type[] { typeof(AnalyzerOptions), typeof(Solution) }) ?? throw new InvalidOperationException("Could not resolve 'Microsoft.CodeAnalysis.Diagnostics.WorkspaceAnalyzerOptions' for IDE analyzers."); _workspace.WorkspaceChanged += OnWorkspaceChanged; _workspace.OnInitialized += OnWorkspaceInitialized; Task.Factory.StartNew(() => Worker(AnalyzerWorkType.Foreground), TaskCreationOptions.LongRunning); Task.Factory.StartNew(() => Worker(AnalyzerWorkType.Background), TaskCreationOptions.LongRunning); OnWorkspaceInitialized(_workspace.Initialized); }
private void UpdateImplementation(OmniSharpOptions options) { var firstRun = _implementation is null; if (options.RoslynExtensionsOptions.EnableAnalyzersSupport && (firstRun || _implementation is CSharpDiagnosticWorker)) { var old = Interlocked.Exchange(ref _implementation, new CSharpDiagnosticWorkerWithAnalyzers(_workspace, _providers, _loggerFactory, _forwarder, options)); if (old is IDisposable disposable) { disposable.Dispose(); } } else if (!options.RoslynExtensionsOptions.EnableAnalyzersSupport && (firstRun || _implementation is CSharpDiagnosticWorkerWithAnalyzers)) { var old = Interlocked.Exchange(ref _implementation, new CSharpDiagnosticWorker(_workspace, _forwarder, _loggerFactory)); if (old is IDisposable disposable) { disposable.Dispose(); } if (!firstRun) { _implementation.QueueDocumentsForDiagnostics(); } } }
public WorkspaceHelper(CompositionHost compositionHost, IConfiguration configuration, OmniSharpOptions options, ILoggerFactory loggerFactory) { _compositionHost = compositionHost; _configuration = configuration; _options = options; _logger = loggerFactory.CreateLogger <WorkspaceHelper>(); }
public ExternalFeaturesHostServicesProvider(IAssemblyLoader loader, OmniSharpOptions options, IOmniSharpEnvironment environment, ILoggerFactory loggerFactory) { var builder = ImmutableArray.CreateBuilder <Assembly>(); var roslynExtensionsLocations = options.RoslynExtensionsOptions.GetNormalizedLocationPaths(environment); if (roslynExtensionsLocations?.Any() == true) { var logger = loggerFactory.CreateLogger <ExternalFeaturesHostServicesProvider>(); foreach (var roslynExtensionsLocation in roslynExtensionsLocations) { var loadedAssemblies = loader.LoadAllFrom(roslynExtensionsLocation); if (loadedAssemblies.Any()) { builder.AddRange(loadedAssemblies); } else { logger.LogWarning($"The path '{roslynExtensionsLocation}' is configured in the RoslynExtensionsOptions as the external features source but no assemblies were found at this path."); } } } Assemblies = builder.ToImmutable(); }
public CSharpDiagnosticWorker(OmniSharpWorkspace workspace, DiagnosticEventForwarder forwarder, ILoggerFactory loggerFactory, OmniSharpOptions options) { _workspace = workspace; _forwarder = forwarder; _logger = loggerFactory.CreateLogger <CSharpDiagnosticWorker>(); _options = options; var openDocumentsSubject = new Subject <string>(); _openDocuments = openDocumentsSubject; _workspace.WorkspaceChanged += OnWorkspaceChanged; _workspace.DocumentOpened += OnDocumentOpened; _workspace.DocumentClosed += OnDocumentOpened; _disposable = openDocumentsSubject .Buffer(() => Observable.Amb( openDocumentsSubject.Skip(99).Select(z => Unit.Default), Observable.Timer(TimeSpan.FromMilliseconds(100)).Select(z => Unit.Default) )) .SubscribeOn(TaskPoolScheduler.Default) .Select(ProcessQueue) .Merge() .Subscribe(); }
public GotoTypeDefinitionHandler( OmniSharpWorkspace workspace, ExternalSourceServiceFactory externalSourceServiceFactory, OmniSharpOptions omniSharpOptions) : base(workspace) { _externalSourceService = externalSourceServiceFactory?.Create(omniSharpOptions) ?? throw new ArgumentNullException(nameof(externalSourceServiceFactory)); }
public static async Task <string> GetFormattedText(Document document, OmniSharpOptions omnisharpOptions, ILoggerFactory loggerFactory) { var newDocument = await FormatDocument(document, omnisharpOptions, loggerFactory); var text = await newDocument.GetTextAsync(); return(text.ToString()); }
public CodeCheckService( OmniSharpWorkspace workspace, ILoggerFactory loggerFactory, OmniSharpOptions options, ICsDiagnosticWorker diagWorker) { _diagWorker = diagWorker; _logger = loggerFactory.CreateLogger <CodeCheckService>(); }
public FixUsingService( OmniSharpWorkspace workspace, OmniSharpOptions options, [ImportMany] IEnumerable <ICodeActionProvider> codeActionProviders) { _workspace = workspace; _options = options; _providers = codeActionProviders; }
public static CompositionHost ConfigureMef(IServiceProvider serviceProvider, OmniSharpOptions options, IEnumerable <Assembly> assemblies, Func <ContainerConfiguration, ContainerConfiguration> configure = null) { var config = new ContainerConfiguration(); assemblies = assemblies .Concat(new[] { typeof(OmnisharpWorkspace).GetTypeInfo().Assembly, typeof(IRequest).GetTypeInfo().Assembly }) .Distinct(); foreach (var assembly in assemblies) { config = config.WithAssembly(assembly); } var memoryCache = serviceProvider.GetService <IMemoryCache>(); var loggerFactory = serviceProvider.GetService <ILoggerFactory>(); var env = serviceProvider.GetService <IOmnisharpEnvironment>(); var writer = serviceProvider.GetService <ISharedTextWriter>(); var applicationLifetime = serviceProvider.GetService <IApplicationLifetime>(); var loader = serviceProvider.GetService <IOmnisharpAssemblyLoader>(); config = config .WithProvider(MefValueProvider.From(serviceProvider)) .WithProvider(MefValueProvider.From <IFileSystemWatcher>(new ManualFileSystemWatcher())) .WithProvider(MefValueProvider.From(memoryCache)) .WithProvider(MefValueProvider.From(loggerFactory)) .WithProvider(MefValueProvider.From(env)) .WithProvider(MefValueProvider.From(writer)) .WithProvider(MefValueProvider.From(applicationLifetime)) .WithProvider(MefValueProvider.From(options)) .WithProvider(MefValueProvider.From(options.FormattingOptions)) .WithProvider(MefValueProvider.From(loader)) .WithProvider(MefValueProvider.From(new MetadataHelper(loader))); // other way to do singleton and autowire? if (env.TransportType == TransportType.Stdio) { config = config .WithProvider(MefValueProvider.From <IEventEmitter>(new StdioEventEmitter(writer))); } else { config = config .WithProvider(MefValueProvider.From <IEventEmitter>(new NullEventEmitter())); } if (configure != null) { config = configure(config); } var container = config.CreateContainer(); return(container); }
public FixUsingsWorker(IEnumerable <ICodeActionProvider> providers, OmniSharpOptions options) { _providers = providers; var codeFixProviders = providers.SelectMany(p => p.CodeFixProviders); _addImportProvider = FindCodeFixProviderByTypeFullName(codeFixProviders, CodeActionHelper.AddImportProviderName); _removeUnnecessaryUsingsProvider = FindCodeFixProviderByTypeFullName(codeFixProviders, CodeActionHelper.RemoveUnnecessaryUsingsProviderName); _options = options; }
private FileSystemHelper CreateFileSystemHelper(params string[] excludePatterns) { var environment = new OmniSharpEnvironment(TestAssets.Instance.TestAssetsFolder, 1000, LogLevel.Information, null); var options = new OmniSharpOptions(); options.FileOptions.ExcludeSearchPatterns = excludePatterns; var helper = new FileSystemHelper(options, environment); return(helper); }
public CancellationToken CreateCancellationToken(OmniSharpOptions omniSharpOptions, int timeout) { var enableDecompilationSupport = omniSharpOptions.RoslynExtensionsOptions.EnableDecompilationSupport; // since decompilation is slower, use a larger cancellation time (default is 2s per request) var cancellationTimeout = enableDecompilationSupport ? timeout <= 10000 ? 10000 : timeout // minimum 10s for decompilation : timeout; // request defined for metadata return(new CancellationTokenSource(cancellationTimeout).Token); }
public GetFixAllCodeActionService( OmniSharpWorkspace workspace, [ImportMany] IEnumerable <ICodeActionProvider> providers, ILoggerFactory loggerFactory, ICsDiagnosticWorker diagnostics, CachingCodeFixProviderForProjects codeFixesForProject, OmniSharpOptions options ) : base(workspace, providers, loggerFactory.CreateLogger <GetFixAllCodeActionService>(), diagnostics, codeFixesForProject, options) { }
public PackagesRestoreTool(OmniSharpOptions options, ILoggerFactory logger, IEventEmitter emitter, DnxContext context, DnxPaths paths) { _options = options; _logger = logger.CreateLogger <PackagesRestoreTool>(); _emitter = emitter; _context = context; _paths = paths; _lock = new object(); _projectLocks = new Dictionary <string, object>(); _semaphore = new SemaphoreSlim(Environment.ProcessorCount / 2); }
public PackagesRestoreTool(OmniSharpOptions options, ILoggerFactory logger, IEventEmitter emitter, DnxContext context, DotNetCorePaths paths) { _options = options; _logger = logger.CreateLogger <PackagesRestoreTool>(); _emitter = emitter; _context = context; _paths = paths; _lock = new object(); _projectLocks = new Dictionary <string, object>(); _semaphore = new SemaphoreSlim(GetNumConcurrentRestores()); }
public OptionSet Process(OptionSet currentOptionSet, OmniSharpOptions omniSharpOptions, IOmniSharpEnvironment omnisharpEnvironment) { return(currentOptionSet .WithChangedOption( OmniSharpBlockStructureOptions.ShowBlockStructureGuidesForCommentsAndPreprocessorRegions, LanguageNames.CSharp, true) .WithChangedOption( OmniSharpBlockStructureOptions.ShowOutliningForCommentsAndPreprocessorRegions, LanguageNames.CSharp, true)); }
public static async Task <string> GetFormattedText(Document document, OmniSharpOptions omnisharpOptions, ILoggerFactory loggerFactory) { var optionSet = omnisharpOptions.FormattingOptions.EnableEditorConfigSupport ? await document.Project.Solution.Workspace.Options.WithEditorConfigOptions(document.FilePath, loggerFactory) : document.Project.Solution.Workspace.Options; var newDocument = await Formatter.FormatAsync(document, optionSet); var text = await newDocument.GetTextAsync(); return(text.ToString()); }
public GotoDefinitionService( ILoggerFactory loggerFactory, ICodeSearchProvider codeSearchServiceProvider, OmniSharpWorkspace workspace, ExternalSourceServiceFactory externalSourceServiceFactory, OmniSharpOptions omnisharpOptions) { _logger = loggerFactory.CreateLogger <GotoDefinitionService>(); _codeSearchServiceProvider = codeSearchServiceProvider; _workspace = workspace; _externalSourceServiceFactory = externalSourceServiceFactory; _omnisharpOptions = omnisharpOptions; }
public AspNet5Initializer(OmnisharpWorkspace workspace, IOmnisharpEnvironment env, IOptions <OmniSharpOptions> optionsAccessor, ILoggerFactory loggerFactory, IMetadataFileReferenceCache metadataFileReferenceCache) { _workspace = workspace; _env = env; _options = optionsAccessor.Options; _logger = loggerFactory.Create <AspNet5Initializer>(); _metadataFileReferenceCache = metadataFileReferenceCache; _designTimeHostManager = new DesignTimeHostManager(loggerFactory); }
public OptionSet Process(OptionSet currentOptionSet, OmniSharpOptions omnisharpOptions, IOmniSharpEnvironment omnisharpEnvironment) { if (!omnisharpOptions.FormattingOptions.EnableEditorConfigSupport) { return(currentOptionSet); } // this is a dummy file that doesn't exist, but we simply want to tell .editorconfig to load *.cs specific settings var filePath = Path.Combine(omnisharpEnvironment.TargetDirectory, "omnisharp.cs"); var changedOptionSet = currentOptionSet.WithEditorConfigOptions(filePath, _loggerFactory).GetAwaiter().GetResult(); return(changedOptionSet); }
public OptionSet Process(OptionSet currentOptionSet, OmniSharpOptions omniSharpOptions, IOmniSharpEnvironment omnisharpEnvironment) { if (_blockStructureOptions.Value.GetField("ShowBlockStructureGuidesForCommentsAndPreprocessorRegions", BindingFlags.Public | BindingFlags.Static)?.GetValue(null) is IOption showBlockStructureGuidesForCommentsAndPreprocessorRegionsOptionValue) { currentOptionSet = currentOptionSet.WithChangedOption(new OptionKey(showBlockStructureGuidesForCommentsAndPreprocessorRegionsOptionValue, LanguageNames.CSharp), true); } if (_blockStructureOptions.Value.GetField("ShowOutliningForCommentsAndPreprocessorRegions", BindingFlags.Public | BindingFlags.Static)?.GetValue(null) is IOption showOutliningForCommentsAndPreprocessorRegionsOptionValue) { currentOptionSet = currentOptionSet.WithChangedOption(new OptionKey(showOutliningForCommentsAndPreprocessorRegionsOptionValue, LanguageNames.CSharp), true); } return(currentOptionSet); }
public RunCodeActionService( IAssemblyLoader loader, OmniSharpWorkspace workspace, CodeActionHelper helper, [ImportMany] IEnumerable <ICodeActionProvider> providers, ILoggerFactory loggerFactory, ICsDiagnosticWorker diagnostics, CachingCodeFixProviderForProjects codeFixesForProjects, OmniSharpOptions options) : base(workspace, providers, loggerFactory.CreateLogger <RunCodeActionService>(), diagnostics, codeFixesForProjects, options) { _loader = loader; _workspaceAssembly = _loader.LazyLoad(Configuration.RoslynWorkspaces); }
public AspNet5Paths(IOmnisharpEnvironment env, OmniSharpOptions options, ILoggerFactory loggerFactory) { _env = env; _options = options; _logger = loggerFactory.Create <AspNet5Paths>(); RuntimePath = GetRuntimePath(); Dnx = FirstPath(RuntimePath, "dnx", "dnx.exe"); Dnu = FirstPath(RuntimePath, "dnu", "dnu.cmd"); Klr = FirstPath(RuntimePath, "klr", "klr.exe"); Kpm = FirstPath(RuntimePath, "kpm", "kpm.cmd"); }
public OptionSet Process(OptionSet currentOptionSet, OmniSharpOptions omniSharpOptions, IOmniSharpEnvironment omnisharpEnvironment) { if (omniSharpOptions.ImplementTypeOptions.InsertionBehavior != null) { currentOptionSet = OmniSharpImplementTypeOptions.SetInsertionBehavior(currentOptionSet, LanguageNames.CSharp, (OmniSharpImplementTypeInsertionBehavior)omniSharpOptions.ImplementTypeOptions.InsertionBehavior); } if (omniSharpOptions.ImplementTypeOptions.PropertyGenerationBehavior != null) { currentOptionSet = OmniSharpImplementTypeOptions.SetPropertyGenerationBehavior(currentOptionSet, LanguageNames.CSharp, (OmniSharpImplementTypePropertyGenerationBehavior)omniSharpOptions.ImplementTypeOptions.PropertyGenerationBehavior); } return(currentOptionSet); }
public static OmniSharpTestHost Create(string path = null, ITestOutputHelper testOutput = null, IEnumerable <KeyValuePair <string, string> > configurationData = null, bool useLegacyDotNetCli = false) { var dotNetPath = Path.Combine( TestAssets.Instance.RootFolder, useLegacyDotNetCli ? ".dotnet-legacy" : ".dotnet", "dotnet"); if (!File.Exists(dotNetPath)) { dotNetPath = Path.ChangeExtension(dotNetPath, ".exe"); } if (!File.Exists(dotNetPath)) { throw new InvalidOperationException($"Local .NET CLI path does not exist. Did you run build.(ps1|sh) from the command line?"); } var builder = new ConfigurationBuilder(); builder.AddInMemoryCollection(configurationData); var configuration = builder.Build(); var environment = new OmniSharpEnvironment(path); var loggerFactory = new LoggerFactory().AddXunit(testOutput); var sharedTextWriter = new TestSharedTextWriter(testOutput); var serviceProvider = new TestServiceProvider(environment, loggerFactory, sharedTextWriter); var omnisharpOptions = new OmniSharpOptions(); ConfigurationBinder.Bind(configuration, omnisharpOptions); var compositionHost = Startup.CreateCompositionHost( serviceProvider, options: omnisharpOptions, assemblies: s_lazyAssemblies.Value); var workspace = compositionHost.GetExport <OmniSharpWorkspace>(); var logger = loggerFactory.CreateLogger <OmniSharpTestHost>(); var dotNetCli = compositionHost.GetExport <DotNetCliService>(); dotNetCli.SetDotNetPath(dotNetPath); var workspaceHelper = new WorkspaceHelper(compositionHost, configuration, omnisharpOptions, loggerFactory); workspaceHelper.Initialize(workspace); return(new OmniSharpTestHost(serviceProvider, loggerFactory, workspace, compositionHost)); }
private static async Task <Document> FormatDocument(Document document, OmniSharpOptions omnisharpOptions, ILoggerFactory loggerFactory, TextSpan?textSpan = null) { var optionSet = omnisharpOptions.FormattingOptions.EnableEditorConfigSupport ? await document.Project.Solution.Workspace.Options.WithEditorConfigOptions(document.FilePath, loggerFactory) : document.Project.Solution.Workspace.Options; var newDocument = textSpan != null ? await Formatter.FormatAsync(document, textSpan.Value, optionSet) : await Formatter.FormatAsync(document, optionSet); if (omnisharpOptions.FormattingOptions.OrganizeImports) { newDocument = await Formatter.OrganizeImportsAsync(newDocument); } return(newDocument); }
private static async Task <Document> FormatDocument(Document document, OmniSharpOptions omnisharpOptions, ILoggerFactory loggerFactory, TextSpan?textSpan = null) { // If we are not using .editorconfig for formatting options then we can avoid any overhead of calculating document options. var optionSet = omnisharpOptions.FormattingOptions.EnableEditorConfigSupport ? await document.GetOptionsAsync() : document.Project.Solution.Options; var newDocument = textSpan != null ? await Formatter.FormatAsync(document, textSpan.Value, optionSet) : await Formatter.FormatAsync(document, optionSet); if (omnisharpOptions.FormattingOptions.OrganizeImports) { newDocument = await Formatter.OrganizeImportsAsync(newDocument); } return(newDocument); }
public CsharpDiagnosticWorkerComposer( OmniSharpWorkspace workspace, [ImportMany] IEnumerable <ICodeActionProvider> providers, ILoggerFactory loggerFactory, DiagnosticEventForwarder forwarder, OmniSharpOptions options) { if (options.RoslynExtensionsOptions.EnableAnalyzersSupport) { _implementation = new CSharpDiagnosticWorkerWithAnalyzers(workspace, providers, loggerFactory, forwarder, options); } else { _implementation = new CSharpDiagnosticWorker(workspace, forwarder, loggerFactory); } }