1 //===- CodeCompleteConsumer.cpp - Code Completion Interface ---------------===//
2 //
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
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 //  This file implements the CodeCompleteConsumer class.
10 //
11 //===----------------------------------------------------------------------===//
12 
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/StringExtras.h"
27 #include "llvm/ADT/StringRef.h"
28 #include "llvm/ADT/Twine.h"
29 #include "llvm/Support/Casting.h"
30 #include "llvm/Support/Compiler.h"
31 #include "llvm/Support/ErrorHandling.h"
32 #include "llvm/Support/FormatVariadic.h"
33 #include "llvm/Support/raw_ostream.h"
34 #include <algorithm>
35 #include <cassert>
36 #include <cstdint>
37 #include <string>
38 
39 using namespace clang;
40 
41 //===----------------------------------------------------------------------===//
42 // Code completion context implementation
43 //===----------------------------------------------------------------------===//
44 
45 bool CodeCompletionContext::wantConstructorResults() const {
46   switch (CCKind) {
47   case CCC_Recovery:
48   case CCC_Statement:
49   case CCC_Expression:
50   case CCC_ObjCMessageReceiver:
51   case CCC_ParenthesizedExpression:
52   case CCC_Symbol:
53   case CCC_SymbolOrNewName:
54     return true;
55 
56   case CCC_TopLevel:
57   case CCC_ObjCInterface:
58   case CCC_ObjCImplementation:
59   case CCC_ObjCIvarList:
60   case CCC_ClassStructUnion:
61   case CCC_DotMemberAccess:
62   case CCC_ArrowMemberAccess:
63   case CCC_ObjCPropertyAccess:
64   case CCC_EnumTag:
65   case CCC_UnionTag:
66   case CCC_ClassOrStructTag:
67   case CCC_ObjCProtocolName:
68   case CCC_Namespace:
69   case CCC_Type:
70   case CCC_NewName:
71   case CCC_MacroName:
72   case CCC_MacroNameUse:
73   case CCC_PreprocessorExpression:
74   case CCC_PreprocessorDirective:
75   case CCC_NaturalLanguage:
76   case CCC_SelectorName:
77   case CCC_TypeQualifiers:
78   case CCC_Other:
79   case CCC_OtherWithMacros:
80   case CCC_ObjCInstanceMessage:
81   case CCC_ObjCClassMessage:
82   case CCC_ObjCInterfaceName:
83   case CCC_ObjCCategoryName:
84   case CCC_IncludedFile:
85   case CCC_Attribute:
86   case CCC_ObjCClassForwardDecl:
87     return false;
88   }
89 
90   llvm_unreachable("Invalid CodeCompletionContext::Kind!");
91 }
92 
93 StringRef clang::getCompletionKindString(CodeCompletionContext::Kind Kind) {
94   using CCKind = CodeCompletionContext::Kind;
95   switch (Kind) {
96   case CCKind::CCC_Other:
97     return "Other";
98   case CCKind::CCC_OtherWithMacros:
99     return "OtherWithMacros";
100   case CCKind::CCC_TopLevel:
101     return "TopLevel";
102   case CCKind::CCC_ObjCInterface:
103     return "ObjCInterface";
104   case CCKind::CCC_ObjCImplementation:
105     return "ObjCImplementation";
106   case CCKind::CCC_ObjCIvarList:
107     return "ObjCIvarList";
108   case CCKind::CCC_ClassStructUnion:
109     return "ClassStructUnion";
110   case CCKind::CCC_Statement:
111     return "Statement";
112   case CCKind::CCC_Expression:
113     return "Expression";
114   case CCKind::CCC_ObjCMessageReceiver:
115     return "ObjCMessageReceiver";
116   case CCKind::CCC_DotMemberAccess:
117     return "DotMemberAccess";
118   case CCKind::CCC_ArrowMemberAccess:
119     return "ArrowMemberAccess";
120   case CCKind::CCC_ObjCPropertyAccess:
121     return "ObjCPropertyAccess";
122   case CCKind::CCC_EnumTag:
123     return "EnumTag";
124   case CCKind::CCC_UnionTag:
125     return "UnionTag";
126   case CCKind::CCC_ClassOrStructTag:
127     return "ClassOrStructTag";
128   case CCKind::CCC_ObjCProtocolName:
129     return "ObjCProtocolName";
130   case CCKind::CCC_Namespace:
131     return "Namespace";
132   case CCKind::CCC_Type:
133     return "Type";
134   case CCKind::CCC_NewName:
135     return "NewName";
136   case CCKind::CCC_Symbol:
137     return "Symbol";
138   case CCKind::CCC_SymbolOrNewName:
139     return "SymbolOrNewName";
140   case CCKind::CCC_MacroName:
141     return "MacroName";
142   case CCKind::CCC_MacroNameUse:
143     return "MacroNameUse";
144   case CCKind::CCC_PreprocessorExpression:
145     return "PreprocessorExpression";
146   case CCKind::CCC_PreprocessorDirective:
147     return "PreprocessorDirective";
148   case CCKind::CCC_NaturalLanguage:
149     return "NaturalLanguage";
150   case CCKind::CCC_SelectorName:
151     return "SelectorName";
152   case CCKind::CCC_TypeQualifiers:
153     return "TypeQualifiers";
154   case CCKind::CCC_ParenthesizedExpression:
155     return "ParenthesizedExpression";
156   case CCKind::CCC_ObjCInstanceMessage:
157     return "ObjCInstanceMessage";
158   case CCKind::CCC_ObjCClassMessage:
159     return "ObjCClassMessage";
160   case CCKind::CCC_ObjCInterfaceName:
161     return "ObjCInterfaceName";
162   case CCKind::CCC_ObjCCategoryName:
163     return "ObjCCategoryName";
164   case CCKind::CCC_IncludedFile:
165     return "IncludedFile";
166   case CCKind::CCC_Attribute:
167     return "Attribute";
168   case CCKind::CCC_Recovery:
169     return "Recovery";
170   case CCKind::CCC_ObjCClassForwardDecl:
171     return "ObjCClassForwardDecl";
172   }
173   llvm_unreachable("Invalid CodeCompletionContext::Kind!");
174 }
175 
176 //===----------------------------------------------------------------------===//
177 // Code completion string implementation
178 //===----------------------------------------------------------------------===//
179 
180 CodeCompletionString::Chunk::Chunk(ChunkKind Kind, const char *Text)
181     : Kind(Kind), Text("") {
182   switch (Kind) {
183   case CK_TypedText:
184   case CK_Text:
185   case CK_Placeholder:
186   case CK_Informative:
187   case CK_ResultType:
188   case CK_CurrentParameter:
189     this->Text = Text;
190     break;
191 
192   case CK_Optional:
193     llvm_unreachable("Optional strings cannot be created from text");
194 
195   case CK_LeftParen:
196     this->Text = "(";
197     break;
198 
199   case CK_RightParen:
200     this->Text = ")";
201     break;
202 
203   case CK_LeftBracket:
204     this->Text = "[";
205     break;
206 
207   case CK_RightBracket:
208     this->Text = "]";
209     break;
210 
211   case CK_LeftBrace:
212     this->Text = "{";
213     break;
214 
215   case CK_RightBrace:
216     this->Text = "}";
217     break;
218 
219   case CK_LeftAngle:
220     this->Text = "<";
221     break;
222 
223   case CK_RightAngle:
224     this->Text = ">";
225     break;
226 
227   case CK_Comma:
228     this->Text = ", ";
229     break;
230 
231   case CK_Colon:
232     this->Text = ":";
233     break;
234 
235   case CK_SemiColon:
236     this->Text = ";";
237     break;
238 
239   case CK_Equal:
240     this->Text = " = ";
241     break;
242 
243   case CK_HorizontalSpace:
244     this->Text = " ";
245     break;
246 
247   case CK_VerticalSpace:
248     this->Text = "\n";
249     break;
250   }
251 }
252 
253 CodeCompletionString::Chunk
254 CodeCompletionString::Chunk::CreateText(const char *Text) {
255   return Chunk(CK_Text, Text);
256 }
257 
258 CodeCompletionString::Chunk
259 CodeCompletionString::Chunk::CreateOptional(CodeCompletionString *Optional) {
260   Chunk Result;
261   Result.Kind = CK_Optional;
262   Result.Optional = Optional;
263   return Result;
264 }
265 
266 CodeCompletionString::Chunk
267 CodeCompletionString::Chunk::CreatePlaceholder(const char *Placeholder) {
268   return Chunk(CK_Placeholder, Placeholder);
269 }
270 
271 CodeCompletionString::Chunk
272 CodeCompletionString::Chunk::CreateInformative(const char *Informative) {
273   return Chunk(CK_Informative, Informative);
274 }
275 
276 CodeCompletionString::Chunk
277 CodeCompletionString::Chunk::CreateResultType(const char *ResultType) {
278   return Chunk(CK_ResultType, ResultType);
279 }
280 
281 CodeCompletionString::Chunk CodeCompletionString::Chunk::CreateCurrentParameter(
282     const char *CurrentParameter) {
283   return Chunk(CK_CurrentParameter, CurrentParameter);
284 }
285 
286 CodeCompletionString::CodeCompletionString(
287     const Chunk *Chunks, unsigned NumChunks, unsigned Priority,
288     CXAvailabilityKind Availability, const char **Annotations,
289     unsigned NumAnnotations, StringRef ParentName, const char *BriefComment)
290     : NumChunks(NumChunks), NumAnnotations(NumAnnotations), Priority(Priority),
291       Availability(Availability), ParentName(ParentName),
292       BriefComment(BriefComment) {
293   assert(NumChunks <= 0xffff);
294   assert(NumAnnotations <= 0xffff);
295 
296   Chunk *StoredChunks = reinterpret_cast<Chunk *>(this + 1);
297   for (unsigned I = 0; I != NumChunks; ++I)
298     StoredChunks[I] = Chunks[I];
299 
300   const char **StoredAnnotations =
301       reinterpret_cast<const char **>(StoredChunks + NumChunks);
302   for (unsigned I = 0; I != NumAnnotations; ++I)
303     StoredAnnotations[I] = Annotations[I];
304 }
305 
306 unsigned CodeCompletionString::getAnnotationCount() const {
307   return NumAnnotations;
308 }
309 
310 const char *CodeCompletionString::getAnnotation(unsigned AnnotationNr) const {
311   if (AnnotationNr < NumAnnotations)
312     return reinterpret_cast<const char *const *>(end())[AnnotationNr];
313   else
314     return nullptr;
315 }
316 
317 std::string CodeCompletionString::getAsString() const {
318   std::string Result;
319   llvm::raw_string_ostream OS(Result);
320 
321   for (const Chunk &C : *this) {
322     switch (C.Kind) {
323     case CK_Optional:
324       OS << "{#" << C.Optional->getAsString() << "#}";
325       break;
326     case CK_Placeholder:
327       OS << "<#" << C.Text << "#>";
328       break;
329     case CK_Informative:
330     case CK_ResultType:
331       OS << "[#" << C.Text << "#]";
332       break;
333     case CK_CurrentParameter:
334       OS << "<#" << C.Text << "#>";
335       break;
336     default:
337       OS << C.Text;
338       break;
339     }
340   }
341   return Result;
342 }
343 
344 const char *CodeCompletionString::getTypedText() const {
345   for (const Chunk &C : *this)
346     if (C.Kind == CK_TypedText)
347       return C.Text;
348 
349   return nullptr;
350 }
351 
352 std::string CodeCompletionString::getAllTypedText() const {
353   std::string Res;
354   for (const Chunk &C : *this)
355     if (C.Kind == CK_TypedText)
356       Res += C.Text;
357 
358   return Res;
359 }
360 
361 const char *CodeCompletionAllocator::CopyString(const Twine &String) {
362   SmallString<128> Data;
363   StringRef Ref = String.toStringRef(Data);
364   // FIXME: It would be more efficient to teach Twine to tell us its size and
365   // then add a routine there to fill in an allocated char* with the contents
366   // of the string.
367   char *Mem = (char *)Allocate(Ref.size() + 1, 1);
368   std::copy(Ref.begin(), Ref.end(), Mem);
369   Mem[Ref.size()] = 0;
370   return Mem;
371 }
372 
373 StringRef CodeCompletionTUInfo::getParentName(const DeclContext *DC) {
374   if (!isa<NamedDecl>(DC))
375     return {};
376 
377   // Check whether we've already cached the parent name.
378   StringRef &CachedParentName = ParentNames[DC];
379   if (!CachedParentName.empty())
380     return CachedParentName;
381 
382   // If we already processed this DeclContext and assigned empty to it, the
383   // data pointer will be non-null.
384   if (CachedParentName.data() != nullptr)
385     return {};
386 
387   // Find the interesting names.
388   SmallVector<const DeclContext *, 2> Contexts;
389   while (DC && !DC->isFunctionOrMethod()) {
390     if (const auto *ND = dyn_cast<NamedDecl>(DC)) {
391       if (ND->getIdentifier())
392         Contexts.push_back(DC);
393     }
394 
395     DC = DC->getParent();
396   }
397 
398   {
399     SmallString<128> S;
400     llvm::raw_svector_ostream OS(S);
401     bool First = true;
402     for (const DeclContext *CurDC : llvm::reverse(Contexts)) {
403       if (First)
404         First = false;
405       else {
406         OS << "::";
407       }
408 
409       if (const auto *CatImpl = dyn_cast<ObjCCategoryImplDecl>(CurDC))
410         CurDC = CatImpl->getCategoryDecl();
411 
412       if (const auto *Cat = dyn_cast<ObjCCategoryDecl>(CurDC)) {
413         const ObjCInterfaceDecl *Interface = Cat->getClassInterface();
414         if (!Interface) {
415           // Assign an empty StringRef but with non-null data to distinguish
416           // between empty because we didn't process the DeclContext yet.
417           CachedParentName = StringRef((const char *)(uintptr_t)~0U, 0);
418           return {};
419         }
420 
421         OS << Interface->getName() << '(' << Cat->getName() << ')';
422       } else {
423         OS << cast<NamedDecl>(CurDC)->getName();
424       }
425     }
426 
427     CachedParentName = AllocatorRef->CopyString(OS.str());
428   }
429 
430   return CachedParentName;
431 }
432 
433 CodeCompletionString *CodeCompletionBuilder::TakeString() {
434   void *Mem = getAllocator().Allocate(
435       sizeof(CodeCompletionString) + sizeof(Chunk) * Chunks.size() +
436           sizeof(const char *) * Annotations.size(),
437       alignof(CodeCompletionString));
438   CodeCompletionString *Result = new (Mem) CodeCompletionString(
439       Chunks.data(), Chunks.size(), Priority, Availability, Annotations.data(),
440       Annotations.size(), ParentName, BriefComment);
441   Chunks.clear();
442   return Result;
443 }
444 
445 void CodeCompletionBuilder::AddTypedTextChunk(const char *Text) {
446   Chunks.push_back(Chunk(CodeCompletionString::CK_TypedText, Text));
447 }
448 
449 void CodeCompletionBuilder::AddTextChunk(const char *Text) {
450   Chunks.push_back(Chunk::CreateText(Text));
451 }
452 
453 void CodeCompletionBuilder::AddOptionalChunk(CodeCompletionString *Optional) {
454   Chunks.push_back(Chunk::CreateOptional(Optional));
455 }
456 
457 void CodeCompletionBuilder::AddPlaceholderChunk(const char *Placeholder) {
458   Chunks.push_back(Chunk::CreatePlaceholder(Placeholder));
459 }
460 
461 void CodeCompletionBuilder::AddInformativeChunk(const char *Text) {
462   Chunks.push_back(Chunk::CreateInformative(Text));
463 }
464 
465 void CodeCompletionBuilder::AddResultTypeChunk(const char *ResultType) {
466   Chunks.push_back(Chunk::CreateResultType(ResultType));
467 }
468 
469 void CodeCompletionBuilder::AddCurrentParameterChunk(
470     const char *CurrentParameter) {
471   Chunks.push_back(Chunk::CreateCurrentParameter(CurrentParameter));
472 }
473 
474 void CodeCompletionBuilder::AddChunk(CodeCompletionString::ChunkKind CK,
475                                      const char *Text) {
476   Chunks.push_back(Chunk(CK, Text));
477 }
478 
479 void CodeCompletionBuilder::addParentContext(const DeclContext *DC) {
480   if (DC->isTranslationUnit())
481     return;
482 
483   if (DC->isFunctionOrMethod())
484     return;
485 
486   if (!isa<NamedDecl>(DC))
487     return;
488 
489   ParentName = getCodeCompletionTUInfo().getParentName(DC);
490 }
491 
492 void CodeCompletionBuilder::addBriefComment(StringRef Comment) {
493   BriefComment = Allocator.CopyString(Comment);
494 }
495 
496 //===----------------------------------------------------------------------===//
497 // Code completion overload candidate implementation
498 //===----------------------------------------------------------------------===//
499 FunctionDecl *CodeCompleteConsumer::OverloadCandidate::getFunction() const {
500   if (getKind() == CK_Function)
501     return Function;
502   else if (getKind() == CK_FunctionTemplate)
503     return FunctionTemplate->getTemplatedDecl();
504   else
505     return nullptr;
506 }
507 
508 const FunctionType *
509 CodeCompleteConsumer::OverloadCandidate::getFunctionType() const {
510   switch (Kind) {
511   case CK_Function:
512     return Function->getType()->getAs<FunctionType>();
513 
514   case CK_FunctionTemplate:
515     return FunctionTemplate->getTemplatedDecl()
516         ->getType()
517         ->getAs<FunctionType>();
518 
519   case CK_FunctionType:
520     return Type;
521   case CK_FunctionProtoTypeLoc:
522     return ProtoTypeLoc.getTypePtr();
523   case CK_Template:
524   case CK_Aggregate:
525     return nullptr;
526   }
527 
528   llvm_unreachable("Invalid CandidateKind!");
529 }
530 
531 const FunctionProtoTypeLoc
532 CodeCompleteConsumer::OverloadCandidate::getFunctionProtoTypeLoc() const {
533   if (Kind == CK_FunctionProtoTypeLoc)
534     return ProtoTypeLoc;
535   return FunctionProtoTypeLoc();
536 }
537 
538 unsigned CodeCompleteConsumer::OverloadCandidate::getNumParams() const {
539   if (Kind == CK_Template)
540     return Template->getTemplateParameters()->size();
541 
542   if (Kind == CK_Aggregate) {
543     unsigned Count =
544         std::distance(AggregateType->field_begin(), AggregateType->field_end());
545     if (const auto *CRD = dyn_cast<CXXRecordDecl>(AggregateType))
546       Count += CRD->getNumBases();
547     return Count;
548   }
549 
550   if (const auto *FT = getFunctionType())
551     if (const auto *FPT = dyn_cast<FunctionProtoType>(FT))
552       return FPT->getNumParams();
553 
554   return 0;
555 }
556 
557 QualType
558 CodeCompleteConsumer::OverloadCandidate::getParamType(unsigned N) const {
559   if (Kind == CK_Aggregate) {
560     if (const auto *CRD = dyn_cast<CXXRecordDecl>(AggregateType)) {
561       if (N < CRD->getNumBases())
562         return std::next(CRD->bases_begin(), N)->getType();
563       N -= CRD->getNumBases();
564     }
565     for (const auto *Field : AggregateType->fields())
566       if (N-- == 0)
567         return Field->getType();
568     return QualType();
569   }
570 
571   if (Kind == CK_Template) {
572     TemplateParameterList *TPL = getTemplate()->getTemplateParameters();
573     if (N < TPL->size())
574       if (const auto *D = dyn_cast<NonTypeTemplateParmDecl>(TPL->getParam(N)))
575         return D->getType();
576     return QualType();
577   }
578 
579   if (const auto *FT = getFunctionType())
580     if (const auto *FPT = dyn_cast<FunctionProtoType>(FT))
581       if (N < FPT->getNumParams())
582         return FPT->getParamType(N);
583   return QualType();
584 }
585 
586 const NamedDecl *
587 CodeCompleteConsumer::OverloadCandidate::getParamDecl(unsigned N) const {
588   if (Kind == CK_Aggregate) {
589     if (const auto *CRD = dyn_cast<CXXRecordDecl>(AggregateType)) {
590       if (N < CRD->getNumBases())
591         return std::next(CRD->bases_begin(), N)->getType()->getAsTagDecl();
592       N -= CRD->getNumBases();
593     }
594     for (const auto *Field : AggregateType->fields())
595       if (N-- == 0)
596         return Field;
597     return nullptr;
598   }
599 
600   if (Kind == CK_Template) {
601     TemplateParameterList *TPL = getTemplate()->getTemplateParameters();
602     if (N < TPL->size())
603       return TPL->getParam(N);
604     return nullptr;
605   }
606 
607   // Note that if we only have a FunctionProtoType, we don't have param decls.
608   if (const auto *FD = getFunction()) {
609     if (N < FD->param_size())
610       return FD->getParamDecl(N);
611   } else if (Kind == CK_FunctionProtoTypeLoc) {
612     if (N < ProtoTypeLoc.getNumParams()) {
613       return ProtoTypeLoc.getParam(N);
614     }
615   }
616 
617   return nullptr;
618 }
619 
620 //===----------------------------------------------------------------------===//
621 // Code completion consumer implementation
622 //===----------------------------------------------------------------------===//
623 
624 CodeCompleteConsumer::~CodeCompleteConsumer() = default;
625 
626 bool PrintingCodeCompleteConsumer::isResultFilteredOut(
627     StringRef Filter, CodeCompletionResult Result) {
628   switch (Result.Kind) {
629   case CodeCompletionResult::RK_Declaration:
630     return !(Result.Declaration->getIdentifier() &&
631              Result.Declaration->getIdentifier()->getName().startswith(Filter));
632   case CodeCompletionResult::RK_Keyword:
633     return !StringRef(Result.Keyword).startswith(Filter);
634   case CodeCompletionResult::RK_Macro:
635     return !Result.Macro->getName().startswith(Filter);
636   case CodeCompletionResult::RK_Pattern:
637     return !(Result.Pattern->getTypedText() &&
638              StringRef(Result.Pattern->getTypedText()).startswith(Filter));
639   }
640   llvm_unreachable("Unknown code completion result Kind.");
641 }
642 
643 void PrintingCodeCompleteConsumer::ProcessCodeCompleteResults(
644     Sema &SemaRef, CodeCompletionContext Context, CodeCompletionResult *Results,
645     unsigned NumResults) {
646   std::stable_sort(Results, Results + NumResults);
647 
648   if (!Context.getPreferredType().isNull())
649     OS << "PREFERRED-TYPE: " << Context.getPreferredType() << '\n';
650 
651   StringRef Filter = SemaRef.getPreprocessor().getCodeCompletionFilter();
652   // Print the completions.
653   for (unsigned I = 0; I != NumResults; ++I) {
654     if (!Filter.empty() && isResultFilteredOut(Filter, Results[I]))
655       continue;
656     OS << "COMPLETION: ";
657     switch (Results[I].Kind) {
658     case CodeCompletionResult::RK_Declaration:
659       OS << *Results[I].Declaration;
660       {
661         std::vector<std::string> Tags;
662         if (Results[I].Hidden)
663           Tags.push_back("Hidden");
664         if (Results[I].InBaseClass)
665           Tags.push_back("InBase");
666         if (Results[I].Availability ==
667             CXAvailabilityKind::CXAvailability_NotAccessible)
668           Tags.push_back("Inaccessible");
669         if (!Tags.empty())
670           OS << " (" << llvm::join(Tags, ",") << ")";
671       }
672       if (CodeCompletionString *CCS = Results[I].CreateCodeCompletionString(
673               SemaRef, Context, getAllocator(), CCTUInfo,
674               includeBriefComments())) {
675         OS << " : " << CCS->getAsString();
676         if (const char *BriefComment = CCS->getBriefComment())
677           OS << " : " << BriefComment;
678       }
679       break;
680 
681     case CodeCompletionResult::RK_Keyword:
682       OS << Results[I].Keyword;
683       break;
684 
685     case CodeCompletionResult::RK_Macro:
686       OS << Results[I].Macro->getName();
687       if (CodeCompletionString *CCS = Results[I].CreateCodeCompletionString(
688               SemaRef, Context, getAllocator(), CCTUInfo,
689               includeBriefComments())) {
690         OS << " : " << CCS->getAsString();
691       }
692       break;
693 
694     case CodeCompletionResult::RK_Pattern:
695       OS << "Pattern : " << Results[I].Pattern->getAsString();
696       break;
697     }
698     for (const FixItHint &FixIt : Results[I].FixIts) {
699       const SourceLocation BLoc = FixIt.RemoveRange.getBegin();
700       const SourceLocation ELoc = FixIt.RemoveRange.getEnd();
701 
702       SourceManager &SM = SemaRef.SourceMgr;
703       std::pair<FileID, unsigned> BInfo = SM.getDecomposedLoc(BLoc);
704       std::pair<FileID, unsigned> EInfo = SM.getDecomposedLoc(ELoc);
705       // Adjust for token ranges.
706       if (FixIt.RemoveRange.isTokenRange())
707         EInfo.second += Lexer::MeasureTokenLength(ELoc, SM, SemaRef.LangOpts);
708 
709       OS << " (requires fix-it:"
710          << " {" << SM.getLineNumber(BInfo.first, BInfo.second) << ':'
711          << SM.getColumnNumber(BInfo.first, BInfo.second) << '-'
712          << SM.getLineNumber(EInfo.first, EInfo.second) << ':'
713          << SM.getColumnNumber(EInfo.first, EInfo.second) << "}"
714          << " to \"" << FixIt.CodeToInsert << "\")";
715     }
716     OS << '\n';
717   }
718 }
719 
720 // This function is used solely to preserve the former presentation of overloads
721 // by "clang -cc1 -code-completion-at", since CodeCompletionString::getAsString
722 // needs to be improved for printing the newer and more detailed overload
723 // chunks.
724 static std::string getOverloadAsString(const CodeCompletionString &CCS) {
725   std::string Result;
726   llvm::raw_string_ostream OS(Result);
727 
728   for (auto &C : CCS) {
729     switch (C.Kind) {
730     case CodeCompletionString::CK_Informative:
731     case CodeCompletionString::CK_ResultType:
732       OS << "[#" << C.Text << "#]";
733       break;
734 
735     case CodeCompletionString::CK_CurrentParameter:
736       OS << "<#" << C.Text << "#>";
737       break;
738 
739     // FIXME: We can also print optional parameters of an overload.
740     case CodeCompletionString::CK_Optional:
741       break;
742 
743     default:
744       OS << C.Text;
745       break;
746     }
747   }
748   return Result;
749 }
750 
751 void PrintingCodeCompleteConsumer::ProcessOverloadCandidates(
752     Sema &SemaRef, unsigned CurrentArg, OverloadCandidate *Candidates,
753     unsigned NumCandidates, SourceLocation OpenParLoc, bool Braced) {
754   OS << "OPENING_PAREN_LOC: ";
755   OpenParLoc.print(OS, SemaRef.getSourceManager());
756   OS << "\n";
757 
758   for (unsigned I = 0; I != NumCandidates; ++I) {
759     if (CodeCompletionString *CCS = Candidates[I].CreateSignatureString(
760             CurrentArg, SemaRef, getAllocator(), CCTUInfo,
761             includeBriefComments(), Braced)) {
762       OS << "OVERLOAD: " << getOverloadAsString(*CCS) << "\n";
763     }
764   }
765 }
766 
767 /// Retrieve the effective availability of the given declaration.
768 static AvailabilityResult getDeclAvailability(const Decl *D) {
769   AvailabilityResult AR = D->getAvailability();
770   if (isa<EnumConstantDecl>(D))
771     AR = std::max(AR, cast<Decl>(D->getDeclContext())->getAvailability());
772   return AR;
773 }
774 
775 void CodeCompletionResult::computeCursorKindAndAvailability(bool Accessible) {
776   switch (Kind) {
777   case RK_Pattern:
778     if (!Declaration) {
779       // Do nothing: Patterns can come with cursor kinds!
780       break;
781     }
782     [[fallthrough]];
783 
784   case RK_Declaration: {
785     // Set the availability based on attributes.
786     switch (getDeclAvailability(Declaration)) {
787     case AR_Available:
788     case AR_NotYetIntroduced:
789       Availability = CXAvailability_Available;
790       break;
791 
792     case AR_Deprecated:
793       Availability = CXAvailability_Deprecated;
794       break;
795 
796     case AR_Unavailable:
797       Availability = CXAvailability_NotAvailable;
798       break;
799     }
800 
801     if (const auto *Function = dyn_cast<FunctionDecl>(Declaration))
802       if (Function->isDeleted())
803         Availability = CXAvailability_NotAvailable;
804 
805     CursorKind = getCursorKindForDecl(Declaration);
806     if (CursorKind == CXCursor_UnexposedDecl) {
807       // FIXME: Forward declarations of Objective-C classes and protocols
808       // are not directly exposed, but we want code completion to treat them
809       // like a definition.
810       if (isa<ObjCInterfaceDecl>(Declaration))
811         CursorKind = CXCursor_ObjCInterfaceDecl;
812       else if (isa<ObjCProtocolDecl>(Declaration))
813         CursorKind = CXCursor_ObjCProtocolDecl;
814       else
815         CursorKind = CXCursor_NotImplemented;
816     }
817     break;
818   }
819 
820   case RK_Macro:
821   case RK_Keyword:
822     llvm_unreachable("Macro and keyword kinds are handled by the constructors");
823   }
824 
825   if (!Accessible)
826     Availability = CXAvailability_NotAccessible;
827 }
828 
829 /// Retrieve the name that should be used to order a result.
830 ///
831 /// If the name needs to be constructed as a string, that string will be
832 /// saved into Saved and the returned StringRef will refer to it.
833 StringRef CodeCompletionResult::getOrderedName(std::string &Saved) const {
834   switch (Kind) {
835   case RK_Keyword:
836     return Keyword;
837   case RK_Pattern:
838     return Pattern->getTypedText();
839   case RK_Macro:
840     return Macro->getName();
841   case RK_Declaration:
842     // Handle declarations below.
843     break;
844   }
845 
846   DeclarationName Name = Declaration->getDeclName();
847 
848   // If the name is a simple identifier (by far the common case), or a
849   // zero-argument selector, just return a reference to that identifier.
850   if (IdentifierInfo *Id = Name.getAsIdentifierInfo())
851     return Id->getName();
852   if (Name.isObjCZeroArgSelector())
853     if (IdentifierInfo *Id = Name.getObjCSelector().getIdentifierInfoForSlot(0))
854       return Id->getName();
855 
856   Saved = Name.getAsString();
857   return Saved;
858 }
859 
860 bool clang::operator<(const CodeCompletionResult &X,
861                       const CodeCompletionResult &Y) {
862   std::string XSaved, YSaved;
863   StringRef XStr = X.getOrderedName(XSaved);
864   StringRef YStr = Y.getOrderedName(YSaved);
865   int cmp = XStr.compare_insensitive(YStr);
866   if (cmp)
867     return cmp < 0;
868 
869   // If case-insensitive comparison fails, try case-sensitive comparison.
870   return XStr.compare(YStr) < 0;
871 }
872