ProMotion | RubyMotion gem that makes iPhone development

It is because this is a signed 8-bit integer. When the value exceeds the max it overflows into the negative numbers. It is not promotion but overflow behavior you are seeing.

To verify:

Your question raises an important issue in C programming and in programming in general: does the program behave as expected in all cases?

The expression (brightness * maxval) / 100 computes an intermediary value brightness * maxval that may exceed the range of the type used to compute it. In Python and some other languages, this is not an issue because integers do not have a restricted range, but in C, C++, java, javascript and many other languages, integer types have a fixed number of bits so the multiplication can exceed this range.

It is the programmer's responsibility to ascertain that the range of the operands ensures that the multiplication does not overflow. This requires a good understanding of the integer promotion and conversion rules, which vary from one language to another and are somewhat tricky in C, especially with operands mixing signed and unsigned types.

In your particular case, both brightness and maxval have a type smaller than int so they are promoted to int with the same value and the multiplication produces an int value. If brightness is a percentage in the range 0 to 100, the result is in the range 0 to 25500, which the C Standard guarantees to be in the range of type int, and dividing this number by 100 produces a value in the range 0 to 100, in the range of int, and also in the range of the destination type uint8_t, so the operation is fully defined.

Whether this process should be documented in a comment or verified with debugging assertions is a matter of local coding rules. Changing the order of the operands to maxval * brightness / 100 and possibly using more explicit values and variable names might help the reader:

Type families have an arity, which is the number of arguments it may "pattern-match" on, and it is specified by putting those arguments to the left of :: in its declaration.

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.

You are using a wrong locator. It brings you a lot of irrelevant elements.
Instead of find_elements_by_class_name('thumb-img') please try find_elements_by_css_selector('.collections-page .thumb-img') so your code will be

You can find what you are asking in the documentation here (version select on the left):
https://spatie.be/docs/laravel-permission/v5/basic-usage/blade-directives

Change your HTML code, works for me:

Luckily, I was able to find the problem just right now with some inspiration from this Post here: TypeError: circular structure to JSON starting at object with constructor 'ClientRequest' property 'socket' -> object with constructor 'Socket'

In the function for requesting the sw6 access token (shopwareAuth.getToken), which I had already adapted from the old salesforce token request function, I made use of the complete response from the OAuth2 query response which was wrong as only the res.data part was needed.

GCC and Clang are correct. The implicit conversion sequences (user-defined conversion sequences) are indistinguishable.

[over.ics.rank]/3:

(emphasis mine)

Two implicit conversion sequences of the same form are indistinguishable conversion sequences unless one of the following rules applies:

...

(3.3) User-defined conversion sequence U1 is a better conversion sequence than another user-defined conversion sequence U2 if they contain the same user-defined conversion function or constructor or they initialize the same class in an aggregate initialization and in either case the second standard conversion sequence of U1 is better than the second standard conversion sequence of U2.

The user-defined conversion sequences involves two different user-defined conversion functions (operator double() and operator long long int()), so compilers can't select one; the 2nd standard conversion sequence won't be considered.