1//===--- TextDiagnostic.cpp - Text 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/TextDiagnostic.h"
11#include "clang/Basic/CharInfo.h"
12#include "clang/Basic/DiagnosticOptions.h"
13#include "clang/Basic/FileManager.h"
14#include "clang/Basic/SourceManager.h"
15#include "clang/Lex/Lexer.h"
16#include "llvm/ADT/SmallString.h"
17#include "llvm/ADT/StringExtras.h"
18#include "llvm/Support/ConvertUTF.h"
19#include "llvm/Support/ErrorHandling.h"
20#include "llvm/Support/Locale.h"
21#include "llvm/Support/MemoryBuffer.h"
22#include "llvm/Support/raw_ostream.h"
23#include <algorithm>
24
25using namespace clang;
26
27static const enum raw_ostream::Colors noteColor =
28  raw_ostream::BLACK;
29static const enum raw_ostream::Colors remarkColor =
30  raw_ostream::BLUE;
31static const enum raw_ostream::Colors fixitColor =
32  raw_ostream::GREEN;
33static const enum raw_ostream::Colors caretColor =
34  raw_ostream::GREEN;
35static const enum raw_ostream::Colors warningColor =
36  raw_ostream::MAGENTA;
37static const enum raw_ostream::Colors templateColor =
38  raw_ostream::CYAN;
39static const enum raw_ostream::Colors errorColor = raw_ostream::RED;
40static const enum raw_ostream::Colors fatalColor = raw_ostream::RED;
41// Used for changing only the bold attribute.
42static const enum raw_ostream::Colors savedColor =
43  raw_ostream::SAVEDCOLOR;
44
45/// \brief Add highlights to differences in template strings.
46static void applyTemplateHighlighting(raw_ostream &OS, StringRef Str,
47                                      bool &Normal, bool Bold) {
48  while (1) {
49    size_t Pos = Str.find(ToggleHighlight);
50    OS << Str.slice(0, Pos);
51    if (Pos == StringRef::npos)
52      break;
53
54    Str = Str.substr(Pos + 1);
55    if (Normal)
56      OS.changeColor(templateColor, true);
57    else {
58      OS.resetColor();
59      if (Bold)
60        OS.changeColor(savedColor, true);
61    }
62    Normal = !Normal;
63  }
64}
65
66/// \brief Number of spaces to indent when word-wrapping.
67const unsigned WordWrapIndentation = 6;
68
69static int bytesSincePreviousTabOrLineBegin(StringRef SourceLine, size_t i) {
70  int bytes = 0;
71  while (0<i) {
72    if (SourceLine[--i]=='\t')
73      break;
74    ++bytes;
75  }
76  return bytes;
77}
78
79/// \brief returns a printable representation of first item from input range
80///
81/// This function returns a printable representation of the next item in a line
82///  of source. If the next byte begins a valid and printable character, that
83///  character is returned along with 'true'.
84///
85/// Otherwise, if the next byte begins a valid, but unprintable character, a
86///  printable, escaped representation of the character is returned, along with
87///  'false'. Otherwise a printable, escaped representation of the next byte
88///  is returned along with 'false'.
89///
90/// \note The index is updated to be used with a subsequent call to
91///        printableTextForNextCharacter.
92///
93/// \param SourceLine The line of source
94/// \param i Pointer to byte index,
95/// \param TabStop used to expand tabs
96/// \return pair(printable text, 'true' iff original text was printable)
97///
98static std::pair<SmallString<16>, bool>
99printableTextForNextCharacter(StringRef SourceLine, size_t *i,
100                              unsigned TabStop) {
101  assert(i && "i must not be null");
102  assert(*i<SourceLine.size() && "must point to a valid index");
103
104  if (SourceLine[*i]=='\t') {
105    assert(0 < TabStop && TabStop <= DiagnosticOptions::MaxTabStop &&
106           "Invalid -ftabstop value");
107    unsigned col = bytesSincePreviousTabOrLineBegin(SourceLine, *i);
108    unsigned NumSpaces = TabStop - col%TabStop;
109    assert(0 < NumSpaces && NumSpaces <= TabStop
110           && "Invalid computation of space amt");
111    ++(*i);
112
113    SmallString<16> expandedTab;
114    expandedTab.assign(NumSpaces, ' ');
115    return std::make_pair(expandedTab, true);
116  }
117
118  unsigned char const *begin, *end;
119  begin = reinterpret_cast<unsigned char const *>(&*(SourceLine.begin() + *i));
120  end = begin + (SourceLine.size() - *i);
121
122  if (isLegalUTF8Sequence(begin, end)) {
123    UTF32 c;
124    UTF32 *cptr = &c;
125    unsigned char const *original_begin = begin;
126    unsigned char const *cp_end = begin+getNumBytesForUTF8(SourceLine[*i]);
127
128    ConversionResult res = ConvertUTF8toUTF32(&begin, cp_end, &cptr, cptr+1,
129                                              strictConversion);
130    (void)res;
131    assert(conversionOK==res);
132    assert(0 < begin-original_begin
133           && "we must be further along in the string now");
134    *i += begin-original_begin;
135
136    if (!llvm::sys::locale::isPrint(c)) {
137      // If next character is valid UTF-8, but not printable
138      SmallString<16> expandedCP("<U+>");
139      while (c) {
140        expandedCP.insert(expandedCP.begin()+3, llvm::hexdigit(c%16));
141        c/=16;
142      }
143      while (expandedCP.size() < 8)
144        expandedCP.insert(expandedCP.begin()+3, llvm::hexdigit(0));
145      return std::make_pair(expandedCP, false);
146    }
147
148    // If next character is valid UTF-8, and printable
149    return std::make_pair(SmallString<16>(original_begin, cp_end), true);
150
151  }
152
153  // If next byte is not valid UTF-8 (and therefore not printable)
154  SmallString<16> expandedByte("<XX>");
155  unsigned char byte = SourceLine[*i];
156  expandedByte[1] = llvm::hexdigit(byte / 16);
157  expandedByte[2] = llvm::hexdigit(byte % 16);
158  ++(*i);
159  return std::make_pair(expandedByte, false);
160}
161
162static void expandTabs(std::string &SourceLine, unsigned TabStop) {
163  size_t i = SourceLine.size();
164  while (i>0) {
165    i--;
166    if (SourceLine[i]!='\t')
167      continue;
168    size_t tmp_i = i;
169    std::pair<SmallString<16>,bool> res
170      = printableTextForNextCharacter(SourceLine, &tmp_i, TabStop);
171    SourceLine.replace(i, 1, res.first.c_str());
172  }
173}
174
175/// This function takes a raw source line and produces a mapping from the bytes
176///  of the printable representation of the line to the columns those printable
177///  characters will appear at (numbering the first column as 0).
178///
179/// If a byte 'i' corresponds to muliple columns (e.g. the byte contains a tab
180///  character) then the array will map that byte to the first column the
181///  tab appears at and the next value in the map will have been incremented
182///  more than once.
183///
184/// If a byte is the first in a sequence of bytes that together map to a single
185///  entity in the output, then the array will map that byte to the appropriate
186///  column while the subsequent bytes will be -1.
187///
188/// The last element in the array does not correspond to any byte in the input
189///  and instead is the number of columns needed to display the source
190///
191/// example: (given a tabstop of 8)
192///
193///    "a \t \u3042" -> {0,1,2,8,9,-1,-1,11}
194///
195///  (\\u3042 is represented in UTF-8 by three bytes and takes two columns to
196///   display)
197static void byteToColumn(StringRef SourceLine, unsigned TabStop,
198                         SmallVectorImpl<int> &out) {
199  out.clear();
200
201  if (SourceLine.empty()) {
202    out.resize(1u,0);
203    return;
204  }
205
206  out.resize(SourceLine.size()+1, -1);
207
208  int columns = 0;
209  size_t i = 0;
210  while (i<SourceLine.size()) {
211    out[i] = columns;
212    std::pair<SmallString<16>,bool> res
213      = printableTextForNextCharacter(SourceLine, &i, TabStop);
214    columns += llvm::sys::locale::columnWidth(res.first);
215  }
216  out.back() = columns;
217}
218
219/// This function takes a raw source line and produces a mapping from columns
220///  to the byte of the source line that produced the character displaying at
221///  that column. This is the inverse of the mapping produced by byteToColumn()
222///
223/// The last element in the array is the number of bytes in the source string
224///
225/// example: (given a tabstop of 8)
226///
227///    "a \t \u3042" -> {0,1,2,-1,-1,-1,-1,-1,3,4,-1,7}
228///
229///  (\\u3042 is represented in UTF-8 by three bytes and takes two columns to
230///   display)
231static void columnToByte(StringRef SourceLine, unsigned TabStop,
232                         SmallVectorImpl<int> &out) {
233  out.clear();
234
235  if (SourceLine.empty()) {
236    out.resize(1u, 0);
237    return;
238  }
239
240  int columns = 0;
241  size_t i = 0;
242  while (i<SourceLine.size()) {
243    out.resize(columns+1, -1);
244    out.back() = i;
245    std::pair<SmallString<16>,bool> res
246      = printableTextForNextCharacter(SourceLine, &i, TabStop);
247    columns += llvm::sys::locale::columnWidth(res.first);
248  }
249  out.resize(columns+1, -1);
250  out.back() = i;
251}
252
253namespace {
254struct SourceColumnMap {
255  SourceColumnMap(StringRef SourceLine, unsigned TabStop)
256  : m_SourceLine(SourceLine) {
257
258    ::byteToColumn(SourceLine, TabStop, m_byteToColumn);
259    ::columnToByte(SourceLine, TabStop, m_columnToByte);
260
261    assert(m_byteToColumn.size()==SourceLine.size()+1);
262    assert(0 < m_byteToColumn.size() && 0 < m_columnToByte.size());
263    assert(m_byteToColumn.size()
264           == static_cast<unsigned>(m_columnToByte.back()+1));
265    assert(static_cast<unsigned>(m_byteToColumn.back()+1)
266           == m_columnToByte.size());
267  }
268  int columns() const { return m_byteToColumn.back(); }
269  int bytes() const { return m_columnToByte.back(); }
270
271  /// \brief Map a byte to the column which it is at the start of, or return -1
272  /// if it is not at the start of a column (for a UTF-8 trailing byte).
273  int byteToColumn(int n) const {
274    assert(0<=n && n<static_cast<int>(m_byteToColumn.size()));
275    return m_byteToColumn[n];
276  }
277
278  /// \brief Map a byte to the first column which contains it.
279  int byteToContainingColumn(int N) const {
280    assert(0 <= N && N < static_cast<int>(m_byteToColumn.size()));
281    while (m_byteToColumn[N] == -1)
282      --N;
283    return m_byteToColumn[N];
284  }
285
286  /// \brief Map a column to the byte which starts the column, or return -1 if
287  /// the column the second or subsequent column of an expanded tab or similar
288  /// multi-column entity.
289  int columnToByte(int n) const {
290    assert(0<=n && n<static_cast<int>(m_columnToByte.size()));
291    return m_columnToByte[n];
292  }
293
294  /// \brief Map from a byte index to the next byte which starts a column.
295  int startOfNextColumn(int N) const {
296    assert(0 <= N && N < static_cast<int>(m_columnToByte.size() - 1));
297    while (byteToColumn(++N) == -1) {}
298    return N;
299  }
300
301  /// \brief Map from a byte index to the previous byte which starts a column.
302  int startOfPreviousColumn(int N) const {
303    assert(0 < N && N < static_cast<int>(m_columnToByte.size()));
304    while (byteToColumn(--N) == -1) {}
305    return N;
306  }
307
308  StringRef getSourceLine() const {
309    return m_SourceLine;
310  }
311
312private:
313  const std::string m_SourceLine;
314  SmallVector<int,200> m_byteToColumn;
315  SmallVector<int,200> m_columnToByte;
316};
317} // end anonymous namespace
318
319/// \brief When the source code line we want to print is too long for
320/// the terminal, select the "interesting" region.
321static void selectInterestingSourceRegion(std::string &SourceLine,
322                                          std::string &CaretLine,
323                                          std::string &FixItInsertionLine,
324                                          unsigned Columns,
325                                          const SourceColumnMap &map) {
326  unsigned MaxColumns = std::max<unsigned>(map.columns(),
327                                           std::max(CaretLine.size(),
328                                                    FixItInsertionLine.size()));
329  // if the number of columns is less than the desired number we're done
330  if (MaxColumns <= Columns)
331    return;
332
333  // No special characters are allowed in CaretLine.
334  assert(CaretLine.end() ==
335         std::find_if(CaretLine.begin(), CaretLine.end(),
336                      [](char c) { return c < ' ' || '~' < c; }));
337
338  // Find the slice that we need to display the full caret line
339  // correctly.
340  unsigned CaretStart = 0, CaretEnd = CaretLine.size();
341  for (; CaretStart != CaretEnd; ++CaretStart)
342    if (!isWhitespace(CaretLine[CaretStart]))
343      break;
344
345  for (; CaretEnd != CaretStart; --CaretEnd)
346    if (!isWhitespace(CaretLine[CaretEnd - 1]))
347      break;
348
349  // caret has already been inserted into CaretLine so the above whitespace
350  // check is guaranteed to include the caret
351
352  // If we have a fix-it line, make sure the slice includes all of the
353  // fix-it information.
354  if (!FixItInsertionLine.empty()) {
355    unsigned FixItStart = 0, FixItEnd = FixItInsertionLine.size();
356    for (; FixItStart != FixItEnd; ++FixItStart)
357      if (!isWhitespace(FixItInsertionLine[FixItStart]))
358        break;
359
360    for (; FixItEnd != FixItStart; --FixItEnd)
361      if (!isWhitespace(FixItInsertionLine[FixItEnd - 1]))
362        break;
363
364    // We can safely use the byte offset FixItStart as the column offset
365    // because the characters up until FixItStart are all ASCII whitespace
366    // characters.
367    unsigned FixItStartCol = FixItStart;
368    unsigned FixItEndCol
369      = llvm::sys::locale::columnWidth(FixItInsertionLine.substr(0, FixItEnd));
370
371    CaretStart = std::min(FixItStartCol, CaretStart);
372    CaretEnd = std::max(FixItEndCol, CaretEnd);
373  }
374
375  // CaretEnd may have been set at the middle of a character
376  // If it's not at a character's first column then advance it past the current
377  //   character.
378  while (static_cast<int>(CaretEnd) < map.columns() &&
379         -1 == map.columnToByte(CaretEnd))
380    ++CaretEnd;
381
382  assert((static_cast<int>(CaretStart) > map.columns() ||
383          -1!=map.columnToByte(CaretStart)) &&
384         "CaretStart must not point to a column in the middle of a source"
385         " line character");
386  assert((static_cast<int>(CaretEnd) > map.columns() ||
387          -1!=map.columnToByte(CaretEnd)) &&
388         "CaretEnd must not point to a column in the middle of a source line"
389         " character");
390
391  // CaretLine[CaretStart, CaretEnd) contains all of the interesting
392  // parts of the caret line. While this slice is smaller than the
393  // number of columns we have, try to grow the slice to encompass
394  // more context.
395
396  unsigned SourceStart = map.columnToByte(std::min<unsigned>(CaretStart,
397                                                             map.columns()));
398  unsigned SourceEnd = map.columnToByte(std::min<unsigned>(CaretEnd,
399                                                           map.columns()));
400
401  unsigned CaretColumnsOutsideSource = CaretEnd-CaretStart
402    - (map.byteToColumn(SourceEnd)-map.byteToColumn(SourceStart));
403
404  char const *front_ellipse = "  ...";
405  char const *front_space   = "     ";
406  char const *back_ellipse = "...";
407  unsigned ellipses_space = strlen(front_ellipse) + strlen(back_ellipse);
408
409  unsigned TargetColumns = Columns;
410  // Give us extra room for the ellipses
411  //  and any of the caret line that extends past the source
412  if (TargetColumns > ellipses_space+CaretColumnsOutsideSource)
413    TargetColumns -= ellipses_space+CaretColumnsOutsideSource;
414
415  while (SourceStart>0 || SourceEnd<SourceLine.size()) {
416    bool ExpandedRegion = false;
417
418    if (SourceStart>0) {
419      unsigned NewStart = map.startOfPreviousColumn(SourceStart);
420
421      // Skip over any whitespace we see here; we're looking for
422      // another bit of interesting text.
423      // FIXME: Detect non-ASCII whitespace characters too.
424      while (NewStart && isWhitespace(SourceLine[NewStart]))
425        NewStart = map.startOfPreviousColumn(NewStart);
426
427      // Skip over this bit of "interesting" text.
428      while (NewStart) {
429        unsigned Prev = map.startOfPreviousColumn(NewStart);
430        if (isWhitespace(SourceLine[Prev]))
431          break;
432        NewStart = Prev;
433      }
434
435      assert(map.byteToColumn(NewStart) != -1);
436      unsigned NewColumns = map.byteToColumn(SourceEnd) -
437                              map.byteToColumn(NewStart);
438      if (NewColumns <= TargetColumns) {
439        SourceStart = NewStart;
440        ExpandedRegion = true;
441      }
442    }
443
444    if (SourceEnd<SourceLine.size()) {
445      unsigned NewEnd = map.startOfNextColumn(SourceEnd);
446
447      // Skip over any whitespace we see here; we're looking for
448      // another bit of interesting text.
449      // FIXME: Detect non-ASCII whitespace characters too.
450      while (NewEnd < SourceLine.size() && isWhitespace(SourceLine[NewEnd]))
451        NewEnd = map.startOfNextColumn(NewEnd);
452
453      // Skip over this bit of "interesting" text.
454      while (NewEnd < SourceLine.size() && isWhitespace(SourceLine[NewEnd]))
455        NewEnd = map.startOfNextColumn(NewEnd);
456
457      assert(map.byteToColumn(NewEnd) != -1);
458      unsigned NewColumns = map.byteToColumn(NewEnd) -
459                              map.byteToColumn(SourceStart);
460      if (NewColumns <= TargetColumns) {
461        SourceEnd = NewEnd;
462        ExpandedRegion = true;
463      }
464    }
465
466    if (!ExpandedRegion)
467      break;
468  }
469
470  CaretStart = map.byteToColumn(SourceStart);
471  CaretEnd = map.byteToColumn(SourceEnd) + CaretColumnsOutsideSource;
472
473  // [CaretStart, CaretEnd) is the slice we want. Update the various
474  // output lines to show only this slice, with two-space padding
475  // before the lines so that it looks nicer.
476
477  assert(CaretStart!=(unsigned)-1 && CaretEnd!=(unsigned)-1 &&
478         SourceStart!=(unsigned)-1 && SourceEnd!=(unsigned)-1);
479  assert(SourceStart <= SourceEnd);
480  assert(CaretStart <= CaretEnd);
481
482  unsigned BackColumnsRemoved
483    = map.byteToColumn(SourceLine.size())-map.byteToColumn(SourceEnd);
484  unsigned FrontColumnsRemoved = CaretStart;
485  unsigned ColumnsKept = CaretEnd-CaretStart;
486
487  // We checked up front that the line needed truncation
488  assert(FrontColumnsRemoved+ColumnsKept+BackColumnsRemoved > Columns);
489
490  // The line needs some trunctiona, and we'd prefer to keep the front
491  //  if possible, so remove the back
492  if (BackColumnsRemoved > strlen(back_ellipse))
493    SourceLine.replace(SourceEnd, std::string::npos, back_ellipse);
494
495  // If that's enough then we're done
496  if (FrontColumnsRemoved+ColumnsKept <= Columns)
497    return;
498
499  // Otherwise remove the front as well
500  if (FrontColumnsRemoved > strlen(front_ellipse)) {
501    SourceLine.replace(0, SourceStart, front_ellipse);
502    CaretLine.replace(0, CaretStart, front_space);
503    if (!FixItInsertionLine.empty())
504      FixItInsertionLine.replace(0, CaretStart, front_space);
505  }
506}
507
508/// \brief Skip over whitespace in the string, starting at the given
509/// index.
510///
511/// \returns The index of the first non-whitespace character that is
512/// greater than or equal to Idx or, if no such character exists,
513/// returns the end of the string.
514static unsigned skipWhitespace(unsigned Idx, StringRef Str, unsigned Length) {
515  while (Idx < Length && isWhitespace(Str[Idx]))
516    ++Idx;
517  return Idx;
518}
519
520/// \brief If the given character is the start of some kind of
521/// balanced punctuation (e.g., quotes or parentheses), return the
522/// character that will terminate the punctuation.
523///
524/// \returns The ending punctuation character, if any, or the NULL
525/// character if the input character does not start any punctuation.
526static inline char findMatchingPunctuation(char c) {
527  switch (c) {
528  case '\'': return '\'';
529  case '`': return '\'';
530  case '"':  return '"';
531  case '(':  return ')';
532  case '[': return ']';
533  case '{': return '}';
534  default: break;
535  }
536
537  return 0;
538}
539
540/// \brief Find the end of the word starting at the given offset
541/// within a string.
542///
543/// \returns the index pointing one character past the end of the
544/// word.
545static unsigned findEndOfWord(unsigned Start, StringRef Str,
546                              unsigned Length, unsigned Column,
547                              unsigned Columns) {
548  assert(Start < Str.size() && "Invalid start position!");
549  unsigned End = Start + 1;
550
551  // If we are already at the end of the string, take that as the word.
552  if (End == Str.size())
553    return End;
554
555  // Determine if the start of the string is actually opening
556  // punctuation, e.g., a quote or parentheses.
557  char EndPunct = findMatchingPunctuation(Str[Start]);
558  if (!EndPunct) {
559    // This is a normal word. Just find the first space character.
560    while (End < Length && !isWhitespace(Str[End]))
561      ++End;
562    return End;
563  }
564
565  // We have the start of a balanced punctuation sequence (quotes,
566  // parentheses, etc.). Determine the full sequence is.
567  SmallString<16> PunctuationEndStack;
568  PunctuationEndStack.push_back(EndPunct);
569  while (End < Length && !PunctuationEndStack.empty()) {
570    if (Str[End] == PunctuationEndStack.back())
571      PunctuationEndStack.pop_back();
572    else if (char SubEndPunct = findMatchingPunctuation(Str[End]))
573      PunctuationEndStack.push_back(SubEndPunct);
574
575    ++End;
576  }
577
578  // Find the first space character after the punctuation ended.
579  while (End < Length && !isWhitespace(Str[End]))
580    ++End;
581
582  unsigned PunctWordLength = End - Start;
583  if (// If the word fits on this line
584      Column + PunctWordLength <= Columns ||
585      // ... or the word is "short enough" to take up the next line
586      // without too much ugly white space
587      PunctWordLength < Columns/3)
588    return End; // Take the whole thing as a single "word".
589
590  // The whole quoted/parenthesized string is too long to print as a
591  // single "word". Instead, find the "word" that starts just after
592  // the punctuation and use that end-point instead. This will recurse
593  // until it finds something small enough to consider a word.
594  return findEndOfWord(Start + 1, Str, Length, Column + 1, Columns);
595}
596
597/// \brief Print the given string to a stream, word-wrapping it to
598/// some number of columns in the process.
599///
600/// \param OS the stream to which the word-wrapping string will be
601/// emitted.
602/// \param Str the string to word-wrap and output.
603/// \param Columns the number of columns to word-wrap to.
604/// \param Column the column number at which the first character of \p
605/// Str will be printed. This will be non-zero when part of the first
606/// line has already been printed.
607/// \param Bold if the current text should be bold
608/// \param Indentation the number of spaces to indent any lines beyond
609/// the first line.
610/// \returns true if word-wrapping was required, or false if the
611/// string fit on the first line.
612static bool printWordWrapped(raw_ostream &OS, StringRef Str,
613                             unsigned Columns,
614                             unsigned Column = 0,
615                             bool Bold = false,
616                             unsigned Indentation = WordWrapIndentation) {
617  const unsigned Length = std::min(Str.find('\n'), Str.size());
618  bool TextNormal = true;
619
620  // The string used to indent each line.
621  SmallString<16> IndentStr;
622  IndentStr.assign(Indentation, ' ');
623  bool Wrapped = false;
624  for (unsigned WordStart = 0, WordEnd; WordStart < Length;
625       WordStart = WordEnd) {
626    // Find the beginning of the next word.
627    WordStart = skipWhitespace(WordStart, Str, Length);
628    if (WordStart == Length)
629      break;
630
631    // Find the end of this word.
632    WordEnd = findEndOfWord(WordStart, Str, Length, Column, Columns);
633
634    // Does this word fit on the current line?
635    unsigned WordLength = WordEnd - WordStart;
636    if (Column + WordLength < Columns) {
637      // This word fits on the current line; print it there.
638      if (WordStart) {
639        OS << ' ';
640        Column += 1;
641      }
642      applyTemplateHighlighting(OS, Str.substr(WordStart, WordLength),
643                                TextNormal, Bold);
644      Column += WordLength;
645      continue;
646    }
647
648    // This word does not fit on the current line, so wrap to the next
649    // line.
650    OS << '\n';
651    OS.write(&IndentStr[0], Indentation);
652    applyTemplateHighlighting(OS, Str.substr(WordStart, WordLength),
653                              TextNormal, Bold);
654    Column = Indentation + WordLength;
655    Wrapped = true;
656  }
657
658  // Append any remaning text from the message with its existing formatting.
659  applyTemplateHighlighting(OS, Str.substr(Length), TextNormal, Bold);
660
661  assert(TextNormal && "Text highlighted at end of diagnostic message.");
662
663  return Wrapped;
664}
665
666TextDiagnostic::TextDiagnostic(raw_ostream &OS,
667                               const LangOptions &LangOpts,
668                               DiagnosticOptions *DiagOpts)
669  : DiagnosticRenderer(LangOpts, DiagOpts), OS(OS) {}
670
671TextDiagnostic::~TextDiagnostic() {}
672
673void
674TextDiagnostic::emitDiagnosticMessage(SourceLocation Loc,
675                                      PresumedLoc PLoc,
676                                      DiagnosticsEngine::Level Level,
677                                      StringRef Message,
678                                      ArrayRef<clang::CharSourceRange> Ranges,
679                                      const SourceManager *SM,
680                                      DiagOrStoredDiag D) {
681  uint64_t StartOfLocationInfo = OS.tell();
682
683  // Emit the location of this particular diagnostic.
684  if (Loc.isValid())
685    emitDiagnosticLoc(Loc, PLoc, Level, Ranges, *SM);
686
687  if (DiagOpts->ShowColors)
688    OS.resetColor();
689
690  printDiagnosticLevel(OS, Level, DiagOpts->ShowColors,
691                       DiagOpts->CLFallbackMode);
692  printDiagnosticMessage(OS,
693                         /*IsSupplemental*/ Level == DiagnosticsEngine::Note,
694                         Message, OS.tell() - StartOfLocationInfo,
695                         DiagOpts->MessageLength, DiagOpts->ShowColors);
696}
697
698/*static*/ void
699TextDiagnostic::printDiagnosticLevel(raw_ostream &OS,
700                                     DiagnosticsEngine::Level Level,
701                                     bool ShowColors,
702                                     bool CLFallbackMode) {
703  if (ShowColors) {
704    // Print diagnostic category in bold and color
705    switch (Level) {
706    case DiagnosticsEngine::Ignored:
707      llvm_unreachable("Invalid diagnostic type");
708    case DiagnosticsEngine::Note:    OS.changeColor(noteColor, true); break;
709    case DiagnosticsEngine::Remark:  OS.changeColor(remarkColor, true); break;
710    case DiagnosticsEngine::Warning: OS.changeColor(warningColor, true); break;
711    case DiagnosticsEngine::Error:   OS.changeColor(errorColor, true); break;
712    case DiagnosticsEngine::Fatal:   OS.changeColor(fatalColor, true); break;
713    }
714  }
715
716  switch (Level) {
717  case DiagnosticsEngine::Ignored:
718    llvm_unreachable("Invalid diagnostic type");
719  case DiagnosticsEngine::Note:    OS << "note"; break;
720  case DiagnosticsEngine::Remark:  OS << "remark"; break;
721  case DiagnosticsEngine::Warning: OS << "warning"; break;
722  case DiagnosticsEngine::Error:   OS << "error"; break;
723  case DiagnosticsEngine::Fatal:   OS << "fatal error"; break;
724  }
725
726  // In clang-cl /fallback mode, print diagnostics as "error(clang):". This
727  // makes it more clear whether a message is coming from clang or cl.exe,
728  // and it prevents MSBuild from concluding that the build failed just because
729  // there is an "error:" in the output.
730  if (CLFallbackMode)
731    OS << "(clang)";
732
733  OS << ": ";
734
735  if (ShowColors)
736    OS.resetColor();
737}
738
739/*static*/
740void TextDiagnostic::printDiagnosticMessage(raw_ostream &OS,
741                                            bool IsSupplemental,
742                                            StringRef Message,
743                                            unsigned CurrentColumn,
744                                            unsigned Columns, bool ShowColors) {
745  bool Bold = false;
746  if (ShowColors && !IsSupplemental) {
747    // Print primary diagnostic messages in bold and without color, to visually
748    // indicate the transition from continuation notes and other output.
749    OS.changeColor(savedColor, true);
750    Bold = true;
751  }
752
753  if (Columns)
754    printWordWrapped(OS, Message, Columns, CurrentColumn, Bold);
755  else {
756    bool Normal = true;
757    applyTemplateHighlighting(OS, Message, Normal, Bold);
758    assert(Normal && "Formatting should have returned to normal");
759  }
760
761  if (ShowColors)
762    OS.resetColor();
763  OS << '\n';
764}
765
766/// \brief Print out the file/line/column information and include trace.
767///
768/// This method handlen the emission of the diagnostic location information.
769/// This includes extracting as much location information as is present for
770/// the diagnostic and printing it, as well as any include stack or source
771/// ranges necessary.
772void TextDiagnostic::emitDiagnosticLoc(SourceLocation Loc, PresumedLoc PLoc,
773                                       DiagnosticsEngine::Level Level,
774                                       ArrayRef<CharSourceRange> Ranges,
775                                       const SourceManager &SM) {
776  if (PLoc.isInvalid()) {
777    // At least print the file name if available:
778    FileID FID = SM.getFileID(Loc);
779    if (!FID.isInvalid()) {
780      const FileEntry* FE = SM.getFileEntryForID(FID);
781      if (FE && FE->isValid()) {
782        OS << FE->getName();
783        if (FE->isInPCH())
784          OS << " (in PCH)";
785        OS << ": ";
786      }
787    }
788    return;
789  }
790  unsigned LineNo = PLoc.getLine();
791
792  if (!DiagOpts->ShowLocation)
793    return;
794
795  if (DiagOpts->ShowColors)
796    OS.changeColor(savedColor, true);
797
798  OS << PLoc.getFilename();
799  switch (DiagOpts->getFormat()) {
800  case DiagnosticOptions::Clang: OS << ':'  << LineNo; break;
801  case DiagnosticOptions::Msvc:  OS << '('  << LineNo; break;
802  case DiagnosticOptions::Vi:    OS << " +" << LineNo; break;
803  }
804
805  if (DiagOpts->ShowColumn)
806    // Compute the column number.
807    if (unsigned ColNo = PLoc.getColumn()) {
808      if (DiagOpts->getFormat() == DiagnosticOptions::Msvc) {
809        OS << ',';
810        // Visual Studio 2010 or earlier expects column number to be off by one
811        if (LangOpts.MSCVersion && LangOpts.MSCVersion < 170000000)
812          ColNo--;
813      } else
814        OS << ':';
815      OS << ColNo;
816    }
817  switch (DiagOpts->getFormat()) {
818  case DiagnosticOptions::Clang:
819  case DiagnosticOptions::Vi:    OS << ':';    break;
820  case DiagnosticOptions::Msvc:  OS << ") : "; break;
821  }
822
823  if (DiagOpts->ShowSourceRanges && !Ranges.empty()) {
824    FileID CaretFileID =
825      SM.getFileID(SM.getExpansionLoc(Loc));
826    bool PrintedRange = false;
827
828    for (ArrayRef<CharSourceRange>::const_iterator RI = Ranges.begin(),
829         RE = Ranges.end();
830         RI != RE; ++RI) {
831      // Ignore invalid ranges.
832      if (!RI->isValid()) continue;
833
834      SourceLocation B = SM.getExpansionLoc(RI->getBegin());
835      SourceLocation E = SM.getExpansionLoc(RI->getEnd());
836
837      // If the End location and the start location are the same and are a
838      // macro location, then the range was something that came from a
839      // macro expansion or _Pragma.  If this is an object-like macro, the
840      // best we can do is to highlight the range.  If this is a
841      // function-like macro, we'd also like to highlight the arguments.
842      if (B == E && RI->getEnd().isMacroID())
843        E = SM.getExpansionRange(RI->getEnd()).second;
844
845      std::pair<FileID, unsigned> BInfo = SM.getDecomposedLoc(B);
846      std::pair<FileID, unsigned> EInfo = SM.getDecomposedLoc(E);
847
848      // If the start or end of the range is in another file, just discard
849      // it.
850      if (BInfo.first != CaretFileID || EInfo.first != CaretFileID)
851        continue;
852
853      // Add in the length of the token, so that we cover multi-char
854      // tokens.
855      unsigned TokSize = 0;
856      if (RI->isTokenRange())
857        TokSize = Lexer::MeasureTokenLength(E, SM, LangOpts);
858
859      OS << '{' << SM.getLineNumber(BInfo.first, BInfo.second) << ':'
860        << SM.getColumnNumber(BInfo.first, BInfo.second) << '-'
861        << SM.getLineNumber(EInfo.first, EInfo.second) << ':'
862        << (SM.getColumnNumber(EInfo.first, EInfo.second)+TokSize)
863        << '}';
864      PrintedRange = true;
865    }
866
867    if (PrintedRange)
868      OS << ':';
869  }
870  OS << ' ';
871}
872
873void TextDiagnostic::emitIncludeLocation(SourceLocation Loc,
874                                         PresumedLoc PLoc,
875                                         const SourceManager &SM) {
876  if (DiagOpts->ShowLocation)
877    OS << "In file included from " << PLoc.getFilename() << ':'
878       << PLoc.getLine() << ":\n";
879  else
880    OS << "In included file:\n";
881}
882
883void TextDiagnostic::emitImportLocation(SourceLocation Loc, PresumedLoc PLoc,
884                                        StringRef ModuleName,
885                                        const SourceManager &SM) {
886  if (DiagOpts->ShowLocation)
887    OS << "In module '" << ModuleName << "' imported from "
888       << PLoc.getFilename() << ':' << PLoc.getLine() << ":\n";
889  else
890    OS << "In module " << ModuleName << "':\n";
891}
892
893void TextDiagnostic::emitBuildingModuleLocation(SourceLocation Loc,
894                                                PresumedLoc PLoc,
895                                                StringRef ModuleName,
896                                                const SourceManager &SM) {
897  if (DiagOpts->ShowLocation && PLoc.getFilename())
898    OS << "While building module '" << ModuleName << "' imported from "
899      << PLoc.getFilename() << ':' << PLoc.getLine() << ":\n";
900  else
901    OS << "While building module '" << ModuleName << "':\n";
902}
903
904/// \brief Highlight a SourceRange (with ~'s) for any characters on LineNo.
905static void highlightRange(const CharSourceRange &R,
906                           unsigned LineNo, FileID FID,
907                           const SourceColumnMap &map,
908                           std::string &CaretLine,
909                           const SourceManager &SM,
910                           const LangOptions &LangOpts) {
911  if (!R.isValid()) return;
912
913  SourceLocation Begin = R.getBegin();
914  SourceLocation End = R.getEnd();
915
916  unsigned StartLineNo = SM.getExpansionLineNumber(Begin);
917  if (StartLineNo > LineNo || SM.getFileID(Begin) != FID)
918    return;  // No intersection.
919
920  unsigned EndLineNo = SM.getExpansionLineNumber(End);
921  if (EndLineNo < LineNo || SM.getFileID(End) != FID)
922    return;  // No intersection.
923
924  // Compute the column number of the start.
925  unsigned StartColNo = 0;
926  if (StartLineNo == LineNo) {
927    StartColNo = SM.getExpansionColumnNumber(Begin);
928    if (StartColNo) --StartColNo;  // Zero base the col #.
929  }
930
931  // Compute the column number of the end.
932  unsigned EndColNo = map.getSourceLine().size();
933  if (EndLineNo == LineNo) {
934    EndColNo = SM.getExpansionColumnNumber(End);
935    if (EndColNo) {
936      --EndColNo;  // Zero base the col #.
937
938      // Add in the length of the token, so that we cover multi-char tokens if
939      // this is a token range.
940      if (R.isTokenRange())
941        EndColNo += Lexer::MeasureTokenLength(End, SM, LangOpts);
942    } else {
943      EndColNo = CaretLine.size();
944    }
945  }
946
947  assert(StartColNo <= EndColNo && "Invalid range!");
948
949  // Check that a token range does not highlight only whitespace.
950  if (R.isTokenRange()) {
951    // Pick the first non-whitespace column.
952    while (StartColNo < map.getSourceLine().size() &&
953           (map.getSourceLine()[StartColNo] == ' ' ||
954            map.getSourceLine()[StartColNo] == '\t'))
955      StartColNo = map.startOfNextColumn(StartColNo);
956
957    // Pick the last non-whitespace column.
958    if (EndColNo > map.getSourceLine().size())
959      EndColNo = map.getSourceLine().size();
960    while (EndColNo &&
961           (map.getSourceLine()[EndColNo-1] == ' ' ||
962            map.getSourceLine()[EndColNo-1] == '\t'))
963      EndColNo = map.startOfPreviousColumn(EndColNo);
964
965    // If the start/end passed each other, then we are trying to highlight a
966    // range that just exists in whitespace, which must be some sort of other
967    // bug.
968    assert(StartColNo <= EndColNo && "Trying to highlight whitespace??");
969  }
970
971  assert(StartColNo <= map.getSourceLine().size() && "Invalid range!");
972  assert(EndColNo <= map.getSourceLine().size() && "Invalid range!");
973
974  // Fill the range with ~'s.
975  StartColNo = map.byteToContainingColumn(StartColNo);
976  EndColNo = map.byteToContainingColumn(EndColNo);
977
978  assert(StartColNo <= EndColNo && "Invalid range!");
979  if (CaretLine.size() < EndColNo)
980    CaretLine.resize(EndColNo,' ');
981  std::fill(CaretLine.begin()+StartColNo,CaretLine.begin()+EndColNo,'~');
982}
983
984static std::string buildFixItInsertionLine(unsigned LineNo,
985                                           const SourceColumnMap &map,
986                                           ArrayRef<FixItHint> Hints,
987                                           const SourceManager &SM,
988                                           const DiagnosticOptions *DiagOpts) {
989  std::string FixItInsertionLine;
990  if (Hints.empty() || !DiagOpts->ShowFixits)
991    return FixItInsertionLine;
992  unsigned PrevHintEndCol = 0;
993
994  for (ArrayRef<FixItHint>::iterator I = Hints.begin(), E = Hints.end();
995       I != E; ++I) {
996    if (!I->CodeToInsert.empty()) {
997      // We have an insertion hint. Determine whether the inserted
998      // code contains no newlines and is on the same line as the caret.
999      std::pair<FileID, unsigned> HintLocInfo
1000        = SM.getDecomposedExpansionLoc(I->RemoveRange.getBegin());
1001      if (LineNo == SM.getLineNumber(HintLocInfo.first, HintLocInfo.second) &&
1002          StringRef(I->CodeToInsert).find_first_of("\n\r") == StringRef::npos) {
1003        // Insert the new code into the line just below the code
1004        // that the user wrote.
1005        // Note: When modifying this function, be very careful about what is a
1006        // "column" (printed width, platform-dependent) and what is a
1007        // "byte offset" (SourceManager "column").
1008        unsigned HintByteOffset
1009          = SM.getColumnNumber(HintLocInfo.first, HintLocInfo.second) - 1;
1010
1011        // The hint must start inside the source or right at the end
1012        assert(HintByteOffset < static_cast<unsigned>(map.bytes())+1);
1013        unsigned HintCol = map.byteToContainingColumn(HintByteOffset);
1014
1015        // If we inserted a long previous hint, push this one forwards, and add
1016        // an extra space to show that this is not part of the previous
1017        // completion. This is sort of the best we can do when two hints appear
1018        // to overlap.
1019        //
1020        // Note that if this hint is located immediately after the previous
1021        // hint, no space will be added, since the location is more important.
1022        if (HintCol < PrevHintEndCol)
1023          HintCol = PrevHintEndCol + 1;
1024
1025        // This should NOT use HintByteOffset, because the source might have
1026        // Unicode characters in earlier columns.
1027        unsigned NewFixItLineSize = FixItInsertionLine.size() +
1028          (HintCol - PrevHintEndCol) + I->CodeToInsert.size();
1029        if (NewFixItLineSize > FixItInsertionLine.size())
1030          FixItInsertionLine.resize(NewFixItLineSize, ' ');
1031
1032        std::copy(I->CodeToInsert.begin(), I->CodeToInsert.end(),
1033                  FixItInsertionLine.end() - I->CodeToInsert.size());
1034
1035        PrevHintEndCol =
1036          HintCol + llvm::sys::locale::columnWidth(I->CodeToInsert);
1037      } else {
1038        FixItInsertionLine.clear();
1039        break;
1040      }
1041    }
1042  }
1043
1044  expandTabs(FixItInsertionLine, DiagOpts->TabStop);
1045
1046  return FixItInsertionLine;
1047}
1048
1049/// \brief Emit a code snippet and caret line.
1050///
1051/// This routine emits a single line's code snippet and caret line..
1052///
1053/// \param Loc The location for the caret.
1054/// \param Ranges The underlined ranges for this code snippet.
1055/// \param Hints The FixIt hints active for this diagnostic.
1056void TextDiagnostic::emitSnippetAndCaret(
1057    SourceLocation Loc, DiagnosticsEngine::Level Level,
1058    SmallVectorImpl<CharSourceRange>& Ranges,
1059    ArrayRef<FixItHint> Hints,
1060    const SourceManager &SM) {
1061  assert(!Loc.isInvalid() && "must have a valid source location here");
1062  assert(Loc.isFileID() && "must have a file location here");
1063
1064  // If caret diagnostics are enabled and we have location, we want to
1065  // emit the caret.  However, we only do this if the location moved
1066  // from the last diagnostic, if the last diagnostic was a note that
1067  // was part of a different warning or error diagnostic, or if the
1068  // diagnostic has ranges.  We don't want to emit the same caret
1069  // multiple times if one loc has multiple diagnostics.
1070  if (!DiagOpts->ShowCarets)
1071    return;
1072  if (Loc == LastLoc && Ranges.empty() && Hints.empty() &&
1073      (LastLevel != DiagnosticsEngine::Note || Level == LastLevel))
1074    return;
1075
1076  // Decompose the location into a FID/Offset pair.
1077  std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(Loc);
1078  FileID FID = LocInfo.first;
1079  unsigned FileOffset = LocInfo.second;
1080
1081  // Get information about the buffer it points into.
1082  bool Invalid = false;
1083  const char *BufStart = SM.getBufferData(FID, &Invalid).data();
1084  if (Invalid)
1085    return;
1086
1087  unsigned LineNo = SM.getLineNumber(FID, FileOffset);
1088  unsigned ColNo = SM.getColumnNumber(FID, FileOffset);
1089
1090  // Arbitrarily stop showing snippets when the line is too long.
1091  static const size_t MaxLineLengthToPrint = 4096;
1092  if (ColNo > MaxLineLengthToPrint)
1093    return;
1094
1095  // Rewind from the current position to the start of the line.
1096  const char *TokPtr = BufStart+FileOffset;
1097  const char *LineStart = TokPtr-ColNo+1; // Column # is 1-based.
1098
1099  // Compute the line end.  Scan forward from the error position to the end of
1100  // the line.
1101  const char *LineEnd = TokPtr;
1102  while (*LineEnd != '\n' && *LineEnd != '\r' && *LineEnd != '\0')
1103    ++LineEnd;
1104
1105  // Arbitrarily stop showing snippets when the line is too long.
1106  if (size_t(LineEnd - LineStart) > MaxLineLengthToPrint)
1107    return;
1108
1109  // Copy the line of code into an std::string for ease of manipulation.
1110  std::string SourceLine(LineStart, LineEnd);
1111
1112  // Create a line for the caret that is filled with spaces that is the same
1113  // length as the line of source code.
1114  std::string CaretLine(LineEnd-LineStart, ' ');
1115
1116  const SourceColumnMap sourceColMap(SourceLine, DiagOpts->TabStop);
1117
1118  // Highlight all of the characters covered by Ranges with ~ characters.
1119  for (SmallVectorImpl<CharSourceRange>::iterator I = Ranges.begin(),
1120                                                  E = Ranges.end();
1121       I != E; ++I)
1122    highlightRange(*I, LineNo, FID, sourceColMap, CaretLine, SM, LangOpts);
1123
1124  // Next, insert the caret itself.
1125  ColNo = sourceColMap.byteToContainingColumn(ColNo-1);
1126  if (CaretLine.size()<ColNo+1)
1127    CaretLine.resize(ColNo+1, ' ');
1128  CaretLine[ColNo] = '^';
1129
1130  std::string FixItInsertionLine = buildFixItInsertionLine(LineNo,
1131                                                           sourceColMap,
1132                                                           Hints, SM,
1133                                                           DiagOpts.get());
1134
1135  // If the source line is too long for our terminal, select only the
1136  // "interesting" source region within that line.
1137  unsigned Columns = DiagOpts->MessageLength;
1138  if (Columns)
1139    selectInterestingSourceRegion(SourceLine, CaretLine, FixItInsertionLine,
1140                                  Columns, sourceColMap);
1141
1142  // If we are in -fdiagnostics-print-source-range-info mode, we are trying
1143  // to produce easily machine parsable output.  Add a space before the
1144  // source line and the caret to make it trivial to tell the main diagnostic
1145  // line from what the user is intended to see.
1146  if (DiagOpts->ShowSourceRanges) {
1147    SourceLine = ' ' + SourceLine;
1148    CaretLine = ' ' + CaretLine;
1149  }
1150
1151  // Finally, remove any blank spaces from the end of CaretLine.
1152  while (CaretLine[CaretLine.size()-1] == ' ')
1153    CaretLine.erase(CaretLine.end()-1);
1154
1155  // Emit what we have computed.
1156  emitSnippet(SourceLine);
1157
1158  if (DiagOpts->ShowColors)
1159    OS.changeColor(caretColor, true);
1160  OS << CaretLine << '\n';
1161  if (DiagOpts->ShowColors)
1162    OS.resetColor();
1163
1164  if (!FixItInsertionLine.empty()) {
1165    if (DiagOpts->ShowColors)
1166      // Print fixit line in color
1167      OS.changeColor(fixitColor, false);
1168    if (DiagOpts->ShowSourceRanges)
1169      OS << ' ';
1170    OS << FixItInsertionLine << '\n';
1171    if (DiagOpts->ShowColors)
1172      OS.resetColor();
1173  }
1174
1175  // Print out any parseable fixit information requested by the options.
1176  emitParseableFixits(Hints, SM);
1177}
1178
1179void TextDiagnostic::emitSnippet(StringRef line) {
1180  if (line.empty())
1181    return;
1182
1183  size_t i = 0;
1184
1185  std::string to_print;
1186  bool print_reversed = false;
1187
1188  while (i<line.size()) {
1189    std::pair<SmallString<16>,bool> res
1190        = printableTextForNextCharacter(line, &i, DiagOpts->TabStop);
1191    bool was_printable = res.second;
1192
1193    if (DiagOpts->ShowColors && was_printable == print_reversed) {
1194      if (print_reversed)
1195        OS.reverseColor();
1196      OS << to_print;
1197      to_print.clear();
1198      if (DiagOpts->ShowColors)
1199        OS.resetColor();
1200    }
1201
1202    print_reversed = !was_printable;
1203    to_print += res.first.str();
1204  }
1205
1206  if (print_reversed && DiagOpts->ShowColors)
1207    OS.reverseColor();
1208  OS << to_print;
1209  if (print_reversed && DiagOpts->ShowColors)
1210    OS.resetColor();
1211
1212  OS << '\n';
1213}
1214
1215void TextDiagnostic::emitParseableFixits(ArrayRef<FixItHint> Hints,
1216                                         const SourceManager &SM) {
1217  if (!DiagOpts->ShowParseableFixits)
1218    return;
1219
1220  // We follow FixItRewriter's example in not (yet) handling
1221  // fix-its in macros.
1222  for (ArrayRef<FixItHint>::iterator I = Hints.begin(), E = Hints.end();
1223       I != E; ++I) {
1224    if (I->RemoveRange.isInvalid() ||
1225        I->RemoveRange.getBegin().isMacroID() ||
1226        I->RemoveRange.getEnd().isMacroID())
1227      return;
1228  }
1229
1230  for (ArrayRef<FixItHint>::iterator I = Hints.begin(), E = Hints.end();
1231       I != E; ++I) {
1232    SourceLocation BLoc = I->RemoveRange.getBegin();
1233    SourceLocation ELoc = I->RemoveRange.getEnd();
1234
1235    std::pair<FileID, unsigned> BInfo = SM.getDecomposedLoc(BLoc);
1236    std::pair<FileID, unsigned> EInfo = SM.getDecomposedLoc(ELoc);
1237
1238    // Adjust for token ranges.
1239    if (I->RemoveRange.isTokenRange())
1240      EInfo.second += Lexer::MeasureTokenLength(ELoc, SM, LangOpts);
1241
1242    // We specifically do not do word-wrapping or tab-expansion here,
1243    // because this is supposed to be easy to parse.
1244    PresumedLoc PLoc = SM.getPresumedLoc(BLoc);
1245    if (PLoc.isInvalid())
1246      break;
1247
1248    OS << "fix-it:\"";
1249    OS.write_escaped(PLoc.getFilename());
1250    OS << "\":{" << SM.getLineNumber(BInfo.first, BInfo.second)
1251      << ':' << SM.getColumnNumber(BInfo.first, BInfo.second)
1252      << '-' << SM.getLineNumber(EInfo.first, EInfo.second)
1253      << ':' << SM.getColumnNumber(EInfo.first, EInfo.second)
1254      << "}:\"";
1255    OS.write_escaped(I->CodeToInsert);
1256    OS << "\"\n";
1257  }
1258}
1259