Support rewriting |to##macroArg()| into |To##macroArg()|.

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

 // 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.
 
 // Identifiers in macros should never be rewritten, as the risk of things

[dcheng, 2016/12/22 11:35:04]

Let's update this comment =)

[Łukasz Anforowicz, 2016/12/22 17:59:30]

Ooops :-)  Done (I've just removed the comment - it wasn't accurate to begin
with and after this CL will be even less useful).

 // breaking is extremely high.
 
 #define DEFINE_TYPE_CASTS(thisType, argumentType, argumentName, predicate) \
-  inline thisType* to##thisType(argumentType* argumentName) {              \
+  inline thisType* To##thisType(argumentType* argumentName) {              \
     if (!predicate)                                                        \
       asm("int 3");                                                        \
     return static_cast<thisType*>(argumentName);                           \
   }                                                                        \
   inline long long ToInt(argumentType* argumentName) {                     \
     return reinterpret_cast<long long>(argumentName);                      \
   }
 
 #define LIKELY(x) x
 
 namespace blink {
 
 struct Base {};
 struct Derived : public Base {};
 
 DEFINE_TYPE_CASTS(Derived, Base, object, true);
 
 void F() {
   Base* base_ptr = new Derived;
-  // 'toDerived' should not be renamed, since the definition lives inside
-  // a macro invocation.
-  Derived* derived_ptr = toDerived(base_ptr);
+  Derived* derived_ptr = ToDerived(base_ptr);
   long long as_int = ToInt(base_ptr);
   // 'derivedPtr' should be renamed: it's a reference to a declaration defined
   // outside a macro invocation.
   if (LIKELY(derived_ptr)) {
     delete derived_ptr;
   }
 }
 
 #define CALL_METHOD_FROM_MACRO()           \
   void CallMethodFromMacro() { Method(); } \
   void Pmethod() override {}
 
 struct WithMacroP {
   virtual void Pmethod() {}
 };
 
 struct WithMacro : public WithMacroP {
   void Method() {}
   CALL_METHOD_FROM_MACRO();
 };
 
+#define DEFINE_WITH_TOKEN_CONCATENATION2(arg1, arg2) \
+  void arg1##arg2() {}
+// We definitely don't want to rewrite |arg1| on the previous line into
+// either |Arg1| or |Frg1| or |Brg1| or |Foo| or |Baz|.
+
+// We might or might not want to rewrite |foo|->|Foo| and |baz|->|Baz| below.
+// The test below just spells out the current behavior of the tool (which one
+// can argue is accidental).
+DEFINE_WITH_TOKEN_CONCATENATION2(foo, Bar1)
+DEFINE_WITH_TOKEN_CONCATENATION2(baz, Bar2)
+
+void TokenConcatenationTest2() {
+  // We might or might not want to rewrite |foo|->|Foo| and |baz|->|Baz| below.
+  // The test below just spells out the current behavior of the tool (which one
+  // can argue is accidental).
+  FooBar1();
+  BazBar2();
+}
+
 }  // namespace blink