Work around VC++ /analyze internal compiler error

base/tuple.h

 // Copyright (c) 2011 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.
 
 // A Tuple is a generic templatized container, similar in concept to std::pair
 // and std::tuple.  The convenient MakeTuple() function takes any number of
 // arguments and will construct and return the appropriate Tuple object.  The
 // functions DispatchToMethod and DispatchToFunction take a function pointer or
 // instance and method pointer, and unpack a tuple into arguments to the call.
 //
@@ skipping 22 matching lines @@
 // Index sequences
 //
 // Minimal clone of the similarly-named C++14 functionality.
 
 template <size_t...>
 struct IndexSequence {};
 
 template <size_t... Ns>
 struct MakeIndexSequenceImpl;
 
+#if defined(_PREFAST_) && defined(OS_WIN)
+
+// Work around VC++ 2013 /analyze internal compiler error:
+// https://connect.microsoft.com/VisualStudio/feedback/details/1053626
+
+template <>
+struct IndexSequence<0> {};
+
+template <>
+struct IndexSequence<0,1> {};
+
+template <>
+struct IndexSequence<0,1,2> {};
+
+template <>
+struct IndexSequence<0,1,2,3> {};
+
+template <>
+struct IndexSequence<0,1,2,3,4> {};
+
+template <>
+struct MakeIndexSequenceImpl<0> {
+  using Type = IndexSequence<>;
+};
+
+template <>
+struct MakeIndexSequenceImpl<1> {
+  using Type = IndexSequence<0>;
+};
+
+template <>
+struct MakeIndexSequenceImpl<2> {
+  using Type = IndexSequence<0,1>;
+};
+
+template <>
+struct MakeIndexSequenceImpl<3> {
+  using Type = IndexSequence<0,1,2>;
+};
+
+template <>
+struct MakeIndexSequenceImpl<4> {
+  using Type = IndexSequence<0,1,2,3>;
+};
+
+template <>
+struct MakeIndexSequenceImpl<5> {
+  using Type = IndexSequence<0,1,2,3,4>;
+};
+
+#else
+
 template <size_t... Ns>
 struct MakeIndexSequenceImpl<0, Ns...> {
   using Type = IndexSequence<Ns...>;
 };
 
 template <size_t N, size_t... Ns>
 struct MakeIndexSequenceImpl<N, Ns...>

[mdempsky, 2014/12/15 22:17:55]

I previously wrote this as:

    template <size_t N, size_t... Ns>
    struct MakeIndexSequenceImpl<N, Ns...> {
      using Type = typename MakeIndexSequenceImpl<N - 1, N - 1, Ns...>::Type;
    };

but later changed it to use inheritance just to be a bit more concise.  Did the
old form have problems with /analyze too?  If not, we could just revert to that
maybe?

     : MakeIndexSequenceImpl<N - 1, N - 1, Ns...> {};
 
+#endif
+
 template <size_t N>
 using MakeIndexSequence = typename MakeIndexSequenceImpl<N>::Type;
 
 // Traits ----------------------------------------------------------------------
 //
 // A simple traits class for tuple arguments.
 //
 // ValueType: the bare, nonref version of a type (same as the type for nonrefs).
 // RefType: the ref version of a type (same as the type for refs).
 // ParamType: what type to pass to functions (refs should not be constified).
@@ skipping 274 matching lines @@
 inline void DispatchToMethod(ObjT* obj,
                              Method method,
                              const Tuple<InTs...>& in,
                              Tuple<OutTs...>* out) {
   DispatchToMethodImpl(obj, method, in, out,
                        MakeIndexSequence<sizeof...(InTs)>(),
                        MakeIndexSequence<sizeof...(OutTs)>());
 }
 
 #endif  // BASE_TUPLE_H__