[analyzer] Fix macro printer crash when macro comes from another translation unit

[Szelethus]

Yup, cheers!

[Szelethus]

Whoops, incorrect commit title and description. Anyways, the committed code and the revision number is OK...

cfe/trunk/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp

static std::string getMacroNameAndPrintExpansion(TokenPrinter &Printer,
                                                  SourceLocation MacroLoc,
                                                  const Preprocessor &PP,
                                                  const MacroArgMap &PrevArgs) {
 
   const SourceManager &SM = PP.getSourceManager();
 
   MacroNameAndArgs Info = getMacroNameAndArgs(SM.getExpansionLoc(MacroLoc), PP);
 
+  if (!Info.MI)
+    return Info.Name;
+
   // Manually expand its arguments from the previous macro.
   Info.Args.expandFromPrevMacro(PrevArgs);
 
   // Iterate over the macro's tokens and stringify them.
   for (auto It = Info.MI->tokens_begin(), E = Info.MI->tokens_end(); It != E;
        ++It) {
     Token T = *It;
 
static MacroNameAndArgs getMacroNameAndArgs(SourceLocation ExpanLoc,
   RawLexer.LexFromRawLexer(TheTok);
 
   std::string MacroName = PP.getSpelling(TheTok);
 
   const auto *II = PP.getIdentifierInfo(MacroName);
   assert(II && "Failed to acquire the IndetifierInfo for the macro!");
 
   const MacroInfo *MI = getMacroInfoForLocation(PP, SM, II, ExpanLoc);
-  assert(MI && "The macro must've been defined at it's expansion location!");
+  // assert(MI && "The macro must've been defined at it's expansion location!");
+  //
+  // We should always be able to obtain the MacroInfo in a given TU, but if
+  // we're running the analyzer with CTU, the Preprocessor won't contain the
+  // directive history (or anything for that matter) from another TU.
+  // TODO: assert when we're not running with CTU.
+  if (!MI)
+    return { MacroName, MI, {} };
 
   // Acquire the macro's arguments.
   //
   // The rough idea here is to lex from the first left parentheses to the last
   // right parentheses, and map the macro's unexpanded arguments to what they
   // will be expanded to. An expanded macro argument may contain several tokens
   // (like '3 + 4'), so we'll lex until we find a tok::comma or tok::r_paren, at
   // which point we start lexing the next argument or finish.