…ch with a 'reasync' function

This fixes a performance regression with the reasync '&&', '||' and '??'
operators.

Also arguably it makes sense anyway since 'reasync' functions can in
fact be called from synchronous functions, so the solution should not
be considered worse.

We don't actually want to be able to overload a synchronous function
with a 'reasync' function anyway; the whole point of 'reasync' is to
avoid the need for such overloading.

Fixes rdar://problem/76254445.

One last usage of getOldType() remains here, but it's actually
meaningful since we want to handle InOutType there, so it will
take more work to eliminate.

…ilability-checking`.

This isn't an officially supported configuration, but is useful for testing and runtime development,
and we shouldn't crash.

The actual fix is to perform qualified lookup on a TypeExpr in `collectPossibleCalleesForApply`.

This changes the behaviour of some test cases in `complete_multiple_trailingclosure.swift`, which now provide argument labels. To make the choices suggested less verbose, I refined the parameter matching to only match trailing closures to parameters of function types.

In `INIT_FALLBACK_1` we technically shouldn't be suggesting `arg3` based on the matched argument types (the closure returns `Int` and the constructor with `arg3` requires the closure to return `String`), but AFAICT we aren't doing type-checking at this stage, so there's no way to rule it out.

…ken in case stmt

The last token in a case stmt can be a string literal token, which can *contain* its interpolation segments. If one of these interpolation segments is the reference point, we'd return false from `isReferencePointInRange` because the string literal token's start location is before the interpolation token. To fix this, adjust the range we are checking to range until the end of the string interpolation token.

Fixes rdar://76330416 [SR-14455]

Due to apple#36552, parsing the code completion token as a type inside a generic parameter list no longer fails. Instead, it consumes the code completion token as a type identifier. However, since `parseExprIdentifer` does not return a `ParserStatus`, the information whether a code completion token was consumed gets lost, causing `setCodeCompletionDelayedDeclState` to not be called and thus no code completion results show up.

To resolve this, make `parseExprIdentifier` return its `ParserStatus` through a `ParserResult`.

Fixes rdar://76335452 [SR-14432]

Otherwise, the runtime needs to be able to adjust the instance size when nonfragile ObjC bases
and/or resilient Swift bases are accounted for. rdar://54089488

rdar://70959417

Through various means, it is possible for a synchronous actor-isolated
function to escape to another concurrency domain and be called from
outside the actor. The problem existed previously, but has become far
easier to trigger now that `@escaping` closures and local functions
can be actor-isolated.

Introduce runtime detection of such data races, where a synchronous
actor-isolated function ends up being called from the wrong executor.
Do this by emitting an executor check in actor-isolated synchronous
functions, where we query the executor in thread-local storage and
ensure that it is what we expect. If it isn't, the runtime complains.
The runtime's complaints can be controlled with the environment
variable `SWIFT_UNEXPECTED_EXECUTOR_LOG_LEVEL`:

  0 - disable checking
  1 - warn when a data race is detected
  2 - error and abort when a data race is detected

At an implementation level, this introduces a new concurrency runtime
entry point `_checkExpectedExecutor` that checks the given executor
(on which the function should always have been called) against the
executor on which is called (which is in thread-local storage). There
is a special carve-out here for `@MainActor` code, where we check
against the OS's notion of "main thread" as well, so that `@MainActor`
code can be called via (e.g.) the Dispatch library's
`DispatchQueue.main.async`.

The new SIL instruction `extract_executor` performs the lowering of an
actor down to its executor, which is implicit in the `hop_to_executor`
instruction. Extend the LowerHopToExecutor pass to perform said
lowering.

…deploy.

rdar://76564535

… fix for placeholders

If left-hand side of a conversion that requires l-value is a placeholder type,
let's fix that by propagating placeholder to the order side (to allow it to
infer a placeholder if needed) without recording a fix since placeholder can
be converted to `inout` and/or l-value and already indicates existence of a
problem at some other spot in the expression.

Resolves: rdar://76250381

An actor's deinit can be invoked from any thread, and does not
(cannot!) synchronize to the actor. However, because "self" is
by definition unique and cannot escape, don't perform data race
checking in it or any local functions/closures within the initializer.

This is an imperfect approximation, because one could introduce a data
race by invoking a concurrent algorithm on "self" that does not
escape the closure but subverts @sendable checking and concurrently
accesses actor state. However, for the moment we accept this false
negative because the false positives from performing this checking are
much more prevalent.

Since 865e80f we are keeping track of internal closure labels in the closure’s type. With this change, wer are also serializing them to the swiftmodules.

Furthermore, this change adjusts the printing behaviour to print the parameter labels in the swiftinterfaces.

Resolves rdar://63633158

…ons."

... with a fix for a non-assert build crash: I used the wrong ilist type for SlabList. This does not explain the crash, though. What I think happened here is that llvm miscompiled and put the llvm_unreachable from the Slab's deleteNode function unconditionally into the SILModule destructor.
Now by using simple_ilist, there is no need for a deleteNode at all.

…ations

rdar://76567524
rdar://76567105

[Test] Disable tests that require new libswiftCore features for back deploy.

…-compat-hook

Compatibility50: Use __dso_handle for cheaper main executable check.

…ss-layout-fixed

IRGen: ObjC rodata can only go in __objc_const if layout is fixed.

rdar://76540446

…k_arm64_macos

This test currently fails on macos arm64

…cking-assertion-failure

SILGen: Don't crash when compiling `if #available` with `-disable-availability-checking`.

Reinstate "SIL: add a StackList data structure with zero cost operations."

…n-switch-case

[CodeComplete] Fix issue with completion in string literal as last token in case stmt

…sure-name

[Serialization] Serialize internal closure labels

[CodeComplete] Fix issue completing type in generic signature

…ructor

[CodeComplete] Complete argument labels in generic initializer

Sema: Don't score a solution higher if there's a sync-vs-async mismatch with a 'reasync' function

…ck_deployment_runtime

…zon Linux 2

Thsi diagnostic currently emits, for example:
```
could not find module Foo for target arm64; found: x86_64
```
It is sometimes very useful to know where exactly the `found` module is located, so this PR changes this diagnostic to emit:
```
could not find module Foo for target arm64; found: x86_64, at:
<Path where Foo.swiftmodule/x86_64.swiftmodule is located>
```

Since 9ba892c we always transform `CurrentType` in `ASTPrinter` to be an interface type.

This causes issues for variables that whose type is a protocol. Previously, when printing the type, we had `CurrentType` set to an `OpenedArchetypeType`. Now we replace the archetype by a `GenericTypeParamType`, which may not have members, so we are hitting an assertion in `ASTPrinter.cpp:270`.
To resolve this, replace any `OpenedArchetypeType`s with their protocol type before calling `mapTypeOutOfContext`.

Resolves rdar://76580851 [SR-14479]

…iginal type

AbstractionPattern::matchesTuple() is used by various assertions, and
the condition was too strict. Relax the condition to fix an assertion
failure in the case where an opaque result type has a tuple as its
underlying type.

Fixes https://bugs.swift.org/browse/SR-14426 / rdar://problem/76057095.

[ConstraintSystem] Allow fixing r-value -> l-value mismatch without a…

…th-tuple

SIL: A tuple type can be lowered with an opaque result type as the original type

…brace-stmt-assert

AST: Remove obsolete commented-out assertion in BraceStmt::create()

…r-isolation

[Concurrency] Introduce runtime detection of data races.

rdar://76566029

rdar://76566242

rdar://76566598

…oyment_runtime.

rdar://76566897

…time.

rdar://76567375

rdar://76567759

rdar://76568032

…esents an operator

…imulator-x86_64.

rdar://76611676

rdar://76080265

The test crashes in both the VS2017 and VS2019 CI machines.

See https://bugs.swift.org/browse/SR-14333 for more of these problems.

…ment_runtime

…lability

Fix iOS availability

[TypeChecker] NFC: Adjust "fast" test-case message to accommodate Ama…

spawnUnlessCancelled is not an asynchronous function, so awaiting on it
in the standard library resulted in warnings.

… closure body is empty to avoid invalid inlet code

[NFC] [ Docs] Fix the missing title underbar

[NFC][Concurrency] Remove await from spawnUnlessCancelled

…alizer.

... instead of a GlobalAddrInst.
This is cleaner and makes the handling of forward-referenced values in the deserializer a bit simpler.

… getter functions.

Instead, put the archetype->instrution map into SIlModule.

SILOpenedArchetypesTracker tried to maintain and reconstruct the mapping locally, e.g. during a use of SILBuilder.
Having a "global" map in SILModule makes the whole logic _much_ simpler.

I'm wondering why we didn't do this in the first place.

This requires that opened archetypes must be unique in a module - which makes sense. This was the case anyway, except for keypath accessors (which I fixed in the previous commit) and in some sil test files.

[Gardening] Extract basic source info structs from RawComment.h

SIL: remove the SILOpenedArchetypesTracker

[Sema] Adding a space in closure parameter destructuring fix in cases closure body is empty

Add missing `REQUIRES: concurrency`

…ync_task_yield

[windows][test] Unsupport async_task_yield in OS=windows-msvc

…ceProducer`

…atorDisjunction`

…y-tests-linux

[Test] Disable failing concurrency tests on Linux.

[Test] Disabled Interpreter/SDK/cf_without_foundation.swift on watchos.

…y some code.

We have for a long time talked about creating a scope like data structure for
use in the SILOptimizer. The discussion was whether or not to reuse the
infrastructure in SILGen that does this already. There were concerns about doing
so since the code in the SILOptimizer and SILGen can work differently.

With that in mind, I added a small AssertingScope class and built on top of that
a composition SIL level class called SILOptScope that one can use to add various
cleanups. One is able to both destructively pop at end of scope and pop along
early exits.

At an implementation level, I kept it simple and:

1. Represented a scope as a stack of Optional<Cleanup> which are just a wrapper
   around a std::function. The Optional is so that we can invalidate a cleanup.
2. Based all of these scopes around the idea that the user of the scope must
   invalidate the scope by hand. If not, the scope object will assert at the end
   of its RAII scope.
3. Rather than creating a whole class hierarchy, I just used std::function
   closures to keep things simple.

…nicalizeInstruction into OwnershipOptUtils.

This API is useful when writing compiler code that needs to handle ossa/non-ossa
as well as load_borrow/load while in OSSA. I am going to use this in
SILMem2Reg.

…forms

[Tests] NFC: Disable concurrency data race detection test on all plat…

Add location to the `sema_no_import_target` diagnostic

Per @xedin, it's fine to leave this test disabled here.

While ModuleDecl::lookupConformance() did the right thing here, we have
another entry point, TypeChecker::containsProtocol(), that also needs
to special-case Error.

Fixes https://bugs.swift.org/browse/SR-13734 / rdar://problem/70338670.

…entification-logic

[ConstraintSystem] NFC: Factor operator overload identification and partitioning.

…ype_checker_perf/fast/rdar26564101.swift

…5c892eb164aec334530

[ownership] Refactor out the composition type LoadOperation from CanonicalizeInstruction into OwnershipOptUtils.

…atype

Sema: Handle Error self-conformance in TypeChecker::containsProtocol()

…77bc7eef73664feef8a

[sil-mem2reg] Add a simple scope data structure and use it to simplify some code.

[ASTPrinter] Don't transform type if current type can't have members

…04-15