metadata as source v1

Author: MattParkerDev

src/SharpIDE.Application/DependencyInjection.cs

@@ -39,6 +39,7 @@ public static IServiceCollection AddApplication(this IServiceCollection services
 		services.AddScoped<SharpIdeSolutionModificationService>();
 		services.AddScoped<AnalyzerFileWatcher>();
 		services.AddScoped<EditorCaretPositionService>();
+		services.AddScoped<SharpIdeMetadataAsSourceService>();
 		services.AddLogging();
 		return services;
 	}

src/SharpIDE.Application/Features/Analysis/RoslynAnalysis.cs

@@ -10,10 +10,12 @@
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.Completion;
+using Microsoft.CodeAnalysis.CSharp.DecompiledSource;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.FindSymbols;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.MetadataAsSource;
 using Microsoft.CodeAnalysis.MSBuild;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.PooledObjects;
@@ -60,6 +62,7 @@ public partial class RoslynAnalysis(ILogger<RoslynAnalysis> logger, BuildService
 	private static ICodeFixService? _codeFixService;
 	private static ICodeRefactoringService? _codeRefactoringService;
 	private static IDocumentMappingService? _documentMappingService;
+	private static IMetadataAsSourceFileService _metadataAsSourceFileService = null!;
 	private static SignatureHelpService _signatureHelpService = null!;
 	private static HashSet<CodeRefactoringProvider> _codeRefactoringProviders = [];
 	private static HashSet<CodeFixProvider> _codeFixProviders = [];
@@ -97,6 +100,7 @@ public async Task LoadSolutionInWorkspace(SharpIdeSolutionModel solutionModel, C
 			var configuration = new ContainerConfiguration()
 				.WithAssemblies(MefHostServices.DefaultAssemblies)
 				.WithAssembly(typeof(RemoteSnapshotManager).Assembly)
+				.WithPart<CSharpDecompilationService2>()
 				.WithPart<PythiaStub>();
 
 			// TODO: dispose container at some point?
@@ -112,7 +116,8 @@ public async Task LoadSolutionInWorkspace(SharpIdeSolutionModel solutionModel, C
 			_codeFixService = container.GetExports<ICodeFixService>().FirstOrDefault();
 			_codeRefactoringService = container.GetExports<ICodeRefactoringService>().FirstOrDefault();
 			_signatureHelpService = container.GetExports<SignatureHelpService>().FirstOrDefault()!;
-
+			// TODO: Write an implementation of ISourceLinkService, as MS's implementation does not appear to be open source
+			_metadataAsSourceFileService = container.GetExports<IMetadataAsSourceFileService>().FirstOrDefault()!;
 			_semanticTokensLegendService = (RemoteSemanticTokensLegendService)container.GetExports<ISemanticTokensLegendService>().FirstOrDefault()!;
 			_semanticTokensLegendService!.OnLspInitialized(new RemoteClientLSPInitializationOptions
 			{
@@ -400,6 +405,7 @@ public async Task<ImmutableArray<SharpIdeDiagnostic>> GetProjectDiagnosticsForFi
 	public async Task<ImmutableArray<SharpIdeDiagnostic>> GetDocumentDiagnostics(SharpIdeFile fileModel, CancellationToken cancellationToken = default)
 	{
 		if (fileModel.IsRoslynWorkspaceFile is false) return [];
+		if (fileModel.IsMetadataAsSourceFile) return []; // Due to the current nature of IMetadataAsSourceFileService, which only decompiles a single document (not the whole project), if this was enabled, we would get error diagnostics for missing references to other "files" in the same dll
 		using var _ = SharpIdeOtel.Source.StartActivity($"{nameof(RoslynAnalysis)}.{nameof(GetDocumentDiagnostics)}");
 		await _solutionLoadedTcs.Task;
 
@@ -424,6 +430,7 @@ public async Task<ImmutableArray<SharpIdeDiagnostic>> GetDocumentDiagnostics(Sha
 	public async Task<ImmutableArray<SharpIdeDiagnostic>> GetDocumentAnalyzerDiagnostics(SharpIdeFile fileModel, CancellationToken cancellationToken = default)
 	{
 		if (fileModel.IsRoslynWorkspaceFile is false) return [];
+		if (fileModel.IsMetadataAsSourceFile) return []; // Decompiled/SourceLink files should not/will not have analyzers
 		using var _ = SharpIdeOtel.Source.StartActivity($"{nameof(RoslynAnalysis)}.{nameof(GetDocumentAnalyzerDiagnostics)}");
 		await _solutionLoadedTcs.Task;
 
@@ -599,6 +606,7 @@ public async Task<ImmutableArray<SharpIdeClassifiedSpan>> GetDocumentSyntaxHighl
 		var root = await syntaxTree!.GetRootAsync(cancellationToken);
 
 		var classifiedSpans = await Classifier.GetClassifiedSpansAsync(document, root.FullSpan, cancellationToken);
+		//var classifiedSpans = await ClassifierHelper.GetClassifiedSpansAsync(document, root.FullSpan, ClassificationOptions.Default, true, cancellationToken);
 		var result = classifiedSpans.Select(s => new SharpIdeClassifiedSpan(syntaxTree.GetMappedLineSpan(s.TextSpan).Span, s)).ToImmutableArray();
 		return result;
 	}
@@ -978,6 +986,23 @@ public async Task<ImmutableArray<IdeReferenceLocationResult>> GetIdeReferenceLoc
 		return changedFilesWithText;
 	}
 
+	public async Task<string?> GetMetadataAsSource(SharpIdeFile currentFile, ISymbol symbol, CancellationToken cancellationToken = default)
+	{
+		using var _ = SharpIdeOtel.Source.StartActivity($"{nameof(RoslynAnalysis)}.{nameof(FindAllSymbolReferences)}");
+		await _solutionLoadedTcs.Task;
+		if (_metadataAsSourceFileService.IsNavigableMetadataSymbol(symbol) is false) return null;
+
+		var documentContainingMetadataReference = await GetDocumentForSharpIdeFile(currentFile, cancellationToken);
+
+		var options = MetadataAsSourceOptions.Default;// with { NavigateToSourceLinkAndEmbeddedSources = false };
+		var metadataAsSourceFile = await _metadataAsSourceFileService.GetGeneratedFileAsync(_workspace!, documentContainingMetadataReference.Project, symbol, false, options, cancellationToken);
+		Console.WriteLine(metadataAsSourceFile.FilePath);
+		var metadataAsSourceWorkspace = _metadataAsSourceFileService.TryGetWorkspace();
+		var documentId = metadataAsSourceWorkspace!.CurrentSolution.GetDocumentIdsWithFilePath(metadataAsSourceFile.FilePath).SingleOrDefault();
+		var document = metadataAsSourceWorkspace.CurrentSolution.GetDocument(documentId);
+		return document?.FilePath;
+	}
+
 	public async Task<ImmutableArray<ReferencedSymbol>> FindAllSymbolReferences(ISymbol symbol, CancellationToken cancellationToken = default)
 	{
 		using var _ = SharpIdeOtel.Source.StartActivity($"{nameof(RoslynAnalysis)}.{nameof(FindAllSymbolReferences)}");
@@ -1321,6 +1346,14 @@ private static SharpIdeProjectModel GetSharpIdeProjectForSharpIdeFile(SharpIdeFi
 
 	private static Project GetProjectForSharpIdeFile(SharpIdeFile sharpIdeFile)
 	{
+		if (sharpIdeFile.IsMetadataAsSourceFile)
+		{
+			var metadataAsSourceWorkspace = _metadataAsSourceFileService.TryGetWorkspace() ?? throw new InvalidOperationException("Metadata as source workspace is not available");
+			var documentId = metadataAsSourceWorkspace.CurrentSolution.GetDocumentIdsWithFilePath(sharpIdeFile.Path).SingleOrDefault() ?? throw new InvalidOperationException($"Document with path '{sharpIdeFile.Path}' not found in metadata as source workspace");
+			var document = metadataAsSourceWorkspace.CurrentSolution.GetDocument(documentId) ?? throw new InvalidOperationException($"Document with id '{documentId}' not found in metadata as source workspace");
+			var metadataAsSourceProject = document.Project;
+			return metadataAsSourceProject;
+		}
 		var sharpIdeProjectModel = GetSharpIdeProjectForSharpIdeFile(sharpIdeFile);
 		var project = GetProjectForSharpIdeProjectModel(sharpIdeProjectModel);
 		return project;

src/SharpIDE.Application/Features/Analysis/SharpIdeMetadataAsSourceService.cs

@@ -0,0 +1,17 @@
+using Microsoft.CodeAnalysis;
+using SharpIDE.Application.Features.SolutionDiscovery;
+
+namespace SharpIDE.Application.Features.Analysis;
+
+public class SharpIdeMetadataAsSourceService(RoslynAnalysis roslynAnalysis)
+{
+	private readonly RoslynAnalysis _roslynAnalysis = roslynAnalysis;
+
+	public async Task<SharpIdeFile?> CreateSharpIdeFileForMetadataAsSourceAsync(SharpIdeFile currentFile, ISymbol referencedSymbol)
+	{
+		var filePath = await _roslynAnalysis.GetMetadataAsSource(currentFile, referencedSymbol);
+		if (filePath is null) return null;
+		var metadataAsSourceSharpIdeFile = new SharpIdeFile(filePath, Path.GetFileName(filePath), Path.GetExtension(filePath), null!, [], true);
+		return metadataAsSourceSharpIdeFile;
+	}
+}

src/SharpIDE.Application/Features/Analysis/WorkspaceServices/CSharpDecompilationService2.cs

@@ -0,0 +1,86 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Composition;
+using System.Diagnostics;
+using System.Reflection.PortableExecutable;
+using System.Runtime.CompilerServices;
+using System.Text;
+using ICSharpCode.Decompiler;
+using ICSharpCode.Decompiler.CSharp;
+using ICSharpCode.Decompiler.CSharp.Transforms;
+using ICSharpCode.Decompiler.Metadata;
+using ICSharpCode.Decompiler.TypeSystem;
+using Microsoft.CodeAnalysis.DecompiledSource;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.CSharp.DecompiledSource;
+
+[ExportLanguageService(typeof(IDecompilationService), LanguageNames.CSharp), Shared]
+internal sealed class CSharpDecompilationService2 : IDecompilationService
+{
+	private static readonly Version s_decompilerVersion2 = typeof(CSharpDecompiler).Assembly.GetName().Version ?? throw new ArgumentNullException();
+
+    [ImportingConstructor]
+    [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+    public CSharpDecompilationService2()
+    {
+    }
+
+    public FileVersionInfo GetDecompilerVersion()
+    {
+	    // workaround until https://github.com/dotnet/roslyn/pull/82490 is merged
+	    var fileVersionInfo = (FileVersionInfo)RuntimeHelpers.GetUninitializedObject(typeof(FileVersionInfo));
+	    var fileVersionField = typeof(FileVersionInfo).GetField("_fileVersion", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+	    fileVersionField?.SetValue(fileVersionInfo, s_decompilerVersion2.ToString());
+	    return fileVersionInfo;
+    }
+
+    public Document? PerformDecompilation(Document document, string fullName, Compilation compilation, MetadataReference? metadataReference, string? assemblyLocation)
+    {
+        var logger = new StringBuilder();
+        var resolver = new AssemblyResolver(compilation, logger);
+
+        // Load the assembly.
+        PEFile? file = null;
+        if (metadataReference is not null)
+            file = resolver.TryResolve(metadataReference, PEStreamOptions.PrefetchEntireImage);
+
+        if (file is null && assemblyLocation is not null)
+            file = new PEFile(assemblyLocation, PEStreamOptions.PrefetchEntireImage);
+
+        if (file is null)
+            return null;
+
+        using (file)
+        {
+            // Initialize a decompiler with default settings.
+            var decompiler = new CSharpDecompiler(file, resolver, new DecompilerSettings());
+            // Escape invalid identifiers to prevent Roslyn from failing to parse the generated code.
+            // (This happens for example, when there is compiler-generated code that is not yet recognized/transformed by the decompiler.)
+            decompiler.AstTransforms.Add(new EscapeInvalidIdentifiers());
+
+            var fullTypeName = new FullTypeName(fullName);
+
+            // ILSpy only allows decompiling a type that comes from the 'Main Module'.  They will throw on anything
+            // else.  Prevent this by doing this quick check corresponding to:
+            // https://github.com/icsharpcode/ILSpy/blob/4ebe075e5859939463ae420446f024f10c3bf077/ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs#L978
+            var type = decompiler.TypeSystem.MainModule.GetTypeDefinition(fullTypeName);
+            if (type is null)
+                return null;
+
+            // Try to decompile; if an exception is thrown the caller will handle it
+            var text = decompiler.DecompileTypeAsString(fullTypeName);
+
+            text += "#if false // " + FeaturesResources.Decompilation_log + Environment.NewLine;
+            text += logger.ToString();
+            text += "#endif" + Environment.NewLine;
+
+            return document.WithText(SourceText.From(text, encoding: null, checksumAlgorithm: SourceHashAlgorithms.Default));
+        }
+    }
+}

src/SharpIDE.Application/Features/SolutionDiscovery/SharpIdeFile.cs

@@ -18,6 +18,7 @@ public class SharpIdeFile : ISharpIdeNode, IChildSharpIdeNode, IFileOrFolder
 	public bool IsCshtmlFile => Path.EndsWith(".cshtml", StringComparison.OrdinalIgnoreCase);
 	public bool IsCsharpFile => Path.EndsWith(".cs", StringComparison.OrdinalIgnoreCase);
 	public bool IsRoslynWorkspaceFile => IsCsharpFile || IsRazorFile || IsCshtmlFile;
+	public bool IsMetadataAsSourceFile { get; set; }
 	public GitFileStatus GitStatus { get; set; } = GitFileStatus.Unaltered;
 	public required ReactiveProperty<bool> IsDirty { get; init; }
 	public required bool SuppressDiskChangeEvents { get; set; } // probably has concurrency issues
@@ -26,14 +27,15 @@ public class SharpIdeFile : ISharpIdeNode, IChildSharpIdeNode, IFileOrFolder
 	public EventWrapper<Task> FileDeleted { get; } = new(() => Task.CompletedTask);
 
 	[SetsRequiredMembers]
-	internal SharpIdeFile(string fullPath, string name, string extension, IExpandableSharpIdeNode parent, ConcurrentBag<SharpIdeFile> allFiles)
+	internal SharpIdeFile(string fullPath, string name, string extension, IExpandableSharpIdeNode parent, ConcurrentBag<SharpIdeFile> allFiles, bool isMetadataAsSourceFile = false)
 	{
 		Path = fullPath;
 		Name = name;
 		Extension = extension;
 		Parent = parent;
 		IsDirty = new ReactiveProperty<bool>(false);
 		SuppressDiskChangeEvents = false;
+		IsMetadataAsSourceFile = isMetadataAsSourceFile;
 		allFiles.Add(this);
 	}
 }

src/SharpIDE.Godot/Features/CodeEditor/SharpIdeCodeEdit.cs

@@ -58,6 +58,7 @@ public partial class SharpIdeCodeEdit : CodeEdit
     [Inject] private readonly IdeApplyCompletionService _ideApplyCompletionService = null!;
     [Inject] private readonly IdeNavigationHistoryService _navigationHistoryService = null!;
     [Inject] private readonly EditorCaretPositionService _editorCaretPositionService = null!;
+    [Inject] private readonly SharpIdeMetadataAsSourceService _sharpIdeMetadataAsSourceService = null!;
 
 	public SharpIdeCodeEdit()
 	{
@@ -333,6 +334,7 @@ public async Task SetSharpIdeFile(SharpIdeFile file, SharpIdeFileLinePosition? f
 			_fileChangingSuppressBreakpointToggleEvent = false;
 			ClearUndoHistory();
 			if (fileLinePosition is not null) SetFileLinePosition(fileLinePosition.Value);
+			if (file.IsMetadataAsSourceFile) Editable = false;
 		});
 		_ = Task.GodotRun(async () =>
 		{

src/SharpIDE.Godot/Features/CodeEditor/SharpIdeCodeEdit_SymbolLookup.cs

@@ -89,7 +89,16 @@ await this.InvokeAsync(() =>
                     }
                     else
                     {
-                        GD.PrintErr($"Definition is not in source code, cannot navigate to it: {referencedSymbol.Name}");
+                        GD.Print($"Definition is not in source code, attempting to navigate to metadata as source: {referencedSymbol.Name}");
+                        var metadataAsSourceSharpIdeFile = await _sharpIdeMetadataAsSourceService.CreateSharpIdeFileForMetadataAsSourceAsync(_currentFile, referencedSymbol);
+                        if (metadataAsSourceSharpIdeFile is not null)
+                        {
+                            await GodotGlobalEvents.Instance.FileExternallySelected.InvokeParallelAsync(metadataAsSourceSharpIdeFile, new SharpIdeFileLinePosition(0, 0));
+                        }
+                        else
+                        {
+                            GD.PrintErr($"Failed to create metadata as source file for symbol: {referencedSymbol.Name}");
+                        }
                     }
                 }
                 else