Apply suggestions from code review

Author: Nigel-Ecma

standard/classes.md

@@ -2748,7 +2748,9 @@ A compile-time error occurs unless all of the following are true for an override
 - The overridden base method is not a sealed method.
 - There is an identity conversion between the return type of the overridden base method and the override method.
 - The override declaration and the overridden base method have the same declared accessibility. In other words, an override declaration cannot change the accessibility of the virtual method. However, if the overridden base method is protected internal and it is declared in a different assembly than the assembly containing the override declaration then the override declaration’s declared accessibility shall be protected.
-- If any *type_parameter_constraints_clause*s are present, each of their *type_parameter_constraints* shall be `class` or `struct`, and for the constraint `class` in the override shall correspond to a type parameter in the base method that is known to be a non-nullable reference type. Any type parameter that has the `struct` constraint in the override shall correspond to a type parameter in the base method that is known to be a non-nullable value type. In the absence of *type_parameter_constraints_clause*s, the constraints are inherited from the overridden base method, and for the constraint `struct` a parameter type `T?` is interpreted as `System.Nullable<T>`. Constraints that are type parameters in the overridden method may be replaced by type arguments in the inherited constraint. This can lead to constraints that are not valid when explicitly specified, such as value types or sealed types.
+- A *type_parameter_constraints_clause* may only consist of the `class` or `struct` *primary_constraint*s applied to *type_parameter*s which are known according to the inherited constraints to be either reference or value types respectively. Any type of the form `T?` in the overriding method’s signature, where `T` is a type parameter, is interpreted as follows:
+  - If a `class` constraint is added for type parameter `T` then `T?` is a nullable reference type; otherwise
+  - If either there is no added constraint, or a `struct` is added, for the type parameter `T` then `T?` is a nullable value type.
 
 > *Example*: The following demonstrates how the overriding rules work for generic classes:
 >

standard/interfaces.md

@@ -659,7 +659,11 @@ It is not possible to access an explicit interface member implementation through
 
 It is a compile-time error for an explicit interface member implementation to include any modifiers ([§15.6](classes.md#156-methods)) other than `extern` or `async`.
 
-If *type_parameter_constraints_clause*s are present in an explicit interface method implementation, each of their *type_parameter_constraints* shall be `class` or `struct`, and for the constraint `class` in the implementation shall correspond to a type parameter in the interface method that is known to be a non-nullable reference type. Any type parameter that has the `struct` constraint in the implementation shall correspond to a type parameter in the interface method that is known to be a non-nullable value type. In the absence of *type_parameter_constraints_clause*s, the constraints for an explicit interface method implementation are inherited from the interface method, and for the constraint `struct` a parameter type `T?` is interpreted as `System.Nullable<T>`.
+An explicit interface method implementation inherits any type parameter constraints from the interface.
+
+A *type_parameter_constraints_clause* on an explicit interface method implementation may only consist of the `class` or `struct` *primary_constraint*s applied to *type_parameter*s which are known according to the inherited constraints to be either reference or value types respectively. Any type of the form `T?` in the signature of the explicit interface method implementation, where `T` is a type parameter, is interpreted as follows:
+  - If a `class` constraint is added for type parameter `T` then `T?` is a nullable reference type; otherwise
+  - If either there is no added constraint, or a `struct` is added, for the type parameter `T` then `T?` is a nullable value type.
 
 > *Example*: The following demonstrates how the rules work when type parameters are involved:
 >