trunk | Build , bundle & ship your Rust WASM application to the web

C++20 recognizes that there can be different spellings of the same effective requirements. So the standard defines two concepts: "equivalent" and "functionally equivalent".

True "equivalence" is based on satisfying the ODR (one-definition rule):

Two expressions involving template parameters are considered equivalent if two function definitions containing the expressions would satisfy the one-definition rule, except that the tokens used to name the template parameters may differ as long as a token used to name a template parameter in one expression is replaced by another token that names the same template parameter in the other expression.

There's more to it, but that's not an issue here.

Equivalence for template heads includes that all constraint expressions are equivalent (template headers include constraints).

Functional equivalence is (usually) about the results of expressions being equal. For template heads, two template heads that are not ODR equivalent can be functionally equivalent:

Two template-heads are functionally equivalent if they accept and are satisfied by ([temp.constr.constr]) the same set of template argument lists.

That's based in part on the validity of the constraint expressions.

Your two template heads in versions 1 and 3 are not ODR equivalent, but they are functionally equivalent, as they both accept the same template parameters. And the behavior of that code will be different from its behavior if they were ODR equivalent. Therefore, this passage kicks in:

If the validity or meaning of the program depends on whether two constructs are equivalent, and they are functionally equivalent but not equivalent, the program is ill-formed, no diagnostic required.

As such, all of the compilers are equally right because your code is wrong. Obviously a compiler shouldn't straight-up crash (and that should be submitted as a bug), but "ill-formed, no diagnostic required" often carries with it unforeseen consequences.

Because each fetch produces its own packfile and one packfile is more efficient than multiple packfiles. A lot more efficient. How?

First, the checkouts are a red herring. They don't affect the size of the .git/ directory.

Second, in the first example only the first git fetch origin does anything. The rest will fetch nothing (unless something changed on origin).

Compression works by finding common long sequences within the data and reducing them to very short sequences. If

We can see in the example below that the first packfile is 113M, the second is 161M, the third is 177M, and the final fetch is 209M. The size of the final packfile is roughly equal to the size of the single garbage compacted packfile.

git fetch is very efficient. It will only fetch objects you not already have. Sending individual object files is inefficient. A smart Git server will send them as a single packfile.

When you do a single git fetch on a fresh repository, Git asks the server for every object. The remote sends it a packfile of every object.

When you do git fetch ABC and then git fetch DEFs, Git tells the server "I already have everything up to ABC, give me all the objects up to DEF", so the server makes a new packfile of everything from ABC to DEF and sends it.

Eventually your repository will do an automatic garbage collection and repack these into a single packfile.

We can reduce the examples. I'm going to use Rails to illustrate because it has clearly defined tags to fetch.

What matters here is whether the unqualified lookup from inside std finds any other operator< (regardless of its signature!) before reaching the global namespace. That depends on what headers have been included (any standard library header may include any other), and it also depends on the language version since C++20 replaced many such operators with operator<=>. Also, occasionally such things are respecified as hidden friends that are not found by unqualified lookup. It’s obviously unwise to rely on it in any case.

For a built-in compound assignment operator $= the expression A $= B behaves identical to an expression A = A $ B, except that A is evaluated only once. All promotions and other usual arithmetic conversions and converting back to the original type still happen.

Therefore it shouldn't be expected that the warnings differ between short avg1 = sum / count; and tmp /= count;.

A conversion from int to short happens in each case. So a conversion warning would be appropriate in either case.

However, the documentation of GCC warning flags says specifically that conversions back from arithmetic on small types which are promoted is excluded from the -Wconversion flag. GCC offers the -Warith-conversion flag to include such cases nonetheless. With it all arithmetic in your examples generates a warning.

Also note that this exception to -Wconversion has been introduced only with GCC 10. For some more context on it, the bug report from which it was introduced is here.

It seems that Clang has always been more lenient on these cases than GCC. See for example this issue and this issue.

For / in GCC -fsanitize=undefined seems to break the exception that -Wconversion is supposed to have. It seems to me that this is related to the undefined behavior sanitizer adding a null-value check specifically for division. Maybe, after this transformation, the warning flag logic doesn't recognize it as direct arithmetic on the smaller type anymore.

If my understanding of the intended behavior of the warning flags is correct, I would say that this looks unintended and thus is a bug.

A response on IssueTracker says

This problem is present with Android Studio Bumblebee on Mac. Launching flutter from the IDE causes this issue where it can't find the Cocoapods path.

Forced to run flutter from terminal for it to work.

Here's how run your project from the CLI on the iOS simulator. cd into your project directory and run:

From the clang manual:

Because default argument promotion only applies to the standard floating-point types, _Float16 values are not promoted to double when passed as variadic or untyped arguments. As a consequence, some caution must be taken when using certain library facilities with _Float16; for example, there is no printf format specifier for _Float16, and (unlike float) it will not be implicitly promoted to double when passed to printf, so the programmer must explicitly cast it to double before using it with an %f or similar specifier.

It doesn't matter that i is guaranteed to be evaluated only at compile-time when its value is known in an abstract sense.

It also doesn't matter whether the function is consteval or constexpr or none of these.

The language is still statically typed and nth_type_t; must in any given instantiation of the function refer to exactly one type. If i can change in the for loop, that is not possible to guarantee.

The language requires that the expression i when used as template argument is by itself a constant expression, independently of whether the whole function body can only be evaluated as part of a larger constant expression. But i is neither declared constexpr, nor declared const with constant initializer.

Maybe I'm wrong, but it seems that last part:

As far as i experienced, the only way to disable this message is to set the config globally in the .gitconfig of the user running the gitlab-runner.

This can either be done on the underlying VM if you use the shell-runner or inside the used docker-image when using the docker-runner

Update

Altough it says global, the git-setting is user based. You'll have to set it as the same user that executes the gitlab-runner. Depending on the configuration, this might be gitlab-runner or a custom user on shell-runners or root when using the docker-executor.