Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

include/swift/AST/AvailabilityContext.h

@@ -71,14 +71,20 @@ class AvailabilityContext {
   /// Returns true if this context is deprecated on the current platform.
   bool isDeprecated() const;
 
+  /// Constrain with another `AvailabilityContext`.
+  void constrainWithContext(const AvailabilityContext &other, ASTContext &ctx);
+
+  /// Constrain with the availability attributes of `decl`.
+  void constrainWithDecl(const Decl *decl);
+
   /// Constrain the platform availability range with `platformRange`.
   void constrainWithPlatformRange(const AvailabilityRange &platformRange,
                                   ASTContext &ctx);
 
-  /// Constrain the platform availability range with both the availability
-  /// attributes of `decl` and with `platformRange`.
+  /// Constrain with the availability attributes of `decl`, intersecting the
+  /// platform range of `decl` with `platformRange`.
   void
-  constrainWithDeclAndPlatformRange(Decl *decl,
+  constrainWithDeclAndPlatformRange(const Decl *decl,
                                     const AvailabilityRange &platformRange);
 
   /// Returns true if `other` is as available or is more available.

include/swift/AST/AvailabilityContextStorage.h

@@ -40,8 +40,15 @@ struct AvailabilityContext::PlatformInfo {
   /// platform.
   unsigned IsDeprecated : 1;
 
-  /// Sets `Range` to `other` if `other` is more restrictive. Returns true if
-  /// any property changed as a result of adding this constraint.
+  /// Sets each field to the value of the corresponding field in `other` if the
+  /// other is more restrictive. Returns true if any field changed as a result
+  /// of adding this constraint.
+  bool constrainWith(const PlatformInfo &other);
+
+  /// Updates each field to reflect the availability of `decl`, if that
+  /// availability is more restrictive. Returns true if any field was updated.
+  bool constrainWith(const Decl *decl);
+
   bool constrainRange(const AvailabilityRange &other) {
     if (!other.isContainedIn(Range))
       return false;
@@ -50,19 +57,9 @@ struct AvailabilityContext::PlatformInfo {
     return true;
   }
 
-  /// Sets `Range` to the platform introduction range of `decl` if that range
-  /// is more restrictive. Returns true if
-  /// any property changed as a result of adding this constraint.
-  bool constrainRange(const Decl *decl);
-
-  /// Updates `UnavailablePlatform` and `IsUnavailable` to reflect the status
-  /// of `decl` if its platform unavailability is more restrictive. Returns
-  /// true if any property changed as a result of adding this constraint.
-  bool constrainUnavailability(const Decl *decl);
+  bool constrainUnavailability(std::optional<PlatformKind> unavailablePlatform);
 
-  /// If `decl` is deprecated, sets `IsDeprecated` to true. Returns true if
-  /// any property changed as a result of adding this constraint.
-  bool constrainDeprecated(const Decl *decl);
+  bool constrainDeprecated(bool deprecated);
 
   /// Returns true if `other` is as available or is more available.
   bool isContainedIn(const PlatformInfo &other) const;

include/swift/SIL/MemAccessUtils.h

@@ -1650,6 +1650,21 @@ inline bool isAccessStorageIdentityCast(SingleValueInstruction *svi) {
   }
 }
 
+// Strip access markers and casts that preserve the address type.
+//
+// Consider using RelativeAccessStorageWithBase::compute().
+inline SILValue stripAccessAndIdentityCasts(SILValue v) {
+  if (auto *bai = dyn_cast<BeginAccessInst>(v)) {
+    return stripAccessAndIdentityCasts(bai->getOperand());
+  }
+  if (auto *svi = dyn_cast<SingleValueInstruction>(v)) {
+    if (isAccessStorageIdentityCast(svi)) {
+      return stripAccessAndIdentityCasts(svi->getAllOperands()[0].get());
+    }
+  }
+  return v;
+}
+
 /// An address, pointer, or box cast that occurs outside of the formal
 /// access. These convert the base of accessed storage without affecting the
 /// AccessPath. Useful for both use-def and def-use traversal. The source

lib/AST/AvailabilityContext.cpp

@@ -18,37 +18,62 @@
 
 using namespace swift;
 
-bool AvailabilityContext::PlatformInfo::constrainRange(const Decl *decl) {
+bool AvailabilityContext::PlatformInfo::constrainWith(
+    const PlatformInfo &other) {
+  bool isConstrained = false;
+  isConstrained |= constrainRange(other.Range);
+  if (other.IsUnavailable) {
+    isConstrained |= constrainUnavailability(other.UnavailablePlatform);
+  }
+  isConstrained |= constrainDeprecated(other.IsDeprecated);
+
+  return isConstrained;
+}
+
+bool AvailabilityContext::PlatformInfo::constrainWith(const Decl *decl) {
+  bool isConstrained = false;
+  auto &ctx = decl->getASTContext();
+
   if (auto range = AvailabilityInference::annotatedAvailableRange(decl))
-    return constrainRange(*range);
+    isConstrained |= constrainRange(*range);
+
+  if (auto *attr = decl->getAttrs().getUnavailable(ctx))
+    isConstrained |= constrainUnavailability(attr->Platform);
+
+  if (!IsDeprecated)
+    isConstrained |= constrainDeprecated(decl->getAttrs().isDeprecated(ctx));
 
-  return false;
+  return isConstrained;
 }
 
 bool AvailabilityContext::PlatformInfo::constrainUnavailability(
-    const Decl *decl) {
-  auto &ctx = decl->getASTContext();
-  auto *attr = decl->getAttrs().getUnavailable(ctx);
-  if (!attr)
+    std::optional<PlatformKind> unavailablePlatform) {
+  if (!unavailablePlatform)
     return false;
 
-  // Check whether the decl's unavailability reason is the same.
-  if (IsUnavailable && UnavailablePlatform == attr->Platform)
-    return false;
+  if (IsUnavailable) {
+    // Universal unavailability cannot be refined.
+    if (UnavailablePlatform == PlatformKind::none)
+      return false;
 
-  // Check whether the decl's unavailability reason is more specific.
-  if (attr->Platform != PlatformKind::none &&
-      inheritsAvailabilityFromPlatform(attr->Platform, UnavailablePlatform))
-    return false;
+    // There's nothing to do if the platforms already match.
+    if (UnavailablePlatform == *unavailablePlatform)
+      return false;
+
+    // The new platform must be more restrictive.
+    if (*unavailablePlatform != PlatformKind::none &&
+        inheritsAvailabilityFromPlatform(*unavailablePlatform,
+                                         UnavailablePlatform))
+      return false;
+  }
 
   IsUnavailable = true;
-  UnavailablePlatform = attr->Platform;
+  UnavailablePlatform = *unavailablePlatform;
   return true;
 }
 
-bool AvailabilityContext::PlatformInfo::constrainDeprecated(const Decl *decl) {
-  auto &ctx = decl->getASTContext();
-  if (IsDeprecated || !decl->getAttrs().isDeprecated(ctx))
+bool AvailabilityContext::PlatformInfo::constrainDeprecated(bool deprecated) {
+  if (IsDeprecated || !deprecated)
     return false;
 
   IsDeprecated = true;
@@ -116,6 +141,18 @@ bool AvailabilityContext::isDeprecated() const {
   return Info->Platform.IsDeprecated;
 }
 
+void AvailabilityContext::constrainWithContext(const AvailabilityContext &other,
+                                               ASTContext &ctx) {
+  PlatformInfo platformAvailability{Info->Platform};
+  if (platformAvailability.constrainWith(other.Info->Platform)) {
+    Info = Storage::get(platformAvailability, ctx);
+  }
+}
+
+void AvailabilityContext::constrainWithDecl(const Decl *decl) {
+  constrainWithDeclAndPlatformRange(decl, AvailabilityRange::alwaysAvailable());
+}
+
 void AvailabilityContext::constrainWithPlatformRange(
     const AvailabilityRange &platformRange, ASTContext &ctx) {
   PlatformInfo platformAvailability{Info->Platform};
@@ -126,13 +163,11 @@ void AvailabilityContext::constrainWithPlatformRange(
 }
 
 void AvailabilityContext::constrainWithDeclAndPlatformRange(
-    Decl *decl, const AvailabilityRange &platformRange) {
+    const Decl *decl, const AvailabilityRange &platformRange) {
   PlatformInfo platformAvailability{Info->Platform};
   bool isConstrained = false;
-  isConstrained |= platformAvailability.constrainRange(decl);
+  isConstrained |= platformAvailability.constrainWith(decl);
   isConstrained |= platformAvailability.constrainRange(platformRange);
-  isConstrained |= platformAvailability.constrainUnavailability(decl);
-  isConstrained |= platformAvailability.constrainDeprecated(decl);
 
   if (!isConstrained)
     return;

lib/SILOptimizer/Mandatory/MoveOnlyAddressCheckerUtils.cpp

@@ -2379,7 +2379,7 @@ bool GatherUsesVisitor::visitUse(Operand *op) {
       if (moveChecker.canonicalizer.foundAnyConsumingUses()) {
         LLVM_DEBUG(llvm::dbgs()
                    << "Found mark must check [nocopy] error: " << *user);
-        auto operand = stripAccessMarkers(markedValue->getOperand());
+        auto operand = stripAccessAndIdentityCasts(markedValue->getOperand());
         auto *fArg = dyn_cast<SILFunctionArgument>(operand);
         auto *ptrToAddr = dyn_cast<PointerToAddressInst>(operand);
 

lib/SILOptimizer/Mandatory/MoveOnlyBorrowToDestructureUtils.cpp

@@ -1540,6 +1540,12 @@ static bool gatherBorrows(SILValue rootValue,
     // escape. Is it legal to canonicalize ForwardingUnowned?
     case OperandOwnership::ForwardingUnowned:
     case OperandOwnership::PointerEscape:
+      if (auto *md = dyn_cast<MarkDependenceInst>(use->getUser())) {
+        // mark_depenence uses only keep its base value alive; they do not use
+        // the base value itself and are irrelevant for destructuring.
+        if (use == &md->getOperandRef(MarkDependenceInst::Base))
+          continue;
+      }
       return false;
 
     case OperandOwnership::InstantaneousUse:

lib/SILOptimizer/Mandatory/MoveOnlyObjectCheckerUtils.cpp

@@ -219,15 +219,12 @@ bool MoveOnlyObjectCheckerPImpl::checkForSameInstMultipleUseErrors(
     case OperandOwnership::NonUse:
       continue;
 
-    // Conservatively treat a conversion to an unowned value as a pointer
-    // escape. If we see this in the SIL, fail and return false so we emit a
-    // "compiler doesn't understand error".
     case OperandOwnership::ForwardingUnowned:
     case OperandOwnership::PointerEscape:
     case OperandOwnership::BitwiseEscape:
-      LLVM_DEBUG(llvm::dbgs()
-                 << "        Found forwarding unowned or escape!\n");
-      return false;
+      // None of the "unowned" uses can consume the original value. Simply
+      // ignore them.
+      continue;
 
     case OperandOwnership::TrivialUse:
     case OperandOwnership::InstantaneousUse:

lib/SILOptimizer/Utils/VariableNameUtils.cpp

@@ -642,6 +642,7 @@ SILValue VariableNameInferrer::findDebugInfoProvidingValueHelper(
         isa<ProjectBoxInst>(searchValue) || isa<CopyValueInst>(searchValue) ||
         isa<ConvertFunctionInst>(searchValue) ||
         isa<MarkUninitializedInst>(searchValue) ||
+        isa<MarkDependenceInst>(searchValue) ||
         isa<CopyableToMoveOnlyWrapperAddrInst>(searchValue) ||
         isa<MoveOnlyWrapperToCopyableAddrInst>(searchValue) ||
         isa<MoveOnlyWrapperToCopyableValueInst>(searchValue) ||