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
28using namespace clang;
29
30//===----------------------------------------------------------------------===//
31// Code completion context implementation
32//===----------------------------------------------------------------------===//
33
34bool 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//===----------------------------------------------------------------------===//
81CodeCompletionString::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
155CodeCompletionString::Chunk
156CodeCompletionString::Chunk::CreateText(const char *Text) {
157  return Chunk(CK_Text, Text);
158}
159
160CodeCompletionString::Chunk
161CodeCompletionString::Chunk::CreateOptional(CodeCompletionString *Optional) {
162  Chunk Result;
163  Result.Kind = CK_Optional;
164  Result.Optional = Optional;
165  return Result;
166}
167
168CodeCompletionString::Chunk
169CodeCompletionString::Chunk::CreatePlaceholder(const char *Placeholder) {
170  return Chunk(CK_Placeholder, Placeholder);
171}
172
173CodeCompletionString::Chunk
174CodeCompletionString::Chunk::CreateInformative(const char *Informative) {
175  return Chunk(CK_Informative, Informative);
176}
177
178CodeCompletionString::Chunk
179CodeCompletionString::Chunk::CreateResultType(const char *ResultType) {
180  return Chunk(CK_ResultType, ResultType);
181}
182
183CodeCompletionString::Chunk
184CodeCompletionString::Chunk::CreateCurrentParameter(
185                                                const char *CurrentParameter) {
186  return Chunk(CK_CurrentParameter, CurrentParameter);
187}
188
189CodeCompletionString::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
213unsigned CodeCompletionString::getAnnotationCount() const {
214  return NumAnnotations;
215}
216
217const 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
225std::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
246const 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
254const char *CodeCompletionAllocator::CopyString(const Twine &String) {
255  SmallString<128> Data;
256  StringRef Ref = String.toStringRef(Data);
257  // FIXME: It would be more efficient to teach Twine to tell us its size and
258  // then add a routine there to fill in an allocated char* with the contents
259  // of the string.
260  char *Mem = (char *)Allocate(Ref.size() + 1, 1);
261  std::copy(Ref.begin(), Ref.end(), Mem);
262  Mem[Ref.size()] = 0;
263  return Mem;
264}
265
266StringRef CodeCompletionTUInfo::getParentName(const DeclContext *DC) {
267  const NamedDecl *ND = dyn_cast<NamedDecl>(DC);
268  if (!ND)
269    return StringRef();
270
271  // Check whether we've already cached the parent name.
272  StringRef &CachedParentName = ParentNames[DC];
273  if (!CachedParentName.empty())
274    return CachedParentName;
275
276  // If we already processed this DeclContext and assigned empty to it, the
277  // data pointer will be non-null.
278  if (CachedParentName.data() != nullptr)
279    return StringRef();
280
281  // Find the interesting names.
282  SmallVector<const DeclContext *, 2> Contexts;
283  while (DC && !DC->isFunctionOrMethod()) {
284    if (const NamedDecl *ND = dyn_cast<NamedDecl>(DC)) {
285      if (ND->getIdentifier())
286        Contexts.push_back(DC);
287    }
288
289    DC = DC->getParent();
290  }
291
292  {
293    SmallString<128> S;
294    llvm::raw_svector_ostream OS(S);
295    bool First = true;
296    for (unsigned I = Contexts.size(); I != 0; --I) {
297      if (First)
298        First = false;
299      else {
300        OS << "::";
301      }
302
303      const DeclContext *CurDC = Contexts[I-1];
304      if (const ObjCCategoryImplDecl *CatImpl = dyn_cast<ObjCCategoryImplDecl>(CurDC))
305        CurDC = CatImpl->getCategoryDecl();
306
307      if (const ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(CurDC)) {
308        const ObjCInterfaceDecl *Interface = Cat->getClassInterface();
309        if (!Interface) {
310          // Assign an empty StringRef but with non-null data to distinguish
311          // between empty because we didn't process the DeclContext yet.
312          CachedParentName = StringRef((const char *)(uintptr_t)~0U, 0);
313          return StringRef();
314        }
315
316        OS << Interface->getName() << '(' << Cat->getName() << ')';
317      } else {
318        OS << cast<NamedDecl>(CurDC)->getName();
319      }
320    }
321
322    CachedParentName = AllocatorRef->CopyString(OS.str());
323  }
324
325  return CachedParentName;
326}
327
328CodeCompletionString *CodeCompletionBuilder::TakeString() {
329  void *Mem = getAllocator().Allocate(
330                  sizeof(CodeCompletionString) + sizeof(Chunk) * Chunks.size()
331                                    + sizeof(const char *) * Annotations.size(),
332                                 llvm::alignOf<CodeCompletionString>());
333  CodeCompletionString *Result
334    = new (Mem) CodeCompletionString(Chunks.data(), Chunks.size(),
335                                     Priority, Availability,
336                                     Annotations.data(), Annotations.size(),
337                                     ParentName, BriefComment);
338  Chunks.clear();
339  return Result;
340}
341
342void CodeCompletionBuilder::AddTypedTextChunk(const char *Text) {
343  Chunks.push_back(Chunk(CodeCompletionString::CK_TypedText, Text));
344}
345
346void CodeCompletionBuilder::AddTextChunk(const char *Text) {
347  Chunks.push_back(Chunk::CreateText(Text));
348}
349
350void CodeCompletionBuilder::AddOptionalChunk(CodeCompletionString *Optional) {
351  Chunks.push_back(Chunk::CreateOptional(Optional));
352}
353
354void CodeCompletionBuilder::AddPlaceholderChunk(const char *Placeholder) {
355  Chunks.push_back(Chunk::CreatePlaceholder(Placeholder));
356}
357
358void CodeCompletionBuilder::AddInformativeChunk(const char *Text) {
359  Chunks.push_back(Chunk::CreateInformative(Text));
360}
361
362void CodeCompletionBuilder::AddResultTypeChunk(const char *ResultType) {
363  Chunks.push_back(Chunk::CreateResultType(ResultType));
364}
365
366void
367CodeCompletionBuilder::AddCurrentParameterChunk(const char *CurrentParameter) {
368  Chunks.push_back(Chunk::CreateCurrentParameter(CurrentParameter));
369}
370
371void CodeCompletionBuilder::AddChunk(CodeCompletionString::ChunkKind CK,
372                                     const char *Text) {
373  Chunks.push_back(Chunk(CK, Text));
374}
375
376void CodeCompletionBuilder::addParentContext(const DeclContext *DC) {
377  if (DC->isTranslationUnit()) {
378    return;
379  }
380
381  if (DC->isFunctionOrMethod())
382    return;
383
384  const NamedDecl *ND = dyn_cast<NamedDecl>(DC);
385  if (!ND)
386    return;
387
388  ParentName = getCodeCompletionTUInfo().getParentName(DC);
389}
390
391void CodeCompletionBuilder::addBriefComment(StringRef Comment) {
392  BriefComment = Allocator.CopyString(Comment);
393}
394
395//===----------------------------------------------------------------------===//
396// Code completion overload candidate implementation
397//===----------------------------------------------------------------------===//
398FunctionDecl *
399CodeCompleteConsumer::OverloadCandidate::getFunction() const {
400  if (getKind() == CK_Function)
401    return Function;
402  else if (getKind() == CK_FunctionTemplate)
403    return FunctionTemplate->getTemplatedDecl();
404  else
405    return nullptr;
406}
407
408const FunctionType *
409CodeCompleteConsumer::OverloadCandidate::getFunctionType() const {
410  switch (Kind) {
411  case CK_Function:
412    return Function->getType()->getAs<FunctionType>();
413
414  case CK_FunctionTemplate:
415    return FunctionTemplate->getTemplatedDecl()->getType()
416             ->getAs<FunctionType>();
417
418  case CK_FunctionType:
419    return Type;
420  }
421
422  llvm_unreachable("Invalid CandidateKind!");
423}
424
425//===----------------------------------------------------------------------===//
426// Code completion consumer implementation
427//===----------------------------------------------------------------------===//
428
429CodeCompleteConsumer::~CodeCompleteConsumer() { }
430
431void
432PrintingCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &SemaRef,
433                                                 CodeCompletionContext Context,
434                                                 CodeCompletionResult *Results,
435                                                         unsigned NumResults) {
436  std::stable_sort(Results, Results + NumResults);
437
438  // Print the results.
439  for (unsigned I = 0; I != NumResults; ++I) {
440    OS << "COMPLETION: ";
441    switch (Results[I].Kind) {
442    case CodeCompletionResult::RK_Declaration:
443      OS << *Results[I].Declaration;
444      if (Results[I].Hidden)
445        OS << " (Hidden)";
446      if (CodeCompletionString *CCS
447            = Results[I].CreateCodeCompletionString(SemaRef, Context,
448                                                    getAllocator(),
449                                                    CCTUInfo,
450                                                    includeBriefComments())) {
451        OS << " : " << CCS->getAsString();
452        if (const char *BriefComment = CCS->getBriefComment())
453          OS << " : " << BriefComment;
454      }
455
456      OS << '\n';
457      break;
458
459    case CodeCompletionResult::RK_Keyword:
460      OS << Results[I].Keyword << '\n';
461      break;
462
463    case CodeCompletionResult::RK_Macro: {
464      OS << Results[I].Macro->getName();
465      if (CodeCompletionString *CCS
466            = Results[I].CreateCodeCompletionString(SemaRef, Context,
467                                                    getAllocator(),
468                                                    CCTUInfo,
469                                                    includeBriefComments())) {
470        OS << " : " << CCS->getAsString();
471      }
472      OS << '\n';
473      break;
474    }
475
476    case CodeCompletionResult::RK_Pattern: {
477      OS << "Pattern : "
478         << Results[I].Pattern->getAsString() << '\n';
479      break;
480    }
481    }
482  }
483}
484
485// This function is used solely to preserve the former presentation of overloads
486// by "clang -cc1 -code-completion-at", since CodeCompletionString::getAsString
487// needs to be improved for printing the newer and more detailed overload
488// chunks.
489static std::string getOverloadAsString(const CodeCompletionString &CCS) {
490  std::string Result;
491  llvm::raw_string_ostream OS(Result);
492
493  for (auto &C : CCS) {
494    switch (C.Kind) {
495    case CodeCompletionString::CK_Informative:
496    case CodeCompletionString::CK_ResultType:
497      OS << "[#" << C.Text << "#]";
498      break;
499
500    case CodeCompletionString::CK_CurrentParameter:
501      OS << "<#" << C.Text << "#>";
502      break;
503
504    default: OS << C.Text; break;
505    }
506  }
507  return OS.str();
508}
509
510void
511PrintingCodeCompleteConsumer::ProcessOverloadCandidates(Sema &SemaRef,
512                                                        unsigned CurrentArg,
513                                              OverloadCandidate *Candidates,
514                                                     unsigned NumCandidates) {
515  for (unsigned I = 0; I != NumCandidates; ++I) {
516    if (CodeCompletionString *CCS
517          = Candidates[I].CreateSignatureString(CurrentArg, SemaRef,
518                                                getAllocator(), CCTUInfo,
519                                                includeBriefComments())) {
520      OS << "OVERLOAD: " << getOverloadAsString(*CCS) << "\n";
521    }
522  }
523}
524
525/// \brief Retrieve the effective availability of the given declaration.
526static AvailabilityResult getDeclAvailability(const Decl *D) {
527  AvailabilityResult AR = D->getAvailability();
528  if (isa<EnumConstantDecl>(D))
529    AR = std::max(AR, cast<Decl>(D->getDeclContext())->getAvailability());
530  return AR;
531}
532
533void CodeCompletionResult::computeCursorKindAndAvailability(bool Accessible) {
534  switch (Kind) {
535  case RK_Pattern:
536    if (!Declaration) {
537      // Do nothing: Patterns can come with cursor kinds!
538      break;
539    }
540    // Fall through
541
542  case RK_Declaration: {
543    // Set the availability based on attributes.
544    switch (getDeclAvailability(Declaration)) {
545    case AR_Available:
546    case AR_NotYetIntroduced:
547      Availability = CXAvailability_Available;
548      break;
549
550    case AR_Deprecated:
551      Availability = CXAvailability_Deprecated;
552      break;
553
554    case AR_Unavailable:
555      Availability = CXAvailability_NotAvailable;
556      break;
557    }
558
559    if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(Declaration))
560      if (Function->isDeleted())
561        Availability = CXAvailability_NotAvailable;
562
563    CursorKind = getCursorKindForDecl(Declaration);
564    if (CursorKind == CXCursor_UnexposedDecl) {
565      // FIXME: Forward declarations of Objective-C classes and protocols
566      // are not directly exposed, but we want code completion to treat them
567      // like a definition.
568      if (isa<ObjCInterfaceDecl>(Declaration))
569        CursorKind = CXCursor_ObjCInterfaceDecl;
570      else if (isa<ObjCProtocolDecl>(Declaration))
571        CursorKind = CXCursor_ObjCProtocolDecl;
572      else
573        CursorKind = CXCursor_NotImplemented;
574    }
575    break;
576  }
577
578  case RK_Macro:
579  case RK_Keyword:
580    llvm_unreachable("Macro and keyword kinds are handled by the constructors");
581  }
582
583  if (!Accessible)
584    Availability = CXAvailability_NotAccessible;
585}
586
587/// \brief Retrieve the name that should be used to order a result.
588///
589/// If the name needs to be constructed as a string, that string will be
590/// saved into Saved and the returned StringRef will refer to it.
591static StringRef getOrderedName(const CodeCompletionResult &R,
592                                    std::string &Saved) {
593  switch (R.Kind) {
594    case CodeCompletionResult::RK_Keyword:
595      return R.Keyword;
596
597    case CodeCompletionResult::RK_Pattern:
598      return R.Pattern->getTypedText();
599
600    case CodeCompletionResult::RK_Macro:
601      return R.Macro->getName();
602
603    case CodeCompletionResult::RK_Declaration:
604      // Handle declarations below.
605      break;
606  }
607
608  DeclarationName Name = R.Declaration->getDeclName();
609
610  // If the name is a simple identifier (by far the common case), or a
611  // zero-argument selector, just return a reference to that identifier.
612  if (IdentifierInfo *Id = Name.getAsIdentifierInfo())
613    return Id->getName();
614  if (Name.isObjCZeroArgSelector())
615    if (IdentifierInfo *Id
616        = Name.getObjCSelector().getIdentifierInfoForSlot(0))
617      return Id->getName();
618
619  Saved = Name.getAsString();
620  return Saved;
621}
622
623bool clang::operator<(const CodeCompletionResult &X,
624                      const CodeCompletionResult &Y) {
625  std::string XSaved, YSaved;
626  StringRef XStr = getOrderedName(X, XSaved);
627  StringRef YStr = getOrderedName(Y, YSaved);
628  int cmp = XStr.compare_lower(YStr);
629  if (cmp)
630    return cmp < 0;
631
632  // If case-insensitive comparison fails, try case-sensitive comparison.
633  cmp = XStr.compare(YStr);
634  if (cmp)
635    return cmp < 0;
636
637  return false;
638}
639