Merge pull request #2782 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

include/swift/AST/DiagnosticsSema.def

@@ -4316,24 +4316,45 @@ WARNING(non_concurrent_property_type,none,
         "cannot use %0 %1 with a non-concurrent-value type %2 "
         "%select{across actors|from concurrently-executed code}3",
         (DescriptiveDeclKind, DeclName, Type, bool))
+WARNING(non_concurrent_keypath_capture,none,
+        "cannot form key path that captures non-concurrent-value type %0",
+        (Type))
 ERROR(non_concurrent_type_member,none,
       "%select{stored property %1|associated value %1}0 of "
       "'ConcurrentValue'-conforming %2 %3 has non-concurrent-value type %4",
       (bool, DeclName, DescriptiveDeclKind, DeclName, Type))
+WARNING(non_concurrent_type_member_warn,none,
+      "%select{stored property %1|associated value %1}0 of "
+      "'ConcurrentValue'-conforming %2 %3 has non-concurrent-value type %4",
+      (bool, DeclName, DescriptiveDeclKind, DeclName, Type))
 ERROR(concurrent_value_class_mutable_property,none,
       "stored property %0 of 'ConcurrentValue'-conforming %1 %2 is mutable",
       (DeclName, DescriptiveDeclKind, DeclName))
+WARNING(concurrent_value_class_mutable_property_warn,none,
+      "stored property %0 of 'ConcurrentValue'-conforming %1 %2 is mutable",
+      (DeclName, DescriptiveDeclKind, DeclName))
 ERROR(concurrent_value_outside_source_file,none,
-      "conformance 'ConcurrentValue' must occur in the same source file as "
+      "conformance to 'ConcurrentValue' must occur in the same source file as "
+      "%0 %1; use 'UnsafeConcurrentValue' for retroactive conformance",
+      (DescriptiveDeclKind, DeclName))
+WARNING(concurrent_value_outside_source_file_warn,none,
+      "conformance to 'ConcurrentValue' must occur in the same source file as "
       "%0 %1; use 'UnsafeConcurrentValue' for retroactive conformance",
       (DescriptiveDeclKind, DeclName))
 ERROR(concurrent_value_open_class,none,
       "open class %0 cannot conform to `ConcurrentValue`; "
       "use `UnsafeConcurrentValue`", (DeclName))
+WARNING(concurrent_value_open_class_warn,none,
+      "open class %0 cannot conform to `ConcurrentValue`; "
+      "use `UnsafeConcurrentValue`", (DeclName))
 ERROR(concurrent_value_inherit,none,
       "`ConcurrentValue` class %1 cannot inherit from another class"
       "%select{| other than 'NSObject'}0",
       (bool, DeclName))
+WARNING(concurrent_value_inherit_warn,none,
+        "`ConcurrentValue` class %1 cannot inherit from another class"
+        "%select{| other than 'NSObject'}0",
+        (bool, DeclName))
 
 ERROR(actorindependent_let,none,
       "'@actorIndependent' is meaningless on 'let' declarations because "
@@ -5624,6 +5645,10 @@ ERROR(marker_protocol_inherit_nonmarker, none,
       (DeclName, DeclName))
 ERROR(marker_protocol_cast,none,
       "marker protocol %0 cannot be used in a conditional cast", (DeclName))
+ERROR(marker_protocol_conditional_conformance,none,
+      "conditional conformance to non-marker protocol %0 cannot depend on "
+      "conformance of %1 to non-marker protocol %2",
+      (Identifier, Type, Identifier))
 
 //------------------------------------------------------------------------------
 // MARK: differentiable programming diagnostics

include/swift/SILOptimizer/Analysis/EscapeAnalysis.h

@@ -989,8 +989,13 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
   /// The allocator for the connection graphs in Function2ConGraph.
   llvm::SpecificBumpPtrAllocator<FunctionInfo> Allocator;
 
+  // TODO: Use per-function caches, at least for Resilient types, to use Maximal
+  // expansion.
+
   /// Cache for isPointer().
   PointerKindCache pointerKindCache;
+  /// Cache for checking the aggregate pointerness of class properties.
+  PointerKindCache classPropertiesKindCache;
 
   SILModule *M;
 
@@ -1014,6 +1019,12 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
 
   PointerKind findCachedPointerKind(SILType Ty, const SILFunction &F) const;
 
+  PointerKind findClassPropertiesPointerKind(SILType Ty,
+                                             const SILFunction &F) const;
+
+  PointerKind findCachedClassPropertiesKind(SILType Ty,
+                                            const SILFunction &F) const;
+
   // Returns true if the type \p Ty must be a reference or must transitively
   // contain a reference and no other pointer or address type.
   bool hasReferenceOnly(SILType Ty, const SILFunction &F) const {
@@ -1114,6 +1125,10 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
   bool canEscapeToUsePoint(SILValue value, SILInstruction *usePoint,
                            ConnectionGraph *conGraph);
 
+  /// Common implementation for mayReleaseReferenceContent and
+  /// mayReleaseAddressContent.
+  bool mayReleaseContent(SILValue releasedPtr, SILValue liveAddress);
+
   friend struct ::CGForDotView;
 
 public:
@@ -1163,8 +1178,38 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
   bool canEscapeTo(SILValue V, DestroyValueInst *DVI);
 
   /// Return true if \p releasedReference deinitialization may release memory
-  /// pointed to by \p accessedAddress.
-  bool mayReleaseContent(SILValue releasedReference, SILValue accessedAddress);
+  /// pointed to by \p liveAddress.
+  ///
+  /// This determines whether a direct release of \p releasedReference, such as
+  /// destroy_value or strong_release may release memory pointed to by \p
+  /// liveAddress. It can also be used to determine whether passing a
+  /// reference-type call argument may release \p liveAddress.
+  ///
+  /// This does not distinguish between a call that releases \p
+  /// releasedReference directly, vs. a call that releases one of indirect
+  /// references.The side effects of releasing any object reachable from \p
+  /// releasedReference are a strict subset of the side effects of directly
+  /// releasing the parent reference.
+  bool mayReleaseReferenceContent(SILValue releasedReference,
+                                  SILValue liveAddress) {
+    assert(!releasedReference->getType().isAddress() &&
+           "expected a potentially nontrivial value, not an address");
+    return mayReleaseContent(releasedReference, liveAddress);
+  }
+
+  /// Return true if accessing memory at \p accessedAddress may release memory
+  /// pointed to by \p liveAddress.
+  ///
+  /// This makes sense for determining whether accessing indirect call argument
+  /// \p accessedAddress may release memory pointed to by \p liveAddress.
+  ///
+  /// "Access" to the memory can be any release of a reference pointed to by \p
+  /// accessedAddress, so '@in' and '@inout' are handled the same.
+  bool mayReleaseAddressContent(SILValue accessedAddress,
+                                SILValue liveAddress) {
+    assert(accessedAddress->getType().isAddress() && "expected an address");
+    return mayReleaseContent(accessedAddress, liveAddress);
+  }
 
   /// Returns true if the pointers \p V1 and \p V2 can possibly point to the
   /// same memory.

include/swift/SILOptimizer/Differentiation/ADContext.h

@@ -115,6 +115,8 @@ class ADContext {
   mutable FuncDecl *cachedPlusFn = nullptr;
   /// `AdditiveArithmetic.+=` declaration.
   mutable FuncDecl *cachedPlusEqualFn = nullptr;
+  /// `AdditiveArithmetic.zero` declaration.
+  mutable AccessorDecl *cachedZeroGetter = nullptr;
 
 public:
   /// Construct an ADContext for the given module.
@@ -201,6 +203,7 @@ class ADContext {
 
   FuncDecl *getPlusDecl() const;
   FuncDecl *getPlusEqualDecl() const;
+  AccessorDecl *getAdditiveArithmeticZeroGetter() const;
 
   /// Cleans up all the internal state.
   void cleanUp();
@@ -269,6 +272,10 @@ class ADContext {
                                 Diag<T...> diag, U &&... args);
 };
 
+raw_ostream &getADDebugStream();
+SILLocation getValidLocation(SILValue v);
+SILLocation getValidLocation(SILInstruction *inst);
+
 template <typename... T, typename... U>
 InFlightDiagnostic
 ADContext::emitNondifferentiabilityError(SILValue value,

include/swift/SILOptimizer/Differentiation/AdjointValue.h

@@ -51,29 +51,45 @@ class AdjointValueBase {
   /// The type of this value as if it were materialized as a SIL value.
   SILType type;
 
+  using DebugInfo = std::pair<SILDebugLocation, SILDebugVariable>;
+
+  /// The debug location and variable info associated with the original value.
+  Optional<DebugInfo> debugInfo;
+
   /// The underlying value.
   union Value {
-    llvm::ArrayRef<AdjointValue> aggregate;
+    unsigned numAggregateElements;
     SILValue concrete;
-    Value(llvm::ArrayRef<AdjointValue> v) : aggregate(v) {}
+    Value(unsigned numAggregateElements)
+        : numAggregateElements(numAggregateElements) {}
     Value(SILValue v) : concrete(v) {}
     Value() {}
   } value;
 
+  // Begins tail-allocated aggregate elements, if
+  // `kind == AdjointValueKind::Aggregate`.
+
   explicit AdjointValueBase(SILType type,
-                            llvm::ArrayRef<AdjointValue> aggregate)
-      : kind(AdjointValueKind::Aggregate), type(type), value(aggregate) {}
+                            llvm::ArrayRef<AdjointValue> aggregate,
+                            Optional<DebugInfo> debugInfo)
+      : kind(AdjointValueKind::Aggregate), type(type), debugInfo(debugInfo),
+        value(aggregate.size()) {
+    MutableArrayRef<AdjointValue> tailElements(
+        reinterpret_cast<AdjointValue *>(this + 1), aggregate.size());
+    std::uninitialized_copy(
+        aggregate.begin(), aggregate.end(), tailElements.begin());
+  }
 
-  explicit AdjointValueBase(SILValue v)
-      : kind(AdjointValueKind::Concrete), type(v->getType()), value(v) {}
+  explicit AdjointValueBase(SILValue v, Optional<DebugInfo> debugInfo)
+      : kind(AdjointValueKind::Concrete), type(v->getType()),
+        debugInfo(debugInfo), value(v) {}
 
-  explicit AdjointValueBase(SILType type)
-      : kind(AdjointValueKind::Zero), type(type) {}
+  explicit AdjointValueBase(SILType type, Optional<DebugInfo> debugInfo)
+      : kind(AdjointValueKind::Zero), type(type), debugInfo(debugInfo) {}
 };
 
-/// A symbolic adjoint value that is capable of representing zero value 0 and
-/// 1, in addition to a materialized SILValue. This is expected to be passed
-/// around by value in most cases, as it's two words long.
+/// A symbolic adjoint value that wraps a `SILValue`, a zero, or an aggregate
+/// thereof.
 class AdjointValue final {
 
 private:
@@ -85,26 +101,37 @@ class AdjointValue final {
   AdjointValueBase *operator->() const { return base; }
   AdjointValueBase &operator*() const { return *base; }
 
-  static AdjointValue createConcrete(llvm::BumpPtrAllocator &allocator,
-                                     SILValue value) {
-    return new (allocator.Allocate<AdjointValueBase>()) AdjointValueBase(value);
+  using DebugInfo = AdjointValueBase::DebugInfo;
+
+  static AdjointValue createConcrete(
+      llvm::BumpPtrAllocator &allocator, SILValue value,
+      Optional<DebugInfo> debugInfo = None) {
+    auto *buf = allocator.Allocate<AdjointValueBase>();
+    return new (buf) AdjointValueBase(value, debugInfo);
   }
 
-  static AdjointValue createZero(llvm::BumpPtrAllocator &allocator,
-                                 SILType type) {
-    return new (allocator.Allocate<AdjointValueBase>()) AdjointValueBase(type);
+  static AdjointValue createZero(
+      llvm::BumpPtrAllocator &allocator, SILType type,
+      Optional<DebugInfo> debugInfo = None) {
+    auto *buf = allocator.Allocate<AdjointValueBase>();
+    return new (buf) AdjointValueBase(type, debugInfo);
   }
 
-  static AdjointValue createAggregate(llvm::BumpPtrAllocator &allocator,
-                                      SILType type,
-                                      llvm::ArrayRef<AdjointValue> aggregate) {
-    return new (allocator.Allocate<AdjointValueBase>())
-        AdjointValueBase(type, aggregate);
+  static AdjointValue createAggregate(
+      llvm::BumpPtrAllocator &allocator, SILType type,
+      ArrayRef<AdjointValue> elements,
+      Optional<DebugInfo> debugInfo = None) {
+    AdjointValue *buf = reinterpret_cast<AdjointValue *>(allocator.Allocate(
+        sizeof(AdjointValueBase) + elements.size() * sizeof(AdjointValue),
+        alignof(AdjointValueBase)));
+    return new (buf) AdjointValueBase(type, elements, debugInfo);
   }
 
   AdjointValueKind getKind() const { return base->kind; }
   SILType getType() const { return base->type; }
   CanType getSwiftType() const { return getType().getASTType(); }
+  Optional<DebugInfo> getDebugInfo() const { return base->debugInfo; }
+  void setDebugInfo(DebugInfo debugInfo) const { base->debugInfo = debugInfo; }
 
   NominalTypeDecl *getAnyNominal() const {
     return getSwiftType()->getAnyNominal();
@@ -116,16 +143,18 @@ class AdjointValue final {
 
   unsigned getNumAggregateElements() const {
     assert(isAggregate());
-    return base->value.aggregate.size();
+    return base->value.numAggregateElements;
   }
 
   AdjointValue getAggregateElement(unsigned i) const {
-    assert(isAggregate());
-    return base->value.aggregate[i];
+    return getAggregateElements()[i];
   }
 
   llvm::ArrayRef<AdjointValue> getAggregateElements() const {
-    return base->value.aggregate;
+    assert(isAggregate());
+    return {
+        reinterpret_cast<const AdjointValue *>(base + 1),
+        getNumAggregateElements()};
   }
 
   SILValue getConcreteValue() const {
@@ -143,15 +172,15 @@ class AdjointValue final {
       if (auto *decl =
               getType().getASTType()->getStructOrBoundGenericStruct()) {
         interleave(
-            llvm::zip(decl->getStoredProperties(), base->value.aggregate),
+            llvm::zip(decl->getStoredProperties(), getAggregateElements()),
             [&s](std::tuple<VarDecl *, const AdjointValue &> elt) {
               s << std::get<0>(elt)->getName() << ": ";
               std::get<1>(elt).print(s);
             },
             [&s] { s << ", "; });
       } else if (getType().is<TupleType>()) {
         interleave(
-            base->value.aggregate,
+            getAggregateElements(),
             [&s](const AdjointValue &elt) { elt.print(s); },
             [&s] { s << ", "; });
       } else {

include/swift/SILOptimizer/Differentiation/Common.h

@@ -27,7 +27,9 @@
 #include "swift/SIL/TypeSubstCloner.h"
 #include "swift/SILOptimizer/Analysis/ArraySemantic.h"
 #include "swift/SILOptimizer/Analysis/DifferentiableActivityAnalysis.h"
+#include "swift/SILOptimizer/Differentiation/ADContext.h"
 #include "swift/SILOptimizer/Differentiation/DifferentiationInvoker.h"
+#include "swift/SILOptimizer/Differentiation/TangentBuilder.h"
 
 namespace swift {
 
@@ -142,6 +144,9 @@ template <class Inst> Inst *peerThroughFunctionConversions(SILValue value) {
   return nullptr;
 }
 
+Optional<std::pair<SILDebugLocation, SILDebugVariable>>
+findDebugLocationAndVariable(SILValue originalValue);
+
 //===----------------------------------------------------------------------===//
 // Diagnostic utilities
 //===----------------------------------------------------------------------===//
@@ -190,12 +195,6 @@ SILValue joinElements(ArrayRef<SILValue> elements, SILBuilder &builder,
 void extractAllElements(SILValue value, SILBuilder &builder,
                         SmallVectorImpl<SILValue> &results);
 
-/// Emit a zero value into the given buffer access by calling
-/// `AdditiveArithmetic.zero`. The given type must conform to
-/// `AdditiveArithmetic`.
-void emitZeroIntoBuffer(SILBuilder &builder, CanType type,
-                        SILValue bufferAccess, SILLocation loc);
-
 /// Emit a `Builtin.Word` value that represents the given type's memory layout
 /// size.
 SILValue emitMemoryLayoutSize(