Use universal references in templated analysis passthrough functions.

base/logging.h

 // Copyright (c) 2012 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.
 
 #ifndef BASE_LOGGING_H_
 #define BASE_LOGGING_H_
 
 #include <stddef.h>
 
 #include <cassert>
@@ skipping 280 matching lines @@
 
 // ANALYZER_ASSUME_TRUE(...) generates compiler-specific annotations which
 // prevent the static analyzer from analyzing the code using hypothetical
 // values that are asserted to be impossible.
 // The value of the condition passed to ANALYZER_ASSUME_TRUE() is returned
 // directly.
 #if defined(__clang_analyzer__)
 
 inline void AnalyzerNoReturn() __attribute__((analyzer_noreturn)) {}
 
+// A universal reference is used for compatibility with lvalue and rvalue
+// argument passing.
 template <typename TVal>
 inline constexpr TVal AnalysisAssumeTrue(TVal arg) {

[danakj, 2017/02/14 21:10:10]

dropped the && here

[Kevin M, 2017/02/14 22:07:48]

Done.

   if (!arg) {
     AnalyzerNoReturn();
   }
   return arg;
 }
 
 #define ANALYZER_ASSUME_TRUE(val) ::logging::AnalysisAssumeTrue(val)
 
 #elif defined(_PREFAST_) && defined(OS_WIN)
 
+// A universal reference is used for compatibility with lvalue and rvalue
+// argument passing.
 template <typename TVal>
-inline constexpr TVal AnalysisAssumeTrue(TVal arg) {
+inline constexpr TVal AnalysisAssumeTrue(TVal&& arg) {
   __analysis_assume(!!arg);
   return arg;
 }
 
 #define ANALYZER_ASSUME_TRUE(val) ::logging::AnalysisAssumeTrue(val)
 
 #else  // !_PREFAST_ & !__clang_analyzer__
 
 #define ANALYZER_ASSUME_TRUE(val) (val)
 
@@ skipping 296 matching lines @@
 std::string* MakeCheckOpString<unsigned int, unsigned long>(
     const unsigned int&, const unsigned long&, const char* names);
 extern template BASE_EXPORT
 std::string* MakeCheckOpString<std::string, std::string>(
     const std::string&, const std::string&, const char* name);
 
 // Helper functions for CHECK_OP macro.
 // The (int, int) specialization works around the issue that the compiler
 // will not instantiate the template version of the function on values of
 // unnamed enum type - see comment below.
-#define DEFINE_CHECK_OP_IMPL(name, op) \
-  template <class t1, class t2> \
-  inline std::string* Check##name##Impl(const t1& v1, const t2& v2, \
-                                        const char* names) { \
-    if (v1 op v2) return NULL; \
-    else return ::logging::MakeCheckOpString(v1, v2, names);    \
-  } \
+#define DEFINE_CHECK_OP_IMPL(name, op)                                       \
+  template <class t1, class t2>                                              \
+  inline std::string* Check##name##Impl(const t1& v1, const t2& v2,          \
+                                        const char* names) {                 \
+    if (ANALYZER_ASSUME_TRUE(v1 op v2))                                      \
+      return NULL;                                                           \
+    else                                                                     \
+      return ::logging::MakeCheckOpString(v1, v2, names);                    \
+  }                                                                          \
   inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \
-    if (v1 op v2) return NULL; \
-    else return ::logging::MakeCheckOpString(v1, v2, names);    \
+    if (ANALYZER_ASSUME_TRUE(v1 op v2))                                      \
+      return NULL;                                                           \
+    else                                                                     \
+      return ::logging::MakeCheckOpString(v1, v2, names);                    \
   }
 DEFINE_CHECK_OP_IMPL(EQ, ==)
 DEFINE_CHECK_OP_IMPL(NE, !=)
 DEFINE_CHECK_OP_IMPL(LE, <=)
 DEFINE_CHECK_OP_IMPL(LT, < )
 DEFINE_CHECK_OP_IMPL(GE, >=)
 DEFINE_CHECK_OP_IMPL(GT, > )
 #undef DEFINE_CHECK_OP_IMPL
 
 #define CHECK_EQ(val1, val2) CHECK_OP(EQ, ==, val1, val2)
@@ skipping 400 matching lines @@
 #elif NOTIMPLEMENTED_POLICY == 5
 #define NOTIMPLEMENTED() do {\
   static bool logged_once = false;\
   LOG_IF(ERROR, !logged_once) << NOTIMPLEMENTED_MSG;\
   logged_once = true;\
 } while(0);\
 EAT_STREAM_PARAMETERS
 #endif
 
 #endif  // BASE_LOGGING_H_