Add TypeDecoding for Builtin.FixedArray

Author: Azoy

include/swift/AST/ASTDemangler.h

@@ -250,6 +250,8 @@ class ASTBuilder {
 
   Type createNegativeIntegerType(intptr_t value);
 
+  Type createBuiltinFixedArrayType(Type size, Type element);
+
   BuiltGenericSignature
   createGenericSignature(ArrayRef<BuiltType> params,
                          ArrayRef<BuiltRequirement> requirements);

include/swift/Demangling/TypeDecoder.h

@@ -1530,6 +1530,23 @@ class TypeDecoder {
       return Builder.createNegativeIntegerType((intptr_t)Node->getIndex());
     }
 
+    case NodeKind::BuiltinFixedArray: {
+      if (Node->getNumChildren() < 2)
+        return MAKE_NODE_TYPE_ERROR(Node,
+                                    "fewer children (%zu) than required (2)",
+                                    Node->getNumChildren());
+
+      auto size = decodeMangledType(Node->getChild(0), depth + 1);
+      if (size.isError())
+        return size;
+
+      auto element = decodeMangledType(Node->getChild(1), depth + 1);
+      if (element.isError())
+        return element;
+
+      return Builder.createBuiltinFixedArrayType(size.getType(), element.getType());
+    }
+
     // TODO: Handle OpaqueReturnType, when we're in the middle of reconstructing
     // the defining decl
     default:

include/swift/RemoteInspection/TypeRefBuilder.h

@@ -933,6 +933,12 @@ class TypeRefBuilder {
     return nullptr;
   }
 
+  const TypeRef *createBuiltinFixedArrayType(const TypeRef *size,
+                                             const TypeRef *element) {
+    // FIXME: implement
+    return nullptr;
+  }
+
   // Construct a bound generic type ref along with the parent type info
   // The parent list contains every parent type with at least 1 generic
   // type parameter.

lib/AST/ASTDemangler.cpp

@@ -1065,6 +1065,11 @@ Type ASTBuilder::createNegativeIntegerType(intptr_t value) {
   return IntegerType::get(std::to_string(value), /*isNegative*/ true, Ctx);
 }
 
+Type ASTBuilder::createBuiltinFixedArrayType(Type size, Type element) {
+  return BuiltinFixedArrayType::get(size->getCanonicalType(),
+                                    element->getCanonicalType());
+}
+
 GenericSignature
 ASTBuilder::createGenericSignature(ArrayRef<BuiltType> builtParams,
                                    ArrayRef<BuiltRequirement> requirements) {

stdlib/public/runtime/MetadataLookup.cpp

@@ -2454,6 +2454,13 @@ class DecodedMetadataBuilder {
   TypeLookupErrorOr<BuiltType> createNegativeIntegerType(intptr_t value) {
     return BuiltType(value);
   }
+
+  TypeLookupErrorOr<BuiltType> createBuiltinFixedArrayType(BuiltType size,
+                                                           BuiltType element) {
+    return BuiltType(swift_getFixedArrayTypeMetadata(MetadataState::Abstract,
+                                                     size.getValue(),
+                                                     element.getMetadata()));
+  }
 };
 
 }

test/DebugInfo/value-generics.swift

@@ -0,0 +1,21 @@
+// RUN: %target-swift-frontend %s -emit-ir -g -enable-builtin-module -enable-experimental-feature ValueGenerics -disable-experimental-parser-round-trip -disable-availability-checking -o - | %FileCheck %s
+
+import Builtin
+
+struct Vector<let N: Int, Element: ~Copyable>: ~Copyable {
+  let storage: Builtin.FixedArray<N, Element>
+}
+
+extension Vector: Copyable where Element: Copyable {}
+
+// CHECK-DAG: !DICompositeType({{.*}}name: "Builtin.FixedArray", {{.*}}identifier: "$sxq_BVD"
+func genericBA<let N: Int, Element>(_: Builtin.FixedArray<N, Element>) {}
+
+// CHECK-DAG: !DICompositeType({{.*}}name: "$s4main6VectorVyxq_GD"
+func genericV<let N: Int, Element>(_: Vector<N, Element>) {}
+
+// CHECK-DAG: !DICompositeType({{.*}}name: "Builtin.FixedArray", {{.*}}identifier: "$s$4SiBVD"
+func concreteBA(_: Builtin.FixedArray<4, Int>) {}
+
+// CHECK-DAG: !DICompositeType({{.*}}name: "$s4main6VectorVy$2SiGD"
+func concreteV(_: Vector<2, Int>) {}