summaryrefslogtreecommitdiff
path: root/compilerplugins
diff options
context:
space:
mode:
Diffstat (limited to 'compilerplugins')
-rw-r--r--compilerplugins/clang/fakebool.cxx (renamed from compilerplugins/clang/salbool.cxx)720
-rw-r--r--compilerplugins/clang/test/fakebool.cxx (renamed from compilerplugins/clang/test/salbool.cxx)6
2 files changed, 477 insertions, 249 deletions
diff --git a/compilerplugins/clang/salbool.cxx b/compilerplugins/clang/fakebool.cxx
index fdadfc6b795a..1dbb535ceef9 100644
--- a/compilerplugins/clang/salbool.cxx
+++ b/compilerplugins/clang/fakebool.cxx
@@ -10,27 +10,167 @@
#include <algorithm>
#include <cassert>
#include <limits>
-#include <set>
+#include <map>
#include <string>
#include "clang/AST/Attr.h"
#include "check.hxx"
#include "compat.hxx"
+#include "functionaddress.hxx"
#include "plugin.hxx"
namespace {
-bool isSalBool(QualType type) {
+// BEGIN code copied from LLVM's clang/lib/Sema/Sema.cpp
+
+typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
+
+/// Returns true, if all methods and nested classes of the given
+/// CXXRecordDecl are defined in this translation unit.
+///
+/// Should only be called from ActOnEndOfTranslationUnit so that all
+/// definitions are actually read.
+static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD,
+ RecordCompleteMap &MNCComplete) {
+ RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
+ if (Cache != MNCComplete.end())
+ return Cache->second;
+ if (!RD->isCompleteDefinition())
+ return false;
+ bool Complete = true;
+ for (DeclContext::decl_iterator I = RD->decls_begin(),
+ E = RD->decls_end();
+ I != E && Complete; ++I) {
+ if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
+ Complete = M->isDefined() || M->isDefaulted() ||
+ (M->isPure() && !isa<CXXDestructorDecl>(M));
+ else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
+ // If the template function is marked as late template parsed at this
+ // point, it has not been instantiated and therefore we have not
+ // performed semantic analysis on it yet, so we cannot know if the type
+ // can be considered complete.
+ Complete = !F->getTemplatedDecl()->isLateTemplateParsed() &&
+ F->getTemplatedDecl()->isDefined();
+ else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
+ if (R->isInjectedClassName())
+ continue;
+ if (R->hasDefinition())
+ Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
+ MNCComplete);
+ else
+ Complete = false;
+ }
+ }
+ MNCComplete[RD] = Complete;
+ return Complete;
+}
+
+/// Returns true, if the given CXXRecordDecl is fully defined in this
+/// translation unit, i.e. all methods are defined or pure virtual and all
+/// friends, friend functions and nested classes are fully defined in this
+/// translation unit.
+///
+/// Should only be called from ActOnEndOfTranslationUnit so that all
+/// definitions are actually read.
+static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
+ RecordCompleteMap &RecordsComplete,
+ RecordCompleteMap &MNCComplete) {
+ RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
+ if (Cache != RecordsComplete.end())
+ return Cache->second;
+ bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
+ for (CXXRecordDecl::friend_iterator I = RD->friend_begin(),
+ E = RD->friend_end();
+ I != E && Complete; ++I) {
+ // Check if friend classes and methods are complete.
+ if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
+ // Friend classes are available as the TypeSourceInfo of the FriendDecl.
+ if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
+ Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
+ else
+ Complete = false;
+ } else {
+ // Friend functions are available through the NamedDecl of FriendDecl.
+ if (const FunctionDecl *FD =
+ dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
+ Complete = FD->isDefined();
+ else
+ // This is a template friend, give up.
+ Complete = false;
+ }
+ }
+ RecordsComplete[RD] = Complete;
+ return Complete;
+}
+
+RecordCompleteMap RecordsComplete;
+RecordCompleteMap MNCComplete;
+
+// END code copied from LLVM's clang/lib/Sema/Sema.cpp
+
+// Is all code that could see `decl` defined in this TU?
+bool isAllRelevantCodeDefined(NamedDecl const * decl) {
+ switch (decl->getAccess()) {
+ case AS_protected:
+ if (!cast<CXXRecordDecl>(decl->getDeclContext())->hasAttr<FinalAttr>()) {
+ break;
+ }
+ LLVM_FALLTHROUGH;
+ case AS_private:
+ if (IsRecordFullyDefined(
+ cast<CXXRecordDecl>(decl->getDeclContext()), RecordsComplete, MNCComplete))
+ {
+ return true;
+ }
+ break;
+ default:
+ break;
+ }
+ return !decl->isExternallyVisible();
+}
+
+enum FakeBoolKind {
+ FBK_No,
+ FBK_BOOL, FBK_First = FBK_BOOL,
+ FBK_Boolean, FBK_FT_Bool, FBK_FcBool, FBK_GLboolean, FBK_NPBool, FBK_TW_BOOL, FBK_UBool,
+ FBK_boolean, FBK_dbus_bool_t, FBK_gboolean, FBK_hb_boot_t, FBK_jboolean, FBK_my_bool,
+ FBK_sal_Bool,
+ FBK_End };
+ // matches loplugin::TypeCheck::AnyBoolean (compilerplugins/clang/check.hxx)
+
+StringRef getName(FakeBoolKind k) {
+ static constexpr llvm::StringLiteral names[] = {
+ "BOOL", "Boolean", "FT_Bool", "FcBool", "GLboolean", "NPBool", "TW_BOOL", "UBool",
+ "boolean", "dbus_bool_t", "gboolean", "hb_boot_t", "jboolean", "my_bool", "sal_Bool"};
+ assert(k >= FBK_First && k < FBK_End);
+ return names[k - FBK_First];
+}
+
+FakeBoolKind isFakeBool(QualType type) {
TypedefType const * t = type->getAs<TypedefType>();
- return t != nullptr && t->getDecl()->getName() == "sal_Bool";
+ if (t != nullptr) {
+ auto const name = t->getDecl()->getName();
+ for (int i = FBK_First; i != FBK_End; ++i) {
+ auto const k = FakeBoolKind(i);
+ if (name == getName(k)) {
+ return k;
+ }
+ }
+ }
+ return FBK_No;
}
-bool isSalBoolArray(QualType type) {
+FakeBoolKind isFakeBoolArray(QualType type) {
auto t = type->getAsArrayTypeUnsafe();
- return t != nullptr
- && (isSalBool(t->getElementType())
- || isSalBoolArray(t->getElementType()));
+ if (t == nullptr) {
+ return FBK_No;
+ }
+ auto const k = isFakeBool(t->getElementType());
+ if (k != FBK_No) {
+ return k;
+ }
+ return isFakeBoolArray(t->getElementType());
}
// It appears that, given a function declaration, there is no way to determine
@@ -78,27 +218,27 @@ BoolOverloadKind isBoolOverloadOf(
if (!mustBeDeleted || f->isDeleted()) {
unsigned n = decl->getNumParams();
if (f->getNumParams() == n) {
- bool hasSB = false;
+ bool hasFB = false;
for (unsigned i = 0; i != n; ++i) {
QualType t1 { decl->getParamDecl(i)->getType() };
- bool isSB = isSalBool(t1);
- bool isSBRef = !isSB && t1->isReferenceType()
- && isSalBool(t1.getNonReferenceType());
+ bool isFB = isFakeBool(t1) != FBK_No;
+ bool isFBRef = !isFB && t1->isReferenceType()
+ && isFakeBool(t1.getNonReferenceType()) != FBK_No;
QualType t2 { f->getParamDecl(i)->getType() };
- if (!(isSB
+ if (!(isFB
? t2->isBooleanType()
- : isSBRef
+ : isFBRef
? (t2->isReferenceType()
&& t2.getNonReferenceType()->isBooleanType())
: t2.getCanonicalType() == t1.getCanonicalType()))
{
return BoolOverloadKind::CheckNext;
}
- hasSB |= isSB || isSBRef;
+ hasFB |= isFB || isFBRef;
}
- return hasSB ? BoolOverloadKind::Yes : BoolOverloadKind::No;
+ return hasFB ? BoolOverloadKind::Yes : BoolOverloadKind::No;
// cheaply protect against the case where decl would have no
- // sal_Bool parameters at all and would match itself
+ // fake bool parameters at all and would match itself
}
}
return BoolOverloadKind::CheckNext;
@@ -142,12 +282,12 @@ bool hasBoolOverload(FunctionDecl const * decl, bool mustBeDeleted) {
return false;
}
-class SalBool:
- public loplugin::FilteringRewritePlugin<SalBool>
+class FakeBool:
+ public loplugin::FunctionAddress<loplugin::FilteringRewritePlugin<FakeBool>>
{
public:
- explicit SalBool(loplugin::InstantiationData const & data):
- FilteringRewritePlugin(data) {}
+ explicit FakeBool(loplugin::InstantiationData const & data):
+ FunctionAddress(data) {}
virtual void run() override;
@@ -190,16 +330,20 @@ private:
bool isInSpecialMainFile(SourceLocation spellingLocation) const;
- bool rewrite(SourceLocation location);
+ bool rewrite(SourceLocation location, FakeBoolKind kind);
- std::set<VarDecl const *> varDecls_;
+ std::map<VarDecl const *, FakeBoolKind> varDecls_;
+ std::map<FieldDecl const *, FakeBoolKind> fieldDecls_;
+ std::map<ParmVarDecl const *, FakeBoolKind> parmVarDecls_;
+ std::map<FunctionDecl const *, FakeBoolKind> functionDecls_;
unsigned int externCContexts_ = 0;
};
-void SalBool::run() {
+void FakeBool::run() {
if (compiler.getLangOpts().CPlusPlus) {
TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());
- for (auto decl: varDecls_) {
+ for (auto const dcl: varDecls_) {
+ auto const decl = dcl.first; auto const fbk = dcl.second;
SourceLocation loc { compat::getBeginLoc(decl) };
TypeSourceInfo * tsi = decl->getTypeSourceInfo();
if (tsi != nullptr) {
@@ -221,7 +365,95 @@ void SalBool::run() {
std::string s {
compiler.getSourceManager().getCharacterData(l),
n };
- if (s == "sal_Bool") {
+ if (s == getName(fbk)) {
+ loc = l;
+ break;
+ }
+ if (l == end) {
+ break;
+ }
+ l = l.getLocWithOffset(std::max<unsigned>(n, 1));
+ }
+ }
+ }
+ if (!rewrite(loc, fbk)) {
+ report(
+ DiagnosticsEngine::Warning,
+ "VarDecl, use \"bool\" instead of %0", loc)
+ << decl->getType().getLocalUnqualifiedType()
+ << decl->getSourceRange();
+ }
+ }
+ for (auto const dcl: fieldDecls_) {
+ auto const decl = dcl.first; auto const fbk = dcl.second;
+ SourceLocation loc { compat::getBeginLoc(decl) };
+ TypeSourceInfo * tsi = decl->getTypeSourceInfo();
+ if (tsi != nullptr) {
+ SourceLocation l {
+ compiler.getSourceManager().getExpansionLoc(
+ tsi->getTypeLoc().getBeginLoc()) };
+ SourceLocation end {
+ compiler.getSourceManager().getExpansionLoc(
+ tsi->getTypeLoc().getEndLoc()) };
+ assert(l.isFileID() && end.isFileID());
+ if (l == end
+ || compiler.getSourceManager().isBeforeInTranslationUnit(
+ l, end))
+ {
+ for (;;) {
+ unsigned n = Lexer::MeasureTokenLength(
+ l, compiler.getSourceManager(),
+ compiler.getLangOpts());
+ std::string s {
+ compiler.getSourceManager().getCharacterData(l),
+ n };
+ if (s == getName(fbk)) {
+ loc = l;
+ break;
+ }
+ if (l == end) {
+ break;
+ }
+ l = l.getLocWithOffset(std::max<unsigned>(n, 1));
+ }
+ }
+ }
+ if (!rewrite(loc, fbk)) {
+ report(
+ DiagnosticsEngine::Warning,
+ "FieldDecl, use \"bool\" instead of %0", loc)
+ << decl->getType().getLocalUnqualifiedType() << decl->getSourceRange();
+ }
+ }
+ auto const ignoredFns = getFunctionsWithAddressTaken();
+ for (auto const dcl: parmVarDecls_) {
+ auto const decl = dcl.first; auto const fbk = dcl.second;
+ FunctionDecl const * f = cast<FunctionDecl>(decl->getDeclContext())->getCanonicalDecl();
+ if (ignoredFns.find(f) != ignoredFns.end()) {
+ continue;
+ }
+ SourceLocation loc { compat::getBeginLoc(decl) };
+ TypeSourceInfo * tsi = decl->getTypeSourceInfo();
+ if (tsi != nullptr) {
+ SourceLocation l {
+ compiler.getSourceManager().getExpansionLoc(
+ tsi->getTypeLoc().getBeginLoc()) };
+ SourceLocation end {
+ compiler.getSourceManager().getExpansionLoc(
+ tsi->getTypeLoc().getEndLoc()) };
+ assert(l.isFileID() && end.isFileID());
+ if (l == end
+ || (compiler.getSourceManager()
+ .isBeforeInTranslationUnit(l, end)))
+ {
+ for (;;) {
+ unsigned n = Lexer::MeasureTokenLength(
+ l, compiler.getSourceManager(),
+ compiler.getLangOpts());
+ std::string s {
+ compiler.getSourceManager().getCharacterData(l),
+ n };
+ if (s == getName(fbk)) {
loc = l;
break;
}
@@ -232,31 +464,114 @@ void SalBool::run() {
}
}
}
- if (!rewrite(loc)) {
+ // Only rewrite declarations in include files if a
+ // definition is also seen, to avoid compilation of a
+ // definition (in a main file only processed later) to fail
+ // with a "mismatch" error before the rewriter had a chance
+ // to act upon the definition (but use the heuristic of
+ // assuming pure virtual functions do not have definitions);
+ // also, do not automatically rewrite functions that could
+ // implicitly override depend base functions (and thus stop
+ // doing so after the rewrite; note that this is less
+ // dangerous for return types than for parameter types,
+ // where the function would still implicitly override and
+ // cause a compilation error due to the incompatible return
+ // type):
+ OverrideKind k = getOverrideKind(f);
+ if (!((compiler.getSourceManager().isInMainFile(
+ compiler.getSourceManager().getSpellingLoc(
+ dyn_cast<FunctionDecl>(
+ decl->getDeclContext())
+ ->getNameInfo().getLoc()))
+ || f->isDefined() || f->isPure())
+ && k != OverrideKind::MAYBE && rewrite(loc, fbk)))
+ {
report(
DiagnosticsEngine::Warning,
- "VarDecl, use \"bool\" instead of \"sal_Bool\"", loc)
+ ("ParmVarDecl, use \"bool\" instead of"
+ " %0%1"),
+ loc)
+ << decl->getType().getNonReferenceType().getLocalUnqualifiedType()
+ << (k == OverrideKind::MAYBE
+ ? (" (unless this member function overrides a"
+ " dependent base member function, even"
+ " though it is not marked 'override')")
+ : "")
+ << decl->getSourceRange();
+ }
+ }
+ for (auto const dcl: functionDecls_) {
+ auto const decl = dcl.first; auto const fbk = dcl.second;
+ FunctionDecl const * f = decl->getCanonicalDecl();
+ if (ignoredFns.find(f) != ignoredFns.end()) {
+ continue;
+ }
+ SourceLocation loc { compat::getBeginLoc(decl) };
+ SourceLocation l { compiler.getSourceManager().getExpansionLoc(
+ loc) };
+ SourceLocation end { compiler.getSourceManager().getExpansionLoc(
+ decl->getNameInfo().getLoc()) };
+ assert(l.isFileID() && end.isFileID());
+ if (compiler.getSourceManager().isBeforeInTranslationUnit(l, end)) {
+ while (l != end) {
+ unsigned n = Lexer::MeasureTokenLength(
+ l, compiler.getSourceManager(), compiler.getLangOpts());
+ std::string s {
+ compiler.getSourceManager().getCharacterData(l), n };
+ if (s == getName(fbk)) {
+ loc = l;
+ break;
+ }
+ l = l.getLocWithOffset(std::max<unsigned>(n, 1));
+ }
+ }
+ // Only rewrite declarations in include files if a definition is
+ // also seen, to avoid compilation of a definition (in a main file
+ // only processed later) to fail with a "mismatch" error before the
+ // rewriter had a chance to act upon the definition (but use the
+ // heuristic of assuming pure virtual functions do not have
+ // definitions):
+ if (!((compiler.getSourceManager().isInMainFile(
+ compiler.getSourceManager().getSpellingLoc(
+ decl->getNameInfo().getLoc()))
+ || f->isDefined() || f->isPure())
+ && rewrite(loc, fbk)))
+ {
+ report(
+ DiagnosticsEngine::Warning,
+ "use \"bool\" instead of %0 as return type%1",
+ loc)
+ << decl->getReturnType().getNonReferenceType().getLocalUnqualifiedType()
+ << (getOverrideKind(f) == OverrideKind::MAYBE
+ ? (" (unless this member function overrides a dependent"
+ " base member function, even though it is not marked"
+ " 'override')")
+ : "")
<< decl->getSourceRange();
}
}
}
}
-bool SalBool::VisitUnaryAddrOf(UnaryOperator const * op) {
+bool FakeBool::VisitUnaryAddrOf(UnaryOperator const * op) {
+ FunctionAddress::VisitUnaryAddrOf(op);
Expr const * e1 = op->getSubExpr()->IgnoreParenCasts();
- if (isSalBool(e1->getType())) {
- DeclRefExpr const * e2 = dyn_cast<DeclRefExpr>(e1);
- if (e2 != nullptr) {
+ if (isFakeBool(e1->getType()) != FBK_No) {
+ if (DeclRefExpr const * e2 = dyn_cast<DeclRefExpr>(e1)) {
VarDecl const * d = dyn_cast<VarDecl>(e2->getDecl());
if (d != nullptr) {
varDecls_.erase(d);
}
+ } else if (auto const e3 = dyn_cast<MemberExpr>(e1)) {
+ if (auto const d = dyn_cast<FieldDecl>(e3->getMemberDecl())) {
+ fieldDecls_.erase(d);
+ }
}
}
return true;
}
-bool SalBool::VisitCallExpr(CallExpr * expr) {
+bool FakeBool::VisitCallExpr(CallExpr * expr) {
Decl const * d = expr->getCalleeDecl();
FunctionProtoType const * ft = nullptr;
if (d != nullptr) {
@@ -290,7 +605,7 @@ bool SalBool::VisitCallExpr(CallExpr * expr) {
bool b = false;
if (t->isLValueReferenceType()) {
t = t.getNonReferenceType();
- b = !t.isConstQualified() && isSalBool(t);
+ b = !t.isConstQualified() && isFakeBool(t) != FBK_No;
} else if (t->isPointerType()) {
for (;;) {
auto t2 = t->getAs<clang::PointerType>();
@@ -299,16 +614,19 @@ bool SalBool::VisitCallExpr(CallExpr * expr) {
}
t = t2->getPointeeType();
}
- b = isSalBool(t);
+ b = isFakeBool(t) != FBK_No;
}
if (b && i < expr->getNumArgs()) {
- DeclRefExpr * ref = dyn_cast<DeclRefExpr>(
- expr->getArg(i)->IgnoreParenImpCasts());
- if (ref != nullptr) {
+ auto const e1 = expr->getArg(i)->IgnoreParenImpCasts();
+ if (DeclRefExpr * ref = dyn_cast<DeclRefExpr>(e1)) {
VarDecl const * d = dyn_cast<VarDecl>(ref->getDecl());
if (d != nullptr) {
varDecls_.erase(d);
}
+ } else if (auto const e2 = dyn_cast<MemberExpr>(e1)) {
+ if (auto const d = dyn_cast<FieldDecl>(e2->getMemberDecl())) {
+ fieldDecls_.erase(d);
+ }
}
}
}
@@ -316,11 +634,12 @@ bool SalBool::VisitCallExpr(CallExpr * expr) {
return true;
}
-bool SalBool::VisitCStyleCastExpr(CStyleCastExpr * expr) {
+bool FakeBool::VisitCStyleCastExpr(CStyleCastExpr * expr) {
if (ignoreLocation(expr)) {
return true;
}
- if (isSalBool(expr->getType())) {
+ auto const k = isFakeBool(expr->getType());
+ if (k != FBK_No) {
SourceLocation loc { compat::getBeginLoc(expr) };
while (compiler.getSourceManager().isMacroArgExpansion(loc)) {
loc = compiler.getSourceManager().getImmediateMacroCallerLoc(loc);
@@ -328,7 +647,7 @@ bool SalBool::VisitCStyleCastExpr(CStyleCastExpr * expr) {
if (compiler.getSourceManager().isMacroBodyExpansion(loc)) {
StringRef name { Lexer::getImmediateMacroName(
loc, compiler.getSourceManager(), compiler.getLangOpts()) };
- if (name == "sal_False" || name == "sal_True") {
+ if (k == FBK_sal_Bool && (name == "sal_False" || name == "sal_True")) {
auto callLoc = compiler.getSourceManager()
.getImmediateMacroCallerLoc(loc);
if (!isSharedCAndCppCode(callLoc)) {
@@ -345,7 +664,7 @@ bool SalBool::VisitCStyleCastExpr(CStyleCastExpr * expr) {
// arguments to CPPUNIT_ASSERT_EQUAL:
return true;
}
- bool b = name == "sal_True";
+ bool b = k == FBK_sal_Bool && name == "sal_True";
if (rewriter != nullptr) {
auto callSpellLoc = compiler.getSourceManager()
.getSpellingLoc(callLoc);
@@ -380,29 +699,34 @@ bool SalBool::VisitCStyleCastExpr(CStyleCastExpr * expr) {
return true;
}
-bool SalBool::VisitCXXStaticCastExpr(CXXStaticCastExpr * expr) {
+bool FakeBool::VisitCXXStaticCastExpr(CXXStaticCastExpr * expr) {
if (ignoreLocation(expr)) {
return true;
}
- if (isSalBool(expr->getType())
- && !isInSpecialMainFile(
+ auto const k = isFakeBool(expr->getType());
+ if (k == FBK_No) {
+ return true;
+ }
+ if (k == FBK_sal_Bool
+ && isInSpecialMainFile(
compiler.getSourceManager().getSpellingLoc(compat::getBeginLoc(expr))))
{
- report(
- DiagnosticsEngine::Warning,
- "CXXStaticCastExpr, suspicious cast from %0 to %1",
- compat::getBeginLoc(expr))
- << expr->getSubExpr()->IgnoreParenImpCasts()->getType()
- << expr->getType() << expr->getSourceRange();
+ return true;
}
+ report(
+ DiagnosticsEngine::Warning,
+ "CXXStaticCastExpr, suspicious cast from %0 to %1",
+ compat::getBeginLoc(expr))
+ << expr->getSubExpr()->IgnoreParenImpCasts()->getType()
+ << expr->getType() << expr->getSourceRange();
return true;
}
-bool SalBool::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr * expr) {
+bool FakeBool::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr * expr) {
if (ignoreLocation(expr)) {
return true;
}
- if (isSalBool(expr->getType())) {
+ if (isFakeBool(expr->getType()) != FBK_No) {
report(
DiagnosticsEngine::Warning,
"CXXFunctionalCastExpr, suspicious cast from %0 to %1",
@@ -413,11 +737,13 @@ bool SalBool::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr * expr) {
return true;
}
-bool SalBool::VisitImplicitCastExpr(ImplicitCastExpr * expr) {
+bool FakeBool::VisitImplicitCastExpr(ImplicitCastExpr * expr) {
+ FunctionAddress::VisitImplicitCastExpr(expr);
if (ignoreLocation(expr)) {
return true;
}
- if (!isSalBool(expr->getType())) {
+ auto const k = isFakeBool(expr->getType());
+ if (k == FBK_No) {
return true;
}
auto l = compat::getBeginLoc(expr);
@@ -427,7 +753,11 @@ bool SalBool::VisitImplicitCastExpr(ImplicitCastExpr * expr) {
if (compiler.getSourceManager().isMacroBodyExpansion(l)) {
auto n = Lexer::getImmediateMacroName(
l, compiler.getSourceManager(), compiler.getLangOpts());
- if (n == "sal_False" || n == "sal_True") {
+ if ((k == FBK_GLboolean && (n == "GL_FALSE" || n == "GL_TRUE"))
+ || (k == FBK_UBool && (n == "FALSE" || n == "TRUE"))
+ || (k == FBK_jboolean && (n == "JNI_FALSE" || n == "JNI_TRUE"))
+ || (k == FBK_sal_Bool && (n == "sal_False" || n == "sal_True")))
+ {
return true;
}
}
@@ -454,13 +784,13 @@ bool SalBool::VisitImplicitCastExpr(ImplicitCastExpr * expr) {
}
}
report(
- DiagnosticsEngine::Warning, "conversion from %0 to sal_Bool",
+ DiagnosticsEngine::Warning, "conversion from %0 to %1",
compat::getBeginLoc(expr))
- << t << expr->getSourceRange();
+ << t << expr->getType() << expr->getSourceRange();
return true;
}
-bool SalBool::VisitReturnStmt(ReturnStmt const * stmt) {
+bool FakeBool::VisitReturnStmt(ReturnStmt const * stmt) {
// Just enough to avoid warnings in rtl_getUriCharClass (sal/rtl/uri.cxx),
// which has
//
@@ -488,7 +818,7 @@ bool SalBool::VisitReturnStmt(ReturnStmt const * stmt) {
}
t = t2->getPointeeType();
}
- if (!isSalBool(t)) {
+ if (isFakeBool(t) != FBK_sal_Bool) {
return true;
}
auto e2 = dyn_cast<ArraySubscriptExpr>(e->IgnoreParenImpCasts());
@@ -507,92 +837,30 @@ bool SalBool::VisitReturnStmt(ReturnStmt const * stmt) {
return true;
}
-bool SalBool::WalkUpFromParmVarDecl(ParmVarDecl const * decl) {
+bool FakeBool::WalkUpFromParmVarDecl(ParmVarDecl const * decl) {
return VisitParmVarDecl(decl);
}
-bool SalBool::VisitParmVarDecl(ParmVarDecl const * decl) {
+bool FakeBool::VisitParmVarDecl(ParmVarDecl const * decl) {
if (ignoreLocation(decl)) {
return true;
}
- if (isSalBool(decl->getType().getNonReferenceType())) {
+ auto const fbk = isFakeBool(decl->getType().getNonReferenceType());
+ if (fbk != FBK_No) {
FunctionDecl const * f = dyn_cast<FunctionDecl>(decl->getDeclContext());
if (f != nullptr) { // e.g.: typedef sal_Bool (* FuncPtr )( sal_Bool );
f = f->getCanonicalDecl();
- if (!(hasCLanguageLinkageType(f)
- || (isInUnoIncludeFile(f)
- && (!f->isInlined() || f->hasAttr<DeprecatedAttr>()
- || decl->getType()->isReferenceType()
- || hasBoolOverload(f, false)))
- || f->isDeleted() || hasBoolOverload(f, true)))
+ if (isAllRelevantCodeDefined(f)
+ && !(hasCLanguageLinkageType(f)
+ || (fbk == FBK_sal_Bool && isInUnoIncludeFile(f)
+ && (!f->isInlined() || f->hasAttr<DeprecatedAttr>()
+ || decl->getType()->isReferenceType()
+ || hasBoolOverload(f, false)))
+ || f->isDeleted() || hasBoolOverload(f, true)))
{
OverrideKind k = getOverrideKind(f);
if (k != OverrideKind::YES) {
- SourceLocation loc { compat::getBeginLoc(decl) };
- TypeSourceInfo * tsi = decl->getTypeSourceInfo();
- if (tsi != nullptr) {
- SourceLocation l {
- compiler.getSourceManager().getExpansionLoc(
- tsi->getTypeLoc().getBeginLoc()) };
- SourceLocation end {
- compiler.getSourceManager().getExpansionLoc(
- tsi->getTypeLoc().getEndLoc()) };
- assert(l.isFileID() && end.isFileID());
- if (l == end
- || (compiler.getSourceManager()
- .isBeforeInTranslationUnit(l, end)))
- {
- for (;;) {
- unsigned n = Lexer::MeasureTokenLength(
- l, compiler.getSourceManager(),
- compiler.getLangOpts());
- std::string s {
- compiler.getSourceManager().getCharacterData(l),
- n };
- if (s == "sal_Bool") {
- loc = l;
- break;
- }
- if (l == end) {
- break;
- }
- l = l.getLocWithOffset(std::max<unsigned>(n, 1));
- }
- }
- }
- // Only rewrite declarations in include files if a
- // definition is also seen, to avoid compilation of a
- // definition (in a main file only processed later) to fail
- // with a "mismatch" error before the rewriter had a chance
- // to act upon the definition (but use the heuristic of
- // assuming pure virtual functions do not have definitions);
- // also, do not automatically rewrite functions that could
- // implicitly override depend base functions (and thus stop
- // doing so after the rewrite; note that this is less
- // dangerous for return types than for parameter types,
- // where the function would still implicitly override and
- // cause a compilation error due to the incompatible return
- // type):
- if (!((compiler.getSourceManager().isInMainFile(
- compiler.getSourceManager().getSpellingLoc(
- dyn_cast<FunctionDecl>(
- decl->getDeclContext())
- ->getNameInfo().getLoc()))
- || f->isDefined() || f->isPure())
- && k != OverrideKind::MAYBE && rewrite(loc)))
- {
- report(
- DiagnosticsEngine::Warning,
- ("ParmVarDecl, use \"bool\" instead of"
- " \"sal_Bool\"%0"),
- loc)
- << (k == OverrideKind::MAYBE
- ? (" (unless this member function overrides a"
- " dependent base member function, even"
- " though it is not marked 'override')")
- : "")
- << decl->getSourceRange();
- }
+ parmVarDecls_.insert({decl, fbk});
}
}
}
@@ -600,96 +868,92 @@ bool SalBool::VisitParmVarDecl(ParmVarDecl const * decl) {
return true;
}
-bool SalBool::WalkUpFromVarDecl(VarDecl const * decl) {
+bool FakeBool::WalkUpFromVarDecl(VarDecl const * decl) {
return VisitVarDecl(decl);
}
-bool SalBool::VisitVarDecl(VarDecl const * decl) {
+bool FakeBool::VisitVarDecl(VarDecl const * decl) {
if (ignoreLocation(decl)) {
return true;
}
- if (!decl->isExternC()
- && (isSalBool(decl->getType()) || isSalBoolArray(decl->getType()))
- && !isInSpecialMainFile(
- compiler.getSourceManager().getSpellingLoc(compat::getBeginLoc(decl))))
+ if (decl->isExternC()) {
+ return true;
+ }
+ auto k = isFakeBool(decl->getType());
+ if (k == FBK_No) {
+ k = isFakeBoolArray(decl->getType());
+ }
+ if (k == FBK_No) {
+ return true;
+ }
+ auto const loc = compat::getBeginLoc(decl);
+ if (k == FBK_sal_Bool
+ && isInSpecialMainFile(
+ compiler.getSourceManager().getSpellingLoc(loc)))
+ {
+ return true;
+ }
+ auto l = loc;
+ while (compiler.getSourceManager().isMacroArgExpansion(l)) {
+ l = compiler.getSourceManager().getImmediateMacroCallerLoc(l);
+ }
+ if (compiler.getSourceManager().isMacroBodyExpansion(l)
+ && isSharedCAndCppCode(compiler.getSourceManager().getImmediateMacroCallerLoc(l)))
{
- varDecls_.insert(decl);
+ return true;
}
+ varDecls_.insert({decl, k});
return true;
}
-bool SalBool::WalkUpFromFieldDecl(FieldDecl const * decl) {
+bool FakeBool::WalkUpFromFieldDecl(FieldDecl const * decl) {
return VisitFieldDecl(decl);
}
-bool SalBool::VisitFieldDecl(FieldDecl const * decl) {
+bool FakeBool::VisitFieldDecl(FieldDecl const * decl) {
if (ignoreLocation(decl)) {
return true;
}
- if ((isSalBool(decl->getType()) || isSalBoolArray(decl->getType()))
- && !isInSpecialMainFile(
+ auto k = isFakeBool(decl->getType());
+ if (k == FBK_No) {
+ k = isFakeBoolArray(decl->getType());
+ }
+ if (k == FBK_No) {
+ return true;
+ }
+ if (!isAllRelevantCodeDefined(decl)) {
+ return true;
+ }
+ if (k == FBK_sal_Bool
+ && isInSpecialMainFile(
compiler.getSourceManager().getSpellingLoc(compat::getBeginLoc(decl))))
{
- TagDecl const * td = dyn_cast<TagDecl>(decl->getDeclContext());
- assert(td != nullptr);
- if (!(((td->isStruct() || td->isUnion()) && td->isExternCContext())
- || isInUnoIncludeFile(
- compiler.getSourceManager().getSpellingLoc(
- decl->getLocation()))))
- {
- SourceLocation loc { compat::getBeginLoc(decl) };
- TypeSourceInfo * tsi = decl->getTypeSourceInfo();
- if (tsi != nullptr) {
- SourceLocation l {
- compiler.getSourceManager().getExpansionLoc(
- tsi->getTypeLoc().getBeginLoc()) };
- SourceLocation end {
- compiler.getSourceManager().getExpansionLoc(
- tsi->getTypeLoc().getEndLoc()) };
- assert(l.isFileID() && end.isFileID());
- if (l == end
- || compiler.getSourceManager().isBeforeInTranslationUnit(
- l, end))
- {
- for (;;) {
- unsigned n = Lexer::MeasureTokenLength(
- l, compiler.getSourceManager(),
- compiler.getLangOpts());
- std::string s {
- compiler.getSourceManager().getCharacterData(l),
- n };
- if (s == "sal_Bool") {
- loc = l;
- break;
- }
- if (l == end) {
- break;
- }
- l = l.getLocWithOffset(std::max<unsigned>(n, 1));
- }
- }
- }
- if (!rewrite(loc)) {
- report(
- DiagnosticsEngine::Warning,
- "FieldDecl, use \"bool\" instead of \"sal_Bool\"", loc)
- << decl->getSourceRange();
- }
- }
+ return true;
+ }
+ TagDecl const * td = dyn_cast<TagDecl>(decl->getDeclContext());
+ assert(td != nullptr);
+ if (!(((td->isStruct() || td->isUnion()) && td->isExternCContext())
+ || isInUnoIncludeFile(
+ compiler.getSourceManager().getSpellingLoc(
+ decl->getLocation()))))
+ {
+ fieldDecls_.insert({decl, k});
}
return true;
}
-bool SalBool::WalkUpFromFunctionDecl(FunctionDecl const * decl) {
+bool FakeBool::WalkUpFromFunctionDecl(FunctionDecl const * decl) {
return VisitFunctionDecl(decl);
}
-bool SalBool::VisitFunctionDecl(FunctionDecl const * decl) {
+bool FakeBool::VisitFunctionDecl(FunctionDecl const * decl) {
if (ignoreLocation(decl)) {
return true;
}
- if (isSalBool(decl->getReturnType().getNonReferenceType())
- && !(decl->isDeletedAsWritten() && isa<CXXConversionDecl>(decl)))
+ auto const fbk = isFakeBool(decl->getReturnType().getNonReferenceType());
+ if (fbk != FBK_No
+ && !(decl->isDeletedAsWritten() && isa<CXXConversionDecl>(decl))
+ && isAllRelevantCodeDefined(decl))
{
FunctionDecl const * f = decl->getCanonicalDecl();
OverrideKind k = getOverrideKind(f);
@@ -698,68 +962,28 @@ bool SalBool::VisitFunctionDecl(FunctionDecl const * decl) {
|| (isInUnoIncludeFile(f)
&& (!f->isInlined() || f->hasAttr<DeprecatedAttr>()))))
{
- SourceLocation loc { compat::getBeginLoc(decl) };
- SourceLocation l { compiler.getSourceManager().getExpansionLoc(
- loc) };
- SourceLocation end { compiler.getSourceManager().getExpansionLoc(
- decl->getNameInfo().getLoc()) };
- assert(l.isFileID() && end.isFileID());
- if (compiler.getSourceManager().isBeforeInTranslationUnit(l, end)) {
- while (l != end) {
- unsigned n = Lexer::MeasureTokenLength(
- l, compiler.getSourceManager(), compiler.getLangOpts());
- std::string s {
- compiler.getSourceManager().getCharacterData(l), n };
- if (s == "sal_Bool") {
- loc = l;
- break;
- }
- l = l.getLocWithOffset(std::max<unsigned>(n, 1));
- }
- }
- // Only rewrite declarations in include files if a definition is
- // also seen, to avoid compilation of a definition (in a main file
- // only processed later) to fail with a "mismatch" error before the
- // rewriter had a chance to act upon the definition (but use the
- // heuristic of assuming pure virtual functions do not have
- // definitions):
- if (!((compiler.getSourceManager().isInMainFile(
- compiler.getSourceManager().getSpellingLoc(
- decl->getNameInfo().getLoc()))
- || f->isDefined() || f->isPure())
- && rewrite(loc)))
- {
- report(
- DiagnosticsEngine::Warning,
- "use \"bool\" instead of \"sal_Bool\" as return type%0",
- loc)
- << (k == OverrideKind::MAYBE
- ? (" (unless this member function overrides a dependent"
- " base member function, even though it is not marked"
- " 'override')")
- : "")
- << decl->getSourceRange();
- }
+ functionDecls_.insert({decl, fbk});
}
}
return true;
}
-bool SalBool::VisitValueDecl(ValueDecl const * decl) {
+bool FakeBool::VisitValueDecl(ValueDecl const * decl) {
if (ignoreLocation(decl)) {
return true;
}
- if (isSalBool(decl->getType()) && !rewrite(compat::getBeginLoc(decl))) {
+ auto const k = isFakeBool(decl->getType());
+ if (k != FBK_No && !rewrite(compat::getBeginLoc(decl), k)) {
report(
DiagnosticsEngine::Warning,
- "ValueDecl, use \"bool\" instead of \"sal_Bool\"",
+ "ValueDecl, use \"bool\" instead of %0",
compat::getBeginLoc(decl))
- << decl->getSourceRange();
+ << decl->getType() << decl->getSourceRange();
}
return true;
}
-bool SalBool::TraverseStaticAssertDecl(StaticAssertDecl * decl) {
+bool FakeBool::TraverseStaticAssertDecl(StaticAssertDecl * decl) {
// Ignore special code like
//
// static_cast<sal_Bool>(true) == sal_True
@@ -772,7 +996,7 @@ bool SalBool::TraverseStaticAssertDecl(StaticAssertDecl * decl) {
|| RecursiveASTVisitor::TraverseStaticAssertDecl(decl);
}
-bool SalBool::TraverseLinkageSpecDecl(LinkageSpecDecl * decl) {
+bool FakeBool::TraverseLinkageSpecDecl(LinkageSpecDecl * decl) {
assert(externCContexts_ != std::numeric_limits<unsigned int>::max()); //TODO
++externCContexts_;
bool ret = RecursiveASTVisitor::TraverseLinkageSpecDecl(decl);
@@ -781,7 +1005,7 @@ bool SalBool::TraverseLinkageSpecDecl(LinkageSpecDecl * decl) {
return ret;
}
-bool SalBool::isFromCIncludeFile(SourceLocation spellingLocation) const {
+bool FakeBool::isFromCIncludeFile(SourceLocation spellingLocation) const {
return !compiler.getSourceManager().isInMainFile(spellingLocation)
&& (StringRef(
compiler.getSourceManager().getPresumedLoc(spellingLocation)
@@ -789,7 +1013,7 @@ bool SalBool::isFromCIncludeFile(SourceLocation spellingLocation) const {
.endswith(".h"));
}
-bool SalBool::isSharedCAndCppCode(SourceLocation location) const {
+bool FakeBool::isSharedCAndCppCode(SourceLocation location) const {
// Assume that code is intended to be shared between C and C++ if it comes
// from an include file ending in .h, and is either in an extern "C" context
// or the body of a macro definition:
@@ -799,7 +1023,7 @@ bool SalBool::isSharedCAndCppCode(SourceLocation location) const {
|| compiler.getSourceManager().isMacroBodyExpansion(location));
}
-bool SalBool::isInSpecialMainFile(SourceLocation spellingLocation) const {
+bool FakeBool::isInSpecialMainFile(SourceLocation spellingLocation) const {
if (!compiler.getSourceManager().isInMainFile(spellingLocation)) {
return false;
}
@@ -809,7 +1033,7 @@ bool SalBool::isInSpecialMainFile(SourceLocation spellingLocation) const {
// TODO: the offset checks
}
-bool SalBool::rewrite(SourceLocation location) {
+bool FakeBool::rewrite(SourceLocation location, FakeBoolKind kind) {
if (rewriter != nullptr) {
//TODO: "::sal_Bool" -> "bool", not "::bool"
SourceLocation loc { compiler.getSourceManager().getExpansionLoc(
@@ -817,7 +1041,7 @@ bool SalBool::rewrite(SourceLocation location) {
unsigned n = Lexer::MeasureTokenLength(
loc, compiler.getSourceManager(), compiler.getLangOpts());
if (std::string(compiler.getSourceManager().getCharacterData(loc), n)
- == "sal_Bool")
+ == getName(kind))
{
return replaceText(loc, n, "bool");
}
@@ -825,7 +1049,7 @@ bool SalBool::rewrite(SourceLocation location) {
return false;
}
-loplugin::Plugin::Registration<SalBool> X("salbool", true);
+loplugin::Plugin::Registration<FakeBool> X("fakebool", true);
}
diff --git a/compilerplugins/clang/test/salbool.cxx b/compilerplugins/clang/test/fakebool.cxx
index da861afe73be..26b5d7e2f791 100644
--- a/compilerplugins/clang/test/salbool.cxx
+++ b/compilerplugins/clang/test/fakebool.cxx
@@ -11,8 +11,12 @@
#include <sal/types.h>
+namespace {
+
struct S {
- sal_Bool b; // expected-error {{FieldDecl, use "bool" instead of "sal_Bool" [loplugin:salbool]}}
+ sal_Bool b; // expected-error {{FieldDecl, use "bool" instead of 'sal_Bool' (aka 'unsigned char') [loplugin:fakebool]}}
};
+}
+
/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */