Merge pull request #4231 from swiftwasm/main

Author: MaxDesiatov

docs/README.md

@@ -102,6 +102,8 @@ documentation, please create a thread on the Swift forums under the
 - [DependencyAnalysis.md](/docs/DependencyAnalysis.md):
   Describes different kinds of dependencies across files in the same module,
   important for understanding incremental builds.
+- [DifferentiableProgrammingImplementation.md](/docs/DifferentiableProgrammingImplementation.md):
+  Describes how automatic differentiation is implemented in the Swift compiler.
 - C and ObjC interoperability: Clang Importer and PrintAsClang
   - [CToSwiftNameTranslation.md](/docs/CToSwiftNameTranslation.md):
     Describes how C and ObjC entities are imported into Swift

include/swift/AST/Decl.h

@@ -5396,6 +5396,10 @@ class VarDecl : public AbstractStorageDecl {
   /// an attached property wrapper.
   VarDecl *getPropertyWrapperWrappedValueVar() const;
 
+  /// Return true if this property either has storage or has an attached property
+  /// wrapper that has storage.
+  bool hasStorageOrWrapsStorage() const;
+  
   /// Visit all auxiliary declarations to this VarDecl.
   ///
   /// An auxiliary declaration is a declaration synthesized by the compiler to support

include/swift/AST/DiagnosticsSema.def

@@ -2559,8 +2559,10 @@ WARNING(associated_type_override_typealias,none,
 
 ERROR(requirement_machine_completion_failed,none,
       "cannot build rewrite system for %select{generic signature|protocol}0; "
-      "%select{step|depth}1 limit exceeded",
+      "%select{%error|rule count|rule length|concrete nesting}1 limit exceeded",
       (unsigned, unsigned))
+NOTE(requirement_machine_completion_rule,none,
+     "failed rewrite rule is %0", (StringRef))
 
 ERROR(associated_type_objc,none,
       "associated type %0 cannot be declared inside '@objc' protocol %1",

include/swift/Basic/LangOptions.h

@@ -510,13 +510,17 @@ namespace swift {
     /// Enables fine-grained debug output from the requirement machine.
     std::string DebugRequirementMachine;
 
-    /// Maximum iteration count for requirement machine Knuth-Bendix completion
+    /// Maximum rule count for requirement machine Knuth-Bendix completion
     /// algorithm.
-    unsigned RequirementMachineStepLimit = 4000;
+    unsigned RequirementMachineMaxRuleCount = 4000;
 
     /// Maximum term length for requirement machine Knuth-Bendix completion
     /// algorithm.
-    unsigned RequirementMachineDepthLimit = 12;
+    unsigned RequirementMachineMaxRuleLength = 12;
+
+    /// Maximum concrete type nesting depth for requirement machine property map
+    /// algorithm.
+    unsigned RequirementMachineMaxConcreteNesting = 30;
 
     /// Enable the new experimental protocol requirement signature minimization
     /// algorithm.

include/swift/Option/FrontendOptions.td

@@ -343,13 +343,17 @@ def analyze_requirement_machine : Flag<["-"], "analyze-requirement-machine">,
   Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
   HelpText<"Print out requirement machine statistics at the end of the compilation job">;
 
-def requirement_machine_step_limit : Separate<["-"], "requirement-machine-step-limit">,
+def requirement_machine_max_rule_count : Joined<["-"], "requirement-machine-max-rule-count=">,
   Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
-  HelpText<"Set the maximum steps before we give up on confluent completion">;
+  HelpText<"Set the maximum number of rules before giving up">;
 
-def requirement_machine_depth_limit : Separate<["-"], "requirement-machine-depth-limit">,
+def requirement_machine_max_rule_length : Joined<["-"], "requirement-machine-max-rule-length=">,
   Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
-  HelpText<"Set the maximum depth before we give up on confluent completion">;
+  HelpText<"Set the maximum rule length before giving up">;
+
+def requirement_machine_max_concrete_nesting : Joined<["-"], "requirement-machine-max-concrete-nesting=">,
+  Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
+  HelpText<"Set the maximum concrete type nesting depth before giving up">;
 
 def disable_requirement_machine_merged_associated_types : Flag<["-"], "disable-requirement-machine-merged-associated-types">,
   Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,

include/swift/Runtime/Atomic.h

@@ -72,6 +72,13 @@ class alignas(Size) atomic_impl {
     return value.compare_exchange_weak(oldValue, newValue, successOrder,
                                        failureOrder);
   }
+
+  bool compare_exchange_strong(Value &oldValue, Value newValue,
+                               std::memory_order successOrder,
+                               std::memory_order failureOrder) {
+    return value.compare_exchange_strong(oldValue, newValue, successOrder,
+                                         failureOrder);
+  }
 };
 
 #if defined(_WIN64)
@@ -128,11 +135,14 @@ class alignas(2 * sizeof(void*)) atomic_impl<Value, 2 * sizeof(void*)> {
   bool compare_exchange_weak(Value &oldValue, Value newValue,
                              std::memory_order successOrder,
                              std::memory_order failureOrder) {
-    assert(failureOrder == std::memory_order_relaxed ||
-           failureOrder == std::memory_order_acquire ||
-           failureOrder == std::memory_order_consume);
-    assert(successOrder == std::memory_order_relaxed ||
-           successOrder == std::memory_order_release);
+    // We do not have weak CAS intrinsics, fallback to strong
+    return compare_exchange_strong(oldValue, newValue, successOrder,
+                                   failureOrder);
+  }
+
+  bool compare_exchange_strong(Value &oldValue, Value newValue,
+                               std::memory_order successOrder,
+                               std::memory_order failureOrder) {
 #if SWIFT_HAS_MSVC_ARM_ATOMICS
     if (successOrder == std::memory_order_relaxed &&
         failureOrder != std::memory_order_acquire) {
@@ -180,7 +190,7 @@ class alignas(2 * sizeof(void*)) atomic_impl<Value, 2 * sizeof(void*)> {
 template <class T>
 class atomic : public impl::atomic_impl<T> {
 public:
-  atomic(T value) : impl::atomic_impl<T>(value) {}
+  constexpr atomic(T value) : impl::atomic_impl<T>(value) {}
 };
 
 } // end namespace swift

include/swift/SILOptimizer/Utils/UpdatingInstructionIterator.h

@@ -169,31 +169,33 @@ class UpdatingInstructionIteratorRegistry {
   SmallVector<UpdatingInstructionIterator *, 4> forwardIterators;
   SmallVector<UpdatingReverseInstructionIterator *, 4> reverseIterators;
 
+  std::function<void(SILInstruction *)> chainedDelete;
+  std::function<void(SILInstruction *)> chainedNew;
+
   /// Callbacks used when adding/deleting instructions.
   InstModCallbacks callbacks;
 
-public:
-  UpdatingInstructionIteratorRegistry(
-      InstModCallbacks chainedCallbacks = InstModCallbacks()) {
-    rechainCallbacks(chainedCallbacks);
-  }
-
-  // The callbacks capture 'this'. So copying is invalid.
-  UpdatingInstructionIteratorRegistry(
-      const UpdatingInstructionIteratorRegistry &) = delete;
-
-  UpdatingInstructionIteratorRegistry &
-  operator=(const UpdatingInstructionIteratorRegistry &) = delete;
 
-  InstModCallbacks &getCallbacks() { return callbacks; }
+public:
+  UpdatingInstructionIteratorRegistry() :
+    callbacks(InstModCallbacks()
+                    .onDelete([this](SILInstruction *toDelete) {
+                      notifyDelete(toDelete);
+                      toDelete->eraseFromParent();
+                    })
+                    .onCreateNewInst(
+                        [this](SILInstruction *newlyCreatedInst) {
+                          notifyNew(newlyCreatedInst);
+                        }))
+  {}
 
-  void rechainCallbacks(InstModCallbacks chainedCallbacks) {
+  UpdatingInstructionIteratorRegistry(InstModCallbacks &&chainedCallbacks) :
     // Copy the two std::functions that we need. The rest of the callbacks are
     // copied implicitly by assignment.
-    auto chainedDelete = chainedCallbacks.deleteInstFunc;
-    auto chainedNew = chainedCallbacks.createdNewInstFunc;
-    callbacks = chainedCallbacks
-                    .onDelete([this, chainedDelete](SILInstruction *toDelete) {
+    chainedDelete(std::move(chainedCallbacks.deleteInstFunc)),
+    chainedNew(std::move(chainedCallbacks.createdNewInstFunc)),
+    callbacks(std::move(chainedCallbacks
+                    .onDelete([this](SILInstruction *toDelete) {
                       notifyDelete(toDelete);
                       if (chainedDelete) {
                         chainedDelete(toDelete);
@@ -202,13 +204,22 @@ class UpdatingInstructionIteratorRegistry {
                       toDelete->eraseFromParent();
                     })
                     .onCreateNewInst(
-                        [this, chainedNew](SILInstruction *newlyCreatedInst) {
+                        [this](SILInstruction *newlyCreatedInst) {
                           notifyNew(newlyCreatedInst);
                           if (chainedNew) {
                             chainedNew(newlyCreatedInst);
                           }
-                        });
-  }
+                        })))
+  {}
+
+  // The callbacks capture 'this'. So copying is invalid.
+  UpdatingInstructionIteratorRegistry(
+      const UpdatingInstructionIteratorRegistry &) = delete;
+
+  UpdatingInstructionIteratorRegistry &
+  operator=(const UpdatingInstructionIteratorRegistry &) = delete;
+
+  InstModCallbacks &getCallbacks() { return callbacks; }
 
   void registerIterator(UpdatingInstructionIterator *i) {
     forwardIterators.push_back(i);

lib/AST/CMakeLists.txt

@@ -91,6 +91,7 @@ add_swift_host_library(swiftAST STATIC
   RequirementMachine/RewriteSystem.cpp
   RequirementMachine/Symbol.cpp
   RequirementMachine/Term.cpp
+  RequirementMachine/TypeDifference.cpp
   SearchPathOptions.cpp
   SILLayout.cpp
   Stmt.cpp

lib/AST/Decl.cpp

@@ -6524,6 +6524,20 @@ VarDecl *VarDecl::getPropertyWrapperWrappedValueVar() const {
   return getPropertyWrapperAuxiliaryVariables().localWrappedValueVar;
 }
 
+bool VarDecl::hasStorageOrWrapsStorage() const {
+  if (hasStorage())
+    return true;
+  
+  if (getAttrs().hasAttribute<LazyAttr>())
+    return true;
+  
+  auto *backing = getPropertyWrapperBackingProperty();
+  if (backing && backing->hasStorage())
+    return true;
+  
+  return false;
+}
+
 void VarDecl::visitAuxiliaryDecls(llvm::function_ref<void(VarDecl *)> visit) const {
   if (getDeclContext()->isTypeContext() || isImplicit())
     return;

lib/AST/RequirementMachine/ConcreteTypeWitness.cpp

@@ -458,17 +458,17 @@ void PropertyMap::recordConcreteConformanceRule(
       /*ruleID=*/concreteRuleID,
       /*inverse=*/true));
 
-  // Apply a concrete type adjustment to the concrete symbol if T' is shorter
-  // than T.
+  // If T' is a suffix of T, prepend the prefix to the concrete type's
+  // substitutions.
   auto concreteSymbol = *concreteRule.isPropertyRule();
-  unsigned adjustment = rhs.size() - concreteRule.getRHS().size();
+  unsigned prefixLength = rhs.size() - concreteRule.getRHS().size();
 
-  if (adjustment > 0 &&
+  if (prefixLength > 0 &&
       !concreteConformanceSymbol.getSubstitutions().empty()) {
-    path.add(RewriteStep::forAdjustment(adjustment, /*endOffset=*/1,
-                                        /*inverse=*/false));
+    path.add(RewriteStep::forPrefixSubstitutions(prefixLength, /*endOffset=*/1,
+                                                 /*inverse=*/false));
 
-    MutableTerm prefix(rhs.begin(), rhs.begin() + adjustment);
+    MutableTerm prefix(rhs.begin(), rhs.begin() + prefixLength);
     concreteSymbol = concreteSymbol.prependPrefixToConcreteSubstitutions(
         prefix, Context);
   }