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 Expr *defaultArg = Param->getDefaultArg();
2407 const SourceRange SrcRange = defaultArg->getSourceRange();
2408 CharSourceRange CharSrcRange = CharSourceRange::getTokenRange(SrcRange);
2409 bool Invalid = CharSrcRange.isInvalid();
2412 StringRef srcText = Lexer::getSourceText(CharSrcRange, SM, LangOpts, &Invalid);
2416 if (srcText.empty() || srcText == "=") {
2417 // Lexer can't determine the value.
2418 // This happens if the code is incorrect (for example class is forward declared).
2421 std::string DefValue(srcText.str());
2422 // FIXME: remove this check if the Lexer::getSourceText value is fixed and
2423 // this value always has (or always does not have) '=' in front of it
2424 if (DefValue.at(0) != '=') {
2425 // If we don't have '=' in front of value.
2426 // Lexer returns built-in types values without '=' and user-defined types values with it.
2427 return " = " + DefValue;
2429 return " " + DefValue;
2432 /// \brief Add function parameter chunks to the given code completion string.
2433 static void AddFunctionParameterChunks(Preprocessor &PP,
2434 const PrintingPolicy &Policy,
2435 const FunctionDecl *Function,
2436 CodeCompletionBuilder &Result,
2438 bool InOptional = false) {
2439 bool FirstParameter = true;
2441 for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) {
2442 const ParmVarDecl *Param = Function->getParamDecl(P);
2444 if (Param->hasDefaultArg() && !InOptional) {
2445 // When we see an optional default argument, put that argument and
2446 // the remaining default arguments into a new, optional string.
2447 CodeCompletionBuilder Opt(Result.getAllocator(),
2448 Result.getCodeCompletionTUInfo());
2449 if (!FirstParameter)
2450 Opt.AddChunk(CodeCompletionString::CK_Comma);
2451 AddFunctionParameterChunks(PP, Policy, Function, Opt, P, true);
2452 Result.AddOptionalChunk(Opt.TakeString());
2457 FirstParameter = false;
2459 Result.AddChunk(CodeCompletionString::CK_Comma);
2463 // Format the placeholder string.
2464 std::string PlaceholderStr = FormatFunctionParameter(Policy, Param);
2465 if (Param->hasDefaultArg())
2466 PlaceholderStr += GetDefaultValueString(Param, PP.getSourceManager(), PP.getLangOpts());
2468 if (Function->isVariadic() && P == N - 1)
2469 PlaceholderStr += ", ...";
2471 // Add the placeholder string.
2472 Result.AddPlaceholderChunk(
2473 Result.getAllocator().CopyString(PlaceholderStr));
2476 if (const FunctionProtoType *Proto
2477 = Function->getType()->getAs<FunctionProtoType>())
2478 if (Proto->isVariadic()) {
2479 if (Proto->getNumParams() == 0)
2480 Result.AddPlaceholderChunk("...");
2482 MaybeAddSentinel(PP, Function, Result);
2486 /// \brief Add template parameter chunks to the given code completion string.
2487 static void AddTemplateParameterChunks(ASTContext &Context,
2488 const PrintingPolicy &Policy,
2489 const TemplateDecl *Template,
2490 CodeCompletionBuilder &Result,
2491 unsigned MaxParameters = 0,
2493 bool InDefaultArg = false) {
2494 bool FirstParameter = true;
2496 // Prefer to take the template parameter names from the first declaration of
2498 Template = cast<TemplateDecl>(Template->getCanonicalDecl());
2500 TemplateParameterList *Params = Template->getTemplateParameters();
2501 TemplateParameterList::iterator PEnd = Params->end();
2503 PEnd = Params->begin() + MaxParameters;
2504 for (TemplateParameterList::iterator P = Params->begin() + Start;
2506 bool HasDefaultArg = false;
2507 std::string PlaceholderStr;
2508 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
2509 if (TTP->wasDeclaredWithTypename())
2510 PlaceholderStr = "typename";
2512 PlaceholderStr = "class";
2514 if (TTP->getIdentifier()) {
2515 PlaceholderStr += ' ';
2516 PlaceholderStr += TTP->getIdentifier()->getName();
2519 HasDefaultArg = TTP->hasDefaultArgument();
2520 } else if (NonTypeTemplateParmDecl *NTTP
2521 = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
2522 if (NTTP->getIdentifier())
2523 PlaceholderStr = NTTP->getIdentifier()->getName();
2524 NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
2525 HasDefaultArg = NTTP->hasDefaultArgument();
2527 assert(isa<TemplateTemplateParmDecl>(*P));
2528 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
2530 // Since putting the template argument list into the placeholder would
2531 // be very, very long, we just use an abbreviation.
2532 PlaceholderStr = "template<...> class";
2533 if (TTP->getIdentifier()) {
2534 PlaceholderStr += ' ';
2535 PlaceholderStr += TTP->getIdentifier()->getName();
2538 HasDefaultArg = TTP->hasDefaultArgument();
2541 if (HasDefaultArg && !InDefaultArg) {
2542 // When we see an optional default argument, put that argument and
2543 // the remaining default arguments into a new, optional string.
2544 CodeCompletionBuilder Opt(Result.getAllocator(),
2545 Result.getCodeCompletionTUInfo());
2546 if (!FirstParameter)
2547 Opt.AddChunk(CodeCompletionString::CK_Comma);
2548 AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters,
2549 P - Params->begin(), true);
2550 Result.AddOptionalChunk(Opt.TakeString());
2554 InDefaultArg = false;
2557 FirstParameter = false;
2559 Result.AddChunk(CodeCompletionString::CK_Comma);
2561 // Add the placeholder string.
2562 Result.AddPlaceholderChunk(
2563 Result.getAllocator().CopyString(PlaceholderStr));
2567 /// \brief Add a qualifier to the given code-completion string, if the
2568 /// provided nested-name-specifier is non-NULL.
2570 AddQualifierToCompletionString(CodeCompletionBuilder &Result,
2571 NestedNameSpecifier *Qualifier,
2572 bool QualifierIsInformative,
2573 ASTContext &Context,
2574 const PrintingPolicy &Policy) {
2578 std::string PrintedNNS;
2580 llvm::raw_string_ostream OS(PrintedNNS);
2581 Qualifier->print(OS, Policy);
2583 if (QualifierIsInformative)
2584 Result.AddInformativeChunk(Result.getAllocator().CopyString(PrintedNNS));
2586 Result.AddTextChunk(Result.getAllocator().CopyString(PrintedNNS));
2590 AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result,
2591 const FunctionDecl *Function) {
2592 const FunctionProtoType *Proto
2593 = Function->getType()->getAs<FunctionProtoType>();
2594 if (!Proto || !Proto->getTypeQuals())
2597 // FIXME: Add ref-qualifier!
2599 // Handle single qualifiers without copying
2600 if (Proto->getTypeQuals() == Qualifiers::Const) {
2601 Result.AddInformativeChunk(" const");
2605 if (Proto->getTypeQuals() == Qualifiers::Volatile) {
2606 Result.AddInformativeChunk(" volatile");
2610 if (Proto->getTypeQuals() == Qualifiers::Restrict) {
2611 Result.AddInformativeChunk(" restrict");
2615 // Handle multiple qualifiers.
2616 std::string QualsStr;
2617 if (Proto->isConst())
2618 QualsStr += " const";
2619 if (Proto->isVolatile())
2620 QualsStr += " volatile";
2621 if (Proto->isRestrict())
2622 QualsStr += " restrict";
2623 Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
2626 /// \brief Add the name of the given declaration
2627 static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy,
2628 const NamedDecl *ND,
2629 CodeCompletionBuilder &Result) {
2630 DeclarationName Name = ND->getDeclName();
2634 switch (Name.getNameKind()) {
2635 case DeclarationName::CXXOperatorName: {
2636 const char *OperatorName = nullptr;
2637 switch (Name.getCXXOverloadedOperator()) {
2639 case OO_Conditional:
2640 case NUM_OVERLOADED_OPERATORS:
2641 OperatorName = "operator";
2644 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2645 case OO_##Name: OperatorName = "operator" Spelling; break;
2646 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2647 #include "clang/Basic/OperatorKinds.def"
2649 case OO_New: OperatorName = "operator new"; break;
2650 case OO_Delete: OperatorName = "operator delete"; break;
2651 case OO_Array_New: OperatorName = "operator new[]"; break;
2652 case OO_Array_Delete: OperatorName = "operator delete[]"; break;
2653 case OO_Call: OperatorName = "operator()"; break;
2654 case OO_Subscript: OperatorName = "operator[]"; break;
2656 Result.AddTypedTextChunk(OperatorName);
2660 case DeclarationName::Identifier:
2661 case DeclarationName::CXXConversionFunctionName:
2662 case DeclarationName::CXXDestructorName:
2663 case DeclarationName::CXXLiteralOperatorName:
2664 Result.AddTypedTextChunk(
2665 Result.getAllocator().CopyString(ND->getNameAsString()));
2668 case DeclarationName::CXXDeductionGuideName:
2669 case DeclarationName::CXXUsingDirective:
2670 case DeclarationName::ObjCZeroArgSelector:
2671 case DeclarationName::ObjCOneArgSelector:
2672 case DeclarationName::ObjCMultiArgSelector:
2675 case DeclarationName::CXXConstructorName: {
2676 CXXRecordDecl *Record = nullptr;
2677 QualType Ty = Name.getCXXNameType();
2678 if (const RecordType *RecordTy = Ty->getAs<RecordType>())
2679 Record = cast<CXXRecordDecl>(RecordTy->getDecl());
2680 else if (const InjectedClassNameType *InjectedTy
2681 = Ty->getAs<InjectedClassNameType>())
2682 Record = InjectedTy->getDecl();
2684 Result.AddTypedTextChunk(
2685 Result.getAllocator().CopyString(ND->getNameAsString()));
2689 Result.AddTypedTextChunk(
2690 Result.getAllocator().CopyString(Record->getNameAsString()));
2691 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) {
2692 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2693 AddTemplateParameterChunks(Context, Policy, Template, Result);
2694 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2701 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(Sema &S,
2702 const CodeCompletionContext &CCContext,
2703 CodeCompletionAllocator &Allocator,
2704 CodeCompletionTUInfo &CCTUInfo,
2705 bool IncludeBriefComments) {
2706 return CreateCodeCompletionString(S.Context, S.PP, CCContext, Allocator,
2707 CCTUInfo, IncludeBriefComments);
2710 /// \brief If possible, create a new code completion string for the given
2713 /// \returns Either a new, heap-allocated code completion string describing
2714 /// how to use this result, or NULL to indicate that the string or name of the
2715 /// result is all that is needed.
2716 CodeCompletionString *
2717 CodeCompletionResult::CreateCodeCompletionString(ASTContext &Ctx,
2719 const CodeCompletionContext &CCContext,
2720 CodeCompletionAllocator &Allocator,
2721 CodeCompletionTUInfo &CCTUInfo,
2722 bool IncludeBriefComments) {
2723 CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
2725 PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP);
2726 if (Kind == RK_Pattern) {
2727 Pattern->Priority = Priority;
2728 Pattern->Availability = Availability;
2731 Result.addParentContext(Declaration->getDeclContext());
2732 Pattern->ParentName = Result.getParentName();
2733 // Provide code completion comment for self.GetterName where
2734 // GetterName is the getter method for a property with name
2735 // different from the property name (declared via a property
2736 // getter attribute.
2737 const NamedDecl *ND = Declaration;
2738 if (const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(ND))
2739 if (M->isPropertyAccessor())
2740 if (const ObjCPropertyDecl *PDecl = M->findPropertyDecl())
2741 if (PDecl->getGetterName() == M->getSelector() &&
2742 PDecl->getIdentifier() != M->getIdentifier()) {
2743 if (const RawComment *RC =
2744 Ctx.getRawCommentForAnyRedecl(M)) {
2745 Result.addBriefComment(RC->getBriefText(Ctx));
2746 Pattern->BriefComment = Result.getBriefComment();
2748 else if (const RawComment *RC =
2749 Ctx.getRawCommentForAnyRedecl(PDecl)) {
2750 Result.addBriefComment(RC->getBriefText(Ctx));
2751 Pattern->BriefComment = Result.getBriefComment();
2759 if (Kind == RK_Keyword) {
2760 Result.AddTypedTextChunk(Keyword);
2761 return Result.TakeString();
2764 if (Kind == RK_Macro) {
2765 const MacroInfo *MI = PP.getMacroInfo(Macro);
2766 Result.AddTypedTextChunk(
2767 Result.getAllocator().CopyString(Macro->getName()));
2769 if (!MI || !MI->isFunctionLike())
2770 return Result.TakeString();
2772 // Format a function-like macro with placeholders for the arguments.
2773 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2774 MacroInfo::param_iterator A = MI->param_begin(), AEnd = MI->param_end();
2776 // C99 variadic macros add __VA_ARGS__ at the end. Skip it.
2777 if (MI->isC99Varargs()) {
2781 Result.AddPlaceholderChunk("...");
2785 for (MacroInfo::param_iterator A = MI->param_begin(); A != AEnd; ++A) {
2786 if (A != MI->param_begin())
2787 Result.AddChunk(CodeCompletionString::CK_Comma);
2789 if (MI->isVariadic() && (A+1) == AEnd) {
2790 SmallString<32> Arg = (*A)->getName();
2791 if (MI->isC99Varargs())
2795 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
2799 // Non-variadic macros are simple.
2800 Result.AddPlaceholderChunk(
2801 Result.getAllocator().CopyString((*A)->getName()));
2803 Result.AddChunk(CodeCompletionString::CK_RightParen);
2804 return Result.TakeString();
2807 assert(Kind == RK_Declaration && "Missed a result kind?");
2808 const NamedDecl *ND = Declaration;
2809 Result.addParentContext(ND->getDeclContext());
2811 if (IncludeBriefComments) {
2812 // Add documentation comment, if it exists.
2813 if (const RawComment *RC = Ctx.getRawCommentForAnyRedecl(ND)) {
2814 Result.addBriefComment(RC->getBriefText(Ctx));
2816 else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND))
2817 if (OMD->isPropertyAccessor())
2818 if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())
2819 if (const RawComment *RC = Ctx.getRawCommentForAnyRedecl(PDecl))
2820 Result.addBriefComment(RC->getBriefText(Ctx));
2823 if (StartsNestedNameSpecifier) {
2824 Result.AddTypedTextChunk(
2825 Result.getAllocator().CopyString(ND->getNameAsString()));
2826 Result.AddTextChunk("::");
2827 return Result.TakeString();
2830 for (const auto *I : ND->specific_attrs<AnnotateAttr>())
2831 Result.AddAnnotation(Result.getAllocator().CopyString(I->getAnnotation()));
2833 AddResultTypeChunk(Ctx, Policy, ND, CCContext.getBaseType(), Result);
2835 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) {
2836 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2838 AddTypedNameChunk(Ctx, Policy, ND, Result);
2839 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2840 AddFunctionParameterChunks(PP, Policy, Function, Result);
2841 Result.AddChunk(CodeCompletionString::CK_RightParen);
2842 AddFunctionTypeQualsToCompletionString(Result, Function);
2843 return Result.TakeString();
2846 if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) {
2847 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2849 FunctionDecl *Function = FunTmpl->getTemplatedDecl();
2850 AddTypedNameChunk(Ctx, Policy, Function, Result);
2852 // Figure out which template parameters are deduced (or have default
2854 llvm::SmallBitVector Deduced;
2855 Sema::MarkDeducedTemplateParameters(Ctx, FunTmpl, Deduced);
2856 unsigned LastDeducibleArgument;
2857 for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0;
2858 --LastDeducibleArgument) {
2859 if (!Deduced[LastDeducibleArgument - 1]) {
2860 // C++0x: Figure out if the template argument has a default. If so,
2861 // the user doesn't need to type this argument.
2862 // FIXME: We need to abstract template parameters better!
2863 bool HasDefaultArg = false;
2864 NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam(
2865 LastDeducibleArgument - 1);
2866 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
2867 HasDefaultArg = TTP->hasDefaultArgument();
2868 else if (NonTypeTemplateParmDecl *NTTP
2869 = dyn_cast<NonTypeTemplateParmDecl>(Param))
2870 HasDefaultArg = NTTP->hasDefaultArgument();
2872 assert(isa<TemplateTemplateParmDecl>(Param));
2874 = cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument();
2882 if (LastDeducibleArgument) {
2883 // Some of the function template arguments cannot be deduced from a
2884 // function call, so we introduce an explicit template argument list
2885 // containing all of the arguments up to the first deducible argument.
2886 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2887 AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result,
2888 LastDeducibleArgument);
2889 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2892 // Add the function parameters
2893 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2894 AddFunctionParameterChunks(PP, Policy, Function, Result);
2895 Result.AddChunk(CodeCompletionString::CK_RightParen);
2896 AddFunctionTypeQualsToCompletionString(Result, Function);
2897 return Result.TakeString();
2900 if (const TemplateDecl *Template = dyn_cast<TemplateDecl>(ND)) {
2901 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2903 Result.AddTypedTextChunk(
2904 Result.getAllocator().CopyString(Template->getNameAsString()));
2905 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2906 AddTemplateParameterChunks(Ctx, Policy, Template, Result);
2907 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2908 return Result.TakeString();
2911 if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2912 Selector Sel = Method->getSelector();
2913 if (Sel.isUnarySelector()) {
2914 Result.AddTypedTextChunk(Result.getAllocator().CopyString(
2915 Sel.getNameForSlot(0)));
2916 return Result.TakeString();
2919 std::string SelName = Sel.getNameForSlot(0).str();
2921 if (StartParameter == 0)
2922 Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName));
2924 Result.AddInformativeChunk(Result.getAllocator().CopyString(SelName));
2926 // If there is only one parameter, and we're past it, add an empty
2927 // typed-text chunk since there is nothing to type.
2928 if (Method->param_size() == 1)
2929 Result.AddTypedTextChunk("");
2932 for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(),
2933 PEnd = Method->param_end();
2934 P != PEnd; (void)++P, ++Idx) {
2936 std::string Keyword;
2937 if (Idx > StartParameter)
2938 Result.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2939 if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx))
2940 Keyword += II->getName();
2942 if (Idx < StartParameter || AllParametersAreInformative)
2943 Result.AddInformativeChunk(Result.getAllocator().CopyString(Keyword));
2945 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Keyword));
2948 // If we're before the starting parameter, skip the placeholder.
2949 if (Idx < StartParameter)
2953 QualType ParamType = (*P)->getType();
2954 Optional<ArrayRef<QualType>> ObjCSubsts;
2955 if (!CCContext.getBaseType().isNull())
2956 ObjCSubsts = CCContext.getBaseType()->getObjCSubstitutions(Method);
2958 if (ParamType->isBlockPointerType() && !DeclaringEntity)
2959 Arg = FormatFunctionParameter(Policy, *P, true,
2960 /*SuppressBlock=*/false,
2964 ParamType = ParamType.substObjCTypeArgs(Ctx, *ObjCSubsts,
2965 ObjCSubstitutionContext::Parameter);
2966 Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier(),
2968 Arg += ParamType.getAsString(Policy) + ")";
2969 if (IdentifierInfo *II = (*P)->getIdentifier())
2970 if (DeclaringEntity || AllParametersAreInformative)
2971 Arg += II->getName();
2974 if (Method->isVariadic() && (P + 1) == PEnd)
2977 if (DeclaringEntity)
2978 Result.AddTextChunk(Result.getAllocator().CopyString(Arg));
2979 else if (AllParametersAreInformative)
2980 Result.AddInformativeChunk(Result.getAllocator().CopyString(Arg));
2982 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
2985 if (Method->isVariadic()) {
2986 if (Method->param_size() == 0) {
2987 if (DeclaringEntity)
2988 Result.AddTextChunk(", ...");
2989 else if (AllParametersAreInformative)
2990 Result.AddInformativeChunk(", ...");
2992 Result.AddPlaceholderChunk(", ...");
2995 MaybeAddSentinel(PP, Method, Result);
2998 return Result.TakeString();
3002 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
3005 Result.AddTypedTextChunk(
3006 Result.getAllocator().CopyString(ND->getNameAsString()));
3007 return Result.TakeString();
3010 /// \brief Add function overload parameter chunks to the given code completion
3012 static void AddOverloadParameterChunks(ASTContext &Context,
3013 const PrintingPolicy &Policy,
3014 const FunctionDecl *Function,
3015 const FunctionProtoType *Prototype,
3016 CodeCompletionBuilder &Result,
3017 unsigned CurrentArg,
3019 bool InOptional = false) {
3020 bool FirstParameter = true;
3021 unsigned NumParams = Function ? Function->getNumParams()
3022 : Prototype->getNumParams();
3024 for (unsigned P = Start; P != NumParams; ++P) {
3025 if (Function && Function->getParamDecl(P)->hasDefaultArg() && !InOptional) {
3026 // When we see an optional default argument, put that argument and
3027 // the remaining default arguments into a new, optional string.
3028 CodeCompletionBuilder Opt(Result.getAllocator(),
3029 Result.getCodeCompletionTUInfo());
3030 if (!FirstParameter)
3031 Opt.AddChunk(CodeCompletionString::CK_Comma);
3032 // Optional sections are nested.
3033 AddOverloadParameterChunks(Context, Policy, Function, Prototype, Opt,
3034 CurrentArg, P, /*InOptional=*/true);
3035 Result.AddOptionalChunk(Opt.TakeString());
3040 FirstParameter = false;
3042 Result.AddChunk(CodeCompletionString::CK_Comma);
3046 // Format the placeholder string.
3047 std::string Placeholder;
3049 const ParmVarDecl *Param = Function->getParamDecl(P);
3050 Placeholder = FormatFunctionParameter(Policy, Param);
3051 if (Param->hasDefaultArg())
3052 Placeholder += GetDefaultValueString(Param, Context.getSourceManager(), Context.getLangOpts());
3054 Placeholder = Prototype->getParamType(P).getAsString(Policy);
3057 if (P == CurrentArg)
3058 Result.AddCurrentParameterChunk(
3059 Result.getAllocator().CopyString(Placeholder));
3061 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Placeholder));
3064 if (Prototype && Prototype->isVariadic()) {
3065 CodeCompletionBuilder Opt(Result.getAllocator(),
3066 Result.getCodeCompletionTUInfo());
3067 if (!FirstParameter)
3068 Opt.AddChunk(CodeCompletionString::CK_Comma);
3070 if (CurrentArg < NumParams)
3071 Opt.AddPlaceholderChunk("...");
3073 Opt.AddCurrentParameterChunk("...");
3075 Result.AddOptionalChunk(Opt.TakeString());
3079 CodeCompletionString *
3080 CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
3081 unsigned CurrentArg, Sema &S,
3082 CodeCompletionAllocator &Allocator,
3083 CodeCompletionTUInfo &CCTUInfo,
3084 bool IncludeBriefComments) const {
3085 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
3087 // FIXME: Set priority, availability appropriately.
3088 CodeCompletionBuilder Result(Allocator,CCTUInfo, 1, CXAvailability_Available);
3089 FunctionDecl *FDecl = getFunction();
3090 const FunctionProtoType *Proto
3091 = dyn_cast<FunctionProtoType>(getFunctionType());
3092 if (!FDecl && !Proto) {
3093 // Function without a prototype. Just give the return type and a
3094 // highlighted ellipsis.
3095 const FunctionType *FT = getFunctionType();
3096 Result.AddResultTypeChunk(Result.getAllocator().CopyString(
3097 FT->getReturnType().getAsString(Policy)));
3098 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3099 Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
3100 Result.AddChunk(CodeCompletionString::CK_RightParen);
3101 return Result.TakeString();
3105 if (IncludeBriefComments && CurrentArg < FDecl->getNumParams())
3106 if (auto RC = S.getASTContext().getRawCommentForAnyRedecl(
3107 FDecl->getParamDecl(CurrentArg)))
3108 Result.addBriefComment(RC->getBriefText(S.getASTContext()));
3109 AddResultTypeChunk(S.Context, Policy, FDecl, QualType(), Result);
3110 Result.AddTextChunk(
3111 Result.getAllocator().CopyString(FDecl->getNameAsString()));
3113 Result.AddResultTypeChunk(
3114 Result.getAllocator().CopyString(
3115 Proto->getReturnType().getAsString(Policy)));
3118 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3119 AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, Result,
3121 Result.AddChunk(CodeCompletionString::CK_RightParen);
3123 return Result.TakeString();
3126 unsigned clang::getMacroUsagePriority(StringRef MacroName,
3127 const LangOptions &LangOpts,
3128 bool PreferredTypeIsPointer) {
3129 unsigned Priority = CCP_Macro;
3131 // Treat the "nil", "Nil" and "NULL" macros as null pointer constants.
3132 if (MacroName.equals("nil") || MacroName.equals("NULL") ||
3133 MacroName.equals("Nil")) {
3134 Priority = CCP_Constant;
3135 if (PreferredTypeIsPointer)
3136 Priority = Priority / CCF_SimilarTypeMatch;
3138 // Treat "YES", "NO", "true", and "false" as constants.
3139 else if (MacroName.equals("YES") || MacroName.equals("NO") ||
3140 MacroName.equals("true") || MacroName.equals("false"))
3141 Priority = CCP_Constant;
3142 // Treat "bool" as a type.
3143 else if (MacroName.equals("bool"))
3144 Priority = CCP_Type + (LangOpts.ObjC1? CCD_bool_in_ObjC : 0);
3150 CXCursorKind clang::getCursorKindForDecl(const Decl *D) {
3152 return CXCursor_UnexposedDecl;
3154 switch (D->getKind()) {
3155 case Decl::Enum: return CXCursor_EnumDecl;
3156 case Decl::EnumConstant: return CXCursor_EnumConstantDecl;
3157 case Decl::Field: return CXCursor_FieldDecl;
3158 case Decl::Function:
3159 return CXCursor_FunctionDecl;
3160 case Decl::ObjCCategory: return CXCursor_ObjCCategoryDecl;
3161 case Decl::ObjCCategoryImpl: return CXCursor_ObjCCategoryImplDecl;
3162 case Decl::ObjCImplementation: return CXCursor_ObjCImplementationDecl;
3164 case Decl::ObjCInterface: return CXCursor_ObjCInterfaceDecl;
3165 case Decl::ObjCIvar: return CXCursor_ObjCIvarDecl;
3166 case Decl::ObjCMethod:
3167 return cast<ObjCMethodDecl>(D)->isInstanceMethod()
3168 ? CXCursor_ObjCInstanceMethodDecl : CXCursor_ObjCClassMethodDecl;
3169 case Decl::CXXMethod: return CXCursor_CXXMethod;
3170 case Decl::CXXConstructor: return CXCursor_Constructor;
3171 case Decl::CXXDestructor: return CXCursor_Destructor;
3172 case Decl::CXXConversion: return CXCursor_ConversionFunction;
3173 case Decl::ObjCProperty: return CXCursor_ObjCPropertyDecl;
3174 case Decl::ObjCProtocol: return CXCursor_ObjCProtocolDecl;
3175 case Decl::ParmVar: return CXCursor_ParmDecl;
3176 case Decl::Typedef: return CXCursor_TypedefDecl;
3177 case Decl::TypeAlias: return CXCursor_TypeAliasDecl;
3178 case Decl::TypeAliasTemplate: return CXCursor_TypeAliasTemplateDecl;
3179 case Decl::Var: return CXCursor_VarDecl;
3180 case Decl::Namespace: return CXCursor_Namespace;
3181 case Decl::NamespaceAlias: return CXCursor_NamespaceAlias;
3182 case Decl::TemplateTypeParm: return CXCursor_TemplateTypeParameter;
3183 case Decl::NonTypeTemplateParm:return CXCursor_NonTypeTemplateParameter;
3184 case Decl::TemplateTemplateParm:return CXCursor_TemplateTemplateParameter;
3185 case Decl::FunctionTemplate: return CXCursor_FunctionTemplate;
3186 case Decl::ClassTemplate: return CXCursor_ClassTemplate;
3187 case Decl::AccessSpec: return CXCursor_CXXAccessSpecifier;
3188 case Decl::ClassTemplatePartialSpecialization:
3189 return CXCursor_ClassTemplatePartialSpecialization;
3190 case Decl::UsingDirective: return CXCursor_UsingDirective;
3191 case Decl::StaticAssert: return CXCursor_StaticAssert;
3192 case Decl::Friend: return CXCursor_FriendDecl;
3193 case Decl::TranslationUnit: return CXCursor_TranslationUnit;
3196 case Decl::UnresolvedUsingValue:
3197 case Decl::UnresolvedUsingTypename:
3198 return CXCursor_UsingDeclaration;
3200 case Decl::ObjCPropertyImpl:
3201 switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
3202 case ObjCPropertyImplDecl::Dynamic:
3203 return CXCursor_ObjCDynamicDecl;
3205 case ObjCPropertyImplDecl::Synthesize:
3206 return CXCursor_ObjCSynthesizeDecl;
3210 return CXCursor_ModuleImportDecl;
3212 case Decl::ObjCTypeParam: return CXCursor_TemplateTypeParameter;
3215 if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
3216 switch (TD->getTagKind()) {
3217 case TTK_Interface: // fall through
3218 case TTK_Struct: return CXCursor_StructDecl;
3219 case TTK_Class: return CXCursor_ClassDecl;
3220 case TTK_Union: return CXCursor_UnionDecl;
3221 case TTK_Enum: return CXCursor_EnumDecl;
3226 return CXCursor_UnexposedDecl;
3229 static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results,
3230 bool IncludeUndefined,
3231 bool TargetTypeIsPointer = false) {
3232 typedef CodeCompletionResult Result;
3234 Results.EnterNewScope();
3236 for (Preprocessor::macro_iterator M = PP.macro_begin(),
3237 MEnd = PP.macro_end();
3239 auto MD = PP.getMacroDefinition(M->first);
3240 if (IncludeUndefined || MD) {
3241 if (MacroInfo *MI = MD.getMacroInfo())
3242 if (MI->isUsedForHeaderGuard())
3245 Results.AddResult(Result(M->first,
3246 getMacroUsagePriority(M->first->getName(),
3248 TargetTypeIsPointer)));
3252 Results.ExitScope();
3256 static void AddPrettyFunctionResults(const LangOptions &LangOpts,
3257 ResultBuilder &Results) {
3258 typedef CodeCompletionResult Result;
3260 Results.EnterNewScope();
3262 Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant));
3263 Results.AddResult(Result("__FUNCTION__", CCP_Constant));
3264 if (LangOpts.C99 || LangOpts.CPlusPlus11)
3265 Results.AddResult(Result("__func__", CCP_Constant));
3266 Results.ExitScope();
3269 static void HandleCodeCompleteResults(Sema *S,
3270 CodeCompleteConsumer *CodeCompleter,
3271 CodeCompletionContext Context,
3272 CodeCompletionResult *Results,
3273 unsigned NumResults) {
3275 CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults);
3278 static enum CodeCompletionContext::Kind mapCodeCompletionContext(Sema &S,
3279 Sema::ParserCompletionContext PCC) {
3281 case Sema::PCC_Namespace:
3282 return CodeCompletionContext::CCC_TopLevel;
3284 case Sema::PCC_Class:
3285 return CodeCompletionContext::CCC_ClassStructUnion;
3287 case Sema::PCC_ObjCInterface:
3288 return CodeCompletionContext::CCC_ObjCInterface;
3290 case Sema::PCC_ObjCImplementation:
3291 return CodeCompletionContext::CCC_ObjCImplementation;
3293 case Sema::PCC_ObjCInstanceVariableList:
3294 return CodeCompletionContext::CCC_ObjCIvarList;
3296 case Sema::PCC_Template:
3297 case Sema::PCC_MemberTemplate:
3298 if (S.CurContext->isFileContext())
3299 return CodeCompletionContext::CCC_TopLevel;
3300 if (S.CurContext->isRecord())
3301 return CodeCompletionContext::CCC_ClassStructUnion;
3302 return CodeCompletionContext::CCC_Other;
3304 case Sema::PCC_RecoveryInFunction:
3305 return CodeCompletionContext::CCC_Recovery;
3307 case Sema::PCC_ForInit:
3308 if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 ||
3309 S.getLangOpts().ObjC1)
3310 return CodeCompletionContext::CCC_ParenthesizedExpression;
3312 return CodeCompletionContext::CCC_Expression;
3314 case Sema::PCC_Expression:
3315 case Sema::PCC_Condition:
3316 return CodeCompletionContext::CCC_Expression;
3318 case Sema::PCC_Statement:
3319 return CodeCompletionContext::CCC_Statement;
3321 case Sema::PCC_Type:
3322 return CodeCompletionContext::CCC_Type;
3324 case Sema::PCC_ParenthesizedExpression:
3325 return CodeCompletionContext::CCC_ParenthesizedExpression;
3327 case Sema::PCC_LocalDeclarationSpecifiers:
3328 return CodeCompletionContext::CCC_Type;
3331 llvm_unreachable("Invalid ParserCompletionContext!");
3334 /// \brief If we're in a C++ virtual member function, add completion results
3335 /// that invoke the functions we override, since it's common to invoke the
3336 /// overridden function as well as adding new functionality.
3338 /// \param S The semantic analysis object for which we are generating results.
3340 /// \param InContext This context in which the nested-name-specifier preceding
3341 /// the code-completion point
3342 static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext,
3343 ResultBuilder &Results) {
3344 // Look through blocks.
3345 DeclContext *CurContext = S.CurContext;
3346 while (isa<BlockDecl>(CurContext))
3347 CurContext = CurContext->getParent();
3350 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext);
3351 if (!Method || !Method->isVirtual())
3354 // We need to have names for all of the parameters, if we're going to
3355 // generate a forwarding call.
3356 for (auto P : Method->parameters())
3357 if (!P->getDeclName())
3360 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
3361 for (CXXMethodDecl::method_iterator M = Method->begin_overridden_methods(),
3362 MEnd = Method->end_overridden_methods();
3364 CodeCompletionBuilder Builder(Results.getAllocator(),
3365 Results.getCodeCompletionTUInfo());
3366 const CXXMethodDecl *Overridden = *M;
3367 if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl())
3370 // If we need a nested-name-specifier, add one now.
3372 NestedNameSpecifier *NNS
3373 = getRequiredQualification(S.Context, CurContext,
3374 Overridden->getDeclContext());
3377 llvm::raw_string_ostream OS(Str);
3378 NNS->print(OS, Policy);
3379 Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
3381 } else if (!InContext->Equals(Overridden->getDeclContext()))
3384 Builder.AddTypedTextChunk(Results.getAllocator().CopyString(
3385 Overridden->getNameAsString()));
3386 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
3387 bool FirstParam = true;
3388 for (auto P : Method->parameters()) {
3392 Builder.AddChunk(CodeCompletionString::CK_Comma);
3394 Builder.AddPlaceholderChunk(
3395 Results.getAllocator().CopyString(P->getIdentifier()->getName()));
3397 Builder.AddChunk(CodeCompletionString::CK_RightParen);
3398 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
3399 CCP_SuperCompletion,
3401 CXAvailability_Available,
3403 Results.Ignore(Overridden);
3407 void Sema::CodeCompleteModuleImport(SourceLocation ImportLoc,
3408 ModuleIdPath Path) {
3409 typedef CodeCompletionResult Result;
3410 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3411 CodeCompleter->getCodeCompletionTUInfo(),
3412 CodeCompletionContext::CCC_Other);
3413 Results.EnterNewScope();
3415 CodeCompletionAllocator &Allocator = Results.getAllocator();
3416 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
3417 typedef CodeCompletionResult Result;
3419 // Enumerate all top-level modules.
3420 SmallVector<Module *, 8> Modules;
3421 PP.getHeaderSearchInfo().collectAllModules(Modules);
3422 for (unsigned I = 0, N = Modules.size(); I != N; ++I) {
3423 Builder.AddTypedTextChunk(
3424 Builder.getAllocator().CopyString(Modules[I]->Name));
3425 Results.AddResult(Result(Builder.TakeString(),
3427 CXCursor_ModuleImportDecl,
3428 Modules[I]->isAvailable()
3429 ? CXAvailability_Available
3430 : CXAvailability_NotAvailable));
3432 } else if (getLangOpts().Modules) {
3433 // Load the named module.
3434 Module *Mod = PP.getModuleLoader().loadModule(ImportLoc, Path,
3436 /*IsInclusionDirective=*/false);
3437 // Enumerate submodules.
3439 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
3440 SubEnd = Mod->submodule_end();
3441 Sub != SubEnd; ++Sub) {
3443 Builder.AddTypedTextChunk(
3444 Builder.getAllocator().CopyString((*Sub)->Name));
3445 Results.AddResult(Result(Builder.TakeString(),
3447 CXCursor_ModuleImportDecl,
3448 (*Sub)->isAvailable()
3449 ? CXAvailability_Available
3450 : CXAvailability_NotAvailable));
3454 Results.ExitScope();
3455 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3456 Results.data(),Results.size());
3459 void Sema::CodeCompleteOrdinaryName(Scope *S,
3460 ParserCompletionContext CompletionContext) {
3461 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3462 CodeCompleter->getCodeCompletionTUInfo(),
3463 mapCodeCompletionContext(*this, CompletionContext));
3464 Results.EnterNewScope();
3466 // Determine how to filter results, e.g., so that the names of
3467 // values (functions, enumerators, function templates, etc.) are
3468 // only allowed where we can have an expression.
3469 switch (CompletionContext) {
3472 case PCC_ObjCInterface:
3473 case PCC_ObjCImplementation:
3474 case PCC_ObjCInstanceVariableList:
3476 case PCC_MemberTemplate:
3478 case PCC_LocalDeclarationSpecifiers:
3479 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
3483 case PCC_ParenthesizedExpression:
3484 case PCC_Expression:
3487 if (WantTypesInContext(CompletionContext, getLangOpts()))
3488 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3490 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3492 if (getLangOpts().CPlusPlus)
3493 MaybeAddOverrideCalls(*this, /*InContext=*/nullptr, Results);
3496 case PCC_RecoveryInFunction:
3501 // If we are in a C++ non-static member function, check the qualifiers on
3502 // the member function to filter/prioritize the results list.
3503 if (CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext))
3504 if (CurMethod->isInstance())
3505 Results.setObjectTypeQualifiers(
3506 Qualifiers::fromCVRMask(CurMethod->getTypeQualifiers()));
3508 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3509 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3510 CodeCompleter->includeGlobals());
3512 AddOrdinaryNameResults(CompletionContext, S, *this, Results);
3513 Results.ExitScope();
3515 switch (CompletionContext) {
3516 case PCC_ParenthesizedExpression:
3517 case PCC_Expression:
3519 case PCC_RecoveryInFunction:
3520 if (S->getFnParent())
3521 AddPrettyFunctionResults(getLangOpts(), Results);
3526 case PCC_ObjCInterface:
3527 case PCC_ObjCImplementation:
3528 case PCC_ObjCInstanceVariableList:
3530 case PCC_MemberTemplate:
3534 case PCC_LocalDeclarationSpecifiers:
3538 if (CodeCompleter->includeMacros())
3539 AddMacroResults(PP, Results, false);
3541 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3542 Results.data(),Results.size());
3545 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
3546 ParsedType Receiver,
3547 ArrayRef<IdentifierInfo *> SelIdents,
3548 bool AtArgumentExpression,
3550 ResultBuilder &Results);
3552 void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
3553 bool AllowNonIdentifiers,
3554 bool AllowNestedNameSpecifiers) {
3555 typedef CodeCompletionResult Result;
3556 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3557 CodeCompleter->getCodeCompletionTUInfo(),
3558 AllowNestedNameSpecifiers
3559 ? CodeCompletionContext::CCC_PotentiallyQualifiedName
3560 : CodeCompletionContext::CCC_Name);
3561 Results.EnterNewScope();
3563 // Type qualifiers can come after names.
3564 Results.AddResult(Result("const"));
3565 Results.AddResult(Result("volatile"));
3566 if (getLangOpts().C99)
3567 Results.AddResult(Result("restrict"));
3569 if (getLangOpts().CPlusPlus) {
3570 if (getLangOpts().CPlusPlus11 &&
3571 (DS.getTypeSpecType() == DeclSpec::TST_class ||
3572 DS.getTypeSpecType() == DeclSpec::TST_struct))
3573 Results.AddResult("final");
3575 if (AllowNonIdentifiers) {
3576 Results.AddResult(Result("operator"));
3579 // Add nested-name-specifiers.
3580 if (AllowNestedNameSpecifiers) {
3581 Results.allowNestedNameSpecifiers();
3582 Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy);
3583 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3584 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
3585 CodeCompleter->includeGlobals());
3586 Results.setFilter(nullptr);
3589 Results.ExitScope();
3591 // If we're in a context where we might have an expression (rather than a
3592 // declaration), and what we've seen so far is an Objective-C type that could
3593 // be a receiver of a class message, this may be a class message send with
3594 // the initial opening bracket '[' missing. Add appropriate completions.
3595 if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
3596 DS.getParsedSpecifiers() == DeclSpec::PQ_TypeSpecifier &&
3597 DS.getTypeSpecType() == DeclSpec::TST_typename &&
3598 DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified &&
3599 DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
3600 !DS.isTypeAltiVecVector() &&
3602 (S->getFlags() & Scope::DeclScope) != 0 &&
3603 (S->getFlags() & (Scope::ClassScope | Scope::TemplateParamScope |
3604 Scope::FunctionPrototypeScope |
3605 Scope::AtCatchScope)) == 0) {
3606 ParsedType T = DS.getRepAsType();
3607 if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType())
3608 AddClassMessageCompletions(*this, S, T, None, false, false, Results);
3611 // Note that we intentionally suppress macro results here, since we do not
3612 // encourage using macros to produce the names of entities.
3614 HandleCodeCompleteResults(this, CodeCompleter,
3615 Results.getCompletionContext(),
3616 Results.data(), Results.size());
3619 struct Sema::CodeCompleteExpressionData {
3620 CodeCompleteExpressionData(QualType PreferredType = QualType())
3621 : PreferredType(PreferredType), IntegralConstantExpression(false),
3622 ObjCCollection(false) { }
3624 QualType PreferredType;
3625 bool IntegralConstantExpression;
3626 bool ObjCCollection;
3627 SmallVector<Decl *, 4> IgnoreDecls;
3630 /// \brief Perform code-completion in an expression context when we know what
3631 /// type we're looking for.
3632 void Sema::CodeCompleteExpression(Scope *S,
3633 const CodeCompleteExpressionData &Data) {
3634 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3635 CodeCompleter->getCodeCompletionTUInfo(),
3636 CodeCompletionContext::CCC_Expression);
3637 if (Data.ObjCCollection)
3638 Results.setFilter(&ResultBuilder::IsObjCCollection);
3639 else if (Data.IntegralConstantExpression)
3640 Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
3641 else if (WantTypesInContext(PCC_Expression, getLangOpts()))
3642 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3644 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3646 if (!Data.PreferredType.isNull())
3647 Results.setPreferredType(Data.PreferredType.getNonReferenceType());
3649 // Ignore any declarations that we were told that we don't care about.
3650 for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I)
3651 Results.Ignore(Data.IgnoreDecls[I]);
3653 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3654 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3655 CodeCompleter->includeGlobals());
3657 Results.EnterNewScope();
3658 AddOrdinaryNameResults(PCC_Expression, S, *this, Results);
3659 Results.ExitScope();
3661 bool PreferredTypeIsPointer = false;
3662 if (!Data.PreferredType.isNull())
3663 PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType()
3664 || Data.PreferredType->isMemberPointerType()
3665 || Data.PreferredType->isBlockPointerType();
3667 if (S->getFnParent() &&
3668 !Data.ObjCCollection &&
3669 !Data.IntegralConstantExpression)
3670 AddPrettyFunctionResults(getLangOpts(), Results);
3672 if (CodeCompleter->includeMacros())
3673 AddMacroResults(PP, Results, false, PreferredTypeIsPointer);
3674 HandleCodeCompleteResults(this, CodeCompleter,
3675 CodeCompletionContext(CodeCompletionContext::CCC_Expression,
3676 Data.PreferredType),
3677 Results.data(),Results.size());
3680 void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E) {
3682 CodeCompleteOrdinaryName(S, PCC_RecoveryInFunction);
3683 else if (getLangOpts().ObjC1)
3684 CodeCompleteObjCInstanceMessage(S, E.get(), None, false);
3687 /// \brief The set of properties that have already been added, referenced by
3689 typedef llvm::SmallPtrSet<IdentifierInfo*, 16> AddedPropertiesSet;
3691 /// \brief Retrieve the container definition, if any?
3692 static ObjCContainerDecl *getContainerDef(ObjCContainerDecl *Container) {
3693 if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
3694 if (Interface->hasDefinition())
3695 return Interface->getDefinition();
3700 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3701 if (Protocol->hasDefinition())
3702 return Protocol->getDefinition();
3709 /// \brief Adds a block invocation code completion result for the given block
3710 /// declaration \p BD.
3711 static void AddObjCBlockCall(ASTContext &Context, const PrintingPolicy &Policy,
3712 CodeCompletionBuilder &Builder,
3713 const NamedDecl *BD,
3714 const FunctionTypeLoc &BlockLoc,
3715 const FunctionProtoTypeLoc &BlockProtoLoc) {
3716 Builder.AddResultTypeChunk(
3717 GetCompletionTypeString(BlockLoc.getReturnLoc().getType(), Context,
3718 Policy, Builder.getAllocator()));
3720 AddTypedNameChunk(Context, Policy, BD, Builder);
3721 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
3723 if (BlockProtoLoc && BlockProtoLoc.getTypePtr()->isVariadic()) {
3724 Builder.AddPlaceholderChunk("...");
3726 for (unsigned I = 0, N = BlockLoc.getNumParams(); I != N; ++I) {
3728 Builder.AddChunk(CodeCompletionString::CK_Comma);
3730 // Format the placeholder string.
3731 std::string PlaceholderStr =
3732 FormatFunctionParameter(Policy, BlockLoc.getParam(I));
3734 if (I == N - 1 && BlockProtoLoc &&
3735 BlockProtoLoc.getTypePtr()->isVariadic())
3736 PlaceholderStr += ", ...";
3738 // Add the placeholder string.
3739 Builder.AddPlaceholderChunk(
3740 Builder.getAllocator().CopyString(PlaceholderStr));
3744 Builder.AddChunk(CodeCompletionString::CK_RightParen);
3747 static void AddObjCProperties(
3748 const CodeCompletionContext &CCContext, ObjCContainerDecl *Container,
3749 bool AllowCategories, bool AllowNullaryMethods, DeclContext *CurContext,
3750 AddedPropertiesSet &AddedProperties, ResultBuilder &Results,
3751 bool IsBaseExprStatement = false, bool IsClassProperty = false) {
3752 typedef CodeCompletionResult Result;
3754 // Retrieve the definition.
3755 Container = getContainerDef(Container);
3757 // Add properties in this container.
3758 const auto AddProperty = [&](const ObjCPropertyDecl *P) {
3759 if (!AddedProperties.insert(P->getIdentifier()).second)
3762 // FIXME: Provide block invocation completion for non-statement
3764 if (!P->getType().getTypePtr()->isBlockPointerType() ||
3765 !IsBaseExprStatement) {
3766 Results.MaybeAddResult(Result(P, Results.getBasePriority(P), nullptr),
3771 // Block setter and invocation completion is provided only when we are able
3772 // to find the FunctionProtoTypeLoc with parameter names for the block.
3773 FunctionTypeLoc BlockLoc;
3774 FunctionProtoTypeLoc BlockProtoLoc;
3775 findTypeLocationForBlockDecl(P->getTypeSourceInfo(), BlockLoc,
3778 Results.MaybeAddResult(Result(P, Results.getBasePriority(P), nullptr),
3783 // The default completion result for block properties should be the block
3784 // invocation completion when the base expression is a statement.
3785 CodeCompletionBuilder Builder(Results.getAllocator(),
3786 Results.getCodeCompletionTUInfo());
3787 AddObjCBlockCall(Container->getASTContext(),
3788 getCompletionPrintingPolicy(Results.getSema()), Builder, P,
3789 BlockLoc, BlockProtoLoc);
3790 Results.MaybeAddResult(
3791 Result(Builder.TakeString(), P, Results.getBasePriority(P)),
3794 // Provide additional block setter completion iff the base expression is a
3795 // statement and the block property is mutable.
3796 if (!P->isReadOnly()) {
3797 CodeCompletionBuilder Builder(Results.getAllocator(),
3798 Results.getCodeCompletionTUInfo());
3799 AddResultTypeChunk(Container->getASTContext(),
3800 getCompletionPrintingPolicy(Results.getSema()), P,
3801 CCContext.getBaseType(), Builder);
3802 Builder.AddTypedTextChunk(
3803 Results.getAllocator().CopyString(P->getName()));
3804 Builder.AddChunk(CodeCompletionString::CK_Equal);
3806 std::string PlaceholderStr = formatBlockPlaceholder(
3807 getCompletionPrintingPolicy(Results.getSema()), P, BlockLoc,
3808 BlockProtoLoc, /*SuppressBlockName=*/true);
3809 // Add the placeholder string.
3810 Builder.AddPlaceholderChunk(
3811 Builder.getAllocator().CopyString(PlaceholderStr));
3813 // When completing blocks properties that return void the default
3814 // property completion result should show up before the setter,
3815 // otherwise the setter completion should show up before the default
3816 // property completion, as we normally want to use the result of the
3818 Results.MaybeAddResult(
3819 Result(Builder.TakeString(), P,
3820 Results.getBasePriority(P) +
3821 (BlockLoc.getTypePtr()->getReturnType()->isVoidType()
3822 ? CCD_BlockPropertySetter
3823 : -CCD_BlockPropertySetter)),
3828 if (IsClassProperty) {
3829 for (const auto *P : Container->class_properties())
3832 for (const auto *P : Container->instance_properties())
3836 // Add nullary methods or implicit class properties
3837 if (AllowNullaryMethods) {
3838 ASTContext &Context = Container->getASTContext();
3839 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
3840 // Adds a method result
3841 const auto AddMethod = [&](const ObjCMethodDecl *M) {
3842 IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0);
3845 if (!AddedProperties.insert(Name).second)
3847 CodeCompletionBuilder Builder(Results.getAllocator(),
3848 Results.getCodeCompletionTUInfo());
3849 AddResultTypeChunk(Context, Policy, M, CCContext.getBaseType(), Builder);
3850 Builder.AddTypedTextChunk(
3851 Results.getAllocator().CopyString(Name->getName()));
3852 Results.MaybeAddResult(
3853 Result(Builder.TakeString(), M,
3854 CCP_MemberDeclaration + CCD_MethodAsProperty),
3858 if (IsClassProperty) {
3859 for (const auto *M : Container->methods()) {
3860 // Gather the class method that can be used as implicit property
3861 // getters. Methods with arguments or methods that return void aren't
3862 // added to the results as they can't be used as a getter.
3863 if (!M->getSelector().isUnarySelector() ||
3864 M->getReturnType()->isVoidType() || M->isInstanceMethod())
3869 for (auto *M : Container->methods()) {
3870 if (M->getSelector().isUnarySelector())
3876 // Add properties in referenced protocols.
3877 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3878 for (auto *P : Protocol->protocols())
3879 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
3880 CurContext, AddedProperties, Results,
3881 IsBaseExprStatement, IsClassProperty);
3882 } else if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)){
3883 if (AllowCategories) {
3884 // Look through categories.
3885 for (auto *Cat : IFace->known_categories())
3886 AddObjCProperties(CCContext, Cat, AllowCategories, AllowNullaryMethods,
3887 CurContext, AddedProperties, Results,
3888 IsBaseExprStatement, IsClassProperty);
3891 // Look through protocols.
3892 for (auto *I : IFace->all_referenced_protocols())
3893 AddObjCProperties(CCContext, I, AllowCategories, AllowNullaryMethods,
3894 CurContext, AddedProperties, Results,
3895 IsBaseExprStatement, IsClassProperty);
3897 // Look in the superclass.
3898 if (IFace->getSuperClass())
3899 AddObjCProperties(CCContext, IFace->getSuperClass(), AllowCategories,
3900 AllowNullaryMethods, CurContext, AddedProperties,
3901 Results, IsBaseExprStatement, IsClassProperty);
3902 } else if (const ObjCCategoryDecl *Category
3903 = dyn_cast<ObjCCategoryDecl>(Container)) {
3904 // Look through protocols.
3905 for (auto *P : Category->protocols())
3906 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
3907 CurContext, AddedProperties, Results,
3908 IsBaseExprStatement, IsClassProperty);
3912 static void AddRecordMembersCompletionResults(Sema &SemaRef,
3913 ResultBuilder &Results, Scope *S,
3916 // Indicate that we are performing a member access, and the cv-qualifiers
3917 // for the base object type.
3918 Results.setObjectTypeQualifiers(BaseType.getQualifiers());
3920 // Access to a C/C++ class, struct, or union.
3921 Results.allowNestedNameSpecifiers();
3922 CodeCompletionDeclConsumer Consumer(Results, SemaRef.CurContext);
3923 SemaRef.LookupVisibleDecls(RD, Sema::LookupMemberName, Consumer,
3924 SemaRef.CodeCompleter->includeGlobals(),
3925 /*IncludeDependentBases=*/true);
3927 if (SemaRef.getLangOpts().CPlusPlus) {
3928 if (!Results.empty()) {
3929 // The "template" keyword can follow "->" or "." in the grammar.
3930 // However, we only want to suggest the template keyword if something
3932 bool IsDependent = BaseType->isDependentType();
3934 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent())
3935 if (DeclContext *Ctx = DepScope->getEntity()) {
3936 IsDependent = Ctx->isDependentContext();
3942 Results.AddResult(CodeCompletionResult("template"));
3947 void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
3948 SourceLocation OpLoc, bool IsArrow,
3949 bool IsBaseExprStatement) {
3950 if (!Base || !CodeCompleter)
3953 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
3954 if (ConvertedBase.isInvalid())
3956 Base = ConvertedBase.get();
3958 QualType BaseType = Base->getType();
3961 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
3962 BaseType = Ptr->getPointeeType();
3963 else if (BaseType->isObjCObjectPointerType())
3969 enum CodeCompletionContext::Kind contextKind;
3972 contextKind = CodeCompletionContext::CCC_ArrowMemberAccess;
3975 if (BaseType->isObjCObjectPointerType() ||
3976 BaseType->isObjCObjectOrInterfaceType()) {
3977 contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess;
3980 contextKind = CodeCompletionContext::CCC_DotMemberAccess;
3984 CodeCompletionContext CCContext(contextKind, BaseType);
3985 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3986 CodeCompleter->getCodeCompletionTUInfo(),
3988 &ResultBuilder::IsMember);
3989 Results.EnterNewScope();
3990 if (const RecordType *Record = BaseType->getAs<RecordType>()) {
3991 AddRecordMembersCompletionResults(*this, Results, S, BaseType,
3993 } else if (const auto *TST = BaseType->getAs<TemplateSpecializationType>()) {
3994 TemplateName TN = TST->getTemplateName();
3995 if (const auto *TD =
3996 dyn_cast_or_null<ClassTemplateDecl>(TN.getAsTemplateDecl())) {
3997 CXXRecordDecl *RD = TD->getTemplatedDecl();
3998 AddRecordMembersCompletionResults(*this, Results, S, BaseType, RD);
4000 } else if (const auto *ICNT = BaseType->getAs<InjectedClassNameType>()) {
4001 if (auto *RD = ICNT->getDecl())
4002 AddRecordMembersCompletionResults(*this, Results, S, BaseType, RD);
4003 } else if (!IsArrow && BaseType->isObjCObjectPointerType()) {
4004 // Objective-C property reference.
4005 AddedPropertiesSet AddedProperties;
4007 if (const ObjCObjectPointerType *ObjCPtr =
4008 BaseType->getAsObjCInterfacePointerType()) {
4009 // Add property results based on our interface.
4010 assert(ObjCPtr && "Non-NULL pointer guaranteed above!");
4011 AddObjCProperties(CCContext, ObjCPtr->getInterfaceDecl(), true,
4012 /*AllowNullaryMethods=*/true, CurContext,
4013 AddedProperties, Results, IsBaseExprStatement);
4016 // Add properties from the protocols in a qualified interface.
4017 for (auto *I : BaseType->getAs<ObjCObjectPointerType>()->quals())
4018 AddObjCProperties(CCContext, I, true, /*AllowNullaryMethods=*/true,
4019 CurContext, AddedProperties, Results,
4020 IsBaseExprStatement);
4021 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) ||
4022 (!IsArrow && BaseType->isObjCObjectType())) {
4023 // Objective-C instance variable access.
4024 ObjCInterfaceDecl *Class = nullptr;
4025 if (const ObjCObjectPointerType *ObjCPtr
4026 = BaseType->getAs<ObjCObjectPointerType>())
4027 Class = ObjCPtr->getInterfaceDecl();
4029 Class = BaseType->getAs<ObjCObjectType>()->getInterface();
4031 // Add all ivars from this class and its superclasses.
4033 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4034 Results.setFilter(&ResultBuilder::IsObjCIvar);
4035 LookupVisibleDecls(Class, LookupMemberName, Consumer,
4036 CodeCompleter->includeGlobals());
4040 // FIXME: How do we cope with isa?
4042 Results.ExitScope();
4044 // Hand off the results found for code completion.
4045 HandleCodeCompleteResults(this, CodeCompleter,
4046 Results.getCompletionContext(),
4047 Results.data(),Results.size());
4050 void Sema::CodeCompleteObjCClassPropertyRefExpr(Scope *S,
4051 IdentifierInfo &ClassName,
4052 SourceLocation ClassNameLoc,
4053 bool IsBaseExprStatement) {
4054 IdentifierInfo *ClassNamePtr = &ClassName;
4055 ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(ClassNamePtr, ClassNameLoc);
4058 CodeCompletionContext CCContext(
4059 CodeCompletionContext::CCC_ObjCPropertyAccess);
4060 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4061 CodeCompleter->getCodeCompletionTUInfo(), CCContext,
4062 &ResultBuilder::IsMember);
4063 Results.EnterNewScope();
4064 AddedPropertiesSet AddedProperties;
4065 AddObjCProperties(CCContext, IFace, true,
4066 /*AllowNullaryMethods=*/true, CurContext, AddedProperties,
4067 Results, IsBaseExprStatement,
4068 /*IsClassProperty=*/true);
4069 Results.ExitScope();
4070 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4071 Results.data(), Results.size());
4074 void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) {
4078 ResultBuilder::LookupFilter Filter = nullptr;
4079 enum CodeCompletionContext::Kind ContextKind
4080 = CodeCompletionContext::CCC_Other;
4081 switch ((DeclSpec::TST)TagSpec) {
4082 case DeclSpec::TST_enum:
4083 Filter = &ResultBuilder::IsEnum;
4084 ContextKind = CodeCompletionContext::CCC_EnumTag;
4087 case DeclSpec::TST_union:
4088 Filter = &ResultBuilder::IsUnion;
4089 ContextKind = CodeCompletionContext::CCC_UnionTag;
4092 case DeclSpec::TST_struct:
4093 case DeclSpec::TST_class:
4094 case DeclSpec::TST_interface:
4095 Filter = &ResultBuilder::IsClassOrStruct;
4096 ContextKind = CodeCompletionContext::CCC_ClassOrStructTag;
4100 llvm_unreachable("Unknown type specifier kind in CodeCompleteTag");
4103 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4104 CodeCompleter->getCodeCompletionTUInfo(), ContextKind);
4105 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4107 // First pass: look for tags.
4108 Results.setFilter(Filter);
4109 LookupVisibleDecls(S, LookupTagName, Consumer,
4110 CodeCompleter->includeGlobals());
4112 if (CodeCompleter->includeGlobals()) {
4113 // Second pass: look for nested name specifiers.
4114 Results.setFilter(&ResultBuilder::IsNestedNameSpecifier);
4115 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer);
4118 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4119 Results.data(),Results.size());
4122 static void AddTypeQualifierResults(DeclSpec &DS, ResultBuilder &Results,
4123 const LangOptions &LangOpts) {
4124 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
4125 Results.AddResult("const");
4126 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile))
4127 Results.AddResult("volatile");
4128 if (LangOpts.C99 && !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict))
4129 Results.AddResult("restrict");
4130 if (LangOpts.C11 && !(DS.getTypeQualifiers() & DeclSpec::TQ_atomic))
4131 Results.AddResult("_Atomic");
4132 if (LangOpts.MSVCCompat && !(DS.getTypeQualifiers() & DeclSpec::TQ_unaligned))
4133 Results.AddResult("__unaligned");
4136 void Sema::CodeCompleteTypeQualifiers(DeclSpec &DS) {
4137 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4138 CodeCompleter->getCodeCompletionTUInfo(),
4139 CodeCompletionContext::CCC_TypeQualifiers);
4140 Results.EnterNewScope();
4141 AddTypeQualifierResults(DS, Results, LangOpts);
4142 Results.ExitScope();
4143 HandleCodeCompleteResults(this, CodeCompleter,
4144 Results.getCompletionContext(),
4145 Results.data(), Results.size());
4148 void Sema::CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D,
4149 const VirtSpecifiers *VS) {
4150 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4151 CodeCompleter->getCodeCompletionTUInfo(),
4152 CodeCompletionContext::CCC_TypeQualifiers);
4153 Results.EnterNewScope();
4154 AddTypeQualifierResults(DS, Results, LangOpts);
4155 if (LangOpts.CPlusPlus11) {
4156 Results.AddResult("noexcept");
4157 if (D.getContext() == Declarator::MemberContext && !D.isCtorOrDtor() &&
4158 !D.isStaticMember()) {
4159 if (!VS || !VS->isFinalSpecified())
4160 Results.AddResult("final");
4161 if (!VS || !VS->isOverrideSpecified())
4162 Results.AddResult("override");
4165 Results.ExitScope();
4166 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4167 Results.data(), Results.size());
4170 void Sema::CodeCompleteBracketDeclarator(Scope *S) {
4171 CodeCompleteExpression(S, QualType(getASTContext().getSizeType()));
4174 void Sema::CodeCompleteCase(Scope *S) {
4175 if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
4178 SwitchStmt *Switch = getCurFunction()->SwitchStack.back();
4179 QualType type = Switch->getCond()->IgnoreImplicit()->getType();
4180 if (!type->isEnumeralType()) {
4181 CodeCompleteExpressionData Data(type);
4182 Data.IntegralConstantExpression = true;
4183 CodeCompleteExpression(S, Data);
4187 // Code-complete the cases of a switch statement over an enumeration type
4188 // by providing the list of
4189 EnumDecl *Enum = type->castAs<EnumType>()->getDecl();
4190 if (EnumDecl *Def = Enum->getDefinition())
4193 // Determine which enumerators we have already seen in the switch statement.
4194 // FIXME: Ideally, we would also be able to look *past* the code-completion
4195 // token, in case we are code-completing in the middle of the switch and not
4196 // at the end. However, we aren't able to do so at the moment.
4197 llvm::SmallPtrSet<EnumConstantDecl *, 8> EnumeratorsSeen;
4198 NestedNameSpecifier *Qualifier = nullptr;
4199 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC;
4200 SC = SC->getNextSwitchCase()) {
4201 CaseStmt *Case = dyn_cast<CaseStmt>(SC);
4205 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
4206 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CaseVal))
4207 if (EnumConstantDecl *Enumerator
4208 = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
4209 // We look into the AST of the case statement to determine which
4210 // enumerator was named. Alternatively, we could compute the value of
4211 // the integral constant expression, then compare it against the
4212 // values of each enumerator. However, value-based approach would not
4213 // work as well with C++ templates where enumerators declared within a
4214 // template are type- and value-dependent.
4215 EnumeratorsSeen.insert(Enumerator);
4217 // If this is a qualified-id, keep track of the nested-name-specifier
4218 // so that we can reproduce it as part of code completion, e.g.,
4220 // switch (TagD.getKind()) {
4221 // case TagDecl::TK_enum:
4225 // At the XXX, our completions are TagDecl::TK_union,
4226 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union,
4227 // TK_struct, and TK_class.
4228 Qualifier = DRE->getQualifier();
4232 if (getLangOpts().CPlusPlus && !Qualifier && EnumeratorsSeen.empty()) {
4233 // If there are no prior enumerators in C++, check whether we have to
4234 // qualify the names of the enumerators that we suggest, because they
4235 // may not be visible in this scope.
4236 Qualifier = getRequiredQualification(Context, CurContext, Enum);
4239 // Add any enumerators that have not yet been mentioned.
4240 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4241 CodeCompleter->getCodeCompletionTUInfo(),
4242 CodeCompletionContext::CCC_Expression);
4243 Results.EnterNewScope();
4244 for (auto *E : Enum->enumerators()) {
4245 if (EnumeratorsSeen.count(E))
4248 CodeCompletionResult R(E, CCP_EnumInCase, Qualifier);
4249 Results.AddResult(R, CurContext, nullptr, false);
4251 Results.ExitScope();
4253 //We need to make sure we're setting the right context,
4254 //so only say we include macros if the code completer says we do
4255 enum CodeCompletionContext::Kind kind = CodeCompletionContext::CCC_Other;
4256 if (CodeCompleter->includeMacros()) {
4257 AddMacroResults(PP, Results, false);
4258 kind = CodeCompletionContext::CCC_OtherWithMacros;
4261 HandleCodeCompleteResults(this, CodeCompleter,
4263 Results.data(),Results.size());
4266 static bool anyNullArguments(ArrayRef<Expr *> Args) {
4267 if (Args.size() && !Args.data())
4270 for (unsigned I = 0; I != Args.size(); ++I)
4277 typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate;
4279 static void mergeCandidatesWithResults(Sema &SemaRef,
4280 SmallVectorImpl<ResultCandidate> &Results,
4281 OverloadCandidateSet &CandidateSet,
4282 SourceLocation Loc) {
4283 if (!CandidateSet.empty()) {
4284 // Sort the overload candidate set by placing the best overloads first.
4286 CandidateSet.begin(), CandidateSet.end(),
4287 [&](const OverloadCandidate &X, const OverloadCandidate &Y) {
4288 return isBetterOverloadCandidate(SemaRef, X, Y, Loc);
4291 // Add the remaining viable overload candidates as code-completion results.
4292 for (auto &Candidate : CandidateSet)
4293 if (Candidate.Viable)
4294 Results.push_back(ResultCandidate(Candidate.Function));
4298 /// \brief Get the type of the Nth parameter from a given set of overload
4300 static QualType getParamType(Sema &SemaRef,
4301 ArrayRef<ResultCandidate> Candidates,
4304 // Given the overloads 'Candidates' for a function call matching all arguments
4305 // up to N, return the type of the Nth parameter if it is the same for all
4306 // overload candidates.
4308 for (auto &Candidate : Candidates) {
4309 if (auto FType = Candidate.getFunctionType())
4310 if (auto Proto = dyn_cast<FunctionProtoType>(FType))
4311 if (N < Proto->getNumParams()) {
4312 if (ParamType.isNull())
4313 ParamType = Proto->getParamType(N);
4314 else if (!SemaRef.Context.hasSameUnqualifiedType(
4315 ParamType.getNonReferenceType(),
4316 Proto->getParamType(N).getNonReferenceType()))
4317 // Otherwise return a default-constructed QualType.
4325 static void CodeCompleteOverloadResults(Sema &SemaRef, Scope *S,
4326 MutableArrayRef<ResultCandidate> Candidates,
4327 unsigned CurrentArg,
4328 bool CompleteExpressionWithCurrentArg = true) {
4330 if (CompleteExpressionWithCurrentArg)
4331 ParamType = getParamType(SemaRef, Candidates, CurrentArg);
4333 if (ParamType.isNull())
4334 SemaRef.CodeCompleteOrdinaryName(S, Sema::PCC_Expression);
4336 SemaRef.CodeCompleteExpression(S, ParamType);
4338 if (!Candidates.empty())
4339 SemaRef.CodeCompleter->ProcessOverloadCandidates(SemaRef, CurrentArg,
4344 void Sema::CodeCompleteCall(Scope *S, Expr *Fn, ArrayRef<Expr *> Args) {
4348 // When we're code-completing for a call, we fall back to ordinary
4349 // name code-completion whenever we can't produce specific
4350 // results. We may want to revisit this strategy in the future,
4351 // e.g., by merging the two kinds of results.
4353 // FIXME: Provide support for variadic template functions.
4355 // Ignore type-dependent call expressions entirely.
4356 if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args) ||
4357 Expr::hasAnyTypeDependentArguments(Args)) {
4358 CodeCompleteOrdinaryName(S, PCC_Expression);
4362 // Build an overload candidate set based on the functions we find.
4363 SourceLocation Loc = Fn->getExprLoc();
4364 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
4366 SmallVector<ResultCandidate, 8> Results;
4368 Expr *NakedFn = Fn->IgnoreParenCasts();
4369 if (auto ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn))
4370 AddOverloadedCallCandidates(ULE, Args, CandidateSet,
4371 /*PartialOverloading=*/true);
4372 else if (auto UME = dyn_cast<UnresolvedMemberExpr>(NakedFn)) {
4373 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
4374 if (UME->hasExplicitTemplateArgs()) {
4375 UME->copyTemplateArgumentsInto(TemplateArgsBuffer);
4376 TemplateArgs = &TemplateArgsBuffer;
4379 // Add the base as first argument (use a nullptr if the base is implicit).
4380 SmallVector<Expr *, 12> ArgExprs(
4381 1, UME->isImplicitAccess() ? nullptr : UME->getBase());
4382 ArgExprs.append(Args.begin(), Args.end());
4383 UnresolvedSet<8> Decls;
4384 Decls.append(UME->decls_begin(), UME->decls_end());
4385 AddFunctionCandidates(Decls, ArgExprs, CandidateSet, TemplateArgs,
4386 /*SuppressUsedConversions=*/false,
4387 /*PartialOverloading=*/true);
4389 FunctionDecl *FD = nullptr;
4390 if (auto MCE = dyn_cast<MemberExpr>(NakedFn))
4391 FD = dyn_cast<FunctionDecl>(MCE->getMemberDecl());
4392 else if (auto DRE = dyn_cast<DeclRefExpr>(NakedFn))
4393 FD = dyn_cast<FunctionDecl>(DRE->getDecl());
4394 if (FD) { // We check whether it's a resolved function declaration.
4395 if (!getLangOpts().CPlusPlus ||
4396 !FD->getType()->getAs<FunctionProtoType>())
4397 Results.push_back(ResultCandidate(FD));
4399 AddOverloadCandidate(FD, DeclAccessPair::make(FD, FD->getAccess()),
4401 /*SuppressUsedConversions=*/false,
4402 /*PartialOverloading=*/true);
4404 } else if (auto DC = NakedFn->getType()->getAsCXXRecordDecl()) {
4405 // If expression's type is CXXRecordDecl, it may overload the function
4406 // call operator, so we check if it does and add them as candidates.
4407 // A complete type is needed to lookup for member function call operators.
4408 if (isCompleteType(Loc, NakedFn->getType())) {
4409 DeclarationName OpName = Context.DeclarationNames
4410 .getCXXOperatorName(OO_Call);
4411 LookupResult R(*this, OpName, Loc, LookupOrdinaryName);
4412 LookupQualifiedName(R, DC);
4413 R.suppressDiagnostics();
4414 SmallVector<Expr *, 12> ArgExprs(1, NakedFn);
4415 ArgExprs.append(Args.begin(), Args.end());
4416 AddFunctionCandidates(R.asUnresolvedSet(), ArgExprs, CandidateSet,
4417 /*ExplicitArgs=*/nullptr,
4418 /*SuppressUsedConversions=*/false,
4419 /*PartialOverloading=*/true);
4422 // Lastly we check whether expression's type is function pointer or
4424 QualType T = NakedFn->getType();
4425 if (!T->getPointeeType().isNull())
4426 T = T->getPointeeType();
4428 if (auto FP = T->getAs<FunctionProtoType>()) {
4429 if (!TooManyArguments(FP->getNumParams(), Args.size(),
4430 /*PartialOverloading=*/true) ||
4432 Results.push_back(ResultCandidate(FP));
4433 } else if (auto FT = T->getAs<FunctionType>())
4434 // No prototype and declaration, it may be a K & R style function.
4435 Results.push_back(ResultCandidate(FT));
4439 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4440 CodeCompleteOverloadResults(*this, S, Results, Args.size(),
4441 !CandidateSet.empty());
4444 void Sema::CodeCompleteConstructor(Scope *S, QualType Type, SourceLocation Loc,
4445 ArrayRef<Expr *> Args) {
4449 // A complete type is needed to lookup for constructors.
4450 if (!isCompleteType(Loc, Type))
4453 CXXRecordDecl *RD = Type->getAsCXXRecordDecl();
4455 CodeCompleteExpression(S, Type);
4459 // FIXME: Provide support for member initializers.
4460 // FIXME: Provide support for variadic template constructors.
4462 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
4464 for (auto C : LookupConstructors(RD)) {
4465 if (auto FD = dyn_cast<FunctionDecl>(C)) {
4466 AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()),
4468 /*SuppressUsedConversions=*/false,
4469 /*PartialOverloading=*/true);
4470 } else if (auto FTD = dyn_cast<FunctionTemplateDecl>(C)) {
4471 AddTemplateOverloadCandidate(FTD,
4472 DeclAccessPair::make(FTD, C->getAccess()),
4473 /*ExplicitTemplateArgs=*/nullptr,
4475 /*SuppressUsedConversions=*/false,
4476 /*PartialOverloading=*/true);
4480 SmallVector<ResultCandidate, 8> Results;
4481 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4482 CodeCompleteOverloadResults(*this, S, Results, Args.size());
4485 void Sema::CodeCompleteInitializer(Scope *S, Decl *D) {
4486 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D);
4488 CodeCompleteOrdinaryName(S, PCC_Expression);
4492 CodeCompleteExpression(S, VD->getType());
4495 void Sema::CodeCompleteReturn(Scope *S) {
4496 QualType ResultType;
4497 if (isa<BlockDecl>(CurContext)) {
4498 if (BlockScopeInfo *BSI = getCurBlock())
4499 ResultType = BSI->ReturnType;
4500 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(CurContext))
4501 ResultType = Function->getReturnType();
4502 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(CurContext))
4503 ResultType = Method->getReturnType();
4505 if (ResultType.isNull())
4506 CodeCompleteOrdinaryName(S, PCC_Expression);
4508 CodeCompleteExpression(S, ResultType);
4511 void Sema::CodeCompleteAfterIf(Scope *S) {
4512 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4513 CodeCompleter->getCodeCompletionTUInfo(),
4514 mapCodeCompletionContext(*this, PCC_Statement));
4515 Results.setFilter(&ResultBuilder::IsOrdinaryName);
4516 Results.EnterNewScope();
4518 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4519 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4520 CodeCompleter->includeGlobals());
4522 AddOrdinaryNameResults(PCC_Statement, S, *this, Results);
4525 CodeCompletionBuilder Builder(Results.getAllocator(),
4526 Results.getCodeCompletionTUInfo());
4527 Builder.AddTypedTextChunk("else");
4528 if (Results.includeCodePatterns()) {
4529 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4530 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4531 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4532 Builder.AddPlaceholderChunk("statements");
4533 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4534 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4536 Results.AddResult(Builder.TakeString());
4539 Builder.AddTypedTextChunk("else");
4540 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4541 Builder.AddTextChunk("if");
4542 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4543 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4544 if (getLangOpts().CPlusPlus)
4545 Builder.AddPlaceholderChunk("condition");
4547 Builder.AddPlaceholderChunk("expression");
4548 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4549 if (Results.includeCodePatterns()) {
4550 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4551 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4552 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4553 Builder.AddPlaceholderChunk("statements");
4554 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4555 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4557 Results.AddResult(Builder.TakeString());
4559 Results.ExitScope();
4561 if (S->getFnParent())
4562 AddPrettyFunctionResults(getLangOpts(), Results);
4564 if (CodeCompleter->includeMacros())
4565 AddMacroResults(PP, Results, false);
4567 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4568 Results.data(),Results.size());
4571 void Sema::CodeCompleteAssignmentRHS(Scope *S, Expr *LHS) {
4573 CodeCompleteExpression(S, static_cast<Expr *>(LHS)->getType());
4575 CodeCompleteOrdinaryName(S, PCC_Expression);
4578 void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
4579 bool EnteringContext) {
4580 if (!SS.getScopeRep() || !CodeCompleter)
4583 // Always pretend to enter a context to ensure that a dependent type
4584 // resolves to a dependent record.
4585 DeclContext *Ctx = computeDeclContext(SS, /*EnteringContext=*/true);
4589 // Try to instantiate any non-dependent declaration contexts before
4591 if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx))
4594 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4595 CodeCompleter->getCodeCompletionTUInfo(),
4596 CodeCompletionContext::CCC_Name);
4597 Results.EnterNewScope();
4599 // The "template" keyword can follow "::" in the grammar, but only
4600 // put it into the grammar if the nested-name-specifier is dependent.
4601 NestedNameSpecifier *NNS = SS.getScopeRep();
4602 if (!Results.empty() && NNS->isDependent())
4603 Results.AddResult("template");
4605 // Add calls to overridden virtual functions, if there are any.
4607 // FIXME: This isn't wonderful, because we don't know whether we're actually
4608 // in a context that permits expressions. This is a general issue with
4609 // qualified-id completions.
4610 if (!EnteringContext)
4611 MaybeAddOverrideCalls(*this, Ctx, Results);
4612 Results.ExitScope();
4614 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4615 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer,
4616 /*IncludeGlobalScope=*/true,
4617 /*IncludeDependentBases=*/true);
4619 HandleCodeCompleteResults(this, CodeCompleter,
4620 Results.getCompletionContext(),
4621 Results.data(),Results.size());
4624 void Sema::CodeCompleteUsing(Scope *S) {
4628 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4629 CodeCompleter->getCodeCompletionTUInfo(),
4630 CodeCompletionContext::CCC_PotentiallyQualifiedName,
4631 &ResultBuilder::IsNestedNameSpecifier);
4632 Results.EnterNewScope();
4634 // If we aren't in class scope, we could see the "namespace" keyword.
4635 if (!S->isClassScope())
4636 Results.AddResult(CodeCompletionResult("namespace"));
4638 // After "using", we can see anything that would start a
4639 // nested-name-specifier.
4640 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4641 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4642 CodeCompleter->includeGlobals());
4643 Results.ExitScope();
4645 HandleCodeCompleteResults(this, CodeCompleter,
4646 CodeCompletionContext::CCC_PotentiallyQualifiedName,
4647 Results.data(),Results.size());
4650 void Sema::CodeCompleteUsingDirective(Scope *S) {
4654 // After "using namespace", we expect to see a namespace name or namespace
4656 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4657 CodeCompleter->getCodeCompletionTUInfo(),
4658 CodeCompletionContext::CCC_Namespace,
4659 &ResultBuilder::IsNamespaceOrAlias);
4660 Results.EnterNewScope();
4661 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4662 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4663 CodeCompleter->includeGlobals());
4664 Results.ExitScope();
4665 HandleCodeCompleteResults(this, CodeCompleter,
4666 CodeCompletionContext::CCC_Namespace,
4667 Results.data(),Results.size());
4670 void Sema::CodeCompleteNamespaceDecl(Scope *S) {
4674 DeclContext *Ctx = S->getEntity();
4675 if (!S->getParent())
4676 Ctx = Context.getTranslationUnitDecl();
4678 bool SuppressedGlobalResults
4679 = Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx);
4681 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4682 CodeCompleter->getCodeCompletionTUInfo(),
4683 SuppressedGlobalResults
4684 ? CodeCompletionContext::CCC_Namespace
4685 : CodeCompletionContext::CCC_Other,
4686 &ResultBuilder::IsNamespace);
4688 if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) {
4689 // We only want to see those namespaces that have already been defined
4690 // within this scope, because its likely that the user is creating an
4691 // extended namespace declaration. Keep track of the most recent
4692 // definition of each namespace.
4693 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest;
4694 for (DeclContext::specific_decl_iterator<NamespaceDecl>
4695 NS(Ctx->decls_begin()), NSEnd(Ctx->decls_end());
4697 OrigToLatest[NS->getOriginalNamespace()] = *NS;
4699 // Add the most recent definition (or extended definition) of each
4700 // namespace to the list of results.
4701 Results.EnterNewScope();
4702 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator
4703 NS = OrigToLatest.begin(),
4704 NSEnd = OrigToLatest.end();
4706 Results.AddResult(CodeCompletionResult(
4707 NS->second, Results.getBasePriority(NS->second),
4709 CurContext, nullptr, false);
4710 Results.ExitScope();
4713 HandleCodeCompleteResults(this, CodeCompleter,
4714 Results.getCompletionContext(),
4715 Results.data(),Results.size());
4718 void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) {
4722 // After "namespace", we expect to see a namespace or alias.
4723 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4724 CodeCompleter->getCodeCompletionTUInfo(),
4725 CodeCompletionContext::CCC_Namespace,
4726 &ResultBuilder::IsNamespaceOrAlias);
4727 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4728 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4729 CodeCompleter->includeGlobals());
4730 HandleCodeCompleteResults(this, CodeCompleter,
4731 Results.getCompletionContext(),
4732 Results.data(),Results.size());
4735 void Sema::CodeCompleteOperatorName(Scope *S) {
4739 typedef CodeCompletionResult Result;
4740 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4741 CodeCompleter->getCodeCompletionTUInfo(),
4742 CodeCompletionContext::CCC_Type,
4743 &ResultBuilder::IsType);
4744 Results.EnterNewScope();
4746 // Add the names of overloadable operators.
4747 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4748 if (std::strcmp(Spelling, "?")) \
4749 Results.AddResult(Result(Spelling));
4750 #include "clang/Basic/OperatorKinds.def"
4752 // Add any type names visible from the current scope
4753 Results.allowNestedNameSpecifiers();
4754 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4755 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4756 CodeCompleter->includeGlobals());
4758 // Add any type specifiers
4759 AddTypeSpecifierResults(getLangOpts(), Results);
4760 Results.ExitScope();
4762 HandleCodeCompleteResults(this, CodeCompleter,
4763 CodeCompletionContext::CCC_Type,
4764 Results.data(),Results.size());
4767 void Sema::CodeCompleteConstructorInitializer(
4769 ArrayRef <CXXCtorInitializer *> Initializers) {
4773 AdjustDeclIfTemplate(ConstructorD);
4775 CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ConstructorD);
4779 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4780 CodeCompleter->getCodeCompletionTUInfo(),
4781 CodeCompletionContext::CCC_PotentiallyQualifiedName);
4782 Results.EnterNewScope();
4784 // Fill in any already-initialized fields or base classes.
4785 llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
4786 llvm::SmallPtrSet<CanQualType, 4> InitializedBases;
4787 for (unsigned I = 0, E = Initializers.size(); I != E; ++I) {
4788 if (Initializers[I]->isBaseInitializer())
4789 InitializedBases.insert(
4790 Context.getCanonicalType(QualType(Initializers[I]->getBaseClass(), 0)));
4792 InitializedFields.insert(cast<FieldDecl>(
4793 Initializers[I]->getAnyMember()));
4796 // Add completions for base classes.
4797 CodeCompletionBuilder Builder(Results.getAllocator(),
4798 Results.getCodeCompletionTUInfo());
4799 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
4800 bool SawLastInitializer = Initializers.empty();
4801 CXXRecordDecl *ClassDecl = Constructor->getParent();
4802 for (const auto &Base : ClassDecl->bases()) {
4803 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4806 = !Initializers.empty() &&
4807 Initializers.back()->isBaseInitializer() &&
4808 Context.hasSameUnqualifiedType(Base.getType(),
4809 QualType(Initializers.back()->getBaseClass(), 0));
4813 Builder.AddTypedTextChunk(
4814 Results.getAllocator().CopyString(
4815 Base.getType().getAsString(Policy)));
4816 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4817 Builder.AddPlaceholderChunk("args");
4818 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4819 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4820 SawLastInitializer? CCP_NextInitializer
4821 : CCP_MemberDeclaration));
4822 SawLastInitializer = false;
4825 // Add completions for virtual base classes.
4826 for (const auto &Base : ClassDecl->vbases()) {
4827 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4830 = !Initializers.empty() &&
4831 Initializers.back()->isBaseInitializer() &&
4832 Context.hasSameUnqualifiedType(Base.getType(),
4833 QualType(Initializers.back()->getBaseClass(), 0));
4837 Builder.AddTypedTextChunk(
4838 Builder.getAllocator().CopyString(
4839 Base.getType().getAsString(Policy)));
4840 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4841 Builder.AddPlaceholderChunk("args");
4842 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4843 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4844 SawLastInitializer? CCP_NextInitializer
4845 : CCP_MemberDeclaration));
4846 SawLastInitializer = false;
4849 // Add completions for members.
4850 for (auto *Field : ClassDecl->fields()) {
4851 if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))
4854 = !Initializers.empty() &&
4855 Initializers.back()->isAnyMemberInitializer() &&
4856 Initializers.back()->getAnyMember() == Field;
4860 if (!Field->getDeclName())
4863 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
4864 Field->getIdentifier()->getName()));
4865 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4866 Builder.AddPlaceholderChunk("args");
4867 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4868 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4869 SawLastInitializer? CCP_NextInitializer
4870 : CCP_MemberDeclaration,
4872 CXAvailability_Available,
4874 SawLastInitializer = false;
4876 Results.ExitScope();
4878 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4879 Results.data(), Results.size());
4882 /// \brief Determine whether this scope denotes a namespace.
4883 static bool isNamespaceScope(Scope *S) {
4884 DeclContext *DC = S->getEntity();
4888 return DC->isFileContext();
4891 void Sema::CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
4892 bool AfterAmpersand) {
4893 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4894 CodeCompleter->getCodeCompletionTUInfo(),
4895 CodeCompletionContext::CCC_Other);
4896 Results.EnterNewScope();
4898 // Note what has already been captured.
4899 llvm::SmallPtrSet<IdentifierInfo *, 4> Known;
4900 bool IncludedThis = false;
4901 for (const auto &C : Intro.Captures) {
4902 if (C.Kind == LCK_This) {
4903 IncludedThis = true;
4910 // Look for other capturable variables.
4911 for (; S && !isNamespaceScope(S); S = S->getParent()) {
4912 for (const auto *D : S->decls()) {
4913 const auto *Var = dyn_cast<VarDecl>(D);
4915 !Var->hasLocalStorage() ||
4916 Var->hasAttr<BlocksAttr>())
4919 if (Known.insert(Var->getIdentifier()).second)
4920 Results.AddResult(CodeCompletionResult(Var, CCP_LocalDeclaration),
4921 CurContext, nullptr, false);
4925 // Add 'this', if it would be valid.
4926 if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy)
4927 addThisCompletion(*this, Results);
4929 Results.ExitScope();
4931 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4932 Results.data(), Results.size());
4935 /// Macro that optionally prepends an "@" to the string literal passed in via
4936 /// Keyword, depending on whether NeedAt is true or false.
4937 #define OBJC_AT_KEYWORD_NAME(NeedAt,Keyword) ((NeedAt)? "@" Keyword : Keyword)
4939 static void AddObjCImplementationResults(const LangOptions &LangOpts,
4940 ResultBuilder &Results,
4942 typedef CodeCompletionResult Result;
4943 // Since we have an implementation, we can end it.
4944 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
4946 CodeCompletionBuilder Builder(Results.getAllocator(),
4947 Results.getCodeCompletionTUInfo());
4948 if (LangOpts.ObjC2) {
4950 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"dynamic"));
4951 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4952 Builder.AddPlaceholderChunk("property");
4953 Results.AddResult(Result(Builder.TakeString()));
4956 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synthesize"));
4957 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4958 Builder.AddPlaceholderChunk("property");
4959 Results.AddResult(Result(Builder.TakeString()));
4963 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
4964 ResultBuilder &Results,
4966 typedef CodeCompletionResult Result;
4968 // Since we have an interface or protocol, we can end it.
4969 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
4971 if (LangOpts.ObjC2) {
4973 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"property")));
4976 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"required")));
4979 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"optional")));
4983 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
4984 typedef CodeCompletionResult Result;
4985 CodeCompletionBuilder Builder(Results.getAllocator(),
4986 Results.getCodeCompletionTUInfo());
4989 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"class"));
4990 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4991 Builder.AddPlaceholderChunk("name");
4992 Results.AddResult(Result(Builder.TakeString()));
4994 if (Results.includeCodePatterns()) {
4996 // FIXME: Could introduce the whole pattern, including superclasses and
4998 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"interface"));
4999 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5000 Builder.AddPlaceholderChunk("class");
5001 Results.AddResult(Result(Builder.TakeString()));
5004 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
5005 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5006 Builder.AddPlaceholderChunk("protocol");
5007 Results.AddResult(Result(Builder.TakeString()));
5009 // @implementation name
5010 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"implementation"));
5011 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5012 Builder.AddPlaceholderChunk("class");
5013 Results.AddResult(Result(Builder.TakeString()));
5016 // @compatibility_alias name
5017 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"compatibility_alias"));
5018 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5019 Builder.AddPlaceholderChunk("alias");
5020 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5021 Builder.AddPlaceholderChunk("class");
5022 Results.AddResult(Result(Builder.TakeString()));
5024 if (Results.getSema().getLangOpts().Modules) {
5026 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import"));
5027 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5028 Builder.AddPlaceholderChunk("module");
5029 Results.AddResult(Result(Builder.TakeString()));
5033 void Sema::CodeCompleteObjCAtDirective(Scope *S) {
5034 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5035 CodeCompleter->getCodeCompletionTUInfo(),
5036 CodeCompletionContext::CCC_Other);
5037 Results.EnterNewScope();
5038 if (isa<ObjCImplDecl>(CurContext))
5039 AddObjCImplementationResults(getLangOpts(), Results, false);
5040 else if (CurContext->isObjCContainer())
5041 AddObjCInterfaceResults(getLangOpts(), Results, false);
5043 AddObjCTopLevelResults(Results, false);
5044 Results.ExitScope();
5045 HandleCodeCompleteResults(this, CodeCompleter,
5046 CodeCompletionContext::CCC_Other,
5047 Results.data(),Results.size());
5050 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) {
5051 typedef CodeCompletionResult Result;
5052 CodeCompletionBuilder Builder(Results.getAllocator(),
5053 Results.getCodeCompletionTUInfo());
5055 // @encode ( type-name )
5056 const char *EncodeType = "char[]";
5057 if (Results.getSema().getLangOpts().CPlusPlus ||
5058 Results.getSema().getLangOpts().ConstStrings)
5059 EncodeType = "const char[]";
5060 Builder.AddResultTypeChunk(EncodeType);
5061 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"encode"));
5062 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5063 Builder.AddPlaceholderChunk("type-name");
5064 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5065 Results.AddResult(Result(Builder.TakeString()));
5067 // @protocol ( protocol-name )
5068 Builder.AddResultTypeChunk("Protocol *");
5069 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
5070 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5071 Builder.AddPlaceholderChunk("protocol-name");
5072 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5073 Results.AddResult(Result(Builder.TakeString()));
5075 // @selector ( selector )
5076 Builder.AddResultTypeChunk("SEL");
5077 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"selector"));
5078 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5079 Builder.AddPlaceholderChunk("selector");
5080 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5081 Results.AddResult(Result(Builder.TakeString()));
5084 Builder.AddResultTypeChunk("NSString *");
5085 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"\""));
5086 Builder.AddPlaceholderChunk("string");
5087 Builder.AddTextChunk("\"");
5088 Results.AddResult(Result(Builder.TakeString()));
5091 Builder.AddResultTypeChunk("NSArray *");
5092 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"["));
5093 Builder.AddPlaceholderChunk("objects, ...");
5094 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
5095 Results.AddResult(Result(Builder.TakeString()));
5097 // @{key : object, ...}
5098 Builder.AddResultTypeChunk("NSDictionary *");
5099 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"{"));
5100 Builder.AddPlaceholderChunk("key");
5101 Builder.AddChunk(CodeCompletionString::CK_Colon);
5102 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5103 Builder.AddPlaceholderChunk("object, ...");
5104 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5105 Results.AddResult(Result(Builder.TakeString()));
5108 Builder.AddResultTypeChunk("id");
5109 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "("));
5110 Builder.AddPlaceholderChunk("expression");
5111 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5112 Results.AddResult(Result(Builder.TakeString()));
5115 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) {
5116 typedef CodeCompletionResult Result;
5117 CodeCompletionBuilder Builder(Results.getAllocator(),
5118 Results.getCodeCompletionTUInfo());
5120 if (Results.includeCodePatterns()) {
5121 // @try { statements } @catch ( declaration ) { statements } @finally
5123 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"try"));
5124 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5125 Builder.AddPlaceholderChunk("statements");
5126 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5127 Builder.AddTextChunk("@catch");
5128 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5129 Builder.AddPlaceholderChunk("parameter");
5130 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5131 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5132 Builder.AddPlaceholderChunk("statements");
5133 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5134 Builder.AddTextChunk("@finally");
5135 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5136 Builder.AddPlaceholderChunk("statements");
5137 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5138 Results.AddResult(Result(Builder.TakeString()));
5142 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"throw"));
5143 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5144 Builder.AddPlaceholderChunk("expression");
5145 Results.AddResult(Result(Builder.TakeString()));
5147 if (Results.includeCodePatterns()) {
5148 // @synchronized ( expression ) { statements }
5149 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synchronized"));
5150 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5151 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5152 Builder.AddPlaceholderChunk("expression");
5153 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5154 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5155 Builder.AddPlaceholderChunk("statements");
5156 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5157 Results.AddResult(Result(Builder.TakeString()));
5161 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
5162 ResultBuilder &Results,
5164 typedef CodeCompletionResult Result;
5165 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"private")));
5166 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"protected")));
5167 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"public")));
5169 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"package")));
5172 void Sema::CodeCompleteObjCAtVisibility(Scope *S) {
5173 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5174 CodeCompleter->getCodeCompletionTUInfo(),
5175 CodeCompletionContext::CCC_Other);
5176 Results.EnterNewScope();
5177 AddObjCVisibilityResults(getLangOpts(), Results, false);
5178 Results.ExitScope();
5179 HandleCodeCompleteResults(this, CodeCompleter,
5180 CodeCompletionContext::CCC_Other,
5181 Results.data(),Results.size());
5184 void Sema::CodeCompleteObjCAtStatement(Scope *S) {
5185 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5186 CodeCompleter->getCodeCompletionTUInfo(),
5187 CodeCompletionContext::CCC_Other);
5188 Results.EnterNewScope();
5189 AddObjCStatementResults(Results, false);
5190 AddObjCExpressionResults(Results, false);
5191 Results.ExitScope();
5192 HandleCodeCompleteResults(this, CodeCompleter,
5193 CodeCompletionContext::CCC_Other,
5194 Results.data(),Results.size());
5197 void Sema::CodeCompleteObjCAtExpression(Scope *S) {
5198 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5199 CodeCompleter->getCodeCompletionTUInfo(),
5200 CodeCompletionContext::CCC_Other);
5201 Results.EnterNewScope();
5202 AddObjCExpressionResults(Results, false);
5203 Results.ExitScope();
5204 HandleCodeCompleteResults(this, CodeCompleter,
5205 CodeCompletionContext::CCC_Other,
5206 Results.data(),Results.size());
5209 /// \brief Determine whether the addition of the given flag to an Objective-C
5210 /// property's attributes will cause a conflict.
5211 static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) {
5212 // Check if we've already added this flag.
5213 if (Attributes & NewFlag)
5216 Attributes |= NewFlag;
5218 // Check for collisions with "readonly".
5219 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
5220 (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
5223 // Check for more than one of { assign, copy, retain, strong, weak }.
5224 unsigned AssignCopyRetMask = Attributes & (ObjCDeclSpec::DQ_PR_assign |
5225 ObjCDeclSpec::DQ_PR_unsafe_unretained |
5226 ObjCDeclSpec::DQ_PR_copy |
5227 ObjCDeclSpec::DQ_PR_retain |
5228 ObjCDeclSpec::DQ_PR_strong |
5229 ObjCDeclSpec::DQ_PR_weak);
5230 if (AssignCopyRetMask &&
5231 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign &&
5232 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_unsafe_unretained &&
5233 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy &&
5234 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain &&
5235 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_strong &&
5236 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_weak)
5242 void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) {
5246 unsigned Attributes = ODS.getPropertyAttributes();
5248 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5249 CodeCompleter->getCodeCompletionTUInfo(),
5250 CodeCompletionContext::CCC_Other);
5251 Results.EnterNewScope();
5252 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readonly))
5253 Results.AddResult(CodeCompletionResult("readonly"));
5254 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_assign))
5255 Results.AddResult(CodeCompletionResult("assign"));
5256 if (!ObjCPropertyFlagConflicts(Attributes,
5257 ObjCDeclSpec::DQ_PR_unsafe_unretained))
5258 Results.AddResult(CodeCompletionResult("unsafe_unretained"));
5259 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readwrite))
5260 Results.AddResult(CodeCompletionResult("readwrite"));
5261 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_retain))
5262 Results.AddResult(CodeCompletionResult("retain"));
5263 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_strong))
5264 Results.AddResult(CodeCompletionResult("strong"));
5265 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_copy))
5266 Results.AddResult(CodeCompletionResult("copy"));
5267 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nonatomic))
5268 Results.AddResult(CodeCompletionResult("nonatomic"));
5269 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_atomic))
5270 Results.AddResult(CodeCompletionResult("atomic"));
5272 // Only suggest "weak" if we're compiling for ARC-with-weak-references or GC.
5273 if (getLangOpts().ObjCWeak || getLangOpts().getGC() != LangOptions::NonGC)
5274 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_weak))
5275 Results.AddResult(CodeCompletionResult("weak"));
5277 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_setter)) {
5278 CodeCompletionBuilder Setter(Results.getAllocator(),
5279 Results.getCodeCompletionTUInfo());
5280 Setter.AddTypedTextChunk("setter");
5281 Setter.AddTextChunk("=");
5282 Setter.AddPlaceholderChunk("method");
5283 Results.AddResult(CodeCompletionResult(Setter.TakeString()));
5285 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_getter)) {
5286 CodeCompletionBuilder Getter(Results.getAllocator(),
5287 Results.getCodeCompletionTUInfo());
5288 Getter.AddTypedTextChunk("getter");
5289 Getter.AddTextChunk("=");
5290 Getter.AddPlaceholderChunk("method");
5291 Results.AddResult(CodeCompletionResult(Getter.TakeString()));
5293 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nullability)) {
5294 Results.AddResult(CodeCompletionResult("nonnull"));
5295 Results.AddResult(CodeCompletionResult("nullable"));
5296 Results.AddResult(CodeCompletionResult("null_unspecified"));
5297 Results.AddResult(CodeCompletionResult("null_resettable"));
5299 Results.ExitScope();
5300 HandleCodeCompleteResults(this, CodeCompleter,
5301 CodeCompletionContext::CCC_Other,
5302 Results.data(),Results.size());
5305 /// \brief Describes the kind of Objective-C method that we want to find
5306 /// via code completion.
5307 enum ObjCMethodKind {
5308 MK_Any, ///< Any kind of method, provided it means other specified criteria.
5309 MK_ZeroArgSelector, ///< Zero-argument (unary) selector.
5310 MK_OneArgSelector ///< One-argument selector.
5313 static bool isAcceptableObjCSelector(Selector Sel,
5314 ObjCMethodKind WantKind,
5315 ArrayRef<IdentifierInfo *> SelIdents,
5316 bool AllowSameLength = true) {
5317 unsigned NumSelIdents = SelIdents.size();
5318 if (NumSelIdents > Sel.getNumArgs())
5323 case MK_ZeroArgSelector: return Sel.isUnarySelector();
5324 case MK_OneArgSelector: return Sel.getNumArgs() == 1;
5327 if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs())
5330 for (unsigned I = 0; I != NumSelIdents; ++I)
5331 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I))
5337 static bool isAcceptableObjCMethod(ObjCMethodDecl *Method,
5338 ObjCMethodKind WantKind,
5339 ArrayRef<IdentifierInfo *> SelIdents,
5340 bool AllowSameLength = true) {
5341 return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents,
5346 /// \brief A set of selectors, which is used to avoid introducing multiple
5347 /// completions with the same selector into the result set.
5348 typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet;
5351 /// \brief Add all of the Objective-C methods in the given Objective-C
5352 /// container to the set of results.
5354 /// The container will be a class, protocol, category, or implementation of
5355 /// any of the above. This mether will recurse to include methods from
5356 /// the superclasses of classes along with their categories, protocols, and
5357 /// implementations.
5359 /// \param Container the container in which we'll look to find methods.
5361 /// \param WantInstanceMethods Whether to add instance methods (only); if
5362 /// false, this routine will add factory methods (only).
5364 /// \param CurContext the context in which we're performing the lookup that
5367 /// \param AllowSameLength Whether we allow a method to be added to the list
5368 /// when it has the same number of parameters as we have selector identifiers.
5370 /// \param Results the structure into which we'll add results.
5371 static void AddObjCMethods(ObjCContainerDecl *Container,
5372 bool WantInstanceMethods, ObjCMethodKind WantKind,
5373 ArrayRef<IdentifierInfo *> SelIdents,
5374 DeclContext *CurContext,
5375 VisitedSelectorSet &Selectors, bool AllowSameLength,
5376 ResultBuilder &Results, bool InOriginalClass = true,
5377 bool IsRootClass = false) {
5378 typedef CodeCompletionResult Result;
5379 Container = getContainerDef(Container);
5380 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
5381 IsRootClass = IsRootClass || (IFace && !IFace->getSuperClass());
5382 for (auto *M : Container->methods()) {
5383 // The instance methods on the root class can be messaged via the
5385 if (M->isInstanceMethod() == WantInstanceMethods ||
5386 (IsRootClass && !WantInstanceMethods)) {
5387 // Check whether the selector identifiers we've been given are a
5388 // subset of the identifiers for this particular method.
5389 if (!isAcceptableObjCMethod(M, WantKind, SelIdents, AllowSameLength))
5392 if (!Selectors.insert(M->getSelector()).second)
5395 Result R = Result(M, Results.getBasePriority(M), nullptr);
5396 R.StartParameter = SelIdents.size();
5397 R.AllParametersAreInformative = (WantKind != MK_Any);
5398 if (!InOriginalClass)
5399 R.Priority += CCD_InBaseClass;
5400 Results.MaybeAddResult(R, CurContext);
5404 // Visit the protocols of protocols.
5405 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
5406 if (Protocol->hasDefinition()) {
5407 const ObjCList<ObjCProtocolDecl> &Protocols
5408 = Protocol->getReferencedProtocols();
5409 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5410 E = Protocols.end();
5412 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5413 Selectors, AllowSameLength, Results, false, IsRootClass);
5417 if (!IFace || !IFace->hasDefinition())
5420 // Add methods in protocols.
5421 for (auto *I : IFace->protocols())
5422 AddObjCMethods(I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5423 Selectors, AllowSameLength, Results, false, IsRootClass);
5425 // Add methods in categories.
5426 for (auto *CatDecl : IFace->known_categories()) {
5427 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
5428 CurContext, Selectors, AllowSameLength, Results,
5429 InOriginalClass, IsRootClass);
5431 // Add a categories protocol methods.
5432 const ObjCList<ObjCProtocolDecl> &Protocols
5433 = CatDecl->getReferencedProtocols();
5434 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5435 E = Protocols.end();
5437 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5438 Selectors, AllowSameLength, Results, false, IsRootClass);
5440 // Add methods in category implementations.
5441 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation())
5442 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
5443 Selectors, AllowSameLength, Results, InOriginalClass,
5447 // Add methods in superclass.
5448 // Avoid passing in IsRootClass since root classes won't have super classes.
5449 if (IFace->getSuperClass())
5450 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind,
5451 SelIdents, CurContext, Selectors, AllowSameLength, Results,
5452 /*IsRootClass=*/false);
5454 // Add methods in our implementation, if any.
5455 if (ObjCImplementationDecl *Impl = IFace->getImplementation())
5456 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
5457 Selectors, AllowSameLength, Results, InOriginalClass,
5462 void Sema::CodeCompleteObjCPropertyGetter(Scope *S) {
5463 // Try to find the interface where getters might live.
5464 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
5466 if (ObjCCategoryDecl *Category
5467 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
5468 Class = Category->getClassInterface();
5474 // Find all of the potential getters.
5475 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5476 CodeCompleter->getCodeCompletionTUInfo(),
5477 CodeCompletionContext::CCC_Other);
5478 Results.EnterNewScope();
5480 VisitedSelectorSet Selectors;
5481 AddObjCMethods(Class, true, MK_ZeroArgSelector, None, CurContext, Selectors,
5482 /*AllowSameLength=*/true, Results);
5483 Results.ExitScope();
5484 HandleCodeCompleteResults(this, CodeCompleter,
5485 CodeCompletionContext::CCC_Other,
5486 Results.data(),Results.size());
5489 void Sema::CodeCompleteObjCPropertySetter(Scope *S) {
5490 // Try to find the interface where setters might live.
5491 ObjCInterfaceDecl *Class
5492 = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
5494 if (ObjCCategoryDecl *Category
5495 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
5496 Class = Category->getClassInterface();
5502 // Find all of the potential getters.
5503 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5504 CodeCompleter->getCodeCompletionTUInfo(),
5505 CodeCompletionContext::CCC_Other);
5506 Results.EnterNewScope();
5508 VisitedSelectorSet Selectors;
5509 AddObjCMethods(Class, true, MK_OneArgSelector, None, CurContext,
5510 Selectors, /*AllowSameLength=*/true, Results);
5512 Results.ExitScope();
5513 HandleCodeCompleteResults(this, CodeCompleter,
5514 CodeCompletionContext::CCC_Other,
5515 Results.data(),Results.size());
5518 void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
5520 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5521 CodeCompleter->getCodeCompletionTUInfo(),
5522 CodeCompletionContext::CCC_Type);
5523 Results.EnterNewScope();
5525 // Add context-sensitive, Objective-C parameter-passing keywords.
5526 bool AddedInOut = false;
5527 if ((DS.getObjCDeclQualifier() &
5528 (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) {
5529 Results.AddResult("in");
5530 Results.AddResult("inout");
5533 if ((DS.getObjCDeclQualifier() &
5534 (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) {
5535 Results.AddResult("out");
5537 Results.AddResult("inout");
5539 if ((DS.getObjCDeclQualifier() &
5540 (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref |
5541 ObjCDeclSpec::DQ_Oneway)) == 0) {
5542 Results.AddResult("bycopy");
5543 Results.AddResult("byref");
5544 Results.AddResult("oneway");
5546 if ((DS.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability) == 0) {
5547 Results.AddResult("nonnull");
5548 Results.AddResult("nullable");
5549 Results.AddResult("null_unspecified");
5552 // If we're completing the return type of an Objective-C method and the
5553 // identifier IBAction refers to a macro, provide a completion item for
5555 // IBAction)<#selector#>:(id)sender
5556 if (DS.getObjCDeclQualifier() == 0 && !IsParameter &&
5557 PP.isMacroDefined("IBAction")) {
5558 CodeCompletionBuilder Builder(Results.getAllocator(),
5559 Results.getCodeCompletionTUInfo(),
5560 CCP_CodePattern, CXAvailability_Available);
5561 Builder.AddTypedTextChunk("IBAction");
5562 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5563 Builder.AddPlaceholderChunk("selector");
5564 Builder.AddChunk(CodeCompletionString::CK_Colon);
5565 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5566 Builder.AddTextChunk("id");
5567 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5568 Builder.AddTextChunk("sender");
5569 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
5572 // If we're completing the return type, provide 'instancetype'.
5574 Results.AddResult(CodeCompletionResult("instancetype"));
5577 // Add various builtin type names and specifiers.
5578 AddOrdinaryNameResults(PCC_Type, S, *this, Results);
5579 Results.ExitScope();
5581 // Add the various type names
5582 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
5583 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5584 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5585 CodeCompleter->includeGlobals());
5587 if (CodeCompleter->includeMacros())
5588 AddMacroResults(PP, Results, false);
5590 HandleCodeCompleteResults(this, CodeCompleter,
5591 CodeCompletionContext::CCC_Type,
5592 Results.data(), Results.size());
5595 /// \brief When we have an expression with type "id", we may assume
5596 /// that it has some more-specific class type based on knowledge of
5597 /// common uses of Objective-C. This routine returns that class type,
5598 /// or NULL if no better result could be determined.
5599 static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) {
5600 ObjCMessageExpr *Msg = dyn_cast_or_null<ObjCMessageExpr>(E);
5604 Selector Sel = Msg->getSelector();
5608 IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0);
5612 ObjCMethodDecl *Method = Msg->getMethodDecl();
5616 // Determine the class that we're sending the message to.
5617 ObjCInterfaceDecl *IFace = nullptr;
5618 switch (Msg->getReceiverKind()) {
5619 case ObjCMessageExpr::Class:
5620 if (const ObjCObjectType *ObjType
5621 = Msg->getClassReceiver()->getAs<ObjCObjectType>())
5622 IFace = ObjType->getInterface();
5625 case ObjCMessageExpr::Instance: {
5626 QualType T = Msg->getInstanceReceiver()->getType();
5627 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
5628 IFace = Ptr->getInterfaceDecl();
5632 case ObjCMessageExpr::SuperInstance:
5633 case ObjCMessageExpr::SuperClass:
5640 ObjCInterfaceDecl *Super = IFace->getSuperClass();
5641 if (Method->isInstanceMethod())
5642 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5643 .Case("retain", IFace)
5644 .Case("strong", IFace)
5645 .Case("autorelease", IFace)
5646 .Case("copy", IFace)
5647 .Case("copyWithZone", IFace)
5648 .Case("mutableCopy", IFace)
5649 .Case("mutableCopyWithZone", IFace)
5650 .Case("awakeFromCoder", IFace)
5651 .Case("replacementObjectFromCoder", IFace)
5652 .Case("class", IFace)
5653 .Case("classForCoder", IFace)
5654 .Case("superclass", Super)
5657 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5659 .Case("alloc", IFace)
5660 .Case("allocWithZone", IFace)
5661 .Case("class", IFace)
5662 .Case("superclass", Super)
5666 // Add a special completion for a message send to "super", which fills in the
5667 // most likely case of forwarding all of our arguments to the superclass
5670 /// \param S The semantic analysis object.
5672 /// \param NeedSuperKeyword Whether we need to prefix this completion with
5673 /// the "super" keyword. Otherwise, we just need to provide the arguments.
5675 /// \param SelIdents The identifiers in the selector that have already been
5676 /// provided as arguments for a send to "super".
5678 /// \param Results The set of results to augment.
5680 /// \returns the Objective-C method declaration that would be invoked by
5681 /// this "super" completion. If NULL, no completion was added.
5682 static ObjCMethodDecl *AddSuperSendCompletion(
5683 Sema &S, bool NeedSuperKeyword,
5684 ArrayRef<IdentifierInfo *> SelIdents,
5685 ResultBuilder &Results) {
5686 ObjCMethodDecl *CurMethod = S.getCurMethodDecl();
5690 ObjCInterfaceDecl *Class = CurMethod->getClassInterface();
5694 // Try to find a superclass method with the same selector.
5695 ObjCMethodDecl *SuperMethod = nullptr;
5696 while ((Class = Class->getSuperClass()) && !SuperMethod) {
5697 // Check in the class
5698 SuperMethod = Class->getMethod(CurMethod->getSelector(),
5699 CurMethod->isInstanceMethod());
5701 // Check in categories or class extensions.
5703 for (const auto *Cat : Class->known_categories()) {
5704 if ((SuperMethod = Cat->getMethod(CurMethod->getSelector(),
5705 CurMethod->isInstanceMethod())))
5714 // Check whether the superclass method has the same signature.
5715 if (CurMethod->param_size() != SuperMethod->param_size() ||
5716 CurMethod->isVariadic() != SuperMethod->isVariadic())
5719 for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(),
5720 CurPEnd = CurMethod->param_end(),
5721 SuperP = SuperMethod->param_begin();
5722 CurP != CurPEnd; ++CurP, ++SuperP) {
5723 // Make sure the parameter types are compatible.
5724 if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(),
5725 (*SuperP)->getType()))
5728 // Make sure we have a parameter name to forward!
5729 if (!(*CurP)->getIdentifier())
5733 // We have a superclass method. Now, form the send-to-super completion.
5734 CodeCompletionBuilder Builder(Results.getAllocator(),
5735 Results.getCodeCompletionTUInfo());
5737 // Give this completion a return type.
5738 AddResultTypeChunk(S.Context, getCompletionPrintingPolicy(S), SuperMethod,
5739 Results.getCompletionContext().getBaseType(),
5742 // If we need the "super" keyword, add it (plus some spacing).
5743 if (NeedSuperKeyword) {
5744 Builder.AddTypedTextChunk("super");
5745 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5748 Selector Sel = CurMethod->getSelector();
5749 if (Sel.isUnarySelector()) {
5750 if (NeedSuperKeyword)
5751 Builder.AddTextChunk(Builder.getAllocator().CopyString(
5752 Sel.getNameForSlot(0)));
5754 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
5755 Sel.getNameForSlot(0)));
5757 ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin();
5758 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) {
5759 if (I > SelIdents.size())
5760 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5762 if (I < SelIdents.size())
5763 Builder.AddInformativeChunk(
5764 Builder.getAllocator().CopyString(
5765 Sel.getNameForSlot(I) + ":"));
5766 else if (NeedSuperKeyword || I > SelIdents.size()) {
5767 Builder.AddTextChunk(
5768 Builder.getAllocator().CopyString(
5769 Sel.getNameForSlot(I) + ":"));
5770 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5771 (*CurP)->getIdentifier()->getName()));
5773 Builder.AddTypedTextChunk(
5774 Builder.getAllocator().CopyString(
5775 Sel.getNameForSlot(I) + ":"));
5776 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5777 (*CurP)->getIdentifier()->getName()));
5782 Results.AddResult(CodeCompletionResult(Builder.TakeString(), SuperMethod,
5783 CCP_SuperCompletion));
5787 void Sema::CodeCompleteObjCMessageReceiver(Scope *S) {
5788 typedef CodeCompletionResult Result;
5789 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5790 CodeCompleter->getCodeCompletionTUInfo(),
5791 CodeCompletionContext::CCC_ObjCMessageReceiver,
5792 getLangOpts().CPlusPlus11
5793 ? &ResultBuilder::IsObjCMessageReceiverOrLambdaCapture
5794 : &ResultBuilder::IsObjCMessageReceiver);
5796 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5797 Results.EnterNewScope();
5798 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5799 CodeCompleter->includeGlobals());
5801 // If we are in an Objective-C method inside a class that has a superclass,
5802 // add "super" as an option.
5803 if (ObjCMethodDecl *Method = getCurMethodDecl())
5804 if (ObjCInterfaceDecl *Iface = Method->getClassInterface())
5805 if (Iface->getSuperClass()) {
5806 Results.AddResult(Result("super"));
5808 AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, None, Results);
5811 if (getLangOpts().CPlusPlus11)
5812 addThisCompletion(*this, Results);
5814 Results.ExitScope();
5816 if (CodeCompleter->includeMacros())
5817 AddMacroResults(PP, Results, false);
5818 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5819 Results.data(), Results.size());
5823 void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
5824 ArrayRef<IdentifierInfo *> SelIdents,
5825 bool AtArgumentExpression) {
5826 ObjCInterfaceDecl *CDecl = nullptr;
5827 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5828 // Figure out which interface we're in.
5829 CDecl = CurMethod->getClassInterface();
5833 // Find the superclass of this class.
5834 CDecl = CDecl->getSuperClass();
5838 if (CurMethod->isInstanceMethod()) {
5839 // We are inside an instance method, which means that the message
5840 // send [super ...] is actually calling an instance method on the
5842 return CodeCompleteObjCInstanceMessage(S, nullptr, SelIdents,
5843 AtArgumentExpression,
5847 // Fall through to send to the superclass in CDecl.
5849 // "super" may be the name of a type or variable. Figure out which
5851 IdentifierInfo *Super = getSuperIdentifier();
5852 NamedDecl *ND = LookupSingleName(S, Super, SuperLoc,
5853 LookupOrdinaryName);
5854 if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) {
5855 // "super" names an interface. Use it.
5856 } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) {
5857 if (const ObjCObjectType *Iface
5858 = Context.getTypeDeclType(TD)->getAs<ObjCObjectType>())
5859 CDecl = Iface->getInterface();
5860 } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) {
5861 // "super" names an unresolved type; we can't be more specific.
5863 // Assume that "super" names some kind of value and parse that way.
5865 SourceLocation TemplateKWLoc;
5867 id.setIdentifier(Super, SuperLoc);
5868 ExprResult SuperExpr = ActOnIdExpression(S, SS, TemplateKWLoc, id,
5870 return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
5872 AtArgumentExpression);
5878 ParsedType Receiver;
5880 Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl));
5881 return CodeCompleteObjCClassMessage(S, Receiver, SelIdents,
5882 AtArgumentExpression,
5886 /// \brief Given a set of code-completion results for the argument of a message
5887 /// send, determine the preferred type (if any) for that argument expression.
5888 static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
5889 unsigned NumSelIdents) {
5890 typedef CodeCompletionResult Result;
5891 ASTContext &Context = Results.getSema().Context;
5893 QualType PreferredType;
5894 unsigned BestPriority = CCP_Unlikely * 2;
5895 Result *ResultsData = Results.data();
5896 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
5897 Result &R = ResultsData[I];
5898 if (R.Kind == Result::RK_Declaration &&
5899 isa<ObjCMethodDecl>(R.Declaration)) {
5900 if (R.Priority <= BestPriority) {
5901 const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration);
5902 if (NumSelIdents <= Method->param_size()) {
5903 QualType MyPreferredType = Method->parameters()[NumSelIdents - 1]
5905 if (R.Priority < BestPriority || PreferredType.isNull()) {
5906 BestPriority = R.Priority;
5907 PreferredType = MyPreferredType;
5908 } else if (!Context.hasSameUnqualifiedType(PreferredType,
5910 PreferredType = QualType();
5917 return PreferredType;
5920 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
5921 ParsedType Receiver,
5922 ArrayRef<IdentifierInfo *> SelIdents,
5923 bool AtArgumentExpression,
5925 ResultBuilder &Results) {
5926 typedef CodeCompletionResult Result;
5927 ObjCInterfaceDecl *CDecl = nullptr;
5929 // If the given name refers to an interface type, retrieve the
5930 // corresponding declaration.
5932 QualType T = SemaRef.GetTypeFromParser(Receiver, nullptr);
5934 if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>())
5935 CDecl = Interface->getInterface();
5938 // Add all of the factory methods in this Objective-C class, its protocols,
5939 // superclasses, categories, implementation, etc.
5940 Results.EnterNewScope();
5942 // If this is a send-to-super, try to add the special "super" send
5945 if (ObjCMethodDecl *SuperMethod
5946 = AddSuperSendCompletion(SemaRef, false, SelIdents, Results))
5947 Results.Ignore(SuperMethod);
5950 // If we're inside an Objective-C method definition, prefer its selector to
5952 if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl())
5953 Results.setPreferredSelector(CurMethod->getSelector());
5955 VisitedSelectorSet Selectors;
5957 AddObjCMethods(CDecl, false, MK_Any, SelIdents,
5958 SemaRef.CurContext, Selectors, AtArgumentExpression,
5961 // We're messaging "id" as a type; provide all class/factory methods.
5963 // If we have an external source, load the entire class method
5964 // pool from the AST file.
5965 if (SemaRef.getExternalSource()) {
5966 for (uint32_t I = 0,
5967 N = SemaRef.getExternalSource()->GetNumExternalSelectors();
5969 Selector Sel = SemaRef.getExternalSource()->GetExternalSelector(I);
5970 if (Sel.isNull() || SemaRef.MethodPool.count(Sel))
5973 SemaRef.ReadMethodPool(Sel);
5977 for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(),
5978 MEnd = SemaRef.MethodPool.end();
5980 for (ObjCMethodList *MethList = &M->second.second;
5981 MethList && MethList->getMethod();
5982 MethList = MethList->getNext()) {
5983 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
5986 Result R(MethList->getMethod(),
5987 Results.getBasePriority(MethList->getMethod()), nullptr);
5988 R.StartParameter = SelIdents.size();
5989 R.AllParametersAreInformative = false;
5990 Results.MaybeAddResult(R, SemaRef.CurContext);
5995 Results.ExitScope();
5998 void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
5999 ArrayRef<IdentifierInfo *> SelIdents,
6000 bool AtArgumentExpression,
6003 QualType T = this->GetTypeFromParser(Receiver);
6005 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6006 CodeCompleter->getCodeCompletionTUInfo(),
6007 CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage,
6010 AddClassMessageCompletions(*this, S, Receiver, SelIdents,
6011 AtArgumentExpression, IsSuper, Results);
6013 // If we're actually at the argument expression (rather than prior to the
6014 // selector), we're actually performing code completion for an expression.
6015 // Determine whether we have a single, best method. If so, we can
6016 // code-complete the expression using the corresponding parameter type as
6017 // our preferred type, improving completion results.
6018 if (AtArgumentExpression) {
6019 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
6021 if (PreferredType.isNull())
6022 CodeCompleteOrdinaryName(S, PCC_Expression);
6024 CodeCompleteExpression(S, PreferredType);
6028 HandleCodeCompleteResults(this, CodeCompleter,
6029 Results.getCompletionContext(),
6030 Results.data(), Results.size());
6033 void Sema::CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
6034 ArrayRef<IdentifierInfo *> SelIdents,
6035 bool AtArgumentExpression,
6036 ObjCInterfaceDecl *Super) {
6037 typedef CodeCompletionResult Result;
6039 Expr *RecExpr = static_cast<Expr *>(Receiver);
6041 // If necessary, apply function/array conversion to the receiver.
6042 // C99 6.7.5.3p[7,8].
6044 ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr);
6045 if (Conv.isInvalid()) // conversion failed. bail.
6047 RecExpr = Conv.get();
6049 QualType ReceiverType = RecExpr? RecExpr->getType()
6050 : Super? Context.getObjCObjectPointerType(
6051 Context.getObjCInterfaceType(Super))
6052 : Context.getObjCIdType();
6054 // If we're messaging an expression with type "id" or "Class", check
6055 // whether we know something special about the receiver that allows
6056 // us to assume a more-specific receiver type.
6057 if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType()) {
6058 if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) {
6059 if (ReceiverType->isObjCClassType())
6060 return CodeCompleteObjCClassMessage(S,
6061 ParsedType::make(Context.getObjCInterfaceType(IFace)),
6063 AtArgumentExpression, Super);
6065 ReceiverType = Context.getObjCObjectPointerType(
6066 Context.getObjCInterfaceType(IFace));
6068 } else if (RecExpr && getLangOpts().CPlusPlus) {
6069 ExprResult Conv = PerformContextuallyConvertToObjCPointer(RecExpr);
6070 if (Conv.isUsable()) {
6071 RecExpr = Conv.get();
6072 ReceiverType = RecExpr->getType();
6076 // Build the set of methods we can see.
6077 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6078 CodeCompleter->getCodeCompletionTUInfo(),
6079 CodeCompletionContext(CodeCompletionContext::CCC_ObjCInstanceMessage,
6080 ReceiverType, SelIdents));
6082 Results.EnterNewScope();
6084 // If this is a send-to-super, try to add the special "super" send
6087 if (ObjCMethodDecl *SuperMethod
6088 = AddSuperSendCompletion(*this, false, SelIdents, Results))
6089 Results.Ignore(SuperMethod);
6092 // If we're inside an Objective-C method definition, prefer its selector to
6094 if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
6095 Results.setPreferredSelector(CurMethod->getSelector());
6097 // Keep track of the selectors we've already added.
6098 VisitedSelectorSet Selectors;
6100 // Handle messages to Class. This really isn't a message to an instance
6101 // method, so we treat it the same way we would treat a message send to a
6103 if (ReceiverType->isObjCClassType() ||
6104 ReceiverType->isObjCQualifiedClassType()) {
6105 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
6106 if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface())
6107 AddObjCMethods(ClassDecl, false, MK_Any, SelIdents,
6108 CurContext, Selectors, AtArgumentExpression, Results);
6111 // Handle messages to a qualified ID ("id<foo>").
6112 else if (const ObjCObjectPointerType *QualID
6113 = ReceiverType->getAsObjCQualifiedIdType()) {
6114 // Search protocols for instance methods.
6115 for (auto *I : QualID->quals())
6116 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
6117 Selectors, AtArgumentExpression, Results);
6119 // Handle messages to a pointer to interface type.
6120 else if (const ObjCObjectPointerType *IFacePtr
6121 = ReceiverType->getAsObjCInterfacePointerType()) {
6122 // Search the class, its superclasses, etc., for instance methods.
6123 AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents,
6124 CurContext, Selectors, AtArgumentExpression,
6127 // Search protocols for instance methods.
6128 for (auto *I : IFacePtr->quals())
6129 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
6130 Selectors, AtArgumentExpression, Results);
6132 // Handle messages to "id".
6133 else if (ReceiverType->isObjCIdType()) {
6134 // We're messaging "id", so provide all instance methods we know
6135 // about as code-completion results.
6137 // If we have an external source, load the entire class method
6138 // pool from the AST file.
6139 if (ExternalSource) {
6140 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
6142 Selector Sel = ExternalSource->GetExternalSelector(I);
6143 if (Sel.isNull() || MethodPool.count(Sel))
6146 ReadMethodPool(Sel);
6150 for (GlobalMethodPool::iterator M = MethodPool.begin(),
6151 MEnd = MethodPool.end();
6153 for (ObjCMethodList *MethList = &M->second.first;
6154 MethList && MethList->getMethod();
6155 MethList = MethList->getNext()) {
6156 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
6159 if (!Selectors.insert(MethList->getMethod()->getSelector()).second)
6162 Result R(MethList->getMethod(),
6163 Results.getBasePriority(MethList->getMethod()), nullptr);
6164 R.StartParameter = SelIdents.size();
6165 R.AllParametersAreInformative = false;
6166 Results.MaybeAddResult(R, CurContext);
6170 Results.ExitScope();
6173 // If we're actually at the argument expression (rather than prior to the
6174 // selector), we're actually performing code completion for an expression.
6175 // Determine whether we have a single, best method. If so, we can
6176 // code-complete the expression using the corresponding parameter type as
6177 // our preferred type, improving completion results.
6178 if (AtArgumentExpression) {
6179 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
6181 if (PreferredType.isNull())
6182 CodeCompleteOrdinaryName(S, PCC_Expression);
6184 CodeCompleteExpression(S, PreferredType);
6188 HandleCodeCompleteResults(this, CodeCompleter,
6189 Results.getCompletionContext(),
6190 Results.data(),Results.size());
6193 void Sema::CodeCompleteObjCForCollection(Scope *S,
6194 DeclGroupPtrTy IterationVar) {
6195 CodeCompleteExpressionData Data;
6196 Data.ObjCCollection = true;
6198 if (IterationVar.getAsOpaquePtr()) {
6199 DeclGroupRef DG = IterationVar.get();
6200 for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) {
6202 Data.IgnoreDecls.push_back(*I);
6206 CodeCompleteExpression(S, Data);
6209 void Sema::CodeCompleteObjCSelector(Scope *S,
6210 ArrayRef<IdentifierInfo *> SelIdents) {
6211 // If we have an external source, load the entire class method
6212 // pool from the AST file.
6213 if (ExternalSource) {
6214 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
6216 Selector Sel = ExternalSource->GetExternalSelector(I);
6217 if (Sel.isNull() || MethodPool.count(Sel))
6220 ReadMethodPool(Sel);
6224 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6225 CodeCompleter->getCodeCompletionTUInfo(),
6226 CodeCompletionContext::CCC_SelectorName);
6227 Results.EnterNewScope();
6228 for (GlobalMethodPool::iterator M = MethodPool.begin(),
6229 MEnd = MethodPool.end();
6232 Selector Sel = M->first;
6233 if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents))
6236 CodeCompletionBuilder Builder(Results.getAllocator(),
6237 Results.getCodeCompletionTUInfo());
6238 if (Sel.isUnarySelector()) {
6239 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
6240 Sel.getNameForSlot(0)));
6241 Results.AddResult(Builder.TakeString());
6245 std::string Accumulator;
6246 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) {
6247 if (I == SelIdents.size()) {
6248 if (!Accumulator.empty()) {
6249 Builder.AddInformativeChunk(Builder.getAllocator().CopyString(
6251 Accumulator.clear();
6255 Accumulator += Sel.getNameForSlot(I);
6258 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString( Accumulator));
6259 Results.AddResult(Builder.TakeString());
6261 Results.ExitScope();
6263 HandleCodeCompleteResults(this, CodeCompleter,
6264 CodeCompletionContext::CCC_SelectorName,
6265 Results.data(), Results.size());
6268 /// \brief Add all of the protocol declarations that we find in the given
6269 /// (translation unit) context.
6270 static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext,
6271 bool OnlyForwardDeclarations,
6272 ResultBuilder &Results) {
6273 typedef CodeCompletionResult Result;
6275 for (const auto *D : Ctx->decls()) {
6276 // Record any protocols we find.
6277 if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(D))
6278 if (!OnlyForwardDeclarations || !Proto->hasDefinition())
6279 Results.AddResult(Result(Proto, Results.getBasePriority(Proto),nullptr),
6280 CurContext, nullptr, false);
6284 void Sema::CodeCompleteObjCProtocolReferences(
6285 ArrayRef<IdentifierLocPair> Protocols) {
6286 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6287 CodeCompleter->getCodeCompletionTUInfo(),
6288 CodeCompletionContext::CCC_ObjCProtocolName);
6290 if (CodeCompleter->includeGlobals()) {
6291 Results.EnterNewScope();
6293 // Tell the result set to ignore all of the protocols we have
6295 // FIXME: This doesn't work when caching code-completion results.
6296 for (const IdentifierLocPair &Pair : Protocols)
6297 if (ObjCProtocolDecl *Protocol = LookupProtocol(Pair.first,
6299 Results.Ignore(Protocol);
6301 // Add all protocols.
6302 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false,
6305 Results.ExitScope();
6308 HandleCodeCompleteResults(this, CodeCompleter,
6309 CodeCompletionContext::CCC_ObjCProtocolName,
6310 Results.data(),Results.size());
6313 void Sema::CodeCompleteObjCProtocolDecl(Scope *) {
6314 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6315 CodeCompleter->getCodeCompletionTUInfo(),
6316 CodeCompletionContext::CCC_ObjCProtocolName);
6318 if (CodeCompleter->includeGlobals()) {
6319 Results.EnterNewScope();
6321 // Add all protocols.
6322 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true,
6325 Results.ExitScope();
6328 HandleCodeCompleteResults(this, CodeCompleter,
6329 CodeCompletionContext::CCC_ObjCProtocolName,
6330 Results.data(),Results.size());
6333 /// \brief Add all of the Objective-C interface declarations that we find in
6334 /// the given (translation unit) context.
6335 static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext,
6336 bool OnlyForwardDeclarations,
6337 bool OnlyUnimplemented,
6338 ResultBuilder &Results) {
6339 typedef CodeCompletionResult Result;
6341 for (const auto *D : Ctx->decls()) {
6342 // Record any interfaces we find.
6343 if (const auto *Class = dyn_cast<ObjCInterfaceDecl>(D))
6344 if ((!OnlyForwardDeclarations || !Class->hasDefinition()) &&
6345 (!OnlyUnimplemented || !Class->getImplementation()))
6346 Results.AddResult(Result(Class, Results.getBasePriority(Class),nullptr),
6347 CurContext, nullptr, false);
6351 void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) {
6352 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6353 CodeCompleter->getCodeCompletionTUInfo(),
6354 CodeCompletionContext::CCC_Other);
6355 Results.EnterNewScope();
6357 if (CodeCompleter->includeGlobals()) {
6359 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6363 Results.ExitScope();
6365 HandleCodeCompleteResults(this, CodeCompleter,
6366 CodeCompletionContext::CCC_ObjCInterfaceName,
6367 Results.data(),Results.size());
6370 void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName,
6371 SourceLocation ClassNameLoc) {
6372 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6373 CodeCompleter->getCodeCompletionTUInfo(),
6374 CodeCompletionContext::CCC_ObjCInterfaceName);
6375 Results.EnterNewScope();
6377 // Make sure that we ignore the class we're currently defining.
6379 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6380 if (CurClass && isa<ObjCInterfaceDecl>(CurClass))
6381 Results.Ignore(CurClass);
6383 if (CodeCompleter->includeGlobals()) {
6385 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6389 Results.ExitScope();
6391 HandleCodeCompleteResults(this, CodeCompleter,
6392 CodeCompletionContext::CCC_ObjCInterfaceName,
6393 Results.data(),Results.size());
6396 void Sema::CodeCompleteObjCImplementationDecl(Scope *S) {
6397 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6398 CodeCompleter->getCodeCompletionTUInfo(),
6399 CodeCompletionContext::CCC_Other);
6400 Results.EnterNewScope();
6402 if (CodeCompleter->includeGlobals()) {
6403 // Add all unimplemented classes.
6404 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6408 Results.ExitScope();
6410 HandleCodeCompleteResults(this, CodeCompleter,
6411 CodeCompletionContext::CCC_ObjCInterfaceName,
6412 Results.data(),Results.size());
6415 void Sema::CodeCompleteObjCInterfaceCategory(Scope *S,
6416 IdentifierInfo *ClassName,
6417 SourceLocation ClassNameLoc) {
6418 typedef CodeCompletionResult Result;
6420 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6421 CodeCompleter->getCodeCompletionTUInfo(),
6422 CodeCompletionContext::CCC_ObjCCategoryName);
6424 // Ignore any categories we find that have already been implemented by this
6426 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
6428 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6429 if (ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)){
6430 for (const auto *Cat : Class->visible_categories())
6431 CategoryNames.insert(Cat->getIdentifier());
6434 // Add all of the categories we know about.
6435 Results.EnterNewScope();
6436 TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
6437 for (const auto *D : TU->decls())
6438 if (const auto *Category = dyn_cast<ObjCCategoryDecl>(D))
6439 if (CategoryNames.insert(Category->getIdentifier()).second)
6440 Results.AddResult(Result(Category, Results.getBasePriority(Category),
6442 CurContext, nullptr, false);
6443 Results.ExitScope();
6445 HandleCodeCompleteResults(this, CodeCompleter,
6446 CodeCompletionContext::CCC_ObjCCategoryName,
6447 Results.data(),Results.size());
6450 void Sema::CodeCompleteObjCImplementationCategory(Scope *S,
6451 IdentifierInfo *ClassName,
6452 SourceLocation ClassNameLoc) {
6453 typedef CodeCompletionResult Result;
6455 // Find the corresponding interface. If we couldn't find the interface, the
6456 // program itself is ill-formed. However, we'll try to be helpful still by
6457 // providing the list of all of the categories we know about.
6459 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6460 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass);
6462 return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc);
6464 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6465 CodeCompleter->getCodeCompletionTUInfo(),
6466 CodeCompletionContext::CCC_ObjCCategoryName);
6468 // Add all of the categories that have have corresponding interface
6469 // declarations in this class and any of its superclasses, except for
6470 // already-implemented categories in the class itself.
6471 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
6472 Results.EnterNewScope();
6473 bool IgnoreImplemented = true;
6475 for (const auto *Cat : Class->visible_categories()) {
6476 if ((!IgnoreImplemented || !Cat->getImplementation()) &&
6477 CategoryNames.insert(Cat->getIdentifier()).second)
6478 Results.AddResult(Result(Cat, Results.getBasePriority(Cat), nullptr),
6479 CurContext, nullptr, false);
6482 Class = Class->getSuperClass();
6483 IgnoreImplemented = false;
6485 Results.ExitScope();
6487 HandleCodeCompleteResults(this, CodeCompleter,
6488 CodeCompletionContext::CCC_ObjCCategoryName,
6489 Results.data(),Results.size());
6492 void Sema::CodeCompleteObjCPropertyDefinition(Scope *S) {
6493 CodeCompletionContext CCContext(CodeCompletionContext::CCC_Other);
6494 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6495 CodeCompleter->getCodeCompletionTUInfo(),
6498 // Figure out where this @synthesize lives.
6499 ObjCContainerDecl *Container
6500 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6502 (!isa<ObjCImplementationDecl>(Container) &&
6503 !isa<ObjCCategoryImplDecl>(Container)))
6506 // Ignore any properties that have already been implemented.
6507 Container = getContainerDef(Container);
6508 for (const auto *D : Container->decls())
6509 if (const auto *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(D))
6510 Results.Ignore(PropertyImpl->getPropertyDecl());
6512 // Add any properties that we find.
6513 AddedPropertiesSet AddedProperties;
6514 Results.EnterNewScope();
6515 if (ObjCImplementationDecl *ClassImpl
6516 = dyn_cast<ObjCImplementationDecl>(Container))
6517 AddObjCProperties(CCContext, ClassImpl->getClassInterface(), false,
6518 /*AllowNullaryMethods=*/false, CurContext,
6519 AddedProperties, Results);
6521 AddObjCProperties(CCContext,
6522 cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(),
6523 false, /*AllowNullaryMethods=*/false, CurContext,
6524 AddedProperties, Results);
6525 Results.ExitScope();
6527 HandleCodeCompleteResults(this, CodeCompleter,
6528 CodeCompletionContext::CCC_Other,
6529 Results.data(),Results.size());
6532 void Sema::CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
6533 IdentifierInfo *PropertyName) {
6534 typedef CodeCompletionResult Result;
6535 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6536 CodeCompleter->getCodeCompletionTUInfo(),
6537 CodeCompletionContext::CCC_Other);
6539 // Figure out where this @synthesize lives.
6540 ObjCContainerDecl *Container
6541 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6543 (!isa<ObjCImplementationDecl>(Container) &&
6544 !isa<ObjCCategoryImplDecl>(Container)))
6547 // Figure out which interface we're looking into.
6548 ObjCInterfaceDecl *Class = nullptr;
6549 if (ObjCImplementationDecl *ClassImpl
6550 = dyn_cast<ObjCImplementationDecl>(Container))
6551 Class = ClassImpl->getClassInterface();
6553 Class = cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl()
6554 ->getClassInterface();
6556 // Determine the type of the property we're synthesizing.
6557 QualType PropertyType = Context.getObjCIdType();
6559 if (ObjCPropertyDecl *Property = Class->FindPropertyDeclaration(
6560 PropertyName, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
6562 = Property->getType().getNonReferenceType().getUnqualifiedType();
6564 // Give preference to ivars
6565 Results.setPreferredType(PropertyType);
6569 // Add all of the instance variables in this class and its superclasses.
6570 Results.EnterNewScope();
6571 bool SawSimilarlyNamedIvar = false;
6572 std::string NameWithPrefix;
6573 NameWithPrefix += '_';
6574 NameWithPrefix += PropertyName->getName();
6575 std::string NameWithSuffix = PropertyName->getName().str();
6576 NameWithSuffix += '_';
6577 for(; Class; Class = Class->getSuperClass()) {
6578 for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar;
6579 Ivar = Ivar->getNextIvar()) {
6580 Results.AddResult(Result(Ivar, Results.getBasePriority(Ivar), nullptr),
6581 CurContext, nullptr, false);
6583 // Determine whether we've seen an ivar with a name similar to the
6585 if ((PropertyName == Ivar->getIdentifier() ||
6586 NameWithPrefix == Ivar->getName() ||
6587 NameWithSuffix == Ivar->getName())) {
6588 SawSimilarlyNamedIvar = true;
6590 // Reduce the priority of this result by one, to give it a slight
6591 // advantage over other results whose names don't match so closely.
6592 if (Results.size() &&
6593 Results.data()[Results.size() - 1].Kind
6594 == CodeCompletionResult::RK_Declaration &&
6595 Results.data()[Results.size() - 1].Declaration == Ivar)
6596 Results.data()[Results.size() - 1].Priority--;
6601 if (!SawSimilarlyNamedIvar) {
6602 // Create ivar result _propName, that the user can use to synthesize
6603 // an ivar of the appropriate type.
6604 unsigned Priority = CCP_MemberDeclaration + 1;
6605 typedef CodeCompletionResult Result;
6606 CodeCompletionAllocator &Allocator = Results.getAllocator();
6607 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo(),
6608 Priority,CXAvailability_Available);
6610 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
6611 Builder.AddResultTypeChunk(GetCompletionTypeString(PropertyType, Context,
6612 Policy, Allocator));
6613 Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix));
6614 Results.AddResult(Result(Builder.TakeString(), Priority,
6615 CXCursor_ObjCIvarDecl));
6618 Results.ExitScope();
6620 HandleCodeCompleteResults(this, CodeCompleter,
6621 CodeCompletionContext::CCC_Other,
6622 Results.data(),Results.size());
6625 // Mapping from selectors to the methods that implement that selector, along
6626 // with the "in original class" flag.
6627 typedef llvm::DenseMap<
6628 Selector, llvm::PointerIntPair<ObjCMethodDecl *, 1, bool> > KnownMethodsMap;
6630 /// \brief Find all of the methods that reside in the given container
6631 /// (and its superclasses, protocols, etc.) that meet the given
6632 /// criteria. Insert those methods into the map of known methods,
6633 /// indexed by selector so they can be easily found.
6634 static void FindImplementableMethods(ASTContext &Context,
6635 ObjCContainerDecl *Container,
6636 bool WantInstanceMethods,
6637 QualType ReturnType,
6638 KnownMethodsMap &KnownMethods,
6639 bool InOriginalClass = true) {
6640 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) {
6641 // Make sure we have a definition; that's what we'll walk.
6642 if (!IFace->hasDefinition())
6645 IFace = IFace->getDefinition();
6648 const ObjCList<ObjCProtocolDecl> &Protocols
6649 = IFace->getReferencedProtocols();
6650 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6651 E = Protocols.end();
6653 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6654 KnownMethods, InOriginalClass);
6656 // Add methods from any class extensions and categories.
6657 for (auto *Cat : IFace->visible_categories()) {
6658 FindImplementableMethods(Context, Cat, WantInstanceMethods, ReturnType,
6659 KnownMethods, false);
6662 // Visit the superclass.
6663 if (IFace->getSuperClass())
6664 FindImplementableMethods(Context, IFace->getSuperClass(),
6665 WantInstanceMethods, ReturnType,
6666 KnownMethods, false);
6669 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
6670 // Recurse into protocols.
6671 const ObjCList<ObjCProtocolDecl> &Protocols
6672 = Category->getReferencedProtocols();
6673 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6674 E = Protocols.end();
6676 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6677 KnownMethods, InOriginalClass);
6679 // If this category is the original class, jump to the interface.
6680 if (InOriginalClass && Category->getClassInterface())
6681 FindImplementableMethods(Context, Category->getClassInterface(),
6682 WantInstanceMethods, ReturnType, KnownMethods,
6686 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
6687 // Make sure we have a definition; that's what we'll walk.
6688 if (!Protocol->hasDefinition())
6690 Protocol = Protocol->getDefinition();
6691 Container = Protocol;
6693 // Recurse into protocols.
6694 const ObjCList<ObjCProtocolDecl> &Protocols
6695 = Protocol->getReferencedProtocols();
6696 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6697 E = Protocols.end();
6699 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6700 KnownMethods, false);
6703 // Add methods in this container. This operation occurs last because
6704 // we want the methods from this container to override any methods
6705 // we've previously seen with the same selector.
6706 for (auto *M : Container->methods()) {
6707 if (M->isInstanceMethod() == WantInstanceMethods) {
6708 if (!ReturnType.isNull() &&
6709 !Context.hasSameUnqualifiedType(ReturnType, M->getReturnType()))
6712 KnownMethods[M->getSelector()] =
6713 KnownMethodsMap::mapped_type(M, InOriginalClass);
6718 /// \brief Add the parenthesized return or parameter type chunk to a code
6719 /// completion string.
6720 static void AddObjCPassingTypeChunk(QualType Type,
6721 unsigned ObjCDeclQuals,
6722 ASTContext &Context,
6723 const PrintingPolicy &Policy,
6724 CodeCompletionBuilder &Builder) {
6725 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6726 std::string Quals = formatObjCParamQualifiers(ObjCDeclQuals, Type);
6728 Builder.AddTextChunk(Builder.getAllocator().CopyString(Quals));
6729 Builder.AddTextChunk(GetCompletionTypeString(Type, Context, Policy,
6730 Builder.getAllocator()));
6731 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6734 /// \brief Determine whether the given class is or inherits from a class by
6736 static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class,
6741 if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name)
6744 return InheritsFromClassNamed(Class->getSuperClass(), Name);
6747 /// \brief Add code completions for Objective-C Key-Value Coding (KVC) and
6748 /// Key-Value Observing (KVO).
6749 static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property,
6750 bool IsInstanceMethod,
6751 QualType ReturnType,
6752 ASTContext &Context,
6753 VisitedSelectorSet &KnownSelectors,
6754 ResultBuilder &Results) {
6755 IdentifierInfo *PropName = Property->getIdentifier();
6756 if (!PropName || PropName->getLength() == 0)
6759 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
6761 // Builder that will create each code completion.
6762 typedef CodeCompletionResult Result;
6763 CodeCompletionAllocator &Allocator = Results.getAllocator();
6764 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
6766 // The selector table.
6767 SelectorTable &Selectors = Context.Selectors;
6769 // The property name, copied into the code completion allocation region
6772 CodeCompletionAllocator &Allocator;
6774 const char *CopiedKey;
6776 KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key)
6777 : Allocator(Allocator), Key(Key), CopiedKey(nullptr) {}
6779 operator const char *() {
6783 return CopiedKey = Allocator.CopyString(Key);
6785 } Key(Allocator, PropName->getName());
6787 // The uppercased name of the property name.
6788 std::string UpperKey = PropName->getName();
6789 if (!UpperKey.empty())
6790 UpperKey[0] = toUppercase(UpperKey[0]);
6792 bool ReturnTypeMatchesProperty = ReturnType.isNull() ||
6793 Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(),
6794 Property->getType());
6795 bool ReturnTypeMatchesVoid
6796 = ReturnType.isNull() || ReturnType->isVoidType();
6798 // Add the normal accessor -(type)key.
6799 if (IsInstanceMethod &&
6800 KnownSelectors.insert(Selectors.getNullarySelector(PropName)).second &&
6801 ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) {
6802 if (ReturnType.isNull())
6803 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6804 Context, Policy, Builder);
6806 Builder.AddTypedTextChunk(Key);
6807 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6808 CXCursor_ObjCInstanceMethodDecl));
6811 // If we have an integral or boolean property (or the user has provided
6812 // an integral or boolean return type), add the accessor -(type)isKey.
6813 if (IsInstanceMethod &&
6814 ((!ReturnType.isNull() &&
6815 (ReturnType->isIntegerType() || ReturnType->isBooleanType())) ||
6816 (ReturnType.isNull() &&
6817 (Property->getType()->isIntegerType() ||
6818 Property->getType()->isBooleanType())))) {
6819 std::string SelectorName = (Twine("is") + UpperKey).str();
6820 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6821 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6823 if (ReturnType.isNull()) {
6824 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6825 Builder.AddTextChunk("BOOL");
6826 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6829 Builder.AddTypedTextChunk(
6830 Allocator.CopyString(SelectorId->getName()));
6831 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6832 CXCursor_ObjCInstanceMethodDecl));
6836 // Add the normal mutator.
6837 if (IsInstanceMethod && ReturnTypeMatchesVoid &&
6838 !Property->getSetterMethodDecl()) {
6839 std::string SelectorName = (Twine("set") + UpperKey).str();
6840 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6841 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6842 if (ReturnType.isNull()) {
6843 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6844 Builder.AddTextChunk("void");
6845 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6848 Builder.AddTypedTextChunk(
6849 Allocator.CopyString(SelectorId->getName()));
6850 Builder.AddTypedTextChunk(":");
6851 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6852 Context, Policy, Builder);
6853 Builder.AddTextChunk(Key);
6854 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6855 CXCursor_ObjCInstanceMethodDecl));
6859 // Indexed and unordered accessors
6860 unsigned IndexedGetterPriority = CCP_CodePattern;
6861 unsigned IndexedSetterPriority = CCP_CodePattern;
6862 unsigned UnorderedGetterPriority = CCP_CodePattern;
6863 unsigned UnorderedSetterPriority = CCP_CodePattern;
6864 if (const ObjCObjectPointerType *ObjCPointer
6865 = Property->getType()->getAs<ObjCObjectPointerType>()) {
6866 if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) {
6867 // If this interface type is not provably derived from a known
6868 // collection, penalize the corresponding completions.
6869 if (!InheritsFromClassNamed(IFace, "NSMutableArray")) {
6870 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6871 if (!InheritsFromClassNamed(IFace, "NSArray"))
6872 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6875 if (!InheritsFromClassNamed(IFace, "NSMutableSet")) {
6876 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6877 if (!InheritsFromClassNamed(IFace, "NSSet"))
6878 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6882 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6883 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6884 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6885 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6888 // Add -(NSUInteger)countOf<key>
6889 if (IsInstanceMethod &&
6890 (ReturnType.isNull() || ReturnType->isIntegerType())) {
6891 std::string SelectorName = (Twine("countOf") + UpperKey).str();
6892 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6893 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6895 if (ReturnType.isNull()) {
6896 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6897 Builder.AddTextChunk("NSUInteger");
6898 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6901 Builder.AddTypedTextChunk(
6902 Allocator.CopyString(SelectorId->getName()));
6903 Results.AddResult(Result(Builder.TakeString(),
6904 std::min(IndexedGetterPriority,
6905 UnorderedGetterPriority),
6906 CXCursor_ObjCInstanceMethodDecl));
6911 // Add -(id)objectInKeyAtIndex:(NSUInteger)index
6912 if (IsInstanceMethod &&
6913 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
6914 std::string SelectorName
6915 = (Twine("objectIn") + UpperKey + "AtIndex").str();
6916 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6917 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6918 if (ReturnType.isNull()) {
6919 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6920 Builder.AddTextChunk("id");
6921 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6924 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6925 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6926 Builder.AddTextChunk("NSUInteger");
6927 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6928 Builder.AddTextChunk("index");
6929 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6930 CXCursor_ObjCInstanceMethodDecl));
6934 // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes
6935 if (IsInstanceMethod &&
6936 (ReturnType.isNull() ||
6937 (ReturnType->isObjCObjectPointerType() &&
6938 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6939 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6940 ->getName() == "NSArray"))) {
6941 std::string SelectorName
6942 = (Twine(Property->getName()) + "AtIndexes").str();
6943 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6944 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6945 if (ReturnType.isNull()) {
6946 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6947 Builder.AddTextChunk("NSArray *");
6948 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6951 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6952 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6953 Builder.AddTextChunk("NSIndexSet *");
6954 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6955 Builder.AddTextChunk("indexes");
6956 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6957 CXCursor_ObjCInstanceMethodDecl));
6961 // Add -(void)getKey:(type **)buffer range:(NSRange)inRange
6962 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6963 std::string SelectorName = (Twine("get") + UpperKey).str();
6964 IdentifierInfo *SelectorIds[2] = {
6965 &Context.Idents.get(SelectorName),
6966 &Context.Idents.get("range")
6969 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6970 if (ReturnType.isNull()) {
6971 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6972 Builder.AddTextChunk("void");
6973 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6976 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6977 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6978 Builder.AddPlaceholderChunk("object-type");
6979 Builder.AddTextChunk(" **");
6980 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6981 Builder.AddTextChunk("buffer");
6982 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6983 Builder.AddTypedTextChunk("range:");
6984 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6985 Builder.AddTextChunk("NSRange");
6986 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6987 Builder.AddTextChunk("inRange");
6988 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6989 CXCursor_ObjCInstanceMethodDecl));
6993 // Mutable indexed accessors
6995 // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index
6996 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6997 std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str();
6998 IdentifierInfo *SelectorIds[2] = {
6999 &Context.Idents.get("insertObject"),
7000 &Context.Idents.get(SelectorName)
7003 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7004 if (ReturnType.isNull()) {
7005 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7006 Builder.AddTextChunk("void");
7007 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7010 Builder.AddTypedTextChunk("insertObject:");
7011 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7012 Builder.AddPlaceholderChunk("object-type");
7013 Builder.AddTextChunk(" *");
7014 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7015 Builder.AddTextChunk("object");
7016 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7017 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7018 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7019 Builder.AddPlaceholderChunk("NSUInteger");
7020 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7021 Builder.AddTextChunk("index");
7022 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7023 CXCursor_ObjCInstanceMethodDecl));
7027 // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes
7028 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7029 std::string SelectorName = (Twine("insert") + UpperKey).str();
7030 IdentifierInfo *SelectorIds[2] = {
7031 &Context.Idents.get(SelectorName),
7032 &Context.Idents.get("atIndexes")
7035 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7036 if (ReturnType.isNull()) {
7037 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7038 Builder.AddTextChunk("void");
7039 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7042 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7043 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7044 Builder.AddTextChunk("NSArray *");
7045 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7046 Builder.AddTextChunk("array");
7047 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7048 Builder.AddTypedTextChunk("atIndexes:");
7049 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7050 Builder.AddPlaceholderChunk("NSIndexSet *");
7051 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7052 Builder.AddTextChunk("indexes");
7053 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7054 CXCursor_ObjCInstanceMethodDecl));
7058 // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index
7059 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7060 std::string SelectorName
7061 = (Twine("removeObjectFrom") + UpperKey + "AtIndex").str();
7062 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7063 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7064 if (ReturnType.isNull()) {
7065 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7066 Builder.AddTextChunk("void");
7067 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7070 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7071 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7072 Builder.AddTextChunk("NSUInteger");
7073 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7074 Builder.AddTextChunk("index");
7075 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7076 CXCursor_ObjCInstanceMethodDecl));
7080 // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes
7081 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7082 std::string SelectorName
7083 = (Twine("remove") + UpperKey + "AtIndexes").str();
7084 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7085 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7086 if (ReturnType.isNull()) {
7087 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7088 Builder.AddTextChunk("void");
7089 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7092 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7093 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7094 Builder.AddTextChunk("NSIndexSet *");
7095 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7096 Builder.AddTextChunk("indexes");
7097 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7098 CXCursor_ObjCInstanceMethodDecl));
7102 // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object
7103 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7104 std::string SelectorName
7105 = (Twine("replaceObjectIn") + UpperKey + "AtIndex").str();
7106 IdentifierInfo *SelectorIds[2] = {
7107 &Context.Idents.get(SelectorName),
7108 &Context.Idents.get("withObject")
7111 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7112 if (ReturnType.isNull()) {
7113 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7114 Builder.AddTextChunk("void");
7115 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7118 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7119 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7120 Builder.AddPlaceholderChunk("NSUInteger");
7121 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7122 Builder.AddTextChunk("index");
7123 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7124 Builder.AddTypedTextChunk("withObject:");
7125 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7126 Builder.AddTextChunk("id");
7127 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7128 Builder.AddTextChunk("object");
7129 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7130 CXCursor_ObjCInstanceMethodDecl));
7134 // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array
7135 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7136 std::string SelectorName1
7137 = (Twine("replace") + UpperKey + "AtIndexes").str();
7138 std::string SelectorName2 = (Twine("with") + UpperKey).str();
7139 IdentifierInfo *SelectorIds[2] = {
7140 &Context.Idents.get(SelectorName1),
7141 &Context.Idents.get(SelectorName2)
7144 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7145 if (ReturnType.isNull()) {
7146 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7147 Builder.AddTextChunk("void");
7148 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7151 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName1 + ":"));
7152 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7153 Builder.AddPlaceholderChunk("NSIndexSet *");
7154 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7155 Builder.AddTextChunk("indexes");
7156 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7157 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":"));
7158 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7159 Builder.AddTextChunk("NSArray *");
7160 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7161 Builder.AddTextChunk("array");
7162 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7163 CXCursor_ObjCInstanceMethodDecl));
7167 // Unordered getters
7168 // - (NSEnumerator *)enumeratorOfKey
7169 if (IsInstanceMethod &&
7170 (ReturnType.isNull() ||
7171 (ReturnType->isObjCObjectPointerType() &&
7172 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7173 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
7174 ->getName() == "NSEnumerator"))) {
7175 std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str();
7176 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7177 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7179 if (ReturnType.isNull()) {
7180 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7181 Builder.AddTextChunk("NSEnumerator *");
7182 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7185 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7186 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
7187 CXCursor_ObjCInstanceMethodDecl));
7191 // - (type *)memberOfKey:(type *)object
7192 if (IsInstanceMethod &&
7193 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
7194 std::string SelectorName = (Twine("memberOf") + UpperKey).str();
7195 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7196 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7197 if (ReturnType.isNull()) {
7198 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7199 Builder.AddPlaceholderChunk("object-type");
7200 Builder.AddTextChunk(" *");
7201 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7204 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7205 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7206 if (ReturnType.isNull()) {
7207 Builder.AddPlaceholderChunk("object-type");
7208 Builder.AddTextChunk(" *");
7210 Builder.AddTextChunk(GetCompletionTypeString(ReturnType, Context,
7212 Builder.getAllocator()));
7214 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7215 Builder.AddTextChunk("object");
7216 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
7217 CXCursor_ObjCInstanceMethodDecl));
7221 // Mutable unordered accessors
7222 // - (void)addKeyObject:(type *)object
7223 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7224 std::string SelectorName
7225 = (Twine("add") + UpperKey + Twine("Object")).str();
7226 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7227 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7228 if (ReturnType.isNull()) {
7229 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7230 Builder.AddTextChunk("void");
7231 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7234 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7235 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7236 Builder.AddPlaceholderChunk("object-type");
7237 Builder.AddTextChunk(" *");
7238 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7239 Builder.AddTextChunk("object");
7240 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7241 CXCursor_ObjCInstanceMethodDecl));
7245 // - (void)addKey:(NSSet *)objects
7246 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7247 std::string SelectorName = (Twine("add") + UpperKey).str();
7248 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7249 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7250 if (ReturnType.isNull()) {
7251 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7252 Builder.AddTextChunk("void");
7253 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7256 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7257 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7258 Builder.AddTextChunk("NSSet *");
7259 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7260 Builder.AddTextChunk("objects");
7261 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7262 CXCursor_ObjCInstanceMethodDecl));
7266 // - (void)removeKeyObject:(type *)object
7267 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7268 std::string SelectorName
7269 = (Twine("remove") + UpperKey + Twine("Object")).str();
7270 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7271 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7272 if (ReturnType.isNull()) {
7273 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7274 Builder.AddTextChunk("void");
7275 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7278 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7279 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7280 Builder.AddPlaceholderChunk("object-type");
7281 Builder.AddTextChunk(" *");
7282 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7283 Builder.AddTextChunk("object");
7284 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7285 CXCursor_ObjCInstanceMethodDecl));
7289 // - (void)removeKey:(NSSet *)objects
7290 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7291 std::string SelectorName = (Twine("remove") + UpperKey).str();
7292 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7293 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7294 if (ReturnType.isNull()) {
7295 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7296 Builder.AddTextChunk("void");
7297 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7300 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7301 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7302 Builder.AddTextChunk("NSSet *");
7303 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7304 Builder.AddTextChunk("objects");
7305 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7306 CXCursor_ObjCInstanceMethodDecl));
7310 // - (void)intersectKey:(NSSet *)objects
7311 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7312 std::string SelectorName = (Twine("intersect") + UpperKey).str();
7313 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7314 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7315 if (ReturnType.isNull()) {
7316 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7317 Builder.AddTextChunk("void");
7318 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7321 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7322 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7323 Builder.AddTextChunk("NSSet *");
7324 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7325 Builder.AddTextChunk("objects");
7326 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7327 CXCursor_ObjCInstanceMethodDecl));
7331 // Key-Value Observing
7332 // + (NSSet *)keyPathsForValuesAffectingKey
7333 if (!IsInstanceMethod &&
7334 (ReturnType.isNull() ||
7335 (ReturnType->isObjCObjectPointerType() &&
7336 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7337 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
7338 ->getName() == "NSSet"))) {
7339 std::string SelectorName
7340 = (Twine("keyPathsForValuesAffecting") + UpperKey).str();
7341 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7342 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7344 if (ReturnType.isNull()) {
7345 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7346 Builder.AddTextChunk("NSSet<NSString *> *");
7347 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7350 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7351 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7352 CXCursor_ObjCClassMethodDecl));
7356 // + (BOOL)automaticallyNotifiesObserversForKey
7357 if (!IsInstanceMethod &&
7358 (ReturnType.isNull() ||
7359 ReturnType->isIntegerType() ||
7360 ReturnType->isBooleanType())) {
7361 std::string SelectorName
7362 = (Twine("automaticallyNotifiesObserversOf") + UpperKey).str();
7363 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7364 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7366 if (ReturnType.isNull()) {
7367 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7368 Builder.AddTextChunk("BOOL");
7369 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7372 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7373 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7374 CXCursor_ObjCClassMethodDecl));
7379 void Sema::CodeCompleteObjCMethodDecl(Scope *S,
7380 bool IsInstanceMethod,
7381 ParsedType ReturnTy) {
7382 // Determine the return type of the method we're declaring, if
7384 QualType ReturnType = GetTypeFromParser(ReturnTy);
7385 Decl *IDecl = nullptr;
7386 if (CurContext->isObjCContainer()) {
7387 ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
7388 IDecl = cast<Decl>(OCD);
7390 // Determine where we should start searching for methods.
7391 ObjCContainerDecl *SearchDecl = nullptr;
7392 bool IsInImplementation = false;
7393 if (Decl *D = IDecl) {
7394 if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) {
7395 SearchDecl = Impl->getClassInterface();
7396 IsInImplementation = true;
7397 } else if (ObjCCategoryImplDecl *CatImpl
7398 = dyn_cast<ObjCCategoryImplDecl>(D)) {
7399 SearchDecl = CatImpl->getCategoryDecl();
7400 IsInImplementation = true;
7402 SearchDecl = dyn_cast<ObjCContainerDecl>(D);
7405 if (!SearchDecl && S) {
7406 if (DeclContext *DC = S->getEntity())
7407 SearchDecl = dyn_cast<ObjCContainerDecl>(DC);
7411 HandleCodeCompleteResults(this, CodeCompleter,
7412 CodeCompletionContext::CCC_Other,
7417 // Find all of the methods that we could declare/implement here.
7418 KnownMethodsMap KnownMethods;
7419 FindImplementableMethods(Context, SearchDecl, IsInstanceMethod,
7420 ReturnType, KnownMethods);
7422 // Add declarations or definitions for each of the known methods.
7423 typedef CodeCompletionResult Result;
7424 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7425 CodeCompleter->getCodeCompletionTUInfo(),
7426 CodeCompletionContext::CCC_Other);
7427 Results.EnterNewScope();
7428 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
7429 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7430 MEnd = KnownMethods.end();
7432 ObjCMethodDecl *Method = M->second.getPointer();
7433 CodeCompletionBuilder Builder(Results.getAllocator(),
7434 Results.getCodeCompletionTUInfo());
7436 // If the result type was not already provided, add it to the
7437 // pattern as (type).
7438 if (ReturnType.isNull()) {
7439 QualType ResTy = Method->getSendResultType().stripObjCKindOfType(Context);
7440 AttributedType::stripOuterNullability(ResTy);
7441 AddObjCPassingTypeChunk(ResTy,
7442 Method->getObjCDeclQualifier(), Context, Policy,
7446 Selector Sel = Method->getSelector();
7448 // Add the first part of the selector to the pattern.
7449 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7450 Sel.getNameForSlot(0)));
7452 // Add parameters to the pattern.
7454 for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
7455 PEnd = Method->param_end();
7456 P != PEnd; (void)++P, ++I) {
7457 // Add the part of the selector name.
7459 Builder.AddTypedTextChunk(":");
7460 else if (I < Sel.getNumArgs()) {
7461 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7462 Builder.AddTypedTextChunk(
7463 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
7467 // Add the parameter type.
7469 if ((*P)->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
7470 ParamType = (*P)->getType();
7472 ParamType = (*P)->getOriginalType();
7473 ParamType = ParamType.substObjCTypeArgs(Context, {},
7474 ObjCSubstitutionContext::Parameter);
7475 AttributedType::stripOuterNullability(ParamType);
7476 AddObjCPassingTypeChunk(ParamType,
7477 (*P)->getObjCDeclQualifier(),
7481 if (IdentifierInfo *Id = (*P)->getIdentifier())
7482 Builder.AddTextChunk(Builder.getAllocator().CopyString( Id->getName()));
7485 if (Method->isVariadic()) {
7486 if (Method->param_size() > 0)
7487 Builder.AddChunk(CodeCompletionString::CK_Comma);
7488 Builder.AddTextChunk("...");
7491 if (IsInImplementation && Results.includeCodePatterns()) {
7492 // We will be defining the method here, so add a compound statement.
7493 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7494 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
7495 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
7496 if (!Method->getReturnType()->isVoidType()) {
7497 // If the result type is not void, add a return clause.
7498 Builder.AddTextChunk("return");
7499 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7500 Builder.AddPlaceholderChunk("expression");
7501 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
7503 Builder.AddPlaceholderChunk("statements");
7505 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
7506 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
7509 unsigned Priority = CCP_CodePattern;
7510 if (!M->second.getInt())
7511 Priority += CCD_InBaseClass;
7513 Results.AddResult(Result(Builder.TakeString(), Method, Priority));
7516 // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of
7517 // the properties in this class and its categories.
7518 if (Context.getLangOpts().ObjC2) {
7519 SmallVector<ObjCContainerDecl *, 4> Containers;
7520 Containers.push_back(SearchDecl);
7522 VisitedSelectorSet KnownSelectors;
7523 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7524 MEnd = KnownMethods.end();
7526 KnownSelectors.insert(M->first);
7529 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl);
7531 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl))
7532 IFace = Category->getClassInterface();
7535 for (auto *Cat : IFace->visible_categories())
7536 Containers.push_back(Cat);
7538 for (unsigned I = 0, N = Containers.size(); I != N; ++I)
7539 for (auto *P : Containers[I]->instance_properties())
7540 AddObjCKeyValueCompletions(P, IsInstanceMethod, ReturnType, Context,
7541 KnownSelectors, Results);
7544 Results.ExitScope();
7546 HandleCodeCompleteResults(this, CodeCompleter,
7547 CodeCompletionContext::CCC_Other,
7548 Results.data(),Results.size());
7551 void Sema::CodeCompleteObjCMethodDeclSelector(Scope *S,
7552 bool IsInstanceMethod,
7553 bool AtParameterName,
7554 ParsedType ReturnTy,
7555 ArrayRef<IdentifierInfo *> SelIdents) {
7556 // If we have an external source, load the entire class method
7557 // pool from the AST file.
7558 if (ExternalSource) {
7559 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
7561 Selector Sel = ExternalSource->GetExternalSelector(I);
7562 if (Sel.isNull() || MethodPool.count(Sel))
7565 ReadMethodPool(Sel);
7569 // Build the set of methods we can see.
7570 typedef CodeCompletionResult Result;
7571 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7572 CodeCompleter->getCodeCompletionTUInfo(),
7573 CodeCompletionContext::CCC_Other);
7576 Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType());
7578 Results.EnterNewScope();
7579 for (GlobalMethodPool::iterator M = MethodPool.begin(),
7580 MEnd = MethodPool.end();
7582 for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first :
7584 MethList && MethList->getMethod();
7585 MethList = MethList->getNext()) {
7586 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
7589 if (AtParameterName) {
7590 // Suggest parameter names we've seen before.
7591 unsigned NumSelIdents = SelIdents.size();
7593 NumSelIdents <= MethList->getMethod()->param_size()) {
7594 ParmVarDecl *Param =
7595 MethList->getMethod()->parameters()[NumSelIdents - 1];
7596 if (Param->getIdentifier()) {
7597 CodeCompletionBuilder Builder(Results.getAllocator(),
7598 Results.getCodeCompletionTUInfo());
7599 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7600 Param->getIdentifier()->getName()));
7601 Results.AddResult(Builder.TakeString());
7608 Result R(MethList->getMethod(),
7609 Results.getBasePriority(MethList->getMethod()), nullptr);
7610 R.StartParameter = SelIdents.size();
7611 R.AllParametersAreInformative = false;
7612 R.DeclaringEntity = true;
7613 Results.MaybeAddResult(R, CurContext);
7617 Results.ExitScope();
7619 if (!AtParameterName && !SelIdents.empty() &&
7620 SelIdents.front()->getName().startswith("init")) {
7621 for (const auto &M : PP.macros()) {
7622 if (M.first->getName() != "NS_DESIGNATED_INITIALIZER")
7624 Results.EnterNewScope();
7625 CodeCompletionBuilder Builder(Results.getAllocator(),
7626 Results.getCodeCompletionTUInfo());
7627 Builder.AddTypedTextChunk(
7628 Builder.getAllocator().CopyString(M.first->getName()));
7629 Results.AddResult(CodeCompletionResult(Builder.TakeString(), CCP_Macro,
7630 CXCursor_MacroDefinition));
7631 Results.ExitScope();
7635 HandleCodeCompleteResults(this, CodeCompleter,
7636 CodeCompletionContext::CCC_Other,
7637 Results.data(),Results.size());
7640 void Sema::CodeCompletePreprocessorDirective(bool InConditional) {
7641 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7642 CodeCompleter->getCodeCompletionTUInfo(),
7643 CodeCompletionContext::CCC_PreprocessorDirective);
7644 Results.EnterNewScope();
7647 CodeCompletionBuilder Builder(Results.getAllocator(),
7648 Results.getCodeCompletionTUInfo());
7649 Builder.AddTypedTextChunk("if");
7650 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7651 Builder.AddPlaceholderChunk("condition");
7652 Results.AddResult(Builder.TakeString());
7655 Builder.AddTypedTextChunk("ifdef");
7656 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7657 Builder.AddPlaceholderChunk("macro");
7658 Results.AddResult(Builder.TakeString());
7661 Builder.AddTypedTextChunk("ifndef");
7662 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7663 Builder.AddPlaceholderChunk("macro");
7664 Results.AddResult(Builder.TakeString());
7666 if (InConditional) {
7667 // #elif <condition>
7668 Builder.AddTypedTextChunk("elif");
7669 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7670 Builder.AddPlaceholderChunk("condition");
7671 Results.AddResult(Builder.TakeString());
7674 Builder.AddTypedTextChunk("else");
7675 Results.AddResult(Builder.TakeString());
7678 Builder.AddTypedTextChunk("endif");
7679 Results.AddResult(Builder.TakeString());
7682 // #include "header"
7683 Builder.AddTypedTextChunk("include");
7684 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7685 Builder.AddTextChunk("\"");
7686 Builder.AddPlaceholderChunk("header");
7687 Builder.AddTextChunk("\"");
7688 Results.AddResult(Builder.TakeString());
7690 // #include <header>
7691 Builder.AddTypedTextChunk("include");
7692 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7693 Builder.AddTextChunk("<");
7694 Builder.AddPlaceholderChunk("header");
7695 Builder.AddTextChunk(">");
7696 Results.AddResult(Builder.TakeString());
7699 Builder.AddTypedTextChunk("define");
7700 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7701 Builder.AddPlaceholderChunk("macro");
7702 Results.AddResult(Builder.TakeString());
7704 // #define <macro>(<args>)
7705 Builder.AddTypedTextChunk("define");
7706 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7707 Builder.AddPlaceholderChunk("macro");
7708 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7709 Builder.AddPlaceholderChunk("args");
7710 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7711 Results.AddResult(Builder.TakeString());
7714 Builder.AddTypedTextChunk("undef");
7715 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7716 Builder.AddPlaceholderChunk("macro");
7717 Results.AddResult(Builder.TakeString());
7720 Builder.AddTypedTextChunk("line");
7721 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7722 Builder.AddPlaceholderChunk("number");
7723 Results.AddResult(Builder.TakeString());
7725 // #line <number> "filename"
7726 Builder.AddTypedTextChunk("line");
7727 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7728 Builder.AddPlaceholderChunk("number");
7729 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7730 Builder.AddTextChunk("\"");
7731 Builder.AddPlaceholderChunk("filename");
7732 Builder.AddTextChunk("\"");
7733 Results.AddResult(Builder.TakeString());
7736 Builder.AddTypedTextChunk("error");
7737 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7738 Builder.AddPlaceholderChunk("message");
7739 Results.AddResult(Builder.TakeString());
7741 // #pragma <arguments>
7742 Builder.AddTypedTextChunk("pragma");
7743 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7744 Builder.AddPlaceholderChunk("arguments");
7745 Results.AddResult(Builder.TakeString());
7747 if (getLangOpts().ObjC1) {
7749 Builder.AddTypedTextChunk("import");
7750 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7751 Builder.AddTextChunk("\"");
7752 Builder.AddPlaceholderChunk("header");
7753 Builder.AddTextChunk("\"");
7754 Results.AddResult(Builder.TakeString());
7757 Builder.AddTypedTextChunk("import");
7758 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7759 Builder.AddTextChunk("<");
7760 Builder.AddPlaceholderChunk("header");
7761 Builder.AddTextChunk(">");
7762 Results.AddResult(Builder.TakeString());
7765 // #include_next "header"
7766 Builder.AddTypedTextChunk("include_next");
7767 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7768 Builder.AddTextChunk("\"");
7769 Builder.AddPlaceholderChunk("header");
7770 Builder.AddTextChunk("\"");
7771 Results.AddResult(Builder.TakeString());
7773 // #include_next <header>
7774 Builder.AddTypedTextChunk("include_next");
7775 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7776 Builder.AddTextChunk("<");
7777 Builder.AddPlaceholderChunk("header");
7778 Builder.AddTextChunk(">");
7779 Results.AddResult(Builder.TakeString());
7781 // #warning <message>
7782 Builder.AddTypedTextChunk("warning");
7783 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7784 Builder.AddPlaceholderChunk("message");
7785 Results.AddResult(Builder.TakeString());
7787 // Note: #ident and #sccs are such crazy anachronisms that we don't provide
7788 // completions for them. And __include_macros is a Clang-internal extension
7789 // that we don't want to encourage anyone to use.
7791 // FIXME: we don't support #assert or #unassert, so don't suggest them.
7792 Results.ExitScope();
7794 HandleCodeCompleteResults(this, CodeCompleter,
7795 CodeCompletionContext::CCC_PreprocessorDirective,
7796 Results.data(), Results.size());
7799 void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) {
7800 CodeCompleteOrdinaryName(S,
7801 S->getFnParent()? Sema::PCC_RecoveryInFunction
7802 : Sema::PCC_Namespace);
7805 void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) {
7806 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7807 CodeCompleter->getCodeCompletionTUInfo(),
7808 IsDefinition? CodeCompletionContext::CCC_MacroName
7809 : CodeCompletionContext::CCC_MacroNameUse);
7810 if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) {
7811 // Add just the names of macros, not their arguments.
7812 CodeCompletionBuilder Builder(Results.getAllocator(),
7813 Results.getCodeCompletionTUInfo());
7814 Results.EnterNewScope();
7815 for (Preprocessor::macro_iterator M = PP.macro_begin(),
7816 MEnd = PP.macro_end();
7818 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7819 M->first->getName()));
7820 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
7822 CXCursor_MacroDefinition));
7824 Results.ExitScope();
7825 } else if (IsDefinition) {
7826 // FIXME: Can we detect when the user just wrote an include guard above?
7829 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7830 Results.data(), Results.size());
7833 void Sema::CodeCompletePreprocessorExpression() {
7834 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7835 CodeCompleter->getCodeCompletionTUInfo(),
7836 CodeCompletionContext::CCC_PreprocessorExpression);
7838 if (!CodeCompleter || CodeCompleter->includeMacros())
7839 AddMacroResults(PP, Results, true);
7841 // defined (<macro>)
7842 Results.EnterNewScope();
7843 CodeCompletionBuilder Builder(Results.getAllocator(),
7844 Results.getCodeCompletionTUInfo());
7845 Builder.AddTypedTextChunk("defined");
7846 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7847 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7848 Builder.AddPlaceholderChunk("macro");
7849 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7850 Results.AddResult(Builder.TakeString());
7851 Results.ExitScope();
7853 HandleCodeCompleteResults(this, CodeCompleter,
7854 CodeCompletionContext::CCC_PreprocessorExpression,
7855 Results.data(), Results.size());
7858 void Sema::CodeCompletePreprocessorMacroArgument(Scope *S,
7859 IdentifierInfo *Macro,
7860 MacroInfo *MacroInfo,
7861 unsigned Argument) {
7862 // FIXME: In the future, we could provide "overload" results, much like we
7863 // do for function calls.
7865 // Now just ignore this. There will be another code-completion callback
7866 // for the expanded tokens.
7869 void Sema::CodeCompleteNaturalLanguage() {
7870 HandleCodeCompleteResults(this, CodeCompleter,
7871 CodeCompletionContext::CCC_NaturalLanguage,
7875 void Sema::CodeCompleteAvailabilityPlatformName() {
7876 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7877 CodeCompleter->getCodeCompletionTUInfo(),
7878 CodeCompletionContext::CCC_Other);
7879 Results.EnterNewScope();
7880 static const char *Platforms[] = {"macOS", "iOS", "watchOS", "tvOS"};
7881 for (const char *Platform : llvm::makeArrayRef(Platforms)) {
7882 Results.AddResult(CodeCompletionResult(Platform));
7883 Results.AddResult(CodeCompletionResult(Results.getAllocator().CopyString(
7884 Twine(Platform) + "ApplicationExtension")));
7886 Results.ExitScope();
7887 HandleCodeCompleteResults(this, CodeCompleter,
7888 CodeCompletionContext::CCC_Other, Results.data(),
7892 void Sema::GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,
7893 CodeCompletionTUInfo &CCTUInfo,
7894 SmallVectorImpl<CodeCompletionResult> &Results) {
7895 ResultBuilder Builder(*this, Allocator, CCTUInfo,
7896 CodeCompletionContext::CCC_Recovery);
7897 if (!CodeCompleter || CodeCompleter->includeGlobals()) {
7898 CodeCompletionDeclConsumer Consumer(Builder,
7899 Context.getTranslationUnitDecl());
7900 LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName,
7904 if (!CodeCompleter || CodeCompleter->includeMacros())
7905 AddMacroResults(PP, Builder, true);
7908 Results.insert(Results.end(),
7909 Builder.data(), Builder.data() + Builder.size());