maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Fix for PR9812: warn about bool instead of _Bool. 

llvm-svn: 199311
This commit is contained in:
Erik Verbruggen 2014-01-15 09:15:43 +00:00
parent da3b5987ca
commit 888d52a655
13 changed files with 227 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
clang/include/clang/Sema/DeclSpec.h
View File

@ -508,7 +508,8 @@ public:
bool hasTagDefinition() const; bool hasTagDefinition() const;
/// \brief Turn a type-specifier-type into a string like "_Bool" or "union". /// \brief Turn a type-specifier-type into a string like "_Bool" or "union".
static const char *getSpecifierName(DeclSpec::TST T); static const char *getSpecifierName(DeclSpec::TST T,
const PrintingPolicy &Policy);
static const char *getSpecifierName(DeclSpec::TQ Q); static const char *getSpecifierName(DeclSpec::TQ Q);
static const char *getSpecifierName(DeclSpec::TSS S); static const char *getSpecifierName(DeclSpec::TSS S);
static const char *getSpecifierName(DeclSpec::TSC C); static const char *getSpecifierName(DeclSpec::TSC C);
@ -596,36 +597,45 @@ public:
/// TODO: use a more general approach that still allows these /// TODO: use a more general approach that still allows these
/// diagnostics to be ignored when desired. /// diagnostics to be ignored when desired.
bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,
const char *&PrevSpec, unsigned &DiagID); const char *&PrevSpec, unsigned &DiagID,
const PrintingPolicy &Policy);
bool SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc, bool SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc,
const char *&PrevSpec, unsigned &DiagID); const char *&PrevSpec, unsigned &DiagID);
bool SetTypeSpecWidth(TSW W, SourceLocation Loc, const char *&PrevSpec, bool SetTypeSpecWidth(TSW W, SourceLocation Loc, const char *&PrevSpec,
unsigned &DiagID); unsigned &DiagID, const PrintingPolicy &Policy);
bool SetTypeSpecComplex(TSC C, SourceLocation Loc, const char *&PrevSpec, bool SetTypeSpecComplex(TSC C, SourceLocation Loc, const char *&PrevSpec,
unsigned &DiagID); unsigned &DiagID);
bool SetTypeSpecSign(TSS S, SourceLocation Loc, const char *&PrevSpec, bool SetTypeSpecSign(TSS S, SourceLocation Loc, const char *&PrevSpec,
unsigned &DiagID); unsigned &DiagID);
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
unsigned &DiagID); unsigned &DiagID, const PrintingPolicy &Policy);
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
unsigned &DiagID, ParsedType Rep); unsigned &DiagID, ParsedType Rep,
const PrintingPolicy &Policy);
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
unsigned &DiagID, Decl *Rep, bool Owned); unsigned &DiagID, Decl *Rep, bool Owned,
const PrintingPolicy &Policy);
bool SetTypeSpecType(TST T, SourceLocation TagKwLoc, bool SetTypeSpecType(TST T, SourceLocation TagKwLoc,
SourceLocation TagNameLoc, const char *&PrevSpec, SourceLocation TagNameLoc, const char *&PrevSpec,
unsigned &DiagID, ParsedType Rep); unsigned &DiagID, ParsedType Rep,
const PrintingPolicy &Policy);
bool SetTypeSpecType(TST T, SourceLocation TagKwLoc, bool SetTypeSpecType(TST T, SourceLocation TagKwLoc,
SourceLocation TagNameLoc, const char *&PrevSpec, SourceLocation TagNameLoc, const char *&PrevSpec,
unsigned &DiagID, Decl *Rep, bool Owned); unsigned &DiagID, Decl *Rep, bool Owned,
const PrintingPolicy &Policy);
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
unsigned &DiagID, Expr *Rep); unsigned &DiagID, Expr *Rep,
const PrintingPolicy &policy);
bool SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc, bool SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
const char *&PrevSpec, unsigned &DiagID); const char *&PrevSpec, unsigned &DiagID,
const PrintingPolicy &Policy);
bool SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc, bool SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
const char *&PrevSpec, unsigned &DiagID); const char *&PrevSpec, unsigned &DiagID,
const PrintingPolicy &Policy);
bool SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc, bool SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
const char *&PrevSpec, unsigned &DiagID); const char *&PrevSpec, unsigned &DiagID,
const PrintingPolicy &Policy);
bool SetTypeSpecError(); bool SetTypeSpecError();
void UpdateDeclRep(Decl *Rep) { void UpdateDeclRep(Decl *Rep) {
assert(isDeclRep((TST) TypeSpecType)); assert(isDeclRep((TST) TypeSpecType));
@ -735,7 +745,8 @@ public:
/// Finish - This does final analysis of the declspec, issuing diagnostics for /// Finish - This does final analysis of the declspec, issuing diagnostics for
/// things like "_Imaginary" (lacking an FP type). After calling this method, /// things like "_Imaginary" (lacking an FP type). After calling this method,
/// DeclSpec is guaranteed self-consistent, even if an error occurred. /// DeclSpec is guaranteed self-consistent, even if an error occurred.
void Finish(DiagnosticsEngine &D, Preprocessor &PP); void Finish(DiagnosticsEngine &D, Preprocessor &PP,
const PrintingPolicy &Policy);
const WrittenBuiltinSpecs& getWrittenBuiltinSpecs() const { const WrittenBuiltinSpecs& getWrittenBuiltinSpecs() const {
return writtenBS; return writtenBS;

3
clang/include/clang/Sema/Sema.h
View File

@ -1641,7 +1641,8 @@ public:
Decl *BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, Decl *BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
AccessSpecifier AS, AccessSpecifier AS,
RecordDecl *Record); RecordDecl *Record,
const PrintingPolicy &Policy);
Decl *BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS, Decl *BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
RecordDecl *Record); RecordDecl *Record);

106
clang/lib/Parse/ParseDecl.cpp
View File

@ -14,6 +14,7 @@
#include "clang/Parse/Parser.h" #include "clang/Parse/Parser.h"
#include "RAIIObjectsForParser.h" #include "RAIIObjectsForParser.h"
#include "clang/AST/DeclTemplate.h" #include "clang/AST/DeclTemplate.h"
#include "clang/AST/ASTContext.h"
#include "clang/Basic/AddressSpaces.h" #include "clang/Basic/AddressSpaces.h"
#include "clang/Basic/CharInfo.h" #include "clang/Basic/CharInfo.h"
#include "clang/Parse/ParseDiagnostic.h" #include "clang/Parse/ParseDiagnostic.h"
@ -2218,7 +2219,8 @@ bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
// name token, and we're done. // name token, and we're done.
const char *PrevSpec; const char *PrevSpec;
unsigned DiagID; unsigned DiagID;
DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, T); DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, T,
Actions.getASTContext().getPrintingPolicy());
DS.SetRangeEnd(Tok.getLocation()); DS.SetRangeEnd(Tok.getLocation());
ConsumeToken(); ConsumeToken();
// There may be other declaration specifiers after this. // There may be other declaration specifiers after this.
@ -2422,9 +2424,10 @@ Parser::DiagnoseMissingSemiAfterTagDefinition(DeclSpec &DS, AccessSpecifier AS,
if (MightBeDeclarator) if (MightBeDeclarator)
return false; return false;
const PrintingPolicy &PPol = Actions.getASTContext().getPrintingPolicy();
Diag(PP.getLocForEndOfToken(DS.getRepAsDecl()->getLocEnd()), Diag(PP.getLocForEndOfToken(DS.getRepAsDecl()->getLocEnd()),
diag::err_expected_after) diag::err_expected_after)
<< DeclSpec::getSpecifierName(DS.getTypeSpecType()) << tok::semi; << DeclSpec::getSpecifierName(DS.getTypeSpecType(), PPol) << tok::semi;
// Try to recover from the typo, by dropping the tag definition and parsing // Try to recover from the typo, by dropping the tag definition and parsing
// the problematic tokens as a type. // the problematic tokens as a type.
@ -2480,6 +2483,7 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
bool EnteringContext = (DSContext == DSC_class || DSContext == DSC_top_level); bool EnteringContext = (DSContext == DSC_class || DSContext == DSC_top_level);
bool AttrsLastTime = false; bool AttrsLastTime = false;
ParsedAttributesWithRange attrs(AttrFactory); ParsedAttributesWithRange attrs(AttrFactory);
const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy();
while (1) { while (1) {
bool isInvalid = false; bool isInvalid = false;
const char *PrevSpec = 0; const char *PrevSpec = 0;
@ -2503,7 +2507,7 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
// If this is not a declaration specifier token, we're done reading decl // If this is not a declaration specifier token, we're done reading decl
// specifiers. First verify that DeclSpec's are consistent. // specifiers. First verify that DeclSpec's are consistent.
DS.Finish(Diags, PP); DS.Finish(Diags, PP, Policy);
return; return;
case tok::l_square: case tok::l_square:
@ -2637,7 +2641,7 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
ParsedType T = getTypeAnnotation(Tok); ParsedType T = getTypeAnnotation(Tok);
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename,
Tok.getAnnotationEndLoc(), Tok.getAnnotationEndLoc(),
PrevSpec, DiagID, T); PrevSpec, DiagID, T, Policy);
if (isInvalid) if (isInvalid)
break; break;
} }
@ -2696,7 +2700,7 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
ConsumeToken(); // The C++ scope. ConsumeToken(); // The C++ scope.
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
DiagID, TypeRep); DiagID, TypeRep, Policy);
if (isInvalid) if (isInvalid)
break; break;
@ -2715,7 +2719,7 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
if (Tok.getAnnotationValue()) { if (Tok.getAnnotationValue()) {
ParsedType T = getTypeAnnotation(Tok); ParsedType T = getTypeAnnotation(Tok);
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
DiagID, T); DiagID, T, Policy);
} else } else
DS.SetTypeSpecError(); DS.SetTypeSpecError();
@ -2806,7 +2810,7 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
goto DoneWithDeclSpec; goto DoneWithDeclSpec;
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
DiagID, TypeRep); DiagID, TypeRep, Policy);
if (isInvalid) if (isInvalid)
break; break;
@ -2893,46 +2897,46 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
// storage-class-specifier // storage-class-specifier
case tok::kw_typedef: case tok::kw_typedef:
isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_typedef, Loc, isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_typedef, Loc,
PrevSpec, DiagID); PrevSpec, DiagID, Policy);
break; break;
case tok::kw_extern: case tok::kw_extern:
if (DS.getThreadStorageClassSpec() == DeclSpec::TSCS___thread) if (DS.getThreadStorageClassSpec() == DeclSpec::TSCS___thread)
Diag(Tok, diag::ext_thread_before) << "extern"; Diag(Tok, diag::ext_thread_before) << "extern";
isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_extern, Loc, isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_extern, Loc,
PrevSpec, DiagID); PrevSpec, DiagID, Policy);
break; break;
case tok::kw___private_extern__: case tok::kw___private_extern__:
isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_private_extern, isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_private_extern,
Loc, PrevSpec, DiagID); Loc, PrevSpec, DiagID, Policy);
break; break;
case tok::kw_static: case tok::kw_static:
if (DS.getThreadStorageClassSpec() == DeclSpec::TSCS___thread) if (DS.getThreadStorageClassSpec() == DeclSpec::TSCS___thread)
Diag(Tok, diag::ext_thread_before) << "static"; Diag(Tok, diag::ext_thread_before) << "static";
isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_static, Loc, isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_static, Loc,
PrevSpec, DiagID); PrevSpec, DiagID, Policy);
break; break;
case tok::kw_auto: case tok::kw_auto:
if (getLangOpts().CPlusPlus11) { if (getLangOpts().CPlusPlus11) {
if (isKnownToBeTypeSpecifier(GetLookAheadToken(1))) { if (isKnownToBeTypeSpecifier(GetLookAheadToken(1))) {
isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc, isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
PrevSpec, DiagID); PrevSpec, DiagID, Policy);
if (!isInvalid) if (!isInvalid)
Diag(Tok, diag::ext_auto_storage_class) Diag(Tok, diag::ext_auto_storage_class)
<< FixItHint::CreateRemoval(DS.getStorageClassSpecLoc()); << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
} else } else
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec,
DiagID); DiagID, Policy);
} else } else
isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc, isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
PrevSpec, DiagID); PrevSpec, DiagID, Policy);
break; break;
case tok::kw_register: case tok::kw_register:
isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_register, Loc, isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_register, Loc,
PrevSpec, DiagID); PrevSpec, DiagID, Policy);
break; break;
case tok::kw_mutable: case tok::kw_mutable:
isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_mutable, Loc, isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_mutable, Loc,
PrevSpec, DiagID); PrevSpec, DiagID, Policy);
break; break;
case tok::kw___thread: case tok::kw___thread:
isInvalid = DS.SetStorageClassSpecThread(DeclSpec::TSCS___thread, Loc, isInvalid = DS.SetStorageClassSpecThread(DeclSpec::TSCS___thread, Loc,
@ -2994,19 +2998,19 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
// type-specifier // type-specifier
case tok::kw_short: case tok::kw_short:
isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec,
DiagID); DiagID, Policy);
break; break;
case tok::kw_long: case tok::kw_long:
if (DS.getTypeSpecWidth() != DeclSpec::TSW_long) if (DS.getTypeSpecWidth() != DeclSpec::TSW_long)
isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec,
DiagID); DiagID, Policy);
else else
isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
DiagID); DiagID, Policy);
break; break;
case tok::kw___int64: case tok::kw___int64:
isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec,
DiagID); DiagID, Policy);
break; break;
case tok::kw_signed: case tok::kw_signed:
isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec,
@ -3026,43 +3030,43 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
break; break;
case tok::kw_void: case tok::kw_void:
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec,
DiagID); DiagID, Policy);
break; break;
case tok::kw_char: case tok::kw_char:
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec,
DiagID); DiagID, Policy);
break; break;
case tok::kw_int: case tok::kw_int:
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec,
DiagID); DiagID, Policy);
break; break;
case tok::kw___int128: case tok::kw___int128:
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec,
DiagID); DiagID, Policy);
break; break;
case tok::kw_half: case tok::kw_half:
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec,
DiagID); DiagID, Policy);
break; break;
case tok::kw_float: case tok::kw_float:
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec,
DiagID); DiagID, Policy);
break; break;
case tok::kw_double: case tok::kw_double:
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec,
DiagID); DiagID, Policy);
break; break;
case tok::kw_wchar_t: case tok::kw_wchar_t:
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec,
DiagID); DiagID, Policy);
break; break;
case tok::kw_char16_t: case tok::kw_char16_t:
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec,
DiagID); DiagID, Policy);
break; break;
case tok::kw_char32_t: case tok::kw_char32_t:
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec,
DiagID); DiagID, Policy);
break; break;
case tok::kw_bool: case tok::kw_bool:
case tok::kw__Bool: case tok::kw__Bool:
@ -3076,30 +3080,30 @@ void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
isInvalid = true; isInvalid = true;
} else { } else {
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec,
DiagID); DiagID, Policy);
} }
break; break;
case tok::kw__Decimal32: case tok::kw__Decimal32:
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec,
DiagID); DiagID, Policy);
break; break;
case tok::kw__Decimal64: case tok::kw__Decimal64:
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec,
DiagID); DiagID, Policy);
break; break;
case tok::kw__Decimal128: case tok::kw__Decimal128:
isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec, isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec,
DiagID); DiagID, Policy);
break; break;
case tok::kw___vector: case tok::kw___vector:
isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID); isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID, Policy);
break; break;
case tok::kw___pixel: case tok::kw___pixel:
isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID); isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID, Policy);
break; break;
case tok::kw___unknown_anytype: case tok::kw___unknown_anytype:
isInvalid = DS.SetTypeSpecType(TST_unknown_anytype, Loc, isInvalid = DS.SetTypeSpecType(TST_unknown_anytype, Loc,
PrevSpec, DiagID); PrevSpec, DiagID, Policy);
break; break;
// class-specifier: // class-specifier:
@ -3759,7 +3763,8 @@ void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS,
if (DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc, if (DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc,
NameLoc.isValid() ? NameLoc : StartLoc, NameLoc.isValid() ? NameLoc : StartLoc,
PrevSpec, DiagID, Type.get())) PrevSpec, DiagID, Type.get(),
Actions.getASTContext().getPrintingPolicy()))
Diag(StartLoc, DiagID) << PrevSpec; Diag(StartLoc, DiagID) << PrevSpec;
return; return;
@ -3782,7 +3787,8 @@ void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS,
if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc, if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc,
NameLoc.isValid() ? NameLoc : StartLoc, NameLoc.isValid() ? NameLoc : StartLoc,
PrevSpec, DiagID, TagDecl, Owned)) PrevSpec, DiagID, TagDecl, Owned,
Actions.getASTContext().getPrintingPolicy()))
Diag(StartLoc, DiagID) << PrevSpec; Diag(StartLoc, DiagID) << PrevSpec;
} }
@ -4464,7 +4470,7 @@ void Parser::ParseTypeQualifierListOpt(DeclSpec &DS,
DoneWithTypeQuals: DoneWithTypeQuals:
// If this is not a type-qualifier token, we're done reading type // If this is not a type-qualifier token, we're done reading type
// qualifiers. First verify that DeclSpec's are consistent. // qualifiers. First verify that DeclSpec's are consistent.
DS.Finish(Diags, PP); DS.Finish(Diags, PP, Actions.getASTContext().getPrintingPolicy());
if (EndLoc.isValid()) if (EndLoc.isValid())
DS.SetRangeEnd(EndLoc); DS.SetRangeEnd(EndLoc);
return; return;
@ -5619,7 +5625,8 @@ void Parser::ParseTypeofSpecifier(DeclSpec &DS) {
unsigned DiagID; unsigned DiagID;
// Check for duplicate type specifiers (e.g. "int typeof(int)"). // Check for duplicate type specifiers (e.g. "int typeof(int)").
if (DS.SetTypeSpecType(DeclSpec::TST_typeofType, StartLoc, PrevSpec, if (DS.SetTypeSpecType(DeclSpec::TST_typeofType, StartLoc, PrevSpec,
DiagID, CastTy)) DiagID, CastTy,
Actions.getASTContext().getPrintingPolicy()))
Diag(StartLoc, DiagID) << PrevSpec; Diag(StartLoc, DiagID) << PrevSpec;
return; return;
} }
@ -5641,7 +5648,8 @@ void Parser::ParseTypeofSpecifier(DeclSpec &DS) {
unsigned DiagID; unsigned DiagID;
// Check for duplicate type specifiers (e.g. "int typeof(int)"). // Check for duplicate type specifiers (e.g. "int typeof(int)").
if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec, if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec,
DiagID, Operand.get())) DiagID, Operand.get(),
Actions.getASTContext().getPrintingPolicy()))
Diag(StartLoc, DiagID) << PrevSpec; Diag(StartLoc, DiagID) << PrevSpec;
} }
@ -5675,7 +5683,8 @@ void Parser::ParseAtomicSpecifier(DeclSpec &DS) {
const char *PrevSpec = 0; const char *PrevSpec = 0;
unsigned DiagID; unsigned DiagID;
if (DS.SetTypeSpecType(DeclSpec::TST_atomic, StartLoc, PrevSpec, if (DS.SetTypeSpecType(DeclSpec::TST_atomic, StartLoc, PrevSpec,
DiagID, Result.release())) DiagID, Result.release(),
Actions.getASTContext().getPrintingPolicy()))
Diag(StartLoc, DiagID) << PrevSpec; Diag(StartLoc, DiagID) << PrevSpec;
} }
@ -5715,6 +5724,7 @@ bool Parser::TryAltiVecVectorTokenOutOfLine() {
bool Parser::TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc, bool Parser::TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc,
const char *&PrevSpec, unsigned &DiagID, const char *&PrevSpec, unsigned &DiagID,
bool &isInvalid) { bool &isInvalid) {
const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy();
if (Tok.getIdentifierInfo() == Ident_vector) { if (Tok.getIdentifierInfo() == Ident_vector) {
Token Next = NextToken(); Token Next = NextToken();
switch (Next.getKind()) { switch (Next.getKind()) {
@ -5729,15 +5739,15 @@ bool Parser::TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc,
case tok::kw_double: case tok::kw_double:
case tok::kw_bool: case tok::kw_bool:
case tok::kw___pixel: case tok::kw___pixel:
isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID); isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID, Policy);
return true; return true;
case tok::identifier: case tok::identifier:
if (Next.getIdentifierInfo() == Ident_pixel) { if (Next.getIdentifierInfo() == Ident_pixel) {
isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID); isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID,Policy);
return true; return true;
} }
if (Next.getIdentifierInfo() == Ident_bool) { if (Next.getIdentifierInfo() == Ident_bool) {
isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID); isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID,Policy);
return true; return true;
} }
break; break;
@ -5746,11 +5756,11 @@ bool Parser::TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc,
} }
} else if ((Tok.getIdentifierInfo() == Ident_pixel) && } else if ((Tok.getIdentifierInfo() == Ident_pixel) &&
DS.isTypeAltiVecVector()) { DS.isTypeAltiVecVector()) {
isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID); isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID, Policy);
return true; return true;
} else if ((Tok.getIdentifierInfo() == Ident_bool) && } else if ((Tok.getIdentifierInfo() == Ident_bool) &&
DS.isTypeAltiVecVector()) { DS.isTypeAltiVecVector()) {
isInvalid = DS.SetTypeAltiVecBool(true, Loc, PrevSpec, DiagID); isInvalid = DS.SetTypeAltiVecBool(true, Loc, PrevSpec, DiagID, Policy);
return true; return true;
} }
return false; return false;

26
clang/lib/Parse/ParseDeclCXX.cpp
View File

@ -14,6 +14,7 @@
#include "clang/Parse/Parser.h" #include "clang/Parse/Parser.h"
#include "RAIIObjectsForParser.h" #include "RAIIObjectsForParser.h"
#include "clang/AST/DeclTemplate.h" #include "clang/AST/DeclTemplate.h"
#include "clang/AST/ASTContext.h"
#include "clang/Basic/CharInfo.h" #include "clang/Basic/CharInfo.h"
#include "clang/Basic/OperatorKinds.h" #include "clang/Basic/OperatorKinds.h"
#include "clang/Parse/ParseDiagnostic.h" #include "clang/Parse/ParseDiagnostic.h"
@ -786,12 +787,13 @@ SourceLocation Parser::ParseDecltypeSpecifier(DeclSpec &DS) {
const char *PrevSpec = 0; const char *PrevSpec = 0;
unsigned DiagID; unsigned DiagID;
const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy();
// Check for duplicate type specifiers (e.g. "int decltype(a)"). // Check for duplicate type specifiers (e.g. "int decltype(a)").
if (Result.get() if (Result.get()
? DS.SetTypeSpecType(DeclSpec::TST_decltype, StartLoc, PrevSpec, ? DS.SetTypeSpecType(DeclSpec::TST_decltype, StartLoc, PrevSpec,
DiagID, Result.release()) DiagID, Result.release(), Policy)
: DS.SetTypeSpecType(DeclSpec::TST_decltype_auto, StartLoc, PrevSpec, : DS.SetTypeSpecType(DeclSpec::TST_decltype_auto, StartLoc, PrevSpec,
DiagID)) { DiagID, Policy)) {
Diag(StartLoc, DiagID) << PrevSpec; Diag(StartLoc, DiagID) << PrevSpec;
DS.SetTypeSpecError(); DS.SetTypeSpecError();
} }
@ -842,7 +844,8 @@ void Parser::ParseUnderlyingTypeSpecifier(DeclSpec &DS) {
const char *PrevSpec = 0; const char *PrevSpec = 0;
unsigned DiagID; unsigned DiagID;
if (DS.SetTypeSpecType(DeclSpec::TST_underlyingType, StartLoc, PrevSpec, if (DS.SetTypeSpecType(DeclSpec::TST_underlyingType, StartLoc, PrevSpec,
DiagID, Result.release())) DiagID, Result.release(),
Actions.getASTContext().getPrintingPolicy()))
Diag(StartLoc, DiagID) << PrevSpec; Diag(StartLoc, DiagID) << PrevSpec;
DS.setTypeofParensRange(T.getRange()); DS.setTypeofParensRange(T.getRange());
} }
@ -990,7 +993,8 @@ Parser::TypeResult Parser::ParseBaseTypeSpecifier(SourceLocation &BaseLoc,
const char *PrevSpec = 0; const char *PrevSpec = 0;
unsigned DiagID; unsigned DiagID;
DS.SetTypeSpecType(TST_typename, IdLoc, PrevSpec, DiagID, Type); DS.SetTypeSpecType(TST_typename, IdLoc, PrevSpec, DiagID, Type,
Actions.getASTContext().getPrintingPolicy());
Declarator DeclaratorInfo(DS, Declarator::TypeNameContext); Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
return Actions.ActOnTypeName(getCurScope(), DeclaratorInfo); return Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
@ -1311,6 +1315,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
// If there are attributes after class name, parse them. // If there are attributes after class name, parse them.
MaybeParseCXX11Attributes(Attributes); MaybeParseCXX11Attributes(Attributes);
const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy();
Sema::TagUseKind TUK; Sema::TagUseKind TUK;
if (DSC == DSC_trailing) if (DSC == DSC_trailing)
TUK = Sema::TUK_Reference; TUK = Sema::TUK_Reference;
@ -1368,9 +1373,10 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
(Tok.isAtStartOfLine() && !isValidAfterTypeSpecifier(false)))) { (Tok.isAtStartOfLine() && !isValidAfterTypeSpecifier(false)))) {
TUK = DS.isFriendSpecified() ? Sema::TUK_Friend : Sema::TUK_Declaration; TUK = DS.isFriendSpecified() ? Sema::TUK_Friend : Sema::TUK_Declaration;
if (Tok.isNot(tok::semi)) { if (Tok.isNot(tok::semi)) {
const PrintingPolicy &PPol = Actions.getASTContext().getPrintingPolicy();
// A semicolon was missing after this declaration. Diagnose and recover. // A semicolon was missing after this declaration. Diagnose and recover.
ExpectAndConsume(tok::semi, diag::err_expected_after, ExpectAndConsume(tok::semi, diag::err_expected_after,
DeclSpec::getSpecifierName(TagType)); DeclSpec::getSpecifierName(TagType, PPol));
PP.EnterToken(Tok); PP.EnterToken(Tok);
Tok.setKind(tok::semi); Tok.setKind(tok::semi);
} }
@ -1412,7 +1418,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
if (DS.getTypeSpecType() != DeclSpec::TST_error) { if (DS.getTypeSpecType() != DeclSpec::TST_error) {
// We have a declaration or reference to an anonymous class. // We have a declaration or reference to an anonymous class.
Diag(StartLoc, diag::err_anon_type_definition) Diag(StartLoc, diag::err_anon_type_definition)
<< DeclSpec::getSpecifierName(TagType); << DeclSpec::getSpecifierName(TagType, Policy);
} }
// If we are parsing a definition and stop at a base-clause, continue on // If we are parsing a definition and stop at a base-clause, continue on
@ -1609,11 +1615,12 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
if (!TypeResult.isInvalid()) { if (!TypeResult.isInvalid()) {
Result = DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc, Result = DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc,
NameLoc.isValid() ? NameLoc : StartLoc, NameLoc.isValid() ? NameLoc : StartLoc,
PrevSpec, DiagID, TypeResult.get()); PrevSpec, DiagID, TypeResult.get(), Policy);
} else if (!TagOrTempResult.isInvalid()) { } else if (!TagOrTempResult.isInvalid()) {
Result = DS.SetTypeSpecType(TagType, StartLoc, Result = DS.SetTypeSpecType(TagType, StartLoc,
NameLoc.isValid() ? NameLoc : StartLoc, NameLoc.isValid() ? NameLoc : StartLoc,
PrevSpec, DiagID, TagOrTempResult.get(), Owned); PrevSpec, DiagID, TagOrTempResult.get(), Owned,
Policy);
} else { } else {
DS.SetTypeSpecError(); DS.SetTypeSpecError();
return; return;
@ -1634,8 +1641,9 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
if (TUK == Sema::TUK_Definition && if (TUK == Sema::TUK_Definition &&
(TemplateInfo.Kind || !isValidAfterTypeSpecifier(false))) { (TemplateInfo.Kind || !isValidAfterTypeSpecifier(false))) {
if (Tok.isNot(tok::semi)) { if (Tok.isNot(tok::semi)) {
const PrintingPolicy &PPol = Actions.getASTContext().getPrintingPolicy();
ExpectAndConsume(tok::semi, diag::err_expected_after, ExpectAndConsume(tok::semi, diag::err_expected_after,
DeclSpec::getSpecifierName(TagType)); DeclSpec::getSpecifierName(TagType, PPol));
// Push this token back into the preprocessor and change our current token // Push this token back into the preprocessor and change our current token
// to ';' so that the rest of the code recovers as though there were an // to ';' so that the rest of the code recovers as though there were an
// ';' after the definition. // ';' after the definition.

7
clang/lib/Parse/ParseExpr.cpp
View File

@ -30,6 +30,7 @@
#include "clang/Sema/TypoCorrection.h" #include "clang/Sema/TypoCorrection.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "clang/AST/ASTContext.h"
using namespace clang; using namespace clang;
/// \brief Simple precedence-based parser for binary/ternary operators. /// \brief Simple precedence-based parser for binary/ternary operators.
@ -790,7 +791,8 @@ ExprResult Parser::ParseCastExpression(bool isUnaryExpression,
DS.SetRangeEnd(ILoc); DS.SetRangeEnd(ILoc);
const char *PrevSpec = 0; const char *PrevSpec = 0;
unsigned DiagID; unsigned DiagID;
DS.SetTypeSpecType(TST_typename, ILoc, PrevSpec, DiagID, Typ); DS.SetTypeSpecType(TST_typename, ILoc, PrevSpec, DiagID, Typ,
Actions.getASTContext().getPrintingPolicy());
Declarator DeclaratorInfo(DS, Declarator::TypeNameContext); Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
TypeResult Ty = Actions.ActOnTypeName(getCurScope(), TypeResult Ty = Actions.ActOnTypeName(getCurScope(),
@ -955,7 +957,8 @@ ExprResult Parser::ParseCastExpression(bool isUnaryExpression,
const char *PrevSpec = 0; const char *PrevSpec = 0;
unsigned DiagID; unsigned DiagID;
DS.SetTypeSpecType(TST_typename, Tok.getAnnotationEndLoc(), DS.SetTypeSpecType(TST_typename, Tok.getAnnotationEndLoc(),
PrevSpec, DiagID, Type); PrevSpec, DiagID, Type,
Actions.getASTContext().getPrintingPolicy());
Declarator DeclaratorInfo(DS, Declarator::TypeNameContext); Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo); TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);

43
clang/lib/Parse/ParseExprCXX.cpp
View File

@ -10,6 +10,7 @@
// This file implements the Expression parsing implementation for C++. // This file implements the Expression parsing implementation for C++.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclTemplate.h" #include "clang/AST/DeclTemplate.h"
#include "RAIIObjectsForParser.h" #include "RAIIObjectsForParser.h"
#include "clang/Basic/PrettyStackTrace.h" #include "clang/Basic/PrettyStackTrace.h"
@ -1671,6 +1672,8 @@ void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
const char *PrevSpec; const char *PrevSpec;
unsigned DiagID; unsigned DiagID;
SourceLocation Loc = Tok.getLocation(); SourceLocation Loc = Tok.getLocation();
const clang::PrintingPolicy &Policy =
Actions.getASTContext().getPrintingPolicy();
switch (Tok.getKind()) { switch (Tok.getKind()) {
case tok::identifier: // foo::bar case tok::identifier: // foo::bar
@ -1683,7 +1686,7 @@ void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
case tok::annot_typename: { case tok::annot_typename: {
if (getTypeAnnotation(Tok)) if (getTypeAnnotation(Tok))
DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID,
getTypeAnnotation(Tok)); getTypeAnnotation(Tok), Policy);
else else
DS.SetTypeSpecError(); DS.SetTypeSpecError();
@ -1697,19 +1700,19 @@ void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
if (Tok.is(tok::less) && getLangOpts().ObjC1) if (Tok.is(tok::less) && getLangOpts().ObjC1)
ParseObjCProtocolQualifiers(DS); ParseObjCProtocolQualifiers(DS);
DS.Finish(Diags, PP); DS.Finish(Diags, PP, Policy);
return; return;
} }
// builtin types // builtin types
case tok::kw_short: case tok::kw_short:
DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID); DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID, Policy);
break; break;
case tok::kw_long: case tok::kw_long:
DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, DiagID); DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, DiagID, Policy);
break; break;
case tok::kw___int64: case tok::kw___int64:
DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, DiagID); DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, DiagID, Policy);
break; break;
case tok::kw_signed: case tok::kw_signed:
DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, DiagID); DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, DiagID);
@ -1718,47 +1721,47 @@ void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec, DiagID); DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec, DiagID);
break; break;
case tok::kw_void: case tok::kw_void:
DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID); DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID, Policy);
break; break;
case tok::kw_char: case tok::kw_char:
DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID); DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID, Policy);
break; break;
case tok::kw_int: case tok::kw_int:
DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID); DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID, Policy);
break; break;
case tok::kw___int128: case tok::kw___int128:
DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, DiagID); DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, DiagID, Policy);
break; break;
case tok::kw_half: case tok::kw_half:
DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID); DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID, Policy);
break; break;
case tok::kw_float: case tok::kw_float:
DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID); DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID, Policy);
break; break;
case tok::kw_double: case tok::kw_double:
DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID); DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID, Policy);
break; break;
case tok::kw_wchar_t: case tok::kw_wchar_t:
DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID); DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID, Policy);
break; break;
case tok::kw_char16_t: case tok::kw_char16_t:
DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID); DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID, Policy);
break; break;
case tok::kw_char32_t: case tok::kw_char32_t:
DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID); DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID, Policy);
break; break;
case tok::kw_bool: case tok::kw_bool:
DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID); DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID, Policy);
break; break;
case tok::annot_decltype: case tok::annot_decltype:
case tok::kw_decltype: case tok::kw_decltype:
DS.SetRangeEnd(ParseDecltypeSpecifier(DS)); DS.SetRangeEnd(ParseDecltypeSpecifier(DS));
return DS.Finish(Diags, PP); return DS.Finish(Diags, PP, Policy);
// GNU typeof support. // GNU typeof support.
case tok::kw_typeof: case tok::kw_typeof:
ParseTypeofSpecifier(DS); ParseTypeofSpecifier(DS);
DS.Finish(Diags, PP); DS.Finish(Diags, PP, Policy);
return; return;
} }
if (Tok.is(tok::annot_typename)) if (Tok.is(tok::annot_typename))
@ -1766,7 +1769,7 @@ void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
else else
DS.SetRangeEnd(Tok.getLocation()); DS.SetRangeEnd(Tok.getLocation());
ConsumeToken(); ConsumeToken();
DS.Finish(Diags, PP); DS.Finish(Diags, PP, Policy);
} }
/// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++ /// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++
@ -1782,7 +1785,7 @@ void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
/// ///
bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) { bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) {
ParseSpecifierQualifierList(DS, AS_none, DSC_type_specifier); ParseSpecifierQualifierList(DS, AS_none, DSC_type_specifier);
DS.Finish(Diags, PP); DS.Finish(Diags, PP, Actions.getASTContext().getPrintingPolicy());
return false; return false;
} }

11
clang/lib/Parse/Parser.cpp
View File

@ -15,6 +15,7 @@
#include "ParsePragma.h" #include "ParsePragma.h"
#include "RAIIObjectsForParser.h" #include "RAIIObjectsForParser.h"
#include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclTemplate.h" #include "clang/AST/DeclTemplate.h"
#include "clang/Parse/ParseDiagnostic.h" #include "clang/Parse/ParseDiagnostic.h"
#include "clang/Sema/DeclSpec.h" #include "clang/Sema/DeclSpec.h"
@ -246,7 +247,8 @@ void Parser::ConsumeExtraSemi(ExtraSemiKind Kind, unsigned TST) {
if (Kind != AfterMemberFunctionDefinition || HadMultipleSemis) if (Kind != AfterMemberFunctionDefinition || HadMultipleSemis)
Diag(StartLoc, diag::ext_extra_semi) Diag(StartLoc, diag::ext_extra_semi)
<< Kind << DeclSpec::getSpecifierName((DeclSpec::TST)TST) << Kind << DeclSpec::getSpecifierName((DeclSpec::TST)TST,
Actions.getASTContext().getPrintingPolicy())
<< FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc)); << FixItHint::CreateRemoval(SourceRange(StartLoc, EndLoc));
else else
// A single semicolon is valid after a member function definition. // A single semicolon is valid after a member function definition.
@ -930,7 +932,8 @@ Parser::ParseDeclOrFunctionDefInternal(ParsedAttributesWithRange &attrs,
const char *PrevSpec = 0; const char *PrevSpec = 0;
unsigned DiagID; unsigned DiagID;
if (DS.SetTypeSpecType(DeclSpec::TST_unspecified, AtLoc, PrevSpec, DiagID)) if (DS.SetTypeSpecType(DeclSpec::TST_unspecified, AtLoc, PrevSpec, DiagID,
Actions.getASTContext().getPrintingPolicy()))
Diag(AtLoc, DiagID) << PrevSpec; Diag(AtLoc, DiagID) << PrevSpec;
if (Tok.isObjCAtKeyword(tok::objc_protocol)) if (Tok.isObjCAtKeyword(tok::objc_protocol))
@ -1017,9 +1020,11 @@ Decl *Parser::ParseFunctionDefinition(ParsingDeclarator &D,
if (getLangOpts().ImplicitInt && D.getDeclSpec().isEmpty()) { if (getLangOpts().ImplicitInt && D.getDeclSpec().isEmpty()) {
const char *PrevSpec; const char *PrevSpec;
unsigned DiagID; unsigned DiagID;
const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy();
D.getMutableDeclSpec().SetTypeSpecType(DeclSpec::TST_int, D.getMutableDeclSpec().SetTypeSpecType(DeclSpec::TST_int,
D.getIdentifierLoc(), D.getIdentifierLoc(),
PrevSpec, DiagID); PrevSpec, DiagID,
Policy);
D.SetRangeBegin(D.getDeclSpec().getSourceRange().getBegin()); D.SetRangeBegin(D.getDeclSpec().getSourceRange().getBegin());
} }

78
clang/lib/Sema/DeclSpec.cpp
View File

@ -418,12 +418,13 @@ const char *DeclSpec::getSpecifierName(TSS S) {
llvm_unreachable("Unknown typespec!"); llvm_unreachable("Unknown typespec!");
} }
const char *DeclSpec::getSpecifierName(DeclSpec::TST T) { const char *DeclSpec::getSpecifierName(DeclSpec::TST T,
const PrintingPolicy &Policy) {
switch (T) { switch (T) {
case DeclSpec::TST_unspecified: return "unspecified"; case DeclSpec::TST_unspecified: return "unspecified";
case DeclSpec::TST_void: return "void"; case DeclSpec::TST_void: return "void";
case DeclSpec::TST_char: return "char"; case DeclSpec::TST_char: return "char";
case DeclSpec::TST_wchar: return "wchar_t"; case DeclSpec::TST_wchar: return Policy.MSWChar ? "__wchar_t" : "wchar_t";
case DeclSpec::TST_char16: return "char16_t"; case DeclSpec::TST_char16: return "char16_t";
case DeclSpec::TST_char32: return "char32_t"; case DeclSpec::TST_char32: return "char32_t";
case DeclSpec::TST_int: return "int"; case DeclSpec::TST_int: return "int";
@ -431,7 +432,7 @@ const char *DeclSpec::getSpecifierName(DeclSpec::TST T) {
case DeclSpec::TST_half: return "half"; case DeclSpec::TST_half: return "half";
case DeclSpec::TST_float: return "float"; case DeclSpec::TST_float: return "float";
case DeclSpec::TST_double: return "double"; case DeclSpec::TST_double: return "double";
case DeclSpec::TST_bool: return "_Bool"; case DeclSpec::TST_bool: return Policy.Bool ? "bool" : "_Bool";
case DeclSpec::TST_decimal32: return "_Decimal32"; case DeclSpec::TST_decimal32: return "_Decimal32";
case DeclSpec::TST_decimal64: return "_Decimal64"; case DeclSpec::TST_decimal64: return "_Decimal64";
case DeclSpec::TST_decimal128: return "_Decimal128"; case DeclSpec::TST_decimal128: return "_Decimal128";
@ -467,7 +468,8 @@ const char *DeclSpec::getSpecifierName(TQ T) {
bool DeclSpec::SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, bool DeclSpec::SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,
const char *&PrevSpec, const char *&PrevSpec,
unsigned &DiagID) { unsigned &DiagID,
const PrintingPolicy &Policy) {
// OpenCL v1.1 s6.8g: "The extern, static, auto and register storage-class // OpenCL v1.1 s6.8g: "The extern, static, auto and register storage-class
// specifiers are not supported. // specifiers are not supported.
// It seems sensible to prohibit private_extern too // It seems sensible to prohibit private_extern too
@ -502,10 +504,10 @@ bool DeclSpec::SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc,
bool isInvalid = true; bool isInvalid = true;
if (TypeSpecType == TST_unspecified && S.getLangOpts().CPlusPlus) { if (TypeSpecType == TST_unspecified && S.getLangOpts().CPlusPlus) {
if (SC == SCS_auto) if (SC == SCS_auto)
return SetTypeSpecType(TST_auto, Loc, PrevSpec, DiagID); return SetTypeSpecType(TST_auto, Loc, PrevSpec, DiagID, Policy);
if (StorageClassSpec == SCS_auto) { if (StorageClassSpec == SCS_auto) {
isInvalid = SetTypeSpecType(TST_auto, StorageClassSpecLoc, isInvalid = SetTypeSpecType(TST_auto, StorageClassSpecLoc,
PrevSpec, DiagID); PrevSpec, DiagID, Policy);
assert(!isInvalid && "auto SCS -> TST recovery failed"); assert(!isInvalid && "auto SCS -> TST recovery failed");
} }
} }
@ -541,7 +543,8 @@ bool DeclSpec::SetStorageClassSpecThread(TSCS TSC, SourceLocation Loc,
/// specified). /// specified).
bool DeclSpec::SetTypeSpecWidth(TSW W, SourceLocation Loc, bool DeclSpec::SetTypeSpecWidth(TSW W, SourceLocation Loc,
const char *&PrevSpec, const char *&PrevSpec,
unsigned &DiagID) { unsigned &DiagID,
const PrintingPolicy &Policy) {
// Overwrite TSWLoc only if TypeSpecWidth was unspecified, so that // Overwrite TSWLoc only if TypeSpecWidth was unspecified, so that
// for 'long long' we will keep the source location of the first 'long'. // for 'long long' we will keep the source location of the first 'long'.
if (TypeSpecWidth == TSW_unspecified) if (TypeSpecWidth == TSW_unspecified)
@ -552,7 +555,7 @@ bool DeclSpec::SetTypeSpecWidth(TSW W, SourceLocation Loc,
TypeSpecWidth = W; TypeSpecWidth = W;
if (TypeAltiVecVector && !TypeAltiVecBool && if (TypeAltiVecVector && !TypeAltiVecBool &&
((TypeSpecWidth == TSW_long) || (TypeSpecWidth == TSW_longlong))) { ((TypeSpecWidth == TSW_long) || (TypeSpecWidth == TSW_longlong))) {
PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType); PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
DiagID = diag::warn_vector_long_decl_spec_combination; DiagID = diag::warn_vector_long_decl_spec_combination;
return true; return true;
} }
@ -582,19 +585,21 @@ bool DeclSpec::SetTypeSpecSign(TSS S, SourceLocation Loc,
bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc, bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
const char *&PrevSpec, const char *&PrevSpec,
unsigned &DiagID, unsigned &DiagID,
ParsedType Rep) { ParsedType Rep,
return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep); const PrintingPolicy &Policy) {
return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Policy);
} }
bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc, bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
SourceLocation TagNameLoc, SourceLocation TagNameLoc,
const char *&PrevSpec, const char *&PrevSpec,
unsigned &DiagID, unsigned &DiagID,
ParsedType Rep) { ParsedType Rep,
const PrintingPolicy &Policy) {
assert(isTypeRep(T) && "T does not store a type"); assert(isTypeRep(T) && "T does not store a type");
assert(Rep && "no type provided!"); assert(Rep && "no type provided!");
if (TypeSpecType != TST_unspecified) { if (TypeSpecType != TST_unspecified) {
PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType); PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
DiagID = diag::err_invalid_decl_spec_combination; DiagID = diag::err_invalid_decl_spec_combination;
return true; return true;
} }
@ -609,11 +614,12 @@ bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc, bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
const char *&PrevSpec, const char *&PrevSpec,
unsigned &DiagID, unsigned &DiagID,
Expr *Rep) { Expr *Rep,
const PrintingPolicy &Policy) {
assert(isExprRep(T) && "T does not store an expr"); assert(isExprRep(T) && "T does not store an expr");
assert(Rep && "no expression provided!"); assert(Rep && "no expression provided!");
if (TypeSpecType != TST_unspecified) { if (TypeSpecType != TST_unspecified) {
PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType); PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
DiagID = diag::err_invalid_decl_spec_combination; DiagID = diag::err_invalid_decl_spec_combination;
return true; return true;
} }
@ -628,20 +634,22 @@ bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc, bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
const char *&PrevSpec, const char *&PrevSpec,
unsigned &DiagID, unsigned &DiagID,
Decl *Rep, bool Owned) { Decl *Rep, bool Owned,
return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Owned); const PrintingPolicy &Policy) {
return SetTypeSpecType(T, Loc, Loc, PrevSpec, DiagID, Rep, Owned, Policy);
} }
bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc, bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
SourceLocation TagNameLoc, SourceLocation TagNameLoc,
const char *&PrevSpec, const char *&PrevSpec,
unsigned &DiagID, unsigned &DiagID,
Decl *Rep, bool Owned) { Decl *Rep, bool Owned,
const PrintingPolicy &Policy) {
assert(isDeclRep(T) && "T does not store a decl"); assert(isDeclRep(T) && "T does not store a decl");
// Unlike the other cases, we don't assert that we actually get a decl. // Unlike the other cases, we don't assert that we actually get a decl.
if (TypeSpecType != TST_unspecified) { if (TypeSpecType != TST_unspecified) {
PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType); PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
DiagID = diag::err_invalid_decl_spec_combination; DiagID = diag::err_invalid_decl_spec_combination;
return true; return true;
} }
@ -655,11 +663,12 @@ bool DeclSpec::SetTypeSpecType(TST T, SourceLocation TagKwLoc,
bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc, bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
const char *&PrevSpec, const char *&PrevSpec,
unsigned &DiagID) { unsigned &DiagID,
const PrintingPolicy &Policy) {
assert(!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) && assert(!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) &&
"rep required for these type-spec kinds!"); "rep required for these type-spec kinds!");
if (TypeSpecType != TST_unspecified) { if (TypeSpecType != TST_unspecified) {
PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType); PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
DiagID = diag::err_invalid_decl_spec_combination; DiagID = diag::err_invalid_decl_spec_combination;
return true; return true;
} }
@ -672,7 +681,7 @@ bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
TypeSpecType = T; TypeSpecType = T;
TypeSpecOwned = false; TypeSpecOwned = false;
if (TypeAltiVecVector && !TypeAltiVecBool && (TypeSpecType == TST_double)) { if (TypeAltiVecVector && !TypeAltiVecBool && (TypeSpecType == TST_double)) {
PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType); PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
DiagID = diag::err_invalid_vector_decl_spec; DiagID = diag::err_invalid_vector_decl_spec;
return true; return true;
} }
@ -680,9 +689,10 @@ bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
} }
bool DeclSpec::SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc, bool DeclSpec::SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
const char *&PrevSpec, unsigned &DiagID) { const char *&PrevSpec, unsigned &DiagID,
const PrintingPolicy &Policy) {
if (TypeSpecType != TST_unspecified) { if (TypeSpecType != TST_unspecified) {
PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType); PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
DiagID = diag::err_invalid_vector_decl_spec_combination; DiagID = diag::err_invalid_vector_decl_spec_combination;
return true; return true;
} }
@ -692,10 +702,11 @@ bool DeclSpec::SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
} }
bool DeclSpec::SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc, bool DeclSpec::SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
const char *&PrevSpec, unsigned &DiagID) { const char *&PrevSpec, unsigned &DiagID,
const PrintingPolicy &Policy) {
if (!TypeAltiVecVector || TypeAltiVecPixel || if (!TypeAltiVecVector || TypeAltiVecPixel ||
(TypeSpecType != TST_unspecified)) { (TypeSpecType != TST_unspecified)) {
PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType); PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
DiagID = diag::err_invalid_pixel_decl_spec_combination; DiagID = diag::err_invalid_pixel_decl_spec_combination;
return true; return true;
} }
@ -706,10 +717,11 @@ bool DeclSpec::SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc,
} }
bool DeclSpec::SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc, bool DeclSpec::SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
const char *&PrevSpec, unsigned &DiagID) { const char *&PrevSpec, unsigned &DiagID,
const PrintingPolicy &Policy) {
if (!TypeAltiVecVector || TypeAltiVecBool || if (!TypeAltiVecVector || TypeAltiVecBool ||
(TypeSpecType != TST_unspecified)) { (TypeSpecType != TST_unspecified)) {
PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType); PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
DiagID = diag::err_invalid_vector_bool_decl_spec; DiagID = diag::err_invalid_vector_bool_decl_spec;
return true; return true;
} }
@ -901,7 +913,7 @@ void DeclSpec::SaveWrittenBuiltinSpecs() {
/// "_Imaginary" (lacking an FP type). This returns a diagnostic to issue or /// "_Imaginary" (lacking an FP type). This returns a diagnostic to issue or
/// diag::NUM_DIAGNOSTICS if there is no error. After calling this method, /// diag::NUM_DIAGNOSTICS if there is no error. After calling this method,
/// DeclSpec is guaranteed self-consistent, even if an error occurred. /// DeclSpec is guaranteed self-consistent, even if an error occurred.
void DeclSpec::Finish(DiagnosticsEngine &D, Preprocessor &PP) { void DeclSpec::Finish(DiagnosticsEngine &D, Preprocessor &PP, const PrintingPolicy &Policy) {
// Before possibly changing their values, save specs as written. // Before possibly changing their values, save specs as written.
SaveWrittenBuiltinSpecs(); SaveWrittenBuiltinSpecs();
@ -954,7 +966,7 @@ void DeclSpec::Finish(DiagnosticsEngine &D, Preprocessor &PP) {
(TypeSpecType != TST_int)) || TypeAltiVecPixel) { (TypeSpecType != TST_int)) || TypeAltiVecPixel) {
Diag(D, TSTLoc, diag::err_invalid_vector_bool_decl_spec) Diag(D, TSTLoc, diag::err_invalid_vector_bool_decl_spec)
<< (TypeAltiVecPixel ? "__pixel" : << (TypeAltiVecPixel ? "__pixel" :
getSpecifierName((TST)TypeSpecType)); getSpecifierName((TST)TypeSpecType, Policy));
} }
// Only 'short' is valid with vector bool. (PIM 2.1) // Only 'short' is valid with vector bool. (PIM 2.1)
@ -984,7 +996,7 @@ void DeclSpec::Finish(DiagnosticsEngine &D, Preprocessor &PP) {
else if (TypeSpecType != TST_int && TypeSpecType != TST_int128 && else if (TypeSpecType != TST_int && TypeSpecType != TST_int128 &&
TypeSpecType != TST_char && TypeSpecType != TST_wchar) { TypeSpecType != TST_char && TypeSpecType != TST_wchar) {
Diag(D, TSSLoc, diag::err_invalid_sign_spec) Diag(D, TSSLoc, diag::err_invalid_sign_spec)
<< getSpecifierName((TST)TypeSpecType); << getSpecifierName((TST)TypeSpecType, Policy);
// signed double -> double. // signed double -> double.
TypeSpecSign = TSS_unspecified; TypeSpecSign = TSS_unspecified;
} }
@ -1001,7 +1013,7 @@ void DeclSpec::Finish(DiagnosticsEngine &D, Preprocessor &PP) {
Diag(D, TSWLoc, Diag(D, TSWLoc,
TypeSpecWidth == TSW_short ? diag::err_invalid_short_spec TypeSpecWidth == TSW_short ? diag::err_invalid_short_spec
: diag::err_invalid_longlong_spec) : diag::err_invalid_longlong_spec)
<< getSpecifierName((TST)TypeSpecType); << getSpecifierName((TST)TypeSpecType, Policy);
TypeSpecType = TST_int; TypeSpecType = TST_int;
TypeSpecOwned = false; TypeSpecOwned = false;
} }
@ -1011,7 +1023,7 @@ void DeclSpec::Finish(DiagnosticsEngine &D, Preprocessor &PP) {
TypeSpecType = TST_int; // long -> long int. TypeSpecType = TST_int; // long -> long int.
else if (TypeSpecType != TST_int && TypeSpecType != TST_double) { else if (TypeSpecType != TST_int && TypeSpecType != TST_double) {
Diag(D, TSWLoc, diag::err_invalid_long_spec) Diag(D, TSWLoc, diag::err_invalid_long_spec)
<< getSpecifierName((TST)TypeSpecType); << getSpecifierName((TST)TypeSpecType, Policy);
TypeSpecType = TST_int; TypeSpecType = TST_int;
TypeSpecOwned = false; TypeSpecOwned = false;
} }
@ -1033,7 +1045,7 @@ void DeclSpec::Finish(DiagnosticsEngine &D, Preprocessor &PP) {
Diag(D, TSTLoc, diag::ext_integer_complex); Diag(D, TSTLoc, diag::ext_integer_complex);
} else if (TypeSpecType != TST_float && TypeSpecType != TST_double) { } else if (TypeSpecType != TST_float && TypeSpecType != TST_double) {
Diag(D, TSCLoc, diag::err_invalid_complex_spec) Diag(D, TSCLoc, diag::err_invalid_complex_spec)
<< getSpecifierName((TST)TypeSpecType); << getSpecifierName((TST)TypeSpecType, Policy);
TypeSpecComplex = TSC_unspecified; TypeSpecComplex = TSC_unspecified;
} }
} }

16
clang/lib/Sema/SemaDecl.cpp
View File

@ -3282,7 +3282,7 @@ Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
DS.getStorageClassSpec() != DeclSpec::SCS_typedef) { DS.getStorageClassSpec() != DeclSpec::SCS_typedef) {
if (getLangOpts().CPlusPlus || if (getLangOpts().CPlusPlus ||
Record->getDeclContext()->isRecord()) Record->getDeclContext()->isRecord())
return BuildAnonymousStructOrUnion(S, DS, AS, Record); return BuildAnonymousStructOrUnion(S, DS, AS, Record, Context.getPrintingPolicy());
DeclaresAnything = false; DeclaresAnything = false;
} }
@ -3584,8 +3584,9 @@ static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent,
/// (C++ [class.union]) and a C11 feature; anonymous structures /// (C++ [class.union]) and a C11 feature; anonymous structures
/// are a C11 feature and GNU C++ extension. /// are a C11 feature and GNU C++ extension.
Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
AccessSpecifier AS, AccessSpecifier AS,
RecordDecl *Record) { RecordDecl *Record,
const PrintingPolicy &Policy) {
DeclContext *Owner = Record->getDeclContext(); DeclContext *Owner = Record->getDeclContext();
// Diagnose whether this anonymous struct/union is an extension. // Diagnose whether this anonymous struct/union is an extension.
@ -3615,7 +3616,7 @@ Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
// Recover by adding 'static'. // Recover by adding 'static'.
DS.SetStorageClassSpec(*this, DeclSpec::SCS_static, SourceLocation(), DS.SetStorageClassSpec(*this, DeclSpec::SCS_static, SourceLocation(),
PrevSpec, DiagID); PrevSpec, DiagID, Policy);
} }
// C++ [class.union]p6: // C++ [class.union]p6:
// A storage class is not allowed in a declaration of an // A storage class is not allowed in a declaration of an
@ -3629,7 +3630,7 @@ Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
// Recover by removing the storage specifier. // Recover by removing the storage specifier.
DS.SetStorageClassSpec(*this, DeclSpec::SCS_unspecified, DS.SetStorageClassSpec(*this, DeclSpec::SCS_unspecified,
SourceLocation(), SourceLocation(),
PrevSpec, DiagID); PrevSpec, DiagID, Context.getPrintingPolicy());
} }
} }
@ -9405,7 +9406,7 @@ void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
const char* PrevSpec; // unused const char* PrevSpec; // unused
unsigned DiagID; // unused unsigned DiagID; // unused
DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc, DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc,
PrevSpec, DiagID); PrevSpec, DiagID, Context.getPrintingPolicy());
// Use the identifier location for the type source range. // Use the identifier location for the type source range.
DS.SetRangeStart(FTI.ArgInfo[i].IdentLoc); DS.SetRangeStart(FTI.ArgInfo[i].IdentLoc);
DS.SetRangeEnd(FTI.ArgInfo[i].IdentLoc); DS.SetRangeEnd(FTI.ArgInfo[i].IdentLoc);
@ -10018,7 +10019,8 @@ NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
AttributeFactory attrFactory; AttributeFactory attrFactory;
DeclSpec DS(attrFactory); DeclSpec DS(attrFactory);
unsigned DiagID; unsigned DiagID;
bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID); bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID,
Context.getPrintingPolicy());
(void)Error; // Silence warning. (void)Error; // Silence warning.
assert(!Error && "Error setting up implicit decl!"); assert(!Error && "Error setting up implicit decl!");
SourceLocation NoLoc; SourceLocation NoLoc;

3
clang/lib/Sema/SemaDeclCXX.cpp
View File

@ -1976,7 +1976,8 @@ Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
const char *PrevSpec; const char *PrevSpec;
unsigned DiagID; unsigned DiagID;
if (D.getMutableDeclSpec().SetStorageClassSpec( if (D.getMutableDeclSpec().SetStorageClassSpec(
*this, DeclSpec::SCS_static, ConstexprLoc, PrevSpec, DiagID)) { *this, DeclSpec::SCS_static, ConstexprLoc, PrevSpec, DiagID,
Context.getPrintingPolicy())) {
assert(DS.getStorageClassSpec() == DeclSpec::SCS_mutable && assert(DS.getStorageClassSpec() == DeclSpec::SCS_mutable &&
"This is the only DeclSpec that should fail to be applied"); "This is the only DeclSpec that should fail to be applied");
B << 1; B << 1;

6
clang/lib/Sema/SemaType.cpp
View File

@ -727,13 +727,15 @@ static QualType ConvertDeclSpecToType(TypeProcessingState &state) {
Result = Context.WCharTy; Result = Context.WCharTy;
else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed) { else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed) {
S.Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec) S.Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec)
<< DS.getSpecifierName(DS.getTypeSpecType()); << DS.getSpecifierName(DS.getTypeSpecType(),
Context.getPrintingPolicy());
Result = Context.getSignedWCharType(); Result = Context.getSignedWCharType();
} else { } else {
assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned && assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned &&
"Unknown TSS value"); "Unknown TSS value");
S.Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec) S.Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec)
<< DS.getSpecifierName(DS.getTypeSpecType()); << DS.getSpecifierName(DS.getTypeSpecType(),
Context.getPrintingPolicy());
Result = Context.getUnsignedWCharType(); Result = Context.getUnsignedWCharType();
} }
break; break;

21
clang/test/SemaCXX/pr9812.c Normal file
View File

@ -0,0 +1,21 @@
// RUN: %clang_cc1 -fsyntax-only -verify %s
#define bool _Bool
int test1(int argc, char** argv)
{
bool signed; // expected-error {{'bool' cannot be signed or unsigned}} expected-warning {{declaration does not declare anything}}
return 0;
}
#undef bool
typedef int bool;
int test2(int argc, char** argv)
{
bool signed; // expected-error {{'type-name' cannot be signed or unsigned}} expected-warning {{declaration does not declare anything}}
_Bool signed; // expected-error {{'_Bool' cannot be signed or unsigned}} expected-warning {{declaration does not declare anything}}
return 0;
}

9
clang/test/SemaCXX/pr9812.cpp Normal file
View File

@ -0,0 +1,9 @@
// RUN: %clang_cc1 -fsyntax-only -verify %s
int test(int, char**)
{
bool signed; // expected-error {{'bool' cannot be signed or unsigned}} expected-warning {{declaration does not declare anything}}
return 0;
}