public BlockStructureService(IAssemblyLoader loader, OmniSharpWorkspace workspace)
{
_workspace = workspace;
_loader = loader;
_featureAssembly = _loader.LazyLoad(Configuration.RoslynFeatures);
_blockStructureService = _featureAssembly.LazyGetType("Microsoft.CodeAnalysis.Structure.BlockStructureService");
_blockStructure = _featureAssembly.LazyGetType("Microsoft.CodeAnalysis.Structure.BlockStructure");
_taskOfBlockStructure = new(() => typeof(Task <>).MakeGenericType(_blockStructure.Value));
_blockSpan = _featureAssembly.LazyGetType("Microsoft.CodeAnalysis.Structure.BlockSpan");
_getBlockStructure = _blockStructureService.LazyGetMethod("GetBlockStructureAsync");
_result = _taskOfBlockStructure.LazyGetProperty("Result", getMethod: true);
_getSpans = _blockStructure.LazyGetProperty("Spans", getMethod: true);
_getIsCollpasible = _blockSpan.LazyGetProperty("IsCollapsible", getMethod: true);
_getTextSpan = _blockSpan.LazyGetProperty("TextSpan", getMethod: true);
_getType = _blockSpan.LazyGetProperty("Type", getMethod: true);
}
public static void AddCsxProjectToWorkspace(OmniSharpWorkspace workspace, TestFile testFile)
{
var references = GetReferences();
var scriptHelper = new ScriptProjectProvider(new ScriptOptions(), new OmniSharpEnvironment(), new LoggerFactory(), true);
var project = scriptHelper.CreateProject(testFile.FileName, references.Union(new[] { MetadataReference.CreateFromFile(typeof(CommandLineScriptGlobals).GetTypeInfo().Assembly.Location) }), testFile.FileName, typeof(CommandLineScriptGlobals), Enumerable.Empty <string>());
workspace.AddProject(project);
var documentInfo = DocumentInfo.Create(
id: DocumentId.CreateNewId(project.Id),
name: testFile.FileName,
sourceCodeKind: SourceCodeKind.Script,
loader: TextLoader.From(TextAndVersion.Create(testFile.Content.Text, VersionStamp.Create())),
filePath: testFile.FileName);
workspace.AddDocument(documentInfo);
}
public OmniSharpTextDocumentSyncHandler(
Mef.IRequestHandler <FileOpenRequest, FileOpenResponse> openHandler,
Mef.IRequestHandler <FileCloseRequest, FileCloseResponse> closeHandler,
Mef.IRequestHandler <UpdateBufferRequest, object> bufferHandler,
DocumentSelector documentSelector,
TextDocumentSyncKind documentSyncKind,
OmniSharpWorkspace workspace,
DocumentVersions documentVersions)
{
_openHandler = openHandler;
_closeHandler = closeHandler;
_bufferHandler = bufferHandler;
_documentSelector = documentSelector;
_documentSyncKind = documentSyncKind;
_workspace = workspace;
_documentVersions = documentVersions;
}
public OmniSharpTextDocumentSyncHandler(
Mef.IRequestHandler <FileOpenRequest, FileOpenResponse> openHandler,
Mef.IRequestHandler <FileCloseRequest, FileCloseResponse> closeHandler,
Mef.IRequestHandler <UpdateBufferRequest, object> bufferHandler,
DocumentSelector documentSelector,
TextDocumentSyncKind documentSyncKind,
OmniSharpWorkspace workspace)
: base(documentSyncKind, new TextDocumentSaveRegistrationOptions()
{
DocumentSelector = documentSelector,
IncludeText = true,
})
{
_openHandler = openHandler;
_closeHandler = closeHandler;
_bufferHandler = bufferHandler;
_workspace = workspace;
}
private static async Task <Range> TranslateAsync(this Range range, OmniSharpWorkspace workspace, SimpleFileRequest request)
{
var(line, _) = await LineIndexHelper.TranslateFromGenerated(request.FileName, range.Start.Line, workspace, true);
if (range.Start.Line == range.End.Line)
{
range.Start.Line = line;
range.End.Line = line;
return(range);
}
range.Start.Line = line;
(line, _) = await LineIndexHelper.TranslateFromGenerated(request.FileName, range.End.Line, workspace, true);
range.End.Line = line;
return(range);
}
public ProjectManager(ILoggerFactory loggerFactory, IEventEmitter eventEmitter, IFileSystemWatcher fileSystemWatcher, MetadataFileReferenceCache metadataFileReferenceCache, PackageDependencyChecker packageDependencyChecker, ProjectLoader projectLoader, OmniSharpWorkspace workspace)
{
_logger = loggerFactory.CreateLogger <ProjectManager>();
_eventEmitter = eventEmitter;
_fileSystemWatcher = fileSystemWatcher;
_metadataFileReferenceCache = metadataFileReferenceCache;
_packageDependencyChecker = packageDependencyChecker;
_projectFiles = new ProjectFileInfoCollection();
_failedToLoadProjectFiles = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_projectLoader = projectLoader;
_workspace = workspace;
_queue = new BufferBlock <ProjectToUpdate>();
_processLoopCancellation = new CancellationTokenSource();
_processLoopTask = Task.Run(() => ProcessLoopAsync(_processLoopCancellation.Token));
_onDirectoryFileChanged = OnDirectoryFileChanged;
}
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);
}
_workspace = workspace;
}
public CakeProjectSystem(
OmniSharpWorkspace workspace,
MetadataFileReferenceCache metadataReferenceCache,
IOmniSharpEnvironment environment,
IAssemblyLoader assemblyLoader,
ICakeScriptService scriptService,
ILoggerFactory loggerFactory)
{
_workspace = workspace ?? throw new ArgumentNullException(nameof(workspace));
_metadataReferenceCache = metadataReferenceCache ?? throw new ArgumentNullException(nameof(metadataReferenceCache));
_environment = environment ?? throw new ArgumentNullException(nameof(environment));
_assemblyLoader = assemblyLoader ?? throw new ArgumentNullException(nameof(assemblyLoader));
_scriptService = scriptService ?? throw new ArgumentNullException(nameof(scriptService));
_logger = loggerFactory?.CreateLogger <CakeProjectSystem>() ?? throw new ArgumentNullException(nameof(loggerFactory));
_projects = new Dictionary <string, ProjectInfo>();
_compilationOptions = new Lazy <CSharpCompilationOptions>(CreateCompilationOptions);
}
public static IEnumerable <ProjectId> AddProjectToWorkspace(OmniSharpWorkspace workspace, string filePath, string[] frameworks, TestFile[] testFiles, ImmutableArray <AnalyzerReference> analyzerRefs = default, string languageName = LanguageNames.CSharp)
{
var versionStamp = VersionStamp.Create();
var references = GetReferences();
frameworks = frameworks ?? new[] { string.Empty };
var projectsIds = new List <ProjectId>();
var editorConfigPaths = EditorConfigFinder.GetEditorConfigPaths(filePath);
foreach (var framework in frameworks)
{
var projectId = ProjectId.CreateNewId();
var analyzerConfigDocuments = editorConfigPaths.Select(path =>
DocumentInfo.Create(
DocumentId.CreateNewId(projectId),
name: ".editorconfig",
loader: new FileTextLoader(path, Encoding.UTF8),
filePath: path))
.ToImmutableArray();
var projectInfo = ProjectInfo.Create(
id: projectId,
version: versionStamp,
name: "OmniSharp+" + framework,
assemblyName: "AssemblyName",
language: languageName,
filePath: filePath,
metadataReferences: references,
analyzerReferences: analyzerRefs)
.WithDefaultNamespace("OmniSharpTest")
.WithAnalyzerConfigDocuments(analyzerConfigDocuments);
workspace.AddProject(projectInfo);
foreach (var testFile in testFiles)
{
workspace.AddDocument(projectInfo.Id, testFile.FileName, TextLoader.From(TextAndVersion.Create(testFile.Content.Text, versionStamp)), SourceCodeKind.Regular);
}
projectsIds.Add(projectInfo.Id);
}
return(projectsIds);
}
public static IEnumerable <IJsonRpcHandler> Enumerate(
RequestHandlers handlers,
OmniSharpWorkspace workspace)
{
foreach (var(selector, openHandler, closeHandler, bufferHandler) in handlers
.OfType <
Mef.IRequestHandler <FileOpenRequest, FileOpenResponse>,
Mef.IRequestHandler <FileCloseRequest, FileCloseResponse>,
Mef.IRequestHandler <UpdateBufferRequest, object> >())
{
// TODO: Fix once cake has working support for incremental
var documentSyncKind = TextDocumentSyncKind.Incremental;
if (selector.ToString().IndexOf(".cake") > -1)
{
documentSyncKind = TextDocumentSyncKind.Full;
}
yield return(new OmniSharpTextDocumentSyncHandler(openHandler, closeHandler, bufferHandler, selector, documentSyncKind, workspace));
}
}
public DotNetProjectSystem(
IOmniSharpEnvironment environment,
OmniSharpWorkspace workspace,
IDotNetCliService dotNetCliService,
MetadataFileReferenceCache metadataFileReferenceCache,
IEventEmitter eventEmitter,
IFileSystemWatcher fileSystemWatcher,
ILoggerFactory loggerFactory)
{
_environment = environment;
_workspace = workspace;
_dotNetCliService = dotNetCliService;
_metadataFileReferenceCache = metadataFileReferenceCache;
_eventEmitter = eventEmitter;
_fileSystemWatcher = fileSystemWatcher;
_logger = loggerFactory.CreateLogger <DotNetProjectSystem>();
_projectStates = new ProjectStatesCache(loggerFactory, _eventEmitter);
}
private async Task <IEnumerable <ISymbol> > SymbolsFromQuickFixesAsync(OmniSharpWorkspace workspace, IEnumerable <QuickFix> quickFixes)
{
var symbols = new List <ISymbol>();
foreach (var quickfix in quickFixes)
{
var document = workspace.GetDocument(quickfix.FileName);
var sourceText = await document.GetTextAsync();
var position = sourceText.Lines.GetPosition(new LinePosition(quickfix.Line, quickfix.Column));
var semanticModel = await document.GetSemanticModelAsync();
var symbol = await SymbolFinder.FindSymbolAtPositionAsync(semanticModel, position, workspace);
symbols.Add(symbol);
}
return(symbols);
}
public void ProvideOptions(OmniSharpWorkspace workspace, OmniSharpOptions options)
{
// run all workspace options providers discovered with MEF
foreach (var workspaceOptionsProvider in _compositionHost.GetExports <IWorkspaceOptionsProvider>())
{
var providerName = workspaceOptionsProvider.GetType().FullName;
try
{
_logger.LogInformation($"Invoking Workspace Options Provider: {providerName}");
workspace.Options = workspaceOptionsProvider.Process(workspace.Options, options.FormattingOptions);
}
catch (Exception e)
{
var message = $"The workspace options provider '{providerName}' threw exception during initialization.";
_logger.LogError(e, message);
}
}
}
public static async Task <NavigateResponse> Navigate(OmniSharpWorkspace workspace, Request request, Func <FileMemberElement, FileMemberElement, Request, bool> IsCloserNode)
{
var stack = new List <FileMemberElement>(await StructureComputer.Compute(workspace.GetDocuments(request.FileName)));
var response = new NavigateResponse();
//Retain current line in case we dont need to navigate.
response.Line = request.Line;
response.Column = request.Column;
FileMemberElement closestNode = null;
FileMemberElement thisNode = null;
while (stack.Count > 0)
{
var node = stack[0];
stack.Remove(node);
var isCloserNode = IsCloserNode(node, closestNode, request);
if (isCloserNode)
{
closestNode = node;
}
if (node.Location.Line == request.Line)
{
thisNode = node;
}
stack.AddRange(node.ChildNodes);
}
//If there is a closest node, use its line and column.
//or if we are on the last node, adjust column.
//if we are above the first or below the last node, do nothing.
if (closestNode != null)
{
response.Line = closestNode.Location.Line;
response.Column = closestNode.Location.Column;
}
else if (thisNode != null)
{
response.Column = thisNode.Location.Column;
}
return(response);
}
private static OmniSharpWorkspace CreateSimpleWorkspace(string fileName, string contents)
{
var workspace = new OmniSharpWorkspace(
new HostServicesAggregator(
Enumerable.Empty <IHostServicesProvider>(), new LoggerFactory()),
new LoggerFactory());
var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Create(),
"ProjectNameVal", "AssemblyNameVal", LanguageNames.CSharp);
var documentInfo = DocumentInfo.Create(DocumentId.CreateNewId(projectInfo.Id), fileName,
null, SourceCodeKind.Regular,
TextLoader.From(TextAndVersion.Create(SourceText.From(contents), VersionStamp.Create())),
fileName);
workspace.AddProject(projectInfo);
workspace.AddDocument(documentInfo);
return(workspace);
}
private static async Task <QuickFix> TranslateAsync(this QuickFix quickFix, OmniSharpWorkspace workspace, Request request)
{
var sameFile = string.IsNullOrEmpty(quickFix.FileName);
var fileName = !sameFile ? quickFix.FileName : request.FileName;
if (string.IsNullOrEmpty(fileName))
{
return(quickFix);
}
var(line, newFileName) = await LineIndexHelper.TranslateFromGenerated(fileName, quickFix.Line, workspace, sameFile);
quickFix.Line = line;
quickFix.FileName = newFileName;
(line, _) = await LineIndexHelper.TranslateFromGenerated(fileName, quickFix.EndLine, workspace, sameFile);
quickFix.EndLine = line;
return(quickFix);
}
protected BaseCodeActionService(OmniSharpWorkspace workspace, CodeActionHelper helper, IEnumerable <ICodeActionProvider> providers, ILogger logger)
{
this.Workspace = workspace;
this.Providers = providers;
this.Logger = logger;
this._helper = helper;
// Sadly, the CodeAction.NestedCodeActions property is still internal.
var nestedCodeActionsProperty = typeof(CodeAction).GetProperty("NestedCodeActions", BindingFlags.NonPublic | BindingFlags.Instance);
if (nestedCodeActionsProperty == null)
{
throw new InvalidOperationException("Could not find CodeAction.NestedCodeActions property.");
}
this._getNestedCodeActions = nestedCodeActionsProperty.GetGetMethod(nonPublic: true);
if (this._getNestedCodeActions == null)
{
throw new InvalidOperationException("Could not retrieve 'get' method for CodeAction.NestedCodeActions property.");
}
}
public static IEnumerable <ProjectId> AddProjectToWorkspace(OmniSharpWorkspace workspace, string filePath, string[] frameworks, TestFile[] testFiles, ImmutableArray <AnalyzerReference> analyzerRefs = default)
{
var versionStamp = VersionStamp.Create();
var references = GetReferences();
frameworks = frameworks ?? new[] { string.Empty };
var projectsIds = new List <ProjectId>();
foreach (var framework in frameworks)
{
var projectInfo = ProjectInfo.Create(
id: ProjectId.CreateNewId(),
version: versionStamp,
name: "OmniSharp+" + framework,
assemblyName: "AssemblyName",
language: LanguageNames.CSharp,
filePath: filePath,
metadataReferences: references,
analyzerReferences: analyzerRefs);
workspace.AddProject(projectInfo);
foreach (var testFile in testFiles)
{
var documentInfo = DocumentInfo.Create(
id: DocumentId.CreateNewId(projectInfo.Id),
name: testFile.FileName,
sourceCodeKind: SourceCodeKind.Regular,
loader: TextLoader.From(TextAndVersion.Create(testFile.Content.Text, versionStamp)),
filePath: testFile.FileName);
workspace.AddDocument(documentInfo);
}
projectsIds.Add(projectInfo.Id);
}
return(projectsIds);
}
public MSBuildProjectSystem(
IOmniSharpEnvironment environment,
OmniSharpWorkspace workspace,
DotNetCliService dotNetCliService,
MetadataFileReferenceCache metadataFileReferenceCache,
IEventEmitter eventEmitter,
IFileSystemWatcher fileSystemWatcher,
ILoggerFactory loggerFactory)
{
_environment = environment;
_workspace = workspace;
_dotNetCli = dotNetCliService;
_metadataFileReferenceCache = metadataFileReferenceCache;
_eventEmitter = eventEmitter;
_fileSystemWatcher = fileSystemWatcher;
_loggerFactory = loggerFactory;
_projects = new ProjectFileInfoCollection();
_projectsToProcess = new Queue <ProjectFileInfo>();
_logger = loggerFactory.CreateLogger <MSBuildProjectSystem>();
_packageDepedencyResolver = new PackageDependencyResolver(loggerFactory);
}
public async Task UpdateBufferFindsProjectBasedOnNearestPath()
{
var workspace = new OmniSharpWorkspace(
new HostServicesAggregator(
Enumerable.Empty <IHostServicesProvider>(), new LoggerFactory()),
new LoggerFactory());
TestHelpers.AddProjectToWorkspace(workspace,
filePath: Path.Combine("src", "root", "foo.csproj"),
frameworks: null,
testFiles: new[] { new TestFile(Path.Combine("src", "root", "foo.cs"), "class C1 {}") });
TestHelpers.AddProjectToWorkspace(workspace,
filePath: Path.Combine("src", "root", "foo", "bar", "insane.csproj"),
frameworks: null,
testFiles: new [] { new TestFile(Path.Combine("src", "root", "foo", "bar", "nested", "code.cs"), "class C2 {}") });
await workspace.BufferManager.UpdateBufferAsync(new Request()
{
FileName = Path.Combine("src", "root", "bar.cs"), Buffer = "enum E {}"
});
var documents = workspace.GetDocuments(Path.Combine("src", "root", "bar.cs"));
Assert.Single(documents);
Assert.Equal(Path.Combine("src", "root", "foo.csproj"), documents.ElementAt(0).Project.FilePath);
Assert.Equal(2, documents.ElementAt(0).Project.Documents.Count());
await workspace.BufferManager.UpdateBufferAsync(new Request()
{
FileName = Path.Combine("src", "root", "foo", "bar", "nested", "paths", "dance.cs"), Buffer = "enum E {}"
});
documents = workspace.GetDocuments(Path.Combine("src", "root", "foo", "bar", "nested", "paths", "dance.cs"));
Assert.Single(documents);
Assert.Equal(Path.Combine("src", "root", "foo", "bar", "insane.csproj"), documents.ElementAt(0).Project.FilePath);
Assert.Equal(2, documents.ElementAt(0).Project.Documents.Count());
}
public ProjectManager(
ILoggerFactory loggerFactory,
MSBuildOptions options,
IEventEmitter eventEmitter,
IFileSystemWatcher fileSystemWatcher,
MetadataFileReferenceCache metadataFileReferenceCache,
PackageDependencyChecker packageDependencyChecker,
ProjectLoader projectLoader,
OmniSharpWorkspace workspace,
IAnalyzerAssemblyLoader analyzerAssemblyLoader,
ImmutableArray <IMSBuildEventSink> eventSinks,
DotNetInfo dotNetInfo)
{
_logger = loggerFactory.CreateLogger <ProjectManager>();
_options = options ?? new MSBuildOptions();
_eventEmitter = eventEmitter;
_fileSystemWatcher = fileSystemWatcher;
_metadataFileReferenceCache = metadataFileReferenceCache;
_packageDependencyChecker = packageDependencyChecker;
_projectFiles = new ProjectFileInfoCollection();
_failedToLoadProjectFiles = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_projectsRequestedOnDemand = new ConcurrentDictionary <string, int>(StringComparer.OrdinalIgnoreCase);
_projectLoader = projectLoader;
_workspace = workspace;
_eventSinks = eventSinks;
_dotNetInfo = dotNetInfo;
_queue = new BufferBlock <ProjectToUpdate>();
_processLoopCancellation = new CancellationTokenSource();
_processLoopTask = Task.Run(() => ProcessLoopAsync(_processLoopCancellation.Token));
_analyzerAssemblyLoader = analyzerAssemblyLoader;
_onDirectoryFileChanged = OnDirectoryFileChanged;
if (_options.LoadProjectsOnDemand)
{
_workspace.AddWaitForProjectModelReadyHandler(WaitForProjectModelReadyAsync);
}
}
public ProjectSystem(
IOmniSharpEnvironment environment,
OmniSharpWorkspace workspace,
IMSBuildLocator msbuildLocator,
DotNetCliService dotNetCliService,
SdksPathResolver sdksPathResolver,
MetadataFileReferenceCache metadataFileReferenceCache,
IEventEmitter eventEmitter,
IFileSystemWatcher fileSystemWatcher,
ILoggerFactory loggerFactory)
{
_environment = environment;
_workspace = workspace;
_propertyOverrides = msbuildLocator.RegisteredInstance.PropertyOverrides;
_dotNetCli = dotNetCliService;
_sdksPathResolver = sdksPathResolver;
_metadataFileReferenceCache = metadataFileReferenceCache;
_eventEmitter = eventEmitter;
_fileSystemWatcher = fileSystemWatcher;
_loggerFactory = loggerFactory;
_projectsToProcess = new Queue <ProjectFileInfo>();
_logger = loggerFactory.CreateLogger <ProjectSystem>();
}
private static OmniSharpWorkspace GetWorkspaceWithProjects()
{
var workspace = new OmniSharpWorkspace(
new HostServicesAggregator(
Enumerable.Empty <IHostServicesProvider>(), new LoggerFactory()));
TestHelpers.AddProjectToWorkspace(workspace,
filePath: Path.Combine("src", "project.json"),
frameworks: new[] { "dnx451", "dnxcore50" },
testFiles: new [] { new TestFile(Path.Combine("src", "a.cs"), "class C {}") });
TestHelpers.AddProjectToWorkspace(workspace,
filePath: Path.Combine("test", "project.json"),
frameworks: new[] { "dnx451", "dnxcore50" },
testFiles: new [] { new TestFile(Path.Combine("test", "b.cs"), "class C {}") });
Assert.Equal(4, workspace.CurrentSolution.Projects.Count());
foreach (var project in workspace.CurrentSolution.Projects)
{
Assert.Single(project.Documents);
}
return(workspace);
}
public CSharpDiagnosticWorker(OmniSharpWorkspace workspace, DiagnosticEventForwarder forwarder, ILoggerFactory loggerFactory)
{
_workspace = workspace;
_forwarder = forwarder;
_logger = loggerFactory.CreateLogger <CSharpDiagnosticWorker>();
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 FormatAfterKeystrokeService(OmniSharpWorkspace workspace, OmniSharpOptions omnisharpOptions)
{
_workspace = workspace;
_omnisharpOptions = omnisharpOptions;
}
public FindImplementationsService(OmniSharpWorkspace workspace)
{
_workspace = workspace;
}
public AutoCompleteHandler(OmniSharpWorkspace workspace)
: base(workspace)
{
}
public static async Task <(int, string)> TranslateFromGenerated(string fileName, int index, OmniSharpWorkspace workspace, bool sameFile)
{
if (string.IsNullOrEmpty(fileName))
{
return(-1, fileName);
}
var document = workspace.GetDocument(fileName);
if (document == null)
{
return(-1, fileName);
}
var sourceText = await document.GetTextAsync();
if (index > sourceText.Lines.Count)
{
return(-1, fileName);
}
var syntaxTree = await document.GetSyntaxTreeAsync(CancellationToken.None);
if (syntaxTree == null)
{
return(-1, fileName);
}
var point = new Point {
Column = 0, Line = index
};
var textSpan = sourceText.GetSpanFromRange(new Range
{
Start = point,
End = point
});
var lineMapping = syntaxTree.GetMappedLineSpan(textSpan);
if (sameFile && !PathsAreEqual(lineMapping.Path, fileName))
{
return(-1, fileName);
}
return(lineMapping.StartLinePosition.Line, PlatformHelper.IsWindows ? lineMapping.Path.Replace('/', '\\') : lineMapping.Path);
}
public static async Task <int> TranslateToGenerated(string fileName, int index, OmniSharpWorkspace workspace)
{
if (string.IsNullOrEmpty(fileName))
{
return(index);
}
var document = workspace.GetDocument(fileName);
if (document == null)
{
return(index);
}
var sourceText = await document.GetTextAsync();
var root = await document.GetSyntaxRootAsync();
for (var i = sourceText.Lines.Count - 1; i >= 0; i--)
{
var line = sourceText.Lines[i];
if (!line.StartsWith("#line "))
{
continue;
}
if (!(root.FindNode(line.Span, true) is LineDirectiveTriviaSyntax lineDirective) ||
lineDirective.Line.IsMissing ||
!PathsAreEqual((string)lineDirective.File.Value, fileName))
{
continue;
}
var lineDirectiveValue = (int)lineDirective.Line.Value - 1;
if (index < lineDirectiveValue)
{
continue;
}
return(line.LineNumber - lineDirectiveValue + index + 1);
}
return(index);
}
public GotoRegionService(OmniSharpWorkspace workspace)
{
_workspace = workspace;
}
