From 402abb55fc2e0cdda5fb1ac90009b1f5f6774906 Mon Sep 17 00:00:00 2001 From: Douglas Gregor Date: Thu, 28 May 2009 23:31:59 +0000 Subject: [PATCH] When we parse a tag specifier, keep track of whether that tag specifier resulted in the creation of a new TagDecl node, which happens either when the tag specifier was a definition or when the tag specifier was the first declaration of that tag type. This information has several uses, the first of which is implemented in this commit: 1) In C++, one is not allowed to define tag types within a type specifier (e.g., static_cast(0) is ill-formed) or within the result or parameter types of a function. We now diagnose this. 2) We can extend DeclGroups to contain information about any tags that are declared/defined within the declaration specifiers of a variable, e.g., struct Point { int x, y, z; } p; This will help improve AST printing and template instantiation, among other things. 3) For C99, we can keep track of whether a tag type is defined within the type of a parameter, to properly cope with cases like, e.g., int bar(struct T2 { int x; } y) { struct T2 z; } We can also do similar things wherever there is a type specifier, e.g., to keep track of where the definition of S occurs in this legal C99 code: (struct S { int x, y; } *)0 git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@72555 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/Basic/DiagnosticSemaKinds.td | 7 ++++ include/clang/Parse/Action.h | 3 +- include/clang/Parse/DeclSpec.h | 9 +++-- lib/Frontend/PrintParserCallbacks.cpp | 3 +- lib/Parse/DeclSpec.cpp | 4 ++- lib/Parse/ParseDecl.cpp | 6 ++-- lib/Parse/ParseDeclCXX.cpp | 5 +-- lib/Sema/Sema.h | 6 ++-- lib/Sema/SemaDecl.cpp | 15 ++++++-- lib/Sema/SemaTemplate.cpp | 3 +- lib/Sema/SemaType.cpp | 34 ++++++++++++++++--- test/SemaCXX/type-definition-in-specifier.cpp | 25 ++++++++++++++ 12 files changed, 101 insertions(+), 19 deletions(-) create mode 100644 test/SemaCXX/type-definition-in-specifier.cpp diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td index 1c6c7f2e7c..39feda9691 100644 --- a/include/clang/Basic/DiagnosticSemaKinds.td +++ b/include/clang/Basic/DiagnosticSemaKinds.td @@ -253,6 +253,13 @@ def err_abstract_type_in_decl : Error< def err_allocation_of_abstract_type : Error< "allocation of an object of abstract type %0">; +def err_type_defined_in_type_specifier : Error< + "%0 can not be defined in a type specifier">; +def err_type_defined_in_result_type : Error< + "%0 can not be defined in the result type of a function">; +def err_type_defined_in_param_type : Error< + "%0 can not be defined in a parameter type">; + def note_pure_virtual_function : Note< "pure virtual function %0">; diff --git a/include/clang/Parse/Action.h b/include/clang/Parse/Action.h index 8fa9f8cc49..86e3194836 100644 --- a/include/clang/Parse/Action.h +++ b/include/clang/Parse/Action.h @@ -397,7 +397,8 @@ public: virtual DeclPtrTy ActOnTag(Scope *S, unsigned TagSpec, TagKind TK, SourceLocation KWLoc, const CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, - AttributeList *Attr, AccessSpecifier AS) { + AttributeList *Attr, AccessSpecifier AS, + bool &OwnedDecl) { // TagType is an instance of DeclSpec::TST, indicating what kind of tag this // is (struct/union/enum/class). return DeclPtrTy(); diff --git a/include/clang/Parse/DeclSpec.h b/include/clang/Parse/DeclSpec.h index efb7d65c2d..9cccd5ebaf 100644 --- a/include/clang/Parse/DeclSpec.h +++ b/include/clang/Parse/DeclSpec.h @@ -114,7 +114,8 @@ private: /*TSC*/unsigned TypeSpecComplex : 2; /*TSS*/unsigned TypeSpecSign : 2; /*TST*/unsigned TypeSpecType : 5; - + bool TypeSpecOwned : 1; + // type-qualifiers unsigned TypeQualifiers : 3; // Bitwise OR of TQ. @@ -129,7 +130,7 @@ private: /// TypeRep - This contains action-specific information about a specific TST. /// For example, for a typedef or struct, it might contain the declaration for /// these. - ActionBase::TypeTy *TypeRep; + void *TypeRep; // attributes. AttributeList *AttrList; @@ -168,6 +169,7 @@ public: TypeSpecComplex(TSC_unspecified), TypeSpecSign(TSS_unspecified), TypeSpecType(TST_unspecified), + TypeSpecOwned(false), TypeQualifiers(TSS_unspecified), FS_inline_specified(false), FS_virtual_specified(false), @@ -201,6 +203,7 @@ public: TSC getTypeSpecComplex() const { return (TSC)TypeSpecComplex; } TSS getTypeSpecSign() const { return (TSS)TypeSpecSign; } TST getTypeSpecType() const { return (TST)TypeSpecType; } + bool isTypeSpecOwned() const { return TypeSpecOwned; } void *getTypeRep() const { return TypeRep; } const SourceRange &getSourceRange() const { return Range; } @@ -272,7 +275,7 @@ public: bool SetTypeSpecComplex(TSC C, SourceLocation Loc, const char *&PrevSpec); bool SetTypeSpecSign(TSS S, SourceLocation Loc, const char *&PrevSpec); bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, - void *Rep = 0); + void *Rep = 0, bool Owned = false); bool SetTypeSpecError(); bool SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec, diff --git a/lib/Frontend/PrintParserCallbacks.cpp b/lib/Frontend/PrintParserCallbacks.cpp index e9aece968f..73530ef58d 100644 --- a/lib/Frontend/PrintParserCallbacks.cpp +++ b/lib/Frontend/PrintParserCallbacks.cpp @@ -195,7 +195,8 @@ namespace { virtual DeclPtrTy ActOnTag(Scope *S, unsigned TagType, TagKind TK, SourceLocation KWLoc, const CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, - AttributeList *Attr, AccessSpecifier AS) { + AttributeList *Attr, AccessSpecifier AS, + bool &Owned) { // TagType is an instance of DeclSpec::TST, indicating what kind of tag this // is (struct/union/enum/class). Out << __FUNCTION__ << "\n"; diff --git a/lib/Parse/DeclSpec.cpp b/lib/Parse/DeclSpec.cpp index e592deecd0..2a765d2124 100644 --- a/lib/Parse/DeclSpec.cpp +++ b/lib/Parse/DeclSpec.cpp @@ -241,12 +241,14 @@ bool DeclSpec::SetTypeSpecSign(TSS S, SourceLocation Loc, } bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc, - const char *&PrevSpec, void *Rep) { + const char *&PrevSpec, void *Rep, + bool Owned) { if (TypeSpecType != TST_unspecified) return BadSpecifier((TST)TypeSpecType, PrevSpec); TypeSpecType = T; TypeRep = Rep; TSTLoc = Loc; + TypeSpecOwned = Owned; return false; } diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp index 59e9555a88..54e70be16e 100644 --- a/lib/Parse/ParseDecl.cpp +++ b/lib/Parse/ParseDecl.cpp @@ -1460,8 +1460,10 @@ void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS, TK = Action::TK_Declaration; else TK = Action::TK_Reference; + bool Owned = false; DeclPtrTy TagDecl = Actions.ActOnTag(CurScope, DeclSpec::TST_enum, TK, - StartLoc, SS, Name, NameLoc, Attr, AS); + StartLoc, SS, Name, NameLoc, Attr, AS, + Owned); if (Tok.is(tok::l_brace)) ParseEnumBody(StartLoc, TagDecl); @@ -1469,7 +1471,7 @@ void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS, // TODO: semantic analysis on the declspec for enums. const char *PrevSpec = 0; if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc, PrevSpec, - TagDecl.getAs())) + TagDecl.getAs(), Owned)) Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec; } diff --git a/lib/Parse/ParseDeclCXX.cpp b/lib/Parse/ParseDeclCXX.cpp index a7d3b52bd2..cfbd9097f7 100644 --- a/lib/Parse/ParseDeclCXX.cpp +++ b/lib/Parse/ParseDeclCXX.cpp @@ -479,6 +479,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind, // FIXME: When TK == TK_Reference and we have a template-id, we need // to turn that template-id into a type. + bool Owned = false; if (TemplateId && TK != Action::TK_Reference) { // Explicit specialization, class template partial specialization, // or explicit instantiation. @@ -582,7 +583,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind, // Declaration or definition of a class type TagOrTempResult = Actions.ActOnTag(CurScope, TagType, TK, StartLoc, SS, - Name, NameLoc, Attr, AS); + Name, NameLoc, Attr, AS, Owned); } // Parse the optional base clause (C++ only). @@ -608,7 +609,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind, } if (DS.SetTypeSpecType(TagType, StartLoc, PrevSpec, - TagOrTempResult.get().getAs())) + TagOrTempResult.get().getAs(), Owned)) Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec; if (DS.isFriendSpecified()) diff --git a/lib/Sema/Sema.h b/lib/Sema/Sema.h index 0a285bd309..fae5a92747 100644 --- a/lib/Sema/Sema.h +++ b/lib/Sema/Sema.h @@ -346,7 +346,8 @@ public: QualType *ParamTypes, unsigned NumParamTypes, bool Variadic, unsigned Quals, SourceLocation Loc, DeclarationName Entity); - QualType GetTypeForDeclarator(Declarator &D, Scope *S, unsigned Skip = 0); + QualType GetTypeForDeclarator(Declarator &D, Scope *S, unsigned Skip = 0, + TagDecl **OwnedDecl = 0); DeclarationName GetNameForDeclarator(Declarator &D); QualType ObjCGetTypeForMethodDefinition(DeclPtrTy D); @@ -444,7 +445,8 @@ public: virtual DeclPtrTy ActOnTag(Scope *S, unsigned TagSpec, TagKind TK, SourceLocation KWLoc, const CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, - AttributeList *Attr, AccessSpecifier AS); + AttributeList *Attr, AccessSpecifier AS, + bool &OwnedDecl); virtual void ActOnDefs(Scope *S, DeclPtrTy TagD, SourceLocation DeclStart, IdentifierInfo *ClassName, diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp index 7b36b13416..6a2e3099cd 100644 --- a/lib/Sema/SemaDecl.cpp +++ b/lib/Sema/SemaDecl.cpp @@ -2835,8 +2835,16 @@ Sema::ActOnParamDeclarator(Scope *S, Declarator &D) { if (getLangOptions().CPlusPlus) CheckExtraCXXDefaultArguments(D); - QualType parmDeclType = GetTypeForDeclarator(D, S); + TagDecl *OwnedDecl = 0; + QualType parmDeclType = GetTypeForDeclarator(D, S, /*Skip=*/0, &OwnedDecl); + if (getLangOptions().CPlusPlus && OwnedDecl && OwnedDecl->isDefinition()) { + // C++ [dcl.fct]p6: + // Types shall not be defined in return or parameter types. + Diag(OwnedDecl->getLocation(), diag::err_type_defined_in_param_type) + << Context.getTypeDeclType(OwnedDecl); + } + // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope. // Can this happen for params? We already checked that they don't conflict // among each other. Here they can only shadow globals, which is ok. @@ -3316,11 +3324,13 @@ bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous, Sema::DeclPtrTy Sema::ActOnTag(Scope *S, unsigned TagSpec, TagKind TK, SourceLocation KWLoc, const CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, - AttributeList *Attr, AccessSpecifier AS) { + AttributeList *Attr, AccessSpecifier AS, + bool &OwnedDecl) { // If this is not a definition, it must have a name. assert((Name != 0 || TK == TK_Definition) && "Nameless record must be a definition!"); + OwnedDecl = false; TagDecl::TagKind Kind; switch (TagSpec) { default: assert(0 && "Unknown tag type!"); @@ -3645,6 +3655,7 @@ CreateNewDecl: CurContext->addDecl(Context, New); } + OwnedDecl = true; return DeclPtrTy::make(New); } diff --git a/lib/Sema/SemaTemplate.cpp b/lib/Sema/SemaTemplate.cpp index b15ce295ea..179e27d8b7 100644 --- a/lib/Sema/SemaTemplate.cpp +++ b/lib/Sema/SemaTemplate.cpp @@ -2357,8 +2357,9 @@ Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation TemplateLoc, SourceLocation NameLoc, AttributeList *Attr) { + bool Owned = false; DeclPtrTy TagD = ActOnTag(S, TagSpec, Action::TK_Reference, - KWLoc, SS, Name, NameLoc, Attr, AS_none); + KWLoc, SS, Name, NameLoc, Attr, AS_none, Owned); if (!TagD) return true; diff --git a/lib/Sema/SemaType.cpp b/lib/Sema/SemaType.cpp index 298a6cddda..83f9b60fd7 100644 --- a/lib/Sema/SemaType.cpp +++ b/lib/Sema/SemaType.cpp @@ -604,7 +604,12 @@ QualType Sema::BuildFunctionType(QualType T, /// GetTypeForDeclarator - Convert the type for the specified /// declarator to Type instances. Skip the outermost Skip type /// objects. -QualType Sema::GetTypeForDeclarator(Declarator &D, Scope *S, unsigned Skip) { +/// +/// If OwnedDecl is non-NULL, and this declarator's decl-specifier-seq +/// owns the declaration of a type (e.g., the definition of a struct +/// type), then *OwnedDecl will receive the owned declaration. +QualType Sema::GetTypeForDeclarator(Declarator &D, Scope *S, unsigned Skip, + TagDecl **OwnedDecl) { bool OmittedReturnType = false; if (D.getContext() == Declarator::BlockLiteralContext @@ -637,6 +642,8 @@ QualType Sema::GetTypeForDeclarator(Declarator &D, Scope *S, unsigned Skip) { T = ConvertDeclSpecToType(DS, D.getIdentifierLoc(), isInvalid); if (isInvalid) D.setInvalidType(true); + else if (OwnedDecl && DS.isTypeSpecOwned()) + *OwnedDecl = cast((Decl *)DS.getTypeRep()); } break; } @@ -717,6 +724,15 @@ QualType Sema::GetTypeForDeclarator(Declarator &D, Scope *S, unsigned Skip) { D.setInvalidType(true); } + if (getLangOptions().CPlusPlus && D.getDeclSpec().isTypeSpecOwned()) { + // C++ [dcl.fct]p6: + // Types shall not be defined in return or parameter types. + TagDecl *Tag = cast((Decl *)D.getDeclSpec().getTypeRep()); + if (Tag->isDefinition()) + Diag(Tag->getLocation(), diag::err_type_defined_in_result_type) + << Context.getTypeDeclType(Tag); + } + if (FTI.NumArgs == 0) { if (getLangOptions().CPlusPlus) { // C++ 8.3.5p2: If the parameter-declaration-clause is empty, the @@ -971,14 +987,24 @@ Sema::TypeResult Sema::ActOnTypeName(Scope *S, Declarator &D) { // the parser. assert(D.getIdentifier() == 0 && "Type name should have no identifier!"); - QualType T = GetTypeForDeclarator(D, S); + TagDecl *OwnedTag = 0; + QualType T = GetTypeForDeclarator(D, S, /*Skip=*/0, &OwnedTag); if (D.isInvalidType()) return true; - // Check that there are no default arguments (C++ only). - if (getLangOptions().CPlusPlus) + if (getLangOptions().CPlusPlus) { + // Check that there are no default arguments (C++ only). CheckExtraCXXDefaultArguments(D); + // C++0x [dcl.type]p3: + // A type-specifier-seq shall not define a class or enumeration + // unless it appears in the type-id of an alias-declaration + // (7.1.3). + if (OwnedTag && OwnedTag->isDefinition()) + Diag(OwnedTag->getLocation(), diag::err_type_defined_in_type_specifier) + << Context.getTypeDeclType(OwnedTag); + } + return T.getAsOpaquePtr(); } diff --git a/test/SemaCXX/type-definition-in-specifier.cpp b/test/SemaCXX/type-definition-in-specifier.cpp new file mode 100644 index 0000000000..60c28b0f5e --- /dev/null +++ b/test/SemaCXX/type-definition-in-specifier.cpp @@ -0,0 +1,25 @@ +// RUN: clang-cc -fsyntax-only -verify %s + +struct S0; +struct S1; +struct S2; +struct S3; +struct S4; +struct S5; +struct S6; + +struct S0 { int x; }; + +void f0() { + typedef struct S1 { int x; } S1_typedef; + + (void)((struct S2 { int x; }*)0); // expected-error{{can not be defined}} + + struct S3 { int x; } s3; + + (void)static_cast(0); // expected-error{{can not be defined}} +} + +struct S5 { int x; } f1() { return S5(); } // expected-error{{result type}} + +void f2(struct S6 { int x; } p); // expected-error{{parameter type}} -- 2.40.0