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