maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/tools/libclang/CIndexDiagnostic.cpp

310 lines
11 KiB
C++
Raw Normal View History

Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
/*===-- CIndexDiagnostics.cpp - Diagnostics C Interface ---------*- C++ -*-===*\
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
|* *|
|* The LLVM Compiler Infrastructure *|
|* *|
|* This file is distributed under the University of Illinois Open Source *|
|* License. See LICENSE.TXT for details. *|
|* *|
|*===----------------------------------------------------------------------===*|
|* *|
|* Implements the diagnostic functions of the Clang C interface. *|
|* *|
\*===----------------------------------------------------------------------===*/
#include "CIndexDiagnostic.h"
#include "CIndexer.h"
Make definition of CXTranslationUnitImpl private to libclang. llvm-svn: 119585
2010-11-18 07:24:11 +08:00
#include "CXTranslationUnit.h"
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
#include "CXSourceLocation.h"
Move CXString creation/management routines into their own .cpp file and make the interpretation of its flags private. llvm-svn: 119319
2010-11-16 09:56:27 +08:00
#include "CXString.h"
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
Prune includes. llvm-svn: 101059
2010-04-13 03:45:50 +08:00
#include "clang/Frontend/ASTUnit.h"
Introduce serialization and deserialization of diagnostic information so that CIndex can report diagnostics through the normal mechanisms even when executing Clang in a separate process. This applies both when performing code completion and when using ASTs as an intermediary for clang_createTranslationUnitFromSourceFile(). The serialized format is not perfect at the moment, because it does not encapsulate macro-instantiation information. Instead, it maps all source locations back to the instantiation location. However, it does maintain source-range and fix-it information. To get perfect fidelity from the serialized format would require serializing a large chunk of the source manager; at present, it isn't clear if this code will live long enough for that to matter. llvm-svn: 94740
2010-01-28 14:00:51 +08:00
#include "clang/Frontend/FrontendDiagnostic.h"
Rework the CIndex API for displaying diagnostics. Instead of printing the diagnostics to a FILE*, return a CXString containing the formatted diagnostic. llvm-svn: 96823
2010-02-23 07:17:23 +08:00
#include "llvm/ADT/SmallString.h"
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
#include "llvm/ADT/Twine.h"
Introduce serialization and deserialization of diagnostic information so that CIndex can report diagnostics through the normal mechanisms even when executing Clang in a separate process. This applies both when performing code completion and when using ASTs as an intermediary for clang_createTranslationUnitFromSourceFile(). The serialized format is not perfect at the moment, because it does not encapsulate macro-instantiation information. Instead, it maps all source locations back to the instantiation location. However, it does maintain source-range and fix-it information. To get perfect fidelity from the serialized format would require serializing a large chunk of the source manager; at present, it isn't clear if this code will live long enough for that to matter. llvm-svn: 94740
2010-01-28 14:00:51 +08:00
#include "llvm/Support/MemoryBuffer.h"
Rework the CIndex API for displaying diagnostics. Instead of printing the diagnostics to a FILE*, return a CXString containing the formatted diagnostic. llvm-svn: 96823
2010-02-23 07:17:23 +08:00
#include "llvm/Support/raw_ostream.h"
Introduce serialization and deserialization of diagnostic information so that CIndex can report diagnostics through the normal mechanisms even when executing Clang in a separate process. This applies both when performing code completion and when using ASTs as an intermediary for clang_createTranslationUnitFromSourceFile(). The serialized format is not perfect at the moment, because it does not encapsulate macro-instantiation information. Instead, it maps all source locations back to the instantiation location. However, it does maintain source-range and fix-it information. To get perfect fidelity from the serialized format would require serializing a large chunk of the source manager; at present, it isn't clear if this code will live long enough for that to matter. llvm-svn: 94740
2010-01-28 14:00:51 +08:00
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
using namespace clang;
using namespace clang::cxloc;
Move createCXString() functions out of CIndexer and into the clang::cxstring namespace. We can much more succinctly refer to these functions this way. Also change the default behavior of createCXString(StringRef&) to duplicate the string. This is almost always what we want. The other case is where we pass a constant c-string, which uses the other version of createCXString(). llvm-svn: 96423
2010-02-17 08:41:08 +08:00
using namespace clang::cxstring;
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
using namespace llvm;
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
//-----------------------------------------------------------------------------
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
// C Interface Routines
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
//-----------------------------------------------------------------------------
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
extern "C" {
CIndex: Fix diagnostic callback to not return SourceLocations with a reference to a temporary LangOptions object. llvm-svn: 94928
2010-01-31 07:31:49 +08:00
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
unsigned clang_getNumDiagnostics(CXTranslationUnit Unit) {
Change CXTranslationUnit to not directly cast to an ASTUnit*, but to wrap both an ASTUnit and a "string pool" that will be used for fast USR generation. This requires a bunch of mechanical changes, as there was a ton of code that assumed that CXTranslationUnit and ASTUnit* were the same. Along with this change, introduce CXStringBuf, which provides an llvm::SmallVector<char> backing for repeatedly generating CXStrings without a huge amount of malloc() traffic. This requires making some changes to the representation of CXString by renaming a few fields (but keeping the size of the object the same). llvm-svn: 119337
2010-11-16 16:15:36 +08:00
ASTUnit *CXXUnit = static_cast<ASTUnit *>(Unit->TUData);
Minor ASTUnit cleanups: - Rename "Diagnostics" and related to "StoredDiagnostics", to better capture what we're actually storing. - Move SourceManager and FileManager to the heap. llvm-svn: 100441
2010-04-06 02:10:21 +08:00
return CXXUnit? CXXUnit->stored_diag_size() : 0;
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
}
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
CXDiagnostic clang_getDiagnostic(CXTranslationUnit Unit, unsigned Index) {
Change CXTranslationUnit to not directly cast to an ASTUnit*, but to wrap both an ASTUnit and a "string pool" that will be used for fast USR generation. This requires a bunch of mechanical changes, as there was a ton of code that assumed that CXTranslationUnit and ASTUnit* were the same. Along with this change, introduce CXStringBuf, which provides an llvm::SmallVector<char> backing for repeatedly generating CXStrings without a huge amount of malloc() traffic. This requires making some changes to the representation of CXString by renaming a few fields (but keeping the size of the object the same). llvm-svn: 119337
2010-11-16 16:15:36 +08:00
ASTUnit *CXXUnit = static_cast<ASTUnit *>(Unit->TUData);
Minor ASTUnit cleanups: - Rename "Diagnostics" and related to "StoredDiagnostics", to better capture what we're actually storing. - Move SourceManager and FileManager to the heap. llvm-svn: 100441
2010-04-06 02:10:21 +08:00
if (!CXXUnit || Index >= CXXUnit->stored_diag_size())
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
return 0;
CIndex: Fix diagnostic callback to not return SourceLocations with a reference to a temporary LangOptions object. llvm-svn: 94928
2010-01-31 07:31:49 +08:00
Minor ASTUnit cleanups: - Rename "Diagnostics" and related to "StoredDiagnostics", to better capture what we're actually storing. - Move SourceManager and FileManager to the heap. llvm-svn: 100441
2010-04-06 02:10:21 +08:00
return new CXStoredDiagnostic(CXXUnit->stored_diag_begin()[Index],
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
CXXUnit->getASTContext().getLangOptions());
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
}
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
void clang_disposeDiagnostic(CXDiagnostic Diagnostic) {
CXStoredDiagnostic *Stored = static_cast<CXStoredDiagnostic *>(Diagnostic);
delete Stored;
}
Move createCXString() functions out of CIndexer and into the clang::cxstring namespace. We can much more succinctly refer to these functions this way. Also change the default behavior of createCXString(StringRef&) to duplicate the string. This is almost always what we want. The other case is where we pass a constant c-string, which uses the other version of createCXString(). llvm-svn: 96423
2010-02-17 08:41:08 +08:00
Rework the CIndex API for displaying diagnostics. Instead of printing the diagnostics to a FILE*, return a CXString containing the formatted diagnostic. llvm-svn: 96823
2010-02-23 07:17:23 +08:00
CXString clang_formatDiagnostic(CXDiagnostic Diagnostic, unsigned Options) {
if (!Diagnostic)
return createCXString("");
Re-apply my diagnostics-capture patch for CIndex, with some tweaks to try to address the msvc failures. llvm-svn: 96624
2010-02-19 07:07:20 +08:00
CXDiagnosticSeverity Severity = clang_getDiagnosticSeverity(Diagnostic);
Rework the CIndex API for displaying diagnostics. Instead of printing the diagnostics to a FILE*, return a CXString containing the formatted diagnostic. llvm-svn: 96823
2010-02-23 07:17:23 +08:00
llvm::SmallString<256> Str;
llvm::raw_svector_ostream Out(Str);
Re-apply my diagnostics-capture patch for CIndex, with some tweaks to try to address the msvc failures. llvm-svn: 96624
2010-02-19 07:07:20 +08:00
if (Options & CXDiagnostic_DisplaySourceLocation) {
// Print source location (file:line), along with optional column
// and source ranges.
CXFile File;
unsigned Line, Column;
ntroduce clang_getSpellingLocation() into libclang, to provide the location where we're spelling a token even within a macro. clang_getInstantiationLocation() tells where we instantiated the macro. I'm still not thrilled with the CXSourceLocation/CXSourceRange APIs, since they gloss over macro-instantiation information. Take 2: this time, adjusted tests appropriately and used a "simple" approach to the spelling location. llvm-svn: 118495
2010-11-09 14:24:54 +08:00
clang_getSpellingLocation(clang_getDiagnosticLocation(Diagnostic),
&File, &Line, &Column, 0);
Re-apply my diagnostics-capture patch for CIndex, with some tweaks to try to address the msvc failures. llvm-svn: 96624
2010-02-19 07:07:20 +08:00
if (File) {
CXString FName = clang_getFileName(File);
Rework the CIndex API for displaying diagnostics. Instead of printing the diagnostics to a FILE*, return a CXString containing the formatted diagnostic. llvm-svn: 96823
2010-02-23 07:17:23 +08:00
Out << clang_getCString(FName) << ":" << Line << ":";
Re-apply my diagnostics-capture patch for CIndex, with some tweaks to try to address the msvc failures. llvm-svn: 96624
2010-02-19 07:07:20 +08:00
clang_disposeString(FName);
if (Options & CXDiagnostic_DisplayColumn)
Rework the CIndex API for displaying diagnostics. Instead of printing the diagnostics to a FILE*, return a CXString containing the formatted diagnostic. llvm-svn: 96823
2010-02-23 07:17:23 +08:00
Out << Column << ":";
Re-apply my diagnostics-capture patch for CIndex, with some tweaks to try to address the msvc failures. llvm-svn: 96624
2010-02-19 07:07:20 +08:00
if (Options & CXDiagnostic_DisplaySourceRanges) {
unsigned N = clang_getDiagnosticNumRanges(Diagnostic);
bool PrintedRange = false;
for (unsigned I = 0; I != N; ++I) {
CXFile StartFile, EndFile;
CXSourceRange Range = clang_getDiagnosticRange(Diagnostic, I);
unsigned StartLine, StartColumn, EndLine, EndColumn;
ntroduce clang_getSpellingLocation() into libclang, to provide the location where we're spelling a token even within a macro. clang_getInstantiationLocation() tells where we instantiated the macro. I'm still not thrilled with the CXSourceLocation/CXSourceRange APIs, since they gloss over macro-instantiation information. Take 2: this time, adjusted tests appropriately and used a "simple" approach to the spelling location. llvm-svn: 118495
2010-11-09 14:24:54 +08:00
clang_getSpellingLocation(clang_getRangeStart(Range),
&StartFile, &StartLine, &StartColumn,
0);
clang_getSpellingLocation(clang_getRangeEnd(Range),
&EndFile, &EndLine, &EndColumn, 0);
Re-apply my diagnostics-capture patch for CIndex, with some tweaks to try to address the msvc failures. llvm-svn: 96624
2010-02-19 07:07:20 +08:00
if (StartFile != EndFile || StartFile != File)
continue;
Rework the CIndex API for displaying diagnostics. Instead of printing the diagnostics to a FILE*, return a CXString containing the formatted diagnostic. llvm-svn: 96823
2010-02-23 07:17:23 +08:00
Out << "{" << StartLine << ":" << StartColumn << "-"
<< EndLine << ":" << EndColumn << "}";
Re-apply my diagnostics-capture patch for CIndex, with some tweaks to try to address the msvc failures. llvm-svn: 96624
2010-02-19 07:07:20 +08:00
PrintedRange = true;
}
if (PrintedRange)
Rework the CIndex API for displaying diagnostics. Instead of printing the diagnostics to a FILE*, return a CXString containing the formatted diagnostic. llvm-svn: 96823
2010-02-23 07:17:23 +08:00
Out << ":";
Re-apply my diagnostics-capture patch for CIndex, with some tweaks to try to address the msvc failures. llvm-svn: 96624
2010-02-19 07:07:20 +08:00
}
When we load an ASTUnit from command-line arguments, hold on to the diagnostics produced by the driver itself. Previously, we were allowing these to either be dropped or to slip through to stderr. Fixes <rdar://problem/7595339>. llvm-svn: 116285
2010-10-12 08:50:20 +08:00
Out << " ";
Re-apply my diagnostics-capture patch for CIndex, with some tweaks to try to address the msvc failures. llvm-svn: 96624
2010-02-19 07:07:20 +08:00
}
}
/* Print warning/error/etc. */
switch (Severity) {
Removing a bunch of dead returns/breaks after llvm_unreachables. llvm-svn: 140407
2011-09-24 04:26:49 +08:00
case CXDiagnostic_Ignored: llvm_unreachable("impossible");
Rework the CIndex API for displaying diagnostics. Instead of printing the diagnostics to a FILE*, return a CXString containing the formatted diagnostic. llvm-svn: 96823
2010-02-23 07:17:23 +08:00
case CXDiagnostic_Note: Out << "note: "; break;
case CXDiagnostic_Warning: Out << "warning: "; break;
case CXDiagnostic_Error: Out << "error: "; break;
case CXDiagnostic_Fatal: Out << "fatal error: "; break;
Re-apply my diagnostics-capture patch for CIndex, with some tweaks to try to address the msvc failures. llvm-svn: 96624
2010-02-19 07:07:20 +08:00
}
CXString Text = clang_getDiagnosticSpelling(Diagnostic);
if (clang_getCString(Text))
Rework the CIndex API for displaying diagnostics. Instead of printing the diagnostics to a FILE*, return a CXString containing the formatted diagnostic. llvm-svn: 96823
2010-02-23 07:17:23 +08:00
Out << clang_getCString(Text);
Re-apply my diagnostics-capture patch for CIndex, with some tweaks to try to address the msvc failures. llvm-svn: 96624
2010-02-19 07:07:20 +08:00
else
Rework the CIndex API for displaying diagnostics. Instead of printing the diagnostics to a FILE*, return a CXString containing the formatted diagnostic. llvm-svn: 96823
2010-02-23 07:17:23 +08:00
Out << "<no diagnostic text>";
Re-apply my diagnostics-capture patch for CIndex, with some tweaks to try to address the msvc failures. llvm-svn: 96624
2010-02-19 07:07:20 +08:00
clang_disposeString(Text);
Extend the libclang diagnostic API to provide information about the option name, category ID, and category name corresponding to a diagnostic. llvm-svn: 119802
2010-11-20 00:18:16 +08:00
if (Options & (CXDiagnostic_DisplayOption | CXDiagnostic_DisplayCategoryId |
CXDiagnostic_DisplayCategoryName)) {
bool NeedBracket = true;
bool NeedComma = false;
if (Options & CXDiagnostic_DisplayOption) {
CXString OptionName = clang_getDiagnosticOption(Diagnostic, 0);
if (const char *OptionText = clang_getCString(OptionName)) {
if (OptionText[0]) {
Out << " [" << OptionText;
NeedBracket = false;
NeedComma = true;
}
}
clang_disposeString(OptionName);
}
if (Options & (CXDiagnostic_DisplayCategoryId |
CXDiagnostic_DisplayCategoryName)) {
if (unsigned CategoryID = clang_getDiagnosticCategory(Diagnostic)) {
if (Options & CXDiagnostic_DisplayCategoryId) {
if (NeedBracket)
Out << " [";
if (NeedComma)
Out << ", ";
Out << CategoryID;
NeedBracket = false;
NeedComma = true;
}
if (Options & CXDiagnostic_DisplayCategoryName) {
CXString CategoryName = clang_getDiagnosticCategoryName(CategoryID);
if (NeedBracket)
Out << " [";
if (NeedComma)
Out << ", ";
Out << clang_getCString(CategoryName);
NeedBracket = false;
NeedComma = true;
clang_disposeString(CategoryName);
}
}
}
if (!NeedBracket)
Out << "]";
}
Rework the CIndex API for displaying diagnostics. Instead of printing the diagnostics to a FILE*, return a CXString containing the formatted diagnostic. llvm-svn: 96823
2010-02-23 07:17:23 +08:00
return createCXString(Out.str(), true);
Re-apply my diagnostics-capture patch for CIndex, with some tweaks to try to address the msvc failures. llvm-svn: 96624
2010-02-19 07:07:20 +08:00
}
unsigned clang_defaultDiagnosticDisplayOptions() {
Extend the libclang diagnostic API to provide information about the option name, category ID, and category name corresponding to a diagnostic. llvm-svn: 119802
2010-11-20 00:18:16 +08:00
return CXDiagnostic_DisplaySourceLocation | CXDiagnostic_DisplayColumn |
CXDiagnostic_DisplayOption;
Re-apply my diagnostics-capture patch for CIndex, with some tweaks to try to address the msvc failures. llvm-svn: 96624
2010-02-19 07:07:20 +08:00
}
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
enum CXDiagnosticSeverity clang_getDiagnosticSeverity(CXDiagnostic Diag) {
CXStoredDiagnostic *StoredDiag = static_cast<CXStoredDiagnostic *>(Diag);
if (!StoredDiag)
return CXDiagnostic_Ignored;
Move createCXString() functions out of CIndexer and into the clang::cxstring namespace. We can much more succinctly refer to these functions this way. Also change the default behavior of createCXString(StringRef&) to duplicate the string. This is almost always what we want. The other case is where we pass a constant c-string, which uses the other version of createCXString(). llvm-svn: 96423
2010-02-17 08:41:08 +08:00
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
switch (StoredDiag->Diag.getLevel()) {
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
case DiagnosticsEngine::Ignored: return CXDiagnostic_Ignored;
case DiagnosticsEngine::Note: return CXDiagnostic_Note;
case DiagnosticsEngine::Warning: return CXDiagnostic_Warning;
case DiagnosticsEngine::Error: return CXDiagnostic_Error;
case DiagnosticsEngine::Fatal: return CXDiagnostic_Fatal;
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
}
Move createCXString() functions out of CIndexer and into the clang::cxstring namespace. We can much more succinctly refer to these functions this way. Also change the default behavior of createCXString(StringRef&) to duplicate the string. This is almost always what we want. The other case is where we pass a constant c-string, which uses the other version of createCXString(). llvm-svn: 96423
2010-02-17 08:41:08 +08:00
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
llvm_unreachable("Invalid diagnostic level");
return CXDiagnostic_Ignored;
}
Move createCXString() functions out of CIndexer and into the clang::cxstring namespace. We can much more succinctly refer to these functions this way. Also change the default behavior of createCXString(StringRef&) to duplicate the string. This is almost always what we want. The other case is where we pass a constant c-string, which uses the other version of createCXString(). llvm-svn: 96423
2010-02-17 08:41:08 +08:00
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
CXSourceLocation clang_getDiagnosticLocation(CXDiagnostic Diag) {
CXStoredDiagnostic *StoredDiag = static_cast<CXStoredDiagnostic *>(Diag);
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
if (!StoredDiag || StoredDiag->Diag.getLocation().isInvalid())
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
return clang_getNullLocation();
Move createCXString() functions out of CIndexer and into the clang::cxstring namespace. We can much more succinctly refer to these functions this way. Also change the default behavior of createCXString(StringRef&) to duplicate the string. This is almost always what we want. The other case is where we pass a constant c-string, which uses the other version of createCXString(). llvm-svn: 96423
2010-02-17 08:41:08 +08:00
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
return translateSourceLocation(StoredDiag->Diag.getLocation().getManager(),
StoredDiag->LangOpts,
StoredDiag->Diag.getLocation());
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
}
CXString clang_getDiagnosticSpelling(CXDiagnostic Diag) {
CXStoredDiagnostic *StoredDiag = static_cast<CXStoredDiagnostic *>(Diag);
if (!StoredDiag)
Move createCXString() functions out of CIndexer and into the clang::cxstring namespace. We can much more succinctly refer to these functions this way. Also change the default behavior of createCXString(StringRef&) to duplicate the string. This is almost always what we want. The other case is where we pass a constant c-string, which uses the other version of createCXString(). llvm-svn: 96423
2010-02-17 08:41:08 +08:00
return createCXString("");
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
return createCXString(StoredDiag->Diag.getMessage(), false);
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
}
Extend the libclang diagnostic API to provide information about the option name, category ID, and category name corresponding to a diagnostic. llvm-svn: 119802
2010-11-20 00:18:16 +08:00
CXString clang_getDiagnosticOption(CXDiagnostic Diag, CXString *Disable) {
if (Disable)
*Disable = createCXString("");
CXStoredDiagnostic *StoredDiag = static_cast<CXStoredDiagnostic *>(Diag);
if (!StoredDiag)
return createCXString("");
unsigned ID = StoredDiag->Diag.getID();
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef Option = DiagnosticIDs::getWarningOptionForDiag(ID);
A StringRef-ication of the DiagnosticIDs API and internals. Patch by Matthieu Monrocq with tweaks by me to avoid StringRefs in the static diagnostic data structures, which resulted in a huge global-var-init function. Depends on llvm commit r132046. llvm-svn: 132047
2011-05-25 13:05:01 +08:00
if (!Option.empty()) {
Extend the libclang diagnostic API to provide information about the option name, category ID, and category name corresponding to a diagnostic. llvm-svn: 119802
2010-11-20 00:18:16 +08:00
if (Disable)
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
*Disable = createCXString((Twine("-Wno-") + Option).str());
return createCXString((Twine("-W") + Option).str());
Extend the libclang diagnostic API to provide information about the option name, category ID, and category name corresponding to a diagnostic. llvm-svn: 119802
2010-11-20 00:18:16 +08:00
}
if (ID == diag::fatal_too_many_errors) {
if (Disable)
*Disable = createCXString("-ferror-limit=0");
return createCXString("-ferror-limit=");
}
bool EnabledByDefault;
if (DiagnosticIDs::isBuiltinExtensionDiag(ID, EnabledByDefault) &&
!EnabledByDefault)
return createCXString("-pedantic");
return createCXString("");
}
unsigned clang_getDiagnosticCategory(CXDiagnostic Diag) {
CXStoredDiagnostic *StoredDiag = static_cast<CXStoredDiagnostic *>(Diag);
if (!StoredDiag)
return 0;
return DiagnosticIDs::getCategoryNumberForDiag(StoredDiag->Diag.getID());
}
CXString clang_getDiagnosticCategoryName(unsigned Category) {
return createCXString(DiagnosticIDs::getCategoryNameFromID(Category));
}
Clean up the CIndex interface to diagnostic ranges. Thanks, Daniel! llvm-svn: 95602
2010-02-09 07:11:56 +08:00
unsigned clang_getDiagnosticNumRanges(CXDiagnostic Diag) {
CXStoredDiagnostic *StoredDiag = static_cast<CXStoredDiagnostic *>(Diag);
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
if (!StoredDiag || StoredDiag->Diag.getLocation().isInvalid())
Clean up the CIndex interface to diagnostic ranges. Thanks, Daniel! llvm-svn: 95602
2010-02-09 07:11:56 +08:00
return 0;
Move createCXString() functions out of CIndexer and into the clang::cxstring namespace. We can much more succinctly refer to these functions this way. Also change the default behavior of createCXString(StringRef&) to duplicate the string. This is almost always what we want. The other case is where we pass a constant c-string, which uses the other version of createCXString(). llvm-svn: 96423
2010-02-17 08:41:08 +08:00
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
return StoredDiag->Diag.range_size();
Clean up the CIndex interface to diagnostic ranges. Thanks, Daniel! llvm-svn: 95602
2010-02-09 07:11:56 +08:00
}
Move createCXString() functions out of CIndexer and into the clang::cxstring namespace. We can much more succinctly refer to these functions this way. Also change the default behavior of createCXString(StringRef&) to duplicate the string. This is almost always what we want. The other case is where we pass a constant c-string, which uses the other version of createCXString(). llvm-svn: 96423
2010-02-17 08:41:08 +08:00
Clean up the CIndex interface to diagnostic ranges. Thanks, Daniel! llvm-svn: 95602
2010-02-09 07:11:56 +08:00
CXSourceRange clang_getDiagnosticRange(CXDiagnostic Diag, unsigned Range) {
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
CXStoredDiagnostic *StoredDiag = static_cast<CXStoredDiagnostic *>(Diag);
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
if (!StoredDiag || Range >= StoredDiag->Diag.range_size() ||
StoredDiag->Diag.getLocation().isInvalid())
Clean up the CIndex interface to diagnostic ranges. Thanks, Daniel! llvm-svn: 95602
2010-02-09 07:11:56 +08:00
return clang_getNullRange();
Move createCXString() functions out of CIndexer and into the clang::cxstring namespace. We can much more succinctly refer to these functions this way. Also change the default behavior of createCXString(StringRef&) to duplicate the string. This is almost always what we want. The other case is where we pass a constant c-string, which uses the other version of createCXString(). llvm-svn: 96423
2010-02-17 08:41:08 +08:00
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
return translateSourceRange(StoredDiag->Diag.getLocation().getManager(),
StoredDiag->LangOpts,
StoredDiag->Diag.range_begin()[Range]);
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
}
unsigned clang_getDiagnosticNumFixIts(CXDiagnostic Diag) {
CXStoredDiagnostic *StoredDiag = static_cast<CXStoredDiagnostic *>(Diag);
if (!StoredDiag)
return 0;
Move createCXString() functions out of CIndexer and into the clang::cxstring namespace. We can much more succinctly refer to these functions this way. Also change the default behavior of createCXString(StringRef&) to duplicate the string. This is almost always what we want. The other case is where we pass a constant c-string, which uses the other version of createCXString(). llvm-svn: 96423
2010-02-17 08:41:08 +08:00
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
return StoredDiag->Diag.fixit_size();
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
}
Simplify the CIndex fix-it API, now that we have half-open CXSourceRanges. llvm-svn: 96685
2010-02-20 02:16:06 +08:00
CXString clang_getDiagnosticFixIt(CXDiagnostic Diagnostic, unsigned FixIt,
CXSourceRange *ReplacementRange) {
CXStoredDiagnostic *StoredDiag
= static_cast<CXStoredDiagnostic *>(Diagnostic);
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
if (!StoredDiag || FixIt >= StoredDiag->Diag.fixit_size() ||
StoredDiag->Diag.getLocation().isInvalid()) {
Simplify the CIndex fix-it API, now that we have half-open CXSourceRanges. llvm-svn: 96685
2010-02-20 02:16:06 +08:00
if (ReplacementRange)
*ReplacementRange = clang_getNullRange();
Move createCXString() functions out of CIndexer and into the clang::cxstring namespace. We can much more succinctly refer to these functions this way. Also change the default behavior of createCXString(StringRef&) to duplicate the string. This is almost always what we want. The other case is where we pass a constant c-string, which uses the other version of createCXString(). llvm-svn: 96423
2010-02-17 08:41:08 +08:00
return createCXString("");
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
}
Move createCXString() functions out of CIndexer and into the clang::cxstring namespace. We can much more succinctly refer to these functions this way. Also change the default behavior of createCXString(StringRef&) to duplicate the string. This is almost always what we want. The other case is where we pass a constant c-string, which uses the other version of createCXString(). llvm-svn: 96423
2010-02-17 08:41:08 +08:00
Reinstate my CodeModificationHint -> FixItHint renaming patch, without the C-only "optimization". llvm-svn: 100022
2010-04-01 01:46:05 +08:00
const FixItHint &Hint = StoredDiag->Diag.fixit_begin()[FixIt];
Simplify the CIndex fix-it API, now that we have half-open CXSourceRanges. llvm-svn: 96685
2010-02-20 02:16:06 +08:00
if (ReplacementRange) {
Simplify FixItHint by eliminated the unnecessary InsertionLoc location. Patch by Eelis van der Weegen! llvm-svn: 111362
2010-08-18 22:24:02 +08:00
// Create a range that covers the entire replacement (or
// removal) range, adjusting the end of the range to point to
// the end of the token.
*ReplacementRange
= translateSourceRange(StoredDiag->Diag.getLocation().getManager(),
StoredDiag->LangOpts,
Hint.RemoveRange);
Simplify the CIndex fix-it API, now that we have half-open CXSourceRanges. llvm-svn: 96685
2010-02-20 02:16:06 +08:00
}
Move createCXString() functions out of CIndexer and into the clang::cxstring namespace. We can much more succinctly refer to these functions this way. Also change the default behavior of createCXString(StringRef&) to duplicate the string. This is almost always what we want. The other case is where we pass a constant c-string, which uses the other version of createCXString(). llvm-svn: 96423
2010-02-17 08:41:08 +08:00
return createCXString(Hint.CodeToInsert);
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
}
Move createCXString() functions out of CIndexer and into the clang::cxstring namespace. We can much more succinctly refer to these functions this way. Also change the default behavior of createCXString(StringRef&) to duplicate the string. This is almost always what we want. The other case is where we pass a constant c-string, which uses the other version of createCXString(). llvm-svn: 96423
2010-02-17 08:41:08 +08:00
Implement a diagnostics callback for the C interface to Clang, so that clients can format diagnostics as they wish rather than having to parse standard error. All of the important parts of the front end's diagnostics are exposed: text, severity, location, source ranges, and fix-its. The diagnostics callback is now available with clang_createTranslationUnitFromSource() and clang_createTranslationUnit(). As part of this change, CXSourceLocation and CXSourceRange got one pointer larger, since we need to hold on to the SourceManager and LangOptions structures in the source location. This is the minimum amount of information needed for the functions that operate on source locations and ranges (as implemented now). Previously we held on to the ASTContext, but the diagnostics callback can end up with source locations when there is no ASTContext (or preprocessor). Still to do: - Code completion needs to support the diagnostics callback, once we have the ability to (de-)serialize diagnostics. - Eliminate the "displayDiagnostics" argument to createIndex; we'll always pass diagnostics to the callback and let it deal with display. llvm-svn: 94709
2010-01-28 08:27:43 +08:00
} // end extern "C"