| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,199 @@ | ||
| //===--- TaggedUnionMemberCountCheck.cpp - clang-tidy ---------------------===// | ||
| // | ||
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | ||
| // See https://llvm.org/LICENSE.txt for license information. | ||
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | ||
| // | ||
| //===----------------------------------------------------------------------===// | ||
|
|
||
| #include "TaggedUnionMemberCountCheck.h" | ||
| #include "../utils/OptionsUtils.h" | ||
| #include "clang/ASTMatchers/ASTMatchFinder.h" | ||
| #include "llvm/ADT/STLExtras.h" | ||
| #include "llvm/ADT/SmallSet.h" | ||
|
|
||
| using namespace clang::ast_matchers; | ||
|
|
||
| namespace clang::tidy::bugprone { | ||
|
|
||
| static constexpr llvm::StringLiteral StrictModeOptionName = "StrictMode"; | ||
| static constexpr llvm::StringLiteral EnableCountingEnumHeuristicOptionName = | ||
| "EnableCountingEnumHeuristic"; | ||
| static constexpr llvm::StringLiteral CountingEnumPrefixesOptionName = | ||
| "CountingEnumPrefixes"; | ||
| static constexpr llvm::StringLiteral CountingEnumSuffixesOptionName = | ||
| "CountingEnumSuffixes"; | ||
|
|
||
| static constexpr bool StrictModeOptionDefaultValue = false; | ||
| static constexpr bool EnableCountingEnumHeuristicOptionDefaultValue = true; | ||
| static constexpr llvm::StringLiteral CountingEnumPrefixesOptionDefaultValue = | ||
| ""; | ||
| static constexpr llvm::StringLiteral CountingEnumSuffixesOptionDefaultValue = | ||
| "count"; | ||
|
|
||
| static constexpr llvm::StringLiteral RootMatchBindName = "root"; | ||
| static constexpr llvm::StringLiteral UnionMatchBindName = "union"; | ||
| static constexpr llvm::StringLiteral TagMatchBindName = "tags"; | ||
|
|
||
| namespace { | ||
|
|
||
| AST_MATCHER_P2(RecordDecl, fieldCountOfKindIsOne, | ||
| ast_matchers::internal::Matcher<FieldDecl>, InnerMatcher, | ||
| StringRef, BindName) { | ||
| // BoundNodesTreeBuilder resets itself when a match occurs. | ||
| // So to avoid losing previously saved binds, a temporary instance | ||
| // is used for matching. | ||
| // | ||
| // For precedence, see commit: 5b07de1a5faf4a22ae6fd982b877c5e7e3a76559 | ||
| clang::ast_matchers::internal::BoundNodesTreeBuilder TempBuilder; | ||
|
|
||
| const FieldDecl *FirstMatch = nullptr; | ||
| for (const FieldDecl *Field : Node.fields()) { | ||
| if (InnerMatcher.matches(*Field, Finder, &TempBuilder)) { | ||
| if (FirstMatch) { | ||
| return false; | ||
| } else { | ||
| FirstMatch = Field; | ||
| } | ||
| } | ||
| } | ||
|
|
||
| if (FirstMatch) { | ||
| Builder->setBinding(BindName, clang::DynTypedNode::create(*FirstMatch)); | ||
| return true; | ||
| } | ||
| return false; | ||
| } | ||
|
|
||
| } // namespace | ||
|
|
||
| TaggedUnionMemberCountCheck::TaggedUnionMemberCountCheck( | ||
| StringRef Name, ClangTidyContext *Context) | ||
| : ClangTidyCheck(Name, Context), | ||
| StrictMode( | ||
| Options.get(StrictModeOptionName, StrictModeOptionDefaultValue)), | ||
| EnableCountingEnumHeuristic( | ||
| Options.get(EnableCountingEnumHeuristicOptionName, | ||
| EnableCountingEnumHeuristicOptionDefaultValue)), | ||
| CountingEnumPrefixes(utils::options::parseStringList( | ||
| Options.get(CountingEnumPrefixesOptionName, | ||
| CountingEnumPrefixesOptionDefaultValue))), | ||
| CountingEnumSuffixes(utils::options::parseStringList( | ||
| Options.get(CountingEnumSuffixesOptionName, | ||
| CountingEnumSuffixesOptionDefaultValue))) { | ||
| if (!EnableCountingEnumHeuristic) { | ||
| if (Options.get(CountingEnumPrefixesOptionName)) | ||
| configurationDiag("%0: Counting enum heuristic is disabled but " | ||
| "%1 is set") | ||
| << Name << CountingEnumPrefixesOptionName; | ||
| if (Options.get(CountingEnumSuffixesOptionName)) | ||
| configurationDiag("%0: Counting enum heuristic is disabled but " | ||
| "%1 is set") | ||
| << Name << CountingEnumSuffixesOptionName; | ||
| } | ||
| } | ||
|
|
||
| void TaggedUnionMemberCountCheck::storeOptions( | ||
| ClangTidyOptions::OptionMap &Opts) { | ||
| Options.store(Opts, StrictModeOptionName, StrictMode); | ||
| Options.store(Opts, EnableCountingEnumHeuristicOptionName, | ||
| EnableCountingEnumHeuristic); | ||
| Options.store(Opts, CountingEnumPrefixesOptionName, | ||
| utils::options::serializeStringList(CountingEnumPrefixes)); | ||
| Options.store(Opts, CountingEnumSuffixesOptionName, | ||
| utils::options::serializeStringList(CountingEnumSuffixes)); | ||
| } | ||
|
|
||
| void TaggedUnionMemberCountCheck::registerMatchers(MatchFinder *Finder) { | ||
|
|
||
| auto UnionField = fieldDecl(hasType(qualType( | ||
| hasCanonicalType(recordType(hasDeclaration(recordDecl(isUnion()))))))); | ||
|
|
||
| auto EnumField = fieldDecl(hasType( | ||
| qualType(hasCanonicalType(enumType(hasDeclaration(enumDecl())))))); | ||
|
|
||
| auto hasOneUnionField = fieldCountOfKindIsOne(UnionField, UnionMatchBindName); | ||
| auto hasOneEnumField = fieldCountOfKindIsOne(EnumField, TagMatchBindName); | ||
|
|
||
| Finder->addMatcher(recordDecl(anyOf(isStruct(), isClass()), hasOneUnionField, | ||
| hasOneEnumField, unless(isImplicit())) | ||
| .bind(RootMatchBindName), | ||
| this); | ||
| } | ||
|
|
||
| bool TaggedUnionMemberCountCheck::isCountingEnumLikeName(StringRef Name) const { | ||
| if (llvm::any_of(CountingEnumPrefixes, [Name](StringRef Prefix) -> bool { | ||
| return Name.starts_with_insensitive(Prefix); | ||
| })) | ||
| return true; | ||
| if (llvm::any_of(CountingEnumSuffixes, [Name](StringRef Suffix) -> bool { | ||
| return Name.ends_with_insensitive(Suffix); | ||
| })) | ||
| return true; | ||
| return false; | ||
| } | ||
|
|
||
| std::pair<const std::size_t, const EnumConstantDecl *> | ||
| TaggedUnionMemberCountCheck::getNumberOfEnumValues(const EnumDecl *ED) { | ||
| llvm::SmallSet<llvm::APSInt, 16> EnumValues; | ||
|
|
||
| const EnumConstantDecl *LastEnumConstant = nullptr; | ||
| for (const EnumConstantDecl *Enumerator : ED->enumerators()) { | ||
| EnumValues.insert(Enumerator->getInitVal()); | ||
| LastEnumConstant = Enumerator; | ||
| } | ||
|
|
||
| if (EnableCountingEnumHeuristic && LastEnumConstant && | ||
| isCountingEnumLikeName(LastEnumConstant->getName()) && | ||
| (LastEnumConstant->getInitVal() == (EnumValues.size() - 1))) { | ||
| return {EnumValues.size() - 1, LastEnumConstant}; | ||
| } | ||
|
|
||
| return {EnumValues.size(), nullptr}; | ||
| } | ||
|
|
||
| void TaggedUnionMemberCountCheck::check( | ||
| const MatchFinder::MatchResult &Result) { | ||
| const auto *Root = Result.Nodes.getNodeAs<RecordDecl>(RootMatchBindName); | ||
| const auto *UnionField = | ||
| Result.Nodes.getNodeAs<FieldDecl>(UnionMatchBindName); | ||
| const auto *TagField = Result.Nodes.getNodeAs<FieldDecl>(TagMatchBindName); | ||
|
|
||
| assert(Root && "Root is missing!"); | ||
| assert(UnionField && "UnionField is missing!"); | ||
| assert(TagField && "TagField is missing!"); | ||
| if (!Root || !UnionField || !TagField) | ||
| return; | ||
|
|
||
| const auto *UnionDef = | ||
| UnionField->getType().getCanonicalType().getTypePtr()->getAsRecordDecl(); | ||
| const auto *EnumDef = llvm::dyn_cast<EnumDecl>( | ||
| TagField->getType().getCanonicalType().getTypePtr()->getAsTagDecl()); | ||
|
|
||
| assert(UnionDef && "UnionDef is missing!"); | ||
| assert(EnumDef && "EnumDef is missing!"); | ||
| if (!UnionDef || !EnumDef) | ||
| return; | ||
|
|
||
| const std::size_t UnionMemberCount = llvm::range_size(UnionDef->fields()); | ||
| auto [TagCount, CountingEnumConstantDecl] = getNumberOfEnumValues(EnumDef); | ||
|
|
||
| if (UnionMemberCount > TagCount) { | ||
| diag(Root->getLocation(), | ||
| "tagged union has more data members (%0) than tags (%1)!") | ||
| << UnionMemberCount << TagCount; | ||
| } else if (StrictMode && UnionMemberCount < TagCount) { | ||
| diag(Root->getLocation(), | ||
| "tagged union has fewer data members (%0) than tags (%1)!") | ||
| << UnionMemberCount << TagCount; | ||
| } | ||
|
|
||
| if (CountingEnumConstantDecl) { | ||
| diag(CountingEnumConstantDecl->getLocation(), | ||
| "assuming that this constant is just an auxiliary value and not " | ||
| "used for indicating a valid union data member", | ||
| DiagnosticIDs::Note); | ||
| } | ||
| } | ||
|
|
||
| } // namespace clang::tidy::bugprone |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,41 @@ | ||
| //===--- TaggedUnionMemberCountCheck.h - clang-tidy -------------*- C++ -*-===// | ||
| // | ||
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | ||
| // See https://llvm.org/LICENSE.txt for license information. | ||
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | ||
| // | ||
| //===----------------------------------------------------------------------===// | ||
|
|
||
| #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_TAGGEDUNIONMEMBERCOUNTCHECK_H | ||
| #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_TAGGEDUNIONMEMBERCOUNTCHECK_H | ||
|
|
||
| #include "../ClangTidyCheck.h" | ||
|
|
||
| namespace clang::tidy::bugprone { | ||
|
|
||
| /// Gives warnings for tagged unions, where the number of tags is | ||
| /// different from the number of data members inside the union. | ||
| /// | ||
| /// For the user-facing documentation see: | ||
| /// http://clang.llvm.org/extra/clang-tidy/checks/bugprone/tagged-union-member-count.html | ||
| class TaggedUnionMemberCountCheck : public ClangTidyCheck { | ||
| public: | ||
| TaggedUnionMemberCountCheck(StringRef Name, ClangTidyContext *Context); | ||
| void storeOptions(ClangTidyOptions::OptionMap &Opts) override; | ||
| void registerMatchers(ast_matchers::MatchFinder *Finder) override; | ||
| void check(const ast_matchers::MatchFinder::MatchResult &Result) override; | ||
|
|
||
| private: | ||
| const bool StrictMode; | ||
| const bool EnableCountingEnumHeuristic; | ||
| const std::vector<StringRef> CountingEnumPrefixes; | ||
| const std::vector<StringRef> CountingEnumSuffixes; | ||
|
|
||
| std::pair<const std::size_t, const EnumConstantDecl *> | ||
| getNumberOfEnumValues(const EnumDecl *ED); | ||
| bool isCountingEnumLikeName(StringRef Name) const; | ||
| }; | ||
|
|
||
| } // namespace clang::tidy::bugprone | ||
|
|
||
| #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_TAGGEDUNIONMEMBERCOUNTCHECK_H |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -483,7 +483,6 @@ std::string convertGlobToRegex(llvm::StringRef Glob) { | |
| } | ||
| } | ||
| RegStream << '$'; | ||
| return RegText; | ||
| } | ||
|
|
||
|
|
||
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -87,7 +87,6 @@ std::string buildUmbrella(llvm::StringLiteral Mandatory, | |
| "#endif\n", | ||
| Header); | ||
| } | ||
| return Result; | ||
| } | ||
|
|
||
|
|
||
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,217 @@ | ||
| //===--- SwapBinaryOperands.cpp ----------------------------------*- C++-*-===// | ||
| // | ||
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | ||
| // See https://llvm.org/LICENSE.txt for license information. | ||
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | ||
| // | ||
| //===----------------------------------------------------------------------===// | ||
| #include "ParsedAST.h" | ||
| #include "Protocol.h" | ||
| #include "Selection.h" | ||
| #include "SourceCode.h" | ||
| #include "refactor/Tweak.h" | ||
| #include "support/Logger.h" | ||
| #include "clang/AST/ASTContext.h" | ||
| #include "clang/AST/Expr.h" | ||
| #include "clang/AST/OperationKinds.h" | ||
| #include "clang/AST/Stmt.h" | ||
| #include "clang/Basic/LLVM.h" | ||
| #include "clang/Basic/SourceLocation.h" | ||
| #include "clang/Tooling/Core/Replacement.h" | ||
| #include "llvm/ADT/StringRef.h" | ||
| #include "llvm/Support/Casting.h" | ||
| #include "llvm/Support/FormatVariadic.h" | ||
| #include <string> | ||
| #include <utility> | ||
|
|
||
| namespace clang { | ||
| namespace clangd { | ||
| namespace { | ||
| /// Check whether it makes logical sense to swap operands to an operator. | ||
| /// Assignment or member access operators are rarely swappable | ||
| /// while keeping the meaning intact, whereas comparison operators, mathematical | ||
| /// operators, etc. are often desired to be swappable for readability, avoiding | ||
| /// bugs by assigning to nullptr when comparison was desired, etc. | ||
| bool isOpSwappable(const BinaryOperatorKind Opcode) { | ||
| switch (Opcode) { | ||
| case BinaryOperatorKind::BO_Mul: | ||
| case BinaryOperatorKind::BO_Add: | ||
| case BinaryOperatorKind::BO_LT: | ||
| case BinaryOperatorKind::BO_GT: | ||
| case BinaryOperatorKind::BO_LE: | ||
| case BinaryOperatorKind::BO_GE: | ||
| case BinaryOperatorKind::BO_EQ: | ||
| case BinaryOperatorKind::BO_NE: | ||
| case BinaryOperatorKind::BO_And: | ||
| case BinaryOperatorKind::BO_Xor: | ||
| case BinaryOperatorKind::BO_Or: | ||
| case BinaryOperatorKind::BO_LAnd: | ||
| case BinaryOperatorKind::BO_LOr: | ||
| case BinaryOperatorKind::BO_Comma: | ||
| return true; | ||
| // Noncommutative operators: | ||
| case BinaryOperatorKind::BO_Div: | ||
| case BinaryOperatorKind::BO_Sub: | ||
| case BinaryOperatorKind::BO_Shl: | ||
| case BinaryOperatorKind::BO_Shr: | ||
| case BinaryOperatorKind::BO_Rem: | ||
| // <=> is noncommutative | ||
| case BinaryOperatorKind::BO_Cmp: | ||
| // Member access: | ||
| case BinaryOperatorKind::BO_PtrMemD: | ||
| case BinaryOperatorKind::BO_PtrMemI: | ||
| // Assignment: | ||
| case BinaryOperatorKind::BO_Assign: | ||
| case BinaryOperatorKind::BO_MulAssign: | ||
| case BinaryOperatorKind::BO_DivAssign: | ||
| case BinaryOperatorKind::BO_RemAssign: | ||
| case BinaryOperatorKind::BO_AddAssign: | ||
| case BinaryOperatorKind::BO_SubAssign: | ||
| case BinaryOperatorKind::BO_ShlAssign: | ||
| case BinaryOperatorKind::BO_ShrAssign: | ||
| case BinaryOperatorKind::BO_AndAssign: | ||
| case BinaryOperatorKind::BO_XorAssign: | ||
| case BinaryOperatorKind::BO_OrAssign: | ||
| return false; | ||
| } | ||
| return false; | ||
| } | ||
|
|
||
| /// Some operators are asymmetric and need to be flipped when swapping their | ||
| /// operands | ||
| /// @param[out] Opcode the opcode to potentially swap | ||
| /// If the opcode does not need to be swapped or is not swappable, does nothing | ||
| BinaryOperatorKind swapOperator(const BinaryOperatorKind Opcode) { | ||
| switch (Opcode) { | ||
| case BinaryOperatorKind::BO_LT: | ||
| return BinaryOperatorKind::BO_GT; | ||
|
|
||
| case BinaryOperatorKind::BO_GT: | ||
| return BinaryOperatorKind::BO_LT; | ||
|
|
||
| case BinaryOperatorKind::BO_LE: | ||
| return BinaryOperatorKind::BO_GE; | ||
|
|
||
| case BinaryOperatorKind::BO_GE: | ||
| return BinaryOperatorKind::BO_LE; | ||
|
|
||
| case BinaryOperatorKind::BO_Mul: | ||
| case BinaryOperatorKind::BO_Add: | ||
| case BinaryOperatorKind::BO_Cmp: | ||
| case BinaryOperatorKind::BO_EQ: | ||
| case BinaryOperatorKind::BO_NE: | ||
| case BinaryOperatorKind::BO_And: | ||
| case BinaryOperatorKind::BO_Xor: | ||
| case BinaryOperatorKind::BO_Or: | ||
| case BinaryOperatorKind::BO_LAnd: | ||
| case BinaryOperatorKind::BO_LOr: | ||
| case BinaryOperatorKind::BO_Comma: | ||
| case BinaryOperatorKind::BO_Div: | ||
| case BinaryOperatorKind::BO_Sub: | ||
| case BinaryOperatorKind::BO_Shl: | ||
| case BinaryOperatorKind::BO_Shr: | ||
| case BinaryOperatorKind::BO_Rem: | ||
| case BinaryOperatorKind::BO_PtrMemD: | ||
| case BinaryOperatorKind::BO_PtrMemI: | ||
| case BinaryOperatorKind::BO_Assign: | ||
| case BinaryOperatorKind::BO_MulAssign: | ||
| case BinaryOperatorKind::BO_DivAssign: | ||
| case BinaryOperatorKind::BO_RemAssign: | ||
| case BinaryOperatorKind::BO_AddAssign: | ||
| case BinaryOperatorKind::BO_SubAssign: | ||
| case BinaryOperatorKind::BO_ShlAssign: | ||
| case BinaryOperatorKind::BO_ShrAssign: | ||
| case BinaryOperatorKind::BO_AndAssign: | ||
| case BinaryOperatorKind::BO_XorAssign: | ||
| case BinaryOperatorKind::BO_OrAssign: | ||
| return Opcode; | ||
| } | ||
| llvm_unreachable("Unknown BinaryOperatorKind enum"); | ||
| } | ||
|
|
||
| /// Swaps the operands to a binary operator | ||
| /// Before: | ||
| /// x != nullptr | ||
| /// ^ ^^^^^^^ | ||
| /// After: | ||
| /// nullptr != x | ||
| class SwapBinaryOperands : public Tweak { | ||
| public: | ||
| const char *id() const final; | ||
|
|
||
| bool prepare(const Selection &Inputs) override; | ||
| Expected<Effect> apply(const Selection &Inputs) override; | ||
| std::string title() const override { | ||
| return llvm::formatv("Swap operands to {0}", | ||
| Op ? Op->getOpcodeStr() : "binary operator"); | ||
| } | ||
| llvm::StringLiteral kind() const override { | ||
| return CodeAction::REFACTOR_KIND; | ||
| } | ||
| bool hidden() const override { return false; } | ||
|
|
||
| private: | ||
| const BinaryOperator *Op; | ||
| }; | ||
|
|
||
| REGISTER_TWEAK(SwapBinaryOperands) | ||
|
|
||
| bool SwapBinaryOperands::prepare(const Selection &Inputs) { | ||
| for (const SelectionTree::Node *N = Inputs.ASTSelection.commonAncestor(); | ||
| N && !Op; N = N->Parent) { | ||
| // Stop once we hit a block, e.g. a lambda in one of the operands. | ||
| // This makes sure that the selection point is in the 'scope' of the binary | ||
| // operator, not from somewhere inside a lambda for example | ||
| // (5 < [](){ ^return 1; }) | ||
| if (llvm::isa_and_nonnull<CompoundStmt>(N->ASTNode.get<Stmt>())) | ||
| return false; | ||
| Op = dyn_cast_or_null<BinaryOperator>(N->ASTNode.get<Stmt>()); | ||
| // If we hit upon a nonswappable binary operator, ignore and keep going | ||
| if (Op && !isOpSwappable(Op->getOpcode())) { | ||
| Op = nullptr; | ||
| } | ||
| } | ||
| return Op != nullptr; | ||
| } | ||
|
|
||
| Expected<Tweak::Effect> SwapBinaryOperands::apply(const Selection &Inputs) { | ||
| const auto &Ctx = Inputs.AST->getASTContext(); | ||
| const auto &SrcMgr = Inputs.AST->getSourceManager(); | ||
|
|
||
| const auto LHSRng = toHalfOpenFileRange(SrcMgr, Ctx.getLangOpts(), | ||
| Op->getLHS()->getSourceRange()); | ||
| if (!LHSRng) | ||
| return error( | ||
| "Could not obtain range of the 'lhs' of the operator. Macros?"); | ||
| const auto RHSRng = toHalfOpenFileRange(SrcMgr, Ctx.getLangOpts(), | ||
| Op->getRHS()->getSourceRange()); | ||
| if (!RHSRng) | ||
| return error( | ||
| "Could not obtain range of the 'rhs' of the operator. Macros?"); | ||
| const auto OpRng = | ||
| toHalfOpenFileRange(SrcMgr, Ctx.getLangOpts(), Op->getOperatorLoc()); | ||
| if (!OpRng) | ||
| return error("Could not obtain range of the operator itself. Macros?"); | ||
|
|
||
| const auto LHSCode = toSourceCode(SrcMgr, *LHSRng); | ||
| const auto RHSCode = toSourceCode(SrcMgr, *RHSRng); | ||
| const auto OperatorCode = toSourceCode(SrcMgr, *OpRng); | ||
|
|
||
| tooling::Replacements Result; | ||
| if (auto Err = Result.add(tooling::Replacement( | ||
| Ctx.getSourceManager(), LHSRng->getBegin(), LHSCode.size(), RHSCode))) | ||
| return std::move(Err); | ||
| if (auto Err = Result.add(tooling::Replacement( | ||
| Ctx.getSourceManager(), RHSRng->getBegin(), RHSCode.size(), LHSCode))) | ||
| return std::move(Err); | ||
| const auto SwappedOperator = swapOperator(Op->getOpcode()); | ||
| if (auto Err = Result.add(tooling::Replacement( | ||
| Ctx.getSourceManager(), OpRng->getBegin(), OperatorCode.size(), | ||
| Op->getOpcodeStr(SwappedOperator)))) | ||
| return std::move(Err); | ||
| return Effect::mainFileEdit(SrcMgr, std::move(Result)); | ||
| } | ||
|
|
||
| } // namespace | ||
| } // namespace clangd | ||
| } // namespace clang |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,92 @@ | ||
| //===-- SwapBinaryOperandsTests.cpp -----------------------------*- C++ -*-===// | ||
| // | ||
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | ||
| // See https://llvm.org/LICENSE.txt for license information. | ||
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | ||
| // | ||
| //===----------------------------------------------------------------------===// | ||
|
|
||
| #include "TweakTesting.h" | ||
| #include "gmock/gmock-matchers.h" | ||
| #include "gmock/gmock.h" | ||
| #include "gtest/gtest.h" | ||
|
|
||
| namespace clang { | ||
| namespace clangd { | ||
| namespace { | ||
|
|
||
| TWEAK_TEST(SwapBinaryOperands); | ||
|
|
||
| TEST_F(SwapBinaryOperandsTest, Test) { | ||
| Context = Function; | ||
| EXPECT_EQ(apply("int *p = nullptr; bool c = ^p == nullptr;"), | ||
| "int *p = nullptr; bool c = nullptr == p;"); | ||
| EXPECT_EQ(apply("int *p = nullptr; bool c = p ^== nullptr;"), | ||
| "int *p = nullptr; bool c = nullptr == p;"); | ||
| EXPECT_EQ(apply("int x = 3; bool c = ^x >= 5;"), | ||
| "int x = 3; bool c = 5 <= x;"); | ||
| EXPECT_EQ(apply("int x = 3; bool c = x >^= 5;"), | ||
| "int x = 3; bool c = 5 <= x;"); | ||
| EXPECT_EQ(apply("int x = 3; bool c = x >=^ 5;"), | ||
| "int x = 3; bool c = 5 <= x;"); | ||
| EXPECT_EQ(apply("int x = 3; bool c = x >=^ 5;"), | ||
| "int x = 3; bool c = 5 <= x;"); | ||
| EXPECT_EQ(apply("int f(); int x = 3; bool c = x >=^ f();"), | ||
| "int f(); int x = 3; bool c = f() <= x;"); | ||
| EXPECT_EQ(apply(R"cpp( | ||
| int f(); | ||
| #define F f | ||
| int x = 3; bool c = x >=^ F(); | ||
| )cpp"), | ||
| R"cpp( | ||
| int f(); | ||
| #define F f | ||
| int x = 3; bool c = F() <= x; | ||
| )cpp"); | ||
| EXPECT_EQ(apply(R"cpp( | ||
| int f(); | ||
| #define F f() | ||
| int x = 3; bool c = x >=^ F; | ||
| )cpp"), | ||
| R"cpp( | ||
| int f(); | ||
| #define F f() | ||
| int x = 3; bool c = F <= x; | ||
| )cpp"); | ||
| EXPECT_EQ(apply(R"cpp( | ||
| int f(bool); | ||
| #define F(v) f(v) | ||
| int x = 0; | ||
| bool c = F(x^ < 5); | ||
| )cpp"), | ||
| R"cpp( | ||
| int f(bool); | ||
| #define F(v) f(v) | ||
| int x = 0; | ||
| bool c = F(5 > x); | ||
| )cpp"); | ||
| ExtraArgs = {"-std=c++20"}; | ||
| Context = CodeContext::File; | ||
| EXPECT_UNAVAILABLE(R"cpp( | ||
| namespace std { | ||
| struct strong_ordering { | ||
| int val; | ||
| static const strong_ordering less; | ||
| static const strong_ordering equivalent; | ||
| static const strong_ordering equal; | ||
| static const strong_ordering greater; | ||
| }; | ||
| inline constexpr strong_ordering strong_ordering::less {-1}; | ||
| inline constexpr strong_ordering strong_ordering::equivalent {0}; | ||
| inline constexpr strong_ordering strong_ordering::equal {0}; | ||
| inline constexpr strong_ordering strong_ordering::greater {1}; | ||
| }; | ||
| #define F(v) v | ||
| int x = 0; | ||
| auto c = F(5^ <=> x); | ||
| )cpp"); | ||
| } | ||
|
|
||
| } // namespace | ||
| } // namespace clangd | ||
| } // namespace clang |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,52 @@ | ||
| .. title:: clang-tidy - bugprone-bitwise-pointer-cast | ||
|
|
||
| bugprone-bitwise-pointer-cast | ||
| ============================= | ||
|
|
||
| Warns about code that tries to cast between pointers by means of | ||
| ``std::bit_cast`` or ``memcpy``. | ||
|
|
||
| The motivation is that ``std::bit_cast`` is advertised as the safe alternative | ||
| to type punning via ``reinterpret_cast`` in modern C++. However, one should not | ||
| blindly replace ``reinterpret_cast`` with ``std::bit_cast``, as follows: | ||
|
|
||
| .. code-block:: c++ | ||
|
|
||
| int x{}; | ||
| -float y = *reinterpret_cast<float*>(&x); | ||
| +float y = *std::bit_cast<float*>(&x); | ||
|
|
||
| The drop-in replacement behaves exactly the same as ``reinterpret_cast``, and | ||
| Undefined Behavior is still invoked. ``std::bit_cast`` is copying the bytes of | ||
| the input pointer, not the pointee, into an output pointer of a different type, | ||
| which may violate the strict aliasing rules. However, simply looking at the | ||
| code, it looks "safe", because it uses ``std::bit_cast`` which is advertised as | ||
| safe. | ||
|
|
||
| The solution to safe type punning is to apply ``std::bit_cast`` on value types, | ||
| not on pointer types: | ||
|
|
||
| .. code-block:: c++ | ||
|
|
||
| int x{}; | ||
| float y = std::bit_cast<float>(x); | ||
|
|
||
| This way, the bytes of the input object are copied into the output object, which | ||
| is much safer. Do note that Undefined Behavior can still occur, if there is no | ||
| value of type ``To`` corresponding to the value representation produced. | ||
| Compilers may be able to optimize this copy and generate identical assembly to | ||
| the original ``reinterpret_cast`` version. | ||
|
|
||
| Code before C++20 may backport ``std::bit_cast`` by means of ``memcpy``, or | ||
| simply call ``memcpy`` directly, which is equally problematic. This is also | ||
| detected by this check: | ||
|
|
||
| .. code-block:: c++ | ||
|
|
||
| int* x{}; | ||
| float* y{}; | ||
| std::memcpy(&y, &x, sizeof(x)); | ||
|
|
||
| Alternatively, if a cast between pointers is truly wanted, ``reinterpret_cast`` | ||
| should be used, to clearly convey the intent and enable warnings from compilers | ||
| and linters, which should be addressed accordingly. |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,280 @@ | ||
| .. title:: clang-tidy - bugprone-tagged-union-member-count | ||
|
|
||
| bugprone-tagged-union-member-count | ||
| ================================== | ||
|
|
||
| Gives warnings for tagged unions, where the number of tags is | ||
| different from the number of data members inside the union. | ||
|
|
||
| A struct or a class is considered to be a tagged union if it has | ||
| exactly one union data member and exactly one enum data member and | ||
| any number of other data members that are neither unions or enums. | ||
|
|
||
| Example: | ||
|
|
||
| .. code-block:: c++ | ||
|
|
||
| enum Tags { | ||
| Tag1, | ||
| Tag2, | ||
| }; | ||
|
|
||
| struct TaggedUnion { // warning: tagged union has more data members (3) than tags (2) | ||
| enum Tags Kind; | ||
| union { | ||
| int I; | ||
| float F; | ||
| char *Str; | ||
| } Data; | ||
| }; | ||
|
|
||
| How enum constants are counted | ||
| ------------------------------ | ||
|
|
||
| The main complicating factor when counting the number of enum constants is that | ||
| some of them might be auxiliary values that purposefully don't have a corresponding union | ||
| data member and are used for something else. For example the last enum constant | ||
| sometimes explicitly "points to" the last declared valid enum constant or | ||
| tracks how many enum constants have been declared. | ||
|
|
||
| For an illustration: | ||
|
|
||
| .. code-block:: c++ | ||
|
|
||
| enum TagWithLast { | ||
| Tag1 = 0, | ||
| Tag2 = 1, | ||
| Tag3 = 2, | ||
| LastTag = 2 | ||
| }; | ||
|
|
||
| enum TagWithCounter { | ||
| Tag1, // is 0 | ||
| Tag2, // is 1 | ||
| Tag3, // is 2 | ||
| TagCount, // is 3 | ||
| }; | ||
|
|
||
| The check counts the number of distinct values among the enum constants and not the enum | ||
| constants themselves. This way the enum constants that are essentially just aliases of other | ||
| enum constants are not included in the final count. | ||
|
|
||
| Handling of counting enum constants (ones like :code:`TagCount` in the previous code example) | ||
| is done by decreasing the number of enum values by one if the name of the last enum constant | ||
| starts with a prefix or ends with a suffix specified in :option:`CountingEnumPrefixes`, | ||
| :option:`CountingEnumSuffixes` and it's value is one less than the total number of distinct | ||
| values in the enum. | ||
|
|
||
| When the final count is adjusted based on this heuristic then a diagnostic note is emitted | ||
| that shows which enum constant matched the criteria. | ||
|
|
||
| The heuristic can be disabled entirely (:option:`EnableCountingEnumHeuristic`) or | ||
| configured to follow your naming convention (:option:`CountingEnumPrefixes`, :option:`CountingEnumSuffixes`). | ||
| The strings specified in :option:`CountingEnumPrefixes`, :option:`CountingEnumSuffixes` are matched | ||
| case insensitively. | ||
|
|
||
| Example counts: | ||
|
|
||
| .. code-block:: c++ | ||
|
|
||
| // Enum count is 3, because the value 2 is counted only once | ||
| enum TagWithLast { | ||
| Tag1 = 0, | ||
| Tag2 = 1, | ||
| Tag3 = 2, | ||
| LastTag = 2 | ||
| }; | ||
|
|
||
| // Enum count is 3, because TagCount is heuristically excluded | ||
| enum TagWithCounter { | ||
| Tag1, // is 0 | ||
| Tag2, // is 1 | ||
| Tag3, // is 2 | ||
| TagCount, // is 3 | ||
| }; | ||
|
|
||
|
|
||
| Options | ||
| ------- | ||
|
|
||
| .. option:: EnableCountingEnumHeuristic | ||
|
|
||
| This option enables or disables the counting enum heuristic. | ||
| It uses the prefixes and suffixes specified in the options | ||
| :option:`CountingEnumPrefixes`, :option:`CountingEnumSuffixes` to find counting enum constants by | ||
| using them for prefix and suffix matching. | ||
|
|
||
| This option is enabled by default. | ||
|
|
||
| When :option:`EnableCountingEnumHeuristic` is `false`: | ||
|
|
||
| .. code-block:: c++ | ||
|
|
||
| enum TagWithCounter { | ||
| Tag1, | ||
| Tag2, | ||
| Tag3, | ||
| TagCount, | ||
| }; | ||
|
|
||
| struct TaggedUnion { | ||
| TagWithCounter Kind; | ||
| union { | ||
| int A; | ||
| long B; | ||
| char *Str; | ||
| float F; | ||
| } Data; | ||
| }; | ||
|
|
||
| When :option:`EnableCountingEnumHeuristic` is `true`: | ||
|
|
||
| .. code-block:: c++ | ||
|
|
||
| enum TagWithCounter { | ||
| Tag1, | ||
| Tag2, | ||
| Tag3, | ||
| TagCount, | ||
| }; | ||
|
|
||
| struct TaggedUnion { // warning: tagged union has more data members (4) than tags (3) | ||
| TagWithCounter Kind; | ||
| union { | ||
| int A; | ||
| long B; | ||
| char *Str; | ||
| float F; | ||
| } Data; | ||
| }; | ||
|
|
||
| .. option:: CountingEnumPrefixes | ||
|
|
||
| See :option:`CountingEnumSuffixes` below. | ||
|
|
||
| .. option:: CountingEnumSuffixes | ||
|
|
||
| CountingEnumPrefixes and CountingEnumSuffixes are lists of semicolon | ||
| separated strings that are used to search for possible counting enum constants. | ||
| These strings are matched case insensitively as prefixes and suffixes | ||
| respectively on the names of the enum constants. | ||
| If :option:`EnableCountingEnumHeuristic` is `false` then these options do nothing. | ||
|
|
||
| The default value of :option:`CountingEnumSuffixes` is `count` and of | ||
| :option:`CountingEnumPrefixes` is the empty string. | ||
|
|
||
| When :option:`EnableCountingEnumHeuristic` is `true` and :option:`CountingEnumSuffixes` | ||
| is `count;size`: | ||
|
|
||
| .. code-block:: c++ | ||
|
|
||
| enum TagWithCounterCount { | ||
| Tag1, | ||
| Tag2, | ||
| Tag3, | ||
| TagCount, | ||
| }; | ||
|
|
||
| struct TaggedUnionCount { // warning: tagged union has more data members (4) than tags (3) | ||
| TagWithCounterCount Kind; | ||
| union { | ||
| int A; | ||
| long B; | ||
| char *Str; | ||
| float F; | ||
| } Data; | ||
| }; | ||
|
|
||
| enum TagWithCounterSize { | ||
| Tag11, | ||
| Tag22, | ||
| Tag33, | ||
| TagSize, | ||
| }; | ||
|
|
||
| struct TaggedUnionSize { // warning: tagged union has more data members (4) than tags (3) | ||
| TagWithCounterSize Kind; | ||
| union { | ||
| int A; | ||
| long B; | ||
| char *Str; | ||
| float F; | ||
| } Data; | ||
| }; | ||
|
|
||
| When :option:`EnableCountingEnumHeuristic` is `true` and :option:`CountingEnumPrefixes` is `maxsize;last_` | ||
|
|
||
| .. code-block:: c++ | ||
|
|
||
| enum TagWithCounterLast { | ||
| Tag1, | ||
| Tag2, | ||
| Tag3, | ||
| last_tag, | ||
| }; | ||
|
|
||
| struct TaggedUnionLast { // warning: tagged union has more data members (4) than tags (3) | ||
| TagWithCounterLast tag; | ||
| union { | ||
| int I; | ||
| short S; | ||
| char *C; | ||
| float F; | ||
| } Data; | ||
| }; | ||
|
|
||
| enum TagWithCounterMaxSize { | ||
| Tag1, | ||
| Tag2, | ||
| Tag3, | ||
| MaxSizeTag, | ||
| }; | ||
|
|
||
| struct TaggedUnionMaxSize { // warning: tagged union has more data members (4) than tags (3) | ||
| TagWithCounterMaxSize tag; | ||
| union { | ||
| int I; | ||
| short S; | ||
| char *C; | ||
| float F; | ||
| } Data; | ||
| }; | ||
|
|
||
| .. option:: StrictMode | ||
|
|
||
| When enabled, the check will also give a warning, when the number of tags | ||
| is greater than the number of union data members. | ||
|
|
||
| This option is disabled by default. | ||
|
|
||
| When :option:`StrictMode` is `false`: | ||
|
|
||
| .. code-block:: c++ | ||
|
|
||
| struct TaggedUnion { | ||
| enum { | ||
| Tag1, | ||
| Tag2, | ||
| Tag3, | ||
| } Tags; | ||
| union { | ||
| int I; | ||
| float F; | ||
| } Data; | ||
| }; | ||
|
|
||
| When :option:`StrictMode` is `true`: | ||
|
|
||
| .. code-block:: c++ | ||
|
|
||
| struct TaggedUnion { // warning: tagged union has fewer data members (2) than tags (3) | ||
| enum { | ||
| Tag1, | ||
| Tag2, | ||
| Tag3, | ||
| } Tags; | ||
| union { | ||
| int I; | ||
| float F; | ||
| } Data; | ||
| }; |