Merge pull request #2370 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

CMakeLists.txt

@@ -610,8 +610,12 @@ if(SWIFT_HOST_VARIANT_ARCH)
 else()
   if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")
     set(SWIFT_HOST_VARIANT_ARCH_default "x86_64")
-  elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|ARM64")
-    set(SWIFT_HOST_VARIANT_ARCH_default "aarch64")
+  elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|ARM64|arm64")
+    if(SWIFT_HOST_VARIANT_SDK_default STREQUAL OSX)
+      set(SWIFT_HOST_VARIANT_ARCH_default "arm64")
+    else()
+      set(SWIFT_HOST_VARIANT_ARCH_default "aarch64")
+    endif()
   elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "ppc64")
     set(SWIFT_HOST_VARIANT_ARCH_default "powerpc64")
   elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "ppc64le")

docs/HowToGuides/GettingStarted.md

@@ -343,7 +343,7 @@ git remote add my-remote https://github.com/username/swift.git
 Finally, create a new branch.
 ```sh
 # Using 'my-branch' as a placeholder name
-git checkout my-branch
+git checkout -b my-branch
 git push --set-upstream my-remote my-branch
 ```
 

docs/SIL.rst

@@ -1675,17 +1675,17 @@ Ownership SSA
 A SILFunction marked with the ``[ossa]`` function attribute is considered to be
 in Ownership SSA form. Ownership SSA is an augmented version of SSA that
 enforces ownership invariants by imbuing value-operand edges with semantic
-ownership information. All SIL values are statically assigned an ownership kind
+ownership information. All SIL values are assigned a constant ownership kind
 that defines the ownership semantics that the value models. All SIL operands
 that use a SIL value are required to be able to be semantically partitioned in
-between "normal uses" that just require the value to be live and "consuming
-uses" that end the lifetime of the value and after which the value can no longer
-be used. Since operands that are consuming uses end a value's lifetime,
-naturally we must have that the consuming use points jointly post-dominate all
-non-consuming use points and that a value must be consumed exactly once along
-all reachable program paths, preventing leaks and use-after-frees. As an
-example, consider the following SIL example with partitioned defs/uses annotated
-inline::
+between "non-lifetime ending uses" that just require the value to be live and
+"lifetime ending uses" that end the lifetime of the value and after which the
+value can no longer be used. Since by definition operands that are lifetime
+ending uses end their associated value's lifetime, we must have that the
+lifetime ending use points jointly post-dominate all non-lifetime ending use
+points and that a value must have exactly one lifetime ending use along all
+reachable program paths, preventing leaks and use-after-frees. As an example,
+consider the following SIL example with partitioned defs/uses annotated inline::
 
   sil @stash_and_cast : $@convention(thin) (@owned Klass) -> @owned SuperKlass {
   bb0(%kls1 : @owned $Klass): // Definition of %kls1
@@ -1710,12 +1710,101 @@ inline::
 
 Notice how every value in the SIL above has a partionable set of uses with
 normal uses always before consuming uses. Any such violations of ownership
-semantics would trigger a static SILVerifier error allowing us to know that we
+semantics would trigger a SILVerifier error allowing us to know that we
 do not have any leaks or use-after-frees in the above code.
 
+Ownership Kind
+~~~~~~~~~~~~~~
+
 The semantics in the previous example is of just one form of ownership semantics
-supported: "owned" semantics. In SIL, we allow for values to have one of four
-different ownership kinds:
+supported: "owned" semantics. In SIL, we map these "ownership semantics" into a
+form that a compiler can reason about by mapping semantics onto a lattice with
+the following elements: `None`_, `Owned`_, `Guaranteed`_, `Unowned`_, `Any`. We
+call this the lattice of "Ownership Kinds" and each individual value an
+"Ownership Kind". This lattice is defined as a 3-level lattice with::
+
+  1. None being Top.
+  2. Any being Bottom.
+  3. All non-Any, non-None OwnershipKinds being defined as a mid-level elements of the lattice
+
+We can graphically represent the lattice via a diagram like the following::
+
+                +------+
+      +-------- | None | ---------+
+      |         +------+          |
+      |            |              |
+      v            v              v         ^
+  +-------+  +-----+------+  +---------+    |
+  | Owned |  | Guaranteed |  | Unowned |    +--- Value Ownership Kinds and
+  +-------+  +-----+------+  +---------+         Ownership Constraints
+      |            |              |
+      |            v              |         +--- Only Ownership Constraints
+      |         +-----+           |         |
+      +-------->| Any |<----------+         v
+                +-----+
+
+One moves down the lattice by performing a "meet" operation::
+
+  None meet OtherOwnershipKind -> OtherOwnershipKind
+  Unowned meet Owned -> Any
+  Owned meet Guaranteed -> Any
+
+and one moves up the lattice by performing a "join" operation, e.x.::
+
+  Any join OtherOwnershipKind -> OtherOwnershipKind
+  Owned join Any -> Owned
+  Owned join Guaranteed -> None
+
+This lattice is applied to SIL by requiring well formed SIL to:
+
+1. Define a map of each SIL value to a constant OwnershipKind that classify the
+   semantics that the SIL value obeys. This ownership kind may be static (i.e.:
+   the same for all instances of an instruction) or dynamic (e.x.: forwarding
+   instructions set their ownership upon construction). We call this subset of
+   OwnershipKind to be the set of `Value Ownership Kind`_: `None`_, `Unowned`_,
+   `Guaranteed`_, `Owned`_ (note conspiciously missing `Any`). This is because
+   in our model `Any` represents an unknown ownership semantics and since our
+   model is strict, we do not allow for values to have unknown ownership.
+
+2. Define a map from each operand of a SILInstruction, `i`, to a constant
+   Ownership Kind, Boolean pair called the operand's `Ownership
+   Constraint`_. The Ownership Kind element of the `Ownership Constraint`_
+   determines semantically which ownership kind's the operand's value can take
+   on. The Boolean value is used to know if an operand will end the lifetime of
+   the incoming value when checking dataflow rules. The dataflow rules that each
+   `Value Ownership Kind`_ obeys is documented for each `Value Ownership Kind`_
+   in its detailed description below.
+
+Then we take these two maps and require that valid SIL has the property that
+given an operand, ``op(i)`` of an instruction ``i`` and a value ``v`` that
+``op(i)`` can only use ``v`` if the ``join`` of
+``OwnershipConstraint(operand(i))`` with ``ValueOwnershipKind(v)`` is equal to
+the ``ValueOwnershipKind`` of ``v``. In symbols, we must have that::
+
+  join : (OwnershipConstraint, ValueOwnershipKind) -> ValueOwnershipKind
+  OwnershipConstraint(operand(i)) join ValueOwnershipKind(v) = ValueOwnershipKind(v)
+
+In words, a value can be passed to an operand if applying the operand's
+ownership constraint to the value's ownership does not change the value's
+ownership. Operationally this has a few interesting effects on SIL::
+
+  1. We have defined away invalid value-operand (aka def-use) pairing since the
+     SILVerifier validates the aforementioned relationship on all SIL values,
+     uses at all points of the pipeline until ossa is lowered.
+
+  2. Many SIL instructions do not care about the ownership kind that their value
+     will take. They can just define all of their operand's as having an
+     ownership constraint of Any.
+
+Now lets go into more depth upon `Value Ownership Kind`_ and `Ownership Constraint`_.
+
+Value Ownership Kind
+~~~~~~~~~~~~~~~~~~~~
+
+As mentioned above, each SIL value is statically mapped to an `Ownership Kind`_
+called the value's "ValueOwnershipKind" that classify the semantics of the
+value. Below, we map each ValueOwnershipKind to a short summary of the semantics
+implied upon the parent value:
 
 * **None**. This is used to represent values that do not require memory
   management and are outside of Ownership SSA invariants. Examples: trivial
@@ -1739,10 +1828,7 @@ different ownership kinds:
   bitcasting a trivial type to a non-trivial type. This value should never be
   consumed.
 
-We describe each of these semantics in more detail below.
-
-Value Ownership Kind
-~~~~~~~~~~~~~~~~~~~~
+We describe each of these semantics in below in more detail.
 
 Owned
 `````
@@ -1912,10 +1998,26 @@ This is a form of ownership that is used to model two different use cases:
   trivial pointer to a class. In that case, since we have no reason to assume
   that the object will remain alive, we need to make a copy of the value.
 
+Ownership Constraint
+~~~~~~~~~~~~~~~~~~~~
+
+NOTE: We assume that one has read the section above on `Ownership Kind`_.
+
+As mentioned above, every operand ``operand(i)`` of a SIL instruction ``i`` has
+statically mapped to it:
+
+1. An ownership kind that acts as an "Ownership Constraint" upon what "Ownership
+   Kind" a value can take.
+
+2. A boolean value that defines whether or not the execution of the operand's
+   instruction will cause the operand's value to be invalidated. This is often
+   times referred to as an operand acting as a "lifetime ending use".
+
 Forwarding Uses
 ~~~~~~~~~~~~~~~
 
-NOTE: In the following, we assumed that one read the section above, `Value Ownership Kind`_.
+NOTE: In the following, we assumed that one read the section above, `Ownership
+Kind`_, `Value Ownership Kind`_ and `Ownership Constraint`_.
 
 A subset of SIL instructions define the value ownership kind of their results in
 terms of the value ownership kind of their operands. Such an instruction is

include/swift/AST/DiagnosticsSema.def

@@ -4132,6 +4132,9 @@ NOTE(note_add_async_to_function,none,
      "add 'async' to function %0 to make it asynchronous", (DeclName))
 NOTE(note_add_asynchandler_to_function,none,
      "add '@asyncHandler' to function %0 to create an implicit asynchronous context", (DeclName))
+NOTE(note_add_actorindependent_to_decl,none,
+     "add '@actorIndependent' to %0 to make this %1 independent of the actor",
+     (DeclName, DescriptiveDeclKind))
 NOTE(note_add_globalactor_to_function,none,
      "add '@%0' to make %1 %2 part of global actor %3", 
      (StringRef, DescriptiveDeclKind, DeclName, Type))
@@ -4255,10 +4258,6 @@ WARNING(shared_mutable_state_access,none,
 ERROR(actor_isolated_witness,none,
      "actor-isolated %0 %1 cannot be used to satisfy a protocol requirement",
      (DescriptiveDeclKind, DeclName))
-ERROR(actor_isolated_witness_could_be_async_handler,none,
-     "actor-isolated %0 %1 cannot be used to satisfy a protocol requirement; "
-     "did you mean to make it an asychronous handler?",
-     (DescriptiveDeclKind, DeclName))
 ERROR(global_actor_isolated_requirement,none,
       "%0 %1 must be isolated to the global actor %2 to satisfy corresponding "
       "requirement from protocol %3",

include/swift/IDE/CodeCompletion.h

@@ -89,11 +89,8 @@ class CodeCompletionStringChunk {
     /// The "override" keyword.
     OverrideKeyword,
 
-    /// The "throws" keyword.
-    ThrowsKeyword,
-
-    /// The "rethrows" keyword.
-    RethrowsKeyword,
+    /// The "throws", "rethrows" and "async" keyword.
+    EffectsSpecifierKeyword,
 
     /// The keyword part of a declaration before the name, like "func".
     DeclIntroducer,
@@ -220,8 +217,7 @@ class CodeCompletionStringChunk {
   static bool chunkHasText(ChunkKind Kind) {
     return Kind == ChunkKind::AccessControlKeyword ||
            Kind == ChunkKind::OverrideKeyword ||
-           Kind == ChunkKind::ThrowsKeyword ||
-           Kind == ChunkKind::RethrowsKeyword ||
+           Kind == ChunkKind::EffectsSpecifierKeyword ||
            Kind == ChunkKind::DeclAttrKeyword ||
            Kind == ChunkKind::DeclIntroducer ||
            Kind == ChunkKind::Keyword ||

include/swift/Parse/SyntaxParsingContext.h

@@ -220,6 +220,9 @@ class alignas(1 << SyntaxAlignInBits) SyntaxParsingContext {
     setCreateSyntax(Kind);
   }
 
+  SyntaxParsingContext(const SyntaxParsingContext &other) = delete;
+  SyntaxParsingContext &operator=(const SyntaxParsingContext &other) = delete;
+
   ~SyntaxParsingContext();
 
   /// Try looking up if an unmodified node exists at \p LexerOffset of the same

include/swift/SIL/OwnershipUtils.h

@@ -86,7 +86,7 @@ class ForwardingOperand {
   OwnershipConstraint getOwnershipConstraint() const {
     // We use a force unwrap since a ForwardingOperand should always have an
     // ownership constraint.
-    return *use->getOwnershipConstraint();
+    return use->getOwnershipConstraint();
   }
   ValueOwnershipKind getOwnershipKind() const;
   void setOwnershipKind(ValueOwnershipKind newKind) const;