private static object CallMethod(Symbols.Container BaseReference, string MethodName, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, bool[] CopyBack, BindingFlags InvocationFlags, bool ReportErrors, ref OverloadResolution.ResolutionFailure Failure)
{
Failure = OverloadResolution.ResolutionFailure.None;
if (ArgumentNames.Length > Arguments.Length || CopyBack != null && CopyBack.Length != Arguments.Length)
{
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (ReportErrors)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue"));
}
return((object)null);
}
if (Symbols.HasFlag(InvocationFlags, BindingFlags.SetProperty) && Arguments.Length < 1)
{
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (ReportErrors)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue"));
}
return((object)null);
}
MemberInfo[] members = BaseReference.GetMembers(ref MethodName, ReportErrors);
if (members == null || members.Length == 0)
{
Failure = OverloadResolution.ResolutionFailure.MissingMember;
if (ReportErrors)
{
BaseReference.GetMembers(ref MethodName, true);
}
return((object)null);
}
Symbols.Method TargetProcedure = NewLateBinding.ResolveCall(BaseReference, MethodName, members, Arguments, ArgumentNames, TypeArguments, InvocationFlags, ReportErrors, ref Failure);
if (Failure == OverloadResolution.ResolutionFailure.None)
{
return(BaseReference.InvokeMethod(TargetProcedure, Arguments, CopyBack, InvocationFlags));
}
return((object)null);
}
internal MemberInfo[] LookupNamedMembers(string MemberName)
{
MemberInfo[] Members;
if (Symbols.IsGenericParameter(this.m_Type))
{
Type classConstraint = Symbols.GetClassConstraint(this.m_Type);
Members = classConstraint == null ? (MemberInfo[])null : classConstraint.GetMember(MemberName, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
}
else
{
Members = this.m_IReflect.GetMember(MemberName, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
}
MemberInfo[] memberInfoArray = Symbols.Container.FilterInvalidMembers(Members);
if (memberInfoArray == null)
{
memberInfoArray = Symbols.Container.NoMembers;
}
else if (memberInfoArray.Length > 1)
{
Array.Sort((Array)memberInfoArray, (IComparer)Symbols.Container.InheritanceSorter.Instance);
}
return(memberInfoArray);
}
internal static bool RefersToGenericParameter(Type ReferringType, MethodBase Method)
{
if (!Symbols.IsRawGeneric(Method))
{
return(false);
}
if (ReferringType.IsByRef)
{
ReferringType = Symbols.GetElementType(ReferringType);
}
if (Symbols.IsGenericParameter(ReferringType))
{
if (Symbols.AreGenericMethodDefsEqual(ReferringType.DeclaringMethod, Method))
{
return(true);
}
}
else if (Symbols.IsGeneric(ReferringType))
{
Type[] typeArguments = Symbols.GetTypeArguments(ReferringType);
int index = 0;
while (index < typeArguments.Length)
{
if (Symbols.RefersToGenericParameter(typeArguments[index], Method))
{
return(true);
}
checked { ++index; }
}
}
else if (Symbols.IsArrayType(ReferringType))
{
return(Symbols.RefersToGenericParameter(ReferringType.GetElementType(), Method));
}
return(false);
}
private static MemberInfo[] FilterInvalidMembers(MemberInfo[] Members)
{
if (Members == null || Members.Length == 0)
{
return((MemberInfo[])null);
}
int num1 = 0;
int num2 = 0;
int num3 = checked (Members.Length - 1);
int index1 = num2;
while (index1 <= num3)
{
ParameterInfo[] Parameters = (ParameterInfo[])null;
Type ReturnType = (Type)null;
switch (Members[index1].MemberType)
{
case MemberTypes.Constructor:
case MemberTypes.Method:
MethodInfo member1 = (MethodInfo)Members[index1];
Parameters = member1.GetParameters();
ReturnType = member1.ReturnType;
break;
case MemberTypes.Field:
ReturnType = ((FieldInfo)Members[index1]).FieldType;
break;
case MemberTypes.Property:
PropertyInfo member2 = (PropertyInfo)Members[index1];
MethodInfo getMethod = member2.GetGetMethod();
if (getMethod != null)
{
Parameters = getMethod.GetParameters();
}
else
{
ParameterInfo[] parameters = member2.GetSetMethod().GetParameters();
Parameters = new ParameterInfo[checked (parameters.Length - 2 + 1)];
Array.Copy((Array)parameters, (Array)Parameters, Parameters.Length);
}
ReturnType = member2.PropertyType;
break;
}
if (Symbols.AreParametersAndReturnTypesValid(Parameters, ReturnType))
{
checked { ++num1; }
}
else
{
Members[index1] = (MemberInfo)null;
}
checked { ++index1; }
}
if (num1 == Members.Length)
{
return(Members);
}
if (num1 <= 0)
{
return((MemberInfo[])null);
}
MemberInfo[] memberInfoArray = new MemberInfo[checked (num1 - 1 + 1)];
int index2 = 0;
int num4 = 0;
int num5 = checked (Members.Length - 1);
int index3 = num4;
while (index3 <= num5)
{
if (Members[index3] != null)
{
memberInfoArray[index2] = Members[index3];
checked { ++index2; }
}
checked { ++index3; }
}
return(memberInfoArray);
}
internal static bool IsParamArray(ParameterInfo Parameter)
{
return(Symbols.IsArrayType(Parameter.ParameterType) && Parameter.IsDefined(typeof(ParamArrayAttribute), false));
}
internal static int IndexIn(Type PossibleGenericParameter, MethodBase GenericMethodDef)
{
if (Symbols.IsGenericParameter(PossibleGenericParameter) && PossibleGenericParameter.DeclaringMethod != null && Symbols.AreGenericMethodDefsEqual(PossibleGenericParameter.DeclaringMethod, GenericMethodDef))
{
return(PossibleGenericParameter.GenericParameterPosition);
}
return(-1);
}
internal static bool IsOrInheritsFrom(Type Derived, Type Base)
{
if (Derived == Base)
{
return(true);
}
if (Derived.IsGenericParameter)
{
if (Symbols.IsClass(Base) && (uint)(Derived.GenericParameterAttributes & GenericParameterAttributes.NotNullableValueTypeConstraint) > 0U && Symbols.IsOrInheritsFrom(typeof(ValueType), Base))
{
return(true);
}
Type[] parameterConstraints = Derived.GetGenericParameterConstraints();
int index = 0;
while (index < parameterConstraints.Length)
{
if (Symbols.IsOrInheritsFrom(parameterConstraints[index], Base))
{
return(true);
}
checked { ++index; }
}
}
else if (Symbols.IsInterface(Derived))
{
if (Symbols.IsInterface(Base))
{
Type[] interfaces = Derived.GetInterfaces();
int index = 0;
while (index < interfaces.Length)
{
if (interfaces[index] == Base)
{
return(true);
}
checked { ++index; }
}
}
}
else if (Symbols.IsClass(Base) && Symbols.IsClassOrValueType(Derived))
{
return(Derived.IsSubclassOf(Base));
}
return(false);
}
internal static bool IsReferenceType(Type Type)
{
return(Symbols.IsClass(Type) || Symbols.IsInterface(Type));
}
internal static bool IsClassOrValueType(Type Type)
{
return(Symbols.IsValueType(Type) || Symbols.IsClass(Type));
}
internal static bool IsClass(Type Type)
{
return(Type.IsClass || Symbols.IsRootEnumType(Type));
}
internal static bool IsIntrinsicType(Type Type)
{
return(Symbols.IsIntrinsicType(Symbols.GetTypeCode(Type)) && !Symbols.IsEnum(Type));
}
internal static bool IsNumericType(Type Type)
{
return(Symbols.IsNumericType(Symbols.GetTypeCode(Type)));
}
internal static string VBFriendlyNameOfType(Type typ, bool FullName = false)
{
string suffixAndElementType = Utils.GetArraySuffixAndElementType(ref typ);
string str1;
switch (!typ.IsEnum ? Type.GetTypeCode(typ) : TypeCode.Object)
{
case TypeCode.DBNull:
str1 = "DBNull";
break;
case TypeCode.Boolean:
str1 = "Boolean";
break;
case TypeCode.Char:
str1 = "Char";
break;
case TypeCode.SByte:
str1 = "SByte";
break;
case TypeCode.Byte:
str1 = "Byte";
break;
case TypeCode.Int16:
str1 = "Short";
break;
case TypeCode.UInt16:
str1 = "UShort";
break;
case TypeCode.Int32:
str1 = "Integer";
break;
case TypeCode.UInt32:
str1 = "UInteger";
break;
case TypeCode.Int64:
str1 = "Long";
break;
case TypeCode.UInt64:
str1 = "ULong";
break;
case TypeCode.Single:
str1 = "Single";
break;
case TypeCode.Double:
str1 = "Double";
break;
case TypeCode.Decimal:
str1 = "Decimal";
break;
case TypeCode.DateTime:
str1 = "Date";
break;
case TypeCode.String:
str1 = "String";
break;
default:
if (Symbols.IsGenericParameter(typ))
{
str1 = typ.Name;
break;
}
string str2 = (string)null;
string genericArgsSuffix = Utils.GetGenericArgsSuffix(typ);
string str3;
if (FullName)
{
if (typ.IsNested)
{
str2 = Utils.VBFriendlyNameOfType(typ.DeclaringType, true);
str3 = typ.Name;
}
else
{
str3 = typ.FullName;
}
}
else
{
str3 = typ.Name;
}
if (genericArgsSuffix != null)
{
int length = str3.LastIndexOf('`');
if (length != -1)
{
str3 = str3.Substring(0, length);
}
str1 = str3 + genericArgsSuffix;
}
else
{
str1 = str3;
}
if (str2 != null)
{
str1 = str2 + "." + str1;
break;
}
break;
}
if (suffixAndElementType != null)
{
str1 += suffixAndElementType;
}
return(str1);
}
internal static string PropertyToString(PropertyInfo Prop)
{
string str1 = "";
MethodInfo methodInfo = Prop.GetGetMethod();
Utils.PropertyKind propertyKind;
ParameterInfo[] parameterInfoArray1;
Type typ;
if (methodInfo != null)
{
propertyKind = Prop.GetSetMethod() == null ? Utils.PropertyKind.ReadOnly : Utils.PropertyKind.ReadWrite;
parameterInfoArray1 = methodInfo.GetParameters();
typ = methodInfo.ReturnType;
}
else
{
propertyKind = Utils.PropertyKind.WriteOnly;
methodInfo = Prop.GetSetMethod();
ParameterInfo[] parameters = methodInfo.GetParameters();
parameterInfoArray1 = new ParameterInfo[checked (parameters.Length - 2 + 1)];
Array.Copy((Array)parameters, (Array)parameterInfoArray1, parameterInfoArray1.Length);
typ = parameters[checked (parameters.Length - 1)].ParameterType;
}
string str2 = str1 + "Public ";
if ((methodInfo.Attributes & MethodAttributes.Virtual) != MethodAttributes.PrivateScope)
{
if (!Prop.DeclaringType.IsInterface)
{
str2 += "Overrides ";
}
}
else if (Symbols.IsShared((MemberInfo)methodInfo))
{
str2 += "Shared ";
}
if (propertyKind == Utils.PropertyKind.ReadOnly)
{
str2 += "ReadOnly ";
}
if (propertyKind == Utils.PropertyKind.WriteOnly)
{
str2 += "WriteOnly ";
}
string str3 = str2 + "Property " + Prop.Name + "(";
bool flag = true;
ParameterInfo[] parameterInfoArray2 = parameterInfoArray1;
int index = 0;
while (index < parameterInfoArray2.Length)
{
ParameterInfo Parameter = parameterInfoArray2[index];
if (!flag)
{
str3 += ", ";
}
else
{
flag = false;
}
str3 += Utils.ParameterToString(Parameter);
checked { ++index; }
}
return(str3 + ") As " + Utils.VBFriendlyNameOfType(typ, true));
}
/// <summary>Returns a Visual Basic method signature.</summary>
/// <param name="Method">A <see cref="T:System.Reflection.MethodBase" /> object to return a Visual Basic method signature for.</param>
/// <returns>The Visual Basic method signature for the supplied <see cref="T:System.Reflection.MethodBase" /> object.</returns>
public static string MethodToString(MethodBase Method)
{
Type typ1 = (Type)null;
string str1 = "";
if (Method.MemberType == MemberTypes.Method)
{
typ1 = ((MethodInfo)Method).ReturnType;
}
if (Method.IsPublic)
{
str1 += "Public ";
}
else if (Method.IsPrivate)
{
str1 += "Private ";
}
else if (Method.IsAssembly)
{
str1 += "Friend ";
}
if ((Method.Attributes & MethodAttributes.Virtual) != MethodAttributes.PrivateScope)
{
if (!Method.DeclaringType.IsInterface)
{
str1 += "Overrides ";
}
}
else if (Symbols.IsShared((MemberInfo)Method))
{
str1 += "Shared ";
}
Symbols.UserDefinedOperator userDefinedOperator = Symbols.UserDefinedOperator.UNDEF;
if (Symbols.IsUserDefinedOperator(Method))
{
userDefinedOperator = Symbols.MapToUserDefinedOperator(Method);
}
string str2;
switch (userDefinedOperator)
{
case Symbols.UserDefinedOperator.UNDEF:
str2 = typ1 == null || typ1 == Utils.VoidType ? str1 + "Sub " : str1 + "Function ";
break;
case Symbols.UserDefinedOperator.Narrow:
str1 += "Narrowing ";
goto default;
case Symbols.UserDefinedOperator.Widen:
str1 += "Widening ";
goto default;
default:
str2 = str1 + "Operator ";
break;
}
string str3 = userDefinedOperator == Symbols.UserDefinedOperator.UNDEF ? (Method.MemberType != MemberTypes.Constructor ? str2 + Method.Name : str2 + "New") : str2 + Symbols.OperatorNames[(int)userDefinedOperator];
if (Symbols.IsGeneric(Method))
{
string str4 = str3 + "(Of ";
bool flag = true;
Type[] typeParameters = Symbols.GetTypeParameters((MemberInfo)Method);
int index = 0;
while (index < typeParameters.Length)
{
Type typ2 = typeParameters[index];
if (!flag)
{
str4 += ", ";
}
else
{
flag = false;
}
str4 += Utils.VBFriendlyNameOfType(typ2, false);
checked { ++index; }
}
str3 = str4 + ")";
}
string str5 = str3 + "(";
bool flag1 = true;
ParameterInfo[] parameters = Method.GetParameters();
int index1 = 0;
while (index1 < parameters.Length)
{
ParameterInfo Parameter = parameters[index1];
if (!flag1)
{
str5 += ", ";
}
else
{
flag1 = false;
}
str5 += Utils.ParameterToString(Parameter);
checked { ++index1; }
}
string str6 = str5 + ")";
if (typ1 != null && typ1 != Utils.VoidType)
{
str6 = str6 + " As " + Utils.VBFriendlyNameOfType(typ1, true);
}
return(str6);
}
internal static Symbols.Method ResolveCall(Symbols.Container BaseReference, string MethodName, MemberInfo[] Members, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, BindingFlags LookupFlags, bool ReportErrors, ref OverloadResolution.ResolutionFailure Failure)
{
Failure = OverloadResolution.ResolutionFailure.None;
if (Members[0].MemberType != MemberTypes.Method && Members[0].MemberType != MemberTypes.Property)
{
Failure = OverloadResolution.ResolutionFailure.InvalidTarget;
if (ReportErrors)
{
throw new ArgumentException(Utils.GetResourceString("ExpressionNotProcedure", MethodName, BaseReference.VBFriendlyName));
}
return((Symbols.Method)null);
}
int length = Arguments.Length;
object obj1 = (object)null;
if (Symbols.HasFlag(LookupFlags, BindingFlags.SetProperty))
{
if (Arguments.Length == 0)
{
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (ReportErrors)
{
throw new InvalidCastException(Utils.GetResourceString("PropertySetMissingArgument1", new string[1]
{
MethodName
}));
}
return((Symbols.Method)null);
}
object[] objArray = Arguments;
Arguments = new object[checked (length - 2 + 1)];
Array.Copy((Array)objArray, (Array)Arguments, Arguments.Length);
obj1 = objArray[checked (length - 1)];
}
Symbols.Method TargetProcedure1 = OverloadResolution.ResolveOverloadedCall(MethodName, Members, Arguments, ArgumentNames, TypeArguments, LookupFlags, ReportErrors, ref Failure);
if (Failure != OverloadResolution.ResolutionFailure.None)
{
return((Symbols.Method)null);
}
if (!TargetProcedure1.ArgumentsValidated && !OverloadResolution.CanMatchArguments(TargetProcedure1, Arguments, ArgumentNames, TypeArguments, false, (List <string>)null))
{
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (ReportErrors)
{
string str = "";
List <string> Errors = new List <string>();
OverloadResolution.CanMatchArguments(TargetProcedure1, Arguments, ArgumentNames, TypeArguments, false, Errors);
List <string> .Enumerator enumerator = Ported.VisualBasic.CompilerServices.OverloadResolution.InitEnumerator <string>();
try
{
enumerator = Errors.GetEnumerator();
while (enumerator.MoveNext())
{
string current = enumerator.Current;
str = str + "\r\n " + current;
}
}
finally
{
enumerator.Dispose();
}
throw new InvalidCastException(Utils.GetResourceString("MatchArgumentFailure2", TargetProcedure1.ToString(), str));
}
return((Symbols.Method)null);
}
if (TargetProcedure1.IsProperty)
{
if (NewLateBinding.MatchesPropertyRequirements(TargetProcedure1, LookupFlags) == null)
{
Failure = OverloadResolution.ResolutionFailure.InvalidTarget;
if (ReportErrors)
{
throw NewLateBinding.ReportPropertyMismatch(TargetProcedure1, LookupFlags);
}
return((Symbols.Method)null);
}
}
else if (Symbols.HasFlag(LookupFlags, BindingFlags.SetProperty))
{
Failure = OverloadResolution.ResolutionFailure.InvalidTarget;
if (ReportErrors)
{
throw new MissingMemberException(Utils.GetResourceString("MethodAssignment1", new string[1]
{
TargetProcedure1.AsMethod().Name
}));
}
return((Symbols.Method)null);
}
if (Symbols.HasFlag(LookupFlags, BindingFlags.SetProperty))
{
ParameterInfo[] parameters = NewLateBinding.GetCallTarget(TargetProcedure1, LookupFlags).GetParameters();
ParameterInfo parameterInfo = parameters[checked (parameters.Length - 1)];
Symbols.Method TargetProcedure2 = TargetProcedure1;
object obj2 = obj1;
ParameterInfo Parameter1 = parameterInfo;
int num1 = 0;
int num2 = 0;
// ISSUE: variable of the null type
object local1 = null;
bool flag1 = false;
ref bool local2 = ref flag1;
bool flag2 = false;
ref bool local3 = ref flag2;
