[patterns] Clarify when map key primitive == comes into play. (#2691)

* [patterns] Clarify when map key primitive `==` comes into play.

Fix #2690.

* Update accepted/future-releases/0546-patterns/feature-specification.md

Co-authored-by: Erik Ernst <eernst@google.com>

Co-authored-by: Erik Ernst <eernst@google.com>

Author: munificent

accepted/future-releases/0546-patterns/feature-specification.md

@@ -595,27 +595,29 @@ It is a compile-time error if:
 
 *   Any of the entry key expressions are not constant expressions.
 
-*   If any two keys in the map are identical. *Map patterns that don't have a
-    rest element only match if the `length` of the map is equal to the number of
-    map entries. If a map pattern has multiple identical key entries, they will
+*   Any two keys in the map are identical. *Map patterns that don't have a rest
+    element only match if the `length` of the map is equal to the number of map
+    entries. If a map pattern has multiple identical key entries, they will
     increase the required length for the pattern to match but in all but the
     most perverse `Map` implementations will represent the same key. Thus, it's
     very unlikely that any map pattern containing identical keys (and no rest
     element) will ever match. Duplicate keys are most likely a typo in the
     code.*
 
-*   If any two keys in the map both have primitive `==` methods, then it is a
-    compile-time error if they are equal according to their `==` operator. *In
-    cases where keys have types whose equality can be checked at compile time,
-    we report errors if there are redundant keys. But we don't require the keys
-    to have primitive equality for flexibility. In map patterns where the keys
-    don't have primitive equality, it is possible to have redundant keys and the
-    compiler won't detect it.*
+*   Any two record keys which both have primitive `==` are equal. *Since
+    records don't have defined identity, we can't use the previous rule to
+    detect identical records. But records do support an equality test known at
+    compile time if all of their fields do, so we use that.*
 
 *   There is more than one `...` element in the map pattern.
 
 *   The `...` element is not the last element in the map pattern.
 
+*Note that we don't require map keys to have primitive `==` methods to enable
+more flexibility in key types. If the keys have user-defined `==` methods, then
+it's possible to have keys that are equal according to those `==` methods, but
+the compiler won't detect it.*
+
 ### Rest elements
 
 Like lists, map patterns can also have a rest element. However, there's no
@@ -3221,6 +3223,8 @@ Here is one way it could be broken down into separate pieces:
 
 -   Clarify which variables are valid in pattern assignments.
 
+-   Clarify when primitive `==` for map pattern keys comes into play (#2690).
+
 ### 2.19
 
 -   Specify exhaustiveness checking of switch elements.