From 3bbfc2d7c6bff96ba1a76992e3c4afaded8095a9 Mon Sep 17 00:00:00 2001 From: Atsushi Kanamori Date: Wed, 15 Mar 2017 12:55:21 -0700 Subject: [PATCH] Prepare MethodBase.cs for migration to shared partition. (dotnet/coreclr#10194) * Clone the files w/out changes. * Distill each file to its intended subset. * Minimize usings. * Renamed to *.CoreClr.cs - extended free car wash to fix the nits. Commit migrated from https://github.com/dotnet/coreclr/commit/eb54ecde215f4aa705151f66e8b3b593ca0b3772 --- .../src/mscorlib/System.Private.CoreLib.csproj | 2 + .../src/System/Reflection/INVOCATION_FLAGS.cs | 38 ++++ .../src/System/Reflection/MethodBase.CoreCLR.cs | 157 +++++++++++++++++ .../mscorlib/src/System/Reflection/MethodBase.cs | 191 +-------------------- 4 files changed, 200 insertions(+), 188 deletions(-) create mode 100644 src/coreclr/src/mscorlib/src/System/Reflection/INVOCATION_FLAGS.cs create mode 100644 src/coreclr/src/mscorlib/src/System/Reflection/MethodBase.CoreCLR.cs diff --git a/src/coreclr/src/mscorlib/System.Private.CoreLib.csproj b/src/coreclr/src/mscorlib/System.Private.CoreLib.csproj index cf14056..22ac071 100644 --- a/src/coreclr/src/mscorlib/System.Private.CoreLib.csproj +++ b/src/coreclr/src/mscorlib/System.Private.CoreLib.csproj @@ -473,6 +473,7 @@ + @@ -484,6 +485,7 @@ + diff --git a/src/coreclr/src/mscorlib/src/System/Reflection/INVOCATION_FLAGS.cs b/src/coreclr/src/mscorlib/src/System/Reflection/INVOCATION_FLAGS.cs new file mode 100644 index 0000000..6ffc3e9 --- /dev/null +++ b/src/coreclr/src/mscorlib/src/System/Reflection/INVOCATION_FLAGS.cs @@ -0,0 +1,38 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +namespace System.Reflection +{ + // + // Invocation cached flags. Those are used in unmanaged code as well + // so be careful if you change them + // + [Flags] + internal enum INVOCATION_FLAGS : uint + { + INVOCATION_FLAGS_UNKNOWN = 0x00000000, + INVOCATION_FLAGS_INITIALIZED = 0x00000001, + // it's used for both method and field to signify that no access is allowed + INVOCATION_FLAGS_NO_INVOKE = 0x00000002, + INVOCATION_FLAGS_NEED_SECURITY = 0x00000004, + // Set for static ctors and ctors on abstract types, which + // can be invoked only if the "this" object is provided (even if it's null). + INVOCATION_FLAGS_NO_CTOR_INVOKE = 0x00000008, + // because field and method are different we can reuse the same bits + // method + INVOCATION_FLAGS_IS_CTOR = 0x00000010, + INVOCATION_FLAGS_RISKY_METHOD = 0x00000020, + /* unused 0x00000040 */ + INVOCATION_FLAGS_IS_DELEGATE_CTOR = 0x00000080, + INVOCATION_FLAGS_CONTAINS_STACK_POINTERS = 0x00000100, + // field + INVOCATION_FLAGS_SPECIAL_FIELD = 0x00000010, + INVOCATION_FLAGS_FIELD_SPECIAL_CAST = 0x00000020, + + // temporary flag used for flagging invocation of method vs ctor + // this flag never appears on the instance m_invocationFlag and is simply + // passed down from within ConstructorInfo.Invoke() + INVOCATION_FLAGS_CONSTRUCTOR_INVOKE = 0x10000000, + } +} diff --git a/src/coreclr/src/mscorlib/src/System/Reflection/MethodBase.CoreCLR.cs b/src/coreclr/src/mscorlib/src/System/Reflection/MethodBase.CoreCLR.cs new file mode 100644 index 0000000..384b2dd --- /dev/null +++ b/src/coreclr/src/mscorlib/src/System/Reflection/MethodBase.CoreCLR.cs @@ -0,0 +1,157 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.Diagnostics; +using System.Globalization; +using System.Text; +using System.Threading; + +namespace System.Reflection +{ + public abstract partial class MethodBase : MemberInfo + { + #region Static Members + public static MethodBase GetMethodFromHandle(RuntimeMethodHandle handle) + { + if (handle.IsNullHandle()) + throw new ArgumentException(Environment.GetResourceString("Argument_InvalidHandle")); + + MethodBase m = RuntimeType.GetMethodBase(handle.GetMethodInfo()); + + Type declaringType = m.DeclaringType; + if (declaringType != null && declaringType.IsGenericType) + throw new ArgumentException(String.Format( + CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_MethodDeclaringTypeGeneric"), + m, declaringType.GetGenericTypeDefinition())); + + return m; + } + + public static MethodBase GetMethodFromHandle(RuntimeMethodHandle handle, RuntimeTypeHandle declaringType) + { + if (handle.IsNullHandle()) + throw new ArgumentException(Environment.GetResourceString("Argument_InvalidHandle")); + + return RuntimeType.GetMethodBase(declaringType.GetRuntimeType(), handle.GetMethodInfo()); + } + + [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod + public static MethodBase GetCurrentMethod() + { + StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; + return RuntimeMethodInfo.InternalGetCurrentMethod(ref stackMark); + } + #endregion + + #region Internal Members + // used by EE + private IntPtr GetMethodDesc() { return MethodHandle.Value; } + + internal virtual ParameterInfo[] GetParametersNoCopy() { return GetParameters(); } + #endregion + + #region Internal Methods + // helper method to construct the string representation of the parameter list + + internal static string ConstructParameters(Type[] parameterTypes, CallingConventions callingConvention, bool serialization) + { + StringBuilder sbParamList = new StringBuilder(); + string comma = ""; + + for (int i = 0; i < parameterTypes.Length; i++) + { + Type t = parameterTypes[i]; + + sbParamList.Append(comma); + + string typeName = t.FormatTypeName(serialization); + + // Legacy: Why use "ByRef" for by ref parameters? What language is this? + // VB uses "ByRef" but it should precede (not follow) the parameter name. + // Why don't we just use "&"? + if (t.IsByRef && !serialization) + { + sbParamList.Append(typeName.TrimEnd('&')); + sbParamList.Append(" ByRef"); + } + else + { + sbParamList.Append(typeName); + } + + comma = ", "; + } + + if ((callingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs) + { + sbParamList.Append(comma); + sbParamList.Append("..."); + } + + return sbParamList.ToString(); + } + + internal string FullName + { + get + { + return String.Format("{0}.{1}", DeclaringType.FullName, FormatNameAndSig()); + } + } + internal string FormatNameAndSig() + { + return FormatNameAndSig(false); + } + + internal virtual string FormatNameAndSig(bool serialization) + { + // Serialization uses ToString to resolve MethodInfo overloads. + StringBuilder sbName = new StringBuilder(Name); + + sbName.Append("("); + sbName.Append(ConstructParameters(GetParameterTypes(), CallingConvention, serialization)); + sbName.Append(")"); + + return sbName.ToString(); + } + + internal virtual Type[] GetParameterTypes() + { + ParameterInfo[] paramInfo = GetParametersNoCopy(); + + Type[] parameterTypes = new Type[paramInfo.Length]; + for (int i = 0; i < paramInfo.Length; i++) + parameterTypes[i] = paramInfo[i].ParameterType; + + return parameterTypes; + } + + internal Object[] CheckArguments(Object[] parameters, Binder binder, + BindingFlags invokeAttr, CultureInfo culture, Signature sig) + { + // copy the arguments in a different array so we detach from any user changes + Object[] copyOfParameters = new Object[parameters.Length]; + + ParameterInfo[] p = null; + for (int i = 0; i < parameters.Length; i++) + { + Object arg = parameters[i]; + RuntimeType argRT = sig.Arguments[i]; + + if (arg == Type.Missing) + { + if (p == null) + p = GetParametersNoCopy(); + if (p[i].DefaultValue == System.DBNull.Value) + throw new ArgumentException(Environment.GetResourceString("Arg_VarMissNull"), nameof(parameters)); + arg = p[i].DefaultValue; + } + copyOfParameters[i] = argRT.CheckValue(arg, binder, culture, invokeAttr); + } + + return copyOfParameters; + } + #endregion + } +} diff --git a/src/coreclr/src/mscorlib/src/System/Reflection/MethodBase.cs b/src/coreclr/src/mscorlib/src/System/Reflection/MethodBase.cs index afccf27..bf254b1 100644 --- a/src/coreclr/src/mscorlib/src/System/Reflection/MethodBase.cs +++ b/src/coreclr/src/mscorlib/src/System/Reflection/MethodBase.cs @@ -2,86 +2,14 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. -// +using System.Diagnostics; +using System.Globalization; namespace System.Reflection { - using System; - using System.Diagnostics; - using System.Globalization; - using System.Runtime.CompilerServices; - using System.Runtime.InteropServices; - using System.Text; - using System.Threading; - - // - // Invocation cached flags. Those are used in unmanaged code as well - // so be careful if you change them - // - [Flags] - internal enum INVOCATION_FLAGS : uint - { - INVOCATION_FLAGS_UNKNOWN = 0x00000000, - INVOCATION_FLAGS_INITIALIZED = 0x00000001, - // it's used for both method and field to signify that no access is allowed - INVOCATION_FLAGS_NO_INVOKE = 0x00000002, - INVOCATION_FLAGS_NEED_SECURITY = 0x00000004, - // Set for static ctors and ctors on abstract types, which - // can be invoked only if the "this" object is provided (even if it's null). - INVOCATION_FLAGS_NO_CTOR_INVOKE = 0x00000008, - // because field and method are different we can reuse the same bits - // method - INVOCATION_FLAGS_IS_CTOR = 0x00000010, - INVOCATION_FLAGS_RISKY_METHOD = 0x00000020, - /* unused 0x00000040 */ - INVOCATION_FLAGS_IS_DELEGATE_CTOR = 0x00000080, - INVOCATION_FLAGS_CONTAINS_STACK_POINTERS = 0x00000100, - // field - INVOCATION_FLAGS_SPECIAL_FIELD = 0x00000010, - INVOCATION_FLAGS_FIELD_SPECIAL_CAST = 0x00000020, - - // temporary flag used for flagging invocation of method vs ctor - // this flag never appears on the instance m_invocationFlag and is simply - // passed down from within ConstructorInfo.Invoke() - INVOCATION_FLAGS_CONSTRUCTOR_INVOKE = 0x10000000, - } - [Serializable] - public abstract class MethodBase : MemberInfo + public abstract partial class MethodBase : MemberInfo { - #region Static Members - public static MethodBase GetMethodFromHandle(RuntimeMethodHandle handle) - { - if (handle.IsNullHandle()) - throw new ArgumentException(Environment.GetResourceString("Argument_InvalidHandle")); - - MethodBase m = RuntimeType.GetMethodBase(handle.GetMethodInfo()); - - Type declaringType = m.DeclaringType; - if (declaringType != null && declaringType.IsGenericType) - throw new ArgumentException(String.Format( - CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_MethodDeclaringTypeGeneric"), - m, declaringType.GetGenericTypeDefinition())); - - return m; - } - - public static MethodBase GetMethodFromHandle(RuntimeMethodHandle handle, RuntimeTypeHandle declaringType) - { - if (handle.IsNullHandle()) - throw new ArgumentException(Environment.GetResourceString("Argument_InvalidHandle")); - - return RuntimeType.GetMethodBase(declaringType.GetRuntimeType(), handle.GetMethodInfo()); - } - - [System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod - public static MethodBase GetCurrentMethod() - { - StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller; - return RuntimeMethodInfo.InternalGetCurrentMethod(ref stackMark); - } - #endregion - #region Constructor protected MethodBase() { } #endregion @@ -120,17 +48,7 @@ namespace System.Reflection return base.GetHashCode(); } - #region Internal Members - // used by EE - private IntPtr GetMethodDesc() { return MethodHandle.Value; } - -#if FEATURE_APPX -#endif - #endregion - #region Public Abstract\Virtual Members - internal virtual ParameterInfo[] GetParametersNoCopy() { return GetParameters(); } - [System.Diagnostics.Contracts.Pure] public abstract ParameterInfo[] GetParameters(); @@ -226,108 +144,5 @@ namespace System.Reflection throw new InvalidOperationException(); } #endregion - - #region Internal Methods - // helper method to construct the string representation of the parameter list - - internal static string ConstructParameters(Type[] parameterTypes, CallingConventions callingConvention, bool serialization) - { - StringBuilder sbParamList = new StringBuilder(); - string comma = ""; - - for (int i = 0; i < parameterTypes.Length; i++) - { - Type t = parameterTypes[i]; - - sbParamList.Append(comma); - - string typeName = t.FormatTypeName(serialization); - - // Legacy: Why use "ByRef" for by ref parameters? What language is this? - // VB uses "ByRef" but it should precede (not follow) the parameter name. - // Why don't we just use "&"? - if (t.IsByRef && !serialization) - { - sbParamList.Append(typeName.TrimEnd('&')); - sbParamList.Append(" ByRef"); - } - else - { - sbParamList.Append(typeName); - } - - comma = ", "; - } - - if ((callingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs) - { - sbParamList.Append(comma); - sbParamList.Append("..."); - } - - return sbParamList.ToString(); - } - - internal string FullName - { - get - { - return String.Format("{0}.{1}", DeclaringType.FullName, FormatNameAndSig()); - } - } - internal string FormatNameAndSig() - { - return FormatNameAndSig(false); - } - - internal virtual string FormatNameAndSig(bool serialization) - { - // Serialization uses ToString to resolve MethodInfo overloads. - StringBuilder sbName = new StringBuilder(Name); - - sbName.Append("("); - sbName.Append(ConstructParameters(GetParameterTypes(), CallingConvention, serialization)); - sbName.Append(")"); - - return sbName.ToString(); - } - - internal virtual Type[] GetParameterTypes() - { - ParameterInfo[] paramInfo = GetParametersNoCopy(); - - Type[] parameterTypes = new Type[paramInfo.Length]; - for (int i = 0; i < paramInfo.Length; i++) - parameterTypes[i] = paramInfo[i].ParameterType; - - return parameterTypes; - } - - internal Object[] CheckArguments(Object[] parameters, Binder binder, - BindingFlags invokeAttr, CultureInfo culture, Signature sig) - { - // copy the arguments in a different array so we detach from any user changes - Object[] copyOfParameters = new Object[parameters.Length]; - - ParameterInfo[] p = null; - for (int i = 0; i < parameters.Length; i++) - { - Object arg = parameters[i]; - RuntimeType argRT = sig.Arguments[i]; - - if (arg == Type.Missing) - { - if (p == null) - p = GetParametersNoCopy(); - if (p[i].DefaultValue == System.DBNull.Value) - throw new ArgumentException(Environment.GetResourceString("Arg_VarMissNull"), nameof(parameters)); - arg = p[i].DefaultValue; - } - copyOfParameters[i] = argRT.CheckValue(arg, binder, culture, invokeAttr); - } - - return copyOfParameters; - } - #endregion } } -- 2.7.4