1 //===- CodeCompleteConsumer.cpp - Code Completion Interface ---------------===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // This file implements the CodeCompleteConsumer class.
11 //===----------------------------------------------------------------------===//
13 #include "clang/Sema/CodeCompleteConsumer.h"
14 #include "clang-c/Index.h"
15 #include "clang/AST/Decl.h"
16 #include "clang/AST/DeclBase.h"
17 #include "clang/AST/DeclObjC.h"
18 #include "clang/AST/DeclTemplate.h"
19 #include "clang/AST/DeclarationName.h"
20 #include "clang/AST/Type.h"
21 #include "clang/Basic/IdentifierTable.h"
22 #include "clang/Lex/Preprocessor.h"
23 #include "clang/Sema/Sema.h"
24 #include "llvm/ADT/SmallString.h"
25 #include "llvm/ADT/SmallVector.h"
26 #include "llvm/ADT/StringRef.h"
27 #include "llvm/ADT/Twine.h"
28 #include "llvm/Support/Casting.h"
29 #include "llvm/Support/Compiler.h"
30 #include "llvm/Support/ErrorHandling.h"
31 #include "llvm/Support/FormatVariadic.h"
32 #include "llvm/Support/raw_ostream.h"
38 using namespace clang;
40 //===----------------------------------------------------------------------===//
41 // Code completion context implementation
42 //===----------------------------------------------------------------------===//
44 bool CodeCompletionContext::wantConstructorResults() const {
49 case CCC_ObjCMessageReceiver:
50 case CCC_ParenthesizedExpression:
52 case CCC_SymbolOrNewName:
56 case CCC_ObjCInterface:
57 case CCC_ObjCImplementation:
58 case CCC_ObjCIvarList:
59 case CCC_ClassStructUnion:
60 case CCC_DotMemberAccess:
61 case CCC_ArrowMemberAccess:
62 case CCC_ObjCPropertyAccess:
65 case CCC_ClassOrStructTag:
66 case CCC_ObjCProtocolName:
71 case CCC_MacroNameUse:
72 case CCC_PreprocessorExpression:
73 case CCC_PreprocessorDirective:
74 case CCC_NaturalLanguage:
75 case CCC_SelectorName:
76 case CCC_TypeQualifiers:
78 case CCC_OtherWithMacros:
79 case CCC_ObjCInstanceMessage:
80 case CCC_ObjCClassMessage:
81 case CCC_ObjCInterfaceName:
82 case CCC_ObjCCategoryName:
83 case CCC_IncludedFile:
87 llvm_unreachable("Invalid CodeCompletionContext::Kind!");
90 StringRef clang::getCompletionKindString(CodeCompletionContext::Kind Kind) {
91 using CCKind = CodeCompletionContext::Kind;
93 case CCKind::CCC_Other:
95 case CCKind::CCC_OtherWithMacros:
96 return "OtherWithMacros";
97 case CCKind::CCC_TopLevel:
99 case CCKind::CCC_ObjCInterface:
100 return "ObjCInterface";
101 case CCKind::CCC_ObjCImplementation:
102 return "ObjCImplementation";
103 case CCKind::CCC_ObjCIvarList:
104 return "ObjCIvarList";
105 case CCKind::CCC_ClassStructUnion:
106 return "ClassStructUnion";
107 case CCKind::CCC_Statement:
109 case CCKind::CCC_Expression:
111 case CCKind::CCC_ObjCMessageReceiver:
112 return "ObjCMessageReceiver";
113 case CCKind::CCC_DotMemberAccess:
114 return "DotMemberAccess";
115 case CCKind::CCC_ArrowMemberAccess:
116 return "ArrowMemberAccess";
117 case CCKind::CCC_ObjCPropertyAccess:
118 return "ObjCPropertyAccess";
119 case CCKind::CCC_EnumTag:
121 case CCKind::CCC_UnionTag:
123 case CCKind::CCC_ClassOrStructTag:
124 return "ClassOrStructTag";
125 case CCKind::CCC_ObjCProtocolName:
126 return "ObjCProtocolName";
127 case CCKind::CCC_Namespace:
129 case CCKind::CCC_Type:
131 case CCKind::CCC_NewName:
133 case CCKind::CCC_Symbol:
135 case CCKind::CCC_SymbolOrNewName:
136 return "SymbolOrNewName";
137 case CCKind::CCC_MacroName:
139 case CCKind::CCC_MacroNameUse:
140 return "MacroNameUse";
141 case CCKind::CCC_PreprocessorExpression:
142 return "PreprocessorExpression";
143 case CCKind::CCC_PreprocessorDirective:
144 return "PreprocessorDirective";
145 case CCKind::CCC_NaturalLanguage:
146 return "NaturalLanguage";
147 case CCKind::CCC_SelectorName:
148 return "SelectorName";
149 case CCKind::CCC_TypeQualifiers:
150 return "TypeQualifiers";
151 case CCKind::CCC_ParenthesizedExpression:
152 return "ParenthesizedExpression";
153 case CCKind::CCC_ObjCInstanceMessage:
154 return "ObjCInstanceMessage";
155 case CCKind::CCC_ObjCClassMessage:
156 return "ObjCClassMessage";
157 case CCKind::CCC_ObjCInterfaceName:
158 return "ObjCInterfaceName";
159 case CCKind::CCC_ObjCCategoryName:
160 return "ObjCCategoryName";
161 case CCKind::CCC_IncludedFile:
162 return "IncludedFile";
163 case CCKind::CCC_Recovery:
166 llvm_unreachable("Invalid CodeCompletionContext::Kind!");
169 //===----------------------------------------------------------------------===//
170 // Code completion string implementation
171 //===----------------------------------------------------------------------===//
173 CodeCompletionString::Chunk::Chunk(ChunkKind Kind, const char *Text)
174 : Kind(Kind), Text("") {
181 case CK_CurrentParameter:
186 llvm_unreachable("Optional strings cannot be created from text");
200 case CK_RightBracket:
236 case CK_HorizontalSpace:
240 case CK_VerticalSpace:
246 CodeCompletionString::Chunk
247 CodeCompletionString::Chunk::CreateText(const char *Text) {
248 return Chunk(CK_Text, Text);
251 CodeCompletionString::Chunk
252 CodeCompletionString::Chunk::CreateOptional(CodeCompletionString *Optional) {
254 Result.Kind = CK_Optional;
255 Result.Optional = Optional;
259 CodeCompletionString::Chunk
260 CodeCompletionString::Chunk::CreatePlaceholder(const char *Placeholder) {
261 return Chunk(CK_Placeholder, Placeholder);
264 CodeCompletionString::Chunk
265 CodeCompletionString::Chunk::CreateInformative(const char *Informative) {
266 return Chunk(CK_Informative, Informative);
269 CodeCompletionString::Chunk
270 CodeCompletionString::Chunk::CreateResultType(const char *ResultType) {
271 return Chunk(CK_ResultType, ResultType);
274 CodeCompletionString::Chunk CodeCompletionString::Chunk::CreateCurrentParameter(
275 const char *CurrentParameter) {
276 return Chunk(CK_CurrentParameter, CurrentParameter);
279 CodeCompletionString::CodeCompletionString(
280 const Chunk *Chunks, unsigned NumChunks, unsigned Priority,
281 CXAvailabilityKind Availability, const char **Annotations,
282 unsigned NumAnnotations, StringRef ParentName, const char *BriefComment)
283 : NumChunks(NumChunks), NumAnnotations(NumAnnotations), Priority(Priority),
284 Availability(Availability), ParentName(ParentName),
285 BriefComment(BriefComment) {
286 assert(NumChunks <= 0xffff);
287 assert(NumAnnotations <= 0xffff);
289 Chunk *StoredChunks = reinterpret_cast<Chunk *>(this + 1);
290 for (unsigned I = 0; I != NumChunks; ++I)
291 StoredChunks[I] = Chunks[I];
293 const char **StoredAnnotations =
294 reinterpret_cast<const char **>(StoredChunks + NumChunks);
295 for (unsigned I = 0; I != NumAnnotations; ++I)
296 StoredAnnotations[I] = Annotations[I];
299 unsigned CodeCompletionString::getAnnotationCount() const {
300 return NumAnnotations;
303 const char *CodeCompletionString::getAnnotation(unsigned AnnotationNr) const {
304 if (AnnotationNr < NumAnnotations)
305 return reinterpret_cast<const char *const *>(end())[AnnotationNr];
310 std::string CodeCompletionString::getAsString() const {
312 llvm::raw_string_ostream OS(Result);
314 for (const Chunk &C : *this) {
317 OS << "{#" << C.Optional->getAsString() << "#}";
320 OS << "<#" << C.Text << "#>";
324 OS << "[#" << C.Text << "#]";
326 case CK_CurrentParameter:
327 OS << "<#" << C.Text << "#>";
337 const char *CodeCompletionString::getTypedText() const {
338 for (const Chunk &C : *this)
339 if (C.Kind == CK_TypedText)
345 const char *CodeCompletionAllocator::CopyString(const Twine &String) {
346 SmallString<128> Data;
347 StringRef Ref = String.toStringRef(Data);
348 // FIXME: It would be more efficient to teach Twine to tell us its size and
349 // then add a routine there to fill in an allocated char* with the contents
351 char *Mem = (char *)Allocate(Ref.size() + 1, 1);
352 std::copy(Ref.begin(), Ref.end(), Mem);
357 StringRef CodeCompletionTUInfo::getParentName(const DeclContext *DC) {
358 const NamedDecl *ND = dyn_cast<NamedDecl>(DC);
362 // Check whether we've already cached the parent name.
363 StringRef &CachedParentName = ParentNames[DC];
364 if (!CachedParentName.empty())
365 return CachedParentName;
367 // If we already processed this DeclContext and assigned empty to it, the
368 // data pointer will be non-null.
369 if (CachedParentName.data() != nullptr)
372 // Find the interesting names.
373 SmallVector<const DeclContext *, 2> Contexts;
374 while (DC && !DC->isFunctionOrMethod()) {
375 if (const auto *ND = dyn_cast<NamedDecl>(DC)) {
376 if (ND->getIdentifier())
377 Contexts.push_back(DC);
380 DC = DC->getParent();
385 llvm::raw_svector_ostream OS(S);
387 for (unsigned I = Contexts.size(); I != 0; --I) {
394 const DeclContext *CurDC = Contexts[I - 1];
395 if (const auto *CatImpl = dyn_cast<ObjCCategoryImplDecl>(CurDC))
396 CurDC = CatImpl->getCategoryDecl();
398 if (const auto *Cat = dyn_cast<ObjCCategoryDecl>(CurDC)) {
399 const ObjCInterfaceDecl *Interface = Cat->getClassInterface();
401 // Assign an empty StringRef but with non-null data to distinguish
402 // between empty because we didn't process the DeclContext yet.
403 CachedParentName = StringRef((const char *)(uintptr_t)~0U, 0);
407 OS << Interface->getName() << '(' << Cat->getName() << ')';
409 OS << cast<NamedDecl>(CurDC)->getName();
413 CachedParentName = AllocatorRef->CopyString(OS.str());
416 return CachedParentName;
419 CodeCompletionString *CodeCompletionBuilder::TakeString() {
420 void *Mem = getAllocator().Allocate(
421 sizeof(CodeCompletionString) + sizeof(Chunk) * Chunks.size() +
422 sizeof(const char *) * Annotations.size(),
423 alignof(CodeCompletionString));
424 CodeCompletionString *Result = new (Mem) CodeCompletionString(
425 Chunks.data(), Chunks.size(), Priority, Availability, Annotations.data(),
426 Annotations.size(), ParentName, BriefComment);
431 void CodeCompletionBuilder::AddTypedTextChunk(const char *Text) {
432 Chunks.push_back(Chunk(CodeCompletionString::CK_TypedText, Text));
435 void CodeCompletionBuilder::AddTextChunk(const char *Text) {
436 Chunks.push_back(Chunk::CreateText(Text));
439 void CodeCompletionBuilder::AddOptionalChunk(CodeCompletionString *Optional) {
440 Chunks.push_back(Chunk::CreateOptional(Optional));
443 void CodeCompletionBuilder::AddPlaceholderChunk(const char *Placeholder) {
444 Chunks.push_back(Chunk::CreatePlaceholder(Placeholder));
447 void CodeCompletionBuilder::AddInformativeChunk(const char *Text) {
448 Chunks.push_back(Chunk::CreateInformative(Text));
451 void CodeCompletionBuilder::AddResultTypeChunk(const char *ResultType) {
452 Chunks.push_back(Chunk::CreateResultType(ResultType));
455 void CodeCompletionBuilder::AddCurrentParameterChunk(
456 const char *CurrentParameter) {
457 Chunks.push_back(Chunk::CreateCurrentParameter(CurrentParameter));
460 void CodeCompletionBuilder::AddChunk(CodeCompletionString::ChunkKind CK,
462 Chunks.push_back(Chunk(CK, Text));
465 void CodeCompletionBuilder::addParentContext(const DeclContext *DC) {
466 if (DC->isTranslationUnit())
469 if (DC->isFunctionOrMethod())
472 const NamedDecl *ND = dyn_cast<NamedDecl>(DC);
476 ParentName = getCodeCompletionTUInfo().getParentName(DC);
479 void CodeCompletionBuilder::addBriefComment(StringRef Comment) {
480 BriefComment = Allocator.CopyString(Comment);
483 //===----------------------------------------------------------------------===//
484 // Code completion overload candidate implementation
485 //===----------------------------------------------------------------------===//
486 FunctionDecl *CodeCompleteConsumer::OverloadCandidate::getFunction() const {
487 if (getKind() == CK_Function)
489 else if (getKind() == CK_FunctionTemplate)
490 return FunctionTemplate->getTemplatedDecl();
496 CodeCompleteConsumer::OverloadCandidate::getFunctionType() const {
499 return Function->getType()->getAs<FunctionType>();
501 case CK_FunctionTemplate:
502 return FunctionTemplate->getTemplatedDecl()
504 ->getAs<FunctionType>();
506 case CK_FunctionType:
510 llvm_unreachable("Invalid CandidateKind!");
513 //===----------------------------------------------------------------------===//
514 // Code completion consumer implementation
515 //===----------------------------------------------------------------------===//
517 CodeCompleteConsumer::~CodeCompleteConsumer() = default;
519 bool PrintingCodeCompleteConsumer::isResultFilteredOut(
520 StringRef Filter, CodeCompletionResult Result) {
521 switch (Result.Kind) {
522 case CodeCompletionResult::RK_Declaration:
523 return !(Result.Declaration->getIdentifier() &&
524 Result.Declaration->getIdentifier()->getName().startswith(Filter));
525 case CodeCompletionResult::RK_Keyword:
526 return !StringRef(Result.Keyword).startswith(Filter);
527 case CodeCompletionResult::RK_Macro:
528 return !Result.Macro->getName().startswith(Filter);
529 case CodeCompletionResult::RK_Pattern:
530 return !(Result.Pattern->getTypedText() &&
531 StringRef(Result.Pattern->getTypedText()).startswith(Filter));
533 llvm_unreachable("Unknown code completion result Kind.");
536 void PrintingCodeCompleteConsumer::ProcessCodeCompleteResults(
537 Sema &SemaRef, CodeCompletionContext Context, CodeCompletionResult *Results,
538 unsigned NumResults) {
539 std::stable_sort(Results, Results + NumResults);
541 if (!Context.getPreferredType().isNull())
542 OS << "PREFERRED-TYPE: " << Context.getPreferredType().getAsString()
545 StringRef Filter = SemaRef.getPreprocessor().getCodeCompletionFilter();
546 // Print the completions.
547 for (unsigned I = 0; I != NumResults; ++I) {
548 if (!Filter.empty() && isResultFilteredOut(Filter, Results[I]))
550 OS << "COMPLETION: ";
551 switch (Results[I].Kind) {
552 case CodeCompletionResult::RK_Declaration:
553 OS << *Results[I].Declaration;
555 std::vector<std::string> Tags;
556 if (Results[I].Hidden)
557 Tags.push_back("Hidden");
558 if (Results[I].InBaseClass)
559 Tags.push_back("InBase");
560 if (Results[I].Availability ==
561 CXAvailabilityKind::CXAvailability_NotAccessible)
562 Tags.push_back("Inaccessible");
564 OS << " (" << llvm::join(Tags, ",") << ")";
566 if (CodeCompletionString *CCS = Results[I].CreateCodeCompletionString(
567 SemaRef, Context, getAllocator(), CCTUInfo,
568 includeBriefComments())) {
569 OS << " : " << CCS->getAsString();
570 if (const char *BriefComment = CCS->getBriefComment())
571 OS << " : " << BriefComment;
573 for (const FixItHint &FixIt : Results[I].FixIts) {
574 const SourceLocation BLoc = FixIt.RemoveRange.getBegin();
575 const SourceLocation ELoc = FixIt.RemoveRange.getEnd();
577 SourceManager &SM = SemaRef.SourceMgr;
578 std::pair<FileID, unsigned> BInfo = SM.getDecomposedLoc(BLoc);
579 std::pair<FileID, unsigned> EInfo = SM.getDecomposedLoc(ELoc);
580 // Adjust for token ranges.
581 if (FixIt.RemoveRange.isTokenRange())
582 EInfo.second += Lexer::MeasureTokenLength(ELoc, SM, SemaRef.LangOpts);
584 OS << " (requires fix-it:"
585 << " {" << SM.getLineNumber(BInfo.first, BInfo.second) << ':'
586 << SM.getColumnNumber(BInfo.first, BInfo.second) << '-'
587 << SM.getLineNumber(EInfo.first, EInfo.second) << ':'
588 << SM.getColumnNumber(EInfo.first, EInfo.second) << "}"
589 << " to \"" << FixIt.CodeToInsert << "\")";
594 case CodeCompletionResult::RK_Keyword:
595 OS << Results[I].Keyword << '\n';
598 case CodeCompletionResult::RK_Macro:
599 OS << Results[I].Macro->getName();
600 if (CodeCompletionString *CCS = Results[I].CreateCodeCompletionString(
601 SemaRef, Context, getAllocator(), CCTUInfo,
602 includeBriefComments())) {
603 OS << " : " << CCS->getAsString();
608 case CodeCompletionResult::RK_Pattern:
609 OS << "Pattern : " << Results[I].Pattern->getAsString() << '\n';
615 // This function is used solely to preserve the former presentation of overloads
616 // by "clang -cc1 -code-completion-at", since CodeCompletionString::getAsString
617 // needs to be improved for printing the newer and more detailed overload
619 static std::string getOverloadAsString(const CodeCompletionString &CCS) {
621 llvm::raw_string_ostream OS(Result);
623 for (auto &C : CCS) {
625 case CodeCompletionString::CK_Informative:
626 case CodeCompletionString::CK_ResultType:
627 OS << "[#" << C.Text << "#]";
630 case CodeCompletionString::CK_CurrentParameter:
631 OS << "<#" << C.Text << "#>";
634 // FIXME: We can also print optional parameters of an overload.
635 case CodeCompletionString::CK_Optional:
646 void PrintingCodeCompleteConsumer::ProcessOverloadCandidates(
647 Sema &SemaRef, unsigned CurrentArg, OverloadCandidate *Candidates,
648 unsigned NumCandidates, SourceLocation OpenParLoc) {
649 OS << "OPENING_PAREN_LOC: ";
650 OpenParLoc.print(OS, SemaRef.getSourceManager());
653 for (unsigned I = 0; I != NumCandidates; ++I) {
654 if (CodeCompletionString *CCS = Candidates[I].CreateSignatureString(
655 CurrentArg, SemaRef, getAllocator(), CCTUInfo,
656 includeBriefComments())) {
657 OS << "OVERLOAD: " << getOverloadAsString(*CCS) << "\n";
662 /// Retrieve the effective availability of the given declaration.
663 static AvailabilityResult getDeclAvailability(const Decl *D) {
664 AvailabilityResult AR = D->getAvailability();
665 if (isa<EnumConstantDecl>(D))
666 AR = std::max(AR, cast<Decl>(D->getDeclContext())->getAvailability());
670 void CodeCompletionResult::computeCursorKindAndAvailability(bool Accessible) {
674 // Do nothing: Patterns can come with cursor kinds!
679 case RK_Declaration: {
680 // Set the availability based on attributes.
681 switch (getDeclAvailability(Declaration)) {
683 case AR_NotYetIntroduced:
684 Availability = CXAvailability_Available;
688 Availability = CXAvailability_Deprecated;
692 Availability = CXAvailability_NotAvailable;
696 if (const auto *Function = dyn_cast<FunctionDecl>(Declaration))
697 if (Function->isDeleted())
698 Availability = CXAvailability_NotAvailable;
700 CursorKind = getCursorKindForDecl(Declaration);
701 if (CursorKind == CXCursor_UnexposedDecl) {
702 // FIXME: Forward declarations of Objective-C classes and protocols
703 // are not directly exposed, but we want code completion to treat them
704 // like a definition.
705 if (isa<ObjCInterfaceDecl>(Declaration))
706 CursorKind = CXCursor_ObjCInterfaceDecl;
707 else if (isa<ObjCProtocolDecl>(Declaration))
708 CursorKind = CXCursor_ObjCProtocolDecl;
710 CursorKind = CXCursor_NotImplemented;
717 llvm_unreachable("Macro and keyword kinds are handled by the constructors");
721 Availability = CXAvailability_NotAccessible;
724 /// Retrieve the name that should be used to order a result.
726 /// If the name needs to be constructed as a string, that string will be
727 /// saved into Saved and the returned StringRef will refer to it.
728 StringRef CodeCompletionResult::getOrderedName(std::string &Saved) const {
733 return Pattern->getTypedText();
735 return Macro->getName();
737 // Handle declarations below.
741 DeclarationName Name = Declaration->getDeclName();
743 // If the name is a simple identifier (by far the common case), or a
744 // zero-argument selector, just return a reference to that identifier.
745 if (IdentifierInfo *Id = Name.getAsIdentifierInfo())
746 return Id->getName();
747 if (Name.isObjCZeroArgSelector())
748 if (IdentifierInfo *Id = Name.getObjCSelector().getIdentifierInfoForSlot(0))
749 return Id->getName();
751 Saved = Name.getAsString();
755 bool clang::operator<(const CodeCompletionResult &X,
756 const CodeCompletionResult &Y) {
757 std::string XSaved, YSaved;
758 StringRef XStr = X.getOrderedName(XSaved);
759 StringRef YStr = Y.getOrderedName(YSaved);
760 int cmp = XStr.compare_lower(YStr);
764 // If case-insensitive comparison fails, try case-sensitive comparison.
765 return XStr.compare(YStr) < 0;