Imported Upstream version 6.0.0.172

Former-commit-id: f3cc9b82f3e5bd8f0fd3ebc098f789556b44e9cd

mcs/class/corlib/ReferenceSources/MethodBase.cs

@@ -2,7 +2,9 @@
 using System.Reflection.Emit;
 #endif
 
+using System.Globalization;
 using System.Runtime.CompilerServices;
+using System.Text;
 
 namespace System.Reflection
 {
@@ -44,30 +46,112 @@ namespace System.Reflection
 			throw new Exception ("Method is not a builder method");
 		}
 
-		internal static MethodBase GetMethodFromHandleNoGenericCheck (RuntimeMethodHandle handle)
+		internal virtual string FormatNameAndSig (bool serialization)
 		{
-			return GetMethodFromHandleInternalType_native (handle.Value, IntPtr.Zero, false);
+			// 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 static MethodBase GetMethodFromHandleNoGenericCheck (RuntimeMethodHandle handle, RuntimeTypeHandle reflectedType)
+		internal virtual Type[] GetParameterTypes ()
 		{
-			return GetMethodFromHandleInternalType_native (handle.Value, reflectedType.Value, false);
+			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 virtual ParameterInfo[] GetParametersNoCopy () => GetParameters ();
+
+		public static MethodBase GetMethodFromHandle (RuntimeMethodHandle handle)
+		{
+			if (handle.IsNullHandle ())
+				throw new ArgumentException (Environment.GetResourceString("Argument_InvalidHandle"));
+
+#if MONO
+			MethodBase m = RuntimeMethodInfo.GetMethodFromHandleInternalType (handle.Value, IntPtr.Zero);
+			if (m == null)
+				throw new ArgumentException ("The handle is invalid.");
+#else
+			MethodBase m = RuntimeType.GetMethodBase (handle.GetMethodInfo ());
+#endif
+
+			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;
+		}
+
+		[System.Runtime.InteropServices.ComVisible(false)]
+		public static MethodBase GetMethodFromHandle (RuntimeMethodHandle handle, RuntimeTypeHandle declaringType)
+		{
+			if (handle.IsNullHandle ())
+				throw new ArgumentException (Environment.GetResourceString("Argument_InvalidHandle"));
+#if MONO
+			MethodBase m = RuntimeMethodInfo.GetMethodFromHandleInternalType (handle.Value, declaringType.Value);
+			if (m == null)
+				throw new ArgumentException ("The handle is invalid.");
+			return m;
+#else
+			return RuntimeType.GetMethodBase (declaringType.GetRuntimeType (), handle.GetMethodInfo ());
+#endif
+		}
+
+		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 (new char[] { '&' }));
+					sbParamList.Append (" ByRef");
+				} else {
+					sbParamList.Append (typeName);
+				}
+
+				comma = ", ";
+			}
+
+			if ((callingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs) {
+				sbParamList.Append (comma);
+				sbParamList.Append ("...");
+			}
+
+			return sbParamList.ToString ();
+		}
+
+#if MONO
 		[MethodImplAttribute (MethodImplOptions.InternalCall)]
-		internal extern static MethodBody GetMethodBodyInternal (IntPtr handle);
-
-		internal static MethodBody GetMethodBody (IntPtr handle) 
+		public extern static MethodBase GetCurrentMethod ();
+#else
+		[System.Security.DynamicSecurityMethod] // Specify DynamicSecurityMethod attribute to prevent inlining of the caller.
+		[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+		public static MethodBase GetCurrentMethod ()
 		{
-			return GetMethodBodyInternal (handle);
+			StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+			return RuntimeMethodInfo.InternalGetCurrentMethod (ref stackMark);
 		}
-
-		static MethodBase GetMethodFromHandleInternalType (IntPtr method_handle, IntPtr type_handle) {
-			return GetMethodFromHandleInternalType_native (method_handle, type_handle, true);
-		}
-
-		[MethodImplAttribute (MethodImplOptions.InternalCall)]
-		internal extern static MethodBase GetMethodFromHandleInternalType_native (IntPtr method_handle, IntPtr type_handle, bool genericCheck);
-
+#endif
 	}
 }