[pull] swiftwasm from main

docs/ABI/Mangling.rst

@@ -570,19 +570,19 @@ Types
                                              // they are mangled separately as part of the entity.
   params-type ::= empty-list                 // shortcut for no parameters
 
-  sendable ::= 'J'                           // @Sendable on function types
-  async ::= 'Y'                              // 'async' annotation on function types
+  async ::= 'Ya'                             // 'async' annotation on function types
+  sendable ::= 'Yb'                          // @Sendable on function types
   throws ::= 'K'                             // 'throws' annotation on function types
-  differentiable ::= 'jf'                    // @differentiable(_forward) on function type
-  differentiable ::= 'jr'                    // @differentiable(reverse) on function type
-  differentiable ::= 'jd'                    // @differentiable on function type
-  differentiable ::= 'jl'                    // @differentiable(_linear) on function type
+  differentiable ::= 'Yjf'                   // @differentiable(_forward) on function type
+  differentiable ::= 'Yjr'                   // @differentiable(reverse) on function type
+  differentiable ::= 'Yjd'                   // @differentiable on function type
+  differentiable ::= 'Yjl'                   // @differentiable(_linear) on function type
 
   type-list ::= list-type '_' list-type*     // list of types
   type-list ::= empty-list
 
                                                   // FIXME: Consider replacing 'h' with a two-char code
-  list-type ::= type identifier? 'z'? 'h'? 'n'? 'd'?   // type with optional label, inout convention, shared convention, owned convention, and variadic specifier
+  list-type ::= type identifier? 'Yk'? 'z'? 'h'? 'n'? 'd'?  // type with optional label, '@noDerivative', inout convention, shared convention, owned convention, and variadic specifier
 
   METATYPE-REPR ::= 't'                      // Thin metatype representation
   METATYPE-REPR ::= 'T'                      // Thick metatype representation
@@ -666,7 +666,7 @@ mangled in to disambiguate.
   COROUTINE-KIND ::= 'A'                     // yield-once coroutine
   COROUTINE-KIND ::= 'G'                     // yield-many coroutine
 
-  SENDABLE ::= 'h'                         // @Sendable
+  SENDABLE ::= 'h'                           // @Sendable
   ASYNC ::= 'H'                              // @async
 
   PARAM-CONVENTION ::= 'i'                   // indirect in

include/swift/AST/Attr.h

@@ -2324,8 +2324,6 @@ class TypeAttributes {
 
   Optional<Convention> ConventionArguments;
 
-  // Indicates whether the type's '@differentiable' attribute has a 'linear'
-  // argument.
   DifferentiabilityKind differentiabilityKind =
       DifferentiabilityKind::NonDifferentiable;
 

include/swift/AST/GenericSignatureBuilder.h

@@ -654,7 +654,7 @@ class GenericSignatureBuilder {
 
   class ExplicitRequirement;
 
-  bool isRedundantExplicitRequirement(ExplicitRequirement req) const;
+  bool isRedundantExplicitRequirement(const ExplicitRequirement &req) const;
 
 private:
   void computeRedundantRequirements();

include/swift/AST/Types.h

@@ -1929,7 +1929,7 @@ class ParameterTypeFlags {
     NonEphemeral = 1 << 2,
     OwnershipShift = 3,
     Ownership    = 7 << OwnershipShift,
-    NoDerivative = 1 << 7,
+    NoDerivative = 1 << 6,
     NumBits = 7
   };
   OptionSet<ParameterFlags> value;

include/swift/Demangling/DemangleNodes.def

@@ -312,6 +312,7 @@ NODE(AutoDiffSelfReorderingReabstractionThunk)
 NODE(AutoDiffSubsetParametersThunk)
 NODE(AutoDiffDerivativeVTableThunk)
 NODE(DifferentiabilityWitness)
+NODE(NoDerivative)
 NODE(IndexSubset)
 NODE(AsyncAwaitResumePartialFunction)
 NODE(AsyncSuspendResumePartialFunction)

include/swift/Demangling/Demangler.h

@@ -569,6 +569,8 @@ class Demangler : public NodeFactory {
 
   NodePointer demangleTypeMangling();
   NodePointer demangleSymbolicReference(unsigned char rawKind);
+  NodePointer demangleTypeAnnotation();
+
   NodePointer demangleAutoDiffFunctionOrSimpleThunk(Node::Kind nodeKind);
   NodePointer demangleAutoDiffFunctionKind();
   NodePointer demangleAutoDiffSubsetParametersThunk();

include/swift/Demangling/TypeDecoder.h

@@ -72,6 +72,7 @@ class FunctionParam {
   void setValueOwnership(ValueOwnership ownership) {
     Flags = Flags.withValueOwnership(ownership);
   }
+  void setNoDerivative() { Flags = Flags.withNoDerivative(true); }
   void setFlags(ParameterFlags flags) { Flags = flags; };
 
   FunctionParam withLabel(StringRef label) const {
@@ -737,27 +738,6 @@ class TypeDecoder {
         ++firstChildIdx;
       }
 
-      bool isThrow = false;
-      if (Node->getChild(firstChildIdx)->getKind()
-            == NodeKind::ThrowsAnnotation) {
-        isThrow = true;
-        ++firstChildIdx;
-      }
-
-      bool isSendable = false;
-      if (Node->getChild(firstChildIdx)->getKind()
-            == NodeKind::ConcurrentFunctionType) {
-        isSendable = true;
-        ++firstChildIdx;
-      }
-
-      bool isAsync = false;
-      if (Node->getChild(firstChildIdx)->getKind()
-            == NodeKind::AsyncAnnotation) {
-        isAsync = true;
-        ++firstChildIdx;
-      }
-
       FunctionMetadataDifferentiabilityKind diffKind;
       if (Node->getChild(firstChildIdx)->getKind() ==
             NodeKind::DifferentiableFunctionType) {
@@ -783,6 +763,27 @@ class TypeDecoder {
         ++firstChildIdx;
       }
 
+      bool isThrow = false;
+      if (Node->getChild(firstChildIdx)->getKind()
+            == NodeKind::ThrowsAnnotation) {
+        isThrow = true;
+        ++firstChildIdx;
+      }
+
+      bool isSendable = false;
+      if (Node->getChild(firstChildIdx)->getKind()
+            == NodeKind::ConcurrentFunctionType) {
+        isSendable = true;
+        ++firstChildIdx;
+      }
+
+      bool isAsync = false;
+      if (Node->getChild(firstChildIdx)->getKind()
+            == NodeKind::AsyncAnnotation) {
+        isAsync = true;
+        ++firstChildIdx;
+      }
+
       flags = flags.withConcurrent(isSendable)
           .withAsync(isAsync).withThrows(isThrow)
           .withDifferentiable(diffKind.isDifferentiable());
@@ -1370,33 +1371,44 @@ class TypeDecoder {
             FunctionParam<BuiltType> &param) -> bool {
       Demangle::NodePointer node = typeNode;
 
-      auto setOwnership = [&](ValueOwnership ownership) {
-        param.setValueOwnership(ownership);
-        node = node->getFirstChild();
-        hasParamFlags = true;
-      };
-      switch (node->getKind()) {
-      case NodeKind::InOut:
-        setOwnership(ValueOwnership::InOut);
-        break;
+      bool recurse = true;
+      while (recurse) {
+        switch (node->getKind()) {
+        case NodeKind::InOut:
+          param.setValueOwnership(ValueOwnership::InOut);
+          node = node->getFirstChild();
+          hasParamFlags = true;
+          break;
 
-      case NodeKind::Shared:
-        setOwnership(ValueOwnership::Shared);
-        break;
+        case NodeKind::Shared:
+          param.setValueOwnership(ValueOwnership::Shared);
+          node = node->getFirstChild();
+          hasParamFlags = true;
+          break;
 
-      case NodeKind::Owned:
-        setOwnership(ValueOwnership::Owned);
-        break;
+        case NodeKind::Owned:
+          param.setValueOwnership(ValueOwnership::Owned);
+          node = node->getFirstChild();
+          hasParamFlags = true;
+          break;
 
-      case NodeKind::AutoClosureType:
-      case NodeKind::EscapingAutoClosureType: {
-        param.setAutoClosure();
-        hasParamFlags = true;
-        break;
-      }
+        case NodeKind::NoDerivative:
+          param.setNoDerivative();
+          node = node->getFirstChild();
+          hasParamFlags = true;
+          break;
 
-      default:
-        break;
+        case NodeKind::AutoClosureType:
+        case NodeKind::EscapingAutoClosureType:
+          param.setAutoClosure();
+          hasParamFlags = true;
+          recurse = false;
+          break;
+
+        default:
+          recurse = false;
+          break;
+        }
       }
 
       auto paramType = decodeMangledType(node);

include/swift/Frontend/Frontend.h

@@ -204,6 +204,12 @@ class CompilerInvocation {
 
   void setRuntimeResourcePath(StringRef Path);
 
+  /// Compute the default prebuilt module cache path for a given resource path
+  /// and SDK version. This function is also used by LLDB.
+  static std::string
+  computePrebuiltCachePath(StringRef RuntimeResourcePath, llvm::Triple target,
+                           Optional<llvm::VersionTuple> sdkVer);
+
   /// If we haven't explicitly passed -prebuilt-module-cache-path, set it to
   /// the default value of <resource-dir>/<platform>/prebuilt-modules.
   /// @note This should be called once, after search path options and frontend

lib/AST/ASTMangler.cpp

@@ -2448,25 +2448,25 @@ void ASTMangler::appendFunctionSignature(AnyFunctionType *fn,
   appendFunctionResultType(fn->getResult(), forDecl);
   appendFunctionInputType(fn->getParams(), forDecl);
   if (fn->isAsync() || functionMangling == AsyncHandlerBodyMangling)
-    appendOperator("Y");
+    appendOperator("Ya");
   if (fn->isSendable())
-    appendOperator("J");
+    appendOperator("Yb");
   if (fn->isThrowing())
     appendOperator("K");
   switch (auto diffKind = fn->getDifferentiabilityKind()) {
   case DifferentiabilityKind::NonDifferentiable:
     break;
   case DifferentiabilityKind::Forward:
-    appendOperator("jf");
+    appendOperator("Yjf");
     break;
   case DifferentiabilityKind::Reverse:
-    appendOperator("jr");
+    appendOperator("Yjr");
     break;
   case DifferentiabilityKind::Normal:
-    appendOperator("jd");
+    appendOperator("Yjd");
     break;
   case DifferentiabilityKind::Linear:
-    appendOperator("jl");
+    appendOperator("Yjl");
     break;
   }
 }
@@ -2541,6 +2541,9 @@ void ASTMangler::appendTypeListElement(Identifier name, Type elementType,
   else
     appendType(elementType, forDecl);
 
+  if (flags.isNoDerivative()) {
+    appendOperator("Yk");
+  }
   switch (flags.getValueOwnership()) {
   case ValueOwnership::Default:
     /* nothing */