conform | scrubs data based on struct tags | Widget library

The problem here is fundamentally that it's possible to write C programs containing errors (not just failures to achieve strict conformance) that it is not reasonable to demand a C compiler detect. At the time the standard was originally written (1989), whole-program analysis was out of the question, and even now, it's expensive. And one will always be able to gin up constructs like

I think this is insufficient reduction as a result of the adoption of <=> in P1614. Before that paper, there were three ==s in the example:

First, the way to check a concept is just to static_assert (not to try to instantiate a constrained class template).

GCC and Clang report that S is trivially copyable in C++11 through C++23 standard modes. MSVC reports that S is not trivially copyable in C++14 through C++20 standard modes.

N3337 (~ C++11) and N4140 (~ C++14) say:

A trivially copyable class is a class that:

• has no non-trivial copy constructors,
• has no non-trivial move constructors,
• has no non-trivial copy assignment operators,
• has no non-trivial move assignment operators, and
• has a trivial destructor.

By this definition, S is trivially copyable.

N4659 (~ C++17) says:

A trivially copyable class is a class:

• where each copy constructor, move constructor, copy assignment operator, and move assignment operator is either deleted or trivial,
• that has at least one non-deleted copy constructor, move constructor, copy assignment operator, or move assignment operator, and
• that has a trivial, non-deleted destructor

By this definition, S is not trivially copyable.

N4860 (~ C++20) says:

A trivially copyable class is a class:

• that has at least one eligible copy constructor, move constructor, copy assignment operator, or move assignment operator,
• where each eligible copy constructor, move constructor, copy assignment operator, and move assignment operator is trivial, and
• that has a trivial, non-deleted destructor.

By this definition, S is not trivially copyable.

Thus, as published, S was trivally copyable in C++11 and C++14, but not in C++17 and C++20.

The change was adopted from DR 1734 in February 2016. Implementors generally treat DRs as though they apply to all prior language standards by convention. Thus, by the published standard for C++11 and C++14, S was trivially copyable, and by convention, newer compiler versions might choose to treat S as not trivially copyable in C++11 and C++14 modes. Thus, all compilers could be said to be correct for C++11 and C++14.

For C++17 and beyond, S is unambiguously not trivially copyable so GCC and Clang are incorrect. This is GCC bug #96288 and LLVM bug #39050

automatic synthesis of Equatable conformance is available for structs, and enums with associated values

This means for structs and enums that use basic value types there is no need to declare explicit conformance to Equatable since it will be provided automatically by Swift itself So

This is just an exception in the rule. It is documented here:

Exceptions

When used as a type, the Swift protocol Error conforms to itself; @objc protocols with no static requirements can also be used as types that conform to themselves.

If it weren't for this exception, you wouldn't be able to do Result or AnyPublisher to say "some result that can be any error" or "a publisher that can emit any error".

Based on the quoted passages, particularly 6.9.2p3 and the non-normative J.2p1, it seems clear that the code violates these clauses and therefore may not appear in a strictly conforming program defined in section 4p5 of the C standard:

A strictly conforming program shall use only those features of the language and library specified in this International Standard. It shall not produce output dependent on any unspecified, undefined, or implementation-defined behavior, and shall not exceed any minimum implementation limit

Implementations are however free to define extensions that would not be allowed in a strictly conforming program. A program using such extensions is a conforming program as defined in section 4p6:

The two forms of conforming implementation are hosted and freestanding. A conforming hosted implementation shall accept any strictly conforming program. [ ... details of freestanding omitted ... ] A conforming implementation may have extensions (including additional library functions), provided they do not alter the behavior of any strictly conforming program

Based on the compiler output, it appears that MSVC does not support such an extension but gcc and clang do.

Additionally, gcc correctly disables this feature when the -pedantic flag is passed, forcing strict compliance. That clang does not generate a diagnostic with -pedantic appears to be a bug.

No, macro_rules is a special "directive". You can check the compiler syntax tree here. The important part is:

All that perldelta entry is stating is that when foo() is a predefined function then, prior to 5.22, the call splat(foo) might have been interpreted by the parser as either splat(foo()) or splat('foo'), but you couldn't easily tell which. Now it will always be seen as splat(foo()).