Rename CorElementType enum members to match the others definitions (#21324)

diff --git a/src/System.Private.CoreLib/src/System/Enum.cs b/src/System.Private.CoreLib/src/System/Enum.cs
index 81a6a3c..44a52ab 100644 (file)
--- a/src/System.Private.CoreLib/src/System/Enum.cs
+++ b/src/System.Private.CoreLib/src/System/Enum.cs
@@ -60,33 +60,33 @@ namespace System
             ref byte data = ref this.GetRawData();
             switch (InternalGetCorElementType())
             {
-                case CorElementType.I1:
+                case CorElementType.ELEMENT_TYPE_I1:
                     return Unsafe.As<byte, sbyte>(ref data).ToString();
-                case CorElementType.U1:
+                case CorElementType.ELEMENT_TYPE_U1:
                     return data.ToString();
-                case CorElementType.Boolean:
+                case CorElementType.ELEMENT_TYPE_BOOLEAN:
                     return Unsafe.As<byte, bool>(ref data).ToString();
-                case CorElementType.I2:
+                case CorElementType.ELEMENT_TYPE_I2:
                     return Unsafe.As<byte, short>(ref data).ToString();
-                case CorElementType.U2:
+                case CorElementType.ELEMENT_TYPE_U2:
                     return Unsafe.As<byte, ushort>(ref data).ToString();
-                case CorElementType.Char:
+                case CorElementType.ELEMENT_TYPE_CHAR:
                     return Unsafe.As<byte, char>(ref data).ToString();
-                case CorElementType.I4:
+                case CorElementType.ELEMENT_TYPE_I4:
                     return Unsafe.As<byte, int>(ref data).ToString();
-                case CorElementType.U4:
+                case CorElementType.ELEMENT_TYPE_U4:
                     return Unsafe.As<byte, uint>(ref data).ToString();
-                case CorElementType.R4:
+                case CorElementType.ELEMENT_TYPE_R4:
                     return Unsafe.As<byte, float>(ref data).ToString();
-                case CorElementType.I8:
+                case CorElementType.ELEMENT_TYPE_I8:
                     return Unsafe.As<byte, long>(ref data).ToString();
-                case CorElementType.U8:
+                case CorElementType.ELEMENT_TYPE_U8:
                     return Unsafe.As<byte, ulong>(ref data).ToString();
-                case CorElementType.R8:
+                case CorElementType.ELEMENT_TYPE_R8:
                     return Unsafe.As<byte, double>(ref data).ToString();
-                case CorElementType.I:
+                case CorElementType.ELEMENT_TYPE_I:
                     return Unsafe.As<byte, IntPtr>(ref data).ToString();
-                case CorElementType.U:
+                case CorElementType.ELEMENT_TYPE_U:
                     return Unsafe.As<byte, UIntPtr>(ref data).ToString();
                 default:
                     Debug.Fail("Invalid primitive type");
@@ -99,20 +99,20 @@ namespace System
             ref byte data = ref this.GetRawData();
             switch (InternalGetCorElementType())
             {
-                case CorElementType.I1:
-                case CorElementType.U1:
+                case CorElementType.ELEMENT_TYPE_I1:
+                case CorElementType.ELEMENT_TYPE_U1:
                     return data.ToString("X2", null);
-                case CorElementType.Boolean:
+                case CorElementType.ELEMENT_TYPE_BOOLEAN:
                     return Convert.ToByte(Unsafe.As<byte, bool>(ref data)).ToString("X2", null);
-                case CorElementType.I2:
-                case CorElementType.U2:
-                case CorElementType.Char:
+                case CorElementType.ELEMENT_TYPE_I2:
+                case CorElementType.ELEMENT_TYPE_U2:
+                case CorElementType.ELEMENT_TYPE_CHAR:
                     return Unsafe.As<byte, ushort>(ref data).ToString("X4", null);
-                case CorElementType.I4:
-                case CorElementType.U4:
+                case CorElementType.ELEMENT_TYPE_I4:
+                case CorElementType.ELEMENT_TYPE_U4:
                     return Unsafe.As<byte, uint>(ref data).ToString("X8", null);
-                case CorElementType.I8:
-                case CorElementType.U8:
+                case CorElementType.ELEMENT_TYPE_I8:
+                case CorElementType.ELEMENT_TYPE_U8:
                     return Unsafe.As<byte, ulong>(ref data).ToString("X16", null);
                 default:
                     throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType);
@@ -974,33 +974,33 @@ namespace System
             ref byte data = ref this.GetRawData();
             switch (InternalGetCorElementType())
             {
-                case CorElementType.I1:
+                case CorElementType.ELEMENT_TYPE_I1:
                     return Unsafe.As<byte, sbyte>(ref data);
-                case CorElementType.U1:
+                case CorElementType.ELEMENT_TYPE_U1:
                     return data;
-                case CorElementType.Boolean:
+                case CorElementType.ELEMENT_TYPE_BOOLEAN:
                     return Unsafe.As<byte, bool>(ref data);
-                case CorElementType.I2:
+                case CorElementType.ELEMENT_TYPE_I2:
                     return Unsafe.As<byte, short>(ref data);
-                case CorElementType.U2:
+                case CorElementType.ELEMENT_TYPE_U2:
                     return Unsafe.As<byte, ushort>(ref data);
-                case CorElementType.Char:
+                case CorElementType.ELEMENT_TYPE_CHAR:
                     return Unsafe.As<byte, char>(ref data);
-                case CorElementType.I4:
+                case CorElementType.ELEMENT_TYPE_I4:
                     return Unsafe.As<byte, int>(ref data);
-                case CorElementType.U4:
+                case CorElementType.ELEMENT_TYPE_U4:
                     return Unsafe.As<byte, uint>(ref data);
-                case CorElementType.R4:
+                case CorElementType.ELEMENT_TYPE_R4:
                     return Unsafe.As<byte, float>(ref data);
-                case CorElementType.I8:
+                case CorElementType.ELEMENT_TYPE_I8:
                     return Unsafe.As<byte, long>(ref data);
-                case CorElementType.U8:
+                case CorElementType.ELEMENT_TYPE_U8:
                     return Unsafe.As<byte, ulong>(ref data);
-                case CorElementType.R8:
+                case CorElementType.ELEMENT_TYPE_R8:
                     return Unsafe.As<byte, double>(ref data);
-                case CorElementType.I:
+                case CorElementType.ELEMENT_TYPE_I:
                     return Unsafe.As<byte, IntPtr>(ref data);
-                case CorElementType.U:
+                case CorElementType.ELEMENT_TYPE_U:
                     return Unsafe.As<byte, UIntPtr>(ref data);
                 default:
                     Debug.Fail("Invalid primitive type");
@@ -1013,30 +1013,30 @@ namespace System
             ref byte data = ref this.GetRawData();
             switch (InternalGetCorElementType())
             {
-                case CorElementType.I1:
+                case CorElementType.ELEMENT_TYPE_I1:
                     return (ulong)Unsafe.As<byte, sbyte>(ref data);
-                case CorElementType.U1:
+                case CorElementType.ELEMENT_TYPE_U1:
                     return data;
-                case CorElementType.Boolean:
+                case CorElementType.ELEMENT_TYPE_BOOLEAN:
                     return Convert.ToUInt64(Unsafe.As<byte, bool>(ref data), CultureInfo.InvariantCulture);
-                case CorElementType.I2:
+                case CorElementType.ELEMENT_TYPE_I2:
                     return (ulong)Unsafe.As<byte, short>(ref data);
-                case CorElementType.U2:
-                case CorElementType.Char:
+                case CorElementType.ELEMENT_TYPE_U2:
+                case CorElementType.ELEMENT_TYPE_CHAR:
                     return Unsafe.As<byte, ushort>(ref data);
-                case CorElementType.I4:
+                case CorElementType.ELEMENT_TYPE_I4:
                     return (ulong)Unsafe.As<byte, int>(ref data);
-                case CorElementType.U4:
-                case CorElementType.R4:
+                case CorElementType.ELEMENT_TYPE_U4:
+                case CorElementType.ELEMENT_TYPE_R4:
                     return Unsafe.As<byte, uint>(ref data);
-                case CorElementType.I8:
+                case CorElementType.ELEMENT_TYPE_I8:
                     return (ulong)Unsafe.As<byte, long>(ref data);
-                case CorElementType.U8:
-                case CorElementType.R8:
+                case CorElementType.ELEMENT_TYPE_U8:
+                case CorElementType.ELEMENT_TYPE_R8:
                     return Unsafe.As<byte, ulong>(ref data);
-                case CorElementType.I:
+                case CorElementType.ELEMENT_TYPE_I:
                     return (ulong)Unsafe.As<byte, IntPtr>(ref data);
-                case CorElementType.U:
+                case CorElementType.ELEMENT_TYPE_U:
                     return (ulong)Unsafe.As<byte, UIntPtr>(ref data);
                 default:
                     Debug.Fail("Invalid primitive type");
@@ -1064,33 +1064,33 @@ namespace System
             ref byte data = ref this.GetRawData();
             switch (InternalGetCorElementType())
             {
-                case CorElementType.I1:
+                case CorElementType.ELEMENT_TYPE_I1:
                     return Unsafe.As<byte, sbyte>(ref data).GetHashCode();
-                case CorElementType.U1:
+                case CorElementType.ELEMENT_TYPE_U1:
                     return data.GetHashCode();
-                case CorElementType.Boolean:
+                case CorElementType.ELEMENT_TYPE_BOOLEAN:
                     return Unsafe.As<byte, bool>(ref data).GetHashCode();
-                case CorElementType.I2:
+                case CorElementType.ELEMENT_TYPE_I2:
                     return Unsafe.As<byte, short>(ref data).GetHashCode();
-                case CorElementType.U2:
+                case CorElementType.ELEMENT_TYPE_U2:
                     return Unsafe.As<byte, ushort>(ref data).GetHashCode();
-                case CorElementType.Char:
+                case CorElementType.ELEMENT_TYPE_CHAR:
                     return Unsafe.As<byte, char>(ref data).GetHashCode();
-                case CorElementType.I4:
+                case CorElementType.ELEMENT_TYPE_I4:
                     return Unsafe.As<byte, int>(ref data).GetHashCode();
-                case CorElementType.U4:
+                case CorElementType.ELEMENT_TYPE_U4:
                     return Unsafe.As<byte, uint>(ref data).GetHashCode();
-                case CorElementType.R4:
+                case CorElementType.ELEMENT_TYPE_R4:
                     return Unsafe.As<byte, float>(ref data).GetHashCode();
-                case CorElementType.I8:
+                case CorElementType.ELEMENT_TYPE_I8:
                     return Unsafe.As<byte, long>(ref data).GetHashCode();
-                case CorElementType.U8:
+                case CorElementType.ELEMENT_TYPE_U8:
                     return Unsafe.As<byte, ulong>(ref data).GetHashCode();
-                case CorElementType.R8:
+                case CorElementType.ELEMENT_TYPE_R8:
                     return Unsafe.As<byte, double>(ref data).GetHashCode();
-                case CorElementType.I:
+                case CorElementType.ELEMENT_TYPE_I:
                     return Unsafe.As<byte, IntPtr>(ref data).GetHashCode();
-                case CorElementType.U:
+                case CorElementType.ELEMENT_TYPE_U:
                     return Unsafe.As<byte, UIntPtr>(ref data).GetHashCode();
                 default:
                     Debug.Fail("Invalid primitive type");
@@ -1212,25 +1212,25 @@ namespace System
         {
             switch (InternalGetCorElementType())
             {
-                case CorElementType.I1:
+                case CorElementType.ELEMENT_TYPE_I1:
                     return TypeCode.SByte;
-                case CorElementType.U1:
+                case CorElementType.ELEMENT_TYPE_U1:
                     return TypeCode.Byte;
-                case CorElementType.Boolean:
+                case CorElementType.ELEMENT_TYPE_BOOLEAN:
                     return TypeCode.Boolean;
-                case CorElementType.I2:
+                case CorElementType.ELEMENT_TYPE_I2:
                     return TypeCode.Int16;
-                case CorElementType.U2:
+                case CorElementType.ELEMENT_TYPE_U2:
                     return TypeCode.UInt16;
-                case CorElementType.Char:
+                case CorElementType.ELEMENT_TYPE_CHAR:
                     return TypeCode.Char;
-                case CorElementType.I4:
+                case CorElementType.ELEMENT_TYPE_I4:
                     return TypeCode.Int32;
-                case CorElementType.U4:
+                case CorElementType.ELEMENT_TYPE_U4:
                     return TypeCode.UInt32;
-                case CorElementType.I8:
+                case CorElementType.ELEMENT_TYPE_I8:
                     return TypeCode.Int64;
-                case CorElementType.U8:
+                case CorElementType.ELEMENT_TYPE_U8:
                     return TypeCode.UInt64;
                 default:
                     throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType);

diff --git a/src/System.Private.CoreLib/src/System/Reflection/CustomAttribute.cs b/src/System.Private.CoreLib/src/System/Reflection/CustomAttribute.cs
index 44d1284..50015dd 100644 (file)
--- a/src/System.Private.CoreLib/src/System/Reflection/CustomAttribute.cs
+++ b/src/System.Private.CoreLib/src/System/Reflection/CustomAttribute.cs
@@ -912,20 +912,20 @@ namespace System.Reflection
     internal enum CustomAttributeEncoding : int
     {
         Undefined = 0,
-        Boolean = CorElementType.Boolean,
-        Char = CorElementType.Char,
-        SByte = CorElementType.I1,
-        Byte = CorElementType.U1,
-        Int16 = CorElementType.I2,
-        UInt16 = CorElementType.U2,
-        Int32 = CorElementType.I4,
-        UInt32 = CorElementType.U4,
-        Int64 = CorElementType.I8,
-        UInt64 = CorElementType.U8,
-        Float = CorElementType.R4,
-        Double = CorElementType.R8,
-        String = CorElementType.String,
-        Array = CorElementType.SzArray,
+        Boolean = CorElementType.ELEMENT_TYPE_BOOLEAN,
+        Char = CorElementType.ELEMENT_TYPE_CHAR,
+        SByte = CorElementType.ELEMENT_TYPE_I1,
+        Byte = CorElementType.ELEMENT_TYPE_U1,
+        Int16 = CorElementType.ELEMENT_TYPE_I2,
+        UInt16 = CorElementType.ELEMENT_TYPE_U2,
+        Int32 = CorElementType.ELEMENT_TYPE_I4,
+        UInt32 = CorElementType.ELEMENT_TYPE_U4,
+        Int64 = CorElementType.ELEMENT_TYPE_I8,
+        UInt64 = CorElementType.ELEMENT_TYPE_U8,
+        Float = CorElementType.ELEMENT_TYPE_R4,
+        Double = CorElementType.ELEMENT_TYPE_R8,
+        String = CorElementType.ELEMENT_TYPE_STRING,
+        Array = CorElementType.ELEMENT_TYPE_SZARRAY,
         Type = 0x50,
         Object = 0x51,
         Field = 0x53,

diff --git a/src/System.Private.CoreLib/src/System/Reflection/Emit/SignatureHelper.cs b/src/System.Private.CoreLib/src/System/Reflection/Emit/SignatureHelper.cs
index cad49cb..b9eecdb 100644 (file)
--- a/src/System.Private.CoreLib/src/System/Reflection/Emit/SignatureHelper.cs
+++ b/src/System.Private.CoreLib/src/System/Reflection/Emit/SignatureHelper.cs
@@ -278,7 +278,7 @@ namespace System.Reflection.Emit
         private void AddOneArgTypeHelper(Type argument, bool pinned)
         {
             if (pinned)
-                AddElementType(CorElementType.Pinned);
+                AddElementType(CorElementType.ELEMENT_TYPE_PINNED);
 
             AddOneArgTypeHelper(argument);
         }
@@ -305,7 +305,7 @@ namespace System.Reflection.Emit
                     if (t.ContainsGenericParameters)
                         throw new ArgumentException(SR.Argument_GenericsInvalid, nameof(optionalCustomModifiers));
 
-                    AddElementType(CorElementType.CModOpt);
+                    AddElementType(CorElementType.ELEMENT_TYPE_CMOD_OPT);
 
                     int token = m_module.GetTypeToken(t).Token;
                     Debug.Assert(!MetadataToken.IsNullToken(token));
@@ -328,7 +328,7 @@ namespace System.Reflection.Emit
                     if (t.ContainsGenericParameters)
                         throw new ArgumentException(SR.Argument_GenericsInvalid, nameof(requiredCustomModifiers));
 
-                    AddElementType(CorElementType.CModReqd);
+                    AddElementType(CorElementType.ELEMENT_TYPE_CMOD_REQD);
 
                     int token = m_module.GetTypeToken(t).Token;
                     Debug.Assert(!MetadataToken.IsNullToken(token));
@@ -345,15 +345,15 @@ namespace System.Reflection.Emit
             if (clsArgument.IsGenericParameter)
             {
                 if (clsArgument.DeclaringMethod != null)
-                    AddElementType(CorElementType.MVar);
+                    AddElementType(CorElementType.ELEMENT_TYPE_MVAR);
                 else
-                    AddElementType(CorElementType.Var);
+                    AddElementType(CorElementType.ELEMENT_TYPE_VAR);
 
                 AddData(clsArgument.GenericParameterPosition);
             }
             else if (clsArgument.IsGenericType && (!clsArgument.IsGenericTypeDefinition || !lastWasGenericInst))
             {
-                AddElementType(CorElementType.GenericInst);
+                AddElementType(CorElementType.ELEMENT_TYPE_GENERICINST);
 
                 AddOneArgTypeHelperWorker(clsArgument.GetGenericTypeDefinition(), true);
 
@@ -380,11 +380,11 @@ namespace System.Reflection.Emit
 
                 if (clsArgument.IsValueType)
                 {
-                    InternalAddTypeToken(tkType, CorElementType.ValueType);
+                    InternalAddTypeToken(tkType, CorElementType.ELEMENT_TYPE_VALUETYPE);
                 }
                 else
                 {
-                    InternalAddTypeToken(tkType, CorElementType.Class);
+                    InternalAddTypeToken(tkType, CorElementType.ELEMENT_TYPE_CLASS);
                 }
             }
             else if (clsArgument is EnumBuilder)
@@ -403,35 +403,35 @@ namespace System.Reflection.Emit
 
                 if (clsArgument.IsValueType)
                 {
-                    InternalAddTypeToken(tkType, CorElementType.ValueType);
+                    InternalAddTypeToken(tkType, CorElementType.ELEMENT_TYPE_VALUETYPE);
                 }
                 else
                 {
-                    InternalAddTypeToken(tkType, CorElementType.Class);
+                    InternalAddTypeToken(tkType, CorElementType.ELEMENT_TYPE_CLASS);
                 }
             }
             else if (clsArgument.IsByRef)
             {
-                AddElementType(CorElementType.ByRef);
+                AddElementType(CorElementType.ELEMENT_TYPE_BYREF);
                 clsArgument = clsArgument.GetElementType();
                 AddOneArgTypeHelper(clsArgument);
             }
             else if (clsArgument.IsPointer)
             {
-                AddElementType(CorElementType.Ptr);
+                AddElementType(CorElementType.ELEMENT_TYPE_PTR);
                 AddOneArgTypeHelper(clsArgument.GetElementType());
             }
             else if (clsArgument.IsArray)
             {
                 if (clsArgument.IsSZArray)
                 {
-                    AddElementType(CorElementType.SzArray);
+                    AddElementType(CorElementType.ELEMENT_TYPE_SZARRAY);
 
                     AddOneArgTypeHelper(clsArgument.GetElementType());
                 }
                 else
                 {
-                    AddElementType(CorElementType.Array);
+                    AddElementType(CorElementType.ELEMENT_TYPE_ARRAY);
 
                     AddOneArgTypeHelper(clsArgument.GetElementType());
 
@@ -446,19 +446,19 @@ namespace System.Reflection.Emit
             }
             else
             {
-                CorElementType type = CorElementType.Max;
+                CorElementType type = CorElementType.ELEMENT_TYPE_MAX;
 
                 if (clsArgument is RuntimeType)
                 {
                     type = RuntimeTypeHandle.GetCorElementType((RuntimeType)clsArgument);
 
-                    //GetCorElementType returns CorElementType.Class for both object and string
-                    if (type == CorElementType.Class)
+                    //GetCorElementType returns CorElementType.ELEMENT_TYPE_CLASS for both object and string
+                    if (type == CorElementType.ELEMENT_TYPE_CLASS)
                     {
                         if (clsArgument == typeof(object))
-                            type = CorElementType.Object;
+                            type = CorElementType.ELEMENT_TYPE_OBJECT;
                         else if (clsArgument == typeof(string))
-                            type = CorElementType.String;
+                            type = CorElementType.ELEMENT_TYPE_STRING;
                     }
                 }
 
@@ -472,11 +472,11 @@ namespace System.Reflection.Emit
                 }
                 else if (clsArgument.IsValueType)
                 {
-                    InternalAddTypeToken(m_module.GetTypeToken(clsArgument), CorElementType.ValueType);
+                    InternalAddTypeToken(m_module.GetTypeToken(clsArgument), CorElementType.ELEMENT_TYPE_VALUETYPE);
                 }
                 else
                 {
-                    InternalAddTypeToken(m_module.GetTypeToken(clsArgument), CorElementType.Class);
+                    InternalAddTypeToken(m_module.GetTypeToken(clsArgument), CorElementType.ELEMENT_TYPE_CLASS);
                 }
             }
         }
@@ -557,7 +557,7 @@ namespace System.Reflection.Emit
 
         private void InternalAddTypeToken(TypeToken clsToken, CorElementType CorType)
         {
-            // Add a type token into signature. CorType will be either CorElementType.Class or CorElementType.ValueType
+            // Add a type token into signature. CorType will be either CorElementType.ELEMENT_TYPE_CLASS or CorElementType.ELEMENT_TYPE_VALUETYPE
             AddElementType(CorType);
             AddToken(clsToken.Token);
         }
@@ -566,7 +566,7 @@ namespace System.Reflection.Emit
         {
             // Add a runtime type into the signature. 
 
-            AddElementType(CorElementType.Internal);
+            AddElementType(CorElementType.ELEMENT_TYPE_INTERNAL);
 
             IntPtr handle = type.GetTypeHandleInternal().Value;
 
@@ -682,10 +682,10 @@ namespace System.Reflection.Emit
 
         internal static bool IsSimpleType(CorElementType type)
         {
-            if (type <= CorElementType.String)
+            if (type <= CorElementType.ELEMENT_TYPE_STRING)
                 return true;
 
-            if (type == CorElementType.TypedByRef || type == CorElementType.I || type == CorElementType.U || type == CorElementType.Object)
+            if (type == CorElementType.ELEMENT_TYPE_TYPEDBYREF || type == CorElementType.ELEMENT_TYPE_I || type == CorElementType.ELEMENT_TYPE_U || type == CorElementType.ELEMENT_TYPE_OBJECT)
                 return true;
 
             return false;
@@ -757,7 +757,7 @@ namespace System.Reflection.Emit
             // copy the sig part of the sig
             Buffer.BlockCopy(m_signature, 2, temp, sigCopyIndex, currSigLength - 2);
             // mark the end of sig
-            temp[newSigSize - 1] = (byte)CorElementType.End;
+            temp[newSigSize - 1] = (byte)CorElementType.ELEMENT_TYPE_END;
 
             return temp;
         }
@@ -817,7 +817,7 @@ namespace System.Reflection.Emit
 
         public void AddSentinel()
         {
-            AddElementType(CorElementType.Sentinel);
+            AddElementType(CorElementType.ELEMENT_TYPE_SENTINEL);
         }
 
         public override bool Equals(object obj)
@@ -871,7 +871,7 @@ namespace System.Reflection.Emit
             if (!m_sigDone)
             {
                 if (appendEndOfSig)
-                    AddElementType(CorElementType.End);
+                    AddElementType(CorElementType.ELEMENT_TYPE_END);
                 SetNumberOfSignatureElements(true);
                 m_sigDone = true;
             }

diff --git a/src/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.cs b/src/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.cs
index 5b62e81..1c063ac 100644 (file)
--- a/src/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.cs
+++ b/src/System.Private.CoreLib/src/System/Reflection/Emit/TypeBuilder.cs
@@ -354,18 +354,18 @@ namespace System.Reflection.Emit
 
                 switch (corType)
                 {
-                    case CorElementType.I1:
-                    case CorElementType.U1:
-                    case CorElementType.Boolean:
-                    case CorElementType.I2:
-                    case CorElementType.U2:
-                    case CorElementType.Char:
-                    case CorElementType.I4:
-                    case CorElementType.U4:
-                    case CorElementType.R4:
-                    case CorElementType.I8:
-                    case CorElementType.U8:
-                    case CorElementType.R8:
+                    case CorElementType.ELEMENT_TYPE_I1:
+                    case CorElementType.ELEMENT_TYPE_U1:
+                    case CorElementType.ELEMENT_TYPE_BOOLEAN:
+                    case CorElementType.ELEMENT_TYPE_I2:
+                    case CorElementType.ELEMENT_TYPE_U2:
+                    case CorElementType.ELEMENT_TYPE_CHAR:
+                    case CorElementType.ELEMENT_TYPE_I4:
+                    case CorElementType.ELEMENT_TYPE_U4:
+                    case CorElementType.ELEMENT_TYPE_R4:
+                    case CorElementType.ELEMENT_TYPE_I8:
+                    case CorElementType.ELEMENT_TYPE_U8:
+                    case CorElementType.ELEMENT_TYPE_R8:
                         fixed (byte* pData = &value.GetRawData())
                             SetConstantValue(module.GetNativeHandle(), tk, (int)corType, pData);
                         break;
@@ -374,13 +374,13 @@ namespace System.Reflection.Emit
                         if (type == typeof(string))
                         {
                             fixed (char* pString = (string)value)
-                                SetConstantValue(module.GetNativeHandle(), tk, (int)CorElementType.String, pString);
+                                SetConstantValue(module.GetNativeHandle(), tk, (int)CorElementType.ELEMENT_TYPE_STRING, pString);
                         }
                         else if (type == typeof(DateTime))
                         {
                             //date is a I8 representation
                             long ticks = ((DateTime)value).Ticks;
-                            SetConstantValue(module.GetNativeHandle(), tk, (int)CorElementType.I8, &ticks);
+                            SetConstantValue(module.GetNativeHandle(), tk, (int)CorElementType.ELEMENT_TYPE_I8, &ticks);
                         }
                         else
                         {
@@ -395,7 +395,7 @@ namespace System.Reflection.Emit
                 // (See ECMA-335 II.15.4.1.4 "The .param directive" and II.22.9 "Constant" for details.)
                 // This is how the Roslyn compilers generally encode `default(TValueType)` default values.
 
-                SetConstantValue(module.GetNativeHandle(), tk, (int)CorElementType.Class, null);
+                SetConstantValue(module.GetNativeHandle(), tk, (int)CorElementType.ELEMENT_TYPE_CLASS, null);
             }
         }
 

diff --git a/src/System.Private.CoreLib/src/System/Reflection/MdConstant.cs b/src/System.Private.CoreLib/src/System/Reflection/MdConstant.cs
index a2fd72e..76b1c80 100644 (file)
--- a/src/System.Private.CoreLib/src/System/Reflection/MdConstant.cs
+++ b/src/System.Private.CoreLib/src/System/Reflection/MdConstant.cs
@@ -35,46 +35,46 @@ namespace System.Reflection
                 {
                     #region Switch
 
-                    case CorElementType.Void:
+                    case CorElementType.ELEMENT_TYPE_VOID:
                         return DBNull.Value;
 
-                    case CorElementType.Char:
+                    case CorElementType.ELEMENT_TYPE_CHAR:
                         defaultValue = *(char*)&buffer;
                         break;
 
-                    case CorElementType.I1:
+                    case CorElementType.ELEMENT_TYPE_I1:
                         defaultValue = *(sbyte*)&buffer;
                         break;
 
-                    case CorElementType.U1:
+                    case CorElementType.ELEMENT_TYPE_U1:
                         defaultValue = *(byte*)&buffer;
                         break;
 
-                    case CorElementType.I2:
+                    case CorElementType.ELEMENT_TYPE_I2:
                         defaultValue = *(short*)&buffer;
                         break;
 
-                    case CorElementType.U2:
+                    case CorElementType.ELEMENT_TYPE_U2:
                         defaultValue = *(ushort*)&buffer;
                         break;
 
-                    case CorElementType.I4:
+                    case CorElementType.ELEMENT_TYPE_I4:
                         defaultValue = *(int*)&buffer;
                         break;
 
-                    case CorElementType.U4:
+                    case CorElementType.ELEMENT_TYPE_U4:
                         defaultValue = *(uint*)&buffer;
                         break;
 
-                    case CorElementType.I8:
+                    case CorElementType.ELEMENT_TYPE_I8:
                         defaultValue = buffer;
                         break;
 
-                    case CorElementType.U8:
+                    case CorElementType.ELEMENT_TYPE_U8:
                         defaultValue = buffer;
                         break;
 
-                    case CorElementType.Class:
+                    case CorElementType.ELEMENT_TYPE_CLASS:
                         return null;
 
                     default:
@@ -92,18 +92,18 @@ namespace System.Reflection
                 {
                     #region Switch
 
-                    case CorElementType.Void:
+                    case CorElementType.ELEMENT_TYPE_VOID:
                         return DBNull.Value;
 
-                    case CorElementType.I8:
+                    case CorElementType.ELEMENT_TYPE_I8:
                         defaultValue = buffer;
                         break;
 
-                    case CorElementType.U8:
+                    case CorElementType.ELEMENT_TYPE_U8:
                         defaultValue = buffer;
                         break;
 
-                    case CorElementType.Class:
+                    case CorElementType.ELEMENT_TYPE_CLASS:
                         return null;
 
                     default:
@@ -119,54 +119,54 @@ namespace System.Reflection
                 {
                     #region Switch
 
-                    case CorElementType.Void:
+                    case CorElementType.ELEMENT_TYPE_VOID:
                         return DBNull.Value;
 
-                    case CorElementType.Char:
+                    case CorElementType.ELEMENT_TYPE_CHAR:
                         return *(char*)&buffer;
 
-                    case CorElementType.I1:
+                    case CorElementType.ELEMENT_TYPE_I1:
                         return *(sbyte*)&buffer;
 
-                    case CorElementType.U1:
+                    case CorElementType.ELEMENT_TYPE_U1:
                         return *(byte*)&buffer;
 
-                    case CorElementType.I2:
+                    case CorElementType.ELEMENT_TYPE_I2:
                         return *(short*)&buffer;
 
-                    case CorElementType.U2:
+                    case CorElementType.ELEMENT_TYPE_U2:
                         return *(ushort*)&buffer;
 
-                    case CorElementType.I4:
+                    case CorElementType.ELEMENT_TYPE_I4:
                         return *(int*)&buffer;
 
-                    case CorElementType.U4:
+                    case CorElementType.ELEMENT_TYPE_U4:
                         return *(uint*)&buffer;
 
-                    case CorElementType.I8:
+                    case CorElementType.ELEMENT_TYPE_I8:
                         return buffer;
 
-                    case CorElementType.U8:
+                    case CorElementType.ELEMENT_TYPE_U8:
                         return (ulong)buffer;
 
-                    case CorElementType.Boolean:
+                    case CorElementType.ELEMENT_TYPE_BOOLEAN:
                         // The boolean value returned from the metadata engine is stored as a
                         // BOOL, which actually maps to an int. We need to read it out as an int
                         // to avoid problems on big-endian machines.
                         return (*(int*)&buffer != 0);
 
-                    case CorElementType.R4:
+                    case CorElementType.ELEMENT_TYPE_R4:
                         return *(float*)&buffer;
 
-                    case CorElementType.R8:
+                    case CorElementType.ELEMENT_TYPE_R8:
                         return *(double*)&buffer;
 
-                    case CorElementType.String:
+                    case CorElementType.ELEMENT_TYPE_STRING:
                         // A string constant can be empty but never null.
-                        // A nullref constant can only be type CorElementType.Class.
+                        // A nullref constant can only be type CorElementType.ELEMENT_TYPE_CLASS.
                         return stringVal == null ? string.Empty : stringVal;
 
-                    case CorElementType.Class:
+                    case CorElementType.ELEMENT_TYPE_CLASS:
                         return null;
 
                     default:

diff --git a/src/System.Private.CoreLib/src/System/Reflection/MdImport.cs b/src/System.Private.CoreLib/src/System/Reflection/MdImport.cs
index 4515324..a159745 100644 (file)
--- a/src/System.Private.CoreLib/src/System/Reflection/MdImport.cs
+++ b/src/System.Private.CoreLib/src/System/Reflection/MdImport.cs
@@ -21,42 +21,42 @@ namespace System.Reflection
 {
     internal enum CorElementType : byte
     {
-        End = 0x00,
-        Void = 0x01,
-        Boolean = 0x02,
-        Char = 0x03,
-        I1 = 0x04,
-        U1 = 0x05,
-        I2 = 0x06,
-        U2 = 0x07,
-        I4 = 0x08,
-        U4 = 0x09,
-        I8 = 0x0A,
-        U8 = 0x0B,
-        R4 = 0x0C,
-        R8 = 0x0D,
-        String = 0x0E,
-        Ptr = 0x0F,
-        ByRef = 0x10,
-        ValueType = 0x11,
-        Class = 0x12,
-        Var = 0x13,
-        Array = 0x14,
-        GenericInst = 0x15,
-        TypedByRef = 0x16,
-        I = 0x18,
-        U = 0x19,
-        FnPtr = 0x1B,
-        Object = 0x1C,
-        SzArray = 0x1D,
-        MVar = 0x1E,
-        CModReqd = 0x1F,
-        CModOpt = 0x20,
-        Internal = 0x21,
-        Max = 0x22,
-        Modifier = 0x40,
-        Sentinel = 0x41,
-        Pinned = 0x45,
+        ELEMENT_TYPE_END = 0x00,
+        ELEMENT_TYPE_VOID = 0x01,
+        ELEMENT_TYPE_BOOLEAN = 0x02,
+        ELEMENT_TYPE_CHAR = 0x03,
+        ELEMENT_TYPE_I1 = 0x04,
+        ELEMENT_TYPE_U1 = 0x05,
+        ELEMENT_TYPE_I2 = 0x06,
+        ELEMENT_TYPE_U2 = 0x07,
+        ELEMENT_TYPE_I4 = 0x08,
+        ELEMENT_TYPE_U4 = 0x09,
+        ELEMENT_TYPE_I8 = 0x0A,
+        ELEMENT_TYPE_U8 = 0x0B,
+        ELEMENT_TYPE_R4 = 0x0C,
+        ELEMENT_TYPE_R8 = 0x0D,
+        ELEMENT_TYPE_STRING = 0x0E,
+        ELEMENT_TYPE_PTR = 0x0F,
+        ELEMENT_TYPE_BYREF = 0x10,
+        ELEMENT_TYPE_VALUETYPE = 0x11,
+        ELEMENT_TYPE_CLASS = 0x12,
+        ELEMENT_TYPE_VAR = 0x13,
+        ELEMENT_TYPE_ARRAY = 0x14,
+        ELEMENT_TYPE_GENERICINST = 0x15,
+        ELEMENT_TYPE_TYPEDBYREF = 0x16,
+        ELEMENT_TYPE_I = 0x18,
+        ELEMENT_TYPE_U = 0x19,
+        ELEMENT_TYPE_FNPTR = 0x1B,
+        ELEMENT_TYPE_OBJECT = 0x1C,
+        ELEMENT_TYPE_SZARRAY = 0x1D,
+        ELEMENT_TYPE_MVAR = 0x1E,
+        ELEMENT_TYPE_CMOD_REQD = 0x1F,
+        ELEMENT_TYPE_CMOD_OPT = 0x20,
+        ELEMENT_TYPE_INTERNAL = 0x21,
+        ELEMENT_TYPE_MAX = 0x22,
+        ELEMENT_TYPE_MODIFIER = 0x40,
+        ELEMENT_TYPE_SENTINEL = 0x41,
+        ELEMENT_TYPE_PINNED = 0x45,
     }
 
     [Flags()]

diff --git a/src/System.Private.CoreLib/src/System/RtType.cs b/src/System.Private.CoreLib/src/System/RtType.cs
index 6cce52b..4e2a29a 100644 (file)
--- a/src/System.Private.CoreLib/src/System/RtType.cs
+++ b/src/System.Private.CoreLib/src/System/RtType.cs
@@ -3069,33 +3069,33 @@ namespace System
             CorElementType corElementType = RuntimeTypeHandle.GetCorElementType(this);
             switch (corElementType)
             {
-                case CorElementType.Boolean:
+                case CorElementType.ELEMENT_TYPE_BOOLEAN:
                     typeCode = TypeCode.Boolean; break;
-                case CorElementType.Char:
+                case CorElementType.ELEMENT_TYPE_CHAR:
                     typeCode = TypeCode.Char; break;
-                case CorElementType.I1:
+                case CorElementType.ELEMENT_TYPE_I1:
                     typeCode = TypeCode.SByte; break;
-                case CorElementType.U1:
+                case CorElementType.ELEMENT_TYPE_U1:
                     typeCode = TypeCode.Byte; break;
-                case CorElementType.I2:
+                case CorElementType.ELEMENT_TYPE_I2:
                     typeCode = TypeCode.Int16; break;
-                case CorElementType.U2:
+                case CorElementType.ELEMENT_TYPE_U2:
                     typeCode = TypeCode.UInt16; break;
-                case CorElementType.I4:
+                case CorElementType.ELEMENT_TYPE_I4:
                     typeCode = TypeCode.Int32; break;
-                case CorElementType.U4:
+                case CorElementType.ELEMENT_TYPE_U4:
                     typeCode = TypeCode.UInt32; break;
-                case CorElementType.I8:
+                case CorElementType.ELEMENT_TYPE_I8:
                     typeCode = TypeCode.Int64; break;
-                case CorElementType.U8:
+                case CorElementType.ELEMENT_TYPE_U8:
                     typeCode = TypeCode.UInt64; break;
-                case CorElementType.R4:
+                case CorElementType.ELEMENT_TYPE_R4:
                     typeCode = TypeCode.Single; break;
-                case CorElementType.R8:
+                case CorElementType.ELEMENT_TYPE_R8:
                     typeCode = TypeCode.Double; break;
-                case CorElementType.String:
+                case CorElementType.ELEMENT_TYPE_STRING:
                     typeCode = TypeCode.String; break;
-                case CorElementType.ValueType:
+                case CorElementType.ELEMENT_TYPE_VALUETYPE:
                     if (this == Convert.ConvertTypes[(int)TypeCode.Decimal])
                         typeCode = TypeCode.Decimal;
                     else if (this == Convert.ConvertTypes[(int)TypeCode.DateTime])

diff --git a/src/System.Private.CoreLib/src/System/RuntimeHandles.cs b/src/System.Private.CoreLib/src/System/RuntimeHandles.cs
index 29b3fe3..0d215ef 100644 (file)
--- a/src/System.Private.CoreLib/src/System/RuntimeHandles.cs
+++ b/src/System.Private.CoreLib/src/System/RuntimeHandles.cs
@@ -50,13 +50,13 @@ namespace System
                 int* arModifiers = (int*)pModifiers.ToPointer();
                 for (int i = 0; i < cModifiers; i++)
                 {
-                    if ((CorElementType)Marshal.ReadInt32((IntPtr)arModifiers, i * sizeof(int)) == CorElementType.Ptr)
+                    if ((CorElementType)Marshal.ReadInt32((IntPtr)arModifiers, i * sizeof(int)) == CorElementType.ELEMENT_TYPE_PTR)
                         type = type.MakePointerType();
 
-                    else if ((CorElementType)Marshal.ReadInt32((IntPtr)arModifiers, i * sizeof(int)) == CorElementType.ByRef)
+                    else if ((CorElementType)Marshal.ReadInt32((IntPtr)arModifiers, i * sizeof(int)) == CorElementType.ELEMENT_TYPE_BYREF)
                         type = type.MakeByRefType();
 
-                    else if ((CorElementType)Marshal.ReadInt32((IntPtr)arModifiers, i * sizeof(int)) == CorElementType.SzArray)
+                    else if ((CorElementType)Marshal.ReadInt32((IntPtr)arModifiers, i * sizeof(int)) == CorElementType.ELEMENT_TYPE_SZARRAY)
                         type = type.MakeArrayType();
 
                     else
@@ -117,13 +117,13 @@ namespace System
         internal static bool IsTypeDefinition(RuntimeType type)
         {
             CorElementType corElemType = GetCorElementType(type);
-            if (!((corElemType >= CorElementType.Void && corElemType < CorElementType.Ptr) ||
-                    corElemType == CorElementType.ValueType ||
-                    corElemType == CorElementType.Class ||
-                    corElemType == CorElementType.TypedByRef ||
-                    corElemType == CorElementType.I ||
-                    corElemType == CorElementType.U ||
-                    corElemType == CorElementType.Object))
+            if (!((corElemType >= CorElementType.ELEMENT_TYPE_VOID && corElemType < CorElementType.ELEMENT_TYPE_PTR) ||
+                    corElemType == CorElementType.ELEMENT_TYPE_VALUETYPE ||
+                    corElemType == CorElementType.ELEMENT_TYPE_CLASS ||
+                    corElemType == CorElementType.ELEMENT_TYPE_TYPEDBYREF ||
+                    corElemType == CorElementType.ELEMENT_TYPE_I ||
+                    corElemType == CorElementType.ELEMENT_TYPE_U ||
+                    corElemType == CorElementType.ELEMENT_TYPE_OBJECT))
                 return false;
 
             if (HasInstantiation(type) && !IsGenericTypeDefinition(type))
@@ -135,42 +135,42 @@ namespace System
         internal static bool IsPrimitive(RuntimeType type)
         {
             CorElementType corElemType = GetCorElementType(type);
-            return (corElemType >= CorElementType.Boolean && corElemType <= CorElementType.R8) ||
-                    corElemType == CorElementType.I ||
-                    corElemType == CorElementType.U;
+            return (corElemType >= CorElementType.ELEMENT_TYPE_BOOLEAN && corElemType <= CorElementType.ELEMENT_TYPE_R8) ||
+                    corElemType == CorElementType.ELEMENT_TYPE_I ||
+                    corElemType == CorElementType.ELEMENT_TYPE_U;
         }
 
         internal static bool IsByRef(RuntimeType type)
         {
             CorElementType corElemType = GetCorElementType(type);
-            return (corElemType == CorElementType.ByRef);
+            return (corElemType == CorElementType.ELEMENT_TYPE_BYREF);
         }
 
         internal static bool IsPointer(RuntimeType type)
         {
             CorElementType corElemType = GetCorElementType(type);
-            return (corElemType == CorElementType.Ptr);
+            return (corElemType == CorElementType.ELEMENT_TYPE_PTR);
         }
 
         internal static bool IsArray(RuntimeType type)
         {
             CorElementType corElemType = GetCorElementType(type);
-            return (corElemType == CorElementType.Array || corElemType == CorElementType.SzArray);
+            return (corElemType == CorElementType.ELEMENT_TYPE_ARRAY || corElemType == CorElementType.ELEMENT_TYPE_SZARRAY);
         }
 
         internal static bool IsSZArray(RuntimeType type)
         {
             CorElementType corElemType = GetCorElementType(type);
-            return (corElemType == CorElementType.SzArray);
+            return (corElemType == CorElementType.ELEMENT_TYPE_SZARRAY);
         }
 
         internal static bool HasElementType(RuntimeType type)
         {
             CorElementType corElemType = GetCorElementType(type);
 
-            return ((corElemType == CorElementType.Array || corElemType == CorElementType.SzArray) // IsArray
-                   || (corElemType == CorElementType.Ptr)                                          // IsPointer
-                   || (corElemType == CorElementType.ByRef));                                      // IsByRef
+            return ((corElemType == CorElementType.ELEMENT_TYPE_ARRAY || corElemType == CorElementType.ELEMENT_TYPE_SZARRAY) // IsArray
+                   || (corElemType == CorElementType.ELEMENT_TYPE_PTR)                                          // IsPointer
+                   || (corElemType == CorElementType.ELEMENT_TYPE_BYREF));                                      // IsByRef
         }
 
         internal static IntPtr[] CopyRuntimeTypeHandles(RuntimeTypeHandle[] inHandles, out int length)