diff options
Diffstat (limited to 'compilerplugins/clang/indentation.cxx')
| -rw-r--r-- | compilerplugins/clang/indentation.cxx | 460 |
1 files changed, 460 insertions, 0 deletions
diff --git a/compilerplugins/clang/indentation.cxx b/compilerplugins/clang/indentation.cxx new file mode 100644 index 000000000..cf2512d1d --- /dev/null +++ b/compilerplugins/clang/indentation.cxx @@ -0,0 +1,460 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * Based on LLVM/Clang. + * + * This file is distributed under the University of Illinois Open Source + * License. See LICENSE.TXT for details. + * + */ +#ifndef LO_CLANG_SHARED_PLUGINS + +#include <cassert> +#include <string> +#include <iostream> +#include <fstream> +#include <set> +#include <unordered_set> +#include "config_clang.h" +#include "plugin.hxx" + +/* +Check for child statements inside a compound statement that do not share the same indentation. + +TODO if an open-brace starts on a new line by itself, check that it lines up with it's closing-brace +TODO else should line up with if +*/ + +namespace +{ +class Indentation : public loplugin::FilteringPlugin<Indentation> +{ +public: + explicit Indentation(loplugin::InstantiationData const& data) + : FilteringPlugin(data) + { + } + + virtual bool preRun() override + { + std::string fn(handler.getMainFileName()); + loplugin::normalizeDotDotInFilePath(fn); + // include another file to build a table + if (fn == SRCDIR "/sc/source/core/tool/cellkeytranslator.cxx") + return false; + // weird structure + if (fn == SRCDIR "/sc/source/core/tool/compiler.cxx") + return false; + // looks like lex/yacc output + if (fn == SRCDIR "/hwpfilter/source/grammar.cxx") + return false; + // the QEMIT macros + if (loplugin::hasPathnamePrefix(fn, SRCDIR "/vcl/qt5/") + || loplugin::hasPathnamePrefix(fn, SRCDIR "/vcl/qt6/") + || loplugin::isSamePathname(fn, SRCDIR "/vcl/unx/gtk3_kde5/kde5_filepicker_ipc.cxx")) + return false; + return true; + } + + virtual void run() override + { + if (preRun()) + TraverseDecl(compiler.getASTContext().getTranslationUnitDecl()); + } + + bool VisitCompoundStmt(CompoundStmt const*); + bool PreTraverseSwitchStmt(SwitchStmt*); + bool PostTraverseSwitchStmt(SwitchStmt*, bool); + bool TraverseSwitchStmt(SwitchStmt*); + bool VisitSwitchStmt(SwitchStmt const*); + bool VisitIfStmt(IfStmt const*); + bool VisitForStmt(ForStmt const*); + bool VisitWhileStmt(WhileStmt const*); + bool VisitDoStmt(DoStmt const*); + bool VisitCXXForRangeStmt(CXXForRangeStmt const*); + +private: + void checkCompoundStmtBraces(const Stmt* parentStmt, const CompoundStmt*); + + std::vector<const Stmt*> switchStmtBodies; + std::unordered_set<const Stmt*> chainedSet; +}; + +bool Indentation::PreTraverseSwitchStmt(SwitchStmt* switchStmt) +{ + switchStmtBodies.push_back(switchStmt->getBody()); + return true; +} + +bool Indentation::PostTraverseSwitchStmt(SwitchStmt*, bool) +{ + switchStmtBodies.pop_back(); + return true; +} + +bool Indentation::TraverseSwitchStmt(SwitchStmt* switchStmt) +{ + PreTraverseSwitchStmt(switchStmt); + auto ret = FilteringPlugin::TraverseSwitchStmt(switchStmt); + PostTraverseSwitchStmt(switchStmt, ret); + return ret; +} + +bool Indentation::VisitCompoundStmt(CompoundStmt const* compoundStmt) +{ + if (ignoreLocation(compoundStmt)) + return true; + // these are kind of free form + if (!switchStmtBodies.empty() && switchStmtBodies.back() == compoundStmt) + return true; + + constexpr unsigned MAX = std::numeric_limits<unsigned>::max(); + unsigned column = MAX; + Stmt const* firstStmt = nullptr; + unsigned curLine = MAX; + unsigned prevLine = MAX; + SourceLocation prevEnd; + auto& SM = compiler.getSourceManager(); + for (auto i = compoundStmt->body_begin(); i != compoundStmt->body_end(); ++i) + { + auto stmt = *i; + auto const actualPrevEnd = prevEnd; + prevEnd = stmt->getEndLoc(); // compute early, before below `continue`s + + // these show up in macro expansions, not interesting + if (isa<NullStmt>(stmt)) + continue; + // these are always weirdly indented + if (isa<LabelStmt>(stmt)) + continue; + + auto stmtLoc = stmt->getBeginLoc(); + + StringRef macroName; + bool partOfMacro = false; + if (SM.isMacroArgExpansion(stmtLoc) || SM.isMacroBodyExpansion(stmtLoc)) + { + partOfMacro = true; + macroName = Lexer::getImmediateMacroNameForDiagnostics( + stmtLoc, compiler.getSourceManager(), compiler.getLangOpts()); + // CPPUNIT_TEST_SUITE/CPPUNIT_TEST/CPPUNIT_TEST_SUITE_END work together, so the one is indented inside the other + if (macroName == "CPPUNIT_TEST_SUITE") + continue; + // similar thing in dbaccess/ + if (macroName == "DECL_PROP_IMPL") + continue; + // similar thing in forms/ + if (macroName == "DECL_IFACE_PROP_IMPL" || macroName == "DECL_BOOL_PROP_IMPL") + continue; + stmtLoc = SM.getExpansionRange(stmtLoc).getBegin(); + } + + // check for comment to the left of the statement + { + const char* p1 = SM.getCharacterData(stmtLoc); + --p1; + bool foundComment = false; + while (*p1 && *p1 != '\n') + { + if (*p1 == '/') + { + foundComment = true; + break; + } + --p1; + } + if (foundComment) + continue; + } + + bool invalid1 = false; + bool invalid2 = false; + unsigned tmpColumn = SM.getPresumedColumnNumber(stmtLoc, &invalid1); + unsigned tmpLine = SM.getPresumedLineNumber(stmtLoc, &invalid2); + if (invalid1 || invalid2) + continue; + prevLine = curLine; + curLine = tmpLine; + if (column == MAX) + { + column = tmpColumn; + firstStmt = stmt; + } + else if (curLine == prevLine) + { + // ignore multiple statements on same line + } + else if (column != tmpColumn) + { + if (containsPreprocessingConditionalInclusion(SourceRange( + locationAfterToken(compiler.getSourceManager().getExpansionLoc(actualPrevEnd)), + compiler.getSourceManager().getExpansionLoc(stmt->getBeginLoc())))) + continue; + report(DiagnosticsEngine::Warning, "statement mis-aligned compared to neighbours %0", + stmtLoc) + << macroName; + report(DiagnosticsEngine::Note, "measured against this one", firstStmt->getBeginLoc()); + //getParentStmt(compoundStmt)->dump(); + //stmt->dump(); + } + + if (!partOfMacro) + if (auto ifStmt = dyn_cast<IfStmt>(stmt)) + { + auto bodyStmt = ifStmt->getThen(); + if (bodyStmt && !isa<CompoundStmt>(bodyStmt)) + { + stmtLoc = bodyStmt->getBeginLoc(); + invalid1 = false; + invalid2 = false; + unsigned bodyColumn = SM.getPresumedColumnNumber(stmtLoc, &invalid1); + unsigned bodyLine = SM.getPresumedLineNumber(stmtLoc, &invalid2); + if (invalid1 || invalid2) + return true; + + if (bodyLine != tmpLine && bodyColumn <= tmpColumn) + report(DiagnosticsEngine::Warning, "if body should be indented", stmtLoc); + } + + auto elseStmt = ifStmt->getElse(); + if (elseStmt && !isa<CompoundStmt>(elseStmt) && !isa<IfStmt>(elseStmt)) + { + stmtLoc = elseStmt->getBeginLoc(); + invalid1 = false; + invalid2 = false; + unsigned elseColumn = SM.getPresumedColumnNumber(stmtLoc, &invalid1); + unsigned elseLine = SM.getPresumedLineNumber(stmtLoc, &invalid2); + if (invalid1 || invalid2) + return true; + if (elseLine != tmpLine && elseColumn <= tmpColumn) + report(DiagnosticsEngine::Warning, "else body should be indented", stmtLoc); + } + if (elseStmt && !isa<CompoundStmt>(bodyStmt)) + { + stmtLoc = ifStmt->getElseLoc(); + invalid1 = false; + invalid2 = false; + unsigned elseColumn = SM.getPresumedColumnNumber(stmtLoc, &invalid1); + unsigned elseLine = SM.getPresumedLineNumber(stmtLoc, &invalid2); + if (invalid1 || invalid2) + return true; + if (elseLine != tmpLine && elseColumn != tmpColumn) + report(DiagnosticsEngine::Warning, "if and else not aligned", stmtLoc); + } + } + } + + return true; +} + +bool Indentation::VisitIfStmt(IfStmt const* ifStmt) +{ + if (ignoreLocation(ifStmt)) + return true; + + // TODO - ignore chained if statements for now + if (auto chained = ifStmt->getElse()) + chainedSet.insert(chained); + if (chainedSet.find(ifStmt) != chainedSet.end()) + return true; + + if (auto compoundStmt = dyn_cast_or_null<CompoundStmt>(ifStmt->getThen())) + checkCompoundStmtBraces(ifStmt, compoundStmt); + // TODO - needs to be checked against the line that contains the else keyword, but not against the parent + // if (auto compoundStmt = dyn_cast_or_null<CompoundStmt>(ifStmt->getElse())) + // checkCompoundStmtBraces(ifStmt, compoundStmt); + return true; +} + +bool Indentation::VisitForStmt(ForStmt const* forStmt) +{ + if (ignoreLocation(forStmt)) + return true; + if (chainedSet.find(forStmt) != chainedSet.end()) + return true; + if (auto compoundStmt = dyn_cast_or_null<CompoundStmt>(forStmt->getBody())) + checkCompoundStmtBraces(forStmt, compoundStmt); + return true; +} + +bool Indentation::VisitWhileStmt(WhileStmt const* whileStmt) +{ + if (ignoreLocation(whileStmt)) + return true; + if (chainedSet.find(whileStmt) != chainedSet.end()) + return true; + if (auto compoundStmt = dyn_cast_or_null<CompoundStmt>(whileStmt->getBody())) + checkCompoundStmtBraces(whileStmt, compoundStmt); + return true; +} + +bool Indentation::VisitDoStmt(DoStmt const* doStmt) +{ + if (ignoreLocation(doStmt)) + return true; + if (chainedSet.find(doStmt) != chainedSet.end()) + return true; + if (auto compoundStmt = dyn_cast_or_null<CompoundStmt>(doStmt->getBody())) + checkCompoundStmtBraces(doStmt, compoundStmt); + return true; +} + +bool Indentation::VisitCXXForRangeStmt(CXXForRangeStmt const* cxxForRangeStmt) +{ + if (ignoreLocation(cxxForRangeStmt)) + return true; + if (chainedSet.find(cxxForRangeStmt) != chainedSet.end()) + return true; + if (auto compoundStmt = dyn_cast_or_null<CompoundStmt>(cxxForRangeStmt->getBody())) + checkCompoundStmtBraces(cxxForRangeStmt, compoundStmt); + return true; +} + +void Indentation::checkCompoundStmtBraces(const Stmt* parentStmt, const CompoundStmt* compoundStmt) +{ + auto& SM = compiler.getSourceManager(); + bool invalid1 = false; + bool invalid2 = false; + + auto parentBeginLoc = parentStmt->getBeginLoc(); + unsigned parentColumn = SM.getPresumedColumnNumber(parentBeginLoc, &invalid1); + if (invalid1) + return; + + auto startBraceLoc = compoundStmt->getLBracLoc(); + auto endBraceLoc = compoundStmt->getRBracLoc(); + unsigned beginColumn = SM.getPresumedColumnNumber(startBraceLoc, &invalid1); + unsigned beginLine = SM.getPresumedLineNumber(startBraceLoc, &invalid2); + if (invalid1 || invalid2) + return; + unsigned endColumn = SM.getPresumedColumnNumber(endBraceLoc, &invalid1); + unsigned endLine = SM.getPresumedLineNumber(endBraceLoc, &invalid2); + if (invalid1 || invalid2) + return; + if (beginLine == endLine) + return; + + // check for code to the left of the starting brace + bool foundCodeToLeft = false; + { + const char* p1 = SM.getCharacterData(startBraceLoc); + --p1; + while (*p1 && *p1 != '\n') + { + if (*p1 != ' ') + { + foundCodeToLeft = true; + break; + } + --p1; + } + } + + // if we found code to the left of the start brace, that means the end-brace needs + // to line up with the start of the parent statement + if (foundCodeToLeft) + { + if (parentColumn != endColumn) + { + report(DiagnosticsEngine::Warning, "end brace not aligned with beginning of statement", + endBraceLoc); + report(DiagnosticsEngine::Note, "statement beginning here", parentBeginLoc); + } + return; + } + + if (parentColumn != beginColumn) + { + report(DiagnosticsEngine::Warning, + "start brace not aligned with beginning of parent statement", startBraceLoc); + report(DiagnosticsEngine::Note, "statement beginning here", parentBeginLoc); + } + else if (beginColumn != endColumn) + { + report(DiagnosticsEngine::Warning, "start and end brace not aligned", endBraceLoc); + report(DiagnosticsEngine::Note, "start brace here", startBraceLoc); + } + + /** now check that lines inside the compoundstmt are indented */ + if (!compoundStmt->size()) + return; + auto firstStmt = compoundStmt->body_front(); + if (isa<LabelStmt>(firstStmt)) + return; + auto firstStmtLoc = firstStmt->getBeginLoc(); + unsigned firstStmtBeginColumn = SM.getPresumedColumnNumber(firstStmtLoc, &invalid1); + if (invalid1) + return; + if (firstStmtBeginColumn > beginColumn) + return; + StringRef fn = getFilenameOfLocation(compiler.getSourceManager().getSpellingLoc(firstStmtLoc)); + // this is doing code generation, so the weird layout is deliberate + if (loplugin::hasPathnamePrefix(fn, SRCDIR "/sc/source/core/opencl/")) + return; + report(DiagnosticsEngine::Warning, "body inside brace not indented", firstStmtLoc); +} + +bool Indentation::VisitSwitchStmt(SwitchStmt const* switchStmt) +{ + if (ignoreLocation(switchStmt)) + return true; + + constexpr unsigned MAX = std::numeric_limits<unsigned>::max(); + unsigned column = MAX; + Stmt const* firstStmt = nullptr; + unsigned curLine = MAX; + unsigned prevLine = MAX; + auto& SM = compiler.getSourceManager(); + auto compoundStmt = dyn_cast<CompoundStmt>(switchStmt->getBody()); + if (!compoundStmt) + return true; + for (auto i = compoundStmt->body_begin(); i != compoundStmt->body_end(); ++i) + { + Stmt const* caseStmt = dyn_cast<CaseStmt>(*i); + if (!caseStmt) + caseStmt = dyn_cast<DefaultStmt>(*i); + if (!caseStmt) + continue; + + auto stmtLoc = caseStmt->getBeginLoc(); + + bool invalid1 = false; + bool invalid2 = false; + unsigned tmpColumn = SM.getPresumedColumnNumber(stmtLoc, &invalid1); + unsigned tmpLine = SM.getPresumedLineNumber(stmtLoc, &invalid2); + if (invalid1 || invalid2) + continue; + prevLine = curLine; + curLine = tmpLine; + if (column == MAX) + { + column = tmpColumn; + firstStmt = caseStmt; + } + else if (curLine == prevLine) + { + // ignore multiple statements on same line + } + else if (column != tmpColumn) + { + // disable this for now, ends up touching some very large switch statements in sw/ and sc/ + (void)firstStmt; + // report(DiagnosticsEngine::Warning, "statement mis-aligned compared to neighbours", + // stmtLoc); + // report(DiagnosticsEngine::Note, "measured against this one", + // firstStmt->getBeginLoc()); + //getParentStmt(compoundStmt)->dump(); + //stmt->dump(); + } + } + return true; +} + +loplugin::Plugin::Registration<Indentation> indentation("indentation"); + +} // namespace + +#endif // LO_CLANG_SHARED_PLUGINS + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |