CodeCompleteConsumer.cpp revision 226890
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/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 return false; 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 break; 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 156CodeCompletionString::Chunk 157CodeCompletionString::Chunk::CreateText(const char *Text) { 158 return Chunk(CK_Text, Text); 159} 160 161CodeCompletionString::Chunk 162CodeCompletionString::Chunk::CreateOptional(CodeCompletionString *Optional) { 163 Chunk Result; 164 Result.Kind = CK_Optional; 165 Result.Optional = Optional; 166 return Result; 167} 168 169CodeCompletionString::Chunk 170CodeCompletionString::Chunk::CreatePlaceholder(const char *Placeholder) { 171 return Chunk(CK_Placeholder, Placeholder); 172} 173 174CodeCompletionString::Chunk 175CodeCompletionString::Chunk::CreateInformative(const char *Informative) { 176 return Chunk(CK_Informative, Informative); 177} 178 179CodeCompletionString::Chunk 180CodeCompletionString::Chunk::CreateResultType(const char *ResultType) { 181 return Chunk(CK_ResultType, ResultType); 182} 183 184CodeCompletionString::Chunk 185CodeCompletionString::Chunk::CreateCurrentParameter( 186 const char *CurrentParameter) { 187 return Chunk(CK_CurrentParameter, CurrentParameter); 188} 189 190CodeCompletionString::CodeCompletionString(const Chunk *Chunks, 191 unsigned NumChunks, 192 unsigned Priority, 193 CXAvailabilityKind Availability, 194 const char **Annotations, 195 unsigned NumAnnotations) 196 : NumChunks(NumChunks), NumAnnotations(NumAnnotations) 197 , Priority(Priority), Availability(Availability) 198{ 199 assert(NumChunks <= 0xffff); 200 assert(NumAnnotations <= 0xffff); 201 202 Chunk *StoredChunks = reinterpret_cast<Chunk *>(this + 1); 203 for (unsigned I = 0; I != NumChunks; ++I) 204 StoredChunks[I] = Chunks[I]; 205 206 const char **StoredAnnotations = reinterpret_cast<const char **>(StoredChunks + NumChunks); 207 for (unsigned I = 0; I != NumAnnotations; ++I) 208 StoredAnnotations[I] = Annotations[I]; 209} 210 211unsigned CodeCompletionString::getAnnotationCount() const { 212 return NumAnnotations; 213} 214 215const char *CodeCompletionString::getAnnotation(unsigned AnnotationNr) const { 216 if (AnnotationNr < NumAnnotations) 217 return reinterpret_cast<const char * const*>(end())[AnnotationNr]; 218 else 219 return 0; 220} 221 222 223std::string CodeCompletionString::getAsString() const { 224 std::string Result; 225 llvm::raw_string_ostream OS(Result); 226 227 for (iterator C = begin(), CEnd = end(); C != CEnd; ++C) { 228 switch (C->Kind) { 229 case CK_Optional: OS << "{#" << C->Optional->getAsString() << "#}"; break; 230 case CK_Placeholder: OS << "<#" << C->Text << "#>"; break; 231 232 case CK_Informative: 233 case CK_ResultType: 234 OS << "[#" << C->Text << "#]"; 235 break; 236 237 case CK_CurrentParameter: OS << "<#" << C->Text << "#>"; break; 238 default: OS << C->Text; break; 239 } 240 } 241 return OS.str(); 242} 243 244const char *CodeCompletionString::getTypedText() const { 245 for (iterator C = begin(), CEnd = end(); C != CEnd; ++C) 246 if (C->Kind == CK_TypedText) 247 return C->Text; 248 249 return 0; 250} 251 252const char *CodeCompletionAllocator::CopyString(StringRef String) { 253 char *Mem = (char *)Allocate(String.size() + 1, 1); 254 std::copy(String.begin(), String.end(), Mem); 255 Mem[String.size()] = 0; 256 return Mem; 257} 258 259const char *CodeCompletionAllocator::CopyString(Twine String) { 260 // FIXME: It would be more efficient to teach Twine to tell us its size and 261 // then add a routine there to fill in an allocated char* with the contents 262 // of the string. 263 llvm::SmallString<128> Data; 264 return CopyString(String.toStringRef(Data)); 265} 266 267CodeCompletionString *CodeCompletionBuilder::TakeString() { 268 void *Mem = Allocator.Allocate( 269 sizeof(CodeCompletionString) + sizeof(Chunk) * Chunks.size() 270 + sizeof(const char *) * Annotations.size(), 271 llvm::alignOf<CodeCompletionString>()); 272 CodeCompletionString *Result 273 = new (Mem) CodeCompletionString(Chunks.data(), Chunks.size(), 274 Priority, Availability, 275 Annotations.data(), Annotations.size()); 276 Chunks.clear(); 277 return Result; 278} 279 280unsigned CodeCompletionResult::getPriorityFromDecl(NamedDecl *ND) { 281 if (!ND) 282 return CCP_Unlikely; 283 284 // Context-based decisions. 285 DeclContext *DC = ND->getDeclContext()->getRedeclContext(); 286 if (DC->isFunctionOrMethod() || isa<BlockDecl>(DC)) { 287 // _cmd is relatively rare 288 if (ImplicitParamDecl *ImplicitParam = dyn_cast<ImplicitParamDecl>(ND)) 289 if (ImplicitParam->getIdentifier() && 290 ImplicitParam->getIdentifier()->isStr("_cmd")) 291 return CCP_ObjC_cmd; 292 293 return CCP_LocalDeclaration; 294 } 295 if (DC->isRecord() || isa<ObjCContainerDecl>(DC)) 296 return CCP_MemberDeclaration; 297 298 // Content-based decisions. 299 if (isa<EnumConstantDecl>(ND)) 300 return CCP_Constant; 301 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) 302 return CCP_Type; 303 304 return CCP_Declaration; 305} 306 307//===----------------------------------------------------------------------===// 308// Code completion overload candidate implementation 309//===----------------------------------------------------------------------===// 310FunctionDecl * 311CodeCompleteConsumer::OverloadCandidate::getFunction() const { 312 if (getKind() == CK_Function) 313 return Function; 314 else if (getKind() == CK_FunctionTemplate) 315 return FunctionTemplate->getTemplatedDecl(); 316 else 317 return 0; 318} 319 320const FunctionType * 321CodeCompleteConsumer::OverloadCandidate::getFunctionType() const { 322 switch (Kind) { 323 case CK_Function: 324 return Function->getType()->getAs<FunctionType>(); 325 326 case CK_FunctionTemplate: 327 return FunctionTemplate->getTemplatedDecl()->getType() 328 ->getAs<FunctionType>(); 329 330 case CK_FunctionType: 331 return Type; 332 } 333 334 return 0; 335} 336 337//===----------------------------------------------------------------------===// 338// Code completion consumer implementation 339//===----------------------------------------------------------------------===// 340 341CodeCompleteConsumer::~CodeCompleteConsumer() { } 342 343void 344PrintingCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &SemaRef, 345 CodeCompletionContext Context, 346 CodeCompletionResult *Results, 347 unsigned NumResults) { 348 std::stable_sort(Results, Results + NumResults); 349 350 // Print the results. 351 for (unsigned I = 0; I != NumResults; ++I) { 352 OS << "COMPLETION: "; 353 switch (Results[I].Kind) { 354 case CodeCompletionResult::RK_Declaration: 355 OS << *Results[I].Declaration; 356 if (Results[I].Hidden) 357 OS << " (Hidden)"; 358 if (CodeCompletionString *CCS 359 = Results[I].CreateCodeCompletionString(SemaRef, Allocator)) { 360 OS << " : " << CCS->getAsString(); 361 } 362 363 OS << '\n'; 364 break; 365 366 case CodeCompletionResult::RK_Keyword: 367 OS << Results[I].Keyword << '\n'; 368 break; 369 370 case CodeCompletionResult::RK_Macro: { 371 OS << Results[I].Macro->getName(); 372 if (CodeCompletionString *CCS 373 = Results[I].CreateCodeCompletionString(SemaRef, Allocator)) { 374 OS << " : " << CCS->getAsString(); 375 } 376 OS << '\n'; 377 break; 378 } 379 380 case CodeCompletionResult::RK_Pattern: { 381 OS << "Pattern : " 382 << Results[I].Pattern->getAsString() << '\n'; 383 break; 384 } 385 } 386 } 387} 388 389void 390PrintingCodeCompleteConsumer::ProcessOverloadCandidates(Sema &SemaRef, 391 unsigned CurrentArg, 392 OverloadCandidate *Candidates, 393 unsigned NumCandidates) { 394 for (unsigned I = 0; I != NumCandidates; ++I) { 395 if (CodeCompletionString *CCS 396 = Candidates[I].CreateSignatureString(CurrentArg, SemaRef, 397 Allocator)) { 398 OS << "OVERLOAD: " << CCS->getAsString() << "\n"; 399 } 400 } 401} 402 403void CodeCompletionResult::computeCursorKindAndAvailability(bool Accessible) { 404 switch (Kind) { 405 case RK_Declaration: 406 // Set the availability based on attributes. 407 switch (Declaration->getAvailability()) { 408 case AR_Available: 409 case AR_NotYetIntroduced: 410 Availability = CXAvailability_Available; 411 break; 412 413 case AR_Deprecated: 414 Availability = CXAvailability_Deprecated; 415 break; 416 417 case AR_Unavailable: 418 Availability = CXAvailability_NotAvailable; 419 break; 420 } 421 422 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Declaration)) 423 if (Function->isDeleted()) 424 Availability = CXAvailability_NotAvailable; 425 426 CursorKind = getCursorKindForDecl(Declaration); 427 if (CursorKind == CXCursor_UnexposedDecl) 428 CursorKind = CXCursor_NotImplemented; 429 break; 430 431 case RK_Macro: 432 Availability = CXAvailability_Available; 433 CursorKind = CXCursor_MacroDefinition; 434 break; 435 436 case RK_Keyword: 437 Availability = CXAvailability_Available; 438 CursorKind = CXCursor_NotImplemented; 439 break; 440 441 case RK_Pattern: 442 // Do nothing: Patterns can come with cursor kinds! 443 break; 444 } 445 446 if (!Accessible) 447 Availability = CXAvailability_NotAccessible; 448} 449 450/// \brief Retrieve the name that should be used to order a result. 451/// 452/// If the name needs to be constructed as a string, that string will be 453/// saved into Saved and the returned StringRef will refer to it. 454static StringRef getOrderedName(const CodeCompletionResult &R, 455 std::string &Saved) { 456 switch (R.Kind) { 457 case CodeCompletionResult::RK_Keyword: 458 return R.Keyword; 459 460 case CodeCompletionResult::RK_Pattern: 461 return R.Pattern->getTypedText(); 462 463 case CodeCompletionResult::RK_Macro: 464 return R.Macro->getName(); 465 466 case CodeCompletionResult::RK_Declaration: 467 // Handle declarations below. 468 break; 469 } 470 471 DeclarationName Name = R.Declaration->getDeclName(); 472 473 // If the name is a simple identifier (by far the common case), or a 474 // zero-argument selector, just return a reference to that identifier. 475 if (IdentifierInfo *Id = Name.getAsIdentifierInfo()) 476 return Id->getName(); 477 if (Name.isObjCZeroArgSelector()) 478 if (IdentifierInfo *Id 479 = Name.getObjCSelector().getIdentifierInfoForSlot(0)) 480 return Id->getName(); 481 482 Saved = Name.getAsString(); 483 return Saved; 484} 485 486bool clang::operator<(const CodeCompletionResult &X, 487 const CodeCompletionResult &Y) { 488 std::string XSaved, YSaved; 489 StringRef XStr = getOrderedName(X, XSaved); 490 StringRef YStr = getOrderedName(Y, YSaved); 491 int cmp = XStr.compare_lower(YStr); 492 if (cmp) 493 return cmp < 0; 494 495 // If case-insensitive comparison fails, try case-sensitive comparison. 496 cmp = XStr.compare(YStr); 497 if (cmp) 498 return cmp < 0; 499 500 return false; 501} 502