static bool isValueType(
TypeParameterSymbol thisTypeParameter,
ImmutableArray <TypeParameterConstraintClause> constraintClauses,
SmallDictionary <TypeParameterSymbol, bool> isValueTypeMap,
ConsList <TypeParameterSymbol> inProgress
)
{
if (inProgress.ContainsReference(thisTypeParameter))
{
return(false);
}
if (isValueTypeMap.TryGetValue(thisTypeParameter, out bool knownIsValueType))
{
return(knownIsValueType);
}
TypeParameterConstraintClause constraintClause = constraintClauses[
thisTypeParameter.Ordinal
];
bool result = false;
if (
(constraintClause.Constraints & TypeParameterConstraintKind.AllValueTypeKinds)
!= 0
)
{
result = true;
}
else
{
Symbol container = thisTypeParameter.ContainingSymbol;
inProgress = inProgress.Prepend(thisTypeParameter);
foreach (TypeWithAnnotations constraintType in constraintClause.ConstraintTypes)
{
TypeSymbol type = constraintType.IsResolved
? constraintType.Type
: constraintType.DefaultType;
if (
type is TypeParameterSymbol typeParameter &&
(object)typeParameter.ContainingSymbol == (object)container
)
{
if (
isValueType(
typeParameter,
constraintClauses,
isValueTypeMap,
inProgress
)
)
{
result = true;
break;
}
}
private static bool HaveSameConstraints(TypeParameterConstraintClause clause1, TypeParameterConstraintClause clause2)
{
if ((clause1 == null) || (clause2 == null))
{
return((clause1 == null) && (clause2 == null));
}
if (clause1.Constraints != clause2.Constraints)
{
return(false);
}
var constraintTypes1 = clause1.ConstraintTypes;
var constraintTypes2 = clause2.ConstraintTypes;
int n = constraintTypes1.Length;
if (constraintTypes2.Length != n)
{
return(false);
}
// Construct a HashSet<T> for one of the sets
// to allow O(n) comparison of the two sets.
var setTypes2 = new HashSet <TypeSymbol>();
foreach (var constraintType in constraintTypes2)
{
// Binder should have dropped any duplicates.
Debug.Assert(!setTypes2.Contains(constraintType));
setTypes2.Add(constraintType);
}
foreach (var constraintType in constraintTypes1)
{
if (!setTypes2.Contains(constraintType))
{
return(false);
}
}
return(true);
}
private static bool HaveSameConstraints(TypeParameterConstraintClause clause1, TypeParameterConstraintClause clause2)
{
if ((clause1 == null) || (clause2 == null))
{
return (clause1 == null) && (clause2 == null);
}
if (clause1.Constraints != clause2.Constraints)
{
return false;
}
var constraintTypes1 = clause1.ConstraintTypes;
var constraintTypes2 = clause2.ConstraintTypes;
int n = constraintTypes1.Length;
if (constraintTypes2.Length != n)
{
return false;
}
// Construct a HashSet<T> for one of the sets
// to allow O(n) comparison of the two sets.
var setTypes2 = new HashSet<TypeSymbol>();
foreach (var constraintType in constraintTypes2)
{
// Binder should have dropped any duplicates.
Debug.Assert(!setTypes2.Contains(constraintType));
setTypes2.Add(constraintType);
}
foreach (var constraintType in constraintTypes1)
{
if (!setTypes2.Contains(constraintType))
{
return false;
}
}
return true;
}
/// <summary>
/// Return a collection of bound constraint clauses indexed by type parameter
/// ordinal. All constraint clauses are bound, even if there are multiple constraints
/// for the same type parameter, or constraints for unrecognized type parameters.
/// Extra constraints are not included in the returned collection however.
/// </summary>
internal ImmutableArray<TypeParameterConstraintClause> BindTypeParameterConstraintClauses(
Symbol containingSymbol,
ImmutableArray<TypeParameterSymbol> typeParameters,
SyntaxList<TypeParameterConstraintClauseSyntax> clauses,
DiagnosticBag diagnostics)
{
Debug.Assert(this.Flags.Includes(BinderFlags.GenericConstraintsClause));
Debug.Assert((object)containingSymbol != null);
Debug.Assert((containingSymbol.Kind == SymbolKind.NamedType) || (containingSymbol.Kind == SymbolKind.Method));
Debug.Assert(typeParameters.Length > 0);
Debug.Assert(clauses.Count > 0);
int n = typeParameters.Length;
// Create a map from type parameter name to ordinal.
// No need to report duplicate names since duplicates
// are reported when the type parameters are bound.
var names = new Dictionary<string, int>(n);
foreach (var typeParameter in typeParameters)
{
var name = typeParameter.Name;
if (!names.ContainsKey(name))
{
names.Add(name, names.Count);
}
}
// An array of constraint clauses, one for each type parameter, indexed by ordinal.
var results = new TypeParameterConstraintClause[n];
// Bind each clause and add to the results.
foreach (var clause in clauses)
{
var name = clause.Name.Identifier.ValueText;
int ordinal;
if (names.TryGetValue(name, out ordinal))
{
Debug.Assert(ordinal >= 0);
Debug.Assert(ordinal < n);
var constraintClause = this.BindTypeParameterConstraints(name, clause.Constraints, diagnostics);
if (results[ordinal] == null)
{
results[ordinal] = constraintClause;
}
else
{
// "A constraint clause has already been specified for type parameter '{0}'. ..."
diagnostics.Add(ErrorCode.ERR_DuplicateConstraintClause, clause.Name.Location, name);
}
}
else
{
// Unrecognized type parameter. Don't bother binding the constraints
// (the ": I<U>" in "where U : I<U>") since that will lead to additional
// errors ("type or namespace 'U' could not be found") if the type
// parameter is referenced in the constraints.
// "'{1}' does not define type parameter '{0}'"
diagnostics.Add(ErrorCode.ERR_TyVarNotFoundInConstraint, clause.Name.Location, name, containingSymbol.ConstructedFrom());
}
}
return results.AsImmutableOrNull();
}