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()));
1340 if (LangOpts.GNUMode) {
1341 // FIXME: Enable when we actually support decimal floating point.
1342 // Results.AddResult(Result("_Decimal32"));
1343 // Results.AddResult(Result("_Decimal64"));
1344 // Results.AddResult(Result("_Decimal128"));
1346 Builder.AddTypedTextChunk("typeof");
1347 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1348 Builder.AddPlaceholderChunk("expression");
1349 Results.AddResult(Result(Builder.TakeString()));
1351 Builder.AddTypedTextChunk("typeof");
1352 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1353 Builder.AddPlaceholderChunk("type");
1354 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1355 Results.AddResult(Result(Builder.TakeString()));
1359 Results.AddResult(Result("_Nonnull", CCP_Type));
1360 Results.AddResult(Result("_Null_unspecified", CCP_Type));
1361 Results.AddResult(Result("_Nullable", CCP_Type));
1364 static void AddStorageSpecifiers(Sema::ParserCompletionContext CCC,
1365 const LangOptions &LangOpts,
1366 ResultBuilder &Results) {
1367 typedef CodeCompletionResult Result;
1368 // Note: we don't suggest either "auto" or "register", because both
1369 // are pointless as storage specifiers. Elsewhere, we suggest "auto"
1370 // in C++0x as a type specifier.
1371 Results.AddResult(Result("extern"));
1372 Results.AddResult(Result("static"));
1375 static void AddFunctionSpecifiers(Sema::ParserCompletionContext CCC,
1376 const LangOptions &LangOpts,
1377 ResultBuilder &Results) {
1378 typedef CodeCompletionResult Result;
1380 case Sema::PCC_Class:
1381 case Sema::PCC_MemberTemplate:
1382 if (LangOpts.CPlusPlus) {
1383 Results.AddResult(Result("explicit"));
1384 Results.AddResult(Result("friend"));
1385 Results.AddResult(Result("mutable"));
1386 Results.AddResult(Result("virtual"));
1390 case Sema::PCC_ObjCInterface:
1391 case Sema::PCC_ObjCImplementation:
1392 case Sema::PCC_Namespace:
1393 case Sema::PCC_Template:
1394 if (LangOpts.CPlusPlus || LangOpts.C99)
1395 Results.AddResult(Result("inline"));
1398 case Sema::PCC_ObjCInstanceVariableList:
1399 case Sema::PCC_Expression:
1400 case Sema::PCC_Statement:
1401 case Sema::PCC_ForInit:
1402 case Sema::PCC_Condition:
1403 case Sema::PCC_RecoveryInFunction:
1404 case Sema::PCC_Type:
1405 case Sema::PCC_ParenthesizedExpression:
1406 case Sema::PCC_LocalDeclarationSpecifiers:
1411 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt);
1412 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt);
1413 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
1414 ResultBuilder &Results,
1416 static void AddObjCImplementationResults(const LangOptions &LangOpts,
1417 ResultBuilder &Results,
1419 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
1420 ResultBuilder &Results,
1422 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt);
1424 static void AddTypedefResult(ResultBuilder &Results) {
1425 CodeCompletionBuilder Builder(Results.getAllocator(),
1426 Results.getCodeCompletionTUInfo());
1427 Builder.AddTypedTextChunk("typedef");
1428 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1429 Builder.AddPlaceholderChunk("type");
1430 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1431 Builder.AddPlaceholderChunk("name");
1432 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1435 static bool WantTypesInContext(Sema::ParserCompletionContext CCC,
1436 const LangOptions &LangOpts) {
1438 case Sema::PCC_Namespace:
1439 case Sema::PCC_Class:
1440 case Sema::PCC_ObjCInstanceVariableList:
1441 case Sema::PCC_Template:
1442 case Sema::PCC_MemberTemplate:
1443 case Sema::PCC_Statement:
1444 case Sema::PCC_RecoveryInFunction:
1445 case Sema::PCC_Type:
1446 case Sema::PCC_ParenthesizedExpression:
1447 case Sema::PCC_LocalDeclarationSpecifiers:
1450 case Sema::PCC_Expression:
1451 case Sema::PCC_Condition:
1452 return LangOpts.CPlusPlus;
1454 case Sema::PCC_ObjCInterface:
1455 case Sema::PCC_ObjCImplementation:
1458 case Sema::PCC_ForInit:
1459 return LangOpts.CPlusPlus || LangOpts.ObjC1 || LangOpts.C99;
1462 llvm_unreachable("Invalid ParserCompletionContext!");
1465 static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context,
1466 const Preprocessor &PP) {
1467 PrintingPolicy Policy = Sema::getPrintingPolicy(Context, PP);
1468 Policy.AnonymousTagLocations = false;
1469 Policy.SuppressStrongLifetime = true;
1470 Policy.SuppressUnwrittenScope = true;
1474 /// \brief Retrieve a printing policy suitable for code completion.
1475 static PrintingPolicy getCompletionPrintingPolicy(Sema &S) {
1476 return getCompletionPrintingPolicy(S.Context, S.PP);
1479 /// \brief Retrieve the string representation of the given type as a string
1480 /// that has the appropriate lifetime for code completion.
1482 /// This routine provides a fast path where we provide constant strings for
1483 /// common type names.
1484 static const char *GetCompletionTypeString(QualType T,
1485 ASTContext &Context,
1486 const PrintingPolicy &Policy,
1487 CodeCompletionAllocator &Allocator) {
1488 if (!T.getLocalQualifiers()) {
1489 // Built-in type names are constant strings.
1490 if (const BuiltinType *BT = dyn_cast<BuiltinType>(T))
1491 return BT->getNameAsCString(Policy);
1493 // Anonymous tag types are constant strings.
1494 if (const TagType *TagT = dyn_cast<TagType>(T))
1495 if (TagDecl *Tag = TagT->getDecl())
1496 if (!Tag->hasNameForLinkage()) {
1497 switch (Tag->getTagKind()) {
1498 case TTK_Struct: return "struct <anonymous>";
1499 case TTK_Interface: return "__interface <anonymous>";
1500 case TTK_Class: return "class <anonymous>";
1501 case TTK_Union: return "union <anonymous>";
1502 case TTK_Enum: return "enum <anonymous>";
1507 // Slow path: format the type as a string.
1509 T.getAsStringInternal(Result, Policy);
1510 return Allocator.CopyString(Result);
1513 /// \brief Add a completion for "this", if we're in a member function.
1514 static void addThisCompletion(Sema &S, ResultBuilder &Results) {
1515 QualType ThisTy = S.getCurrentThisType();
1516 if (ThisTy.isNull())
1519 CodeCompletionAllocator &Allocator = Results.getAllocator();
1520 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1521 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
1522 Builder.AddResultTypeChunk(GetCompletionTypeString(ThisTy,
1526 Builder.AddTypedTextChunk("this");
1527 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1530 /// \brief Add language constructs that show up for "ordinary" names.
1531 static void AddOrdinaryNameResults(Sema::ParserCompletionContext CCC,
1534 ResultBuilder &Results) {
1535 CodeCompletionAllocator &Allocator = Results.getAllocator();
1536 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1538 typedef CodeCompletionResult Result;
1540 case Sema::PCC_Namespace:
1541 if (SemaRef.getLangOpts().CPlusPlus) {
1542 if (Results.includeCodePatterns()) {
1543 // namespace <identifier> { declarations }
1544 Builder.AddTypedTextChunk("namespace");
1545 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1546 Builder.AddPlaceholderChunk("identifier");
1547 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1548 Builder.AddPlaceholderChunk("declarations");
1549 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1550 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1551 Results.AddResult(Result(Builder.TakeString()));
1554 // namespace identifier = identifier ;
1555 Builder.AddTypedTextChunk("namespace");
1556 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1557 Builder.AddPlaceholderChunk("name");
1558 Builder.AddChunk(CodeCompletionString::CK_Equal);
1559 Builder.AddPlaceholderChunk("namespace");
1560 Results.AddResult(Result(Builder.TakeString()));
1563 Builder.AddTypedTextChunk("using");
1564 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1565 Builder.AddTextChunk("namespace");
1566 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1567 Builder.AddPlaceholderChunk("identifier");
1568 Results.AddResult(Result(Builder.TakeString()));
1570 // asm(string-literal)
1571 Builder.AddTypedTextChunk("asm");
1572 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1573 Builder.AddPlaceholderChunk("string-literal");
1574 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1575 Results.AddResult(Result(Builder.TakeString()));
1577 if (Results.includeCodePatterns()) {
1578 // Explicit template instantiation
1579 Builder.AddTypedTextChunk("template");
1580 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1581 Builder.AddPlaceholderChunk("declaration");
1582 Results.AddResult(Result(Builder.TakeString()));
1586 if (SemaRef.getLangOpts().ObjC1)
1587 AddObjCTopLevelResults(Results, true);
1589 AddTypedefResult(Results);
1592 case Sema::PCC_Class:
1593 if (SemaRef.getLangOpts().CPlusPlus) {
1594 // Using declaration
1595 Builder.AddTypedTextChunk("using");
1596 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1597 Builder.AddPlaceholderChunk("qualifier");
1598 Builder.AddTextChunk("::");
1599 Builder.AddPlaceholderChunk("name");
1600 Results.AddResult(Result(Builder.TakeString()));
1602 // using typename qualifier::name (only in a dependent context)
1603 if (SemaRef.CurContext->isDependentContext()) {
1604 Builder.AddTypedTextChunk("using");
1605 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1606 Builder.AddTextChunk("typename");
1607 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1608 Builder.AddPlaceholderChunk("qualifier");
1609 Builder.AddTextChunk("::");
1610 Builder.AddPlaceholderChunk("name");
1611 Results.AddResult(Result(Builder.TakeString()));
1614 if (CCC == Sema::PCC_Class) {
1615 AddTypedefResult(Results);
1618 Builder.AddTypedTextChunk("public");
1619 if (Results.includeCodePatterns())
1620 Builder.AddChunk(CodeCompletionString::CK_Colon);
1621 Results.AddResult(Result(Builder.TakeString()));
1624 Builder.AddTypedTextChunk("protected");
1625 if (Results.includeCodePatterns())
1626 Builder.AddChunk(CodeCompletionString::CK_Colon);
1627 Results.AddResult(Result(Builder.TakeString()));
1630 Builder.AddTypedTextChunk("private");
1631 if (Results.includeCodePatterns())
1632 Builder.AddChunk(CodeCompletionString::CK_Colon);
1633 Results.AddResult(Result(Builder.TakeString()));
1638 case Sema::PCC_Template:
1639 case Sema::PCC_MemberTemplate:
1640 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns()) {
1641 // template < parameters >
1642 Builder.AddTypedTextChunk("template");
1643 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1644 Builder.AddPlaceholderChunk("parameters");
1645 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1646 Results.AddResult(Result(Builder.TakeString()));
1649 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1650 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1653 case Sema::PCC_ObjCInterface:
1654 AddObjCInterfaceResults(SemaRef.getLangOpts(), Results, true);
1655 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1656 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1659 case Sema::PCC_ObjCImplementation:
1660 AddObjCImplementationResults(SemaRef.getLangOpts(), Results, true);
1661 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1662 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1665 case Sema::PCC_ObjCInstanceVariableList:
1666 AddObjCVisibilityResults(SemaRef.getLangOpts(), Results, true);
1669 case Sema::PCC_RecoveryInFunction:
1670 case Sema::PCC_Statement: {
1671 AddTypedefResult(Results);
1673 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns() &&
1674 SemaRef.getLangOpts().CXXExceptions) {
1675 Builder.AddTypedTextChunk("try");
1676 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1677 Builder.AddPlaceholderChunk("statements");
1678 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1679 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1680 Builder.AddTextChunk("catch");
1681 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1682 Builder.AddPlaceholderChunk("declaration");
1683 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1684 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1685 Builder.AddPlaceholderChunk("statements");
1686 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1687 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1688 Results.AddResult(Result(Builder.TakeString()));
1690 if (SemaRef.getLangOpts().ObjC1)
1691 AddObjCStatementResults(Results, true);
1693 if (Results.includeCodePatterns()) {
1694 // if (condition) { statements }
1695 Builder.AddTypedTextChunk("if");
1696 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1697 if (SemaRef.getLangOpts().CPlusPlus)
1698 Builder.AddPlaceholderChunk("condition");
1700 Builder.AddPlaceholderChunk("expression");
1701 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1702 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1703 Builder.AddPlaceholderChunk("statements");
1704 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1705 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1706 Results.AddResult(Result(Builder.TakeString()));
1708 // switch (condition) { }
1709 Builder.AddTypedTextChunk("switch");
1710 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1711 if (SemaRef.getLangOpts().CPlusPlus)
1712 Builder.AddPlaceholderChunk("condition");
1714 Builder.AddPlaceholderChunk("expression");
1715 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1716 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1717 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1718 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1719 Results.AddResult(Result(Builder.TakeString()));
1722 // Switch-specific statements.
1723 if (!SemaRef.getCurFunction()->SwitchStack.empty()) {
1725 Builder.AddTypedTextChunk("case");
1726 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1727 Builder.AddPlaceholderChunk("expression");
1728 Builder.AddChunk(CodeCompletionString::CK_Colon);
1729 Results.AddResult(Result(Builder.TakeString()));
1732 Builder.AddTypedTextChunk("default");
1733 Builder.AddChunk(CodeCompletionString::CK_Colon);
1734 Results.AddResult(Result(Builder.TakeString()));
1737 if (Results.includeCodePatterns()) {
1738 /// while (condition) { statements }
1739 Builder.AddTypedTextChunk("while");
1740 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1741 if (SemaRef.getLangOpts().CPlusPlus)
1742 Builder.AddPlaceholderChunk("condition");
1744 Builder.AddPlaceholderChunk("expression");
1745 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1746 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1747 Builder.AddPlaceholderChunk("statements");
1748 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1749 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1750 Results.AddResult(Result(Builder.TakeString()));
1752 // do { statements } while ( expression );
1753 Builder.AddTypedTextChunk("do");
1754 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1755 Builder.AddPlaceholderChunk("statements");
1756 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1757 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1758 Builder.AddTextChunk("while");
1759 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1760 Builder.AddPlaceholderChunk("expression");
1761 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1762 Results.AddResult(Result(Builder.TakeString()));
1764 // for ( for-init-statement ; condition ; expression ) { statements }
1765 Builder.AddTypedTextChunk("for");
1766 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1767 if (SemaRef.getLangOpts().CPlusPlus || SemaRef.getLangOpts().C99)
1768 Builder.AddPlaceholderChunk("init-statement");
1770 Builder.AddPlaceholderChunk("init-expression");
1771 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1772 Builder.AddPlaceholderChunk("condition");
1773 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1774 Builder.AddPlaceholderChunk("inc-expression");
1775 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1776 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1777 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1778 Builder.AddPlaceholderChunk("statements");
1779 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1780 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1781 Results.AddResult(Result(Builder.TakeString()));
1784 if (S->getContinueParent()) {
1786 Builder.AddTypedTextChunk("continue");
1787 Results.AddResult(Result(Builder.TakeString()));
1790 if (S->getBreakParent()) {
1792 Builder.AddTypedTextChunk("break");
1793 Results.AddResult(Result(Builder.TakeString()));
1796 // "return expression ;" or "return ;", depending on whether we
1797 // know the function is void or not.
1798 bool isVoid = false;
1799 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(SemaRef.CurContext))
1800 isVoid = Function->getReturnType()->isVoidType();
1801 else if (ObjCMethodDecl *Method
1802 = dyn_cast<ObjCMethodDecl>(SemaRef.CurContext))
1803 isVoid = Method->getReturnType()->isVoidType();
1804 else if (SemaRef.getCurBlock() &&
1805 !SemaRef.getCurBlock()->ReturnType.isNull())
1806 isVoid = SemaRef.getCurBlock()->ReturnType->isVoidType();
1807 Builder.AddTypedTextChunk("return");
1809 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1810 Builder.AddPlaceholderChunk("expression");
1812 Results.AddResult(Result(Builder.TakeString()));
1814 // goto identifier ;
1815 Builder.AddTypedTextChunk("goto");
1816 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1817 Builder.AddPlaceholderChunk("label");
1818 Results.AddResult(Result(Builder.TakeString()));
1821 Builder.AddTypedTextChunk("using");
1822 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1823 Builder.AddTextChunk("namespace");
1824 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1825 Builder.AddPlaceholderChunk("identifier");
1826 Results.AddResult(Result(Builder.TakeString()));
1829 // Fall through (for statement expressions).
1830 case Sema::PCC_ForInit:
1831 case Sema::PCC_Condition:
1832 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1833 // Fall through: conditions and statements can have expressions.
1835 case Sema::PCC_ParenthesizedExpression:
1836 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
1837 CCC == Sema::PCC_ParenthesizedExpression) {
1838 // (__bridge <type>)<expression>
1839 Builder.AddTypedTextChunk("__bridge");
1840 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1841 Builder.AddPlaceholderChunk("type");
1842 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1843 Builder.AddPlaceholderChunk("expression");
1844 Results.AddResult(Result(Builder.TakeString()));
1846 // (__bridge_transfer <Objective-C type>)<expression>
1847 Builder.AddTypedTextChunk("__bridge_transfer");
1848 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1849 Builder.AddPlaceholderChunk("Objective-C type");
1850 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1851 Builder.AddPlaceholderChunk("expression");
1852 Results.AddResult(Result(Builder.TakeString()));
1854 // (__bridge_retained <CF type>)<expression>
1855 Builder.AddTypedTextChunk("__bridge_retained");
1856 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1857 Builder.AddPlaceholderChunk("CF type");
1858 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1859 Builder.AddPlaceholderChunk("expression");
1860 Results.AddResult(Result(Builder.TakeString()));
1864 case Sema::PCC_Expression: {
1865 if (SemaRef.getLangOpts().CPlusPlus) {
1866 // 'this', if we're in a non-static member function.
1867 addThisCompletion(SemaRef, Results);
1870 Builder.AddResultTypeChunk("bool");
1871 Builder.AddTypedTextChunk("true");
1872 Results.AddResult(Result(Builder.TakeString()));
1875 Builder.AddResultTypeChunk("bool");
1876 Builder.AddTypedTextChunk("false");
1877 Results.AddResult(Result(Builder.TakeString()));
1879 if (SemaRef.getLangOpts().RTTI) {
1880 // dynamic_cast < type-id > ( expression )
1881 Builder.AddTypedTextChunk("dynamic_cast");
1882 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1883 Builder.AddPlaceholderChunk("type");
1884 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1885 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1886 Builder.AddPlaceholderChunk("expression");
1887 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1888 Results.AddResult(Result(Builder.TakeString()));
1891 // static_cast < type-id > ( expression )
1892 Builder.AddTypedTextChunk("static_cast");
1893 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1894 Builder.AddPlaceholderChunk("type");
1895 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1896 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1897 Builder.AddPlaceholderChunk("expression");
1898 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1899 Results.AddResult(Result(Builder.TakeString()));
1901 // reinterpret_cast < type-id > ( expression )
1902 Builder.AddTypedTextChunk("reinterpret_cast");
1903 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1904 Builder.AddPlaceholderChunk("type");
1905 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1906 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1907 Builder.AddPlaceholderChunk("expression");
1908 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1909 Results.AddResult(Result(Builder.TakeString()));
1911 // const_cast < type-id > ( expression )
1912 Builder.AddTypedTextChunk("const_cast");
1913 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1914 Builder.AddPlaceholderChunk("type");
1915 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1916 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1917 Builder.AddPlaceholderChunk("expression");
1918 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1919 Results.AddResult(Result(Builder.TakeString()));
1921 if (SemaRef.getLangOpts().RTTI) {
1922 // typeid ( expression-or-type )
1923 Builder.AddResultTypeChunk("std::type_info");
1924 Builder.AddTypedTextChunk("typeid");
1925 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1926 Builder.AddPlaceholderChunk("expression-or-type");
1927 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1928 Results.AddResult(Result(Builder.TakeString()));
1932 Builder.AddTypedTextChunk("new");
1933 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1934 Builder.AddPlaceholderChunk("type");
1935 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1936 Builder.AddPlaceholderChunk("expressions");
1937 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1938 Results.AddResult(Result(Builder.TakeString()));
1940 // new T [ ] ( ... )
1941 Builder.AddTypedTextChunk("new");
1942 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1943 Builder.AddPlaceholderChunk("type");
1944 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
1945 Builder.AddPlaceholderChunk("size");
1946 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
1947 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1948 Builder.AddPlaceholderChunk("expressions");
1949 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1950 Results.AddResult(Result(Builder.TakeString()));
1952 // delete expression
1953 Builder.AddResultTypeChunk("void");
1954 Builder.AddTypedTextChunk("delete");
1955 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1956 Builder.AddPlaceholderChunk("expression");
1957 Results.AddResult(Result(Builder.TakeString()));
1959 // delete [] expression
1960 Builder.AddResultTypeChunk("void");
1961 Builder.AddTypedTextChunk("delete");
1962 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1963 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
1964 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
1965 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1966 Builder.AddPlaceholderChunk("expression");
1967 Results.AddResult(Result(Builder.TakeString()));
1969 if (SemaRef.getLangOpts().CXXExceptions) {
1971 Builder.AddResultTypeChunk("void");
1972 Builder.AddTypedTextChunk("throw");
1973 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1974 Builder.AddPlaceholderChunk("expression");
1975 Results.AddResult(Result(Builder.TakeString()));
1980 if (SemaRef.getLangOpts().CPlusPlus11) {
1982 Builder.AddResultTypeChunk("std::nullptr_t");
1983 Builder.AddTypedTextChunk("nullptr");
1984 Results.AddResult(Result(Builder.TakeString()));
1987 Builder.AddResultTypeChunk("size_t");
1988 Builder.AddTypedTextChunk("alignof");
1989 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1990 Builder.AddPlaceholderChunk("type");
1991 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1992 Results.AddResult(Result(Builder.TakeString()));
1995 Builder.AddResultTypeChunk("bool");
1996 Builder.AddTypedTextChunk("noexcept");
1997 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1998 Builder.AddPlaceholderChunk("expression");
1999 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2000 Results.AddResult(Result(Builder.TakeString()));
2002 // sizeof... expression
2003 Builder.AddResultTypeChunk("size_t");
2004 Builder.AddTypedTextChunk("sizeof...");
2005 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2006 Builder.AddPlaceholderChunk("parameter-pack");
2007 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2008 Results.AddResult(Result(Builder.TakeString()));
2012 if (SemaRef.getLangOpts().ObjC1) {
2013 // Add "super", if we're in an Objective-C class with a superclass.
2014 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) {
2015 // The interface can be NULL.
2016 if (ObjCInterfaceDecl *ID = Method->getClassInterface())
2017 if (ID->getSuperClass()) {
2018 std::string SuperType;
2019 SuperType = ID->getSuperClass()->getNameAsString();
2020 if (Method->isInstanceMethod())
2023 Builder.AddResultTypeChunk(Allocator.CopyString(SuperType));
2024 Builder.AddTypedTextChunk("super");
2025 Results.AddResult(Result(Builder.TakeString()));
2029 AddObjCExpressionResults(Results, true);
2032 if (SemaRef.getLangOpts().C11) {
2034 Builder.AddResultTypeChunk("size_t");
2035 if (SemaRef.PP.isMacroDefined("alignof"))
2036 Builder.AddTypedTextChunk("alignof");
2038 Builder.AddTypedTextChunk("_Alignof");
2039 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2040 Builder.AddPlaceholderChunk("type");
2041 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2042 Results.AddResult(Result(Builder.TakeString()));
2045 // sizeof expression
2046 Builder.AddResultTypeChunk("size_t");
2047 Builder.AddTypedTextChunk("sizeof");
2048 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2049 Builder.AddPlaceholderChunk("expression-or-type");
2050 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2051 Results.AddResult(Result(Builder.TakeString()));
2055 case Sema::PCC_Type:
2056 case Sema::PCC_LocalDeclarationSpecifiers:
2060 if (WantTypesInContext(CCC, SemaRef.getLangOpts()))
2061 AddTypeSpecifierResults(SemaRef.getLangOpts(), Results);
2063 if (SemaRef.getLangOpts().CPlusPlus && CCC != Sema::PCC_Type)
2064 Results.AddResult(Result("operator"));
2067 /// \brief If the given declaration has an associated type, add it as a result
2069 static void AddResultTypeChunk(ASTContext &Context,
2070 const PrintingPolicy &Policy,
2071 const NamedDecl *ND,
2073 CodeCompletionBuilder &Result) {
2077 // Skip constructors and conversion functions, which have their return types
2078 // built into their names.
2079 if (isa<CXXConstructorDecl>(ND) || isa<CXXConversionDecl>(ND))
2082 // Determine the type of the declaration (if it has a type).
2084 if (const FunctionDecl *Function = ND->getAsFunction())
2085 T = Function->getReturnType();
2086 else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2087 if (!BaseType.isNull())
2088 T = Method->getSendResultType(BaseType);
2090 T = Method->getReturnType();
2091 } else if (const EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND))
2092 T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext()));
2093 else if (isa<UnresolvedUsingValueDecl>(ND)) {
2094 /* Do nothing: ignore unresolved using declarations*/
2095 } else if (const ObjCIvarDecl *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
2096 if (!BaseType.isNull())
2097 T = Ivar->getUsageType(BaseType);
2099 T = Ivar->getType();
2100 } else if (const ValueDecl *Value = dyn_cast<ValueDecl>(ND)) {
2101 T = Value->getType();
2102 } else if (const ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND)) {
2103 if (!BaseType.isNull())
2104 T = Property->getUsageType(BaseType);
2106 T = Property->getType();
2109 if (T.isNull() || Context.hasSameType(T, Context.DependentTy))
2112 Result.AddResultTypeChunk(GetCompletionTypeString(T, Context, Policy,
2113 Result.getAllocator()));
2116 static void MaybeAddSentinel(Preprocessor &PP,
2117 const NamedDecl *FunctionOrMethod,
2118 CodeCompletionBuilder &Result) {
2119 if (SentinelAttr *Sentinel = FunctionOrMethod->getAttr<SentinelAttr>())
2120 if (Sentinel->getSentinel() == 0) {
2121 if (PP.getLangOpts().ObjC1 && PP.isMacroDefined("nil"))
2122 Result.AddTextChunk(", nil");
2123 else if (PP.isMacroDefined("NULL"))
2124 Result.AddTextChunk(", NULL");
2126 Result.AddTextChunk(", (void*)0");
2130 static std::string formatObjCParamQualifiers(unsigned ObjCQuals,
2133 if (ObjCQuals & Decl::OBJC_TQ_In)
2135 else if (ObjCQuals & Decl::OBJC_TQ_Inout)
2137 else if (ObjCQuals & Decl::OBJC_TQ_Out)
2139 if (ObjCQuals & Decl::OBJC_TQ_Bycopy)
2140 Result += "bycopy ";
2141 else if (ObjCQuals & Decl::OBJC_TQ_Byref)
2143 if (ObjCQuals & Decl::OBJC_TQ_Oneway)
2144 Result += "oneway ";
2145 if (ObjCQuals & Decl::OBJC_TQ_CSNullability) {
2146 if (auto nullability = AttributedType::stripOuterNullability(Type)) {
2147 switch (*nullability) {
2148 case NullabilityKind::NonNull:
2149 Result += "nonnull ";
2152 case NullabilityKind::Nullable:
2153 Result += "nullable ";
2156 case NullabilityKind::Unspecified:
2157 Result += "null_unspecified ";
2165 static std::string FormatFunctionParameter(const PrintingPolicy &Policy,
2166 const ParmVarDecl *Param,
2167 bool SuppressName = false,
2168 bool SuppressBlock = false,
2169 Optional<ArrayRef<QualType>> ObjCSubsts = None) {
2170 bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext());
2171 if (Param->getType()->isDependentType() ||
2172 !Param->getType()->isBlockPointerType()) {
2173 // The argument for a dependent or non-block parameter is a placeholder
2174 // containing that parameter's type.
2177 if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName)
2178 Result = Param->getIdentifier()->getName();
2180 QualType Type = Param->getType();
2182 Type = Type.substObjCTypeArgs(Param->getASTContext(), *ObjCSubsts,
2183 ObjCSubstitutionContext::Parameter);
2184 if (ObjCMethodParam) {
2185 Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(),
2187 Result += Type.getAsString(Policy) + ")";
2188 if (Param->getIdentifier() && !SuppressName)
2189 Result += Param->getIdentifier()->getName();
2191 Type.getAsStringInternal(Result, Policy);
2196 // The argument for a block pointer parameter is a block literal with
2197 // the appropriate type.
2198 FunctionTypeLoc Block;
2199 FunctionProtoTypeLoc BlockProto;
2201 if (TypeSourceInfo *TSInfo = Param->getTypeSourceInfo()) {
2202 TL = TSInfo->getTypeLoc().getUnqualifiedLoc();
2204 // Look through typedefs.
2205 if (!SuppressBlock) {
2206 if (TypedefTypeLoc TypedefTL = TL.getAs<TypedefTypeLoc>()) {
2207 if (TypeSourceInfo *InnerTSInfo =
2208 TypedefTL.getTypedefNameDecl()->getTypeSourceInfo()) {
2209 TL = InnerTSInfo->getTypeLoc().getUnqualifiedLoc();
2214 // Look through qualified types
2215 if (QualifiedTypeLoc QualifiedTL = TL.getAs<QualifiedTypeLoc>()) {
2216 TL = QualifiedTL.getUnqualifiedLoc();
2220 if (AttributedTypeLoc AttrTL = TL.getAs<AttributedTypeLoc>()) {
2221 TL = AttrTL.getModifiedLoc();
2226 // Try to get the function prototype behind the block pointer type,
2228 if (BlockPointerTypeLoc BlockPtr = TL.getAs<BlockPointerTypeLoc>()) {
2229 TL = BlockPtr.getPointeeLoc().IgnoreParens();
2230 Block = TL.getAs<FunctionTypeLoc>();
2231 BlockProto = TL.getAs<FunctionProtoTypeLoc>();
2238 // We were unable to find a FunctionProtoTypeLoc with parameter names
2239 // for the block; just use the parameter type as a placeholder.
2241 if (!ObjCMethodParam && Param->getIdentifier())
2242 Result = Param->getIdentifier()->getName();
2244 QualType Type = Param->getType().getUnqualifiedType();
2246 if (ObjCMethodParam) {
2247 Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(),
2249 Result += Type.getAsString(Policy) + Result + ")";
2250 if (Param->getIdentifier())
2251 Result += Param->getIdentifier()->getName();
2253 Type.getAsStringInternal(Result, Policy);
2259 // We have the function prototype behind the block pointer type, as it was
2260 // written in the source.
2262 QualType ResultType = Block.getTypePtr()->getReturnType();
2264 ResultType = ResultType.substObjCTypeArgs(Param->getASTContext(),
2266 ObjCSubstitutionContext::Result);
2267 if (!ResultType->isVoidType() || SuppressBlock)
2268 ResultType.getAsStringInternal(Result, Policy);
2270 // Format the parameter list.
2272 if (!BlockProto || Block.getNumParams() == 0) {
2273 if (BlockProto && BlockProto.getTypePtr()->isVariadic())
2279 for (unsigned I = 0, N = Block.getNumParams(); I != N; ++I) {
2282 Params += FormatFunctionParameter(Policy, Block.getParam(I),
2283 /*SuppressName=*/false,
2284 /*SuppressBlock=*/true,
2287 if (I == N - 1 && BlockProto.getTypePtr()->isVariadic())
2293 if (SuppressBlock) {
2294 // Format as a parameter.
2295 Result = Result + " (^";
2296 if (Param->getIdentifier())
2297 Result += Param->getIdentifier()->getName();
2301 // Format as a block literal argument.
2302 Result = '^' + Result;
2305 if (Param->getIdentifier())
2306 Result += Param->getIdentifier()->getName();
2312 /// \brief Add function parameter chunks to the given code completion string.
2313 static void AddFunctionParameterChunks(Preprocessor &PP,
2314 const PrintingPolicy &Policy,
2315 const FunctionDecl *Function,
2316 CodeCompletionBuilder &Result,
2318 bool InOptional = false) {
2319 bool FirstParameter = true;
2321 for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) {
2322 const ParmVarDecl *Param = Function->getParamDecl(P);
2324 if (Param->hasDefaultArg() && !InOptional) {
2325 // When we see an optional default argument, put that argument and
2326 // the remaining default arguments into a new, optional string.
2327 CodeCompletionBuilder Opt(Result.getAllocator(),
2328 Result.getCodeCompletionTUInfo());
2329 if (!FirstParameter)
2330 Opt.AddChunk(CodeCompletionString::CK_Comma);
2331 AddFunctionParameterChunks(PP, Policy, Function, Opt, P, true);
2332 Result.AddOptionalChunk(Opt.TakeString());
2337 FirstParameter = false;
2339 Result.AddChunk(CodeCompletionString::CK_Comma);
2343 // Format the placeholder string.
2344 std::string PlaceholderStr = FormatFunctionParameter(Policy, Param);
2346 if (Function->isVariadic() && P == N - 1)
2347 PlaceholderStr += ", ...";
2349 // Add the placeholder string.
2350 Result.AddPlaceholderChunk(
2351 Result.getAllocator().CopyString(PlaceholderStr));
2354 if (const FunctionProtoType *Proto
2355 = Function->getType()->getAs<FunctionProtoType>())
2356 if (Proto->isVariadic()) {
2357 if (Proto->getNumParams() == 0)
2358 Result.AddPlaceholderChunk("...");
2360 MaybeAddSentinel(PP, Function, Result);
2364 /// \brief Add template parameter chunks to the given code completion string.
2365 static void AddTemplateParameterChunks(ASTContext &Context,
2366 const PrintingPolicy &Policy,
2367 const TemplateDecl *Template,
2368 CodeCompletionBuilder &Result,
2369 unsigned MaxParameters = 0,
2371 bool InDefaultArg = false) {
2372 bool FirstParameter = true;
2374 // Prefer to take the template parameter names from the first declaration of
2376 Template = cast<TemplateDecl>(Template->getCanonicalDecl());
2378 TemplateParameterList *Params = Template->getTemplateParameters();
2379 TemplateParameterList::iterator PEnd = Params->end();
2381 PEnd = Params->begin() + MaxParameters;
2382 for (TemplateParameterList::iterator P = Params->begin() + Start;
2384 bool HasDefaultArg = false;
2385 std::string PlaceholderStr;
2386 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
2387 if (TTP->wasDeclaredWithTypename())
2388 PlaceholderStr = "typename";
2390 PlaceholderStr = "class";
2392 if (TTP->getIdentifier()) {
2393 PlaceholderStr += ' ';
2394 PlaceholderStr += TTP->getIdentifier()->getName();
2397 HasDefaultArg = TTP->hasDefaultArgument();
2398 } else if (NonTypeTemplateParmDecl *NTTP
2399 = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
2400 if (NTTP->getIdentifier())
2401 PlaceholderStr = NTTP->getIdentifier()->getName();
2402 NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
2403 HasDefaultArg = NTTP->hasDefaultArgument();
2405 assert(isa<TemplateTemplateParmDecl>(*P));
2406 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
2408 // Since putting the template argument list into the placeholder would
2409 // be very, very long, we just use an abbreviation.
2410 PlaceholderStr = "template<...> class";
2411 if (TTP->getIdentifier()) {
2412 PlaceholderStr += ' ';
2413 PlaceholderStr += TTP->getIdentifier()->getName();
2416 HasDefaultArg = TTP->hasDefaultArgument();
2419 if (HasDefaultArg && !InDefaultArg) {
2420 // When we see an optional default argument, put that argument and
2421 // the remaining default arguments into a new, optional string.
2422 CodeCompletionBuilder Opt(Result.getAllocator(),
2423 Result.getCodeCompletionTUInfo());
2424 if (!FirstParameter)
2425 Opt.AddChunk(CodeCompletionString::CK_Comma);
2426 AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters,
2427 P - Params->begin(), true);
2428 Result.AddOptionalChunk(Opt.TakeString());
2432 InDefaultArg = false;
2435 FirstParameter = false;
2437 Result.AddChunk(CodeCompletionString::CK_Comma);
2439 // Add the placeholder string.
2440 Result.AddPlaceholderChunk(
2441 Result.getAllocator().CopyString(PlaceholderStr));
2445 /// \brief Add a qualifier to the given code-completion string, if the
2446 /// provided nested-name-specifier is non-NULL.
2448 AddQualifierToCompletionString(CodeCompletionBuilder &Result,
2449 NestedNameSpecifier *Qualifier,
2450 bool QualifierIsInformative,
2451 ASTContext &Context,
2452 const PrintingPolicy &Policy) {
2456 std::string PrintedNNS;
2458 llvm::raw_string_ostream OS(PrintedNNS);
2459 Qualifier->print(OS, Policy);
2461 if (QualifierIsInformative)
2462 Result.AddInformativeChunk(Result.getAllocator().CopyString(PrintedNNS));
2464 Result.AddTextChunk(Result.getAllocator().CopyString(PrintedNNS));
2468 AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result,
2469 const FunctionDecl *Function) {
2470 const FunctionProtoType *Proto
2471 = Function->getType()->getAs<FunctionProtoType>();
2472 if (!Proto || !Proto->getTypeQuals())
2475 // FIXME: Add ref-qualifier!
2477 // Handle single qualifiers without copying
2478 if (Proto->getTypeQuals() == Qualifiers::Const) {
2479 Result.AddInformativeChunk(" const");
2483 if (Proto->getTypeQuals() == Qualifiers::Volatile) {
2484 Result.AddInformativeChunk(" volatile");
2488 if (Proto->getTypeQuals() == Qualifiers::Restrict) {
2489 Result.AddInformativeChunk(" restrict");
2493 // Handle multiple qualifiers.
2494 std::string QualsStr;
2495 if (Proto->isConst())
2496 QualsStr += " const";
2497 if (Proto->isVolatile())
2498 QualsStr += " volatile";
2499 if (Proto->isRestrict())
2500 QualsStr += " restrict";
2501 Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
2504 /// \brief Add the name of the given declaration
2505 static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy,
2506 const NamedDecl *ND,
2507 CodeCompletionBuilder &Result) {
2508 DeclarationName Name = ND->getDeclName();
2512 switch (Name.getNameKind()) {
2513 case DeclarationName::CXXOperatorName: {
2514 const char *OperatorName = nullptr;
2515 switch (Name.getCXXOverloadedOperator()) {
2517 case OO_Conditional:
2518 case NUM_OVERLOADED_OPERATORS:
2519 OperatorName = "operator";
2522 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2523 case OO_##Name: OperatorName = "operator" Spelling; break;
2524 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2525 #include "clang/Basic/OperatorKinds.def"
2527 case OO_New: OperatorName = "operator new"; break;
2528 case OO_Delete: OperatorName = "operator delete"; break;
2529 case OO_Array_New: OperatorName = "operator new[]"; break;
2530 case OO_Array_Delete: OperatorName = "operator delete[]"; break;
2531 case OO_Call: OperatorName = "operator()"; break;
2532 case OO_Subscript: OperatorName = "operator[]"; break;
2534 Result.AddTypedTextChunk(OperatorName);
2538 case DeclarationName::Identifier:
2539 case DeclarationName::CXXConversionFunctionName:
2540 case DeclarationName::CXXDestructorName:
2541 case DeclarationName::CXXLiteralOperatorName:
2542 Result.AddTypedTextChunk(
2543 Result.getAllocator().CopyString(ND->getNameAsString()));
2546 case DeclarationName::CXXUsingDirective:
2547 case DeclarationName::ObjCZeroArgSelector:
2548 case DeclarationName::ObjCOneArgSelector:
2549 case DeclarationName::ObjCMultiArgSelector:
2552 case DeclarationName::CXXConstructorName: {
2553 CXXRecordDecl *Record = nullptr;
2554 QualType Ty = Name.getCXXNameType();
2555 if (const RecordType *RecordTy = Ty->getAs<RecordType>())
2556 Record = cast<CXXRecordDecl>(RecordTy->getDecl());
2557 else if (const InjectedClassNameType *InjectedTy
2558 = Ty->getAs<InjectedClassNameType>())
2559 Record = InjectedTy->getDecl();
2561 Result.AddTypedTextChunk(
2562 Result.getAllocator().CopyString(ND->getNameAsString()));
2566 Result.AddTypedTextChunk(
2567 Result.getAllocator().CopyString(Record->getNameAsString()));
2568 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) {
2569 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2570 AddTemplateParameterChunks(Context, Policy, Template, Result);
2571 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2578 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(Sema &S,
2579 const CodeCompletionContext &CCContext,
2580 CodeCompletionAllocator &Allocator,
2581 CodeCompletionTUInfo &CCTUInfo,
2582 bool IncludeBriefComments) {
2583 return CreateCodeCompletionString(S.Context, S.PP, CCContext, Allocator,
2584 CCTUInfo, IncludeBriefComments);
2587 /// \brief If possible, create a new code completion string for the given
2590 /// \returns Either a new, heap-allocated code completion string describing
2591 /// how to use this result, or NULL to indicate that the string or name of the
2592 /// result is all that is needed.
2593 CodeCompletionString *
2594 CodeCompletionResult::CreateCodeCompletionString(ASTContext &Ctx,
2596 const CodeCompletionContext &CCContext,
2597 CodeCompletionAllocator &Allocator,
2598 CodeCompletionTUInfo &CCTUInfo,
2599 bool IncludeBriefComments) {
2600 CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
2602 PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP);
2603 if (Kind == RK_Pattern) {
2604 Pattern->Priority = Priority;
2605 Pattern->Availability = Availability;
2608 Result.addParentContext(Declaration->getDeclContext());
2609 Pattern->ParentName = Result.getParentName();
2610 // Provide code completion comment for self.GetterName where
2611 // GetterName is the getter method for a property with name
2612 // different from the property name (declared via a property
2613 // getter attribute.
2614 const NamedDecl *ND = Declaration;
2615 if (const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(ND))
2616 if (M->isPropertyAccessor())
2617 if (const ObjCPropertyDecl *PDecl = M->findPropertyDecl())
2618 if (PDecl->getGetterName() == M->getSelector() &&
2619 PDecl->getIdentifier() != M->getIdentifier()) {
2620 if (const RawComment *RC =
2621 Ctx.getRawCommentForAnyRedecl(M)) {
2622 Result.addBriefComment(RC->getBriefText(Ctx));
2623 Pattern->BriefComment = Result.getBriefComment();
2625 else if (const RawComment *RC =
2626 Ctx.getRawCommentForAnyRedecl(PDecl)) {
2627 Result.addBriefComment(RC->getBriefText(Ctx));
2628 Pattern->BriefComment = Result.getBriefComment();
2636 if (Kind == RK_Keyword) {
2637 Result.AddTypedTextChunk(Keyword);
2638 return Result.TakeString();
2641 if (Kind == RK_Macro) {
2642 const MacroInfo *MI = PP.getMacroInfo(Macro);
2643 Result.AddTypedTextChunk(
2644 Result.getAllocator().CopyString(Macro->getName()));
2646 if (!MI || !MI->isFunctionLike())
2647 return Result.TakeString();
2649 // Format a function-like macro with placeholders for the arguments.
2650 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2651 MacroInfo::arg_iterator A = MI->arg_begin(), AEnd = MI->arg_end();
2653 // C99 variadic macros add __VA_ARGS__ at the end. Skip it.
2654 if (MI->isC99Varargs()) {
2658 Result.AddPlaceholderChunk("...");
2662 for (MacroInfo::arg_iterator A = MI->arg_begin(); A != AEnd; ++A) {
2663 if (A != MI->arg_begin())
2664 Result.AddChunk(CodeCompletionString::CK_Comma);
2666 if (MI->isVariadic() && (A+1) == AEnd) {
2667 SmallString<32> Arg = (*A)->getName();
2668 if (MI->isC99Varargs())
2672 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
2676 // Non-variadic macros are simple.
2677 Result.AddPlaceholderChunk(
2678 Result.getAllocator().CopyString((*A)->getName()));
2680 Result.AddChunk(CodeCompletionString::CK_RightParen);
2681 return Result.TakeString();
2684 assert(Kind == RK_Declaration && "Missed a result kind?");
2685 const NamedDecl *ND = Declaration;
2686 Result.addParentContext(ND->getDeclContext());
2688 if (IncludeBriefComments) {
2689 // Add documentation comment, if it exists.
2690 if (const RawComment *RC = Ctx.getRawCommentForAnyRedecl(ND)) {
2691 Result.addBriefComment(RC->getBriefText(Ctx));
2693 else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND))
2694 if (OMD->isPropertyAccessor())
2695 if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())
2696 if (const RawComment *RC = Ctx.getRawCommentForAnyRedecl(PDecl))
2697 Result.addBriefComment(RC->getBriefText(Ctx));
2700 if (StartsNestedNameSpecifier) {
2701 Result.AddTypedTextChunk(
2702 Result.getAllocator().CopyString(ND->getNameAsString()));
2703 Result.AddTextChunk("::");
2704 return Result.TakeString();
2707 for (const auto *I : ND->specific_attrs<AnnotateAttr>())
2708 Result.AddAnnotation(Result.getAllocator().CopyString(I->getAnnotation()));
2710 AddResultTypeChunk(Ctx, Policy, ND, CCContext.getBaseType(), Result);
2712 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) {
2713 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2715 AddTypedNameChunk(Ctx, Policy, ND, Result);
2716 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2717 AddFunctionParameterChunks(PP, Policy, Function, Result);
2718 Result.AddChunk(CodeCompletionString::CK_RightParen);
2719 AddFunctionTypeQualsToCompletionString(Result, Function);
2720 return Result.TakeString();
2723 if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) {
2724 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2726 FunctionDecl *Function = FunTmpl->getTemplatedDecl();
2727 AddTypedNameChunk(Ctx, Policy, Function, Result);
2729 // Figure out which template parameters are deduced (or have default
2731 llvm::SmallBitVector Deduced;
2732 Sema::MarkDeducedTemplateParameters(Ctx, FunTmpl, Deduced);
2733 unsigned LastDeducibleArgument;
2734 for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0;
2735 --LastDeducibleArgument) {
2736 if (!Deduced[LastDeducibleArgument - 1]) {
2737 // C++0x: Figure out if the template argument has a default. If so,
2738 // the user doesn't need to type this argument.
2739 // FIXME: We need to abstract template parameters better!
2740 bool HasDefaultArg = false;
2741 NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam(
2742 LastDeducibleArgument - 1);
2743 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
2744 HasDefaultArg = TTP->hasDefaultArgument();
2745 else if (NonTypeTemplateParmDecl *NTTP
2746 = dyn_cast<NonTypeTemplateParmDecl>(Param))
2747 HasDefaultArg = NTTP->hasDefaultArgument();
2749 assert(isa<TemplateTemplateParmDecl>(Param));
2751 = cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument();
2759 if (LastDeducibleArgument) {
2760 // Some of the function template arguments cannot be deduced from a
2761 // function call, so we introduce an explicit template argument list
2762 // containing all of the arguments up to the first deducible argument.
2763 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2764 AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result,
2765 LastDeducibleArgument);
2766 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2769 // Add the function parameters
2770 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2771 AddFunctionParameterChunks(PP, Policy, Function, Result);
2772 Result.AddChunk(CodeCompletionString::CK_RightParen);
2773 AddFunctionTypeQualsToCompletionString(Result, Function);
2774 return Result.TakeString();
2777 if (const TemplateDecl *Template = dyn_cast<TemplateDecl>(ND)) {
2778 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2780 Result.AddTypedTextChunk(
2781 Result.getAllocator().CopyString(Template->getNameAsString()));
2782 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2783 AddTemplateParameterChunks(Ctx, Policy, Template, Result);
2784 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2785 return Result.TakeString();
2788 if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2789 Selector Sel = Method->getSelector();
2790 if (Sel.isUnarySelector()) {
2791 Result.AddTypedTextChunk(Result.getAllocator().CopyString(
2792 Sel.getNameForSlot(0)));
2793 return Result.TakeString();
2796 std::string SelName = Sel.getNameForSlot(0).str();
2798 if (StartParameter == 0)
2799 Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName));
2801 Result.AddInformativeChunk(Result.getAllocator().CopyString(SelName));
2803 // If there is only one parameter, and we're past it, add an empty
2804 // typed-text chunk since there is nothing to type.
2805 if (Method->param_size() == 1)
2806 Result.AddTypedTextChunk("");
2809 for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(),
2810 PEnd = Method->param_end();
2811 P != PEnd; (void)++P, ++Idx) {
2813 std::string Keyword;
2814 if (Idx > StartParameter)
2815 Result.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2816 if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx))
2817 Keyword += II->getName();
2819 if (Idx < StartParameter || AllParametersAreInformative)
2820 Result.AddInformativeChunk(Result.getAllocator().CopyString(Keyword));
2822 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Keyword));
2825 // If we're before the starting parameter, skip the placeholder.
2826 if (Idx < StartParameter)
2830 QualType ParamType = (*P)->getType();
2831 Optional<ArrayRef<QualType>> ObjCSubsts;
2832 if (!CCContext.getBaseType().isNull())
2833 ObjCSubsts = CCContext.getBaseType()->getObjCSubstitutions(Method);
2835 if (ParamType->isBlockPointerType() && !DeclaringEntity)
2836 Arg = FormatFunctionParameter(Policy, *P, true,
2837 /*SuppressBlock=*/false,
2841 ParamType = ParamType.substObjCTypeArgs(Ctx, *ObjCSubsts,
2842 ObjCSubstitutionContext::Parameter);
2843 Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier(),
2845 Arg += ParamType.getAsString(Policy) + ")";
2846 if (IdentifierInfo *II = (*P)->getIdentifier())
2847 if (DeclaringEntity || AllParametersAreInformative)
2848 Arg += II->getName();
2851 if (Method->isVariadic() && (P + 1) == PEnd)
2854 if (DeclaringEntity)
2855 Result.AddTextChunk(Result.getAllocator().CopyString(Arg));
2856 else if (AllParametersAreInformative)
2857 Result.AddInformativeChunk(Result.getAllocator().CopyString(Arg));
2859 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
2862 if (Method->isVariadic()) {
2863 if (Method->param_size() == 0) {
2864 if (DeclaringEntity)
2865 Result.AddTextChunk(", ...");
2866 else if (AllParametersAreInformative)
2867 Result.AddInformativeChunk(", ...");
2869 Result.AddPlaceholderChunk(", ...");
2872 MaybeAddSentinel(PP, Method, Result);
2875 return Result.TakeString();
2879 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2882 Result.AddTypedTextChunk(
2883 Result.getAllocator().CopyString(ND->getNameAsString()));
2884 return Result.TakeString();
2887 /// \brief Add function overload parameter chunks to the given code completion
2889 static void AddOverloadParameterChunks(ASTContext &Context,
2890 const PrintingPolicy &Policy,
2891 const FunctionDecl *Function,
2892 const FunctionProtoType *Prototype,
2893 CodeCompletionBuilder &Result,
2894 unsigned CurrentArg,
2896 bool InOptional = false) {
2897 bool FirstParameter = true;
2898 unsigned NumParams = Function ? Function->getNumParams()
2899 : Prototype->getNumParams();
2901 for (unsigned P = Start; P != NumParams; ++P) {
2902 if (Function && Function->getParamDecl(P)->hasDefaultArg() && !InOptional) {
2903 // When we see an optional default argument, put that argument and
2904 // the remaining default arguments into a new, optional string.
2905 CodeCompletionBuilder Opt(Result.getAllocator(),
2906 Result.getCodeCompletionTUInfo());
2907 if (!FirstParameter)
2908 Opt.AddChunk(CodeCompletionString::CK_Comma);
2909 // Optional sections are nested.
2910 AddOverloadParameterChunks(Context, Policy, Function, Prototype, Opt,
2911 CurrentArg, P, /*InOptional=*/true);
2912 Result.AddOptionalChunk(Opt.TakeString());
2917 FirstParameter = false;
2919 Result.AddChunk(CodeCompletionString::CK_Comma);
2923 // Format the placeholder string.
2924 std::string Placeholder;
2926 Placeholder = FormatFunctionParameter(Policy, Function->getParamDecl(P));
2928 Placeholder = Prototype->getParamType(P).getAsString(Policy);
2930 if (P == CurrentArg)
2931 Result.AddCurrentParameterChunk(
2932 Result.getAllocator().CopyString(Placeholder));
2934 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Placeholder));
2937 if (Prototype && Prototype->isVariadic()) {
2938 CodeCompletionBuilder Opt(Result.getAllocator(),
2939 Result.getCodeCompletionTUInfo());
2940 if (!FirstParameter)
2941 Opt.AddChunk(CodeCompletionString::CK_Comma);
2943 if (CurrentArg < NumParams)
2944 Opt.AddPlaceholderChunk("...");
2946 Opt.AddCurrentParameterChunk("...");
2948 Result.AddOptionalChunk(Opt.TakeString());
2952 CodeCompletionString *
2953 CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
2954 unsigned CurrentArg, Sema &S,
2955 CodeCompletionAllocator &Allocator,
2956 CodeCompletionTUInfo &CCTUInfo,
2957 bool IncludeBriefComments) const {
2958 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
2960 // FIXME: Set priority, availability appropriately.
2961 CodeCompletionBuilder Result(Allocator,CCTUInfo, 1, CXAvailability_Available);
2962 FunctionDecl *FDecl = getFunction();
2963 const FunctionProtoType *Proto
2964 = dyn_cast<FunctionProtoType>(getFunctionType());
2965 if (!FDecl && !Proto) {
2966 // Function without a prototype. Just give the return type and a
2967 // highlighted ellipsis.
2968 const FunctionType *FT = getFunctionType();
2969 Result.AddResultTypeChunk(Result.getAllocator().CopyString(
2970 FT->getReturnType().getAsString(Policy)));
2971 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2972 Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
2973 Result.AddChunk(CodeCompletionString::CK_RightParen);
2974 return Result.TakeString();
2978 if (IncludeBriefComments && CurrentArg < FDecl->getNumParams())
2979 if (auto RC = S.getASTContext().getRawCommentForAnyRedecl(
2980 FDecl->getParamDecl(CurrentArg)))
2981 Result.addBriefComment(RC->getBriefText(S.getASTContext()));
2982 AddResultTypeChunk(S.Context, Policy, FDecl, QualType(), Result);
2983 Result.AddTextChunk(
2984 Result.getAllocator().CopyString(FDecl->getNameAsString()));
2986 Result.AddResultTypeChunk(
2987 Result.getAllocator().CopyString(
2988 Proto->getReturnType().getAsString(Policy)));
2991 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2992 AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, Result,
2994 Result.AddChunk(CodeCompletionString::CK_RightParen);
2996 return Result.TakeString();
2999 unsigned clang::getMacroUsagePriority(StringRef MacroName,
3000 const LangOptions &LangOpts,
3001 bool PreferredTypeIsPointer) {
3002 unsigned Priority = CCP_Macro;
3004 // Treat the "nil", "Nil" and "NULL" macros as null pointer constants.
3005 if (MacroName.equals("nil") || MacroName.equals("NULL") ||
3006 MacroName.equals("Nil")) {
3007 Priority = CCP_Constant;
3008 if (PreferredTypeIsPointer)
3009 Priority = Priority / CCF_SimilarTypeMatch;
3011 // Treat "YES", "NO", "true", and "false" as constants.
3012 else if (MacroName.equals("YES") || MacroName.equals("NO") ||
3013 MacroName.equals("true") || MacroName.equals("false"))
3014 Priority = CCP_Constant;
3015 // Treat "bool" as a type.
3016 else if (MacroName.equals("bool"))
3017 Priority = CCP_Type + (LangOpts.ObjC1? CCD_bool_in_ObjC : 0);
3023 CXCursorKind clang::getCursorKindForDecl(const Decl *D) {
3025 return CXCursor_UnexposedDecl;
3027 switch (D->getKind()) {
3028 case Decl::Enum: return CXCursor_EnumDecl;
3029 case Decl::EnumConstant: return CXCursor_EnumConstantDecl;
3030 case Decl::Field: return CXCursor_FieldDecl;
3031 case Decl::Function:
3032 return CXCursor_FunctionDecl;
3033 case Decl::ObjCCategory: return CXCursor_ObjCCategoryDecl;
3034 case Decl::ObjCCategoryImpl: return CXCursor_ObjCCategoryImplDecl;
3035 case Decl::ObjCImplementation: return CXCursor_ObjCImplementationDecl;
3037 case Decl::ObjCInterface: return CXCursor_ObjCInterfaceDecl;
3038 case Decl::ObjCIvar: return CXCursor_ObjCIvarDecl;
3039 case Decl::ObjCMethod:
3040 return cast<ObjCMethodDecl>(D)->isInstanceMethod()
3041 ? CXCursor_ObjCInstanceMethodDecl : CXCursor_ObjCClassMethodDecl;
3042 case Decl::CXXMethod: return CXCursor_CXXMethod;
3043 case Decl::CXXConstructor: return CXCursor_Constructor;
3044 case Decl::CXXDestructor: return CXCursor_Destructor;
3045 case Decl::CXXConversion: return CXCursor_ConversionFunction;
3046 case Decl::ObjCProperty: return CXCursor_ObjCPropertyDecl;
3047 case Decl::ObjCProtocol: return CXCursor_ObjCProtocolDecl;
3048 case Decl::ParmVar: return CXCursor_ParmDecl;
3049 case Decl::Typedef: return CXCursor_TypedefDecl;
3050 case Decl::TypeAlias: return CXCursor_TypeAliasDecl;
3051 case Decl::TypeAliasTemplate: return CXCursor_TypeAliasTemplateDecl;
3052 case Decl::Var: return CXCursor_VarDecl;
3053 case Decl::Namespace: return CXCursor_Namespace;
3054 case Decl::NamespaceAlias: return CXCursor_NamespaceAlias;
3055 case Decl::TemplateTypeParm: return CXCursor_TemplateTypeParameter;
3056 case Decl::NonTypeTemplateParm:return CXCursor_NonTypeTemplateParameter;
3057 case Decl::TemplateTemplateParm:return CXCursor_TemplateTemplateParameter;
3058 case Decl::FunctionTemplate: return CXCursor_FunctionTemplate;
3059 case Decl::ClassTemplate: return CXCursor_ClassTemplate;
3060 case Decl::AccessSpec: return CXCursor_CXXAccessSpecifier;
3061 case Decl::ClassTemplatePartialSpecialization:
3062 return CXCursor_ClassTemplatePartialSpecialization;
3063 case Decl::UsingDirective: return CXCursor_UsingDirective;
3064 case Decl::StaticAssert: return CXCursor_StaticAssert;
3065 case Decl::TranslationUnit: return CXCursor_TranslationUnit;
3068 case Decl::UnresolvedUsingValue:
3069 case Decl::UnresolvedUsingTypename:
3070 return CXCursor_UsingDeclaration;
3072 case Decl::ObjCPropertyImpl:
3073 switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
3074 case ObjCPropertyImplDecl::Dynamic:
3075 return CXCursor_ObjCDynamicDecl;
3077 case ObjCPropertyImplDecl::Synthesize:
3078 return CXCursor_ObjCSynthesizeDecl;
3082 return CXCursor_ModuleImportDecl;
3084 case Decl::ObjCTypeParam: return CXCursor_TemplateTypeParameter;
3087 if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
3088 switch (TD->getTagKind()) {
3089 case TTK_Interface: // fall through
3090 case TTK_Struct: return CXCursor_StructDecl;
3091 case TTK_Class: return CXCursor_ClassDecl;
3092 case TTK_Union: return CXCursor_UnionDecl;
3093 case TTK_Enum: return CXCursor_EnumDecl;
3098 return CXCursor_UnexposedDecl;
3101 static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results,
3102 bool IncludeUndefined,
3103 bool TargetTypeIsPointer = false) {
3104 typedef CodeCompletionResult Result;
3106 Results.EnterNewScope();
3108 for (Preprocessor::macro_iterator M = PP.macro_begin(),
3109 MEnd = PP.macro_end();
3111 auto MD = PP.getMacroDefinition(M->first);
3112 if (IncludeUndefined || MD) {
3113 if (MacroInfo *MI = MD.getMacroInfo())
3114 if (MI->isUsedForHeaderGuard())
3117 Results.AddResult(Result(M->first,
3118 getMacroUsagePriority(M->first->getName(),
3120 TargetTypeIsPointer)));
3124 Results.ExitScope();
3128 static void AddPrettyFunctionResults(const LangOptions &LangOpts,
3129 ResultBuilder &Results) {
3130 typedef CodeCompletionResult Result;
3132 Results.EnterNewScope();
3134 Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant));
3135 Results.AddResult(Result("__FUNCTION__", CCP_Constant));
3136 if (LangOpts.C99 || LangOpts.CPlusPlus11)
3137 Results.AddResult(Result("__func__", CCP_Constant));
3138 Results.ExitScope();
3141 static void HandleCodeCompleteResults(Sema *S,
3142 CodeCompleteConsumer *CodeCompleter,
3143 CodeCompletionContext Context,
3144 CodeCompletionResult *Results,
3145 unsigned NumResults) {
3147 CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults);
3150 static enum CodeCompletionContext::Kind mapCodeCompletionContext(Sema &S,
3151 Sema::ParserCompletionContext PCC) {
3153 case Sema::PCC_Namespace:
3154 return CodeCompletionContext::CCC_TopLevel;
3156 case Sema::PCC_Class:
3157 return CodeCompletionContext::CCC_ClassStructUnion;
3159 case Sema::PCC_ObjCInterface:
3160 return CodeCompletionContext::CCC_ObjCInterface;
3162 case Sema::PCC_ObjCImplementation:
3163 return CodeCompletionContext::CCC_ObjCImplementation;
3165 case Sema::PCC_ObjCInstanceVariableList:
3166 return CodeCompletionContext::CCC_ObjCIvarList;
3168 case Sema::PCC_Template:
3169 case Sema::PCC_MemberTemplate:
3170 if (S.CurContext->isFileContext())
3171 return CodeCompletionContext::CCC_TopLevel;
3172 if (S.CurContext->isRecord())
3173 return CodeCompletionContext::CCC_ClassStructUnion;
3174 return CodeCompletionContext::CCC_Other;
3176 case Sema::PCC_RecoveryInFunction:
3177 return CodeCompletionContext::CCC_Recovery;
3179 case Sema::PCC_ForInit:
3180 if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 ||
3181 S.getLangOpts().ObjC1)
3182 return CodeCompletionContext::CCC_ParenthesizedExpression;
3184 return CodeCompletionContext::CCC_Expression;
3186 case Sema::PCC_Expression:
3187 case Sema::PCC_Condition:
3188 return CodeCompletionContext::CCC_Expression;
3190 case Sema::PCC_Statement:
3191 return CodeCompletionContext::CCC_Statement;
3193 case Sema::PCC_Type:
3194 return CodeCompletionContext::CCC_Type;
3196 case Sema::PCC_ParenthesizedExpression:
3197 return CodeCompletionContext::CCC_ParenthesizedExpression;
3199 case Sema::PCC_LocalDeclarationSpecifiers:
3200 return CodeCompletionContext::CCC_Type;
3203 llvm_unreachable("Invalid ParserCompletionContext!");
3206 /// \brief If we're in a C++ virtual member function, add completion results
3207 /// that invoke the functions we override, since it's common to invoke the
3208 /// overridden function as well as adding new functionality.
3210 /// \param S The semantic analysis object for which we are generating results.
3212 /// \param InContext This context in which the nested-name-specifier preceding
3213 /// the code-completion point
3214 static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext,
3215 ResultBuilder &Results) {
3216 // Look through blocks.
3217 DeclContext *CurContext = S.CurContext;
3218 while (isa<BlockDecl>(CurContext))
3219 CurContext = CurContext->getParent();
3222 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext);
3223 if (!Method || !Method->isVirtual())
3226 // We need to have names for all of the parameters, if we're going to
3227 // generate a forwarding call.
3228 for (auto P : Method->parameters())
3229 if (!P->getDeclName())
3232 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
3233 for (CXXMethodDecl::method_iterator M = Method->begin_overridden_methods(),
3234 MEnd = Method->end_overridden_methods();
3236 CodeCompletionBuilder Builder(Results.getAllocator(),
3237 Results.getCodeCompletionTUInfo());
3238 const CXXMethodDecl *Overridden = *M;
3239 if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl())
3242 // If we need a nested-name-specifier, add one now.
3244 NestedNameSpecifier *NNS
3245 = getRequiredQualification(S.Context, CurContext,
3246 Overridden->getDeclContext());
3249 llvm::raw_string_ostream OS(Str);
3250 NNS->print(OS, Policy);
3251 Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
3253 } else if (!InContext->Equals(Overridden->getDeclContext()))
3256 Builder.AddTypedTextChunk(Results.getAllocator().CopyString(
3257 Overridden->getNameAsString()));
3258 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
3259 bool FirstParam = true;
3260 for (auto P : Method->parameters()) {
3264 Builder.AddChunk(CodeCompletionString::CK_Comma);
3266 Builder.AddPlaceholderChunk(
3267 Results.getAllocator().CopyString(P->getIdentifier()->getName()));
3269 Builder.AddChunk(CodeCompletionString::CK_RightParen);
3270 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
3271 CCP_SuperCompletion,
3273 CXAvailability_Available,
3275 Results.Ignore(Overridden);
3279 void Sema::CodeCompleteModuleImport(SourceLocation ImportLoc,
3280 ModuleIdPath Path) {
3281 typedef CodeCompletionResult Result;
3282 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3283 CodeCompleter->getCodeCompletionTUInfo(),
3284 CodeCompletionContext::CCC_Other);
3285 Results.EnterNewScope();
3287 CodeCompletionAllocator &Allocator = Results.getAllocator();
3288 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
3289 typedef CodeCompletionResult Result;
3291 // Enumerate all top-level modules.
3292 SmallVector<Module *, 8> Modules;
3293 PP.getHeaderSearchInfo().collectAllModules(Modules);
3294 for (unsigned I = 0, N = Modules.size(); I != N; ++I) {
3295 Builder.AddTypedTextChunk(
3296 Builder.getAllocator().CopyString(Modules[I]->Name));
3297 Results.AddResult(Result(Builder.TakeString(),
3299 CXCursor_ModuleImportDecl,
3300 Modules[I]->isAvailable()
3301 ? CXAvailability_Available
3302 : CXAvailability_NotAvailable));
3304 } else if (getLangOpts().Modules) {
3305 // Load the named module.
3306 Module *Mod = PP.getModuleLoader().loadModule(ImportLoc, Path,
3308 /*IsInclusionDirective=*/false);
3309 // Enumerate submodules.
3311 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
3312 SubEnd = Mod->submodule_end();
3313 Sub != SubEnd; ++Sub) {
3315 Builder.AddTypedTextChunk(
3316 Builder.getAllocator().CopyString((*Sub)->Name));
3317 Results.AddResult(Result(Builder.TakeString(),
3319 CXCursor_ModuleImportDecl,
3320 (*Sub)->isAvailable()
3321 ? CXAvailability_Available
3322 : CXAvailability_NotAvailable));
3326 Results.ExitScope();
3327 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3328 Results.data(),Results.size());
3331 void Sema::CodeCompleteOrdinaryName(Scope *S,
3332 ParserCompletionContext CompletionContext) {
3333 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3334 CodeCompleter->getCodeCompletionTUInfo(),
3335 mapCodeCompletionContext(*this, CompletionContext));
3336 Results.EnterNewScope();
3338 // Determine how to filter results, e.g., so that the names of
3339 // values (functions, enumerators, function templates, etc.) are
3340 // only allowed where we can have an expression.
3341 switch (CompletionContext) {
3344 case PCC_ObjCInterface:
3345 case PCC_ObjCImplementation:
3346 case PCC_ObjCInstanceVariableList:
3348 case PCC_MemberTemplate:
3350 case PCC_LocalDeclarationSpecifiers:
3351 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
3355 case PCC_ParenthesizedExpression:
3356 case PCC_Expression:
3359 if (WantTypesInContext(CompletionContext, getLangOpts()))
3360 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3362 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3364 if (getLangOpts().CPlusPlus)
3365 MaybeAddOverrideCalls(*this, /*InContext=*/nullptr, Results);
3368 case PCC_RecoveryInFunction:
3373 // If we are in a C++ non-static member function, check the qualifiers on
3374 // the member function to filter/prioritize the results list.
3375 if (CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext))
3376 if (CurMethod->isInstance())
3377 Results.setObjectTypeQualifiers(
3378 Qualifiers::fromCVRMask(CurMethod->getTypeQualifiers()));
3380 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3381 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3382 CodeCompleter->includeGlobals());
3384 AddOrdinaryNameResults(CompletionContext, S, *this, Results);
3385 Results.ExitScope();
3387 switch (CompletionContext) {
3388 case PCC_ParenthesizedExpression:
3389 case PCC_Expression:
3391 case PCC_RecoveryInFunction:
3392 if (S->getFnParent())
3393 AddPrettyFunctionResults(getLangOpts(), Results);
3398 case PCC_ObjCInterface:
3399 case PCC_ObjCImplementation:
3400 case PCC_ObjCInstanceVariableList:
3402 case PCC_MemberTemplate:
3406 case PCC_LocalDeclarationSpecifiers:
3410 if (CodeCompleter->includeMacros())
3411 AddMacroResults(PP, Results, false);
3413 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3414 Results.data(),Results.size());
3417 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
3418 ParsedType Receiver,
3419 ArrayRef<IdentifierInfo *> SelIdents,
3420 bool AtArgumentExpression,
3422 ResultBuilder &Results);
3424 void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
3425 bool AllowNonIdentifiers,
3426 bool AllowNestedNameSpecifiers) {
3427 typedef CodeCompletionResult Result;
3428 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3429 CodeCompleter->getCodeCompletionTUInfo(),
3430 AllowNestedNameSpecifiers
3431 ? CodeCompletionContext::CCC_PotentiallyQualifiedName
3432 : CodeCompletionContext::CCC_Name);
3433 Results.EnterNewScope();
3435 // Type qualifiers can come after names.
3436 Results.AddResult(Result("const"));
3437 Results.AddResult(Result("volatile"));
3438 if (getLangOpts().C99)
3439 Results.AddResult(Result("restrict"));
3441 if (getLangOpts().CPlusPlus) {
3442 if (AllowNonIdentifiers) {
3443 Results.AddResult(Result("operator"));
3446 // Add nested-name-specifiers.
3447 if (AllowNestedNameSpecifiers) {
3448 Results.allowNestedNameSpecifiers();
3449 Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy);
3450 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3451 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
3452 CodeCompleter->includeGlobals());
3453 Results.setFilter(nullptr);
3456 Results.ExitScope();
3458 // If we're in a context where we might have an expression (rather than a
3459 // declaration), and what we've seen so far is an Objective-C type that could
3460 // be a receiver of a class message, this may be a class message send with
3461 // the initial opening bracket '[' missing. Add appropriate completions.
3462 if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
3463 DS.getParsedSpecifiers() == DeclSpec::PQ_TypeSpecifier &&
3464 DS.getTypeSpecType() == DeclSpec::TST_typename &&
3465 DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified &&
3466 DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
3467 !DS.isTypeAltiVecVector() &&
3469 (S->getFlags() & Scope::DeclScope) != 0 &&
3470 (S->getFlags() & (Scope::ClassScope | Scope::TemplateParamScope |
3471 Scope::FunctionPrototypeScope |
3472 Scope::AtCatchScope)) == 0) {
3473 ParsedType T = DS.getRepAsType();
3474 if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType())
3475 AddClassMessageCompletions(*this, S, T, None, false, false, Results);
3478 // Note that we intentionally suppress macro results here, since we do not
3479 // encourage using macros to produce the names of entities.
3481 HandleCodeCompleteResults(this, CodeCompleter,
3482 Results.getCompletionContext(),
3483 Results.data(), Results.size());
3486 struct Sema::CodeCompleteExpressionData {
3487 CodeCompleteExpressionData(QualType PreferredType = QualType())
3488 : PreferredType(PreferredType), IntegralConstantExpression(false),
3489 ObjCCollection(false) { }
3491 QualType PreferredType;
3492 bool IntegralConstantExpression;
3493 bool ObjCCollection;
3494 SmallVector<Decl *, 4> IgnoreDecls;
3497 /// \brief Perform code-completion in an expression context when we know what
3498 /// type we're looking for.
3499 void Sema::CodeCompleteExpression(Scope *S,
3500 const CodeCompleteExpressionData &Data) {
3501 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3502 CodeCompleter->getCodeCompletionTUInfo(),
3503 CodeCompletionContext::CCC_Expression);
3504 if (Data.ObjCCollection)
3505 Results.setFilter(&ResultBuilder::IsObjCCollection);
3506 else if (Data.IntegralConstantExpression)
3507 Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
3508 else if (WantTypesInContext(PCC_Expression, getLangOpts()))
3509 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3511 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3513 if (!Data.PreferredType.isNull())
3514 Results.setPreferredType(Data.PreferredType.getNonReferenceType());
3516 // Ignore any declarations that we were told that we don't care about.
3517 for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I)
3518 Results.Ignore(Data.IgnoreDecls[I]);
3520 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3521 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3522 CodeCompleter->includeGlobals());
3524 Results.EnterNewScope();
3525 AddOrdinaryNameResults(PCC_Expression, S, *this, Results);
3526 Results.ExitScope();
3528 bool PreferredTypeIsPointer = false;
3529 if (!Data.PreferredType.isNull())
3530 PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType()
3531 || Data.PreferredType->isMemberPointerType()
3532 || Data.PreferredType->isBlockPointerType();
3534 if (S->getFnParent() &&
3535 !Data.ObjCCollection &&
3536 !Data.IntegralConstantExpression)
3537 AddPrettyFunctionResults(getLangOpts(), Results);
3539 if (CodeCompleter->includeMacros())
3540 AddMacroResults(PP, Results, false, PreferredTypeIsPointer);
3541 HandleCodeCompleteResults(this, CodeCompleter,
3542 CodeCompletionContext(CodeCompletionContext::CCC_Expression,
3543 Data.PreferredType),
3544 Results.data(),Results.size());
3547 void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E) {
3549 CodeCompleteOrdinaryName(S, PCC_RecoveryInFunction);
3550 else if (getLangOpts().ObjC1)
3551 CodeCompleteObjCInstanceMessage(S, E.get(), None, false);
3554 /// \brief The set of properties that have already been added, referenced by
3556 typedef llvm::SmallPtrSet<IdentifierInfo*, 16> AddedPropertiesSet;
3558 /// \brief Retrieve the container definition, if any?
3559 static ObjCContainerDecl *getContainerDef(ObjCContainerDecl *Container) {
3560 if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
3561 if (Interface->hasDefinition())
3562 return Interface->getDefinition();
3567 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3568 if (Protocol->hasDefinition())
3569 return Protocol->getDefinition();
3576 static void AddObjCProperties(const CodeCompletionContext &CCContext,
3577 ObjCContainerDecl *Container,
3578 bool AllowCategories,
3579 bool AllowNullaryMethods,
3580 DeclContext *CurContext,
3581 AddedPropertiesSet &AddedProperties,
3582 ResultBuilder &Results) {
3583 typedef CodeCompletionResult Result;
3585 // Retrieve the definition.
3586 Container = getContainerDef(Container);
3588 // Add properties in this container.
3589 for (const auto *P : Container->instance_properties())
3590 if (AddedProperties.insert(P->getIdentifier()).second)
3591 Results.MaybeAddResult(Result(P, Results.getBasePriority(P), nullptr),
3594 // Add nullary methods
3595 if (AllowNullaryMethods) {
3596 ASTContext &Context = Container->getASTContext();
3597 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
3598 for (auto *M : Container->methods()) {
3599 if (M->getSelector().isUnarySelector())
3600 if (IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0))
3601 if (AddedProperties.insert(Name).second) {
3602 CodeCompletionBuilder Builder(Results.getAllocator(),
3603 Results.getCodeCompletionTUInfo());
3604 AddResultTypeChunk(Context, Policy, M, CCContext.getBaseType(),
3606 Builder.AddTypedTextChunk(
3607 Results.getAllocator().CopyString(Name->getName()));
3609 Results.MaybeAddResult(Result(Builder.TakeString(), M,
3610 CCP_MemberDeclaration + CCD_MethodAsProperty),
3617 // Add properties in referenced protocols.
3618 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3619 for (auto *P : Protocol->protocols())
3620 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
3621 CurContext, AddedProperties, Results);
3622 } else if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)){
3623 if (AllowCategories) {
3624 // Look through categories.
3625 for (auto *Cat : IFace->known_categories())
3626 AddObjCProperties(CCContext, Cat, AllowCategories, AllowNullaryMethods,
3627 CurContext, AddedProperties, Results);
3630 // Look through protocols.
3631 for (auto *I : IFace->all_referenced_protocols())
3632 AddObjCProperties(CCContext, I, AllowCategories, AllowNullaryMethods,
3633 CurContext, AddedProperties, Results);
3635 // Look in the superclass.
3636 if (IFace->getSuperClass())
3637 AddObjCProperties(CCContext, IFace->getSuperClass(), AllowCategories,
3638 AllowNullaryMethods, CurContext,
3639 AddedProperties, Results);
3640 } else if (const ObjCCategoryDecl *Category
3641 = dyn_cast<ObjCCategoryDecl>(Container)) {
3642 // Look through protocols.
3643 for (auto *P : Category->protocols())
3644 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
3645 CurContext, AddedProperties, Results);
3649 void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
3650 SourceLocation OpLoc,
3652 if (!Base || !CodeCompleter)
3655 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
3656 if (ConvertedBase.isInvalid())
3658 Base = ConvertedBase.get();
3660 typedef CodeCompletionResult Result;
3662 QualType BaseType = Base->getType();
3665 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
3666 BaseType = Ptr->getPointeeType();
3667 else if (BaseType->isObjCObjectPointerType())
3673 enum CodeCompletionContext::Kind contextKind;
3676 contextKind = CodeCompletionContext::CCC_ArrowMemberAccess;
3679 if (BaseType->isObjCObjectPointerType() ||
3680 BaseType->isObjCObjectOrInterfaceType()) {
3681 contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess;
3684 contextKind = CodeCompletionContext::CCC_DotMemberAccess;
3688 CodeCompletionContext CCContext(contextKind, BaseType);
3689 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3690 CodeCompleter->getCodeCompletionTUInfo(),
3692 &ResultBuilder::IsMember);
3693 Results.EnterNewScope();
3694 if (const RecordType *Record = BaseType->getAs<RecordType>()) {
3695 // Indicate that we are performing a member access, and the cv-qualifiers
3696 // for the base object type.
3697 Results.setObjectTypeQualifiers(BaseType.getQualifiers());
3699 // Access to a C/C++ class, struct, or union.
3700 Results.allowNestedNameSpecifiers();
3701 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3702 LookupVisibleDecls(Record->getDecl(), LookupMemberName, Consumer,
3703 CodeCompleter->includeGlobals());
3705 if (getLangOpts().CPlusPlus) {
3706 if (!Results.empty()) {
3707 // The "template" keyword can follow "->" or "." in the grammar.
3708 // However, we only want to suggest the template keyword if something
3710 bool IsDependent = BaseType->isDependentType();
3712 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent())
3713 if (DeclContext *Ctx = DepScope->getEntity()) {
3714 IsDependent = Ctx->isDependentContext();
3720 Results.AddResult(Result("template"));
3723 } else if (!IsArrow && BaseType->getAsObjCInterfacePointerType()) {
3724 // Objective-C property reference.
3725 AddedPropertiesSet AddedProperties;
3727 // Add property results based on our interface.
3728 const ObjCObjectPointerType *ObjCPtr
3729 = BaseType->getAsObjCInterfacePointerType();
3730 assert(ObjCPtr && "Non-NULL pointer guaranteed above!");
3731 AddObjCProperties(CCContext, ObjCPtr->getInterfaceDecl(), true,
3732 /*AllowNullaryMethods=*/true, CurContext,
3733 AddedProperties, Results);
3735 // Add properties from the protocols in a qualified interface.
3736 for (auto *I : ObjCPtr->quals())
3737 AddObjCProperties(CCContext, I, true, /*AllowNullaryMethods=*/true,
3738 CurContext, AddedProperties, Results);
3739 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) ||
3740 (!IsArrow && BaseType->isObjCObjectType())) {
3741 // Objective-C instance variable access.
3742 ObjCInterfaceDecl *Class = nullptr;
3743 if (const ObjCObjectPointerType *ObjCPtr
3744 = BaseType->getAs<ObjCObjectPointerType>())
3745 Class = ObjCPtr->getInterfaceDecl();
3747 Class = BaseType->getAs<ObjCObjectType>()->getInterface();
3749 // Add all ivars from this class and its superclasses.
3751 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3752 Results.setFilter(&ResultBuilder::IsObjCIvar);
3753 LookupVisibleDecls(Class, LookupMemberName, Consumer,
3754 CodeCompleter->includeGlobals());
3758 // FIXME: How do we cope with isa?
3760 Results.ExitScope();
3762 // Hand off the results found for code completion.
3763 HandleCodeCompleteResults(this, CodeCompleter,
3764 Results.getCompletionContext(),
3765 Results.data(),Results.size());
3768 void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) {
3772 ResultBuilder::LookupFilter Filter = nullptr;
3773 enum CodeCompletionContext::Kind ContextKind
3774 = CodeCompletionContext::CCC_Other;
3775 switch ((DeclSpec::TST)TagSpec) {
3776 case DeclSpec::TST_enum:
3777 Filter = &ResultBuilder::IsEnum;
3778 ContextKind = CodeCompletionContext::CCC_EnumTag;
3781 case DeclSpec::TST_union:
3782 Filter = &ResultBuilder::IsUnion;
3783 ContextKind = CodeCompletionContext::CCC_UnionTag;
3786 case DeclSpec::TST_struct:
3787 case DeclSpec::TST_class:
3788 case DeclSpec::TST_interface:
3789 Filter = &ResultBuilder::IsClassOrStruct;
3790 ContextKind = CodeCompletionContext::CCC_ClassOrStructTag;
3794 llvm_unreachable("Unknown type specifier kind in CodeCompleteTag");
3797 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3798 CodeCompleter->getCodeCompletionTUInfo(), ContextKind);
3799 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3801 // First pass: look for tags.
3802 Results.setFilter(Filter);
3803 LookupVisibleDecls(S, LookupTagName, Consumer,
3804 CodeCompleter->includeGlobals());
3806 if (CodeCompleter->includeGlobals()) {
3807 // Second pass: look for nested name specifiers.
3808 Results.setFilter(&ResultBuilder::IsNestedNameSpecifier);
3809 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer);
3812 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3813 Results.data(),Results.size());
3816 void Sema::CodeCompleteTypeQualifiers(DeclSpec &DS) {
3817 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3818 CodeCompleter->getCodeCompletionTUInfo(),
3819 CodeCompletionContext::CCC_TypeQualifiers);
3820 Results.EnterNewScope();
3821 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
3822 Results.AddResult("const");
3823 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile))
3824 Results.AddResult("volatile");
3825 if (getLangOpts().C99 &&
3826 !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict))
3827 Results.AddResult("restrict");
3828 if (getLangOpts().C11 &&
3829 !(DS.getTypeQualifiers() & DeclSpec::TQ_atomic))
3830 Results.AddResult("_Atomic");
3831 if (getLangOpts().MSVCCompat &&
3832 !(DS.getTypeQualifiers() & DeclSpec::TQ_unaligned))
3833 Results.AddResult("__unaligned");
3834 Results.ExitScope();
3835 HandleCodeCompleteResults(this, CodeCompleter,
3836 Results.getCompletionContext(),
3837 Results.data(), Results.size());
3840 void Sema::CodeCompleteBracketDeclarator(Scope *S) {
3841 CodeCompleteExpression(S, QualType(getASTContext().getSizeType()));
3844 void Sema::CodeCompleteCase(Scope *S) {
3845 if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
3848 SwitchStmt *Switch = getCurFunction()->SwitchStack.back();
3849 QualType type = Switch->getCond()->IgnoreImplicit()->getType();
3850 if (!type->isEnumeralType()) {
3851 CodeCompleteExpressionData Data(type);
3852 Data.IntegralConstantExpression = true;
3853 CodeCompleteExpression(S, Data);
3857 // Code-complete the cases of a switch statement over an enumeration type
3858 // by providing the list of
3859 EnumDecl *Enum = type->castAs<EnumType>()->getDecl();
3860 if (EnumDecl *Def = Enum->getDefinition())
3863 // Determine which enumerators we have already seen in the switch statement.
3864 // FIXME: Ideally, we would also be able to look *past* the code-completion
3865 // token, in case we are code-completing in the middle of the switch and not
3866 // at the end. However, we aren't able to do so at the moment.
3867 llvm::SmallPtrSet<EnumConstantDecl *, 8> EnumeratorsSeen;
3868 NestedNameSpecifier *Qualifier = nullptr;
3869 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC;
3870 SC = SC->getNextSwitchCase()) {
3871 CaseStmt *Case = dyn_cast<CaseStmt>(SC);
3875 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
3876 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CaseVal))
3877 if (EnumConstantDecl *Enumerator
3878 = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
3879 // We look into the AST of the case statement to determine which
3880 // enumerator was named. Alternatively, we could compute the value of
3881 // the integral constant expression, then compare it against the
3882 // values of each enumerator. However, value-based approach would not
3883 // work as well with C++ templates where enumerators declared within a
3884 // template are type- and value-dependent.
3885 EnumeratorsSeen.insert(Enumerator);
3887 // If this is a qualified-id, keep track of the nested-name-specifier
3888 // so that we can reproduce it as part of code completion, e.g.,
3890 // switch (TagD.getKind()) {
3891 // case TagDecl::TK_enum:
3895 // At the XXX, our completions are TagDecl::TK_union,
3896 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union,
3897 // TK_struct, and TK_class.
3898 Qualifier = DRE->getQualifier();
3902 if (getLangOpts().CPlusPlus && !Qualifier && EnumeratorsSeen.empty()) {
3903 // If there are no prior enumerators in C++, check whether we have to
3904 // qualify the names of the enumerators that we suggest, because they
3905 // may not be visible in this scope.
3906 Qualifier = getRequiredQualification(Context, CurContext, Enum);
3909 // Add any enumerators that have not yet been mentioned.
3910 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3911 CodeCompleter->getCodeCompletionTUInfo(),
3912 CodeCompletionContext::CCC_Expression);
3913 Results.EnterNewScope();
3914 for (auto *E : Enum->enumerators()) {
3915 if (EnumeratorsSeen.count(E))
3918 CodeCompletionResult R(E, CCP_EnumInCase, Qualifier);
3919 Results.AddResult(R, CurContext, nullptr, false);
3921 Results.ExitScope();
3923 //We need to make sure we're setting the right context,
3924 //so only say we include macros if the code completer says we do
3925 enum CodeCompletionContext::Kind kind = CodeCompletionContext::CCC_Other;
3926 if (CodeCompleter->includeMacros()) {
3927 AddMacroResults(PP, Results, false);
3928 kind = CodeCompletionContext::CCC_OtherWithMacros;
3931 HandleCodeCompleteResults(this, CodeCompleter,
3933 Results.data(),Results.size());
3936 static bool anyNullArguments(ArrayRef<Expr *> Args) {
3937 if (Args.size() && !Args.data())
3940 for (unsigned I = 0; I != Args.size(); ++I)
3947 typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate;
3949 static void mergeCandidatesWithResults(Sema &SemaRef,
3950 SmallVectorImpl<ResultCandidate> &Results,
3951 OverloadCandidateSet &CandidateSet,
3952 SourceLocation Loc) {
3953 if (!CandidateSet.empty()) {
3954 // Sort the overload candidate set by placing the best overloads first.
3956 CandidateSet.begin(), CandidateSet.end(),
3957 [&](const OverloadCandidate &X, const OverloadCandidate &Y) {
3958 return isBetterOverloadCandidate(SemaRef, X, Y, Loc);
3961 // Add the remaining viable overload candidates as code-completion results.
3962 for (auto &Candidate : CandidateSet)
3963 if (Candidate.Viable)
3964 Results.push_back(ResultCandidate(Candidate.Function));
3968 /// \brief Get the type of the Nth parameter from a given set of overload
3970 static QualType getParamType(Sema &SemaRef,
3971 ArrayRef<ResultCandidate> Candidates,
3974 // Given the overloads 'Candidates' for a function call matching all arguments
3975 // up to N, return the type of the Nth parameter if it is the same for all
3976 // overload candidates.
3978 for (auto &Candidate : Candidates) {
3979 if (auto FType = Candidate.getFunctionType())
3980 if (auto Proto = dyn_cast<FunctionProtoType>(FType))
3981 if (N < Proto->getNumParams()) {
3982 if (ParamType.isNull())
3983 ParamType = Proto->getParamType(N);
3984 else if (!SemaRef.Context.hasSameUnqualifiedType(
3985 ParamType.getNonReferenceType(),
3986 Proto->getParamType(N).getNonReferenceType()))
3987 // Otherwise return a default-constructed QualType.
3995 static void CodeCompleteOverloadResults(Sema &SemaRef, Scope *S,
3996 MutableArrayRef<ResultCandidate> Candidates,
3997 unsigned CurrentArg,
3998 bool CompleteExpressionWithCurrentArg = true) {
4000 if (CompleteExpressionWithCurrentArg)
4001 ParamType = getParamType(SemaRef, Candidates, CurrentArg);
4003 if (ParamType.isNull())
4004 SemaRef.CodeCompleteOrdinaryName(S, Sema::PCC_Expression);
4006 SemaRef.CodeCompleteExpression(S, ParamType);
4008 if (!Candidates.empty())
4009 SemaRef.CodeCompleter->ProcessOverloadCandidates(SemaRef, CurrentArg,
4014 void Sema::CodeCompleteCall(Scope *S, Expr *Fn, ArrayRef<Expr *> Args) {
4018 // When we're code-completing for a call, we fall back to ordinary
4019 // name code-completion whenever we can't produce specific
4020 // results. We may want to revisit this strategy in the future,
4021 // e.g., by merging the two kinds of results.
4023 // FIXME: Provide support for variadic template functions.
4025 // Ignore type-dependent call expressions entirely.
4026 if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args) ||
4027 Expr::hasAnyTypeDependentArguments(Args)) {
4028 CodeCompleteOrdinaryName(S, PCC_Expression);
4032 // Build an overload candidate set based on the functions we find.
4033 SourceLocation Loc = Fn->getExprLoc();
4034 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
4036 SmallVector<ResultCandidate, 8> Results;
4038 Expr *NakedFn = Fn->IgnoreParenCasts();
4039 if (auto ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn))
4040 AddOverloadedCallCandidates(ULE, Args, CandidateSet,
4041 /*PartialOverloading=*/true);
4042 else if (auto UME = dyn_cast<UnresolvedMemberExpr>(NakedFn)) {
4043 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
4044 if (UME->hasExplicitTemplateArgs()) {
4045 UME->copyTemplateArgumentsInto(TemplateArgsBuffer);
4046 TemplateArgs = &TemplateArgsBuffer;
4048 SmallVector<Expr *, 12> ArgExprs(1, UME->getBase());
4049 ArgExprs.append(Args.begin(), Args.end());
4050 UnresolvedSet<8> Decls;
4051 Decls.append(UME->decls_begin(), UME->decls_end());
4052 AddFunctionCandidates(Decls, ArgExprs, CandidateSet, TemplateArgs,
4053 /*SuppressUsedConversions=*/false,
4054 /*PartialOverloading=*/true);
4056 FunctionDecl *FD = nullptr;
4057 if (auto MCE = dyn_cast<MemberExpr>(NakedFn))
4058 FD = dyn_cast<FunctionDecl>(MCE->getMemberDecl());
4059 else if (auto DRE = dyn_cast<DeclRefExpr>(NakedFn))
4060 FD = dyn_cast<FunctionDecl>(DRE->getDecl());
4061 if (FD) { // We check whether it's a resolved function declaration.
4062 if (!getLangOpts().CPlusPlus ||
4063 !FD->getType()->getAs<FunctionProtoType>())
4064 Results.push_back(ResultCandidate(FD));
4066 AddOverloadCandidate(FD, DeclAccessPair::make(FD, FD->getAccess()),
4068 /*SuppressUsedConversions=*/false,
4069 /*PartialOverloading=*/true);
4071 } else if (auto DC = NakedFn->getType()->getAsCXXRecordDecl()) {
4072 // If expression's type is CXXRecordDecl, it may overload the function
4073 // call operator, so we check if it does and add them as candidates.
4074 // A complete type is needed to lookup for member function call operators.
4075 if (isCompleteType(Loc, NakedFn->getType())) {
4076 DeclarationName OpName = Context.DeclarationNames
4077 .getCXXOperatorName(OO_Call);
4078 LookupResult R(*this, OpName, Loc, LookupOrdinaryName);
4079 LookupQualifiedName(R, DC);
4080 R.suppressDiagnostics();
4081 SmallVector<Expr *, 12> ArgExprs(1, NakedFn);
4082 ArgExprs.append(Args.begin(), Args.end());
4083 AddFunctionCandidates(R.asUnresolvedSet(), ArgExprs, CandidateSet,
4084 /*ExplicitArgs=*/nullptr,
4085 /*SuppressUsedConversions=*/false,
4086 /*PartialOverloading=*/true);
4089 // Lastly we check whether expression's type is function pointer or
4091 QualType T = NakedFn->getType();
4092 if (!T->getPointeeType().isNull())
4093 T = T->getPointeeType();
4095 if (auto FP = T->getAs<FunctionProtoType>()) {
4096 if (!TooManyArguments(FP->getNumParams(), Args.size(),
4097 /*PartialOverloading=*/true) ||
4099 Results.push_back(ResultCandidate(FP));
4100 } else if (auto FT = T->getAs<FunctionType>())
4101 // No prototype and declaration, it may be a K & R style function.
4102 Results.push_back(ResultCandidate(FT));
4106 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4107 CodeCompleteOverloadResults(*this, S, Results, Args.size(),
4108 !CandidateSet.empty());
4111 void Sema::CodeCompleteConstructor(Scope *S, QualType Type, SourceLocation Loc,
4112 ArrayRef<Expr *> Args) {
4116 // A complete type is needed to lookup for constructors.
4117 if (!isCompleteType(Loc, Type))
4120 CXXRecordDecl *RD = Type->getAsCXXRecordDecl();
4122 CodeCompleteExpression(S, Type);
4126 // FIXME: Provide support for member initializers.
4127 // FIXME: Provide support for variadic template constructors.
4129 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
4131 for (auto C : LookupConstructors(RD)) {
4132 if (auto FD = dyn_cast<FunctionDecl>(C)) {
4133 AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()),
4135 /*SuppressUsedConversions=*/false,
4136 /*PartialOverloading=*/true);
4137 } else if (auto FTD = dyn_cast<FunctionTemplateDecl>(C)) {
4138 AddTemplateOverloadCandidate(FTD,
4139 DeclAccessPair::make(FTD, C->getAccess()),
4140 /*ExplicitTemplateArgs=*/nullptr,
4142 /*SuppressUsedConversions=*/false,
4143 /*PartialOverloading=*/true);
4147 SmallVector<ResultCandidate, 8> Results;
4148 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4149 CodeCompleteOverloadResults(*this, S, Results, Args.size());
4152 void Sema::CodeCompleteInitializer(Scope *S, Decl *D) {
4153 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D);
4155 CodeCompleteOrdinaryName(S, PCC_Expression);
4159 CodeCompleteExpression(S, VD->getType());
4162 void Sema::CodeCompleteReturn(Scope *S) {
4163 QualType ResultType;
4164 if (isa<BlockDecl>(CurContext)) {
4165 if (BlockScopeInfo *BSI = getCurBlock())
4166 ResultType = BSI->ReturnType;
4167 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(CurContext))
4168 ResultType = Function->getReturnType();
4169 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(CurContext))
4170 ResultType = Method->getReturnType();
4172 if (ResultType.isNull())
4173 CodeCompleteOrdinaryName(S, PCC_Expression);
4175 CodeCompleteExpression(S, ResultType);
4178 void Sema::CodeCompleteAfterIf(Scope *S) {
4179 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4180 CodeCompleter->getCodeCompletionTUInfo(),
4181 mapCodeCompletionContext(*this, PCC_Statement));
4182 Results.setFilter(&ResultBuilder::IsOrdinaryName);
4183 Results.EnterNewScope();
4185 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4186 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4187 CodeCompleter->includeGlobals());
4189 AddOrdinaryNameResults(PCC_Statement, S, *this, Results);
4192 CodeCompletionBuilder Builder(Results.getAllocator(),
4193 Results.getCodeCompletionTUInfo());
4194 Builder.AddTypedTextChunk("else");
4195 if (Results.includeCodePatterns()) {
4196 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4197 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4198 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4199 Builder.AddPlaceholderChunk("statements");
4200 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4201 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4203 Results.AddResult(Builder.TakeString());
4206 Builder.AddTypedTextChunk("else");
4207 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4208 Builder.AddTextChunk("if");
4209 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4210 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4211 if (getLangOpts().CPlusPlus)
4212 Builder.AddPlaceholderChunk("condition");
4214 Builder.AddPlaceholderChunk("expression");
4215 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4216 if (Results.includeCodePatterns()) {
4217 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4218 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4219 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4220 Builder.AddPlaceholderChunk("statements");
4221 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4222 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4224 Results.AddResult(Builder.TakeString());
4226 Results.ExitScope();
4228 if (S->getFnParent())
4229 AddPrettyFunctionResults(getLangOpts(), Results);
4231 if (CodeCompleter->includeMacros())
4232 AddMacroResults(PP, Results, false);
4234 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4235 Results.data(),Results.size());
4238 void Sema::CodeCompleteAssignmentRHS(Scope *S, Expr *LHS) {
4240 CodeCompleteExpression(S, static_cast<Expr *>(LHS)->getType());
4242 CodeCompleteOrdinaryName(S, PCC_Expression);
4245 void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
4246 bool EnteringContext) {
4247 if (!SS.getScopeRep() || !CodeCompleter)
4250 DeclContext *Ctx = computeDeclContext(SS, EnteringContext);
4254 // Try to instantiate any non-dependent declaration contexts before
4256 if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx))
4259 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4260 CodeCompleter->getCodeCompletionTUInfo(),
4261 CodeCompletionContext::CCC_Name);
4262 Results.EnterNewScope();
4264 // The "template" keyword can follow "::" in the grammar, but only
4265 // put it into the grammar if the nested-name-specifier is dependent.
4266 NestedNameSpecifier *NNS = SS.getScopeRep();
4267 if (!Results.empty() && NNS->isDependent())
4268 Results.AddResult("template");
4270 // Add calls to overridden virtual functions, if there are any.
4272 // FIXME: This isn't wonderful, because we don't know whether we're actually
4273 // in a context that permits expressions. This is a general issue with
4274 // qualified-id completions.
4275 if (!EnteringContext)
4276 MaybeAddOverrideCalls(*this, Ctx, Results);
4277 Results.ExitScope();
4279 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4280 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer);
4282 HandleCodeCompleteResults(this, CodeCompleter,
4283 Results.getCompletionContext(),
4284 Results.data(),Results.size());
4287 void Sema::CodeCompleteUsing(Scope *S) {
4291 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4292 CodeCompleter->getCodeCompletionTUInfo(),
4293 CodeCompletionContext::CCC_PotentiallyQualifiedName,
4294 &ResultBuilder::IsNestedNameSpecifier);
4295 Results.EnterNewScope();
4297 // If we aren't in class scope, we could see the "namespace" keyword.
4298 if (!S->isClassScope())
4299 Results.AddResult(CodeCompletionResult("namespace"));
4301 // After "using", we can see anything that would start a
4302 // nested-name-specifier.
4303 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4304 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4305 CodeCompleter->includeGlobals());
4306 Results.ExitScope();
4308 HandleCodeCompleteResults(this, CodeCompleter,
4309 CodeCompletionContext::CCC_PotentiallyQualifiedName,
4310 Results.data(),Results.size());
4313 void Sema::CodeCompleteUsingDirective(Scope *S) {
4317 // After "using namespace", we expect to see a namespace name or namespace
4319 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4320 CodeCompleter->getCodeCompletionTUInfo(),
4321 CodeCompletionContext::CCC_Namespace,
4322 &ResultBuilder::IsNamespaceOrAlias);
4323 Results.EnterNewScope();
4324 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4325 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4326 CodeCompleter->includeGlobals());
4327 Results.ExitScope();
4328 HandleCodeCompleteResults(this, CodeCompleter,
4329 CodeCompletionContext::CCC_Namespace,
4330 Results.data(),Results.size());
4333 void Sema::CodeCompleteNamespaceDecl(Scope *S) {
4337 DeclContext *Ctx = S->getEntity();
4338 if (!S->getParent())
4339 Ctx = Context.getTranslationUnitDecl();
4341 bool SuppressedGlobalResults
4342 = Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx);
4344 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4345 CodeCompleter->getCodeCompletionTUInfo(),
4346 SuppressedGlobalResults
4347 ? CodeCompletionContext::CCC_Namespace
4348 : CodeCompletionContext::CCC_Other,
4349 &ResultBuilder::IsNamespace);
4351 if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) {
4352 // We only want to see those namespaces that have already been defined
4353 // within this scope, because its likely that the user is creating an
4354 // extended namespace declaration. Keep track of the most recent
4355 // definition of each namespace.
4356 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest;
4357 for (DeclContext::specific_decl_iterator<NamespaceDecl>
4358 NS(Ctx->decls_begin()), NSEnd(Ctx->decls_end());
4360 OrigToLatest[NS->getOriginalNamespace()] = *NS;
4362 // Add the most recent definition (or extended definition) of each
4363 // namespace to the list of results.
4364 Results.EnterNewScope();
4365 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator
4366 NS = OrigToLatest.begin(),
4367 NSEnd = OrigToLatest.end();
4369 Results.AddResult(CodeCompletionResult(
4370 NS->second, Results.getBasePriority(NS->second),
4372 CurContext, nullptr, false);
4373 Results.ExitScope();
4376 HandleCodeCompleteResults(this, CodeCompleter,
4377 Results.getCompletionContext(),
4378 Results.data(),Results.size());
4381 void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) {
4385 // After "namespace", we expect to see a namespace or alias.
4386 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4387 CodeCompleter->getCodeCompletionTUInfo(),
4388 CodeCompletionContext::CCC_Namespace,
4389 &ResultBuilder::IsNamespaceOrAlias);
4390 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4391 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4392 CodeCompleter->includeGlobals());
4393 HandleCodeCompleteResults(this, CodeCompleter,
4394 Results.getCompletionContext(),
4395 Results.data(),Results.size());
4398 void Sema::CodeCompleteOperatorName(Scope *S) {
4402 typedef CodeCompletionResult Result;
4403 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4404 CodeCompleter->getCodeCompletionTUInfo(),
4405 CodeCompletionContext::CCC_Type,
4406 &ResultBuilder::IsType);
4407 Results.EnterNewScope();
4409 // Add the names of overloadable operators.
4410 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4411 if (std::strcmp(Spelling, "?")) \
4412 Results.AddResult(Result(Spelling));
4413 #include "clang/Basic/OperatorKinds.def"
4415 // Add any type names visible from the current scope
4416 Results.allowNestedNameSpecifiers();
4417 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4418 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4419 CodeCompleter->includeGlobals());
4421 // Add any type specifiers
4422 AddTypeSpecifierResults(getLangOpts(), Results);
4423 Results.ExitScope();
4425 HandleCodeCompleteResults(this, CodeCompleter,
4426 CodeCompletionContext::CCC_Type,
4427 Results.data(),Results.size());
4430 void Sema::CodeCompleteConstructorInitializer(
4432 ArrayRef <CXXCtorInitializer *> Initializers) {
4436 AdjustDeclIfTemplate(ConstructorD);
4438 CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ConstructorD);
4442 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4443 CodeCompleter->getCodeCompletionTUInfo(),
4444 CodeCompletionContext::CCC_PotentiallyQualifiedName);
4445 Results.EnterNewScope();
4447 // Fill in any already-initialized fields or base classes.
4448 llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
4449 llvm::SmallPtrSet<CanQualType, 4> InitializedBases;
4450 for (unsigned I = 0, E = Initializers.size(); I != E; ++I) {
4451 if (Initializers[I]->isBaseInitializer())
4452 InitializedBases.insert(
4453 Context.getCanonicalType(QualType(Initializers[I]->getBaseClass(), 0)));
4455 InitializedFields.insert(cast<FieldDecl>(
4456 Initializers[I]->getAnyMember()));
4459 // Add completions for base classes.
4460 CodeCompletionBuilder Builder(Results.getAllocator(),
4461 Results.getCodeCompletionTUInfo());
4462 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
4463 bool SawLastInitializer = Initializers.empty();
4464 CXXRecordDecl *ClassDecl = Constructor->getParent();
4465 for (const auto &Base : ClassDecl->bases()) {
4466 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4469 = !Initializers.empty() &&
4470 Initializers.back()->isBaseInitializer() &&
4471 Context.hasSameUnqualifiedType(Base.getType(),
4472 QualType(Initializers.back()->getBaseClass(), 0));
4476 Builder.AddTypedTextChunk(
4477 Results.getAllocator().CopyString(
4478 Base.getType().getAsString(Policy)));
4479 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4480 Builder.AddPlaceholderChunk("args");
4481 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4482 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4483 SawLastInitializer? CCP_NextInitializer
4484 : CCP_MemberDeclaration));
4485 SawLastInitializer = false;
4488 // Add completions for virtual base classes.
4489 for (const auto &Base : ClassDecl->vbases()) {
4490 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4493 = !Initializers.empty() &&
4494 Initializers.back()->isBaseInitializer() &&
4495 Context.hasSameUnqualifiedType(Base.getType(),
4496 QualType(Initializers.back()->getBaseClass(), 0));
4500 Builder.AddTypedTextChunk(
4501 Builder.getAllocator().CopyString(
4502 Base.getType().getAsString(Policy)));
4503 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4504 Builder.AddPlaceholderChunk("args");
4505 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4506 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4507 SawLastInitializer? CCP_NextInitializer
4508 : CCP_MemberDeclaration));
4509 SawLastInitializer = false;
4512 // Add completions for members.
4513 for (auto *Field : ClassDecl->fields()) {
4514 if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))
4517 = !Initializers.empty() &&
4518 Initializers.back()->isAnyMemberInitializer() &&
4519 Initializers.back()->getAnyMember() == Field;
4523 if (!Field->getDeclName())
4526 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
4527 Field->getIdentifier()->getName()));
4528 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4529 Builder.AddPlaceholderChunk("args");
4530 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4531 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4532 SawLastInitializer? CCP_NextInitializer
4533 : CCP_MemberDeclaration,
4535 CXAvailability_Available,
4537 SawLastInitializer = false;
4539 Results.ExitScope();
4541 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4542 Results.data(), Results.size());
4545 /// \brief Determine whether this scope denotes a namespace.
4546 static bool isNamespaceScope(Scope *S) {
4547 DeclContext *DC = S->getEntity();
4551 return DC->isFileContext();
4554 void Sema::CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
4555 bool AfterAmpersand) {
4556 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4557 CodeCompleter->getCodeCompletionTUInfo(),
4558 CodeCompletionContext::CCC_Other);
4559 Results.EnterNewScope();
4561 // Note what has already been captured.
4562 llvm::SmallPtrSet<IdentifierInfo *, 4> Known;
4563 bool IncludedThis = false;
4564 for (const auto &C : Intro.Captures) {
4565 if (C.Kind == LCK_This) {
4566 IncludedThis = true;
4573 // Look for other capturable variables.
4574 for (; S && !isNamespaceScope(S); S = S->getParent()) {
4575 for (const auto *D : S->decls()) {
4576 const auto *Var = dyn_cast<VarDecl>(D);
4578 !Var->hasLocalStorage() ||
4579 Var->hasAttr<BlocksAttr>())
4582 if (Known.insert(Var->getIdentifier()).second)
4583 Results.AddResult(CodeCompletionResult(Var, CCP_LocalDeclaration),
4584 CurContext, nullptr, false);
4588 // Add 'this', if it would be valid.
4589 if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy)
4590 addThisCompletion(*this, Results);
4592 Results.ExitScope();
4594 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4595 Results.data(), Results.size());
4598 /// Macro that optionally prepends an "@" to the string literal passed in via
4599 /// Keyword, depending on whether NeedAt is true or false.
4600 #define OBJC_AT_KEYWORD_NAME(NeedAt,Keyword) ((NeedAt)? "@" Keyword : Keyword)
4602 static void AddObjCImplementationResults(const LangOptions &LangOpts,
4603 ResultBuilder &Results,
4605 typedef CodeCompletionResult Result;
4606 // Since we have an implementation, we can end it.
4607 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
4609 CodeCompletionBuilder Builder(Results.getAllocator(),
4610 Results.getCodeCompletionTUInfo());
4611 if (LangOpts.ObjC2) {
4613 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"dynamic"));
4614 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4615 Builder.AddPlaceholderChunk("property");
4616 Results.AddResult(Result(Builder.TakeString()));
4619 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synthesize"));
4620 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4621 Builder.AddPlaceholderChunk("property");
4622 Results.AddResult(Result(Builder.TakeString()));
4626 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
4627 ResultBuilder &Results,
4629 typedef CodeCompletionResult Result;
4631 // Since we have an interface or protocol, we can end it.
4632 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
4634 if (LangOpts.ObjC2) {
4636 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"property")));
4639 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"required")));
4642 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"optional")));
4646 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
4647 typedef CodeCompletionResult Result;
4648 CodeCompletionBuilder Builder(Results.getAllocator(),
4649 Results.getCodeCompletionTUInfo());
4652 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"class"));
4653 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4654 Builder.AddPlaceholderChunk("name");
4655 Results.AddResult(Result(Builder.TakeString()));
4657 if (Results.includeCodePatterns()) {
4659 // FIXME: Could introduce the whole pattern, including superclasses and
4661 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"interface"));
4662 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4663 Builder.AddPlaceholderChunk("class");
4664 Results.AddResult(Result(Builder.TakeString()));
4667 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
4668 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4669 Builder.AddPlaceholderChunk("protocol");
4670 Results.AddResult(Result(Builder.TakeString()));
4672 // @implementation name
4673 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"implementation"));
4674 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4675 Builder.AddPlaceholderChunk("class");
4676 Results.AddResult(Result(Builder.TakeString()));
4679 // @compatibility_alias name
4680 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"compatibility_alias"));
4681 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4682 Builder.AddPlaceholderChunk("alias");
4683 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4684 Builder.AddPlaceholderChunk("class");
4685 Results.AddResult(Result(Builder.TakeString()));
4687 if (Results.getSema().getLangOpts().Modules) {
4689 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import"));
4690 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4691 Builder.AddPlaceholderChunk("module");
4692 Results.AddResult(Result(Builder.TakeString()));
4696 void Sema::CodeCompleteObjCAtDirective(Scope *S) {
4697 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4698 CodeCompleter->getCodeCompletionTUInfo(),
4699 CodeCompletionContext::CCC_Other);
4700 Results.EnterNewScope();
4701 if (isa<ObjCImplDecl>(CurContext))
4702 AddObjCImplementationResults(getLangOpts(), Results, false);
4703 else if (CurContext->isObjCContainer())
4704 AddObjCInterfaceResults(getLangOpts(), Results, false);
4706 AddObjCTopLevelResults(Results, false);
4707 Results.ExitScope();
4708 HandleCodeCompleteResults(this, CodeCompleter,
4709 CodeCompletionContext::CCC_Other,
4710 Results.data(),Results.size());
4713 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) {
4714 typedef CodeCompletionResult Result;
4715 CodeCompletionBuilder Builder(Results.getAllocator(),
4716 Results.getCodeCompletionTUInfo());
4718 // @encode ( type-name )
4719 const char *EncodeType = "char[]";
4720 if (Results.getSema().getLangOpts().CPlusPlus ||
4721 Results.getSema().getLangOpts().ConstStrings)
4722 EncodeType = "const char[]";
4723 Builder.AddResultTypeChunk(EncodeType);
4724 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"encode"));
4725 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4726 Builder.AddPlaceholderChunk("type-name");
4727 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4728 Results.AddResult(Result(Builder.TakeString()));
4730 // @protocol ( protocol-name )
4731 Builder.AddResultTypeChunk("Protocol *");
4732 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
4733 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4734 Builder.AddPlaceholderChunk("protocol-name");
4735 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4736 Results.AddResult(Result(Builder.TakeString()));
4738 // @selector ( selector )
4739 Builder.AddResultTypeChunk("SEL");
4740 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"selector"));
4741 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4742 Builder.AddPlaceholderChunk("selector");
4743 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4744 Results.AddResult(Result(Builder.TakeString()));
4747 Builder.AddResultTypeChunk("NSString *");
4748 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"\""));
4749 Builder.AddPlaceholderChunk("string");
4750 Builder.AddTextChunk("\"");
4751 Results.AddResult(Result(Builder.TakeString()));
4754 Builder.AddResultTypeChunk("NSArray *");
4755 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"["));
4756 Builder.AddPlaceholderChunk("objects, ...");
4757 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
4758 Results.AddResult(Result(Builder.TakeString()));
4760 // @{key : object, ...}
4761 Builder.AddResultTypeChunk("NSDictionary *");
4762 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"{"));
4763 Builder.AddPlaceholderChunk("key");
4764 Builder.AddChunk(CodeCompletionString::CK_Colon);
4765 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4766 Builder.AddPlaceholderChunk("object, ...");
4767 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4768 Results.AddResult(Result(Builder.TakeString()));
4771 Builder.AddResultTypeChunk("id");
4772 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "("));
4773 Builder.AddPlaceholderChunk("expression");
4774 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4775 Results.AddResult(Result(Builder.TakeString()));
4778 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) {
4779 typedef CodeCompletionResult Result;
4780 CodeCompletionBuilder Builder(Results.getAllocator(),
4781 Results.getCodeCompletionTUInfo());
4783 if (Results.includeCodePatterns()) {
4784 // @try { statements } @catch ( declaration ) { statements } @finally
4786 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"try"));
4787 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4788 Builder.AddPlaceholderChunk("statements");
4789 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4790 Builder.AddTextChunk("@catch");
4791 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4792 Builder.AddPlaceholderChunk("parameter");
4793 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4794 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4795 Builder.AddPlaceholderChunk("statements");
4796 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4797 Builder.AddTextChunk("@finally");
4798 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4799 Builder.AddPlaceholderChunk("statements");
4800 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4801 Results.AddResult(Result(Builder.TakeString()));
4805 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"throw"));
4806 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4807 Builder.AddPlaceholderChunk("expression");
4808 Results.AddResult(Result(Builder.TakeString()));
4810 if (Results.includeCodePatterns()) {
4811 // @synchronized ( expression ) { statements }
4812 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synchronized"));
4813 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4814 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4815 Builder.AddPlaceholderChunk("expression");
4816 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4817 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4818 Builder.AddPlaceholderChunk("statements");
4819 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4820 Results.AddResult(Result(Builder.TakeString()));
4824 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
4825 ResultBuilder &Results,
4827 typedef CodeCompletionResult Result;
4828 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"private")));
4829 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"protected")));
4830 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"public")));
4832 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"package")));
4835 void Sema::CodeCompleteObjCAtVisibility(Scope *S) {
4836 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4837 CodeCompleter->getCodeCompletionTUInfo(),
4838 CodeCompletionContext::CCC_Other);
4839 Results.EnterNewScope();
4840 AddObjCVisibilityResults(getLangOpts(), Results, false);
4841 Results.ExitScope();
4842 HandleCodeCompleteResults(this, CodeCompleter,
4843 CodeCompletionContext::CCC_Other,
4844 Results.data(),Results.size());
4847 void Sema::CodeCompleteObjCAtStatement(Scope *S) {
4848 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4849 CodeCompleter->getCodeCompletionTUInfo(),
4850 CodeCompletionContext::CCC_Other);
4851 Results.EnterNewScope();
4852 AddObjCStatementResults(Results, false);
4853 AddObjCExpressionResults(Results, false);
4854 Results.ExitScope();
4855 HandleCodeCompleteResults(this, CodeCompleter,
4856 CodeCompletionContext::CCC_Other,
4857 Results.data(),Results.size());
4860 void Sema::CodeCompleteObjCAtExpression(Scope *S) {
4861 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4862 CodeCompleter->getCodeCompletionTUInfo(),
4863 CodeCompletionContext::CCC_Other);
4864 Results.EnterNewScope();
4865 AddObjCExpressionResults(Results, false);
4866 Results.ExitScope();
4867 HandleCodeCompleteResults(this, CodeCompleter,
4868 CodeCompletionContext::CCC_Other,
4869 Results.data(),Results.size());
4872 /// \brief Determine whether the addition of the given flag to an Objective-C
4873 /// property's attributes will cause a conflict.
4874 static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) {
4875 // Check if we've already added this flag.
4876 if (Attributes & NewFlag)
4879 Attributes |= NewFlag;
4881 // Check for collisions with "readonly".
4882 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
4883 (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
4886 // Check for more than one of { assign, copy, retain, strong, weak }.
4887 unsigned AssignCopyRetMask = Attributes & (ObjCDeclSpec::DQ_PR_assign |
4888 ObjCDeclSpec::DQ_PR_unsafe_unretained |
4889 ObjCDeclSpec::DQ_PR_copy |
4890 ObjCDeclSpec::DQ_PR_retain |
4891 ObjCDeclSpec::DQ_PR_strong |
4892 ObjCDeclSpec::DQ_PR_weak);
4893 if (AssignCopyRetMask &&
4894 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign &&
4895 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_unsafe_unretained &&
4896 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy &&
4897 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain &&
4898 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_strong &&
4899 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_weak)
4905 void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) {
4909 unsigned Attributes = ODS.getPropertyAttributes();
4911 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4912 CodeCompleter->getCodeCompletionTUInfo(),
4913 CodeCompletionContext::CCC_Other);
4914 Results.EnterNewScope();
4915 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readonly))
4916 Results.AddResult(CodeCompletionResult("readonly"));
4917 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_assign))
4918 Results.AddResult(CodeCompletionResult("assign"));
4919 if (!ObjCPropertyFlagConflicts(Attributes,
4920 ObjCDeclSpec::DQ_PR_unsafe_unretained))
4921 Results.AddResult(CodeCompletionResult("unsafe_unretained"));
4922 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readwrite))
4923 Results.AddResult(CodeCompletionResult("readwrite"));
4924 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_retain))
4925 Results.AddResult(CodeCompletionResult("retain"));
4926 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_strong))
4927 Results.AddResult(CodeCompletionResult("strong"));
4928 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_copy))
4929 Results.AddResult(CodeCompletionResult("copy"));
4930 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nonatomic))
4931 Results.AddResult(CodeCompletionResult("nonatomic"));
4932 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_atomic))
4933 Results.AddResult(CodeCompletionResult("atomic"));
4935 // Only suggest "weak" if we're compiling for ARC-with-weak-references or GC.
4936 if (getLangOpts().ObjCWeak || getLangOpts().getGC() != LangOptions::NonGC)
4937 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_weak))
4938 Results.AddResult(CodeCompletionResult("weak"));
4940 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_setter)) {
4941 CodeCompletionBuilder Setter(Results.getAllocator(),
4942 Results.getCodeCompletionTUInfo());
4943 Setter.AddTypedTextChunk("setter");
4944 Setter.AddTextChunk("=");
4945 Setter.AddPlaceholderChunk("method");
4946 Results.AddResult(CodeCompletionResult(Setter.TakeString()));
4948 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_getter)) {
4949 CodeCompletionBuilder Getter(Results.getAllocator(),
4950 Results.getCodeCompletionTUInfo());
4951 Getter.AddTypedTextChunk("getter");
4952 Getter.AddTextChunk("=");
4953 Getter.AddPlaceholderChunk("method");
4954 Results.AddResult(CodeCompletionResult(Getter.TakeString()));
4956 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nullability)) {
4957 Results.AddResult(CodeCompletionResult("nonnull"));
4958 Results.AddResult(CodeCompletionResult("nullable"));
4959 Results.AddResult(CodeCompletionResult("null_unspecified"));
4960 Results.AddResult(CodeCompletionResult("null_resettable"));
4962 Results.ExitScope();
4963 HandleCodeCompleteResults(this, CodeCompleter,
4964 CodeCompletionContext::CCC_Other,
4965 Results.data(),Results.size());
4968 /// \brief Describes the kind of Objective-C method that we want to find
4969 /// via code completion.
4970 enum ObjCMethodKind {
4971 MK_Any, ///< Any kind of method, provided it means other specified criteria.
4972 MK_ZeroArgSelector, ///< Zero-argument (unary) selector.
4973 MK_OneArgSelector ///< One-argument selector.
4976 static bool isAcceptableObjCSelector(Selector Sel,
4977 ObjCMethodKind WantKind,
4978 ArrayRef<IdentifierInfo *> SelIdents,
4979 bool AllowSameLength = true) {
4980 unsigned NumSelIdents = SelIdents.size();
4981 if (NumSelIdents > Sel.getNumArgs())
4986 case MK_ZeroArgSelector: return Sel.isUnarySelector();
4987 case MK_OneArgSelector: return Sel.getNumArgs() == 1;
4990 if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs())
4993 for (unsigned I = 0; I != NumSelIdents; ++I)
4994 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I))
5000 static bool isAcceptableObjCMethod(ObjCMethodDecl *Method,
5001 ObjCMethodKind WantKind,
5002 ArrayRef<IdentifierInfo *> SelIdents,
5003 bool AllowSameLength = true) {
5004 return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents,
5009 /// \brief A set of selectors, which is used to avoid introducing multiple
5010 /// completions with the same selector into the result set.
5011 typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet;
5014 /// \brief Add all of the Objective-C methods in the given Objective-C
5015 /// container to the set of results.
5017 /// The container will be a class, protocol, category, or implementation of
5018 /// any of the above. This mether will recurse to include methods from
5019 /// the superclasses of classes along with their categories, protocols, and
5020 /// implementations.
5022 /// \param Container the container in which we'll look to find methods.
5024 /// \param WantInstanceMethods Whether to add instance methods (only); if
5025 /// false, this routine will add factory methods (only).
5027 /// \param CurContext the context in which we're performing the lookup that
5030 /// \param AllowSameLength Whether we allow a method to be added to the list
5031 /// when it has the same number of parameters as we have selector identifiers.
5033 /// \param Results the structure into which we'll add results.
5034 static void AddObjCMethods(ObjCContainerDecl *Container,
5035 bool WantInstanceMethods,
5036 ObjCMethodKind WantKind,
5037 ArrayRef<IdentifierInfo *> SelIdents,
5038 DeclContext *CurContext,
5039 VisitedSelectorSet &Selectors,
5040 bool AllowSameLength,
5041 ResultBuilder &Results,
5042 bool InOriginalClass = true) {
5043 typedef CodeCompletionResult Result;
5044 Container = getContainerDef(Container);
5045 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
5046 bool isRootClass = IFace && !IFace->getSuperClass();
5047 for (auto *M : Container->methods()) {
5048 // The instance methods on the root class can be messaged via the
5050 if (M->isInstanceMethod() == WantInstanceMethods ||
5051 (isRootClass && !WantInstanceMethods)) {
5052 // Check whether the selector identifiers we've been given are a
5053 // subset of the identifiers for this particular method.
5054 if (!isAcceptableObjCMethod(M, WantKind, SelIdents, AllowSameLength))
5057 if (!Selectors.insert(M->getSelector()).second)
5060 Result R = Result(M, Results.getBasePriority(M), nullptr);
5061 R.StartParameter = SelIdents.size();
5062 R.AllParametersAreInformative = (WantKind != MK_Any);
5063 if (!InOriginalClass)
5064 R.Priority += CCD_InBaseClass;
5065 Results.MaybeAddResult(R, CurContext);
5069 // Visit the protocols of protocols.
5070 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
5071 if (Protocol->hasDefinition()) {
5072 const ObjCList<ObjCProtocolDecl> &Protocols
5073 = Protocol->getReferencedProtocols();
5074 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5075 E = Protocols.end();
5077 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents,
5078 CurContext, Selectors, AllowSameLength, Results, false);
5082 if (!IFace || !IFace->hasDefinition())
5085 // Add methods in protocols.
5086 for (auto *I : IFace->protocols())
5087 AddObjCMethods(I, WantInstanceMethods, WantKind, SelIdents,
5088 CurContext, Selectors, AllowSameLength, Results, false);
5090 // Add methods in categories.
5091 for (auto *CatDecl : IFace->known_categories()) {
5092 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
5093 CurContext, Selectors, AllowSameLength,
5094 Results, InOriginalClass);
5096 // Add a categories protocol methods.
5097 const ObjCList<ObjCProtocolDecl> &Protocols
5098 = CatDecl->getReferencedProtocols();
5099 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5100 E = Protocols.end();
5102 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents,
5103 CurContext, Selectors, AllowSameLength,
5106 // Add methods in category implementations.
5107 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation())
5108 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents,
5109 CurContext, Selectors, AllowSameLength,
5110 Results, InOriginalClass);
5113 // Add methods in superclass.
5114 if (IFace->getSuperClass())
5115 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind,
5116 SelIdents, CurContext, Selectors,
5117 AllowSameLength, Results, false);
5119 // Add methods in our implementation, if any.
5120 if (ObjCImplementationDecl *Impl = IFace->getImplementation())
5121 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents,
5122 CurContext, Selectors, AllowSameLength,
5123 Results, InOriginalClass);
5127 void Sema::CodeCompleteObjCPropertyGetter(Scope *S) {
5128 // Try to find the interface where getters might live.
5129 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
5131 if (ObjCCategoryDecl *Category
5132 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
5133 Class = Category->getClassInterface();
5139 // Find all of the potential getters.
5140 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5141 CodeCompleter->getCodeCompletionTUInfo(),
5142 CodeCompletionContext::CCC_Other);
5143 Results.EnterNewScope();
5145 VisitedSelectorSet Selectors;
5146 AddObjCMethods(Class, true, MK_ZeroArgSelector, None, CurContext, Selectors,
5147 /*AllowSameLength=*/true, Results);
5148 Results.ExitScope();
5149 HandleCodeCompleteResults(this, CodeCompleter,
5150 CodeCompletionContext::CCC_Other,
5151 Results.data(),Results.size());
5154 void Sema::CodeCompleteObjCPropertySetter(Scope *S) {
5155 // Try to find the interface where setters might live.
5156 ObjCInterfaceDecl *Class
5157 = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
5159 if (ObjCCategoryDecl *Category
5160 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
5161 Class = Category->getClassInterface();
5167 // Find all of the potential getters.
5168 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5169 CodeCompleter->getCodeCompletionTUInfo(),
5170 CodeCompletionContext::CCC_Other);
5171 Results.EnterNewScope();
5173 VisitedSelectorSet Selectors;
5174 AddObjCMethods(Class, true, MK_OneArgSelector, None, CurContext,
5175 Selectors, /*AllowSameLength=*/true, Results);
5177 Results.ExitScope();
5178 HandleCodeCompleteResults(this, CodeCompleter,
5179 CodeCompletionContext::CCC_Other,
5180 Results.data(),Results.size());
5183 void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
5185 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5186 CodeCompleter->getCodeCompletionTUInfo(),
5187 CodeCompletionContext::CCC_Type);
5188 Results.EnterNewScope();
5190 // Add context-sensitive, Objective-C parameter-passing keywords.
5191 bool AddedInOut = false;
5192 if ((DS.getObjCDeclQualifier() &
5193 (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) {
5194 Results.AddResult("in");
5195 Results.AddResult("inout");
5198 if ((DS.getObjCDeclQualifier() &
5199 (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) {
5200 Results.AddResult("out");
5202 Results.AddResult("inout");
5204 if ((DS.getObjCDeclQualifier() &
5205 (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref |
5206 ObjCDeclSpec::DQ_Oneway)) == 0) {
5207 Results.AddResult("bycopy");
5208 Results.AddResult("byref");
5209 Results.AddResult("oneway");
5211 if ((DS.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability) == 0) {
5212 Results.AddResult("nonnull");
5213 Results.AddResult("nullable");
5214 Results.AddResult("null_unspecified");
5217 // If we're completing the return type of an Objective-C method and the
5218 // identifier IBAction refers to a macro, provide a completion item for
5220 // IBAction)<#selector#>:(id)sender
5221 if (DS.getObjCDeclQualifier() == 0 && !IsParameter &&
5222 PP.isMacroDefined("IBAction")) {
5223 CodeCompletionBuilder Builder(Results.getAllocator(),
5224 Results.getCodeCompletionTUInfo(),
5225 CCP_CodePattern, CXAvailability_Available);
5226 Builder.AddTypedTextChunk("IBAction");
5227 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5228 Builder.AddPlaceholderChunk("selector");
5229 Builder.AddChunk(CodeCompletionString::CK_Colon);
5230 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5231 Builder.AddTextChunk("id");
5232 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5233 Builder.AddTextChunk("sender");
5234 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
5237 // If we're completing the return type, provide 'instancetype'.
5239 Results.AddResult(CodeCompletionResult("instancetype"));
5242 // Add various builtin type names and specifiers.
5243 AddOrdinaryNameResults(PCC_Type, S, *this, Results);
5244 Results.ExitScope();
5246 // Add the various type names
5247 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
5248 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5249 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5250 CodeCompleter->includeGlobals());
5252 if (CodeCompleter->includeMacros())
5253 AddMacroResults(PP, Results, false);
5255 HandleCodeCompleteResults(this, CodeCompleter,
5256 CodeCompletionContext::CCC_Type,
5257 Results.data(), Results.size());
5260 /// \brief When we have an expression with type "id", we may assume
5261 /// that it has some more-specific class type based on knowledge of
5262 /// common uses of Objective-C. This routine returns that class type,
5263 /// or NULL if no better result could be determined.
5264 static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) {
5265 ObjCMessageExpr *Msg = dyn_cast_or_null<ObjCMessageExpr>(E);
5269 Selector Sel = Msg->getSelector();
5273 IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0);
5277 ObjCMethodDecl *Method = Msg->getMethodDecl();
5281 // Determine the class that we're sending the message to.
5282 ObjCInterfaceDecl *IFace = nullptr;
5283 switch (Msg->getReceiverKind()) {
5284 case ObjCMessageExpr::Class:
5285 if (const ObjCObjectType *ObjType
5286 = Msg->getClassReceiver()->getAs<ObjCObjectType>())
5287 IFace = ObjType->getInterface();
5290 case ObjCMessageExpr::Instance: {
5291 QualType T = Msg->getInstanceReceiver()->getType();
5292 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
5293 IFace = Ptr->getInterfaceDecl();
5297 case ObjCMessageExpr::SuperInstance:
5298 case ObjCMessageExpr::SuperClass:
5305 ObjCInterfaceDecl *Super = IFace->getSuperClass();
5306 if (Method->isInstanceMethod())
5307 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5308 .Case("retain", IFace)
5309 .Case("strong", IFace)
5310 .Case("autorelease", IFace)
5311 .Case("copy", IFace)
5312 .Case("copyWithZone", IFace)
5313 .Case("mutableCopy", IFace)
5314 .Case("mutableCopyWithZone", IFace)
5315 .Case("awakeFromCoder", IFace)
5316 .Case("replacementObjectFromCoder", IFace)
5317 .Case("class", IFace)
5318 .Case("classForCoder", IFace)
5319 .Case("superclass", Super)
5322 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5324 .Case("alloc", IFace)
5325 .Case("allocWithZone", IFace)
5326 .Case("class", IFace)
5327 .Case("superclass", Super)
5331 // Add a special completion for a message send to "super", which fills in the
5332 // most likely case of forwarding all of our arguments to the superclass
5335 /// \param S The semantic analysis object.
5337 /// \param NeedSuperKeyword Whether we need to prefix this completion with
5338 /// the "super" keyword. Otherwise, we just need to provide the arguments.
5340 /// \param SelIdents The identifiers in the selector that have already been
5341 /// provided as arguments for a send to "super".
5343 /// \param Results The set of results to augment.
5345 /// \returns the Objective-C method declaration that would be invoked by
5346 /// this "super" completion. If NULL, no completion was added.
5347 static ObjCMethodDecl *AddSuperSendCompletion(
5348 Sema &S, bool NeedSuperKeyword,
5349 ArrayRef<IdentifierInfo *> SelIdents,
5350 ResultBuilder &Results) {
5351 ObjCMethodDecl *CurMethod = S.getCurMethodDecl();
5355 ObjCInterfaceDecl *Class = CurMethod->getClassInterface();
5359 // Try to find a superclass method with the same selector.
5360 ObjCMethodDecl *SuperMethod = nullptr;
5361 while ((Class = Class->getSuperClass()) && !SuperMethod) {
5362 // Check in the class
5363 SuperMethod = Class->getMethod(CurMethod->getSelector(),
5364 CurMethod->isInstanceMethod());
5366 // Check in categories or class extensions.
5368 for (const auto *Cat : Class->known_categories()) {
5369 if ((SuperMethod = Cat->getMethod(CurMethod->getSelector(),
5370 CurMethod->isInstanceMethod())))
5379 // Check whether the superclass method has the same signature.
5380 if (CurMethod->param_size() != SuperMethod->param_size() ||
5381 CurMethod->isVariadic() != SuperMethod->isVariadic())
5384 for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(),
5385 CurPEnd = CurMethod->param_end(),
5386 SuperP = SuperMethod->param_begin();
5387 CurP != CurPEnd; ++CurP, ++SuperP) {
5388 // Make sure the parameter types are compatible.
5389 if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(),
5390 (*SuperP)->getType()))
5393 // Make sure we have a parameter name to forward!
5394 if (!(*CurP)->getIdentifier())
5398 // We have a superclass method. Now, form the send-to-super completion.
5399 CodeCompletionBuilder Builder(Results.getAllocator(),
5400 Results.getCodeCompletionTUInfo());
5402 // Give this completion a return type.
5403 AddResultTypeChunk(S.Context, getCompletionPrintingPolicy(S), SuperMethod,
5404 Results.getCompletionContext().getBaseType(),
5407 // If we need the "super" keyword, add it (plus some spacing).
5408 if (NeedSuperKeyword) {
5409 Builder.AddTypedTextChunk("super");
5410 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5413 Selector Sel = CurMethod->getSelector();
5414 if (Sel.isUnarySelector()) {
5415 if (NeedSuperKeyword)
5416 Builder.AddTextChunk(Builder.getAllocator().CopyString(
5417 Sel.getNameForSlot(0)));
5419 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
5420 Sel.getNameForSlot(0)));
5422 ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin();
5423 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) {
5424 if (I > SelIdents.size())
5425 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5427 if (I < SelIdents.size())
5428 Builder.AddInformativeChunk(
5429 Builder.getAllocator().CopyString(
5430 Sel.getNameForSlot(I) + ":"));
5431 else if (NeedSuperKeyword || I > SelIdents.size()) {
5432 Builder.AddTextChunk(
5433 Builder.getAllocator().CopyString(
5434 Sel.getNameForSlot(I) + ":"));
5435 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5436 (*CurP)->getIdentifier()->getName()));
5438 Builder.AddTypedTextChunk(
5439 Builder.getAllocator().CopyString(
5440 Sel.getNameForSlot(I) + ":"));
5441 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5442 (*CurP)->getIdentifier()->getName()));
5447 Results.AddResult(CodeCompletionResult(Builder.TakeString(), SuperMethod,
5448 CCP_SuperCompletion));
5452 void Sema::CodeCompleteObjCMessageReceiver(Scope *S) {
5453 typedef CodeCompletionResult Result;
5454 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5455 CodeCompleter->getCodeCompletionTUInfo(),
5456 CodeCompletionContext::CCC_ObjCMessageReceiver,
5457 getLangOpts().CPlusPlus11
5458 ? &ResultBuilder::IsObjCMessageReceiverOrLambdaCapture
5459 : &ResultBuilder::IsObjCMessageReceiver);
5461 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5462 Results.EnterNewScope();
5463 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5464 CodeCompleter->includeGlobals());
5466 // If we are in an Objective-C method inside a class that has a superclass,
5467 // add "super" as an option.
5468 if (ObjCMethodDecl *Method = getCurMethodDecl())
5469 if (ObjCInterfaceDecl *Iface = Method->getClassInterface())
5470 if (Iface->getSuperClass()) {
5471 Results.AddResult(Result("super"));
5473 AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, None, Results);
5476 if (getLangOpts().CPlusPlus11)
5477 addThisCompletion(*this, Results);
5479 Results.ExitScope();
5481 if (CodeCompleter->includeMacros())
5482 AddMacroResults(PP, Results, false);
5483 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5484 Results.data(), Results.size());
5488 void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
5489 ArrayRef<IdentifierInfo *> SelIdents,
5490 bool AtArgumentExpression) {
5491 ObjCInterfaceDecl *CDecl = nullptr;
5492 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5493 // Figure out which interface we're in.
5494 CDecl = CurMethod->getClassInterface();
5498 // Find the superclass of this class.
5499 CDecl = CDecl->getSuperClass();
5503 if (CurMethod->isInstanceMethod()) {
5504 // We are inside an instance method, which means that the message
5505 // send [super ...] is actually calling an instance method on the
5507 return CodeCompleteObjCInstanceMessage(S, nullptr, SelIdents,
5508 AtArgumentExpression,
5512 // Fall through to send to the superclass in CDecl.
5514 // "super" may be the name of a type or variable. Figure out which
5516 IdentifierInfo *Super = getSuperIdentifier();
5517 NamedDecl *ND = LookupSingleName(S, Super, SuperLoc,
5518 LookupOrdinaryName);
5519 if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) {
5520 // "super" names an interface. Use it.
5521 } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) {
5522 if (const ObjCObjectType *Iface
5523 = Context.getTypeDeclType(TD)->getAs<ObjCObjectType>())
5524 CDecl = Iface->getInterface();
5525 } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) {
5526 // "super" names an unresolved type; we can't be more specific.
5528 // Assume that "super" names some kind of value and parse that way.
5530 SourceLocation TemplateKWLoc;
5532 id.setIdentifier(Super, SuperLoc);
5533 ExprResult SuperExpr = ActOnIdExpression(S, SS, TemplateKWLoc, id,
5535 return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
5537 AtArgumentExpression);
5543 ParsedType Receiver;
5545 Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl));
5546 return CodeCompleteObjCClassMessage(S, Receiver, SelIdents,
5547 AtArgumentExpression,
5551 /// \brief Given a set of code-completion results for the argument of a message
5552 /// send, determine the preferred type (if any) for that argument expression.
5553 static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
5554 unsigned NumSelIdents) {
5555 typedef CodeCompletionResult Result;
5556 ASTContext &Context = Results.getSema().Context;
5558 QualType PreferredType;
5559 unsigned BestPriority = CCP_Unlikely * 2;
5560 Result *ResultsData = Results.data();
5561 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
5562 Result &R = ResultsData[I];
5563 if (R.Kind == Result::RK_Declaration &&
5564 isa<ObjCMethodDecl>(R.Declaration)) {
5565 if (R.Priority <= BestPriority) {
5566 const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration);
5567 if (NumSelIdents <= Method->param_size()) {
5568 QualType MyPreferredType = Method->parameters()[NumSelIdents - 1]
5570 if (R.Priority < BestPriority || PreferredType.isNull()) {
5571 BestPriority = R.Priority;
5572 PreferredType = MyPreferredType;
5573 } else if (!Context.hasSameUnqualifiedType(PreferredType,
5575 PreferredType = QualType();
5582 return PreferredType;
5585 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
5586 ParsedType Receiver,
5587 ArrayRef<IdentifierInfo *> SelIdents,
5588 bool AtArgumentExpression,
5590 ResultBuilder &Results) {
5591 typedef CodeCompletionResult Result;
5592 ObjCInterfaceDecl *CDecl = nullptr;
5594 // If the given name refers to an interface type, retrieve the
5595 // corresponding declaration.
5597 QualType T = SemaRef.GetTypeFromParser(Receiver, nullptr);
5599 if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>())
5600 CDecl = Interface->getInterface();
5603 // Add all of the factory methods in this Objective-C class, its protocols,
5604 // superclasses, categories, implementation, etc.
5605 Results.EnterNewScope();
5607 // If this is a send-to-super, try to add the special "super" send
5610 if (ObjCMethodDecl *SuperMethod
5611 = AddSuperSendCompletion(SemaRef, false, SelIdents, Results))
5612 Results.Ignore(SuperMethod);
5615 // If we're inside an Objective-C method definition, prefer its selector to
5617 if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl())
5618 Results.setPreferredSelector(CurMethod->getSelector());
5620 VisitedSelectorSet Selectors;
5622 AddObjCMethods(CDecl, false, MK_Any, SelIdents,
5623 SemaRef.CurContext, Selectors, AtArgumentExpression,
5626 // We're messaging "id" as a type; provide all class/factory methods.
5628 // If we have an external source, load the entire class method
5629 // pool from the AST file.
5630 if (SemaRef.getExternalSource()) {
5631 for (uint32_t I = 0,
5632 N = SemaRef.getExternalSource()->GetNumExternalSelectors();
5634 Selector Sel = SemaRef.getExternalSource()->GetExternalSelector(I);
5635 if (Sel.isNull() || SemaRef.MethodPool.count(Sel))
5638 SemaRef.ReadMethodPool(Sel);
5642 for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(),
5643 MEnd = SemaRef.MethodPool.end();
5645 for (ObjCMethodList *MethList = &M->second.second;
5646 MethList && MethList->getMethod();
5647 MethList = MethList->getNext()) {
5648 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
5651 Result R(MethList->getMethod(),
5652 Results.getBasePriority(MethList->getMethod()), nullptr);
5653 R.StartParameter = SelIdents.size();
5654 R.AllParametersAreInformative = false;
5655 Results.MaybeAddResult(R, SemaRef.CurContext);
5660 Results.ExitScope();
5663 void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
5664 ArrayRef<IdentifierInfo *> SelIdents,
5665 bool AtArgumentExpression,
5668 QualType T = this->GetTypeFromParser(Receiver);
5670 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5671 CodeCompleter->getCodeCompletionTUInfo(),
5672 CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage,
5675 AddClassMessageCompletions(*this, S, Receiver, SelIdents,
5676 AtArgumentExpression, IsSuper, Results);
5678 // If we're actually at the argument expression (rather than prior to the
5679 // selector), we're actually performing code completion for an expression.
5680 // Determine whether we have a single, best method. If so, we can
5681 // code-complete the expression using the corresponding parameter type as
5682 // our preferred type, improving completion results.
5683 if (AtArgumentExpression) {
5684 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
5686 if (PreferredType.isNull())
5687 CodeCompleteOrdinaryName(S, PCC_Expression);
5689 CodeCompleteExpression(S, PreferredType);
5693 HandleCodeCompleteResults(this, CodeCompleter,
5694 Results.getCompletionContext(),
5695 Results.data(), Results.size());
5698 void Sema::CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
5699 ArrayRef<IdentifierInfo *> SelIdents,
5700 bool AtArgumentExpression,
5701 ObjCInterfaceDecl *Super) {
5702 typedef CodeCompletionResult Result;
5704 Expr *RecExpr = static_cast<Expr *>(Receiver);
5706 // If necessary, apply function/array conversion to the receiver.
5707 // C99 6.7.5.3p[7,8].
5709 ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr);
5710 if (Conv.isInvalid()) // conversion failed. bail.
5712 RecExpr = Conv.get();
5714 QualType ReceiverType = RecExpr? RecExpr->getType()
5715 : Super? Context.getObjCObjectPointerType(
5716 Context.getObjCInterfaceType(Super))
5717 : Context.getObjCIdType();
5719 // If we're messaging an expression with type "id" or "Class", check
5720 // whether we know something special about the receiver that allows
5721 // us to assume a more-specific receiver type.
5722 if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType()) {
5723 if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) {
5724 if (ReceiverType->isObjCClassType())
5725 return CodeCompleteObjCClassMessage(S,
5726 ParsedType::make(Context.getObjCInterfaceType(IFace)),
5728 AtArgumentExpression, Super);
5730 ReceiverType = Context.getObjCObjectPointerType(
5731 Context.getObjCInterfaceType(IFace));
5733 } else if (RecExpr && getLangOpts().CPlusPlus) {
5734 ExprResult Conv = PerformContextuallyConvertToObjCPointer(RecExpr);
5735 if (Conv.isUsable()) {
5736 RecExpr = Conv.get();
5737 ReceiverType = RecExpr->getType();
5741 // Build the set of methods we can see.
5742 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5743 CodeCompleter->getCodeCompletionTUInfo(),
5744 CodeCompletionContext(CodeCompletionContext::CCC_ObjCInstanceMessage,
5745 ReceiverType, SelIdents));
5747 Results.EnterNewScope();
5749 // If this is a send-to-super, try to add the special "super" send
5752 if (ObjCMethodDecl *SuperMethod
5753 = AddSuperSendCompletion(*this, false, SelIdents, Results))
5754 Results.Ignore(SuperMethod);
5757 // If we're inside an Objective-C method definition, prefer its selector to
5759 if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
5760 Results.setPreferredSelector(CurMethod->getSelector());
5762 // Keep track of the selectors we've already added.
5763 VisitedSelectorSet Selectors;
5765 // Handle messages to Class. This really isn't a message to an instance
5766 // method, so we treat it the same way we would treat a message send to a
5768 if (ReceiverType->isObjCClassType() ||
5769 ReceiverType->isObjCQualifiedClassType()) {
5770 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5771 if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface())
5772 AddObjCMethods(ClassDecl, false, MK_Any, SelIdents,
5773 CurContext, Selectors, AtArgumentExpression, Results);
5776 // Handle messages to a qualified ID ("id<foo>").
5777 else if (const ObjCObjectPointerType *QualID
5778 = ReceiverType->getAsObjCQualifiedIdType()) {
5779 // Search protocols for instance methods.
5780 for (auto *I : QualID->quals())
5781 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
5782 Selectors, AtArgumentExpression, Results);
5784 // Handle messages to a pointer to interface type.
5785 else if (const ObjCObjectPointerType *IFacePtr
5786 = ReceiverType->getAsObjCInterfacePointerType()) {
5787 // Search the class, its superclasses, etc., for instance methods.
5788 AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents,
5789 CurContext, Selectors, AtArgumentExpression,
5792 // Search protocols for instance methods.
5793 for (auto *I : IFacePtr->quals())
5794 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
5795 Selectors, AtArgumentExpression, Results);
5797 // Handle messages to "id".
5798 else if (ReceiverType->isObjCIdType()) {
5799 // We're messaging "id", so provide all instance methods we know
5800 // about as code-completion results.
5802 // If we have an external source, load the entire class method
5803 // pool from the AST file.
5804 if (ExternalSource) {
5805 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
5807 Selector Sel = ExternalSource->GetExternalSelector(I);
5808 if (Sel.isNull() || MethodPool.count(Sel))
5811 ReadMethodPool(Sel);
5815 for (GlobalMethodPool::iterator M = MethodPool.begin(),
5816 MEnd = MethodPool.end();
5818 for (ObjCMethodList *MethList = &M->second.first;
5819 MethList && MethList->getMethod();
5820 MethList = MethList->getNext()) {
5821 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
5824 if (!Selectors.insert(MethList->getMethod()->getSelector()).second)
5827 Result R(MethList->getMethod(),
5828 Results.getBasePriority(MethList->getMethod()), nullptr);
5829 R.StartParameter = SelIdents.size();
5830 R.AllParametersAreInformative = false;
5831 Results.MaybeAddResult(R, CurContext);
5835 Results.ExitScope();
5838 // If we're actually at the argument expression (rather than prior to the
5839 // selector), we're actually performing code completion for an expression.
5840 // Determine whether we have a single, best method. If so, we can
5841 // code-complete the expression using the corresponding parameter type as
5842 // our preferred type, improving completion results.
5843 if (AtArgumentExpression) {
5844 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
5846 if (PreferredType.isNull())
5847 CodeCompleteOrdinaryName(S, PCC_Expression);
5849 CodeCompleteExpression(S, PreferredType);
5853 HandleCodeCompleteResults(this, CodeCompleter,
5854 Results.getCompletionContext(),
5855 Results.data(),Results.size());
5858 void Sema::CodeCompleteObjCForCollection(Scope *S,
5859 DeclGroupPtrTy IterationVar) {
5860 CodeCompleteExpressionData Data;
5861 Data.ObjCCollection = true;
5863 if (IterationVar.getAsOpaquePtr()) {
5864 DeclGroupRef DG = IterationVar.get();
5865 for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) {
5867 Data.IgnoreDecls.push_back(*I);
5871 CodeCompleteExpression(S, Data);
5874 void Sema::CodeCompleteObjCSelector(Scope *S,
5875 ArrayRef<IdentifierInfo *> SelIdents) {
5876 // If we have an external source, load the entire class method
5877 // pool from the AST file.
5878 if (ExternalSource) {
5879 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
5881 Selector Sel = ExternalSource->GetExternalSelector(I);
5882 if (Sel.isNull() || MethodPool.count(Sel))
5885 ReadMethodPool(Sel);
5889 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5890 CodeCompleter->getCodeCompletionTUInfo(),
5891 CodeCompletionContext::CCC_SelectorName);
5892 Results.EnterNewScope();
5893 for (GlobalMethodPool::iterator M = MethodPool.begin(),
5894 MEnd = MethodPool.end();
5897 Selector Sel = M->first;
5898 if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents))
5901 CodeCompletionBuilder Builder(Results.getAllocator(),
5902 Results.getCodeCompletionTUInfo());
5903 if (Sel.isUnarySelector()) {
5904 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
5905 Sel.getNameForSlot(0)));
5906 Results.AddResult(Builder.TakeString());
5910 std::string Accumulator;
5911 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) {
5912 if (I == SelIdents.size()) {
5913 if (!Accumulator.empty()) {
5914 Builder.AddInformativeChunk(Builder.getAllocator().CopyString(
5916 Accumulator.clear();
5920 Accumulator += Sel.getNameForSlot(I);
5923 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString( Accumulator));
5924 Results.AddResult(Builder.TakeString());
5926 Results.ExitScope();
5928 HandleCodeCompleteResults(this, CodeCompleter,
5929 CodeCompletionContext::CCC_SelectorName,
5930 Results.data(), Results.size());
5933 /// \brief Add all of the protocol declarations that we find in the given
5934 /// (translation unit) context.
5935 static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext,
5936 bool OnlyForwardDeclarations,
5937 ResultBuilder &Results) {
5938 typedef CodeCompletionResult Result;
5940 for (const auto *D : Ctx->decls()) {
5941 // Record any protocols we find.
5942 if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(D))
5943 if (!OnlyForwardDeclarations || !Proto->hasDefinition())
5944 Results.AddResult(Result(Proto, Results.getBasePriority(Proto),nullptr),
5945 CurContext, nullptr, false);
5949 void Sema::CodeCompleteObjCProtocolReferences(
5950 ArrayRef<IdentifierLocPair> Protocols) {
5951 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5952 CodeCompleter->getCodeCompletionTUInfo(),
5953 CodeCompletionContext::CCC_ObjCProtocolName);
5955 if (CodeCompleter && CodeCompleter->includeGlobals()) {
5956 Results.EnterNewScope();
5958 // Tell the result set to ignore all of the protocols we have
5960 // FIXME: This doesn't work when caching code-completion results.
5961 for (const IdentifierLocPair &Pair : Protocols)
5962 if (ObjCProtocolDecl *Protocol = LookupProtocol(Pair.first,
5964 Results.Ignore(Protocol);
5966 // Add all protocols.
5967 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false,
5970 Results.ExitScope();
5973 HandleCodeCompleteResults(this, CodeCompleter,
5974 CodeCompletionContext::CCC_ObjCProtocolName,
5975 Results.data(),Results.size());
5978 void Sema::CodeCompleteObjCProtocolDecl(Scope *) {
5979 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5980 CodeCompleter->getCodeCompletionTUInfo(),
5981 CodeCompletionContext::CCC_ObjCProtocolName);
5983 if (CodeCompleter && CodeCompleter->includeGlobals()) {
5984 Results.EnterNewScope();
5986 // Add all protocols.
5987 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true,
5990 Results.ExitScope();
5993 HandleCodeCompleteResults(this, CodeCompleter,
5994 CodeCompletionContext::CCC_ObjCProtocolName,
5995 Results.data(),Results.size());
5998 /// \brief Add all of the Objective-C interface declarations that we find in
5999 /// the given (translation unit) context.
6000 static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext,
6001 bool OnlyForwardDeclarations,
6002 bool OnlyUnimplemented,
6003 ResultBuilder &Results) {
6004 typedef CodeCompletionResult Result;
6006 for (const auto *D : Ctx->decls()) {
6007 // Record any interfaces we find.
6008 if (const auto *Class = dyn_cast<ObjCInterfaceDecl>(D))
6009 if ((!OnlyForwardDeclarations || !Class->hasDefinition()) &&
6010 (!OnlyUnimplemented || !Class->getImplementation()))
6011 Results.AddResult(Result(Class, Results.getBasePriority(Class),nullptr),
6012 CurContext, nullptr, false);
6016 void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) {
6017 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6018 CodeCompleter->getCodeCompletionTUInfo(),
6019 CodeCompletionContext::CCC_Other);
6020 Results.EnterNewScope();
6022 if (CodeCompleter->includeGlobals()) {
6024 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6028 Results.ExitScope();
6030 HandleCodeCompleteResults(this, CodeCompleter,
6031 CodeCompletionContext::CCC_ObjCInterfaceName,
6032 Results.data(),Results.size());
6035 void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName,
6036 SourceLocation ClassNameLoc) {
6037 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6038 CodeCompleter->getCodeCompletionTUInfo(),
6039 CodeCompletionContext::CCC_ObjCInterfaceName);
6040 Results.EnterNewScope();
6042 // Make sure that we ignore the class we're currently defining.
6044 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6045 if (CurClass && isa<ObjCInterfaceDecl>(CurClass))
6046 Results.Ignore(CurClass);
6048 if (CodeCompleter->includeGlobals()) {
6050 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6054 Results.ExitScope();
6056 HandleCodeCompleteResults(this, CodeCompleter,
6057 CodeCompletionContext::CCC_ObjCInterfaceName,
6058 Results.data(),Results.size());
6061 void Sema::CodeCompleteObjCImplementationDecl(Scope *S) {
6062 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6063 CodeCompleter->getCodeCompletionTUInfo(),
6064 CodeCompletionContext::CCC_Other);
6065 Results.EnterNewScope();
6067 if (CodeCompleter->includeGlobals()) {
6068 // Add all unimplemented classes.
6069 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6073 Results.ExitScope();
6075 HandleCodeCompleteResults(this, CodeCompleter,
6076 CodeCompletionContext::CCC_ObjCInterfaceName,
6077 Results.data(),Results.size());
6080 void Sema::CodeCompleteObjCInterfaceCategory(Scope *S,
6081 IdentifierInfo *ClassName,
6082 SourceLocation ClassNameLoc) {
6083 typedef CodeCompletionResult Result;
6085 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6086 CodeCompleter->getCodeCompletionTUInfo(),
6087 CodeCompletionContext::CCC_ObjCCategoryName);
6089 // Ignore any categories we find that have already been implemented by this
6091 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
6093 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6094 if (ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)){
6095 for (const auto *Cat : Class->visible_categories())
6096 CategoryNames.insert(Cat->getIdentifier());
6099 // Add all of the categories we know about.
6100 Results.EnterNewScope();
6101 TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
6102 for (const auto *D : TU->decls())
6103 if (const auto *Category = dyn_cast<ObjCCategoryDecl>(D))
6104 if (CategoryNames.insert(Category->getIdentifier()).second)
6105 Results.AddResult(Result(Category, Results.getBasePriority(Category),
6107 CurContext, nullptr, false);
6108 Results.ExitScope();
6110 HandleCodeCompleteResults(this, CodeCompleter,
6111 CodeCompletionContext::CCC_ObjCCategoryName,
6112 Results.data(),Results.size());
6115 void Sema::CodeCompleteObjCImplementationCategory(Scope *S,
6116 IdentifierInfo *ClassName,
6117 SourceLocation ClassNameLoc) {
6118 typedef CodeCompletionResult Result;
6120 // Find the corresponding interface. If we couldn't find the interface, the
6121 // program itself is ill-formed. However, we'll try to be helpful still by
6122 // providing the list of all of the categories we know about.
6124 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6125 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass);
6127 return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc);
6129 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6130 CodeCompleter->getCodeCompletionTUInfo(),
6131 CodeCompletionContext::CCC_ObjCCategoryName);
6133 // Add all of the categories that have have corresponding interface
6134 // declarations in this class and any of its superclasses, except for
6135 // already-implemented categories in the class itself.
6136 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
6137 Results.EnterNewScope();
6138 bool IgnoreImplemented = true;
6140 for (const auto *Cat : Class->visible_categories()) {
6141 if ((!IgnoreImplemented || !Cat->getImplementation()) &&
6142 CategoryNames.insert(Cat->getIdentifier()).second)
6143 Results.AddResult(Result(Cat, Results.getBasePriority(Cat), nullptr),
6144 CurContext, nullptr, false);
6147 Class = Class->getSuperClass();
6148 IgnoreImplemented = false;
6150 Results.ExitScope();
6152 HandleCodeCompleteResults(this, CodeCompleter,
6153 CodeCompletionContext::CCC_ObjCCategoryName,
6154 Results.data(),Results.size());
6157 void Sema::CodeCompleteObjCPropertyDefinition(Scope *S) {
6158 CodeCompletionContext CCContext(CodeCompletionContext::CCC_Other);
6159 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6160 CodeCompleter->getCodeCompletionTUInfo(),
6163 // Figure out where this @synthesize lives.
6164 ObjCContainerDecl *Container
6165 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6167 (!isa<ObjCImplementationDecl>(Container) &&
6168 !isa<ObjCCategoryImplDecl>(Container)))
6171 // Ignore any properties that have already been implemented.
6172 Container = getContainerDef(Container);
6173 for (const auto *D : Container->decls())
6174 if (const auto *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(D))
6175 Results.Ignore(PropertyImpl->getPropertyDecl());
6177 // Add any properties that we find.
6178 AddedPropertiesSet AddedProperties;
6179 Results.EnterNewScope();
6180 if (ObjCImplementationDecl *ClassImpl
6181 = dyn_cast<ObjCImplementationDecl>(Container))
6182 AddObjCProperties(CCContext, ClassImpl->getClassInterface(), false,
6183 /*AllowNullaryMethods=*/false, CurContext,
6184 AddedProperties, Results);
6186 AddObjCProperties(CCContext,
6187 cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(),
6188 false, /*AllowNullaryMethods=*/false, CurContext,
6189 AddedProperties, Results);
6190 Results.ExitScope();
6192 HandleCodeCompleteResults(this, CodeCompleter,
6193 CodeCompletionContext::CCC_Other,
6194 Results.data(),Results.size());
6197 void Sema::CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
6198 IdentifierInfo *PropertyName) {
6199 typedef CodeCompletionResult Result;
6200 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6201 CodeCompleter->getCodeCompletionTUInfo(),
6202 CodeCompletionContext::CCC_Other);
6204 // Figure out where this @synthesize lives.
6205 ObjCContainerDecl *Container
6206 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6208 (!isa<ObjCImplementationDecl>(Container) &&
6209 !isa<ObjCCategoryImplDecl>(Container)))
6212 // Figure out which interface we're looking into.
6213 ObjCInterfaceDecl *Class = nullptr;
6214 if (ObjCImplementationDecl *ClassImpl
6215 = dyn_cast<ObjCImplementationDecl>(Container))
6216 Class = ClassImpl->getClassInterface();
6218 Class = cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl()
6219 ->getClassInterface();
6221 // Determine the type of the property we're synthesizing.
6222 QualType PropertyType = Context.getObjCIdType();
6224 if (ObjCPropertyDecl *Property = Class->FindPropertyDeclaration(
6225 PropertyName, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
6227 = Property->getType().getNonReferenceType().getUnqualifiedType();
6229 // Give preference to ivars
6230 Results.setPreferredType(PropertyType);
6234 // Add all of the instance variables in this class and its superclasses.
6235 Results.EnterNewScope();
6236 bool SawSimilarlyNamedIvar = false;
6237 std::string NameWithPrefix;
6238 NameWithPrefix += '_';
6239 NameWithPrefix += PropertyName->getName();
6240 std::string NameWithSuffix = PropertyName->getName().str();
6241 NameWithSuffix += '_';
6242 for(; Class; Class = Class->getSuperClass()) {
6243 for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar;
6244 Ivar = Ivar->getNextIvar()) {
6245 Results.AddResult(Result(Ivar, Results.getBasePriority(Ivar), nullptr),
6246 CurContext, nullptr, false);
6248 // Determine whether we've seen an ivar with a name similar to the
6250 if ((PropertyName == Ivar->getIdentifier() ||
6251 NameWithPrefix == Ivar->getName() ||
6252 NameWithSuffix == Ivar->getName())) {
6253 SawSimilarlyNamedIvar = true;
6255 // Reduce the priority of this result by one, to give it a slight
6256 // advantage over other results whose names don't match so closely.
6257 if (Results.size() &&
6258 Results.data()[Results.size() - 1].Kind
6259 == CodeCompletionResult::RK_Declaration &&
6260 Results.data()[Results.size() - 1].Declaration == Ivar)
6261 Results.data()[Results.size() - 1].Priority--;
6266 if (!SawSimilarlyNamedIvar) {
6267 // Create ivar result _propName, that the user can use to synthesize
6268 // an ivar of the appropriate type.
6269 unsigned Priority = CCP_MemberDeclaration + 1;
6270 typedef CodeCompletionResult Result;
6271 CodeCompletionAllocator &Allocator = Results.getAllocator();
6272 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo(),
6273 Priority,CXAvailability_Available);
6275 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
6276 Builder.AddResultTypeChunk(GetCompletionTypeString(PropertyType, Context,
6277 Policy, Allocator));
6278 Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix));
6279 Results.AddResult(Result(Builder.TakeString(), Priority,
6280 CXCursor_ObjCIvarDecl));
6283 Results.ExitScope();
6285 HandleCodeCompleteResults(this, CodeCompleter,
6286 CodeCompletionContext::CCC_Other,
6287 Results.data(),Results.size());
6290 // Mapping from selectors to the methods that implement that selector, along
6291 // with the "in original class" flag.
6292 typedef llvm::DenseMap<
6293 Selector, llvm::PointerIntPair<ObjCMethodDecl *, 1, bool> > KnownMethodsMap;
6295 /// \brief Find all of the methods that reside in the given container
6296 /// (and its superclasses, protocols, etc.) that meet the given
6297 /// criteria. Insert those methods into the map of known methods,
6298 /// indexed by selector so they can be easily found.
6299 static void FindImplementableMethods(ASTContext &Context,
6300 ObjCContainerDecl *Container,
6301 bool WantInstanceMethods,
6302 QualType ReturnType,
6303 KnownMethodsMap &KnownMethods,
6304 bool InOriginalClass = true) {
6305 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) {
6306 // Make sure we have a definition; that's what we'll walk.
6307 if (!IFace->hasDefinition())
6310 IFace = IFace->getDefinition();
6313 const ObjCList<ObjCProtocolDecl> &Protocols
6314 = IFace->getReferencedProtocols();
6315 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6316 E = Protocols.end();
6318 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6319 KnownMethods, InOriginalClass);
6321 // Add methods from any class extensions and categories.
6322 for (auto *Cat : IFace->visible_categories()) {
6323 FindImplementableMethods(Context, Cat, WantInstanceMethods, ReturnType,
6324 KnownMethods, false);
6327 // Visit the superclass.
6328 if (IFace->getSuperClass())
6329 FindImplementableMethods(Context, IFace->getSuperClass(),
6330 WantInstanceMethods, ReturnType,
6331 KnownMethods, false);
6334 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
6335 // Recurse into protocols.
6336 const ObjCList<ObjCProtocolDecl> &Protocols
6337 = Category->getReferencedProtocols();
6338 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6339 E = Protocols.end();
6341 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6342 KnownMethods, InOriginalClass);
6344 // If this category is the original class, jump to the interface.
6345 if (InOriginalClass && Category->getClassInterface())
6346 FindImplementableMethods(Context, Category->getClassInterface(),
6347 WantInstanceMethods, ReturnType, KnownMethods,
6351 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
6352 // Make sure we have a definition; that's what we'll walk.
6353 if (!Protocol->hasDefinition())
6355 Protocol = Protocol->getDefinition();
6356 Container = Protocol;
6358 // Recurse into protocols.
6359 const ObjCList<ObjCProtocolDecl> &Protocols
6360 = Protocol->getReferencedProtocols();
6361 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6362 E = Protocols.end();
6364 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6365 KnownMethods, false);
6368 // Add methods in this container. This operation occurs last because
6369 // we want the methods from this container to override any methods
6370 // we've previously seen with the same selector.
6371 for (auto *M : Container->methods()) {
6372 if (M->isInstanceMethod() == WantInstanceMethods) {
6373 if (!ReturnType.isNull() &&
6374 !Context.hasSameUnqualifiedType(ReturnType, M->getReturnType()))
6377 KnownMethods[M->getSelector()] =
6378 KnownMethodsMap::mapped_type(M, InOriginalClass);
6383 /// \brief Add the parenthesized return or parameter type chunk to a code
6384 /// completion string.
6385 static void AddObjCPassingTypeChunk(QualType Type,
6386 unsigned ObjCDeclQuals,
6387 ASTContext &Context,
6388 const PrintingPolicy &Policy,
6389 CodeCompletionBuilder &Builder) {
6390 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6391 std::string Quals = formatObjCParamQualifiers(ObjCDeclQuals, Type);
6393 Builder.AddTextChunk(Builder.getAllocator().CopyString(Quals));
6394 Builder.AddTextChunk(GetCompletionTypeString(Type, Context, Policy,
6395 Builder.getAllocator()));
6396 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6399 /// \brief Determine whether the given class is or inherits from a class by
6401 static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class,
6406 if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name)
6409 return InheritsFromClassNamed(Class->getSuperClass(), Name);
6412 /// \brief Add code completions for Objective-C Key-Value Coding (KVC) and
6413 /// Key-Value Observing (KVO).
6414 static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property,
6415 bool IsInstanceMethod,
6416 QualType ReturnType,
6417 ASTContext &Context,
6418 VisitedSelectorSet &KnownSelectors,
6419 ResultBuilder &Results) {
6420 IdentifierInfo *PropName = Property->getIdentifier();
6421 if (!PropName || PropName->getLength() == 0)
6424 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
6426 // Builder that will create each code completion.
6427 typedef CodeCompletionResult Result;
6428 CodeCompletionAllocator &Allocator = Results.getAllocator();
6429 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
6431 // The selector table.
6432 SelectorTable &Selectors = Context.Selectors;
6434 // The property name, copied into the code completion allocation region
6437 CodeCompletionAllocator &Allocator;
6439 const char *CopiedKey;
6441 KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key)
6442 : Allocator(Allocator), Key(Key), CopiedKey(nullptr) {}
6444 operator const char *() {
6448 return CopiedKey = Allocator.CopyString(Key);
6450 } Key(Allocator, PropName->getName());
6452 // The uppercased name of the property name.
6453 std::string UpperKey = PropName->getName();
6454 if (!UpperKey.empty())
6455 UpperKey[0] = toUppercase(UpperKey[0]);
6457 bool ReturnTypeMatchesProperty = ReturnType.isNull() ||
6458 Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(),
6459 Property->getType());
6460 bool ReturnTypeMatchesVoid
6461 = ReturnType.isNull() || ReturnType->isVoidType();
6463 // Add the normal accessor -(type)key.
6464 if (IsInstanceMethod &&
6465 KnownSelectors.insert(Selectors.getNullarySelector(PropName)).second &&
6466 ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) {
6467 if (ReturnType.isNull())
6468 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6469 Context, Policy, Builder);
6471 Builder.AddTypedTextChunk(Key);
6472 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6473 CXCursor_ObjCInstanceMethodDecl));
6476 // If we have an integral or boolean property (or the user has provided
6477 // an integral or boolean return type), add the accessor -(type)isKey.
6478 if (IsInstanceMethod &&
6479 ((!ReturnType.isNull() &&
6480 (ReturnType->isIntegerType() || ReturnType->isBooleanType())) ||
6481 (ReturnType.isNull() &&
6482 (Property->getType()->isIntegerType() ||
6483 Property->getType()->isBooleanType())))) {
6484 std::string SelectorName = (Twine("is") + UpperKey).str();
6485 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6486 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6488 if (ReturnType.isNull()) {
6489 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6490 Builder.AddTextChunk("BOOL");
6491 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6494 Builder.AddTypedTextChunk(
6495 Allocator.CopyString(SelectorId->getName()));
6496 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6497 CXCursor_ObjCInstanceMethodDecl));
6501 // Add the normal mutator.
6502 if (IsInstanceMethod && ReturnTypeMatchesVoid &&
6503 !Property->getSetterMethodDecl()) {
6504 std::string SelectorName = (Twine("set") + UpperKey).str();
6505 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6506 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6507 if (ReturnType.isNull()) {
6508 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6509 Builder.AddTextChunk("void");
6510 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6513 Builder.AddTypedTextChunk(
6514 Allocator.CopyString(SelectorId->getName()));
6515 Builder.AddTypedTextChunk(":");
6516 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6517 Context, Policy, Builder);
6518 Builder.AddTextChunk(Key);
6519 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6520 CXCursor_ObjCInstanceMethodDecl));
6524 // Indexed and unordered accessors
6525 unsigned IndexedGetterPriority = CCP_CodePattern;
6526 unsigned IndexedSetterPriority = CCP_CodePattern;
6527 unsigned UnorderedGetterPriority = CCP_CodePattern;
6528 unsigned UnorderedSetterPriority = CCP_CodePattern;
6529 if (const ObjCObjectPointerType *ObjCPointer
6530 = Property->getType()->getAs<ObjCObjectPointerType>()) {
6531 if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) {
6532 // If this interface type is not provably derived from a known
6533 // collection, penalize the corresponding completions.
6534 if (!InheritsFromClassNamed(IFace, "NSMutableArray")) {
6535 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6536 if (!InheritsFromClassNamed(IFace, "NSArray"))
6537 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6540 if (!InheritsFromClassNamed(IFace, "NSMutableSet")) {
6541 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6542 if (!InheritsFromClassNamed(IFace, "NSSet"))
6543 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6547 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6548 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6549 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6550 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6553 // Add -(NSUInteger)countOf<key>
6554 if (IsInstanceMethod &&
6555 (ReturnType.isNull() || ReturnType->isIntegerType())) {
6556 std::string SelectorName = (Twine("countOf") + UpperKey).str();
6557 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6558 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6560 if (ReturnType.isNull()) {
6561 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6562 Builder.AddTextChunk("NSUInteger");
6563 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6566 Builder.AddTypedTextChunk(
6567 Allocator.CopyString(SelectorId->getName()));
6568 Results.AddResult(Result(Builder.TakeString(),
6569 std::min(IndexedGetterPriority,
6570 UnorderedGetterPriority),
6571 CXCursor_ObjCInstanceMethodDecl));
6576 // Add -(id)objectInKeyAtIndex:(NSUInteger)index
6577 if (IsInstanceMethod &&
6578 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
6579 std::string SelectorName
6580 = (Twine("objectIn") + UpperKey + "AtIndex").str();
6581 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6582 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6583 if (ReturnType.isNull()) {
6584 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6585 Builder.AddTextChunk("id");
6586 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6589 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6590 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6591 Builder.AddTextChunk("NSUInteger");
6592 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6593 Builder.AddTextChunk("index");
6594 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6595 CXCursor_ObjCInstanceMethodDecl));
6599 // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes
6600 if (IsInstanceMethod &&
6601 (ReturnType.isNull() ||
6602 (ReturnType->isObjCObjectPointerType() &&
6603 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6604 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6605 ->getName() == "NSArray"))) {
6606 std::string SelectorName
6607 = (Twine(Property->getName()) + "AtIndexes").str();
6608 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6609 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6610 if (ReturnType.isNull()) {
6611 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6612 Builder.AddTextChunk("NSArray *");
6613 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6616 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6617 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6618 Builder.AddTextChunk("NSIndexSet *");
6619 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6620 Builder.AddTextChunk("indexes");
6621 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6622 CXCursor_ObjCInstanceMethodDecl));
6626 // Add -(void)getKey:(type **)buffer range:(NSRange)inRange
6627 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6628 std::string SelectorName = (Twine("get") + UpperKey).str();
6629 IdentifierInfo *SelectorIds[2] = {
6630 &Context.Idents.get(SelectorName),
6631 &Context.Idents.get("range")
6634 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6635 if (ReturnType.isNull()) {
6636 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6637 Builder.AddTextChunk("void");
6638 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6641 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6642 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6643 Builder.AddPlaceholderChunk("object-type");
6644 Builder.AddTextChunk(" **");
6645 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6646 Builder.AddTextChunk("buffer");
6647 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6648 Builder.AddTypedTextChunk("range:");
6649 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6650 Builder.AddTextChunk("NSRange");
6651 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6652 Builder.AddTextChunk("inRange");
6653 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6654 CXCursor_ObjCInstanceMethodDecl));
6658 // Mutable indexed accessors
6660 // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index
6661 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6662 std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str();
6663 IdentifierInfo *SelectorIds[2] = {
6664 &Context.Idents.get("insertObject"),
6665 &Context.Idents.get(SelectorName)
6668 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6669 if (ReturnType.isNull()) {
6670 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6671 Builder.AddTextChunk("void");
6672 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6675 Builder.AddTypedTextChunk("insertObject:");
6676 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6677 Builder.AddPlaceholderChunk("object-type");
6678 Builder.AddTextChunk(" *");
6679 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6680 Builder.AddTextChunk("object");
6681 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6682 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6683 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6684 Builder.AddPlaceholderChunk("NSUInteger");
6685 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6686 Builder.AddTextChunk("index");
6687 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6688 CXCursor_ObjCInstanceMethodDecl));
6692 // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes
6693 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6694 std::string SelectorName = (Twine("insert") + UpperKey).str();
6695 IdentifierInfo *SelectorIds[2] = {
6696 &Context.Idents.get(SelectorName),
6697 &Context.Idents.get("atIndexes")
6700 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6701 if (ReturnType.isNull()) {
6702 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6703 Builder.AddTextChunk("void");
6704 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6707 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6708 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6709 Builder.AddTextChunk("NSArray *");
6710 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6711 Builder.AddTextChunk("array");
6712 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6713 Builder.AddTypedTextChunk("atIndexes:");
6714 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6715 Builder.AddPlaceholderChunk("NSIndexSet *");
6716 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6717 Builder.AddTextChunk("indexes");
6718 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6719 CXCursor_ObjCInstanceMethodDecl));
6723 // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index
6724 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6725 std::string SelectorName
6726 = (Twine("removeObjectFrom") + UpperKey + "AtIndex").str();
6727 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6728 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6729 if (ReturnType.isNull()) {
6730 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6731 Builder.AddTextChunk("void");
6732 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6735 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6736 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6737 Builder.AddTextChunk("NSUInteger");
6738 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6739 Builder.AddTextChunk("index");
6740 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6741 CXCursor_ObjCInstanceMethodDecl));
6745 // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes
6746 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6747 std::string SelectorName
6748 = (Twine("remove") + UpperKey + "AtIndexes").str();
6749 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6750 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6751 if (ReturnType.isNull()) {
6752 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6753 Builder.AddTextChunk("void");
6754 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6757 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6758 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6759 Builder.AddTextChunk("NSIndexSet *");
6760 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6761 Builder.AddTextChunk("indexes");
6762 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6763 CXCursor_ObjCInstanceMethodDecl));
6767 // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object
6768 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6769 std::string SelectorName
6770 = (Twine("replaceObjectIn") + UpperKey + "AtIndex").str();
6771 IdentifierInfo *SelectorIds[2] = {
6772 &Context.Idents.get(SelectorName),
6773 &Context.Idents.get("withObject")
6776 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6777 if (ReturnType.isNull()) {
6778 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6779 Builder.AddTextChunk("void");
6780 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6783 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6784 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6785 Builder.AddPlaceholderChunk("NSUInteger");
6786 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6787 Builder.AddTextChunk("index");
6788 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6789 Builder.AddTypedTextChunk("withObject:");
6790 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6791 Builder.AddTextChunk("id");
6792 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6793 Builder.AddTextChunk("object");
6794 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6795 CXCursor_ObjCInstanceMethodDecl));
6799 // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array
6800 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6801 std::string SelectorName1
6802 = (Twine("replace") + UpperKey + "AtIndexes").str();
6803 std::string SelectorName2 = (Twine("with") + UpperKey).str();
6804 IdentifierInfo *SelectorIds[2] = {
6805 &Context.Idents.get(SelectorName1),
6806 &Context.Idents.get(SelectorName2)
6809 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6810 if (ReturnType.isNull()) {
6811 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6812 Builder.AddTextChunk("void");
6813 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6816 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName1 + ":"));
6817 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6818 Builder.AddPlaceholderChunk("NSIndexSet *");
6819 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6820 Builder.AddTextChunk("indexes");
6821 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6822 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":"));
6823 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6824 Builder.AddTextChunk("NSArray *");
6825 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6826 Builder.AddTextChunk("array");
6827 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6828 CXCursor_ObjCInstanceMethodDecl));
6832 // Unordered getters
6833 // - (NSEnumerator *)enumeratorOfKey
6834 if (IsInstanceMethod &&
6835 (ReturnType.isNull() ||
6836 (ReturnType->isObjCObjectPointerType() &&
6837 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6838 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6839 ->getName() == "NSEnumerator"))) {
6840 std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str();
6841 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6842 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6844 if (ReturnType.isNull()) {
6845 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6846 Builder.AddTextChunk("NSEnumerator *");
6847 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6850 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6851 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
6852 CXCursor_ObjCInstanceMethodDecl));
6856 // - (type *)memberOfKey:(type *)object
6857 if (IsInstanceMethod &&
6858 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
6859 std::string SelectorName = (Twine("memberOf") + UpperKey).str();
6860 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6861 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6862 if (ReturnType.isNull()) {
6863 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6864 Builder.AddPlaceholderChunk("object-type");
6865 Builder.AddTextChunk(" *");
6866 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6869 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6870 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6871 if (ReturnType.isNull()) {
6872 Builder.AddPlaceholderChunk("object-type");
6873 Builder.AddTextChunk(" *");
6875 Builder.AddTextChunk(GetCompletionTypeString(ReturnType, Context,
6877 Builder.getAllocator()));
6879 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6880 Builder.AddTextChunk("object");
6881 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
6882 CXCursor_ObjCInstanceMethodDecl));
6886 // Mutable unordered accessors
6887 // - (void)addKeyObject:(type *)object
6888 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6889 std::string SelectorName
6890 = (Twine("add") + UpperKey + Twine("Object")).str();
6891 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6892 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6893 if (ReturnType.isNull()) {
6894 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6895 Builder.AddTextChunk("void");
6896 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6899 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6900 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6901 Builder.AddPlaceholderChunk("object-type");
6902 Builder.AddTextChunk(" *");
6903 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6904 Builder.AddTextChunk("object");
6905 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6906 CXCursor_ObjCInstanceMethodDecl));
6910 // - (void)addKey:(NSSet *)objects
6911 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6912 std::string SelectorName = (Twine("add") + UpperKey).str();
6913 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6914 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6915 if (ReturnType.isNull()) {
6916 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6917 Builder.AddTextChunk("void");
6918 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6921 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6922 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6923 Builder.AddTextChunk("NSSet *");
6924 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6925 Builder.AddTextChunk("objects");
6926 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6927 CXCursor_ObjCInstanceMethodDecl));
6931 // - (void)removeKeyObject:(type *)object
6932 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6933 std::string SelectorName
6934 = (Twine("remove") + UpperKey + Twine("Object")).str();
6935 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6936 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6937 if (ReturnType.isNull()) {
6938 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6939 Builder.AddTextChunk("void");
6940 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6943 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6944 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6945 Builder.AddPlaceholderChunk("object-type");
6946 Builder.AddTextChunk(" *");
6947 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6948 Builder.AddTextChunk("object");
6949 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6950 CXCursor_ObjCInstanceMethodDecl));
6954 // - (void)removeKey:(NSSet *)objects
6955 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6956 std::string SelectorName = (Twine("remove") + UpperKey).str();
6957 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6958 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6959 if (ReturnType.isNull()) {
6960 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6961 Builder.AddTextChunk("void");
6962 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6965 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6966 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6967 Builder.AddTextChunk("NSSet *");
6968 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6969 Builder.AddTextChunk("objects");
6970 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6971 CXCursor_ObjCInstanceMethodDecl));
6975 // - (void)intersectKey:(NSSet *)objects
6976 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6977 std::string SelectorName = (Twine("intersect") + UpperKey).str();
6978 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6979 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6980 if (ReturnType.isNull()) {
6981 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6982 Builder.AddTextChunk("void");
6983 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6986 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6987 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6988 Builder.AddTextChunk("NSSet *");
6989 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6990 Builder.AddTextChunk("objects");
6991 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6992 CXCursor_ObjCInstanceMethodDecl));
6996 // Key-Value Observing
6997 // + (NSSet *)keyPathsForValuesAffectingKey
6998 if (!IsInstanceMethod &&
6999 (ReturnType.isNull() ||
7000 (ReturnType->isObjCObjectPointerType() &&
7001 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7002 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
7003 ->getName() == "NSSet"))) {
7004 std::string SelectorName
7005 = (Twine("keyPathsForValuesAffecting") + UpperKey).str();
7006 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7007 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7009 if (ReturnType.isNull()) {
7010 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7011 Builder.AddTextChunk("NSSet *");
7012 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7015 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7016 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7017 CXCursor_ObjCClassMethodDecl));
7021 // + (BOOL)automaticallyNotifiesObserversForKey
7022 if (!IsInstanceMethod &&
7023 (ReturnType.isNull() ||
7024 ReturnType->isIntegerType() ||
7025 ReturnType->isBooleanType())) {
7026 std::string SelectorName
7027 = (Twine("automaticallyNotifiesObserversOf") + UpperKey).str();
7028 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7029 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7031 if (ReturnType.isNull()) {
7032 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7033 Builder.AddTextChunk("BOOL");
7034 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7037 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7038 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7039 CXCursor_ObjCClassMethodDecl));
7044 void Sema::CodeCompleteObjCMethodDecl(Scope *S,
7045 bool IsInstanceMethod,
7046 ParsedType ReturnTy) {
7047 // Determine the return type of the method we're declaring, if
7049 QualType ReturnType = GetTypeFromParser(ReturnTy);
7050 Decl *IDecl = nullptr;
7051 if (CurContext->isObjCContainer()) {
7052 ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
7053 IDecl = cast<Decl>(OCD);
7055 // Determine where we should start searching for methods.
7056 ObjCContainerDecl *SearchDecl = nullptr;
7057 bool IsInImplementation = false;
7058 if (Decl *D = IDecl) {
7059 if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) {
7060 SearchDecl = Impl->getClassInterface();
7061 IsInImplementation = true;
7062 } else if (ObjCCategoryImplDecl *CatImpl
7063 = dyn_cast<ObjCCategoryImplDecl>(D)) {
7064 SearchDecl = CatImpl->getCategoryDecl();
7065 IsInImplementation = true;
7067 SearchDecl = dyn_cast<ObjCContainerDecl>(D);
7070 if (!SearchDecl && S) {
7071 if (DeclContext *DC = S->getEntity())
7072 SearchDecl = dyn_cast<ObjCContainerDecl>(DC);
7076 HandleCodeCompleteResults(this, CodeCompleter,
7077 CodeCompletionContext::CCC_Other,
7082 // Find all of the methods that we could declare/implement here.
7083 KnownMethodsMap KnownMethods;
7084 FindImplementableMethods(Context, SearchDecl, IsInstanceMethod,
7085 ReturnType, KnownMethods);
7087 // Add declarations or definitions for each of the known methods.
7088 typedef CodeCompletionResult Result;
7089 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7090 CodeCompleter->getCodeCompletionTUInfo(),
7091 CodeCompletionContext::CCC_Other);
7092 Results.EnterNewScope();
7093 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
7094 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7095 MEnd = KnownMethods.end();
7097 ObjCMethodDecl *Method = M->second.getPointer();
7098 CodeCompletionBuilder Builder(Results.getAllocator(),
7099 Results.getCodeCompletionTUInfo());
7101 // If the result type was not already provided, add it to the
7102 // pattern as (type).
7103 if (ReturnType.isNull()) {
7104 QualType ResTy = Method->getSendResultType().stripObjCKindOfType(Context);
7105 AttributedType::stripOuterNullability(ResTy);
7106 AddObjCPassingTypeChunk(ResTy,
7107 Method->getObjCDeclQualifier(), Context, Policy,
7111 Selector Sel = Method->getSelector();
7113 // Add the first part of the selector to the pattern.
7114 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7115 Sel.getNameForSlot(0)));
7117 // Add parameters to the pattern.
7119 for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
7120 PEnd = Method->param_end();
7121 P != PEnd; (void)++P, ++I) {
7122 // Add the part of the selector name.
7124 Builder.AddTypedTextChunk(":");
7125 else if (I < Sel.getNumArgs()) {
7126 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7127 Builder.AddTypedTextChunk(
7128 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
7132 // Add the parameter type.
7134 if ((*P)->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
7135 ParamType = (*P)->getType();
7137 ParamType = (*P)->getOriginalType();
7138 ParamType = ParamType.substObjCTypeArgs(Context, {},
7139 ObjCSubstitutionContext::Parameter);
7140 AttributedType::stripOuterNullability(ParamType);
7141 AddObjCPassingTypeChunk(ParamType,
7142 (*P)->getObjCDeclQualifier(),
7146 if (IdentifierInfo *Id = (*P)->getIdentifier())
7147 Builder.AddTextChunk(Builder.getAllocator().CopyString( Id->getName()));
7150 if (Method->isVariadic()) {
7151 if (Method->param_size() > 0)
7152 Builder.AddChunk(CodeCompletionString::CK_Comma);
7153 Builder.AddTextChunk("...");
7156 if (IsInImplementation && Results.includeCodePatterns()) {
7157 // We will be defining the method here, so add a compound statement.
7158 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7159 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
7160 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
7161 if (!Method->getReturnType()->isVoidType()) {
7162 // If the result type is not void, add a return clause.
7163 Builder.AddTextChunk("return");
7164 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7165 Builder.AddPlaceholderChunk("expression");
7166 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
7168 Builder.AddPlaceholderChunk("statements");
7170 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
7171 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
7174 unsigned Priority = CCP_CodePattern;
7175 if (!M->second.getInt())
7176 Priority += CCD_InBaseClass;
7178 Results.AddResult(Result(Builder.TakeString(), Method, Priority));
7181 // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of
7182 // the properties in this class and its categories.
7183 if (Context.getLangOpts().ObjC2) {
7184 SmallVector<ObjCContainerDecl *, 4> Containers;
7185 Containers.push_back(SearchDecl);
7187 VisitedSelectorSet KnownSelectors;
7188 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7189 MEnd = KnownMethods.end();
7191 KnownSelectors.insert(M->first);
7194 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl);
7196 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl))
7197 IFace = Category->getClassInterface();
7200 for (auto *Cat : IFace->visible_categories())
7201 Containers.push_back(Cat);
7203 for (unsigned I = 0, N = Containers.size(); I != N; ++I)
7204 for (auto *P : Containers[I]->instance_properties())
7205 AddObjCKeyValueCompletions(P, IsInstanceMethod, ReturnType, Context,
7206 KnownSelectors, Results);
7209 Results.ExitScope();
7211 HandleCodeCompleteResults(this, CodeCompleter,
7212 CodeCompletionContext::CCC_Other,
7213 Results.data(),Results.size());
7216 void Sema::CodeCompleteObjCMethodDeclSelector(Scope *S,
7217 bool IsInstanceMethod,
7218 bool AtParameterName,
7219 ParsedType ReturnTy,
7220 ArrayRef<IdentifierInfo *> SelIdents) {
7221 // If we have an external source, load the entire class method
7222 // pool from the AST file.
7223 if (ExternalSource) {
7224 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
7226 Selector Sel = ExternalSource->GetExternalSelector(I);
7227 if (Sel.isNull() || MethodPool.count(Sel))
7230 ReadMethodPool(Sel);
7234 // Build the set of methods we can see.
7235 typedef CodeCompletionResult Result;
7236 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7237 CodeCompleter->getCodeCompletionTUInfo(),
7238 CodeCompletionContext::CCC_Other);
7241 Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType());
7243 Results.EnterNewScope();
7244 for (GlobalMethodPool::iterator M = MethodPool.begin(),
7245 MEnd = MethodPool.end();
7247 for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first :
7249 MethList && MethList->getMethod();
7250 MethList = MethList->getNext()) {
7251 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
7254 if (AtParameterName) {
7255 // Suggest parameter names we've seen before.
7256 unsigned NumSelIdents = SelIdents.size();
7258 NumSelIdents <= MethList->getMethod()->param_size()) {
7259 ParmVarDecl *Param =
7260 MethList->getMethod()->parameters()[NumSelIdents - 1];
7261 if (Param->getIdentifier()) {
7262 CodeCompletionBuilder Builder(Results.getAllocator(),
7263 Results.getCodeCompletionTUInfo());
7264 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7265 Param->getIdentifier()->getName()));
7266 Results.AddResult(Builder.TakeString());
7273 Result R(MethList->getMethod(),
7274 Results.getBasePriority(MethList->getMethod()), nullptr);
7275 R.StartParameter = SelIdents.size();
7276 R.AllParametersAreInformative = false;
7277 R.DeclaringEntity = true;
7278 Results.MaybeAddResult(R, CurContext);
7282 Results.ExitScope();
7283 HandleCodeCompleteResults(this, CodeCompleter,
7284 CodeCompletionContext::CCC_Other,
7285 Results.data(),Results.size());
7288 void Sema::CodeCompletePreprocessorDirective(bool InConditional) {
7289 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7290 CodeCompleter->getCodeCompletionTUInfo(),
7291 CodeCompletionContext::CCC_PreprocessorDirective);
7292 Results.EnterNewScope();
7295 CodeCompletionBuilder Builder(Results.getAllocator(),
7296 Results.getCodeCompletionTUInfo());
7297 Builder.AddTypedTextChunk("if");
7298 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7299 Builder.AddPlaceholderChunk("condition");
7300 Results.AddResult(Builder.TakeString());
7303 Builder.AddTypedTextChunk("ifdef");
7304 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7305 Builder.AddPlaceholderChunk("macro");
7306 Results.AddResult(Builder.TakeString());
7309 Builder.AddTypedTextChunk("ifndef");
7310 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7311 Builder.AddPlaceholderChunk("macro");
7312 Results.AddResult(Builder.TakeString());
7314 if (InConditional) {
7315 // #elif <condition>
7316 Builder.AddTypedTextChunk("elif");
7317 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7318 Builder.AddPlaceholderChunk("condition");
7319 Results.AddResult(Builder.TakeString());
7322 Builder.AddTypedTextChunk("else");
7323 Results.AddResult(Builder.TakeString());
7326 Builder.AddTypedTextChunk("endif");
7327 Results.AddResult(Builder.TakeString());
7330 // #include "header"
7331 Builder.AddTypedTextChunk("include");
7332 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7333 Builder.AddTextChunk("\"");
7334 Builder.AddPlaceholderChunk("header");
7335 Builder.AddTextChunk("\"");
7336 Results.AddResult(Builder.TakeString());
7338 // #include <header>
7339 Builder.AddTypedTextChunk("include");
7340 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7341 Builder.AddTextChunk("<");
7342 Builder.AddPlaceholderChunk("header");
7343 Builder.AddTextChunk(">");
7344 Results.AddResult(Builder.TakeString());
7347 Builder.AddTypedTextChunk("define");
7348 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7349 Builder.AddPlaceholderChunk("macro");
7350 Results.AddResult(Builder.TakeString());
7352 // #define <macro>(<args>)
7353 Builder.AddTypedTextChunk("define");
7354 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7355 Builder.AddPlaceholderChunk("macro");
7356 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7357 Builder.AddPlaceholderChunk("args");
7358 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7359 Results.AddResult(Builder.TakeString());
7362 Builder.AddTypedTextChunk("undef");
7363 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7364 Builder.AddPlaceholderChunk("macro");
7365 Results.AddResult(Builder.TakeString());
7368 Builder.AddTypedTextChunk("line");
7369 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7370 Builder.AddPlaceholderChunk("number");
7371 Results.AddResult(Builder.TakeString());
7373 // #line <number> "filename"
7374 Builder.AddTypedTextChunk("line");
7375 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7376 Builder.AddPlaceholderChunk("number");
7377 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7378 Builder.AddTextChunk("\"");
7379 Builder.AddPlaceholderChunk("filename");
7380 Builder.AddTextChunk("\"");
7381 Results.AddResult(Builder.TakeString());
7384 Builder.AddTypedTextChunk("error");
7385 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7386 Builder.AddPlaceholderChunk("message");
7387 Results.AddResult(Builder.TakeString());
7389 // #pragma <arguments>
7390 Builder.AddTypedTextChunk("pragma");
7391 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7392 Builder.AddPlaceholderChunk("arguments");
7393 Results.AddResult(Builder.TakeString());
7395 if (getLangOpts().ObjC1) {
7397 Builder.AddTypedTextChunk("import");
7398 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7399 Builder.AddTextChunk("\"");
7400 Builder.AddPlaceholderChunk("header");
7401 Builder.AddTextChunk("\"");
7402 Results.AddResult(Builder.TakeString());
7405 Builder.AddTypedTextChunk("import");
7406 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7407 Builder.AddTextChunk("<");
7408 Builder.AddPlaceholderChunk("header");
7409 Builder.AddTextChunk(">");
7410 Results.AddResult(Builder.TakeString());
7413 // #include_next "header"
7414 Builder.AddTypedTextChunk("include_next");
7415 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7416 Builder.AddTextChunk("\"");
7417 Builder.AddPlaceholderChunk("header");
7418 Builder.AddTextChunk("\"");
7419 Results.AddResult(Builder.TakeString());
7421 // #include_next <header>
7422 Builder.AddTypedTextChunk("include_next");
7423 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7424 Builder.AddTextChunk("<");
7425 Builder.AddPlaceholderChunk("header");
7426 Builder.AddTextChunk(">");
7427 Results.AddResult(Builder.TakeString());
7429 // #warning <message>
7430 Builder.AddTypedTextChunk("warning");
7431 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7432 Builder.AddPlaceholderChunk("message");
7433 Results.AddResult(Builder.TakeString());
7435 // Note: #ident and #sccs are such crazy anachronisms that we don't provide
7436 // completions for them. And __include_macros is a Clang-internal extension
7437 // that we don't want to encourage anyone to use.
7439 // FIXME: we don't support #assert or #unassert, so don't suggest them.
7440 Results.ExitScope();
7442 HandleCodeCompleteResults(this, CodeCompleter,
7443 CodeCompletionContext::CCC_PreprocessorDirective,
7444 Results.data(), Results.size());
7447 void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) {
7448 CodeCompleteOrdinaryName(S,
7449 S->getFnParent()? Sema::PCC_RecoveryInFunction
7450 : Sema::PCC_Namespace);
7453 void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) {
7454 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7455 CodeCompleter->getCodeCompletionTUInfo(),
7456 IsDefinition? CodeCompletionContext::CCC_MacroName
7457 : CodeCompletionContext::CCC_MacroNameUse);
7458 if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) {
7459 // Add just the names of macros, not their arguments.
7460 CodeCompletionBuilder Builder(Results.getAllocator(),
7461 Results.getCodeCompletionTUInfo());
7462 Results.EnterNewScope();
7463 for (Preprocessor::macro_iterator M = PP.macro_begin(),
7464 MEnd = PP.macro_end();
7466 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7467 M->first->getName()));
7468 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
7470 CXCursor_MacroDefinition));
7472 Results.ExitScope();
7473 } else if (IsDefinition) {
7474 // FIXME: Can we detect when the user just wrote an include guard above?
7477 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7478 Results.data(), Results.size());
7481 void Sema::CodeCompletePreprocessorExpression() {
7482 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7483 CodeCompleter->getCodeCompletionTUInfo(),
7484 CodeCompletionContext::CCC_PreprocessorExpression);
7486 if (!CodeCompleter || CodeCompleter->includeMacros())
7487 AddMacroResults(PP, Results, true);
7489 // defined (<macro>)
7490 Results.EnterNewScope();
7491 CodeCompletionBuilder Builder(Results.getAllocator(),
7492 Results.getCodeCompletionTUInfo());
7493 Builder.AddTypedTextChunk("defined");
7494 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7495 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7496 Builder.AddPlaceholderChunk("macro");
7497 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7498 Results.AddResult(Builder.TakeString());
7499 Results.ExitScope();
7501 HandleCodeCompleteResults(this, CodeCompleter,
7502 CodeCompletionContext::CCC_PreprocessorExpression,
7503 Results.data(), Results.size());
7506 void Sema::CodeCompletePreprocessorMacroArgument(Scope *S,
7507 IdentifierInfo *Macro,
7508 MacroInfo *MacroInfo,
7509 unsigned Argument) {
7510 // FIXME: In the future, we could provide "overload" results, much like we
7511 // do for function calls.
7513 // Now just ignore this. There will be another code-completion callback
7514 // for the expanded tokens.
7517 void Sema::CodeCompleteNaturalLanguage() {
7518 HandleCodeCompleteResults(this, CodeCompleter,
7519 CodeCompletionContext::CCC_NaturalLanguage,
7523 void Sema::GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,
7524 CodeCompletionTUInfo &CCTUInfo,
7525 SmallVectorImpl<CodeCompletionResult> &Results) {
7526 ResultBuilder Builder(*this, Allocator, CCTUInfo,
7527 CodeCompletionContext::CCC_Recovery);
7528 if (!CodeCompleter || CodeCompleter->includeGlobals()) {
7529 CodeCompletionDeclConsumer Consumer(Builder,
7530 Context.getTranslationUnitDecl());
7531 LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName,
7535 if (!CodeCompleter || CodeCompleter->includeMacros())
7536 AddMacroResults(PP, Builder, true);
7539 Results.insert(Results.end(),
7540 Builder.data(), Builder.data() + Builder.size());