Specify open dictionaries.

index.bs

@@ -106,6 +106,10 @@ urlPrefix: https://tc39.github.io/ecma262/; spec: ECMA-262
         text: Set; url: sec-set-o-p-v-throw
         text: IsConstructor; url: sec-isconstructor
         text: Construct; url: sec-construct
+        text: own property; url: sec-own-property
+        text: enumerable; url: sec-property-attributes
+        text: HasOwnProperty; url: sec-hasownproperty
+        text: EnumerableOwnProperties; url: sec-enumerableownproperties
         text: DefinePropertyOrThrow; url: sec-definepropertyorthrow
         url: sec-code-realms
             text: Realm
@@ -120,6 +124,7 @@ urlPrefix: https://tc39.github.io/ecma262/; spec: ECMA-262
         text: ECMA-262 section 9.1.8; url: sec-ordinary-object-internal-methods-and-internal-slots-get-p-receiver
         text: ECMA-262 section 19.2.2.3; url: sec-function-@@create
         text: ECMA-262 section 19.2.3.8; url: sec-function.prototype-@@hasinstance
+        text: List; url: sec-list-and-record-specification-type
         text: Array methods; url: sec-properties-of-the-array-prototype-object
         text: typed arrays; url: sec-typedarray-objects
         text: GetMethod; url: sec-getmethod
@@ -5171,6 +5176,7 @@ type.
         "DOMException" Null
         BufferRelatedType Null
         "FrozenArray" "<" Type ">" Null
+        OpenDictionaryType Null
 </pre>
 
 <div data-fill-with="grammar-ConstType"></div>
@@ -5219,6 +5225,17 @@ type.
         "Promise" "&lt;" ReturnType "&gt;"
 </pre>
 
+<pre class="grammar" id="prod-OpenDictionaryType">
+    OpenDictionaryType :
+        "OpenDictionary" "&lt;" Type OpenDictionaryTypeMaybeValue
+</pre>
+
+<pre class="grammar" id="prod-OpenDictionaryTypeMaybeValue">
+    OpenDictionaryTypeMaybeValue :
+        "&gt;"
+        "," Type "&gt;"
+</pre>
+
 <pre class="grammar" id="prod-Null">
     Null :
         "?"
@@ -5737,6 +5754,35 @@ is the concatenation of the type name for |T| and
 the string “Sequence”.
 
 
+<h4 id="idl-open-dictionary" dictionary lt="OpenDictionary">Open dictionary types — OpenDictionary&lt;[|K|,] |V|&gt;</h4>
+
+An <dfn export>open dictionary type</dfn> is a parameterized [=dictionary type=]
+whose values are ordered associative arrays mapping instances of |K| to
+instances of |V|. The (key, value) pairs are called
+<dfn for="OpenDictionary">mappings</dfn>.
+The order of an open dictionary's mappings is determined when the open
+dictionary value is created.
+
+|K| must be one of {{DOMString}}, {{USVString}}, or {{ByteString}}. In a type
+name of the form <code>OpenDictionary&lt;|V|></code>, which omits |K|, |K| defaults
+to {{DOMString}}.
+
+Open dictionaries are always passed by value. In language bindings where an open
+dictionary is represented by an object of some kind, passing an open dictionary
+to a [=platform object=] will not result in a reference to the open dictionary
+being kept by that object. Similarly, any open dictionary returned from a
+platform object will be a copy and modifications made to it will not be visible
+to the platform object.
+
+There is no way to represent a constant open dictionary value in IDL.
+
+Open dictionaries must not be used as the type of an [=attribute=] or
+[=constant=].
+
+The [=type name=] of an open dictionary type is the concatenation of the type
+name for |K|, the type name for |V| and the string “OpenDictionary”.
+
+
 <h4 oldids="dom-promise" id="idl-promise" interface lt="Promise|Promise&lt;T&gt;">Promise types — Promise&lt;|T|&gt;</h4>
 
 A <dfn id="dfn-promise-type" export>promise type</dfn> is a parameterized type
@@ -7529,6 +7575,95 @@ iterable |iterable| and an iterator getter
 </div>
 
 
+<h4 id="es-open-dictionary">Open dictionaries — OpenDictionary&lt;[|K|,] |V|&gt;</h4>
+
+IDL {{OpenDictionary}}&lt;|K|, |V|&gt; values are represented by
+ECMAScript <emu-val>Object</emu-val> values.
+
+<p id="es-to-open-dictionary">
+    An ECMAScript value |O| is [=converted to an IDL value|converted=] to an IDL <code>{{OpenDictionary}}<|K|, |V|></code> value as follows:
+</p>
+
+<ol class="algorithm">
+    1.  Let |result| be a new empty instance of <code>{{OpenDictionary}}<|K|, |V|></code>.
+    1.  If [=Type=](|O|) is <emu-val>Undefined</emu-val> or <emu-val>Null</emu-val>,
+        return |result|.
+    1.  If [=Type=](|O|) is not <emu-val>Object</emu-val>,
+        <a lt="es throw">throw a <emu-val>TypeError</emu-val></a>.
+    1.  Let |keys| be [=?=] [=EnumerableOwnProperties=](|O|, "key").
+    1.  Repeat, for each element |key| of |keys| in [=List=] order:
+        1.  If [=!=] [=HasOwnProperty=](|O|, |key|) is <code>true</code>, then:
+            1.  Let |typedKey| be |key| [=converted to an IDL value=] of type |K|.
+            1.  Let |value| be [=?=] [=Get=](|O|, |key|).
+            1.  Let |typedValue| be |value| [=converted to an IDL value=] of type |V|.
+            1.  Assert: |typedKey| is not yet a key in |result|.
+            1.  Append to |result| a mapping from |typedKey| to |typedValue|.
+    1.  Return |result|.
+</ol>
+
+<p id="open-dictionary-to-es">
+    An IDL <code>{{OpenDictionary}}<…></code> value |D| is [=converted to an
+    ECMAScript value|converted=] to an ECMAScript value as follows:
+</p>
+
+<ol class="algorithm">
+    1.  Let |result| be [=!=] [=ObjectCreate=]([=%ObjectPrototype%=]).
+    1.  Repeat, for each [=OpenDictionary/mapping=] (|key|, |value|) in |D|:
+        1.  Let |esKey| be |key| [=converted to an ECMAScript value=].
+        1.  Let |esValue| be |value| [=converted to an ECMAScript value=].
+        1.  Let |created| be [=!=] [=CreateDataProperty=](|result|, |esKey|, |esValue|).
+        1.  Assert: |created| is <code>true</code>.
+    1.  Return |result|.
+</ol>
+
+<div class="example" id="example-es-open-dictionary">
+    Passing the ECMAScript value <code>{b: 3, a: 4}</code> to a
+    <code>{{OpenDictionary}}&lt;DOMString, double></code> argument
+    would result in the IDL value <code>[ "b" ⇒ 3, "a" ⇒ 4 ]</code>.
+
+    Open dictionaries only consider [=own property|own=] [=enumerable=] properties, so given an IDL operation
+    <code>OpenDictionary&lt;double> identity(OpenDictionary&lt;double> arg)</code> which
+    returns its argument, the following code passes its assertions:
+
+    <pre highlight="js">
+        let proto = {a: 3, b: 4};
+        let obj = {__proto__: proto, d: 5, c: 6}
+        Object.defineProperty(obj, "e", {value: 7, enumerable: false});
+        let result = identity(obj);
+        console.assert(result.a === undefined);
+        console.assert(result.b === undefined);
+        console.assert(result.e === undefined);
+        let entries = Object.entries(result);
+        console.assert(entries[0][0] === "d");
+        console.assert(entries[0][1] === 5);
+        console.assert(entries[1][0] === "c");
+        console.assert(entries[1][1] === 6);
+    </pre>
+
+    Open dictionary keys and values can be constrained, although keys can only be
+    constrained among the three string types.
+    The following conversions have the described results:
+    <table class="data">
+        <thead><th>Value</th><th>Passed to type</th><th>Result</th></thead>
+        <tr>
+            <td><code>{"😞": 1}</code></td>
+            <td><code>{{OpenDictionary}}&lt;ByteString, double></code></td>
+            <td><emu-val>TypeError</emu-val></td>
+        </tr>
+        <tr>
+            <td><code>{"\uD83D": 1}</code></td>
+            <td><code>{{OpenDictionary}}&lt;USVString, double></code></td>
+            <td>[ "\uFFFD" ⇒ 1 ]</td>
+        </tr>
+        <tr>
+            <td><code>{"\uD83D": {hello: "world"}}</code></td>
+            <td><code>{{OpenDictionary}}&lt;DOMString, double></code></td>
+            <td>[ "\uD83D" ⇒ 0 ]</td>
+        </tr>
+    </table>
+</div>
+
+
 <h4 id="es-promise">Promise types — Promise&lt;|T|&gt;</h4>
 
 IDL [=promise type=] values are