summaryrefslogtreecommitdiffstats
path: root/compilerplugins/clang/indentation.cxx
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--compilerplugins/clang/indentation.cxx460
1 files changed, 460 insertions, 0 deletions
diff --git a/compilerplugins/clang/indentation.cxx b/compilerplugins/clang/indentation.cxx
new file mode 100644
index 0000000000..cf2512d1d2
--- /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: */