Wrap any ?? throw news that go beyond 120 characters

stephentoub · stephentoub · commit 03576a142719 · 2024-07-24T23:35:53.000-04:00
diff --git a/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/InteropServices/InMemoryAssemblyLoader.cs b/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/InteropServices/InMemoryAssemblyLoader.cs
@@ -69,7 +69,8 @@ public static unsafe void LoadInMemoryAssemblyInContext(IntPtr moduleHandle, Int
         [RequiresUnreferencedCode("C++/CLI is not trim-compatible", Url = "https://aka.ms/dotnet-illink/nativehost")]
         private static void LoadInMemoryAssemblyInContextImpl(IntPtr moduleHandle, IntPtr assemblyPath, AssemblyLoadContext? alc = null)
         {
-            string assemblyPathString = Marshal.PtrToStringUni(assemblyPath) ?? throw new ArgumentOutOfRangeException(nameof(assemblyPath));
+            string assemblyPathString = Marshal.PtrToStringUni(assemblyPath) ??
+                throw new ArgumentOutOfRangeException(nameof(assemblyPath));
 
             // We don't cache the ALCs or resolvers here since each IJW assembly will call this method at most once
             // (the load process rewrites the stubs that call here to call the actual methods they're supposed to)
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs
@@ -85,7 +85,6 @@ protected Delegate([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Al
             return invoke.Invoke(this, BindingFlags.Default, null, args, null);
         }
 
-
         public override bool Equals([NotNullWhen(true)] object? obj)
         {
             if (obj == null || !InternalEqualTypes(this, obj))
@@ -107,9 +106,11 @@ public override bool Equals([NotNullWhen(true)] object? obj)
             {
                 if (d._methodPtrAux != IntPtr.Zero)
                     return false; // different delegate kind
+
                 // they are both closed over the first arg
                 if (_target != d._target)
                     return false;
+
                 // fall through method handle check
             }
             else
@@ -121,19 +122,20 @@ public override bool Equals([NotNullWhen(true)] object? obj)
                 /*
                 if (_methodPtr != d._methodPtr)
                     return false;
-                    */
+                */
 
                 if (_methodPtrAux == d._methodPtrAux)
                     return true;
+
                 // fall through method handle check
             }
 
             // method ptrs don't match, go down long path
-            //
-            if (_methodBase == null || d._methodBase == null || _methodBase is not MethodInfo || d._methodBase is not MethodInfo)
-                return InternalEqualMethodHandles(this, d);
-            else
+
+            if (_methodBase is MethodInfo && d._methodBase is MethodInfo)
                 return _methodBase.Equals(d._methodBase);
+            else
+                return InternalEqualMethodHandles(this, d);
         }
 
         public override int GetHashCode()
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicILGenerator.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicILGenerator.cs
@@ -61,20 +61,24 @@ public override void Emit(OpCode opcode, MethodInfo meth)
             DynamicMethod? dynMeth = meth as DynamicMethod;
             if (dynMeth == null)
             {
-                RuntimeMethodInfo rtMeth = meth as RuntimeMethodInfo ?? throw new ArgumentException(SR.Argument_MustBeRuntimeMethodInfo, nameof(meth));
+                RuntimeMethodInfo rtMeth = meth as RuntimeMethodInfo ??
+                    throw new ArgumentException(SR.Argument_MustBeRuntimeMethodInfo, nameof(meth));
+
                 RuntimeType declaringType = rtMeth.GetRuntimeType();
-                if (declaringType != null && (declaringType.IsGenericType || declaringType.IsArray))
-                    token = GetTokenFor(rtMeth, declaringType);
-                else
-                    token = GetTokenFor(rtMeth);
+                token = declaringType != null && (declaringType.IsGenericType || declaringType.IsArray) ?
+                    GetTokenFor(rtMeth, declaringType) :
+                    GetTokenFor(rtMeth);
             }
             else
             {
                 // rule out not allowed operations on DynamicMethods
-                if (opcode.Equals(OpCodes.Ldtoken) || opcode.Equals(OpCodes.Ldftn) || opcode.Equals(OpCodes.Ldvirtftn))
+                if (opcode.Equals(OpCodes.Ldtoken) ||
+                    opcode.Equals(OpCodes.Ldftn) ||
+                    opcode.Equals(OpCodes.Ldvirtftn))
                 {
                     throw new ArgumentException(SR.Argument_InvalidOpCodeOnDynamicMethod);
                 }
+
                 token = GetTokenFor(dynMeth);
             }
 
@@ -106,15 +110,13 @@ public override void Emit(OpCode opcode, ConstructorInfo con)
         {
             ArgumentNullException.ThrowIfNull(con);
 
-            RuntimeConstructorInfo rtConstructor = con as RuntimeConstructorInfo ?? throw new ArgumentException(SR.Argument_MustBeRuntimeMethodInfo, nameof(con));
-            RuntimeType declaringType = rtConstructor.GetRuntimeType();
-            int token;
+            RuntimeConstructorInfo rtConstructor = con as RuntimeConstructorInfo ??
+                throw new ArgumentException(SR.Argument_MustBeRuntimeMethodInfo, nameof(con));
 
-            if (declaringType != null && (declaringType.IsGenericType || declaringType.IsArray))
-                // need to sort out the stack size story
-                token = GetTokenFor(rtConstructor, declaringType);
-            else
-                token = GetTokenFor(rtConstructor);
+            RuntimeType declaringType = rtConstructor.GetRuntimeType();
+            int token = declaringType != null && (declaringType.IsGenericType || declaringType.IsArray) ?
+                GetTokenFor(rtConstructor, declaringType) : // need to sort out the stack size story
+                GetTokenFor(rtConstructor);
 
             EnsureCapacity(7);
             InternalEmit(opcode);
@@ -139,12 +141,12 @@ public override void Emit(OpCode opcode, FieldInfo field)
         {
             ArgumentNullException.ThrowIfNull(field);
 
-            RuntimeFieldInfo runtimeField = field as RuntimeFieldInfo ?? throw new ArgumentException(SR.Argument_MustBeRuntimeFieldInfo, nameof(field));
-            int token;
-            if (field.DeclaringType == null)
-                token = GetTokenFor(runtimeField);
-            else
-                token = GetTokenFor(runtimeField, runtimeField.GetRuntimeType());
+            RuntimeFieldInfo runtimeField = field as RuntimeFieldInfo ??
+                throw new ArgumentException(SR.Argument_MustBeRuntimeFieldInfo, nameof(field));
+
+            int token = field.DeclaringType == null ?
+                GetTokenFor(runtimeField) :
+                GetTokenFor(runtimeField, runtimeField.GetRuntimeType());
 
             EnsureCapacity(7);
             InternalEmit(opcode);
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs
@@ -252,7 +252,9 @@ public override int GetMethodMetadataToken(ConstructorInfo constructor)
             {
                 // some user derived ConstructorInfo
                 // go through the slower code path, i.e. retrieve parameters and form signature helper.
-                ParameterInfo[] parameters = constructor.GetParameters() ?? throw new ArgumentException(SR.Argument_InvalidConstructorInfo);
+                ParameterInfo[] parameters = constructor.GetParameters() ??
+                    throw new ArgumentException(SR.Argument_InvalidConstructorInfo);
+
                 Type[] parameterTypes = new Type[parameters.Length];
                 Type[][] requiredCustomModifiers = new Type[parameters.Length][];
                 Type[][] optionalCustomModifiers = new Type[parameters.Length][];
@@ -990,7 +992,9 @@ private int GetMethodTokenNoLock(MethodInfo method, bool getGenericTypeDefinitio
             }
             else
             {
-                Type declaringType = method.DeclaringType ?? throw new InvalidOperationException(SR.InvalidOperation_CannotImportGlobalFromDifferentModule);
+                Type declaringType = method.DeclaringType ??
+                    throw new InvalidOperationException(SR.InvalidOperation_CannotImportGlobalFromDifferentModule);
+
                 if (declaringType.IsArray)
                 {
                     // use reflection to build signature to work around the E_T_VAR problem in EEClass
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/SignatureHelper.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/SignatureHelper.cs
@@ -276,7 +276,9 @@ private void AddOneArgTypeHelper(Type clsArgument, Type[]? requiredCustomModifie
             {
                 for (int i = 0; i < optionalCustomModifiers.Length; i++)
                 {
-                    Type t = optionalCustomModifiers[i] ?? throw new ArgumentNullException(nameof(optionalCustomModifiers));
+                    Type t = optionalCustomModifiers[i] ??
+                        throw new ArgumentNullException(nameof(optionalCustomModifiers));
+
                     if (t.HasElementType)
                         throw new ArgumentException(SR.Argument_ArraysInvalid, nameof(optionalCustomModifiers));
 
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeMethodInfo.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeMethodInfo.CoreCLR.cs
@@ -380,12 +380,14 @@ private Delegate CreateDelegateInternal(Type delegateType, object? firstArgument
         {
             ArgumentNullException.ThrowIfNull(delegateType);
 
-            RuntimeType rtType = delegateType as RuntimeType ?? throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(delegateType));
+            RuntimeType rtType = delegateType as RuntimeType ??
+                throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(delegateType));
+
             if (!rtType.IsDelegate())
                 throw new ArgumentException(SR.Arg_MustBeDelegate, nameof(delegateType));
 
-            Delegate d = Delegate.CreateDelegateInternal(rtType, this, firstArgument, bindingFlags) ?? throw new ArgumentException(SR.Arg_DlgtTargMeth);
-            return d;
+            return Delegate.CreateDelegateInternal(rtType, this, firstArgument, bindingFlags) ??
+                throw new ArgumentException(SR.Arg_DlgtTargMeth);
         }
 
         #endregion
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeModule.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeModule.cs
@@ -33,12 +33,11 @@ internal sealed partial class RuntimeModule : Module
             RuntimeTypeHandle[] typeHandleArgs = new RuntimeTypeHandle[size];
             for (int i = 0; i < size; i++)
             {
-                Type typeArg = genericArguments[i] ?? throw new ArgumentException(SR.Argument_InvalidGenericInstArray);
-                typeArg = typeArg.UnderlyingSystemType;
-                if (typeArg == null)
-                    throw new ArgumentException(SR.Argument_InvalidGenericInstArray);
+                Type? typeArg = genericArguments[i]?.UnderlyingSystemType;
+
                 if (typeArg is not System.RuntimeType)
                     throw new ArgumentException(SR.Argument_InvalidGenericInstArray);
+
                 typeHandleArgs[i] = typeArg.TypeHandle;
             }
             return typeHandleArgs;
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs
@@ -167,7 +167,9 @@ private static unsafe ref byte GetSpanDataFrom(
         [RequiresUnreferencedCode("Trimmer can't guarantee existence of class constructor")]
         public static void RunClassConstructor(RuntimeTypeHandle type)
         {
-            RuntimeType rt = type.GetRuntimeType() ?? throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, nameof(type));
+            RuntimeType rt = type.GetRuntimeType() ??
+                throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, nameof(type));
+
             RunClassConstructor(new QCallTypeHandle(ref rt));
         }
 
@@ -184,7 +186,9 @@ public static void RunClassConstructor(RuntimeTypeHandle type)
 
         public static void RunModuleConstructor(ModuleHandle module)
         {
-            RuntimeModule rm = module.GetRuntimeModule() ?? throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, nameof(module));
+            RuntimeModule rm = module.GetRuntimeModule() ??
+                throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, nameof(module));
+
             RunModuleConstructor(new QCallModule(ref rm));
         }
 
@@ -198,7 +202,8 @@ public static void RunModuleConstructor(ModuleHandle module)
 
         public static unsafe void PrepareMethod(RuntimeMethodHandle method, RuntimeTypeHandle[]? instantiation)
         {
-            IRuntimeMethodInfo methodInfo = method.GetMethodInfo() ?? throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, nameof(method));
+            IRuntimeMethodInfo methodInfo = method.GetMethodInfo() ??
+                throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, nameof(method));
 
             // defensive copy of user-provided array, per CopyRuntimeTypeHandles contract
             instantiation = (RuntimeTypeHandle[]?)instantiation?.Clone();
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs
@@ -37,7 +37,9 @@ public static IntPtr OffsetOf(Type t, string fieldName)
         {
             ArgumentNullException.ThrowIfNull(t);
 
-            FieldInfo f = t.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) ?? throw new ArgumentException(SR.Format(SR.Argument_OffsetOfFieldNotFound, t.FullName), nameof(fieldName));
+            FieldInfo f = t.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) ??
+                throw new ArgumentException(SR.Format(SR.Argument_OffsetOfFieldNotFound, t.FullName), nameof(fieldName));
+
             if (f is not RtFieldInfo rtField)
             {
                 throw new ArgumentException(SR.Argument_MustBeRuntimeFieldInfo, nameof(fieldName));
diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs
@@ -2730,7 +2730,9 @@ public override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(Dyn
 
             ArgumentNullException.ThrowIfNull(interfaceType);
 
-            RuntimeType ifaceRtType = interfaceType as RuntimeType ?? throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(interfaceType));
+            RuntimeType ifaceRtType = interfaceType as RuntimeType ??
+                throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(interfaceType));
+
             RuntimeTypeHandle ifaceRtTypeHandle = ifaceRtType.TypeHandle;
 
             TypeHandle.VerifyInterfaceIsImplemented(ifaceRtTypeHandle);
diff --git a/src/libraries/System.Private.CoreLib/src/Internal/Runtime/InteropServices/ComponentActivator.cs b/src/libraries/System.Private.CoreLib/src/Internal/Runtime/InteropServices/ComponentActivator.cs
@@ -329,8 +329,9 @@ private static IntPtr InternalGetFunctionPointer(AssemblyLoadContext alc,
             if (delegateType == null)
             {
                 // Match search semantics of the CreateDelegate() function below.
-                BindingFlags bindingFlags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
-                MethodInfo methodInfo = type.GetMethod(methodName, bindingFlags) ?? throw new MissingMethodException(typeName, methodName);
+                const BindingFlags bindingFlags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
+                MethodInfo methodInfo = type.GetMethod(methodName, bindingFlags) ??
+                    throw new MissingMethodException(typeName, methodName);
 
                 // Verify the function is properly marked.
                 if (null == methodInfo.GetCustomAttribute<UnmanagedCallersOnlyAttribute>())
diff --git a/src/libraries/System.Private.CoreLib/src/System/AppDomain.cs b/src/libraries/System.Private.CoreLib/src/System/AppDomain.cs
@@ -134,7 +134,9 @@ public int ExecuteAssembly(string assemblyFile, string?[]? args, byte[]? hashVal
 
         private static int ExecuteAssembly(Assembly assembly, string?[]? args)
         {
-            MethodInfo entry = assembly.EntryPoint ?? throw new MissingMethodException(SR.Arg_EntryPointNotFoundException);
+            MethodInfo entry = assembly.EntryPoint ??
+                throw new MissingMethodException(SR.Arg_EntryPointNotFoundException);
+
             object? result = entry.Invoke(
                 obj: null,
                 invokeAttr: BindingFlags.DoNotWrapExceptions,
@@ -419,7 +421,8 @@ public void SetThreadPrincipal(IPrincipal principal)
                         if (s_getWindowsPrincipal == null)
                         {
                             Type type = Type.GetType("System.Security.Principal.WindowsPrincipal, System.Security.Principal.Windows", throwOnError: true)!;
-                            MethodInfo mi = type.GetMethod("GetDefaultInstance", BindingFlags.NonPublic | BindingFlags.Static) ?? throw new PlatformNotSupportedException(SR.PlatformNotSupported_Principal);
+                            MethodInfo mi = type.GetMethod("GetDefaultInstance", BindingFlags.NonPublic | BindingFlags.Static) ??
+                                throw new PlatformNotSupportedException(SR.PlatformNotSupported_Principal);
                             s_getWindowsPrincipal = mi.CreateDelegate<Func<IPrincipal>>();
                         }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/CultureInfo.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/CultureInfo.cs
@@ -164,8 +164,8 @@ public CultureInfo(string name, bool useUserOverride)
             ArgumentNullException.ThrowIfNull(name);
 
             // Get our data providing record
-            CultureData cultureData = CultureData.GetCultureData(name, useUserOverride) ?? throw new CultureNotFoundException(nameof(name), name, GetCultureNotSupportedExceptionMessage());
-            _cultureData = cultureData;
+            _cultureData = CultureData.GetCultureData(name, useUserOverride) ??
+                throw new CultureNotFoundException(nameof(name), name, GetCultureNotSupportedExceptionMessage());
             _name = _cultureData.CultureName;
             _isInherited = GetType() != typeof(CultureInfo);
         }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Reflection/Emit/ILGenerator.cs b/src/libraries/System.Private.CoreLib/src/System/Reflection/Emit/ILGenerator.cs
@@ -119,18 +119,18 @@ public virtual void EmitWriteLine(LocalBuilder localBuilder)
             // one of the types for which Console.WriteLine implements overloads. (e.g.
             // we do *not* call ToString on the locals.
 
-            Type consoleType = Type.GetType(ConsoleTypeFullName, throwOnError: true)!;
-            MethodInfo prop = consoleType.GetMethod("get_Out")!;
-            Emit(OpCodes.Call, prop);
+            Emit(OpCodes.Call, Type.GetType(ConsoleTypeFullName, throwOnError: true)!.GetMethod("get_Out")!);
             Emit(OpCodes.Ldloc, localBuilder);
-            Type[] parameterTypes = new Type[1];
+
             Type cls = localBuilder.LocalType;
-            if (cls is TypeBuilder || cls is EnumBuilder)
+            if (cls is TypeBuilder or EnumBuilder)
             {
                 throw new ArgumentException(SR.NotSupported_OutputStreamUsingTypeBuilder);
             }
-            parameterTypes[0] = cls;
-            MethodInfo mi = typeof(IO.TextWriter).GetMethod("WriteLine", parameterTypes) ?? throw new ArgumentException(SR.Argument_EmitWriteLineType, nameof(localBuilder));
+
+            MethodInfo mi = typeof(IO.TextWriter).GetMethod("WriteLine", [cls]) ??
+                throw new ArgumentException(SR.Argument_EmitWriteLineType, nameof(localBuilder));
+
             Emit(OpCodes.Callvirt, mi);
         }
 
@@ -142,9 +142,7 @@ public virtual void EmitWriteLine(FieldInfo fld)
             // an error to call EmitWriteLine with a fld which is not of
             // one of the types for which Console.WriteLine implements overloads. (e.g.
             // we do *not* call ToString on the fields.
-            Type consoleType = Type.GetType(ConsoleTypeFullName, throwOnError: true)!;
-            MethodInfo prop = consoleType.GetMethod("get_Out")!;
-            Emit(OpCodes.Call, prop);
+            Emit(OpCodes.Call, Type.GetType(ConsoleTypeFullName, throwOnError: true)!.GetMethod("get_Out")!);
 
             if ((fld.Attributes & FieldAttributes.Static) != 0)
             {
@@ -155,14 +153,16 @@ public virtual void EmitWriteLine(FieldInfo fld)
                 Emit(OpCodes.Ldarg_0); // Load the this ref.
                 Emit(OpCodes.Ldfld, fld);
             }
-            Type[] parameterTypes = new Type[1];
+
             Type cls = fld.FieldType;
-            if (cls is TypeBuilder || cls is EnumBuilder)
+            if (cls is TypeBuilder or EnumBuilder)
             {
                 throw new NotSupportedException(SR.NotSupported_OutputStreamUsingTypeBuilder);
             }
-            parameterTypes[0] = cls;
-            MethodInfo mi = typeof(IO.TextWriter).GetMethod("WriteLine", parameterTypes) ?? throw new ArgumentException(SR.Argument_EmitWriteLineType, nameof(fld));
+
+            MethodInfo mi = typeof(IO.TextWriter).GetMethod("WriteLine", [cls]) ??
+                throw new ArgumentException(SR.Argument_EmitWriteLineType, nameof(fld));
+
             Emit(OpCodes.Callvirt, mi);
         }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Resources/RuntimeResourceSet.cs b/src/libraries/System.Private.CoreLib/src/System/Resources/RuntimeResourceSet.cs
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.cs

Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,8 @@ public static unsafe void LoadInMemoryAssemblyInContext(IntPtr moduleHandle, Int`
`69`	`69`	`[RequiresUnreferencedCode("C++/CLI is not trim-compatible", Url = "https://aka.ms/dotnet-illink/nativehost")]`
`70`	`70`	`private static void LoadInMemoryAssemblyInContextImpl(IntPtr moduleHandle, IntPtr assemblyPath, AssemblyLoadContext? alc = null)`
`71`	`71`	`{`
`72`		`- string assemblyPathString = Marshal.PtrToStringUni(assemblyPath) ?? throw new ArgumentOutOfRangeException(nameof(assemblyPath));`
	`72`	`+ string assemblyPathString = Marshal.PtrToStringUni(assemblyPath) ??`
	`73`	`+ throw new ArgumentOutOfRangeException(nameof(assemblyPath));`
`73`	`74`
`74`	`75`	`// We don't cache the ALCs or resolvers here since each IJW assembly will call this method at most once`
`75`	`76`	`// (the load process rewrites the stubs that call here to call the actual methods they're supposed to)`
Original file line number	Diff line number	Diff line change
`@@ -252,7 +252,9 @@ public override int GetMethodMetadataToken(ConstructorInfo constructor)`
`252`	`252`	`{`
`253`	`253`	`// some user derived ConstructorInfo`
`254`	`254`	`// go through the slower code path, i.e. retrieve parameters and form signature helper.`
`255`		`- ParameterInfo[] parameters = constructor.GetParameters() ?? throw new ArgumentException(SR.Argument_InvalidConstructorInfo);`
	`255`	`+ ParameterInfo[] parameters = constructor.GetParameters() ??`
	`256`	`+ throw new ArgumentException(SR.Argument_InvalidConstructorInfo);`
	`257`	`+`
`256`	`258`	`Type[] parameterTypes = new Type[parameters.Length];`
`257`	`259`	`Type[][] requiredCustomModifiers = new Type[parameters.Length][];`
`258`	`260`	`Type[][] optionalCustomModifiers = new Type[parameters.Length][];`
`@@ -990,7 +992,9 @@ private int GetMethodTokenNoLock(MethodInfo method, bool getGenericTypeDefinitio`
`990`	`992`	`}`
`991`	`993`	`else`
`992`	`994`	`{`
`993`		`- Type declaringType = method.DeclaringType ?? throw new InvalidOperationException(SR.InvalidOperation_CannotImportGlobalFromDifferentModule);`
	`995`	`+ Type declaringType = method.DeclaringType ??`
	`996`	`+ throw new InvalidOperationException(SR.InvalidOperation_CannotImportGlobalFromDifferentModule);`
	`997`	`+`
`994`	`998`	`if (declaringType.IsArray)`
`995`	`999`	`{`
`996`	`1000`	`// use reflection to build signature to work around the E_T_VAR problem in EEClass`
Original file line number	Diff line number	Diff line change
`@@ -276,7 +276,9 @@ private void AddOneArgTypeHelper(Type clsArgument, Type[]? requiredCustomModifie`
`276`	`276`	`{`
`277`	`277`	`for (int i = 0; i < optionalCustomModifiers.Length; i++)`
`278`	`278`	`{`
`279`		`- Type t = optionalCustomModifiers[i] ?? throw new ArgumentNullException(nameof(optionalCustomModifiers));`
	`279`	`+ Type t = optionalCustomModifiers[i] ??`
	`280`	`+ throw new ArgumentNullException(nameof(optionalCustomModifiers));`
	`281`	`+`
`280`	`282`	`if (t.HasElementType)`
`281`	`283`	`throw new ArgumentException(SR.Argument_ArraysInvalid, nameof(optionalCustomModifiers));`
`282`	`284`
Original file line number	Diff line number	Diff line change
`@@ -167,7 +167,9 @@ private static unsafe ref byte GetSpanDataFrom(`
`167`	`167`	`[RequiresUnreferencedCode("Trimmer can't guarantee existence of class constructor")]`
`168`	`168`	`public static void RunClassConstructor(RuntimeTypeHandle type)`
`169`	`169`	`{`
`170`		`- RuntimeType rt = type.GetRuntimeType() ?? throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, nameof(type));`
	`170`	`+ RuntimeType rt = type.GetRuntimeType() ??`
	`171`	`+ throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, nameof(type));`
	`172`	`+`
`171`	`173`	`RunClassConstructor(new QCallTypeHandle(ref rt));`
`172`	`174`	`}`
`173`	`175`
`@@ -184,7 +186,9 @@ public static void RunClassConstructor(RuntimeTypeHandle type)`
`184`	`186`
`185`	`187`	`public static void RunModuleConstructor(ModuleHandle module)`
`186`	`188`	`{`
`187`		`- RuntimeModule rm = module.GetRuntimeModule() ?? throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, nameof(module));`
	`189`	`+ RuntimeModule rm = module.GetRuntimeModule() ??`
	`190`	`+ throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, nameof(module));`
	`191`	`+`
`188`	`192`	`RunModuleConstructor(new QCallModule(ref rm));`
`189`	`193`	`}`
`190`	`194`
`@@ -198,7 +202,8 @@ public static void RunModuleConstructor(ModuleHandle module)`
`198`	`202`
`199`	`203`	`public static unsafe void PrepareMethod(RuntimeMethodHandle method, RuntimeTypeHandle[]? instantiation)`
`200`	`204`	`{`
`201`		`- IRuntimeMethodInfo methodInfo = method.GetMethodInfo() ?? throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, nameof(method));`
	`205`	`+ IRuntimeMethodInfo methodInfo = method.GetMethodInfo() ??`
	`206`	`+ throw new ArgumentException(SR.InvalidOperation_HandleIsNotInitialized, nameof(method));`
`202`	`207`
`203`	`208`	`// defensive copy of user-provided array, per CopyRuntimeTypeHandles contract`
`204`	`209`	`instantiation = (RuntimeTypeHandle[]?)instantiation?.Clone();`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,9 @@ public static IntPtr OffsetOf(Type t, string fieldName)`
`37`	`37`	`{`
`38`	`38`	`ArgumentNullException.ThrowIfNull(t);`
`39`	`39`
`40`		`- FieldInfo f = t.GetField(fieldName, BindingFlags.Instance \| BindingFlags.Public \| BindingFlags.NonPublic) ?? throw new ArgumentException(SR.Format(SR.Argument_OffsetOfFieldNotFound, t.FullName), nameof(fieldName));`
	`40`	`+ FieldInfo f = t.GetField(fieldName, BindingFlags.Instance \| BindingFlags.Public \| BindingFlags.NonPublic) ??`
	`41`	`+ throw new ArgumentException(SR.Format(SR.Argument_OffsetOfFieldNotFound, t.FullName), nameof(fieldName));`
	`42`	`+`
`41`	`43`	`if (f is not RtFieldInfo rtField)`
`42`	`44`	`{`
`43`	`45`	`throw new ArgumentException(SR.Argument_MustBeRuntimeFieldInfo, nameof(fieldName));`