private static ConversionClass ClassifyCLRConversionForArrayElementTypes(Type TargetElementType, Type SourceElementType)
{
if (Symbols.IsReferenceType(SourceElementType) && Symbols.IsReferenceType(TargetElementType))
{
return(ClassifyPredefinedCLRConversion(TargetElementType, SourceElementType));
}
if (Symbols.IsValueType(SourceElementType) && Symbols.IsValueType(TargetElementType))
{
return(ClassifyPredefinedCLRConversion(TargetElementType, SourceElementType));
}
if (Symbols.IsGenericParameter(SourceElementType) && Symbols.IsGenericParameter(TargetElementType))
{
if (SourceElementType == TargetElementType)
{
return(ConversionClass.Identity);
}
if (Symbols.IsReferenceType(SourceElementType) && Symbols.IsOrInheritsFrom(SourceElementType, TargetElementType))
{
return(ConversionClass.Widening);
}
if (Symbols.IsReferenceType(TargetElementType) && Symbols.IsOrInheritsFrom(TargetElementType, SourceElementType))
{
return(ConversionClass.Narrowing);
}
}
return(ConversionClass.None);
}
internal MemberInfo[] LookupNamedMembers(string MemberName)
{
MemberInfo[] member;
if (Symbols.IsGenericParameter(this.m_Type))
{
Type classConstraint = Symbols.GetClassConstraint(this.m_Type);
if (classConstraint != null)
{
member = classConstraint.GetMember(MemberName, BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.IgnoreCase);
}
else
{
member = null;
}
}
else
{
member = this.m_IReflect.GetMember(MemberName, BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.IgnoreCase);
}
member = FilterInvalidMembers(member);
if (member == null)
{
return(NoMembers);
}
if (member.Length > 1)
{
Array.Sort <MemberInfo>(member, InheritanceSorter.Instance);
}
return(member);
}
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 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);
}
