private void RegisterType(INamedTypeSymbol namedTypeSymbol, TypeDefinitionData declaringType) { var accessibility = namedTypeSymbol.DeclaredAccessibility; if (!accessibility.IsPublicOrProtected()) { return; } var typeDefinitionData = new TypeDefinitionData(namedTypeSymbol, declaringType, this); _typeDefinitions.Add(namedTypeSymbol.GetFullName(), typeDefinitionData); foreach (var typeParameterSymbol in namedTypeSymbol.TypeParameters) { _typeOwnedGenericParameters.Add(Tuple.Create(namedTypeSymbol.GetFullName(), typeParameterSymbol.Ordinal), new GenericTypeParameterData(typeParameterSymbol, this)); } foreach (var method in namedTypeSymbol.Methods().Where(m => !m.TypeParameters.IsEmpty && m.DeclaredAccessibility.IsPublicOrProtected())) { var signature = new MethodSignature(Context, method); foreach (var typeParameterSymbol in method.TypeParameters) { _methodOwnedGenericParameters.Add(Tuple.Create(signature, typeParameterSymbol.Ordinal), new GenericTypeParameterData(typeParameterSymbol, this)); } } foreach (var nestedTypeSymbol in namedTypeSymbol.GetTypeMembers()) { RegisterType(nestedTypeSymbol, typeDefinitionData); } }
/// <summary> /// Indicates whether a new member of the same type and name is logically the same member as the current member, just from a newer build. /// </summary> /// <param name="newType">The new member to compare.</param> /// <param name="newAssemblyFamily">The assembly family in which new assemblies reside.</param> /// <param name="ignoreNewOptionalParameters"> /// Indicates whether to ignore any new parameters at the end of the collection which are optional when comparing. /// </param> #endif private bool IsEquivalentToNewTypeHelper(TypeDefinitionData newType, AssemblyFamily newAssemblyFamily, bool ignoreNewOptionalParameters) { if (base.IsEquivalentToNewMember(newType, newAssemblyFamily) == false) { return(false); } var isEquivalent = this.AssemblyData.IsEquivalentToNewAssembly(newType.AssemblyData); if (isEquivalent == false) { foreach (var source in newType.AssemblyData.GetForwardedTypeSources(newType)) { if (this.AssemblyData.IsEquivalentToNewAssembly(newAssemblyFamily.GetAssembly(source))) { isEquivalent = true; break; } } if (isEquivalent == false) { return(false); } } return (this.GenericParameters.Count == newType.GenericParameters.Count && this.TypeKind == newType.TypeKind && this.NameForComparison == newType.OldNameResolved); }
private void RegisterType(TypeDefinition type, TypeDefinitionData declaringType) { var accessibility = type.GetAccessibility(); if (accessibility == null) { return; } var typeDefinitionData = new TypeDefinitionData(type, accessibility.Value, declaringType, this); _typeDefinitions.Add(type.FullName, typeDefinitionData); foreach (var genericParameter in type.GenericParameters) { _typeOwnedGenericParameters.Add(Tuple.Create(type.FullName, genericParameter.Position), new GenericTypeParameterData(genericParameter, this)); } foreach (var method in type.Methods.Where(m => m.HasGenericParameters && m.GetAccessibility() != null)) { var signature = new MethodSignature(method); foreach (var genericParameter in method.GenericParameters) { _methodOwnedGenericParameters.Add(Tuple.Create(signature, genericParameter.Position), new GenericTypeParameterData(genericParameter, this)); } } foreach (var nestedType in type.NestedTypes) { this.RegisterType(nestedType, typeDefinitionData); } }
private void AddForwardedType(TypeDefinitionData type) { Debug.Assert(this != type.AssemblyData, "A type should not be forwarded to its own assembly."); if (type.AssemblyData._forwardedTypeSources.TryGetValue(type, out List <AssemblyData> forwardedTypeSources) == false) { type.AssemblyData._forwardedTypeSources[type] = forwardedTypeSources = new List <AssemblyData>(); } forwardedTypeSources.Add(this); }
internal ConstructedGenericTypeData(TypeDefinitionData genericTypeDefinition, IEnumerable <TypeData> genericArguments) : base(genericTypeDefinition.Name, genericTypeDefinition.Accessibility, genericTypeDefinition.MemberFlags, genericTypeDefinition.TypeKind) { GenericTypeDefinition = genericTypeDefinition; ContainingType = genericTypeDefinition.ContainingType; _isNullable = genericTypeDefinition.IsType(typeof(Nullable <>)); GenericArguments = new GenericTypeArgumentCollection(genericArguments); genericTypeDefinition.RegisterConstructedGenericTypeData(this); genericTypeDefinition.AssemblyData.RegisterForFinalize(this); }
internal IEnumerable <string> GetForwardedTypeSources(TypeDefinitionData type) { if (_forwardedTypeSources.TryGetValue(type, out List <AssemblyData> sourceAssemblies)) { foreach (var sourceAssembly in sourceAssemblies) { yield return(sourceAssembly.FullName); } } if (_forwardedTypeSourcesOnTarget.TryGetValue(type, out string sourceFullName)) { yield return(sourceFullName); } }
/// <summary> /// Gets the <see cref="TypeDefinitionData"/> instance representing the specified type. /// </summary> /// <typeparam name="T">The type for which to get the <see cref="TypeDefinitionData"/>.</typeparam> /// <returns>The <see cref="TypeDefinitionData"/> instance.</returns> public new static TypeDefinitionData FromType <T>() { return(TypeDefinitionData.FromType(typeof(T))); }
/// <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())); }
internal void AddForwardedTypeFromTarget(TypeDefinitionData type, string sourceAssembly) { _forwardedTypeSourcesOnTarget.Add(type, sourceAssembly); }
/// <summary> /// The visit implementation for <see cref="TypeDefinitionData"/> instances. /// </summary> public virtual void VisitTypeDefinitionData(TypeDefinitionData item) { this.DefaultVisit(item); }