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);