Merge main 2022-03-11

.github/workflows/build-toolchain.yml

@@ -129,11 +129,12 @@ jobs:
           restore-keys: |
             ${{ matrix.target }}-sccache-v11-
 
-      - name: Clean stdlib build directory
+      - name: Clean build directory
         if: ${{ matrix.clean_build_dir }}
         run: |
           rm -rf ${{ github.workspace }}/target-build \
             ${{ github.workspace }}/host-build \
+            ${{ github.workspace }}/build-sdk \
             ${{ github.workspace }}/host-toolchain-sdk \
             ${{ github.workspace }}/dist-toolchain-sdk
 

docs/ABI/Mangling.rst

@@ -635,6 +635,7 @@ Types
   type ::= protocol-list 'p'                 // existential type
   type ::= protocol-list superclass 'Xc'     // existential type with superclass
   type ::= protocol-list 'Xl'                // existential type with AnyObject
+  type ::= protocol-list 'y' (type* '_')* type* retroactive-conformance* 'Xp'   // parameterized protocol type
   type ::= type-list 't'                     // tuple
   type ::= type generic-signature 'u'        // generic type
   type ::= 'x'                               // generic param, depth=0, idx=0

docs/CppInteropability/GettingStartedWithC++Interop.md → docs/CppInteroperability/GettingStartedWithC++Interop.md

@@ -59,24 +59,23 @@ struct ContentView: View {
 ```
 
 ```
-//In Cxx.cpp
+//In Cxx.hpp
+
+#ifndef Cxx_hpp
+#define Cxx_hpp
 
-#include "Cxx.hpp"
 int cxxFunction(int n) {
     return n;
 }
-
+#endif
 ```
 
 ```
-//In Cxx.hpp
-
-#ifndef Cxx_hpp
-#define Cxx_hpp
+//In Cxx.cpp
 
+#include "Cxx.hpp"
 int cxxFunction(int n);
 
-#endif
 
 ```
 
@@ -198,7 +197,7 @@ CxxInterop.main()
 
 ```
 
-- In your projects direcetoy, run `cmake` to generate the systems build files
+- In your project's directory, run `cmake` to generate the systems build files
 
 - To generate an Xcode project run `cmake -GXcode` 
 - To generate with Ninja run `cmake -GNinja`

docs/ReferenceGuides/UnderscoredAttributes.md

@@ -830,10 +830,20 @@ the compiler.
 
 This `async` function uses the pre-SE-0338 semantics of unsafely inheriting the caller's executor.  This is an underscored feature because the right way of inheriting an executor is to pass in the required executor and switch to it.  Unfortunately, there are functions in the standard library which need to inherit their caller's executor but cannot change their ABI because they were not defined as `@_alwaysEmitIntoClient` in the initial release.
 
+
 ## `@_spi_available(platform, version)`
 
 Like `@available`, this attribute indicates a decl is available only as an SPI.
 This implies several behavioral changes comparing to regular `@available`:
 1. Type checker diagnoses when a client accidently exposes such a symbol in library APIs.
 2. When emitting public interfaces, `@_spi_available` is printed as `@available(platform, unavailable)`.
 3. ClangImporter imports ObjC macros `SPI_AVAILABLE` and `__SPI_AVAILABLE` to this attribute.
+
+
+## `_local`
+
+A distributed actor can be marked as "known to be local" which allows avoiding 
+the distributed actor isolation checks. This is used for things like `whenLocal`
+where the actor passed to the closure is known-to-be-local, and similarly a 
+`self` of obtained from an _isolated_ function inside a distributed actor is 
+also guaranteed to be local by construction.

include/swift/AST/ASTContext.h

@@ -658,12 +658,11 @@ class ASTContext final {
 
   /// Retrieve the declaration of DistributedActorSystem.make().
   ///
-  /// \param actorOrSystem distributed actor or actor system to get the
-  /// remoteCall function for. Since the method we're looking for is an ad-hoc
-  /// requirement, a specific type MUST be passed here as it is not possible
-  /// to obtain the decl from just the `DistributedActorSystem` protocol type.
+  /// \param thunk the function from which we'll be invoking things on the obtained
+  /// actor system; This way we'll always get the right type, taking care of any
+  /// where clauses etc.
   FuncDecl *getMakeInvocationEncoderOnDistributedActorSystem(
-      NominalTypeDecl *actorOrSystem) const;
+      AbstractFunctionDecl *thunk) const;
 
   // Retrieve the declaration of
   // DistributedInvocationEncoder.recordGenericSubstitution(_:).

include/swift/AST/ASTDemangler.h

@@ -112,6 +112,8 @@ class ASTBuilder {
                                      bool isClassBound,
                                      bool forRequirement = true);
 
+  Type createParameterizedProtocolType(Type base, ArrayRef<Type> args);
+
   Type createExistentialMetatypeType(Type instance,
                      Optional<Demangle::ImplMetatypeRepresentation> repr=None);
 

include/swift/AST/Attr.def

@@ -57,6 +57,7 @@ TYPE_ATTR(async)
 TYPE_ATTR(Sendable)
 TYPE_ATTR(unchecked)
 TYPE_ATTR(_typeSequence)
+TYPE_ATTR(_local)
 
 // SIL-specific attributes
 TYPE_ATTR(block_storage)
@@ -720,6 +721,13 @@ DECL_ATTR(_backDeploy, BackDeploy,
   ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIBreakingToRemove,
   129)
 
+CONTEXTUAL_SIMPLE_DECL_ATTR(_local, KnownToBeLocal,
+  DeclModifier | OnFunc | OnParam | OnVar |
+  DistributedOnly |
+  ABIBreakingToAdd | ABIBreakingToRemove |
+  APIBreakingToAdd | APIBreakingToRemove,
+  130)
+
 // If you're adding a new underscored attribute here, please document it in
 // docs/ReferenceGuides/UnderscoredAttributes.md.
 

include/swift/AST/Decl.h

@@ -2693,8 +2693,7 @@ class ValueDecl : public Decl {
   /// property, or the uncurried result type of a method/subscript, e.g.
   /// '() -> () -> Self'.
   GenericParameterReferenceInfo findExistentialSelfReferences(
-      Type baseTy, const DeclContext *useDC,
-      bool treatNonResultCovariantSelfAsInvariant) const;
+      Type baseTy, bool treatNonResultCovariantSelfAsInvariant) const;
 };
 
 /// This is a common base class for declarations which declare a type.
@@ -4491,10 +4490,6 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// semantics but has no corresponding witness table.
   bool isMarkerProtocol() const;
 
-  /// Is a protocol that can only be conformed by distributed actors.
-  /// Such protocols are allowed to contain distributed functions.
-  bool inheritsFromDistributedActor() const;
-
 private:
   void computeKnownProtocolKind() const;
 
@@ -5255,6 +5250,10 @@ class VarDecl : public AbstractStorageDecl {
   /// Does this have a 'distributed' modifier?
   bool isDistributed() const;
 
+  /// Is this var known to be a "local" distributed actor,
+  /// if so the implicit throwing ans some isolation checks can be skipped.
+  bool isKnownToBeLocal() const;
+
   /// Is this a stored property that will _not_ trigger any user-defined code
   /// upon any kind of access?
   bool isOrdinaryStoredProperty() const;
@@ -6309,6 +6308,13 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// Returns 'true' if the function is distributed.
   bool isDistributed() const;
 
+  /// For a 'distributed' target (func or computed property),
+  /// get the 'thunk' responsible for performing the 'remoteCall'.
+  ///
+  /// \return the synthesized thunk, or null if the base of the call has
+  ///         diagnosed errors during type checking.
+  FuncDecl *getDistributedThunk() const;
+
   /// Returns 'true' if the function has the @c @_backDeploy attribute.
   bool isBackDeployed() const;
 
@@ -6456,6 +6462,16 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// 'DistributedActorSystem' protocol.
   bool isDistributedActorSystemRemoteCall(bool isVoidReturn) const;
 
+  /// Determines whether this function is a 'makeInvocationEncoder' function,
+  /// which is used as ad-hoc protocol requirement by the
+  /// 'DistributedActorSystem' protocol.
+  bool isDistributedActorSystemMakeInvocationEncoder() const;
+
+  /// Determines if this function is a 'recordGenericSubstitution' function,
+  /// which is used as ad-hoc protocol requirement by the
+  /// 'DistributedTargetInvocationEncoder' protocol.
+  bool isDistributedTargetInvocationEncoderRecordGenericSubstitution() const;
+
   /// Determines if this function is a 'recordArgument' function,
   /// which is used as ad-hoc protocol requirement by the
   /// 'DistributedTargetInvocationEncoder' protocol.

include/swift/AST/DiagnosticsParse.def

@@ -1561,46 +1561,16 @@ ERROR(attr_availability_duplicate,none,
       (StringRef, StringRef))
 
 // originallyDefinedIn
-// FIXME(backDeploy): Refactor to share with back deployment attr
 ERROR(originally_defined_in_missing_rparen,none,
       "expected ')' in @_originallyDefinedIn argument list", ())
 
-// FIXME(backDeploy): Refactor to share with back deployment attr
-ERROR(originally_defined_in_unrecognized_platform,none,
-      "unrecognized platform name in @_originallyDefinedIn argument list", ())
-
-// FIXME: This is unused and can be removed
-ERROR(originally_defined_in_unrecognized_property,none,
-      "unrecognized property in @_originallyDefinedIn argument list", ())
-
 ERROR(originally_defined_in_need_original_module_name,none,
       "expected 'module: \"original\"' in the first argument to "
       "@_originallyDefinedIn", ())
 
 ERROR(originally_defined_in_need_nonempty_module_name,none,
       "original module name cannot be empty in @_originallyDefinedIn", ())
 
-// FIXME(backDeploy): Refactor to share with back deployment attr
-ERROR(originally_defined_in_need_platform_version,none,
-     "expected at least one platform version in @_originallyDefinedIn", ())
-
-// FIXME(backDeploy): Refactor to share with back deployment attr
-WARNING(originally_defined_in_major_minor_only,none,
-        "@_originallyDefinedIn only uses major and minor version number", ())
-
-// FIXME(backDeploy): Refactor to share with back deployment attr
-WARNING(originally_defined_in_missing_platform_name,none,
-        "* as platform name has no effect", ())
-
-// FIXME(backDeploy): Refactor to share with back deployment attr
-WARNING(originally_defined_in_swift_version, none,
-        "Swift language version checks has no effect "
-        "in @_originallyDefinedIn", ())
-
-WARNING(originally_defined_in_package_description, none,
-        "PackageDescription version checks has no effect "
-        "in @_originallyDefinedIn", ())
-
 // backDeploy
 ERROR(attr_back_deploy_missing_rparen,none,
       "expected ')' in '@_backDeploy' argument list", ())

include/swift/AST/DiagnosticsSema.def

@@ -1935,8 +1935,8 @@ WARNING(type_does_not_conform_swiftui_warning,none,
 
 ERROR(non_final_class_cannot_conform_to_self_same_type,none,
       "non-final class %0 cannot safely conform to protocol %1, "
-      "which requires that 'Self' is exactly equal to %2",
-      (Type, Type, Type))
+      "which requires that %2 %select{is exactly equal to|inherit from}3 %4",
+      (Type, Type, Type, unsigned, Type))
 
 ERROR(cannot_use_nil_with_this_type,none,
       "'nil' cannot be used in context expecting type %0", (Type))
@@ -4495,6 +4495,13 @@ ERROR(actor_inheritance,none,
 ERROR(actor_protocol_illegal_inheritance,none,
       "non-actor type %0 cannot conform to the 'Actor' protocol",
       (DeclName))
+ERROR(distributed_actor_conformance_missing_system_type,none,
+      "distributed actor %0 does not declare ActorSystem it can be used with.",
+      (DeclName))
+NOTE(note_distributed_actor_system_can_be_defined_using_defaultdistributedactorsystem,none,
+     "you can provide a module-wide default actor system by declaring:\n"
+     "typealias DefaultDistributedActorSystem = <#ConcreteActorSystem#>\n",
+     ())
 ERROR(distributed_actor_protocol_illegal_inheritance,none,
       "non-distributed actor type %0 cannot conform to the 'DistributedActor' protocol",
       (DeclName))
@@ -4595,6 +4602,9 @@ NOTE(note_distributed_actor_isolated_method,none,
 ERROR(distributed_actor_isolated_method,none,
       "only 'distributed' instance methods can be called on a potentially remote distributed actor",
       ())
+ERROR(distributed_local_cannot_be_used,none,
+      "'local' cannot be used in user-defined code currently",
+      ())
 ERROR(distributed_actor_func_param_not_codable,none,
       "parameter '%0' of type %1 in %2 does not conform to serialization requirement '%3'",
       (StringRef, Type, DescriptiveDeclKind, StringRef))

include/swift/AST/DistributedDecl.h

@@ -31,6 +31,16 @@ class DeclContext;
 class FuncDecl;
 class NominalTypeDecl;
 
+/// Determine the concrete type of 'ActorSystem' as seen from the member.
+/// E.g. when in a protocol, and trying to determine what the actor system was
+/// constrained to.
+///
+/// \param member the member from which context the lookup should be performed,
+///        e.g. a function or computed property.
+/// \return the concrete type of the ActorSystem to be used by this member,
+///         or null if no concrete actor system was found.
+Type getConcreteReplacementForProtocolActorSystemType(ValueDecl *member);
+
 /// Determine the `ActorSystem` type for the given actor.
 Type getDistributedActorSystemType(NominalTypeDecl *actor);
 
@@ -43,14 +53,12 @@ Type getDistributedActorIDType(NominalTypeDecl *actor);
 Type getDistributedSerializationRequirementType(
     NominalTypeDecl *nominal, ProtocolDecl *protocol);
 
-///// Determine the serialization requirement for the given actor, actor system
-///// or other type that has the SerializationRequirement associated type.
-//Type getDistributedSerializationRequirementType(
-//    NominalTypeDecl *nominal, ProtocolDecl *protocol);
-
-Type getDistributedActorSystemActorIDRequirementType(
-    NominalTypeDecl *system);
+/// Get the specific 'InvocationEncoder' type of a specific distributed actor
+/// system.
+Type getDistributedActorSystemInvocationEncoderType(NominalTypeDecl *system);
 
+/// Get the 'ActorID' type of a specific distributed actor system.
+Type getDistributedActorSystemActorIDRequirementType(NominalTypeDecl *system);
 
 /// Get the specific protocols that the `SerializationRequirement` specifies,
 /// and all parameters / return types of distributed targets must conform to.