plugin.hxx 9.84 KB
Newer Older
1
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 3 4 5 6 7 8 9 10 11
/*
 * 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.
 *
 */

12 13
#ifndef PLUGIN_H
#define PLUGIN_H
14

15
#include <clang/AST/ASTContext.h>
16
#include <clang/AST/RecursiveASTVisitor.h>
17 18
#include <clang/Basic/FileManager.h>
#include <clang/Basic/SourceManager.h>
19
#include <clang/Frontend/CompilerInstance.h>
20
#include <clang/Lex/Preprocessor.h>
21
#include <unordered_map>
22
#include <vector>
Stephan Bergmann's avatar
Stephan Bergmann committed
23 24

#include <clang/Rewrite/Core/Rewriter.h>
25

26
#include "compat.hxx"
27 28
#include "pluginhandler.hxx"

29
using namespace clang;
30
using namespace llvm;
31 32 33 34

namespace loplugin
{

35 36 37 38 39 40 41
struct InstantiationData
{
    const char* name;
    PluginHandler& handler;
    CompilerInstance& compiler;
    Rewriter* rewriter;
};
42

43 44 45 46 47 48
/**
    Base class for plugins.

    If you want to create a non-rewriter action, inherit from this class. Remember to also
    use Plugin::Registration.
*/
49
class Plugin
50 51 52 53
{
public:
    explicit Plugin( const InstantiationData& data );
    virtual ~Plugin() {}
54 55 56
    // The main function of the plugin.
    // Note that for shared plugins, its functionality must be split into preRun() and postRun(),
    // see sharedvisitor/generator.cxx .
57
    virtual void run() = 0;
58 59 60 61
    // Should be called from run() before TraverseDecl().
    // If returns false, run() should not do anything.
    virtual bool preRun() { return true; }
    virtual void postRun() {}
62 63 64
    template< typename T > class Registration;
    // Returns location right after the end of the token that starts at the given location.
    SourceLocation locationAfterToken( SourceLocation location );
65 66 67
    virtual bool setSharedPlugin( Plugin* /*plugin*/, const char* /*name*/ ) { return false; }
    enum { isPPCallback = false };
    enum { isSharedPlugin = false };
68 69
protected:
    DiagnosticBuilder report( DiagnosticsEngine::Level level, StringRef message, SourceLocation loc = SourceLocation()) const;
70 71 72 73
    bool ignoreLocation( SourceLocation loc ) const
    { return handler.ignoreLocation(loc); }
    bool ignoreLocation( const Decl* decl ) const;
    bool ignoreLocation( const Stmt* stmt ) const;
74 75 76 77 78 79
    CompilerInstance& compiler;
    PluginHandler& handler;
    /**
     Returns the parent of the given AST node. Clang's internal AST representation doesn't provide this information,
     it can only provide children, but getting the parent is often useful for inspecting a part of the AST.
    */
80 81 82
    const Stmt* getParentStmt( const Stmt* stmt );
    Stmt* getParentStmt( Stmt* stmt );
    const FunctionDecl* getParentFunctionDecl( const Stmt* stmt );
83 84 85

    /// to check file names against whitelists, so that it works with preprocessed input too
    StringRef getFileNameOfSpellingLoc(SourceLocation spellingLocation) const;
86 87 88 89 90 91 92
    /**
     Checks if the location is inside an UNO file, more specifically, if it forms part of the URE stable interface,
     which is not allowed to be changed.
    */
    bool isInUnoIncludeFile(SourceLocation spellingLocation) const;
    bool isInUnoIncludeFile(const FunctionDecl*) const;

93 94
    bool isDebugMode() const { return handler.isDebugMode(); }

95
    static bool isUnitTestMode();
96 97 98

    bool containsPreprocessingConditionalInclusion(SourceRange range);

99 100 101 102
    enum class IdenticalDefaultArgumentsResult { No, Yes, Maybe };
    IdenticalDefaultArgumentsResult checkIdenticalDefaultArguments(
        Expr const * argument1, Expr const * argument2);

103
private:
104 105
    static void registerPlugin( Plugin* (*create)( const InstantiationData& ), const char* optionName,
        bool isPPCallback, bool isSharedPlugin, bool byDefault );
106
    template< typename T > static Plugin* createHelper( const InstantiationData& data );
107 108
    bool evaluate(const Expr* expr, APSInt& x);

109 110 111 112
    enum { isRewriter = false };
    const char* name;
};

113 114 115 116 117 118 119
template<typename Derived>
class FilteringPlugin : public RecursiveASTVisitor<Derived>, public Plugin
{
public:
    explicit FilteringPlugin( const InstantiationData& data ) : Plugin(data) {}

    bool TraverseNamespaceDecl(NamespaceDecl * decl) {
120
        if (ignoreLocation(compat::getBeginLoc(decl)))
121 122 123 124 125
            return true;
        return RecursiveASTVisitor<Derived>::TraverseNamespaceDecl(decl);
    }
};

126 127 128 129 130
/**
    Base class for rewriter plugins.

    Remember to also use Plugin::Registration.
*/
131 132
class RewritePlugin
    : public Plugin
133 134 135 136 137
{
public:
    explicit RewritePlugin( const InstantiationData& data );
protected:
    enum RewriteOption
138
    {
139 140 141 142 143 144 145 146 147 148 149
        // This enum allows passing just 'RemoveLineIfEmpty' to functions below.
        // If the resulting line would be completely empty, it'll be removed.
        RemoveLineIfEmpty    = 1 << 0,
        // Use this to remove the declaration/statement as a whole, i.e. all whitespace before the statement
        // and the trailing semicolon (is not part of the AST element range itself).
        // The trailing semicolon must be present.
        RemoveWholeStatement = 1 << 1,
        // Removes also all whitespace preceding and following the expression (completely, so that
        // the preceding and following tokens would be right next to each other, follow with insertText( " " )
        // if this is not wanted). Despite the name, indentation whitespace is not removed.
        RemoveAllWhitespace  = 1 << 2
150
    };
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
    struct RewriteOptions
        : public Rewriter::RewriteOptions
    {
        RewriteOptions() : flags( 0 ) {}
        explicit RewriteOptions( RewriteOption option );
        const int flags;
    };
    // syntactic sugar to be able to write 'RemoveLineIfEmpty | RemoveWholeStatement'
    friend RewriteOption operator|( RewriteOption option1, RewriteOption option2 );
    // These following insert/remove/replaceText functions map to functions
    // in clang::Rewriter, with these differences:
    // - they (more intuitively) return false on failure rather than true
    // - they report a warning when the change cannot be done
    // - There are more options for easier removal of surroundings of a statement/expression.
    bool insertText( SourceLocation Loc, StringRef Str,
    bool InsertAfter = true, bool indentNewLines = false );
    bool insertTextAfter( SourceLocation Loc, StringRef Str );
    bool insertTextAfterToken( SourceLocation Loc, StringRef Str );
    bool insertTextBefore( SourceLocation Loc, StringRef Str );
    bool removeText( SourceLocation Start, unsigned Length, RewriteOptions opts = RewriteOptions());
    bool removeText( CharSourceRange range, RewriteOptions opts = RewriteOptions());
    bool removeText( SourceRange range, RewriteOptions opts = RewriteOptions());
    bool replaceText( SourceLocation Start, unsigned OrigLength, StringRef NewStr );
    bool replaceText( SourceRange range, StringRef NewStr );
    bool replaceText( SourceRange range, SourceRange replacementRange );
    Rewriter* rewriter;
private:
    template< typename T > friend class Plugin::Registration;
    enum { isRewriter = true };
    bool wouldRewriteWorkdir(SourceLocation loc);
    bool reportEditFailure( SourceLocation loc );
    bool adjustRangeForOptions( CharSourceRange* range, RewriteOptions options );
};
184

185 186 187 188 189 190 191 192 193 194 195 196 197
/**
    Plugin registration helper.

    If you create a new helper class, create also an instance of this class to automatically register it.
    The passed argument is name of the plugin, used for explicitly invoking rewriter plugins
    (it is ignored for non-rewriter plugins).

    @code
    static Plugin::Registration< NameOfClass > X( "nameofclass" );
    @endcode
*/
template< typename T >
class Plugin::Registration
198 199 200 201
{
public:
    Registration( const char* optionName, bool byDefault = !T::isRewriter );
};
202 203

class RegistrationCreate
204 205
{
public:
206
    template< typename T, bool > static T* create( const InstantiationData& data );
207
};
208

209
inline
210
bool Plugin::ignoreLocation( const Decl* decl ) const
211
{
212
    return ignoreLocation( decl->getLocation());
213
}
214 215

inline
216
bool Plugin::ignoreLocation( const Stmt* stmt ) const
217
{
218 219
    // Invalid location can happen at least for ImplicitCastExpr of
    // ImplicitParam 'self' in Objective C method declarations:
220
    return compat::getBeginLoc(stmt).isValid() && ignoreLocation( compat::getBeginLoc(stmt));
221
}
222

223
template< typename T >
224
Plugin* Plugin::createHelper( const InstantiationData& data )
225
 {
226
    return new T( data );
227
}
228 229 230

template< typename T >
inline
231
Plugin::Registration< T >::Registration( const char* optionName, bool byDefault )
232
{
233
    registerPlugin( &T::template createHelper< T >, optionName, T::isPPCallback, T::isSharedPlugin, byDefault );
234
}
235 236 237 238

inline
RewritePlugin::RewriteOptions::RewriteOptions( RewriteOption option )
    : flags( option )
239
{
240 241
    // Note that 'flags' stores also RemoveLineIfEmpty, it must be kept in sync with the base class.
    if( flags & RewritePlugin::RemoveLineIfEmpty )
242
        RemoveLineIfEmpty = true;
243
}
244 245 246

inline
RewritePlugin::RewriteOption operator|( RewritePlugin::RewriteOption option1, RewritePlugin::RewriteOption option2 )
247
{
248
    return static_cast< RewritePlugin::RewriteOption >( int( option1 ) | int( option2 ));
249
}
250

251 252 253 254 255 256 257
template<typename Derived>
class FilteringRewritePlugin : public RecursiveASTVisitor<Derived>, public RewritePlugin
{
public:
    explicit FilteringRewritePlugin( const InstantiationData& data ) : RewritePlugin(data) {}

    bool TraverseNamespaceDecl(NamespaceDecl * decl) {
258
        if (ignoreLocation(compat::getBeginLoc(decl)))
259 260 261 262 263
            return true;
        return RecursiveASTVisitor<Derived>::TraverseNamespaceDecl(decl);
    }
};

264 265
void normalizeDotDotInFilePath(std::string&);

266 267
// Same as pathname.startswith(prefix), except on Windows, where pathname and
// prefix may also contain backslashes:
268 269
bool hasPathnamePrefix(StringRef pathname, StringRef prefix);

270 271
// Same as pathname == other, except on Windows, where pathname and other may
// also contain backslashes:
272 273
bool isSamePathname(StringRef pathname, StringRef other);

274 275
} // namespace

276
#endif // COMPILEPLUGIN_H
277 278

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