Rename to Slab

Author: Azoy

include/swift/AST/Decl.h

@@ -3958,7 +3958,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

@@ -8176,11 +8176,11 @@ ERROR(invalid_value_for_type_same_type,none,
       "cannot constrain type parameter %0 to be integer %1", (Type, Type))
 
 //===----------------------------------------------------------------------===//
-// MARK: Vector
+// MARK: Slab
 //===----------------------------------------------------------------------===//
 
-ERROR(vector_literal_incorrect_count,none,
-      "expected %0 elements in vector literal, but got %1", (Type, Type))
+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,6 +97,6 @@ KNOWN_STDLIB_TYPE_DECL(DecodingError, NominalTypeDecl, 0)
 
 KNOWN_STDLIB_TYPE_DECL(Result, NominalTypeDecl, 2)
 
-KNOWN_STDLIB_TYPE_DECL(Vector, 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/Basic/Features.def

@@ -225,7 +225,6 @@ UPCOMING_FEATURE(GlobalActorIsolatedTypesUsability, 0434, 6)
 UPCOMING_FEATURE(ExistentialAny, 335, 7)
 UPCOMING_FEATURE(InternalImportsByDefault, 409, 7)
 UPCOMING_FEATURE(MemberImportVisibility, 444, 7)
-UPCOMING_FEATURE(ImportCArraysAsVectors, 453, 7)
 
 EXPERIMENTAL_FEATURE(StaticAssert, false)
 EXPERIMENTAL_FEATURE(NamedOpaqueTypes, false)

include/swift/Sema/CSFix.h

@@ -484,9 +484,9 @@ enum class FixKind : uint8_t {
   /// result.
   AllowSendingMismatch,
 
-  /// Ignore when a 'Vector' literal has mismatched number of elements to the
+  /// Ignore when a 'Slab' literal has mismatched number of elements to the
   /// type it's attempting to bind to.
-  AllowVectorLiteralCountMismatch,
+  AllowSlabLiteralCountMismatch,
 };
 
 class ConstraintFix {
@@ -3841,12 +3841,12 @@ class IgnoreKeyPathSubscriptIndexMismatch final : public ConstraintFix {
   }
 };
 
-class AllowVectorLiteralCountMismatch final : public ConstraintFix {
+class AllowSlabLiteralCountMismatch final : public ConstraintFix {
   Type lhsCount, rhsCount;
 
-  AllowVectorLiteralCountMismatch(ConstraintSystem &cs, Type lhsCount,
-                                  Type rhsCount, ConstraintLocator *locator)
-      : ConstraintFix(cs, FixKind::AllowVectorLiteralCountMismatch, locator),
+  AllowSlabLiteralCountMismatch(ConstraintSystem &cs, Type lhsCount,
+                                Type rhsCount, ConstraintLocator *locator)
+      : ConstraintFix(cs, FixKind::AllowSlabLiteralCountMismatch, locator),
         lhsCount(lhsCount), rhsCount(rhsCount) {}
 
 public:
@@ -3856,12 +3856,12 @@ class AllowVectorLiteralCountMismatch final : public ConstraintFix {
 
   bool diagnose(const Solution &solution, bool asNote = false) const override;
 
-  static AllowVectorLiteralCountMismatch *
+  static AllowSlabLiteralCountMismatch *
   create(ConstraintSystem &cs, Type lhsCount, Type rhsCount,
          ConstraintLocator *locator);
 
   static bool classof(const ConstraintFix *fix) {
-    return fix->getKind() == FixKind::AllowVectorLiteralCountMismatch;
+    return fix->getKind() == FixKind::AllowSlabLiteralCountMismatch;
   }
 };
 

lib/AST/FeatureSet.cpp

@@ -69,7 +69,6 @@ UNINTERESTING_FEATURE(ExistentialAny)
 UNINTERESTING_FEATURE(InferSendableFromCaptures)
 UNINTERESTING_FEATURE(ImplicitOpenExistentials)
 UNINTERESTING_FEATURE(MemberImportVisibility)
-UNINTERESTING_FEATURE(ImportCArraysAsVectors) // fixme?
 
 // ----------------------------------------------------------------------------
 // MARK: - Experimental Features

lib/AST/Type.cpp

@@ -811,7 +811,7 @@ Type TypeBase::isArrayType() {
     if (isArray())
       return boundStruct->getGenericArgs()[0];
 
-    if (isVector())
+    if (isSlab())
       return boundStruct->getGenericArgs()[1];
   }
   return Type();

lib/ClangImporter/ImportType.cpp

@@ -634,6 +634,10 @@ namespace {
     }
 
     ImportResult VisitConstantArrayType(const clang::ConstantArrayType *type) {
+      // FIXME: Map to a real fixed-size Swift array type when we have those.
+      // Importing as a tuple at least fills the right amount of space, and
+      // we can cheese static-offset "indexing" using .$n operations.
+
       Type elementType = Impl.importTypeIgnoreIUO(
           type->getElementType(), ImportTypeKind::Value, addImportDiagnostic,
           AllowNSUIntegerAsInt, Bridgeability::None, ImportTypeAttrs());
@@ -642,25 +646,15 @@ namespace {
 
       auto size = type->getSize().getZExtValue();
 
-      if (size == 1)
-        return elementType;
-
-      auto &ctx = elementType->getASTContext();
-
-      if (ctx.LangOpts.hasFeature(Feature::ImportCArraysAsVectors)) {
-        auto vector = cast<StructDecl>(ctx.getVectorDecl());
-        auto countType = IntegerType::get(std::to_string(size),
-                                          /* isNegative */ false, ctx);
-        return BoundGenericStructType::get(vector, /* parent */ nullptr,
-                                           {countType, elementType});
-      }
-
       // An array of size N is imported as an N-element tuple which
       // takes very long to compile. We chose 4096 as the upper limit because
       // we don't want to break arrays of size PATH_MAX.
       if (size > 4096)
         return Type();
 
+      if (size == 1)
+        return elementType;
+
       SmallVector<TupleTypeElt, 8> elts{static_cast<size_t>(size), elementType};
       return TupleType::get(elts, elementType->getASTContext());
     }

lib/Parse/ParseType.cpp

@@ -716,7 +716,7 @@ ParserStatus Parser::parseGenericArguments(SmallVectorImpl<TypeRepr *> &Args,
   // variadic generic types.
   if (!startsWithGreater(Tok)) {
     while (true) {
-      // Note: This can be a value type, e.g. 'Vector<3, Int>'.
+      // Note: This can be a value type, e.g. 'Slab<3, Int>'.
       ParserResult<TypeRepr> Ty = parseTypeOrValue(diag::expected_type);
       if (Ty.isNull() || Ty.hasCodeCompletion()) {
         // Skip until we hit the '>'.