Rename Action::TagKind to Action::TagUseKind, which removes both a misnomer

and a name collision.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@77658 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/Parse/Action.h b/include/clang/Parse/Action.h
index abab82ec9136f48e339ba4af13dded3b8c0dc2cb..bfe90d98b79b3d927a2c6750ab2e8cff798064b7 100644 (file)
--- a/include/clang/Parse/Action.h
+++ b/include/clang/Parse/Action.h
@@ -410,10 +410,10 @@ public:
     return TypeResult();
   }
   
-  enum TagKind {
-    TK_Reference,   // Reference to a tag:  'struct foo *X;'
-    TK_Declaration, // Fwd decl of a tag:   'struct foo;'
-    TK_Definition   // Definition of a tag: 'struct foo { int X; } Y;'
+  enum TagUseKind {
+    TUK_Reference,   // Reference to a tag:  'struct foo *X;'
+    TUK_Declaration, // Fwd decl of a tag:   'struct foo;'
+    TUK_Definition   // Definition of a tag: 'struct foo { int X; } Y;'
   };
 
   /// \brief The parser has encountered a tag (e.g., "class X") that should be
@@ -424,9 +424,10 @@ public:
   /// \param TagSpec an instance of DeclSpec::TST, indicating what kind of tag 
   /// this is (struct/union/enum/class).
   ///
-  /// \param TK the kind of tag we have encountered, which can be a reference
-  /// to a (possibly pre-existing) tag, a declaration of that tag, or the
-  /// beginning of a definition of that tag.
+  /// \param TUK how the tag we have encountered is being used, which
+  /// can be a reference to a (possibly pre-existing) tag, a
+  /// declaration of that tag, or the beginning of a definition of
+  /// that tag.
   ///
   /// \param KWLoc the location of the "struct", "class", "union", or "enum" 
   /// keyword.
@@ -456,7 +457,7 @@ public:
   /// by the action module.
   ///
   /// \returns the declaration to which this tag refers.
-  virtual DeclPtrTy ActOnTag(Scope *S, unsigned TagSpec, TagKind TK,
+  virtual DeclPtrTy ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
                              SourceLocation KWLoc, const CXXScopeSpec &SS,
                              IdentifierInfo *Name, SourceLocation NameLoc,
                              AttributeList *Attr, AccessSpecifier AS,
@@ -1478,7 +1479,7 @@ public:
   /// \param TagSpec whether this declares a class, struct, or union
   /// (template)
   ///
-  /// \param TK whether this is a declaration or a definition
+  /// \param TUK whether this is a declaration or a definition
   /// 
   /// \param KWLoc the location of the 'class', 'struct', or 'union'
   /// keyword.
@@ -1498,7 +1499,7 @@ public:
   /// parameter lists (such as a missing \c template<> prior to a
   /// specialization); the parser does not check this condition.
   virtual DeclResult
-  ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagKind TK,
+  ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagUseKind TUK,
                                    SourceLocation KWLoc, 
                                    const CXXScopeSpec &SS,
                                    TemplateTy Template,

diff --git a/lib/Frontend/PrintParserCallbacks.cpp b/lib/Frontend/PrintParserCallbacks.cpp
index 51693cc00dfb9eb10643dcb6d5f8a21d474dbca7..4231d66ef86344183da5f4883405a49c00c18033 100644 (file)
--- a/lib/Frontend/PrintParserCallbacks.cpp
+++ b/lib/Frontend/PrintParserCallbacks.cpp
@@ -193,7 +193,7 @@ namespace {
       return TypeResult();
     }
   
-    virtual DeclPtrTy ActOnTag(Scope *S, unsigned TagType, TagKind TK,
+    virtual DeclPtrTy ActOnTag(Scope *S, unsigned TagType, TagUseKind TUK,
                                SourceLocation KWLoc, const CXXScopeSpec &SS,
                                IdentifierInfo *Name, SourceLocation NameLoc,
                                AttributeList *Attr, AccessSpecifier AS,

diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
index 27f3293aca3acfe56c1560bb74ed64d87bc27459..1365282ee1216f38ee76a94fd73e2eb4fc0f1628 100644 (file)
--- a/lib/Parse/ParseDecl.cpp
+++ b/lib/Parse/ParseDecl.cpp
@@ -1577,15 +1577,15 @@ void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS,
   // enum foo {..};  void bar() { enum foo; }    <- new foo in bar.
   // enum foo {..};  void bar() { enum foo x; }  <- use of old foo.
   //
-  Action::TagKind TK;
+  Action::TagUseKind TUK;
   if (Tok.is(tok::l_brace))
-    TK = Action::TK_Definition;
+    TUK = Action::TUK_Definition;
   else if (Tok.is(tok::semi))
-    TK = Action::TK_Declaration;
+    TUK = Action::TUK_Declaration;
   else
-    TK = Action::TK_Reference;
+    TUK = Action::TUK_Reference;
   bool Owned = false;
-  DeclPtrTy TagDecl = Actions.ActOnTag(CurScope, DeclSpec::TST_enum, TK,
+  DeclPtrTy TagDecl = Actions.ActOnTag(CurScope, DeclSpec::TST_enum, TUK,
                                        StartLoc, SS, Name, NameLoc, Attr, AS,
                                        Action::MultiTemplateParamsArg(Actions),
                                        Owned);

diff --git a/lib/Parse/ParseDeclCXX.cpp b/lib/Parse/ParseDeclCXX.cpp
index f28ffe350940219896b2d2f1d2957f9e23e76d3b..176cb35889d43c9ccadf84ce8068ae51d956abff 100644 (file)
--- a/lib/Parse/ParseDeclCXX.cpp
+++ b/lib/Parse/ParseDeclCXX.cpp
@@ -570,15 +570,15 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
   // this is a forward declaration.  If we have 'struct foo {...' or
   // 'struct foo :...' then this is a definition. Otherwise we have
   // something like 'struct foo xyz', a reference.
-  Action::TagKind TK;
+  Action::TagUseKind TUK;
   if (Tok.is(tok::l_brace) || (getLang().CPlusPlus && Tok.is(tok::colon)))
-    TK = Action::TK_Definition;
+    TUK = Action::TUK_Definition;
   else if (Tok.is(tok::semi) && !DS.isFriendSpecified())
-    TK = Action::TK_Declaration;
+    TUK = Action::TUK_Declaration;
   else
-    TK = Action::TK_Reference;
+    TUK = Action::TUK_Reference;
 
-  if (!Name && !TemplateId && TK != Action::TK_Definition) {
+  if (!Name && !TemplateId && TUK != Action::TUK_Definition) {
     // We have a declaration or reference to an anonymous class.
     Diag(StartLoc, diag::err_anon_type_definition)
       << DeclSpec::getSpecifierName(TagType);
@@ -595,11 +595,11 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
   Action::DeclResult TagOrTempResult;
   TemplateParameterLists *TemplateParams = TemplateInfo.TemplateParams;
 
-  // FIXME: When TK == TK_Reference and we have a template-id, we need
+  // FIXME: When TUK == TUK_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) {
+  if (TemplateId && TUK != Action::TUK_Reference) {
     // Explicit specialization, class template partial specialization,
     // or explicit instantiation.
     ASTTemplateArgsPtr TemplateArgsPtr(Actions, 
@@ -607,7 +607,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
                                        TemplateId->getTemplateArgIsType(),
                                        TemplateId->NumArgs);
     if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation &&
-        TK == Action::TK_Declaration) {
+        TUK == Action::TUK_Declaration) {
       // This is an explicit instantiation of a class template.
       TagOrTempResult
         = Actions.ActOnExplicitInstantiation(CurScope, 
@@ -636,7 +636,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
         // but it actually has a definition. Most likely, this was
         // meant to be an explicit specialization, but the user forgot
         // the '<>' after 'template'.
-        assert(TK == Action::TK_Definition && "Expected a definition here");
+        assert(TUK == Action::TUK_Definition && "Expected a definition here");
 
         SourceLocation LAngleLoc 
           = PP.getLocForEndOfToken(TemplateInfo.TemplateLoc);
@@ -659,7 +659,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
 
       // Build the class template specialization.
       TagOrTempResult
-        = Actions.ActOnClassTemplateSpecialization(CurScope, TagType, TK,
+        = Actions.ActOnClassTemplateSpecialization(CurScope, TagType, TUK,
                        StartLoc, SS,
                        TemplateTy::make(TemplateId->Template), 
                        TemplateId->TemplateNameLoc, 
@@ -674,7 +674,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
     }
     TemplateId->Destroy();
   } else if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation &&
-             TK == Action::TK_Declaration) {
+             TUK == Action::TUK_Declaration) {
     // Explicit instantiation of a member of a class template
     // specialization, e.g.,
     //
@@ -687,12 +687,12 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
                                            NameLoc, Attr);
   } else {
     if (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation &&
-        TK == Action::TK_Definition) {
+        TUK == Action::TUK_Definition) {
       // FIXME: Diagnose this particular error.
     }
 
     // Declaration or definition of a class type
-    TagOrTempResult = Actions.ActOnTag(CurScope, TagType, TK, StartLoc, SS, 
+    TagOrTempResult = Actions.ActOnTag(CurScope, TagType, TUK, StartLoc, SS, 
                                        Name, NameLoc, Attr, AS,
                                   Action::MultiTemplateParamsArg(Actions, 
                                     TemplateParams? &(*TemplateParams)[0] : 0,
@@ -710,7 +710,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
       ParseCXXMemberSpecification(StartLoc, TagType, TagOrTempResult.get());
     else
       ParseStructUnionBody(StartLoc, TagType, TagOrTempResult.get());
-  else if (TK == Action::TK_Definition) {
+  else if (TUK == Action::TUK_Definition) {
     // FIXME: Complain that we have a base-specifier list but no
     // definition.
     Diag(Tok, diag::err_expected_lbrace);

diff --git a/lib/Sema/Sema.h b/lib/Sema/Sema.h
index 989dc76a706fb1a0751d3763e520d467e4f935b0..e41172a0d55a2966cf6b3cf2b0a13565ad12f64f 100644 (file)
--- a/lib/Sema/Sema.h
+++ b/lib/Sema/Sema.h
@@ -542,7 +542,7 @@ public:
                                     SourceLocation NewTagLoc,
                                     const IdentifierInfo &Name);
 
-  virtual DeclPtrTy ActOnTag(Scope *S, unsigned TagSpec, TagKind TK,
+  virtual DeclPtrTy ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
                              SourceLocation KWLoc, const CXXScopeSpec &SS,
                              IdentifierInfo *Name, SourceLocation NameLoc,
                              AttributeList *Attr, AccessSpecifier AS,
@@ -2129,7 +2129,7 @@ public:
                                           TemplateParameterList **ParamLists,
                                           unsigned NumParamLists);
                                                 
-  DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagKind TK,
+  DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
                                 SourceLocation KWLoc, const CXXScopeSpec &SS,
                                 IdentifierInfo *Name, SourceLocation NameLoc,
                                 AttributeList *Attr,
@@ -2182,7 +2182,7 @@ public:
                                         bool &MirrorsPrimaryTemplate);
 
   virtual DeclResult
-  ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagKind TK,
+  ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagUseKind TUK,
                                    SourceLocation KWLoc, 
                                    const CXXScopeSpec &SS,
                                    TemplateTy Template,

diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index 4c310aaa072d45c734e08dccaaa6d7013b7f0e95..58df38b6457f3cf867b5778f5753fe93ecabd8e3 100644 (file)
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -3851,16 +3851,16 @@ bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous,
 
 /// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'.  In the
 /// former case, Name will be non-null.  In the later case, Name will be null.
-/// TagSpec indicates what kind of tag this is. TK indicates whether this is a
+/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a
 /// reference/declaration/definition of a tag.
-Sema::DeclPtrTy Sema::ActOnTag(Scope *S, unsigned TagSpec, TagKind TK,
+Sema::DeclPtrTy Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
                                SourceLocation KWLoc, const CXXScopeSpec &SS,
                                IdentifierInfo *Name, SourceLocation NameLoc,
                                AttributeList *Attr, AccessSpecifier AS,
                                MultiTemplateParamsArg TemplateParameterLists,
                                bool &OwnedDecl) {
   // If this is not a definition, it must have a name.
-  assert((Name != 0 || TK == TK_Definition) &&
+  assert((Name != 0 || TUK == TUK_Definition) &&
          "Nameless record must be a definition!");
 
   OwnedDecl = false;
@@ -3873,7 +3873,7 @@ Sema::DeclPtrTy Sema::ActOnTag(Scope *S, unsigned TagSpec, TagKind TK,
   case DeclSpec::TST_enum:   Kind = TagDecl::TK_enum; break;
   }
   
-  if (TK != TK_Reference) {
+  if (TUK != TUK_Reference) {
     if (TemplateParameterList *TemplateParams
           = MatchTemplateParametersToScopeSpecifier(KWLoc, SS,
                         (TemplateParameterList**)TemplateParameterLists.get(),
@@ -3882,7 +3882,7 @@ Sema::DeclPtrTy Sema::ActOnTag(Scope *S, unsigned TagSpec, TagKind TK,
         // This is a declaration or definition of a class template (which may
         // be a member of another template).
         OwnedDecl = false;
-        DeclResult Result = CheckClassTemplate(S, TagSpec, TK, KWLoc,
+        DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc,
                                                SS, Name, NameLoc, Attr,
                                                move(TemplateParameterLists),
                                                AS);
@@ -3934,7 +3934,7 @@ Sema::DeclPtrTy Sema::ActOnTag(Scope *S, unsigned TagSpec, TagKind TK,
     // shouldn't be. Doing so can result in ambiguities that we
     // shouldn't be diagnosing.
     LookupResult R = LookupName(S, Name, LookupTagName,
-                                /*RedeclarationOnly=*/(TK != TK_Reference));
+                                /*RedeclarationOnly=*/(TUK != TUK_Reference));
     if (R.isAmbiguous()) {
       DiagnoseAmbiguousLookup(R, Name, NameLoc);
       // FIXME: This is not best way to recover from case like:
@@ -3949,7 +3949,7 @@ Sema::DeclPtrTy Sema::ActOnTag(Scope *S, unsigned TagSpec, TagKind TK,
     else
       PrevDecl = R;
 
-    if (!getLangOptions().CPlusPlus && TK != TK_Reference) {
+    if (!getLangOptions().CPlusPlus && TUK != TUK_Reference) {
       // FIXME: This makes sure that we ignore the contexts associated
       // with C structs, unions, and enums when looking for a matching
       // tag declaration or definition. See the similar lookup tweak
@@ -3974,7 +3974,7 @@ Sema::DeclPtrTy Sema::ActOnTag(Scope *S, unsigned TagSpec, TagKind TK,
       // If this is a use of a previous tag, or if the tag is already declared
       // in the same scope (so that the definition/declaration completes or
       // rementions the tag), reuse the decl.
-      if (TK == TK_Reference || isDeclInScope(PrevDecl, SearchDC, S)) {
+      if (TUK == TUK_Reference || isDeclInScope(PrevDecl, SearchDC, S)) {
         // Make sure that this wasn't declared as an enum and now used as a
         // struct or something similar.
         if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind, KWLoc, *Name)) {
@@ -4007,11 +4007,11 @@ Sema::DeclPtrTy Sema::ActOnTag(Scope *S, unsigned TagSpec, TagKind TK,
           // for the consumer of this Decl to know it doesn't own it.
           // For our current ASTs this shouldn't be a problem, but will
           // need to be changed with DeclGroups.
-          if (TK == TK_Reference)
+          if (TUK == TUK_Reference)
             return DeclPtrTy::make(PrevDecl);
 
           // Diagnose attempts to redefine a tag.
-          if (TK == TK_Definition) {
+          if (TUK == TUK_Definition) {
             if (TagDecl *Def = PrevTagDecl->getDefinition(Context)) {
               Diag(NameLoc, diag::err_redefinition) << Name;
               Diag(Def->getLocation(), diag::note_previous_definition);
@@ -4068,7 +4068,7 @@ Sema::DeclPtrTy Sema::ActOnTag(Scope *S, unsigned TagSpec, TagKind TK,
         PrevDecl = 0;
       }
     }
-  } else if (TK == TK_Reference && SS.isEmpty() && Name &&
+  } else if (TUK == TUK_Reference && SS.isEmpty() && Name &&
              (Kind != TagDecl::TK_enum || !getLangOptions().CPlusPlus)) {
     // C++ [basic.scope.pdecl]p5:
     //   -- for an elaborated-type-specifier of the form 
@@ -4123,7 +4123,7 @@ CreateNewDecl:
     New = EnumDecl::Create(Context, SearchDC, Loc, Name, KWLoc,
                            cast_or_null<EnumDecl>(PrevDecl));
     // If this is an undefined enum, warn.
-    if (TK != TK_Definition && !Invalid)  {
+    if (TUK != TUK_Definition && !Invalid)  {
       unsigned DK = getLangOptions().CPlusPlus? diag::err_forward_ref_enum
                                               : diag::ext_forward_ref_enum;
       Diag(Loc, DK);
@@ -4199,7 +4199,7 @@ CreateNewDecl:
   if (!Invalid)
     SetMemberAccessSpecifier(New, PrevDecl, AS);
 
-  if (TK == TK_Definition)
+  if (TUK == TUK_Definition)
     New->startDefinition();
   
   // If this has an identifier, add it to the scope stack.

diff --git a/lib/Sema/SemaTemplate.cpp b/lib/Sema/SemaTemplate.cpp
index 29258575c1cfa97c2e8be4eb31cc4fc89f764437..1bcc8c37ecd7aff0799644f1bad4f32da449d0f4 100644 (file)
--- a/lib/Sema/SemaTemplate.cpp
+++ b/lib/Sema/SemaTemplate.cpp
@@ -438,14 +438,14 @@ Sema::ActOnTemplateParameterList(unsigned Depth,
 }
 
 Sema::DeclResult
-Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagKind TK,
+Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
                          SourceLocation KWLoc, const CXXScopeSpec &SS,
                          IdentifierInfo *Name, SourceLocation NameLoc,
                          AttributeList *Attr,
                          MultiTemplateParamsArg TemplateParameterLists,
                          AccessSpecifier AS) {
   assert(TemplateParameterLists.size() > 0 && "No template parameter lists?");
-  assert(TK != TK_Reference && "Can only declare or define class templates");
+  assert(TUK != TUK_Reference && "Can only declare or define class templates");
   bool Invalid = false;
 
   // Check that we can declare a template here.
@@ -515,7 +515,7 @@ Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagKind TK,
     }
 
     // Check for redefinition of this class template.
-    if (TK == TK_Definition) {
+    if (TUK == TUK_Definition) {
       if (TagDecl *Def = PrevRecordDecl->getDefinition(Context)) {
         Diag(NameLoc, diag::err_redefinition) << Name;
         Diag(Def->getLocation(), diag::note_previous_definition);
@@ -577,7 +577,7 @@ Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagKind TK,
   NewClass->setLexicalDeclContext(CurContext);
   NewTemplate->setLexicalDeclContext(CurContext);
 
-  if (TK == TK_Definition)
+  if (TUK == TUK_Definition)
     NewClass->startDefinition();
 
   if (Attr)
@@ -2346,7 +2346,8 @@ bool Sema::CheckClassTemplatePartialSpecializationArgs(
 }
 
 Sema::DeclResult
-Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagKind TK,
+Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
+                                       TagUseKind TUK,
                                        SourceLocation KWLoc, 
                                        const CXXScopeSpec &SS,
                                        TemplateTy TemplateD,
@@ -2472,10 +2473,10 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagKind TK,
       //   -- The argument list of the specialization shall not be identical 
       //      to the implicit argument list of the primary template. 
       Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
-        << (TK == TK_Definition)
+        << (TUK == TUK_Definition)
         << CodeModificationHint::CreateRemoval(SourceRange(LAngleLoc, 
                                                            RAngleLoc));
-      return CheckClassTemplate(S, TagSpec, TK, KWLoc, SS,
+      return CheckClassTemplate(S, TagSpec, TUK, KWLoc, SS,
                                 ClassTemplate->getIdentifier(),
                                 TemplateNameLoc,
                                 Attr,
@@ -2613,7 +2614,7 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagKind TK,
   Specialization->setSpecializationKind(TSK_ExplicitSpecialization);
 
   // Check that this isn't a redefinition of this specialization.
-  if (TK == TK_Definition) {
+  if (TUK == TUK_Definition) {
     if (RecordDecl *Def = Specialization->getDefinition(Context)) {
       // FIXME: Should also handle explicit specialization after implicit
       // instantiation with a special diagnostic.
@@ -2652,7 +2653,7 @@ Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagKind TK,
   Specialization->setLexicalDeclContext(CurContext);
   
   // We may be starting the definition of this specialization.
-  if (TK == TK_Definition)
+  if (TUK == TUK_Definition)
     Specialization->startDefinition();
 
   // Add the specialization into its lexical context, so that it can
@@ -2892,7 +2893,7 @@ Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation TemplateLoc,
                                  AttributeList *Attr) {
 
   bool Owned = false;
-  DeclPtrTy TagD = ActOnTag(S, TagSpec, Action::TK_Reference,
+  DeclPtrTy TagD = ActOnTag(S, TagSpec, Action::TUK_Reference,
                             KWLoc, SS, Name, NameLoc, Attr, AS_none,
                             MultiTemplateParamsArg(*this, 0, 0), Owned);
   if (!TagD)