Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 1 | //===- CIndexCodeCompletion.cpp - Code Completion API hooks ---------------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file implements the Clang-C Source Indexing library hooks for |
| 11 | // code completion. |
| 12 | // |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
| 15 | #include "CIndexer.h" |
Ted Kremenek | 0a90d32 | 2010-11-17 23:24:11 +0000 | [diff] [blame] | 16 | #include "CXTranslationUnit.h" |
Ted Kremenek | ed12273 | 2010-11-16 01:56:27 +0000 | [diff] [blame] | 17 | #include "CXString.h" |
Douglas Gregor | 936ea3b | 2010-01-28 00:56:43 +0000 | [diff] [blame] | 18 | #include "CIndexDiagnostic.h" |
Benjamin Kramer | b846deb | 2010-04-12 19:45:50 +0000 | [diff] [blame] | 19 | #include "clang/Basic/SourceManager.h" |
| 20 | #include "clang/Basic/FileManager.h" |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 21 | #include "clang/Frontend/ASTUnit.h" |
Benjamin Kramer | b846deb | 2010-04-12 19:45:50 +0000 | [diff] [blame] | 22 | #include "clang/Frontend/CompilerInstance.h" |
Douglas Gregor | 936ea3b | 2010-01-28 00:56:43 +0000 | [diff] [blame] | 23 | #include "clang/Frontend/FrontendDiagnostic.h" |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 24 | #include "clang/Sema/CodeCompleteConsumer.h" |
Douglas Gregor | df95a13 | 2010-08-09 20:45:32 +0000 | [diff] [blame] | 25 | #include "llvm/ADT/SmallString.h" |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 26 | #include "llvm/ADT/StringExtras.h" |
Douglas Gregor | 1fd9e0d | 2010-12-07 00:05:48 +0000 | [diff] [blame] | 27 | #include "llvm/Support/Atomic.h" |
Daniel Dunbar | b1fd345 | 2010-08-19 23:44:10 +0000 | [diff] [blame] | 28 | #include "llvm/Support/CrashRecoveryContext.h" |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 29 | #include "llvm/Support/MemoryBuffer.h" |
Douglas Gregor | df95a13 | 2010-08-09 20:45:32 +0000 | [diff] [blame] | 30 | #include "llvm/Support/Timer.h" |
| 31 | #include "llvm/Support/raw_ostream.h" |
Michael J. Spencer | 03013fa | 2010-11-29 18:12:39 +0000 | [diff] [blame] | 32 | #include "llvm/Support/Program.h" |
Douglas Gregor | 3d398aa | 2010-07-26 16:29:14 +0000 | [diff] [blame] | 33 | #include <cstdlib> |
| 34 | #include <cstdio> |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 35 | |
Douglas Gregor | df95a13 | 2010-08-09 20:45:32 +0000 | [diff] [blame] | 36 | |
Ted Kremenek | da7af32 | 2010-04-15 01:02:28 +0000 | [diff] [blame] | 37 | #ifdef UDP_CODE_COMPLETION_LOGGER |
| 38 | #include "clang/Basic/Version.h" |
Ted Kremenek | da7af32 | 2010-04-15 01:02:28 +0000 | [diff] [blame] | 39 | #include <arpa/inet.h> |
| 40 | #include <sys/socket.h> |
| 41 | #include <sys/types.h> |
| 42 | #include <unistd.h> |
| 43 | #endif |
| 44 | |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 45 | using namespace clang; |
Ted Kremenek | 2ef6f8f | 2010-02-17 01:42:24 +0000 | [diff] [blame] | 46 | using namespace clang::cxstring; |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 47 | |
| 48 | extern "C" { |
| 49 | |
| 50 | enum CXCompletionChunkKind |
| 51 | clang_getCompletionChunkKind(CXCompletionString completion_string, |
| 52 | unsigned chunk_number) { |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 53 | CodeCompletionString *CCStr = (CodeCompletionString *)completion_string; |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 54 | if (!CCStr || chunk_number >= CCStr->size()) |
| 55 | return CXCompletionChunk_Text; |
| 56 | |
| 57 | switch ((*CCStr)[chunk_number].Kind) { |
| 58 | case CodeCompletionString::CK_TypedText: |
| 59 | return CXCompletionChunk_TypedText; |
| 60 | case CodeCompletionString::CK_Text: |
| 61 | return CXCompletionChunk_Text; |
| 62 | case CodeCompletionString::CK_Optional: |
| 63 | return CXCompletionChunk_Optional; |
| 64 | case CodeCompletionString::CK_Placeholder: |
| 65 | return CXCompletionChunk_Placeholder; |
| 66 | case CodeCompletionString::CK_Informative: |
| 67 | return CXCompletionChunk_Informative; |
| 68 | case CodeCompletionString::CK_ResultType: |
| 69 | return CXCompletionChunk_ResultType; |
| 70 | case CodeCompletionString::CK_CurrentParameter: |
| 71 | return CXCompletionChunk_CurrentParameter; |
| 72 | case CodeCompletionString::CK_LeftParen: |
| 73 | return CXCompletionChunk_LeftParen; |
| 74 | case CodeCompletionString::CK_RightParen: |
| 75 | return CXCompletionChunk_RightParen; |
| 76 | case CodeCompletionString::CK_LeftBracket: |
| 77 | return CXCompletionChunk_LeftBracket; |
| 78 | case CodeCompletionString::CK_RightBracket: |
| 79 | return CXCompletionChunk_RightBracket; |
| 80 | case CodeCompletionString::CK_LeftBrace: |
| 81 | return CXCompletionChunk_LeftBrace; |
| 82 | case CodeCompletionString::CK_RightBrace: |
| 83 | return CXCompletionChunk_RightBrace; |
| 84 | case CodeCompletionString::CK_LeftAngle: |
| 85 | return CXCompletionChunk_LeftAngle; |
| 86 | case CodeCompletionString::CK_RightAngle: |
| 87 | return CXCompletionChunk_RightAngle; |
| 88 | case CodeCompletionString::CK_Comma: |
| 89 | return CXCompletionChunk_Comma; |
Douglas Gregor | 01dfea0 | 2010-01-10 23:08:15 +0000 | [diff] [blame] | 90 | case CodeCompletionString::CK_Colon: |
| 91 | return CXCompletionChunk_Colon; |
| 92 | case CodeCompletionString::CK_SemiColon: |
| 93 | return CXCompletionChunk_SemiColon; |
| 94 | case CodeCompletionString::CK_Equal: |
| 95 | return CXCompletionChunk_Equal; |
| 96 | case CodeCompletionString::CK_HorizontalSpace: |
| 97 | return CXCompletionChunk_HorizontalSpace; |
| 98 | case CodeCompletionString::CK_VerticalSpace: |
| 99 | return CXCompletionChunk_VerticalSpace; |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 100 | } |
| 101 | |
| 102 | // Should be unreachable, but let's be careful. |
| 103 | return CXCompletionChunk_Text; |
| 104 | } |
| 105 | |
Ted Kremenek | 2ef6f8f | 2010-02-17 01:42:24 +0000 | [diff] [blame] | 106 | CXString clang_getCompletionChunkText(CXCompletionString completion_string, |
| 107 | unsigned chunk_number) { |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 108 | CodeCompletionString *CCStr = (CodeCompletionString *)completion_string; |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 109 | if (!CCStr || chunk_number >= CCStr->size()) |
Ted Kremenek | a60ed47 | 2010-11-16 08:15:36 +0000 | [diff] [blame] | 110 | return createCXString((const char*)0); |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 111 | |
| 112 | switch ((*CCStr)[chunk_number].Kind) { |
| 113 | case CodeCompletionString::CK_TypedText: |
| 114 | case CodeCompletionString::CK_Text: |
| 115 | case CodeCompletionString::CK_Placeholder: |
| 116 | case CodeCompletionString::CK_CurrentParameter: |
| 117 | case CodeCompletionString::CK_Informative: |
| 118 | case CodeCompletionString::CK_LeftParen: |
| 119 | case CodeCompletionString::CK_RightParen: |
| 120 | case CodeCompletionString::CK_LeftBracket: |
| 121 | case CodeCompletionString::CK_RightBracket: |
| 122 | case CodeCompletionString::CK_LeftBrace: |
| 123 | case CodeCompletionString::CK_RightBrace: |
| 124 | case CodeCompletionString::CK_LeftAngle: |
| 125 | case CodeCompletionString::CK_RightAngle: |
| 126 | case CodeCompletionString::CK_Comma: |
| 127 | case CodeCompletionString::CK_ResultType: |
Douglas Gregor | 01dfea0 | 2010-01-10 23:08:15 +0000 | [diff] [blame] | 128 | case CodeCompletionString::CK_Colon: |
| 129 | case CodeCompletionString::CK_SemiColon: |
| 130 | case CodeCompletionString::CK_Equal: |
| 131 | case CodeCompletionString::CK_HorizontalSpace: |
Douglas Gregor | 21c241f | 2010-05-25 06:14:46 +0000 | [diff] [blame] | 132 | case CodeCompletionString::CK_VerticalSpace: |
Douglas Gregor | 5a9c0bc | 2010-10-08 20:39:29 +0000 | [diff] [blame] | 133 | return createCXString((*CCStr)[chunk_number].Text, false); |
Douglas Gregor | 21c241f | 2010-05-25 06:14:46 +0000 | [diff] [blame] | 134 | |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 135 | case CodeCompletionString::CK_Optional: |
| 136 | // Note: treated as an empty text block. |
Ted Kremenek | 2ef6f8f | 2010-02-17 01:42:24 +0000 | [diff] [blame] | 137 | return createCXString(""); |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 138 | } |
| 139 | |
| 140 | // Should be unreachable, but let's be careful. |
Ted Kremenek | a60ed47 | 2010-11-16 08:15:36 +0000 | [diff] [blame] | 141 | return createCXString((const char*)0); |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 142 | } |
| 143 | |
Ted Kremenek | 2ef6f8f | 2010-02-17 01:42:24 +0000 | [diff] [blame] | 144 | |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 145 | CXCompletionString |
| 146 | clang_getCompletionChunkCompletionString(CXCompletionString completion_string, |
| 147 | unsigned chunk_number) { |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 148 | CodeCompletionString *CCStr = (CodeCompletionString *)completion_string; |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 149 | if (!CCStr || chunk_number >= CCStr->size()) |
| 150 | return 0; |
| 151 | |
| 152 | switch ((*CCStr)[chunk_number].Kind) { |
| 153 | case CodeCompletionString::CK_TypedText: |
| 154 | case CodeCompletionString::CK_Text: |
| 155 | case CodeCompletionString::CK_Placeholder: |
| 156 | case CodeCompletionString::CK_CurrentParameter: |
| 157 | case CodeCompletionString::CK_Informative: |
| 158 | case CodeCompletionString::CK_LeftParen: |
| 159 | case CodeCompletionString::CK_RightParen: |
| 160 | case CodeCompletionString::CK_LeftBracket: |
| 161 | case CodeCompletionString::CK_RightBracket: |
| 162 | case CodeCompletionString::CK_LeftBrace: |
| 163 | case CodeCompletionString::CK_RightBrace: |
| 164 | case CodeCompletionString::CK_LeftAngle: |
| 165 | case CodeCompletionString::CK_RightAngle: |
| 166 | case CodeCompletionString::CK_Comma: |
| 167 | case CodeCompletionString::CK_ResultType: |
Douglas Gregor | 01dfea0 | 2010-01-10 23:08:15 +0000 | [diff] [blame] | 168 | case CodeCompletionString::CK_Colon: |
| 169 | case CodeCompletionString::CK_SemiColon: |
| 170 | case CodeCompletionString::CK_Equal: |
| 171 | case CodeCompletionString::CK_HorizontalSpace: |
| 172 | case CodeCompletionString::CK_VerticalSpace: |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 173 | return 0; |
| 174 | |
| 175 | case CodeCompletionString::CK_Optional: |
| 176 | // Note: treated as an empty text block. |
| 177 | return (*CCStr)[chunk_number].Optional; |
| 178 | } |
| 179 | |
| 180 | // Should be unreachable, but let's be careful. |
| 181 | return 0; |
| 182 | } |
| 183 | |
| 184 | unsigned clang_getNumCompletionChunks(CXCompletionString completion_string) { |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 185 | CodeCompletionString *CCStr = (CodeCompletionString *)completion_string; |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 186 | return CCStr? CCStr->size() : 0; |
| 187 | } |
| 188 | |
Douglas Gregor | 12e1313 | 2010-05-26 22:00:08 +0000 | [diff] [blame] | 189 | unsigned clang_getCompletionPriority(CXCompletionString completion_string) { |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 190 | CodeCompletionString *CCStr = (CodeCompletionString *)completion_string; |
Bill Wendling | a2ace58 | 2010-05-27 18:35:05 +0000 | [diff] [blame] | 191 | return CCStr? CCStr->getPriority() : unsigned(CCP_Unlikely); |
Douglas Gregor | 12e1313 | 2010-05-26 22:00:08 +0000 | [diff] [blame] | 192 | } |
| 193 | |
Douglas Gregor | 58ddb60 | 2010-08-23 23:00:57 +0000 | [diff] [blame] | 194 | enum CXAvailabilityKind |
| 195 | clang_getCompletionAvailability(CXCompletionString completion_string) { |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 196 | CodeCompletionString *CCStr = (CodeCompletionString *)completion_string; |
| 197 | return CCStr? static_cast<CXAvailabilityKind>(CCStr->getAvailability()) |
| 198 | : CXAvailability_Available; |
Douglas Gregor | 58ddb60 | 2010-08-23 23:00:57 +0000 | [diff] [blame] | 199 | } |
| 200 | |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 201 | /// \brief The CXCodeCompleteResults structure we allocate internally; |
| 202 | /// the client only sees the initial CXCodeCompleteResults structure. |
| 203 | struct AllocatedCXCodeCompleteResults : public CXCodeCompleteResults { |
Douglas Gregor | 0a812cf | 2010-02-18 23:07:20 +0000 | [diff] [blame] | 204 | AllocatedCXCodeCompleteResults(); |
| 205 | ~AllocatedCXCodeCompleteResults(); |
| 206 | |
Douglas Gregor | a88084b | 2010-02-18 18:08:43 +0000 | [diff] [blame] | 207 | /// \brief Diagnostics produced while performing code completion. |
| 208 | llvm::SmallVector<StoredDiagnostic, 8> Diagnostics; |
| 209 | |
Douglas Gregor | f715ca1 | 2010-03-16 00:06:06 +0000 | [diff] [blame] | 210 | /// \brief Diag object |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 211 | llvm::IntrusiveRefCntPtr<Diagnostic> Diag; |
Douglas Gregor | f715ca1 | 2010-03-16 00:06:06 +0000 | [diff] [blame] | 212 | |
Douglas Gregor | a88084b | 2010-02-18 18:08:43 +0000 | [diff] [blame] | 213 | /// \brief Language options used to adjust source locations. |
Daniel Dunbar | 35b8440 | 2010-01-30 23:31:40 +0000 | [diff] [blame] | 214 | LangOptions LangOpts; |
Argyrios Kyrtzidis | 389db16 | 2010-11-03 22:45:23 +0000 | [diff] [blame] | 215 | |
| 216 | FileSystemOptions FileSystemOpts; |
| 217 | |
Chris Lattner | 39b49bc | 2010-11-23 08:35:12 +0000 | [diff] [blame] | 218 | /// \brief File manager, used for diagnostics. |
| 219 | FileManager FileMgr; |
| 220 | |
Argyrios Kyrtzidis | 389db16 | 2010-11-03 22:45:23 +0000 | [diff] [blame] | 221 | /// \brief Source manager, used for diagnostics. |
| 222 | SourceManager SourceMgr; |
Douglas Gregor | 313e26c | 2010-02-18 23:35:40 +0000 | [diff] [blame] | 223 | |
| 224 | /// \brief Temporary files that should be removed once we have finished |
| 225 | /// with the code-completion results. |
| 226 | std::vector<llvm::sys::Path> TemporaryFiles; |
Douglas Gregor | b75d3df | 2010-08-04 17:07:00 +0000 | [diff] [blame] | 227 | |
Chris Lattner | 7ad97ff | 2010-11-23 07:51:02 +0000 | [diff] [blame] | 228 | /// \brief Temporary buffers that will be deleted once we have finished with |
| 229 | /// the code-completion results. |
Douglas Gregor | b75d3df | 2010-08-04 17:07:00 +0000 | [diff] [blame] | 230 | llvm::SmallVector<const llvm::MemoryBuffer *, 1> TemporaryBuffers; |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 231 | |
Douglas Gregor | 48601b3 | 2011-02-16 19:08:06 +0000 | [diff] [blame^] | 232 | /// \brief Allocator used to store globally cached code-completion results. |
| 233 | llvm::IntrusiveRefCntPtr<clang::GlobalCodeCompletionAllocator> |
| 234 | CachedCompletionAllocator; |
| 235 | |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 236 | /// \brief Allocator used to store code completion results. |
Douglas Gregor | 110a68e | 2011-02-01 23:14:23 +0000 | [diff] [blame] | 237 | clang::CodeCompletionAllocator CodeCompletionAllocator; |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 238 | }; |
| 239 | |
Douglas Gregor | e3c60a7 | 2010-11-17 00:13:31 +0000 | [diff] [blame] | 240 | /// \brief Tracks the number of code-completion result objects that are |
| 241 | /// currently active. |
| 242 | /// |
| 243 | /// Used for debugging purposes only. |
Douglas Gregor | 1fd9e0d | 2010-12-07 00:05:48 +0000 | [diff] [blame] | 244 | static llvm::sys::cas_flag CodeCompletionResultObjects; |
Douglas Gregor | e3c60a7 | 2010-11-17 00:13:31 +0000 | [diff] [blame] | 245 | |
Douglas Gregor | 0a812cf | 2010-02-18 23:07:20 +0000 | [diff] [blame] | 246 | AllocatedCXCodeCompleteResults::AllocatedCXCodeCompleteResults() |
Argyrios Kyrtzidis | 33e4e70 | 2010-11-18 20:06:41 +0000 | [diff] [blame] | 247 | : CXCodeCompleteResults(), |
| 248 | Diag(new Diagnostic( |
| 249 | llvm::IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs))), |
Chris Lattner | 7ad97ff | 2010-11-23 07:51:02 +0000 | [diff] [blame] | 250 | FileMgr(FileSystemOpts), |
Chris Lattner | 39b49bc | 2010-11-23 08:35:12 +0000 | [diff] [blame] | 251 | SourceMgr(*Diag, FileMgr) { |
Douglas Gregor | e3c60a7 | 2010-11-17 00:13:31 +0000 | [diff] [blame] | 252 | if (getenv("LIBCLANG_OBJTRACKING")) { |
Douglas Gregor | 1fd9e0d | 2010-12-07 00:05:48 +0000 | [diff] [blame] | 253 | llvm::sys::AtomicIncrement(&CodeCompletionResultObjects); |
Douglas Gregor | e3c60a7 | 2010-11-17 00:13:31 +0000 | [diff] [blame] | 254 | fprintf(stderr, "+++ %d completion results\n", CodeCompletionResultObjects); |
| 255 | } |
| 256 | } |
Douglas Gregor | 0a812cf | 2010-02-18 23:07:20 +0000 | [diff] [blame] | 257 | |
| 258 | AllocatedCXCodeCompleteResults::~AllocatedCXCodeCompleteResults() { |
Douglas Gregor | 0a812cf | 2010-02-18 23:07:20 +0000 | [diff] [blame] | 259 | delete [] Results; |
Douglas Gregor | 313e26c | 2010-02-18 23:35:40 +0000 | [diff] [blame] | 260 | |
| 261 | for (unsigned I = 0, N = TemporaryFiles.size(); I != N; ++I) |
| 262 | TemporaryFiles[I].eraseFromDisk(); |
Douglas Gregor | b75d3df | 2010-08-04 17:07:00 +0000 | [diff] [blame] | 263 | for (unsigned I = 0, N = TemporaryBuffers.size(); I != N; ++I) |
| 264 | delete TemporaryBuffers[I]; |
Douglas Gregor | e3c60a7 | 2010-11-17 00:13:31 +0000 | [diff] [blame] | 265 | |
| 266 | if (getenv("LIBCLANG_OBJTRACKING")) { |
Douglas Gregor | 1fd9e0d | 2010-12-07 00:05:48 +0000 | [diff] [blame] | 267 | llvm::sys::AtomicDecrement(&CodeCompletionResultObjects); |
Douglas Gregor | e3c60a7 | 2010-11-17 00:13:31 +0000 | [diff] [blame] | 268 | fprintf(stderr, "--- %d completion results\n", CodeCompletionResultObjects); |
| 269 | } |
Douglas Gregor | 0a812cf | 2010-02-18 23:07:20 +0000 | [diff] [blame] | 270 | } |
| 271 | |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 272 | } // end extern "C" |
| 273 | |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 274 | namespace { |
| 275 | class CaptureCompletionResults : public CodeCompleteConsumer { |
| 276 | AllocatedCXCodeCompleteResults &AllocatedResults; |
Douglas Gregor | 32be4a5 | 2010-10-11 21:37:58 +0000 | [diff] [blame] | 277 | llvm::SmallVector<CXCompletionResult, 16> StoredResults; |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 278 | public: |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 279 | CaptureCompletionResults(AllocatedCXCodeCompleteResults &Results) |
Douglas Gregor | 8071e42 | 2010-08-15 06:18:01 +0000 | [diff] [blame] | 280 | : CodeCompleteConsumer(true, false, true, false), |
| 281 | AllocatedResults(Results) { } |
Douglas Gregor | 32be4a5 | 2010-10-11 21:37:58 +0000 | [diff] [blame] | 282 | ~CaptureCompletionResults() { Finish(); } |
| 283 | |
Douglas Gregor | e6b1bb6 | 2010-08-11 21:23:17 +0000 | [diff] [blame] | 284 | virtual void ProcessCodeCompleteResults(Sema &S, |
| 285 | CodeCompletionContext Context, |
John McCall | 0a2c5e2 | 2010-08-25 06:19:51 +0000 | [diff] [blame] | 286 | CodeCompletionResult *Results, |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 287 | unsigned NumResults) { |
Douglas Gregor | 32be4a5 | 2010-10-11 21:37:58 +0000 | [diff] [blame] | 288 | StoredResults.reserve(StoredResults.size() + NumResults); |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 289 | for (unsigned I = 0; I != NumResults; ++I) { |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 290 | CodeCompletionString *StoredCompletion |
| 291 | = Results[I].CreateCodeCompletionString(S, |
| 292 | AllocatedResults.CodeCompletionAllocator); |
Douglas Gregor | 32be4a5 | 2010-10-11 21:37:58 +0000 | [diff] [blame] | 293 | |
| 294 | CXCompletionResult R; |
| 295 | R.CursorKind = Results[I].CursorKind; |
| 296 | R.CompletionString = StoredCompletion; |
| 297 | StoredResults.push_back(R); |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 298 | } |
| 299 | } |
Douglas Gregor | 1e5e668 | 2010-08-26 13:48:20 +0000 | [diff] [blame] | 300 | |
Douglas Gregor | 32be4a5 | 2010-10-11 21:37:58 +0000 | [diff] [blame] | 301 | virtual void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg, |
| 302 | OverloadCandidate *Candidates, |
| 303 | unsigned NumCandidates) { |
| 304 | StoredResults.reserve(StoredResults.size() + NumCandidates); |
| 305 | for (unsigned I = 0; I != NumCandidates; ++I) { |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 306 | CodeCompletionString *StoredCompletion |
| 307 | = Candidates[I].CreateSignatureString(CurrentArg, S, |
| 308 | AllocatedResults.CodeCompletionAllocator); |
Douglas Gregor | 32be4a5 | 2010-10-11 21:37:58 +0000 | [diff] [blame] | 309 | |
| 310 | CXCompletionResult R; |
| 311 | R.CursorKind = CXCursor_NotImplemented; |
| 312 | R.CompletionString = StoredCompletion; |
| 313 | StoredResults.push_back(R); |
| 314 | } |
| 315 | } |
| 316 | |
Douglas Gregor | dae6875 | 2011-02-01 22:57:45 +0000 | [diff] [blame] | 317 | virtual CodeCompletionAllocator &getAllocator() { |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 318 | return AllocatedResults.CodeCompletionAllocator; |
| 319 | } |
| 320 | |
Douglas Gregor | 32be4a5 | 2010-10-11 21:37:58 +0000 | [diff] [blame] | 321 | private: |
| 322 | void Finish() { |
| 323 | AllocatedResults.Results = new CXCompletionResult [StoredResults.size()]; |
| 324 | AllocatedResults.NumResults = StoredResults.size(); |
| 325 | std::memcpy(AllocatedResults.Results, StoredResults.data(), |
| 326 | StoredResults.size() * sizeof(CXCompletionResult)); |
| 327 | StoredResults.clear(); |
| 328 | } |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 329 | }; |
| 330 | } |
| 331 | |
| 332 | extern "C" { |
Daniel Dunbar | b1fd345 | 2010-08-19 23:44:10 +0000 | [diff] [blame] | 333 | struct CodeCompleteAtInfo { |
| 334 | CXTranslationUnit TU; |
| 335 | const char *complete_filename; |
| 336 | unsigned complete_line; |
| 337 | unsigned complete_column; |
| 338 | struct CXUnsavedFile *unsaved_files; |
| 339 | unsigned num_unsaved_files; |
| 340 | unsigned options; |
| 341 | CXCodeCompleteResults *result; |
| 342 | }; |
| 343 | void clang_codeCompleteAt_Impl(void *UserData) { |
| 344 | CodeCompleteAtInfo *CCAI = static_cast<CodeCompleteAtInfo*>(UserData); |
| 345 | CXTranslationUnit TU = CCAI->TU; |
| 346 | const char *complete_filename = CCAI->complete_filename; |
| 347 | unsigned complete_line = CCAI->complete_line; |
| 348 | unsigned complete_column = CCAI->complete_column; |
| 349 | struct CXUnsavedFile *unsaved_files = CCAI->unsaved_files; |
| 350 | unsigned num_unsaved_files = CCAI->num_unsaved_files; |
| 351 | unsigned options = CCAI->options; |
| 352 | CCAI->result = 0; |
| 353 | |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 354 | #ifdef UDP_CODE_COMPLETION_LOGGER |
| 355 | #ifdef UDP_CODE_COMPLETION_LOGGER_PORT |
| 356 | const llvm::TimeRecord &StartTime = llvm::TimeRecord::getCurrentTime(); |
| 357 | #endif |
| 358 | #endif |
| 359 | |
| 360 | bool EnableLogging = getenv("LIBCLANG_CODE_COMPLETION_LOGGING") != 0; |
| 361 | |
Ted Kremenek | a60ed47 | 2010-11-16 08:15:36 +0000 | [diff] [blame] | 362 | ASTUnit *AST = static_cast<ASTUnit *>(TU->TUData); |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 363 | if (!AST) |
Daniel Dunbar | b1fd345 | 2010-08-19 23:44:10 +0000 | [diff] [blame] | 364 | return; |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 365 | |
Douglas Gregor | 593b0c1 | 2010-09-23 18:47:53 +0000 | [diff] [blame] | 366 | ASTUnit::ConcurrencyCheck Check(*AST); |
| 367 | |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 368 | // Perform the remapping of source files. |
| 369 | llvm::SmallVector<ASTUnit::RemappedFile, 4> RemappedFiles; |
| 370 | for (unsigned I = 0; I != num_unsaved_files; ++I) { |
| 371 | llvm::StringRef Data(unsaved_files[I].Contents, unsaved_files[I].Length); |
| 372 | const llvm::MemoryBuffer *Buffer |
| 373 | = llvm::MemoryBuffer::getMemBufferCopy(Data, unsaved_files[I].Filename); |
| 374 | RemappedFiles.push_back(std::make_pair(unsaved_files[I].Filename, |
| 375 | Buffer)); |
| 376 | } |
| 377 | |
| 378 | if (EnableLogging) { |
| 379 | // FIXME: Add logging. |
| 380 | } |
| 381 | |
| 382 | // Parse the resulting source file to find code-completion results. |
| 383 | AllocatedCXCodeCompleteResults *Results = new AllocatedCXCodeCompleteResults; |
| 384 | Results->Results = 0; |
| 385 | Results->NumResults = 0; |
Douglas Gregor | 48601b3 | 2011-02-16 19:08:06 +0000 | [diff] [blame^] | 386 | |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 387 | // Create a code-completion consumer to capture the results. |
| 388 | CaptureCompletionResults Capture(*Results); |
| 389 | |
| 390 | // Perform completion. |
| 391 | AST->CodeComplete(complete_filename, complete_line, complete_column, |
Douglas Gregor | cee235c | 2010-08-05 09:09:23 +0000 | [diff] [blame] | 392 | RemappedFiles.data(), RemappedFiles.size(), |
| 393 | (options & CXCodeComplete_IncludeMacros), |
| 394 | (options & CXCodeComplete_IncludeCodePatterns), |
| 395 | Capture, |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 396 | *Results->Diag, Results->LangOpts, Results->SourceMgr, |
Douglas Gregor | 2283d79 | 2010-08-20 00:59:43 +0000 | [diff] [blame] | 397 | Results->FileMgr, Results->Diagnostics, |
| 398 | Results->TemporaryBuffers); |
Douglas Gregor | 48601b3 | 2011-02-16 19:08:06 +0000 | [diff] [blame^] | 399 | |
| 400 | // Keep a reference to the allocator used for cached global completions, so |
| 401 | // that we can be sure that the memory used by our code completion strings |
| 402 | // doesn't get freed due to subsequent reparses (while the code completion |
| 403 | // results are still active). |
| 404 | Results->CachedCompletionAllocator = AST->getCachedCompletionAllocator(); |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 405 | |
| 406 | |
| 407 | |
| 408 | #ifdef UDP_CODE_COMPLETION_LOGGER |
| 409 | #ifdef UDP_CODE_COMPLETION_LOGGER_PORT |
| 410 | const llvm::TimeRecord &EndTime = llvm::TimeRecord::getCurrentTime(); |
| 411 | llvm::SmallString<256> LogResult; |
| 412 | llvm::raw_svector_ostream os(LogResult); |
| 413 | |
| 414 | // Figure out the language and whether or not it uses PCH. |
| 415 | const char *lang = 0; |
| 416 | bool usesPCH = false; |
| 417 | |
| 418 | for (std::vector<const char*>::iterator I = argv.begin(), E = argv.end(); |
| 419 | I != E; ++I) { |
| 420 | if (*I == 0) |
| 421 | continue; |
| 422 | if (strcmp(*I, "-x") == 0) { |
| 423 | if (I + 1 != E) { |
| 424 | lang = *(++I); |
| 425 | continue; |
| 426 | } |
| 427 | } |
| 428 | else if (strcmp(*I, "-include") == 0) { |
| 429 | if (I+1 != E) { |
| 430 | const char *arg = *(++I); |
| 431 | llvm::SmallString<512> pchName; |
| 432 | { |
| 433 | llvm::raw_svector_ostream os(pchName); |
| 434 | os << arg << ".pth"; |
| 435 | } |
| 436 | pchName.push_back('\0'); |
| 437 | struct stat stat_results; |
| 438 | if (stat(pchName.data(), &stat_results) == 0) |
| 439 | usesPCH = true; |
| 440 | continue; |
| 441 | } |
| 442 | } |
| 443 | } |
| 444 | |
| 445 | os << "{ "; |
| 446 | os << "\"wall\": " << (EndTime.getWallTime() - StartTime.getWallTime()); |
| 447 | os << ", \"numRes\": " << Results->NumResults; |
| 448 | os << ", \"diags\": " << Results->Diagnostics.size(); |
| 449 | os << ", \"pch\": " << (usesPCH ? "true" : "false"); |
| 450 | os << ", \"lang\": \"" << (lang ? lang : "<unknown>") << '"'; |
| 451 | const char *name = getlogin(); |
| 452 | os << ", \"user\": \"" << (name ? name : "unknown") << '"'; |
| 453 | os << ", \"clangVer\": \"" << getClangFullVersion() << '"'; |
| 454 | os << " }"; |
| 455 | |
| 456 | llvm::StringRef res = os.str(); |
| 457 | if (res.size() > 0) { |
| 458 | do { |
| 459 | // Setup the UDP socket. |
| 460 | struct sockaddr_in servaddr; |
| 461 | bzero(&servaddr, sizeof(servaddr)); |
| 462 | servaddr.sin_family = AF_INET; |
| 463 | servaddr.sin_port = htons(UDP_CODE_COMPLETION_LOGGER_PORT); |
| 464 | if (inet_pton(AF_INET, UDP_CODE_COMPLETION_LOGGER, |
| 465 | &servaddr.sin_addr) <= 0) |
| 466 | break; |
| 467 | |
| 468 | int sockfd = socket(AF_INET, SOCK_DGRAM, 0); |
| 469 | if (sockfd < 0) |
| 470 | break; |
| 471 | |
| 472 | sendto(sockfd, res.data(), res.size(), 0, |
| 473 | (struct sockaddr *)&servaddr, sizeof(servaddr)); |
| 474 | close(sockfd); |
| 475 | } |
| 476 | while (false); |
| 477 | } |
| 478 | #endif |
| 479 | #endif |
Daniel Dunbar | b1fd345 | 2010-08-19 23:44:10 +0000 | [diff] [blame] | 480 | CCAI->result = Results; |
| 481 | } |
| 482 | CXCodeCompleteResults *clang_codeCompleteAt(CXTranslationUnit TU, |
| 483 | const char *complete_filename, |
| 484 | unsigned complete_line, |
| 485 | unsigned complete_column, |
| 486 | struct CXUnsavedFile *unsaved_files, |
| 487 | unsigned num_unsaved_files, |
| 488 | unsigned options) { |
| 489 | CodeCompleteAtInfo CCAI = { TU, complete_filename, complete_line, |
| 490 | complete_column, unsaved_files, num_unsaved_files, |
| 491 | options, 0 }; |
| 492 | llvm::CrashRecoveryContext CRC; |
| 493 | |
Daniel Dunbar | bf44c3b | 2010-11-05 07:19:31 +0000 | [diff] [blame] | 494 | if (!RunSafely(CRC, clang_codeCompleteAt_Impl, &CCAI)) { |
Daniel Dunbar | b1fd345 | 2010-08-19 23:44:10 +0000 | [diff] [blame] | 495 | fprintf(stderr, "libclang: crash detected in code completion\n"); |
Ted Kremenek | a60ed47 | 2010-11-16 08:15:36 +0000 | [diff] [blame] | 496 | static_cast<ASTUnit *>(TU->TUData)->setUnsafeToFree(true); |
Daniel Dunbar | b1fd345 | 2010-08-19 23:44:10 +0000 | [diff] [blame] | 497 | return 0; |
| 498 | } |
| 499 | |
| 500 | return CCAI.result; |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 501 | } |
| 502 | |
Douglas Gregor | cee235c | 2010-08-05 09:09:23 +0000 | [diff] [blame] | 503 | unsigned clang_defaultCodeCompleteOptions(void) { |
| 504 | return CXCodeComplete_IncludeMacros; |
| 505 | } |
| 506 | |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 507 | void clang_disposeCodeCompleteResults(CXCodeCompleteResults *ResultsIn) { |
| 508 | if (!ResultsIn) |
| 509 | return; |
| 510 | |
| 511 | AllocatedCXCodeCompleteResults *Results |
| 512 | = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn); |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 513 | delete Results; |
| 514 | } |
Douglas Gregor | 58ddb60 | 2010-08-23 23:00:57 +0000 | [diff] [blame] | 515 | |
Douglas Gregor | a88084b | 2010-02-18 18:08:43 +0000 | [diff] [blame] | 516 | unsigned |
| 517 | clang_codeCompleteGetNumDiagnostics(CXCodeCompleteResults *ResultsIn) { |
| 518 | AllocatedCXCodeCompleteResults *Results |
| 519 | = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn); |
| 520 | if (!Results) |
| 521 | return 0; |
| 522 | |
| 523 | return Results->Diagnostics.size(); |
| 524 | } |
| 525 | |
| 526 | CXDiagnostic |
| 527 | clang_codeCompleteGetDiagnostic(CXCodeCompleteResults *ResultsIn, |
| 528 | unsigned Index) { |
| 529 | AllocatedCXCodeCompleteResults *Results |
| 530 | = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn); |
| 531 | if (!Results || Index >= Results->Diagnostics.size()) |
| 532 | return 0; |
| 533 | |
| 534 | return new CXStoredDiagnostic(Results->Diagnostics[Index], Results->LangOpts); |
| 535 | } |
| 536 | |
| 537 | |
Ted Kremenek | ab18893 | 2010-01-05 19:32:54 +0000 | [diff] [blame] | 538 | } // end extern "C" |
Douglas Gregor | 1e5e668 | 2010-08-26 13:48:20 +0000 | [diff] [blame] | 539 | |
Douglas Gregor | c7b7b7a | 2010-10-18 21:05:04 +0000 | [diff] [blame] | 540 | /// \brief Simple utility function that appends a \p New string to the given |
| 541 | /// \p Old string, using the \p Buffer for storage. |
| 542 | /// |
| 543 | /// \param Old The string to which we are appending. This parameter will be |
| 544 | /// updated to reflect the complete string. |
| 545 | /// |
| 546 | /// |
| 547 | /// \param New The string to append to \p Old. |
| 548 | /// |
| 549 | /// \param Buffer A buffer that stores the actual, concatenated string. It will |
| 550 | /// be used if the old string is already-non-empty. |
| 551 | static void AppendToString(llvm::StringRef &Old, llvm::StringRef New, |
| 552 | llvm::SmallString<256> &Buffer) { |
| 553 | if (Old.empty()) { |
| 554 | Old = New; |
| 555 | return; |
| 556 | } |
| 557 | |
| 558 | if (Buffer.empty()) |
| 559 | Buffer.append(Old.begin(), Old.end()); |
| 560 | Buffer.append(New.begin(), New.end()); |
| 561 | Old = Buffer.str(); |
| 562 | } |
| 563 | |
| 564 | /// \brief Get the typed-text blocks from the given code-completion string |
| 565 | /// and return them as a single string. |
| 566 | /// |
| 567 | /// \param String The code-completion string whose typed-text blocks will be |
| 568 | /// concatenated. |
| 569 | /// |
| 570 | /// \param Buffer A buffer used for storage of the completed name. |
| 571 | static llvm::StringRef GetTypedName(CodeCompletionString *String, |
| 572 | llvm::SmallString<256> &Buffer) { |
| 573 | llvm::StringRef Result; |
| 574 | for (CodeCompletionString::iterator C = String->begin(), CEnd = String->end(); |
| 575 | C != CEnd; ++C) { |
| 576 | if (C->Kind == CodeCompletionString::CK_TypedText) |
| 577 | AppendToString(Result, C->Text, Buffer); |
| 578 | } |
| 579 | |
| 580 | return Result; |
| 581 | } |
| 582 | |
Douglas Gregor | 1e5e668 | 2010-08-26 13:48:20 +0000 | [diff] [blame] | 583 | namespace { |
| 584 | struct OrderCompletionResults { |
| 585 | bool operator()(const CXCompletionResult &XR, |
| 586 | const CXCompletionResult &YR) const { |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 587 | CodeCompletionString *X |
| 588 | = (CodeCompletionString *)XR.CompletionString; |
| 589 | CodeCompletionString *Y |
| 590 | = (CodeCompletionString *)YR.CompletionString; |
Douglas Gregor | 1e5e668 | 2010-08-26 13:48:20 +0000 | [diff] [blame] | 591 | |
Douglas Gregor | c7b7b7a | 2010-10-18 21:05:04 +0000 | [diff] [blame] | 592 | llvm::SmallString<256> XBuffer; |
| 593 | llvm::StringRef XText = GetTypedName(X, XBuffer); |
| 594 | llvm::SmallString<256> YBuffer; |
| 595 | llvm::StringRef YText = GetTypedName(Y, YBuffer); |
Douglas Gregor | 1e5e668 | 2010-08-26 13:48:20 +0000 | [diff] [blame] | 596 | |
Douglas Gregor | c7b7b7a | 2010-10-18 21:05:04 +0000 | [diff] [blame] | 597 | if (XText.empty() || YText.empty()) |
| 598 | return !XText.empty(); |
| 599 | |
| 600 | int result = XText.compare_lower(YText); |
Douglas Gregor | 1e5e668 | 2010-08-26 13:48:20 +0000 | [diff] [blame] | 601 | if (result < 0) |
| 602 | return true; |
| 603 | if (result > 0) |
| 604 | return false; |
| 605 | |
Douglas Gregor | c7b7b7a | 2010-10-18 21:05:04 +0000 | [diff] [blame] | 606 | result = XText.compare(YText); |
Douglas Gregor | 1aad340 | 2010-09-10 23:05:54 +0000 | [diff] [blame] | 607 | return result < 0; |
Douglas Gregor | 1e5e668 | 2010-08-26 13:48:20 +0000 | [diff] [blame] | 608 | } |
| 609 | }; |
| 610 | } |
| 611 | |
| 612 | extern "C" { |
| 613 | void clang_sortCodeCompletionResults(CXCompletionResult *Results, |
| 614 | unsigned NumResults) { |
| 615 | std::stable_sort(Results, Results + NumResults, OrderCompletionResults()); |
| 616 | } |
Douglas Gregor | 458433d | 2010-08-26 15:07:07 +0000 | [diff] [blame] | 617 | } |