CodeCompleteConsumer.cpp revision 6f942b2cabf32b96f9901b889d8e44a34e0e7c62 
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/Sema/Scope.h"
15#include "clang/Sema/Sema.h"
16#include "clang/AST/DeclCXX.h"
17#include "clang/AST/DeclObjC.h"
18#include "clang/AST/DeclTemplate.h"
19#include "clang/Lex/Preprocessor.h"
20#include "clang-c/Index.h"
21#include "llvm/ADT/STLExtras.h"
22#include "llvm/Support/raw_ostream.h"
23#include <algorithm>
24#include <cstring>
25#include <functional>
26
27using namespace clang;
28using llvm::StringRef;
29
30//===----------------------------------------------------------------------===//
31// Code completion context implementation
32//===----------------------------------------------------------------------===//
33
34bool CodeCompletionContext::wantConstructorResults() const {
35  switch (Kind) {
36  case CCC_Other:
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_MemberAccess:
49  case CCC_EnumTag:
50  case CCC_UnionTag:
51  case CCC_ClassOrStructTag:
52  case CCC_ObjCProtocolName:
53  case CCC_Namespace:
54  case CCC_Type:
55  case CCC_Name:
56  case CCC_PotentiallyQualifiedName:
57  case CCC_MacroName:
58  case CCC_MacroNameUse:
59  case CCC_PreprocessorExpression:
60  case CCC_PreprocessorDirective:
61  case CCC_NaturalLanguage:
62  case CCC_SelectorName:
63  case CCC_TypeQualifiers:
64    return false;
65  }
66
67  return false;
68}
69
70//===----------------------------------------------------------------------===//
71// Code completion string implementation
72//===----------------------------------------------------------------------===//
73CodeCompletionString::Chunk::Chunk(ChunkKind Kind, llvm::StringRef Text)
74  : Kind(Kind), Text("")
75{
76  switch (Kind) {
77  case CK_TypedText:
78  case CK_Text:
79  case CK_Placeholder:
80  case CK_Informative:
81  case CK_ResultType:
82  case CK_CurrentParameter: {
83    char *New = new char [Text.size() + 1];
84    std::memcpy(New, Text.data(), Text.size());
85    New[Text.size()] = '\0';
86    this->Text = New;
87    break;
88  }
89
90  case CK_Optional:
91    llvm_unreachable("Optional strings cannot be created from text");
92    break;
93
94  case CK_LeftParen:
95    this->Text = "(";
96    break;
97
98  case CK_RightParen:
99    this->Text = ")";
100    break;
101
102  case CK_LeftBracket:
103    this->Text = "[";
104    break;
105
106  case CK_RightBracket:
107    this->Text = "]";
108    break;
109
110  case CK_LeftBrace:
111    this->Text = "{";
112    break;
113
114  case CK_RightBrace:
115    this->Text = "}";
116    break;
117
118  case CK_LeftAngle:
119    this->Text = "<";
120    break;
121
122  case CK_RightAngle:
123    this->Text = ">";
124    break;
125
126  case CK_Comma:
127    this->Text = ", ";
128    break;
129
130  case CK_Colon:
131    this->Text = ":";
132    break;
133
134  case CK_SemiColon:
135    this->Text = ";";
136    break;
137
138  case CK_Equal:
139    this->Text = " = ";
140    break;
141
142  case CK_HorizontalSpace:
143    this->Text = " ";
144    break;
145
146  case CK_VerticalSpace:
147    this->Text = "\n";
148    break;
149  }
150}
151
152CodeCompletionString::Chunk
153CodeCompletionString::Chunk::CreateText(StringRef Text) {
154  return Chunk(CK_Text, Text);
155}
156
157CodeCompletionString::Chunk
158CodeCompletionString::Chunk::CreateOptional(
159                                 std::auto_ptr<CodeCompletionString> Optional) {
160  Chunk Result;
161  Result.Kind = CK_Optional;
162  Result.Optional = Optional.release();
163  return Result;
164}
165
166CodeCompletionString::Chunk
167CodeCompletionString::Chunk::CreatePlaceholder(StringRef Placeholder) {
168  return Chunk(CK_Placeholder, Placeholder);
169}
170
171CodeCompletionString::Chunk
172CodeCompletionString::Chunk::CreateInformative(StringRef Informative) {
173  return Chunk(CK_Informative, Informative);
174}
175
176CodeCompletionString::Chunk
177CodeCompletionString::Chunk::CreateResultType(StringRef ResultType) {
178  return Chunk(CK_ResultType, ResultType);
179}
180
181CodeCompletionString::Chunk
182CodeCompletionString::Chunk::CreateCurrentParameter(
183                                                StringRef CurrentParameter) {
184  return Chunk(CK_CurrentParameter, CurrentParameter);
185}
186
187CodeCompletionString::Chunk CodeCompletionString::Chunk::Clone() const {
188  switch (Kind) {
189  case CK_TypedText:
190  case CK_Text:
191  case CK_Placeholder:
192  case CK_Informative:
193  case CK_ResultType:
194  case CK_CurrentParameter:
195  case CK_LeftParen:
196  case CK_RightParen:
197  case CK_LeftBracket:
198  case CK_RightBracket:
199  case CK_LeftBrace:
200  case CK_RightBrace:
201  case CK_LeftAngle:
202  case CK_RightAngle:
203  case CK_Comma:
204  case CK_Colon:
205  case CK_SemiColon:
206  case CK_Equal:
207  case CK_HorizontalSpace:
208  case CK_VerticalSpace:
209    return Chunk(Kind, Text);
210
211  case CK_Optional: {
212    std::auto_ptr<CodeCompletionString> Opt(Optional->Clone());
213    return CreateOptional(Opt);
214  }
215  }
216
217  // Silence GCC warning.
218  return Chunk();
219}
220
221void
222CodeCompletionString::Chunk::Destroy() {
223  switch (Kind) {
224  case CK_Optional:
225    delete Optional;
226    break;
227
228  case CK_TypedText:
229  case CK_Text:
230  case CK_Placeholder:
231  case CK_Informative:
232  case CK_ResultType:
233  case CK_CurrentParameter:
234    delete [] Text;
235    break;
236
237  case CK_LeftParen:
238  case CK_RightParen:
239  case CK_LeftBracket:
240  case CK_RightBracket:
241  case CK_LeftBrace:
242  case CK_RightBrace:
243  case CK_LeftAngle:
244  case CK_RightAngle:
245  case CK_Comma:
246  case CK_Colon:
247  case CK_SemiColon:
248  case CK_Equal:
249  case CK_HorizontalSpace:
250  case CK_VerticalSpace:
251    break;
252  }
253}
254
255void CodeCompletionString::clear() {
256  std::for_each(Chunks.begin(), Chunks.end(),
257                std::mem_fun_ref(&Chunk::Destroy));
258  Chunks.clear();
259}
260
261std::string CodeCompletionString::getAsString() const {
262  std::string Result;
263  llvm::raw_string_ostream OS(Result);
264
265  for (iterator C = begin(), CEnd = end(); C != CEnd; ++C) {
266    switch (C->Kind) {
267    case CK_Optional: OS << "{#" << C->Optional->getAsString() << "#}"; break;
268    case CK_Placeholder: OS << "<#" << C->Text << "#>"; break;
269
270    case CK_Informative:
271    case CK_ResultType:
272      OS << "[#" << C->Text << "#]";
273      break;
274
275    case CK_CurrentParameter: OS << "<#" << C->Text << "#>"; break;
276    default: OS << C->Text; break;
277    }
278  }
279  return OS.str();
280}
281
282const char *CodeCompletionString::getTypedText() const {
283  for (iterator C = begin(), CEnd = end(); C != CEnd; ++C)
284    if (C->Kind == CK_TypedText)
285      return C->Text;
286
287  return 0;
288}
289
290CodeCompletionString *
291CodeCompletionString::Clone(CodeCompletionString *Result) const {
292  if (!Result)
293    Result = new CodeCompletionString;
294  for (iterator C = begin(), CEnd = end(); C != CEnd; ++C)
295    Result->AddChunk(C->Clone());
296  return Result;
297}
298
299static void WriteUnsigned(llvm::raw_ostream &OS, unsigned Value) {
300  OS.write((const char *)&Value, sizeof(unsigned));
301}
302
303static bool ReadUnsigned(const char *&Memory, const char *MemoryEnd,
304                         unsigned &Value) {
305  if (Memory + sizeof(unsigned) > MemoryEnd)
306    return true;
307
308  memmove(&Value, Memory, sizeof(unsigned));
309  Memory += sizeof(unsigned);
310  return false;
311}
312
313void CodeCompletionString::Serialize(llvm::raw_ostream &OS) const {
314  // Write the number of chunks.
315  WriteUnsigned(OS, size());
316
317  for (iterator C = begin(), CEnd = end(); C != CEnd; ++C) {
318    WriteUnsigned(OS, C->Kind);
319
320    switch (C->Kind) {
321    case CK_TypedText:
322    case CK_Text:
323    case CK_Placeholder:
324    case CK_Informative:
325    case CK_ResultType:
326    case CK_CurrentParameter: {
327      const char *Text = C->Text;
328      unsigned StrLen = strlen(Text);
329      WriteUnsigned(OS, StrLen);
330      OS.write(Text, StrLen);
331      break;
332    }
333
334    case CK_Optional:
335      C->Optional->Serialize(OS);
336      break;
337
338    case CK_LeftParen:
339    case CK_RightParen:
340    case CK_LeftBracket:
341    case CK_RightBracket:
342    case CK_LeftBrace:
343    case CK_RightBrace:
344    case CK_LeftAngle:
345    case CK_RightAngle:
346    case CK_Comma:
347    case CK_Colon:
348    case CK_SemiColon:
349    case CK_Equal:
350    case CK_HorizontalSpace:
351    case CK_VerticalSpace:
352      break;
353    }
354  }
355}
356
357bool CodeCompletionString::Deserialize(const char *&Str, const char *StrEnd) {
358  if (Str == StrEnd || *Str == 0)
359    return false;
360
361  unsigned NumBlocks;
362  if (ReadUnsigned(Str, StrEnd, NumBlocks))
363    return false;
364
365  for (unsigned I = 0; I != NumBlocks; ++I) {
366    if (Str + 1 >= StrEnd)
367      break;
368
369    // Parse the next kind.
370    unsigned KindValue;
371    if (ReadUnsigned(Str, StrEnd, KindValue))
372      return false;
373
374    switch (ChunkKind Kind = (ChunkKind)KindValue) {
375    case CK_TypedText:
376    case CK_Text:
377    case CK_Placeholder:
378    case CK_Informative:
379    case CK_ResultType:
380    case CK_CurrentParameter: {
381      unsigned StrLen;
382      if (ReadUnsigned(Str, StrEnd, StrLen) || (Str + StrLen > StrEnd))
383        return false;
384
385      AddChunk(Chunk(Kind, StringRef(Str, StrLen)));
386      Str += StrLen;
387      break;
388    }
389
390    case CK_Optional: {
391      std::auto_ptr<CodeCompletionString> Optional(new CodeCompletionString());
392      if (Optional->Deserialize(Str, StrEnd))
393        AddOptionalChunk(Optional);
394      break;
395    }
396
397    case CK_LeftParen:
398    case CK_RightParen:
399    case CK_LeftBracket:
400    case CK_RightBracket:
401    case CK_LeftBrace:
402    case CK_RightBrace:
403    case CK_LeftAngle:
404    case CK_RightAngle:
405    case CK_Comma:
406    case CK_Colon:
407    case CK_SemiColon:
408    case CK_Equal:
409    case CK_HorizontalSpace:
410    case CK_VerticalSpace:
411      AddChunk(Chunk(Kind));
412      break;
413    }
414  };
415
416  return true;
417}
418
419void CodeCompletionResult::Destroy() {
420  if (Kind == RK_Pattern) {
421    delete Pattern;
422    Pattern = 0;
423  }
424}
425
426unsigned CodeCompletionResult::getPriorityFromDecl(NamedDecl *ND) {
427  if (!ND)
428    return CCP_Unlikely;
429
430  // Context-based decisions.
431  DeclContext *DC = ND->getDeclContext()->getRedeclContext();
432  if (DC->isFunctionOrMethod() || isa<BlockDecl>(DC)) {
433    // _cmd is relatively rare
434    if (ImplicitParamDecl *ImplicitParam = dyn_cast<ImplicitParamDecl>(ND))
435      if (ImplicitParam->getIdentifier() &&
436          ImplicitParam->getIdentifier()->isStr("_cmd"))
437        return CCP_ObjC_cmd;
438
439    return CCP_LocalDeclaration;
440  }
441  if (DC->isRecord() || isa<ObjCContainerDecl>(DC))
442    return CCP_MemberDeclaration;
443
444  // Content-based decisions.
445  if (isa<EnumConstantDecl>(ND))
446    return CCP_Constant;
447  if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND))
448    return CCP_Type;
449
450  return CCP_Declaration;
451}
452
453//===----------------------------------------------------------------------===//
454// Code completion overload candidate implementation
455//===----------------------------------------------------------------------===//
456FunctionDecl *
457CodeCompleteConsumer::OverloadCandidate::getFunction() const {
458  if (getKind() == CK_Function)
459    return Function;
460  else if (getKind() == CK_FunctionTemplate)
461    return FunctionTemplate->getTemplatedDecl();
462  else
463    return 0;
464}
465
466const FunctionType *
467CodeCompleteConsumer::OverloadCandidate::getFunctionType() const {
468  switch (Kind) {
469  case CK_Function:
470    return Function->getType()->getAs<FunctionType>();
471
472  case CK_FunctionTemplate:
473    return FunctionTemplate->getTemplatedDecl()->getType()
474             ->getAs<FunctionType>();
475
476  case CK_FunctionType:
477    return Type;
478  }
479
480  return 0;
481}
482
483//===----------------------------------------------------------------------===//
484// Code completion consumer implementation
485//===----------------------------------------------------------------------===//
486
487CodeCompleteConsumer::~CodeCompleteConsumer() { }
488
489void
490PrintingCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &SemaRef,
491                                                 CodeCompletionContext Context,
492                                                 CodeCompletionResult *Results,
493                                                         unsigned NumResults) {
494  std::stable_sort(Results, Results + NumResults);
495
496  // Print the results.
497  for (unsigned I = 0; I != NumResults; ++I) {
498    OS << "COMPLETION: ";
499    switch (Results[I].Kind) {
500    case CodeCompletionResult::RK_Declaration:
501      OS << Results[I].Declaration;
502      if (Results[I].Hidden)
503        OS << " (Hidden)";
504      if (CodeCompletionString *CCS
505            = Results[I].CreateCodeCompletionString(SemaRef)) {
506        OS << " : " << CCS->getAsString();
507        delete CCS;
508      }
509
510      OS << '\n';
511      break;
512
513    case CodeCompletionResult::RK_Keyword:
514      OS << Results[I].Keyword << '\n';
515      break;
516
517    case CodeCompletionResult::RK_Macro: {
518      OS << Results[I].Macro->getName();
519      if (CodeCompletionString *CCS
520            = Results[I].CreateCodeCompletionString(SemaRef)) {
521        OS << " : " << CCS->getAsString();
522        delete CCS;
523      }
524      OS << '\n';
525      break;
526    }
527
528    case CodeCompletionResult::RK_Pattern: {
529      OS << "Pattern : "
530         << Results[I].Pattern->getAsString() << '\n';
531      break;
532    }
533    }
534  }
535}
536
537void
538PrintingCodeCompleteConsumer::ProcessOverloadCandidates(Sema &SemaRef,
539                                                        unsigned CurrentArg,
540                                              OverloadCandidate *Candidates,
541                                                     unsigned NumCandidates) {
542  for (unsigned I = 0; I != NumCandidates; ++I) {
543    if (CodeCompletionString *CCS
544          = Candidates[I].CreateSignatureString(CurrentArg, SemaRef)) {
545      OS << "OVERLOAD: " << CCS->getAsString() << "\n";
546      delete CCS;
547    }
548  }
549}
550
551void CodeCompletionResult::computeCursorKindAndAvailability() {
552  switch (Kind) {
553  case RK_Declaration:
554    // Set the availability based on attributes.
555    Availability = CXAvailability_Available;
556    if (Declaration->getAttr<UnavailableAttr>())
557      Availability = CXAvailability_NotAvailable;
558    else if (Declaration->getAttr<DeprecatedAttr>())
559      Availability = CXAvailability_Deprecated;
560
561    if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Declaration))
562      if (Function->isDeleted())
563        Availability = CXAvailability_NotAvailable;
564
565    CursorKind = getCursorKindForDecl(Declaration);
566    if (CursorKind == CXCursor_UnexposedDecl)
567      CursorKind = CXCursor_NotImplemented;
568    break;
569
570  case RK_Macro:
571    Availability = CXAvailability_Available;
572    CursorKind = CXCursor_MacroDefinition;
573    break;
574
575  case RK_Keyword:
576    Availability = CXAvailability_Available;
577    CursorKind = CXCursor_NotImplemented;
578    break;
579
580  case RK_Pattern:
581    // Do nothing: Patterns can come with cursor kinds!
582    break;
583  }
584}
585
586/// \brief Retrieve the name that should be used to order a result.
587///
588/// If the name needs to be constructed as a string, that string will be
589/// saved into Saved and the returned StringRef will refer to it.
590static llvm::StringRef getOrderedName(const CodeCompletionResult &R,
591                                    std::string &Saved) {
592  switch (R.Kind) {
593    case CodeCompletionResult::RK_Keyword:
594      return R.Keyword;
595
596    case CodeCompletionResult::RK_Pattern:
597      return R.Pattern->getTypedText();
598
599    case CodeCompletionResult::RK_Macro:
600      return R.Macro->getName();
601
602    case CodeCompletionResult::RK_Declaration:
603      // Handle declarations below.
604      break;
605  }
606
607  DeclarationName Name = R.Declaration->getDeclName();
608
609  // If the name is a simple identifier (by far the common case), or a
610  // zero-argument selector, just return a reference to that identifier.
611  if (IdentifierInfo *Id = Name.getAsIdentifierInfo())
612    return Id->getName();
613  if (Name.isObjCZeroArgSelector())
614    if (IdentifierInfo *Id
615        = Name.getObjCSelector().getIdentifierInfoForSlot(0))
616      return Id->getName();
617
618  Saved = Name.getAsString();
619  return Saved;
620}
621
622bool clang::operator<(const CodeCompletionResult &X,
623                      const CodeCompletionResult &Y) {
624  std::string XSaved, YSaved;
625  llvm::StringRef XStr = getOrderedName(X, XSaved);
626  llvm::StringRef YStr = getOrderedName(Y, YSaved);
627  int cmp = XStr.compare_lower(YStr);
628  if (cmp)
629    return cmp < 0;
630
631  // If case-insensitive comparison fails, try case-sensitive comparison.
632  cmp = XStr.compare(YStr);
633  if (cmp)
634    return cmp < 0;
635
636  return false;
637}
638
639void
640CIndexCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &SemaRef,
641                                                 CodeCompletionContext Context,
642                                                 CodeCompletionResult *Results,
643                                                       unsigned NumResults) {
644  // Print the results.
645  for (unsigned I = 0; I != NumResults; ++I) {
646    WriteUnsigned(OS, Results[I].CursorKind);
647    WriteUnsigned(OS, Results[I].Priority);
648    WriteUnsigned(OS, Results[I].Availability);
649    CodeCompletionString *CCS = Results[I].CreateCodeCompletionString(SemaRef);
650    assert(CCS && "No code-completion string?");
651    CCS->Serialize(OS);
652    delete CCS;
653  }
654}
655
656void
657CIndexCodeCompleteConsumer::ProcessOverloadCandidates(Sema &SemaRef,
658                                                      unsigned CurrentArg,
659                                                OverloadCandidate *Candidates,
660                                                       unsigned NumCandidates) {
661  for (unsigned I = 0; I != NumCandidates; ++I) {
662    WriteUnsigned(OS, CXCursor_NotImplemented);
663    WriteUnsigned(OS, /*Priority=*/I);
664    WriteUnsigned(OS, /*Availability=*/CXAvailability_Available);
665    CodeCompletionString *CCS
666      = Candidates[I].CreateSignatureString(CurrentArg, SemaRef);
667    assert(CCS && "No code-completion string?");
668    CCS->Serialize(OS);
669    delete CCS;
670  }
671}
672