Type annotations for instruction operands are omitted, e.g.
```
%3 = struct $S(%1, %2)
```
Operand types are redundant anyway and were only used for sanity checking in the SIL parser.
But: operand types _are_ printed if the definition of the operand value was not printed yet.
This happens:
* if the block with the definition appears after the block where the operand's instruction is located
* if a block or instruction is printed in isolation, e.g. in a debugger
The old behavior can be restored with `-Xllvm -sil-print-types`.
This option is added to many existing test files which check for operand types in their check-lines.
Use the `%target-swift-5.1-abi-triple` substitution to compile the tests for
deployment to the minimum OS versions required for use of _Concurrency APIs,
instead of disabling availability checking.
All non-trivial values which correspond to `VarDecl`s must be marked
appropriately so that they can be found by the relevant checker. Here,
values with none ownership are marked.
In light of SE-338, you'd think all functions converted to
be `async` would have hops in their reabstraction thunks.
But that's not the case. A non-async function that is not
otherwise isolated according to its type, when converted
to become an async function, should not have hops in its
reabstraction thunk; not even to the generic executor.
That was not intuitive for me, so I thought I'd add
extra test coverage to ensure we maintain that existing
behavior, since we rely on it when non-async functions
have their isolation casted away when in an isolated
context (only allowed when it's not also Sendable).
Thus, when it's called later on, it needs to inherit the
executor, as its guaranteed to only be called while on
a matching one. For example:
```
@MainActor func caller() async {
let f: () -> () = mainActorFn
let g: () async -> () = f
await g() // g cannot be hopping to a different executor, it must inherit!
}
```
Repurpose mangling operator `Y` as an umbrella operator that covers new attributes on function types. Free up operators `J`, `j`, and `k`.
```
async ::= 'Ya' // 'async' annotation on function types
sendable ::= 'Yb' // @Sendable on function types
throws ::= 'K' // 'throws' annotation on function types
differentiable ::= 'Yjf' // @differentiable(_forward) on function type
differentiable ::= 'Yjr' // @differentiable(reverse) on function type
differentiable ::= 'Yjd' // @differentiable on function type
differentiable ::= 'Yjl' // @differentiable(_linear) on function type
```
Resolves rdar://76299796.
