Merge branch 'apple:main' into main

Author: Genaro-Chris

docs/ReferenceGuides/UnderscoredAttributes.md

@@ -437,19 +437,19 @@ the export name.
 
 It's the equivalent of clang's `__attribute__((export_name))`.
 
-## `@extern(<language>)`
+## `@_extern(<language>)`
 
 Indicates that a particular declaration should be imported
 from the external environment.
 
-### `@extern(wasm, module: <"moduleName">, name: <"fieldName">)`
+### `@_extern(wasm, module: <"moduleName">, name: <"fieldName">)`
 
 Indicates that a particular declaration should be imported
 through WebAssembly's import interface.
 
 It's the equivalent of clang's `__attribute__((import_module("module"), import_name("field")))`.
 
-### `@extern(c, [, <"cName">])`
+### `@_extern(c, [, <"cName">])`
 
 Indicates that a particular declaration should refer to a
 C declaration with the given name. If the optional "cName"
@@ -462,7 +462,7 @@ C declarations from Swift, while `@_cdecl` is used to define
 Swift functions that can be referenced from C.
 
 Also similar to `@_silgen_name`, but a function declared with
-`@extern(c)` is assumed to use the C ABI, while `@_silgen_name`
+`@_extern(c)` is assumed to use the C ABI, while `@_silgen_name`
 assumes the Swift ABI.
 
 ## `@_fixed_layout`

docs/SIL.rst

@@ -4799,6 +4799,71 @@ eliminated. However, a memory location ``%a`` must not be accessed
 after ``destroy_addr %a`` (which has not yet been eliminated)
 regardless of its type.
 
+tuple_addr_constructor
+``````````````````````
+
+::
+
+   sil-instruction ::= 'tuple_addr_constructor' sil-tuple-addr-constructor-init sil-operand 'with' sil-tuple-addr-constructor-elements
+   sil-tuple-addr-constructor-init ::= init|assign
+   sil-tuple-addr-constructor-elements ::= '(' (sil-operand (',' sil-operand)*)? ')'
+
+   // %destAddr has the type $*(Type1, Type2, Type3). Note how we convert all of the types
+   // to their address form.
+   %1 = tuple_addr_constructor [init] %destAddr : $*(Type1, Type2, Type3) with (%a : $Type1, %b : $*Type2, %c : $Type3)
+
+Creates a new tuple in memory from an exploded list of object and address
+values. The SSA values form the leaf elements of the exploded tuple. So for a
+simple tuple that only has top level tuple elements, then the instruction lowers
+as follows::
+
+  %1 = tuple_addr_constructor [init] %destAddr : $*(Type1, Type2, Type3) with (%a : $Type1, %b : $*Type2, %c : $Type3)
+  
+  -->
+  
+  %0 = tuple_element_addr %destAddr : $*(Type1, Type2, Type3), 0
+  store %a to [init] %0 : $*Type1
+  %1 = tuple_element_addr %destAddr : $*(Type1, Type2, Type3), 1
+  copy_addr %b to [init] %1 : $*Type2
+  %2 = tuple_element_addr %destAddr : $*(Type1, Type2, Type3), 2
+  store %2 to [init] %2 : $*Type3
+
+A ``tuple_addr_constructor`` is lowered similarly with each store/copy_addr
+being changed to their dest assign form.
+
+In contrast, if we have a more complicated form of tuple with sub-tuples, then
+we read one element from the list as we process the tuple recursively from left
+to right. So for instance we would lower as follows a more complicated tuple::
+
+  %1 = tuple_addr_constructor [init] %destAddr : $*((), (Type1, ((), Type2)), Type3) with (%a : $Type1, %b : $*Type2, %c : $Type3)
+
+  ->
+
+  %0 = tuple_element_addr %destAddr : $*((), (Type1, ((), Type2)), Type3), 1
+  %1 = tuple_element_addr %0 : $*(Type1, ((), Type2)), 0
+  store %a to [init] %1 : $*Type1
+  %2 = tuple_element_addr %0 : $*(Type1, ((), Type2)), 1
+  %3 = tuple_element_addr %2 : $*((), Type2), 1
+  copy_addr %b to [init] %3 : $*Type2
+  %4 = tuple_element_addr %destAddr : $*((), (Type1, ((), Type2)), Type3), 2
+  store %c to [init] %4 : $*Type3
+
+This instruction exists to enable for SILGen to init and assign RValues into
+tuples with a single instruction. Since an RValue is a potentially exploded
+tuple, we are forced to use our representation here. If SILGen instead just uses
+separate address projections and stores when it sees such an aggregate,
+diagnostic SIL passes can not tell the difference semantically in between
+initializing a tuple in parts or at once::
+
+  var arg = (Type1(), Type2())
+  
+  // This looks the same at the SIL level...
+  arg = (a, b)
+  
+  // to assigning in pieces even though we have formed a new tuple.
+  arg.0 = a
+  arg.1 = a
+
 index_addr
 ``````````
 ::

include/swift/AST/Attr.def

@@ -421,7 +421,7 @@ DECL_ATTR(_section, Section,
 DECL_ATTR(_rawLayout, RawLayout,
   OnStruct | UserInaccessible | ABIBreakingToAdd | ABIBreakingToRemove | APIStableToAdd | APIStableToRemove,
   146)
-DECL_ATTR(extern, Extern,
+DECL_ATTR(_extern, Extern,
   OnFunc | AllowMultipleAttributes | ABIBreakingToAdd | ABIBreakingToRemove | APIStableToAdd | APIStableToRemove,
   147)
 SIMPLE_DECL_ATTR(_nonEscapable, NonEscapable,

include/swift/AST/Attr.h

@@ -2343,7 +2343,7 @@ class ExposeAttr : public DeclAttribute {
   }
 };
 
-/// Define the `@extern` attribute, used to import external declarations in
+/// Define the `@_extern` attribute, used to import external declarations in
 /// the specified way to interoperate with Swift.
 class ExternAttr : public DeclAttribute {
   SourceLoc LParenLoc, RParenLoc;
@@ -2368,7 +2368,7 @@ class ExternAttr : public DeclAttribute {
   const llvm::Optional<StringRef> ModuleName;
 
   /// The declaration name to import
-  /// std::nullopt if the declaration name is not specified with @extern(c)
+  /// std::nullopt if the declaration name is not specified with @_extern(c)
   const llvm::Optional<StringRef> Name;
 
   SourceLoc getLParenLoc() const { return LParenLoc; }

include/swift/AST/AttrKind.h

@@ -112,7 +112,7 @@ enum class ExposureKind: uint8_t {
 enum : unsigned { NumExposureKindBits =
   countBitsUsed(static_cast<unsigned>(ExposureKind::Last_ExposureKind)) };
 
-/// This enum represents the possible values of the @extern attribute.
+/// This enum represents the possible values of the @_extern attribute.
 enum class ExternKind: uint8_t {
   /// Reference an externally defined C function.
   /// The imported function has C function pointer representation,

include/swift/AST/Decl.h

@@ -94,6 +94,7 @@ namespace swift {
   class NamedPattern;
   class EnumCaseDecl;
   class EnumElementDecl;
+  struct InverseMarking;
   class ParameterList;
   class ParameterTypeFlags;
   class Pattern;
@@ -3117,15 +3118,6 @@ class TypeDecl : public ValueDecl {
 private:
   ArrayRef<InheritedEntry> Inherited;
 
-  struct {
-    /// Whether the "hasNoncopyableAnnotation" bit has been computed yet.
-    unsigned isNoncopyableAnnotationComputed : 1;
-
-    /// Whether this declaration had a noncopyable inverse written somewhere.
-    unsigned hasNoncopyableAnnotation : 1;
-  } LazySemanticInfo = { };
-  friend class HasNoncopyableAnnotationRequest;
-
 protected:
   TypeDecl(DeclKind K, llvm::PointerUnion<DeclContext *, ASTContext *> context,
            Identifier name, SourceLoc NameLoc,
@@ -3153,9 +3145,13 @@ class TypeDecl : public ValueDecl {
 
   void setInherited(ArrayRef<InheritedEntry> i) { Inherited = i; }
 
-  /// Is this type _always_ noncopyable? Will answer 'false' if the type is
-  /// conditionally copyable.
-  bool isNoncopyable() const;
+  /// Is it possible for this type to lack a Copyable constraint?
+  /// If you need a more precise answer, ask this Decl's corresponding
+  /// Type if it `isNoncopyable` instead of using this.
+  bool canBeNoncopyable() const;
+
+  /// Determine how the ~Copyable was applied to this TypeDecl, if at all.
+  InverseMarking getNoncopyableMarking() const;
 
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_TypeDecl &&

include/swift/AST/DiagnosticsParse.def

@@ -429,8 +429,6 @@ ERROR(destructor_decl_outside_class_or_noncopyable,none,
       "deinitializers may only be declared within a class, actor, or noncopyable type", ())
 ERROR(destructor_decl_on_noncopyable_enum,none,
       "deinitializers are not yet supported on noncopyable enums", ())
-ERROR(destructor_decl_on_objc_enum,none,
-      "deinitializers cannot be declared on an @objc enum type", ())
 ERROR(expected_lbrace_destructor,PointsToFirstBadToken,
       "expected '{' for deinitializer", ())
 ERROR(destructor_has_name,PointsToFirstBadToken,
@@ -1869,7 +1867,7 @@ ERROR(attr_rawlayout_expected_params,none,
       "expected %1 argument after %0 argument in @_rawLayout attribute", (StringRef, StringRef))
 
 ERROR(attr_extern_expected_label,none,
-      "expected %0 argument to @extern attribute", (StringRef))
+      "expected %0 argument to @_extern attribute", (StringRef))
 //------------------------------------------------------------------------------
 // MARK: Generics parsing diagnostics
 //------------------------------------------------------------------------------

include/swift/AST/DiagnosticsSema.def

@@ -1900,17 +1900,17 @@ ERROR(section_not_at_top_level,none,
 ERROR(section_empty_name,none,
       "@_section section name cannot be empty", ())
 
-// @extern
+// @_extern
 ERROR(attr_extern_experimental,none,
-      "@extern requires '-enable-experimental-feature Extern'", ())
+      "@_extern requires '-enable-experimental-feature Extern'", ())
 ERROR(extern_not_at_top_level_func,none,
-      "@extern attribute can only be applied to global functions", ())
+      "@_extern attribute can only be applied to global functions", ())
 ERROR(extern_empty_c_name,none,
-      "expected non-empty C name in @extern attribute", ())
+      "expected non-empty C name in @_extern attribute", ())
 ERROR(extern_only_non_other_attr,none,
-      "@extern attribute cannot be applied to an '@%0' declaration", (StringRef))
+      "@_extern attribute cannot be applied to an '@%0' declaration", (StringRef))
 WARNING(extern_c_maybe_invalid_name, none,
-        "C name '%0' may be invalid; explicitly specify the name in @extern(c) to suppress this warning",
+        "C name '%0' may be invalid; explicitly specify the name in @_extern(c) to suppress this warning",
         (StringRef))
 
 ERROR(c_func_variadic, none,
@@ -3170,7 +3170,7 @@ ERROR(recursive_superclass_constraint,none,
 ERROR(requires_same_concrete_type,none,
       "generic signature requires types %0 and %1 to be the same", (Type, Type))
 WARNING(redundant_conformance_constraint,none,
-        "redundant conformance constraint %0 : %1", (Type, ProtocolDecl *))
+        "redundant conformance constraint %0 : %1", (Type, Type))
 
 WARNING(missing_protocol_refinement, none,
         "protocol %0 should be declared to refine %1 due to a same-type constraint on 'Self'",
@@ -7533,22 +7533,34 @@ ERROR(accessor_macro_not_single_var, none,
 //------------------------------------------------------------------------------
 // MARK: Noncopyable Types Diagnostics
 //------------------------------------------------------------------------------
-
+ERROR(noncopyable_but_copyable, none,
+      "%kind0 required to be 'Copyable' but is marked with '~Copyable'",
+      (const ValueDecl *))
 ERROR(noncopyable_class, none,
       "classes cannot be noncopyable",
       ())
+ERROR(inverse_extension, none,
+      "cannot apply inverse %0 to extension",
+      (Type))
+ERROR(copyable_illegal_deinit, none,
+      "deinitializer cannot be declared in %kind0 that conforms to 'Copyable'",
+      (const ValueDecl *))
 ERROR(noncopyable_type_member_in_copyable,none,
       "%select{stored property %2|associated value %2}1 of "
       "'Copyable'-conforming %kind3 has noncopyable type %0",
       (Type, bool, DeclName, const ValueDecl *))
-NOTE(add_inverse_for_containment,none,
-     "consider removing implicit '%1' conformance from %kind0",
+NOTE(add_inverse,none,
+     "consider adding '~%1' to %kind0",
      (const ValueDecl *, StringRef))
-NOTE(remove_inverse_on_generic_parameter_for_conformance,none,
-     "consider removing '~%1' from generic parameter %0 so it conforms to the '%1' protocol",
+NOTE(note_inverse_preventing_conformance,none,
+     "%0 has '~%1' constraint preventing implicit '%1' conformance",
      (Type, StringRef))
-NOTE(remove_inverse_on_nominal_for_conformance,none,
-     "consider removing '~%1' from %kind0 so it conforms to the '%1' protocol",
+NOTE(note_inverse_preventing_conformance_implicit,none,
+     "%kind0 has '~%1' constraint on a generic parameter, "
+     "making its '%1' conformance conditional",
+     (const ValueDecl *, StringRef))
+NOTE(note_inverse_preventing_conformance_explicit,none,
+     "%kind0 has '~%1' constraint preventing '%1' conformance",
      (const ValueDecl *, StringRef))
 NOTE(add_explicit_protocol_for_conformance,none,
      "consider making %kind0 explicitly conform to the '%1' protocol",

include/swift/AST/InverseMarking.h

@@ -0,0 +1,110 @@
+//===- InverseMarking.h - Utilities for tracking inverse types -*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_LIB_SEMA_INVERSEMARKING_H
+#define SWIFT_LIB_SEMA_INVERSEMARKING_H
+
+#include "swift/AST/KnownProtocols.h"
+#include "swift/Basic/SourceLoc.h"
+#include "swift/Basic/OptionalEnum.h"
+
+namespace swift {
+
+/// Describes the way an inverse and its corresponding positive contraint
+/// appears on a TypeDecl, i.e., the way it was marked.
+struct InverseMarking {
+  enum class Kind : uint8_t {
+    None,            // No inverse marking is present
+    Inferred,        // Inverse is inferred based on generic parameters.
+    Explicit,        // Inverse is explicitly present.
+
+    LAST = Explicit
+  };
+
+  // Describes what kind of mark was found, if any.
+  struct Mark {
+  private:
+    OptionalEnum<Kind> kind;
+    SourceLoc loc;
+  public:
+    // Creates an empty mark.
+    Mark() {};
+
+    // Creates a mark.
+    Mark(Kind k, SourceLoc l = SourceLoc())
+      : kind(k), loc(l) {};
+
+    // Is there an inferred or explicit marking?
+    bool isPresent() const {
+      return getKind() != Kind::None;
+    }
+    operator bool() { return isPresent(); }
+
+    Kind getKind() const {
+      return kind.getValueOr(Kind::None);
+    }
+
+    SourceLoc getLoc() const { return loc; }
+
+    void set(Kind k, SourceLoc l = SourceLoc()) {
+      assert(!kind.hasValue());
+      kind = k;
+      loc = l;
+    }
+
+    void setIfUnset(Kind k, SourceLoc l = SourceLoc()) {
+      if (kind.hasValue())
+        return;
+      set(k, l);
+    }
+
+    void setIfUnset(Mark other) {
+      if (kind.hasValue())
+        return;
+      kind = other.kind;
+      loc = other.loc;
+    }
+
+    Mark with(Kind k) {
+      kind = k;
+      return *this;
+    }
+  };
+
+private:
+  Mark inverse;
+  Mark positive;
+public:
+
+  // Creates an empty marking.
+  InverseMarking() {}
+
+  Mark &getInverse() { return inverse; }
+  Mark &getPositive() { return positive; }
+
+  // Merge the results of another marking into this one.
+  void merge(InverseMarking other) const {
+    other.inverse.setIfUnset(other.inverse);
+    other.positive.setIfUnset(other.positive);
+  }
+
+  static InverseMarking forInverse(Kind kind, SourceLoc loc = SourceLoc()) {
+    InverseMarking marking;
+    marking.inverse.set(kind, loc);
+    marking.positive.set(Kind::None);
+    return marking;
+  }
+};
+
+}
+
+#endif //SWIFT_LIB_SEMA_INVERSEMARKING_H