Merge pull request #4490 from swiftwasm/katei/merge-main-2022-04-29

Merge main 2022-04-29

Author: kateinoigakukun

cmake/modules/AddSwift.cmake

@@ -709,7 +709,7 @@ function(add_swift_host_tool executable)
       if(BOOTSTRAPPING_MODE STREQUAL "HOSTTOOLS")
         # Add in the toolchain directory so we can grab compatibility libraries
         get_filename_component(TOOLCHAIN_BIN_DIR ${SWIFT_EXEC_FOR_SWIFT_MODULES} DIRECTORY)
-        get_filename_component(TOOLCHAIN_LIB_DIR "${TOOLCHAIN_BIN_DIR}/../lib/swift/macosx" ABSOLUTE)
+        get_filename_component(TOOLCHAIN_LIB_DIR "${TOOLCHAIN_BIN_DIR}/../lib/swift/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}" ABSOLUTE)
         target_link_directories(${executable} PUBLIC ${TOOLCHAIN_LIB_DIR})
 
         # Add the SDK directory for the host platform.

cmake/modules/Libdispatch.cmake

@@ -74,8 +74,10 @@ foreach(sdk ${DISPATCH_SDKS})
       set(SWIFT_LIBDISPATCH_COMPILER_TRIPLE_CMAKE_ARGS -DCMAKE_C_COMPILER_TARGET=${SWIFT_SDK_WINDOWS_ARCH_${arch}_TRIPLE};-DCMAKE_CXX_COMPILER_TARGET=${SWIFT_SDK_WINDOWS_ARCH_${arch}_TRIPLE})
     endif()
 
-
-    if(NOT sdk STREQUAL ANDROID)
+    if("${sdk}" STREQUAL "ANDROID")
+      file(TO_CMAKE_PATH "${SWIFT_ANDROID_NDK_PATH}" _ANDROID_NDK)
+      set(SWIFT_LIBDISPATCH_ANDROID_NDK -DCMAKE_ANDROID_NDK=${_ANDROID_NDK})
+    else()
       set(SWIFT_LIBDISPATCH_SYSTEM_PROCESSOR  -DCMAKE_SYSTEM_PROCESSOR=${arch})
     endif()
 
@@ -100,7 +102,7 @@ foreach(sdk ${DISPATCH_SDKS})
                           -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
                           -DCMAKE_SYSTEM_NAME=${SWIFT_SDK_${sdk}_NAME}
                           ${SWIFT_LIBDISPATCH_SYSTEM_PROCESSOR}
-                          "-DCMAKE_ANDROID_NDK=${SWIFT_ANDROID_NDK_PATH}"
+                          "${SWIFT_LIBDISPATCH_ANDROID_NDK}"
                           -DCMAKE_ANDROID_ARCH_ABI=${SWIFT_SDK_ANDROID_ARCH_${arch}_ABI}
                           -DCMAKE_ANDROID_API=${SWIFT_ANDROID_API_LEVEL}
                           -DBUILD_SHARED_LIBS=YES

docs/RequirementMachine/RequirementMachine.tex

@@ -10,7 +10,7 @@
 %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
-\documentclass[headsepline,bibliography=totoc]{scrreport}
+\documentclass[headsepline,bibliography=totoc]{scrreprt}
 
 \usepackage{imakeidx}
 

include/swift/AST/DiagnosticsClangImporter.def

@@ -106,6 +106,15 @@ WARNING(import_multiple_mainactor_attr,none,
       "this attribute for global actor '%0' is invalid; the declaration already has attribute for global actor '%1'",
       (StringRef, StringRef))
 
+WARNING(contradicting_mutation_attrs,none,
+        "attribute 'nonmutating' is ignored when combined with attribute 'mutating'", ())
+
+WARNING(nonmutating_without_const,none,
+        "attribute 'nonmutating' has no effect on non-const method", ())
+
+WARNING(nonmutating_without_mutable_fields,none,
+        "attribute 'nonmutating' has no effect without any mutable fields", ())
+
 ERROR(module_map_not_found, none, "module map file '%0' not found", (StringRef))
 
 NOTE(macro_not_imported_unsupported_operator, none, "operator not supported in macro arithmetic", ())

include/swift/Basic/LangOptions.h

@@ -223,9 +223,6 @@ namespace swift {
     /// Emit a remark after loading a module.
     bool EnableModuleLoadingRemarks = false;
 
-    /// Resolve main function as though it were called from an async context
-    bool EnableAsyncMainResolution = false;
-
     ///
     /// Support for alternate usage modes
     ///

include/swift/ClangImporter/ClangImporter.h

@@ -516,6 +516,8 @@ class ClangImporter final : public ClangModuleLoader {
 
   bool isCXXMethodMutating(const clang::CXXMethodDecl *method) override;
 
+  bool isAnnotatedWith(const clang::CXXMethodDecl *method, StringRef attr);
+
   /// Find the lookup table that corresponds to the given Clang module.
   ///
   /// \param clangModule The module, or null to indicate that we're talking

include/swift/Option/Options.td

@@ -270,10 +270,6 @@ def pch_output_dir: Separate<["-"], "pch-output-dir">,
   Flags<[FrontendOption, HelpHidden, ArgumentIsPath]>,
   HelpText<"Directory to persist automatically created precompiled bridging headers">;
 
-def async_main: Flag<["-"], "async-main">,
-    Flags<[FrontendOption]>,
-    HelpText<"Resolve main function as if it were called from an asynchronous context">;
-
 // FIXME: Unhide this once it doesn't depend on an output file map.
 def incremental : Flag<["-"], "incremental">,
   Flags<[NoInteractiveOption, HelpHidden, DoesNotAffectIncrementalBuild]>,

include/swift/Runtime/Heap.h

@@ -20,13 +20,72 @@
 #include <cstddef>
 #include <cstdint>
 #include <cstdlib>
+#include <new>
 #include <type_traits>
+#include <utility>
+
+#include "swift/Runtime/Config.h"
 
 #if defined(_WIN32)
 #include <malloc.h>
 #endif
 
 namespace swift {
+// Allocate plain old memory. This is the generalized entry point
+// Never returns nil. The returned memory is uninitialized. 
+//
+// An "alignment mask" is just the alignment (a power of 2) minus 1.
+SWIFT_RUNTIME_EXPORT
+void *swift_slowAlloc(size_t bytes, size_t alignMask);
+
+// If the caller cannot promise to zero the object during destruction,
+// then call these corresponding APIs:
+SWIFT_RUNTIME_EXPORT
+void swift_slowDealloc(void *ptr, size_t bytes, size_t alignMask);
+
+/// Allocate and construct an instance of type \c T.
+///
+/// \param args The arguments to pass to the constructor for \c T.
+///
+/// \returns A pointer to a new, fully constructed instance of \c T. This
+///   function never returns \c nullptr. The caller is responsible for
+///   eventually destroying the resulting object by passing it to
+///   \c swift_cxx_deleteObject().
+///
+/// This function avoids the use of the global \c operator \c new (which may be
+/// overridden by other code in a process) in favor of calling
+/// \c swift_slowAlloc() and constructing the new object with placement new.
+///
+/// This function is capable of returning well-aligned memory even on platforms
+/// that do not implement the C++17 "over-aligned new" feature.
+template <typename T, typename... Args>
+static inline T *swift_cxx_newObject(Args &&... args) {
+  auto result = reinterpret_cast<T *>(swift_slowAlloc(sizeof(T),
+                                                      alignof(T) - 1));
+  ::new (result) T(std::forward<Args>(args)...);
+  return result;
+}
+
+/// Destruct and deallocate an instance of type \c T.
+///
+/// \param ptr A pointer to an instance of type \c T previously created with a
+///   call to \c swift_cxx_newObject().
+///
+/// This function avoids the use of the global \c operator \c delete (which may
+/// be overridden by other code in a process) in favor of directly calling the
+/// destructor for \a *ptr and then freeing its memory by calling
+/// \c swift_slowDealloc().
+///
+/// The effect of passing a pointer to this function that was \em not returned
+/// from \c swift_cxx_newObject() is undefined.
+template <typename T>
+static inline void swift_cxx_deleteObject(T *ptr) {
+  if (ptr) {
+    ptr->~T();
+    swift_slowDealloc(ptr, sizeof(T), alignof(T) - 1);
+  }
+}
+
 namespace {
 // This is C++17 and newer, so we simply re-define it.  Since the codebase is
 // C++14, assume that DR1558 is accounted for and that unused parameters in alias

include/swift/Runtime/HeapObject.h

@@ -19,8 +19,6 @@
 
 #include <cstddef>
 #include <cstdint>
-#include <new>
-#include <utility>
 #include "swift/Runtime/Config.h"
 
 #if SWIFT_OBJC_INTEROP
@@ -120,62 +118,6 @@ BoxPair swift_makeBoxUnique(OpaqueValue *buffer, Metadata const *type,
 SWIFT_RUNTIME_EXPORT
 HeapObject* swift_allocEmptyBox();
 
-// Allocate plain old memory. This is the generalized entry point
-// Never returns nil. The returned memory is uninitialized. 
-//
-// An "alignment mask" is just the alignment (a power of 2) minus 1.
-
-SWIFT_RUNTIME_EXPORT
-void *swift_slowAlloc(size_t bytes, size_t alignMask);
-
-// If the caller cannot promise to zero the object during destruction,
-// then call these corresponding APIs:
-SWIFT_RUNTIME_EXPORT
-void swift_slowDealloc(void *ptr, size_t bytes, size_t alignMask);
-
-/// Allocate and construct an instance of type \c T.
-///
-/// \param args The arguments to pass to the constructor for \c T.
-///
-/// \returns A pointer to a new, fully constructed instance of \c T. This
-///   function never returns \c nullptr. The caller is responsible for
-///   eventually destroying the resulting object by passing it to
-///   \c swift_cxx_deleteObject().
-///
-/// This function avoids the use of the global \c operator \c new (which may be
-/// overridden by other code in a process) in favor of calling
-/// \c swift_slowAlloc() and constructing the new object with placement new.
-///
-/// This function is capable of returning well-aligned memory even on platforms
-/// that do not implement the C++17 "over-aligned new" feature.
-template <typename T, typename... Args>
-static inline T *swift_cxx_newObject(Args &&... args) {
-  auto result = reinterpret_cast<T *>(swift_slowAlloc(sizeof(T),
-                                                      alignof(T) - 1));
-  ::new (result) T(std::forward<Args>(args)...);
-  return result;
-}
-
-/// Destruct and deallocate an instance of type \c T.
-///
-/// \param ptr A pointer to an instance of type \c T previously created with a
-///   call to \c swift_cxx_newObject().
-///
-/// This function avoids the use of the global \c operator \c delete (which may
-/// be overridden by other code in a process) in favor of directly calling the
-/// destructor for \a *ptr and then freeing its memory by calling
-/// \c swift_slowDealloc().
-///
-/// The effect of passing a pointer to this function that was \em not returned
-/// from \c swift_cxx_newObject() is undefined.
-template <typename T>
-static inline void swift_cxx_deleteObject(T *ptr) {
-  if (ptr) {
-    ptr->~T();
-    swift_slowDealloc(ptr, sizeof(T), alignof(T) - 1);
-  }
-}
-
 /// Atomically increments the retain count of an object.
 ///
 /// \param object - may be null, in which case this is a no-op

include/swift/Sema/Constraint.h

@@ -209,10 +209,9 @@ enum class ConstraintKind : char {
   /// inferred from a conversion, so the check is more relax comparing to
   /// `ConformsTo`.
   TransitivelyConformsTo,
-  /// Represents an AST node contained in a body of a closure. It has only
-  /// one type - type variable representing type of a node, other side is
-  /// the AST node to infer the type for.
-  ClosureBodyElement,
+  /// Represents an AST node contained in a body of a function/closure.
+  /// It only has an AST node to generate constraints and infer the type for.
+  SyntacticElement,
   /// Do not add new uses of this, it only exists to retain compatibility for
   /// rdar://85263844.
   ///
@@ -240,8 +239,8 @@ enum class ConstraintClassification : char {
   /// A conjunction constraint.
   Conjunction,
 
-  /// An element of a closure body.
-  ClosureElement,
+  /// An element of a closure/function body.
+  SyntacticElement,
 };
 
 /// Specifies a restriction on the kind of conversion that should be
@@ -448,7 +447,7 @@ class Constraint final : public llvm::ilist_node<Constraint>,
       ContextualTypeInfo Context;
       /// Identifies whether result of this node is unused.
       bool IsDiscarded;
-    } ClosureElement;
+    } SyntacticElement;
   };
 
   /// The locator that describes where in the expression this
@@ -589,12 +588,12 @@ class Constraint final : public llvm::ilist_node<Constraint>,
       Optional<TrailingClosureMatching> trailingClosureMatching,
       ConstraintLocator *locator);
 
-  static Constraint *createClosureBodyElement(ConstraintSystem &cs,
+  static Constraint *createSyntacticElement(ConstraintSystem &cs,
                                               ASTNode node,
                                               ConstraintLocator *locator,
                                               bool isDiscarded = false);
 
-  static Constraint *createClosureBodyElement(ConstraintSystem &cs,
+  static Constraint *createSyntacticElement(ConstraintSystem &cs,
                                               ASTNode node,
                                               ContextualTypeInfo context,
                                               ConstraintLocator *locator,
@@ -708,8 +707,8 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     case ConstraintKind::Conjunction:
       return ConstraintClassification::Conjunction;
 
-    case ConstraintKind::ClosureBodyElement:
-      return ConstraintClassification::ClosureElement;
+    case ConstraintKind::SyntacticElement:
+      return ConstraintClassification::SyntacticElement;
     }
 
     llvm_unreachable("Unhandled ConstraintKind in switch.");
@@ -732,7 +731,7 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     case ConstraintKind::ValueWitness:
       return Member.First;
 
-    case ConstraintKind::ClosureBodyElement:
+    case ConstraintKind::SyntacticElement:
       llvm_unreachable("closure body element constraint has no type operands");
 
     default:
@@ -746,7 +745,7 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     case ConstraintKind::Disjunction:
     case ConstraintKind::Conjunction:
     case ConstraintKind::BindOverload:
-    case ConstraintKind::ClosureBodyElement:
+    case ConstraintKind::SyntacticElement:
       llvm_unreachable("constraint has no second type");
 
     case ConstraintKind::ValueMember:
@@ -855,19 +854,19 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     return Member.UseDC;
   }
 
-  ASTNode getClosureElement() const {
-    assert(Kind == ConstraintKind::ClosureBodyElement);
-    return ClosureElement.Element;
+  ASTNode getSyntacticElement() const {
+    assert(Kind == ConstraintKind::SyntacticElement);
+    return SyntacticElement.Element;
   }
 
   ContextualTypeInfo getElementContext() const {
-    assert(Kind == ConstraintKind::ClosureBodyElement);
-    return ClosureElement.Context;
+    assert(Kind == ConstraintKind::SyntacticElement);
+    return SyntacticElement.Context;
   }
 
   bool isDiscardedElement() const {
-    assert(Kind == ConstraintKind::ClosureBodyElement);
-    return ClosureElement.IsDiscarded;
+    assert(Kind == ConstraintKind::SyntacticElement);
+    return SyntacticElement.IsDiscarded;
   }
 
   /// For an applicable function constraint, retrieve the trailing closure

include/swift/Sema/ConstraintLocator.h

@@ -1012,11 +1012,11 @@ class LocatorPathElt::ConstructorMemberType final
   }
 };
 
-class LocatorPathElt::ClosureBodyElement final
+class LocatorPathElt::SyntacticElement final
     : public StoredPointerElement<void> {
 public:
-  ClosureBodyElement(ASTNode element)
-      : StoredPointerElement(PathElementKind::ClosureBodyElement,
+  SyntacticElement(ASTNode element)
+      : StoredPointerElement(PathElementKind::SyntacticElement,
                              element.getOpaqueValue()) {
     assert(element);
   }
@@ -1054,7 +1054,7 @@ class LocatorPathElt::ClosureBodyElement final
   }
 
   static bool classof(const LocatorPathElt *elt) {
-    return elt->getKind() == PathElementKind::ClosureBodyElement;
+    return elt->getKind() == PathElementKind::SyntacticElement;
   }
 };
 

include/swift/Sema/ConstraintLocatorPathElts.def

@@ -229,8 +229,9 @@ CUSTOM_LOCATOR_PATH_ELT(ImplicitConversion)
 /// An implicit call to a 'dynamicMember' subscript for a dynamic member lookup.
 SIMPLE_LOCATOR_PATH_ELT(ImplicitDynamicMemberSubscript)
 
-/// The element of the closure body e.g. statement, declaration, or expression.
-CUSTOM_LOCATOR_PATH_ELT(ClosureBodyElement)
+/// The element of the closure/function body e.g. statement, pattern,
+/// declaration, or expression.
+CUSTOM_LOCATOR_PATH_ELT(SyntacticElement)
 
 /// The element of the pattern binding declaration.
 CUSTOM_LOCATOR_PATH_ELT(PatternBindingElement)