swiftwasm · kateinoigakukun · Oct 29, 2021 · Oct 21, 2021 · Oct 21, 2021 · Oct 21, 2021
diff --git a/cmake/modules/AddSwift.cmake b/cmake/modules/AddSwift.cmake
@@ -732,7 +732,8 @@ function(add_libswift name)
 
   set(libswift_compile_options
       "-Xfrontend" "-validate-tbd-against-ir=none"
-      "-Xfrontend" "-enable-cxx-interop")
+      "-Xfrontend" "-enable-cxx-interop"
+      "-Xcc" "-UIBOutlet" "-Xcc" "-UIBAction" "-Xcc" "-UIBInspectable")
 
   if(CMAKE_BUILD_TYPE STREQUAL Debug)
     list(APPEND libswift_compile_options "-g")

diff --git a/cmake/modules/SwiftWindowsSupport.cmake b/cmake/modules/SwiftWindowsSupport.cmake
@@ -81,7 +81,7 @@ endfunction()
 # NOTE(compnerd) we use a macro here as this modifies global variables
 macro(swift_swap_compiler_if_needed target)
   if(NOT CMAKE_C_COMPILER_ID MATCHES Clang)
-    if(CMAKE_SYSTEM_NAME STREQUAL CMAKE_HOST_SYSTEM_NAME)
+    if(CMAKE_SYSTEM_NAME STREQUAL CMAKE_HOST_SYSTEM_NAME AND CMAKE_SYSTEM_PROCESSOR STREQUAL CMAKE_HOST_SYSTEM_PROCESSOR)
       if(SWIFT_BUILT_STANDALONE)
         get_target_property(CLANG_LOCATION clang LOCATION)
         get_filename_component(CLANG_LOCATION ${CLANG_LOCATION} DIRECTORY)

diff --git a/docs/ReferenceGuides/UnderscoredAttributes.md b/docs/ReferenceGuides/UnderscoredAttributes.md
@@ -620,3 +620,8 @@ within Swift 5 code that has adopted concurrency, but non-`@MainActor`
 
 See the forum post on [Concurrency in Swift 5 and 6](https://forums.swift.org/t/concurrency-in-swift-5-and-6/49337)
 for more details.
+
+## `@_noImplicitCopy`
+
+Marks a var decl as a variable that must be copied explicitly using the builtin
+function Builtin.copy.
diff --git a/include/swift/APIDigester/ModuleAnalyzerNodes.h b/include/swift/APIDigester/ModuleAnalyzerNodes.h
@@ -360,13 +360,12 @@ class SDKNodeDecl: public SDKNode {
   Optional<uint8_t> FixedBinaryOrder;
   PlatformIntroVersion introVersions;
   StringRef ObjCName;
-  mutable Optional<StringRef> demangledName;
+
 protected:
   SDKNodeDecl(SDKNodeInitInfo Info, SDKNodeKind Kind);
   virtual ~SDKNodeDecl() = default;
 public:
   StringRef getUsr() const { return Usr; }
-  StringRef getDemangledName() const;
   StringRef getLocation() const { return Location; }
   StringRef getModuleName() const {return ModuleName;}
   StringRef getHeaderName() const;

diff --git a/include/swift/AST/Attr.def b/include/swift/AST/Attr.def
@@ -672,6 +672,13 @@ DECL_ATTR(_nonSendable, NonSendable,
   APIStableToAdd | APIBreakingToRemove,
   121)
 
+SIMPLE_DECL_ATTR(_noImplicitCopy, NoImplicitCopy,
+  UserInaccessible |
+  ABIStableToAdd | ABIBreakingToRemove |
+  APIStableToAdd | APIBreakingToRemove |
+  OnVar,
+  122)
+
 // If you're adding a new underscored attribute here, please document it in
 // docs/ReferenceGuides/UnderscoredAttributes.md.
 

diff --git a/include/swift/AST/Builtins.def b/include/swift/AST/Builtins.def
@@ -515,9 +515,6 @@ BUILTIN_SIL_OPERATION(WithUnsafeThrowingContinuation, "withUnsafeThrowingContinu
 /// Force the current task to be rescheduled on the specified actor.
 BUILTIN_SIL_OPERATION(HopToActor, "hopToActor", None)
 
-/// Generate a move_value instruction to convert a T to a @_moveOnly T.
-BUILTIN_SIL_OPERATION(Move, "move", Special)
-
 #undef BUILTIN_SIL_OPERATION
 
 // BUILTIN_RUNTIME_CALL - A call into a runtime function.
@@ -603,6 +600,29 @@ BUILTIN_MISC_OPERATION(AllocRaw, "allocRaw", "", Special)
 /// was allocated.
 BUILTIN_MISC_OPERATION(DeallocRaw, "deallocRaw", "", Special)
 
+/// StackAlloc has type (Int, Int, Int) -> Builtin.RawPointer
+///
+/// Parameters: capacity, stride, alignment
+///
+/// The resulting pointer comes from the stack (as in the non-standard C
+/// extension `alloca()`.) It is at least as aligned as specified and is valid
+/// until the end of the calling scope.
+///
+/// The count and stride are multiplied together to get the byte count to use
+/// for the allocation.
+///
+/// The passed alignment must be a positive power of two. If the alignment value
+/// is not known at compile time, MaximumAlignment is assumed.
+BUILTIN_MISC_OPERATION(StackAlloc, "stackAlloc", "", Special)
+
+/// StackDealloc has type (Builtin.RawPointer) -> ()
+///
+/// Parameters: address.
+///
+/// The range starting at `address`, previously allocated with
+/// Builtin.stackAlloc(), is deallocated from the stack.
+BUILTIN_MISC_OPERATION(StackDealloc, "stackDealloc", "", Special)
+
 /// Fence has type () -> ().
 BUILTIN_MISC_OPERATION(Fence, "fence", "", None)
 
@@ -757,6 +777,19 @@ BUILTIN_MISC_OPERATION(CreateTaskGroup,
 BUILTIN_MISC_OPERATION(DestroyTaskGroup,
                        "destroyTaskGroup", "", Special)
 
+
+/// A builtin that can only be called from a transparent generic function. Takes
+/// two operands, the first operand the result address, the second operand the
+/// input address. Transforms into load [take] + move_value + store [init] when
+/// transparently inlined into a caller that has the generic of the callee
+/// specialized into a loadable type. If the transparent inlining does not
+/// specialize the type (due to being inlined into a non-generic context, the
+/// SILVerifier will abort).
+///
+/// Illegal to call except for in Swift._move in the stdlib. This is enforced by
+/// the SILVerifier.
+BUILTIN_MISC_OPERATION(Move, "move", "", Special)
+
 // BUILTIN_MISC_OPERATION_WITH_SILGEN - Miscellaneous operations that are
 // specially emitted during SIL generation.
 //

diff --git a/include/swift/AST/DiagnosticsFrontend.def b/include/swift/AST/DiagnosticsFrontend.def
@@ -136,6 +136,9 @@ ERROR(error_mode_cannot_emit_module_semantic_info,none,
 ERROR(cannot_emit_ir_skipping_function_bodies,none,
       "the -experimental-skip-*-function-bodies* flags do not support "
       "emitting IR", ())
+ERROR(cannot_emit_ir_checking_api_availability_only,none,
+      "the flag -check-api-availability-only does not support "
+      "emitting IR", ())
 
 WARNING(emit_reference_dependencies_without_primary_file,none,
         "ignoring -emit-reference-dependencies (requires -primary-file)", ())

diff --git a/include/swift/AST/DiagnosticsIRGen.def b/include/swift/AST/DiagnosticsIRGen.def
@@ -50,5 +50,14 @@ ERROR(alignment_more_than_maximum,none,
       "@_alignment cannot increase alignment above maximum alignment of %0",
       (unsigned))
 
+ERROR(temporary_allocation_size_negative,none,
+      "allocation capacity must be greater than or equal to zero", ())
+ERROR(temporary_allocation_size_overflow,none,
+      "allocation byte count too large", ())
+ERROR(temporary_allocation_alignment_not_positive,none,
+      "alignment value must be greater than zero", ())
+ERROR(temporary_allocation_alignment_not_power_of_2,none,
+      "alignment value must be a power of two", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"
diff --git a/include/swift/AST/DiagnosticsSIL.def b/include/swift/AST/DiagnosticsSIL.def
@@ -686,5 +686,20 @@ NOTE(capturepromotion_concurrentcapture_capturinguse_here, none,
 NOTE(capturepromotion_variable_defined_here,none,
      "variable defined here", ())
 
+// move operator used on generic or evalue
+ERROR(move_operator_used_on_generic_or_existential_value, none,
+      "move() used on a generic or existential value", ())
+
+// noimplicitcopy on generic or existential binding
+ERROR(noimplicitcopy_used_on_generic_or_existential, none,
+      "@_noImplicitCopy can not be used on a generic or existential typed "
+      "binding or a nominal type containing such typed things", ())
+
+// move only checker diagnostics
+ERROR(sil_moveonlychecker_value_consumed_more_than_once, none,
+      "'%0' consumed more than once", (StringRef))
+NOTE(sil_moveonlychecker_consuming_use_here, none,
+     "consuming use", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -2263,6 +2263,11 @@ NOTE(associated_type_witness_conform_impossible,none,
      "candidate can not infer %0 = %1 because %1 "
      "is not a nominal type and so can't conform to %2",
      (Identifier, Type, Type))
+NOTE(suggest_opaque_type_witness,none,
+     "cannot infer %0 = %1 because %1 as a type cannot "
+     "conform to protocols; did you mean to use an opaque "
+     "result type?",
+     (Identifier, Type, Type))
 NOTE(associated_type_witness_inherit_impossible,none,
      "candidate can not infer %0 = %1 because %1 "
      "is not a class type and so can't inherit from %2",
@@ -6029,5 +6034,16 @@ ERROR(wrap_invalid_attr_added_by_access_note, none,
 
 #undef WHICH_ACCESS_NOTE
 
+// Move Only diagnostics
+
+ERROR(experimental_moveonly_feature_can_only_be_used_when_enabled,
+      none, "Can not use feature when experimental move only is disabled! Pass"
+      " the frontend flag -enable-experimental-move-only to swift to enable "
+      "the usage of this language feature", ())
+ERROR(noimplicitcopy_attr_valid_only_on_local_let,
+      none, "'@_noImplicitCopy' attribute can only be applied to local lets", ())
+ERROR(noimplicitcopy_attr_invalid_in_generic_context,
+      none, "'@_noImplicitCopy' attribute cannot be applied to entities in generic contexts", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"
diff --git a/include/swift/AST/SemanticAttrs.def b/include/swift/AST/SemanticAttrs.def
@@ -113,5 +113,7 @@ SEMANTICS_ATTR(FORCE_EMIT_OPT_REMARK_PREFIX, "optremark")
 /// for testing purposes.
 SEMANTICS_ATTR(OBJC_FORBID_ASSOCIATED_OBJECTS, "objc.forbidAssociatedObjects")
 
+SEMANTICS_ATTR(LIFETIMEMANAGEMENT_MOVE, "lifetimemanagement.move")
+
 #undef SEMANTICS_ATTR
 
diff --git a/include/swift/AST/Type.h b/include/swift/AST/Type.h
@@ -317,9 +317,6 @@ class Type {
              LookupConformanceFn conformances,
              SubstOptions options=None) const;
 
-  /// Replace references to substitutable types with error types.
-  Type substDependentTypesWithErrorTypes() const;
-
   bool isPrivateStdlibType(bool treatNonBuiltinProtocolsAsPublic = true) const;
 
   SWIFT_DEBUG_DUMP;

diff --git a/include/swift/AST/USRGeneration.h b/include/swift/AST/USRGeneration.h
@@ -63,11 +63,8 @@ bool printExtensionUSR(const ExtensionDecl *ED, raw_ostream &OS);
 /// \returns true if it failed, false on success.
 bool printDeclUSR(const Decl *D, raw_ostream &OS);
 
-/// Get mangled name from a USR.
-std::string getMangledNameFromUSR(StringRef usr);
-
-/// Demangle a mangled name to a human readable name.
-std::string demangleMangledName(StringRef mangled);
+/// Demangle a mangle-name-based USR to a human readable name.
+std::string demangleUSR(StringRef mangled);
 
 } // namespace ide
 } // namespace swift

diff --git a/include/swift/Basic/Features.def b/include/swift/Basic/Features.def
@@ -54,5 +54,6 @@ LANGUAGE_FEATURE(ImplicitSelfCapture, 0, "@_implicitSelfCapture attribute", true
 LANGUAGE_FEATURE(BuiltinBuildExecutor, 0, "Executor-building builtins", true)
 LANGUAGE_FEATURE(BuiltinBuildMainExecutor, 0, "MainActor executor building builtin", true)
 LANGUAGE_FEATURE(BuiltinCreateAsyncTaskInGroup, 0, "MainActor executor building builtin", true)
+LANGUAGE_FEATURE(BuiltinMove, 0, "Builtin.move()", true)
 
 #undef LANGUAGE_FEATURE
diff --git a/include/swift/Basic/LangOptions.h b/include/swift/Basic/LangOptions.h
@@ -320,6 +320,9 @@ namespace swift {
     /// Enable experimental 'distributed' actors and functions.
     bool EnableExperimentalDistributed = false;
 
+    /// Enable experimental 'move only' features.
+    bool EnableExperimentalMoveOnly = false;
+
     /// Disable the implicit import of the _Concurrency module.
     bool DisableImplicitConcurrencyModuleImport =
         !SWIFT_IMPLICIT_CONCURRENCY_IMPORT;

diff --git a/include/swift/Demangling/Demangle.h b/include/swift/Demangling/Demangle.h
@@ -20,8 +20,8 @@
 #define SWIFT_DEMANGLING_DEMANGLE_H
 
 #include "swift/Demangling/NamespaceMacros.h"
-#include "swift/Runtime/Config.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Compiler.h"
 #include <cassert>
 #include <cstdint>
 #include <memory>
@@ -514,7 +514,7 @@ enum class OperatorKind {
 };
 
 /// A mangling error, which consists of an error code and a Node pointer
-struct SWIFT_NODISCARD ManglingError {
+struct LLVM_NODISCARD ManglingError {
   enum Code {
     Success = 0,
     AssertionFailed,
@@ -556,7 +556,7 @@ struct SWIFT_NODISCARD ManglingError {
 
 /// Used as a return type for mangling functions that may fail
 template <typename T>
-class SWIFT_NODISCARD ManglingErrorOr {
+class LLVM_NODISCARD ManglingErrorOr {
 private:
   ManglingError err_;
   T             value_;

diff --git a/include/swift/Demangling/TypeLookupError.h b/include/swift/Demangling/TypeLookupError.h
@@ -209,6 +209,7 @@ static TypeLookupError TypeLookupErrorImpl(const char *fmt, Args... args) {
     char *str;
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wformat-security"
+#pragma clang diagnostic ignored "-Wformat-nonliteral"
     swift_asprintf(&str, fmt, args...);
 #pragma clang diagnostic pop
     return str;

diff --git a/include/swift/Option/FrontendOptions.td b/include/swift/Option/FrontendOptions.td
@@ -259,6 +259,10 @@ def enable_experimental_lexical_lifetimes :
   Flag<["-"], "enable-experimental-lexical-lifetimes">,
   HelpText<"Enable experimental lexical lifetimes">;
 
+def enable_experimental_move_only :
+  Flag<["-"], "enable-experimental-move-only">,
+  HelpText<"Enable experimental move only">;
+
 def enable_experimental_distributed :
   Flag<["-"], "enable-experimental-distributed">,
   HelpText<"Enable experimental 'distributed' actors and functions">;
@@ -469,10 +473,6 @@ def disable_availability_checking : Flag<["-"],
   "disable-availability-checking">,
   HelpText<"Disable checking for potentially unavailable APIs">;
 
-def check_api_availability_only : Flag<["-"],
-  "check-api-availability-only">,
-  HelpText<"Only check the availability of the APIs, ignore function bodies">;
-
 def enable_conformance_availability_errors : Flag<["-"],
   "enable-conformance-availability-errors">,
   HelpText<"Diagnose conformance availability violations as errors">;

diff --git a/include/swift/Option/Options.td b/include/swift/Option/Options.td
@@ -422,6 +422,10 @@ def define_availability : Separate<["-"], "define-availability">,
   HelpText<"Define an availability macro in the format 'macroName : iOS 13.0, macOS 10.15'">,
   MetaVarName<"<macro>">;
 
+def check_api_availability_only : Flag<["-"], "check-api-availability-only">,
+  Flags<[HelpHidden, FrontendOption, NoInteractiveOption]>,
+  HelpText<"Only check the availability of the APIs, ignore function bodies">;
+
 def library_level : Separate<["-"], "library-level">,
   MetaVarName<"<level>">,
   Flags<[HelpHidden, FrontendOption, ModuleInterfaceOption]>,

diff --git a/include/swift/Runtime/Config.h b/include/swift/Runtime/Config.h
@@ -226,6 +226,22 @@ extern uintptr_t __COMPATIBILITY_LIBRARIES_CANNOT_CHECK_THE_IS_SWIFT_BIT_DIRECTL
 // so changing this value is not sufficient.
 #define SWIFT_DEFAULT_LLVM_CC llvm::CallingConv::C
 
+// SWIFT_FORMAT(fmt,first) marks a function as taking a format string argument
+// at argument `fmt`, with the first argument for the format string as `first`.
+#if __has_attribute(format)
+#define SWIFT_FORMAT(fmt,first) __attribute__((format(printf, fmt, first)))
+#else
+#define SWIFT_FORMAT(fmt,first)
+#endif
+
+// SWIFT_VFORMAT(fmt) marks a function as taking a format string argument at
+// argument `fmt`, with the arguments in a `va_list`.
+#if __has_attribute(format)
+#define SWIFT_VFORMAT(fmt)      __attribute__((format(printf, fmt, 0)))
+#else
+#define SWIFT_VFORMAT(fmt)
+#endif
+
 // Pointer authentication.
 #if __has_feature(ptrauth_calls)
 #define SWIFT_PTRAUTH 1

diff --git a/include/swift/Runtime/Debug.h b/include/swift/Runtime/Debug.h
@@ -85,15 +85,18 @@ static inline void crash(const char *message) {
 // swift::fatalError() halts with a crash log message, 
 // but makes no attempt to preserve register state.
 SWIFT_RUNTIME_ATTRIBUTE_NORETURN
+SWIFT_FORMAT(2, 3)
 extern void
 fatalError(uint32_t flags, const char *format, ...);
 
 /// swift::warning() emits a warning from the runtime.
 extern void
+SWIFT_VFORMAT(2)
 warningv(uint32_t flags, const char *format, va_list args);
 
 /// swift::warning() emits a warning from the runtime.
 extern void
+SWIFT_FORMAT(2, 3)
 warning(uint32_t flags, const char *format, ...);
 
 // swift_dynamicCastFailure halts using fatalError()

diff --git a/include/swift/SIL/DebugUtils.h b/include/swift/SIL/DebugUtils.h
@@ -174,6 +174,18 @@ inline SILInstruction *getSingleNonDebugUser(SILValue V) {
   return I->getUser();
 }
 
+/// If \p value has a single debug user, return the operand associated with that
+/// use. Otherwise, returns nullptr.
+inline Operand *getSingleDebugUse(SILValue value) {
+  auto range = getDebugUses(value);
+  auto ii = range.begin(), ie = range.end();
+  if (ii == ie)
+    return nullptr;
+  if (std::next(ii) != ie)
+    return nullptr;
+  return *ii;
+}
+
 /// Erases the instruction \p I from it's parent block and deletes it, including
 /// all debug instructions which use \p I.
 /// Precondition: The instruction may only have debug instructions as uses.

diff --git a/include/swift/SIL/MemAccessUtils.h b/include/swift/SIL/MemAccessUtils.h
@@ -204,6 +204,11 @@ SILValue findReferenceRoot(SILValue ref);
 /// Find the first owned root of the reference.
 SILValue findOwnershipReferenceRoot(SILValue ref);
 
+/// Look through all ownership forwarding instructions to find the values which
+/// were originally borrowed.
+void findGuaranteedReferenceRoots(SILValue value,
+                                  SmallVectorImpl<SILValue> &roots);
+
 /// Find the aggregate containing the first owned root of the
 /// reference. Identical to findOwnershipReferenceRoot, but looks through
 /// struct_extract, tuple_extract, etc.

diff --git a/include/swift/SIL/SILType.h b/include/swift/SIL/SILType.h
@@ -620,6 +620,9 @@ class SILType {
   /// Get the SIL token type.
   static SILType getSILTokenType(const ASTContext &C);
 
+  /// Return '()'
+  static SILType getEmptyTupleType(const ASTContext &C);
+
   //
   // Utilities for treating SILType as a pointer-like type.
   //