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 static void AddRecordMembersCompletionResults(Sema &SemaRef,
3873 ResultBuilder &Results, Scope *S,
3876 // Indicate that we are performing a member access, and the cv-qualifiers
3877 // for the base object type.
3878 Results.setObjectTypeQualifiers(BaseType.getQualifiers());
3880 // Access to a C/C++ class, struct, or union.
3881 Results.allowNestedNameSpecifiers();
3882 CodeCompletionDeclConsumer Consumer(Results, SemaRef.CurContext);
3883 SemaRef.LookupVisibleDecls(RD, Sema::LookupMemberName, Consumer,
3884 SemaRef.CodeCompleter->includeGlobals(),
3885 /*IncludeDependentBases=*/true);
3887 if (SemaRef.getLangOpts().CPlusPlus) {
3888 if (!Results.empty()) {
3889 // The "template" keyword can follow "->" or "." in the grammar.
3890 // However, we only want to suggest the template keyword if something
3892 bool IsDependent = BaseType->isDependentType();
3894 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent())
3895 if (DeclContext *Ctx = DepScope->getEntity()) {
3896 IsDependent = Ctx->isDependentContext();
3902 Results.AddResult(CodeCompletionResult("template"));
3907 void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
3908 SourceLocation OpLoc, bool IsArrow,
3909 bool IsBaseExprStatement) {
3910 if (!Base || !CodeCompleter)
3913 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
3914 if (ConvertedBase.isInvalid())
3916 Base = ConvertedBase.get();
3918 QualType BaseType = Base->getType();
3921 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
3922 BaseType = Ptr->getPointeeType();
3923 else if (BaseType->isObjCObjectPointerType())
3929 enum CodeCompletionContext::Kind contextKind;
3932 contextKind = CodeCompletionContext::CCC_ArrowMemberAccess;
3935 if (BaseType->isObjCObjectPointerType() ||
3936 BaseType->isObjCObjectOrInterfaceType()) {
3937 contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess;
3940 contextKind = CodeCompletionContext::CCC_DotMemberAccess;
3944 CodeCompletionContext CCContext(contextKind, BaseType);
3945 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3946 CodeCompleter->getCodeCompletionTUInfo(),
3948 &ResultBuilder::IsMember);
3949 Results.EnterNewScope();
3950 if (const RecordType *Record = BaseType->getAs<RecordType>()) {
3951 AddRecordMembersCompletionResults(*this, Results, S, BaseType,
3953 } else if (const auto *TST = BaseType->getAs<TemplateSpecializationType>()) {
3954 TemplateName TN = TST->getTemplateName();
3955 if (const auto *TD =
3956 dyn_cast_or_null<ClassTemplateDecl>(TN.getAsTemplateDecl())) {
3957 CXXRecordDecl *RD = TD->getTemplatedDecl();
3958 AddRecordMembersCompletionResults(*this, Results, S, BaseType, RD);
3960 } else if (const auto *ICNT = BaseType->getAs<InjectedClassNameType>()) {
3961 if (auto *RD = ICNT->getDecl())
3962 AddRecordMembersCompletionResults(*this, Results, S, BaseType, RD);
3963 } else if (!IsArrow && BaseType->isObjCObjectPointerType()) {
3964 // Objective-C property reference.
3965 AddedPropertiesSet AddedProperties;
3967 if (const ObjCObjectPointerType *ObjCPtr =
3968 BaseType->getAsObjCInterfacePointerType()) {
3969 // Add property results based on our interface.
3970 assert(ObjCPtr && "Non-NULL pointer guaranteed above!");
3971 AddObjCProperties(CCContext, ObjCPtr->getInterfaceDecl(), true,
3972 /*AllowNullaryMethods=*/true, CurContext,
3973 AddedProperties, Results, IsBaseExprStatement);
3976 // Add properties from the protocols in a qualified interface.
3977 for (auto *I : BaseType->getAs<ObjCObjectPointerType>()->quals())
3978 AddObjCProperties(CCContext, I, true, /*AllowNullaryMethods=*/true,
3979 CurContext, AddedProperties, Results,
3980 IsBaseExprStatement);
3981 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) ||
3982 (!IsArrow && BaseType->isObjCObjectType())) {
3983 // Objective-C instance variable access.
3984 ObjCInterfaceDecl *Class = nullptr;
3985 if (const ObjCObjectPointerType *ObjCPtr
3986 = BaseType->getAs<ObjCObjectPointerType>())
3987 Class = ObjCPtr->getInterfaceDecl();
3989 Class = BaseType->getAs<ObjCObjectType>()->getInterface();
3991 // Add all ivars from this class and its superclasses.
3993 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3994 Results.setFilter(&ResultBuilder::IsObjCIvar);
3995 LookupVisibleDecls(Class, LookupMemberName, Consumer,
3996 CodeCompleter->includeGlobals());
4000 // FIXME: How do we cope with isa?
4002 Results.ExitScope();
4004 // Hand off the results found for code completion.
4005 HandleCodeCompleteResults(this, CodeCompleter,
4006 Results.getCompletionContext(),
4007 Results.data(),Results.size());
4010 void Sema::CodeCompleteObjCClassPropertyRefExpr(Scope *S,
4011 IdentifierInfo &ClassName,
4012 SourceLocation ClassNameLoc,
4013 bool IsBaseExprStatement) {
4014 IdentifierInfo *ClassNamePtr = &ClassName;
4015 ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(ClassNamePtr, ClassNameLoc);
4018 CodeCompletionContext CCContext(
4019 CodeCompletionContext::CCC_ObjCPropertyAccess);
4020 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4021 CodeCompleter->getCodeCompletionTUInfo(), CCContext,
4022 &ResultBuilder::IsMember);
4023 Results.EnterNewScope();
4024 AddedPropertiesSet AddedProperties;
4025 AddObjCProperties(CCContext, IFace, true,
4026 /*AllowNullaryMethods=*/true, CurContext, AddedProperties,
4027 Results, IsBaseExprStatement,
4028 /*IsClassProperty=*/true);
4029 Results.ExitScope();
4030 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4031 Results.data(), Results.size());
4034 void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) {
4038 ResultBuilder::LookupFilter Filter = nullptr;
4039 enum CodeCompletionContext::Kind ContextKind
4040 = CodeCompletionContext::CCC_Other;
4041 switch ((DeclSpec::TST)TagSpec) {
4042 case DeclSpec::TST_enum:
4043 Filter = &ResultBuilder::IsEnum;
4044 ContextKind = CodeCompletionContext::CCC_EnumTag;
4047 case DeclSpec::TST_union:
4048 Filter = &ResultBuilder::IsUnion;
4049 ContextKind = CodeCompletionContext::CCC_UnionTag;
4052 case DeclSpec::TST_struct:
4053 case DeclSpec::TST_class:
4054 case DeclSpec::TST_interface:
4055 Filter = &ResultBuilder::IsClassOrStruct;
4056 ContextKind = CodeCompletionContext::CCC_ClassOrStructTag;
4060 llvm_unreachable("Unknown type specifier kind in CodeCompleteTag");
4063 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4064 CodeCompleter->getCodeCompletionTUInfo(), ContextKind);
4065 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4067 // First pass: look for tags.
4068 Results.setFilter(Filter);
4069 LookupVisibleDecls(S, LookupTagName, Consumer,
4070 CodeCompleter->includeGlobals());
4072 if (CodeCompleter->includeGlobals()) {
4073 // Second pass: look for nested name specifiers.
4074 Results.setFilter(&ResultBuilder::IsNestedNameSpecifier);
4075 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer);
4078 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4079 Results.data(),Results.size());
4082 static void AddTypeQualifierResults(DeclSpec &DS, ResultBuilder &Results,
4083 const LangOptions &LangOpts) {
4084 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
4085 Results.AddResult("const");
4086 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile))
4087 Results.AddResult("volatile");
4088 if (LangOpts.C99 && !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict))
4089 Results.AddResult("restrict");
4090 if (LangOpts.C11 && !(DS.getTypeQualifiers() & DeclSpec::TQ_atomic))
4091 Results.AddResult("_Atomic");
4092 if (LangOpts.MSVCCompat && !(DS.getTypeQualifiers() & DeclSpec::TQ_unaligned))
4093 Results.AddResult("__unaligned");
4096 void Sema::CodeCompleteTypeQualifiers(DeclSpec &DS) {
4097 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4098 CodeCompleter->getCodeCompletionTUInfo(),
4099 CodeCompletionContext::CCC_TypeQualifiers);
4100 Results.EnterNewScope();
4101 AddTypeQualifierResults(DS, Results, LangOpts);
4102 Results.ExitScope();
4103 HandleCodeCompleteResults(this, CodeCompleter,
4104 Results.getCompletionContext(),
4105 Results.data(), Results.size());
4108 void Sema::CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D,
4109 const VirtSpecifiers *VS) {
4110 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4111 CodeCompleter->getCodeCompletionTUInfo(),
4112 CodeCompletionContext::CCC_TypeQualifiers);
4113 Results.EnterNewScope();
4114 AddTypeQualifierResults(DS, Results, LangOpts);
4115 if (LangOpts.CPlusPlus11) {
4116 Results.AddResult("noexcept");
4117 if (D.getContext() == Declarator::MemberContext && !D.isCtorOrDtor() &&
4118 !D.isStaticMember()) {
4119 if (!VS || !VS->isFinalSpecified())
4120 Results.AddResult("final");
4121 if (!VS || !VS->isOverrideSpecified())
4122 Results.AddResult("override");
4125 Results.ExitScope();
4126 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4127 Results.data(), Results.size());
4130 void Sema::CodeCompleteBracketDeclarator(Scope *S) {
4131 CodeCompleteExpression(S, QualType(getASTContext().getSizeType()));
4134 void Sema::CodeCompleteCase(Scope *S) {
4135 if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
4138 SwitchStmt *Switch = getCurFunction()->SwitchStack.back();
4139 QualType type = Switch->getCond()->IgnoreImplicit()->getType();
4140 if (!type->isEnumeralType()) {
4141 CodeCompleteExpressionData Data(type);
4142 Data.IntegralConstantExpression = true;
4143 CodeCompleteExpression(S, Data);
4147 // Code-complete the cases of a switch statement over an enumeration type
4148 // by providing the list of
4149 EnumDecl *Enum = type->castAs<EnumType>()->getDecl();
4150 if (EnumDecl *Def = Enum->getDefinition())
4153 // Determine which enumerators we have already seen in the switch statement.
4154 // FIXME: Ideally, we would also be able to look *past* the code-completion
4155 // token, in case we are code-completing in the middle of the switch and not
4156 // at the end. However, we aren't able to do so at the moment.
4157 llvm::SmallPtrSet<EnumConstantDecl *, 8> EnumeratorsSeen;
4158 NestedNameSpecifier *Qualifier = nullptr;
4159 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC;
4160 SC = SC->getNextSwitchCase()) {
4161 CaseStmt *Case = dyn_cast<CaseStmt>(SC);
4165 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
4166 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CaseVal))
4167 if (EnumConstantDecl *Enumerator
4168 = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
4169 // We look into the AST of the case statement to determine which
4170 // enumerator was named. Alternatively, we could compute the value of
4171 // the integral constant expression, then compare it against the
4172 // values of each enumerator. However, value-based approach would not
4173 // work as well with C++ templates where enumerators declared within a
4174 // template are type- and value-dependent.
4175 EnumeratorsSeen.insert(Enumerator);
4177 // If this is a qualified-id, keep track of the nested-name-specifier
4178 // so that we can reproduce it as part of code completion, e.g.,
4180 // switch (TagD.getKind()) {
4181 // case TagDecl::TK_enum:
4185 // At the XXX, our completions are TagDecl::TK_union,
4186 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union,
4187 // TK_struct, and TK_class.
4188 Qualifier = DRE->getQualifier();
4192 if (getLangOpts().CPlusPlus && !Qualifier && EnumeratorsSeen.empty()) {
4193 // If there are no prior enumerators in C++, check whether we have to
4194 // qualify the names of the enumerators that we suggest, because they
4195 // may not be visible in this scope.
4196 Qualifier = getRequiredQualification(Context, CurContext, Enum);
4199 // Add any enumerators that have not yet been mentioned.
4200 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4201 CodeCompleter->getCodeCompletionTUInfo(),
4202 CodeCompletionContext::CCC_Expression);
4203 Results.EnterNewScope();
4204 for (auto *E : Enum->enumerators()) {
4205 if (EnumeratorsSeen.count(E))
4208 CodeCompletionResult R(E, CCP_EnumInCase, Qualifier);
4209 Results.AddResult(R, CurContext, nullptr, false);
4211 Results.ExitScope();
4213 //We need to make sure we're setting the right context,
4214 //so only say we include macros if the code completer says we do
4215 enum CodeCompletionContext::Kind kind = CodeCompletionContext::CCC_Other;
4216 if (CodeCompleter->includeMacros()) {
4217 AddMacroResults(PP, Results, false);
4218 kind = CodeCompletionContext::CCC_OtherWithMacros;
4221 HandleCodeCompleteResults(this, CodeCompleter,
4223 Results.data(),Results.size());
4226 static bool anyNullArguments(ArrayRef<Expr *> Args) {
4227 if (Args.size() && !Args.data())
4230 for (unsigned I = 0; I != Args.size(); ++I)
4237 typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate;
4239 static void mergeCandidatesWithResults(Sema &SemaRef,
4240 SmallVectorImpl<ResultCandidate> &Results,
4241 OverloadCandidateSet &CandidateSet,
4242 SourceLocation Loc) {
4243 if (!CandidateSet.empty()) {
4244 // Sort the overload candidate set by placing the best overloads first.
4246 CandidateSet.begin(), CandidateSet.end(),
4247 [&](const OverloadCandidate &X, const OverloadCandidate &Y) {
4248 return isBetterOverloadCandidate(SemaRef, X, Y, Loc);
4251 // Add the remaining viable overload candidates as code-completion results.
4252 for (auto &Candidate : CandidateSet)
4253 if (Candidate.Viable)
4254 Results.push_back(ResultCandidate(Candidate.Function));
4258 /// \brief Get the type of the Nth parameter from a given set of overload
4260 static QualType getParamType(Sema &SemaRef,
4261 ArrayRef<ResultCandidate> Candidates,
4264 // Given the overloads 'Candidates' for a function call matching all arguments
4265 // up to N, return the type of the Nth parameter if it is the same for all
4266 // overload candidates.
4268 for (auto &Candidate : Candidates) {
4269 if (auto FType = Candidate.getFunctionType())
4270 if (auto Proto = dyn_cast<FunctionProtoType>(FType))
4271 if (N < Proto->getNumParams()) {
4272 if (ParamType.isNull())
4273 ParamType = Proto->getParamType(N);
4274 else if (!SemaRef.Context.hasSameUnqualifiedType(
4275 ParamType.getNonReferenceType(),
4276 Proto->getParamType(N).getNonReferenceType()))
4277 // Otherwise return a default-constructed QualType.
4285 static void CodeCompleteOverloadResults(Sema &SemaRef, Scope *S,
4286 MutableArrayRef<ResultCandidate> Candidates,
4287 unsigned CurrentArg,
4288 bool CompleteExpressionWithCurrentArg = true) {
4290 if (CompleteExpressionWithCurrentArg)
4291 ParamType = getParamType(SemaRef, Candidates, CurrentArg);
4293 if (ParamType.isNull())
4294 SemaRef.CodeCompleteOrdinaryName(S, Sema::PCC_Expression);
4296 SemaRef.CodeCompleteExpression(S, ParamType);
4298 if (!Candidates.empty())
4299 SemaRef.CodeCompleter->ProcessOverloadCandidates(SemaRef, CurrentArg,
4304 void Sema::CodeCompleteCall(Scope *S, Expr *Fn, ArrayRef<Expr *> Args) {
4308 // When we're code-completing for a call, we fall back to ordinary
4309 // name code-completion whenever we can't produce specific
4310 // results. We may want to revisit this strategy in the future,
4311 // e.g., by merging the two kinds of results.
4313 // FIXME: Provide support for variadic template functions.
4315 // Ignore type-dependent call expressions entirely.
4316 if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args) ||
4317 Expr::hasAnyTypeDependentArguments(Args)) {
4318 CodeCompleteOrdinaryName(S, PCC_Expression);
4322 // Build an overload candidate set based on the functions we find.
4323 SourceLocation Loc = Fn->getExprLoc();
4324 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
4326 SmallVector<ResultCandidate, 8> Results;
4328 Expr *NakedFn = Fn->IgnoreParenCasts();
4329 if (auto ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn))
4330 AddOverloadedCallCandidates(ULE, Args, CandidateSet,
4331 /*PartialOverloading=*/true);
4332 else if (auto UME = dyn_cast<UnresolvedMemberExpr>(NakedFn)) {
4333 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
4334 if (UME->hasExplicitTemplateArgs()) {
4335 UME->copyTemplateArgumentsInto(TemplateArgsBuffer);
4336 TemplateArgs = &TemplateArgsBuffer;
4339 // Add the base as first argument (use a nullptr if the base is implicit).
4340 SmallVector<Expr *, 12> ArgExprs(
4341 1, UME->isImplicitAccess() ? nullptr : UME->getBase());
4342 ArgExprs.append(Args.begin(), Args.end());
4343 UnresolvedSet<8> Decls;
4344 Decls.append(UME->decls_begin(), UME->decls_end());
4345 AddFunctionCandidates(Decls, ArgExprs, CandidateSet, TemplateArgs,
4346 /*SuppressUsedConversions=*/false,
4347 /*PartialOverloading=*/true);
4349 FunctionDecl *FD = nullptr;
4350 if (auto MCE = dyn_cast<MemberExpr>(NakedFn))
4351 FD = dyn_cast<FunctionDecl>(MCE->getMemberDecl());
4352 else if (auto DRE = dyn_cast<DeclRefExpr>(NakedFn))
4353 FD = dyn_cast<FunctionDecl>(DRE->getDecl());
4354 if (FD) { // We check whether it's a resolved function declaration.
4355 if (!getLangOpts().CPlusPlus ||
4356 !FD->getType()->getAs<FunctionProtoType>())
4357 Results.push_back(ResultCandidate(FD));
4359 AddOverloadCandidate(FD, DeclAccessPair::make(FD, FD->getAccess()),
4361 /*SuppressUsedConversions=*/false,
4362 /*PartialOverloading=*/true);
4364 } else if (auto DC = NakedFn->getType()->getAsCXXRecordDecl()) {
4365 // If expression's type is CXXRecordDecl, it may overload the function
4366 // call operator, so we check if it does and add them as candidates.
4367 // A complete type is needed to lookup for member function call operators.
4368 if (isCompleteType(Loc, NakedFn->getType())) {
4369 DeclarationName OpName = Context.DeclarationNames
4370 .getCXXOperatorName(OO_Call);
4371 LookupResult R(*this, OpName, Loc, LookupOrdinaryName);
4372 LookupQualifiedName(R, DC);
4373 R.suppressDiagnostics();
4374 SmallVector<Expr *, 12> ArgExprs(1, NakedFn);
4375 ArgExprs.append(Args.begin(), Args.end());
4376 AddFunctionCandidates(R.asUnresolvedSet(), ArgExprs, CandidateSet,
4377 /*ExplicitArgs=*/nullptr,
4378 /*SuppressUsedConversions=*/false,
4379 /*PartialOverloading=*/true);
4382 // Lastly we check whether expression's type is function pointer or
4384 QualType T = NakedFn->getType();
4385 if (!T->getPointeeType().isNull())
4386 T = T->getPointeeType();
4388 if (auto FP = T->getAs<FunctionProtoType>()) {
4389 if (!TooManyArguments(FP->getNumParams(), Args.size(),
4390 /*PartialOverloading=*/true) ||
4392 Results.push_back(ResultCandidate(FP));
4393 } else if (auto FT = T->getAs<FunctionType>())
4394 // No prototype and declaration, it may be a K & R style function.
4395 Results.push_back(ResultCandidate(FT));
4399 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4400 CodeCompleteOverloadResults(*this, S, Results, Args.size(),
4401 !CandidateSet.empty());
4404 void Sema::CodeCompleteConstructor(Scope *S, QualType Type, SourceLocation Loc,
4405 ArrayRef<Expr *> Args) {
4409 // A complete type is needed to lookup for constructors.
4410 if (!isCompleteType(Loc, Type))
4413 CXXRecordDecl *RD = Type->getAsCXXRecordDecl();
4415 CodeCompleteExpression(S, Type);
4419 // FIXME: Provide support for member initializers.
4420 // FIXME: Provide support for variadic template constructors.
4422 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
4424 for (auto C : LookupConstructors(RD)) {
4425 if (auto FD = dyn_cast<FunctionDecl>(C)) {
4426 AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()),
4428 /*SuppressUsedConversions=*/false,
4429 /*PartialOverloading=*/true);
4430 } else if (auto FTD = dyn_cast<FunctionTemplateDecl>(C)) {
4431 AddTemplateOverloadCandidate(FTD,
4432 DeclAccessPair::make(FTD, C->getAccess()),
4433 /*ExplicitTemplateArgs=*/nullptr,
4435 /*SuppressUsedConversions=*/false,
4436 /*PartialOverloading=*/true);
4440 SmallVector<ResultCandidate, 8> Results;
4441 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4442 CodeCompleteOverloadResults(*this, S, Results, Args.size());
4445 void Sema::CodeCompleteInitializer(Scope *S, Decl *D) {
4446 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D);
4448 CodeCompleteOrdinaryName(S, PCC_Expression);
4452 CodeCompleteExpression(S, VD->getType());
4455 void Sema::CodeCompleteReturn(Scope *S) {
4456 QualType ResultType;
4457 if (isa<BlockDecl>(CurContext)) {
4458 if (BlockScopeInfo *BSI = getCurBlock())
4459 ResultType = BSI->ReturnType;
4460 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(CurContext))
4461 ResultType = Function->getReturnType();
4462 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(CurContext))
4463 ResultType = Method->getReturnType();
4465 if (ResultType.isNull())
4466 CodeCompleteOrdinaryName(S, PCC_Expression);
4468 CodeCompleteExpression(S, ResultType);
4471 void Sema::CodeCompleteAfterIf(Scope *S) {
4472 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4473 CodeCompleter->getCodeCompletionTUInfo(),
4474 mapCodeCompletionContext(*this, PCC_Statement));
4475 Results.setFilter(&ResultBuilder::IsOrdinaryName);
4476 Results.EnterNewScope();
4478 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4479 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4480 CodeCompleter->includeGlobals());
4482 AddOrdinaryNameResults(PCC_Statement, S, *this, Results);
4485 CodeCompletionBuilder Builder(Results.getAllocator(),
4486 Results.getCodeCompletionTUInfo());
4487 Builder.AddTypedTextChunk("else");
4488 if (Results.includeCodePatterns()) {
4489 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4490 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4491 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4492 Builder.AddPlaceholderChunk("statements");
4493 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4494 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4496 Results.AddResult(Builder.TakeString());
4499 Builder.AddTypedTextChunk("else");
4500 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4501 Builder.AddTextChunk("if");
4502 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4503 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4504 if (getLangOpts().CPlusPlus)
4505 Builder.AddPlaceholderChunk("condition");
4507 Builder.AddPlaceholderChunk("expression");
4508 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4509 if (Results.includeCodePatterns()) {
4510 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4511 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4512 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4513 Builder.AddPlaceholderChunk("statements");
4514 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4515 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4517 Results.AddResult(Builder.TakeString());
4519 Results.ExitScope();
4521 if (S->getFnParent())
4522 AddPrettyFunctionResults(getLangOpts(), Results);
4524 if (CodeCompleter->includeMacros())
4525 AddMacroResults(PP, Results, false);
4527 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4528 Results.data(),Results.size());
4531 void Sema::CodeCompleteAssignmentRHS(Scope *S, Expr *LHS) {
4533 CodeCompleteExpression(S, static_cast<Expr *>(LHS)->getType());
4535 CodeCompleteOrdinaryName(S, PCC_Expression);
4538 void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
4539 bool EnteringContext) {
4540 if (!SS.getScopeRep() || !CodeCompleter)
4543 DeclContext *Ctx = computeDeclContext(SS, EnteringContext);
4547 // Try to instantiate any non-dependent declaration contexts before
4549 if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx))
4552 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4553 CodeCompleter->getCodeCompletionTUInfo(),
4554 CodeCompletionContext::CCC_Name);
4555 Results.EnterNewScope();
4557 // The "template" keyword can follow "::" in the grammar, but only
4558 // put it into the grammar if the nested-name-specifier is dependent.
4559 NestedNameSpecifier *NNS = SS.getScopeRep();
4560 if (!Results.empty() && NNS->isDependent())
4561 Results.AddResult("template");
4563 // Add calls to overridden virtual functions, if there are any.
4565 // FIXME: This isn't wonderful, because we don't know whether we're actually
4566 // in a context that permits expressions. This is a general issue with
4567 // qualified-id completions.
4568 if (!EnteringContext)
4569 MaybeAddOverrideCalls(*this, Ctx, Results);
4570 Results.ExitScope();
4572 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4573 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer);
4575 HandleCodeCompleteResults(this, CodeCompleter,
4576 Results.getCompletionContext(),
4577 Results.data(),Results.size());
4580 void Sema::CodeCompleteUsing(Scope *S) {
4584 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4585 CodeCompleter->getCodeCompletionTUInfo(),
4586 CodeCompletionContext::CCC_PotentiallyQualifiedName,
4587 &ResultBuilder::IsNestedNameSpecifier);
4588 Results.EnterNewScope();
4590 // If we aren't in class scope, we could see the "namespace" keyword.
4591 if (!S->isClassScope())
4592 Results.AddResult(CodeCompletionResult("namespace"));
4594 // After "using", we can see anything that would start a
4595 // nested-name-specifier.
4596 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4597 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4598 CodeCompleter->includeGlobals());
4599 Results.ExitScope();
4601 HandleCodeCompleteResults(this, CodeCompleter,
4602 CodeCompletionContext::CCC_PotentiallyQualifiedName,
4603 Results.data(),Results.size());
4606 void Sema::CodeCompleteUsingDirective(Scope *S) {
4610 // After "using namespace", we expect to see a namespace name or namespace
4612 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4613 CodeCompleter->getCodeCompletionTUInfo(),
4614 CodeCompletionContext::CCC_Namespace,
4615 &ResultBuilder::IsNamespaceOrAlias);
4616 Results.EnterNewScope();
4617 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4618 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4619 CodeCompleter->includeGlobals());
4620 Results.ExitScope();
4621 HandleCodeCompleteResults(this, CodeCompleter,
4622 CodeCompletionContext::CCC_Namespace,
4623 Results.data(),Results.size());
4626 void Sema::CodeCompleteNamespaceDecl(Scope *S) {
4630 DeclContext *Ctx = S->getEntity();
4631 if (!S->getParent())
4632 Ctx = Context.getTranslationUnitDecl();
4634 bool SuppressedGlobalResults
4635 = Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx);
4637 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4638 CodeCompleter->getCodeCompletionTUInfo(),
4639 SuppressedGlobalResults
4640 ? CodeCompletionContext::CCC_Namespace
4641 : CodeCompletionContext::CCC_Other,
4642 &ResultBuilder::IsNamespace);
4644 if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) {
4645 // We only want to see those namespaces that have already been defined
4646 // within this scope, because its likely that the user is creating an
4647 // extended namespace declaration. Keep track of the most recent
4648 // definition of each namespace.
4649 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest;
4650 for (DeclContext::specific_decl_iterator<NamespaceDecl>
4651 NS(Ctx->decls_begin()), NSEnd(Ctx->decls_end());
4653 OrigToLatest[NS->getOriginalNamespace()] = *NS;
4655 // Add the most recent definition (or extended definition) of each
4656 // namespace to the list of results.
4657 Results.EnterNewScope();
4658 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator
4659 NS = OrigToLatest.begin(),
4660 NSEnd = OrigToLatest.end();
4662 Results.AddResult(CodeCompletionResult(
4663 NS->second, Results.getBasePriority(NS->second),
4665 CurContext, nullptr, false);
4666 Results.ExitScope();
4669 HandleCodeCompleteResults(this, CodeCompleter,
4670 Results.getCompletionContext(),
4671 Results.data(),Results.size());
4674 void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) {
4678 // After "namespace", we expect to see a namespace or alias.
4679 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4680 CodeCompleter->getCodeCompletionTUInfo(),
4681 CodeCompletionContext::CCC_Namespace,
4682 &ResultBuilder::IsNamespaceOrAlias);
4683 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4684 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4685 CodeCompleter->includeGlobals());
4686 HandleCodeCompleteResults(this, CodeCompleter,
4687 Results.getCompletionContext(),
4688 Results.data(),Results.size());
4691 void Sema::CodeCompleteOperatorName(Scope *S) {
4695 typedef CodeCompletionResult Result;
4696 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4697 CodeCompleter->getCodeCompletionTUInfo(),
4698 CodeCompletionContext::CCC_Type,
4699 &ResultBuilder::IsType);
4700 Results.EnterNewScope();
4702 // Add the names of overloadable operators.
4703 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4704 if (std::strcmp(Spelling, "?")) \
4705 Results.AddResult(Result(Spelling));
4706 #include "clang/Basic/OperatorKinds.def"
4708 // Add any type names visible from the current scope
4709 Results.allowNestedNameSpecifiers();
4710 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4711 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4712 CodeCompleter->includeGlobals());
4714 // Add any type specifiers
4715 AddTypeSpecifierResults(getLangOpts(), Results);
4716 Results.ExitScope();
4718 HandleCodeCompleteResults(this, CodeCompleter,
4719 CodeCompletionContext::CCC_Type,
4720 Results.data(),Results.size());
4723 void Sema::CodeCompleteConstructorInitializer(
4725 ArrayRef <CXXCtorInitializer *> Initializers) {
4729 AdjustDeclIfTemplate(ConstructorD);
4731 CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ConstructorD);
4735 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4736 CodeCompleter->getCodeCompletionTUInfo(),
4737 CodeCompletionContext::CCC_PotentiallyQualifiedName);
4738 Results.EnterNewScope();
4740 // Fill in any already-initialized fields or base classes.
4741 llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
4742 llvm::SmallPtrSet<CanQualType, 4> InitializedBases;
4743 for (unsigned I = 0, E = Initializers.size(); I != E; ++I) {
4744 if (Initializers[I]->isBaseInitializer())
4745 InitializedBases.insert(
4746 Context.getCanonicalType(QualType(Initializers[I]->getBaseClass(), 0)));
4748 InitializedFields.insert(cast<FieldDecl>(
4749 Initializers[I]->getAnyMember()));
4752 // Add completions for base classes.
4753 CodeCompletionBuilder Builder(Results.getAllocator(),
4754 Results.getCodeCompletionTUInfo());
4755 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
4756 bool SawLastInitializer = Initializers.empty();
4757 CXXRecordDecl *ClassDecl = Constructor->getParent();
4758 for (const auto &Base : ClassDecl->bases()) {
4759 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4762 = !Initializers.empty() &&
4763 Initializers.back()->isBaseInitializer() &&
4764 Context.hasSameUnqualifiedType(Base.getType(),
4765 QualType(Initializers.back()->getBaseClass(), 0));
4769 Builder.AddTypedTextChunk(
4770 Results.getAllocator().CopyString(
4771 Base.getType().getAsString(Policy)));
4772 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4773 Builder.AddPlaceholderChunk("args");
4774 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4775 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4776 SawLastInitializer? CCP_NextInitializer
4777 : CCP_MemberDeclaration));
4778 SawLastInitializer = false;
4781 // Add completions for virtual base classes.
4782 for (const auto &Base : ClassDecl->vbases()) {
4783 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4786 = !Initializers.empty() &&
4787 Initializers.back()->isBaseInitializer() &&
4788 Context.hasSameUnqualifiedType(Base.getType(),
4789 QualType(Initializers.back()->getBaseClass(), 0));
4793 Builder.AddTypedTextChunk(
4794 Builder.getAllocator().CopyString(
4795 Base.getType().getAsString(Policy)));
4796 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4797 Builder.AddPlaceholderChunk("args");
4798 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4799 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4800 SawLastInitializer? CCP_NextInitializer
4801 : CCP_MemberDeclaration));
4802 SawLastInitializer = false;
4805 // Add completions for members.
4806 for (auto *Field : ClassDecl->fields()) {
4807 if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))
4810 = !Initializers.empty() &&
4811 Initializers.back()->isAnyMemberInitializer() &&
4812 Initializers.back()->getAnyMember() == Field;
4816 if (!Field->getDeclName())
4819 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
4820 Field->getIdentifier()->getName()));
4821 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4822 Builder.AddPlaceholderChunk("args");
4823 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4824 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4825 SawLastInitializer? CCP_NextInitializer
4826 : CCP_MemberDeclaration,
4828 CXAvailability_Available,
4830 SawLastInitializer = false;
4832 Results.ExitScope();
4834 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4835 Results.data(), Results.size());
4838 /// \brief Determine whether this scope denotes a namespace.
4839 static bool isNamespaceScope(Scope *S) {
4840 DeclContext *DC = S->getEntity();
4844 return DC->isFileContext();
4847 void Sema::CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
4848 bool AfterAmpersand) {
4849 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4850 CodeCompleter->getCodeCompletionTUInfo(),
4851 CodeCompletionContext::CCC_Other);
4852 Results.EnterNewScope();
4854 // Note what has already been captured.
4855 llvm::SmallPtrSet<IdentifierInfo *, 4> Known;
4856 bool IncludedThis = false;
4857 for (const auto &C : Intro.Captures) {
4858 if (C.Kind == LCK_This) {
4859 IncludedThis = true;
4866 // Look for other capturable variables.
4867 for (; S && !isNamespaceScope(S); S = S->getParent()) {
4868 for (const auto *D : S->decls()) {
4869 const auto *Var = dyn_cast<VarDecl>(D);
4871 !Var->hasLocalStorage() ||
4872 Var->hasAttr<BlocksAttr>())
4875 if (Known.insert(Var->getIdentifier()).second)
4876 Results.AddResult(CodeCompletionResult(Var, CCP_LocalDeclaration),
4877 CurContext, nullptr, false);
4881 // Add 'this', if it would be valid.
4882 if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy)
4883 addThisCompletion(*this, Results);
4885 Results.ExitScope();
4887 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4888 Results.data(), Results.size());
4891 /// Macro that optionally prepends an "@" to the string literal passed in via
4892 /// Keyword, depending on whether NeedAt is true or false.
4893 #define OBJC_AT_KEYWORD_NAME(NeedAt,Keyword) ((NeedAt)? "@" Keyword : Keyword)
4895 static void AddObjCImplementationResults(const LangOptions &LangOpts,
4896 ResultBuilder &Results,
4898 typedef CodeCompletionResult Result;
4899 // Since we have an implementation, we can end it.
4900 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
4902 CodeCompletionBuilder Builder(Results.getAllocator(),
4903 Results.getCodeCompletionTUInfo());
4904 if (LangOpts.ObjC2) {
4906 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"dynamic"));
4907 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4908 Builder.AddPlaceholderChunk("property");
4909 Results.AddResult(Result(Builder.TakeString()));
4912 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synthesize"));
4913 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4914 Builder.AddPlaceholderChunk("property");
4915 Results.AddResult(Result(Builder.TakeString()));
4919 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
4920 ResultBuilder &Results,
4922 typedef CodeCompletionResult Result;
4924 // Since we have an interface or protocol, we can end it.
4925 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
4927 if (LangOpts.ObjC2) {
4929 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"property")));
4932 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"required")));
4935 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"optional")));
4939 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
4940 typedef CodeCompletionResult Result;
4941 CodeCompletionBuilder Builder(Results.getAllocator(),
4942 Results.getCodeCompletionTUInfo());
4945 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"class"));
4946 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4947 Builder.AddPlaceholderChunk("name");
4948 Results.AddResult(Result(Builder.TakeString()));
4950 if (Results.includeCodePatterns()) {
4952 // FIXME: Could introduce the whole pattern, including superclasses and
4954 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"interface"));
4955 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4956 Builder.AddPlaceholderChunk("class");
4957 Results.AddResult(Result(Builder.TakeString()));
4960 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
4961 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4962 Builder.AddPlaceholderChunk("protocol");
4963 Results.AddResult(Result(Builder.TakeString()));
4965 // @implementation name
4966 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"implementation"));
4967 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4968 Builder.AddPlaceholderChunk("class");
4969 Results.AddResult(Result(Builder.TakeString()));
4972 // @compatibility_alias name
4973 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"compatibility_alias"));
4974 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4975 Builder.AddPlaceholderChunk("alias");
4976 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4977 Builder.AddPlaceholderChunk("class");
4978 Results.AddResult(Result(Builder.TakeString()));
4980 if (Results.getSema().getLangOpts().Modules) {
4982 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import"));
4983 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4984 Builder.AddPlaceholderChunk("module");
4985 Results.AddResult(Result(Builder.TakeString()));
4989 void Sema::CodeCompleteObjCAtDirective(Scope *S) {
4990 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4991 CodeCompleter->getCodeCompletionTUInfo(),
4992 CodeCompletionContext::CCC_Other);
4993 Results.EnterNewScope();
4994 if (isa<ObjCImplDecl>(CurContext))
4995 AddObjCImplementationResults(getLangOpts(), Results, false);
4996 else if (CurContext->isObjCContainer())
4997 AddObjCInterfaceResults(getLangOpts(), Results, false);
4999 AddObjCTopLevelResults(Results, false);
5000 Results.ExitScope();
5001 HandleCodeCompleteResults(this, CodeCompleter,
5002 CodeCompletionContext::CCC_Other,
5003 Results.data(),Results.size());
5006 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) {
5007 typedef CodeCompletionResult Result;
5008 CodeCompletionBuilder Builder(Results.getAllocator(),
5009 Results.getCodeCompletionTUInfo());
5011 // @encode ( type-name )
5012 const char *EncodeType = "char[]";
5013 if (Results.getSema().getLangOpts().CPlusPlus ||
5014 Results.getSema().getLangOpts().ConstStrings)
5015 EncodeType = "const char[]";
5016 Builder.AddResultTypeChunk(EncodeType);
5017 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"encode"));
5018 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5019 Builder.AddPlaceholderChunk("type-name");
5020 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5021 Results.AddResult(Result(Builder.TakeString()));
5023 // @protocol ( protocol-name )
5024 Builder.AddResultTypeChunk("Protocol *");
5025 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
5026 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5027 Builder.AddPlaceholderChunk("protocol-name");
5028 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5029 Results.AddResult(Result(Builder.TakeString()));
5031 // @selector ( selector )
5032 Builder.AddResultTypeChunk("SEL");
5033 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"selector"));
5034 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5035 Builder.AddPlaceholderChunk("selector");
5036 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5037 Results.AddResult(Result(Builder.TakeString()));
5040 Builder.AddResultTypeChunk("NSString *");
5041 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"\""));
5042 Builder.AddPlaceholderChunk("string");
5043 Builder.AddTextChunk("\"");
5044 Results.AddResult(Result(Builder.TakeString()));
5047 Builder.AddResultTypeChunk("NSArray *");
5048 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"["));
5049 Builder.AddPlaceholderChunk("objects, ...");
5050 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
5051 Results.AddResult(Result(Builder.TakeString()));
5053 // @{key : object, ...}
5054 Builder.AddResultTypeChunk("NSDictionary *");
5055 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"{"));
5056 Builder.AddPlaceholderChunk("key");
5057 Builder.AddChunk(CodeCompletionString::CK_Colon);
5058 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5059 Builder.AddPlaceholderChunk("object, ...");
5060 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5061 Results.AddResult(Result(Builder.TakeString()));
5064 Builder.AddResultTypeChunk("id");
5065 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "("));
5066 Builder.AddPlaceholderChunk("expression");
5067 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5068 Results.AddResult(Result(Builder.TakeString()));
5071 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) {
5072 typedef CodeCompletionResult Result;
5073 CodeCompletionBuilder Builder(Results.getAllocator(),
5074 Results.getCodeCompletionTUInfo());
5076 if (Results.includeCodePatterns()) {
5077 // @try { statements } @catch ( declaration ) { statements } @finally
5079 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"try"));
5080 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5081 Builder.AddPlaceholderChunk("statements");
5082 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5083 Builder.AddTextChunk("@catch");
5084 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5085 Builder.AddPlaceholderChunk("parameter");
5086 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5087 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5088 Builder.AddPlaceholderChunk("statements");
5089 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5090 Builder.AddTextChunk("@finally");
5091 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5092 Builder.AddPlaceholderChunk("statements");
5093 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5094 Results.AddResult(Result(Builder.TakeString()));
5098 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"throw"));
5099 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5100 Builder.AddPlaceholderChunk("expression");
5101 Results.AddResult(Result(Builder.TakeString()));
5103 if (Results.includeCodePatterns()) {
5104 // @synchronized ( expression ) { statements }
5105 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synchronized"));
5106 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5107 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5108 Builder.AddPlaceholderChunk("expression");
5109 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5110 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5111 Builder.AddPlaceholderChunk("statements");
5112 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5113 Results.AddResult(Result(Builder.TakeString()));
5117 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
5118 ResultBuilder &Results,
5120 typedef CodeCompletionResult Result;
5121 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"private")));
5122 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"protected")));
5123 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"public")));
5125 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"package")));
5128 void Sema::CodeCompleteObjCAtVisibility(Scope *S) {
5129 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5130 CodeCompleter->getCodeCompletionTUInfo(),
5131 CodeCompletionContext::CCC_Other);
5132 Results.EnterNewScope();
5133 AddObjCVisibilityResults(getLangOpts(), Results, false);
5134 Results.ExitScope();
5135 HandleCodeCompleteResults(this, CodeCompleter,
5136 CodeCompletionContext::CCC_Other,
5137 Results.data(),Results.size());
5140 void Sema::CodeCompleteObjCAtStatement(Scope *S) {
5141 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5142 CodeCompleter->getCodeCompletionTUInfo(),
5143 CodeCompletionContext::CCC_Other);
5144 Results.EnterNewScope();
5145 AddObjCStatementResults(Results, false);
5146 AddObjCExpressionResults(Results, false);
5147 Results.ExitScope();
5148 HandleCodeCompleteResults(this, CodeCompleter,
5149 CodeCompletionContext::CCC_Other,
5150 Results.data(),Results.size());
5153 void Sema::CodeCompleteObjCAtExpression(Scope *S) {
5154 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5155 CodeCompleter->getCodeCompletionTUInfo(),
5156 CodeCompletionContext::CCC_Other);
5157 Results.EnterNewScope();
5158 AddObjCExpressionResults(Results, false);
5159 Results.ExitScope();
5160 HandleCodeCompleteResults(this, CodeCompleter,
5161 CodeCompletionContext::CCC_Other,
5162 Results.data(),Results.size());
5165 /// \brief Determine whether the addition of the given flag to an Objective-C
5166 /// property's attributes will cause a conflict.
5167 static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) {
5168 // Check if we've already added this flag.
5169 if (Attributes & NewFlag)
5172 Attributes |= NewFlag;
5174 // Check for collisions with "readonly".
5175 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
5176 (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
5179 // Check for more than one of { assign, copy, retain, strong, weak }.
5180 unsigned AssignCopyRetMask = Attributes & (ObjCDeclSpec::DQ_PR_assign |
5181 ObjCDeclSpec::DQ_PR_unsafe_unretained |
5182 ObjCDeclSpec::DQ_PR_copy |
5183 ObjCDeclSpec::DQ_PR_retain |
5184 ObjCDeclSpec::DQ_PR_strong |
5185 ObjCDeclSpec::DQ_PR_weak);
5186 if (AssignCopyRetMask &&
5187 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign &&
5188 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_unsafe_unretained &&
5189 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy &&
5190 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain &&
5191 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_strong &&
5192 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_weak)
5198 void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) {
5202 unsigned Attributes = ODS.getPropertyAttributes();
5204 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5205 CodeCompleter->getCodeCompletionTUInfo(),
5206 CodeCompletionContext::CCC_Other);
5207 Results.EnterNewScope();
5208 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readonly))
5209 Results.AddResult(CodeCompletionResult("readonly"));
5210 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_assign))
5211 Results.AddResult(CodeCompletionResult("assign"));
5212 if (!ObjCPropertyFlagConflicts(Attributes,
5213 ObjCDeclSpec::DQ_PR_unsafe_unretained))
5214 Results.AddResult(CodeCompletionResult("unsafe_unretained"));
5215 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readwrite))
5216 Results.AddResult(CodeCompletionResult("readwrite"));
5217 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_retain))
5218 Results.AddResult(CodeCompletionResult("retain"));
5219 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_strong))
5220 Results.AddResult(CodeCompletionResult("strong"));
5221 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_copy))
5222 Results.AddResult(CodeCompletionResult("copy"));
5223 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nonatomic))
5224 Results.AddResult(CodeCompletionResult("nonatomic"));
5225 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_atomic))
5226 Results.AddResult(CodeCompletionResult("atomic"));
5228 // Only suggest "weak" if we're compiling for ARC-with-weak-references or GC.
5229 if (getLangOpts().ObjCWeak || getLangOpts().getGC() != LangOptions::NonGC)
5230 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_weak))
5231 Results.AddResult(CodeCompletionResult("weak"));
5233 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_setter)) {
5234 CodeCompletionBuilder Setter(Results.getAllocator(),
5235 Results.getCodeCompletionTUInfo());
5236 Setter.AddTypedTextChunk("setter");
5237 Setter.AddTextChunk("=");
5238 Setter.AddPlaceholderChunk("method");
5239 Results.AddResult(CodeCompletionResult(Setter.TakeString()));
5241 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_getter)) {
5242 CodeCompletionBuilder Getter(Results.getAllocator(),
5243 Results.getCodeCompletionTUInfo());
5244 Getter.AddTypedTextChunk("getter");
5245 Getter.AddTextChunk("=");
5246 Getter.AddPlaceholderChunk("method");
5247 Results.AddResult(CodeCompletionResult(Getter.TakeString()));
5249 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nullability)) {
5250 Results.AddResult(CodeCompletionResult("nonnull"));
5251 Results.AddResult(CodeCompletionResult("nullable"));
5252 Results.AddResult(CodeCompletionResult("null_unspecified"));
5253 Results.AddResult(CodeCompletionResult("null_resettable"));
5255 Results.ExitScope();
5256 HandleCodeCompleteResults(this, CodeCompleter,
5257 CodeCompletionContext::CCC_Other,
5258 Results.data(),Results.size());
5261 /// \brief Describes the kind of Objective-C method that we want to find
5262 /// via code completion.
5263 enum ObjCMethodKind {
5264 MK_Any, ///< Any kind of method, provided it means other specified criteria.
5265 MK_ZeroArgSelector, ///< Zero-argument (unary) selector.
5266 MK_OneArgSelector ///< One-argument selector.
5269 static bool isAcceptableObjCSelector(Selector Sel,
5270 ObjCMethodKind WantKind,
5271 ArrayRef<IdentifierInfo *> SelIdents,
5272 bool AllowSameLength = true) {
5273 unsigned NumSelIdents = SelIdents.size();
5274 if (NumSelIdents > Sel.getNumArgs())
5279 case MK_ZeroArgSelector: return Sel.isUnarySelector();
5280 case MK_OneArgSelector: return Sel.getNumArgs() == 1;
5283 if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs())
5286 for (unsigned I = 0; I != NumSelIdents; ++I)
5287 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I))
5293 static bool isAcceptableObjCMethod(ObjCMethodDecl *Method,
5294 ObjCMethodKind WantKind,
5295 ArrayRef<IdentifierInfo *> SelIdents,
5296 bool AllowSameLength = true) {
5297 return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents,
5302 /// \brief A set of selectors, which is used to avoid introducing multiple
5303 /// completions with the same selector into the result set.
5304 typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet;
5307 /// \brief Add all of the Objective-C methods in the given Objective-C
5308 /// container to the set of results.
5310 /// The container will be a class, protocol, category, or implementation of
5311 /// any of the above. This mether will recurse to include methods from
5312 /// the superclasses of classes along with their categories, protocols, and
5313 /// implementations.
5315 /// \param Container the container in which we'll look to find methods.
5317 /// \param WantInstanceMethods Whether to add instance methods (only); if
5318 /// false, this routine will add factory methods (only).
5320 /// \param CurContext the context in which we're performing the lookup that
5323 /// \param AllowSameLength Whether we allow a method to be added to the list
5324 /// when it has the same number of parameters as we have selector identifiers.
5326 /// \param Results the structure into which we'll add results.
5327 static void AddObjCMethods(ObjCContainerDecl *Container,
5328 bool WantInstanceMethods, ObjCMethodKind WantKind,
5329 ArrayRef<IdentifierInfo *> SelIdents,
5330 DeclContext *CurContext,
5331 VisitedSelectorSet &Selectors, bool AllowSameLength,
5332 ResultBuilder &Results, bool InOriginalClass = true,
5333 bool IsRootClass = false) {
5334 typedef CodeCompletionResult Result;
5335 Container = getContainerDef(Container);
5336 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
5337 IsRootClass = IsRootClass || (IFace && !IFace->getSuperClass());
5338 for (auto *M : Container->methods()) {
5339 // The instance methods on the root class can be messaged via the
5341 if (M->isInstanceMethod() == WantInstanceMethods ||
5342 (IsRootClass && !WantInstanceMethods)) {
5343 // Check whether the selector identifiers we've been given are a
5344 // subset of the identifiers for this particular method.
5345 if (!isAcceptableObjCMethod(M, WantKind, SelIdents, AllowSameLength))
5348 if (!Selectors.insert(M->getSelector()).second)
5351 Result R = Result(M, Results.getBasePriority(M), nullptr);
5352 R.StartParameter = SelIdents.size();
5353 R.AllParametersAreInformative = (WantKind != MK_Any);
5354 if (!InOriginalClass)
5355 R.Priority += CCD_InBaseClass;
5356 Results.MaybeAddResult(R, CurContext);
5360 // Visit the protocols of protocols.
5361 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
5362 if (Protocol->hasDefinition()) {
5363 const ObjCList<ObjCProtocolDecl> &Protocols
5364 = Protocol->getReferencedProtocols();
5365 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5366 E = Protocols.end();
5368 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5369 Selectors, AllowSameLength, Results, false, IsRootClass);
5373 if (!IFace || !IFace->hasDefinition())
5376 // Add methods in protocols.
5377 for (auto *I : IFace->protocols())
5378 AddObjCMethods(I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5379 Selectors, AllowSameLength, Results, false, IsRootClass);
5381 // Add methods in categories.
5382 for (auto *CatDecl : IFace->known_categories()) {
5383 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
5384 CurContext, Selectors, AllowSameLength, Results,
5385 InOriginalClass, IsRootClass);
5387 // Add a categories protocol methods.
5388 const ObjCList<ObjCProtocolDecl> &Protocols
5389 = CatDecl->getReferencedProtocols();
5390 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5391 E = Protocols.end();
5393 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5394 Selectors, AllowSameLength, Results, false, IsRootClass);
5396 // Add methods in category implementations.
5397 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation())
5398 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
5399 Selectors, AllowSameLength, Results, InOriginalClass,
5403 // Add methods in superclass.
5404 // Avoid passing in IsRootClass since root classes won't have super classes.
5405 if (IFace->getSuperClass())
5406 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind,
5407 SelIdents, CurContext, Selectors, AllowSameLength, Results,
5408 /*IsRootClass=*/false);
5410 // Add methods in our implementation, if any.
5411 if (ObjCImplementationDecl *Impl = IFace->getImplementation())
5412 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
5413 Selectors, AllowSameLength, Results, InOriginalClass,
5418 void Sema::CodeCompleteObjCPropertyGetter(Scope *S) {
5419 // Try to find the interface where getters might live.
5420 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
5422 if (ObjCCategoryDecl *Category
5423 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
5424 Class = Category->getClassInterface();
5430 // Find all of the potential getters.
5431 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5432 CodeCompleter->getCodeCompletionTUInfo(),
5433 CodeCompletionContext::CCC_Other);
5434 Results.EnterNewScope();
5436 VisitedSelectorSet Selectors;
5437 AddObjCMethods(Class, true, MK_ZeroArgSelector, None, CurContext, Selectors,
5438 /*AllowSameLength=*/true, Results);
5439 Results.ExitScope();
5440 HandleCodeCompleteResults(this, CodeCompleter,
5441 CodeCompletionContext::CCC_Other,
5442 Results.data(),Results.size());
5445 void Sema::CodeCompleteObjCPropertySetter(Scope *S) {
5446 // Try to find the interface where setters might live.
5447 ObjCInterfaceDecl *Class
5448 = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
5450 if (ObjCCategoryDecl *Category
5451 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
5452 Class = Category->getClassInterface();
5458 // Find all of the potential getters.
5459 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5460 CodeCompleter->getCodeCompletionTUInfo(),
5461 CodeCompletionContext::CCC_Other);
5462 Results.EnterNewScope();
5464 VisitedSelectorSet Selectors;
5465 AddObjCMethods(Class, true, MK_OneArgSelector, None, CurContext,
5466 Selectors, /*AllowSameLength=*/true, Results);
5468 Results.ExitScope();
5469 HandleCodeCompleteResults(this, CodeCompleter,
5470 CodeCompletionContext::CCC_Other,
5471 Results.data(),Results.size());
5474 void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
5476 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5477 CodeCompleter->getCodeCompletionTUInfo(),
5478 CodeCompletionContext::CCC_Type);
5479 Results.EnterNewScope();
5481 // Add context-sensitive, Objective-C parameter-passing keywords.
5482 bool AddedInOut = false;
5483 if ((DS.getObjCDeclQualifier() &
5484 (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) {
5485 Results.AddResult("in");
5486 Results.AddResult("inout");
5489 if ((DS.getObjCDeclQualifier() &
5490 (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) {
5491 Results.AddResult("out");
5493 Results.AddResult("inout");
5495 if ((DS.getObjCDeclQualifier() &
5496 (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref |
5497 ObjCDeclSpec::DQ_Oneway)) == 0) {
5498 Results.AddResult("bycopy");
5499 Results.AddResult("byref");
5500 Results.AddResult("oneway");
5502 if ((DS.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability) == 0) {
5503 Results.AddResult("nonnull");
5504 Results.AddResult("nullable");
5505 Results.AddResult("null_unspecified");
5508 // If we're completing the return type of an Objective-C method and the
5509 // identifier IBAction refers to a macro, provide a completion item for
5511 // IBAction)<#selector#>:(id)sender
5512 if (DS.getObjCDeclQualifier() == 0 && !IsParameter &&
5513 PP.isMacroDefined("IBAction")) {
5514 CodeCompletionBuilder Builder(Results.getAllocator(),
5515 Results.getCodeCompletionTUInfo(),
5516 CCP_CodePattern, CXAvailability_Available);
5517 Builder.AddTypedTextChunk("IBAction");
5518 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5519 Builder.AddPlaceholderChunk("selector");
5520 Builder.AddChunk(CodeCompletionString::CK_Colon);
5521 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5522 Builder.AddTextChunk("id");
5523 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5524 Builder.AddTextChunk("sender");
5525 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
5528 // If we're completing the return type, provide 'instancetype'.
5530 Results.AddResult(CodeCompletionResult("instancetype"));
5533 // Add various builtin type names and specifiers.
5534 AddOrdinaryNameResults(PCC_Type, S, *this, Results);
5535 Results.ExitScope();
5537 // Add the various type names
5538 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
5539 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5540 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5541 CodeCompleter->includeGlobals());
5543 if (CodeCompleter->includeMacros())
5544 AddMacroResults(PP, Results, false);
5546 HandleCodeCompleteResults(this, CodeCompleter,
5547 CodeCompletionContext::CCC_Type,
5548 Results.data(), Results.size());
5551 /// \brief When we have an expression with type "id", we may assume
5552 /// that it has some more-specific class type based on knowledge of
5553 /// common uses of Objective-C. This routine returns that class type,
5554 /// or NULL if no better result could be determined.
5555 static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) {
5556 ObjCMessageExpr *Msg = dyn_cast_or_null<ObjCMessageExpr>(E);
5560 Selector Sel = Msg->getSelector();
5564 IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0);
5568 ObjCMethodDecl *Method = Msg->getMethodDecl();
5572 // Determine the class that we're sending the message to.
5573 ObjCInterfaceDecl *IFace = nullptr;
5574 switch (Msg->getReceiverKind()) {
5575 case ObjCMessageExpr::Class:
5576 if (const ObjCObjectType *ObjType
5577 = Msg->getClassReceiver()->getAs<ObjCObjectType>())
5578 IFace = ObjType->getInterface();
5581 case ObjCMessageExpr::Instance: {
5582 QualType T = Msg->getInstanceReceiver()->getType();
5583 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
5584 IFace = Ptr->getInterfaceDecl();
5588 case ObjCMessageExpr::SuperInstance:
5589 case ObjCMessageExpr::SuperClass:
5596 ObjCInterfaceDecl *Super = IFace->getSuperClass();
5597 if (Method->isInstanceMethod())
5598 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5599 .Case("retain", IFace)
5600 .Case("strong", IFace)
5601 .Case("autorelease", IFace)
5602 .Case("copy", IFace)
5603 .Case("copyWithZone", IFace)
5604 .Case("mutableCopy", IFace)
5605 .Case("mutableCopyWithZone", IFace)
5606 .Case("awakeFromCoder", IFace)
5607 .Case("replacementObjectFromCoder", IFace)
5608 .Case("class", IFace)
5609 .Case("classForCoder", IFace)
5610 .Case("superclass", Super)
5613 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5615 .Case("alloc", IFace)
5616 .Case("allocWithZone", IFace)
5617 .Case("class", IFace)
5618 .Case("superclass", Super)
5622 // Add a special completion for a message send to "super", which fills in the
5623 // most likely case of forwarding all of our arguments to the superclass
5626 /// \param S The semantic analysis object.
5628 /// \param NeedSuperKeyword Whether we need to prefix this completion with
5629 /// the "super" keyword. Otherwise, we just need to provide the arguments.
5631 /// \param SelIdents The identifiers in the selector that have already been
5632 /// provided as arguments for a send to "super".
5634 /// \param Results The set of results to augment.
5636 /// \returns the Objective-C method declaration that would be invoked by
5637 /// this "super" completion. If NULL, no completion was added.
5638 static ObjCMethodDecl *AddSuperSendCompletion(
5639 Sema &S, bool NeedSuperKeyword,
5640 ArrayRef<IdentifierInfo *> SelIdents,
5641 ResultBuilder &Results) {
5642 ObjCMethodDecl *CurMethod = S.getCurMethodDecl();
5646 ObjCInterfaceDecl *Class = CurMethod->getClassInterface();
5650 // Try to find a superclass method with the same selector.
5651 ObjCMethodDecl *SuperMethod = nullptr;
5652 while ((Class = Class->getSuperClass()) && !SuperMethod) {
5653 // Check in the class
5654 SuperMethod = Class->getMethod(CurMethod->getSelector(),
5655 CurMethod->isInstanceMethod());
5657 // Check in categories or class extensions.
5659 for (const auto *Cat : Class->known_categories()) {
5660 if ((SuperMethod = Cat->getMethod(CurMethod->getSelector(),
5661 CurMethod->isInstanceMethod())))
5670 // Check whether the superclass method has the same signature.
5671 if (CurMethod->param_size() != SuperMethod->param_size() ||
5672 CurMethod->isVariadic() != SuperMethod->isVariadic())
5675 for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(),
5676 CurPEnd = CurMethod->param_end(),
5677 SuperP = SuperMethod->param_begin();
5678 CurP != CurPEnd; ++CurP, ++SuperP) {
5679 // Make sure the parameter types are compatible.
5680 if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(),
5681 (*SuperP)->getType()))
5684 // Make sure we have a parameter name to forward!
5685 if (!(*CurP)->getIdentifier())
5689 // We have a superclass method. Now, form the send-to-super completion.
5690 CodeCompletionBuilder Builder(Results.getAllocator(),
5691 Results.getCodeCompletionTUInfo());
5693 // Give this completion a return type.
5694 AddResultTypeChunk(S.Context, getCompletionPrintingPolicy(S), SuperMethod,
5695 Results.getCompletionContext().getBaseType(),
5698 // If we need the "super" keyword, add it (plus some spacing).
5699 if (NeedSuperKeyword) {
5700 Builder.AddTypedTextChunk("super");
5701 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5704 Selector Sel = CurMethod->getSelector();
5705 if (Sel.isUnarySelector()) {
5706 if (NeedSuperKeyword)
5707 Builder.AddTextChunk(Builder.getAllocator().CopyString(
5708 Sel.getNameForSlot(0)));
5710 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
5711 Sel.getNameForSlot(0)));
5713 ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin();
5714 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) {
5715 if (I > SelIdents.size())
5716 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5718 if (I < SelIdents.size())
5719 Builder.AddInformativeChunk(
5720 Builder.getAllocator().CopyString(
5721 Sel.getNameForSlot(I) + ":"));
5722 else if (NeedSuperKeyword || I > SelIdents.size()) {
5723 Builder.AddTextChunk(
5724 Builder.getAllocator().CopyString(
5725 Sel.getNameForSlot(I) + ":"));
5726 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5727 (*CurP)->getIdentifier()->getName()));
5729 Builder.AddTypedTextChunk(
5730 Builder.getAllocator().CopyString(
5731 Sel.getNameForSlot(I) + ":"));
5732 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5733 (*CurP)->getIdentifier()->getName()));
5738 Results.AddResult(CodeCompletionResult(Builder.TakeString(), SuperMethod,
5739 CCP_SuperCompletion));
5743 void Sema::CodeCompleteObjCMessageReceiver(Scope *S) {
5744 typedef CodeCompletionResult Result;
5745 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5746 CodeCompleter->getCodeCompletionTUInfo(),
5747 CodeCompletionContext::CCC_ObjCMessageReceiver,
5748 getLangOpts().CPlusPlus11
5749 ? &ResultBuilder::IsObjCMessageReceiverOrLambdaCapture
5750 : &ResultBuilder::IsObjCMessageReceiver);
5752 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5753 Results.EnterNewScope();
5754 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5755 CodeCompleter->includeGlobals());
5757 // If we are in an Objective-C method inside a class that has a superclass,
5758 // add "super" as an option.
5759 if (ObjCMethodDecl *Method = getCurMethodDecl())
5760 if (ObjCInterfaceDecl *Iface = Method->getClassInterface())
5761 if (Iface->getSuperClass()) {
5762 Results.AddResult(Result("super"));
5764 AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, None, Results);
5767 if (getLangOpts().CPlusPlus11)
5768 addThisCompletion(*this, Results);
5770 Results.ExitScope();
5772 if (CodeCompleter->includeMacros())
5773 AddMacroResults(PP, Results, false);
5774 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5775 Results.data(), Results.size());
5779 void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
5780 ArrayRef<IdentifierInfo *> SelIdents,
5781 bool AtArgumentExpression) {
5782 ObjCInterfaceDecl *CDecl = nullptr;
5783 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5784 // Figure out which interface we're in.
5785 CDecl = CurMethod->getClassInterface();
5789 // Find the superclass of this class.
5790 CDecl = CDecl->getSuperClass();
5794 if (CurMethod->isInstanceMethod()) {
5795 // We are inside an instance method, which means that the message
5796 // send [super ...] is actually calling an instance method on the
5798 return CodeCompleteObjCInstanceMessage(S, nullptr, SelIdents,
5799 AtArgumentExpression,
5803 // Fall through to send to the superclass in CDecl.
5805 // "super" may be the name of a type or variable. Figure out which
5807 IdentifierInfo *Super = getSuperIdentifier();
5808 NamedDecl *ND = LookupSingleName(S, Super, SuperLoc,
5809 LookupOrdinaryName);
5810 if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) {
5811 // "super" names an interface. Use it.
5812 } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) {
5813 if (const ObjCObjectType *Iface
5814 = Context.getTypeDeclType(TD)->getAs<ObjCObjectType>())
5815 CDecl = Iface->getInterface();
5816 } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) {
5817 // "super" names an unresolved type; we can't be more specific.
5819 // Assume that "super" names some kind of value and parse that way.
5821 SourceLocation TemplateKWLoc;
5823 id.setIdentifier(Super, SuperLoc);
5824 ExprResult SuperExpr = ActOnIdExpression(S, SS, TemplateKWLoc, id,
5826 return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
5828 AtArgumentExpression);
5834 ParsedType Receiver;
5836 Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl));
5837 return CodeCompleteObjCClassMessage(S, Receiver, SelIdents,
5838 AtArgumentExpression,
5842 /// \brief Given a set of code-completion results for the argument of a message
5843 /// send, determine the preferred type (if any) for that argument expression.
5844 static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
5845 unsigned NumSelIdents) {
5846 typedef CodeCompletionResult Result;
5847 ASTContext &Context = Results.getSema().Context;
5849 QualType PreferredType;
5850 unsigned BestPriority = CCP_Unlikely * 2;
5851 Result *ResultsData = Results.data();
5852 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
5853 Result &R = ResultsData[I];
5854 if (R.Kind == Result::RK_Declaration &&
5855 isa<ObjCMethodDecl>(R.Declaration)) {
5856 if (R.Priority <= BestPriority) {
5857 const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration);
5858 if (NumSelIdents <= Method->param_size()) {
5859 QualType MyPreferredType = Method->parameters()[NumSelIdents - 1]
5861 if (R.Priority < BestPriority || PreferredType.isNull()) {
5862 BestPriority = R.Priority;
5863 PreferredType = MyPreferredType;
5864 } else if (!Context.hasSameUnqualifiedType(PreferredType,
5866 PreferredType = QualType();
5873 return PreferredType;
5876 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
5877 ParsedType Receiver,
5878 ArrayRef<IdentifierInfo *> SelIdents,
5879 bool AtArgumentExpression,
5881 ResultBuilder &Results) {
5882 typedef CodeCompletionResult Result;
5883 ObjCInterfaceDecl *CDecl = nullptr;
5885 // If the given name refers to an interface type, retrieve the
5886 // corresponding declaration.
5888 QualType T = SemaRef.GetTypeFromParser(Receiver, nullptr);
5890 if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>())
5891 CDecl = Interface->getInterface();
5894 // Add all of the factory methods in this Objective-C class, its protocols,
5895 // superclasses, categories, implementation, etc.
5896 Results.EnterNewScope();
5898 // If this is a send-to-super, try to add the special "super" send
5901 if (ObjCMethodDecl *SuperMethod
5902 = AddSuperSendCompletion(SemaRef, false, SelIdents, Results))
5903 Results.Ignore(SuperMethod);
5906 // If we're inside an Objective-C method definition, prefer its selector to
5908 if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl())
5909 Results.setPreferredSelector(CurMethod->getSelector());
5911 VisitedSelectorSet Selectors;
5913 AddObjCMethods(CDecl, false, MK_Any, SelIdents,
5914 SemaRef.CurContext, Selectors, AtArgumentExpression,
5917 // We're messaging "id" as a type; provide all class/factory methods.
5919 // If we have an external source, load the entire class method
5920 // pool from the AST file.
5921 if (SemaRef.getExternalSource()) {
5922 for (uint32_t I = 0,
5923 N = SemaRef.getExternalSource()->GetNumExternalSelectors();
5925 Selector Sel = SemaRef.getExternalSource()->GetExternalSelector(I);
5926 if (Sel.isNull() || SemaRef.MethodPool.count(Sel))
5929 SemaRef.ReadMethodPool(Sel);
5933 for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(),
5934 MEnd = SemaRef.MethodPool.end();
5936 for (ObjCMethodList *MethList = &M->second.second;
5937 MethList && MethList->getMethod();
5938 MethList = MethList->getNext()) {
5939 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
5942 Result R(MethList->getMethod(),
5943 Results.getBasePriority(MethList->getMethod()), nullptr);
5944 R.StartParameter = SelIdents.size();
5945 R.AllParametersAreInformative = false;
5946 Results.MaybeAddResult(R, SemaRef.CurContext);
5951 Results.ExitScope();
5954 void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
5955 ArrayRef<IdentifierInfo *> SelIdents,
5956 bool AtArgumentExpression,
5959 QualType T = this->GetTypeFromParser(Receiver);
5961 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5962 CodeCompleter->getCodeCompletionTUInfo(),
5963 CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage,
5966 AddClassMessageCompletions(*this, S, Receiver, SelIdents,
5967 AtArgumentExpression, IsSuper, Results);
5969 // If we're actually at the argument expression (rather than prior to the
5970 // selector), we're actually performing code completion for an expression.
5971 // Determine whether we have a single, best method. If so, we can
5972 // code-complete the expression using the corresponding parameter type as
5973 // our preferred type, improving completion results.
5974 if (AtArgumentExpression) {
5975 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
5977 if (PreferredType.isNull())
5978 CodeCompleteOrdinaryName(S, PCC_Expression);
5980 CodeCompleteExpression(S, PreferredType);
5984 HandleCodeCompleteResults(this, CodeCompleter,
5985 Results.getCompletionContext(),
5986 Results.data(), Results.size());
5989 void Sema::CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
5990 ArrayRef<IdentifierInfo *> SelIdents,
5991 bool AtArgumentExpression,
5992 ObjCInterfaceDecl *Super) {
5993 typedef CodeCompletionResult Result;
5995 Expr *RecExpr = static_cast<Expr *>(Receiver);
5997 // If necessary, apply function/array conversion to the receiver.
5998 // C99 6.7.5.3p[7,8].
6000 ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr);
6001 if (Conv.isInvalid()) // conversion failed. bail.
6003 RecExpr = Conv.get();
6005 QualType ReceiverType = RecExpr? RecExpr->getType()
6006 : Super? Context.getObjCObjectPointerType(
6007 Context.getObjCInterfaceType(Super))
6008 : Context.getObjCIdType();
6010 // If we're messaging an expression with type "id" or "Class", check
6011 // whether we know something special about the receiver that allows
6012 // us to assume a more-specific receiver type.
6013 if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType()) {
6014 if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) {
6015 if (ReceiverType->isObjCClassType())
6016 return CodeCompleteObjCClassMessage(S,
6017 ParsedType::make(Context.getObjCInterfaceType(IFace)),
6019 AtArgumentExpression, Super);
6021 ReceiverType = Context.getObjCObjectPointerType(
6022 Context.getObjCInterfaceType(IFace));
6024 } else if (RecExpr && getLangOpts().CPlusPlus) {
6025 ExprResult Conv = PerformContextuallyConvertToObjCPointer(RecExpr);
6026 if (Conv.isUsable()) {
6027 RecExpr = Conv.get();
6028 ReceiverType = RecExpr->getType();
6032 // Build the set of methods we can see.
6033 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6034 CodeCompleter->getCodeCompletionTUInfo(),
6035 CodeCompletionContext(CodeCompletionContext::CCC_ObjCInstanceMessage,
6036 ReceiverType, SelIdents));
6038 Results.EnterNewScope();
6040 // If this is a send-to-super, try to add the special "super" send
6043 if (ObjCMethodDecl *SuperMethod
6044 = AddSuperSendCompletion(*this, false, SelIdents, Results))
6045 Results.Ignore(SuperMethod);
6048 // If we're inside an Objective-C method definition, prefer its selector to
6050 if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
6051 Results.setPreferredSelector(CurMethod->getSelector());
6053 // Keep track of the selectors we've already added.
6054 VisitedSelectorSet Selectors;
6056 // Handle messages to Class. This really isn't a message to an instance
6057 // method, so we treat it the same way we would treat a message send to a
6059 if (ReceiverType->isObjCClassType() ||
6060 ReceiverType->isObjCQualifiedClassType()) {
6061 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
6062 if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface())
6063 AddObjCMethods(ClassDecl, false, MK_Any, SelIdents,
6064 CurContext, Selectors, AtArgumentExpression, Results);
6067 // Handle messages to a qualified ID ("id<foo>").
6068 else if (const ObjCObjectPointerType *QualID
6069 = ReceiverType->getAsObjCQualifiedIdType()) {
6070 // Search protocols for instance methods.
6071 for (auto *I : QualID->quals())
6072 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
6073 Selectors, AtArgumentExpression, Results);
6075 // Handle messages to a pointer to interface type.
6076 else if (const ObjCObjectPointerType *IFacePtr
6077 = ReceiverType->getAsObjCInterfacePointerType()) {
6078 // Search the class, its superclasses, etc., for instance methods.
6079 AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents,
6080 CurContext, Selectors, AtArgumentExpression,
6083 // Search protocols for instance methods.
6084 for (auto *I : IFacePtr->quals())
6085 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
6086 Selectors, AtArgumentExpression, Results);
6088 // Handle messages to "id".
6089 else if (ReceiverType->isObjCIdType()) {
6090 // We're messaging "id", so provide all instance methods we know
6091 // about as code-completion results.
6093 // If we have an external source, load the entire class method
6094 // pool from the AST file.
6095 if (ExternalSource) {
6096 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
6098 Selector Sel = ExternalSource->GetExternalSelector(I);
6099 if (Sel.isNull() || MethodPool.count(Sel))
6102 ReadMethodPool(Sel);
6106 for (GlobalMethodPool::iterator M = MethodPool.begin(),
6107 MEnd = MethodPool.end();
6109 for (ObjCMethodList *MethList = &M->second.first;
6110 MethList && MethList->getMethod();
6111 MethList = MethList->getNext()) {
6112 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
6115 if (!Selectors.insert(MethList->getMethod()->getSelector()).second)
6118 Result R(MethList->getMethod(),
6119 Results.getBasePriority(MethList->getMethod()), nullptr);
6120 R.StartParameter = SelIdents.size();
6121 R.AllParametersAreInformative = false;
6122 Results.MaybeAddResult(R, CurContext);
6126 Results.ExitScope();
6129 // If we're actually at the argument expression (rather than prior to the
6130 // selector), we're actually performing code completion for an expression.
6131 // Determine whether we have a single, best method. If so, we can
6132 // code-complete the expression using the corresponding parameter type as
6133 // our preferred type, improving completion results.
6134 if (AtArgumentExpression) {
6135 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
6137 if (PreferredType.isNull())
6138 CodeCompleteOrdinaryName(S, PCC_Expression);
6140 CodeCompleteExpression(S, PreferredType);
6144 HandleCodeCompleteResults(this, CodeCompleter,
6145 Results.getCompletionContext(),
6146 Results.data(),Results.size());
6149 void Sema::CodeCompleteObjCForCollection(Scope *S,
6150 DeclGroupPtrTy IterationVar) {
6151 CodeCompleteExpressionData Data;
6152 Data.ObjCCollection = true;
6154 if (IterationVar.getAsOpaquePtr()) {
6155 DeclGroupRef DG = IterationVar.get();
6156 for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) {
6158 Data.IgnoreDecls.push_back(*I);
6162 CodeCompleteExpression(S, Data);
6165 void Sema::CodeCompleteObjCSelector(Scope *S,
6166 ArrayRef<IdentifierInfo *> SelIdents) {
6167 // If we have an external source, load the entire class method
6168 // pool from the AST file.
6169 if (ExternalSource) {
6170 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
6172 Selector Sel = ExternalSource->GetExternalSelector(I);
6173 if (Sel.isNull() || MethodPool.count(Sel))
6176 ReadMethodPool(Sel);
6180 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6181 CodeCompleter->getCodeCompletionTUInfo(),
6182 CodeCompletionContext::CCC_SelectorName);
6183 Results.EnterNewScope();
6184 for (GlobalMethodPool::iterator M = MethodPool.begin(),
6185 MEnd = MethodPool.end();
6188 Selector Sel = M->first;
6189 if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents))
6192 CodeCompletionBuilder Builder(Results.getAllocator(),
6193 Results.getCodeCompletionTUInfo());
6194 if (Sel.isUnarySelector()) {
6195 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
6196 Sel.getNameForSlot(0)));
6197 Results.AddResult(Builder.TakeString());
6201 std::string Accumulator;
6202 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) {
6203 if (I == SelIdents.size()) {
6204 if (!Accumulator.empty()) {
6205 Builder.AddInformativeChunk(Builder.getAllocator().CopyString(
6207 Accumulator.clear();
6211 Accumulator += Sel.getNameForSlot(I);
6214 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString( Accumulator));
6215 Results.AddResult(Builder.TakeString());
6217 Results.ExitScope();
6219 HandleCodeCompleteResults(this, CodeCompleter,
6220 CodeCompletionContext::CCC_SelectorName,
6221 Results.data(), Results.size());
6224 /// \brief Add all of the protocol declarations that we find in the given
6225 /// (translation unit) context.
6226 static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext,
6227 bool OnlyForwardDeclarations,
6228 ResultBuilder &Results) {
6229 typedef CodeCompletionResult Result;
6231 for (const auto *D : Ctx->decls()) {
6232 // Record any protocols we find.
6233 if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(D))
6234 if (!OnlyForwardDeclarations || !Proto->hasDefinition())
6235 Results.AddResult(Result(Proto, Results.getBasePriority(Proto),nullptr),
6236 CurContext, nullptr, false);
6240 void Sema::CodeCompleteObjCProtocolReferences(
6241 ArrayRef<IdentifierLocPair> Protocols) {
6242 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6243 CodeCompleter->getCodeCompletionTUInfo(),
6244 CodeCompletionContext::CCC_ObjCProtocolName);
6246 if (CodeCompleter->includeGlobals()) {
6247 Results.EnterNewScope();
6249 // Tell the result set to ignore all of the protocols we have
6251 // FIXME: This doesn't work when caching code-completion results.
6252 for (const IdentifierLocPair &Pair : Protocols)
6253 if (ObjCProtocolDecl *Protocol = LookupProtocol(Pair.first,
6255 Results.Ignore(Protocol);
6257 // Add all protocols.
6258 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false,
6261 Results.ExitScope();
6264 HandleCodeCompleteResults(this, CodeCompleter,
6265 CodeCompletionContext::CCC_ObjCProtocolName,
6266 Results.data(),Results.size());
6269 void Sema::CodeCompleteObjCProtocolDecl(Scope *) {
6270 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6271 CodeCompleter->getCodeCompletionTUInfo(),
6272 CodeCompletionContext::CCC_ObjCProtocolName);
6274 if (CodeCompleter->includeGlobals()) {
6275 Results.EnterNewScope();
6277 // Add all protocols.
6278 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true,
6281 Results.ExitScope();
6284 HandleCodeCompleteResults(this, CodeCompleter,
6285 CodeCompletionContext::CCC_ObjCProtocolName,
6286 Results.data(),Results.size());
6289 /// \brief Add all of the Objective-C interface declarations that we find in
6290 /// the given (translation unit) context.
6291 static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext,
6292 bool OnlyForwardDeclarations,
6293 bool OnlyUnimplemented,
6294 ResultBuilder &Results) {
6295 typedef CodeCompletionResult Result;
6297 for (const auto *D : Ctx->decls()) {
6298 // Record any interfaces we find.
6299 if (const auto *Class = dyn_cast<ObjCInterfaceDecl>(D))
6300 if ((!OnlyForwardDeclarations || !Class->hasDefinition()) &&
6301 (!OnlyUnimplemented || !Class->getImplementation()))
6302 Results.AddResult(Result(Class, Results.getBasePriority(Class),nullptr),
6303 CurContext, nullptr, false);
6307 void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) {
6308 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6309 CodeCompleter->getCodeCompletionTUInfo(),
6310 CodeCompletionContext::CCC_Other);
6311 Results.EnterNewScope();
6313 if (CodeCompleter->includeGlobals()) {
6315 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6319 Results.ExitScope();
6321 HandleCodeCompleteResults(this, CodeCompleter,
6322 CodeCompletionContext::CCC_ObjCInterfaceName,
6323 Results.data(),Results.size());
6326 void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName,
6327 SourceLocation ClassNameLoc) {
6328 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6329 CodeCompleter->getCodeCompletionTUInfo(),
6330 CodeCompletionContext::CCC_ObjCInterfaceName);
6331 Results.EnterNewScope();
6333 // Make sure that we ignore the class we're currently defining.
6335 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6336 if (CurClass && isa<ObjCInterfaceDecl>(CurClass))
6337 Results.Ignore(CurClass);
6339 if (CodeCompleter->includeGlobals()) {
6341 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6345 Results.ExitScope();
6347 HandleCodeCompleteResults(this, CodeCompleter,
6348 CodeCompletionContext::CCC_ObjCInterfaceName,
6349 Results.data(),Results.size());
6352 void Sema::CodeCompleteObjCImplementationDecl(Scope *S) {
6353 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6354 CodeCompleter->getCodeCompletionTUInfo(),
6355 CodeCompletionContext::CCC_Other);
6356 Results.EnterNewScope();
6358 if (CodeCompleter->includeGlobals()) {
6359 // Add all unimplemented classes.
6360 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6364 Results.ExitScope();
6366 HandleCodeCompleteResults(this, CodeCompleter,
6367 CodeCompletionContext::CCC_ObjCInterfaceName,
6368 Results.data(),Results.size());
6371 void Sema::CodeCompleteObjCInterfaceCategory(Scope *S,
6372 IdentifierInfo *ClassName,
6373 SourceLocation ClassNameLoc) {
6374 typedef CodeCompletionResult Result;
6376 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6377 CodeCompleter->getCodeCompletionTUInfo(),
6378 CodeCompletionContext::CCC_ObjCCategoryName);
6380 // Ignore any categories we find that have already been implemented by this
6382 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
6384 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6385 if (ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)){
6386 for (const auto *Cat : Class->visible_categories())
6387 CategoryNames.insert(Cat->getIdentifier());
6390 // Add all of the categories we know about.
6391 Results.EnterNewScope();
6392 TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
6393 for (const auto *D : TU->decls())
6394 if (const auto *Category = dyn_cast<ObjCCategoryDecl>(D))
6395 if (CategoryNames.insert(Category->getIdentifier()).second)
6396 Results.AddResult(Result(Category, Results.getBasePriority(Category),
6398 CurContext, nullptr, false);
6399 Results.ExitScope();
6401 HandleCodeCompleteResults(this, CodeCompleter,
6402 CodeCompletionContext::CCC_ObjCCategoryName,
6403 Results.data(),Results.size());
6406 void Sema::CodeCompleteObjCImplementationCategory(Scope *S,
6407 IdentifierInfo *ClassName,
6408 SourceLocation ClassNameLoc) {
6409 typedef CodeCompletionResult Result;
6411 // Find the corresponding interface. If we couldn't find the interface, the
6412 // program itself is ill-formed. However, we'll try to be helpful still by
6413 // providing the list of all of the categories we know about.
6415 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6416 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass);
6418 return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc);
6420 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6421 CodeCompleter->getCodeCompletionTUInfo(),
6422 CodeCompletionContext::CCC_ObjCCategoryName);
6424 // Add all of the categories that have have corresponding interface
6425 // declarations in this class and any of its superclasses, except for
6426 // already-implemented categories in the class itself.
6427 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
6428 Results.EnterNewScope();
6429 bool IgnoreImplemented = true;
6431 for (const auto *Cat : Class->visible_categories()) {
6432 if ((!IgnoreImplemented || !Cat->getImplementation()) &&
6433 CategoryNames.insert(Cat->getIdentifier()).second)
6434 Results.AddResult(Result(Cat, Results.getBasePriority(Cat), nullptr),
6435 CurContext, nullptr, false);
6438 Class = Class->getSuperClass();
6439 IgnoreImplemented = false;
6441 Results.ExitScope();
6443 HandleCodeCompleteResults(this, CodeCompleter,
6444 CodeCompletionContext::CCC_ObjCCategoryName,
6445 Results.data(),Results.size());
6448 void Sema::CodeCompleteObjCPropertyDefinition(Scope *S) {
6449 CodeCompletionContext CCContext(CodeCompletionContext::CCC_Other);
6450 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6451 CodeCompleter->getCodeCompletionTUInfo(),
6454 // Figure out where this @synthesize lives.
6455 ObjCContainerDecl *Container
6456 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6458 (!isa<ObjCImplementationDecl>(Container) &&
6459 !isa<ObjCCategoryImplDecl>(Container)))
6462 // Ignore any properties that have already been implemented.
6463 Container = getContainerDef(Container);
6464 for (const auto *D : Container->decls())
6465 if (const auto *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(D))
6466 Results.Ignore(PropertyImpl->getPropertyDecl());
6468 // Add any properties that we find.
6469 AddedPropertiesSet AddedProperties;
6470 Results.EnterNewScope();
6471 if (ObjCImplementationDecl *ClassImpl
6472 = dyn_cast<ObjCImplementationDecl>(Container))
6473 AddObjCProperties(CCContext, ClassImpl->getClassInterface(), false,
6474 /*AllowNullaryMethods=*/false, CurContext,
6475 AddedProperties, Results);
6477 AddObjCProperties(CCContext,
6478 cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(),
6479 false, /*AllowNullaryMethods=*/false, CurContext,
6480 AddedProperties, Results);
6481 Results.ExitScope();
6483 HandleCodeCompleteResults(this, CodeCompleter,
6484 CodeCompletionContext::CCC_Other,
6485 Results.data(),Results.size());
6488 void Sema::CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
6489 IdentifierInfo *PropertyName) {
6490 typedef CodeCompletionResult Result;
6491 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6492 CodeCompleter->getCodeCompletionTUInfo(),
6493 CodeCompletionContext::CCC_Other);
6495 // Figure out where this @synthesize lives.
6496 ObjCContainerDecl *Container
6497 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6499 (!isa<ObjCImplementationDecl>(Container) &&
6500 !isa<ObjCCategoryImplDecl>(Container)))
6503 // Figure out which interface we're looking into.
6504 ObjCInterfaceDecl *Class = nullptr;
6505 if (ObjCImplementationDecl *ClassImpl
6506 = dyn_cast<ObjCImplementationDecl>(Container))
6507 Class = ClassImpl->getClassInterface();
6509 Class = cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl()
6510 ->getClassInterface();
6512 // Determine the type of the property we're synthesizing.
6513 QualType PropertyType = Context.getObjCIdType();
6515 if (ObjCPropertyDecl *Property = Class->FindPropertyDeclaration(
6516 PropertyName, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
6518 = Property->getType().getNonReferenceType().getUnqualifiedType();
6520 // Give preference to ivars
6521 Results.setPreferredType(PropertyType);
6525 // Add all of the instance variables in this class and its superclasses.
6526 Results.EnterNewScope();
6527 bool SawSimilarlyNamedIvar = false;
6528 std::string NameWithPrefix;
6529 NameWithPrefix += '_';
6530 NameWithPrefix += PropertyName->getName();
6531 std::string NameWithSuffix = PropertyName->getName().str();
6532 NameWithSuffix += '_';
6533 for(; Class; Class = Class->getSuperClass()) {
6534 for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar;
6535 Ivar = Ivar->getNextIvar()) {
6536 Results.AddResult(Result(Ivar, Results.getBasePriority(Ivar), nullptr),
6537 CurContext, nullptr, false);
6539 // Determine whether we've seen an ivar with a name similar to the
6541 if ((PropertyName == Ivar->getIdentifier() ||
6542 NameWithPrefix == Ivar->getName() ||
6543 NameWithSuffix == Ivar->getName())) {
6544 SawSimilarlyNamedIvar = true;
6546 // Reduce the priority of this result by one, to give it a slight
6547 // advantage over other results whose names don't match so closely.
6548 if (Results.size() &&
6549 Results.data()[Results.size() - 1].Kind
6550 == CodeCompletionResult::RK_Declaration &&
6551 Results.data()[Results.size() - 1].Declaration == Ivar)
6552 Results.data()[Results.size() - 1].Priority--;
6557 if (!SawSimilarlyNamedIvar) {
6558 // Create ivar result _propName, that the user can use to synthesize
6559 // an ivar of the appropriate type.
6560 unsigned Priority = CCP_MemberDeclaration + 1;
6561 typedef CodeCompletionResult Result;
6562 CodeCompletionAllocator &Allocator = Results.getAllocator();
6563 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo(),
6564 Priority,CXAvailability_Available);
6566 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
6567 Builder.AddResultTypeChunk(GetCompletionTypeString(PropertyType, Context,
6568 Policy, Allocator));
6569 Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix));
6570 Results.AddResult(Result(Builder.TakeString(), Priority,
6571 CXCursor_ObjCIvarDecl));
6574 Results.ExitScope();
6576 HandleCodeCompleteResults(this, CodeCompleter,
6577 CodeCompletionContext::CCC_Other,
6578 Results.data(),Results.size());
6581 // Mapping from selectors to the methods that implement that selector, along
6582 // with the "in original class" flag.
6583 typedef llvm::DenseMap<
6584 Selector, llvm::PointerIntPair<ObjCMethodDecl *, 1, bool> > KnownMethodsMap;
6586 /// \brief Find all of the methods that reside in the given container
6587 /// (and its superclasses, protocols, etc.) that meet the given
6588 /// criteria. Insert those methods into the map of known methods,
6589 /// indexed by selector so they can be easily found.
6590 static void FindImplementableMethods(ASTContext &Context,
6591 ObjCContainerDecl *Container,
6592 bool WantInstanceMethods,
6593 QualType ReturnType,
6594 KnownMethodsMap &KnownMethods,
6595 bool InOriginalClass = true) {
6596 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) {
6597 // Make sure we have a definition; that's what we'll walk.
6598 if (!IFace->hasDefinition())
6601 IFace = IFace->getDefinition();
6604 const ObjCList<ObjCProtocolDecl> &Protocols
6605 = IFace->getReferencedProtocols();
6606 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6607 E = Protocols.end();
6609 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6610 KnownMethods, InOriginalClass);
6612 // Add methods from any class extensions and categories.
6613 for (auto *Cat : IFace->visible_categories()) {
6614 FindImplementableMethods(Context, Cat, WantInstanceMethods, ReturnType,
6615 KnownMethods, false);
6618 // Visit the superclass.
6619 if (IFace->getSuperClass())
6620 FindImplementableMethods(Context, IFace->getSuperClass(),
6621 WantInstanceMethods, ReturnType,
6622 KnownMethods, false);
6625 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
6626 // Recurse into protocols.
6627 const ObjCList<ObjCProtocolDecl> &Protocols
6628 = Category->getReferencedProtocols();
6629 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6630 E = Protocols.end();
6632 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6633 KnownMethods, InOriginalClass);
6635 // If this category is the original class, jump to the interface.
6636 if (InOriginalClass && Category->getClassInterface())
6637 FindImplementableMethods(Context, Category->getClassInterface(),
6638 WantInstanceMethods, ReturnType, KnownMethods,
6642 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
6643 // Make sure we have a definition; that's what we'll walk.
6644 if (!Protocol->hasDefinition())
6646 Protocol = Protocol->getDefinition();
6647 Container = Protocol;
6649 // Recurse into protocols.
6650 const ObjCList<ObjCProtocolDecl> &Protocols
6651 = Protocol->getReferencedProtocols();
6652 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6653 E = Protocols.end();
6655 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6656 KnownMethods, false);
6659 // Add methods in this container. This operation occurs last because
6660 // we want the methods from this container to override any methods
6661 // we've previously seen with the same selector.
6662 for (auto *M : Container->methods()) {
6663 if (M->isInstanceMethod() == WantInstanceMethods) {
6664 if (!ReturnType.isNull() &&
6665 !Context.hasSameUnqualifiedType(ReturnType, M->getReturnType()))
6668 KnownMethods[M->getSelector()] =
6669 KnownMethodsMap::mapped_type(M, InOriginalClass);
6674 /// \brief Add the parenthesized return or parameter type chunk to a code
6675 /// completion string.
6676 static void AddObjCPassingTypeChunk(QualType Type,
6677 unsigned ObjCDeclQuals,
6678 ASTContext &Context,
6679 const PrintingPolicy &Policy,
6680 CodeCompletionBuilder &Builder) {
6681 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6682 std::string Quals = formatObjCParamQualifiers(ObjCDeclQuals, Type);
6684 Builder.AddTextChunk(Builder.getAllocator().CopyString(Quals));
6685 Builder.AddTextChunk(GetCompletionTypeString(Type, Context, Policy,
6686 Builder.getAllocator()));
6687 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6690 /// \brief Determine whether the given class is or inherits from a class by
6692 static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class,
6697 if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name)
6700 return InheritsFromClassNamed(Class->getSuperClass(), Name);
6703 /// \brief Add code completions for Objective-C Key-Value Coding (KVC) and
6704 /// Key-Value Observing (KVO).
6705 static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property,
6706 bool IsInstanceMethod,
6707 QualType ReturnType,
6708 ASTContext &Context,
6709 VisitedSelectorSet &KnownSelectors,
6710 ResultBuilder &Results) {
6711 IdentifierInfo *PropName = Property->getIdentifier();
6712 if (!PropName || PropName->getLength() == 0)
6715 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
6717 // Builder that will create each code completion.
6718 typedef CodeCompletionResult Result;
6719 CodeCompletionAllocator &Allocator = Results.getAllocator();
6720 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
6722 // The selector table.
6723 SelectorTable &Selectors = Context.Selectors;
6725 // The property name, copied into the code completion allocation region
6728 CodeCompletionAllocator &Allocator;
6730 const char *CopiedKey;
6732 KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key)
6733 : Allocator(Allocator), Key(Key), CopiedKey(nullptr) {}
6735 operator const char *() {
6739 return CopiedKey = Allocator.CopyString(Key);
6741 } Key(Allocator, PropName->getName());
6743 // The uppercased name of the property name.
6744 std::string UpperKey = PropName->getName();
6745 if (!UpperKey.empty())
6746 UpperKey[0] = toUppercase(UpperKey[0]);
6748 bool ReturnTypeMatchesProperty = ReturnType.isNull() ||
6749 Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(),
6750 Property->getType());
6751 bool ReturnTypeMatchesVoid
6752 = ReturnType.isNull() || ReturnType->isVoidType();
6754 // Add the normal accessor -(type)key.
6755 if (IsInstanceMethod &&
6756 KnownSelectors.insert(Selectors.getNullarySelector(PropName)).second &&
6757 ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) {
6758 if (ReturnType.isNull())
6759 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6760 Context, Policy, Builder);
6762 Builder.AddTypedTextChunk(Key);
6763 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6764 CXCursor_ObjCInstanceMethodDecl));
6767 // If we have an integral or boolean property (or the user has provided
6768 // an integral or boolean return type), add the accessor -(type)isKey.
6769 if (IsInstanceMethod &&
6770 ((!ReturnType.isNull() &&
6771 (ReturnType->isIntegerType() || ReturnType->isBooleanType())) ||
6772 (ReturnType.isNull() &&
6773 (Property->getType()->isIntegerType() ||
6774 Property->getType()->isBooleanType())))) {
6775 std::string SelectorName = (Twine("is") + UpperKey).str();
6776 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6777 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6779 if (ReturnType.isNull()) {
6780 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6781 Builder.AddTextChunk("BOOL");
6782 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6785 Builder.AddTypedTextChunk(
6786 Allocator.CopyString(SelectorId->getName()));
6787 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6788 CXCursor_ObjCInstanceMethodDecl));
6792 // Add the normal mutator.
6793 if (IsInstanceMethod && ReturnTypeMatchesVoid &&
6794 !Property->getSetterMethodDecl()) {
6795 std::string SelectorName = (Twine("set") + UpperKey).str();
6796 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6797 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6798 if (ReturnType.isNull()) {
6799 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6800 Builder.AddTextChunk("void");
6801 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6804 Builder.AddTypedTextChunk(
6805 Allocator.CopyString(SelectorId->getName()));
6806 Builder.AddTypedTextChunk(":");
6807 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6808 Context, Policy, Builder);
6809 Builder.AddTextChunk(Key);
6810 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6811 CXCursor_ObjCInstanceMethodDecl));
6815 // Indexed and unordered accessors
6816 unsigned IndexedGetterPriority = CCP_CodePattern;
6817 unsigned IndexedSetterPriority = CCP_CodePattern;
6818 unsigned UnorderedGetterPriority = CCP_CodePattern;
6819 unsigned UnorderedSetterPriority = CCP_CodePattern;
6820 if (const ObjCObjectPointerType *ObjCPointer
6821 = Property->getType()->getAs<ObjCObjectPointerType>()) {
6822 if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) {
6823 // If this interface type is not provably derived from a known
6824 // collection, penalize the corresponding completions.
6825 if (!InheritsFromClassNamed(IFace, "NSMutableArray")) {
6826 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6827 if (!InheritsFromClassNamed(IFace, "NSArray"))
6828 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6831 if (!InheritsFromClassNamed(IFace, "NSMutableSet")) {
6832 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6833 if (!InheritsFromClassNamed(IFace, "NSSet"))
6834 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6838 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6839 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6840 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6841 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6844 // Add -(NSUInteger)countOf<key>
6845 if (IsInstanceMethod &&
6846 (ReturnType.isNull() || ReturnType->isIntegerType())) {
6847 std::string SelectorName = (Twine("countOf") + UpperKey).str();
6848 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6849 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6851 if (ReturnType.isNull()) {
6852 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6853 Builder.AddTextChunk("NSUInteger");
6854 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6857 Builder.AddTypedTextChunk(
6858 Allocator.CopyString(SelectorId->getName()));
6859 Results.AddResult(Result(Builder.TakeString(),
6860 std::min(IndexedGetterPriority,
6861 UnorderedGetterPriority),
6862 CXCursor_ObjCInstanceMethodDecl));
6867 // Add -(id)objectInKeyAtIndex:(NSUInteger)index
6868 if (IsInstanceMethod &&
6869 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
6870 std::string SelectorName
6871 = (Twine("objectIn") + UpperKey + "AtIndex").str();
6872 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6873 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6874 if (ReturnType.isNull()) {
6875 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6876 Builder.AddTextChunk("id");
6877 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6880 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6881 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6882 Builder.AddTextChunk("NSUInteger");
6883 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6884 Builder.AddTextChunk("index");
6885 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6886 CXCursor_ObjCInstanceMethodDecl));
6890 // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes
6891 if (IsInstanceMethod &&
6892 (ReturnType.isNull() ||
6893 (ReturnType->isObjCObjectPointerType() &&
6894 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6895 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6896 ->getName() == "NSArray"))) {
6897 std::string SelectorName
6898 = (Twine(Property->getName()) + "AtIndexes").str();
6899 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6900 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6901 if (ReturnType.isNull()) {
6902 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6903 Builder.AddTextChunk("NSArray *");
6904 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6907 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6908 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6909 Builder.AddTextChunk("NSIndexSet *");
6910 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6911 Builder.AddTextChunk("indexes");
6912 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6913 CXCursor_ObjCInstanceMethodDecl));
6917 // Add -(void)getKey:(type **)buffer range:(NSRange)inRange
6918 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6919 std::string SelectorName = (Twine("get") + UpperKey).str();
6920 IdentifierInfo *SelectorIds[2] = {
6921 &Context.Idents.get(SelectorName),
6922 &Context.Idents.get("range")
6925 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6926 if (ReturnType.isNull()) {
6927 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6928 Builder.AddTextChunk("void");
6929 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6932 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6933 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6934 Builder.AddPlaceholderChunk("object-type");
6935 Builder.AddTextChunk(" **");
6936 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6937 Builder.AddTextChunk("buffer");
6938 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6939 Builder.AddTypedTextChunk("range:");
6940 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6941 Builder.AddTextChunk("NSRange");
6942 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6943 Builder.AddTextChunk("inRange");
6944 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6945 CXCursor_ObjCInstanceMethodDecl));
6949 // Mutable indexed accessors
6951 // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index
6952 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6953 std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str();
6954 IdentifierInfo *SelectorIds[2] = {
6955 &Context.Idents.get("insertObject"),
6956 &Context.Idents.get(SelectorName)
6959 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6960 if (ReturnType.isNull()) {
6961 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6962 Builder.AddTextChunk("void");
6963 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6966 Builder.AddTypedTextChunk("insertObject:");
6967 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6968 Builder.AddPlaceholderChunk("object-type");
6969 Builder.AddTextChunk(" *");
6970 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6971 Builder.AddTextChunk("object");
6972 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6973 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6974 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6975 Builder.AddPlaceholderChunk("NSUInteger");
6976 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6977 Builder.AddTextChunk("index");
6978 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6979 CXCursor_ObjCInstanceMethodDecl));
6983 // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes
6984 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6985 std::string SelectorName = (Twine("insert") + UpperKey).str();
6986 IdentifierInfo *SelectorIds[2] = {
6987 &Context.Idents.get(SelectorName),
6988 &Context.Idents.get("atIndexes")
6991 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6992 if (ReturnType.isNull()) {
6993 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6994 Builder.AddTextChunk("void");
6995 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6998 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6999 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7000 Builder.AddTextChunk("NSArray *");
7001 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7002 Builder.AddTextChunk("array");
7003 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7004 Builder.AddTypedTextChunk("atIndexes:");
7005 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7006 Builder.AddPlaceholderChunk("NSIndexSet *");
7007 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7008 Builder.AddTextChunk("indexes");
7009 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7010 CXCursor_ObjCInstanceMethodDecl));
7014 // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index
7015 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7016 std::string SelectorName
7017 = (Twine("removeObjectFrom") + UpperKey + "AtIndex").str();
7018 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7019 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7020 if (ReturnType.isNull()) {
7021 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7022 Builder.AddTextChunk("void");
7023 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7026 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7027 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7028 Builder.AddTextChunk("NSUInteger");
7029 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7030 Builder.AddTextChunk("index");
7031 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7032 CXCursor_ObjCInstanceMethodDecl));
7036 // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes
7037 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7038 std::string SelectorName
7039 = (Twine("remove") + UpperKey + "AtIndexes").str();
7040 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7041 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7042 if (ReturnType.isNull()) {
7043 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7044 Builder.AddTextChunk("void");
7045 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7048 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7049 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7050 Builder.AddTextChunk("NSIndexSet *");
7051 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7052 Builder.AddTextChunk("indexes");
7053 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7054 CXCursor_ObjCInstanceMethodDecl));
7058 // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object
7059 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7060 std::string SelectorName
7061 = (Twine("replaceObjectIn") + UpperKey + "AtIndex").str();
7062 IdentifierInfo *SelectorIds[2] = {
7063 &Context.Idents.get(SelectorName),
7064 &Context.Idents.get("withObject")
7067 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7068 if (ReturnType.isNull()) {
7069 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7070 Builder.AddTextChunk("void");
7071 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7074 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7075 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7076 Builder.AddPlaceholderChunk("NSUInteger");
7077 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7078 Builder.AddTextChunk("index");
7079 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7080 Builder.AddTypedTextChunk("withObject:");
7081 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7082 Builder.AddTextChunk("id");
7083 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7084 Builder.AddTextChunk("object");
7085 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7086 CXCursor_ObjCInstanceMethodDecl));
7090 // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array
7091 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7092 std::string SelectorName1
7093 = (Twine("replace") + UpperKey + "AtIndexes").str();
7094 std::string SelectorName2 = (Twine("with") + UpperKey).str();
7095 IdentifierInfo *SelectorIds[2] = {
7096 &Context.Idents.get(SelectorName1),
7097 &Context.Idents.get(SelectorName2)
7100 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7101 if (ReturnType.isNull()) {
7102 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7103 Builder.AddTextChunk("void");
7104 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7107 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName1 + ":"));
7108 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7109 Builder.AddPlaceholderChunk("NSIndexSet *");
7110 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7111 Builder.AddTextChunk("indexes");
7112 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7113 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":"));
7114 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7115 Builder.AddTextChunk("NSArray *");
7116 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7117 Builder.AddTextChunk("array");
7118 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7119 CXCursor_ObjCInstanceMethodDecl));
7123 // Unordered getters
7124 // - (NSEnumerator *)enumeratorOfKey
7125 if (IsInstanceMethod &&
7126 (ReturnType.isNull() ||
7127 (ReturnType->isObjCObjectPointerType() &&
7128 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7129 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
7130 ->getName() == "NSEnumerator"))) {
7131 std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str();
7132 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7133 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7135 if (ReturnType.isNull()) {
7136 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7137 Builder.AddTextChunk("NSEnumerator *");
7138 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7141 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7142 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
7143 CXCursor_ObjCInstanceMethodDecl));
7147 // - (type *)memberOfKey:(type *)object
7148 if (IsInstanceMethod &&
7149 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
7150 std::string SelectorName = (Twine("memberOf") + UpperKey).str();
7151 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7152 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7153 if (ReturnType.isNull()) {
7154 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7155 Builder.AddPlaceholderChunk("object-type");
7156 Builder.AddTextChunk(" *");
7157 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7160 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7161 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7162 if (ReturnType.isNull()) {
7163 Builder.AddPlaceholderChunk("object-type");
7164 Builder.AddTextChunk(" *");
7166 Builder.AddTextChunk(GetCompletionTypeString(ReturnType, Context,
7168 Builder.getAllocator()));
7170 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7171 Builder.AddTextChunk("object");
7172 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
7173 CXCursor_ObjCInstanceMethodDecl));
7177 // Mutable unordered accessors
7178 // - (void)addKeyObject:(type *)object
7179 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7180 std::string SelectorName
7181 = (Twine("add") + UpperKey + Twine("Object")).str();
7182 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7183 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7184 if (ReturnType.isNull()) {
7185 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7186 Builder.AddTextChunk("void");
7187 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7190 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7191 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7192 Builder.AddPlaceholderChunk("object-type");
7193 Builder.AddTextChunk(" *");
7194 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7195 Builder.AddTextChunk("object");
7196 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7197 CXCursor_ObjCInstanceMethodDecl));
7201 // - (void)addKey:(NSSet *)objects
7202 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7203 std::string SelectorName = (Twine("add") + UpperKey).str();
7204 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7205 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7206 if (ReturnType.isNull()) {
7207 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7208 Builder.AddTextChunk("void");
7209 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7212 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7213 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7214 Builder.AddTextChunk("NSSet *");
7215 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7216 Builder.AddTextChunk("objects");
7217 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7218 CXCursor_ObjCInstanceMethodDecl));
7222 // - (void)removeKeyObject:(type *)object
7223 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7224 std::string SelectorName
7225 = (Twine("remove") + UpperKey + Twine("Object")).str();
7226 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7227 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7228 if (ReturnType.isNull()) {
7229 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7230 Builder.AddTextChunk("void");
7231 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7234 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7235 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7236 Builder.AddPlaceholderChunk("object-type");
7237 Builder.AddTextChunk(" *");
7238 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7239 Builder.AddTextChunk("object");
7240 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7241 CXCursor_ObjCInstanceMethodDecl));
7245 // - (void)removeKey:(NSSet *)objects
7246 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7247 std::string SelectorName = (Twine("remove") + UpperKey).str();
7248 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7249 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7250 if (ReturnType.isNull()) {
7251 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7252 Builder.AddTextChunk("void");
7253 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7256 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7257 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7258 Builder.AddTextChunk("NSSet *");
7259 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7260 Builder.AddTextChunk("objects");
7261 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7262 CXCursor_ObjCInstanceMethodDecl));
7266 // - (void)intersectKey:(NSSet *)objects
7267 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7268 std::string SelectorName = (Twine("intersect") + UpperKey).str();
7269 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7270 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7271 if (ReturnType.isNull()) {
7272 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7273 Builder.AddTextChunk("void");
7274 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7277 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7278 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7279 Builder.AddTextChunk("NSSet *");
7280 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7281 Builder.AddTextChunk("objects");
7282 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7283 CXCursor_ObjCInstanceMethodDecl));
7287 // Key-Value Observing
7288 // + (NSSet *)keyPathsForValuesAffectingKey
7289 if (!IsInstanceMethod &&
7290 (ReturnType.isNull() ||
7291 (ReturnType->isObjCObjectPointerType() &&
7292 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7293 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
7294 ->getName() == "NSSet"))) {
7295 std::string SelectorName
7296 = (Twine("keyPathsForValuesAffecting") + UpperKey).str();
7297 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7298 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7300 if (ReturnType.isNull()) {
7301 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7302 Builder.AddTextChunk("NSSet<NSString *> *");
7303 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7306 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7307 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7308 CXCursor_ObjCClassMethodDecl));
7312 // + (BOOL)automaticallyNotifiesObserversForKey
7313 if (!IsInstanceMethod &&
7314 (ReturnType.isNull() ||
7315 ReturnType->isIntegerType() ||
7316 ReturnType->isBooleanType())) {
7317 std::string SelectorName
7318 = (Twine("automaticallyNotifiesObserversOf") + UpperKey).str();
7319 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7320 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7322 if (ReturnType.isNull()) {
7323 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7324 Builder.AddTextChunk("BOOL");
7325 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7328 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7329 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7330 CXCursor_ObjCClassMethodDecl));
7335 void Sema::CodeCompleteObjCMethodDecl(Scope *S,
7336 bool IsInstanceMethod,
7337 ParsedType ReturnTy) {
7338 // Determine the return type of the method we're declaring, if
7340 QualType ReturnType = GetTypeFromParser(ReturnTy);
7341 Decl *IDecl = nullptr;
7342 if (CurContext->isObjCContainer()) {
7343 ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
7344 IDecl = cast<Decl>(OCD);
7346 // Determine where we should start searching for methods.
7347 ObjCContainerDecl *SearchDecl = nullptr;
7348 bool IsInImplementation = false;
7349 if (Decl *D = IDecl) {
7350 if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) {
7351 SearchDecl = Impl->getClassInterface();
7352 IsInImplementation = true;
7353 } else if (ObjCCategoryImplDecl *CatImpl
7354 = dyn_cast<ObjCCategoryImplDecl>(D)) {
7355 SearchDecl = CatImpl->getCategoryDecl();
7356 IsInImplementation = true;
7358 SearchDecl = dyn_cast<ObjCContainerDecl>(D);
7361 if (!SearchDecl && S) {
7362 if (DeclContext *DC = S->getEntity())
7363 SearchDecl = dyn_cast<ObjCContainerDecl>(DC);
7367 HandleCodeCompleteResults(this, CodeCompleter,
7368 CodeCompletionContext::CCC_Other,
7373 // Find all of the methods that we could declare/implement here.
7374 KnownMethodsMap KnownMethods;
7375 FindImplementableMethods(Context, SearchDecl, IsInstanceMethod,
7376 ReturnType, KnownMethods);
7378 // Add declarations or definitions for each of the known methods.
7379 typedef CodeCompletionResult Result;
7380 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7381 CodeCompleter->getCodeCompletionTUInfo(),
7382 CodeCompletionContext::CCC_Other);
7383 Results.EnterNewScope();
7384 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
7385 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7386 MEnd = KnownMethods.end();
7388 ObjCMethodDecl *Method = M->second.getPointer();
7389 CodeCompletionBuilder Builder(Results.getAllocator(),
7390 Results.getCodeCompletionTUInfo());
7392 // If the result type was not already provided, add it to the
7393 // pattern as (type).
7394 if (ReturnType.isNull()) {
7395 QualType ResTy = Method->getSendResultType().stripObjCKindOfType(Context);
7396 AttributedType::stripOuterNullability(ResTy);
7397 AddObjCPassingTypeChunk(ResTy,
7398 Method->getObjCDeclQualifier(), Context, Policy,
7402 Selector Sel = Method->getSelector();
7404 // Add the first part of the selector to the pattern.
7405 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7406 Sel.getNameForSlot(0)));
7408 // Add parameters to the pattern.
7410 for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
7411 PEnd = Method->param_end();
7412 P != PEnd; (void)++P, ++I) {
7413 // Add the part of the selector name.
7415 Builder.AddTypedTextChunk(":");
7416 else if (I < Sel.getNumArgs()) {
7417 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7418 Builder.AddTypedTextChunk(
7419 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
7423 // Add the parameter type.
7425 if ((*P)->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
7426 ParamType = (*P)->getType();
7428 ParamType = (*P)->getOriginalType();
7429 ParamType = ParamType.substObjCTypeArgs(Context, {},
7430 ObjCSubstitutionContext::Parameter);
7431 AttributedType::stripOuterNullability(ParamType);
7432 AddObjCPassingTypeChunk(ParamType,
7433 (*P)->getObjCDeclQualifier(),
7437 if (IdentifierInfo *Id = (*P)->getIdentifier())
7438 Builder.AddTextChunk(Builder.getAllocator().CopyString( Id->getName()));
7441 if (Method->isVariadic()) {
7442 if (Method->param_size() > 0)
7443 Builder.AddChunk(CodeCompletionString::CK_Comma);
7444 Builder.AddTextChunk("...");
7447 if (IsInImplementation && Results.includeCodePatterns()) {
7448 // We will be defining the method here, so add a compound statement.
7449 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7450 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
7451 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
7452 if (!Method->getReturnType()->isVoidType()) {
7453 // If the result type is not void, add a return clause.
7454 Builder.AddTextChunk("return");
7455 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7456 Builder.AddPlaceholderChunk("expression");
7457 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
7459 Builder.AddPlaceholderChunk("statements");
7461 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
7462 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
7465 unsigned Priority = CCP_CodePattern;
7466 if (!M->second.getInt())
7467 Priority += CCD_InBaseClass;
7469 Results.AddResult(Result(Builder.TakeString(), Method, Priority));
7472 // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of
7473 // the properties in this class and its categories.
7474 if (Context.getLangOpts().ObjC2) {
7475 SmallVector<ObjCContainerDecl *, 4> Containers;
7476 Containers.push_back(SearchDecl);
7478 VisitedSelectorSet KnownSelectors;
7479 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7480 MEnd = KnownMethods.end();
7482 KnownSelectors.insert(M->first);
7485 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl);
7487 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl))
7488 IFace = Category->getClassInterface();
7491 for (auto *Cat : IFace->visible_categories())
7492 Containers.push_back(Cat);
7494 for (unsigned I = 0, N = Containers.size(); I != N; ++I)
7495 for (auto *P : Containers[I]->instance_properties())
7496 AddObjCKeyValueCompletions(P, IsInstanceMethod, ReturnType, Context,
7497 KnownSelectors, Results);
7500 Results.ExitScope();
7502 HandleCodeCompleteResults(this, CodeCompleter,
7503 CodeCompletionContext::CCC_Other,
7504 Results.data(),Results.size());
7507 void Sema::CodeCompleteObjCMethodDeclSelector(Scope *S,
7508 bool IsInstanceMethod,
7509 bool AtParameterName,
7510 ParsedType ReturnTy,
7511 ArrayRef<IdentifierInfo *> SelIdents) {
7512 // If we have an external source, load the entire class method
7513 // pool from the AST file.
7514 if (ExternalSource) {
7515 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
7517 Selector Sel = ExternalSource->GetExternalSelector(I);
7518 if (Sel.isNull() || MethodPool.count(Sel))
7521 ReadMethodPool(Sel);
7525 // Build the set of methods we can see.
7526 typedef CodeCompletionResult Result;
7527 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7528 CodeCompleter->getCodeCompletionTUInfo(),
7529 CodeCompletionContext::CCC_Other);
7532 Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType());
7534 Results.EnterNewScope();
7535 for (GlobalMethodPool::iterator M = MethodPool.begin(),
7536 MEnd = MethodPool.end();
7538 for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first :
7540 MethList && MethList->getMethod();
7541 MethList = MethList->getNext()) {
7542 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
7545 if (AtParameterName) {
7546 // Suggest parameter names we've seen before.
7547 unsigned NumSelIdents = SelIdents.size();
7549 NumSelIdents <= MethList->getMethod()->param_size()) {
7550 ParmVarDecl *Param =
7551 MethList->getMethod()->parameters()[NumSelIdents - 1];
7552 if (Param->getIdentifier()) {
7553 CodeCompletionBuilder Builder(Results.getAllocator(),
7554 Results.getCodeCompletionTUInfo());
7555 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7556 Param->getIdentifier()->getName()));
7557 Results.AddResult(Builder.TakeString());
7564 Result R(MethList->getMethod(),
7565 Results.getBasePriority(MethList->getMethod()), nullptr);
7566 R.StartParameter = SelIdents.size();
7567 R.AllParametersAreInformative = false;
7568 R.DeclaringEntity = true;
7569 Results.MaybeAddResult(R, CurContext);
7573 Results.ExitScope();
7575 if (!AtParameterName && !SelIdents.empty() &&
7576 SelIdents.front()->getName().startswith("init")) {
7577 for (const auto &M : PP.macros()) {
7578 if (M.first->getName() != "NS_DESIGNATED_INITIALIZER")
7580 Results.EnterNewScope();
7581 CodeCompletionBuilder Builder(Results.getAllocator(),
7582 Results.getCodeCompletionTUInfo());
7583 Builder.AddTypedTextChunk(
7584 Builder.getAllocator().CopyString(M.first->getName()));
7585 Results.AddResult(CodeCompletionResult(Builder.TakeString(), CCP_Macro,
7586 CXCursor_MacroDefinition));
7587 Results.ExitScope();
7591 HandleCodeCompleteResults(this, CodeCompleter,
7592 CodeCompletionContext::CCC_Other,
7593 Results.data(),Results.size());
7596 void Sema::CodeCompletePreprocessorDirective(bool InConditional) {
7597 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7598 CodeCompleter->getCodeCompletionTUInfo(),
7599 CodeCompletionContext::CCC_PreprocessorDirective);
7600 Results.EnterNewScope();
7603 CodeCompletionBuilder Builder(Results.getAllocator(),
7604 Results.getCodeCompletionTUInfo());
7605 Builder.AddTypedTextChunk("if");
7606 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7607 Builder.AddPlaceholderChunk("condition");
7608 Results.AddResult(Builder.TakeString());
7611 Builder.AddTypedTextChunk("ifdef");
7612 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7613 Builder.AddPlaceholderChunk("macro");
7614 Results.AddResult(Builder.TakeString());
7617 Builder.AddTypedTextChunk("ifndef");
7618 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7619 Builder.AddPlaceholderChunk("macro");
7620 Results.AddResult(Builder.TakeString());
7622 if (InConditional) {
7623 // #elif <condition>
7624 Builder.AddTypedTextChunk("elif");
7625 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7626 Builder.AddPlaceholderChunk("condition");
7627 Results.AddResult(Builder.TakeString());
7630 Builder.AddTypedTextChunk("else");
7631 Results.AddResult(Builder.TakeString());
7634 Builder.AddTypedTextChunk("endif");
7635 Results.AddResult(Builder.TakeString());
7638 // #include "header"
7639 Builder.AddTypedTextChunk("include");
7640 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7641 Builder.AddTextChunk("\"");
7642 Builder.AddPlaceholderChunk("header");
7643 Builder.AddTextChunk("\"");
7644 Results.AddResult(Builder.TakeString());
7646 // #include <header>
7647 Builder.AddTypedTextChunk("include");
7648 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7649 Builder.AddTextChunk("<");
7650 Builder.AddPlaceholderChunk("header");
7651 Builder.AddTextChunk(">");
7652 Results.AddResult(Builder.TakeString());
7655 Builder.AddTypedTextChunk("define");
7656 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7657 Builder.AddPlaceholderChunk("macro");
7658 Results.AddResult(Builder.TakeString());
7660 // #define <macro>(<args>)
7661 Builder.AddTypedTextChunk("define");
7662 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7663 Builder.AddPlaceholderChunk("macro");
7664 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7665 Builder.AddPlaceholderChunk("args");
7666 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7667 Results.AddResult(Builder.TakeString());
7670 Builder.AddTypedTextChunk("undef");
7671 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7672 Builder.AddPlaceholderChunk("macro");
7673 Results.AddResult(Builder.TakeString());
7676 Builder.AddTypedTextChunk("line");
7677 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7678 Builder.AddPlaceholderChunk("number");
7679 Results.AddResult(Builder.TakeString());
7681 // #line <number> "filename"
7682 Builder.AddTypedTextChunk("line");
7683 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7684 Builder.AddPlaceholderChunk("number");
7685 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7686 Builder.AddTextChunk("\"");
7687 Builder.AddPlaceholderChunk("filename");
7688 Builder.AddTextChunk("\"");
7689 Results.AddResult(Builder.TakeString());
7692 Builder.AddTypedTextChunk("error");
7693 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7694 Builder.AddPlaceholderChunk("message");
7695 Results.AddResult(Builder.TakeString());
7697 // #pragma <arguments>
7698 Builder.AddTypedTextChunk("pragma");
7699 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7700 Builder.AddPlaceholderChunk("arguments");
7701 Results.AddResult(Builder.TakeString());
7703 if (getLangOpts().ObjC1) {
7705 Builder.AddTypedTextChunk("import");
7706 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7707 Builder.AddTextChunk("\"");
7708 Builder.AddPlaceholderChunk("header");
7709 Builder.AddTextChunk("\"");
7710 Results.AddResult(Builder.TakeString());
7713 Builder.AddTypedTextChunk("import");
7714 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7715 Builder.AddTextChunk("<");
7716 Builder.AddPlaceholderChunk("header");
7717 Builder.AddTextChunk(">");
7718 Results.AddResult(Builder.TakeString());
7721 // #include_next "header"
7722 Builder.AddTypedTextChunk("include_next");
7723 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7724 Builder.AddTextChunk("\"");
7725 Builder.AddPlaceholderChunk("header");
7726 Builder.AddTextChunk("\"");
7727 Results.AddResult(Builder.TakeString());
7729 // #include_next <header>
7730 Builder.AddTypedTextChunk("include_next");
7731 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7732 Builder.AddTextChunk("<");
7733 Builder.AddPlaceholderChunk("header");
7734 Builder.AddTextChunk(">");
7735 Results.AddResult(Builder.TakeString());
7737 // #warning <message>
7738 Builder.AddTypedTextChunk("warning");
7739 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7740 Builder.AddPlaceholderChunk("message");
7741 Results.AddResult(Builder.TakeString());
7743 // Note: #ident and #sccs are such crazy anachronisms that we don't provide
7744 // completions for them. And __include_macros is a Clang-internal extension
7745 // that we don't want to encourage anyone to use.
7747 // FIXME: we don't support #assert or #unassert, so don't suggest them.
7748 Results.ExitScope();
7750 HandleCodeCompleteResults(this, CodeCompleter,
7751 CodeCompletionContext::CCC_PreprocessorDirective,
7752 Results.data(), Results.size());
7755 void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) {
7756 CodeCompleteOrdinaryName(S,
7757 S->getFnParent()? Sema::PCC_RecoveryInFunction
7758 : Sema::PCC_Namespace);
7761 void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) {
7762 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7763 CodeCompleter->getCodeCompletionTUInfo(),
7764 IsDefinition? CodeCompletionContext::CCC_MacroName
7765 : CodeCompletionContext::CCC_MacroNameUse);
7766 if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) {
7767 // Add just the names of macros, not their arguments.
7768 CodeCompletionBuilder Builder(Results.getAllocator(),
7769 Results.getCodeCompletionTUInfo());
7770 Results.EnterNewScope();
7771 for (Preprocessor::macro_iterator M = PP.macro_begin(),
7772 MEnd = PP.macro_end();
7774 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7775 M->first->getName()));
7776 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
7778 CXCursor_MacroDefinition));
7780 Results.ExitScope();
7781 } else if (IsDefinition) {
7782 // FIXME: Can we detect when the user just wrote an include guard above?
7785 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7786 Results.data(), Results.size());
7789 void Sema::CodeCompletePreprocessorExpression() {
7790 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7791 CodeCompleter->getCodeCompletionTUInfo(),
7792 CodeCompletionContext::CCC_PreprocessorExpression);
7794 if (!CodeCompleter || CodeCompleter->includeMacros())
7795 AddMacroResults(PP, Results, true);
7797 // defined (<macro>)
7798 Results.EnterNewScope();
7799 CodeCompletionBuilder Builder(Results.getAllocator(),
7800 Results.getCodeCompletionTUInfo());
7801 Builder.AddTypedTextChunk("defined");
7802 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7803 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7804 Builder.AddPlaceholderChunk("macro");
7805 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7806 Results.AddResult(Builder.TakeString());
7807 Results.ExitScope();
7809 HandleCodeCompleteResults(this, CodeCompleter,
7810 CodeCompletionContext::CCC_PreprocessorExpression,
7811 Results.data(), Results.size());
7814 void Sema::CodeCompletePreprocessorMacroArgument(Scope *S,
7815 IdentifierInfo *Macro,
7816 MacroInfo *MacroInfo,
7817 unsigned Argument) {
7818 // FIXME: In the future, we could provide "overload" results, much like we
7819 // do for function calls.
7821 // Now just ignore this. There will be another code-completion callback
7822 // for the expanded tokens.
7825 void Sema::CodeCompleteNaturalLanguage() {
7826 HandleCodeCompleteResults(this, CodeCompleter,
7827 CodeCompletionContext::CCC_NaturalLanguage,
7831 void Sema::CodeCompleteAvailabilityPlatformName() {
7832 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7833 CodeCompleter->getCodeCompletionTUInfo(),
7834 CodeCompletionContext::CCC_Other);
7835 Results.EnterNewScope();
7836 static const char *Platforms[] = {"macOS", "iOS", "watchOS", "tvOS"};
7837 for (const char *Platform : llvm::makeArrayRef(Platforms)) {
7838 Results.AddResult(CodeCompletionResult(Platform));
7839 Results.AddResult(CodeCompletionResult(Results.getAllocator().CopyString(
7840 Twine(Platform) + "ApplicationExtension")));
7842 Results.ExitScope();
7843 HandleCodeCompleteResults(this, CodeCompleter,
7844 CodeCompletionContext::CCC_Other, Results.data(),
7848 void Sema::GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,
7849 CodeCompletionTUInfo &CCTUInfo,
7850 SmallVectorImpl<CodeCompletionResult> &Results) {
7851 ResultBuilder Builder(*this, Allocator, CCTUInfo,
7852 CodeCompletionContext::CCC_Recovery);
7853 if (!CodeCompleter || CodeCompleter->includeGlobals()) {
7854 CodeCompletionDeclConsumer Consumer(Builder,
7855 Context.getTranslationUnitDecl());
7856 LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName,
7860 if (!CodeCompleter || CodeCompleter->includeMacros())
7861 AddMacroResults(PP, Builder, true);
7864 Results.insert(Results.end(),
7865 Builder.data(), Builder.data() + Builder.size());