1 //===--- TaggedUnionMemberCountCheck.cpp - clang-tidy ---------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "TaggedUnionMemberCountCheck.h" 10 #include "../utils/OptionsUtils.h" 11 #include "clang/ASTMatchers/ASTMatchFinder.h" 12 #include "llvm/ADT/STLExtras.h" 13 #include "llvm/ADT/SmallSet.h" 14 15 using namespace clang::ast_matchers; 16 17 namespace clang::tidy::bugprone { 18 19 static constexpr llvm::StringLiteral StrictModeOptionName = "StrictMode"; 20 static constexpr llvm::StringLiteral EnableCountingEnumHeuristicOptionName = 21 "EnableCountingEnumHeuristic"; 22 static constexpr llvm::StringLiteral CountingEnumPrefixesOptionName = 23 "CountingEnumPrefixes"; 24 static constexpr llvm::StringLiteral CountingEnumSuffixesOptionName = 25 "CountingEnumSuffixes"; 26 27 static constexpr bool StrictModeOptionDefaultValue = false; 28 static constexpr bool EnableCountingEnumHeuristicOptionDefaultValue = true; 29 static constexpr llvm::StringLiteral CountingEnumPrefixesOptionDefaultValue = 30 ""; 31 static constexpr llvm::StringLiteral CountingEnumSuffixesOptionDefaultValue = 32 "count"; 33 34 static constexpr llvm::StringLiteral RootMatchBindName = "root"; 35 static constexpr llvm::StringLiteral UnionMatchBindName = "union"; 36 static constexpr llvm::StringLiteral TagMatchBindName = "tags"; 37 38 namespace { 39 40 AST_MATCHER_P2(RecordDecl, fieldCountOfKindIsOne, 41 ast_matchers::internal::Matcher<FieldDecl>, InnerMatcher, 42 StringRef, BindName) { 43 // BoundNodesTreeBuilder resets itself when a match occurs. 44 // So to avoid losing previously saved binds, a temporary instance 45 // is used for matching. 46 // 47 // For precedence, see commit: 5b07de1a5faf4a22ae6fd982b877c5e7e3a76559 48 clang::ast_matchers::internal::BoundNodesTreeBuilder TempBuilder; 49 50 const FieldDecl *FirstMatch = nullptr; 51 for (const FieldDecl *Field : Node.fields()) { 52 if (InnerMatcher.matches(*Field, Finder, &TempBuilder)) { 53 if (FirstMatch) { 54 return false; 55 } else { 56 FirstMatch = Field; 57 } 58 } 59 } 60 61 if (FirstMatch) { 62 Builder->setBinding(BindName, clang::DynTypedNode::create(*FirstMatch)); 63 return true; 64 } 65 return false; 66 } 67 68 } // namespace 69 70 TaggedUnionMemberCountCheck::TaggedUnionMemberCountCheck( 71 StringRef Name, ClangTidyContext *Context) 72 : ClangTidyCheck(Name, Context), 73 StrictMode( 74 Options.get(StrictModeOptionName, StrictModeOptionDefaultValue)), 75 EnableCountingEnumHeuristic( 76 Options.get(EnableCountingEnumHeuristicOptionName, 77 EnableCountingEnumHeuristicOptionDefaultValue)), 78 CountingEnumPrefixes(utils::options::parseStringList( 79 Options.get(CountingEnumPrefixesOptionName, 80 CountingEnumPrefixesOptionDefaultValue))), 81 CountingEnumSuffixes(utils::options::parseStringList( 82 Options.get(CountingEnumSuffixesOptionName, 83 CountingEnumSuffixesOptionDefaultValue))) { 84 if (!EnableCountingEnumHeuristic) { 85 if (Options.get(CountingEnumPrefixesOptionName)) 86 configurationDiag("%0: Counting enum heuristic is disabled but " 87 "%1 is set") 88 << Name << CountingEnumPrefixesOptionName; 89 if (Options.get(CountingEnumSuffixesOptionName)) 90 configurationDiag("%0: Counting enum heuristic is disabled but " 91 "%1 is set") 92 << Name << CountingEnumSuffixesOptionName; 93 } 94 } 95 96 void TaggedUnionMemberCountCheck::storeOptions( 97 ClangTidyOptions::OptionMap &Opts) { 98 Options.store(Opts, StrictModeOptionName, StrictMode); 99 Options.store(Opts, EnableCountingEnumHeuristicOptionName, 100 EnableCountingEnumHeuristic); 101 Options.store(Opts, CountingEnumPrefixesOptionName, 102 utils::options::serializeStringList(CountingEnumPrefixes)); 103 Options.store(Opts, CountingEnumSuffixesOptionName, 104 utils::options::serializeStringList(CountingEnumSuffixes)); 105 } 106 107 void TaggedUnionMemberCountCheck::registerMatchers(MatchFinder *Finder) { 108 109 auto UnionField = fieldDecl(hasType(qualType( 110 hasCanonicalType(recordType(hasDeclaration(recordDecl(isUnion()))))))); 111 112 auto EnumField = fieldDecl(hasType( 113 qualType(hasCanonicalType(enumType(hasDeclaration(enumDecl())))))); 114 115 auto hasOneUnionField = fieldCountOfKindIsOne(UnionField, UnionMatchBindName); 116 auto hasOneEnumField = fieldCountOfKindIsOne(EnumField, TagMatchBindName); 117 118 Finder->addMatcher(recordDecl(anyOf(isStruct(), isClass()), hasOneUnionField, 119 hasOneEnumField, unless(isImplicit())) 120 .bind(RootMatchBindName), 121 this); 122 } 123 124 bool TaggedUnionMemberCountCheck::isCountingEnumLikeName(StringRef Name) const { 125 if (llvm::any_of(CountingEnumPrefixes, [Name](StringRef Prefix) -> bool { 126 return Name.starts_with_insensitive(Prefix); 127 })) 128 return true; 129 if (llvm::any_of(CountingEnumSuffixes, [Name](StringRef Suffix) -> bool { 130 return Name.ends_with_insensitive(Suffix); 131 })) 132 return true; 133 return false; 134 } 135 136 std::pair<const std::size_t, const EnumConstantDecl *> 137 TaggedUnionMemberCountCheck::getNumberOfEnumValues(const EnumDecl *ED) { 138 llvm::SmallSet<llvm::APSInt, 16> EnumValues; 139 140 const EnumConstantDecl *LastEnumConstant = nullptr; 141 for (const EnumConstantDecl *Enumerator : ED->enumerators()) { 142 EnumValues.insert(Enumerator->getInitVal()); 143 LastEnumConstant = Enumerator; 144 } 145 146 if (EnableCountingEnumHeuristic && LastEnumConstant && 147 isCountingEnumLikeName(LastEnumConstant->getName()) && 148 (LastEnumConstant->getInitVal() == (EnumValues.size() - 1))) { 149 return {EnumValues.size() - 1, LastEnumConstant}; 150 } 151 152 return {EnumValues.size(), nullptr}; 153 } 154 155 void TaggedUnionMemberCountCheck::check( 156 const MatchFinder::MatchResult &Result) { 157 const auto *Root = Result.Nodes.getNodeAs<RecordDecl>(RootMatchBindName); 158 const auto *UnionField = 159 Result.Nodes.getNodeAs<FieldDecl>(UnionMatchBindName); 160 const auto *TagField = Result.Nodes.getNodeAs<FieldDecl>(TagMatchBindName); 161 162 assert(Root && "Root is missing!"); 163 assert(UnionField && "UnionField is missing!"); 164 assert(TagField && "TagField is missing!"); 165 if (!Root || !UnionField || !TagField) 166 return; 167 168 const auto *UnionDef = 169 UnionField->getType().getCanonicalType().getTypePtr()->getAsRecordDecl(); 170 const auto *EnumDef = llvm::dyn_cast<EnumDecl>( 171 TagField->getType().getCanonicalType().getTypePtr()->getAsTagDecl()); 172 173 assert(UnionDef && "UnionDef is missing!"); 174 assert(EnumDef && "EnumDef is missing!"); 175 if (!UnionDef || !EnumDef) 176 return; 177 178 const std::size_t UnionMemberCount = llvm::range_size(UnionDef->fields()); 179 auto [TagCount, CountingEnumConstantDecl] = getNumberOfEnumValues(EnumDef); 180 181 if (UnionMemberCount > TagCount) { 182 diag(Root->getLocation(), 183 "tagged union has more data members (%0) than tags (%1)!") 184 << UnionMemberCount << TagCount; 185 } else if (StrictMode && UnionMemberCount < TagCount) { 186 diag(Root->getLocation(), 187 "tagged union has fewer data members (%0) than tags (%1)!") 188 << UnionMemberCount << TagCount; 189 } 190 191 if (CountingEnumConstantDecl) { 192 diag(CountingEnumConstantDecl->getLocation(), 193 "assuming that this constant is just an auxiliary value and not " 194 "used for indicating a valid union data member", 195 DiagnosticIDs::Note); 196 } 197 } 198 199 } // namespace clang::tidy::bugprone 200