Get more consistent decisions if a statement is constant in templates

tools/clang/rewrite_to_chrome_style/tests/template-original.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.
 
 #include <type_traits>
 
 namespace not_blink {
 
 void function(int x) {}
 
@@ skipping 18 matching lines @@
 template <typename T = Class>
 class TemplatedClass {
  public:
   void anotherMethod() { T::staticMethodTemplate(123); }
 };
 
 }  // not_blink
 
 namespace blink {
 
+bool functionNotMarkedConstexpr(int a) {
+  return a == 4 || a == 10;
+}
+
+template <typename T>
+bool templatedFunctionNotMarkedConstexpr(T t) {
+  return !!t;
+}
+
+int g_globalNumber;
+
 template <typename T, int number>
 void F() {
-  // We don't assert on this, and we don't end up considering it a const for
-  // now.
+  // These are const but hacker_case so we leave them alone.
   const int maybe_a_const = sizeof(T);
   const int is_a_const = number;
+  // These are const expressions so they get a k prefix.
+  const int maybeAConstToo = sizeof(T);
+  const int isAConstToo = number;
+  // These are built from calls to functions which produces inconsistent
+  // results so they should not be considered const to be safe.
+  const bool fromAMethod = functionNotMarkedConstexpr(number);
+  const bool fromATemplatedMethod = templatedFunctionNotMarkedConstexpr(number);
+  // A complex statement of const things is const.
+  const bool complexConst = number || (number + 1);
+  // A complex statement with a non-const thing is not const.
+  const bool complexNotConst = number || (g_globalNumber + 1);
 }
 
 template <int number, typename... T>
 void F() {
-  // We don't assert on this, and we don't end up considering it a const for
-  // now.
+  // These are const but hacker_case so we leave them alone.
   const int maybe_a_const = sizeof...(T);
   const int is_a_const = number;
+  // These are const expressions so they get a k prefix.
+  const int maybeAConstToo = sizeof...(T);
+  const int isAConstToo = number;
 }
 
 namespace test_template_arg_is_function {
 
 void f(int x) {}
 
 template <typename T, void g(T)>
 void h(T x) {
   g(x);
 }
 
 void test() {
   // f should be rewritten.
   h<int, f>(0);
   // Non-Blink should stay the same.
   h<int, not_blink::function>(1);
+
+  // The int one makes the methods called from F() considered as constexpr, and
+  // can be collapsed to not have template arguments before it reaches the AST.
+  F<int, 10>();
+  // The enum one makes them not constexpr, as it doesn't collapse away the
+  // template stuff as much. This can lead to conflicting decisions about
+  // the names inside F() vs the above instantiation.
+  enum E { A };
+  F<E, 11>();
 }
 
 }  // namespace test_template_arg_is_function
 
 namespace test_template_arg_is_method {
 
 class Class {
  public:
   void method() {}
 };
@@ skipping 223 matching lines @@
     // Need to rewrite |f| to |F| below (because this method name
     // does get rewritten when processing blink::test_unnamed_arg::Class).
     // See also https://crbug.com/670434.
     output->f(123);
   }
 };
 
 }  // namespace blink_methods_called_from_mojo_traits_are_not_rewritten
 
 }  // namespace not_blink