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 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);
}
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));
}
