diff --git a/patches/type_traits_MSVC_12.patch b/patches/type_traits_MSVC_12.patch new file mode 100644 index 00000000..ed8be6ab --- /dev/null +++ b/patches/type_traits_MSVC_12.patch @@ -0,0 +1,255 @@ +Index: include/clang/Basic/TokenKinds.def +=================================================================== +--- include/clang/Basic/TokenKinds.def (revision 195759) ++++ include/clang/Basic/TokenKinds.def (working copy) +@@ -369,10 +369,15 @@ + KEYWORD(__is_abstract , KEYCXX) + KEYWORD(__is_base_of , KEYCXX) + KEYWORD(__is_class , KEYCXX) ++KEYWORD(__is_constructible , KEYCXX) + KEYWORD(__is_convertible_to , KEYCXX) ++KEYWORD(__is_destructible , KEYCXX) + KEYWORD(__is_empty , KEYCXX) + KEYWORD(__is_enum , KEYCXX) + KEYWORD(__is_final , KEYCXX) ++KEYWORD(__is_nothrow_assignable , KEYCXX) ++KEYWORD(__is_nothrow_constructible , KEYCXX) ++KEYWORD(__is_nothrow_destructible , KEYCXX) + // Tentative name - there's no implementation of std::is_literal_type yet. + KEYWORD(__is_literal , KEYCXX) + // Name for GCC 4.6 compatibility - people have already written libraries using +Index: include/clang/Basic/TypeTraits.h +=================================================================== +--- include/clang/Basic/TypeTraits.h (revision 195759) ++++ include/clang/Basic/TypeTraits.h (working copy) +@@ -37,6 +37,7 @@ + UTT_IsCompleteType, + UTT_IsCompound, + UTT_IsConst, ++ UTT_IsDestructible, + UTT_IsEmpty, + UTT_IsEnum, + UTT_IsFinal, +@@ -50,6 +51,7 @@ + UTT_IsMemberFunctionPointer, + UTT_IsMemberObjectPointer, + UTT_IsMemberPointer, ++ UTT_IsNothrowDestructible, + UTT_IsObject, + UTT_IsPOD, + UTT_IsPointer, +@@ -73,6 +75,7 @@ + BTT_IsBaseOf, + BTT_IsConvertible, + BTT_IsConvertibleTo, ++ BTT_IsNothrowAssignable, + BTT_IsSame, + BTT_TypeCompatible, + BTT_IsTriviallyAssignable +@@ -93,6 +96,8 @@ + + /// \brief Names for type traits that operate specifically on types. + enum TypeTrait { ++ TT_IsConstructible, ++ TT_IsNothrowConstructible, + TT_IsTriviallyConstructible + }; + +Index: lib/AST/StmtPrinter.cpp +=================================================================== +--- lib/AST/StmtPrinter.cpp (revision 195759) ++++ lib/AST/StmtPrinter.cpp (working copy) +@@ -1695,6 +1695,7 @@ + case UTT_IsCompleteType: return "__is_complete_type"; + case UTT_IsCompound: return "__is_compound"; + case UTT_IsConst: return "__is_const"; ++ case UTT_IsDestructible: return "__is_destructible"; + case UTT_IsEmpty: return "__is_empty"; + case UTT_IsEnum: return "__is_enum"; + case UTT_IsFinal: return "__is_final"; +@@ -1708,6 +1709,7 @@ + case UTT_IsMemberFunctionPointer: return "__is_member_function_pointer"; + case UTT_IsMemberObjectPointer: return "__is_member_object_pointer"; + case UTT_IsMemberPointer: return "__is_member_pointer"; ++ case UTT_IsNothrowDestructible: return "__is_nothrow_destructible"; + case UTT_IsObject: return "__is_object"; + case UTT_IsPOD: return "__is_pod"; + case UTT_IsPointer: return "__is_pointer"; +@@ -1735,6 +1737,7 @@ + case BTT_IsSame: return "__is_same"; + case BTT_TypeCompatible: return "__builtin_types_compatible_p"; + case BTT_IsConvertibleTo: return "__is_convertible_to"; ++ case BTT_IsNothrowAssignable: return "__is_nothrow_assignable"; + case BTT_IsTriviallyAssignable: return "__is_trivially_assignable"; + } + llvm_unreachable("Binary type trait not covered by switch"); +@@ -1742,6 +1745,8 @@ + + static const char *getTypeTraitName(TypeTrait TT) { + switch (TT) { ++ case clang::TT_IsConstructible: return "__is_constructible"; ++ case clang::TT_IsNothrowConstructible: return "__is_nothrow_constructible"; + case clang::TT_IsTriviallyConstructible:return "__is_trivially_constructible"; + } + llvm_unreachable("Type trait not covered by switch"); +Index: lib/Parse/ParseExpr.cpp +=================================================================== +--- lib/Parse/ParseExpr.cpp (revision 195759) ++++ lib/Parse/ParseExpr.cpp (working copy) +@@ -1205,6 +1205,8 @@ + case tok::kw___is_union: + case tok::kw___is_final: + case tok::kw___is_sealed: ++ case tok::kw___is_destructible: ++ case tok::kw___is_nothrow_destructible: + case tok::kw___has_trivial_constructor: + case tok::kw___has_trivial_move_constructor: + case tok::kw___has_trivial_copy: +@@ -1223,9 +1225,12 @@ + case tok::kw___is_same: + case tok::kw___is_convertible: + case tok::kw___is_convertible_to: ++ case tok::kw___is_nothrow_assignable: + case tok::kw___is_trivially_assignable: + return ParseBinaryTypeTrait(); + ++ case tok::kw___is_constructible: ++ case tok::kw___is_nothrow_constructible: + case tok::kw___is_trivially_constructible: + return ParseTypeTrait(); + +Index: lib/Parse/ParseExprCXX.cpp +=================================================================== +--- lib/Parse/ParseExprCXX.cpp (revision 195759) ++++ lib/Parse/ParseExprCXX.cpp (working copy) +@@ -2648,6 +2648,7 @@ + case tok::kw___is_complete_type: return UTT_IsCompleteType; + case tok::kw___is_compound: return UTT_IsCompound; + case tok::kw___is_const: return UTT_IsConst; ++ case tok::kw___is_destructible: return UTT_IsDestructible; + case tok::kw___is_empty: return UTT_IsEmpty; + case tok::kw___is_enum: return UTT_IsEnum; + case tok::kw___is_final: return UTT_IsFinal; +@@ -2660,6 +2661,7 @@ + case tok::kw___is_member_function_pointer: return UTT_IsMemberFunctionPointer; + case tok::kw___is_member_object_pointer: return UTT_IsMemberObjectPointer; + case tok::kw___is_member_pointer: return UTT_IsMemberPointer; ++ case tok::kw___is_nothrow_destructible: return UTT_IsNothrowDestructible; + case tok::kw___is_object: return UTT_IsObject; + case tok::kw___is_literal: return UTT_IsLiteral; + case tok::kw___is_literal_type: return UTT_IsLiteral; +@@ -2689,6 +2691,7 @@ + case tok::kw___is_same: return BTT_IsSame; + case tok::kw___builtin_types_compatible_p: return BTT_TypeCompatible; + case tok::kw___is_convertible_to: return BTT_IsConvertibleTo; ++ case tok::kw___is_nothrow_assignable: return BTT_IsNothrowAssignable; + case tok::kw___is_trivially_assignable: return BTT_IsTriviallyAssignable; + } + } +@@ -2696,6 +2699,10 @@ + static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind) { + switch (kind) { + default: llvm_unreachable("Not a known type trait"); ++ case tok::kw___is_constructible: ++ return TT_IsConstructible; ++ case tok::kw___is_nothrow_constructible: ++ return TT_IsNothrowConstructible; + case tok::kw___is_trivially_constructible: + return TT_IsTriviallyConstructible; + } +Index: lib/Sema/SemaExprCXX.cpp +=================================================================== +--- lib/Sema/SemaExprCXX.cpp (revision 195759) ++++ lib/Sema/SemaExprCXX.cpp (working copy) +@@ -3088,6 +3088,12 @@ + // these class templates. We also try to follow any GCC documented behavior + // in these expressions to ensure portability of standard libraries. + switch (UTT) { ++ case UTT_IsDestructible: ++ // TODO: stubbed ++ return true; ++ case UTT_IsNothrowDestructible: ++ // TODO: stubbed ++ return true; + // is_complete_type somewhat obviously cannot require a complete type. + case UTT_IsCompleteType: + // Fall-through +@@ -3219,6 +3225,12 @@ + + ASTContext &C = Self.Context; + switch(UTT) { ++ case UTT_IsDestructible: ++ // TODO: stubbed ++ return false; ++ case UTT_IsNothrowDestructible: ++ // TODO: stubbed ++ return false; + // Type trait expressions corresponding to the primary type category + // predicates in C++0x [meta.unary.cat]. + case UTT_IsVoid: +@@ -3610,6 +3622,14 @@ + ArrayRef Args, + SourceLocation RParenLoc) { + switch (Kind) { ++ case clang::TT_IsConstructible: { ++ // TODO: stubbed ++ return false; ++ } ++ case clang::TT_IsNothrowConstructible: { ++ // TODO: stubbed ++ return false; ++ } + case clang::TT_IsTriviallyConstructible: { + // C++11 [meta.unary.prop]: + // is_trivially_constructible is defined as: +@@ -3834,6 +3854,10 @@ + ExprResult Result = Init.Perform(Self, To, Kind, FromPtr); + return !Result.isInvalid() && !SFINAE.hasErrorOccurred(); + } ++ case BTT_IsNothrowAssignable: { ++ // TODO: stubbed ++ return false; ++ } + + case BTT_IsTriviallyAssignable: { + // C++11 [meta.unary.prop]p3: +@@ -3920,6 +3944,8 @@ + case BTT_IsSame: ResultType = Context.BoolTy; break; + case BTT_TypeCompatible: ResultType = Context.IntTy; break; + case BTT_IsConvertibleTo: ResultType = Context.BoolTy; break; ++ // TODO: stubbed ++ case BTT_IsNothrowAssignable: ResultType = Context.BoolTy; break; + case BTT_IsTriviallyAssignable: ResultType = Context.BoolTy; + } + +Index: test/SemaCXX/type-traits.cpp +=================================================================== +--- test/SemaCXX/type-traits.cpp (revision 195759) ++++ test/SemaCXX/type-traits.cpp (working copy) +@@ -1594,7 +1594,26 @@ + { int arr[F(__has_virtual_destructor(AllPrivate))]; } + } + ++void is_constructible() { ++ // TODO: stubbed ++} + ++void is_destructible() { ++ // TODO: stubbed ++} ++ ++void is_nothrow_assignable() { ++ // TODO: stubbed ++} ++ ++void is_nothrow_constructible() { ++ // TODO: stubbed ++} ++ ++void is_nothrow_destructible() { ++ // TODO: stubbed ++} ++ + class Base {}; + class Derived : Base {}; + class Derived2a : Derived {};