semantics | Этот репозиторий содержит материалы , необходимые для

When in doubt, JLS will help:

If two methods of a class (whether both declared in the same class, or both inherited by a class, or one declared and one inherited) have the same name but signatures that are not override-equivalent, then the method name is said to be overloaded.

So it's not "changing the parameters", it is about not override-equivalent. To find out what that is, you go to another chapter, that says:

Two method signatures m1 and m2 are override-equivalent iff either m1 is a subsignature of m2 or m2 is a subsignature of m1.

And the same chapter explains what subsignature is:

The signature of a method m1 is a subsignature of the signature of a method m2 if either:

• m2 has the same signature as m1, or

• the signature of m1 is the same as the erasure (§4.6) of the signature of m2.

How you interpret your above methods is an exercise left to you.

Well, it's indeed not possible that declarative way since we don't have hook for injecting to the reactive type in the middle on that level.

Try to look into a TransactionalOperator and its usage from the Java DSL's fluxTransform():

If a variable is potentially read or written, it matters what order that happens in. The point of a "memory" clobber is to make sure the reads and/or writes in an asm statement happen at the right point in the program's execution.

Any read of a C variable's value that happens in the source after an asm statement must be after the memory-clobbering asm statement in the compiler-generated assembly output for the target machine, otherwise it might be reading a value before the asm statement would have changed it.

Any read of a C var in the source before an asm statement similarly must stay sequenced before, otherwise it might incorrectly read a modified value.

Similar reasoning applies to assignments to (writes of) C variables before/after any asm statement with a "memory" clobber. Just like a function call to an "opaque" function, one who's definition the compiler can't see.

No reads or writes can reorder with the barrier in either direction, therefore no operation before the barrier can reorder with any operation after the barrier, or vice versa.

Another way to look at it: the actual machine memory contents must match the C abstract machine at that point. The compiler-generated asm has to respect that, by storing any variable values from registers to memory before the start of an asm("":::"memory") statement, and afterwards it has to assume that any registers that had copies of variable values might not be up to date anymore. So they have to be reloaded if they're needed.

This reads-everything / writes-everything assumption for the "memory" clobber is what keeps the asm statement from reordering at all at compile time wrt. all accesses, even non-volatile ones. The volatile is already implicit from being an asm() statement with no "=..." output operands, and is what stops it from being optimized away entirely (and with it the memory clobber).

Note that only potentially "reachable" C variables are affected. For example, escape analysis can still let the compiler keep a local int i in a register across a "memory" clobber, as long as the asm statement itself doesn't have the address as an input.

Just like a function call: for (int i=0;i<10;i++) {foobar("%d\n", i);} can keep the loop counter in a register, and just copy it to the 2nd arg-passing register for foobar every iteration. There's no way foobar can have a reference to i because its address hasn't been stored anywhere or passed anywhere.

(This is fine for the memory barrier use-case; no other thread could have its address either.)

Related:

• How does a mutex lock and unlock functions prevents CPU reordering? - why opaque function calls work as compiler barriers.
• How can I indicate that the memory *pointed* to by an inline ASM argument may be used? - cases where a "memory" clobber is needed for a non-empty asm statement (or other dummy operands to tell the asm statement which memory is read / written.)

It's a big in peachpie compiler itself.

https://github.com/peachpiecompiler/peachpie/issues/957

You van either delete the failing code from the php script or wait for the next release of peachpie.

You do not need to take variance into account here. The reason why Record fails is simply due to the utility requiring its type parameter to have an index signature. For the same reason, the method cannot expect to get a type assignable to { [x:string]: unknown } as its only parameter.

In any case, I do not think you will be able to do that without generic type parameters. Then you simply need to check if a string-only keyed type like { [P in Extract : any } is assignable to the passed-in type (the other way around will obviously always pass as your interfaces are subtypes of the former).

Note that X extends T ? T : never in the parameter is needed for the compiler to be able to infer T from usage while still maintaining the constraint. The only caveat is that you will not be able to catch symbol properties (but will be if their type is unique symbol):

The problem I am facing comes from the fact that a pointer to an array of unknown bound is, by my understanding, illegal C++.

You're mistaken. Pointer to an array of unknown bound is not illegal in C++.

I am in fact invoking undefined behaviour. (Or, possibly, some non-standard compiler extension?)

Neither (as long as the pointer is valid). The shown function is standard conforming even if T is an array of unknown bound.

why are pointers and references to arrays of unknown bound illegal?

They aren't illegal.

_{There used to be a special case that pointers and references to arrays of unknown bound were illegal as function parameters. That was made legal in a defect resolution in 2014}

Other than the usual suspects (process.exit(), or process termination/signal, or crash/hardware failure), are there any circumstances where code in a finally block will not be reached?

If the promise will resolve or reject in future then it should reach to the final block.

According to the MDN docs,

The finally-block contains statements to execute after the try-block and catch-block(s) execute, but before the statements following the try...catch...finally-block. Note that the finally-block executes regardless of whether an exception is thrown. Also, if an exception is thrown, the statements in the finally-block execute even if no catch-block handles the exception.

A promise is just a JavaScript object. An object can have many states. A promise object can be in pending state or settled state. The state settled can divide as fulfilled and rejected. For this example just imagine we have only two state as PENDING and SETTLED.

Now if the promise never resolve or reject then it will never go to the settled state which means your then..catch..finally will never call. If nothing is reference to the promise then it will just garbage collected.

In your original question you mentioned about a 3rd party async method. If you see that code, the first thing you can see is, there are set of if(..) blocks to determine the current OS. But it does not have any else block or a default case.

What if non of the if(..) blocks are trigger ? There is nothing to execute and you already returned a promise with return new Promise(). So basically if non of the if(..) blocks are triggered, the promise will never change its state from pending to settled.

And then as @Bergi also mentioned there are some codes like this. A classic Promise constructor antipattern as he mentioned. For example see the below code,

Raku doesn't have an ordered message queue. It has an unordered list of things that needs doing.

This is Core issue 1805, which changed ?: to decay arrays and functions to pointers before testing whether the other operand can be converted to it. The example in that issue is basically the one in your question: