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());
1865 // Fall through (for statement expressions).
1866 case Sema::PCC_ForInit:
1867 case Sema::PCC_Condition:
1868 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1869 // Fall through: conditions and statements can have expressions.
1872 case Sema::PCC_ParenthesizedExpression:
1873 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
1874 CCC == Sema::PCC_ParenthesizedExpression) {
1875 // (__bridge <type>)<expression>
1876 Builder.AddTypedTextChunk("__bridge");
1877 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1878 Builder.AddPlaceholderChunk("type");
1879 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1880 Builder.AddPlaceholderChunk("expression");
1881 Results.AddResult(Result(Builder.TakeString()));
1883 // (__bridge_transfer <Objective-C type>)<expression>
1884 Builder.AddTypedTextChunk("__bridge_transfer");
1885 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1886 Builder.AddPlaceholderChunk("Objective-C type");
1887 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1888 Builder.AddPlaceholderChunk("expression");
1889 Results.AddResult(Result(Builder.TakeString()));
1891 // (__bridge_retained <CF type>)<expression>
1892 Builder.AddTypedTextChunk("__bridge_retained");
1893 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1894 Builder.AddPlaceholderChunk("CF type");
1895 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1896 Builder.AddPlaceholderChunk("expression");
1897 Results.AddResult(Result(Builder.TakeString()));
1902 case Sema::PCC_Expression: {
1903 if (SemaRef.getLangOpts().CPlusPlus) {
1904 // 'this', if we're in a non-static member function.
1905 addThisCompletion(SemaRef, Results);
1908 Builder.AddResultTypeChunk("bool");
1909 Builder.AddTypedTextChunk("true");
1910 Results.AddResult(Result(Builder.TakeString()));
1913 Builder.AddResultTypeChunk("bool");
1914 Builder.AddTypedTextChunk("false");
1915 Results.AddResult(Result(Builder.TakeString()));
1917 if (SemaRef.getLangOpts().RTTI) {
1918 // dynamic_cast < type-id > ( expression )
1919 Builder.AddTypedTextChunk("dynamic_cast");
1920 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1921 Builder.AddPlaceholderChunk("type");
1922 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1923 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1924 Builder.AddPlaceholderChunk("expression");
1925 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1926 Results.AddResult(Result(Builder.TakeString()));
1929 // static_cast < type-id > ( expression )
1930 Builder.AddTypedTextChunk("static_cast");
1931 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1932 Builder.AddPlaceholderChunk("type");
1933 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1934 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1935 Builder.AddPlaceholderChunk("expression");
1936 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1937 Results.AddResult(Result(Builder.TakeString()));
1939 // reinterpret_cast < type-id > ( expression )
1940 Builder.AddTypedTextChunk("reinterpret_cast");
1941 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1942 Builder.AddPlaceholderChunk("type");
1943 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1944 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1945 Builder.AddPlaceholderChunk("expression");
1946 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1947 Results.AddResult(Result(Builder.TakeString()));
1949 // const_cast < type-id > ( expression )
1950 Builder.AddTypedTextChunk("const_cast");
1951 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1952 Builder.AddPlaceholderChunk("type");
1953 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1954 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1955 Builder.AddPlaceholderChunk("expression");
1956 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1957 Results.AddResult(Result(Builder.TakeString()));
1959 if (SemaRef.getLangOpts().RTTI) {
1960 // typeid ( expression-or-type )
1961 Builder.AddResultTypeChunk("std::type_info");
1962 Builder.AddTypedTextChunk("typeid");
1963 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1964 Builder.AddPlaceholderChunk("expression-or-type");
1965 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1966 Results.AddResult(Result(Builder.TakeString()));
1970 Builder.AddTypedTextChunk("new");
1971 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1972 Builder.AddPlaceholderChunk("type");
1973 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1974 Builder.AddPlaceholderChunk("expressions");
1975 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1976 Results.AddResult(Result(Builder.TakeString()));
1978 // new T [ ] ( ... )
1979 Builder.AddTypedTextChunk("new");
1980 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1981 Builder.AddPlaceholderChunk("type");
1982 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
1983 Builder.AddPlaceholderChunk("size");
1984 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
1985 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1986 Builder.AddPlaceholderChunk("expressions");
1987 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1988 Results.AddResult(Result(Builder.TakeString()));
1990 // delete expression
1991 Builder.AddResultTypeChunk("void");
1992 Builder.AddTypedTextChunk("delete");
1993 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1994 Builder.AddPlaceholderChunk("expression");
1995 Results.AddResult(Result(Builder.TakeString()));
1997 // delete [] expression
1998 Builder.AddResultTypeChunk("void");
1999 Builder.AddTypedTextChunk("delete");
2000 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2001 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
2002 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
2003 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2004 Builder.AddPlaceholderChunk("expression");
2005 Results.AddResult(Result(Builder.TakeString()));
2007 if (SemaRef.getLangOpts().CXXExceptions) {
2009 Builder.AddResultTypeChunk("void");
2010 Builder.AddTypedTextChunk("throw");
2011 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2012 Builder.AddPlaceholderChunk("expression");
2013 Results.AddResult(Result(Builder.TakeString()));
2018 if (SemaRef.getLangOpts().CPlusPlus11) {
2020 Builder.AddResultTypeChunk("std::nullptr_t");
2021 Builder.AddTypedTextChunk("nullptr");
2022 Results.AddResult(Result(Builder.TakeString()));
2025 Builder.AddResultTypeChunk("size_t");
2026 Builder.AddTypedTextChunk("alignof");
2027 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2028 Builder.AddPlaceholderChunk("type");
2029 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2030 Results.AddResult(Result(Builder.TakeString()));
2033 Builder.AddResultTypeChunk("bool");
2034 Builder.AddTypedTextChunk("noexcept");
2035 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2036 Builder.AddPlaceholderChunk("expression");
2037 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2038 Results.AddResult(Result(Builder.TakeString()));
2040 // sizeof... expression
2041 Builder.AddResultTypeChunk("size_t");
2042 Builder.AddTypedTextChunk("sizeof...");
2043 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2044 Builder.AddPlaceholderChunk("parameter-pack");
2045 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2046 Results.AddResult(Result(Builder.TakeString()));
2050 if (SemaRef.getLangOpts().ObjC1) {
2051 // Add "super", if we're in an Objective-C class with a superclass.
2052 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) {
2053 // The interface can be NULL.
2054 if (ObjCInterfaceDecl *ID = Method->getClassInterface())
2055 if (ID->getSuperClass()) {
2056 std::string SuperType;
2057 SuperType = ID->getSuperClass()->getNameAsString();
2058 if (Method->isInstanceMethod())
2061 Builder.AddResultTypeChunk(Allocator.CopyString(SuperType));
2062 Builder.AddTypedTextChunk("super");
2063 Results.AddResult(Result(Builder.TakeString()));
2067 AddObjCExpressionResults(Results, true);
2070 if (SemaRef.getLangOpts().C11) {
2072 Builder.AddResultTypeChunk("size_t");
2073 if (SemaRef.PP.isMacroDefined("alignof"))
2074 Builder.AddTypedTextChunk("alignof");
2076 Builder.AddTypedTextChunk("_Alignof");
2077 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2078 Builder.AddPlaceholderChunk("type");
2079 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2080 Results.AddResult(Result(Builder.TakeString()));
2083 // sizeof expression
2084 Builder.AddResultTypeChunk("size_t");
2085 Builder.AddTypedTextChunk("sizeof");
2086 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2087 Builder.AddPlaceholderChunk("expression-or-type");
2088 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2089 Results.AddResult(Result(Builder.TakeString()));
2093 case Sema::PCC_Type:
2094 case Sema::PCC_LocalDeclarationSpecifiers:
2098 if (WantTypesInContext(CCC, SemaRef.getLangOpts()))
2099 AddTypeSpecifierResults(SemaRef.getLangOpts(), Results);
2101 if (SemaRef.getLangOpts().CPlusPlus && CCC != Sema::PCC_Type)
2102 Results.AddResult(Result("operator"));
2105 /// \brief If the given declaration has an associated type, add it as a result
2107 static void AddResultTypeChunk(ASTContext &Context,
2108 const PrintingPolicy &Policy,
2109 const NamedDecl *ND,
2111 CodeCompletionBuilder &Result) {
2115 // Skip constructors and conversion functions, which have their return types
2116 // built into their names.
2117 if (isa<CXXConstructorDecl>(ND) || isa<CXXConversionDecl>(ND))
2120 // Determine the type of the declaration (if it has a type).
2122 if (const FunctionDecl *Function = ND->getAsFunction())
2123 T = Function->getReturnType();
2124 else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2125 if (!BaseType.isNull())
2126 T = Method->getSendResultType(BaseType);
2128 T = Method->getReturnType();
2129 } else if (const EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND))
2130 T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext()));
2131 else if (isa<UnresolvedUsingValueDecl>(ND)) {
2132 /* Do nothing: ignore unresolved using declarations*/
2133 } else if (const ObjCIvarDecl *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
2134 if (!BaseType.isNull())
2135 T = Ivar->getUsageType(BaseType);
2137 T = Ivar->getType();
2138 } else if (const ValueDecl *Value = dyn_cast<ValueDecl>(ND)) {
2139 T = Value->getType();
2140 } else if (const ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND)) {
2141 if (!BaseType.isNull())
2142 T = Property->getUsageType(BaseType);
2144 T = Property->getType();
2147 if (T.isNull() || Context.hasSameType(T, Context.DependentTy))
2150 Result.AddResultTypeChunk(GetCompletionTypeString(T, Context, Policy,
2151 Result.getAllocator()));
2154 static void MaybeAddSentinel(Preprocessor &PP,
2155 const NamedDecl *FunctionOrMethod,
2156 CodeCompletionBuilder &Result) {
2157 if (SentinelAttr *Sentinel = FunctionOrMethod->getAttr<SentinelAttr>())
2158 if (Sentinel->getSentinel() == 0) {
2159 if (PP.getLangOpts().ObjC1 && PP.isMacroDefined("nil"))
2160 Result.AddTextChunk(", nil");
2161 else if (PP.isMacroDefined("NULL"))
2162 Result.AddTextChunk(", NULL");
2164 Result.AddTextChunk(", (void*)0");
2168 static std::string formatObjCParamQualifiers(unsigned ObjCQuals,
2171 if (ObjCQuals & Decl::OBJC_TQ_In)
2173 else if (ObjCQuals & Decl::OBJC_TQ_Inout)
2175 else if (ObjCQuals & Decl::OBJC_TQ_Out)
2177 if (ObjCQuals & Decl::OBJC_TQ_Bycopy)
2178 Result += "bycopy ";
2179 else if (ObjCQuals & Decl::OBJC_TQ_Byref)
2181 if (ObjCQuals & Decl::OBJC_TQ_Oneway)
2182 Result += "oneway ";
2183 if (ObjCQuals & Decl::OBJC_TQ_CSNullability) {
2184 if (auto nullability = AttributedType::stripOuterNullability(Type)) {
2185 switch (*nullability) {
2186 case NullabilityKind::NonNull:
2187 Result += "nonnull ";
2190 case NullabilityKind::Nullable:
2191 Result += "nullable ";
2194 case NullabilityKind::Unspecified:
2195 Result += "null_unspecified ";
2203 /// \brief Tries to find the most appropriate type location for an Objective-C
2204 /// block placeholder.
2206 /// This function ignores things like typedefs and qualifiers in order to
2207 /// present the most relevant and accurate block placeholders in code completion
2209 static void findTypeLocationForBlockDecl(const TypeSourceInfo *TSInfo,
2210 FunctionTypeLoc &Block,
2211 FunctionProtoTypeLoc &BlockProto,
2212 bool SuppressBlock = false) {
2215 TypeLoc TL = TSInfo->getTypeLoc().getUnqualifiedLoc();
2217 // Look through typedefs.
2218 if (!SuppressBlock) {
2219 if (TypedefTypeLoc TypedefTL = TL.getAs<TypedefTypeLoc>()) {
2220 if (TypeSourceInfo *InnerTSInfo =
2221 TypedefTL.getTypedefNameDecl()->getTypeSourceInfo()) {
2222 TL = InnerTSInfo->getTypeLoc().getUnqualifiedLoc();
2227 // Look through qualified types
2228 if (QualifiedTypeLoc QualifiedTL = TL.getAs<QualifiedTypeLoc>()) {
2229 TL = QualifiedTL.getUnqualifiedLoc();
2233 if (AttributedTypeLoc AttrTL = TL.getAs<AttributedTypeLoc>()) {
2234 TL = AttrTL.getModifiedLoc();
2239 // Try to get the function prototype behind the block pointer type,
2241 if (BlockPointerTypeLoc BlockPtr = TL.getAs<BlockPointerTypeLoc>()) {
2242 TL = BlockPtr.getPointeeLoc().IgnoreParens();
2243 Block = TL.getAs<FunctionTypeLoc>();
2244 BlockProto = TL.getAs<FunctionProtoTypeLoc>();
2251 formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
2252 FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
2253 bool SuppressBlockName = false,
2254 bool SuppressBlock = false,
2255 Optional<ArrayRef<QualType>> ObjCSubsts = None);
2257 static std::string FormatFunctionParameter(const PrintingPolicy &Policy,
2258 const ParmVarDecl *Param,
2259 bool SuppressName = false,
2260 bool SuppressBlock = false,
2261 Optional<ArrayRef<QualType>> ObjCSubsts = None) {
2262 bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext());
2263 if (Param->getType()->isDependentType() ||
2264 !Param->getType()->isBlockPointerType()) {
2265 // The argument for a dependent or non-block parameter is a placeholder
2266 // containing that parameter's type.
2269 if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName)
2270 Result = Param->getIdentifier()->getName();
2272 QualType Type = Param->getType();
2274 Type = Type.substObjCTypeArgs(Param->getASTContext(), *ObjCSubsts,
2275 ObjCSubstitutionContext::Parameter);
2276 if (ObjCMethodParam) {
2277 Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(),
2279 Result += Type.getAsString(Policy) + ")";
2280 if (Param->getIdentifier() && !SuppressName)
2281 Result += Param->getIdentifier()->getName();
2283 Type.getAsStringInternal(Result, Policy);
2288 // The argument for a block pointer parameter is a block literal with
2289 // the appropriate type.
2290 FunctionTypeLoc Block;
2291 FunctionProtoTypeLoc BlockProto;
2292 findTypeLocationForBlockDecl(Param->getTypeSourceInfo(), Block, BlockProto,
2294 // Try to retrieve the block type information from the property if this is a
2295 // parameter in a setter.
2296 if (!Block && ObjCMethodParam &&
2297 cast<ObjCMethodDecl>(Param->getDeclContext())->isPropertyAccessor()) {
2298 if (const auto *PD = cast<ObjCMethodDecl>(Param->getDeclContext())
2299 ->findPropertyDecl(/*CheckOverrides=*/false))
2300 findTypeLocationForBlockDecl(PD->getTypeSourceInfo(), Block, BlockProto,
2305 // We were unable to find a FunctionProtoTypeLoc with parameter names
2306 // for the block; just use the parameter type as a placeholder.
2308 if (!ObjCMethodParam && Param->getIdentifier())
2309 Result = Param->getIdentifier()->getName();
2311 QualType Type = Param->getType().getUnqualifiedType();
2313 if (ObjCMethodParam) {
2314 Result = Type.getAsString(Policy);
2316 formatObjCParamQualifiers(Param->getObjCDeclQualifier(), Type);
2318 Result = "(" + Quals + " " + Result + ")";
2319 if (Result.back() != ')')
2321 if (Param->getIdentifier())
2322 Result += Param->getIdentifier()->getName();
2324 Type.getAsStringInternal(Result, Policy);
2330 // We have the function prototype behind the block pointer type, as it was
2331 // written in the source.
2332 return formatBlockPlaceholder(Policy, Param, Block, BlockProto,
2333 /*SuppressBlockName=*/false, SuppressBlock,
2337 /// \brief Returns a placeholder string that corresponds to an Objective-C block
2340 /// \param BlockDecl A declaration with an Objective-C block type.
2342 /// \param Block The most relevant type location for that block type.
2344 /// \param SuppressBlockName Determines wether or not the name of the block
2345 /// declaration is included in the resulting string.
2347 formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
2348 FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
2349 bool SuppressBlockName, bool SuppressBlock,
2350 Optional<ArrayRef<QualType>> ObjCSubsts) {
2352 QualType ResultType = Block.getTypePtr()->getReturnType();
2355 ResultType.substObjCTypeArgs(BlockDecl->getASTContext(), *ObjCSubsts,
2356 ObjCSubstitutionContext::Result);
2357 if (!ResultType->isVoidType() || SuppressBlock)
2358 ResultType.getAsStringInternal(Result, Policy);
2360 // Format the parameter list.
2362 if (!BlockProto || Block.getNumParams() == 0) {
2363 if (BlockProto && BlockProto.getTypePtr()->isVariadic())
2369 for (unsigned I = 0, N = Block.getNumParams(); I != N; ++I) {
2372 Params += FormatFunctionParameter(Policy, Block.getParam(I),
2373 /*SuppressName=*/false,
2374 /*SuppressBlock=*/true, ObjCSubsts);
2376 if (I == N - 1 && BlockProto.getTypePtr()->isVariadic())
2382 if (SuppressBlock) {
2383 // Format as a parameter.
2384 Result = Result + " (^";
2385 if (!SuppressBlockName && BlockDecl->getIdentifier())
2386 Result += BlockDecl->getIdentifier()->getName();
2390 // Format as a block literal argument.
2391 Result = '^' + Result;
2394 if (!SuppressBlockName && BlockDecl->getIdentifier())
2395 Result += BlockDecl->getIdentifier()->getName();
2401 static std::string GetDefaultValueString(const ParmVarDecl *Param,
2402 const SourceManager &SM,
2403 const LangOptions &LangOpts) {
2404 const SourceRange SrcRange = Param->getDefaultArgRange();
2405 CharSourceRange CharSrcRange = CharSourceRange::getTokenRange(SrcRange);
2406 bool Invalid = CharSrcRange.isInvalid();
2409 StringRef srcText = Lexer::getSourceText(CharSrcRange, SM, LangOpts, &Invalid);
2413 if (srcText.empty() || srcText == "=") {
2414 // Lexer can't determine the value.
2415 // This happens if the code is incorrect (for example class is forward declared).
2418 std::string DefValue(srcText.str());
2419 // FIXME: remove this check if the Lexer::getSourceText value is fixed and
2420 // this value always has (or always does not have) '=' in front of it
2421 if (DefValue.at(0) != '=') {
2422 // If we don't have '=' in front of value.
2423 // Lexer returns built-in types values without '=' and user-defined types values with it.
2424 return " = " + DefValue;
2426 return " " + DefValue;
2429 /// \brief Add function parameter chunks to the given code completion string.
2430 static void AddFunctionParameterChunks(Preprocessor &PP,
2431 const PrintingPolicy &Policy,
2432 const FunctionDecl *Function,
2433 CodeCompletionBuilder &Result,
2435 bool InOptional = false) {
2436 bool FirstParameter = true;
2438 for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) {
2439 const ParmVarDecl *Param = Function->getParamDecl(P);
2441 if (Param->hasDefaultArg() && !InOptional) {
2442 // When we see an optional default argument, put that argument and
2443 // the remaining default arguments into a new, optional string.
2444 CodeCompletionBuilder Opt(Result.getAllocator(),
2445 Result.getCodeCompletionTUInfo());
2446 if (!FirstParameter)
2447 Opt.AddChunk(CodeCompletionString::CK_Comma);
2448 AddFunctionParameterChunks(PP, Policy, Function, Opt, P, true);
2449 Result.AddOptionalChunk(Opt.TakeString());
2454 FirstParameter = false;
2456 Result.AddChunk(CodeCompletionString::CK_Comma);
2460 // Format the placeholder string.
2461 std::string PlaceholderStr = FormatFunctionParameter(Policy, Param);
2462 if (Param->hasDefaultArg())
2463 PlaceholderStr += GetDefaultValueString(Param, PP.getSourceManager(), PP.getLangOpts());
2465 if (Function->isVariadic() && P == N - 1)
2466 PlaceholderStr += ", ...";
2468 // Add the placeholder string.
2469 Result.AddPlaceholderChunk(
2470 Result.getAllocator().CopyString(PlaceholderStr));
2473 if (const FunctionProtoType *Proto
2474 = Function->getType()->getAs<FunctionProtoType>())
2475 if (Proto->isVariadic()) {
2476 if (Proto->getNumParams() == 0)
2477 Result.AddPlaceholderChunk("...");
2479 MaybeAddSentinel(PP, Function, Result);
2483 /// \brief Add template parameter chunks to the given code completion string.
2484 static void AddTemplateParameterChunks(ASTContext &Context,
2485 const PrintingPolicy &Policy,
2486 const TemplateDecl *Template,
2487 CodeCompletionBuilder &Result,
2488 unsigned MaxParameters = 0,
2490 bool InDefaultArg = false) {
2491 bool FirstParameter = true;
2493 // Prefer to take the template parameter names from the first declaration of
2495 Template = cast<TemplateDecl>(Template->getCanonicalDecl());
2497 TemplateParameterList *Params = Template->getTemplateParameters();
2498 TemplateParameterList::iterator PEnd = Params->end();
2500 PEnd = Params->begin() + MaxParameters;
2501 for (TemplateParameterList::iterator P = Params->begin() + Start;
2503 bool HasDefaultArg = false;
2504 std::string PlaceholderStr;
2505 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
2506 if (TTP->wasDeclaredWithTypename())
2507 PlaceholderStr = "typename";
2509 PlaceholderStr = "class";
2511 if (TTP->getIdentifier()) {
2512 PlaceholderStr += ' ';
2513 PlaceholderStr += TTP->getIdentifier()->getName();
2516 HasDefaultArg = TTP->hasDefaultArgument();
2517 } else if (NonTypeTemplateParmDecl *NTTP
2518 = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
2519 if (NTTP->getIdentifier())
2520 PlaceholderStr = NTTP->getIdentifier()->getName();
2521 NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
2522 HasDefaultArg = NTTP->hasDefaultArgument();
2524 assert(isa<TemplateTemplateParmDecl>(*P));
2525 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
2527 // Since putting the template argument list into the placeholder would
2528 // be very, very long, we just use an abbreviation.
2529 PlaceholderStr = "template<...> class";
2530 if (TTP->getIdentifier()) {
2531 PlaceholderStr += ' ';
2532 PlaceholderStr += TTP->getIdentifier()->getName();
2535 HasDefaultArg = TTP->hasDefaultArgument();
2538 if (HasDefaultArg && !InDefaultArg) {
2539 // When we see an optional default argument, put that argument and
2540 // the remaining default arguments into a new, optional string.
2541 CodeCompletionBuilder Opt(Result.getAllocator(),
2542 Result.getCodeCompletionTUInfo());
2543 if (!FirstParameter)
2544 Opt.AddChunk(CodeCompletionString::CK_Comma);
2545 AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters,
2546 P - Params->begin(), true);
2547 Result.AddOptionalChunk(Opt.TakeString());
2551 InDefaultArg = false;
2554 FirstParameter = false;
2556 Result.AddChunk(CodeCompletionString::CK_Comma);
2558 // Add the placeholder string.
2559 Result.AddPlaceholderChunk(
2560 Result.getAllocator().CopyString(PlaceholderStr));
2564 /// \brief Add a qualifier to the given code-completion string, if the
2565 /// provided nested-name-specifier is non-NULL.
2567 AddQualifierToCompletionString(CodeCompletionBuilder &Result,
2568 NestedNameSpecifier *Qualifier,
2569 bool QualifierIsInformative,
2570 ASTContext &Context,
2571 const PrintingPolicy &Policy) {
2575 std::string PrintedNNS;
2577 llvm::raw_string_ostream OS(PrintedNNS);
2578 Qualifier->print(OS, Policy);
2580 if (QualifierIsInformative)
2581 Result.AddInformativeChunk(Result.getAllocator().CopyString(PrintedNNS));
2583 Result.AddTextChunk(Result.getAllocator().CopyString(PrintedNNS));
2587 AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result,
2588 const FunctionDecl *Function) {
2589 const FunctionProtoType *Proto
2590 = Function->getType()->getAs<FunctionProtoType>();
2591 if (!Proto || !Proto->getTypeQuals())
2594 // FIXME: Add ref-qualifier!
2596 // Handle single qualifiers without copying
2597 if (Proto->getTypeQuals() == Qualifiers::Const) {
2598 Result.AddInformativeChunk(" const");
2602 if (Proto->getTypeQuals() == Qualifiers::Volatile) {
2603 Result.AddInformativeChunk(" volatile");
2607 if (Proto->getTypeQuals() == Qualifiers::Restrict) {
2608 Result.AddInformativeChunk(" restrict");
2612 // Handle multiple qualifiers.
2613 std::string QualsStr;
2614 if (Proto->isConst())
2615 QualsStr += " const";
2616 if (Proto->isVolatile())
2617 QualsStr += " volatile";
2618 if (Proto->isRestrict())
2619 QualsStr += " restrict";
2620 Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
2623 /// \brief Add the name of the given declaration
2624 static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy,
2625 const NamedDecl *ND,
2626 CodeCompletionBuilder &Result) {
2627 DeclarationName Name = ND->getDeclName();
2631 switch (Name.getNameKind()) {
2632 case DeclarationName::CXXOperatorName: {
2633 const char *OperatorName = nullptr;
2634 switch (Name.getCXXOverloadedOperator()) {
2636 case OO_Conditional:
2637 case NUM_OVERLOADED_OPERATORS:
2638 OperatorName = "operator";
2641 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2642 case OO_##Name: OperatorName = "operator" Spelling; break;
2643 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2644 #include "clang/Basic/OperatorKinds.def"
2646 case OO_New: OperatorName = "operator new"; break;
2647 case OO_Delete: OperatorName = "operator delete"; break;
2648 case OO_Array_New: OperatorName = "operator new[]"; break;
2649 case OO_Array_Delete: OperatorName = "operator delete[]"; break;
2650 case OO_Call: OperatorName = "operator()"; break;
2651 case OO_Subscript: OperatorName = "operator[]"; break;
2653 Result.AddTypedTextChunk(OperatorName);
2657 case DeclarationName::Identifier:
2658 case DeclarationName::CXXConversionFunctionName:
2659 case DeclarationName::CXXDestructorName:
2660 case DeclarationName::CXXLiteralOperatorName:
2661 Result.AddTypedTextChunk(
2662 Result.getAllocator().CopyString(ND->getNameAsString()));
2665 case DeclarationName::CXXDeductionGuideName:
2666 case DeclarationName::CXXUsingDirective:
2667 case DeclarationName::ObjCZeroArgSelector:
2668 case DeclarationName::ObjCOneArgSelector:
2669 case DeclarationName::ObjCMultiArgSelector:
2672 case DeclarationName::CXXConstructorName: {
2673 CXXRecordDecl *Record = nullptr;
2674 QualType Ty = Name.getCXXNameType();
2675 if (const RecordType *RecordTy = Ty->getAs<RecordType>())
2676 Record = cast<CXXRecordDecl>(RecordTy->getDecl());
2677 else if (const InjectedClassNameType *InjectedTy
2678 = Ty->getAs<InjectedClassNameType>())
2679 Record = InjectedTy->getDecl();
2681 Result.AddTypedTextChunk(
2682 Result.getAllocator().CopyString(ND->getNameAsString()));
2686 Result.AddTypedTextChunk(
2687 Result.getAllocator().CopyString(Record->getNameAsString()));
2688 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) {
2689 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2690 AddTemplateParameterChunks(Context, Policy, Template, Result);
2691 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2698 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(Sema &S,
2699 const CodeCompletionContext &CCContext,
2700 CodeCompletionAllocator &Allocator,
2701 CodeCompletionTUInfo &CCTUInfo,
2702 bool IncludeBriefComments) {
2703 return CreateCodeCompletionString(S.Context, S.PP, CCContext, Allocator,
2704 CCTUInfo, IncludeBriefComments);
2707 /// \brief If possible, create a new code completion string for the given
2710 /// \returns Either a new, heap-allocated code completion string describing
2711 /// how to use this result, or NULL to indicate that the string or name of the
2712 /// result is all that is needed.
2713 CodeCompletionString *
2714 CodeCompletionResult::CreateCodeCompletionString(ASTContext &Ctx,
2716 const CodeCompletionContext &CCContext,
2717 CodeCompletionAllocator &Allocator,
2718 CodeCompletionTUInfo &CCTUInfo,
2719 bool IncludeBriefComments) {
2720 CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
2722 PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP);
2723 if (Kind == RK_Pattern) {
2724 Pattern->Priority = Priority;
2725 Pattern->Availability = Availability;
2728 Result.addParentContext(Declaration->getDeclContext());
2729 Pattern->ParentName = Result.getParentName();
2730 // Provide code completion comment for self.GetterName where
2731 // GetterName is the getter method for a property with name
2732 // different from the property name (declared via a property
2733 // getter attribute.
2734 const NamedDecl *ND = Declaration;
2735 if (const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(ND))
2736 if (M->isPropertyAccessor())
2737 if (const ObjCPropertyDecl *PDecl = M->findPropertyDecl())
2738 if (PDecl->getGetterName() == M->getSelector() &&
2739 PDecl->getIdentifier() != M->getIdentifier()) {
2740 if (const RawComment *RC =
2741 Ctx.getRawCommentForAnyRedecl(M)) {
2742 Result.addBriefComment(RC->getBriefText(Ctx));
2743 Pattern->BriefComment = Result.getBriefComment();
2745 else if (const RawComment *RC =
2746 Ctx.getRawCommentForAnyRedecl(PDecl)) {
2747 Result.addBriefComment(RC->getBriefText(Ctx));
2748 Pattern->BriefComment = Result.getBriefComment();
2756 if (Kind == RK_Keyword) {
2757 Result.AddTypedTextChunk(Keyword);
2758 return Result.TakeString();
2761 if (Kind == RK_Macro) {
2762 const MacroInfo *MI = PP.getMacroInfo(Macro);
2763 Result.AddTypedTextChunk(
2764 Result.getAllocator().CopyString(Macro->getName()));
2766 if (!MI || !MI->isFunctionLike())
2767 return Result.TakeString();
2769 // Format a function-like macro with placeholders for the arguments.
2770 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2771 MacroInfo::param_iterator A = MI->param_begin(), AEnd = MI->param_end();
2773 // C99 variadic macros add __VA_ARGS__ at the end. Skip it.
2774 if (MI->isC99Varargs()) {
2778 Result.AddPlaceholderChunk("...");
2782 for (MacroInfo::param_iterator A = MI->param_begin(); A != AEnd; ++A) {
2783 if (A != MI->param_begin())
2784 Result.AddChunk(CodeCompletionString::CK_Comma);
2786 if (MI->isVariadic() && (A+1) == AEnd) {
2787 SmallString<32> Arg = (*A)->getName();
2788 if (MI->isC99Varargs())
2792 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
2796 // Non-variadic macros are simple.
2797 Result.AddPlaceholderChunk(
2798 Result.getAllocator().CopyString((*A)->getName()));
2800 Result.AddChunk(CodeCompletionString::CK_RightParen);
2801 return Result.TakeString();
2804 assert(Kind == RK_Declaration && "Missed a result kind?");
2805 const NamedDecl *ND = Declaration;
2806 Result.addParentContext(ND->getDeclContext());
2808 if (IncludeBriefComments) {
2809 // Add documentation comment, if it exists.
2810 if (const RawComment *RC = Ctx.getRawCommentForAnyRedecl(ND)) {
2811 Result.addBriefComment(RC->getBriefText(Ctx));
2813 else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND))
2814 if (OMD->isPropertyAccessor())
2815 if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())
2816 if (const RawComment *RC = Ctx.getRawCommentForAnyRedecl(PDecl))
2817 Result.addBriefComment(RC->getBriefText(Ctx));
2820 if (StartsNestedNameSpecifier) {
2821 Result.AddTypedTextChunk(
2822 Result.getAllocator().CopyString(ND->getNameAsString()));
2823 Result.AddTextChunk("::");
2824 return Result.TakeString();
2827 for (const auto *I : ND->specific_attrs<AnnotateAttr>())
2828 Result.AddAnnotation(Result.getAllocator().CopyString(I->getAnnotation()));
2830 AddResultTypeChunk(Ctx, Policy, ND, CCContext.getBaseType(), Result);
2832 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) {
2833 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2835 AddTypedNameChunk(Ctx, Policy, ND, Result);
2836 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2837 AddFunctionParameterChunks(PP, Policy, Function, Result);
2838 Result.AddChunk(CodeCompletionString::CK_RightParen);
2839 AddFunctionTypeQualsToCompletionString(Result, Function);
2840 return Result.TakeString();
2843 if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) {
2844 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2846 FunctionDecl *Function = FunTmpl->getTemplatedDecl();
2847 AddTypedNameChunk(Ctx, Policy, Function, Result);
2849 // Figure out which template parameters are deduced (or have default
2851 llvm::SmallBitVector Deduced;
2852 Sema::MarkDeducedTemplateParameters(Ctx, FunTmpl, Deduced);
2853 unsigned LastDeducibleArgument;
2854 for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0;
2855 --LastDeducibleArgument) {
2856 if (!Deduced[LastDeducibleArgument - 1]) {
2857 // C++0x: Figure out if the template argument has a default. If so,
2858 // the user doesn't need to type this argument.
2859 // FIXME: We need to abstract template parameters better!
2860 bool HasDefaultArg = false;
2861 NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam(
2862 LastDeducibleArgument - 1);
2863 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
2864 HasDefaultArg = TTP->hasDefaultArgument();
2865 else if (NonTypeTemplateParmDecl *NTTP
2866 = dyn_cast<NonTypeTemplateParmDecl>(Param))
2867 HasDefaultArg = NTTP->hasDefaultArgument();
2869 assert(isa<TemplateTemplateParmDecl>(Param));
2871 = cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument();
2879 if (LastDeducibleArgument) {
2880 // Some of the function template arguments cannot be deduced from a
2881 // function call, so we introduce an explicit template argument list
2882 // containing all of the arguments up to the first deducible argument.
2883 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2884 AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result,
2885 LastDeducibleArgument);
2886 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2889 // Add the function parameters
2890 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2891 AddFunctionParameterChunks(PP, Policy, Function, Result);
2892 Result.AddChunk(CodeCompletionString::CK_RightParen);
2893 AddFunctionTypeQualsToCompletionString(Result, Function);
2894 return Result.TakeString();
2897 if (const TemplateDecl *Template = dyn_cast<TemplateDecl>(ND)) {
2898 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2900 Result.AddTypedTextChunk(
2901 Result.getAllocator().CopyString(Template->getNameAsString()));
2902 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2903 AddTemplateParameterChunks(Ctx, Policy, Template, Result);
2904 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2905 return Result.TakeString();
2908 if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2909 Selector Sel = Method->getSelector();
2910 if (Sel.isUnarySelector()) {
2911 Result.AddTypedTextChunk(Result.getAllocator().CopyString(
2912 Sel.getNameForSlot(0)));
2913 return Result.TakeString();
2916 std::string SelName = Sel.getNameForSlot(0).str();
2918 if (StartParameter == 0)
2919 Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName));
2921 Result.AddInformativeChunk(Result.getAllocator().CopyString(SelName));
2923 // If there is only one parameter, and we're past it, add an empty
2924 // typed-text chunk since there is nothing to type.
2925 if (Method->param_size() == 1)
2926 Result.AddTypedTextChunk("");
2929 for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(),
2930 PEnd = Method->param_end();
2931 P != PEnd; (void)++P, ++Idx) {
2933 std::string Keyword;
2934 if (Idx > StartParameter)
2935 Result.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2936 if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx))
2937 Keyword += II->getName();
2939 if (Idx < StartParameter || AllParametersAreInformative)
2940 Result.AddInformativeChunk(Result.getAllocator().CopyString(Keyword));
2942 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Keyword));
2945 // If we're before the starting parameter, skip the placeholder.
2946 if (Idx < StartParameter)
2950 QualType ParamType = (*P)->getType();
2951 Optional<ArrayRef<QualType>> ObjCSubsts;
2952 if (!CCContext.getBaseType().isNull())
2953 ObjCSubsts = CCContext.getBaseType()->getObjCSubstitutions(Method);
2955 if (ParamType->isBlockPointerType() && !DeclaringEntity)
2956 Arg = FormatFunctionParameter(Policy, *P, true,
2957 /*SuppressBlock=*/false,
2961 ParamType = ParamType.substObjCTypeArgs(Ctx, *ObjCSubsts,
2962 ObjCSubstitutionContext::Parameter);
2963 Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier(),
2965 Arg += ParamType.getAsString(Policy) + ")";
2966 if (IdentifierInfo *II = (*P)->getIdentifier())
2967 if (DeclaringEntity || AllParametersAreInformative)
2968 Arg += II->getName();
2971 if (Method->isVariadic() && (P + 1) == PEnd)
2974 if (DeclaringEntity)
2975 Result.AddTextChunk(Result.getAllocator().CopyString(Arg));
2976 else if (AllParametersAreInformative)
2977 Result.AddInformativeChunk(Result.getAllocator().CopyString(Arg));
2979 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
2982 if (Method->isVariadic()) {
2983 if (Method->param_size() == 0) {
2984 if (DeclaringEntity)
2985 Result.AddTextChunk(", ...");
2986 else if (AllParametersAreInformative)
2987 Result.AddInformativeChunk(", ...");
2989 Result.AddPlaceholderChunk(", ...");
2992 MaybeAddSentinel(PP, Method, Result);
2995 return Result.TakeString();
2999 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
3002 Result.AddTypedTextChunk(
3003 Result.getAllocator().CopyString(ND->getNameAsString()));
3004 return Result.TakeString();
3007 /// \brief Add function overload parameter chunks to the given code completion
3009 static void AddOverloadParameterChunks(ASTContext &Context,
3010 const PrintingPolicy &Policy,
3011 const FunctionDecl *Function,
3012 const FunctionProtoType *Prototype,
3013 CodeCompletionBuilder &Result,
3014 unsigned CurrentArg,
3016 bool InOptional = false) {
3017 bool FirstParameter = true;
3018 unsigned NumParams = Function ? Function->getNumParams()
3019 : Prototype->getNumParams();
3021 for (unsigned P = Start; P != NumParams; ++P) {
3022 if (Function && Function->getParamDecl(P)->hasDefaultArg() && !InOptional) {
3023 // When we see an optional default argument, put that argument and
3024 // the remaining default arguments into a new, optional string.
3025 CodeCompletionBuilder Opt(Result.getAllocator(),
3026 Result.getCodeCompletionTUInfo());
3027 if (!FirstParameter)
3028 Opt.AddChunk(CodeCompletionString::CK_Comma);
3029 // Optional sections are nested.
3030 AddOverloadParameterChunks(Context, Policy, Function, Prototype, Opt,
3031 CurrentArg, P, /*InOptional=*/true);
3032 Result.AddOptionalChunk(Opt.TakeString());
3037 FirstParameter = false;
3039 Result.AddChunk(CodeCompletionString::CK_Comma);
3043 // Format the placeholder string.
3044 std::string Placeholder;
3046 const ParmVarDecl *Param = Function->getParamDecl(P);
3047 Placeholder = FormatFunctionParameter(Policy, Param);
3048 if (Param->hasDefaultArg())
3049 Placeholder += GetDefaultValueString(Param, Context.getSourceManager(), Context.getLangOpts());
3051 Placeholder = Prototype->getParamType(P).getAsString(Policy);
3054 if (P == CurrentArg)
3055 Result.AddCurrentParameterChunk(
3056 Result.getAllocator().CopyString(Placeholder));
3058 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Placeholder));
3061 if (Prototype && Prototype->isVariadic()) {
3062 CodeCompletionBuilder Opt(Result.getAllocator(),
3063 Result.getCodeCompletionTUInfo());
3064 if (!FirstParameter)
3065 Opt.AddChunk(CodeCompletionString::CK_Comma);
3067 if (CurrentArg < NumParams)
3068 Opt.AddPlaceholderChunk("...");
3070 Opt.AddCurrentParameterChunk("...");
3072 Result.AddOptionalChunk(Opt.TakeString());
3076 CodeCompletionString *
3077 CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
3078 unsigned CurrentArg, Sema &S,
3079 CodeCompletionAllocator &Allocator,
3080 CodeCompletionTUInfo &CCTUInfo,
3081 bool IncludeBriefComments) const {
3082 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
3084 // FIXME: Set priority, availability appropriately.
3085 CodeCompletionBuilder Result(Allocator,CCTUInfo, 1, CXAvailability_Available);
3086 FunctionDecl *FDecl = getFunction();
3087 const FunctionProtoType *Proto
3088 = dyn_cast<FunctionProtoType>(getFunctionType());
3089 if (!FDecl && !Proto) {
3090 // Function without a prototype. Just give the return type and a
3091 // highlighted ellipsis.
3092 const FunctionType *FT = getFunctionType();
3093 Result.AddResultTypeChunk(Result.getAllocator().CopyString(
3094 FT->getReturnType().getAsString(Policy)));
3095 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3096 Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
3097 Result.AddChunk(CodeCompletionString::CK_RightParen);
3098 return Result.TakeString();
3102 if (IncludeBriefComments && CurrentArg < FDecl->getNumParams())
3103 if (auto RC = S.getASTContext().getRawCommentForAnyRedecl(
3104 FDecl->getParamDecl(CurrentArg)))
3105 Result.addBriefComment(RC->getBriefText(S.getASTContext()));
3106 AddResultTypeChunk(S.Context, Policy, FDecl, QualType(), Result);
3107 Result.AddTextChunk(
3108 Result.getAllocator().CopyString(FDecl->getNameAsString()));
3110 Result.AddResultTypeChunk(
3111 Result.getAllocator().CopyString(
3112 Proto->getReturnType().getAsString(Policy)));
3115 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3116 AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, Result,
3118 Result.AddChunk(CodeCompletionString::CK_RightParen);
3120 return Result.TakeString();
3123 unsigned clang::getMacroUsagePriority(StringRef MacroName,
3124 const LangOptions &LangOpts,
3125 bool PreferredTypeIsPointer) {
3126 unsigned Priority = CCP_Macro;
3128 // Treat the "nil", "Nil" and "NULL" macros as null pointer constants.
3129 if (MacroName.equals("nil") || MacroName.equals("NULL") ||
3130 MacroName.equals("Nil")) {
3131 Priority = CCP_Constant;
3132 if (PreferredTypeIsPointer)
3133 Priority = Priority / CCF_SimilarTypeMatch;
3135 // Treat "YES", "NO", "true", and "false" as constants.
3136 else if (MacroName.equals("YES") || MacroName.equals("NO") ||
3137 MacroName.equals("true") || MacroName.equals("false"))
3138 Priority = CCP_Constant;
3139 // Treat "bool" as a type.
3140 else if (MacroName.equals("bool"))
3141 Priority = CCP_Type + (LangOpts.ObjC1? CCD_bool_in_ObjC : 0);
3147 CXCursorKind clang::getCursorKindForDecl(const Decl *D) {
3149 return CXCursor_UnexposedDecl;
3151 switch (D->getKind()) {
3152 case Decl::Enum: return CXCursor_EnumDecl;
3153 case Decl::EnumConstant: return CXCursor_EnumConstantDecl;
3154 case Decl::Field: return CXCursor_FieldDecl;
3155 case Decl::Function:
3156 return CXCursor_FunctionDecl;
3157 case Decl::ObjCCategory: return CXCursor_ObjCCategoryDecl;
3158 case Decl::ObjCCategoryImpl: return CXCursor_ObjCCategoryImplDecl;
3159 case Decl::ObjCImplementation: return CXCursor_ObjCImplementationDecl;
3161 case Decl::ObjCInterface: return CXCursor_ObjCInterfaceDecl;
3162 case Decl::ObjCIvar: return CXCursor_ObjCIvarDecl;
3163 case Decl::ObjCMethod:
3164 return cast<ObjCMethodDecl>(D)->isInstanceMethod()
3165 ? CXCursor_ObjCInstanceMethodDecl : CXCursor_ObjCClassMethodDecl;
3166 case Decl::CXXMethod: return CXCursor_CXXMethod;
3167 case Decl::CXXConstructor: return CXCursor_Constructor;
3168 case Decl::CXXDestructor: return CXCursor_Destructor;
3169 case Decl::CXXConversion: return CXCursor_ConversionFunction;
3170 case Decl::ObjCProperty: return CXCursor_ObjCPropertyDecl;
3171 case Decl::ObjCProtocol: return CXCursor_ObjCProtocolDecl;
3172 case Decl::ParmVar: return CXCursor_ParmDecl;
3173 case Decl::Typedef: return CXCursor_TypedefDecl;
3174 case Decl::TypeAlias: return CXCursor_TypeAliasDecl;
3175 case Decl::TypeAliasTemplate: return CXCursor_TypeAliasTemplateDecl;
3176 case Decl::Var: return CXCursor_VarDecl;
3177 case Decl::Namespace: return CXCursor_Namespace;
3178 case Decl::NamespaceAlias: return CXCursor_NamespaceAlias;
3179 case Decl::TemplateTypeParm: return CXCursor_TemplateTypeParameter;
3180 case Decl::NonTypeTemplateParm:return CXCursor_NonTypeTemplateParameter;
3181 case Decl::TemplateTemplateParm:return CXCursor_TemplateTemplateParameter;
3182 case Decl::FunctionTemplate: return CXCursor_FunctionTemplate;
3183 case Decl::ClassTemplate: return CXCursor_ClassTemplate;
3184 case Decl::AccessSpec: return CXCursor_CXXAccessSpecifier;
3185 case Decl::ClassTemplatePartialSpecialization:
3186 return CXCursor_ClassTemplatePartialSpecialization;
3187 case Decl::UsingDirective: return CXCursor_UsingDirective;
3188 case Decl::StaticAssert: return CXCursor_StaticAssert;
3189 case Decl::Friend: return CXCursor_FriendDecl;
3190 case Decl::TranslationUnit: return CXCursor_TranslationUnit;
3193 case Decl::UnresolvedUsingValue:
3194 case Decl::UnresolvedUsingTypename:
3195 return CXCursor_UsingDeclaration;
3197 case Decl::ObjCPropertyImpl:
3198 switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
3199 case ObjCPropertyImplDecl::Dynamic:
3200 return CXCursor_ObjCDynamicDecl;
3202 case ObjCPropertyImplDecl::Synthesize:
3203 return CXCursor_ObjCSynthesizeDecl;
3207 return CXCursor_ModuleImportDecl;
3209 case Decl::ObjCTypeParam: return CXCursor_TemplateTypeParameter;
3212 if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
3213 switch (TD->getTagKind()) {
3214 case TTK_Interface: // fall through
3215 case TTK_Struct: return CXCursor_StructDecl;
3216 case TTK_Class: return CXCursor_ClassDecl;
3217 case TTK_Union: return CXCursor_UnionDecl;
3218 case TTK_Enum: return CXCursor_EnumDecl;
3223 return CXCursor_UnexposedDecl;
3226 static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results,
3227 bool IncludeUndefined,
3228 bool TargetTypeIsPointer = false) {
3229 typedef CodeCompletionResult Result;
3231 Results.EnterNewScope();
3233 for (Preprocessor::macro_iterator M = PP.macro_begin(),
3234 MEnd = PP.macro_end();
3236 auto MD = PP.getMacroDefinition(M->first);
3237 if (IncludeUndefined || MD) {
3238 if (MacroInfo *MI = MD.getMacroInfo())
3239 if (MI->isUsedForHeaderGuard())
3242 Results.AddResult(Result(M->first,
3243 getMacroUsagePriority(M->first->getName(),
3245 TargetTypeIsPointer)));
3249 Results.ExitScope();
3253 static void AddPrettyFunctionResults(const LangOptions &LangOpts,
3254 ResultBuilder &Results) {
3255 typedef CodeCompletionResult Result;
3257 Results.EnterNewScope();
3259 Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant));
3260 Results.AddResult(Result("__FUNCTION__", CCP_Constant));
3261 if (LangOpts.C99 || LangOpts.CPlusPlus11)
3262 Results.AddResult(Result("__func__", CCP_Constant));
3263 Results.ExitScope();
3266 static void HandleCodeCompleteResults(Sema *S,
3267 CodeCompleteConsumer *CodeCompleter,
3268 CodeCompletionContext Context,
3269 CodeCompletionResult *Results,
3270 unsigned NumResults) {
3272 CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults);
3275 static enum CodeCompletionContext::Kind mapCodeCompletionContext(Sema &S,
3276 Sema::ParserCompletionContext PCC) {
3278 case Sema::PCC_Namespace:
3279 return CodeCompletionContext::CCC_TopLevel;
3281 case Sema::PCC_Class:
3282 return CodeCompletionContext::CCC_ClassStructUnion;
3284 case Sema::PCC_ObjCInterface:
3285 return CodeCompletionContext::CCC_ObjCInterface;
3287 case Sema::PCC_ObjCImplementation:
3288 return CodeCompletionContext::CCC_ObjCImplementation;
3290 case Sema::PCC_ObjCInstanceVariableList:
3291 return CodeCompletionContext::CCC_ObjCIvarList;
3293 case Sema::PCC_Template:
3294 case Sema::PCC_MemberTemplate:
3295 if (S.CurContext->isFileContext())
3296 return CodeCompletionContext::CCC_TopLevel;
3297 if (S.CurContext->isRecord())
3298 return CodeCompletionContext::CCC_ClassStructUnion;
3299 return CodeCompletionContext::CCC_Other;
3301 case Sema::PCC_RecoveryInFunction:
3302 return CodeCompletionContext::CCC_Recovery;
3304 case Sema::PCC_ForInit:
3305 if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 ||
3306 S.getLangOpts().ObjC1)
3307 return CodeCompletionContext::CCC_ParenthesizedExpression;
3309 return CodeCompletionContext::CCC_Expression;
3311 case Sema::PCC_Expression:
3312 case Sema::PCC_Condition:
3313 return CodeCompletionContext::CCC_Expression;
3315 case Sema::PCC_Statement:
3316 return CodeCompletionContext::CCC_Statement;
3318 case Sema::PCC_Type:
3319 return CodeCompletionContext::CCC_Type;
3321 case Sema::PCC_ParenthesizedExpression:
3322 return CodeCompletionContext::CCC_ParenthesizedExpression;
3324 case Sema::PCC_LocalDeclarationSpecifiers:
3325 return CodeCompletionContext::CCC_Type;
3328 llvm_unreachable("Invalid ParserCompletionContext!");
3331 /// \brief If we're in a C++ virtual member function, add completion results
3332 /// that invoke the functions we override, since it's common to invoke the
3333 /// overridden function as well as adding new functionality.
3335 /// \param S The semantic analysis object for which we are generating results.
3337 /// \param InContext This context in which the nested-name-specifier preceding
3338 /// the code-completion point
3339 static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext,
3340 ResultBuilder &Results) {
3341 // Look through blocks.
3342 DeclContext *CurContext = S.CurContext;
3343 while (isa<BlockDecl>(CurContext))
3344 CurContext = CurContext->getParent();
3347 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext);
3348 if (!Method || !Method->isVirtual())
3351 // We need to have names for all of the parameters, if we're going to
3352 // generate a forwarding call.
3353 for (auto P : Method->parameters())
3354 if (!P->getDeclName())
3357 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
3358 for (CXXMethodDecl::method_iterator M = Method->begin_overridden_methods(),
3359 MEnd = Method->end_overridden_methods();
3361 CodeCompletionBuilder Builder(Results.getAllocator(),
3362 Results.getCodeCompletionTUInfo());
3363 const CXXMethodDecl *Overridden = *M;
3364 if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl())
3367 // If we need a nested-name-specifier, add one now.
3369 NestedNameSpecifier *NNS
3370 = getRequiredQualification(S.Context, CurContext,
3371 Overridden->getDeclContext());
3374 llvm::raw_string_ostream OS(Str);
3375 NNS->print(OS, Policy);
3376 Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
3378 } else if (!InContext->Equals(Overridden->getDeclContext()))
3381 Builder.AddTypedTextChunk(Results.getAllocator().CopyString(
3382 Overridden->getNameAsString()));
3383 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
3384 bool FirstParam = true;
3385 for (auto P : Method->parameters()) {
3389 Builder.AddChunk(CodeCompletionString::CK_Comma);
3391 Builder.AddPlaceholderChunk(
3392 Results.getAllocator().CopyString(P->getIdentifier()->getName()));
3394 Builder.AddChunk(CodeCompletionString::CK_RightParen);
3395 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
3396 CCP_SuperCompletion,
3398 CXAvailability_Available,
3400 Results.Ignore(Overridden);
3404 void Sema::CodeCompleteModuleImport(SourceLocation ImportLoc,
3405 ModuleIdPath Path) {
3406 typedef CodeCompletionResult Result;
3407 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3408 CodeCompleter->getCodeCompletionTUInfo(),
3409 CodeCompletionContext::CCC_Other);
3410 Results.EnterNewScope();
3412 CodeCompletionAllocator &Allocator = Results.getAllocator();
3413 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
3414 typedef CodeCompletionResult Result;
3416 // Enumerate all top-level modules.
3417 SmallVector<Module *, 8> Modules;
3418 PP.getHeaderSearchInfo().collectAllModules(Modules);
3419 for (unsigned I = 0, N = Modules.size(); I != N; ++I) {
3420 Builder.AddTypedTextChunk(
3421 Builder.getAllocator().CopyString(Modules[I]->Name));
3422 Results.AddResult(Result(Builder.TakeString(),
3424 CXCursor_ModuleImportDecl,
3425 Modules[I]->isAvailable()
3426 ? CXAvailability_Available
3427 : CXAvailability_NotAvailable));
3429 } else if (getLangOpts().Modules) {
3430 // Load the named module.
3431 Module *Mod = PP.getModuleLoader().loadModule(ImportLoc, Path,
3433 /*IsInclusionDirective=*/false);
3434 // Enumerate submodules.
3436 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
3437 SubEnd = Mod->submodule_end();
3438 Sub != SubEnd; ++Sub) {
3440 Builder.AddTypedTextChunk(
3441 Builder.getAllocator().CopyString((*Sub)->Name));
3442 Results.AddResult(Result(Builder.TakeString(),
3444 CXCursor_ModuleImportDecl,
3445 (*Sub)->isAvailable()
3446 ? CXAvailability_Available
3447 : CXAvailability_NotAvailable));
3451 Results.ExitScope();
3452 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3453 Results.data(),Results.size());
3456 void Sema::CodeCompleteOrdinaryName(Scope *S,
3457 ParserCompletionContext CompletionContext) {
3458 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3459 CodeCompleter->getCodeCompletionTUInfo(),
3460 mapCodeCompletionContext(*this, CompletionContext));
3461 Results.EnterNewScope();
3463 // Determine how to filter results, e.g., so that the names of
3464 // values (functions, enumerators, function templates, etc.) are
3465 // only allowed where we can have an expression.
3466 switch (CompletionContext) {
3469 case PCC_ObjCInterface:
3470 case PCC_ObjCImplementation:
3471 case PCC_ObjCInstanceVariableList:
3473 case PCC_MemberTemplate:
3475 case PCC_LocalDeclarationSpecifiers:
3476 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
3480 case PCC_ParenthesizedExpression:
3481 case PCC_Expression:
3484 if (WantTypesInContext(CompletionContext, getLangOpts()))
3485 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3487 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3489 if (getLangOpts().CPlusPlus)
3490 MaybeAddOverrideCalls(*this, /*InContext=*/nullptr, Results);
3493 case PCC_RecoveryInFunction:
3498 // If we are in a C++ non-static member function, check the qualifiers on
3499 // the member function to filter/prioritize the results list.
3500 if (CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext))
3501 if (CurMethod->isInstance())
3502 Results.setObjectTypeQualifiers(
3503 Qualifiers::fromCVRMask(CurMethod->getTypeQualifiers()));
3505 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3506 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3507 CodeCompleter->includeGlobals());
3509 AddOrdinaryNameResults(CompletionContext, S, *this, Results);
3510 Results.ExitScope();
3512 switch (CompletionContext) {
3513 case PCC_ParenthesizedExpression:
3514 case PCC_Expression:
3516 case PCC_RecoveryInFunction:
3517 if (S->getFnParent())
3518 AddPrettyFunctionResults(getLangOpts(), Results);
3523 case PCC_ObjCInterface:
3524 case PCC_ObjCImplementation:
3525 case PCC_ObjCInstanceVariableList:
3527 case PCC_MemberTemplate:
3531 case PCC_LocalDeclarationSpecifiers:
3535 if (CodeCompleter->includeMacros())
3536 AddMacroResults(PP, Results, false);
3538 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3539 Results.data(),Results.size());
3542 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
3543 ParsedType Receiver,
3544 ArrayRef<IdentifierInfo *> SelIdents,
3545 bool AtArgumentExpression,
3547 ResultBuilder &Results);
3549 void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
3550 bool AllowNonIdentifiers,
3551 bool AllowNestedNameSpecifiers) {
3552 typedef CodeCompletionResult Result;
3553 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3554 CodeCompleter->getCodeCompletionTUInfo(),
3555 AllowNestedNameSpecifiers
3556 ? CodeCompletionContext::CCC_PotentiallyQualifiedName
3557 : CodeCompletionContext::CCC_Name);
3558 Results.EnterNewScope();
3560 // Type qualifiers can come after names.
3561 Results.AddResult(Result("const"));
3562 Results.AddResult(Result("volatile"));
3563 if (getLangOpts().C99)
3564 Results.AddResult(Result("restrict"));
3566 if (getLangOpts().CPlusPlus) {
3567 if (getLangOpts().CPlusPlus11 &&
3568 (DS.getTypeSpecType() == DeclSpec::TST_class ||
3569 DS.getTypeSpecType() == DeclSpec::TST_struct))
3570 Results.AddResult("final");
3572 if (AllowNonIdentifiers) {
3573 Results.AddResult(Result("operator"));
3576 // Add nested-name-specifiers.
3577 if (AllowNestedNameSpecifiers) {
3578 Results.allowNestedNameSpecifiers();
3579 Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy);
3580 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3581 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
3582 CodeCompleter->includeGlobals());
3583 Results.setFilter(nullptr);
3586 Results.ExitScope();
3588 // If we're in a context where we might have an expression (rather than a
3589 // declaration), and what we've seen so far is an Objective-C type that could
3590 // be a receiver of a class message, this may be a class message send with
3591 // the initial opening bracket '[' missing. Add appropriate completions.
3592 if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
3593 DS.getParsedSpecifiers() == DeclSpec::PQ_TypeSpecifier &&
3594 DS.getTypeSpecType() == DeclSpec::TST_typename &&
3595 DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified &&
3596 DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
3597 !DS.isTypeAltiVecVector() &&
3599 (S->getFlags() & Scope::DeclScope) != 0 &&
3600 (S->getFlags() & (Scope::ClassScope | Scope::TemplateParamScope |
3601 Scope::FunctionPrototypeScope |
3602 Scope::AtCatchScope)) == 0) {
3603 ParsedType T = DS.getRepAsType();
3604 if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType())
3605 AddClassMessageCompletions(*this, S, T, None, false, false, Results);
3608 // Note that we intentionally suppress macro results here, since we do not
3609 // encourage using macros to produce the names of entities.
3611 HandleCodeCompleteResults(this, CodeCompleter,
3612 Results.getCompletionContext(),
3613 Results.data(), Results.size());
3616 struct Sema::CodeCompleteExpressionData {
3617 CodeCompleteExpressionData(QualType PreferredType = QualType())
3618 : PreferredType(PreferredType), IntegralConstantExpression(false),
3619 ObjCCollection(false) { }
3621 QualType PreferredType;
3622 bool IntegralConstantExpression;
3623 bool ObjCCollection;
3624 SmallVector<Decl *, 4> IgnoreDecls;
3627 /// \brief Perform code-completion in an expression context when we know what
3628 /// type we're looking for.
3629 void Sema::CodeCompleteExpression(Scope *S,
3630 const CodeCompleteExpressionData &Data) {
3631 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3632 CodeCompleter->getCodeCompletionTUInfo(),
3633 CodeCompletionContext::CCC_Expression);
3634 if (Data.ObjCCollection)
3635 Results.setFilter(&ResultBuilder::IsObjCCollection);
3636 else if (Data.IntegralConstantExpression)
3637 Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
3638 else if (WantTypesInContext(PCC_Expression, getLangOpts()))
3639 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3641 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3643 if (!Data.PreferredType.isNull())
3644 Results.setPreferredType(Data.PreferredType.getNonReferenceType());
3646 // Ignore any declarations that we were told that we don't care about.
3647 for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I)
3648 Results.Ignore(Data.IgnoreDecls[I]);
3650 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3651 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3652 CodeCompleter->includeGlobals());
3654 Results.EnterNewScope();
3655 AddOrdinaryNameResults(PCC_Expression, S, *this, Results);
3656 Results.ExitScope();
3658 bool PreferredTypeIsPointer = false;
3659 if (!Data.PreferredType.isNull())
3660 PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType()
3661 || Data.PreferredType->isMemberPointerType()
3662 || Data.PreferredType->isBlockPointerType();
3664 if (S->getFnParent() &&
3665 !Data.ObjCCollection &&
3666 !Data.IntegralConstantExpression)
3667 AddPrettyFunctionResults(getLangOpts(), Results);
3669 if (CodeCompleter->includeMacros())
3670 AddMacroResults(PP, Results, false, PreferredTypeIsPointer);
3671 HandleCodeCompleteResults(this, CodeCompleter,
3672 CodeCompletionContext(CodeCompletionContext::CCC_Expression,
3673 Data.PreferredType),
3674 Results.data(),Results.size());
3677 void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E) {
3679 CodeCompleteOrdinaryName(S, PCC_RecoveryInFunction);
3680 else if (getLangOpts().ObjC1)
3681 CodeCompleteObjCInstanceMessage(S, E.get(), None, false);
3684 /// \brief The set of properties that have already been added, referenced by
3686 typedef llvm::SmallPtrSet<IdentifierInfo*, 16> AddedPropertiesSet;
3688 /// \brief Retrieve the container definition, if any?
3689 static ObjCContainerDecl *getContainerDef(ObjCContainerDecl *Container) {
3690 if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
3691 if (Interface->hasDefinition())
3692 return Interface->getDefinition();
3697 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3698 if (Protocol->hasDefinition())
3699 return Protocol->getDefinition();
3706 /// \brief Adds a block invocation code completion result for the given block
3707 /// declaration \p BD.
3708 static void AddObjCBlockCall(ASTContext &Context, const PrintingPolicy &Policy,
3709 CodeCompletionBuilder &Builder,
3710 const NamedDecl *BD,
3711 const FunctionTypeLoc &BlockLoc,
3712 const FunctionProtoTypeLoc &BlockProtoLoc) {
3713 Builder.AddResultTypeChunk(
3714 GetCompletionTypeString(BlockLoc.getReturnLoc().getType(), Context,
3715 Policy, Builder.getAllocator()));
3717 AddTypedNameChunk(Context, Policy, BD, Builder);
3718 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
3720 if (BlockProtoLoc && BlockProtoLoc.getTypePtr()->isVariadic()) {
3721 Builder.AddPlaceholderChunk("...");
3723 for (unsigned I = 0, N = BlockLoc.getNumParams(); I != N; ++I) {
3725 Builder.AddChunk(CodeCompletionString::CK_Comma);
3727 // Format the placeholder string.
3728 std::string PlaceholderStr =
3729 FormatFunctionParameter(Policy, BlockLoc.getParam(I));
3731 if (I == N - 1 && BlockProtoLoc &&
3732 BlockProtoLoc.getTypePtr()->isVariadic())
3733 PlaceholderStr += ", ...";
3735 // Add the placeholder string.
3736 Builder.AddPlaceholderChunk(
3737 Builder.getAllocator().CopyString(PlaceholderStr));
3741 Builder.AddChunk(CodeCompletionString::CK_RightParen);
3744 static void AddObjCProperties(
3745 const CodeCompletionContext &CCContext, ObjCContainerDecl *Container,
3746 bool AllowCategories, bool AllowNullaryMethods, DeclContext *CurContext,
3747 AddedPropertiesSet &AddedProperties, ResultBuilder &Results,
3748 bool IsBaseExprStatement = false, bool IsClassProperty = false) {
3749 typedef CodeCompletionResult Result;
3751 // Retrieve the definition.
3752 Container = getContainerDef(Container);
3754 // Add properties in this container.
3755 const auto AddProperty = [&](const ObjCPropertyDecl *P) {
3756 if (!AddedProperties.insert(P->getIdentifier()).second)
3759 // FIXME: Provide block invocation completion for non-statement
3761 if (!P->getType().getTypePtr()->isBlockPointerType() ||
3762 !IsBaseExprStatement) {
3763 Results.MaybeAddResult(Result(P, Results.getBasePriority(P), nullptr),
3768 // Block setter and invocation completion is provided only when we are able
3769 // to find the FunctionProtoTypeLoc with parameter names for the block.
3770 FunctionTypeLoc BlockLoc;
3771 FunctionProtoTypeLoc BlockProtoLoc;
3772 findTypeLocationForBlockDecl(P->getTypeSourceInfo(), BlockLoc,
3775 Results.MaybeAddResult(Result(P, Results.getBasePriority(P), nullptr),
3780 // The default completion result for block properties should be the block
3781 // invocation completion when the base expression is a statement.
3782 CodeCompletionBuilder Builder(Results.getAllocator(),
3783 Results.getCodeCompletionTUInfo());
3784 AddObjCBlockCall(Container->getASTContext(),
3785 getCompletionPrintingPolicy(Results.getSema()), Builder, P,
3786 BlockLoc, BlockProtoLoc);
3787 Results.MaybeAddResult(
3788 Result(Builder.TakeString(), P, Results.getBasePriority(P)),
3791 // Provide additional block setter completion iff the base expression is a
3792 // statement and the block property is mutable.
3793 if (!P->isReadOnly()) {
3794 CodeCompletionBuilder Builder(Results.getAllocator(),
3795 Results.getCodeCompletionTUInfo());
3796 AddResultTypeChunk(Container->getASTContext(),
3797 getCompletionPrintingPolicy(Results.getSema()), P,
3798 CCContext.getBaseType(), Builder);
3799 Builder.AddTypedTextChunk(
3800 Results.getAllocator().CopyString(P->getName()));
3801 Builder.AddChunk(CodeCompletionString::CK_Equal);
3803 std::string PlaceholderStr = formatBlockPlaceholder(
3804 getCompletionPrintingPolicy(Results.getSema()), P, BlockLoc,
3805 BlockProtoLoc, /*SuppressBlockName=*/true);
3806 // Add the placeholder string.
3807 Builder.AddPlaceholderChunk(
3808 Builder.getAllocator().CopyString(PlaceholderStr));
3810 // When completing blocks properties that return void the default
3811 // property completion result should show up before the setter,
3812 // otherwise the setter completion should show up before the default
3813 // property completion, as we normally want to use the result of the
3815 Results.MaybeAddResult(
3816 Result(Builder.TakeString(), P,
3817 Results.getBasePriority(P) +
3818 (BlockLoc.getTypePtr()->getReturnType()->isVoidType()
3819 ? CCD_BlockPropertySetter
3820 : -CCD_BlockPropertySetter)),
3825 if (IsClassProperty) {
3826 for (const auto *P : Container->class_properties())
3829 for (const auto *P : Container->instance_properties())
3833 // Add nullary methods or implicit class properties
3834 if (AllowNullaryMethods) {
3835 ASTContext &Context = Container->getASTContext();
3836 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
3837 // Adds a method result
3838 const auto AddMethod = [&](const ObjCMethodDecl *M) {
3839 IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0);
3842 if (!AddedProperties.insert(Name).second)
3844 CodeCompletionBuilder Builder(Results.getAllocator(),
3845 Results.getCodeCompletionTUInfo());
3846 AddResultTypeChunk(Context, Policy, M, CCContext.getBaseType(), Builder);
3847 Builder.AddTypedTextChunk(
3848 Results.getAllocator().CopyString(Name->getName()));
3849 Results.MaybeAddResult(
3850 Result(Builder.TakeString(), M,
3851 CCP_MemberDeclaration + CCD_MethodAsProperty),
3855 if (IsClassProperty) {
3856 for (const auto *M : Container->methods()) {
3857 // Gather the class method that can be used as implicit property
3858 // getters. Methods with arguments or methods that return void aren't
3859 // added to the results as they can't be used as a getter.
3860 if (!M->getSelector().isUnarySelector() ||
3861 M->getReturnType()->isVoidType() || M->isInstanceMethod())
3866 for (auto *M : Container->methods()) {
3867 if (M->getSelector().isUnarySelector())
3873 // Add properties in referenced protocols.
3874 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3875 for (auto *P : Protocol->protocols())
3876 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
3877 CurContext, AddedProperties, Results,
3878 IsBaseExprStatement, IsClassProperty);
3879 } else if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)){
3880 if (AllowCategories) {
3881 // Look through categories.
3882 for (auto *Cat : IFace->known_categories())
3883 AddObjCProperties(CCContext, Cat, AllowCategories, AllowNullaryMethods,
3884 CurContext, AddedProperties, Results,
3885 IsBaseExprStatement, IsClassProperty);
3888 // Look through protocols.
3889 for (auto *I : IFace->all_referenced_protocols())
3890 AddObjCProperties(CCContext, I, AllowCategories, AllowNullaryMethods,
3891 CurContext, AddedProperties, Results,
3892 IsBaseExprStatement, IsClassProperty);
3894 // Look in the superclass.
3895 if (IFace->getSuperClass())
3896 AddObjCProperties(CCContext, IFace->getSuperClass(), AllowCategories,
3897 AllowNullaryMethods, CurContext, AddedProperties,
3898 Results, IsBaseExprStatement, IsClassProperty);
3899 } else if (const ObjCCategoryDecl *Category
3900 = dyn_cast<ObjCCategoryDecl>(Container)) {
3901 // Look through protocols.
3902 for (auto *P : Category->protocols())
3903 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
3904 CurContext, AddedProperties, Results,
3905 IsBaseExprStatement, IsClassProperty);
3909 static void AddRecordMembersCompletionResults(Sema &SemaRef,
3910 ResultBuilder &Results, Scope *S,
3913 // Indicate that we are performing a member access, and the cv-qualifiers
3914 // for the base object type.
3915 Results.setObjectTypeQualifiers(BaseType.getQualifiers());
3917 // Access to a C/C++ class, struct, or union.
3918 Results.allowNestedNameSpecifiers();
3919 CodeCompletionDeclConsumer Consumer(Results, SemaRef.CurContext);
3920 SemaRef.LookupVisibleDecls(RD, Sema::LookupMemberName, Consumer,
3921 SemaRef.CodeCompleter->includeGlobals(),
3922 /*IncludeDependentBases=*/true);
3924 if (SemaRef.getLangOpts().CPlusPlus) {
3925 if (!Results.empty()) {
3926 // The "template" keyword can follow "->" or "." in the grammar.
3927 // However, we only want to suggest the template keyword if something
3929 bool IsDependent = BaseType->isDependentType();
3931 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent())
3932 if (DeclContext *Ctx = DepScope->getEntity()) {
3933 IsDependent = Ctx->isDependentContext();
3939 Results.AddResult(CodeCompletionResult("template"));
3944 void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
3945 SourceLocation OpLoc, bool IsArrow,
3946 bool IsBaseExprStatement) {
3947 if (!Base || !CodeCompleter)
3950 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
3951 if (ConvertedBase.isInvalid())
3953 Base = ConvertedBase.get();
3955 QualType BaseType = Base->getType();
3958 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
3959 BaseType = Ptr->getPointeeType();
3960 else if (BaseType->isObjCObjectPointerType())
3966 enum CodeCompletionContext::Kind contextKind;
3969 contextKind = CodeCompletionContext::CCC_ArrowMemberAccess;
3972 if (BaseType->isObjCObjectPointerType() ||
3973 BaseType->isObjCObjectOrInterfaceType()) {
3974 contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess;
3977 contextKind = CodeCompletionContext::CCC_DotMemberAccess;
3981 CodeCompletionContext CCContext(contextKind, BaseType);
3982 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3983 CodeCompleter->getCodeCompletionTUInfo(),
3985 &ResultBuilder::IsMember);
3986 Results.EnterNewScope();
3987 if (const RecordType *Record = BaseType->getAs<RecordType>()) {
3988 AddRecordMembersCompletionResults(*this, Results, S, BaseType,
3990 } else if (const auto *TST = BaseType->getAs<TemplateSpecializationType>()) {
3991 TemplateName TN = TST->getTemplateName();
3992 if (const auto *TD =
3993 dyn_cast_or_null<ClassTemplateDecl>(TN.getAsTemplateDecl())) {
3994 CXXRecordDecl *RD = TD->getTemplatedDecl();
3995 AddRecordMembersCompletionResults(*this, Results, S, BaseType, RD);
3997 } else if (const auto *ICNT = BaseType->getAs<InjectedClassNameType>()) {
3998 if (auto *RD = ICNT->getDecl())
3999 AddRecordMembersCompletionResults(*this, Results, S, BaseType, RD);
4000 } else if (!IsArrow && BaseType->isObjCObjectPointerType()) {
4001 // Objective-C property reference.
4002 AddedPropertiesSet AddedProperties;
4004 if (const ObjCObjectPointerType *ObjCPtr =
4005 BaseType->getAsObjCInterfacePointerType()) {
4006 // Add property results based on our interface.
4007 assert(ObjCPtr && "Non-NULL pointer guaranteed above!");
4008 AddObjCProperties(CCContext, ObjCPtr->getInterfaceDecl(), true,
4009 /*AllowNullaryMethods=*/true, CurContext,
4010 AddedProperties, Results, IsBaseExprStatement);
4013 // Add properties from the protocols in a qualified interface.
4014 for (auto *I : BaseType->getAs<ObjCObjectPointerType>()->quals())
4015 AddObjCProperties(CCContext, I, true, /*AllowNullaryMethods=*/true,
4016 CurContext, AddedProperties, Results,
4017 IsBaseExprStatement);
4018 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) ||
4019 (!IsArrow && BaseType->isObjCObjectType())) {
4020 // Objective-C instance variable access.
4021 ObjCInterfaceDecl *Class = nullptr;
4022 if (const ObjCObjectPointerType *ObjCPtr
4023 = BaseType->getAs<ObjCObjectPointerType>())
4024 Class = ObjCPtr->getInterfaceDecl();
4026 Class = BaseType->getAs<ObjCObjectType>()->getInterface();
4028 // Add all ivars from this class and its superclasses.
4030 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4031 Results.setFilter(&ResultBuilder::IsObjCIvar);
4032 LookupVisibleDecls(Class, LookupMemberName, Consumer,
4033 CodeCompleter->includeGlobals());
4037 // FIXME: How do we cope with isa?
4039 Results.ExitScope();
4041 // Hand off the results found for code completion.
4042 HandleCodeCompleteResults(this, CodeCompleter,
4043 Results.getCompletionContext(),
4044 Results.data(),Results.size());
4047 void Sema::CodeCompleteObjCClassPropertyRefExpr(Scope *S,
4048 IdentifierInfo &ClassName,
4049 SourceLocation ClassNameLoc,
4050 bool IsBaseExprStatement) {
4051 IdentifierInfo *ClassNamePtr = &ClassName;
4052 ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(ClassNamePtr, ClassNameLoc);
4055 CodeCompletionContext CCContext(
4056 CodeCompletionContext::CCC_ObjCPropertyAccess);
4057 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4058 CodeCompleter->getCodeCompletionTUInfo(), CCContext,
4059 &ResultBuilder::IsMember);
4060 Results.EnterNewScope();
4061 AddedPropertiesSet AddedProperties;
4062 AddObjCProperties(CCContext, IFace, true,
4063 /*AllowNullaryMethods=*/true, CurContext, AddedProperties,
4064 Results, IsBaseExprStatement,
4065 /*IsClassProperty=*/true);
4066 Results.ExitScope();
4067 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4068 Results.data(), Results.size());
4071 void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) {
4075 ResultBuilder::LookupFilter Filter = nullptr;
4076 enum CodeCompletionContext::Kind ContextKind
4077 = CodeCompletionContext::CCC_Other;
4078 switch ((DeclSpec::TST)TagSpec) {
4079 case DeclSpec::TST_enum:
4080 Filter = &ResultBuilder::IsEnum;
4081 ContextKind = CodeCompletionContext::CCC_EnumTag;
4084 case DeclSpec::TST_union:
4085 Filter = &ResultBuilder::IsUnion;
4086 ContextKind = CodeCompletionContext::CCC_UnionTag;
4089 case DeclSpec::TST_struct:
4090 case DeclSpec::TST_class:
4091 case DeclSpec::TST_interface:
4092 Filter = &ResultBuilder::IsClassOrStruct;
4093 ContextKind = CodeCompletionContext::CCC_ClassOrStructTag;
4097 llvm_unreachable("Unknown type specifier kind in CodeCompleteTag");
4100 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4101 CodeCompleter->getCodeCompletionTUInfo(), ContextKind);
4102 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4104 // First pass: look for tags.
4105 Results.setFilter(Filter);
4106 LookupVisibleDecls(S, LookupTagName, Consumer,
4107 CodeCompleter->includeGlobals());
4109 if (CodeCompleter->includeGlobals()) {
4110 // Second pass: look for nested name specifiers.
4111 Results.setFilter(&ResultBuilder::IsNestedNameSpecifier);
4112 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer);
4115 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4116 Results.data(),Results.size());
4119 static void AddTypeQualifierResults(DeclSpec &DS, ResultBuilder &Results,
4120 const LangOptions &LangOpts) {
4121 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
4122 Results.AddResult("const");
4123 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile))
4124 Results.AddResult("volatile");
4125 if (LangOpts.C99 && !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict))
4126 Results.AddResult("restrict");
4127 if (LangOpts.C11 && !(DS.getTypeQualifiers() & DeclSpec::TQ_atomic))
4128 Results.AddResult("_Atomic");
4129 if (LangOpts.MSVCCompat && !(DS.getTypeQualifiers() & DeclSpec::TQ_unaligned))
4130 Results.AddResult("__unaligned");
4133 void Sema::CodeCompleteTypeQualifiers(DeclSpec &DS) {
4134 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4135 CodeCompleter->getCodeCompletionTUInfo(),
4136 CodeCompletionContext::CCC_TypeQualifiers);
4137 Results.EnterNewScope();
4138 AddTypeQualifierResults(DS, Results, LangOpts);
4139 Results.ExitScope();
4140 HandleCodeCompleteResults(this, CodeCompleter,
4141 Results.getCompletionContext(),
4142 Results.data(), Results.size());
4145 void Sema::CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D,
4146 const VirtSpecifiers *VS) {
4147 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4148 CodeCompleter->getCodeCompletionTUInfo(),
4149 CodeCompletionContext::CCC_TypeQualifiers);
4150 Results.EnterNewScope();
4151 AddTypeQualifierResults(DS, Results, LangOpts);
4152 if (LangOpts.CPlusPlus11) {
4153 Results.AddResult("noexcept");
4154 if (D.getContext() == Declarator::MemberContext && !D.isCtorOrDtor() &&
4155 !D.isStaticMember()) {
4156 if (!VS || !VS->isFinalSpecified())
4157 Results.AddResult("final");
4158 if (!VS || !VS->isOverrideSpecified())
4159 Results.AddResult("override");
4162 Results.ExitScope();
4163 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4164 Results.data(), Results.size());
4167 void Sema::CodeCompleteBracketDeclarator(Scope *S) {
4168 CodeCompleteExpression(S, QualType(getASTContext().getSizeType()));
4171 void Sema::CodeCompleteCase(Scope *S) {
4172 if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
4175 SwitchStmt *Switch = getCurFunction()->SwitchStack.back();
4176 QualType type = Switch->getCond()->IgnoreImplicit()->getType();
4177 if (!type->isEnumeralType()) {
4178 CodeCompleteExpressionData Data(type);
4179 Data.IntegralConstantExpression = true;
4180 CodeCompleteExpression(S, Data);
4184 // Code-complete the cases of a switch statement over an enumeration type
4185 // by providing the list of
4186 EnumDecl *Enum = type->castAs<EnumType>()->getDecl();
4187 if (EnumDecl *Def = Enum->getDefinition())
4190 // Determine which enumerators we have already seen in the switch statement.
4191 // FIXME: Ideally, we would also be able to look *past* the code-completion
4192 // token, in case we are code-completing in the middle of the switch and not
4193 // at the end. However, we aren't able to do so at the moment.
4194 llvm::SmallPtrSet<EnumConstantDecl *, 8> EnumeratorsSeen;
4195 NestedNameSpecifier *Qualifier = nullptr;
4196 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC;
4197 SC = SC->getNextSwitchCase()) {
4198 CaseStmt *Case = dyn_cast<CaseStmt>(SC);
4202 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
4203 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CaseVal))
4204 if (EnumConstantDecl *Enumerator
4205 = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
4206 // We look into the AST of the case statement to determine which
4207 // enumerator was named. Alternatively, we could compute the value of
4208 // the integral constant expression, then compare it against the
4209 // values of each enumerator. However, value-based approach would not
4210 // work as well with C++ templates where enumerators declared within a
4211 // template are type- and value-dependent.
4212 EnumeratorsSeen.insert(Enumerator);
4214 // If this is a qualified-id, keep track of the nested-name-specifier
4215 // so that we can reproduce it as part of code completion, e.g.,
4217 // switch (TagD.getKind()) {
4218 // case TagDecl::TK_enum:
4222 // At the XXX, our completions are TagDecl::TK_union,
4223 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union,
4224 // TK_struct, and TK_class.
4225 Qualifier = DRE->getQualifier();
4229 if (getLangOpts().CPlusPlus && !Qualifier && EnumeratorsSeen.empty()) {
4230 // If there are no prior enumerators in C++, check whether we have to
4231 // qualify the names of the enumerators that we suggest, because they
4232 // may not be visible in this scope.
4233 Qualifier = getRequiredQualification(Context, CurContext, Enum);
4236 // Add any enumerators that have not yet been mentioned.
4237 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4238 CodeCompleter->getCodeCompletionTUInfo(),
4239 CodeCompletionContext::CCC_Expression);
4240 Results.EnterNewScope();
4241 for (auto *E : Enum->enumerators()) {
4242 if (EnumeratorsSeen.count(E))
4245 CodeCompletionResult R(E, CCP_EnumInCase, Qualifier);
4246 Results.AddResult(R, CurContext, nullptr, false);
4248 Results.ExitScope();
4250 //We need to make sure we're setting the right context,
4251 //so only say we include macros if the code completer says we do
4252 enum CodeCompletionContext::Kind kind = CodeCompletionContext::CCC_Other;
4253 if (CodeCompleter->includeMacros()) {
4254 AddMacroResults(PP, Results, false);
4255 kind = CodeCompletionContext::CCC_OtherWithMacros;
4258 HandleCodeCompleteResults(this, CodeCompleter,
4260 Results.data(),Results.size());
4263 static bool anyNullArguments(ArrayRef<Expr *> Args) {
4264 if (Args.size() && !Args.data())
4267 for (unsigned I = 0; I != Args.size(); ++I)
4274 typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate;
4276 static void mergeCandidatesWithResults(Sema &SemaRef,
4277 SmallVectorImpl<ResultCandidate> &Results,
4278 OverloadCandidateSet &CandidateSet,
4279 SourceLocation Loc) {
4280 if (!CandidateSet.empty()) {
4281 // Sort the overload candidate set by placing the best overloads first.
4283 CandidateSet.begin(), CandidateSet.end(),
4284 [&](const OverloadCandidate &X, const OverloadCandidate &Y) {
4285 return isBetterOverloadCandidate(SemaRef, X, Y, Loc);
4288 // Add the remaining viable overload candidates as code-completion results.
4289 for (auto &Candidate : CandidateSet)
4290 if (Candidate.Viable)
4291 Results.push_back(ResultCandidate(Candidate.Function));
4295 /// \brief Get the type of the Nth parameter from a given set of overload
4297 static QualType getParamType(Sema &SemaRef,
4298 ArrayRef<ResultCandidate> Candidates,
4301 // Given the overloads 'Candidates' for a function call matching all arguments
4302 // up to N, return the type of the Nth parameter if it is the same for all
4303 // overload candidates.
4305 for (auto &Candidate : Candidates) {
4306 if (auto FType = Candidate.getFunctionType())
4307 if (auto Proto = dyn_cast<FunctionProtoType>(FType))
4308 if (N < Proto->getNumParams()) {
4309 if (ParamType.isNull())
4310 ParamType = Proto->getParamType(N);
4311 else if (!SemaRef.Context.hasSameUnqualifiedType(
4312 ParamType.getNonReferenceType(),
4313 Proto->getParamType(N).getNonReferenceType()))
4314 // Otherwise return a default-constructed QualType.
4322 static void CodeCompleteOverloadResults(Sema &SemaRef, Scope *S,
4323 MutableArrayRef<ResultCandidate> Candidates,
4324 unsigned CurrentArg,
4325 bool CompleteExpressionWithCurrentArg = true) {
4327 if (CompleteExpressionWithCurrentArg)
4328 ParamType = getParamType(SemaRef, Candidates, CurrentArg);
4330 if (ParamType.isNull())
4331 SemaRef.CodeCompleteOrdinaryName(S, Sema::PCC_Expression);
4333 SemaRef.CodeCompleteExpression(S, ParamType);
4335 if (!Candidates.empty())
4336 SemaRef.CodeCompleter->ProcessOverloadCandidates(SemaRef, CurrentArg,
4341 void Sema::CodeCompleteCall(Scope *S, Expr *Fn, ArrayRef<Expr *> Args) {
4345 // When we're code-completing for a call, we fall back to ordinary
4346 // name code-completion whenever we can't produce specific
4347 // results. We may want to revisit this strategy in the future,
4348 // e.g., by merging the two kinds of results.
4350 // FIXME: Provide support for variadic template functions.
4352 // Ignore type-dependent call expressions entirely.
4353 if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args) ||
4354 Expr::hasAnyTypeDependentArguments(Args)) {
4355 CodeCompleteOrdinaryName(S, PCC_Expression);
4359 // Build an overload candidate set based on the functions we find.
4360 SourceLocation Loc = Fn->getExprLoc();
4361 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
4363 SmallVector<ResultCandidate, 8> Results;
4365 Expr *NakedFn = Fn->IgnoreParenCasts();
4366 if (auto ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn))
4367 AddOverloadedCallCandidates(ULE, Args, CandidateSet,
4368 /*PartialOverloading=*/true);
4369 else if (auto UME = dyn_cast<UnresolvedMemberExpr>(NakedFn)) {
4370 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
4371 if (UME->hasExplicitTemplateArgs()) {
4372 UME->copyTemplateArgumentsInto(TemplateArgsBuffer);
4373 TemplateArgs = &TemplateArgsBuffer;
4376 // Add the base as first argument (use a nullptr if the base is implicit).
4377 SmallVector<Expr *, 12> ArgExprs(
4378 1, UME->isImplicitAccess() ? nullptr : UME->getBase());
4379 ArgExprs.append(Args.begin(), Args.end());
4380 UnresolvedSet<8> Decls;
4381 Decls.append(UME->decls_begin(), UME->decls_end());
4382 AddFunctionCandidates(Decls, ArgExprs, CandidateSet, TemplateArgs,
4383 /*SuppressUsedConversions=*/false,
4384 /*PartialOverloading=*/true);
4386 FunctionDecl *FD = nullptr;
4387 if (auto MCE = dyn_cast<MemberExpr>(NakedFn))
4388 FD = dyn_cast<FunctionDecl>(MCE->getMemberDecl());
4389 else if (auto DRE = dyn_cast<DeclRefExpr>(NakedFn))
4390 FD = dyn_cast<FunctionDecl>(DRE->getDecl());
4391 if (FD) { // We check whether it's a resolved function declaration.
4392 if (!getLangOpts().CPlusPlus ||
4393 !FD->getType()->getAs<FunctionProtoType>())
4394 Results.push_back(ResultCandidate(FD));
4396 AddOverloadCandidate(FD, DeclAccessPair::make(FD, FD->getAccess()),
4398 /*SuppressUsedConversions=*/false,
4399 /*PartialOverloading=*/true);
4401 } else if (auto DC = NakedFn->getType()->getAsCXXRecordDecl()) {
4402 // If expression's type is CXXRecordDecl, it may overload the function
4403 // call operator, so we check if it does and add them as candidates.
4404 // A complete type is needed to lookup for member function call operators.
4405 if (isCompleteType(Loc, NakedFn->getType())) {
4406 DeclarationName OpName = Context.DeclarationNames
4407 .getCXXOperatorName(OO_Call);
4408 LookupResult R(*this, OpName, Loc, LookupOrdinaryName);
4409 LookupQualifiedName(R, DC);
4410 R.suppressDiagnostics();
4411 SmallVector<Expr *, 12> ArgExprs(1, NakedFn);
4412 ArgExprs.append(Args.begin(), Args.end());
4413 AddFunctionCandidates(R.asUnresolvedSet(), ArgExprs, CandidateSet,
4414 /*ExplicitArgs=*/nullptr,
4415 /*SuppressUsedConversions=*/false,
4416 /*PartialOverloading=*/true);
4419 // Lastly we check whether expression's type is function pointer or
4421 QualType T = NakedFn->getType();
4422 if (!T->getPointeeType().isNull())
4423 T = T->getPointeeType();
4425 if (auto FP = T->getAs<FunctionProtoType>()) {
4426 if (!TooManyArguments(FP->getNumParams(), Args.size(),
4427 /*PartialOverloading=*/true) ||
4429 Results.push_back(ResultCandidate(FP));
4430 } else if (auto FT = T->getAs<FunctionType>())
4431 // No prototype and declaration, it may be a K & R style function.
4432 Results.push_back(ResultCandidate(FT));
4436 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4437 CodeCompleteOverloadResults(*this, S, Results, Args.size(),
4438 !CandidateSet.empty());
4441 void Sema::CodeCompleteConstructor(Scope *S, QualType Type, SourceLocation Loc,
4442 ArrayRef<Expr *> Args) {
4446 // A complete type is needed to lookup for constructors.
4447 if (!isCompleteType(Loc, Type))
4450 CXXRecordDecl *RD = Type->getAsCXXRecordDecl();
4452 CodeCompleteExpression(S, Type);
4456 // FIXME: Provide support for member initializers.
4457 // FIXME: Provide support for variadic template constructors.
4459 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
4461 for (auto C : LookupConstructors(RD)) {
4462 if (auto FD = dyn_cast<FunctionDecl>(C)) {
4463 AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()),
4465 /*SuppressUsedConversions=*/false,
4466 /*PartialOverloading=*/true);
4467 } else if (auto FTD = dyn_cast<FunctionTemplateDecl>(C)) {
4468 AddTemplateOverloadCandidate(FTD,
4469 DeclAccessPair::make(FTD, C->getAccess()),
4470 /*ExplicitTemplateArgs=*/nullptr,
4472 /*SuppressUsedConversions=*/false,
4473 /*PartialOverloading=*/true);
4477 SmallVector<ResultCandidate, 8> Results;
4478 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4479 CodeCompleteOverloadResults(*this, S, Results, Args.size());
4482 void Sema::CodeCompleteInitializer(Scope *S, Decl *D) {
4483 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D);
4485 CodeCompleteOrdinaryName(S, PCC_Expression);
4489 CodeCompleteExpression(S, VD->getType());
4492 void Sema::CodeCompleteReturn(Scope *S) {
4493 QualType ResultType;
4494 if (isa<BlockDecl>(CurContext)) {
4495 if (BlockScopeInfo *BSI = getCurBlock())
4496 ResultType = BSI->ReturnType;
4497 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(CurContext))
4498 ResultType = Function->getReturnType();
4499 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(CurContext))
4500 ResultType = Method->getReturnType();
4502 if (ResultType.isNull())
4503 CodeCompleteOrdinaryName(S, PCC_Expression);
4505 CodeCompleteExpression(S, ResultType);
4508 void Sema::CodeCompleteAfterIf(Scope *S) {
4509 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4510 CodeCompleter->getCodeCompletionTUInfo(),
4511 mapCodeCompletionContext(*this, PCC_Statement));
4512 Results.setFilter(&ResultBuilder::IsOrdinaryName);
4513 Results.EnterNewScope();
4515 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4516 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4517 CodeCompleter->includeGlobals());
4519 AddOrdinaryNameResults(PCC_Statement, S, *this, Results);
4522 CodeCompletionBuilder Builder(Results.getAllocator(),
4523 Results.getCodeCompletionTUInfo());
4524 Builder.AddTypedTextChunk("else");
4525 if (Results.includeCodePatterns()) {
4526 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4527 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4528 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4529 Builder.AddPlaceholderChunk("statements");
4530 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4531 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4533 Results.AddResult(Builder.TakeString());
4536 Builder.AddTypedTextChunk("else");
4537 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4538 Builder.AddTextChunk("if");
4539 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4540 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4541 if (getLangOpts().CPlusPlus)
4542 Builder.AddPlaceholderChunk("condition");
4544 Builder.AddPlaceholderChunk("expression");
4545 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4546 if (Results.includeCodePatterns()) {
4547 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4548 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4549 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4550 Builder.AddPlaceholderChunk("statements");
4551 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4552 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4554 Results.AddResult(Builder.TakeString());
4556 Results.ExitScope();
4558 if (S->getFnParent())
4559 AddPrettyFunctionResults(getLangOpts(), Results);
4561 if (CodeCompleter->includeMacros())
4562 AddMacroResults(PP, Results, false);
4564 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4565 Results.data(),Results.size());
4568 void Sema::CodeCompleteAssignmentRHS(Scope *S, Expr *LHS) {
4570 CodeCompleteExpression(S, static_cast<Expr *>(LHS)->getType());
4572 CodeCompleteOrdinaryName(S, PCC_Expression);
4575 void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
4576 bool EnteringContext) {
4577 if (!SS.getScopeRep() || !CodeCompleter)
4580 // Always pretend to enter a context to ensure that a dependent type
4581 // resolves to a dependent record.
4582 DeclContext *Ctx = computeDeclContext(SS, /*EnteringContext=*/true);
4586 // Try to instantiate any non-dependent declaration contexts before
4588 if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx))
4591 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4592 CodeCompleter->getCodeCompletionTUInfo(),
4593 CodeCompletionContext::CCC_Name);
4594 Results.EnterNewScope();
4596 // The "template" keyword can follow "::" in the grammar, but only
4597 // put it into the grammar if the nested-name-specifier is dependent.
4598 NestedNameSpecifier *NNS = SS.getScopeRep();
4599 if (!Results.empty() && NNS->isDependent())
4600 Results.AddResult("template");
4602 // Add calls to overridden virtual functions, if there are any.
4604 // FIXME: This isn't wonderful, because we don't know whether we're actually
4605 // in a context that permits expressions. This is a general issue with
4606 // qualified-id completions.
4607 if (!EnteringContext)
4608 MaybeAddOverrideCalls(*this, Ctx, Results);
4609 Results.ExitScope();
4611 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4612 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer,
4613 /*IncludeGlobalScope=*/true,
4614 /*IncludeDependentBases=*/true);
4616 HandleCodeCompleteResults(this, CodeCompleter,
4617 Results.getCompletionContext(),
4618 Results.data(),Results.size());
4621 void Sema::CodeCompleteUsing(Scope *S) {
4625 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4626 CodeCompleter->getCodeCompletionTUInfo(),
4627 CodeCompletionContext::CCC_PotentiallyQualifiedName,
4628 &ResultBuilder::IsNestedNameSpecifier);
4629 Results.EnterNewScope();
4631 // If we aren't in class scope, we could see the "namespace" keyword.
4632 if (!S->isClassScope())
4633 Results.AddResult(CodeCompletionResult("namespace"));
4635 // After "using", we can see anything that would start a
4636 // nested-name-specifier.
4637 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4638 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4639 CodeCompleter->includeGlobals());
4640 Results.ExitScope();
4642 HandleCodeCompleteResults(this, CodeCompleter,
4643 CodeCompletionContext::CCC_PotentiallyQualifiedName,
4644 Results.data(),Results.size());
4647 void Sema::CodeCompleteUsingDirective(Scope *S) {
4651 // After "using namespace", we expect to see a namespace name or namespace
4653 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4654 CodeCompleter->getCodeCompletionTUInfo(),
4655 CodeCompletionContext::CCC_Namespace,
4656 &ResultBuilder::IsNamespaceOrAlias);
4657 Results.EnterNewScope();
4658 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4659 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4660 CodeCompleter->includeGlobals());
4661 Results.ExitScope();
4662 HandleCodeCompleteResults(this, CodeCompleter,
4663 CodeCompletionContext::CCC_Namespace,
4664 Results.data(),Results.size());
4667 void Sema::CodeCompleteNamespaceDecl(Scope *S) {
4671 DeclContext *Ctx = S->getEntity();
4672 if (!S->getParent())
4673 Ctx = Context.getTranslationUnitDecl();
4675 bool SuppressedGlobalResults
4676 = Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx);
4678 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4679 CodeCompleter->getCodeCompletionTUInfo(),
4680 SuppressedGlobalResults
4681 ? CodeCompletionContext::CCC_Namespace
4682 : CodeCompletionContext::CCC_Other,
4683 &ResultBuilder::IsNamespace);
4685 if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) {
4686 // We only want to see those namespaces that have already been defined
4687 // within this scope, because its likely that the user is creating an
4688 // extended namespace declaration. Keep track of the most recent
4689 // definition of each namespace.
4690 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest;
4691 for (DeclContext::specific_decl_iterator<NamespaceDecl>
4692 NS(Ctx->decls_begin()), NSEnd(Ctx->decls_end());
4694 OrigToLatest[NS->getOriginalNamespace()] = *NS;
4696 // Add the most recent definition (or extended definition) of each
4697 // namespace to the list of results.
4698 Results.EnterNewScope();
4699 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator
4700 NS = OrigToLatest.begin(),
4701 NSEnd = OrigToLatest.end();
4703 Results.AddResult(CodeCompletionResult(
4704 NS->second, Results.getBasePriority(NS->second),
4706 CurContext, nullptr, false);
4707 Results.ExitScope();
4710 HandleCodeCompleteResults(this, CodeCompleter,
4711 Results.getCompletionContext(),
4712 Results.data(),Results.size());
4715 void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) {
4719 // After "namespace", we expect to see a namespace or alias.
4720 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4721 CodeCompleter->getCodeCompletionTUInfo(),
4722 CodeCompletionContext::CCC_Namespace,
4723 &ResultBuilder::IsNamespaceOrAlias);
4724 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4725 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4726 CodeCompleter->includeGlobals());
4727 HandleCodeCompleteResults(this, CodeCompleter,
4728 Results.getCompletionContext(),
4729 Results.data(),Results.size());
4732 void Sema::CodeCompleteOperatorName(Scope *S) {
4736 typedef CodeCompletionResult Result;
4737 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4738 CodeCompleter->getCodeCompletionTUInfo(),
4739 CodeCompletionContext::CCC_Type,
4740 &ResultBuilder::IsType);
4741 Results.EnterNewScope();
4743 // Add the names of overloadable operators.
4744 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4745 if (std::strcmp(Spelling, "?")) \
4746 Results.AddResult(Result(Spelling));
4747 #include "clang/Basic/OperatorKinds.def"
4749 // Add any type names visible from the current scope
4750 Results.allowNestedNameSpecifiers();
4751 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4752 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4753 CodeCompleter->includeGlobals());
4755 // Add any type specifiers
4756 AddTypeSpecifierResults(getLangOpts(), Results);
4757 Results.ExitScope();
4759 HandleCodeCompleteResults(this, CodeCompleter,
4760 CodeCompletionContext::CCC_Type,
4761 Results.data(),Results.size());
4764 void Sema::CodeCompleteConstructorInitializer(
4766 ArrayRef <CXXCtorInitializer *> Initializers) {
4770 AdjustDeclIfTemplate(ConstructorD);
4772 CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ConstructorD);
4776 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4777 CodeCompleter->getCodeCompletionTUInfo(),
4778 CodeCompletionContext::CCC_PotentiallyQualifiedName);
4779 Results.EnterNewScope();
4781 // Fill in any already-initialized fields or base classes.
4782 llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
4783 llvm::SmallPtrSet<CanQualType, 4> InitializedBases;
4784 for (unsigned I = 0, E = Initializers.size(); I != E; ++I) {
4785 if (Initializers[I]->isBaseInitializer())
4786 InitializedBases.insert(
4787 Context.getCanonicalType(QualType(Initializers[I]->getBaseClass(), 0)));
4789 InitializedFields.insert(cast<FieldDecl>(
4790 Initializers[I]->getAnyMember()));
4793 // Add completions for base classes.
4794 CodeCompletionBuilder Builder(Results.getAllocator(),
4795 Results.getCodeCompletionTUInfo());
4796 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
4797 bool SawLastInitializer = Initializers.empty();
4798 CXXRecordDecl *ClassDecl = Constructor->getParent();
4799 for (const auto &Base : ClassDecl->bases()) {
4800 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4803 = !Initializers.empty() &&
4804 Initializers.back()->isBaseInitializer() &&
4805 Context.hasSameUnqualifiedType(Base.getType(),
4806 QualType(Initializers.back()->getBaseClass(), 0));
4810 Builder.AddTypedTextChunk(
4811 Results.getAllocator().CopyString(
4812 Base.getType().getAsString(Policy)));
4813 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4814 Builder.AddPlaceholderChunk("args");
4815 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4816 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4817 SawLastInitializer? CCP_NextInitializer
4818 : CCP_MemberDeclaration));
4819 SawLastInitializer = false;
4822 // Add completions for virtual base classes.
4823 for (const auto &Base : ClassDecl->vbases()) {
4824 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4827 = !Initializers.empty() &&
4828 Initializers.back()->isBaseInitializer() &&
4829 Context.hasSameUnqualifiedType(Base.getType(),
4830 QualType(Initializers.back()->getBaseClass(), 0));
4834 Builder.AddTypedTextChunk(
4835 Builder.getAllocator().CopyString(
4836 Base.getType().getAsString(Policy)));
4837 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4838 Builder.AddPlaceholderChunk("args");
4839 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4840 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4841 SawLastInitializer? CCP_NextInitializer
4842 : CCP_MemberDeclaration));
4843 SawLastInitializer = false;
4846 // Add completions for members.
4847 for (auto *Field : ClassDecl->fields()) {
4848 if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))
4851 = !Initializers.empty() &&
4852 Initializers.back()->isAnyMemberInitializer() &&
4853 Initializers.back()->getAnyMember() == Field;
4857 if (!Field->getDeclName())
4860 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
4861 Field->getIdentifier()->getName()));
4862 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4863 Builder.AddPlaceholderChunk("args");
4864 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4865 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4866 SawLastInitializer? CCP_NextInitializer
4867 : CCP_MemberDeclaration,
4869 CXAvailability_Available,
4871 SawLastInitializer = false;
4873 Results.ExitScope();
4875 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4876 Results.data(), Results.size());
4879 /// \brief Determine whether this scope denotes a namespace.
4880 static bool isNamespaceScope(Scope *S) {
4881 DeclContext *DC = S->getEntity();
4885 return DC->isFileContext();
4888 void Sema::CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
4889 bool AfterAmpersand) {
4890 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4891 CodeCompleter->getCodeCompletionTUInfo(),
4892 CodeCompletionContext::CCC_Other);
4893 Results.EnterNewScope();
4895 // Note what has already been captured.
4896 llvm::SmallPtrSet<IdentifierInfo *, 4> Known;
4897 bool IncludedThis = false;
4898 for (const auto &C : Intro.Captures) {
4899 if (C.Kind == LCK_This) {
4900 IncludedThis = true;
4907 // Look for other capturable variables.
4908 for (; S && !isNamespaceScope(S); S = S->getParent()) {
4909 for (const auto *D : S->decls()) {
4910 const auto *Var = dyn_cast<VarDecl>(D);
4912 !Var->hasLocalStorage() ||
4913 Var->hasAttr<BlocksAttr>())
4916 if (Known.insert(Var->getIdentifier()).second)
4917 Results.AddResult(CodeCompletionResult(Var, CCP_LocalDeclaration),
4918 CurContext, nullptr, false);
4922 // Add 'this', if it would be valid.
4923 if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy)
4924 addThisCompletion(*this, Results);
4926 Results.ExitScope();
4928 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4929 Results.data(), Results.size());
4932 /// Macro that optionally prepends an "@" to the string literal passed in via
4933 /// Keyword, depending on whether NeedAt is true or false.
4934 #define OBJC_AT_KEYWORD_NAME(NeedAt,Keyword) ((NeedAt)? "@" Keyword : Keyword)
4936 static void AddObjCImplementationResults(const LangOptions &LangOpts,
4937 ResultBuilder &Results,
4939 typedef CodeCompletionResult Result;
4940 // Since we have an implementation, we can end it.
4941 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
4943 CodeCompletionBuilder Builder(Results.getAllocator(),
4944 Results.getCodeCompletionTUInfo());
4945 if (LangOpts.ObjC2) {
4947 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"dynamic"));
4948 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4949 Builder.AddPlaceholderChunk("property");
4950 Results.AddResult(Result(Builder.TakeString()));
4953 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synthesize"));
4954 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4955 Builder.AddPlaceholderChunk("property");
4956 Results.AddResult(Result(Builder.TakeString()));
4960 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
4961 ResultBuilder &Results,
4963 typedef CodeCompletionResult Result;
4965 // Since we have an interface or protocol, we can end it.
4966 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
4968 if (LangOpts.ObjC2) {
4970 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"property")));
4973 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"required")));
4976 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"optional")));
4980 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
4981 typedef CodeCompletionResult Result;
4982 CodeCompletionBuilder Builder(Results.getAllocator(),
4983 Results.getCodeCompletionTUInfo());
4986 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"class"));
4987 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4988 Builder.AddPlaceholderChunk("name");
4989 Results.AddResult(Result(Builder.TakeString()));
4991 if (Results.includeCodePatterns()) {
4993 // FIXME: Could introduce the whole pattern, including superclasses and
4995 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"interface"));
4996 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4997 Builder.AddPlaceholderChunk("class");
4998 Results.AddResult(Result(Builder.TakeString()));
5001 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
5002 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5003 Builder.AddPlaceholderChunk("protocol");
5004 Results.AddResult(Result(Builder.TakeString()));
5006 // @implementation name
5007 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"implementation"));
5008 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5009 Builder.AddPlaceholderChunk("class");
5010 Results.AddResult(Result(Builder.TakeString()));
5013 // @compatibility_alias name
5014 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"compatibility_alias"));
5015 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5016 Builder.AddPlaceholderChunk("alias");
5017 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5018 Builder.AddPlaceholderChunk("class");
5019 Results.AddResult(Result(Builder.TakeString()));
5021 if (Results.getSema().getLangOpts().Modules) {
5023 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import"));
5024 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5025 Builder.AddPlaceholderChunk("module");
5026 Results.AddResult(Result(Builder.TakeString()));
5030 void Sema::CodeCompleteObjCAtDirective(Scope *S) {
5031 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5032 CodeCompleter->getCodeCompletionTUInfo(),
5033 CodeCompletionContext::CCC_Other);
5034 Results.EnterNewScope();
5035 if (isa<ObjCImplDecl>(CurContext))
5036 AddObjCImplementationResults(getLangOpts(), Results, false);
5037 else if (CurContext->isObjCContainer())
5038 AddObjCInterfaceResults(getLangOpts(), Results, false);
5040 AddObjCTopLevelResults(Results, false);
5041 Results.ExitScope();
5042 HandleCodeCompleteResults(this, CodeCompleter,
5043 CodeCompletionContext::CCC_Other,
5044 Results.data(),Results.size());
5047 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) {
5048 typedef CodeCompletionResult Result;
5049 CodeCompletionBuilder Builder(Results.getAllocator(),
5050 Results.getCodeCompletionTUInfo());
5052 // @encode ( type-name )
5053 const char *EncodeType = "char[]";
5054 if (Results.getSema().getLangOpts().CPlusPlus ||
5055 Results.getSema().getLangOpts().ConstStrings)
5056 EncodeType = "const char[]";
5057 Builder.AddResultTypeChunk(EncodeType);
5058 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"encode"));
5059 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5060 Builder.AddPlaceholderChunk("type-name");
5061 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5062 Results.AddResult(Result(Builder.TakeString()));
5064 // @protocol ( protocol-name )
5065 Builder.AddResultTypeChunk("Protocol *");
5066 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
5067 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5068 Builder.AddPlaceholderChunk("protocol-name");
5069 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5070 Results.AddResult(Result(Builder.TakeString()));
5072 // @selector ( selector )
5073 Builder.AddResultTypeChunk("SEL");
5074 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"selector"));
5075 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5076 Builder.AddPlaceholderChunk("selector");
5077 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5078 Results.AddResult(Result(Builder.TakeString()));
5081 Builder.AddResultTypeChunk("NSString *");
5082 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"\""));
5083 Builder.AddPlaceholderChunk("string");
5084 Builder.AddTextChunk("\"");
5085 Results.AddResult(Result(Builder.TakeString()));
5088 Builder.AddResultTypeChunk("NSArray *");
5089 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"["));
5090 Builder.AddPlaceholderChunk("objects, ...");
5091 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
5092 Results.AddResult(Result(Builder.TakeString()));
5094 // @{key : object, ...}
5095 Builder.AddResultTypeChunk("NSDictionary *");
5096 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"{"));
5097 Builder.AddPlaceholderChunk("key");
5098 Builder.AddChunk(CodeCompletionString::CK_Colon);
5099 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5100 Builder.AddPlaceholderChunk("object, ...");
5101 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5102 Results.AddResult(Result(Builder.TakeString()));
5105 Builder.AddResultTypeChunk("id");
5106 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "("));
5107 Builder.AddPlaceholderChunk("expression");
5108 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5109 Results.AddResult(Result(Builder.TakeString()));
5112 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) {
5113 typedef CodeCompletionResult Result;
5114 CodeCompletionBuilder Builder(Results.getAllocator(),
5115 Results.getCodeCompletionTUInfo());
5117 if (Results.includeCodePatterns()) {
5118 // @try { statements } @catch ( declaration ) { statements } @finally
5120 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"try"));
5121 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5122 Builder.AddPlaceholderChunk("statements");
5123 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5124 Builder.AddTextChunk("@catch");
5125 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5126 Builder.AddPlaceholderChunk("parameter");
5127 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5128 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5129 Builder.AddPlaceholderChunk("statements");
5130 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5131 Builder.AddTextChunk("@finally");
5132 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5133 Builder.AddPlaceholderChunk("statements");
5134 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5135 Results.AddResult(Result(Builder.TakeString()));
5139 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"throw"));
5140 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5141 Builder.AddPlaceholderChunk("expression");
5142 Results.AddResult(Result(Builder.TakeString()));
5144 if (Results.includeCodePatterns()) {
5145 // @synchronized ( expression ) { statements }
5146 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synchronized"));
5147 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5148 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5149 Builder.AddPlaceholderChunk("expression");
5150 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5151 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5152 Builder.AddPlaceholderChunk("statements");
5153 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5154 Results.AddResult(Result(Builder.TakeString()));
5158 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
5159 ResultBuilder &Results,
5161 typedef CodeCompletionResult Result;
5162 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"private")));
5163 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"protected")));
5164 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"public")));
5166 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"package")));
5169 void Sema::CodeCompleteObjCAtVisibility(Scope *S) {
5170 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5171 CodeCompleter->getCodeCompletionTUInfo(),
5172 CodeCompletionContext::CCC_Other);
5173 Results.EnterNewScope();
5174 AddObjCVisibilityResults(getLangOpts(), Results, false);
5175 Results.ExitScope();
5176 HandleCodeCompleteResults(this, CodeCompleter,
5177 CodeCompletionContext::CCC_Other,
5178 Results.data(),Results.size());
5181 void Sema::CodeCompleteObjCAtStatement(Scope *S) {
5182 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5183 CodeCompleter->getCodeCompletionTUInfo(),
5184 CodeCompletionContext::CCC_Other);
5185 Results.EnterNewScope();
5186 AddObjCStatementResults(Results, false);
5187 AddObjCExpressionResults(Results, false);
5188 Results.ExitScope();
5189 HandleCodeCompleteResults(this, CodeCompleter,
5190 CodeCompletionContext::CCC_Other,
5191 Results.data(),Results.size());
5194 void Sema::CodeCompleteObjCAtExpression(Scope *S) {
5195 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5196 CodeCompleter->getCodeCompletionTUInfo(),
5197 CodeCompletionContext::CCC_Other);
5198 Results.EnterNewScope();
5199 AddObjCExpressionResults(Results, false);
5200 Results.ExitScope();
5201 HandleCodeCompleteResults(this, CodeCompleter,
5202 CodeCompletionContext::CCC_Other,
5203 Results.data(),Results.size());
5206 /// \brief Determine whether the addition of the given flag to an Objective-C
5207 /// property's attributes will cause a conflict.
5208 static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) {
5209 // Check if we've already added this flag.
5210 if (Attributes & NewFlag)
5213 Attributes |= NewFlag;
5215 // Check for collisions with "readonly".
5216 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
5217 (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
5220 // Check for more than one of { assign, copy, retain, strong, weak }.
5221 unsigned AssignCopyRetMask = Attributes & (ObjCDeclSpec::DQ_PR_assign |
5222 ObjCDeclSpec::DQ_PR_unsafe_unretained |
5223 ObjCDeclSpec::DQ_PR_copy |
5224 ObjCDeclSpec::DQ_PR_retain |
5225 ObjCDeclSpec::DQ_PR_strong |
5226 ObjCDeclSpec::DQ_PR_weak);
5227 if (AssignCopyRetMask &&
5228 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign &&
5229 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_unsafe_unretained &&
5230 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy &&
5231 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain &&
5232 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_strong &&
5233 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_weak)
5239 void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) {
5243 unsigned Attributes = ODS.getPropertyAttributes();
5245 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5246 CodeCompleter->getCodeCompletionTUInfo(),
5247 CodeCompletionContext::CCC_Other);
5248 Results.EnterNewScope();
5249 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readonly))
5250 Results.AddResult(CodeCompletionResult("readonly"));
5251 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_assign))
5252 Results.AddResult(CodeCompletionResult("assign"));
5253 if (!ObjCPropertyFlagConflicts(Attributes,
5254 ObjCDeclSpec::DQ_PR_unsafe_unretained))
5255 Results.AddResult(CodeCompletionResult("unsafe_unretained"));
5256 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readwrite))
5257 Results.AddResult(CodeCompletionResult("readwrite"));
5258 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_retain))
5259 Results.AddResult(CodeCompletionResult("retain"));
5260 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_strong))
5261 Results.AddResult(CodeCompletionResult("strong"));
5262 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_copy))
5263 Results.AddResult(CodeCompletionResult("copy"));
5264 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nonatomic))
5265 Results.AddResult(CodeCompletionResult("nonatomic"));
5266 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_atomic))
5267 Results.AddResult(CodeCompletionResult("atomic"));
5269 // Only suggest "weak" if we're compiling for ARC-with-weak-references or GC.
5270 if (getLangOpts().ObjCWeak || getLangOpts().getGC() != LangOptions::NonGC)
5271 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_weak))
5272 Results.AddResult(CodeCompletionResult("weak"));
5274 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_setter)) {
5275 CodeCompletionBuilder Setter(Results.getAllocator(),
5276 Results.getCodeCompletionTUInfo());
5277 Setter.AddTypedTextChunk("setter");
5278 Setter.AddTextChunk("=");
5279 Setter.AddPlaceholderChunk("method");
5280 Results.AddResult(CodeCompletionResult(Setter.TakeString()));
5282 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_getter)) {
5283 CodeCompletionBuilder Getter(Results.getAllocator(),
5284 Results.getCodeCompletionTUInfo());
5285 Getter.AddTypedTextChunk("getter");
5286 Getter.AddTextChunk("=");
5287 Getter.AddPlaceholderChunk("method");
5288 Results.AddResult(CodeCompletionResult(Getter.TakeString()));
5290 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nullability)) {
5291 Results.AddResult(CodeCompletionResult("nonnull"));
5292 Results.AddResult(CodeCompletionResult("nullable"));
5293 Results.AddResult(CodeCompletionResult("null_unspecified"));
5294 Results.AddResult(CodeCompletionResult("null_resettable"));
5296 Results.ExitScope();
5297 HandleCodeCompleteResults(this, CodeCompleter,
5298 CodeCompletionContext::CCC_Other,
5299 Results.data(),Results.size());
5302 /// \brief Describes the kind of Objective-C method that we want to find
5303 /// via code completion.
5304 enum ObjCMethodKind {
5305 MK_Any, ///< Any kind of method, provided it means other specified criteria.
5306 MK_ZeroArgSelector, ///< Zero-argument (unary) selector.
5307 MK_OneArgSelector ///< One-argument selector.
5310 static bool isAcceptableObjCSelector(Selector Sel,
5311 ObjCMethodKind WantKind,
5312 ArrayRef<IdentifierInfo *> SelIdents,
5313 bool AllowSameLength = true) {
5314 unsigned NumSelIdents = SelIdents.size();
5315 if (NumSelIdents > Sel.getNumArgs())
5320 case MK_ZeroArgSelector: return Sel.isUnarySelector();
5321 case MK_OneArgSelector: return Sel.getNumArgs() == 1;
5324 if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs())
5327 for (unsigned I = 0; I != NumSelIdents; ++I)
5328 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I))
5334 static bool isAcceptableObjCMethod(ObjCMethodDecl *Method,
5335 ObjCMethodKind WantKind,
5336 ArrayRef<IdentifierInfo *> SelIdents,
5337 bool AllowSameLength = true) {
5338 return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents,
5343 /// \brief A set of selectors, which is used to avoid introducing multiple
5344 /// completions with the same selector into the result set.
5345 typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet;
5348 /// \brief Add all of the Objective-C methods in the given Objective-C
5349 /// container to the set of results.
5351 /// The container will be a class, protocol, category, or implementation of
5352 /// any of the above. This mether will recurse to include methods from
5353 /// the superclasses of classes along with their categories, protocols, and
5354 /// implementations.
5356 /// \param Container the container in which we'll look to find methods.
5358 /// \param WantInstanceMethods Whether to add instance methods (only); if
5359 /// false, this routine will add factory methods (only).
5361 /// \param CurContext the context in which we're performing the lookup that
5364 /// \param AllowSameLength Whether we allow a method to be added to the list
5365 /// when it has the same number of parameters as we have selector identifiers.
5367 /// \param Results the structure into which we'll add results.
5368 static void AddObjCMethods(ObjCContainerDecl *Container,
5369 bool WantInstanceMethods, ObjCMethodKind WantKind,
5370 ArrayRef<IdentifierInfo *> SelIdents,
5371 DeclContext *CurContext,
5372 VisitedSelectorSet &Selectors, bool AllowSameLength,
5373 ResultBuilder &Results, bool InOriginalClass = true,
5374 bool IsRootClass = false) {
5375 typedef CodeCompletionResult Result;
5376 Container = getContainerDef(Container);
5377 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
5378 IsRootClass = IsRootClass || (IFace && !IFace->getSuperClass());
5379 for (auto *M : Container->methods()) {
5380 // The instance methods on the root class can be messaged via the
5382 if (M->isInstanceMethod() == WantInstanceMethods ||
5383 (IsRootClass && !WantInstanceMethods)) {
5384 // Check whether the selector identifiers we've been given are a
5385 // subset of the identifiers for this particular method.
5386 if (!isAcceptableObjCMethod(M, WantKind, SelIdents, AllowSameLength))
5389 if (!Selectors.insert(M->getSelector()).second)
5392 Result R = Result(M, Results.getBasePriority(M), nullptr);
5393 R.StartParameter = SelIdents.size();
5394 R.AllParametersAreInformative = (WantKind != MK_Any);
5395 if (!InOriginalClass)
5396 R.Priority += CCD_InBaseClass;
5397 Results.MaybeAddResult(R, CurContext);
5401 // Visit the protocols of protocols.
5402 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
5403 if (Protocol->hasDefinition()) {
5404 const ObjCList<ObjCProtocolDecl> &Protocols
5405 = Protocol->getReferencedProtocols();
5406 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5407 E = Protocols.end();
5409 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5410 Selectors, AllowSameLength, Results, false, IsRootClass);
5414 if (!IFace || !IFace->hasDefinition())
5417 // Add methods in protocols.
5418 for (auto *I : IFace->protocols())
5419 AddObjCMethods(I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5420 Selectors, AllowSameLength, Results, false, IsRootClass);
5422 // Add methods in categories.
5423 for (auto *CatDecl : IFace->known_categories()) {
5424 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
5425 CurContext, Selectors, AllowSameLength, Results,
5426 InOriginalClass, IsRootClass);
5428 // Add a categories protocol methods.
5429 const ObjCList<ObjCProtocolDecl> &Protocols
5430 = CatDecl->getReferencedProtocols();
5431 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5432 E = Protocols.end();
5434 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5435 Selectors, AllowSameLength, Results, false, IsRootClass);
5437 // Add methods in category implementations.
5438 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation())
5439 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
5440 Selectors, AllowSameLength, Results, InOriginalClass,
5444 // Add methods in superclass.
5445 // Avoid passing in IsRootClass since root classes won't have super classes.
5446 if (IFace->getSuperClass())
5447 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind,
5448 SelIdents, CurContext, Selectors, AllowSameLength, Results,
5449 /*IsRootClass=*/false);
5451 // Add methods in our implementation, if any.
5452 if (ObjCImplementationDecl *Impl = IFace->getImplementation())
5453 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
5454 Selectors, AllowSameLength, Results, InOriginalClass,
5459 void Sema::CodeCompleteObjCPropertyGetter(Scope *S) {
5460 // Try to find the interface where getters might live.
5461 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
5463 if (ObjCCategoryDecl *Category
5464 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
5465 Class = Category->getClassInterface();
5471 // Find all of the potential getters.
5472 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5473 CodeCompleter->getCodeCompletionTUInfo(),
5474 CodeCompletionContext::CCC_Other);
5475 Results.EnterNewScope();
5477 VisitedSelectorSet Selectors;
5478 AddObjCMethods(Class, true, MK_ZeroArgSelector, None, CurContext, Selectors,
5479 /*AllowSameLength=*/true, Results);
5480 Results.ExitScope();
5481 HandleCodeCompleteResults(this, CodeCompleter,
5482 CodeCompletionContext::CCC_Other,
5483 Results.data(),Results.size());
5486 void Sema::CodeCompleteObjCPropertySetter(Scope *S) {
5487 // Try to find the interface where setters might live.
5488 ObjCInterfaceDecl *Class
5489 = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
5491 if (ObjCCategoryDecl *Category
5492 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
5493 Class = Category->getClassInterface();
5499 // Find all of the potential getters.
5500 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5501 CodeCompleter->getCodeCompletionTUInfo(),
5502 CodeCompletionContext::CCC_Other);
5503 Results.EnterNewScope();
5505 VisitedSelectorSet Selectors;
5506 AddObjCMethods(Class, true, MK_OneArgSelector, None, CurContext,
5507 Selectors, /*AllowSameLength=*/true, Results);
5509 Results.ExitScope();
5510 HandleCodeCompleteResults(this, CodeCompleter,
5511 CodeCompletionContext::CCC_Other,
5512 Results.data(),Results.size());
5515 void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
5517 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5518 CodeCompleter->getCodeCompletionTUInfo(),
5519 CodeCompletionContext::CCC_Type);
5520 Results.EnterNewScope();
5522 // Add context-sensitive, Objective-C parameter-passing keywords.
5523 bool AddedInOut = false;
5524 if ((DS.getObjCDeclQualifier() &
5525 (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) {
5526 Results.AddResult("in");
5527 Results.AddResult("inout");
5530 if ((DS.getObjCDeclQualifier() &
5531 (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) {
5532 Results.AddResult("out");
5534 Results.AddResult("inout");
5536 if ((DS.getObjCDeclQualifier() &
5537 (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref |
5538 ObjCDeclSpec::DQ_Oneway)) == 0) {
5539 Results.AddResult("bycopy");
5540 Results.AddResult("byref");
5541 Results.AddResult("oneway");
5543 if ((DS.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability) == 0) {
5544 Results.AddResult("nonnull");
5545 Results.AddResult("nullable");
5546 Results.AddResult("null_unspecified");
5549 // If we're completing the return type of an Objective-C method and the
5550 // identifier IBAction refers to a macro, provide a completion item for
5552 // IBAction)<#selector#>:(id)sender
5553 if (DS.getObjCDeclQualifier() == 0 && !IsParameter &&
5554 PP.isMacroDefined("IBAction")) {
5555 CodeCompletionBuilder Builder(Results.getAllocator(),
5556 Results.getCodeCompletionTUInfo(),
5557 CCP_CodePattern, CXAvailability_Available);
5558 Builder.AddTypedTextChunk("IBAction");
5559 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5560 Builder.AddPlaceholderChunk("selector");
5561 Builder.AddChunk(CodeCompletionString::CK_Colon);
5562 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5563 Builder.AddTextChunk("id");
5564 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5565 Builder.AddTextChunk("sender");
5566 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
5569 // If we're completing the return type, provide 'instancetype'.
5571 Results.AddResult(CodeCompletionResult("instancetype"));
5574 // Add various builtin type names and specifiers.
5575 AddOrdinaryNameResults(PCC_Type, S, *this, Results);
5576 Results.ExitScope();
5578 // Add the various type names
5579 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
5580 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5581 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5582 CodeCompleter->includeGlobals());
5584 if (CodeCompleter->includeMacros())
5585 AddMacroResults(PP, Results, false);
5587 HandleCodeCompleteResults(this, CodeCompleter,
5588 CodeCompletionContext::CCC_Type,
5589 Results.data(), Results.size());
5592 /// \brief When we have an expression with type "id", we may assume
5593 /// that it has some more-specific class type based on knowledge of
5594 /// common uses of Objective-C. This routine returns that class type,
5595 /// or NULL if no better result could be determined.
5596 static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) {
5597 ObjCMessageExpr *Msg = dyn_cast_or_null<ObjCMessageExpr>(E);
5601 Selector Sel = Msg->getSelector();
5605 IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0);
5609 ObjCMethodDecl *Method = Msg->getMethodDecl();
5613 // Determine the class that we're sending the message to.
5614 ObjCInterfaceDecl *IFace = nullptr;
5615 switch (Msg->getReceiverKind()) {
5616 case ObjCMessageExpr::Class:
5617 if (const ObjCObjectType *ObjType
5618 = Msg->getClassReceiver()->getAs<ObjCObjectType>())
5619 IFace = ObjType->getInterface();
5622 case ObjCMessageExpr::Instance: {
5623 QualType T = Msg->getInstanceReceiver()->getType();
5624 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
5625 IFace = Ptr->getInterfaceDecl();
5629 case ObjCMessageExpr::SuperInstance:
5630 case ObjCMessageExpr::SuperClass:
5637 ObjCInterfaceDecl *Super = IFace->getSuperClass();
5638 if (Method->isInstanceMethod())
5639 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5640 .Case("retain", IFace)
5641 .Case("strong", IFace)
5642 .Case("autorelease", IFace)
5643 .Case("copy", IFace)
5644 .Case("copyWithZone", IFace)
5645 .Case("mutableCopy", IFace)
5646 .Case("mutableCopyWithZone", IFace)
5647 .Case("awakeFromCoder", IFace)
5648 .Case("replacementObjectFromCoder", IFace)
5649 .Case("class", IFace)
5650 .Case("classForCoder", IFace)
5651 .Case("superclass", Super)
5654 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5656 .Case("alloc", IFace)
5657 .Case("allocWithZone", IFace)
5658 .Case("class", IFace)
5659 .Case("superclass", Super)
5663 // Add a special completion for a message send to "super", which fills in the
5664 // most likely case of forwarding all of our arguments to the superclass
5667 /// \param S The semantic analysis object.
5669 /// \param NeedSuperKeyword Whether we need to prefix this completion with
5670 /// the "super" keyword. Otherwise, we just need to provide the arguments.
5672 /// \param SelIdents The identifiers in the selector that have already been
5673 /// provided as arguments for a send to "super".
5675 /// \param Results The set of results to augment.
5677 /// \returns the Objective-C method declaration that would be invoked by
5678 /// this "super" completion. If NULL, no completion was added.
5679 static ObjCMethodDecl *AddSuperSendCompletion(
5680 Sema &S, bool NeedSuperKeyword,
5681 ArrayRef<IdentifierInfo *> SelIdents,
5682 ResultBuilder &Results) {
5683 ObjCMethodDecl *CurMethod = S.getCurMethodDecl();
5687 ObjCInterfaceDecl *Class = CurMethod->getClassInterface();
5691 // Try to find a superclass method with the same selector.
5692 ObjCMethodDecl *SuperMethod = nullptr;
5693 while ((Class = Class->getSuperClass()) && !SuperMethod) {
5694 // Check in the class
5695 SuperMethod = Class->getMethod(CurMethod->getSelector(),
5696 CurMethod->isInstanceMethod());
5698 // Check in categories or class extensions.
5700 for (const auto *Cat : Class->known_categories()) {
5701 if ((SuperMethod = Cat->getMethod(CurMethod->getSelector(),
5702 CurMethod->isInstanceMethod())))
5711 // Check whether the superclass method has the same signature.
5712 if (CurMethod->param_size() != SuperMethod->param_size() ||
5713 CurMethod->isVariadic() != SuperMethod->isVariadic())
5716 for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(),
5717 CurPEnd = CurMethod->param_end(),
5718 SuperP = SuperMethod->param_begin();
5719 CurP != CurPEnd; ++CurP, ++SuperP) {
5720 // Make sure the parameter types are compatible.
5721 if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(),
5722 (*SuperP)->getType()))
5725 // Make sure we have a parameter name to forward!
5726 if (!(*CurP)->getIdentifier())
5730 // We have a superclass method. Now, form the send-to-super completion.
5731 CodeCompletionBuilder Builder(Results.getAllocator(),
5732 Results.getCodeCompletionTUInfo());
5734 // Give this completion a return type.
5735 AddResultTypeChunk(S.Context, getCompletionPrintingPolicy(S), SuperMethod,
5736 Results.getCompletionContext().getBaseType(),
5739 // If we need the "super" keyword, add it (plus some spacing).
5740 if (NeedSuperKeyword) {
5741 Builder.AddTypedTextChunk("super");
5742 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5745 Selector Sel = CurMethod->getSelector();
5746 if (Sel.isUnarySelector()) {
5747 if (NeedSuperKeyword)
5748 Builder.AddTextChunk(Builder.getAllocator().CopyString(
5749 Sel.getNameForSlot(0)));
5751 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
5752 Sel.getNameForSlot(0)));
5754 ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin();
5755 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) {
5756 if (I > SelIdents.size())
5757 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5759 if (I < SelIdents.size())
5760 Builder.AddInformativeChunk(
5761 Builder.getAllocator().CopyString(
5762 Sel.getNameForSlot(I) + ":"));
5763 else if (NeedSuperKeyword || I > SelIdents.size()) {
5764 Builder.AddTextChunk(
5765 Builder.getAllocator().CopyString(
5766 Sel.getNameForSlot(I) + ":"));
5767 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5768 (*CurP)->getIdentifier()->getName()));
5770 Builder.AddTypedTextChunk(
5771 Builder.getAllocator().CopyString(
5772 Sel.getNameForSlot(I) + ":"));
5773 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5774 (*CurP)->getIdentifier()->getName()));
5779 Results.AddResult(CodeCompletionResult(Builder.TakeString(), SuperMethod,
5780 CCP_SuperCompletion));
5784 void Sema::CodeCompleteObjCMessageReceiver(Scope *S) {
5785 typedef CodeCompletionResult Result;
5786 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5787 CodeCompleter->getCodeCompletionTUInfo(),
5788 CodeCompletionContext::CCC_ObjCMessageReceiver,
5789 getLangOpts().CPlusPlus11
5790 ? &ResultBuilder::IsObjCMessageReceiverOrLambdaCapture
5791 : &ResultBuilder::IsObjCMessageReceiver);
5793 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5794 Results.EnterNewScope();
5795 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5796 CodeCompleter->includeGlobals());
5798 // If we are in an Objective-C method inside a class that has a superclass,
5799 // add "super" as an option.
5800 if (ObjCMethodDecl *Method = getCurMethodDecl())
5801 if (ObjCInterfaceDecl *Iface = Method->getClassInterface())
5802 if (Iface->getSuperClass()) {
5803 Results.AddResult(Result("super"));
5805 AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, None, Results);
5808 if (getLangOpts().CPlusPlus11)
5809 addThisCompletion(*this, Results);
5811 Results.ExitScope();
5813 if (CodeCompleter->includeMacros())
5814 AddMacroResults(PP, Results, false);
5815 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5816 Results.data(), Results.size());
5820 void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
5821 ArrayRef<IdentifierInfo *> SelIdents,
5822 bool AtArgumentExpression) {
5823 ObjCInterfaceDecl *CDecl = nullptr;
5824 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5825 // Figure out which interface we're in.
5826 CDecl = CurMethod->getClassInterface();
5830 // Find the superclass of this class.
5831 CDecl = CDecl->getSuperClass();
5835 if (CurMethod->isInstanceMethod()) {
5836 // We are inside an instance method, which means that the message
5837 // send [super ...] is actually calling an instance method on the
5839 return CodeCompleteObjCInstanceMessage(S, nullptr, SelIdents,
5840 AtArgumentExpression,
5844 // Fall through to send to the superclass in CDecl.
5846 // "super" may be the name of a type or variable. Figure out which
5848 IdentifierInfo *Super = getSuperIdentifier();
5849 NamedDecl *ND = LookupSingleName(S, Super, SuperLoc,
5850 LookupOrdinaryName);
5851 if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) {
5852 // "super" names an interface. Use it.
5853 } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) {
5854 if (const ObjCObjectType *Iface
5855 = Context.getTypeDeclType(TD)->getAs<ObjCObjectType>())
5856 CDecl = Iface->getInterface();
5857 } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) {
5858 // "super" names an unresolved type; we can't be more specific.
5860 // Assume that "super" names some kind of value and parse that way.
5862 SourceLocation TemplateKWLoc;
5864 id.setIdentifier(Super, SuperLoc);
5865 ExprResult SuperExpr = ActOnIdExpression(S, SS, TemplateKWLoc, id,
5867 return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
5869 AtArgumentExpression);
5875 ParsedType Receiver;
5877 Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl));
5878 return CodeCompleteObjCClassMessage(S, Receiver, SelIdents,
5879 AtArgumentExpression,
5883 /// \brief Given a set of code-completion results for the argument of a message
5884 /// send, determine the preferred type (if any) for that argument expression.
5885 static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
5886 unsigned NumSelIdents) {
5887 typedef CodeCompletionResult Result;
5888 ASTContext &Context = Results.getSema().Context;
5890 QualType PreferredType;
5891 unsigned BestPriority = CCP_Unlikely * 2;
5892 Result *ResultsData = Results.data();
5893 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
5894 Result &R = ResultsData[I];
5895 if (R.Kind == Result::RK_Declaration &&
5896 isa<ObjCMethodDecl>(R.Declaration)) {
5897 if (R.Priority <= BestPriority) {
5898 const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration);
5899 if (NumSelIdents <= Method->param_size()) {
5900 QualType MyPreferredType = Method->parameters()[NumSelIdents - 1]
5902 if (R.Priority < BestPriority || PreferredType.isNull()) {
5903 BestPriority = R.Priority;
5904 PreferredType = MyPreferredType;
5905 } else if (!Context.hasSameUnqualifiedType(PreferredType,
5907 PreferredType = QualType();
5914 return PreferredType;
5917 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
5918 ParsedType Receiver,
5919 ArrayRef<IdentifierInfo *> SelIdents,
5920 bool AtArgumentExpression,
5922 ResultBuilder &Results) {
5923 typedef CodeCompletionResult Result;
5924 ObjCInterfaceDecl *CDecl = nullptr;
5926 // If the given name refers to an interface type, retrieve the
5927 // corresponding declaration.
5929 QualType T = SemaRef.GetTypeFromParser(Receiver, nullptr);
5931 if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>())
5932 CDecl = Interface->getInterface();
5935 // Add all of the factory methods in this Objective-C class, its protocols,
5936 // superclasses, categories, implementation, etc.
5937 Results.EnterNewScope();
5939 // If this is a send-to-super, try to add the special "super" send
5942 if (ObjCMethodDecl *SuperMethod
5943 = AddSuperSendCompletion(SemaRef, false, SelIdents, Results))
5944 Results.Ignore(SuperMethod);
5947 // If we're inside an Objective-C method definition, prefer its selector to
5949 if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl())
5950 Results.setPreferredSelector(CurMethod->getSelector());
5952 VisitedSelectorSet Selectors;
5954 AddObjCMethods(CDecl, false, MK_Any, SelIdents,
5955 SemaRef.CurContext, Selectors, AtArgumentExpression,
5958 // We're messaging "id" as a type; provide all class/factory methods.
5960 // If we have an external source, load the entire class method
5961 // pool from the AST file.
5962 if (SemaRef.getExternalSource()) {
5963 for (uint32_t I = 0,
5964 N = SemaRef.getExternalSource()->GetNumExternalSelectors();
5966 Selector Sel = SemaRef.getExternalSource()->GetExternalSelector(I);
5967 if (Sel.isNull() || SemaRef.MethodPool.count(Sel))
5970 SemaRef.ReadMethodPool(Sel);
5974 for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(),
5975 MEnd = SemaRef.MethodPool.end();
5977 for (ObjCMethodList *MethList = &M->second.second;
5978 MethList && MethList->getMethod();
5979 MethList = MethList->getNext()) {
5980 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
5983 Result R(MethList->getMethod(),
5984 Results.getBasePriority(MethList->getMethod()), nullptr);
5985 R.StartParameter = SelIdents.size();
5986 R.AllParametersAreInformative = false;
5987 Results.MaybeAddResult(R, SemaRef.CurContext);
5992 Results.ExitScope();
5995 void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
5996 ArrayRef<IdentifierInfo *> SelIdents,
5997 bool AtArgumentExpression,
6000 QualType T = this->GetTypeFromParser(Receiver);
6002 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6003 CodeCompleter->getCodeCompletionTUInfo(),
6004 CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage,
6007 AddClassMessageCompletions(*this, S, Receiver, SelIdents,
6008 AtArgumentExpression, IsSuper, Results);
6010 // If we're actually at the argument expression (rather than prior to the
6011 // selector), we're actually performing code completion for an expression.
6012 // Determine whether we have a single, best method. If so, we can
6013 // code-complete the expression using the corresponding parameter type as
6014 // our preferred type, improving completion results.
6015 if (AtArgumentExpression) {
6016 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
6018 if (PreferredType.isNull())
6019 CodeCompleteOrdinaryName(S, PCC_Expression);
6021 CodeCompleteExpression(S, PreferredType);
6025 HandleCodeCompleteResults(this, CodeCompleter,
6026 Results.getCompletionContext(),
6027 Results.data(), Results.size());
6030 void Sema::CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
6031 ArrayRef<IdentifierInfo *> SelIdents,
6032 bool AtArgumentExpression,
6033 ObjCInterfaceDecl *Super) {
6034 typedef CodeCompletionResult Result;
6036 Expr *RecExpr = static_cast<Expr *>(Receiver);
6038 // If necessary, apply function/array conversion to the receiver.
6039 // C99 6.7.5.3p[7,8].
6041 ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr);
6042 if (Conv.isInvalid()) // conversion failed. bail.
6044 RecExpr = Conv.get();
6046 QualType ReceiverType = RecExpr? RecExpr->getType()
6047 : Super? Context.getObjCObjectPointerType(
6048 Context.getObjCInterfaceType(Super))
6049 : Context.getObjCIdType();
6051 // If we're messaging an expression with type "id" or "Class", check
6052 // whether we know something special about the receiver that allows
6053 // us to assume a more-specific receiver type.
6054 if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType()) {
6055 if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) {
6056 if (ReceiverType->isObjCClassType())
6057 return CodeCompleteObjCClassMessage(S,
6058 ParsedType::make(Context.getObjCInterfaceType(IFace)),
6060 AtArgumentExpression, Super);
6062 ReceiverType = Context.getObjCObjectPointerType(
6063 Context.getObjCInterfaceType(IFace));
6065 } else if (RecExpr && getLangOpts().CPlusPlus) {
6066 ExprResult Conv = PerformContextuallyConvertToObjCPointer(RecExpr);
6067 if (Conv.isUsable()) {
6068 RecExpr = Conv.get();
6069 ReceiverType = RecExpr->getType();
6073 // Build the set of methods we can see.
6074 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6075 CodeCompleter->getCodeCompletionTUInfo(),
6076 CodeCompletionContext(CodeCompletionContext::CCC_ObjCInstanceMessage,
6077 ReceiverType, SelIdents));
6079 Results.EnterNewScope();
6081 // If this is a send-to-super, try to add the special "super" send
6084 if (ObjCMethodDecl *SuperMethod
6085 = AddSuperSendCompletion(*this, false, SelIdents, Results))
6086 Results.Ignore(SuperMethod);
6089 // If we're inside an Objective-C method definition, prefer its selector to
6091 if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
6092 Results.setPreferredSelector(CurMethod->getSelector());
6094 // Keep track of the selectors we've already added.
6095 VisitedSelectorSet Selectors;
6097 // Handle messages to Class. This really isn't a message to an instance
6098 // method, so we treat it the same way we would treat a message send to a
6100 if (ReceiverType->isObjCClassType() ||
6101 ReceiverType->isObjCQualifiedClassType()) {
6102 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
6103 if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface())
6104 AddObjCMethods(ClassDecl, false, MK_Any, SelIdents,
6105 CurContext, Selectors, AtArgumentExpression, Results);
6108 // Handle messages to a qualified ID ("id<foo>").
6109 else if (const ObjCObjectPointerType *QualID
6110 = ReceiverType->getAsObjCQualifiedIdType()) {
6111 // Search protocols for instance methods.
6112 for (auto *I : QualID->quals())
6113 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
6114 Selectors, AtArgumentExpression, Results);
6116 // Handle messages to a pointer to interface type.
6117 else if (const ObjCObjectPointerType *IFacePtr
6118 = ReceiverType->getAsObjCInterfacePointerType()) {
6119 // Search the class, its superclasses, etc., for instance methods.
6120 AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents,
6121 CurContext, Selectors, AtArgumentExpression,
6124 // Search protocols for instance methods.
6125 for (auto *I : IFacePtr->quals())
6126 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
6127 Selectors, AtArgumentExpression, Results);
6129 // Handle messages to "id".
6130 else if (ReceiverType->isObjCIdType()) {
6131 // We're messaging "id", so provide all instance methods we know
6132 // about as code-completion results.
6134 // If we have an external source, load the entire class method
6135 // pool from the AST file.
6136 if (ExternalSource) {
6137 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
6139 Selector Sel = ExternalSource->GetExternalSelector(I);
6140 if (Sel.isNull() || MethodPool.count(Sel))
6143 ReadMethodPool(Sel);
6147 for (GlobalMethodPool::iterator M = MethodPool.begin(),
6148 MEnd = MethodPool.end();
6150 for (ObjCMethodList *MethList = &M->second.first;
6151 MethList && MethList->getMethod();
6152 MethList = MethList->getNext()) {
6153 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
6156 if (!Selectors.insert(MethList->getMethod()->getSelector()).second)
6159 Result R(MethList->getMethod(),
6160 Results.getBasePriority(MethList->getMethod()), nullptr);
6161 R.StartParameter = SelIdents.size();
6162 R.AllParametersAreInformative = false;
6163 Results.MaybeAddResult(R, CurContext);
6167 Results.ExitScope();
6170 // If we're actually at the argument expression (rather than prior to the
6171 // selector), we're actually performing code completion for an expression.
6172 // Determine whether we have a single, best method. If so, we can
6173 // code-complete the expression using the corresponding parameter type as
6174 // our preferred type, improving completion results.
6175 if (AtArgumentExpression) {
6176 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
6178 if (PreferredType.isNull())
6179 CodeCompleteOrdinaryName(S, PCC_Expression);
6181 CodeCompleteExpression(S, PreferredType);
6185 HandleCodeCompleteResults(this, CodeCompleter,
6186 Results.getCompletionContext(),
6187 Results.data(),Results.size());
6190 void Sema::CodeCompleteObjCForCollection(Scope *S,
6191 DeclGroupPtrTy IterationVar) {
6192 CodeCompleteExpressionData Data;
6193 Data.ObjCCollection = true;
6195 if (IterationVar.getAsOpaquePtr()) {
6196 DeclGroupRef DG = IterationVar.get();
6197 for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) {
6199 Data.IgnoreDecls.push_back(*I);
6203 CodeCompleteExpression(S, Data);
6206 void Sema::CodeCompleteObjCSelector(Scope *S,
6207 ArrayRef<IdentifierInfo *> SelIdents) {
6208 // If we have an external source, load the entire class method
6209 // pool from the AST file.
6210 if (ExternalSource) {
6211 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
6213 Selector Sel = ExternalSource->GetExternalSelector(I);
6214 if (Sel.isNull() || MethodPool.count(Sel))
6217 ReadMethodPool(Sel);
6221 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6222 CodeCompleter->getCodeCompletionTUInfo(),
6223 CodeCompletionContext::CCC_SelectorName);
6224 Results.EnterNewScope();
6225 for (GlobalMethodPool::iterator M = MethodPool.begin(),
6226 MEnd = MethodPool.end();
6229 Selector Sel = M->first;
6230 if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents))
6233 CodeCompletionBuilder Builder(Results.getAllocator(),
6234 Results.getCodeCompletionTUInfo());
6235 if (Sel.isUnarySelector()) {
6236 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
6237 Sel.getNameForSlot(0)));
6238 Results.AddResult(Builder.TakeString());
6242 std::string Accumulator;
6243 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) {
6244 if (I == SelIdents.size()) {
6245 if (!Accumulator.empty()) {
6246 Builder.AddInformativeChunk(Builder.getAllocator().CopyString(
6248 Accumulator.clear();
6252 Accumulator += Sel.getNameForSlot(I);
6255 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString( Accumulator));
6256 Results.AddResult(Builder.TakeString());
6258 Results.ExitScope();
6260 HandleCodeCompleteResults(this, CodeCompleter,
6261 CodeCompletionContext::CCC_SelectorName,
6262 Results.data(), Results.size());
6265 /// \brief Add all of the protocol declarations that we find in the given
6266 /// (translation unit) context.
6267 static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext,
6268 bool OnlyForwardDeclarations,
6269 ResultBuilder &Results) {
6270 typedef CodeCompletionResult Result;
6272 for (const auto *D : Ctx->decls()) {
6273 // Record any protocols we find.
6274 if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(D))
6275 if (!OnlyForwardDeclarations || !Proto->hasDefinition())
6276 Results.AddResult(Result(Proto, Results.getBasePriority(Proto),nullptr),
6277 CurContext, nullptr, false);
6281 void Sema::CodeCompleteObjCProtocolReferences(
6282 ArrayRef<IdentifierLocPair> Protocols) {
6283 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6284 CodeCompleter->getCodeCompletionTUInfo(),
6285 CodeCompletionContext::CCC_ObjCProtocolName);
6287 if (CodeCompleter->includeGlobals()) {
6288 Results.EnterNewScope();
6290 // Tell the result set to ignore all of the protocols we have
6292 // FIXME: This doesn't work when caching code-completion results.
6293 for (const IdentifierLocPair &Pair : Protocols)
6294 if (ObjCProtocolDecl *Protocol = LookupProtocol(Pair.first,
6296 Results.Ignore(Protocol);
6298 // Add all protocols.
6299 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false,
6302 Results.ExitScope();
6305 HandleCodeCompleteResults(this, CodeCompleter,
6306 CodeCompletionContext::CCC_ObjCProtocolName,
6307 Results.data(),Results.size());
6310 void Sema::CodeCompleteObjCProtocolDecl(Scope *) {
6311 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6312 CodeCompleter->getCodeCompletionTUInfo(),
6313 CodeCompletionContext::CCC_ObjCProtocolName);
6315 if (CodeCompleter->includeGlobals()) {
6316 Results.EnterNewScope();
6318 // Add all protocols.
6319 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true,
6322 Results.ExitScope();
6325 HandleCodeCompleteResults(this, CodeCompleter,
6326 CodeCompletionContext::CCC_ObjCProtocolName,
6327 Results.data(),Results.size());
6330 /// \brief Add all of the Objective-C interface declarations that we find in
6331 /// the given (translation unit) context.
6332 static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext,
6333 bool OnlyForwardDeclarations,
6334 bool OnlyUnimplemented,
6335 ResultBuilder &Results) {
6336 typedef CodeCompletionResult Result;
6338 for (const auto *D : Ctx->decls()) {
6339 // Record any interfaces we find.
6340 if (const auto *Class = dyn_cast<ObjCInterfaceDecl>(D))
6341 if ((!OnlyForwardDeclarations || !Class->hasDefinition()) &&
6342 (!OnlyUnimplemented || !Class->getImplementation()))
6343 Results.AddResult(Result(Class, Results.getBasePriority(Class),nullptr),
6344 CurContext, nullptr, false);
6348 void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) {
6349 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6350 CodeCompleter->getCodeCompletionTUInfo(),
6351 CodeCompletionContext::CCC_Other);
6352 Results.EnterNewScope();
6354 if (CodeCompleter->includeGlobals()) {
6356 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6360 Results.ExitScope();
6362 HandleCodeCompleteResults(this, CodeCompleter,
6363 CodeCompletionContext::CCC_ObjCInterfaceName,
6364 Results.data(),Results.size());
6367 void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName,
6368 SourceLocation ClassNameLoc) {
6369 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6370 CodeCompleter->getCodeCompletionTUInfo(),
6371 CodeCompletionContext::CCC_ObjCInterfaceName);
6372 Results.EnterNewScope();
6374 // Make sure that we ignore the class we're currently defining.
6376 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6377 if (CurClass && isa<ObjCInterfaceDecl>(CurClass))
6378 Results.Ignore(CurClass);
6380 if (CodeCompleter->includeGlobals()) {
6382 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6386 Results.ExitScope();
6388 HandleCodeCompleteResults(this, CodeCompleter,
6389 CodeCompletionContext::CCC_ObjCInterfaceName,
6390 Results.data(),Results.size());
6393 void Sema::CodeCompleteObjCImplementationDecl(Scope *S) {
6394 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6395 CodeCompleter->getCodeCompletionTUInfo(),
6396 CodeCompletionContext::CCC_Other);
6397 Results.EnterNewScope();
6399 if (CodeCompleter->includeGlobals()) {
6400 // Add all unimplemented classes.
6401 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6405 Results.ExitScope();
6407 HandleCodeCompleteResults(this, CodeCompleter,
6408 CodeCompletionContext::CCC_ObjCInterfaceName,
6409 Results.data(),Results.size());
6412 void Sema::CodeCompleteObjCInterfaceCategory(Scope *S,
6413 IdentifierInfo *ClassName,
6414 SourceLocation ClassNameLoc) {
6415 typedef CodeCompletionResult Result;
6417 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6418 CodeCompleter->getCodeCompletionTUInfo(),
6419 CodeCompletionContext::CCC_ObjCCategoryName);
6421 // Ignore any categories we find that have already been implemented by this
6423 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
6425 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6426 if (ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)){
6427 for (const auto *Cat : Class->visible_categories())
6428 CategoryNames.insert(Cat->getIdentifier());
6431 // Add all of the categories we know about.
6432 Results.EnterNewScope();
6433 TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
6434 for (const auto *D : TU->decls())
6435 if (const auto *Category = dyn_cast<ObjCCategoryDecl>(D))
6436 if (CategoryNames.insert(Category->getIdentifier()).second)
6437 Results.AddResult(Result(Category, Results.getBasePriority(Category),
6439 CurContext, nullptr, false);
6440 Results.ExitScope();
6442 HandleCodeCompleteResults(this, CodeCompleter,
6443 CodeCompletionContext::CCC_ObjCCategoryName,
6444 Results.data(),Results.size());
6447 void Sema::CodeCompleteObjCImplementationCategory(Scope *S,
6448 IdentifierInfo *ClassName,
6449 SourceLocation ClassNameLoc) {
6450 typedef CodeCompletionResult Result;
6452 // Find the corresponding interface. If we couldn't find the interface, the
6453 // program itself is ill-formed. However, we'll try to be helpful still by
6454 // providing the list of all of the categories we know about.
6456 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6457 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass);
6459 return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc);
6461 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6462 CodeCompleter->getCodeCompletionTUInfo(),
6463 CodeCompletionContext::CCC_ObjCCategoryName);
6465 // Add all of the categories that have have corresponding interface
6466 // declarations in this class and any of its superclasses, except for
6467 // already-implemented categories in the class itself.
6468 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
6469 Results.EnterNewScope();
6470 bool IgnoreImplemented = true;
6472 for (const auto *Cat : Class->visible_categories()) {
6473 if ((!IgnoreImplemented || !Cat->getImplementation()) &&
6474 CategoryNames.insert(Cat->getIdentifier()).second)
6475 Results.AddResult(Result(Cat, Results.getBasePriority(Cat), nullptr),
6476 CurContext, nullptr, false);
6479 Class = Class->getSuperClass();
6480 IgnoreImplemented = false;
6482 Results.ExitScope();
6484 HandleCodeCompleteResults(this, CodeCompleter,
6485 CodeCompletionContext::CCC_ObjCCategoryName,
6486 Results.data(),Results.size());
6489 void Sema::CodeCompleteObjCPropertyDefinition(Scope *S) {
6490 CodeCompletionContext CCContext(CodeCompletionContext::CCC_Other);
6491 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6492 CodeCompleter->getCodeCompletionTUInfo(),
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 // Ignore any properties that have already been implemented.
6504 Container = getContainerDef(Container);
6505 for (const auto *D : Container->decls())
6506 if (const auto *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(D))
6507 Results.Ignore(PropertyImpl->getPropertyDecl());
6509 // Add any properties that we find.
6510 AddedPropertiesSet AddedProperties;
6511 Results.EnterNewScope();
6512 if (ObjCImplementationDecl *ClassImpl
6513 = dyn_cast<ObjCImplementationDecl>(Container))
6514 AddObjCProperties(CCContext, ClassImpl->getClassInterface(), false,
6515 /*AllowNullaryMethods=*/false, CurContext,
6516 AddedProperties, Results);
6518 AddObjCProperties(CCContext,
6519 cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(),
6520 false, /*AllowNullaryMethods=*/false, CurContext,
6521 AddedProperties, Results);
6522 Results.ExitScope();
6524 HandleCodeCompleteResults(this, CodeCompleter,
6525 CodeCompletionContext::CCC_Other,
6526 Results.data(),Results.size());
6529 void Sema::CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
6530 IdentifierInfo *PropertyName) {
6531 typedef CodeCompletionResult Result;
6532 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6533 CodeCompleter->getCodeCompletionTUInfo(),
6534 CodeCompletionContext::CCC_Other);
6536 // Figure out where this @synthesize lives.
6537 ObjCContainerDecl *Container
6538 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6540 (!isa<ObjCImplementationDecl>(Container) &&
6541 !isa<ObjCCategoryImplDecl>(Container)))
6544 // Figure out which interface we're looking into.
6545 ObjCInterfaceDecl *Class = nullptr;
6546 if (ObjCImplementationDecl *ClassImpl
6547 = dyn_cast<ObjCImplementationDecl>(Container))
6548 Class = ClassImpl->getClassInterface();
6550 Class = cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl()
6551 ->getClassInterface();
6553 // Determine the type of the property we're synthesizing.
6554 QualType PropertyType = Context.getObjCIdType();
6556 if (ObjCPropertyDecl *Property = Class->FindPropertyDeclaration(
6557 PropertyName, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
6559 = Property->getType().getNonReferenceType().getUnqualifiedType();
6561 // Give preference to ivars
6562 Results.setPreferredType(PropertyType);
6566 // Add all of the instance variables in this class and its superclasses.
6567 Results.EnterNewScope();
6568 bool SawSimilarlyNamedIvar = false;
6569 std::string NameWithPrefix;
6570 NameWithPrefix += '_';
6571 NameWithPrefix += PropertyName->getName();
6572 std::string NameWithSuffix = PropertyName->getName().str();
6573 NameWithSuffix += '_';
6574 for(; Class; Class = Class->getSuperClass()) {
6575 for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar;
6576 Ivar = Ivar->getNextIvar()) {
6577 Results.AddResult(Result(Ivar, Results.getBasePriority(Ivar), nullptr),
6578 CurContext, nullptr, false);
6580 // Determine whether we've seen an ivar with a name similar to the
6582 if ((PropertyName == Ivar->getIdentifier() ||
6583 NameWithPrefix == Ivar->getName() ||
6584 NameWithSuffix == Ivar->getName())) {
6585 SawSimilarlyNamedIvar = true;
6587 // Reduce the priority of this result by one, to give it a slight
6588 // advantage over other results whose names don't match so closely.
6589 if (Results.size() &&
6590 Results.data()[Results.size() - 1].Kind
6591 == CodeCompletionResult::RK_Declaration &&
6592 Results.data()[Results.size() - 1].Declaration == Ivar)
6593 Results.data()[Results.size() - 1].Priority--;
6598 if (!SawSimilarlyNamedIvar) {
6599 // Create ivar result _propName, that the user can use to synthesize
6600 // an ivar of the appropriate type.
6601 unsigned Priority = CCP_MemberDeclaration + 1;
6602 typedef CodeCompletionResult Result;
6603 CodeCompletionAllocator &Allocator = Results.getAllocator();
6604 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo(),
6605 Priority,CXAvailability_Available);
6607 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
6608 Builder.AddResultTypeChunk(GetCompletionTypeString(PropertyType, Context,
6609 Policy, Allocator));
6610 Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix));
6611 Results.AddResult(Result(Builder.TakeString(), Priority,
6612 CXCursor_ObjCIvarDecl));
6615 Results.ExitScope();
6617 HandleCodeCompleteResults(this, CodeCompleter,
6618 CodeCompletionContext::CCC_Other,
6619 Results.data(),Results.size());
6622 // Mapping from selectors to the methods that implement that selector, along
6623 // with the "in original class" flag.
6624 typedef llvm::DenseMap<
6625 Selector, llvm::PointerIntPair<ObjCMethodDecl *, 1, bool> > KnownMethodsMap;
6627 /// \brief Find all of the methods that reside in the given container
6628 /// (and its superclasses, protocols, etc.) that meet the given
6629 /// criteria. Insert those methods into the map of known methods,
6630 /// indexed by selector so they can be easily found.
6631 static void FindImplementableMethods(ASTContext &Context,
6632 ObjCContainerDecl *Container,
6633 bool WantInstanceMethods,
6634 QualType ReturnType,
6635 KnownMethodsMap &KnownMethods,
6636 bool InOriginalClass = true) {
6637 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) {
6638 // Make sure we have a definition; that's what we'll walk.
6639 if (!IFace->hasDefinition())
6642 IFace = IFace->getDefinition();
6645 const ObjCList<ObjCProtocolDecl> &Protocols
6646 = IFace->getReferencedProtocols();
6647 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6648 E = Protocols.end();
6650 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6651 KnownMethods, InOriginalClass);
6653 // Add methods from any class extensions and categories.
6654 for (auto *Cat : IFace->visible_categories()) {
6655 FindImplementableMethods(Context, Cat, WantInstanceMethods, ReturnType,
6656 KnownMethods, false);
6659 // Visit the superclass.
6660 if (IFace->getSuperClass())
6661 FindImplementableMethods(Context, IFace->getSuperClass(),
6662 WantInstanceMethods, ReturnType,
6663 KnownMethods, false);
6666 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
6667 // Recurse into protocols.
6668 const ObjCList<ObjCProtocolDecl> &Protocols
6669 = Category->getReferencedProtocols();
6670 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6671 E = Protocols.end();
6673 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6674 KnownMethods, InOriginalClass);
6676 // If this category is the original class, jump to the interface.
6677 if (InOriginalClass && Category->getClassInterface())
6678 FindImplementableMethods(Context, Category->getClassInterface(),
6679 WantInstanceMethods, ReturnType, KnownMethods,
6683 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
6684 // Make sure we have a definition; that's what we'll walk.
6685 if (!Protocol->hasDefinition())
6687 Protocol = Protocol->getDefinition();
6688 Container = Protocol;
6690 // Recurse into protocols.
6691 const ObjCList<ObjCProtocolDecl> &Protocols
6692 = Protocol->getReferencedProtocols();
6693 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6694 E = Protocols.end();
6696 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6697 KnownMethods, false);
6700 // Add methods in this container. This operation occurs last because
6701 // we want the methods from this container to override any methods
6702 // we've previously seen with the same selector.
6703 for (auto *M : Container->methods()) {
6704 if (M->isInstanceMethod() == WantInstanceMethods) {
6705 if (!ReturnType.isNull() &&
6706 !Context.hasSameUnqualifiedType(ReturnType, M->getReturnType()))
6709 KnownMethods[M->getSelector()] =
6710 KnownMethodsMap::mapped_type(M, InOriginalClass);
6715 /// \brief Add the parenthesized return or parameter type chunk to a code
6716 /// completion string.
6717 static void AddObjCPassingTypeChunk(QualType Type,
6718 unsigned ObjCDeclQuals,
6719 ASTContext &Context,
6720 const PrintingPolicy &Policy,
6721 CodeCompletionBuilder &Builder) {
6722 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6723 std::string Quals = formatObjCParamQualifiers(ObjCDeclQuals, Type);
6725 Builder.AddTextChunk(Builder.getAllocator().CopyString(Quals));
6726 Builder.AddTextChunk(GetCompletionTypeString(Type, Context, Policy,
6727 Builder.getAllocator()));
6728 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6731 /// \brief Determine whether the given class is or inherits from a class by
6733 static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class,
6738 if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name)
6741 return InheritsFromClassNamed(Class->getSuperClass(), Name);
6744 /// \brief Add code completions for Objective-C Key-Value Coding (KVC) and
6745 /// Key-Value Observing (KVO).
6746 static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property,
6747 bool IsInstanceMethod,
6748 QualType ReturnType,
6749 ASTContext &Context,
6750 VisitedSelectorSet &KnownSelectors,
6751 ResultBuilder &Results) {
6752 IdentifierInfo *PropName = Property->getIdentifier();
6753 if (!PropName || PropName->getLength() == 0)
6756 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
6758 // Builder that will create each code completion.
6759 typedef CodeCompletionResult Result;
6760 CodeCompletionAllocator &Allocator = Results.getAllocator();
6761 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
6763 // The selector table.
6764 SelectorTable &Selectors = Context.Selectors;
6766 // The property name, copied into the code completion allocation region
6769 CodeCompletionAllocator &Allocator;
6771 const char *CopiedKey;
6773 KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key)
6774 : Allocator(Allocator), Key(Key), CopiedKey(nullptr) {}
6776 operator const char *() {
6780 return CopiedKey = Allocator.CopyString(Key);
6782 } Key(Allocator, PropName->getName());
6784 // The uppercased name of the property name.
6785 std::string UpperKey = PropName->getName();
6786 if (!UpperKey.empty())
6787 UpperKey[0] = toUppercase(UpperKey[0]);
6789 bool ReturnTypeMatchesProperty = ReturnType.isNull() ||
6790 Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(),
6791 Property->getType());
6792 bool ReturnTypeMatchesVoid
6793 = ReturnType.isNull() || ReturnType->isVoidType();
6795 // Add the normal accessor -(type)key.
6796 if (IsInstanceMethod &&
6797 KnownSelectors.insert(Selectors.getNullarySelector(PropName)).second &&
6798 ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) {
6799 if (ReturnType.isNull())
6800 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6801 Context, Policy, Builder);
6803 Builder.AddTypedTextChunk(Key);
6804 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6805 CXCursor_ObjCInstanceMethodDecl));
6808 // If we have an integral or boolean property (or the user has provided
6809 // an integral or boolean return type), add the accessor -(type)isKey.
6810 if (IsInstanceMethod &&
6811 ((!ReturnType.isNull() &&
6812 (ReturnType->isIntegerType() || ReturnType->isBooleanType())) ||
6813 (ReturnType.isNull() &&
6814 (Property->getType()->isIntegerType() ||
6815 Property->getType()->isBooleanType())))) {
6816 std::string SelectorName = (Twine("is") + UpperKey).str();
6817 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6818 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6820 if (ReturnType.isNull()) {
6821 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6822 Builder.AddTextChunk("BOOL");
6823 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6826 Builder.AddTypedTextChunk(
6827 Allocator.CopyString(SelectorId->getName()));
6828 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6829 CXCursor_ObjCInstanceMethodDecl));
6833 // Add the normal mutator.
6834 if (IsInstanceMethod && ReturnTypeMatchesVoid &&
6835 !Property->getSetterMethodDecl()) {
6836 std::string SelectorName = (Twine("set") + UpperKey).str();
6837 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6838 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6839 if (ReturnType.isNull()) {
6840 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6841 Builder.AddTextChunk("void");
6842 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6845 Builder.AddTypedTextChunk(
6846 Allocator.CopyString(SelectorId->getName()));
6847 Builder.AddTypedTextChunk(":");
6848 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6849 Context, Policy, Builder);
6850 Builder.AddTextChunk(Key);
6851 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6852 CXCursor_ObjCInstanceMethodDecl));
6856 // Indexed and unordered accessors
6857 unsigned IndexedGetterPriority = CCP_CodePattern;
6858 unsigned IndexedSetterPriority = CCP_CodePattern;
6859 unsigned UnorderedGetterPriority = CCP_CodePattern;
6860 unsigned UnorderedSetterPriority = CCP_CodePattern;
6861 if (const ObjCObjectPointerType *ObjCPointer
6862 = Property->getType()->getAs<ObjCObjectPointerType>()) {
6863 if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) {
6864 // If this interface type is not provably derived from a known
6865 // collection, penalize the corresponding completions.
6866 if (!InheritsFromClassNamed(IFace, "NSMutableArray")) {
6867 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6868 if (!InheritsFromClassNamed(IFace, "NSArray"))
6869 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6872 if (!InheritsFromClassNamed(IFace, "NSMutableSet")) {
6873 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6874 if (!InheritsFromClassNamed(IFace, "NSSet"))
6875 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6879 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6880 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6881 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6882 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6885 // Add -(NSUInteger)countOf<key>
6886 if (IsInstanceMethod &&
6887 (ReturnType.isNull() || ReturnType->isIntegerType())) {
6888 std::string SelectorName = (Twine("countOf") + UpperKey).str();
6889 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6890 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6892 if (ReturnType.isNull()) {
6893 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6894 Builder.AddTextChunk("NSUInteger");
6895 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6898 Builder.AddTypedTextChunk(
6899 Allocator.CopyString(SelectorId->getName()));
6900 Results.AddResult(Result(Builder.TakeString(),
6901 std::min(IndexedGetterPriority,
6902 UnorderedGetterPriority),
6903 CXCursor_ObjCInstanceMethodDecl));
6908 // Add -(id)objectInKeyAtIndex:(NSUInteger)index
6909 if (IsInstanceMethod &&
6910 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
6911 std::string SelectorName
6912 = (Twine("objectIn") + UpperKey + "AtIndex").str();
6913 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6914 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6915 if (ReturnType.isNull()) {
6916 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6917 Builder.AddTextChunk("id");
6918 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6921 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6922 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6923 Builder.AddTextChunk("NSUInteger");
6924 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6925 Builder.AddTextChunk("index");
6926 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6927 CXCursor_ObjCInstanceMethodDecl));
6931 // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes
6932 if (IsInstanceMethod &&
6933 (ReturnType.isNull() ||
6934 (ReturnType->isObjCObjectPointerType() &&
6935 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6936 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6937 ->getName() == "NSArray"))) {
6938 std::string SelectorName
6939 = (Twine(Property->getName()) + "AtIndexes").str();
6940 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6941 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6942 if (ReturnType.isNull()) {
6943 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6944 Builder.AddTextChunk("NSArray *");
6945 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6948 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6949 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6950 Builder.AddTextChunk("NSIndexSet *");
6951 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6952 Builder.AddTextChunk("indexes");
6953 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6954 CXCursor_ObjCInstanceMethodDecl));
6958 // Add -(void)getKey:(type **)buffer range:(NSRange)inRange
6959 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6960 std::string SelectorName = (Twine("get") + UpperKey).str();
6961 IdentifierInfo *SelectorIds[2] = {
6962 &Context.Idents.get(SelectorName),
6963 &Context.Idents.get("range")
6966 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6967 if (ReturnType.isNull()) {
6968 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6969 Builder.AddTextChunk("void");
6970 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6973 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6974 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6975 Builder.AddPlaceholderChunk("object-type");
6976 Builder.AddTextChunk(" **");
6977 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6978 Builder.AddTextChunk("buffer");
6979 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6980 Builder.AddTypedTextChunk("range:");
6981 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6982 Builder.AddTextChunk("NSRange");
6983 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6984 Builder.AddTextChunk("inRange");
6985 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6986 CXCursor_ObjCInstanceMethodDecl));
6990 // Mutable indexed accessors
6992 // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index
6993 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6994 std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str();
6995 IdentifierInfo *SelectorIds[2] = {
6996 &Context.Idents.get("insertObject"),
6997 &Context.Idents.get(SelectorName)
7000 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7001 if (ReturnType.isNull()) {
7002 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7003 Builder.AddTextChunk("void");
7004 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7007 Builder.AddTypedTextChunk("insertObject:");
7008 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7009 Builder.AddPlaceholderChunk("object-type");
7010 Builder.AddTextChunk(" *");
7011 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7012 Builder.AddTextChunk("object");
7013 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7014 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7015 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7016 Builder.AddPlaceholderChunk("NSUInteger");
7017 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7018 Builder.AddTextChunk("index");
7019 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7020 CXCursor_ObjCInstanceMethodDecl));
7024 // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes
7025 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7026 std::string SelectorName = (Twine("insert") + UpperKey).str();
7027 IdentifierInfo *SelectorIds[2] = {
7028 &Context.Idents.get(SelectorName),
7029 &Context.Idents.get("atIndexes")
7032 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7033 if (ReturnType.isNull()) {
7034 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7035 Builder.AddTextChunk("void");
7036 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7039 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7040 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7041 Builder.AddTextChunk("NSArray *");
7042 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7043 Builder.AddTextChunk("array");
7044 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7045 Builder.AddTypedTextChunk("atIndexes:");
7046 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7047 Builder.AddPlaceholderChunk("NSIndexSet *");
7048 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7049 Builder.AddTextChunk("indexes");
7050 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7051 CXCursor_ObjCInstanceMethodDecl));
7055 // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index
7056 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7057 std::string SelectorName
7058 = (Twine("removeObjectFrom") + UpperKey + "AtIndex").str();
7059 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7060 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7061 if (ReturnType.isNull()) {
7062 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7063 Builder.AddTextChunk("void");
7064 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7067 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7068 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7069 Builder.AddTextChunk("NSUInteger");
7070 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7071 Builder.AddTextChunk("index");
7072 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7073 CXCursor_ObjCInstanceMethodDecl));
7077 // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes
7078 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7079 std::string SelectorName
7080 = (Twine("remove") + UpperKey + "AtIndexes").str();
7081 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7082 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7083 if (ReturnType.isNull()) {
7084 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7085 Builder.AddTextChunk("void");
7086 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7089 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7090 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7091 Builder.AddTextChunk("NSIndexSet *");
7092 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7093 Builder.AddTextChunk("indexes");
7094 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7095 CXCursor_ObjCInstanceMethodDecl));
7099 // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object
7100 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7101 std::string SelectorName
7102 = (Twine("replaceObjectIn") + UpperKey + "AtIndex").str();
7103 IdentifierInfo *SelectorIds[2] = {
7104 &Context.Idents.get(SelectorName),
7105 &Context.Idents.get("withObject")
7108 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7109 if (ReturnType.isNull()) {
7110 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7111 Builder.AddTextChunk("void");
7112 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7115 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7116 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7117 Builder.AddPlaceholderChunk("NSUInteger");
7118 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7119 Builder.AddTextChunk("index");
7120 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7121 Builder.AddTypedTextChunk("withObject:");
7122 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7123 Builder.AddTextChunk("id");
7124 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7125 Builder.AddTextChunk("object");
7126 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7127 CXCursor_ObjCInstanceMethodDecl));
7131 // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array
7132 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7133 std::string SelectorName1
7134 = (Twine("replace") + UpperKey + "AtIndexes").str();
7135 std::string SelectorName2 = (Twine("with") + UpperKey).str();
7136 IdentifierInfo *SelectorIds[2] = {
7137 &Context.Idents.get(SelectorName1),
7138 &Context.Idents.get(SelectorName2)
7141 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7142 if (ReturnType.isNull()) {
7143 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7144 Builder.AddTextChunk("void");
7145 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7148 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName1 + ":"));
7149 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7150 Builder.AddPlaceholderChunk("NSIndexSet *");
7151 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7152 Builder.AddTextChunk("indexes");
7153 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7154 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":"));
7155 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7156 Builder.AddTextChunk("NSArray *");
7157 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7158 Builder.AddTextChunk("array");
7159 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7160 CXCursor_ObjCInstanceMethodDecl));
7164 // Unordered getters
7165 // - (NSEnumerator *)enumeratorOfKey
7166 if (IsInstanceMethod &&
7167 (ReturnType.isNull() ||
7168 (ReturnType->isObjCObjectPointerType() &&
7169 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7170 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
7171 ->getName() == "NSEnumerator"))) {
7172 std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str();
7173 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7174 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7176 if (ReturnType.isNull()) {
7177 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7178 Builder.AddTextChunk("NSEnumerator *");
7179 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7182 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7183 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
7184 CXCursor_ObjCInstanceMethodDecl));
7188 // - (type *)memberOfKey:(type *)object
7189 if (IsInstanceMethod &&
7190 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
7191 std::string SelectorName = (Twine("memberOf") + UpperKey).str();
7192 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7193 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7194 if (ReturnType.isNull()) {
7195 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7196 Builder.AddPlaceholderChunk("object-type");
7197 Builder.AddTextChunk(" *");
7198 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7201 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7202 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7203 if (ReturnType.isNull()) {
7204 Builder.AddPlaceholderChunk("object-type");
7205 Builder.AddTextChunk(" *");
7207 Builder.AddTextChunk(GetCompletionTypeString(ReturnType, Context,
7209 Builder.getAllocator()));
7211 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7212 Builder.AddTextChunk("object");
7213 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
7214 CXCursor_ObjCInstanceMethodDecl));
7218 // Mutable unordered accessors
7219 // - (void)addKeyObject:(type *)object
7220 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7221 std::string SelectorName
7222 = (Twine("add") + UpperKey + Twine("Object")).str();
7223 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7224 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7225 if (ReturnType.isNull()) {
7226 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7227 Builder.AddTextChunk("void");
7228 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7231 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7232 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7233 Builder.AddPlaceholderChunk("object-type");
7234 Builder.AddTextChunk(" *");
7235 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7236 Builder.AddTextChunk("object");
7237 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7238 CXCursor_ObjCInstanceMethodDecl));
7242 // - (void)addKey:(NSSet *)objects
7243 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7244 std::string SelectorName = (Twine("add") + UpperKey).str();
7245 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7246 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7247 if (ReturnType.isNull()) {
7248 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7249 Builder.AddTextChunk("void");
7250 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7253 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7254 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7255 Builder.AddTextChunk("NSSet *");
7256 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7257 Builder.AddTextChunk("objects");
7258 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7259 CXCursor_ObjCInstanceMethodDecl));
7263 // - (void)removeKeyObject:(type *)object
7264 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7265 std::string SelectorName
7266 = (Twine("remove") + UpperKey + Twine("Object")).str();
7267 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7268 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7269 if (ReturnType.isNull()) {
7270 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7271 Builder.AddTextChunk("void");
7272 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7275 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7276 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7277 Builder.AddPlaceholderChunk("object-type");
7278 Builder.AddTextChunk(" *");
7279 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7280 Builder.AddTextChunk("object");
7281 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7282 CXCursor_ObjCInstanceMethodDecl));
7286 // - (void)removeKey:(NSSet *)objects
7287 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7288 std::string SelectorName = (Twine("remove") + UpperKey).str();
7289 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7290 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7291 if (ReturnType.isNull()) {
7292 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7293 Builder.AddTextChunk("void");
7294 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7297 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7298 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7299 Builder.AddTextChunk("NSSet *");
7300 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7301 Builder.AddTextChunk("objects");
7302 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7303 CXCursor_ObjCInstanceMethodDecl));
7307 // - (void)intersectKey:(NSSet *)objects
7308 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7309 std::string SelectorName = (Twine("intersect") + UpperKey).str();
7310 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7311 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7312 if (ReturnType.isNull()) {
7313 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7314 Builder.AddTextChunk("void");
7315 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7318 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7319 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7320 Builder.AddTextChunk("NSSet *");
7321 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7322 Builder.AddTextChunk("objects");
7323 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7324 CXCursor_ObjCInstanceMethodDecl));
7328 // Key-Value Observing
7329 // + (NSSet *)keyPathsForValuesAffectingKey
7330 if (!IsInstanceMethod &&
7331 (ReturnType.isNull() ||
7332 (ReturnType->isObjCObjectPointerType() &&
7333 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7334 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
7335 ->getName() == "NSSet"))) {
7336 std::string SelectorName
7337 = (Twine("keyPathsForValuesAffecting") + UpperKey).str();
7338 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7339 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7341 if (ReturnType.isNull()) {
7342 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7343 Builder.AddTextChunk("NSSet<NSString *> *");
7344 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7347 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7348 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7349 CXCursor_ObjCClassMethodDecl));
7353 // + (BOOL)automaticallyNotifiesObserversForKey
7354 if (!IsInstanceMethod &&
7355 (ReturnType.isNull() ||
7356 ReturnType->isIntegerType() ||
7357 ReturnType->isBooleanType())) {
7358 std::string SelectorName
7359 = (Twine("automaticallyNotifiesObserversOf") + UpperKey).str();
7360 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7361 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7363 if (ReturnType.isNull()) {
7364 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7365 Builder.AddTextChunk("BOOL");
7366 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7369 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7370 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7371 CXCursor_ObjCClassMethodDecl));
7376 void Sema::CodeCompleteObjCMethodDecl(Scope *S,
7377 bool IsInstanceMethod,
7378 ParsedType ReturnTy) {
7379 // Determine the return type of the method we're declaring, if
7381 QualType ReturnType = GetTypeFromParser(ReturnTy);
7382 Decl *IDecl = nullptr;
7383 if (CurContext->isObjCContainer()) {
7384 ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
7385 IDecl = cast<Decl>(OCD);
7387 // Determine where we should start searching for methods.
7388 ObjCContainerDecl *SearchDecl = nullptr;
7389 bool IsInImplementation = false;
7390 if (Decl *D = IDecl) {
7391 if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) {
7392 SearchDecl = Impl->getClassInterface();
7393 IsInImplementation = true;
7394 } else if (ObjCCategoryImplDecl *CatImpl
7395 = dyn_cast<ObjCCategoryImplDecl>(D)) {
7396 SearchDecl = CatImpl->getCategoryDecl();
7397 IsInImplementation = true;
7399 SearchDecl = dyn_cast<ObjCContainerDecl>(D);
7402 if (!SearchDecl && S) {
7403 if (DeclContext *DC = S->getEntity())
7404 SearchDecl = dyn_cast<ObjCContainerDecl>(DC);
7408 HandleCodeCompleteResults(this, CodeCompleter,
7409 CodeCompletionContext::CCC_Other,
7414 // Find all of the methods that we could declare/implement here.
7415 KnownMethodsMap KnownMethods;
7416 FindImplementableMethods(Context, SearchDecl, IsInstanceMethod,
7417 ReturnType, KnownMethods);
7419 // Add declarations or definitions for each of the known methods.
7420 typedef CodeCompletionResult Result;
7421 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7422 CodeCompleter->getCodeCompletionTUInfo(),
7423 CodeCompletionContext::CCC_Other);
7424 Results.EnterNewScope();
7425 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
7426 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7427 MEnd = KnownMethods.end();
7429 ObjCMethodDecl *Method = M->second.getPointer();
7430 CodeCompletionBuilder Builder(Results.getAllocator(),
7431 Results.getCodeCompletionTUInfo());
7433 // If the result type was not already provided, add it to the
7434 // pattern as (type).
7435 if (ReturnType.isNull()) {
7436 QualType ResTy = Method->getSendResultType().stripObjCKindOfType(Context);
7437 AttributedType::stripOuterNullability(ResTy);
7438 AddObjCPassingTypeChunk(ResTy,
7439 Method->getObjCDeclQualifier(), Context, Policy,
7443 Selector Sel = Method->getSelector();
7445 // Add the first part of the selector to the pattern.
7446 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7447 Sel.getNameForSlot(0)));
7449 // Add parameters to the pattern.
7451 for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
7452 PEnd = Method->param_end();
7453 P != PEnd; (void)++P, ++I) {
7454 // Add the part of the selector name.
7456 Builder.AddTypedTextChunk(":");
7457 else if (I < Sel.getNumArgs()) {
7458 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7459 Builder.AddTypedTextChunk(
7460 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
7464 // Add the parameter type.
7466 if ((*P)->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
7467 ParamType = (*P)->getType();
7469 ParamType = (*P)->getOriginalType();
7470 ParamType = ParamType.substObjCTypeArgs(Context, {},
7471 ObjCSubstitutionContext::Parameter);
7472 AttributedType::stripOuterNullability(ParamType);
7473 AddObjCPassingTypeChunk(ParamType,
7474 (*P)->getObjCDeclQualifier(),
7478 if (IdentifierInfo *Id = (*P)->getIdentifier())
7479 Builder.AddTextChunk(Builder.getAllocator().CopyString( Id->getName()));
7482 if (Method->isVariadic()) {
7483 if (Method->param_size() > 0)
7484 Builder.AddChunk(CodeCompletionString::CK_Comma);
7485 Builder.AddTextChunk("...");
7488 if (IsInImplementation && Results.includeCodePatterns()) {
7489 // We will be defining the method here, so add a compound statement.
7490 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7491 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
7492 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
7493 if (!Method->getReturnType()->isVoidType()) {
7494 // If the result type is not void, add a return clause.
7495 Builder.AddTextChunk("return");
7496 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7497 Builder.AddPlaceholderChunk("expression");
7498 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
7500 Builder.AddPlaceholderChunk("statements");
7502 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
7503 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
7506 unsigned Priority = CCP_CodePattern;
7507 if (!M->second.getInt())
7508 Priority += CCD_InBaseClass;
7510 Results.AddResult(Result(Builder.TakeString(), Method, Priority));
7513 // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of
7514 // the properties in this class and its categories.
7515 if (Context.getLangOpts().ObjC2) {
7516 SmallVector<ObjCContainerDecl *, 4> Containers;
7517 Containers.push_back(SearchDecl);
7519 VisitedSelectorSet KnownSelectors;
7520 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7521 MEnd = KnownMethods.end();
7523 KnownSelectors.insert(M->first);
7526 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl);
7528 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl))
7529 IFace = Category->getClassInterface();
7532 for (auto *Cat : IFace->visible_categories())
7533 Containers.push_back(Cat);
7535 for (unsigned I = 0, N = Containers.size(); I != N; ++I)
7536 for (auto *P : Containers[I]->instance_properties())
7537 AddObjCKeyValueCompletions(P, IsInstanceMethod, ReturnType, Context,
7538 KnownSelectors, Results);
7541 Results.ExitScope();
7543 HandleCodeCompleteResults(this, CodeCompleter,
7544 CodeCompletionContext::CCC_Other,
7545 Results.data(),Results.size());
7548 void Sema::CodeCompleteObjCMethodDeclSelector(Scope *S,
7549 bool IsInstanceMethod,
7550 bool AtParameterName,
7551 ParsedType ReturnTy,
7552 ArrayRef<IdentifierInfo *> SelIdents) {
7553 // If we have an external source, load the entire class method
7554 // pool from the AST file.
7555 if (ExternalSource) {
7556 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
7558 Selector Sel = ExternalSource->GetExternalSelector(I);
7559 if (Sel.isNull() || MethodPool.count(Sel))
7562 ReadMethodPool(Sel);
7566 // Build the set of methods we can see.
7567 typedef CodeCompletionResult Result;
7568 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7569 CodeCompleter->getCodeCompletionTUInfo(),
7570 CodeCompletionContext::CCC_Other);
7573 Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType());
7575 Results.EnterNewScope();
7576 for (GlobalMethodPool::iterator M = MethodPool.begin(),
7577 MEnd = MethodPool.end();
7579 for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first :
7581 MethList && MethList->getMethod();
7582 MethList = MethList->getNext()) {
7583 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
7586 if (AtParameterName) {
7587 // Suggest parameter names we've seen before.
7588 unsigned NumSelIdents = SelIdents.size();
7590 NumSelIdents <= MethList->getMethod()->param_size()) {
7591 ParmVarDecl *Param =
7592 MethList->getMethod()->parameters()[NumSelIdents - 1];
7593 if (Param->getIdentifier()) {
7594 CodeCompletionBuilder Builder(Results.getAllocator(),
7595 Results.getCodeCompletionTUInfo());
7596 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7597 Param->getIdentifier()->getName()));
7598 Results.AddResult(Builder.TakeString());
7605 Result R(MethList->getMethod(),
7606 Results.getBasePriority(MethList->getMethod()), nullptr);
7607 R.StartParameter = SelIdents.size();
7608 R.AllParametersAreInformative = false;
7609 R.DeclaringEntity = true;
7610 Results.MaybeAddResult(R, CurContext);
7614 Results.ExitScope();
7616 if (!AtParameterName && !SelIdents.empty() &&
7617 SelIdents.front()->getName().startswith("init")) {
7618 for (const auto &M : PP.macros()) {
7619 if (M.first->getName() != "NS_DESIGNATED_INITIALIZER")
7621 Results.EnterNewScope();
7622 CodeCompletionBuilder Builder(Results.getAllocator(),
7623 Results.getCodeCompletionTUInfo());
7624 Builder.AddTypedTextChunk(
7625 Builder.getAllocator().CopyString(M.first->getName()));
7626 Results.AddResult(CodeCompletionResult(Builder.TakeString(), CCP_Macro,
7627 CXCursor_MacroDefinition));
7628 Results.ExitScope();
7632 HandleCodeCompleteResults(this, CodeCompleter,
7633 CodeCompletionContext::CCC_Other,
7634 Results.data(),Results.size());
7637 void Sema::CodeCompletePreprocessorDirective(bool InConditional) {
7638 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7639 CodeCompleter->getCodeCompletionTUInfo(),
7640 CodeCompletionContext::CCC_PreprocessorDirective);
7641 Results.EnterNewScope();
7644 CodeCompletionBuilder Builder(Results.getAllocator(),
7645 Results.getCodeCompletionTUInfo());
7646 Builder.AddTypedTextChunk("if");
7647 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7648 Builder.AddPlaceholderChunk("condition");
7649 Results.AddResult(Builder.TakeString());
7652 Builder.AddTypedTextChunk("ifdef");
7653 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7654 Builder.AddPlaceholderChunk("macro");
7655 Results.AddResult(Builder.TakeString());
7658 Builder.AddTypedTextChunk("ifndef");
7659 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7660 Builder.AddPlaceholderChunk("macro");
7661 Results.AddResult(Builder.TakeString());
7663 if (InConditional) {
7664 // #elif <condition>
7665 Builder.AddTypedTextChunk("elif");
7666 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7667 Builder.AddPlaceholderChunk("condition");
7668 Results.AddResult(Builder.TakeString());
7671 Builder.AddTypedTextChunk("else");
7672 Results.AddResult(Builder.TakeString());
7675 Builder.AddTypedTextChunk("endif");
7676 Results.AddResult(Builder.TakeString());
7679 // #include "header"
7680 Builder.AddTypedTextChunk("include");
7681 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7682 Builder.AddTextChunk("\"");
7683 Builder.AddPlaceholderChunk("header");
7684 Builder.AddTextChunk("\"");
7685 Results.AddResult(Builder.TakeString());
7687 // #include <header>
7688 Builder.AddTypedTextChunk("include");
7689 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7690 Builder.AddTextChunk("<");
7691 Builder.AddPlaceholderChunk("header");
7692 Builder.AddTextChunk(">");
7693 Results.AddResult(Builder.TakeString());
7696 Builder.AddTypedTextChunk("define");
7697 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7698 Builder.AddPlaceholderChunk("macro");
7699 Results.AddResult(Builder.TakeString());
7701 // #define <macro>(<args>)
7702 Builder.AddTypedTextChunk("define");
7703 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7704 Builder.AddPlaceholderChunk("macro");
7705 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7706 Builder.AddPlaceholderChunk("args");
7707 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7708 Results.AddResult(Builder.TakeString());
7711 Builder.AddTypedTextChunk("undef");
7712 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7713 Builder.AddPlaceholderChunk("macro");
7714 Results.AddResult(Builder.TakeString());
7717 Builder.AddTypedTextChunk("line");
7718 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7719 Builder.AddPlaceholderChunk("number");
7720 Results.AddResult(Builder.TakeString());
7722 // #line <number> "filename"
7723 Builder.AddTypedTextChunk("line");
7724 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7725 Builder.AddPlaceholderChunk("number");
7726 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7727 Builder.AddTextChunk("\"");
7728 Builder.AddPlaceholderChunk("filename");
7729 Builder.AddTextChunk("\"");
7730 Results.AddResult(Builder.TakeString());
7733 Builder.AddTypedTextChunk("error");
7734 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7735 Builder.AddPlaceholderChunk("message");
7736 Results.AddResult(Builder.TakeString());
7738 // #pragma <arguments>
7739 Builder.AddTypedTextChunk("pragma");
7740 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7741 Builder.AddPlaceholderChunk("arguments");
7742 Results.AddResult(Builder.TakeString());
7744 if (getLangOpts().ObjC1) {
7746 Builder.AddTypedTextChunk("import");
7747 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7748 Builder.AddTextChunk("\"");
7749 Builder.AddPlaceholderChunk("header");
7750 Builder.AddTextChunk("\"");
7751 Results.AddResult(Builder.TakeString());
7754 Builder.AddTypedTextChunk("import");
7755 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7756 Builder.AddTextChunk("<");
7757 Builder.AddPlaceholderChunk("header");
7758 Builder.AddTextChunk(">");
7759 Results.AddResult(Builder.TakeString());
7762 // #include_next "header"
7763 Builder.AddTypedTextChunk("include_next");
7764 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7765 Builder.AddTextChunk("\"");
7766 Builder.AddPlaceholderChunk("header");
7767 Builder.AddTextChunk("\"");
7768 Results.AddResult(Builder.TakeString());
7770 // #include_next <header>
7771 Builder.AddTypedTextChunk("include_next");
7772 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7773 Builder.AddTextChunk("<");
7774 Builder.AddPlaceholderChunk("header");
7775 Builder.AddTextChunk(">");
7776 Results.AddResult(Builder.TakeString());
7778 // #warning <message>
7779 Builder.AddTypedTextChunk("warning");
7780 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7781 Builder.AddPlaceholderChunk("message");
7782 Results.AddResult(Builder.TakeString());
7784 // Note: #ident and #sccs are such crazy anachronisms that we don't provide
7785 // completions for them. And __include_macros is a Clang-internal extension
7786 // that we don't want to encourage anyone to use.
7788 // FIXME: we don't support #assert or #unassert, so don't suggest them.
7789 Results.ExitScope();
7791 HandleCodeCompleteResults(this, CodeCompleter,
7792 CodeCompletionContext::CCC_PreprocessorDirective,
7793 Results.data(), Results.size());
7796 void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) {
7797 CodeCompleteOrdinaryName(S,
7798 S->getFnParent()? Sema::PCC_RecoveryInFunction
7799 : Sema::PCC_Namespace);
7802 void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) {
7803 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7804 CodeCompleter->getCodeCompletionTUInfo(),
7805 IsDefinition? CodeCompletionContext::CCC_MacroName
7806 : CodeCompletionContext::CCC_MacroNameUse);
7807 if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) {
7808 // Add just the names of macros, not their arguments.
7809 CodeCompletionBuilder Builder(Results.getAllocator(),
7810 Results.getCodeCompletionTUInfo());
7811 Results.EnterNewScope();
7812 for (Preprocessor::macro_iterator M = PP.macro_begin(),
7813 MEnd = PP.macro_end();
7815 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7816 M->first->getName()));
7817 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
7819 CXCursor_MacroDefinition));
7821 Results.ExitScope();
7822 } else if (IsDefinition) {
7823 // FIXME: Can we detect when the user just wrote an include guard above?
7826 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7827 Results.data(), Results.size());
7830 void Sema::CodeCompletePreprocessorExpression() {
7831 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7832 CodeCompleter->getCodeCompletionTUInfo(),
7833 CodeCompletionContext::CCC_PreprocessorExpression);
7835 if (!CodeCompleter || CodeCompleter->includeMacros())
7836 AddMacroResults(PP, Results, true);
7838 // defined (<macro>)
7839 Results.EnterNewScope();
7840 CodeCompletionBuilder Builder(Results.getAllocator(),
7841 Results.getCodeCompletionTUInfo());
7842 Builder.AddTypedTextChunk("defined");
7843 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7844 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7845 Builder.AddPlaceholderChunk("macro");
7846 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7847 Results.AddResult(Builder.TakeString());
7848 Results.ExitScope();
7850 HandleCodeCompleteResults(this, CodeCompleter,
7851 CodeCompletionContext::CCC_PreprocessorExpression,
7852 Results.data(), Results.size());
7855 void Sema::CodeCompletePreprocessorMacroArgument(Scope *S,
7856 IdentifierInfo *Macro,
7857 MacroInfo *MacroInfo,
7858 unsigned Argument) {
7859 // FIXME: In the future, we could provide "overload" results, much like we
7860 // do for function calls.
7862 // Now just ignore this. There will be another code-completion callback
7863 // for the expanded tokens.
7866 void Sema::CodeCompleteNaturalLanguage() {
7867 HandleCodeCompleteResults(this, CodeCompleter,
7868 CodeCompletionContext::CCC_NaturalLanguage,
7872 void Sema::CodeCompleteAvailabilityPlatformName() {
7873 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7874 CodeCompleter->getCodeCompletionTUInfo(),
7875 CodeCompletionContext::CCC_Other);
7876 Results.EnterNewScope();
7877 static const char *Platforms[] = {"macOS", "iOS", "watchOS", "tvOS"};
7878 for (const char *Platform : llvm::makeArrayRef(Platforms)) {
7879 Results.AddResult(CodeCompletionResult(Platform));
7880 Results.AddResult(CodeCompletionResult(Results.getAllocator().CopyString(
7881 Twine(Platform) + "ApplicationExtension")));
7883 Results.ExitScope();
7884 HandleCodeCompleteResults(this, CodeCompleter,
7885 CodeCompletionContext::CCC_Other, Results.data(),
7889 void Sema::GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,
7890 CodeCompletionTUInfo &CCTUInfo,
7891 SmallVectorImpl<CodeCompletionResult> &Results) {
7892 ResultBuilder Builder(*this, Allocator, CCTUInfo,
7893 CodeCompletionContext::CCC_Recovery);
7894 if (!CodeCompleter || CodeCompleter->includeGlobals()) {
7895 CodeCompletionDeclConsumer Consumer(Builder,
7896 Context.getTranslationUnitDecl());
7897 LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName,
7901 if (!CodeCompleter || CodeCompleter->includeMacros())
7902 AddMacroResults(PP, Builder, true);
7905 Results.insert(Results.end(),
7906 Builder.data(), Builder.data() + Builder.size());