Fix __is_fundamental to accept nullptr_t

[zoecarver]

Summary

This patch updates the __is_fundamental builtin type trait to return true for nullptr_t.

[zoecarver]

Resolved by rL372624.

clang/include/clang/AST/Type.h

return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
           getTypePtr()->isFunctionType());
 }
 
 /// Tests whether the type is categorized as a fundamental type.
 ///
 /// \returns True for types specified in C++0x [basic.fundamental].
 inline bool Type::isFundamentalType() const {
   return isVoidType() ||
+         isNullPtrType() ||
          // FIXME: It's really annoying that we don't have an
          // 'isArithmeticType()' which agrees with the standard definition.
          (isArithmeticType() && !isEnumeralType());
 }
 
 /// Tests whether the type is categorized as a compound type.
 ///
 /// \returns True for types specified in C++0x [basic.compound].

clang/test/SemaCXX/type-traits.cpp

 struct DerivesEmpty : Empty {};
 struct HasCons { HasCons(int); };
 struct HasDefaultCons { HasDefaultCons() = default; };
 struct HasExplicitDefaultCons { explicit HasExplicitDefaultCons() = default; };
 struct HasInheritedCons : HasDefaultCons { using HasDefaultCons::HasDefaultCons; };
 struct HasNoInheritedCons : HasCons {};
 struct HasCopyAssign { HasCopyAssign operator =(const HasCopyAssign&); };
 struct HasMoveAssign { HasMoveAssign operator =(const HasMoveAssign&&); };
-struct HasNoThrowMoveAssign { 
+struct HasNoThrowMoveAssign {
   HasNoThrowMoveAssign& operator=(
     const HasNoThrowMoveAssign&&) throw(); };
-struct HasNoExceptNoThrowMoveAssign { 
+struct HasNoExceptNoThrowMoveAssign {
   HasNoExceptNoThrowMoveAssign& operator=(
-    const HasNoExceptNoThrowMoveAssign&&) noexcept; 
+    const HasNoExceptNoThrowMoveAssign&&) noexcept;
 };
-struct HasThrowMoveAssign { 
+struct HasThrowMoveAssign {
   HasThrowMoveAssign& operator=(const HasThrowMoveAssign&&)
 #if __cplusplus <= 201402L
   throw(POD);
 #else
   noexcept(false);
 #endif
 };
 
 
-struct HasNoExceptFalseMoveAssign { 
+struct HasNoExceptFalseMoveAssign {
   HasNoExceptFalseMoveAssign& operator=(
     const HasNoExceptFalseMoveAssign&&) noexcept(false); };
 struct HasMoveCtor { HasMoveCtor(const HasMoveCtor&&); };
 struct HasMemberMoveCtor { HasMoveCtor member; };
 struct HasMemberMoveAssign { HasMoveAssign member; };
 struct HasStaticMemberMoveCtor { static HasMoveCtor member; };
 struct HasStaticMemberMoveAssign { static HasMoveAssign member; };
 struct HasMemberThrowMoveAssign { HasThrowMoveAssign member; };
-struct HasMemberNoExceptFalseMoveAssign { 
+struct HasMemberNoExceptFalseMoveAssign {
   HasNoExceptFalseMoveAssign member; };
 struct HasMemberNoThrowMoveAssign { HasNoThrowMoveAssign member; };
-struct HasMemberNoExceptNoThrowMoveAssign { 
+struct HasMemberNoExceptNoThrowMoveAssign {
   HasNoExceptNoThrowMoveAssign member; };
 
-struct HasDefaultTrivialCopyAssign { 
+struct HasDefaultTrivialCopyAssign {
   HasDefaultTrivialCopyAssign &operator=(
-    const HasDefaultTrivialCopyAssign&) = default; 
+    const HasDefaultTrivialCopyAssign&) = default;
 };
-struct TrivialMoveButNotCopy { 
+struct TrivialMoveButNotCopy {
   TrivialMoveButNotCopy &operator=(TrivialMoveButNotCopy&&) = default;
   TrivialMoveButNotCopy &operator=(const TrivialMoveButNotCopy&);
 };
 struct NonTrivialDefault {
   NonTrivialDefault();
 };
 
 struct HasDest { ~HasDest(); };
void is_enum()
   { int arr[F(__is_enum(cvoid))]; }
   { int arr[F(__is_enum(IntArNB))]; }
   { int arr[F(__is_enum(HasAnonymousUnion))]; }
 }
 
 struct FinalClass final {
 };
 
-template<typename T> 
+template<typename T>
 struct PotentiallyFinal { };
 
 template<typename T>
 struct PotentiallyFinal<T*> final { };
 
 template<>
 struct PotentiallyFinal<int> final { };
 
void is_fundamental()
   int t18[T(__is_fundamental(short))];
   int t19[T(__is_fundamental(unsigned short))];
   int t20[T(__is_fundamental(int))];
   int t21[T(__is_fundamental(unsigned int))];
   int t22[T(__is_fundamental(long))];
   int t23[T(__is_fundamental(unsigned long))];
   int t24[T(__is_fundamental(void))];
   int t25[T(__is_fundamental(cvoid))];
+  int t26[T(__is_fundamental(decltype(nullptr)))];
 
   int t30[F(__is_fundamental(Union))];
   int t31[F(__is_fundamental(UnionAr))];
   int t32[F(__is_fundamental(Derives))];
   int t33[F(__is_fundamental(ClassType))];
   int t34[F(__is_fundamental(Enum))];
   int t35[F(__is_fundamental(IntArNB))];
 }

 
 void is_convertible_to();
 class PrivateCopy {
   PrivateCopy(const PrivateCopy&);
   friend void is_convertible_to();
 };
 
 template<typename T>
-struct X0 { 
+struct X0 {
   template<typename U> X0(const X0<U>&);
 };
 
 struct Abstract { virtual void f() = 0; };
 
 void is_convertible_to() {
   { int arr[T(__is_convertible_to(Int, Int))]; }
   { int arr[F(__is_convertible_to(Int, IntAr))]; }

 struct NotUniqueBecauseTailPadding {
   int &r;
   char a;
 };
 struct CanBeUniqueIfNoPadding : NotUniqueBecauseTailPadding {
   char b[7];
 };
 
-static_assert(!has_unique_object_representations<NotUniqueBecauseTailPadding>::value, 
+static_assert(!has_unique_object_representations<NotUniqueBecauseTailPadding>::value,
               "non trivial");
 // Can be unique on Itanium, since the is child class' data is 'folded' into the
 // parent's tail padding.
 static_assert(sizeof(CanBeUniqueIfNoPadding) != 16 ||
               has_unique_object_representations<CanBeUniqueIfNoPadding>::value,
               "inherit from std layout");
 
 namespace ErrorType {
   struct S; //expected-note{{forward declaration of 'ErrorType::S'}}
 
   struct T {
         S t; //expected-error{{field has incomplete type 'ErrorType::S'}}
   };
   bool b = __has_unique_object_representations(T);
 };