contrib/llvm/tools/clang/lib/Sema/CodeCompleteConsumer.cpp

   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 }