std.getopt test cases:

1) Passing and "just" triggering deprecation warnings


---
@system unittest
{
    shared real v;
    shared uint i;
    shared string[] arrString;
    shared int[] arrInt;

    auto args = ["program.name",
        "-v=2",
        "-i=10",
        "--arrString=a", "--arrString=b",
        "--arrInt=1", "--arrInt=2",
    ];
    getopt(args,
        "v", &v,
        "i", &i,
        "arrString", &arrString,
        "arrInt", &arrInt,
    );
    assert(v == 2);
    assert(i == 10);

    shared expectedArrString = ["a", "b"];
    assert(arrString == expectedArrString);
    shared expectedArrInt = [1, 2];
    assert(arrInt == expectedArrInt);
}
---

2) Completely failing

---
@system unittest
{
    shared string s;
    shared bool b;
    shared string[string] assocArrayString;
    shared double[string] assocArrayDouble;

    auto args = ["program.name",
        "-s=bar",
        "-b",
        "--assocArrayString=foo=bar,bar=1",
        "--assocArrayDouble=foo=1,bar=2",
    ];
    getopt(args,
        "s", &s,
        "b", &b,
        "assocArrayString", &assocArrayString,
        "assocArrayDouble", &assocArrayDouble,
    );

    assert(s == "bar");
    assert(b == 1);

    shared expectedAssocArrayString = ["foo": "bar", "bar": "1"];
    assert(assocArrayString == expectedAssocArrayString);
    shared expectedAssocArrayDouble = ["foo":1.0, "bar": 2];
    assert(assocArrayDouble == expectedAssocArrayDouble);
}
---

All of these examples should *never* compile. The whole point of `shared` is to statically disallow accidental access shared mutable state. > 90% of all functions in phobos have no business touching `shared`/`__gshared` variables, especially `std.getopt`.

`std.getopt` can be safely used to set:
* function local variables
* (static) thread-local variables
* immutable global variables from shared static constructors (not sure if this currently works, but it should be ok from memory model perspective)

I consider everything else to potentially trigger undefined behavior.

>  immutable global variables from shared static constructors (not sure if this currently works, but it should be ok from memory model perspective)

No this doesn't work at the moment.


For future readers: it has been used by people before (https://github.com/vibe-d/vibe.d/pull/2060).

THIS ISSUE HAS BEEN MOVED TO GITHUB

https://github.com/dlang/dmd/issues/19379

DO NOT COMMENT HERE ANYMORE, NOBODY WILL SEE IT, THIS ISSUE HAS BEEN MOVED TO GITHUB