PR: Fix variable naming cases for variables, leave lambdas for now

cjappl · cjappl · commit 1a2db4187500 · 2024-05-21T08:03:40.000-07:00
diff --git a/compiler-rt/lib/radsan/radsan_context.cpp b/compiler-rt/lib/radsan/radsan_context.cpp
@@ -24,28 +24,28 @@ using namespace __sanitizer;
 
 namespace detail {
 
-static pthread_key_t Key;
-static pthread_once_t KeyOnce = PTHREAD_ONCE_INIT;
-void internalFree(void *Ptr) { __sanitizer::InternalFree(Ptr); }
+static pthread_key_t key;
+static pthread_once_t key_once = PTHREAD_ONCE_INIT;
+void internalFree(void *ptr) { __sanitizer::InternalFree(ptr); }
 
 using __radsan::Context;
 
 Context &GetContextForThisThreadImpl() {
-  auto MakeTlsKey = []() {
-    CHECK_EQ(pthread_key_create(&detail::Key, detail::internalFree), 0);
+  auto make_tls_key = []() {
+    CHECK_EQ(pthread_key_create(&detail::key, detail::internalFree), 0);
   };
 
-  pthread_once(&detail::KeyOnce, MakeTlsKey);
-  Context *CurrentThreadContext =
-      static_cast<Context *>(pthread_getspecific(detail::Key));
-  if (CurrentThreadContext == nullptr) {
-    CurrentThreadContext =
+  pthread_once(&detail::key_once, make_tls_key);
+  Context *current_thread_context =
+      static_cast<Context *>(pthread_getspecific(detail::key));
+  if (current_thread_context == nullptr) {
+    current_thread_context =
         static_cast<Context *>(InternalAlloc(sizeof(Context)));
-    new (CurrentThreadContext) Context();
-    pthread_setspecific(detail::Key, CurrentThreadContext);
+    new (current_thread_context) Context();
+    pthread_setspecific(detail::key, current_thread_context);
   }
 
-  return *CurrentThreadContext;
+  return *current_thread_context;
 }
 
 /*
@@ -70,32 +70,32 @@ namespace __radsan {
 
 Context::Context() = default;
 
-void Context::RealtimePush() { RealtimeDepth++; }
+void Context::RealtimePush() { realtime_depth++; }
 
-void Context::RealtimePop() { RealtimeDepth--; }
+void Context::RealtimePop() { realtime_depth--; }
 
-void Context::BypassPush() { BypassDepth++; }
+void Context::BypassPush() { bypass_depth++; }
 
-void Context::BypassPop() { BypassDepth--; }
+void Context::BypassPop() { bypass_depth--; }
 
-void Context::ExpectNotRealtime(const char *InterceptedFunctionName) {
+void Context::ExpectNotRealtime(const char *intercepted_function_name) {
   if (InRealtimeContext() && !IsBypassed()) {
     BypassPush();
-    PrintDiagnostics(InterceptedFunctionName);
+    PrintDiagnostics(intercepted_function_name);
     detail::InvokeViolationDetectedAction();
     BypassPop();
   }
 }
 
-bool Context::InRealtimeContext() const { return RealtimeDepth > 0; }
+bool Context::InRealtimeContext() const { return realtime_depth > 0; }
 
-bool Context::IsBypassed() const { return BypassDepth > 0; }
+bool Context::IsBypassed() const { return bypass_depth > 0; }
 
-void Context::PrintDiagnostics(const char *InterceptedFunctionName) {
+void Context::PrintDiagnostics(const char *intercepted_function_name) {
   fprintf(stderr,
           "Real-time violation: intercepted call to real-time unsafe function "
           "`%s` in real-time context! Stack trace:\n",
-          InterceptedFunctionName);
+          intercepted_function_name);
   __radsan::PrintStackTrace();
 }
 
diff --git a/compiler-rt/lib/radsan/radsan_context.h b/compiler-rt/lib/radsan/radsan_context.h
@@ -22,15 +22,15 @@ class Context {
   void BypassPush();
   void BypassPop();
 
-  void ExpectNotRealtime(const char *InterceptedFunctionName);
+  void ExpectNotRealtime(const char *intercepted_function_name);
 
 private:
   bool InRealtimeContext() const;
   bool IsBypassed() const;
-  void PrintDiagnostics(const char *InterceptedFunctionName);
+  void PrintDiagnostics(const char *intercepted_function_name);
 
-  int RealtimeDepth{0};
-  int BypassDepth{0};
+  int realtime_depth{0};
+  int bypass_depth{0};
 };
 
 Context &GetContextForThisThread();
diff --git a/compiler-rt/lib/radsan/radsan_interceptors.cpp b/compiler-rt/lib/radsan/radsan_interceptors.cpp
@@ -41,8 +41,8 @@
 using namespace __sanitizer;
 
 namespace __radsan {
-void ExpectNotRealtime(const char *InterceptedFunctionName) {
-  GetContextForThisThread().ExpectNotRealtime(InterceptedFunctionName);
+void ExpectNotRealtime(const char *intercepted_function_name) {
+  GetContextForThisThread().ExpectNotRealtime(intercepted_function_name);
 }
 } // namespace __radsan
 
diff --git a/compiler-rt/lib/radsan/radsan_interceptors.h b/compiler-rt/lib/radsan/radsan_interceptors.h
@@ -13,4 +13,4 @@
 
 namespace __radsan {
 void InitializeInterceptors();
-}
+} // namespace __radsan
diff --git a/compiler-rt/lib/radsan/radsan_stack.cpp b/compiler-rt/lib/radsan/radsan_stack.cpp
@@ -43,11 +43,11 @@ void SetGlobalStackTraceFormat() {
 using namespace __radsan;
 void __radsan::PrintStackTrace() {
 
-  BufferedStackTrace Stack{};
+  BufferedStackTrace stack{};
 
   GET_CURRENT_PC_BP;
-  Stack.Unwind(pc, bp, nullptr, common_flags()->fast_unwind_on_fatal);
+  stack.Unwind(pc, bp, nullptr, common_flags()->fast_unwind_on_fatal);
 
   SetGlobalStackTraceFormat();
-  Stack.Print();
+  stack.Print();
 }
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_context.cpp b/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
@@ -13,58 +13,58 @@
 
 #include "radsan_context.h"
 
-TEST(TestRadsanContext, CanCreateContext) { __radsan::Context Context{}; }
+TEST(TestRadsanContext, CanCreateContext) { __radsan::Context context{}; }
 
 TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieBeforeRealtimePush) {
-  __radsan::Context Context{};
-  Context.ExpectNotRealtime("do_some_stuff");
+  __radsan::Context context{};
+  context.ExpectNotRealtime("do_some_stuff");
 }
 
 TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieAfterPushAndPop) {
-  __radsan::Context Context{};
-  Context.RealtimePush();
-  Context.RealtimePop();
-  Context.ExpectNotRealtime("do_some_stuff");
+  __radsan::Context context{};
+  context.RealtimePush();
+  context.RealtimePop();
+  context.ExpectNotRealtime("do_some_stuff");
 }
 
 TEST(TestRadsanContext, ExpectNotRealtimeDiesAfterRealtimePush) {
-  __radsan::Context Context{};
+  __radsan::Context context{};
 
-  Context.RealtimePush();
-  EXPECT_DEATH(Context.ExpectNotRealtime("do_some_stuff"), "");
+  context.RealtimePush();
+  EXPECT_DEATH(context.ExpectNotRealtime("do_some_stuff"), "");
 }
 
 TEST(TestRadsanContext,
      ExpectNotRealtimeDiesAfterRealtimeAfterMorePushesThanPops) {
-  __radsan::Context Context{};
+  __radsan::Context context{};
 
-  Context.RealtimePush();
-  Context.RealtimePush();
-  Context.RealtimePush();
-  Context.RealtimePop();
-  Context.RealtimePop();
-  EXPECT_DEATH(Context.ExpectNotRealtime("do_some_stuff"), "");
+  context.RealtimePush();
+  context.RealtimePush();
+  context.RealtimePush();
+  context.RealtimePop();
+  context.RealtimePop();
+  EXPECT_DEATH(context.ExpectNotRealtime("do_some_stuff"), "");
 }
 
 TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieAfterBypassPush) {
-  __radsan::Context Context{};
+  __radsan::Context context{};
 
-  Context.RealtimePush();
-  Context.BypassPush();
-  Context.ExpectNotRealtime("do_some_stuff");
+  context.RealtimePush();
+  context.BypassPush();
+  context.ExpectNotRealtime("do_some_stuff");
 }
 
 TEST(TestRadsanContext,
      ExpectNotRealtimeDoesNotDieIfBypassDepthIsGreaterThanZero) {
-  __radsan::Context Context{};
+  __radsan::Context context{};
 
-  Context.RealtimePush();
-  Context.BypassPush();
-  Context.BypassPush();
-  Context.BypassPush();
-  Context.BypassPop();
-  Context.BypassPop();
-  Context.ExpectNotRealtime("do_some_stuff");
-  Context.BypassPop();
-  EXPECT_DEATH(Context.ExpectNotRealtime("do_some_stuff"), "");
+  context.RealtimePush();
+  context.BypassPush();
+  context.BypassPush();
+  context.BypassPush();
+  context.BypassPop();
+  context.BypassPop();
+  context.ExpectNotRealtime("do_some_stuff");
+  context.BypassPop();
+  EXPECT_DEATH(context.ExpectNotRealtime("do_some_stuff"), "");
 }
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_functional.cpp b/compiler-rt/lib/radsan/tests/radsan_test_functional.cpp
@@ -41,21 +41,21 @@ using namespace radsan_testing;
 using namespace std::chrono_literals;
 
 TEST(TestRadsan, VectorPushBackAllocationDiesWhenRealtime) {
-  std::vector<float> Vec{};
-  auto Func = [&Vec]() { Vec.push_back(0.4f); };
+  std::vector<float> vec{};
+  auto Func = [&vec]() { vec.push_back(0.4f); };
   ExpectRealtimeDeath(Func);
-  ASSERT_EQ(0u, Vec.size());
+  ASSERT_EQ(0u, vec.size());
   ExpectNonRealtimeSurvival(Func);
-  ASSERT_EQ(1u, Vec.size());
+  ASSERT_EQ(1u, vec.size());
 }
 
 TEST(TestRadsan, DestructionOfObjectOnHeapDiesWhenRealtime) {
-  auto AllocatedPtr = std::make_unique<std::array<float, 256>>();
-  auto Func = [&AllocatedPtr]() { AllocatedPtr.reset(); };
+  auto allocated_ptr = std::make_unique<std::array<float, 256>>();
+  auto Func = [&allocated_ptr]() { allocated_ptr.reset(); };
   ExpectRealtimeDeath(Func);
-  ASSERT_NE(nullptr, AllocatedPtr.get());
+  ASSERT_NE(nullptr, allocated_ptr.get());
   ExpectNonRealtimeSurvival(Func);
-  ASSERT_EQ(nullptr, AllocatedPtr.get());
+  ASSERT_EQ(nullptr, allocated_ptr.get());
 }
 
 TEST(TestRadsan, SleepingAThreadDiesWhenRealtime) {
@@ -79,48 +79,48 @@ TEST(TestRadsan, OfstreamCreationDiesWhenRealtime) {
 }
 
 TEST(TestRadsan, LockingAMutexDiesWhenRealtime) {
-  std::mutex Mutex{};
-  auto Func = [&]() { Mutex.lock(); };
+  std::mutex mutex{};
+  auto Func = [&]() { mutex.lock(); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
 
 TEST(TestRadsan, UnlockingAMutexDiesWhenRealtime) {
-  std::mutex Mutex{};
-  Mutex.lock();
-  auto Func = [&]() { Mutex.unlock(); };
+  std::mutex mutex{};
+  mutex.lock();
+  auto Func = [&]() { mutex.unlock(); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
 
 #if RADSAN_TEST_SHARED_MUTEX
 
 TEST(TestRadsan, LockingASharedMutexDiesWhenRealtime) {
-  std::shared_mutex Mutex{};
-  auto Func = [&]() { Mutex.lock(); };
+  std::shared_mutex mutex{};
+  auto Func = [&]() { mutex.lock(); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
 
 TEST(TestRadsan, UnlockingASharedMutexDiesWhenRealtime) {
-  std::shared_mutex Mutex{};
-  Mutex.lock();
-  auto Func = [&]() { Mutex.unlock(); };
+  std::shared_mutex mutex{};
+  mutex.lock();
+  auto Func = [&]() { mutex.unlock(); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
 
 TEST(TestRadsan, SharedLockingASharedMutexDiesWhenRealtime) {
-  std::shared_mutex Mutex{};
-  auto Func = [&]() { Mutex.lock_shared(); };
+  std::shared_mutex mutex{};
+  auto Func = [&]() { mutex.lock_shared(); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
 
 TEST(TestRadsan, SharedUnlockingASharedMutexDiesWhenRealtime) {
-  std::shared_mutex Mutex{};
-  Mutex.lock_shared();
-  auto Func = [&]() { Mutex.unlock_shared(); };
+  std::shared_mutex mutex{};
+  mutex.lock_shared();
+  auto Func = [&]() { mutex.unlock_shared(); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
@@ -141,26 +141,26 @@ void InvokeStdFunction(std::function<void()> &&function) { function(); }
 } // namespace
 
 TEST(TestRadsan, CopyingALambdaWithLargeCaptureDiesWhenRealtime) {
-  std::array<float, 16> LotsOfData{};
-  auto lambda = [LotsOfData]() mutable {
+  std::array<float, 16> lots_of_data{};
+  auto lambda = [lots_of_data]() mutable {
     // Stop everything getting optimised out
-    LotsOfData[3] = 0.25f;
-    EXPECT_EQ(16, LotsOfData.size());
-    EXPECT_EQ(0.25f, LotsOfData[3]);
+    lots_of_data[3] = 0.25f;
+    EXPECT_EQ(16, lots_of_data.size());
+    EXPECT_EQ(0.25f, lots_of_data[3]);
   };
   auto Func = [&]() { InvokeStdFunction(lambda); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
 
 TEST(TestRadsan, AccessingALargeAtomicVariableDiesWhenRealtime) {
-  std::atomic<float> SmallAtomic{0.0f};
-  ASSERT_TRUE(SmallAtomic.is_lock_free());
-  RealtimeInvoke([&SmallAtomic]() { float x = SmallAtomic.load(); });
+  std::atomic<float> small_atomic{0.0f};
+  ASSERT_TRUE(small_atomic.is_lock_free());
+  RealtimeInvoke([&small_atomic]() { float x = small_atomic.load(); });
 
-  std::atomic<std::array<float, 2048>> LargeAtomic{};
-  ASSERT_FALSE(LargeAtomic.is_lock_free());
-  auto Func = [&]() { auto x = LargeAtomic.load(); };
+  std::atomic<std::array<float, 2048>> large_atomic{};
+  ASSERT_FALSE(large_atomic.is_lock_free());
+  auto Func = [&]() { auto x = large_atomic.load(); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
@@ -196,11 +196,11 @@ TEST(TestRadsan, ThrowingAnExceptionDiesWhenRealtime) {
 }
 
 TEST(TestRadsan, DoesNotDieIfTurnedOff) {
-  std::mutex Mutex{};
+  std::mutex mutex{};
   auto RealtimeUnsafeFunc = [&]() {
     __radsan_off();
-    Mutex.lock();
-    Mutex.unlock();
+    mutex.lock();
+    mutex.unlock();
     __radsan_on();
   };
   RealtimeInvoke(RealtimeUnsafeFunc);
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_utilities.h b/compiler-rt/lib/radsan/tests/radsan_test_utilities.h

Original file line number	Diff line number	Diff line change
`@@ -41,8 +41,8 @@`
`41`	`41`	`using namespace __sanitizer;`
`42`	`42`
`43`	`43`	`namespace __radsan {`
`44`		`-void ExpectNotRealtime(const char *InterceptedFunctionName) {`
`45`		`- GetContextForThisThread().ExpectNotRealtime(InterceptedFunctionName);`
	`44`	`+void ExpectNotRealtime(const char *intercepted_function_name) {`
	`45`	`+ GetContextForThisThread().ExpectNotRealtime(intercepted_function_name);`
`46`	`46`	`}`
`47`	`47`	`} // namespace __radsan`
`48`	`48`