Clean up rewrite_to_chrome_style naming logic.

tools/clang/rewrite_to_chrome_style/Renamer.cpp

Index: tools/clang/rewrite_to_chrome_style/Renamer.cpp
diff --git a/tools/clang/rewrite_to_chrome_style/Renamer.cpp b/tools/clang/rewrite_to_chrome_style/Renamer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..26e00147720eb500fed184f17e1704d2b8e37f34
--- /dev/null
+++ b/tools/clang/rewrite_to_chrome_style/Renamer.cpp
@@ -0,0 +1,103 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "Renamer.h"
+
+#include <assert.h>
+
+#include "clang/Basic/CharInfo.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace {
+
+using WordList = llvm::SmallVector<llvm::StringRef, 6>;
+
+WordList SplitIdentifier(llvm::StringRef input) {
+  assert(input.size() > 0);
+
+  WordList output;
+  for (size_t i = 0; i < input.size(); ) {
+    size_t start = i;
+    size_t end = input.size();
+    bool was_lowercase = clang::isLowercase(input[start]);
+    bool was_uppercase = clang::isUppercase(input[start]);
+    bool in_acronym = false;
+
+    // Find the next "meaningful" uppercase letter or underscore.
+    for (++i; i < input.size(); ++i) {
+
+      // Underscore case: assume underscores always separate two words.
+      if (input[i] == '_') {
+        end = i;
+        ++i;  // Skip the underscore.
+        break;
+      }
+
+      bool is_lowercase = clang::isLowercase(input[i]);
+      bool is_uppercase = clang::isUppercase(input[i]);
+      // Non-acronym case: the next uppercase letter is the beginning of the
+      // next word.
+      if (was_lowercase && is_uppercase) {

[danakj, 2016/01/26 21:32:10]

What about V8Stuff?

8 won't be uppercase or lowercase right? But Stuff is a new word. So easiest is
probably to treat numbers as lowercase?

Or else here do !was_uppercase && is_uppercase?

Having 2 bools for upper/lower but then not handling the both-false case seems
off.

[dcheng, 2016/01/27 00:09:28]

I made a small tweak so this gets handled correctly now (and added some test
cases).

I don't think we necessarily want to treat numbers as lowercase: this means
acronyms with numbers embedded in the middle might get split into two parts.
However, I did a search for acronyms of this type and found that they were only
present in THINGS_NAM3D_LIKE_THIS. So I added a fallback path for the simple
splitting case to just use underscores.

Of course, to make things more complicated, there are identifiers like:
- calculateStringHashAndLengthFromUTF8MaskingTop8Bits
- enableUnsafeES3APIs

I added these to the test set.

+        end = i;
+        break;
+      }
+      // End of ACRONYM case:
+      if (in_acronym && was_uppercase && is_lowercase) {
+        --i;  // Already iterated into the next word, so backtrack.

[danakj, 2016/01/26 21:32:10]

Should it in_acronym = false?

[dcheng, 2016/01/27 00:09:28]

This is scoped to the body of the outermost for loop, so it automatically gets
reset at the next iteration.

+        end = i;
+        break;
+      }
+      // Seeing two consecutive uppercase letters indicates that this is
+      // probably part of an acronym.

[danakj, 2016/01/26 21:32:10]

Heh, except AThing. I wonder if that happens..

It does:
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

[dcheng, 2016/01/27 00:09:28]

This is OK though: we'll mark this as being in an acronym, then we hit the
lowercase letter on the next iteration of the loop. Since we backtrack, this
will clip it the word to one letter. I'll add an explicit test case though.

+      if (was_uppercase && is_uppercase) {
+        in_acronym = true;
+        // Intentionally fallthrough, so casing state is updated.
+      }
+
+      was_lowercase = is_lowercase;
+      was_uppercase = is_uppercase;
+    }
+    // TODO(dcheng): Special acronym handling here.
+    output.emplace_back(input.substr(start, end - start));
+  }
+
+  return output;
+}
+
+}  // namespace
+
+std::string IdentifierToCamelCase(llvm::StringRef input) {
+  WordList words = SplitIdentifier(input);
+  std::string output;
+  for (const auto& word : words) {
+    output += clang::toUppercase(word[0]);
+    for (size_t i = 1; i < word.size(); ++i)
+      output += clang::toLowercase(word[i]);
+  }
+  return output;
+}
+
+std::string IdentifierToUnderscoreCase(llvm::StringRef input) {
+  WordList words = SplitIdentifier(input);
+  std::string output;
+  for (const auto& word : words) {
+    if (!output.empty())
+      output += '_';
+    for (size_t i = 0; i < word.size(); ++i)
+      output += clang::toLowercase(word[i]);
+  }
+  return output;
+}
+
+std::string identifierToShoutyCase(llvm::StringRef input) {
+  WordList words = SplitIdentifier(input);
+  std::string output;
+  for (const auto& word : words) {
+    if (!output.empty())
+      output += '_';
+    for (size_t i = 0; i < word.size(); ++i)
+      output += clang::toUppercase(word[i]);
+  }
+  return output;
+}