void AddModuleDefinition(ModuleDefinition moduleDefinition, bool loadInternal, bool instantiateTypeParameter) { InstantiatedParamResolver resolver = new InstantiatedParamResolver(); Module module = new Module(moduleDefinition); foreach (TypeDefinition type in moduleDefinition.Types) { if (!loadInternal && IsInternal(DomCecilType.GetModifiers(type.Attributes))) { continue; } // if (type.Name == "SimplePropertyDescriptor") // System.Console.WriteLine(type.Attributes + "/" + DomCecilType.GetModifiers (type.Attributes) + "/" + IsInternal (DomCecilType.GetModifiers (type.Attributes))); DomCecilType loadType = new DomCecilType(type, loadInternal, loadMonotouchDocumentation); if (instantiateTypeParameter) { resolver.Visit(loadType, null); resolver.ClearTypes(); } loadMonotouchDocumentation &= loadType.LoadMonotouchDocumentation; Add(loadType); module.Types.Add(loadType); } this.modules.Add(module); }
void AddModuleDefinition(ModuleDefinition moduleDefinition, bool loadInternal, bool instantiateTypeParameter) { InstantiatedParamResolver resolver = new InstantiatedParamResolver(xmlDocumentation); Module module = new Module(moduleDefinition); foreach (TypeDefinition type in moduleDefinition.Types) { // filter nested types, they're handled in DomCecilType. if ((type.Attributes & TypeAttributes.NestedPublic) == TypeAttributes.NestedPublic || (type.Attributes & TypeAttributes.NestedFamily) == TypeAttributes.NestedFamily || (type.Attributes & TypeAttributes.NestedAssembly) == TypeAttributes.NestedAssembly || (type.Attributes & TypeAttributes.NestedPrivate) == TypeAttributes.NestedPrivate || (type.Attributes & TypeAttributes.NestedFamANDAssem) == TypeAttributes.NestedFamANDAssem) { continue; } if (!loadInternal && IsInternal(DomCecilType.GetModifiers(type.Attributes))) { continue; } // if (type.Name == "SimplePropertyDescriptor") // System.Console.WriteLine(type.Attributes + "/" + DomCecilType.GetModifiers (type.Attributes) + "/" + IsInternal (DomCecilType.GetModifiers (type.Attributes))); DomCecilType loadType = new DomCecilType(type, loadInternal); if (instantiateTypeParameter) { resolver.Visit(loadType, null); resolver.ClearTypes(); } Add(loadType); module.Types.Add(loadType); } this.modules.Add(module); }
/* FieldDefinition fieldDefinition; * * public FieldDefinition FieldDefinition { * get { * return fieldDefinition; * } * } */ public DomCecilField(FieldDefinition fieldDefinition) { base.name = fieldDefinition.Name; base.Modifiers = DomCecilType.GetModifiers(fieldDefinition); base.ReturnType = DomCecilMethod.GetReturnType(fieldDefinition.FieldType); DomCecilMethod.AddAttributes(this, fieldDefinition.CustomAttributes); }
public DomCecilType(TypeReference typeReference) { this.classType = ClassType.Unknown; this.Modifiers = Modifiers.None; this.Name = DomCecilType.RemoveGenericParamSuffix(typeReference.Name); this.Namespace = typeReference.Namespace; }
public static IReturnType GetReturnType(MethodReference methodReference) { if (methodReference == null) { return(DomReturnType.Void); } return(DomReturnType.GetSharedReturnType(DomCecilType.RemoveGenericParamSuffix(methodReference.DeclaringType.FullName))); }
public DomCecilMethod(MethodDefinition methodDefinition) { this.methodDefinition = methodDefinition; this.name = methodDefinition.Name; if (methodDefinition.Name == ".ctor") { MethodModifier |= MethodModifier.IsConstructor; } foreach (GenericParameter param in methodDefinition.GenericParameters) { TypeParameter tp = new TypeParameter(param.FullName); tp.Variance = (TypeParameterVariance)(((uint)param.Attributes) & 3); if (param.HasDefaultConstructorConstraint) { tp.TypeParameterModifier |= TypeParameterModifier.HasDefaultConstructorConstraint; } foreach (TypeReference tr in param.Constraints) { tp.AddConstraint(DomCecilMethod.GetReturnType(tr)); } AddTypeParameter(tp); } AddAttributes(this, methodDefinition.CustomAttributes); base.Modifiers = DomCecilType.GetModifiers(methodDefinition); base.ReturnType = DomCecilMethod.GetReturnType(methodDefinition.ReturnType); foreach (ParameterDefinition paramDef in methodDefinition.Parameters) { Add(new DomCecilParameter(paramDef)); } if (this.IsStatic) { foreach (IAttribute attr in this.Attributes) { if (attr.Name == "System.Runtime.CompilerServices.ExtensionAttribute") { MethodModifier |= MethodModifier.IsExtension; break; } } } foreach (MethodReference overrideRef in methodDefinition.Overrides) { if (overrideRef.Name == this.name && IsPublic) { continue; } AddExplicitInterface(GetReturnType(overrideRef.DeclaringType)); } }
public DomCecilEvent(EventDefinition eventDefinition) { this.eventDefinition = eventDefinition; base.name = eventDefinition.Name; base.Modifiers = DomCecilType.GetModifiers(eventDefinition.AddMethod); base.ReturnType = DomCecilMethod.GetReturnType(eventDefinition.EventType); DomCecilMethod.AddAttributes(this, eventDefinition.CustomAttributes); if (!eventDefinition.IsSpecialName) { base.Modifiers &= ~MonoDevelop.Projects.Dom.Modifiers.SpecialName; } }
public DomCecilType(TypeDefinition typeDefinition, bool loadInternal, bool loadMonotouchDocumentation = true) { this.LoadMonotouchDocumentation = loadMonotouchDocumentation; this.typeDefinition = typeDefinition; this.loadInternal = loadInternal; this.classType = GetClassType(typeDefinition); this.Name = DomCecilType.RemoveGenericParamSuffix(typeDefinition.Name); this.Namespace = typeDefinition.Namespace; this.Modifiers = GetModifiers(typeDefinition.Attributes); if (typeDefinition.BaseType != null) { this.baseType = DomCecilMethod.GetReturnType(typeDefinition.BaseType); } DomCecilMethod.AddAttributes(this, typeDefinition.CustomAttributes); foreach (TypeReference interfaceReference in typeDefinition.Interfaces) { this.AddInterfaceImplementation(DomCecilMethod.GetReturnType(interfaceReference)); } foreach (GenericParameter parameter in typeDefinition.GenericParameters) { TypeParameter tp = new TypeParameter(parameter.FullName); tp.Variance = (TypeParameterVariance)(((uint)parameter.Attributes) & 3); if (parameter.HasDefaultConstructorConstraint) { tp.TypeParameterModifier |= TypeParameterModifier.HasDefaultConstructorConstraint; } foreach (TypeReference tr in parameter.Constraints) { tp.AddConstraint(DomCecilMethod.GetReturnType(tr)); } AddTypeParameter(tp); } AddDocumentation(this); }
void CheckInitialization () { if (isInitialized) return; isInitialized = true; foreach (FieldDefinition fieldDefinition in typeDefinition.Fields) { if (!loadInternal && DomCecilCompilationUnit.IsInternal (DomCecilType.GetModifiers (fieldDefinition))) continue; base.Add (new DomCecilField (fieldDefinition)); } foreach (MethodDefinition methodDefinition in typeDefinition.Methods.Where (m => !m.IsConstructor)) { if (!loadInternal && DomCecilCompilationUnit.IsInternal (DomCecilType.GetModifiers (methodDefinition))) continue; base.Add (new DomCecilMethod (methodDefinition)); } bool internalOnly = true; bool hasConstructors = false; foreach (MethodDefinition methodDefinition in typeDefinition.Methods.Where (m => m.IsConstructor)) { hasConstructors = true; if (!loadInternal && DomCecilCompilationUnit.IsInternal (DomCecilType.GetModifiers (methodDefinition))) continue; internalOnly = false; base.Add (new DomCecilMethod (methodDefinition)); } if (hasConstructors && internalOnly) base.TypeModifier |= TypeModifier.HasOnlyHiddenConstructors; foreach (PropertyDefinition propertyDefinition in typeDefinition.Properties) { if (!loadInternal && DomCecilCompilationUnit.IsInternal (DomCecilType.GetModifiers (propertyDefinition.Attributes))) continue; base.Add (new DomCecilProperty (propertyDefinition)); } foreach (EventDefinition eventDefinition in typeDefinition.Events) { if (!loadInternal && DomCecilCompilationUnit.IsInternal (DomCecilType.GetModifiers (eventDefinition.Attributes))) continue; base.Add (new DomCecilEvent (eventDefinition)); } foreach (TypeDefinition nestedType in typeDefinition.NestedTypes) { if (!loadInternal && DomCecilCompilationUnit.IsInternal (DomCecilType.GetModifiers (nestedType.Attributes))) continue; DomCecilType innerType = new DomCecilType (nestedType, loadInternal); base.Add (innerType); if (typeParameters != null && innerType.typeParameters != null) innerType.typeParameters.RemoveAll (para => typeParameters.Any (myPara => myPara.Name == para.Name)); } }
/* * // Check if 'type' has some decorations applied to it * if (type is Mono.Cecil.TypeSpecification) { * // Go through all levels of 'indirection', 'array dimensions' * // and 'generic types' - in the end, we should get the actual * // type of the ReturnType (but all data about its array * // dimensions, levels of indirection and even its generic * // parameters is correctly stored within ArrayCount and * // ArrayDimensions, PointerNestingLevel and GenericArguments * // respectively). * if (type is ArrayType) { * // This return type is obviously an array - add the rank * ArrayType at = (ArrayType) type; * if (arrays == null) * arrays = new Stack<int>(); * arrays.Push(at.Rank); * type = at.ElementType; * } else else if (type is Mono.Cecil.ReferenceType) { * Mono.Cecil.ReferenceType rt = (Mono.Cecil.ReferenceType) type; * byRef = true; * type = rt.ElementType; * } else if (type is PointerType) { * // The type is a pointer * PointerType pt = (PointerType) type; ++pointerNestingLevel; * type = pt.ElementType; * // Go down one level * } else { * // TODO: Check if we loose some relevant info here * type = ((TypeSpecification)type).ElementType; * }*/ public static DomReturnType GetReturnType(TypeReference typeReference) { if (typeReference == null) { return(new DomReturnType(DomReturnType.Void.ToInvariantString())); } if (typeReference is Mono.Cecil.GenericInstanceType) { Mono.Cecil.GenericInstanceType genType = (Mono.Cecil.GenericInstanceType)typeReference; DomReturnType result = GetReturnType(genType.ElementType); foreach (TypeReference typeRef in genType.GenericArguments) { DomReturnType param = GetReturnType(typeRef); foreach (IReturnTypePart part in result.Parts) { if (part.Tag is TypeDefinition) { TypeDefinition typeDef = (TypeDefinition)part.Tag; foreach (TypeReference typeParam in typeDef.GenericParameters) { if (typeParam.Name == param.Name) { part.AddTypeParameter(param); goto skip; } } } } result.AddTypeParameter(param); skip :; } return(result); } if (typeReference is Mono.Cecil.ArrayType) { Mono.Cecil.ArrayType arrType = (Mono.Cecil.ArrayType)typeReference; DomReturnType result = GetReturnType(arrType.ElementType); result.ArrayDimensions++; result.SetDimension(result.ArrayDimensions - 1, arrType.Rank - 1); return(result); } if (typeReference is Mono.Cecil.PointerType) { Mono.Cecil.PointerType ptrType = (Mono.Cecil.PointerType)typeReference; DomReturnType result = GetReturnType(ptrType.ElementType); if (result.ArrayDimensions > 0) { result.ArrayPointerNestingLevel++; } else { result.PointerNestingLevel++; } return(result); } if (typeReference is Mono.Cecil.ByReferenceType) { return(GetReturnType(((Mono.Cecil.ByReferenceType)typeReference).ElementType)); } if (typeReference is Mono.Cecil.TypeDefinition) { Mono.Cecil.TypeDefinition typeDefinition = (Mono.Cecil.TypeDefinition)typeReference; DomReturnType result; if (typeDefinition.DeclaringType != null) { result = GetReturnType(typeDefinition.DeclaringType); result.Parts.Add(new ReturnTypePart(typeDefinition.Name)); result.Tag = typeDefinition; } else { result = new DomReturnType(typeDefinition.Name); result.Namespace = typeDefinition.Namespace; result.Tag = typeDefinition; } return(result); } return(new DomReturnType(DomCecilType.RemoveGenericParamSuffix(typeReference.FullName))); }
void CheckInitialization() { if (isInitialized) { return; } isInitialized = true; foreach (FieldDefinition fieldDefinition in typeDefinition.Fields) { if (!loadInternal && DomCecilCompilationUnit.IsInternal(DomCecilType.GetModifiers(fieldDefinition))) { continue; } base.Add(new DomCecilField(fieldDefinition)); } foreach (MethodDefinition methodDefinition in typeDefinition.Methods.Where(m => !m.IsConstructor)) { if (!loadInternal && DomCecilCompilationUnit.IsInternal(DomCecilType.GetModifiers(methodDefinition))) { continue; } base.Add(new DomCecilMethod(methodDefinition)); } bool internalOnly = true; bool hasConstructors = false; foreach (MethodDefinition methodDefinition in typeDefinition.Methods.Where(m => m.IsConstructor)) { hasConstructors = true; if (!loadInternal && DomCecilCompilationUnit.IsInternal(DomCecilType.GetModifiers(methodDefinition))) { continue; } internalOnly = false; base.Add(new DomCecilMethod(methodDefinition)); } if (hasConstructors && internalOnly) { base.TypeModifier |= TypeModifier.HasOnlyHiddenConstructors; } foreach (PropertyDefinition propertyDefinition in typeDefinition.Properties) { if (!loadInternal && DomCecilCompilationUnit.IsInternal(DomCecilType.GetModifiers(propertyDefinition.Attributes))) { continue; } base.Add(new DomCecilProperty(propertyDefinition)); } foreach (EventDefinition eventDefinition in typeDefinition.Events) { if (!loadInternal && DomCecilCompilationUnit.IsInternal(DomCecilType.GetModifiers(eventDefinition.Attributes))) { continue; } base.Add(new DomCecilEvent(eventDefinition)); } foreach (TypeDefinition nestedType in typeDefinition.NestedTypes) { if (!loadInternal && DomCecilCompilationUnit.IsInternal(DomCecilType.GetModifiers(nestedType.Attributes))) { continue; } DomCecilType innerType = new DomCecilType(nestedType, loadInternal); base.Add(innerType); if (typeParameters != null && innerType.typeParameters != null) { innerType.typeParameters.RemoveAll(para => typeParameters.Any(myPara => myPara.Name == para.Name)); } } }