Merge pull request #3682 from swiftwasm/main

Author: MaxDesiatov

CHANGELOG.md

@@ -6,6 +6,53 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 Swift 5.6
 ---------
 
+* References to `Self` or so-called "`Self` requirements" in the type signatures
+  of protocol members are now correctly detected in the parent of a nested type.
+  As a result, protocol members that fall under this overlooked case are no longer
+  available on values of protocol type:
+
+  ```swift
+  struct Outer<T> {
+    struct Inner {}
+  }
+
+  protocol P {}
+  extension P {
+    func method(arg: Outer<Self>.Inner) {}
+  }
+
+  func test(p: P) {
+    // error: 'method' has a 'Self' requirement and cannot be used on a value of
+    // protocol type (use a generic constraint instead).
+    _ = p.method
+  }
+  ``` 
+
+* [SE-0324][]:
+
+  Relax diagnostics for pointer arguments to C functions. The Swift
+  compiler now accepts limited pointer type mismatches when directly
+  calling functions imported from C as long as the C language allows
+  those pointer types to alias. Consequently, any Swift
+  `Unsafe[Mutable]Pointer<T>` or `Unsafe[Mutable]RawPointer` may be
+  passed to C function arguments declared as `[signed|unsigned] char
+  *`. Swift `Unsafe[Mutable]Pointer<T>` can also be passed to C
+  function arguments with an integer type that differs from `T` only
+  in its signedness.
+
+  For example, after importing a C function declaration:
+  ```c
+  long long decode_int64(const char *ptr_to_int64);
+  ```
+  Swift can now directly pass a raw pointer as the function argument:
+  ```swift
+  func decodeAsInt64(data: Data) -> Int64 {
+      data.withUnsafeBytes { (bytes: UnsafeRawBufferPointer) in
+          decode_int64(bytes.baseAddress!)
+      }
+  }
+  ```
+
 * [SE-0315][]:
 
   Type expressions and annotations can now include "type placeholders" which
@@ -8697,6 +8744,7 @@ Swift 1.0
 [SE-0313]: <https://github.com/apple/swift-evolution/blob/main/proposals/0313-actor-isolation-control.md>
 [SE-0315]: <https://github.com/apple/swift-evolution/blob/main/proposals/0315-placeholder-types.md>
 [SE-0316]: <https://github.com/apple/swift-evolution/blob/main/proposals/0316-global-actors.md>
+[SE-0324]: <https://github.com/apple/swift-evolution/blob/main/proposals/0324-c-lang-pointer-arg-conversion.md>
 
 [SR-75]: <https://bugs.swift.org/browse/SR-75>
 [SR-106]: <https://bugs.swift.org/browse/SR-106>

include/swift/AST/DiagnosticsSema.def

@@ -1954,6 +1954,15 @@ NOTE(non_sendable_nominal,none,
 NOTE(add_nominal_sendable_conformance,none,
      "consider making %0 %1 conform to the 'Sendable' protocol",
      (DescriptiveDeclKind, DeclName))
+WARNING(public_decl_needs_sendable,none,
+        "public %0 %1 does not specify whether it is 'Sendable' or not",
+        (DescriptiveDeclKind, DeclName))
+NOTE(explicit_unchecked_sendable,none,
+     "add '@unchecked Sendable' conformance to %0 %1 if this type manually implements concurrency safety",
+     (DescriptiveDeclKind, DeclName))
+NOTE(explicit_disable_sendable,none,
+     "make %0 %1 explicitly non-Sendable to suppress this warning",
+     (DescriptiveDeclKind, DeclName))
 
 NOTE(required_by_opaque_return,none,
     "required by opaque return type of %0 %1", (DescriptiveDeclKind, DeclName))

include/swift/Basic/LangOptions.h

@@ -147,6 +147,9 @@ namespace swift {
     /// Disable API availability checking.
     bool DisableAvailabilityChecking = false;
 
+    /// Only check the availability of the API, ignore function bodies.
+    bool CheckAPIAvailabilityOnly = false;
+
     /// Should conformance availability violations be diagnosed as errors?
     bool EnableConformanceAvailabilityErrors = false;
 
@@ -176,6 +179,9 @@ namespace swift {
     // Availability macros definitions to be expanded at parsing.
     SmallVector<std::string, 4> AvailabilityMacros;
 
+    /// Require public declarations to declare that they are Sendable (or not).
+    bool RequireExplicitSendable = false;
+
     /// If false, '#file' evaluates to the full path rather than a
     /// human-readable string.
     bool EnableConcisePoundFile = false;

include/swift/Option/FrontendOptions.td

@@ -465,6 +465,10 @@ def disable_availability_checking : Flag<["-"],
   "disable-availability-checking">,
   HelpText<"Disable checking for potentially unavailable APIs">;
 
+def check_api_availability_only : Flag<["-"],
+  "check-api-availability-only">,
+  HelpText<"Only check the availability of the APIs, ignore function bodies">;
+
 def enable_conformance_availability_errors : Flag<["-"],
   "enable-conformance-availability-errors">,
   HelpText<"Diagnose conformance availability violations as errors">;

include/swift/Option/Options.td

@@ -413,6 +413,10 @@ def require_explicit_availability_target : Separate<["-"], "require-explicit-ava
   HelpText<"Suggest fix-its adding @available(<target>, *) to public declarations without availability">,
   MetaVarName<"<target>">;
 
+def require_explicit_sendable : Flag<["-"], "require-explicit-sendable">,
+  Flags<[FrontendOption, NoInteractiveOption]>,
+  HelpText<"Require explicit Sendable annotations on public declarations">;
+
 def define_availability : Separate<["-"], "define-availability">,
   Flags<[FrontendOption, NoInteractiveOption]>,
   HelpText<"Define an availability macro in the format 'macroName : iOS 13.0, macOS 10.15'">,

include/swift/SIL/OwnershipUtils.h

@@ -15,9 +15,10 @@
 
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/LLVM.h"
+#include "swift/SIL/MemAccessUtils.h"
 #include "swift/SIL/SILArgument.h"
-#include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILBasicBlock.h"
+#include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILValue.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
@@ -29,6 +30,7 @@ class SILInstruction;
 class SILModule;
 class SILValue;
 class DeadEndBlocks;
+class PrunedLiveness;
 
 /// Returns true if v is an address or trivial.
 bool isValueAddressOrTrivial(SILValue v);
@@ -148,7 +150,7 @@ bool findTransitiveGuaranteedUses(SILValue guaranteedValue,
 /// 1. If \p guaranteedValue introduces a borrow scope (begin_borrow,
 /// load_borrow, or phi), then its only use points are the extended scope-ending
 /// uses, and this function returns true. This is, in fact, equivalent to
-/// calling BorrowedValue::visitExtendedLocalScopeEndingUses().
+/// calling BorrowedValue::visitExtendedScopeEndingUses().
 ///
 /// 2. If \p guaranteedValue does not introduce a borrow scope (it is not a
 /// valid BorrowedValue), then its uses are discovered transitively by looking
@@ -172,8 +174,8 @@ class ForwardingOperand {
     return use->getOwnershipConstraint();
   }
 
-  ValueOwnershipKind getOwnershipKind() const;
-  void setOwnershipKind(ValueOwnershipKind newKind) const;
+  ValueOwnershipKind getForwardingOwnershipKind() const;
+  void setForwardingOwnershipKind(ValueOwnershipKind newKind) const;
   void replaceOwnershipKind(ValueOwnershipKind oldKind,
                             ValueOwnershipKind newKind) const;
 
@@ -304,13 +306,20 @@ struct BorrowingOperand {
   /// visits the end of the introduced borrow scope.
   bool visitScopeEndingUses(function_ref<bool(Operand *)> func) const;
 
+  /// Returns true for borrows that create a local borrow scope but have no
+  /// scope-ending uses (presumably all paths are dead-end blocks). This does
+  /// not include instantaneous borrows, which don't require explicit scope
+  /// ending uses.
+  ///
+  /// FIXME: Borrow scopes should have scope-ending uses on all paths, even to
+  /// dead end blocks. When the verifier enforces this, remove this check.
+  bool hasEmptyRequiredEndingUses() const;
+
   /// Visit the scope ending operands of the extended scope, after transitively
   /// searching through reborrows. These uses might not be dominated by this
   /// BorrowingOperand.
   ///
   /// Returns false and early exits if the visitor \p func returns false.
-  ///
-  /// Note: this does not visit the intermediate reborrows.
   bool visitExtendedScopeEndingUses(function_ref<bool(Operand *)> func) const;
 
   /// Returns true if this borrow scope operand consumes guaranteed
@@ -493,7 +502,7 @@ struct InteriorPointerOperand;
 /// jointly post-dominate this value (see visitLocalScopeEndingUses()). The
 /// extended scope, including reborrows has end points that are not dominated by
 /// this value but still jointly post-dominate (see
-/// visitExtendedLocalScopeEndingUses()).
+/// visitExtendedScopeEndingUses()).
 struct BorrowedValue {
   SILValue value;
   BorrowedValueKind kind = BorrowedValueKind::Invalid;
@@ -535,20 +544,25 @@ struct BorrowedValue {
 
   bool isLocalScope() const { return kind.isLocalScope(); }
 
-  /// Returns true if the passed in set of uses is completely within
-  /// the lifetime of this borrow introducer.
+  /// Add this scopes live blocks into the PrunedLiveness result.
+  void computeLiveness(PrunedLiveness &liveness) const;
+
+  /// Returns true if \p uses are completely within this borrow introducer's
+  /// local scope.
   ///
-  /// NOTE: Scratch space is used internally to this method to store the end
-  /// borrow scopes if needed.
-  bool areUsesWithinScope(ArrayRef<Operand *> uses,
-                          SmallVectorImpl<Operand *> &scratchSpace,
-                          DeadEndBlocks &deadEndBlocks) const;
+  /// Precondition: \p uses are dominated by the local borrow introducer.
+  ///
+  /// This ignores reborrows. The assumption is that, since \p uses are
+  /// dominated by this local scope, checking the extended borrow scope should
+  /// not be necessary to determine they are within the scope.
+  bool areUsesWithinLocalScope(ArrayRef<Operand *> uses,
+                               DeadEndBlocks &deadEndBlocks) const;
 
   /// Given a local borrow scope introducer, visit all non-forwarding consuming
   /// users. This means that this looks through guaranteed block arguments. \p
   /// visitor is *not* called on Reborrows, only on final scope ending uses.
-  bool visitExtendedLocalScopeEndingUses(
-      function_ref<bool(Operand *)> visitor) const;
+  bool
+  visitExtendedScopeEndingUses(function_ref<bool(Operand *)> visitor) const;
 
   void print(llvm::raw_ostream &os) const;
   SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }
@@ -583,6 +597,14 @@ struct BorrowedValue {
         func, InteriorPointerOperandVisitorKind::YesNestedYesReborrows);
   }
 
+  bool hasReborrow() const {
+    for (auto *op : value->getUses()) {
+      if (op->getOperandOwnership() == OperandOwnership::Reborrow)
+        return true;
+    }
+    return false;
+  }
+
   /// Visit all immediate uses of this borrowed value and if any of them are
   /// reborrows, place them in BorrowingOperand form into \p
   /// foundReborrows. Returns true if we appended any such reborrows to
@@ -591,12 +613,10 @@ struct BorrowedValue {
                            &foundReborrows) const {
     bool foundAnyReborrows = false;
     for (auto *op : value->getUses()) {
-      if (auto borrowingOperand = BorrowingOperand(op)) {
-        if (borrowingOperand.isReborrow()) {
-          foundReborrows.push_back(
-              {value->getParentBlock(), op->getOperandNumber()});
-          foundAnyReborrows = true;
-        }
+      if (op->getOperandOwnership() == OperandOwnership::Reborrow) {
+        foundReborrows.push_back(
+            {value->getParentBlock(), op->getOperandNumber()});
+        foundAnyReborrows = true;
       }
     }
     return foundAnyReborrows;
@@ -642,6 +662,13 @@ bool getAllBorrowIntroducingValues(SILValue value,
 /// introducer, then we return a .some(BorrowScopeIntroducingValue).
 BorrowedValue getSingleBorrowIntroducingValue(SILValue inputValue);
 
+/// 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);
+
 class InteriorPointerOperandKind {
 public:
   enum Kind : uint8_t {
@@ -785,7 +812,7 @@ struct InteriorPointerOperand {
   }
 
   /// Return the base BorrowedValue of the incoming value's operand.
-  BorrowedValue getSingleBaseValue() const {
+  BorrowedValue getSingleBorrowedValue() const {
     return getSingleBorrowIntroducingValue(operand->get());
   }
 
@@ -820,14 +847,6 @@ struct InteriorPointerOperand {
                                         onError);
   }
 
-  /// 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.
-  static bool
-  findTransitiveUsesForAddress(SILValue address,
-                               SmallVectorImpl<Operand *> &foundUses,
-                               std::function<void(Operand *)> *onError = nullptr);
-
   Operand *operator->() { return operand; }
   const Operand *operator->() const { return operand; }
   Operand *operator*() { return operand; }
@@ -840,23 +859,70 @@ struct InteriorPointerOperand {
       : operand(op), kind(kind) {}
 };
 
-/// Utility to check if an address may originate from a borrowed value. If so,
+/// Utility to check if an address may originate from an OSSA value. If so,
 /// then uses of the address cannot be replaced without ensuring that they are
-/// also within the same scope.
+/// also within the same owned lifetime or borrow scope.
 ///
-/// If mayBeBorrowed is false, then there is no enclosing borrow scope and
-/// interiorPointerOp is irrelevant.
+/// If hasOwnership() is false, then there is no enclosing lifetime or borrow
+/// scope and interiorPointerOp is irrelevant.
 ///
-/// If mayBeBorrowed is true, then interiorPointerOp refers to the operand that
+/// If hasOwnership() is true, then interiorPointerOp refers to the operand that
 /// converts a non-address value into the address from which the contructor's
 /// address is derived. If the best-effort to find an InteriorPointerOperand
 /// fails, then interiorPointerOp remains invalid, and clients must be
 /// conservative.
-struct BorrowedAddress {
-  bool mayBeBorrowed = true;
-  InteriorPointerOperand interiorPointerOp;
+///
+/// TODO: Handle implicit borrow scopes once they are legal in SIL. The operand
+/// of the base will be owned but mayBeBorrowed will remain true.
+struct AddressOwnership {
+  AccessBase base;
+
+  AddressOwnership() = default;
+
+  AddressOwnership(SILValue address) : base(AccessBase::compute(address)) {
+    assert(address->getType().isAddress());
+  }
+
+  AddressOwnership(AccessBase base) : base(base) {}
+
+  operator bool() const { return bool(base); }
+
+  bool operator==(const AddressOwnership &other) const {
+    return base.hasIdenticalAccessInfo(other.base);
+  }
+
+  bool operator!=(const AddressOwnership &other) const {
+    return !(*this == other);
+  }
 
-  BorrowedAddress(SILValue address);
+  /// Return true if this address may be derived from a value with a local OSSA
+  /// lifetime or borrow scope.
+  bool hasLocalOwnershipLifetime() const {
+    return base.hasLocalOwnershipLifetime();
+  }
+
+  /// Return the OSSA value from which this address is derived. This may be
+  /// invalid even if hasOSSALifetime() is true in cases where the
+  /// InteriorPointerOperand is unrecognized.
+  SILValue getOwnershipReferenceRoot() const {
+    if (base.isReference())
+      return base.getOwnershipReferenceRoot();
+
+    return SILValue();
+  }
+
+  /// Transitively compute uses of this base address.
+  bool findTransitiveUses(SmallVectorImpl<Operand *> &foundUses) {
+    return findTransitiveUsesForAddress(base.getBaseAddress(), foundUses);
+  }
+
+  /// Return true of all \p uses occur before the end of the address' lifetime
+  /// or borrow scope.
+  ///
+  /// Precondition: all \p uses are dominated by the beginning of the address'
+  /// lifetime or borrow scope.
+  bool areUsesWithinLifetime(ArrayRef<Operand *> uses,
+                             DeadEndBlocks &deadEndBlocks) const;
 };
 
 class OwnedValueIntroducerKind {