static object ReplaceTypeByIReturnType(IProjectContent pc, object val)
{
if (val is Type)
{
return(ReflectionReturnType.Create(pc, (Type)val, forceGenericType: false));
}
else
{
return(val);
}
}
internal static void AddConstraintsFromType(ITypeParameter tp, Type type)
{
foreach (Type constraint in type.GetGenericParameterConstraints())
{
if (tp.Method != null)
{
tp.Constraints.Add(ReflectionReturnType.Create(tp.Method, constraint));
}
else
{
tp.Constraints.Add(ReflectionReturnType.Create(tp.Class, constraint));
}
}
}
internal static void AddAttributes(IProjectContent pc, IList <IAttribute> list, IList <CustomAttributeData> attributes)
{
foreach (CustomAttributeData att in attributes)
{
DefaultAttribute a = new DefaultAttribute(ReflectionReturnType.Create(pc, att.Constructor.DeclaringType));
foreach (CustomAttributeTypedArgument arg in att.ConstructorArguments)
{
a.PositionalArguments.Add(ReplaceTypeByIReturnType(pc, arg.Value));
}
foreach (CustomAttributeNamedArgument arg in att.NamedArguments)
{
a.NamedArguments.Add(arg.MemberInfo.Name, ReplaceTypeByIReturnType(pc, arg.TypedValue.Value));
}
list.Add(a);
}
}
public ReflectionField(FieldInfo fieldInfo, IClass declaringType) : base(declaringType, fieldInfo.Name)
{
this.ReturnType = ReflectionReturnType.Create(this, fieldInfo.FieldType, attributeProvider: fieldInfo);
ModifierEnum modifiers = ModifierEnum.None;
if (fieldInfo.IsInitOnly)
{
modifiers |= ModifierEnum.Readonly;
}
if (fieldInfo.IsStatic)
{
modifiers |= ModifierEnum.Static;
}
if (fieldInfo.IsAssembly)
{
modifiers |= ModifierEnum.Internal;
}
if (fieldInfo.IsPrivate) // I assume that private is used most and public last (at least should be)
{
modifiers |= ModifierEnum.Private;
}
else if (fieldInfo.IsFamily || fieldInfo.IsFamilyOrAssembly)
{
modifiers |= ModifierEnum.Protected;
}
else if (fieldInfo.IsPublic)
{
modifiers |= ModifierEnum.Public;
}
else
{
modifiers |= ModifierEnum.Internal;
}
if (fieldInfo.IsLiteral)
{
modifiers |= ModifierEnum.Const;
}
this.Modifiers = modifiers;
}
public ReflectionProperty(PropertyInfo propertyInfo, IClass declaringType) : base(declaringType, propertyInfo.Name)
{
this.ReturnType = ReflectionReturnType.Create(this, propertyInfo.PropertyType, attributeProvider: propertyInfo);
CanGet = propertyInfo.CanRead;
CanSet = propertyInfo.CanWrite;
ParameterInfo[] parameterInfo = propertyInfo.GetIndexParameters();
if (parameterInfo != null && parameterInfo.Length > 0)
{
// check if this property is an indexer (=default member of parent class)
foreach (MemberInfo memberInfo in propertyInfo.DeclaringType.GetDefaultMembers())
{
if (memberInfo == propertyInfo)
{
this.IsIndexer = true;
break;
}
}
// there are only few properties with parameters, so we can load them immediately
foreach (ParameterInfo info in parameterInfo)
{
this.Parameters.Add(new ReflectionParameter(info, this));
}
}
MethodInfo getterMethod = null;
try {
getterMethod = propertyInfo.GetGetMethod(true);
} catch (Exception) {}
MethodInfo setterMethod = null;
try {
setterMethod = propertyInfo.GetSetMethod(true);
} catch (Exception) {}
MethodInfo methodBase = getterMethod ?? setterMethod;
ModifierEnum modifiers = ModifierEnum.None;
if (methodBase != null)
{
if (methodBase.IsStatic)
{
modifiers |= ModifierEnum.Static;
}
if (methodBase.IsAssembly)
{
modifiers |= ModifierEnum.Internal;
}
if (methodBase.IsPrivate) // I assume that private is used most and public last (at least should be)
{
modifiers |= ModifierEnum.Private;
}
else if (methodBase.IsFamily || methodBase.IsFamilyOrAssembly)
{
modifiers |= ModifierEnum.Protected;
}
else if (methodBase.IsPublic)
{
modifiers |= ModifierEnum.Public;
}
else
{
modifiers |= ModifierEnum.Internal;
}
if (methodBase.IsFinal)
{
modifiers |= ModifierEnum.Sealed;
}
else if (methodBase.IsAbstract)
{
modifiers |= ModifierEnum.Abstract;
}
else if (methodBase.IsVirtual)
{
modifiers |= ModifierEnum.Virtual;
}
}
else // assume public property, if no methodBase could be get.
{
modifiers = ModifierEnum.Public;
}
this.Modifiers = modifiers;
if (getterMethod != null)
{
ModifierEnum getterModifier = GetAccessorModifier(getterMethod);
if (getterModifier == ModifierEnum.Private)
{
this.CanGet = false;
}
else
{
if (getterModifier != (modifiers & ModifierEnum.VisibilityMask))
{
this.GetterModifiers = getterModifier;
}
}
}
if (setterMethod != null)
{
ModifierEnum setterModifier = GetAccessorModifier(setterMethod);
if (setterModifier == ModifierEnum.Private)
{
this.CanSet = false;
}
else
{
if (setterModifier != (modifiers & ModifierEnum.VisibilityMask))
{
this.SetterModifiers = setterModifier;
}
}
}
}
public ReflectionMethod(MethodBase methodBase, ReflectionClass declaringType)
: base(declaringType, methodBase is ConstructorInfo ? "#ctor" : methodBase.Name)
{
if (methodBase is MethodInfo)
{
MethodInfo m = ((MethodInfo)methodBase);
this.ReturnType = ReflectionReturnType.Create(this, m.ReturnType, attributeProvider: m.ReturnTypeCustomAttributes);
}
else if (methodBase is ConstructorInfo)
{
this.ReturnType = DeclaringType.DefaultReturnType;
}
foreach (ParameterInfo paramInfo in methodBase.GetParameters())
{
this.Parameters.Add(new ReflectionParameter(paramInfo, this));
}
if (methodBase.IsGenericMethodDefinition)
{
foreach (Type g in methodBase.GetGenericArguments())
{
this.TypeParameters.Add(new DefaultTypeParameter(this, g));
}
int i = 0;
foreach (Type g in methodBase.GetGenericArguments())
{
ReflectionClass.AddConstraintsFromType(this.TypeParameters[i++], g);
}
}
ModifierEnum modifiers = ModifierEnum.None;
if (methodBase.IsStatic)
{
modifiers |= ModifierEnum.Static;
}
if (methodBase.IsPrivate) // I assume that private is used most and public last (at least should be)
{
modifiers |= ModifierEnum.Private;
}
else if (methodBase.IsFamily || methodBase.IsFamilyOrAssembly)
{
modifiers |= ModifierEnum.Protected;
}
else if (methodBase.IsPublic)
{
modifiers |= ModifierEnum.Public;
}
else
{
modifiers |= ModifierEnum.Internal;
}
if (methodBase.IsFinal)
{
modifiers |= ModifierEnum.Sealed;
}
else if (methodBase.IsAbstract)
{
modifiers |= ModifierEnum.Abstract;
}
else if (methodBase.IsVirtual)
{
if ((methodBase.Attributes & MethodAttributes.NewSlot) != 0)
{
modifiers |= ModifierEnum.Virtual;
}
else
{
modifiers |= ModifierEnum.Override;
}
}
this.Modifiers = modifiers;
ReflectionClass.AddAttributes(declaringType.ProjectContent, this.Attributes, CustomAttributeData.GetCustomAttributes(methodBase));
ApplySpecialsFromAttributes(this);
}
public ReflectionEvent(EventInfo eventInfo, IClass declaringType) : base(declaringType, eventInfo.Name)
{
this.ReturnType = ReflectionReturnType.Create(this, eventInfo.EventHandlerType, attributeProvider: eventInfo);
// get modifiers
MethodInfo methodBase = null;
try {
methodBase = eventInfo.GetAddMethod(true);
} catch (Exception) {}
if (methodBase == null)
{
try {
methodBase = eventInfo.GetRemoveMethod(true);
} catch (Exception) {}
}
ModifierEnum modifiers = ModifierEnum.None;
if (methodBase != null)
{
if (methodBase.IsStatic)
{
modifiers |= ModifierEnum.Static;
}
if (methodBase.IsAssembly)
{
modifiers |= ModifierEnum.Internal;
}
if (methodBase.IsPrivate) // I assume that private is used most and public last (at least should be)
{
modifiers |= ModifierEnum.Private;
}
else if (methodBase.IsFamily || methodBase.IsFamilyOrAssembly)
{
modifiers |= ModifierEnum.Protected;
}
else if (methodBase.IsPublic)
{
modifiers |= ModifierEnum.Public;
}
else
{
modifiers |= ModifierEnum.Internal;
}
if (methodBase.IsFinal)
{
modifiers |= ModifierEnum.Sealed;
}
else if (methodBase.IsAbstract)
{
modifiers |= ModifierEnum.Abstract;
}
else if (methodBase.IsVirtual)
{
modifiers |= ModifierEnum.Virtual;
}
}
else
{
// assume public property, if no methodBase could be get.
modifiers = ModifierEnum.Public;
}
this.Modifiers = modifiers;
}
public ReflectionClass(ICompilationUnit compilationUnit, Type type, string fullName, IClass declaringType) : base(compilationUnit, declaringType)
{
FullyQualifiedName = SplitTypeParameterCountFromReflectionName(fullName);
try {
AddAttributes(compilationUnit.ProjectContent, this.Attributes, CustomAttributeData.GetCustomAttributes(type));
} catch (Exception ex) {
HostCallback.ShowError("Error reading custom attributes", ex);
}
// set classtype
if (type.IsInterface)
{
this.ClassType = ClassType.Interface;
}
else if (type.IsEnum)
{
this.ClassType = ClassType.Enum;
}
else if (type.IsValueType)
{
this.ClassType = ClassType.Struct;
}
else if (IsDelegate(type))
{
this.ClassType = ClassType.Delegate;
}
else
{
this.ClassType = ClassType.Class;
ApplySpecialsFromAttributes(this);
}
if (type.IsGenericTypeDefinition)
{
foreach (Type g in type.GetGenericArguments())
{
this.TypeParameters.Add(new DefaultTypeParameter(this, g));
}
int i = 0;
foreach (Type g in type.GetGenericArguments())
{
AddConstraintsFromType(this.TypeParameters[i++], g);
}
}
ModifierEnum modifiers = ModifierEnum.None;
if (type.IsNestedAssembly)
{
modifiers |= ModifierEnum.Internal;
}
if (type.IsSealed)
{
modifiers |= ModifierEnum.Sealed;
}
if (type.IsAbstract)
{
modifiers |= ModifierEnum.Abstract;
}
if (type.IsSealed && type.IsAbstract)
{
modifiers |= ModifierEnum.Static;
}
if (type.IsNestedPrivate) // I assume that private is used most and public last (at least should be)
{
modifiers |= ModifierEnum.Private;
}
else if (type.IsNestedFamily)
{
modifiers |= ModifierEnum.Protected;
}
else if (type.IsNestedPublic || type.IsPublic)
{
modifiers |= ModifierEnum.Public;
}
else if (type.IsNotPublic)
{
modifiers |= ModifierEnum.Internal;
}
else if (type.IsNestedFamORAssem || type.IsNestedFamANDAssem)
{
modifiers |= ModifierEnum.Protected;
modifiers |= ModifierEnum.Internal;
}
this.Modifiers = modifiers;
// set base classes
if (type.BaseType != null) // it's null for System.Object ONLY !!!
{
BaseTypes.Add(ReflectionReturnType.Create(this, type.BaseType));
}
foreach (Type iface in type.GetInterfaces())
{
BaseTypes.Add(ReflectionReturnType.Create(this, iface));
}
InitMembers(type);
}
