Use the Google Style for clang-format without exceptions (#8706)

This reduces the friction when merging from github and google repos by
using the exact same clang style guide.

MARKDOWN=true

tests/test_builder.cpp

@@ -11,16 +11,16 @@ struct OwnedAllocator : public DefaultAllocator {};
 
 class TestHeapBuilder : public FlatBufferBuilder {
  private:
-  TestHeapBuilder(const TestHeapBuilder &);
-  TestHeapBuilder &operator=(const TestHeapBuilder &);
+  TestHeapBuilder(const TestHeapBuilder&);
+  TestHeapBuilder& operator=(const TestHeapBuilder&);
 
  public:
   TestHeapBuilder() : FlatBufferBuilder(2048, new OwnedAllocator(), true) {}
 
-  TestHeapBuilder(TestHeapBuilder &&other)
+  TestHeapBuilder(TestHeapBuilder&& other)
       : FlatBufferBuilder(std::move(other)) {}
 
-  TestHeapBuilder &operator=(TestHeapBuilder &&other) {
+  TestHeapBuilder& operator=(TestHeapBuilder&& other) {
     FlatBufferBuilder::operator=(std::move(other));
     return *this;
   }
@@ -34,27 +34,27 @@ struct AllocatorMember {
 struct GrpcLikeMessageBuilder : private AllocatorMember,
                                 public FlatBufferBuilder {
  private:
-  GrpcLikeMessageBuilder(const GrpcLikeMessageBuilder &);
-  GrpcLikeMessageBuilder &operator=(const GrpcLikeMessageBuilder &);
+  GrpcLikeMessageBuilder(const GrpcLikeMessageBuilder&);
+  GrpcLikeMessageBuilder& operator=(const GrpcLikeMessageBuilder&);
 
  public:
   GrpcLikeMessageBuilder()
       : FlatBufferBuilder(1024, &member_allocator_, false) {}
 
-  GrpcLikeMessageBuilder(GrpcLikeMessageBuilder &&other)
+  GrpcLikeMessageBuilder(GrpcLikeMessageBuilder&& other)
       : FlatBufferBuilder(1024, &member_allocator_, false) {
     // Default construct and swap idiom.
     Swap(other);
   }
 
-  GrpcLikeMessageBuilder &operator=(GrpcLikeMessageBuilder &&other) {
+  GrpcLikeMessageBuilder& operator=(GrpcLikeMessageBuilder&& other) {
     // Construct temporary and swap idiom
     GrpcLikeMessageBuilder temp(std::move(other));
     Swap(temp);
     return *this;
   }
 
-  void Swap(GrpcLikeMessageBuilder &other) {
+  void Swap(GrpcLikeMessageBuilder& other) {
     // No need to swap member_allocator_ because it's stateless.
     FlatBufferBuilder::Swap(other);
     // After swapping the FlatBufferBuilder, we swap back the allocator, which
@@ -67,23 +67,23 @@ struct GrpcLikeMessageBuilder : private AllocatorMember,
 };
 
 flatbuffers::Offset<Monster> populate1(
-    flatbuffers::FlatBufferBuilder &builder) {
+    flatbuffers::FlatBufferBuilder& builder) {
   auto name_offset = builder.CreateString(m1_name());
   return CreateMonster(builder, nullptr, 0, 0, name_offset, 0, m1_color());
 }
 
 flatbuffers::Offset<Monster> populate2(
-    flatbuffers::FlatBufferBuilder &builder) {
+    flatbuffers::FlatBufferBuilder& builder) {
   auto name_offset = builder.CreateString(m2_name());
   return CreateMonster(builder, nullptr, 0, 0, name_offset, 0, m2_color());
 }
 
-uint8_t *release_raw_base(flatbuffers::FlatBufferBuilder &fbb, size_t &size,
-                          size_t &offset) {
+uint8_t* release_raw_base(flatbuffers::FlatBufferBuilder& fbb, size_t& size,
+                          size_t& offset) {
   return fbb.ReleaseRaw(size, offset);
 }
 
-void free_raw(flatbuffers::grpc::MessageBuilder &, uint8_t *) {
+void free_raw(flatbuffers::grpc::MessageBuilder&, uint8_t*) {
   // release_raw_base calls FlatBufferBuilder::ReleaseRaw on the argument
   // MessageBuilder. It's semantically wrong as MessageBuilder has its own
   // ReleaseRaw member function that takes three arguments. In such cases
@@ -94,26 +94,26 @@ void free_raw(flatbuffers::grpc::MessageBuilder &, uint8_t *) {
   // not occur with FlatBufferBuilder.
 }
 
-void free_raw(flatbuffers::FlatBufferBuilder &, uint8_t *buf) {
+void free_raw(flatbuffers::FlatBufferBuilder&, uint8_t* buf) {
   flatbuffers::DefaultAllocator().deallocate(buf, 0);
 }
 
-bool verify(const flatbuffers::DetachedBuffer &buf,
-            const std::string &expected_name, Color color) {
-  const Monster *monster = flatbuffers::GetRoot<Monster>(buf.data());
+bool verify(const flatbuffers::DetachedBuffer& buf,
+            const std::string& expected_name, Color color) {
+  const Monster* monster = flatbuffers::GetRoot<Monster>(buf.data());
   return (monster->name()->str() == expected_name) &&
          (monster->color() == color);
 }
 
-bool verify(const uint8_t *buf, size_t offset, const std::string &expected_name,
+bool verify(const uint8_t* buf, size_t offset, const std::string& expected_name,
             Color color) {
-  const Monster *monster = flatbuffers::GetRoot<Monster>(buf + offset);
+  const Monster* monster = flatbuffers::GetRoot<Monster>(buf + offset);
   return (monster->name()->str() == expected_name) &&
          (monster->color() == color);
 }
 
-bool release_n_verify(flatbuffers::FlatBufferBuilder &fbb,
-                      const std::string &expected_name, Color color) {
+bool release_n_verify(flatbuffers::FlatBufferBuilder& fbb,
+                      const std::string& expected_name, Color color) {
   flatbuffers::DetachedBuffer buf = fbb.Release();
   return verify(buf, expected_name, color);
 }
@@ -129,10 +129,9 @@ void FlatBufferBuilderTest() {
   BuilderTests<GrpcLikeMessageBuilder>::all_tests();
 
   BuilderReuseTestSelector tests[4] = {
-    REUSABLE_AFTER_RELEASE, REUSABLE_AFTER_RELEASE_RAW,
-    REUSABLE_AFTER_RELEASE_AND_MOVE_ASSIGN,
-    REUSABLE_AFTER_RELEASE_RAW_AND_MOVE_ASSIGN
-  };
+      REUSABLE_AFTER_RELEASE, REUSABLE_AFTER_RELEASE_RAW,
+      REUSABLE_AFTER_RELEASE_AND_MOVE_ASSIGN,
+      REUSABLE_AFTER_RELEASE_RAW_AND_MOVE_ASSIGN};
 
   BuilderReuseTests<FlatBufferBuilder, FlatBufferBuilder>::run_tests(
       TestSelector(tests, tests + 4));
@@ -143,7 +142,7 @@ void FlatBufferBuilderTest() {
 }
 
 // forward-declared in test_builder.h
-void CheckTestGeneratedIsValid(const MyGame::Example::Color &);
+void CheckTestGeneratedIsValid(const MyGame::Example::Color&);
 
 // Link-time check using pointer type.
-void CheckTestGeneratedIsValid(const MyGame::Example::Color &) {}
+void CheckTestGeneratedIsValid(const MyGame::Example::Color&) {}