Merge pull request #4190 from swiftwasm/main

Author: MaxDesiatov

CHANGELOG.md

@@ -5,6 +5,29 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 
 ## Swift 5.7
 
+* The compiler now correctly emits warnings for more kinds of expressions where a protocol conformance is used and may be unavailable at runtime. Previously, member reference expressions and type erasing expressions that used potentially unavailable conformances were not diagnosed, leading to potential crashes at runtime.
+
+  ```swift
+  struct Pancake {}
+  protocol Food {}
+
+  extension Food {
+    var isGlutenFree: Bool { false }
+  }
+
+  @available(macOS 12.0, *)
+  extension Pancake: Food {}
+
+  @available(macOS 11.0, *)
+  func eatPancake(_ pancake: Pancake) {
+    if (pancake.isGlutenFree) { // warning: conformance of 'Pancake' to 'Food' is only available in macOS 12.0 or newer
+      eatFood(pancake) // warning: conformance of 'Pancake' to 'Food' is only available in macOS 12.0 or newer
+    }
+  }
+
+  func eatFood(_ food: Food) {}
+  ```
+
 * [SE-0328][]:
 
   Opaque types (expressed with 'some') can now be used in structural positions
@@ -19,6 +42,27 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 Swift 5.6
 ---------
 
+* [SE-0327][]:
+
+In Swift 5 mode, a warning is now emitted if the default-value expression of an
+instance-member property requires global-actor isolation. For example:
+
+```swift
+@MainActor
+func partyGenerator() -> [PartyMember] { fatalError("todo") }
+
+class Party {
+  @MainActor var members: [PartyMember] = partyGenerator()
+  //                                      ^~~~~~~~~~~~~~~~
+  // warning: expression requiring global actor 'MainActor' cannot
+  //          appear in default-value expression of property 'members'
+}
+```
+
+Previously, the isolation granted by the type checker matched the isolation of
+the property itself, but at runtime that is not guaranteed. In Swift 6, 
+such default-value expressions will become an error if they require isolation.
+
 * Actor isolation checking now understands that `defer` bodies share the isolation of their enclosing function.
 
   ```swift
@@ -8913,6 +8957,7 @@ Swift 1.0
 [SE-0322]: <https://github.com/apple/swift-evolution/blob/main/proposals/0322-temporary-buffers.md>
 [SE-0324]: <https://github.com/apple/swift-evolution/blob/main/proposals/0324-c-lang-pointer-arg-conversion.md>
 [SE-0323]: <https://github.com/apple/swift-evolution/blob/main/proposals/0323-async-main-semantics.md>
+[SE-0327]: <https://github.com/apple/swift-evolution/blob/main/proposals/0327-actor-initializers.md>
 [SE-0328]: <https://github.com/apple/swift-evolution/blob/main/proposals/0328-structural-opaque-result-types.md>
 [SE-0331]: <https://github.com/apple/swift-evolution/blob/main/proposals/0331-remove-sendable-from-unsafepointer.md>
 [SE-0337]: <https://github.com/apple/swift-evolution/blob/main/proposals/0337-support-incremental-migration-to-concurrency-checking.md>

cmake/modules/AddSwift.cmake

@@ -162,9 +162,9 @@ function(_add_host_variant_c_compile_link_flags name)
     # side effects are introduced should a new search path be added.
     target_compile_options(${name} PRIVATE
       $<$<COMPILE_LANGUAGE:C,CXX,OBJC,OBJCXX>:
-      -arch ${SWIFT_HOST_VARIANT_ARCH}
       "-F${SWIFT_SDK_${SWIFT_HOST_VARIANT_ARCH}_PATH}/../../../Developer/Library/Frameworks"
     >)
+    set_property(TARGET ${name} PROPERTY OSX_ARCHITECTURES "${SWIFT_HOST_VARIANT_ARCH}")
   endif()
 
   _compute_lto_flag("${SWIFT_TOOLS_ENABLE_LTO}" _lto_flag_out)

docs/ABI/Mangling.rst

@@ -1139,6 +1139,7 @@ Some kinds need arguments, which precede ``Tf``.
   CONST-PROP ::= 'i' NATURAL_ZERO            // 64-bit-integer
   CONST-PROP ::= 'd' NATURAL_ZERO            // float-as-64-bit-integer
   CONST-PROP ::= 's' ENCODING                // string literal. Consumes one identifier argument.
+  CONST-PROP ::= 'k'                         // keypath. Consumes one identifier - the SHA1 of the keypath and two types (root and value).
 
   ENCODING ::= 'b'                           // utf8
   ENCODING ::= 'w'                           // utf16

include/swift/ABI/Metadata.h

@@ -540,6 +540,9 @@ namespace {
 
 using TypeContextDescriptor = TargetTypeContextDescriptor<InProcess>;
 
+template<template <typename Runtime> class ObjCInteropKind, unsigned PointerSize>
+using ExternalTypeContextDescriptor = TargetTypeContextDescriptor<External<ObjCInteropKind<RuntimeTarget<PointerSize>>>>;
+
 // FIXME: https://bugs.swift.org/browse/SR-1155
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Winvalid-offsetof"
@@ -2106,7 +2109,10 @@ using ProtocolRequirement = TargetProtocolRequirement<InProcess>;
 
 template<typename Runtime> struct TargetProtocolDescriptor;
 using ProtocolDescriptor = TargetProtocolDescriptor<InProcess>;
-  
+
+template<template <typename Runtime> class ObjCInteropKind, unsigned PointerSize>
+using ExternalProtocolDescriptor = TargetProtocolDescriptor<External<ObjCInteropKind<RuntimeTarget<PointerSize>>>>;
+
 /// A witness table for a protocol.
 ///
 /// With the exception of the initial protocol conformance descriptor,
@@ -2722,6 +2728,16 @@ struct TargetProtocolConformanceDescriptor final
     return TypeRef.getTypeDescriptor(getTypeKind());
   }
 
+  constexpr inline auto
+  getTypeRefDescriptorOffset() const -> typename Runtime::StoredSize {
+    return offsetof(typename std::remove_reference<decltype(*this)>::type, TypeRef);
+  }
+
+  constexpr inline auto
+  getProtocolDescriptorOffset() const -> typename Runtime::StoredSize {
+    return offsetof(typename std::remove_reference<decltype(*this)>::type, Protocol);
+  }
+
   TargetContextDescriptor<Runtime> * __ptrauth_swift_type_descriptor *
   _getTypeDescriptorLocation() const {
     if (getTypeKind() != TypeReferenceKind::IndirectTypeDescriptor)
@@ -2840,6 +2856,12 @@ using TargetProtocolConformanceRecord =
 
 using ProtocolConformanceRecord = TargetProtocolConformanceRecord<InProcess>;
 
+template<template <typename Runtime> class ObjCInteropKind, unsigned PointerSize>
+using ExternalProtocolConformanceDescriptor = TargetProtocolConformanceDescriptor<External<ObjCInteropKind<RuntimeTarget<PointerSize>>>>;
+
+template<template <typename Runtime> class ObjCInteropKind, unsigned PointerSize>
+using ExternalProtocolConformanceRecord = TargetProtocolConformanceRecord<External<ObjCInteropKind<RuntimeTarget<PointerSize>>>>;
+
 template<typename Runtime>
 struct TargetGenericContext;
 
@@ -2876,6 +2898,11 @@ struct TargetContextDescriptor {
               : 0;
   }
 
+  constexpr inline auto
+  getParentOffset() const -> typename Runtime::StoredSize {
+    return offsetof(typename std::remove_reference<decltype(*this)>::type, Parent);
+  }
+
 #ifndef NDEBUG
   LLVM_ATTRIBUTE_DEPRECATED(void dump() const,
                             "only for use in the debugger");
@@ -2889,6 +2916,8 @@ struct TargetContextDescriptor {
 };
 
 using ContextDescriptor = TargetContextDescriptor<InProcess>;
+template<template <typename Runtime> class ObjCInteropKind, unsigned PointerSize>
+using ExternalContextDescriptor = TargetContextDescriptor<External<ObjCInteropKind<RuntimeTarget<PointerSize>>>>;
 
 inline bool isCImportedModuleName(llvm::StringRef name) {
   // This does not include MANGLING_MODULE_CLANG_IMPORTER because that's
@@ -2908,13 +2937,21 @@ struct TargetModuleContextDescriptor final : TargetContextDescriptor<Runtime> {
     return isCImportedModuleName(Name.get());
   }
 
+  constexpr inline auto
+  getNameOffset() const -> typename Runtime::StoredSize {
+    return offsetof(typename std::remove_reference<decltype(*this)>::type, Name);
+  }
+
   static bool classof(const TargetContextDescriptor<Runtime> *cd) {
     return cd->getKind() == ContextDescriptorKind::Module;
   }
 };
 
 using ModuleContextDescriptor = TargetModuleContextDescriptor<InProcess>;
 
+template<template <typename Runtime> class ObjCInteropKind, unsigned PointerSize>
+using ExternalModuleContextDescriptor = TargetModuleContextDescriptor<External<ObjCInteropKind<RuntimeTarget<PointerSize>>>>;
+
 template<typename Runtime>
 inline bool TargetContextDescriptor<Runtime>::isCImportedContext() const {
   return getModuleContext()->isCImportedContext();
@@ -3415,6 +3452,11 @@ struct TargetProtocolDescriptor final
             NumRequirements};
   }
 
+  constexpr inline auto
+  getNameOffset() const -> typename Runtime::StoredSize {
+    return offsetof(typename std::remove_reference<decltype(*this)>::type, Name);
+  }
+
   /// Retrieve the requirement base descriptor address.
   ConstTargetPointer<Runtime, TargetProtocolRequirement<Runtime>>
   getRequirementBaseDescriptor() const {
@@ -4079,6 +4121,11 @@ class TargetTypeContextDescriptor
   /// type's metadata. The returned value is measured in sizeof(StoredPointer).
   int32_t getGenericArgumentOffset() const;
 
+  constexpr inline auto
+  getNameOffset() const -> typename Runtime::StoredSize {
+    return offsetof(typename std::remove_reference<decltype(*this)>::type, Name);
+  }
+
   /// Return the start of the generic arguments array in the nominal
   /// type's metadata. The returned value is measured in sizeof(StoredPointer).
   const TargetMetadata<Runtime> * const *getGenericArguments(

include/swift/ABI/ObjectFile.h

@@ -12,14 +12,16 @@
 
 namespace swift {
 
-/// Represents the six reflection sections used by Swift
+/// Represents the eight reflection sections used by Swift
 enum ReflectionSectionKind : uint8_t {
   fieldmd,
   assocty,
   builtin,
   capture,
   typeref,
-  reflstr
+  reflstr,
+  conform,
+  protocs
 };
 
 /// Abstract base class responsible for providing the correct reflection section
@@ -31,6 +33,8 @@ class SwiftObjectFileFormat {
   virtual llvm::Optional<llvm::StringRef> getSegmentName() {
     return {};
   }
+  /// Predicate to identify if the named section can contain reflection data.
+  virtual bool sectionContainsReflectionData(llvm::StringRef sectionName) = 0;
 };
 
 /// Responsible for providing the Mach-O reflection section identifiers.
@@ -50,12 +54,25 @@ class SwiftObjectFileFormatMachO : public SwiftObjectFileFormat {
       return "__swift5_typeref";
     case reflstr:
       return "__swift5_reflstr";
+    case conform:
+      return "__swift5_proto";
+    case protocs:
+      return "__swift5_protos";
     }
     llvm_unreachable("Section type not found.");
   }
   llvm::Optional<llvm::StringRef> getSegmentName() override {
     return {"__TEXT"};
   }
+
+  bool sectionContainsReflectionData(llvm::StringRef sectionName) override {
+    // For Mach-O, the caller must call this function twice, once with just the
+    // section name (ex `__swift5_fieldmd`), and again with the segment
+    // qualified section name (ex `__DATA,__const`).
+    return sectionName.startswith("__swift5_") ||
+           sectionName == "__DATA_CONST,__const" ||
+           sectionName == "__DATA,__const";
+  }
 };
 
 /// Responsible for providing the ELF reflection section identifiers.
@@ -75,9 +92,17 @@ class SwiftObjectFileFormatELF : public SwiftObjectFileFormat {
       return "swift5_typeref";
     case reflstr:
       return "swift5_reflstr";
+    case conform:
+      return "swift5_protocol_conformances";
+    case protocs:
+      return "swift5_protocols";
     }
     llvm_unreachable("Section type not found.");
   }
+
+  bool sectionContainsReflectionData(llvm::StringRef sectionName) override {
+    return sectionName.startswith("swift5_");
+  }
 };
 
 /// Responsible for providing the COFF reflection section identifiers
@@ -97,9 +122,17 @@ class SwiftObjectFileFormatCOFF : public SwiftObjectFileFormat {
       return ".sw5tyrf";
     case reflstr:
       return ".sw5rfst";
+    case conform:
+      return ".sw5prtc$B";
+    case protocs:
+      return ".sw5prt$B";
     }
     llvm_unreachable("Section  not found.");
   }
+
+  bool sectionContainsReflectionData(llvm::StringRef sectionName) override {
+    return sectionName.startswith(".sw5");
+  }
 };
 } // namespace swift
 #endif // SWIFT_ABI_OBJECTFILE_H

include/swift/AST/ASTContext.h

@@ -679,6 +679,15 @@ class ASTContext final {
   FuncDecl *getMakeInvocationEncoderOnDistributedActorSystem(
       NominalTypeDecl *actorOrSystem) const;
 
+  // Retrieve the declaration of
+  // DistributedInvocationEncoder.recordGenericSubstitution(_:).
+  //
+  // \param nominal optionally provide a 'NominalTypeDecl' from which the
+  // function decl shall be extracted. This is useful to avoid witness calls
+  // through the protocol which is looked up when nominal is null.
+  FuncDecl *getRecordGenericSubstitutionOnDistributedInvocationEncoder(
+      NominalTypeDecl *nominal) const;
+
   // Retrieve the declaration of DistributedInvocationEncoder.recordArgument(_:).
   //
   // \param nominal optionally provide a 'NominalTypeDecl' from which the
@@ -1217,9 +1226,6 @@ class ASTContext final {
   InheritedProtocolConformance *
   getInheritedConformance(Type type, ProtocolConformance *inherited);
 
-  /// Check if \p decl is included in LazyContexts.
-  bool isLazyContext(const DeclContext *decl);
-
   /// Get the lazy data for the given declaration.
   ///
   /// \param lazyLoader If non-null, the lazy loader to use when creating the
@@ -1345,6 +1351,20 @@ class ASTContext final {
   /// alternative specified via the -entry-point-function-name frontend flag.
   std::string getEntryPointFunctionName() const;
 
+  /// Find the type of SerializationRequirement on the passed nominal.
+  ///
+  /// This type exists as a typealias/associatedtype on all distributed actors,
+  /// actor systems, and related serialization types.
+  Type getDistributedSerializationRequirementType(NominalTypeDecl *);
+
+  /// Find the concrete invocation decoder associated with the given actor.
+  NominalTypeDecl *
+  getDistributedActorInvocationDecoder(NominalTypeDecl *);
+
+  /// Find `decodeNextArgument<T>(type: T.Type) -> T` method associated with
+  /// invocation decoder of the given distributed actor.
+  FuncDecl *getDistributedActorArgumentDecodingMethod(NominalTypeDecl *);
+
 private:
   friend Decl;
 

include/swift/AST/ClangModuleLoader.h

@@ -182,8 +182,14 @@ class ClangModuleLoader : public ModuleLoader {
   /// Imports a clang decl directly, rather than looking up its name.
   virtual Decl *importDeclDirectly(const clang::NamedDecl *decl) = 0;
 
-  /// Emits any import diagnostics associated with the provided decl.
-  virtual void diagnoseDeclDirectly(const clang::NamedDecl *decl) = 0;
+  /// Emits diagnostics for any declarations named name
+  /// whose direct declaration context is a TU.
+  virtual void diagnoseTopLevelValue(const DeclName &name) = 0;
+
+  /// Emit diagnostics for declarations named name that are members
+  /// of the provided baseType.
+  virtual void diagnoseMemberValue(const DeclName &name,
+                                   const Type &baseType) = 0;
 
   /// Instantiate and import class template using given arguments.
   ///