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 null;
}
if (Symbols.HasFlag(InvocationFlags, BindingFlags.SetProperty) && (Arguments.Length < 1))
{
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (ReportErrors)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue"));
}
return null;
}
MemberInfo[] members = BaseReference.GetMembers(ref MethodName, ReportErrors);
if ((members == null) || (members.Length == 0))
{
Failure = OverloadResolution.ResolutionFailure.MissingMember;
if (ReportErrors)
{
members = BaseReference.GetMembers(ref MethodName, true);
}
return null;
}
Symbols.Method targetProcedure = ResolveCall(BaseReference, MethodName, members, Arguments, ArgumentNames, TypeArguments, InvocationFlags, ReportErrors, ref Failure);
if (Failure == OverloadResolution.ResolutionFailure.None)
{
return BaseReference.InvokeMethod(targetProcedure, Arguments, CopyBack, InvocationFlags);
}
return null;
}
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(null);
}
if (Symbols.HasFlag(InvocationFlags, BindingFlags.SetProperty) && (Arguments.Length < 1))
{
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (ReportErrors)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue"));
}
return(null);
}
MemberInfo[] members = BaseReference.GetMembers(ref MethodName, ReportErrors);
if ((members == null) || (members.Length == 0))
{
Failure = OverloadResolution.ResolutionFailure.MissingMember;
if (ReportErrors)
{
members = BaseReference.GetMembers(ref MethodName, true);
}
return(null);
}
Symbols.Method targetProcedure = ResolveCall(BaseReference, MethodName, members, Arguments, ArgumentNames, TypeArguments, InvocationFlags, ReportErrors, ref Failure);
if (Failure == OverloadResolution.ResolutionFailure.None)
{
return(BaseReference.InvokeMethod(targetProcedure, Arguments, CopyBack, InvocationFlags));
}
return(null);
}
private static void InsertInOperatorListIfLessGenericThanExisting(Symbols.Method OperatorToInsert, List <Symbols.Method> OperatorList, ref bool GenericMembersExistInList)
{
if (Symbols.IsGeneric(OperatorToInsert.DeclaringType))
{
GenericMembersExistInList = true;
}
if (GenericMembersExistInList)
{
for (int i = OperatorList.Count - 1; i >= 0; i += -1)
{
Symbols.Method left = OperatorList[i];
Symbols.Method method2 = OverloadResolution.LeastGenericProcedure(left, OperatorToInsert);
if (method2 == left)
{
return;
}
if (method2 != null)
{
OperatorList.Remove(left);
}
}
}
OperatorList.Add(OperatorToInsert);
}
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", new string[] { MethodName, BaseReference.VBFriendlyName }));
}
return(null);
}
int length = Arguments.Length;
object argument = 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[] { MethodName }));
}
return(null);
}
object[] sourceArray = Arguments;
Arguments = new object[(length - 2) + 1];
Array.Copy(sourceArray, Arguments, Arguments.Length);
argument = sourceArray[length - 1];
}
Symbols.Method targetProcedure = OverloadResolution.ResolveOverloadedCall(MethodName, Members, Arguments, ArgumentNames, TypeArguments, LookupFlags, ReportErrors, ref Failure);
if (Failure != OverloadResolution.ResolutionFailure.None)
{
return(null);
}
if (!targetProcedure.ArgumentsValidated && !OverloadResolution.CanMatchArguments(targetProcedure, Arguments, ArgumentNames, TypeArguments, false, null))
{
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (!ReportErrors)
{
return(null);
}
string str = "";
List <string> list = new List <string>();
bool flag = OverloadResolution.CanMatchArguments(targetProcedure, Arguments, ArgumentNames, TypeArguments, false, list);
foreach (string str2 in list)
{
str = str + "\r\n " + str2;
}
throw new InvalidCastException(Utils.GetResourceString("MatchArgumentFailure2", new string[] { targetProcedure.ToString(), str }));
}
if (targetProcedure.IsProperty)
{
if (MatchesPropertyRequirements(targetProcedure, LookupFlags) == null)
{
Failure = OverloadResolution.ResolutionFailure.InvalidTarget;
if (ReportErrors)
{
throw ReportPropertyMismatch(targetProcedure, LookupFlags);
}
return(null);
}
}
else if (Symbols.HasFlag(LookupFlags, BindingFlags.SetProperty))
{
Failure = OverloadResolution.ResolutionFailure.InvalidTarget;
if (ReportErrors)
{
throw new MissingMemberException(Utils.GetResourceString("MethodAssignment1", new string[] { targetProcedure.AsMethod().Name }));
}
return(null);
}
if (!Symbols.HasFlag(LookupFlags, BindingFlags.SetProperty))
{
return(targetProcedure);
}
ParameterInfo[] parameters = GetCallTarget(targetProcedure, LookupFlags).GetParameters();
ParameterInfo parameter = parameters[parameters.Length - 1];
bool requiresNarrowingConversion = false;
bool allNarrowingIsFromObject = false;
if (OverloadResolution.CanPassToParameter(targetProcedure, argument, parameter, false, false, null, ref requiresNarrowingConversion, ref allNarrowingIsFromObject))
{
return(targetProcedure);
}
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (!ReportErrors)
{
return(null);
}
string str3 = "";
List <string> errors = new List <string>();
allNarrowingIsFromObject = false;
requiresNarrowingConversion = false;
bool flag2 = OverloadResolution.CanPassToParameter(targetProcedure, argument, parameter, false, false, errors, ref allNarrowingIsFromObject, ref requiresNarrowingConversion);
foreach (string str4 in errors)
{
str3 = str3 + "\r\n " + str4;
}
throw new InvalidCastException(Utils.GetResourceString("MatchArgumentFailure2", new string[] { targetProcedure.ToString(), str3 }));
}
internal static string PropertyToString(PropertyInfo Prop)
{
ParameterInfo[] parameters;
Type returnType;
string str2 = "";
PropertyKind readWrite = PropertyKind.ReadWrite;
MethodInfo getMethod = Prop.GetGetMethod();
if (getMethod != null)
{
if (Prop.GetSetMethod() != null)
{
readWrite = PropertyKind.ReadWrite;
}
else
{
readWrite = PropertyKind.ReadOnly;
}
parameters = getMethod.GetParameters();
returnType = getMethod.ReturnType;
}
else
{
readWrite = PropertyKind.WriteOnly;
getMethod = Prop.GetSetMethod();
ParameterInfo[] sourceArray = getMethod.GetParameters();
parameters = new ParameterInfo[(sourceArray.Length - 2) + 1];
Array.Copy(sourceArray, parameters, parameters.Length);
returnType = sourceArray[sourceArray.Length - 1].ParameterType;
}
str2 = str2 + "Public ";
if ((getMethod.Attributes & MethodAttributes.Virtual) != MethodAttributes.ReuseSlot)
{
if (!Prop.DeclaringType.IsInterface)
{
str2 = str2 + "Overrides ";
}
}
else if (Symbols.IsShared(getMethod))
{
str2 = str2 + "Shared ";
}
switch (readWrite)
{
case PropertyKind.ReadOnly:
str2 = str2 + "ReadOnly ";
break;
case PropertyKind.WriteOnly:
str2 = str2 + "WriteOnly ";
break;
}
str2 = str2 + "Property " + Prop.Name + "(";
bool flag = true;
foreach (ParameterInfo info2 in parameters)
{
if (!flag)
{
str2 = str2 + ", ";
}
else
{
flag = false;
}
str2 = str2 + ParameterToString(info2);
}
return(str2 + ") As " + VBFriendlyNameOfType(returnType, true));
}
internal static object InvokeUserDefinedOperator(Symbols.UserDefinedOperator Op, object[] Arguments)
{
CallSiteBinder binder;
ExpressionType? nullable = IDOUtils.LinqOperator(Op);
if (!nullable.HasValue)
{
return Operators.InvokeObjectUserDefinedOperator(Op, Arguments);
}
ExpressionType linqOp = (ExpressionType) nullable;
if (Arguments.Length == 1)
{
binder = new VBUnaryOperatorBinder(Op, linqOp);
}
else
{
binder = new VBBinaryOperatorBinder(Op, linqOp);
}
object instance = Arguments[0];
object[] arguments = (Arguments.Length == 1) ? Symbols.NoArguments : new object[] { Arguments[1] };
return IDOUtils.CreateFuncCallSiteAndInvoke(binder, instance, arguments);
}
internal static Exception ReportPropertyMismatch(Symbols.Method TargetProcedure, BindingFlags Flags)
{
if (Symbols.HasFlag(Flags, BindingFlags.SetProperty))
{
return new MissingMemberException(Utils.GetResourceString("NoSetProperty1", new string[] { TargetProcedure.AsProperty().Name }));
}
return new MissingMemberException(Utils.GetResourceString("NoGetProperty1", new string[] { TargetProcedure.AsProperty().Name }));
}
internal static ExpressionType? LinqOperator(Symbols.UserDefinedOperator vbOperator)
{
ExpressionType? nullable2;
switch (vbOperator)
{
case Symbols.UserDefinedOperator.Negate:
return 0x1c;
case Symbols.UserDefinedOperator.Not:
return 0x22;
case Symbols.UserDefinedOperator.UnaryPlus:
return 0x1d;
case Symbols.UserDefinedOperator.Plus:
return 0;
case Symbols.UserDefinedOperator.Minus:
return 0x2a;
case Symbols.UserDefinedOperator.Multiply:
return 0x1a;
case Symbols.UserDefinedOperator.Divide:
return 12;
case Symbols.UserDefinedOperator.Power:
return 0x27;
case Symbols.UserDefinedOperator.IntegralDivide:
case Symbols.UserDefinedOperator.Concatenate:
case Symbols.UserDefinedOperator.Like:
return nullable2;
case Symbols.UserDefinedOperator.ShiftLeft:
return 0x13;
case Symbols.UserDefinedOperator.ShiftRight:
return 0x29;
case Symbols.UserDefinedOperator.Modulus:
return 0x19;
case Symbols.UserDefinedOperator.Or:
return 0x24;
case Symbols.UserDefinedOperator.Xor:
return 14;
case Symbols.UserDefinedOperator.And:
return 2;
case Symbols.UserDefinedOperator.Equal:
return 13;
case Symbols.UserDefinedOperator.NotEqual:
return 0x23;
case Symbols.UserDefinedOperator.Less:
return 20;
case Symbols.UserDefinedOperator.LessEqual:
return 0x15;
case Symbols.UserDefinedOperator.GreaterEqual:
return 0x10;
case Symbols.UserDefinedOperator.Greater:
return 15;
}
return nullable2;
}
internal static bool InferTypeArgumentsFromArgument(Symbols.Method TargetProcedure, object Argument, ParameterInfo Parameter, bool IsExpandedParamArray, List<string> Errors)
{
if (Argument == null)
{
return true;
}
Type parameterType = Parameter.ParameterType;
if (parameterType.IsByRef || IsExpandedParamArray)
{
parameterType = Symbols.GetElementType(parameterType);
}
if (InferTypeArgumentsFromArgument(GetArgumentTypeInContextOfParameterType(Argument, parameterType), parameterType, TargetProcedure.TypeArguments, TargetProcedure.AsMethod(), true))
{
return true;
}
if (Errors != null)
{
ReportError(Errors, "TypeInferenceFails1", Parameter.Name);
}
return false;
}
internal static MethodBase GetCallTarget(Symbols.Method TargetProcedure, BindingFlags Flags)
{
if (TargetProcedure.IsMethod)
{
return TargetProcedure.AsMethod();
}
if (TargetProcedure.IsProperty)
{
return MatchesPropertyRequirements(TargetProcedure, Flags);
}
return null;
}
private static bool DetectUnspecificity(Symbols.Method TargetProcedure, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, List<string> Errors)
{
ReportError(Errors, "NotMostSpecificOverload");
return false;
}
private static Symbols.Method VerifyForLoopOperator(Symbols.UserDefinedOperator Op, object ForLoopArgument, Type ForLoopArgumentType)
{
Symbols.Method callableUserDefinedOperator = Operators.GetCallableUserDefinedOperator(Op, new object[] { ForLoopArgument, ForLoopArgument });
if (callableUserDefinedOperator == null)
{
throw new ArgumentException(Utils.GetResourceString("ForLoop_OperatorRequired2", new string[] { Utils.VBFriendlyNameOfType(ForLoopArgumentType, true), Symbols.OperatorNames[(int) Op] }));
}
MethodInfo info = callableUserDefinedOperator.AsMethod() as MethodInfo;
ParameterInfo[] parameters = info.GetParameters();
switch (Op)
{
case Symbols.UserDefinedOperator.Plus:
case Symbols.UserDefinedOperator.Minus:
if (((parameters.Length != 2) || (parameters[0].ParameterType != ForLoopArgumentType)) || ((parameters[1].ParameterType != ForLoopArgumentType) || (info.ReturnType != ForLoopArgumentType)))
{
throw new ArgumentException(Utils.GetResourceString("ForLoop_UnacceptableOperator2", new string[] { callableUserDefinedOperator.ToString(), Utils.VBFriendlyNameOfType(ForLoopArgumentType, true) }));
}
return callableUserDefinedOperator;
case Symbols.UserDefinedOperator.Multiply:
case Symbols.UserDefinedOperator.Divide:
case Symbols.UserDefinedOperator.Power:
case Symbols.UserDefinedOperator.IntegralDivide:
case Symbols.UserDefinedOperator.Concatenate:
case Symbols.UserDefinedOperator.ShiftLeft:
case Symbols.UserDefinedOperator.ShiftRight:
case Symbols.UserDefinedOperator.Modulus:
case Symbols.UserDefinedOperator.Or:
case Symbols.UserDefinedOperator.Xor:
case Symbols.UserDefinedOperator.And:
case Symbols.UserDefinedOperator.Like:
case Symbols.UserDefinedOperator.Equal:
case Symbols.UserDefinedOperator.NotEqual:
case Symbols.UserDefinedOperator.Less:
return callableUserDefinedOperator;
case Symbols.UserDefinedOperator.LessEqual:
case Symbols.UserDefinedOperator.GreaterEqual:
if (((parameters.Length != 2) || (parameters[0].ParameterType != ForLoopArgumentType)) || (parameters[1].ParameterType != ForLoopArgumentType))
{
throw new ArgumentException(Utils.GetResourceString("ForLoop_UnacceptableRelOperator2", new string[] { callableUserDefinedOperator.ToString(), Utils.VBFriendlyNameOfType(ForLoopArgumentType, true) }));
}
return callableUserDefinedOperator;
}
return callableUserDefinedOperator;
}
internal static List<Symbols.Method> CollectOperators(Symbols.UserDefinedOperator Op, Type Type1, Type Type2, ref bool FoundType1Operators, ref bool FoundType2Operators)
{
List<Symbols.Method> list2;
int num;
int num2;
bool flag = Type2 != null;
if (!Symbols.IsRootObjectType(Type1) && Symbols.IsClassOrValueType(Type1))
{
Symbols.Container container = new Symbols.Container(Type1);
num = 0;
num2 = 0;
list2 = OverloadResolution.CollectOverloadCandidates(container.LookupNamedMembers(Symbols.OperatorCLSNames[(int) Op]), null, Interaction.IIf<int>(Symbols.IsUnaryOperator(Op), 1, 2), null, null, true, null, ref num, ref num2);
if (list2.Count > 0)
{
FoundType1Operators = true;
}
}
else
{
list2 = new List<Symbols.Method>();
}
if ((flag && !Symbols.IsRootObjectType(Type2)) && Symbols.IsClassOrValueType(Type2))
{
Type baseType = Type1;
while (baseType != null)
{
if (Symbols.IsOrInheritsFrom(Type2, baseType))
{
break;
}
baseType = baseType.BaseType;
}
Symbols.Container container2 = new Symbols.Container(Type2);
num2 = 0;
num = 0;
List<Symbols.Method> collection = OverloadResolution.CollectOverloadCandidates(container2.LookupNamedMembers(Symbols.OperatorCLSNames[(int) Op]), null, Interaction.IIf<int>(Symbols.IsUnaryOperator(Op), 1, 2), null, null, true, baseType, ref num2, ref num);
if (collection.Count > 0)
{
FoundType2Operators = true;
}
list2.AddRange(collection);
}
return list2;
}
internal static Symbols.Method GetCallableUserDefinedOperator(Symbols.UserDefinedOperator Op, params object[] Arguments)
{
Symbols.Method targetProcedure = ResolveUserDefinedOperator(Op, Arguments, false);
if (((targetProcedure != null) && !targetProcedure.ArgumentsValidated) && !OverloadResolution.CanMatchArguments(targetProcedure, Arguments, Symbols.NoArgumentNames, Symbols.NoTypeArguments, false, null))
{
return null;
}
return targetProcedure;
}
internal bool Lookup(Type TargetType, Type SourceType, ref ConversionResolution.ConversionClass Classification, ref Symbols.Method OperatorMethod)
{
int first = this.m_First;
for (int i = 0; i < this.m_Count; i++)
{
if ((TargetType == this.m_List[first].TargetType) && (SourceType == this.m_List[first].SourceType))
{
Classification = this.m_List[first].Classification;
OperatorMethod = this.m_List[first].OperatorMethod;
this.MoveToFront(first);
return true;
}
first = this.m_List[first].Next;
}
Classification = ConversionResolution.ConversionClass.Bad;
OperatorMethod = null;
return false;
}
internal void Insert(Type TargetType, Type SourceType, ConversionResolution.ConversionClass Classification, Symbols.Method OperatorMethod)
{
if (this.m_Count < this.m_Size)
{
this.m_Count++;
}
int last = this.m_Last;
this.m_First = last;
this.m_Last = this.m_List[this.m_Last].Previous;
this.m_List[last].TargetType = TargetType;
this.m_List[last].SourceType = SourceType;
this.m_List[last].Classification = Classification;
this.m_List[last].OperatorMethod = OperatorMethod;
}
internal object InvokeMethod(Symbols.Method TargetProcedure, object[] Arguments, bool[] CopyBack, BindingFlags Flags)
{
object obj3;
MethodBase callTarget = NewLateBinding.GetCallTarget(TargetProcedure, Flags);
object[] parameters = NewLateBinding.ConstructCallArguments(TargetProcedure, Arguments, Flags);
if ((this.m_Instance == null) && !Symbols.IsShared(callTarget))
{
throw new NullReferenceException(Utils.GetResourceString("NullReference_InstanceReqToAccessMember1", new string[] { TargetProcedure.ToString() }));
}
if (Symbols.IsNonPublicRuntimeMember(callTarget))
{
throw new MissingMemberException();
}
try
{
obj3 = callTarget.Invoke(this.m_Instance, parameters);
}
catch when (?)
{
TargetInvocationException exception;
throw exception.InnerException;
}
OverloadResolution.ReorderArgumentArray(TargetProcedure, parameters, Arguments, CopyBack, Flags);
return obj3;
}
internal static ConversionClass ClassifyPredefinedCLRConversion(Type TargetType, Type SourceType)
{
if (TargetType == SourceType)
{
return(ConversionClass.Identity);
}
if (Symbols.IsRootObjectType(TargetType) || Symbols.IsOrInheritsFrom(SourceType, TargetType))
{
return(ConversionClass.Widening);
}
if (Symbols.IsRootObjectType(SourceType) || Symbols.IsOrInheritsFrom(TargetType, SourceType))
{
return(ConversionClass.Narrowing);
}
if (Symbols.IsInterface(SourceType))
{
if ((Symbols.IsClass(TargetType) || Symbols.IsArrayType(TargetType)) || Symbols.IsGenericParameter(TargetType))
{
return(ConversionClass.Narrowing);
}
if (Symbols.IsInterface(TargetType))
{
return(ConversionClass.Narrowing);
}
if (!Symbols.IsValueType(TargetType))
{
return(ConversionClass.Narrowing);
}
if (Symbols.Implements(TargetType, SourceType))
{
return(ConversionClass.Narrowing);
}
return(ConversionClass.None);
}
if (Symbols.IsInterface(TargetType))
{
if (Symbols.IsArrayType(SourceType))
{
return(ClassifyCLRArrayToInterfaceConversion(TargetType, SourceType));
}
if (Symbols.IsValueType(SourceType))
{
if (Symbols.Implements(SourceType, TargetType))
{
return(ConversionClass.Widening);
}
return(ConversionClass.None);
}
if (Symbols.IsClass(SourceType))
{
if (Symbols.Implements(SourceType, TargetType))
{
return(ConversionClass.Widening);
}
return(ConversionClass.Narrowing);
}
}
if (Symbols.IsEnum(SourceType) || Symbols.IsEnum(TargetType))
{
if (Symbols.GetTypeCode(SourceType) != Symbols.GetTypeCode(TargetType))
{
return(ConversionClass.None);
}
if (Symbols.IsEnum(TargetType))
{
return(ConversionClass.Narrowing);
}
return(ConversionClass.Widening);
}
if (Symbols.IsGenericParameter(SourceType))
{
if (!Symbols.IsClassOrInterface(TargetType))
{
return(ConversionClass.None);
}
foreach (Type type2 in Symbols.GetInterfaceConstraints(SourceType))
{
switch (ClassifyPredefinedConversion(TargetType, type2))
{
case ConversionClass.Widening:
case ConversionClass.Identity:
return(ConversionClass.Widening);
}
}
Type classConstraint = Symbols.GetClassConstraint(SourceType);
if (classConstraint != null)
{
switch (ClassifyPredefinedConversion(TargetType, classConstraint))
{
case ConversionClass.Widening:
case ConversionClass.Identity:
return(ConversionClass.Widening);
}
}
return(Interaction.IIf <ConversionClass>(Symbols.IsInterface(TargetType), ConversionClass.Narrowing, ConversionClass.None));
}
if (Symbols.IsGenericParameter(TargetType))
{
Type derived = Symbols.GetClassConstraint(TargetType);
if ((derived != null) && Symbols.IsOrInheritsFrom(derived, SourceType))
{
return(ConversionClass.Narrowing);
}
return(ConversionClass.None);
}
if ((Symbols.IsArrayType(SourceType) && Symbols.IsArrayType(TargetType)) && (SourceType.GetArrayRank() == TargetType.GetArrayRank()))
{
return(ClassifyCLRConversionForArrayElementTypes(TargetType.GetElementType(), SourceType.GetElementType()));
}
return(ConversionClass.None);
}
internal static bool CanMatchArguments(Symbols.Method TargetProcedure, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, bool RejectNarrowingConversions, List<string> Errors)
{
bool flag2 = Errors != null;
TargetProcedure.ArgumentsValidated = true;
if (TargetProcedure.IsMethod && Symbols.IsRawGeneric(TargetProcedure.AsMethod()))
{
if (TypeArguments.Length == 0)
{
TypeArguments = new Type[(TargetProcedure.TypeParameters.Length - 1) + 1];
TargetProcedure.TypeArguments = TypeArguments;
if (!InferTypeArguments(TargetProcedure, Arguments, ArgumentNames, TypeArguments, Errors))
{
return false;
}
}
else
{
TargetProcedure.TypeArguments = TypeArguments;
}
if (!InstantiateGenericMethod(TargetProcedure, TypeArguments, Errors))
{
return false;
}
}
ParameterInfo[] parameters = TargetProcedure.Parameters;
int length = ArgumentNames.Length;
int index = 0;
while (length < Arguments.Length)
{
if (index == TargetProcedure.ParamArrayIndex)
{
break;
}
if (!CanPassToParameter(TargetProcedure, Arguments[length], parameters[index], false, RejectNarrowingConversions, Errors, ref TargetProcedure.RequiresNarrowingConversion, ref TargetProcedure.AllNarrowingIsFromObject) && !flag2)
{
return false;
}
length++;
index++;
}
if (TargetProcedure.HasParamArray)
{
if (!TargetProcedure.ParamArrayExpanded)
{
if ((Arguments.Length - length) != 1)
{
return false;
}
if (!CanPassToParamArray(TargetProcedure, Arguments[length], parameters[index]))
{
if (flag2)
{
ReportError(Errors, "ArgumentMismatch3", parameters[index].Name, GetArgumentTypeInContextOfParameterType(Arguments[length], parameters[index].ParameterType), parameters[index].ParameterType);
}
return false;
}
}
else if ((length != (Arguments.Length - 1)) || (Arguments[length] != null))
{
while (length < Arguments.Length)
{
if (!CanPassToParameter(TargetProcedure, Arguments[length], parameters[index], true, RejectNarrowingConversions, Errors, ref TargetProcedure.RequiresNarrowingConversion, ref TargetProcedure.AllNarrowingIsFromObject) && !flag2)
{
return false;
}
length++;
}
}
else
{
return false;
}
index++;
}
bool[] flagArray = null;
if ((ArgumentNames.Length > 0) || (index < parameters.Length))
{
flagArray = CreateMatchTable(parameters.Length, index - 1);
}
if (ArgumentNames.Length > 0)
{
int[] numArray = new int[(ArgumentNames.Length - 1) + 1];
for (length = 0; length < ArgumentNames.Length; length++)
{
if (!FindParameterByName(parameters, ArgumentNames[length], ref index))
{
if (!flag2)
{
return false;
}
ReportError(Errors, "NamedParamNotFound2", ArgumentNames[length], TargetProcedure);
}
else if (index == TargetProcedure.ParamArrayIndex)
{
if (!flag2)
{
return false;
}
ReportError(Errors, "NamedParamArrayArgument1", ArgumentNames[length]);
}
else if (flagArray[index])
{
if (!flag2)
{
return false;
}
ReportError(Errors, "NamedArgUsedTwice2", ArgumentNames[length], TargetProcedure);
}
else
{
if (!CanPassToParameter(TargetProcedure, Arguments[length], parameters[index], false, RejectNarrowingConversions, Errors, ref TargetProcedure.RequiresNarrowingConversion, ref TargetProcedure.AllNarrowingIsFromObject) && !flag2)
{
return false;
}
flagArray[index] = true;
numArray[length] = index;
}
}
TargetProcedure.NamedArgumentMapping = numArray;
}
if (flagArray != null)
{
int num4 = flagArray.Length - 1;
for (int i = 0; i <= num4; i++)
{
if (!flagArray[i] && !parameters[i].IsOptional)
{
if (!flag2)
{
return false;
}
ReportError(Errors, "OmittedArgument1", parameters[i].Name);
}
}
}
if ((Errors != null) && (Errors.Count > 0))
{
return false;
}
return true;
}
private static Exception GetNoValidOperatorException(Symbols.UserDefinedOperator Op, object Operand)
{
return new InvalidCastException(Utils.GetResourceString("UnaryOperand2", new string[] { Symbols.OperatorNames[(int) Op], Utils.VBFriendlyName(Operand) }));
}
private static bool InferTypeArguments(Symbols.Method TargetProcedure, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, List<string> Errors)
{
bool flag2 = Errors != null;
ParameterInfo[] rawParameters = TargetProcedure.RawParameters;
int length = ArgumentNames.Length;
int index = 0;
while (length < Arguments.Length)
{
if (index == TargetProcedure.ParamArrayIndex)
{
break;
}
if (!InferTypeArgumentsFromArgument(TargetProcedure, Arguments[length], rawParameters[index], false, Errors) && !flag2)
{
return false;
}
length++;
index++;
}
if (TargetProcedure.HasParamArray)
{
if (TargetProcedure.ParamArrayExpanded)
{
while (length < Arguments.Length)
{
if (!InferTypeArgumentsFromArgument(TargetProcedure, Arguments[length], rawParameters[index], true, Errors) && !flag2)
{
return false;
}
length++;
}
}
else
{
if ((Arguments.Length - length) != 1)
{
return true;
}
if (!InferTypeArgumentsFromArgument(TargetProcedure, Arguments[length], rawParameters[index], false, Errors))
{
return false;
}
}
index++;
}
if (ArgumentNames.Length > 0)
{
for (length = 0; length < ArgumentNames.Length; length++)
{
if ((FindParameterByName(rawParameters, ArgumentNames[length], ref index) && (index != TargetProcedure.ParamArrayIndex)) && (!InferTypeArgumentsFromArgument(TargetProcedure, Arguments[length], rawParameters[index], false, Errors) && !flag2))
{
return false;
}
}
}
if ((Errors != null) && (Errors.Count > 0))
{
return false;
}
return true;
}
private static void InsertInOperatorListIfLessGenericThanExisting(Symbols.Method OperatorToInsert, List<Symbols.Method> OperatorList, ref bool GenericMembersExistInList)
{
if (Symbols.IsGeneric(OperatorToInsert.DeclaringType))
{
GenericMembersExistInList = true;
}
if (GenericMembersExistInList)
{
for (int i = OperatorList.Count - 1; i >= 0; i += -1)
{
Symbols.Method left = OperatorList[i];
Symbols.Method method2 = OverloadResolution.LeastGenericProcedure(left, OperatorToInsert);
if (method2 == left)
{
return;
}
if (method2 != null)
{
OperatorList.Remove(left);
}
}
}
OperatorList.Add(OperatorToInsert);
}
private static Exception GetNoValidOperatorException(Symbols.UserDefinedOperator Op, object Left, object Right)
{
string resourceString;
string str2;
if (Left == null)
{
resourceString = "'Nothing'";
}
else
{
string str3 = Left as string;
if (str3 != null)
{
resourceString = Utils.GetResourceString("NoValidOperator_StringType1", new string[] { Strings.Left(str3, 0x20) });
}
else
{
resourceString = Utils.GetResourceString("NoValidOperator_NonStringType1", new string[] { Utils.VBFriendlyName(Left) });
}
}
if (Right == null)
{
str2 = "'Nothing'";
}
else
{
string str = Right as string;
if (str != null)
{
str2 = Utils.GetResourceString("NoValidOperator_StringType1", new string[] { Strings.Left(str, 0x20) });
}
else
{
str2 = Utils.GetResourceString("NoValidOperator_NonStringType1", new string[] { Utils.VBFriendlyName(Right) });
}
}
return new InvalidCastException(Utils.GetResourceString("BinaryOperands3", new string[] { Symbols.OperatorNames[(int) Op], resourceString, str2 }));
}
private static MemberInfo[] FilterInvalidMembers(MemberInfo[] Members)
{
if ((Members == null) || (Members.Length == 0))
{
return(null);
}
int num2 = 0;
int index = 0;
int num4 = Members.Length - 1;
for (index = 0; index <= num4; index++)
{
PropertyInfo info3;
ParameterInfo[] destinationArray = null;
Type returnType = null;
switch (Members[index].MemberType)
{
case MemberTypes.Constructor:
case MemberTypes.Method:
{
MethodInfo info = (MethodInfo)Members[index];
destinationArray = info.GetParameters();
returnType = info.ReturnType;
goto Label_00F9;
}
case MemberTypes.Field:
returnType = ((FieldInfo)Members[index]).FieldType;
goto Label_00F9;
case MemberTypes.Property:
{
info3 = (PropertyInfo)Members[index];
MethodInfo getMethod = info3.GetGetMethod();
if (getMethod == null)
{
break;
}
destinationArray = getMethod.GetParameters();
goto Label_00DF;
}
default:
goto Label_00F9;
}
ParameterInfo[] parameters = info3.GetSetMethod().GetParameters();
destinationArray = new ParameterInfo[(parameters.Length - 2) + 1];
Array.Copy(parameters, destinationArray, destinationArray.Length);
Label_00DF:
returnType = info3.PropertyType;
Label_00F9:
if (Symbols.AreParametersAndReturnTypesValid(destinationArray, returnType))
{
num2++;
}
else
{
Members[index] = null;
}
}
if (num2 == Members.Length)
{
return(Members);
}
if (num2 <= 0)
{
return(null);
}
MemberInfo[] infoArray4 = new MemberInfo[(num2 - 1) + 1];
int num3 = 0;
int num5 = Members.Length - 1;
for (index = 0; index <= num5; index++)
{
if (Members[index] != null)
{
infoArray4[num3] = Members[index];
num3++;
}
}
return(infoArray4);
}
internal static object InvokeObjectUserDefinedOperator(Symbols.UserDefinedOperator Op, object[] Arguments)
{
Symbols.Method operatorMethod = ResolveUserDefinedOperator(Op, Arguments, true);
if (operatorMethod != null)
{
return InvokeUserDefinedOperator(operatorMethod, false, Arguments);
}
if (Arguments.Length > 1)
{
throw GetNoValidOperatorException(Op, Arguments[0], Arguments[1]);
}
throw GetNoValidOperatorException(Op, Arguments[0]);
}
internal static object[] ConstructCallArguments(Symbols.Method TargetProcedure, object[] Arguments, BindingFlags LookupFlags)
{
ParameterInfo[] parameters = GetCallTarget(TargetProcedure, LookupFlags).GetParameters();
object[] matchedArguments = new object[(parameters.Length - 1) + 1];
int length = Arguments.Length;
object argument = null;
if (Symbols.HasFlag(LookupFlags, BindingFlags.SetProperty))
{
object[] sourceArray = Arguments;
Arguments = new object[(length - 2) + 1];
Array.Copy(sourceArray, Arguments, Arguments.Length);
argument = sourceArray[length - 1];
}
OverloadResolution.MatchArguments(TargetProcedure, Arguments, matchedArguments);
if (Symbols.HasFlag(LookupFlags, BindingFlags.SetProperty))
{
ParameterInfo parameter = parameters[parameters.Length - 1];
matchedArguments[parameters.Length - 1] = OverloadResolution.PassToParameter(argument, parameter, parameter.ParameterType);
}
return matchedArguments;
}
internal static object InvokeUserDefinedOperator(Symbols.UserDefinedOperator Op, params object[] Arguments)
{
if (IDOUtils.TryCastToIDMOP(Arguments[0]) != null)
{
return IDOBinder.InvokeUserDefinedOperator(Op, Arguments);
}
return InvokeObjectUserDefinedOperator(Op, Arguments);
}
internal static MethodInfo MatchesPropertyRequirements(Symbols.Method TargetProcedure, BindingFlags Flags)
{
if (Symbols.HasFlag(Flags, BindingFlags.SetProperty))
{
return TargetProcedure.AsProperty().GetSetMethod();
}
return TargetProcedure.AsProperty().GetGetMethod();
}
internal static object InvokeUserDefinedOperator(Symbols.Method OperatorMethod, bool ForceArgumentValidation, params object[] Arguments)
{
if ((!OperatorMethod.ArgumentsValidated || ForceArgumentValidation) && !OverloadResolution.CanMatchArguments(OperatorMethod, Arguments, Symbols.NoArgumentNames, Symbols.NoTypeArguments, false, null))
{
string str = "";
List<string> errors = new List<string>();
bool flag = OverloadResolution.CanMatchArguments(OperatorMethod, Arguments, Symbols.NoArgumentNames, Symbols.NoTypeArguments, false, errors);
foreach (string str2 in errors)
{
str = str + "\r\n " + str2;
}
throw new InvalidCastException(Utils.GetResourceString("MatchArgumentFailure2", new string[] { OperatorMethod.ToString(), str }));
}
Symbols.Container container = new Symbols.Container(OperatorMethod.DeclaringType);
return container.InvokeMethod(OperatorMethod, Arguments, null, BindingFlags.InvokeMethod);
}
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", new string[] { MethodName, BaseReference.VBFriendlyName }));
}
return null;
}
int length = Arguments.Length;
object argument = 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[] { MethodName }));
}
return null;
}
object[] sourceArray = Arguments;
Arguments = new object[(length - 2) + 1];
Array.Copy(sourceArray, Arguments, Arguments.Length);
argument = sourceArray[length - 1];
}
Symbols.Method targetProcedure = OverloadResolution.ResolveOverloadedCall(MethodName, Members, Arguments, ArgumentNames, TypeArguments, LookupFlags, ReportErrors, ref Failure);
if (Failure != OverloadResolution.ResolutionFailure.None)
{
return null;
}
if (!targetProcedure.ArgumentsValidated && !OverloadResolution.CanMatchArguments(targetProcedure, Arguments, ArgumentNames, TypeArguments, false, null))
{
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (!ReportErrors)
{
return null;
}
string str = "";
List<string> list = new List<string>();
bool flag = OverloadResolution.CanMatchArguments(targetProcedure, Arguments, ArgumentNames, TypeArguments, false, list);
foreach (string str2 in list)
{
str = str + "\r\n " + str2;
}
throw new InvalidCastException(Utils.GetResourceString("MatchArgumentFailure2", new string[] { targetProcedure.ToString(), str }));
}
if (targetProcedure.IsProperty)
{
if (MatchesPropertyRequirements(targetProcedure, LookupFlags) == null)
{
Failure = OverloadResolution.ResolutionFailure.InvalidTarget;
if (ReportErrors)
{
throw ReportPropertyMismatch(targetProcedure, LookupFlags);
}
return null;
}
}
else if (Symbols.HasFlag(LookupFlags, BindingFlags.SetProperty))
{
Failure = OverloadResolution.ResolutionFailure.InvalidTarget;
if (ReportErrors)
{
throw new MissingMemberException(Utils.GetResourceString("MethodAssignment1", new string[] { targetProcedure.AsMethod().Name }));
}
return null;
}
if (!Symbols.HasFlag(LookupFlags, BindingFlags.SetProperty))
{
return targetProcedure;
}
ParameterInfo[] parameters = GetCallTarget(targetProcedure, LookupFlags).GetParameters();
ParameterInfo parameter = parameters[parameters.Length - 1];
bool requiresNarrowingConversion = false;
bool allNarrowingIsFromObject = false;
if (OverloadResolution.CanPassToParameter(targetProcedure, argument, parameter, false, false, null, ref requiresNarrowingConversion, ref allNarrowingIsFromObject))
{
return targetProcedure;
}
Failure = OverloadResolution.ResolutionFailure.InvalidArgument;
if (!ReportErrors)
{
return null;
}
string str3 = "";
List<string> errors = new List<string>();
allNarrowingIsFromObject = false;
requiresNarrowingConversion = false;
bool flag2 = OverloadResolution.CanPassToParameter(targetProcedure, argument, parameter, false, false, errors, ref allNarrowingIsFromObject, ref requiresNarrowingConversion);
foreach (string str4 in errors)
{
str3 = str3 + "\r\n " + str4;
}
throw new InvalidCastException(Utils.GetResourceString("MatchArgumentFailure2", new string[] { targetProcedure.ToString(), str3 }));
}
internal static Symbols.Method ResolveUserDefinedOperator(Symbols.UserDefinedOperator Op, object[] Arguments, bool ReportErrors)
{
bool flag;
bool flag2;
Type type;
Arguments = (object[]) Arguments.Clone();
Type type2 = null;
if (Arguments[0] == null)
{
type2 = Arguments[1].GetType();
type = type2;
Arguments[0] = new Symbols.TypedNothing(type);
}
else
{
type = Arguments[0].GetType();
if (Arguments.Length > 1)
{
if (Arguments[1] != null)
{
type2 = Arguments[1].GetType();
}
else
{
type2 = type;
Arguments[1] = new Symbols.TypedNothing(type2);
}
}
}
List<Symbols.Method> candidates = CollectOperators(Op, type, type2, ref flag, ref flag2);
if (candidates.Count > 0)
{
OverloadResolution.ResolutionFailure failure;
return OverloadResolution.ResolveOverloadedCall(Symbols.OperatorNames[(int) Op], candidates, Arguments, Symbols.NoArgumentNames, Symbols.NoTypeArguments, BindingFlags.InvokeMethod, ReportErrors, ref failure);
}
return null;
}
public static string MethodToString(MethodBase Method)
{
bool flag;
Type typ = null;
string str = "";
if (Method.MemberType == MemberTypes.Method)
{
typ = ((MethodInfo)Method).ReturnType;
}
if (Method.IsPublic)
{
str = str + "Public ";
}
else if (Method.IsPrivate)
{
str = str + "Private ";
}
else if (Method.IsAssembly)
{
str = str + "Friend ";
}
if ((Method.Attributes & MethodAttributes.Virtual) != MethodAttributes.ReuseSlot)
{
if (!Method.DeclaringType.IsInterface)
{
str = str + "Overrides ";
}
}
else if (Symbols.IsShared(Method))
{
str = str + "Shared ";
}
Symbols.UserDefinedOperator uNDEF = Symbols.UserDefinedOperator.UNDEF;
if (Symbols.IsUserDefinedOperator(Method))
{
uNDEF = Symbols.MapToUserDefinedOperator(Method);
}
if (uNDEF != Symbols.UserDefinedOperator.UNDEF)
{
if (uNDEF == Symbols.UserDefinedOperator.Narrow)
{
str = str + "Narrowing ";
}
else if (uNDEF == Symbols.UserDefinedOperator.Widen)
{
str = str + "Widening ";
}
str = str + "Operator ";
}
else if ((typ == null) || (typ == VoidType))
{
str = str + "Sub ";
}
else
{
str = str + "Function ";
}
if (uNDEF != Symbols.UserDefinedOperator.UNDEF)
{
str = str + Symbols.OperatorNames[(int)uNDEF];
}
else if (Method.MemberType == MemberTypes.Constructor)
{
str = str + "New";
}
else
{
str = str + Method.Name;
}
if (Symbols.IsGeneric(Method))
{
str = str + "(Of ";
flag = true;
foreach (Type type2 in Symbols.GetTypeParameters(Method))
{
if (!flag)
{
str = str + ", ";
}
else
{
flag = false;
}
str = str + VBFriendlyNameOfType(type2, false);
}
str = str + ")";
}
str = str + "(";
flag = true;
foreach (ParameterInfo info in Method.GetParameters())
{
if (!flag)
{
str = str + ", ";
}
else
{
flag = false;
}
str = str + ParameterToString(info);
}
str = str + ")";
if ((typ == null) || (typ == VoidType))
{
return(str);
}
return(str + " As " + VBFriendlyNameOfType(typ, true));
}
public static bool ForNextCheckObj(object Counter, object LoopObj, ref object CounterResult)
{
if (LoopObj == null)
{
throw ExceptionUtils.VbMakeException(0x5c);
}
if (Counter == null)
{
throw new NullReferenceException(Utils.GetResourceString("Argument_InvalidNullValue1", new string[] { "Counter" }));
}
ObjectFlowControl.ForLoopControl loopFor = (ObjectFlowControl.ForLoopControl)LoopObj;
bool flag2 = false;
if (!loopFor.UseUserDefinedOperators)
{
TypeCode typeCode = ((IConvertible)Counter).GetTypeCode();
if ((typeCode != loopFor.WidestTypeCode) || (typeCode == TypeCode.String))
{
if (typeCode == TypeCode.Object)
{
throw new ArgumentException(Utils.GetResourceString("ForLoop_CommonType2", new string[] { Utils.VBFriendlyName(Symbols.MapTypeCodeToType(typeCode)), Utils.VBFriendlyName(loopFor.WidestType) }));
}
TypeCode code2 = Symbols.GetTypeCode(GetWidestType(Symbols.MapTypeCodeToType(typeCode), loopFor.WidestType));
if (code2 == TypeCode.String)
{
code2 = TypeCode.Double;
}
loopFor.WidestTypeCode = code2;
loopFor.WidestType = Symbols.MapTypeCodeToType(code2);
flag2 = true;
}
}
if (flag2 || loopFor.UseUserDefinedOperators)
{
Counter = ConvertLoopElement("Start", Counter, Counter.GetType(), loopFor.WidestType);
if (!loopFor.UseUserDefinedOperators)
{
loopFor.Limit = ConvertLoopElement("Limit", loopFor.Limit, loopFor.Limit.GetType(), loopFor.WidestType);
loopFor.StepValue = ConvertLoopElement("Step", loopFor.StepValue, loopFor.StepValue.GetType(), loopFor.WidestType);
}
}
if (!loopFor.UseUserDefinedOperators)
{
loopFor.Counter = Operators.AddObject(Counter, loopFor.StepValue);
TypeCode code3 = ((IConvertible)loopFor.Counter).GetTypeCode();
if (loopFor.EnumType != null)
{
CounterResult = Enum.ToObject(loopFor.EnumType, loopFor.Counter);
}
else
{
CounterResult = loopFor.Counter;
}
if (code3 != loopFor.WidestTypeCode)
{
loopFor.Limit = Conversions.ChangeType(loopFor.Limit, Symbols.MapTypeCodeToType(code3));
loopFor.StepValue = Conversions.ChangeType(loopFor.StepValue, Symbols.MapTypeCodeToType(code3));
return(false);
}
}
else
{
loopFor.Counter = Operators.InvokeUserDefinedOperator(loopFor.OperatorPlus, true, new object[] { Counter, loopFor.StepValue });
if (loopFor.Counter.GetType() != loopFor.WidestType)
{
loopFor.Counter = ConvertLoopElement("Start", loopFor.Counter, loopFor.Counter.GetType(), loopFor.WidestType);
}
CounterResult = loopFor.Counter;
}
return(CheckContinueLoop(loopFor));
}
internal static string VBFriendlyNameOfType(Type typ, [Optional, DefaultParameterValue(false)] bool FullName)
{
string name;
TypeCode typeCode;
string arraySuffixAndElementType = GetArraySuffixAndElementType(ref typ);
if (typ.IsEnum)
{
typeCode = TypeCode.Object;
}
else
{
typeCode = Type.GetTypeCode(typ);
}
switch (typeCode)
{
case TypeCode.DBNull:
name = "DBNull";
break;
case TypeCode.Boolean:
name = "Boolean";
break;
case TypeCode.Char:
name = "Char";
break;
case TypeCode.SByte:
name = "SByte";
break;
case TypeCode.Byte:
name = "Byte";
break;
case TypeCode.Int16:
name = "Short";
break;
case TypeCode.UInt16:
name = "UShort";
break;
case TypeCode.Int32:
name = "Integer";
break;
case TypeCode.UInt32:
name = "UInteger";
break;
case TypeCode.Int64:
name = "Long";
break;
case TypeCode.UInt64:
name = "ULong";
break;
case TypeCode.Single:
name = "Single";
break;
case TypeCode.Double:
name = "Double";
break;
case TypeCode.Decimal:
name = "Decimal";
break;
case TypeCode.DateTime:
name = "Date";
break;
case TypeCode.String:
name = "String";
break;
default:
if (Symbols.IsGenericParameter(typ))
{
name = typ.Name;
}
else
{
string fullName;
string str6 = null;
string genericArgsSuffix = GetGenericArgsSuffix(typ);
if (FullName)
{
if (typ.DeclaringType != null)
{
str6 = VBFriendlyNameOfType(typ.DeclaringType, true);
fullName = typ.Name;
}
else
{
fullName = typ.FullName;
}
}
else
{
fullName = typ.Name;
}
if (genericArgsSuffix != null)
{
int length = fullName.LastIndexOf('`');
if (length != -1)
{
fullName = fullName.Substring(0, length);
}
name = fullName + genericArgsSuffix;
}
else
{
name = fullName;
}
if (str6 != null)
{
name = str6 + "." + name;
}
}
break;
}
if (arraySuffixAndElementType != null)
{
name = name + arraySuffixAndElementType;
}
return(name);
}
public static bool ForLoopInitObj(object Counter, object Start, object Limit, object StepValue, ref object LoopForResult, ref object CounterResult)
{
if (Start == null)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidNullValue1", new string[] { "Start" }));
}
if (Limit == null)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidNullValue1", new string[] { "Limit" }));
}
if (StepValue == null)
{
throw new ArgumentException(Utils.GetResourceString("Argument_InvalidNullValue1", new string[] { "Step" }));
}
Type type3 = Start.GetType();
Type type2 = Limit.GetType();
Type type4 = StepValue.GetType();
Type type5 = GetWidestType(type4, type3, type2);
if (type5 == null)
{
throw new ArgumentException(Utils.GetResourceString("ForLoop_CommonType3", new string[] { Utils.VBFriendlyName(type3), Utils.VBFriendlyName(type2), Utils.VBFriendlyName(StepValue) }));
}
ObjectFlowControl.ForLoopControl loopFor = new ObjectFlowControl.ForLoopControl();
TypeCode typeCode = Symbols.GetTypeCode(type5);
switch (typeCode)
{
case TypeCode.Object:
loopFor.UseUserDefinedOperators = true;
break;
case TypeCode.String:
typeCode = TypeCode.Double;
break;
}
TypeCode code2 = Type.GetTypeCode(type3);
TypeCode code = Type.GetTypeCode(type2);
TypeCode code3 = Type.GetTypeCode(type4);
Type type = null;
if ((code2 == typeCode) && type3.IsEnum)
{
type = type3;
}
if ((code == typeCode) && type2.IsEnum)
{
if ((type != null) && (type != type2))
{
type = null;
goto Label_015E;
}
type = type2;
}
if ((code3 == typeCode) && type4.IsEnum)
{
if ((type != null) && (type != type4))
{
type = null;
}
else
{
type = type4;
}
}
Label_015E:
loopFor.EnumType = type;
if (!loopFor.UseUserDefinedOperators)
{
loopFor.WidestType = Symbols.MapTypeCodeToType(typeCode);
}
else
{
loopFor.WidestType = type5;
}
loopFor.WidestTypeCode = typeCode;
loopFor.Counter = ConvertLoopElement("Start", Start, type3, loopFor.WidestType);
loopFor.Limit = ConvertLoopElement("Limit", Limit, type2, loopFor.WidestType);
loopFor.StepValue = ConvertLoopElement("Step", StepValue, type4, loopFor.WidestType);
if (loopFor.UseUserDefinedOperators)
{
loopFor.OperatorPlus = VerifyForLoopOperator(Symbols.UserDefinedOperator.Plus, loopFor.Counter, loopFor.WidestType);
VerifyForLoopOperator(Symbols.UserDefinedOperator.Minus, loopFor.Counter, loopFor.WidestType);
loopFor.OperatorLessEqual = VerifyForLoopOperator(Symbols.UserDefinedOperator.LessEqual, loopFor.Counter, loopFor.WidestType);
loopFor.OperatorGreaterEqual = VerifyForLoopOperator(Symbols.UserDefinedOperator.GreaterEqual, loopFor.Counter, loopFor.WidestType);
}
loopFor.PositiveStep = Operators.ConditionalCompareObjectGreaterEqual(loopFor.StepValue, Operators.SubtractObject(loopFor.StepValue, loopFor.StepValue), false);
LoopForResult = loopFor;
if (loopFor.EnumType != null)
{
CounterResult = Enum.ToObject(loopFor.EnumType, loopFor.Counter);
}
else
{
CounterResult = loopFor.Counter;
}
return(CheckContinueLoop(loopFor));
}
public VBUnaryOperatorBinder(Symbols.UserDefinedOperator Op, ExpressionType LinqOp) : base(LinqOp)
{
this._Op = Op;
}
internal static ConversionClass ClassifyConversion(Type TargetType, Type SourceType, ref Symbols.Method OperatorMethod)
{
ConversionClass class3 = ClassifyPredefinedConversion(TargetType, SourceType);
if ((((class3 != ConversionClass.None) || Symbols.IsInterface(SourceType)) || Symbols.IsInterface(TargetType)) || (!Symbols.IsClassOrValueType(SourceType) && !Symbols.IsClassOrValueType(TargetType)))
{
return class3;
}
if (Symbols.IsIntrinsicType(SourceType) && Symbols.IsIntrinsicType(TargetType))
{
return class3;
}
return ClassifyUserDefinedConversion(TargetType, SourceType, ref OperatorMethod);
}
internal static ConversionClass ClassifyConversion(Type TargetType, Type SourceType, ref Symbols.Method OperatorMethod)
{
ConversionClass class3 = ClassifyPredefinedConversion(TargetType, SourceType);
if ((((class3 != ConversionClass.None) || Symbols.IsInterface(SourceType)) || Symbols.IsInterface(TargetType)) || (!Symbols.IsClassOrValueType(SourceType) && !Symbols.IsClassOrValueType(TargetType)))
{
return(class3);
}
if (Symbols.IsIntrinsicType(SourceType) && Symbols.IsIntrinsicType(TargetType))
{
return(class3);
}
return(ClassifyUserDefinedConversion(TargetType, SourceType, ref OperatorMethod));
}
internal static ConversionClass ClassifyUserDefinedConversion(Type TargetType, Type SourceType, ref Symbols.Method OperatorMethod)
{
ConversionClass class3;
OperatorCaches.FixedList conversionCache = OperatorCaches.ConversionCache;
lock (conversionCache)
{
if (OperatorCaches.UnconvertibleTypeCache.Lookup(TargetType) && OperatorCaches.UnconvertibleTypeCache.Lookup(SourceType))
{
return ConversionClass.None;
}
if (OperatorCaches.ConversionCache.Lookup(TargetType, SourceType, ref class3, ref OperatorMethod))
{
return class3;
}
}
bool foundTargetTypeOperators = false;
bool foundSourceTypeOperators = false;
class3 = DoClassifyUserDefinedConversion(TargetType, SourceType, ref OperatorMethod, ref foundTargetTypeOperators, ref foundSourceTypeOperators);
OperatorCaches.FixedList list2 = OperatorCaches.ConversionCache;
lock (list2)
{
if (!foundTargetTypeOperators)
{
OperatorCaches.UnconvertibleTypeCache.Insert(TargetType);
}
if (!foundSourceTypeOperators)
{
OperatorCaches.UnconvertibleTypeCache.Insert(SourceType);
}
if (!foundTargetTypeOperators && !foundSourceTypeOperators)
{
return class3;
}
OperatorCaches.ConversionCache.Insert(TargetType, SourceType, class3, OperatorMethod);
}
return class3;
}
internal static ConversionClass ClassifyPredefinedConversion(Type TargetType, Type SourceType)
{
if (TargetType == SourceType)
{
return(ConversionClass.Identity);
}
TypeCode typeCode = Symbols.GetTypeCode(SourceType);
TypeCode code2 = Symbols.GetTypeCode(TargetType);
if (Symbols.IsIntrinsicType(typeCode) && Symbols.IsIntrinsicType(code2))
{
if ((Symbols.IsEnum(TargetType) && Symbols.IsIntegralType(typeCode)) && Symbols.IsIntegralType(code2))
{
return(ConversionClass.Narrowing);
}
if ((typeCode == code2) && Symbols.IsEnum(SourceType))
{
return(ConversionClass.Widening);
}
return(ClassifyIntrinsicConversion(code2, typeCode));
}
if (Symbols.IsCharArrayRankOne(SourceType) && Symbols.IsStringType(TargetType))
{
return(ConversionClass.Widening);
}
if (Symbols.IsCharArrayRankOne(TargetType) && Symbols.IsStringType(SourceType))
{
return(ConversionClass.Narrowing);
}
return(ClassifyPredefinedCLRConversion(TargetType, SourceType));
}
private static ConversionClass DoClassifyUserDefinedConversion(Type TargetType, Type SourceType, ref Symbols.Method OperatorMethod, ref bool FoundTargetTypeOperators, ref bool FoundSourceTypeOperators)
{
OperatorMethod = null;
List<Symbols.Method> operatorSet = CollectConversionOperators(TargetType, SourceType, ref FoundTargetTypeOperators, ref FoundSourceTypeOperators);
if (operatorSet.Count == 0)
{
return ConversionClass.None;
}
bool resolutionIsAmbiguous = false;
List<Symbols.Method> list = ResolveConversion(TargetType, SourceType, operatorSet, true, ref resolutionIsAmbiguous);
if (list.Count == 1)
{
OperatorMethod = list[0];
OperatorMethod.ArgumentsValidated = true;
return ConversionClass.Widening;
}
if ((list.Count == 0) && !resolutionIsAmbiguous)
{
list = ResolveConversion(TargetType, SourceType, operatorSet, false, ref resolutionIsAmbiguous);
if (list.Count == 1)
{
OperatorMethod = list[0];
OperatorMethod.ArgumentsValidated = true;
return ConversionClass.Narrowing;
}
if (list.Count == 0)
{
return ConversionClass.None;
}
}
return ConversionClass.Ambiguous;
}
private static List <Symbols.Method> ResolveConversion(Type TargetType, Type SourceType, List <Symbols.Method> OperatorSet, bool WideningOnly, ref bool ResolutionIsAmbiguous)
{
ResolutionIsAmbiguous = false;
Type sourceType = null;
Type targetType = null;
bool genericMembersExistInList = false;
List <Symbols.Method> operatorList = new List <Symbols.Method>(OperatorSet.Count);
List <Symbols.Method> searchList = new List <Symbols.Method>(OperatorSet.Count);
List <Type> types = new List <Type>(OperatorSet.Count);
List <Type> list7 = new List <Type>(OperatorSet.Count);
List <Type> list5 = null;
List <Type> list6 = null;
if (!WideningOnly)
{
list5 = new List <Type>(OperatorSet.Count);
list6 = new List <Type>(OperatorSet.Count);
}
foreach (Symbols.Method method in OperatorSet)
{
MethodBase base2 = method.AsMethod();
if (WideningOnly && Symbols.IsNarrowingConversionOperator(base2))
{
break;
}
Type parameterType = base2.GetParameters()[0].ParameterType;
Type returnType = ((MethodInfo)base2).ReturnType;
if ((!Symbols.IsGeneric(base2) && !Symbols.IsGeneric(base2.DeclaringType)) || (ClassifyPredefinedConversion(returnType, parameterType) == ConversionClass.None))
{
if ((parameterType == SourceType) && (returnType == TargetType))
{
InsertInOperatorListIfLessGenericThanExisting(method, operatorList, ref genericMembersExistInList);
continue;
}
if (operatorList.Count == 0)
{
if (Encompasses(parameterType, SourceType) && Encompasses(TargetType, returnType))
{
searchList.Add(method);
if (parameterType == SourceType)
{
sourceType = parameterType;
}
else
{
types.Add(parameterType);
}
if (returnType == TargetType)
{
targetType = returnType;
}
else
{
list7.Add(returnType);
}
continue;
}
if ((!WideningOnly && Encompasses(parameterType, SourceType)) && NotEncompasses(TargetType, returnType))
{
searchList.Add(method);
if (parameterType == SourceType)
{
sourceType = parameterType;
}
else
{
types.Add(parameterType);
}
if (returnType == TargetType)
{
targetType = returnType;
}
else
{
list6.Add(returnType);
}
continue;
}
if ((!WideningOnly && NotEncompasses(parameterType, SourceType)) && NotEncompasses(TargetType, returnType))
{
searchList.Add(method);
if (parameterType == SourceType)
{
sourceType = parameterType;
}
else
{
list5.Add(parameterType);
}
if (returnType == TargetType)
{
targetType = returnType;
}
else
{
list6.Add(returnType);
}
}
}
}
}
if ((operatorList.Count == 0) && (searchList.Count > 0))
{
if (sourceType == null)
{
if (types.Count > 0)
{
sourceType = MostEncompassed(types);
}
else
{
sourceType = MostEncompassing(list5);
}
}
if (targetType == null)
{
if (list7.Count > 0)
{
targetType = MostEncompassing(list7);
}
else
{
targetType = MostEncompassed(list6);
}
}
if ((sourceType == null) || (targetType == null))
{
ResolutionIsAmbiguous = true;
return(new List <Symbols.Method>());
}
FindBestMatch(targetType, sourceType, searchList, operatorList, ref genericMembersExistInList);
}
if (operatorList.Count > 1)
{
ResolutionIsAmbiguous = true;
}
return(operatorList);
}
private static bool DetectArgumentNarrowing(Symbols.Method TargetProcedure, object[] Arguments, string[] ArgumentNames, Type[] TypeArguments, List<string> Errors)
{
return CanMatchArguments(TargetProcedure, Arguments, ArgumentNames, TypeArguments, true, Errors);
}
