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/DiagnosticOptions.h"
12 #include "clang/Basic/FileManager.h"
13 #include "clang/Basic/SourceManager.h"
14 #include "clang/Edit/Commit.h"
15 #include "clang/Edit/EditedSource.h"
16 #include "clang/Edit/EditsReceiver.h"
17 #include "clang/Lex/Lexer.h"
18 #include "llvm/ADT/SmallSet.h"
19 #include "llvm/ADT/SmallString.h"
20 #include "llvm/Support/ErrorHandling.h"
21 #include "llvm/Support/MemoryBuffer.h"
22 #include "llvm/Support/raw_ostream.h"
23 #include <algorithm>
24 using namespace clang;
25 
26 /// \brief Retrieve the name of the immediate macro expansion.
27 ///
28 /// This routine starts from a source location, and finds the name of the macro
29 /// responsible for its immediate expansion. It looks through any intervening
30 /// macro argument expansions to compute this. It returns a StringRef which
31 /// refers to the SourceManager-owned buffer of the source where that macro
32 /// name is spelled. Thus, the result shouldn't out-live that SourceManager.
33 ///
34 /// This differs from Lexer::getImmediateMacroName in that any macro argument
35 /// location will result in the topmost function macro that accepted it.
36 /// e.g.
37 /// \code
38 ///   MAC1( MAC2(foo) )
39 /// \endcode
40 /// for location of 'foo' token, this function will return "MAC1" while
41 /// Lexer::getImmediateMacroName will return "MAC2".
getImmediateMacroName(SourceLocation Loc,const SourceManager & SM,const LangOptions & LangOpts)42 static StringRef getImmediateMacroName(SourceLocation Loc,
43                                        const SourceManager &SM,
44                                        const LangOptions &LangOpts) {
45    assert(Loc.isMacroID() && "Only reasonble to call this on macros");
46    // Walk past macro argument expanions.
47    while (SM.isMacroArgExpansion(Loc))
48      Loc = SM.getImmediateExpansionRange(Loc).first;
49 
50    // If the macro's spelling has no FileID, then it's actually a token paste
51    // or stringization (or similar) and not a macro at all.
52    if (!SM.getFileEntryForID(SM.getFileID(SM.getSpellingLoc(Loc))))
53      return StringRef();
54 
55    // Find the spelling location of the start of the non-argument expansion
56    // range. This is where the macro name was spelled in order to begin
57    // expanding this macro.
58    Loc = SM.getSpellingLoc(SM.getImmediateExpansionRange(Loc).first);
59 
60    // Dig out the buffer where the macro name was spelled and the extents of the
61    // name so that we can render it into the expansion note.
62    std::pair<FileID, unsigned> ExpansionInfo = SM.getDecomposedLoc(Loc);
63    unsigned MacroTokenLength = Lexer::MeasureTokenLength(Loc, SM, LangOpts);
64    StringRef ExpansionBuffer = SM.getBufferData(ExpansionInfo.first);
65    return ExpansionBuffer.substr(ExpansionInfo.second, MacroTokenLength);
66 }
67 
DiagnosticRenderer(const LangOptions & LangOpts,DiagnosticOptions * DiagOpts)68 DiagnosticRenderer::DiagnosticRenderer(const LangOptions &LangOpts,
69                                        DiagnosticOptions *DiagOpts)
70   : LangOpts(LangOpts), DiagOpts(DiagOpts), LastLevel() {}
71 
~DiagnosticRenderer()72 DiagnosticRenderer::~DiagnosticRenderer() {}
73 
74 namespace {
75 
76 class FixitReceiver : public edit::EditsReceiver {
77   SmallVectorImpl<FixItHint> &MergedFixits;
78 
79 public:
FixitReceiver(SmallVectorImpl<FixItHint> & MergedFixits)80   FixitReceiver(SmallVectorImpl<FixItHint> &MergedFixits)
81     : MergedFixits(MergedFixits) { }
insert(SourceLocation loc,StringRef text)82   void insert(SourceLocation loc, StringRef text) override {
83     MergedFixits.push_back(FixItHint::CreateInsertion(loc, text));
84   }
replace(CharSourceRange range,StringRef text)85   void replace(CharSourceRange range, StringRef text) override {
86     MergedFixits.push_back(FixItHint::CreateReplacement(range, text));
87   }
88 };
89 
90 }
91 
mergeFixits(ArrayRef<FixItHint> FixItHints,const SourceManager & SM,const LangOptions & LangOpts,SmallVectorImpl<FixItHint> & MergedFixits)92 static void mergeFixits(ArrayRef<FixItHint> FixItHints,
93                         const SourceManager &SM, const LangOptions &LangOpts,
94                         SmallVectorImpl<FixItHint> &MergedFixits) {
95   edit::Commit commit(SM, LangOpts);
96   for (ArrayRef<FixItHint>::const_iterator
97          I = FixItHints.begin(), E = FixItHints.end(); I != E; ++I) {
98     const FixItHint &Hint = *I;
99     if (Hint.CodeToInsert.empty()) {
100       if (Hint.InsertFromRange.isValid())
101         commit.insertFromRange(Hint.RemoveRange.getBegin(),
102                            Hint.InsertFromRange, /*afterToken=*/false,
103                            Hint.BeforePreviousInsertions);
104       else
105         commit.remove(Hint.RemoveRange);
106     } else {
107       if (Hint.RemoveRange.isTokenRange() ||
108           Hint.RemoveRange.getBegin() != Hint.RemoveRange.getEnd())
109         commit.replace(Hint.RemoveRange, Hint.CodeToInsert);
110       else
111         commit.insert(Hint.RemoveRange.getBegin(), Hint.CodeToInsert,
112                     /*afterToken=*/false, Hint.BeforePreviousInsertions);
113     }
114   }
115 
116   edit::EditedSource Editor(SM, LangOpts);
117   if (Editor.commit(commit)) {
118     FixitReceiver Rec(MergedFixits);
119     Editor.applyRewrites(Rec);
120   }
121 }
122 
emitDiagnostic(SourceLocation Loc,DiagnosticsEngine::Level Level,StringRef Message,ArrayRef<CharSourceRange> Ranges,ArrayRef<FixItHint> FixItHints,const SourceManager * SM,DiagOrStoredDiag D)123 void DiagnosticRenderer::emitDiagnostic(SourceLocation Loc,
124                                         DiagnosticsEngine::Level Level,
125                                         StringRef Message,
126                                         ArrayRef<CharSourceRange> Ranges,
127                                         ArrayRef<FixItHint> FixItHints,
128                                         const SourceManager *SM,
129                                         DiagOrStoredDiag D) {
130   assert(SM || Loc.isInvalid());
131 
132   beginDiagnostic(D, Level);
133 
134   if (!Loc.isValid())
135     // If we have no source location, just emit the diagnostic message.
136     emitDiagnosticMessage(Loc, PresumedLoc(), Level, Message, Ranges, SM, D);
137   else {
138     // Get the ranges into a local array we can hack on.
139     SmallVector<CharSourceRange, 20> MutableRanges(Ranges.begin(),
140                                                    Ranges.end());
141 
142     SmallVector<FixItHint, 8> MergedFixits;
143     if (!FixItHints.empty()) {
144       mergeFixits(FixItHints, *SM, LangOpts, MergedFixits);
145       FixItHints = MergedFixits;
146     }
147 
148     for (ArrayRef<FixItHint>::const_iterator I = FixItHints.begin(),
149          E = FixItHints.end();
150          I != E; ++I)
151       if (I->RemoveRange.isValid())
152         MutableRanges.push_back(I->RemoveRange);
153 
154     SourceLocation UnexpandedLoc = Loc;
155 
156     // Find the ultimate expansion location for the diagnostic.
157     Loc = SM->getFileLoc(Loc);
158 
159     PresumedLoc PLoc = SM->getPresumedLoc(Loc, DiagOpts->ShowPresumedLoc);
160 
161     // First, if this diagnostic is not in the main file, print out the
162     // "included from" lines.
163     emitIncludeStack(Loc, PLoc, Level, *SM);
164 
165     // Next, emit the actual diagnostic message and caret.
166     emitDiagnosticMessage(Loc, PLoc, Level, Message, Ranges, SM, D);
167     emitCaret(Loc, Level, MutableRanges, FixItHints, *SM);
168 
169     // If this location is within a macro, walk from UnexpandedLoc up to Loc
170     // and produce a macro backtrace.
171     if (UnexpandedLoc.isValid() && UnexpandedLoc.isMacroID()) {
172       unsigned MacroDepth = 0;
173       emitMacroExpansions(UnexpandedLoc, Level, MutableRanges, FixItHints, *SM,
174                           MacroDepth);
175     }
176   }
177 
178   LastLoc = Loc;
179   LastLevel = Level;
180 
181   endDiagnostic(D, Level);
182 }
183 
184 
emitStoredDiagnostic(StoredDiagnostic & Diag)185 void DiagnosticRenderer::emitStoredDiagnostic(StoredDiagnostic &Diag) {
186   emitDiagnostic(Diag.getLocation(), Diag.getLevel(), Diag.getMessage(),
187                  Diag.getRanges(), Diag.getFixIts(),
188                  Diag.getLocation().isValid() ? &Diag.getLocation().getManager()
189                                               : nullptr,
190                  &Diag);
191 }
192 
emitBasicNote(StringRef Message)193 void DiagnosticRenderer::emitBasicNote(StringRef Message) {
194   emitDiagnosticMessage(
195       SourceLocation(), PresumedLoc(), DiagnosticsEngine::Note, Message,
196       None, nullptr, DiagOrStoredDiag());
197 }
198 
199 /// \brief Prints an include stack when appropriate for a particular
200 /// diagnostic level and location.
201 ///
202 /// This routine handles all the logic of suppressing particular include
203 /// stacks (such as those for notes) and duplicate include stacks when
204 /// repeated warnings occur within the same file. It also handles the logic
205 /// of customizing the formatting and display of the include stack.
206 ///
207 /// \param Loc   The diagnostic location.
208 /// \param PLoc  The presumed location of the diagnostic location.
209 /// \param Level The diagnostic level of the message this stack pertains to.
emitIncludeStack(SourceLocation Loc,PresumedLoc PLoc,DiagnosticsEngine::Level Level,const SourceManager & SM)210 void DiagnosticRenderer::emitIncludeStack(SourceLocation Loc,
211                                           PresumedLoc PLoc,
212                                           DiagnosticsEngine::Level Level,
213                                           const SourceManager &SM) {
214   SourceLocation IncludeLoc = PLoc.getIncludeLoc();
215 
216   // Skip redundant include stacks altogether.
217   if (LastIncludeLoc == IncludeLoc)
218     return;
219 
220   LastIncludeLoc = IncludeLoc;
221 
222   if (!DiagOpts->ShowNoteIncludeStack && Level == DiagnosticsEngine::Note)
223     return;
224 
225   if (IncludeLoc.isValid())
226     emitIncludeStackRecursively(IncludeLoc, SM);
227   else {
228     emitModuleBuildStack(SM);
229     emitImportStack(Loc, SM);
230   }
231 }
232 
233 /// \brief Helper to recursivly walk up the include stack and print each layer
234 /// on the way back down.
emitIncludeStackRecursively(SourceLocation Loc,const SourceManager & SM)235 void DiagnosticRenderer::emitIncludeStackRecursively(SourceLocation Loc,
236                                                      const SourceManager &SM) {
237   if (Loc.isInvalid()) {
238     emitModuleBuildStack(SM);
239     return;
240   }
241 
242   PresumedLoc PLoc = SM.getPresumedLoc(Loc, DiagOpts->ShowPresumedLoc);
243   if (PLoc.isInvalid())
244     return;
245 
246   // If this source location was imported from a module, print the module
247   // import stack rather than the
248   // FIXME: We want submodule granularity here.
249   std::pair<SourceLocation, StringRef> Imported = SM.getModuleImportLoc(Loc);
250   if (Imported.first.isValid()) {
251     // This location was imported by a module. Emit the module import stack.
252     emitImportStackRecursively(Imported.first, Imported.second, SM);
253     return;
254   }
255 
256   // Emit the other include frames first.
257   emitIncludeStackRecursively(PLoc.getIncludeLoc(), SM);
258 
259   // Emit the inclusion text/note.
260   emitIncludeLocation(Loc, PLoc, SM);
261 }
262 
263 /// \brief Emit the module import stack associated with the current location.
emitImportStack(SourceLocation Loc,const SourceManager & SM)264 void DiagnosticRenderer::emitImportStack(SourceLocation Loc,
265                                          const SourceManager &SM) {
266   if (Loc.isInvalid()) {
267     emitModuleBuildStack(SM);
268     return;
269   }
270 
271   std::pair<SourceLocation, StringRef> NextImportLoc
272     = SM.getModuleImportLoc(Loc);
273   emitImportStackRecursively(NextImportLoc.first, NextImportLoc.second, SM);
274 }
275 
276 /// \brief Helper to recursivly walk up the import stack and print each layer
277 /// on the way back down.
emitImportStackRecursively(SourceLocation Loc,StringRef ModuleName,const SourceManager & SM)278 void DiagnosticRenderer::emitImportStackRecursively(SourceLocation Loc,
279                                                     StringRef ModuleName,
280                                                     const SourceManager &SM) {
281   if (Loc.isInvalid()) {
282     return;
283   }
284 
285   PresumedLoc PLoc = SM.getPresumedLoc(Loc, DiagOpts->ShowPresumedLoc);
286   if (PLoc.isInvalid())
287     return;
288 
289   // Emit the other import frames first.
290   std::pair<SourceLocation, StringRef> NextImportLoc
291     = SM.getModuleImportLoc(Loc);
292   emitImportStackRecursively(NextImportLoc.first, NextImportLoc.second, SM);
293 
294   // Emit the inclusion text/note.
295   emitImportLocation(Loc, PLoc, ModuleName, SM);
296 }
297 
298 /// \brief Emit the module build stack, for cases where a module is (re-)built
299 /// on demand.
emitModuleBuildStack(const SourceManager & SM)300 void DiagnosticRenderer::emitModuleBuildStack(const SourceManager &SM) {
301   ModuleBuildStack Stack = SM.getModuleBuildStack();
302   for (unsigned I = 0, N = Stack.size(); I != N; ++I) {
303     const SourceManager &CurSM = Stack[I].second.getManager();
304     SourceLocation CurLoc = Stack[I].second;
305     emitBuildingModuleLocation(CurLoc,
306                                CurSM.getPresumedLoc(CurLoc,
307                                                     DiagOpts->ShowPresumedLoc),
308                                Stack[I].first,
309                                CurSM);
310   }
311 }
312 
313 // Helper function to fix up source ranges.  It takes in an array of ranges,
314 // and outputs an array of ranges where we want to draw the range highlighting
315 // around the location specified by CaretLoc.
316 //
317 // To find locations which correspond to the caret, we crawl the macro caller
318 // chain for the beginning and end of each range.  If the caret location
319 // is in a macro expansion, we search each chain for a location
320 // in the same expansion as the caret; otherwise, we crawl to the top of
321 // each chain. Two locations are part of the same macro expansion
322 // iff the FileID is the same.
mapDiagnosticRanges(SourceLocation CaretLoc,ArrayRef<CharSourceRange> Ranges,SmallVectorImpl<CharSourceRange> & SpellingRanges,const SourceManager * SM)323 static void mapDiagnosticRanges(
324     SourceLocation CaretLoc,
325     ArrayRef<CharSourceRange> Ranges,
326     SmallVectorImpl<CharSourceRange> &SpellingRanges,
327     const SourceManager *SM) {
328   FileID CaretLocFileID = SM->getFileID(CaretLoc);
329 
330   for (ArrayRef<CharSourceRange>::const_iterator I = Ranges.begin(),
331        E = Ranges.end();
332        I != E; ++I) {
333     SourceLocation Begin = I->getBegin(), End = I->getEnd();
334     bool IsTokenRange = I->isTokenRange();
335 
336     FileID BeginFileID = SM->getFileID(Begin);
337     FileID EndFileID = SM->getFileID(End);
338 
339     // Find the common parent for the beginning and end of the range.
340 
341     // First, crawl the expansion chain for the beginning of the range.
342     llvm::SmallDenseMap<FileID, SourceLocation> BeginLocsMap;
343     while (Begin.isMacroID() && BeginFileID != EndFileID) {
344       BeginLocsMap[BeginFileID] = Begin;
345       Begin = SM->getImmediateExpansionRange(Begin).first;
346       BeginFileID = SM->getFileID(Begin);
347     }
348 
349     // Then, crawl the expansion chain for the end of the range.
350     if (BeginFileID != EndFileID) {
351       while (End.isMacroID() && !BeginLocsMap.count(EndFileID)) {
352         End = SM->getImmediateExpansionRange(End).second;
353         EndFileID = SM->getFileID(End);
354       }
355       if (End.isMacroID()) {
356         Begin = BeginLocsMap[EndFileID];
357         BeginFileID = EndFileID;
358       }
359     }
360 
361     while (Begin.isMacroID() && BeginFileID != CaretLocFileID) {
362       if (SM->isMacroArgExpansion(Begin)) {
363         Begin = SM->getImmediateSpellingLoc(Begin);
364         End = SM->getImmediateSpellingLoc(End);
365       } else {
366         Begin = SM->getImmediateExpansionRange(Begin).first;
367         End = SM->getImmediateExpansionRange(End).second;
368       }
369       BeginFileID = SM->getFileID(Begin);
370       if (BeginFileID != SM->getFileID(End)) {
371         // FIXME: Ugly hack to stop a crash; this code is making bad
372         // assumptions and it's too complicated for me to reason
373         // about.
374         Begin = End = SourceLocation();
375         break;
376       }
377     }
378 
379     // Return the spelling location of the beginning and end of the range.
380     Begin = SM->getSpellingLoc(Begin);
381     End = SM->getSpellingLoc(End);
382     SpellingRanges.push_back(CharSourceRange(SourceRange(Begin, End),
383                                              IsTokenRange));
384   }
385 }
386 
emitCaret(SourceLocation Loc,DiagnosticsEngine::Level Level,ArrayRef<CharSourceRange> Ranges,ArrayRef<FixItHint> Hints,const SourceManager & SM)387 void DiagnosticRenderer::emitCaret(SourceLocation Loc,
388                                    DiagnosticsEngine::Level Level,
389                                    ArrayRef<CharSourceRange> Ranges,
390                                    ArrayRef<FixItHint> Hints,
391                                    const SourceManager &SM) {
392   SmallVector<CharSourceRange, 4> SpellingRanges;
393   mapDiagnosticRanges(Loc, Ranges, SpellingRanges, &SM);
394   emitCodeContext(Loc, Level, SpellingRanges, Hints, SM);
395 }
396 
397 /// \brief Recursively emit notes for each macro expansion and caret
398 /// diagnostics where appropriate.
399 ///
400 /// Walks up the macro expansion stack printing expansion notes, the code
401 /// snippet, caret, underlines and FixItHint display as appropriate at each
402 /// level.
403 ///
404 /// \param Loc The location for this caret.
405 /// \param Level The diagnostic level currently being emitted.
406 /// \param Ranges The underlined ranges for this code snippet.
407 /// \param Hints The FixIt hints active for this diagnostic.
408 /// \param OnMacroInst The current depth of the macro expansion stack.
emitMacroExpansions(SourceLocation Loc,DiagnosticsEngine::Level Level,ArrayRef<CharSourceRange> Ranges,ArrayRef<FixItHint> Hints,const SourceManager & SM,unsigned & MacroDepth,unsigned OnMacroInst)409 void DiagnosticRenderer::emitMacroExpansions(SourceLocation Loc,
410                                              DiagnosticsEngine::Level Level,
411                                              ArrayRef<CharSourceRange> Ranges,
412                                              ArrayRef<FixItHint> Hints,
413                                              const SourceManager &SM,
414                                              unsigned &MacroDepth,
415                                              unsigned OnMacroInst) {
416   assert(!Loc.isInvalid() && "must have a valid source location here");
417 
418   // Walk up to the caller of this macro, and produce a backtrace down to there.
419   SourceLocation OneLevelUp = SM.getImmediateMacroCallerLoc(Loc);
420   if (OneLevelUp.isMacroID())
421     emitMacroExpansions(OneLevelUp, Level, Ranges, Hints, SM,
422                         MacroDepth, OnMacroInst + 1);
423   else
424     MacroDepth = OnMacroInst + 1;
425 
426   unsigned MacroSkipStart = 0, MacroSkipEnd = 0;
427   if (MacroDepth > DiagOpts->MacroBacktraceLimit &&
428       DiagOpts->MacroBacktraceLimit != 0) {
429     MacroSkipStart = DiagOpts->MacroBacktraceLimit / 2 +
430     DiagOpts->MacroBacktraceLimit % 2;
431     MacroSkipEnd = MacroDepth - DiagOpts->MacroBacktraceLimit / 2;
432   }
433 
434   // Whether to suppress printing this macro expansion.
435   bool Suppressed = (OnMacroInst >= MacroSkipStart &&
436                      OnMacroInst < MacroSkipEnd);
437 
438   if (Suppressed) {
439     // Tell the user that we've skipped contexts.
440     if (OnMacroInst == MacroSkipStart) {
441       SmallString<200> MessageStorage;
442       llvm::raw_svector_ostream Message(MessageStorage);
443       Message << "(skipping " << (MacroSkipEnd - MacroSkipStart)
444               << " expansions in backtrace; use -fmacro-backtrace-limit=0 to "
445                  "see all)";
446       emitBasicNote(Message.str());
447     }
448     return;
449   }
450 
451   // Find the spelling location for the macro definition. We must use the
452   // spelling location here to avoid emitting a macro bactrace for the note.
453   SourceLocation SpellingLoc = Loc;
454   // If this is the expansion of a macro argument, point the caret at the
455   // use of the argument in the definition of the macro, not the expansion.
456   if (SM.isMacroArgExpansion(Loc))
457     SpellingLoc = SM.getImmediateExpansionRange(Loc).first;
458   SpellingLoc = SM.getSpellingLoc(SpellingLoc);
459 
460   // Map the ranges into the FileID of the diagnostic location.
461   SmallVector<CharSourceRange, 4> SpellingRanges;
462   mapDiagnosticRanges(Loc, Ranges, SpellingRanges, &SM);
463 
464   SmallString<100> MessageStorage;
465   llvm::raw_svector_ostream Message(MessageStorage);
466   StringRef MacroName = getImmediateMacroName(Loc, SM, LangOpts);
467   if (MacroName.empty())
468     Message << "expanded from here";
469   else
470     Message << "expanded from macro '" << MacroName << "'";
471   emitDiagnostic(SpellingLoc, DiagnosticsEngine::Note, Message.str(),
472                  SpellingRanges, None, &SM);
473 }
474 
~DiagnosticNoteRenderer()475 DiagnosticNoteRenderer::~DiagnosticNoteRenderer() {}
476 
emitIncludeLocation(SourceLocation Loc,PresumedLoc PLoc,const SourceManager & SM)477 void DiagnosticNoteRenderer::emitIncludeLocation(SourceLocation Loc,
478                                                  PresumedLoc PLoc,
479                                                  const SourceManager &SM) {
480   // Generate a note indicating the include location.
481   SmallString<200> MessageStorage;
482   llvm::raw_svector_ostream Message(MessageStorage);
483   Message << "in file included from " << PLoc.getFilename() << ':'
484           << PLoc.getLine() << ":";
485   emitNote(Loc, Message.str(), &SM);
486 }
487 
emitImportLocation(SourceLocation Loc,PresumedLoc PLoc,StringRef ModuleName,const SourceManager & SM)488 void DiagnosticNoteRenderer::emitImportLocation(SourceLocation Loc,
489                                                 PresumedLoc PLoc,
490                                                 StringRef ModuleName,
491                                                 const SourceManager &SM) {
492   // Generate a note indicating the include location.
493   SmallString<200> MessageStorage;
494   llvm::raw_svector_ostream Message(MessageStorage);
495   Message << "in module '" << ModuleName << "' imported from "
496           << PLoc.getFilename() << ':' << PLoc.getLine() << ":";
497   emitNote(Loc, Message.str(), &SM);
498 }
499 
500 void
emitBuildingModuleLocation(SourceLocation Loc,PresumedLoc PLoc,StringRef ModuleName,const SourceManager & SM)501 DiagnosticNoteRenderer::emitBuildingModuleLocation(SourceLocation Loc,
502                                                    PresumedLoc PLoc,
503                                                    StringRef ModuleName,
504                                                    const SourceManager &SM) {
505   // Generate a note indicating the include location.
506   SmallString<200> MessageStorage;
507   llvm::raw_svector_ostream Message(MessageStorage);
508   if (PLoc.getFilename())
509     Message << "while building module '" << ModuleName << "' imported from "
510             << PLoc.getFilename() << ':' << PLoc.getLine() << ":";
511   else
512     Message << "while building module '" << ModuleName << "':";
513   emitNote(Loc, Message.str(), &SM);
514 }
515