From 0e869433eb6182be9f12d98632f48bc75084df71 Mon Sep 17 00:00:00 2001 From: Alp Toker Date: Thu, 12 Dec 2013 21:23:03 +0000 Subject: [PATCH] Unify type trait parsing Type trait parsing is all over the place at the moment with unary, binary and n-ary C++11 type traits that were developed independently at different points in clang's history. There's no good reason to handle them separately -- there are three parsers, three AST nodes and lots of duplicated handling code with slightly different implementations and diags for each kind. This commit unifies parsing of type traits and sets the stage for further consolidation. No change in behaviour other than more consistent error recovery. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@197179 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/Basic/DiagnosticParseKinds.td | 5 + include/clang/Basic/DiagnosticSemaKinds.td | 3 - include/clang/Basic/TokenKinds.def | 128 ++++++++------- include/clang/Parse/Parser.h | 4 +- lib/AST/StmtPrinter.cpp | 63 ++------ lib/Parse/ParseExpr.cpp | 62 +------ lib/Parse/ParseExprCXX.cpp | 170 ++++++-------------- lib/Parse/ParseTentative.cpp | 30 +--- lib/Sema/SemaExprCXX.cpp | 6 +- 9 files changed, 141 insertions(+), 330 deletions(-) diff --git a/include/clang/Basic/DiagnosticParseKinds.td b/include/clang/Basic/DiagnosticParseKinds.td index 4339fbe8e5..0aa2f32481 100644 --- a/include/clang/Basic/DiagnosticParseKinds.td +++ b/include/clang/Basic/DiagnosticParseKinds.td @@ -777,6 +777,11 @@ def warn_availability_and_unavailable : Warning< def err_type_safety_unknown_flag : Error< "invalid comparison flag %0; use 'layout_compatible' or 'must_be_null'">; +// Type traits +def err_type_trait_arity : Error< + "type trait requires %0%select{| or more}1 argument%select{|s}2; have " + "%3 argument%s3">; + // Language specific pragmas // - Generic warnings def warn_pragma_expected_lparen : Warning< diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td index 031454337b..741d4c6e27 100644 --- a/include/clang/Basic/DiagnosticSemaKinds.td +++ b/include/clang/Basic/DiagnosticSemaKinds.td @@ -5750,9 +5750,6 @@ def note_inequality_comparison_to_or_assign : Note< def err_incomplete_type_used_in_type_trait_expr : Error< "incomplete type %0 used in type trait expression">; -def err_type_trait_arity : Error< - "type trait requires %0%select{| or more}1 argument%select{|s}2; have " - "%3 argument%s3">; def err_dimension_expr_not_constant_integer : Error< "dimension expression does not evaluate to a constant unsigned int">; diff --git a/include/clang/Basic/TokenKinds.def b/include/clang/Basic/TokenKinds.def index 90d3370c64..faafdba7b7 100644 --- a/include/clang/Basic/TokenKinds.def +++ b/include/clang/Basic/TokenKinds.def @@ -23,6 +23,18 @@ #ifndef KEYWORD #define KEYWORD(X,Y) TOK(kw_ ## X) #endif +#ifndef TYPE_TRAIT +#define TYPE_TRAIT(N,I,K) KEYWORD(I,K) +#endif +#ifndef TYPE_TRAIT_1 +#define TYPE_TRAIT_1(I,E,K) TYPE_TRAIT(1,I,K) +#endif +#ifndef TYPE_TRAIT_2 +#define TYPE_TRAIT_2(I,E,K) TYPE_TRAIT(2,I,K) +#endif +#ifndef TYPE_TRAIT_N +#define TYPE_TRAIT_N(I,E,K) TYPE_TRAIT(0,I,K) +#endif #ifndef ALIAS #define ALIAS(X,Y,Z) #endif @@ -334,7 +346,9 @@ KEYWORD(__alignof , KEYALL) KEYWORD(__attribute , KEYALL) KEYWORD(__builtin_choose_expr , KEYALL) KEYWORD(__builtin_offsetof , KEYALL) -KEYWORD(__builtin_types_compatible_p, KEYALL) +// __builtin_types_compatible_p is a GNU C extension that we handle like a C++ +// type trait. +TYPE_TRAIT_2(__builtin_types_compatible_p, TypeCompatible, KEYALL) KEYWORD(__builtin_va_arg , KEYALL) KEYWORD(__extension__ , KEYALL) KEYWORD(__imag , KEYALL) @@ -351,42 +365,42 @@ KEYWORD(typeof , KEYGNU) // MS Extensions KEYWORD(__FUNCDNAME__ , KEYMS) KEYWORD(L__FUNCTION__ , KEYMS) -KEYWORD(__is_interface_class , KEYMS) -KEYWORD(__is_sealed , KEYMS) +TYPE_TRAIT_1(__is_interface_class, IsInterfaceClass, KEYMS) +TYPE_TRAIT_1(__is_sealed, IsSealed, KEYMS) // GNU and MS Type Traits -KEYWORD(__has_nothrow_assign , KEYCXX) -KEYWORD(__has_nothrow_move_assign , KEYCXX) -KEYWORD(__has_nothrow_copy , KEYCXX) -KEYWORD(__has_nothrow_constructor , KEYCXX) -KEYWORD(__has_trivial_assign , KEYCXX) -KEYWORD(__has_trivial_move_assign , KEYCXX) -KEYWORD(__has_trivial_copy , KEYCXX) -KEYWORD(__has_trivial_constructor , KEYCXX) -KEYWORD(__has_trivial_move_constructor, KEYCXX) -KEYWORD(__has_trivial_destructor , KEYCXX) -KEYWORD(__has_virtual_destructor , KEYCXX) -KEYWORD(__is_abstract , KEYCXX) -KEYWORD(__is_base_of , KEYCXX) -KEYWORD(__is_class , KEYCXX) -KEYWORD(__is_convertible_to , KEYCXX) -KEYWORD(__is_empty , KEYCXX) -KEYWORD(__is_enum , KEYCXX) -KEYWORD(__is_final , KEYCXX) +TYPE_TRAIT_1(__has_nothrow_assign, HasNothrowAssign, KEYCXX) +TYPE_TRAIT_1(__has_nothrow_move_assign, HasNothrowMoveAssign, KEYCXX) +TYPE_TRAIT_1(__has_nothrow_copy, HasNothrowCopy, KEYCXX) +TYPE_TRAIT_1(__has_nothrow_constructor, HasNothrowConstructor, KEYCXX) +TYPE_TRAIT_1(__has_trivial_assign, HasTrivialAssign, KEYCXX) +TYPE_TRAIT_1(__has_trivial_move_assign, HasTrivialMoveAssign, KEYCXX) +TYPE_TRAIT_1(__has_trivial_copy, HasTrivialCopy, KEYCXX) +TYPE_TRAIT_1(__has_trivial_constructor, HasTrivialDefaultConstructor, KEYCXX) +TYPE_TRAIT_1(__has_trivial_move_constructor, HasTrivialMoveConstructor, KEYCXX) +TYPE_TRAIT_1(__has_trivial_destructor, HasTrivialDestructor, KEYCXX) +TYPE_TRAIT_1(__has_virtual_destructor, HasVirtualDestructor, KEYCXX) +TYPE_TRAIT_1(__is_abstract, IsAbstract, KEYCXX) +TYPE_TRAIT_2(__is_base_of, IsBaseOf, KEYCXX) +TYPE_TRAIT_1(__is_class, IsClass, KEYCXX) +TYPE_TRAIT_2(__is_convertible_to, IsConvertibleTo, KEYCXX) +TYPE_TRAIT_1(__is_empty, IsEmpty, KEYCXX) +TYPE_TRAIT_1(__is_enum, IsEnum, KEYCXX) +TYPE_TRAIT_1(__is_final, IsFinal, KEYCXX) // Tentative name - there's no implementation of std::is_literal_type yet. -KEYWORD(__is_literal , KEYCXX) +TYPE_TRAIT_1(__is_literal, IsLiteral, KEYCXX) // Name for GCC 4.6 compatibility - people have already written libraries using // this name unfortunately. -KEYWORD(__is_literal_type , KEYCXX) -KEYWORD(__is_pod , KEYCXX) -KEYWORD(__is_polymorphic , KEYCXX) -KEYWORD(__is_trivial , KEYCXX) -KEYWORD(__is_union , KEYCXX) +ALIAS("__is_literal_type", __is_literal, KEYCXX) +TYPE_TRAIT_1(__is_pod, IsPOD, KEYCXX) +TYPE_TRAIT_1(__is_polymorphic, IsPolymorphic, KEYCXX) +TYPE_TRAIT_1(__is_trivial, IsTrivial, KEYCXX) +TYPE_TRAIT_1(__is_union, IsUnion, KEYCXX) // Clang-only C++ Type Traits -KEYWORD(__is_trivially_constructible, KEYCXX) -KEYWORD(__is_trivially_copyable , KEYCXX) -KEYWORD(__is_trivially_assignable , KEYCXX) +TYPE_TRAIT_N(__is_trivially_constructible, IsTriviallyConstructible, KEYCXX) +TYPE_TRAIT_1(__is_trivially_copyable, IsTriviallyCopyable, KEYCXX) +TYPE_TRAIT_2(__is_trivially_assignable, IsTriviallyAssignable, KEYCXX) KEYWORD(__underlying_type , KEYCXX) // Embarcadero Expression Traits @@ -394,33 +408,33 @@ KEYWORD(__is_lvalue_expr , KEYCXX) KEYWORD(__is_rvalue_expr , KEYCXX) // Embarcadero Unary Type Traits -KEYWORD(__is_arithmetic , KEYCXX) -KEYWORD(__is_floating_point , KEYCXX) -KEYWORD(__is_integral , KEYCXX) -KEYWORD(__is_complete_type , KEYCXX) -KEYWORD(__is_void , KEYCXX) -KEYWORD(__is_array , KEYCXX) -KEYWORD(__is_function , KEYCXX) -KEYWORD(__is_reference , KEYCXX) -KEYWORD(__is_lvalue_reference , KEYCXX) -KEYWORD(__is_rvalue_reference , KEYCXX) -KEYWORD(__is_fundamental , KEYCXX) -KEYWORD(__is_object , KEYCXX) -KEYWORD(__is_scalar , KEYCXX) -KEYWORD(__is_compound , KEYCXX) -KEYWORD(__is_pointer , KEYCXX) -KEYWORD(__is_member_object_pointer , KEYCXX) -KEYWORD(__is_member_function_pointer, KEYCXX) -KEYWORD(__is_member_pointer , KEYCXX) -KEYWORD(__is_const , KEYCXX) -KEYWORD(__is_volatile , KEYCXX) -KEYWORD(__is_standard_layout , KEYCXX) -KEYWORD(__is_signed , KEYCXX) -KEYWORD(__is_unsigned , KEYCXX) +TYPE_TRAIT_1(__is_arithmetic, IsArithmetic, KEYCXX) +TYPE_TRAIT_1(__is_floating_point, IsFloatingPoint, KEYCXX) +TYPE_TRAIT_1(__is_integral, IsIntegral, KEYCXX) +TYPE_TRAIT_1(__is_complete_type, IsCompleteType, KEYCXX) +TYPE_TRAIT_1(__is_void, IsVoid, KEYCXX) +TYPE_TRAIT_1(__is_array, IsArray, KEYCXX) +TYPE_TRAIT_1(__is_function, IsFunction, KEYCXX) +TYPE_TRAIT_1(__is_reference, IsReference, KEYCXX) +TYPE_TRAIT_1(__is_lvalue_reference, IsLvalueReference, KEYCXX) +TYPE_TRAIT_1(__is_rvalue_reference, IsRvalueReference, KEYCXX) +TYPE_TRAIT_1(__is_fundamental, IsFundamental, KEYCXX) +TYPE_TRAIT_1(__is_object, IsObject, KEYCXX) +TYPE_TRAIT_1(__is_scalar, IsScalar, KEYCXX) +TYPE_TRAIT_1(__is_compound, IsCompound, KEYCXX) +TYPE_TRAIT_1(__is_pointer, IsPointer, KEYCXX) +TYPE_TRAIT_1(__is_member_object_pointer, IsMemberObjectPointer, KEYCXX) +TYPE_TRAIT_1(__is_member_function_pointer, IsMemberFunctionPointer, KEYCXX) +TYPE_TRAIT_1(__is_member_pointer, IsMemberPointer, KEYCXX) +TYPE_TRAIT_1(__is_const, IsConst, KEYCXX) +TYPE_TRAIT_1(__is_volatile, IsVolatile, KEYCXX) +TYPE_TRAIT_1(__is_standard_layout, IsStandardLayout, KEYCXX) +TYPE_TRAIT_1(__is_signed, IsSigned, KEYCXX) +TYPE_TRAIT_1(__is_unsigned, IsUnsigned, KEYCXX) // Embarcadero Binary Type Traits -KEYWORD(__is_same , KEYCXX) -KEYWORD(__is_convertible , KEYCXX) +TYPE_TRAIT_2(__is_same, IsSame, KEYCXX) +TYPE_TRAIT_2(__is_convertible, IsConvertible, KEYCXX) KEYWORD(__array_rank , KEYCXX) KEYWORD(__array_extent , KEYCXX) @@ -679,6 +693,10 @@ ANNOTATION(module_end) #undef CXX_KEYWORD_OPERATOR #undef PPKEYWORD #undef ALIAS +#undef TYPE_TRAIT_N +#undef TYPE_TRAIT_2 +#undef TYPE_TRAIT_1 +#undef TYPE_TRAIT #undef KEYWORD #undef PUNCTUATOR #undef TOK diff --git a/include/clang/Parse/Parser.h b/include/clang/Parse/Parser.h index c124c697e5..6555fd6613 100644 --- a/include/clang/Parse/Parser.h +++ b/include/clang/Parse/Parser.h @@ -2312,9 +2312,7 @@ private: DeclGroupPtrTy ParseModuleImport(SourceLocation AtLoc); //===--------------------------------------------------------------------===// - // GNU G++: Type Traits [Type-Traits.html in the GCC manual] - ExprResult ParseUnaryTypeTrait(); - ExprResult ParseBinaryTypeTrait(); + // C++11/G++: Type Traits [Type-Traits.html in the GCC manual] ExprResult ParseTypeTrait(); //===--------------------------------------------------------------------===// diff --git a/lib/AST/StmtPrinter.cpp b/lib/AST/StmtPrinter.cpp index abbc3d89aa..7f9e98a904 100644 --- a/lib/AST/StmtPrinter.cpp +++ b/lib/AST/StmtPrinter.cpp @@ -1684,72 +1684,27 @@ void StmtPrinter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *Node) { static const char *getTypeTraitName(UnaryTypeTrait UTT) { switch (UTT) { - case UTT_HasNothrowAssign: return "__has_nothrow_assign"; - case UTT_HasNothrowMoveAssign: return "__has_nothrow_move_assign"; - case UTT_HasNothrowConstructor: return "__has_nothrow_constructor"; - case UTT_HasNothrowCopy: return "__has_nothrow_copy"; - case UTT_HasTrivialAssign: return "__has_trivial_assign"; - case UTT_HasTrivialMoveAssign: return "__has_trivial_move_assign"; - case UTT_HasTrivialMoveConstructor: return "__has_trivial_move_constructor"; - case UTT_HasTrivialDefaultConstructor: return "__has_trivial_constructor"; - case UTT_HasTrivialCopy: return "__has_trivial_copy"; - case UTT_HasTrivialDestructor: return "__has_trivial_destructor"; - case UTT_HasVirtualDestructor: return "__has_virtual_destructor"; - case UTT_IsAbstract: return "__is_abstract"; - case UTT_IsArithmetic: return "__is_arithmetic"; - case UTT_IsArray: return "__is_array"; - case UTT_IsClass: return "__is_class"; - case UTT_IsCompleteType: return "__is_complete_type"; - case UTT_IsCompound: return "__is_compound"; - case UTT_IsConst: return "__is_const"; - case UTT_IsEmpty: return "__is_empty"; - case UTT_IsEnum: return "__is_enum"; - case UTT_IsFinal: return "__is_final"; - case UTT_IsFloatingPoint: return "__is_floating_point"; - case UTT_IsFunction: return "__is_function"; - case UTT_IsFundamental: return "__is_fundamental"; - case UTT_IsIntegral: return "__is_integral"; - case UTT_IsInterfaceClass: return "__is_interface_class"; - case UTT_IsLiteral: return "__is_literal"; - case UTT_IsLvalueReference: return "__is_lvalue_reference"; - 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_IsObject: return "__is_object"; - case UTT_IsPOD: return "__is_pod"; - case UTT_IsPointer: return "__is_pointer"; - case UTT_IsPolymorphic: return "__is_polymorphic"; - case UTT_IsReference: return "__is_reference"; - case UTT_IsRvalueReference: return "__is_rvalue_reference"; - case UTT_IsScalar: return "__is_scalar"; - case UTT_IsSealed: return "__is_sealed"; - case UTT_IsSigned: return "__is_signed"; - case UTT_IsStandardLayout: return "__is_standard_layout"; - case UTT_IsTrivial: return "__is_trivial"; - case UTT_IsTriviallyCopyable: return "__is_trivially_copyable"; - case UTT_IsUnion: return "__is_union"; - case UTT_IsUnsigned: return "__is_unsigned"; - case UTT_IsVoid: return "__is_void"; - case UTT_IsVolatile: return "__is_volatile"; +#define TYPE_TRAIT_1(Spelling, Name, Key) \ + case clang::UTT_##Name: return #Spelling; +#include "clang/Basic/TokenKinds.def" } llvm_unreachable("Type trait not covered by switch statement"); } static const char *getTypeTraitName(BinaryTypeTrait BTT) { switch (BTT) { - case BTT_IsBaseOf: return "__is_base_of"; - case BTT_IsConvertible: return "__is_convertible"; - case BTT_IsSame: return "__is_same"; - case BTT_TypeCompatible: return "__builtin_types_compatible_p"; - case BTT_IsConvertibleTo: return "__is_convertible_to"; - case BTT_IsTriviallyAssignable: return "__is_trivially_assignable"; +#define TYPE_TRAIT_2(Spelling, Name, Key) \ + case clang::BTT_##Name: return #Spelling; +#include "clang/Basic/TokenKinds.def" } llvm_unreachable("Binary type trait not covered by switch"); } static const char *getTypeTraitName(TypeTrait TT) { switch (TT) { - case clang::TT_IsTriviallyConstructible:return "__is_trivially_constructible"; +#define TYPE_TRAIT_N(Spelling, Name, Key) \ + case clang::TT_##Name: return #Spelling; +#include "clang/Basic/TokenKinds.def" } llvm_unreachable("Type trait not covered by switch"); } diff --git a/lib/Parse/ParseExpr.cpp b/lib/Parse/ParseExpr.cpp index f9885905a9..8fb0660b34 100644 --- a/lib/Parse/ParseExpr.cpp +++ b/lib/Parse/ParseExpr.cpp @@ -1168,65 +1168,9 @@ ExprResult Parser::ParseCastExpression(bool isUnaryExpression, return Result; } - case tok::kw___is_abstract: // [GNU] unary-type-trait - case tok::kw___is_class: - case tok::kw___is_empty: - case tok::kw___is_enum: - case tok::kw___is_interface_class: - case tok::kw___is_literal: - case tok::kw___is_arithmetic: - case tok::kw___is_integral: - case tok::kw___is_floating_point: - case tok::kw___is_complete_type: - case tok::kw___is_void: - case tok::kw___is_array: - case tok::kw___is_function: - case tok::kw___is_reference: - case tok::kw___is_lvalue_reference: - case tok::kw___is_rvalue_reference: - case tok::kw___is_fundamental: - case tok::kw___is_object: - case tok::kw___is_scalar: - case tok::kw___is_compound: - case tok::kw___is_pointer: - case tok::kw___is_member_object_pointer: - case tok::kw___is_member_function_pointer: - case tok::kw___is_member_pointer: - case tok::kw___is_const: - case tok::kw___is_volatile: - case tok::kw___is_standard_layout: - case tok::kw___is_signed: - case tok::kw___is_unsigned: - case tok::kw___is_literal_type: - case tok::kw___is_pod: - case tok::kw___is_polymorphic: - case tok::kw___is_trivial: - case tok::kw___is_trivially_copyable: - case tok::kw___is_union: - case tok::kw___is_final: - case tok::kw___is_sealed: - case tok::kw___has_trivial_constructor: - case tok::kw___has_trivial_move_constructor: - case tok::kw___has_trivial_copy: - case tok::kw___has_trivial_assign: - case tok::kw___has_trivial_move_assign: - case tok::kw___has_trivial_destructor: - case tok::kw___has_nothrow_assign: - case tok::kw___has_nothrow_move_assign: - case tok::kw___has_nothrow_copy: - case tok::kw___has_nothrow_constructor: - case tok::kw___has_virtual_destructor: - return ParseUnaryTypeTrait(); - - case tok::kw___builtin_types_compatible_p: - case tok::kw___is_base_of: - case tok::kw___is_same: - case tok::kw___is_convertible: - case tok::kw___is_convertible_to: - case tok::kw___is_trivially_assignable: - return ParseBinaryTypeTrait(); - - case tok::kw___is_trivially_constructible: +#define TYPE_TRAIT(N,Spelling,K) \ + case tok::kw_##Spelling: +#include "clang/Basic/TokenKinds.def" return ParseTypeTrait(); case tok::kw___array_rank: diff --git a/lib/Parse/ParseExprCXX.cpp b/lib/Parse/ParseExprCXX.cpp index 3f6d36c8b8..846995e0ce 100644 --- a/lib/Parse/ParseExprCXX.cpp +++ b/lib/Parse/ParseExprCXX.cpp @@ -2687,76 +2687,27 @@ Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) { static UnaryTypeTrait UnaryTypeTraitFromTokKind(tok::TokenKind kind) { switch(kind) { default: llvm_unreachable("Not a known unary type trait."); - case tok::kw___has_nothrow_assign: return UTT_HasNothrowAssign; - case tok::kw___has_nothrow_move_assign: return UTT_HasNothrowMoveAssign; - case tok::kw___has_nothrow_constructor: return UTT_HasNothrowConstructor; - case tok::kw___has_nothrow_copy: return UTT_HasNothrowCopy; - case tok::kw___has_trivial_assign: return UTT_HasTrivialAssign; - case tok::kw___has_trivial_move_assign: return UTT_HasTrivialMoveAssign; - case tok::kw___has_trivial_constructor: - return UTT_HasTrivialDefaultConstructor; - case tok::kw___has_trivial_move_constructor: - return UTT_HasTrivialMoveConstructor; - case tok::kw___has_trivial_copy: return UTT_HasTrivialCopy; - case tok::kw___has_trivial_destructor: return UTT_HasTrivialDestructor; - case tok::kw___has_virtual_destructor: return UTT_HasVirtualDestructor; - case tok::kw___is_abstract: return UTT_IsAbstract; - case tok::kw___is_arithmetic: return UTT_IsArithmetic; - case tok::kw___is_array: return UTT_IsArray; - case tok::kw___is_class: return UTT_IsClass; - 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_empty: return UTT_IsEmpty; - case tok::kw___is_enum: return UTT_IsEnum; - case tok::kw___is_final: return UTT_IsFinal; - case tok::kw___is_floating_point: return UTT_IsFloatingPoint; - case tok::kw___is_function: return UTT_IsFunction; - case tok::kw___is_fundamental: return UTT_IsFundamental; - case tok::kw___is_integral: return UTT_IsIntegral; - case tok::kw___is_interface_class: return UTT_IsInterfaceClass; - case tok::kw___is_lvalue_reference: return UTT_IsLvalueReference; - 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_object: return UTT_IsObject; - case tok::kw___is_literal: return UTT_IsLiteral; - case tok::kw___is_literal_type: return UTT_IsLiteral; - case tok::kw___is_pod: return UTT_IsPOD; - case tok::kw___is_pointer: return UTT_IsPointer; - case tok::kw___is_polymorphic: return UTT_IsPolymorphic; - case tok::kw___is_reference: return UTT_IsReference; - case tok::kw___is_rvalue_reference: return UTT_IsRvalueReference; - case tok::kw___is_scalar: return UTT_IsScalar; - case tok::kw___is_sealed: return UTT_IsSealed; - case tok::kw___is_signed: return UTT_IsSigned; - case tok::kw___is_standard_layout: return UTT_IsStandardLayout; - case tok::kw___is_trivial: return UTT_IsTrivial; - case tok::kw___is_trivially_copyable: return UTT_IsTriviallyCopyable; - case tok::kw___is_union: return UTT_IsUnion; - case tok::kw___is_unsigned: return UTT_IsUnsigned; - case tok::kw___is_void: return UTT_IsVoid; - case tok::kw___is_volatile: return UTT_IsVolatile; +#define TYPE_TRAIT_1(Spelling, Name, Key) \ + case tok::kw_ ## Spelling: return UTT_ ## Name; +#include "clang/Basic/TokenKinds.def" } } static BinaryTypeTrait BinaryTypeTraitFromTokKind(tok::TokenKind kind) { switch(kind) { default: llvm_unreachable("Not a known binary type trait"); - case tok::kw___is_base_of: return BTT_IsBaseOf; - case tok::kw___is_convertible: return BTT_IsConvertible; - 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_trivially_assignable: return BTT_IsTriviallyAssignable; +#define TYPE_TRAIT_2(Spelling, Name, Key) \ + case tok::kw_ ## Spelling: return BTT_ ## Name; +#include "clang/Basic/TokenKinds.def" } } static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind) { switch (kind) { default: llvm_unreachable("Not a known type trait"); - case tok::kw___is_trivially_constructible: - return TT_IsTriviallyConstructible; +#define TYPE_TRAIT_N(Spelling, Name, Key) \ + case tok::kw_ ## Spelling: return TT_ ## Name; +#include "clang/Basic/TokenKinds.def" } } @@ -2776,83 +2727,29 @@ static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind) { } } -/// ParseUnaryTypeTrait - Parse the built-in unary type-trait -/// pseudo-functions that allow implementation of the TR1/C++0x type traits -/// templates. -/// -/// primary-expression: -/// [GNU] unary-type-trait '(' type-id ')' -/// -ExprResult Parser::ParseUnaryTypeTrait() { - UnaryTypeTrait UTT = UnaryTypeTraitFromTokKind(Tok.getKind()); - SourceLocation Loc = ConsumeToken(); - - BalancedDelimiterTracker T(*this, tok::l_paren); - if (T.expectAndConsume(diag::err_expected_lparen)) - return ExprError(); - - // FIXME: Error reporting absolutely sucks! If the this fails to parse a type - // there will be cryptic errors about mismatched parentheses and missing - // specifiers. - TypeResult Ty = ParseTypeName(); - - T.consumeClose(); - - if (Ty.isInvalid()) - return ExprError(); - - return Actions.ActOnUnaryTypeTrait(UTT, Loc, Ty.get(), T.getCloseLocation()); -} - -/// ParseBinaryTypeTrait - Parse the built-in binary type-trait -/// pseudo-functions that allow implementation of the TR1/C++0x type traits -/// templates. -/// -/// primary-expression: -/// [GNU] binary-type-trait '(' type-id ',' type-id ')' -/// -ExprResult Parser::ParseBinaryTypeTrait() { - BinaryTypeTrait BTT = BinaryTypeTraitFromTokKind(Tok.getKind()); - SourceLocation Loc = ConsumeToken(); - - BalancedDelimiterTracker T(*this, tok::l_paren); - if (T.expectAndConsume(diag::err_expected_lparen)) - return ExprError(); - - TypeResult LhsTy = ParseTypeName(); - if (LhsTy.isInvalid()) { - SkipUntil(tok::r_paren, StopAtSemi); - return ExprError(); - } - - if (ExpectAndConsume(tok::comma, diag::err_expected_comma)) { - SkipUntil(tok::r_paren, StopAtSemi); - return ExprError(); - } - - TypeResult RhsTy = ParseTypeName(); - if (RhsTy.isInvalid()) { - SkipUntil(tok::r_paren, StopAtSemi); - return ExprError(); +static unsigned TypeTraitArity(tok::TokenKind kind) { + switch (kind) { + default: llvm_unreachable("Not a known type trait"); +#define TYPE_TRAIT(N,Spelling,K) case tok::kw_##Spelling: return N; +#include "clang/Basic/TokenKinds.def" } - - T.consumeClose(); - - return Actions.ActOnBinaryTypeTrait(BTT, Loc, LhsTy.get(), RhsTy.get(), - T.getCloseLocation()); } /// \brief Parse the built-in type-trait pseudo-functions that allow /// implementation of the TR1/C++11 type traits templates. /// /// primary-expression: +/// unary-type-trait '(' type-id ')' +/// binary-type-trait '(' type-id ',' type-id ')' /// type-trait '(' type-id-seq ')' /// /// type-id-seq: /// type-id ...[opt] type-id-seq[opt] /// ExprResult Parser::ParseTypeTrait() { - TypeTrait Kind = TypeTraitFromTokKind(Tok.getKind()); + tok::TokenKind Kind = Tok.getKind(); + unsigned Arity = TypeTraitArity(Kind); + SourceLocation Loc = ConsumeToken(); BalancedDelimiterTracker Parens(*this, tok::l_paren); @@ -2890,8 +2787,33 @@ ExprResult Parser::ParseTypeTrait() { if (Parens.consumeClose()) return ExprError(); - - return Actions.ActOnTypeTrait(Kind, Loc, Args, Parens.getCloseLocation()); + + SourceLocation EndLoc = Parens.getCloseLocation(); + + if (Arity && Args.size() != Arity) { + Diag(EndLoc, diag::err_type_trait_arity) + << Arity << 0 << (Arity > 1) << (int)Args.size() << SourceRange(Loc); + return ExprError(); + } + + if (!Arity && Args.empty()) { + Diag(EndLoc, diag::err_type_trait_arity) + << 1 << 1 << 1 << (int)Args.size() << SourceRange(Loc); + return ExprError(); + } + + if (Arity == 1) + return Actions.ActOnUnaryTypeTrait(UnaryTypeTraitFromTokKind(Kind), Loc, + Args[0], EndLoc); + if (Arity == 2) + return Actions.ActOnBinaryTypeTrait(BinaryTypeTraitFromTokKind(Kind), Loc, + Args[0], Args[1], EndLoc); + if (!Arity) + return Actions.ActOnTypeTrait(TypeTraitFromTokKind(Kind), Loc, Args, + EndLoc); + + llvm_unreachable("unhandled type trait rank"); + return ExprError(); } /// ParseArrayTypeTrait - Parse the built-in array type-trait diff --git a/lib/Parse/ParseTentative.cpp b/lib/Parse/ParseTentative.cpp index a1d6b13fda..59118b0fd3 100644 --- a/lib/Parse/ParseTentative.cpp +++ b/lib/Parse/ParseTentative.cpp @@ -935,7 +935,6 @@ Parser::isExpressionOrTypeSpecifierSimple(tok::TokenKind Kind) { case tok::kw___alignof: case tok::kw___builtin_choose_expr: case tok::kw___builtin_offsetof: - case tok::kw___builtin_types_compatible_p: case tok::kw___builtin_va_arg: case tok::kw___imag: case tok::kw___real: @@ -943,33 +942,10 @@ Parser::isExpressionOrTypeSpecifierSimple(tok::TokenKind Kind) { case tok::kw___FUNCDNAME__: case tok::kw_L__FUNCTION__: case tok::kw___PRETTY_FUNCTION__: - case tok::kw___has_nothrow_assign: - case tok::kw___has_nothrow_copy: - case tok::kw___has_nothrow_constructor: - case tok::kw___has_trivial_assign: - case tok::kw___has_trivial_copy: - case tok::kw___has_trivial_constructor: - case tok::kw___has_trivial_destructor: - case tok::kw___has_virtual_destructor: - case tok::kw___is_abstract: - case tok::kw___is_base_of: - case tok::kw___is_class: - case tok::kw___is_convertible_to: - case tok::kw___is_empty: - case tok::kw___is_enum: - case tok::kw___is_interface_class: - case tok::kw___is_final: - case tok::kw___is_literal: - case tok::kw___is_literal_type: - case tok::kw___is_pod: - case tok::kw___is_polymorphic: - case tok::kw___is_sealed: - case tok::kw___is_trivial: - case tok::kw___is_trivially_assignable: - case tok::kw___is_trivially_constructible: - case tok::kw___is_trivially_copyable: - case tok::kw___is_union: case tok::kw___uuidof: +#define TYPE_TRAIT(N,Spelling,K) \ + case tok::kw_##Spelling: +#include "clang/Basic/TokenKinds.def" return TPResult::True(); // Obviously starts a type-specifier-seq: diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp index 04871d367e..2c9eb63f15 100644 --- a/lib/Sema/SemaExprCXX.cpp +++ b/lib/Sema/SemaExprCXX.cpp @@ -3650,11 +3650,7 @@ static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc, // variable t: // // T t(create()...); - if (Args.empty()) { - S.Diag(KWLoc, diag::err_type_trait_arity) - << 1 << 1 << 1 << (int)Args.size(); - return false; - } + assert(!Args.empty()); // Precondition: T and all types in the parameter pack Args shall be // complete types, (possibly cv-qualified) void, or arrays of -- 2.40.0