/// <inheritdoc/> internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments) { List <TypeData> replacedGenericArguments = null; for (int i = 0; i < GenericArguments.Count; i++) { var currentArgument = GenericArguments[i]; var replacedArgument = (TypeData)currentArgument.ReplaceGenericTypeParameters(genericParameters, genericArguments); if (replacedArgument == currentArgument) { continue; } if (replacedGenericArguments == null) { replacedGenericArguments = new List <TypeData>(GenericArguments); } replacedGenericArguments[i] = replacedArgument; } if (replacedGenericArguments != null) { return(GenericTypeDefinition.GetConstructedGenericTypeData(replacedGenericArguments)); } return(this); }
/// <summary> /// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type. /// </summary> /// <param name="genericParameters">The generic parameters being replaced.</param> /// <param name="genericArguments">The generic arguments replacing the parameters.</param> /// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns> #endif internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments) { if (this.GenericParameters == genericParameters) { return(this.GetConstructedGenericTypeData(genericArguments)); } return(this); }
/// <inheritdoc/> internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments) { var replacedType = (TypeData)Type.ReplaceGenericTypeParameters(genericParameters, genericArguments); if (replacedType == Type) { return(this); } return(new PropertyData(Name, Accessibility, MemberFlags, replacedType, IsTypeDynamic, GetMethodAccessibility, SetMethodAccessibility)); }
/// <summary> /// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type. /// </summary> /// <param name="genericParameters">The generic parameters being replaced.</param> /// <param name="genericArguments">The generic arguments replacing the parameters.</param> /// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns> #endif internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments) { var replacedParameters = this.Parameters.ReplaceGenericTypeParameters(this.MetadataItemKind, genericParameters, genericArguments); if (replacedParameters == this.Parameters) { return(this); } return(new ConstructorData(this.Name, this.Accessibility, this.MemberFlags, replacedParameters)); }
/// <summary> /// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type. /// </summary> /// <param name="genericParameters">The generic parameters being replaced.</param> /// <param name="genericArguments">The generic arguments replacing the parameters.</param> /// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns> #endif internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments) { var replacedType = (TypeData)this.Type.ReplaceGenericTypeParameters(genericParameters, genericArguments); if (replacedType == this.Type) { return(this); } return(new EventData(this.Name, this.Accessibility, this.MemberFlags, replacedType)); }
/// <inheritdoc/> internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments) { var replacedElementType = (TypeData)ElementType.ReplaceGenericTypeParameters(genericParameters, genericArguments); if (replacedElementType == ElementType) { return(this); } return(replacedElementType.GetPointerType()); }
/// <summary> /// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type. /// </summary> /// <param name="genericParameters">The generic parameters being replaced.</param> /// <param name="genericArguments">The generic arguments replacing the parameters.</param> /// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns> #endif internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments) { var replacedType = (TypeData)this.Type.ReplaceGenericTypeParameters(genericParameters, genericArguments); if (replacedType == this.Type) { return(this); } Debug.Fail("It was assumed that constants cannot be generic"); return(new ConstantData(this.Name, this.Accessibility, this.MemberFlags, replacedType, this.IsTypeDynamic, this.Value)); }
/// <summary> /// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type. /// </summary> /// <param name="genericParameters">The generic parameters being replaced.</param> /// <param name="genericArguments">The generic arguments replacing the parameters.</param> /// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns> #endif internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments) { var replacedType = (TypeData)this.Type.ReplaceGenericTypeParameters(genericParameters, genericArguments); var replacedParameters = this.Parameters.ReplaceGenericTypeParameters(this.MetadataItemKind, genericParameters, genericArguments); if (replacedType == this.Type && replacedParameters == this.Parameters) { return(this); } return(new IndexerData(this.Name, this.Accessibility, this.MemberFlags, replacedType, this.IsTypeDynamic, replacedParameters, this.GetMethodAccessibility, this.SetMethodAccessibility)); }
/// <inheritdoc/> internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments) { var replacedType = (TypeData)Type.ReplaceGenericTypeParameters(genericParameters, genericArguments); var replacedParameters = Parameters.ReplaceGenericTypeParameters(MetadataItemKind, genericParameters, genericArguments); if (replacedType == Type && replacedParameters == Parameters) { return(this); } return(new MethodData(Name, Accessibility, MemberFlags, replacedType, IsTypeDynamic, GenericParameters, IsExtensionMethod, replacedParameters)); }
/// <summary> /// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type. /// </summary> /// <param name="genericParameters">The generic parameters being replaced.</param> /// <param name="genericArguments">The generic arguments replacing the parameters.</param> /// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns> #endif internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments) { for (int i = 0; i < genericParameters.Count; i++) { if (this == genericParameters[i]) { Debug.Assert(this.GenericParameterPosition == i, "We are expecting the generic argument to be in its proper position."); return(genericArguments[i]); } } return(this); }
internal bool DoesMatch(GenericTypeParameterCollection other) { if (this.Count != other.Count) { return(false); } for (int i = 0; i < this.Count; i++) { if (this[i].DoesMatch(other[i]) == false) { return(false); } } return(true); }
/// <summary> /// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type. /// </summary> /// <param name="genericParameters">The generic parameters being replaced.</param> /// <param name="genericArguments">The generic arguments replacing the parameters.</param> /// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns> #endif internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments) { var replacedElementType = (TypeData)this.ElementType.ReplaceGenericTypeParameters(genericParameters, genericArguments); if (replacedElementType == this.ElementType) { return(this); } return (replacedElementType.GetArrayType(this.ArrayRank) ?? new ArrayTypeData( this.Name, this.Accessibility, this.MemberFlags, this.TypeKind, replacedElementType, this.ArrayRank)); }
internal MethodData(string name, Accessibility accessibility, MemberFlags memberFlags, TypeData type, bool isTypeDynamic, GenericTypeParameterCollection genericParameters, bool isExtensionMethod, ParameterCollection parameters) : base(name, accessibility, memberFlags, type, isTypeDynamic, parameters) { GenericParameters = genericParameters; IsExtensionMethod = isExtensionMethod; }
internal ImplementedInterfacesCollection ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments) { return(new ImplementedInterfacesCollection(this.Select(im => (DeclaringTypeData)im.ReplaceGenericTypeParameters(genericParameters, genericArguments)))); }
/// <inheritdoc/> internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments) => GenericParameters == genericParameters?GetConstructedGenericTypeData(genericArguments) : (MemberDataBase)this;
/// <summary> /// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type. /// </summary> /// <param name="declaringMemberKind">The type of member owning the parameter collection.</param> /// <param name="genericParameters">The generic parameters being replaced.</param> /// <param name="genericArguments">The generic arguments replacing the parameters.</param> /// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns> #endif internal ParameterData ReplaceGenericTypeParameters(MetadataItemKinds declaringMemberKind, GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments) { var replacedType = (TypeData)this.Type.ReplaceGenericTypeParameters(genericParameters, genericArguments); if (replacedType == this.Type) { return(this); } return(new ParameterData(declaringMemberKind, this.Name, replacedType, this.Modifer, _flags, this.DefaultValue)); }
/// <summary> /// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type. /// </summary> /// <param name="genericParameters">The generic parameters being replaced.</param> /// <param name="genericArguments">The generic arguments replacing the parameters.</param> /// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns> #endif internal abstract MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments);
/// <summary> /// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type. /// </summary> /// <param name="declaringMemberKind">The type of member owning the parameter collection.</param> /// <param name="genericParameters">The generic parameters being replaced.</param> /// <param name="genericArguments">The generic arguments replacing the parameters.</param> /// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns> #endif internal ParameterCollection ReplaceGenericTypeParameters(MetadataItemKinds declaringMemberKind, GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments) { ParameterCollection replacedParameters = null; for (int i = 0; i < this.Count; i++) { var currentParameter = this[i]; var replacedParameter = currentParameter.ReplaceGenericTypeParameters(declaringMemberKind, genericParameters, genericArguments); if (replacedParameter == currentParameter) { continue; } if (replacedParameters == null) { replacedParameters = new ParameterCollection(); replacedParameters._parameters.AddRange(_parameters); } replacedParameters._parameters[i] = replacedParameter; } return(replacedParameters ?? this); }