diff --git a/include/flatbuffers/flatbuffer_builder.h b/include/flatbuffers/flatbuffer_builder.h
index 5837cc6f7..d913e07f6 100644
--- a/include/flatbuffers/flatbuffer_builder.h
+++ b/include/flatbuffers/flatbuffer_builder.h
@@ -285,9 +285,7 @@ class FlatBufferBuilder {
     FieldLoc fl = { off, field };
     buf_.scratch_push_small(fl);
     num_field_loc++;
-    if (field > max_voffset_) {
-      max_voffset_ = field;
-    }
+    if (field > max_voffset_) { max_voffset_ = field; }
   }
 
   // Like PushElement, but additionally tracks the field this represents.
@@ -1074,7 +1072,7 @@ class FlatBufferBuilder {
   void SwapBufAllocator(FlatBufferBuilder &other) {
     buf_.swap_allocator(other.buf_);
   }
-  
+
   /// @brief The length of a FlatBuffer file header.
   static const size_t kFileIdentifierLength =
       ::flatbuffers::kFileIdentifierLength;
diff --git a/include/flatbuffers/flatbuffers.h b/include/flatbuffers/flatbuffers.h
index 43681ddd3..642178897 100644
--- a/include/flatbuffers/flatbuffers.h
+++ b/include/flatbuffers/flatbuffers.h
@@ -226,12 +226,13 @@ struct TypeTable {
 };
 
 // String which identifies the current version of FlatBuffers.
-inline const char * flatbuffers_version_string() {
+inline const char *flatbuffers_version_string() {
   return "FlatBuffers " FLATBUFFERS_STRING(FLATBUFFERS_VERSION_MAJOR) "."
       FLATBUFFERS_STRING(FLATBUFFERS_VERSION_MINOR) "."
       FLATBUFFERS_STRING(FLATBUFFERS_VERSION_REVISION);
 }
 
+// clang-format off
 #define FLATBUFFERS_DEFINE_BITMASK_OPERATORS(E, T)\
     inline E operator | (E lhs, E rhs){\
         return E(T(lhs) | T(rhs));\
diff --git a/include/flatbuffers/flexbuffers.h b/include/flatbuffers/flexbuffers.h
index 89f3f3086..a8d58d8b8 100644
--- a/include/flatbuffers/flexbuffers.h
+++ b/include/flatbuffers/flexbuffers.h
@@ -371,10 +371,7 @@ void AppendToString(std::string &s, T &&v, bool keys_quoted) {
 class Reference {
  public:
   Reference()
-      : data_(nullptr),
-        parent_width_(0),
-        byte_width_(0),
-        type_(FBT_NULL) {}
+      : data_(nullptr), parent_width_(0), byte_width_(0), type_(FBT_NULL) {}
 
   Reference(const uint8_t *data, uint8_t parent_width, uint8_t byte_width,
             Type type)
@@ -1645,8 +1642,7 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
            // comes at the cost of using additional memory the same size of
            // the buffer being verified, so it is by default off.
            std::vector<uint8_t> *reuse_tracker = nullptr,
-           bool _check_alignment = true,
-           size_t max_depth = 64)
+           bool _check_alignment = true, size_t max_depth = 64)
       : buf_(buf),
         size_(buf_len),
         depth_(0),
@@ -1689,18 +1685,16 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
     auto o = static_cast<size_t>(p - buf_);
     return VerifyBefore(o, len);
   }
-  
+
   bool VerifyByteWidth(size_t width) {
     return Check(width == 1 || width == 2 || width == 4 || width == 8);
   }
 
-  bool VerifyType(int type) {
-    return Check(type >= 0 && type < FBT_MAX_TYPE);
-  }
+  bool VerifyType(int type) { return Check(type >= 0 && type < FBT_MAX_TYPE); }
 
   bool VerifyOffset(uint64_t off, const uint8_t *p) {
     return Check(off <= static_cast<uint64_t>(size_)) &&
-                 off <= static_cast<uint64_t>(p - buf_);
+           off <= static_cast<uint64_t>(p - buf_);
   }
 
   bool VerifyAlignment(const uint8_t *p, size_t size) const {
@@ -1708,16 +1702,16 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
     return Check((o & (size - 1)) == 0 || !check_alignment_);
   }
 
-  // Macro, since we want to escape from parent function & use lazy args.
-  #define FLEX_CHECK_VERIFIED(P, PACKED_TYPE) \
-    if (reuse_tracker_) { \
-      auto packed_type = PACKED_TYPE; \
-      auto existing = (*reuse_tracker_)[P - buf_]; \
-      if (existing == packed_type) return true; \
-      /* Fail verification if already set with different type! */ \
-      if (!Check(existing == 0)) return false; \
-      (*reuse_tracker_)[P - buf_] = packed_type; \
-    }
+// Macro, since we want to escape from parent function & use lazy args.
+#define FLEX_CHECK_VERIFIED(P, PACKED_TYPE)                     \
+  if (reuse_tracker_) {                                         \
+    auto packed_type = PACKED_TYPE;                             \
+    auto existing = (*reuse_tracker_)[P - buf_];                \
+    if (existing == packed_type) return true;                   \
+    /* Fail verification if already set with different type! */ \
+    if (!Check(existing == 0)) return false;                    \
+    (*reuse_tracker_)[P - buf_] = packed_type;                  \
+  }
 
   bool VerifyVector(Reference r, const uint8_t *p, Type elem_type) {
     // Any kind of nesting goes thru this function, so guard against that
@@ -1727,19 +1721,19 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
     if (!Check(depth_ <= max_depth_ && num_vectors_ <= max_vectors_))
       return false;
     auto size_byte_width = r.byte_width_;
-    FLEX_CHECK_VERIFIED(p, PackedType(Builder::WidthB(size_byte_width), r.type_));
-    if (!VerifyBeforePointer(p, size_byte_width))
-      return false;
+    FLEX_CHECK_VERIFIED(p,
+                        PackedType(Builder::WidthB(size_byte_width), r.type_));
+    if (!VerifyBeforePointer(p, size_byte_width)) return false;
     auto sized = Sized(p, size_byte_width);
     auto num_elems = sized.size();
-    auto elem_byte_width =
-        r.type_ == FBT_STRING || r.type_ == FBT_BLOB ? uint8_t(1) : r.byte_width_;
+    auto elem_byte_width = r.type_ == FBT_STRING || r.type_ == FBT_BLOB
+                               ? uint8_t(1)
+                               : r.byte_width_;
     auto max_elems = SIZE_MAX / elem_byte_width;
     if (!Check(num_elems < max_elems))
       return false;  // Protect against byte_size overflowing.
     auto byte_size = num_elems * elem_byte_width;
-    if (!VerifyFromPointer(p, byte_size))
-      return false;
+    if (!VerifyFromPointer(p, byte_size)) return false;
     if (elem_type == FBT_NULL) {
       // Verify type bytes after the vector.
       if (!VerifyFromPointer(p + byte_size, num_elems)) return false;
@@ -1760,28 +1754,25 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
   bool VerifyKeys(const uint8_t *p, uint8_t byte_width) {
     // The vector part of the map has already been verified.
     const size_t num_prefixed_fields = 3;
-    if (!VerifyBeforePointer(p, byte_width * num_prefixed_fields))
-      return false;
+    if (!VerifyBeforePointer(p, byte_width * num_prefixed_fields)) return false;
     p -= byte_width * num_prefixed_fields;
     auto off = ReadUInt64(p, byte_width);
-    if (!VerifyOffset(off, p))
-      return false;
+    if (!VerifyOffset(off, p)) return false;
     auto key_byte_with =
-      static_cast<uint8_t>(ReadUInt64(p + byte_width, byte_width));
-    if (!VerifyByteWidth(key_byte_with))
-      return false;
+        static_cast<uint8_t>(ReadUInt64(p + byte_width, byte_width));
+    if (!VerifyByteWidth(key_byte_with)) return false;
     return VerifyVector(Reference(p, byte_width, key_byte_with, FBT_VECTOR_KEY),
                         p - off, FBT_KEY);
   }
 
-  bool VerifyKey(const uint8_t* p) {
+  bool VerifyKey(const uint8_t *p) {
     FLEX_CHECK_VERIFIED(p, PackedType(BIT_WIDTH_8, FBT_KEY));
     while (p < buf_ + size_)
       if (*p++) return true;
     return false;
   }
 
-  #undef FLEX_CHECK_VERIFIED
+#undef FLEX_CHECK_VERIFIED
 
   bool VerifyTerminator(const String &s) {
     return VerifyFromPointer(reinterpret_cast<const uint8_t *>(s.c_str()),
@@ -1799,37 +1790,26 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
     }
     // All remaining types are an offset.
     auto off = ReadUInt64(r.data_, r.parent_width_);
-    if (!VerifyOffset(off, r.data_))
-      return false;
+    if (!VerifyOffset(off, r.data_)) return false;
     auto p = r.Indirect();
-    if (!VerifyAlignment(p, r.byte_width_))
-      return false;
+    if (!VerifyAlignment(p, r.byte_width_)) return false;
     switch (r.type_) {
       case FBT_INDIRECT_INT:
       case FBT_INDIRECT_UINT:
-      case FBT_INDIRECT_FLOAT:
-        return VerifyFromPointer(p, r.byte_width_);
-      case FBT_KEY:
-        return VerifyKey(p);
+      case FBT_INDIRECT_FLOAT: return VerifyFromPointer(p, r.byte_width_);
+      case FBT_KEY: return VerifyKey(p);
       case FBT_MAP:
-        return VerifyVector(r, p, FBT_NULL) &&
-               VerifyKeys(p, r.byte_width_);
-      case FBT_VECTOR:
-        return VerifyVector(r, p, FBT_NULL);
-      case FBT_VECTOR_INT:
-        return VerifyVector(r, p, FBT_INT);
+        return VerifyVector(r, p, FBT_NULL) && VerifyKeys(p, r.byte_width_);
+      case FBT_VECTOR: return VerifyVector(r, p, FBT_NULL);
+      case FBT_VECTOR_INT: return VerifyVector(r, p, FBT_INT);
       case FBT_VECTOR_BOOL:
-      case FBT_VECTOR_UINT:
-        return VerifyVector(r, p, FBT_UINT);
-      case FBT_VECTOR_FLOAT:
-        return VerifyVector(r, p, FBT_FLOAT);
-      case FBT_VECTOR_KEY:
-        return VerifyVector(r, p, FBT_KEY);
+      case FBT_VECTOR_UINT: return VerifyVector(r, p, FBT_UINT);
+      case FBT_VECTOR_FLOAT: return VerifyVector(r, p, FBT_FLOAT);
+      case FBT_VECTOR_KEY: return VerifyVector(r, p, FBT_KEY);
       case FBT_VECTOR_STRING_DEPRECATED:
         // Use of FBT_KEY here intentional, see elsewhere.
         return VerifyVector(r, p, FBT_KEY);
-      case FBT_BLOB:
-        return VerifyVector(r, p, FBT_UINT);
+      case FBT_BLOB: return VerifyVector(r, p, FBT_UINT);
       case FBT_STRING:
         return VerifyVector(r, p, FBT_UINT) &&
                VerifyTerminator(String(p, r.byte_width_));
@@ -1844,12 +1824,10 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
       case FBT_VECTOR_FLOAT4: {
         uint8_t len = 0;
         auto vtype = ToFixedTypedVectorElementType(r.type_, &len);
-        if (!VerifyType(vtype))
-          return false;
+        if (!VerifyType(vtype)) return false;
         return VerifyFromPointer(p, r.byte_width_ * len);
       }
-      default:
-        return false;
+      default: return false;
     }
   }
 
@@ -1859,8 +1837,7 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
     auto end = buf_ + size_;
     auto byte_width = *--end;
     auto packed_type = *--end;
-    return VerifyByteWidth(byte_width) &&
-           Check(end - buf_ >= byte_width) &&
+    return VerifyByteWidth(byte_width) && Check(end - buf_ >= byte_width) &&
            VerifyRef(Reference(end - byte_width, byte_width, packed_type));
   }
 
@@ -1875,14 +1852,14 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
   std::vector<uint8_t> *reuse_tracker_;
 };
 
-// Utility function that contructs the Verifier for you, see above for parameters.
+// Utility function that contructs the Verifier for you, see above for
+// parameters.
 inline bool VerifyBuffer(const uint8_t *buf, size_t buf_len,
                          std::vector<uint8_t> *reuse_tracker = nullptr) {
   Verifier verifier(buf, buf_len, reuse_tracker);
   return verifier.VerifyBuffer();
 }
 
-
 #ifdef FLATBUFFERS_H_
 // This is a verifier utility function that works together with the
 // FlatBuffers verifier, which should only be present if flatbuffer.h
@@ -1890,9 +1867,8 @@ inline bool VerifyBuffer(const uint8_t *buf, size_t buf_len,
 inline bool VerifyNestedFlexBuffer(const flatbuffers::Vector<uint8_t> *nv,
                                    flatbuffers::Verifier &verifier) {
   if (!nv) return true;
-  return verifier.Check(
-    flexbuffers::VerifyBuffer(nv->data(), nv->size(),
-                              verifier.GetFlexReuseTracker()));
+  return verifier.Check(flexbuffers::VerifyBuffer(
+      nv->data(), nv->size(), verifier.GetFlexReuseTracker()));
 }
 #endif
 
diff --git a/include/flatbuffers/table.h b/include/flatbuffers/table.h
index dd35e9190..11b292476 100644
--- a/include/flatbuffers/table.h
+++ b/include/flatbuffers/table.h
@@ -112,18 +112,19 @@ class Table {
 
   // Verify a particular field.
   template<typename T>
-  bool VerifyField(const Verifier &verifier, voffset_t field, size_t align) const {
+  bool VerifyField(const Verifier &verifier, voffset_t field,
+                   size_t align) const {
     // Calling GetOptionalFieldOffset should be safe now thanks to
     // VerifyTable().
     auto field_offset = GetOptionalFieldOffset(field);
     // Check the actual field.
-    return !field_offset ||
-           verifier.VerifyField<T>(data_, field_offset, align);
+    return !field_offset || verifier.VerifyField<T>(data_, field_offset, align);
   }
 
   // VerifyField for required fields.
   template<typename T>
-  bool VerifyFieldRequired(const Verifier &verifier, voffset_t field, size_t align) const {
+  bool VerifyFieldRequired(const Verifier &verifier, voffset_t field,
+                           size_t align) const {
     auto field_offset = GetOptionalFieldOffset(field);
     return verifier.Check(field_offset != 0) &&
            verifier.VerifyField<T>(data_, field_offset, align);
diff --git a/include/flatbuffers/util.h b/include/flatbuffers/util.h
index c0a37b9f6..690e63d30 100644
--- a/include/flatbuffers/util.h
+++ b/include/flatbuffers/util.h
@@ -17,15 +17,15 @@
 #ifndef FLATBUFFERS_UTIL_H_
 #define FLATBUFFERS_UTIL_H_
 
-#include <errno.h>
 #include <ctype.h>
+#include <errno.h>
 
 #include "flatbuffers/base.h"
 #include "flatbuffers/stl_emulation.h"
 
 #ifndef FLATBUFFERS_PREFER_PRINTF
-#  include <sstream>
 #  include <iomanip>
+#  include <sstream>
 #else  // FLATBUFFERS_PREFER_PRINTF
 #  include <float.h>
 #  include <stdio.h>
diff --git a/include/flatbuffers/verifier.h b/include/flatbuffers/verifier.h
index bc1976d25..4512d451b 100644
--- a/include/flatbuffers/verifier.h
+++ b/include/flatbuffers/verifier.h
@@ -81,14 +81,15 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
   }
 
   // Verify relative to a known-good base pointer.
-  bool VerifyFieldStruct(const uint8_t *base, voffset_t elem_off, size_t elem_len,
-                         size_t align) const {
+  bool VerifyFieldStruct(const uint8_t *base, voffset_t elem_off,
+                         size_t elem_len, size_t align) const {
     auto f = static_cast<size_t>(base - buf_) + elem_off;
     return VerifyAlignment(f, align) && Verify(f, elem_len);
   }
 
   template<typename T>
-  bool VerifyField(const uint8_t *base, voffset_t elem_off, size_t align) const {
+  bool VerifyField(const uint8_t *base, voffset_t elem_off,
+                   size_t align) const {
     auto f = static_cast<size_t>(base - buf_) + elem_off;
     return VerifyAlignment(f, align) && Verify(f, sizeof(T));
   }
@@ -259,9 +260,7 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
     // clang-format on
   }
 
-  std::vector<uint8_t> *GetFlexReuseTracker() {
-    return flex_reuse_tracker_;
-  }
+  std::vector<uint8_t> *GetFlexReuseTracker() { return flex_reuse_tracker_; }
 
   void SetFlexReuseTracker(std::vector<uint8_t> *rt) {
     flex_reuse_tracker_ = rt;
diff --git a/src/idl_gen_cpp.cpp b/src/idl_gen_cpp.cpp
index e1386fdf6..dc5002692 100644
--- a/src/idl_gen_cpp.cpp
+++ b/src/idl_gen_cpp.cpp
@@ -538,7 +538,9 @@ class CppGenerator : public BaseGenerator {
 
         // Check if a size-prefixed buffer has the identifier.
         code_ += "inline \\";
-        code_ += "bool SizePrefixed{{STRUCT_NAME}}BufferHasIdentifier(const void *buf) {";
+        code_ +=
+            "bool SizePrefixed{{STRUCT_NAME}}BufferHasIdentifier(const void "
+            "*buf) {";
         code_ += "  return flatbuffers::BufferHasIdentifier(";
         code_ += "      buf, {{STRUCT_NAME}}Identifier(), true);";
         code_ += "}";
@@ -1482,7 +1484,7 @@ class CppGenerator : public BaseGenerator {
         if (ev.union_type.base_type == BASE_TYPE_STRUCT) {
           if (ev.union_type.struct_def->fixed) {
             code_.SetValue("ALIGN",
-              NumToString(ev.union_type.struct_def->minalign));
+                           NumToString(ev.union_type.struct_def->minalign));
             code_ +=
                 "      return verifier.VerifyField<{{TYPE}}>("
                 "static_cast<const uint8_t *>(obj), 0, {{ALIGN}});";
@@ -2122,8 +2124,9 @@ class CppGenerator : public BaseGenerator {
     code_.SetValue("OFFSET", GenFieldOffsetName(field));
     if (IsScalar(field.value.type.base_type) || IsStruct(field.value.type)) {
       code_.SetValue("ALIGN", NumToString(InlineAlignment(field.value.type)));
-      code_ += "{{PRE}}VerifyField{{REQUIRED}}<{{SIZE}}>(verifier, "
-               "{{OFFSET}}, {{ALIGN}})\\";
+      code_ +=
+          "{{PRE}}VerifyField{{REQUIRED}}<{{SIZE}}>(verifier, "
+          "{{OFFSET}}, {{ALIGN}})\\";
     } else {
       code_ += "{{PRE}}VerifyOffset{{REQUIRED}}(verifier, {{OFFSET}})\\";
     }
@@ -2175,11 +2178,13 @@ class CppGenerator : public BaseGenerator {
         if (!nfn.empty()) {
           code_.SetValue("CPP_NAME", nfn);
           // FIXME: file_identifier.
-          code_ += "{{PRE}}verifier.VerifyNestedFlatBuffer<{{CPP_NAME}}>"
-                   "({{NAME}}(), nullptr)\\";
+          code_ +=
+              "{{PRE}}verifier.VerifyNestedFlatBuffer<{{CPP_NAME}}>"
+              "({{NAME}}(), nullptr)\\";
         } else if (field.flexbuffer) {
-          code_ += "{{PRE}}flexbuffers::VerifyNestedFlexBuffer"
-                   "({{NAME}}(), verifier)\\";        
+          code_ +=
+              "{{PRE}}flexbuffers::VerifyNestedFlexBuffer"
+              "({{NAME}}(), verifier)\\";
         }
         break;
       }
@@ -2216,7 +2221,8 @@ class CppGenerator : public BaseGenerator {
       }
       // Returns {field<val: -1, field==val: 0, field>val: +1}.
       code_.SetValue("KEY_TYPE", type);
-      code_ += "  int KeyCompareWithValue({{KEY_TYPE}} _{{FIELD_NAME}}) const {";
+      code_ +=
+          "  int KeyCompareWithValue({{KEY_TYPE}} _{{FIELD_NAME}}) const {";
       code_ +=
           "    return static_cast<int>({{FIELD_NAME}}() > _{{FIELD_NAME}}) - "
           "static_cast<int>({{FIELD_NAME}}() < _{{FIELD_NAME}});";
diff --git a/src/idl_gen_python.cpp b/src/idl_gen_python.cpp
index fddeb1a1f..395c5b553 100644
--- a/src/idl_gen_python.cpp
+++ b/src/idl_gen_python.cpp
@@ -738,11 +738,8 @@ class PythonGenerator : public BaseGenerator {
           }
           break;
         }
-        case BASE_TYPE_UNION:
-          GetUnionField(struct_def, field, code_ptr);
-          break;
-        default:
-          FLATBUFFERS_ASSERT(0);
+        case BASE_TYPE_UNION: GetUnionField(struct_def, field, code_ptr); break;
+        default: FLATBUFFERS_ASSERT(0);
       }
     }
     if (IsVector(field.value.type) || IsArray(field.value.type)) {
@@ -913,14 +910,9 @@ class PythonGenerator : public BaseGenerator {
             import_list->insert("import " + package_reference);
           }
           break;
-        case BASE_TYPE_STRING:
-          field_type += "str";
-          break;
-        case BASE_TYPE_NONE:
-          field_type += "None";
-          break;
-        default:
-          break;
+        case BASE_TYPE_STRING: field_type += "str"; break;
+        case BASE_TYPE_NONE: field_type += "None"; break;
+        default: break;
       }
       field_types += field_type + separator_string;
     }
@@ -1253,8 +1245,7 @@ class PythonGenerator : public BaseGenerator {
           GenUnPackForScalarVector(struct_def, field, &code);
           break;
         }
-        default:
-          GenUnPackForScalar(struct_def, field, &code);
+        default: GenUnPackForScalar(struct_def, field, &code);
       }
     }
 
diff --git a/src/idl_gen_rust.cpp b/src/idl_gen_rust.cpp
index d4cb31274..0f4117bb9 100644
--- a/src/idl_gen_rust.cpp
+++ b/src/idl_gen_rust.cpp
@@ -859,7 +859,8 @@ class RustGenerator : public BaseGenerator {
         code_ += "    serializer.serialize_u32(self.bits() as u32)";
       } else {
         code_ +=
-            "    serializer.serialize_unit_variant(\"{{ENUM_NAME}}\", self.0 as "
+            "    serializer.serialize_unit_variant(\"{{ENUM_NAME}}\", self.0 "
+            "as "
             "u32, self.variant_name().unwrap())";
       }
       code_ += "  }";
@@ -2752,7 +2753,8 @@ class RustGenerator : public BaseGenerator {
       ForAllStructFields(struct_def, [&](const FieldDef &unused) {
         (void)unused;
         code_ +=
-            "    s.serialize_field(\"{{FIELD_NAME}}\", &self.{{FIELD_NAME}}())?;";
+            "    s.serialize_field(\"{{FIELD_NAME}}\", "
+            "&self.{{FIELD_NAME}}())?;";
       });
       code_ += "    s.end()";
       code_ += "  }";
@@ -2959,8 +2961,9 @@ class RustGenerator : public BaseGenerator {
     code_ += "";
     if (parser_.opts.rust_serialize) {
       code_ += indent + "extern crate serde;";
-      code_ += indent +
-               "use self::serde::ser::{Serialize, Serializer, SerializeStruct};";
+      code_ +=
+          indent +
+          "use self::serde::ser::{Serialize, Serializer, SerializeStruct};";
       code_ += "";
     }
     code_ += indent + "extern crate flatbuffers;";
diff --git a/src/idl_gen_swift.cpp b/src/idl_gen_swift.cpp
index 816e76be9..262041507 100644
--- a/src/idl_gen_swift.cpp
+++ b/src/idl_gen_swift.cpp
@@ -711,8 +711,9 @@ class SwiftGenerator : public BaseGenerator {
     }
 
     if (IsBool(field.value.type.base_type)) {
-      std::string default_value = field.IsOptional() ? "nil" :
-       ("0" == field.value.constant ? "false" : "true");
+      std::string default_value =
+          field.IsOptional() ? "nil"
+                             : ("0" == field.value.constant ? "false" : "true");
       code_.SetValue("CONSTANT", default_value);
       code_.SetValue("VALUETYPE", "Bool");
       code_ += GenReaderMainBody(optional) + "\\";
diff --git a/src/idl_gen_ts.cpp b/src/idl_gen_ts.cpp
index ac4b1640e..110c610f8 100644
--- a/src/idl_gen_ts.cpp
+++ b/src/idl_gen_ts.cpp
@@ -343,8 +343,7 @@ class TsGenerator : public BaseGenerator {
     switch (type.base_type) {
       case BASE_TYPE_BOOL: return allowNull ? "boolean|null" : "boolean";
       case BASE_TYPE_LONG:
-      case BASE_TYPE_ULONG:
-        return allowNull ? "bigint|null" : "bigint";
+      case BASE_TYPE_ULONG: return allowNull ? "bigint|null" : "bigint";
       default:
         if (IsScalar(type.base_type)) {
           if (type.enum_def) {
@@ -907,8 +906,7 @@ class TsGenerator : public BaseGenerator {
       // a string that contains values for things that can be created inline or
       // the variable name from field_offset_decl
       std::string field_offset_val;
-      const auto field_default_val =
-          GenDefaultValue(field, imports);
+      const auto field_default_val = GenDefaultValue(field, imports);
 
       // Emit a scalar field
       const auto is_string = IsString(field.value.type);
@@ -1643,7 +1641,7 @@ class TsGenerator : public BaseGenerator {
 
   std::string GetArgName(const FieldDef &field) {
     auto argname = MakeCamel(field.name, false);
-    if (!IsScalar(field.value.type.base_type)) { 
+    if (!IsScalar(field.value.type.base_type)) {
       argname += "Offset";
     } else {
       argname = EscapeKeyword(argname);
diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp
index 4ebf99b33..7e4cb08fd 100644
--- a/src/idl_parser.cpp
+++ b/src/idl_parser.cpp
@@ -1677,8 +1677,9 @@ CheckedError Parser::ParseNestedFlatbuffer(Value &val, FieldDef *field,
     if (opts.json_nested_legacy_flatbuffers) {
       ECHECK(ParseAnyValue(val, field, fieldn, parent_struct_def, 0));
     } else {
-      return Error("cannot parse nested_flatbuffer as bytes unless"
-                   " --json-nested-bytes is set");
+      return Error(
+          "cannot parse nested_flatbuffer as bytes unless"
+          " --json-nested-bytes is set");
     }
   } else {
     auto cursor_at_value_begin = cursor_;
@@ -2167,9 +2168,7 @@ void EnumDef::SortByValue() {
     });
   else
     std::sort(v.begin(), v.end(), [](const EnumVal *e1, const EnumVal *e2) {
-      if (e1->GetAsInt64() == e2->GetAsInt64()) {
-        return e1->name < e2->name;
-      }
+      if (e1->GetAsInt64() == e2->GetAsInt64()) { return e1->name < e2->name; }
       return e1->GetAsInt64() < e2->GetAsInt64();
     });
 }
diff --git a/src/reflection.cpp b/src/reflection.cpp
index 16fd5c17e..6bba28c53 100644
--- a/src/reflection.cpp
+++ b/src/reflection.cpp
@@ -645,8 +645,7 @@ bool VerifyObject(flatbuffers::Verifier &v, const reflection::Schema &schema,
       case reflection::Bool:
       case reflection::Byte:
       case reflection::UByte:
-        if (!table->VerifyField<int8_t>(v, field_def->offset(),
-                                        sizeof(int8_t)))
+        if (!table->VerifyField<int8_t>(v, field_def->offset(), sizeof(int8_t)))
           return false;
         break;
       case reflection::Short:
@@ -668,13 +667,11 @@ bool VerifyObject(flatbuffers::Verifier &v, const reflection::Schema &schema,
           return false;
         break;
       case reflection::Float:
-        if (!table->VerifyField<float>(v, field_def->offset(),
-                                       sizeof(float)))
+        if (!table->VerifyField<float>(v, field_def->offset(), sizeof(float)))
           return false;
         break;
       case reflection::Double:
-        if (!table->VerifyField<double>(v, field_def->offset(),
-                                        sizeof(double)))
+        if (!table->VerifyField<double>(v, field_def->offset(), sizeof(double)))
           return false;
         break;
       case reflection::String:
diff --git a/tests/test.cpp b/tests/test.cpp
index 4aa9077dc..5247f5086 100644
--- a/tests/test.cpp
+++ b/tests/test.cpp
@@ -496,7 +496,7 @@ void MutateFlatBuffersTest(uint8_t *flatbuf, std::size_t length) {
 }
 
 // Utility function to check a Monster object.
-void CheckMonsterObject(MonsterT* monster2) {
+void CheckMonsterObject(MonsterT *monster2) {
   TEST_EQ(monster2->hp, 80);
   TEST_EQ(monster2->mana, 150);  // default
   TEST_EQ_STR(monster2->name.c_str(), "MyMonster");
@@ -589,8 +589,7 @@ void ObjectFlatBuffersTest(uint8_t *flatbuf) {
   // Test object copy.
   auto monster3 = *monster2;
   flatbuffers::FlatBufferBuilder fbb3;
-  fbb3.Finish(CreateMonster(fbb3, &monster3, &rehasher),
-              MonsterIdentifier());
+  fbb3.Finish(CreateMonster(fbb3, &monster3, &rehasher), MonsterIdentifier());
   const auto len3 = fbb3.GetSize();
   TEST_EQ(len2, len3);
   TEST_EQ(memcmp(fbb2.GetBufferPointer(), fbb3.GetBufferPointer(), len2), 0);