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<struct S { int x; } *>(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

diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td
index 1c6c7f2e7cbba8102cc656d298e5d797ad7a3ddb..39feda96916a4868f38fc8e1d6a8ceb79fbb3cab 100644 (file)
--- 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 8fa9f8cc49ba8bbc02df0a790036d2b14491a181..86e319483640cbb83dfd2280a52866034eb23cc9 100644 (file)
--- 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 efb7d65c2df585463b44836e3bf705f9d1de66fd..9cccd5ebaff9692845fb726376d6fa2e8e856b92 100644 (file)
--- 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 e9aece968fd8afa369dcdc2308dd2fff29531179..73530ef58d86c487c558d2f8339078c29765be7a 100644 (file)
--- 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 e592deecd0439f2dbdcee0e1e23e1e280eba7a93..2a765d212486a6c28a3e1609c13a45a4990276b1 100644 (file)
--- 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 59e9555a88925a801878e016436fff2a0cf61903..54e70be16ec6353775040d2d69dfab1fc066369c 100644 (file)
--- 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<void>()))
+                         TagDecl.getAs<void>(), Owned))
     Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec;
 }
 

diff --git a/lib/Parse/ParseDeclCXX.cpp b/lib/Parse/ParseDeclCXX.cpp
index a7d3b52bd2393309cebe4def4a42239f3b7ab805..cfbd9097f72f7b8bc4cb03411cd6a35329d929da 100644 (file)
--- 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<void>()))
+                         TagOrTempResult.get().getAs<void>(), 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 0a285bd3095028e8b66b85306ecfdc43b0df6cdf..fae5a927478ba5b78d645010b9846d208024c89a 100644 (file)
--- 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 7b36b13416752c0693948826dd0da65718dc8374..6a2e3099cd2bbe257d6b668651b0e3f4a981f242 100644 (file)
--- 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 b15ce295ea2c94ddfa48de4defbad37df45bd7f8..179e27d8b7a63b3268bce51744e242c71c176f64 100644 (file)
--- 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 298a6cddda268b6611e61eb1b51c5fc0feef6de7..83f9b60fd7f66878aa325a74a8453470e3a1fbe3 100644 (file)
--- 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<TagDecl>((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<TagDecl>((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 (file)
index 0000000..60c28b0
--- /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<struct S4 { int x; } *>(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}}