Add sample files

data/raw_sample/diffs/000142d2876d424ad9e7b0e1f67f4fb5ca4d5a69.diff

@@ -0,0 +1,204 @@
+diff --git a/src/coreclr/src/inc/clrconfigvalues.h b/src/coreclr/src/inc/clrconfigvalues.h
+index 32d07226003dc7..f92167f0dfdb5b 100644
+--- a/src/coreclr/src/inc/clrconfigvalues.h
++++ b/src/coreclr/src/inc/clrconfigvalues.h
+@@ -712,7 +712,7 @@ RETAIL_CONFIG_DWORD_INFO(INTERNAL_EventPipeProcNumbers, W("EventPipeProcNumbers"
+ //
+ // Diagnostics Ports
+ //
+-RRETAIL_CONFIG_DWORD_INFO_EX(EXTERNAL_DOTNET_DiagnosticPortSuspend, W("DOTNET_DiagnosticPortSuspend"), 1, "This will cause the runtime to pause during startup before major subsystems are started.  Resume using the Diagnostics IPC ResumeStartup command.", CLRConfig::DontPrependCOMPlus_);
++RETAIL_CONFIG_DWORD_INFO_EX(EXTERNAL_DOTNET_DiagnosticPortSuspend, W("DOTNET_DiagnosticPortSuspend"), 0, "This will cause the runtime to pause during startup before major subsystems are started.  Resume using the Diagnostics IPC ResumeStartup command.", CLRConfig::DontPrependCOMPlus_);
+ RETAIL_CONFIG_STRING_INFO_EX(EXTERNAL_DOTNET_DiagnosticPorts, W("DOTNET_DiagnosticPorts"), "A semicolon delimited list of additional Diagnostic Ports, where a Diagnostic Port is a NamedPipe path without '\\\\.\\pipe\\' on Windows or the full path of Unix Domain Socket on Linux/Unix followed by optional tags, e.g., '<path>,listen,nosuspend;<path>,connect'", CLRConfig::DontPrependCOMPlus_);
+ 
+ //
+diff --git a/src/coreclr/src/vm/ipcstreamfactory.cpp b/src/coreclr/src/vm/ipcstreamfactory.cpp
+index df18c7602585a0..75b7fb3a0c4117 100644
+--- a/src/coreclr/src/vm/ipcstreamfactory.cpp
++++ b/src/coreclr/src/vm/ipcstreamfactory.cpp
+@@ -15,11 +15,11 @@ CQuickArrayList<LPSTR> split(LPSTR string, LPCSTR delimiters)
+ {
+     CQuickArrayList<LPSTR> parts;
+     char *context;
+-    char *portConfig = nullptr;
++    char *part = nullptr;
+     for (char *cursor = string; ; cursor = nullptr)
+     {
+-        if ((portConfig = strtok_s(cursor, delimiters, &context)) != nullptr)
+-            parts.Push(portConfig);
++        if ((part = strtok_s(cursor, delimiters, &context)) != nullptr)
++            parts.Push(part);
+         else
+             break;
+     }
+@@ -110,11 +110,14 @@ bool IpcStreamFactory::Configure(ErrorCallback callback)
+ 
+             ASSERT(portConfigParts.Size() >= 1);
+             if (portConfigParts.Size() == 0)
++            {
++                fSuccess &= false;
+                 continue;
++            }
+ 
+-            builder.WithPath(portConfigParts.Pop());
+-            while (portConfigParts.Size() > 0)
++            while (portConfigParts.Size() > 1)
+                 builder.WithTag(portConfigParts.Pop());
++            builder.WithPath(portConfigParts.Pop());
+ 
+             const bool fBuildSuccess = BuildAndAddPort(builder, callback);
+             STRESS_LOG1(LF_DIAGNOSTICS_PORT, LL_INFO10, "IpcStreamFactory::Configure - Diagnostic Port creation succeeded? %d \n", fBuildSuccess);
+diff --git a/src/coreclr/src/vm/ipcstreamfactory.h b/src/coreclr/src/vm/ipcstreamfactory.h
+index 80554b7d523884..cfd286beee0bba 100644
+--- a/src/coreclr/src/vm/ipcstreamfactory.h
++++ b/src/coreclr/src/vm/ipcstreamfactory.h
+@@ -32,7 +32,7 @@ class IpcStreamFactory
+         DiagnosticPortType Type = DiagnosticPortType::LISTEN;
+         DiagnosticPortSuspendMode SuspendMode = DiagnosticPortSuspendMode::NOSUSPEND;
+ 
+-        DiagnosticPortBuilder WithPath(LPSTR path) { Path = _strdup(path); return *this; }
++        DiagnosticPortBuilder WithPath(LPSTR path) { Path = path != nullptr ? _strdup(path) : nullptr; return *this; }
+         DiagnosticPortBuilder WithType(DiagnosticPortType type) { Type = type; return *this; }
+         DiagnosticPortBuilder WithSuspendMode(DiagnosticPortSuspendMode mode) { SuspendMode = mode; return *this; }
+         DiagnosticPortBuilder WithTag(LPSTR tag)
+diff --git a/src/tests/tracing/eventpipe/common/IpcUtils.cs b/src/tests/tracing/eventpipe/common/IpcUtils.cs
+index bf17e1e27e837b..73e817859ad828 100644
+--- a/src/tests/tracing/eventpipe/common/IpcUtils.cs
++++ b/src/tests/tracing/eventpipe/common/IpcUtils.cs
+@@ -21,8 +21,8 @@ namespace Tracing.Tests.Common
+ {
+     public static class Utils
+     {
+-        public static readonly string DiagnosticsMonitorAddressEnvKey = "DOTNET_DiagnosticsMonitorAddress";
+-        public static readonly string DiagnosticsMonitorPauseOnStartEnvKey = "DOTNET_DiagnosticsMonitorPauseOnStart";
++        public static readonly string DiagnosticPortsEnvKey = "DOTNET_DiagnosticPorts";
++        public static readonly string DiagnosticPortSuspend = "DOTNET_DiagnosticPortSuspend";
+ 
+         public static async Task<T> WaitTillTimeout<T>(Task<T> task, TimeSpan timeout)
+         {
+diff --git a/src/tests/tracing/eventpipe/pauseonstart/pauseonstart.cs b/src/tests/tracing/eventpipe/pauseonstart/pauseonstart.cs
+index 4065cd586feef1..e87d367651b06b 100644
+--- a/src/tests/tracing/eventpipe/pauseonstart/pauseonstart.cs
++++ b/src/tests/tracing/eventpipe/pauseonstart/pauseonstart.cs
+@@ -28,7 +28,7 @@ public static async Task<bool> TEST_RuntimeResumesExecutionWithCommand()
+             var server = new ReverseServer(serverName);
+             Task<bool> subprocessTask = Utils.RunSubprocess(
+                 currentAssembly: Assembly.GetExecutingAssembly(),
+-                environment: new Dictionary<string,string> { { Utils.DiagnosticsMonitorAddressEnvKey, serverName } },
++                environment: new Dictionary<string,string> { { Utils.DiagnosticPortsEnvKey, $"{serverName},connect,suspend" } },
+                 duringExecution: async (_) =>
+                 {
+                     Stream stream = await server.AcceptAsync();
+@@ -56,7 +56,7 @@ public static async Task<bool> TEST_TracesHaveRelevantEvents()
+             using var memoryStream = new MemoryStream();
+             Task<bool> subprocessTask = Utils.RunSubprocess(
+                 currentAssembly: Assembly.GetExecutingAssembly(),
+-                environment: new Dictionary<string,string> { { Utils.DiagnosticsMonitorAddressEnvKey, serverName } },
++                environment: new Dictionary<string,string> { { Utils.DiagnosticPortsEnvKey, $"{serverName},connect,suspend" } },
+                 duringExecution: async (pid) =>
+                 {
+                     Stream stream = await server.AcceptAsync();
+@@ -114,7 +114,7 @@ public static async Task<bool> TEST_MultipleSessionsCanBeStartedWhilepaused()
+             using var memoryStream3 = new MemoryStream();
+             Task<bool> subprocessTask = Utils.RunSubprocess(
+                 currentAssembly: Assembly.GetExecutingAssembly(),
+-                environment: new Dictionary<string,string> { { Utils.DiagnosticsMonitorAddressEnvKey, serverName } },
++                environment: new Dictionary<string,string> { { Utils.DiagnosticPortsEnvKey, $"{serverName},connect,suspend" } },
+                 duringExecution: async (pid) =>
+                 {
+                     Stream stream = await server.AcceptAsync();
+@@ -207,7 +207,7 @@ public static async Task<bool> TEST_CanStartAndStopSessionWhilepaused()
+             using var memoryStream3 = new MemoryStream();
+             Task<bool> subprocessTask = Utils.RunSubprocess(
+                 currentAssembly: Assembly.GetExecutingAssembly(),
+-                environment: new Dictionary<string,string> { { Utils.DiagnosticsMonitorAddressEnvKey, serverName } },
++                environment: new Dictionary<string,string> { { Utils.DiagnosticPortsEnvKey, $"{serverName},connect,suspend" } },
+                 duringExecution: async (pid) =>
+                 {
+                     Stream stream = await server.AcceptAsync();
+@@ -271,7 +271,7 @@ public static async Task<bool> TEST_DisabledCommandsError()
+             using var memoryStream3 = new MemoryStream();
+             Task<bool> subprocessTask = Utils.RunSubprocess(
+                 currentAssembly: Assembly.GetExecutingAssembly(),
+-                environment: new Dictionary<string,string> { { Utils.DiagnosticsMonitorAddressEnvKey, serverName } },
++                environment: new Dictionary<string,string> { { Utils.DiagnosticPortsEnvKey, $"{serverName},connect,suspend" } },
+                 duringExecution: async (pid) =>
+                 {
+                     Stream stream = await server.AcceptAsync();
+diff --git a/src/tests/tracing/eventpipe/reverse/reverse.cs b/src/tests/tracing/eventpipe/reverse/reverse.cs
+index 05436e574d6436..6ce09ea82b81b7 100644
+--- a/src/tests/tracing/eventpipe/reverse/reverse.cs
++++ b/src/tests/tracing/eventpipe/reverse/reverse.cs
+@@ -28,8 +28,7 @@ public static async Task<bool> TEST_RuntimeIsResilientToServerClosing()
+                 currentAssembly: Assembly.GetExecutingAssembly(),
+                 environment: new Dictionary<string,string> 
+                 {
+-                    { Utils.DiagnosticsMonitorAddressEnvKey, serverName },
+-                    { Utils.DiagnosticsMonitorPauseOnStartEnvKey, "0" }
++                    { Utils.DiagnosticPortsEnvKey, $"{serverName},connect,nosuspend" }
+                 },
+                 duringExecution: async (_) =>
+                 {
+@@ -59,8 +58,7 @@ public static async Task<bool> TEST_RuntimeConnectsToExistingServer()
+                 currentAssembly: Assembly.GetExecutingAssembly(),
+                 environment: new Dictionary<string,string> 
+                 {
+-                    { Utils.DiagnosticsMonitorAddressEnvKey, serverName },
+-                    { Utils.DiagnosticsMonitorPauseOnStartEnvKey, "0" }
++                    { Utils.DiagnosticPortsEnvKey, $"{serverName},connect,nosuspend" }
+                 },
+                 duringExecution: async (_) => 
+                 {
+@@ -85,8 +83,7 @@ public static async Task<bool> TEST_CanConnectServerAndClientAtSameTime()
+                 currentAssembly: Assembly.GetExecutingAssembly(),
+                 environment: new Dictionary<string,string> 
+                 {
+-                    { Utils.DiagnosticsMonitorAddressEnvKey, serverName },
+-                    { Utils.DiagnosticsMonitorPauseOnStartEnvKey, "0" }
++                    { Utils.DiagnosticPortsEnvKey, $"{serverName},connect,nosuspend" }
+                 },
+                 duringExecution: async (int pid) =>
+                 {
+@@ -139,8 +136,7 @@ public static async Task<bool> TEST_ServerWorksIfClientDoesntAccept()
+                 currentAssembly: Assembly.GetExecutingAssembly(),
+                 environment: new Dictionary<string,string> 
+                 {
+-                    { Utils.DiagnosticsMonitorAddressEnvKey, serverName },
+-                    { Utils.DiagnosticsMonitorPauseOnStartEnvKey, "0" }
++                    { Utils.DiagnosticPortsEnvKey, $"{serverName},connect,nosuspend" }
+                 },
+                 duringExecution: async (int pid) =>
+                 {
+@@ -181,8 +177,7 @@ public static async Task<bool> TEST_ServerIsResilientToNoBufferAgent()
+                 currentAssembly: Assembly.GetExecutingAssembly(),
+                 environment: new Dictionary<string,string> 
+                 {
+-                    { Utils.DiagnosticsMonitorAddressEnvKey, serverName },
+-                    { Utils.DiagnosticsMonitorPauseOnStartEnvKey, "0" }
++                    { Utils.DiagnosticPortsEnvKey, $"{serverName},connect,nosuspend" }
+                 },
+                 duringExecution: async (int pid) =>
+                 {
+@@ -220,8 +215,7 @@ public static async Task<bool> TEST_StandardConnectionStillWorksIfReverseConnect
+                 currentAssembly: Assembly.GetExecutingAssembly(),
+                 environment: new Dictionary<string,string> 
+                 {
+-                    { Utils.DiagnosticsMonitorAddressEnvKey, serverName },
+-                    { Utils.DiagnosticsMonitorPauseOnStartEnvKey, "0" }
++                    { Utils.DiagnosticPortsEnvKey, $"{serverName},connect,nosuspend" }
+                 },
+                 duringExecution: async (int pid) =>
+                 {
+diff --git a/src/tests/tracing/eventpipe/reverseouter/reverseouter.cs b/src/tests/tracing/eventpipe/reverseouter/reverseouter.cs
+index ff01fbc0f449f1..6d3c0e4657cd84 100644
+--- a/src/tests/tracing/eventpipe/reverseouter/reverseouter.cs
++++ b/src/tests/tracing/eventpipe/reverseouter/reverseouter.cs
+@@ -28,8 +28,7 @@ public static async Task<bool> TEST_ReverseConnectionCanRecycleWhileTracing()
+                 currentAssembly: Assembly.GetExecutingAssembly(),
+                 environment: new Dictionary<string,string> 
+                 {
+-                    { Utils.DiagnosticsMonitorAddressEnvKey, serverName },
+-                    { Utils.DiagnosticsMonitorPauseOnStartEnvKey, "0" }
++                    { Utils.DiagnosticPortsEnvKey, $"{serverName},connect,nosuspend" }
+                 },
+                 duringExecution: async (int pid) =>
+                 {

data/raw_sample/diffs/0001a6da1bc38074bea56262468e0171b521fe56.diff

@@ -0,0 +1,178 @@
+diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs
+index b10ec23495b98d..6e89f50a1ea294 100644
+--- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs
++++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/CastHelpers.cs
+@@ -24,11 +24,26 @@ internal static void ThrowInvalidCastException(object fromType, void* toTypeHnd)
+             throw null!; // Provide hint to the inliner that this method does not return
+         }
+ 
+-        [MethodImpl(MethodImplOptions.InternalCall)]
+-        private static extern object IsInstanceOfAny_NoCacheLookup(void* toTypeHnd, object obj);
++        [LibraryImport(RuntimeHelpers.QCall)]
++        [return: MarshalAs(UnmanagedType.Bool)]
++        private static partial bool IsInstanceOf_NoCacheLookup(void *toTypeHnd, [MarshalAs(UnmanagedType.Bool)] bool throwCastException, ObjectHandleOnStack obj);
+ 
+-        [MethodImpl(MethodImplOptions.InternalCall)]
+-        private static extern object ChkCastAny_NoCacheLookup(void* toTypeHnd, object obj);
++        [MethodImpl(MethodImplOptions.NoInlining)]
++        private static object? IsInstanceOfAny_NoCacheLookup(void* toTypeHnd, object obj)
++        {
++            if (IsInstanceOf_NoCacheLookup(toTypeHnd, false, ObjectHandleOnStack.Create(ref obj)))
++            {
++                return obj;
++            }
++            return null;
++        }
++
++        [MethodImpl(MethodImplOptions.NoInlining)]
++        private static object ChkCastAny_NoCacheLookup(void* toTypeHnd, object obj)
++        {
++            IsInstanceOf_NoCacheLookup(toTypeHnd, true, ObjectHandleOnStack.Create(ref obj));
++            return obj;
++        }
+ 
+         [MethodImpl(MethodImplOptions.InternalCall)]
+         private static extern void WriteBarrier(ref object? dst, object? obj);
+@@ -464,13 +479,13 @@ private static void StelemRef_Helper_NoCacheLookup(ref object? element, void* el
+         {
+             Debug.Assert(obj != null);
+ 
+-            obj = IsInstanceOfAny_NoCacheLookup(elementType, obj);
+-            if (obj == null)
++            object? obj2 = IsInstanceOfAny_NoCacheLookup(elementType, obj);
++            if (obj2 == null)
+             {
+                 ThrowArrayMismatchException();
+             }
+ 
+-            WriteBarrier(ref element, obj);
++            WriteBarrier(ref element, obj2);
+         }
+ 
+         [DebuggerHidden]
+@@ -496,8 +511,7 @@ private static unsafe void ArrayTypeCheck_Helper(object obj, void* elementType)
+         {
+             Debug.Assert(obj != null);
+ 
+-            obj = IsInstanceOfAny_NoCacheLookup(elementType, obj);
+-            if (obj == null)
++            if (IsInstanceOfAny_NoCacheLookup(elementType, obj) == null)
+             {
+                 ThrowArrayMismatchException();
+             }
+diff --git a/src/coreclr/vm/JitQCallHelpers.h b/src/coreclr/vm/JitQCallHelpers.h
+index ff3bfa97981f3e..f229bff39f9fca 100644
+--- a/src/coreclr/vm/JitQCallHelpers.h
++++ b/src/coreclr/vm/JitQCallHelpers.h
+@@ -24,5 +24,6 @@ extern "C" void QCALLTYPE InitClassHelper(MethodTable* pMT);
+ extern "C" void QCALLTYPE ThrowInvalidCastException(CORINFO_CLASS_HANDLE pTargetType, CORINFO_CLASS_HANDLE pSourceType);
+ extern "C" void QCALLTYPE GetThreadStaticsByMethodTable(QCall::ByteRefOnStack refHandle, MethodTable* pMT, bool gcStatic);
+ extern "C" void QCALLTYPE GetThreadStaticsByIndex(QCall::ByteRefOnStack refHandle, uint32_t staticBlockIndex, bool gcStatic);
++extern "C" BOOL QCALLTYPE IsInstanceOf_NoCacheLookup(CORINFO_CLASS_HANDLE type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack);
+ 
+ #endif //_JITQCALLHELPERS_H
+diff --git a/src/coreclr/vm/ecalllist.h b/src/coreclr/vm/ecalllist.h
+index 5aff25d5caa72c..a934364e77591c 100644
+--- a/src/coreclr/vm/ecalllist.h
++++ b/src/coreclr/vm/ecalllist.h
+@@ -256,8 +256,6 @@ FCFuncStart(gThreadPoolFuncs)
+ FCFuncEnd()
+ 
+ FCFuncStart(gCastHelpers)
+-    FCFuncElement("IsInstanceOfAny_NoCacheLookup", ::IsInstanceOfAny_NoCacheLookup)
+-    FCFuncElement("ChkCastAny_NoCacheLookup", ::ChkCastAny_NoCacheLookup)
+     FCFuncElement("WriteBarrier", ::WriteBarrier_Helper)
+ FCFuncEnd()
+ 
+diff --git a/src/coreclr/vm/jithelpers.cpp b/src/coreclr/vm/jithelpers.cpp
+index 197c2035a847a5..780323637cf4bd 100644
+--- a/src/coreclr/vm/jithelpers.cpp
++++ b/src/coreclr/vm/jithelpers.cpp
+@@ -781,51 +781,22 @@ BOOL ObjIsInstanceOf(Object* pObject, TypeHandle toTypeHnd, BOOL throwCastExcept
+     return ObjIsInstanceOfCore(pObject, toTypeHnd, throwCastException);
+ }
+ 
+-HCIMPL2(Object*, ChkCastAny_NoCacheLookup, CORINFO_CLASS_HANDLE type, Object* obj)
++extern "C" BOOL QCALLTYPE IsInstanceOf_NoCacheLookup(CORINFO_CLASS_HANDLE type, BOOL throwCastException, QCall::ObjectHandleOnStack objOnStack)
+ {
+-    FCALL_CONTRACT;
+-
+-    // This case should be handled by frameless helper
+-    _ASSERTE(obj != NULL);
+-
+-    OBJECTREF oref = ObjectToOBJECTREF(obj);
+-    VALIDATEOBJECTREF(oref);
+-
+-    TypeHandle clsHnd(type);
+-
+-    HELPER_METHOD_FRAME_BEGIN_RET_1(oref);
+-    if (!ObjIsInstanceOfCore(OBJECTREFToObject(oref), clsHnd, TRUE))
+-    {
+-        UNREACHABLE(); //ObjIsInstanceOf will throw if cast can't be done
+-    }
+-    HELPER_METHOD_POLL();
+-    HELPER_METHOD_FRAME_END();
+-
+-    return OBJECTREFToObject(oref);
+-}
+-HCIMPLEND
+-
+-HCIMPL2(Object*, IsInstanceOfAny_NoCacheLookup, CORINFO_CLASS_HANDLE type, Object* obj)
+-{
+-    FCALL_CONTRACT;
++    QCALL_CONTRACT;
++    BOOL result = FALSE;
+ 
+-    // This case should be handled by frameless helper
+-    _ASSERTE(obj != NULL);
++    BEGIN_QCALL;
+ 
+-    OBJECTREF oref = ObjectToOBJECTREF(obj);
+-    VALIDATEOBJECTREF(oref);
++    GCX_COOP();
+ 
+     TypeHandle clsHnd(type);
++    result = ObjIsInstanceOfCore(OBJECTREFToObject(objOnStack.Get()), clsHnd, throwCastException);
+ 
+-    HELPER_METHOD_FRAME_BEGIN_RET_1(oref);
+-    if (!ObjIsInstanceOfCore(OBJECTREFToObject(oref), clsHnd))
+-        oref = NULL;
+-    HELPER_METHOD_POLL();
+-    HELPER_METHOD_FRAME_END();
++    END_QCALL;
+ 
+-    return OBJECTREFToObject(oref);
++    return result;
+ }
+-HCIMPLEND
+ 
+ //========================================================================
+ //
+diff --git a/src/coreclr/vm/jitinterface.h b/src/coreclr/vm/jitinterface.h
+index 0de84367ab3c70..a99604cd66716c 100644
+--- a/src/coreclr/vm/jitinterface.h
++++ b/src/coreclr/vm/jitinterface.h
+@@ -236,10 +236,7 @@ extern "C" FCDECL2(VOID, JIT_CheckedWriteBarrier, Object **dst, Object *ref);
+ extern "C" FCDECL2(VOID, JIT_WriteBarrier, Object **dst, Object *ref);
+ extern "C" FCDECL2(VOID, JIT_WriteBarrierEnsureNonHeapTarget, Object **dst, Object *ref);
+ 
+-extern "C" FCDECL2(Object*, ChkCastAny_NoCacheLookup, CORINFO_CLASS_HANDLE type, Object* obj);
+-extern "C" FCDECL2(Object*, IsInstanceOfAny_NoCacheLookup, CORINFO_CLASS_HANDLE type, Object* obj);
+-
+-// ARM64 JIT_WriteBarrier uses speciall ABI and thus is not callable directly
++// ARM64 JIT_WriteBarrier uses special ABI and thus is not callable directly
+ // Copied write barriers must be called at a different location
+ extern "C" FCDECL2(VOID, JIT_WriteBarrier_Callable, Object **dst, Object *ref);
+ 
+diff --git a/src/coreclr/vm/qcallentrypoints.cpp b/src/coreclr/vm/qcallentrypoints.cpp
+index 32dc4c7ed27853..c41ab9e70bdc62 100644
+--- a/src/coreclr/vm/qcallentrypoints.cpp
++++ b/src/coreclr/vm/qcallentrypoints.cpp
+@@ -515,6 +515,7 @@ static const Entry s_QCall[] =
+     DllImportEntry(GetThreadStaticsByIndex)
+     DllImportEntry(GenericHandleWorker)
+     DllImportEntry(ThrowInvalidCastException)
++    DllImportEntry(IsInstanceOf_NoCacheLookup)
+ };
+ 
+ const void* QCallResolveDllImport(const char* name)

data/raw_sample/diffs/0001fcfea66c03e3adba44bf8ead1d1440ad5b7a.diff

@@ -0,0 +1,24 @@
+diff --git a/src/coreclr/src/zap/zapinfo.cpp b/src/coreclr/src/zap/zapinfo.cpp
+index 48d30834b8e241..3b229470e913eb 100644
+--- a/src/coreclr/src/zap/zapinfo.cpp
++++ b/src/coreclr/src/zap/zapinfo.cpp
+@@ -2147,13 +2147,15 @@ DWORD FilterNamedIntrinsicMethodAttribs(ZapInfo* pZapInfo, DWORD attribs, CORINF
+         // is because they often change the code they emit based on what ISAs are supported by the compiler,
+         // but we don't know what the target machine will support.
+         //
+-        // Additionally, we make sure none of the hardware intrinsic method bodies get pregenerated in crossgen
++        // Additionally, we make sure none of the hardware intrinsic method bodies (except ARM64) get pregenerated in crossgen
+         // (see ZapInfo::CompileMethod) but get JITted instead. The JITted method will have the correct
+         // answer for the CPU the code is running on.
+-#if defined(TARGET_ARM64)
++
++        // For Arm64, AdvSimd/ArmBase is the baseline that is suported and hence we do pregenerate the method bodies
++        // of ARM4 harware intrinsic.
+         fTreatAsRegularMethodCall = (fIsGetIsSupportedMethod && fIsPlatformHWIntrinsic);
+-#else
+-        fTreatAsRegularMethodCall = (fIsGetIsSupportedMethod && fIsPlatformHWIntrinsic) || (!fIsPlatformHWIntrinsic && fIsHWIntrinsic);
++#if !defined(TARGET_ARM64)
++        fTreatAsRegularMethodCall |= (!fIsPlatformHWIntrinsic && fIsHWIntrinsic);
+ #endif 
+ 
+ 

data/raw_sample/diffs/00022b5da3c98c9d7693a93fe586034febd46c65.diff

@@ -0,0 +1,31 @@
+diff --git a/eng/testing/tests.mobile.targets b/eng/testing/tests.mobile.targets
+index cd006df4bd1d61..3d1535e026c9bc 100644
+--- a/eng/testing/tests.mobile.targets
++++ b/eng/testing/tests.mobile.targets
+@@ -20,6 +20,11 @@
+     <DebuggerSupport>false</DebuggerSupport>
+   </PropertyGroup>
+ 
++  <PropertyGroup Condition="'$(TargetOS)' == 'Browser' and '$(EnableAggressiveTrimming)' == 'true'">
++    <PublishTrimmed>true</PublishTrimmed>
++    <TrimMode>link</TrimMode>
++  </PropertyGroup>
++
+   <PropertyGroup Condition="'$(TargetOS)' == 'Android'">
+     <RunScriptCommand>$HARNESS_RUNNER android test --instrumentation="net.dot.MonoRunner" --package-name="net.dot.$(AssemblyName)" --app=$EXECUTION_DIR/bin/$(TestProjectName).apk --output-directory=$XHARNESS_OUT -v --</RunScriptCommand>
+   </PropertyGroup>
+diff --git a/eng/testing/tests.props b/eng/testing/tests.props
+index b84e791ba6c99e..bf54e899d4d11e 100644
+--- a/eng/testing/tests.props
++++ b/eng/testing/tests.props
+@@ -30,10 +30,6 @@
+     <RuntimeIdentifier>$(PackageRID)</RuntimeIdentifier>
+     <SelfContained>true</SelfContained>
+   </PropertyGroup>
+-  <PropertyGroup Condition="'$(TargetOS)' == 'Browser' and '$(EnableAggressiveTrimming)' == 'true'">
+-    <PublishTrimmed>true</PublishTrimmed>
+-    <TrimMode>link</TrimMode>
+-  </PropertyGroup>
+ 
+   <!-- Provide runtime options to Mono (interpreter, aot, debugging, etc) -->
+   <ItemGroup Condition="'$(MonoEnvOptions)' != '' and '$(TargetsMobile)' != 'true'">

data/raw_sample/diffs/000230aa9db13b77781b7c7b33fa8a92a39ee58e.diff

@@ -0,0 +1,229 @@
+diff --git a/src/libraries/System.Diagnostics.PerformanceCounter/src/System/Diagnostics/PerformanceCounterLib.cs b/src/libraries/System.Diagnostics.PerformanceCounter/src/System/Diagnostics/PerformanceCounterLib.cs
+index bdd47b922779d8..567a8bf433f1f7 100644
+--- a/src/libraries/System.Diagnostics.PerformanceCounter/src/System/Diagnostics/PerformanceCounterLib.cs
++++ b/src/libraries/System.Diagnostics.PerformanceCounter/src/System/Diagnostics/PerformanceCounterLib.cs
+@@ -45,12 +45,12 @@ internal sealed class PerformanceCounterLib
+         private const string LanguageKeyword = "language";
+         private const string DllName = "netfxperf.dll";
+ 
+-        private const int EnglishLCID = 0x009;
+-
+         private static volatile string s_computerName;
+         private static volatile string s_iniFilePath;
+         private static volatile string s_symbolFilePath;
+ 
++        private static CultureInfo s_englishCulture;
++
+         private PerformanceMonitor _performanceMonitor;
+         private readonly string _machineName;
+         private readonly string _perfLcid;
+@@ -79,6 +79,25 @@ private static object InternalSyncObject
+             }
+         }
+ 
++        private static CultureInfo EnglishCulture
++        {
++            get
++            {
++                if (s_englishCulture is null)
++                {
++                    try
++                    {
++                        s_englishCulture = CultureInfo.GetCultureInfo("en");
++                    }
++                    catch
++                    {
++                        s_englishCulture = CultureInfo.InvariantCulture;
++                    }
++                }
++                return s_englishCulture;
++            }
++        }
++
+         internal PerformanceCounterLib(string machineName, string lcid)
+         {
+             _machineName = machineName;
+@@ -277,11 +296,11 @@ private static string SymbolFilePath
+ 
+         internal static bool CategoryExists(string machine, string category)
+         {
+-            PerformanceCounterLib library = GetPerformanceCounterLib(machine, new CultureInfo(EnglishLCID));
++            PerformanceCounterLib library = GetPerformanceCounterLib(machine, EnglishCulture);
+             if (library.CategoryExists(category))
+                 return true;
+ 
+-            if (CultureInfo.CurrentCulture.Parent.LCID != EnglishLCID)
++            if (CultureInfo.CurrentCulture.Parent.Name != EnglishCulture.Name)
+             {
+                 CultureInfo culture = CultureInfo.CurrentCulture;
+                 while (culture != CultureInfo.InvariantCulture)
+@@ -349,11 +368,11 @@ internal void Close()
+ 
+         internal static bool CounterExists(string machine, string category, string counter)
+         {
+-            PerformanceCounterLib library = GetPerformanceCounterLib(machine, new CultureInfo(EnglishLCID));
++            PerformanceCounterLib library = GetPerformanceCounterLib(machine, EnglishCulture);
+             bool categoryExists = false;
+             bool counterExists = library.CounterExists(category, counter, ref categoryExists);
+ 
+-            if (!categoryExists && CultureInfo.CurrentCulture.Parent.LCID != EnglishLCID)
++            if (!categoryExists && CultureInfo.CurrentCulture.Parent.Name != EnglishCulture.Name)
+             {
+                 CultureInfo culture = CultureInfo.CurrentCulture;
+                 while (culture != CultureInfo.InvariantCulture)
+@@ -753,7 +772,7 @@ internal static string[] GetCategories(string machineName)
+                 culture = culture.Parent;
+             }
+ 
+-            library = GetPerformanceCounterLib(machineName, new CultureInfo(EnglishLCID));
++            library = GetPerformanceCounterLib(machineName, EnglishCulture);
+             return library.GetCategories();
+         }
+ 
+@@ -772,7 +791,7 @@ internal static string GetCategoryHelp(string machine, string category)
+ 
+             //First check the current culture for the category. This will allow
+             //PerformanceCounterCategory.CategoryHelp to return localized strings.
+-            if (CultureInfo.CurrentCulture.Parent.LCID != EnglishLCID)
++            if (CultureInfo.CurrentCulture.Parent.Name != EnglishCulture.Name)
+             {
+                 CultureInfo culture = CultureInfo.CurrentCulture;
+ 
+@@ -788,7 +807,7 @@ internal static string GetCategoryHelp(string machine, string category)
+ 
+             //We did not find the category walking up the culture hierarchy. Try looking
+             // for the category in the default culture English.
+-            library = GetPerformanceCounterLib(machine, new CultureInfo(EnglishLCID));
++            library = GetPerformanceCounterLib(machine, EnglishCulture);
+             help = library.GetCategoryHelp(category);
+ 
+             if (help == null)
+@@ -808,9 +827,9 @@ private string GetCategoryHelp(string category)
+ 
+         internal static CategorySample GetCategorySample(string machine, string category)
+         {
+-            PerformanceCounterLib library = GetPerformanceCounterLib(machine, new CultureInfo(EnglishLCID));
++            PerformanceCounterLib library = GetPerformanceCounterLib(machine, EnglishCulture);
+             CategorySample sample = library.GetCategorySample(category);
+-            if (sample == null && CultureInfo.CurrentCulture.Parent.LCID != EnglishLCID)
++            if (sample == null && CultureInfo.CurrentCulture.Parent.Name != EnglishCulture.Name)
+             {
+                 CultureInfo culture = CultureInfo.CurrentCulture;
+                 while (culture != CultureInfo.InvariantCulture)
+@@ -845,11 +864,11 @@ private CategorySample GetCategorySample(string category)
+ 
+         internal static string[] GetCounters(string machine, string category)
+         {
+-            PerformanceCounterLib library = GetPerformanceCounterLib(machine, new CultureInfo(EnglishLCID));
++            PerformanceCounterLib library = GetPerformanceCounterLib(machine, EnglishCulture);
+             bool categoryExists = false;
+             string[] counters = library.GetCounters(category, ref categoryExists);
+ 
+-            if (!categoryExists && CultureInfo.CurrentCulture.Parent.LCID != EnglishLCID)
++            if (!categoryExists && CultureInfo.CurrentCulture.Parent.Name != EnglishCulture.Name)
+             {
+                 CultureInfo culture = CultureInfo.CurrentCulture;
+                 while (culture != CultureInfo.InvariantCulture)
+@@ -910,7 +929,7 @@ internal static string GetCounterHelp(string machine, string category, string co
+ 
+             //First check the current culture for the counter. This will allow
+             //PerformanceCounter.CounterHelp to return localized strings.
+-            if (CultureInfo.CurrentCulture.Parent.LCID != EnglishLCID)
++            if (CultureInfo.CurrentCulture.Parent.Name != EnglishCulture.Name)
+             {
+                 CultureInfo culture = CultureInfo.CurrentCulture;
+                 while (culture != CultureInfo.InvariantCulture)
+@@ -925,7 +944,7 @@ internal static string GetCounterHelp(string machine, string category, string co
+ 
+             //We did not find the counter walking up the culture hierarchy. Try looking
+             // for the counter in the default culture English.
+-            library = GetPerformanceCounterLib(machine, new CultureInfo(EnglishLCID));
++            library = GetPerformanceCounterLib(machine, EnglishCulture);
+             help = library.GetCounterHelp(category, counter, ref categoryExists);
+ 
+             if (!categoryExists)
+@@ -990,7 +1009,8 @@ private static string[] GetLanguageIds()
+ 
+         internal static PerformanceCounterLib GetPerformanceCounterLib(string machineName, CultureInfo culture)
+         {
+-            string lcidString = culture.LCID.ToString("X3", CultureInfo.InvariantCulture);
++            // EnglishCulture.LCID == 9 will be false only if running with Globalization Invariant Mode. Use "009" at that time as default English language identifier.
++            string lcidString = EnglishCulture.LCID == 9 ? culture.LCID.ToString("X3", CultureInfo.InvariantCulture) : "009";
+ 
+             machineName = (machineName == "." ? ComputerName : machineName).ToLowerInvariant();
+ 
+@@ -1135,11 +1155,11 @@ private Hashtable GetStringTable(bool isHelp)
+ 
+         internal static bool IsCustomCategory(string machine, string category)
+         {
+-            PerformanceCounterLib library = GetPerformanceCounterLib(machine, new CultureInfo(EnglishLCID));
++            PerformanceCounterLib library = GetPerformanceCounterLib(machine, EnglishCulture);
+             if (library.IsCustomCategory(category))
+                 return true;
+ 
+-            if (CultureInfo.CurrentCulture.Parent.LCID != EnglishLCID)
++            if (CultureInfo.CurrentCulture.Parent.Name != EnglishCulture.Name)
+             {
+                 CultureInfo culture = CultureInfo.CurrentCulture;
+                 while (culture != CultureInfo.InvariantCulture)
+@@ -1174,10 +1194,10 @@ internal static PerformanceCounterCategoryType GetCategoryType(string machine, s
+         {
+             PerformanceCounterCategoryType categoryType = PerformanceCounterCategoryType.Unknown;
+ 
+-            PerformanceCounterLib library = GetPerformanceCounterLib(machine, new CultureInfo(EnglishLCID));
++            PerformanceCounterLib library = GetPerformanceCounterLib(machine, EnglishCulture);
+             if (!library.FindCustomCategory(category, out categoryType))
+             {
+-                if (CultureInfo.CurrentCulture.Parent.LCID != EnglishLCID)
++                if (CultureInfo.CurrentCulture.Parent.Name != EnglishCulture.Name)
+                 {
+                     CultureInfo culture = CultureInfo.CurrentCulture;
+                     while (culture != CultureInfo.InvariantCulture)
+diff --git a/src/libraries/System.Diagnostics.PerformanceCounter/tests/PerformanceCounterTests.cs b/src/libraries/System.Diagnostics.PerformanceCounter/tests/PerformanceCounterTests.cs
+index bfaf5fba64b3de..c8df93e8c267b4 100644
+--- a/src/libraries/System.Diagnostics.PerformanceCounter/tests/PerformanceCounterTests.cs
++++ b/src/libraries/System.Diagnostics.PerformanceCounter/tests/PerformanceCounterTests.cs
+@@ -2,8 +2,10 @@
+ // The .NET Foundation licenses this file to you under the MIT license.
+ 
+ using System;
++using System.Globalization;
+ using System.Collections;
+ using System.Collections.Specialized;
++using Microsoft.DotNet.RemoteExecutor;
+ using Xunit;
+ 
+ namespace System.Diagnostics.Tests
+@@ -287,6 +289,32 @@ public static void PerformanceCounter_NextSample_MultiInstance()
+             }
+         }
+ 
++        private static bool CanRunInInvariantMode => RemoteExecutor.IsSupported && !PlatformDetection.IsNetFramework;
++
++        [ConditionalTheory(nameof(CanRunInInvariantMode))]
++        [PlatformSpecific(TestPlatforms.Windows)]
++        [InlineData(true)]
++        [InlineData(false)]
++        public static void RunWithGlobalizationInvariantModeTest(bool predefinedCultures)
++        {
++            ProcessStartInfo psi = new ProcessStartInfo() {  UseShellExecute = false };
++            psi.Environment.Add("DOTNET_SYSTEM_GLOBALIZATION_INVARIANT", "1");
++            psi.Environment.Add("DOTNET_SYSTEM_GLOBALIZATION_PREDEFINED_CULTURES_ONLY", predefinedCultures ? "1" : "0");
++            RemoteExecutor.Invoke(() =>
++            {
++                // Ensure we are running inside the Globalization invariant mode.
++                Assert.Equal("", CultureInfo.CurrentCulture.Name);
++
++                // This test ensure creating PerformanceCounter object while we are running with Globalization Invariant Mode.
++                // PerformanceCounter used to create cultures using LCID's which fail in Globalization Invariant Mode.
++                // This test ensure no failure should be encountered in this case.
++                using (PerformanceCounter counterSample = new PerformanceCounter("Processor", "Interrupts/sec", "0", "."))
++                {
++                    Assert.Equal("Processor", counterSample.CategoryName);
++                }
++            }, new RemoteInvokeOptions { StartInfo =  psi}).Dispose();
++        }
++
+         public static PerformanceCounter CreateCounterWithCategory(string name, bool readOnly, PerformanceCounterCategoryType categoryType )
+         {
+             var category = Helpers.CreateCategory(name, categoryType);

data/raw_sample/diffs/0002740ace8e48ec69914eef4db7463c083ec1a6.diff

@@ -0,0 +1,67 @@
+diff --git a/src/coreclr/src/vm/threadsuspend.cpp b/src/coreclr/src/vm/threadsuspend.cpp
+index d17835863ac589..dbb8cb8ee4ad13 100644
+--- a/src/coreclr/src/vm/threadsuspend.cpp
++++ b/src/coreclr/src/vm/threadsuspend.cpp
+@@ -2187,7 +2187,7 @@ CONTEXT* AllocateOSContextHelper(BYTE** contextBuffer)
+         pfnInitializeContext2 = (PINITIALIZECONTEXT2)GetProcAddress(hm, "InitializeContext2");
+     }
+ 
+-    // Determine if the processor supports AVX so we could 
++    // Determine if the processor supports AVX so we could
+     // retrieve extended registers
+     DWORD64 FeatureMask = GetEnabledXStateFeatures();
+     if ((FeatureMask & XSTATE_MASK_AVX) != 0)
+@@ -2203,7 +2203,14 @@ CONTEXT* AllocateOSContextHelper(BYTE** contextBuffer)
+         pfnInitializeContext2(NULL, context, NULL, &contextSize, xStateCompactionMask) :
+         InitializeContext(NULL, context, NULL, &contextSize);
+ 
+-    _ASSERTE(!success && GetLastError() == ERROR_INSUFFICIENT_BUFFER);
++    // Spec mentions that we may get a different error (it was observed on Windows7).
++    // In such case the contextSize is undefined.
++    if (success || GetLastError() != ERROR_INSUFFICIENT_BUFFER)
++    {
++        STRESS_LOG2(LF_SYNC, LL_INFO1000, "AllocateOSContextHelper: Unexpected result from InitializeContext (success: %d, error: %d).\n",
++            success, GetLastError());
++        return NULL;
++    }
+ 
+     // So now allocate a buffer of that size and call InitializeContext again
+     BYTE* buffer = new (nothrow)BYTE[contextSize];
+@@ -2227,7 +2234,7 @@ CONTEXT* AllocateOSContextHelper(BYTE** contextBuffer)
+ 
+     *contextBuffer = buffer;
+ 
+-#else 
++#else
+     pOSContext = new (nothrow) CONTEXT;
+     pOSContext->ContextFlags = CONTEXT_COMPLETE;
+     *contextBuffer = NULL;
+@@ -3170,9 +3177,15 @@ BOOL Thread::RedirectThreadAtHandledJITCase(PFN_REDIRECTTARGET pTgt)
+     if (!pCtx)
+     {
+         pCtx = m_pSavedRedirectContext = ThreadStore::GrabOSContext(&m_pOSContextBuffer);
+-        _ASSERTE(GetSavedRedirectContext() != NULL);
+     }
+ 
++    // We may not have a preallocated context. Could be short on memory when we tried to preallocate.
++    // We cannot allocate here since we have a thread stopped in a random place, possibly holding locks
++    // that we would need while allocating.
++    // Other ways and attempts at suspending may yet succeed, but this redirection cannot continue.
++    if (!pCtx)
++        return (FALSE);
++
+     //////////////////////////////////////
+     // Get and save the thread's context
+     BOOL bRes = true;
+@@ -3182,9 +3195,9 @@ BOOL Thread::RedirectThreadAtHandledJITCase(PFN_REDIRECTTARGET pTgt)
+ #if defined(TARGET_X86) || defined(TARGET_AMD64)
+     // Scenarios like GC stress may indirectly disable XState features in the pCtx
+     // depending on the state at the time of GC stress interrupt.
+-    // 
++    //
+     // Make sure that AVX feature mask is set, if supported.
+-    // 
++    //
+     // This should not normally fail.
+     // The system silently ignores any feature specified in the FeatureMask
+     // which is not enabled on the processor.

data/raw_sample/diffs/000286f7b0da4fb1d1ca66f6f2fe4543e8c959e3.diff

@@ -0,0 +1,13 @@
+diff --git a/src/coreclr/jit/lsraxarch.cpp b/src/coreclr/jit/lsraxarch.cpp
+index faa0b8e8d4009c..ecdb69ed971901 100644
+--- a/src/coreclr/jit/lsraxarch.cpp
++++ b/src/coreclr/jit/lsraxarch.cpp
+@@ -438,7 +438,7 @@ int LinearScan::BuildNode(GenTree* tree)
+         case GT_XAND:
+             if (!tree->IsUnusedValue())
+             {
+-                // if value is unused, we'll emit a cmpxchg-loop idiom (requires RAX)
++                // if tree's value is used, we'll emit a cmpxchg-loop idiom (requires RAX)
+                 buildInternalIntRegisterDefForNode(tree, availableIntRegs & ~RBM_RAX);
+                 BuildUse(tree->gtGetOp1(), availableIntRegs & ~RBM_RAX);
+                 BuildUse(tree->gtGetOp2(), availableIntRegs & ~RBM_RAX);

data/raw_sample/diffs/0002c625a7bcb71aa7c5eecccd7b6d310155bae9.diff

@@ -0,0 +1,12 @@
+diff --git a/src/coreclr/tools/Common/Internal/Text/Utf8StringBuilder.cs b/src/coreclr/tools/Common/Internal/Text/Utf8StringBuilder.cs
+index 88cb8c80994910..d5dfa7c0ba0ed1 100644
+--- a/src/coreclr/tools/Common/Internal/Text/Utf8StringBuilder.cs
++++ b/src/coreclr/tools/Common/Internal/Text/Utf8StringBuilder.cs
+@@ -16,6 +16,7 @@ public Utf8StringBuilder()
+         {
+         }
+ 
++        public ReadOnlySpan<byte> UnderlyingArray => _buffer;
+         public int Length => _length;
+ 
+         public Utf8StringBuilder Clear()

data/raw_sample/diffs/0003313fc63699ca6458caea66add9d4ccf0336b.diff

@@ -0,0 +1,1112 @@
+diff --git a/eng/pipelines/common/templates/runtimes/run-test-job.yml b/eng/pipelines/common/templates/runtimes/run-test-job.yml
+index 1f41fae7575455..76452e320e54c8 100644
+--- a/eng/pipelines/common/templates/runtimes/run-test-job.yml
++++ b/eng/pipelines/common/templates/runtimes/run-test-job.yml
+@@ -64,9 +64,10 @@ jobs:
+       - ${{ if notIn(parameters.testGroup, 'innerloop', 'clrinterpreter') }}:
+         - '${{ parameters.runtimeFlavor }}_common_test_build_p1_AnyOS_AnyCPU_${{parameters.buildConfig }}'
+       - ${{ if ne(parameters.stagedBuild, true) }}:
+-        - ${{ if or( eq(parameters.runtimeVariant, 'minijit'), eq(parameters.runtimeVariant, 'monointerpreter'))  }}:
++        - ${{ if or( eq(parameters.runtimeVariant, 'minijit'), eq(parameters.runtimeVariant, 'monointerpreter'), eq(parameters.runtimeVariant, 'llvmaot'), eq(parameters.runtimeVariant, 'llvmfullaot'))  }}:
+           # This is needed for creating a CORE_ROOT in the current design.
+           - ${{ format('coreclr_{0}_product_build_{1}{2}_{3}_{4}', '', parameters.osGroup, parameters.osSubgroup, parameters.archType, parameters.buildConfig) }}
++        - ${{ if or( eq(parameters.runtimeVariant, 'minijit'), eq(parameters.runtimeVariant, 'monointerpreter')) }} :
+           # minijit and mono interpreter runtimevariants do not require any special build of the runtime
+           - ${{ format('{0}_{1}_product_build_{2}{3}_{4}_{5}', parameters.runtimeFlavor, '', parameters.osGroup, parameters.osSubgroup, parameters.archType, parameters.buildConfig) }}
+         - ${{ if not(or(eq(parameters.runtimeVariant, 'minijit'), eq(parameters.runtimeVariant, 'monointerpreter')))  }}:
+diff --git a/eng/testing/tests.mobile.targets b/eng/testing/tests.mobile.targets
+index d6a4d13e979e40..53f3274b9e45d0 100644
+--- a/eng/testing/tests.mobile.targets
++++ b/eng/testing/tests.mobile.targets
+@@ -213,6 +213,8 @@
+     </ItemGroup>
+   </Target>
+ 
++  <Import Project="$(MSBuildThisFileDirectory)workloads-testing.targets" />
++
+   <Target Name="PublishTestAsSelfContained"
+           Condition="'$(IsCrossTargetingBuild)' != 'true'"
+           AfterTargets="Build"
+diff --git a/src/libraries/workloads-testing.targets b/eng/testing/workloads-testing.targets
+similarity index 92%
+rename from src/libraries/workloads-testing.targets
+rename to eng/testing/workloads-testing.targets
+index 6a8fa5055bbbb3..712a29a717f5cf 100644
+--- a/src/libraries/workloads-testing.targets
++++ b/eng/testing/workloads-testing.targets
+@@ -1,4 +1,10 @@
+ <Project>
++
++  <PropertyGroup Condition="'$(TestUsingWorkloads)' == 'true'">
++    <!-- for non-ci builds, we install the sdk when tests are run -->
++    <InstallWorkloadForTesting Condition="'$(ContinuousIntegrationBuild)' == 'true' and '$(ArchiveTests)' == 'true'">true</InstallWorkloadForTesting>
++  </PropertyGroup>
++
+   <Target Name="ProvisionSdkForWorkloadTesting"
+           DependsOnTargets="_ProvisionSdkWithNoWorkload"
+           Condition="!Exists($(SdkWithNoWorkloadStampPath)) or !Exists($(SdkWithWorkloadStampPath))">
+@@ -88,8 +94,10 @@
+     </ItemGroup>
+ 
+     <PropertyGroup>
++      <_PackageVersion>$(PackageVersion)</_PackageVersion>
++      <_PackageVersion Condition="'$(StabilizePackageVersion)' == 'true'">$(ProductVersion)</_PackageVersion>
+       <!-- Eg. Microsoft.NETCore.App.Runtime.AOT.osx-x64.Cross.browser-wasm.6.0.0-dev.nupkg -->
+-      <_AOTCrossNuGetPath>$(LibrariesShippingPackagesDir)Microsoft.NETCore.App.Runtime.AOT.$(NETCoreSdkRuntimeIdentifier).Cross.$(RuntimeIdentifier).$(PackageVersion).nupkg</_AOTCrossNuGetPath>
++      <_AOTCrossNuGetPath>$(LibrariesShippingPackagesDir)Microsoft.NETCore.App.Runtime.AOT.$(NETCoreSdkRuntimeIdentifier).Cross.$(RuntimeIdentifier).$(_PackageVersion).nupkg</_AOTCrossNuGetPath>
+     </PropertyGroup>
+ 
+     <Error Text="Could not find cross compiler nupkg at $(_AOTCrossNuGetPath). Found packages: @(_BuiltNuGets)"
+diff --git a/src/libraries/Common/tests/Tests/System/StringTests.cs b/src/libraries/Common/tests/Tests/System/StringTests.cs
+index 08a2f6a3509b5d..c9c617ca640db9 100644
+--- a/src/libraries/Common/tests/Tests/System/StringTests.cs
++++ b/src/libraries/Common/tests/Tests/System/StringTests.cs
+@@ -2918,6 +2918,7 @@ public static void IndexOf_AllSubstrings(string s, string value, int startIndex,
+         }
+ 
+         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))]
++        [ActiveIssue("https://github.com/dotnet/runtime/issues/60568", TestPlatforms.Android)]
+         public static void IndexOf_TurkishI_TurkishCulture()
+         {
+             using (new ThreadCultureChange("tr-TR"))
+@@ -3001,6 +3002,7 @@ public static void IndexOf_TurkishI_EnglishUSCulture()
+         }
+ 
+         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))]
++        [ActiveIssue("https://github.com/dotnet/runtime/issues/60568", TestPlatforms.Android)]
+         public static void IndexOf_HungarianDoubleCompression_HungarianCulture()
+         {
+             using (new ThreadCultureChange("hu-HU"))
+@@ -5123,20 +5125,24 @@ public static void ToLower_String(string s, string expected)
+ 
+         private static IEnumerable<object[]> ToLower_Culture_TestData()
+         {
+-            var tuples = new[]
++            List<Tuple<char, char, CultureInfo>> tuples = new List<Tuple<char, char, CultureInfo>>();
++
++            // Android has different results w/ tr-TR
++            // See https://github.com/dotnet/runtime/issues/60568
++            if (!PlatformDetection.IsAndroid)
+             {
+-                Tuple.Create('\u0049', '\u0131', new CultureInfo("tr-TR")),
+-                Tuple.Create('\u0130', '\u0069', new CultureInfo("tr-TR")),
+-                Tuple.Create('\u0131', '\u0131', new CultureInfo("tr-TR")),
++                tuples.Add(Tuple.Create('\u0049', '\u0131', new CultureInfo("tr-TR")));
++                tuples.Add(Tuple.Create('\u0130', '\u0069', new CultureInfo("tr-TR")));
++                tuples.Add(Tuple.Create('\u0131', '\u0131', new CultureInfo("tr-TR")));
++            }
+ 
+-                Tuple.Create('\u0049', '\u0069', new CultureInfo("en-US")),
+-                Tuple.Create('\u0130', '\u0069', new CultureInfo("en-US")),
+-                Tuple.Create('\u0131', '\u0131', new CultureInfo("en-US")),
++            tuples.Add(Tuple.Create('\u0049', '\u0069', new CultureInfo("en-US")));
++            tuples.Add(Tuple.Create('\u0130', '\u0069', new CultureInfo("en-US")));
++            tuples.Add(Tuple.Create('\u0131', '\u0131', new CultureInfo("en-US")));
+ 
+-                Tuple.Create('\u0049', '\u0069', CultureInfo.InvariantCulture),
+-                Tuple.Create('\u0130', '\u0130', CultureInfo.InvariantCulture),
+-                Tuple.Create('\u0131', '\u0131', CultureInfo.InvariantCulture),
+-            };
++            tuples.Add(Tuple.Create('\u0049', '\u0069', CultureInfo.InvariantCulture));
++            tuples.Add(Tuple.Create('\u0130', '\u0130', CultureInfo.InvariantCulture));
++            tuples.Add(Tuple.Create('\u0131', '\u0131', CultureInfo.InvariantCulture));
+ 
+             foreach (Tuple<char, char, CultureInfo> tuple in tuples)
+             {
+@@ -5610,9 +5616,14 @@ public static void MakeSureNoToUpperChecksGoOutOfRange()
+ 
+         public static IEnumerable<object[]> ToUpper_Culture_TestData()
+         {
+-            yield return new object[] { "h\u0069 world", "H\u0130 WORLD", new CultureInfo("tr-TR") };
+-            yield return new object[] { "h\u0130 world", "H\u0130 WORLD", new CultureInfo("tr-TR") };
+-            yield return new object[] { "h\u0131 world", "H\u0049 WORLD", new CultureInfo("tr-TR") };
++            // Android has different results w/ tr-TR
++            // See https://github.com/dotnet/runtime/issues/60568
++            if (!PlatformDetection.IsAndroid)
++            {
++                yield return new object[] { "h\u0069 world", "H\u0130 WORLD", new CultureInfo("tr-TR") };
++                yield return new object[] { "h\u0130 world", "H\u0130 WORLD", new CultureInfo("tr-TR") };
++                yield return new object[] { "h\u0131 world", "H\u0049 WORLD", new CultureInfo("tr-TR") };
++            }
+ 
+             yield return new object[] { "h\u0069 world", "H\u0049 WORLD", new CultureInfo("en-US") };
+             yield return new object[] { "h\u0130 world", "H\u0130 WORLD", new CultureInfo("en-US") };
+@@ -5683,6 +5694,7 @@ public static IEnumerable<object[]> ToUpper_TurkishI_TurkishCulture_MemberData()
+ 
+         [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))]
+         [MemberData(nameof(ToUpper_TurkishI_TurkishCulture_MemberData))]
++        [ActiveIssue("https://github.com/dotnet/runtime/issues/60568", TestPlatforms.Android)]
+         public static void ToUpper_TurkishI_TurkishCulture(string s, string expected)
+         {
+             using (new ThreadCultureChange("tr-TR"))
+@@ -6774,7 +6786,9 @@ public static IEnumerable<object[]> CompareTest_TestData()
+             yield return new object[] { "",                 null,         "en-us",    true,         1  };
+             yield return new object[] { "",                 null,         null,       true,         1  };
+ 
+-            if (PlatformDetection.IsNotInvariantGlobalization)
++            // Android has different results w/ tr-TR
++            // See https://github.com/dotnet/runtime/issues/60568
++            if (PlatformDetection.IsNotInvariantGlobalization && !PlatformDetection.IsAndroid)
+             {
+                 yield return new object[] { "latin i",         "Latin I",     "tr-TR",    false,        1  };
+                 yield return new object[] { "latin i",         "Latin I",     "tr-TR",    true,         1  };
+@@ -6794,8 +6808,13 @@ public static IEnumerable<object[]> UpperLowerCasing_TestData()
+ 
+             if (PlatformDetection.IsNotInvariantGlobalization)
+             {
+-                yield return new object[] { "turky \u0131",     "TURKY I",      "tr-TR" };
+-                yield return new object[] { "turky i",          "TURKY \u0130", "tr-TR" };
++                // Android has different results w/ tr-TR
++                // See https://github.com/dotnet/runtime/issues/60568
++                if (!PlatformDetection.IsAndroid)
++                {
++                    yield return new object[] { "turky \u0131",     "TURKY I",      "tr-TR" };
++                    yield return new object[] { "turky i",          "TURKY \u0130", "tr-TR" };
++                }
+                 yield return new object[] { "\ud801\udc29",     PlatformDetection.IsWindows7 ? "\ud801\udc29" : "\ud801\udc01", "en-US" };
+             }
+         }
+@@ -6810,7 +6829,9 @@ public static IEnumerable<object[]> StartEndWith_TestData()
+             yield return new object[] { "ABcd",                  "ab",      "CD",   "en-US",    false,       false  };
+             yield return new object[] { "abcd",                  "AB",      "CD",   "en-US",    true,        true   };
+ 
+-            if (PlatformDetection.IsNotInvariantGlobalization)
++            // Android has different results w/ tr-TR
++            // See https://github.com/dotnet/runtime/issues/60568
++            if (PlatformDetection.IsNotInvariantGlobalization && !PlatformDetection.IsAndroid)
+             {
+                 yield return new object[] { "i latin i",             "I Latin", "I",    "tr-TR",    false,       false  };
+                 yield return new object[] { "i latin i",             "I Latin", "I",    "tr-TR",    true,        false  };
+diff --git a/src/libraries/Directory.Build.targets b/src/libraries/Directory.Build.targets
+index 29bd80118ee7d7..362a93ebef916d 100644
+--- a/src/libraries/Directory.Build.targets
++++ b/src/libraries/Directory.Build.targets
+@@ -7,11 +7,6 @@
+     <StrongNameKeyId Condition="'$(IsTestProject)' == 'true' or '$(IsTestSupportProject)' == 'true'">$(TestStrongNameKeyId)</StrongNameKeyId>
+   </PropertyGroup>
+ 
+-  <PropertyGroup Condition="'$(TestUsingWorkloads)' == 'true'">
+-    <!-- for non-ci builds, we install the sdk when tests are run -->
+-    <InstallWorkloadForTesting Condition="'$(ContinuousIntegrationBuild)' == 'true' and '$(ArchiveTests)' == 'true'">true</InstallWorkloadForTesting>
+-  </PropertyGroup>
+-
+   <!-- resources.targets need to be imported before the Arcade SDK. -->
+   <Import Project="$(RepositoryEngineeringDir)resources.targets" />
+   <Import Project="..\..\Directory.Build.targets" />
+@@ -272,6 +267,4 @@
+     <Error Condition="'%(_AnalyzerPackFile.TargetFramework)' != 'netstandard2.0'"
+            Text="Analyzers must only target netstandard2.0 since they run in the compiler which targets netstandard2.0. The following files were found to target '%(_AnalyzerPackFile.TargetFramework)': @(_AnalyzerPackFile)" />
+   </Target>
+-
+-  <Import Project="$(MSBuildThisFileDirectory)workloads-testing.targets" />
+ </Project>
+diff --git a/src/libraries/System.Diagnostics.TextWriterTraceListener/tests/XmlWriterTraceListenerTests.cs b/src/libraries/System.Diagnostics.TextWriterTraceListener/tests/XmlWriterTraceListenerTests.cs
+index 418e7b04d952f0..d71818e9fd097a 100644
+--- a/src/libraries/System.Diagnostics.TextWriterTraceListener/tests/XmlWriterTraceListenerTests.cs
++++ b/src/libraries/System.Diagnostics.TextWriterTraceListener/tests/XmlWriterTraceListenerTests.cs
+@@ -160,7 +160,6 @@ public void ListenerWithFilter()
+         [InlineData("<Escaped Message>", "&lt;Escaped Message&gt;")]
+         [InlineData("&\"\'", "&amp;\"\'")]
+         [InlineData("Hello\n\r", "Hello\n\r")]
+-        [ActiveIssue("https://github.com/dotnet/runtime/issues/50925", TestPlatforms.Android)]
+         public void WriteTest(string message, string expectedXml)
+         {
+             string file = GetTestFilePath();
+@@ -187,7 +186,6 @@ public void WriteTest(string message, string expectedXml)
+         [Theory]
+         [InlineData("Fail:", null)]
+         [InlineData("Fail:", "the process failed when running")]
+-        [ActiveIssue("https://github.com/dotnet/runtime/issues/50925", TestPlatforms.Android)]
+         public void FailTest(string message, string detailMessage)
+         {
+             string file = GetTestFilePath();
+diff --git a/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/PipeReader.cs b/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/PipeReader.cs
+index 52a5a3caff92bb..5c1beb95c6b9a6 100644
+--- a/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/PipeReader.cs
++++ b/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/PipeReader.cs
+@@ -15,7 +15,15 @@ public abstract partial class PipeReader
+         /// <summary>Attempts to synchronously read data from the <see cref="System.IO.Pipelines.PipeReader" />.</summary>
+         /// <param name="result">When this method returns <see langword="true" />, this value is set to a <see cref="System.IO.Pipelines.ReadResult" /> instance that represents the result of the read call; otherwise, this value is set to <see langword="default" />.</param>
+         /// <returns><see langword="true" /> if data was available, or if the call was canceled or the writer was completed; otherwise, <see langword="false" />.</returns>
+-        /// <remarks>If the pipe returns <see langword="false" />, there is no need to call <see cref="System.IO.Pipelines.PipeReader.AdvanceTo(System.SequencePosition,System.SequencePosition)" />.</remarks>
++        /// <remarks><format type="text/markdown"><![CDATA[
++        /// If the pipe returns <see langword="false" />, there is no need to call <see cref="System.IO.Pipelines.PipeReader.AdvanceTo(System.SequencePosition,System.SequencePosition)" />.
++        /// [!IMPORTANT]
++        /// The `System.IO.Pipelines.PipeReader` implementation returned by `System.IO.Pipelines.PipeReader.Create(System.IO.Stream, System.IO.Pipelines.StreamPipeReaderOptions?)`
++        /// will not read new data from the backing `System.IO.Stream` when `System.IO.Pipelines.PipeReader.TryRead(out System.IO.Pipelines.ReadResult)` is called.
++        ///
++        /// `System.IO.Pipelines.PipeReader.ReadAsync(System.Threading.CancellationToken)` must be called to read new data from the backing `System.IO.Stream`.
++        /// Any unconsumed data from a previous asynchronous read will be available to `System.IO.Pipelines.PipeReader.TryRead(out System.IO.Pipelines.ReadResult)`.
++        /// ]]></format></remarks>
+         public abstract bool TryRead(out ReadResult result);
+ 
+         /// <summary>Asynchronously reads a sequence of bytes from the current <see cref="System.IO.Pipelines.PipeReader" />.</summary>
+diff --git a/src/libraries/System.Private.CoreLib/src/System/Resources/ResourceReader.cs b/src/libraries/System.Private.CoreLib/src/System/Resources/ResourceReader.cs
+index 16e2b161fc0dbf..9aa2c73bb74719 100644
+--- a/src/libraries/System.Private.CoreLib/src/System/Resources/ResourceReader.cs
++++ b/src/libraries/System.Private.CoreLib/src/System/Resources/ResourceReader.cs
+@@ -575,7 +575,11 @@ private unsafe string AllocateStringForNameIndex(int index, out int dataOffset)
+                 return new TimeSpan(_store.ReadInt64());
+             else if (type == typeof(decimal))
+             {
++#if RESOURCES_EXTENSIONS
+                 int[] bits = new int[4];
++#else
++                Span<int> bits = stackalloc int[4];
++#endif
+                 for (int i = 0; i < bits.Length; i++)
+                     bits[i] = _store.ReadInt32();
+                 return new decimal(bits);
+diff --git a/src/libraries/System.Runtime.InteropServices/tests/DllImportGenerator.Tests/BooleanTests.cs b/src/libraries/System.Runtime.InteropServices/tests/DllImportGenerator.Tests/BooleanTests.cs
+index 063174d3e35771..2d703c3abdb2ff 100644
+--- a/src/libraries/System.Runtime.InteropServices/tests/DllImportGenerator.Tests/BooleanTests.cs
++++ b/src/libraries/System.Runtime.InteropServices/tests/DllImportGenerator.Tests/BooleanTests.cs
+@@ -90,6 +90,7 @@ public class BooleanTests
+         const ushort VARIANT_FALSE = 0;
+ 
+         [Fact]
++        [ActiveIssue("https://github.com/dotnet/runtime/issues/60649", TestRuntimes.Mono)]
+         public void ValidateBoolIsMarshalledAsExpected()
+         {
+             Assert.Equal((uint)1, NativeExportsNE.ReturnByteBoolAsUInt(true));
+diff --git a/src/libraries/System.Runtime/tests/System/DateTimeOffsetTests.cs b/src/libraries/System.Runtime/tests/System/DateTimeOffsetTests.cs
+index 67c3f9a678b298..043fa669ccdb7b 100644
+--- a/src/libraries/System.Runtime/tests/System/DateTimeOffsetTests.cs
++++ b/src/libraries/System.Runtime/tests/System/DateTimeOffsetTests.cs
+@@ -1255,6 +1255,7 @@ public static IEnumerable<object[]> ToString_MatchesExpected_MemberData()
+ 
+         [Theory]
+         [MemberData(nameof(ToString_MatchesExpected_MemberData))]
++        [ActiveIssue("https://github.com/dotnet/runtime/issues/60562", TestPlatforms.Android)]
+         public static void ToString_MatchesExpected(DateTimeOffset dateTimeOffset, string format, IFormatProvider provider, string expected)
+         {
+             if (provider == null)
+@@ -1354,6 +1355,7 @@ public static void TryFormat_ToString_EqualResults()
+ 
+         [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))]
+         [MemberData(nameof(ToString_MatchesExpected_MemberData))]
++        [ActiveIssue("https://github.com/dotnet/runtime/issues/60562", TestPlatforms.Android)]
+         public static void TryFormat_MatchesExpected(DateTimeOffset dateTimeOffset, string format, IFormatProvider provider, string expected)
+         {
+             var destination = new char[expected.Length];
+diff --git a/src/libraries/System.Runtime/tests/System/DateTimeTests.cs b/src/libraries/System.Runtime/tests/System/DateTimeTests.cs
+index d2b40c647dfd3c..1a9a487ecd4849 100644
+--- a/src/libraries/System.Runtime/tests/System/DateTimeTests.cs
++++ b/src/libraries/System.Runtime/tests/System/DateTimeTests.cs
+@@ -2110,6 +2110,7 @@ public static void ParseExact_Span_InvalidInputs_Fail(string input, string forma
+ 
+         [Theory]
+         [MemberData(nameof(ToString_MatchesExpected_MemberData))]
++        [ActiveIssue("https://github.com/dotnet/runtime/issues/60562", TestPlatforms.Android)]
+         public void ToString_Invoke_ReturnsExpected(DateTime dateTime, string format, IFormatProvider provider, string expected)
+         {
+             if (provider == null)
+@@ -2355,6 +2356,7 @@ public static void TryFormat_MatchesToString(string format)
+ 
+         [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))]
+         [MemberData(nameof(ToString_MatchesExpected_MemberData))]
++        [ActiveIssue("https://github.com/dotnet/runtime/issues/60562", TestPlatforms.Android)]
+         public static void TryFormat_MatchesExpected(DateTime dateTime, string format, IFormatProvider provider, string expected)
+         {
+             var destination = new char[expected.Length];
+diff --git a/src/libraries/System.Runtime/tests/System/Reflection/ModuleTests.cs b/src/libraries/System.Runtime/tests/System/Reflection/ModuleTests.cs
+index 7ebf93afcc3fe6..9d44bbce1d0122 100644
+--- a/src/libraries/System.Runtime/tests/System/Reflection/ModuleTests.cs
++++ b/src/libraries/System.Runtime/tests/System/Reflection/ModuleTests.cs
+@@ -163,6 +163,7 @@ public void GetField_NullName()
+         }
+ 
+         [Fact]
++        [ActiveIssue("https://github.com/dotnet/runtime/issues/60558", TestPlatforms.Android)]
+         public void GetField()
+         {
+             FieldInfo testInt = TestModule.GetField("TestInt", BindingFlags.Public | BindingFlags.Static);
+diff --git a/src/libraries/System.Runtime/tests/System/StringTests.cs b/src/libraries/System.Runtime/tests/System/StringTests.cs
+index b0786bb2370fb5..993f5c9eba34aa 100644
+--- a/src/libraries/System.Runtime/tests/System/StringTests.cs
++++ b/src/libraries/System.Runtime/tests/System/StringTests.cs
+@@ -315,6 +315,7 @@ public static void Contains_String_StringComparison(string s, string value, Stri
+         }
+ 
+         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))]
++        [ActiveIssue("https://github.com/dotnet/runtime/issues/60568", TestPlatforms.Android)]
+         public static void Contains_StringComparison_TurkishI()
+         {
+             const string Source = "\u0069\u0130";
+@@ -782,6 +783,7 @@ public void Replace_StringComparison_ReturnsExpected(string original, string old
+         }
+ 
+         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))]
++        [ActiveIssue("https://github.com/dotnet/runtime/issues/60568", TestPlatforms.Android)]
+         public void Replace_StringComparison_TurkishI()
+         {
+             const string Source = "\u0069\u0130";
+@@ -826,8 +828,14 @@ public static IEnumerable<object[]> Replace_StringComparisonCulture_TestData()
+                 yield return new object[] { "abc", "abc" + SoftHyphen, "def", false, CultureInfo.InvariantCulture, "def" };
+                 yield return new object[] { "abc", "abc" + SoftHyphen, "def", true, CultureInfo.InvariantCulture, "def" };
+ 
+-                yield return new object[] { "\u0069\u0130", "\u0069", "a", false, new CultureInfo("tr-TR"), "a\u0130" };
+-                yield return new object[] { "\u0069\u0130", "\u0069", "a", true, new CultureInfo("tr-TR"), "aa" };
++                // Android has different results w/ tr-TR
++                // See https://github.com/dotnet/runtime/issues/60568
++                if (!PlatformDetection.IsAndroid)
++                {
++                    yield return new object[] { "\u0069\u0130", "\u0069", "a", false, new CultureInfo("tr-TR"), "a\u0130" };
++                    yield return new object[] { "\u0069\u0130", "\u0069", "a", true, new CultureInfo("tr-TR"), "aa" };
++                }
++
+                 yield return new object[] { "\u0069\u0130", "\u0069", "a", false, CultureInfo.InvariantCulture, "a\u0130" };
+                 yield return new object[] { "\u0069\u0130", "\u0069", "a", true, CultureInfo.InvariantCulture, "a\u0130" };
+             }
+@@ -1104,6 +1112,7 @@ public static void IndexOf_SingleLetter_StringComparison(string s, char target,
+         }
+ 
+         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))]
++        [ActiveIssue("https://github.com/dotnet/runtime/issues/60568", TestPlatforms.Android)]
+         public static void IndexOf_TurkishI_TurkishCulture_Char()
+         {
+             using (new ThreadCultureChange("tr-TR"))
+diff --git a/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs b/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs
+index a75d4003b3ed7c..9e8e39f7d35efc 100644
+--- a/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs
++++ b/src/libraries/System.Runtime/tests/System/TimeZoneInfoTests.cs
+@@ -2349,6 +2349,14 @@ public static IEnumerable<object[]> SystemTimeZonesTestData()
+             "Zulu"
+         };
+ 
++        // On Android GMT, GMT+0, and GMT-0 are values
++        private static readonly string[] s_GMTAliases = new [] {
++            "GMT",
++            "GMT0",
++            "GMT+0",
++            "GMT-0"
++        };
++
+         [Theory]
+         [MemberData(nameof(SystemTimeZonesTestData))]
+         [PlatformSpecific(TestPlatforms.AnyUnix)]
+@@ -2401,7 +2409,12 @@ public static void TimeZoneDisplayNames_Unix(TimeZoneInfo timeZone)
+                 // All we can really say generically here is that they aren't empty.
+                 Assert.False(string.IsNullOrWhiteSpace(timeZone.DisplayName), $"Id: \"{timeZone.Id}\", DisplayName should not have been empty.");
+                 Assert.False(string.IsNullOrWhiteSpace(timeZone.StandardName), $"Id: \"{timeZone.Id}\", StandardName should not have been empty.");
+-                Assert.False(string.IsNullOrWhiteSpace(timeZone.DaylightName), $"Id: \"{timeZone.Id}\", DaylightName should not have been empty.");
++
++                // GMT* on Android does sets daylight savings time to false, so there will be no DaylightName
++                if (!PlatformDetection.IsAndroid || (PlatformDetection.IsAndroid && !timeZone.Id.StartsWith("GMT")))
++                {
++                    Assert.False(string.IsNullOrWhiteSpace(timeZone.DaylightName), $"Id: \"{timeZone.Id}\", DaylightName should not have been empty.");
++                }
+             }
+         }
+ 
+@@ -2586,6 +2599,10 @@ public static void TimeZoneInfo_DisplayNameStartsWithOffset(TimeZoneInfo tzi)
+                 // UTC and all of its aliases (Etc/UTC, and others) start with just "(UTC) "
+                 Assert.StartsWith("(UTC) ", tzi.DisplayName);
+             }
++            else if (s_GMTAliases.Contains(tzi.Id, StringComparer.OrdinalIgnoreCase))
++            {
++                Assert.StartsWith("GMT", tzi.DisplayName);
++            }
+             else
+             {
+                 Assert.False(string.IsNullOrWhiteSpace(tzi.StandardName));
+@@ -2701,6 +2718,7 @@ public static void IsIanaIdTest()
+         }
+ 
+         [ConditionalFact(nameof(DoesNotSupportIanaNamesConversion))]
++        [PlatformSpecific(~TestPlatforms.Android)]
+         public static void UnsupportedImplicitConversionTest()
+         {
+             string nonNativeTzName = s_isWindows ? "America/Los_Angeles" : "Pacific Standard Time";
+diff --git a/src/libraries/System.Text.RegularExpressions/tests/RegexCultureTests.cs b/src/libraries/System.Text.RegularExpressions/tests/RegexCultureTests.cs
+index 86dc23b0fe35c8..ac0bc82bff7a79 100644
+--- a/src/libraries/System.Text.RegularExpressions/tests/RegexCultureTests.cs
++++ b/src/libraries/System.Text.RegularExpressions/tests/RegexCultureTests.cs
+@@ -190,6 +190,7 @@ Regex[] Create(string input, CultureInfo info, RegexOptions additional)
+ 
+         [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework, "Doesn't support NonBacktracking")]
+         [Fact]
++        [ActiveIssue("https://github.com/dotnet/runtime/issues/60568", TestPlatforms.Android)]
+         public void TurkishI_Is_Differently_LowerUpperCased_In_Turkish_Culture_NonBacktracking()
+         {
+             var turkish = new CultureInfo("tr-TR");
+@@ -275,11 +276,17 @@ public static IEnumerable<object[]> Match_In_Different_Cultures_TestData()
+                 yield return new object[] { "(?i:iI+)", options, invariant, "abc\u0130\u0131Ixyz", "" };
+ 
+                 // Expected answers in the Turkish culture
+-                yield return new object[] { "(?i:I)", options, turkish, "xy\u0131ab", "\u0131" };
+-                yield return new object[] { "(?i:iI+)", options, turkish, "abcIIIxyz", "" };
+-                yield return new object[] { "(?i:iI+)", options, turkish, "abcIi\u0130xyz", "" };
+-                yield return new object[] { "(?i:iI+)", options, turkish, "abcI\u0130ixyz", "" };
+-                yield return new object[] { "(?i:[^IJKLM]I)", options, turkish, "ii\u0130i\u0131ab", "i\u0131" };
++                //
++                // Android produces unexpected results for tr-TR
++                // https://github.com/dotnet/runtime/issues/60568
++                if (!PlatformDetection.IsAndroid)
++                {
++                    yield return new object[] { "(?i:I)", options, turkish, "xy\u0131ab", "\u0131" };
++                    yield return new object[] { "(?i:iI+)", options, turkish, "abcIIIxyz", "" };
++                    yield return new object[] { "(?i:iI+)", options, turkish, "abcIi\u0130xyz", "" };
++                    yield return new object[] { "(?i:iI+)", options, turkish, "abcI\u0130ixyz", "" };
++                    yield return new object[] { "(?i:[^IJKLM]I)", options, turkish, "ii\u0130i\u0131ab", "i\u0131" };
++                }
+ 
+                 // None and Compiled are separated into the Match_In_Different_Cultures_CriticalCases test
+                 if (options == RegexHelpers.RegexOptionNonBacktracking)
+@@ -305,9 +312,14 @@ public static IEnumerable<object[]> Match_In_Different_Cultures_CriticalCases_Te
+             yield return new object[] { "(?i:[^IJKLM]I)", options, invariant, "ii\u0130i\u0131ab", "\u0130i" }; // <-- failing for None, Compiled
+ 
+             // Expected answers in the Turkish culture
+-            yield return new object[] { "(?i:iI+)", options, turkish, "abc\u0130IIxyz", "\u0130II" };           // <-- failing for None, Compiled
+-            yield return new object[] { "(?i:iI+)", options, turkish, "abc\u0130\u0131Ixyz", "\u0130\u0131I" }; // <-- failing for None, Compiled
+-            yield return new object[] { "(?i:iI+)", options, turkish, "abc\u0130Iixyz", "\u0130I" };            // <-- failing for None, Compiled
++            // Android produces unexpected results for tr-TR
++            // https://github.com/dotnet/runtime/issues/60568
++            if (!PlatformDetection.IsAndroid)
++            {
++                yield return new object[] { "(?i:iI+)", options, turkish, "abc\u0130IIxyz", "\u0130II" };           // <-- failing for None, Compiled
++                yield return new object[] { "(?i:iI+)", options, turkish, "abc\u0130\u0131Ixyz", "\u0130\u0131I" }; // <-- failing for None, Compiled
++                yield return new object[] { "(?i:iI+)", options, turkish, "abc\u0130Iixyz", "\u0130I" };            // <-- failing for None, Compiled
++            }
+         }
+ 
+         public static IEnumerable<object[]> Match_In_Different_Cultures_CriticalCases_TestData() =>
+diff --git a/src/libraries/tests.proj b/src/libraries/tests.proj
+index 5e8478e3258817..8306ba65778b10 100644
+--- a/src/libraries/tests.proj
++++ b/src/libraries/tests.proj
+@@ -75,9 +75,6 @@
+     <ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Threading.Thread\tests\System.Threading.Thread.Tests.csproj" />
+ 
+     <!-- Actual test failures -->
+-    <!-- https://github.com/dotnet/runtime/issues/37088 -->
+-    <!--<ProjectExclusions Include="$(MSBuildThisFileDirectory)System.Runtime\tests\System.Runtime.Tests.csproj" />-->
+-
+     <!-- https://github.com/dotnet/runtime/issues/50871 -->
+     <ProjectExclusions Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.DependencyInjection\tests\DI.Tests\Microsoft.Extensions.DependencyInjection.Tests.csproj" />
+ 
+diff --git a/src/mono/wasm/build/WasmApp.Native.targets b/src/mono/wasm/build/WasmApp.Native.targets
+index e42c22e4464c17..69facc5d7204a3 100644
+--- a/src/mono/wasm/build/WasmApp.Native.targets
++++ b/src/mono/wasm/build/WasmApp.Native.targets
+@@ -161,6 +161,7 @@
+       <_EmccOptimizationFlagDefault Condition="'$(_EmccOptimizationFlagDefault)' == ''">-Oz</_EmccOptimizationFlagDefault>
+ 
+       <EmccCompileOptimizationFlag Condition="'$(EmccCompileOptimizationFlag)' == ''">$(_EmccOptimizationFlagDefault)</EmccCompileOptimizationFlag>
++      <EmccLinkOptimizationFlag    Condition="'$(EmccLinkOptimizationFlag)' == '' and '$(Configuration)' == 'Release'">-O2</EmccLinkOptimizationFlag>
+       <EmccLinkOptimizationFlag    Condition="'$(EmccLinkOptimizationFlag)' == ''"   >$(EmccCompileOptimizationFlag)</EmccLinkOptimizationFlag>
+ 
+       <_EmccCompileRsp>$(_WasmIntermediateOutputPath)emcc-compile.rsp</_EmccCompileRsp>
+diff --git a/src/mono/wasm/runtime/CMakeLists.txt b/src/mono/wasm/runtime/CMakeLists.txt
+index d2c59089a49c22..450d8df3918b8b 100644
+--- a/src/mono/wasm/runtime/CMakeLists.txt
++++ b/src/mono/wasm/runtime/CMakeLists.txt
+@@ -25,7 +25,7 @@ target_link_libraries(dotnet
+ 
+ set_target_properties(dotnet PROPERTIES
+     LINK_DEPENDS "${NATIVE_BIN_DIR}/src/emcc-default.rsp;${NATIVE_BIN_DIR}/src/runtime.iffe.js;${SOURCE_DIR}/library-dotnet.js;${SYSTEM_NATIVE_DIR}/pal_random.js"
+-    LINK_FLAGS "@${NATIVE_BIN_DIR}/src/emcc-default.rsp ${CONFIGURATION_EMCC_FLAGS} -DENABLE_NETCORE=1 --pre-js ${NATIVE_BIN_DIR}/src/runtime.iffe.js --js-library ${SOURCE_DIR}/library-dotnet.js --js-library ${SYSTEM_NATIVE_DIR}/pal_random.js"
++    LINK_FLAGS "@${NATIVE_BIN_DIR}/src/emcc-default.rsp ${CONFIGURATION_LINK_FLAGS} -DENABLE_NETCORE=1 --pre-js ${NATIVE_BIN_DIR}/src/runtime.iffe.js --js-library ${SOURCE_DIR}/library-dotnet.js --js-library ${SYSTEM_NATIVE_DIR}/pal_random.js"
+     RUNTIME_OUTPUT_DIRECTORY "${NATIVE_BIN_DIR}")
+ 
+ if(CMAKE_BUILD_TYPE STREQUAL "Release")
+diff --git a/src/mono/wasm/wasm.proj b/src/mono/wasm/wasm.proj
+index 53b1fe1fd7c756..1f85febd2f9dd6 100644
+--- a/src/mono/wasm/wasm.proj
++++ b/src/mono/wasm/wasm.proj
+@@ -149,8 +149,10 @@
+       <PInvokeTableFile>$(ArtifactsObjDir)wasm/pinvoke-table.h</PInvokeTableFile>
+       <CMakeConfigurationEmccFlags Condition="'$(Configuration)' == 'Debug'">-g -Os -s -DDEBUG=1</CMakeConfigurationEmccFlags>
+       <CMakeConfigurationEmccFlags Condition="'$(Configuration)' == 'Release'">-Oz</CMakeConfigurationEmccFlags>
++      <CMakeConfigurationLinkFlags Condition="'$(Configuration)' == 'Debug'">$(CMakeConfigurationEmccFlags)</CMakeConfigurationLinkFlags>
++      <CMakeConfigurationLinkFlags Condition="'$(Configuration)' == 'Release'">-O2</CMakeConfigurationLinkFlags>
+       <CMakeConfigurationEmsdkPath Condition="'$(Configuration)' == 'Release'"> -DEMSDK_PATH=&quot;$(EMSDK_PATH.TrimEnd('\/'))&quot;</CMakeConfigurationEmsdkPath>
+-      <CMakeBuildRuntimeConfigureCmd>emcmake cmake $(MSBuildThisFileDirectory)runtime -DCMAKE_BUILD_TYPE=$(Configuration) -DCONFIGURATION_EMCC_FLAGS=&quot;$(CMakeConfigurationEmccFlags)&quot; -DMONO_INCLUDES=&quot;$(MonoArtifactsPath)include/mono-2.0&quot; -DMONO_OBJ_INCLUDES=&quot;$(MonoObjDir.TrimEnd('\/'))&quot; -DICU_LIB_DIR=&quot;$(ICULibDir.TrimEnd('\/'))&quot; -DMONO_ARTIFACTS_DIR=&quot;$(MonoArtifactsPath.TrimEnd('\/'))&quot; -DNATIVE_BIN_DIR=&quot;$(NativeBinDir.TrimEnd('\/'))&quot; -DSYSTEM_NATIVE_DIR=&quot;$(RepoRoot)src/libraries/Native/Unix/System.Native&quot; -DSOURCE_DIR=&quot;$(MSBuildThisFileDirectory.TrimEnd('\/'))/runtime&quot;$(CMakeConfigurationEmsdkPath)</CMakeBuildRuntimeConfigureCmd>
++      <CMakeBuildRuntimeConfigureCmd>emcmake cmake $(MSBuildThisFileDirectory)runtime -DCMAKE_BUILD_TYPE=$(Configuration) -DCONFIGURATION_EMCC_FLAGS=&quot;$(CMakeConfigurationEmccFlags)&quot; -DCONFIGURATION_LINK_FLAGS=&quot;$(CMakeConfigurationLinkFlags)&quot; -DMONO_INCLUDES=&quot;$(MonoArtifactsPath)include/mono-2.0&quot; -DMONO_OBJ_INCLUDES=&quot;$(MonoObjDir.TrimEnd('\/'))&quot; -DICU_LIB_DIR=&quot;$(ICULibDir.TrimEnd('\/'))&quot; -DMONO_ARTIFACTS_DIR=&quot;$(MonoArtifactsPath.TrimEnd('\/'))&quot; -DNATIVE_BIN_DIR=&quot;$(NativeBinDir.TrimEnd('\/'))&quot; -DSYSTEM_NATIVE_DIR=&quot;$(RepoRoot)src/libraries/Native/Unix/System.Native&quot; -DSOURCE_DIR=&quot;$(MSBuildThisFileDirectory.TrimEnd('\/'))/runtime&quot;$(CMakeConfigurationEmsdkPath)</CMakeBuildRuntimeConfigureCmd>
+       <CMakeBuildRuntimeConfigureCmd Condition="'$(OS)' == 'Windows_NT'">call &quot;$(RepositoryEngineeringDir)native\init-vs-env.cmd&quot; &amp;&amp; call &quot;$([MSBuild]::NormalizePath('$(EMSDK_PATH)', 'emsdk_env.bat'))&quot; &amp;&amp; $(CMakeBuildRuntimeConfigureCmd)</CMakeBuildRuntimeConfigureCmd>
+       <CMakeBuildRuntimeConfigureCmd Condition="'$(OS)' != 'Windows_NT'">bash -c 'source $(EMSDK_PATH)/emsdk_env.sh 2>&amp;1 &amp;&amp; $(CMakeBuildRuntimeConfigureCmd)'</CMakeBuildRuntimeConfigureCmd>
+ 
+diff --git a/src/tests/Common/Coreclr.TestWrapper/MobileAppHandler.cs b/src/tests/Common/Coreclr.TestWrapper/MobileAppHandler.cs
+index 324edcce76fa13..834bf24e451708 100644
+--- a/src/tests/Common/Coreclr.TestWrapper/MobileAppHandler.cs
++++ b/src/tests/Common/Coreclr.TestWrapper/MobileAppHandler.cs
+@@ -22,6 +22,12 @@ private static int HandleMobileApp(string action, string platform, string catego
+         {
+             //install or uninstall mobile app
+             int exitCode = -100;
++
++            if (action == "install" && (File.Exists($"{testBinaryBase}/.retry") || File.Exists($"{testBinaryBase}/.reboot")))
++            {
++                return exitCode;
++            }
++
+             string outputFile = Path.Combine(reportBase, action, $"{category}_{action}.output.txt");
+             string errorFile = Path.Combine(reportBase, action, $"{category}_{action}.error.txt");
+             bool platformValueFlag = true;
+@@ -81,6 +87,11 @@ private static int HandleMobileApp(string action, string platform, string catego
+                         }
+                     }
+ 
++                    if (action == "install")
++                    {
++                        cmdStr += " --timeout 00:05:00";
++                    }
++
+                     using (Process process = new Process())
+                     {
+                         if (OperatingSystem.IsWindows())
+@@ -108,6 +119,19 @@ private static int HandleMobileApp(string action, string platform, string catego
+                         {
+                             // Process completed.
+                             exitCode = process.ExitCode;
++
++                            // See https://github.com/dotnet/xharness/blob/main/src/Microsoft.DotNet.XHarness.Common/CLI/ExitCode.cs
++                            // 78 - PACKAGE_INSTALLATION_FAILURE
++                            // 81 - DEVICE_NOT_FOUND
++                            // 85 - ADB_DEVICE_ENUMERATION_FAILURE
++                            // 86 - PACKAGE_INSTALLATION_TIMEOUT
++                            if (action == "install" && (exitCode == 78 || exitCode == 81|| exitCode == 85|| exitCode == 86))
++                            {
++                                CreateRetryFile($"{testBinaryBase}/.retry", exitCode, category);
++                                CreateRetryFile($"{testBinaryBase}/.reboot", exitCode, category);
++                                return exitCode;
++                            }
++
+                             Task.WaitAll(copyOutput, copyError);
+                         }
+                         else
+@@ -155,5 +179,13 @@ private static string ConvertCmd2Arg(string cmd)
+ 
+             return $"{cmdPrefix} \"{cmd}\"";
+         }
++
++        private static void CreateRetryFile(string fileName, int exitCode, string appName)
++        {
++            using (StreamWriter writer = new StreamWriter(fileName))  
++            {
++                writer.WriteLine($"appName: {appName}; exitCode: {exitCode}"); 
++            }
++        }
+     }
+ }
+diff --git a/src/tests/Interop/CMakeLists.txt b/src/tests/Interop/CMakeLists.txt
+index 30a1e9ea0a879a..1914910027eb47 100644
+--- a/src/tests/Interop/CMakeLists.txt
++++ b/src/tests/Interop/CMakeLists.txt
+@@ -14,8 +14,6 @@ SET(CLR_INTEROP_TEST_ROOT ${CMAKE_CURRENT_SOURCE_DIR})
+ include_directories(common)
+ add_subdirectory(PInvoke/Decimal)
+ add_subdirectory(PInvoke/ArrayWithOffset)
+-add_subdirectory(PInvoke/BestFitMapping/Char)
+-add_subdirectory(PInvoke/BestFitMapping/LPStr)
+ add_subdirectory(PInvoke/Delegate)
+ add_subdirectory(PInvoke/Primitives/Int)
+ add_subdirectory(PInvoke/Primitives/RuntimeHandles)
+@@ -55,16 +53,18 @@ add_subdirectory(StringMarshalling/BSTR)
+ add_subdirectory(StringMarshalling/AnsiBSTR)
+ add_subdirectory(StringMarshalling/VBByRefStr)
+ add_subdirectory(MarshalAPI/FunctionPointer)
+-add_subdirectory(MarshalAPI/IUnknown)
+ add_subdirectory(NativeLibrary/NativeLibraryToLoad)
+ add_subdirectory(DllImportAttribute/DllImportPath)
+ add_subdirectory(DllImportAttribute/ExactSpelling)
+-add_subdirectory(ExecInDefAppDom)
+ add_subdirectory(ICustomMarshaler/ConflictingNames)
+ add_subdirectory(LayoutClass)
+ add_subdirectory(PInvoke/DateTime)
+ if(CLR_CMAKE_TARGET_WIN32)
++    add_subdirectory(ExecInDefAppDom)
++    add_subdirectory(MarshalAPI/IUnknown)
+     add_subdirectory(PInvoke/Attributes/LCID)
++    add_subdirectory(PInvoke/BestFitMapping/Char)
++    add_subdirectory(PInvoke/BestFitMapping/LPStr)
+     add_subdirectory(PInvoke/Variant)
+     add_subdirectory(PInvoke/Varargs)
+     add_subdirectory(PInvoke/NativeCallManagedComVisible)
+diff --git a/src/tests/Interop/ExecInDefAppDom/ExecInDefAppDom.csproj b/src/tests/Interop/ExecInDefAppDom/ExecInDefAppDom.csproj
+index 0a0137d6f3fd52..1e10117bc3dbf6 100644
+--- a/src/tests/Interop/ExecInDefAppDom/ExecInDefAppDom.csproj
++++ b/src/tests/Interop/ExecInDefAppDom/ExecInDefAppDom.csproj
+@@ -1,6 +1,7 @@
+ <Project Sdk="Microsoft.NET.Sdk">
+   <PropertyGroup>
+     <OutputType>Exe</OutputType>
++    <CLRTestTargetUnsupported Condition="'$(TargetsWindows)' != 'true'">true</CLRTestTargetUnsupported>
+   </PropertyGroup>
+   <ItemGroup>
+     <Compile Include="$(MSBuildProjectName).cs" />
+diff --git a/src/tests/issues.targets b/src/tests/issues.targets
+index 37f4d2615cd851..4b51bdad3d9b1f 100644
+--- a/src/tests/issues.targets
++++ b/src/tests/issues.targets
+@@ -73,9 +73,6 @@
+          <ExcludeList Include="$(XunitTestBinBase)/JIT/Directed/arglist/vararg_TargetUnix/*">
+             <Issue>https://github.com/dotnet/runtime/issues/10478 </Issue>
+         </ExcludeList>
+-        <ExcludeList Include="$(XunitTestBinBase)/Interop/ExecInDefAppDom/ExecInDefAppDom/*">
+-            <Issue>Issue building native components for the test.</Issue>
+-        </ExcludeList>
+     </ItemGroup>
+ 
+     <!-- All Unix targets  on CoreCLR Runtime -->
+diff --git a/src/tests/profiler/native/CMakeLists.txt b/src/tests/profiler/native/CMakeLists.txt
+index b7357a678b15a9..b9a1f47e5ab803 100644
+--- a/src/tests/profiler/native/CMakeLists.txt
++++ b/src/tests/profiler/native/CMakeLists.txt
+@@ -11,6 +11,7 @@ set(SOURCES
+     gcbasicprofiler/gcbasicprofiler.cpp
+     gcprofiler/gcprofiler.cpp
+     getappdomainstaticaddress/getappdomainstaticaddress.cpp
++    inlining/inlining.cpp
+     metadatagetdispenser/metadatagetdispenser.cpp
+     multiple/multiple.cpp
+     nullprofiler/nullprofiler.cpp
+diff --git a/src/tests/profiler/native/classfactory.cpp b/src/tests/profiler/native/classfactory.cpp
+index d09cb4c4e3bb02..de0a07ce08937d 100644
+--- a/src/tests/profiler/native/classfactory.cpp
++++ b/src/tests/profiler/native/classfactory.cpp
+@@ -15,6 +15,7 @@
+ #include "releaseondetach/releaseondetach.h"
+ #include "transitions/transitions.h"
+ #include "multiple/multiple.h"
++#include "inlining/inlining.h"
+ 
+ ClassFactory::ClassFactory(REFCLSID clsid) : refCount(0), clsid(clsid)
+ {
+@@ -114,6 +115,10 @@ HRESULT STDMETHODCALLTYPE ClassFactory::CreateInstance(IUnknown *pUnkOuter, REFI
+     {
+         profiler = new MultiplyLoaded();
+     }
++    else if (clsid == InliningProfiler::GetClsid())
++    {
++        profiler = new InliningProfiler();
++    }
+     else
+     {
+         printf("No profiler found in ClassFactory::CreateInstance. Did you add your profiler to the list?\n");
+diff --git a/src/tests/profiler/native/eltprofiler/slowpatheltprofiler.cpp b/src/tests/profiler/native/eltprofiler/slowpatheltprofiler.cpp
+index 17b114dd68b4c8..032dd3a82fa9ca 100644
+--- a/src/tests/profiler/native/eltprofiler/slowpatheltprofiler.cpp
++++ b/src/tests/profiler/native/eltprofiler/slowpatheltprofiler.cpp
+@@ -21,10 +21,10 @@ shared_ptr<SlowPathELTProfiler> SlowPathELTProfiler::s_profiler;
+ 
+ #ifndef WIN32
+ #define UINT_PTR_FORMAT "lx"
+-#define PROFILER_STUB EXTERN_C __attribute__((visibility("hidden"))) void STDMETHODCALLTYPE
++#define PROFILER_STUB __attribute__((visibility("hidden"))) static void STDMETHODCALLTYPE
+ #else // WIN32
+ #define UINT_PTR_FORMAT "llx"
+-#define PROFILER_STUB EXTERN_C void STDMETHODCALLTYPE
++#define PROFILER_STUB static void STDMETHODCALLTYPE
+ #endif // WIN32
+ 
+ PROFILER_STUB EnterStub(FunctionIDOrClientID functionId, COR_PRF_ELT_INFO eltInfo)
+diff --git a/src/tests/profiler/native/inlining/inlining.cpp b/src/tests/profiler/native/inlining/inlining.cpp
+new file mode 100644
+index 00000000000000..0cd436833efd05
+--- /dev/null
++++ b/src/tests/profiler/native/inlining/inlining.cpp
+@@ -0,0 +1,172 @@
++// Licensed to the .NET Foundation under one or more agreements.
++// The .NET Foundation licenses this file to you under the MIT license.
++
++#define NOMINMAX
++
++#include "inlining.h"
++#include <iostream>
++
++using std::shared_ptr;
++using std::wcout;
++using std::endl;
++using std::atomic;
++
++shared_ptr<InliningProfiler> InliningProfiler::s_profiler;
++
++#ifndef WIN32
++#define UINT_PTR_FORMAT "lx"
++#define PROFILER_STUB __attribute__((visibility("hidden"))) static void STDMETHODCALLTYPE
++#else // WIN32
++#define UINT_PTR_FORMAT "llx"
++#define PROFILER_STUB static void STDMETHODCALLTYPE
++#endif // WIN32
++
++PROFILER_STUB EnterStub(FunctionIDOrClientID functionId, COR_PRF_ELT_INFO eltInfo)
++{
++    SHUTDOWNGUARD_RETVOID();
++
++    InliningProfiler::s_profiler->EnterCallback(functionId, eltInfo);
++}
++
++PROFILER_STUB LeaveStub(FunctionIDOrClientID functionId, COR_PRF_ELT_INFO eltInfo)
++{
++    SHUTDOWNGUARD_RETVOID();
++
++    InliningProfiler::s_profiler->LeaveCallback(functionId, eltInfo);
++}
++
++PROFILER_STUB TailcallStub(FunctionIDOrClientID functionId, COR_PRF_ELT_INFO eltInfo)
++{
++    SHUTDOWNGUARD_RETVOID();
++
++    InliningProfiler::s_profiler->TailcallCallback(functionId, eltInfo);
++}
++
++GUID InliningProfiler::GetClsid()
++{
++    // {DDADC0CB-21C8-4E53-9A6C-7C65EE5800CE}
++    GUID clsid = { 0xDDADC0CB, 0x21C8, 0x4E53, { 0x9A, 0x6C, 0x7C, 0x65, 0xEE, 0x58, 0x00, 0xCE } };
++    return clsid;
++}
++
++HRESULT InliningProfiler::Initialize(IUnknown* pICorProfilerInfoUnk)
++{
++    Profiler::Initialize(pICorProfilerInfoUnk);
++
++    HRESULT hr = S_OK;
++    InliningProfiler::s_profiler = shared_ptr<InliningProfiler>(this);
++
++    if (FAILED(hr = pCorProfilerInfo->SetEventMask2(COR_PRF_MONITOR_ENTERLEAVE
++                                                    | COR_PRF_ENABLE_FUNCTION_ARGS
++                                                    | COR_PRF_ENABLE_FUNCTION_RETVAL
++                                                    | COR_PRF_ENABLE_FRAME_INFO
++                                                    | COR_PRF_MONITOR_JIT_COMPILATION,
++                                                    0)))
++    {
++        wcout << L"FAIL: IpCorProfilerInfo::SetEventMask2() failed hr=0x" << std::hex << hr << endl;
++        _failures++;
++        return hr;
++    }
++
++    hr = this->pCorProfilerInfo->SetEnterLeaveFunctionHooks3WithInfo(EnterStub, LeaveStub, TailcallStub);
++    if (hr != S_OK)
++    {
++        wcout << L"SetEnterLeaveFunctionHooks3WithInfo failed with hr=0x" << std::hex << hr << endl;
++        _failures++;
++        return hr;
++    }
++
++    return S_OK;
++}
++
++HRESULT InliningProfiler::Shutdown()
++{
++    Profiler::Shutdown();
++
++    if (_failures == 0 && _sawInlineeCall)
++    {
++        wcout << L"PROFILER TEST PASSES" << endl;
++    }
++    else
++    {
++        wcout << L"TEST FAILED _failures=" << _failures.load() 
++              << L"_sawInlineeCall=" << _sawInlineeCall << endl;
++    }
++
++    return S_OK;
++}
++
++HRESULT STDMETHODCALLTYPE InliningProfiler::EnterCallback(FunctionIDOrClientID functionIdOrClientID, COR_PRF_ELT_INFO eltInfo)
++{
++    String functionName = GetFunctionIDName(functionIdOrClientID.functionID);
++    if (functionName == WCHAR("Inlining"))
++    {
++        _inInlining = true;
++    }
++    else if (functionName == WCHAR("BlockInlining"))
++    {
++        _inBlockInlining = true;
++    }
++    else if (functionName == WCHAR("NoResponse"))
++    {
++        _inNoResponse = true;
++    }
++    else if (functionName == WCHAR("Inlinee"))
++    {
++        if (_inInlining || _inNoResponse)
++        {
++            _failures++;
++            wcout << L"Saw Inlinee as a real method call instead of inlined." << endl;
++        }
++
++        if (_inBlockInlining)
++        {
++            _sawInlineeCall = true;
++        }
++    }
++
++    return S_OK;
++}
++
++HRESULT STDMETHODCALLTYPE InliningProfiler::LeaveCallback(FunctionIDOrClientID functionIdOrClientID, COR_PRF_ELT_INFO eltInfo)
++{
++    String functionName = GetFunctionIDName(functionIdOrClientID.functionID);
++    if (functionName == WCHAR("Inlining"))
++    {
++        _inInlining = false;
++    }
++    else if (functionName == WCHAR("BlockInlining"))
++    {
++        _inBlockInlining = false;
++    }
++    else if (functionName == WCHAR("NoResponse"))
++    {
++        _inNoResponse = false;
++    }
++
++    return S_OK;
++}
++
++HRESULT STDMETHODCALLTYPE InliningProfiler::TailcallCallback(FunctionIDOrClientID functionIdOrClientID, COR_PRF_ELT_INFO eltInfo)
++{
++    return S_OK;
++}
++
++HRESULT STDMETHODCALLTYPE InliningProfiler::JITInlining(FunctionID callerId, FunctionID calleeId, BOOL* pfShouldInline)
++{
++    String inlineeName = GetFunctionIDName(calleeId);
++    if (inlineeName == WCHAR("Inlinee"))
++    {
++        String inlinerName = GetFunctionIDName(callerId);
++        if (inlinerName == WCHAR("Inlining"))
++        {
++            *pfShouldInline = TRUE;
++        }
++        else if (inlinerName == WCHAR("BlockInlining"))
++        {
++            *pfShouldInline = FALSE;
++        }
++    }
++
++    return S_OK;
++}
+diff --git a/src/tests/profiler/native/inlining/inlining.h b/src/tests/profiler/native/inlining/inlining.h
+new file mode 100644
+index 00000000000000..4b1b8752e3ec56
+--- /dev/null
++++ b/src/tests/profiler/native/inlining/inlining.h
+@@ -0,0 +1,38 @@
++// Licensed to the .NET Foundation under one or more agreements.
++// The .NET Foundation licenses this file to you under the MIT license.
++
++#pragma once
++
++#include "../profiler.h"
++#include <memory>
++
++class InliningProfiler : public Profiler
++{
++public:
++    static std::shared_ptr<InliningProfiler> s_profiler;
++
++    InliningProfiler() : 
++    	Profiler(),
++    	_failures(0),
++    	_inInlining(false),
++    	_inBlockInlining(false),
++    	_inNoResponse(false)
++    {
++    }
++
++    static GUID GetClsid();
++    virtual HRESULT STDMETHODCALLTYPE Initialize(IUnknown* pICorProfilerInfoUnk);
++    virtual HRESULT STDMETHODCALLTYPE Shutdown();
++    virtual HRESULT STDMETHODCALLTYPE JITInlining(FunctionID callerId, FunctionID calleeId, BOOL* pfShouldInline);
++
++    HRESULT STDMETHODCALLTYPE EnterCallback(FunctionIDOrClientID functionId, COR_PRF_ELT_INFO eltInfo);
++    HRESULT STDMETHODCALLTYPE LeaveCallback(FunctionIDOrClientID functionId, COR_PRF_ELT_INFO eltInfo);
++    HRESULT STDMETHODCALLTYPE TailcallCallback(FunctionIDOrClientID functionId, COR_PRF_ELT_INFO eltInfo);
++
++private:
++    std::atomic<int> _failures;
++    bool _inInlining;
++    bool _inBlockInlining;
++    bool _inNoResponse;
++    bool _sawInlineeCall;
++};
+diff --git a/src/tests/profiler/unittest/inlining.cs b/src/tests/profiler/unittest/inlining.cs
+new file mode 100644
+index 00000000000000..84b9cdb85f5e45
+--- /dev/null
++++ b/src/tests/profiler/unittest/inlining.cs
+@@ -0,0 +1,66 @@
++// Licensed to the .NET Foundation under one or more agreements.
++// The .NET Foundation licenses this file to you under the MIT license.
++
++using System;
++using System.IO;
++using System.Runtime.CompilerServices;
++using System.Runtime.InteropServices;
++using System.Threading;
++
++namespace Profiler.Tests
++{
++    class InliningTest
++    {
++        private static readonly Guid InliningGuid = new Guid("DDADC0CB-21C8-4E53-9A6C-7C65EE5800CE");
++
++        [MethodImpl(MethodImplOptions.AggressiveInlining)]
++        public static int Inlinee()
++        {
++            Random rand = new Random();
++            return rand.Next();
++        }
++
++        [MethodImpl(MethodImplOptions.NoInlining)]
++        public static void Inlining()
++        {
++            int x = Inlinee();
++            Console.WriteLine($"Inlining, x={x}");
++        }
++
++        [MethodImpl(MethodImplOptions.NoInlining)]
++        public static void BlockInlining()
++        {
++            int x = Inlinee();
++            Console.WriteLine($"BlockInlining, x={x}");
++        }
++
++        [MethodImpl(MethodImplOptions.NoInlining)]
++        public static void NoResponse()
++        {
++            int x = Inlinee();
++            Console.WriteLine($"NoResponse, x={x}");
++        }
++
++        public static int RunTest(string[] args)
++        {
++            Inlining();
++            BlockInlining();
++            NoResponse();
++
++            return 100;
++        }
++
++        public static int Main(string[] args)
++        {
++            if (args.Length > 0 && args[0].Equals("RunTest", StringComparison.OrdinalIgnoreCase))
++            {
++                return RunTest(args);
++            }
++
++            return ProfilerTestRunner.Run(profileePath: System.Reflection.Assembly.GetExecutingAssembly().Location,
++                                          testName: "UnitTestInlining",
++                                          profilerClsid: InliningGuid,
++                                          profileeOptions: ProfileeOptions.OptimizationSensitive);
++        }
++    }
++}
+diff --git a/src/tests/profiler/unittest/inlining.csproj b/src/tests/profiler/unittest/inlining.csproj
+new file mode 100644
+index 00000000000000..b2fbdc913b04a2
+--- /dev/null
++++ b/src/tests/profiler/unittest/inlining.csproj
+@@ -0,0 +1,23 @@
++<Project Sdk="Microsoft.NET.Sdk">
++  <PropertyGroup>
++    <TargetFrameworkIdentifier>.NETCoreApp</TargetFrameworkIdentifier>
++    <OutputType>exe</OutputType>
++    <CLRTestKind>BuildAndRun</CLRTestKind>
++    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
++    <CLRTestPriority>0</CLRTestPriority>
++    <Optimize>true</Optimize>
++    <!-- This test provides no interesting scenarios for GCStress -->
++    <GCStressIncompatible>true</GCStressIncompatible>
++    <!-- The test launches a secondary process and process launch creates
++    an infinite event loop in the SocketAsyncEngine on Linux. Since 
++    runincontext loads even framework assemblies into the unloadable
++    context, locals in this loop prevent unloading -->
++    <UnloadabilityIncompatible>true</UnloadabilityIncompatible>
++  </PropertyGroup>
++  <ItemGroup>
++    <Compile Include="$(MSBuildProjectName).cs" />
++    <ProjectReference Include="$(TestSourceDir)Common/CoreCLRTestLibrary/CoreCLRTestLibrary.csproj" />
++    <ProjectReference Include="../common/profiler_common.csproj" />
++    <ProjectReference Include="$(MSBuildThisFileDirectory)/../native/CMakeLists.txt" />
++  </ItemGroup>
++</Project>
+diff --git a/src/workloads/workloads.csproj b/src/workloads/workloads.csproj
+index c1f6b4bb419ff2..f64d641604674d 100644
+--- a/src/workloads/workloads.csproj
++++ b/src/workloads/workloads.csproj
+@@ -48,7 +48,7 @@
+ 
+   <Import Sdk="Microsoft.NET.Sdk" Project="Sdk.targets" />
+ 
+-  <Target Name="Build" DependsOnTargets="GenerateVersions">
++  <Target Name="Build" DependsOnTargets="GetAssemblyVersion;_GetVersionProps;_GenerateMsiVersionString">
+     <ItemGroup>
+       <!-- Overrides for Visual Studio setup generation. If the workload definition IDs change,
+            these must be updated. -->
+@@ -106,14 +106,6 @@
+       <ManifestPackages Include="$(PackageSource)Microsoft.NET.Workload.Mono.ToolChain.Manifest-*.nupkg" />
+     </ItemGroup>
+ 
+-    <GenerateMsiVersion
+-        Major="$([System.Version]::Parse('$(SDKBundleVersion)').Major)"
+-        Minor="$([System.Version]::Parse('$(SDKBundleVersion)').Minor)"
+-        Patch="$([System.Version]::Parse('$(SDKBundleVersion)').Build)"
+-        BuildNumber="$([System.Version]::Parse('$(SDKBundleVersion)').Revision)" >
+-      <Output TaskParameter="MsiVersion" PropertyName="MsiVersion" />
+-    </GenerateMsiVersion>
+-
+     <GenerateManifestMsi
+         IntermediateBaseOutputPath="$(IntermediateOutputPath)"
+         OutputPath="$(OutputPath)"
+@@ -195,28 +187,38 @@
+     <MSBuild Projects="@(VisualStudioManifestProjects)" BuildInParallel="true" Properties="SwixBuildTargets=$(SwixBuildTargets);ManifestOutputPath=$(VersionedVisualStudioSetupInsertionPath);OutputPath=$(VersionedVisualStudioSetupInsertionPath)" />
+   </Target>
+ 
+-  <Target Name="GenerateVersions" DependsOnTargets="GetAssemblyVersion">
+-    <Exec Command="git rev-list --count HEAD"
+-          ConsoleToMSBuild="true"
+-          Condition=" '$(GitCommitCount)' == '' ">
+-      <Output TaskParameter="ConsoleOutput" PropertyName="GitCommitCount" />
+-    </Exec>
+-
+-    <Error Condition=" '$(OfficialBuild)' == 'true' And '$(_PatchNumber)' == '' "
+-           Text="_PatchNumber should not be empty in an official build. Check if there were changes in Arcade." />
++  <Target Name="_GetVersionProps">
++    <PropertyGroup>
++      <_MajorVersion>$([System.Version]::Parse('$(AssemblyVersion)').Major)</_MajorVersion>
++      <_MinorVersion>$([System.Version]::Parse('$(AssemblyVersion)').Minor)</_MinorVersion>
++      <_PatchVersion>$([System.Version]::Parse('$(AssemblyVersion)').Build)</_PatchVersion>
++      <_BuildNumber>$([System.Version]::Parse('$(AssemblyVersion)').Revision)</_BuildNumber>
++    </PropertyGroup>
++  </Target>
+ 
++  <Target Name="_GenerateMsiVersionString">
+     <PropertyGroup>
+-      <GitCommitCount>$(GitCommitCount.PadLeft(6,'0'))</GitCommitCount>
++      <VersionPadding Condition="'$(VersionPadding)'==''">5</VersionPadding>
++      <!-- Using the following default comparison date will produce versions that align with our internal build system. -->
++      <VersionComparisonDate Condition="'$(VersionComparisonDate)'==''">1996-04-01</VersionComparisonDate>
++    </PropertyGroup>
+ 
+-      <!-- This number comes from arcade and combines the date based build number id and the revision (incremental number per day) -->
+-      <CombinedBuildNumberAndRevision>$(_PatchNumber)</CombinedBuildNumberAndRevision>
+-      <!-- Fallback to commit count when patch number is not set. This happens only during CI. -->
+-      <CombinedBuildNumberAndRevision Condition=" '$(CombinedBuildNumberAndRevision)' == '' ">$(GitCommitCount)</CombinedBuildNumberAndRevision>
++    <GenerateCurrentVersion
++      SeedDate="$([System.DateTime]::Now.ToString(yyyy-MM-dd))"
++      OfficialBuildId="$(OfficialBuildId)"
++      ComparisonDate="$(VersionComparisonDate)"
++      Padding="$(VersionPadding)">
++      <Output PropertyName="BuildNumberMajor" TaskParameter="GeneratedVersion" />
++      <Output PropertyName="BuildNumberMinor" TaskParameter="GeneratedRevision" />
++    </GenerateCurrentVersion>
+ 
+-      <!-- This number comes from arcade and combines the date based build number id and the revision (incremental number per day) -->
+-      <SDKBundleVersion>$(FileVersion)</SDKBundleVersion>
+-      <!-- Fallback to commit count when patch number is not set. This happens only during CI. -->
+-      <SDKBundleVersion Condition=" '$(SDKBundleVersion)' == '' ">$(VersionPrefix).$(CombinedBuildNumberAndRevision)</SDKBundleVersion>
+-    </PropertyGroup>
++    <GenerateMsiVersion
++      Major="$(_MajorVersion)"
++      Minor="$(_MinorVersion)"
++      Patch="$(_PatchVersion)"
++      BuildNumberMajor="$(BuildNumberMajor)"
++      BuildNumberMinor="$(BuildNumberMinor)">
++      <Output TaskParameter="MsiVersion" PropertyName="MsiVersion" />
++    </GenerateMsiVersion>
+   </Target>
+ </Project>

data/raw_sample/diffs/00040d352d668fc001dae7cf6b9c31a2529ad941.diff

@@ -0,0 +1,13 @@
+diff --git a/src/tasks/Microsoft.NET.Sdk.WebAssembly.Pack.Tasks/GenerateWasmBootJson.cs b/src/tasks/Microsoft.NET.Sdk.WebAssembly.Pack.Tasks/GenerateWasmBootJson.cs
+index c5589c9781cea6..0e8dc24e3e23a4 100644
+--- a/src/tasks/Microsoft.NET.Sdk.WebAssembly.Pack.Tasks/GenerateWasmBootJson.cs
++++ b/src/tasks/Microsoft.NET.Sdk.WebAssembly.Pack.Tasks/GenerateWasmBootJson.cs
+@@ -196,7 +196,7 @@ public void WriteBootJson(Stream output, string entryAssemblyName)
+                         string.Equals(assetTraitValue, "native", StringComparison.OrdinalIgnoreCase))
+                 {
+                     Log.LogMessage(MessageImportance.Low, "Candidate '{0}' is defined as a native application resource.", resource.ItemSpec);
+-                    if (fileName.StartsWith("dotnet.native", StringComparison.OrdinalIgnoreCase) && string.Equals(fileExtension, ".wasm", StringComparison.OrdinalIgnoreCase))
++                    if (fileName.StartsWith("dotnet", StringComparison.OrdinalIgnoreCase) && string.Equals(fileExtension, ".wasm", StringComparison.OrdinalIgnoreCase))
+                     {
+                         behavior = "dotnetwasm";
+                     }

data/raw_sample/prs/pr-1.json

@@ -0,0 +1,223 @@
+{
+  "number": 1,
+  "title": "WIP: repo consolidation scouting kick-off - make clr build locally on Windows",
+  "body": "This is my first contribution to the scouting to let other people\r\nsee the first problems I'm hitting as I believe them to be mostly\r\ngeneral. With this small change I now have at least the native part\r\nof CoreCLR build running - I'm not yet past that so then I'll see\r\nwhat other problems I hit when building the managed components,\r\nbuilding and running tests.\r\n\r\nAs you can easily see, the first (and so far the only) problem is\r\nthe split of the two roots (subrepo root vs. repo root) making the\r\nbuild script fail when trying to locate \"msbuild.ps1\" which is now\r\nunder a repo-global eng folder. I can imagine it may be undesirable\r\nto query GIT in the build script; in this particular case we have\r\nmultiple alternate ways to proceed (keep the duplicates of\r\nmsbuild.ps1? autodetecting the root based on some well-known file?).\r\n\r\nThanks\r\n\r\nTomas",
+  "createdAt": "2019-10-15T17:51:16Z",
+  "closedAt": "2019-10-29T16:41:31Z",
+  "mergedAt": null,
+  "state": "CLOSED",
+  "author": {
+    "login": "trylek"
+  },
+  "labels": {
+    "nodes": []
+  },
+  "headRefName": "BuildCoreCLR",
+  "additions": 2,
+  "deletions": 2,
+  "changedFiles": 2,
+  "comments": {
+    "totalCount": 19,
+    "nodes": [
+      {
+        "body": "I'm seeing a similar issue in core-setup.",
+        "createdAt": "2019-10-15T17:53:02Z"
+      },
+      {
+        "body": "Can you use the `RepositoryEngineeringDir` variable?",
+        "createdAt": "2019-10-15T17:58:16Z"
+      },
+      {
+        "body": "@ViktorHofer this is just to find the `eng/common` folder before even invoking the scripts.",
+        "createdAt": "2019-10-15T18:00:35Z"
+      },
+      {
+        "body": "Hmm, where is this supposed to be coming from? I'm normally building the repo from the Windows prompt - who is going to set the variable there? Or are you saying we should go through some central script that would set the variable? That would probably solve the problem but we're back to chicken-egg problem w.r.t. how to locate such a global script? ",
+        "createdAt": "2019-10-15T18:01:22Z"
+      },
+      {
+        "body": "Arcade defines that property, so you would get it if you import the Arcade SDK. Are you saying that at this point you don't have Arcade imported yet?\r\n\r\nIf that's the case we can probably manually define it in a runtime root's Directory.Build.props file which is then imported by the repos.",
+        "createdAt": "2019-10-15T18:02:27Z"
+      },
+      {
+        "body": "In fact, that might be one of the solutions - we would check in a special script at the root of each of the repos being merged, that would set the path to the repo root. In the source repos that would equal the repo root while we would massage it during the port to point to the global root.",
+        "createdAt": "2019-10-15T18:03:08Z"
+      },
+      {
+        "body": "https://github.com/dotnet/arcade/blob/e0112fe2f1fd7f6db08b228db98f22225f82267b/src/Microsoft.DotNet.Arcade.Sdk/tools/RepoLayout.props#L22-L65",
+        "createdAt": "2019-10-15T18:04:18Z"
+      },
+      {
+        "body": "@ViktorHofer we haven't even found MSBuild yet, let alone invoked a build with the Arcade SDK at this point.\r\n\r\nI encountered the same issue in core-setup's `build.cmd` just to find Arcade's `build.ps1`.",
+        "createdAt": "2019-10-15T18:04:22Z"
+      },
+      {
+        "body": "OK got it.",
+        "createdAt": "2019-10-15T18:04:49Z"
+      },
+      {
+        "body": "I am afraid that we're still on the chicken-egg plan as in CoreCLR running \"msbuild.ps1\" is exactly the thing that requires locating the repo root.",
+        "createdAt": "2019-10-15T18:06:06Z"
+      },
+      {
+        "body": "OK there are multiple options here. \r\n\r\n1. Importing a cmd/sh script that defines those paths that lives either in the parent (src) directory or parent-parent (repo root) dir?\r\n2. Hardcoding the relative path to the repo root (../../)\r\n3. Using git to resolve to the repo-root\r\n\r\nOther ideas?",
+        "createdAt": "2019-10-15T18:08:39Z"
+      },
+      {
+        "body": "Circling back to my suggestion to \"check in a script at the root of each repo being merged\", that may be also usable for other things like exporting an environment variable declaring whether we're in the split or merged repo.",
+        "createdAt": "2019-10-15T18:08:50Z"
+      },
+      {
+        "body": "[not sure what kind of script that should be, ideally something that doesn't require two versions for Windows vs. non-Windows]",
+        "createdAt": "2019-10-15T18:09:27Z"
+      },
+      {
+        "body": "I think I like Jared's suggestion to ideally make most of the changes in the original repos so that we can arbitrarily repeat this process. So I think hard-coding ..\\.. is not ideal unless it comes from a script the porting process will create. I leave it to others to chime in as to whether it's legal to query git or not. I don't think it's strictly illegal, I think that the BuildVersion script is doing that already, and both in the lab and locally we always have a legal GIT repository available whenever we run the build script. Considering the dichotomy is supposed to be temporary, using the GIT magic may be a reasonable workaround.",
+        "createdAt": "2019-10-15T18:12:48Z"
+      },
+      {
+        "body": "I agree with you. We should make most changes in the original repository. Just as an FYI, in cases where this isn't possible, you can create a GIT patch and place it here: https://github.com/dotnet/consolidation/tree/master/patches/coreclr",
+        "createdAt": "2019-10-15T18:16:22Z"
+      },
+      {
+        "body": "Conceptually, if we decide to emit / special case some scripts in the subrepos to interface the subrepos to their \"embedding\" within either the split or consolidated repo, we might also want to introduce similar per-subrepo interfacing YAML files under eng somewhere, going back to Jared's proposal for encoding the script / source location details via variables.",
+        "createdAt": "2019-10-15T18:16:59Z"
+      },
+      {
+        "body": "Ahh, thanks Viktor for making me aware of the patch list, that's very nice!",
+        "createdAt": "2019-10-15T18:19:54Z"
+      },
+      {
+        "body": "OK, so if I may try to divide the problem space, I believe that we're basically in agreement that we need some environment variable representing the \"main root repo\" that translates to the normal thing for the existing repos like CoreCLR and to the root of the consolidated repo in the merged case. In such case I can continue making further progress using my temporary git query hack while we discuss how to tackle this cleanly as there seem to be several available options.",
+        "createdAt": "2019-10-15T18:24:10Z"
+      },
+      {
+        "body": "Source-build does have a requirement to be able to build without a valid Git repo since we package sources and tools into a tarball without the accompanying Git repo.  We could work with an environment variable override or similar though.",
+        "createdAt": "2019-10-15T18:29:33Z"
+      }
+    ]
+  },
+  "reviewThreads": {
+    "totalCount": 4,
+    "nodes": [
+      {
+        "comments": {
+          "nodes": [
+            {
+              "path": "NuGet.config",
+              "diffHunk": "@@ -14,6 +14,7 @@\n     <add key=\"dotnet-core\" value=\"https://dotnetfeed.blob.core.windows.net/dotnet-core/index.json\" />\n     <add key=\"dotnet-coreclr\" value=\"https://dotnetfeed.blob.core.windows.net/dotnet-coreclr/index.json\" />\n     <add key=\"dotnet-windowsdesktop\" value=\"https://dotnetfeed.blob.core.windows.net/dotnet-windowsdesktop/index.json\" />\n+    <add key=\"myget.org dotnet-core\" value=\"https://dotnet.myget.org/F/dotnet-core/api/v3/index.json\" />",
+              "body": "@trylek I think we should try to get rid of this feed in coreclr before we consolidate as myget is unreliable. What assets are you currently pushing there?",
+              "createdAt": "2019-10-17T10:09:05Z"
+            },
+            {
+              "path": "NuGet.config",
+              "diffHunk": "@@ -14,6 +14,7 @@\n     <add key=\"dotnet-core\" value=\"https://dotnetfeed.blob.core.windows.net/dotnet-core/index.json\" />\n     <add key=\"dotnet-coreclr\" value=\"https://dotnetfeed.blob.core.windows.net/dotnet-coreclr/index.json\" />\n     <add key=\"dotnet-windowsdesktop\" value=\"https://dotnetfeed.blob.core.windows.net/dotnet-windowsdesktop/index.json\" />\n+    <add key=\"myget.org dotnet-core\" value=\"https://dotnet.myget.org/F/dotnet-core/api/v3/index.json\" />",
+              "body": "I believe this is only needed by crossgen2 and R2RDump - without the additional feed they cannot find the [old] System.CommandLine parser package. I have already switched SuperIlc over to use the new parser and it would be probably feasible to do the same for the two other apps if necessary.",
+              "createdAt": "2019-10-17T14:12:39Z"
+            },
+            {
+              "path": "NuGet.config",
+              "diffHunk": "@@ -14,6 +14,7 @@\n     <add key=\"dotnet-core\" value=\"https://dotnetfeed.blob.core.windows.net/dotnet-core/index.json\" />\n     <add key=\"dotnet-coreclr\" value=\"https://dotnetfeed.blob.core.windows.net/dotnet-coreclr/index.json\" />\n     <add key=\"dotnet-windowsdesktop\" value=\"https://dotnetfeed.blob.core.windows.net/dotnet-windowsdesktop/index.json\" />\n+    <add key=\"myget.org dotnet-core\" value=\"https://dotnet.myget.org/F/dotnet-core/api/v3/index.json\" />",
+              "body": "IIRC there was some work in the dotnet/jitutils repo that was waiting on R2RDump to move off the old System.CommandLine, so there'd be a number of people happy about removing old System.CommandLine.",
+              "createdAt": "2019-10-17T15:06:51Z"
+            },
+            {
+              "path": "NuGet.config",
+              "diffHunk": "@@ -14,6 +14,7 @@\n     <add key=\"dotnet-core\" value=\"https://dotnetfeed.blob.core.windows.net/dotnet-core/index.json\" />\n     <add key=\"dotnet-coreclr\" value=\"https://dotnetfeed.blob.core.windows.net/dotnet-coreclr/index.json\" />\n     <add key=\"dotnet-windowsdesktop\" value=\"https://dotnetfeed.blob.core.windows.net/dotnet-windowsdesktop/index.json\" />\n+    <add key=\"myget.org dotnet-core\" value=\"https://dotnet.myget.org/F/dotnet-core/api/v3/index.json\" />",
+              "body": "myget is unreliable but I wouldn't block consolidation on it. \r\n\r\nMy mental model for should or shouldn't we require this before consolidation is roughly this (assuming it's not a functional blocker);\r\n\r\n> Could we fix this in the consolidated repository in less than one business day. If so don't block consolidation on it because it's something we could iterate on pretty fast. \r\n\r\n",
+              "createdAt": "2019-10-21T16:57:31Z"
+            }
+          ]
+        }
+      },
+      {
+        "comments": {
+          "nodes": [
+            {
+              "path": "eng/Tools.props",
+              "diffHunk": "@@ -0,0 +1,15 @@\n+<?xml version=\"1.0\" encoding=\"utf-8\"?>\n+<Project>\n+  <PropertyGroup>\n+    <RestoreSources Condition=\"'$(AdditionalRestoreSources)' != ''\">",
+              "body": "AFAIK, RestoreSources aren't honored by Arcade anymore.",
+              "createdAt": "2019-10-17T10:09:29Z"
+            },
+            {
+              "path": "eng/Tools.props",
+              "diffHunk": "@@ -0,0 +1,15 @@\n+<?xml version=\"1.0\" encoding=\"utf-8\"?>\n+<Project>\n+  <PropertyGroup>\n+    <RestoreSources Condition=\"'$(AdditionalRestoreSources)' != ''\">",
+              "body": "I must admit I actually don't know what exactly this file is needed for, I just see that in its absence CoreCLR build seems unable to install \"dotnet.exe\" (dotnet-install) and subsequently pull down some packages needed by the build like Microsoft.DotNet.Build.Tasks.Packaging. Having said that, I fully admit I've never been a Nuget expert so I may be easily misinterpreting the symptome.",
+              "createdAt": "2019-10-17T14:14:34Z"
+            }
+          ]
+        }
+      },
+      {
+        "comments": {
+          "nodes": [
+            {
+              "path": "eng/configure-toolset.ps1",
+              "diffHunk": "@@ -1,2 +1,12 @@\n+# We depend on a local cli for a number of our buildtool\n+# commands like init-tools so for now we need to disable\n+# using the globally installed dotnet\n+\n+$script:useInstalledDotNetCli = $false\n+\n+# Always use the local repo packages directory instead of\n+# the user's NuGet cache\n+$script:useGlobalNuGetCache = $false",
+              "body": "I think we should make sure that coreclr works with the global nuget cache enabled. This is the default for corefx and it would be really sad if we need to go back to the old world with the repo packages dir.",
+              "createdAt": "2019-10-17T10:10:44Z"
+            },
+            {
+              "path": "eng/configure-toolset.ps1",
+              "diffHunk": "@@ -1,2 +1,12 @@\n+# We depend on a local cli for a number of our buildtool\n+# commands like init-tools so for now we need to disable\n+# using the globally installed dotnet\n+\n+$script:useInstalledDotNetCli = $false\n+\n+# Always use the local repo packages directory instead of\n+# the user's NuGet cache\n+$script:useGlobalNuGetCache = $false",
+              "body": "Using the repo package level directory has helped us achieve higher fidelity in our CI. At the moment I believe arcade still uses the global nuget cache as well, but our goal pre-consolidation was to move as much as we could to the repo level nuget cache.",
+              "createdAt": "2019-10-17T16:57:11Z"
+            },
+            {
+              "path": "eng/configure-toolset.ps1",
+              "diffHunk": "@@ -1,2 +1,12 @@\n+# We depend on a local cli for a number of our buildtool\n+# commands like init-tools so for now we need to disable\n+# using the globally installed dotnet\n+\n+$script:useInstalledDotNetCli = $false\n+\n+# Always use the local repo packages directory instead of\n+# the user's NuGet cache\n+$script:useGlobalNuGetCache = $false",
+              "body": "Do you have some data on that? We aren't hitting any issues with using the user global nuget cache locally and the repo package cache in CI (the default behavior in an arcade enabled repo) in corefx.\r\n\r\n> but our goal pre-consolidation was to move as much as we could to the repo level nuget cache\r\n\r\nCan you please elaborate on that? Not sure what you mean.",
+              "createdAt": "2019-10-17T17:07:14Z"
+            },
+            {
+              "path": "eng/configure-toolset.ps1",
+              "diffHunk": "@@ -1,2 +1,12 @@\n+# We depend on a local cli for a number of our buildtool\n+# commands like init-tools so for now we need to disable\n+# using the globally installed dotnet\n+\n+$script:useInstalledDotNetCli = $false\n+\n+# Always use the local repo packages directory instead of\n+# the user's NuGet cache\n+$script:useGlobalNuGetCache = $false",
+              "body": "The issue is that the default global cache is on the home drive. Which for vms is the most expensive and smallest size disk. This equates to a performance problem, for our arm hardware our home disks are extremely small. Helix also consumes most of the home disk, so accidentally filling the disk with the global nuget cache on the main disk used to happen.",
+              "createdAt": "2019-10-17T18:47:10Z"
+            },
+            {
+              "path": "eng/configure-toolset.ps1",
+              "diffHunk": "@@ -1,2 +1,12 @@\n+# We depend on a local cli for a number of our buildtool\n+# commands like init-tools so for now we need to disable\n+# using the globally installed dotnet\n+\n+$script:useInstalledDotNetCli = $false\n+\n+# Always use the local repo packages directory instead of\n+# the user's NuGet cache\n+$script:useGlobalNuGetCache = $false",
+              "body": "As for the comment. It is more of less whet I said. Coreclr’s expectation was to continue to use the non global nuget cache. I think there are still blockers keeping us from migrating away from that plan.",
+              "createdAt": "2019-10-17T18:48:21Z"
+            },
+            {
+              "path": "eng/configure-toolset.ps1",
+              "diffHunk": "@@ -1,2 +1,12 @@\n+# We depend on a local cli for a number of our buildtool\n+# commands like init-tools so for now we need to disable\n+# using the globally installed dotnet\n+\n+$script:useInstalledDotNetCli = $false\n+\n+# Always use the local repo packages directory instead of\n+# the user's NuGet cache\n+$script:useGlobalNuGetCache = $false",
+              "body": "Got it, that makes sense. What I don't understand is why this causes a problem as on CI the user global cache isn't used by default (arcade convention).",
+              "createdAt": "2019-10-17T18:48:52Z"
+            },
+            {
+              "path": "eng/configure-toolset.ps1",
+              "diffHunk": "@@ -1,2 +1,12 @@\n+# We depend on a local cli for a number of our buildtool\n+# commands like init-tools so for now we need to disable\n+# using the globally installed dotnet\n+\n+$script:useInstalledDotNetCli = $false\n+\n+# Always use the local repo packages directory instead of\n+# the user's NuGet cache\n+$script:useGlobalNuGetCache = $false",
+              "body": "https://github.com/dotnet/arcade/blob/90d8a77c53d5f540ebda7a56d8a2e5661657d742/eng/common/tools.sh#L52-L57",
+              "createdAt": "2019-10-17T18:51:09Z"
+            }
+          ]
+        }
+      },
+      {
+        "comments": {
+          "nodes": [
+            {
+              "path": "eng/configure-toolset.ps1",
+              "diffHunk": "@@ -1,2 +1,12 @@\n+# We depend on a local cli for a number of our buildtool\n+# commands like init-tools so for now we need to disable\n+# using the globally installed dotnet\n+\n+$script:useInstalledDotNetCli = $false",
+              "body": "Same for the SDK here. CoreClr isn't using buildtools anymore, why is still required?",
+              "createdAt": "2019-10-17T10:11:04Z"
+            },
+            {
+              "path": "eng/configure-toolset.ps1",
+              "diffHunk": "@@ -1,2 +1,12 @@\n+# We depend on a local cli for a number of our buildtool\n+# commands like init-tools so for now we need to disable\n+# using the globally installed dotnet\n+\n+$script:useInstalledDotNetCli = $false",
+              "body": "This is possibly an artifact of our older hack to support building with arcade and buildtools. I am not familiar exactly with what can be removed.",
+              "createdAt": "2019-10-17T16:58:35Z"
+            }
+          ]
+        }
+      }
+    ]
+  },
+  "commits": {
+    "totalCount": 0,
+    "nodes": []
+  }
+}

data/raw_sample/prs/pr-100.json

@@ -0,0 +1,137 @@
+{
+  "number": 100,
+  "title": "Remove repo zipping / unzipping",
+  "body": "As according to Matt Mitchell performance issues related to\r\nrepeated git checkouts (throttling) have been fixed and Azure\r\npipelines should automatically make sure that all jobs check out\r\nthe same GIT commit, I am removing the previous workaround to\r\nzip the Windows & Linux checkout as an initial step in each\r\npipeline and unzip it in subsequent jobs instead of repeating\r\nthe git checkout.\r\n\r\nThanks\r\n\r\nTomas",
+  "createdAt": "2019-11-18T15:50:10Z",
+  "closedAt": "2019-11-27T11:35:11Z",
+  "mergedAt": null,
+  "state": "CLOSED",
+  "author": {
+    "login": "trylek"
+  },
+  "labels": {
+    "nodes": [
+      {
+        "name": "area-Infrastructure-coreclr"
+      }
+    ]
+  },
+  "headRefName": "RemoveRepoZipUnzip",
+  "additions": 3,
+  "deletions": 201,
+  "changedFiles": 24,
+  "comments": {
+    "totalCount": 17,
+    "nodes": [
+      {
+        "body": "Fixes: #96 ",
+        "createdAt": "2019-11-18T15:57:21Z"
+      },
+      {
+        "body": "AzDO folks say the bug isn't fixed yet so you may get a torn state. The fix is currently in progress. it's probably not too risky to merge this, as most repos are getting this behavior already.",
+        "createdAt": "2019-11-18T16:44:44Z"
+      },
+      {
+        "body": "I am conflicted on whether we should take this or not. I think there is little benefit to moving back at the moment.",
+        "createdAt": "2019-11-18T16:56:09Z"
+      },
+      {
+        "body": "Mostly about cleanliness and potentially reducing overall PR times.  It means you've removed a dependency edge from the build graph.",
+        "createdAt": "2019-11-18T17:03:58Z"
+      },
+      {
+        "body": "> AzDO folks say the bug isn't fixed yet so you may get a torn state. The fix is currently in progress. it's probably not too risky to merge this, as most repos are getting this behavior already.\r\n\r\nThey've known about the issue with the checkout ref for a while - so I would keep the workaround with zipping/unzipping (or see another proposal below) until they have the fix ready. Otherwise, you will get strange failures in PRs when a test job fails because someone has commited a test to the repo in the meantime (e.g. that reproduces a jit assertion)\r\n\r\n> Mostly about cleanliness and potentially reducing overall PR times. It means you've removed a dependency edge from the build graph.\r\n\r\nHow about if I port my changes in https://github.com/dotnet/coreclr/pull/27867 to runtimes - so we can gen twice less dependency edges - and have only one checkout job that works for both Windows and non-Windows scenarios",
+        "createdAt": "2019-11-18T19:11:09Z"
+      },
+      {
+        "body": "Do you have perf numbers how long uploading and downloading (from AzDO) of the compressed repository takes?",
+        "createdAt": "2019-11-18T19:12:46Z"
+      },
+      {
+        "body": "> Do you have perf numbers how long uploading and downloading (from AzDO) of the compressed repository takes?\r\n\r\nI have only one measurement https://dev.azure.com/dnceng/public/_build/results?buildId=427792 with git bundles (which is obviously not enough):\r\n* cloning from GitHub took 1m22s (on macOS agent)\r\n* creation of the bundle took 6s\r\n* upload took 13s \r\n* download steps took from 6-11s (depending on the agent)\r\n* cloning repo from the bundle takes from 7s (on macOS agent) up to 1m40s (on NetCorePublic-Pool agent)\r\n\r\n",
+        "createdAt": "2019-11-18T19:22:19Z"
+      },
+      {
+        "body": "> The fix is currently in progress\r\n\r\n@mmitche do you have the internal link to the tracking issue?",
+        "createdAt": "2019-11-18T19:25:20Z"
+      },
+      {
+        "body": "There is one more approach we can take:\r\n\r\n* Checkout directly from GitHub during build job - this way we remove common dependency edge [Build] -> [Checkout]\r\n* Then create a git bundle based on the commit fetched in a build job and publish the bundle as artifact\r\n* Download the bundle during test job instead of cloning from GitHub\r\n\r\nThis way we can remove a common dependency **and** make sure that the tests are built based on the same commit that product was built on.",
+        "createdAt": "2019-11-18T19:26:31Z"
+      },
+      {
+        "body": "> The fix is currently in progress\r\n> \r\n> @mmitche do you have the internal link to the tracking issue?\r\n\r\nWe reported this issue to the AzDO team with help from @chcosta. Chris do you happen to know the tracking issue?",
+        "createdAt": "2019-11-18T19:29:55Z"
+      },
+      {
+        "body": "https://dev.azure.com/mseng/AzureDevOps/_workitems/edit/1529338",
+        "createdAt": "2019-11-18T19:31:10Z"
+      },
+      {
+        "body": "We're tracking with https://dev.azure.com/dnceng/internal/_queries/edit/152 which links to [AzDo's work item](https://mseng.visualstudio.com/AzureDevOps/_workitems/edit/1529338)",
+        "createdAt": "2019-11-18T19:32:23Z"
+      },
+      {
+        "body": "As concerns perf, I usually saw GIT checkout take about 30~60 seconds on both Linux and Windows; downloading and unzipping of the zipped repo takes about 40 seconds on Linux / Mac and about 60 seconds on Windows. For now I would assume Egor's change to be the easiest to take as he already has it working and it maintains commit stability (in fact it even improves it by removing a potential difference between the Windows and Linux checkout).",
+        "createdAt": "2019-11-18T20:28:12Z"
+      },
+      {
+        "body": "> As concerns perf, I usually saw GIT checkout take about 30~60 seconds on both Linux and Windows; downloading and unzipping of the zipped repo takes about 40 seconds on Linux / Mac and about 60 seconds on Windows. For now I would assume Egor's change to be the easiest to take as he already has it working and it maintains commit stability (in fact it even improves it by removing a potential difference between the Windows and Linux checkout).\r\n\r\nThe downside is that you have the setup + teardown and queuing of another leg we can be signfiicant (e.g. parallelism).  Anyway, I think we should fix this once AzDO confirms they have the fix for the checkout sha in place.",
+        "createdAt": "2019-11-18T21:08:34Z"
+      },
+      {
+        "body": "I agree with @mmitche here but I would just keep the PR open until this is fixed on the AzDO side. I'm following the tracking issue and will comment here as soon as the fix landed.",
+        "createdAt": "2019-11-19T10:42:43Z"
+      },
+      {
+        "body": "@trylek let's close this until we have the fix on AzDO ready. This will probably take 4-6 weeks.",
+        "createdAt": "2019-11-27T11:35:11Z"
+      },
+      {
+        "body": "The AzDO change is now implemented but probably will take a few weeks till being rolled out. I will keep you updated.",
+        "createdAt": "2019-12-05T16:17:58Z"
+      }
+    ]
+  },
+  "reviewThreads": {
+    "totalCount": 1,
+    "nodes": [
+      {
+        "comments": {
+          "nodes": [
+            {
+              "path": "eng/pipelines/coreclr/templates/xplat-job.yml",
+              "diffHunk": "@@ -164,20 +155,8 @@ jobs:\n       - ${{insert}}: ${{ variable }}\n \n     steps:\n-    - checkout: none\n+    - checkout: self",
+              "body": "Do you actually need the checkout step here? Except the clean eq true, this is the default. We don't clean in the Libraries ones so I don't think that's necessary.",
+              "createdAt": "2019-11-18T16:43:42Z"
+            },
+            {
+              "path": "eng/pipelines/coreclr/templates/xplat-job.yml",
+              "diffHunk": "@@ -164,20 +155,8 @@ jobs:\n       - ${{insert}}: ${{ variable }}\n \n     steps:\n-    - checkout: none\n+    - checkout: self",
+              "body": "Just saw that you are also specifying the fetchDepth here. Then it makes sense to keep it here.",
+              "createdAt": "2019-11-18T16:44:15Z"
+            },
+            {
+              "path": "eng/pipelines/coreclr/templates/xplat-job.yml",
+              "diffHunk": "@@ -164,20 +155,8 @@ jobs:\n       - ${{insert}}: ${{ variable }}\n \n     steps:\n-    - checkout: none\n+    - checkout: self",
+              "body": "Still my question would be, do we need cleaning enabled?",
+              "createdAt": "2019-11-18T16:45:38Z"
+            }
+          ]
+        }
+      }
+    ]
+  },
+  "commits": {
+    "totalCount": 1,
+    "nodes": [
+      {
+        "commit": {
+          "oid": "23ae599fe2f44f9be3d24e0223240d25c21ee3a4",
+          "message": "Remove repo zipping / unzipping\n\nAs according to Matt Mitchell performance issues related to\nrepeated git checkouts (throttling) have been fixed and Azure\npipelines should automatically make sure that all jobs check out\nthe same GIT commit, I am removing the previous workaround to\nzip the Windows & Linux checkout as an initial step in each\npipeline and unzip it in subsequent jobs instead of repeating\nthe git checkout.\n\nThanks\n\nTomas",
+          "committedDate": "2019-11-18T15:53:55Z"
+        }
+      }
+    ]
+  }
+}

data/raw_sample/prs/pr-100000.json

@@ -0,0 +1,110 @@
+{
+  "number": 100000,
+  "title": "Trim unused interfaces",
+  "body": "So far, the compiler could only trim unused interface __methods__; the interface __types__ themselves were left alone. There is not a huge cost associated with having these extra `MethodTable`s, but it sill impacts size/working set/startup. Initial estimate showed this could actually be up to 2% for BasicMinimalApi so I decided to investigate a fix.\r\n\r\nThis is an attempt to start trimming them. I chose a relatively conservative approach:\r\n\r\n* Stop unconditionally rooting the interface `MethodTable` in the implementing class `MethodTable` InterfaceList. Instead check whether someone else marked it first.\r\n* Track whether an interface type definition is used in any way. This avoids problem with variance, etc. If an interface definition is used, all instantiations that we were trying to optimize away get the `MethodTable` and won't be optimized. We should be able to do better than this, maybe, at some point.\r\n* Classes that implement generic interfaces with default methods need special treatment because we index into interface list at runtime and we might not know the correct index yet. So just forget the optimization in that case.\r\n\r\nFixes #66716.",
+  "createdAt": "2024-03-20T08:55:34Z",
+  "closedAt": "2024-03-23T22:28:34Z",
+  "mergedAt": "2024-03-23T22:28:34Z",
+  "state": "MERGED",
+  "author": {
+    "login": "MichalStrehovsky"
+  },
+  "labels": {
+    "nodes": [
+      {
+        "name": "area-NativeAOT-coreclr"
+      }
+    ]
+  },
+  "headRefName": "intfstrip",
+  "additions": 224,
+  "deletions": 57,
+  "changedFiles": 21,
+  "comments": {
+    "totalCount": 13,
+    "nodes": [
+      {
+        "body": "I vaguely remember that some part of the iOS managed static registrar or the linker pipeline may depend on the current behavior. So, cc @ivanpovazan, @simonrozsival in case they do remember the details or have some general concerns.",
+        "createdAt": "2024-03-20T09:12:35Z"
+      },
+      {
+        "body": "@filipnavara If I understand this change correctly, I don't think this should break iOS. There are cases when we explicitly cast objects to an interface they implement and call a method on the interface. I think that falls under the second bullet point and in that case the optimization won't be applied.",
+        "createdAt": "2024-03-20T10:43:39Z"
+      },
+      {
+        "body": "> I think that falls under the second bullet point and in that case the optimization won't be applied.\r\n\r\nThanks for checking!\r\n",
+        "createdAt": "2024-03-20T10:48:50Z"
+      },
+      {
+        "body": "/azp run runtime-nativeaot-outerloop",
+        "createdAt": "2024-03-20T11:36:21Z"
+      },
+      {
+        "body": "<samp>\nAzure Pipelines successfully started running 1 pipeline(s).<br>\r\n\n</samp>",
+        "createdAt": "2024-03-20T11:36:34Z"
+      },
+      {
+        "body": "ID: 100000 🎉 ",
+        "createdAt": "2024-03-20T15:22:08Z"
+      },
+      {
+        "body": "So this won't be quite the promised 2% size saving on WebapiAot template because once I started to worry about generic interfaces and the suppressions that assume IL level trimming we have within the libraries, it became 0.7%.\r\n\r\nIn libraries, we have several places where we call `GetInterfaces()` without a properly annotated/statically known type and assume that if we grab the type definition of the interface we got from `GetInterfaces()` and compare with `typeof(OpenVersion<>)`, it's going to be reliable and trim safe way to detect if the type implemented say `OpenVersion<int>`. It's safe in IL sense. In AOT sense, we could have stripped `OpenVersion<int>` if it was never used and then this trim-unsafe piece of code won't find it. So we can't do it. Oh well.\r\n\r\nBut the good news is that `dotnet new console --aot` followed by `dotnet publish /p:OptimizationPreference=Size /p:StackTraceSupport=false /p:UseSystemResourceKeys=true` is now ***877 kB***.\r\n\r\n# Size statistics\r\n\r\nPull request dotnet/runtime#100000\r\n\r\n| Project | Size before | Size after | Difference |\r\n|---------|-------------|------------|------------|\r\n| avalonia.app-linux | [ 24681968 ](https://github.com/MichalStrehovsky/rt-sz/actions/runs/8371281835/artifacts/1345532638) | [ 24615120 ](https://github.com/MichalStrehovsky/rt-sz/actions/runs/8371281835/artifacts/1345532361) | -66848 |\r\n| avalonia.app-windows | [ 22321152 ](https://github.com/MichalStrehovsky/rt-sz/actions/runs/8371281835/artifacts/1345533992) | [ 22253568 ](https://github.com/MichalStrehovsky/rt-sz/actions/runs/8371281835/artifacts/1345534230) | -67584 |\r\n| hello-linux | [ 1316304 ](https://github.com/MichalStrehovsky/rt-sz/actions/runs/8371281835/artifacts/1345530706) | [ 1266592 ](https://github.com/MichalStrehovsky/rt-sz/actions/runs/8371281835/artifacts/1345530587) | -49712 |\r\n| hello-minimal-linux | [ 1172808 ](https://github.com/MichalStrehovsky/rt-sz/actions/runs/8371281835/artifacts/1345530970) | [ 1119000 ](https://github.com/MichalStrehovsky/rt-sz/actions/runs/8371281835/artifacts/1345530503) | -53808 |\r\n| hello-minimal-windows | [ 947200 ](https://github.com/MichalStrehovsky/rt-sz/actions/runs/8371281835/artifacts/1345531948) | [ 898560 ](https://github.com/MichalStrehovsky/rt-sz/actions/runs/8371281835/artifacts/1345532788) | -48640 |\r\n| hello-windows | [ 1200640 ](https://github.com/MichalStrehovsky/rt-sz/actions/runs/8371281835/artifacts/1345532280) | [ 1149952 ](https://github.com/MichalStrehovsky/rt-sz/actions/runs/8371281835/artifacts/1345532013) | -50688 |\r\n| webapiaot-linux | [ 10363808 ](https://github.com/MichalStrehovsky/rt-sz/actions/runs/8371281835/artifacts/1345531354) | [ 10301344 ](https://github.com/MichalStrehovsky/rt-sz/actions/runs/8371281835/artifacts/1345531459) | -62464 |\r\n| webapiaot-windows | [ 9438720 ](https://github.com/MichalStrehovsky/rt-sz/actions/runs/8371281835/artifacts/1345532871) | [ 9377280 ](https://github.com/MichalStrehovsky/rt-sz/actions/runs/8371281835/artifacts/1345532767) | -61440 |\r\n",
+        "createdAt": "2024-03-21T09:09:34Z"
+      },
+      {
+        "body": "@dotnet/ilc-contrib this is ready for review",
+        "createdAt": "2024-03-21T11:08:03Z"
+      },
+      {
+        "body": "/azp run runtime-nativeaot-outerloop",
+        "createdAt": "2024-03-21T11:24:25Z"
+      },
+      {
+        "body": "<samp>\nAzure Pipelines successfully started running 1 pipeline(s).<br>\r\n\n</samp>",
+        "createdAt": "2024-03-21T11:24:40Z"
+      },
+      {
+        "body": "Hmm, the linux-arm failure is interesting but unrelated:\r\n\r\n```\r\n(lldb) bt\r\nThis version of LLDB has no plugin for the language \"assembler\". Inspection of frame variables will be limited.\r\n* thread #1, name = 'Microsoft.Exten', stop reason = signal SIGSEGV\r\n  * frame #0: 0x00eab31e Microsoft.Extensions.Logging.Console.Tests`RhpCheckedAssignRefr1 at WriteBarriers.S:251\r\n    frame #1: 0x011ec304 Microsoft.Extensions.Logging.Console.Tests`System.Runtime.TypeCast___cctor at TypeCast.cs:36\r\n    frame #2: 0x0121c2b8 Microsoft.Extensions.Logging.Console.Tests`Internal.Runtime.CompilerHelpers.StartupCodeHelpers__RunInitializers(typeManager=<unavailable>, section=<unavailable>) at StartupCodeHelpers.cs:181\r\n    frame #3: 0x0121be8e Microsoft.Extensions.Logging.Console.Tests`Internal.Runtime.CompilerHelpers.StartupCodeHelpers__InitializeModules(osModule=<unavailable>, pModuleHeaders=<unavailable>, count=<unavailable>, pClasslibFunctions=<unavailable>, nClasslibFunctions=<unavailable>) at StartupCodeHelpers.cs:53\r\n    frame #4: 0x00e6f4d4 Microsoft.Extensions.Logging.Console.Tests`main [inlined] InitializeRuntime() at main.cpp:203:5 [opt]\r\n    frame #5: 0x00e6f470 Microsoft.Extensions.Logging.Console.Tests`main(argc=9, argv=0xffca6804) at main.cpp:221:19 [opt]\r\n(lldb) dis -b -A thumbv7\r\nMicrosoft.Extensions.Logging.Console.Tests`RhpCheckedAssignRef:\r\n    0xeab2be <+0>:   0xf3bf8f5f   dmb    sy\r\n\r\nMicrosoft.Extensions.Logging.Console.Tests`RhpCheckedAssignRefr1:\r\n    0xeab2c2 <+4>:   0x6001       str    r1, [r0]\r\n    0xeab2c4 <+6>:   0xf2400c4c   movw   r12, #0x4c\r\n    0xeab2c8 <+10>:  0xf2c00ca0   movt   r12, #0xa0\r\n    0xeab2cc <+14>:  0x44fc       add    r12, pc\r\n    0xeab2ce <+16>:  0xf8dcc000   ldr.w  r12, [r12]\r\n    0xeab2d2 <+20>:  0x4560       cmp    r0, r12\r\n    0xeab2d4 <+22>:  0xd328       blo    0x89b328                  ; <+106>\r\n    0xeab2d6 <+24>:  0xf2400c3e   movw   r12, #0x3e\r\n    0xeab2da <+28>:  0xf2c00ca0   movt   r12, #0xa0\r\n    0xeab2de <+32>:  0x44fc       add    r12, pc\r\n    0xeab2e0 <+34>:  0xf8dcc000   ldr.w  r12, [r12]\r\n    0xeab2e4 <+38>:  0x4560       cmp    r0, r12\r\n    0xeab2e6 <+40>:  0xd21f       bhs    0x89b328                  ; <+106>\r\n    0xeab2e8 <+42>:  0xf6470ca0   movw   r12, #0x78a0\r\n    0xeab2ec <+46>:  0xf2c00c9e   movt   r12, #0x9e\r\n    0xeab2f0 <+50>:  0x44fc       add    r12, pc\r\n    0xeab2f2 <+52>:  0xf8dcc000   ldr.w  r12, [r12]\r\n    0xeab2f6 <+56>:  0x4561       cmp    r1, r12\r\n    0xeab2f8 <+58>:  0xd31b       blo    0x89b332                  ; <+116>\r\n    0xeab2fa <+60>:  0xf6470c92   movw   r12, #0x7892\r\n    0xeab2fe <+64>:  0xf2c00c9e   movt   r12, #0x9e\r\n    0xeab302 <+68>:  0x44fc       add    r12, pc\r\n    0xeab304 <+70>:  0xf8dcc000   ldr.w  r12, [r12]\r\n    0xeab308 <+74>:  0x4561       cmp    r1, r12\r\n    0xeab30a <+76>:  0xd212       bhs    0x89b332                  ; <+116>\r\n    0xeab30c <+78>:  0xf2400c00   movw   r12, #0x0\r\n    0xeab310 <+82>:  0xf2c00c9f   movt   r12, #0x9f\r\n    0xeab314 <+86>:  0x44fc       add    r12, pc\r\n    0xeab316 <+88>:  0xf8dcc000   ldr.w  r12, [r12]\r\n    0xeab31a <+92>:  0xeb0c2090   add.w  r0, r12, r0, lsr #10\r\n->  0xeab31e <+96>:  0xf890c000   ldrb.w r12, [r0]\r\n    0xeab322 <+100>: 0xf1bc0fff   cmp.w  r12, #0xff\r\n    0xeab326 <+104>: 0xd100       bne    0x89b32a                  ; <+108>\r\n    0xeab328 <+106>: 0xe003       b      0x89b332                  ; <+116>\r\n    0xeab32a <+108>: 0xf04f0cff   mov.w  r12, #0xff\r\n    0xeab32e <+112>: 0xf880c000   strb.w r12, [r0]\r\n    0xeab332 <+116>: 0x4770       bx     lr\r\n(lldb)\r\n```\r\n\r\nCc @filipnavara \r\n\r\nRunfo:\r\n\r\n```\r\nrunfo get-helix-payload -j 320338f9-9d8c-4deb-9eeb-884cfb26892e -w Microsoft.Extensions.Logging.Console.Tests -o c:\\helix_payload\\Microsoft.Extensions.Logging.Console.Tests\r\n```",
+        "createdAt": "2024-03-21T17:24:13Z"
+      },
+      {
+        "body": "I'll wait with merging this until after #98712. I don't want to mask off how much of a regression that PR is.",
+        "createdAt": "2024-03-21T17:26:19Z"
+      },
+      {
+        "body": "> the linux-arm failure is interesting\r\n\r\nOpened https://github.com/dotnet/runtime/issues/100112",
+        "createdAt": "2024-03-22T01:50:53Z"
+      }
+    ]
+  },
+  "reviewThreads": {
+    "totalCount": 0,
+    "nodes": []
+  },
+  "commits": {
+    "totalCount": 3,
+    "nodes": [
+      {
+        "commit": {
+          "oid": "13e62212b9b6de6ff0b198207fcbe5531bf6b442",
+          "message": "Trim unused interfaces\n\nSo far, the compiler could only trim unused interface __methods__; the interface __types__ themselves were left alone. There is not a huge cost associated with having these extra `MethodTable`s, but it sill impacts size/working set/startup. Initial estimate showed this could actually be up to 2% for BasicMinimalApi so I decided to investigate a fix.\n\nThis is an attempt to start trimming them. I chose a relatively conservative approach:\n\n* Stop unconditionally rooting the interface `MethodTable` in the implementing class `MethodTable` InterfaceList. Instead check whether someone else marked it first.\n* Track whether an interface type definition is used in any way. This avoids problem with variance, etc. If an interface definition is used, all instantiations that we were trying to optimize away get the `MethodTable` and won't be optimized. We should be able to do better than this, maybe, at some point.\n* Classes that implement generic interfaces with default methods need special treatment because we index into interface list at runtime and we might not know the correct index yet. So just forget the optimization in that case.\n\nFixes #66716.",
+          "committedDate": "2024-03-20T08:49:22Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "008f01ec8042cfa23abe4dff91bc07cde848b0c6",
+          "message": "Also remove from reflection metadata",
+          "committedDate": "2024-03-21T06:52:52Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "7a4a308fa7351ff447cffc1f465af4db98d0e411",
+          "message": "Fix tests",
+          "committedDate": "2024-03-21T11:07:28Z"
+        }
+      }
+    ]
+  }
+}

data/raw_sample/prs/pr-100001.json

@@ -0,0 +1,214 @@
+{
+  "number": 100001,
+  "title": "Support setting NamedPipeClientStream.ReadMode with PipeAccessRights ctor overload",
+  "body": "Fixes #83072 ([Cannot set ReadMode after creating a NamedPipeClientStream instance](https://github.com/dotnet/runtime/issues/83072)).\r\n\r\nPer the [API Review notes and video](https://github.com/dotnet/runtime/issues/83072#issuecomment-1942189738):\r\n\r\n1. Add the missing constructor to `NamedPipeClientStream` that accepts `PipeAccessRights`\r\n2. Promote `PipeAccessRights` from System.IO.Pipes.AccessRights to System.IO.Pipes, and add the necessary type-forward\r\n3. Mark the constructor as being only supported on Windows, but leave the enum available on all platforms\r\n4. Review for nullability annotations -- no arguments allow null\r\n\r\nThe .NET Framework implementation was referenced from [Pipe.cs](https://referencesource.microsoft.com/#System.Core/System/IO/Pipes/Pipe.cs,a71f90682fcb0da9), but the behavior was improved slightly.\r\n\r\n* Argument validation logic is reused rather than being duplicated into the new constructor\r\n* The `direction` argument is given a valid value when the `desiredAccessRights` value is invalid, ensuring that the correct `desiredAccessRights` argument exception is thrown\r\n    * In netfx, any `desiredAccessRights` value missing both the `ReadData` (1) and `WriteData` (2) bits would throw an argument exception for `direction`, which is not an argument to the constructor\r\n* Argument validation for `desiredAccessRights` also throws for a `0` value, which netfx didn't do\r\n\r\nThe functionality was tested using the following server / client apps:\r\n\r\n**server.cs**\r\n```c#\r\nusing System.IO.Pipes;\r\n\r\nvar pipeOut = new NamedPipeServerStream(\"SomeNamedPipe\",\r\n                                        PipeDirection.Out,\r\n                                        1,\r\n                                        PipeTransmissionMode.Message);\r\n\r\nConsole.WriteLine(\"Waiting for a connection...\");\r\npipeOut.WaitForConnection();\r\n\r\nConsole.WriteLine(\"Connected. Sending messages...\");\r\n\r\nwhile (true) {\r\n    pipeOut.Write(\"Hello \"u8);\r\n    pipeOut.Write(\"from \"u8);\r\n    pipeOut.Write(\"the \"u8);\r\n    pipeOut.Write(\"server!\"u8);\r\n\r\n    Console.WriteLine(\"Messages sent. Sleeping for 10 seconds.\");\r\n    System.Threading.Thread.Sleep(10_000);\r\n}\r\n```\r\n\r\n**client.cs**\r\n```c#\r\nusing System.IO.Pipes;\r\n\r\nvar pipeIn = new NamedPipeClientStream(\".\",\r\n                             \"SomeNamedPipe\",\r\n                             PipeAccessRights.ReadData | PipeAccessRights.WriteAttributes,\r\n                             PipeOptions.None,\r\n                             System.Security.Principal.TokenImpersonationLevel.None,\r\n                             System.IO.HandleInheritability.None);\r\n\r\npipeIn.Connect();\r\npipeIn.ReadMode = PipeTransmissionMode.Message;\r\n\r\nwhile (pipeIn.IsConnected)\r\n{\r\n    var buffer = new byte[2];\r\n    var bytesRead = pipeIn.Read(buffer, 0, buffer.Length);\r\n\r\n    if (bytesRead > 0) {\r\n        var message = System.Text.Encoding.UTF8.GetString(buffer, 0, bytesRead);\r\n        Console.Write(message);\r\n\r\n        System.Threading.Thread.Sleep(1000);\r\n\r\n        if (pipeIn.IsMessageComplete) {\r\n            Console.WriteLine();\r\n        }\r\n    }\r\n}\r\n```\r\n\r\nWith this PR, that application works as expected, with the client detecting completed messages after each word and rendering newlines.\r\n",
+  "createdAt": "2024-03-20T09:10:25Z",
+  "closedAt": "2024-03-27T15:02:32Z",
+  "mergedAt": "2024-03-27T15:02:32Z",
+  "state": "MERGED",
+  "author": {
+    "login": "jeffhandley"
+  },
+  "labels": {
+    "nodes": [
+      {
+        "name": "area-System.IO"
+      },
+      {
+        "name": "new-api-needs-documentation"
+      }
+    ]
+  },
+  "headRefName": "jeffhandley/namedpipe-readmode",
+  "additions": 334,
+  "deletions": 58,
+  "changedFiles": 15,
+  "comments": {
+    "totalCount": 1,
+    "nodes": [
+      {
+        "body": "Note regarding the `new-api-needs-documentation` label:\r\n\r\n    This serves as a reminder for when your PR is modifying a ref *.cs file and adding/modifying public APIs, please make sure the API implementation in the src *.cs file is documented with triple slash comments, so the PR reviewers can sign off that change.",
+        "createdAt": "2024-03-20T09:10:30Z"
+      }
+    ]
+  },
+  "reviewThreads": {
+    "totalCount": 7,
+    "nodes": [
+      {
+        "comments": {
+          "nodes": [
+            {
+              "path": "src/libraries/System.IO.Pipes/src/System/IO/Pipes/NamedPipeClientStream.Windows.cs",
+              "diffHunk": "@@ -16,6 +17,78 @@ namespace System.IO.Pipes\n     /// </summary>\n     public sealed partial class NamedPipeClientStream : PipeStream\n     {\n+        /// <summary>\n+        /// Initializes a new instance of the <see cref=\"NamedPipeClientStream\"/> class with the specified pipe and server names,\n+        /// the desired <see cref=\"PipeAccessRights\"/>, and the specified impersonation level and inheritability.\n+        /// </summary>\n+        /// <param name=\"serverName\">The name of the remote computer to connect to, or \".\" to specify the local computer.</param>\n+        /// <param name=\"pipeName\">The name of the pipe.</param>\n+        /// <param name=\"desiredAccessRights\">One of the enumeration values that specifies the desired access rights of the pipe.</param>\n+        /// <param name=\"options\">One of the enumeration values that determines how to open or create the pipe.</param>\n+        /// <param name=\"impersonationLevel\">One of the enumeration values that determines the security impersonation level.</param>\n+        /// <param name=\"inheritability\">One of the enumeration values that determines whether the underlying handle will be inheritable by child processes.</param>\n+        /// <exception cref=\"ArgumentNullException\"><paramref name=\"pipeName\"/> or <paramref name=\"serverName\"/> is <c>null</c>.</exception>\n+        /// <exception cref=\"ArgumentException\"><paramref name=\"pipeName\"/> or <paramref name=\"serverName\"/> is a zero-length string.</exception>\n+        /// <exception cref=\"ArgumentOutOfRangeException\"><paramref name=\"pipeName\"/> is set to \"anonymous\".</exception>\n+        /// <exception cref=\"ArgumentOutOfRangeException\"><paramref name=\"desiredAccessRights\"/> is not a valid <see cref=\"PipeAccessRights\"/> value.</exception>\n+        /// <exception cref=\"ArgumentOutOfRangeException\"><paramref name=\"options\"/> is not a valid <see cref=\"PipeOptions\"/> value.</exception>\n+        /// <exception cref=\"ArgumentOutOfRangeException\"><paramref name=\"impersonationLevel\"/> is not a valid <see cref=\"TokenImpersonationLevel\"/> value.</exception>\n+        /// <exception cref=\"ArgumentOutOfRangeException\"><paramref name=\"inheritability\"/> is not a valid <see cref=\"HandleInheritability\"/> value.</exception>\n+        /// <remarks>\n+        /// The pipe direction for this constructor is determined by the <paramref name=\"desiredAccessRights\"/> parameter.\n+        /// If the <paramref name=\"desiredAccessRights\"/> parameter specifies <see cref=\"PipeAccessRights.ReadData\"/>,\n+        /// the pipe direction is <see cref=\"PipeDirection.In\"/>. If the <paramref name=\"desiredAccessRights\"/> parameter\n+        /// specifies <see cref=\"PipeAccessRights.WriteData\"/>, the pipe direction is <see cref=\"PipeDirection.Out\"/>.\n+        /// If the value of <paramref name=\"desiredAccessRights\"/> specifies both <see cref=\"PipeAccessRights.ReadData\"/>\n+        /// and <see cref=\"PipeAccessRights.WriteData\"/>, the pipe direction is <see cref=\"PipeDirection.InOut\"/>.\n+        /// </remarks>\n+        [System.Runtime.Versioning.SupportedOSPlatform(\"windows\")]\n+        public NamedPipeClientStream(string serverName, string pipeName, PipeAccessRights desiredAccessRights,",
+              "body": "Are there any tests for this new ctor other than failure cases?",
+              "createdAt": "2024-03-20T14:15:02Z"
+            }
+          ]
+        }
+      },
+      {
+        "comments": {
+          "nodes": [
+            {
+              "path": "src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.CreateClient.cs",
+              "diffHunk": "@@ -17,13 +17,15 @@ public static void NullPipeName_Throws_ArgumentNullException()\n         {\n             AssertExtensions.Throws<ArgumentNullException>(\"pipeName\", () => new NamedPipeClientStream(null));\n             AssertExtensions.Throws<ArgumentNullException>(\"pipeName\", () => new NamedPipeClientStream(\".\", null));\n+            AssertExtensions.Throws<ArgumentNullException>(\"pipeName\", () => new NamedPipeClientStream(\".\", null, PipeAccessRights.FullControl, PipeOptions.None, TokenImpersonationLevel.None, HandleInheritability.None));",
+              "body": "Do these tests run on Unix? I'd expect such use would result in a PlatformNotSupportedException being thrown, since the Unix impl is hardcoded to always do that and not do any arg validation.",
+              "createdAt": "2024-03-20T14:18:55Z"
+            },
+            {
+              "path": "src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.CreateClient.cs",
+              "diffHunk": "@@ -17,13 +17,15 @@ public static void NullPipeName_Throws_ArgumentNullException()\n         {\n             AssertExtensions.Throws<ArgumentNullException>(\"pipeName\", () => new NamedPipeClientStream(null));\n             AssertExtensions.Throws<ArgumentNullException>(\"pipeName\", () => new NamedPipeClientStream(\".\", null));\n+            AssertExtensions.Throws<ArgumentNullException>(\"pipeName\", () => new NamedPipeClientStream(\".\", null, PipeAccessRights.FullControl, PipeOptions.None, TokenImpersonationLevel.None, HandleInheritability.None));",
+              "body": "Thanks for catching that. I broke these out into separate platform-specific tests.",
+              "createdAt": "2024-03-22T01:10:32Z"
+            }
+          ]
+        }
+      },
+      {
+        "comments": {
+          "nodes": [
+            {
+              "path": "src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.CreateClient.cs",
+              "diffHunk": "@@ -17,6 +17,12 @@ public static void NullPipeName_Throws_ArgumentNullException()\n         {\n             AssertExtensions.Throws<ArgumentNullException>(\"pipeName\", () => new NamedPipeClientStream(null));\n             AssertExtensions.Throws<ArgumentNullException>(\"pipeName\", () => new NamedPipeClientStream(\".\", null));\n+        }\n+\n+        [Fact]\n+        [PlatformSpecific(TestPlatforms.Windows)]",
+              "body": "Since AccessRights are specific to Windows, could you please move the PlatformSpecific tests to a separate file? It could be named NamedPipeTest.CreateClient.Windows.cs and can be placed in the same csproj ItemGroup as the other Windows-specific tests.",
+              "createdAt": "2024-03-23T00:04:01Z"
+            },
+            {
+              "path": "src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.CreateClient.cs",
+              "diffHunk": "@@ -17,6 +17,12 @@ public static void NullPipeName_Throws_ArgumentNullException()\n         {\n             AssertExtensions.Throws<ArgumentNullException>(\"pipeName\", () => new NamedPipeClientStream(null));\n             AssertExtensions.Throws<ArgumentNullException>(\"pipeName\", () => new NamedPipeClientStream(\".\", null));\n+        }\n+\n+        [Fact]\n+        [PlatformSpecific(TestPlatforms.Windows)]",
+              "body": "I was torn on this and saw trade-offs in either direction (separate file for improved cleanliness, or same file for improved discoverability). But as you call out, there is already a heavy usage of platform-specific files, so I'll make the change.",
+              "createdAt": "2024-03-26T04:26:42Z"
+            }
+          ]
+        }
+      },
+      {
+        "comments": {
+          "nodes": [
+            {
+              "path": "src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.MessageMode.Windows.cs",
+              "diffHunk": "@@ -0,0 +1,106 @@\n+// Licensed to the .NET Foundation under one or more agreements.\n+// The .NET Foundation licenses this file to you under the MIT license.\n+\n+using System.Collections.Generic;\n+using System.IO.Tests;\n+using System.Linq;\n+using System.Runtime.InteropServices;\n+using System.Threading;\n+using System.Threading.Tasks;\n+using Xunit;\n+\n+namespace System.IO.Pipes.Tests\n+{\n+    // Support for PipeAccessRights and setting ReadMode to Message is only supported on Windows\n+    public class NamedPipeTest_MessageMode_Windows\n+    {\n+        private const PipeAccessRights MinimumMessageAccessRights = PipeAccessRights.ReadData | PipeAccessRights.WriteAttributes;\n+\n+        private static NamedPipeClientStream CreateClientStream(string pipeName, PipeOptions options) =>\n+            new NamedPipeClientStream(\".\", pipeName, MinimumMessageAccessRights, options, Security.Principal.TokenImpersonationLevel.None, HandleInheritability.None);\n+\n+        [Theory]\n+        [InlineData(PipeDirection.Out, PipeOptions.None)]\n+        [InlineData(PipeDirection.InOut, PipeOptions.Asynchronous)]\n+        public async Task Client_DetectsMessageCompleted(PipeDirection serverDirection, PipeOptions options)\n+        {\n+            string pipeName = PipeStreamConformanceTests.GetUniquePipeName();\n+\n+            using NamedPipeServerStream server = new NamedPipeServerStream(pipeName, serverDirection, 1, PipeTransmissionMode.Message, options);\n+            using NamedPipeClientStream client = CreateClientStream(pipeName, options);\n+\n+            Task.WaitAll(server.WaitForConnectionAsync(), client.ConnectAsync());\n+            client.ReadMode = PipeTransmissionMode.Message;\n+\n+            ValueTask serverWrite = server.WriteAsync(new byte[] { 1, 2, 3, 4, 5 });",
+              "body": "Is there a reason why the `ValueTask` is being created here if it's not being awaited? I'm failing to see if such early/non-awaited call is relevant to the new constructor.",
+              "createdAt": "2024-03-23T00:10:23Z"
+            },
+            {
+              "path": "src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.MessageMode.Windows.cs",
+              "diffHunk": "@@ -0,0 +1,106 @@\n+// Licensed to the .NET Foundation under one or more agreements.\n+// The .NET Foundation licenses this file to you under the MIT license.\n+\n+using System.Collections.Generic;\n+using System.IO.Tests;\n+using System.Linq;\n+using System.Runtime.InteropServices;\n+using System.Threading;\n+using System.Threading.Tasks;\n+using Xunit;\n+\n+namespace System.IO.Pipes.Tests\n+{\n+    // Support for PipeAccessRights and setting ReadMode to Message is only supported on Windows\n+    public class NamedPipeTest_MessageMode_Windows\n+    {\n+        private const PipeAccessRights MinimumMessageAccessRights = PipeAccessRights.ReadData | PipeAccessRights.WriteAttributes;\n+\n+        private static NamedPipeClientStream CreateClientStream(string pipeName, PipeOptions options) =>\n+            new NamedPipeClientStream(\".\", pipeName, MinimumMessageAccessRights, options, Security.Principal.TokenImpersonationLevel.None, HandleInheritability.None);\n+\n+        [Theory]\n+        [InlineData(PipeDirection.Out, PipeOptions.None)]\n+        [InlineData(PipeDirection.InOut, PipeOptions.Asynchronous)]\n+        public async Task Client_DetectsMessageCompleted(PipeDirection serverDirection, PipeOptions options)\n+        {\n+            string pipeName = PipeStreamConformanceTests.GetUniquePipeName();\n+\n+            using NamedPipeServerStream server = new NamedPipeServerStream(pipeName, serverDirection, 1, PipeTransmissionMode.Message, options);\n+            using NamedPipeClientStream client = CreateClientStream(pipeName, options);\n+\n+            Task.WaitAll(server.WaitForConnectionAsync(), client.ConnectAsync());\n+            client.ReadMode = PipeTransmissionMode.Message;\n+\n+            ValueTask serverWrite = server.WriteAsync(new byte[] { 1, 2, 3, 4, 5 });",
+              "body": "It is awaited before existing the test. I need to call the non-blocking `WriteAsync` so that the test can proceed and the client can start consuming the data; otherwise, `Write` blocks while waiting for a client to consume the data.\r\n\r\nI could probably get away with discarding the `ValueTask`, but it seemed cleaner to capture it and await it before letting the test finish.",
+              "createdAt": "2024-03-26T05:01:25Z"
+            }
+          ]
+        }
+      },
+      {
+        "comments": {
+          "nodes": [
+            {
+              "path": "src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.MessageMode.Windows.cs",
+              "diffHunk": "@@ -0,0 +1,106 @@\n+// Licensed to the .NET Foundation under one or more agreements.\n+// The .NET Foundation licenses this file to you under the MIT license.\n+\n+using System.Collections.Generic;\n+using System.IO.Tests;\n+using System.Linq;\n+using System.Runtime.InteropServices;\n+using System.Threading;\n+using System.Threading.Tasks;\n+using Xunit;\n+\n+namespace System.IO.Pipes.Tests\n+{\n+    // Support for PipeAccessRights and setting ReadMode to Message is only supported on Windows\n+    public class NamedPipeTest_MessageMode_Windows\n+    {\n+        private const PipeAccessRights MinimumMessageAccessRights = PipeAccessRights.ReadData | PipeAccessRights.WriteAttributes;\n+\n+        private static NamedPipeClientStream CreateClientStream(string pipeName, PipeOptions options) =>\n+            new NamedPipeClientStream(\".\", pipeName, MinimumMessageAccessRights, options, Security.Principal.TokenImpersonationLevel.None, HandleInheritability.None);\n+\n+        [Theory]\n+        [InlineData(PipeDirection.Out, PipeOptions.None)]\n+        [InlineData(PipeDirection.InOut, PipeOptions.Asynchronous)]\n+        public async Task Client_DetectsMessageCompleted(PipeDirection serverDirection, PipeOptions options)\n+        {\n+            string pipeName = PipeStreamConformanceTests.GetUniquePipeName();\n+\n+            using NamedPipeServerStream server = new NamedPipeServerStream(pipeName, serverDirection, 1, PipeTransmissionMode.Message, options);\n+            using NamedPipeClientStream client = CreateClientStream(pipeName, options);\n+\n+            Task.WaitAll(server.WaitForConnectionAsync(), client.ConnectAsync());\n+            client.ReadMode = PipeTransmissionMode.Message;\n+\n+            ValueTask serverWrite = server.WriteAsync(new byte[] { 1, 2, 3, 4, 5 });\n+\n+            byte[] buffer1 = new byte[2], buffer2 = new byte[2], buffer3 = new byte[2];\n+            bool[] messageCompleted = new bool[3];\n+\n+            int bytesRead = client.Read(buffer1, 0, 2);\n+            messageCompleted[0] = client.IsMessageComplete;\n+\n+            bytesRead += client.Read(buffer2, 0, 2);\n+            messageCompleted[1] = client.IsMessageComplete;\n+\n+            bytesRead += client.Read(buffer3, 0, 2);\n+            messageCompleted[2] = client.IsMessageComplete;\n+\n+            Assert.Equal(5, bytesRead);\n+            Assert.Equal(new byte[] { 1, 2, 3, 4, 5, 0 }, buffer1.Concat(buffer2).Concat(buffer3));\n+            Assert.Equal(new bool[] { false, false, true }, messageCompleted);\n+\n+            await serverWrite;",
+              "body": "I would move line 35 to here, and return the `ValueTask` directly:\r\n\r\n```suggestion\r\n            return server.WriteAsync(new byte[] { 1, 2, 3, 4, 5 });\r\n```\r\n\r\nAnd since you have no more awaits in the method body, you can remove the `async` modified from the method. And I think you can also change the return type of the method to `ValueTask`.\r\n\r\n@stephentoub please yell at me if I'm giving a bad suggestion.",
+              "createdAt": "2024-03-23T00:11:18Z"
+            },
+            {
+              "path": "src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.MessageMode.Windows.cs",
+              "diffHunk": "@@ -0,0 +1,106 @@\n+// Licensed to the .NET Foundation under one or more agreements.\n+// The .NET Foundation licenses this file to you under the MIT license.\n+\n+using System.Collections.Generic;\n+using System.IO.Tests;\n+using System.Linq;\n+using System.Runtime.InteropServices;\n+using System.Threading;\n+using System.Threading.Tasks;\n+using Xunit;\n+\n+namespace System.IO.Pipes.Tests\n+{\n+    // Support for PipeAccessRights and setting ReadMode to Message is only supported on Windows\n+    public class NamedPipeTest_MessageMode_Windows\n+    {\n+        private const PipeAccessRights MinimumMessageAccessRights = PipeAccessRights.ReadData | PipeAccessRights.WriteAttributes;\n+\n+        private static NamedPipeClientStream CreateClientStream(string pipeName, PipeOptions options) =>\n+            new NamedPipeClientStream(\".\", pipeName, MinimumMessageAccessRights, options, Security.Principal.TokenImpersonationLevel.None, HandleInheritability.None);\n+\n+        [Theory]\n+        [InlineData(PipeDirection.Out, PipeOptions.None)]\n+        [InlineData(PipeDirection.InOut, PipeOptions.Asynchronous)]\n+        public async Task Client_DetectsMessageCompleted(PipeDirection serverDirection, PipeOptions options)\n+        {\n+            string pipeName = PipeStreamConformanceTests.GetUniquePipeName();\n+\n+            using NamedPipeServerStream server = new NamedPipeServerStream(pipeName, serverDirection, 1, PipeTransmissionMode.Message, options);\n+            using NamedPipeClientStream client = CreateClientStream(pipeName, options);\n+\n+            Task.WaitAll(server.WaitForConnectionAsync(), client.ConnectAsync());\n+            client.ReadMode = PipeTransmissionMode.Message;\n+\n+            ValueTask serverWrite = server.WriteAsync(new byte[] { 1, 2, 3, 4, 5 });\n+\n+            byte[] buffer1 = new byte[2], buffer2 = new byte[2], buffer3 = new byte[2];\n+            bool[] messageCompleted = new bool[3];\n+\n+            int bytesRead = client.Read(buffer1, 0, 2);\n+            messageCompleted[0] = client.IsMessageComplete;\n+\n+            bytesRead += client.Read(buffer2, 0, 2);\n+            messageCompleted[1] = client.IsMessageComplete;\n+\n+            bytesRead += client.Read(buffer3, 0, 2);\n+            messageCompleted[2] = client.IsMessageComplete;\n+\n+            Assert.Equal(5, bytesRead);\n+            Assert.Equal(new byte[] { 1, 2, 3, 4, 5, 0 }, buffer1.Concat(buffer2).Concat(buffer3));\n+            Assert.Equal(new bool[] { false, false, true }, messageCompleted);\n+\n+            await serverWrite;",
+              "body": "I'm not sure I follow the recommendation. The test is getting both the server and client running and connected, and then it fires off an async write from the server so that the test can proceed with the client consuming the written bytes (and make asserts based on the received data). Without the `WriteAsync`, the `client.Read` calls will block until data can be received.\r\n\r\n_XUnit test methods don't support `ValueTask` returns. Today I learned._",
+              "createdAt": "2024-03-26T05:10:16Z"
+            }
+          ]
+        }
+      },
+      {
+        "comments": {
+          "nodes": [
+            {
+              "path": "src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.MessageMode.Windows.cs",
+              "diffHunk": "@@ -0,0 +1,106 @@\n+// Licensed to the .NET Foundation under one or more agreements.\n+// The .NET Foundation licenses this file to you under the MIT license.\n+\n+using System.Collections.Generic;\n+using System.IO.Tests;\n+using System.Linq;\n+using System.Runtime.InteropServices;\n+using System.Threading;\n+using System.Threading.Tasks;\n+using Xunit;\n+\n+namespace System.IO.Pipes.Tests\n+{\n+    // Support for PipeAccessRights and setting ReadMode to Message is only supported on Windows\n+    public class NamedPipeTest_MessageMode_Windows\n+    {\n+        private const PipeAccessRights MinimumMessageAccessRights = PipeAccessRights.ReadData | PipeAccessRights.WriteAttributes;\n+\n+        private static NamedPipeClientStream CreateClientStream(string pipeName, PipeOptions options) =>\n+            new NamedPipeClientStream(\".\", pipeName, MinimumMessageAccessRights, options, Security.Principal.TokenImpersonationLevel.None, HandleInheritability.None);\n+\n+        [Theory]\n+        [InlineData(PipeDirection.Out, PipeOptions.None)]\n+        [InlineData(PipeDirection.InOut, PipeOptions.Asynchronous)]\n+        public async Task Client_DetectsMessageCompleted(PipeDirection serverDirection, PipeOptions options)\n+        {\n+            string pipeName = PipeStreamConformanceTests.GetUniquePipeName();\n+\n+            using NamedPipeServerStream server = new NamedPipeServerStream(pipeName, serverDirection, 1, PipeTransmissionMode.Message, options);\n+            using NamedPipeClientStream client = CreateClientStream(pipeName, options);\n+\n+            Task.WaitAll(server.WaitForConnectionAsync(), client.ConnectAsync());\n+            client.ReadMode = PipeTransmissionMode.Message;\n+\n+            ValueTask serverWrite = server.WriteAsync(new byte[] { 1, 2, 3, 4, 5 });\n+\n+            byte[] buffer1 = new byte[2], buffer2 = new byte[2], buffer3 = new byte[2];\n+            bool[] messageCompleted = new bool[3];\n+\n+            int bytesRead = client.Read(buffer1, 0, 2);\n+            messageCompleted[0] = client.IsMessageComplete;\n+\n+            bytesRead += client.Read(buffer2, 0, 2);\n+            messageCompleted[1] = client.IsMessageComplete;\n+\n+            bytesRead += client.Read(buffer3, 0, 2);\n+            messageCompleted[2] = client.IsMessageComplete;\n+\n+            Assert.Equal(5, bytesRead);\n+            Assert.Equal(new byte[] { 1, 2, 3, 4, 5, 0 }, buffer1.Concat(buffer2).Concat(buffer3));\n+            Assert.Equal(new bool[] { false, false, true }, messageCompleted);\n+\n+            await serverWrite;\n+        }\n+\n+        [Theory]\n+        [InlineData(PipeTransmissionMode.Byte, PipeOptions.None)]\n+        [InlineData(PipeTransmissionMode.Message, PipeOptions.None)]\n+        [InlineData(PipeTransmissionMode.Byte, PipeOptions.Asynchronous)]\n+        [InlineData(PipeTransmissionMode.Message, PipeOptions.Asynchronous)]\n+        public void ServerIn_ClientConnect_Throws(PipeTransmissionMode serverMode, PipeOptions options)\n+        {\n+            string pipeName = PipeStreamConformanceTests.GetUniquePipeName();\n+\n+            using NamedPipeServerStream server = new NamedPipeServerStream(pipeName, PipeDirection.In, 1, serverMode, options);\n+            using NamedPipeClientStream client = CreateClientStream(pipeName, options);\n+\n+            Assert.Throws<UnauthorizedAccessException>(() => client.Connect());\n+        }\n+\n+        [Theory]\n+        [InlineData(PipeDirection.Out, PipeTransmissionMode.Byte, PipeOptions.None)]\n+        [InlineData(PipeDirection.Out, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)]\n+        [InlineData(PipeDirection.InOut, PipeTransmissionMode.Byte, PipeOptions.None)]\n+        [InlineData(PipeDirection.InOut, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)]\n+        public async Task ServerByteMode_ClientReadModeMessage_Throws(PipeDirection serverDirection, PipeTransmissionMode serverMode, PipeOptions options)\n+        {\n+            string pipeName = PipeStreamConformanceTests.GetUniquePipeName();\n+\n+            using NamedPipeServerStream server = new NamedPipeServerStream(pipeName, serverDirection, 1, serverMode, options);\n+            using NamedPipeClientStream client = CreateClientStream(pipeName, options);\n+\n+            Task serverConnected = server.WaitForConnectionAsync();\n+            client.Connect();\n+            await serverConnected;",
+              "body": "Similar question here. I think the `WaitForConnectionAsync` method invocation has to be awaited here, not in line 85.\r\n\r\nAdditionally, if the server async methods are being called, I would also call the client async methods. In line 84, I would call `await client.ConnectAsync();`\r\n",
+              "createdAt": "2024-03-23T00:17:33Z"
+            },
+            {
+              "path": "src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.MessageMode.Windows.cs",
+              "diffHunk": "@@ -0,0 +1,106 @@\n+// Licensed to the .NET Foundation under one or more agreements.\n+// The .NET Foundation licenses this file to you under the MIT license.\n+\n+using System.Collections.Generic;\n+using System.IO.Tests;\n+using System.Linq;\n+using System.Runtime.InteropServices;\n+using System.Threading;\n+using System.Threading.Tasks;\n+using Xunit;\n+\n+namespace System.IO.Pipes.Tests\n+{\n+    // Support for PipeAccessRights and setting ReadMode to Message is only supported on Windows\n+    public class NamedPipeTest_MessageMode_Windows\n+    {\n+        private const PipeAccessRights MinimumMessageAccessRights = PipeAccessRights.ReadData | PipeAccessRights.WriteAttributes;\n+\n+        private static NamedPipeClientStream CreateClientStream(string pipeName, PipeOptions options) =>\n+            new NamedPipeClientStream(\".\", pipeName, MinimumMessageAccessRights, options, Security.Principal.TokenImpersonationLevel.None, HandleInheritability.None);\n+\n+        [Theory]\n+        [InlineData(PipeDirection.Out, PipeOptions.None)]\n+        [InlineData(PipeDirection.InOut, PipeOptions.Asynchronous)]\n+        public async Task Client_DetectsMessageCompleted(PipeDirection serverDirection, PipeOptions options)\n+        {\n+            string pipeName = PipeStreamConformanceTests.GetUniquePipeName();\n+\n+            using NamedPipeServerStream server = new NamedPipeServerStream(pipeName, serverDirection, 1, PipeTransmissionMode.Message, options);\n+            using NamedPipeClientStream client = CreateClientStream(pipeName, options);\n+\n+            Task.WaitAll(server.WaitForConnectionAsync(), client.ConnectAsync());\n+            client.ReadMode = PipeTransmissionMode.Message;\n+\n+            ValueTask serverWrite = server.WriteAsync(new byte[] { 1, 2, 3, 4, 5 });\n+\n+            byte[] buffer1 = new byte[2], buffer2 = new byte[2], buffer3 = new byte[2];\n+            bool[] messageCompleted = new bool[3];\n+\n+            int bytesRead = client.Read(buffer1, 0, 2);\n+            messageCompleted[0] = client.IsMessageComplete;\n+\n+            bytesRead += client.Read(buffer2, 0, 2);\n+            messageCompleted[1] = client.IsMessageComplete;\n+\n+            bytesRead += client.Read(buffer3, 0, 2);\n+            messageCompleted[2] = client.IsMessageComplete;\n+\n+            Assert.Equal(5, bytesRead);\n+            Assert.Equal(new byte[] { 1, 2, 3, 4, 5, 0 }, buffer1.Concat(buffer2).Concat(buffer3));\n+            Assert.Equal(new bool[] { false, false, true }, messageCompleted);\n+\n+            await serverWrite;\n+        }\n+\n+        [Theory]\n+        [InlineData(PipeTransmissionMode.Byte, PipeOptions.None)]\n+        [InlineData(PipeTransmissionMode.Message, PipeOptions.None)]\n+        [InlineData(PipeTransmissionMode.Byte, PipeOptions.Asynchronous)]\n+        [InlineData(PipeTransmissionMode.Message, PipeOptions.Asynchronous)]\n+        public void ServerIn_ClientConnect_Throws(PipeTransmissionMode serverMode, PipeOptions options)\n+        {\n+            string pipeName = PipeStreamConformanceTests.GetUniquePipeName();\n+\n+            using NamedPipeServerStream server = new NamedPipeServerStream(pipeName, PipeDirection.In, 1, serverMode, options);\n+            using NamedPipeClientStream client = CreateClientStream(pipeName, options);\n+\n+            Assert.Throws<UnauthorizedAccessException>(() => client.Connect());\n+        }\n+\n+        [Theory]\n+        [InlineData(PipeDirection.Out, PipeTransmissionMode.Byte, PipeOptions.None)]\n+        [InlineData(PipeDirection.Out, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)]\n+        [InlineData(PipeDirection.InOut, PipeTransmissionMode.Byte, PipeOptions.None)]\n+        [InlineData(PipeDirection.InOut, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)]\n+        public async Task ServerByteMode_ClientReadModeMessage_Throws(PipeDirection serverDirection, PipeTransmissionMode serverMode, PipeOptions options)\n+        {\n+            string pipeName = PipeStreamConformanceTests.GetUniquePipeName();\n+\n+            using NamedPipeServerStream server = new NamedPipeServerStream(pipeName, serverDirection, 1, serverMode, options);\n+            using NamedPipeClientStream client = CreateClientStream(pipeName, options);\n+\n+            Task serverConnected = server.WaitForConnectionAsync();\n+            client.Connect();\n+            await serverConnected;",
+              "body": "We need to have _at least one_ end of the pipe connect asynchronously so that execution isn't blocked and the other side of the connection can be made. As soon as both sides connect, the awaited tasks are completed. The approach here lets me establish that connection and proceed.\r\n\r\nI did use `Task.WaitAll(server.WaitForConnectionAsync(), client.ConnectAsync())` elsewhere though, so I can standardize on that so it's clearer.",
+              "createdAt": "2024-03-26T05:13:30Z"
+            }
+          ]
+        }
+      },
+      {
+        "comments": {
+          "nodes": [
+            {
+              "path": "src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.MessageMode.Windows.cs",
+              "diffHunk": "@@ -0,0 +1,106 @@\n+// Licensed to the .NET Foundation under one or more agreements.\n+// The .NET Foundation licenses this file to you under the MIT license.\n+\n+using System.Collections.Generic;\n+using System.IO.Tests;\n+using System.Linq;\n+using System.Runtime.InteropServices;\n+using System.Threading;\n+using System.Threading.Tasks;\n+using Xunit;\n+\n+namespace System.IO.Pipes.Tests\n+{\n+    // Support for PipeAccessRights and setting ReadMode to Message is only supported on Windows\n+    public class NamedPipeTest_MessageMode_Windows\n+    {\n+        private const PipeAccessRights MinimumMessageAccessRights = PipeAccessRights.ReadData | PipeAccessRights.WriteAttributes;\n+\n+        private static NamedPipeClientStream CreateClientStream(string pipeName, PipeOptions options) =>\n+            new NamedPipeClientStream(\".\", pipeName, MinimumMessageAccessRights, options, Security.Principal.TokenImpersonationLevel.None, HandleInheritability.None);\n+\n+        [Theory]\n+        [InlineData(PipeDirection.Out, PipeOptions.None)]\n+        [InlineData(PipeDirection.InOut, PipeOptions.Asynchronous)]\n+        public async Task Client_DetectsMessageCompleted(PipeDirection serverDirection, PipeOptions options)\n+        {\n+            string pipeName = PipeStreamConformanceTests.GetUniquePipeName();\n+\n+            using NamedPipeServerStream server = new NamedPipeServerStream(pipeName, serverDirection, 1, PipeTransmissionMode.Message, options);\n+            using NamedPipeClientStream client = CreateClientStream(pipeName, options);\n+\n+            Task.WaitAll(server.WaitForConnectionAsync(), client.ConnectAsync());\n+            client.ReadMode = PipeTransmissionMode.Message;\n+\n+            ValueTask serverWrite = server.WriteAsync(new byte[] { 1, 2, 3, 4, 5 });\n+\n+            byte[] buffer1 = new byte[2], buffer2 = new byte[2], buffer3 = new byte[2];\n+            bool[] messageCompleted = new bool[3];\n+\n+            int bytesRead = client.Read(buffer1, 0, 2);\n+            messageCompleted[0] = client.IsMessageComplete;\n+\n+            bytesRead += client.Read(buffer2, 0, 2);\n+            messageCompleted[1] = client.IsMessageComplete;\n+\n+            bytesRead += client.Read(buffer3, 0, 2);\n+            messageCompleted[2] = client.IsMessageComplete;\n+\n+            Assert.Equal(5, bytesRead);\n+            Assert.Equal(new byte[] { 1, 2, 3, 4, 5, 0 }, buffer1.Concat(buffer2).Concat(buffer3));\n+            Assert.Equal(new bool[] { false, false, true }, messageCompleted);\n+\n+            await serverWrite;\n+        }\n+\n+        [Theory]\n+        [InlineData(PipeTransmissionMode.Byte, PipeOptions.None)]\n+        [InlineData(PipeTransmissionMode.Message, PipeOptions.None)]\n+        [InlineData(PipeTransmissionMode.Byte, PipeOptions.Asynchronous)]\n+        [InlineData(PipeTransmissionMode.Message, PipeOptions.Asynchronous)]\n+        public void ServerIn_ClientConnect_Throws(PipeTransmissionMode serverMode, PipeOptions options)\n+        {\n+            string pipeName = PipeStreamConformanceTests.GetUniquePipeName();\n+\n+            using NamedPipeServerStream server = new NamedPipeServerStream(pipeName, PipeDirection.In, 1, serverMode, options);\n+            using NamedPipeClientStream client = CreateClientStream(pipeName, options);\n+\n+            Assert.Throws<UnauthorizedAccessException>(() => client.Connect());\n+        }\n+\n+        [Theory]\n+        [InlineData(PipeDirection.Out, PipeTransmissionMode.Byte, PipeOptions.None)]\n+        [InlineData(PipeDirection.Out, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)]\n+        [InlineData(PipeDirection.InOut, PipeTransmissionMode.Byte, PipeOptions.None)]\n+        [InlineData(PipeDirection.InOut, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)]\n+        public async Task ServerByteMode_ClientReadModeMessage_Throws(PipeDirection serverDirection, PipeTransmissionMode serverMode, PipeOptions options)\n+        {\n+            string pipeName = PipeStreamConformanceTests.GetUniquePipeName();\n+\n+            using NamedPipeServerStream server = new NamedPipeServerStream(pipeName, serverDirection, 1, serverMode, options);\n+            using NamedPipeClientStream client = CreateClientStream(pipeName, options);\n+\n+            Task serverConnected = server.WaitForConnectionAsync();\n+            client.Connect();\n+            await serverConnected;\n+\n+            Assert.Throws<IOException>(() => client.ReadMode = PipeTransmissionMode.Message);\n+        }\n+\n+        [Fact]\n+        public async Task PipeAccessRights_Without_WriteAttributes_ClientReadModeMessage_Throws()\n+        {\n+            string pipeName = PipeStreamConformanceTests.GetUniquePipeName();\n+            PipeAccessRights rights = MinimumMessageAccessRights & ~PipeAccessRights.WriteAttributes;\n+\n+            using NamedPipeServerStream server = new NamedPipeServerStream(pipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Message);\n+            using NamedPipeClientStream client = new NamedPipeClientStream(\".\", pipeName, rights, PipeOptions.None, Security.Principal.TokenImpersonationLevel.None, HandleInheritability.None);\n+\n+            Task serverConnected = server.WaitForConnectionAsync();\n+            client.Connect();\n+            await serverConnected;",
+              "body": "Ditto.\r\n\r\nIt would be nice to see synchronous methods and asynchronous methods doing the same logic. Similar to System.Formats.Tar: we have files to test the async methods only, and files to test the sync methods only, but never intermixed. Here we don't need separate files, they can be added to the same file. The async methods need to end with the *Async suffix.",
+              "createdAt": "2024-03-23T00:19:27Z"
+            },
+            {
+              "path": "src/libraries/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.MessageMode.Windows.cs",
+              "diffHunk": "@@ -0,0 +1,106 @@\n+// Licensed to the .NET Foundation under one or more agreements.\n+// The .NET Foundation licenses this file to you under the MIT license.\n+\n+using System.Collections.Generic;\n+using System.IO.Tests;\n+using System.Linq;\n+using System.Runtime.InteropServices;\n+using System.Threading;\n+using System.Threading.Tasks;\n+using Xunit;\n+\n+namespace System.IO.Pipes.Tests\n+{\n+    // Support for PipeAccessRights and setting ReadMode to Message is only supported on Windows\n+    public class NamedPipeTest_MessageMode_Windows\n+    {\n+        private const PipeAccessRights MinimumMessageAccessRights = PipeAccessRights.ReadData | PipeAccessRights.WriteAttributes;\n+\n+        private static NamedPipeClientStream CreateClientStream(string pipeName, PipeOptions options) =>\n+            new NamedPipeClientStream(\".\", pipeName, MinimumMessageAccessRights, options, Security.Principal.TokenImpersonationLevel.None, HandleInheritability.None);\n+\n+        [Theory]\n+        [InlineData(PipeDirection.Out, PipeOptions.None)]\n+        [InlineData(PipeDirection.InOut, PipeOptions.Asynchronous)]\n+        public async Task Client_DetectsMessageCompleted(PipeDirection serverDirection, PipeOptions options)\n+        {\n+            string pipeName = PipeStreamConformanceTests.GetUniquePipeName();\n+\n+            using NamedPipeServerStream server = new NamedPipeServerStream(pipeName, serverDirection, 1, PipeTransmissionMode.Message, options);\n+            using NamedPipeClientStream client = CreateClientStream(pipeName, options);\n+\n+            Task.WaitAll(server.WaitForConnectionAsync(), client.ConnectAsync());\n+            client.ReadMode = PipeTransmissionMode.Message;\n+\n+            ValueTask serverWrite = server.WriteAsync(new byte[] { 1, 2, 3, 4, 5 });\n+\n+            byte[] buffer1 = new byte[2], buffer2 = new byte[2], buffer3 = new byte[2];\n+            bool[] messageCompleted = new bool[3];\n+\n+            int bytesRead = client.Read(buffer1, 0, 2);\n+            messageCompleted[0] = client.IsMessageComplete;\n+\n+            bytesRead += client.Read(buffer2, 0, 2);\n+            messageCompleted[1] = client.IsMessageComplete;\n+\n+            bytesRead += client.Read(buffer3, 0, 2);\n+            messageCompleted[2] = client.IsMessageComplete;\n+\n+            Assert.Equal(5, bytesRead);\n+            Assert.Equal(new byte[] { 1, 2, 3, 4, 5, 0 }, buffer1.Concat(buffer2).Concat(buffer3));\n+            Assert.Equal(new bool[] { false, false, true }, messageCompleted);\n+\n+            await serverWrite;\n+        }\n+\n+        [Theory]\n+        [InlineData(PipeTransmissionMode.Byte, PipeOptions.None)]\n+        [InlineData(PipeTransmissionMode.Message, PipeOptions.None)]\n+        [InlineData(PipeTransmissionMode.Byte, PipeOptions.Asynchronous)]\n+        [InlineData(PipeTransmissionMode.Message, PipeOptions.Asynchronous)]\n+        public void ServerIn_ClientConnect_Throws(PipeTransmissionMode serverMode, PipeOptions options)\n+        {\n+            string pipeName = PipeStreamConformanceTests.GetUniquePipeName();\n+\n+            using NamedPipeServerStream server = new NamedPipeServerStream(pipeName, PipeDirection.In, 1, serverMode, options);\n+            using NamedPipeClientStream client = CreateClientStream(pipeName, options);\n+\n+            Assert.Throws<UnauthorizedAccessException>(() => client.Connect());\n+        }\n+\n+        [Theory]\n+        [InlineData(PipeDirection.Out, PipeTransmissionMode.Byte, PipeOptions.None)]\n+        [InlineData(PipeDirection.Out, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)]\n+        [InlineData(PipeDirection.InOut, PipeTransmissionMode.Byte, PipeOptions.None)]\n+        [InlineData(PipeDirection.InOut, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)]\n+        public async Task ServerByteMode_ClientReadModeMessage_Throws(PipeDirection serverDirection, PipeTransmissionMode serverMode, PipeOptions options)\n+        {\n+            string pipeName = PipeStreamConformanceTests.GetUniquePipeName();\n+\n+            using NamedPipeServerStream server = new NamedPipeServerStream(pipeName, serverDirection, 1, serverMode, options);\n+            using NamedPipeClientStream client = CreateClientStream(pipeName, options);\n+\n+            Task serverConnected = server.WaitForConnectionAsync();\n+            client.Connect();\n+            await serverConnected;\n+\n+            Assert.Throws<IOException>(() => client.ReadMode = PipeTransmissionMode.Message);\n+        }\n+\n+        [Fact]\n+        public async Task PipeAccessRights_Without_WriteAttributes_ClientReadModeMessage_Throws()\n+        {\n+            string pipeName = PipeStreamConformanceTests.GetUniquePipeName();\n+            PipeAccessRights rights = MinimumMessageAccessRights & ~PipeAccessRights.WriteAttributes;\n+\n+            using NamedPipeServerStream server = new NamedPipeServerStream(pipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Message);\n+            using NamedPipeClientStream client = new NamedPipeClientStream(\".\", pipeName, rights, PipeOptions.None, Security.Principal.TokenImpersonationLevel.None, HandleInheritability.None);\n+\n+            Task serverConnected = server.WaitForConnectionAsync();\n+            client.Connect();\n+            await serverConnected;",
+              "body": "These tests are focused on the message mode itself, not the aspect of making connections, so I'll leave that out of scope to ensure all combinations of sync/async connections are covered. But I'll standardize onto `Task.WaitAll(server.WaitForConnectionAsync(), client.ConnectAsync())` instead of mixing sync/async to make it more readable.\r\n\r\nSince the access rights overload throws on non-Windows platforms, I'll keep these tests in a separate file too (otherwise, they'd need to all be `[PlatformSpecific(TestPlatforms.Windows)]`).",
+              "createdAt": "2024-03-26T05:17:55Z"
+            }
+          ]
+        }
+      }
+    ]
+  },
+  "commits": {
+    "totalCount": 7,
+    "nodes": [
+      {
+        "commit": {
+          "oid": "6ca147bf996f585931b64177096050d837b9ef1e",
+          "message": "Support setting NamedPipeClientStream.ReadMode with PipeAccessRights ctor overload",
+          "committedDate": "2024-03-20T09:09:23Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "d5eacc149076afd03f3d53323be1602da2dc694e",
+          "message": "Add API doc comments for new constructor (and fix placement of comment)",
+          "committedDate": "2024-03-20T09:24:24Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "5bdf1c858a4ad483a6653e62886847b2f0feee34",
+          "message": "Add more tests including functional tests. Fill an argument validation gap.",
+          "committedDate": "2024-03-22T01:09:57Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "2cfb092d293dd126e2b02b68aa80c91c98351396",
+          "message": "Merge branch 'main' into jeffhandley/namedpipe-readmode",
+          "committedDate": "2024-03-22T06:19:36Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "6d7aad7900110947ee565a0bc7bb111ab29b8759",
+          "message": "Remove old ApiCompat suppression from PipeAccessRights",
+          "committedDate": "2024-03-22T06:30:59Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "8c0a19e05cc847fac12bac17d06d5038882c7dd0",
+          "message": "Make new tests more readable per PR feedback",
+          "committedDate": "2024-03-26T05:47:08Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "481df95464dc298e111fc9b3e3e0659f8ad82b99",
+          "message": "Merge branch 'main' into jeffhandley/namedpipe-readmode",
+          "committedDate": "2024-03-26T23:02:29Z"
+        }
+      }
+    ]
+  }
+}

data/raw_sample/prs/pr-100002.json

@@ -0,0 +1,87 @@
+{
+  "number": 100002,
+  "title": "Skip ro segments which are not in range when walking heap for GC diagnostics",
+  "body": "Fixed crash in gc_heap::walk_heap_per_heap when walking frozen segments\r\n\r\n**Motivation:**\r\n\r\nEnabling `COR_PRF_MONITOR_GC` GC Heap diagnostics flag causes crash after initiating AssemblyLoadContext unloading with the following callstack.\r\n\r\n```\r\n[Inline Frame] coreclr.dll!WKS::my_get_size(Object *) Line 11572\tC++\tSymbols loaded.\r\n>\tcoreclr.dll!WKS::gc_heap::walk_heap_per_heap(bool(*)(Object *, void *) fn, void * context, int gen_number, int walk_large_object_heap_p) Line 51974\tC++\tSymbols loaded.\r\n \tcoreclr.dll!GCProfileWalkHeapWorker(int fProfilerPinned, int fShouldWalkHeapRootsForEtw, int fShouldWalkHeapObjectsForEtw) Line 727\tC++\tSymbols loaded.\r\n \tcoreclr.dll!GCToEEInterface::DiagGCEnd(unsigned __int64 fConcurrent, int index, int gen, bool reason) Line 818\tC++\tSymbols loaded.\r\n \tcoreclr.dll!WKS::gc_heap::do_post_gc() Line 50183\tC++\tSymbols loaded.\r\n \tcoreclr.dll!WKS::gc_heap::gc1() Line 22865\tC++\tSymbols loaded.\r\n \t[Inline Frame] coreclr.dll!GCToOSInterface::GetLowPrecisionTimeStamp() Line 1091\tC++\tSymbols loaded.\r\n \tcoreclr.dll!WKS::gc_heap::garbage_collect(int n) Line 24329\tC++\tSymbols loaded.\r\n \tcoreclr.dll!WKS::GCHeap::GarbageCollectGeneration(unsigned int gen, gc_reason reason) Line 50526\tC++\tSymbols loaded.\r\n \tcoreclr.dll!WKS::GCHeap::GarbageCollect(int generation, bool low_memory_p, int mode) Line 49681\tC++\tSymbols loaded.\r\n \tcoreclr.dll!ETW::GCLog::ForceGCForDiagnostics() Line 492\tC++\tSymbols loaded.\r\n \t[Inline Frame] coreclr.dll!ETW::GCLog::ForceGC(__int64) Line 431\tC++\t\r\n```\r\n\r\nI was suspecting invalid profiler setup, however the issue was also reproducible with [PerfView](https://github.com/microsoft/perfview) tool without enabling `COR_PRF_MONITOR_GC` flag via profiler dll at startup - tool crashes on GC Heap dump once one of assemblies from  AssemblyLoadContext gets unloaded.\r\n\r\nI was suspecting then heap corruption, but was not able to gather any proof of that by running `gc::verify_heap` every GC and native/managed transition (the latter was painfully slow 😁). Further comparison with `gc::verify_heap` yielded that heap verification uses `heap_segment_in_range/heap_segment_next_in_range` methods [to get the heap segment to iterate over](https://github.com/dotnet/runtime/blob/main/src/coreclr/gc/gc.cpp#L47873). `heap_segment_in_range` checks that segment is not readonly/frozen (`heap_segment_flags_readonly` flag) or if it is “in range” (`heap_segment_flags_inrange` flag). At the same time `gc_heap::walk_heap_per_heap` scans through all segments.\r\n\r\n**Changes**:\r\n\r\nMy hypothesis is that assembly unloading may free/rollback segments that are used for string/type/etc data in frozen segments and thus we need to skip such segments when traversing heap for diagnostics. I might be wrong given my limited understanding of `USE_RANGES` feature and would appreciate other ideas 😄 ",
+  "createdAt": "2024-03-20T09:15:59Z",
+  "closedAt": "2024-03-29T16:36:08Z",
+  "mergedAt": null,
+  "state": "CLOSED",
+  "author": {
+    "login": "alexey-zakharov"
+  },
+  "labels": {
+    "nodes": [
+      {
+        "name": "area-GC-coreclr"
+      },
+      {
+        "name": "community-contribution"
+      }
+    ]
+  },
+  "headRefName": "upstream-walk_heap-skip-frozen-segments",
+  "additions": 5,
+  "deletions": 5,
+  "changedFiles": 1,
+  "comments": {
+    "totalCount": 10,
+    "nodes": [
+      {
+        "body": "Tagging subscribers to this area: @dotnet/gc\nSee info in [area-owners.md](https://github.com/dotnet/runtime/blob/main/docs/area-owners.md) if you want to be subscribed.\n<!-- Policy app identification https://img.shields.io/static/v1?label=PullRequestIssueManagement. -->",
+        "createdAt": "2024-03-20T09:16:29Z"
+      },
+      {
+        "body": "@dotnet-policy-service agree company=\"Unity Technologies\"",
+        "createdAt": "2024-03-20T09:24:34Z"
+      },
+      {
+        "body": "cc @cshung \r\n\r\n> My hypothesis is that assembly unloading may free/rollback segments that are used for string/type/etc data in frozen segments\r\n\r\nWe currently never unregister/remove such segments and never put stuff from unloadable ALCs there 🤔 ",
+        "createdAt": "2024-03-20T15:33:07Z"
+      },
+      {
+        "body": "> We currently never unregister/remove such segments and never put stuff from unloadable ALCs there 🤔\r\n\r\nthanks! ok, then my understanding was wrong and perhaps we do have segments corruption or there is another mechanism that may unmark segments\r\nin case of corruption the question then would be how to diagnose it assuming verify_heap skips such segments and never crashes? 🤔 (perhaps protect frozen segments memory with READONLY flag)",
+        "createdAt": "2024-03-20T15:43:51Z"
+      },
+      {
+        "body": "@alexey-zakharov, is the crash something you can share with us a repro?",
+        "createdAt": "2024-03-20T16:34:43Z"
+      },
+      {
+        "body": "> @alexey-zakharov, is the crash something you can share with us a repro?\r\n\r\n@cshung yes, I think so - do you know what are the guidelines for sharing?\r\nand should I make an issue instead?",
+        "createdAt": "2024-03-21T08:41:47Z"
+      },
+      {
+        "body": "> Do you know what are the guidelines for sharing? and should I make an issue instead?\r\n\r\nThanks for planning to share! I don't think we have guidelines for sharing repro, but we have a template for opening bug issues and there are some general questions that you can answer there.\r\n\r\nhttps://github.com/dotnet/runtime/issues/new?assignees=&labels=&projects=&template=01_bug_report.yml",
+        "createdAt": "2024-03-21T17:57:04Z"
+      },
+      {
+        "body": "Is this superseded by https://github.com/dotnet/runtime/pull/100444 ?",
+        "createdAt": "2024-03-29T16:21:46Z"
+      },
+      {
+        "body": "> Is this superseded by #100444 ?\r\n\r\nyes, I've dug deeper into the issue and we've figured a better fix\r\nI'm closing this PR",
+        "createdAt": "2024-03-29T16:36:08Z"
+      },
+      {
+        "body": "(the real issue we had was that SzArray of a collectible type was allocated on a frozen heap and once LoaderAllocator gets destroyed object's MethodTable points to a bad memory which leads to random consequences when iterating heap)",
+        "createdAt": "2024-03-29T16:39:12Z"
+      }
+    ]
+  },
+  "reviewThreads": {
+    "totalCount": 0,
+    "nodes": []
+  },
+  "commits": {
+    "totalCount": 1,
+    "nodes": [
+      {
+        "commit": {
+          "oid": "397d04883ccec635d21d6891c4beea3cd26150bd",
+          "message": "Skip ro segments which are not in range when walking heap for GC diagnostics",
+          "committedDate": "2024-03-20T09:09:08Z"
+        }
+      }
+    ]
+  }
+}

data/raw_sample/prs/pr-100004.json

@@ -0,0 +1,195 @@
+{
+  "number": 100004,
+  "title": "Include versions and checksums in VMR publishing and remove prepare-artifacts.proj",
+  "body": "Fixes https://github.com/dotnet/source-build/issues/4239\r\n\r\nFollows the pattern that we established in windowsdesktop: https://github.com/dotnet/windowsdesktop/blob/main/eng/Publishing.props\r\n\r\n**Important: No Merge until I verified the changes in a runtime official build and a VMR build.**\r\n\r\nRuntime official build: https://dnceng.visualstudio.com/internal/_build/results?buildId=2414748&view=results",
+  "createdAt": "2024-03-20T09:44:23Z",
+  "closedAt": "2024-11-29T08:36:33Z",
+  "mergedAt": null,
+  "state": "CLOSED",
+  "author": {
+    "login": "ViktorHofer"
+  },
+  "labels": {
+    "nodes": [
+      {
+        "name": "NO-MERGE"
+      },
+      {
+        "name": "area-Infrastructure-libraries"
+      }
+    ]
+  },
+  "headRefName": "ViktorHofer-patch-1",
+  "additions": 223,
+  "deletions": 500,
+  "changedFiles": 14,
+  "comments": {
+    "totalCount": 0,
+    "nodes": []
+  },
+  "reviewThreads": {
+    "totalCount": 6,
+    "nodes": [
+      {
+        "comments": {
+          "nodes": [
+            {
+              "path": "src/native/corehost/corehost.proj",
+              "diffHunk": "@@ -8,7 +8,7 @@\n \n   <PropertyGroup>\n     <IncrementalNativeBuild Condition=\"'$(IncrementalNativeBuild)' == ''\">true</IncrementalNativeBuild>\n-    <BuildCoreHostDependsOn>GetProductVersions;GenerateRuntimeVersionFile</BuildCoreHostDependsOn>\n+    <BuildCoreHostDependsOn>GenerateRuntimeVersionFile</BuildCoreHostDependsOn>",
+              "body": "I checked and I couldn't find a place under src/native that still depended on the `GetProductVersions` target.",
+              "createdAt": "2024-03-25T14:02:05Z"
+            }
+          ]
+        }
+      },
+      {
+        "comments": {
+          "nodes": [
+            {
+              "path": "src/mono/wasm/templates/Microsoft.NET.Runtime.WebAssembly.Templates.csproj",
+              "diffHunk": "@@ -24,10 +24,5 @@\n \n   <Target Name=\"CreateManifestResourceNames\" />\n   <Target Name=\"CoreCompile\" />\n-  <Target Name=\"_SetProductVersion\" DependsOnTargets=\"GetProductVersions\" BeforeTargets=\"Pack\">\n-    <PropertyGroup>\n-      <PackageVersion>$(ProductVersion)</PackageVersion>\n-    </PropertyGroup>\n-  </Target>",
+              "body": "From what I could see, this setting shouldn't be necessary as PackageVersion is already automatically set by Arcade.",
+              "createdAt": "2024-03-25T14:03:07Z"
+            }
+          ]
+        }
+      },
+      {
+        "comments": {
+          "nodes": [
+            {
+              "path": "src/mono/browser/browser.proj",
+              "diffHunk": "@@ -533,12 +533,20 @@\n     <_RollupInputs Include=\"$(BrowserProjectRoot)runtime/*.js\"/>\n   </ItemGroup>\n \n-  <Target Name=\"SetMonoRollupEnvironment\" DependsOnTargets=\"GetProductVersions\">\n+  <Target Name=\"SetMonoRollupEnvironment\">\n+    <!-- Retrieve the runtime pack product version. -->\n+    <MSBuild Projects=\"$(RepoRoot)src/installer/pkg/sfx/Microsoft.NETCore.App/Microsoft.NETCore.App.Runtime.sfxproj\"\n+             Targets=\"ReturnProductVersion\"\n+             Properties=\"Crossgen2SdkOverridePropsPath=;\n+                         Crossgen2SdkOverrideTargetsPath=\">\n+      <Output TaskParameter=\"TargetOutputs\" PropertyName=\"RuntimePackProductVersion\" />\n+    </MSBuild>\n+\n     <ItemGroup>\n       <_MonoRollupEnvironmentVariable Include=\"Configuration:$(Configuration)\" />\n       <_MonoRollupEnvironmentVariable Include=\"NativeBinDir:$(NativeBinDir)\" />\n       <_MonoRollupEnvironmentVariable Include=\"WasmObjDir:$(WasmObjDir)\" />\n-      <_MonoRollupEnvironmentVariable Include=\"ProductVersion:$(ProductVersion)\" />\n+      <_MonoRollupEnvironmentVariable Include=\"ProductVersion:$(RuntimePackProductVersion)\" />",
+              "body": "Calling into sfxproj to retrieve the version felt safer than just relying on PackageVersion here in case this project sets IsShipping or any other properties already or in the future.",
+              "createdAt": "2024-03-25T14:03:56Z"
+            }
+          ]
+        }
+      },
+      {
+        "comments": {
+          "nodes": [
+            {
+              "path": "src/installer/tests/Directory.Build.targets",
+              "diffHunk": "@@ -37,7 +37,6 @@\n   <Target Name=\"SetupTestContextVariables\"\n           Condition=\"'$(IsTestProject)' == 'true'\"\n           DependsOnTargets=\"\n-            GetProductVersions;",
+              "body": "I couldn't find any place that still depends on this target or its properties.",
+              "createdAt": "2024-03-25T14:04:27Z"
+            }
+          ]
+        }
+      },
+      {
+        "comments": {
+          "nodes": [
+            {
+              "path": "src/installer/pkg/projects/Directory.Build.targets",
+              "diffHunk": "@@ -16,20 +18,6 @@\n     <SymbolPackageOutputPath>$(PackageOutputPath)</SymbolPackageOutputPath>\n   </PropertyGroup>\n \n-  <Target Name=\"SetTargetBasedPackageVersion\"\n-          BeforeTargets=\"GenerateNuSpec\"\n-          DependsOnTargets=\"GetProductVersions\">\n-    <PropertyGroup>\n-      <Version>$(ProductVersion)</Version>\n-      <!--\n-        PackageVersion is normally calculated using Version during static property evaluation, but\n-        we need some info from GetProductVersions, so it's too late to rely on that. We need to set\n-        both in target evaluation, here.\n-      -->\n-      <PackageVersion>$(ProductVersion)</PackageVersion>\n-    </PropertyGroup>\n-  </Target>\n-",
+              "body": "This might have been necessary in the past but AFAIK, NuGet calculates PackageVersion correctly, even for pkgprojs.",
+              "createdAt": "2024-03-25T14:06:13Z"
+            }
+          ]
+        }
+      },
+      {
+        "comments": {
+          "nodes": [
+            {
+              "path": "eng/Signing.props",
+              "diffHunk": "@@ -55,14 +44,30 @@\n     <FileSignInfo Update=\"@(FileSignInfo->WithMetadataValue('CertificateName','Microsoft400'))\" CertificateName=\"MicrosoftDotNet500\" />\n   </ItemGroup>\n \n-  <ItemGroup Condition=\"'$(PrepareArtifacts)' == 'true'\">\n-    <ItemsToSignWithPaths Include=\"$(DownloadDirectory)**\\*.msi\" />\n-    <ItemsToSignWithPaths Include=\"$(DownloadDirectory)**\\*.exe\" />\n-    <ItemsToSignWithPaths Include=\"$(DownloadDirectory)**\\*.nupkg\" />\n-    <ItemsToSignWithPaths Include=\"$(DownloadDirectory)**\\*.zip\" />\n+  <!-- In build signing and publishing without a join point -->\n+  <ItemGroup Condition=\"'$(SignAndPublishAsJoinPoint)' != 'true'\">\n+    <Artifact Include=\"$(ArtifactsPackagesDir)**\\*.tar.gz;\n+                       $(ArtifactsPackagesDir)**\\*.zip;\n+                       $(ArtifactsPackagesDir)**\\*.deb;\n+                       $(ArtifactsPackagesDir)**\\*.rpm;\n+                       $(ArtifactsPackagesDir)**\\*.pkg;\n+                       $(ArtifactsPackagesDir)**\\*.exe;\n+                       $(ArtifactsPackagesDir)**\\*.msi\"\n+              Exclude=\"$(ArtifactsPackagesDir)**\\Symbols.runtime.tar.gz\"\n+              IsShipping=\"$([System.String]::Copy('%(RecursiveDir)').StartsWith('Shipping'))\">",
+              "body": "Can you point me to the docs for `ItemsToSign` vs `Artifact`? ",
+              "createdAt": "2024-04-01T18:39:36Z"
+            },
+            {
+              "path": "eng/Signing.props",
+              "diffHunk": "@@ -55,14 +44,30 @@\n     <FileSignInfo Update=\"@(FileSignInfo->WithMetadataValue('CertificateName','Microsoft400'))\" CertificateName=\"MicrosoftDotNet500\" />\n   </ItemGroup>\n \n-  <ItemGroup Condition=\"'$(PrepareArtifacts)' == 'true'\">\n-    <ItemsToSignWithPaths Include=\"$(DownloadDirectory)**\\*.msi\" />\n-    <ItemsToSignWithPaths Include=\"$(DownloadDirectory)**\\*.exe\" />\n-    <ItemsToSignWithPaths Include=\"$(DownloadDirectory)**\\*.nupkg\" />\n-    <ItemsToSignWithPaths Include=\"$(DownloadDirectory)**\\*.zip\" />\n+  <!-- In build signing and publishing without a join point -->\n+  <ItemGroup Condition=\"'$(SignAndPublishAsJoinPoint)' != 'true'\">\n+    <Artifact Include=\"$(ArtifactsPackagesDir)**\\*.tar.gz;\n+                       $(ArtifactsPackagesDir)**\\*.zip;\n+                       $(ArtifactsPackagesDir)**\\*.deb;\n+                       $(ArtifactsPackagesDir)**\\*.rpm;\n+                       $(ArtifactsPackagesDir)**\\*.pkg;\n+                       $(ArtifactsPackagesDir)**\\*.exe;\n+                       $(ArtifactsPackagesDir)**\\*.msi\"\n+              Exclude=\"$(ArtifactsPackagesDir)**\\Symbols.runtime.tar.gz\"\n+              IsShipping=\"$([System.String]::Copy('%(RecursiveDir)').StartsWith('Shipping'))\">",
+              "body": "Just checked Arcade and this makes sense (Artifact feeds into ItemsToSign)",
+              "createdAt": "2024-04-05T17:21:49Z"
+            }
+          ]
+        }
+      }
+    ]
+  },
+  "commits": {
+    "totalCount": 11,
+    "nodes": [
+      {
+        "commit": {
+          "oid": "684ff76979aeb60fc02332c769c8add360ec290c",
+          "message": "Include versions and checksums in VMR publishing",
+          "committedDate": "2024-03-20T09:43:52Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "df52116e7e8d3d58e7e0090c4852b19676c7028d",
+          "message": "Create AfterSigning.targets",
+          "committedDate": "2024-03-20T09:50:45Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "98f0bb68a01586dc01ef9b9391c95c876bdc8ea7",
+          "message": "Update Publishing.props",
+          "committedDate": "2024-03-20T09:52:39Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "8ec942dee98ac6812f4bf33cea76bc088e36d51b",
+          "message": "Update Publishing.props",
+          "committedDate": "2024-03-20T09:54:55Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "be3b37beceb99a36794c6131c6a31f8fc86f0349",
+          "message": "Update Publishing.props",
+          "committedDate": "2024-03-20T10:04:11Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "3e7855889467dc74d8d21926137e6c2927e5bb6b",
+          "message": "Update Publishing.props",
+          "committedDate": "2024-03-25T14:01:16Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "65660ec908be9196470062db00c849155d8a5c93",
+          "message": "Update Signing.props",
+          "committedDate": "2024-03-25T14:07:43Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "5f3d52a6abf4015a67d4a8c6a06a9ecc01cc16f2",
+          "message": "Clean-up and fixes",
+          "committedDate": "2024-03-26T06:27:07Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "020baf9424882fa96fbcc3e6f172ef0b4dc5d0ef",
+          "message": "Merge branch 'ViktorHofer-patch-1' of https://github.com/dotnet/runtime into ViktorHofer-patch-1",
+          "committedDate": "2024-03-26T06:28:48Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "b3fe52e81d0094bc769f33dc10cf60648b4592d0",
+          "message": "style nit",
+          "committedDate": "2024-03-26T06:30:50Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "f35ffde0407866e996b3d4f1ead7b5360c7e5295",
+          "message": "Remove prepare-artifacts.proj",
+          "committedDate": "2024-03-26T10:31:27Z"
+        }
+      }
+    ]
+  }
+}

data/raw_sample/prs/pr-100005.json

@@ -0,0 +1,52 @@
+{
+  "number": 100005,
+  "title": "JIT: Fix flags updating when sinking stores below commas",
+  "body": "When we sink a store below a comma, we should update the comma's flags after updating the flags of the store, not before.\r\n\r\nFix #99929",
+  "createdAt": "2024-03-20T09:47:09Z",
+  "closedAt": "2024-03-20T15:21:09Z",
+  "mergedAt": "2024-03-20T15:21:09Z",
+  "state": "MERGED",
+  "author": {
+    "login": "jakobbotsch"
+  },
+  "labels": {
+    "nodes": [
+      {
+        "name": "area-CodeGen-coreclr"
+      }
+    ]
+  },
+  "headRefName": "fix-99929",
+  "additions": 1,
+  "deletions": 1,
+  "changedFiles": 1,
+  "comments": {
+    "totalCount": 2,
+    "nodes": [
+      {
+        "body": "Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch\nSee info in [area-owners.md](https://github.com/dotnet/runtime/blob/main/docs/area-owners.md) if you want to be subscribed.\n<!-- Policy app identification https://img.shields.io/static/v1?label=PullRequestIssueManagement. -->",
+        "createdAt": "2024-03-20T09:47:31Z"
+      },
+      {
+        "body": "cc @dotnet/jit-contrib PTAL @EgorBo \r\n\r\n[No diffs](https://dev.azure.com/dnceng-public/public/_build/results?buildId=609666&view=ms.vss-build-web.run-extensions-tab)",
+        "createdAt": "2024-03-20T13:34:32Z"
+      }
+    ]
+  },
+  "reviewThreads": {
+    "totalCount": 0,
+    "nodes": []
+  },
+  "commits": {
+    "totalCount": 1,
+    "nodes": [
+      {
+        "commit": {
+          "oid": "c546af932a5e27f8b845e9d3dbe406dea17f6730",
+          "message": "JIT: Fix flags updating when sinking stores below commas\n\nWhen we sink a store below a comma, we should update the comma's flags\nafter updating the flags of the store, not before.\n\nFix #99929",
+          "committedDate": "2024-03-20T09:46:30Z"
+        }
+      }
+    ]
+  }
+}

data/raw_sample/prs/pr-100011.json

@@ -0,0 +1,85 @@
+{
+  "number": 100011,
+  "title": "[main] Update dependencies from dotnet/emsdk",
+  "body": "This pull request updates the following dependencies\r\n\r\n[marker]: <> (Begin:Coherency Updates)\r\n## Coherency Updates\r\n\r\nThe following updates ensure that dependencies with a *CoherentParentDependency*\r\nattribute were produced in a build used as input to the parent dependency's build.\r\nSee [Dependency Description Format](https://github.com/dotnet/arcade/blob/master/Documentation/DependencyDescriptionFormat.md#dependency-description-overview)\r\n\r\n[DependencyUpdate]: <> (Begin)\r\n\r\n- **Coherency Updates**:\r\n  - **runtime.linux-arm64.Microsoft.NETCore.Runtime.JIT.Tools**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.linux-x64.Microsoft.NETCore.Runtime.JIT.Tools**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.JIT.Tools**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.linux-musl-x64.Microsoft.NETCore.Runtime.JIT.Tools**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.win-arm64.Microsoft.NETCore.Runtime.JIT.Tools**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.win-x64.Microsoft.NETCore.Runtime.JIT.Tools**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.osx-arm64.Microsoft.NETCore.Runtime.JIT.Tools**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.osx-x64.Microsoft.NETCore.Runtime.JIT.Tools**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.linux-musl-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.linux-musl-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.osx-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.osx-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.osx-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n  - **runtime.osx-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools**: from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport)\r\n\r\n[DependencyUpdate]: <> (End)\r\n\r\n[marker]: <> (End:Coherency Updates)\r\n\r\n\r\n\r\n\r\n\r\n\r\n[marker]: <> (Begin:c22d5069-447c-4252-29fd-08d90a7bb4bc)\r\n## From https://github.com/dotnet/emsdk\r\n- **Subscription**: c22d5069-447c-4252-29fd-08d90a7bb4bc\r\n- **Build**: \r\n- **Date Produced**: March 22, 2024 2:08:43 PM UTC\r\n- **Commit**: 2106e0604f52119b7d49577476ece7d51a23a40d\r\n- **Branch**: refs/heads/main\r\n\r\n[DependencyUpdate]: <> (Begin)\r\n\r\n- **Updates**:\r\n  - **Microsoft.SourceBuild.Intermediate.emsdk**: [from 9.0.0-preview.3.24160.1 to 9.0.0-preview.4.24172.11][11]\r\n  - **Microsoft.NET.Runtime.Emscripten.3.1.34.Python.win-x64**: [from 9.0.0-preview.3.24160.1 to 9.0.0-preview.4.24172.11][11]\r\n  - **Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport**: [from 9.0.0-preview.3.24160.1 to 9.0.0-preview.4.24172.11][11]\r\n  - **runtime.linux-arm64.Microsoft.NETCore.Runtime.JIT.Tools**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.linux-x64.Microsoft.NETCore.Runtime.JIT.Tools**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.JIT.Tools**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.linux-musl-x64.Microsoft.NETCore.Runtime.JIT.Tools**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.win-arm64.Microsoft.NETCore.Runtime.JIT.Tools**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.win-x64.Microsoft.NETCore.Runtime.JIT.Tools**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.osx-arm64.Microsoft.NETCore.Runtime.JIT.Tools**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.osx-x64.Microsoft.NETCore.Runtime.JIT.Tools**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.linux-musl-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.linux-musl-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.osx-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.osx-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.osx-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n  - **runtime.osx-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools**: [from 16.0.5-alpha.1.24154.3 to 16.0.5-alpha.1.24169.1][12]\r\n\r\n[11]: https://github.com/dotnet/emsdk/compare/5dd0620274...2106e0604f\r\n[12]: https://github.com/dotnet/llvm-project/compare/3ac1a8b8d5...ad6d4582d5\r\n\r\n[DependencyUpdate]: <> (End)\r\n\r\n\r\n[marker]: <> (End:c22d5069-447c-4252-29fd-08d90a7bb4bc)\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n",
+  "createdAt": "2024-03-20T12:25:12Z",
+  "closedAt": "2024-03-25T16:10:04Z",
+  "mergedAt": "2024-03-25T16:10:04Z",
+  "state": "MERGED",
+  "author": {
+    "login": "dotnet-maestro"
+  },
+  "labels": {
+    "nodes": [
+      {
+        "name": "area-codeflow"
+      }
+    ]
+  },
+  "headRefName": "darc-main-a78e253c-4e4d-4515-aa80-7915c88e4f5a",
+  "additions": 74,
+  "deletions": 74,
+  "changedFiles": 2,
+  "comments": {
+    "totalCount": 0,
+    "nodes": []
+  },
+  "reviewThreads": {
+    "totalCount": 0,
+    "nodes": []
+  },
+  "commits": {
+    "totalCount": 7,
+    "nodes": [
+      {
+        "commit": {
+          "oid": "b055ba9acf9945f1399ff1bfbe7879c321555f99",
+          "message": "Update dependencies from https://github.com/dotnet/emsdk build\n\nMicrosoft.SourceBuild.Intermediate.emsdk , Microsoft.NET.Runtime.Emscripten.3.1.34.Python.win-x64 , Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport\n From Version 9.0.0-preview.3.24160.1 -> To Version 9.0.0-preview.3.24169.1\n\nDependency coherency updates\n\nruntime.linux-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-musl-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.win-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.win-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.osx-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.osx-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.linux-musl-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-musl-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.osx-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.osx-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.osx-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.osx-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools\n From Version 16.0.5-alpha.1.24154.3 -> To Version 16.0.5-alpha.1.24168.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport",
+          "committedDate": "2024-03-20T12:25:08Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "db61b1c8a9ee37e02fdfc6a5f470c9ff62753668",
+          "message": "Update dependencies from https://github.com/dotnet/emsdk build\n\nMicrosoft.SourceBuild.Intermediate.emsdk , Microsoft.NET.Runtime.Emscripten.3.1.34.Python.win-x64 , Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport\n From Version 9.0.0-preview.3.24160.1 -> To Version 9.0.0-preview.4.24170.12\n\nDependency coherency updates\n\nruntime.linux-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-musl-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.win-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.win-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.osx-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.osx-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.linux-musl-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-musl-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.osx-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.osx-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.osx-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.osx-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools\n From Version 16.0.5-alpha.1.24154.3 -> To Version 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport",
+          "committedDate": "2024-03-21T12:24:47Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "103e9e6791d76cb0aedee2d7711d7502bcc33665",
+          "message": "Update dependencies from https://github.com/dotnet/emsdk build\n\nMicrosoft.SourceBuild.Intermediate.emsdk , Microsoft.NET.Runtime.Emscripten.3.1.34.Python.win-x64 , Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport\n From Version 9.0.0-preview.3.24160.1 -> To Version 9.0.0-preview.4.24172.3\n\nDependency coherency updates\n\nruntime.linux-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-musl-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.win-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.win-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.osx-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.osx-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.linux-musl-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-musl-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.osx-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.osx-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.osx-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.osx-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools\n From Version 16.0.5-alpha.1.24154.3 -> To Version 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport",
+          "committedDate": "2024-03-22T12:26:24Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "853c98011585ef6e2e31774523fe0c2f1b52436f",
+          "message": "Merge branch 'main' into darc-main-a78e253c-4e4d-4515-aa80-7915c88e4f5a",
+          "committedDate": "2024-03-23T03:46:45Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "b744b4293662406db6e1e4f5038244d700b27414",
+          "message": "Update dependencies from https://github.com/dotnet/emsdk build\n\nMicrosoft.SourceBuild.Intermediate.emsdk , Microsoft.NET.Runtime.Emscripten.3.1.34.Python.win-x64 , Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport\n From Version 9.0.0-preview.3.24160.1 -> To Version 9.0.0-preview.4.24172.11\n\nDependency coherency updates\n\nruntime.linux-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-musl-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.win-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.win-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.osx-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.osx-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.linux-musl-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-musl-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.osx-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.osx-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.osx-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.osx-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools\n From Version 16.0.5-alpha.1.24154.3 -> To Version 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport",
+          "committedDate": "2024-03-23T12:26:40Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "23cba010a5bb5a18780025bed4fd832593bae113",
+          "message": "Update dependencies from https://github.com/dotnet/emsdk build\n\nMicrosoft.SourceBuild.Intermediate.emsdk , Microsoft.NET.Runtime.Emscripten.3.1.34.Python.win-x64 , Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport\n From Version 9.0.0-preview.3.24160.1 -> To Version 9.0.0-preview.4.24172.11\n\nDependency coherency updates\n\nruntime.linux-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-musl-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.win-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.win-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.osx-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.osx-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.linux-musl-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-musl-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.osx-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.osx-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.osx-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.osx-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools\n From Version 16.0.5-alpha.1.24154.3 -> To Version 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport",
+          "committedDate": "2024-03-24T12:20:40Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "0d9561da446e7b9ec92d857e4c97219147016c89",
+          "message": "Update dependencies from https://github.com/dotnet/emsdk build\n\nMicrosoft.SourceBuild.Intermediate.emsdk , Microsoft.NET.Runtime.Emscripten.3.1.34.Python.win-x64 , Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport\n From Version 9.0.0-preview.3.24160.1 -> To Version 9.0.0-preview.4.24172.11\n\nDependency coherency updates\n\nruntime.linux-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-musl-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.win-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.win-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.osx-arm64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.osx-x64.Microsoft.NETCore.Runtime.JIT.Tools,runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-musl-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.linux-musl-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.linux-musl-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.win-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.osx-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.osx-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools,runtime.osx-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk,runtime.osx-x64.Microsoft.NETCore.Runtime.Mono.LLVM.Tools\n From Version 16.0.5-alpha.1.24154.3 -> To Version 16.0.5-alpha.1.24169.1 (parent: Microsoft.NET.Workload.Emscripten.Current.Manifest-9.0.100.Transport",
+          "committedDate": "2024-03-25T12:17:28Z"
+        }
+      }
+    ]
+  }
+}

data/raw_sample/prs/pr-100012.json

@@ -0,0 +1,50 @@
+{
+  "number": 100012,
+  "title": "[main] Update dependencies from dotnet/roslyn-analyzers",
+  "body": "This pull request updates the following dependencies\r\n\r\n[marker]: <> (Begin:5465c78f-1281-49a8-f9b0-08d9301a7704)\r\n## From https://github.com/dotnet/roslyn-analyzers\r\n- **Subscription**: 5465c78f-1281-49a8-f9b0-08d9301a7704\r\n- **Build**: \r\n- **Date Produced**: March 20, 2024 10:47:31 PM UTC\r\n- **Commit**: 29bdbf5df540dc13d4fe440a1ca7076c6ed65864\r\n- **Branch**: refs/heads/main\r\n\r\n[DependencyUpdate]: <> (Begin)\r\n\r\n- **Updates**:\r\n  - **Microsoft.CodeAnalysis.Analyzers**: [from 3.11.0-beta1.24158.2 to 3.11.0-beta1.24170.2][2]\r\n  - **Microsoft.CodeAnalysis.NetAnalyzers**: [from 9.0.0-preview.24158.2 to 9.0.0-preview.24170.2][2]\r\n\r\n[2]: https://github.com/dotnet/roslyn-analyzers/compare/94749ce487...29bdbf5df5\r\n\r\n[DependencyUpdate]: <> (End)\r\n\r\n\r\n[marker]: <> (End:5465c78f-1281-49a8-f9b0-08d9301a7704)\r\n\r\n\r\n\r\n",
+  "createdAt": "2024-03-20T12:26:35Z",
+  "closedAt": "2024-03-22T00:32:43Z",
+  "mergedAt": "2024-03-22T00:32:43Z",
+  "state": "MERGED",
+  "author": {
+    "login": "dotnet-maestro"
+  },
+  "labels": {
+    "nodes": [
+      {
+        "name": "area-codeflow"
+      }
+    ]
+  },
+  "headRefName": "darc-main-2e69a06b-9639-45b0-beab-3567d9f4b9f0",
+  "additions": 6,
+  "deletions": 6,
+  "changedFiles": 2,
+  "comments": {
+    "totalCount": 0,
+    "nodes": []
+  },
+  "reviewThreads": {
+    "totalCount": 0,
+    "nodes": []
+  },
+  "commits": {
+    "totalCount": 2,
+    "nodes": [
+      {
+        "commit": {
+          "oid": "5c74dfc928c1a258dd1e1a9d39ba135d5d57e893",
+          "message": "Update dependencies from https://github.com/dotnet/roslyn-analyzers build\n\nMicrosoft.CodeAnalysis.Analyzers , Microsoft.CodeAnalysis.NetAnalyzers\n From Version 3.11.0-beta1.24158.2 -> To Version 3.11.0-beta1.24169.2",
+          "committedDate": "2024-03-20T12:26:31Z"
+        }
+      },
+      {
+        "commit": {
+          "oid": "5eee4dfb3dabed4d6d7f27d650fa774001d73496",
+          "message": "Update dependencies from https://github.com/dotnet/roslyn-analyzers build\n\nMicrosoft.CodeAnalysis.Analyzers , Microsoft.CodeAnalysis.NetAnalyzers\n From Version 3.11.0-beta1.24158.2 -> To Version 3.11.0-beta1.24170.2",
+          "committedDate": "2024-03-21T12:26:17Z"
+        }
+      }
+    ]
+  }
+}