Re: [Json] The names within an object SHOULD be unique.

[Nico Williams <[e-mail]>]

On Mon, Jun 10, 2013 at 12:08 PM, Stephen Dolan
<[e-mail]> wrote:
> On Mon, Jun 10, 2013 at 6:01 PM, Paul Hoffman <[e-mail]> wrote:
>> <no hat>
>>
>> On Jun 10, 2013, at 9:55 AM, Stephen Dolan <[e-mail]> wrote:
>>
>>> The issue is, that currently there exists a JSON document which one
>>> RFC-conforming correct JSON parser can say is indistinguishable from
>>> {a: true}, and another equally RFC-conforming correct JSON parser can
>>> say is indistinguishable from {a: false}.
>>>
>>> While my example might not have been great, this still seems easily
>>> exploitable: two parsers parsing a supposedly standard format can be
>>> tricked into seeing completely different results from the same input.
>>> Surely it would be better if we could say that one of those parsers
>>> was not RFC-conforming?
>>
>> Stated that narrowly, yes. But given your first paragraph, the comparison might be
>> more fully stated as "would it be better if we could says that one of these parsers was
>> not RFC-conforming if making such a statement caused what was a stored valid
>> JSON text now non-valid".
>
> I don't propose making any stored valid JSON text become non-valid.
> {a: true, a: false} is currently a valid JSON text, and it should
> remain so or things would break.
>
> Some JSON parsers consider that document distinguishable from {a:
> false} (e.g. streaming parsers that return all key/value pairs). Most
> of them don't.
>
> I propose that it be invalid to consider that document
> indistinguishable from {a: true}. Parsers are free to accept or reject
> it, and if they accept it they are free to return either one or two
> "a" entries, but if they only return one it must be {a: false}.

More briefly: {"a": true, "a": false} MAY be indistinguishable from
either {"a": true, "a": false} or from {"a": false}, but MUST NOT be
indistinguishable from {"a": true}.

That would allow a streaming parser application like this:

while ((name, value) = parser.nextPair()) {
    doCommand(name, value);
}

But not one like this, which I doubt anyone will argue should be allowed:

while ((name, value) = parser.nextPair()) {
    if (hash[name])
        continue;
    hash[name] = value;
    doCommand(name, value);
}

But what about this:

while ((name, value) = parser.nextPair()) {
    if (hash[name])
        throw "duplicate names!";
    hash[name] = value;
    doCommand(name, value);
}

Here {"a": true, "a": false} would be distinguished from {"a": true}
only by the error thrown, but the doCommand("a", true) action will
have run.  Is this invalidated by your construction?  I think it's
not, and one could make a reasonable argument that it should not be.
(In particular {"a": true, "a": false, "b": null} would be equivalent
to {"a": true} + an exception in this last case, but it would be
distinct from {"a": true, "b": null}.)

+1 from me.