rewrite_to_chrome_style: Improve naming of iterator and type traits.

tools/clang/rewrite_to_chrome_style/tests/methods-expected.cc

 // Copyright 2015 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.
 
 namespace blink {
 
+class MyIterator {};
+using my_iterator = MyIterator;

[dcheng, 2016/03/02 00:35:19]

I think the problem case I was considering is if you have something like:

using my_iterator = char*;

[dcheng, 2016/03/02 00:37:00]

Or perhaps something like this:

template<typename T>
class Vector {
  using iterator = T*;
  iterator begin();
  iterator end();
};

+
 class Task {
  public:
   // Already style-compliant methods shouldn't change.
   void OutputDebugString() {}
 
   // Tests that the declarations for methods are updated.
   void DoTheWork();
   // Overload to test using declarations that introduce multiple shadow
   // declarations.
   void DoTheWork(int);
   virtual void ReallyDoTheWork() = 0;
 
   // Note: this is purposely copyable and assignable, to make sure the Clang
   // tool doesn't try to emit replacements for things that aren't explicitly
   // written.
 
   // Overloaded operators should not be rewritten.
   Task& operator++() { return *this; }
 
   // Conversion functions should not be rewritten.
   explicit operator int() const { return 42; }
 
   // These are special functions that we don't rename so that range-based
   // for loops and STL things work.
-  void begin() {}
-  void end() {}
-  void rbegin() {}
-  void rend() {}
+  MyIterator begin() {}
+  my_iterator end() {}
+  my_iterator rbegin() {}
+  MyIterator rend() {}
   // The trace() method is used by Oilpan, we shouldn't rename it.
   void trace() {}
   // These are used by std::unique_lock and std::lock_guard.
   void lock() {}
   void unlock() {}
   void try_lock() {}
 };
 
 class Other {
   // Static begin/end/trace don't count, and should be renamed.
-  static void Begin() {}
-  static void End() {}
+  static MyIterator Begin() {}
+  static my_iterator End() {}
   static void Trace() {}
   static void Lock() {}
 };
 
+class NonIterators {
+  // begin()/end() and friends are renamed if they don't return an iterator.
+  void Begin() {}
+  int End() { return 0; }
+  void Rbegin() {}
+  int Rend() { return 0; }
+};
+
 // Test that the actual method definition is also updated.
 void Task::DoTheWork() {
   ReallyDoTheWork();
 }
 
 }  // namespace blink
 
 // Test that overrides from outside the Blink namespace are also updated.
 class BovineTask : public blink::Task {
  public:
@@ skipping 12 matching lines @@
   ReallyDoTheWork();
 }
 
 // Finally, test that method pointers are also updated.
 void F() {
   void (blink::Task::*p1)() = &blink::Task::DoTheWork;
   void (blink::Task::*p2)() = &BovineTask::DoTheWork;
   void (blink::Task::*p3)() = &blink::Task::ReallyDoTheWork;
   void (BovineTask::*p4)() = &BovineTask::ReallyDoTheWork;
 }
+
+namespace blink {
+
+struct StructInBlink {
+  // Structs in blink should rename their methods to capitals.
+  bool Function() { return true; }
+};
+
+}  // namespace blink
+
+namespace WTF {
+
+struct StructInWTF {
+  // Structs in WTF should rename their methods to capitals.
+  bool Function() { return true; }
+};
+
+}  // namespace WTF
+
+void F2() {
+  blink::StructInBlink b;
+  b.Function();
+  WTF::StructInWTF w;
+  w.Function();
+}