Remove invalid std::is_pod specializations from s2

# Conflicts:
#	CHANGELOG.md

Author: tgoyne

src/external/s2/base/macros.h

@@ -133,62 +133,13 @@ char (&ArraySizeHelper(const T (&array)[N]))[N];
 #define AS_STRING(x)   AS_STRING_INTERNAL(x)
 #define AS_STRING_INTERNAL(x)   #x
 
-
-// One of the type traits, is_pod, makes it possible to query whether
-// a type is a POD type. It is impossible for type_traits.h to get
-// this right without compiler support, so it fails conservatively. It
-// knows that fundamental types and pointers are PODs, but it can't
-// tell whether user classes are PODs. The DECLARE_POD macro is used
-// to inform the type traits library that a user class is a POD.
-//
-// Implementation note: the typedef at the end is just to make it legal
-// to put a semicolon after DECLARE_POD(foo).
-//
-// The only reason this matters is that a few parts of the google3
-// code base either require their template arguments to be PODs
-// (e.g. compact_vector) or are able to use a more efficient code path
-// when their template arguments are PODs (e.g. sparse_hash_map). You
-// should use DECLARE_POD if you have written a class that you intend
-// to use with one of those components, and if you know that your
-// class satisfies all of the conditions to be a POD type.
-//
-// So what's a POD?  The C++ standard (clause 9 paragraph 4) gives a
-// full definition, but a good rule of thumb is that a struct is a POD
-// ("plain old data") if it doesn't use any of the features that make
-// C++ different from C.  A POD struct can't have constructors,
-// destructors, assignment operators, base classes, private or
-// protected members, or virtual functions, and all of its member
-// variables must themselves be PODs.
-
-#define DECLARE_POD(TypeName)                       \
-namespace std {                                    \
-template<> struct is_pod<TypeName> : true_type { }; \
-}                                                   \
-typedef int Dummy_Type_For_DECLARE_POD              \
-
-// We once needed a different technique to assert that a nested class
-// is a POD. This is no longer necessary, and DECLARE_NESTED_POD is
-// just a synonym for DECLARE_POD. We continue to provide
-// DECLARE_NESTED_POD only so we don't have to change client
-// code. Regardless of whether you use DECLARE_POD or
-// DECLARE_NESTED_POD: use it after the outer class. Using it within a
-// class definition will give a compiler error.
+// These macros are a mess of undefined behavior that specialize std::is_pod to
+// pretend that non-POD types are POD, which is both invalid and would do very
+// broken things. Fortunately s2 internally does not actually rely on this and
+// we can make them no-ops.
+#define DECLARE_POD(TypeName)
 #define DECLARE_NESTED_POD(TypeName) DECLARE_POD(TypeName)
-
-// Declare that TemplateName<T> is a POD whenever T is
-#define PROPAGATE_POD_FROM_TEMPLATE_ARGUMENT(TemplateName)             \
-namespace std {                                                       \
-template <typename T> struct is_pod<TemplateName<T> > : std::is_trivial<T> { }; \
-}                                                                      \
-typedef int Dummy_Type_For_PROPAGATE_POD_FROM_TEMPLATE_ARGUMENT
-
-// Macro that does nothing if TypeName is a POD, and gives a compiler
-// error if TypeName is a non-POD.  You should put a descriptive
-// comment right next to the macro call so that people can tell what
-// the compiler error is about.
-//
-// Implementation note: this works by taking the size of a type that's
-// complete when TypeName is a POD and incomplete otherwise.
+#define PROPAGATE_POD_FROM_TEMPLATE_ARGUMENT(TemplateName)
 
 template <bool IsPod> struct ERROR_TYPE_MUST_BE_POD;
 template <> struct ERROR_TYPE_MUST_BE_POD<true> { };