Fix Debugger Windows integration tests not running

tracer/build/_build/Build.Steps.Debugger.cs

@@ -148,7 +148,7 @@ string GetTestFilter()
                         _ => "(Category!=LinuxUnsupported)&(SkipInCI!=True)",
                     };
 
-                    return Filter is null ? filter : $"{Filter}&{filter}";
+                    return string.IsNullOrEmpty(Filter) ? filter : $"{Filter}&{filter}";
                 }
             }
             finally

tracer/src/Datadog.Trace/Debugger/SpanCodeOrigin/EndpointDetector.cs

@@ -79,7 +79,7 @@ internal static ImmutableHashSet<int> GetEndpointMethodTokens(DatadogMetadataRea
                     isSignalRHub = IsInheritFromTypes(typeDef, metadataReader, SignalRHubBaseNames);
                     if (!isSignalRHub)
                     {
-                        isCompilerGeneratedType = datadogMetadataReader.IsCompilerGeneratedAttributeDefinedOnType(typeHandle.RowId);
+                        isCompilerGeneratedType = datadogMetadataReader.IsCompilerGeneratedAttributeDefinedOnType(MetadataTokens.GetToken(typeHandle));
                         if (!isCompilerGeneratedType)
                         {
                             continue;

tracer/src/Datadog.Trace/Debugger/Symbols/SymbolExtractor.cs

@@ -14,6 +14,7 @@
 using Datadog.Trace.VendoredMicrosoftCode.System.Buffers;
 using Datadog.Trace.VendoredMicrosoftCode.System.Collections.Immutable;
 using Datadog.Trace.VendoredMicrosoftCode.System.Reflection.Metadata;
+using Datadog.Trace.VendoredMicrosoftCode.System.Reflection.Metadata.Ecma335;
 
 namespace Datadog.Trace.Debugger.Symbols
 {
@@ -167,7 +168,7 @@ private bool TryGetClassSymbols(TypeDefinitionHandle typeDefinitionHandle, out M
                     return false;
                 }
 
-                if (DatadogMetadataReader.IsCompilerGeneratedAttributeDefinedOnType(typeDefinitionHandle.RowId))
+                if (DatadogMetadataReader.IsCompilerGeneratedAttributeDefinedOnType(MetadataTokens.GetToken(typeDefinitionHandle)))
                 {
                     return false;
                 }
@@ -352,7 +353,7 @@ private void PopulateNestedNotCompileGeneratedClassScope(ImmutableArray<TypeDefi
                         continue;
                     }
 
-                    if (DatadogMetadataReader.IsCompilerGeneratedAttributeDefinedOnType(typeHandle.RowId))
+                    if (DatadogMetadataReader.IsCompilerGeneratedAttributeDefinedOnType(MetadataTokens.GetToken(typeHandle)))
                     {
                         continue;
                     }
@@ -459,12 +460,14 @@ private void PopulateMethodScopes(TypeDefinition type, MethodDefinitionHandleCol
                         continue;
                     }
 
-                    if (DatadogMetadataReader.IsCompilerGeneratedAttributeDefinedOnMethod(methodDefHandle.RowId))
+                    var methodToken = MetadataTokens.GetToken(methodDefHandle);
+
+                    if (DatadogMetadataReader.IsCompilerGeneratedAttributeDefinedOnMethod(methodToken))
                     {
                         continue;
                     }
 
-                    if (!DatadogMetadataReader.HasMethodBody(methodDefHandle.RowId))
+                    if (!DatadogMetadataReader.HasMethodBody(methodToken))
                     {
                         continue;
                     }
@@ -632,7 +635,7 @@ protected virtual bool TryCreateMethodScope(TypeDefinition type, MethodDefinitio
 
                 for (int i = 0; i < nestedTypes.Length; i++)
                 {
-                    if (!DatadogMetadataReader.IsCompilerGeneratedAttributeDefinedOnType(nestedTypes[i].RowId))
+                    if (!DatadogMetadataReader.IsCompilerGeneratedAttributeDefinedOnType(MetadataTokens.GetToken(nestedTypes[i])))
                     {
                         continue;
                     }
@@ -658,7 +661,7 @@ protected virtual bool TryCreateMethodScope(TypeDefinition type, MethodDefinitio
                         continue;
                     }
 
-                    if (!DatadogMetadataReader.IsCompilerGeneratedAttributeDefinedOnMethod(methodHandle.RowId))
+                    if (!DatadogMetadataReader.IsCompilerGeneratedAttributeDefinedOnMethod(MetadataTokens.GetToken(methodHandle)))
                     {
                         continue;
                     }

tracer/src/Datadog.Trace/Debugger/Symbols/SymbolPdbExtractor.cs

@@ -11,6 +11,7 @@
 using Datadog.Trace.VendoredMicrosoftCode.System;
 using Datadog.Trace.VendoredMicrosoftCode.System.Buffers;
 using Datadog.Trace.VendoredMicrosoftCode.System.Reflection.Metadata;
+using Datadog.Trace.VendoredMicrosoftCode.System.Reflection.Metadata.Ecma335;
 using Datadog.Trace.VendoredMicrosoftCode.System.Runtime.CompilerServices.Unsafe;
 using Datadog.Trace.VendoredMicrosoftCode.System.Runtime.InteropServices;
 
@@ -32,7 +33,7 @@ protected override bool TryCreateMethodScope(TypeDefinition type, MethodDefiniti
             return false;
         }
 
-        using var memory = DatadogMetadataReader.GetMethodSequencePointsAsMemoryOwner(method.Handle.RowId, false, out var count);
+        using var memory = DatadogMetadataReader.GetMethodSequencePointsAsMemoryOwner(MetadataTokens.GetToken(method.Handle), false, out var count);
         if (memory == null || count == 0)
         {
             return true;
@@ -57,7 +58,7 @@ protected override bool TryCreateMethodScope(TypeDefinition type, MethodDefiniti
             methodScope.LanguageSpecifics = ls;
         }
 
-        var localScopes = GetLocalSymbols(method.Handle.RowId, sequencePoints, methodScope);
+        var localScopes = GetLocalSymbols(method, sequencePoints, methodScope);
         methodScope.Scopes = ConcatMethodScopes(methodScope.Scopes ?? null, localScopes);
         return true;
     }
@@ -98,16 +99,17 @@ protected override bool TryCreateMethodScopeForGeneratedMethod(MethodDefinition
             return false;
         }
 
-        if (!DatadogMetadataReader.HasSequencePoints(generatedMethod.Handle.RowId))
+        var methodToken = MetadataTokens.GetToken(generatedMethod.Handle);
+        if (!DatadogMetadataReader.HasSequencePoints(methodToken))
         {
             return false;
         }
 
-        var cdi = DatadogMetadataReader.GetAsyncAndClosureCustomDebugInfo(generatedMethod.Handle.RowId);
+        var cdi = DatadogMetadataReader.GetAsyncAndClosureCustomDebugInfo(methodToken);
         string? methodName;
-        if (cdi.StateMachineHoistedLocal && method.Handle.RowId == cdi.StateMachineKickoffMethodRid)
+        if (cdi.StateMachineHoistedLocal && MetadataTokens.GetToken(method.Handle) == cdi.StateMachineKickoffMethodToken)
         {
-            var kickoffDef = DatadogMetadataReader.GetMethodDef(cdi.StateMachineKickoffMethodRid);
+            var kickoffDef = DatadogMetadataReader.GetMethodDef(cdi.StateMachineKickoffMethodToken);
             methodName = MetadataReader.GetString(kickoffDef.Name);
         }
         else
@@ -141,19 +143,21 @@ protected override bool TryCreateMethodScopeForGeneratedMethod(MethodDefinition
         return true;
     }
 
-    private Model.Scope[]? GetLocalSymbols(int rowId, VendoredMicrosoftCode.System.ReadOnlySpan<DatadogMetadataReader.DatadogSequencePoint> sequencePoints, Model.Scope methodScope)
+    private Model.Scope[]? GetLocalSymbols(MethodDefinition methodDefinition, VendoredMicrosoftCode.System.ReadOnlySpan<DatadogMetadataReader.DatadogSequencePoint> sequencePoints, Model.Scope methodScope)
     {
         List<Model.Scope>? scopes = null;
         var generatedClassPrefix = Datadog.Trace.VendoredMicrosoftCode.System.MemoryExtensions.AsSpan(GeneratedClassPrefix);
 
-        if (DatadogMetadataReader.GetAsyncAndClosureCustomDebugInfo(rowId).StateMachineHoistedLocal && DatadogMetadataReader.IsCompilerGeneratedAttributeDefinedOnType(MetadataReader.GetMethodDefinition(MethodDefinitionHandle.FromRowId(rowId)).GetDeclaringType().RowId))
+        var methodToken = MetadataTokens.GetToken(methodDefinition.Handle);
+        if (DatadogMetadataReader.GetAsyncAndClosureCustomDebugInfo(methodToken).StateMachineHoistedLocal
+         && DatadogMetadataReader.IsCompilerGeneratedAttributeDefinedOnType(MetadataTokens.GetToken(methodDefinition.GetDeclaringType())))
         {
             scopes = new List<Model.Scope>();
             var scope = new Model.Scope();
             using var localsMemory = ArrayMemoryPool<Model.Symbol>.Shared.Rent();
             var localIndex = 0;
             var localSymbols = localsMemory.Memory.Span;
-            var fields = MetadataReader.GetTypeDefinition(DatadogMetadataReader.GetMethodDef(rowId).GetDeclaringType()).GetFields();
+            var fields = MetadataReader.GetTypeDefinition(methodDefinition.GetDeclaringType()).GetFields();
             foreach (var fieldHandle in fields)
             {
                 var field = MetadataReader.GetFieldDefinition(fieldHandle);
@@ -222,7 +226,7 @@ protected override bool TryCreateMethodScopeForGeneratedMethod(MethodDefinition
             scopes.Add(scope);
         }
 
-        var localScopes = DatadogMetadataReader.GetLocalSymbols(rowId, sequencePoints, false);
+        var localScopes = DatadogMetadataReader.GetLocalSymbols(methodToken, sequencePoints, false);
         if (localScopes is not { Length: > 0 })
         {
             return scopes?.ToArray();
@@ -245,10 +249,10 @@ protected override bool TryCreateMethodScopeForGeneratedMethod(MethodDefinition
 
                 if (Datadog.Trace.VendoredMicrosoftCode.System.MemoryExtensions.IndexOf(nameAsSpan, generatedClassPrefix, StringComparison.Ordinal) > 0)
                 {
-                    var cdi = DatadogMetadataReader.GetAsyncAndClosureCustomDebugInfo(rowId);
+                    var cdi = DatadogMetadataReader.GetAsyncAndClosureCustomDebugInfo(methodToken);
                     if (cdi.EncLambdaAndClosureMap || cdi.LocalSlot)
                     {
-                        var nestedTypes = MetadataReader.GetTypeDefinition(DatadogMetadataReader.GetMethodDef(rowId).GetDeclaringType()).GetNestedTypes();
+                        var nestedTypes = MetadataReader.GetTypeDefinition(methodDefinition.GetDeclaringType()).GetNestedTypes();
                         for (int i = 0; i < nestedTypes.Length; i++)
                         {
                             var nestedHandle = nestedTypes[i];

tracer/src/Datadog.Trace/PDBs/DatadogMetadataReader.Dnlib.cs

@@ -26,14 +26,14 @@ internal partial class DatadogMetadataReader : IDisposable
 
         private SymbolReader? DnlibPdbReader { get; }
 
-        private MethodDef? GetMethodDefDnlib(uint methodRid)
+        private MethodDef? GetMethodDefDnlib(int methodToken)
         {
-            return _dnlibModule?.ResolveMethod(methodRid);
+            return _dnlibModule?.ResolveMethod((uint)RidOf(methodToken));
         }
 
-        private List<SymbolScope>? GetAllScopes(uint methodRid, bool searchMoveNext)
+        private List<SymbolScope>? GetAllScopes(int methodToken, bool searchMoveNext)
         {
-            var method = GetSymbolMethodDnlib(methodRid, searchMoveNext);
+            var method = GetSymbolMethodDnlib(methodToken, searchMoveNext);
             if (method == null)
             {
                 return null;
@@ -59,9 +59,9 @@ void RetrieveAllNestedScopes(SymbolScope? scope, List<SymbolScope> scopes)
             }
         }
 
-        private string[]? GetLocalVariableNamesDnlib(int methodRid, int localVariablesCount, bool searchMoveNext)
+        private string[]? GetLocalVariableNamesDnlib(int methodToken, int localVariablesCount, bool searchMoveNext)
         {
-            if (GetSymbolMethodDnlib((uint)methodRid, searchMoveNext) is not { } symbolMethod)
+            if (GetSymbolMethodDnlib(methodToken, searchMoveNext) is not { } symbolMethod)
             {
                 return null;
             }
@@ -89,9 +89,14 @@ void RetrieveAllNestedScopes(SymbolScope? scope, List<SymbolScope> scopes)
             return localNames;
         }
 
-        private SymbolMethod? GetSymbolMethodDnlib(uint methodRid, bool searchMoveNext)
+        private SymbolMethod? GetSymbolMethodDnlib(int methodToken, bool searchMoveNext)
         {
-            var mdMethod = GetMethodDefDnlib(methodRid);
+            var mdMethod = GetMethodDefDnlib(methodToken);
+            if (mdMethod == null)
+            {
+                return null;
+            }
+
             return searchMoveNext ? (GetSymbolMethodOfAsyncMethodDnlib(mdMethod) ?? DnlibPdbReader?.GetMethod(mdMethod, version: 1)) : DnlibPdbReader?.GetMethod(mdMethod, version: 1);
         }
 
@@ -114,17 +119,17 @@ void RetrieveAllNestedScopes(SymbolScope? scope, List<SymbolScope> scopes)
             return DnlibPdbReader?.GetMethod(breakpointMethod.Value.BreakpointMethod, version: 1);
         }
 
-        private ImmutableArray<LocalScope>? GetLocalSymbolsDnlib(int methodRid, VendoredMicrosoftCode.System.ReadOnlySpan<DatadogSequencePoint> sequencePoints, bool searchMoveNext)
+        private ImmutableArray<LocalScope>? GetLocalSymbolsDnlib(int methodToken, VendoredMicrosoftCode.System.ReadOnlySpan<DatadogSequencePoint> sequencePoints, bool searchMoveNext)
         {
             ImmutableArray<LocalScope>.Builder? localScopes = null;
-            var method = GetMethodDefDnlib((uint)methodRid);
+            var method = GetMethodDefDnlib(methodToken);
             if (method!.Body is not { Variables.Count: > 0 })
             {
                 return null;
             }
 
             var methodLocals = method.Body.Variables;
-            var allMethodScopes = GetAllScopes(method.MDToken.Rid, searchMoveNext);
+            var allMethodScopes = GetAllScopes(method.MDToken.ToInt32(), searchMoveNext);
             if (allMethodScopes == null)
             {
                 return null;
@@ -197,10 +202,10 @@ void RetrieveAllNestedScopes(SymbolScope? scope, List<SymbolScope> scopes)
             return localScopes.ToImmutable();
         }
 
-        private CustomDebugInfoAsyncAndClosure GetAsyncAndClosureCustomDebugInfoDnlib(int methodRid)
+        private CustomDebugInfoAsyncAndClosure GetAsyncAndClosureCustomDebugInfoDnlib(int methodToken)
         {
             CustomDebugInfoAsyncAndClosure cdiAsyncAndClosure = default;
-            Datadog.Trace.Vendors.dnlib.DotNet.MethodDef? method = GetMethodDefDnlib((uint)methodRid);
+            Datadog.Trace.Vendors.dnlib.DotNet.MethodDef? method = GetMethodDefDnlib(methodToken);
             if (method is not { HasCustomDebugInfos: true })
             {
                 return cdiAsyncAndClosure;
@@ -215,7 +220,7 @@ private CustomDebugInfoAsyncAndClosure GetAsyncAndClosureCustomDebugInfoDnlib(in
                 else if (methodCustomDebugInfo.Kind is PdbCustomDebugInfoKind.AsyncMethod)
                 {
                     cdiAsyncAndClosure.StateMachineHoistedLocal = true;
-                    cdiAsyncAndClosure.StateMachineKickoffMethodRid = (int)((PdbAsyncMethodCustomDebugInfo)methodCustomDebugInfo).KickoffMethod.MDToken.Rid;
+                    cdiAsyncAndClosure.StateMachineKickoffMethodToken = ((PdbAsyncMethodCustomDebugInfo)methodCustomDebugInfo).KickoffMethod.MDToken.ToInt32();
                 }
             }
 
@@ -239,10 +244,10 @@ private CustomDebugInfoAsyncAndClosure GetAsyncAndClosureCustomDebugInfoDnlib(in
             return sourceLink == null ? null : Encoding.UTF8.GetString(sourceLink.FileBlob);
         }
 
-        private IMemoryOwner<DatadogSequencePoint>? GetMethodSequencePointsDnlib(int methodRid, bool searchMoveNext, out int count)
+        private IMemoryOwner<DatadogSequencePoint>? GetMethodSequencePointsDnlib(int methodToken, bool searchMoveNext, out int count)
         {
             count = 0;
-            var symbolMethod = GetSymbolMethodDnlib((uint)methodRid, searchMoveNext);
+            var symbolMethod = GetSymbolMethodDnlib(methodToken, searchMoveNext);
             if (symbolMethod == null)
             {
                 return null;
@@ -276,9 +281,9 @@ private CustomDebugInfoAsyncAndClosure GetAsyncAndClosureCustomDebugInfoDnlib(in
             return memory;
         }
 
-        private DatadogSequencePoint? GetMethodSourceLocationDnlib(int methodRid, bool searchMoveNext)
+        private DatadogSequencePoint? GetMethodSourceLocationDnlib(int methodToken, bool searchMoveNext)
         {
-            var symbolMethod = GetSymbolMethodDnlib((uint)methodRid, searchMoveNext);
+            var symbolMethod = GetSymbolMethodDnlib(methodToken, searchMoveNext);
             if (symbolMethod == null)
             {
                 return null;