step into decompiled methods from debugger

Author: MattParkerDev

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

@@ -991,6 +991,48 @@ public async Task<ImmutableArray<IdeReferenceLocationResult>> GetIdeReferenceLoc
 		return changedFilesWithText;
 	}
 
+	public async Task<string?> GetMetadataAsSourceFromDebuggingAssemblyAndType(string typeName, string assemblyName, Guid mvid, string userCodeCallingAssemblyPath, CancellationToken cancellationToken = default)
+	{
+		using var _ = SharpIdeOtel.Source.StartActivity($"{nameof(RoslynAnalysis)}.{nameof(FindAllSymbolReferences)}");
+		await _solutionLoadedTcs.Task;
+
+		var callingProject = _workspace!.CurrentSolution.Projects.SingleOrDefault(p => p.OutputFilePath == userCodeCallingAssemblyPath);
+		if (callingProject is null) return null;
+
+		var compilation = await callingProject.GetRequiredCompilationAsync(cancellationToken);
+		var symbols = compilation.GetTypesByMetadataName(typeName);
+
+		var symbol = symbols.SingleOrDefault(s =>
+		{
+			if (Path.GetFileNameWithoutExtension(s.ContainingModule.Name) != assemblyName) return false;
+
+			var containingAssembly = s.ContainingAssembly;
+			var metadataReference = compilation.GetMetadataReference(containingAssembly) as PortableExecutableReference;
+			if (metadataReference is null) return false;
+			var referenceAssemblyFilePath = metadataReference.FilePath;
+			// Runtime loads implementation assemblies, but Roslyn only has reference assemblies, so try to resolve the implementation assembly
+			if (referenceAssemblyFilePath is not null && MetadataAsSourceHelpers.IsReferenceAssembly(containingAssembly))
+			{
+				if (_implementationAssemblyLookupService.TryFindImplementationAssemblyPath(referenceAssemblyFilePath, out var implementationAssemblyLocation))
+				{
+					// TODO: Do we need to follow type forwards here?
+					// read the metadata from the implementation assembly, instead of the reference assembly, to get the correct MVID for comparison
+					metadataReference = MetadataReference.CreateFromFile(implementationAssemblyLocation);
+				}
+			}
+			if (metadataReference.GetMetadata() is not AssemblyMetadata assemblyMetadata) return false;
+			return assemblyMetadata.GetMvid() == mvid;
+		});
+		if (symbol is null) return null;
+
+		var options = MetadataAsSourceOptions.Default;// with { NavigateToSourceLinkAndEmbeddedSources = false };
+		var metadataAsSourceFile = await _metadataAsSourceFileService.GetGeneratedFileAsync(_workspace, callingProject, symbol, false, options, cancellationToken);
+		var metadataAsSourceWorkspace = _metadataAsSourceFileService.TryGetWorkspace();
+		var documentId = metadataAsSourceWorkspace!.CurrentSolution.GetDocumentIdsWithFilePath(metadataAsSourceFile.FilePath).SingleOrDefault();
+		var document = metadataAsSourceWorkspace.CurrentSolution.GetDocument(documentId);
+		return document?.FilePath;
+	}
+
 	public async Task<string?> WriteSourceFromMetadataAsSourceWorkspaceToDisk(string filePath, CancellationToken cancellationToken = default)
 	{
 		await _solutionLoadedTcs.Task;

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

@@ -31,4 +31,15 @@ public class SharpIdeMetadataAsSourceService(RoslynAnalysis roslynAnalysis)
 		return metadataAsSourceSharpIdeFile;
 	}
 
+	public async Task<SharpIdeFile?> CreateSharpIdeFileForMetadataAsSourceForTypeFromDebuggingAsync(string typeName, string assemblyPath, Guid mvid, string userCodeCallingAssemblyPath)
+	{
+		var assemblyName = Path.GetFileNameWithoutExtension(assemblyPath);
+		var filePath = await _roslynAnalysis.GetMetadataAsSourceFromDebuggingAssemblyAndType(typeName, assemblyName, mvid, userCodeCallingAssemblyPath);
+		if (filePath is null) return null;
+		var fileFromCache = _metadataAsSourceFileCache.GetValueOrDefault(filePath);
+		if (fileFromCache is not null) return fileFromCache;
+		var metadataAsSourceSharpIdeFile = new SharpIdeFile(filePath, Path.GetFileName(filePath), Path.GetExtension(filePath), null!, [], true);
+		_metadataAsSourceFileCache[filePath] = metadataAsSourceSharpIdeFile;
+		return metadataAsSourceSharpIdeFile;
+	}
 }

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

@@ -4,7 +4,11 @@
 using System.Reflection.Metadata;
 using System.Reflection.PortableExecutable;
 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;
 using Microsoft.CodeAnalysis.Debugging;
 using Microsoft.CodeAnalysis.ErrorReporting;
@@ -18,6 +22,7 @@
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 using Document = Microsoft.CodeAnalysis.Document;
+using ISymbol = Microsoft.CodeAnalysis.ISymbol;
 
 namespace SharpIDE.Application.Features.Analysis.WorkspaceServices;
 
@@ -116,8 +121,7 @@ internal sealed class DecompileWholeAssemblyToProjectMetadataAsSourceFileProvide
 					decompiledFiles = await GetSourceFilesFromSymbolCachePdb(refInfo.metadataReference, refInfo.assemblyLocation, assemblyKey, cancellationToken);
 					if (decompiledFiles is null)
 					{
-						decompiledFiles = await DecompileAssemblyToMemoryAsync(
-							compilation, refInfo.metadataReference, refInfo.assemblyLocation, cancellationToken).ConfigureAwait(false);
+						decompiledFiles = await DecompileAssemblyToMemoryAsync(compilation, refInfo.metadataReference, refInfo.assemblyLocation, assemblyKey, cancellationToken);
 					}
 
 					telemetryMessage?.SetDecompiled(decompiledFiles is not null);
@@ -180,7 +184,7 @@ internal sealed class DecompileWholeAssemblyToProjectMetadataAsSourceFileProvide
 		if (metadataReference is null || assemblyLocation is null) return null;
 
 		// TBD
-		var symbolCacheFolderPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Temp", "SharpIdeSymbolCache");
+		var symbolCacheFolderPath = SharpIdeDecompilationConstants.SymbolCachePath;
 
 		var assemblyName = Path.GetFileNameWithoutExtension(assemblyLocation);
 		var mvid = assemblyKey.Mvid;
@@ -245,12 +249,14 @@ internal sealed class DecompileWholeAssemblyToProjectMetadataAsSourceFileProvide
 	}
 
 	/// <summary>
-	/// Decompiles all types in the assembly to a dictionary of relative path -> source code.
+	/// Decompiles all types in the assembly to a dictionary of relative path -> source code,
+	/// and writes a portable PDB with embedded sources to the symbol cache.
 	/// </summary>
 	private static Task<Dictionary<string, string>?> DecompileAssemblyToMemoryAsync(
 		Compilation compilation,
 		MetadataReference? metadataReference,
 		string? assemblyLocation,
+		UniqueAssemblyKey assemblyKey,
 		CancellationToken cancellationToken)
 	{
 		return Task.Run(Dictionary<string, string>? () =>
@@ -270,8 +276,30 @@ internal sealed class DecompileWholeAssemblyToProjectMetadataAsSourceFileProvide
 
 			using (file)
 			{
-				var decompiler = new WholeAssemblyDecompiler(resolver);
-				return decompiler.DecompileToMemory(file, cancellationToken);
+				var settings = new DecompilerSettings();
+				var ts = new DecompilerTypeSystem(file, resolver, settings);
+				var decompiler = new CSharpDecompiler(ts, settings)
+				{
+					AstTransforms = {
+						new TransformFieldAndConstructorInitializers(),
+						new AddXmlDocumentationTransform(),
+						new EscapeInvalidIdentifiers(),
+						new FixNameCollisions(),
+						new RemoveCLSCompliantAttribute(),
+						new ReplaceMethodCallsWithOperators()
+					}
+				};
+
+				// Determine PDB cache path.
+				var assemblyName = assemblyLocation is not null ? Path.GetFileNameWithoutExtension(assemblyLocation) : file.Name;
+				var pdbDir = Path.Combine(SharpIdeDecompilationConstants.SymbolCachePath, assemblyName, assemblyKey.Mvid.ToString());
+				var pdbPath = Path.Combine(pdbDir, $"{assemblyName}.decompiled.pdb");
+				Directory.CreateDirectory(pdbDir);
+
+				using var pdbStream = new FileStream(pdbPath, FileMode.Create, FileAccess.Write, FileShare.None);
+				var sourceFiles = PortablePdbWriter2.WritePdb(file, decompiler, settings, pdbStream, noLogo: true);
+
+				return sourceFiles.Count > 0 ? sourceFiles : null;
 			}
 		}, cancellationToken);
 	}