More custom debug records

Author: Windows10CE

src/AsmResolver.DotNet/PortablePdbs/CustomRecords/CustomDebugRecord.cs

@@ -35,6 +35,14 @@ public static CustomDebugRecord FromRow(PdbReaderContext context, in CustomDebug
         {
             return SourceLinkRecord.FromReader(blobReaderContext, ref reader);
         }
+        else if (kind == DefaultNamespaceRecord.KnownKind)
+        {
+            return DefaultNamespaceRecord.FromReader(blobReaderContext, ref reader);
+        }
+        else if (kind == DynamicLocalVariablesRecord.KnownKind)
+        {
+            return DynamicLocalVariablesRecord.FromReader(blobReaderContext, ref reader);
+        }
 
         if (hasBlob)
         {

src/AsmResolver.DotNet/PortablePdbs/CustomRecords/DefaultNamespaceRecord.cs

@@ -0,0 +1,29 @@
+using System;
+using AsmResolver.DotNet.Signatures;
+using AsmResolver.IO;
+
+namespace AsmResolver.DotNet.PortablePdbs.CustomRecords;
+
+public class DefaultNamespaceRecord : CustomDebugRecord
+{
+    public static Guid KnownKind { get; } = new("58b2eab6-209f-4e4e-a22c-b2d0f910c782");
+
+    public override Guid Kind => KnownKind;
+
+    public override bool HasBlob => true;
+
+    public Utf8String? Namespace { get; set; }
+
+    public static DefaultNamespaceRecord FromReader(in BlobReaderContext context, ref BinaryStreamReader reader)
+    {
+        return new DefaultNamespaceRecord
+        {
+            Namespace = new Utf8String(reader.ReadToEnd()),
+        };
+    }
+
+    protected override void WriteContents(in BlobSerializationContext context)
+    {
+        throw new NotImplementedException();
+    }
+}

src/AsmResolver.DotNet/PortablePdbs/CustomRecords/DynamicLocalVariablesRecord.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections;
+using AsmResolver.DotNet.Signatures;
+using AsmResolver.IO;
+using AsmResolver.PE.DotNet.Metadata.Tables;
+
+namespace AsmResolver.DotNet.PortablePdbs.CustomRecords;
+
+public class DynamicLocalVariablesRecord : CustomDebugRecord
+{
+    public static Guid KnownKind { get; } = new("83C563C4-B4F3-47D5-B824-BA5441477EA8");
+
+    public override Guid Kind => KnownKind;
+
+    public override bool HasBlob => true;
+
+    public BitArray? BitSequence { get; set; }
+
+    public static DynamicLocalVariablesRecord FromReader(in BlobReaderContext context, ref BinaryStreamReader reader)
+    {
+        return new DynamicLocalVariablesRecord
+        {
+            BitSequence = new BitArray(reader.ReadToEnd()),
+        };
+    }
+
+    // TODO: decide whether these are wanted/figure out a better way to encode this
+    public static TypeSignature DecodeDynamicBits(BitArray bitSequence, TypeSignature sig)
+    {
+        throw new NotImplementedException();
+    }
+
+    public static BitArray EncodeDynamicBits(TypeSignature sig)
+    {
+        throw new NotImplementedException();
+    }
+
+    public sealed class DynamicMarkerTypeSignature : TypeSignature
+    {
+        public CorLibTypeSignature ObjectType { get; }
+
+        public DynamicMarkerTypeSignature(CorLibTypeSignature objectType)
+        {
+            if (objectType.ElementType != ElementType.Object)
+            {
+                throw new ArgumentException("Object type must have ElementType == ElementType.Object", nameof(objectType));
+            }
+
+            ObjectType = objectType;
+        }
+
+        public override string Name => ObjectType.Name;
+
+        public override string Namespace => ObjectType.Namespace;
+
+        public override IResolutionScope? Scope => ObjectType.Scope;
+
+        public override bool IsValueType => false;
+
+        public override ElementType ElementType => ElementType.Object;
+
+        public override ITypeDefOrRef GetUnderlyingTypeDefOrRef() => ObjectType.GetUnderlyingTypeDefOrRef();
+
+        public override bool IsImportedInModule(ModuleDefinition module) => ObjectType.IsImportedInModule(module);
+
+        public override TResult AcceptVisitor<TResult>(ITypeSignatureVisitor<TResult> visitor) => visitor.VisitCorLibType(ObjectType);
+
+        public override TResult AcceptVisitor<TState, TResult>(ITypeSignatureVisitor<TState, TResult> visitor, TState state) => visitor.VisitCorLibType(ObjectType, state);
+
+        protected override void WriteContents(in BlobSerializationContext context) => context.Writer.WriteByte((byte)ElementType.Object);
+    }
+
+    protected override void WriteContents(in BlobSerializationContext context)
+    {
+        throw new NotImplementedException();
+    }
+}

src/AsmResolver.DotNet/PortablePdbs/LocalConstant.cs

@@ -1,9 +1,11 @@
-using AsmResolver.Collections;
+using System.Collections.Generic;
+using AsmResolver.Collections;
+using AsmResolver.DotNet.Collections;
 using AsmResolver.PE.DotNet.Metadata.Tables;
 
 namespace AsmResolver.DotNet.PortablePdbs;
 
-public partial class LocalConstant : IMetadataMember, IOwnedCollectionElement<LocalScope>
+public partial class LocalConstant : IMetadataMember, IOwnedCollectionElement<LocalScope>, IHasCustomDebugInformation
 {
     public LocalConstant(MetadataToken token)
     {
@@ -36,9 +38,17 @@ public partial LocalConstantSignature? Signature
         set;
     }
 
+    [LazyProperty]
+    public partial IList<CustomDebugInformation> CustomDebugInformations
+    {
+        get;
+    }
+
     protected virtual LocalScope? GetOwner() => null;
 
     protected virtual Utf8String? GetName() => null;
 
     protected virtual LocalConstantSignature? GetSignature() => null;
+
+    protected virtual IList<CustomDebugInformation> GetCustomDebugInformations() => new MemberCollection<IHasCustomDebugInformation, CustomDebugInformation>(this);
 }

src/AsmResolver.DotNet/PortablePdbs/Serialized/SerializedCustomDebugInformation.cs

@@ -1,3 +1,4 @@
+using System;
 using AsmResolver.DotNet.PortablePdbs.CustomRecords;
 using AsmResolver.PE.DotNet.Metadata.Tables;
 
@@ -16,4 +17,49 @@ public SerializedCustomDebugInformation(PdbReaderContext context, MetadataToken
     }
 
     protected override CustomDebugRecord GetValue() => CustomDebugRecord.FromRow(_context, in _row);
+
+    protected override IHasCustomDebugInformation? GetOwner()
+    {
+        var encoder = _context.TablesStream.GetIndexEncoder(CodedIndex.HasCustomDebugInformation);
+        var decoded = encoder.DecodeIndex(_row.Parent);
+        IHasCustomDebugInformation? member;
+        switch (decoded.Table)
+        {
+            case TableIndex.Method:
+            case TableIndex.Field:
+            case TableIndex.TypeRef:
+            case TableIndex.TypeDef:
+            case TableIndex.Param:
+            case TableIndex.InterfaceImpl:
+            case TableIndex.MemberRef:
+            case TableIndex.Module:
+            case TableIndex.DeclSecurity:
+            case TableIndex.Property:
+            case TableIndex.Event:
+            case TableIndex.StandAloneSig:
+            case TableIndex.ModuleRef:
+            case TableIndex.TypeSpec:
+            case TableIndex.Assembly:
+            case TableIndex.AssemblyRef:
+            case TableIndex.File:
+            case TableIndex.ExportedType:
+            case TableIndex.ManifestResource:
+            case TableIndex.GenericParam:
+            case TableIndex.GenericParamConstraint:
+            case TableIndex.MethodSpec:
+                _context.OwningModule.TryLookupMember<IHasCustomDebugInformation>(decoded, out member);
+                break;
+            case TableIndex.Document:
+            case TableIndex.LocalScope:
+            case TableIndex.LocalVariable:
+            case TableIndex.LocalConstant:
+            case TableIndex.ImportScope:
+                _context.Pdb.TryLookupMember<IHasCustomDebugInformation>(decoded, out member);
+                break;
+            default:
+                throw new ArgumentOutOfRangeException();
+        }
+
+        return member;
+    }
 }

src/AsmResolver.DotNet/PortablePdbs/Serialized/SerializedLocalConstant.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using AsmResolver.DotNet.Signatures;
 using AsmResolver.PE.DotNet.Metadata.Tables;
 
@@ -28,4 +29,6 @@ public SerializedLocalConstant(PdbReaderContext context, MetadataToken token, in
         }
         return null;
     }
+
+    protected override IList<CustomDebugInformation> GetCustomDebugInformations() => _context.Pdb.GetCustomDebugInformations(this);
 }

src/AsmResolver.DotNet/PortablePdbs/Serialized/SerializedPortablePdb.cs

@@ -39,7 +39,18 @@ public override bool TryLookupMember<T>(MetadataToken token, [MaybeNullWhen(fals
         return false;
     }
 
-    public IList<CustomDebugInformation> GetCustomDebugInformations(IHasCustomDebugInformation owner)
+    public IEnumerable<IMetadataMember> EnumerateTableMembers(TableIndex tableIndex)
+    {
+        var table = PdbReaderContext.TablesStream.GetTable(tableIndex);
+
+        for (uint rid = 1; rid <= table.Count; rid++)
+        {
+            if (TryLookupMember<IMetadataMember>(new MetadataToken(tableIndex, rid), out var member))
+                yield return member;
+        }
+    }
+
+    internal IList<CustomDebugInformation> GetCustomDebugInformations(IHasCustomDebugInformation owner)
     {
         var rids = GetCustomDebugInformations(owner.MetadataToken);
         var customDebugInformations = new MemberCollection<IHasCustomDebugInformation, CustomDebugInformation>(owner, rids.Count);

src/AsmResolver.DotNet/Signatures/CorLibTypeSignature.cs

@@ -39,7 +39,7 @@ public ITypeDefOrRef Type
         }
 
         /// <inheritdoc />
-        public override string? Name
+        public override string Name
         {
             get;
         }

test/AsmResolver.DotNet.Tests/PortablePdbs/PortablePdbTest.cs

@@ -1,3 +1,7 @@
+using System.Linq;
+using AsmResolver.DotNet.PortablePdbs;
+using AsmResolver.DotNet.Serialized;
+using AsmResolver.PE.DotNet.Metadata.Tables;
 using Xunit;
 
 namespace AsmResolver.DotNet.Tests.PortablePdbs;
@@ -7,6 +11,7 @@ public class PortablePdbTest
     [Fact]
     public void Test()
     {
-        var mod = ModuleDefinition.FromFile("/home/aaronr/.nuget/packages/microsoft.codeanalysis.csharp/5.3.0-1.25619.109/lib/net9.0/Microsoft.CodeAnalysis.CSharp.dll");
+        var mod = ModuleDefinition.FromFile(typeof(PortablePdbTest).Assembly.Location);
+        var pdb = ((PortablePdbSymbolReader)((SerializedModuleDefinition)mod).SymbolReader).Pdb.EnumerateTableMembers(TableIndex.CustomDebugInformation).Cast<CustomDebugInformation>().ToArray();
     }
 }