Merge branch 'main' into wip-main-remove-task-current

Author: ktoso

cmake/modules/DarwinSDKs.cmake

@@ -13,7 +13,7 @@ endif()
 set(SUPPORTED_TVOS_ARCHS "arm64")
 set(SUPPORTED_TVOS_SIMULATOR_ARCHS "x86_64;arm64")
 set(SUPPORTED_WATCHOS_ARCHS "armv7k;arm64_32")
-set(SUPPORTED_WATCHOS_SIMULATOR_ARCHS "i386;arm64")
+set(SUPPORTED_WATCHOS_SIMULATOR_ARCHS "i386;x86_64;arm64")
 set(SUPPORTED_OSX_ARCHS "x86_64;arm64;arm64e")
 
 is_sdk_requested(OSX swift_build_osx)

include/swift/ABI/Metadata.h

@@ -4897,6 +4897,9 @@ struct DynamicReplacementKey {
   uint16_t getExtraDiscriminator() const {
     return flags & 0x0000FFFF;
   }
+  bool isAsync() const {
+    return ((flags >> 16 ) & 0x1);
+  }
 };
 
 /// A record describing a dynamic function replacement.

include/swift/AST/DiagnosticsSema.def

@@ -4351,8 +4351,8 @@ NOTE(objc_ambiguous_async_convention_candidate,none,
 ERROR(async_objc_dynamic_self,none,
       "asynchronous method returning 'Self' cannot be '@objc'", ())
 
-ERROR(actor_with_nonactor_superclass,none,
-      "actor cannot inherit from non-actor class %0", (DeclName))
+ERROR(actor_inheritance,none,
+      "actor types do not support inheritance", ())
 
 ERROR(actor_isolated_non_self_reference,none,
         "actor-isolated %0 %1 can only be %select{referenced|mutated|used 'inout'}3 "
@@ -4426,6 +4426,9 @@ NOTE(actor_isolated_sync_func,none,
 NOTE(actor_mutable_state,none,
      "mutation of this %0 is only permitted within the actor",
      (DescriptiveDeclKind))
+NOTE(actor_isolated_let,none,
+     "use `nonisolated` to allow synchronous access to 'let' from outside "
+     "the actor", ())
 WARNING(shared_mutable_state_access,none,
         "reference to %0 %1 is not concurrency-safe because it involves "
         "shared mutable state", (DescriptiveDeclKind, DeclName))
@@ -4458,13 +4461,12 @@ WARNING(non_concurrent_property_type,none,
 WARNING(non_concurrent_keypath_capture,none,
         "cannot form key path that captures non-sendable type %0",
         (Type))
-WARNING(non_concurrent_keypath_access,none,
-        "cannot form key path that accesses non-sendable type %0",
-        (Type))
 ERROR(non_concurrent_type_member,none,
       "%select{stored property %1|associated value %1}0 of "
       "'Sendable'-conforming %2 %3 has non-sendable type %4",
       (bool, DeclName, DescriptiveDeclKind, DeclName, Type))
+ERROR(non_sendable_nonisolated_let,none,
+      "non-isolated let property %0 has non-Sendable type %1", (DeclName, Type))
 ERROR(concurrent_value_class_mutable_property,none,
       "stored property %0 of 'Sendable'-conforming %1 %2 is mutable",
       (DeclName, DescriptiveDeclKind, DeclName))
@@ -4480,21 +4482,13 @@ ERROR(concurrent_value_inherit,none,
       "%select{| other than 'NSObject'}0",
       (bool, DeclName))
 
-ERROR(actorindependent_let,none,
-      "'@actorIndependent' is meaningless on 'let' declarations because "
-      "they are immutable",
-      ())
 ERROR(actorindependent_mutable_storage,none,
       "'@actorIndependent' can not be applied to stored properties",
       ())
 ERROR(actorindependent_local_var,none,
       "'@actorIndependent' can not be applied to local variables",
       ())
 
-ERROR(nonisolated_let,none,
-      "'nonisolated' is meaningless on 'let' declarations because "
-      "they are immutable",
-      ())
 ERROR(nonisolated_mutable_storage,none,
       "nonisolated' can not be applied to stored properties",
       ())
@@ -5678,8 +5672,8 @@ ERROR(wrapped_value_mismatch, none,
       "property type %0 does not match 'wrappedValue' type %1",
       (Type, Type))
 ERROR(composed_property_wrapper_mismatch, none,
-      "composed wrapper type %0 does not match former 'wrappedValue' type %1",
-      (Type, Type))
+      "composed wrapper type %0 does not match type of '%1.wrappedValue', which is %2",
+      (Type, StringRef, Type))
 
 ERROR(property_wrapper_type_access,none,
       "%select{%select{variable|constant}0|property}1 "

include/swift/Basic/Features.def

@@ -43,7 +43,9 @@ LANGUAGE_FEATURE(RethrowsProtocol, 0, "@rethrows protocol", true)
 LANGUAGE_FEATURE(GlobalActors, 0, "Global actors", langOpts.EnableExperimentalConcurrency)
 LANGUAGE_FEATURE(BuiltinJob, 0, "Builtin.Job type", true)
 LANGUAGE_FEATURE(Sendable, 0, "Sendable and @Sendable", true)
+LANGUAGE_FEATURE(BuiltinExecutor, 0, "Executor builtins", true)
 LANGUAGE_FEATURE(BuiltinContinuation, 0, "Continuation builtins", true)
 LANGUAGE_FEATURE(BuiltinTaskGroup, 0, "TaskGroup builtins", true)
+LANGUAGE_FEATURE(InheritActorContext, 0, "@_inheritActorContext attribute", true)
 
 #undef LANGUAGE_FEATURE

include/swift/Basic/FileTypes.def

@@ -83,8 +83,6 @@ TYPE("index-unit-output-path", IndexUnitOutputPath,    "",                "")
 TYPE("yaml-opt-record",     YAMLOptRecord,             "opt.yaml",        "")
 TYPE("bitstream-opt-record",BitstreamOptRecord,        "opt.bitstream",   "")
 
-TYPE("symbol-graph-output-path", SymbolGraphOutputPath, "",               "")
-
 // Overlay files declare wrapper modules, called "separately-imported overlays",
 // that should be automatically imported when a particular module is imported.
 // Cross-import directories conditionalize overlay files so they only take

include/swift/Basic/SupplementaryOutputPaths.h

@@ -152,9 +152,6 @@ struct SupplementaryOutputPaths {
 
   /// The path to which we should emit module summary file.
   std::string ModuleSummaryOutputPath;
-  
-  /// The directory to which we should emit symbol graphs for the current module.
-  std::string SymbolGraphOutputDir;
 
   SupplementaryOutputPaths() = default;
   SupplementaryOutputPaths(const SupplementaryOutputPaths &) = default;
@@ -189,8 +186,6 @@ struct SupplementaryOutputPaths {
       fn(LdAddCFilePath); 
     if (!ModuleSummaryOutputPath.empty())
       fn(ModuleSummaryOutputPath);
-    if (!SymbolGraphOutputDir.empty())
-      fn(SymbolGraphOutputDir);
   }
 
   bool empty() const {
@@ -199,8 +194,7 @@ struct SupplementaryOutputPaths {
            ReferenceDependenciesFilePath.empty() &&
            SerializedDiagnosticsPath.empty() && LoadedModuleTracePath.empty() &&
            TBDPath.empty() && ModuleInterfaceOutputPath.empty() &&
-           ModuleSourceInfoOutputPath.empty() && LdAddCFilePath.empty() &&
-           SymbolGraphOutputDir.empty();
+           ModuleSourceInfoOutputPath.empty() && LdAddCFilePath.empty();
   }
 };
 } // namespace swift

include/swift/Driver/Driver.h

@@ -416,11 +416,6 @@ class Driver {
                                         const TypeToPathMap *OutputMap,
                                         StringRef workingDirectory,
                                         CommandOutput *Output) const;
-  
-  void chooseSymbolGraphOutputPath(Compilation &C,
-                                   const TypeToPathMap *OutputMap,
-                                   StringRef workingDirectory,
-                                   CommandOutput *Output) const;
 
   void chooseLoadedModuleTracePath(Compilation &C,
                                    StringRef workingDirectory,

include/swift/Runtime/BackDeployment.h

@@ -22,8 +22,18 @@ namespace bincompat {
 
 /// Whether protocol conformance iteration should be reversed, to prefer
 /// conformances from images that are later in the list over earlier ones.
+/// Default is false starting with Swift 5.4.
 bool workaroundProtocolConformanceReverseIteration();
 
+/// Whether we should crash when we encounter a non-nullable Obj-C
+/// reference with a null value as the source of a cast.
+/// Default is true starting with Swift 5.4.
+bool unexpectedObjCNullWhileCastingIsFatal();
+
+/// Whether we should use the legacy semantics for casting nil optionals
+/// to nested optionals
+bool useLegacyOptionalNilInjection();
+
 } // namespace bincompat
 
 } // namespace runtime

include/swift/Runtime/Bincompat.h

@@ -100,34 +100,21 @@
 /// from ObjC classes?
 #ifndef SWIFT_CLASS_IS_SWIFT_MASK
 
-// Non-Apple platforms always use 1.
-# if !defined(__APPLE__)
-#  define SWIFT_CLASS_IS_SWIFT_MASK 1ULL
-
-// Builds for Swift-in-the-OS always use 2.
-# elif SWIFT_BNI_OS_BUILD
-#  define SWIFT_CLASS_IS_SWIFT_MASK 2ULL
-
-// Builds for Xcode always use 1.
-# elif SWIFT_BNI_XCODE_BUILD
-#  define SWIFT_CLASS_IS_SWIFT_MASK 1ULL
-
 // Compatibility hook libraries cannot rely on the "is swift" bit being either
 // value, since they must work with both OS and Xcode versions of the libraries.
 // Generate a reference to a nonexistent symbol so that we get obvious linker
 // errors if we try.
-# elif SWIFT_COMPATIBILITY_LIBRARY
+# if SWIFT_COMPATIBILITY_LIBRARY
 extern uintptr_t __COMPATIBILITY_LIBRARIES_CANNOT_CHECK_THE_IS_SWIFT_BIT_DIRECTLY__;
 #  define SWIFT_CLASS_IS_SWIFT_MASK __COMPATIBILITY_LIBRARIES_CANNOT_CHECK_THE_IS_SWIFT_BIT_DIRECTLY__
 
-// Other builds (such as local builds on developers' computers)
-// dynamically choose the bit at runtime based on the current OS
-// version.
+// Apple platforms always use 2
+# elif defined(__APPLE__)
+#  define SWIFT_CLASS_IS_SWIFT_MASK 2ULL
+
+// Non-Apple platforms always use 1.
 # else
-#  define SWIFT_CLASS_IS_SWIFT_MASK _swift_classIsSwiftMask
-#  define SWIFT_CLASS_IS_SWIFT_MASK_GLOBAL_VARIABLE 1
-#  define SWIFT_BUILD_HAS_BACK_DEPLOYMENT 1
-#  include "BackDeployment.h"
+#  define SWIFT_CLASS_IS_SWIFT_MASK 1ULL
 
 # endif
 #endif

include/swift/Runtime/Config.h

@@ -1020,19 +1020,12 @@ class SILFunction
 
   /// Transfer all blocks of \p F into this function, at the begin of the block
   /// list.
-  void moveAllBlocksFromOtherFunction(SILFunction *F) {
-    BlockList.splice(begin(), F->BlockList);
-  }
+  void moveAllBlocksFromOtherFunction(SILFunction *F);
 
   /// Transfer \p blockInOtherFunction of another function into this function,
   /// before \p insertPointInThisFunction.
   void moveBlockFromOtherFunction(SILBasicBlock *blockInOtherFunction,
-                                  iterator insertPointInThisFunction) {
-    SILFunction *otherFunc = blockInOtherFunction->getParent();
-    assert(otherFunc != this);
-    BlockList.splice(insertPointInThisFunction, otherFunc->BlockList,
-                     blockInOtherFunction);
-  }
+                                  iterator insertPointInThisFunction);
 
   /// Move block \p BB to immediately before the iterator \p IP.
   ///

include/swift/SIL/SILFunction.h

@@ -304,7 +304,13 @@ class SILModule {
   /// The value is either a SingleValueInstrution or a PlaceholderValue, in case
   /// an opened-archetype definition is lookedup during parsing or deserializing
   /// SIL, where opened archetypes can be forward referenced.
-  llvm::DenseMap<ArchetypeType*, SILValue> openedArchetypeDefs;
+  ///
+  /// In theory we wouldn't need to have the SILFunction in the key, because
+  /// opened archetypes _should_ be unique across the module. But currently
+  /// in some rare cases SILGen re-uses the same opened archetype for multiple
+  /// functions.
+  using OpenedArchetypeKey = std::pair<ArchetypeType*, SILFunction*>;
+  llvm::DenseMap<OpenedArchetypeKey, SILValue> openedArchetypeDefs;
 
   /// The number of PlaceholderValues in openedArchetypeDefs.
   int numUnresolvedOpenedArchetypes = 0;
@@ -382,15 +388,18 @@ class SILModule {
   /// In case the opened archetype is not defined yet (e.g. during parsing or
   /// deserilization), a PlaceholderValue is returned. This should not be the
   /// case outside of parsing or deserialization.
-  SILValue getOpenedArchetypeDef(CanArchetypeType archetype);
+  SILValue getOpenedArchetypeDef(CanArchetypeType archetype,
+                                 SILFunction *inFunction);
 
   /// Returns the instruction which defines an opened archetype, e.g. an
   /// open_existential_addr.
   ///
   /// In contrast to getOpenedArchetypeDef, it is required that all opened
   /// archetypes are resolved.
-  SingleValueInstruction *getOpenedArchetypeInst(CanArchetypeType archetype) {
-    return cast<SingleValueInstruction>(getOpenedArchetypeDef(archetype));
+  SingleValueInstruction *getOpenedArchetypeInst(CanArchetypeType archetype,
+                                                 SILFunction *inFunction) {
+    return cast<SingleValueInstruction>(getOpenedArchetypeDef(archetype,
+                                                              inFunction));
   }
 
   /// Returns true if there are unresolved opened archetypes in the module.
@@ -401,6 +410,9 @@ class SILModule {
   /// Called by SILBuilder whenever a new instruction is created and inserted.
   void notifyAddedInstruction(SILInstruction *inst);
 
+  /// Called after an instruction is moved from one function to another.
+  void notifyMovedInstruction(SILInstruction *inst, SILFunction *fromFunction);
+
   /// Add a delete notification handler \p Handler to the module context.
   void registerDeleteNotificationHandler(DeleteNotificationHandler* Handler);
 

include/swift/SIL/SILModule.h

@@ -322,6 +322,12 @@ enum class FixKind : uint8_t {
   /// even though result type of the reference doesn't conform
   /// to an expected protocol.
   AllowInvalidStaticMemberRefOnProtocolMetatype,
+
+  /// Allow the wrappedValue type of any property wrapper that is a
+  /// part of a composed property wrapper to mismatch the type of
+  /// another property wrapper that is a part of the same composed
+  /// property wrapper.
+  AllowWrappedValueMismatch,
 };
 
 class ConstraintFix {
@@ -615,6 +621,20 @@ class TreatArrayLiteralAsDictionary final : public ContextualMismatch {
                                                ConstraintLocator *loc);
 };
 
+class AllowWrappedValueMismatch : public ContextualMismatch {
+  AllowWrappedValueMismatch(ConstraintSystem &cs, Type lhs, Type rhs,
+                            ConstraintLocator *locator)
+      : ContextualMismatch(cs, FixKind::AllowWrappedValueMismatch, lhs, rhs, locator) {}
+
+public:
+  std::string getName() const override { return "fix wrapped value type mismatch"; }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  static AllowWrappedValueMismatch *create(ConstraintSystem &cs, Type lhs, Type rhs,
+                                           ConstraintLocator *locator);
+};
+
 /// Mark function type as explicitly '@escaping'.
 class MarkExplicitlyEscaping final : public ContextualMismatch {
   MarkExplicitlyEscaping(ConstraintSystem &cs, Type lhs, Type rhs,