Introduce type sugar for InlineArray

Parse e.g `[3 x Int]` as type sugar for InlineArray. Gated behind
an experimental feature flag for now.

Author: hamishknight

include/swift/AST/ASTBridging.h

@@ -2681,6 +2681,11 @@ BridgedImplicitlyUnwrappedOptionalTypeRepr_createParsed(
     BridgedASTContext cContext, BridgedTypeRepr base,
     BridgedSourceLoc cExclamationLoc);
 
+SWIFT_NAME("BridgedInlineArrayTypeRepr.createParsed(_:count:element:brackets:)")
+BridgedInlineArrayTypeRepr BridgedInlineArrayTypeRepr_createParsed(
+    BridgedASTContext cContext, BridgedTypeRepr cCountType,
+    BridgedTypeRepr cElementType, BridgedSourceRange cBracketsRange);
+
 SWIFT_NAME("BridgedInverseTypeRepr.createParsed(_:tildeLoc:constraint:)")
 BridgedInverseTypeRepr
 BridgedInverseTypeRepr_createParsed(BridgedASTContext cContext,

include/swift/AST/DiagnosticsParse.def

@@ -878,6 +878,10 @@ NOTE(subscript_array_element_fix_it_add_comma, none, "add a separator between "
 NOTE(subscript_array_element_fix_it_remove_space, none,
      "remove the space between the elements to silence this warning", ())
 
+// Inline Array
+ERROR(expected_rsquare_inline_array,none,
+      "expected ']' in inline array type", ())
+
 // Tuple Types
 ERROR(expected_rparen_tuple_type_list,none,
       "expected ')' at end of tuple list", ())

include/swift/AST/DiagnosticsSema.def

@@ -6059,7 +6059,7 @@ NOTE(note_recursive_enum_case_here,none,
 
 ERROR(sugar_type_not_found,none,
       "broken standard library: cannot find "
-      "%select{Array|Optional|ImplicitlyUnwrappedOptional|Dictionary|"
+      "%select{Array|Optional|InlineArray|Dictionary|"
       "Error}0 type", (unsigned))
 ERROR(optional_intrinsics_not_found,none,
       "broken standard library: cannot find intrinsic operations on "
@@ -8283,6 +8283,9 @@ ERROR(invalid_value_for_type_same_type,none,
 ERROR(inlinearray_literal_incorrect_count,none,
       "expected %0 elements in inline array literal, but got %1", (Type, Type))
 
+ERROR(inline_array_type_backwards,none,
+      "element count must precede inline array element type", ())
+
 //===----------------------------------------------------------------------===//
 // MARK: @abi Attribute
 //===----------------------------------------------------------------------===//

include/swift/AST/PrintOptions.h

@@ -590,6 +590,10 @@ struct PrintOptions {
   /// Whether to always desugar array types from `[base_type]` to `Array<base_type>`
   bool AlwaysDesugarArraySliceTypes = false;
 
+  /// Whether to always desugar inline array types from
+  /// `[<count> x <element>]` to `InlineArray<count, element>`
+  bool AlwaysDesugarInlineArrayTypes = false;
+
   /// Whether to always desugar dictionary types
   /// from `[key_type:value_type]` to `Dictionary<key_type,value_type>`
   bool AlwaysDesugarDictionaryTypes = false;

include/swift/AST/TypeNodes.def

@@ -217,6 +217,7 @@ ABSTRACT_SUGARED_TYPE(Sugar, Type)
       SUGARED_TYPE(Optional, UnarySyntaxSugarType)
       SUGARED_TYPE(VariadicSequence, UnarySyntaxSugarType)
       TYPE_RANGE(UnarySyntaxSugar, ArraySlice, VariadicSequence)
+    SUGARED_TYPE(InlineArray, SyntaxSugarType)
     SUGARED_TYPE(Dictionary, SyntaxSugarType)
     TYPE_RANGE(SyntaxSugar, ArraySlice, Dictionary)
   TYPE_RANGE(Sugar, TypeAlias, Dictionary)

include/swift/AST/TypeRepr.h

@@ -641,6 +641,35 @@ class ArrayTypeRepr : public TypeRepr {
   friend class TypeRepr;
 };
 
+/// An InlineArray type e.g `[2 x Foo]`, sugar for `InlineArray<2, Foo>`.
+class InlineArrayTypeRepr : public TypeRepr {
+  TypeRepr *Count;
+  TypeRepr *Element;
+  SourceRange Brackets;
+
+  InlineArrayTypeRepr(TypeRepr *count, TypeRepr *element, SourceRange brackets)
+      : TypeRepr(TypeReprKind::InlineArray), Count(count), Element(element),
+        Brackets(brackets) {}
+
+public:
+  static InlineArrayTypeRepr *create(ASTContext &ctx, TypeRepr *count,
+                                     TypeRepr *element, SourceRange brackets);
+
+  TypeRepr *getCount() const { return Count; }
+  TypeRepr *getElement() const { return Element; }
+  SourceRange getBrackets() const { return Brackets; }
+
+  static bool classof(const TypeRepr *T) {
+    return T->getKind() == TypeReprKind::InlineArray;
+  }
+
+private:
+  SourceLoc getStartLocImpl() const { return Brackets.Start; }
+  SourceLoc getEndLocImpl() const { return Brackets.End; }
+  void printImpl(ASTPrinter &Printer, const PrintOptions &Opts) const;
+  friend class TypeRepr;
+};
+
 /// A dictionary type.
 /// \code
 ///   [K : V]
@@ -1626,6 +1655,7 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::Fixed:
   case TypeReprKind::Self:
   case TypeReprKind::Array:
+  case TypeReprKind::InlineArray:
   case TypeReprKind::SILBox:
   case TypeReprKind::Isolated:
   case TypeReprKind::Sending:

include/swift/AST/TypeReprNodes.def

@@ -49,6 +49,7 @@ ABSTRACT_TYPEREPR(DeclRef, TypeRepr)
   TYPEREPR(UnqualifiedIdent, DeclRefTypeRepr)
   TYPEREPR(QualifiedIdent, DeclRefTypeRepr)
 TYPEREPR(Function, TypeRepr)
+TYPEREPR(InlineArray, TypeRepr)
 TYPEREPR(Array, TypeRepr)
 TYPEREPR(Dictionary, TypeRepr)
 TYPEREPR(Optional, TypeRepr)

include/swift/AST/TypeTransform.h

@@ -894,6 +894,25 @@ case TypeKind::Id:
       return ArraySliceType::get(baseTy);
     }
 
+    case TypeKind::InlineArray: {
+      auto ty = cast<InlineArrayType>(base);
+      auto countTy = doIt(ty->getCountType(), TypePosition::Invariant);
+      if (!countTy)
+        return Type();
+
+      // Currently the element type is invariant for InlineArray.
+      // FIXME: Should we allow covariance?
+      auto eltTy = doIt(ty->getElementType(), TypePosition::Invariant);
+      if (!eltTy)
+        return Type();
+
+      if (countTy.getPointer() == ty->getCountType().getPointer() &&
+          eltTy.getPointer() == ty->getElementType().getPointer())
+        return t;
+
+      return InlineArrayType::get(countTy, eltTy);
+    }
+
     case TypeKind::Optional: {
       auto optional = cast<OptionalType>(base);
       auto baseTy = doIt(optional->getBaseType(), pos);

include/swift/AST/Types.h

@@ -6191,6 +6191,27 @@ class ArraySliceType : public UnarySyntaxSugarType {
   }
 };
 
+/// An InlineArray type e.g `[2 x Foo]`, sugar for `InlineArray<2, Foo>`.
+class InlineArrayType : public SyntaxSugarType {
+  Type Count;
+  Type Elt;
+
+  InlineArrayType(const ASTContext &ctx, Type count, Type elt,
+                  RecursiveTypeProperties properties)
+      : SyntaxSugarType(TypeKind::InlineArray, ctx, properties), Count(count),
+        Elt(elt) {}
+
+public:
+  static InlineArrayType *get(Type count, Type elt);
+
+  Type getCountType() const { return Count; }
+  Type getElementType() const { return Elt; }
+
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::InlineArray;
+  }
+};
+
 /// The type T?, which is always sugar for a library type.
 class OptionalType : public UnarySyntaxSugarType {
   OptionalType(const ASTContext &ctx,Type base,

include/swift/Basic/Features.def

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