[LLD] Fix Clang-tidy modernize-use-nullptr warnings in include/lld/Core/range.h; other minor fixes

[Eugene.Zelenko]

Summary

I checked this patch on my own build on RHEL 6. Regressions were OK.

[ruiu]

LGTM

lld/trunk/include/lld/Core/range.h

 #include <string>
 #include <type_traits>
 #include <utility>
 #include <vector>
 
 namespace lld {
 // Nothing in this namespace is part of the exported interface.
 namespace detail {
+
 using std::begin;
 using std::end;
+
 /// Used as the result type of undefined functions.
 struct undefined {};
 
 template <typename R> class begin_result {
   template <typename T> static auto check(T &&t) -> decltype(begin(t));
   static undefined check(...);
 public:
   typedef decltype(check(std::declval<R>())) type;
public:
   /// an lvalue.  Another option would be to insist that rvalue
   /// arguments to range() must have const begin() and end() methods.
   template <typename R> LLVM_CONSTEXPR range(
       R &&r,
       typename std::enable_if<
         !std::is_pointer<Iterator>::value &&
         detail::is_range<R>::value &&
         std::is_convertible<typename detail::begin_result<R>::type,
-                            Iterator>::value>::type* = 0)
+                            Iterator>::value>::type* = nullptr)
       : begin_(detail::adl_begin(r)), end_(detail::adl_end(r)) {}
 
   /// This constructor creates a \c range<T*> from any range with
   /// contiguous iterators. Because dereferencing a past-the-end
   /// iterator can be undefined behavior, empty ranges get initialized
   /// with \c nullptr rather than \c &*begin().
   ///
   /// \par Participates in overload resolution if:
template <typename R> LLVM_CONSTEXPR range(
         std::is_pointer<Iterator>::value &&
         detail::is_contiguous_range<R>::value
       // MSVC returns false for this in this context, but not if we lift it out of the
       // constructor.
 #ifndef _MSC_VER
         && detail::conversion_preserves_array_indexing<
              decltype(&*detail::adl_begin(r)), Iterator>::value
 #endif
-      >::type* = 0)
+      >::type* = nullptr)
       : begin_((detail::adl_begin(r) == detail::adl_end(r) &&
                 !std::is_pointer<decltype(detail::adl_begin(r))>::value)
                // For non-pointers, &*begin(r) is only defined behavior
                // if there's an element there.  Otherwise, use nullptr
                // since the user can't dereference it anyway.  This _is_
                // detectable.
                ? nullptr : &*detail::adl_begin(r)),
         end_(begin_ + (detail::adl_end(r) - detail::adl_begin(r))) {}

 LLVM_CONSTEXPR range<Iterator> make_range(Iterator begin, Iterator end) {
   return range<Iterator>(begin, end);
 }
 
 /// \par Participates in overload resolution if:
 /// \c begin(r) and \c end(r) return the same type.
 template <typename Range> LLVM_CONSTEXPR auto make_range(
     Range &&r,
-    typename std::enable_if<detail::is_range<Range>::value>::type* = 0)
+    typename std::enable_if<detail::is_range<Range>::value>::type* = nullptr)
     -> range<decltype(detail::adl_begin(r))> {
   return range<decltype(detail::adl_begin(r))>(r);
 }
 
 /// \par Participates in overload resolution if:
 ///   - \c begin(r) and \c end(r) return the same type,
 ///   -  that type satisfies the invariant that <code>&*(i + N) ==
 ///      (&*i) + N</code>, and
 ///   - \c &*begin(r) has a pointer type.
 template <typename Range> LLVM_CONSTEXPR auto make_ptr_range(
     Range &&r,
     typename std::enable_if<
       detail::is_contiguous_range<Range>::value &&
-      std::is_pointer<decltype(&*detail::adl_begin(r))>::value>::type* = 0)
-      -> range<decltype(&*detail::adl_begin(r))> {
+      std::is_pointer<decltype(&*detail::adl_begin(r))>::value>::type* =
+      nullptr) -> range<decltype(&*detail::adl_begin(r))> {
   return range<decltype(&*detail::adl_begin(r))>(r);
 }
 /// @}
 } // end namespace lld
 
-#endif
+#endif // LLD_CORE_RANGE_H