static object ReplaceTypeByIReturnType(IProjectContent pc, object val)
{
if (val is Type)
{
return(ReflectionReturnType.Create(pc, null, (Type)val, false, false));
}
else
{
return(val);
}
}
internal static void AddAttributes(IProjectContent pc, IList<IAttribute> list, IList<CustomAttributeData> attributes)
{
foreach (CustomAttributeData att in attributes) {
DefaultAttribute a = new DefaultAttribute(ReflectionReturnType.Create(pc, null, att.Constructor.DeclaringType, false));
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);
}
}
internal void AddConstraintsFromType(ITypeParameter tp, Type type)
{
foreach (Type constraint in type.GetGenericParameterConstraints())
{
if (tp.Method != null)
{
tp.Constraints.Add(ReflectionReturnType.Create(tp.Method, constraint, false));
}
else
{
tp.Constraints.Add(ReflectionReturnType.Create(tp.Class, constraint, false));
}
}
}
public ReflectionField(FieldInfo fieldInfo, IClass declaringType) : base(declaringType, fieldInfo.Name)
{
this.ReturnType = ReflectionReturnType.Create(this, fieldInfo.FieldType, false);
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, false);
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 methodBase = null;
try {
methodBase = propertyInfo.GetGetMethod(true);
} catch (Exception) {}
if (methodBase == null)
{
try {
methodBase = propertyInfo.GetSetMethod(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.IsVirtual)
{
modifiers |= ModifierEnum.Virtual;
}
if (methodBase.IsAbstract)
{
modifiers |= ModifierEnum.Abstract;
}
if (methodBase.IsFinal)
{
modifiers |= ModifierEnum.Sealed;
}
}
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, false));
}
foreach (Type iface in type.GetInterfaces()) {
BaseTypes.Add(ReflectionReturnType.Create(this, iface, false));
}
InitMembers(type);
}
public ReflectionEvent(EventInfo eventInfo, IClass declaringType) : base(declaringType, eventInfo.Name)
{
this.ReturnType = ReflectionReturnType.Create(this, eventInfo.EventHandlerType, false);
// 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 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 ReflectionMethod(MethodBase methodBase, ReflectionClass declaringType)
: base(declaringType, methodBase is ConstructorInfo ? "#ctor" : methodBase.Name)
{
if (methodBase is MethodInfo)
{
this.ReturnType = ReflectionReturnType.Create(this, ((MethodInfo)methodBase).ReturnType, false);
}
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())
{
declaringType.AddConstraintsFromType(this.TypeParameters[i++], g);
}
}
if (methodBase.IsStatic)
{
foreach (CustomAttributeData data in CustomAttributeData.GetCustomAttributes(methodBase))
{
string attributeName = data.Constructor.DeclaringType.FullName;
if (attributeName == "System.Runtime.CompilerServices.ExtensionAttribute" ||
attributeName == "Boo.Lang.ExtensionAttribute")
{
this.IsExtensionMethod = true;
}
}
}
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.IsVirtual)
{
modifiers |= ModifierEnum.Virtual;
}
if (methodBase.IsAbstract)
{
modifiers |= ModifierEnum.Abstract;
}
this.Modifiers = modifiers;
}
