Merge pull request swiftlang#81868 from hamishknight/x-of-hearts

Change InlineArray sugar separator `x` -> `of`

Author: hamishknight

include/swift/AST/PrintOptions.h

@@ -601,7 +601,7 @@ struct PrintOptions {
   bool AlwaysDesugarArraySliceTypes = false;
 
   /// Whether to always desugar inline array types from
-  /// `[<count> x <element>]` to `InlineArray<count, element>`
+  /// `[<count> of <element>]` to `InlineArray<count, element>`
   bool AlwaysDesugarInlineArrayTypes = false;
 
   /// Whether to always desugar dictionary types

include/swift/AST/TypeRepr.h

@@ -641,7 +641,7 @@ class ArrayTypeRepr : public TypeRepr {
   friend class TypeRepr;
 };
 
-/// An InlineArray type e.g `[2 x Foo]`, sugar for `InlineArray<2, Foo>`.
+/// An InlineArray type e.g `[2 of Foo]`, sugar for `InlineArray<2, Foo>`.
 class InlineArrayTypeRepr : public TypeRepr {
   TypeRepr *Count;
   TypeRepr *Element;

include/swift/AST/Types.h

@@ -6299,7 +6299,7 @@ class ArraySliceType : public UnarySyntaxSugarType {
   }
 };
 
-/// An InlineArray type e.g `[2 x Foo]`, sugar for `InlineArray<2, Foo>`.
+/// An InlineArray type e.g `[2 of Foo]`, sugar for `InlineArray<2, Foo>`.
 class InlineArrayType : public SyntaxSugarType {
   Type Count;
   Type Elt;

include/swift/Basic/Features.def

@@ -497,7 +497,7 @@ EXPERIMENTAL_FEATURE(CustomAvailability, true)
 /// Syntax sugar features for concurrency.
 EXPERIMENTAL_FEATURE(ConcurrencySyntaxSugar, true)
 
-/// Enable syntax sugar type '[3 x Int]' for Inline Array
+/// Enable syntax sugar type '[3 of Int]' for Inline Array
 EXPERIMENTAL_FEATURE(InlineArrayTypeSugar, false)
 
 /// Allow declaration of compile-time values

lib/AST/ASTPrinter.cpp

@@ -7115,7 +7115,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     } else {
       Printer << "[";
       visit(T->getCountType());
-      Printer << " x ";
+      Printer << " of ";
       visit(T->getElementType());
       Printer << "]";
     }

lib/AST/TypeRepr.cpp

@@ -484,7 +484,7 @@ void InlineArrayTypeRepr::printImpl(ASTPrinter &Printer,
                                     const PrintOptions &Opts) const {
   Printer << "[";
   printTypeRepr(getCount(), Printer, Opts);
-  Printer << " x ";
+  Printer << " of ";
   printTypeRepr(getElement(), Printer, Opts);
   Printer << "]";
 }

lib/Demangling/NodePrinter.cpp

@@ -3316,7 +3316,7 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
   case Node::Kind::SugaredInlineArray: {
     Printer << "[";
     print(Node->getChild(0), depth + 1);
-    Printer << " x ";
+    Printer << " of ";
     print(Node->getChild(1), depth + 1);
     Printer << "]";
     return nullptr;

lib/Parse/ParseType.cpp

@@ -1322,13 +1322,13 @@ ParserResult<TypeRepr> Parser::parseTypeInlineArray(SourceLoc lSquare) {
 
   ParserStatus status;
 
-  // 'isStartOfInlineArrayTypeBody' means we should at least have a type and 'x'
-  // to start with.
+  // 'isStartOfInlineArrayTypeBody' means we should at least have a type and
+  // 'of' to start with.
   auto count = parseTypeOrValue();
   auto *countTy = count.get();
   status |= count;
 
-  // 'x'
+  // 'of'
   consumeToken(tok::identifier);
 
   // Allow parsing a value for better recovery, Sema will diagnose any
@@ -1827,16 +1827,16 @@ bool Parser::canParseStartOfInlineArrayType() {
   if (!Context.LangOpts.hasFeature(Feature::InlineArrayTypeSugar))
     return false;
 
-  // We must have at least '[<type> x', which cannot be any other kind of
+  // We must have at least '[<type> of', which cannot be any other kind of
   // expression or type. We specifically look for any type, not just integers
-  // for better recovery in e.g cases where the user writes '[Int x 2]'. We
-  // only do type-scalar since variadics would be ambiguous e.g 'Int...x'.
+  // for better recovery in e.g cases where the user writes '[Int of 2]'. We
+  // only do type-scalar since variadics would be ambiguous e.g 'Int...of'.
   if (!canParseTypeScalar())
     return false;
 
   // For now we don't allow multi-line since that would require
   // disambiguation.
-  if (Tok.isAtStartOfLine() || !Tok.isContextualKeyword("x"))
+  if (Tok.isAtStartOfLine() || !Tok.isContextualKeyword("of"))
     return false;
 
   consumeToken();

lib/Sema/TypeCheckType.cpp

@@ -5379,7 +5379,7 @@ TypeResolver::resolveInlineArrayType(InlineArrayTypeRepr *repr,
   auto argOptions = options.withoutContext().withContext(
       TypeResolverContext::ValueGenericArgument);
 
-  // It's possible the user accidentally wrote '[Int x 4]', correct that here.
+  // It's possible the user accidentally wrote '[Int of 4]', correct that here.
   auto *countRepr = repr->getCount();
   auto *eltRepr = repr->getElement();
   if (!isa<IntegerTypeRepr>(countRepr) && isa<IntegerTypeRepr>(eltRepr)) {

test/ASTGen/types.swift

@@ -84,10 +84,10 @@ let optionalIntArray: Array<_> = [42]
 
 @available(SwiftStdlib 9999, *)
 func testInlineArray() {
-  let _: [3 x Int] = [1, 2, 3]
-  let _: [_ x _] = [1, 2]
-  let _ = [3 x Int](repeating: 0)
-  let _ = [3 x _](repeating: 0)
+  let _: [3 of Int] = [1, 2, 3]
+  let _: [_ of _] = [1, 2]
+  let _ = [3 of Int](repeating: 0)
+  let _ = [3 of _](repeating: 0)
 }
 
 func testNamedOpaqueReturnTy() -> <T> T { return () }