IRGen: Rename "Sequential Type" to "Record Type", the latter is more standard, NFC.

Author: slavapestov

lib/IRGen/GenSequential.h renamed to lib/IRGen/GenRecord.h

@@ -1,4 +1,4 @@
-//===--- GenSequential.h - IR generation for sequential types ---*- C++ -*-===//
+//===--- GenRecord.h - IR generation for record types -----------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -10,13 +10,13 @@
 //
 //===----------------------------------------------------------------------===//
 //
-//  This file provides some common code for emitting sequential types.
-//  A sequential type is something like a tuple or a struct.
+//  This file provides some common code for emitting record types.
+//  A record type is something like a tuple or a struct.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SWIFT_IRGEN_GENSEQUENTIAL_H
-#define SWIFT_IRGEN_GENSEQUENTIAL_H
+#ifndef SWIFT_IRGEN_GENRECORD_H
+#define SWIFT_IRGEN_GENRECORD_H
 
 #include "IRGenFunction.h"
 #include "IRGenModule.h"
@@ -29,24 +29,24 @@
 namespace swift {
 namespace irgen {
 
-template <class, class, class> class SequentialTypeBuilder;
+template <class, class, class> class RecordTypeBuilder;
 
-/// A field of a sequential type.
-template <class FieldImpl> class SequentialField {
+/// A field of a record type.
+template <class FieldImpl> class RecordField {
   ElementLayout Layout;
 
-  template <class, class, class> friend class SequentialTypeBuilder;
+  template <class, class, class> friend class RecordTypeBuilder;
 
   /// Begin/End - the range of explosion indexes for this element
   unsigned Begin : 16;
   unsigned End : 16;
 
 protected:
-  explicit SequentialField(const TypeInfo &elementTI)
+  explicit RecordField(const TypeInfo &elementTI)
     : Layout(ElementLayout::getIncomplete(elementTI)) {}
 
-  explicit SequentialField(const ElementLayout &layout,
-                           unsigned begin, unsigned end)
+  explicit RecordField(const ElementLayout &layout,
+                       unsigned begin, unsigned end)
     : Layout(layout), Begin(begin), End(end) {}
 
   const FieldImpl *asImpl() const {
@@ -85,10 +85,10 @@ template <class FieldImpl> class SequentialField {
   }
 };
 
-/// A metaprogrammed TypeInfo implementation for sequential types.
+/// A metaprogrammed TypeInfo implementation for record types.
 template <class Impl, class Base, class FieldImpl_,
           bool IsLoadable = std::is_base_of<LoadableTypeInfo, Base>::value>
-class SequentialTypeInfoImpl : public Base {
+class RecordTypeInfoImpl : public Base {
 public:
   typedef FieldImpl_ FieldImpl;
 
@@ -106,7 +106,7 @@ class SequentialTypeInfoImpl : public Base {
   const Impl &asImpl() const { return *static_cast<const Impl*>(this); }
 
   template <class... As> 
-  SequentialTypeInfoImpl(ArrayRef<FieldImpl> fields, As&&...args)
+  RecordTypeInfoImpl(ArrayRef<FieldImpl> fields, As&&...args)
       : Base(std::forward<As>(args)...), NumFields(fields.size()) {
     std::uninitialized_copy(fields.begin(), fields.end(),
                             getFieldsBuffer());
@@ -214,32 +214,32 @@ class SequentialTypeInfoImpl : public Base {
 
 template <class Impl, class Base, class FieldImpl_,
           bool IsLoadable = std::is_base_of<LoadableTypeInfo, Base>::value>
-class SequentialTypeInfo;
+class RecordTypeInfo;
 
-/// An implementation of SequentialTypeInfo for non-loadable types. 
+/// An implementation of RecordTypeInfo for non-loadable types. 
 template <class Impl, class Base, class FieldImpl>
-class SequentialTypeInfo<Impl, Base, FieldImpl, /*IsLoadable*/ false>
-    : public SequentialTypeInfoImpl<Impl, Base, FieldImpl> {
-  typedef SequentialTypeInfoImpl<Impl, Base, FieldImpl> super;
+class RecordTypeInfo<Impl, Base, FieldImpl, /*IsLoadable*/ false>
+    : public RecordTypeInfoImpl<Impl, Base, FieldImpl> {
+  typedef RecordTypeInfoImpl<Impl, Base, FieldImpl> super;
 protected:
   template <class... As> 
-  SequentialTypeInfo(As&&...args) : super(std::forward<As>(args)...) {}
+  RecordTypeInfo(As&&...args) : super(std::forward<As>(args)...) {}
 };
 
-/// An implementation of SequentialTypeInfo for loadable types. 
+/// An implementation of RecordTypeInfo for loadable types. 
 template <class Impl, class Base, class FieldImpl>
-class SequentialTypeInfo<Impl, Base, FieldImpl, /*IsLoadable*/ true>
-    : public SequentialTypeInfoImpl<Impl, Base, FieldImpl> {
-  typedef SequentialTypeInfoImpl<Impl, Base, FieldImpl> super;
+class RecordTypeInfo<Impl, Base, FieldImpl, /*IsLoadable*/ true>
+    : public RecordTypeInfoImpl<Impl, Base, FieldImpl> {
+  typedef RecordTypeInfoImpl<Impl, Base, FieldImpl> super;
 
   unsigned ExplosionSize : 16;
 
 protected:
   using super::asImpl;
 
   template <class... As> 
-  SequentialTypeInfo(ArrayRef<FieldImpl> fields, unsigned explosionSize,
-                     As &&...args)
+  RecordTypeInfo(ArrayRef<FieldImpl> fields, unsigned explosionSize,
+                 As &&...args)
     : super(fields, std::forward<As>(args)...),
       ExplosionSize(explosionSize) {}
 
@@ -346,7 +346,7 @@ class SequentialTypeInfo<Impl, Base, FieldImpl, /*IsLoadable*/ true>
   }
 };
 
-/// A builder of sequential types.
+/// A builder of record types.
 ///
 /// Required for a full implementation:
 ///   TypeInfoImpl *construct(void *buffer, ArrayRef<ASTField> fields);
@@ -355,10 +355,10 @@ class SequentialTypeInfo<Impl, Base, FieldImpl, /*IsLoadable*/ true>
 ///   void performLayout(ArrayRef<const TypeInfo *> fieldTypes);
 ///     - should call recordLayout with the layout
 template <class BuilderImpl, class FieldImpl, class ASTField>
-class SequentialTypeBuilder {
+class RecordTypeBuilder {
 protected:
   IRGenModule &IGM;
-  SequentialTypeBuilder(IRGenModule &IGM) : IGM(IGM) {}
+  RecordTypeBuilder(IRGenModule &IGM) : IGM(IGM) {}
 
   BuilderImpl *asImpl() { return static_cast<BuilderImpl*>(this); }
 

lib/IRGen/GenStruct.cpp

@@ -28,7 +28,7 @@
 #include "clang/AST/RecordLayout.h"
 
 #include "GenMeta.h"
-#include "GenSequential.h"
+#include "GenRecord.h"
 #include "GenType.h"
 #include "IRGenFunction.h"
 #include "IRGenModule.h"
@@ -57,10 +57,10 @@ static StructTypeInfoKind getStructTypeInfoKind(const TypeInfo &type) {
 }
 
 namespace {
-  class StructFieldInfo : public SequentialField<StructFieldInfo> {
+  class StructFieldInfo : public RecordField<StructFieldInfo> {
   public:
     StructFieldInfo(VarDecl *field, const TypeInfo &type)
-      : SequentialField(type), Field(field) {}
+      : RecordField(type), Field(field) {}
 
     /// The field.
     VarDecl * const Field;
@@ -75,11 +75,11 @@ namespace {
   };
 
   /// A field-info implementation for fields of Clang types.
-  class ClangFieldInfo : public SequentialField<ClangFieldInfo> {
+  class ClangFieldInfo : public RecordField<ClangFieldInfo> {
   public:
     ClangFieldInfo(VarDecl *swiftField, const ElementLayout &layout,
                    unsigned explosionBegin, unsigned explosionEnd)
-      : SequentialField(layout, explosionBegin, explosionEnd),
+      : RecordField(layout, explosionBegin, explosionEnd),
         Field(swiftField) {}
 
     VarDecl * const Field;
@@ -102,8 +102,8 @@ namespace {
   /// A common base class for structs.
   template <class Impl, class Base, class FieldInfoType = StructFieldInfo>
   class StructTypeInfoBase :
-     public SequentialTypeInfo<Impl, Base, FieldInfoType> {
-    typedef SequentialTypeInfo<Impl, Base, FieldInfoType> super;
+     public RecordTypeInfo<Impl, Base, FieldInfoType> {
+    typedef RecordTypeInfo<Impl, Base, FieldInfoType> super;
 
   protected:
     template <class... As>
@@ -441,14 +441,14 @@ namespace {
   };
 
   class StructTypeBuilder :
-    public SequentialTypeBuilder<StructTypeBuilder, StructFieldInfo, VarDecl*> {
+    public RecordTypeBuilder<StructTypeBuilder, StructFieldInfo, VarDecl*> {
 
     llvm::StructType *StructTy;
     CanType TheStruct;
   public:
     StructTypeBuilder(IRGenModule &IGM, llvm::StructType *structTy,
                       CanType type) :
-      SequentialTypeBuilder(IGM), StructTy(structTy), TheStruct(type) {
+      RecordTypeBuilder(IGM), StructTy(structTy), TheStruct(type) {
     }
 
     LoadableStructTypeInfo *createLoadable(ArrayRef<StructFieldInfo> fields,

lib/IRGen/GenTuple.cpp

@@ -27,7 +27,7 @@
 #include "llvm/IR/DerivedTypes.h"
 
 #include "GenHeap.h"
-#include "GenSequential.h"
+#include "GenRecord.h"
 #include "GenType.h"
 #include "IRGenFunction.h"
 #include "IRGenModule.h"
@@ -43,10 +43,10 @@ using namespace swift;
 using namespace irgen;
 
 namespace {
-  class TupleFieldInfo : public SequentialField<TupleFieldInfo> {
+  class TupleFieldInfo : public RecordField<TupleFieldInfo> {
   public:
     TupleFieldInfo(unsigned index, StringRef name, const TypeInfo &type)
-      : SequentialField(type), Index(index), Name(name)
+      : RecordField(type), Index(index), Name(name)
     {}
 
     /// The field index.
@@ -71,8 +71,8 @@ namespace {
   /// Adapter for tuple types.
   template <class Impl, class Base>
   class TupleTypeInfoBase
-      : public SequentialTypeInfo<Impl, Base, TupleFieldInfo> {
-    typedef SequentialTypeInfo<Impl, Base, TupleFieldInfo> super;
+      : public RecordTypeInfo<Impl, Base, TupleFieldInfo> {
+    typedef RecordTypeInfo<Impl, Base, TupleFieldInfo> super;
 
   protected:
     template <class... As>
@@ -283,13 +283,13 @@ namespace {
   };
 
   class TupleTypeBuilder :
-      public SequentialTypeBuilder<TupleTypeBuilder, TupleFieldInfo,
-                                   TupleTypeElt> {
+      public RecordTypeBuilder<TupleTypeBuilder, TupleFieldInfo,
+                               TupleTypeElt> {
     SILType TheTuple;
 
   public:
     TupleTypeBuilder(IRGenModule &IGM, SILType theTuple)
-      : SequentialTypeBuilder(IGM), TheTuple(theTuple) {}
+      : RecordTypeBuilder(IGM), TheTuple(theTuple) {}
 
     FixedTupleTypeInfo *createFixed(ArrayRef<TupleFieldInfo> fields,
                                     StructLayout &&layout) {