Merge pull request #2959 from swiftwasm/main

[pull] swiftwasm from main

Author: MaxDesiatov

docs/ABI/Mangling.rst

@@ -514,13 +514,17 @@ Types
 
   type ::= 'Bb'                              // Builtin.BridgeObject
   type ::= 'BB'                              // Builtin.UnsafeValueBuffer
-  type ::= 'Bc'                              // Builtin.RawUnsafeContinuation
-  type ::= 'BD'                              // Builtin.DefaultActorStorage
-  type ::= 'Be'                              // Builtin.Executor
+  #if SWIFT_RUNTIME_VERSION >= 5.5
+    type ::= 'Bc'                              // Builtin.RawUnsafeContinuation
+    type ::= 'BD'                              // Builtin.DefaultActorStorage
+    type ::= 'Be'                              // Builtin.Executor
+  #endif
   type ::= 'Bf' NATURAL '_'                  // Builtin.Float<n>
   type ::= 'Bi' NATURAL '_'                  // Builtin.Int<n>
   type ::= 'BI'                              // Builtin.IntLiteral
-  type ::= 'Bj'                              // Builtin.Job
+  #if SWIFT_RUNTIME_VERSION >= 5.5
+    type ::= 'Bj'                              // Builtin.Job
+  #endif
   type ::= 'BO'                              // Builtin.UnknownObject (no longer a distinct type, but still used for AnyObject)
   type ::= 'Bo'                              // Builtin.NativeObject
   type ::= 'Bp'                              // Builtin.RawPointer
@@ -570,8 +574,10 @@ Types
                                              // they are mangled separately as part of the entity.
   params-type ::= empty-list                 // shortcut for no parameters
 
-  async ::= 'Ya'                             // 'async' annotation on function types
-  sendable ::= 'Yb'                          // @Sendable on function types
+  #if SWIFT_RUNTIME_VERSION >= 5.5
+    async ::= 'Ya'                             // 'async' annotation on function types
+    sendable ::= 'Yb'                          // @Sendable on function types
+  #endif
   throws ::= 'K'                             // 'throws' annotation on function types
   differentiable ::= 'Yjf'                   // @differentiable(_forward) on function type
   differentiable ::= 'Yjr'                   // @differentiable(reverse) on function type
@@ -666,8 +672,10 @@ mangled in to disambiguate.
   COROUTINE-KIND ::= 'A'                     // yield-once coroutine
   COROUTINE-KIND ::= 'G'                     // yield-many coroutine
 
-  SENDABLE ::= 'h'                           // @Sendable
-  ASYNC ::= 'H'                              // @async
+  #if SWIFT_RUNTIME_VERSION >= 5.5
+    SENDABLE ::= 'h'                           // @Sendable
+    ASYNC ::= 'H'                              // @async
+  #endif
 
   PARAM-CONVENTION ::= 'i'                   // indirect in
   PARAM-CONVENTION ::= 'c'                   // indirect in constant

include/swift/Option/Options.td

@@ -187,7 +187,8 @@ def help_hidden : Flag<["-", "--"], "help-hidden">,
   Flags<[HelpHidden, FrontendOption]>,
   HelpText<"Display available options, including hidden options">;
 
-def v : Flag<["-"], "v">, Flags<[DoesNotAffectIncrementalBuild]>,
+def v : Flag<["-"], "v">,
+  Flags<[DoesNotAffectIncrementalBuild, SwiftSymbolGraphExtractOption]>,
   HelpText<"Show commands to run and use verbose output">;
 def version : Flag<["-", "--"], "version">, Flags<[FrontendOption]>,
   HelpText<"Print version information and exit">;

include/swift/Runtime/BuiltinTypes.def

@@ -60,6 +60,11 @@ BUILTIN_TYPE(BB, "Builtin.UnsafeValueBuffer")
 // shaped like AnyObject (normal mangling yXl).
 BUILTIN_POINTER_TYPE(BO, "Builtin.UnknownObject")
 
+BUILTIN_POINTER_TYPE(Bc, "Builtin.RawUnsafeContinuation")
+BUILTIN_TYPE(BD, "Builtin.DefaultActorStorage")
+BUILTIN_TYPE(Be, "Builtin.Executor")
+BUILTIN_POINTER_TYPE(Bj, "Builtin.Job")
+
 // Int8 vector types
 BUILTIN_VECTOR_TYPE(Bi8_, Int8, 2)
 BUILTIN_VECTOR_TYPE(Bi8_, Int8, 3)

include/swift/Runtime/Concurrent.h

@@ -416,6 +416,35 @@ class ConcurrentMap
   }
 };
 
+/// A simple linked list representing pointers that need to be freed. This is
+/// not a concurrent data structure, just a bit of support used in the types
+/// below.
+struct ConcurrentFreeListNode {
+  ConcurrentFreeListNode *Next;
+  void *Ptr;
+
+  static void add(ConcurrentFreeListNode **head, void *ptr) {
+    auto *newNode = reinterpret_cast<ConcurrentFreeListNode *>(
+        malloc(sizeof(ConcurrentFreeListNode)));
+    newNode->Next = *head;
+    newNode->Ptr = ptr;
+    *head = newNode;
+  }
+
+  /// Free all nodes in the free list, resetting `head` to `NULL`. Calls
+  /// `FreeFn` on the Ptr field of every node.
+  template <typename FreeFn>
+  static void freeAll(ConcurrentFreeListNode **head, const FreeFn &freeFn) {
+    auto *node = *head;
+    while (node) {
+      auto *next = node->Next;
+      freeFn(node->Ptr);
+      free(node);
+      node = next;
+    }
+    *head = nullptr;
+  }
+};
 
 /// An append-only array that can be read without taking locks. Writes
 /// are still locked and serialized, but only with respect to other
@@ -454,8 +483,8 @@ template <class ElemTy> struct ConcurrentReadableArray {
   std::atomic<size_t> ReaderCount;
   std::atomic<Storage *> Elements;
   Mutex WriterLock;
-  std::vector<Storage *> FreeList;
-  
+  ConcurrentFreeListNode *FreeList{nullptr};
+
   void incrementReaders() {
     ReaderCount.fetch_add(1, std::memory_order_acquire);
   }
@@ -465,10 +494,9 @@ template <class ElemTy> struct ConcurrentReadableArray {
   }
 
   void deallocateFreeList() {
-    for (Storage *storage : FreeList)
-      storage->deallocate();
-    FreeList.clear();
-    FreeList.shrink_to_fit();
+    ConcurrentFreeListNode::freeAll(&FreeList, [](void *ptr) {
+      reinterpret_cast<Storage *>(ptr)->deallocate();
+    });
   }
 
 public:
@@ -522,7 +550,7 @@ template <class ElemTy> struct ConcurrentReadableArray {
       if (storage) {
         std::copy(storage->data(), storage->data() + count, newStorage->data());
         newStorage->Count.store(count, std::memory_order_release);
-        FreeList.push_back(storage);
+        ConcurrentFreeListNode::add(&FreeList, storage);
       }
 
       storage = newStorage;
@@ -797,28 +825,6 @@ struct ConcurrentReadableHashMap {
     ElemTy *data() { return &Elem; }
   };
 
-  /// A simple linked list representing pointers that need to be freed.
-  struct FreeListNode {
-    FreeListNode *Next;
-    void *Ptr;
-
-    static void add(FreeListNode **head, void *ptr) {
-      auto *newNode = new FreeListNode{*head, ptr};
-      *head = newNode;
-    }
-
-    static void freeAll(FreeListNode **head) {
-      auto *node = *head;
-      while (node) {
-        auto *next = node->Next;
-        free(node->Ptr);
-        delete node;
-        node = next;
-      }
-      *head = nullptr;
-    }
-  };
-
   /// The number of readers currently active, equal to the number of snapshot
   /// objects currently alive.
   std::atomic<uint32_t> ReaderCount{0};
@@ -840,7 +846,7 @@ struct ConcurrentReadableHashMap {
   MutexTy WriterLock;
 
   /// The list of pointers to be freed once no readers are active.
-  FreeListNode *FreeList{nullptr};
+  ConcurrentFreeListNode *FreeList{nullptr};
 
   void incrementReaders() {
     ReaderCount.fetch_add(1, std::memory_order_acquire);
@@ -854,7 +860,7 @@ struct ConcurrentReadableHashMap {
   /// there are active readers, do nothing.
   void deallocateFreeListIfSafe() {
     if (ReaderCount.load(std::memory_order_seq_cst) == 0)
-      FreeListNode::freeAll(&FreeList);
+      ConcurrentFreeListNode::freeAll(&FreeList, free);
   }
 
   /// Grow the elements array, adding the old array to the free list and
@@ -868,7 +874,7 @@ struct ConcurrentReadableHashMap {
     if (elements) {
       memcpy(newElements->data(), elements->data(),
              elementCount * sizeof(ElemTy));
-      FreeListNode::add(&FreeList, elements);
+      ConcurrentFreeListNode::add(&FreeList, elements);
     }
 
     // Use seq_cst here to ensure that the subsequent load of ReaderCount is
@@ -916,7 +922,7 @@ struct ConcurrentReadableHashMap {
     Indices.store(newIndices.Value, std::memory_order_seq_cst);
 
     if (auto *ptr = indices.pointer())
-      FreeListNode::add(&FreeList, ptr);
+      ConcurrentFreeListNode::add(&FreeList, ptr);
 
     return newIndices;
   }
@@ -1122,8 +1128,8 @@ struct ConcurrentReadableHashMap {
     Elements.store(nullptr, std::memory_order_relaxed);
 
     if (auto *ptr = indices.pointer())
-      FreeListNode::add(&FreeList, ptr);
-    FreeListNode::add(&FreeList, elements);
+      ConcurrentFreeListNode::add(&FreeList, ptr);
+    ConcurrentFreeListNode::add(&FreeList, elements);
 
     deallocateFreeListIfSafe();
   }

include/swift/SymbolGraphGen/SymbolGraphOptions.h

@@ -35,6 +35,10 @@ struct SymbolGraphOptions {
   /// Emit members gotten through class inheritance or protocol default
   /// implementations with compound, "SYNTHESIZED" USRs.
   bool EmitSynthesizedMembers;
+  
+  /// Whether to print informational messages when rendering
+  /// a symbol graph.
+  bool PrintMessages;
 };
 
 } // end namespace symbolgraphgen

lib/Demangling/Demangler.cpp

@@ -1146,6 +1146,10 @@ NodePointer Demangler::demangleBuiltinType() {
       Ty = createNode(Node::Kind::BuiltinTypeName,
                               BUILTIN_TYPE_NAME_UNSAFEVALUEBUFFER);
       break;
+    case 'e':
+      Ty = createNode(Node::Kind::BuiltinTypeName,
+                              BUILTIN_TYPE_NAME_EXECUTOR);
+      break;
     case 'f': {
       int size = demangleIndex() - 1;
       if (size <= 0 || size > maxTypeSize)

lib/Demangling/Remangler.cpp

@@ -753,6 +753,8 @@ void Remangler::mangleBuiltinTypeName(Node *node) {
     Buffer << 'j';
   } else if (text == BUILTIN_TYPE_NAME_DEFAULTACTORSTORAGE) {
     Buffer << 'D';
+  } else if (text == BUILTIN_TYPE_NAME_EXECUTOR) {
+    Buffer << 'e';
   } else if (text == BUILTIN_TYPE_NAME_SILTOKEN) {
     Buffer << 't';
   } else if (text == BUILTIN_TYPE_NAME_INTLITERAL) {

lib/IDE/ExprContextAnalysis.cpp

@@ -745,6 +745,22 @@ static bool getPositionInArgs(DeclContext &DC, Expr *Args, Expr *CCExpr,
   return false;
 }
 
+/// For function call arguments \p Args, return the argument at \p Position
+/// computed by \c getPositionInArgs
+static Expr *getArgAtPosition(Expr *Args, unsigned Position) {
+  if (isa<ParenExpr>(Args)) {
+    assert(Position == 0);
+    return Args;
+  }
+
+  if (auto *tuple = dyn_cast<TupleExpr>(Args)) {
+    return tuple->getElement(Position);
+  } else {
+    llvm_unreachable("Unable to retrieve arg at position returned by "
+                     "getPositionInArgs?");
+  }
+}
+
 /// Get index of \p CCExpr in \p Params. Note that the position in \p Params may
 /// be different than the position in \p Args if there are defaulted arguments
 /// in \p Params which don't occur in \p Args.
@@ -848,15 +864,15 @@ class ExprContextAnalyzer {
   bool analyzeApplyExpr(Expr *E) {
     // Collect parameter lists for possible func decls.
     SmallVector<FunctionTypeAndDecl, 2> Candidates;
-    Expr *Arg = nullptr;
+    Expr *Args = nullptr;
     if (auto *applyExpr = dyn_cast<ApplyExpr>(E)) {
       if (!collectPossibleCalleesForApply(*DC, applyExpr, Candidates))
         return false;
-      Arg = applyExpr->getArg();
+      Args = applyExpr->getArg();
     } else if (auto *subscriptExpr = dyn_cast<SubscriptExpr>(E)) {
       if (!collectPossibleCalleesForSubscript(*DC, subscriptExpr, Candidates))
         return false;
-      Arg = subscriptExpr->getIndex();
+      Args = subscriptExpr->getIndex();
     } else {
       llvm_unreachable("unexpected expression kind");
     }
@@ -866,14 +882,43 @@ class ExprContextAnalyzer {
     // Determine the position of code completion token in call argument.
     unsigned PositionInArgs;
     bool HasName;
-    if (!getPositionInArgs(*DC, Arg, ParsedExpr, PositionInArgs, HasName))
+    if (!getPositionInArgs(*DC, Args, ParsedExpr, PositionInArgs, HasName))
       return false;
 
     // Collect possible types (or labels) at the position.
     {
-      bool MayNeedName = !HasName && !E->isImplicit() &&
-                         (isa<CallExpr>(E) | isa<SubscriptExpr>(E) ||
-                          isa<UnresolvedMemberExpr>(E));
+      bool MayBeArgForLabeledParam =
+          HasName || E->isImplicit() ||
+          (!isa<CallExpr>(E) && !isa<SubscriptExpr>(E) &&
+           !isa<UnresolvedMemberExpr>(E));
+
+      // If the completion position cannot be the actual argument, it must be
+      // able to be an argument label.
+      bool MayBeLabel = !MayBeArgForLabeledParam;
+
+      // Alternatively, the code completion position may complete to an argument
+      // label if we are currently completing variadic args.
+      // E.g.
+      // func foo(x: Int..., y: Int...) {}
+      // foo(x: 1, #^COMPLETE^#)
+      // #^COMPLETE^# may complete to either an additional variadic arg or to
+      // the argument label `y`.
+      //
+      // Varargs are represented by a VarargExpansionExpr that contains an
+      // ArrayExpr on the call side.
+      if (auto Vararg = dyn_cast<VarargExpansionExpr>(
+              getArgAtPosition(Args, PositionInArgs))) {
+        if (auto Array = dyn_cast_or_null<ArrayExpr>(Vararg->getSubExpr())) {
+          if (Array->getNumElements() > 0 &&
+              !isa<CodeCompletionExpr>(Array->getElement(0))) {
+            // We can only complete as argument label if we have at least one
+            // proper vararg before the code completion token. We shouldn't be
+            // suggesting labels for:
+            // foo(x: #^COMPLETE^#)
+            MayBeLabel = true;
+          }
+        }
+      }
       SmallPtrSet<CanType, 4> seenTypes;
       llvm::SmallSet<std::pair<Identifier, CanType>, 4> seenArgs;
       for (auto &typeAndDecl : Candidates) {
@@ -883,7 +928,7 @@ class ExprContextAnalyzer {
 
         auto Params = typeAndDecl.Type->getParams();
         unsigned PositionInParams;
-        if (!getPositionInParams(*DC, Arg, ParsedExpr, Params,
+        if (!getPositionInParams(*DC, Args, ParsedExpr, Params,
                                  PositionInParams)) {
           // If the argument doesn't have a matching position in the parameters,
           // indicate that with optional nullptr param.
@@ -907,11 +952,13 @@ class ExprContextAnalyzer {
               paramList && (paramList->get(Pos)->isDefaultArgument() ||
                             paramList->get(Pos)->isVariadic());
 
-          if (paramType.hasLabel() && MayNeedName) {
+          if (MayBeLabel && paramType.hasLabel()) {
             if (seenArgs.insert({paramType.getLabel(), ty->getCanonicalType()})
                     .second)
               recordPossibleParam(&paramType, !canSkip);
-          } else {
+          }
+
+          if (MayBeArgForLabeledParam || !paramType.hasLabel()) {
             auto argTy = ty;
             if (paramType.isInOut())
               argTy = InOutType::get(argTy);

lib/IRGen/GenObjC.cpp

@@ -1185,10 +1185,11 @@ irgen::emitObjCMethodDescriptorParts(IRGenModule &IGM,
   /// with numbers that used to represent stack offsets for each of these
   /// elements.
   CanSILFunctionType methodType = getObjCMethodType(IGM, method);
-  descriptor.typeEncoding =
-      getObjCEncodingForMethod(IGM, methodType, /*extended*/ method->hasAsync(),
-                               method);
 
+  bool useExtendedEncoding =
+    method->hasAsync() && !isa<ProtocolDecl>(method->getDeclContext());
+  descriptor.typeEncoding = getObjCEncodingForMethod(
+      IGM, methodType, /*extended*/ useExtendedEncoding, method);
   /// The third element is the method implementation pointer.
   if (!concrete) {
     descriptor.impl = nullptr;

lib/IRGen/MetadataRequest.cpp

@@ -1745,7 +1745,7 @@ namespace {
       llvm_unreachable("error type should not appear in IRGen");
     }
 
-    // These types are artificial types used for for internal purposes and
+    // These types are artificial types used for internal purposes and
     // should never appear in a metadata request.
 #define INTERNAL_ONLY_TYPE(ID)                                               \
     MetadataResponse visit##ID##Type(Can##ID##Type type,                     \