2011-10-16 07:43:53 +08:00
|
|
|
//===--- TextDiagnostic.cpp - Text Diagnostic Pretty-Printing -------------===//
|
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2011-10-16 07:43:53 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "clang/Frontend/TextDiagnostic.h"
|
2013-02-09 06:30:41 +08:00
|
|
|
#include "clang/Basic/CharInfo.h"
|
2012-10-24 06:26:28 +08:00
|
|
|
#include "clang/Basic/DiagnosticOptions.h"
|
2012-12-04 17:13:33 +08:00
|
|
|
#include "clang/Basic/FileManager.h"
|
|
|
|
#include "clang/Basic/SourceManager.h"
|
2011-10-16 07:43:53 +08:00
|
|
|
#include "clang/Lex/Lexer.h"
|
|
|
|
#include "llvm/ADT/SmallString.h"
|
2012-04-18 10:44:46 +08:00
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2013-01-30 20:06:08 +08:00
|
|
|
#include "llvm/Support/ConvertUTF.h"
|
2012-12-04 17:13:33 +08:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
#include "llvm/Support/Locale.h"
|
2016-08-26 23:45:36 +08:00
|
|
|
#include "llvm/Support/Path.h"
|
2012-12-04 17:13:33 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2011-10-16 07:43:53 +08:00
|
|
|
#include <algorithm>
|
2012-04-18 10:44:46 +08:00
|
|
|
|
2011-10-16 07:43:53 +08:00
|
|
|
using namespace clang;
|
|
|
|
|
2019-08-02 15:22:34 +08:00
|
|
|
static const enum raw_ostream::Colors noteColor =
|
|
|
|
raw_ostream::BLACK;
|
|
|
|
static const enum raw_ostream::Colors remarkColor =
|
|
|
|
raw_ostream::BLUE;
|
|
|
|
static const enum raw_ostream::Colors fixitColor =
|
|
|
|
raw_ostream::GREEN;
|
|
|
|
static const enum raw_ostream::Colors caretColor =
|
|
|
|
raw_ostream::GREEN;
|
|
|
|
static const enum raw_ostream::Colors warningColor =
|
|
|
|
raw_ostream::MAGENTA;
|
|
|
|
static const enum raw_ostream::Colors templateColor =
|
|
|
|
raw_ostream::CYAN;
|
|
|
|
static const enum raw_ostream::Colors errorColor = raw_ostream::RED;
|
|
|
|
static const enum raw_ostream::Colors fatalColor = raw_ostream::RED;
|
2011-10-16 07:43:53 +08:00
|
|
|
// Used for changing only the bold attribute.
|
2019-08-02 15:22:34 +08:00
|
|
|
static const enum raw_ostream::Colors savedColor =
|
|
|
|
raw_ostream::SAVEDCOLOR;
|
2011-10-16 07:43:53 +08:00
|
|
|
|
2018-05-09 09:00:01 +08:00
|
|
|
/// Add highlights to differences in template strings.
|
2012-06-27 02:18:47 +08:00
|
|
|
static void applyTemplateHighlighting(raw_ostream &OS, StringRef Str,
|
2012-06-29 06:39:03 +08:00
|
|
|
bool &Normal, bool Bold) {
|
2022-01-09 16:19:47 +08:00
|
|
|
while (true) {
|
2012-10-19 04:09:54 +08:00
|
|
|
size_t Pos = Str.find(ToggleHighlight);
|
|
|
|
OS << Str.slice(0, Pos);
|
|
|
|
if (Pos == StringRef::npos)
|
|
|
|
break;
|
|
|
|
|
|
|
|
Str = Str.substr(Pos + 1);
|
|
|
|
if (Normal)
|
|
|
|
OS.changeColor(templateColor, true);
|
|
|
|
else {
|
|
|
|
OS.resetColor();
|
|
|
|
if (Bold)
|
|
|
|
OS.changeColor(savedColor, true);
|
2012-06-27 02:18:47 +08:00
|
|
|
}
|
2012-10-19 04:09:54 +08:00
|
|
|
Normal = !Normal;
|
|
|
|
}
|
2012-06-27 02:18:47 +08:00
|
|
|
}
|
|
|
|
|
2018-05-09 09:00:01 +08:00
|
|
|
/// Number of spaces to indent when word-wrapping.
|
2011-10-16 07:43:53 +08:00
|
|
|
const unsigned WordWrapIndentation = 6;
|
|
|
|
|
2012-05-01 22:34:11 +08:00
|
|
|
static int bytesSincePreviousTabOrLineBegin(StringRef SourceLine, size_t i) {
|
2012-04-18 10:44:46 +08:00
|
|
|
int bytes = 0;
|
|
|
|
while (0<i) {
|
|
|
|
if (SourceLine[--i]=='\t')
|
|
|
|
break;
|
|
|
|
++bytes;
|
|
|
|
}
|
|
|
|
return bytes;
|
|
|
|
}
|
|
|
|
|
2018-05-09 09:00:01 +08:00
|
|
|
/// returns a printable representation of first item from input range
|
2012-04-18 10:44:46 +08:00
|
|
|
///
|
|
|
|
/// This function returns a printable representation of the next item in a line
|
|
|
|
/// of source. If the next byte begins a valid and printable character, that
|
|
|
|
/// character is returned along with 'true'.
|
|
|
|
///
|
|
|
|
/// Otherwise, if the next byte begins a valid, but unprintable character, a
|
|
|
|
/// printable, escaped representation of the character is returned, along with
|
|
|
|
/// 'false'. Otherwise a printable, escaped representation of the next byte
|
|
|
|
/// is returned along with 'false'.
|
|
|
|
///
|
|
|
|
/// \note The index is updated to be used with a subsequent call to
|
|
|
|
/// printableTextForNextCharacter.
|
|
|
|
///
|
|
|
|
/// \param SourceLine The line of source
|
|
|
|
/// \param i Pointer to byte index,
|
|
|
|
/// \param TabStop used to expand tabs
|
2012-09-27 18:16:10 +08:00
|
|
|
/// \return pair(printable text, 'true' iff original text was printable)
|
2012-04-18 10:44:46 +08:00
|
|
|
///
|
2012-05-01 22:34:11 +08:00
|
|
|
static std::pair<SmallString<16>, bool>
|
2012-04-18 10:44:46 +08:00
|
|
|
printableTextForNextCharacter(StringRef SourceLine, size_t *i,
|
|
|
|
unsigned TabStop) {
|
|
|
|
assert(i && "i must not be null");
|
|
|
|
assert(*i<SourceLine.size() && "must point to a valid index");
|
2018-07-31 03:24:48 +08:00
|
|
|
|
2012-04-18 10:44:46 +08:00
|
|
|
if (SourceLine[*i]=='\t') {
|
|
|
|
assert(0 < TabStop && TabStop <= DiagnosticOptions::MaxTabStop &&
|
|
|
|
"Invalid -ftabstop value");
|
|
|
|
unsigned col = bytesSincePreviousTabOrLineBegin(SourceLine, *i);
|
|
|
|
unsigned NumSpaces = TabStop - col%TabStop;
|
|
|
|
assert(0 < NumSpaces && NumSpaces <= TabStop
|
|
|
|
&& "Invalid computation of space amt");
|
|
|
|
++(*i);
|
|
|
|
|
|
|
|
SmallString<16> expandedTab;
|
|
|
|
expandedTab.assign(NumSpaces, ' ');
|
|
|
|
return std::make_pair(expandedTab, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned char const *begin, *end;
|
|
|
|
begin = reinterpret_cast<unsigned char const *>(&*(SourceLine.begin() + *i));
|
2012-10-30 14:13:50 +08:00
|
|
|
end = begin + (SourceLine.size() - *i);
|
2018-07-31 03:24:48 +08:00
|
|
|
|
2016-09-30 08:38:45 +08:00
|
|
|
if (llvm::isLegalUTF8Sequence(begin, end)) {
|
|
|
|
llvm::UTF32 c;
|
|
|
|
llvm::UTF32 *cptr = &c;
|
2012-04-18 10:44:46 +08:00
|
|
|
unsigned char const *original_begin = begin;
|
2016-09-30 08:38:45 +08:00
|
|
|
unsigned char const *cp_end =
|
|
|
|
begin + llvm::getNumBytesForUTF8(SourceLine[*i]);
|
2012-04-18 10:44:46 +08:00
|
|
|
|
2016-09-30 08:38:45 +08:00
|
|
|
llvm::ConversionResult res = llvm::ConvertUTF8toUTF32(
|
|
|
|
&begin, cp_end, &cptr, cptr + 1, llvm::strictConversion);
|
2012-04-19 01:25:16 +08:00
|
|
|
(void)res;
|
2016-09-30 08:38:45 +08:00
|
|
|
assert(llvm::conversionOK == res);
|
2012-04-18 10:44:46 +08:00
|
|
|
assert(0 < begin-original_begin
|
|
|
|
&& "we must be further along in the string now");
|
|
|
|
*i += begin-original_begin;
|
|
|
|
|
|
|
|
if (!llvm::sys::locale::isPrint(c)) {
|
|
|
|
// If next character is valid UTF-8, but not printable
|
|
|
|
SmallString<16> expandedCP("<U+>");
|
|
|
|
while (c) {
|
|
|
|
expandedCP.insert(expandedCP.begin()+3, llvm::hexdigit(c%16));
|
|
|
|
c/=16;
|
|
|
|
}
|
|
|
|
while (expandedCP.size() < 8)
|
|
|
|
expandedCP.insert(expandedCP.begin()+3, llvm::hexdigit(0));
|
|
|
|
return std::make_pair(expandedCP, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If next character is valid UTF-8, and printable
|
|
|
|
return std::make_pair(SmallString<16>(original_begin, cp_end), true);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
// If next byte is not valid UTF-8 (and therefore not printable)
|
|
|
|
SmallString<16> expandedByte("<XX>");
|
|
|
|
unsigned char byte = SourceLine[*i];
|
|
|
|
expandedByte[1] = llvm::hexdigit(byte / 16);
|
|
|
|
expandedByte[2] = llvm::hexdigit(byte % 16);
|
|
|
|
++(*i);
|
|
|
|
return std::make_pair(expandedByte, false);
|
|
|
|
}
|
|
|
|
|
2012-05-01 22:34:11 +08:00
|
|
|
static void expandTabs(std::string &SourceLine, unsigned TabStop) {
|
2012-04-18 10:44:46 +08:00
|
|
|
size_t i = SourceLine.size();
|
|
|
|
while (i>0) {
|
|
|
|
i--;
|
|
|
|
if (SourceLine[i]!='\t')
|
|
|
|
continue;
|
|
|
|
size_t tmp_i = i;
|
|
|
|
std::pair<SmallString<16>,bool> res
|
|
|
|
= printableTextForNextCharacter(SourceLine, &tmp_i, TabStop);
|
|
|
|
SourceLine.replace(i, 1, res.first.c_str());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// This function takes a raw source line and produces a mapping from the bytes
|
|
|
|
/// of the printable representation of the line to the columns those printable
|
|
|
|
/// characters will appear at (numbering the first column as 0).
|
|
|
|
///
|
2014-12-20 16:51:22 +08:00
|
|
|
/// If a byte 'i' corresponds to multiple columns (e.g. the byte contains a tab
|
2012-07-23 16:59:39 +08:00
|
|
|
/// character) then the array will map that byte to the first column the
|
2012-04-18 10:44:46 +08:00
|
|
|
/// tab appears at and the next value in the map will have been incremented
|
|
|
|
/// more than once.
|
|
|
|
///
|
|
|
|
/// If a byte is the first in a sequence of bytes that together map to a single
|
|
|
|
/// entity in the output, then the array will map that byte to the appropriate
|
|
|
|
/// column while the subsequent bytes will be -1.
|
|
|
|
///
|
|
|
|
/// The last element in the array does not correspond to any byte in the input
|
|
|
|
/// and instead is the number of columns needed to display the source
|
|
|
|
///
|
|
|
|
/// example: (given a tabstop of 8)
|
|
|
|
///
|
|
|
|
/// "a \t \u3042" -> {0,1,2,8,9,-1,-1,11}
|
|
|
|
///
|
2012-06-22 13:33:23 +08:00
|
|
|
/// (\\u3042 is represented in UTF-8 by three bytes and takes two columns to
|
2012-04-18 10:44:46 +08:00
|
|
|
/// display)
|
2012-05-01 22:34:11 +08:00
|
|
|
static void byteToColumn(StringRef SourceLine, unsigned TabStop,
|
|
|
|
SmallVectorImpl<int> &out) {
|
2012-04-18 10:44:46 +08:00
|
|
|
out.clear();
|
|
|
|
|
|
|
|
if (SourceLine.empty()) {
|
|
|
|
out.resize(1u,0);
|
|
|
|
return;
|
|
|
|
}
|
2018-07-31 03:24:48 +08:00
|
|
|
|
2012-04-18 10:44:46 +08:00
|
|
|
out.resize(SourceLine.size()+1, -1);
|
|
|
|
|
|
|
|
int columns = 0;
|
|
|
|
size_t i = 0;
|
|
|
|
while (i<SourceLine.size()) {
|
|
|
|
out[i] = columns;
|
|
|
|
std::pair<SmallString<16>,bool> res
|
|
|
|
= printableTextForNextCharacter(SourceLine, &i, TabStop);
|
|
|
|
columns += llvm::sys::locale::columnWidth(res.first);
|
|
|
|
}
|
|
|
|
out.back() = columns;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// This function takes a raw source line and produces a mapping from columns
|
|
|
|
/// to the byte of the source line that produced the character displaying at
|
|
|
|
/// that column. This is the inverse of the mapping produced by byteToColumn()
|
|
|
|
///
|
|
|
|
/// The last element in the array is the number of bytes in the source string
|
|
|
|
///
|
|
|
|
/// example: (given a tabstop of 8)
|
|
|
|
///
|
|
|
|
/// "a \t \u3042" -> {0,1,2,-1,-1,-1,-1,-1,3,4,-1,7}
|
|
|
|
///
|
2012-06-22 13:33:23 +08:00
|
|
|
/// (\\u3042 is represented in UTF-8 by three bytes and takes two columns to
|
2012-04-18 10:44:46 +08:00
|
|
|
/// display)
|
2012-05-01 22:34:11 +08:00
|
|
|
static void columnToByte(StringRef SourceLine, unsigned TabStop,
|
2012-04-18 10:44:46 +08:00
|
|
|
SmallVectorImpl<int> &out) {
|
|
|
|
out.clear();
|
|
|
|
|
|
|
|
if (SourceLine.empty()) {
|
|
|
|
out.resize(1u, 0);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
int columns = 0;
|
|
|
|
size_t i = 0;
|
|
|
|
while (i<SourceLine.size()) {
|
|
|
|
out.resize(columns+1, -1);
|
|
|
|
out.back() = i;
|
|
|
|
std::pair<SmallString<16>,bool> res
|
|
|
|
= printableTextForNextCharacter(SourceLine, &i, TabStop);
|
|
|
|
columns += llvm::sys::locale::columnWidth(res.first);
|
|
|
|
}
|
|
|
|
out.resize(columns+1, -1);
|
|
|
|
out.back() = i;
|
|
|
|
}
|
|
|
|
|
2012-12-02 04:58:01 +08:00
|
|
|
namespace {
|
2012-04-18 10:44:46 +08:00
|
|
|
struct SourceColumnMap {
|
|
|
|
SourceColumnMap(StringRef SourceLine, unsigned TabStop)
|
|
|
|
: m_SourceLine(SourceLine) {
|
2018-07-31 03:24:48 +08:00
|
|
|
|
2012-04-18 10:44:46 +08:00
|
|
|
::byteToColumn(SourceLine, TabStop, m_byteToColumn);
|
|
|
|
::columnToByte(SourceLine, TabStop, m_columnToByte);
|
2018-07-31 03:24:48 +08:00
|
|
|
|
2012-04-18 10:44:46 +08:00
|
|
|
assert(m_byteToColumn.size()==SourceLine.size()+1);
|
|
|
|
assert(0 < m_byteToColumn.size() && 0 < m_columnToByte.size());
|
|
|
|
assert(m_byteToColumn.size()
|
|
|
|
== static_cast<unsigned>(m_columnToByte.back()+1));
|
|
|
|
assert(static_cast<unsigned>(m_byteToColumn.back()+1)
|
|
|
|
== m_columnToByte.size());
|
|
|
|
}
|
|
|
|
int columns() const { return m_byteToColumn.back(); }
|
|
|
|
int bytes() const { return m_columnToByte.back(); }
|
2012-09-14 02:37:50 +08:00
|
|
|
|
2018-05-09 09:00:01 +08:00
|
|
|
/// Map a byte to the column which it is at the start of, or return -1
|
2012-09-14 02:37:50 +08:00
|
|
|
/// if it is not at the start of a column (for a UTF-8 trailing byte).
|
2012-04-18 10:44:46 +08:00
|
|
|
int byteToColumn(int n) const {
|
|
|
|
assert(0<=n && n<static_cast<int>(m_byteToColumn.size()));
|
|
|
|
return m_byteToColumn[n];
|
|
|
|
}
|
2012-09-14 02:37:50 +08:00
|
|
|
|
2018-05-09 09:00:01 +08:00
|
|
|
/// Map a byte to the first column which contains it.
|
2012-09-14 02:37:50 +08:00
|
|
|
int byteToContainingColumn(int N) const {
|
|
|
|
assert(0 <= N && N < static_cast<int>(m_byteToColumn.size()));
|
|
|
|
while (m_byteToColumn[N] == -1)
|
|
|
|
--N;
|
|
|
|
return m_byteToColumn[N];
|
|
|
|
}
|
|
|
|
|
2018-05-09 09:00:01 +08:00
|
|
|
/// Map a column to the byte which starts the column, or return -1 if
|
2012-09-14 02:37:50 +08:00
|
|
|
/// the column the second or subsequent column of an expanded tab or similar
|
|
|
|
/// multi-column entity.
|
2012-04-18 10:44:46 +08:00
|
|
|
int columnToByte(int n) const {
|
|
|
|
assert(0<=n && n<static_cast<int>(m_columnToByte.size()));
|
|
|
|
return m_columnToByte[n];
|
|
|
|
}
|
2012-09-14 02:37:50 +08:00
|
|
|
|
2018-05-09 09:00:01 +08:00
|
|
|
/// Map from a byte index to the next byte which starts a column.
|
2012-09-14 02:37:50 +08:00
|
|
|
int startOfNextColumn(int N) const {
|
2015-01-08 21:19:07 +08:00
|
|
|
assert(0 <= N && N < static_cast<int>(m_byteToColumn.size() - 1));
|
2012-09-14 02:37:50 +08:00
|
|
|
while (byteToColumn(++N) == -1) {}
|
|
|
|
return N;
|
|
|
|
}
|
|
|
|
|
2018-05-09 09:00:01 +08:00
|
|
|
/// Map from a byte index to the previous byte which starts a column.
|
2012-09-14 02:37:50 +08:00
|
|
|
int startOfPreviousColumn(int N) const {
|
2015-01-08 21:19:07 +08:00
|
|
|
assert(0 < N && N < static_cast<int>(m_byteToColumn.size()));
|
2012-11-04 05:21:14 +08:00
|
|
|
while (byteToColumn(--N) == -1) {}
|
2012-09-14 02:37:50 +08:00
|
|
|
return N;
|
|
|
|
}
|
|
|
|
|
2012-04-18 10:44:46 +08:00
|
|
|
StringRef getSourceLine() const {
|
|
|
|
return m_SourceLine;
|
|
|
|
}
|
2018-07-31 03:24:48 +08:00
|
|
|
|
2012-04-18 10:44:46 +08:00
|
|
|
private:
|
|
|
|
const std::string m_SourceLine;
|
|
|
|
SmallVector<int,200> m_byteToColumn;
|
|
|
|
SmallVector<int,200> m_columnToByte;
|
|
|
|
};
|
2012-12-02 04:58:01 +08:00
|
|
|
} // end anonymous namespace
|
2012-04-18 10:44:46 +08:00
|
|
|
|
2018-05-09 09:00:01 +08:00
|
|
|
/// When the source code line we want to print is too long for
|
2011-10-16 07:43:53 +08:00
|
|
|
/// the terminal, select the "interesting" region.
|
2011-10-16 07:54:09 +08:00
|
|
|
static void selectInterestingSourceRegion(std::string &SourceLine,
|
2011-10-16 07:43:53 +08:00
|
|
|
std::string &CaretLine,
|
|
|
|
std::string &FixItInsertionLine,
|
2012-04-18 10:44:46 +08:00
|
|
|
unsigned Columns,
|
|
|
|
const SourceColumnMap &map) {
|
2015-01-08 21:19:07 +08:00
|
|
|
unsigned CaretColumns = CaretLine.size();
|
|
|
|
unsigned FixItColumns = llvm::sys::locale::columnWidth(FixItInsertionLine);
|
|
|
|
unsigned MaxColumns = std::max(static_cast<unsigned>(map.columns()),
|
|
|
|
std::max(CaretColumns, FixItColumns));
|
2012-04-18 10:44:46 +08:00
|
|
|
// if the number of columns is less than the desired number we're done
|
|
|
|
if (MaxColumns <= Columns)
|
|
|
|
return;
|
|
|
|
|
2013-06-08 01:16:01 +08:00
|
|
|
// No special characters are allowed in CaretLine.
|
2012-04-18 10:44:46 +08:00
|
|
|
assert(CaretLine.end() ==
|
2019-03-31 16:48:19 +08:00
|
|
|
llvm::find_if(CaretLine, [](char c) { return c < ' ' || '~' < c; }));
|
2012-04-18 10:44:46 +08:00
|
|
|
|
2011-10-16 07:43:53 +08:00
|
|
|
// Find the slice that we need to display the full caret line
|
|
|
|
// correctly.
|
|
|
|
unsigned CaretStart = 0, CaretEnd = CaretLine.size();
|
|
|
|
for (; CaretStart != CaretEnd; ++CaretStart)
|
2013-02-09 06:30:41 +08:00
|
|
|
if (!isWhitespace(CaretLine[CaretStart]))
|
2011-10-16 07:43:53 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
for (; CaretEnd != CaretStart; --CaretEnd)
|
2013-02-09 06:30:41 +08:00
|
|
|
if (!isWhitespace(CaretLine[CaretEnd - 1]))
|
2011-10-16 07:43:53 +08:00
|
|
|
break;
|
|
|
|
|
2012-04-18 10:44:46 +08:00
|
|
|
// caret has already been inserted into CaretLine so the above whitespace
|
|
|
|
// check is guaranteed to include the caret
|
2011-10-16 07:43:53 +08:00
|
|
|
|
|
|
|
// If we have a fix-it line, make sure the slice includes all of the
|
|
|
|
// fix-it information.
|
|
|
|
if (!FixItInsertionLine.empty()) {
|
|
|
|
unsigned FixItStart = 0, FixItEnd = FixItInsertionLine.size();
|
|
|
|
for (; FixItStart != FixItEnd; ++FixItStart)
|
2013-02-09 06:30:41 +08:00
|
|
|
if (!isWhitespace(FixItInsertionLine[FixItStart]))
|
2011-10-16 07:43:53 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
for (; FixItEnd != FixItStart; --FixItEnd)
|
2013-02-09 06:30:41 +08:00
|
|
|
if (!isWhitespace(FixItInsertionLine[FixItEnd - 1]))
|
2011-10-16 07:43:53 +08:00
|
|
|
break;
|
|
|
|
|
2013-06-08 01:16:01 +08:00
|
|
|
// We can safely use the byte offset FixItStart as the column offset
|
|
|
|
// because the characters up until FixItStart are all ASCII whitespace
|
|
|
|
// characters.
|
|
|
|
unsigned FixItStartCol = FixItStart;
|
|
|
|
unsigned FixItEndCol
|
|
|
|
= llvm::sys::locale::columnWidth(FixItInsertionLine.substr(0, FixItEnd));
|
|
|
|
|
|
|
|
CaretStart = std::min(FixItStartCol, CaretStart);
|
|
|
|
CaretEnd = std::max(FixItEndCol, CaretEnd);
|
2011-10-16 07:43:53 +08:00
|
|
|
}
|
|
|
|
|
2012-05-24 13:14:44 +08:00
|
|
|
// CaretEnd may have been set at the middle of a character
|
|
|
|
// If it's not at a character's first column then advance it past the current
|
|
|
|
// character.
|
|
|
|
while (static_cast<int>(CaretEnd) < map.columns() &&
|
|
|
|
-1 == map.columnToByte(CaretEnd))
|
|
|
|
++CaretEnd;
|
|
|
|
|
|
|
|
assert((static_cast<int>(CaretStart) > map.columns() ||
|
|
|
|
-1!=map.columnToByte(CaretStart)) &&
|
|
|
|
"CaretStart must not point to a column in the middle of a source"
|
|
|
|
" line character");
|
|
|
|
assert((static_cast<int>(CaretEnd) > map.columns() ||
|
|
|
|
-1!=map.columnToByte(CaretEnd)) &&
|
|
|
|
"CaretEnd must not point to a column in the middle of a source line"
|
|
|
|
" character");
|
|
|
|
|
2011-10-16 07:43:53 +08:00
|
|
|
// CaretLine[CaretStart, CaretEnd) contains all of the interesting
|
|
|
|
// parts of the caret line. While this slice is smaller than the
|
|
|
|
// number of columns we have, try to grow the slice to encompass
|
|
|
|
// more context.
|
|
|
|
|
2012-04-18 10:44:46 +08:00
|
|
|
unsigned SourceStart = map.columnToByte(std::min<unsigned>(CaretStart,
|
|
|
|
map.columns()));
|
|
|
|
unsigned SourceEnd = map.columnToByte(std::min<unsigned>(CaretEnd,
|
|
|
|
map.columns()));
|
|
|
|
|
|
|
|
unsigned CaretColumnsOutsideSource = CaretEnd-CaretStart
|
|
|
|
- (map.byteToColumn(SourceEnd)-map.byteToColumn(SourceStart));
|
|
|
|
|
|
|
|
char const *front_ellipse = " ...";
|
|
|
|
char const *front_space = " ";
|
|
|
|
char const *back_ellipse = "...";
|
|
|
|
unsigned ellipses_space = strlen(front_ellipse) + strlen(back_ellipse);
|
2011-10-16 07:43:53 +08:00
|
|
|
|
|
|
|
unsigned TargetColumns = Columns;
|
2012-04-18 10:44:46 +08:00
|
|
|
// Give us extra room for the ellipses
|
|
|
|
// and any of the caret line that extends past the source
|
|
|
|
if (TargetColumns > ellipses_space+CaretColumnsOutsideSource)
|
|
|
|
TargetColumns -= ellipses_space+CaretColumnsOutsideSource;
|
|
|
|
|
|
|
|
while (SourceStart>0 || SourceEnd<SourceLine.size()) {
|
2011-10-16 07:43:53 +08:00
|
|
|
bool ExpandedRegion = false;
|
2012-04-18 10:44:46 +08:00
|
|
|
|
|
|
|
if (SourceStart>0) {
|
2012-11-04 05:21:17 +08:00
|
|
|
unsigned NewStart = map.startOfPreviousColumn(SourceStart);
|
2011-10-16 07:43:53 +08:00
|
|
|
|
|
|
|
// Skip over any whitespace we see here; we're looking for
|
|
|
|
// another bit of interesting text.
|
2012-09-14 02:37:50 +08:00
|
|
|
// FIXME: Detect non-ASCII whitespace characters too.
|
2013-02-09 06:30:41 +08:00
|
|
|
while (NewStart && isWhitespace(SourceLine[NewStart]))
|
2012-09-14 02:37:50 +08:00
|
|
|
NewStart = map.startOfPreviousColumn(NewStart);
|
2011-10-16 07:43:53 +08:00
|
|
|
|
|
|
|
// Skip over this bit of "interesting" text.
|
2012-09-14 02:37:50 +08:00
|
|
|
while (NewStart) {
|
|
|
|
unsigned Prev = map.startOfPreviousColumn(NewStart);
|
2013-02-09 06:30:41 +08:00
|
|
|
if (isWhitespace(SourceLine[Prev]))
|
2012-09-14 02:37:50 +08:00
|
|
|
break;
|
|
|
|
NewStart = Prev;
|
|
|
|
}
|
2011-10-16 07:43:53 +08:00
|
|
|
|
2012-09-14 02:37:50 +08:00
|
|
|
assert(map.byteToColumn(NewStart) != -1);
|
2012-04-18 10:44:46 +08:00
|
|
|
unsigned NewColumns = map.byteToColumn(SourceEnd) -
|
|
|
|
map.byteToColumn(NewStart);
|
|
|
|
if (NewColumns <= TargetColumns) {
|
|
|
|
SourceStart = NewStart;
|
2011-10-16 07:43:53 +08:00
|
|
|
ExpandedRegion = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-18 10:44:46 +08:00
|
|
|
if (SourceEnd<SourceLine.size()) {
|
2012-11-04 05:21:17 +08:00
|
|
|
unsigned NewEnd = map.startOfNextColumn(SourceEnd);
|
2011-10-16 07:43:53 +08:00
|
|
|
|
|
|
|
// Skip over any whitespace we see here; we're looking for
|
|
|
|
// another bit of interesting text.
|
2012-09-14 02:37:50 +08:00
|
|
|
// FIXME: Detect non-ASCII whitespace characters too.
|
2013-02-09 06:30:41 +08:00
|
|
|
while (NewEnd < SourceLine.size() && isWhitespace(SourceLine[NewEnd]))
|
2012-09-14 02:37:50 +08:00
|
|
|
NewEnd = map.startOfNextColumn(NewEnd);
|
2011-10-16 07:43:53 +08:00
|
|
|
|
|
|
|
// Skip over this bit of "interesting" text.
|
2013-02-09 06:30:41 +08:00
|
|
|
while (NewEnd < SourceLine.size() && isWhitespace(SourceLine[NewEnd]))
|
2012-09-14 02:37:50 +08:00
|
|
|
NewEnd = map.startOfNextColumn(NewEnd);
|
2011-10-16 07:43:53 +08:00
|
|
|
|
2012-09-14 02:37:50 +08:00
|
|
|
assert(map.byteToColumn(NewEnd) != -1);
|
2012-04-18 10:44:46 +08:00
|
|
|
unsigned NewColumns = map.byteToColumn(NewEnd) -
|
|
|
|
map.byteToColumn(SourceStart);
|
|
|
|
if (NewColumns <= TargetColumns) {
|
|
|
|
SourceEnd = NewEnd;
|
2011-10-16 07:43:53 +08:00
|
|
|
ExpandedRegion = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ExpandedRegion)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-04-18 10:44:46 +08:00
|
|
|
CaretStart = map.byteToColumn(SourceStart);
|
|
|
|
CaretEnd = map.byteToColumn(SourceEnd) + CaretColumnsOutsideSource;
|
|
|
|
|
2011-10-16 07:43:53 +08:00
|
|
|
// [CaretStart, CaretEnd) is the slice we want. Update the various
|
|
|
|
// output lines to show only this slice, with two-space padding
|
|
|
|
// before the lines so that it looks nicer.
|
2012-04-18 10:44:46 +08:00
|
|
|
|
|
|
|
assert(CaretStart!=(unsigned)-1 && CaretEnd!=(unsigned)-1 &&
|
|
|
|
SourceStart!=(unsigned)-1 && SourceEnd!=(unsigned)-1);
|
|
|
|
assert(SourceStart <= SourceEnd);
|
|
|
|
assert(CaretStart <= CaretEnd);
|
|
|
|
|
|
|
|
unsigned BackColumnsRemoved
|
|
|
|
= map.byteToColumn(SourceLine.size())-map.byteToColumn(SourceEnd);
|
|
|
|
unsigned FrontColumnsRemoved = CaretStart;
|
|
|
|
unsigned ColumnsKept = CaretEnd-CaretStart;
|
|
|
|
|
|
|
|
// We checked up front that the line needed truncation
|
|
|
|
assert(FrontColumnsRemoved+ColumnsKept+BackColumnsRemoved > Columns);
|
|
|
|
|
2014-12-20 16:51:22 +08:00
|
|
|
// The line needs some truncation, and we'd prefer to keep the front
|
2012-04-18 10:44:46 +08:00
|
|
|
// if possible, so remove the back
|
2012-11-04 07:56:43 +08:00
|
|
|
if (BackColumnsRemoved > strlen(back_ellipse))
|
2012-04-18 10:44:46 +08:00
|
|
|
SourceLine.replace(SourceEnd, std::string::npos, back_ellipse);
|
|
|
|
|
|
|
|
// If that's enough then we're done
|
|
|
|
if (FrontColumnsRemoved+ColumnsKept <= Columns)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Otherwise remove the front as well
|
2012-11-04 07:56:43 +08:00
|
|
|
if (FrontColumnsRemoved > strlen(front_ellipse)) {
|
2012-04-18 10:44:46 +08:00
|
|
|
SourceLine.replace(0, SourceStart, front_ellipse);
|
|
|
|
CaretLine.replace(0, CaretStart, front_space);
|
|
|
|
if (!FixItInsertionLine.empty())
|
|
|
|
FixItInsertionLine.replace(0, CaretStart, front_space);
|
2011-10-16 07:43:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-09 09:00:01 +08:00
|
|
|
/// Skip over whitespace in the string, starting at the given
|
2011-10-16 07:43:53 +08:00
|
|
|
/// index.
|
|
|
|
///
|
|
|
|
/// \returns The index of the first non-whitespace character that is
|
|
|
|
/// greater than or equal to Idx or, if no such character exists,
|
|
|
|
/// returns the end of the string.
|
|
|
|
static unsigned skipWhitespace(unsigned Idx, StringRef Str, unsigned Length) {
|
2013-02-09 06:30:41 +08:00
|
|
|
while (Idx < Length && isWhitespace(Str[Idx]))
|
2011-10-16 07:43:53 +08:00
|
|
|
++Idx;
|
|
|
|
return Idx;
|
|
|
|
}
|
|
|
|
|
2018-05-09 09:00:01 +08:00
|
|
|
/// If the given character is the start of some kind of
|
2011-10-16 07:43:53 +08:00
|
|
|
/// balanced punctuation (e.g., quotes or parentheses), return the
|
|
|
|
/// character that will terminate the punctuation.
|
|
|
|
///
|
|
|
|
/// \returns The ending punctuation character, if any, or the NULL
|
|
|
|
/// character if the input character does not start any punctuation.
|
|
|
|
static inline char findMatchingPunctuation(char c) {
|
|
|
|
switch (c) {
|
|
|
|
case '\'': return '\'';
|
|
|
|
case '`': return '\'';
|
|
|
|
case '"': return '"';
|
|
|
|
case '(': return ')';
|
|
|
|
case '[': return ']';
|
|
|
|
case '{': return '}';
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-05-09 09:00:01 +08:00
|
|
|
/// Find the end of the word starting at the given offset
|
2011-10-16 07:43:53 +08:00
|
|
|
/// within a string.
|
|
|
|
///
|
|
|
|
/// \returns the index pointing one character past the end of the
|
|
|
|
/// word.
|
|
|
|
static unsigned findEndOfWord(unsigned Start, StringRef Str,
|
|
|
|
unsigned Length, unsigned Column,
|
|
|
|
unsigned Columns) {
|
|
|
|
assert(Start < Str.size() && "Invalid start position!");
|
|
|
|
unsigned End = Start + 1;
|
|
|
|
|
|
|
|
// If we are already at the end of the string, take that as the word.
|
|
|
|
if (End == Str.size())
|
|
|
|
return End;
|
|
|
|
|
|
|
|
// Determine if the start of the string is actually opening
|
|
|
|
// punctuation, e.g., a quote or parentheses.
|
|
|
|
char EndPunct = findMatchingPunctuation(Str[Start]);
|
|
|
|
if (!EndPunct) {
|
|
|
|
// This is a normal word. Just find the first space character.
|
2013-02-09 06:30:41 +08:00
|
|
|
while (End < Length && !isWhitespace(Str[End]))
|
2011-10-16 07:43:53 +08:00
|
|
|
++End;
|
|
|
|
return End;
|
|
|
|
}
|
|
|
|
|
|
|
|
// We have the start of a balanced punctuation sequence (quotes,
|
|
|
|
// parentheses, etc.). Determine the full sequence is.
|
2012-02-05 10:13:05 +08:00
|
|
|
SmallString<16> PunctuationEndStack;
|
2011-10-16 07:43:53 +08:00
|
|
|
PunctuationEndStack.push_back(EndPunct);
|
|
|
|
while (End < Length && !PunctuationEndStack.empty()) {
|
|
|
|
if (Str[End] == PunctuationEndStack.back())
|
|
|
|
PunctuationEndStack.pop_back();
|
|
|
|
else if (char SubEndPunct = findMatchingPunctuation(Str[End]))
|
|
|
|
PunctuationEndStack.push_back(SubEndPunct);
|
|
|
|
|
|
|
|
++End;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Find the first space character after the punctuation ended.
|
2013-02-09 06:30:41 +08:00
|
|
|
while (End < Length && !isWhitespace(Str[End]))
|
2011-10-16 07:43:53 +08:00
|
|
|
++End;
|
|
|
|
|
|
|
|
unsigned PunctWordLength = End - Start;
|
|
|
|
if (// If the word fits on this line
|
|
|
|
Column + PunctWordLength <= Columns ||
|
|
|
|
// ... or the word is "short enough" to take up the next line
|
|
|
|
// without too much ugly white space
|
|
|
|
PunctWordLength < Columns/3)
|
|
|
|
return End; // Take the whole thing as a single "word".
|
|
|
|
|
|
|
|
// The whole quoted/parenthesized string is too long to print as a
|
|
|
|
// single "word". Instead, find the "word" that starts just after
|
|
|
|
// the punctuation and use that end-point instead. This will recurse
|
|
|
|
// until it finds something small enough to consider a word.
|
|
|
|
return findEndOfWord(Start + 1, Str, Length, Column + 1, Columns);
|
|
|
|
}
|
|
|
|
|
2018-05-09 09:00:01 +08:00
|
|
|
/// Print the given string to a stream, word-wrapping it to
|
2011-10-16 07:43:53 +08:00
|
|
|
/// some number of columns in the process.
|
|
|
|
///
|
|
|
|
/// \param OS the stream to which the word-wrapping string will be
|
|
|
|
/// emitted.
|
|
|
|
/// \param Str the string to word-wrap and output.
|
|
|
|
/// \param Columns the number of columns to word-wrap to.
|
|
|
|
/// \param Column the column number at which the first character of \p
|
|
|
|
/// Str will be printed. This will be non-zero when part of the first
|
|
|
|
/// line has already been printed.
|
2012-06-29 06:39:03 +08:00
|
|
|
/// \param Bold if the current text should be bold
|
2011-10-16 07:43:53 +08:00
|
|
|
/// \param Indentation the number of spaces to indent any lines beyond
|
|
|
|
/// the first line.
|
|
|
|
/// \returns true if word-wrapping was required, or false if the
|
|
|
|
/// string fit on the first line.
|
|
|
|
static bool printWordWrapped(raw_ostream &OS, StringRef Str,
|
|
|
|
unsigned Columns,
|
|
|
|
unsigned Column = 0,
|
2012-06-29 06:39:03 +08:00
|
|
|
bool Bold = false,
|
2011-10-16 07:43:53 +08:00
|
|
|
unsigned Indentation = WordWrapIndentation) {
|
|
|
|
const unsigned Length = std::min(Str.find('\n'), Str.size());
|
2012-06-27 02:18:47 +08:00
|
|
|
bool TextNormal = true;
|
2011-10-16 07:43:53 +08:00
|
|
|
|
|
|
|
// The string used to indent each line.
|
2012-02-05 10:13:05 +08:00
|
|
|
SmallString<16> IndentStr;
|
2011-10-16 07:43:53 +08:00
|
|
|
IndentStr.assign(Indentation, ' ');
|
|
|
|
bool Wrapped = false;
|
|
|
|
for (unsigned WordStart = 0, WordEnd; WordStart < Length;
|
|
|
|
WordStart = WordEnd) {
|
|
|
|
// Find the beginning of the next word.
|
|
|
|
WordStart = skipWhitespace(WordStart, Str, Length);
|
|
|
|
if (WordStart == Length)
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Find the end of this word.
|
|
|
|
WordEnd = findEndOfWord(WordStart, Str, Length, Column, Columns);
|
|
|
|
|
|
|
|
// Does this word fit on the current line?
|
|
|
|
unsigned WordLength = WordEnd - WordStart;
|
|
|
|
if (Column + WordLength < Columns) {
|
|
|
|
// This word fits on the current line; print it there.
|
|
|
|
if (WordStart) {
|
|
|
|
OS << ' ';
|
|
|
|
Column += 1;
|
|
|
|
}
|
2012-06-27 02:18:47 +08:00
|
|
|
applyTemplateHighlighting(OS, Str.substr(WordStart, WordLength),
|
2012-06-29 06:39:03 +08:00
|
|
|
TextNormal, Bold);
|
2011-10-16 07:43:53 +08:00
|
|
|
Column += WordLength;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// This word does not fit on the current line, so wrap to the next
|
|
|
|
// line.
|
|
|
|
OS << '\n';
|
|
|
|
OS.write(&IndentStr[0], Indentation);
|
2012-06-27 02:18:47 +08:00
|
|
|
applyTemplateHighlighting(OS, Str.substr(WordStart, WordLength),
|
2012-06-29 06:39:03 +08:00
|
|
|
TextNormal, Bold);
|
2011-10-16 07:43:53 +08:00
|
|
|
Column = Indentation + WordLength;
|
|
|
|
Wrapped = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Append any remaning text from the message with its existing formatting.
|
2012-06-29 06:39:03 +08:00
|
|
|
applyTemplateHighlighting(OS, Str.substr(Length), TextNormal, Bold);
|
2012-06-27 02:18:47 +08:00
|
|
|
|
|
|
|
assert(TextNormal && "Text highlighted at end of diagnostic message.");
|
2011-10-16 07:43:53 +08:00
|
|
|
|
|
|
|
return Wrapped;
|
|
|
|
}
|
|
|
|
|
|
|
|
TextDiagnostic::TextDiagnostic(raw_ostream &OS,
|
|
|
|
const LangOptions &LangOpts,
|
2012-10-24 06:26:28 +08:00
|
|
|
DiagnosticOptions *DiagOpts)
|
2012-05-10 13:03:45 +08:00
|
|
|
: DiagnosticRenderer(LangOpts, DiagOpts), OS(OS) {}
|
2011-10-16 07:43:53 +08:00
|
|
|
|
2015-10-20 21:23:58 +08:00
|
|
|
TextDiagnostic::~TextDiagnostic() {}
|
2011-10-16 07:43:53 +08:00
|
|
|
|
2017-06-27 17:50:38 +08:00
|
|
|
void TextDiagnostic::emitDiagnosticMessage(
|
|
|
|
FullSourceLoc Loc, PresumedLoc PLoc, DiagnosticsEngine::Level Level,
|
|
|
|
StringRef Message, ArrayRef<clang::CharSourceRange> Ranges,
|
|
|
|
DiagOrStoredDiag D) {
|
2011-10-16 07:43:53 +08:00
|
|
|
uint64_t StartOfLocationInfo = OS.tell();
|
|
|
|
|
2011-12-17 13:26:04 +08:00
|
|
|
// Emit the location of this particular diagnostic.
|
2012-05-10 13:03:45 +08:00
|
|
|
if (Loc.isValid())
|
2017-06-27 17:50:38 +08:00
|
|
|
emitDiagnosticLoc(Loc, PLoc, Level, Ranges);
|
|
|
|
|
2012-10-24 06:26:28 +08:00
|
|
|
if (DiagOpts->ShowColors)
|
2011-10-16 07:43:53 +08:00
|
|
|
OS.resetColor();
|
2018-07-31 03:24:48 +08:00
|
|
|
|
[lldb] Print better diagnostics for user expressions and modules
Summary:
Currently our expression evaluators only prints very basic errors that are not very useful when writing complex expressions.
For example, in the expression below the user made a type error, but it's not clear from the diagnostic what went wrong:
```
(lldb) expr printf("Modulos are:", foobar%mo1, foobar%mo2, foobar%mo3)
error: invalid operands to binary expression ('int' and 'double')
```
This patch enables full Clang diagnostics in our expression evaluator. After this patch the diagnostics for the expression look like this:
```
(lldb) expr printf("Modulos are:", foobar%mo1, foobar%mo2, foobar%mo3)
error: <user expression 1>:1:54: invalid operands to binary expression ('int' and 'float')
printf("Modulos are:", foobar%mo1, foobar%mo2, foobar%mo3)
~~~~~~^~~~
```
To make this possible, we now emulate a user expression file within our diagnostics. This prevents that the user is exposed to
our internal wrapper code we inject.
Note that the diagnostics that refer to declarations from the debug information (e.g. 'note' diagnostics pointing to a called function)
will not be improved by this as they don't have any source locations associated with them, so caret or line printing isn't possible.
We instead just suppress these diagnostics as we already do with warnings as they would otherwise just be a context message
without any context (and the original diagnostic in the user expression should be enough to explain the issue).
Fixes rdar://24306342
Reviewers: JDevlieghere, aprantl, shafik, #lldb
Reviewed By: JDevlieghere, #lldb
Subscribers: usaxena95, davide, jingham, aprantl, arphaman, kadircet, lldb-commits
Tags: #lldb
Differential Revision: https://reviews.llvm.org/D65646
llvm-svn: 372203
2019-09-18 16:53:35 +08:00
|
|
|
if (DiagOpts->ShowLevel)
|
2021-02-02 21:10:26 +08:00
|
|
|
printDiagnosticLevel(OS, Level, DiagOpts->ShowColors);
|
2014-06-22 07:31:52 +08:00
|
|
|
printDiagnosticMessage(OS,
|
|
|
|
/*IsSupplemental*/ Level == DiagnosticsEngine::Note,
|
|
|
|
Message, OS.tell() - StartOfLocationInfo,
|
2012-10-24 06:26:28 +08:00
|
|
|
DiagOpts->MessageLength, DiagOpts->ShowColors);
|
2011-10-16 07:43:53 +08:00
|
|
|
}
|
|
|
|
|
2011-10-16 07:48:02 +08:00
|
|
|
/*static*/ void
|
|
|
|
TextDiagnostic::printDiagnosticLevel(raw_ostream &OS,
|
|
|
|
DiagnosticsEngine::Level Level,
|
2021-02-02 21:10:26 +08:00
|
|
|
bool ShowColors) {
|
2011-10-16 07:48:02 +08:00
|
|
|
if (ShowColors) {
|
|
|
|
// Print diagnostic category in bold and color
|
|
|
|
switch (Level) {
|
|
|
|
case DiagnosticsEngine::Ignored:
|
|
|
|
llvm_unreachable("Invalid diagnostic type");
|
|
|
|
case DiagnosticsEngine::Note: OS.changeColor(noteColor, true); break;
|
2014-02-28 17:11:08 +08:00
|
|
|
case DiagnosticsEngine::Remark: OS.changeColor(remarkColor, true); break;
|
2011-10-16 07:48:02 +08:00
|
|
|
case DiagnosticsEngine::Warning: OS.changeColor(warningColor, true); break;
|
|
|
|
case DiagnosticsEngine::Error: OS.changeColor(errorColor, true); break;
|
|
|
|
case DiagnosticsEngine::Fatal: OS.changeColor(fatalColor, true); break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (Level) {
|
|
|
|
case DiagnosticsEngine::Ignored:
|
|
|
|
llvm_unreachable("Invalid diagnostic type");
|
2021-02-02 21:10:26 +08:00
|
|
|
case DiagnosticsEngine::Note: OS << "note: "; break;
|
|
|
|
case DiagnosticsEngine::Remark: OS << "remark: "; break;
|
|
|
|
case DiagnosticsEngine::Warning: OS << "warning: "; break;
|
|
|
|
case DiagnosticsEngine::Error: OS << "error: "; break;
|
|
|
|
case DiagnosticsEngine::Fatal: OS << "fatal error: "; break;
|
2011-10-16 07:48:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ShowColors)
|
|
|
|
OS.resetColor();
|
|
|
|
}
|
|
|
|
|
2014-06-22 07:31:52 +08:00
|
|
|
/*static*/
|
|
|
|
void TextDiagnostic::printDiagnosticMessage(raw_ostream &OS,
|
|
|
|
bool IsSupplemental,
|
|
|
|
StringRef Message,
|
|
|
|
unsigned CurrentColumn,
|
|
|
|
unsigned Columns, bool ShowColors) {
|
2012-06-29 06:39:03 +08:00
|
|
|
bool Bold = false;
|
2014-06-22 07:31:52 +08:00
|
|
|
if (ShowColors && !IsSupplemental) {
|
|
|
|
// Print primary diagnostic messages in bold and without color, to visually
|
|
|
|
// indicate the transition from continuation notes and other output.
|
|
|
|
OS.changeColor(savedColor, true);
|
|
|
|
Bold = true;
|
2011-10-16 07:48:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (Columns)
|
2012-06-29 06:39:03 +08:00
|
|
|
printWordWrapped(OS, Message, Columns, CurrentColumn, Bold);
|
2012-06-29 05:46:07 +08:00
|
|
|
else {
|
|
|
|
bool Normal = true;
|
2012-06-29 06:39:03 +08:00
|
|
|
applyTemplateHighlighting(OS, Message, Normal, Bold);
|
2012-06-29 05:46:07 +08:00
|
|
|
assert(Normal && "Formatting should have returned to normal");
|
|
|
|
}
|
2011-10-16 07:48:02 +08:00
|
|
|
|
|
|
|
if (ShowColors)
|
|
|
|
OS.resetColor();
|
|
|
|
OS << '\n';
|
|
|
|
}
|
|
|
|
|
2016-08-26 23:45:36 +08:00
|
|
|
void TextDiagnostic::emitFilename(StringRef Filename, const SourceManager &SM) {
|
2019-12-20 15:07:22 +08:00
|
|
|
#ifdef _WIN32
|
|
|
|
SmallString<4096> TmpFilename;
|
|
|
|
#endif
|
2016-08-26 23:45:36 +08:00
|
|
|
if (DiagOpts->AbsolutePath) {
|
2019-12-20 15:07:22 +08:00
|
|
|
auto File = SM.getFileManager().getFile(Filename);
|
|
|
|
if (File) {
|
2019-05-24 12:46:22 +08:00
|
|
|
// We want to print a simplified absolute path, i. e. without "dots".
|
|
|
|
//
|
|
|
|
// The hardest part here are the paths like "<part1>/<link>/../<part2>".
|
|
|
|
// On Unix-like systems, we cannot just collapse "<link>/..", because
|
|
|
|
// paths are resolved sequentially, and, thereby, the path
|
|
|
|
// "<part1>/<part2>" may point to a different location. That is why
|
|
|
|
// we use FileManager::getCanonicalName(), which expands all indirections
|
|
|
|
// with llvm::sys::fs::real_path() and caches the result.
|
|
|
|
//
|
|
|
|
// On the other hand, it would be better to preserve as much of the
|
|
|
|
// original path as possible, because that helps a user to recognize it.
|
|
|
|
// real_path() expands all links, which sometimes too much. Luckily,
|
|
|
|
// on Windows we can just use llvm::sys::path::remove_dots(), because,
|
|
|
|
// on that system, both aforementioned paths point to the same place.
|
|
|
|
#ifdef _WIN32
|
2019-12-20 15:07:22 +08:00
|
|
|
TmpFilename = (*File)->getName();
|
|
|
|
llvm::sys::fs::make_absolute(TmpFilename);
|
|
|
|
llvm::sys::path::native(TmpFilename);
|
|
|
|
llvm::sys::path::remove_dots(TmpFilename, /* remove_dot_dot */ true);
|
|
|
|
Filename = StringRef(TmpFilename.data(), TmpFilename.size());
|
2019-05-24 12:46:22 +08:00
|
|
|
#else
|
2019-12-20 15:07:22 +08:00
|
|
|
Filename = SM.getFileManager().getCanonicalName(*File);
|
2019-05-24 12:46:22 +08:00
|
|
|
#endif
|
2016-08-26 23:45:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
OS << Filename;
|
|
|
|
}
|
|
|
|
|
2018-05-09 09:00:01 +08:00
|
|
|
/// Print out the file/line/column information and include trace.
|
2011-10-16 07:48:02 +08:00
|
|
|
///
|
|
|
|
/// This method handlen the emission of the diagnostic location information.
|
|
|
|
/// This includes extracting as much location information as is present for
|
|
|
|
/// the diagnostic and printing it, as well as any include stack or source
|
|
|
|
/// ranges necessary.
|
2017-06-27 17:50:38 +08:00
|
|
|
void TextDiagnostic::emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
|
2011-10-16 07:48:02 +08:00
|
|
|
DiagnosticsEngine::Level Level,
|
2017-06-27 17:50:38 +08:00
|
|
|
ArrayRef<CharSourceRange> Ranges) {
|
2011-10-16 07:48:02 +08:00
|
|
|
if (PLoc.isInvalid()) {
|
|
|
|
// At least print the file name if available:
|
2017-06-27 17:50:38 +08:00
|
|
|
FileID FID = Loc.getFileID();
|
2015-10-03 18:46:20 +08:00
|
|
|
if (FID.isValid()) {
|
2017-06-27 17:50:38 +08:00
|
|
|
const FileEntry *FE = Loc.getFileEntry();
|
2014-02-28 01:23:33 +08:00
|
|
|
if (FE && FE->isValid()) {
|
2017-06-27 17:50:38 +08:00
|
|
|
emitFilename(FE->getName(), Loc.getManager());
|
2011-10-16 07:48:02 +08:00
|
|
|
OS << ": ";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
unsigned LineNo = PLoc.getLine();
|
|
|
|
|
2012-10-24 06:26:28 +08:00
|
|
|
if (!DiagOpts->ShowLocation)
|
2011-10-16 07:48:02 +08:00
|
|
|
return;
|
|
|
|
|
2012-10-24 06:26:28 +08:00
|
|
|
if (DiagOpts->ShowColors)
|
2011-10-16 07:48:02 +08:00
|
|
|
OS.changeColor(savedColor, true);
|
|
|
|
|
2017-06-27 17:50:38 +08:00
|
|
|
emitFilename(PLoc.getFilename(), Loc.getManager());
|
2012-10-24 07:11:23 +08:00
|
|
|
switch (DiagOpts->getFormat()) {
|
2020-11-05 22:41:09 +08:00
|
|
|
case DiagnosticOptions::Clang:
|
|
|
|
if (DiagOpts->ShowLine)
|
|
|
|
OS << ':' << LineNo;
|
|
|
|
break;
|
2015-02-03 03:30:52 +08:00
|
|
|
case DiagnosticOptions::MSVC: OS << '(' << LineNo; break;
|
2011-10-16 07:48:02 +08:00
|
|
|
case DiagnosticOptions::Vi: OS << " +" << LineNo; break;
|
|
|
|
}
|
|
|
|
|
2012-10-24 06:26:28 +08:00
|
|
|
if (DiagOpts->ShowColumn)
|
2011-10-16 07:48:02 +08:00
|
|
|
// Compute the column number.
|
|
|
|
if (unsigned ColNo = PLoc.getColumn()) {
|
2015-02-03 03:30:52 +08:00
|
|
|
if (DiagOpts->getFormat() == DiagnosticOptions::MSVC) {
|
2011-10-16 07:48:02 +08:00
|
|
|
OS << ',';
|
2014-03-07 08:23:36 +08:00
|
|
|
// Visual Studio 2010 or earlier expects column number to be off by one
|
2014-07-16 11:13:50 +08:00
|
|
|
if (LangOpts.MSCompatibilityVersion &&
|
2015-05-11 11:57:49 +08:00
|
|
|
!LangOpts.isCompatibleWithMSVC(LangOptions::MSVC2012))
|
2014-03-07 08:23:36 +08:00
|
|
|
ColNo--;
|
2011-10-16 07:48:02 +08:00
|
|
|
} else
|
|
|
|
OS << ':';
|
|
|
|
OS << ColNo;
|
|
|
|
}
|
2012-10-24 07:11:23 +08:00
|
|
|
switch (DiagOpts->getFormat()) {
|
2011-10-16 07:48:02 +08:00
|
|
|
case DiagnosticOptions::Clang:
|
|
|
|
case DiagnosticOptions::Vi: OS << ':'; break;
|
2016-03-24 06:57:55 +08:00
|
|
|
case DiagnosticOptions::MSVC:
|
|
|
|
// MSVC2013 and before print 'file(4) : error'. MSVC2015 gets rid of the
|
|
|
|
// space and prints 'file(4): error'.
|
|
|
|
OS << ')';
|
|
|
|
if (LangOpts.MSCompatibilityVersion &&
|
|
|
|
!LangOpts.isCompatibleWithMSVC(LangOptions::MSVC2015))
|
|
|
|
OS << ' ';
|
2019-02-20 00:58:25 +08:00
|
|
|
OS << ':';
|
2016-03-24 06:57:55 +08:00
|
|
|
break;
|
2011-10-16 07:48:02 +08:00
|
|
|
}
|
|
|
|
|
2012-10-24 06:26:28 +08:00
|
|
|
if (DiagOpts->ShowSourceRanges && !Ranges.empty()) {
|
2017-06-27 17:50:38 +08:00
|
|
|
FileID CaretFileID = Loc.getExpansionLoc().getFileID();
|
2011-10-16 07:48:02 +08:00
|
|
|
bool PrintedRange = false;
|
|
|
|
|
|
|
|
for (ArrayRef<CharSourceRange>::const_iterator RI = Ranges.begin(),
|
|
|
|
RE = Ranges.end();
|
|
|
|
RI != RE; ++RI) {
|
|
|
|
// Ignore invalid ranges.
|
|
|
|
if (!RI->isValid()) continue;
|
|
|
|
|
2018-04-30 13:25:48 +08:00
|
|
|
auto &SM = Loc.getManager();
|
|
|
|
SourceLocation B = SM.getExpansionLoc(RI->getBegin());
|
|
|
|
CharSourceRange ERange = SM.getExpansionRange(RI->getEnd());
|
|
|
|
SourceLocation E = ERange.getEnd();
|
|
|
|
bool IsTokenRange = ERange.isTokenRange();
|
|
|
|
|
|
|
|
std::pair<FileID, unsigned> BInfo = SM.getDecomposedLoc(B);
|
|
|
|
std::pair<FileID, unsigned> EInfo = SM.getDecomposedLoc(E);
|
2011-10-16 07:48:02 +08:00
|
|
|
|
|
|
|
// If the start or end of the range is in another file, just discard
|
|
|
|
// it.
|
|
|
|
if (BInfo.first != CaretFileID || EInfo.first != CaretFileID)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Add in the length of the token, so that we cover multi-char
|
|
|
|
// tokens.
|
|
|
|
unsigned TokSize = 0;
|
2018-04-30 13:25:48 +08:00
|
|
|
if (IsTokenRange)
|
|
|
|
TokSize = Lexer::MeasureTokenLength(E, SM, LangOpts);
|
|
|
|
|
|
|
|
FullSourceLoc BF(B, SM), EF(E, SM);
|
|
|
|
OS << '{'
|
|
|
|
<< BF.getLineNumber() << ':' << BF.getColumnNumber() << '-'
|
|
|
|
<< EF.getLineNumber() << ':' << (EF.getColumnNumber() + TokSize)
|
|
|
|
<< '}';
|
2011-10-16 07:48:02 +08:00
|
|
|
PrintedRange = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (PrintedRange)
|
|
|
|
OS << ':';
|
|
|
|
}
|
|
|
|
OS << ' ';
|
|
|
|
}
|
|
|
|
|
2017-06-27 17:50:38 +08:00
|
|
|
void TextDiagnostic::emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc) {
|
2016-04-29 02:26:32 +08:00
|
|
|
if (DiagOpts->ShowLocation && PLoc.isValid())
|
2011-12-17 13:26:04 +08:00
|
|
|
OS << "In file included from " << PLoc.getFilename() << ':'
|
|
|
|
<< PLoc.getLine() << ":\n";
|
|
|
|
else
|
2018-07-31 03:24:48 +08:00
|
|
|
OS << "In included file:\n";
|
2011-10-16 07:43:53 +08:00
|
|
|
}
|
|
|
|
|
2017-06-27 17:50:38 +08:00
|
|
|
void TextDiagnostic::emitImportLocation(FullSourceLoc Loc, PresumedLoc PLoc,
|
|
|
|
StringRef ModuleName) {
|
2016-04-29 02:26:32 +08:00
|
|
|
if (DiagOpts->ShowLocation && PLoc.isValid())
|
2012-12-01 05:58:49 +08:00
|
|
|
OS << "In module '" << ModuleName << "' imported from "
|
|
|
|
<< PLoc.getFilename() << ':' << PLoc.getLine() << ":\n";
|
|
|
|
else
|
2015-08-11 08:05:21 +08:00
|
|
|
OS << "In module '" << ModuleName << "':\n";
|
2012-12-01 05:58:49 +08:00
|
|
|
}
|
|
|
|
|
2017-06-27 17:50:38 +08:00
|
|
|
void TextDiagnostic::emitBuildingModuleLocation(FullSourceLoc Loc,
|
2012-12-01 02:38:50 +08:00
|
|
|
PresumedLoc PLoc,
|
2017-06-27 17:50:38 +08:00
|
|
|
StringRef ModuleName) {
|
2016-04-29 02:26:32 +08:00
|
|
|
if (DiagOpts->ShowLocation && PLoc.isValid())
|
2012-12-01 02:38:50 +08:00
|
|
|
OS << "While building module '" << ModuleName << "' imported from "
|
|
|
|
<< PLoc.getFilename() << ':' << PLoc.getLine() << ":\n";
|
|
|
|
else
|
|
|
|
OS << "While building module '" << ModuleName << "':\n";
|
|
|
|
}
|
|
|
|
|
2018-05-09 09:00:01 +08:00
|
|
|
/// Find the suitable set of lines to show to include a set of ranges.
|
2017-05-23 07:51:40 +08:00
|
|
|
static llvm::Optional<std::pair<unsigned, unsigned>>
|
|
|
|
findLinesForRange(const CharSourceRange &R, FileID FID,
|
|
|
|
const SourceManager &SM) {
|
|
|
|
if (!R.isValid()) return None;
|
|
|
|
|
|
|
|
SourceLocation Begin = R.getBegin();
|
|
|
|
SourceLocation End = R.getEnd();
|
|
|
|
if (SM.getFileID(Begin) != FID || SM.getFileID(End) != FID)
|
|
|
|
return None;
|
|
|
|
|
|
|
|
return std::make_pair(SM.getExpansionLineNumber(Begin),
|
|
|
|
SM.getExpansionLineNumber(End));
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Add as much of range B into range A as possible without exceeding a maximum
|
|
|
|
/// size of MaxRange. Ranges are inclusive.
|
2017-05-27 04:08:24 +08:00
|
|
|
static std::pair<unsigned, unsigned>
|
|
|
|
maybeAddRange(std::pair<unsigned, unsigned> A, std::pair<unsigned, unsigned> B,
|
|
|
|
unsigned MaxRange) {
|
2017-05-23 07:51:40 +08:00
|
|
|
// If A is already the maximum size, we're done.
|
|
|
|
unsigned Slack = MaxRange - (A.second - A.first + 1);
|
|
|
|
if (Slack == 0)
|
|
|
|
return A;
|
|
|
|
|
|
|
|
// Easy case: merge succeeds within MaxRange.
|
|
|
|
unsigned Min = std::min(A.first, B.first);
|
|
|
|
unsigned Max = std::max(A.second, B.second);
|
|
|
|
if (Max - Min + 1 <= MaxRange)
|
|
|
|
return {Min, Max};
|
|
|
|
|
|
|
|
// If we can't reach B from A within MaxRange, there's nothing to do.
|
|
|
|
// Don't add lines to the range that contain nothing interesting.
|
|
|
|
if ((B.first > A.first && B.first - A.first + 1 > MaxRange) ||
|
|
|
|
(B.second < A.second && A.second - B.second + 1 > MaxRange))
|
|
|
|
return A;
|
|
|
|
|
|
|
|
// Otherwise, expand A towards B to produce a range of size MaxRange. We
|
|
|
|
// attempt to expand by the same amount in both directions if B strictly
|
|
|
|
// contains A.
|
|
|
|
|
|
|
|
// Expand downwards by up to half the available amount, then upwards as
|
|
|
|
// much as possible, then downwards as much as possible.
|
|
|
|
A.second = std::min(A.second + (Slack + 1) / 2, Max);
|
|
|
|
Slack = MaxRange - (A.second - A.first + 1);
|
|
|
|
A.first = std::max(Min + Slack, A.first) - Slack;
|
|
|
|
A.second = std::min(A.first + MaxRange - 1, Max);
|
|
|
|
return A;
|
|
|
|
}
|
|
|
|
|
2018-05-09 09:00:01 +08:00
|
|
|
/// Highlight a SourceRange (with ~'s) for any characters on LineNo.
|
2012-12-02 04:58:01 +08:00
|
|
|
static void highlightRange(const CharSourceRange &R,
|
|
|
|
unsigned LineNo, FileID FID,
|
|
|
|
const SourceColumnMap &map,
|
|
|
|
std::string &CaretLine,
|
|
|
|
const SourceManager &SM,
|
|
|
|
const LangOptions &LangOpts) {
|
|
|
|
if (!R.isValid()) return;
|
|
|
|
|
|
|
|
SourceLocation Begin = R.getBegin();
|
|
|
|
SourceLocation End = R.getEnd();
|
|
|
|
|
|
|
|
unsigned StartLineNo = SM.getExpansionLineNumber(Begin);
|
|
|
|
if (StartLineNo > LineNo || SM.getFileID(Begin) != FID)
|
|
|
|
return; // No intersection.
|
|
|
|
|
|
|
|
unsigned EndLineNo = SM.getExpansionLineNumber(End);
|
|
|
|
if (EndLineNo < LineNo || SM.getFileID(End) != FID)
|
|
|
|
return; // No intersection.
|
|
|
|
|
|
|
|
// Compute the column number of the start.
|
|
|
|
unsigned StartColNo = 0;
|
|
|
|
if (StartLineNo == LineNo) {
|
|
|
|
StartColNo = SM.getExpansionColumnNumber(Begin);
|
|
|
|
if (StartColNo) --StartColNo; // Zero base the col #.
|
|
|
|
}
|
|
|
|
|
|
|
|
// Compute the column number of the end.
|
|
|
|
unsigned EndColNo = map.getSourceLine().size();
|
|
|
|
if (EndLineNo == LineNo) {
|
|
|
|
EndColNo = SM.getExpansionColumnNumber(End);
|
|
|
|
if (EndColNo) {
|
|
|
|
--EndColNo; // Zero base the col #.
|
|
|
|
|
|
|
|
// Add in the length of the token, so that we cover multi-char tokens if
|
|
|
|
// this is a token range.
|
|
|
|
if (R.isTokenRange())
|
|
|
|
EndColNo += Lexer::MeasureTokenLength(End, SM, LangOpts);
|
|
|
|
} else {
|
|
|
|
EndColNo = CaretLine.size();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(StartColNo <= EndColNo && "Invalid range!");
|
|
|
|
|
|
|
|
// Check that a token range does not highlight only whitespace.
|
|
|
|
if (R.isTokenRange()) {
|
|
|
|
// Pick the first non-whitespace column.
|
|
|
|
while (StartColNo < map.getSourceLine().size() &&
|
|
|
|
(map.getSourceLine()[StartColNo] == ' ' ||
|
|
|
|
map.getSourceLine()[StartColNo] == '\t'))
|
|
|
|
StartColNo = map.startOfNextColumn(StartColNo);
|
|
|
|
|
|
|
|
// Pick the last non-whitespace column.
|
|
|
|
if (EndColNo > map.getSourceLine().size())
|
|
|
|
EndColNo = map.getSourceLine().size();
|
2013-03-16 07:09:37 +08:00
|
|
|
while (EndColNo &&
|
2012-12-02 04:58:01 +08:00
|
|
|
(map.getSourceLine()[EndColNo-1] == ' ' ||
|
|
|
|
map.getSourceLine()[EndColNo-1] == '\t'))
|
|
|
|
EndColNo = map.startOfPreviousColumn(EndColNo);
|
|
|
|
|
|
|
|
// If the start/end passed each other, then we are trying to highlight a
|
2017-05-23 07:51:40 +08:00
|
|
|
// range that just exists in whitespace. That most likely means we have
|
|
|
|
// a multi-line highlighting range that covers a blank line.
|
|
|
|
if (StartColNo > EndColNo) {
|
|
|
|
assert(StartLineNo != EndLineNo && "trying to highlight whitespace");
|
|
|
|
StartColNo = EndColNo;
|
|
|
|
}
|
2012-12-02 04:58:01 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
assert(StartColNo <= map.getSourceLine().size() && "Invalid range!");
|
|
|
|
assert(EndColNo <= map.getSourceLine().size() && "Invalid range!");
|
|
|
|
|
|
|
|
// Fill the range with ~'s.
|
|
|
|
StartColNo = map.byteToContainingColumn(StartColNo);
|
|
|
|
EndColNo = map.byteToContainingColumn(EndColNo);
|
|
|
|
|
|
|
|
assert(StartColNo <= EndColNo && "Invalid range!");
|
|
|
|
if (CaretLine.size() < EndColNo)
|
|
|
|
CaretLine.resize(EndColNo,' ');
|
|
|
|
std::fill(CaretLine.begin()+StartColNo,CaretLine.begin()+EndColNo,'~');
|
|
|
|
}
|
|
|
|
|
2017-07-13 00:25:40 +08:00
|
|
|
static std::string buildFixItInsertionLine(FileID FID,
|
|
|
|
unsigned LineNo,
|
2012-12-02 04:58:01 +08:00
|
|
|
const SourceColumnMap &map,
|
|
|
|
ArrayRef<FixItHint> Hints,
|
|
|
|
const SourceManager &SM,
|
|
|
|
const DiagnosticOptions *DiagOpts) {
|
|
|
|
std::string FixItInsertionLine;
|
|
|
|
if (Hints.empty() || !DiagOpts->ShowFixits)
|
|
|
|
return FixItInsertionLine;
|
|
|
|
unsigned PrevHintEndCol = 0;
|
|
|
|
|
|
|
|
for (ArrayRef<FixItHint>::iterator I = Hints.begin(), E = Hints.end();
|
|
|
|
I != E; ++I) {
|
|
|
|
if (!I->CodeToInsert.empty()) {
|
|
|
|
// We have an insertion hint. Determine whether the inserted
|
|
|
|
// code contains no newlines and is on the same line as the caret.
|
|
|
|
std::pair<FileID, unsigned> HintLocInfo
|
|
|
|
= SM.getDecomposedExpansionLoc(I->RemoveRange.getBegin());
|
2017-07-13 00:25:40 +08:00
|
|
|
if (FID == HintLocInfo.first &&
|
|
|
|
LineNo == SM.getLineNumber(HintLocInfo.first, HintLocInfo.second) &&
|
2012-12-02 04:58:01 +08:00
|
|
|
StringRef(I->CodeToInsert).find_first_of("\n\r") == StringRef::npos) {
|
|
|
|
// Insert the new code into the line just below the code
|
|
|
|
// that the user wrote.
|
|
|
|
// Note: When modifying this function, be very careful about what is a
|
|
|
|
// "column" (printed width, platform-dependent) and what is a
|
|
|
|
// "byte offset" (SourceManager "column").
|
|
|
|
unsigned HintByteOffset
|
|
|
|
= SM.getColumnNumber(HintLocInfo.first, HintLocInfo.second) - 1;
|
|
|
|
|
|
|
|
// The hint must start inside the source or right at the end
|
|
|
|
assert(HintByteOffset < static_cast<unsigned>(map.bytes())+1);
|
|
|
|
unsigned HintCol = map.byteToContainingColumn(HintByteOffset);
|
|
|
|
|
|
|
|
// If we inserted a long previous hint, push this one forwards, and add
|
|
|
|
// an extra space to show that this is not part of the previous
|
|
|
|
// completion. This is sort of the best we can do when two hints appear
|
|
|
|
// to overlap.
|
|
|
|
//
|
|
|
|
// Note that if this hint is located immediately after the previous
|
|
|
|
// hint, no space will be added, since the location is more important.
|
|
|
|
if (HintCol < PrevHintEndCol)
|
|
|
|
HintCol = PrevHintEndCol + 1;
|
|
|
|
|
|
|
|
// This should NOT use HintByteOffset, because the source might have
|
|
|
|
// Unicode characters in earlier columns.
|
2013-06-08 01:16:01 +08:00
|
|
|
unsigned NewFixItLineSize = FixItInsertionLine.size() +
|
|
|
|
(HintCol - PrevHintEndCol) + I->CodeToInsert.size();
|
|
|
|
if (NewFixItLineSize > FixItInsertionLine.size())
|
|
|
|
FixItInsertionLine.resize(NewFixItLineSize, ' ');
|
2012-12-02 04:58:01 +08:00
|
|
|
|
|
|
|
std::copy(I->CodeToInsert.begin(), I->CodeToInsert.end(),
|
2013-06-08 01:16:01 +08:00
|
|
|
FixItInsertionLine.end() - I->CodeToInsert.size());
|
2012-12-02 04:58:01 +08:00
|
|
|
|
2013-06-08 01:16:01 +08:00
|
|
|
PrevHintEndCol =
|
|
|
|
HintCol + llvm::sys::locale::columnWidth(I->CodeToInsert);
|
2012-12-02 04:58:01 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
expandTabs(FixItInsertionLine, DiagOpts->TabStop);
|
|
|
|
|
|
|
|
return FixItInsertionLine;
|
|
|
|
}
|
|
|
|
|
2018-05-09 09:00:01 +08:00
|
|
|
/// Emit a code snippet and caret line.
|
2011-10-16 07:43:53 +08:00
|
|
|
///
|
|
|
|
/// This routine emits a single line's code snippet and caret line..
|
|
|
|
///
|
|
|
|
/// \param Loc The location for the caret.
|
|
|
|
/// \param Ranges The underlined ranges for this code snippet.
|
|
|
|
/// \param Hints The FixIt hints active for this diagnostic.
|
2011-10-16 07:54:09 +08:00
|
|
|
void TextDiagnostic::emitSnippetAndCaret(
|
2017-06-27 17:50:38 +08:00
|
|
|
FullSourceLoc Loc, DiagnosticsEngine::Level Level,
|
|
|
|
SmallVectorImpl<CharSourceRange> &Ranges, ArrayRef<FixItHint> Hints) {
|
2015-10-03 13:15:57 +08:00
|
|
|
assert(Loc.isValid() && "must have a valid source location here");
|
2011-10-16 07:43:53 +08:00
|
|
|
assert(Loc.isFileID() && "must have a file location here");
|
|
|
|
|
2011-10-16 15:20:28 +08:00
|
|
|
// If caret diagnostics are enabled and we have location, we want to
|
|
|
|
// emit the caret. However, we only do this if the location moved
|
|
|
|
// from the last diagnostic, if the last diagnostic was a note that
|
|
|
|
// was part of a different warning or error diagnostic, or if the
|
|
|
|
// diagnostic has ranges. We don't want to emit the same caret
|
|
|
|
// multiple times if one loc has multiple diagnostics.
|
2012-10-24 06:26:28 +08:00
|
|
|
if (!DiagOpts->ShowCarets)
|
2011-10-16 15:20:28 +08:00
|
|
|
return;
|
|
|
|
if (Loc == LastLoc && Ranges.empty() && Hints.empty() &&
|
|
|
|
(LastLevel != DiagnosticsEngine::Note || Level == LastLevel))
|
|
|
|
return;
|
|
|
|
|
2011-10-16 07:43:53 +08:00
|
|
|
// Decompose the location into a FID/Offset pair.
|
2017-06-27 17:50:38 +08:00
|
|
|
std::pair<FileID, unsigned> LocInfo = Loc.getDecomposedLoc();
|
2011-10-16 07:43:53 +08:00
|
|
|
FileID FID = LocInfo.first;
|
2017-06-27 17:50:38 +08:00
|
|
|
const SourceManager &SM = Loc.getManager();
|
2011-10-16 07:43:53 +08:00
|
|
|
|
|
|
|
// Get information about the buffer it points into.
|
|
|
|
bool Invalid = false;
|
2017-06-27 17:50:38 +08:00
|
|
|
StringRef BufData = Loc.getBufferData(&Invalid);
|
2011-10-16 07:43:53 +08:00
|
|
|
if (Invalid)
|
|
|
|
return;
|
|
|
|
|
2017-06-27 17:50:38 +08:00
|
|
|
unsigned CaretLineNo = Loc.getLineNumber();
|
|
|
|
unsigned CaretColNo = Loc.getColumnNumber();
|
2016-02-18 06:37:45 +08:00
|
|
|
|
2013-01-31 05:41:07 +08:00
|
|
|
// Arbitrarily stop showing snippets when the line is too long.
|
2013-04-23 22:42:47 +08:00
|
|
|
static const size_t MaxLineLengthToPrint = 4096;
|
2017-05-23 07:51:40 +08:00
|
|
|
if (CaretColNo > MaxLineLengthToPrint)
|
2013-01-31 05:41:07 +08:00
|
|
|
return;
|
2011-10-16 07:43:53 +08:00
|
|
|
|
2017-05-23 07:51:40 +08:00
|
|
|
// Find the set of lines to include.
|
|
|
|
const unsigned MaxLines = DiagOpts->SnippetLineLimit;
|
|
|
|
std::pair<unsigned, unsigned> Lines = {CaretLineNo, CaretLineNo};
|
2011-10-16 07:43:53 +08:00
|
|
|
for (SmallVectorImpl<CharSourceRange>::iterator I = Ranges.begin(),
|
|
|
|
E = Ranges.end();
|
|
|
|
I != E; ++I)
|
2017-05-23 07:51:40 +08:00
|
|
|
if (auto OptionalRange = findLinesForRange(*I, FID, SM))
|
|
|
|
Lines = maybeAddRange(Lines, *OptionalRange, MaxLines);
|
|
|
|
|
|
|
|
for (unsigned LineNo = Lines.first; LineNo != Lines.second + 1; ++LineNo) {
|
|
|
|
const char *BufStart = BufData.data();
|
|
|
|
const char *BufEnd = BufStart + BufData.size();
|
|
|
|
|
|
|
|
// Rewind from the current position to the start of the line.
|
|
|
|
const char *LineStart =
|
|
|
|
BufStart +
|
|
|
|
SM.getDecomposedLoc(SM.translateLineCol(FID, LineNo, 1)).second;
|
|
|
|
if (LineStart == BufEnd)
|
|
|
|
break;
|
2011-10-16 07:43:53 +08:00
|
|
|
|
2017-05-23 07:51:40 +08:00
|
|
|
// Compute the line end.
|
|
|
|
const char *LineEnd = LineStart;
|
|
|
|
while (*LineEnd != '\n' && *LineEnd != '\r' && LineEnd != BufEnd)
|
|
|
|
++LineEnd;
|
|
|
|
|
|
|
|
// Arbitrarily stop showing snippets when the line is too long.
|
|
|
|
// FIXME: Don't print any lines in this case.
|
|
|
|
if (size_t(LineEnd - LineStart) > MaxLineLengthToPrint)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Trim trailing null-bytes.
|
|
|
|
StringRef Line(LineStart, LineEnd - LineStart);
|
|
|
|
while (!Line.empty() && Line.back() == '\0' &&
|
|
|
|
(LineNo != CaretLineNo || Line.size() > CaretColNo))
|
|
|
|
Line = Line.drop_back();
|
|
|
|
|
|
|
|
// Copy the line of code into an std::string for ease of manipulation.
|
|
|
|
std::string SourceLine(Line.begin(), Line.end());
|
|
|
|
|
|
|
|
// Build the byte to column map.
|
|
|
|
const SourceColumnMap sourceColMap(SourceLine, DiagOpts->TabStop);
|
|
|
|
|
|
|
|
// Create a line for the caret that is filled with spaces that is the same
|
|
|
|
// number of columns as the line of source code.
|
|
|
|
std::string CaretLine(sourceColMap.columns(), ' ');
|
|
|
|
|
|
|
|
// Highlight all of the characters covered by Ranges with ~ characters.
|
|
|
|
for (SmallVectorImpl<CharSourceRange>::iterator I = Ranges.begin(),
|
|
|
|
E = Ranges.end();
|
|
|
|
I != E; ++I)
|
|
|
|
highlightRange(*I, LineNo, FID, sourceColMap, CaretLine, SM, LangOpts);
|
|
|
|
|
|
|
|
// Next, insert the caret itself.
|
|
|
|
if (CaretLineNo == LineNo) {
|
|
|
|
CaretColNo = sourceColMap.byteToContainingColumn(CaretColNo - 1);
|
|
|
|
if (CaretLine.size() < CaretColNo + 1)
|
|
|
|
CaretLine.resize(CaretColNo + 1, ' ');
|
|
|
|
CaretLine[CaretColNo] = '^';
|
|
|
|
}
|
2011-10-16 07:43:53 +08:00
|
|
|
|
2017-05-23 07:51:40 +08:00
|
|
|
std::string FixItInsertionLine = buildFixItInsertionLine(
|
2017-07-13 00:25:40 +08:00
|
|
|
FID, LineNo, sourceColMap, Hints, SM, DiagOpts.get());
|
2017-05-23 07:51:40 +08:00
|
|
|
|
|
|
|
// If the source line is too long for our terminal, select only the
|
|
|
|
// "interesting" source region within that line.
|
|
|
|
unsigned Columns = DiagOpts->MessageLength;
|
|
|
|
if (Columns)
|
|
|
|
selectInterestingSourceRegion(SourceLine, CaretLine, FixItInsertionLine,
|
|
|
|
Columns, sourceColMap);
|
|
|
|
|
|
|
|
// If we are in -fdiagnostics-print-source-range-info mode, we are trying
|
|
|
|
// to produce easily machine parsable output. Add a space before the
|
|
|
|
// source line and the caret to make it trivial to tell the main diagnostic
|
|
|
|
// line from what the user is intended to see.
|
|
|
|
if (DiagOpts->ShowSourceRanges) {
|
|
|
|
SourceLine = ' ' + SourceLine;
|
|
|
|
CaretLine = ' ' + CaretLine;
|
|
|
|
}
|
2011-10-16 07:43:53 +08:00
|
|
|
|
2017-05-23 07:51:40 +08:00
|
|
|
// Finally, remove any blank spaces from the end of CaretLine.
|
2017-05-24 04:48:21 +08:00
|
|
|
while (!CaretLine.empty() && CaretLine[CaretLine.size() - 1] == ' ')
|
2017-05-23 07:51:40 +08:00
|
|
|
CaretLine.erase(CaretLine.end() - 1);
|
2011-10-16 07:43:53 +08:00
|
|
|
|
2017-05-23 07:51:40 +08:00
|
|
|
// Emit what we have computed.
|
|
|
|
emitSnippet(SourceLine);
|
|
|
|
|
|
|
|
if (!CaretLine.empty()) {
|
|
|
|
if (DiagOpts->ShowColors)
|
|
|
|
OS.changeColor(caretColor, true);
|
|
|
|
OS << CaretLine << '\n';
|
|
|
|
if (DiagOpts->ShowColors)
|
|
|
|
OS.resetColor();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!FixItInsertionLine.empty()) {
|
|
|
|
if (DiagOpts->ShowColors)
|
|
|
|
// Print fixit line in color
|
|
|
|
OS.changeColor(fixitColor, false);
|
|
|
|
if (DiagOpts->ShowSourceRanges)
|
|
|
|
OS << ' ';
|
|
|
|
OS << FixItInsertionLine << '\n';
|
|
|
|
if (DiagOpts->ShowColors)
|
|
|
|
OS.resetColor();
|
|
|
|
}
|
2011-10-16 07:43:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Print out any parseable fixit information requested by the options.
|
2012-05-10 13:03:45 +08:00
|
|
|
emitParseableFixits(Hints, SM);
|
2011-10-16 07:43:53 +08:00
|
|
|
}
|
|
|
|
|
2012-05-01 22:34:11 +08:00
|
|
|
void TextDiagnostic::emitSnippet(StringRef line) {
|
2012-04-18 10:44:46 +08:00
|
|
|
if (line.empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
size_t i = 0;
|
2018-07-31 03:24:48 +08:00
|
|
|
|
2012-04-18 10:44:46 +08:00
|
|
|
std::string to_print;
|
|
|
|
bool print_reversed = false;
|
2018-07-31 03:24:48 +08:00
|
|
|
|
2012-04-18 10:44:46 +08:00
|
|
|
while (i<line.size()) {
|
|
|
|
std::pair<SmallString<16>,bool> res
|
2012-10-24 06:26:28 +08:00
|
|
|
= printableTextForNextCharacter(line, &i, DiagOpts->TabStop);
|
2012-04-18 10:44:46 +08:00
|
|
|
bool was_printable = res.second;
|
2018-07-31 03:24:48 +08:00
|
|
|
|
2012-10-24 06:26:28 +08:00
|
|
|
if (DiagOpts->ShowColors && was_printable == print_reversed) {
|
2012-04-18 10:44:46 +08:00
|
|
|
if (print_reversed)
|
|
|
|
OS.reverseColor();
|
|
|
|
OS << to_print;
|
|
|
|
to_print.clear();
|
2012-10-24 06:26:28 +08:00
|
|
|
if (DiagOpts->ShowColors)
|
2012-04-18 10:44:46 +08:00
|
|
|
OS.resetColor();
|
|
|
|
}
|
2018-07-31 03:24:48 +08:00
|
|
|
|
2012-04-18 10:44:46 +08:00
|
|
|
print_reversed = !was_printable;
|
|
|
|
to_print += res.first.str();
|
|
|
|
}
|
2018-07-31 03:24:48 +08:00
|
|
|
|
2012-10-24 06:26:28 +08:00
|
|
|
if (print_reversed && DiagOpts->ShowColors)
|
2012-04-18 10:44:46 +08:00
|
|
|
OS.reverseColor();
|
|
|
|
OS << to_print;
|
2012-10-24 06:26:28 +08:00
|
|
|
if (print_reversed && DiagOpts->ShowColors)
|
2012-04-18 10:44:46 +08:00
|
|
|
OS.resetColor();
|
2018-07-31 03:24:48 +08:00
|
|
|
|
2012-04-18 10:44:46 +08:00
|
|
|
OS << '\n';
|
|
|
|
}
|
|
|
|
|
2012-05-10 13:03:45 +08:00
|
|
|
void TextDiagnostic::emitParseableFixits(ArrayRef<FixItHint> Hints,
|
|
|
|
const SourceManager &SM) {
|
2012-10-24 06:26:28 +08:00
|
|
|
if (!DiagOpts->ShowParseableFixits)
|
2011-10-16 07:43:53 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
// We follow FixItRewriter's example in not (yet) handling
|
|
|
|
// fix-its in macros.
|
|
|
|
for (ArrayRef<FixItHint>::iterator I = Hints.begin(), E = Hints.end();
|
|
|
|
I != E; ++I) {
|
|
|
|
if (I->RemoveRange.isInvalid() ||
|
|
|
|
I->RemoveRange.getBegin().isMacroID() ||
|
|
|
|
I->RemoveRange.getEnd().isMacroID())
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (ArrayRef<FixItHint>::iterator I = Hints.begin(), E = Hints.end();
|
|
|
|
I != E; ++I) {
|
|
|
|
SourceLocation BLoc = I->RemoveRange.getBegin();
|
|
|
|
SourceLocation ELoc = I->RemoveRange.getEnd();
|
|
|
|
|
|
|
|
std::pair<FileID, unsigned> BInfo = SM.getDecomposedLoc(BLoc);
|
|
|
|
std::pair<FileID, unsigned> EInfo = SM.getDecomposedLoc(ELoc);
|
|
|
|
|
|
|
|
// Adjust for token ranges.
|
|
|
|
if (I->RemoveRange.isTokenRange())
|
|
|
|
EInfo.second += Lexer::MeasureTokenLength(ELoc, SM, LangOpts);
|
|
|
|
|
|
|
|
// We specifically do not do word-wrapping or tab-expansion here,
|
|
|
|
// because this is supposed to be easy to parse.
|
|
|
|
PresumedLoc PLoc = SM.getPresumedLoc(BLoc);
|
|
|
|
if (PLoc.isInvalid())
|
|
|
|
break;
|
|
|
|
|
|
|
|
OS << "fix-it:\"";
|
|
|
|
OS.write_escaped(PLoc.getFilename());
|
|
|
|
OS << "\":{" << SM.getLineNumber(BInfo.first, BInfo.second)
|
|
|
|
<< ':' << SM.getColumnNumber(BInfo.first, BInfo.second)
|
|
|
|
<< '-' << SM.getLineNumber(EInfo.first, EInfo.second)
|
|
|
|
<< ':' << SM.getColumnNumber(EInfo.first, EInfo.second)
|
|
|
|
<< "}:\"";
|
|
|
|
OS.write_escaped(I->CodeToInsert);
|
|
|
|
OS << "\"\n";
|
|
|
|
}
|
|
|
|
}
|