/// <summary> /// Populates the type with additional information which can't be loaded when the type is created (due to potential circularities in item dependencies). /// </summary> /// <param name="underlyingType">The underlying type this instance represents.</param> #endif internal void FinalizeDefinition(GenericParameter underlyingType) { foreach (var type in underlyingType.Constraints) { this.Constraints.Add(TypeData.FromType(type)); } }
internal TypedMemberDataBase(MemberReference member, MemberAccessibility accessibility, TypeReference type, bool isTypeDynamic, MemberFlags flags, DeclaringTypeData declaringType) : base(member, accessibility, flags, declaringType) { this.Type = TypeData.FromType(type); this.IsTypeDynamic = isTypeDynamic; Debug.Assert(this.Type != null, "Unable to get the TypeData."); }
internal ParameterData(ParameterDefinition underlyingParameter, MemberDataBase declaringMember) { var modifer = ParameterModifier.None; var parameterType = underlyingParameter.ParameterType; var byReferenceType = parameterType as ByReferenceType; if (byReferenceType != null) { modifer = underlyingParameter.IsOut ? ParameterModifier.Out : ParameterModifier.Ref; parameterType = byReferenceType.ElementType; } this.DeclaringMemberKind = declaringMember.MetadataItemKind; this.Modifer = modifer; this.Name = underlyingParameter.Name; this.Type = TypeData.FromType(parameterType); if (underlyingParameter.IsOptional) { _flags |= InternalFlags.IsOptional; this.DefaultValue = Utilities.PreprocessConstantValue(parameterType, underlyingParameter.GetDefualtValue()); } if (underlyingParameter.CustomAttributes.Any(c => c.AttributeType.EqualsType(typeof(ParamArrayAttribute)))) { _flags |= InternalFlags.IsParamsArray; } if (underlyingParameter.IsDynamicType()) { _flags |= InternalFlags.IsTypeDynamic; } }
/// <summary> /// Gets the <see cref="TypeDefinitionData"/> instance representing the specified type. /// </summary> /// <returns>The <see cref="TypeDefinitionData"/> instance.</returns> public new static TypeDefinitionData FromType(Type t) { var typeDefinition = TypeData.FromType(t) as TypeDefinitionData; if (typeDefinition == null) { throw new ArgumentException("The specified type is not an externally visible type definition.", "t"); } return(typeDefinition); }
/// <summary> /// Populates the type with additional information which can't be loaded when the type is created (due to potential circularities in item dependencies). /// </summary> /// <param name="underlyingType">The underlying type this instance represents.</param> #endif internal void FinalizeDefinition(TypeDefinition underlyingType) { if (underlyingType.IsEnum) { this.BaseType = (DeclaringTypeData)TypeData.FromType(underlyingType.GetEnumUnderlyingType()); } else if (underlyingType.BaseType != null) { this.BaseType = (DeclaringTypeData)TypeData.FromType(underlyingType.BaseType); } this.ImplementedInterfaces = new ImplementedInterfacesCollection( underlyingType.Interfaces.Select(i => (DeclaringTypeData)TypeData.FromType(i)).Where(i => i != null) ); if (this.TypeKind == TypeKind.Delegate) { var invokeMethod = underlyingType.Methods.Single(m => m.Name == "Invoke"); this.DelegateParameters = new ParameterCollection(invokeMethod.Parameters, this); this.DelegateReturnType = TypeData.FromType(invokeMethod.ReturnType); this.DelegateReturnTypeIsDynamic = invokeMethod.IsReturnTypeDynamic(); } if (underlyingType.HasGenericParameters) { this.GenericParameters = Utilities.GetGenericParameters(underlyingType.GenericParameters, this); Debug.Assert( _constructedGenericTypes == null || _constructedGenericTypes.Values.All(c => c.GenericArguments.Count == this.GenericParameters.Count), "The type arity does not match."); } else { this.GenericParameters = GenericTypeParameterData.EmptyList; Debug.Assert(_constructedGenericTypes == null, "There should be no constructed generic types."); } this.NameForComparison = this.GetDisplayName(fullyQualify: true, includeGenericInfo: false); Debug.Assert(_constructedGenericTypes == null || _constructedGenericTypes.Keys.All(t => t.Count == this.GenericParameters.Count), "A constructed generic has the wrong type arity."); }
/// <summary> /// Gets the <see cref="TypeDefinitionData"/> instance representing the specified type. /// </summary> /// <returns>The <see cref="TypeDefinitionData"/> instance.</returns> public new static TypeDefinitionData FromType(TypeReference t) { return((TypeDefinitionData)TypeData.FromType(t)); }
private void LoadFromMetadata(AssemblyDefinition assembly) { _isLoading = true; foreach (var module in assembly.Modules) { foreach (var type in module.Types) { this.RegisterType(type, null); } } // Finalize Definitions this.IterateAllTypeDefinitions(assembly, typeDefinitionAction: type => { var typeData = (TypeDefinitionData)this.GetTypeData(type); if (typeData == null) { return(false); } typeData.FinalizeDefinition(type); return(true); }, genericParameterAction: genericParameter => { this.GetGenericTypeParameterData(genericParameter).FinalizeDefinition(genericParameter); }); // Populate Members this.IterateAllTypeDefinitions(assembly, typeDefinitionAction: type => { var typeData = (TypeDefinitionData)this.GetTypeData(type); if (typeData == null) { return(false); } typeData.PopulateMembers(type); return(true); }); while (_constructedGenericsToFinalizeAfterLoad.Count != 0) { var temp = _constructedGenericsToFinalizeAfterLoad.ToArray(); _constructedGenericsToFinalizeAfterLoad.Clear(); foreach (var type in temp) { type.FinalizeDefiniton(); } } foreach (var type in assembly.MainModule.ExportedTypes.Where(e => e.IsForwarder).Select(t => (TypeDefinitionData)TypeData.FromType(t.Resolve())).Where(t => t != null)) { this.AddForwardedType(type); } foreach (var referenceName in assembly.Modules.SelectMany(m => m.AssemblyReferences)) { AssemblyData reference; if (_cachedAssemblyDatas.TryGetValue(referenceName.FullName, out reference)) { _referencedAssemblies.Add(reference); } } _isLoading = false; }
/// <summary> /// Gets the <see cref="TypeData"/> instance containing the metadata for externally visible types and members of the specified <see cref="Type"/>. /// </summary> /// <param name="type">The type for which of corresponding to the TypeData to get.</param> /// <returns>The TypeData instance containing the metadata for externally visible types and members of the specified Type.</returns> #endif internal TypeData GetTypeData(TypeReference type) { Debug.Assert(type.GetType() != typeof(TypeReference), "The type has not been resolved yet, and may be from a different assembly."); Debug.Assert(type.GetDeclaringAssembly().FullName == this.FullName, "The type belongs to another assembly."); var genericParameter = type as GenericParameter; if (genericParameter != null) { return(this.GetGenericTypeParameterData(genericParameter)); } var accessibility = type.GetAccessibility(); if (accessibility == null) { return(null); } var typeDefinition = type as TypeDefinition; if (typeDefinition != null) { return(this.GetTypeDefinitionData(typeDefinition.FullName)); } DeclaringTypeData declaringType = null; if (type.DeclaringType != null) { declaringType = (DeclaringTypeData)this.GetTypeData(type.DeclaringType.Resolve()); } var genericInstance = type as GenericInstanceType; if (genericInstance != null) { return(TypeDefinitionData.FromType(genericInstance.ElementType).GetConstructedGenericTypeData(genericInstance.GenericArguments.Select(a => TypeData.FromType(a)))); } if (type.IsByReference) { Debug.Fail("We should never create representations for by-ref types. They can only be parameter types and ref or out parameters store the element type and indicate whether they are ref or out."); return(null); } var arrayType = type as ArrayType; if (arrayType != null) { Debug.Assert(declaringType == null, "Types with elements should not be declared within other types."); return(TypeData.FromType(arrayType.ElementType).GetArrayType((byte)arrayType.Rank)); } var pointerType = type as PointerType; if (pointerType != null) { return(TypeData.FromType(pointerType.ElementType).GetPointerType()); } var modifierType = type as IModifierType; if (modifierType != null) { return(TypeData.FromType(modifierType.ElementType)); } Debug.Fail("Unknown kind of type."); return(TypeData.FromType(type.Resolve())); }
/// <summary> /// Gets the derived <see cref="TypeData"/> instance representing the specified type. /// </summary> /// <param name="t">The type for which to get the <see cref="TypeData"/>.</param> /// <returns>The derived <see cref="TypeData"/> instance.</returns> public static TypeData FromType(Type t) { return(TypeData.FromType( t.Assembly.ToAssemblyDefinition().MainModule.GetType(t.FullName, runtimeName: true))); }
/// <summary> /// Gets the derived <see cref="TypeData"/> instance representing the specified type. /// </summary> /// <typeparam name="T">The type for which to get the <see cref="TypeData"/>.</typeparam> /// <returns>The derived <see cref="TypeData"/> instance.</returns> public static TypeData FromType <T>() { return(TypeData.FromType(typeof(T))); }
/// <summary> /// Gets the derived <see cref="ConstructedGenericTypeData"/> instance representing the specified type. /// </summary> /// <returns>The derived <see cref="ConstructedGenericTypeData"/> instance.</returns> public new static ConstructedGenericTypeData FromType(Type t) { // TODO_Public: throw an exception if the type is not a constructed generic return((ConstructedGenericTypeData)TypeData.FromType(t)); }