Merge pull request #76438 from Azoy/vector

[stdlib] Slab

Author: Azoy

include/swift/AST/Decl.h

@@ -3948,7 +3948,7 @@ class GenericTypeParamDecl final
   /// type parameter.
   ///
   /// \code
-  /// struct Vector<Element, let N: Int>
+  /// struct Slab<let count: Int, Element: ~Copyable>
   /// \endcode
   bool isValue() const {
     return getParamKind() == GenericTypeParamKind::Value;

include/swift/AST/DiagnosticsSema.def

@@ -8165,6 +8165,13 @@ ERROR(availability_value_generic_type_only_version_newer, none,
 ERROR(invalid_value_for_type_same_type,none,
       "cannot constrain type parameter %0 to be integer %1", (Type, Type))
 
+//===----------------------------------------------------------------------===//
+// MARK: Slab
+//===----------------------------------------------------------------------===//
+
+ERROR(slab_literal_incorrect_count,none,
+      "expected %0 elements in slab literal, but got %1", (Type, Type))
+
 //===----------------------------------------------------------------------===//
 // MARK: @abi Attribute
 //===----------------------------------------------------------------------===//

include/swift/AST/KnownStdlibTypes.def

@@ -97,4 +97,6 @@ KNOWN_STDLIB_TYPE_DECL(DecodingError, NominalTypeDecl, 0)
 
 KNOWN_STDLIB_TYPE_DECL(Result, NominalTypeDecl, 2)
 
+KNOWN_STDLIB_TYPE_DECL(Slab, NominalTypeDecl, 2)
+
 #undef KNOWN_STDLIB_TYPE_DECL

include/swift/AST/Types.h

@@ -7246,7 +7246,7 @@ class GenericTypeParamType : public SubstitutableType,
   /// Returns \c true if this type parameter is declared as a value.
   ///
   /// \code
-  /// struct Vector<Element, let N: Int>
+  /// struct Slab<let count: Int, Element: ~Copyable>
   /// \endcode
   bool isValue() const {
     return ParamKind == GenericTypeParamKind::Value;

include/swift/RemoteInspection/TypeLowering.h

@@ -117,6 +117,7 @@ enum class TypeInfoKind : unsigned {
   Reference,
   Invalid,
   Enum,
+  Array,
 };
 
 class TypeInfo {
@@ -350,6 +351,24 @@ class ReferenceTypeInfo : public TypeInfo {
   }
 };
 
+/// Array based layouts like Builtin.FixedArray<N, T>
+class ArrayTypeInfo : public TypeInfo {
+  const TypeInfo *ElementTI;
+
+public:
+  explicit ArrayTypeInfo(intptr_t size, const TypeInfo *elementTI);
+
+  bool readExtraInhabitantIndex(remote::MemoryReader &reader,
+                                remote::RemoteAddress address,
+                                int *extraInhabitantIndex) const override;
+
+  BitMask getSpareBits(TypeConverter &TC, bool &hasAddrOnly) const override;
+
+  static bool classof(const TypeInfo *TI) {
+    return TI->getKind() == TypeInfoKind::Array;
+  }
+};
+
 /// This class owns the memory for all TypeInfo instances that it vends.
 class TypeConverter {
   TypeRefBuilder &Builder;

include/swift/RemoteInspection/TypeRef.h

@@ -1095,6 +1095,68 @@ class SILBoxTypeWithLayoutTypeRef final : public TypeRef {
   }
 };
 
+class IntegerTypeRef final : public TypeRef {
+  intptr_t Value;
+
+  static TypeRefID Profile(const intptr_t &Value) {
+    TypeRefID ID;
+    ID.addInteger((uint64_t)Value);
+    return ID;
+  }
+
+public:
+  IntegerTypeRef(const intptr_t &Value)
+    : TypeRef(TypeRefKind::Integer), Value(Value) {}
+
+  template <typename Allocator>
+  static const IntegerTypeRef *create(Allocator &A, intptr_t Value) {
+    FIND_OR_CREATE_TYPEREF(A, IntegerTypeRef, Value);
+  }
+
+  const intptr_t &getValue() const {
+    return Value;
+  }
+
+  static bool classof(const TypeRef *TR) {
+    return TR->getKind() == TypeRefKind::Integer;
+  }
+};
+
+class BuiltinFixedArrayTypeRef final : public TypeRef {
+  const TypeRef *Size;
+  const TypeRef *Element;
+
+  static TypeRefID Profile(const TypeRef *Size, const TypeRef *Element) {
+    TypeRefID ID;
+    ID.addPointer(Size);
+    ID.addPointer(Element);
+    return ID;
+  }
+
+public:
+  BuiltinFixedArrayTypeRef(const TypeRef *Size, const TypeRef *Element)
+    : TypeRef(TypeRefKind::BuiltinFixedArray), Size(Size), Element(Element) {}
+
+  template <typename Allocator>
+  static const BuiltinFixedArrayTypeRef *create(Allocator &A,
+                                                const TypeRef *Size,
+                                                const TypeRef *Element) {
+    FIND_OR_CREATE_TYPEREF(A, BuiltinFixedArrayTypeRef, Size, Element);
+  }
+
+  const TypeRef *getSizeType() const {
+    return Size;
+  }
+
+  const TypeRef *getElementType() const {
+    return Element;
+  }
+
+  static bool classof(const TypeRef *TR) {
+    return TR->getKind() == TypeRefKind::BuiltinFixedArray;
+  }
+};
+
 template <typename ImplClass, typename RetTy = void, typename... Args>
 class TypeRefVisitor {
 public:

include/swift/RemoteInspection/TypeRefBuilder.h

@@ -929,19 +929,16 @@ class TypeRefBuilder {
   }
 
   const TypeRef *createIntegerType(intptr_t value) {
-    // FIXME: implement
-    return nullptr;
+    return IntegerTypeRef::create(*this, value);
   }
 
   const TypeRef *createNegativeIntegerType(intptr_t value) {
-    // FIXME: implement
-    return nullptr;
+    return IntegerTypeRef::create(*this, value);
   }
 
   const TypeRef *createBuiltinFixedArrayType(const TypeRef *size,
                                              const TypeRef *element) {
-    // FIXME: implement
-    return nullptr;
+    return BuiltinFixedArrayTypeRef::create(*this, size, element);
   }
 
   // Construct a bound generic type ref along with the parent type info

include/swift/RemoteInspection/TypeRefs.def

@@ -37,5 +37,7 @@ TYPEREF(OpaqueArchetype, TypeRef)
 #include "swift/AST/ReferenceStorage.def"
 TYPEREF(SILBox, TypeRef)
 TYPEREF(SILBoxTypeWithLayout, TypeRef)
+TYPEREF(Integer, TypeRef)
+TYPEREF(BuiltinFixedArray, TypeRef)
 
 #undef TYPEREF

include/swift/Sema/CSFix.h

@@ -483,6 +483,10 @@ enum class FixKind : uint8_t {
   /// sending result, but is passed a function typed parameter without a sending
   /// result.
   AllowSendingMismatch,
+
+  /// Ignore when a 'Slab' literal has mismatched number of elements to the
+  /// type it's attempting to bind to.
+  AllowSlabLiteralCountMismatch,
 };
 
 class ConstraintFix {
@@ -3837,6 +3841,30 @@ class IgnoreKeyPathSubscriptIndexMismatch final : public ConstraintFix {
   }
 };
 
+class AllowSlabLiteralCountMismatch final : public ConstraintFix {
+  Type lhsCount, rhsCount;
+
+  AllowSlabLiteralCountMismatch(ConstraintSystem &cs, Type lhsCount,
+                                Type rhsCount, ConstraintLocator *locator)
+      : ConstraintFix(cs, FixKind::AllowSlabLiteralCountMismatch, locator),
+        lhsCount(lhsCount), rhsCount(rhsCount) {}
+
+public:
+  std::string getName() const override {
+    return "allow vector literal count mismatch";
+  }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  static AllowSlabLiteralCountMismatch *
+  create(ConstraintSystem &cs, Type lhsCount, Type rhsCount,
+         ConstraintLocator *locator);
+
+  static bool classof(const ConstraintFix *fix) {
+    return fix->getKind() == FixKind::AllowSlabLiteralCountMismatch;
+  }
+};
+
 } // end namespace constraints
 } // end namespace swift
 

include/swift/SwiftRemoteMirror/SwiftRemoteMirrorTypes.h

@@ -143,6 +143,9 @@ typedef enum swift_layout_kind {
   // swift_reflection_infoForTypeRef().
   SWIFT_CLASS_INSTANCE,
   SWIFT_CLOSURE_CONTEXT,
+
+  // A contiguous list of N Ts, typically for Builtin.FixedArray<N, T>.
+  SWIFT_ARRAY,
 } swift_layout_kind_t;
 
 struct swift_childinfo;