public ReflectionParameter(ParameterInfo parameterInfo, IMember member) : base(parameterInfo.Name) { Type type = parameterInfo.ParameterType; this.ReturnType = ReflectionReturnType.Create(member, type, false); if (type.IsByRef && parameterInfo.IsOut) { this.Modifiers = ParameterModifiers.Out; } else if (type.IsByRef) { this.Modifiers = ParameterModifiers.Ref; } if (parameterInfo.IsOptional) { this.Modifiers |= ParameterModifiers.Optional; } if (type.IsArray && type != typeof(Array)) { foreach (CustomAttributeData data in CustomAttributeData.GetCustomAttributes(parameterInfo)) { if (data.Constructor.DeclaringType.FullName == typeof(ParamArrayAttribute).FullName) { this.Modifiers |= ParameterModifiers.Params; break; } } } }
static object ReplaceTypeByIReturnType(IProjectContent pc, object val) { if (val is Type) { return ReflectionReturnType.Create(pc, null, (Type)val, false, false); } else { return val; } }
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; } } else { // assume public property, if no methodBase could be get. modifiers = ModifierEnum.Public; } this.Modifiers = modifiers; }
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, false)); } else { tp.Constraints.Add(ReflectionReturnType.Create(tp.Class, constraint, false)); } } }
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 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); } }
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 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; }