public override IType VisitChildren(TypeVisitor visitor)
{
IType e = elementType.AcceptVisitor(visitor);
if (e == elementType)
return this;
else
return new PointerType(e);
}
public IType VisitChildren(TypeVisitor visitor)
{
IType g = genericType.AcceptVisitor(visitor);
ITypeDefinition def = g as ITypeDefinition;
if (def == null)
return g;
// Keep ta == null as long as no elements changed, allocate the array only if necessary.
IType[] ta = (g != genericType) ? new IType[typeArguments.Length] : null;
for (int i = 0; i < typeArguments.Length; i++) {
IType r = typeArguments[i].AcceptVisitor(visitor);
if (r == null)
throw new NullReferenceException("TypeVisitor.Visit-method returned null");
if (ta == null && r != typeArguments[i]) {
// we found a difference, so we need to allocate the array
ta = new IType[typeArguments.Length];
for (int j = 0; j < i; j++) {
ta[j] = typeArguments[j];
}
}
if (ta != null)
ta[i] = r;
}
if (ta == null)
return this;
else
return new ParameterizedType(def, ta);
}
public IType AcceptVisitor(TypeVisitor visitor)
{
return visitor.VisitParameterizedType(this);
}
internal static bool ValidateConstraints(ITypeParameter typeParameter, IType typeArgument, TypeVisitor substitution, Conversions conversions)
{
switch (typeArgument.Kind) { // void, null, and pointers cannot be used as type arguments
case TypeKind.Void:
case TypeKind.Null:
case TypeKind.Pointer:
return false;
}
if (typeParameter.HasReferenceTypeConstraint) {
if (typeArgument.IsReferenceType != true)
return false;
}
if (typeParameter.HasValueTypeConstraint) {
if (!NullableType.IsNonNullableValueType(typeArgument))
return false;
}
if (typeParameter.HasDefaultConstructorConstraint) {
ITypeDefinition def = typeArgument.GetDefinition();
if (def != null && def.IsAbstract)
return false;
var ctors = typeArgument.GetConstructors(
m => m.Parameters.Count == 0 && m.Accessibility == Accessibility.Public,
GetMemberOptions.IgnoreInheritedMembers | GetMemberOptions.ReturnMemberDefinitions
);
if (!ctors.Any())
return false;
}
foreach (IType constraintType in typeParameter.DirectBaseTypes) {
IType c = constraintType;
if (substitution != null)
c = c.AcceptVisitor(substitution);
if (!conversions.IsConstraintConvertible(typeArgument, c))
return false;
}
return true;
}
/// <summary>
/// Validates whether the given type argument satisfies the constraints for the given type parameter.
/// </summary>
/// <param name="typeParameter">The type parameter.</param>
/// <param name="typeArgument">The type argument.</param>
/// <param name="substitution">The substitution that defines how type parameters are replaced with type arguments.
/// The substitution is used to check constraints that depend on other type parameters (or recursively on the same type parameter).</param>
/// <returns>True if the constraints are satisfied; false otherwise.</returns>
public static bool ValidateConstraints(ITypeParameter typeParameter, IType typeArgument, TypeVisitor substitution)
{
if (typeParameter == null)
throw new ArgumentNullException("typeParameter");
if (typeParameter.Owner == null)
throw new ArgumentNullException("typeParameter.Owner");
if (typeArgument == null)
throw new ArgumentNullException("typeArgument");
return ValidateConstraints(typeParameter, typeArgument, substitution, Conversions.Get(typeParameter.Owner.Compilation));
}
public IType AcceptVisitor(TypeVisitor visitor)
{
return(visitor.VisitParameterizedType(this));
}
// NestedTypes, Events, Fields: System.Array doesn't have any; so we can use the AbstractType default implementation
// that simply returns an empty list
public override IType AcceptVisitor(TypeVisitor visitor)
{
return(visitor.VisitArrayType(this));
}
public IType VisitChildren(TypeVisitor visitor)
{
throw new NotImplementedException ();
}
public override IType AcceptVisitor(TypeVisitor visitor)
{
return visitor.VisitPointerType(this);
}
public override IType AcceptVisitor(TypeVisitor visitor)
{
return visitor.VisitByReferenceType(this);
}
public override IType AcceptVisitor(TypeVisitor visitor)
{
return(visitor.VisitPointerType(this));
}
public override IType AcceptVisitor(TypeVisitor visitor)
{
return(visitor.VisitByReferenceType(this));
}
IType IType.VisitChildren(TypeVisitor visitor)
{
Contract.Requires(visitor != null);
Contract.Ensures(Contract.Result <IType>() != null);
return(this);
}
IType IType.AcceptVisitor(TypeVisitor visitor)
{
Contract.Requires(visitor != null);
Contract.Ensures(Contract.Result <IType>() != null);
return(this);
}
// NestedTypes, Events, Fields: System.Array doesn't have any; so we can use the AbstractType default implementation
// that simply returns an empty list
public override IType AcceptVisitor(TypeVisitor visitor)
{
return visitor.VisitArrayType(this);
}
public override IType VisitChildren(TypeVisitor visitor)
{
IType e = elementType.AcceptVisitor(visitor);
if (e == elementType)
return this;
else
return new ArrayType(compilation, e, dimensions);
}
public IType AcceptVisitor(TypeVisitor visitor)
{
throw new NotImplementedException ();
}
