Manually merge main to rebranch

CONTRIBUTING.md

@@ -236,7 +236,7 @@ To switch to this template when drafting a pull request in a [swiftlang](https:/
 ### Commit Access
 
 Commit access is granted to contributors with a track record of submitting high-quality changes.
-If you would like commit access, please send an email to [the code owners list]([email protected]) with the GitHub user name that you want to use and a list of 5 non-trivial pull requests that were accepted without modifications.
+If you would like commit access, please send an email to [the code owners list](mailto:[email protected]) with the GitHub user name that you want to use and a list of 5 non-trivial pull requests that were accepted without modifications.
 
 Once you’ve been granted commit access, you will be able to commit to all of the GitHub repositories that host Swift.org projects.
 To verify that your commit access works, please make a test commit (for example, change a comment or add a blank line). The following policies apply to users with commit access:

SwiftCompilerSources/Sources/Optimizer/Utilities/GenericSpecialization.swift

@@ -86,6 +86,7 @@ private struct VTableSpecializer {
       let methodSubs = classContextSubs.getMethodSubstitutions(for: entry.implementation)
 
       guard !methodSubs.conformances.contains(where: {!$0.isValid}),
+            context.loadFunction(function: entry.implementation, loadCalleesRecursively: true),
             let specializedMethod = context.specialize(function: entry.implementation, for: methodSubs) else
       {
         context.diagnosticEngine.diagnose(entry.methodDecl.location.sourceLoc, .non_final_generic_class_function)
@@ -125,6 +126,7 @@ func specializeWitnessTable(forConformance conformance: Conformance,
       let methodSubs = conformance.specializedSubstitutions.getMethodSubstitutions(for: origMethod)
 
       guard !methodSubs.conformances.contains(where: {!$0.isValid}),
+            context.loadFunction(function: origMethod, loadCalleesRecursively: true),
             let specializedMethod = context.specialize(function: origMethod, for: methodSubs) else
       {
         context.diagnosticEngine.diagnose(errorLocation.sourceLoc, .cannot_specialize_witness_method, requirement)

docs/ABI/Mangling.rst

@@ -693,6 +693,7 @@ Types
   type ::= 'Bp'                              // Builtin.RawPointer
   type ::= 'Bt'                              // Builtin.SILToken
   type ::= type 'Bv' NATURAL '_'             // Builtin.Vec<n>x<type>
+  type ::= type type 'BV'                    // Builtin.FixedArray<N, T>
   type ::= 'Bw'                              // Builtin.Word
   type ::= function-signature 'c'            // function type (escaping)
   type ::= function-signature 'X' FUNCTION-KIND // special function type

include/swift/ABI/Metadata.h

@@ -1665,6 +1665,27 @@ struct TargetMetatypeMetadata : public TargetMetadata<Runtime> {
 };
 using MetatypeMetadata = TargetMetatypeMetadata<InProcess>;
 
+/// The structure of `Builtin.FixedArray` type metadata.
+template <typename Runtime>
+struct TargetFixedArrayTypeMetadata : public TargetMetadata<Runtime> {
+  using StoredPointerDifference = typename Runtime::StoredPointerDifference;
+
+  StoredPointerDifference Count;
+  ConstTargetMetadataPointer<Runtime, swift::TargetMetadata> Element;
+
+  // Returns the number of elements for which storage is reserved.
+  // A type that is instantiated with negative size cannot have values
+  // instantiated, so is laid out with zero size like an uninhabited type.
+  StoredPointerDifference getRealizedCount() const {
+    return Count < 0 ? 0 : Count;
+  }
+
+  static bool classof(const TargetMetadata<Runtime> *metadata) {
+    return metadata->getKind() == MetadataKind::FixedArray;
+  }
+};
+using FixedArrayTypeMetadata = TargetFixedArrayTypeMetadata<InProcess>;
+
 /// The structure of tuple type metadata.
 template <typename Runtime>
 struct TargetTupleTypeMetadata : public TargetMetadata<Runtime> {

include/swift/ABI/MetadataKind.def

@@ -44,7 +44,6 @@ NOMINALTYPEMETADATAKIND(Class, 0)
 NOMINALTYPEMETADATAKIND(Struct, 0 | MetadataKindIsNonHeap)
 
 /// An enum type.
-/// If we add reference enums, that needs to go here.
 NOMINALTYPEMETADATAKIND(Enum, 1 | MetadataKindIsNonHeap)
 
 /// An optional type.
@@ -80,6 +79,10 @@ METADATAKIND(ExistentialMetatype, 6 | MetadataKindIsRuntimePrivate | MetadataKin
 /// An extended existential type.
 METADATAKIND(ExtendedExistential, 7 | MetadataKindIsRuntimePrivate | MetadataKindIsNonHeap)
 
+/// A `Builtin.FixedArray`.
+METADATAKIND(FixedArray, 8 | MetadataKindIsRuntimePrivate | MetadataKindIsNonHeap)
+
+
 /// A heap-allocated local variable using statically-generated metadata.
 METADATAKIND(HeapLocalVariable, 0 | MetadataKindIsNonType)
 

include/swift/AST/Builtins.def

@@ -1126,6 +1126,13 @@ BUILTIN_MISC_OPERATION_WITH_SILGEN(DistributedActorAsAnyActor, "distributedActor
 /// lowered away at IRGen, no sooner.
 BUILTIN_MISC_OPERATION_WITH_SILGEN(AddressOfRawLayout, "addressOfRawLayout", "n", Special)
 
+/// emplace<T>((Builtin.RawPointer) -> Void) -> T
+///
+/// Passes a pointer to an uninitialized result value to the given function,
+/// which must initialize the memory before finishing execution. The value in
+/// memory becomes the result of the call.
+BUILTIN_SIL_OPERATION(Emplace, "emplace", Special)
+
 /// Builtins for instrumentation added by sanitizers during SILGen.
 #ifndef BUILTIN_SANITIZER_OPERATION
 #define BUILTIN_SANITIZER_OPERATION(Id, Name, Attrs) BUILTIN(Id, Name, Attrs)

include/swift/AST/DiagnosticsParse.def

@@ -255,6 +255,8 @@ ERROR(static_var_decl_global_scope,none,
       (StaticSpellingKind))
 ERROR(expected_getset_in_protocol,none,
       "expected get or set in a protocol property", ())
+ERROR(expected_getreadset_in_protocol,none,
+      "expected get, read, or set in a protocol property", ())
 ERROR(unexpected_getset_implementation_in_protocol,none,
       "protocol property %0 cannot have a default implementation specified "
       "here; use extension instead", (StringRef))

include/swift/AST/DiagnosticsSema.def

@@ -4641,6 +4641,8 @@ ERROR(cannot_explicitly_specialize_function,none,
       "cannot explicitly specialize %kind0", (ValueDecl *))
 ERROR(not_a_generic_type,none,
       "cannot specialize non-generic type %0", (Type))
+ERROR(invalid_generic_builtin_type,none,
+      "invalid generic arguments to builtin type %0", (Type))
 ERROR(not_a_generic_macro,none,
       "cannot specialize a non-generic external macro %0", (const ValueDecl *))
 ERROR(protocol_declares_unknown_primary_assoc_type,none,

include/swift/AST/ExistentialLayout.h

@@ -10,7 +10,11 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file defines the ExistentialLayout struct.
+// The ExistentialLayout struct describes the in-memory layout of an existential
+// type.
+//
+// It flattens and canonicalizes protocol compositions, and also expands defaults
+// for invertible protocols.
 //
 //===----------------------------------------------------------------------===//
 
@@ -33,7 +37,6 @@ struct ExistentialLayout {
     hasExplicitAnyObject = false;
     containsObjCProtocol = false;
     containsSwiftProtocol = false;
-    containsParameterized = false;
     representsAnyObject = false;
   }
 
@@ -53,9 +56,6 @@ struct ExistentialLayout {
   /// Whether any protocol members require a witness table.
   bool containsSwiftProtocol : 1;
 
-  /// Whether any protocol members are parameterized.s
-  bool containsParameterized : 1;
-
   /// Whether this layout is the canonical layout for plain-old 'AnyObject'.
   bool representsAnyObject : 1;
 
@@ -105,14 +105,18 @@ struct ExistentialLayout {
   /// calling this on a temporary is likely to be incorrect.
   ArrayRef<ProtocolDecl*> getProtocols() const && = delete;
 
+  ArrayRef<ParameterizedProtocolType *> getParameterizedProtocols() const & {
+    return parameterized;
+  }
+  /// The returned ArrayRef points to internal storage, so
+  /// calling this on a temporary is likely to be incorrect.
+  ArrayRef<ProtocolDecl*> getParameterizedProtocols() const && = delete;
+
   LayoutConstraint getLayoutConstraint() const;
 
 private:
   SmallVector<ProtocolDecl *, 4> protocols;
-
-  /// Zero or more primary associated type requirements from a
-  /// ParameterizedProtocolType
-  ArrayRef<Type> sameTypeRequirements;
+  SmallVector<ParameterizedProtocolType *, 4> parameterized;
 };
 
 }

include/swift/AST/TypeDifferenceVisitor.h

@@ -129,6 +129,19 @@ class CanTypeDifferenceVisitor : public CanTypePairVisitor<Impl, bool> {
       return asImpl().visitDifferentTypeStructure(type1, type2);
     return asImpl().visit(type1.getElementType(), type2.getElementType());
   }
+
+  bool visitBuiltinUnboundGenericType(CanBuiltinUnboundGenericType type1,
+                                      CanBuiltinUnboundGenericType type2) {
+    return asImpl().visitDifferentTypeStructure(type1, type2);
+  }
+
+  bool visitBuiltinFixedArrayType(CanBuiltinFixedArrayType type1,
+                                  CanBuiltinFixedArrayType type2) {
+    if (asImpl().visit(type1->getSize(), type2->getSize())) {
+      return true;
+    }
+    return asImpl().visit(type1->getElementType(), type2->getElementType());
+  }
 
   bool visitPackType(CanPackType type1, CanPackType type2) {
     return visitComponentArray(type1, type2,

include/swift/AST/TypeMatcher.h

@@ -111,6 +111,8 @@ class TypeMatcher {
     TRIVIAL_CASE(BuiltinIntegerType)
     TRIVIAL_CASE(BuiltinFloatType)
     TRIVIAL_CASE(BuiltinVectorType)
+    TRIVIAL_CASE(BuiltinUnboundGenericType)
+    TRIVIAL_CASE(BuiltinFixedArrayType)
     TRIVIAL_CASE(IntegerType)
 #define SINGLETON_TYPE(SHORT_ID, ID) TRIVIAL_CASE(ID##Type)
 #include "swift/AST/TypeNodes.def"

include/swift/AST/TypeNodes.def

@@ -27,6 +27,14 @@
 ///   This type is a builtin type. The default behavior is
 ///   ALWAYS_CANONICAL_TYPE(id, parent).
 
+/// BUILTIN_CONCRETE_TYPE(id, parent)
+///   This type is a builtin type without generic parameters. The default
+///   behavior is BUILTIN_TYPE(id, parent).
+
+/// BUILTIN_GENERIC_TYPE(id, parent)
+///   This type is a builtin type with generic parameters. The default
+///   behavior is BUILTIN_TYPE(id, parent).
+
 /// SUGARED_TYPE(id, parent)
 ///   This type is never canonical.  It provides an efficient accessor,
 ///   getSinglyDesugaredType(), which removes one level of sugar.  This
@@ -72,6 +80,14 @@
 #define BUILTIN_TYPE(id, parent) ALWAYS_CANONICAL_TYPE(id, parent)
 #endif
 
+#ifndef BUILTIN_CONCRETE_TYPE
+#define BUILTIN_CONCRETE_TYPE(id, parent) BUILTIN_TYPE(id, parent)
+#endif
+
+#ifndef BUILTIN_GENERIC_TYPE
+#define BUILTIN_GENERIC_TYPE(id, parent) BUILTIN_TYPE(id, parent)
+#endif
+
 #ifndef SUGARED_TYPE
 #define SUGARED_TYPE(id, parent) TYPE(id, parent)
 #endif
@@ -111,22 +127,24 @@ UNCHECKED_TYPE(Unresolved, Type)
 UNCHECKED_TYPE(Placeholder, Type)
 ABSTRACT_TYPE(Builtin, Type)
   ABSTRACT_TYPE(AnyBuiltinInteger, BuiltinType)
-    BUILTIN_TYPE(BuiltinInteger, AnyBuiltinIntegerType)
-    BUILTIN_TYPE(BuiltinIntegerLiteral, AnyBuiltinIntegerType)
+    BUILTIN_CONCRETE_TYPE(BuiltinInteger, AnyBuiltinIntegerType)
+    BUILTIN_CONCRETE_TYPE(BuiltinIntegerLiteral, AnyBuiltinIntegerType)
     TYPE_RANGE(AnyBuiltinInteger, BuiltinInteger, BuiltinIntegerLiteral)
-  BUILTIN_TYPE(BuiltinExecutor, BuiltinType)
-  BUILTIN_TYPE(BuiltinFloat, BuiltinType)
-  BUILTIN_TYPE(BuiltinJob, BuiltinType)
-  BUILTIN_TYPE(BuiltinPackIndex, BuiltinType)
-  BUILTIN_TYPE(BuiltinRawPointer, BuiltinType)
-  BUILTIN_TYPE(BuiltinRawUnsafeContinuation, BuiltinType)
-  BUILTIN_TYPE(BuiltinNativeObject, BuiltinType)
-  BUILTIN_TYPE(BuiltinBridgeObject, BuiltinType)
-  BUILTIN_TYPE(BuiltinUnsafeValueBuffer, BuiltinType)
-  BUILTIN_TYPE(BuiltinDefaultActorStorage, BuiltinType)
-  BUILTIN_TYPE(BuiltinNonDefaultDistributedActorStorage, BuiltinType)
-  BUILTIN_TYPE(BuiltinVector, BuiltinType)
-  TYPE_RANGE(Builtin, BuiltinInteger, BuiltinVector)
+  BUILTIN_CONCRETE_TYPE(BuiltinExecutor, BuiltinType)
+  BUILTIN_CONCRETE_TYPE(BuiltinFloat, BuiltinType)
+  BUILTIN_CONCRETE_TYPE(BuiltinJob, BuiltinType)
+  BUILTIN_CONCRETE_TYPE(BuiltinPackIndex, BuiltinType)
+  BUILTIN_CONCRETE_TYPE(BuiltinRawPointer, BuiltinType)
+  BUILTIN_CONCRETE_TYPE(BuiltinRawUnsafeContinuation, BuiltinType)
+  BUILTIN_CONCRETE_TYPE(BuiltinNativeObject, BuiltinType)
+  BUILTIN_CONCRETE_TYPE(BuiltinBridgeObject, BuiltinType)
+  BUILTIN_CONCRETE_TYPE(BuiltinUnsafeValueBuffer, BuiltinType)
+  BUILTIN_CONCRETE_TYPE(BuiltinDefaultActorStorage, BuiltinType)
+  BUILTIN_CONCRETE_TYPE(BuiltinNonDefaultDistributedActorStorage, BuiltinType)
+  BUILTIN_CONCRETE_TYPE(BuiltinVector, BuiltinType)
+  BUILTIN_GENERIC_TYPE(BuiltinFixedArray, BuiltinType)
+  BUILTIN_CONCRETE_TYPE(BuiltinUnboundGeneric, BuiltinType)
+  TYPE_RANGE(Builtin, BuiltinInteger, BuiltinUnboundGeneric)
 TYPE(Tuple, Type)
 ABSTRACT_TYPE(ReferenceStorage, Type)
 #define REF_STORAGE(Name, ...) \
@@ -228,6 +246,8 @@ SINGLETON_TYPE(SILToken, SILToken)
 #undef UNCHECKED_TYPE
 #undef ARTIFICIAL_TYPE
 #undef SUGARED_TYPE
+#undef BUILTIN_GENERIC_TYPE
+#undef BUILTIN_CONCRETE_TYPE
 #undef BUILTIN_TYPE
 #undef ALWAYS_CANONICAL_TYPE
 #undef ALWAYS_CANONICAL_ARTIFICIAL_TYPE

include/swift/AST/TypeTransform.h

@@ -106,7 +106,7 @@ class TypeTransform {
     TypeBase *base = t.getPointer();
 
     switch (base->getKind()) {
-#define BUILTIN_TYPE(Id, Parent) \
+#define BUILTIN_CONCRETE_TYPE(Id, Parent) \
 case TypeKind::Id:
 #define TYPE(Id, Parent)
 #include "swift/AST/TypeNodes.def"
@@ -120,6 +120,31 @@ case TypeKind::Id:
     case TypeKind::Integer:
       return t;
 
+    case TypeKind::BuiltinFixedArray: {
+      auto bfaTy = cast<BuiltinFixedArrayType>(base);
+
+      Type transSize = doIt(bfaTy->getSize(),
+                            TypePosition::Invariant);
+      if (!transSize) {
+        return Type();
+      }
+
+      Type transElement = doIt(bfaTy->getElementType(),
+                               TypePosition::Invariant);
+      if (!transElement) {
+        return Type();
+      }
+
+      CanType canTransSize = transSize->getCanonicalType();
+      CanType canTransElement = transElement->getCanonicalType();
+      if (canTransSize != bfaTy->getSize()
+          || canTransElement != bfaTy->getElementType()) {
+        return BuiltinFixedArrayType::get(canTransSize, canTransElement);
+      }
+
+      return bfaTy;
+    }
+
     case TypeKind::PrimaryArchetype:
     case TypeKind::PackArchetype: {
       auto *archetype = cast<ArchetypeType>(base);