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));
}
internal static string ParameterToString(ParameterInfo Parameter)
{
string str2 = "";
Type parameterType = Parameter.ParameterType;
if (Parameter.IsOptional)
{
str2 = str2 + "[";
}
if (parameterType.IsByRef)
{
str2 = str2 + "ByRef ";
parameterType = parameterType.GetElementType();
}
else if (Symbols.IsParamArray(Parameter))
{
str2 = str2 + "ParamArray ";
}
str2 = str2 + Parameter.Name + " As " + VBFriendlyNameOfType(parameterType, true);
if (!Parameter.IsOptional)
{
return(str2);
}
object defaultValue = Parameter.DefaultValue;
if (defaultValue == null)
{
str2 = str2 + " = Nothing";
}
else
{
Type type = defaultValue.GetType();
if (type != VoidType)
{
if (Symbols.IsEnum(type))
{
str2 = str2 + " = " + Enum.GetName(type, defaultValue);
}
else
{
str2 = str2 + " = " + Conversions.ToString(defaultValue);
}
}
}
return(str2 + "]");
}
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);
}
