1 //===--- CodeCompleteConsumer.cpp - Code Completion Interface ---*- C++ -*-===//
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 CodeCompleteConsumer class.
11 //
12 //===----------------------------------------------------------------------===//
13 #include "clang/Sema/CodeCompleteConsumer.h"
14 #include "clang-c/Index.h"
15 #include "clang/AST/DeclCXX.h"
16 #include "clang/AST/DeclObjC.h"
17 #include "clang/AST/DeclTemplate.h"
18 #include "clang/Sema/Scope.h"
19 #include "clang/Sema/Sema.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/SmallString.h"
22 #include "llvm/ADT/Twine.h"
23 #include "llvm/Support/raw_ostream.h"
24 #include <algorithm>
25 #include <cstring>
26 #include <functional>
27
28 using namespace clang;
29
30 //===----------------------------------------------------------------------===//
31 // Code completion context implementation
32 //===----------------------------------------------------------------------===//
33
wantConstructorResults() const34 bool CodeCompletionContext::wantConstructorResults() const {
35 switch (Kind) {
36 case CCC_Recovery:
37 case CCC_Statement:
38 case CCC_Expression:
39 case CCC_ObjCMessageReceiver:
40 case CCC_ParenthesizedExpression:
41 return true;
42
43 case CCC_TopLevel:
44 case CCC_ObjCInterface:
45 case CCC_ObjCImplementation:
46 case CCC_ObjCIvarList:
47 case CCC_ClassStructUnion:
48 case CCC_DotMemberAccess:
49 case CCC_ArrowMemberAccess:
50 case CCC_ObjCPropertyAccess:
51 case CCC_EnumTag:
52 case CCC_UnionTag:
53 case CCC_ClassOrStructTag:
54 case CCC_ObjCProtocolName:
55 case CCC_Namespace:
56 case CCC_Type:
57 case CCC_Name:
58 case CCC_PotentiallyQualifiedName:
59 case CCC_MacroName:
60 case CCC_MacroNameUse:
61 case CCC_PreprocessorExpression:
62 case CCC_PreprocessorDirective:
63 case CCC_NaturalLanguage:
64 case CCC_SelectorName:
65 case CCC_TypeQualifiers:
66 case CCC_Other:
67 case CCC_OtherWithMacros:
68 case CCC_ObjCInstanceMessage:
69 case CCC_ObjCClassMessage:
70 case CCC_ObjCInterfaceName:
71 case CCC_ObjCCategoryName:
72 return false;
73 }
74
75 llvm_unreachable("Invalid CodeCompletionContext::Kind!");
76 }
77
78 //===----------------------------------------------------------------------===//
79 // Code completion string implementation
80 //===----------------------------------------------------------------------===//
Chunk(ChunkKind Kind,const char * Text)81 CodeCompletionString::Chunk::Chunk(ChunkKind Kind, const char *Text)
82 : Kind(Kind), Text("")
83 {
84 switch (Kind) {
85 case CK_TypedText:
86 case CK_Text:
87 case CK_Placeholder:
88 case CK_Informative:
89 case CK_ResultType:
90 case CK_CurrentParameter:
91 this->Text = Text;
92 break;
93
94 case CK_Optional:
95 llvm_unreachable("Optional strings cannot be created from text");
96
97 case CK_LeftParen:
98 this->Text = "(";
99 break;
100
101 case CK_RightParen:
102 this->Text = ")";
103 break;
104
105 case CK_LeftBracket:
106 this->Text = "[";
107 break;
108
109 case CK_RightBracket:
110 this->Text = "]";
111 break;
112
113 case CK_LeftBrace:
114 this->Text = "{";
115 break;
116
117 case CK_RightBrace:
118 this->Text = "}";
119 break;
120
121 case CK_LeftAngle:
122 this->Text = "<";
123 break;
124
125 case CK_RightAngle:
126 this->Text = ">";
127 break;
128
129 case CK_Comma:
130 this->Text = ", ";
131 break;
132
133 case CK_Colon:
134 this->Text = ":";
135 break;
136
137 case CK_SemiColon:
138 this->Text = ";";
139 break;
140
141 case CK_Equal:
142 this->Text = " = ";
143 break;
144
145 case CK_HorizontalSpace:
146 this->Text = " ";
147 break;
148
149 case CK_VerticalSpace:
150 this->Text = "\n";
151 break;
152 }
153 }
154
155 CodeCompletionString::Chunk
CreateText(const char * Text)156 CodeCompletionString::Chunk::CreateText(const char *Text) {
157 return Chunk(CK_Text, Text);
158 }
159
160 CodeCompletionString::Chunk
CreateOptional(CodeCompletionString * Optional)161 CodeCompletionString::Chunk::CreateOptional(CodeCompletionString *Optional) {
162 Chunk Result;
163 Result.Kind = CK_Optional;
164 Result.Optional = Optional;
165 return Result;
166 }
167
168 CodeCompletionString::Chunk
CreatePlaceholder(const char * Placeholder)169 CodeCompletionString::Chunk::CreatePlaceholder(const char *Placeholder) {
170 return Chunk(CK_Placeholder, Placeholder);
171 }
172
173 CodeCompletionString::Chunk
CreateInformative(const char * Informative)174 CodeCompletionString::Chunk::CreateInformative(const char *Informative) {
175 return Chunk(CK_Informative, Informative);
176 }
177
178 CodeCompletionString::Chunk
CreateResultType(const char * ResultType)179 CodeCompletionString::Chunk::CreateResultType(const char *ResultType) {
180 return Chunk(CK_ResultType, ResultType);
181 }
182
183 CodeCompletionString::Chunk
CreateCurrentParameter(const char * CurrentParameter)184 CodeCompletionString::Chunk::CreateCurrentParameter(
185 const char *CurrentParameter) {
186 return Chunk(CK_CurrentParameter, CurrentParameter);
187 }
188
CodeCompletionString(const Chunk * Chunks,unsigned NumChunks,unsigned Priority,CXAvailabilityKind Availability,const char ** Annotations,unsigned NumAnnotations,StringRef ParentName,const char * BriefComment)189 CodeCompletionString::CodeCompletionString(const Chunk *Chunks,
190 unsigned NumChunks,
191 unsigned Priority,
192 CXAvailabilityKind Availability,
193 const char **Annotations,
194 unsigned NumAnnotations,
195 StringRef ParentName,
196 const char *BriefComment)
197 : NumChunks(NumChunks), NumAnnotations(NumAnnotations),
198 Priority(Priority), Availability(Availability),
199 ParentName(ParentName), BriefComment(BriefComment)
200 {
201 assert(NumChunks <= 0xffff);
202 assert(NumAnnotations <= 0xffff);
203
204 Chunk *StoredChunks = reinterpret_cast<Chunk *>(this + 1);
205 for (unsigned I = 0; I != NumChunks; ++I)
206 StoredChunks[I] = Chunks[I];
207
208 const char **StoredAnnotations = reinterpret_cast<const char **>(StoredChunks + NumChunks);
209 for (unsigned I = 0; I != NumAnnotations; ++I)
210 StoredAnnotations[I] = Annotations[I];
211 }
212
getAnnotationCount() const213 unsigned CodeCompletionString::getAnnotationCount() const {
214 return NumAnnotations;
215 }
216
getAnnotation(unsigned AnnotationNr) const217 const char *CodeCompletionString::getAnnotation(unsigned AnnotationNr) const {
218 if (AnnotationNr < NumAnnotations)
219 return reinterpret_cast<const char * const*>(end())[AnnotationNr];
220 else
221 return nullptr;
222 }
223
224
getAsString() const225 std::string CodeCompletionString::getAsString() const {
226 std::string Result;
227 llvm::raw_string_ostream OS(Result);
228
229 for (iterator C = begin(), CEnd = end(); C != CEnd; ++C) {
230 switch (C->Kind) {
231 case CK_Optional: OS << "{#" << C->Optional->getAsString() << "#}"; break;
232 case CK_Placeholder: OS << "<#" << C->Text << "#>"; break;
233
234 case CK_Informative:
235 case CK_ResultType:
236 OS << "[#" << C->Text << "#]";
237 break;
238
239 case CK_CurrentParameter: OS << "<#" << C->Text << "#>"; break;
240 default: OS << C->Text; break;
241 }
242 }
243 return OS.str();
244 }
245
getTypedText() const246 const char *CodeCompletionString::getTypedText() const {
247 for (iterator C = begin(), CEnd = end(); C != CEnd; ++C)
248 if (C->Kind == CK_TypedText)
249 return C->Text;
250
251 return nullptr;
252 }
253
CopyString(StringRef String)254 const char *CodeCompletionAllocator::CopyString(StringRef String) {
255 char *Mem = (char *)Allocate(String.size() + 1, 1);
256 std::copy(String.begin(), String.end(), Mem);
257 Mem[String.size()] = 0;
258 return Mem;
259 }
260
CopyString(Twine String)261 const char *CodeCompletionAllocator::CopyString(Twine String) {
262 // FIXME: It would be more efficient to teach Twine to tell us its size and
263 // then add a routine there to fill in an allocated char* with the contents
264 // of the string.
265 SmallString<128> Data;
266 return CopyString(String.toStringRef(Data));
267 }
268
getParentName(const DeclContext * DC)269 StringRef CodeCompletionTUInfo::getParentName(const DeclContext *DC) {
270 const NamedDecl *ND = dyn_cast<NamedDecl>(DC);
271 if (!ND)
272 return StringRef();
273
274 // Check whether we've already cached the parent name.
275 StringRef &CachedParentName = ParentNames[DC];
276 if (!CachedParentName.empty())
277 return CachedParentName;
278
279 // If we already processed this DeclContext and assigned empty to it, the
280 // data pointer will be non-null.
281 if (CachedParentName.data() != nullptr)
282 return StringRef();
283
284 // Find the interesting names.
285 SmallVector<const DeclContext *, 2> Contexts;
286 while (DC && !DC->isFunctionOrMethod()) {
287 if (const NamedDecl *ND = dyn_cast<NamedDecl>(DC)) {
288 if (ND->getIdentifier())
289 Contexts.push_back(DC);
290 }
291
292 DC = DC->getParent();
293 }
294
295 {
296 SmallString<128> S;
297 llvm::raw_svector_ostream OS(S);
298 bool First = true;
299 for (unsigned I = Contexts.size(); I != 0; --I) {
300 if (First)
301 First = false;
302 else {
303 OS << "::";
304 }
305
306 const DeclContext *CurDC = Contexts[I-1];
307 if (const ObjCCategoryImplDecl *CatImpl = dyn_cast<ObjCCategoryImplDecl>(CurDC))
308 CurDC = CatImpl->getCategoryDecl();
309
310 if (const ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(CurDC)) {
311 const ObjCInterfaceDecl *Interface = Cat->getClassInterface();
312 if (!Interface) {
313 // Assign an empty StringRef but with non-null data to distinguish
314 // between empty because we didn't process the DeclContext yet.
315 CachedParentName = StringRef((const char *)~0U, 0);
316 return StringRef();
317 }
318
319 OS << Interface->getName() << '(' << Cat->getName() << ')';
320 } else {
321 OS << cast<NamedDecl>(CurDC)->getName();
322 }
323 }
324
325 CachedParentName = AllocatorRef->CopyString(OS.str());
326 }
327
328 return CachedParentName;
329 }
330
TakeString()331 CodeCompletionString *CodeCompletionBuilder::TakeString() {
332 void *Mem = getAllocator().Allocate(
333 sizeof(CodeCompletionString) + sizeof(Chunk) * Chunks.size()
334 + sizeof(const char *) * Annotations.size(),
335 llvm::alignOf<CodeCompletionString>());
336 CodeCompletionString *Result
337 = new (Mem) CodeCompletionString(Chunks.data(), Chunks.size(),
338 Priority, Availability,
339 Annotations.data(), Annotations.size(),
340 ParentName, BriefComment);
341 Chunks.clear();
342 return Result;
343 }
344
AddTypedTextChunk(const char * Text)345 void CodeCompletionBuilder::AddTypedTextChunk(const char *Text) {
346 Chunks.push_back(Chunk(CodeCompletionString::CK_TypedText, Text));
347 }
348
AddTextChunk(const char * Text)349 void CodeCompletionBuilder::AddTextChunk(const char *Text) {
350 Chunks.push_back(Chunk::CreateText(Text));
351 }
352
AddOptionalChunk(CodeCompletionString * Optional)353 void CodeCompletionBuilder::AddOptionalChunk(CodeCompletionString *Optional) {
354 Chunks.push_back(Chunk::CreateOptional(Optional));
355 }
356
AddPlaceholderChunk(const char * Placeholder)357 void CodeCompletionBuilder::AddPlaceholderChunk(const char *Placeholder) {
358 Chunks.push_back(Chunk::CreatePlaceholder(Placeholder));
359 }
360
AddInformativeChunk(const char * Text)361 void CodeCompletionBuilder::AddInformativeChunk(const char *Text) {
362 Chunks.push_back(Chunk::CreateInformative(Text));
363 }
364
AddResultTypeChunk(const char * ResultType)365 void CodeCompletionBuilder::AddResultTypeChunk(const char *ResultType) {
366 Chunks.push_back(Chunk::CreateResultType(ResultType));
367 }
368
369 void
AddCurrentParameterChunk(const char * CurrentParameter)370 CodeCompletionBuilder::AddCurrentParameterChunk(const char *CurrentParameter) {
371 Chunks.push_back(Chunk::CreateCurrentParameter(CurrentParameter));
372 }
373
AddChunk(CodeCompletionString::ChunkKind CK,const char * Text)374 void CodeCompletionBuilder::AddChunk(CodeCompletionString::ChunkKind CK,
375 const char *Text) {
376 Chunks.push_back(Chunk(CK, Text));
377 }
378
addParentContext(const DeclContext * DC)379 void CodeCompletionBuilder::addParentContext(const DeclContext *DC) {
380 if (DC->isTranslationUnit()) {
381 return;
382 }
383
384 if (DC->isFunctionOrMethod())
385 return;
386
387 const NamedDecl *ND = dyn_cast<NamedDecl>(DC);
388 if (!ND)
389 return;
390
391 ParentName = getCodeCompletionTUInfo().getParentName(DC);
392 }
393
addBriefComment(StringRef Comment)394 void CodeCompletionBuilder::addBriefComment(StringRef Comment) {
395 BriefComment = Allocator.CopyString(Comment);
396 }
397
398 //===----------------------------------------------------------------------===//
399 // Code completion overload candidate implementation
400 //===----------------------------------------------------------------------===//
401 FunctionDecl *
getFunction() const402 CodeCompleteConsumer::OverloadCandidate::getFunction() const {
403 if (getKind() == CK_Function)
404 return Function;
405 else if (getKind() == CK_FunctionTemplate)
406 return FunctionTemplate->getTemplatedDecl();
407 else
408 return nullptr;
409 }
410
411 const FunctionType *
getFunctionType() const412 CodeCompleteConsumer::OverloadCandidate::getFunctionType() const {
413 switch (Kind) {
414 case CK_Function:
415 return Function->getType()->getAs<FunctionType>();
416
417 case CK_FunctionTemplate:
418 return FunctionTemplate->getTemplatedDecl()->getType()
419 ->getAs<FunctionType>();
420
421 case CK_FunctionType:
422 return Type;
423 }
424
425 llvm_unreachable("Invalid CandidateKind!");
426 }
427
428 //===----------------------------------------------------------------------===//
429 // Code completion consumer implementation
430 //===----------------------------------------------------------------------===//
431
~CodeCompleteConsumer()432 CodeCompleteConsumer::~CodeCompleteConsumer() { }
433
434 void
ProcessCodeCompleteResults(Sema & SemaRef,CodeCompletionContext Context,CodeCompletionResult * Results,unsigned NumResults)435 PrintingCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &SemaRef,
436 CodeCompletionContext Context,
437 CodeCompletionResult *Results,
438 unsigned NumResults) {
439 std::stable_sort(Results, Results + NumResults);
440
441 // Print the results.
442 for (unsigned I = 0; I != NumResults; ++I) {
443 OS << "COMPLETION: ";
444 switch (Results[I].Kind) {
445 case CodeCompletionResult::RK_Declaration:
446 OS << *Results[I].Declaration;
447 if (Results[I].Hidden)
448 OS << " (Hidden)";
449 if (CodeCompletionString *CCS
450 = Results[I].CreateCodeCompletionString(SemaRef, getAllocator(),
451 CCTUInfo,
452 includeBriefComments())) {
453 OS << " : " << CCS->getAsString();
454 if (const char *BriefComment = CCS->getBriefComment())
455 OS << " : " << BriefComment;
456 }
457
458 OS << '\n';
459 break;
460
461 case CodeCompletionResult::RK_Keyword:
462 OS << Results[I].Keyword << '\n';
463 break;
464
465 case CodeCompletionResult::RK_Macro: {
466 OS << Results[I].Macro->getName();
467 if (CodeCompletionString *CCS
468 = Results[I].CreateCodeCompletionString(SemaRef, getAllocator(),
469 CCTUInfo,
470 includeBriefComments())) {
471 OS << " : " << CCS->getAsString();
472 }
473 OS << '\n';
474 break;
475 }
476
477 case CodeCompletionResult::RK_Pattern: {
478 OS << "Pattern : "
479 << Results[I].Pattern->getAsString() << '\n';
480 break;
481 }
482 }
483 }
484 }
485
486 void
ProcessOverloadCandidates(Sema & SemaRef,unsigned CurrentArg,OverloadCandidate * Candidates,unsigned NumCandidates)487 PrintingCodeCompleteConsumer::ProcessOverloadCandidates(Sema &SemaRef,
488 unsigned CurrentArg,
489 OverloadCandidate *Candidates,
490 unsigned NumCandidates) {
491 for (unsigned I = 0; I != NumCandidates; ++I) {
492 if (CodeCompletionString *CCS
493 = Candidates[I].CreateSignatureString(CurrentArg, SemaRef,
494 getAllocator(), CCTUInfo)) {
495 OS << "OVERLOAD: " << CCS->getAsString() << "\n";
496 }
497 }
498 }
499
500 /// \brief Retrieve the effective availability of the given declaration.
getDeclAvailability(const Decl * D)501 static AvailabilityResult getDeclAvailability(const Decl *D) {
502 AvailabilityResult AR = D->getAvailability();
503 if (isa<EnumConstantDecl>(D))
504 AR = std::max(AR, cast<Decl>(D->getDeclContext())->getAvailability());
505 return AR;
506 }
507
computeCursorKindAndAvailability(bool Accessible)508 void CodeCompletionResult::computeCursorKindAndAvailability(bool Accessible) {
509 switch (Kind) {
510 case RK_Pattern:
511 if (!Declaration) {
512 // Do nothing: Patterns can come with cursor kinds!
513 break;
514 }
515 // Fall through
516
517 case RK_Declaration: {
518 // Set the availability based on attributes.
519 switch (getDeclAvailability(Declaration)) {
520 case AR_Available:
521 case AR_NotYetIntroduced:
522 Availability = CXAvailability_Available;
523 break;
524
525 case AR_Deprecated:
526 Availability = CXAvailability_Deprecated;
527 break;
528
529 case AR_Unavailable:
530 Availability = CXAvailability_NotAvailable;
531 break;
532 }
533
534 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(Declaration))
535 if (Function->isDeleted())
536 Availability = CXAvailability_NotAvailable;
537
538 CursorKind = getCursorKindForDecl(Declaration);
539 if (CursorKind == CXCursor_UnexposedDecl) {
540 // FIXME: Forward declarations of Objective-C classes and protocols
541 // are not directly exposed, but we want code completion to treat them
542 // like a definition.
543 if (isa<ObjCInterfaceDecl>(Declaration))
544 CursorKind = CXCursor_ObjCInterfaceDecl;
545 else if (isa<ObjCProtocolDecl>(Declaration))
546 CursorKind = CXCursor_ObjCProtocolDecl;
547 else
548 CursorKind = CXCursor_NotImplemented;
549 }
550 break;
551 }
552
553 case RK_Macro:
554 case RK_Keyword:
555 llvm_unreachable("Macro and keyword kinds are handled by the constructors");
556 }
557
558 if (!Accessible)
559 Availability = CXAvailability_NotAccessible;
560 }
561
562 /// \brief Retrieve the name that should be used to order a result.
563 ///
564 /// If the name needs to be constructed as a string, that string will be
565 /// saved into Saved and the returned StringRef will refer to it.
getOrderedName(const CodeCompletionResult & R,std::string & Saved)566 static StringRef getOrderedName(const CodeCompletionResult &R,
567 std::string &Saved) {
568 switch (R.Kind) {
569 case CodeCompletionResult::RK_Keyword:
570 return R.Keyword;
571
572 case CodeCompletionResult::RK_Pattern:
573 return R.Pattern->getTypedText();
574
575 case CodeCompletionResult::RK_Macro:
576 return R.Macro->getName();
577
578 case CodeCompletionResult::RK_Declaration:
579 // Handle declarations below.
580 break;
581 }
582
583 DeclarationName Name = R.Declaration->getDeclName();
584
585 // If the name is a simple identifier (by far the common case), or a
586 // zero-argument selector, just return a reference to that identifier.
587 if (IdentifierInfo *Id = Name.getAsIdentifierInfo())
588 return Id->getName();
589 if (Name.isObjCZeroArgSelector())
590 if (IdentifierInfo *Id
591 = Name.getObjCSelector().getIdentifierInfoForSlot(0))
592 return Id->getName();
593
594 Saved = Name.getAsString();
595 return Saved;
596 }
597
operator <(const CodeCompletionResult & X,const CodeCompletionResult & Y)598 bool clang::operator<(const CodeCompletionResult &X,
599 const CodeCompletionResult &Y) {
600 std::string XSaved, YSaved;
601 StringRef XStr = getOrderedName(X, XSaved);
602 StringRef YStr = getOrderedName(Y, YSaved);
603 int cmp = XStr.compare_lower(YStr);
604 if (cmp)
605 return cmp < 0;
606
607 // If case-insensitive comparison fails, try case-sensitive comparison.
608 cmp = XStr.compare(YStr);
609 if (cmp)
610 return cmp < 0;
611
612 return false;
613 }
614