summaryrefslogtreecommitdiff
path: root/compilerplugins/clang/redundantstatic.cxx
blob: 95a3c85c9d17c0567742bce90e8e6b3533ac2cdd (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/* -*- 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.
 *
 */
#ifndef LO_CLANG_SHARED_PLUGINS

#include "check.hxx"
#include "compat.hxx"
#include "plugin.hxx"

/*
This is a compile check.

Warns about functions with static keyword in an unnamed namespace.
*/

namespace loplugin
{

class RedundantStatic
    : public loplugin::FilteringPlugin<RedundantStatic>
    {
    public:
        explicit RedundantStatic( const InstantiationData& data );

        bool preRun() override { return compiler.getLangOpts().CPlusPlus; }

        virtual void run() override;
        bool VisitFunctionDecl( const FunctionDecl* func );

        bool VisitVarDecl(VarDecl const * decl) {
            if (ignoreLocation(decl)) {
                return true;
            }
            if (!decl->isFileVarDecl() || decl->isStaticDataMember()) {
                return true;
            }
            if (decl->getStorageClass() != SC_Static) {
                return true;
            }
            if (decl->isInAnonymousNamespace()) {
                auto loc = compat::getBeginLoc(decl);
                while (compiler.getSourceManager().isMacroArgExpansion(loc)) {
                    loc = compiler.getSourceManager().getImmediateMacroCallerLoc(loc);
                }
                if (compiler.getSourceManager().isMacroBodyExpansion(loc)) {
                    auto const name = Lexer::getImmediateMacroName(
                        loc, compiler.getSourceManager(), compiler.getLangOpts());
                    if (name == "CPPUNIT_TEST_SUITE_REGISTRATION"
                        || name == "CPPUNIT_TEST_SUITE_NAMED_REGISTRATION")
                    {
                        // Those macros contain a `static`, but are often used in an unnamed
                        // namespace, so filter them out:
                        return true;
                    }
                }
                report(
                    DiagnosticsEngine::Warning, "redundant 'static' keyword in unnamed namespace",
                    decl->getLocation())
                    << decl->getSourceRange();
                return true;
            }
            if (decl->isInline()) {
                return true;
            }
            if (!loplugin::TypeCheck(decl->getType()).ConstNonVolatile()) {
                return true;
            }
            report(
                DiagnosticsEngine::Warning,
                "non-inline variable of non-volatile const-qualified type is redundantly marked as"
                    " 'static'",
                decl->getLocation())
                << decl->getSourceRange();
            return true;
        }
    };

RedundantStatic::RedundantStatic( const InstantiationData& data )
    : FilteringPlugin( data )
    {
    }

void RedundantStatic::run()
    {
    if (preRun()) {
        TraverseDecl( compiler.getASTContext().getTranslationUnitDecl());
    }
    }


bool RedundantStatic::VisitFunctionDecl( const FunctionDecl* func )

    {
    if( ignoreLocation( func ) )
        return true;
    if( func -> isInAnonymousNamespace () )
    {
      if ( !isa<CXXMethodDecl>(func) && !func->isInExternCContext() )
         {
            if(func-> getStorageClass() == SC_Static)
               {
                    report( DiagnosticsEngine::Warning,
                        "redundant 'static' keyword in unnamed namespace",
                        compat::getBeginLoc(func));
               }
         }
    }

    return true;
    }

// Register the plugin action with the LO plugin handling.
static Plugin::Registration< RedundantStatic > redundantstatic("redundantstatic");

} // namespace

#endif // LO_CLANG_SHARED_PLUGINS

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */