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/Lookup.h"
23 #include "clang/Sema/Overload.h"
24 #include "clang/Sema/Scope.h"
25 #include "clang/Sema/ScopeInfo.h"
26 #include "llvm/ADT/DenseSet.h"
27 #include "llvm/ADT/SmallBitVector.h"
28 #include "llvm/ADT/SmallPtrSet.h"
29 #include "llvm/ADT/SmallString.h"
30 #include "llvm/ADT/StringExtras.h"
31 #include "llvm/ADT/StringSwitch.h"
32 #include "llvm/ADT/Twine.h"
37 using namespace clang;
41 /// \brief A container of code-completion results.
44 /// \brief The type of a name-lookup filter, which can be provided to the
45 /// name-lookup routines to specify which declarations should be included in
46 /// the result set (when it returns true) and which declarations should be
47 /// filtered out (returns false).
48 typedef bool (ResultBuilder::*LookupFilter)(const NamedDecl *) const;
50 typedef CodeCompletionResult Result;
53 /// \brief The actual results we have found.
54 std::vector<Result> Results;
56 /// \brief A record of all of the declarations we have found and placed
57 /// into the result set, used to ensure that no declaration ever gets into
58 /// the result set twice.
59 llvm::SmallPtrSet<const Decl*, 16> AllDeclsFound;
61 typedef std::pair<const NamedDecl *, unsigned> DeclIndexPair;
63 /// \brief An entry in the shadow map, which is optimized to store
64 /// a single (declaration, index) mapping (the common case) but
65 /// can also store a list of (declaration, index) mappings.
66 class ShadowMapEntry {
67 typedef SmallVector<DeclIndexPair, 4> DeclIndexPairVector;
69 /// \brief Contains either the solitary NamedDecl * or a vector
70 /// of (declaration, index) pairs.
71 llvm::PointerUnion<const NamedDecl *, DeclIndexPairVector*> DeclOrVector;
73 /// \brief When the entry contains a single declaration, this is
74 /// the index associated with that entry.
75 unsigned SingleDeclIndex;
78 ShadowMapEntry() : DeclOrVector(), SingleDeclIndex(0) { }
80 void Add(const NamedDecl *ND, unsigned Index) {
81 if (DeclOrVector.isNull()) {
82 // 0 - > 1 elements: just set the single element information.
84 SingleDeclIndex = Index;
88 if (const NamedDecl *PrevND =
89 DeclOrVector.dyn_cast<const NamedDecl *>()) {
90 // 1 -> 2 elements: create the vector of results and push in the
91 // existing declaration.
92 DeclIndexPairVector *Vec = new DeclIndexPairVector;
93 Vec->push_back(DeclIndexPair(PrevND, SingleDeclIndex));
97 // Add the new element to the end of the vector.
98 DeclOrVector.get<DeclIndexPairVector*>()->push_back(
99 DeclIndexPair(ND, Index));
103 if (DeclIndexPairVector *Vec
104 = DeclOrVector.dyn_cast<DeclIndexPairVector *>()) {
106 DeclOrVector = ((NamedDecl *)nullptr);
112 iterator begin() const;
113 iterator end() const;
116 /// \brief A mapping from declaration names to the declarations that have
117 /// this name within a particular scope and their index within the list of
119 typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;
121 /// \brief The semantic analysis object for which results are being
125 /// \brief The allocator used to allocate new code-completion strings.
126 CodeCompletionAllocator &Allocator;
128 CodeCompletionTUInfo &CCTUInfo;
130 /// \brief If non-NULL, a filter function used to remove any code-completion
131 /// results that are not desirable.
134 /// \brief Whether we should allow declarations as
135 /// nested-name-specifiers that would otherwise be filtered out.
136 bool AllowNestedNameSpecifiers;
138 /// \brief If set, the type that we would prefer our resulting value
139 /// declarations to have.
141 /// Closely matching the preferred type gives a boost to a result's
143 CanQualType PreferredType;
145 /// \brief A list of shadow maps, which is used to model name hiding at
146 /// different levels of, e.g., the inheritance hierarchy.
147 std::list<ShadowMap> ShadowMaps;
149 /// \brief If we're potentially referring to a C++ member function, the set
150 /// of qualifiers applied to the object type.
151 Qualifiers ObjectTypeQualifiers;
153 /// \brief Whether the \p ObjectTypeQualifiers field is active.
154 bool HasObjectTypeQualifiers;
156 /// \brief The selector that we prefer.
157 Selector PreferredSelector;
159 /// \brief The completion context in which we are gathering results.
160 CodeCompletionContext CompletionContext;
162 /// \brief If we are in an instance method definition, the \@implementation
164 ObjCImplementationDecl *ObjCImplementation;
166 void AdjustResultPriorityForDecl(Result &R);
168 void MaybeAddConstructorResults(Result R);
171 explicit ResultBuilder(Sema &SemaRef, CodeCompletionAllocator &Allocator,
172 CodeCompletionTUInfo &CCTUInfo,
173 const CodeCompletionContext &CompletionContext,
174 LookupFilter Filter = nullptr)
175 : SemaRef(SemaRef), Allocator(Allocator), CCTUInfo(CCTUInfo),
177 AllowNestedNameSpecifiers(false), HasObjectTypeQualifiers(false),
178 CompletionContext(CompletionContext),
179 ObjCImplementation(nullptr)
181 // If this is an Objective-C instance method definition, dig out the
182 // corresponding implementation.
183 switch (CompletionContext.getKind()) {
184 case CodeCompletionContext::CCC_Expression:
185 case CodeCompletionContext::CCC_ObjCMessageReceiver:
186 case CodeCompletionContext::CCC_ParenthesizedExpression:
187 case CodeCompletionContext::CCC_Statement:
188 case CodeCompletionContext::CCC_Recovery:
189 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl())
190 if (Method->isInstanceMethod())
191 if (ObjCInterfaceDecl *Interface = Method->getClassInterface())
192 ObjCImplementation = Interface->getImplementation();
200 /// \brief Determine the priority for a reference to the given declaration.
201 unsigned getBasePriority(const NamedDecl *D);
203 /// \brief Whether we should include code patterns in the completion
205 bool includeCodePatterns() const {
206 return SemaRef.CodeCompleter &&
207 SemaRef.CodeCompleter->includeCodePatterns();
210 /// \brief Set the filter used for code-completion results.
211 void setFilter(LookupFilter Filter) {
212 this->Filter = Filter;
215 Result *data() { return Results.empty()? nullptr : &Results.front(); }
216 unsigned size() const { return Results.size(); }
217 bool empty() const { return Results.empty(); }
219 /// \brief Specify the preferred type.
220 void setPreferredType(QualType T) {
221 PreferredType = SemaRef.Context.getCanonicalType(T);
224 /// \brief Set the cv-qualifiers on the object type, for us in filtering
225 /// calls to member functions.
227 /// When there are qualifiers in this set, they will be used to filter
228 /// out member functions that aren't available (because there will be a
229 /// cv-qualifier mismatch) or prefer functions with an exact qualifier
231 void setObjectTypeQualifiers(Qualifiers Quals) {
232 ObjectTypeQualifiers = Quals;
233 HasObjectTypeQualifiers = true;
236 /// \brief Set the preferred selector.
238 /// When an Objective-C method declaration result is added, and that
239 /// method's selector matches this preferred selector, we give that method
240 /// a slight priority boost.
241 void setPreferredSelector(Selector Sel) {
242 PreferredSelector = Sel;
245 /// \brief Retrieve the code-completion context for which results are
247 const CodeCompletionContext &getCompletionContext() const {
248 return CompletionContext;
251 /// \brief Specify whether nested-name-specifiers are allowed.
252 void allowNestedNameSpecifiers(bool Allow = true) {
253 AllowNestedNameSpecifiers = Allow;
256 /// \brief Return the semantic analysis object for which we are collecting
257 /// code completion results.
258 Sema &getSema() const { return SemaRef; }
260 /// \brief Retrieve the allocator used to allocate code completion strings.
261 CodeCompletionAllocator &getAllocator() const { return Allocator; }
263 CodeCompletionTUInfo &getCodeCompletionTUInfo() const { return CCTUInfo; }
265 /// \brief Determine whether the given declaration is at all interesting
266 /// as a code-completion result.
268 /// \param ND the declaration that we are inspecting.
270 /// \param AsNestedNameSpecifier will be set true if this declaration is
271 /// only interesting when it is a nested-name-specifier.
272 bool isInterestingDecl(const NamedDecl *ND,
273 bool &AsNestedNameSpecifier) const;
275 /// \brief Check whether the result is hidden by the Hiding declaration.
277 /// \returns true if the result is hidden and cannot be found, false if
278 /// the hidden result could still be found. When false, \p R may be
279 /// modified to describe how the result can be found (e.g., via extra
281 bool CheckHiddenResult(Result &R, DeclContext *CurContext,
282 const NamedDecl *Hiding);
284 /// \brief Add a new result to this result set (if it isn't already in one
285 /// of the shadow maps), or replace an existing result (for, e.g., a
288 /// \param R the result to add (if it is unique).
290 /// \param CurContext the context in which this result will be named.
291 void MaybeAddResult(Result R, DeclContext *CurContext = nullptr);
293 /// \brief Add a new result to this result set, where we already know
294 /// the hiding declaration (if any).
296 /// \param R the result to add (if it is unique).
298 /// \param CurContext the context in which this result will be named.
300 /// \param Hiding the declaration that hides the result.
302 /// \param InBaseClass whether the result was found in a base
303 /// class of the searched context.
304 void AddResult(Result R, DeclContext *CurContext, NamedDecl *Hiding,
307 /// \brief Add a new non-declaration result to this result set.
308 void AddResult(Result R);
310 /// \brief Enter into a new scope.
311 void EnterNewScope();
313 /// \brief Exit from the current scope.
316 /// \brief Ignore this declaration, if it is seen again.
317 void Ignore(const Decl *D) { AllDeclsFound.insert(D->getCanonicalDecl()); }
319 /// \name Name lookup predicates
321 /// These predicates can be passed to the name lookup functions to filter the
322 /// results of name lookup. All of the predicates have the same type, so that
325 bool IsOrdinaryName(const NamedDecl *ND) const;
326 bool IsOrdinaryNonTypeName(const NamedDecl *ND) const;
327 bool IsIntegralConstantValue(const NamedDecl *ND) const;
328 bool IsOrdinaryNonValueName(const NamedDecl *ND) const;
329 bool IsNestedNameSpecifier(const NamedDecl *ND) const;
330 bool IsEnum(const NamedDecl *ND) const;
331 bool IsClassOrStruct(const NamedDecl *ND) const;
332 bool IsUnion(const NamedDecl *ND) const;
333 bool IsNamespace(const NamedDecl *ND) const;
334 bool IsNamespaceOrAlias(const NamedDecl *ND) const;
335 bool IsType(const NamedDecl *ND) const;
336 bool IsMember(const NamedDecl *ND) const;
337 bool IsObjCIvar(const NamedDecl *ND) const;
338 bool IsObjCMessageReceiver(const NamedDecl *ND) const;
339 bool IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const;
340 bool IsObjCCollection(const NamedDecl *ND) const;
341 bool IsImpossibleToSatisfy(const NamedDecl *ND) const;
346 class ResultBuilder::ShadowMapEntry::iterator {
347 llvm::PointerUnion<const NamedDecl *, const DeclIndexPair *> DeclOrIterator;
348 unsigned SingleDeclIndex;
351 typedef DeclIndexPair value_type;
352 typedef value_type reference;
353 typedef std::ptrdiff_t difference_type;
354 typedef std::input_iterator_tag iterator_category;
360 pointer(const DeclIndexPair &Value) : Value(Value) { }
362 const DeclIndexPair *operator->() const {
367 iterator() : DeclOrIterator((NamedDecl *)nullptr), SingleDeclIndex(0) {}
369 iterator(const NamedDecl *SingleDecl, unsigned Index)
370 : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) { }
372 iterator(const DeclIndexPair *Iterator)
373 : DeclOrIterator(Iterator), SingleDeclIndex(0) { }
375 iterator &operator++() {
376 if (DeclOrIterator.is<const NamedDecl *>()) {
377 DeclOrIterator = (NamedDecl *)nullptr;
382 const DeclIndexPair *I = DeclOrIterator.get<const DeclIndexPair*>();
388 /*iterator operator++(int) {
394 reference operator*() const {
395 if (const NamedDecl *ND = DeclOrIterator.dyn_cast<const NamedDecl *>())
396 return reference(ND, SingleDeclIndex);
398 return *DeclOrIterator.get<const DeclIndexPair*>();
401 pointer operator->() const {
402 return pointer(**this);
405 friend bool operator==(const iterator &X, const iterator &Y) {
406 return X.DeclOrIterator.getOpaqueValue()
407 == Y.DeclOrIterator.getOpaqueValue() &&
408 X.SingleDeclIndex == Y.SingleDeclIndex;
411 friend bool operator!=(const iterator &X, const iterator &Y) {
416 ResultBuilder::ShadowMapEntry::iterator
417 ResultBuilder::ShadowMapEntry::begin() const {
418 if (DeclOrVector.isNull())
421 if (const NamedDecl *ND = DeclOrVector.dyn_cast<const NamedDecl *>())
422 return iterator(ND, SingleDeclIndex);
424 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->begin());
427 ResultBuilder::ShadowMapEntry::iterator
428 ResultBuilder::ShadowMapEntry::end() const {
429 if (DeclOrVector.is<const NamedDecl *>() || DeclOrVector.isNull())
432 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end());
435 /// \brief Compute the qualification required to get from the current context
436 /// (\p CurContext) to the target context (\p TargetContext).
438 /// \param Context the AST context in which the qualification will be used.
440 /// \param CurContext the context where an entity is being named, which is
441 /// typically based on the current scope.
443 /// \param TargetContext the context in which the named entity actually
446 /// \returns a nested name specifier that refers into the target context, or
447 /// NULL if no qualification is needed.
448 static NestedNameSpecifier *
449 getRequiredQualification(ASTContext &Context,
450 const DeclContext *CurContext,
451 const DeclContext *TargetContext) {
452 SmallVector<const DeclContext *, 4> TargetParents;
454 for (const DeclContext *CommonAncestor = TargetContext;
455 CommonAncestor && !CommonAncestor->Encloses(CurContext);
456 CommonAncestor = CommonAncestor->getLookupParent()) {
457 if (CommonAncestor->isTransparentContext() ||
458 CommonAncestor->isFunctionOrMethod())
461 TargetParents.push_back(CommonAncestor);
464 NestedNameSpecifier *Result = nullptr;
465 while (!TargetParents.empty()) {
466 const DeclContext *Parent = TargetParents.pop_back_val();
468 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Parent)) {
469 if (!Namespace->getIdentifier())
472 Result = NestedNameSpecifier::Create(Context, Result, Namespace);
474 else if (const TagDecl *TD = dyn_cast<TagDecl>(Parent))
475 Result = NestedNameSpecifier::Create(Context, Result,
477 Context.getTypeDeclType(TD).getTypePtr());
482 /// Determine whether \p Id is a name reserved for the implementation (C99
483 /// 7.1.3, C++ [lib.global.names]).
484 static bool isReservedName(const IdentifierInfo *Id,
485 bool doubleUnderscoreOnly = false) {
486 if (Id->getLength() < 2)
488 const char *Name = Id->getNameStart();
489 return Name[0] == '_' &&
490 (Name[1] == '_' || (Name[1] >= 'A' && Name[1] <= 'Z' &&
491 !doubleUnderscoreOnly));
494 // Some declarations have reserved names that we don't want to ever show.
495 // Filter out names reserved for the implementation if they come from a
497 static bool shouldIgnoreDueToReservedName(const NamedDecl *ND, Sema &SemaRef) {
498 const IdentifierInfo *Id = ND->getIdentifier();
502 // Ignore reserved names for compiler provided decls.
503 if (isReservedName(Id) && ND->getLocation().isInvalid())
506 // For system headers ignore only double-underscore names.
507 // This allows for system headers providing private symbols with a single
509 if (isReservedName(Id, /*doubleUnderscoreOnly=*/true) &&
510 SemaRef.SourceMgr.isInSystemHeader(
511 SemaRef.SourceMgr.getSpellingLoc(ND->getLocation())))
517 bool ResultBuilder::isInterestingDecl(const NamedDecl *ND,
518 bool &AsNestedNameSpecifier) const {
519 AsNestedNameSpecifier = false;
522 ND = ND->getUnderlyingDecl();
524 // Skip unnamed entities.
525 if (!ND->getDeclName())
528 // Friend declarations and declarations introduced due to friends are never
530 if (ND->getFriendObjectKind() == Decl::FOK_Undeclared)
533 // Class template (partial) specializations are never added as results.
534 if (isa<ClassTemplateSpecializationDecl>(ND) ||
535 isa<ClassTemplatePartialSpecializationDecl>(ND))
538 // Using declarations themselves are never added as results.
539 if (isa<UsingDecl>(ND))
542 if (shouldIgnoreDueToReservedName(ND, SemaRef))
545 if (Filter == &ResultBuilder::IsNestedNameSpecifier ||
546 (isa<NamespaceDecl>(ND) &&
547 Filter != &ResultBuilder::IsNamespace &&
548 Filter != &ResultBuilder::IsNamespaceOrAlias &&
550 AsNestedNameSpecifier = true;
552 // Filter out any unwanted results.
553 if (Filter && !(this->*Filter)(Named)) {
554 // Check whether it is interesting as a nested-name-specifier.
555 if (AllowNestedNameSpecifiers && SemaRef.getLangOpts().CPlusPlus &&
556 IsNestedNameSpecifier(ND) &&
557 (Filter != &ResultBuilder::IsMember ||
558 (isa<CXXRecordDecl>(ND) &&
559 cast<CXXRecordDecl>(ND)->isInjectedClassName()))) {
560 AsNestedNameSpecifier = true;
566 // ... then it must be interesting!
570 bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext,
571 const NamedDecl *Hiding) {
572 // In C, there is no way to refer to a hidden name.
573 // FIXME: This isn't true; we can find a tag name hidden by an ordinary
574 // name if we introduce the tag type.
575 if (!SemaRef.getLangOpts().CPlusPlus)
578 const DeclContext *HiddenCtx =
579 R.Declaration->getDeclContext()->getRedeclContext();
581 // There is no way to qualify a name declared in a function or method.
582 if (HiddenCtx->isFunctionOrMethod())
585 if (HiddenCtx == Hiding->getDeclContext()->getRedeclContext())
588 // We can refer to the result with the appropriate qualification. Do it.
590 R.QualifierIsInformative = false;
593 R.Qualifier = getRequiredQualification(SemaRef.Context,
595 R.Declaration->getDeclContext());
599 /// \brief A simplified classification of types used to determine whether two
600 /// types are "similar enough" when adjusting priorities.
601 SimplifiedTypeClass clang::getSimplifiedTypeClass(CanQualType T) {
602 switch (T->getTypeClass()) {
604 switch (cast<BuiltinType>(T)->getKind()) {
605 case BuiltinType::Void:
608 case BuiltinType::NullPtr:
611 case BuiltinType::Overload:
612 case BuiltinType::Dependent:
615 case BuiltinType::ObjCId:
616 case BuiltinType::ObjCClass:
617 case BuiltinType::ObjCSel:
618 return STC_ObjectiveC;
621 return STC_Arithmetic;
625 return STC_Arithmetic;
630 case Type::BlockPointer:
633 case Type::LValueReference:
634 case Type::RValueReference:
635 return getSimplifiedTypeClass(T->getAs<ReferenceType>()->getPointeeType());
637 case Type::ConstantArray:
638 case Type::IncompleteArray:
639 case Type::VariableArray:
640 case Type::DependentSizedArray:
643 case Type::DependentSizedExtVector:
645 case Type::ExtVector:
646 return STC_Arithmetic;
648 case Type::FunctionProto:
649 case Type::FunctionNoProto:
656 return STC_Arithmetic;
658 case Type::ObjCObject:
659 case Type::ObjCInterface:
660 case Type::ObjCObjectPointer:
661 return STC_ObjectiveC;
668 /// \brief Get the type that a given expression will have if this declaration
669 /// is used as an expression in its "typical" code-completion form.
670 QualType clang::getDeclUsageType(ASTContext &C, const NamedDecl *ND) {
671 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
673 if (const TypeDecl *Type = dyn_cast<TypeDecl>(ND))
674 return C.getTypeDeclType(Type);
675 if (const ObjCInterfaceDecl *Iface = dyn_cast<ObjCInterfaceDecl>(ND))
676 return C.getObjCInterfaceType(Iface);
679 if (const FunctionDecl *Function = ND->getAsFunction())
680 T = Function->getCallResultType();
681 else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND))
682 T = Method->getSendResultType();
683 else if (const EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND))
684 T = C.getTypeDeclType(cast<EnumDecl>(Enumerator->getDeclContext()));
685 else if (const ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND))
686 T = Property->getType();
687 else if (const ValueDecl *Value = dyn_cast<ValueDecl>(ND))
688 T = Value->getType();
692 // Dig through references, function pointers, and block pointers to
693 // get down to the likely type of an expression when the entity is
696 if (const ReferenceType *Ref = T->getAs<ReferenceType>()) {
697 T = Ref->getPointeeType();
701 if (const PointerType *Pointer = T->getAs<PointerType>()) {
702 if (Pointer->getPointeeType()->isFunctionType()) {
703 T = Pointer->getPointeeType();
710 if (const BlockPointerType *Block = T->getAs<BlockPointerType>()) {
711 T = Block->getPointeeType();
715 if (const FunctionType *Function = T->getAs<FunctionType>()) {
716 T = Function->getReturnType();
726 unsigned ResultBuilder::getBasePriority(const NamedDecl *ND) {
730 // Context-based decisions.
731 const DeclContext *LexicalDC = ND->getLexicalDeclContext();
732 if (LexicalDC->isFunctionOrMethod()) {
733 // _cmd is relatively rare
734 if (const ImplicitParamDecl *ImplicitParam =
735 dyn_cast<ImplicitParamDecl>(ND))
736 if (ImplicitParam->getIdentifier() &&
737 ImplicitParam->getIdentifier()->isStr("_cmd"))
740 return CCP_LocalDeclaration;
743 const DeclContext *DC = ND->getDeclContext()->getRedeclContext();
744 if (DC->isRecord() || isa<ObjCContainerDecl>(DC))
745 return CCP_MemberDeclaration;
747 // Content-based decisions.
748 if (isa<EnumConstantDecl>(ND))
751 // Use CCP_Type for type declarations unless we're in a statement, Objective-C
752 // message receiver, or parenthesized expression context. There, it's as
753 // likely that the user will want to write a type as other declarations.
754 if ((isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) &&
755 !(CompletionContext.getKind() == CodeCompletionContext::CCC_Statement ||
756 CompletionContext.getKind()
757 == CodeCompletionContext::CCC_ObjCMessageReceiver ||
758 CompletionContext.getKind()
759 == CodeCompletionContext::CCC_ParenthesizedExpression))
762 return CCP_Declaration;
765 void ResultBuilder::AdjustResultPriorityForDecl(Result &R) {
766 // If this is an Objective-C method declaration whose selector matches our
767 // preferred selector, give it a priority boost.
768 if (!PreferredSelector.isNull())
769 if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(R.Declaration))
770 if (PreferredSelector == Method->getSelector())
771 R.Priority += CCD_SelectorMatch;
773 // If we have a preferred type, adjust the priority for results with exactly-
774 // matching or nearly-matching types.
775 if (!PreferredType.isNull()) {
776 QualType T = getDeclUsageType(SemaRef.Context, R.Declaration);
778 CanQualType TC = SemaRef.Context.getCanonicalType(T);
779 // Check for exactly-matching types (modulo qualifiers).
780 if (SemaRef.Context.hasSameUnqualifiedType(PreferredType, TC))
781 R.Priority /= CCF_ExactTypeMatch;
782 // Check for nearly-matching types, based on classification of each.
783 else if ((getSimplifiedTypeClass(PreferredType)
784 == getSimplifiedTypeClass(TC)) &&
785 !(PreferredType->isEnumeralType() && TC->isEnumeralType()))
786 R.Priority /= CCF_SimilarTypeMatch;
791 void ResultBuilder::MaybeAddConstructorResults(Result R) {
792 if (!SemaRef.getLangOpts().CPlusPlus || !R.Declaration ||
793 !CompletionContext.wantConstructorResults())
796 ASTContext &Context = SemaRef.Context;
797 const NamedDecl *D = R.Declaration;
798 const CXXRecordDecl *Record = nullptr;
799 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D))
800 Record = ClassTemplate->getTemplatedDecl();
801 else if ((Record = dyn_cast<CXXRecordDecl>(D))) {
802 // Skip specializations and partial specializations.
803 if (isa<ClassTemplateSpecializationDecl>(Record))
806 // There are no constructors here.
810 Record = Record->getDefinition();
815 QualType RecordTy = Context.getTypeDeclType(Record);
816 DeclarationName ConstructorName
817 = Context.DeclarationNames.getCXXConstructorName(
818 Context.getCanonicalType(RecordTy));
819 DeclContext::lookup_result Ctors = Record->lookup(ConstructorName);
820 for (DeclContext::lookup_iterator I = Ctors.begin(),
824 R.CursorKind = getCursorKindForDecl(R.Declaration);
825 Results.push_back(R);
829 void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) {
830 assert(!ShadowMaps.empty() && "Must enter into a results scope");
832 if (R.Kind != Result::RK_Declaration) {
833 // For non-declaration results, just add the result.
834 Results.push_back(R);
838 // Look through using declarations.
839 if (const UsingShadowDecl *Using =
840 dyn_cast<UsingShadowDecl>(R.Declaration)) {
841 MaybeAddResult(Result(Using->getTargetDecl(),
842 getBasePriority(Using->getTargetDecl()),
848 const Decl *CanonDecl = R.Declaration->getCanonicalDecl();
849 unsigned IDNS = CanonDecl->getIdentifierNamespace();
851 bool AsNestedNameSpecifier = false;
852 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
855 // C++ constructors are never found by name lookup.
856 if (isa<CXXConstructorDecl>(R.Declaration))
859 ShadowMap &SMap = ShadowMaps.back();
860 ShadowMapEntry::iterator I, IEnd;
861 ShadowMap::iterator NamePos = SMap.find(R.Declaration->getDeclName());
862 if (NamePos != SMap.end()) {
863 I = NamePos->second.begin();
864 IEnd = NamePos->second.end();
867 for (; I != IEnd; ++I) {
868 const NamedDecl *ND = I->first;
869 unsigned Index = I->second;
870 if (ND->getCanonicalDecl() == CanonDecl) {
871 // This is a redeclaration. Always pick the newer declaration.
872 Results[Index].Declaration = R.Declaration;
879 // This is a new declaration in this scope. However, check whether this
880 // declaration name is hidden by a similarly-named declaration in an outer
882 std::list<ShadowMap>::iterator SM, SMEnd = ShadowMaps.end();
884 for (SM = ShadowMaps.begin(); SM != SMEnd; ++SM) {
885 ShadowMapEntry::iterator I, IEnd;
886 ShadowMap::iterator NamePos = SM->find(R.Declaration->getDeclName());
887 if (NamePos != SM->end()) {
888 I = NamePos->second.begin();
889 IEnd = NamePos->second.end();
891 for (; I != IEnd; ++I) {
892 // A tag declaration does not hide a non-tag declaration.
893 if (I->first->hasTagIdentifierNamespace() &&
894 (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary |
895 Decl::IDNS_LocalExtern | Decl::IDNS_ObjCProtocol)))
898 // Protocols are in distinct namespaces from everything else.
899 if (((I->first->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol)
900 || (IDNS & Decl::IDNS_ObjCProtocol)) &&
901 I->first->getIdentifierNamespace() != IDNS)
904 // The newly-added result is hidden by an entry in the shadow map.
905 if (CheckHiddenResult(R, CurContext, I->first))
912 // Make sure that any given declaration only shows up in the result set once.
913 if (!AllDeclsFound.insert(CanonDecl).second)
916 // If the filter is for nested-name-specifiers, then this result starts a
917 // nested-name-specifier.
918 if (AsNestedNameSpecifier) {
919 R.StartsNestedNameSpecifier = true;
920 R.Priority = CCP_NestedNameSpecifier;
922 AdjustResultPriorityForDecl(R);
924 // If this result is supposed to have an informative qualifier, add one.
925 if (R.QualifierIsInformative && !R.Qualifier &&
926 !R.StartsNestedNameSpecifier) {
927 const DeclContext *Ctx = R.Declaration->getDeclContext();
928 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
929 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr,
931 else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
932 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr,
933 false, SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
935 R.QualifierIsInformative = false;
938 // Insert this result into the set of results and into the current shadow
940 SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size());
941 Results.push_back(R);
943 if (!AsNestedNameSpecifier)
944 MaybeAddConstructorResults(R);
947 void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
948 NamedDecl *Hiding, bool InBaseClass = false) {
949 if (R.Kind != Result::RK_Declaration) {
950 // For non-declaration results, just add the result.
951 Results.push_back(R);
955 // Look through using declarations.
956 if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
957 AddResult(Result(Using->getTargetDecl(),
958 getBasePriority(Using->getTargetDecl()),
964 bool AsNestedNameSpecifier = false;
965 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
968 // C++ constructors are never found by name lookup.
969 if (isa<CXXConstructorDecl>(R.Declaration))
972 if (Hiding && CheckHiddenResult(R, CurContext, Hiding))
975 // Make sure that any given declaration only shows up in the result set once.
976 if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl()).second)
979 // If the filter is for nested-name-specifiers, then this result starts a
980 // nested-name-specifier.
981 if (AsNestedNameSpecifier) {
982 R.StartsNestedNameSpecifier = true;
983 R.Priority = CCP_NestedNameSpecifier;
985 else if (Filter == &ResultBuilder::IsMember && !R.Qualifier && InBaseClass &&
986 isa<CXXRecordDecl>(R.Declaration->getDeclContext()
987 ->getRedeclContext()))
988 R.QualifierIsInformative = true;
990 // If this result is supposed to have an informative qualifier, add one.
991 if (R.QualifierIsInformative && !R.Qualifier &&
992 !R.StartsNestedNameSpecifier) {
993 const DeclContext *Ctx = R.Declaration->getDeclContext();
994 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
995 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr,
997 else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
998 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr, false,
999 SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
1001 R.QualifierIsInformative = false;
1004 // Adjust the priority if this result comes from a base class.
1006 R.Priority += CCD_InBaseClass;
1008 AdjustResultPriorityForDecl(R);
1010 if (HasObjectTypeQualifiers)
1011 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(R.Declaration))
1012 if (Method->isInstance()) {
1013 Qualifiers MethodQuals
1014 = Qualifiers::fromCVRMask(Method->getTypeQualifiers());
1015 if (ObjectTypeQualifiers == MethodQuals)
1016 R.Priority += CCD_ObjectQualifierMatch;
1017 else if (ObjectTypeQualifiers - MethodQuals) {
1018 // The method cannot be invoked, because doing so would drop
1024 // Insert this result into the set of results.
1025 Results.push_back(R);
1027 if (!AsNestedNameSpecifier)
1028 MaybeAddConstructorResults(R);
1031 void ResultBuilder::AddResult(Result R) {
1032 assert(R.Kind != Result::RK_Declaration &&
1033 "Declaration results need more context");
1034 Results.push_back(R);
1037 /// \brief Enter into a new scope.
1038 void ResultBuilder::EnterNewScope() { ShadowMaps.emplace_back(); }
1040 /// \brief Exit from the current scope.
1041 void ResultBuilder::ExitScope() {
1042 for (ShadowMap::iterator E = ShadowMaps.back().begin(),
1043 EEnd = ShadowMaps.back().end();
1046 E->second.Destroy();
1048 ShadowMaps.pop_back();
1051 /// \brief Determines whether this given declaration will be found by
1052 /// ordinary name lookup.
1053 bool ResultBuilder::IsOrdinaryName(const NamedDecl *ND) const {
1054 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
1056 // If name lookup finds a local extern declaration, then we are in a
1057 // context where it behaves like an ordinary name.
1058 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1059 if (SemaRef.getLangOpts().CPlusPlus)
1060 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
1061 else if (SemaRef.getLangOpts().ObjC1) {
1062 if (isa<ObjCIvarDecl>(ND))
1066 return ND->getIdentifierNamespace() & IDNS;
1069 /// \brief Determines whether this given declaration will be found by
1070 /// ordinary name lookup but is not a type name.
1071 bool ResultBuilder::IsOrdinaryNonTypeName(const NamedDecl *ND) const {
1072 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
1073 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND))
1076 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1077 if (SemaRef.getLangOpts().CPlusPlus)
1078 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
1079 else if (SemaRef.getLangOpts().ObjC1) {
1080 if (isa<ObjCIvarDecl>(ND))
1084 return ND->getIdentifierNamespace() & IDNS;
1087 bool ResultBuilder::IsIntegralConstantValue(const NamedDecl *ND) const {
1088 if (!IsOrdinaryNonTypeName(ND))
1091 if (const ValueDecl *VD = dyn_cast<ValueDecl>(ND->getUnderlyingDecl()))
1092 if (VD->getType()->isIntegralOrEnumerationType())
1098 /// \brief Determines whether this given declaration will be found by
1099 /// ordinary name lookup.
1100 bool ResultBuilder::IsOrdinaryNonValueName(const NamedDecl *ND) const {
1101 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
1103 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1104 if (SemaRef.getLangOpts().CPlusPlus)
1105 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace;
1107 return (ND->getIdentifierNamespace() & IDNS) &&
1108 !isa<ValueDecl>(ND) && !isa<FunctionTemplateDecl>(ND) &&
1109 !isa<ObjCPropertyDecl>(ND);
1112 /// \brief Determines whether the given declaration is suitable as the
1113 /// start of a C++ nested-name-specifier, e.g., a class or namespace.
1114 bool ResultBuilder::IsNestedNameSpecifier(const NamedDecl *ND) const {
1115 // Allow us to find class templates, too.
1116 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1117 ND = ClassTemplate->getTemplatedDecl();
1119 return SemaRef.isAcceptableNestedNameSpecifier(ND);
1122 /// \brief Determines whether the given declaration is an enumeration.
1123 bool ResultBuilder::IsEnum(const NamedDecl *ND) const {
1124 return isa<EnumDecl>(ND);
1127 /// \brief Determines whether the given declaration is a class or struct.
1128 bool ResultBuilder::IsClassOrStruct(const NamedDecl *ND) const {
1129 // Allow us to find class templates, too.
1130 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1131 ND = ClassTemplate->getTemplatedDecl();
1133 // For purposes of this check, interfaces match too.
1134 if (const RecordDecl *RD = dyn_cast<RecordDecl>(ND))
1135 return RD->getTagKind() == TTK_Class ||
1136 RD->getTagKind() == TTK_Struct ||
1137 RD->getTagKind() == TTK_Interface;
1142 /// \brief Determines whether the given declaration is a union.
1143 bool ResultBuilder::IsUnion(const NamedDecl *ND) const {
1144 // Allow us to find class templates, too.
1145 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1146 ND = ClassTemplate->getTemplatedDecl();
1148 if (const RecordDecl *RD = dyn_cast<RecordDecl>(ND))
1149 return RD->getTagKind() == TTK_Union;
1154 /// \brief Determines whether the given declaration is a namespace.
1155 bool ResultBuilder::IsNamespace(const NamedDecl *ND) const {
1156 return isa<NamespaceDecl>(ND);
1159 /// \brief Determines whether the given declaration is a namespace or
1160 /// namespace alias.
1161 bool ResultBuilder::IsNamespaceOrAlias(const NamedDecl *ND) const {
1162 return isa<NamespaceDecl>(ND->getUnderlyingDecl());
1165 /// \brief Determines whether the given declaration is a type.
1166 bool ResultBuilder::IsType(const NamedDecl *ND) const {
1167 ND = ND->getUnderlyingDecl();
1168 return isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
1171 /// \brief Determines which members of a class should be visible via
1172 /// "." or "->". Only value declarations, nested name specifiers, and
1173 /// using declarations thereof should show up.
1174 bool ResultBuilder::IsMember(const NamedDecl *ND) const {
1175 ND = ND->getUnderlyingDecl();
1176 return isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND) ||
1177 isa<ObjCPropertyDecl>(ND);
1180 static bool isObjCReceiverType(ASTContext &C, QualType T) {
1181 T = C.getCanonicalType(T);
1182 switch (T->getTypeClass()) {
1183 case Type::ObjCObject:
1184 case Type::ObjCInterface:
1185 case Type::ObjCObjectPointer:
1189 switch (cast<BuiltinType>(T)->getKind()) {
1190 case BuiltinType::ObjCId:
1191 case BuiltinType::ObjCClass:
1192 case BuiltinType::ObjCSel:
1204 if (!C.getLangOpts().CPlusPlus)
1207 // FIXME: We could perform more analysis here to determine whether a
1208 // particular class type has any conversions to Objective-C types. For now,
1209 // just accept all class types.
1210 return T->isDependentType() || T->isRecordType();
1213 bool ResultBuilder::IsObjCMessageReceiver(const NamedDecl *ND) const {
1214 QualType T = getDeclUsageType(SemaRef.Context, ND);
1218 T = SemaRef.Context.getBaseElementType(T);
1219 return isObjCReceiverType(SemaRef.Context, T);
1222 bool ResultBuilder::IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const {
1223 if (IsObjCMessageReceiver(ND))
1226 const VarDecl *Var = dyn_cast<VarDecl>(ND);
1230 return Var->hasLocalStorage() && !Var->hasAttr<BlocksAttr>();
1233 bool ResultBuilder::IsObjCCollection(const NamedDecl *ND) const {
1234 if ((SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryName(ND)) ||
1235 (!SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryNonTypeName(ND)))
1238 QualType T = getDeclUsageType(SemaRef.Context, ND);
1242 T = SemaRef.Context.getBaseElementType(T);
1243 return T->isObjCObjectType() || T->isObjCObjectPointerType() ||
1244 T->isObjCIdType() ||
1245 (SemaRef.getLangOpts().CPlusPlus && T->isRecordType());
1248 bool ResultBuilder::IsImpossibleToSatisfy(const NamedDecl *ND) const {
1252 /// \brief Determines whether the given declaration is an Objective-C
1253 /// instance variable.
1254 bool ResultBuilder::IsObjCIvar(const NamedDecl *ND) const {
1255 return isa<ObjCIvarDecl>(ND);
1259 /// \brief Visible declaration consumer that adds a code-completion result
1260 /// for each visible declaration.
1261 class CodeCompletionDeclConsumer : public VisibleDeclConsumer {
1262 ResultBuilder &Results;
1263 DeclContext *CurContext;
1266 CodeCompletionDeclConsumer(ResultBuilder &Results, DeclContext *CurContext)
1267 : Results(Results), CurContext(CurContext) { }
1269 void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,
1270 bool InBaseClass) override {
1271 bool Accessible = true;
1273 Accessible = Results.getSema().IsSimplyAccessible(ND, Ctx);
1275 ResultBuilder::Result Result(ND, Results.getBasePriority(ND), nullptr,
1277 Results.AddResult(Result, CurContext, Hiding, InBaseClass);
1282 /// \brief Add type specifiers for the current language as keyword results.
1283 static void AddTypeSpecifierResults(const LangOptions &LangOpts,
1284 ResultBuilder &Results) {
1285 typedef CodeCompletionResult Result;
1286 Results.AddResult(Result("short", CCP_Type));
1287 Results.AddResult(Result("long", CCP_Type));
1288 Results.AddResult(Result("signed", CCP_Type));
1289 Results.AddResult(Result("unsigned", CCP_Type));
1290 Results.AddResult(Result("void", CCP_Type));
1291 Results.AddResult(Result("char", CCP_Type));
1292 Results.AddResult(Result("int", CCP_Type));
1293 Results.AddResult(Result("float", CCP_Type));
1294 Results.AddResult(Result("double", CCP_Type));
1295 Results.AddResult(Result("enum", CCP_Type));
1296 Results.AddResult(Result("struct", CCP_Type));
1297 Results.AddResult(Result("union", CCP_Type));
1298 Results.AddResult(Result("const", CCP_Type));
1299 Results.AddResult(Result("volatile", CCP_Type));
1303 Results.AddResult(Result("_Complex", CCP_Type));
1304 Results.AddResult(Result("_Imaginary", CCP_Type));
1305 Results.AddResult(Result("_Bool", CCP_Type));
1306 Results.AddResult(Result("restrict", CCP_Type));
1309 CodeCompletionBuilder Builder(Results.getAllocator(),
1310 Results.getCodeCompletionTUInfo());
1311 if (LangOpts.CPlusPlus) {
1313 Results.AddResult(Result("bool", CCP_Type +
1314 (LangOpts.ObjC1? CCD_bool_in_ObjC : 0)));
1315 Results.AddResult(Result("class", CCP_Type));
1316 Results.AddResult(Result("wchar_t", CCP_Type));
1318 // typename qualified-id
1319 Builder.AddTypedTextChunk("typename");
1320 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1321 Builder.AddPlaceholderChunk("qualifier");
1322 Builder.AddTextChunk("::");
1323 Builder.AddPlaceholderChunk("name");
1324 Results.AddResult(Result(Builder.TakeString()));
1326 if (LangOpts.CPlusPlus11) {
1327 Results.AddResult(Result("auto", CCP_Type));
1328 Results.AddResult(Result("char16_t", CCP_Type));
1329 Results.AddResult(Result("char32_t", CCP_Type));
1331 Builder.AddTypedTextChunk("decltype");
1332 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1333 Builder.AddPlaceholderChunk("expression");
1334 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1335 Results.AddResult(Result(Builder.TakeString()));
1338 Results.AddResult(Result("__auto_type", CCP_Type));
1341 if (LangOpts.GNUMode) {
1342 // FIXME: Enable when we actually support decimal floating point.
1343 // Results.AddResult(Result("_Decimal32"));
1344 // Results.AddResult(Result("_Decimal64"));
1345 // Results.AddResult(Result("_Decimal128"));
1347 Builder.AddTypedTextChunk("typeof");
1348 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1349 Builder.AddPlaceholderChunk("expression");
1350 Results.AddResult(Result(Builder.TakeString()));
1352 Builder.AddTypedTextChunk("typeof");
1353 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1354 Builder.AddPlaceholderChunk("type");
1355 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1356 Results.AddResult(Result(Builder.TakeString()));
1360 Results.AddResult(Result("_Nonnull", CCP_Type));
1361 Results.AddResult(Result("_Null_unspecified", CCP_Type));
1362 Results.AddResult(Result("_Nullable", CCP_Type));
1365 static void AddStorageSpecifiers(Sema::ParserCompletionContext CCC,
1366 const LangOptions &LangOpts,
1367 ResultBuilder &Results) {
1368 typedef CodeCompletionResult Result;
1369 // Note: we don't suggest either "auto" or "register", because both
1370 // are pointless as storage specifiers. Elsewhere, we suggest "auto"
1371 // in C++0x as a type specifier.
1372 Results.AddResult(Result("extern"));
1373 Results.AddResult(Result("static"));
1375 if (LangOpts.CPlusPlus11) {
1376 CodeCompletionAllocator &Allocator = Results.getAllocator();
1377 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1380 Builder.AddTypedTextChunk("alignas");
1381 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1382 Builder.AddPlaceholderChunk("expression");
1383 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1384 Results.AddResult(Result(Builder.TakeString()));
1386 Results.AddResult(Result("constexpr"));
1387 Results.AddResult(Result("thread_local"));
1391 static void AddFunctionSpecifiers(Sema::ParserCompletionContext CCC,
1392 const LangOptions &LangOpts,
1393 ResultBuilder &Results) {
1394 typedef CodeCompletionResult Result;
1396 case Sema::PCC_Class:
1397 case Sema::PCC_MemberTemplate:
1398 if (LangOpts.CPlusPlus) {
1399 Results.AddResult(Result("explicit"));
1400 Results.AddResult(Result("friend"));
1401 Results.AddResult(Result("mutable"));
1402 Results.AddResult(Result("virtual"));
1406 case Sema::PCC_ObjCInterface:
1407 case Sema::PCC_ObjCImplementation:
1408 case Sema::PCC_Namespace:
1409 case Sema::PCC_Template:
1410 if (LangOpts.CPlusPlus || LangOpts.C99)
1411 Results.AddResult(Result("inline"));
1414 case Sema::PCC_ObjCInstanceVariableList:
1415 case Sema::PCC_Expression:
1416 case Sema::PCC_Statement:
1417 case Sema::PCC_ForInit:
1418 case Sema::PCC_Condition:
1419 case Sema::PCC_RecoveryInFunction:
1420 case Sema::PCC_Type:
1421 case Sema::PCC_ParenthesizedExpression:
1422 case Sema::PCC_LocalDeclarationSpecifiers:
1427 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt);
1428 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt);
1429 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
1430 ResultBuilder &Results,
1432 static void AddObjCImplementationResults(const LangOptions &LangOpts,
1433 ResultBuilder &Results,
1435 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
1436 ResultBuilder &Results,
1438 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt);
1440 static void AddTypedefResult(ResultBuilder &Results) {
1441 CodeCompletionBuilder Builder(Results.getAllocator(),
1442 Results.getCodeCompletionTUInfo());
1443 Builder.AddTypedTextChunk("typedef");
1444 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1445 Builder.AddPlaceholderChunk("type");
1446 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1447 Builder.AddPlaceholderChunk("name");
1448 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1451 static bool WantTypesInContext(Sema::ParserCompletionContext CCC,
1452 const LangOptions &LangOpts) {
1454 case Sema::PCC_Namespace:
1455 case Sema::PCC_Class:
1456 case Sema::PCC_ObjCInstanceVariableList:
1457 case Sema::PCC_Template:
1458 case Sema::PCC_MemberTemplate:
1459 case Sema::PCC_Statement:
1460 case Sema::PCC_RecoveryInFunction:
1461 case Sema::PCC_Type:
1462 case Sema::PCC_ParenthesizedExpression:
1463 case Sema::PCC_LocalDeclarationSpecifiers:
1466 case Sema::PCC_Expression:
1467 case Sema::PCC_Condition:
1468 return LangOpts.CPlusPlus;
1470 case Sema::PCC_ObjCInterface:
1471 case Sema::PCC_ObjCImplementation:
1474 case Sema::PCC_ForInit:
1475 return LangOpts.CPlusPlus || LangOpts.ObjC1 || LangOpts.C99;
1478 llvm_unreachable("Invalid ParserCompletionContext!");
1481 static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context,
1482 const Preprocessor &PP) {
1483 PrintingPolicy Policy = Sema::getPrintingPolicy(Context, PP);
1484 Policy.AnonymousTagLocations = false;
1485 Policy.SuppressStrongLifetime = true;
1486 Policy.SuppressUnwrittenScope = true;
1490 /// \brief Retrieve a printing policy suitable for code completion.
1491 static PrintingPolicy getCompletionPrintingPolicy(Sema &S) {
1492 return getCompletionPrintingPolicy(S.Context, S.PP);
1495 /// \brief Retrieve the string representation of the given type as a string
1496 /// that has the appropriate lifetime for code completion.
1498 /// This routine provides a fast path where we provide constant strings for
1499 /// common type names.
1500 static const char *GetCompletionTypeString(QualType T,
1501 ASTContext &Context,
1502 const PrintingPolicy &Policy,
1503 CodeCompletionAllocator &Allocator) {
1504 if (!T.getLocalQualifiers()) {
1505 // Built-in type names are constant strings.
1506 if (const BuiltinType *BT = dyn_cast<BuiltinType>(T))
1507 return BT->getNameAsCString(Policy);
1509 // Anonymous tag types are constant strings.
1510 if (const TagType *TagT = dyn_cast<TagType>(T))
1511 if (TagDecl *Tag = TagT->getDecl())
1512 if (!Tag->hasNameForLinkage()) {
1513 switch (Tag->getTagKind()) {
1514 case TTK_Struct: return "struct <anonymous>";
1515 case TTK_Interface: return "__interface <anonymous>";
1516 case TTK_Class: return "class <anonymous>";
1517 case TTK_Union: return "union <anonymous>";
1518 case TTK_Enum: return "enum <anonymous>";
1523 // Slow path: format the type as a string.
1525 T.getAsStringInternal(Result, Policy);
1526 return Allocator.CopyString(Result);
1529 /// \brief Add a completion for "this", if we're in a member function.
1530 static void addThisCompletion(Sema &S, ResultBuilder &Results) {
1531 QualType ThisTy = S.getCurrentThisType();
1532 if (ThisTy.isNull())
1535 CodeCompletionAllocator &Allocator = Results.getAllocator();
1536 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1537 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
1538 Builder.AddResultTypeChunk(GetCompletionTypeString(ThisTy,
1542 Builder.AddTypedTextChunk("this");
1543 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1546 static void AddStaticAssertResult(CodeCompletionBuilder &Builder,
1547 ResultBuilder &Results,
1548 const LangOptions &LangOpts) {
1549 if (!LangOpts.CPlusPlus11)
1552 Builder.AddTypedTextChunk("static_assert");
1553 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1554 Builder.AddPlaceholderChunk("expression");
1555 Builder.AddChunk(CodeCompletionString::CK_Comma);
1556 Builder.AddPlaceholderChunk("message");
1557 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1558 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1561 /// \brief Add language constructs that show up for "ordinary" names.
1562 static void AddOrdinaryNameResults(Sema::ParserCompletionContext CCC,
1565 ResultBuilder &Results) {
1566 CodeCompletionAllocator &Allocator = Results.getAllocator();
1567 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1569 typedef CodeCompletionResult Result;
1571 case Sema::PCC_Namespace:
1572 if (SemaRef.getLangOpts().CPlusPlus) {
1573 if (Results.includeCodePatterns()) {
1574 // namespace <identifier> { declarations }
1575 Builder.AddTypedTextChunk("namespace");
1576 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1577 Builder.AddPlaceholderChunk("identifier");
1578 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1579 Builder.AddPlaceholderChunk("declarations");
1580 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1581 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1582 Results.AddResult(Result(Builder.TakeString()));
1585 // namespace identifier = identifier ;
1586 Builder.AddTypedTextChunk("namespace");
1587 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1588 Builder.AddPlaceholderChunk("name");
1589 Builder.AddChunk(CodeCompletionString::CK_Equal);
1590 Builder.AddPlaceholderChunk("namespace");
1591 Results.AddResult(Result(Builder.TakeString()));
1594 Builder.AddTypedTextChunk("using");
1595 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1596 Builder.AddTextChunk("namespace");
1597 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1598 Builder.AddPlaceholderChunk("identifier");
1599 Results.AddResult(Result(Builder.TakeString()));
1601 // asm(string-literal)
1602 Builder.AddTypedTextChunk("asm");
1603 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1604 Builder.AddPlaceholderChunk("string-literal");
1605 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1606 Results.AddResult(Result(Builder.TakeString()));
1608 if (Results.includeCodePatterns()) {
1609 // Explicit template instantiation
1610 Builder.AddTypedTextChunk("template");
1611 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1612 Builder.AddPlaceholderChunk("declaration");
1613 Results.AddResult(Result(Builder.TakeString()));
1617 if (SemaRef.getLangOpts().ObjC1)
1618 AddObjCTopLevelResults(Results, true);
1620 AddTypedefResult(Results);
1623 case Sema::PCC_Class:
1624 if (SemaRef.getLangOpts().CPlusPlus) {
1625 // Using declaration
1626 Builder.AddTypedTextChunk("using");
1627 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1628 Builder.AddPlaceholderChunk("qualifier");
1629 Builder.AddTextChunk("::");
1630 Builder.AddPlaceholderChunk("name");
1631 Results.AddResult(Result(Builder.TakeString()));
1633 // using typename qualifier::name (only in a dependent context)
1634 if (SemaRef.CurContext->isDependentContext()) {
1635 Builder.AddTypedTextChunk("using");
1636 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1637 Builder.AddTextChunk("typename");
1638 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1639 Builder.AddPlaceholderChunk("qualifier");
1640 Builder.AddTextChunk("::");
1641 Builder.AddPlaceholderChunk("name");
1642 Results.AddResult(Result(Builder.TakeString()));
1645 AddStaticAssertResult(Builder, Results, SemaRef.getLangOpts());
1647 if (CCC == Sema::PCC_Class) {
1648 AddTypedefResult(Results);
1651 Builder.AddTypedTextChunk("public");
1652 if (Results.includeCodePatterns())
1653 Builder.AddChunk(CodeCompletionString::CK_Colon);
1654 Results.AddResult(Result(Builder.TakeString()));
1657 Builder.AddTypedTextChunk("protected");
1658 if (Results.includeCodePatterns())
1659 Builder.AddChunk(CodeCompletionString::CK_Colon);
1660 Results.AddResult(Result(Builder.TakeString()));
1663 Builder.AddTypedTextChunk("private");
1664 if (Results.includeCodePatterns())
1665 Builder.AddChunk(CodeCompletionString::CK_Colon);
1666 Results.AddResult(Result(Builder.TakeString()));
1671 case Sema::PCC_Template:
1672 case Sema::PCC_MemberTemplate:
1673 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns()) {
1674 // template < parameters >
1675 Builder.AddTypedTextChunk("template");
1676 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1677 Builder.AddPlaceholderChunk("parameters");
1678 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1679 Results.AddResult(Result(Builder.TakeString()));
1682 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1683 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1686 case Sema::PCC_ObjCInterface:
1687 AddObjCInterfaceResults(SemaRef.getLangOpts(), Results, true);
1688 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1689 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1692 case Sema::PCC_ObjCImplementation:
1693 AddObjCImplementationResults(SemaRef.getLangOpts(), Results, true);
1694 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1695 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1698 case Sema::PCC_ObjCInstanceVariableList:
1699 AddObjCVisibilityResults(SemaRef.getLangOpts(), Results, true);
1702 case Sema::PCC_RecoveryInFunction:
1703 case Sema::PCC_Statement: {
1704 AddTypedefResult(Results);
1706 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns() &&
1707 SemaRef.getLangOpts().CXXExceptions) {
1708 Builder.AddTypedTextChunk("try");
1709 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1710 Builder.AddPlaceholderChunk("statements");
1711 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1712 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1713 Builder.AddTextChunk("catch");
1714 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1715 Builder.AddPlaceholderChunk("declaration");
1716 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1717 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1718 Builder.AddPlaceholderChunk("statements");
1719 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1720 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1721 Results.AddResult(Result(Builder.TakeString()));
1723 if (SemaRef.getLangOpts().ObjC1)
1724 AddObjCStatementResults(Results, true);
1726 if (Results.includeCodePatterns()) {
1727 // if (condition) { statements }
1728 Builder.AddTypedTextChunk("if");
1729 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1730 if (SemaRef.getLangOpts().CPlusPlus)
1731 Builder.AddPlaceholderChunk("condition");
1733 Builder.AddPlaceholderChunk("expression");
1734 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1735 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1736 Builder.AddPlaceholderChunk("statements");
1737 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1738 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1739 Results.AddResult(Result(Builder.TakeString()));
1741 // switch (condition) { }
1742 Builder.AddTypedTextChunk("switch");
1743 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1744 if (SemaRef.getLangOpts().CPlusPlus)
1745 Builder.AddPlaceholderChunk("condition");
1747 Builder.AddPlaceholderChunk("expression");
1748 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1749 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1750 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1751 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1752 Results.AddResult(Result(Builder.TakeString()));
1755 // Switch-specific statements.
1756 if (!SemaRef.getCurFunction()->SwitchStack.empty()) {
1758 Builder.AddTypedTextChunk("case");
1759 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1760 Builder.AddPlaceholderChunk("expression");
1761 Builder.AddChunk(CodeCompletionString::CK_Colon);
1762 Results.AddResult(Result(Builder.TakeString()));
1765 Builder.AddTypedTextChunk("default");
1766 Builder.AddChunk(CodeCompletionString::CK_Colon);
1767 Results.AddResult(Result(Builder.TakeString()));
1770 if (Results.includeCodePatterns()) {
1771 /// while (condition) { statements }
1772 Builder.AddTypedTextChunk("while");
1773 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1774 if (SemaRef.getLangOpts().CPlusPlus)
1775 Builder.AddPlaceholderChunk("condition");
1777 Builder.AddPlaceholderChunk("expression");
1778 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1779 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1780 Builder.AddPlaceholderChunk("statements");
1781 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1782 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1783 Results.AddResult(Result(Builder.TakeString()));
1785 // do { statements } while ( expression );
1786 Builder.AddTypedTextChunk("do");
1787 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1788 Builder.AddPlaceholderChunk("statements");
1789 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1790 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1791 Builder.AddTextChunk("while");
1792 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1793 Builder.AddPlaceholderChunk("expression");
1794 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1795 Results.AddResult(Result(Builder.TakeString()));
1797 // for ( for-init-statement ; condition ; expression ) { statements }
1798 Builder.AddTypedTextChunk("for");
1799 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1800 if (SemaRef.getLangOpts().CPlusPlus || SemaRef.getLangOpts().C99)
1801 Builder.AddPlaceholderChunk("init-statement");
1803 Builder.AddPlaceholderChunk("init-expression");
1804 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1805 Builder.AddPlaceholderChunk("condition");
1806 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1807 Builder.AddPlaceholderChunk("inc-expression");
1808 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1809 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1810 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1811 Builder.AddPlaceholderChunk("statements");
1812 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1813 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1814 Results.AddResult(Result(Builder.TakeString()));
1817 if (S->getContinueParent()) {
1819 Builder.AddTypedTextChunk("continue");
1820 Results.AddResult(Result(Builder.TakeString()));
1823 if (S->getBreakParent()) {
1825 Builder.AddTypedTextChunk("break");
1826 Results.AddResult(Result(Builder.TakeString()));
1829 // "return expression ;" or "return ;", depending on whether we
1830 // know the function is void or not.
1831 bool isVoid = false;
1832 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(SemaRef.CurContext))
1833 isVoid = Function->getReturnType()->isVoidType();
1834 else if (ObjCMethodDecl *Method
1835 = dyn_cast<ObjCMethodDecl>(SemaRef.CurContext))
1836 isVoid = Method->getReturnType()->isVoidType();
1837 else if (SemaRef.getCurBlock() &&
1838 !SemaRef.getCurBlock()->ReturnType.isNull())
1839 isVoid = SemaRef.getCurBlock()->ReturnType->isVoidType();
1840 Builder.AddTypedTextChunk("return");
1842 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1843 Builder.AddPlaceholderChunk("expression");
1845 Results.AddResult(Result(Builder.TakeString()));
1847 // goto identifier ;
1848 Builder.AddTypedTextChunk("goto");
1849 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1850 Builder.AddPlaceholderChunk("label");
1851 Results.AddResult(Result(Builder.TakeString()));
1854 Builder.AddTypedTextChunk("using");
1855 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1856 Builder.AddTextChunk("namespace");
1857 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1858 Builder.AddPlaceholderChunk("identifier");
1859 Results.AddResult(Result(Builder.TakeString()));
1861 AddStaticAssertResult(Builder, Results, SemaRef.getLangOpts());
1864 // Fall through (for statement expressions).
1865 case Sema::PCC_ForInit:
1866 case Sema::PCC_Condition:
1867 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1868 // Fall through: conditions and statements can have expressions.
1870 case Sema::PCC_ParenthesizedExpression:
1871 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
1872 CCC == Sema::PCC_ParenthesizedExpression) {
1873 // (__bridge <type>)<expression>
1874 Builder.AddTypedTextChunk("__bridge");
1875 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1876 Builder.AddPlaceholderChunk("type");
1877 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1878 Builder.AddPlaceholderChunk("expression");
1879 Results.AddResult(Result(Builder.TakeString()));
1881 // (__bridge_transfer <Objective-C type>)<expression>
1882 Builder.AddTypedTextChunk("__bridge_transfer");
1883 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1884 Builder.AddPlaceholderChunk("Objective-C type");
1885 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1886 Builder.AddPlaceholderChunk("expression");
1887 Results.AddResult(Result(Builder.TakeString()));
1889 // (__bridge_retained <CF type>)<expression>
1890 Builder.AddTypedTextChunk("__bridge_retained");
1891 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1892 Builder.AddPlaceholderChunk("CF type");
1893 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1894 Builder.AddPlaceholderChunk("expression");
1895 Results.AddResult(Result(Builder.TakeString()));
1899 case Sema::PCC_Expression: {
1900 if (SemaRef.getLangOpts().CPlusPlus) {
1901 // 'this', if we're in a non-static member function.
1902 addThisCompletion(SemaRef, Results);
1905 Builder.AddResultTypeChunk("bool");
1906 Builder.AddTypedTextChunk("true");
1907 Results.AddResult(Result(Builder.TakeString()));
1910 Builder.AddResultTypeChunk("bool");
1911 Builder.AddTypedTextChunk("false");
1912 Results.AddResult(Result(Builder.TakeString()));
1914 if (SemaRef.getLangOpts().RTTI) {
1915 // dynamic_cast < type-id > ( expression )
1916 Builder.AddTypedTextChunk("dynamic_cast");
1917 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1918 Builder.AddPlaceholderChunk("type");
1919 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1920 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1921 Builder.AddPlaceholderChunk("expression");
1922 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1923 Results.AddResult(Result(Builder.TakeString()));
1926 // static_cast < type-id > ( expression )
1927 Builder.AddTypedTextChunk("static_cast");
1928 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1929 Builder.AddPlaceholderChunk("type");
1930 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1931 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1932 Builder.AddPlaceholderChunk("expression");
1933 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1934 Results.AddResult(Result(Builder.TakeString()));
1936 // reinterpret_cast < type-id > ( expression )
1937 Builder.AddTypedTextChunk("reinterpret_cast");
1938 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1939 Builder.AddPlaceholderChunk("type");
1940 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1941 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1942 Builder.AddPlaceholderChunk("expression");
1943 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1944 Results.AddResult(Result(Builder.TakeString()));
1946 // const_cast < type-id > ( expression )
1947 Builder.AddTypedTextChunk("const_cast");
1948 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1949 Builder.AddPlaceholderChunk("type");
1950 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1951 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1952 Builder.AddPlaceholderChunk("expression");
1953 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1954 Results.AddResult(Result(Builder.TakeString()));
1956 if (SemaRef.getLangOpts().RTTI) {
1957 // typeid ( expression-or-type )
1958 Builder.AddResultTypeChunk("std::type_info");
1959 Builder.AddTypedTextChunk("typeid");
1960 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1961 Builder.AddPlaceholderChunk("expression-or-type");
1962 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1963 Results.AddResult(Result(Builder.TakeString()));
1967 Builder.AddTypedTextChunk("new");
1968 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1969 Builder.AddPlaceholderChunk("type");
1970 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1971 Builder.AddPlaceholderChunk("expressions");
1972 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1973 Results.AddResult(Result(Builder.TakeString()));
1975 // new T [ ] ( ... )
1976 Builder.AddTypedTextChunk("new");
1977 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1978 Builder.AddPlaceholderChunk("type");
1979 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
1980 Builder.AddPlaceholderChunk("size");
1981 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
1982 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1983 Builder.AddPlaceholderChunk("expressions");
1984 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1985 Results.AddResult(Result(Builder.TakeString()));
1987 // delete expression
1988 Builder.AddResultTypeChunk("void");
1989 Builder.AddTypedTextChunk("delete");
1990 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1991 Builder.AddPlaceholderChunk("expression");
1992 Results.AddResult(Result(Builder.TakeString()));
1994 // delete [] expression
1995 Builder.AddResultTypeChunk("void");
1996 Builder.AddTypedTextChunk("delete");
1997 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1998 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
1999 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
2000 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2001 Builder.AddPlaceholderChunk("expression");
2002 Results.AddResult(Result(Builder.TakeString()));
2004 if (SemaRef.getLangOpts().CXXExceptions) {
2006 Builder.AddResultTypeChunk("void");
2007 Builder.AddTypedTextChunk("throw");
2008 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2009 Builder.AddPlaceholderChunk("expression");
2010 Results.AddResult(Result(Builder.TakeString()));
2015 if (SemaRef.getLangOpts().CPlusPlus11) {
2017 Builder.AddResultTypeChunk("std::nullptr_t");
2018 Builder.AddTypedTextChunk("nullptr");
2019 Results.AddResult(Result(Builder.TakeString()));
2022 Builder.AddResultTypeChunk("size_t");
2023 Builder.AddTypedTextChunk("alignof");
2024 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2025 Builder.AddPlaceholderChunk("type");
2026 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2027 Results.AddResult(Result(Builder.TakeString()));
2030 Builder.AddResultTypeChunk("bool");
2031 Builder.AddTypedTextChunk("noexcept");
2032 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2033 Builder.AddPlaceholderChunk("expression");
2034 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2035 Results.AddResult(Result(Builder.TakeString()));
2037 // sizeof... expression
2038 Builder.AddResultTypeChunk("size_t");
2039 Builder.AddTypedTextChunk("sizeof...");
2040 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2041 Builder.AddPlaceholderChunk("parameter-pack");
2042 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2043 Results.AddResult(Result(Builder.TakeString()));
2047 if (SemaRef.getLangOpts().ObjC1) {
2048 // Add "super", if we're in an Objective-C class with a superclass.
2049 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) {
2050 // The interface can be NULL.
2051 if (ObjCInterfaceDecl *ID = Method->getClassInterface())
2052 if (ID->getSuperClass()) {
2053 std::string SuperType;
2054 SuperType = ID->getSuperClass()->getNameAsString();
2055 if (Method->isInstanceMethod())
2058 Builder.AddResultTypeChunk(Allocator.CopyString(SuperType));
2059 Builder.AddTypedTextChunk("super");
2060 Results.AddResult(Result(Builder.TakeString()));
2064 AddObjCExpressionResults(Results, true);
2067 if (SemaRef.getLangOpts().C11) {
2069 Builder.AddResultTypeChunk("size_t");
2070 if (SemaRef.PP.isMacroDefined("alignof"))
2071 Builder.AddTypedTextChunk("alignof");
2073 Builder.AddTypedTextChunk("_Alignof");
2074 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2075 Builder.AddPlaceholderChunk("type");
2076 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2077 Results.AddResult(Result(Builder.TakeString()));
2080 // sizeof expression
2081 Builder.AddResultTypeChunk("size_t");
2082 Builder.AddTypedTextChunk("sizeof");
2083 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2084 Builder.AddPlaceholderChunk("expression-or-type");
2085 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2086 Results.AddResult(Result(Builder.TakeString()));
2090 case Sema::PCC_Type:
2091 case Sema::PCC_LocalDeclarationSpecifiers:
2095 if (WantTypesInContext(CCC, SemaRef.getLangOpts()))
2096 AddTypeSpecifierResults(SemaRef.getLangOpts(), Results);
2098 if (SemaRef.getLangOpts().CPlusPlus && CCC != Sema::PCC_Type)
2099 Results.AddResult(Result("operator"));
2102 /// \brief If the given declaration has an associated type, add it as a result
2104 static void AddResultTypeChunk(ASTContext &Context,
2105 const PrintingPolicy &Policy,
2106 const NamedDecl *ND,
2108 CodeCompletionBuilder &Result) {
2112 // Skip constructors and conversion functions, which have their return types
2113 // built into their names.
2114 if (isa<CXXConstructorDecl>(ND) || isa<CXXConversionDecl>(ND))
2117 // Determine the type of the declaration (if it has a type).
2119 if (const FunctionDecl *Function = ND->getAsFunction())
2120 T = Function->getReturnType();
2121 else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2122 if (!BaseType.isNull())
2123 T = Method->getSendResultType(BaseType);
2125 T = Method->getReturnType();
2126 } else if (const EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND))
2127 T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext()));
2128 else if (isa<UnresolvedUsingValueDecl>(ND)) {
2129 /* Do nothing: ignore unresolved using declarations*/
2130 } else if (const ObjCIvarDecl *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
2131 if (!BaseType.isNull())
2132 T = Ivar->getUsageType(BaseType);
2134 T = Ivar->getType();
2135 } else if (const ValueDecl *Value = dyn_cast<ValueDecl>(ND)) {
2136 T = Value->getType();
2137 } else if (const ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND)) {
2138 if (!BaseType.isNull())
2139 T = Property->getUsageType(BaseType);
2141 T = Property->getType();
2144 if (T.isNull() || Context.hasSameType(T, Context.DependentTy))
2147 Result.AddResultTypeChunk(GetCompletionTypeString(T, Context, Policy,
2148 Result.getAllocator()));
2151 static void MaybeAddSentinel(Preprocessor &PP,
2152 const NamedDecl *FunctionOrMethod,
2153 CodeCompletionBuilder &Result) {
2154 if (SentinelAttr *Sentinel = FunctionOrMethod->getAttr<SentinelAttr>())
2155 if (Sentinel->getSentinel() == 0) {
2156 if (PP.getLangOpts().ObjC1 && PP.isMacroDefined("nil"))
2157 Result.AddTextChunk(", nil");
2158 else if (PP.isMacroDefined("NULL"))
2159 Result.AddTextChunk(", NULL");
2161 Result.AddTextChunk(", (void*)0");
2165 static std::string formatObjCParamQualifiers(unsigned ObjCQuals,
2168 if (ObjCQuals & Decl::OBJC_TQ_In)
2170 else if (ObjCQuals & Decl::OBJC_TQ_Inout)
2172 else if (ObjCQuals & Decl::OBJC_TQ_Out)
2174 if (ObjCQuals & Decl::OBJC_TQ_Bycopy)
2175 Result += "bycopy ";
2176 else if (ObjCQuals & Decl::OBJC_TQ_Byref)
2178 if (ObjCQuals & Decl::OBJC_TQ_Oneway)
2179 Result += "oneway ";
2180 if (ObjCQuals & Decl::OBJC_TQ_CSNullability) {
2181 if (auto nullability = AttributedType::stripOuterNullability(Type)) {
2182 switch (*nullability) {
2183 case NullabilityKind::NonNull:
2184 Result += "nonnull ";
2187 case NullabilityKind::Nullable:
2188 Result += "nullable ";
2191 case NullabilityKind::Unspecified:
2192 Result += "null_unspecified ";
2200 /// \brief Tries to find the most appropriate type location for an Objective-C
2201 /// block placeholder.
2203 /// This function ignores things like typedefs and qualifiers in order to
2204 /// present the most relevant and accurate block placeholders in code completion
2206 static void findTypeLocationForBlockDecl(const TypeSourceInfo *TSInfo,
2207 FunctionTypeLoc &Block,
2208 FunctionProtoTypeLoc &BlockProto,
2209 bool SuppressBlock = false) {
2212 TypeLoc TL = TSInfo->getTypeLoc().getUnqualifiedLoc();
2214 // Look through typedefs.
2215 if (!SuppressBlock) {
2216 if (TypedefTypeLoc TypedefTL = TL.getAs<TypedefTypeLoc>()) {
2217 if (TypeSourceInfo *InnerTSInfo =
2218 TypedefTL.getTypedefNameDecl()->getTypeSourceInfo()) {
2219 TL = InnerTSInfo->getTypeLoc().getUnqualifiedLoc();
2224 // Look through qualified types
2225 if (QualifiedTypeLoc QualifiedTL = TL.getAs<QualifiedTypeLoc>()) {
2226 TL = QualifiedTL.getUnqualifiedLoc();
2230 if (AttributedTypeLoc AttrTL = TL.getAs<AttributedTypeLoc>()) {
2231 TL = AttrTL.getModifiedLoc();
2236 // Try to get the function prototype behind the block pointer type,
2238 if (BlockPointerTypeLoc BlockPtr = TL.getAs<BlockPointerTypeLoc>()) {
2239 TL = BlockPtr.getPointeeLoc().IgnoreParens();
2240 Block = TL.getAs<FunctionTypeLoc>();
2241 BlockProto = TL.getAs<FunctionProtoTypeLoc>();
2248 formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
2249 FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
2250 bool SuppressBlockName = false,
2251 bool SuppressBlock = false,
2252 Optional<ArrayRef<QualType>> ObjCSubsts = None);
2254 static std::string FormatFunctionParameter(const PrintingPolicy &Policy,
2255 const ParmVarDecl *Param,
2256 bool SuppressName = false,
2257 bool SuppressBlock = false,
2258 Optional<ArrayRef<QualType>> ObjCSubsts = None) {
2259 bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext());
2260 if (Param->getType()->isDependentType() ||
2261 !Param->getType()->isBlockPointerType()) {
2262 // The argument for a dependent or non-block parameter is a placeholder
2263 // containing that parameter's type.
2266 if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName)
2267 Result = Param->getIdentifier()->getName();
2269 QualType Type = Param->getType();
2271 Type = Type.substObjCTypeArgs(Param->getASTContext(), *ObjCSubsts,
2272 ObjCSubstitutionContext::Parameter);
2273 if (ObjCMethodParam) {
2274 Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(),
2276 Result += Type.getAsString(Policy) + ")";
2277 if (Param->getIdentifier() && !SuppressName)
2278 Result += Param->getIdentifier()->getName();
2280 Type.getAsStringInternal(Result, Policy);
2285 // The argument for a block pointer parameter is a block literal with
2286 // the appropriate type.
2287 FunctionTypeLoc Block;
2288 FunctionProtoTypeLoc BlockProto;
2289 findTypeLocationForBlockDecl(Param->getTypeSourceInfo(), Block, BlockProto,
2291 // Try to retrieve the block type information from the property if this is a
2292 // parameter in a setter.
2293 if (!Block && ObjCMethodParam &&
2294 cast<ObjCMethodDecl>(Param->getDeclContext())->isPropertyAccessor()) {
2295 if (const auto *PD = cast<ObjCMethodDecl>(Param->getDeclContext())
2296 ->findPropertyDecl(/*CheckOverrides=*/false))
2297 findTypeLocationForBlockDecl(PD->getTypeSourceInfo(), Block, BlockProto,
2302 // We were unable to find a FunctionProtoTypeLoc with parameter names
2303 // for the block; just use the parameter type as a placeholder.
2305 if (!ObjCMethodParam && Param->getIdentifier())
2306 Result = Param->getIdentifier()->getName();
2308 QualType Type = Param->getType().getUnqualifiedType();
2310 if (ObjCMethodParam) {
2311 Result = Type.getAsString(Policy);
2313 formatObjCParamQualifiers(Param->getObjCDeclQualifier(), Type);
2315 Result = "(" + Quals + " " + Result + ")";
2316 if (Result.back() != ')')
2318 if (Param->getIdentifier())
2319 Result += Param->getIdentifier()->getName();
2321 Type.getAsStringInternal(Result, Policy);
2327 // We have the function prototype behind the block pointer type, as it was
2328 // written in the source.
2329 return formatBlockPlaceholder(Policy, Param, Block, BlockProto,
2330 /*SuppressBlockName=*/false, SuppressBlock,
2334 /// \brief Returns a placeholder string that corresponds to an Objective-C block
2337 /// \param BlockDecl A declaration with an Objective-C block type.
2339 /// \param Block The most relevant type location for that block type.
2341 /// \param SuppressBlockName Determines wether or not the name of the block
2342 /// declaration is included in the resulting string.
2344 formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
2345 FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
2346 bool SuppressBlockName, bool SuppressBlock,
2347 Optional<ArrayRef<QualType>> ObjCSubsts) {
2349 QualType ResultType = Block.getTypePtr()->getReturnType();
2352 ResultType.substObjCTypeArgs(BlockDecl->getASTContext(), *ObjCSubsts,
2353 ObjCSubstitutionContext::Result);
2354 if (!ResultType->isVoidType() || SuppressBlock)
2355 ResultType.getAsStringInternal(Result, Policy);
2357 // Format the parameter list.
2359 if (!BlockProto || Block.getNumParams() == 0) {
2360 if (BlockProto && BlockProto.getTypePtr()->isVariadic())
2366 for (unsigned I = 0, N = Block.getNumParams(); I != N; ++I) {
2369 Params += FormatFunctionParameter(Policy, Block.getParam(I),
2370 /*SuppressName=*/false,
2371 /*SuppressBlock=*/true, ObjCSubsts);
2373 if (I == N - 1 && BlockProto.getTypePtr()->isVariadic())
2379 if (SuppressBlock) {
2380 // Format as a parameter.
2381 Result = Result + " (^";
2382 if (!SuppressBlockName && BlockDecl->getIdentifier())
2383 Result += BlockDecl->getIdentifier()->getName();
2387 // Format as a block literal argument.
2388 Result = '^' + Result;
2391 if (!SuppressBlockName && BlockDecl->getIdentifier())
2392 Result += BlockDecl->getIdentifier()->getName();
2398 /// \brief Add function parameter chunks to the given code completion string.
2399 static void AddFunctionParameterChunks(Preprocessor &PP,
2400 const PrintingPolicy &Policy,
2401 const FunctionDecl *Function,
2402 CodeCompletionBuilder &Result,
2404 bool InOptional = false) {
2405 bool FirstParameter = true;
2407 for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) {
2408 const ParmVarDecl *Param = Function->getParamDecl(P);
2410 if (Param->hasDefaultArg() && !InOptional) {
2411 // When we see an optional default argument, put that argument and
2412 // the remaining default arguments into a new, optional string.
2413 CodeCompletionBuilder Opt(Result.getAllocator(),
2414 Result.getCodeCompletionTUInfo());
2415 if (!FirstParameter)
2416 Opt.AddChunk(CodeCompletionString::CK_Comma);
2417 AddFunctionParameterChunks(PP, Policy, Function, Opt, P, true);
2418 Result.AddOptionalChunk(Opt.TakeString());
2423 FirstParameter = false;
2425 Result.AddChunk(CodeCompletionString::CK_Comma);
2429 // Format the placeholder string.
2430 std::string PlaceholderStr = FormatFunctionParameter(Policy, Param);
2432 if (Function->isVariadic() && P == N - 1)
2433 PlaceholderStr += ", ...";
2435 // Add the placeholder string.
2436 Result.AddPlaceholderChunk(
2437 Result.getAllocator().CopyString(PlaceholderStr));
2440 if (const FunctionProtoType *Proto
2441 = Function->getType()->getAs<FunctionProtoType>())
2442 if (Proto->isVariadic()) {
2443 if (Proto->getNumParams() == 0)
2444 Result.AddPlaceholderChunk("...");
2446 MaybeAddSentinel(PP, Function, Result);
2450 /// \brief Add template parameter chunks to the given code completion string.
2451 static void AddTemplateParameterChunks(ASTContext &Context,
2452 const PrintingPolicy &Policy,
2453 const TemplateDecl *Template,
2454 CodeCompletionBuilder &Result,
2455 unsigned MaxParameters = 0,
2457 bool InDefaultArg = false) {
2458 bool FirstParameter = true;
2460 // Prefer to take the template parameter names from the first declaration of
2462 Template = cast<TemplateDecl>(Template->getCanonicalDecl());
2464 TemplateParameterList *Params = Template->getTemplateParameters();
2465 TemplateParameterList::iterator PEnd = Params->end();
2467 PEnd = Params->begin() + MaxParameters;
2468 for (TemplateParameterList::iterator P = Params->begin() + Start;
2470 bool HasDefaultArg = false;
2471 std::string PlaceholderStr;
2472 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
2473 if (TTP->wasDeclaredWithTypename())
2474 PlaceholderStr = "typename";
2476 PlaceholderStr = "class";
2478 if (TTP->getIdentifier()) {
2479 PlaceholderStr += ' ';
2480 PlaceholderStr += TTP->getIdentifier()->getName();
2483 HasDefaultArg = TTP->hasDefaultArgument();
2484 } else if (NonTypeTemplateParmDecl *NTTP
2485 = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
2486 if (NTTP->getIdentifier())
2487 PlaceholderStr = NTTP->getIdentifier()->getName();
2488 NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
2489 HasDefaultArg = NTTP->hasDefaultArgument();
2491 assert(isa<TemplateTemplateParmDecl>(*P));
2492 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
2494 // Since putting the template argument list into the placeholder would
2495 // be very, very long, we just use an abbreviation.
2496 PlaceholderStr = "template<...> class";
2497 if (TTP->getIdentifier()) {
2498 PlaceholderStr += ' ';
2499 PlaceholderStr += TTP->getIdentifier()->getName();
2502 HasDefaultArg = TTP->hasDefaultArgument();
2505 if (HasDefaultArg && !InDefaultArg) {
2506 // When we see an optional default argument, put that argument and
2507 // the remaining default arguments into a new, optional string.
2508 CodeCompletionBuilder Opt(Result.getAllocator(),
2509 Result.getCodeCompletionTUInfo());
2510 if (!FirstParameter)
2511 Opt.AddChunk(CodeCompletionString::CK_Comma);
2512 AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters,
2513 P - Params->begin(), true);
2514 Result.AddOptionalChunk(Opt.TakeString());
2518 InDefaultArg = false;
2521 FirstParameter = false;
2523 Result.AddChunk(CodeCompletionString::CK_Comma);
2525 // Add the placeholder string.
2526 Result.AddPlaceholderChunk(
2527 Result.getAllocator().CopyString(PlaceholderStr));
2531 /// \brief Add a qualifier to the given code-completion string, if the
2532 /// provided nested-name-specifier is non-NULL.
2534 AddQualifierToCompletionString(CodeCompletionBuilder &Result,
2535 NestedNameSpecifier *Qualifier,
2536 bool QualifierIsInformative,
2537 ASTContext &Context,
2538 const PrintingPolicy &Policy) {
2542 std::string PrintedNNS;
2544 llvm::raw_string_ostream OS(PrintedNNS);
2545 Qualifier->print(OS, Policy);
2547 if (QualifierIsInformative)
2548 Result.AddInformativeChunk(Result.getAllocator().CopyString(PrintedNNS));
2550 Result.AddTextChunk(Result.getAllocator().CopyString(PrintedNNS));
2554 AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result,
2555 const FunctionDecl *Function) {
2556 const FunctionProtoType *Proto
2557 = Function->getType()->getAs<FunctionProtoType>();
2558 if (!Proto || !Proto->getTypeQuals())
2561 // FIXME: Add ref-qualifier!
2563 // Handle single qualifiers without copying
2564 if (Proto->getTypeQuals() == Qualifiers::Const) {
2565 Result.AddInformativeChunk(" const");
2569 if (Proto->getTypeQuals() == Qualifiers::Volatile) {
2570 Result.AddInformativeChunk(" volatile");
2574 if (Proto->getTypeQuals() == Qualifiers::Restrict) {
2575 Result.AddInformativeChunk(" restrict");
2579 // Handle multiple qualifiers.
2580 std::string QualsStr;
2581 if (Proto->isConst())
2582 QualsStr += " const";
2583 if (Proto->isVolatile())
2584 QualsStr += " volatile";
2585 if (Proto->isRestrict())
2586 QualsStr += " restrict";
2587 Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
2590 /// \brief Add the name of the given declaration
2591 static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy,
2592 const NamedDecl *ND,
2593 CodeCompletionBuilder &Result) {
2594 DeclarationName Name = ND->getDeclName();
2598 switch (Name.getNameKind()) {
2599 case DeclarationName::CXXOperatorName: {
2600 const char *OperatorName = nullptr;
2601 switch (Name.getCXXOverloadedOperator()) {
2603 case OO_Conditional:
2604 case NUM_OVERLOADED_OPERATORS:
2605 OperatorName = "operator";
2608 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2609 case OO_##Name: OperatorName = "operator" Spelling; break;
2610 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2611 #include "clang/Basic/OperatorKinds.def"
2613 case OO_New: OperatorName = "operator new"; break;
2614 case OO_Delete: OperatorName = "operator delete"; break;
2615 case OO_Array_New: OperatorName = "operator new[]"; break;
2616 case OO_Array_Delete: OperatorName = "operator delete[]"; break;
2617 case OO_Call: OperatorName = "operator()"; break;
2618 case OO_Subscript: OperatorName = "operator[]"; break;
2620 Result.AddTypedTextChunk(OperatorName);
2624 case DeclarationName::Identifier:
2625 case DeclarationName::CXXConversionFunctionName:
2626 case DeclarationName::CXXDestructorName:
2627 case DeclarationName::CXXLiteralOperatorName:
2628 Result.AddTypedTextChunk(
2629 Result.getAllocator().CopyString(ND->getNameAsString()));
2632 case DeclarationName::CXXDeductionGuideName:
2633 case DeclarationName::CXXUsingDirective:
2634 case DeclarationName::ObjCZeroArgSelector:
2635 case DeclarationName::ObjCOneArgSelector:
2636 case DeclarationName::ObjCMultiArgSelector:
2639 case DeclarationName::CXXConstructorName: {
2640 CXXRecordDecl *Record = nullptr;
2641 QualType Ty = Name.getCXXNameType();
2642 if (const RecordType *RecordTy = Ty->getAs<RecordType>())
2643 Record = cast<CXXRecordDecl>(RecordTy->getDecl());
2644 else if (const InjectedClassNameType *InjectedTy
2645 = Ty->getAs<InjectedClassNameType>())
2646 Record = InjectedTy->getDecl();
2648 Result.AddTypedTextChunk(
2649 Result.getAllocator().CopyString(ND->getNameAsString()));
2653 Result.AddTypedTextChunk(
2654 Result.getAllocator().CopyString(Record->getNameAsString()));
2655 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) {
2656 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2657 AddTemplateParameterChunks(Context, Policy, Template, Result);
2658 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2665 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(Sema &S,
2666 const CodeCompletionContext &CCContext,
2667 CodeCompletionAllocator &Allocator,
2668 CodeCompletionTUInfo &CCTUInfo,
2669 bool IncludeBriefComments) {
2670 return CreateCodeCompletionString(S.Context, S.PP, CCContext, Allocator,
2671 CCTUInfo, IncludeBriefComments);
2674 /// \brief If possible, create a new code completion string for the given
2677 /// \returns Either a new, heap-allocated code completion string describing
2678 /// how to use this result, or NULL to indicate that the string or name of the
2679 /// result is all that is needed.
2680 CodeCompletionString *
2681 CodeCompletionResult::CreateCodeCompletionString(ASTContext &Ctx,
2683 const CodeCompletionContext &CCContext,
2684 CodeCompletionAllocator &Allocator,
2685 CodeCompletionTUInfo &CCTUInfo,
2686 bool IncludeBriefComments) {
2687 CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
2689 PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP);
2690 if (Kind == RK_Pattern) {
2691 Pattern->Priority = Priority;
2692 Pattern->Availability = Availability;
2695 Result.addParentContext(Declaration->getDeclContext());
2696 Pattern->ParentName = Result.getParentName();
2697 // Provide code completion comment for self.GetterName where
2698 // GetterName is the getter method for a property with name
2699 // different from the property name (declared via a property
2700 // getter attribute.
2701 const NamedDecl *ND = Declaration;
2702 if (const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(ND))
2703 if (M->isPropertyAccessor())
2704 if (const ObjCPropertyDecl *PDecl = M->findPropertyDecl())
2705 if (PDecl->getGetterName() == M->getSelector() &&
2706 PDecl->getIdentifier() != M->getIdentifier()) {
2707 if (const RawComment *RC =
2708 Ctx.getRawCommentForAnyRedecl(M)) {
2709 Result.addBriefComment(RC->getBriefText(Ctx));
2710 Pattern->BriefComment = Result.getBriefComment();
2712 else if (const RawComment *RC =
2713 Ctx.getRawCommentForAnyRedecl(PDecl)) {
2714 Result.addBriefComment(RC->getBriefText(Ctx));
2715 Pattern->BriefComment = Result.getBriefComment();
2723 if (Kind == RK_Keyword) {
2724 Result.AddTypedTextChunk(Keyword);
2725 return Result.TakeString();
2728 if (Kind == RK_Macro) {
2729 const MacroInfo *MI = PP.getMacroInfo(Macro);
2730 Result.AddTypedTextChunk(
2731 Result.getAllocator().CopyString(Macro->getName()));
2733 if (!MI || !MI->isFunctionLike())
2734 return Result.TakeString();
2736 // Format a function-like macro with placeholders for the arguments.
2737 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2738 MacroInfo::arg_iterator A = MI->arg_begin(), AEnd = MI->arg_end();
2740 // C99 variadic macros add __VA_ARGS__ at the end. Skip it.
2741 if (MI->isC99Varargs()) {
2745 Result.AddPlaceholderChunk("...");
2749 for (MacroInfo::arg_iterator A = MI->arg_begin(); A != AEnd; ++A) {
2750 if (A != MI->arg_begin())
2751 Result.AddChunk(CodeCompletionString::CK_Comma);
2753 if (MI->isVariadic() && (A+1) == AEnd) {
2754 SmallString<32> Arg = (*A)->getName();
2755 if (MI->isC99Varargs())
2759 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
2763 // Non-variadic macros are simple.
2764 Result.AddPlaceholderChunk(
2765 Result.getAllocator().CopyString((*A)->getName()));
2767 Result.AddChunk(CodeCompletionString::CK_RightParen);
2768 return Result.TakeString();
2771 assert(Kind == RK_Declaration && "Missed a result kind?");
2772 const NamedDecl *ND = Declaration;
2773 Result.addParentContext(ND->getDeclContext());
2775 if (IncludeBriefComments) {
2776 // Add documentation comment, if it exists.
2777 if (const RawComment *RC = Ctx.getRawCommentForAnyRedecl(ND)) {
2778 Result.addBriefComment(RC->getBriefText(Ctx));
2780 else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND))
2781 if (OMD->isPropertyAccessor())
2782 if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())
2783 if (const RawComment *RC = Ctx.getRawCommentForAnyRedecl(PDecl))
2784 Result.addBriefComment(RC->getBriefText(Ctx));
2787 if (StartsNestedNameSpecifier) {
2788 Result.AddTypedTextChunk(
2789 Result.getAllocator().CopyString(ND->getNameAsString()));
2790 Result.AddTextChunk("::");
2791 return Result.TakeString();
2794 for (const auto *I : ND->specific_attrs<AnnotateAttr>())
2795 Result.AddAnnotation(Result.getAllocator().CopyString(I->getAnnotation()));
2797 AddResultTypeChunk(Ctx, Policy, ND, CCContext.getBaseType(), Result);
2799 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) {
2800 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2802 AddTypedNameChunk(Ctx, Policy, ND, Result);
2803 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2804 AddFunctionParameterChunks(PP, Policy, Function, Result);
2805 Result.AddChunk(CodeCompletionString::CK_RightParen);
2806 AddFunctionTypeQualsToCompletionString(Result, Function);
2807 return Result.TakeString();
2810 if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) {
2811 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2813 FunctionDecl *Function = FunTmpl->getTemplatedDecl();
2814 AddTypedNameChunk(Ctx, Policy, Function, Result);
2816 // Figure out which template parameters are deduced (or have default
2818 llvm::SmallBitVector Deduced;
2819 Sema::MarkDeducedTemplateParameters(Ctx, FunTmpl, Deduced);
2820 unsigned LastDeducibleArgument;
2821 for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0;
2822 --LastDeducibleArgument) {
2823 if (!Deduced[LastDeducibleArgument - 1]) {
2824 // C++0x: Figure out if the template argument has a default. If so,
2825 // the user doesn't need to type this argument.
2826 // FIXME: We need to abstract template parameters better!
2827 bool HasDefaultArg = false;
2828 NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam(
2829 LastDeducibleArgument - 1);
2830 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
2831 HasDefaultArg = TTP->hasDefaultArgument();
2832 else if (NonTypeTemplateParmDecl *NTTP
2833 = dyn_cast<NonTypeTemplateParmDecl>(Param))
2834 HasDefaultArg = NTTP->hasDefaultArgument();
2836 assert(isa<TemplateTemplateParmDecl>(Param));
2838 = cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument();
2846 if (LastDeducibleArgument) {
2847 // Some of the function template arguments cannot be deduced from a
2848 // function call, so we introduce an explicit template argument list
2849 // containing all of the arguments up to the first deducible argument.
2850 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2851 AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result,
2852 LastDeducibleArgument);
2853 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2856 // Add the function parameters
2857 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2858 AddFunctionParameterChunks(PP, Policy, Function, Result);
2859 Result.AddChunk(CodeCompletionString::CK_RightParen);
2860 AddFunctionTypeQualsToCompletionString(Result, Function);
2861 return Result.TakeString();
2864 if (const TemplateDecl *Template = dyn_cast<TemplateDecl>(ND)) {
2865 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2867 Result.AddTypedTextChunk(
2868 Result.getAllocator().CopyString(Template->getNameAsString()));
2869 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2870 AddTemplateParameterChunks(Ctx, Policy, Template, Result);
2871 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2872 return Result.TakeString();
2875 if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2876 Selector Sel = Method->getSelector();
2877 if (Sel.isUnarySelector()) {
2878 Result.AddTypedTextChunk(Result.getAllocator().CopyString(
2879 Sel.getNameForSlot(0)));
2880 return Result.TakeString();
2883 std::string SelName = Sel.getNameForSlot(0).str();
2885 if (StartParameter == 0)
2886 Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName));
2888 Result.AddInformativeChunk(Result.getAllocator().CopyString(SelName));
2890 // If there is only one parameter, and we're past it, add an empty
2891 // typed-text chunk since there is nothing to type.
2892 if (Method->param_size() == 1)
2893 Result.AddTypedTextChunk("");
2896 for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(),
2897 PEnd = Method->param_end();
2898 P != PEnd; (void)++P, ++Idx) {
2900 std::string Keyword;
2901 if (Idx > StartParameter)
2902 Result.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2903 if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx))
2904 Keyword += II->getName();
2906 if (Idx < StartParameter || AllParametersAreInformative)
2907 Result.AddInformativeChunk(Result.getAllocator().CopyString(Keyword));
2909 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Keyword));
2912 // If we're before the starting parameter, skip the placeholder.
2913 if (Idx < StartParameter)
2917 QualType ParamType = (*P)->getType();
2918 Optional<ArrayRef<QualType>> ObjCSubsts;
2919 if (!CCContext.getBaseType().isNull())
2920 ObjCSubsts = CCContext.getBaseType()->getObjCSubstitutions(Method);
2922 if (ParamType->isBlockPointerType() && !DeclaringEntity)
2923 Arg = FormatFunctionParameter(Policy, *P, true,
2924 /*SuppressBlock=*/false,
2928 ParamType = ParamType.substObjCTypeArgs(Ctx, *ObjCSubsts,
2929 ObjCSubstitutionContext::Parameter);
2930 Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier(),
2932 Arg += ParamType.getAsString(Policy) + ")";
2933 if (IdentifierInfo *II = (*P)->getIdentifier())
2934 if (DeclaringEntity || AllParametersAreInformative)
2935 Arg += II->getName();
2938 if (Method->isVariadic() && (P + 1) == PEnd)
2941 if (DeclaringEntity)
2942 Result.AddTextChunk(Result.getAllocator().CopyString(Arg));
2943 else if (AllParametersAreInformative)
2944 Result.AddInformativeChunk(Result.getAllocator().CopyString(Arg));
2946 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
2949 if (Method->isVariadic()) {
2950 if (Method->param_size() == 0) {
2951 if (DeclaringEntity)
2952 Result.AddTextChunk(", ...");
2953 else if (AllParametersAreInformative)
2954 Result.AddInformativeChunk(", ...");
2956 Result.AddPlaceholderChunk(", ...");
2959 MaybeAddSentinel(PP, Method, Result);
2962 return Result.TakeString();
2966 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2969 Result.AddTypedTextChunk(
2970 Result.getAllocator().CopyString(ND->getNameAsString()));
2971 return Result.TakeString();
2974 /// \brief Add function overload parameter chunks to the given code completion
2976 static void AddOverloadParameterChunks(ASTContext &Context,
2977 const PrintingPolicy &Policy,
2978 const FunctionDecl *Function,
2979 const FunctionProtoType *Prototype,
2980 CodeCompletionBuilder &Result,
2981 unsigned CurrentArg,
2983 bool InOptional = false) {
2984 bool FirstParameter = true;
2985 unsigned NumParams = Function ? Function->getNumParams()
2986 : Prototype->getNumParams();
2988 for (unsigned P = Start; P != NumParams; ++P) {
2989 if (Function && Function->getParamDecl(P)->hasDefaultArg() && !InOptional) {
2990 // When we see an optional default argument, put that argument and
2991 // the remaining default arguments into a new, optional string.
2992 CodeCompletionBuilder Opt(Result.getAllocator(),
2993 Result.getCodeCompletionTUInfo());
2994 if (!FirstParameter)
2995 Opt.AddChunk(CodeCompletionString::CK_Comma);
2996 // Optional sections are nested.
2997 AddOverloadParameterChunks(Context, Policy, Function, Prototype, Opt,
2998 CurrentArg, P, /*InOptional=*/true);
2999 Result.AddOptionalChunk(Opt.TakeString());
3004 FirstParameter = false;
3006 Result.AddChunk(CodeCompletionString::CK_Comma);
3010 // Format the placeholder string.
3011 std::string Placeholder;
3013 Placeholder = FormatFunctionParameter(Policy, Function->getParamDecl(P));
3015 Placeholder = Prototype->getParamType(P).getAsString(Policy);
3017 if (P == CurrentArg)
3018 Result.AddCurrentParameterChunk(
3019 Result.getAllocator().CopyString(Placeholder));
3021 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Placeholder));
3024 if (Prototype && Prototype->isVariadic()) {
3025 CodeCompletionBuilder Opt(Result.getAllocator(),
3026 Result.getCodeCompletionTUInfo());
3027 if (!FirstParameter)
3028 Opt.AddChunk(CodeCompletionString::CK_Comma);
3030 if (CurrentArg < NumParams)
3031 Opt.AddPlaceholderChunk("...");
3033 Opt.AddCurrentParameterChunk("...");
3035 Result.AddOptionalChunk(Opt.TakeString());
3039 CodeCompletionString *
3040 CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
3041 unsigned CurrentArg, Sema &S,
3042 CodeCompletionAllocator &Allocator,
3043 CodeCompletionTUInfo &CCTUInfo,
3044 bool IncludeBriefComments) const {
3045 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
3047 // FIXME: Set priority, availability appropriately.
3048 CodeCompletionBuilder Result(Allocator,CCTUInfo, 1, CXAvailability_Available);
3049 FunctionDecl *FDecl = getFunction();
3050 const FunctionProtoType *Proto
3051 = dyn_cast<FunctionProtoType>(getFunctionType());
3052 if (!FDecl && !Proto) {
3053 // Function without a prototype. Just give the return type and a
3054 // highlighted ellipsis.
3055 const FunctionType *FT = getFunctionType();
3056 Result.AddResultTypeChunk(Result.getAllocator().CopyString(
3057 FT->getReturnType().getAsString(Policy)));
3058 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3059 Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
3060 Result.AddChunk(CodeCompletionString::CK_RightParen);
3061 return Result.TakeString();
3065 if (IncludeBriefComments && CurrentArg < FDecl->getNumParams())
3066 if (auto RC = S.getASTContext().getRawCommentForAnyRedecl(
3067 FDecl->getParamDecl(CurrentArg)))
3068 Result.addBriefComment(RC->getBriefText(S.getASTContext()));
3069 AddResultTypeChunk(S.Context, Policy, FDecl, QualType(), Result);
3070 Result.AddTextChunk(
3071 Result.getAllocator().CopyString(FDecl->getNameAsString()));
3073 Result.AddResultTypeChunk(
3074 Result.getAllocator().CopyString(
3075 Proto->getReturnType().getAsString(Policy)));
3078 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3079 AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, Result,
3081 Result.AddChunk(CodeCompletionString::CK_RightParen);
3083 return Result.TakeString();
3086 unsigned clang::getMacroUsagePriority(StringRef MacroName,
3087 const LangOptions &LangOpts,
3088 bool PreferredTypeIsPointer) {
3089 unsigned Priority = CCP_Macro;
3091 // Treat the "nil", "Nil" and "NULL" macros as null pointer constants.
3092 if (MacroName.equals("nil") || MacroName.equals("NULL") ||
3093 MacroName.equals("Nil")) {
3094 Priority = CCP_Constant;
3095 if (PreferredTypeIsPointer)
3096 Priority = Priority / CCF_SimilarTypeMatch;
3098 // Treat "YES", "NO", "true", and "false" as constants.
3099 else if (MacroName.equals("YES") || MacroName.equals("NO") ||
3100 MacroName.equals("true") || MacroName.equals("false"))
3101 Priority = CCP_Constant;
3102 // Treat "bool" as a type.
3103 else if (MacroName.equals("bool"))
3104 Priority = CCP_Type + (LangOpts.ObjC1? CCD_bool_in_ObjC : 0);
3110 CXCursorKind clang::getCursorKindForDecl(const Decl *D) {
3112 return CXCursor_UnexposedDecl;
3114 switch (D->getKind()) {
3115 case Decl::Enum: return CXCursor_EnumDecl;
3116 case Decl::EnumConstant: return CXCursor_EnumConstantDecl;
3117 case Decl::Field: return CXCursor_FieldDecl;
3118 case Decl::Function:
3119 return CXCursor_FunctionDecl;
3120 case Decl::ObjCCategory: return CXCursor_ObjCCategoryDecl;
3121 case Decl::ObjCCategoryImpl: return CXCursor_ObjCCategoryImplDecl;
3122 case Decl::ObjCImplementation: return CXCursor_ObjCImplementationDecl;
3124 case Decl::ObjCInterface: return CXCursor_ObjCInterfaceDecl;
3125 case Decl::ObjCIvar: return CXCursor_ObjCIvarDecl;
3126 case Decl::ObjCMethod:
3127 return cast<ObjCMethodDecl>(D)->isInstanceMethod()
3128 ? CXCursor_ObjCInstanceMethodDecl : CXCursor_ObjCClassMethodDecl;
3129 case Decl::CXXMethod: return CXCursor_CXXMethod;
3130 case Decl::CXXConstructor: return CXCursor_Constructor;
3131 case Decl::CXXDestructor: return CXCursor_Destructor;
3132 case Decl::CXXConversion: return CXCursor_ConversionFunction;
3133 case Decl::ObjCProperty: return CXCursor_ObjCPropertyDecl;
3134 case Decl::ObjCProtocol: return CXCursor_ObjCProtocolDecl;
3135 case Decl::ParmVar: return CXCursor_ParmDecl;
3136 case Decl::Typedef: return CXCursor_TypedefDecl;
3137 case Decl::TypeAlias: return CXCursor_TypeAliasDecl;
3138 case Decl::TypeAliasTemplate: return CXCursor_TypeAliasTemplateDecl;
3139 case Decl::Var: return CXCursor_VarDecl;
3140 case Decl::Namespace: return CXCursor_Namespace;
3141 case Decl::NamespaceAlias: return CXCursor_NamespaceAlias;
3142 case Decl::TemplateTypeParm: return CXCursor_TemplateTypeParameter;
3143 case Decl::NonTypeTemplateParm:return CXCursor_NonTypeTemplateParameter;
3144 case Decl::TemplateTemplateParm:return CXCursor_TemplateTemplateParameter;
3145 case Decl::FunctionTemplate: return CXCursor_FunctionTemplate;
3146 case Decl::ClassTemplate: return CXCursor_ClassTemplate;
3147 case Decl::AccessSpec: return CXCursor_CXXAccessSpecifier;
3148 case Decl::ClassTemplatePartialSpecialization:
3149 return CXCursor_ClassTemplatePartialSpecialization;
3150 case Decl::UsingDirective: return CXCursor_UsingDirective;
3151 case Decl::StaticAssert: return CXCursor_StaticAssert;
3152 case Decl::Friend: return CXCursor_FriendDecl;
3153 case Decl::TranslationUnit: return CXCursor_TranslationUnit;
3156 case Decl::UnresolvedUsingValue:
3157 case Decl::UnresolvedUsingTypename:
3158 return CXCursor_UsingDeclaration;
3160 case Decl::ObjCPropertyImpl:
3161 switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
3162 case ObjCPropertyImplDecl::Dynamic:
3163 return CXCursor_ObjCDynamicDecl;
3165 case ObjCPropertyImplDecl::Synthesize:
3166 return CXCursor_ObjCSynthesizeDecl;
3170 return CXCursor_ModuleImportDecl;
3172 case Decl::ObjCTypeParam: return CXCursor_TemplateTypeParameter;
3175 if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
3176 switch (TD->getTagKind()) {
3177 case TTK_Interface: // fall through
3178 case TTK_Struct: return CXCursor_StructDecl;
3179 case TTK_Class: return CXCursor_ClassDecl;
3180 case TTK_Union: return CXCursor_UnionDecl;
3181 case TTK_Enum: return CXCursor_EnumDecl;
3186 return CXCursor_UnexposedDecl;
3189 static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results,
3190 bool IncludeUndefined,
3191 bool TargetTypeIsPointer = false) {
3192 typedef CodeCompletionResult Result;
3194 Results.EnterNewScope();
3196 for (Preprocessor::macro_iterator M = PP.macro_begin(),
3197 MEnd = PP.macro_end();
3199 auto MD = PP.getMacroDefinition(M->first);
3200 if (IncludeUndefined || MD) {
3201 if (MacroInfo *MI = MD.getMacroInfo())
3202 if (MI->isUsedForHeaderGuard())
3205 Results.AddResult(Result(M->first,
3206 getMacroUsagePriority(M->first->getName(),
3208 TargetTypeIsPointer)));
3212 Results.ExitScope();
3216 static void AddPrettyFunctionResults(const LangOptions &LangOpts,
3217 ResultBuilder &Results) {
3218 typedef CodeCompletionResult Result;
3220 Results.EnterNewScope();
3222 Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant));
3223 Results.AddResult(Result("__FUNCTION__", CCP_Constant));
3224 if (LangOpts.C99 || LangOpts.CPlusPlus11)
3225 Results.AddResult(Result("__func__", CCP_Constant));
3226 Results.ExitScope();
3229 static void HandleCodeCompleteResults(Sema *S,
3230 CodeCompleteConsumer *CodeCompleter,
3231 CodeCompletionContext Context,
3232 CodeCompletionResult *Results,
3233 unsigned NumResults) {
3235 CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults);
3238 static enum CodeCompletionContext::Kind mapCodeCompletionContext(Sema &S,
3239 Sema::ParserCompletionContext PCC) {
3241 case Sema::PCC_Namespace:
3242 return CodeCompletionContext::CCC_TopLevel;
3244 case Sema::PCC_Class:
3245 return CodeCompletionContext::CCC_ClassStructUnion;
3247 case Sema::PCC_ObjCInterface:
3248 return CodeCompletionContext::CCC_ObjCInterface;
3250 case Sema::PCC_ObjCImplementation:
3251 return CodeCompletionContext::CCC_ObjCImplementation;
3253 case Sema::PCC_ObjCInstanceVariableList:
3254 return CodeCompletionContext::CCC_ObjCIvarList;
3256 case Sema::PCC_Template:
3257 case Sema::PCC_MemberTemplate:
3258 if (S.CurContext->isFileContext())
3259 return CodeCompletionContext::CCC_TopLevel;
3260 if (S.CurContext->isRecord())
3261 return CodeCompletionContext::CCC_ClassStructUnion;
3262 return CodeCompletionContext::CCC_Other;
3264 case Sema::PCC_RecoveryInFunction:
3265 return CodeCompletionContext::CCC_Recovery;
3267 case Sema::PCC_ForInit:
3268 if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 ||
3269 S.getLangOpts().ObjC1)
3270 return CodeCompletionContext::CCC_ParenthesizedExpression;
3272 return CodeCompletionContext::CCC_Expression;
3274 case Sema::PCC_Expression:
3275 case Sema::PCC_Condition:
3276 return CodeCompletionContext::CCC_Expression;
3278 case Sema::PCC_Statement:
3279 return CodeCompletionContext::CCC_Statement;
3281 case Sema::PCC_Type:
3282 return CodeCompletionContext::CCC_Type;
3284 case Sema::PCC_ParenthesizedExpression:
3285 return CodeCompletionContext::CCC_ParenthesizedExpression;
3287 case Sema::PCC_LocalDeclarationSpecifiers:
3288 return CodeCompletionContext::CCC_Type;
3291 llvm_unreachable("Invalid ParserCompletionContext!");
3294 /// \brief If we're in a C++ virtual member function, add completion results
3295 /// that invoke the functions we override, since it's common to invoke the
3296 /// overridden function as well as adding new functionality.
3298 /// \param S The semantic analysis object for which we are generating results.
3300 /// \param InContext This context in which the nested-name-specifier preceding
3301 /// the code-completion point
3302 static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext,
3303 ResultBuilder &Results) {
3304 // Look through blocks.
3305 DeclContext *CurContext = S.CurContext;
3306 while (isa<BlockDecl>(CurContext))
3307 CurContext = CurContext->getParent();
3310 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext);
3311 if (!Method || !Method->isVirtual())
3314 // We need to have names for all of the parameters, if we're going to
3315 // generate a forwarding call.
3316 for (auto P : Method->parameters())
3317 if (!P->getDeclName())
3320 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
3321 for (CXXMethodDecl::method_iterator M = Method->begin_overridden_methods(),
3322 MEnd = Method->end_overridden_methods();
3324 CodeCompletionBuilder Builder(Results.getAllocator(),
3325 Results.getCodeCompletionTUInfo());
3326 const CXXMethodDecl *Overridden = *M;
3327 if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl())
3330 // If we need a nested-name-specifier, add one now.
3332 NestedNameSpecifier *NNS
3333 = getRequiredQualification(S.Context, CurContext,
3334 Overridden->getDeclContext());
3337 llvm::raw_string_ostream OS(Str);
3338 NNS->print(OS, Policy);
3339 Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
3341 } else if (!InContext->Equals(Overridden->getDeclContext()))
3344 Builder.AddTypedTextChunk(Results.getAllocator().CopyString(
3345 Overridden->getNameAsString()));
3346 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
3347 bool FirstParam = true;
3348 for (auto P : Method->parameters()) {
3352 Builder.AddChunk(CodeCompletionString::CK_Comma);
3354 Builder.AddPlaceholderChunk(
3355 Results.getAllocator().CopyString(P->getIdentifier()->getName()));
3357 Builder.AddChunk(CodeCompletionString::CK_RightParen);
3358 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
3359 CCP_SuperCompletion,
3361 CXAvailability_Available,
3363 Results.Ignore(Overridden);
3367 void Sema::CodeCompleteModuleImport(SourceLocation ImportLoc,
3368 ModuleIdPath Path) {
3369 typedef CodeCompletionResult Result;
3370 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3371 CodeCompleter->getCodeCompletionTUInfo(),
3372 CodeCompletionContext::CCC_Other);
3373 Results.EnterNewScope();
3375 CodeCompletionAllocator &Allocator = Results.getAllocator();
3376 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
3377 typedef CodeCompletionResult Result;
3379 // Enumerate all top-level modules.
3380 SmallVector<Module *, 8> Modules;
3381 PP.getHeaderSearchInfo().collectAllModules(Modules);
3382 for (unsigned I = 0, N = Modules.size(); I != N; ++I) {
3383 Builder.AddTypedTextChunk(
3384 Builder.getAllocator().CopyString(Modules[I]->Name));
3385 Results.AddResult(Result(Builder.TakeString(),
3387 CXCursor_ModuleImportDecl,
3388 Modules[I]->isAvailable()
3389 ? CXAvailability_Available
3390 : CXAvailability_NotAvailable));
3392 } else if (getLangOpts().Modules) {
3393 // Load the named module.
3394 Module *Mod = PP.getModuleLoader().loadModule(ImportLoc, Path,
3396 /*IsInclusionDirective=*/false);
3397 // Enumerate submodules.
3399 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
3400 SubEnd = Mod->submodule_end();
3401 Sub != SubEnd; ++Sub) {
3403 Builder.AddTypedTextChunk(
3404 Builder.getAllocator().CopyString((*Sub)->Name));
3405 Results.AddResult(Result(Builder.TakeString(),
3407 CXCursor_ModuleImportDecl,
3408 (*Sub)->isAvailable()
3409 ? CXAvailability_Available
3410 : CXAvailability_NotAvailable));
3414 Results.ExitScope();
3415 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3416 Results.data(),Results.size());
3419 void Sema::CodeCompleteOrdinaryName(Scope *S,
3420 ParserCompletionContext CompletionContext) {
3421 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3422 CodeCompleter->getCodeCompletionTUInfo(),
3423 mapCodeCompletionContext(*this, CompletionContext));
3424 Results.EnterNewScope();
3426 // Determine how to filter results, e.g., so that the names of
3427 // values (functions, enumerators, function templates, etc.) are
3428 // only allowed where we can have an expression.
3429 switch (CompletionContext) {
3432 case PCC_ObjCInterface:
3433 case PCC_ObjCImplementation:
3434 case PCC_ObjCInstanceVariableList:
3436 case PCC_MemberTemplate:
3438 case PCC_LocalDeclarationSpecifiers:
3439 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
3443 case PCC_ParenthesizedExpression:
3444 case PCC_Expression:
3447 if (WantTypesInContext(CompletionContext, getLangOpts()))
3448 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3450 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3452 if (getLangOpts().CPlusPlus)
3453 MaybeAddOverrideCalls(*this, /*InContext=*/nullptr, Results);
3456 case PCC_RecoveryInFunction:
3461 // If we are in a C++ non-static member function, check the qualifiers on
3462 // the member function to filter/prioritize the results list.
3463 if (CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext))
3464 if (CurMethod->isInstance())
3465 Results.setObjectTypeQualifiers(
3466 Qualifiers::fromCVRMask(CurMethod->getTypeQualifiers()));
3468 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3469 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3470 CodeCompleter->includeGlobals());
3472 AddOrdinaryNameResults(CompletionContext, S, *this, Results);
3473 Results.ExitScope();
3475 switch (CompletionContext) {
3476 case PCC_ParenthesizedExpression:
3477 case PCC_Expression:
3479 case PCC_RecoveryInFunction:
3480 if (S->getFnParent())
3481 AddPrettyFunctionResults(getLangOpts(), Results);
3486 case PCC_ObjCInterface:
3487 case PCC_ObjCImplementation:
3488 case PCC_ObjCInstanceVariableList:
3490 case PCC_MemberTemplate:
3494 case PCC_LocalDeclarationSpecifiers:
3498 if (CodeCompleter->includeMacros())
3499 AddMacroResults(PP, Results, false);
3501 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3502 Results.data(),Results.size());
3505 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
3506 ParsedType Receiver,
3507 ArrayRef<IdentifierInfo *> SelIdents,
3508 bool AtArgumentExpression,
3510 ResultBuilder &Results);
3512 void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
3513 bool AllowNonIdentifiers,
3514 bool AllowNestedNameSpecifiers) {
3515 typedef CodeCompletionResult Result;
3516 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3517 CodeCompleter->getCodeCompletionTUInfo(),
3518 AllowNestedNameSpecifiers
3519 ? CodeCompletionContext::CCC_PotentiallyQualifiedName
3520 : CodeCompletionContext::CCC_Name);
3521 Results.EnterNewScope();
3523 // Type qualifiers can come after names.
3524 Results.AddResult(Result("const"));
3525 Results.AddResult(Result("volatile"));
3526 if (getLangOpts().C99)
3527 Results.AddResult(Result("restrict"));
3529 if (getLangOpts().CPlusPlus) {
3530 if (getLangOpts().CPlusPlus11 &&
3531 (DS.getTypeSpecType() == DeclSpec::TST_class ||
3532 DS.getTypeSpecType() == DeclSpec::TST_struct))
3533 Results.AddResult("final");
3535 if (AllowNonIdentifiers) {
3536 Results.AddResult(Result("operator"));
3539 // Add nested-name-specifiers.
3540 if (AllowNestedNameSpecifiers) {
3541 Results.allowNestedNameSpecifiers();
3542 Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy);
3543 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3544 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
3545 CodeCompleter->includeGlobals());
3546 Results.setFilter(nullptr);
3549 Results.ExitScope();
3551 // If we're in a context where we might have an expression (rather than a
3552 // declaration), and what we've seen so far is an Objective-C type that could
3553 // be a receiver of a class message, this may be a class message send with
3554 // the initial opening bracket '[' missing. Add appropriate completions.
3555 if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
3556 DS.getParsedSpecifiers() == DeclSpec::PQ_TypeSpecifier &&
3557 DS.getTypeSpecType() == DeclSpec::TST_typename &&
3558 DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified &&
3559 DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
3560 !DS.isTypeAltiVecVector() &&
3562 (S->getFlags() & Scope::DeclScope) != 0 &&
3563 (S->getFlags() & (Scope::ClassScope | Scope::TemplateParamScope |
3564 Scope::FunctionPrototypeScope |
3565 Scope::AtCatchScope)) == 0) {
3566 ParsedType T = DS.getRepAsType();
3567 if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType())
3568 AddClassMessageCompletions(*this, S, T, None, false, false, Results);
3571 // Note that we intentionally suppress macro results here, since we do not
3572 // encourage using macros to produce the names of entities.
3574 HandleCodeCompleteResults(this, CodeCompleter,
3575 Results.getCompletionContext(),
3576 Results.data(), Results.size());
3579 struct Sema::CodeCompleteExpressionData {
3580 CodeCompleteExpressionData(QualType PreferredType = QualType())
3581 : PreferredType(PreferredType), IntegralConstantExpression(false),
3582 ObjCCollection(false) { }
3584 QualType PreferredType;
3585 bool IntegralConstantExpression;
3586 bool ObjCCollection;
3587 SmallVector<Decl *, 4> IgnoreDecls;
3590 /// \brief Perform code-completion in an expression context when we know what
3591 /// type we're looking for.
3592 void Sema::CodeCompleteExpression(Scope *S,
3593 const CodeCompleteExpressionData &Data) {
3594 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3595 CodeCompleter->getCodeCompletionTUInfo(),
3596 CodeCompletionContext::CCC_Expression);
3597 if (Data.ObjCCollection)
3598 Results.setFilter(&ResultBuilder::IsObjCCollection);
3599 else if (Data.IntegralConstantExpression)
3600 Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
3601 else if (WantTypesInContext(PCC_Expression, getLangOpts()))
3602 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3604 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3606 if (!Data.PreferredType.isNull())
3607 Results.setPreferredType(Data.PreferredType.getNonReferenceType());
3609 // Ignore any declarations that we were told that we don't care about.
3610 for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I)
3611 Results.Ignore(Data.IgnoreDecls[I]);
3613 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3614 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3615 CodeCompleter->includeGlobals());
3617 Results.EnterNewScope();
3618 AddOrdinaryNameResults(PCC_Expression, S, *this, Results);
3619 Results.ExitScope();
3621 bool PreferredTypeIsPointer = false;
3622 if (!Data.PreferredType.isNull())
3623 PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType()
3624 || Data.PreferredType->isMemberPointerType()
3625 || Data.PreferredType->isBlockPointerType();
3627 if (S->getFnParent() &&
3628 !Data.ObjCCollection &&
3629 !Data.IntegralConstantExpression)
3630 AddPrettyFunctionResults(getLangOpts(), Results);
3632 if (CodeCompleter->includeMacros())
3633 AddMacroResults(PP, Results, false, PreferredTypeIsPointer);
3634 HandleCodeCompleteResults(this, CodeCompleter,
3635 CodeCompletionContext(CodeCompletionContext::CCC_Expression,
3636 Data.PreferredType),
3637 Results.data(),Results.size());
3640 void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E) {
3642 CodeCompleteOrdinaryName(S, PCC_RecoveryInFunction);
3643 else if (getLangOpts().ObjC1)
3644 CodeCompleteObjCInstanceMessage(S, E.get(), None, false);
3647 /// \brief The set of properties that have already been added, referenced by
3649 typedef llvm::SmallPtrSet<IdentifierInfo*, 16> AddedPropertiesSet;
3651 /// \brief Retrieve the container definition, if any?
3652 static ObjCContainerDecl *getContainerDef(ObjCContainerDecl *Container) {
3653 if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
3654 if (Interface->hasDefinition())
3655 return Interface->getDefinition();
3660 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3661 if (Protocol->hasDefinition())
3662 return Protocol->getDefinition();
3669 /// \brief Adds a block invocation code completion result for the given block
3670 /// declaration \p BD.
3671 static void AddObjCBlockCall(ASTContext &Context, const PrintingPolicy &Policy,
3672 CodeCompletionBuilder &Builder,
3673 const NamedDecl *BD,
3674 const FunctionTypeLoc &BlockLoc,
3675 const FunctionProtoTypeLoc &BlockProtoLoc) {
3676 Builder.AddResultTypeChunk(
3677 GetCompletionTypeString(BlockLoc.getReturnLoc().getType(), Context,
3678 Policy, Builder.getAllocator()));
3680 AddTypedNameChunk(Context, Policy, BD, Builder);
3681 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
3683 if (BlockProtoLoc && BlockProtoLoc.getTypePtr()->isVariadic()) {
3684 Builder.AddPlaceholderChunk("...");
3686 for (unsigned I = 0, N = BlockLoc.getNumParams(); I != N; ++I) {
3688 Builder.AddChunk(CodeCompletionString::CK_Comma);
3690 // Format the placeholder string.
3691 std::string PlaceholderStr =
3692 FormatFunctionParameter(Policy, BlockLoc.getParam(I));
3694 if (I == N - 1 && BlockProtoLoc &&
3695 BlockProtoLoc.getTypePtr()->isVariadic())
3696 PlaceholderStr += ", ...";
3698 // Add the placeholder string.
3699 Builder.AddPlaceholderChunk(
3700 Builder.getAllocator().CopyString(PlaceholderStr));
3704 Builder.AddChunk(CodeCompletionString::CK_RightParen);
3707 static void AddObjCProperties(
3708 const CodeCompletionContext &CCContext, ObjCContainerDecl *Container,
3709 bool AllowCategories, bool AllowNullaryMethods, DeclContext *CurContext,
3710 AddedPropertiesSet &AddedProperties, ResultBuilder &Results,
3711 bool IsBaseExprStatement = false, bool IsClassProperty = false) {
3712 typedef CodeCompletionResult Result;
3714 // Retrieve the definition.
3715 Container = getContainerDef(Container);
3717 // Add properties in this container.
3718 const auto AddProperty = [&](const ObjCPropertyDecl *P) {
3719 if (!AddedProperties.insert(P->getIdentifier()).second)
3722 // FIXME: Provide block invocation completion for non-statement
3724 if (!P->getType().getTypePtr()->isBlockPointerType() ||
3725 !IsBaseExprStatement) {
3726 Results.MaybeAddResult(Result(P, Results.getBasePriority(P), nullptr),
3731 // Block setter and invocation completion is provided only when we are able
3732 // to find the FunctionProtoTypeLoc with parameter names for the block.
3733 FunctionTypeLoc BlockLoc;
3734 FunctionProtoTypeLoc BlockProtoLoc;
3735 findTypeLocationForBlockDecl(P->getTypeSourceInfo(), BlockLoc,
3738 Results.MaybeAddResult(Result(P, Results.getBasePriority(P), nullptr),
3743 // The default completion result for block properties should be the block
3744 // invocation completion when the base expression is a statement.
3745 CodeCompletionBuilder Builder(Results.getAllocator(),
3746 Results.getCodeCompletionTUInfo());
3747 AddObjCBlockCall(Container->getASTContext(),
3748 getCompletionPrintingPolicy(Results.getSema()), Builder, P,
3749 BlockLoc, BlockProtoLoc);
3750 Results.MaybeAddResult(
3751 Result(Builder.TakeString(), P, Results.getBasePriority(P)),
3754 // Provide additional block setter completion iff the base expression is a
3755 // statement and the block property is mutable.
3756 if (!P->isReadOnly()) {
3757 CodeCompletionBuilder Builder(Results.getAllocator(),
3758 Results.getCodeCompletionTUInfo());
3759 AddResultTypeChunk(Container->getASTContext(),
3760 getCompletionPrintingPolicy(Results.getSema()), P,
3761 CCContext.getBaseType(), Builder);
3762 Builder.AddTypedTextChunk(
3763 Results.getAllocator().CopyString(P->getName()));
3764 Builder.AddChunk(CodeCompletionString::CK_Equal);
3766 std::string PlaceholderStr = formatBlockPlaceholder(
3767 getCompletionPrintingPolicy(Results.getSema()), P, BlockLoc,
3768 BlockProtoLoc, /*SuppressBlockName=*/true);
3769 // Add the placeholder string.
3770 Builder.AddPlaceholderChunk(
3771 Builder.getAllocator().CopyString(PlaceholderStr));
3773 // When completing blocks properties that return void the default
3774 // property completion result should show up before the setter,
3775 // otherwise the setter completion should show up before the default
3776 // property completion, as we normally want to use the result of the
3778 Results.MaybeAddResult(
3779 Result(Builder.TakeString(), P,
3780 Results.getBasePriority(P) +
3781 (BlockLoc.getTypePtr()->getReturnType()->isVoidType()
3782 ? CCD_BlockPropertySetter
3783 : -CCD_BlockPropertySetter)),
3788 if (IsClassProperty) {
3789 for (const auto *P : Container->class_properties())
3792 for (const auto *P : Container->instance_properties())
3796 // Add nullary methods or implicit class properties
3797 if (AllowNullaryMethods) {
3798 ASTContext &Context = Container->getASTContext();
3799 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
3800 // Adds a method result
3801 const auto AddMethod = [&](const ObjCMethodDecl *M) {
3802 IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0);
3805 if (!AddedProperties.insert(Name).second)
3807 CodeCompletionBuilder Builder(Results.getAllocator(),
3808 Results.getCodeCompletionTUInfo());
3809 AddResultTypeChunk(Context, Policy, M, CCContext.getBaseType(), Builder);
3810 Builder.AddTypedTextChunk(
3811 Results.getAllocator().CopyString(Name->getName()));
3812 Results.MaybeAddResult(
3813 Result(Builder.TakeString(), M,
3814 CCP_MemberDeclaration + CCD_MethodAsProperty),
3818 if (IsClassProperty) {
3819 for (const auto *M : Container->methods()) {
3820 // Gather the class method that can be used as implicit property
3821 // getters. Methods with arguments or methods that return void aren't
3822 // added to the results as they can't be used as a getter.
3823 if (!M->getSelector().isUnarySelector() ||
3824 M->getReturnType()->isVoidType() || M->isInstanceMethod())
3829 for (auto *M : Container->methods()) {
3830 if (M->getSelector().isUnarySelector())
3836 // Add properties in referenced protocols.
3837 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3838 for (auto *P : Protocol->protocols())
3839 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
3840 CurContext, AddedProperties, Results,
3841 IsBaseExprStatement, IsClassProperty);
3842 } else if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)){
3843 if (AllowCategories) {
3844 // Look through categories.
3845 for (auto *Cat : IFace->known_categories())
3846 AddObjCProperties(CCContext, Cat, AllowCategories, AllowNullaryMethods,
3847 CurContext, AddedProperties, Results,
3848 IsBaseExprStatement, IsClassProperty);
3851 // Look through protocols.
3852 for (auto *I : IFace->all_referenced_protocols())
3853 AddObjCProperties(CCContext, I, AllowCategories, AllowNullaryMethods,
3854 CurContext, AddedProperties, Results,
3855 IsBaseExprStatement, IsClassProperty);
3857 // Look in the superclass.
3858 if (IFace->getSuperClass())
3859 AddObjCProperties(CCContext, IFace->getSuperClass(), AllowCategories,
3860 AllowNullaryMethods, CurContext, AddedProperties,
3861 Results, IsBaseExprStatement, IsClassProperty);
3862 } else if (const ObjCCategoryDecl *Category
3863 = dyn_cast<ObjCCategoryDecl>(Container)) {
3864 // Look through protocols.
3865 for (auto *P : Category->protocols())
3866 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
3867 CurContext, AddedProperties, Results,
3868 IsBaseExprStatement, IsClassProperty);
3872 void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
3873 SourceLocation OpLoc, bool IsArrow,
3874 bool IsBaseExprStatement) {
3875 if (!Base || !CodeCompleter)
3878 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
3879 if (ConvertedBase.isInvalid())
3881 Base = ConvertedBase.get();
3883 typedef CodeCompletionResult Result;
3885 QualType BaseType = Base->getType();
3888 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
3889 BaseType = Ptr->getPointeeType();
3890 else if (BaseType->isObjCObjectPointerType())
3896 enum CodeCompletionContext::Kind contextKind;
3899 contextKind = CodeCompletionContext::CCC_ArrowMemberAccess;
3902 if (BaseType->isObjCObjectPointerType() ||
3903 BaseType->isObjCObjectOrInterfaceType()) {
3904 contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess;
3907 contextKind = CodeCompletionContext::CCC_DotMemberAccess;
3911 CodeCompletionContext CCContext(contextKind, BaseType);
3912 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3913 CodeCompleter->getCodeCompletionTUInfo(),
3915 &ResultBuilder::IsMember);
3916 Results.EnterNewScope();
3917 if (const RecordType *Record = BaseType->getAs<RecordType>()) {
3918 // Indicate that we are performing a member access, and the cv-qualifiers
3919 // for the base object type.
3920 Results.setObjectTypeQualifiers(BaseType.getQualifiers());
3922 // Access to a C/C++ class, struct, or union.
3923 Results.allowNestedNameSpecifiers();
3924 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3925 LookupVisibleDecls(Record->getDecl(), LookupMemberName, Consumer,
3926 CodeCompleter->includeGlobals());
3928 if (getLangOpts().CPlusPlus) {
3929 if (!Results.empty()) {
3930 // The "template" keyword can follow "->" or "." in the grammar.
3931 // However, we only want to suggest the template keyword if something
3933 bool IsDependent = BaseType->isDependentType();
3935 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent())
3936 if (DeclContext *Ctx = DepScope->getEntity()) {
3937 IsDependent = Ctx->isDependentContext();
3943 Results.AddResult(Result("template"));
3946 } else if (!IsArrow && BaseType->isObjCObjectPointerType()) {
3947 // Objective-C property reference.
3948 AddedPropertiesSet AddedProperties;
3950 if (const ObjCObjectPointerType *ObjCPtr =
3951 BaseType->getAsObjCInterfacePointerType()) {
3952 // Add property results based on our interface.
3953 assert(ObjCPtr && "Non-NULL pointer guaranteed above!");
3954 AddObjCProperties(CCContext, ObjCPtr->getInterfaceDecl(), true,
3955 /*AllowNullaryMethods=*/true, CurContext,
3956 AddedProperties, Results, IsBaseExprStatement);
3959 // Add properties from the protocols in a qualified interface.
3960 for (auto *I : BaseType->getAs<ObjCObjectPointerType>()->quals())
3961 AddObjCProperties(CCContext, I, true, /*AllowNullaryMethods=*/true,
3962 CurContext, AddedProperties, Results,
3963 IsBaseExprStatement);
3964 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) ||
3965 (!IsArrow && BaseType->isObjCObjectType())) {
3966 // Objective-C instance variable access.
3967 ObjCInterfaceDecl *Class = nullptr;
3968 if (const ObjCObjectPointerType *ObjCPtr
3969 = BaseType->getAs<ObjCObjectPointerType>())
3970 Class = ObjCPtr->getInterfaceDecl();
3972 Class = BaseType->getAs<ObjCObjectType>()->getInterface();
3974 // Add all ivars from this class and its superclasses.
3976 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3977 Results.setFilter(&ResultBuilder::IsObjCIvar);
3978 LookupVisibleDecls(Class, LookupMemberName, Consumer,
3979 CodeCompleter->includeGlobals());
3983 // FIXME: How do we cope with isa?
3985 Results.ExitScope();
3987 // Hand off the results found for code completion.
3988 HandleCodeCompleteResults(this, CodeCompleter,
3989 Results.getCompletionContext(),
3990 Results.data(),Results.size());
3993 void Sema::CodeCompleteObjCClassPropertyRefExpr(Scope *S,
3994 IdentifierInfo &ClassName,
3995 SourceLocation ClassNameLoc,
3996 bool IsBaseExprStatement) {
3997 IdentifierInfo *ClassNamePtr = &ClassName;
3998 ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(ClassNamePtr, ClassNameLoc);
4001 CodeCompletionContext CCContext(
4002 CodeCompletionContext::CCC_ObjCPropertyAccess);
4003 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4004 CodeCompleter->getCodeCompletionTUInfo(), CCContext,
4005 &ResultBuilder::IsMember);
4006 Results.EnterNewScope();
4007 AddedPropertiesSet AddedProperties;
4008 AddObjCProperties(CCContext, IFace, true,
4009 /*AllowNullaryMethods=*/true, CurContext, AddedProperties,
4010 Results, IsBaseExprStatement,
4011 /*IsClassProperty=*/true);
4012 Results.ExitScope();
4013 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4014 Results.data(), Results.size());
4017 void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) {
4021 ResultBuilder::LookupFilter Filter = nullptr;
4022 enum CodeCompletionContext::Kind ContextKind
4023 = CodeCompletionContext::CCC_Other;
4024 switch ((DeclSpec::TST)TagSpec) {
4025 case DeclSpec::TST_enum:
4026 Filter = &ResultBuilder::IsEnum;
4027 ContextKind = CodeCompletionContext::CCC_EnumTag;
4030 case DeclSpec::TST_union:
4031 Filter = &ResultBuilder::IsUnion;
4032 ContextKind = CodeCompletionContext::CCC_UnionTag;
4035 case DeclSpec::TST_struct:
4036 case DeclSpec::TST_class:
4037 case DeclSpec::TST_interface:
4038 Filter = &ResultBuilder::IsClassOrStruct;
4039 ContextKind = CodeCompletionContext::CCC_ClassOrStructTag;
4043 llvm_unreachable("Unknown type specifier kind in CodeCompleteTag");
4046 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4047 CodeCompleter->getCodeCompletionTUInfo(), ContextKind);
4048 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4050 // First pass: look for tags.
4051 Results.setFilter(Filter);
4052 LookupVisibleDecls(S, LookupTagName, Consumer,
4053 CodeCompleter->includeGlobals());
4055 if (CodeCompleter->includeGlobals()) {
4056 // Second pass: look for nested name specifiers.
4057 Results.setFilter(&ResultBuilder::IsNestedNameSpecifier);
4058 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer);
4061 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4062 Results.data(),Results.size());
4065 static void AddTypeQualifierResults(DeclSpec &DS, ResultBuilder &Results,
4066 const LangOptions &LangOpts) {
4067 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
4068 Results.AddResult("const");
4069 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile))
4070 Results.AddResult("volatile");
4071 if (LangOpts.C99 && !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict))
4072 Results.AddResult("restrict");
4073 if (LangOpts.C11 && !(DS.getTypeQualifiers() & DeclSpec::TQ_atomic))
4074 Results.AddResult("_Atomic");
4075 if (LangOpts.MSVCCompat && !(DS.getTypeQualifiers() & DeclSpec::TQ_unaligned))
4076 Results.AddResult("__unaligned");
4079 void Sema::CodeCompleteTypeQualifiers(DeclSpec &DS) {
4080 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4081 CodeCompleter->getCodeCompletionTUInfo(),
4082 CodeCompletionContext::CCC_TypeQualifiers);
4083 Results.EnterNewScope();
4084 AddTypeQualifierResults(DS, Results, LangOpts);
4085 Results.ExitScope();
4086 HandleCodeCompleteResults(this, CodeCompleter,
4087 Results.getCompletionContext(),
4088 Results.data(), Results.size());
4091 void Sema::CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D,
4092 const VirtSpecifiers *VS) {
4093 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4094 CodeCompleter->getCodeCompletionTUInfo(),
4095 CodeCompletionContext::CCC_TypeQualifiers);
4096 Results.EnterNewScope();
4097 AddTypeQualifierResults(DS, Results, LangOpts);
4098 if (LangOpts.CPlusPlus11) {
4099 Results.AddResult("noexcept");
4100 if (D.getContext() == Declarator::MemberContext && !D.isCtorOrDtor() &&
4101 !D.isStaticMember()) {
4102 if (!VS || !VS->isFinalSpecified())
4103 Results.AddResult("final");
4104 if (!VS || !VS->isOverrideSpecified())
4105 Results.AddResult("override");
4108 Results.ExitScope();
4109 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4110 Results.data(), Results.size());
4113 void Sema::CodeCompleteBracketDeclarator(Scope *S) {
4114 CodeCompleteExpression(S, QualType(getASTContext().getSizeType()));
4117 void Sema::CodeCompleteCase(Scope *S) {
4118 if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
4121 SwitchStmt *Switch = getCurFunction()->SwitchStack.back();
4122 QualType type = Switch->getCond()->IgnoreImplicit()->getType();
4123 if (!type->isEnumeralType()) {
4124 CodeCompleteExpressionData Data(type);
4125 Data.IntegralConstantExpression = true;
4126 CodeCompleteExpression(S, Data);
4130 // Code-complete the cases of a switch statement over an enumeration type
4131 // by providing the list of
4132 EnumDecl *Enum = type->castAs<EnumType>()->getDecl();
4133 if (EnumDecl *Def = Enum->getDefinition())
4136 // Determine which enumerators we have already seen in the switch statement.
4137 // FIXME: Ideally, we would also be able to look *past* the code-completion
4138 // token, in case we are code-completing in the middle of the switch and not
4139 // at the end. However, we aren't able to do so at the moment.
4140 llvm::SmallPtrSet<EnumConstantDecl *, 8> EnumeratorsSeen;
4141 NestedNameSpecifier *Qualifier = nullptr;
4142 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC;
4143 SC = SC->getNextSwitchCase()) {
4144 CaseStmt *Case = dyn_cast<CaseStmt>(SC);
4148 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
4149 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CaseVal))
4150 if (EnumConstantDecl *Enumerator
4151 = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
4152 // We look into the AST of the case statement to determine which
4153 // enumerator was named. Alternatively, we could compute the value of
4154 // the integral constant expression, then compare it against the
4155 // values of each enumerator. However, value-based approach would not
4156 // work as well with C++ templates where enumerators declared within a
4157 // template are type- and value-dependent.
4158 EnumeratorsSeen.insert(Enumerator);
4160 // If this is a qualified-id, keep track of the nested-name-specifier
4161 // so that we can reproduce it as part of code completion, e.g.,
4163 // switch (TagD.getKind()) {
4164 // case TagDecl::TK_enum:
4168 // At the XXX, our completions are TagDecl::TK_union,
4169 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union,
4170 // TK_struct, and TK_class.
4171 Qualifier = DRE->getQualifier();
4175 if (getLangOpts().CPlusPlus && !Qualifier && EnumeratorsSeen.empty()) {
4176 // If there are no prior enumerators in C++, check whether we have to
4177 // qualify the names of the enumerators that we suggest, because they
4178 // may not be visible in this scope.
4179 Qualifier = getRequiredQualification(Context, CurContext, Enum);
4182 // Add any enumerators that have not yet been mentioned.
4183 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4184 CodeCompleter->getCodeCompletionTUInfo(),
4185 CodeCompletionContext::CCC_Expression);
4186 Results.EnterNewScope();
4187 for (auto *E : Enum->enumerators()) {
4188 if (EnumeratorsSeen.count(E))
4191 CodeCompletionResult R(E, CCP_EnumInCase, Qualifier);
4192 Results.AddResult(R, CurContext, nullptr, false);
4194 Results.ExitScope();
4196 //We need to make sure we're setting the right context,
4197 //so only say we include macros if the code completer says we do
4198 enum CodeCompletionContext::Kind kind = CodeCompletionContext::CCC_Other;
4199 if (CodeCompleter->includeMacros()) {
4200 AddMacroResults(PP, Results, false);
4201 kind = CodeCompletionContext::CCC_OtherWithMacros;
4204 HandleCodeCompleteResults(this, CodeCompleter,
4206 Results.data(),Results.size());
4209 static bool anyNullArguments(ArrayRef<Expr *> Args) {
4210 if (Args.size() && !Args.data())
4213 for (unsigned I = 0; I != Args.size(); ++I)
4220 typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate;
4222 static void mergeCandidatesWithResults(Sema &SemaRef,
4223 SmallVectorImpl<ResultCandidate> &Results,
4224 OverloadCandidateSet &CandidateSet,
4225 SourceLocation Loc) {
4226 if (!CandidateSet.empty()) {
4227 // Sort the overload candidate set by placing the best overloads first.
4229 CandidateSet.begin(), CandidateSet.end(),
4230 [&](const OverloadCandidate &X, const OverloadCandidate &Y) {
4231 return isBetterOverloadCandidate(SemaRef, X, Y, Loc);
4234 // Add the remaining viable overload candidates as code-completion results.
4235 for (auto &Candidate : CandidateSet)
4236 if (Candidate.Viable)
4237 Results.push_back(ResultCandidate(Candidate.Function));
4241 /// \brief Get the type of the Nth parameter from a given set of overload
4243 static QualType getParamType(Sema &SemaRef,
4244 ArrayRef<ResultCandidate> Candidates,
4247 // Given the overloads 'Candidates' for a function call matching all arguments
4248 // up to N, return the type of the Nth parameter if it is the same for all
4249 // overload candidates.
4251 for (auto &Candidate : Candidates) {
4252 if (auto FType = Candidate.getFunctionType())
4253 if (auto Proto = dyn_cast<FunctionProtoType>(FType))
4254 if (N < Proto->getNumParams()) {
4255 if (ParamType.isNull())
4256 ParamType = Proto->getParamType(N);
4257 else if (!SemaRef.Context.hasSameUnqualifiedType(
4258 ParamType.getNonReferenceType(),
4259 Proto->getParamType(N).getNonReferenceType()))
4260 // Otherwise return a default-constructed QualType.
4268 static void CodeCompleteOverloadResults(Sema &SemaRef, Scope *S,
4269 MutableArrayRef<ResultCandidate> Candidates,
4270 unsigned CurrentArg,
4271 bool CompleteExpressionWithCurrentArg = true) {
4273 if (CompleteExpressionWithCurrentArg)
4274 ParamType = getParamType(SemaRef, Candidates, CurrentArg);
4276 if (ParamType.isNull())
4277 SemaRef.CodeCompleteOrdinaryName(S, Sema::PCC_Expression);
4279 SemaRef.CodeCompleteExpression(S, ParamType);
4281 if (!Candidates.empty())
4282 SemaRef.CodeCompleter->ProcessOverloadCandidates(SemaRef, CurrentArg,
4287 void Sema::CodeCompleteCall(Scope *S, Expr *Fn, ArrayRef<Expr *> Args) {
4291 // When we're code-completing for a call, we fall back to ordinary
4292 // name code-completion whenever we can't produce specific
4293 // results. We may want to revisit this strategy in the future,
4294 // e.g., by merging the two kinds of results.
4296 // FIXME: Provide support for variadic template functions.
4298 // Ignore type-dependent call expressions entirely.
4299 if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args) ||
4300 Expr::hasAnyTypeDependentArguments(Args)) {
4301 CodeCompleteOrdinaryName(S, PCC_Expression);
4305 // Build an overload candidate set based on the functions we find.
4306 SourceLocation Loc = Fn->getExprLoc();
4307 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
4309 SmallVector<ResultCandidate, 8> Results;
4311 Expr *NakedFn = Fn->IgnoreParenCasts();
4312 if (auto ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn))
4313 AddOverloadedCallCandidates(ULE, Args, CandidateSet,
4314 /*PartialOverloading=*/true);
4315 else if (auto UME = dyn_cast<UnresolvedMemberExpr>(NakedFn)) {
4316 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
4317 if (UME->hasExplicitTemplateArgs()) {
4318 UME->copyTemplateArgumentsInto(TemplateArgsBuffer);
4319 TemplateArgs = &TemplateArgsBuffer;
4322 // Add the base as first argument (use a nullptr if the base is implicit).
4323 SmallVector<Expr *, 12> ArgExprs(
4324 1, UME->isImplicitAccess() ? nullptr : UME->getBase());
4325 ArgExprs.append(Args.begin(), Args.end());
4326 UnresolvedSet<8> Decls;
4327 Decls.append(UME->decls_begin(), UME->decls_end());
4328 AddFunctionCandidates(Decls, ArgExprs, CandidateSet, TemplateArgs,
4329 /*SuppressUsedConversions=*/false,
4330 /*PartialOverloading=*/true);
4332 FunctionDecl *FD = nullptr;
4333 if (auto MCE = dyn_cast<MemberExpr>(NakedFn))
4334 FD = dyn_cast<FunctionDecl>(MCE->getMemberDecl());
4335 else if (auto DRE = dyn_cast<DeclRefExpr>(NakedFn))
4336 FD = dyn_cast<FunctionDecl>(DRE->getDecl());
4337 if (FD) { // We check whether it's a resolved function declaration.
4338 if (!getLangOpts().CPlusPlus ||
4339 !FD->getType()->getAs<FunctionProtoType>())
4340 Results.push_back(ResultCandidate(FD));
4342 AddOverloadCandidate(FD, DeclAccessPair::make(FD, FD->getAccess()),
4344 /*SuppressUsedConversions=*/false,
4345 /*PartialOverloading=*/true);
4347 } else if (auto DC = NakedFn->getType()->getAsCXXRecordDecl()) {
4348 // If expression's type is CXXRecordDecl, it may overload the function
4349 // call operator, so we check if it does and add them as candidates.
4350 // A complete type is needed to lookup for member function call operators.
4351 if (isCompleteType(Loc, NakedFn->getType())) {
4352 DeclarationName OpName = Context.DeclarationNames
4353 .getCXXOperatorName(OO_Call);
4354 LookupResult R(*this, OpName, Loc, LookupOrdinaryName);
4355 LookupQualifiedName(R, DC);
4356 R.suppressDiagnostics();
4357 SmallVector<Expr *, 12> ArgExprs(1, NakedFn);
4358 ArgExprs.append(Args.begin(), Args.end());
4359 AddFunctionCandidates(R.asUnresolvedSet(), ArgExprs, CandidateSet,
4360 /*ExplicitArgs=*/nullptr,
4361 /*SuppressUsedConversions=*/false,
4362 /*PartialOverloading=*/true);
4365 // Lastly we check whether expression's type is function pointer or
4367 QualType T = NakedFn->getType();
4368 if (!T->getPointeeType().isNull())
4369 T = T->getPointeeType();
4371 if (auto FP = T->getAs<FunctionProtoType>()) {
4372 if (!TooManyArguments(FP->getNumParams(), Args.size(),
4373 /*PartialOverloading=*/true) ||
4375 Results.push_back(ResultCandidate(FP));
4376 } else if (auto FT = T->getAs<FunctionType>())
4377 // No prototype and declaration, it may be a K & R style function.
4378 Results.push_back(ResultCandidate(FT));
4382 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4383 CodeCompleteOverloadResults(*this, S, Results, Args.size(),
4384 !CandidateSet.empty());
4387 void Sema::CodeCompleteConstructor(Scope *S, QualType Type, SourceLocation Loc,
4388 ArrayRef<Expr *> Args) {
4392 // A complete type is needed to lookup for constructors.
4393 if (!isCompleteType(Loc, Type))
4396 CXXRecordDecl *RD = Type->getAsCXXRecordDecl();
4398 CodeCompleteExpression(S, Type);
4402 // FIXME: Provide support for member initializers.
4403 // FIXME: Provide support for variadic template constructors.
4405 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
4407 for (auto C : LookupConstructors(RD)) {
4408 if (auto FD = dyn_cast<FunctionDecl>(C)) {
4409 AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()),
4411 /*SuppressUsedConversions=*/false,
4412 /*PartialOverloading=*/true);
4413 } else if (auto FTD = dyn_cast<FunctionTemplateDecl>(C)) {
4414 AddTemplateOverloadCandidate(FTD,
4415 DeclAccessPair::make(FTD, C->getAccess()),
4416 /*ExplicitTemplateArgs=*/nullptr,
4418 /*SuppressUsedConversions=*/false,
4419 /*PartialOverloading=*/true);
4423 SmallVector<ResultCandidate, 8> Results;
4424 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4425 CodeCompleteOverloadResults(*this, S, Results, Args.size());
4428 void Sema::CodeCompleteInitializer(Scope *S, Decl *D) {
4429 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D);
4431 CodeCompleteOrdinaryName(S, PCC_Expression);
4435 CodeCompleteExpression(S, VD->getType());
4438 void Sema::CodeCompleteReturn(Scope *S) {
4439 QualType ResultType;
4440 if (isa<BlockDecl>(CurContext)) {
4441 if (BlockScopeInfo *BSI = getCurBlock())
4442 ResultType = BSI->ReturnType;
4443 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(CurContext))
4444 ResultType = Function->getReturnType();
4445 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(CurContext))
4446 ResultType = Method->getReturnType();
4448 if (ResultType.isNull())
4449 CodeCompleteOrdinaryName(S, PCC_Expression);
4451 CodeCompleteExpression(S, ResultType);
4454 void Sema::CodeCompleteAfterIf(Scope *S) {
4455 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4456 CodeCompleter->getCodeCompletionTUInfo(),
4457 mapCodeCompletionContext(*this, PCC_Statement));
4458 Results.setFilter(&ResultBuilder::IsOrdinaryName);
4459 Results.EnterNewScope();
4461 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4462 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4463 CodeCompleter->includeGlobals());
4465 AddOrdinaryNameResults(PCC_Statement, S, *this, Results);
4468 CodeCompletionBuilder Builder(Results.getAllocator(),
4469 Results.getCodeCompletionTUInfo());
4470 Builder.AddTypedTextChunk("else");
4471 if (Results.includeCodePatterns()) {
4472 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4473 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4474 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4475 Builder.AddPlaceholderChunk("statements");
4476 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4477 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4479 Results.AddResult(Builder.TakeString());
4482 Builder.AddTypedTextChunk("else");
4483 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4484 Builder.AddTextChunk("if");
4485 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4486 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4487 if (getLangOpts().CPlusPlus)
4488 Builder.AddPlaceholderChunk("condition");
4490 Builder.AddPlaceholderChunk("expression");
4491 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4492 if (Results.includeCodePatterns()) {
4493 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4494 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4495 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4496 Builder.AddPlaceholderChunk("statements");
4497 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4498 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4500 Results.AddResult(Builder.TakeString());
4502 Results.ExitScope();
4504 if (S->getFnParent())
4505 AddPrettyFunctionResults(getLangOpts(), Results);
4507 if (CodeCompleter->includeMacros())
4508 AddMacroResults(PP, Results, false);
4510 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4511 Results.data(),Results.size());
4514 void Sema::CodeCompleteAssignmentRHS(Scope *S, Expr *LHS) {
4516 CodeCompleteExpression(S, static_cast<Expr *>(LHS)->getType());
4518 CodeCompleteOrdinaryName(S, PCC_Expression);
4521 void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
4522 bool EnteringContext) {
4523 if (!SS.getScopeRep() || !CodeCompleter)
4526 DeclContext *Ctx = computeDeclContext(SS, EnteringContext);
4530 // Try to instantiate any non-dependent declaration contexts before
4532 if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx))
4535 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4536 CodeCompleter->getCodeCompletionTUInfo(),
4537 CodeCompletionContext::CCC_Name);
4538 Results.EnterNewScope();
4540 // The "template" keyword can follow "::" in the grammar, but only
4541 // put it into the grammar if the nested-name-specifier is dependent.
4542 NestedNameSpecifier *NNS = SS.getScopeRep();
4543 if (!Results.empty() && NNS->isDependent())
4544 Results.AddResult("template");
4546 // Add calls to overridden virtual functions, if there are any.
4548 // FIXME: This isn't wonderful, because we don't know whether we're actually
4549 // in a context that permits expressions. This is a general issue with
4550 // qualified-id completions.
4551 if (!EnteringContext)
4552 MaybeAddOverrideCalls(*this, Ctx, Results);
4553 Results.ExitScope();
4555 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4556 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer);
4558 HandleCodeCompleteResults(this, CodeCompleter,
4559 Results.getCompletionContext(),
4560 Results.data(),Results.size());
4563 void Sema::CodeCompleteUsing(Scope *S) {
4567 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4568 CodeCompleter->getCodeCompletionTUInfo(),
4569 CodeCompletionContext::CCC_PotentiallyQualifiedName,
4570 &ResultBuilder::IsNestedNameSpecifier);
4571 Results.EnterNewScope();
4573 // If we aren't in class scope, we could see the "namespace" keyword.
4574 if (!S->isClassScope())
4575 Results.AddResult(CodeCompletionResult("namespace"));
4577 // After "using", we can see anything that would start a
4578 // nested-name-specifier.
4579 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4580 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4581 CodeCompleter->includeGlobals());
4582 Results.ExitScope();
4584 HandleCodeCompleteResults(this, CodeCompleter,
4585 CodeCompletionContext::CCC_PotentiallyQualifiedName,
4586 Results.data(),Results.size());
4589 void Sema::CodeCompleteUsingDirective(Scope *S) {
4593 // After "using namespace", we expect to see a namespace name or namespace
4595 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4596 CodeCompleter->getCodeCompletionTUInfo(),
4597 CodeCompletionContext::CCC_Namespace,
4598 &ResultBuilder::IsNamespaceOrAlias);
4599 Results.EnterNewScope();
4600 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4601 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4602 CodeCompleter->includeGlobals());
4603 Results.ExitScope();
4604 HandleCodeCompleteResults(this, CodeCompleter,
4605 CodeCompletionContext::CCC_Namespace,
4606 Results.data(),Results.size());
4609 void Sema::CodeCompleteNamespaceDecl(Scope *S) {
4613 DeclContext *Ctx = S->getEntity();
4614 if (!S->getParent())
4615 Ctx = Context.getTranslationUnitDecl();
4617 bool SuppressedGlobalResults
4618 = Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx);
4620 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4621 CodeCompleter->getCodeCompletionTUInfo(),
4622 SuppressedGlobalResults
4623 ? CodeCompletionContext::CCC_Namespace
4624 : CodeCompletionContext::CCC_Other,
4625 &ResultBuilder::IsNamespace);
4627 if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) {
4628 // We only want to see those namespaces that have already been defined
4629 // within this scope, because its likely that the user is creating an
4630 // extended namespace declaration. Keep track of the most recent
4631 // definition of each namespace.
4632 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest;
4633 for (DeclContext::specific_decl_iterator<NamespaceDecl>
4634 NS(Ctx->decls_begin()), NSEnd(Ctx->decls_end());
4636 OrigToLatest[NS->getOriginalNamespace()] = *NS;
4638 // Add the most recent definition (or extended definition) of each
4639 // namespace to the list of results.
4640 Results.EnterNewScope();
4641 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator
4642 NS = OrigToLatest.begin(),
4643 NSEnd = OrigToLatest.end();
4645 Results.AddResult(CodeCompletionResult(
4646 NS->second, Results.getBasePriority(NS->second),
4648 CurContext, nullptr, false);
4649 Results.ExitScope();
4652 HandleCodeCompleteResults(this, CodeCompleter,
4653 Results.getCompletionContext(),
4654 Results.data(),Results.size());
4657 void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) {
4661 // After "namespace", we expect to see a namespace or alias.
4662 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4663 CodeCompleter->getCodeCompletionTUInfo(),
4664 CodeCompletionContext::CCC_Namespace,
4665 &ResultBuilder::IsNamespaceOrAlias);
4666 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4667 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4668 CodeCompleter->includeGlobals());
4669 HandleCodeCompleteResults(this, CodeCompleter,
4670 Results.getCompletionContext(),
4671 Results.data(),Results.size());
4674 void Sema::CodeCompleteOperatorName(Scope *S) {
4678 typedef CodeCompletionResult Result;
4679 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4680 CodeCompleter->getCodeCompletionTUInfo(),
4681 CodeCompletionContext::CCC_Type,
4682 &ResultBuilder::IsType);
4683 Results.EnterNewScope();
4685 // Add the names of overloadable operators.
4686 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4687 if (std::strcmp(Spelling, "?")) \
4688 Results.AddResult(Result(Spelling));
4689 #include "clang/Basic/OperatorKinds.def"
4691 // Add any type names visible from the current scope
4692 Results.allowNestedNameSpecifiers();
4693 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4694 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4695 CodeCompleter->includeGlobals());
4697 // Add any type specifiers
4698 AddTypeSpecifierResults(getLangOpts(), Results);
4699 Results.ExitScope();
4701 HandleCodeCompleteResults(this, CodeCompleter,
4702 CodeCompletionContext::CCC_Type,
4703 Results.data(),Results.size());
4706 void Sema::CodeCompleteConstructorInitializer(
4708 ArrayRef <CXXCtorInitializer *> Initializers) {
4712 AdjustDeclIfTemplate(ConstructorD);
4714 CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ConstructorD);
4718 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4719 CodeCompleter->getCodeCompletionTUInfo(),
4720 CodeCompletionContext::CCC_PotentiallyQualifiedName);
4721 Results.EnterNewScope();
4723 // Fill in any already-initialized fields or base classes.
4724 llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
4725 llvm::SmallPtrSet<CanQualType, 4> InitializedBases;
4726 for (unsigned I = 0, E = Initializers.size(); I != E; ++I) {
4727 if (Initializers[I]->isBaseInitializer())
4728 InitializedBases.insert(
4729 Context.getCanonicalType(QualType(Initializers[I]->getBaseClass(), 0)));
4731 InitializedFields.insert(cast<FieldDecl>(
4732 Initializers[I]->getAnyMember()));
4735 // Add completions for base classes.
4736 CodeCompletionBuilder Builder(Results.getAllocator(),
4737 Results.getCodeCompletionTUInfo());
4738 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
4739 bool SawLastInitializer = Initializers.empty();
4740 CXXRecordDecl *ClassDecl = Constructor->getParent();
4741 for (const auto &Base : ClassDecl->bases()) {
4742 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4745 = !Initializers.empty() &&
4746 Initializers.back()->isBaseInitializer() &&
4747 Context.hasSameUnqualifiedType(Base.getType(),
4748 QualType(Initializers.back()->getBaseClass(), 0));
4752 Builder.AddTypedTextChunk(
4753 Results.getAllocator().CopyString(
4754 Base.getType().getAsString(Policy)));
4755 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4756 Builder.AddPlaceholderChunk("args");
4757 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4758 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4759 SawLastInitializer? CCP_NextInitializer
4760 : CCP_MemberDeclaration));
4761 SawLastInitializer = false;
4764 // Add completions for virtual base classes.
4765 for (const auto &Base : ClassDecl->vbases()) {
4766 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4769 = !Initializers.empty() &&
4770 Initializers.back()->isBaseInitializer() &&
4771 Context.hasSameUnqualifiedType(Base.getType(),
4772 QualType(Initializers.back()->getBaseClass(), 0));
4776 Builder.AddTypedTextChunk(
4777 Builder.getAllocator().CopyString(
4778 Base.getType().getAsString(Policy)));
4779 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4780 Builder.AddPlaceholderChunk("args");
4781 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4782 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4783 SawLastInitializer? CCP_NextInitializer
4784 : CCP_MemberDeclaration));
4785 SawLastInitializer = false;
4788 // Add completions for members.
4789 for (auto *Field : ClassDecl->fields()) {
4790 if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))
4793 = !Initializers.empty() &&
4794 Initializers.back()->isAnyMemberInitializer() &&
4795 Initializers.back()->getAnyMember() == Field;
4799 if (!Field->getDeclName())
4802 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
4803 Field->getIdentifier()->getName()));
4804 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4805 Builder.AddPlaceholderChunk("args");
4806 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4807 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4808 SawLastInitializer? CCP_NextInitializer
4809 : CCP_MemberDeclaration,
4811 CXAvailability_Available,
4813 SawLastInitializer = false;
4815 Results.ExitScope();
4817 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4818 Results.data(), Results.size());
4821 /// \brief Determine whether this scope denotes a namespace.
4822 static bool isNamespaceScope(Scope *S) {
4823 DeclContext *DC = S->getEntity();
4827 return DC->isFileContext();
4830 void Sema::CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
4831 bool AfterAmpersand) {
4832 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4833 CodeCompleter->getCodeCompletionTUInfo(),
4834 CodeCompletionContext::CCC_Other);
4835 Results.EnterNewScope();
4837 // Note what has already been captured.
4838 llvm::SmallPtrSet<IdentifierInfo *, 4> Known;
4839 bool IncludedThis = false;
4840 for (const auto &C : Intro.Captures) {
4841 if (C.Kind == LCK_This) {
4842 IncludedThis = true;
4849 // Look for other capturable variables.
4850 for (; S && !isNamespaceScope(S); S = S->getParent()) {
4851 for (const auto *D : S->decls()) {
4852 const auto *Var = dyn_cast<VarDecl>(D);
4854 !Var->hasLocalStorage() ||
4855 Var->hasAttr<BlocksAttr>())
4858 if (Known.insert(Var->getIdentifier()).second)
4859 Results.AddResult(CodeCompletionResult(Var, CCP_LocalDeclaration),
4860 CurContext, nullptr, false);
4864 // Add 'this', if it would be valid.
4865 if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy)
4866 addThisCompletion(*this, Results);
4868 Results.ExitScope();
4870 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4871 Results.data(), Results.size());
4874 /// Macro that optionally prepends an "@" to the string literal passed in via
4875 /// Keyword, depending on whether NeedAt is true or false.
4876 #define OBJC_AT_KEYWORD_NAME(NeedAt,Keyword) ((NeedAt)? "@" Keyword : Keyword)
4878 static void AddObjCImplementationResults(const LangOptions &LangOpts,
4879 ResultBuilder &Results,
4881 typedef CodeCompletionResult Result;
4882 // Since we have an implementation, we can end it.
4883 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
4885 CodeCompletionBuilder Builder(Results.getAllocator(),
4886 Results.getCodeCompletionTUInfo());
4887 if (LangOpts.ObjC2) {
4889 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"dynamic"));
4890 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4891 Builder.AddPlaceholderChunk("property");
4892 Results.AddResult(Result(Builder.TakeString()));
4895 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synthesize"));
4896 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4897 Builder.AddPlaceholderChunk("property");
4898 Results.AddResult(Result(Builder.TakeString()));
4902 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
4903 ResultBuilder &Results,
4905 typedef CodeCompletionResult Result;
4907 // Since we have an interface or protocol, we can end it.
4908 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
4910 if (LangOpts.ObjC2) {
4912 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"property")));
4915 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"required")));
4918 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"optional")));
4922 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
4923 typedef CodeCompletionResult Result;
4924 CodeCompletionBuilder Builder(Results.getAllocator(),
4925 Results.getCodeCompletionTUInfo());
4928 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"class"));
4929 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4930 Builder.AddPlaceholderChunk("name");
4931 Results.AddResult(Result(Builder.TakeString()));
4933 if (Results.includeCodePatterns()) {
4935 // FIXME: Could introduce the whole pattern, including superclasses and
4937 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"interface"));
4938 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4939 Builder.AddPlaceholderChunk("class");
4940 Results.AddResult(Result(Builder.TakeString()));
4943 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
4944 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4945 Builder.AddPlaceholderChunk("protocol");
4946 Results.AddResult(Result(Builder.TakeString()));
4948 // @implementation name
4949 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"implementation"));
4950 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4951 Builder.AddPlaceholderChunk("class");
4952 Results.AddResult(Result(Builder.TakeString()));
4955 // @compatibility_alias name
4956 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"compatibility_alias"));
4957 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4958 Builder.AddPlaceholderChunk("alias");
4959 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4960 Builder.AddPlaceholderChunk("class");
4961 Results.AddResult(Result(Builder.TakeString()));
4963 if (Results.getSema().getLangOpts().Modules) {
4965 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import"));
4966 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4967 Builder.AddPlaceholderChunk("module");
4968 Results.AddResult(Result(Builder.TakeString()));
4972 void Sema::CodeCompleteObjCAtDirective(Scope *S) {
4973 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4974 CodeCompleter->getCodeCompletionTUInfo(),
4975 CodeCompletionContext::CCC_Other);
4976 Results.EnterNewScope();
4977 if (isa<ObjCImplDecl>(CurContext))
4978 AddObjCImplementationResults(getLangOpts(), Results, false);
4979 else if (CurContext->isObjCContainer())
4980 AddObjCInterfaceResults(getLangOpts(), Results, false);
4982 AddObjCTopLevelResults(Results, false);
4983 Results.ExitScope();
4984 HandleCodeCompleteResults(this, CodeCompleter,
4985 CodeCompletionContext::CCC_Other,
4986 Results.data(),Results.size());
4989 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) {
4990 typedef CodeCompletionResult Result;
4991 CodeCompletionBuilder Builder(Results.getAllocator(),
4992 Results.getCodeCompletionTUInfo());
4994 // @encode ( type-name )
4995 const char *EncodeType = "char[]";
4996 if (Results.getSema().getLangOpts().CPlusPlus ||
4997 Results.getSema().getLangOpts().ConstStrings)
4998 EncodeType = "const char[]";
4999 Builder.AddResultTypeChunk(EncodeType);
5000 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"encode"));
5001 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5002 Builder.AddPlaceholderChunk("type-name");
5003 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5004 Results.AddResult(Result(Builder.TakeString()));
5006 // @protocol ( protocol-name )
5007 Builder.AddResultTypeChunk("Protocol *");
5008 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
5009 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5010 Builder.AddPlaceholderChunk("protocol-name");
5011 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5012 Results.AddResult(Result(Builder.TakeString()));
5014 // @selector ( selector )
5015 Builder.AddResultTypeChunk("SEL");
5016 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"selector"));
5017 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5018 Builder.AddPlaceholderChunk("selector");
5019 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5020 Results.AddResult(Result(Builder.TakeString()));
5023 Builder.AddResultTypeChunk("NSString *");
5024 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"\""));
5025 Builder.AddPlaceholderChunk("string");
5026 Builder.AddTextChunk("\"");
5027 Results.AddResult(Result(Builder.TakeString()));
5030 Builder.AddResultTypeChunk("NSArray *");
5031 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"["));
5032 Builder.AddPlaceholderChunk("objects, ...");
5033 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
5034 Results.AddResult(Result(Builder.TakeString()));
5036 // @{key : object, ...}
5037 Builder.AddResultTypeChunk("NSDictionary *");
5038 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"{"));
5039 Builder.AddPlaceholderChunk("key");
5040 Builder.AddChunk(CodeCompletionString::CK_Colon);
5041 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5042 Builder.AddPlaceholderChunk("object, ...");
5043 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5044 Results.AddResult(Result(Builder.TakeString()));
5047 Builder.AddResultTypeChunk("id");
5048 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "("));
5049 Builder.AddPlaceholderChunk("expression");
5050 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5051 Results.AddResult(Result(Builder.TakeString()));
5054 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) {
5055 typedef CodeCompletionResult Result;
5056 CodeCompletionBuilder Builder(Results.getAllocator(),
5057 Results.getCodeCompletionTUInfo());
5059 if (Results.includeCodePatterns()) {
5060 // @try { statements } @catch ( declaration ) { statements } @finally
5062 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"try"));
5063 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5064 Builder.AddPlaceholderChunk("statements");
5065 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5066 Builder.AddTextChunk("@catch");
5067 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5068 Builder.AddPlaceholderChunk("parameter");
5069 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5070 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5071 Builder.AddPlaceholderChunk("statements");
5072 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5073 Builder.AddTextChunk("@finally");
5074 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5075 Builder.AddPlaceholderChunk("statements");
5076 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5077 Results.AddResult(Result(Builder.TakeString()));
5081 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"throw"));
5082 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5083 Builder.AddPlaceholderChunk("expression");
5084 Results.AddResult(Result(Builder.TakeString()));
5086 if (Results.includeCodePatterns()) {
5087 // @synchronized ( expression ) { statements }
5088 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synchronized"));
5089 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5090 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5091 Builder.AddPlaceholderChunk("expression");
5092 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5093 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5094 Builder.AddPlaceholderChunk("statements");
5095 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5096 Results.AddResult(Result(Builder.TakeString()));
5100 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
5101 ResultBuilder &Results,
5103 typedef CodeCompletionResult Result;
5104 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"private")));
5105 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"protected")));
5106 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"public")));
5108 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"package")));
5111 void Sema::CodeCompleteObjCAtVisibility(Scope *S) {
5112 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5113 CodeCompleter->getCodeCompletionTUInfo(),
5114 CodeCompletionContext::CCC_Other);
5115 Results.EnterNewScope();
5116 AddObjCVisibilityResults(getLangOpts(), Results, false);
5117 Results.ExitScope();
5118 HandleCodeCompleteResults(this, CodeCompleter,
5119 CodeCompletionContext::CCC_Other,
5120 Results.data(),Results.size());
5123 void Sema::CodeCompleteObjCAtStatement(Scope *S) {
5124 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5125 CodeCompleter->getCodeCompletionTUInfo(),
5126 CodeCompletionContext::CCC_Other);
5127 Results.EnterNewScope();
5128 AddObjCStatementResults(Results, false);
5129 AddObjCExpressionResults(Results, false);
5130 Results.ExitScope();
5131 HandleCodeCompleteResults(this, CodeCompleter,
5132 CodeCompletionContext::CCC_Other,
5133 Results.data(),Results.size());
5136 void Sema::CodeCompleteObjCAtExpression(Scope *S) {
5137 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5138 CodeCompleter->getCodeCompletionTUInfo(),
5139 CodeCompletionContext::CCC_Other);
5140 Results.EnterNewScope();
5141 AddObjCExpressionResults(Results, false);
5142 Results.ExitScope();
5143 HandleCodeCompleteResults(this, CodeCompleter,
5144 CodeCompletionContext::CCC_Other,
5145 Results.data(),Results.size());
5148 /// \brief Determine whether the addition of the given flag to an Objective-C
5149 /// property's attributes will cause a conflict.
5150 static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) {
5151 // Check if we've already added this flag.
5152 if (Attributes & NewFlag)
5155 Attributes |= NewFlag;
5157 // Check for collisions with "readonly".
5158 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
5159 (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
5162 // Check for more than one of { assign, copy, retain, strong, weak }.
5163 unsigned AssignCopyRetMask = Attributes & (ObjCDeclSpec::DQ_PR_assign |
5164 ObjCDeclSpec::DQ_PR_unsafe_unretained |
5165 ObjCDeclSpec::DQ_PR_copy |
5166 ObjCDeclSpec::DQ_PR_retain |
5167 ObjCDeclSpec::DQ_PR_strong |
5168 ObjCDeclSpec::DQ_PR_weak);
5169 if (AssignCopyRetMask &&
5170 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign &&
5171 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_unsafe_unretained &&
5172 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy &&
5173 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain &&
5174 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_strong &&
5175 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_weak)
5181 void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) {
5185 unsigned Attributes = ODS.getPropertyAttributes();
5187 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5188 CodeCompleter->getCodeCompletionTUInfo(),
5189 CodeCompletionContext::CCC_Other);
5190 Results.EnterNewScope();
5191 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readonly))
5192 Results.AddResult(CodeCompletionResult("readonly"));
5193 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_assign))
5194 Results.AddResult(CodeCompletionResult("assign"));
5195 if (!ObjCPropertyFlagConflicts(Attributes,
5196 ObjCDeclSpec::DQ_PR_unsafe_unretained))
5197 Results.AddResult(CodeCompletionResult("unsafe_unretained"));
5198 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readwrite))
5199 Results.AddResult(CodeCompletionResult("readwrite"));
5200 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_retain))
5201 Results.AddResult(CodeCompletionResult("retain"));
5202 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_strong))
5203 Results.AddResult(CodeCompletionResult("strong"));
5204 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_copy))
5205 Results.AddResult(CodeCompletionResult("copy"));
5206 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nonatomic))
5207 Results.AddResult(CodeCompletionResult("nonatomic"));
5208 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_atomic))
5209 Results.AddResult(CodeCompletionResult("atomic"));
5211 // Only suggest "weak" if we're compiling for ARC-with-weak-references or GC.
5212 if (getLangOpts().ObjCWeak || getLangOpts().getGC() != LangOptions::NonGC)
5213 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_weak))
5214 Results.AddResult(CodeCompletionResult("weak"));
5216 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_setter)) {
5217 CodeCompletionBuilder Setter(Results.getAllocator(),
5218 Results.getCodeCompletionTUInfo());
5219 Setter.AddTypedTextChunk("setter");
5220 Setter.AddTextChunk("=");
5221 Setter.AddPlaceholderChunk("method");
5222 Results.AddResult(CodeCompletionResult(Setter.TakeString()));
5224 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_getter)) {
5225 CodeCompletionBuilder Getter(Results.getAllocator(),
5226 Results.getCodeCompletionTUInfo());
5227 Getter.AddTypedTextChunk("getter");
5228 Getter.AddTextChunk("=");
5229 Getter.AddPlaceholderChunk("method");
5230 Results.AddResult(CodeCompletionResult(Getter.TakeString()));
5232 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nullability)) {
5233 Results.AddResult(CodeCompletionResult("nonnull"));
5234 Results.AddResult(CodeCompletionResult("nullable"));
5235 Results.AddResult(CodeCompletionResult("null_unspecified"));
5236 Results.AddResult(CodeCompletionResult("null_resettable"));
5238 Results.ExitScope();
5239 HandleCodeCompleteResults(this, CodeCompleter,
5240 CodeCompletionContext::CCC_Other,
5241 Results.data(),Results.size());
5244 /// \brief Describes the kind of Objective-C method that we want to find
5245 /// via code completion.
5246 enum ObjCMethodKind {
5247 MK_Any, ///< Any kind of method, provided it means other specified criteria.
5248 MK_ZeroArgSelector, ///< Zero-argument (unary) selector.
5249 MK_OneArgSelector ///< One-argument selector.
5252 static bool isAcceptableObjCSelector(Selector Sel,
5253 ObjCMethodKind WantKind,
5254 ArrayRef<IdentifierInfo *> SelIdents,
5255 bool AllowSameLength = true) {
5256 unsigned NumSelIdents = SelIdents.size();
5257 if (NumSelIdents > Sel.getNumArgs())
5262 case MK_ZeroArgSelector: return Sel.isUnarySelector();
5263 case MK_OneArgSelector: return Sel.getNumArgs() == 1;
5266 if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs())
5269 for (unsigned I = 0; I != NumSelIdents; ++I)
5270 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I))
5276 static bool isAcceptableObjCMethod(ObjCMethodDecl *Method,
5277 ObjCMethodKind WantKind,
5278 ArrayRef<IdentifierInfo *> SelIdents,
5279 bool AllowSameLength = true) {
5280 return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents,
5285 /// \brief A set of selectors, which is used to avoid introducing multiple
5286 /// completions with the same selector into the result set.
5287 typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet;
5290 /// \brief Add all of the Objective-C methods in the given Objective-C
5291 /// container to the set of results.
5293 /// The container will be a class, protocol, category, or implementation of
5294 /// any of the above. This mether will recurse to include methods from
5295 /// the superclasses of classes along with their categories, protocols, and
5296 /// implementations.
5298 /// \param Container the container in which we'll look to find methods.
5300 /// \param WantInstanceMethods Whether to add instance methods (only); if
5301 /// false, this routine will add factory methods (only).
5303 /// \param CurContext the context in which we're performing the lookup that
5306 /// \param AllowSameLength Whether we allow a method to be added to the list
5307 /// when it has the same number of parameters as we have selector identifiers.
5309 /// \param Results the structure into which we'll add results.
5310 static void AddObjCMethods(ObjCContainerDecl *Container,
5311 bool WantInstanceMethods, ObjCMethodKind WantKind,
5312 ArrayRef<IdentifierInfo *> SelIdents,
5313 DeclContext *CurContext,
5314 VisitedSelectorSet &Selectors, bool AllowSameLength,
5315 ResultBuilder &Results, bool InOriginalClass = true,
5316 bool IsRootClass = false) {
5317 typedef CodeCompletionResult Result;
5318 Container = getContainerDef(Container);
5319 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
5320 IsRootClass = IsRootClass || (IFace && !IFace->getSuperClass());
5321 for (auto *M : Container->methods()) {
5322 // The instance methods on the root class can be messaged via the
5324 if (M->isInstanceMethod() == WantInstanceMethods ||
5325 (IsRootClass && !WantInstanceMethods)) {
5326 // Check whether the selector identifiers we've been given are a
5327 // subset of the identifiers for this particular method.
5328 if (!isAcceptableObjCMethod(M, WantKind, SelIdents, AllowSameLength))
5331 if (!Selectors.insert(M->getSelector()).second)
5334 Result R = Result(M, Results.getBasePriority(M), nullptr);
5335 R.StartParameter = SelIdents.size();
5336 R.AllParametersAreInformative = (WantKind != MK_Any);
5337 if (!InOriginalClass)
5338 R.Priority += CCD_InBaseClass;
5339 Results.MaybeAddResult(R, CurContext);
5343 // Visit the protocols of protocols.
5344 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
5345 if (Protocol->hasDefinition()) {
5346 const ObjCList<ObjCProtocolDecl> &Protocols
5347 = Protocol->getReferencedProtocols();
5348 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5349 E = Protocols.end();
5351 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5352 Selectors, AllowSameLength, Results, false, IsRootClass);
5356 if (!IFace || !IFace->hasDefinition())
5359 // Add methods in protocols.
5360 for (auto *I : IFace->protocols())
5361 AddObjCMethods(I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5362 Selectors, AllowSameLength, Results, false, IsRootClass);
5364 // Add methods in categories.
5365 for (auto *CatDecl : IFace->known_categories()) {
5366 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
5367 CurContext, Selectors, AllowSameLength, Results,
5368 InOriginalClass, IsRootClass);
5370 // Add a categories protocol methods.
5371 const ObjCList<ObjCProtocolDecl> &Protocols
5372 = CatDecl->getReferencedProtocols();
5373 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5374 E = Protocols.end();
5376 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5377 Selectors, AllowSameLength, Results, false, IsRootClass);
5379 // Add methods in category implementations.
5380 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation())
5381 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
5382 Selectors, AllowSameLength, Results, InOriginalClass,
5386 // Add methods in superclass.
5387 // Avoid passing in IsRootClass since root classes won't have super classes.
5388 if (IFace->getSuperClass())
5389 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind,
5390 SelIdents, CurContext, Selectors, AllowSameLength, Results,
5391 /*IsRootClass=*/false);
5393 // Add methods in our implementation, if any.
5394 if (ObjCImplementationDecl *Impl = IFace->getImplementation())
5395 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
5396 Selectors, AllowSameLength, Results, InOriginalClass,
5401 void Sema::CodeCompleteObjCPropertyGetter(Scope *S) {
5402 // Try to find the interface where getters might live.
5403 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
5405 if (ObjCCategoryDecl *Category
5406 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
5407 Class = Category->getClassInterface();
5413 // Find all of the potential getters.
5414 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5415 CodeCompleter->getCodeCompletionTUInfo(),
5416 CodeCompletionContext::CCC_Other);
5417 Results.EnterNewScope();
5419 VisitedSelectorSet Selectors;
5420 AddObjCMethods(Class, true, MK_ZeroArgSelector, None, CurContext, Selectors,
5421 /*AllowSameLength=*/true, Results);
5422 Results.ExitScope();
5423 HandleCodeCompleteResults(this, CodeCompleter,
5424 CodeCompletionContext::CCC_Other,
5425 Results.data(),Results.size());
5428 void Sema::CodeCompleteObjCPropertySetter(Scope *S) {
5429 // Try to find the interface where setters might live.
5430 ObjCInterfaceDecl *Class
5431 = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
5433 if (ObjCCategoryDecl *Category
5434 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
5435 Class = Category->getClassInterface();
5441 // Find all of the potential getters.
5442 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5443 CodeCompleter->getCodeCompletionTUInfo(),
5444 CodeCompletionContext::CCC_Other);
5445 Results.EnterNewScope();
5447 VisitedSelectorSet Selectors;
5448 AddObjCMethods(Class, true, MK_OneArgSelector, None, CurContext,
5449 Selectors, /*AllowSameLength=*/true, Results);
5451 Results.ExitScope();
5452 HandleCodeCompleteResults(this, CodeCompleter,
5453 CodeCompletionContext::CCC_Other,
5454 Results.data(),Results.size());
5457 void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
5459 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5460 CodeCompleter->getCodeCompletionTUInfo(),
5461 CodeCompletionContext::CCC_Type);
5462 Results.EnterNewScope();
5464 // Add context-sensitive, Objective-C parameter-passing keywords.
5465 bool AddedInOut = false;
5466 if ((DS.getObjCDeclQualifier() &
5467 (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) {
5468 Results.AddResult("in");
5469 Results.AddResult("inout");
5472 if ((DS.getObjCDeclQualifier() &
5473 (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) {
5474 Results.AddResult("out");
5476 Results.AddResult("inout");
5478 if ((DS.getObjCDeclQualifier() &
5479 (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref |
5480 ObjCDeclSpec::DQ_Oneway)) == 0) {
5481 Results.AddResult("bycopy");
5482 Results.AddResult("byref");
5483 Results.AddResult("oneway");
5485 if ((DS.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability) == 0) {
5486 Results.AddResult("nonnull");
5487 Results.AddResult("nullable");
5488 Results.AddResult("null_unspecified");
5491 // If we're completing the return type of an Objective-C method and the
5492 // identifier IBAction refers to a macro, provide a completion item for
5494 // IBAction)<#selector#>:(id)sender
5495 if (DS.getObjCDeclQualifier() == 0 && !IsParameter &&
5496 PP.isMacroDefined("IBAction")) {
5497 CodeCompletionBuilder Builder(Results.getAllocator(),
5498 Results.getCodeCompletionTUInfo(),
5499 CCP_CodePattern, CXAvailability_Available);
5500 Builder.AddTypedTextChunk("IBAction");
5501 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5502 Builder.AddPlaceholderChunk("selector");
5503 Builder.AddChunk(CodeCompletionString::CK_Colon);
5504 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5505 Builder.AddTextChunk("id");
5506 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5507 Builder.AddTextChunk("sender");
5508 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
5511 // If we're completing the return type, provide 'instancetype'.
5513 Results.AddResult(CodeCompletionResult("instancetype"));
5516 // Add various builtin type names and specifiers.
5517 AddOrdinaryNameResults(PCC_Type, S, *this, Results);
5518 Results.ExitScope();
5520 // Add the various type names
5521 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
5522 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5523 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5524 CodeCompleter->includeGlobals());
5526 if (CodeCompleter->includeMacros())
5527 AddMacroResults(PP, Results, false);
5529 HandleCodeCompleteResults(this, CodeCompleter,
5530 CodeCompletionContext::CCC_Type,
5531 Results.data(), Results.size());
5534 /// \brief When we have an expression with type "id", we may assume
5535 /// that it has some more-specific class type based on knowledge of
5536 /// common uses of Objective-C. This routine returns that class type,
5537 /// or NULL if no better result could be determined.
5538 static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) {
5539 ObjCMessageExpr *Msg = dyn_cast_or_null<ObjCMessageExpr>(E);
5543 Selector Sel = Msg->getSelector();
5547 IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0);
5551 ObjCMethodDecl *Method = Msg->getMethodDecl();
5555 // Determine the class that we're sending the message to.
5556 ObjCInterfaceDecl *IFace = nullptr;
5557 switch (Msg->getReceiverKind()) {
5558 case ObjCMessageExpr::Class:
5559 if (const ObjCObjectType *ObjType
5560 = Msg->getClassReceiver()->getAs<ObjCObjectType>())
5561 IFace = ObjType->getInterface();
5564 case ObjCMessageExpr::Instance: {
5565 QualType T = Msg->getInstanceReceiver()->getType();
5566 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
5567 IFace = Ptr->getInterfaceDecl();
5571 case ObjCMessageExpr::SuperInstance:
5572 case ObjCMessageExpr::SuperClass:
5579 ObjCInterfaceDecl *Super = IFace->getSuperClass();
5580 if (Method->isInstanceMethod())
5581 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5582 .Case("retain", IFace)
5583 .Case("strong", IFace)
5584 .Case("autorelease", IFace)
5585 .Case("copy", IFace)
5586 .Case("copyWithZone", IFace)
5587 .Case("mutableCopy", IFace)
5588 .Case("mutableCopyWithZone", IFace)
5589 .Case("awakeFromCoder", IFace)
5590 .Case("replacementObjectFromCoder", IFace)
5591 .Case("class", IFace)
5592 .Case("classForCoder", IFace)
5593 .Case("superclass", Super)
5596 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5598 .Case("alloc", IFace)
5599 .Case("allocWithZone", IFace)
5600 .Case("class", IFace)
5601 .Case("superclass", Super)
5605 // Add a special completion for a message send to "super", which fills in the
5606 // most likely case of forwarding all of our arguments to the superclass
5609 /// \param S The semantic analysis object.
5611 /// \param NeedSuperKeyword Whether we need to prefix this completion with
5612 /// the "super" keyword. Otherwise, we just need to provide the arguments.
5614 /// \param SelIdents The identifiers in the selector that have already been
5615 /// provided as arguments for a send to "super".
5617 /// \param Results The set of results to augment.
5619 /// \returns the Objective-C method declaration that would be invoked by
5620 /// this "super" completion. If NULL, no completion was added.
5621 static ObjCMethodDecl *AddSuperSendCompletion(
5622 Sema &S, bool NeedSuperKeyword,
5623 ArrayRef<IdentifierInfo *> SelIdents,
5624 ResultBuilder &Results) {
5625 ObjCMethodDecl *CurMethod = S.getCurMethodDecl();
5629 ObjCInterfaceDecl *Class = CurMethod->getClassInterface();
5633 // Try to find a superclass method with the same selector.
5634 ObjCMethodDecl *SuperMethod = nullptr;
5635 while ((Class = Class->getSuperClass()) && !SuperMethod) {
5636 // Check in the class
5637 SuperMethod = Class->getMethod(CurMethod->getSelector(),
5638 CurMethod->isInstanceMethod());
5640 // Check in categories or class extensions.
5642 for (const auto *Cat : Class->known_categories()) {
5643 if ((SuperMethod = Cat->getMethod(CurMethod->getSelector(),
5644 CurMethod->isInstanceMethod())))
5653 // Check whether the superclass method has the same signature.
5654 if (CurMethod->param_size() != SuperMethod->param_size() ||
5655 CurMethod->isVariadic() != SuperMethod->isVariadic())
5658 for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(),
5659 CurPEnd = CurMethod->param_end(),
5660 SuperP = SuperMethod->param_begin();
5661 CurP != CurPEnd; ++CurP, ++SuperP) {
5662 // Make sure the parameter types are compatible.
5663 if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(),
5664 (*SuperP)->getType()))
5667 // Make sure we have a parameter name to forward!
5668 if (!(*CurP)->getIdentifier())
5672 // We have a superclass method. Now, form the send-to-super completion.
5673 CodeCompletionBuilder Builder(Results.getAllocator(),
5674 Results.getCodeCompletionTUInfo());
5676 // Give this completion a return type.
5677 AddResultTypeChunk(S.Context, getCompletionPrintingPolicy(S), SuperMethod,
5678 Results.getCompletionContext().getBaseType(),
5681 // If we need the "super" keyword, add it (plus some spacing).
5682 if (NeedSuperKeyword) {
5683 Builder.AddTypedTextChunk("super");
5684 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5687 Selector Sel = CurMethod->getSelector();
5688 if (Sel.isUnarySelector()) {
5689 if (NeedSuperKeyword)
5690 Builder.AddTextChunk(Builder.getAllocator().CopyString(
5691 Sel.getNameForSlot(0)));
5693 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
5694 Sel.getNameForSlot(0)));
5696 ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin();
5697 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) {
5698 if (I > SelIdents.size())
5699 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5701 if (I < SelIdents.size())
5702 Builder.AddInformativeChunk(
5703 Builder.getAllocator().CopyString(
5704 Sel.getNameForSlot(I) + ":"));
5705 else if (NeedSuperKeyword || I > SelIdents.size()) {
5706 Builder.AddTextChunk(
5707 Builder.getAllocator().CopyString(
5708 Sel.getNameForSlot(I) + ":"));
5709 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5710 (*CurP)->getIdentifier()->getName()));
5712 Builder.AddTypedTextChunk(
5713 Builder.getAllocator().CopyString(
5714 Sel.getNameForSlot(I) + ":"));
5715 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5716 (*CurP)->getIdentifier()->getName()));
5721 Results.AddResult(CodeCompletionResult(Builder.TakeString(), SuperMethod,
5722 CCP_SuperCompletion));
5726 void Sema::CodeCompleteObjCMessageReceiver(Scope *S) {
5727 typedef CodeCompletionResult Result;
5728 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5729 CodeCompleter->getCodeCompletionTUInfo(),
5730 CodeCompletionContext::CCC_ObjCMessageReceiver,
5731 getLangOpts().CPlusPlus11
5732 ? &ResultBuilder::IsObjCMessageReceiverOrLambdaCapture
5733 : &ResultBuilder::IsObjCMessageReceiver);
5735 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5736 Results.EnterNewScope();
5737 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5738 CodeCompleter->includeGlobals());
5740 // If we are in an Objective-C method inside a class that has a superclass,
5741 // add "super" as an option.
5742 if (ObjCMethodDecl *Method = getCurMethodDecl())
5743 if (ObjCInterfaceDecl *Iface = Method->getClassInterface())
5744 if (Iface->getSuperClass()) {
5745 Results.AddResult(Result("super"));
5747 AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, None, Results);
5750 if (getLangOpts().CPlusPlus11)
5751 addThisCompletion(*this, Results);
5753 Results.ExitScope();
5755 if (CodeCompleter->includeMacros())
5756 AddMacroResults(PP, Results, false);
5757 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5758 Results.data(), Results.size());
5762 void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
5763 ArrayRef<IdentifierInfo *> SelIdents,
5764 bool AtArgumentExpression) {
5765 ObjCInterfaceDecl *CDecl = nullptr;
5766 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5767 // Figure out which interface we're in.
5768 CDecl = CurMethod->getClassInterface();
5772 // Find the superclass of this class.
5773 CDecl = CDecl->getSuperClass();
5777 if (CurMethod->isInstanceMethod()) {
5778 // We are inside an instance method, which means that the message
5779 // send [super ...] is actually calling an instance method on the
5781 return CodeCompleteObjCInstanceMessage(S, nullptr, SelIdents,
5782 AtArgumentExpression,
5786 // Fall through to send to the superclass in CDecl.
5788 // "super" may be the name of a type or variable. Figure out which
5790 IdentifierInfo *Super = getSuperIdentifier();
5791 NamedDecl *ND = LookupSingleName(S, Super, SuperLoc,
5792 LookupOrdinaryName);
5793 if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) {
5794 // "super" names an interface. Use it.
5795 } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) {
5796 if (const ObjCObjectType *Iface
5797 = Context.getTypeDeclType(TD)->getAs<ObjCObjectType>())
5798 CDecl = Iface->getInterface();
5799 } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) {
5800 // "super" names an unresolved type; we can't be more specific.
5802 // Assume that "super" names some kind of value and parse that way.
5804 SourceLocation TemplateKWLoc;
5806 id.setIdentifier(Super, SuperLoc);
5807 ExprResult SuperExpr = ActOnIdExpression(S, SS, TemplateKWLoc, id,
5809 return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
5811 AtArgumentExpression);
5817 ParsedType Receiver;
5819 Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl));
5820 return CodeCompleteObjCClassMessage(S, Receiver, SelIdents,
5821 AtArgumentExpression,
5825 /// \brief Given a set of code-completion results for the argument of a message
5826 /// send, determine the preferred type (if any) for that argument expression.
5827 static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
5828 unsigned NumSelIdents) {
5829 typedef CodeCompletionResult Result;
5830 ASTContext &Context = Results.getSema().Context;
5832 QualType PreferredType;
5833 unsigned BestPriority = CCP_Unlikely * 2;
5834 Result *ResultsData = Results.data();
5835 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
5836 Result &R = ResultsData[I];
5837 if (R.Kind == Result::RK_Declaration &&
5838 isa<ObjCMethodDecl>(R.Declaration)) {
5839 if (R.Priority <= BestPriority) {
5840 const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration);
5841 if (NumSelIdents <= Method->param_size()) {
5842 QualType MyPreferredType = Method->parameters()[NumSelIdents - 1]
5844 if (R.Priority < BestPriority || PreferredType.isNull()) {
5845 BestPriority = R.Priority;
5846 PreferredType = MyPreferredType;
5847 } else if (!Context.hasSameUnqualifiedType(PreferredType,
5849 PreferredType = QualType();
5856 return PreferredType;
5859 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
5860 ParsedType Receiver,
5861 ArrayRef<IdentifierInfo *> SelIdents,
5862 bool AtArgumentExpression,
5864 ResultBuilder &Results) {
5865 typedef CodeCompletionResult Result;
5866 ObjCInterfaceDecl *CDecl = nullptr;
5868 // If the given name refers to an interface type, retrieve the
5869 // corresponding declaration.
5871 QualType T = SemaRef.GetTypeFromParser(Receiver, nullptr);
5873 if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>())
5874 CDecl = Interface->getInterface();
5877 // Add all of the factory methods in this Objective-C class, its protocols,
5878 // superclasses, categories, implementation, etc.
5879 Results.EnterNewScope();
5881 // If this is a send-to-super, try to add the special "super" send
5884 if (ObjCMethodDecl *SuperMethod
5885 = AddSuperSendCompletion(SemaRef, false, SelIdents, Results))
5886 Results.Ignore(SuperMethod);
5889 // If we're inside an Objective-C method definition, prefer its selector to
5891 if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl())
5892 Results.setPreferredSelector(CurMethod->getSelector());
5894 VisitedSelectorSet Selectors;
5896 AddObjCMethods(CDecl, false, MK_Any, SelIdents,
5897 SemaRef.CurContext, Selectors, AtArgumentExpression,
5900 // We're messaging "id" as a type; provide all class/factory methods.
5902 // If we have an external source, load the entire class method
5903 // pool from the AST file.
5904 if (SemaRef.getExternalSource()) {
5905 for (uint32_t I = 0,
5906 N = SemaRef.getExternalSource()->GetNumExternalSelectors();
5908 Selector Sel = SemaRef.getExternalSource()->GetExternalSelector(I);
5909 if (Sel.isNull() || SemaRef.MethodPool.count(Sel))
5912 SemaRef.ReadMethodPool(Sel);
5916 for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(),
5917 MEnd = SemaRef.MethodPool.end();
5919 for (ObjCMethodList *MethList = &M->second.second;
5920 MethList && MethList->getMethod();
5921 MethList = MethList->getNext()) {
5922 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
5925 Result R(MethList->getMethod(),
5926 Results.getBasePriority(MethList->getMethod()), nullptr);
5927 R.StartParameter = SelIdents.size();
5928 R.AllParametersAreInformative = false;
5929 Results.MaybeAddResult(R, SemaRef.CurContext);
5934 Results.ExitScope();
5937 void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
5938 ArrayRef<IdentifierInfo *> SelIdents,
5939 bool AtArgumentExpression,
5942 QualType T = this->GetTypeFromParser(Receiver);
5944 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5945 CodeCompleter->getCodeCompletionTUInfo(),
5946 CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage,
5949 AddClassMessageCompletions(*this, S, Receiver, SelIdents,
5950 AtArgumentExpression, IsSuper, Results);
5952 // If we're actually at the argument expression (rather than prior to the
5953 // selector), we're actually performing code completion for an expression.
5954 // Determine whether we have a single, best method. If so, we can
5955 // code-complete the expression using the corresponding parameter type as
5956 // our preferred type, improving completion results.
5957 if (AtArgumentExpression) {
5958 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
5960 if (PreferredType.isNull())
5961 CodeCompleteOrdinaryName(S, PCC_Expression);
5963 CodeCompleteExpression(S, PreferredType);
5967 HandleCodeCompleteResults(this, CodeCompleter,
5968 Results.getCompletionContext(),
5969 Results.data(), Results.size());
5972 void Sema::CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
5973 ArrayRef<IdentifierInfo *> SelIdents,
5974 bool AtArgumentExpression,
5975 ObjCInterfaceDecl *Super) {
5976 typedef CodeCompletionResult Result;
5978 Expr *RecExpr = static_cast<Expr *>(Receiver);
5980 // If necessary, apply function/array conversion to the receiver.
5981 // C99 6.7.5.3p[7,8].
5983 ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr);
5984 if (Conv.isInvalid()) // conversion failed. bail.
5986 RecExpr = Conv.get();
5988 QualType ReceiverType = RecExpr? RecExpr->getType()
5989 : Super? Context.getObjCObjectPointerType(
5990 Context.getObjCInterfaceType(Super))
5991 : Context.getObjCIdType();
5993 // If we're messaging an expression with type "id" or "Class", check
5994 // whether we know something special about the receiver that allows
5995 // us to assume a more-specific receiver type.
5996 if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType()) {
5997 if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) {
5998 if (ReceiverType->isObjCClassType())
5999 return CodeCompleteObjCClassMessage(S,
6000 ParsedType::make(Context.getObjCInterfaceType(IFace)),
6002 AtArgumentExpression, Super);
6004 ReceiverType = Context.getObjCObjectPointerType(
6005 Context.getObjCInterfaceType(IFace));
6007 } else if (RecExpr && getLangOpts().CPlusPlus) {
6008 ExprResult Conv = PerformContextuallyConvertToObjCPointer(RecExpr);
6009 if (Conv.isUsable()) {
6010 RecExpr = Conv.get();
6011 ReceiverType = RecExpr->getType();
6015 // Build the set of methods we can see.
6016 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6017 CodeCompleter->getCodeCompletionTUInfo(),
6018 CodeCompletionContext(CodeCompletionContext::CCC_ObjCInstanceMessage,
6019 ReceiverType, SelIdents));
6021 Results.EnterNewScope();
6023 // If this is a send-to-super, try to add the special "super" send
6026 if (ObjCMethodDecl *SuperMethod
6027 = AddSuperSendCompletion(*this, false, SelIdents, Results))
6028 Results.Ignore(SuperMethod);
6031 // If we're inside an Objective-C method definition, prefer its selector to
6033 if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
6034 Results.setPreferredSelector(CurMethod->getSelector());
6036 // Keep track of the selectors we've already added.
6037 VisitedSelectorSet Selectors;
6039 // Handle messages to Class. This really isn't a message to an instance
6040 // method, so we treat it the same way we would treat a message send to a
6042 if (ReceiverType->isObjCClassType() ||
6043 ReceiverType->isObjCQualifiedClassType()) {
6044 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
6045 if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface())
6046 AddObjCMethods(ClassDecl, false, MK_Any, SelIdents,
6047 CurContext, Selectors, AtArgumentExpression, Results);
6050 // Handle messages to a qualified ID ("id<foo>").
6051 else if (const ObjCObjectPointerType *QualID
6052 = ReceiverType->getAsObjCQualifiedIdType()) {
6053 // Search protocols for instance methods.
6054 for (auto *I : QualID->quals())
6055 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
6056 Selectors, AtArgumentExpression, Results);
6058 // Handle messages to a pointer to interface type.
6059 else if (const ObjCObjectPointerType *IFacePtr
6060 = ReceiverType->getAsObjCInterfacePointerType()) {
6061 // Search the class, its superclasses, etc., for instance methods.
6062 AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents,
6063 CurContext, Selectors, AtArgumentExpression,
6066 // Search protocols for instance methods.
6067 for (auto *I : IFacePtr->quals())
6068 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
6069 Selectors, AtArgumentExpression, Results);
6071 // Handle messages to "id".
6072 else if (ReceiverType->isObjCIdType()) {
6073 // We're messaging "id", so provide all instance methods we know
6074 // about as code-completion results.
6076 // If we have an external source, load the entire class method
6077 // pool from the AST file.
6078 if (ExternalSource) {
6079 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
6081 Selector Sel = ExternalSource->GetExternalSelector(I);
6082 if (Sel.isNull() || MethodPool.count(Sel))
6085 ReadMethodPool(Sel);
6089 for (GlobalMethodPool::iterator M = MethodPool.begin(),
6090 MEnd = MethodPool.end();
6092 for (ObjCMethodList *MethList = &M->second.first;
6093 MethList && MethList->getMethod();
6094 MethList = MethList->getNext()) {
6095 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
6098 if (!Selectors.insert(MethList->getMethod()->getSelector()).second)
6101 Result R(MethList->getMethod(),
6102 Results.getBasePriority(MethList->getMethod()), nullptr);
6103 R.StartParameter = SelIdents.size();
6104 R.AllParametersAreInformative = false;
6105 Results.MaybeAddResult(R, CurContext);
6109 Results.ExitScope();
6112 // If we're actually at the argument expression (rather than prior to the
6113 // selector), we're actually performing code completion for an expression.
6114 // Determine whether we have a single, best method. If so, we can
6115 // code-complete the expression using the corresponding parameter type as
6116 // our preferred type, improving completion results.
6117 if (AtArgumentExpression) {
6118 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
6120 if (PreferredType.isNull())
6121 CodeCompleteOrdinaryName(S, PCC_Expression);
6123 CodeCompleteExpression(S, PreferredType);
6127 HandleCodeCompleteResults(this, CodeCompleter,
6128 Results.getCompletionContext(),
6129 Results.data(),Results.size());
6132 void Sema::CodeCompleteObjCForCollection(Scope *S,
6133 DeclGroupPtrTy IterationVar) {
6134 CodeCompleteExpressionData Data;
6135 Data.ObjCCollection = true;
6137 if (IterationVar.getAsOpaquePtr()) {
6138 DeclGroupRef DG = IterationVar.get();
6139 for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) {
6141 Data.IgnoreDecls.push_back(*I);
6145 CodeCompleteExpression(S, Data);
6148 void Sema::CodeCompleteObjCSelector(Scope *S,
6149 ArrayRef<IdentifierInfo *> SelIdents) {
6150 // If we have an external source, load the entire class method
6151 // pool from the AST file.
6152 if (ExternalSource) {
6153 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
6155 Selector Sel = ExternalSource->GetExternalSelector(I);
6156 if (Sel.isNull() || MethodPool.count(Sel))
6159 ReadMethodPool(Sel);
6163 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6164 CodeCompleter->getCodeCompletionTUInfo(),
6165 CodeCompletionContext::CCC_SelectorName);
6166 Results.EnterNewScope();
6167 for (GlobalMethodPool::iterator M = MethodPool.begin(),
6168 MEnd = MethodPool.end();
6171 Selector Sel = M->first;
6172 if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents))
6175 CodeCompletionBuilder Builder(Results.getAllocator(),
6176 Results.getCodeCompletionTUInfo());
6177 if (Sel.isUnarySelector()) {
6178 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
6179 Sel.getNameForSlot(0)));
6180 Results.AddResult(Builder.TakeString());
6184 std::string Accumulator;
6185 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) {
6186 if (I == SelIdents.size()) {
6187 if (!Accumulator.empty()) {
6188 Builder.AddInformativeChunk(Builder.getAllocator().CopyString(
6190 Accumulator.clear();
6194 Accumulator += Sel.getNameForSlot(I);
6197 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString( Accumulator));
6198 Results.AddResult(Builder.TakeString());
6200 Results.ExitScope();
6202 HandleCodeCompleteResults(this, CodeCompleter,
6203 CodeCompletionContext::CCC_SelectorName,
6204 Results.data(), Results.size());
6207 /// \brief Add all of the protocol declarations that we find in the given
6208 /// (translation unit) context.
6209 static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext,
6210 bool OnlyForwardDeclarations,
6211 ResultBuilder &Results) {
6212 typedef CodeCompletionResult Result;
6214 for (const auto *D : Ctx->decls()) {
6215 // Record any protocols we find.
6216 if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(D))
6217 if (!OnlyForwardDeclarations || !Proto->hasDefinition())
6218 Results.AddResult(Result(Proto, Results.getBasePriority(Proto),nullptr),
6219 CurContext, nullptr, false);
6223 void Sema::CodeCompleteObjCProtocolReferences(
6224 ArrayRef<IdentifierLocPair> Protocols) {
6225 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6226 CodeCompleter->getCodeCompletionTUInfo(),
6227 CodeCompletionContext::CCC_ObjCProtocolName);
6229 if (CodeCompleter->includeGlobals()) {
6230 Results.EnterNewScope();
6232 // Tell the result set to ignore all of the protocols we have
6234 // FIXME: This doesn't work when caching code-completion results.
6235 for (const IdentifierLocPair &Pair : Protocols)
6236 if (ObjCProtocolDecl *Protocol = LookupProtocol(Pair.first,
6238 Results.Ignore(Protocol);
6240 // Add all protocols.
6241 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false,
6244 Results.ExitScope();
6247 HandleCodeCompleteResults(this, CodeCompleter,
6248 CodeCompletionContext::CCC_ObjCProtocolName,
6249 Results.data(),Results.size());
6252 void Sema::CodeCompleteObjCProtocolDecl(Scope *) {
6253 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6254 CodeCompleter->getCodeCompletionTUInfo(),
6255 CodeCompletionContext::CCC_ObjCProtocolName);
6257 if (CodeCompleter->includeGlobals()) {
6258 Results.EnterNewScope();
6260 // Add all protocols.
6261 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true,
6264 Results.ExitScope();
6267 HandleCodeCompleteResults(this, CodeCompleter,
6268 CodeCompletionContext::CCC_ObjCProtocolName,
6269 Results.data(),Results.size());
6272 /// \brief Add all of the Objective-C interface declarations that we find in
6273 /// the given (translation unit) context.
6274 static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext,
6275 bool OnlyForwardDeclarations,
6276 bool OnlyUnimplemented,
6277 ResultBuilder &Results) {
6278 typedef CodeCompletionResult Result;
6280 for (const auto *D : Ctx->decls()) {
6281 // Record any interfaces we find.
6282 if (const auto *Class = dyn_cast<ObjCInterfaceDecl>(D))
6283 if ((!OnlyForwardDeclarations || !Class->hasDefinition()) &&
6284 (!OnlyUnimplemented || !Class->getImplementation()))
6285 Results.AddResult(Result(Class, Results.getBasePriority(Class),nullptr),
6286 CurContext, nullptr, false);
6290 void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) {
6291 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6292 CodeCompleter->getCodeCompletionTUInfo(),
6293 CodeCompletionContext::CCC_Other);
6294 Results.EnterNewScope();
6296 if (CodeCompleter->includeGlobals()) {
6298 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6302 Results.ExitScope();
6304 HandleCodeCompleteResults(this, CodeCompleter,
6305 CodeCompletionContext::CCC_ObjCInterfaceName,
6306 Results.data(),Results.size());
6309 void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName,
6310 SourceLocation ClassNameLoc) {
6311 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6312 CodeCompleter->getCodeCompletionTUInfo(),
6313 CodeCompletionContext::CCC_ObjCInterfaceName);
6314 Results.EnterNewScope();
6316 // Make sure that we ignore the class we're currently defining.
6318 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6319 if (CurClass && isa<ObjCInterfaceDecl>(CurClass))
6320 Results.Ignore(CurClass);
6322 if (CodeCompleter->includeGlobals()) {
6324 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6328 Results.ExitScope();
6330 HandleCodeCompleteResults(this, CodeCompleter,
6331 CodeCompletionContext::CCC_ObjCInterfaceName,
6332 Results.data(),Results.size());
6335 void Sema::CodeCompleteObjCImplementationDecl(Scope *S) {
6336 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6337 CodeCompleter->getCodeCompletionTUInfo(),
6338 CodeCompletionContext::CCC_Other);
6339 Results.EnterNewScope();
6341 if (CodeCompleter->includeGlobals()) {
6342 // Add all unimplemented classes.
6343 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6347 Results.ExitScope();
6349 HandleCodeCompleteResults(this, CodeCompleter,
6350 CodeCompletionContext::CCC_ObjCInterfaceName,
6351 Results.data(),Results.size());
6354 void Sema::CodeCompleteObjCInterfaceCategory(Scope *S,
6355 IdentifierInfo *ClassName,
6356 SourceLocation ClassNameLoc) {
6357 typedef CodeCompletionResult Result;
6359 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6360 CodeCompleter->getCodeCompletionTUInfo(),
6361 CodeCompletionContext::CCC_ObjCCategoryName);
6363 // Ignore any categories we find that have already been implemented by this
6365 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
6367 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6368 if (ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)){
6369 for (const auto *Cat : Class->visible_categories())
6370 CategoryNames.insert(Cat->getIdentifier());
6373 // Add all of the categories we know about.
6374 Results.EnterNewScope();
6375 TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
6376 for (const auto *D : TU->decls())
6377 if (const auto *Category = dyn_cast<ObjCCategoryDecl>(D))
6378 if (CategoryNames.insert(Category->getIdentifier()).second)
6379 Results.AddResult(Result(Category, Results.getBasePriority(Category),
6381 CurContext, nullptr, false);
6382 Results.ExitScope();
6384 HandleCodeCompleteResults(this, CodeCompleter,
6385 CodeCompletionContext::CCC_ObjCCategoryName,
6386 Results.data(),Results.size());
6389 void Sema::CodeCompleteObjCImplementationCategory(Scope *S,
6390 IdentifierInfo *ClassName,
6391 SourceLocation ClassNameLoc) {
6392 typedef CodeCompletionResult Result;
6394 // Find the corresponding interface. If we couldn't find the interface, the
6395 // program itself is ill-formed. However, we'll try to be helpful still by
6396 // providing the list of all of the categories we know about.
6398 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6399 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass);
6401 return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc);
6403 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6404 CodeCompleter->getCodeCompletionTUInfo(),
6405 CodeCompletionContext::CCC_ObjCCategoryName);
6407 // Add all of the categories that have have corresponding interface
6408 // declarations in this class and any of its superclasses, except for
6409 // already-implemented categories in the class itself.
6410 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
6411 Results.EnterNewScope();
6412 bool IgnoreImplemented = true;
6414 for (const auto *Cat : Class->visible_categories()) {
6415 if ((!IgnoreImplemented || !Cat->getImplementation()) &&
6416 CategoryNames.insert(Cat->getIdentifier()).second)
6417 Results.AddResult(Result(Cat, Results.getBasePriority(Cat), nullptr),
6418 CurContext, nullptr, false);
6421 Class = Class->getSuperClass();
6422 IgnoreImplemented = false;
6424 Results.ExitScope();
6426 HandleCodeCompleteResults(this, CodeCompleter,
6427 CodeCompletionContext::CCC_ObjCCategoryName,
6428 Results.data(),Results.size());
6431 void Sema::CodeCompleteObjCPropertyDefinition(Scope *S) {
6432 CodeCompletionContext CCContext(CodeCompletionContext::CCC_Other);
6433 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6434 CodeCompleter->getCodeCompletionTUInfo(),
6437 // Figure out where this @synthesize lives.
6438 ObjCContainerDecl *Container
6439 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6441 (!isa<ObjCImplementationDecl>(Container) &&
6442 !isa<ObjCCategoryImplDecl>(Container)))
6445 // Ignore any properties that have already been implemented.
6446 Container = getContainerDef(Container);
6447 for (const auto *D : Container->decls())
6448 if (const auto *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(D))
6449 Results.Ignore(PropertyImpl->getPropertyDecl());
6451 // Add any properties that we find.
6452 AddedPropertiesSet AddedProperties;
6453 Results.EnterNewScope();
6454 if (ObjCImplementationDecl *ClassImpl
6455 = dyn_cast<ObjCImplementationDecl>(Container))
6456 AddObjCProperties(CCContext, ClassImpl->getClassInterface(), false,
6457 /*AllowNullaryMethods=*/false, CurContext,
6458 AddedProperties, Results);
6460 AddObjCProperties(CCContext,
6461 cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(),
6462 false, /*AllowNullaryMethods=*/false, CurContext,
6463 AddedProperties, Results);
6464 Results.ExitScope();
6466 HandleCodeCompleteResults(this, CodeCompleter,
6467 CodeCompletionContext::CCC_Other,
6468 Results.data(),Results.size());
6471 void Sema::CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
6472 IdentifierInfo *PropertyName) {
6473 typedef CodeCompletionResult Result;
6474 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6475 CodeCompleter->getCodeCompletionTUInfo(),
6476 CodeCompletionContext::CCC_Other);
6478 // Figure out where this @synthesize lives.
6479 ObjCContainerDecl *Container
6480 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6482 (!isa<ObjCImplementationDecl>(Container) &&
6483 !isa<ObjCCategoryImplDecl>(Container)))
6486 // Figure out which interface we're looking into.
6487 ObjCInterfaceDecl *Class = nullptr;
6488 if (ObjCImplementationDecl *ClassImpl
6489 = dyn_cast<ObjCImplementationDecl>(Container))
6490 Class = ClassImpl->getClassInterface();
6492 Class = cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl()
6493 ->getClassInterface();
6495 // Determine the type of the property we're synthesizing.
6496 QualType PropertyType = Context.getObjCIdType();
6498 if (ObjCPropertyDecl *Property = Class->FindPropertyDeclaration(
6499 PropertyName, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
6501 = Property->getType().getNonReferenceType().getUnqualifiedType();
6503 // Give preference to ivars
6504 Results.setPreferredType(PropertyType);
6508 // Add all of the instance variables in this class and its superclasses.
6509 Results.EnterNewScope();
6510 bool SawSimilarlyNamedIvar = false;
6511 std::string NameWithPrefix;
6512 NameWithPrefix += '_';
6513 NameWithPrefix += PropertyName->getName();
6514 std::string NameWithSuffix = PropertyName->getName().str();
6515 NameWithSuffix += '_';
6516 for(; Class; Class = Class->getSuperClass()) {
6517 for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar;
6518 Ivar = Ivar->getNextIvar()) {
6519 Results.AddResult(Result(Ivar, Results.getBasePriority(Ivar), nullptr),
6520 CurContext, nullptr, false);
6522 // Determine whether we've seen an ivar with a name similar to the
6524 if ((PropertyName == Ivar->getIdentifier() ||
6525 NameWithPrefix == Ivar->getName() ||
6526 NameWithSuffix == Ivar->getName())) {
6527 SawSimilarlyNamedIvar = true;
6529 // Reduce the priority of this result by one, to give it a slight
6530 // advantage over other results whose names don't match so closely.
6531 if (Results.size() &&
6532 Results.data()[Results.size() - 1].Kind
6533 == CodeCompletionResult::RK_Declaration &&
6534 Results.data()[Results.size() - 1].Declaration == Ivar)
6535 Results.data()[Results.size() - 1].Priority--;
6540 if (!SawSimilarlyNamedIvar) {
6541 // Create ivar result _propName, that the user can use to synthesize
6542 // an ivar of the appropriate type.
6543 unsigned Priority = CCP_MemberDeclaration + 1;
6544 typedef CodeCompletionResult Result;
6545 CodeCompletionAllocator &Allocator = Results.getAllocator();
6546 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo(),
6547 Priority,CXAvailability_Available);
6549 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
6550 Builder.AddResultTypeChunk(GetCompletionTypeString(PropertyType, Context,
6551 Policy, Allocator));
6552 Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix));
6553 Results.AddResult(Result(Builder.TakeString(), Priority,
6554 CXCursor_ObjCIvarDecl));
6557 Results.ExitScope();
6559 HandleCodeCompleteResults(this, CodeCompleter,
6560 CodeCompletionContext::CCC_Other,
6561 Results.data(),Results.size());
6564 // Mapping from selectors to the methods that implement that selector, along
6565 // with the "in original class" flag.
6566 typedef llvm::DenseMap<
6567 Selector, llvm::PointerIntPair<ObjCMethodDecl *, 1, bool> > KnownMethodsMap;
6569 /// \brief Find all of the methods that reside in the given container
6570 /// (and its superclasses, protocols, etc.) that meet the given
6571 /// criteria. Insert those methods into the map of known methods,
6572 /// indexed by selector so they can be easily found.
6573 static void FindImplementableMethods(ASTContext &Context,
6574 ObjCContainerDecl *Container,
6575 bool WantInstanceMethods,
6576 QualType ReturnType,
6577 KnownMethodsMap &KnownMethods,
6578 bool InOriginalClass = true) {
6579 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) {
6580 // Make sure we have a definition; that's what we'll walk.
6581 if (!IFace->hasDefinition())
6584 IFace = IFace->getDefinition();
6587 const ObjCList<ObjCProtocolDecl> &Protocols
6588 = IFace->getReferencedProtocols();
6589 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6590 E = Protocols.end();
6592 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6593 KnownMethods, InOriginalClass);
6595 // Add methods from any class extensions and categories.
6596 for (auto *Cat : IFace->visible_categories()) {
6597 FindImplementableMethods(Context, Cat, WantInstanceMethods, ReturnType,
6598 KnownMethods, false);
6601 // Visit the superclass.
6602 if (IFace->getSuperClass())
6603 FindImplementableMethods(Context, IFace->getSuperClass(),
6604 WantInstanceMethods, ReturnType,
6605 KnownMethods, false);
6608 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
6609 // Recurse into protocols.
6610 const ObjCList<ObjCProtocolDecl> &Protocols
6611 = Category->getReferencedProtocols();
6612 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6613 E = Protocols.end();
6615 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6616 KnownMethods, InOriginalClass);
6618 // If this category is the original class, jump to the interface.
6619 if (InOriginalClass && Category->getClassInterface())
6620 FindImplementableMethods(Context, Category->getClassInterface(),
6621 WantInstanceMethods, ReturnType, KnownMethods,
6625 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
6626 // Make sure we have a definition; that's what we'll walk.
6627 if (!Protocol->hasDefinition())
6629 Protocol = Protocol->getDefinition();
6630 Container = Protocol;
6632 // Recurse into protocols.
6633 const ObjCList<ObjCProtocolDecl> &Protocols
6634 = Protocol->getReferencedProtocols();
6635 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6636 E = Protocols.end();
6638 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6639 KnownMethods, false);
6642 // Add methods in this container. This operation occurs last because
6643 // we want the methods from this container to override any methods
6644 // we've previously seen with the same selector.
6645 for (auto *M : Container->methods()) {
6646 if (M->isInstanceMethod() == WantInstanceMethods) {
6647 if (!ReturnType.isNull() &&
6648 !Context.hasSameUnqualifiedType(ReturnType, M->getReturnType()))
6651 KnownMethods[M->getSelector()] =
6652 KnownMethodsMap::mapped_type(M, InOriginalClass);
6657 /// \brief Add the parenthesized return or parameter type chunk to a code
6658 /// completion string.
6659 static void AddObjCPassingTypeChunk(QualType Type,
6660 unsigned ObjCDeclQuals,
6661 ASTContext &Context,
6662 const PrintingPolicy &Policy,
6663 CodeCompletionBuilder &Builder) {
6664 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6665 std::string Quals = formatObjCParamQualifiers(ObjCDeclQuals, Type);
6667 Builder.AddTextChunk(Builder.getAllocator().CopyString(Quals));
6668 Builder.AddTextChunk(GetCompletionTypeString(Type, Context, Policy,
6669 Builder.getAllocator()));
6670 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6673 /// \brief Determine whether the given class is or inherits from a class by
6675 static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class,
6680 if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name)
6683 return InheritsFromClassNamed(Class->getSuperClass(), Name);
6686 /// \brief Add code completions for Objective-C Key-Value Coding (KVC) and
6687 /// Key-Value Observing (KVO).
6688 static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property,
6689 bool IsInstanceMethod,
6690 QualType ReturnType,
6691 ASTContext &Context,
6692 VisitedSelectorSet &KnownSelectors,
6693 ResultBuilder &Results) {
6694 IdentifierInfo *PropName = Property->getIdentifier();
6695 if (!PropName || PropName->getLength() == 0)
6698 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
6700 // Builder that will create each code completion.
6701 typedef CodeCompletionResult Result;
6702 CodeCompletionAllocator &Allocator = Results.getAllocator();
6703 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
6705 // The selector table.
6706 SelectorTable &Selectors = Context.Selectors;
6708 // The property name, copied into the code completion allocation region
6711 CodeCompletionAllocator &Allocator;
6713 const char *CopiedKey;
6715 KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key)
6716 : Allocator(Allocator), Key(Key), CopiedKey(nullptr) {}
6718 operator const char *() {
6722 return CopiedKey = Allocator.CopyString(Key);
6724 } Key(Allocator, PropName->getName());
6726 // The uppercased name of the property name.
6727 std::string UpperKey = PropName->getName();
6728 if (!UpperKey.empty())
6729 UpperKey[0] = toUppercase(UpperKey[0]);
6731 bool ReturnTypeMatchesProperty = ReturnType.isNull() ||
6732 Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(),
6733 Property->getType());
6734 bool ReturnTypeMatchesVoid
6735 = ReturnType.isNull() || ReturnType->isVoidType();
6737 // Add the normal accessor -(type)key.
6738 if (IsInstanceMethod &&
6739 KnownSelectors.insert(Selectors.getNullarySelector(PropName)).second &&
6740 ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) {
6741 if (ReturnType.isNull())
6742 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6743 Context, Policy, Builder);
6745 Builder.AddTypedTextChunk(Key);
6746 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6747 CXCursor_ObjCInstanceMethodDecl));
6750 // If we have an integral or boolean property (or the user has provided
6751 // an integral or boolean return type), add the accessor -(type)isKey.
6752 if (IsInstanceMethod &&
6753 ((!ReturnType.isNull() &&
6754 (ReturnType->isIntegerType() || ReturnType->isBooleanType())) ||
6755 (ReturnType.isNull() &&
6756 (Property->getType()->isIntegerType() ||
6757 Property->getType()->isBooleanType())))) {
6758 std::string SelectorName = (Twine("is") + UpperKey).str();
6759 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6760 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6762 if (ReturnType.isNull()) {
6763 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6764 Builder.AddTextChunk("BOOL");
6765 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6768 Builder.AddTypedTextChunk(
6769 Allocator.CopyString(SelectorId->getName()));
6770 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6771 CXCursor_ObjCInstanceMethodDecl));
6775 // Add the normal mutator.
6776 if (IsInstanceMethod && ReturnTypeMatchesVoid &&
6777 !Property->getSetterMethodDecl()) {
6778 std::string SelectorName = (Twine("set") + UpperKey).str();
6779 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6780 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6781 if (ReturnType.isNull()) {
6782 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6783 Builder.AddTextChunk("void");
6784 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6787 Builder.AddTypedTextChunk(
6788 Allocator.CopyString(SelectorId->getName()));
6789 Builder.AddTypedTextChunk(":");
6790 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6791 Context, Policy, Builder);
6792 Builder.AddTextChunk(Key);
6793 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6794 CXCursor_ObjCInstanceMethodDecl));
6798 // Indexed and unordered accessors
6799 unsigned IndexedGetterPriority = CCP_CodePattern;
6800 unsigned IndexedSetterPriority = CCP_CodePattern;
6801 unsigned UnorderedGetterPriority = CCP_CodePattern;
6802 unsigned UnorderedSetterPriority = CCP_CodePattern;
6803 if (const ObjCObjectPointerType *ObjCPointer
6804 = Property->getType()->getAs<ObjCObjectPointerType>()) {
6805 if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) {
6806 // If this interface type is not provably derived from a known
6807 // collection, penalize the corresponding completions.
6808 if (!InheritsFromClassNamed(IFace, "NSMutableArray")) {
6809 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6810 if (!InheritsFromClassNamed(IFace, "NSArray"))
6811 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6814 if (!InheritsFromClassNamed(IFace, "NSMutableSet")) {
6815 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6816 if (!InheritsFromClassNamed(IFace, "NSSet"))
6817 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6821 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6822 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6823 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6824 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6827 // Add -(NSUInteger)countOf<key>
6828 if (IsInstanceMethod &&
6829 (ReturnType.isNull() || ReturnType->isIntegerType())) {
6830 std::string SelectorName = (Twine("countOf") + UpperKey).str();
6831 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6832 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6834 if (ReturnType.isNull()) {
6835 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6836 Builder.AddTextChunk("NSUInteger");
6837 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6840 Builder.AddTypedTextChunk(
6841 Allocator.CopyString(SelectorId->getName()));
6842 Results.AddResult(Result(Builder.TakeString(),
6843 std::min(IndexedGetterPriority,
6844 UnorderedGetterPriority),
6845 CXCursor_ObjCInstanceMethodDecl));
6850 // Add -(id)objectInKeyAtIndex:(NSUInteger)index
6851 if (IsInstanceMethod &&
6852 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
6853 std::string SelectorName
6854 = (Twine("objectIn") + UpperKey + "AtIndex").str();
6855 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6856 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6857 if (ReturnType.isNull()) {
6858 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6859 Builder.AddTextChunk("id");
6860 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6863 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6864 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6865 Builder.AddTextChunk("NSUInteger");
6866 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6867 Builder.AddTextChunk("index");
6868 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6869 CXCursor_ObjCInstanceMethodDecl));
6873 // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes
6874 if (IsInstanceMethod &&
6875 (ReturnType.isNull() ||
6876 (ReturnType->isObjCObjectPointerType() &&
6877 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6878 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6879 ->getName() == "NSArray"))) {
6880 std::string SelectorName
6881 = (Twine(Property->getName()) + "AtIndexes").str();
6882 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6883 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6884 if (ReturnType.isNull()) {
6885 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6886 Builder.AddTextChunk("NSArray *");
6887 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6890 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6891 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6892 Builder.AddTextChunk("NSIndexSet *");
6893 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6894 Builder.AddTextChunk("indexes");
6895 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6896 CXCursor_ObjCInstanceMethodDecl));
6900 // Add -(void)getKey:(type **)buffer range:(NSRange)inRange
6901 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6902 std::string SelectorName = (Twine("get") + UpperKey).str();
6903 IdentifierInfo *SelectorIds[2] = {
6904 &Context.Idents.get(SelectorName),
6905 &Context.Idents.get("range")
6908 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6909 if (ReturnType.isNull()) {
6910 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6911 Builder.AddTextChunk("void");
6912 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6915 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6916 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6917 Builder.AddPlaceholderChunk("object-type");
6918 Builder.AddTextChunk(" **");
6919 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6920 Builder.AddTextChunk("buffer");
6921 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6922 Builder.AddTypedTextChunk("range:");
6923 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6924 Builder.AddTextChunk("NSRange");
6925 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6926 Builder.AddTextChunk("inRange");
6927 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6928 CXCursor_ObjCInstanceMethodDecl));
6932 // Mutable indexed accessors
6934 // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index
6935 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6936 std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str();
6937 IdentifierInfo *SelectorIds[2] = {
6938 &Context.Idents.get("insertObject"),
6939 &Context.Idents.get(SelectorName)
6942 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6943 if (ReturnType.isNull()) {
6944 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6945 Builder.AddTextChunk("void");
6946 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6949 Builder.AddTypedTextChunk("insertObject:");
6950 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6951 Builder.AddPlaceholderChunk("object-type");
6952 Builder.AddTextChunk(" *");
6953 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6954 Builder.AddTextChunk("object");
6955 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6956 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6957 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6958 Builder.AddPlaceholderChunk("NSUInteger");
6959 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6960 Builder.AddTextChunk("index");
6961 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6962 CXCursor_ObjCInstanceMethodDecl));
6966 // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes
6967 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6968 std::string SelectorName = (Twine("insert") + UpperKey).str();
6969 IdentifierInfo *SelectorIds[2] = {
6970 &Context.Idents.get(SelectorName),
6971 &Context.Idents.get("atIndexes")
6974 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6975 if (ReturnType.isNull()) {
6976 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6977 Builder.AddTextChunk("void");
6978 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6981 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6982 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6983 Builder.AddTextChunk("NSArray *");
6984 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6985 Builder.AddTextChunk("array");
6986 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6987 Builder.AddTypedTextChunk("atIndexes:");
6988 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6989 Builder.AddPlaceholderChunk("NSIndexSet *");
6990 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6991 Builder.AddTextChunk("indexes");
6992 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6993 CXCursor_ObjCInstanceMethodDecl));
6997 // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index
6998 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6999 std::string SelectorName
7000 = (Twine("removeObjectFrom") + UpperKey + "AtIndex").str();
7001 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7002 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7003 if (ReturnType.isNull()) {
7004 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7005 Builder.AddTextChunk("void");
7006 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7009 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7010 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7011 Builder.AddTextChunk("NSUInteger");
7012 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7013 Builder.AddTextChunk("index");
7014 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7015 CXCursor_ObjCInstanceMethodDecl));
7019 // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes
7020 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7021 std::string SelectorName
7022 = (Twine("remove") + UpperKey + "AtIndexes").str();
7023 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7024 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7025 if (ReturnType.isNull()) {
7026 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7027 Builder.AddTextChunk("void");
7028 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7031 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7032 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7033 Builder.AddTextChunk("NSIndexSet *");
7034 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7035 Builder.AddTextChunk("indexes");
7036 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7037 CXCursor_ObjCInstanceMethodDecl));
7041 // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object
7042 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7043 std::string SelectorName
7044 = (Twine("replaceObjectIn") + UpperKey + "AtIndex").str();
7045 IdentifierInfo *SelectorIds[2] = {
7046 &Context.Idents.get(SelectorName),
7047 &Context.Idents.get("withObject")
7050 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7051 if (ReturnType.isNull()) {
7052 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7053 Builder.AddTextChunk("void");
7054 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7057 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7058 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7059 Builder.AddPlaceholderChunk("NSUInteger");
7060 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7061 Builder.AddTextChunk("index");
7062 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7063 Builder.AddTypedTextChunk("withObject:");
7064 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7065 Builder.AddTextChunk("id");
7066 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7067 Builder.AddTextChunk("object");
7068 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7069 CXCursor_ObjCInstanceMethodDecl));
7073 // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array
7074 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7075 std::string SelectorName1
7076 = (Twine("replace") + UpperKey + "AtIndexes").str();
7077 std::string SelectorName2 = (Twine("with") + UpperKey).str();
7078 IdentifierInfo *SelectorIds[2] = {
7079 &Context.Idents.get(SelectorName1),
7080 &Context.Idents.get(SelectorName2)
7083 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7084 if (ReturnType.isNull()) {
7085 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7086 Builder.AddTextChunk("void");
7087 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7090 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName1 + ":"));
7091 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7092 Builder.AddPlaceholderChunk("NSIndexSet *");
7093 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7094 Builder.AddTextChunk("indexes");
7095 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7096 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":"));
7097 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7098 Builder.AddTextChunk("NSArray *");
7099 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7100 Builder.AddTextChunk("array");
7101 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7102 CXCursor_ObjCInstanceMethodDecl));
7106 // Unordered getters
7107 // - (NSEnumerator *)enumeratorOfKey
7108 if (IsInstanceMethod &&
7109 (ReturnType.isNull() ||
7110 (ReturnType->isObjCObjectPointerType() &&
7111 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7112 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
7113 ->getName() == "NSEnumerator"))) {
7114 std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str();
7115 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7116 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7118 if (ReturnType.isNull()) {
7119 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7120 Builder.AddTextChunk("NSEnumerator *");
7121 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7124 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7125 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
7126 CXCursor_ObjCInstanceMethodDecl));
7130 // - (type *)memberOfKey:(type *)object
7131 if (IsInstanceMethod &&
7132 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
7133 std::string SelectorName = (Twine("memberOf") + UpperKey).str();
7134 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7135 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7136 if (ReturnType.isNull()) {
7137 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7138 Builder.AddPlaceholderChunk("object-type");
7139 Builder.AddTextChunk(" *");
7140 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7143 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7144 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7145 if (ReturnType.isNull()) {
7146 Builder.AddPlaceholderChunk("object-type");
7147 Builder.AddTextChunk(" *");
7149 Builder.AddTextChunk(GetCompletionTypeString(ReturnType, Context,
7151 Builder.getAllocator()));
7153 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7154 Builder.AddTextChunk("object");
7155 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
7156 CXCursor_ObjCInstanceMethodDecl));
7160 // Mutable unordered accessors
7161 // - (void)addKeyObject:(type *)object
7162 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7163 std::string SelectorName
7164 = (Twine("add") + UpperKey + Twine("Object")).str();
7165 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7166 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7167 if (ReturnType.isNull()) {
7168 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7169 Builder.AddTextChunk("void");
7170 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7173 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7174 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7175 Builder.AddPlaceholderChunk("object-type");
7176 Builder.AddTextChunk(" *");
7177 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7178 Builder.AddTextChunk("object");
7179 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7180 CXCursor_ObjCInstanceMethodDecl));
7184 // - (void)addKey:(NSSet *)objects
7185 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7186 std::string SelectorName = (Twine("add") + UpperKey).str();
7187 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7188 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7189 if (ReturnType.isNull()) {
7190 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7191 Builder.AddTextChunk("void");
7192 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7195 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7196 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7197 Builder.AddTextChunk("NSSet *");
7198 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7199 Builder.AddTextChunk("objects");
7200 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7201 CXCursor_ObjCInstanceMethodDecl));
7205 // - (void)removeKeyObject:(type *)object
7206 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7207 std::string SelectorName
7208 = (Twine("remove") + UpperKey + Twine("Object")).str();
7209 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7210 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7211 if (ReturnType.isNull()) {
7212 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7213 Builder.AddTextChunk("void");
7214 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7217 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7218 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7219 Builder.AddPlaceholderChunk("object-type");
7220 Builder.AddTextChunk(" *");
7221 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7222 Builder.AddTextChunk("object");
7223 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7224 CXCursor_ObjCInstanceMethodDecl));
7228 // - (void)removeKey:(NSSet *)objects
7229 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7230 std::string SelectorName = (Twine("remove") + UpperKey).str();
7231 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7232 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7233 if (ReturnType.isNull()) {
7234 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7235 Builder.AddTextChunk("void");
7236 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7239 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7240 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7241 Builder.AddTextChunk("NSSet *");
7242 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7243 Builder.AddTextChunk("objects");
7244 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7245 CXCursor_ObjCInstanceMethodDecl));
7249 // - (void)intersectKey:(NSSet *)objects
7250 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7251 std::string SelectorName = (Twine("intersect") + UpperKey).str();
7252 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7253 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7254 if (ReturnType.isNull()) {
7255 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7256 Builder.AddTextChunk("void");
7257 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7260 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7261 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7262 Builder.AddTextChunk("NSSet *");
7263 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7264 Builder.AddTextChunk("objects");
7265 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7266 CXCursor_ObjCInstanceMethodDecl));
7270 // Key-Value Observing
7271 // + (NSSet *)keyPathsForValuesAffectingKey
7272 if (!IsInstanceMethod &&
7273 (ReturnType.isNull() ||
7274 (ReturnType->isObjCObjectPointerType() &&
7275 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7276 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
7277 ->getName() == "NSSet"))) {
7278 std::string SelectorName
7279 = (Twine("keyPathsForValuesAffecting") + UpperKey).str();
7280 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7281 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7283 if (ReturnType.isNull()) {
7284 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7285 Builder.AddTextChunk("NSSet<NSString *> *");
7286 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7289 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7290 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7291 CXCursor_ObjCClassMethodDecl));
7295 // + (BOOL)automaticallyNotifiesObserversForKey
7296 if (!IsInstanceMethod &&
7297 (ReturnType.isNull() ||
7298 ReturnType->isIntegerType() ||
7299 ReturnType->isBooleanType())) {
7300 std::string SelectorName
7301 = (Twine("automaticallyNotifiesObserversOf") + UpperKey).str();
7302 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7303 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7305 if (ReturnType.isNull()) {
7306 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7307 Builder.AddTextChunk("BOOL");
7308 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7311 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7312 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7313 CXCursor_ObjCClassMethodDecl));
7318 void Sema::CodeCompleteObjCMethodDecl(Scope *S,
7319 bool IsInstanceMethod,
7320 ParsedType ReturnTy) {
7321 // Determine the return type of the method we're declaring, if
7323 QualType ReturnType = GetTypeFromParser(ReturnTy);
7324 Decl *IDecl = nullptr;
7325 if (CurContext->isObjCContainer()) {
7326 ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
7327 IDecl = cast<Decl>(OCD);
7329 // Determine where we should start searching for methods.
7330 ObjCContainerDecl *SearchDecl = nullptr;
7331 bool IsInImplementation = false;
7332 if (Decl *D = IDecl) {
7333 if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) {
7334 SearchDecl = Impl->getClassInterface();
7335 IsInImplementation = true;
7336 } else if (ObjCCategoryImplDecl *CatImpl
7337 = dyn_cast<ObjCCategoryImplDecl>(D)) {
7338 SearchDecl = CatImpl->getCategoryDecl();
7339 IsInImplementation = true;
7341 SearchDecl = dyn_cast<ObjCContainerDecl>(D);
7344 if (!SearchDecl && S) {
7345 if (DeclContext *DC = S->getEntity())
7346 SearchDecl = dyn_cast<ObjCContainerDecl>(DC);
7350 HandleCodeCompleteResults(this, CodeCompleter,
7351 CodeCompletionContext::CCC_Other,
7356 // Find all of the methods that we could declare/implement here.
7357 KnownMethodsMap KnownMethods;
7358 FindImplementableMethods(Context, SearchDecl, IsInstanceMethod,
7359 ReturnType, KnownMethods);
7361 // Add declarations or definitions for each of the known methods.
7362 typedef CodeCompletionResult Result;
7363 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7364 CodeCompleter->getCodeCompletionTUInfo(),
7365 CodeCompletionContext::CCC_Other);
7366 Results.EnterNewScope();
7367 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
7368 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7369 MEnd = KnownMethods.end();
7371 ObjCMethodDecl *Method = M->second.getPointer();
7372 CodeCompletionBuilder Builder(Results.getAllocator(),
7373 Results.getCodeCompletionTUInfo());
7375 // If the result type was not already provided, add it to the
7376 // pattern as (type).
7377 if (ReturnType.isNull()) {
7378 QualType ResTy = Method->getSendResultType().stripObjCKindOfType(Context);
7379 AttributedType::stripOuterNullability(ResTy);
7380 AddObjCPassingTypeChunk(ResTy,
7381 Method->getObjCDeclQualifier(), Context, Policy,
7385 Selector Sel = Method->getSelector();
7387 // Add the first part of the selector to the pattern.
7388 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7389 Sel.getNameForSlot(0)));
7391 // Add parameters to the pattern.
7393 for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
7394 PEnd = Method->param_end();
7395 P != PEnd; (void)++P, ++I) {
7396 // Add the part of the selector name.
7398 Builder.AddTypedTextChunk(":");
7399 else if (I < Sel.getNumArgs()) {
7400 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7401 Builder.AddTypedTextChunk(
7402 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
7406 // Add the parameter type.
7408 if ((*P)->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
7409 ParamType = (*P)->getType();
7411 ParamType = (*P)->getOriginalType();
7412 ParamType = ParamType.substObjCTypeArgs(Context, {},
7413 ObjCSubstitutionContext::Parameter);
7414 AttributedType::stripOuterNullability(ParamType);
7415 AddObjCPassingTypeChunk(ParamType,
7416 (*P)->getObjCDeclQualifier(),
7420 if (IdentifierInfo *Id = (*P)->getIdentifier())
7421 Builder.AddTextChunk(Builder.getAllocator().CopyString( Id->getName()));
7424 if (Method->isVariadic()) {
7425 if (Method->param_size() > 0)
7426 Builder.AddChunk(CodeCompletionString::CK_Comma);
7427 Builder.AddTextChunk("...");
7430 if (IsInImplementation && Results.includeCodePatterns()) {
7431 // We will be defining the method here, so add a compound statement.
7432 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7433 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
7434 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
7435 if (!Method->getReturnType()->isVoidType()) {
7436 // If the result type is not void, add a return clause.
7437 Builder.AddTextChunk("return");
7438 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7439 Builder.AddPlaceholderChunk("expression");
7440 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
7442 Builder.AddPlaceholderChunk("statements");
7444 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
7445 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
7448 unsigned Priority = CCP_CodePattern;
7449 if (!M->second.getInt())
7450 Priority += CCD_InBaseClass;
7452 Results.AddResult(Result(Builder.TakeString(), Method, Priority));
7455 // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of
7456 // the properties in this class and its categories.
7457 if (Context.getLangOpts().ObjC2) {
7458 SmallVector<ObjCContainerDecl *, 4> Containers;
7459 Containers.push_back(SearchDecl);
7461 VisitedSelectorSet KnownSelectors;
7462 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7463 MEnd = KnownMethods.end();
7465 KnownSelectors.insert(M->first);
7468 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl);
7470 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl))
7471 IFace = Category->getClassInterface();
7474 for (auto *Cat : IFace->visible_categories())
7475 Containers.push_back(Cat);
7477 for (unsigned I = 0, N = Containers.size(); I != N; ++I)
7478 for (auto *P : Containers[I]->instance_properties())
7479 AddObjCKeyValueCompletions(P, IsInstanceMethod, ReturnType, Context,
7480 KnownSelectors, Results);
7483 Results.ExitScope();
7485 HandleCodeCompleteResults(this, CodeCompleter,
7486 CodeCompletionContext::CCC_Other,
7487 Results.data(),Results.size());
7490 void Sema::CodeCompleteObjCMethodDeclSelector(Scope *S,
7491 bool IsInstanceMethod,
7492 bool AtParameterName,
7493 ParsedType ReturnTy,
7494 ArrayRef<IdentifierInfo *> SelIdents) {
7495 // If we have an external source, load the entire class method
7496 // pool from the AST file.
7497 if (ExternalSource) {
7498 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
7500 Selector Sel = ExternalSource->GetExternalSelector(I);
7501 if (Sel.isNull() || MethodPool.count(Sel))
7504 ReadMethodPool(Sel);
7508 // Build the set of methods we can see.
7509 typedef CodeCompletionResult Result;
7510 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7511 CodeCompleter->getCodeCompletionTUInfo(),
7512 CodeCompletionContext::CCC_Other);
7515 Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType());
7517 Results.EnterNewScope();
7518 for (GlobalMethodPool::iterator M = MethodPool.begin(),
7519 MEnd = MethodPool.end();
7521 for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first :
7523 MethList && MethList->getMethod();
7524 MethList = MethList->getNext()) {
7525 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
7528 if (AtParameterName) {
7529 // Suggest parameter names we've seen before.
7530 unsigned NumSelIdents = SelIdents.size();
7532 NumSelIdents <= MethList->getMethod()->param_size()) {
7533 ParmVarDecl *Param =
7534 MethList->getMethod()->parameters()[NumSelIdents - 1];
7535 if (Param->getIdentifier()) {
7536 CodeCompletionBuilder Builder(Results.getAllocator(),
7537 Results.getCodeCompletionTUInfo());
7538 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7539 Param->getIdentifier()->getName()));
7540 Results.AddResult(Builder.TakeString());
7547 Result R(MethList->getMethod(),
7548 Results.getBasePriority(MethList->getMethod()), nullptr);
7549 R.StartParameter = SelIdents.size();
7550 R.AllParametersAreInformative = false;
7551 R.DeclaringEntity = true;
7552 Results.MaybeAddResult(R, CurContext);
7556 Results.ExitScope();
7558 if (!AtParameterName && !SelIdents.empty() &&
7559 SelIdents.front()->getName().startswith("init")) {
7560 for (const auto &M : PP.macros()) {
7561 if (M.first->getName() != "NS_DESIGNATED_INITIALIZER")
7563 Results.EnterNewScope();
7564 CodeCompletionBuilder Builder(Results.getAllocator(),
7565 Results.getCodeCompletionTUInfo());
7566 Builder.AddTypedTextChunk(
7567 Builder.getAllocator().CopyString(M.first->getName()));
7568 Results.AddResult(CodeCompletionResult(Builder.TakeString(), CCP_Macro,
7569 CXCursor_MacroDefinition));
7570 Results.ExitScope();
7574 HandleCodeCompleteResults(this, CodeCompleter,
7575 CodeCompletionContext::CCC_Other,
7576 Results.data(),Results.size());
7579 void Sema::CodeCompletePreprocessorDirective(bool InConditional) {
7580 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7581 CodeCompleter->getCodeCompletionTUInfo(),
7582 CodeCompletionContext::CCC_PreprocessorDirective);
7583 Results.EnterNewScope();
7586 CodeCompletionBuilder Builder(Results.getAllocator(),
7587 Results.getCodeCompletionTUInfo());
7588 Builder.AddTypedTextChunk("if");
7589 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7590 Builder.AddPlaceholderChunk("condition");
7591 Results.AddResult(Builder.TakeString());
7594 Builder.AddTypedTextChunk("ifdef");
7595 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7596 Builder.AddPlaceholderChunk("macro");
7597 Results.AddResult(Builder.TakeString());
7600 Builder.AddTypedTextChunk("ifndef");
7601 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7602 Builder.AddPlaceholderChunk("macro");
7603 Results.AddResult(Builder.TakeString());
7605 if (InConditional) {
7606 // #elif <condition>
7607 Builder.AddTypedTextChunk("elif");
7608 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7609 Builder.AddPlaceholderChunk("condition");
7610 Results.AddResult(Builder.TakeString());
7613 Builder.AddTypedTextChunk("else");
7614 Results.AddResult(Builder.TakeString());
7617 Builder.AddTypedTextChunk("endif");
7618 Results.AddResult(Builder.TakeString());
7621 // #include "header"
7622 Builder.AddTypedTextChunk("include");
7623 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7624 Builder.AddTextChunk("\"");
7625 Builder.AddPlaceholderChunk("header");
7626 Builder.AddTextChunk("\"");
7627 Results.AddResult(Builder.TakeString());
7629 // #include <header>
7630 Builder.AddTypedTextChunk("include");
7631 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7632 Builder.AddTextChunk("<");
7633 Builder.AddPlaceholderChunk("header");
7634 Builder.AddTextChunk(">");
7635 Results.AddResult(Builder.TakeString());
7638 Builder.AddTypedTextChunk("define");
7639 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7640 Builder.AddPlaceholderChunk("macro");
7641 Results.AddResult(Builder.TakeString());
7643 // #define <macro>(<args>)
7644 Builder.AddTypedTextChunk("define");
7645 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7646 Builder.AddPlaceholderChunk("macro");
7647 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7648 Builder.AddPlaceholderChunk("args");
7649 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7650 Results.AddResult(Builder.TakeString());
7653 Builder.AddTypedTextChunk("undef");
7654 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7655 Builder.AddPlaceholderChunk("macro");
7656 Results.AddResult(Builder.TakeString());
7659 Builder.AddTypedTextChunk("line");
7660 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7661 Builder.AddPlaceholderChunk("number");
7662 Results.AddResult(Builder.TakeString());
7664 // #line <number> "filename"
7665 Builder.AddTypedTextChunk("line");
7666 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7667 Builder.AddPlaceholderChunk("number");
7668 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7669 Builder.AddTextChunk("\"");
7670 Builder.AddPlaceholderChunk("filename");
7671 Builder.AddTextChunk("\"");
7672 Results.AddResult(Builder.TakeString());
7675 Builder.AddTypedTextChunk("error");
7676 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7677 Builder.AddPlaceholderChunk("message");
7678 Results.AddResult(Builder.TakeString());
7680 // #pragma <arguments>
7681 Builder.AddTypedTextChunk("pragma");
7682 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7683 Builder.AddPlaceholderChunk("arguments");
7684 Results.AddResult(Builder.TakeString());
7686 if (getLangOpts().ObjC1) {
7688 Builder.AddTypedTextChunk("import");
7689 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7690 Builder.AddTextChunk("\"");
7691 Builder.AddPlaceholderChunk("header");
7692 Builder.AddTextChunk("\"");
7693 Results.AddResult(Builder.TakeString());
7696 Builder.AddTypedTextChunk("import");
7697 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7698 Builder.AddTextChunk("<");
7699 Builder.AddPlaceholderChunk("header");
7700 Builder.AddTextChunk(">");
7701 Results.AddResult(Builder.TakeString());
7704 // #include_next "header"
7705 Builder.AddTypedTextChunk("include_next");
7706 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7707 Builder.AddTextChunk("\"");
7708 Builder.AddPlaceholderChunk("header");
7709 Builder.AddTextChunk("\"");
7710 Results.AddResult(Builder.TakeString());
7712 // #include_next <header>
7713 Builder.AddTypedTextChunk("include_next");
7714 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7715 Builder.AddTextChunk("<");
7716 Builder.AddPlaceholderChunk("header");
7717 Builder.AddTextChunk(">");
7718 Results.AddResult(Builder.TakeString());
7720 // #warning <message>
7721 Builder.AddTypedTextChunk("warning");
7722 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7723 Builder.AddPlaceholderChunk("message");
7724 Results.AddResult(Builder.TakeString());
7726 // Note: #ident and #sccs are such crazy anachronisms that we don't provide
7727 // completions for them. And __include_macros is a Clang-internal extension
7728 // that we don't want to encourage anyone to use.
7730 // FIXME: we don't support #assert or #unassert, so don't suggest them.
7731 Results.ExitScope();
7733 HandleCodeCompleteResults(this, CodeCompleter,
7734 CodeCompletionContext::CCC_PreprocessorDirective,
7735 Results.data(), Results.size());
7738 void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) {
7739 CodeCompleteOrdinaryName(S,
7740 S->getFnParent()? Sema::PCC_RecoveryInFunction
7741 : Sema::PCC_Namespace);
7744 void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) {
7745 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7746 CodeCompleter->getCodeCompletionTUInfo(),
7747 IsDefinition? CodeCompletionContext::CCC_MacroName
7748 : CodeCompletionContext::CCC_MacroNameUse);
7749 if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) {
7750 // Add just the names of macros, not their arguments.
7751 CodeCompletionBuilder Builder(Results.getAllocator(),
7752 Results.getCodeCompletionTUInfo());
7753 Results.EnterNewScope();
7754 for (Preprocessor::macro_iterator M = PP.macro_begin(),
7755 MEnd = PP.macro_end();
7757 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7758 M->first->getName()));
7759 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
7761 CXCursor_MacroDefinition));
7763 Results.ExitScope();
7764 } else if (IsDefinition) {
7765 // FIXME: Can we detect when the user just wrote an include guard above?
7768 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7769 Results.data(), Results.size());
7772 void Sema::CodeCompletePreprocessorExpression() {
7773 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7774 CodeCompleter->getCodeCompletionTUInfo(),
7775 CodeCompletionContext::CCC_PreprocessorExpression);
7777 if (!CodeCompleter || CodeCompleter->includeMacros())
7778 AddMacroResults(PP, Results, true);
7780 // defined (<macro>)
7781 Results.EnterNewScope();
7782 CodeCompletionBuilder Builder(Results.getAllocator(),
7783 Results.getCodeCompletionTUInfo());
7784 Builder.AddTypedTextChunk("defined");
7785 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7786 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7787 Builder.AddPlaceholderChunk("macro");
7788 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7789 Results.AddResult(Builder.TakeString());
7790 Results.ExitScope();
7792 HandleCodeCompleteResults(this, CodeCompleter,
7793 CodeCompletionContext::CCC_PreprocessorExpression,
7794 Results.data(), Results.size());
7797 void Sema::CodeCompletePreprocessorMacroArgument(Scope *S,
7798 IdentifierInfo *Macro,
7799 MacroInfo *MacroInfo,
7800 unsigned Argument) {
7801 // FIXME: In the future, we could provide "overload" results, much like we
7802 // do for function calls.
7804 // Now just ignore this. There will be another code-completion callback
7805 // for the expanded tokens.
7808 void Sema::CodeCompleteNaturalLanguage() {
7809 HandleCodeCompleteResults(this, CodeCompleter,
7810 CodeCompletionContext::CCC_NaturalLanguage,
7814 void Sema::GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,
7815 CodeCompletionTUInfo &CCTUInfo,
7816 SmallVectorImpl<CodeCompletionResult> &Results) {
7817 ResultBuilder Builder(*this, Allocator, CCTUInfo,
7818 CodeCompletionContext::CCC_Recovery);
7819 if (!CodeCompleter || CodeCompleter->includeGlobals()) {
7820 CodeCompletionDeclConsumer Consumer(Builder,
7821 Context.getTranslationUnitDecl());
7822 LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName,
7826 if (!CodeCompleter || CodeCompleter->includeMacros())
7827 AddMacroResults(PP, Builder, true);
7830 Results.insert(Results.end(),
7831 Builder.data(), Builder.data() + Builder.size());