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 '>'.

lib/SILGen/SILGenExpr.cpp

@@ -4598,17 +4598,17 @@ visitMagicIdentifierLiteralExpr(MagicIdentifierLiteralExpr *E, SGFContext C) {
   llvm_unreachable("Unhandled MagicIdentifierLiteralExpr in switch.");
 }
 
-static RValue emitVectorLiteral(SILGenFunction &SGF, CollectionExpr *E,
-                                SGFContext C) {
+static RValue emitSlabLiteral(SILGenFunction &SGF, CollectionExpr *E,
+                              SGFContext C) {
   ArgumentScope scope(SGF, E);
 
-  auto vectorType = E->getType()->castTo<BoundGenericType>();
-  auto loweredVectorType = SGF.getLoweredType(vectorType);
-  auto elementType = vectorType->getGenericArgs()[1]->getCanonicalType();
+  auto slabType = E->getType()->castTo<BoundGenericType>();
+  auto loweredSlabType = SGF.getLoweredType(slabType);
+  auto elementType = slabType->getGenericArgs()[1]->getCanonicalType();
   auto loweredElementType = SGF.getLoweredType(elementType);
   auto &eltTL = SGF.getTypeLowering(AbstractionPattern::getOpaque(), elementType);
 
-  SILValue alloc = SGF.emitTemporaryAllocation(E, loweredVectorType);
+  SILValue alloc = SGF.emitTemporaryAllocation(E, loweredSlabType);
   SILValue addr = SGF.B.createUncheckedAddrCast(E, alloc,
                                             loweredElementType.getAddressType());
 
@@ -4641,31 +4641,31 @@ static RValue emitVectorLiteral(SILGenFunction &SGF, CollectionExpr *E,
         .forwardInto(SGF, AbstractionPattern::getOpaque(), &init, eltTL);
   }
 
-  // Kill the per-element cleanups. The vector will take ownership of them.
+  // Kill the per-element cleanups. The slab will take ownership of them.
   for (auto destCleanup : cleanups)
     SGF.Cleanups.setCleanupState(destCleanup, CleanupState::Dead);
 
-  SILValue vectorVal;
+  SILValue slabVal;
 
-  // If the vector is naturally address-only, then we can adopt the stack slot
+  // If the slab is naturally address-only, then we can adopt the stack slot
   // as the value directly.
-  if (loweredVectorType.isAddressOnly(SGF.F)) {
-    vectorVal = SGF.B.createUncheckedAddrCast(E, alloc, loweredVectorType);
+  if (loweredSlabType.isAddressOnly(SGF.F)) {
+    slabVal = SGF.B.createUncheckedAddrCast(E, alloc, loweredSlabType);
   } else {
-    // Otherwise, this vector is loadable. Load it.
-    vectorVal = SGF.B.createTrivialLoadOr(E, alloc, LoadOwnershipQualifier::Take);
+    // Otherwise, this slab is loadable. Load it.
+    slabVal = SGF.B.createTrivialLoadOr(E, alloc, LoadOwnershipQualifier::Take);
   }
 
-  auto vectorMV = SGF.emitManagedRValueWithCleanup(vectorVal);
-  auto vector = RValue(SGF, E, vectorMV);
+  auto slabMV = SGF.emitManagedRValueWithCleanup(slabVal);
+  auto slab = RValue(SGF, E, slabMV);
 
-  return scope.popPreservingValue(std::move(vector));
+  return scope.popPreservingValue(std::move(slab));
 }
 
 RValue RValueEmitter::visitCollectionExpr(CollectionExpr *E, SGFContext C) {
-  // Handle 'Vector' literals separately.
-  if (E->getType()->isVector()) {
-    return emitVectorLiteral(SGF, E, C);
+  // Handle 'Slab' literals separately.
+  if (E->getType()->isSlab()) {
+    return emitSlabLiteral(SGF, E, C);
   }
 
   auto loc = SILLocation(E);

lib/Sema/CSApply.cpp

@@ -3794,8 +3794,8 @@ namespace {
       Type arrayTy = cs.getType(expr);
       Type elementType;
 
-      if (arrayTy->isVector()) {
-        // <let Count: Int, Element>
+      if (arrayTy->isSlab()) {
+        // <let count: Int, Element>
         elementType = arrayTy->castTo<BoundGenericStructType>()->getGenericArgs()[1];
       } else {
         ProtocolDecl *arrayProto = TypeChecker::getProtocol(

lib/Sema/CSDiagnostics.cpp

@@ -9572,7 +9572,7 @@ bool InvalidTypeAsKeyPathSubscriptIndex::diagnoseAsError() {
   return true;
 }
 
-bool IncorrectVectorLiteralCount::diagnoseAsError() {
-  emitDiagnostic(diag::vector_literal_incorrect_count, lhsCount, rhsCount);
+bool IncorrectSlabLiteralCount::diagnoseAsError() {
+  emitDiagnostic(diag::slab_literal_incorrect_count, lhsCount, rhsCount);
   return true;
 }

lib/Sema/CSDiagnostics.h

@@ -3234,18 +3234,18 @@ class InvalidTypeAsKeyPathSubscriptIndex final : public FailureDiagnostic {
   bool diagnoseAsError() override;
 };
 
-/// Diagnose when a vector literal has an incorrect number of elements for the
-/// contextual vector type it's initializing.
+/// Diagnose when a slab literal has an incorrect number of elements for the
+/// contextual slab type it's initializing.
 ///
 /// \code
-/// let x: Vector<4, Int> = [1, 2] // expected '4' elements but got '2'
+/// let x: Slab<4, Int> = [1, 2] // expected '4' elements but got '2'
 /// \endcode
-class IncorrectVectorLiteralCount final : public FailureDiagnostic {
+class IncorrectSlabLiteralCount final : public FailureDiagnostic {
   Type lhsCount, rhsCount;
 
 public:
-  IncorrectVectorLiteralCount(const Solution &solution, Type lhsCount,
-                              Type rhsCount, ConstraintLocator *locator)
+  IncorrectSlabLiteralCount(const Solution &solution, Type lhsCount,
+                            Type rhsCount, ConstraintLocator *locator)
       : FailureDiagnostic(solution, locator), lhsCount(resolveType(lhsCount)),
         rhsCount(resolveType(rhsCount)) {}
 

lib/Sema/CSFix.cpp

@@ -2723,16 +2723,16 @@ IgnoreKeyPathSubscriptIndexMismatch::create(ConstraintSystem &cs, Type argType,
       IgnoreKeyPathSubscriptIndexMismatch(cs, argType, locator);
 }
 
-AllowVectorLiteralCountMismatch *
-AllowVectorLiteralCountMismatch::create(ConstraintSystem &cs, Type lhsCount,
-                                        Type rhsCount,
-                                        ConstraintLocator *locator) {
+AllowSlabLiteralCountMismatch *
+AllowSlabLiteralCountMismatch::create(ConstraintSystem &cs, Type lhsCount,
+                                      Type rhsCount,
+                                      ConstraintLocator *locator) {
   return new (cs.getAllocator())
-      AllowVectorLiteralCountMismatch(cs, lhsCount, rhsCount, locator);
+      AllowSlabLiteralCountMismatch(cs, lhsCount, rhsCount, locator);
 }
 
-bool AllowVectorLiteralCountMismatch::diagnose(const Solution &solution,
-                                               bool asNote) const {
-  IncorrectVectorLiteralCount failure(solution, lhsCount, rhsCount, getLocator());
+bool AllowSlabLiteralCountMismatch::diagnose(const Solution &solution,
+                                             bool asNote) const {
+  IncorrectSlabLiteralCount failure(solution, lhsCount, rhsCount, getLocator());
   return failure.diagnose(asNote);
 }

lib/Sema/CSSimplify.cpp

@@ -8704,30 +8704,30 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
     auto anchor = loc->getAnchor();
     auto arrayLiteral = getAsExpr<ArrayExpr>(anchor);
 
-    // If we're attempting to bind an array literal to a 'Vector' parameter,
+    // If we're attempting to bind an array literal to a 'Slab' parameter,
     // then check if the counts are equal and solve.
     if (kind == ConstraintKind::LiteralConformsTo &&
         protocol == arrayLiteralProto &&
-        type->isVector() &&
+        type->isSlab() &&
         arrayLiteral) {
-      auto vectorTy = type->castTo<BoundGenericStructType>();
+      auto slabTy = type->castTo<BoundGenericStructType>();
 
-      // <let Count: Int, Element>
+      // <let count: Int, Element>
       // Attempt to bind the number of elements in the literal with the
       // contextual count. This will diagnose if the literal does not enough
       // or too many elements.
-      auto contextualCount = vectorTy->getGenericArgs()[0];
+      auto contextualCount = slabTy->getGenericArgs()[0];
       auto literalCount = IntegerType::get(
           std::to_string(arrayLiteral->getNumElements()),
           /* isNegative */ false,
-          vectorTy->getASTContext());
+          slabTy->getASTContext());
 
       // If the counts are already equal, '2' == '2', then we're done.
       if (contextualCount->isEqual(literalCount)) {
         return SolutionKind::Solved;
       }
 
-      // If our contextual count is not known, e.g., Vector<_, Int> = [1, 2],
+      // If our contextual count is not known, e.g., Slab<_, Int> = [1, 2],
       // then just eagerly bind the count to what the literal count is.
       if (contextualCount->isTypeVariableOrMember()) {
         addConstraint(ConstraintKind::Bind, contextualCount, literalCount,
@@ -8739,8 +8739,8 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
       if (!shouldAttemptFixes())
         return SolutionKind::Error;
 
-      auto fix = AllowVectorLiteralCountMismatch::create(*this, contextualCount,
-                                                         literalCount, loc);
+      auto fix = AllowSlabLiteralCountMismatch::create(*this, contextualCount,
+                                                       literalCount, loc);
       return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
     }
   } break;
@@ -15654,7 +15654,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::IgnoreInvalidPlaceholder:
   case FixKind::IgnoreOutOfPlaceThenStmt:
   case FixKind::IgnoreMissingEachKeyword:
-  case FixKind::AllowVectorLiteralCountMismatch:
+  case FixKind::AllowSlabLiteralCountMismatch:
     llvm_unreachable("handled elsewhere");
   }
 

lib/Sema/ConstraintSystem.cpp

@@ -1666,10 +1666,10 @@ struct TypeSimplifier {
         auto *proto = assocType->getProtocol();
         auto conformance = CS.lookupConformance(lookupBaseType, proto);
         if (!conformance) {
-          // Special case: When building vector literals, we go through the same
+          // Special case: When building slab literals, we go through the same
           // array literal machinery, so there will be a conversion constraint
           // for the element to ExpressibleByArrayLiteral.ArrayLiteralType.
-          if (lookupBaseType->isVector()) {
+          if (lookupBaseType->isSlab()) {
             auto &ctx = CS.getASTContext();
             auto arrayProto =
                 ctx.getProtocol(KnownProtocolKind::ExpressibleByArrayLiteral);