contrib/llvm/tools/clang/lib/Frontend/DiagnosticRenderer.cpp

   1 //===--- DiagnosticRenderer.cpp - Diagnostic Pretty-Printing --------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "clang/Frontend/DiagnosticRenderer.h"
  11 #include "clang/Basic/FileManager.h"
  12 #include "clang/Basic/SourceManager.h"
  13 #include "clang/Frontend/DiagnosticOptions.h"
  14 #include "clang/Lex/Lexer.h"
  15 #include "clang/Edit/EditedSource.h"
  16 #include "clang/Edit/Commit.h"
  17 #include "clang/Edit/EditsReceiver.h"
  18 #include "llvm/Support/MemoryBuffer.h"
  19 #include "llvm/Support/raw_ostream.h"
  20 #include "llvm/Support/ErrorHandling.h"
  21 #include "llvm/ADT/SmallString.h"
  22 #include <algorithm>
  23 using namespace clang;
  24
  25 /// \brief Retrieve the name of the immediate macro expansion.
  26 ///
  27 /// This routine starts from a source location, and finds the name of the macro
  28 /// responsible for its immediate expansion. It looks through any intervening
  29 /// macro argument expansions to compute this. It returns a StringRef which
  30 /// refers to the SourceManager-owned buffer of the source where that macro
  31 /// name is spelled. Thus, the result shouldn't out-live that SourceManager.
  32 ///
  33 /// This differs from Lexer::getImmediateMacroName in that any macro argument
  34 /// location will result in the topmost function macro that accepted it.
  35 /// e.g.
  36 /// \code
  37 ///   MAC1( MAC2(foo) )
  38 /// \endcode
  39 /// for location of 'foo' token, this function will return "MAC1" while
  40 /// Lexer::getImmediateMacroName will return "MAC2".
  41 static StringRef getImmediateMacroName(SourceLocation Loc,
  42                                        const SourceManager &SM,
  43                                        const LangOptions &LangOpts) {
  44    assert(Loc.isMacroID() && "Only reasonble to call this on macros");
  45    // Walk past macro argument expanions.
  46    while (SM.isMacroArgExpansion(Loc))
  47      Loc = SM.getImmediateExpansionRange(Loc).first;
  48
  49    // Find the spelling location of the start of the non-argument expansion
  50    // range. This is where the macro name was spelled in order to begin
  51    // expanding this macro.
  52    Loc = SM.getSpellingLoc(SM.getImmediateExpansionRange(Loc).first);
  53
  54    // Dig out the buffer where the macro name was spelled and the extents of the
  55    // name so that we can render it into the expansion note.
  56    std::pair<FileID, unsigned> ExpansionInfo = SM.getDecomposedLoc(Loc);
  57    unsigned MacroTokenLength = Lexer::MeasureTokenLength(Loc, SM, LangOpts);
  58    StringRef ExpansionBuffer = SM.getBufferData(ExpansionInfo.first);
  59    return ExpansionBuffer.substr(ExpansionInfo.second, MacroTokenLength);
  60 }
  61
  62 DiagnosticRenderer::DiagnosticRenderer(const LangOptions &LangOpts,
  63                                        const DiagnosticOptions &DiagOpts)
  64 : LangOpts(LangOpts), DiagOpts(DiagOpts), LastLevel() {}
  65
  66 DiagnosticRenderer::~DiagnosticRenderer() {}
  67
  68 namespace {
  69
  70 class FixitReceiver : public edit::EditsReceiver {
  71   SmallVectorImpl<FixItHint> &MergedFixits;
  72
  73 public:
  74   FixitReceiver(SmallVectorImpl<FixItHint> &MergedFixits)
  75     : MergedFixits(MergedFixits) { }
  76   virtual void insert(SourceLocation loc, StringRef text) {
  77     MergedFixits.push_back(FixItHint::CreateInsertion(loc, text));
  78   }
  79   virtual void replace(CharSourceRange range, StringRef text) {
  80     MergedFixits.push_back(FixItHint::CreateReplacement(range, text));
  81   }
  82 };
  83
  84 }
  85
  86 static void mergeFixits(ArrayRef<FixItHint> FixItHints,
  87                         const SourceManager &SM, const LangOptions &LangOpts,
  88                         SmallVectorImpl<FixItHint> &MergedFixits) {
  89   edit::Commit commit(SM, LangOpts);
  90   for (ArrayRef<FixItHint>::const_iterator
  91          I = FixItHints.begin(), E = FixItHints.end(); I != E; ++I) {
  92     const FixItHint &Hint = *I;
  93     if (Hint.CodeToInsert.empty()) {
  94       if (Hint.InsertFromRange.isValid())
  95         commit.insertFromRange(Hint.RemoveRange.getBegin(),
  96                            Hint.InsertFromRange, /*afterToken=*/false,
  97                            Hint.BeforePreviousInsertions);
  98       else
  99         commit.remove(Hint.RemoveRange);
 100     } else {
 101       if (Hint.RemoveRange.isTokenRange() ||
 102           Hint.RemoveRange.getBegin() != Hint.RemoveRange.getEnd())
 103         commit.replace(Hint.RemoveRange, Hint.CodeToInsert);
 104       else
 105         commit.insert(Hint.RemoveRange.getBegin(), Hint.CodeToInsert,
 106                     /*afterToken=*/false, Hint.BeforePreviousInsertions);
 107     }
 108   }
 109
 110   edit::EditedSource Editor(SM, LangOpts);
 111   if (Editor.commit(commit)) {
 112     FixitReceiver Rec(MergedFixits);
 113     Editor.applyRewrites(Rec);
 114   }
 115 }
 116
 117 void DiagnosticRenderer::emitDiagnostic(SourceLocation Loc,
 118                                         DiagnosticsEngine::Level Level,
 119                                         StringRef Message,
 120                                         ArrayRef<CharSourceRange> Ranges,
 121                                         ArrayRef<FixItHint> FixItHints,
 122                                         const SourceManager *SM,
 123                                         DiagOrStoredDiag D) {
 124   assert(SM || Loc.isInvalid());
 125
 126   beginDiagnostic(D, Level);
 127
 128   PresumedLoc PLoc;
 129   if (Loc.isValid()) {
 130     PLoc = SM->getPresumedLocForDisplay(Loc);
 131
 132     // First, if this diagnostic is not in the main file, print out the
 133     // "included from" lines.
 134     emitIncludeStack(PLoc.getIncludeLoc(), Level, *SM);
 135   }
 136
 137   // Next, emit the actual diagnostic message.
 138   emitDiagnosticMessage(Loc, PLoc, Level, Message, Ranges, SM, D);
 139
 140   // Only recurse if we have a valid location.
 141   if (Loc.isValid()) {
 142     // Get the ranges into a local array we can hack on.
 143     SmallVector<CharSourceRange, 20> MutableRanges(Ranges.begin(),
 144                                                    Ranges.end());
 145
 146     llvm::SmallVector<FixItHint, 8> MergedFixits;
 147     if (!FixItHints.empty()) {
 148       mergeFixits(FixItHints, *SM, LangOpts, MergedFixits);
 149       FixItHints = MergedFixits;
 150     }
 151
 152     for (ArrayRef<FixItHint>::const_iterator I = FixItHints.begin(),
 153          E = FixItHints.end();
 154          I != E; ++I)
 155       if (I->RemoveRange.isValid())
 156         MutableRanges.push_back(I->RemoveRange);
 157
 158     unsigned MacroDepth = 0;
 159     emitMacroExpansionsAndCarets(Loc, Level, MutableRanges, FixItHints, *SM,
 160                                  MacroDepth);
 161   }
 162
 163   LastLoc = Loc;
 164   LastLevel = Level;
 165
 166   endDiagnostic(D, Level);
 167 }
 168
 169
 170 void DiagnosticRenderer::emitStoredDiagnostic(StoredDiagnostic &Diag) {
 171   emitDiagnostic(Diag.getLocation(), Diag.getLevel(), Diag.getMessage(),
 172                  Diag.getRanges(), Diag.getFixIts(),
 173                  Diag.getLocation().isValid() ? &Diag.getLocation().getManager()
 174                                               : 0,
 175                  &Diag);
 176 }
 177
 178 /// \brief Prints an include stack when appropriate for a particular
 179 /// diagnostic level and location.
 180 ///
 181 /// This routine handles all the logic of suppressing particular include
 182 /// stacks (such as those for notes) and duplicate include stacks when
 183 /// repeated warnings occur within the same file. It also handles the logic
 184 /// of customizing the formatting and display of the include stack.
 185 ///
 186 /// \param Level The diagnostic level of the message this stack pertains to.
 187 /// \param Loc   The include location of the current file (not the diagnostic
 188 ///              location).
 189 void DiagnosticRenderer::emitIncludeStack(SourceLocation Loc,
 190                                           DiagnosticsEngine::Level Level,
 191                                           const SourceManager &SM) {
 192   // Skip redundant include stacks altogether.
 193   if (LastIncludeLoc == Loc)
 194     return;
 195   LastIncludeLoc = Loc;
 196
 197   if (!DiagOpts.ShowNoteIncludeStack && Level == DiagnosticsEngine::Note)
 198     return;
 199
 200   emitIncludeStackRecursively(Loc, SM);
 201 }
 202
 203 /// \brief Helper to recursivly walk up the include stack and print each layer
 204 /// on the way back down.
 205 void DiagnosticRenderer::emitIncludeStackRecursively(SourceLocation Loc,
 206                                                      const SourceManager &SM) {
 207   if (Loc.isInvalid())
 208     return;
 209
 210   PresumedLoc PLoc = SM.getPresumedLoc(Loc);
 211   if (PLoc.isInvalid())
 212     return;
 213
 214   // Emit the other include frames first.
 215   emitIncludeStackRecursively(PLoc.getIncludeLoc(), SM);
 216
 217   // Emit the inclusion text/note.
 218   emitIncludeLocation(Loc, PLoc, SM);
 219 }
 220
 221 /// \brief Recursively emit notes for each macro expansion and caret
 222 /// diagnostics where appropriate.
 223 ///
 224 /// Walks up the macro expansion stack printing expansion notes, the code
 225 /// snippet, caret, underlines and FixItHint display as appropriate at each
 226 /// level.
 227 ///
 228 /// \param Loc The location for this caret.
 229 /// \param Level The diagnostic level currently being emitted.
 230 /// \param Ranges The underlined ranges for this code snippet.
 231 /// \param Hints The FixIt hints active for this diagnostic.
 232 /// \param MacroSkipEnd The depth to stop skipping macro expansions.
 233 /// \param OnMacroInst The current depth of the macro expansion stack.
 234 void DiagnosticRenderer::emitMacroExpansionsAndCarets(
 235        SourceLocation Loc,
 236        DiagnosticsEngine::Level Level,
 237        SmallVectorImpl<CharSourceRange>& Ranges,
 238        ArrayRef<FixItHint> Hints,
 239        const SourceManager &SM,
 240        unsigned &MacroDepth,
 241        unsigned OnMacroInst)
 242 {
 243   assert(!Loc.isInvalid() && "must have a valid source location here");
 244
 245   // If this is a file source location, directly emit the source snippet and
 246   // caret line. Also record the macro depth reached.
 247   if (Loc.isFileID()) {
 248     assert(MacroDepth == 0 && "We shouldn't hit a leaf node twice!");
 249     MacroDepth = OnMacroInst;
 250     emitCodeContext(Loc, Level, Ranges, Hints, SM);
 251     return;
 252   }
 253   // Otherwise recurse through each macro expansion layer.
 254
 255   // When processing macros, skip over the expansions leading up to
 256   // a macro argument, and trace the argument's expansion stack instead.
 257   Loc = SM.skipToMacroArgExpansion(Loc);
 258
 259   SourceLocation OneLevelUp = SM.getImmediateMacroCallerLoc(Loc);
 260
 261   // FIXME: Map ranges?
 262   emitMacroExpansionsAndCarets(OneLevelUp, Level, Ranges, Hints, SM, MacroDepth,
 263                                OnMacroInst + 1);
 264
 265   // Save the original location so we can find the spelling of the macro call.
 266   SourceLocation MacroLoc = Loc;
 267
 268   // Map the location.
 269   Loc = SM.getImmediateMacroCalleeLoc(Loc);
 270
 271   unsigned MacroSkipStart = 0, MacroSkipEnd = 0;
 272   if (MacroDepth > DiagOpts.MacroBacktraceLimit &&
 273       DiagOpts.MacroBacktraceLimit != 0) {
 274     MacroSkipStart = DiagOpts.MacroBacktraceLimit / 2 +
 275     DiagOpts.MacroBacktraceLimit % 2;
 276     MacroSkipEnd = MacroDepth - DiagOpts.MacroBacktraceLimit / 2;
 277   }
 278
 279   // Whether to suppress printing this macro expansion.
 280   bool Suppressed = (OnMacroInst >= MacroSkipStart &&
 281                      OnMacroInst < MacroSkipEnd);
 282
 283   // Map the ranges.
 284   for (SmallVectorImpl<CharSourceRange>::iterator I = Ranges.begin(),
 285        E = Ranges.end();
 286        I != E; ++I) {
 287     SourceLocation Start = I->getBegin(), End = I->getEnd();
 288     if (Start.isMacroID())
 289       I->setBegin(SM.getImmediateMacroCalleeLoc(Start));
 290     if (End.isMacroID())
 291       I->setEnd(SM.getImmediateMacroCalleeLoc(End));
 292   }
 293
 294   if (Suppressed) {
 295     // Tell the user that we've skipped contexts.
 296     if (OnMacroInst == MacroSkipStart) {
 297       SmallString<200> MessageStorage;
 298       llvm::raw_svector_ostream Message(MessageStorage);
 299       Message << "(skipping " << (MacroSkipEnd - MacroSkipStart)
 300               << " expansions in backtrace; use -fmacro-backtrace-limit=0 to "
 301                  "see all)";
 302       emitBasicNote(Message.str());
 303     }
 304     return;
 305   }
 306
 307   SmallString<100> MessageStorage;
 308   llvm::raw_svector_ostream Message(MessageStorage);
 309   Message << "expanded from macro '"
 310           << getImmediateMacroName(MacroLoc, SM, LangOpts) << "'";
 311   emitDiagnostic(SM.getSpellingLoc(Loc), DiagnosticsEngine::Note,
 312                  Message.str(),
 313                  Ranges, ArrayRef<FixItHint>(), &SM);
 314 }
 315
 316 DiagnosticNoteRenderer::~DiagnosticNoteRenderer() {}
 317
 318 void DiagnosticNoteRenderer::emitIncludeLocation(SourceLocation Loc,
 319                                                  PresumedLoc PLoc,
 320                                                  const SourceManager &SM) {
 321   // Generate a note indicating the include location.
 322   SmallString<200> MessageStorage;
 323   llvm::raw_svector_ostream Message(MessageStorage);
 324   Message << "in file included from " << PLoc.getFilename() << ':'
 325           << PLoc.getLine() << ":";
 326   emitNote(Loc, Message.str(), &SM);
 327 }
 328
 329 void DiagnosticNoteRenderer::emitBasicNote(StringRef Message) {
 330   emitNote(SourceLocation(), Message, 0);
 331 }