1 files changed, 157 insertions, 0 deletions
diff --git a/src/mscorlib/src/System/Reflection/MethodBase.CoreCLR.cs b/src/mscorlib/src/System/Reflection/MethodBase.CoreCLR.cs
new file mode 100644
index 0000000000..3afd396471
--- /dev/null
+++ b/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(SR.Argument_InvalidHandle);
+
+            MethodBase m = RuntimeType.GetMethodBase(handle.GetMethodInfo());
+
+            Type declaringType = m.DeclaringType;
+            if (declaringType != null && declaringType.IsGenericType)
+                throw new ArgumentException(String.Format(
+                    CultureInfo.CurrentCulture, SR.Argument_MethodDeclaringTypeGeneric,
+                    m, declaringType.GetGenericTypeDefinition()));
+
+            return m;
+        }
+
+        public static MethodBase GetMethodFromHandle(RuntimeMethodHandle handle, RuntimeTypeHandle declaringType)
+        {
+            if (handle.IsNullHandle())
+                throw new ArgumentException(SR.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(SR.Arg_VarMissNull, nameof(parameters));
+                    arg = p[i].DefaultValue;
+                }
+                copyOfParameters[i] = argRT.CheckValue(arg, binder, culture, invokeAttr);
+            }
+
+            return copyOfParameters;
+        }
+        #endregion
+    }
+}