plugin.hxx 8.57 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 16
#include <config_clang.h>

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

#include <clang/Rewrite/Core/Rewriter.h>
26 27

using namespace clang;
28 29
using namespace llvm;
using namespace std;
30 31 32 33

namespace loplugin
{

34 35
class PluginHandler;

36 37 38 39 40 41
/**
    Base class for plugins.

    If you want to create a non-rewriter action, inherit from this class. Remember to also
    use Plugin::Registration.
*/
42 43 44
class Plugin
    {
    public:
45 46 47 48 49 50 51 52
        struct InstantiationData
            {
            const char* name;
            PluginHandler& handler;
            CompilerInstance& compiler;
            Rewriter* rewriter;
            };
        explicit Plugin( const InstantiationData& data );
53 54 55
        virtual ~Plugin();
        virtual void run() = 0;
        template< typename T > class Registration;
56
        enum { isPPCallback = false };
57 58
        // Returns location right after the end of the token that starts at the given location.
        SourceLocation locationAfterToken( SourceLocation location );
59
    protected:
Stephan Bergmann's avatar
Stephan Bergmann committed
60
        DiagnosticBuilder report( DiagnosticsEngine::Level level, StringRef message, SourceLocation loc = SourceLocation()) const;
61 62 63
        bool ignoreLocation( SourceLocation loc );
        bool ignoreLocation( const Decl* decl );
        bool ignoreLocation( const Stmt* stmt );
64
        CompilerInstance& compiler;
65
        PluginHandler& handler;
66 67 68 69 70 71
        /**
         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.
        */
        const Stmt* parentStmt( const Stmt* stmt );
        Stmt* parentStmt( Stmt* stmt );
72
        const FunctionDecl* parentFunctionDecl( const Stmt* stmt );
73 74 75 76 77
        /**
         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;
78
        bool isInUnoIncludeFile(const FunctionDecl*) const;
79 80

        static void normalizeDotDotInFilePath(std::string&);
81
    private:
82 83
        static void registerPlugin( Plugin* (*create)( const InstantiationData& ), const char* optionName, bool isPPCallback, bool byDefault );
        template< typename T > static Plugin* createHelper( const InstantiationData& data );
84
        enum { isRewriter = false };
85
        const char* name;
86 87
        static unordered_map< const Stmt*, const Stmt* > parents;
        static void buildParents( CompilerInstance& compiler );
88 89
    };

90 91 92 93 94
/**
    Base class for rewriter plugins.

    Remember to also use Plugin::Registration.
*/
95 96 97 98
class RewritePlugin
    : public Plugin
    {
    public:
99
        explicit RewritePlugin( const InstantiationData& data );
100
    protected:
101 102 103 104 105 106
        enum RewriteOption
            {
            // 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
Andrea Gelmini's avatar
Andrea Gelmini committed
107
            // and the trailing semicolon (is not part of the AST element range itself).
108 109 110 111 112 113 114
            // 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
            };
115 116 117
        struct RewriteOptions
            : public Rewriter::RewriteOptions
            {
118
            RewriteOptions();
119
            explicit RewriteOptions( RewriteOption option );
120
            const int flags;
121
            };
122 123
        // syntactic sugar to be able to write 'RemoveLineIfEmpty | RemoveWholeStatement'
        friend RewriteOption operator|( RewriteOption option1, RewriteOption option2 );
124
        // These following insert/remove/replaceText functions map to functions
125
        // in clang::Rewriter, with these differences:
126 127
        // - they (more intuitively) return false on failure rather than true
        // - they report a warning when the change cannot be done
128
        // - There are more options for easier removal of surroundings of a statement/expression.
129 130 131 132 133 134
        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());
135
        bool removeText( CharSourceRange range, RewriteOptions opts = RewriteOptions());
136 137 138 139
        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 );
140
        Rewriter* rewriter;
141
    private:
142 143
        template< typename T > friend class Plugin::Registration;
        enum { isRewriter = true };
144
        bool wouldRewriteWorkdir(SourceLocation loc);
145
        bool reportEditFailure( SourceLocation loc );
146
        bool adjustRangeForOptions( CharSourceRange* range, RewriteOptions options );
147 148
    };

149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
/**
    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
    {
    public:
164
        Registration( const char* optionName, bool byDefault = !T::isRewriter );
165 166 167 168 169
    };

class RegistrationCreate
    {
    public:
170
        template< typename T, bool > static T* create( const Plugin::InstantiationData& data );
171 172 173 174 175 176 177
    };

inline
Plugin::~Plugin()
    {
    }

178 179 180
inline
bool Plugin::ignoreLocation( const Decl* decl )
    {
181
    return ignoreLocation( decl->getLocation());
182 183 184 185 186
    }

inline
bool Plugin::ignoreLocation( const Stmt* stmt )
    {
187 188 189
    // Invalid location can happen at least for ImplicitCastExpr of
    // ImplicitParam 'self' in Objective C method declarations:
    return stmt->getLocStart().isValid() && ignoreLocation( stmt->getLocStart());
190 191
    }

192
template< typename T >
193
Plugin* Plugin::createHelper( const InstantiationData& data )
194
    {
195
    return new T( data );
196 197 198 199
    }

template< typename T >
inline
200
Plugin::Registration< T >::Registration( const char* optionName, bool byDefault )
201
    {
202
    registerPlugin( &T::template createHelper< T >, optionName, T::isPPCallback, byDefault );
203 204
    }

205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225
inline
RewritePlugin::RewriteOptions::RewriteOptions()
    : flags( 0 )
    {
    }

inline
RewritePlugin::RewriteOptions::RewriteOptions( RewriteOption option )
    : flags( option )
    {
    // Note that 'flags' stores also RemoveLineIfEmpty, it must be kept in sync with the base class.
    if( flags & RewritePlugin::RemoveLineIfEmpty )
        this->RemoveLineIfEmpty = true;
    }

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

226 227 228 229 230 231 232 233
// Same as pathname.startswith(prefix), except on Windows, where pathname (but
// not prefix) may also contain backslashes:
bool hasPathnamePrefix(StringRef pathname, StringRef prefix);

// Same as pathname == other, except on Windows, where pathname (but not other)
// may also contain backslashes:
bool isSamePathname(StringRef pathname, StringRef other);

234 235
} // namespace

236
#endif // COMPILEPLUGIN_H
237 238

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