fiasco | Fiasco -

web-console gem was breaking with Rails 6.1, an upgrade to 4.1.0 fixed the error.

Confirmed clang-tidy bug, https://bugs.llvm.org/show_bug.cgi?id=47511 . I'll leave the question as it is, perhaps someone will find the boost trick useful until it's fixed.

The problem is that it is not constant initialized. This means that M_INFO_COLLECTION may be zero-initialized and then dynamically initialized at run time.

Your code generates assembley to set M_INFO_COLLECTION dynamically because of the "global constructor" (non-constant initialization): https://godbolt.org/z/45x6q6

An example where this leads to unexpected behaviour:

Here is one with, IIUC.

Can C++20 constinit waive the need for nifty counter idiom?

No.

Static initialisation order fiasco is only a problem with dynamic initialisation phase of static objects. Sure, if you don't do dynamic initialisation, then there is no problem, and constinit enforces that. But that doesn't solve anything when you need dynamic initialisation.

You have inadvertently created a namespace package due to your sys.path setting. Namespace packages are directories without an __init__.py in the Python search path and allow loading of submodules or -packages from different paths (e.g. path1/foo/a.py and path2/foo/b.py can be imported as foo.a and foo.b).

The problem is that import fiasco finds /Users/shirman/fiasco first and imports it as a namespace package. If you set sys.path such that /Users/shirman/fiasco comes before /Users/shirman, the importer finds the actual package /Users/shirman/fiasco/fiasco first.

Namespace packages are a Python 3.3 feature, so either the other machine had a different sys.path setting, a really old Python 3 installation, or you were using Python 2.

Static initialization in C does not have the same problems that C++ has.

In C, objects with static storage duration may only be initialized via constant expressions, i.e. values that can be computed at compile time, so there are no issues that can arise regarding order of initialization.

In contrast, C++ allows calling functions to initialize static objects, and the order in which those functions are called are not well-defined.

The usual way is to have functions returning local statics by reference.

Function-local statics

• have static "lifetime" (storage duration) but will only be initialized on first use (dodging the fiasco)
• since C++11 you can even rely on initialization to be thread-safe

So, you might have in the header:

The code unfortunately has unspecified behavior. The reason is similar to, if not the usual definition of, the Static Initialization Order Fiasco.

The object std::cout and other similar objects declared in may not be used before the first object of type std::ios_base::Init is initialized. Including defines (or acts as though it defines) a non-local object of that type with static storage duration ([iostream.objects.overview]/3). This takes care of the requirement in most cases, even when std::cout and friends are used during dynamic initialization, since that Init definition will normally be earlier in the translation unit than any other non-local static storage object definition.

However, [basic.start.dynamic]/1 says

Dynamic initialization of a non-local variable with static storage duration is unordered if the variable is an implicitly or explicitly instantiated specialization, ....

So although the initialization of the std::ios_base::Init object (effectively) defined in is ordered, the initialization of A::i is unordered, and therefore the two initializations are indeterminately sequenced. So we can't count on this code working.

As @walnut mentioned in a comment, the code can be corrected by forcing another std::ios_base::Init object to be initialized during dynamic initialization of A::i before the use of std::cout: