Merge pull request #4106 from swiftwasm/main

Merge upstream `main` into `swiftwasm`

Author: MaxDesiatov

include/swift/AST/Decl.h

@@ -5463,7 +5463,16 @@ class ParamDecl : public VarDecl {
   friend class DefaultArgumentInitContextRequest;
   friend class DefaultArgumentExprRequest;
 
-  llvm::PointerIntPair<Identifier, 1, bool> ArgumentNameAndDestructured;
+  enum class ArgumentNameFlags : uint8_t {
+    /// Whether or not this parameter is destructed.
+    Destructured = 1 << 0,
+
+    /// Whether or not this parameter is '_const'.
+    IsCompileTimeConst = 1 << 1,
+  };
+
+  llvm::PointerIntPair<Identifier, 2, OptionSet<ArgumentNameFlags>>
+      ArgumentNameAndFlags;
   SourceLoc ParameterNameLoc;
   SourceLoc ArgumentNameLoc;
   SourceLoc SpecifierLoc;
@@ -5494,13 +5503,10 @@ class ParamDecl : public VarDecl {
 
     /// Whether or not this parameter is 'isolated'.
     IsIsolated = 1 << 2,
-
-    /// Whether or not this parameter is '_const'.
-    IsCompileTimeConst = 1 << 3,
   };
 
   /// The default value, if any, along with flags.
-  llvm::PointerIntPair<StoredDefaultArgument *, 4, OptionSet<Flags>>
+  llvm::PointerIntPair<StoredDefaultArgument *, 3, OptionSet<Flags>>
       DefaultValueAndFlags;
 
   friend class ParamSpecifierRequest;
@@ -5518,7 +5524,7 @@ class ParamDecl : public VarDecl {
 
   /// Retrieve the argument (API) name for this function parameter.
   Identifier getArgumentName() const {
-    return ArgumentNameAndDestructured.getPointer();
+    return ArgumentNameAndFlags.getPointer();
   }
 
   /// Retrieve the parameter (local) name for this function parameter.
@@ -5538,8 +5544,17 @@ class ParamDecl : public VarDecl {
   TypeRepr *getTypeRepr() const { return TyRepr; }
   void setTypeRepr(TypeRepr *repr) { TyRepr = repr; }
 
-  bool isDestructured() const { return ArgumentNameAndDestructured.getInt(); }
-  void setDestructured(bool repr) { ArgumentNameAndDestructured.setInt(repr); }
+  bool isDestructured() const {
+    auto flags = ArgumentNameAndFlags.getInt();
+    return flags.contains(ArgumentNameFlags::Destructured);
+  }
+
+  void setDestructured(bool repr) {
+    auto flags = ArgumentNameAndFlags.getInt();
+    flags = repr ? flags | ArgumentNameFlags::Destructured
+                 : flags - ArgumentNameFlags::Destructured;
+    ArgumentNameAndFlags.setInt(flags);
+  }
 
   DefaultArgumentKind getDefaultArgumentKind() const {
     return static_cast<DefaultArgumentKind>(Bits.ParamDecl.defaultArgumentKind);
@@ -5671,13 +5686,15 @@ class ParamDecl : public VarDecl {
 
   /// Whether or not this parameter is marked with '_const'.
   bool isCompileTimeConst() const {
-    return DefaultValueAndFlags.getInt().contains(Flags::IsCompileTimeConst);
+    return ArgumentNameAndFlags.getInt().contains(
+        ArgumentNameFlags::IsCompileTimeConst);
   }
 
   void setCompileTimeConst(bool value = true) {
-    auto flags = DefaultValueAndFlags.getInt();
-    DefaultValueAndFlags.setInt(value ? flags | Flags::IsCompileTimeConst
-                                      : flags - Flags::IsCompileTimeConst);
+    auto flags = ArgumentNameAndFlags.getInt();
+    flags = value ? flags | ArgumentNameFlags::IsCompileTimeConst
+                  : flags - ArgumentNameFlags::IsCompileTimeConst;
+    ArgumentNameAndFlags.setInt(flags);
   }
 
   /// Does this parameter reject temporary pointer conversions?

include/swift/AST/TypeAlignments.h

@@ -75,7 +75,7 @@ namespace swift {
   constexpr size_t SILFunctionAlignInBits = 2;
   constexpr size_t ASTContextAlignInBits = 2;
   constexpr size_t TypeVariableAlignInBits = 4;
-  constexpr size_t StoredDefaultArgumentAlignInBits = 4;
+  constexpr size_t StoredDefaultArgumentAlignInBits = 3;
 
   // Well, this is the *minimum* pointer alignment; it's going to be 3 on
   // 64-bit targets, but that doesn't matter.

include/swift/Runtime/Concurrent.h

@@ -881,7 +881,7 @@ struct ConcurrentReadableHashMap {
     auto *newElements = ElementStorage::allocate(newCapacity);
 
     if (elements) {
-      if constexpr (std::is_trivially_copyable<ElemTy>::value) {
+      if (std::is_trivially_copyable<ElemTy>::value) {
         memcpy(newElements->data(), elements->data(),
                elementCount * sizeof(ElemTy));
       } else {

lib/AST/Decl.cpp

@@ -6554,7 +6554,7 @@ ParamDecl::ParamDecl(SourceLoc specifierLoc,
               /*IsStatic*/ false,
               VarDecl::Introducer::Let, parameterNameLoc, parameterName, dc,
               StorageIsNotMutable),
-      ArgumentNameAndDestructured(argumentName, false),
+      ArgumentNameAndFlags(argumentName, None),
       ParameterNameLoc(parameterNameLoc),
       ArgumentNameLoc(argumentNameLoc), SpecifierLoc(specifierLoc) {
   Bits.ParamDecl.SpecifierComputed = false;

lib/IRGen/GenDistributed.cpp

@@ -107,7 +107,7 @@ static CanSILFunctionType getAccessorType(IRGenModule &IGM,
                                           SILFunction *Target) {
   auto &Context = IGM.Context;
 
-  auto getRawPointerParmeter = [&]() {
+  auto getRawPointerParameter = [&]() {
     auto ptrType = Context.getUnsafeRawPointerType();
     return SILParameterInfo(ptrType->getCanonicalType(),
                             ParameterConvention::Direct_Guaranteed);
@@ -131,8 +131,8 @@ static CanSILFunctionType getAccessorType(IRGenModule &IGM,
   return SILFunctionType::get(
       /*genericSignature=*/nullptr, extInfo, SILCoroutineKind::None,
       ParameterConvention::Direct_Guaranteed,
-      {/*argumentBuffer=*/getRawPointerParmeter(),
-       /*resultBuffer=*/getRawPointerParmeter(),
+      {/*argumentBuffer=*/getRawPointerParameter(),
+       /*resultBuffer=*/getRawPointerParameter(),
        /*actor=*/targetTy->getParameters().back()},
       /*Yields=*/{},
       /*Results=*/{},

stdlib/public/runtime/MetadataLookup.cpp

@@ -1913,54 +1913,90 @@ cstrToStringRef(const char *typeNameStart, size_t typeNameLength) {
   return typeName;
 }
 
-SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_SPI
-unsigned
-swift_func_getParameterCount(const char *typeNameStart, size_t typeNameLength) {
+/// Given mangling for a method, extract its function type in demangled
+/// representation.
+static NodePointer extractFunctionTypeFromMethod(Demangler &demangler,
+                                                 const char *typeNameStart,
+                                                 size_t typeNameLength) {
   llvm::Optional<llvm::StringRef> typeName =
       cstrToStringRef(typeNameStart, typeNameLength);
   if (!typeName)
-    return -1;
-
-  StackAllocatedDemangler<1024> demangler;
+    return nullptr;
 
   auto node = demangler.demangleSymbol(*typeName);
-  if (!node) return -2;
+  if (!node)
+    return nullptr;
 
   node = node->findByKind(Node::Kind::Function, /*maxDepth=*/2);
-  if (!node) return -3;
+  if (!node)
+    return nullptr;
 
   node = node->findByKind(Node::Kind::Type, /*maxDepth=*/2);
-  if (!node) return -4;
+  if (!node)
+    return nullptr;
 
-  node = node->findByKind(Node::Kind::ArgumentTuple, /*maxDepth=*/3);
-  // Get the "deepest" Tuple from the ArgumentTuple, that's the arguments
-  while (node && node->getKind() != Node::Kind::Tuple) {
-    node = node->getFirstChild();
+  // If this is a generic function, it requires special handling.
+  if (auto genericType =
+          node->findByKind(Node::Kind::DependentGenericType, /*maxDepth=*/1)) {
+    node = genericType->findByKind(Node::Kind::Type, /*maxDepth=*/1);
+    return node->findByKind(Node::Kind::FunctionType, /*maxDepth=*/1);
   }
 
-  if (node) {
-    return node->getNumChildren();
-  }
+  auto funcType = node->getFirstChild();
+  assert(funcType->getKind() == Node::Kind::FunctionType);
+  return funcType;
+}
+
+/// For a single unlabeled parameter this function returns whole
+/// `ArgumentTuple`, for everything else a `Tuple` element inside it.
+static NodePointer getParameterList(NodePointer funcType) {
+  assert(funcType->getKind() == Node::Kind::FunctionType);
+
+  auto parameterContainer =
+      funcType->findByKind(Node::Kind::ArgumentTuple, /*maxDepth=*/1);
+  assert(parameterContainer->getNumChildren() > 0);
+
+  // This is a type that convers entire parameter list.
+  auto parameterList = parameterContainer->getFirstChild();
+  assert(parameterList->getKind() == Node::Kind::Type);
+
+  auto parameters = parameterList->getFirstChild();
+  if (parameters->getKind() == Node::Kind::Tuple)
+    return parameters;
+
+  return parameterContainer;
+}
+
+SWIFT_CC(swift)
+SWIFT_RUNTIME_STDLIB_SPI
+unsigned swift_func_getParameterCount(const char *typeNameStart,
+                                      size_t typeNameLength) {
+  StackAllocatedDemangler<1024> demangler;
 
-  return -5;
+  auto funcType =
+      extractFunctionTypeFromMethod(demangler, typeNameStart, typeNameLength);
+  if (!funcType)
+    return -1;
+
+  auto parameterList = getParameterList(funcType);
+  return parameterList->getNumChildren();
 }
 
 SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_SPI
 const Metadata *_Nullable
 swift_func_getReturnTypeInfo(const char *typeNameStart, size_t typeNameLength) {
-  llvm::Optional<llvm::StringRef> typeName =
-      cstrToStringRef(typeNameStart, typeNameLength);
-  if (!typeName) return nullptr;
-
   StackAllocatedDemangler<1024> demangler;
-  auto node = demangler.demangleSymbol(*typeName);
-  if (!node) return nullptr;
 
-  node = node->findByKind(Node::Kind::Function, /*maxDepth=*/2);
-  if (!node) return nullptr;
+  auto *funcType =
+      extractFunctionTypeFromMethod(demangler, typeNameStart, typeNameLength);
+  if (!funcType)
+    return nullptr;
+
+  auto resultType = funcType->getLastChild();
+  if (!resultType)
+    return nullptr;
 
-  node = node->findByKind(Node::Kind::ReturnType, /*maxDepth=*/4);
-  if (!node) return nullptr;
+  assert(resultType->getKind() == Node::Kind::ReturnType);
 
   DecodedMetadataBuilder builder(
       demangler,
@@ -1970,7 +2006,8 @@ swift_func_getReturnTypeInfo(const char *typeNameStart, size_t typeNameLength) {
       [](const Metadata *, unsigned) { return nullptr; });
 
   TypeDecoder<DecodedMetadataBuilder> decoder(builder);
-  auto builtTypeOrError = decoder.decodeMangledType(node);
+  auto builtTypeOrError =
+      decoder.decodeMangledType(resultType->getFirstChild());
   if (builtTypeOrError.isError()) {
     auto err = builtTypeOrError.getError();
     char *errStr = err->copyErrorString();
@@ -1988,31 +2025,19 @@ swift_func_getParameterTypeInfo(
     Metadata const **types, unsigned typesLength) {
   if (typesLength < 0) return -1;
 
-  llvm::Optional<llvm::StringRef> typeName =
-      cstrToStringRef(typeNameStart, typeNameLength);
-  if (!typeName) return -1;
-
   StackAllocatedDemangler<1024> demangler;
-  auto node = demangler.demangleSymbol(*typeName);
-  if (!node) return -1;
 
-  node = node->findByKind(Node::Kind::Function, /*maxDepth=*/2);
-  if (!node) return -3;
+  auto *funcType =
+      extractFunctionTypeFromMethod(demangler, typeNameStart, typeNameLength);
+  if (!funcType)
+    return -1;
 
-  node = node->findByKind(Node::Kind::Type, /*maxDepth=*/2);
-  if (!node) return -4;
-
-  node = node->findByKind(Node::Kind::ArgumentTuple, /*maxDepth=*/3);
-  // Get the "deepest" Tuple from the ArgumentTuple, that's the arguments
-  while (node && node->getKind() != Node::Kind::Tuple) {
-    node = node->getFirstChild();
-  }
+  auto parameterList = getParameterList(funcType);
 
   // Only successfully return if the expected parameter count is the same
   // as space prepared for it in the buffer.
-  if (!node || (node && node->getNumChildren() != typesLength)) {
-    return -5;
-  }
+  if (!(parameterList && parameterList->getNumChildren() == typesLength))
+    return -2;
 
   DecodedMetadataBuilder builder(
       demangler,
@@ -2024,14 +2049,15 @@ swift_func_getParameterTypeInfo(
 
   auto typeIdx = 0;
   // for each parameter (TupleElement), store it into the provided buffer
-  for (auto tupleElement : *node) {
-    assert(tupleElement->getKind() == Node::Kind::TupleElement);
-    assert(tupleElement->getNumChildren() == 1);
+  for (auto *parameter : *parameterList) {
+    if (parameter->getKind() == Node::Kind::TupleElement) {
+      assert(parameter->getNumChildren() == 1);
+      parameter = parameter->getFirstChild();
+    }
 
-    auto typeNode = tupleElement->getFirstChild();
-    assert(typeNode->getKind() == Node::Kind::Type);
+    assert(parameter->getKind() == Node::Kind::Type);
 
-    auto builtTypeOrError = decoder.decodeMangledType(tupleElement);
+    auto builtTypeOrError = decoder.decodeMangledType(parameter);
     if (builtTypeOrError.isError()) {
       auto err = builtTypeOrError.getError();
       char *errStr = err->copyErrorString();
@@ -2041,14 +2067,10 @@ swift_func_getParameterTypeInfo(
     }
 
     types[typeIdx] = builtTypeOrError.getType();
-    typeIdx += 1;
+    ++typeIdx;
   } // end foreach parameter
 
-  if (node) {
-    return node->getNumChildren();
-  }
-
-  return -9;
+  return typesLength;
 }
 
 // ==== End of Function metadata functions ---------------------------------------

stdlib/public/stubs/Assert.cpp

@@ -13,7 +13,7 @@
 #include "swift/Runtime/Config.h"
 #include "swift/Runtime/Debug.h"
 #include "swift/Runtime/Portability.h"
-#include "../SwiftShims/AssertionReporting.h"
+#include "SwiftShims/AssertionReporting.h"
 #include <cstdarg>
 #include <cstdint>
 #include <stdio.h>

stdlib/public/stubs/Availability.mm

@@ -20,7 +20,7 @@
 #include "swift/Basic/Lazy.h"
 #include "swift/Runtime/Debug.h"
 #include <TargetConditionals.h>
-#include "../SwiftShims/FoundationShims.h"
+#include "SwiftShims/FoundationShims.h"
 
 struct os_system_version_s {
     unsigned int major;

stdlib/public/stubs/CMakeLists.txt

@@ -26,7 +26,7 @@ set(LLVM_OPTIONAL_SOURCES
 
 set(swift_stubs_c_compile_flags ${SWIFT_RUNTIME_CORE_CXX_FLAGS})
 list(APPEND swift_stubs_c_compile_flags -DswiftCore_EXPORTS)
-list(APPEND swift_stubs_c_compile_flags -I${SWIFT_SOURCE_DIR}/include)
+list(APPEND swift_stubs_c_compile_flags -I${SWIFT_SOURCE_DIR}/include -I${SWIFT_SOURCE_DIR}/stdlib/public)
 
 add_swift_target_library(swiftStdlibStubs
                   OBJECT_LIBRARY

stdlib/public/stubs/FoundationHelpers.mm

@@ -20,7 +20,7 @@
 
 #if SWIFT_OBJC_INTEROP
 #import <CoreFoundation/CoreFoundation.h>
-#include "../SwiftShims/CoreFoundationShims.h"
+#include "SwiftShims/CoreFoundationShims.h"
 #import <objc/runtime.h>
 #include "swift/Runtime/Once.h"
 #include <dlfcn.h>