Fix issue 15884 Encode wstring/wchar[]/dstring/dchar[] as JSON string

[lionello]

This fix will now encode all string types, mutable and immutble, as JSON strings:

    wchar[] wstr = "a"w.dup;
    JSONValue testValw = wstr;
    assert(testValw.type == JSON_TYPE.STRING);

https://issues.dlang.org/show_bug.cgi?id=15884

[dlang-bot]

Fix	Bugzilla	Description
✓	15884	Assigning char[] to std.json.JSONValue creates array, not string

[PetarKirov]

You need to use isSomeString, because isNarrowString would not allow dchar-based strings

[lionello]

isSomeString might not be good either: "Static arrays of characters (like char[80]) are not considered built-in string types."

[PetarKirov]

No need for .dup, .array already does a copy.

[lionello]

I know. But wouldn't work without it.

Even though the result from "array" is unique, I can't seem to make it "immutable" in safe code. Please help?

[PetarKirov]

Sorry, I didn't saw your comment. I'll try to find what the issue is.

[PetarKirov]

How about:

pure nothrow @safe
unittest // issue 15884
{
    import std.meta : AliasSeq;
    import std.traits : MutableOf, ConstOf, ImmutableOf;

    T[3] staticArr(T)() { return ['a', 's', 'd']; }
    T[] dynamicArr(T)() { return ['a', 's', 'd']; }

    foreach (Char; AliasSeq!(char, wchar, dchar))
        foreach (Qualifier; AliasSeq!(MutableOf, ConstOf, ImmutableOf))
            foreach (TestString; AliasSeq!(staticArr, dynamicArr))
            {
                // From lvalue:
                {
                    auto str = TestString!(Qualifier!Char);

                    // test construction
                    JSONValue testVal = str;
                    assert(testVal.type == JSON_TYPE.STRING);

                    // test assignment
                    testVal = str;
                    assert(testVal.type == JSON_TYPE.STRING);
                }

                // From rvalue:
                {               
                    // test construction
                    JSONValue testVal2 = TestString!(Qualifier!Char);
                    assert(testVal2.type == JSON_TYPE.STRING);

                    // test assignment
                    testVal2 = TestString!(Qualifier!Char);
                    assert(testVal2.type == JSON_TYPE.STRING);
                }
            }
}

[PetarKirov]

The above will test the following types:

char[3] char[] const(char[3]) const(char)[] immutable(char[3]) string
wchar[3] wchar[] const(wchar[3]) const(wchar)[] immutable(wchar[3]) wstring
dchar[3] dchar[] const(dchar[3]) const(dchar)[] immutable(dchar[3]) dstring

[PetarKirov]

If you want to add support for static arrays, you will need fix JSONValue.this, because otherwise the assignment from rvalue static array in the above test won't compile.

[PetarKirov]

BTW, this string type testing pattern can be further generalized:

pure nothrow @safe
unittest // issue 15884
{   
    import std.meta : AliasSeq;
    import std.traits : MutableOf, ConstOf, ImmutableOf;

    foreach (Char; AliasSeq!(char, wchar, dchar))
        foreach (Qualifier; AliasSeq!(MutableOf, ConstOf, ImmutableOf))
            foreach (testStr; TestString!(Qualifier!Char).strings)
            {
                // test construction
                JSONValue testVal = testStr();
                assert(testVal.type == JSON_TYPE.STRING);                   

                // test assignment
                testVal = testStr();
                assert(testVal.type == JSON_TYPE.STRING);
            }
}

version (unittest)
private struct TestString(T)
{
    import std.typecons : tuple;
    enum strings = tuple(&this.init.staticArrLvl, &this.init.dynamicArrLvl,
                         &this.init.staticArrRvl, &this.init.dynamicArrRvl);

    pure nothrow @safe @nogc:

    T[3] s = ['a', 's', 'd'];
    T[] d = ['a', 's', 'd'];
    ref T[3] staticArrLvl()  { return s; }
    ref T[]  dynamicArrLvl() { return d; }
        T[3] staticArrRvl()  { return s; }
        T[]  dynamicArrRvl() { return d; }
}

[lionello]

For now, I've considered static arrays out of scope for bug 15884 so let's just get the simple cases done. It's easy to convert a static (or any) array to a dynamic one by just adding a pair of [].

[lionello]

@DmitryOlshansky I saw you had merged PR#4176 from @bbasile before. This is an extension of that. Please check.

[DmitryOlshansky]

LGTM

[DmitryOlshansky]

Auto-merge toggled on