Introduce type sugar for InlineArray (swiftlang#80087)

* [CS] Decline to handle InlineArray in shrink

Previously we would try the contextual type `(<int>, <element>)`,
which is wrong. Given we want to eliminate shrink, let's just bail.

* [Sema] Sink `ValueMatchVisitor` into `applyUnboundGenericArguments`

Make sure it's called for sugar code paths too. Also let's just always
run it since it should be a pretty cheap check.

* [Sema] Diagnose passing integer to non-integer type parameter

This was previously missed, though would have been diagnosed later
as a requirement failure.

* [Parse] Split up `canParseType` 

While here, address the FIXME in `canParseTypeSimpleOrComposition`
and only check to see if we can parse a type-simple, including
`each`, `some`, and `any` for better recovery.

* 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

docs/ABI/Mangling.rst

@@ -954,6 +954,7 @@ productions:
   type ::= base-type "XSq"                       // sugared Optional type
   type ::= base-type "XSa"                       // sugared Array type
   type ::= key-type value-type "XSD"             // sugared Dictionary type
+  type ::= count-type element-type "XSA"         // sugared InlineArray type
 
 Generics
 ~~~~~~~~

include/swift/AST/ASTBridging.h

@@ -2702,6 +2702,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/ASTDemangler.h

@@ -248,6 +248,8 @@ class ASTBuilder {
 
   Type createArrayType(Type base);
 
+  Type createInlineArrayType(Type count, Type element);
+
   Type createDictionaryType(Type key, Type value);
 
   Type createIntegerType(intptr_t value);

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

@@ -6069,7 +6069,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 "
@@ -8334,6 +8334,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);