compilerplugins/clang/plugin.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * Based on LLVM/Clang.
   6  *
   7  * This file is distributed under the University of Illinois Open Source
   8  * License. See LICENSE.TXT for details.
   9  *
  10  */
  11
  12 #include "plugin.hxx"
  13
  14 #include <cassert>
  15
  16 #include <clang/Basic/FileManager.h>
  17 #include <clang/Lex/Lexer.h>
  18
  19 #include "pluginhandler.hxx"
  20 #include "compat.hxx"
  21
  22 /*
  23 Base classes for plugin actions.
  24 */
  25 namespace loplugin
  26 {
  27
  28 Plugin::Plugin( const InstantiationData& data )
  29     : compiler( data.compiler ), handler( data.handler ), name( data.name )
  30     {
  31     }
  32
  33 DiagnosticBuilder Plugin::report( DiagnosticsEngine::Level level, StringRef message, SourceLocation loc ) const
  34     {
  35     return handler.report( level, name, message, compiler, loc );
  36     }
  37
  38 bool Plugin::ignoreLocation( SourceLocation loc )
  39     {
  40     SourceLocation expansionLoc = compiler.getSourceManager().getExpansionLoc( loc );
  41     if( compiler.getSourceManager().isInSystemHeader( expansionLoc ))
  42         return true;
  43     const char* bufferName = compiler.getSourceManager().getPresumedLoc( expansionLoc ).getFilename();
  44     if( bufferName == NULL
  45         || strncmp( bufferName, WORKDIR, strlen( WORKDIR )) == 0 )
  46         return true;
  47     if( strncmp( bufferName, BUILDDIR, strlen( BUILDDIR )) == 0
  48         || strncmp( bufferName, SRCDIR, strlen( SRCDIR )) == 0 )
  49         return false; // ok
  50     return true;
  51     }
  52
  53 void Plugin::registerPlugin( Plugin* (*create)( const InstantiationData& ), const char* optionName, bool isPPCallback, bool byDefault )
  54     {
  55     PluginHandler::registerPlugin( create, optionName, isPPCallback, byDefault );
  56     }
  57
  58 unordered_map< const Stmt*, const Stmt* > Plugin::parents;
  59
  60 const Stmt* Plugin::parentStmt( const Stmt* stmt )
  61     {
  62     if( parents.empty())
  63         buildParents( compiler );
  64 if(parents.count(stmt)!=1)stmt->dump();
  65     assert( parents.count( stmt ) == 1 );
  66     return parents[ stmt ];
  67     }
  68
  69 Stmt* Plugin::parentStmt( Stmt* stmt )
  70     {
  71     if( parents.empty())
  72         buildParents( compiler );
  73     assert( parents.count( stmt ) == 1 );
  74     return const_cast< Stmt* >( parents[ stmt ] );
  75     }
  76
  77
  78 bool Plugin::isInUnoIncludeFile(SourceLocation spellingLocation) const {
  79     StringRef name {
  80         compiler.getSourceManager().getFilename(spellingLocation) };
  81     return compat::isInMainFile(compiler.getSourceManager(), spellingLocation)
  82         ? (name == SRCDIR "/cppu/source/cppu/compat.cxx"
  83            || name == SRCDIR "/cppuhelper/source/compat.cxx"
  84            || name == SRCDIR "/sal/osl/all/compat.cxx")
  85         : (name.startswith(SRCDIR "/include/com/")
  86            || name.startswith(SRCDIR "/include/cppu/")
  87            || name.startswith(SRCDIR "/include/cppuhelper/")
  88            || name.startswith(SRCDIR "/include/osl/")
  89            || name.startswith(SRCDIR "/include/rtl/")
  90            || name.startswith(SRCDIR "/include/sal/")
  91            || name.startswith(SRCDIR "/include/salhelper/")
  92            || name.startswith(SRCDIR "/include/systools/")
  93            || name.startswith(SRCDIR "/include/typelib/")
  94            || name.startswith(SRCDIR "/include/uno/")
  95            || name.startswith(SRCDIR "/workdir/")
  96            || name == SRCDIR "/include/comphelper/implbase_var.hxx");
  97 }
  98
  99 namespace
 100 {
 101 class ParentBuilder
 102     : public RecursiveASTVisitor< ParentBuilder >
 103     {
 104     public:
 105         bool VisitFunctionDecl( const FunctionDecl* function );
 106         bool VisitObjCMethodDecl( const ObjCMethodDecl* method );
 107         void walk( const Stmt* stmt );
 108         unordered_map< const Stmt*, const Stmt* >* parents;
 109     };
 110
 111 bool ParentBuilder::VisitFunctionDecl( const FunctionDecl* function )
 112     {
 113 //    if( ignoreLocation( declaration ))
 114 //        return true; ???
 115     if( function->doesThisDeclarationHaveABody())
 116         {
 117         const Stmt* body = function->getBody();
 118         (*parents)[ body ] = NULL; // no parent
 119         walk( body );
 120         }
 121     if( const CXXConstructorDecl* ctor = dyn_cast< CXXConstructorDecl >( function ))
 122         {
 123         for( CXXConstructorDecl::init_const_iterator it = ctor->init_begin();
 124              it != ctor->init_end();
 125              ++it )
 126             {
 127             const Expr* init_expression = (*it)->getInit();
 128             (*parents)[ init_expression ] = NULL;
 129             walk( init_expression );
 130             }
 131         }
 132     return true;
 133     }
 134
 135 bool ParentBuilder::VisitObjCMethodDecl( const ObjCMethodDecl* method )
 136     {
 137 //    if( ignoreLocation( declaration ))
 138 //        return true; ???
 139     if( method->hasBody())
 140         {
 141         const Stmt* body = method->getBody();
 142         (*parents)[ body ] = NULL; // no parent
 143         walk( body );
 144         }
 145     return true;
 146     }
 147
 148 void ParentBuilder::walk( const Stmt* stmt )
 149     {
 150     for( ConstStmtIterator it = stmt->child_begin();
 151          it != stmt->child_end();
 152          ++it )
 153         {
 154         if( *it != NULL )
 155             {
 156             (*parents)[ *it ] = stmt;
 157             walk( *it );
 158             }
 159         }
 160     }
 161
 162 } // namespace
 163
 164 void Plugin::buildParents( CompilerInstance& compiler )
 165     {
 166     assert( parents.empty());
 167     ParentBuilder builder;
 168     builder.parents = &parents;
 169     builder.TraverseDecl( compiler.getASTContext().getTranslationUnitDecl());
 170     }
 171
 172 SourceLocation Plugin::locationAfterToken( SourceLocation location )
 173     {
 174     return Lexer::getLocForEndOfToken( location, 0, compiler.getSourceManager(), compiler.getLangOpts());
 175     }
 176
 177 RewritePlugin::RewritePlugin( const InstantiationData& data )
 178     : Plugin( data )
 179     , rewriter( data.rewriter )
 180     {
 181     }
 182
 183 bool RewritePlugin::insertText( SourceLocation Loc, StringRef Str, bool InsertAfter, bool indentNewLines )
 184     {
 185     assert( rewriter );
 186     if( rewriter->InsertText( Loc, Str, InsertAfter, indentNewLines ))
 187         return reportEditFailure( Loc );
 188     return true;
 189     }
 190
 191 bool RewritePlugin::insertTextAfter( SourceLocation Loc, StringRef Str )
 192     {
 193     assert( rewriter );
 194     if( rewriter->InsertTextAfter( Loc, Str ))
 195         return reportEditFailure( Loc );
 196     return true;
 197     }
 198
 199 bool RewritePlugin::insertTextAfterToken( SourceLocation Loc, StringRef Str )
 200     {
 201     assert( rewriter );
 202     if( rewriter->InsertTextAfterToken( Loc, Str ))
 203         return reportEditFailure( Loc );
 204     return true;
 205     }
 206
 207 bool RewritePlugin::insertTextBefore( SourceLocation Loc, StringRef Str )
 208     {
 209     assert( rewriter );
 210     if( rewriter->InsertTextBefore( Loc, Str ))
 211         return reportEditFailure( Loc );
 212     return true;
 213     }
 214
 215 bool RewritePlugin::removeText( SourceLocation Start, unsigned Length, RewriteOptions opts )
 216     {
 217     CharSourceRange range( SourceRange( Start, Start.getLocWithOffset( Length )), false );
 218     return removeText( range, opts );
 219     }
 220
 221 bool RewritePlugin::removeText( SourceRange range, RewriteOptions opts )
 222     {
 223     return removeText( CharSourceRange( range, true ), opts );
 224     }
 225
 226 bool RewritePlugin::removeText( CharSourceRange range, RewriteOptions opts )
 227     {
 228     assert( rewriter );
 229     if( rewriter->getRangeSize( range, opts ) == -1 )
 230         return reportEditFailure( range.getBegin());
 231     if( !handler.addRemoval( range.getBegin() ) )
 232         {
 233         report( DiagnosticsEngine::Warning, "double code removal, possible plugin error", range.getBegin());
 234         return true;
 235         }
 236     if( opts.flags & RemoveWholeStatement || opts.flags & RemoveAllWhitespace )
 237         {
 238         if( !adjustRangeForOptions( &range, opts ))
 239             return reportEditFailure( range.getBegin());
 240         }
 241     if( rewriter->RemoveText( range, opts ))
 242         return reportEditFailure( range.getBegin());
 243     return true;
 244     }
 245
 246 bool RewritePlugin::adjustRangeForOptions( CharSourceRange* range, RewriteOptions opts )
 247     {
 248     assert( rewriter );
 249     SourceManager& SM = rewriter->getSourceMgr();
 250     SourceLocation fileStartLoc = SM.getLocForStartOfFile( SM.getFileID( range->getBegin()));
 251     if( fileStartLoc.isInvalid())
 252         return false;
 253     bool invalid = false;
 254     const char* fileBuf = SM.getCharacterData( fileStartLoc, &invalid );
 255     if( invalid )
 256         return false;
 257     const char* startBuf = SM.getCharacterData( range->getBegin(), &invalid );
 258     if( invalid )
 259         return false;
 260     SourceLocation locationEnd = range->getEnd();
 261     if( range->isTokenRange())
 262         locationEnd = locationAfterToken( locationEnd );
 263     const char* endBuf = SM.getCharacterData( locationEnd, &invalid );
 264     if( invalid )
 265         return false;
 266     const char* startPos = startBuf;
 267     --startPos;
 268     while( startPos >= fileBuf && ( *startPos == ' ' || *startPos == '\t' ))
 269         --startPos;
 270     if( startPos >= fileBuf && *startPos == '\n' )
 271         startPos = startBuf - 1; // do not remove indentation whitespace (RemoveLineIfEmpty can do that)
 272     const char* endPos = endBuf;
 273     while( *endPos == ' ' || *endPos == '\t' )
 274         ++endPos;
 275     if( opts.flags & RemoveWholeStatement )
 276         {
 277         if( *endPos == ';' )
 278             ++endPos;
 279         else
 280             return false;
 281         }
 282     *range = CharSourceRange( SourceRange( range->getBegin().getLocWithOffset( startPos - startBuf + 1 ),
 283         locationEnd.getLocWithOffset( endPos - endBuf )), false );
 284     return true;
 285     }
 286
 287 bool RewritePlugin::replaceText( SourceLocation Start, unsigned OrigLength, StringRef NewStr )
 288     {
 289     assert( rewriter );
 290     if( OrigLength != 0 && !handler.addRemoval( Start ) )
 291         {
 292         report( DiagnosticsEngine::Warning, "double code replacement, possible plugin error", Start );
 293         return true;
 294         }
 295     if( rewriter->ReplaceText( Start, OrigLength, NewStr ))
 296         return reportEditFailure( Start );
 297     return true;
 298     }
 299
 300 bool RewritePlugin::replaceText( SourceRange range, StringRef NewStr )
 301     {
 302     assert( rewriter );
 303     if( rewriter->getRangeSize( range ) == -1 )
 304         return reportEditFailure( range.getBegin());
 305     if( !handler.addRemoval( range.getBegin() ) )
 306         {
 307         report( DiagnosticsEngine::Warning, "double code replacement, possible plugin error", range.getBegin());
 308         return true;
 309         }
 310     if( rewriter->ReplaceText( range, NewStr ))
 311         return reportEditFailure( range.getBegin());
 312     return true;
 313     }
 314
 315 bool RewritePlugin::replaceText( SourceRange range, SourceRange replacementRange )
 316     {
 317     assert( rewriter );
 318     if( rewriter->getRangeSize( range ) == -1 )
 319         return reportEditFailure( range.getBegin());
 320     if( !handler.addRemoval( range.getBegin() ) )
 321         {
 322         report( DiagnosticsEngine::Warning, "double code replacement, possible plugin error", range.getBegin());
 323         return true;
 324         }
 325     if( rewriter->ReplaceText( range, replacementRange ))
 326         return reportEditFailure( range.getBegin());
 327     return true;
 328     }
 329
 330 bool RewritePlugin::reportEditFailure( SourceLocation loc )
 331     {
 332     report( DiagnosticsEngine::Warning, "cannot perform source modification (macro expansion involved?)", loc );
 333     return false;
 334     }
 335
 336 } // namespace
 337
 338 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */