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