Update #5

Core/AssemblyMetadata/AssemblyDebugData.cs

@@ -8,13 +8,23 @@ namespace NuGetPe.AssemblyMetadata
 {
     public class AssemblyDebugData
     {
-#pragma warning disable CS8618 // Non-nullable field is uninitialized.
-        public PdbType PdbType { get; internal set; }
+        public AssemblyDebugData()
+        {
+            SourceLinkErrors = new List<string>();
+            Sources = new List<AssemblyDebugSourceDocument>();
+            SymbolKeys = new List<SymbolKey>();
+        }
 
-        public IReadOnlyList<SourceLinkMap> SourceLink { get; internal set; }
+        public PdbType PdbType { get; internal set; }
 
         public IReadOnlyList<AssemblyDebugSourceDocument> Sources { get; internal set; }
-#pragma warning restore CS8618 // Non-nullable field is uninitialized.
+        public IReadOnlyList<string> SourceLinkErrors { get; internal set; }
+        public IReadOnlyList<SymbolKey> SymbolKeys { get; internal set; }
+        public bool HasSourceLink => Sources.All(doc => doc.HasSourceLink);
+
+
+        public bool HasDebugInfo { get; internal set; }
+
     }
 
     public enum PdbType

Core/AssemblyMetadata/AssemblyDebugParser.cs

@@ -1,12 +1,14 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Reflection.Metadata;
+using System.Reflection.PortableExecutable;
 using System.Text;
 using Microsoft.DiaSymReader.Tools;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using Microsoft.SourceLink.Tools;
 
 namespace NuGetPe.AssemblyMetadata
 {
@@ -23,6 +25,7 @@ public AssemblyDebugParser(Stream? peStream, Stream pdbStream)
                 _temporaryPdbStream = new MemoryStream();
                 PdbConverter.Default.ConvertWindowsToPortable(peStream, pdbStream, _temporaryPdbStream);
                 _temporaryPdbStream.Position = 0;
+                peStream.Position = 0;
                 inputStream = _temporaryPdbStream;
                 _pdbType = PdbType.Full;
             }
@@ -34,13 +37,16 @@ public AssemblyDebugParser(Stream? peStream, Stream pdbStream)
 
             _readerProvider = MetadataReaderProvider.FromPortablePdbStream(inputStream);
             _reader = _readerProvider.GetMetadataReader();
-
+            _peReader = new PEReader(peStream!);
+            _ownPeReader = true;
         }
 
-        public AssemblyDebugParser(MetadataReaderProvider readerProvider, PdbType pdbType)
+        public AssemblyDebugParser(PEReader peReader, MetadataReaderProvider readerProvider, PdbType pdbType)
         {
             _readerProvider = readerProvider;
             _pdbType = pdbType;
+            _peReader = peReader;
+            _ownPeReader = false;
 
             // Possible BadImageFormatException if a full PDB is passed
             // in. We'll let the throw bubble up to something that can handle it
@@ -51,124 +57,195 @@ public AssemblyDebugParser(MetadataReaderProvider readerProvider, PdbType pdbTyp
         private bool _disposedValue = false;
         private readonly MetadataReaderProvider _readerProvider;
         private readonly MetadataReader _reader;
+        private readonly PEReader _peReader;
+        private readonly bool _ownPeReader;
         private readonly Stream? _temporaryPdbStream;
 
-        private static readonly Guid SourceLinkGuid = new Guid("CC110556-A091-4D38-9FEC-25AB9A351A6A");
+        private static readonly Guid SourceLinkId = new Guid("CC110556-A091-4D38-9FEC-25AB9A351A6A");
+
+        private static readonly Guid EmbeddedSourceId = new Guid("0E8A571B-6926-466E-B4AD-8AB04611F5FE");
+        private const ushort PortableCodeViewVersionMagic = 0x504d;
 
 
         public AssemblyDebugData GetDebugData()
         {
+
+            var (documents, errors) = GetDocumentsWithUrls();
+
+
             var debugData = new AssemblyDebugData
             {
                 PdbType = _pdbType,
-                Sources = GetSourceDocuments(),
-                SourceLink = GetSourceLinkInformation()
+                Sources = documents,
+                SourceLinkErrors = errors,
+                SymbolKeys = GetSymbolKeys(_peReader),
+                HasDebugInfo = true
             };
 
             return debugData;
         }
 
-        private IReadOnlyList<SourceLinkMap> GetSourceLinkInformation()
+
+        private byte[]? GetSourceLinkBytes()
         {
-            var sl = (from cdi in _reader.CustomDebugInformation
-                      let cd = _reader.GetCustomDebugInformation(cdi)
-                      let kind = _reader.GetGuid(cd.Kind)
-                      where kind == SourceLinkGuid
-                      let bl = _reader.GetBlobBytes(cd.Value)
-                      select Encoding.UTF8.GetString(bl))
-                .FirstOrDefault();
-
-            if (sl != null)
+            if (_reader == null) return null;
+            var blobh = default(BlobHandle);
+            foreach (var cdih in _reader.GetCustomDebugInformation(EntityHandle.ModuleDefinition))
             {
-                try
-                {
-                    /* Some tools, like GitLink generate incorrectly escaped JSON:
+                var cdi = _reader.GetCustomDebugInformation(cdih);
+                if (_reader.GetGuid(cdi.Kind) == SourceLinkId)
+                    blobh = cdi.Value;
+            }
+            if (blobh.IsNil) return Array.Empty<byte>();
+            return _reader.GetBlobBytes(blobh);
+        }
 
-                    {
-                    "documents": {
-                        "C:\projects\cefsharp\*": "https://raw.github.com/CefSharp/CefSharp/4f88ad11416e93dde4b52216800efd42ba3b9c8a/*"
-                      }
-                    }
-
-                    Catch the exception and try to fix the key
-                    */
-                    JObject? jobj = null;
-                    try
-                    {
-                        jobj = JObject.Parse(sl);
-                    }
-                    catch (JsonReaderException e) when (e.Path == "documents")
-                    {
-                        sl = sl.Replace(@"\", @"\\", StringComparison.Ordinal);
-                        jobj = JObject.Parse(sl);
-                    }
+        private bool IsEmbedded(DocumentHandle dh)
+        {
+            foreach (var cdih in _reader.GetCustomDebugInformation(dh))
+            {
+                var cdi = _reader.GetCustomDebugInformation(cdih);
+                if (_reader.GetGuid(cdi.Kind) == EmbeddedSourceId)
+                    return true;
+            }
+            return false;
+        }
 
-                    var docs = (JObject)jobj["documents"];
+        public static IReadOnlyList<SymbolKey> GetSymbolKeys(PEReader peReader)
+        {
+            var result = new List<SymbolKey>();
+            var checksums = new List<string>();
 
-                    var slis = (from prop in docs.Properties()
-                                select new SourceLinkMap
-                                {
-                                    Base = prop.Name.Replace(@"\", @"/", StringComparison.Ordinal), // use forward slashes for the url,
-                                    Location = prop.Value.Value<string>()
-                                })
-                        .ToList();
+            foreach (var entry in peReader.ReadDebugDirectory())
+            {
+                if (entry.Type != DebugDirectoryEntryType.PdbChecksum) continue;
 
-                    return slis;
-                }
-                catch (JsonReaderException jse)
-                {
-                    throw new InvalidDataException("SourceLink data could not be parsed", jse);
-                }
+                var data = peReader.ReadPdbChecksumDebugDirectoryData(entry);
+                var algorithm = data.AlgorithmName;
+                var checksum = data.Checksum.Select(b => b.ToString("x2", CultureInfo.InvariantCulture));
+
+                checksums.Add($"{algorithm}:{checksum}");
+            }
+
+            foreach (var entry in peReader.ReadDebugDirectory())
+            {
+                if (entry.Type != DebugDirectoryEntryType.CodeView) continue;
+
+                var data = peReader.ReadCodeViewDebugDirectoryData(entry);
+                var isPortable = entry.MinorVersion == PortableCodeViewVersionMagic;
 
+                var signature = data.Guid;
+                var age = data.Age;
+#pragma warning disable CA1308 // Normalize strings to uppercase
+                var file = Uri.EscapeDataString(Path.GetFileName(data.Path.Replace("\\", "/", StringComparison.OrdinalIgnoreCase)).ToLowerInvariant());
+#pragma warning restore CA1308 // Normalize strings to uppercase
+
+                // Portable PDBs, see: https://github.com/dotnet/symstore/blob/83032682c049a2b879790c615c27fbc785b254eb/src/Microsoft.SymbolStore/KeyGenerators/PortablePDBFileKeyGenerator.cs#L84
+                // Windows PDBs, see: https://github.com/dotnet/symstore/blob/83032682c049a2b879790c615c27fbc785b254eb/src/Microsoft.SymbolStore/KeyGenerators/PDBFileKeyGenerator.cs#L52
+                var symbolId = isPortable
+                    ? signature.ToString("N", CultureInfo.InvariantCulture) + "FFFFFFFF"
+                    : string.Format(CultureInfo.InvariantCulture, "{0}{1:x}", signature.ToString("N", CultureInfo.InvariantCulture), age);
+
+                result.Add(new SymbolKey
+                {
+                    IsPortablePdb = isPortable,
+                    Checksums = checksums,
+                    Key = $"{file}/{symbolId}/{file}",
+                });
             }
 
-            return Array.Empty<SourceLinkMap>();
+            return result;
         }
 
 
-        private IReadOnlyList<AssemblyDebugSourceDocument> GetSourceDocuments()
+        private IEnumerable<AssemblyDebugSourceDocument> GetSourceDocuments()
         {
-            var list = new List<AssemblyDebugSourceDocument>();
-
-            foreach (var docHandle in _reader.Documents)
+            foreach (var dh in _reader.Documents)
             {
-                var document = _reader.GetDocument(docHandle);
+                if (dh.IsNil) continue;
+                var d = _reader.GetDocument(dh);
+                if (d.Name.IsNil || d.Language.IsNil || d.HashAlgorithm.IsNil || d.Hash.IsNil) continue;
+
+                var name = _reader.GetString(d.Name);
+                var language = _reader.GetGuid(d.Language);
+                var hashAlgorithm = _reader.GetGuid(d.HashAlgorithm);
+                var hash = _reader.GetBlobBytes(d.Hash);
+                var isEmbedded = IsEmbedded(dh);
 
-                var langGuid = _reader.GetGuid(document.Language);
-                var hashGuid = _reader.GetGuid(document.HashAlgorithm);
-                var docName = _reader.GetString(document.Name).Replace(@"\", @"/", StringComparison.Ordinal); // use forward slashes for the url
 
                 var doc = new AssemblyDebugSourceDocument
                 (
-                    docName,
-                    _reader.GetBlobBytes(document.Hash),
-                    langGuid,
-                    hashGuid
+                    name,
+                    hash,
+                    language,
+                    hashAlgorithm,
+                    isEmbedded
                 );
-                list.Add(doc);
-
+
                 if (doc.Language == SymbolLanguage.Unknown)
                 {
                     DiagnosticsClient.TrackEvent("Unknown language Guid", new Dictionary<string, string>
                     {
-                        { "LanguageGuid", langGuid.ToString() },
-                        { "HashGuid", hashGuid.ToString() },
-                        { "DocExtension", Path.GetExtension(docName)! }
+                        { "LanguageGuid", language.ToString() },
+                        { "HashGuid", hashAlgorithm.ToString() },
+                        { "DocExtension", Path.GetExtension(name)! }
                     });
-                }                
+                }
+
+                yield return doc;
+            }
+        }
+
+
+        private (IReadOnlyList<AssemblyDebugSourceDocument> documents, IReadOnlyList<string> errors) GetDocumentsWithUrls()
+        {
+            var bytes = GetSourceLinkBytes();
+            SourceLinkMap? map = null;
+
+            var errors = new List<string>();
+            if (bytes != null && bytes.Length > 0)
+            {
+                var text = Encoding.UTF8.GetString(bytes);
+                map = SourceLinkMap.Parse(text, errors.Add);
             }
-            return list;
+
+            var list = new List<AssemblyDebugSourceDocument>();
+
+            foreach (var doc in GetSourceDocuments())
+            {
+                if (!doc.IsEmbedded)
+                    doc.Url = map?.GetUri(doc.Name);
+                list.Add(doc);
+            }
+
+            return (list, errors);
         }
 
 
+
+
         public void Dispose()
         {
             if (!_disposedValue)
             {
                 _readerProvider.Dispose();
                 _temporaryPdbStream?.Dispose();
+
+                if(_ownPeReader)
+                    _peReader.Dispose();
+
                 _disposedValue = true;
             }
         }
     }
+
+    [DebuggerDisplay("{Key}, IsPortable={IsPortablePdb}")]
+    public class SymbolKey
+    {
+        public bool IsPortablePdb { get; set; }
+#pragma warning disable CS8618 // Non-nullable field is uninitialized. Consider declaring as nullable.
+        public IReadOnlyList<string> Checksums { get; set; }
+        public string Key { get; set; }
+#pragma warning restore CS8618 // Non-nullable field is uninitialized. Consider declaring as nullable.
+    }
 }

Core/AssemblyMetadata/AssemblyDebugSourceDocument.cs

@@ -16,12 +16,13 @@ public class AssemblyDebugSourceDocument
         private static readonly Guid Sha1 = new Guid("ff1816ec-aa5e-4d10-87f7-6f4963833460");
         private static readonly Guid Sha256 = new Guid("8829d00f-11b8-4213-878b-770e8597ac16");
 
-        internal AssemblyDebugSourceDocument(string name, byte[] hash, Guid language, Guid hashAlgorithm)
+        internal AssemblyDebugSourceDocument(string name, byte[] hash, Guid language, Guid hashAlgorithm, bool isEmbedded)
         {
             Name = name;
             Hash = hash;
             Language = LanguageFromGuid(language);
             HashAlgorithm = HashAlgorithmNameFromGuid(hashAlgorithm);
+            IsEmbedded = isEmbedded;
         }
 
         public string Name { get; }
@@ -30,6 +31,9 @@ internal AssemblyDebugSourceDocument(string name, byte[] hash, Guid language, Gu
 #pragma warning restore CA1819 // Properties should not return arrays
         public SymbolLanguage Language { get; }
         public HashAlgorithmName? HashAlgorithm { get; }
+        public bool IsEmbedded { get; }
+        public bool HasSourceLink => IsEmbedded || !string.IsNullOrWhiteSpace(Url);
+        public string? Url { get; internal set; }
 
         private SymbolLanguage LanguageFromGuid(Guid guid)
         {

Core/AssemblyMetadata/AssemblyMetaDataInfo.cs

@@ -14,9 +14,9 @@ public class AssemblyMetaDataInfo
         private string FullName { get; set; }
         private string StrongName { get; set; }
         private IEnumerable<AssemblyName> ReferencedAsseblies { get; set; } = Enumerable.Empty<AssemblyName>();
-        public AssemblyDebugData? DebugData { get; internal set; }
 
 #pragma warning disable CS8618 // Non-nullable field is uninitialized.
+        public AssemblyDebugData DebugData { get; internal set; }
         public AssemblyMetaDataInfo(AssemblyName assemblyName)
 #pragma warning restore CS8618 // Non-nullable field is uninitialized.
         {

Core/AssemblyMetadata/AssemblyMetadataParser.cs

@@ -24,15 +24,21 @@ public AssemblyMetadataParser(string fileName)
             _metadataReader = _peReader.GetMetadataReader();
         }
 
-        public AssemblyDebugData? GetDebugData()
+        public AssemblyDebugData GetDebugData()
         {
             var entry = _peReader.ReadDebugDirectory().Where(de => de.Type == DebugDirectoryEntryType.EmbeddedPortablePdb).ToList();
             if (entry.Count == 0) // no embedded ppdb
             {
-                return null;
+
+                return new AssemblyDebugData
+                {
+                    HasDebugInfo = false,
+                    SymbolKeys = AssemblyDebugParser.GetSymbolKeys(_peReader)
+                };
+
             }
 
-            using var reader = new AssemblyDebugParser(_peReader.ReadEmbeddedPortablePdbDebugDirectoryData(entry[0]), PdbType.Embedded);
+            using var reader = new AssemblyDebugParser(_peReader, _peReader.ReadEmbeddedPortablePdbDebugDirectoryData(entry[0]), PdbType.Embedded);
             return reader.GetDebugData();
         }