Merge branch 'main' of github.com:apple/swift into maxd/main-merge

# Conflicts:
#	CMakeLists.txt

Author: MaxDesiatov

CMakeLists.txt

@@ -405,10 +405,6 @@ option(SWIFT_REPORT_STATISTICS
     "Create json files which contain internal compilation statistics"
     FALSE)
 
-option(SWIFT_DISABLE_OBJC_INTEROP
-    "Disable Objective-C interoperability even on platforms what would normally have it"
-    FALSE)
-
 # FIXME(wasm) Reflection tests are temporalily disabled due to lack of linker features
 option(SWIFTWASM_DISABLE_REFLECTION_TEST
     "Disable building swift-reflection-test for WebAssembly build"

include/swift/AST/Decl.h

@@ -3078,6 +3078,10 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// Prepare to traverse the list of extensions.
   void prepareExtensions();
 
+  /// Add loaded members from all extensions. Eagerly load any members that we
+  /// can't lazily load.
+  void addLoadedExtensions();
+
   /// Retrieve the conformance loader (if any), and removing it in the
   /// same operation. The caller is responsible for loading the
   /// conformances.
@@ -3200,6 +3204,11 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// Add a new extension to this nominal type.
   void addExtension(ExtensionDecl *extension);
 
+  /// Add a member to this decl's lookup table.
+  ///
+  /// Calls "prepareLookupTable" as a side effect.
+  void addMemberToLookupTable(Decl *member);
+
   /// Retrieve the set of extensions of this type.
   ExtensionRange getExtensions();
 

include/swift/Demangling/ManglingMacros.h

@@ -17,10 +17,14 @@
 #define MANGLE_AS_STRING(M) STRINGIFY_MANGLING(M)
 
 /// The mangling prefix for the new mangling.
+#if !defined(_MSC_VER) || _MSC_VER-0 >= 1926
 _Pragma("clang diagnostic push")
 _Pragma("clang diagnostic ignored \"-Wdollar-in-identifier-extension\"")
+#endif
 #define MANGLING_PREFIX $s
+#if !defined(_MSC_VER) || _MSC_VER-0 >= 1926
 _Pragma("clang diagnostic pop")
+#endif
 
 #define MANGLING_PREFIX_STR MANGLE_AS_STRING(MANGLING_PREFIX)
 

include/swift/Frontend/BackDeploymentLibs.def

@@ -27,6 +27,6 @@
 BACK_DEPLOYMENT_LIB((5, 0), all, "swiftCompatibility50")
 BACK_DEPLOYMENT_LIB((5, 1), all, "swiftCompatibility51")
 BACK_DEPLOYMENT_LIB((5, 0), executable, "swiftCompatibilityDynamicReplacements")
-BACK_DEPLOYMENT_LIB((5, 5), all, "swiftCompatibilityConcurrency")
+BACK_DEPLOYMENT_LIB((5, 4), all, "swiftCompatibilityConcurrency")
 
 #undef BACK_DEPLOYMENT_LIB

include/swift/SIL/OwnershipUtils.h

@@ -77,8 +77,9 @@ inline bool isForwardingConsume(SILValue value) {
   return canOpcodeForwardOwnedValues(value);
 }
 
-/// Find all "use points" of \p guaranteedValue that determine its lifetime
-/// requirement.
+/// Find leaf "use points" of \p guaranteedValue that determine its lifetime
+/// requirement. If \p usePoints is nullptr, then the simply returns true if no
+/// PointerEscape use was found.
 ///
 /// Precondition: \p guaranteedValue is not a BorrowedValue.
 ///
@@ -99,10 +100,10 @@ inline bool isForwardingConsume(SILValue value) {
 /// When this is called on a value that does not introduce a new scope, none of
 /// the use points can be EndBorrows or Reborrows. Those uses are only allowed
 /// on borrow-introducing values.
-bool findInnerTransitiveGuaranteedUses(SILValue guaranteedValue,
-                                       SmallVectorImpl<Operand *> &usePoints);
+bool findInnerTransitiveGuaranteedUses(
+    SILValue guaranteedValue, SmallVectorImpl<Operand *> *usePoints = nullptr);
 
-/// Find all "use points" of a guaranteed value within its enclosing borrow
+/// Find leaf "use points" of a guaranteed value within its enclosing borrow
 /// scope (without looking through reborrows). To find the use points of the
 /// extended borrow scope, after looking through reborrows, use
 /// findExtendedTransitiveGuaranteedUses() instead.
@@ -662,12 +663,19 @@ bool getAllBorrowIntroducingValues(SILValue value,
 /// introducer, then we return a .some(BorrowScopeIntroducingValue).
 BorrowedValue getSingleBorrowIntroducingValue(SILValue inputValue);
 
+enum class AddressUseKind { NonEscaping, PointerEscape, Unknown };
+
+inline AddressUseKind meet(AddressUseKind lhs, AddressUseKind rhs) {
+  return (lhs > rhs) ? lhs : rhs;
+}
+
 /// The algorithm that is used to determine what the verifier will consider to
 /// be transitive uses of the given address. Used to implement \see
 /// findTransitiveUses.
-bool findTransitiveUsesForAddress(
-    SILValue address, SmallVectorImpl<Operand *> &foundUses,
-    std::function<void(Operand *)> *onError = nullptr);
+AddressUseKind
+findTransitiveUsesForAddress(SILValue address,
+                             SmallVectorImpl<Operand *> *foundUses = nullptr,
+                             std::function<void(Operand *)> *onError = nullptr);
 
 class InteriorPointerOperandKind {
 public:
@@ -834,15 +842,19 @@ struct InteriorPointerOperand {
     llvm_unreachable("Covered switch isn't covered?!");
   }
 
-  /// Transitively compute the list of uses that this interior pointer operand
-  /// puts on its parent guaranted value.
+  /// Transitively compute the list of leaf uses that this interior pointer
+  /// operand puts on its parent guaranted value.
+  ///
+  /// If \p foundUses is nullptr, this simply returns true if no PointerEscapes
+  /// were found.
   ///
   /// Example: Uses of a ref_element_addr can not occur outside of the lifetime
   /// of the instruction's operand. The uses of that address act as liveness
   /// requirements to ensure that the underlying class is alive at all use
   /// points.
-  bool findTransitiveUses(SmallVectorImpl<Operand *> &foundUses,
-                          std::function<void(Operand *)> *onError = nullptr) {
+  AddressUseKind
+  findTransitiveUses(SmallVectorImpl<Operand *> *foundUses = nullptr,
+                     std::function<void(Operand *)> *onError = nullptr) {
     return findTransitiveUsesForAddress(getProjectedAddress(), foundUses,
                                         onError);
   }
@@ -912,8 +924,8 @@ struct AddressOwnership {
   }
 
   /// Transitively compute uses of this base address.
-  bool findTransitiveUses(SmallVectorImpl<Operand *> &foundUses) {
-    return findTransitiveUsesForAddress(base.getBaseAddress(), foundUses);
+  AddressUseKind findTransitiveUses(SmallVectorImpl<Operand *> &foundUses) {
+    return findTransitiveUsesForAddress(base.getBaseAddress(), &foundUses);
   }
 
   /// Return true of all \p uses occur before the end of the address' lifetime

include/swift/SIL/SILValue.h

@@ -1058,6 +1058,12 @@ class Operand {
   /// Returns true if this ends the lifetime of an owned operand.
   bool isConsuming() const;
 
+  bool endsLocalBorrowScope() const {
+    auto ownership = getOperandOwnership();
+    return ownership == OperandOwnership::EndBorrow
+           || ownership == OperandOwnership::Reborrow;
+  }
+
   SILBasicBlock *getParentBlock() const;
   SILFunction *getParentFunction() const;
 

include/swift/SILOptimizer/Utils/InstOptUtils.h

@@ -647,13 +647,35 @@ FullApplySite cloneFullApplySiteReplacingCallee(FullApplySite applySite,
                                                 SILValue newCallee,
                                                 SILBuilderContext &builderCtx);
 
+/// Replace all uses of \p oldValue with \p newValue, notifying the callbacks
+/// of new uses and when end-of-scope instructions are deleted.
+SILBasicBlock::iterator replaceAllUses(SILValue oldValue, SILValue newValue,
+                                       SILBasicBlock::iterator nextii,
+                                       InstModCallbacks &callbacks);
+
 /// This is a low level routine that makes all uses of \p svi uses of \p
 /// newValue (ignoring end scope markers) and then deletes \p svi and all end
 /// scope markers. Then returns the next inst to process.
 SILBasicBlock::iterator replaceAllUsesAndErase(SingleValueInstruction *svi,
                                                SILValue newValue,
                                                InstModCallbacks &callbacks);
 
+/// Replace all uses of \p oldValue with \p newValue, delete the instruction
+/// that defines \p oldValue, and notify the callbacks of new uses and when
+/// the defining instruction and its end-of-scope instructions are deleted.
+///
+/// Precondition: \p oldValue must be a SingleValueInstruction or a terminator
+/// result. \p oldValue must be the only result with remaining uses. For
+/// terminators with multiple results, remove all other results for, e.g. via
+/// replaceAllUsesWithUndef().
+///
+/// If \p oldValue is a terminator result, a new branch instruction is inserted
+/// in place of the old terminator and all basic block successors become
+/// unreachable except for the successor containing the replaced result.
+SILBasicBlock::iterator replaceAllUsesAndErase(SILValue oldValue,
+                                               SILValue newValue,
+                                               InstModCallbacks &callbacks);
+
 /// This API is equivalent to performing \p use->set(\p newValue) except that:
 ///
 /// 1. If the user of \p use is an end scope, this API no-opts. This API is only

include/swift/SILOptimizer/Utils/OwnershipOptUtils.h

@@ -104,29 +104,46 @@ struct OwnershipFixupContext {
   }
 };
 
-/// A utility composed ontop of OwnershipFixupContext that knows how to RAUW a
+/// A utility composed on top of OwnershipFixupContext that knows how to RAUW a
 /// value or a single value instruction with a new value and then fixup
 /// ownership invariants afterwards.
 class OwnershipRAUWHelper {
+public:
+  /// Return true if \p oldValue can be replaced with \p newValue in terms of
+  /// their value ownership. This ignores any current uses of \p oldValue. To
+  /// determine whether \p oldValue can be replaced as-is with it's existing
+  /// uses, create an instance of OwnershipRAUWHelper and check its validity.
+  static bool hasValidRAUWOwnership(SILValue oldValue, SILValue newValue);
+
+private:
   OwnershipFixupContext *ctx;
-  SingleValueInstruction *oldValue;
+  SILValue oldValue;
   SILValue newValue;
 
 public:
-  OwnershipRAUWHelper() : ctx(nullptr), oldValue(nullptr), newValue(nullptr) {}
+  OwnershipRAUWHelper() : ctx(nullptr) {}
+
+  ~OwnershipRAUWHelper() { if (ctx) ctx->clear(); }
 
   /// Return an instance of this class if we can perform the specific RAUW
   /// operation ignoring if the types line up. Returns None otherwise.
   ///
+  /// \p oldValue may be either a SingleValueInstruction or a terminator result.
+  ///
+  /// Precondition: If \p oldValue is a BorrowedValue that introduces a local
+  /// borrow scope, then \p newValue must either be defined in the same block as
+  /// \p oldValue, or it must dominate \p oldValue (rather than merely
+  /// dominating its uses).
+  ///
   /// DISCUSSION: We do not check that the types line up here so that we can
   /// allow for our users to transform our new value in ways that preserve
   /// ownership at \p oldValue before we perform the actual RAUW. If \p newValue
   /// is an object, any instructions in the chain of transforming instructions
   /// from \p newValue at \p oldValue's must be forwarding. If \p newValue is an
   /// address, then these transforms can only transform the address into a
   /// derived address.
-  OwnershipRAUWHelper(OwnershipFixupContext &ctx,
-                      SingleValueInstruction *oldValue, SILValue newValue);
+  OwnershipRAUWHelper(OwnershipFixupContext &ctx, SILValue oldValue,
+                      SILValue newValue);
 
   /// Returns true if this helper was initialized into a valid state.
   operator bool() const { return isValid(); }
@@ -149,7 +166,6 @@ class OwnershipRAUWHelper {
                                              SILValue newValue);
 
   void invalidate() {
-    ctx->clear();
     ctx = nullptr;
   }
 };
@@ -158,6 +174,9 @@ class OwnershipRAUWHelper {
 /// a single use of a value with another value with a different ownership. We
 /// allow for the values to have different types.
 ///
+/// Precondition: if \p use ends a borrow scope, then \p newValue dominates the
+/// BorrowedValue that begins the scope.
+///
 /// NOTE: When not in OSSA, this just performs a normal set use, so this code is
 /// safe to use with all code.
 class OwnershipReplaceSingleUseHelper {
@@ -177,6 +196,8 @@ class OwnershipReplaceSingleUseHelper {
   OwnershipReplaceSingleUseHelper(OwnershipFixupContext &ctx, Operand *use,
                                   SILValue newValue);
 
+  ~OwnershipReplaceSingleUseHelper() { if (ctx) ctx->clear(); }
+
   /// Returns true if this helper was initialized into a valid state.
   operator bool() const { return isValid(); }
   bool isValid() const { return bool(ctx) && bool(use) && bool(newValue); }

lib/AST/DeclContext.cpp

@@ -867,6 +867,10 @@ void IterableDeclContext::addMemberSilently(Decl *member, Decl *hint,
       if (d->isImplicit())
         return true;
 
+      // Imported decls won't have complete location info.
+      if (d->hasClangNode())
+        return true;
+
       return false;
     };
 

lib/AST/NameLookup.cpp

@@ -1220,6 +1220,12 @@ void ExtensionDecl::addedMember(Decl *member) {
   }
 }
 
+void NominalTypeDecl::addMemberToLookupTable(Decl *member) {
+  prepareLookupTable();
+
+  LookupTable->addMember(member);
+}
+
 // For lack of anywhere more sensible to put it, here's a diagram of the pieces
 // involved in finding members and extensions of a NominalTypeDecl.
 //
@@ -1332,7 +1338,9 @@ void NominalTypeDecl::prepareLookupTable() {
   } else {
     LookupTable->addMembers(getMembers());
   }
+}
 
+void NominalTypeDecl::addLoadedExtensions() {
   for (auto e : getExtensions()) {
     // If we can lazy-load this extension, only take the members we've loaded
     // so far.
@@ -1424,10 +1432,10 @@ DirectLookupRequest::evaluate(Evaluator &evaluator,
 
   decl->prepareLookupTable();
 
-  // If we're allowed to load extensions, call prepareExtensions to ensure we
+  // If we're allowed to load extensions, call addLoadedExtensions to ensure we
   // properly invalidate the lazily-complete cache for any extensions brought in
   // by modules loaded after-the-fact. This can happen with the LLDB REPL.
-  decl->prepareExtensions();
+  decl->addLoadedExtensions();
 
   auto &Table = *decl->LookupTable;
   if (!useNamedLazyMemberLoading) {