Add [RequiresUnsafe] to all extern and LibraryImport methods (repo-wide) + IL5005/IL5006 diagnostics

Directory.Build.props

@@ -285,6 +285,10 @@
     <WarningsNotAsErrors Condition="'$(OfficialBuild)' != 'true' OR '$(NuGetAuditWarnNotError)' == 'true'">$(WarningsNotAsErrors);NU1901;NU1902;NU1903;NU1904</WarningsNotAsErrors>
     <!-- Warnings to always disable -->
     <NoWarn>$(NoWarn);CS8500;CS8969</NoWarn>
+
+    <!-- Temporarily suppress ILLink RequiresUnsafe call-site and annotation-mismatch diagnostics for the entire repo. -->
+    <NoWarn>$(NoWarn);IL5000;IL5001</NoWarn>
+
     <!-- Suppress "CS1591 - Missing XML comment for publicly visible type or member" compiler errors for private assemblies. -->
     <NoWarn Condition="'$(IsPrivateAssembly)' == 'true'">$(NoWarn);CS1591</NoWarn>
     <!-- Always pass portable to override arcade sdk which uses embedded for local builds -->

eng/Analyzers.targets

@@ -16,6 +16,9 @@
       '$(EnableSingleFileAnalyzer)' == '' and
       '$(TargetFrameworkIdentifier)' == '.NETCoreApp' and
       '$(IsSourceProject)' == 'true'">true</EnableSingleFileAnalyzer>
+    <EnableUnsafeAnalyzer Condition="
+      '$(EnableUnsafeAnalyzer)' == '' and
+      '$(IsSourceProject)' == 'true'">true</EnableUnsafeAnalyzer>
   </PropertyGroup>
   <ItemGroup Condition="'$(RunAnalyzers)' != 'false'">
     <EditorConfigFiles Include="$(MSBuildThisFileDirectory)CodeAnalysis.src.globalconfig" />

eng/ApiCompatExcludeAttributes.txt

@@ -1,4 +1,5 @@
 T:System.Diagnostics.CodeAnalysis.MemberNotNullAttribute
+T:System.Diagnostics.CodeAnalysis.RequiresUnsafeAttribute
 T:System.Diagnostics.DebuggerGuidedStepThroughAttribute
 T:System.Runtime.CompilerServices.EagerStaticClassConstructionAttribute
 T:System.Runtime.CompilerServices.NativeIntegerAttribute

src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs

@@ -10,9 +10,9 @@ namespace Internal.Runtime.CompilerHelpers
 {
     internal static unsafe partial class ThrowHelpers
     {
+        [RequiresUnsafe]
         [DoesNotReturn]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowAmbiguousResolutionException")]
-        [RequiresUnsafe]
         private static partial void ThrowAmbiguousResolutionException(MethodTable* targetType, MethodTable* interfaceType, void* methodDesc);
 
         [DoesNotReturn]
@@ -26,9 +26,9 @@ internal static void ThrowAmbiguousResolutionException(
             ThrowAmbiguousResolutionException((MethodTable*)targetType, (MethodTable*)interfaceType, method);
         }
 
+        [RequiresUnsafe]
         [DoesNotReturn]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowEntryPointNotFoundException")]
-        [RequiresUnsafe]
         private static partial void ThrowEntryPointNotFoundException(MethodTable* targetType, MethodTable* interfaceType, void* methodDesc);
 
         [DoesNotReturn]
@@ -42,9 +42,9 @@ internal static void ThrowEntryPointNotFoundException(
             ThrowEntryPointNotFoundException((MethodTable*)targetType, (MethodTable*)interfaceType, method);
         }
 
+        [RequiresUnsafe]
         [DoesNotReturn]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowMethodAccessException")]
-        [RequiresUnsafe]
         private static partial void ThrowMethodAccessExceptionInternal(void* caller, void* callee);
 
         // implementation of CORINFO_HELP_METHOD_ACCESS_EXCEPTION
@@ -58,9 +58,9 @@ internal static void ThrowMethodAccessException(
             ThrowMethodAccessExceptionInternal(caller, callee);
         }
 
+        [RequiresUnsafe]
         [DoesNotReturn]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowFieldAccessException")]
-        [RequiresUnsafe]
         private static partial void ThrowFieldAccessExceptionInternal(void* caller, void* callee);
 
         // implementation of CORINFO_HELP_FIELD_ACCESS_EXCEPTION
@@ -74,9 +74,9 @@ internal static void ThrowFieldAccessException(
             ThrowFieldAccessExceptionInternal(caller, callee);
         }
 
+        [RequiresUnsafe]
         [DoesNotReturn]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowClassAccessException")]
-        [RequiresUnsafe]
         private static partial void ThrowClassAccessExceptionInternal(void* caller, void* callee);
 
         // implementation of CORINFO_HELP_CLASS_ACCESS_EXCEPTION

src/coreclr/System.Private.CoreLib/src/Internal/Runtime/InteropServices/ComActivator.cs

@@ -710,12 +710,14 @@ internal sealed class LicenseInteropProxy
         private object? _licContext;
         private Type? _targetRcwType;
 
+        [RequiresUnsafe]
         [UnsafeAccessor(UnsafeAccessorKind.Method)]
         private static extern void SetSavedLicenseKey(
             [UnsafeAccessorType(LicenseContextTypeName)] object licContext,
             Type type,
             string key);
 
+        [RequiresUnsafe]
         [UnconditionalSuppressMessage("Trimming", "IL2111", Justification = "Manually validated that the annotations are kept in sync.")]
         [UnsafeAccessor(UnsafeAccessorKind.StaticMethod)]
         private static extern object? CreateWithContext(
@@ -724,6 +726,7 @@ private static extern void SetSavedLicenseKey(
             [UnsafeAccessorType(LicenseContextTypeName)] object licContext
         );
 
+        [RequiresUnsafe]
         [UnsafeAccessor(UnsafeAccessorKind.StaticMethod)]
         private static extern bool ValidateAndRetrieveLicenseDetails(
             [UnsafeAccessorType(LicenseInteropHelperTypeName)] object? licInteropHelper,
@@ -732,6 +735,7 @@ private static extern bool ValidateAndRetrieveLicenseDetails(
             [UnsafeAccessorType(LicenseRefTypeName)] out object? license,
             out string? licenseKey);
 
+        [RequiresUnsafe]
         [UnsafeAccessor(UnsafeAccessorKind.StaticMethod)]
         [return: UnsafeAccessorType(LicenseContextTypeName)]
         private static extern object? GetCurrentContextInfo(
@@ -740,23 +744,27 @@ private static extern bool ValidateAndRetrieveLicenseDetails(
             out bool isDesignTime,
             out string? key);
 
+        [RequiresUnsafe]
         [UnsafeAccessor(UnsafeAccessorKind.StaticMethod)]
         [return: UnsafeAccessorType(CLRLicenseContextTypeName)]
         private static extern object CreateDesignContext(
             [UnsafeAccessorType(CLRLicenseContextTypeName)] object? context,
             Type type);
 
+        [RequiresUnsafe]
         [UnsafeAccessor(UnsafeAccessorKind.StaticMethod)]
         [return: UnsafeAccessorType(CLRLicenseContextTypeName)]
         private static extern object CreateRuntimeContext(
             [UnsafeAccessorType(CLRLicenseContextTypeName)] object? context,
             Type type,
             string? key);
 
+        [RequiresUnsafe]
         [UnsafeAccessor(UnsafeAccessorKind.Constructor)]
         [return:UnsafeAccessorType(LicInfoHelperLicenseContextTypeName)]
         private static extern object CreateLicInfoHelperLicenseContext();
 
+        [RequiresUnsafe]
         [UnsafeAccessor(UnsafeAccessorKind.Method)]
         private static extern bool Contains(
             [UnsafeAccessorType(LicInfoHelperLicenseContextTypeName)] object? licInfoHelperContext,

src/coreclr/System.Private.CoreLib/src/Internal/VersionResilientHashCode.CoreCLR.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Reflection.Metadata;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -13,6 +14,7 @@ namespace Internal
     /// </summary>
     internal static partial class VersionResilientHashCode
     {
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "VersionResilientHashCode_TypeHashCode")]
         private static partial int TypeHashCode(QCallTypeHandle typeHandle);
 

src/coreclr/System.Private.CoreLib/src/System/AppContext.CoreCLR.cs

@@ -54,6 +54,7 @@ internal static unsafe void OnFirstChanceException(Exception* pException, Except
         internal static void SetFirstChanceExceptionHandler()
             => SetFirstChanceExceptionHandlerInternal();
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AppContext_SetFirstChanceExceptionHandler")]
         [SuppressGCTransition]
         private static partial void SetFirstChanceExceptionHandlerInternal();

src/coreclr/System.Private.CoreLib/src/System/ArgIterator.cs

@@ -40,6 +40,7 @@ public ArgIterator(RuntimeArgumentHandle arglist)
             Init(ThisPtr, cookie);
         }
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_Init")]
         private static partial void Init(ArgIterator* thisPtr, IntPtr cookie);
 
@@ -57,6 +58,7 @@ public ArgIterator(RuntimeArgumentHandle arglist, void* ptr)
             Init(ThisPtr, cookie, ptr);
         }
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_Init2")]
         private static partial void Init(ArgIterator* thisPtr, IntPtr cookie, void* ptr);
 
@@ -83,6 +85,7 @@ public TypedReference GetNextArg()
             return result;
         }
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_GetNextArg")]
         private static partial void GetNextArg(ArgIterator* thisPtr, TypedReference* pResult);
 
@@ -118,6 +121,7 @@ public TypedReference GetNextArg(RuntimeTypeHandle rth)
             return result;
         }
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_GetNextArg2")]
         private static partial void GetNextArg(ArgIterator* thisPtr, QCallTypeHandle rth, TypedReference* pResult);
 
@@ -143,6 +147,7 @@ public RuntimeTypeHandle GetNextArgType()
             return RuntimeTypeHandle.FromIntPtr(GetNextArgType(ThisPtr));
         }
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ArgIterator_GetNextArgType")]
         private static partial IntPtr GetNextArgType(ArgIterator* thisPtr);
 

src/coreclr/System.Private.CoreLib/src/System/Array.CoreCLR.cs

@@ -15,8 +15,8 @@ namespace System
     // IList<U> and IReadOnlyList<U>, where T : U dynamically.  See the SZArrayHelper class for details.
     public abstract partial class Array : ICloneable, IList, IStructuralComparable, IStructuralEquatable
     {
-        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_CreateInstance")]
         [RequiresUnsafe]
+        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_CreateInstance")]
         private static unsafe partial void InternalCreate(QCallTypeHandle type, int rank, int* pLengths, int* pLowerBounds,
             [MarshalAs(UnmanagedType.Bool)] bool fromArrayType, ObjectHandleOnStack retArray);
 
@@ -38,8 +38,8 @@ private static unsafe Array InternalCreateFromArrayType(RuntimeType arrayType, i
             return retArray!;
         }
 
-        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_Ctor")]
         [RequiresUnsafe]
+        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_Ctor")]
         private static unsafe partial void Ctor(MethodTable* pArrayMT, uint dwNumArgs, int* pArgList, ObjectHandleOnStack retArray);
 
         // implementation of CORINFO_HELP_NEW_MDARR and CORINFO_HELP_NEW_MDARR_RARE.
@@ -355,8 +355,8 @@ internal sealed unsafe partial class ArrayInitializeCache : RuntimeType.IGeneric
         {
             internal readonly delegate*<ref byte, void> ConstructorEntrypoint;
 
-            [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_GetElementConstructorEntrypoint")]
             [RequiresUnsafe]
+            [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Array_GetElementConstructorEntrypoint")]
             private static partial delegate*<ref byte, void> GetElementConstructorEntrypoint(QCallTypeHandle arrayType);
 
             [RequiresUnsafe]

src/coreclr/System.Private.CoreLib/src/System/CLRConfig.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -15,6 +16,7 @@ internal static bool GetBoolValue(string switchName, out bool exist)
             return GetConfigBoolValue(switchName, out exist);
         }
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ClrConfig_GetConfigBoolValue", StringMarshalling = StringMarshalling.Utf16)]
         [return: MarshalAs(UnmanagedType.Bool)]
         private static partial bool GetConfigBoolValue(string configSwitchName, [MarshalAs(UnmanagedType.Bool)] out bool exist);

src/coreclr/System.Private.CoreLib/src/System/ComAwareWeakReference.CoreCLR.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -9,6 +10,7 @@ namespace System
 {
     internal sealed partial class ComAwareWeakReference
     {
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWeakRefToObject")]
         private static partial void ComWeakRefToObject(IntPtr pComWeakRef, ObjectHandleOnStack retRcw);
 
@@ -38,6 +40,7 @@ internal static bool PossiblyComObject(object target)
 #endif // FEATURE_COMINTEROP
         }
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectToComWeakRef")]
         private static partial IntPtr ObjectToComWeakRef(ObjectHandleOnStack retRcw);
 

src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs

@@ -415,6 +415,7 @@ private bool BindToMethodName(object? target, [DynamicallyAccessedMembers(Dynami
                 new QCallTypeHandle(ref methodType), method, flags);
         }
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_BindToMethodName", StringMarshalling = StringMarshalling.Utf8)]
         [return: MarshalAs(UnmanagedType.Bool)]
         private static partial bool BindToMethodName(ObjectHandleOnStack d, ObjectHandleOnStack target, QCallTypeHandle methodType, string method, DelegateBindingFlags flags);
@@ -428,6 +429,7 @@ private bool BindToMethodInfo(object? target, IRuntimeMethodInfo method, Runtime
             return ret;
         }
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_BindToMethodInfo")]
         [return: MarshalAs(UnmanagedType.Bool)]
         private static partial bool BindToMethodInfo(ObjectHandleOnStack d, ObjectHandleOnStack target, RuntimeMethodHandleInternal method, QCallTypeHandle methodType, DelegateBindingFlags flags);
@@ -479,15 +481,16 @@ private void DelegateConstruct(object target, IntPtr method)
             Construct(ObjectHandleOnStack.Create(ref _this), ObjectHandleOnStack.Create(ref target), method);
         }
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_Construct")]
         private static partial void Construct(ObjectHandleOnStack _this, ObjectHandleOnStack target, IntPtr method);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         [RequiresUnsafe]
         private static extern unsafe void* GetMulticastInvoke(MethodTable* pMT);
 
-        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_GetMulticastInvokeSlow")]
         [RequiresUnsafe]
+        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_GetMulticastInvokeSlow")]
         private static unsafe partial void* GetMulticastInvokeSlow(MethodTable* pMT);
 
         internal unsafe IntPtr GetMulticastInvoke()
@@ -524,6 +527,7 @@ internal IRuntimeMethodInfo FindMethodHandle()
             return methodInfo!;
         }
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_FindMethodHandle")]
         private static partial void FindMethodHandle(ObjectHandleOnStack d, ObjectHandleOnStack retMethodInfo);
 
@@ -532,6 +536,7 @@ private static bool InternalEqualMethodHandles(Delegate left, Delegate right)
             return InternalEqualMethodHandles(ObjectHandleOnStack.Create(ref left), ObjectHandleOnStack.Create(ref right));
         }
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_InternalEqualMethodHandles")]
         [return: MarshalAs(UnmanagedType.Bool)]
         private static partial bool InternalEqualMethodHandles(ObjectHandleOnStack left, ObjectHandleOnStack right);
@@ -541,6 +546,7 @@ internal static IntPtr AdjustTarget(object target, IntPtr methodPtr)
             return AdjustTarget(ObjectHandleOnStack.Create(ref target), methodPtr);
         }
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_AdjustTarget")]
         private static partial IntPtr AdjustTarget(ObjectHandleOnStack target, IntPtr methodPtr);
 
@@ -550,6 +556,7 @@ internal void InitializeVirtualCallStub(IntPtr methodPtr)
             InitializeVirtualCallStub(ObjectHandleOnStack.Create(ref d), methodPtr);
         }
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_InitializeVirtualCallStub")]
         private static partial void InitializeVirtualCallStub(ObjectHandleOnStack d, IntPtr methodPtr);
 

src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs

@@ -4,13 +4,15 @@
 // The Debugger class is a part of the System.Diagnostics package
 // and is used for communicating with a debugger.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace System.Diagnostics
 {
     public static partial class Debugger
     {
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_Break")]
         private static partial void BreakInternal();
 
@@ -54,13 +56,15 @@ static void NotifyOfCrossThreadDependencySlow()
             }
         }
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_Launch")]
         [return: MarshalAs(UnmanagedType.Bool)]
         private static partial bool LaunchInternal();
 
         // Returns whether or not a managed debugger is attached to the process.
         public static bool IsAttached => IsManagedDebuggerAttached() != 0;
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_IsManagedDebuggerAttached")]
         [SuppressGCTransition]
         private static partial int IsManagedDebuggerAttached();
@@ -70,19 +74,22 @@ static void NotifyOfCrossThreadDependencySlow()
         // report the message depending on its settings.
         public static void Log(int level, string? category, string? message) => LogInternal(level, category, message);
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_Log", StringMarshalling = StringMarshalling.Utf16)]
         private static partial void LogInternal(int level, string? category, string? message);
 
         // Checks to see if an attached debugger has logging enabled
         public static bool IsLogging() => IsLoggingInternal() != 0;
 
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_IsLoggingHelper")]
         [SuppressGCTransition]
         private static partial int IsLoggingInternal();
 
         // Posts a custom notification for the attached debugger.  If there is no
         // debugger attached, has no effect.  The debugger may or may not
         // report the notification depending on its settings.
+        [RequiresUnsafe]
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_CustomNotification")]
         private static partial void CustomNotification(ObjectHandleOnStack data);