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