internal static bool RefersToGenericParameterCLRSemantics(Type ReferringType, Type Typ)
{
if (ReferringType.IsByRef)
{
ReferringType = Symbols.GetElementType(ReferringType);
}
if (Symbols.IsGenericParameter(ReferringType))
{
if (ReferringType.DeclaringType == Typ)
{
return(true);
}
}
else if (Symbols.IsGeneric(ReferringType))
{
Type[] typeArguments = Symbols.GetTypeArguments(ReferringType);
int index = 0;
while (index < typeArguments.Length)
{
if (Symbols.RefersToGenericParameterCLRSemantics(typeArguments[index], Typ))
{
return(true);
}
checked { ++index; }
}
}
else if (Symbols.IsArrayType(ReferringType))
{
return(Symbols.RefersToGenericParameterCLRSemantics(ReferringType.GetElementType(), Typ));
}
return(false);
}
internal static bool IsGeneric(MemberInfo Member)
{
MethodBase Method = Member as MethodBase;
if (Method == null)
{
return(false);
}
return(Symbols.IsGeneric(Method));
}
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);
}
/// <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);
}