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