/// <summary>
/// Checks whether a given set of arguments can be used to construct a generic type or method from a specified definition.
/// </summary>
public bool CheckGenericConstruction(IEntity definition, Node node, TypeReferenceCollection arguments, CompilerErrorCollection errors)
{
GenericConstructionChecker checker = new GenericConstructionChecker(
TypeSystemServices, node, arguments, Errors);
return(!(
checker.NotGenericDefinition(definition) ||
checker.IncorrectGenerity(definition) ||
checker.ViolatesParameterConstraints(definition)));
}
/// <summary>
/// Constructs generic entities out of an ambiguous definition.
/// </summary>
private IEntity ConstructAmbiguousEntity(Ambiguous ambiguousDefinition, Node constructionNode, TypeReferenceCollection argumentNodes)
{
GenericConstructionChecker checker = new GenericConstructionChecker(
TypeSystemServices,
constructionNode,
argumentNodes,
new CompilerErrorCollection());
List <IEntity> matches = new List <IEntity>(ambiguousDefinition.Entities);
// Filter matches by genericness, generity and constraints
Predicate <IEntity>[] filters = new Predicate <IEntity>[] {
checker.NotGenericDefinition,
checker.IncorrectGenerity,
checker.ViolatesParameterConstraints
};
foreach (Predicate <IEntity> filter in filters)
{
checker.Errors.Clear();
matches.RemoveAll(filter);
// If no matches pass the filter, record the first error only
// (providing all the distinct errors that occured would be superfluous)
if (matches.Count == 0)
{
Errors.Add(checker.Errors[0]);
return(TypeSystemServices.ErrorEntity);
}
// If only one match passes the filter, continue construction normally
if (matches.Count == 1)
{
return(ConstructEntity(matches[0], constructionNode, argumentNodes));
}
}
// Several matches have passed the filter -
// construct all of them and return another Ambiguous entity
IEntity[] constructed = Array.ConvertAll <IEntity, IEntity>(
matches.ToArray(),
delegate(IEntity def) { return(ConstructEntity(def, constructionNode, argumentNodes)); });
return(new Ambiguous(constructed));
}
/// <summary>
/// Constructs generic entities out of an ambiguous definition.
/// </summary>
private IEntity ConstructAmbiguousEntity(Node constructionNode, Ambiguous ambiguousDefinition, IType[] typeArguments)
{
GenericConstructionChecker checker = new GenericConstructionChecker(
TypeSystemServices,
constructionNode,
typeArguments,
new CompilerErrorCollection());
List<IEntity> matches = new List<IEntity>(ambiguousDefinition.Entities);
// Filter matches by genericness, generity and constraints
Predicate<IEntity>[] filters = new Predicate<IEntity>[] {
checker.NotGenericDefinition,
checker.IncorrectGenerity,
checker.ViolatesParameterConstraints };
foreach (Predicate<IEntity> filter in filters)
{
checker.Errors.Clear();
matches.RemoveAll(filter);
// If no matches pass the filter, record the first error only
// (providing all the distinct errors that occured would be superfluous)
if (matches.Count == 0)
{
Errors.Add(checker.Errors[0]);
return TypeSystemServices.ErrorEntity;
}
// If only one match passes the filter, continue construction normally
if (matches.Count == 1)
{
return ConstructEntity(constructionNode, matches[0], typeArguments);
}
}
// Several matches have passed the filter -
// construct all of them and return another Ambiguous entity
IEntity[] constructed = Array.ConvertAll<IEntity, IEntity>(
matches.ToArray(),
delegate(IEntity def) { return ConstructEntity(constructionNode, def, typeArguments); });
return new Ambiguous(constructed);
}
/// <summary>
/// Checks whether a given set of arguments can be used to construct a generic type or method from a specified definition.
/// </summary>
public bool CheckGenericConstruction(Node node, IEntity definition, IType[] argumentTypes, CompilerErrorCollection errors)
{
GenericConstructionChecker checker = new GenericConstructionChecker(
TypeSystemServices, node, argumentTypes, Errors);
return !(
checker.NotGenericDefinition(definition) ||
checker.IncorrectGenerity(definition) ||
checker.ViolatesParameterConstraints(definition));
}
/// <summary>
/// Checks whether a given set of arguments can be used to construct a generic type or method from a specified definition.
/// </summary>
public bool CheckGenericConstruction(IEntity definition, Node node, TypeReferenceCollection arguments, CompilerErrorCollection errors)
{
// Ensure definition is a valid entity
if (definition == null || TypeSystemServices.IsError(definition))
{
return false;
}
// Ensure definition really is a generic definition
GenericConstructionChecker checker = new GenericConstructionChecker(
TypeSystemServices, node, arguments, Errors);
return !(
checker.NotGenericDefinition(definition) ||
checker.IncorrectGenerity(definition) ||
checker.ViolatesParameterConstraints(definition));
}
