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