Merge branch 'main' of github.com:swiftwasm/swift into maxd/main-merge

Author: MaxDesiatov

cmake/modules/SwiftManpage.cmake

@@ -39,8 +39,12 @@ function(manpage)
       ALL)
 
   add_dependencies(${MP_INSTALL_IN_COMPONENT} ${manpage_target})
+  set(MANPAGE_DEST "share/")
+  if("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "OPENBSD")
+    set(MANPAGE_DEST "")
+  endif()
   swift_install_in_component(FILES "${output_file_name}"
-                             DESTINATION "share/man/man${MP_MAN_SECTION}"
+                             DESTINATION "${MANPAGE_DEST}man/man${MP_MAN_SECTION}"
                              COMPONENT "${MP_INSTALL_IN_COMPONENT}")
 endfunction()
 

include/swift/AST/DiagnosticsDriver.def

@@ -193,8 +193,5 @@ WARNING(warn_drv_darwin_sdk_invalid_settings, none,
 REMARK(remark_forwarding_to_new_driver, none,
        "new Swift driver at '%0' will be used", (StringRef))
 
-REMARK(remark_forwarding_driver_not_there, none,
-      "new Swift driver at '%0' cannot be found; C++ driver will be used", (StringRef))
-
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/DiagnosticsSema.def

@@ -1112,9 +1112,13 @@ ERROR(missing_unwrap_optional_try,none,
       "value of optional type %0 not unwrapped; did you mean to use 'try!' "
       "or chain with '?'?",
      (Type))
-ERROR(missing_forced_downcast,none,
-      "%0 is not convertible to %1; "
-      "did you mean to use 'as!' to force downcast?", (Type, Type))
+ERROR(cannot_coerce_to_type, none,
+      "%0 is not convertible to %1", (Type, Type))
+NOTE(missing_forced_downcast, none,
+     "did you mean to use 'as!' to force downcast?", ())
+NOTE(missing_optional_downcast, none,
+     "did you mean to use 'as?' to conditionally downcast?", ())
+     
 WARNING(coercion_may_fail_warning,none,
         "coercion from %0 to %1 may fail; use 'as?' or 'as!' instead",
         (Type, Type))
@@ -1788,6 +1792,10 @@ ERROR(spi_attribute_on_protocol_requirement,none,
 ERROR(spi_attribute_on_frozen_stored_properties,none,
       "stored property %0 cannot be declared '@_spi' in a '@frozen' struct",
       (DeclName))
+WARNING(spi_attribute_on_import_of_public_module,none,
+        "'@_spi' import of %0 will not include any SPI symbols; "
+        "%0 was built from the public interface at %1",
+        (DeclName, StringRef))
 
 // Opaque return types
 ERROR(opaque_type_invalid_constraint,none,
@@ -2615,6 +2623,9 @@ WARNING(duplicate_anyobject_class_inheritance,none,
   "redundant inheritance from 'AnyObject' and Swift 3 'class' keyword", ())
 ERROR(inheritance_from_protocol_with_superclass,none,
   "inheritance from class-constrained protocol composition type %0", (Type))
+WARNING(anyobject_class_inheritance_deprecated,none,
+  "using 'class' keyword for protocol inheritance is deprecated; "
+  "use 'AnyObject' instead", ())
 ERROR(multiple_inheritance,none,
   "multiple inheritance from classes %0 and %1", (Type, Type))
 ERROR(inheritance_from_non_protocol_or_class,none,

include/swift/Basic/InlineBitfield.h

@@ -81,6 +81,32 @@ namespace swift {
   LLVM_PACKED_END \
   static_assert(sizeof(T##Bitfield) <= 8, "Bitfield overflow")
 
+/// Define a full bitfield for type 'T' that uses all of the remaining bits in
+/// the inline bitfield. We allow for 'T' to have a single generic parameter.
+///
+/// For optimal code gen, place naturally sized fields at the end, with the
+/// largest naturally sized field at the very end. For example:
+///
+/// SWIFT_INLINE_BITFIELD_FULL(Foo, Bar, 1+8+16,
+///   flag : 1,
+///   : NumPadBits, // pad the center, not the end
+///   x : 8,
+///   y : 16
+/// );
+///
+/// NOTE: All instances of Foo will access via the same bitfield entry even if
+/// they differ in the templated value!
+#define SWIFT_INLINE_BITFIELD_FULL_TEMPLATE(T, U, C, ...)                      \
+  LLVM_PACKED_START                                                            \
+  class T##Bitfield {                                                          \
+    template <typename TTy>                                                    \
+    friend class T;                                                            \
+    enum { NumPadBits = 64 - (Num##U##Bits + (C)) };                           \
+    uint64_t : Num##U##Bits, __VA_ARGS__;                                      \
+  } T;                                                                         \
+  LLVM_PACKED_END                                                              \
+  static_assert(sizeof(T##Bitfield) <= 8, "Bitfield overflow")
+
 /// Define an empty bitfield for type 'T'.
 #define SWIFT_INLINE_BITFIELD_EMPTY(T, U) \
   enum { Num##T##Bits = Num##U##Bits }

include/swift/SIL/OwnershipUtils.h

@@ -32,33 +32,22 @@ class DeadEndBlocks;
 /// Returns true if v is an address or trivial.
 bool isValueAddressOrTrivial(SILValue v);
 
-/// These operations forward both owned and guaranteed ownership.
-bool isOwnershipForwardingValueKind(SILNodeKind kind);
-
-/// Is this an operand that can forward both owned and guaranteed ownership
-/// kinds.
+/// Is this an operand that can forward both owned and guaranteed ownership into
+/// one of the operand's owner instruction's result.
 bool isOwnershipForwardingUse(Operand *op);
 
-/// Is this an operand that forwards guaranteed ownership from its value to a
-/// result of the using instruction.
+/// Is this an operand that can forward guaranteed ownership into one of the
+/// operand's owner instruction's result.
 bool isGuaranteedForwardingUse(Operand *op);
 
-/// These operations forward guaranteed ownership, but don't necessarily forward
-/// owned values.
-bool isGuaranteedForwardingValueKind(SILNodeKind kind);
+/// Is this an operand that can forward owned ownership into one of the
+/// operand's owner instruction's result.
+bool isOwnedForwardingUse(Operand *use);
 
-/// Is this a value that is the result of an operation that forwards owned
-/// ownership.
+/// Is this a value that is the result of an instruction that forwards
+/// guaranteed ownership from one of its operands.
 bool isGuaranteedForwardingValue(SILValue value);
 
-/// Is this a node kind that can forward owned ownership, but may not be able to
-/// forward guaranteed ownership.
-bool isOwnedForwardingValueKind(SILNodeKind kind);
-
-/// Does this operand 'forward' owned ownership, but may not be able to forward
-/// guaranteed ownership.
-bool isOwnedForwardingUse(Operand *use);
-
 /// Is this value the result of an instruction that 'forward's owned ownership,
 /// but may not be able to forward guaranteed ownership.
 ///
@@ -76,6 +65,11 @@ class ForwardingOperand {
   static Optional<ForwardingOperand> get(Operand *use);
 
   Operand *getUse() const { return use; }
+  OwnershipConstraint getOwnershipConstraint() const {
+    // We use a force unwrap since a ForwardingOperand should always have an
+    // ownership constraint.
+    return *use->getOwnershipConstraint();
+  }
   ValueOwnershipKind getOwnershipKind() const;
   void setOwnershipKind(ValueOwnershipKind newKind) const;
   void replaceOwnershipKind(ValueOwnershipKind oldKind,