Introduce a Builtin.FixedArray type.

`Builtin.FixedArray<let N: Int, T: ~Copyable & ~Escapable>` has the layout of `N` elements of type `T` laid out
sequentially in memory (with the tail padding of every element occupied by the array). This provides a primitive
on which the standard library `Vector` type can be built.

Author: jckarter

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/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/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);

include/swift/AST/Types.h

@@ -62,6 +62,7 @@ class ArgumentList;
 class AssociatedTypeDecl;
 class ASTContext;
 enum BufferPointerTypeKind : unsigned;
+struct BuiltinNameStringLiteral;
 class BuiltinTupleDecl;
 class ClassDecl;
 class ClangModuleLoader;
@@ -1508,6 +1509,9 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// return `None`.
   std::optional<TangentSpace>
   getAutoDiffTangentSpace(LookupConformanceFn lookupConformance);
+
+  /// Return the kind of generic parameter that this type can be matched to.
+  GenericTypeParamKind getMatchingParamKind();
 };
 
 /// AnyGenericType - This abstract class helps types ensure that fields
@@ -1648,8 +1652,9 @@ DEFINE_EMPTY_CAN_TYPE_WRAPPER(UnresolvedType, Type)
 /// BuiltinType - An abstract class for all the builtin types.
 class BuiltinType : public TypeBase {
 protected:
-  BuiltinType(TypeKind kind, const ASTContext &canTypeCtx)
-  : TypeBase(kind, &canTypeCtx, RecursiveTypeProperties()) {}
+  BuiltinType(TypeKind kind, const ASTContext &canTypeCtx,
+              RecursiveTypeProperties properties = {})
+  : TypeBase(kind, &canTypeCtx, properties) {}
 public:
   static bool classof(const TypeBase *T) {
     return T->getKind() >= TypeKind::First_BuiltinType &&
@@ -1672,6 +1677,113 @@ class BuiltinType : public TypeBase {
 };
 DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinType, Type)
 
+/// BuiltinUnboundGenericType - the base declaration of a generic builtin type
+/// that has not yet had generic parameters applied.
+///
+/// Referring to an unbound generic type by itself is invalid, but this
+/// representation is used as an intermediate during type resolution when
+/// resolving a type reference such as `Builtin.Int<31>`. Applying
+/// the generic parameters produces the actual builtin type based on the
+/// kind of the base.
+class BuiltinUnboundGenericType : public BuiltinType {
+  friend class ASTContext;
+  TypeKind BoundGenericTypeKind;
+  
+  BuiltinUnboundGenericType(const ASTContext &C,
+                            TypeKind genericTypeKind)
+    : BuiltinType(TypeKind::BuiltinUnboundGeneric, C),
+      BoundGenericTypeKind(genericTypeKind)
+  {}
+    
+public:
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::BuiltinUnboundGeneric;
+  }
+  
+  /// Produce the unqualified name of the type.
+  BuiltinNameStringLiteral getBuiltinTypeName() const;
+  StringRef getBuiltinTypeNameString() const;
+  
+  static BuiltinUnboundGenericType *get(TypeKind genericTypeKind,
+                                        const ASTContext &C);
+
+  /// Get the generic signature with which to substitute this type.
+  GenericSignature getGenericSignature() const;
+
+  /// Get the type that results from binding the generic parameters of this
+  /// builtin to the given substitutions.
+  ///
+  /// Produces an ErrorType if the substitution is invalid.
+  Type getBound(SubstitutionMap subs) const;
+};
+DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinUnboundGenericType, BuiltinType)
+
+/// BuiltinFixedArrayType - The builtin type representing N values stored
+/// inline contiguously.
+///
+/// All elements of a value of this type must be fully initialized any time the
+/// value may be copied, moved, or destroyed.
+class BuiltinFixedArrayType : public BuiltinType, public llvm::FoldingSetNode {
+  friend class ASTContext;
+  
+  CanType Size;
+  CanType ElementType;
+  
+  static RecursiveTypeProperties
+  getRecursiveTypeProperties(CanType Size, CanType Element) {
+    RecursiveTypeProperties properties;
+    properties |= Size->getRecursiveProperties();
+    properties |= Element->getRecursiveProperties();
+    return properties;
+  }
+  
+  BuiltinFixedArrayType(CanType Size,
+                        CanType ElementType)
+    : BuiltinType(TypeKind::BuiltinFixedArray, ElementType->getASTContext(),
+                  getRecursiveTypeProperties(Size, ElementType)),
+        Size(Size),
+        ElementType(ElementType)
+  {}
+  
+public:
+  /// Arrays with more elements than this are always treated as in-memory values.
+  ///
+  /// (4096 is the hardcoded limit above which we refuse to import C arrays
+  /// as tuples. From first principles, a much lower threshold would probably
+  /// make sense, but we don't want to break the type lowering of C types
+  /// as they appear in existing Swift code.)
+  static constexpr const uint64_t MaximumLoadableSize = 4096;
+
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::BuiltinFixedArray;
+  }
+  
+  static BuiltinFixedArrayType *get(CanType Size,
+                                    CanType ElementType);
+                       
+  /// Get the integer generic parameter representing the number of elements.
+  CanType getSize() const { return Size; }
+  
+  /// Get the fixed integer number of elements if known and zero or greater.
+  std::optional<uint64_t> getFixedInhabitedSize() const;
+  
+  /// True if the type is statically negative-sized (and therefore uninhabited).
+  bool isFixedNegativeSize() const;
+  
+  /// Get the element type.
+  CanType getElementType() const { return ElementType; }
+  
+  void Profile(llvm::FoldingSetNodeID &ID) const {
+    Profile(ID, getSize(), getElementType());
+  }
+  static void Profile(llvm::FoldingSetNodeID &ID,
+                      CanType Size, CanType ElementType) {
+    ID.AddPointer(Size.getPointer());
+    ID.AddPointer(ElementType.getPointer());
+  }
+};
+DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinFixedArrayType, BuiltinType)
+
 /// BuiltinRawPointerType - The builtin raw (and dangling) pointer type.  This
 /// pointer is completely unmanaged and is equivalent to i8* in LLVM IR.
 class BuiltinRawPointerType : public BuiltinType {