From ac08f6633707b430e2188fedc5219c24a76fa49a Mon Sep 17 00:00:00 2001 From: Jan Kotas Date: Sun, 30 Dec 2018 01:08:19 -0800 Subject: [PATCH] Fix CoreCLR build breaks Commit migrated from https://github.com/dotnet/coreclr/commit/5f241249a54f7824812ccf5b87a60c9c1a65d3ec --- .../src/System/Runtime/InteropServices/GcHandle.cs | 16 +- .../src/System/ThrowHelper.cs | 431 +++++++++++++++++---- 2 files changed, 352 insertions(+), 95 deletions(-) diff --git a/src/coreclr/src/System.Private.CoreLib/src/System/Runtime/InteropServices/GcHandle.cs b/src/coreclr/src/System.Private.CoreLib/src/System/Runtime/InteropServices/GcHandle.cs index 85ed660..f6daa3f 100644 --- a/src/coreclr/src/System.Private.CoreLib/src/System/Runtime/InteropServices/GcHandle.cs +++ b/src/coreclr/src/System.Private.CoreLib/src/System/Runtime/InteropServices/GcHandle.cs @@ -59,7 +59,7 @@ namespace System.Runtime.InteropServices { // Make sure the type parameter is within the valid range for the enum. if ((uint)type > (uint)MaxHandleType) - ThrowArgumentOutOfRangeException_ArgumentOutOfRange_Enum(); + ThrowHelper.ThrowArgumentOutOfRangeException_ArgumentOutOfRange_Enum(); IntPtr handle = InternalAlloc(value, type); @@ -268,24 +268,14 @@ namespace System.Runtime.InteropServices { // Check if the handle was never initialized or was freed. if (m_handle == IntPtr.Zero) - ThrowInvalidOperationException_HandleIsNotInitialized(); + ThrowHelper.ThrowInvalidOperationException_HandleIsNotInitialized(); } private static void ValidateHandle(IntPtr handle) { // Check if the handle was never initialized or was freed. if (handle == IntPtr.Zero) - ThrowInvalidOperationException_HandleIsNotInitialized(); - } - - private static void ThrowArgumentOutOfRangeException_ArgumentOutOfRange_Enum() - { - throw ThrowHelper.GetArgumentOutOfRangeException(ExceptionArgument.type, ExceptionResource.ArgumentOutOfRange_Enum); - } - - private static void ThrowInvalidOperationException_HandleIsNotInitialized() - { - throw ThrowHelper.GetInvalidOperationException(ExceptionResource.InvalidOperation_HandleIsNotInitialized); + ThrowHelper.ThrowInvalidOperationException_HandleIsNotInitialized(); } } } diff --git a/src/libraries/System.Private.CoreLib/src/System/ThrowHelper.cs b/src/libraries/System.Private.CoreLib/src/System/ThrowHelper.cs index 09b2f0a..85e81f3 100644 --- a/src/libraries/System.Private.CoreLib/src/System/ThrowHelper.cs +++ b/src/libraries/System.Private.CoreLib/src/System/ThrowHelper.cs @@ -4,8 +4,8 @@ // This file defines an internal class used to throw exceptions in BCL code. -// The main purpose is to reduce code size. -// +// The main purpose is to reduce code size. +// // The old way to throw an exception generates quite a lot IL code and assembly code. // Following is an example: // C# source @@ -17,10 +17,10 @@ // IL_0012: newobj instance void System.ArgumentNullException::.ctor(string,string) // IL_0017: throw // which is 21bytes in IL. -// +// // So we want to get rid of the ldstr and call to Environment.GetResource in IL. // In order to do that, I created two enums: ExceptionResource, ExceptionArgument to represent the -// argument name and resource name in a small integer. The source code will be changed to +// argument name and resource name in a small integer. The source code will be changed to // ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key, ExceptionResource.ArgumentNull_Key); // // The IL code will be 7 bytes. @@ -29,11 +29,11 @@ // IL_000a: call void System.ThrowHelper::ThrowArgumentNullException(valuetype System.ExceptionArgument) // IL_000f: ldarg.0 // -// This will also reduce the Jitted code size a lot. +// This will also reduce the Jitted code size a lot. +// +// It is very important we do this for generic classes because we can easily generate the same code +// multiple times for different instantiation. // -// It is very important we do this for generic classes because we can easily generate the same code -// multiple times for different instantiation. -// using System.Buffers; using System.Collections.Generic; @@ -66,34 +66,11 @@ namespace System throw new ArgumentOutOfRangeException(); } - internal static void ThrowArgumentOutOfRangeException(ExceptionArgument argument) - { - throw new ArgumentOutOfRangeException(GetArgumentName(argument)); - } - - private static ArgumentOutOfRangeException GetArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource) - { - return new ArgumentOutOfRangeException(GetArgumentName(argument), GetResourceString(resource)); - } - internal static void ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource) - { - throw GetArgumentOutOfRangeException(argument, resource); - } - internal static void ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index() - { - throw GetArgumentOutOfRangeException(ExceptionArgument.startIndex, - ExceptionResource.ArgumentOutOfRange_Index); - } - internal static void ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count() - { - throw GetArgumentOutOfRangeException(ExceptionArgument.count, - ExceptionResource.ArgumentOutOfRange_Count); - } - internal static void ThrowArgumentException_DestinationTooShort() { throw new ArgumentException(SR.Argument_DestinationTooShort); } + internal static void ThrowArgumentException_OverlapAlignmentMismatch() { throw new ArgumentException(SR.Argument_OverlapAlignmentMismatch); @@ -109,85 +86,120 @@ namespace System throw GetArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_Index); } + internal static void ThrowIndexArgumentOutOfRange_NeedNonNegNumException() { throw GetArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum); } + internal static void ThrowValueArgumentOutOfRange_NeedNonNegNumException() { throw GetArgumentOutOfRangeException(ExceptionArgument.value, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum); } - private static ArgumentException GetWrongKeyTypeArgumentException(object key, Type targetType) + internal static void ThrowLengthArgumentOutOfRange_ArgumentOutOfRange_NeedNonNegNum() { - return new ArgumentException(SR.Format(SR.Arg_WrongType, key, targetType), nameof(key)); + throw GetArgumentOutOfRangeException(ExceptionArgument.length, + ExceptionResource.ArgumentOutOfRange_NeedNonNegNum); } - internal static void ThrowWrongKeyTypeArgumentException(object key, Type targetType) + + internal static void ThrowStartIndexArgumentOutOfRange_ArgumentOutOfRange_Index() { - throw GetWrongKeyTypeArgumentException(key, targetType); + throw GetArgumentOutOfRangeException(ExceptionArgument.startIndex, + ExceptionResource.ArgumentOutOfRange_Index); } - private static ArgumentException GetWrongValueTypeArgumentException(object value, Type targetType) + internal static void ThrowCountArgumentOutOfRange_ArgumentOutOfRange_Count() { - return new ArgumentException(SR.Format(SR.Arg_WrongType, value, targetType), nameof(value)); + throw GetArgumentOutOfRangeException(ExceptionArgument.count, + ExceptionResource.ArgumentOutOfRange_Count); } - internal static void ThrowWrongValueTypeArgumentException(object value, Type targetType) + + internal static void ThrowArgumentOutOfRangeException_ArgumentOutOfRange_Enum() { - throw GetWrongValueTypeArgumentException(value, targetType); + throw GetArgumentOutOfRangeException(ExceptionArgument.type, + ExceptionResource.ArgumentOutOfRange_Enum); } - private static ArgumentException GetAddingDuplicateWithKeyArgumentException(object key) + internal static void ThrowWrongKeyTypeArgumentException(T key, Type targetType) { - return new ArgumentException(SR.Format(SR.Argument_AddingDuplicate, key)); + // Generic key to move the boxing to the right hand side of throw + throw GetWrongKeyTypeArgumentException((object)key, targetType); } - internal static void ThrowAddingDuplicateWithKeyArgumentException(object key) + + internal static void ThrowWrongValueTypeArgumentException(T value, Type targetType) { - throw GetAddingDuplicateWithKeyArgumentException(key); + // Generic key to move the boxing to the right hand side of throw + throw GetWrongValueTypeArgumentException((object)value, targetType); } - private static KeyNotFoundException GetKeyNotFoundException(object key) + private static ArgumentException GetAddingDuplicateWithKeyArgumentException(object key) { - throw new KeyNotFoundException(SR.Format(SR.Arg_KeyNotFoundWithKey, key.ToString())); + return new ArgumentException(SR.Format(SR.Argument_AddingDuplicateWithKey, key)); } - internal static void ThrowKeyNotFoundException(object key) + + internal static void ThrowAddingDuplicateWithKeyArgumentException(T key) { - throw GetKeyNotFoundException(key); + // Generic key to move the boxing to the right hand side of throw + throw GetAddingDuplicateWithKeyArgumentException((object)key); } - internal static void ThrowArgumentException(ExceptionResource resource) + internal static void ThrowKeyNotFoundException(T key) { - throw new ArgumentException(GetResourceString(resource)); + // Generic key to move the boxing to the right hand side of throw + throw GetKeyNotFoundException((object)key); } - private static ArgumentException GetArgumentException(ExceptionResource resource, ExceptionArgument argument) + internal static void ThrowArgumentException(ExceptionResource resource) { - return new ArgumentException(GetResourceString(resource), GetArgumentName(argument)); + throw GetArgumentException(resource); } + internal static void ThrowArgumentException(ExceptionResource resource, ExceptionArgument argument) { throw GetArgumentException(resource, argument); } - internal static void ThrowAggregateException(List exceptions) + private static ArgumentNullException GetArgumentNullException(ExceptionArgument argument) { - throw new AggregateException(exceptions); + return new ArgumentNullException(GetArgumentName(argument)); } - internal static void ThrowArgumentException_Argument_InvalidArrayType() + internal static void ThrowArgumentNullException(ExceptionArgument argument) { - throw new ArgumentException(SR.Argument_InvalidArrayType); + throw GetArgumentNullException(argument); } - internal static void ThrowArgumentNullException(ExceptionArgument argument) + internal static void ThrowArgumentNullException(ExceptionResource resource) + { + throw new ArgumentNullException(GetResourceString(resource)); + } + + internal static void ThrowArgumentNullException(ExceptionArgument argument, ExceptionResource resource) + { + throw new ArgumentNullException(GetArgumentName(argument), GetResourceString(resource)); + } + + internal static void ThrowArgumentOutOfRangeException(ExceptionArgument argument) { - throw new ArgumentNullException(GetArgumentName(argument)); + throw new ArgumentOutOfRangeException(GetArgumentName(argument)); + } + + internal static void ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource) + { + throw GetArgumentOutOfRangeException(argument, resource); + } + + internal static void ThrowArgumentOutOfRangeException(ExceptionArgument argument, int paramNumber, ExceptionResource resource) + { + throw GetArgumentOutOfRangeException(argument, paramNumber, resource); } internal static void ThrowInvalidOperationException(ExceptionResource resource) { - throw new InvalidOperationException(GetResourceString(resource)); + throw GetInvalidOperationException(resource); } internal static void ThrowInvalidOperationException_OutstandingReferences() @@ -195,14 +207,64 @@ namespace System throw new InvalidOperationException(SR.Memory_OutstandingReferences); } - internal static void ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion() + internal static void ThrowInvalidOperationException(ExceptionResource resource, Exception e) { - throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion); + throw new InvalidOperationException(GetResourceString(resource), e); } - internal static void ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen() + internal static void ThrowSerializationException(ExceptionResource resource) { - throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen); + throw new SerializationException(GetResourceString(resource)); + } + + internal static void ThrowSecurityException(ExceptionResource resource) + { + throw new System.Security.SecurityException(GetResourceString(resource)); + } + + internal static void ThrowRankException(ExceptionResource resource) + { + throw new RankException(GetResourceString(resource)); + } + + internal static void ThrowNotSupportedException(ExceptionResource resource) + { + throw new NotSupportedException(GetResourceString(resource)); + } + + internal static void ThrowUnauthorizedAccessException(ExceptionResource resource) + { + throw new UnauthorizedAccessException(GetResourceString(resource)); + } + + internal static void ThrowObjectDisposedException(string objectName, ExceptionResource resource) + { + throw new ObjectDisposedException(objectName, GetResourceString(resource)); + } + + internal static void ThrowObjectDisposedException(ExceptionResource resource) + { + throw new ObjectDisposedException(null, GetResourceString(resource)); + } + + internal static void ThrowNotSupportedException() + { + throw new NotSupportedException(); + } + + internal static void ThrowAggregateException(List exceptions) + { + throw new AggregateException(exceptions); + } + + internal static void ThrowOutOfMemoryException() + { + throw new OutOfMemoryException(); + } + + internal static void ThrowArgumentException_Argument_InvalidArrayType() + { + throw new ArgumentException(SR.Argument_InvalidArrayType); } internal static void ThrowInvalidOperationException_InvalidOperation_EnumNotStarted() @@ -215,6 +277,21 @@ namespace System throw new InvalidOperationException(SR.InvalidOperation_EnumEnded); } + internal static void ThrowInvalidOperationException_EnumCurrent(int index) + { + throw GetInvalidOperationException_EnumCurrent(index); + } + + internal static void ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion() + { + throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion); + } + + internal static void ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen() + { + throw new InvalidOperationException(SR.InvalidOperation_EnumOpCantHappen); + } + internal static void ThrowInvalidOperationException_InvalidOperation_NoValue() { throw new InvalidOperationException(SR.InvalidOperation_NoValue); @@ -225,24 +302,29 @@ namespace System throw new InvalidOperationException(SR.InvalidOperation_ConcurrentOperationsNotSupported); } - internal static void ThrowSerializationException(ExceptionResource resource) + internal static void ThrowInvalidOperationException_HandleIsNotInitialized() { - throw new SerializationException(GetResourceString(resource)); + throw new InvalidOperationException(SR.InvalidOperation_HandleIsNotInitialized); } - internal static void ThrowObjectDisposedException(ExceptionResource resource) + internal static void ThrowArraySegmentCtorValidationFailedExceptions(Array array, int offset, int count) { - throw new ObjectDisposedException(null, GetResourceString(resource)); + throw GetArraySegmentCtorValidationFailedException(array, offset, count); } - internal static void ThrowNotSupportedException() + internal static void ThrowFormatException_BadFormatSpecifier() { - throw new NotSupportedException(); + throw new FormatException(SR.Argument_BadFormatSpecifier); } - internal static void ThrowNotSupportedException(ExceptionResource resource) + internal static void ThrowArgumentOutOfRangeException_PrecisionTooLarge() { - throw new NotSupportedException(GetResourceString(resource)); + throw new ArgumentOutOfRangeException("precision", SR.Format(SR.Argument_PrecisionTooLarge, StandardFormat.MaxPrecision)); + } + + internal static void ThrowArgumentOutOfRangeException_SymbolDoesNotFit() + { + throw new ArgumentOutOfRangeException("symbol", SR.Argument_BadFormatSpecifier); } private static Exception GetArraySegmentCtorValidationFailedException(Array array, int offset, int count) @@ -257,24 +339,53 @@ namespace System Debug.Assert(array.Length - offset < count); return new ArgumentException(SR.Argument_InvalidOffLen); } - internal static void ThrowArraySegmentCtorValidationFailedExceptions(Array array, int offset, int count) + + private static ArgumentException GetArgumentException(ExceptionResource resource) { - throw GetArraySegmentCtorValidationFailedException(array, offset, count); + return new ArgumentException(GetResourceString(resource)); } - internal static void ThrowFormatException_BadFormatSpecifier() + private static InvalidOperationException GetInvalidOperationException(ExceptionResource resource) { - throw new FormatException(SR.Argument_BadFormatSpecifier); + return new InvalidOperationException(GetResourceString(resource)); } - internal static void ThrowArgumentOutOfRangeException_PrecisionTooLarge() + private static ArgumentException GetWrongKeyTypeArgumentException(object key, Type targetType) { - throw new ArgumentOutOfRangeException("precision", SR.Format(SR.Argument_PrecisionTooLarge, StandardFormat.MaxPrecision)); + return new ArgumentException(SR.Format(SR.Arg_WrongType, key, targetType), nameof(key)); } - internal static void ThrowArgumentOutOfRangeException_SymbolDoesNotFit() + private static ArgumentException GetWrongValueTypeArgumentException(object value, Type targetType) { - throw new ArgumentOutOfRangeException("symbol", SR.Argument_BadFormatSpecifier); + return new ArgumentException(SR.Format(SR.Arg_WrongType, value, targetType), nameof(value)); + } + + private static KeyNotFoundException GetKeyNotFoundException(object key) + { + return new KeyNotFoundException(SR.Format(SR.Arg_KeyNotFoundWithKey, key.ToString())); + } + + private static ArgumentOutOfRangeException GetArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource) + { + return new ArgumentOutOfRangeException(GetArgumentName(argument), GetResourceString(resource)); + } + + private static ArgumentException GetArgumentException(ExceptionResource resource, ExceptionArgument argument) + { + return new ArgumentException(GetResourceString(resource), GetArgumentName(argument)); + } + + private static ArgumentOutOfRangeException GetArgumentOutOfRangeException(ExceptionArgument argument, int paramNumber, ExceptionResource resource) + { + return new ArgumentOutOfRangeException(GetArgumentName(argument) + "[" + paramNumber.ToString() + "]", GetResourceString(resource)); + } + + private static InvalidOperationException GetInvalidOperationException_EnumCurrent(int index) + { + return new InvalidOperationException( + index < 0 ? + SR.InvalidOperation_EnumNotStarted : + SR.InvalidOperation_EnumEnded); } // Allow nulls for reference types and Nullable, but not for value types. @@ -283,11 +394,35 @@ namespace System [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static void IfNullAndNullsAreIllegalThenThrow(object value, ExceptionArgument argName) { - // Note that default(T) is not equal to null for value types except when T is Nullable. + // Note that default(T) is not equal to null for value types except when T is Nullable. if (!(default(T) == null) && value == null) ThrowHelper.ThrowArgumentNullException(argName); } + internal static void ThrowNotSupportedExceptionIfNonNumericType() + { + if (typeof(T) != typeof(byte) && typeof(T) != typeof(sbyte) && + typeof(T) != typeof(short) && typeof(T) != typeof(ushort) && + typeof(T) != typeof(int) && typeof(T) != typeof(uint) && + typeof(T) != typeof(long) && typeof(T) != typeof(ulong) && + typeof(T) != typeof(float) && typeof(T) != typeof(double)) + { + throw new NotSupportedException(SR.Arg_TypeNotSupported); + } + } + +#if false // Reflection-based implementation does not work for CoreRT/ProjectN + // This function will convert an ExceptionArgument enum value to the argument name string. + [MethodImpl(MethodImplOptions.NoInlining)] + private static string GetArgumentName(ExceptionArgument argument) + { + Debug.Assert(Enum.IsDefined(typeof(ExceptionArgument), argument), + "The enum value is not defined, please check the ExceptionArgument Enum."); + + return argument.ToString(); + } +#endif + private static string GetArgumentName(ExceptionArgument argument) { switch (argument) @@ -404,12 +539,68 @@ namespace System return "stateMachine"; case ExceptionArgument.timeout: return "timeout"; + case ExceptionArgument.type: + return "type"; + case ExceptionArgument.sourceIndex: + return "sourceIndex"; + case ExceptionArgument.sourceArray: + return "sourceArray"; + case ExceptionArgument.destinationIndex: + return "destinationIndex"; + case ExceptionArgument.destinationArray: + return "destinationArray"; + case ExceptionArgument.pHandle: + return "pHandle"; + case ExceptionArgument.other: + return "other"; + case ExceptionArgument.newSize: + return "newSize"; + case ExceptionArgument.lowerBounds: + return "lowerBounds"; + case ExceptionArgument.lengths: + return "lengths"; + case ExceptionArgument.len: + return "len"; + case ExceptionArgument.keys: + return "keys"; + case ExceptionArgument.indices: + return "indices"; + case ExceptionArgument.index1: + return "index1"; + case ExceptionArgument.index2: + return "index2"; + case ExceptionArgument.index3: + return "index3"; + case ExceptionArgument.length1: + return "length1"; + case ExceptionArgument.length2: + return "length2"; + case ExceptionArgument.length3: + return "length3"; + case ExceptionArgument.endIndex: + return "endIndex"; + case ExceptionArgument.elementType: + return "elementType"; + case ExceptionArgument.arrayIndex: + return "arrayIndex"; default: Debug.Fail("The enum value is not defined, please check the ExceptionArgument Enum."); return ""; } } +#if false // Reflection-based implementation does not work for CoreRT/ProjectN + // This function will convert an ExceptionResource enum value to the resource string. + [MethodImpl(MethodImplOptions.NoInlining)] + private static string GetResourceString(ExceptionResource resource) + { + Debug.Assert(Enum.IsDefined(typeof(ExceptionResource), resource), + "The enum value is not defined, please check the ExceptionResource Enum."); + + return SR.GetResourceString(resource.ToString()); + } +#endif + private static string GetResourceString(ExceptionResource resource) { switch (resource) @@ -496,6 +687,42 @@ namespace System return SR.Task_ThrowIfDisposed; case ExceptionResource.Task_WaitMulti_NullTask: return SR.Task_WaitMulti_NullTask; + case ExceptionResource.ArgumentException_OtherNotArrayOfCorrectLength: + return SR.ArgumentException_OtherNotArrayOfCorrectLength; + case ExceptionResource.ArgumentNull_SafeHandle: + return SR.ArgumentNull_SafeHandle; + case ExceptionResource.ArgumentOutOfRange_EndIndexStartIndex: + return SR.ArgumentOutOfRange_EndIndexStartIndex; + case ExceptionResource.ArgumentOutOfRange_Enum: + return SR.ArgumentOutOfRange_Enum; + case ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported: + return SR.ArgumentOutOfRange_HugeArrayNotSupported; + case ExceptionResource.Argument_AddingDuplicate: + return SR.Argument_AddingDuplicate; + case ExceptionResource.Argument_InvalidArgumentForComparison: + return SR.Argument_InvalidArgumentForComparison; + case ExceptionResource.Arg_LowerBoundsMustMatch: + return SR.Arg_LowerBoundsMustMatch; + case ExceptionResource.Arg_MustBeType: + return SR.Arg_MustBeType; + case ExceptionResource.Arg_Need1DArray: + return SR.Arg_Need1DArray; + case ExceptionResource.Arg_Need2DArray: + return SR.Arg_Need2DArray; + case ExceptionResource.Arg_Need3DArray: + return SR.Arg_Need3DArray; + case ExceptionResource.Arg_NeedAtLeast1Rank: + return SR.Arg_NeedAtLeast1Rank; + case ExceptionResource.Arg_RankIndices: + return SR.Arg_RankIndices; + case ExceptionResource.Arg_RanksAndBounds: + return SR.Arg_RanksAndBounds; + case ExceptionResource.InvalidOperation_IComparerFailed: + return SR.InvalidOperation_IComparerFailed; + case ExceptionResource.NotSupported_FixedSizeCollection: + return SR.NotSupported_FixedSizeCollection; + case ExceptionResource.Rank_MultiDimNotSupported: + return SR.Rank_MultiDimNotSupported; default: Debug.Assert(false, "The enum value is not defined, please check the ExceptionResource Enum."); @@ -506,7 +733,7 @@ namespace System // // The convention for this enum is using the argument name as the enum name - // + // internal enum ExceptionArgument { obj, @@ -565,11 +792,33 @@ namespace System millisecondsTimeout, stateMachine, timeout, + type, + sourceIndex, + sourceArray, + destinationIndex, + destinationArray, + pHandle, + other, + newSize, + lowerBounds, + lengths, + len, + keys, + indices, + index1, + index2, + index3, + length1, + length2, + length3, + endIndex, + elementType, + arrayIndex, } // // The convention for this enum is using the resource name as the enum name - // + // internal enum ExceptionResource { ArgumentOutOfRange_Index, @@ -613,5 +862,23 @@ namespace System Task_Dispose_NotCompleted, Task_ThrowIfDisposed, Task_WaitMulti_NullTask, + ArgumentException_OtherNotArrayOfCorrectLength, + ArgumentNull_SafeHandle, + ArgumentOutOfRange_EndIndexStartIndex, + ArgumentOutOfRange_Enum, + ArgumentOutOfRange_HugeArrayNotSupported, + Argument_AddingDuplicate, + Argument_InvalidArgumentForComparison, + Arg_LowerBoundsMustMatch, + Arg_MustBeType, + Arg_Need1DArray, + Arg_Need2DArray, + Arg_Need3DArray, + Arg_NeedAtLeast1Rank, + Arg_RankIndices, + Arg_RanksAndBounds, + InvalidOperation_IComparerFailed, + NotSupported_FixedSizeCollection, + Rank_MultiDimNotSupported, } } -- 2.7.4