CIndexCodeCompletion.cpp 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008
  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. #include "CIndexer.h"
  15. #include "CIndexDiagnostic.h"
  16. #include "CLog.h"
  17. #include "CXCursor.h"
  18. #include "CXString.h"
  19. #include "CXTranslationUnit.h"
  20. #include "clang/AST/Decl.h"
  21. #include "clang/AST/DeclObjC.h"
  22. #include "clang/AST/Type.h"
  23. #include "clang/Basic/FileManager.h"
  24. #include "clang/Basic/SourceManager.h"
  25. #include "clang/Frontend/ASTUnit.h"
  26. #include "clang/Frontend/CompilerInstance.h"
  27. #include "clang/Frontend/FrontendDiagnostic.h"
  28. #include "clang/Sema/CodeCompleteConsumer.h"
  29. #include "clang/Sema/Sema.h"
  30. #include "llvm/ADT/SmallString.h"
  31. #include "llvm/ADT/StringExtras.h"
  32. #include "llvm/Support/CrashRecoveryContext.h"
  33. #include "llvm/Support/FileSystem.h"
  34. #include "llvm/Support/MemoryBuffer.h"
  35. #include "llvm/Support/Program.h"
  36. #include "llvm/Support/Timer.h"
  37. #include "llvm/Support/raw_ostream.h"
  38. #include <atomic>
  39. #include <cstdio>
  40. #include <cstdlib>
  41. #include <string>
  42. #ifdef UDP_CODE_COMPLETION_LOGGER
  43. #include "clang/Basic/Version.h"
  44. #include <arpa/inet.h>
  45. #include <sys/socket.h>
  46. #include <sys/types.h>
  47. #include <unistd.h>
  48. #endif
  49. using namespace clang;
  50. using namespace clang::cxindex;
  51. extern "C" {
  52. enum CXCompletionChunkKind
  53. clang_getCompletionChunkKind(CXCompletionString completion_string,
  54. unsigned chunk_number) {
  55. CodeCompletionString *CCStr = (CodeCompletionString *)completion_string;
  56. if (!CCStr || chunk_number >= CCStr->size())
  57. return CXCompletionChunk_Text;
  58. switch ((*CCStr)[chunk_number].Kind) {
  59. case CodeCompletionString::CK_TypedText:
  60. return CXCompletionChunk_TypedText;
  61. case CodeCompletionString::CK_Text:
  62. return CXCompletionChunk_Text;
  63. case CodeCompletionString::CK_Optional:
  64. return CXCompletionChunk_Optional;
  65. case CodeCompletionString::CK_Placeholder:
  66. return CXCompletionChunk_Placeholder;
  67. case CodeCompletionString::CK_Informative:
  68. return CXCompletionChunk_Informative;
  69. case CodeCompletionString::CK_ResultType:
  70. return CXCompletionChunk_ResultType;
  71. case CodeCompletionString::CK_CurrentParameter:
  72. return CXCompletionChunk_CurrentParameter;
  73. case CodeCompletionString::CK_LeftParen:
  74. return CXCompletionChunk_LeftParen;
  75. case CodeCompletionString::CK_RightParen:
  76. return CXCompletionChunk_RightParen;
  77. case CodeCompletionString::CK_LeftBracket:
  78. return CXCompletionChunk_LeftBracket;
  79. case CodeCompletionString::CK_RightBracket:
  80. return CXCompletionChunk_RightBracket;
  81. case CodeCompletionString::CK_LeftBrace:
  82. return CXCompletionChunk_LeftBrace;
  83. case CodeCompletionString::CK_RightBrace:
  84. return CXCompletionChunk_RightBrace;
  85. case CodeCompletionString::CK_LeftAngle:
  86. return CXCompletionChunk_LeftAngle;
  87. case CodeCompletionString::CK_RightAngle:
  88. return CXCompletionChunk_RightAngle;
  89. case CodeCompletionString::CK_Comma:
  90. return CXCompletionChunk_Comma;
  91. case CodeCompletionString::CK_Colon:
  92. return CXCompletionChunk_Colon;
  93. case CodeCompletionString::CK_SemiColon:
  94. return CXCompletionChunk_SemiColon;
  95. case CodeCompletionString::CK_Equal:
  96. return CXCompletionChunk_Equal;
  97. case CodeCompletionString::CK_HorizontalSpace:
  98. return CXCompletionChunk_HorizontalSpace;
  99. case CodeCompletionString::CK_VerticalSpace:
  100. return CXCompletionChunk_VerticalSpace;
  101. }
  102. llvm_unreachable("Invalid CompletionKind!");
  103. }
  104. CXString clang_getCompletionChunkText(CXCompletionString completion_string,
  105. unsigned chunk_number) {
  106. CodeCompletionString *CCStr = (CodeCompletionString *)completion_string;
  107. if (!CCStr || chunk_number >= CCStr->size())
  108. return cxstring::createNull();
  109. switch ((*CCStr)[chunk_number].Kind) {
  110. case CodeCompletionString::CK_TypedText:
  111. case CodeCompletionString::CK_Text:
  112. case CodeCompletionString::CK_Placeholder:
  113. case CodeCompletionString::CK_CurrentParameter:
  114. case CodeCompletionString::CK_Informative:
  115. case CodeCompletionString::CK_LeftParen:
  116. case CodeCompletionString::CK_RightParen:
  117. case CodeCompletionString::CK_LeftBracket:
  118. case CodeCompletionString::CK_RightBracket:
  119. case CodeCompletionString::CK_LeftBrace:
  120. case CodeCompletionString::CK_RightBrace:
  121. case CodeCompletionString::CK_LeftAngle:
  122. case CodeCompletionString::CK_RightAngle:
  123. case CodeCompletionString::CK_Comma:
  124. case CodeCompletionString::CK_ResultType:
  125. case CodeCompletionString::CK_Colon:
  126. case CodeCompletionString::CK_SemiColon:
  127. case CodeCompletionString::CK_Equal:
  128. case CodeCompletionString::CK_HorizontalSpace:
  129. case CodeCompletionString::CK_VerticalSpace:
  130. return cxstring::createRef((*CCStr)[chunk_number].Text);
  131. case CodeCompletionString::CK_Optional:
  132. // Note: treated as an empty text block.
  133. return cxstring::createEmpty();
  134. }
  135. llvm_unreachable("Invalid CodeCompletionString Kind!");
  136. }
  137. CXCompletionString
  138. clang_getCompletionChunkCompletionString(CXCompletionString completion_string,
  139. unsigned chunk_number) {
  140. CodeCompletionString *CCStr = (CodeCompletionString *)completion_string;
  141. if (!CCStr || chunk_number >= CCStr->size())
  142. return nullptr;
  143. switch ((*CCStr)[chunk_number].Kind) {
  144. case CodeCompletionString::CK_TypedText:
  145. case CodeCompletionString::CK_Text:
  146. case CodeCompletionString::CK_Placeholder:
  147. case CodeCompletionString::CK_CurrentParameter:
  148. case CodeCompletionString::CK_Informative:
  149. case CodeCompletionString::CK_LeftParen:
  150. case CodeCompletionString::CK_RightParen:
  151. case CodeCompletionString::CK_LeftBracket:
  152. case CodeCompletionString::CK_RightBracket:
  153. case CodeCompletionString::CK_LeftBrace:
  154. case CodeCompletionString::CK_RightBrace:
  155. case CodeCompletionString::CK_LeftAngle:
  156. case CodeCompletionString::CK_RightAngle:
  157. case CodeCompletionString::CK_Comma:
  158. case CodeCompletionString::CK_ResultType:
  159. case CodeCompletionString::CK_Colon:
  160. case CodeCompletionString::CK_SemiColon:
  161. case CodeCompletionString::CK_Equal:
  162. case CodeCompletionString::CK_HorizontalSpace:
  163. case CodeCompletionString::CK_VerticalSpace:
  164. return nullptr;
  165. case CodeCompletionString::CK_Optional:
  166. // Note: treated as an empty text block.
  167. return (*CCStr)[chunk_number].Optional;
  168. }
  169. llvm_unreachable("Invalid CompletionKind!");
  170. }
  171. unsigned clang_getNumCompletionChunks(CXCompletionString completion_string) {
  172. CodeCompletionString *CCStr = (CodeCompletionString *)completion_string;
  173. return CCStr? CCStr->size() : 0;
  174. }
  175. unsigned clang_getCompletionPriority(CXCompletionString completion_string) {
  176. CodeCompletionString *CCStr = (CodeCompletionString *)completion_string;
  177. return CCStr? CCStr->getPriority() : unsigned(CCP_Unlikely);
  178. }
  179. enum CXAvailabilityKind
  180. clang_getCompletionAvailability(CXCompletionString completion_string) {
  181. CodeCompletionString *CCStr = (CodeCompletionString *)completion_string;
  182. return CCStr? static_cast<CXAvailabilityKind>(CCStr->getAvailability())
  183. : CXAvailability_Available;
  184. }
  185. unsigned clang_getCompletionNumAnnotations(CXCompletionString completion_string)
  186. {
  187. CodeCompletionString *CCStr = (CodeCompletionString *)completion_string;
  188. return CCStr ? CCStr->getAnnotationCount() : 0;
  189. }
  190. CXString clang_getCompletionAnnotation(CXCompletionString completion_string,
  191. unsigned annotation_number) {
  192. CodeCompletionString *CCStr = (CodeCompletionString *)completion_string;
  193. return CCStr ? cxstring::createRef(CCStr->getAnnotation(annotation_number))
  194. : cxstring::createNull();
  195. }
  196. CXString
  197. clang_getCompletionParent(CXCompletionString completion_string,
  198. CXCursorKind *kind) {
  199. if (kind)
  200. *kind = CXCursor_NotImplemented;
  201. CodeCompletionString *CCStr = (CodeCompletionString *)completion_string;
  202. if (!CCStr)
  203. return cxstring::createNull();
  204. return cxstring::createRef(CCStr->getParentContextName());
  205. }
  206. CXString
  207. clang_getCompletionBriefComment(CXCompletionString completion_string) {
  208. CodeCompletionString *CCStr = (CodeCompletionString *)completion_string;
  209. if (!CCStr)
  210. return cxstring::createNull();
  211. return cxstring::createRef(CCStr->getBriefComment());
  212. }
  213. namespace {
  214. /// \brief The CXCodeCompleteResults structure we allocate internally;
  215. /// the client only sees the initial CXCodeCompleteResults structure.
  216. ///
  217. /// Normally, clients of CXString shouldn't care whether or not a CXString is
  218. /// managed by a pool or by explicitly malloc'ed memory. But
  219. /// AllocatedCXCodeCompleteResults outlives the CXTranslationUnit, so we can
  220. /// not rely on the StringPool in the TU.
  221. struct AllocatedCXCodeCompleteResults : public CXCodeCompleteResults {
  222. AllocatedCXCodeCompleteResults(IntrusiveRefCntPtr<FileManager> FileMgr);
  223. ~AllocatedCXCodeCompleteResults();
  224. /// \brief Diagnostics produced while performing code completion.
  225. SmallVector<StoredDiagnostic, 8> Diagnostics;
  226. /// \brief Allocated API-exposed wrappters for Diagnostics.
  227. SmallVector<CXStoredDiagnostic *, 8> DiagnosticsWrappers;
  228. IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
  229. /// \brief Diag object
  230. IntrusiveRefCntPtr<DiagnosticsEngine> Diag;
  231. /// \brief Language options used to adjust source locations.
  232. LangOptions LangOpts;
  233. /// \brief File manager, used for diagnostics.
  234. IntrusiveRefCntPtr<FileManager> FileMgr;
  235. /// \brief Source manager, used for diagnostics.
  236. IntrusiveRefCntPtr<SourceManager> SourceMgr;
  237. /// \brief Temporary files that should be removed once we have finished
  238. /// with the code-completion results.
  239. std::vector<std::string> TemporaryFiles;
  240. /// \brief Temporary buffers that will be deleted once we have finished with
  241. /// the code-completion results.
  242. SmallVector<const llvm::MemoryBuffer *, 1> TemporaryBuffers;
  243. /// \brief Allocator used to store globally cached code-completion results.
  244. IntrusiveRefCntPtr<clang::GlobalCodeCompletionAllocator>
  245. CachedCompletionAllocator;
  246. /// \brief Allocator used to store code completion results.
  247. IntrusiveRefCntPtr<clang::GlobalCodeCompletionAllocator>
  248. CodeCompletionAllocator;
  249. /// \brief Context under which completion occurred.
  250. enum clang::CodeCompletionContext::Kind ContextKind;
  251. /// \brief A bitfield representing the acceptable completions for the
  252. /// current context.
  253. unsigned long long Contexts;
  254. /// \brief The kind of the container for the current context for completions.
  255. enum CXCursorKind ContainerKind;
  256. /// \brief The USR of the container for the current context for completions.
  257. std::string ContainerUSR;
  258. /// \brief a boolean value indicating whether there is complete information
  259. /// about the container
  260. unsigned ContainerIsIncomplete;
  261. /// \brief A string containing the Objective-C selector entered thus far for a
  262. /// message send.
  263. std::string Selector;
  264. };
  265. } // end anonymous namespace
  266. /// \brief Tracks the number of code-completion result objects that are
  267. /// currently active.
  268. ///
  269. /// Used for debugging purposes only.
  270. static std::atomic<unsigned> CodeCompletionResultObjects;
  271. AllocatedCXCodeCompleteResults::AllocatedCXCodeCompleteResults(
  272. IntrusiveRefCntPtr<FileManager> FileMgr)
  273. : CXCodeCompleteResults(),
  274. DiagOpts(new DiagnosticOptions),
  275. Diag(new DiagnosticsEngine(
  276. IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts)),
  277. FileMgr(FileMgr), SourceMgr(new SourceManager(*Diag, *FileMgr)),
  278. CodeCompletionAllocator(new clang::GlobalCodeCompletionAllocator),
  279. Contexts(CXCompletionContext_Unknown),
  280. ContainerKind(CXCursor_InvalidCode), ContainerIsIncomplete(1) {
  281. if (getenv("LIBCLANG_OBJTRACKING"))
  282. fprintf(stderr, "+++ %u completion results\n",
  283. ++CodeCompletionResultObjects);
  284. }
  285. AllocatedCXCodeCompleteResults::~AllocatedCXCodeCompleteResults() {
  286. llvm::DeleteContainerPointers(DiagnosticsWrappers);
  287. delete [] Results;
  288. for (unsigned I = 0, N = TemporaryFiles.size(); I != N; ++I)
  289. llvm::sys::fs::remove(TemporaryFiles[I]);
  290. for (unsigned I = 0, N = TemporaryBuffers.size(); I != N; ++I)
  291. delete TemporaryBuffers[I];
  292. if (getenv("LIBCLANG_OBJTRACKING"))
  293. fprintf(stderr, "--- %u completion results\n",
  294. --CodeCompletionResultObjects);
  295. }
  296. } // end extern "C"
  297. static unsigned long long getContextsForContextKind(
  298. enum CodeCompletionContext::Kind kind,
  299. Sema &S) {
  300. unsigned long long contexts = 0;
  301. switch (kind) {
  302. case CodeCompletionContext::CCC_OtherWithMacros: {
  303. //We can allow macros here, but we don't know what else is permissible
  304. //So we'll say the only thing permissible are macros
  305. contexts = CXCompletionContext_MacroName;
  306. break;
  307. }
  308. case CodeCompletionContext::CCC_TopLevel:
  309. case CodeCompletionContext::CCC_ObjCIvarList:
  310. case CodeCompletionContext::CCC_ClassStructUnion:
  311. case CodeCompletionContext::CCC_Type: {
  312. contexts = CXCompletionContext_AnyType |
  313. CXCompletionContext_ObjCInterface;
  314. if (S.getLangOpts().CPlusPlus) {
  315. contexts |= CXCompletionContext_EnumTag |
  316. CXCompletionContext_UnionTag |
  317. CXCompletionContext_StructTag |
  318. CXCompletionContext_ClassTag |
  319. CXCompletionContext_NestedNameSpecifier;
  320. }
  321. break;
  322. }
  323. case CodeCompletionContext::CCC_Statement: {
  324. contexts = CXCompletionContext_AnyType |
  325. CXCompletionContext_ObjCInterface |
  326. CXCompletionContext_AnyValue;
  327. if (S.getLangOpts().CPlusPlus) {
  328. contexts |= CXCompletionContext_EnumTag |
  329. CXCompletionContext_UnionTag |
  330. CXCompletionContext_StructTag |
  331. CXCompletionContext_ClassTag |
  332. CXCompletionContext_NestedNameSpecifier;
  333. }
  334. break;
  335. }
  336. case CodeCompletionContext::CCC_Expression: {
  337. contexts = CXCompletionContext_AnyValue;
  338. if (S.getLangOpts().CPlusPlus) {
  339. contexts |= CXCompletionContext_AnyType |
  340. CXCompletionContext_ObjCInterface |
  341. CXCompletionContext_EnumTag |
  342. CXCompletionContext_UnionTag |
  343. CXCompletionContext_StructTag |
  344. CXCompletionContext_ClassTag |
  345. CXCompletionContext_NestedNameSpecifier;
  346. }
  347. break;
  348. }
  349. case CodeCompletionContext::CCC_ObjCMessageReceiver: {
  350. contexts = CXCompletionContext_ObjCObjectValue |
  351. CXCompletionContext_ObjCSelectorValue |
  352. CXCompletionContext_ObjCInterface;
  353. if (S.getLangOpts().CPlusPlus) {
  354. contexts |= CXCompletionContext_CXXClassTypeValue |
  355. CXCompletionContext_AnyType |
  356. CXCompletionContext_EnumTag |
  357. CXCompletionContext_UnionTag |
  358. CXCompletionContext_StructTag |
  359. CXCompletionContext_ClassTag |
  360. CXCompletionContext_NestedNameSpecifier;
  361. }
  362. break;
  363. }
  364. case CodeCompletionContext::CCC_DotMemberAccess: {
  365. contexts = CXCompletionContext_DotMemberAccess;
  366. break;
  367. }
  368. case CodeCompletionContext::CCC_ArrowMemberAccess: {
  369. contexts = CXCompletionContext_ArrowMemberAccess;
  370. break;
  371. }
  372. case CodeCompletionContext::CCC_ObjCPropertyAccess: {
  373. contexts = CXCompletionContext_ObjCPropertyAccess;
  374. break;
  375. }
  376. case CodeCompletionContext::CCC_EnumTag: {
  377. contexts = CXCompletionContext_EnumTag |
  378. CXCompletionContext_NestedNameSpecifier;
  379. break;
  380. }
  381. case CodeCompletionContext::CCC_UnionTag: {
  382. contexts = CXCompletionContext_UnionTag |
  383. CXCompletionContext_NestedNameSpecifier;
  384. break;
  385. }
  386. case CodeCompletionContext::CCC_ClassOrStructTag: {
  387. contexts = CXCompletionContext_StructTag |
  388. CXCompletionContext_ClassTag |
  389. CXCompletionContext_NestedNameSpecifier;
  390. break;
  391. }
  392. case CodeCompletionContext::CCC_ObjCProtocolName: {
  393. contexts = CXCompletionContext_ObjCProtocol;
  394. break;
  395. }
  396. case CodeCompletionContext::CCC_Namespace: {
  397. contexts = CXCompletionContext_Namespace;
  398. break;
  399. }
  400. case CodeCompletionContext::CCC_PotentiallyQualifiedName: {
  401. contexts = CXCompletionContext_NestedNameSpecifier;
  402. break;
  403. }
  404. case CodeCompletionContext::CCC_MacroNameUse: {
  405. contexts = CXCompletionContext_MacroName;
  406. break;
  407. }
  408. case CodeCompletionContext::CCC_NaturalLanguage: {
  409. contexts = CXCompletionContext_NaturalLanguage;
  410. break;
  411. }
  412. case CodeCompletionContext::CCC_SelectorName: {
  413. contexts = CXCompletionContext_ObjCSelectorName;
  414. break;
  415. }
  416. case CodeCompletionContext::CCC_ParenthesizedExpression: {
  417. contexts = CXCompletionContext_AnyType |
  418. CXCompletionContext_ObjCInterface |
  419. CXCompletionContext_AnyValue;
  420. if (S.getLangOpts().CPlusPlus) {
  421. contexts |= CXCompletionContext_EnumTag |
  422. CXCompletionContext_UnionTag |
  423. CXCompletionContext_StructTag |
  424. CXCompletionContext_ClassTag |
  425. CXCompletionContext_NestedNameSpecifier;
  426. }
  427. break;
  428. }
  429. case CodeCompletionContext::CCC_ObjCInstanceMessage: {
  430. contexts = CXCompletionContext_ObjCInstanceMessage;
  431. break;
  432. }
  433. case CodeCompletionContext::CCC_ObjCClassMessage: {
  434. contexts = CXCompletionContext_ObjCClassMessage;
  435. break;
  436. }
  437. case CodeCompletionContext::CCC_ObjCInterfaceName: {
  438. contexts = CXCompletionContext_ObjCInterface;
  439. break;
  440. }
  441. case CodeCompletionContext::CCC_ObjCCategoryName: {
  442. contexts = CXCompletionContext_ObjCCategory;
  443. break;
  444. }
  445. case CodeCompletionContext::CCC_Other:
  446. case CodeCompletionContext::CCC_ObjCInterface:
  447. case CodeCompletionContext::CCC_ObjCImplementation:
  448. case CodeCompletionContext::CCC_Name:
  449. case CodeCompletionContext::CCC_MacroName:
  450. case CodeCompletionContext::CCC_PreprocessorExpression:
  451. case CodeCompletionContext::CCC_PreprocessorDirective:
  452. case CodeCompletionContext::CCC_TypeQualifiers: {
  453. //Only Clang results should be accepted, so we'll set all of the other
  454. //context bits to 0 (i.e. the empty set)
  455. contexts = CXCompletionContext_Unexposed;
  456. break;
  457. }
  458. case CodeCompletionContext::CCC_Recovery: {
  459. //We don't know what the current context is, so we'll return unknown
  460. //This is the equivalent of setting all of the other context bits
  461. contexts = CXCompletionContext_Unknown;
  462. break;
  463. }
  464. }
  465. return contexts;
  466. }
  467. namespace {
  468. class CaptureCompletionResults : public CodeCompleteConsumer {
  469. AllocatedCXCodeCompleteResults &AllocatedResults;
  470. CodeCompletionTUInfo CCTUInfo;
  471. SmallVector<CXCompletionResult, 16> StoredResults;
  472. CXTranslationUnit *TU;
  473. public:
  474. CaptureCompletionResults(const CodeCompleteOptions &Opts,
  475. AllocatedCXCodeCompleteResults &Results,
  476. CXTranslationUnit *TranslationUnit)
  477. : CodeCompleteConsumer(Opts, false),
  478. AllocatedResults(Results), CCTUInfo(Results.CodeCompletionAllocator),
  479. TU(TranslationUnit) { }
  480. ~CaptureCompletionResults() override { Finish(); }
  481. void ProcessCodeCompleteResults(Sema &S,
  482. CodeCompletionContext Context,
  483. CodeCompletionResult *Results,
  484. unsigned NumResults) override {
  485. StoredResults.reserve(StoredResults.size() + NumResults);
  486. for (unsigned I = 0; I != NumResults; ++I) {
  487. CodeCompletionString *StoredCompletion
  488. = Results[I].CreateCodeCompletionString(S, getAllocator(),
  489. getCodeCompletionTUInfo(),
  490. includeBriefComments());
  491. CXCompletionResult R;
  492. R.CursorKind = Results[I].CursorKind;
  493. R.CompletionString = StoredCompletion;
  494. StoredResults.push_back(R);
  495. }
  496. enum CodeCompletionContext::Kind contextKind = Context.getKind();
  497. AllocatedResults.ContextKind = contextKind;
  498. AllocatedResults.Contexts = getContextsForContextKind(contextKind, S);
  499. AllocatedResults.Selector = "";
  500. ArrayRef<IdentifierInfo *> SelIdents = Context.getSelIdents();
  501. for (ArrayRef<IdentifierInfo *>::iterator I = SelIdents.begin(),
  502. E = SelIdents.end();
  503. I != E; ++I) {
  504. if (IdentifierInfo *selIdent = *I)
  505. AllocatedResults.Selector += selIdent->getName();
  506. AllocatedResults.Selector += ":";
  507. }
  508. QualType baseType = Context.getBaseType();
  509. NamedDecl *D = nullptr;
  510. if (!baseType.isNull()) {
  511. // Get the declaration for a class/struct/union/enum type
  512. if (const TagType *Tag = baseType->getAs<TagType>())
  513. D = Tag->getDecl();
  514. // Get the @interface declaration for a (possibly-qualified) Objective-C
  515. // object pointer type, e.g., NSString*
  516. else if (const ObjCObjectPointerType *ObjPtr =
  517. baseType->getAs<ObjCObjectPointerType>())
  518. D = ObjPtr->getInterfaceDecl();
  519. // Get the @interface declaration for an Objective-C object type
  520. else if (const ObjCObjectType *Obj = baseType->getAs<ObjCObjectType>())
  521. D = Obj->getInterface();
  522. // Get the class for a C++ injected-class-name
  523. else if (const InjectedClassNameType *Injected =
  524. baseType->getAs<InjectedClassNameType>())
  525. D = Injected->getDecl();
  526. }
  527. if (D != nullptr) {
  528. CXCursor cursor = cxcursor::MakeCXCursor(D, *TU);
  529. AllocatedResults.ContainerKind = clang_getCursorKind(cursor);
  530. CXString CursorUSR = clang_getCursorUSR(cursor);
  531. AllocatedResults.ContainerUSR = clang_getCString(CursorUSR);
  532. clang_disposeString(CursorUSR);
  533. const Type *type = baseType.getTypePtrOrNull();
  534. if (type) {
  535. AllocatedResults.ContainerIsIncomplete = type->isIncompleteType();
  536. }
  537. else {
  538. AllocatedResults.ContainerIsIncomplete = 1;
  539. }
  540. }
  541. else {
  542. AllocatedResults.ContainerKind = CXCursor_InvalidCode;
  543. AllocatedResults.ContainerUSR.clear();
  544. AllocatedResults.ContainerIsIncomplete = 1;
  545. }
  546. }
  547. void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
  548. OverloadCandidate *Candidates,
  549. unsigned NumCandidates) override {
  550. StoredResults.reserve(StoredResults.size() + NumCandidates);
  551. for (unsigned I = 0; I != NumCandidates; ++I) {
  552. CodeCompletionString *StoredCompletion
  553. = Candidates[I].CreateSignatureString(CurrentArg, S, getAllocator(),
  554. getCodeCompletionTUInfo(),
  555. includeBriefComments());
  556. CXCompletionResult R;
  557. R.CursorKind = CXCursor_OverloadCandidate;
  558. R.CompletionString = StoredCompletion;
  559. StoredResults.push_back(R);
  560. }
  561. }
  562. CodeCompletionAllocator &getAllocator() override {
  563. return *AllocatedResults.CodeCompletionAllocator;
  564. }
  565. CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo;}
  566. private:
  567. void Finish() {
  568. AllocatedResults.Results = new CXCompletionResult [StoredResults.size()];
  569. AllocatedResults.NumResults = StoredResults.size();
  570. std::memcpy(AllocatedResults.Results, StoredResults.data(),
  571. StoredResults.size() * sizeof(CXCompletionResult));
  572. StoredResults.clear();
  573. }
  574. };
  575. }
  576. extern "C" {
  577. struct CodeCompleteAtInfo {
  578. CXTranslationUnit TU;
  579. const char *complete_filename;
  580. unsigned complete_line;
  581. unsigned complete_column;
  582. ArrayRef<CXUnsavedFile> unsaved_files;
  583. unsigned options;
  584. CXCodeCompleteResults *result;
  585. };
  586. static void clang_codeCompleteAt_Impl(void *UserData) {
  587. CodeCompleteAtInfo *CCAI = static_cast<CodeCompleteAtInfo*>(UserData);
  588. CXTranslationUnit TU = CCAI->TU;
  589. const char *complete_filename = CCAI->complete_filename;
  590. unsigned complete_line = CCAI->complete_line;
  591. unsigned complete_column = CCAI->complete_column;
  592. unsigned options = CCAI->options;
  593. bool IncludeBriefComments = options & CXCodeComplete_IncludeBriefComments;
  594. CCAI->result = nullptr;
  595. #ifdef UDP_CODE_COMPLETION_LOGGER
  596. #ifdef UDP_CODE_COMPLETION_LOGGER_PORT
  597. const llvm::TimeRecord &StartTime = llvm::TimeRecord::getCurrentTime();
  598. #endif
  599. #endif
  600. bool EnableLogging = getenv("LIBCLANG_CODE_COMPLETION_LOGGING") != nullptr;
  601. if (cxtu::isNotUsableTU(TU)) {
  602. LOG_BAD_TU(TU);
  603. return;
  604. }
  605. ASTUnit *AST = cxtu::getASTUnit(TU);
  606. if (!AST)
  607. return;
  608. CIndexer *CXXIdx = TU->CIdx;
  609. if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing))
  610. setThreadBackgroundPriority();
  611. ASTUnit::ConcurrencyCheck Check(*AST);
  612. // Perform the remapping of source files.
  613. SmallVector<ASTUnit::RemappedFile, 4> RemappedFiles;
  614. for (auto &UF : CCAI->unsaved_files) {
  615. std::unique_ptr<llvm::MemoryBuffer> MB =
  616. llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename);
  617. RemappedFiles.push_back(std::make_pair(UF.Filename, MB.release()));
  618. }
  619. if (EnableLogging) {
  620. // FIXME: Add logging.
  621. }
  622. // Parse the resulting source file to find code-completion results.
  623. AllocatedCXCodeCompleteResults *Results = new AllocatedCXCodeCompleteResults(
  624. &AST->getFileManager());
  625. Results->Results = nullptr;
  626. Results->NumResults = 0;
  627. // Create a code-completion consumer to capture the results.
  628. CodeCompleteOptions Opts;
  629. Opts.IncludeBriefComments = IncludeBriefComments;
  630. CaptureCompletionResults Capture(Opts, *Results, &TU);
  631. // Perform completion.
  632. AST->CodeComplete(complete_filename, complete_line, complete_column,
  633. RemappedFiles,
  634. (options & CXCodeComplete_IncludeMacros),
  635. (options & CXCodeComplete_IncludeCodePatterns),
  636. IncludeBriefComments,
  637. Capture,
  638. *Results->Diag, Results->LangOpts, *Results->SourceMgr,
  639. *Results->FileMgr, Results->Diagnostics,
  640. Results->TemporaryBuffers);
  641. Results->DiagnosticsWrappers.resize(Results->Diagnostics.size());
  642. // Keep a reference to the allocator used for cached global completions, so
  643. // that we can be sure that the memory used by our code completion strings
  644. // doesn't get freed due to subsequent reparses (while the code completion
  645. // results are still active).
  646. Results->CachedCompletionAllocator = AST->getCachedCompletionAllocator();
  647. #ifdef UDP_CODE_COMPLETION_LOGGER
  648. #ifdef UDP_CODE_COMPLETION_LOGGER_PORT
  649. const llvm::TimeRecord &EndTime = llvm::TimeRecord::getCurrentTime();
  650. SmallString<256> LogResult;
  651. llvm::raw_svector_ostream os(LogResult);
  652. // Figure out the language and whether or not it uses PCH.
  653. const char *lang = 0;
  654. bool usesPCH = false;
  655. for (std::vector<const char*>::iterator I = argv.begin(), E = argv.end();
  656. I != E; ++I) {
  657. if (*I == 0)
  658. continue;
  659. if (strcmp(*I, "-x") == 0) {
  660. if (I + 1 != E) {
  661. lang = *(++I);
  662. continue;
  663. }
  664. }
  665. else if (strcmp(*I, "-include") == 0) {
  666. if (I+1 != E) {
  667. const char *arg = *(++I);
  668. SmallString<512> pchName;
  669. {
  670. llvm::raw_svector_ostream os(pchName);
  671. os << arg << ".pth";
  672. }
  673. pchName.push_back('\0');
  674. struct stat stat_results;
  675. if (stat(pchName.str().c_str(), &stat_results) == 0)
  676. usesPCH = true;
  677. continue;
  678. }
  679. }
  680. }
  681. os << "{ ";
  682. os << "\"wall\": " << (EndTime.getWallTime() - StartTime.getWallTime());
  683. os << ", \"numRes\": " << Results->NumResults;
  684. os << ", \"diags\": " << Results->Diagnostics.size();
  685. os << ", \"pch\": " << (usesPCH ? "true" : "false");
  686. os << ", \"lang\": \"" << (lang ? lang : "<unknown>") << '"';
  687. const char *name = getlogin();
  688. os << ", \"user\": \"" << (name ? name : "unknown") << '"';
  689. os << ", \"clangVer\": \"" << getClangFullVersion() << '"';
  690. os << " }";
  691. StringRef res = os.str();
  692. if (res.size() > 0) {
  693. do {
  694. // Setup the UDP socket.
  695. struct sockaddr_in servaddr;
  696. bzero(&servaddr, sizeof(servaddr));
  697. servaddr.sin_family = AF_INET;
  698. servaddr.sin_port = htons(UDP_CODE_COMPLETION_LOGGER_PORT);
  699. if (inet_pton(AF_INET, UDP_CODE_COMPLETION_LOGGER,
  700. &servaddr.sin_addr) <= 0)
  701. break;
  702. int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
  703. if (sockfd < 0)
  704. break;
  705. sendto(sockfd, res.data(), res.size(), 0,
  706. (struct sockaddr *)&servaddr, sizeof(servaddr));
  707. close(sockfd);
  708. }
  709. while (false);
  710. }
  711. #endif
  712. #endif
  713. CCAI->result = Results;
  714. }
  715. CXCodeCompleteResults *clang_codeCompleteAt(CXTranslationUnit TU,
  716. const char *complete_filename,
  717. unsigned complete_line,
  718. unsigned complete_column,
  719. struct CXUnsavedFile *unsaved_files,
  720. unsigned num_unsaved_files,
  721. unsigned options) {
  722. LOG_FUNC_SECTION {
  723. *Log << TU << ' '
  724. << complete_filename << ':' << complete_line << ':' << complete_column;
  725. }
  726. if (num_unsaved_files && !unsaved_files)
  727. return nullptr;
  728. CodeCompleteAtInfo CCAI = {TU, complete_filename, complete_line,
  729. complete_column, llvm::makeArrayRef(unsaved_files, num_unsaved_files),
  730. options, nullptr};
  731. if (getenv("LIBCLANG_NOTHREADS")) {
  732. clang_codeCompleteAt_Impl(&CCAI);
  733. return CCAI.result;
  734. }
  735. llvm::CrashRecoveryContext CRC;
  736. if (!RunSafely(CRC, clang_codeCompleteAt_Impl, &CCAI)) {
  737. fprintf(stderr, "libclang: crash detected in code completion\n");
  738. cxtu::getASTUnit(TU)->setUnsafeToFree(true);
  739. return nullptr;
  740. } else if (getenv("LIBCLANG_RESOURCE_USAGE"))
  741. PrintLibclangResourceUsage(TU);
  742. return CCAI.result;
  743. }
  744. unsigned clang_defaultCodeCompleteOptions(void) {
  745. return CXCodeComplete_IncludeMacros;
  746. }
  747. void clang_disposeCodeCompleteResults(CXCodeCompleteResults *ResultsIn) {
  748. if (!ResultsIn)
  749. return;
  750. AllocatedCXCodeCompleteResults *Results
  751. = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn);
  752. delete Results;
  753. }
  754. unsigned
  755. clang_codeCompleteGetNumDiagnostics(CXCodeCompleteResults *ResultsIn) {
  756. AllocatedCXCodeCompleteResults *Results
  757. = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn);
  758. if (!Results)
  759. return 0;
  760. return Results->Diagnostics.size();
  761. }
  762. CXDiagnostic
  763. clang_codeCompleteGetDiagnostic(CXCodeCompleteResults *ResultsIn,
  764. unsigned Index) {
  765. AllocatedCXCodeCompleteResults *Results
  766. = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn);
  767. if (!Results || Index >= Results->Diagnostics.size())
  768. return nullptr;
  769. CXStoredDiagnostic *Diag = Results->DiagnosticsWrappers[Index];
  770. if (!Diag)
  771. Results->DiagnosticsWrappers[Index] = Diag =
  772. new CXStoredDiagnostic(Results->Diagnostics[Index], Results->LangOpts);
  773. return Diag;
  774. }
  775. unsigned long long
  776. clang_codeCompleteGetContexts(CXCodeCompleteResults *ResultsIn) {
  777. AllocatedCXCodeCompleteResults *Results
  778. = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn);
  779. if (!Results)
  780. return 0;
  781. return Results->Contexts;
  782. }
  783. enum CXCursorKind clang_codeCompleteGetContainerKind(
  784. CXCodeCompleteResults *ResultsIn,
  785. unsigned *IsIncomplete) {
  786. AllocatedCXCodeCompleteResults *Results =
  787. static_cast<AllocatedCXCodeCompleteResults *>(ResultsIn);
  788. if (!Results)
  789. return CXCursor_InvalidCode;
  790. if (IsIncomplete != nullptr) {
  791. *IsIncomplete = Results->ContainerIsIncomplete;
  792. }
  793. return Results->ContainerKind;
  794. }
  795. CXString clang_codeCompleteGetContainerUSR(CXCodeCompleteResults *ResultsIn) {
  796. AllocatedCXCodeCompleteResults *Results =
  797. static_cast<AllocatedCXCodeCompleteResults *>(ResultsIn);
  798. if (!Results)
  799. return cxstring::createEmpty();
  800. return cxstring::createRef(Results->ContainerUSR.c_str());
  801. }
  802. CXString clang_codeCompleteGetObjCSelector(CXCodeCompleteResults *ResultsIn) {
  803. AllocatedCXCodeCompleteResults *Results =
  804. static_cast<AllocatedCXCodeCompleteResults *>(ResultsIn);
  805. if (!Results)
  806. return cxstring::createEmpty();
  807. return cxstring::createDup(Results->Selector);
  808. }
  809. } // end extern "C"
  810. /// \brief Simple utility function that appends a \p New string to the given
  811. /// \p Old string, using the \p Buffer for storage.
  812. ///
  813. /// \param Old The string to which we are appending. This parameter will be
  814. /// updated to reflect the complete string.
  815. ///
  816. ///
  817. /// \param New The string to append to \p Old.
  818. ///
  819. /// \param Buffer A buffer that stores the actual, concatenated string. It will
  820. /// be used if the old string is already-non-empty.
  821. static void AppendToString(StringRef &Old, StringRef New,
  822. SmallString<256> &Buffer) {
  823. if (Old.empty()) {
  824. Old = New;
  825. return;
  826. }
  827. if (Buffer.empty())
  828. Buffer.append(Old.begin(), Old.end());
  829. Buffer.append(New.begin(), New.end());
  830. Old = Buffer.str();
  831. }
  832. /// \brief Get the typed-text blocks from the given code-completion string
  833. /// and return them as a single string.
  834. ///
  835. /// \param String The code-completion string whose typed-text blocks will be
  836. /// concatenated.
  837. ///
  838. /// \param Buffer A buffer used for storage of the completed name.
  839. static StringRef GetTypedName(CodeCompletionString *String,
  840. SmallString<256> &Buffer) {
  841. StringRef Result;
  842. for (CodeCompletionString::iterator C = String->begin(), CEnd = String->end();
  843. C != CEnd; ++C) {
  844. if (C->Kind == CodeCompletionString::CK_TypedText)
  845. AppendToString(Result, C->Text, Buffer);
  846. }
  847. return Result;
  848. }
  849. namespace {
  850. struct OrderCompletionResults {
  851. bool operator()(const CXCompletionResult &XR,
  852. const CXCompletionResult &YR) const {
  853. CodeCompletionString *X
  854. = (CodeCompletionString *)XR.CompletionString;
  855. CodeCompletionString *Y
  856. = (CodeCompletionString *)YR.CompletionString;
  857. SmallString<256> XBuffer;
  858. StringRef XText = GetTypedName(X, XBuffer);
  859. SmallString<256> YBuffer;
  860. StringRef YText = GetTypedName(Y, YBuffer);
  861. if (XText.empty() || YText.empty())
  862. return !XText.empty();
  863. int result = XText.compare_lower(YText);
  864. if (result < 0)
  865. return true;
  866. if (result > 0)
  867. return false;
  868. result = XText.compare(YText);
  869. return result < 0;
  870. }
  871. };
  872. }
  873. extern "C" {
  874. void clang_sortCodeCompletionResults(CXCompletionResult *Results,
  875. unsigned NumResults) {
  876. std::stable_sort(Results, Results + NumResults, OrderCompletionResults());
  877. }
  878. }