public SpecializedMethod(IMethod methodDefinition, TypeParameterSubstitution substitution)
: base(methodDefinition)
{
// The base ctor might have unpacked a SpecializedMember
// (in case we are specializing an already-specialized method)
methodDefinition = (IMethod)base.MemberDefinition;
this.methodDefinition = methodDefinition;
if (methodDefinition.TypeParameters.Any(ConstraintNeedsSpecialization)) {
// The method is generic, and we need to specialize the type parameters
specializedTypeParameters = new ITypeParameter[methodDefinition.TypeParameters.Count];
for (int i = 0; i < specializedTypeParameters.Length; i++) {
ITypeParameter tp = methodDefinition.TypeParameters[i];
if (ConstraintNeedsSpecialization(tp))
tp = new SpecializedTypeParameter(tp, this);
specializedTypeParameters[i] = tp;
}
// add substitution that replaces the base method's type parameters with our specialized version
AddSubstitution(new TypeParameterSubstitution(null, specializedTypeParameters));
}
// Add the main substitution after the method type parameter specialization.
AddSubstitution(substitution);
if (specializedTypeParameters != null) {
// Set the substitution on the type parameters to the final composed substitution
foreach (var tp in specializedTypeParameters.OfType<SpecializedTypeParameter>()) {
if (tp.Owner == this)
tp.substitution = base.Substitution;
}
}
}
public static IMember Create(IMember memberDefinition, TypeParameterSubstitution substitution)
{
if (memberDefinition == null) {
return null;
} else {
return memberDefinition.Specialize(substitution);
}
}
protected SpecializedMember(IMember memberDefinition)
{
if (memberDefinition == null)
throw new ArgumentNullException("memberDefinition");
if (memberDefinition is SpecializedMember)
throw new ArgumentException("Member definition cannot be specialized. Please use IMember.Specialize() instead of directly constructing SpecializedMember instances.");
this.baseMember = memberDefinition;
this.substitution = TypeParameterSubstitution.Identity;
}
public override IMember Specialize(TypeParameterSubstitution substitution)
{
if (TypeParameterSubstitution.Identity.Equals(substitution)
|| DeclaringTypeDefinition == null
|| DeclaringTypeDefinition.TypeParameterCount == 0)
{
return this;
}
if (substitution.MethodTypeArguments != null && substitution.MethodTypeArguments.Count > 0)
substitution = new TypeParameterSubstitution(substitution.ClassTypeArguments, EmptyList<IType>.Instance);
return new SpecializedField(this, substitution);
}
/// <summary>
/// Computes a single TypeParameterSubstitution so that for all types <c>t</c>:
/// <c>t.AcceptVisitor(Compose(g, f)) equals t.AcceptVisitor(f).AcceptVisitor(g)</c>
/// </summary>
/// <remarks>If you consider type parameter substitution to be a function, this is function composition.</remarks>
public static TypeParameterSubstitution Compose(TypeParameterSubstitution g, TypeParameterSubstitution f)
{
if (g == null)
return f;
if (f == null || (f.classTypeArguments == null && f.methodTypeArguments == null))
return g;
// The composition is a copy of 'f', with 'g' applied on the array elements.
// If 'f' has a null list (keeps type parameters unmodified), we have to treat it as
// the identity function, and thus use the list from 'g'.
var classTypeArguments = f.classTypeArguments != null ? GetComposedTypeArguments(f.classTypeArguments, g) : g.classTypeArguments;
var methodTypeArguments = f.methodTypeArguments != null ? GetComposedTypeArguments(f.methodTypeArguments, g) : g.methodTypeArguments;
return new TypeParameterSubstitution(classTypeArguments, methodTypeArguments);
}
protected SpecializedMember(IMember memberDefinition)
{
if (memberDefinition == null)
throw new ArgumentNullException("memberDefinition");
SpecializedMember sm = memberDefinition as SpecializedMember;
if (sm != null) {
this.baseMember = sm.baseMember;
this.substitution = sm.substitution;
} else {
this.baseMember = memberDefinition;
this.substitution = TypeParameterSubstitution.Identity;
}
}
public static SpecializedMember Create(IMember memberDefinition, TypeParameterSubstitution substitution)
{
if (memberDefinition == null) {
return null;
} else if (memberDefinition is IMethod) {
return new SpecializedMethod((IMethod)memberDefinition, substitution);
} else if (memberDefinition is IProperty) {
return new SpecializedProperty((IProperty)memberDefinition, substitution);
} else if (memberDefinition is IField) {
return new SpecializedField((IField)memberDefinition, substitution);
} else if (memberDefinition is IEvent) {
return new SpecializedEvent((IEvent)memberDefinition, substitution);
} else {
throw new NotSupportedException("Unknown IMember: " + memberDefinition);
}
}
public SpecializedMethod(IMethod methodDefinition, TypeParameterSubstitution substitution)
: base(methodDefinition)
{
SpecializedMethod specializedMethodDefinition = methodDefinition as SpecializedMethod;
if (specializedMethodDefinition != null)
this.genericMethodIsSpecialized = specializedMethodDefinition.genericMethodIsSpecialized;
// The base ctor might have unpacked a SpecializedMember
// (in case we are specializing an already-specialized method)
methodDefinition = (IMethod)base.baseMember;
this.methodDefinition = methodDefinition;
if (methodDefinition.TypeParameters.Count > 0) {
// The method is generic, so we need to specialize the type parameters
// (for specializing the constraints, and also to set the correct Owner)
specializedTypeParameters = new ITypeParameter[methodDefinition.TypeParameters.Count];
for (int i = 0; i < specializedTypeParameters.Length; i++) {
specializedTypeParameters[i] = new SpecializedTypeParameter(methodDefinition.TypeParameters[i], this);
}
if (!genericMethodIsSpecialized) {
// Add substitution that replaces the base method's type parameters with our specialized version
// but do this only if the type parameters on the baseMember have not already been substituted
substitutionWithoutSpecializedTypeParameters = this.Substitution;
AddSubstitution(new TypeParameterSubstitution(null, specializedTypeParameters));
}
}
// Add the main substitution after the method type parameter specialization.
AddSubstitution(substitution);
if (substitutionWithoutSpecializedTypeParameters != null) {
// If we already have a substitution without specialized type parameters, update that:
substitutionWithoutSpecializedTypeParameters = TypeParameterSubstitution.Compose(substitution, substitutionWithoutSpecializedTypeParameters);
} else {
// Otherwise just use the whole substitution, as that doesn't contain specialized type parameters
// in this case.
substitutionWithoutSpecializedTypeParameters = this.Substitution;
}
if (substitution != null && substitution.MethodTypeArguments != null && methodDefinition.TypeParameters.Count > 0)
this.genericMethodIsSpecialized = true;
if (specializedTypeParameters != null) {
// Set the substitution on the type parameters to the final composed substitution
foreach (var tp in specializedTypeParameters.OfType<SpecializedTypeParameter>()) {
if (tp.Owner == this)
tp.substitution = base.Substitution;
}
}
}
/// <summary>
/// Performs a substitution. This method may only be called by constructors in derived classes.
/// </summary>
protected void AddSubstitution(TypeParameterSubstitution newSubstitution)
{
Debug.Assert(declaringType == null);
Debug.Assert(returnType == null);
this.substitution = TypeParameterSubstitution.Compose(newSubstitution, this.substitution);
}
public override IMember Specialize(TypeParameterSubstitution substitution)
{
if (TypeParameterSubstitution.Identity.Equals(substitution))
return this;
return new SpecializedField(this, substitution);
}
public virtual IMember Specialize(TypeParameterSubstitution newSubstitution)
{
return baseMember.Specialize(TypeParameterSubstitution.Compose(newSubstitution, this.substitution));
}
public SpecializedProperty(IProperty propertyDefinition, TypeParameterSubstitution substitution)
: base(propertyDefinition)
{
AddSubstitution(substitution);
this.propertyDefinition = (IProperty)base.baseMember;
}
static IList<IType> GetComposedTypeArguments(IList<IType> input, TypeParameterSubstitution substitution)
{
IType[] result = new IType[input.Count];
for (int i = 0; i < result.Length; i++) {
result[i] = input[i].AcceptVisitor(substitution);
}
return result;
}
public override IMember Specialize(TypeParameterSubstitution substitution)
{
return new SpecializedProperty(this, substitution);
}
public SpecializedField(IField fieldDefinition, TypeParameterSubstitution substitution)
: base(fieldDefinition)
{
AddSubstitution(substitution);
this.fieldDefinition = (IField)base.baseMember;
}
public SpecializedEvent(IEvent eventDefinition, TypeParameterSubstitution substitution)
: base(eventDefinition)
{
AddSubstitution(substitution);
this.eventDefinition = (IEvent)base.baseMember;
}
public SpecializedProperty(IProperty propertyDefinition, TypeParameterSubstitution substitution)
: base(propertyDefinition)
{
this.propertyDefinition = propertyDefinition;
AddSubstitution(substitution);
}
public SpecializedField(IField fieldDefinition, TypeParameterSubstitution substitution)
: base(fieldDefinition)
{
this.fieldDefinition = fieldDefinition;
AddSubstitution(substitution);
}
public SpecializedField(IField fieldDefinition, TypeParameterSubstitution substitution)
: base(fieldDefinition)
{
this.fieldDefinition = fieldDefinition;
AddSubstitution(substitution);
}
public SpecializedEvent(IEvent eventDefinition, TypeParameterSubstitution substitution)
: base(eventDefinition)
{
this.eventDefinition = eventDefinition;
AddSubstitution(substitution);
}
public SpecializedProperty(IProperty propertyDefinition, TypeParameterSubstitution substitution)
: base(propertyDefinition)
{
AddSubstitution(substitution);
this.propertyDefinition = (IProperty)base.MemberDefinition;
}
static IEnumerable<IMethod> GetMethodsImpl(IType baseType, IList<IType> methodTypeArguments, Predicate<IUnresolvedMethod> filter, GetMemberOptions options)
{
IEnumerable<IMethod> declaredMethods = baseType.GetMethods(filter, options | declaredMembers);
ParameterizedType pt = baseType as ParameterizedType;
if ((options & GetMemberOptions.ReturnMemberDefinitions) == 0
&& (pt != null || (methodTypeArguments != null && methodTypeArguments.Count > 0)))
{
TypeParameterSubstitution substitution = null;
foreach (IMethod m in declaredMethods) {
if (methodTypeArguments != null && methodTypeArguments.Count > 0) {
if (m.TypeParameters.Count != methodTypeArguments.Count)
continue;
}
if (substitution == null) {
if (pt != null)
substitution = pt.GetSubstitution(methodTypeArguments);
else
substitution = new TypeParameterSubstitution(null, methodTypeArguments);
}
yield return new SpecializedMethod(m, substitution);
}
} else {
foreach (IMethod m in declaredMethods) {
yield return m;
}
}
}
/// <summary>
/// Performs a substitution. This method may only be called by constructors in derived classes.
/// </summary>
protected void AddSubstitution(TypeParameterSubstitution newSubstitution)
{
Debug.Assert(declaringType == null);
Debug.Assert(returnType == null);
this.substitution = TypeParameterSubstitution.Compose(newSubstitution, this.substitution);
}
public override IMember Specialize(TypeParameterSubstitution newSubstitution)
{
return methodDefinition.Specialize(TypeParameterSubstitution.Compose(newSubstitution, substitutionWithoutSpecializedTypeParameters));
}
public virtual IMember Specialize(TypeParameterSubstitution newSubstitution)
{
return(baseMember.Specialize(TypeParameterSubstitution.Compose(newSubstitution, this.substitution)));
}
IMethod IMethod.Specialize(TypeParameterSubstitution newSubstitution)
{
return methodDefinition.Specialize(TypeParameterSubstitution.Compose(newSubstitution, substitutionWithoutSpecializedTypeParameters));
}
public override IMember Specialize(TypeParameterSubstitution substitution)
{
return(new SpecializedField(this, substitution));
}
public abstract IMember Specialize(TypeParameterSubstitution substitution);
