[AST] NFC: Migrate CompositionTypeRepr to llvm::TrailingObjects

Author: davezarzycki

include/swift/AST/TypeRepr.h

@@ -87,6 +87,11 @@ class alignas(8) TypeRepr {
     NumComponents : 32
   );
 
+  SWIFT_INLINE_BITFIELD_FULL(CompositionTypeRepr, TypeRepr, 32,
+    : NumPadBits,
+    NumTypes : 32
+  );
+
   } Bits;
 
   TypeRepr(TypeReprKind K) {
@@ -779,24 +784,30 @@ class TupleTypeRepr final : public TypeRepr,
 /// \code
 ///   Foo & Bar
 /// \endcode
-class CompositionTypeRepr : public TypeRepr {
-  ArrayRef<TypeRepr *> Types;
+class CompositionTypeRepr final : public TypeRepr,
+    private llvm::TrailingObjects<CompositionTypeRepr, TypeRepr*> {
+  friend TrailingObjects;
   SourceLoc FirstTypeLoc;
   SourceRange CompositionRange;
 
-public:
   CompositionTypeRepr(ArrayRef<TypeRepr *> Types,
                       SourceLoc FirstTypeLoc,
                       SourceRange CompositionRange)
-    : TypeRepr(TypeReprKind::Composition), Types(Types),
-    FirstTypeLoc(FirstTypeLoc), CompositionRange(CompositionRange) {
+      : TypeRepr(TypeReprKind::Composition), FirstTypeLoc(FirstTypeLoc),
+        CompositionRange(CompositionRange) {
+    Bits.CompositionTypeRepr.NumTypes = Types.size();
+    std::uninitialized_copy(Types.begin(), Types.end(),
+                            getTrailingObjects<TypeRepr*>());
   }
 
-  ArrayRef<TypeRepr *> getTypes() const { return Types; }
+public:
+  ArrayRef<TypeRepr *> getTypes() const {
+    return {getTrailingObjects<TypeRepr*>(), Bits.CompositionTypeRepr.NumTypes};
+  }
   SourceLoc getSourceLoc() const { return FirstTypeLoc; }
   SourceRange getCompositionRange() const { return CompositionRange; }
 
-  static CompositionTypeRepr *create(ASTContext &C,
+  static CompositionTypeRepr *create(const ASTContext &C,
                                      ArrayRef<TypeRepr*> Protocols,
                                      SourceLoc FirstTypeLoc,
                                      SourceRange CompositionRange);

lib/AST/TypeRepr.cpp

@@ -198,14 +198,14 @@ TypeRepr *CloneVisitor::visitTupleTypeRepr(TupleTypeRepr *T) {
 
 TypeRepr *CloneVisitor::visitCompositionTypeRepr(CompositionTypeRepr *T) {
   // Clone the protocols.
-  auto types = Ctx.Allocate<TypeRepr*>(T->getTypes().size());
-  for (unsigned argI : indices(types)) {
-    types[argI] = cast<TypeRepr>(visit(T->getTypes()[argI]));
+  SmallVector<TypeRepr*, 8> types;
+  types.reserve(T->getTypes().size());
+  for (auto &type : T->getTypes()) {
+    types.push_back(cast<TypeRepr>(visit(type)));
   }
 
-  return new (Ctx) CompositionTypeRepr(types,
-                                       T->getStartLoc(),
-                                       T->getCompositionRange());
+  return CompositionTypeRepr::create(Ctx, types, T->getStartLoc(),
+                                     T->getCompositionRange());
 }
 
 TypeRepr *CloneVisitor::visitMetatypeTypeRepr(MetatypeTypeRepr *T) {
@@ -525,21 +525,21 @@ void TupleTypeRepr::printImpl(ASTPrinter &Printer,
   Printer << ")";
 }
 
-CompositionTypeRepr *
-CompositionTypeRepr::create(ASTContext &C,
-                            ArrayRef<TypeRepr *> Types,
-                            SourceLoc FirstTypeLoc,
-                            SourceRange CompositionRange) {
-  return new (C) CompositionTypeRepr(C.AllocateCopy(Types),
-                                     FirstTypeLoc, CompositionRange);
+CompositionTypeRepr *CompositionTypeRepr::create(const ASTContext &C,
+                                                 ArrayRef<TypeRepr *> Types,
+                                                 SourceLoc FirstTypeLoc,
+                                                 SourceRange CompositionRange) {
+  auto size = totalSizeToAlloc<TypeRepr*>(Types.size());
+  auto mem = C.Allocate(size, alignof(CompositionTypeRepr));
+  return new (mem) CompositionTypeRepr(Types, FirstTypeLoc, CompositionRange);
 }
 
 void CompositionTypeRepr::printImpl(ASTPrinter &Printer,
                                     const PrintOptions &Opts) const {
-  if (Types.empty()) {
+  if (getTypes().empty()) {
     Printer << "Any";
   } else {
-    interleave(Types, [&](TypeRepr *T) { printTypeRepr(T, Printer, Opts); },
+    interleave(getTypes(), [&](TypeRepr *T) { printTypeRepr(T, Printer, Opts);},
                [&] { Printer << " & "; });
   }
 }

lib/Sema/TypeCheckConstraints.cpp

@@ -1419,8 +1419,7 @@ TypeExpr *PreCheckExpression::simplifyTypeExpr(Expr *E) {
       if (!rhs) return nullptr;
       Types.push_back(rhs->getTypeRepr());
 
-      auto CompRepr = new (TC.Context) CompositionTypeRepr(
-          TC.Context.AllocateCopy(Types),
+      auto CompRepr = CompositionTypeRepr::create(TC.Context, Types,
           lhsExpr->getStartLoc(), binaryExpr->getSourceRange());
       return new (TC.Context) TypeExpr(TypeLoc(CompRepr, Type()));
     }