1 //===---------------- SemaCodeComplete.cpp - Code Completion ----*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the code-completion semantic actions.
12 //===----------------------------------------------------------------------===//
13 #include "clang/Sema/SemaInternal.h"
14 #include "clang/AST/DeclObjC.h"
15 #include "clang/AST/ExprCXX.h"
16 #include "clang/AST/ExprObjC.h"
17 #include "clang/Basic/CharInfo.h"
18 #include "clang/Lex/HeaderSearch.h"
19 #include "clang/Lex/MacroInfo.h"
20 #include "clang/Lex/Preprocessor.h"
21 #include "clang/Sema/CodeCompleteConsumer.h"
22 #include "clang/Sema/ExternalSemaSource.h"
23 #include "clang/Sema/Lookup.h"
24 #include "clang/Sema/Overload.h"
25 #include "clang/Sema/Scope.h"
26 #include "clang/Sema/ScopeInfo.h"
27 #include "llvm/ADT/DenseSet.h"
28 #include "llvm/ADT/SmallBitVector.h"
29 #include "llvm/ADT/SmallPtrSet.h"
30 #include "llvm/ADT/SmallString.h"
31 #include "llvm/ADT/StringExtras.h"
32 #include "llvm/ADT/StringSwitch.h"
33 #include "llvm/ADT/Twine.h"
38 using namespace clang;
42 /// \brief A container of code-completion results.
45 /// \brief The type of a name-lookup filter, which can be provided to the
46 /// name-lookup routines to specify which declarations should be included in
47 /// the result set (when it returns true) and which declarations should be
48 /// filtered out (returns false).
49 typedef bool (ResultBuilder::*LookupFilter)(const NamedDecl *) const;
51 typedef CodeCompletionResult Result;
54 /// \brief The actual results we have found.
55 std::vector<Result> Results;
57 /// \brief A record of all of the declarations we have found and placed
58 /// into the result set, used to ensure that no declaration ever gets into
59 /// the result set twice.
60 llvm::SmallPtrSet<const Decl*, 16> AllDeclsFound;
62 typedef std::pair<const NamedDecl *, unsigned> DeclIndexPair;
64 /// \brief An entry in the shadow map, which is optimized to store
65 /// a single (declaration, index) mapping (the common case) but
66 /// can also store a list of (declaration, index) mappings.
67 class ShadowMapEntry {
68 typedef SmallVector<DeclIndexPair, 4> DeclIndexPairVector;
70 /// \brief Contains either the solitary NamedDecl * or a vector
71 /// of (declaration, index) pairs.
72 llvm::PointerUnion<const NamedDecl *, DeclIndexPairVector*> DeclOrVector;
74 /// \brief When the entry contains a single declaration, this is
75 /// the index associated with that entry.
76 unsigned SingleDeclIndex;
79 ShadowMapEntry() : DeclOrVector(), SingleDeclIndex(0) { }
81 void Add(const NamedDecl *ND, unsigned Index) {
82 if (DeclOrVector.isNull()) {
83 // 0 - > 1 elements: just set the single element information.
85 SingleDeclIndex = Index;
89 if (const NamedDecl *PrevND =
90 DeclOrVector.dyn_cast<const NamedDecl *>()) {
91 // 1 -> 2 elements: create the vector of results and push in the
92 // existing declaration.
93 DeclIndexPairVector *Vec = new DeclIndexPairVector;
94 Vec->push_back(DeclIndexPair(PrevND, SingleDeclIndex));
98 // Add the new element to the end of the vector.
99 DeclOrVector.get<DeclIndexPairVector*>()->push_back(
100 DeclIndexPair(ND, Index));
104 if (DeclIndexPairVector *Vec
105 = DeclOrVector.dyn_cast<DeclIndexPairVector *>()) {
107 DeclOrVector = ((NamedDecl *)0);
113 iterator begin() const;
114 iterator end() const;
117 /// \brief A mapping from declaration names to the declarations that have
118 /// this name within a particular scope and their index within the list of
120 typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;
122 /// \brief The semantic analysis object for which results are being
126 /// \brief The allocator used to allocate new code-completion strings.
127 CodeCompletionAllocator &Allocator;
129 CodeCompletionTUInfo &CCTUInfo;
131 /// \brief If non-NULL, a filter function used to remove any code-completion
132 /// results that are not desirable.
135 /// \brief Whether we should allow declarations as
136 /// nested-name-specifiers that would otherwise be filtered out.
137 bool AllowNestedNameSpecifiers;
139 /// \brief If set, the type that we would prefer our resulting value
140 /// declarations to have.
142 /// Closely matching the preferred type gives a boost to a result's
144 CanQualType PreferredType;
146 /// \brief A list of shadow maps, which is used to model name hiding at
147 /// different levels of, e.g., the inheritance hierarchy.
148 std::list<ShadowMap> ShadowMaps;
150 /// \brief If we're potentially referring to a C++ member function, the set
151 /// of qualifiers applied to the object type.
152 Qualifiers ObjectTypeQualifiers;
154 /// \brief Whether the \p ObjectTypeQualifiers field is active.
155 bool HasObjectTypeQualifiers;
157 /// \brief The selector that we prefer.
158 Selector PreferredSelector;
160 /// \brief The completion context in which we are gathering results.
161 CodeCompletionContext CompletionContext;
163 /// \brief If we are in an instance method definition, the \@implementation
165 ObjCImplementationDecl *ObjCImplementation;
167 void AdjustResultPriorityForDecl(Result &R);
169 void MaybeAddConstructorResults(Result R);
172 explicit ResultBuilder(Sema &SemaRef, CodeCompletionAllocator &Allocator,
173 CodeCompletionTUInfo &CCTUInfo,
174 const CodeCompletionContext &CompletionContext,
175 LookupFilter Filter = 0)
176 : SemaRef(SemaRef), Allocator(Allocator), CCTUInfo(CCTUInfo),
178 AllowNestedNameSpecifiers(false), HasObjectTypeQualifiers(false),
179 CompletionContext(CompletionContext),
180 ObjCImplementation(0)
182 // If this is an Objective-C instance method definition, dig out the
183 // corresponding implementation.
184 switch (CompletionContext.getKind()) {
185 case CodeCompletionContext::CCC_Expression:
186 case CodeCompletionContext::CCC_ObjCMessageReceiver:
187 case CodeCompletionContext::CCC_ParenthesizedExpression:
188 case CodeCompletionContext::CCC_Statement:
189 case CodeCompletionContext::CCC_Recovery:
190 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl())
191 if (Method->isInstanceMethod())
192 if (ObjCInterfaceDecl *Interface = Method->getClassInterface())
193 ObjCImplementation = Interface->getImplementation();
201 /// \brief Determine the priority for a reference to the given declaration.
202 unsigned getBasePriority(const NamedDecl *D);
204 /// \brief Whether we should include code patterns in the completion
206 bool includeCodePatterns() const {
207 return SemaRef.CodeCompleter &&
208 SemaRef.CodeCompleter->includeCodePatterns();
211 /// \brief Set the filter used for code-completion results.
212 void setFilter(LookupFilter Filter) {
213 this->Filter = Filter;
216 Result *data() { return Results.empty()? 0 : &Results.front(); }
217 unsigned size() const { return Results.size(); }
218 bool empty() const { return Results.empty(); }
220 /// \brief Specify the preferred type.
221 void setPreferredType(QualType T) {
222 PreferredType = SemaRef.Context.getCanonicalType(T);
225 /// \brief Set the cv-qualifiers on the object type, for us in filtering
226 /// calls to member functions.
228 /// When there are qualifiers in this set, they will be used to filter
229 /// out member functions that aren't available (because there will be a
230 /// cv-qualifier mismatch) or prefer functions with an exact qualifier
232 void setObjectTypeQualifiers(Qualifiers Quals) {
233 ObjectTypeQualifiers = Quals;
234 HasObjectTypeQualifiers = true;
237 /// \brief Set the preferred selector.
239 /// When an Objective-C method declaration result is added, and that
240 /// method's selector matches this preferred selector, we give that method
241 /// a slight priority boost.
242 void setPreferredSelector(Selector Sel) {
243 PreferredSelector = Sel;
246 /// \brief Retrieve the code-completion context for which results are
248 const CodeCompletionContext &getCompletionContext() const {
249 return CompletionContext;
252 /// \brief Specify whether nested-name-specifiers are allowed.
253 void allowNestedNameSpecifiers(bool Allow = true) {
254 AllowNestedNameSpecifiers = Allow;
257 /// \brief Return the semantic analysis object for which we are collecting
258 /// code completion results.
259 Sema &getSema() const { return SemaRef; }
261 /// \brief Retrieve the allocator used to allocate code completion strings.
262 CodeCompletionAllocator &getAllocator() const { return Allocator; }
264 CodeCompletionTUInfo &getCodeCompletionTUInfo() const { return CCTUInfo; }
266 /// \brief Determine whether the given declaration is at all interesting
267 /// as a code-completion result.
269 /// \param ND the declaration that we are inspecting.
271 /// \param AsNestedNameSpecifier will be set true if this declaration is
272 /// only interesting when it is a nested-name-specifier.
273 bool isInterestingDecl(const NamedDecl *ND,
274 bool &AsNestedNameSpecifier) const;
276 /// \brief Check whether the result is hidden by the Hiding declaration.
278 /// \returns true if the result is hidden and cannot be found, false if
279 /// the hidden result could still be found. When false, \p R may be
280 /// modified to describe how the result can be found (e.g., via extra
282 bool CheckHiddenResult(Result &R, DeclContext *CurContext,
283 const NamedDecl *Hiding);
285 /// \brief Add a new result to this result set (if it isn't already in one
286 /// of the shadow maps), or replace an existing result (for, e.g., a
289 /// \param R the result to add (if it is unique).
291 /// \param CurContext the context in which this result will be named.
292 void MaybeAddResult(Result R, DeclContext *CurContext = 0);
294 /// \brief Add a new result to this result set, where we already know
295 /// the hiding declation (if any).
297 /// \param R the result to add (if it is unique).
299 /// \param CurContext the context in which this result will be named.
301 /// \param Hiding the declaration that hides the result.
303 /// \param InBaseClass whether the result was found in a base
304 /// class of the searched context.
305 void AddResult(Result R, DeclContext *CurContext, NamedDecl *Hiding,
308 /// \brief Add a new non-declaration result to this result set.
309 void AddResult(Result R);
311 /// \brief Enter into a new scope.
312 void EnterNewScope();
314 /// \brief Exit from the current scope.
317 /// \brief Ignore this declaration, if it is seen again.
318 void Ignore(const Decl *D) { AllDeclsFound.insert(D->getCanonicalDecl()); }
320 /// \name Name lookup predicates
322 /// These predicates can be passed to the name lookup functions to filter the
323 /// results of name lookup. All of the predicates have the same type, so that
326 bool IsOrdinaryName(const NamedDecl *ND) const;
327 bool IsOrdinaryNonTypeName(const NamedDecl *ND) const;
328 bool IsIntegralConstantValue(const NamedDecl *ND) const;
329 bool IsOrdinaryNonValueName(const NamedDecl *ND) const;
330 bool IsNestedNameSpecifier(const NamedDecl *ND) const;
331 bool IsEnum(const NamedDecl *ND) const;
332 bool IsClassOrStruct(const NamedDecl *ND) const;
333 bool IsUnion(const NamedDecl *ND) const;
334 bool IsNamespace(const NamedDecl *ND) const;
335 bool IsNamespaceOrAlias(const NamedDecl *ND) const;
336 bool IsType(const NamedDecl *ND) const;
337 bool IsMember(const NamedDecl *ND) const;
338 bool IsObjCIvar(const NamedDecl *ND) const;
339 bool IsObjCMessageReceiver(const NamedDecl *ND) const;
340 bool IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const;
341 bool IsObjCCollection(const NamedDecl *ND) const;
342 bool IsImpossibleToSatisfy(const NamedDecl *ND) const;
347 class ResultBuilder::ShadowMapEntry::iterator {
348 llvm::PointerUnion<const NamedDecl *, const DeclIndexPair *> DeclOrIterator;
349 unsigned SingleDeclIndex;
352 typedef DeclIndexPair value_type;
353 typedef value_type reference;
354 typedef std::ptrdiff_t difference_type;
355 typedef std::input_iterator_tag iterator_category;
361 pointer(const DeclIndexPair &Value) : Value(Value) { }
363 const DeclIndexPair *operator->() const {
368 iterator() : DeclOrIterator((NamedDecl *)0), SingleDeclIndex(0) { }
370 iterator(const NamedDecl *SingleDecl, unsigned Index)
371 : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) { }
373 iterator(const DeclIndexPair *Iterator)
374 : DeclOrIterator(Iterator), SingleDeclIndex(0) { }
376 iterator &operator++() {
377 if (DeclOrIterator.is<const NamedDecl *>()) {
378 DeclOrIterator = (NamedDecl *)0;
383 const DeclIndexPair *I = DeclOrIterator.get<const DeclIndexPair*>();
389 /*iterator operator++(int) {
395 reference operator*() const {
396 if (const NamedDecl *ND = DeclOrIterator.dyn_cast<const NamedDecl *>())
397 return reference(ND, SingleDeclIndex);
399 return *DeclOrIterator.get<const DeclIndexPair*>();
402 pointer operator->() const {
403 return pointer(**this);
406 friend bool operator==(const iterator &X, const iterator &Y) {
407 return X.DeclOrIterator.getOpaqueValue()
408 == Y.DeclOrIterator.getOpaqueValue() &&
409 X.SingleDeclIndex == Y.SingleDeclIndex;
412 friend bool operator!=(const iterator &X, const iterator &Y) {
417 ResultBuilder::ShadowMapEntry::iterator
418 ResultBuilder::ShadowMapEntry::begin() const {
419 if (DeclOrVector.isNull())
422 if (const NamedDecl *ND = DeclOrVector.dyn_cast<const NamedDecl *>())
423 return iterator(ND, SingleDeclIndex);
425 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->begin());
428 ResultBuilder::ShadowMapEntry::iterator
429 ResultBuilder::ShadowMapEntry::end() const {
430 if (DeclOrVector.is<const NamedDecl *>() || DeclOrVector.isNull())
433 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end());
436 /// \brief Compute the qualification required to get from the current context
437 /// (\p CurContext) to the target context (\p TargetContext).
439 /// \param Context the AST context in which the qualification will be used.
441 /// \param CurContext the context where an entity is being named, which is
442 /// typically based on the current scope.
444 /// \param TargetContext the context in which the named entity actually
447 /// \returns a nested name specifier that refers into the target context, or
448 /// NULL if no qualification is needed.
449 static NestedNameSpecifier *
450 getRequiredQualification(ASTContext &Context,
451 const DeclContext *CurContext,
452 const DeclContext *TargetContext) {
453 SmallVector<const DeclContext *, 4> TargetParents;
455 for (const DeclContext *CommonAncestor = TargetContext;
456 CommonAncestor && !CommonAncestor->Encloses(CurContext);
457 CommonAncestor = CommonAncestor->getLookupParent()) {
458 if (CommonAncestor->isTransparentContext() ||
459 CommonAncestor->isFunctionOrMethod())
462 TargetParents.push_back(CommonAncestor);
465 NestedNameSpecifier *Result = 0;
466 while (!TargetParents.empty()) {
467 const DeclContext *Parent = TargetParents.back();
468 TargetParents.pop_back();
470 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Parent)) {
471 if (!Namespace->getIdentifier())
474 Result = NestedNameSpecifier::Create(Context, Result, Namespace);
476 else if (const TagDecl *TD = dyn_cast<TagDecl>(Parent))
477 Result = NestedNameSpecifier::Create(Context, Result,
479 Context.getTypeDeclType(TD).getTypePtr());
484 bool ResultBuilder::isInterestingDecl(const NamedDecl *ND,
485 bool &AsNestedNameSpecifier) const {
486 AsNestedNameSpecifier = false;
488 ND = ND->getUnderlyingDecl();
489 unsigned IDNS = ND->getIdentifierNamespace();
491 // Skip unnamed entities.
492 if (!ND->getDeclName())
495 // Friend declarations and declarations introduced due to friends are never
497 if (IDNS & (Decl::IDNS_OrdinaryFriend | Decl::IDNS_TagFriend))
500 // Class template (partial) specializations are never added as results.
501 if (isa<ClassTemplateSpecializationDecl>(ND) ||
502 isa<ClassTemplatePartialSpecializationDecl>(ND))
505 // Using declarations themselves are never added as results.
506 if (isa<UsingDecl>(ND))
509 // Some declarations have reserved names that we don't want to ever show.
510 if (const IdentifierInfo *Id = ND->getIdentifier()) {
511 // __va_list_tag is a freak of nature. Find it and skip it.
512 if (Id->isStr("__va_list_tag") || Id->isStr("__builtin_va_list"))
515 // Filter out names reserved for the implementation (C99 7.1.3,
516 // C++ [lib.global.names]) if they come from a system header.
518 // FIXME: Add predicate for this.
519 if (Id->getLength() >= 2) {
520 const char *Name = Id->getNameStart();
521 if (Name[0] == '_' &&
522 (Name[1] == '_' || (Name[1] >= 'A' && Name[1] <= 'Z')) &&
523 (ND->getLocation().isInvalid() ||
524 SemaRef.SourceMgr.isInSystemHeader(
525 SemaRef.SourceMgr.getSpellingLoc(ND->getLocation()))))
530 if (Filter == &ResultBuilder::IsNestedNameSpecifier ||
531 ((isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND)) &&
532 Filter != &ResultBuilder::IsNamespace &&
533 Filter != &ResultBuilder::IsNamespaceOrAlias &&
535 AsNestedNameSpecifier = true;
537 // Filter out any unwanted results.
538 if (Filter && !(this->*Filter)(ND)) {
539 // Check whether it is interesting as a nested-name-specifier.
540 if (AllowNestedNameSpecifiers && SemaRef.getLangOpts().CPlusPlus &&
541 IsNestedNameSpecifier(ND) &&
542 (Filter != &ResultBuilder::IsMember ||
543 (isa<CXXRecordDecl>(ND) &&
544 cast<CXXRecordDecl>(ND)->isInjectedClassName()))) {
545 AsNestedNameSpecifier = true;
551 // ... then it must be interesting!
555 bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext,
556 const NamedDecl *Hiding) {
557 // In C, there is no way to refer to a hidden name.
558 // FIXME: This isn't true; we can find a tag name hidden by an ordinary
559 // name if we introduce the tag type.
560 if (!SemaRef.getLangOpts().CPlusPlus)
563 const DeclContext *HiddenCtx =
564 R.Declaration->getDeclContext()->getRedeclContext();
566 // There is no way to qualify a name declared in a function or method.
567 if (HiddenCtx->isFunctionOrMethod())
570 if (HiddenCtx == Hiding->getDeclContext()->getRedeclContext())
573 // We can refer to the result with the appropriate qualification. Do it.
575 R.QualifierIsInformative = false;
578 R.Qualifier = getRequiredQualification(SemaRef.Context,
580 R.Declaration->getDeclContext());
584 /// \brief A simplified classification of types used to determine whether two
585 /// types are "similar enough" when adjusting priorities.
586 SimplifiedTypeClass clang::getSimplifiedTypeClass(CanQualType T) {
587 switch (T->getTypeClass()) {
589 switch (cast<BuiltinType>(T)->getKind()) {
590 case BuiltinType::Void:
593 case BuiltinType::NullPtr:
596 case BuiltinType::Overload:
597 case BuiltinType::Dependent:
600 case BuiltinType::ObjCId:
601 case BuiltinType::ObjCClass:
602 case BuiltinType::ObjCSel:
603 return STC_ObjectiveC;
606 return STC_Arithmetic;
610 return STC_Arithmetic;
615 case Type::BlockPointer:
618 case Type::LValueReference:
619 case Type::RValueReference:
620 return getSimplifiedTypeClass(T->getAs<ReferenceType>()->getPointeeType());
622 case Type::ConstantArray:
623 case Type::IncompleteArray:
624 case Type::VariableArray:
625 case Type::DependentSizedArray:
628 case Type::DependentSizedExtVector:
630 case Type::ExtVector:
631 return STC_Arithmetic;
633 case Type::FunctionProto:
634 case Type::FunctionNoProto:
641 return STC_Arithmetic;
643 case Type::ObjCObject:
644 case Type::ObjCInterface:
645 case Type::ObjCObjectPointer:
646 return STC_ObjectiveC;
653 /// \brief Get the type that a given expression will have if this declaration
654 /// is used as an expression in its "typical" code-completion form.
655 QualType clang::getDeclUsageType(ASTContext &C, const NamedDecl *ND) {
656 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
658 if (const TypeDecl *Type = dyn_cast<TypeDecl>(ND))
659 return C.getTypeDeclType(Type);
660 if (const ObjCInterfaceDecl *Iface = dyn_cast<ObjCInterfaceDecl>(ND))
661 return C.getObjCInterfaceType(Iface);
664 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(ND))
665 T = Function->getCallResultType();
666 else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND))
667 T = Method->getSendResultType();
668 else if (const FunctionTemplateDecl *FunTmpl =
669 dyn_cast<FunctionTemplateDecl>(ND))
670 T = FunTmpl->getTemplatedDecl()->getCallResultType();
671 else if (const EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND))
672 T = C.getTypeDeclType(cast<EnumDecl>(Enumerator->getDeclContext()));
673 else if (const ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND))
674 T = Property->getType();
675 else if (const ValueDecl *Value = dyn_cast<ValueDecl>(ND))
676 T = Value->getType();
680 // Dig through references, function pointers, and block pointers to
681 // get down to the likely type of an expression when the entity is
684 if (const ReferenceType *Ref = T->getAs<ReferenceType>()) {
685 T = Ref->getPointeeType();
689 if (const PointerType *Pointer = T->getAs<PointerType>()) {
690 if (Pointer->getPointeeType()->isFunctionType()) {
691 T = Pointer->getPointeeType();
698 if (const BlockPointerType *Block = T->getAs<BlockPointerType>()) {
699 T = Block->getPointeeType();
703 if (const FunctionType *Function = T->getAs<FunctionType>()) {
704 T = Function->getResultType();
714 unsigned ResultBuilder::getBasePriority(const NamedDecl *ND) {
718 // Context-based decisions.
719 const DeclContext *DC = ND->getDeclContext()->getRedeclContext();
720 if (DC->isFunctionOrMethod() || isa<BlockDecl>(DC)) {
721 // _cmd is relatively rare
722 if (const ImplicitParamDecl *ImplicitParam =
723 dyn_cast<ImplicitParamDecl>(ND))
724 if (ImplicitParam->getIdentifier() &&
725 ImplicitParam->getIdentifier()->isStr("_cmd"))
728 return CCP_LocalDeclaration;
730 if (DC->isRecord() || isa<ObjCContainerDecl>(DC))
731 return CCP_MemberDeclaration;
733 // Content-based decisions.
734 if (isa<EnumConstantDecl>(ND))
737 // Use CCP_Type for type declarations unless we're in a statement, Objective-C
738 // message receiver, or parenthesized expression context. There, it's as
739 // likely that the user will want to write a type as other declarations.
740 if ((isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) &&
741 !(CompletionContext.getKind() == CodeCompletionContext::CCC_Statement ||
742 CompletionContext.getKind()
743 == CodeCompletionContext::CCC_ObjCMessageReceiver ||
744 CompletionContext.getKind()
745 == CodeCompletionContext::CCC_ParenthesizedExpression))
748 return CCP_Declaration;
751 void ResultBuilder::AdjustResultPriorityForDecl(Result &R) {
752 // If this is an Objective-C method declaration whose selector matches our
753 // preferred selector, give it a priority boost.
754 if (!PreferredSelector.isNull())
755 if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(R.Declaration))
756 if (PreferredSelector == Method->getSelector())
757 R.Priority += CCD_SelectorMatch;
759 // If we have a preferred type, adjust the priority for results with exactly-
760 // matching or nearly-matching types.
761 if (!PreferredType.isNull()) {
762 QualType T = getDeclUsageType(SemaRef.Context, R.Declaration);
764 CanQualType TC = SemaRef.Context.getCanonicalType(T);
765 // Check for exactly-matching types (modulo qualifiers).
766 if (SemaRef.Context.hasSameUnqualifiedType(PreferredType, TC))
767 R.Priority /= CCF_ExactTypeMatch;
768 // Check for nearly-matching types, based on classification of each.
769 else if ((getSimplifiedTypeClass(PreferredType)
770 == getSimplifiedTypeClass(TC)) &&
771 !(PreferredType->isEnumeralType() && TC->isEnumeralType()))
772 R.Priority /= CCF_SimilarTypeMatch;
777 void ResultBuilder::MaybeAddConstructorResults(Result R) {
778 if (!SemaRef.getLangOpts().CPlusPlus || !R.Declaration ||
779 !CompletionContext.wantConstructorResults())
782 ASTContext &Context = SemaRef.Context;
783 const NamedDecl *D = R.Declaration;
784 const CXXRecordDecl *Record = 0;
785 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D))
786 Record = ClassTemplate->getTemplatedDecl();
787 else if ((Record = dyn_cast<CXXRecordDecl>(D))) {
788 // Skip specializations and partial specializations.
789 if (isa<ClassTemplateSpecializationDecl>(Record))
792 // There are no constructors here.
796 Record = Record->getDefinition();
801 QualType RecordTy = Context.getTypeDeclType(Record);
802 DeclarationName ConstructorName
803 = Context.DeclarationNames.getCXXConstructorName(
804 Context.getCanonicalType(RecordTy));
805 DeclContext::lookup_const_result Ctors = Record->lookup(ConstructorName);
806 for (DeclContext::lookup_const_iterator I = Ctors.begin(),
810 R.CursorKind = getCursorKindForDecl(R.Declaration);
811 Results.push_back(R);
815 void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) {
816 assert(!ShadowMaps.empty() && "Must enter into a results scope");
818 if (R.Kind != Result::RK_Declaration) {
819 // For non-declaration results, just add the result.
820 Results.push_back(R);
824 // Look through using declarations.
825 if (const UsingShadowDecl *Using =
826 dyn_cast<UsingShadowDecl>(R.Declaration)) {
827 MaybeAddResult(Result(Using->getTargetDecl(),
828 getBasePriority(Using->getTargetDecl()),
834 const Decl *CanonDecl = R.Declaration->getCanonicalDecl();
835 unsigned IDNS = CanonDecl->getIdentifierNamespace();
837 bool AsNestedNameSpecifier = false;
838 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
841 // C++ constructors are never found by name lookup.
842 if (isa<CXXConstructorDecl>(R.Declaration))
845 ShadowMap &SMap = ShadowMaps.back();
846 ShadowMapEntry::iterator I, IEnd;
847 ShadowMap::iterator NamePos = SMap.find(R.Declaration->getDeclName());
848 if (NamePos != SMap.end()) {
849 I = NamePos->second.begin();
850 IEnd = NamePos->second.end();
853 for (; I != IEnd; ++I) {
854 const NamedDecl *ND = I->first;
855 unsigned Index = I->second;
856 if (ND->getCanonicalDecl() == CanonDecl) {
857 // This is a redeclaration. Always pick the newer declaration.
858 Results[Index].Declaration = R.Declaration;
865 // This is a new declaration in this scope. However, check whether this
866 // declaration name is hidden by a similarly-named declaration in an outer
868 std::list<ShadowMap>::iterator SM, SMEnd = ShadowMaps.end();
870 for (SM = ShadowMaps.begin(); SM != SMEnd; ++SM) {
871 ShadowMapEntry::iterator I, IEnd;
872 ShadowMap::iterator NamePos = SM->find(R.Declaration->getDeclName());
873 if (NamePos != SM->end()) {
874 I = NamePos->second.begin();
875 IEnd = NamePos->second.end();
877 for (; I != IEnd; ++I) {
878 // A tag declaration does not hide a non-tag declaration.
879 if (I->first->hasTagIdentifierNamespace() &&
880 (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary |
881 Decl::IDNS_ObjCProtocol)))
884 // Protocols are in distinct namespaces from everything else.
885 if (((I->first->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol)
886 || (IDNS & Decl::IDNS_ObjCProtocol)) &&
887 I->first->getIdentifierNamespace() != IDNS)
890 // The newly-added result is hidden by an entry in the shadow map.
891 if (CheckHiddenResult(R, CurContext, I->first))
898 // Make sure that any given declaration only shows up in the result set once.
899 if (!AllDeclsFound.insert(CanonDecl))
902 // If the filter is for nested-name-specifiers, then this result starts a
903 // nested-name-specifier.
904 if (AsNestedNameSpecifier) {
905 R.StartsNestedNameSpecifier = true;
906 R.Priority = CCP_NestedNameSpecifier;
908 AdjustResultPriorityForDecl(R);
910 // If this result is supposed to have an informative qualifier, add one.
911 if (R.QualifierIsInformative && !R.Qualifier &&
912 !R.StartsNestedNameSpecifier) {
913 const DeclContext *Ctx = R.Declaration->getDeclContext();
914 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
915 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, Namespace);
916 else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
917 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, false,
918 SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
920 R.QualifierIsInformative = false;
923 // Insert this result into the set of results and into the current shadow
925 SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size());
926 Results.push_back(R);
928 if (!AsNestedNameSpecifier)
929 MaybeAddConstructorResults(R);
932 void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
933 NamedDecl *Hiding, bool InBaseClass = false) {
934 if (R.Kind != Result::RK_Declaration) {
935 // For non-declaration results, just add the result.
936 Results.push_back(R);
940 // Look through using declarations.
941 if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
942 AddResult(Result(Using->getTargetDecl(),
943 getBasePriority(Using->getTargetDecl()),
949 bool AsNestedNameSpecifier = false;
950 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
953 // C++ constructors are never found by name lookup.
954 if (isa<CXXConstructorDecl>(R.Declaration))
957 if (Hiding && CheckHiddenResult(R, CurContext, Hiding))
960 // Make sure that any given declaration only shows up in the result set once.
961 if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl()))
964 // If the filter is for nested-name-specifiers, then this result starts a
965 // nested-name-specifier.
966 if (AsNestedNameSpecifier) {
967 R.StartsNestedNameSpecifier = true;
968 R.Priority = CCP_NestedNameSpecifier;
970 else if (Filter == &ResultBuilder::IsMember && !R.Qualifier && InBaseClass &&
971 isa<CXXRecordDecl>(R.Declaration->getDeclContext()
972 ->getRedeclContext()))
973 R.QualifierIsInformative = true;
975 // If this result is supposed to have an informative qualifier, add one.
976 if (R.QualifierIsInformative && !R.Qualifier &&
977 !R.StartsNestedNameSpecifier) {
978 const DeclContext *Ctx = R.Declaration->getDeclContext();
979 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
980 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, Namespace);
981 else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
982 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, false,
983 SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
985 R.QualifierIsInformative = false;
988 // Adjust the priority if this result comes from a base class.
990 R.Priority += CCD_InBaseClass;
992 AdjustResultPriorityForDecl(R);
994 if (HasObjectTypeQualifiers)
995 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(R.Declaration))
996 if (Method->isInstance()) {
997 Qualifiers MethodQuals
998 = Qualifiers::fromCVRMask(Method->getTypeQualifiers());
999 if (ObjectTypeQualifiers == MethodQuals)
1000 R.Priority += CCD_ObjectQualifierMatch;
1001 else if (ObjectTypeQualifiers - MethodQuals) {
1002 // The method cannot be invoked, because doing so would drop
1008 // Insert this result into the set of results.
1009 Results.push_back(R);
1011 if (!AsNestedNameSpecifier)
1012 MaybeAddConstructorResults(R);
1015 void ResultBuilder::AddResult(Result R) {
1016 assert(R.Kind != Result::RK_Declaration &&
1017 "Declaration results need more context");
1018 Results.push_back(R);
1021 /// \brief Enter into a new scope.
1022 void ResultBuilder::EnterNewScope() {
1023 ShadowMaps.push_back(ShadowMap());
1026 /// \brief Exit from the current scope.
1027 void ResultBuilder::ExitScope() {
1028 for (ShadowMap::iterator E = ShadowMaps.back().begin(),
1029 EEnd = ShadowMaps.back().end();
1032 E->second.Destroy();
1034 ShadowMaps.pop_back();
1037 /// \brief Determines whether this given declaration will be found by
1038 /// ordinary name lookup.
1039 bool ResultBuilder::IsOrdinaryName(const NamedDecl *ND) const {
1040 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
1042 unsigned IDNS = Decl::IDNS_Ordinary;
1043 if (SemaRef.getLangOpts().CPlusPlus)
1044 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
1045 else if (SemaRef.getLangOpts().ObjC1) {
1046 if (isa<ObjCIvarDecl>(ND))
1050 return ND->getIdentifierNamespace() & IDNS;
1053 /// \brief Determines whether this given declaration will be found by
1054 /// ordinary name lookup but is not a type name.
1055 bool ResultBuilder::IsOrdinaryNonTypeName(const NamedDecl *ND) const {
1056 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
1057 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND))
1060 unsigned IDNS = Decl::IDNS_Ordinary;
1061 if (SemaRef.getLangOpts().CPlusPlus)
1062 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
1063 else if (SemaRef.getLangOpts().ObjC1) {
1064 if (isa<ObjCIvarDecl>(ND))
1068 return ND->getIdentifierNamespace() & IDNS;
1071 bool ResultBuilder::IsIntegralConstantValue(const NamedDecl *ND) const {
1072 if (!IsOrdinaryNonTypeName(ND))
1075 if (const ValueDecl *VD = dyn_cast<ValueDecl>(ND->getUnderlyingDecl()))
1076 if (VD->getType()->isIntegralOrEnumerationType())
1082 /// \brief Determines whether this given declaration will be found by
1083 /// ordinary name lookup.
1084 bool ResultBuilder::IsOrdinaryNonValueName(const NamedDecl *ND) const {
1085 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
1087 unsigned IDNS = Decl::IDNS_Ordinary;
1088 if (SemaRef.getLangOpts().CPlusPlus)
1089 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace;
1091 return (ND->getIdentifierNamespace() & IDNS) &&
1092 !isa<ValueDecl>(ND) && !isa<FunctionTemplateDecl>(ND) &&
1093 !isa<ObjCPropertyDecl>(ND);
1096 /// \brief Determines whether the given declaration is suitable as the
1097 /// start of a C++ nested-name-specifier, e.g., a class or namespace.
1098 bool ResultBuilder::IsNestedNameSpecifier(const NamedDecl *ND) const {
1099 // Allow us to find class templates, too.
1100 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1101 ND = ClassTemplate->getTemplatedDecl();
1103 return SemaRef.isAcceptableNestedNameSpecifier(ND);
1106 /// \brief Determines whether the given declaration is an enumeration.
1107 bool ResultBuilder::IsEnum(const NamedDecl *ND) const {
1108 return isa<EnumDecl>(ND);
1111 /// \brief Determines whether the given declaration is a class or struct.
1112 bool ResultBuilder::IsClassOrStruct(const NamedDecl *ND) const {
1113 // Allow us to find class templates, too.
1114 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1115 ND = ClassTemplate->getTemplatedDecl();
1117 // For purposes of this check, interfaces match too.
1118 if (const RecordDecl *RD = dyn_cast<RecordDecl>(ND))
1119 return RD->getTagKind() == TTK_Class ||
1120 RD->getTagKind() == TTK_Struct ||
1121 RD->getTagKind() == TTK_Interface;
1126 /// \brief Determines whether the given declaration is a union.
1127 bool ResultBuilder::IsUnion(const NamedDecl *ND) const {
1128 // Allow us to find class templates, too.
1129 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1130 ND = ClassTemplate->getTemplatedDecl();
1132 if (const RecordDecl *RD = dyn_cast<RecordDecl>(ND))
1133 return RD->getTagKind() == TTK_Union;
1138 /// \brief Determines whether the given declaration is a namespace.
1139 bool ResultBuilder::IsNamespace(const NamedDecl *ND) const {
1140 return isa<NamespaceDecl>(ND);
1143 /// \brief Determines whether the given declaration is a namespace or
1144 /// namespace alias.
1145 bool ResultBuilder::IsNamespaceOrAlias(const NamedDecl *ND) const {
1146 return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
1149 /// \brief Determines whether the given declaration is a type.
1150 bool ResultBuilder::IsType(const NamedDecl *ND) const {
1151 if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(ND))
1152 ND = Using->getTargetDecl();
1154 return isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
1157 /// \brief Determines which members of a class should be visible via
1158 /// "." or "->". Only value declarations, nested name specifiers, and
1159 /// using declarations thereof should show up.
1160 bool ResultBuilder::IsMember(const NamedDecl *ND) const {
1161 if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(ND))
1162 ND = Using->getTargetDecl();
1164 return isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND) ||
1165 isa<ObjCPropertyDecl>(ND);
1168 static bool isObjCReceiverType(ASTContext &C, QualType T) {
1169 T = C.getCanonicalType(T);
1170 switch (T->getTypeClass()) {
1171 case Type::ObjCObject:
1172 case Type::ObjCInterface:
1173 case Type::ObjCObjectPointer:
1177 switch (cast<BuiltinType>(T)->getKind()) {
1178 case BuiltinType::ObjCId:
1179 case BuiltinType::ObjCClass:
1180 case BuiltinType::ObjCSel:
1192 if (!C.getLangOpts().CPlusPlus)
1195 // FIXME: We could perform more analysis here to determine whether a
1196 // particular class type has any conversions to Objective-C types. For now,
1197 // just accept all class types.
1198 return T->isDependentType() || T->isRecordType();
1201 bool ResultBuilder::IsObjCMessageReceiver(const NamedDecl *ND) const {
1202 QualType T = getDeclUsageType(SemaRef.Context, ND);
1206 T = SemaRef.Context.getBaseElementType(T);
1207 return isObjCReceiverType(SemaRef.Context, T);
1210 bool ResultBuilder::IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const {
1211 if (IsObjCMessageReceiver(ND))
1214 const VarDecl *Var = dyn_cast<VarDecl>(ND);
1218 return Var->hasLocalStorage() && !Var->hasAttr<BlocksAttr>();
1221 bool ResultBuilder::IsObjCCollection(const NamedDecl *ND) const {
1222 if ((SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryName(ND)) ||
1223 (!SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryNonTypeName(ND)))
1226 QualType T = getDeclUsageType(SemaRef.Context, ND);
1230 T = SemaRef.Context.getBaseElementType(T);
1231 return T->isObjCObjectType() || T->isObjCObjectPointerType() ||
1232 T->isObjCIdType() ||
1233 (SemaRef.getLangOpts().CPlusPlus && T->isRecordType());
1236 bool ResultBuilder::IsImpossibleToSatisfy(const NamedDecl *ND) const {
1240 /// \brief Determines whether the given declaration is an Objective-C
1241 /// instance variable.
1242 bool ResultBuilder::IsObjCIvar(const NamedDecl *ND) const {
1243 return isa<ObjCIvarDecl>(ND);
1247 /// \brief Visible declaration consumer that adds a code-completion result
1248 /// for each visible declaration.
1249 class CodeCompletionDeclConsumer : public VisibleDeclConsumer {
1250 ResultBuilder &Results;
1251 DeclContext *CurContext;
1254 CodeCompletionDeclConsumer(ResultBuilder &Results, DeclContext *CurContext)
1255 : Results(Results), CurContext(CurContext) { }
1257 virtual void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,
1259 bool Accessible = true;
1261 Accessible = Results.getSema().IsSimplyAccessible(ND, Ctx);
1263 ResultBuilder::Result Result(ND, Results.getBasePriority(ND), 0, false,
1265 Results.AddResult(Result, CurContext, Hiding, InBaseClass);
1270 /// \brief Add type specifiers for the current language as keyword results.
1271 static void AddTypeSpecifierResults(const LangOptions &LangOpts,
1272 ResultBuilder &Results) {
1273 typedef CodeCompletionResult Result;
1274 Results.AddResult(Result("short", CCP_Type));
1275 Results.AddResult(Result("long", CCP_Type));
1276 Results.AddResult(Result("signed", CCP_Type));
1277 Results.AddResult(Result("unsigned", CCP_Type));
1278 Results.AddResult(Result("void", CCP_Type));
1279 Results.AddResult(Result("char", CCP_Type));
1280 Results.AddResult(Result("int", CCP_Type));
1281 Results.AddResult(Result("float", CCP_Type));
1282 Results.AddResult(Result("double", CCP_Type));
1283 Results.AddResult(Result("enum", CCP_Type));
1284 Results.AddResult(Result("struct", CCP_Type));
1285 Results.AddResult(Result("union", CCP_Type));
1286 Results.AddResult(Result("const", CCP_Type));
1287 Results.AddResult(Result("volatile", CCP_Type));
1291 Results.AddResult(Result("_Complex", CCP_Type));
1292 Results.AddResult(Result("_Imaginary", CCP_Type));
1293 Results.AddResult(Result("_Bool", CCP_Type));
1294 Results.AddResult(Result("restrict", CCP_Type));
1297 CodeCompletionBuilder Builder(Results.getAllocator(),
1298 Results.getCodeCompletionTUInfo());
1299 if (LangOpts.CPlusPlus) {
1301 Results.AddResult(Result("bool", CCP_Type +
1302 (LangOpts.ObjC1? CCD_bool_in_ObjC : 0)));
1303 Results.AddResult(Result("class", CCP_Type));
1304 Results.AddResult(Result("wchar_t", CCP_Type));
1306 // typename qualified-id
1307 Builder.AddTypedTextChunk("typename");
1308 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1309 Builder.AddPlaceholderChunk("qualifier");
1310 Builder.AddTextChunk("::");
1311 Builder.AddPlaceholderChunk("name");
1312 Results.AddResult(Result(Builder.TakeString()));
1314 if (LangOpts.CPlusPlus11) {
1315 Results.AddResult(Result("auto", CCP_Type));
1316 Results.AddResult(Result("char16_t", CCP_Type));
1317 Results.AddResult(Result("char32_t", CCP_Type));
1319 Builder.AddTypedTextChunk("decltype");
1320 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1321 Builder.AddPlaceholderChunk("expression");
1322 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1323 Results.AddResult(Result(Builder.TakeString()));
1328 if (LangOpts.GNUMode) {
1329 // FIXME: Enable when we actually support decimal floating point.
1330 // Results.AddResult(Result("_Decimal32"));
1331 // Results.AddResult(Result("_Decimal64"));
1332 // Results.AddResult(Result("_Decimal128"));
1334 Builder.AddTypedTextChunk("typeof");
1335 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1336 Builder.AddPlaceholderChunk("expression");
1337 Results.AddResult(Result(Builder.TakeString()));
1339 Builder.AddTypedTextChunk("typeof");
1340 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1341 Builder.AddPlaceholderChunk("type");
1342 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1343 Results.AddResult(Result(Builder.TakeString()));
1347 static void AddStorageSpecifiers(Sema::ParserCompletionContext CCC,
1348 const LangOptions &LangOpts,
1349 ResultBuilder &Results) {
1350 typedef CodeCompletionResult Result;
1351 // Note: we don't suggest either "auto" or "register", because both
1352 // are pointless as storage specifiers. Elsewhere, we suggest "auto"
1353 // in C++0x as a type specifier.
1354 Results.AddResult(Result("extern"));
1355 Results.AddResult(Result("static"));
1358 static void AddFunctionSpecifiers(Sema::ParserCompletionContext CCC,
1359 const LangOptions &LangOpts,
1360 ResultBuilder &Results) {
1361 typedef CodeCompletionResult Result;
1363 case Sema::PCC_Class:
1364 case Sema::PCC_MemberTemplate:
1365 if (LangOpts.CPlusPlus) {
1366 Results.AddResult(Result("explicit"));
1367 Results.AddResult(Result("friend"));
1368 Results.AddResult(Result("mutable"));
1369 Results.AddResult(Result("virtual"));
1373 case Sema::PCC_ObjCInterface:
1374 case Sema::PCC_ObjCImplementation:
1375 case Sema::PCC_Namespace:
1376 case Sema::PCC_Template:
1377 if (LangOpts.CPlusPlus || LangOpts.C99)
1378 Results.AddResult(Result("inline"));
1381 case Sema::PCC_ObjCInstanceVariableList:
1382 case Sema::PCC_Expression:
1383 case Sema::PCC_Statement:
1384 case Sema::PCC_ForInit:
1385 case Sema::PCC_Condition:
1386 case Sema::PCC_RecoveryInFunction:
1387 case Sema::PCC_Type:
1388 case Sema::PCC_ParenthesizedExpression:
1389 case Sema::PCC_LocalDeclarationSpecifiers:
1394 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt);
1395 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt);
1396 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
1397 ResultBuilder &Results,
1399 static void AddObjCImplementationResults(const LangOptions &LangOpts,
1400 ResultBuilder &Results,
1402 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
1403 ResultBuilder &Results,
1405 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt);
1407 static void AddTypedefResult(ResultBuilder &Results) {
1408 CodeCompletionBuilder Builder(Results.getAllocator(),
1409 Results.getCodeCompletionTUInfo());
1410 Builder.AddTypedTextChunk("typedef");
1411 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1412 Builder.AddPlaceholderChunk("type");
1413 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1414 Builder.AddPlaceholderChunk("name");
1415 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1418 static bool WantTypesInContext(Sema::ParserCompletionContext CCC,
1419 const LangOptions &LangOpts) {
1421 case Sema::PCC_Namespace:
1422 case Sema::PCC_Class:
1423 case Sema::PCC_ObjCInstanceVariableList:
1424 case Sema::PCC_Template:
1425 case Sema::PCC_MemberTemplate:
1426 case Sema::PCC_Statement:
1427 case Sema::PCC_RecoveryInFunction:
1428 case Sema::PCC_Type:
1429 case Sema::PCC_ParenthesizedExpression:
1430 case Sema::PCC_LocalDeclarationSpecifiers:
1433 case Sema::PCC_Expression:
1434 case Sema::PCC_Condition:
1435 return LangOpts.CPlusPlus;
1437 case Sema::PCC_ObjCInterface:
1438 case Sema::PCC_ObjCImplementation:
1441 case Sema::PCC_ForInit:
1442 return LangOpts.CPlusPlus || LangOpts.ObjC1 || LangOpts.C99;
1445 llvm_unreachable("Invalid ParserCompletionContext!");
1448 static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context,
1449 const Preprocessor &PP) {
1450 PrintingPolicy Policy = Sema::getPrintingPolicy(Context, PP);
1451 Policy.AnonymousTagLocations = false;
1452 Policy.SuppressStrongLifetime = true;
1453 Policy.SuppressUnwrittenScope = true;
1457 /// \brief Retrieve a printing policy suitable for code completion.
1458 static PrintingPolicy getCompletionPrintingPolicy(Sema &S) {
1459 return getCompletionPrintingPolicy(S.Context, S.PP);
1462 /// \brief Retrieve the string representation of the given type as a string
1463 /// that has the appropriate lifetime for code completion.
1465 /// This routine provides a fast path where we provide constant strings for
1466 /// common type names.
1467 static const char *GetCompletionTypeString(QualType T,
1468 ASTContext &Context,
1469 const PrintingPolicy &Policy,
1470 CodeCompletionAllocator &Allocator) {
1471 if (!T.getLocalQualifiers()) {
1472 // Built-in type names are constant strings.
1473 if (const BuiltinType *BT = dyn_cast<BuiltinType>(T))
1474 return BT->getNameAsCString(Policy);
1476 // Anonymous tag types are constant strings.
1477 if (const TagType *TagT = dyn_cast<TagType>(T))
1478 if (TagDecl *Tag = TagT->getDecl())
1479 if (!Tag->hasNameForLinkage()) {
1480 switch (Tag->getTagKind()) {
1481 case TTK_Struct: return "struct <anonymous>";
1482 case TTK_Interface: return "__interface <anonymous>";
1483 case TTK_Class: return "class <anonymous>";
1484 case TTK_Union: return "union <anonymous>";
1485 case TTK_Enum: return "enum <anonymous>";
1490 // Slow path: format the type as a string.
1492 T.getAsStringInternal(Result, Policy);
1493 return Allocator.CopyString(Result);
1496 /// \brief Add a completion for "this", if we're in a member function.
1497 static void addThisCompletion(Sema &S, ResultBuilder &Results) {
1498 QualType ThisTy = S.getCurrentThisType();
1499 if (ThisTy.isNull())
1502 CodeCompletionAllocator &Allocator = Results.getAllocator();
1503 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1504 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
1505 Builder.AddResultTypeChunk(GetCompletionTypeString(ThisTy,
1509 Builder.AddTypedTextChunk("this");
1510 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1513 /// \brief Add language constructs that show up for "ordinary" names.
1514 static void AddOrdinaryNameResults(Sema::ParserCompletionContext CCC,
1517 ResultBuilder &Results) {
1518 CodeCompletionAllocator &Allocator = Results.getAllocator();
1519 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1520 PrintingPolicy Policy = getCompletionPrintingPolicy(SemaRef);
1522 typedef CodeCompletionResult Result;
1524 case Sema::PCC_Namespace:
1525 if (SemaRef.getLangOpts().CPlusPlus) {
1526 if (Results.includeCodePatterns()) {
1527 // namespace <identifier> { declarations }
1528 Builder.AddTypedTextChunk("namespace");
1529 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1530 Builder.AddPlaceholderChunk("identifier");
1531 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1532 Builder.AddPlaceholderChunk("declarations");
1533 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1534 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1535 Results.AddResult(Result(Builder.TakeString()));
1538 // namespace identifier = identifier ;
1539 Builder.AddTypedTextChunk("namespace");
1540 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1541 Builder.AddPlaceholderChunk("name");
1542 Builder.AddChunk(CodeCompletionString::CK_Equal);
1543 Builder.AddPlaceholderChunk("namespace");
1544 Results.AddResult(Result(Builder.TakeString()));
1547 Builder.AddTypedTextChunk("using");
1548 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1549 Builder.AddTextChunk("namespace");
1550 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1551 Builder.AddPlaceholderChunk("identifier");
1552 Results.AddResult(Result(Builder.TakeString()));
1554 // asm(string-literal)
1555 Builder.AddTypedTextChunk("asm");
1556 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1557 Builder.AddPlaceholderChunk("string-literal");
1558 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1559 Results.AddResult(Result(Builder.TakeString()));
1561 if (Results.includeCodePatterns()) {
1562 // Explicit template instantiation
1563 Builder.AddTypedTextChunk("template");
1564 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1565 Builder.AddPlaceholderChunk("declaration");
1566 Results.AddResult(Result(Builder.TakeString()));
1570 if (SemaRef.getLangOpts().ObjC1)
1571 AddObjCTopLevelResults(Results, true);
1573 AddTypedefResult(Results);
1576 case Sema::PCC_Class:
1577 if (SemaRef.getLangOpts().CPlusPlus) {
1578 // Using declaration
1579 Builder.AddTypedTextChunk("using");
1580 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1581 Builder.AddPlaceholderChunk("qualifier");
1582 Builder.AddTextChunk("::");
1583 Builder.AddPlaceholderChunk("name");
1584 Results.AddResult(Result(Builder.TakeString()));
1586 // using typename qualifier::name (only in a dependent context)
1587 if (SemaRef.CurContext->isDependentContext()) {
1588 Builder.AddTypedTextChunk("using");
1589 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1590 Builder.AddTextChunk("typename");
1591 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1592 Builder.AddPlaceholderChunk("qualifier");
1593 Builder.AddTextChunk("::");
1594 Builder.AddPlaceholderChunk("name");
1595 Results.AddResult(Result(Builder.TakeString()));
1598 if (CCC == Sema::PCC_Class) {
1599 AddTypedefResult(Results);
1602 Builder.AddTypedTextChunk("public");
1603 if (Results.includeCodePatterns())
1604 Builder.AddChunk(CodeCompletionString::CK_Colon);
1605 Results.AddResult(Result(Builder.TakeString()));
1608 Builder.AddTypedTextChunk("protected");
1609 if (Results.includeCodePatterns())
1610 Builder.AddChunk(CodeCompletionString::CK_Colon);
1611 Results.AddResult(Result(Builder.TakeString()));
1614 Builder.AddTypedTextChunk("private");
1615 if (Results.includeCodePatterns())
1616 Builder.AddChunk(CodeCompletionString::CK_Colon);
1617 Results.AddResult(Result(Builder.TakeString()));
1622 case Sema::PCC_Template:
1623 case Sema::PCC_MemberTemplate:
1624 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns()) {
1625 // template < parameters >
1626 Builder.AddTypedTextChunk("template");
1627 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1628 Builder.AddPlaceholderChunk("parameters");
1629 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1630 Results.AddResult(Result(Builder.TakeString()));
1633 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1634 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1637 case Sema::PCC_ObjCInterface:
1638 AddObjCInterfaceResults(SemaRef.getLangOpts(), Results, true);
1639 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1640 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1643 case Sema::PCC_ObjCImplementation:
1644 AddObjCImplementationResults(SemaRef.getLangOpts(), Results, true);
1645 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1646 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1649 case Sema::PCC_ObjCInstanceVariableList:
1650 AddObjCVisibilityResults(SemaRef.getLangOpts(), Results, true);
1653 case Sema::PCC_RecoveryInFunction:
1654 case Sema::PCC_Statement: {
1655 AddTypedefResult(Results);
1657 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns() &&
1658 SemaRef.getLangOpts().CXXExceptions) {
1659 Builder.AddTypedTextChunk("try");
1660 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1661 Builder.AddPlaceholderChunk("statements");
1662 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1663 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1664 Builder.AddTextChunk("catch");
1665 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1666 Builder.AddPlaceholderChunk("declaration");
1667 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1668 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1669 Builder.AddPlaceholderChunk("statements");
1670 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1671 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1672 Results.AddResult(Result(Builder.TakeString()));
1674 if (SemaRef.getLangOpts().ObjC1)
1675 AddObjCStatementResults(Results, true);
1677 if (Results.includeCodePatterns()) {
1678 // if (condition) { statements }
1679 Builder.AddTypedTextChunk("if");
1680 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1681 if (SemaRef.getLangOpts().CPlusPlus)
1682 Builder.AddPlaceholderChunk("condition");
1684 Builder.AddPlaceholderChunk("expression");
1685 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1686 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1687 Builder.AddPlaceholderChunk("statements");
1688 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1689 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1690 Results.AddResult(Result(Builder.TakeString()));
1692 // switch (condition) { }
1693 Builder.AddTypedTextChunk("switch");
1694 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1695 if (SemaRef.getLangOpts().CPlusPlus)
1696 Builder.AddPlaceholderChunk("condition");
1698 Builder.AddPlaceholderChunk("expression");
1699 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1700 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1701 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1702 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1703 Results.AddResult(Result(Builder.TakeString()));
1706 // Switch-specific statements.
1707 if (!SemaRef.getCurFunction()->SwitchStack.empty()) {
1709 Builder.AddTypedTextChunk("case");
1710 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1711 Builder.AddPlaceholderChunk("expression");
1712 Builder.AddChunk(CodeCompletionString::CK_Colon);
1713 Results.AddResult(Result(Builder.TakeString()));
1716 Builder.AddTypedTextChunk("default");
1717 Builder.AddChunk(CodeCompletionString::CK_Colon);
1718 Results.AddResult(Result(Builder.TakeString()));
1721 if (Results.includeCodePatterns()) {
1722 /// while (condition) { statements }
1723 Builder.AddTypedTextChunk("while");
1724 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1725 if (SemaRef.getLangOpts().CPlusPlus)
1726 Builder.AddPlaceholderChunk("condition");
1728 Builder.AddPlaceholderChunk("expression");
1729 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1730 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1731 Builder.AddPlaceholderChunk("statements");
1732 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1733 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1734 Results.AddResult(Result(Builder.TakeString()));
1736 // do { statements } while ( expression );
1737 Builder.AddTypedTextChunk("do");
1738 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1739 Builder.AddPlaceholderChunk("statements");
1740 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1741 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1742 Builder.AddTextChunk("while");
1743 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1744 Builder.AddPlaceholderChunk("expression");
1745 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1746 Results.AddResult(Result(Builder.TakeString()));
1748 // for ( for-init-statement ; condition ; expression ) { statements }
1749 Builder.AddTypedTextChunk("for");
1750 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1751 if (SemaRef.getLangOpts().CPlusPlus || SemaRef.getLangOpts().C99)
1752 Builder.AddPlaceholderChunk("init-statement");
1754 Builder.AddPlaceholderChunk("init-expression");
1755 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1756 Builder.AddPlaceholderChunk("condition");
1757 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1758 Builder.AddPlaceholderChunk("inc-expression");
1759 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1760 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1761 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1762 Builder.AddPlaceholderChunk("statements");
1763 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1764 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1765 Results.AddResult(Result(Builder.TakeString()));
1768 if (S->getContinueParent()) {
1770 Builder.AddTypedTextChunk("continue");
1771 Results.AddResult(Result(Builder.TakeString()));
1774 if (S->getBreakParent()) {
1776 Builder.AddTypedTextChunk("break");
1777 Results.AddResult(Result(Builder.TakeString()));
1780 // "return expression ;" or "return ;", depending on whether we
1781 // know the function is void or not.
1782 bool isVoid = false;
1783 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(SemaRef.CurContext))
1784 isVoid = Function->getResultType()->isVoidType();
1785 else if (ObjCMethodDecl *Method
1786 = dyn_cast<ObjCMethodDecl>(SemaRef.CurContext))
1787 isVoid = Method->getResultType()->isVoidType();
1788 else if (SemaRef.getCurBlock() &&
1789 !SemaRef.getCurBlock()->ReturnType.isNull())
1790 isVoid = SemaRef.getCurBlock()->ReturnType->isVoidType();
1791 Builder.AddTypedTextChunk("return");
1793 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1794 Builder.AddPlaceholderChunk("expression");
1796 Results.AddResult(Result(Builder.TakeString()));
1798 // goto identifier ;
1799 Builder.AddTypedTextChunk("goto");
1800 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1801 Builder.AddPlaceholderChunk("label");
1802 Results.AddResult(Result(Builder.TakeString()));
1805 Builder.AddTypedTextChunk("using");
1806 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1807 Builder.AddTextChunk("namespace");
1808 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1809 Builder.AddPlaceholderChunk("identifier");
1810 Results.AddResult(Result(Builder.TakeString()));
1813 // Fall through (for statement expressions).
1814 case Sema::PCC_ForInit:
1815 case Sema::PCC_Condition:
1816 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1817 // Fall through: conditions and statements can have expressions.
1819 case Sema::PCC_ParenthesizedExpression:
1820 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
1821 CCC == Sema::PCC_ParenthesizedExpression) {
1822 // (__bridge <type>)<expression>
1823 Builder.AddTypedTextChunk("__bridge");
1824 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1825 Builder.AddPlaceholderChunk("type");
1826 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1827 Builder.AddPlaceholderChunk("expression");
1828 Results.AddResult(Result(Builder.TakeString()));
1830 // (__bridge_transfer <Objective-C type>)<expression>
1831 Builder.AddTypedTextChunk("__bridge_transfer");
1832 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1833 Builder.AddPlaceholderChunk("Objective-C type");
1834 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1835 Builder.AddPlaceholderChunk("expression");
1836 Results.AddResult(Result(Builder.TakeString()));
1838 // (__bridge_retained <CF type>)<expression>
1839 Builder.AddTypedTextChunk("__bridge_retained");
1840 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1841 Builder.AddPlaceholderChunk("CF type");
1842 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1843 Builder.AddPlaceholderChunk("expression");
1844 Results.AddResult(Result(Builder.TakeString()));
1848 case Sema::PCC_Expression: {
1849 if (SemaRef.getLangOpts().CPlusPlus) {
1850 // 'this', if we're in a non-static member function.
1851 addThisCompletion(SemaRef, Results);
1854 Builder.AddResultTypeChunk("bool");
1855 Builder.AddTypedTextChunk("true");
1856 Results.AddResult(Result(Builder.TakeString()));
1859 Builder.AddResultTypeChunk("bool");
1860 Builder.AddTypedTextChunk("false");
1861 Results.AddResult(Result(Builder.TakeString()));
1863 if (SemaRef.getLangOpts().RTTI) {
1864 // dynamic_cast < type-id > ( expression )
1865 Builder.AddTypedTextChunk("dynamic_cast");
1866 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1867 Builder.AddPlaceholderChunk("type");
1868 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1869 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1870 Builder.AddPlaceholderChunk("expression");
1871 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1872 Results.AddResult(Result(Builder.TakeString()));
1875 // static_cast < type-id > ( expression )
1876 Builder.AddTypedTextChunk("static_cast");
1877 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1878 Builder.AddPlaceholderChunk("type");
1879 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1880 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1881 Builder.AddPlaceholderChunk("expression");
1882 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1883 Results.AddResult(Result(Builder.TakeString()));
1885 // reinterpret_cast < type-id > ( expression )
1886 Builder.AddTypedTextChunk("reinterpret_cast");
1887 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1888 Builder.AddPlaceholderChunk("type");
1889 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1890 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1891 Builder.AddPlaceholderChunk("expression");
1892 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1893 Results.AddResult(Result(Builder.TakeString()));
1895 // const_cast < type-id > ( expression )
1896 Builder.AddTypedTextChunk("const_cast");
1897 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1898 Builder.AddPlaceholderChunk("type");
1899 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1900 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1901 Builder.AddPlaceholderChunk("expression");
1902 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1903 Results.AddResult(Result(Builder.TakeString()));
1905 if (SemaRef.getLangOpts().RTTI) {
1906 // typeid ( expression-or-type )
1907 Builder.AddResultTypeChunk("std::type_info");
1908 Builder.AddTypedTextChunk("typeid");
1909 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1910 Builder.AddPlaceholderChunk("expression-or-type");
1911 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1912 Results.AddResult(Result(Builder.TakeString()));
1916 Builder.AddTypedTextChunk("new");
1917 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1918 Builder.AddPlaceholderChunk("type");
1919 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1920 Builder.AddPlaceholderChunk("expressions");
1921 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1922 Results.AddResult(Result(Builder.TakeString()));
1924 // new T [ ] ( ... )
1925 Builder.AddTypedTextChunk("new");
1926 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1927 Builder.AddPlaceholderChunk("type");
1928 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
1929 Builder.AddPlaceholderChunk("size");
1930 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
1931 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1932 Builder.AddPlaceholderChunk("expressions");
1933 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1934 Results.AddResult(Result(Builder.TakeString()));
1936 // delete expression
1937 Builder.AddResultTypeChunk("void");
1938 Builder.AddTypedTextChunk("delete");
1939 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1940 Builder.AddPlaceholderChunk("expression");
1941 Results.AddResult(Result(Builder.TakeString()));
1943 // delete [] expression
1944 Builder.AddResultTypeChunk("void");
1945 Builder.AddTypedTextChunk("delete");
1946 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1947 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
1948 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
1949 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1950 Builder.AddPlaceholderChunk("expression");
1951 Results.AddResult(Result(Builder.TakeString()));
1953 if (SemaRef.getLangOpts().CXXExceptions) {
1955 Builder.AddResultTypeChunk("void");
1956 Builder.AddTypedTextChunk("throw");
1957 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1958 Builder.AddPlaceholderChunk("expression");
1959 Results.AddResult(Result(Builder.TakeString()));
1964 if (SemaRef.getLangOpts().CPlusPlus11) {
1966 Builder.AddResultTypeChunk("std::nullptr_t");
1967 Builder.AddTypedTextChunk("nullptr");
1968 Results.AddResult(Result(Builder.TakeString()));
1971 Builder.AddResultTypeChunk("size_t");
1972 Builder.AddTypedTextChunk("alignof");
1973 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1974 Builder.AddPlaceholderChunk("type");
1975 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1976 Results.AddResult(Result(Builder.TakeString()));
1979 Builder.AddResultTypeChunk("bool");
1980 Builder.AddTypedTextChunk("noexcept");
1981 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1982 Builder.AddPlaceholderChunk("expression");
1983 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1984 Results.AddResult(Result(Builder.TakeString()));
1986 // sizeof... expression
1987 Builder.AddResultTypeChunk("size_t");
1988 Builder.AddTypedTextChunk("sizeof...");
1989 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1990 Builder.AddPlaceholderChunk("parameter-pack");
1991 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1992 Results.AddResult(Result(Builder.TakeString()));
1996 if (SemaRef.getLangOpts().ObjC1) {
1997 // Add "super", if we're in an Objective-C class with a superclass.
1998 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) {
1999 // The interface can be NULL.
2000 if (ObjCInterfaceDecl *ID = Method->getClassInterface())
2001 if (ID->getSuperClass()) {
2002 std::string SuperType;
2003 SuperType = ID->getSuperClass()->getNameAsString();
2004 if (Method->isInstanceMethod())
2007 Builder.AddResultTypeChunk(Allocator.CopyString(SuperType));
2008 Builder.AddTypedTextChunk("super");
2009 Results.AddResult(Result(Builder.TakeString()));
2013 AddObjCExpressionResults(Results, true);
2016 if (SemaRef.getLangOpts().C11) {
2018 Builder.AddResultTypeChunk("size_t");
2019 if (SemaRef.getASTContext().Idents.get("alignof").hasMacroDefinition())
2020 Builder.AddTypedTextChunk("alignof");
2022 Builder.AddTypedTextChunk("_Alignof");
2023 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2024 Builder.AddPlaceholderChunk("type");
2025 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2026 Results.AddResult(Result(Builder.TakeString()));
2029 // sizeof expression
2030 Builder.AddResultTypeChunk("size_t");
2031 Builder.AddTypedTextChunk("sizeof");
2032 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2033 Builder.AddPlaceholderChunk("expression-or-type");
2034 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2035 Results.AddResult(Result(Builder.TakeString()));
2039 case Sema::PCC_Type:
2040 case Sema::PCC_LocalDeclarationSpecifiers:
2044 if (WantTypesInContext(CCC, SemaRef.getLangOpts()))
2045 AddTypeSpecifierResults(SemaRef.getLangOpts(), Results);
2047 if (SemaRef.getLangOpts().CPlusPlus && CCC != Sema::PCC_Type)
2048 Results.AddResult(Result("operator"));
2051 /// \brief If the given declaration has an associated type, add it as a result
2053 static void AddResultTypeChunk(ASTContext &Context,
2054 const PrintingPolicy &Policy,
2055 const NamedDecl *ND,
2056 CodeCompletionBuilder &Result) {
2060 // Skip constructors and conversion functions, which have their return types
2061 // built into their names.
2062 if (isa<CXXConstructorDecl>(ND) || isa<CXXConversionDecl>(ND))
2065 // Determine the type of the declaration (if it has a type).
2067 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(ND))
2068 T = Function->getResultType();
2069 else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND))
2070 T = Method->getResultType();
2071 else if (const FunctionTemplateDecl *FunTmpl =
2072 dyn_cast<FunctionTemplateDecl>(ND))
2073 T = FunTmpl->getTemplatedDecl()->getResultType();
2074 else if (const EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND))
2075 T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext()));
2076 else if (isa<UnresolvedUsingValueDecl>(ND)) {
2077 /* Do nothing: ignore unresolved using declarations*/
2078 } else if (const ValueDecl *Value = dyn_cast<ValueDecl>(ND)) {
2079 T = Value->getType();
2080 } else if (const ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND))
2081 T = Property->getType();
2083 if (T.isNull() || Context.hasSameType(T, Context.DependentTy))
2086 Result.AddResultTypeChunk(GetCompletionTypeString(T, Context, Policy,
2087 Result.getAllocator()));
2090 static void MaybeAddSentinel(ASTContext &Context,
2091 const NamedDecl *FunctionOrMethod,
2092 CodeCompletionBuilder &Result) {
2093 if (SentinelAttr *Sentinel = FunctionOrMethod->getAttr<SentinelAttr>())
2094 if (Sentinel->getSentinel() == 0) {
2095 if (Context.getLangOpts().ObjC1 &&
2096 Context.Idents.get("nil").hasMacroDefinition())
2097 Result.AddTextChunk(", nil");
2098 else if (Context.Idents.get("NULL").hasMacroDefinition())
2099 Result.AddTextChunk(", NULL");
2101 Result.AddTextChunk(", (void*)0");
2105 static std::string formatObjCParamQualifiers(unsigned ObjCQuals) {
2107 if (ObjCQuals & Decl::OBJC_TQ_In)
2109 else if (ObjCQuals & Decl::OBJC_TQ_Inout)
2111 else if (ObjCQuals & Decl::OBJC_TQ_Out)
2113 if (ObjCQuals & Decl::OBJC_TQ_Bycopy)
2114 Result += "bycopy ";
2115 else if (ObjCQuals & Decl::OBJC_TQ_Byref)
2117 if (ObjCQuals & Decl::OBJC_TQ_Oneway)
2118 Result += "oneway ";
2122 static std::string FormatFunctionParameter(ASTContext &Context,
2123 const PrintingPolicy &Policy,
2124 const ParmVarDecl *Param,
2125 bool SuppressName = false,
2126 bool SuppressBlock = false) {
2127 bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext());
2128 if (Param->getType()->isDependentType() ||
2129 !Param->getType()->isBlockPointerType()) {
2130 // The argument for a dependent or non-block parameter is a placeholder
2131 // containing that parameter's type.
2134 if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName)
2135 Result = Param->getIdentifier()->getName();
2137 Param->getType().getAsStringInternal(Result, Policy);
2139 if (ObjCMethodParam) {
2140 Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier())
2142 if (Param->getIdentifier() && !SuppressName)
2143 Result += Param->getIdentifier()->getName();
2148 // The argument for a block pointer parameter is a block literal with
2149 // the appropriate type.
2150 FunctionTypeLoc Block;
2151 FunctionProtoTypeLoc BlockProto;
2153 if (TypeSourceInfo *TSInfo = Param->getTypeSourceInfo()) {
2154 TL = TSInfo->getTypeLoc().getUnqualifiedLoc();
2156 // Look through typedefs.
2157 if (!SuppressBlock) {
2158 if (TypedefTypeLoc TypedefTL = TL.getAs<TypedefTypeLoc>()) {
2159 if (TypeSourceInfo *InnerTSInfo =
2160 TypedefTL.getTypedefNameDecl()->getTypeSourceInfo()) {
2161 TL = InnerTSInfo->getTypeLoc().getUnqualifiedLoc();
2166 // Look through qualified types
2167 if (QualifiedTypeLoc QualifiedTL = TL.getAs<QualifiedTypeLoc>()) {
2168 TL = QualifiedTL.getUnqualifiedLoc();
2173 // Try to get the function prototype behind the block pointer type,
2175 if (BlockPointerTypeLoc BlockPtr = TL.getAs<BlockPointerTypeLoc>()) {
2176 TL = BlockPtr.getPointeeLoc().IgnoreParens();
2177 Block = TL.getAs<FunctionTypeLoc>();
2178 BlockProto = TL.getAs<FunctionProtoTypeLoc>();
2185 // We were unable to find a FunctionProtoTypeLoc with parameter names
2186 // for the block; just use the parameter type as a placeholder.
2188 if (!ObjCMethodParam && Param->getIdentifier())
2189 Result = Param->getIdentifier()->getName();
2191 Param->getType().getUnqualifiedType().getAsStringInternal(Result, Policy);
2193 if (ObjCMethodParam) {
2194 Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier())
2196 if (Param->getIdentifier())
2197 Result += Param->getIdentifier()->getName();
2203 // We have the function prototype behind the block pointer type, as it was
2204 // written in the source.
2206 QualType ResultType = Block.getTypePtr()->getResultType();
2207 if (!ResultType->isVoidType() || SuppressBlock)
2208 ResultType.getAsStringInternal(Result, Policy);
2210 // Format the parameter list.
2212 if (!BlockProto || Block.getNumArgs() == 0) {
2213 if (BlockProto && BlockProto.getTypePtr()->isVariadic())
2219 for (unsigned I = 0, N = Block.getNumArgs(); I != N; ++I) {
2222 Params += FormatFunctionParameter(Context, Policy, Block.getArg(I),
2223 /*SuppressName=*/false,
2224 /*SuppressBlock=*/true);
2226 if (I == N - 1 && BlockProto.getTypePtr()->isVariadic())
2232 if (SuppressBlock) {
2233 // Format as a parameter.
2234 Result = Result + " (^";
2235 if (Param->getIdentifier())
2236 Result += Param->getIdentifier()->getName();
2240 // Format as a block literal argument.
2241 Result = '^' + Result;
2244 if (Param->getIdentifier())
2245 Result += Param->getIdentifier()->getName();
2251 /// \brief Add function parameter chunks to the given code completion string.
2252 static void AddFunctionParameterChunks(ASTContext &Context,
2253 const PrintingPolicy &Policy,
2254 const FunctionDecl *Function,
2255 CodeCompletionBuilder &Result,
2257 bool InOptional = false) {
2258 bool FirstParameter = true;
2260 for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) {
2261 const ParmVarDecl *Param = Function->getParamDecl(P);
2263 if (Param->hasDefaultArg() && !InOptional) {
2264 // When we see an optional default argument, put that argument and
2265 // the remaining default arguments into a new, optional string.
2266 CodeCompletionBuilder Opt(Result.getAllocator(),
2267 Result.getCodeCompletionTUInfo());
2268 if (!FirstParameter)
2269 Opt.AddChunk(CodeCompletionString::CK_Comma);
2270 AddFunctionParameterChunks(Context, Policy, Function, Opt, P, true);
2271 Result.AddOptionalChunk(Opt.TakeString());
2276 FirstParameter = false;
2278 Result.AddChunk(CodeCompletionString::CK_Comma);
2282 // Format the placeholder string.
2283 std::string PlaceholderStr = FormatFunctionParameter(Context, Policy,
2286 if (Function->isVariadic() && P == N - 1)
2287 PlaceholderStr += ", ...";
2289 // Add the placeholder string.
2290 Result.AddPlaceholderChunk(
2291 Result.getAllocator().CopyString(PlaceholderStr));
2294 if (const FunctionProtoType *Proto
2295 = Function->getType()->getAs<FunctionProtoType>())
2296 if (Proto->isVariadic()) {
2297 if (Proto->getNumArgs() == 0)
2298 Result.AddPlaceholderChunk("...");
2300 MaybeAddSentinel(Context, Function, Result);
2304 /// \brief Add template parameter chunks to the given code completion string.
2305 static void AddTemplateParameterChunks(ASTContext &Context,
2306 const PrintingPolicy &Policy,
2307 const TemplateDecl *Template,
2308 CodeCompletionBuilder &Result,
2309 unsigned MaxParameters = 0,
2311 bool InDefaultArg = false) {
2312 bool FirstParameter = true;
2314 TemplateParameterList *Params = Template->getTemplateParameters();
2315 TemplateParameterList::iterator PEnd = Params->end();
2317 PEnd = Params->begin() + MaxParameters;
2318 for (TemplateParameterList::iterator P = Params->begin() + Start;
2320 bool HasDefaultArg = false;
2321 std::string PlaceholderStr;
2322 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
2323 if (TTP->wasDeclaredWithTypename())
2324 PlaceholderStr = "typename";
2326 PlaceholderStr = "class";
2328 if (TTP->getIdentifier()) {
2329 PlaceholderStr += ' ';
2330 PlaceholderStr += TTP->getIdentifier()->getName();
2333 HasDefaultArg = TTP->hasDefaultArgument();
2334 } else if (NonTypeTemplateParmDecl *NTTP
2335 = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
2336 if (NTTP->getIdentifier())
2337 PlaceholderStr = NTTP->getIdentifier()->getName();
2338 NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
2339 HasDefaultArg = NTTP->hasDefaultArgument();
2341 assert(isa<TemplateTemplateParmDecl>(*P));
2342 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
2344 // Since putting the template argument list into the placeholder would
2345 // be very, very long, we just use an abbreviation.
2346 PlaceholderStr = "template<...> class";
2347 if (TTP->getIdentifier()) {
2348 PlaceholderStr += ' ';
2349 PlaceholderStr += TTP->getIdentifier()->getName();
2352 HasDefaultArg = TTP->hasDefaultArgument();
2355 if (HasDefaultArg && !InDefaultArg) {
2356 // When we see an optional default argument, put that argument and
2357 // the remaining default arguments into a new, optional string.
2358 CodeCompletionBuilder Opt(Result.getAllocator(),
2359 Result.getCodeCompletionTUInfo());
2360 if (!FirstParameter)
2361 Opt.AddChunk(CodeCompletionString::CK_Comma);
2362 AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters,
2363 P - Params->begin(), true);
2364 Result.AddOptionalChunk(Opt.TakeString());
2368 InDefaultArg = false;
2371 FirstParameter = false;
2373 Result.AddChunk(CodeCompletionString::CK_Comma);
2375 // Add the placeholder string.
2376 Result.AddPlaceholderChunk(
2377 Result.getAllocator().CopyString(PlaceholderStr));
2381 /// \brief Add a qualifier to the given code-completion string, if the
2382 /// provided nested-name-specifier is non-NULL.
2384 AddQualifierToCompletionString(CodeCompletionBuilder &Result,
2385 NestedNameSpecifier *Qualifier,
2386 bool QualifierIsInformative,
2387 ASTContext &Context,
2388 const PrintingPolicy &Policy) {
2392 std::string PrintedNNS;
2394 llvm::raw_string_ostream OS(PrintedNNS);
2395 Qualifier->print(OS, Policy);
2397 if (QualifierIsInformative)
2398 Result.AddInformativeChunk(Result.getAllocator().CopyString(PrintedNNS));
2400 Result.AddTextChunk(Result.getAllocator().CopyString(PrintedNNS));
2404 AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result,
2405 const FunctionDecl *Function) {
2406 const FunctionProtoType *Proto
2407 = Function->getType()->getAs<FunctionProtoType>();
2408 if (!Proto || !Proto->getTypeQuals())
2411 // FIXME: Add ref-qualifier!
2413 // Handle single qualifiers without copying
2414 if (Proto->getTypeQuals() == Qualifiers::Const) {
2415 Result.AddInformativeChunk(" const");
2419 if (Proto->getTypeQuals() == Qualifiers::Volatile) {
2420 Result.AddInformativeChunk(" volatile");
2424 if (Proto->getTypeQuals() == Qualifiers::Restrict) {
2425 Result.AddInformativeChunk(" restrict");
2429 // Handle multiple qualifiers.
2430 std::string QualsStr;
2431 if (Proto->isConst())
2432 QualsStr += " const";
2433 if (Proto->isVolatile())
2434 QualsStr += " volatile";
2435 if (Proto->isRestrict())
2436 QualsStr += " restrict";
2437 Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
2440 /// \brief Add the name of the given declaration
2441 static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy,
2442 const NamedDecl *ND,
2443 CodeCompletionBuilder &Result) {
2444 DeclarationName Name = ND->getDeclName();
2448 switch (Name.getNameKind()) {
2449 case DeclarationName::CXXOperatorName: {
2450 const char *OperatorName = 0;
2451 switch (Name.getCXXOverloadedOperator()) {
2453 case OO_Conditional:
2454 case NUM_OVERLOADED_OPERATORS:
2455 OperatorName = "operator";
2458 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2459 case OO_##Name: OperatorName = "operator" Spelling; break;
2460 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2461 #include "clang/Basic/OperatorKinds.def"
2463 case OO_New: OperatorName = "operator new"; break;
2464 case OO_Delete: OperatorName = "operator delete"; break;
2465 case OO_Array_New: OperatorName = "operator new[]"; break;
2466 case OO_Array_Delete: OperatorName = "operator delete[]"; break;
2467 case OO_Call: OperatorName = "operator()"; break;
2468 case OO_Subscript: OperatorName = "operator[]"; break;
2470 Result.AddTypedTextChunk(OperatorName);
2474 case DeclarationName::Identifier:
2475 case DeclarationName::CXXConversionFunctionName:
2476 case DeclarationName::CXXDestructorName:
2477 case DeclarationName::CXXLiteralOperatorName:
2478 Result.AddTypedTextChunk(
2479 Result.getAllocator().CopyString(ND->getNameAsString()));
2482 case DeclarationName::CXXUsingDirective:
2483 case DeclarationName::ObjCZeroArgSelector:
2484 case DeclarationName::ObjCOneArgSelector:
2485 case DeclarationName::ObjCMultiArgSelector:
2488 case DeclarationName::CXXConstructorName: {
2489 CXXRecordDecl *Record = 0;
2490 QualType Ty = Name.getCXXNameType();
2491 if (const RecordType *RecordTy = Ty->getAs<RecordType>())
2492 Record = cast<CXXRecordDecl>(RecordTy->getDecl());
2493 else if (const InjectedClassNameType *InjectedTy
2494 = Ty->getAs<InjectedClassNameType>())
2495 Record = InjectedTy->getDecl();
2497 Result.AddTypedTextChunk(
2498 Result.getAllocator().CopyString(ND->getNameAsString()));
2502 Result.AddTypedTextChunk(
2503 Result.getAllocator().CopyString(Record->getNameAsString()));
2504 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) {
2505 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2506 AddTemplateParameterChunks(Context, Policy, Template, Result);
2507 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2514 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(Sema &S,
2515 CodeCompletionAllocator &Allocator,
2516 CodeCompletionTUInfo &CCTUInfo,
2517 bool IncludeBriefComments) {
2518 return CreateCodeCompletionString(S.Context, S.PP, Allocator, CCTUInfo,
2519 IncludeBriefComments);
2522 /// \brief If possible, create a new code completion string for the given
2525 /// \returns Either a new, heap-allocated code completion string describing
2526 /// how to use this result, or NULL to indicate that the string or name of the
2527 /// result is all that is needed.
2528 CodeCompletionString *
2529 CodeCompletionResult::CreateCodeCompletionString(ASTContext &Ctx,
2531 CodeCompletionAllocator &Allocator,
2532 CodeCompletionTUInfo &CCTUInfo,
2533 bool IncludeBriefComments) {
2534 CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
2536 PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP);
2537 if (Kind == RK_Pattern) {
2538 Pattern->Priority = Priority;
2539 Pattern->Availability = Availability;
2542 Result.addParentContext(Declaration->getDeclContext());
2543 Pattern->ParentName = Result.getParentName();
2544 // Provide code completion comment for self.GetterName where
2545 // GetterName is the getter method for a property with name
2546 // different from the property name (declared via a property
2547 // getter attribute.
2548 const NamedDecl *ND = Declaration;
2549 if (const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(ND))
2550 if (M->isPropertyAccessor())
2551 if (const ObjCPropertyDecl *PDecl = M->findPropertyDecl())
2552 if (PDecl->getGetterName() == M->getSelector() &&
2553 PDecl->getIdentifier() != M->getIdentifier()) {
2554 if (const RawComment *RC =
2555 Ctx.getRawCommentForAnyRedecl(M)) {
2556 Result.addBriefComment(RC->getBriefText(Ctx));
2557 Pattern->BriefComment = Result.getBriefComment();
2559 else if (const RawComment *RC =
2560 Ctx.getRawCommentForAnyRedecl(PDecl)) {
2561 Result.addBriefComment(RC->getBriefText(Ctx));
2562 Pattern->BriefComment = Result.getBriefComment();
2570 if (Kind == RK_Keyword) {
2571 Result.AddTypedTextChunk(Keyword);
2572 return Result.TakeString();
2575 if (Kind == RK_Macro) {
2576 const MacroDirective *MD = PP.getMacroDirectiveHistory(Macro);
2577 assert(MD && "Not a macro?");
2578 const MacroInfo *MI = MD->getMacroInfo();
2580 Result.AddTypedTextChunk(
2581 Result.getAllocator().CopyString(Macro->getName()));
2583 if (!MI->isFunctionLike())
2584 return Result.TakeString();
2586 // Format a function-like macro with placeholders for the arguments.
2587 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2588 MacroInfo::arg_iterator A = MI->arg_begin(), AEnd = MI->arg_end();
2590 // C99 variadic macros add __VA_ARGS__ at the end. Skip it.
2591 if (MI->isC99Varargs()) {
2595 Result.AddPlaceholderChunk("...");
2599 for (MacroInfo::arg_iterator A = MI->arg_begin(); A != AEnd; ++A) {
2600 if (A != MI->arg_begin())
2601 Result.AddChunk(CodeCompletionString::CK_Comma);
2603 if (MI->isVariadic() && (A+1) == AEnd) {
2604 SmallString<32> Arg = (*A)->getName();
2605 if (MI->isC99Varargs())
2609 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
2613 // Non-variadic macros are simple.
2614 Result.AddPlaceholderChunk(
2615 Result.getAllocator().CopyString((*A)->getName()));
2617 Result.AddChunk(CodeCompletionString::CK_RightParen);
2618 return Result.TakeString();
2621 assert(Kind == RK_Declaration && "Missed a result kind?");
2622 const NamedDecl *ND = Declaration;
2623 Result.addParentContext(ND->getDeclContext());
2625 if (IncludeBriefComments) {
2626 // Add documentation comment, if it exists.
2627 if (const RawComment *RC = Ctx.getRawCommentForAnyRedecl(ND)) {
2628 Result.addBriefComment(RC->getBriefText(Ctx));
2630 else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND))
2631 if (OMD->isPropertyAccessor())
2632 if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())
2633 if (const RawComment *RC = Ctx.getRawCommentForAnyRedecl(PDecl))
2634 Result.addBriefComment(RC->getBriefText(Ctx));
2637 if (StartsNestedNameSpecifier) {
2638 Result.AddTypedTextChunk(
2639 Result.getAllocator().CopyString(ND->getNameAsString()));
2640 Result.AddTextChunk("::");
2641 return Result.TakeString();
2644 for (Decl::attr_iterator i = ND->attr_begin(); i != ND->attr_end(); ++i) {
2645 if (AnnotateAttr *Attr = dyn_cast_or_null<AnnotateAttr>(*i)) {
2646 Result.AddAnnotation(Result.getAllocator().CopyString(Attr->getAnnotation()));
2650 AddResultTypeChunk(Ctx, Policy, ND, Result);
2652 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) {
2653 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2655 AddTypedNameChunk(Ctx, Policy, ND, Result);
2656 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2657 AddFunctionParameterChunks(Ctx, Policy, Function, Result);
2658 Result.AddChunk(CodeCompletionString::CK_RightParen);
2659 AddFunctionTypeQualsToCompletionString(Result, Function);
2660 return Result.TakeString();
2663 if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) {
2664 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2666 FunctionDecl *Function = FunTmpl->getTemplatedDecl();
2667 AddTypedNameChunk(Ctx, Policy, Function, Result);
2669 // Figure out which template parameters are deduced (or have default
2671 llvm::SmallBitVector Deduced;
2672 Sema::MarkDeducedTemplateParameters(Ctx, FunTmpl, Deduced);
2673 unsigned LastDeducibleArgument;
2674 for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0;
2675 --LastDeducibleArgument) {
2676 if (!Deduced[LastDeducibleArgument - 1]) {
2677 // C++0x: Figure out if the template argument has a default. If so,
2678 // the user doesn't need to type this argument.
2679 // FIXME: We need to abstract template parameters better!
2680 bool HasDefaultArg = false;
2681 NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam(
2682 LastDeducibleArgument - 1);
2683 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
2684 HasDefaultArg = TTP->hasDefaultArgument();
2685 else if (NonTypeTemplateParmDecl *NTTP
2686 = dyn_cast<NonTypeTemplateParmDecl>(Param))
2687 HasDefaultArg = NTTP->hasDefaultArgument();
2689 assert(isa<TemplateTemplateParmDecl>(Param));
2691 = cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument();
2699 if (LastDeducibleArgument) {
2700 // Some of the function template arguments cannot be deduced from a
2701 // function call, so we introduce an explicit template argument list
2702 // containing all of the arguments up to the first deducible argument.
2703 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2704 AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result,
2705 LastDeducibleArgument);
2706 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2709 // Add the function parameters
2710 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2711 AddFunctionParameterChunks(Ctx, Policy, Function, Result);
2712 Result.AddChunk(CodeCompletionString::CK_RightParen);
2713 AddFunctionTypeQualsToCompletionString(Result, Function);
2714 return Result.TakeString();
2717 if (const TemplateDecl *Template = dyn_cast<TemplateDecl>(ND)) {
2718 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2720 Result.AddTypedTextChunk(
2721 Result.getAllocator().CopyString(Template->getNameAsString()));
2722 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2723 AddTemplateParameterChunks(Ctx, Policy, Template, Result);
2724 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2725 return Result.TakeString();
2728 if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2729 Selector Sel = Method->getSelector();
2730 if (Sel.isUnarySelector()) {
2731 Result.AddTypedTextChunk(Result.getAllocator().CopyString(
2732 Sel.getNameForSlot(0)));
2733 return Result.TakeString();
2736 std::string SelName = Sel.getNameForSlot(0).str();
2738 if (StartParameter == 0)
2739 Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName));
2741 Result.AddInformativeChunk(Result.getAllocator().CopyString(SelName));
2743 // If there is only one parameter, and we're past it, add an empty
2744 // typed-text chunk since there is nothing to type.
2745 if (Method->param_size() == 1)
2746 Result.AddTypedTextChunk("");
2749 for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(),
2750 PEnd = Method->param_end();
2751 P != PEnd; (void)++P, ++Idx) {
2753 std::string Keyword;
2754 if (Idx > StartParameter)
2755 Result.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2756 if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx))
2757 Keyword += II->getName();
2759 if (Idx < StartParameter || AllParametersAreInformative)
2760 Result.AddInformativeChunk(Result.getAllocator().CopyString(Keyword));
2762 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Keyword));
2765 // If we're before the starting parameter, skip the placeholder.
2766 if (Idx < StartParameter)
2771 if ((*P)->getType()->isBlockPointerType() && !DeclaringEntity)
2772 Arg = FormatFunctionParameter(Ctx, Policy, *P, true);
2774 (*P)->getType().getAsStringInternal(Arg, Policy);
2775 Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier())
2777 if (IdentifierInfo *II = (*P)->getIdentifier())
2778 if (DeclaringEntity || AllParametersAreInformative)
2779 Arg += II->getName();
2782 if (Method->isVariadic() && (P + 1) == PEnd)
2785 if (DeclaringEntity)
2786 Result.AddTextChunk(Result.getAllocator().CopyString(Arg));
2787 else if (AllParametersAreInformative)
2788 Result.AddInformativeChunk(Result.getAllocator().CopyString(Arg));
2790 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
2793 if (Method->isVariadic()) {
2794 if (Method->param_size() == 0) {
2795 if (DeclaringEntity)
2796 Result.AddTextChunk(", ...");
2797 else if (AllParametersAreInformative)
2798 Result.AddInformativeChunk(", ...");
2800 Result.AddPlaceholderChunk(", ...");
2803 MaybeAddSentinel(Ctx, Method, Result);
2806 return Result.TakeString();
2810 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2813 Result.AddTypedTextChunk(
2814 Result.getAllocator().CopyString(ND->getNameAsString()));
2815 return Result.TakeString();
2818 CodeCompletionString *
2819 CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
2820 unsigned CurrentArg,
2822 CodeCompletionAllocator &Allocator,
2823 CodeCompletionTUInfo &CCTUInfo) const {
2824 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
2826 // FIXME: Set priority, availability appropriately.
2827 CodeCompletionBuilder Result(Allocator,CCTUInfo, 1, CXAvailability_Available);
2828 FunctionDecl *FDecl = getFunction();
2829 AddResultTypeChunk(S.Context, Policy, FDecl, Result);
2830 const FunctionProtoType *Proto
2831 = dyn_cast<FunctionProtoType>(getFunctionType());
2832 if (!FDecl && !Proto) {
2833 // Function without a prototype. Just give the return type and a
2834 // highlighted ellipsis.
2835 const FunctionType *FT = getFunctionType();
2836 Result.AddTextChunk(GetCompletionTypeString(FT->getResultType(),
2838 Result.getAllocator()));
2839 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2840 Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
2841 Result.AddChunk(CodeCompletionString::CK_RightParen);
2842 return Result.TakeString();
2846 Result.AddTextChunk(
2847 Result.getAllocator().CopyString(FDecl->getNameAsString()));
2849 Result.AddTextChunk(
2850 Result.getAllocator().CopyString(
2851 Proto->getResultType().getAsString(Policy)));
2853 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2854 unsigned NumParams = FDecl? FDecl->getNumParams() : Proto->getNumArgs();
2855 for (unsigned I = 0; I != NumParams; ++I) {
2857 Result.AddChunk(CodeCompletionString::CK_Comma);
2859 std::string ArgString;
2863 ArgString = FDecl->getParamDecl(I)->getNameAsString();
2864 ArgType = FDecl->getParamDecl(I)->getOriginalType();
2866 ArgType = Proto->getArgType(I);
2869 ArgType.getAsStringInternal(ArgString, Policy);
2871 if (I == CurrentArg)
2872 Result.AddChunk(CodeCompletionString::CK_CurrentParameter,
2873 Result.getAllocator().CopyString(ArgString));
2875 Result.AddTextChunk(Result.getAllocator().CopyString(ArgString));
2878 if (Proto && Proto->isVariadic()) {
2879 Result.AddChunk(CodeCompletionString::CK_Comma);
2880 if (CurrentArg < NumParams)
2881 Result.AddTextChunk("...");
2883 Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
2885 Result.AddChunk(CodeCompletionString::CK_RightParen);
2887 return Result.TakeString();
2890 unsigned clang::getMacroUsagePriority(StringRef MacroName,
2891 const LangOptions &LangOpts,
2892 bool PreferredTypeIsPointer) {
2893 unsigned Priority = CCP_Macro;
2895 // Treat the "nil", "Nil" and "NULL" macros as null pointer constants.
2896 if (MacroName.equals("nil") || MacroName.equals("NULL") ||
2897 MacroName.equals("Nil")) {
2898 Priority = CCP_Constant;
2899 if (PreferredTypeIsPointer)
2900 Priority = Priority / CCF_SimilarTypeMatch;
2902 // Treat "YES", "NO", "true", and "false" as constants.
2903 else if (MacroName.equals("YES") || MacroName.equals("NO") ||
2904 MacroName.equals("true") || MacroName.equals("false"))
2905 Priority = CCP_Constant;
2906 // Treat "bool" as a type.
2907 else if (MacroName.equals("bool"))
2908 Priority = CCP_Type + (LangOpts.ObjC1? CCD_bool_in_ObjC : 0);
2914 CXCursorKind clang::getCursorKindForDecl(const Decl *D) {
2916 return CXCursor_UnexposedDecl;
2918 switch (D->getKind()) {
2919 case Decl::Enum: return CXCursor_EnumDecl;
2920 case Decl::EnumConstant: return CXCursor_EnumConstantDecl;
2921 case Decl::Field: return CXCursor_FieldDecl;
2922 case Decl::Function:
2923 return CXCursor_FunctionDecl;
2924 case Decl::ObjCCategory: return CXCursor_ObjCCategoryDecl;
2925 case Decl::ObjCCategoryImpl: return CXCursor_ObjCCategoryImplDecl;
2926 case Decl::ObjCImplementation: return CXCursor_ObjCImplementationDecl;
2928 case Decl::ObjCInterface: return CXCursor_ObjCInterfaceDecl;
2929 case Decl::ObjCIvar: return CXCursor_ObjCIvarDecl;
2930 case Decl::ObjCMethod:
2931 return cast<ObjCMethodDecl>(D)->isInstanceMethod()
2932 ? CXCursor_ObjCInstanceMethodDecl : CXCursor_ObjCClassMethodDecl;
2933 case Decl::CXXMethod: return CXCursor_CXXMethod;
2934 case Decl::CXXConstructor: return CXCursor_Constructor;
2935 case Decl::CXXDestructor: return CXCursor_Destructor;
2936 case Decl::CXXConversion: return CXCursor_ConversionFunction;
2937 case Decl::ObjCProperty: return CXCursor_ObjCPropertyDecl;
2938 case Decl::ObjCProtocol: return CXCursor_ObjCProtocolDecl;
2939 case Decl::ParmVar: return CXCursor_ParmDecl;
2940 case Decl::Typedef: return CXCursor_TypedefDecl;
2941 case Decl::TypeAlias: return CXCursor_TypeAliasDecl;
2942 case Decl::Var: return CXCursor_VarDecl;
2943 case Decl::Namespace: return CXCursor_Namespace;
2944 case Decl::NamespaceAlias: return CXCursor_NamespaceAlias;
2945 case Decl::TemplateTypeParm: return CXCursor_TemplateTypeParameter;
2946 case Decl::NonTypeTemplateParm:return CXCursor_NonTypeTemplateParameter;
2947 case Decl::TemplateTemplateParm:return CXCursor_TemplateTemplateParameter;
2948 case Decl::FunctionTemplate: return CXCursor_FunctionTemplate;
2949 case Decl::ClassTemplate: return CXCursor_ClassTemplate;
2950 case Decl::AccessSpec: return CXCursor_CXXAccessSpecifier;
2951 case Decl::ClassTemplatePartialSpecialization:
2952 return CXCursor_ClassTemplatePartialSpecialization;
2953 case Decl::UsingDirective: return CXCursor_UsingDirective;
2954 case Decl::TranslationUnit: return CXCursor_TranslationUnit;
2957 case Decl::UnresolvedUsingValue:
2958 case Decl::UnresolvedUsingTypename:
2959 return CXCursor_UsingDeclaration;
2961 case Decl::ObjCPropertyImpl:
2962 switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
2963 case ObjCPropertyImplDecl::Dynamic:
2964 return CXCursor_ObjCDynamicDecl;
2966 case ObjCPropertyImplDecl::Synthesize:
2967 return CXCursor_ObjCSynthesizeDecl;
2971 return CXCursor_ModuleImportDecl;
2974 if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
2975 switch (TD->getTagKind()) {
2976 case TTK_Interface: // fall through
2977 case TTK_Struct: return CXCursor_StructDecl;
2978 case TTK_Class: return CXCursor_ClassDecl;
2979 case TTK_Union: return CXCursor_UnionDecl;
2980 case TTK_Enum: return CXCursor_EnumDecl;
2985 return CXCursor_UnexposedDecl;
2988 static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results,
2989 bool IncludeUndefined,
2990 bool TargetTypeIsPointer = false) {
2991 typedef CodeCompletionResult Result;
2993 Results.EnterNewScope();
2995 for (Preprocessor::macro_iterator M = PP.macro_begin(),
2996 MEnd = PP.macro_end();
2998 if (IncludeUndefined || M->first->hasMacroDefinition())
2999 Results.AddResult(Result(M->first,
3000 getMacroUsagePriority(M->first->getName(),
3002 TargetTypeIsPointer)));
3005 Results.ExitScope();
3009 static void AddPrettyFunctionResults(const LangOptions &LangOpts,
3010 ResultBuilder &Results) {
3011 typedef CodeCompletionResult Result;
3013 Results.EnterNewScope();
3015 Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant));
3016 Results.AddResult(Result("__FUNCTION__", CCP_Constant));
3017 if (LangOpts.C99 || LangOpts.CPlusPlus11)
3018 Results.AddResult(Result("__func__", CCP_Constant));
3019 Results.ExitScope();
3022 static void HandleCodeCompleteResults(Sema *S,
3023 CodeCompleteConsumer *CodeCompleter,
3024 CodeCompletionContext Context,
3025 CodeCompletionResult *Results,
3026 unsigned NumResults) {
3028 CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults);
3031 static enum CodeCompletionContext::Kind mapCodeCompletionContext(Sema &S,
3032 Sema::ParserCompletionContext PCC) {
3034 case Sema::PCC_Namespace:
3035 return CodeCompletionContext::CCC_TopLevel;
3037 case Sema::PCC_Class:
3038 return CodeCompletionContext::CCC_ClassStructUnion;
3040 case Sema::PCC_ObjCInterface:
3041 return CodeCompletionContext::CCC_ObjCInterface;
3043 case Sema::PCC_ObjCImplementation:
3044 return CodeCompletionContext::CCC_ObjCImplementation;
3046 case Sema::PCC_ObjCInstanceVariableList:
3047 return CodeCompletionContext::CCC_ObjCIvarList;
3049 case Sema::PCC_Template:
3050 case Sema::PCC_MemberTemplate:
3051 if (S.CurContext->isFileContext())
3052 return CodeCompletionContext::CCC_TopLevel;
3053 if (S.CurContext->isRecord())
3054 return CodeCompletionContext::CCC_ClassStructUnion;
3055 return CodeCompletionContext::CCC_Other;
3057 case Sema::PCC_RecoveryInFunction:
3058 return CodeCompletionContext::CCC_Recovery;
3060 case Sema::PCC_ForInit:
3061 if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 ||
3062 S.getLangOpts().ObjC1)
3063 return CodeCompletionContext::CCC_ParenthesizedExpression;
3065 return CodeCompletionContext::CCC_Expression;
3067 case Sema::PCC_Expression:
3068 case Sema::PCC_Condition:
3069 return CodeCompletionContext::CCC_Expression;
3071 case Sema::PCC_Statement:
3072 return CodeCompletionContext::CCC_Statement;
3074 case Sema::PCC_Type:
3075 return CodeCompletionContext::CCC_Type;
3077 case Sema::PCC_ParenthesizedExpression:
3078 return CodeCompletionContext::CCC_ParenthesizedExpression;
3080 case Sema::PCC_LocalDeclarationSpecifiers:
3081 return CodeCompletionContext::CCC_Type;
3084 llvm_unreachable("Invalid ParserCompletionContext!");
3087 /// \brief If we're in a C++ virtual member function, add completion results
3088 /// that invoke the functions we override, since it's common to invoke the
3089 /// overridden function as well as adding new functionality.
3091 /// \param S The semantic analysis object for which we are generating results.
3093 /// \param InContext This context in which the nested-name-specifier preceding
3094 /// the code-completion point
3095 static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext,
3096 ResultBuilder &Results) {
3097 // Look through blocks.
3098 DeclContext *CurContext = S.CurContext;
3099 while (isa<BlockDecl>(CurContext))
3100 CurContext = CurContext->getParent();
3103 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext);
3104 if (!Method || !Method->isVirtual())
3107 // We need to have names for all of the parameters, if we're going to
3108 // generate a forwarding call.
3109 for (CXXMethodDecl::param_iterator P = Method->param_begin(),
3110 PEnd = Method->param_end();
3113 if (!(*P)->getDeclName())
3117 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
3118 for (CXXMethodDecl::method_iterator M = Method->begin_overridden_methods(),
3119 MEnd = Method->end_overridden_methods();
3121 CodeCompletionBuilder Builder(Results.getAllocator(),
3122 Results.getCodeCompletionTUInfo());
3123 const CXXMethodDecl *Overridden = *M;
3124 if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl())
3127 // If we need a nested-name-specifier, add one now.
3129 NestedNameSpecifier *NNS
3130 = getRequiredQualification(S.Context, CurContext,
3131 Overridden->getDeclContext());
3134 llvm::raw_string_ostream OS(Str);
3135 NNS->print(OS, Policy);
3136 Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
3138 } else if (!InContext->Equals(Overridden->getDeclContext()))
3141 Builder.AddTypedTextChunk(Results.getAllocator().CopyString(
3142 Overridden->getNameAsString()));
3143 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
3144 bool FirstParam = true;
3145 for (CXXMethodDecl::param_iterator P = Method->param_begin(),
3146 PEnd = Method->param_end();
3151 Builder.AddChunk(CodeCompletionString::CK_Comma);
3153 Builder.AddPlaceholderChunk(Results.getAllocator().CopyString(
3154 (*P)->getIdentifier()->getName()));
3156 Builder.AddChunk(CodeCompletionString::CK_RightParen);
3157 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
3158 CCP_SuperCompletion,
3160 CXAvailability_Available,
3162 Results.Ignore(Overridden);
3166 void Sema::CodeCompleteModuleImport(SourceLocation ImportLoc,
3167 ModuleIdPath Path) {
3168 typedef CodeCompletionResult Result;
3169 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3170 CodeCompleter->getCodeCompletionTUInfo(),
3171 CodeCompletionContext::CCC_Other);
3172 Results.EnterNewScope();
3174 CodeCompletionAllocator &Allocator = Results.getAllocator();
3175 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
3176 typedef CodeCompletionResult Result;
3178 // Enumerate all top-level modules.
3179 SmallVector<Module *, 8> Modules;
3180 PP.getHeaderSearchInfo().collectAllModules(Modules);
3181 for (unsigned I = 0, N = Modules.size(); I != N; ++I) {
3182 Builder.AddTypedTextChunk(
3183 Builder.getAllocator().CopyString(Modules[I]->Name));
3184 Results.AddResult(Result(Builder.TakeString(),
3186 CXCursor_NotImplemented,
3187 Modules[I]->isAvailable()
3188 ? CXAvailability_Available
3189 : CXAvailability_NotAvailable));
3192 // Load the named module.
3193 Module *Mod = PP.getModuleLoader().loadModule(ImportLoc, Path,
3195 /*IsInclusionDirective=*/false);
3196 // Enumerate submodules.
3198 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
3199 SubEnd = Mod->submodule_end();
3200 Sub != SubEnd; ++Sub) {
3202 Builder.AddTypedTextChunk(
3203 Builder.getAllocator().CopyString((*Sub)->Name));
3204 Results.AddResult(Result(Builder.TakeString(),
3206 CXCursor_NotImplemented,
3207 (*Sub)->isAvailable()
3208 ? CXAvailability_Available
3209 : CXAvailability_NotAvailable));
3213 Results.ExitScope();
3214 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3215 Results.data(),Results.size());
3218 void Sema::CodeCompleteOrdinaryName(Scope *S,
3219 ParserCompletionContext CompletionContext) {
3220 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3221 CodeCompleter->getCodeCompletionTUInfo(),
3222 mapCodeCompletionContext(*this, CompletionContext));
3223 Results.EnterNewScope();
3225 // Determine how to filter results, e.g., so that the names of
3226 // values (functions, enumerators, function templates, etc.) are
3227 // only allowed where we can have an expression.
3228 switch (CompletionContext) {
3231 case PCC_ObjCInterface:
3232 case PCC_ObjCImplementation:
3233 case PCC_ObjCInstanceVariableList:
3235 case PCC_MemberTemplate:
3237 case PCC_LocalDeclarationSpecifiers:
3238 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
3242 case PCC_ParenthesizedExpression:
3243 case PCC_Expression:
3246 if (WantTypesInContext(CompletionContext, getLangOpts()))
3247 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3249 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3251 if (getLangOpts().CPlusPlus)
3252 MaybeAddOverrideCalls(*this, /*InContext=*/0, Results);
3255 case PCC_RecoveryInFunction:
3260 // If we are in a C++ non-static member function, check the qualifiers on
3261 // the member function to filter/prioritize the results list.
3262 if (CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext))
3263 if (CurMethod->isInstance())
3264 Results.setObjectTypeQualifiers(
3265 Qualifiers::fromCVRMask(CurMethod->getTypeQualifiers()));
3267 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3268 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3269 CodeCompleter->includeGlobals());
3271 AddOrdinaryNameResults(CompletionContext, S, *this, Results);
3272 Results.ExitScope();
3274 switch (CompletionContext) {
3275 case PCC_ParenthesizedExpression:
3276 case PCC_Expression:
3278 case PCC_RecoveryInFunction:
3279 if (S->getFnParent())
3280 AddPrettyFunctionResults(PP.getLangOpts(), Results);
3285 case PCC_ObjCInterface:
3286 case PCC_ObjCImplementation:
3287 case PCC_ObjCInstanceVariableList:
3289 case PCC_MemberTemplate:
3293 case PCC_LocalDeclarationSpecifiers:
3297 if (CodeCompleter->includeMacros())
3298 AddMacroResults(PP, Results, false);
3300 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3301 Results.data(),Results.size());
3304 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
3305 ParsedType Receiver,
3306 IdentifierInfo **SelIdents,
3307 unsigned NumSelIdents,
3308 bool AtArgumentExpression,
3310 ResultBuilder &Results);
3312 void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
3313 bool AllowNonIdentifiers,
3314 bool AllowNestedNameSpecifiers) {
3315 typedef CodeCompletionResult Result;
3316 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3317 CodeCompleter->getCodeCompletionTUInfo(),
3318 AllowNestedNameSpecifiers
3319 ? CodeCompletionContext::CCC_PotentiallyQualifiedName
3320 : CodeCompletionContext::CCC_Name);
3321 Results.EnterNewScope();
3323 // Type qualifiers can come after names.
3324 Results.AddResult(Result("const"));
3325 Results.AddResult(Result("volatile"));
3326 if (getLangOpts().C99)
3327 Results.AddResult(Result("restrict"));
3329 if (getLangOpts().CPlusPlus) {
3330 if (AllowNonIdentifiers) {
3331 Results.AddResult(Result("operator"));
3334 // Add nested-name-specifiers.
3335 if (AllowNestedNameSpecifiers) {
3336 Results.allowNestedNameSpecifiers();
3337 Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy);
3338 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3339 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
3340 CodeCompleter->includeGlobals());
3341 Results.setFilter(0);
3344 Results.ExitScope();
3346 // If we're in a context where we might have an expression (rather than a
3347 // declaration), and what we've seen so far is an Objective-C type that could
3348 // be a receiver of a class message, this may be a class message send with
3349 // the initial opening bracket '[' missing. Add appropriate completions.
3350 if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
3351 DS.getParsedSpecifiers() == DeclSpec::PQ_TypeSpecifier &&
3352 DS.getTypeSpecType() == DeclSpec::TST_typename &&
3353 DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified &&
3354 DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
3355 !DS.isTypeAltiVecVector() &&
3357 (S->getFlags() & Scope::DeclScope) != 0 &&
3358 (S->getFlags() & (Scope::ClassScope | Scope::TemplateParamScope |
3359 Scope::FunctionPrototypeScope |
3360 Scope::AtCatchScope)) == 0) {
3361 ParsedType T = DS.getRepAsType();
3362 if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType())
3363 AddClassMessageCompletions(*this, S, T, 0, 0, false, false, Results);
3366 // Note that we intentionally suppress macro results here, since we do not
3367 // encourage using macros to produce the names of entities.
3369 HandleCodeCompleteResults(this, CodeCompleter,
3370 Results.getCompletionContext(),
3371 Results.data(), Results.size());
3374 struct Sema::CodeCompleteExpressionData {
3375 CodeCompleteExpressionData(QualType PreferredType = QualType())
3376 : PreferredType(PreferredType), IntegralConstantExpression(false),
3377 ObjCCollection(false) { }
3379 QualType PreferredType;
3380 bool IntegralConstantExpression;
3381 bool ObjCCollection;
3382 SmallVector<Decl *, 4> IgnoreDecls;
3385 /// \brief Perform code-completion in an expression context when we know what
3386 /// type we're looking for.
3387 void Sema::CodeCompleteExpression(Scope *S,
3388 const CodeCompleteExpressionData &Data) {
3389 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3390 CodeCompleter->getCodeCompletionTUInfo(),
3391 CodeCompletionContext::CCC_Expression);
3392 if (Data.ObjCCollection)
3393 Results.setFilter(&ResultBuilder::IsObjCCollection);
3394 else if (Data.IntegralConstantExpression)
3395 Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
3396 else if (WantTypesInContext(PCC_Expression, getLangOpts()))
3397 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3399 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3401 if (!Data.PreferredType.isNull())
3402 Results.setPreferredType(Data.PreferredType.getNonReferenceType());
3404 // Ignore any declarations that we were told that we don't care about.
3405 for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I)
3406 Results.Ignore(Data.IgnoreDecls[I]);
3408 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3409 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3410 CodeCompleter->includeGlobals());
3412 Results.EnterNewScope();
3413 AddOrdinaryNameResults(PCC_Expression, S, *this, Results);
3414 Results.ExitScope();
3416 bool PreferredTypeIsPointer = false;
3417 if (!Data.PreferredType.isNull())
3418 PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType()
3419 || Data.PreferredType->isMemberPointerType()
3420 || Data.PreferredType->isBlockPointerType();
3422 if (S->getFnParent() &&
3423 !Data.ObjCCollection &&
3424 !Data.IntegralConstantExpression)
3425 AddPrettyFunctionResults(PP.getLangOpts(), Results);
3427 if (CodeCompleter->includeMacros())
3428 AddMacroResults(PP, Results, false, PreferredTypeIsPointer);
3429 HandleCodeCompleteResults(this, CodeCompleter,
3430 CodeCompletionContext(CodeCompletionContext::CCC_Expression,
3431 Data.PreferredType),
3432 Results.data(),Results.size());
3435 void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E) {
3437 CodeCompleteOrdinaryName(S, PCC_RecoveryInFunction);
3438 else if (getLangOpts().ObjC1)
3439 CodeCompleteObjCInstanceMessage(S, E.take(), 0, 0, false);
3442 /// \brief The set of properties that have already been added, referenced by
3444 typedef llvm::SmallPtrSet<IdentifierInfo*, 16> AddedPropertiesSet;
3446 /// \brief Retrieve the container definition, if any?
3447 static ObjCContainerDecl *getContainerDef(ObjCContainerDecl *Container) {
3448 if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
3449 if (Interface->hasDefinition())
3450 return Interface->getDefinition();
3455 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3456 if (Protocol->hasDefinition())
3457 return Protocol->getDefinition();
3464 static void AddObjCProperties(ObjCContainerDecl *Container,
3465 bool AllowCategories,
3466 bool AllowNullaryMethods,
3467 DeclContext *CurContext,
3468 AddedPropertiesSet &AddedProperties,
3469 ResultBuilder &Results) {
3470 typedef CodeCompletionResult Result;
3472 // Retrieve the definition.
3473 Container = getContainerDef(Container);
3475 // Add properties in this container.
3476 for (ObjCContainerDecl::prop_iterator P = Container->prop_begin(),
3477 PEnd = Container->prop_end();
3480 if (AddedProperties.insert(P->getIdentifier()))
3481 Results.MaybeAddResult(Result(*P, Results.getBasePriority(*P), 0),
3485 // Add nullary methods
3486 if (AllowNullaryMethods) {
3487 ASTContext &Context = Container->getASTContext();
3488 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
3489 for (ObjCContainerDecl::method_iterator M = Container->meth_begin(),
3490 MEnd = Container->meth_end();
3492 if (M->getSelector().isUnarySelector())
3493 if (IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0))
3494 if (AddedProperties.insert(Name)) {
3495 CodeCompletionBuilder Builder(Results.getAllocator(),
3496 Results.getCodeCompletionTUInfo());
3497 AddResultTypeChunk(Context, Policy, *M, Builder);
3498 Builder.AddTypedTextChunk(
3499 Results.getAllocator().CopyString(Name->getName()));
3501 Results.MaybeAddResult(Result(Builder.TakeString(), *M,
3502 CCP_MemberDeclaration + CCD_MethodAsProperty),
3509 // Add properties in referenced protocols.
3510 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3511 for (ObjCProtocolDecl::protocol_iterator P = Protocol->protocol_begin(),
3512 PEnd = Protocol->protocol_end();
3514 AddObjCProperties(*P, AllowCategories, AllowNullaryMethods, CurContext,
3515 AddedProperties, Results);
3516 } else if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)){
3517 if (AllowCategories) {
3518 // Look through categories.
3519 for (ObjCInterfaceDecl::known_categories_iterator
3520 Cat = IFace->known_categories_begin(),
3521 CatEnd = IFace->known_categories_end();
3522 Cat != CatEnd; ++Cat)
3523 AddObjCProperties(*Cat, AllowCategories, AllowNullaryMethods,
3524 CurContext, AddedProperties, Results);
3527 // Look through protocols.
3528 for (ObjCInterfaceDecl::all_protocol_iterator
3529 I = IFace->all_referenced_protocol_begin(),
3530 E = IFace->all_referenced_protocol_end(); I != E; ++I)
3531 AddObjCProperties(*I, AllowCategories, AllowNullaryMethods, CurContext,
3532 AddedProperties, Results);
3534 // Look in the superclass.
3535 if (IFace->getSuperClass())
3536 AddObjCProperties(IFace->getSuperClass(), AllowCategories,
3537 AllowNullaryMethods, CurContext,
3538 AddedProperties, Results);
3539 } else if (const ObjCCategoryDecl *Category
3540 = dyn_cast<ObjCCategoryDecl>(Container)) {
3541 // Look through protocols.
3542 for (ObjCCategoryDecl::protocol_iterator P = Category->protocol_begin(),
3543 PEnd = Category->protocol_end();
3545 AddObjCProperties(*P, AllowCategories, AllowNullaryMethods, CurContext,
3546 AddedProperties, Results);
3550 void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
3551 SourceLocation OpLoc,
3553 if (!Base || !CodeCompleter)
3556 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
3557 if (ConvertedBase.isInvalid())
3559 Base = ConvertedBase.get();
3561 typedef CodeCompletionResult Result;
3563 QualType BaseType = Base->getType();
3566 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
3567 BaseType = Ptr->getPointeeType();
3568 else if (BaseType->isObjCObjectPointerType())
3574 enum CodeCompletionContext::Kind contextKind;
3577 contextKind = CodeCompletionContext::CCC_ArrowMemberAccess;
3580 if (BaseType->isObjCObjectPointerType() ||
3581 BaseType->isObjCObjectOrInterfaceType()) {
3582 contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess;
3585 contextKind = CodeCompletionContext::CCC_DotMemberAccess;
3589 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3590 CodeCompleter->getCodeCompletionTUInfo(),
3591 CodeCompletionContext(contextKind,
3593 &ResultBuilder::IsMember);
3594 Results.EnterNewScope();
3595 if (const RecordType *Record = BaseType->getAs<RecordType>()) {
3596 // Indicate that we are performing a member access, and the cv-qualifiers
3597 // for the base object type.
3598 Results.setObjectTypeQualifiers(BaseType.getQualifiers());
3600 // Access to a C/C++ class, struct, or union.
3601 Results.allowNestedNameSpecifiers();
3602 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3603 LookupVisibleDecls(Record->getDecl(), LookupMemberName, Consumer,
3604 CodeCompleter->includeGlobals());
3606 if (getLangOpts().CPlusPlus) {
3607 if (!Results.empty()) {
3608 // The "template" keyword can follow "->" or "." in the grammar.
3609 // However, we only want to suggest the template keyword if something
3611 bool IsDependent = BaseType->isDependentType();
3613 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent())
3614 if (DeclContext *Ctx = (DeclContext *)DepScope->getEntity()) {
3615 IsDependent = Ctx->isDependentContext();
3621 Results.AddResult(Result("template"));
3624 } else if (!IsArrow && BaseType->getAsObjCInterfacePointerType()) {
3625 // Objective-C property reference.
3626 AddedPropertiesSet AddedProperties;
3628 // Add property results based on our interface.
3629 const ObjCObjectPointerType *ObjCPtr
3630 = BaseType->getAsObjCInterfacePointerType();
3631 assert(ObjCPtr && "Non-NULL pointer guaranteed above!");
3632 AddObjCProperties(ObjCPtr->getInterfaceDecl(), true,
3633 /*AllowNullaryMethods=*/true, CurContext,
3634 AddedProperties, Results);
3636 // Add properties from the protocols in a qualified interface.
3637 for (ObjCObjectPointerType::qual_iterator I = ObjCPtr->qual_begin(),
3638 E = ObjCPtr->qual_end();
3640 AddObjCProperties(*I, true, /*AllowNullaryMethods=*/true, CurContext,
3641 AddedProperties, Results);
3642 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) ||
3643 (!IsArrow && BaseType->isObjCObjectType())) {
3644 // Objective-C instance variable access.
3645 ObjCInterfaceDecl *Class = 0;
3646 if (const ObjCObjectPointerType *ObjCPtr
3647 = BaseType->getAs<ObjCObjectPointerType>())
3648 Class = ObjCPtr->getInterfaceDecl();
3650 Class = BaseType->getAs<ObjCObjectType>()->getInterface();
3652 // Add all ivars from this class and its superclasses.
3654 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3655 Results.setFilter(&ResultBuilder::IsObjCIvar);
3656 LookupVisibleDecls(Class, LookupMemberName, Consumer,
3657 CodeCompleter->includeGlobals());
3661 // FIXME: How do we cope with isa?
3663 Results.ExitScope();
3665 // Hand off the results found for code completion.
3666 HandleCodeCompleteResults(this, CodeCompleter,
3667 Results.getCompletionContext(),
3668 Results.data(),Results.size());
3671 void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) {
3675 ResultBuilder::LookupFilter Filter = 0;
3676 enum CodeCompletionContext::Kind ContextKind
3677 = CodeCompletionContext::CCC_Other;
3678 switch ((DeclSpec::TST)TagSpec) {
3679 case DeclSpec::TST_enum:
3680 Filter = &ResultBuilder::IsEnum;
3681 ContextKind = CodeCompletionContext::CCC_EnumTag;
3684 case DeclSpec::TST_union:
3685 Filter = &ResultBuilder::IsUnion;
3686 ContextKind = CodeCompletionContext::CCC_UnionTag;
3689 case DeclSpec::TST_struct:
3690 case DeclSpec::TST_class:
3691 case DeclSpec::TST_interface:
3692 Filter = &ResultBuilder::IsClassOrStruct;
3693 ContextKind = CodeCompletionContext::CCC_ClassOrStructTag;
3697 llvm_unreachable("Unknown type specifier kind in CodeCompleteTag");
3700 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3701 CodeCompleter->getCodeCompletionTUInfo(), ContextKind);
3702 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3704 // First pass: look for tags.
3705 Results.setFilter(Filter);
3706 LookupVisibleDecls(S, LookupTagName, Consumer,
3707 CodeCompleter->includeGlobals());
3709 if (CodeCompleter->includeGlobals()) {
3710 // Second pass: look for nested name specifiers.
3711 Results.setFilter(&ResultBuilder::IsNestedNameSpecifier);
3712 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer);
3715 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3716 Results.data(),Results.size());
3719 void Sema::CodeCompleteTypeQualifiers(DeclSpec &DS) {
3720 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3721 CodeCompleter->getCodeCompletionTUInfo(),
3722 CodeCompletionContext::CCC_TypeQualifiers);
3723 Results.EnterNewScope();
3724 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
3725 Results.AddResult("const");
3726 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile))
3727 Results.AddResult("volatile");
3728 if (getLangOpts().C99 &&
3729 !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict))
3730 Results.AddResult("restrict");
3731 if (getLangOpts().C11 &&
3732 !(DS.getTypeQualifiers() & DeclSpec::TQ_atomic))
3733 Results.AddResult("_Atomic");
3734 Results.ExitScope();
3735 HandleCodeCompleteResults(this, CodeCompleter,
3736 Results.getCompletionContext(),
3737 Results.data(), Results.size());
3740 void Sema::CodeCompleteCase(Scope *S) {
3741 if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
3744 SwitchStmt *Switch = getCurFunction()->SwitchStack.back();
3745 QualType type = Switch->getCond()->IgnoreImplicit()->getType();
3746 if (!type->isEnumeralType()) {
3747 CodeCompleteExpressionData Data(type);
3748 Data.IntegralConstantExpression = true;
3749 CodeCompleteExpression(S, Data);
3753 // Code-complete the cases of a switch statement over an enumeration type
3754 // by providing the list of
3755 EnumDecl *Enum = type->castAs<EnumType>()->getDecl();
3756 if (EnumDecl *Def = Enum->getDefinition())
3759 // Determine which enumerators we have already seen in the switch statement.
3760 // FIXME: Ideally, we would also be able to look *past* the code-completion
3761 // token, in case we are code-completing in the middle of the switch and not
3762 // at the end. However, we aren't able to do so at the moment.
3763 llvm::SmallPtrSet<EnumConstantDecl *, 8> EnumeratorsSeen;
3764 NestedNameSpecifier *Qualifier = 0;
3765 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC;
3766 SC = SC->getNextSwitchCase()) {
3767 CaseStmt *Case = dyn_cast<CaseStmt>(SC);
3771 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
3772 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CaseVal))
3773 if (EnumConstantDecl *Enumerator
3774 = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
3775 // We look into the AST of the case statement to determine which
3776 // enumerator was named. Alternatively, we could compute the value of
3777 // the integral constant expression, then compare it against the
3778 // values of each enumerator. However, value-based approach would not
3779 // work as well with C++ templates where enumerators declared within a
3780 // template are type- and value-dependent.
3781 EnumeratorsSeen.insert(Enumerator);
3783 // If this is a qualified-id, keep track of the nested-name-specifier
3784 // so that we can reproduce it as part of code completion, e.g.,
3786 // switch (TagD.getKind()) {
3787 // case TagDecl::TK_enum:
3791 // At the XXX, our completions are TagDecl::TK_union,
3792 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union,
3793 // TK_struct, and TK_class.
3794 Qualifier = DRE->getQualifier();
3798 if (getLangOpts().CPlusPlus && !Qualifier && EnumeratorsSeen.empty()) {
3799 // If there are no prior enumerators in C++, check whether we have to
3800 // qualify the names of the enumerators that we suggest, because they
3801 // may not be visible in this scope.
3802 Qualifier = getRequiredQualification(Context, CurContext, Enum);
3805 // Add any enumerators that have not yet been mentioned.
3806 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3807 CodeCompleter->getCodeCompletionTUInfo(),
3808 CodeCompletionContext::CCC_Expression);
3809 Results.EnterNewScope();
3810 for (EnumDecl::enumerator_iterator E = Enum->enumerator_begin(),
3811 EEnd = Enum->enumerator_end();
3813 if (EnumeratorsSeen.count(*E))
3816 CodeCompletionResult R(*E, CCP_EnumInCase, Qualifier);
3817 Results.AddResult(R, CurContext, 0, false);
3819 Results.ExitScope();
3821 //We need to make sure we're setting the right context,
3822 //so only say we include macros if the code completer says we do
3823 enum CodeCompletionContext::Kind kind = CodeCompletionContext::CCC_Other;
3824 if (CodeCompleter->includeMacros()) {
3825 AddMacroResults(PP, Results, false);
3826 kind = CodeCompletionContext::CCC_OtherWithMacros;
3829 HandleCodeCompleteResults(this, CodeCompleter,
3831 Results.data(),Results.size());
3835 struct IsBetterOverloadCandidate {
3840 explicit IsBetterOverloadCandidate(Sema &S, SourceLocation Loc)
3841 : S(S), Loc(Loc) { }
3844 operator()(const OverloadCandidate &X, const OverloadCandidate &Y) const {
3845 return isBetterOverloadCandidate(S, X, Y, Loc);
3850 static bool anyNullArguments(llvm::ArrayRef<Expr*> Args) {
3851 if (Args.size() && !Args.data())
3854 for (unsigned I = 0; I != Args.size(); ++I)
3861 void Sema::CodeCompleteCall(Scope *S, Expr *FnIn,
3862 llvm::ArrayRef<Expr *> Args) {
3866 // When we're code-completing for a call, we fall back to ordinary
3867 // name code-completion whenever we can't produce specific
3868 // results. We may want to revisit this strategy in the future,
3869 // e.g., by merging the two kinds of results.
3871 Expr *Fn = (Expr *)FnIn;
3873 // Ignore type-dependent call expressions entirely.
3874 if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args) ||
3875 Expr::hasAnyTypeDependentArguments(Args)) {
3876 CodeCompleteOrdinaryName(S, PCC_Expression);
3880 // Build an overload candidate set based on the functions we find.
3881 SourceLocation Loc = Fn->getExprLoc();
3882 OverloadCandidateSet CandidateSet(Loc);
3884 // FIXME: What if we're calling something that isn't a function declaration?
3885 // FIXME: What if we're calling a pseudo-destructor?
3886 // FIXME: What if we're calling a member function?
3888 typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate;
3889 SmallVector<ResultCandidate, 8> Results;
3891 Expr *NakedFn = Fn->IgnoreParenCasts();
3892 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn))
3893 AddOverloadedCallCandidates(ULE, Args, CandidateSet,
3894 /*PartialOverloading=*/ true);
3895 else if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(NakedFn)) {
3896 FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
3898 if (!getLangOpts().CPlusPlus ||
3899 !FDecl->getType()->getAs<FunctionProtoType>())
3900 Results.push_back(ResultCandidate(FDecl));
3903 AddOverloadCandidate(FDecl, DeclAccessPair::make(FDecl, AS_none), Args,
3904 CandidateSet, false, /*PartialOverloading*/true);
3910 if (!CandidateSet.empty()) {
3911 // Sort the overload candidate set by placing the best overloads first.
3912 std::stable_sort(CandidateSet.begin(), CandidateSet.end(),
3913 IsBetterOverloadCandidate(*this, Loc));
3915 // Add the remaining viable overload candidates as code-completion reslults.
3916 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(),
3917 CandEnd = CandidateSet.end();
3918 Cand != CandEnd; ++Cand) {
3920 Results.push_back(ResultCandidate(Cand->Function));
3923 // From the viable candidates, try to determine the type of this parameter.
3924 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
3925 if (const FunctionType *FType = Results[I].getFunctionType())
3926 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FType))
3927 if (Args.size() < Proto->getNumArgs()) {
3928 if (ParamType.isNull())
3929 ParamType = Proto->getArgType(Args.size());
3930 else if (!Context.hasSameUnqualifiedType(
3931 ParamType.getNonReferenceType(),
3932 Proto->getArgType(Args.size()).getNonReferenceType())) {
3933 ParamType = QualType();
3939 // Try to determine the parameter type from the type of the expression
3941 QualType FunctionType = Fn->getType();
3942 if (const PointerType *Ptr = FunctionType->getAs<PointerType>())
3943 FunctionType = Ptr->getPointeeType();
3944 else if (const BlockPointerType *BlockPtr
3945 = FunctionType->getAs<BlockPointerType>())
3946 FunctionType = BlockPtr->getPointeeType();
3947 else if (const MemberPointerType *MemPtr
3948 = FunctionType->getAs<MemberPointerType>())
3949 FunctionType = MemPtr->getPointeeType();
3951 if (const FunctionProtoType *Proto
3952 = FunctionType->getAs<FunctionProtoType>()) {
3953 if (Args.size() < Proto->getNumArgs())
3954 ParamType = Proto->getArgType(Args.size());
3958 if (ParamType.isNull())
3959 CodeCompleteOrdinaryName(S, PCC_Expression);
3961 CodeCompleteExpression(S, ParamType);
3963 if (!Results.empty())
3964 CodeCompleter->ProcessOverloadCandidates(*this, Args.size(), Results.data(),
3968 void Sema::CodeCompleteInitializer(Scope *S, Decl *D) {
3969 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D);
3971 CodeCompleteOrdinaryName(S, PCC_Expression);
3975 CodeCompleteExpression(S, VD->getType());
3978 void Sema::CodeCompleteReturn(Scope *S) {
3979 QualType ResultType;
3980 if (isa<BlockDecl>(CurContext)) {
3981 if (BlockScopeInfo *BSI = getCurBlock())
3982 ResultType = BSI->ReturnType;
3983 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(CurContext))
3984 ResultType = Function->getResultType();
3985 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(CurContext))
3986 ResultType = Method->getResultType();
3988 if (ResultType.isNull())
3989 CodeCompleteOrdinaryName(S, PCC_Expression);
3991 CodeCompleteExpression(S, ResultType);
3994 void Sema::CodeCompleteAfterIf(Scope *S) {
3995 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3996 CodeCompleter->getCodeCompletionTUInfo(),
3997 mapCodeCompletionContext(*this, PCC_Statement));
3998 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3999 Results.EnterNewScope();
4001 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4002 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4003 CodeCompleter->includeGlobals());
4005 AddOrdinaryNameResults(PCC_Statement, S, *this, Results);
4008 CodeCompletionBuilder Builder(Results.getAllocator(),
4009 Results.getCodeCompletionTUInfo());
4010 Builder.AddTypedTextChunk("else");
4011 if (Results.includeCodePatterns()) {
4012 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4013 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4014 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4015 Builder.AddPlaceholderChunk("statements");
4016 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4017 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4019 Results.AddResult(Builder.TakeString());
4022 Builder.AddTypedTextChunk("else");
4023 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4024 Builder.AddTextChunk("if");
4025 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4026 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4027 if (getLangOpts().CPlusPlus)
4028 Builder.AddPlaceholderChunk("condition");
4030 Builder.AddPlaceholderChunk("expression");
4031 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4032 if (Results.includeCodePatterns()) {
4033 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4034 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4035 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4036 Builder.AddPlaceholderChunk("statements");
4037 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4038 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4040 Results.AddResult(Builder.TakeString());
4042 Results.ExitScope();
4044 if (S->getFnParent())
4045 AddPrettyFunctionResults(PP.getLangOpts(), Results);
4047 if (CodeCompleter->includeMacros())
4048 AddMacroResults(PP, Results, false);
4050 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4051 Results.data(),Results.size());
4054 void Sema::CodeCompleteAssignmentRHS(Scope *S, Expr *LHS) {
4056 CodeCompleteExpression(S, static_cast<Expr *>(LHS)->getType());
4058 CodeCompleteOrdinaryName(S, PCC_Expression);
4061 void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
4062 bool EnteringContext) {
4063 if (!SS.getScopeRep() || !CodeCompleter)
4066 DeclContext *Ctx = computeDeclContext(SS, EnteringContext);
4070 // Try to instantiate any non-dependent declaration contexts before
4072 if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx))
4075 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4076 CodeCompleter->getCodeCompletionTUInfo(),
4077 CodeCompletionContext::CCC_Name);
4078 Results.EnterNewScope();
4080 // The "template" keyword can follow "::" in the grammar, but only
4081 // put it into the grammar if the nested-name-specifier is dependent.
4082 NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep();
4083 if (!Results.empty() && NNS->isDependent())
4084 Results.AddResult("template");
4086 // Add calls to overridden virtual functions, if there are any.
4088 // FIXME: This isn't wonderful, because we don't know whether we're actually
4089 // in a context that permits expressions. This is a general issue with
4090 // qualified-id completions.
4091 if (!EnteringContext)
4092 MaybeAddOverrideCalls(*this, Ctx, Results);
4093 Results.ExitScope();
4095 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4096 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer);
4098 HandleCodeCompleteResults(this, CodeCompleter,
4099 Results.getCompletionContext(),
4100 Results.data(),Results.size());
4103 void Sema::CodeCompleteUsing(Scope *S) {
4107 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4108 CodeCompleter->getCodeCompletionTUInfo(),
4109 CodeCompletionContext::CCC_PotentiallyQualifiedName,
4110 &ResultBuilder::IsNestedNameSpecifier);
4111 Results.EnterNewScope();
4113 // If we aren't in class scope, we could see the "namespace" keyword.
4114 if (!S->isClassScope())
4115 Results.AddResult(CodeCompletionResult("namespace"));
4117 // After "using", we can see anything that would start a
4118 // nested-name-specifier.
4119 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4120 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4121 CodeCompleter->includeGlobals());
4122 Results.ExitScope();
4124 HandleCodeCompleteResults(this, CodeCompleter,
4125 CodeCompletionContext::CCC_PotentiallyQualifiedName,
4126 Results.data(),Results.size());
4129 void Sema::CodeCompleteUsingDirective(Scope *S) {
4133 // After "using namespace", we expect to see a namespace name or namespace
4135 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4136 CodeCompleter->getCodeCompletionTUInfo(),
4137 CodeCompletionContext::CCC_Namespace,
4138 &ResultBuilder::IsNamespaceOrAlias);
4139 Results.EnterNewScope();
4140 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4141 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4142 CodeCompleter->includeGlobals());
4143 Results.ExitScope();
4144 HandleCodeCompleteResults(this, CodeCompleter,
4145 CodeCompletionContext::CCC_Namespace,
4146 Results.data(),Results.size());
4149 void Sema::CodeCompleteNamespaceDecl(Scope *S) {
4153 DeclContext *Ctx = (DeclContext *)S->getEntity();
4154 if (!S->getParent())
4155 Ctx = Context.getTranslationUnitDecl();
4157 bool SuppressedGlobalResults
4158 = Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx);
4160 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4161 CodeCompleter->getCodeCompletionTUInfo(),
4162 SuppressedGlobalResults
4163 ? CodeCompletionContext::CCC_Namespace
4164 : CodeCompletionContext::CCC_Other,
4165 &ResultBuilder::IsNamespace);
4167 if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) {
4168 // We only want to see those namespaces that have already been defined
4169 // within this scope, because its likely that the user is creating an
4170 // extended namespace declaration. Keep track of the most recent
4171 // definition of each namespace.
4172 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest;
4173 for (DeclContext::specific_decl_iterator<NamespaceDecl>
4174 NS(Ctx->decls_begin()), NSEnd(Ctx->decls_end());
4176 OrigToLatest[NS->getOriginalNamespace()] = *NS;
4178 // Add the most recent definition (or extended definition) of each
4179 // namespace to the list of results.
4180 Results.EnterNewScope();
4181 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator
4182 NS = OrigToLatest.begin(),
4183 NSEnd = OrigToLatest.end();
4185 Results.AddResult(CodeCompletionResult(
4186 NS->second, Results.getBasePriority(NS->second), 0),
4187 CurContext, 0, false);
4188 Results.ExitScope();
4191 HandleCodeCompleteResults(this, CodeCompleter,
4192 Results.getCompletionContext(),
4193 Results.data(),Results.size());
4196 void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) {
4200 // After "namespace", we expect to see a namespace or alias.
4201 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4202 CodeCompleter->getCodeCompletionTUInfo(),
4203 CodeCompletionContext::CCC_Namespace,
4204 &ResultBuilder::IsNamespaceOrAlias);
4205 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4206 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4207 CodeCompleter->includeGlobals());
4208 HandleCodeCompleteResults(this, CodeCompleter,
4209 Results.getCompletionContext(),
4210 Results.data(),Results.size());
4213 void Sema::CodeCompleteOperatorName(Scope *S) {
4217 typedef CodeCompletionResult Result;
4218 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4219 CodeCompleter->getCodeCompletionTUInfo(),
4220 CodeCompletionContext::CCC_Type,
4221 &ResultBuilder::IsType);
4222 Results.EnterNewScope();
4224 // Add the names of overloadable operators.
4225 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4226 if (std::strcmp(Spelling, "?")) \
4227 Results.AddResult(Result(Spelling));
4228 #include "clang/Basic/OperatorKinds.def"
4230 // Add any type names visible from the current scope
4231 Results.allowNestedNameSpecifiers();
4232 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4233 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4234 CodeCompleter->includeGlobals());
4236 // Add any type specifiers
4237 AddTypeSpecifierResults(getLangOpts(), Results);
4238 Results.ExitScope();
4240 HandleCodeCompleteResults(this, CodeCompleter,
4241 CodeCompletionContext::CCC_Type,
4242 Results.data(),Results.size());
4245 void Sema::CodeCompleteConstructorInitializer(Decl *ConstructorD,
4246 CXXCtorInitializer** Initializers,
4247 unsigned NumInitializers) {
4248 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
4249 CXXConstructorDecl *Constructor
4250 = static_cast<CXXConstructorDecl *>(ConstructorD);
4254 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4255 CodeCompleter->getCodeCompletionTUInfo(),
4256 CodeCompletionContext::CCC_PotentiallyQualifiedName);
4257 Results.EnterNewScope();
4259 // Fill in any already-initialized fields or base classes.
4260 llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
4261 llvm::SmallPtrSet<CanQualType, 4> InitializedBases;
4262 for (unsigned I = 0; I != NumInitializers; ++I) {
4263 if (Initializers[I]->isBaseInitializer())
4264 InitializedBases.insert(
4265 Context.getCanonicalType(QualType(Initializers[I]->getBaseClass(), 0)));
4267 InitializedFields.insert(cast<FieldDecl>(
4268 Initializers[I]->getAnyMember()));
4271 // Add completions for base classes.
4272 CodeCompletionBuilder Builder(Results.getAllocator(),
4273 Results.getCodeCompletionTUInfo());
4274 bool SawLastInitializer = (NumInitializers == 0);
4275 CXXRecordDecl *ClassDecl = Constructor->getParent();
4276 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
4277 BaseEnd = ClassDecl->bases_end();
4278 Base != BaseEnd; ++Base) {
4279 if (!InitializedBases.insert(Context.getCanonicalType(Base->getType()))) {
4281 = NumInitializers > 0 &&
4282 Initializers[NumInitializers - 1]->isBaseInitializer() &&
4283 Context.hasSameUnqualifiedType(Base->getType(),
4284 QualType(Initializers[NumInitializers - 1]->getBaseClass(), 0));
4288 Builder.AddTypedTextChunk(
4289 Results.getAllocator().CopyString(
4290 Base->getType().getAsString(Policy)));
4291 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4292 Builder.AddPlaceholderChunk("args");
4293 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4294 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4295 SawLastInitializer? CCP_NextInitializer
4296 : CCP_MemberDeclaration));
4297 SawLastInitializer = false;
4300 // Add completions for virtual base classes.
4301 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(),
4302 BaseEnd = ClassDecl->vbases_end();
4303 Base != BaseEnd; ++Base) {
4304 if (!InitializedBases.insert(Context.getCanonicalType(Base->getType()))) {
4306 = NumInitializers > 0 &&
4307 Initializers[NumInitializers - 1]->isBaseInitializer() &&
4308 Context.hasSameUnqualifiedType(Base->getType(),
4309 QualType(Initializers[NumInitializers - 1]->getBaseClass(), 0));
4313 Builder.AddTypedTextChunk(
4314 Builder.getAllocator().CopyString(
4315 Base->getType().getAsString(Policy)));
4316 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4317 Builder.AddPlaceholderChunk("args");
4318 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4319 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4320 SawLastInitializer? CCP_NextInitializer
4321 : CCP_MemberDeclaration));
4322 SawLastInitializer = false;
4325 // Add completions for members.
4326 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
4327 FieldEnd = ClassDecl->field_end();
4328 Field != FieldEnd; ++Field) {
4329 if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))) {
4331 = NumInitializers > 0 &&
4332 Initializers[NumInitializers - 1]->isAnyMemberInitializer() &&
4333 Initializers[NumInitializers - 1]->getAnyMember() == *Field;
4337 if (!Field->getDeclName())
4340 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
4341 Field->getIdentifier()->getName()));
4342 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4343 Builder.AddPlaceholderChunk("args");
4344 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4345 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4346 SawLastInitializer? CCP_NextInitializer
4347 : CCP_MemberDeclaration,
4349 CXAvailability_Available,
4351 SawLastInitializer = false;
4353 Results.ExitScope();
4355 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4356 Results.data(), Results.size());
4359 /// \brief Determine whether this scope denotes a namespace.
4360 static bool isNamespaceScope(Scope *S) {
4361 DeclContext *DC = static_cast<DeclContext *>(S->getEntity());
4365 return DC->isFileContext();
4368 void Sema::CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
4369 bool AfterAmpersand) {
4370 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4371 CodeCompleter->getCodeCompletionTUInfo(),
4372 CodeCompletionContext::CCC_Other);
4373 Results.EnterNewScope();
4375 // Note what has already been captured.
4376 llvm::SmallPtrSet<IdentifierInfo *, 4> Known;
4377 bool IncludedThis = false;
4378 for (SmallVectorImpl<LambdaCapture>::iterator C = Intro.Captures.begin(),
4379 CEnd = Intro.Captures.end();
4381 if (C->Kind == LCK_This) {
4382 IncludedThis = true;
4386 Known.insert(C->Id);
4389 // Look for other capturable variables.
4390 for (; S && !isNamespaceScope(S); S = S->getParent()) {
4391 for (Scope::decl_iterator D = S->decl_begin(), DEnd = S->decl_end();
4393 VarDecl *Var = dyn_cast<VarDecl>(*D);
4395 !Var->hasLocalStorage() ||
4396 Var->hasAttr<BlocksAttr>())
4399 if (Known.insert(Var->getIdentifier()))
4400 Results.AddResult(CodeCompletionResult(Var, CCP_LocalDeclaration),
4401 CurContext, 0, false);
4405 // Add 'this', if it would be valid.
4406 if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy)
4407 addThisCompletion(*this, Results);
4409 Results.ExitScope();
4411 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4412 Results.data(), Results.size());
4415 /// Macro that optionally prepends an "@" to the string literal passed in via
4416 /// Keyword, depending on whether NeedAt is true or false.
4417 #define OBJC_AT_KEYWORD_NAME(NeedAt,Keyword) ((NeedAt)? "@" Keyword : Keyword)
4419 static void AddObjCImplementationResults(const LangOptions &LangOpts,
4420 ResultBuilder &Results,
4422 typedef CodeCompletionResult Result;
4423 // Since we have an implementation, we can end it.
4424 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
4426 CodeCompletionBuilder Builder(Results.getAllocator(),
4427 Results.getCodeCompletionTUInfo());
4428 if (LangOpts.ObjC2) {
4430 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"dynamic"));
4431 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4432 Builder.AddPlaceholderChunk("property");
4433 Results.AddResult(Result(Builder.TakeString()));
4436 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synthesize"));
4437 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4438 Builder.AddPlaceholderChunk("property");
4439 Results.AddResult(Result(Builder.TakeString()));
4443 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
4444 ResultBuilder &Results,
4446 typedef CodeCompletionResult Result;
4448 // Since we have an interface or protocol, we can end it.
4449 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
4451 if (LangOpts.ObjC2) {
4453 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"property")));
4456 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"required")));
4459 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"optional")));
4463 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
4464 typedef CodeCompletionResult Result;
4465 CodeCompletionBuilder Builder(Results.getAllocator(),
4466 Results.getCodeCompletionTUInfo());
4469 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"class"));
4470 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4471 Builder.AddPlaceholderChunk("name");
4472 Results.AddResult(Result(Builder.TakeString()));
4474 if (Results.includeCodePatterns()) {
4476 // FIXME: Could introduce the whole pattern, including superclasses and
4478 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"interface"));
4479 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4480 Builder.AddPlaceholderChunk("class");
4481 Results.AddResult(Result(Builder.TakeString()));
4484 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
4485 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4486 Builder.AddPlaceholderChunk("protocol");
4487 Results.AddResult(Result(Builder.TakeString()));
4489 // @implementation name
4490 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"implementation"));
4491 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4492 Builder.AddPlaceholderChunk("class");
4493 Results.AddResult(Result(Builder.TakeString()));
4496 // @compatibility_alias name
4497 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"compatibility_alias"));
4498 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4499 Builder.AddPlaceholderChunk("alias");
4500 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4501 Builder.AddPlaceholderChunk("class");
4502 Results.AddResult(Result(Builder.TakeString()));
4504 if (Results.getSema().getLangOpts().Modules) {
4506 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import"));
4507 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4508 Builder.AddPlaceholderChunk("module");
4509 Results.AddResult(Result(Builder.TakeString()));
4513 void Sema::CodeCompleteObjCAtDirective(Scope *S) {
4514 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4515 CodeCompleter->getCodeCompletionTUInfo(),
4516 CodeCompletionContext::CCC_Other);
4517 Results.EnterNewScope();
4518 if (isa<ObjCImplDecl>(CurContext))
4519 AddObjCImplementationResults(getLangOpts(), Results, false);
4520 else if (CurContext->isObjCContainer())
4521 AddObjCInterfaceResults(getLangOpts(), Results, false);
4523 AddObjCTopLevelResults(Results, false);
4524 Results.ExitScope();
4525 HandleCodeCompleteResults(this, CodeCompleter,
4526 CodeCompletionContext::CCC_Other,
4527 Results.data(),Results.size());
4530 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) {
4531 typedef CodeCompletionResult Result;
4532 CodeCompletionBuilder Builder(Results.getAllocator(),
4533 Results.getCodeCompletionTUInfo());
4535 // @encode ( type-name )
4536 const char *EncodeType = "char[]";
4537 if (Results.getSema().getLangOpts().CPlusPlus ||
4538 Results.getSema().getLangOpts().ConstStrings)
4539 EncodeType = "const char[]";
4540 Builder.AddResultTypeChunk(EncodeType);
4541 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"encode"));
4542 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4543 Builder.AddPlaceholderChunk("type-name");
4544 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4545 Results.AddResult(Result(Builder.TakeString()));
4547 // @protocol ( protocol-name )
4548 Builder.AddResultTypeChunk("Protocol *");
4549 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
4550 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4551 Builder.AddPlaceholderChunk("protocol-name");
4552 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4553 Results.AddResult(Result(Builder.TakeString()));
4555 // @selector ( selector )
4556 Builder.AddResultTypeChunk("SEL");
4557 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"selector"));
4558 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4559 Builder.AddPlaceholderChunk("selector");
4560 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4561 Results.AddResult(Result(Builder.TakeString()));
4564 Builder.AddResultTypeChunk("NSString *");
4565 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"\""));
4566 Builder.AddPlaceholderChunk("string");
4567 Builder.AddTextChunk("\"");
4568 Results.AddResult(Result(Builder.TakeString()));
4571 Builder.AddResultTypeChunk("NSArray *");
4572 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"["));
4573 Builder.AddPlaceholderChunk("objects, ...");
4574 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
4575 Results.AddResult(Result(Builder.TakeString()));
4577 // @{key : object, ...}
4578 Builder.AddResultTypeChunk("NSDictionary *");
4579 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"{"));
4580 Builder.AddPlaceholderChunk("key");
4581 Builder.AddChunk(CodeCompletionString::CK_Colon);
4582 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4583 Builder.AddPlaceholderChunk("object, ...");
4584 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4585 Results.AddResult(Result(Builder.TakeString()));
4588 Builder.AddResultTypeChunk("id");
4589 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "("));
4590 Builder.AddPlaceholderChunk("expression");
4591 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4592 Results.AddResult(Result(Builder.TakeString()));
4595 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) {
4596 typedef CodeCompletionResult Result;
4597 CodeCompletionBuilder Builder(Results.getAllocator(),
4598 Results.getCodeCompletionTUInfo());
4600 if (Results.includeCodePatterns()) {
4601 // @try { statements } @catch ( declaration ) { statements } @finally
4603 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"try"));
4604 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4605 Builder.AddPlaceholderChunk("statements");
4606 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4607 Builder.AddTextChunk("@catch");
4608 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4609 Builder.AddPlaceholderChunk("parameter");
4610 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4611 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4612 Builder.AddPlaceholderChunk("statements");
4613 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4614 Builder.AddTextChunk("@finally");
4615 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4616 Builder.AddPlaceholderChunk("statements");
4617 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4618 Results.AddResult(Result(Builder.TakeString()));
4622 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"throw"));
4623 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4624 Builder.AddPlaceholderChunk("expression");
4625 Results.AddResult(Result(Builder.TakeString()));
4627 if (Results.includeCodePatterns()) {
4628 // @synchronized ( expression ) { statements }
4629 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synchronized"));
4630 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4631 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4632 Builder.AddPlaceholderChunk("expression");
4633 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4634 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4635 Builder.AddPlaceholderChunk("statements");
4636 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4637 Results.AddResult(Result(Builder.TakeString()));
4641 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
4642 ResultBuilder &Results,
4644 typedef CodeCompletionResult Result;
4645 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"private")));
4646 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"protected")));
4647 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"public")));
4649 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"package")));
4652 void Sema::CodeCompleteObjCAtVisibility(Scope *S) {
4653 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4654 CodeCompleter->getCodeCompletionTUInfo(),
4655 CodeCompletionContext::CCC_Other);
4656 Results.EnterNewScope();
4657 AddObjCVisibilityResults(getLangOpts(), Results, false);
4658 Results.ExitScope();
4659 HandleCodeCompleteResults(this, CodeCompleter,
4660 CodeCompletionContext::CCC_Other,
4661 Results.data(),Results.size());
4664 void Sema::CodeCompleteObjCAtStatement(Scope *S) {
4665 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4666 CodeCompleter->getCodeCompletionTUInfo(),
4667 CodeCompletionContext::CCC_Other);
4668 Results.EnterNewScope();
4669 AddObjCStatementResults(Results, false);
4670 AddObjCExpressionResults(Results, false);
4671 Results.ExitScope();
4672 HandleCodeCompleteResults(this, CodeCompleter,
4673 CodeCompletionContext::CCC_Other,
4674 Results.data(),Results.size());
4677 void Sema::CodeCompleteObjCAtExpression(Scope *S) {
4678 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4679 CodeCompleter->getCodeCompletionTUInfo(),
4680 CodeCompletionContext::CCC_Other);
4681 Results.EnterNewScope();
4682 AddObjCExpressionResults(Results, false);
4683 Results.ExitScope();
4684 HandleCodeCompleteResults(this, CodeCompleter,
4685 CodeCompletionContext::CCC_Other,
4686 Results.data(),Results.size());
4689 /// \brief Determine whether the addition of the given flag to an Objective-C
4690 /// property's attributes will cause a conflict.
4691 static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) {
4692 // Check if we've already added this flag.
4693 if (Attributes & NewFlag)
4696 Attributes |= NewFlag;
4698 // Check for collisions with "readonly".
4699 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
4700 (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
4703 // Check for more than one of { assign, copy, retain, strong, weak }.
4704 unsigned AssignCopyRetMask = Attributes & (ObjCDeclSpec::DQ_PR_assign |
4705 ObjCDeclSpec::DQ_PR_unsafe_unretained |
4706 ObjCDeclSpec::DQ_PR_copy |
4707 ObjCDeclSpec::DQ_PR_retain |
4708 ObjCDeclSpec::DQ_PR_strong |
4709 ObjCDeclSpec::DQ_PR_weak);
4710 if (AssignCopyRetMask &&
4711 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign &&
4712 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_unsafe_unretained &&
4713 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy &&
4714 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain &&
4715 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_strong &&
4716 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_weak)
4722 void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) {
4726 unsigned Attributes = ODS.getPropertyAttributes();
4728 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4729 CodeCompleter->getCodeCompletionTUInfo(),
4730 CodeCompletionContext::CCC_Other);
4731 Results.EnterNewScope();
4732 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readonly))
4733 Results.AddResult(CodeCompletionResult("readonly"));
4734 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_assign))
4735 Results.AddResult(CodeCompletionResult("assign"));
4736 if (!ObjCPropertyFlagConflicts(Attributes,
4737 ObjCDeclSpec::DQ_PR_unsafe_unretained))
4738 Results.AddResult(CodeCompletionResult("unsafe_unretained"));
4739 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readwrite))
4740 Results.AddResult(CodeCompletionResult("readwrite"));
4741 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_retain))
4742 Results.AddResult(CodeCompletionResult("retain"));
4743 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_strong))
4744 Results.AddResult(CodeCompletionResult("strong"));
4745 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_copy))
4746 Results.AddResult(CodeCompletionResult("copy"));
4747 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nonatomic))
4748 Results.AddResult(CodeCompletionResult("nonatomic"));
4749 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_atomic))
4750 Results.AddResult(CodeCompletionResult("atomic"));
4752 // Only suggest "weak" if we're compiling for ARC-with-weak-references or GC.
4753 if (getLangOpts().ObjCARCWeak || getLangOpts().getGC() != LangOptions::NonGC)
4754 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_weak))
4755 Results.AddResult(CodeCompletionResult("weak"));
4757 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_setter)) {
4758 CodeCompletionBuilder Setter(Results.getAllocator(),
4759 Results.getCodeCompletionTUInfo());
4760 Setter.AddTypedTextChunk("setter");
4761 Setter.AddTextChunk(" = ");
4762 Setter.AddPlaceholderChunk("method");
4763 Results.AddResult(CodeCompletionResult(Setter.TakeString()));
4765 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_getter)) {
4766 CodeCompletionBuilder Getter(Results.getAllocator(),
4767 Results.getCodeCompletionTUInfo());
4768 Getter.AddTypedTextChunk("getter");
4769 Getter.AddTextChunk(" = ");
4770 Getter.AddPlaceholderChunk("method");
4771 Results.AddResult(CodeCompletionResult(Getter.TakeString()));
4773 Results.ExitScope();
4774 HandleCodeCompleteResults(this, CodeCompleter,
4775 CodeCompletionContext::CCC_Other,
4776 Results.data(),Results.size());
4779 /// \brief Describes the kind of Objective-C method that we want to find
4780 /// via code completion.
4781 enum ObjCMethodKind {
4782 MK_Any, ///< Any kind of method, provided it means other specified criteria.
4783 MK_ZeroArgSelector, ///< Zero-argument (unary) selector.
4784 MK_OneArgSelector ///< One-argument selector.
4787 static bool isAcceptableObjCSelector(Selector Sel,
4788 ObjCMethodKind WantKind,
4789 IdentifierInfo **SelIdents,
4790 unsigned NumSelIdents,
4791 bool AllowSameLength = true) {
4792 if (NumSelIdents > Sel.getNumArgs())
4797 case MK_ZeroArgSelector: return Sel.isUnarySelector();
4798 case MK_OneArgSelector: return Sel.getNumArgs() == 1;
4801 if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs())
4804 for (unsigned I = 0; I != NumSelIdents; ++I)
4805 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I))
4811 static bool isAcceptableObjCMethod(ObjCMethodDecl *Method,
4812 ObjCMethodKind WantKind,
4813 IdentifierInfo **SelIdents,
4814 unsigned NumSelIdents,
4815 bool AllowSameLength = true) {
4816 return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents,
4817 NumSelIdents, AllowSameLength);
4821 /// \brief A set of selectors, which is used to avoid introducing multiple
4822 /// completions with the same selector into the result set.
4823 typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet;
4826 /// \brief Add all of the Objective-C methods in the given Objective-C
4827 /// container to the set of results.
4829 /// The container will be a class, protocol, category, or implementation of
4830 /// any of the above. This mether will recurse to include methods from
4831 /// the superclasses of classes along with their categories, protocols, and
4832 /// implementations.
4834 /// \param Container the container in which we'll look to find methods.
4836 /// \param WantInstanceMethods Whether to add instance methods (only); if
4837 /// false, this routine will add factory methods (only).
4839 /// \param CurContext the context in which we're performing the lookup that
4842 /// \param AllowSameLength Whether we allow a method to be added to the list
4843 /// when it has the same number of parameters as we have selector identifiers.
4845 /// \param Results the structure into which we'll add results.
4846 static void AddObjCMethods(ObjCContainerDecl *Container,
4847 bool WantInstanceMethods,
4848 ObjCMethodKind WantKind,
4849 IdentifierInfo **SelIdents,
4850 unsigned NumSelIdents,
4851 DeclContext *CurContext,
4852 VisitedSelectorSet &Selectors,
4853 bool AllowSameLength,
4854 ResultBuilder &Results,
4855 bool InOriginalClass = true) {
4856 typedef CodeCompletionResult Result;
4857 Container = getContainerDef(Container);
4858 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
4859 bool isRootClass = IFace && !IFace->getSuperClass();
4860 for (ObjCContainerDecl::method_iterator M = Container->meth_begin(),
4861 MEnd = Container->meth_end();
4863 // The instance methods on the root class can be messaged via the
4865 if (M->isInstanceMethod() == WantInstanceMethods ||
4866 (isRootClass && !WantInstanceMethods)) {
4867 // Check whether the selector identifiers we've been given are a
4868 // subset of the identifiers for this particular method.
4869 if (!isAcceptableObjCMethod(*M, WantKind, SelIdents, NumSelIdents,
4873 if (!Selectors.insert(M->getSelector()))
4876 Result R = Result(*M, Results.getBasePriority(*M), 0);
4877 R.StartParameter = NumSelIdents;
4878 R.AllParametersAreInformative = (WantKind != MK_Any);
4879 if (!InOriginalClass)
4880 R.Priority += CCD_InBaseClass;
4881 Results.MaybeAddResult(R, CurContext);
4885 // Visit the protocols of protocols.
4886 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
4887 if (Protocol->hasDefinition()) {
4888 const ObjCList<ObjCProtocolDecl> &Protocols
4889 = Protocol->getReferencedProtocols();
4890 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
4891 E = Protocols.end();
4893 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents,
4894 NumSelIdents, CurContext, Selectors, AllowSameLength,
4899 if (!IFace || !IFace->hasDefinition())
4902 // Add methods in protocols.
4903 for (ObjCInterfaceDecl::protocol_iterator I = IFace->protocol_begin(),
4904 E = IFace->protocol_end();
4906 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, NumSelIdents,
4907 CurContext, Selectors, AllowSameLength, Results, false);
4909 // Add methods in categories.
4910 for (ObjCInterfaceDecl::known_categories_iterator
4911 Cat = IFace->known_categories_begin(),
4912 CatEnd = IFace->known_categories_end();
4913 Cat != CatEnd; ++Cat) {
4914 ObjCCategoryDecl *CatDecl = *Cat;
4916 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
4917 NumSelIdents, CurContext, Selectors, AllowSameLength,
4918 Results, InOriginalClass);
4920 // Add a categories protocol methods.
4921 const ObjCList<ObjCProtocolDecl> &Protocols
4922 = CatDecl->getReferencedProtocols();
4923 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
4924 E = Protocols.end();
4926 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents,
4927 NumSelIdents, CurContext, Selectors, AllowSameLength,
4930 // Add methods in category implementations.
4931 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation())
4932 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents,
4933 NumSelIdents, CurContext, Selectors, AllowSameLength,
4934 Results, InOriginalClass);
4937 // Add methods in superclass.
4938 if (IFace->getSuperClass())
4939 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind,
4940 SelIdents, NumSelIdents, CurContext, Selectors,
4941 AllowSameLength, Results, false);
4943 // Add methods in our implementation, if any.
4944 if (ObjCImplementationDecl *Impl = IFace->getImplementation())
4945 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents,
4946 NumSelIdents, CurContext, Selectors, AllowSameLength,
4947 Results, InOriginalClass);
4951 void Sema::CodeCompleteObjCPropertyGetter(Scope *S) {
4952 // Try to find the interface where getters might live.
4953 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
4955 if (ObjCCategoryDecl *Category
4956 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
4957 Class = Category->getClassInterface();
4963 // Find all of the potential getters.
4964 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4965 CodeCompleter->getCodeCompletionTUInfo(),
4966 CodeCompletionContext::CCC_Other);
4967 Results.EnterNewScope();
4969 VisitedSelectorSet Selectors;
4970 AddObjCMethods(Class, true, MK_ZeroArgSelector, 0, 0, CurContext, Selectors,
4971 /*AllowSameLength=*/true, Results);
4972 Results.ExitScope();
4973 HandleCodeCompleteResults(this, CodeCompleter,
4974 CodeCompletionContext::CCC_Other,
4975 Results.data(),Results.size());
4978 void Sema::CodeCompleteObjCPropertySetter(Scope *S) {
4979 // Try to find the interface where setters might live.
4980 ObjCInterfaceDecl *Class
4981 = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
4983 if (ObjCCategoryDecl *Category
4984 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
4985 Class = Category->getClassInterface();
4991 // Find all of the potential getters.
4992 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4993 CodeCompleter->getCodeCompletionTUInfo(),
4994 CodeCompletionContext::CCC_Other);
4995 Results.EnterNewScope();
4997 VisitedSelectorSet Selectors;
4998 AddObjCMethods(Class, true, MK_OneArgSelector, 0, 0, CurContext,
4999 Selectors, /*AllowSameLength=*/true, Results);
5001 Results.ExitScope();
5002 HandleCodeCompleteResults(this, CodeCompleter,
5003 CodeCompletionContext::CCC_Other,
5004 Results.data(),Results.size());
5007 void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
5009 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5010 CodeCompleter->getCodeCompletionTUInfo(),
5011 CodeCompletionContext::CCC_Type);
5012 Results.EnterNewScope();
5014 // Add context-sensitive, Objective-C parameter-passing keywords.
5015 bool AddedInOut = false;
5016 if ((DS.getObjCDeclQualifier() &
5017 (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) {
5018 Results.AddResult("in");
5019 Results.AddResult("inout");
5022 if ((DS.getObjCDeclQualifier() &
5023 (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) {
5024 Results.AddResult("out");
5026 Results.AddResult("inout");
5028 if ((DS.getObjCDeclQualifier() &
5029 (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref |
5030 ObjCDeclSpec::DQ_Oneway)) == 0) {
5031 Results.AddResult("bycopy");
5032 Results.AddResult("byref");
5033 Results.AddResult("oneway");
5036 // If we're completing the return type of an Objective-C method and the
5037 // identifier IBAction refers to a macro, provide a completion item for
5039 // IBAction)<#selector#>:(id)sender
5040 if (DS.getObjCDeclQualifier() == 0 && !IsParameter &&
5041 Context.Idents.get("IBAction").hasMacroDefinition()) {
5042 CodeCompletionBuilder Builder(Results.getAllocator(),
5043 Results.getCodeCompletionTUInfo(),
5044 CCP_CodePattern, CXAvailability_Available);
5045 Builder.AddTypedTextChunk("IBAction");
5046 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5047 Builder.AddPlaceholderChunk("selector");
5048 Builder.AddChunk(CodeCompletionString::CK_Colon);
5049 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5050 Builder.AddTextChunk("id");
5051 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5052 Builder.AddTextChunk("sender");
5053 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
5056 // If we're completing the return type, provide 'instancetype'.
5058 Results.AddResult(CodeCompletionResult("instancetype"));
5061 // Add various builtin type names and specifiers.
5062 AddOrdinaryNameResults(PCC_Type, S, *this, Results);
5063 Results.ExitScope();
5065 // Add the various type names
5066 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
5067 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5068 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5069 CodeCompleter->includeGlobals());
5071 if (CodeCompleter->includeMacros())
5072 AddMacroResults(PP, Results, false);
5074 HandleCodeCompleteResults(this, CodeCompleter,
5075 CodeCompletionContext::CCC_Type,
5076 Results.data(), Results.size());
5079 /// \brief When we have an expression with type "id", we may assume
5080 /// that it has some more-specific class type based on knowledge of
5081 /// common uses of Objective-C. This routine returns that class type,
5082 /// or NULL if no better result could be determined.
5083 static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) {
5084 ObjCMessageExpr *Msg = dyn_cast_or_null<ObjCMessageExpr>(E);
5088 Selector Sel = Msg->getSelector();
5092 IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0);
5096 ObjCMethodDecl *Method = Msg->getMethodDecl();
5100 // Determine the class that we're sending the message to.
5101 ObjCInterfaceDecl *IFace = 0;
5102 switch (Msg->getReceiverKind()) {
5103 case ObjCMessageExpr::Class:
5104 if (const ObjCObjectType *ObjType
5105 = Msg->getClassReceiver()->getAs<ObjCObjectType>())
5106 IFace = ObjType->getInterface();
5109 case ObjCMessageExpr::Instance: {
5110 QualType T = Msg->getInstanceReceiver()->getType();
5111 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
5112 IFace = Ptr->getInterfaceDecl();
5116 case ObjCMessageExpr::SuperInstance:
5117 case ObjCMessageExpr::SuperClass:
5124 ObjCInterfaceDecl *Super = IFace->getSuperClass();
5125 if (Method->isInstanceMethod())
5126 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5127 .Case("retain", IFace)
5128 .Case("strong", IFace)
5129 .Case("autorelease", IFace)
5130 .Case("copy", IFace)
5131 .Case("copyWithZone", IFace)
5132 .Case("mutableCopy", IFace)
5133 .Case("mutableCopyWithZone", IFace)
5134 .Case("awakeFromCoder", IFace)
5135 .Case("replacementObjectFromCoder", IFace)
5136 .Case("class", IFace)
5137 .Case("classForCoder", IFace)
5138 .Case("superclass", Super)
5141 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5143 .Case("alloc", IFace)
5144 .Case("allocWithZone", IFace)
5145 .Case("class", IFace)
5146 .Case("superclass", Super)
5150 // Add a special completion for a message send to "super", which fills in the
5151 // most likely case of forwarding all of our arguments to the superclass
5154 /// \param S The semantic analysis object.
5156 /// \param NeedSuperKeyword Whether we need to prefix this completion with
5157 /// the "super" keyword. Otherwise, we just need to provide the arguments.
5159 /// \param SelIdents The identifiers in the selector that have already been
5160 /// provided as arguments for a send to "super".
5162 /// \param NumSelIdents The number of identifiers in \p SelIdents.
5164 /// \param Results The set of results to augment.
5166 /// \returns the Objective-C method declaration that would be invoked by
5167 /// this "super" completion. If NULL, no completion was added.
5168 static ObjCMethodDecl *AddSuperSendCompletion(Sema &S, bool NeedSuperKeyword,
5169 IdentifierInfo **SelIdents,
5170 unsigned NumSelIdents,
5171 ResultBuilder &Results) {
5172 ObjCMethodDecl *CurMethod = S.getCurMethodDecl();
5176 ObjCInterfaceDecl *Class = CurMethod->getClassInterface();
5180 // Try to find a superclass method with the same selector.
5181 ObjCMethodDecl *SuperMethod = 0;
5182 while ((Class = Class->getSuperClass()) && !SuperMethod) {
5183 // Check in the class
5184 SuperMethod = Class->getMethod(CurMethod->getSelector(),
5185 CurMethod->isInstanceMethod());
5187 // Check in categories or class extensions.
5189 for (ObjCInterfaceDecl::known_categories_iterator
5190 Cat = Class->known_categories_begin(),
5191 CatEnd = Class->known_categories_end();
5192 Cat != CatEnd; ++Cat) {
5193 if ((SuperMethod = Cat->getMethod(CurMethod->getSelector(),
5194 CurMethod->isInstanceMethod())))
5203 // Check whether the superclass method has the same signature.
5204 if (CurMethod->param_size() != SuperMethod->param_size() ||
5205 CurMethod->isVariadic() != SuperMethod->isVariadic())
5208 for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(),
5209 CurPEnd = CurMethod->param_end(),
5210 SuperP = SuperMethod->param_begin();
5211 CurP != CurPEnd; ++CurP, ++SuperP) {
5212 // Make sure the parameter types are compatible.
5213 if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(),
5214 (*SuperP)->getType()))
5217 // Make sure we have a parameter name to forward!
5218 if (!(*CurP)->getIdentifier())
5222 // We have a superclass method. Now, form the send-to-super completion.
5223 CodeCompletionBuilder Builder(Results.getAllocator(),
5224 Results.getCodeCompletionTUInfo());
5226 // Give this completion a return type.
5227 AddResultTypeChunk(S.Context, getCompletionPrintingPolicy(S), SuperMethod,
5230 // If we need the "super" keyword, add it (plus some spacing).
5231 if (NeedSuperKeyword) {
5232 Builder.AddTypedTextChunk("super");
5233 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5236 Selector Sel = CurMethod->getSelector();
5237 if (Sel.isUnarySelector()) {
5238 if (NeedSuperKeyword)
5239 Builder.AddTextChunk(Builder.getAllocator().CopyString(
5240 Sel.getNameForSlot(0)));
5242 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
5243 Sel.getNameForSlot(0)));
5245 ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin();
5246 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) {
5247 if (I > NumSelIdents)
5248 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5250 if (I < NumSelIdents)
5251 Builder.AddInformativeChunk(
5252 Builder.getAllocator().CopyString(
5253 Sel.getNameForSlot(I) + ":"));
5254 else if (NeedSuperKeyword || I > NumSelIdents) {
5255 Builder.AddTextChunk(
5256 Builder.getAllocator().CopyString(
5257 Sel.getNameForSlot(I) + ":"));
5258 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5259 (*CurP)->getIdentifier()->getName()));
5261 Builder.AddTypedTextChunk(
5262 Builder.getAllocator().CopyString(
5263 Sel.getNameForSlot(I) + ":"));
5264 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5265 (*CurP)->getIdentifier()->getName()));
5270 Results.AddResult(CodeCompletionResult(Builder.TakeString(), SuperMethod,
5271 CCP_SuperCompletion));
5275 void Sema::CodeCompleteObjCMessageReceiver(Scope *S) {
5276 typedef CodeCompletionResult Result;
5277 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5278 CodeCompleter->getCodeCompletionTUInfo(),
5279 CodeCompletionContext::CCC_ObjCMessageReceiver,
5280 getLangOpts().CPlusPlus11
5281 ? &ResultBuilder::IsObjCMessageReceiverOrLambdaCapture
5282 : &ResultBuilder::IsObjCMessageReceiver);
5284 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5285 Results.EnterNewScope();
5286 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5287 CodeCompleter->includeGlobals());
5289 // If we are in an Objective-C method inside a class that has a superclass,
5290 // add "super" as an option.
5291 if (ObjCMethodDecl *Method = getCurMethodDecl())
5292 if (ObjCInterfaceDecl *Iface = Method->getClassInterface())
5293 if (Iface->getSuperClass()) {
5294 Results.AddResult(Result("super"));
5296 AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, 0, 0, Results);
5299 if (getLangOpts().CPlusPlus11)
5300 addThisCompletion(*this, Results);
5302 Results.ExitScope();
5304 if (CodeCompleter->includeMacros())
5305 AddMacroResults(PP, Results, false);
5306 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5307 Results.data(), Results.size());
5311 void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
5312 IdentifierInfo **SelIdents,
5313 unsigned NumSelIdents,
5314 bool AtArgumentExpression) {
5315 ObjCInterfaceDecl *CDecl = 0;
5316 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5317 // Figure out which interface we're in.
5318 CDecl = CurMethod->getClassInterface();
5322 // Find the superclass of this class.
5323 CDecl = CDecl->getSuperClass();
5327 if (CurMethod->isInstanceMethod()) {
5328 // We are inside an instance method, which means that the message
5329 // send [super ...] is actually calling an instance method on the
5331 return CodeCompleteObjCInstanceMessage(S, 0,
5332 SelIdents, NumSelIdents,
5333 AtArgumentExpression,
5337 // Fall through to send to the superclass in CDecl.
5339 // "super" may be the name of a type or variable. Figure out which
5341 IdentifierInfo *Super = getSuperIdentifier();
5342 NamedDecl *ND = LookupSingleName(S, Super, SuperLoc,
5343 LookupOrdinaryName);
5344 if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) {
5345 // "super" names an interface. Use it.
5346 } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) {
5347 if (const ObjCObjectType *Iface
5348 = Context.getTypeDeclType(TD)->getAs<ObjCObjectType>())
5349 CDecl = Iface->getInterface();
5350 } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) {
5351 // "super" names an unresolved type; we can't be more specific.
5353 // Assume that "super" names some kind of value and parse that way.
5355 SourceLocation TemplateKWLoc;
5357 id.setIdentifier(Super, SuperLoc);
5358 ExprResult SuperExpr = ActOnIdExpression(S, SS, TemplateKWLoc, id,
5360 return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
5361 SelIdents, NumSelIdents,
5362 AtArgumentExpression);
5368 ParsedType Receiver;
5370 Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl));
5371 return CodeCompleteObjCClassMessage(S, Receiver, SelIdents,
5372 NumSelIdents, AtArgumentExpression,
5376 /// \brief Given a set of code-completion results for the argument of a message
5377 /// send, determine the preferred type (if any) for that argument expression.
5378 static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
5379 unsigned NumSelIdents) {
5380 typedef CodeCompletionResult Result;
5381 ASTContext &Context = Results.getSema().Context;
5383 QualType PreferredType;
5384 unsigned BestPriority = CCP_Unlikely * 2;
5385 Result *ResultsData = Results.data();
5386 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
5387 Result &R = ResultsData[I];
5388 if (R.Kind == Result::RK_Declaration &&
5389 isa<ObjCMethodDecl>(R.Declaration)) {
5390 if (R.Priority <= BestPriority) {
5391 const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration);
5392 if (NumSelIdents <= Method->param_size()) {
5393 QualType MyPreferredType = Method->param_begin()[NumSelIdents - 1]
5395 if (R.Priority < BestPriority || PreferredType.isNull()) {
5396 BestPriority = R.Priority;
5397 PreferredType = MyPreferredType;
5398 } else if (!Context.hasSameUnqualifiedType(PreferredType,
5400 PreferredType = QualType();
5407 return PreferredType;
5410 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
5411 ParsedType Receiver,
5412 IdentifierInfo **SelIdents,
5413 unsigned NumSelIdents,
5414 bool AtArgumentExpression,
5416 ResultBuilder &Results) {
5417 typedef CodeCompletionResult Result;
5418 ObjCInterfaceDecl *CDecl = 0;
5420 // If the given name refers to an interface type, retrieve the
5421 // corresponding declaration.
5423 QualType T = SemaRef.GetTypeFromParser(Receiver, 0);
5425 if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>())
5426 CDecl = Interface->getInterface();
5429 // Add all of the factory methods in this Objective-C class, its protocols,
5430 // superclasses, categories, implementation, etc.
5431 Results.EnterNewScope();
5433 // If this is a send-to-super, try to add the special "super" send
5436 if (ObjCMethodDecl *SuperMethod
5437 = AddSuperSendCompletion(SemaRef, false, SelIdents, NumSelIdents,
5439 Results.Ignore(SuperMethod);
5442 // If we're inside an Objective-C method definition, prefer its selector to
5444 if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl())
5445 Results.setPreferredSelector(CurMethod->getSelector());
5447 VisitedSelectorSet Selectors;
5449 AddObjCMethods(CDecl, false, MK_Any, SelIdents, NumSelIdents,
5450 SemaRef.CurContext, Selectors, AtArgumentExpression,
5453 // We're messaging "id" as a type; provide all class/factory methods.
5455 // If we have an external source, load the entire class method
5456 // pool from the AST file.
5457 if (SemaRef.getExternalSource()) {
5458 for (uint32_t I = 0,
5459 N = SemaRef.getExternalSource()->GetNumExternalSelectors();
5461 Selector Sel = SemaRef.getExternalSource()->GetExternalSelector(I);
5462 if (Sel.isNull() || SemaRef.MethodPool.count(Sel))
5465 SemaRef.ReadMethodPool(Sel);
5469 for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(),
5470 MEnd = SemaRef.MethodPool.end();
5472 for (ObjCMethodList *MethList = &M->second.second;
5473 MethList && MethList->Method;
5474 MethList = MethList->getNext()) {
5475 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents,
5479 Result R(MethList->Method, Results.getBasePriority(MethList->Method),0);
5480 R.StartParameter = NumSelIdents;
5481 R.AllParametersAreInformative = false;
5482 Results.MaybeAddResult(R, SemaRef.CurContext);
5487 Results.ExitScope();
5490 void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
5491 IdentifierInfo **SelIdents,
5492 unsigned NumSelIdents,
5493 bool AtArgumentExpression,
5496 QualType T = this->GetTypeFromParser(Receiver);
5498 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5499 CodeCompleter->getCodeCompletionTUInfo(),
5500 CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage,
5501 T, SelIdents, NumSelIdents));
5503 AddClassMessageCompletions(*this, S, Receiver, SelIdents, NumSelIdents,
5504 AtArgumentExpression, IsSuper, Results);
5506 // If we're actually at the argument expression (rather than prior to the
5507 // selector), we're actually performing code completion for an expression.
5508 // Determine whether we have a single, best method. If so, we can
5509 // code-complete the expression using the corresponding parameter type as
5510 // our preferred type, improving completion results.
5511 if (AtArgumentExpression) {
5512 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
5514 if (PreferredType.isNull())
5515 CodeCompleteOrdinaryName(S, PCC_Expression);
5517 CodeCompleteExpression(S, PreferredType);
5521 HandleCodeCompleteResults(this, CodeCompleter,
5522 Results.getCompletionContext(),
5523 Results.data(), Results.size());
5526 void Sema::CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
5527 IdentifierInfo **SelIdents,
5528 unsigned NumSelIdents,
5529 bool AtArgumentExpression,
5530 ObjCInterfaceDecl *Super) {
5531 typedef CodeCompletionResult Result;
5533 Expr *RecExpr = static_cast<Expr *>(Receiver);
5535 // If necessary, apply function/array conversion to the receiver.
5536 // C99 6.7.5.3p[7,8].
5538 ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr);
5539 if (Conv.isInvalid()) // conversion failed. bail.
5541 RecExpr = Conv.take();
5543 QualType ReceiverType = RecExpr? RecExpr->getType()
5544 : Super? Context.getObjCObjectPointerType(
5545 Context.getObjCInterfaceType(Super))
5546 : Context.getObjCIdType();
5548 // If we're messaging an expression with type "id" or "Class", check
5549 // whether we know something special about the receiver that allows
5550 // us to assume a more-specific receiver type.
5551 if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType())
5552 if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) {
5553 if (ReceiverType->isObjCClassType())
5554 return CodeCompleteObjCClassMessage(S,
5555 ParsedType::make(Context.getObjCInterfaceType(IFace)),
5556 SelIdents, NumSelIdents,
5557 AtArgumentExpression, Super);
5559 ReceiverType = Context.getObjCObjectPointerType(
5560 Context.getObjCInterfaceType(IFace));
5563 // Build the set of methods we can see.
5564 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5565 CodeCompleter->getCodeCompletionTUInfo(),
5566 CodeCompletionContext(CodeCompletionContext::CCC_ObjCInstanceMessage,
5567 ReceiverType, SelIdents, NumSelIdents));
5569 Results.EnterNewScope();
5571 // If this is a send-to-super, try to add the special "super" send
5574 if (ObjCMethodDecl *SuperMethod
5575 = AddSuperSendCompletion(*this, false, SelIdents, NumSelIdents,
5577 Results.Ignore(SuperMethod);
5580 // If we're inside an Objective-C method definition, prefer its selector to
5582 if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
5583 Results.setPreferredSelector(CurMethod->getSelector());
5585 // Keep track of the selectors we've already added.
5586 VisitedSelectorSet Selectors;
5588 // Handle messages to Class. This really isn't a message to an instance
5589 // method, so we treat it the same way we would treat a message send to a
5591 if (ReceiverType->isObjCClassType() ||
5592 ReceiverType->isObjCQualifiedClassType()) {
5593 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5594 if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface())
5595 AddObjCMethods(ClassDecl, false, MK_Any, SelIdents, NumSelIdents,
5596 CurContext, Selectors, AtArgumentExpression, Results);
5599 // Handle messages to a qualified ID ("id<foo>").
5600 else if (const ObjCObjectPointerType *QualID
5601 = ReceiverType->getAsObjCQualifiedIdType()) {
5602 // Search protocols for instance methods.
5603 for (ObjCObjectPointerType::qual_iterator I = QualID->qual_begin(),
5604 E = QualID->qual_end();
5606 AddObjCMethods(*I, true, MK_Any, SelIdents, NumSelIdents, CurContext,
5607 Selectors, AtArgumentExpression, Results);
5609 // Handle messages to a pointer to interface type.
5610 else if (const ObjCObjectPointerType *IFacePtr
5611 = ReceiverType->getAsObjCInterfacePointerType()) {
5612 // Search the class, its superclasses, etc., for instance methods.
5613 AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents,
5614 NumSelIdents, CurContext, Selectors, AtArgumentExpression,
5617 // Search protocols for instance methods.
5618 for (ObjCObjectPointerType::qual_iterator I = IFacePtr->qual_begin(),
5619 E = IFacePtr->qual_end();
5621 AddObjCMethods(*I, true, MK_Any, SelIdents, NumSelIdents, CurContext,
5622 Selectors, AtArgumentExpression, Results);
5624 // Handle messages to "id".
5625 else if (ReceiverType->isObjCIdType()) {
5626 // We're messaging "id", so provide all instance methods we know
5627 // about as code-completion results.
5629 // If we have an external source, load the entire class method
5630 // pool from the AST file.
5631 if (ExternalSource) {
5632 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
5634 Selector Sel = ExternalSource->GetExternalSelector(I);
5635 if (Sel.isNull() || MethodPool.count(Sel))
5638 ReadMethodPool(Sel);
5642 for (GlobalMethodPool::iterator M = MethodPool.begin(),
5643 MEnd = MethodPool.end();
5645 for (ObjCMethodList *MethList = &M->second.first;
5646 MethList && MethList->Method;
5647 MethList = MethList->getNext()) {
5648 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents,
5652 if (!Selectors.insert(MethList->Method->getSelector()))
5655 Result R(MethList->Method, Results.getBasePriority(MethList->Method),0);
5656 R.StartParameter = NumSelIdents;
5657 R.AllParametersAreInformative = false;
5658 Results.MaybeAddResult(R, CurContext);
5662 Results.ExitScope();
5665 // If we're actually at the argument expression (rather than prior to the
5666 // selector), we're actually performing code completion for an expression.
5667 // Determine whether we have a single, best method. If so, we can
5668 // code-complete the expression using the corresponding parameter type as
5669 // our preferred type, improving completion results.
5670 if (AtArgumentExpression) {
5671 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
5673 if (PreferredType.isNull())
5674 CodeCompleteOrdinaryName(S, PCC_Expression);
5676 CodeCompleteExpression(S, PreferredType);
5680 HandleCodeCompleteResults(this, CodeCompleter,
5681 Results.getCompletionContext(),
5682 Results.data(),Results.size());
5685 void Sema::CodeCompleteObjCForCollection(Scope *S,
5686 DeclGroupPtrTy IterationVar) {
5687 CodeCompleteExpressionData Data;
5688 Data.ObjCCollection = true;
5690 if (IterationVar.getAsOpaquePtr()) {
5691 DeclGroupRef DG = IterationVar.getAsVal<DeclGroupRef>();
5692 for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) {
5694 Data.IgnoreDecls.push_back(*I);
5698 CodeCompleteExpression(S, Data);
5701 void Sema::CodeCompleteObjCSelector(Scope *S, IdentifierInfo **SelIdents,
5702 unsigned NumSelIdents) {
5703 // If we have an external source, load the entire class method
5704 // pool from the AST file.
5705 if (ExternalSource) {
5706 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
5708 Selector Sel = ExternalSource->GetExternalSelector(I);
5709 if (Sel.isNull() || MethodPool.count(Sel))
5712 ReadMethodPool(Sel);
5716 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5717 CodeCompleter->getCodeCompletionTUInfo(),
5718 CodeCompletionContext::CCC_SelectorName);
5719 Results.EnterNewScope();
5720 for (GlobalMethodPool::iterator M = MethodPool.begin(),
5721 MEnd = MethodPool.end();
5724 Selector Sel = M->first;
5725 if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents, NumSelIdents))
5728 CodeCompletionBuilder Builder(Results.getAllocator(),
5729 Results.getCodeCompletionTUInfo());
5730 if (Sel.isUnarySelector()) {
5731 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
5732 Sel.getNameForSlot(0)));
5733 Results.AddResult(Builder.TakeString());
5737 std::string Accumulator;
5738 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) {
5739 if (I == NumSelIdents) {
5740 if (!Accumulator.empty()) {
5741 Builder.AddInformativeChunk(Builder.getAllocator().CopyString(
5743 Accumulator.clear();
5747 Accumulator += Sel.getNameForSlot(I);
5750 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString( Accumulator));
5751 Results.AddResult(Builder.TakeString());
5753 Results.ExitScope();
5755 HandleCodeCompleteResults(this, CodeCompleter,
5756 CodeCompletionContext::CCC_SelectorName,
5757 Results.data(), Results.size());
5760 /// \brief Add all of the protocol declarations that we find in the given
5761 /// (translation unit) context.
5762 static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext,
5763 bool OnlyForwardDeclarations,
5764 ResultBuilder &Results) {
5765 typedef CodeCompletionResult Result;
5767 for (DeclContext::decl_iterator D = Ctx->decls_begin(),
5768 DEnd = Ctx->decls_end();
5770 // Record any protocols we find.
5771 if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(*D))
5772 if (!OnlyForwardDeclarations || !Proto->hasDefinition())
5773 Results.AddResult(Result(Proto, Results.getBasePriority(Proto), 0),
5774 CurContext, 0, false);
5778 void Sema::CodeCompleteObjCProtocolReferences(IdentifierLocPair *Protocols,
5779 unsigned NumProtocols) {
5780 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5781 CodeCompleter->getCodeCompletionTUInfo(),
5782 CodeCompletionContext::CCC_ObjCProtocolName);
5784 if (CodeCompleter && CodeCompleter->includeGlobals()) {
5785 Results.EnterNewScope();
5787 // Tell the result set to ignore all of the protocols we have
5789 // FIXME: This doesn't work when caching code-completion results.
5790 for (unsigned I = 0; I != NumProtocols; ++I)
5791 if (ObjCProtocolDecl *Protocol = LookupProtocol(Protocols[I].first,
5792 Protocols[I].second))
5793 Results.Ignore(Protocol);
5795 // Add all protocols.
5796 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false,
5799 Results.ExitScope();
5802 HandleCodeCompleteResults(this, CodeCompleter,
5803 CodeCompletionContext::CCC_ObjCProtocolName,
5804 Results.data(),Results.size());
5807 void Sema::CodeCompleteObjCProtocolDecl(Scope *) {
5808 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5809 CodeCompleter->getCodeCompletionTUInfo(),
5810 CodeCompletionContext::CCC_ObjCProtocolName);
5812 if (CodeCompleter && CodeCompleter->includeGlobals()) {
5813 Results.EnterNewScope();
5815 // Add all protocols.
5816 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true,
5819 Results.ExitScope();
5822 HandleCodeCompleteResults(this, CodeCompleter,
5823 CodeCompletionContext::CCC_ObjCProtocolName,
5824 Results.data(),Results.size());
5827 /// \brief Add all of the Objective-C interface declarations that we find in
5828 /// the given (translation unit) context.
5829 static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext,
5830 bool OnlyForwardDeclarations,
5831 bool OnlyUnimplemented,
5832 ResultBuilder &Results) {
5833 typedef CodeCompletionResult Result;
5835 for (DeclContext::decl_iterator D = Ctx->decls_begin(),
5836 DEnd = Ctx->decls_end();
5838 // Record any interfaces we find.
5839 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(*D))
5840 if ((!OnlyForwardDeclarations || !Class->hasDefinition()) &&
5841 (!OnlyUnimplemented || !Class->getImplementation()))
5842 Results.AddResult(Result(Class, Results.getBasePriority(Class), 0),
5843 CurContext, 0, false);
5847 void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) {
5848 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5849 CodeCompleter->getCodeCompletionTUInfo(),
5850 CodeCompletionContext::CCC_Other);
5851 Results.EnterNewScope();
5853 if (CodeCompleter->includeGlobals()) {
5855 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
5859 Results.ExitScope();
5861 HandleCodeCompleteResults(this, CodeCompleter,
5862 CodeCompletionContext::CCC_ObjCInterfaceName,
5863 Results.data(),Results.size());
5866 void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName,
5867 SourceLocation ClassNameLoc) {
5868 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5869 CodeCompleter->getCodeCompletionTUInfo(),
5870 CodeCompletionContext::CCC_ObjCInterfaceName);
5871 Results.EnterNewScope();
5873 // Make sure that we ignore the class we're currently defining.
5875 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
5876 if (CurClass && isa<ObjCInterfaceDecl>(CurClass))
5877 Results.Ignore(CurClass);
5879 if (CodeCompleter->includeGlobals()) {
5881 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
5885 Results.ExitScope();
5887 HandleCodeCompleteResults(this, CodeCompleter,
5888 CodeCompletionContext::CCC_ObjCInterfaceName,
5889 Results.data(),Results.size());
5892 void Sema::CodeCompleteObjCImplementationDecl(Scope *S) {
5893 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5894 CodeCompleter->getCodeCompletionTUInfo(),
5895 CodeCompletionContext::CCC_Other);
5896 Results.EnterNewScope();
5898 if (CodeCompleter->includeGlobals()) {
5899 // Add all unimplemented classes.
5900 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
5904 Results.ExitScope();
5906 HandleCodeCompleteResults(this, CodeCompleter,
5907 CodeCompletionContext::CCC_ObjCInterfaceName,
5908 Results.data(),Results.size());
5911 void Sema::CodeCompleteObjCInterfaceCategory(Scope *S,
5912 IdentifierInfo *ClassName,
5913 SourceLocation ClassNameLoc) {
5914 typedef CodeCompletionResult Result;
5916 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5917 CodeCompleter->getCodeCompletionTUInfo(),
5918 CodeCompletionContext::CCC_ObjCCategoryName);
5920 // Ignore any categories we find that have already been implemented by this
5922 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
5924 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
5925 if (ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)){
5926 for (ObjCInterfaceDecl::visible_categories_iterator
5927 Cat = Class->visible_categories_begin(),
5928 CatEnd = Class->visible_categories_end();
5929 Cat != CatEnd; ++Cat) {
5930 CategoryNames.insert(Cat->getIdentifier());
5934 // Add all of the categories we know about.
5935 Results.EnterNewScope();
5936 TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
5937 for (DeclContext::decl_iterator D = TU->decls_begin(),
5938 DEnd = TU->decls_end();
5940 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(*D))
5941 if (CategoryNames.insert(Category->getIdentifier()))
5942 Results.AddResult(Result(Category, Results.getBasePriority(Category),0),
5943 CurContext, 0, false);
5944 Results.ExitScope();
5946 HandleCodeCompleteResults(this, CodeCompleter,
5947 CodeCompletionContext::CCC_ObjCCategoryName,
5948 Results.data(),Results.size());
5951 void Sema::CodeCompleteObjCImplementationCategory(Scope *S,
5952 IdentifierInfo *ClassName,
5953 SourceLocation ClassNameLoc) {
5954 typedef CodeCompletionResult Result;
5956 // Find the corresponding interface. If we couldn't find the interface, the
5957 // program itself is ill-formed. However, we'll try to be helpful still by
5958 // providing the list of all of the categories we know about.
5960 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
5961 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass);
5963 return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc);
5965 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5966 CodeCompleter->getCodeCompletionTUInfo(),
5967 CodeCompletionContext::CCC_ObjCCategoryName);
5969 // Add all of the categories that have have corresponding interface
5970 // declarations in this class and any of its superclasses, except for
5971 // already-implemented categories in the class itself.
5972 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
5973 Results.EnterNewScope();
5974 bool IgnoreImplemented = true;
5976 for (ObjCInterfaceDecl::visible_categories_iterator
5977 Cat = Class->visible_categories_begin(),
5978 CatEnd = Class->visible_categories_end();
5979 Cat != CatEnd; ++Cat) {
5980 if ((!IgnoreImplemented || !Cat->getImplementation()) &&
5981 CategoryNames.insert(Cat->getIdentifier()))
5982 Results.AddResult(Result(*Cat, Results.getBasePriority(*Cat), 0),
5983 CurContext, 0, false);
5986 Class = Class->getSuperClass();
5987 IgnoreImplemented = false;
5989 Results.ExitScope();
5991 HandleCodeCompleteResults(this, CodeCompleter,
5992 CodeCompletionContext::CCC_ObjCCategoryName,
5993 Results.data(),Results.size());
5996 void Sema::CodeCompleteObjCPropertyDefinition(Scope *S) {
5997 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5998 CodeCompleter->getCodeCompletionTUInfo(),
5999 CodeCompletionContext::CCC_Other);
6001 // Figure out where this @synthesize lives.
6002 ObjCContainerDecl *Container
6003 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6005 (!isa<ObjCImplementationDecl>(Container) &&
6006 !isa<ObjCCategoryImplDecl>(Container)))
6009 // Ignore any properties that have already been implemented.
6010 Container = getContainerDef(Container);
6011 for (DeclContext::decl_iterator D = Container->decls_begin(),
6012 DEnd = Container->decls_end();
6014 if (ObjCPropertyImplDecl *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(*D))
6015 Results.Ignore(PropertyImpl->getPropertyDecl());
6017 // Add any properties that we find.
6018 AddedPropertiesSet AddedProperties;
6019 Results.EnterNewScope();
6020 if (ObjCImplementationDecl *ClassImpl
6021 = dyn_cast<ObjCImplementationDecl>(Container))
6022 AddObjCProperties(ClassImpl->getClassInterface(), false,
6023 /*AllowNullaryMethods=*/false, CurContext,
6024 AddedProperties, Results);
6026 AddObjCProperties(cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(),
6027 false, /*AllowNullaryMethods=*/false, CurContext,
6028 AddedProperties, Results);
6029 Results.ExitScope();
6031 HandleCodeCompleteResults(this, CodeCompleter,
6032 CodeCompletionContext::CCC_Other,
6033 Results.data(),Results.size());
6036 void Sema::CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
6037 IdentifierInfo *PropertyName) {
6038 typedef CodeCompletionResult Result;
6039 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6040 CodeCompleter->getCodeCompletionTUInfo(),
6041 CodeCompletionContext::CCC_Other);
6043 // Figure out where this @synthesize lives.
6044 ObjCContainerDecl *Container
6045 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6047 (!isa<ObjCImplementationDecl>(Container) &&
6048 !isa<ObjCCategoryImplDecl>(Container)))
6051 // Figure out which interface we're looking into.
6052 ObjCInterfaceDecl *Class = 0;
6053 if (ObjCImplementationDecl *ClassImpl
6054 = dyn_cast<ObjCImplementationDecl>(Container))
6055 Class = ClassImpl->getClassInterface();
6057 Class = cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl()
6058 ->getClassInterface();
6060 // Determine the type of the property we're synthesizing.
6061 QualType PropertyType = Context.getObjCIdType();
6063 if (ObjCPropertyDecl *Property
6064 = Class->FindPropertyDeclaration(PropertyName)) {
6066 = Property->getType().getNonReferenceType().getUnqualifiedType();
6068 // Give preference to ivars
6069 Results.setPreferredType(PropertyType);
6073 // Add all of the instance variables in this class and its superclasses.
6074 Results.EnterNewScope();
6075 bool SawSimilarlyNamedIvar = false;
6076 std::string NameWithPrefix;
6077 NameWithPrefix += '_';
6078 NameWithPrefix += PropertyName->getName();
6079 std::string NameWithSuffix = PropertyName->getName().str();
6080 NameWithSuffix += '_';
6081 for(; Class; Class = Class->getSuperClass()) {
6082 for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar;
6083 Ivar = Ivar->getNextIvar()) {
6084 Results.AddResult(Result(Ivar, Results.getBasePriority(Ivar), 0),
6085 CurContext, 0, false);
6087 // Determine whether we've seen an ivar with a name similar to the
6089 if ((PropertyName == Ivar->getIdentifier() ||
6090 NameWithPrefix == Ivar->getName() ||
6091 NameWithSuffix == Ivar->getName())) {
6092 SawSimilarlyNamedIvar = true;
6094 // Reduce the priority of this result by one, to give it a slight
6095 // advantage over other results whose names don't match so closely.
6096 if (Results.size() &&
6097 Results.data()[Results.size() - 1].Kind
6098 == CodeCompletionResult::RK_Declaration &&
6099 Results.data()[Results.size() - 1].Declaration == Ivar)
6100 Results.data()[Results.size() - 1].Priority--;
6105 if (!SawSimilarlyNamedIvar) {
6106 // Create ivar result _propName, that the user can use to synthesize
6107 // an ivar of the appropriate type.
6108 unsigned Priority = CCP_MemberDeclaration + 1;
6109 typedef CodeCompletionResult Result;
6110 CodeCompletionAllocator &Allocator = Results.getAllocator();
6111 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo(),
6112 Priority,CXAvailability_Available);
6114 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
6115 Builder.AddResultTypeChunk(GetCompletionTypeString(PropertyType, Context,
6116 Policy, Allocator));
6117 Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix));
6118 Results.AddResult(Result(Builder.TakeString(), Priority,
6119 CXCursor_ObjCIvarDecl));
6122 Results.ExitScope();
6124 HandleCodeCompleteResults(this, CodeCompleter,
6125 CodeCompletionContext::CCC_Other,
6126 Results.data(),Results.size());
6129 // Mapping from selectors to the methods that implement that selector, along
6130 // with the "in original class" flag.
6131 typedef llvm::DenseMap<Selector, std::pair<ObjCMethodDecl *, bool> >
6134 /// \brief Find all of the methods that reside in the given container
6135 /// (and its superclasses, protocols, etc.) that meet the given
6136 /// criteria. Insert those methods into the map of known methods,
6137 /// indexed by selector so they can be easily found.
6138 static void FindImplementableMethods(ASTContext &Context,
6139 ObjCContainerDecl *Container,
6140 bool WantInstanceMethods,
6141 QualType ReturnType,
6142 KnownMethodsMap &KnownMethods,
6143 bool InOriginalClass = true) {
6144 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) {
6145 // Make sure we have a definition; that's what we'll walk.
6146 if (!IFace->hasDefinition())
6149 IFace = IFace->getDefinition();
6152 const ObjCList<ObjCProtocolDecl> &Protocols
6153 = IFace->getReferencedProtocols();
6154 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6155 E = Protocols.end();
6157 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6158 KnownMethods, InOriginalClass);
6160 // Add methods from any class extensions and categories.
6161 for (ObjCInterfaceDecl::visible_categories_iterator
6162 Cat = IFace->visible_categories_begin(),
6163 CatEnd = IFace->visible_categories_end();
6164 Cat != CatEnd; ++Cat) {
6165 FindImplementableMethods(Context, *Cat, WantInstanceMethods, ReturnType,
6166 KnownMethods, false);
6169 // Visit the superclass.
6170 if (IFace->getSuperClass())
6171 FindImplementableMethods(Context, IFace->getSuperClass(),
6172 WantInstanceMethods, ReturnType,
6173 KnownMethods, false);
6176 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
6177 // Recurse into protocols.
6178 const ObjCList<ObjCProtocolDecl> &Protocols
6179 = Category->getReferencedProtocols();
6180 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6181 E = Protocols.end();
6183 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6184 KnownMethods, InOriginalClass);
6186 // If this category is the original class, jump to the interface.
6187 if (InOriginalClass && Category->getClassInterface())
6188 FindImplementableMethods(Context, Category->getClassInterface(),
6189 WantInstanceMethods, ReturnType, KnownMethods,
6193 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
6194 // Make sure we have a definition; that's what we'll walk.
6195 if (!Protocol->hasDefinition())
6197 Protocol = Protocol->getDefinition();
6198 Container = Protocol;
6200 // Recurse into protocols.
6201 const ObjCList<ObjCProtocolDecl> &Protocols
6202 = Protocol->getReferencedProtocols();
6203 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6204 E = Protocols.end();
6206 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6207 KnownMethods, false);
6210 // Add methods in this container. This operation occurs last because
6211 // we want the methods from this container to override any methods
6212 // we've previously seen with the same selector.
6213 for (ObjCContainerDecl::method_iterator M = Container->meth_begin(),
6214 MEnd = Container->meth_end();
6216 if (M->isInstanceMethod() == WantInstanceMethods) {
6217 if (!ReturnType.isNull() &&
6218 !Context.hasSameUnqualifiedType(ReturnType, M->getResultType()))
6221 KnownMethods[M->getSelector()] = std::make_pair(*M, InOriginalClass);
6226 /// \brief Add the parenthesized return or parameter type chunk to a code
6227 /// completion string.
6228 static void AddObjCPassingTypeChunk(QualType Type,
6229 unsigned ObjCDeclQuals,
6230 ASTContext &Context,
6231 const PrintingPolicy &Policy,
6232 CodeCompletionBuilder &Builder) {
6233 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6234 std::string Quals = formatObjCParamQualifiers(ObjCDeclQuals);
6236 Builder.AddTextChunk(Builder.getAllocator().CopyString(Quals));
6237 Builder.AddTextChunk(GetCompletionTypeString(Type, Context, Policy,
6238 Builder.getAllocator()));
6239 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6242 /// \brief Determine whether the given class is or inherits from a class by
6244 static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class,
6249 if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name)
6252 return InheritsFromClassNamed(Class->getSuperClass(), Name);
6255 /// \brief Add code completions for Objective-C Key-Value Coding (KVC) and
6256 /// Key-Value Observing (KVO).
6257 static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property,
6258 bool IsInstanceMethod,
6259 QualType ReturnType,
6260 ASTContext &Context,
6261 VisitedSelectorSet &KnownSelectors,
6262 ResultBuilder &Results) {
6263 IdentifierInfo *PropName = Property->getIdentifier();
6264 if (!PropName || PropName->getLength() == 0)
6267 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
6269 // Builder that will create each code completion.
6270 typedef CodeCompletionResult Result;
6271 CodeCompletionAllocator &Allocator = Results.getAllocator();
6272 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
6274 // The selector table.
6275 SelectorTable &Selectors = Context.Selectors;
6277 // The property name, copied into the code completion allocation region
6280 CodeCompletionAllocator &Allocator;
6282 const char *CopiedKey;
6284 KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key)
6285 : Allocator(Allocator), Key(Key), CopiedKey(0) { }
6287 operator const char *() {
6291 return CopiedKey = Allocator.CopyString(Key);
6293 } Key(Allocator, PropName->getName());
6295 // The uppercased name of the property name.
6296 std::string UpperKey = PropName->getName();
6297 if (!UpperKey.empty())
6298 UpperKey[0] = toUppercase(UpperKey[0]);
6300 bool ReturnTypeMatchesProperty = ReturnType.isNull() ||
6301 Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(),
6302 Property->getType());
6303 bool ReturnTypeMatchesVoid
6304 = ReturnType.isNull() || ReturnType->isVoidType();
6306 // Add the normal accessor -(type)key.
6307 if (IsInstanceMethod &&
6308 KnownSelectors.insert(Selectors.getNullarySelector(PropName)) &&
6309 ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) {
6310 if (ReturnType.isNull())
6311 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6312 Context, Policy, Builder);
6314 Builder.AddTypedTextChunk(Key);
6315 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6316 CXCursor_ObjCInstanceMethodDecl));
6319 // If we have an integral or boolean property (or the user has provided
6320 // an integral or boolean return type), add the accessor -(type)isKey.
6321 if (IsInstanceMethod &&
6322 ((!ReturnType.isNull() &&
6323 (ReturnType->isIntegerType() || ReturnType->isBooleanType())) ||
6324 (ReturnType.isNull() &&
6325 (Property->getType()->isIntegerType() ||
6326 Property->getType()->isBooleanType())))) {
6327 std::string SelectorName = (Twine("is") + UpperKey).str();
6328 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6329 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
6330 if (ReturnType.isNull()) {
6331 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6332 Builder.AddTextChunk("BOOL");
6333 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6336 Builder.AddTypedTextChunk(
6337 Allocator.CopyString(SelectorId->getName()));
6338 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6339 CXCursor_ObjCInstanceMethodDecl));
6343 // Add the normal mutator.
6344 if (IsInstanceMethod && ReturnTypeMatchesVoid &&
6345 !Property->getSetterMethodDecl()) {
6346 std::string SelectorName = (Twine("set") + UpperKey).str();
6347 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6348 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
6349 if (ReturnType.isNull()) {
6350 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6351 Builder.AddTextChunk("void");
6352 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6355 Builder.AddTypedTextChunk(
6356 Allocator.CopyString(SelectorId->getName()));
6357 Builder.AddTypedTextChunk(":");
6358 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6359 Context, Policy, Builder);
6360 Builder.AddTextChunk(Key);
6361 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6362 CXCursor_ObjCInstanceMethodDecl));
6366 // Indexed and unordered accessors
6367 unsigned IndexedGetterPriority = CCP_CodePattern;
6368 unsigned IndexedSetterPriority = CCP_CodePattern;
6369 unsigned UnorderedGetterPriority = CCP_CodePattern;
6370 unsigned UnorderedSetterPriority = CCP_CodePattern;
6371 if (const ObjCObjectPointerType *ObjCPointer
6372 = Property->getType()->getAs<ObjCObjectPointerType>()) {
6373 if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) {
6374 // If this interface type is not provably derived from a known
6375 // collection, penalize the corresponding completions.
6376 if (!InheritsFromClassNamed(IFace, "NSMutableArray")) {
6377 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6378 if (!InheritsFromClassNamed(IFace, "NSArray"))
6379 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6382 if (!InheritsFromClassNamed(IFace, "NSMutableSet")) {
6383 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6384 if (!InheritsFromClassNamed(IFace, "NSSet"))
6385 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6389 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6390 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6391 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6392 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6395 // Add -(NSUInteger)countOf<key>
6396 if (IsInstanceMethod &&
6397 (ReturnType.isNull() || ReturnType->isIntegerType())) {
6398 std::string SelectorName = (Twine("countOf") + UpperKey).str();
6399 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6400 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
6401 if (ReturnType.isNull()) {
6402 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6403 Builder.AddTextChunk("NSUInteger");
6404 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6407 Builder.AddTypedTextChunk(
6408 Allocator.CopyString(SelectorId->getName()));
6409 Results.AddResult(Result(Builder.TakeString(),
6410 std::min(IndexedGetterPriority,
6411 UnorderedGetterPriority),
6412 CXCursor_ObjCInstanceMethodDecl));
6417 // Add -(id)objectInKeyAtIndex:(NSUInteger)index
6418 if (IsInstanceMethod &&
6419 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
6420 std::string SelectorName
6421 = (Twine("objectIn") + UpperKey + "AtIndex").str();
6422 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6423 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
6424 if (ReturnType.isNull()) {
6425 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6426 Builder.AddTextChunk("id");
6427 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6430 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6431 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6432 Builder.AddTextChunk("NSUInteger");
6433 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6434 Builder.AddTextChunk("index");
6435 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6436 CXCursor_ObjCInstanceMethodDecl));
6440 // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes
6441 if (IsInstanceMethod &&
6442 (ReturnType.isNull() ||
6443 (ReturnType->isObjCObjectPointerType() &&
6444 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6445 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6446 ->getName() == "NSArray"))) {
6447 std::string SelectorName
6448 = (Twine(Property->getName()) + "AtIndexes").str();
6449 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6450 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
6451 if (ReturnType.isNull()) {
6452 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6453 Builder.AddTextChunk("NSArray *");
6454 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6457 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6458 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6459 Builder.AddTextChunk("NSIndexSet *");
6460 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6461 Builder.AddTextChunk("indexes");
6462 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6463 CXCursor_ObjCInstanceMethodDecl));
6467 // Add -(void)getKey:(type **)buffer range:(NSRange)inRange
6468 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6469 std::string SelectorName = (Twine("get") + UpperKey).str();
6470 IdentifierInfo *SelectorIds[2] = {
6471 &Context.Idents.get(SelectorName),
6472 &Context.Idents.get("range")
6475 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
6476 if (ReturnType.isNull()) {
6477 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6478 Builder.AddTextChunk("void");
6479 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6482 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6483 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6484 Builder.AddPlaceholderChunk("object-type");
6485 Builder.AddTextChunk(" **");
6486 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6487 Builder.AddTextChunk("buffer");
6488 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6489 Builder.AddTypedTextChunk("range:");
6490 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6491 Builder.AddTextChunk("NSRange");
6492 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6493 Builder.AddTextChunk("inRange");
6494 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6495 CXCursor_ObjCInstanceMethodDecl));
6499 // Mutable indexed accessors
6501 // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index
6502 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6503 std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str();
6504 IdentifierInfo *SelectorIds[2] = {
6505 &Context.Idents.get("insertObject"),
6506 &Context.Idents.get(SelectorName)
6509 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
6510 if (ReturnType.isNull()) {
6511 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6512 Builder.AddTextChunk("void");
6513 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6516 Builder.AddTypedTextChunk("insertObject:");
6517 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6518 Builder.AddPlaceholderChunk("object-type");
6519 Builder.AddTextChunk(" *");
6520 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6521 Builder.AddTextChunk("object");
6522 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6523 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6524 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6525 Builder.AddPlaceholderChunk("NSUInteger");
6526 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6527 Builder.AddTextChunk("index");
6528 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6529 CXCursor_ObjCInstanceMethodDecl));
6533 // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes
6534 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6535 std::string SelectorName = (Twine("insert") + UpperKey).str();
6536 IdentifierInfo *SelectorIds[2] = {
6537 &Context.Idents.get(SelectorName),
6538 &Context.Idents.get("atIndexes")
6541 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
6542 if (ReturnType.isNull()) {
6543 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6544 Builder.AddTextChunk("void");
6545 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6548 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6549 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6550 Builder.AddTextChunk("NSArray *");
6551 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6552 Builder.AddTextChunk("array");
6553 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6554 Builder.AddTypedTextChunk("atIndexes:");
6555 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6556 Builder.AddPlaceholderChunk("NSIndexSet *");
6557 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6558 Builder.AddTextChunk("indexes");
6559 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6560 CXCursor_ObjCInstanceMethodDecl));
6564 // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index
6565 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6566 std::string SelectorName
6567 = (Twine("removeObjectFrom") + UpperKey + "AtIndex").str();
6568 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6569 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
6570 if (ReturnType.isNull()) {
6571 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6572 Builder.AddTextChunk("void");
6573 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6576 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6577 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6578 Builder.AddTextChunk("NSUInteger");
6579 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6580 Builder.AddTextChunk("index");
6581 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6582 CXCursor_ObjCInstanceMethodDecl));
6586 // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes
6587 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6588 std::string SelectorName
6589 = (Twine("remove") + UpperKey + "AtIndexes").str();
6590 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6591 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
6592 if (ReturnType.isNull()) {
6593 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6594 Builder.AddTextChunk("void");
6595 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6598 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6599 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6600 Builder.AddTextChunk("NSIndexSet *");
6601 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6602 Builder.AddTextChunk("indexes");
6603 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6604 CXCursor_ObjCInstanceMethodDecl));
6608 // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object
6609 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6610 std::string SelectorName
6611 = (Twine("replaceObjectIn") + UpperKey + "AtIndex").str();
6612 IdentifierInfo *SelectorIds[2] = {
6613 &Context.Idents.get(SelectorName),
6614 &Context.Idents.get("withObject")
6617 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
6618 if (ReturnType.isNull()) {
6619 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6620 Builder.AddTextChunk("void");
6621 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6624 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6625 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6626 Builder.AddPlaceholderChunk("NSUInteger");
6627 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6628 Builder.AddTextChunk("index");
6629 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6630 Builder.AddTypedTextChunk("withObject:");
6631 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6632 Builder.AddTextChunk("id");
6633 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6634 Builder.AddTextChunk("object");
6635 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6636 CXCursor_ObjCInstanceMethodDecl));
6640 // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array
6641 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6642 std::string SelectorName1
6643 = (Twine("replace") + UpperKey + "AtIndexes").str();
6644 std::string SelectorName2 = (Twine("with") + UpperKey).str();
6645 IdentifierInfo *SelectorIds[2] = {
6646 &Context.Idents.get(SelectorName1),
6647 &Context.Idents.get(SelectorName2)
6650 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
6651 if (ReturnType.isNull()) {
6652 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6653 Builder.AddTextChunk("void");
6654 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6657 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName1 + ":"));
6658 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6659 Builder.AddPlaceholderChunk("NSIndexSet *");
6660 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6661 Builder.AddTextChunk("indexes");
6662 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6663 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":"));
6664 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6665 Builder.AddTextChunk("NSArray *");
6666 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6667 Builder.AddTextChunk("array");
6668 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6669 CXCursor_ObjCInstanceMethodDecl));
6673 // Unordered getters
6674 // - (NSEnumerator *)enumeratorOfKey
6675 if (IsInstanceMethod &&
6676 (ReturnType.isNull() ||
6677 (ReturnType->isObjCObjectPointerType() &&
6678 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6679 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6680 ->getName() == "NSEnumerator"))) {
6681 std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str();
6682 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6683 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
6684 if (ReturnType.isNull()) {
6685 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6686 Builder.AddTextChunk("NSEnumerator *");
6687 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6690 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6691 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
6692 CXCursor_ObjCInstanceMethodDecl));
6696 // - (type *)memberOfKey:(type *)object
6697 if (IsInstanceMethod &&
6698 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
6699 std::string SelectorName = (Twine("memberOf") + UpperKey).str();
6700 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6701 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
6702 if (ReturnType.isNull()) {
6703 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6704 Builder.AddPlaceholderChunk("object-type");
6705 Builder.AddTextChunk(" *");
6706 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6709 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6710 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6711 if (ReturnType.isNull()) {
6712 Builder.AddPlaceholderChunk("object-type");
6713 Builder.AddTextChunk(" *");
6715 Builder.AddTextChunk(GetCompletionTypeString(ReturnType, Context,
6717 Builder.getAllocator()));
6719 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6720 Builder.AddTextChunk("object");
6721 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
6722 CXCursor_ObjCInstanceMethodDecl));
6726 // Mutable unordered accessors
6727 // - (void)addKeyObject:(type *)object
6728 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6729 std::string SelectorName
6730 = (Twine("add") + UpperKey + Twine("Object")).str();
6731 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6732 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
6733 if (ReturnType.isNull()) {
6734 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6735 Builder.AddTextChunk("void");
6736 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6739 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6740 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6741 Builder.AddPlaceholderChunk("object-type");
6742 Builder.AddTextChunk(" *");
6743 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6744 Builder.AddTextChunk("object");
6745 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6746 CXCursor_ObjCInstanceMethodDecl));
6750 // - (void)addKey:(NSSet *)objects
6751 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6752 std::string SelectorName = (Twine("add") + UpperKey).str();
6753 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6754 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
6755 if (ReturnType.isNull()) {
6756 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6757 Builder.AddTextChunk("void");
6758 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6761 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6762 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6763 Builder.AddTextChunk("NSSet *");
6764 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6765 Builder.AddTextChunk("objects");
6766 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6767 CXCursor_ObjCInstanceMethodDecl));
6771 // - (void)removeKeyObject:(type *)object
6772 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6773 std::string SelectorName
6774 = (Twine("remove") + UpperKey + Twine("Object")).str();
6775 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6776 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
6777 if (ReturnType.isNull()) {
6778 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6779 Builder.AddTextChunk("void");
6780 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6783 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6784 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6785 Builder.AddPlaceholderChunk("object-type");
6786 Builder.AddTextChunk(" *");
6787 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6788 Builder.AddTextChunk("object");
6789 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6790 CXCursor_ObjCInstanceMethodDecl));
6794 // - (void)removeKey:(NSSet *)objects
6795 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6796 std::string SelectorName = (Twine("remove") + UpperKey).str();
6797 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6798 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
6799 if (ReturnType.isNull()) {
6800 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6801 Builder.AddTextChunk("void");
6802 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6805 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6806 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6807 Builder.AddTextChunk("NSSet *");
6808 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6809 Builder.AddTextChunk("objects");
6810 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6811 CXCursor_ObjCInstanceMethodDecl));
6815 // - (void)intersectKey:(NSSet *)objects
6816 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6817 std::string SelectorName = (Twine("intersect") + UpperKey).str();
6818 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6819 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
6820 if (ReturnType.isNull()) {
6821 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6822 Builder.AddTextChunk("void");
6823 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6826 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6827 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6828 Builder.AddTextChunk("NSSet *");
6829 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6830 Builder.AddTextChunk("objects");
6831 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6832 CXCursor_ObjCInstanceMethodDecl));
6836 // Key-Value Observing
6837 // + (NSSet *)keyPathsForValuesAffectingKey
6838 if (!IsInstanceMethod &&
6839 (ReturnType.isNull() ||
6840 (ReturnType->isObjCObjectPointerType() &&
6841 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6842 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6843 ->getName() == "NSSet"))) {
6844 std::string SelectorName
6845 = (Twine("keyPathsForValuesAffecting") + UpperKey).str();
6846 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6847 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
6848 if (ReturnType.isNull()) {
6849 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6850 Builder.AddTextChunk("NSSet *");
6851 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6854 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6855 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6856 CXCursor_ObjCClassMethodDecl));
6860 // + (BOOL)automaticallyNotifiesObserversForKey
6861 if (!IsInstanceMethod &&
6862 (ReturnType.isNull() ||
6863 ReturnType->isIntegerType() ||
6864 ReturnType->isBooleanType())) {
6865 std::string SelectorName
6866 = (Twine("automaticallyNotifiesObserversOf") + UpperKey).str();
6867 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6868 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
6869 if (ReturnType.isNull()) {
6870 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6871 Builder.AddTextChunk("BOOL");
6872 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6875 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6876 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6877 CXCursor_ObjCClassMethodDecl));
6882 void Sema::CodeCompleteObjCMethodDecl(Scope *S,
6883 bool IsInstanceMethod,
6884 ParsedType ReturnTy) {
6885 // Determine the return type of the method we're declaring, if
6887 QualType ReturnType = GetTypeFromParser(ReturnTy);
6889 if (CurContext->isObjCContainer()) {
6890 ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
6891 IDecl = cast<Decl>(OCD);
6893 // Determine where we should start searching for methods.
6894 ObjCContainerDecl *SearchDecl = 0;
6895 bool IsInImplementation = false;
6896 if (Decl *D = IDecl) {
6897 if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) {
6898 SearchDecl = Impl->getClassInterface();
6899 IsInImplementation = true;
6900 } else if (ObjCCategoryImplDecl *CatImpl
6901 = dyn_cast<ObjCCategoryImplDecl>(D)) {
6902 SearchDecl = CatImpl->getCategoryDecl();
6903 IsInImplementation = true;
6905 SearchDecl = dyn_cast<ObjCContainerDecl>(D);
6908 if (!SearchDecl && S) {
6909 if (DeclContext *DC = static_cast<DeclContext *>(S->getEntity()))
6910 SearchDecl = dyn_cast<ObjCContainerDecl>(DC);
6914 HandleCodeCompleteResults(this, CodeCompleter,
6915 CodeCompletionContext::CCC_Other,
6920 // Find all of the methods that we could declare/implement here.
6921 KnownMethodsMap KnownMethods;
6922 FindImplementableMethods(Context, SearchDecl, IsInstanceMethod,
6923 ReturnType, KnownMethods);
6925 // Add declarations or definitions for each of the known methods.
6926 typedef CodeCompletionResult Result;
6927 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6928 CodeCompleter->getCodeCompletionTUInfo(),
6929 CodeCompletionContext::CCC_Other);
6930 Results.EnterNewScope();
6931 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
6932 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
6933 MEnd = KnownMethods.end();
6935 ObjCMethodDecl *Method = M->second.first;
6936 CodeCompletionBuilder Builder(Results.getAllocator(),
6937 Results.getCodeCompletionTUInfo());
6939 // If the result type was not already provided, add it to the
6940 // pattern as (type).
6941 if (ReturnType.isNull())
6942 AddObjCPassingTypeChunk(Method->getResultType(),
6943 Method->getObjCDeclQualifier(),
6947 Selector Sel = Method->getSelector();
6949 // Add the first part of the selector to the pattern.
6950 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
6951 Sel.getNameForSlot(0)));
6953 // Add parameters to the pattern.
6955 for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
6956 PEnd = Method->param_end();
6957 P != PEnd; (void)++P, ++I) {
6958 // Add the part of the selector name.
6960 Builder.AddTypedTextChunk(":");
6961 else if (I < Sel.getNumArgs()) {
6962 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6963 Builder.AddTypedTextChunk(
6964 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
6968 // Add the parameter type.
6969 AddObjCPassingTypeChunk((*P)->getOriginalType(),
6970 (*P)->getObjCDeclQualifier(),
6974 if (IdentifierInfo *Id = (*P)->getIdentifier())
6975 Builder.AddTextChunk(Builder.getAllocator().CopyString( Id->getName()));
6978 if (Method->isVariadic()) {
6979 if (Method->param_size() > 0)
6980 Builder.AddChunk(CodeCompletionString::CK_Comma);
6981 Builder.AddTextChunk("...");
6984 if (IsInImplementation && Results.includeCodePatterns()) {
6985 // We will be defining the method here, so add a compound statement.
6986 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6987 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
6988 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
6989 if (!Method->getResultType()->isVoidType()) {
6990 // If the result type is not void, add a return clause.
6991 Builder.AddTextChunk("return");
6992 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6993 Builder.AddPlaceholderChunk("expression");
6994 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
6996 Builder.AddPlaceholderChunk("statements");
6998 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
6999 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
7002 unsigned Priority = CCP_CodePattern;
7003 if (!M->second.second)
7004 Priority += CCD_InBaseClass;
7006 Results.AddResult(Result(Builder.TakeString(), Method, Priority));
7009 // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of
7010 // the properties in this class and its categories.
7011 if (Context.getLangOpts().ObjC2) {
7012 SmallVector<ObjCContainerDecl *, 4> Containers;
7013 Containers.push_back(SearchDecl);
7015 VisitedSelectorSet KnownSelectors;
7016 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7017 MEnd = KnownMethods.end();
7019 KnownSelectors.insert(M->first);
7022 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl);
7024 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl))
7025 IFace = Category->getClassInterface();
7028 for (ObjCInterfaceDecl::visible_categories_iterator
7029 Cat = IFace->visible_categories_begin(),
7030 CatEnd = IFace->visible_categories_end();
7031 Cat != CatEnd; ++Cat) {
7032 Containers.push_back(*Cat);
7036 for (unsigned I = 0, N = Containers.size(); I != N; ++I) {
7037 for (ObjCContainerDecl::prop_iterator P = Containers[I]->prop_begin(),
7038 PEnd = Containers[I]->prop_end();
7040 AddObjCKeyValueCompletions(*P, IsInstanceMethod, ReturnType, Context,
7041 KnownSelectors, Results);
7046 Results.ExitScope();
7048 HandleCodeCompleteResults(this, CodeCompleter,
7049 CodeCompletionContext::CCC_Other,
7050 Results.data(),Results.size());
7053 void Sema::CodeCompleteObjCMethodDeclSelector(Scope *S,
7054 bool IsInstanceMethod,
7055 bool AtParameterName,
7056 ParsedType ReturnTy,
7057 IdentifierInfo **SelIdents,
7058 unsigned NumSelIdents) {
7059 // If we have an external source, load the entire class method
7060 // pool from the AST file.
7061 if (ExternalSource) {
7062 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
7064 Selector Sel = ExternalSource->GetExternalSelector(I);
7065 if (Sel.isNull() || MethodPool.count(Sel))
7068 ReadMethodPool(Sel);
7072 // Build the set of methods we can see.
7073 typedef CodeCompletionResult Result;
7074 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7075 CodeCompleter->getCodeCompletionTUInfo(),
7076 CodeCompletionContext::CCC_Other);
7079 Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType());
7081 Results.EnterNewScope();
7082 for (GlobalMethodPool::iterator M = MethodPool.begin(),
7083 MEnd = MethodPool.end();
7085 for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first :
7087 MethList && MethList->Method;
7088 MethList = MethList->getNext()) {
7089 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents,
7093 if (AtParameterName) {
7094 // Suggest parameter names we've seen before.
7095 if (NumSelIdents && NumSelIdents <= MethList->Method->param_size()) {
7096 ParmVarDecl *Param = MethList->Method->param_begin()[NumSelIdents-1];
7097 if (Param->getIdentifier()) {
7098 CodeCompletionBuilder Builder(Results.getAllocator(),
7099 Results.getCodeCompletionTUInfo());
7100 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7101 Param->getIdentifier()->getName()));
7102 Results.AddResult(Builder.TakeString());
7109 Result R(MethList->Method, Results.getBasePriority(MethList->Method), 0);
7110 R.StartParameter = NumSelIdents;
7111 R.AllParametersAreInformative = false;
7112 R.DeclaringEntity = true;
7113 Results.MaybeAddResult(R, CurContext);
7117 Results.ExitScope();
7118 HandleCodeCompleteResults(this, CodeCompleter,
7119 CodeCompletionContext::CCC_Other,
7120 Results.data(),Results.size());
7123 void Sema::CodeCompletePreprocessorDirective(bool InConditional) {
7124 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7125 CodeCompleter->getCodeCompletionTUInfo(),
7126 CodeCompletionContext::CCC_PreprocessorDirective);
7127 Results.EnterNewScope();
7130 CodeCompletionBuilder Builder(Results.getAllocator(),
7131 Results.getCodeCompletionTUInfo());
7132 Builder.AddTypedTextChunk("if");
7133 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7134 Builder.AddPlaceholderChunk("condition");
7135 Results.AddResult(Builder.TakeString());
7138 Builder.AddTypedTextChunk("ifdef");
7139 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7140 Builder.AddPlaceholderChunk("macro");
7141 Results.AddResult(Builder.TakeString());
7144 Builder.AddTypedTextChunk("ifndef");
7145 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7146 Builder.AddPlaceholderChunk("macro");
7147 Results.AddResult(Builder.TakeString());
7149 if (InConditional) {
7150 // #elif <condition>
7151 Builder.AddTypedTextChunk("elif");
7152 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7153 Builder.AddPlaceholderChunk("condition");
7154 Results.AddResult(Builder.TakeString());
7157 Builder.AddTypedTextChunk("else");
7158 Results.AddResult(Builder.TakeString());
7161 Builder.AddTypedTextChunk("endif");
7162 Results.AddResult(Builder.TakeString());
7165 // #include "header"
7166 Builder.AddTypedTextChunk("include");
7167 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7168 Builder.AddTextChunk("\"");
7169 Builder.AddPlaceholderChunk("header");
7170 Builder.AddTextChunk("\"");
7171 Results.AddResult(Builder.TakeString());
7173 // #include <header>
7174 Builder.AddTypedTextChunk("include");
7175 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7176 Builder.AddTextChunk("<");
7177 Builder.AddPlaceholderChunk("header");
7178 Builder.AddTextChunk(">");
7179 Results.AddResult(Builder.TakeString());
7182 Builder.AddTypedTextChunk("define");
7183 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7184 Builder.AddPlaceholderChunk("macro");
7185 Results.AddResult(Builder.TakeString());
7187 // #define <macro>(<args>)
7188 Builder.AddTypedTextChunk("define");
7189 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7190 Builder.AddPlaceholderChunk("macro");
7191 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7192 Builder.AddPlaceholderChunk("args");
7193 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7194 Results.AddResult(Builder.TakeString());
7197 Builder.AddTypedTextChunk("undef");
7198 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7199 Builder.AddPlaceholderChunk("macro");
7200 Results.AddResult(Builder.TakeString());
7203 Builder.AddTypedTextChunk("line");
7204 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7205 Builder.AddPlaceholderChunk("number");
7206 Results.AddResult(Builder.TakeString());
7208 // #line <number> "filename"
7209 Builder.AddTypedTextChunk("line");
7210 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7211 Builder.AddPlaceholderChunk("number");
7212 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7213 Builder.AddTextChunk("\"");
7214 Builder.AddPlaceholderChunk("filename");
7215 Builder.AddTextChunk("\"");
7216 Results.AddResult(Builder.TakeString());
7219 Builder.AddTypedTextChunk("error");
7220 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7221 Builder.AddPlaceholderChunk("message");
7222 Results.AddResult(Builder.TakeString());
7224 // #pragma <arguments>
7225 Builder.AddTypedTextChunk("pragma");
7226 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7227 Builder.AddPlaceholderChunk("arguments");
7228 Results.AddResult(Builder.TakeString());
7230 if (getLangOpts().ObjC1) {
7232 Builder.AddTypedTextChunk("import");
7233 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7234 Builder.AddTextChunk("\"");
7235 Builder.AddPlaceholderChunk("header");
7236 Builder.AddTextChunk("\"");
7237 Results.AddResult(Builder.TakeString());
7240 Builder.AddTypedTextChunk("import");
7241 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7242 Builder.AddTextChunk("<");
7243 Builder.AddPlaceholderChunk("header");
7244 Builder.AddTextChunk(">");
7245 Results.AddResult(Builder.TakeString());
7248 // #include_next "header"
7249 Builder.AddTypedTextChunk("include_next");
7250 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7251 Builder.AddTextChunk("\"");
7252 Builder.AddPlaceholderChunk("header");
7253 Builder.AddTextChunk("\"");
7254 Results.AddResult(Builder.TakeString());
7256 // #include_next <header>
7257 Builder.AddTypedTextChunk("include_next");
7258 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7259 Builder.AddTextChunk("<");
7260 Builder.AddPlaceholderChunk("header");
7261 Builder.AddTextChunk(">");
7262 Results.AddResult(Builder.TakeString());
7264 // #warning <message>
7265 Builder.AddTypedTextChunk("warning");
7266 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7267 Builder.AddPlaceholderChunk("message");
7268 Results.AddResult(Builder.TakeString());
7270 // Note: #ident and #sccs are such crazy anachronisms that we don't provide
7271 // completions for them. And __include_macros is a Clang-internal extension
7272 // that we don't want to encourage anyone to use.
7274 // FIXME: we don't support #assert or #unassert, so don't suggest them.
7275 Results.ExitScope();
7277 HandleCodeCompleteResults(this, CodeCompleter,
7278 CodeCompletionContext::CCC_PreprocessorDirective,
7279 Results.data(), Results.size());
7282 void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) {
7283 CodeCompleteOrdinaryName(S,
7284 S->getFnParent()? Sema::PCC_RecoveryInFunction
7285 : Sema::PCC_Namespace);
7288 void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) {
7289 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7290 CodeCompleter->getCodeCompletionTUInfo(),
7291 IsDefinition? CodeCompletionContext::CCC_MacroName
7292 : CodeCompletionContext::CCC_MacroNameUse);
7293 if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) {
7294 // Add just the names of macros, not their arguments.
7295 CodeCompletionBuilder Builder(Results.getAllocator(),
7296 Results.getCodeCompletionTUInfo());
7297 Results.EnterNewScope();
7298 for (Preprocessor::macro_iterator M = PP.macro_begin(),
7299 MEnd = PP.macro_end();
7301 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7302 M->first->getName()));
7303 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
7305 CXCursor_MacroDefinition));
7307 Results.ExitScope();
7308 } else if (IsDefinition) {
7309 // FIXME: Can we detect when the user just wrote an include guard above?
7312 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7313 Results.data(), Results.size());
7316 void Sema::CodeCompletePreprocessorExpression() {
7317 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7318 CodeCompleter->getCodeCompletionTUInfo(),
7319 CodeCompletionContext::CCC_PreprocessorExpression);
7321 if (!CodeCompleter || CodeCompleter->includeMacros())
7322 AddMacroResults(PP, Results, true);
7324 // defined (<macro>)
7325 Results.EnterNewScope();
7326 CodeCompletionBuilder Builder(Results.getAllocator(),
7327 Results.getCodeCompletionTUInfo());
7328 Builder.AddTypedTextChunk("defined");
7329 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7330 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7331 Builder.AddPlaceholderChunk("macro");
7332 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7333 Results.AddResult(Builder.TakeString());
7334 Results.ExitScope();
7336 HandleCodeCompleteResults(this, CodeCompleter,
7337 CodeCompletionContext::CCC_PreprocessorExpression,
7338 Results.data(), Results.size());
7341 void Sema::CodeCompletePreprocessorMacroArgument(Scope *S,
7342 IdentifierInfo *Macro,
7343 MacroInfo *MacroInfo,
7344 unsigned Argument) {
7345 // FIXME: In the future, we could provide "overload" results, much like we
7346 // do for function calls.
7348 // Now just ignore this. There will be another code-completion callback
7349 // for the expanded tokens.
7352 void Sema::CodeCompleteNaturalLanguage() {
7353 HandleCodeCompleteResults(this, CodeCompleter,
7354 CodeCompletionContext::CCC_NaturalLanguage,
7358 void Sema::GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,
7359 CodeCompletionTUInfo &CCTUInfo,
7360 SmallVectorImpl<CodeCompletionResult> &Results) {
7361 ResultBuilder Builder(*this, Allocator, CCTUInfo,
7362 CodeCompletionContext::CCC_Recovery);
7363 if (!CodeCompleter || CodeCompleter->includeGlobals()) {
7364 CodeCompletionDeclConsumer Consumer(Builder,
7365 Context.getTranslationUnitDecl());
7366 LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName,
7370 if (!CodeCompleter || CodeCompleter->includeMacros())
7371 AddMacroResults(PP, Builder, true);
7374 Results.insert(Results.end(),
7375 Builder.data(), Builder.data() + Builder.size());