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/ExternalSemaSource.h"
23 #include "clang/Sema/Lookup.h"
24 #include "clang/Sema/Overload.h"
25 #include "clang/Sema/Scope.h"
26 #include "clang/Sema/ScopeInfo.h"
27 #include "llvm/ADT/DenseSet.h"
28 #include "llvm/ADT/SmallBitVector.h"
29 #include "llvm/ADT/SmallPtrSet.h"
30 #include "llvm/ADT/SmallString.h"
31 #include "llvm/ADT/StringExtras.h"
32 #include "llvm/ADT/StringSwitch.h"
33 #include "llvm/ADT/Twine.h"
38 using namespace clang;
42 /// \brief A container of code-completion results.
45 /// \brief The type of a name-lookup filter, which can be provided to the
46 /// name-lookup routines to specify which declarations should be included in
47 /// the result set (when it returns true) and which declarations should be
48 /// filtered out (returns false).
49 typedef bool (ResultBuilder::*LookupFilter)(const NamedDecl *) const;
51 typedef CodeCompletionResult Result;
54 /// \brief The actual results we have found.
55 std::vector<Result> Results;
57 /// \brief A record of all of the declarations we have found and placed
58 /// into the result set, used to ensure that no declaration ever gets into
59 /// the result set twice.
60 llvm::SmallPtrSet<const Decl*, 16> AllDeclsFound;
62 typedef std::pair<const NamedDecl *, unsigned> DeclIndexPair;
64 /// \brief An entry in the shadow map, which is optimized to store
65 /// a single (declaration, index) mapping (the common case) but
66 /// can also store a list of (declaration, index) mappings.
67 class ShadowMapEntry {
68 typedef SmallVector<DeclIndexPair, 4> DeclIndexPairVector;
70 /// \brief Contains either the solitary NamedDecl * or a vector
71 /// of (declaration, index) pairs.
72 llvm::PointerUnion<const NamedDecl *, DeclIndexPairVector*> DeclOrVector;
74 /// \brief When the entry contains a single declaration, this is
75 /// the index associated with that entry.
76 unsigned SingleDeclIndex;
79 ShadowMapEntry() : DeclOrVector(), SingleDeclIndex(0) { }
81 void Add(const NamedDecl *ND, unsigned Index) {
82 if (DeclOrVector.isNull()) {
83 // 0 - > 1 elements: just set the single element information.
85 SingleDeclIndex = Index;
89 if (const NamedDecl *PrevND =
90 DeclOrVector.dyn_cast<const NamedDecl *>()) {
91 // 1 -> 2 elements: create the vector of results and push in the
92 // existing declaration.
93 DeclIndexPairVector *Vec = new DeclIndexPairVector;
94 Vec->push_back(DeclIndexPair(PrevND, SingleDeclIndex));
98 // Add the new element to the end of the vector.
99 DeclOrVector.get<DeclIndexPairVector*>()->push_back(
100 DeclIndexPair(ND, Index));
104 if (DeclIndexPairVector *Vec
105 = DeclOrVector.dyn_cast<DeclIndexPairVector *>()) {
107 DeclOrVector = ((NamedDecl *)nullptr);
113 iterator begin() const;
114 iterator end() const;
117 /// \brief A mapping from declaration names to the declarations that have
118 /// this name within a particular scope and their index within the list of
120 typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;
122 /// \brief The semantic analysis object for which results are being
126 /// \brief The allocator used to allocate new code-completion strings.
127 CodeCompletionAllocator &Allocator;
129 CodeCompletionTUInfo &CCTUInfo;
131 /// \brief If non-NULL, a filter function used to remove any code-completion
132 /// results that are not desirable.
135 /// \brief Whether we should allow declarations as
136 /// nested-name-specifiers that would otherwise be filtered out.
137 bool AllowNestedNameSpecifiers;
139 /// \brief If set, the type that we would prefer our resulting value
140 /// declarations to have.
142 /// Closely matching the preferred type gives a boost to a result's
144 CanQualType PreferredType;
146 /// \brief A list of shadow maps, which is used to model name hiding at
147 /// different levels of, e.g., the inheritance hierarchy.
148 std::list<ShadowMap> ShadowMaps;
150 /// \brief If we're potentially referring to a C++ member function, the set
151 /// of qualifiers applied to the object type.
152 Qualifiers ObjectTypeQualifiers;
154 /// \brief Whether the \p ObjectTypeQualifiers field is active.
155 bool HasObjectTypeQualifiers;
157 /// \brief The selector that we prefer.
158 Selector PreferredSelector;
160 /// \brief The completion context in which we are gathering results.
161 CodeCompletionContext CompletionContext;
163 /// \brief If we are in an instance method definition, the \@implementation
165 ObjCImplementationDecl *ObjCImplementation;
167 void AdjustResultPriorityForDecl(Result &R);
169 void MaybeAddConstructorResults(Result R);
172 explicit ResultBuilder(Sema &SemaRef, CodeCompletionAllocator &Allocator,
173 CodeCompletionTUInfo &CCTUInfo,
174 const CodeCompletionContext &CompletionContext,
175 LookupFilter Filter = nullptr)
176 : SemaRef(SemaRef), Allocator(Allocator), CCTUInfo(CCTUInfo),
178 AllowNestedNameSpecifiers(false), HasObjectTypeQualifiers(false),
179 CompletionContext(CompletionContext),
180 ObjCImplementation(nullptr)
182 // If this is an Objective-C instance method definition, dig out the
183 // corresponding implementation.
184 switch (CompletionContext.getKind()) {
185 case CodeCompletionContext::CCC_Expression:
186 case CodeCompletionContext::CCC_ObjCMessageReceiver:
187 case CodeCompletionContext::CCC_ParenthesizedExpression:
188 case CodeCompletionContext::CCC_Statement:
189 case CodeCompletionContext::CCC_Recovery:
190 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl())
191 if (Method->isInstanceMethod())
192 if (ObjCInterfaceDecl *Interface = Method->getClassInterface())
193 ObjCImplementation = Interface->getImplementation();
201 /// \brief Determine the priority for a reference to the given declaration.
202 unsigned getBasePriority(const NamedDecl *D);
204 /// \brief Whether we should include code patterns in the completion
206 bool includeCodePatterns() const {
207 return SemaRef.CodeCompleter &&
208 SemaRef.CodeCompleter->includeCodePatterns();
211 /// \brief Set the filter used for code-completion results.
212 void setFilter(LookupFilter Filter) {
213 this->Filter = Filter;
216 Result *data() { return Results.empty()? nullptr : &Results.front(); }
217 unsigned size() const { return Results.size(); }
218 bool empty() const { return Results.empty(); }
220 /// \brief Specify the preferred type.
221 void setPreferredType(QualType T) {
222 PreferredType = SemaRef.Context.getCanonicalType(T);
225 /// \brief Set the cv-qualifiers on the object type, for us in filtering
226 /// calls to member functions.
228 /// When there are qualifiers in this set, they will be used to filter
229 /// out member functions that aren't available (because there will be a
230 /// cv-qualifier mismatch) or prefer functions with an exact qualifier
232 void setObjectTypeQualifiers(Qualifiers Quals) {
233 ObjectTypeQualifiers = Quals;
234 HasObjectTypeQualifiers = true;
237 /// \brief Set the preferred selector.
239 /// When an Objective-C method declaration result is added, and that
240 /// method's selector matches this preferred selector, we give that method
241 /// a slight priority boost.
242 void setPreferredSelector(Selector Sel) {
243 PreferredSelector = Sel;
246 /// \brief Retrieve the code-completion context for which results are
248 const CodeCompletionContext &getCompletionContext() const {
249 return CompletionContext;
252 /// \brief Specify whether nested-name-specifiers are allowed.
253 void allowNestedNameSpecifiers(bool Allow = true) {
254 AllowNestedNameSpecifiers = Allow;
257 /// \brief Return the semantic analysis object for which we are collecting
258 /// code completion results.
259 Sema &getSema() const { return SemaRef; }
261 /// \brief Retrieve the allocator used to allocate code completion strings.
262 CodeCompletionAllocator &getAllocator() const { return Allocator; }
264 CodeCompletionTUInfo &getCodeCompletionTUInfo() const { return CCTUInfo; }
266 /// \brief Determine whether the given declaration is at all interesting
267 /// as a code-completion result.
269 /// \param ND the declaration that we are inspecting.
271 /// \param AsNestedNameSpecifier will be set true if this declaration is
272 /// only interesting when it is a nested-name-specifier.
273 bool isInterestingDecl(const NamedDecl *ND,
274 bool &AsNestedNameSpecifier) const;
276 /// \brief Check whether the result is hidden by the Hiding declaration.
278 /// \returns true if the result is hidden and cannot be found, false if
279 /// the hidden result could still be found. When false, \p R may be
280 /// modified to describe how the result can be found (e.g., via extra
282 bool CheckHiddenResult(Result &R, DeclContext *CurContext,
283 const NamedDecl *Hiding);
285 /// \brief Add a new result to this result set (if it isn't already in one
286 /// of the shadow maps), or replace an existing result (for, e.g., a
289 /// \param R the result to add (if it is unique).
291 /// \param CurContext the context in which this result will be named.
292 void MaybeAddResult(Result R, DeclContext *CurContext = nullptr);
294 /// \brief Add a new result to this result set, where we already know
295 /// the hiding declaration (if any).
297 /// \param R the result to add (if it is unique).
299 /// \param CurContext the context in which this result will be named.
301 /// \param Hiding the declaration that hides the result.
303 /// \param InBaseClass whether the result was found in a base
304 /// class of the searched context.
305 void AddResult(Result R, DeclContext *CurContext, NamedDecl *Hiding,
308 /// \brief Add a new non-declaration result to this result set.
309 void AddResult(Result R);
311 /// \brief Enter into a new scope.
312 void EnterNewScope();
314 /// \brief Exit from the current scope.
317 /// \brief Ignore this declaration, if it is seen again.
318 void Ignore(const Decl *D) { AllDeclsFound.insert(D->getCanonicalDecl()); }
320 /// \name Name lookup predicates
322 /// These predicates can be passed to the name lookup functions to filter the
323 /// results of name lookup. All of the predicates have the same type, so that
326 bool IsOrdinaryName(const NamedDecl *ND) const;
327 bool IsOrdinaryNonTypeName(const NamedDecl *ND) const;
328 bool IsIntegralConstantValue(const NamedDecl *ND) const;
329 bool IsOrdinaryNonValueName(const NamedDecl *ND) const;
330 bool IsNestedNameSpecifier(const NamedDecl *ND) const;
331 bool IsEnum(const NamedDecl *ND) const;
332 bool IsClassOrStruct(const NamedDecl *ND) const;
333 bool IsUnion(const NamedDecl *ND) const;
334 bool IsNamespace(const NamedDecl *ND) const;
335 bool IsNamespaceOrAlias(const NamedDecl *ND) const;
336 bool IsType(const NamedDecl *ND) const;
337 bool IsMember(const NamedDecl *ND) const;
338 bool IsObjCIvar(const NamedDecl *ND) const;
339 bool IsObjCMessageReceiver(const NamedDecl *ND) const;
340 bool IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const;
341 bool IsObjCCollection(const NamedDecl *ND) const;
342 bool IsImpossibleToSatisfy(const NamedDecl *ND) const;
347 class ResultBuilder::ShadowMapEntry::iterator {
348 llvm::PointerUnion<const NamedDecl *, const DeclIndexPair *> DeclOrIterator;
349 unsigned SingleDeclIndex;
352 typedef DeclIndexPair value_type;
353 typedef value_type reference;
354 typedef std::ptrdiff_t difference_type;
355 typedef std::input_iterator_tag iterator_category;
361 pointer(const DeclIndexPair &Value) : Value(Value) { }
363 const DeclIndexPair *operator->() const {
368 iterator() : DeclOrIterator((NamedDecl *)nullptr), SingleDeclIndex(0) {}
370 iterator(const NamedDecl *SingleDecl, unsigned Index)
371 : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) { }
373 iterator(const DeclIndexPair *Iterator)
374 : DeclOrIterator(Iterator), SingleDeclIndex(0) { }
376 iterator &operator++() {
377 if (DeclOrIterator.is<const NamedDecl *>()) {
378 DeclOrIterator = (NamedDecl *)nullptr;
383 const DeclIndexPair *I = DeclOrIterator.get<const DeclIndexPair*>();
389 /*iterator operator++(int) {
395 reference operator*() const {
396 if (const NamedDecl *ND = DeclOrIterator.dyn_cast<const NamedDecl *>())
397 return reference(ND, SingleDeclIndex);
399 return *DeclOrIterator.get<const DeclIndexPair*>();
402 pointer operator->() const {
403 return pointer(**this);
406 friend bool operator==(const iterator &X, const iterator &Y) {
407 return X.DeclOrIterator.getOpaqueValue()
408 == Y.DeclOrIterator.getOpaqueValue() &&
409 X.SingleDeclIndex == Y.SingleDeclIndex;
412 friend bool operator!=(const iterator &X, const iterator &Y) {
417 ResultBuilder::ShadowMapEntry::iterator
418 ResultBuilder::ShadowMapEntry::begin() const {
419 if (DeclOrVector.isNull())
422 if (const NamedDecl *ND = DeclOrVector.dyn_cast<const NamedDecl *>())
423 return iterator(ND, SingleDeclIndex);
425 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->begin());
428 ResultBuilder::ShadowMapEntry::iterator
429 ResultBuilder::ShadowMapEntry::end() const {
430 if (DeclOrVector.is<const NamedDecl *>() || DeclOrVector.isNull())
433 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end());
436 /// \brief Compute the qualification required to get from the current context
437 /// (\p CurContext) to the target context (\p TargetContext).
439 /// \param Context the AST context in which the qualification will be used.
441 /// \param CurContext the context where an entity is being named, which is
442 /// typically based on the current scope.
444 /// \param TargetContext the context in which the named entity actually
447 /// \returns a nested name specifier that refers into the target context, or
448 /// NULL if no qualification is needed.
449 static NestedNameSpecifier *
450 getRequiredQualification(ASTContext &Context,
451 const DeclContext *CurContext,
452 const DeclContext *TargetContext) {
453 SmallVector<const DeclContext *, 4> TargetParents;
455 for (const DeclContext *CommonAncestor = TargetContext;
456 CommonAncestor && !CommonAncestor->Encloses(CurContext);
457 CommonAncestor = CommonAncestor->getLookupParent()) {
458 if (CommonAncestor->isTransparentContext() ||
459 CommonAncestor->isFunctionOrMethod())
462 TargetParents.push_back(CommonAncestor);
465 NestedNameSpecifier *Result = nullptr;
466 while (!TargetParents.empty()) {
467 const DeclContext *Parent = TargetParents.pop_back_val();
469 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Parent)) {
470 if (!Namespace->getIdentifier())
473 Result = NestedNameSpecifier::Create(Context, Result, Namespace);
475 else if (const TagDecl *TD = dyn_cast<TagDecl>(Parent))
476 Result = NestedNameSpecifier::Create(Context, Result,
478 Context.getTypeDeclType(TD).getTypePtr());
483 /// Determine whether \p Id is a name reserved for the implementation (C99
484 /// 7.1.3, C++ [lib.global.names]).
485 static bool isReservedName(const IdentifierInfo *Id) {
486 if (Id->getLength() < 2)
488 const char *Name = Id->getNameStart();
489 return Name[0] == '_' &&
490 (Name[1] == '_' || (Name[1] >= 'A' && Name[1] <= 'Z'));
493 bool ResultBuilder::isInterestingDecl(const NamedDecl *ND,
494 bool &AsNestedNameSpecifier) const {
495 AsNestedNameSpecifier = false;
498 ND = ND->getUnderlyingDecl();
500 // Skip unnamed entities.
501 if (!ND->getDeclName())
504 // Friend declarations and declarations introduced due to friends are never
506 if (ND->getFriendObjectKind() == Decl::FOK_Undeclared)
509 // Class template (partial) specializations are never added as results.
510 if (isa<ClassTemplateSpecializationDecl>(ND) ||
511 isa<ClassTemplatePartialSpecializationDecl>(ND))
514 // Using declarations themselves are never added as results.
515 if (isa<UsingDecl>(ND))
518 // Some declarations have reserved names that we don't want to ever show.
519 // Filter out names reserved for the implementation if they come from a
521 // TODO: Add a predicate for this.
522 if (const IdentifierInfo *Id = ND->getIdentifier())
523 if (isReservedName(Id) &&
524 (ND->getLocation().isInvalid() ||
525 SemaRef.SourceMgr.isInSystemHeader(
526 SemaRef.SourceMgr.getSpellingLoc(ND->getLocation()))))
529 if (Filter == &ResultBuilder::IsNestedNameSpecifier ||
530 (isa<NamespaceDecl>(ND) &&
531 Filter != &ResultBuilder::IsNamespace &&
532 Filter != &ResultBuilder::IsNamespaceOrAlias &&
534 AsNestedNameSpecifier = true;
536 // Filter out any unwanted results.
537 if (Filter && !(this->*Filter)(Named)) {
538 // Check whether it is interesting as a nested-name-specifier.
539 if (AllowNestedNameSpecifiers && SemaRef.getLangOpts().CPlusPlus &&
540 IsNestedNameSpecifier(ND) &&
541 (Filter != &ResultBuilder::IsMember ||
542 (isa<CXXRecordDecl>(ND) &&
543 cast<CXXRecordDecl>(ND)->isInjectedClassName()))) {
544 AsNestedNameSpecifier = true;
550 // ... then it must be interesting!
554 bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext,
555 const NamedDecl *Hiding) {
556 // In C, there is no way to refer to a hidden name.
557 // FIXME: This isn't true; we can find a tag name hidden by an ordinary
558 // name if we introduce the tag type.
559 if (!SemaRef.getLangOpts().CPlusPlus)
562 const DeclContext *HiddenCtx =
563 R.Declaration->getDeclContext()->getRedeclContext();
565 // There is no way to qualify a name declared in a function or method.
566 if (HiddenCtx->isFunctionOrMethod())
569 if (HiddenCtx == Hiding->getDeclContext()->getRedeclContext())
572 // We can refer to the result with the appropriate qualification. Do it.
574 R.QualifierIsInformative = false;
577 R.Qualifier = getRequiredQualification(SemaRef.Context,
579 R.Declaration->getDeclContext());
583 /// \brief A simplified classification of types used to determine whether two
584 /// types are "similar enough" when adjusting priorities.
585 SimplifiedTypeClass clang::getSimplifiedTypeClass(CanQualType T) {
586 switch (T->getTypeClass()) {
588 switch (cast<BuiltinType>(T)->getKind()) {
589 case BuiltinType::Void:
592 case BuiltinType::NullPtr:
595 case BuiltinType::Overload:
596 case BuiltinType::Dependent:
599 case BuiltinType::ObjCId:
600 case BuiltinType::ObjCClass:
601 case BuiltinType::ObjCSel:
602 return STC_ObjectiveC;
605 return STC_Arithmetic;
609 return STC_Arithmetic;
614 case Type::BlockPointer:
617 case Type::LValueReference:
618 case Type::RValueReference:
619 return getSimplifiedTypeClass(T->getAs<ReferenceType>()->getPointeeType());
621 case Type::ConstantArray:
622 case Type::IncompleteArray:
623 case Type::VariableArray:
624 case Type::DependentSizedArray:
627 case Type::DependentSizedExtVector:
629 case Type::ExtVector:
630 return STC_Arithmetic;
632 case Type::FunctionProto:
633 case Type::FunctionNoProto:
640 return STC_Arithmetic;
642 case Type::ObjCObject:
643 case Type::ObjCInterface:
644 case Type::ObjCObjectPointer:
645 return STC_ObjectiveC;
652 /// \brief Get the type that a given expression will have if this declaration
653 /// is used as an expression in its "typical" code-completion form.
654 QualType clang::getDeclUsageType(ASTContext &C, const NamedDecl *ND) {
655 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
657 if (const TypeDecl *Type = dyn_cast<TypeDecl>(ND))
658 return C.getTypeDeclType(Type);
659 if (const ObjCInterfaceDecl *Iface = dyn_cast<ObjCInterfaceDecl>(ND))
660 return C.getObjCInterfaceType(Iface);
663 if (const FunctionDecl *Function = ND->getAsFunction())
664 T = Function->getCallResultType();
665 else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND))
666 T = Method->getSendResultType();
667 else if (const EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND))
668 T = C.getTypeDeclType(cast<EnumDecl>(Enumerator->getDeclContext()));
669 else if (const ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND))
670 T = Property->getType();
671 else if (const ValueDecl *Value = dyn_cast<ValueDecl>(ND))
672 T = Value->getType();
676 // Dig through references, function pointers, and block pointers to
677 // get down to the likely type of an expression when the entity is
680 if (const ReferenceType *Ref = T->getAs<ReferenceType>()) {
681 T = Ref->getPointeeType();
685 if (const PointerType *Pointer = T->getAs<PointerType>()) {
686 if (Pointer->getPointeeType()->isFunctionType()) {
687 T = Pointer->getPointeeType();
694 if (const BlockPointerType *Block = T->getAs<BlockPointerType>()) {
695 T = Block->getPointeeType();
699 if (const FunctionType *Function = T->getAs<FunctionType>()) {
700 T = Function->getReturnType();
710 unsigned ResultBuilder::getBasePriority(const NamedDecl *ND) {
714 // Context-based decisions.
715 const DeclContext *LexicalDC = ND->getLexicalDeclContext();
716 if (LexicalDC->isFunctionOrMethod()) {
717 // _cmd is relatively rare
718 if (const ImplicitParamDecl *ImplicitParam =
719 dyn_cast<ImplicitParamDecl>(ND))
720 if (ImplicitParam->getIdentifier() &&
721 ImplicitParam->getIdentifier()->isStr("_cmd"))
724 return CCP_LocalDeclaration;
727 const DeclContext *DC = ND->getDeclContext()->getRedeclContext();
728 if (DC->isRecord() || isa<ObjCContainerDecl>(DC))
729 return CCP_MemberDeclaration;
731 // Content-based decisions.
732 if (isa<EnumConstantDecl>(ND))
735 // Use CCP_Type for type declarations unless we're in a statement, Objective-C
736 // message receiver, or parenthesized expression context. There, it's as
737 // likely that the user will want to write a type as other declarations.
738 if ((isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) &&
739 !(CompletionContext.getKind() == CodeCompletionContext::CCC_Statement ||
740 CompletionContext.getKind()
741 == CodeCompletionContext::CCC_ObjCMessageReceiver ||
742 CompletionContext.getKind()
743 == CodeCompletionContext::CCC_ParenthesizedExpression))
746 return CCP_Declaration;
749 void ResultBuilder::AdjustResultPriorityForDecl(Result &R) {
750 // If this is an Objective-C method declaration whose selector matches our
751 // preferred selector, give it a priority boost.
752 if (!PreferredSelector.isNull())
753 if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(R.Declaration))
754 if (PreferredSelector == Method->getSelector())
755 R.Priority += CCD_SelectorMatch;
757 // If we have a preferred type, adjust the priority for results with exactly-
758 // matching or nearly-matching types.
759 if (!PreferredType.isNull()) {
760 QualType T = getDeclUsageType(SemaRef.Context, R.Declaration);
762 CanQualType TC = SemaRef.Context.getCanonicalType(T);
763 // Check for exactly-matching types (modulo qualifiers).
764 if (SemaRef.Context.hasSameUnqualifiedType(PreferredType, TC))
765 R.Priority /= CCF_ExactTypeMatch;
766 // Check for nearly-matching types, based on classification of each.
767 else if ((getSimplifiedTypeClass(PreferredType)
768 == getSimplifiedTypeClass(TC)) &&
769 !(PreferredType->isEnumeralType() && TC->isEnumeralType()))
770 R.Priority /= CCF_SimilarTypeMatch;
775 void ResultBuilder::MaybeAddConstructorResults(Result R) {
776 if (!SemaRef.getLangOpts().CPlusPlus || !R.Declaration ||
777 !CompletionContext.wantConstructorResults())
780 ASTContext &Context = SemaRef.Context;
781 const NamedDecl *D = R.Declaration;
782 const CXXRecordDecl *Record = nullptr;
783 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D))
784 Record = ClassTemplate->getTemplatedDecl();
785 else if ((Record = dyn_cast<CXXRecordDecl>(D))) {
786 // Skip specializations and partial specializations.
787 if (isa<ClassTemplateSpecializationDecl>(Record))
790 // There are no constructors here.
794 Record = Record->getDefinition();
799 QualType RecordTy = Context.getTypeDeclType(Record);
800 DeclarationName ConstructorName
801 = Context.DeclarationNames.getCXXConstructorName(
802 Context.getCanonicalType(RecordTy));
803 DeclContext::lookup_result Ctors = Record->lookup(ConstructorName);
804 for (DeclContext::lookup_iterator I = Ctors.begin(),
808 R.CursorKind = getCursorKindForDecl(R.Declaration);
809 Results.push_back(R);
813 void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) {
814 assert(!ShadowMaps.empty() && "Must enter into a results scope");
816 if (R.Kind != Result::RK_Declaration) {
817 // For non-declaration results, just add the result.
818 Results.push_back(R);
822 // Look through using declarations.
823 if (const UsingShadowDecl *Using =
824 dyn_cast<UsingShadowDecl>(R.Declaration)) {
825 MaybeAddResult(Result(Using->getTargetDecl(),
826 getBasePriority(Using->getTargetDecl()),
832 const Decl *CanonDecl = R.Declaration->getCanonicalDecl();
833 unsigned IDNS = CanonDecl->getIdentifierNamespace();
835 bool AsNestedNameSpecifier = false;
836 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
839 // C++ constructors are never found by name lookup.
840 if (isa<CXXConstructorDecl>(R.Declaration))
843 ShadowMap &SMap = ShadowMaps.back();
844 ShadowMapEntry::iterator I, IEnd;
845 ShadowMap::iterator NamePos = SMap.find(R.Declaration->getDeclName());
846 if (NamePos != SMap.end()) {
847 I = NamePos->second.begin();
848 IEnd = NamePos->second.end();
851 for (; I != IEnd; ++I) {
852 const NamedDecl *ND = I->first;
853 unsigned Index = I->second;
854 if (ND->getCanonicalDecl() == CanonDecl) {
855 // This is a redeclaration. Always pick the newer declaration.
856 Results[Index].Declaration = R.Declaration;
863 // This is a new declaration in this scope. However, check whether this
864 // declaration name is hidden by a similarly-named declaration in an outer
866 std::list<ShadowMap>::iterator SM, SMEnd = ShadowMaps.end();
868 for (SM = ShadowMaps.begin(); SM != SMEnd; ++SM) {
869 ShadowMapEntry::iterator I, IEnd;
870 ShadowMap::iterator NamePos = SM->find(R.Declaration->getDeclName());
871 if (NamePos != SM->end()) {
872 I = NamePos->second.begin();
873 IEnd = NamePos->second.end();
875 for (; I != IEnd; ++I) {
876 // A tag declaration does not hide a non-tag declaration.
877 if (I->first->hasTagIdentifierNamespace() &&
878 (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary |
879 Decl::IDNS_LocalExtern | Decl::IDNS_ObjCProtocol)))
882 // Protocols are in distinct namespaces from everything else.
883 if (((I->first->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol)
884 || (IDNS & Decl::IDNS_ObjCProtocol)) &&
885 I->first->getIdentifierNamespace() != IDNS)
888 // The newly-added result is hidden by an entry in the shadow map.
889 if (CheckHiddenResult(R, CurContext, I->first))
896 // Make sure that any given declaration only shows up in the result set once.
897 if (!AllDeclsFound.insert(CanonDecl).second)
900 // If the filter is for nested-name-specifiers, then this result starts a
901 // nested-name-specifier.
902 if (AsNestedNameSpecifier) {
903 R.StartsNestedNameSpecifier = true;
904 R.Priority = CCP_NestedNameSpecifier;
906 AdjustResultPriorityForDecl(R);
908 // If this result is supposed to have an informative qualifier, add one.
909 if (R.QualifierIsInformative && !R.Qualifier &&
910 !R.StartsNestedNameSpecifier) {
911 const DeclContext *Ctx = R.Declaration->getDeclContext();
912 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
913 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr,
915 else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
916 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr,
917 false, SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
919 R.QualifierIsInformative = false;
922 // Insert this result into the set of results and into the current shadow
924 SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size());
925 Results.push_back(R);
927 if (!AsNestedNameSpecifier)
928 MaybeAddConstructorResults(R);
931 void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
932 NamedDecl *Hiding, bool InBaseClass = false) {
933 if (R.Kind != Result::RK_Declaration) {
934 // For non-declaration results, just add the result.
935 Results.push_back(R);
939 // Look through using declarations.
940 if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
941 AddResult(Result(Using->getTargetDecl(),
942 getBasePriority(Using->getTargetDecl()),
948 bool AsNestedNameSpecifier = false;
949 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
952 // C++ constructors are never found by name lookup.
953 if (isa<CXXConstructorDecl>(R.Declaration))
956 if (Hiding && CheckHiddenResult(R, CurContext, Hiding))
959 // Make sure that any given declaration only shows up in the result set once.
960 if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl()).second)
963 // If the filter is for nested-name-specifiers, then this result starts a
964 // nested-name-specifier.
965 if (AsNestedNameSpecifier) {
966 R.StartsNestedNameSpecifier = true;
967 R.Priority = CCP_NestedNameSpecifier;
969 else if (Filter == &ResultBuilder::IsMember && !R.Qualifier && InBaseClass &&
970 isa<CXXRecordDecl>(R.Declaration->getDeclContext()
971 ->getRedeclContext()))
972 R.QualifierIsInformative = true;
974 // If this result is supposed to have an informative qualifier, add one.
975 if (R.QualifierIsInformative && !R.Qualifier &&
976 !R.StartsNestedNameSpecifier) {
977 const DeclContext *Ctx = R.Declaration->getDeclContext();
978 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
979 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr,
981 else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
982 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr, false,
983 SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
985 R.QualifierIsInformative = false;
988 // Adjust the priority if this result comes from a base class.
990 R.Priority += CCD_InBaseClass;
992 AdjustResultPriorityForDecl(R);
994 if (HasObjectTypeQualifiers)
995 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(R.Declaration))
996 if (Method->isInstance()) {
997 Qualifiers MethodQuals
998 = Qualifiers::fromCVRMask(Method->getTypeQualifiers());
999 if (ObjectTypeQualifiers == MethodQuals)
1000 R.Priority += CCD_ObjectQualifierMatch;
1001 else if (ObjectTypeQualifiers - MethodQuals) {
1002 // The method cannot be invoked, because doing so would drop
1008 // Insert this result into the set of results.
1009 Results.push_back(R);
1011 if (!AsNestedNameSpecifier)
1012 MaybeAddConstructorResults(R);
1015 void ResultBuilder::AddResult(Result R) {
1016 assert(R.Kind != Result::RK_Declaration &&
1017 "Declaration results need more context");
1018 Results.push_back(R);
1021 /// \brief Enter into a new scope.
1022 void ResultBuilder::EnterNewScope() { ShadowMaps.emplace_back(); }
1024 /// \brief Exit from the current scope.
1025 void ResultBuilder::ExitScope() {
1026 for (ShadowMap::iterator E = ShadowMaps.back().begin(),
1027 EEnd = ShadowMaps.back().end();
1030 E->second.Destroy();
1032 ShadowMaps.pop_back();
1035 /// \brief Determines whether this given declaration will be found by
1036 /// ordinary name lookup.
1037 bool ResultBuilder::IsOrdinaryName(const NamedDecl *ND) const {
1038 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
1040 // If name lookup finds a local extern declaration, then we are in a
1041 // context where it behaves like an ordinary name.
1042 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1043 if (SemaRef.getLangOpts().CPlusPlus)
1044 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
1045 else if (SemaRef.getLangOpts().ObjC1) {
1046 if (isa<ObjCIvarDecl>(ND))
1050 return ND->getIdentifierNamespace() & IDNS;
1053 /// \brief Determines whether this given declaration will be found by
1054 /// ordinary name lookup but is not a type name.
1055 bool ResultBuilder::IsOrdinaryNonTypeName(const NamedDecl *ND) const {
1056 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
1057 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND))
1060 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1061 if (SemaRef.getLangOpts().CPlusPlus)
1062 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
1063 else if (SemaRef.getLangOpts().ObjC1) {
1064 if (isa<ObjCIvarDecl>(ND))
1068 return ND->getIdentifierNamespace() & IDNS;
1071 bool ResultBuilder::IsIntegralConstantValue(const NamedDecl *ND) const {
1072 if (!IsOrdinaryNonTypeName(ND))
1075 if (const ValueDecl *VD = dyn_cast<ValueDecl>(ND->getUnderlyingDecl()))
1076 if (VD->getType()->isIntegralOrEnumerationType())
1082 /// \brief Determines whether this given declaration will be found by
1083 /// ordinary name lookup.
1084 bool ResultBuilder::IsOrdinaryNonValueName(const NamedDecl *ND) const {
1085 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
1087 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1088 if (SemaRef.getLangOpts().CPlusPlus)
1089 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace;
1091 return (ND->getIdentifierNamespace() & IDNS) &&
1092 !isa<ValueDecl>(ND) && !isa<FunctionTemplateDecl>(ND) &&
1093 !isa<ObjCPropertyDecl>(ND);
1096 /// \brief Determines whether the given declaration is suitable as the
1097 /// start of a C++ nested-name-specifier, e.g., a class or namespace.
1098 bool ResultBuilder::IsNestedNameSpecifier(const NamedDecl *ND) const {
1099 // Allow us to find class templates, too.
1100 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1101 ND = ClassTemplate->getTemplatedDecl();
1103 return SemaRef.isAcceptableNestedNameSpecifier(ND);
1106 /// \brief Determines whether the given declaration is an enumeration.
1107 bool ResultBuilder::IsEnum(const NamedDecl *ND) const {
1108 return isa<EnumDecl>(ND);
1111 /// \brief Determines whether the given declaration is a class or struct.
1112 bool ResultBuilder::IsClassOrStruct(const NamedDecl *ND) const {
1113 // Allow us to find class templates, too.
1114 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1115 ND = ClassTemplate->getTemplatedDecl();
1117 // For purposes of this check, interfaces match too.
1118 if (const RecordDecl *RD = dyn_cast<RecordDecl>(ND))
1119 return RD->getTagKind() == TTK_Class ||
1120 RD->getTagKind() == TTK_Struct ||
1121 RD->getTagKind() == TTK_Interface;
1126 /// \brief Determines whether the given declaration is a union.
1127 bool ResultBuilder::IsUnion(const NamedDecl *ND) const {
1128 // Allow us to find class templates, too.
1129 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1130 ND = ClassTemplate->getTemplatedDecl();
1132 if (const RecordDecl *RD = dyn_cast<RecordDecl>(ND))
1133 return RD->getTagKind() == TTK_Union;
1138 /// \brief Determines whether the given declaration is a namespace.
1139 bool ResultBuilder::IsNamespace(const NamedDecl *ND) const {
1140 return isa<NamespaceDecl>(ND);
1143 /// \brief Determines whether the given declaration is a namespace or
1144 /// namespace alias.
1145 bool ResultBuilder::IsNamespaceOrAlias(const NamedDecl *ND) const {
1146 return isa<NamespaceDecl>(ND->getUnderlyingDecl());
1149 /// \brief Determines whether the given declaration is a type.
1150 bool ResultBuilder::IsType(const NamedDecl *ND) const {
1151 ND = ND->getUnderlyingDecl();
1152 return isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
1155 /// \brief Determines which members of a class should be visible via
1156 /// "." or "->". Only value declarations, nested name specifiers, and
1157 /// using declarations thereof should show up.
1158 bool ResultBuilder::IsMember(const NamedDecl *ND) const {
1159 ND = ND->getUnderlyingDecl();
1160 return isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND) ||
1161 isa<ObjCPropertyDecl>(ND);
1164 static bool isObjCReceiverType(ASTContext &C, QualType T) {
1165 T = C.getCanonicalType(T);
1166 switch (T->getTypeClass()) {
1167 case Type::ObjCObject:
1168 case Type::ObjCInterface:
1169 case Type::ObjCObjectPointer:
1173 switch (cast<BuiltinType>(T)->getKind()) {
1174 case BuiltinType::ObjCId:
1175 case BuiltinType::ObjCClass:
1176 case BuiltinType::ObjCSel:
1188 if (!C.getLangOpts().CPlusPlus)
1191 // FIXME: We could perform more analysis here to determine whether a
1192 // particular class type has any conversions to Objective-C types. For now,
1193 // just accept all class types.
1194 return T->isDependentType() || T->isRecordType();
1197 bool ResultBuilder::IsObjCMessageReceiver(const NamedDecl *ND) const {
1198 QualType T = getDeclUsageType(SemaRef.Context, ND);
1202 T = SemaRef.Context.getBaseElementType(T);
1203 return isObjCReceiverType(SemaRef.Context, T);
1206 bool ResultBuilder::IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const {
1207 if (IsObjCMessageReceiver(ND))
1210 const VarDecl *Var = dyn_cast<VarDecl>(ND);
1214 return Var->hasLocalStorage() && !Var->hasAttr<BlocksAttr>();
1217 bool ResultBuilder::IsObjCCollection(const NamedDecl *ND) const {
1218 if ((SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryName(ND)) ||
1219 (!SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryNonTypeName(ND)))
1222 QualType T = getDeclUsageType(SemaRef.Context, ND);
1226 T = SemaRef.Context.getBaseElementType(T);
1227 return T->isObjCObjectType() || T->isObjCObjectPointerType() ||
1228 T->isObjCIdType() ||
1229 (SemaRef.getLangOpts().CPlusPlus && T->isRecordType());
1232 bool ResultBuilder::IsImpossibleToSatisfy(const NamedDecl *ND) const {
1236 /// \brief Determines whether the given declaration is an Objective-C
1237 /// instance variable.
1238 bool ResultBuilder::IsObjCIvar(const NamedDecl *ND) const {
1239 return isa<ObjCIvarDecl>(ND);
1243 /// \brief Visible declaration consumer that adds a code-completion result
1244 /// for each visible declaration.
1245 class CodeCompletionDeclConsumer : public VisibleDeclConsumer {
1246 ResultBuilder &Results;
1247 DeclContext *CurContext;
1250 CodeCompletionDeclConsumer(ResultBuilder &Results, DeclContext *CurContext)
1251 : Results(Results), CurContext(CurContext) { }
1253 void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,
1254 bool InBaseClass) override {
1255 bool Accessible = true;
1257 Accessible = Results.getSema().IsSimplyAccessible(ND, Ctx);
1259 ResultBuilder::Result Result(ND, Results.getBasePriority(ND), nullptr,
1261 Results.AddResult(Result, CurContext, Hiding, InBaseClass);
1266 /// \brief Add type specifiers for the current language as keyword results.
1267 static void AddTypeSpecifierResults(const LangOptions &LangOpts,
1268 ResultBuilder &Results) {
1269 typedef CodeCompletionResult Result;
1270 Results.AddResult(Result("short", CCP_Type));
1271 Results.AddResult(Result("long", CCP_Type));
1272 Results.AddResult(Result("signed", CCP_Type));
1273 Results.AddResult(Result("unsigned", CCP_Type));
1274 Results.AddResult(Result("void", CCP_Type));
1275 Results.AddResult(Result("char", CCP_Type));
1276 Results.AddResult(Result("int", CCP_Type));
1277 Results.AddResult(Result("float", CCP_Type));
1278 Results.AddResult(Result("double", CCP_Type));
1279 Results.AddResult(Result("enum", CCP_Type));
1280 Results.AddResult(Result("struct", CCP_Type));
1281 Results.AddResult(Result("union", CCP_Type));
1282 Results.AddResult(Result("const", CCP_Type));
1283 Results.AddResult(Result("volatile", CCP_Type));
1287 Results.AddResult(Result("_Complex", CCP_Type));
1288 Results.AddResult(Result("_Imaginary", CCP_Type));
1289 Results.AddResult(Result("_Bool", CCP_Type));
1290 Results.AddResult(Result("restrict", CCP_Type));
1293 CodeCompletionBuilder Builder(Results.getAllocator(),
1294 Results.getCodeCompletionTUInfo());
1295 if (LangOpts.CPlusPlus) {
1297 Results.AddResult(Result("bool", CCP_Type +
1298 (LangOpts.ObjC1? CCD_bool_in_ObjC : 0)));
1299 Results.AddResult(Result("class", CCP_Type));
1300 Results.AddResult(Result("wchar_t", CCP_Type));
1302 // typename qualified-id
1303 Builder.AddTypedTextChunk("typename");
1304 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1305 Builder.AddPlaceholderChunk("qualifier");
1306 Builder.AddTextChunk("::");
1307 Builder.AddPlaceholderChunk("name");
1308 Results.AddResult(Result(Builder.TakeString()));
1310 if (LangOpts.CPlusPlus11) {
1311 Results.AddResult(Result("auto", CCP_Type));
1312 Results.AddResult(Result("char16_t", CCP_Type));
1313 Results.AddResult(Result("char32_t", CCP_Type));
1315 Builder.AddTypedTextChunk("decltype");
1316 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1317 Builder.AddPlaceholderChunk("expression");
1318 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1319 Results.AddResult(Result(Builder.TakeString()));
1324 if (LangOpts.GNUMode) {
1325 // FIXME: Enable when we actually support decimal floating point.
1326 // Results.AddResult(Result("_Decimal32"));
1327 // Results.AddResult(Result("_Decimal64"));
1328 // Results.AddResult(Result("_Decimal128"));
1330 Builder.AddTypedTextChunk("typeof");
1331 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1332 Builder.AddPlaceholderChunk("expression");
1333 Results.AddResult(Result(Builder.TakeString()));
1335 Builder.AddTypedTextChunk("typeof");
1336 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1337 Builder.AddPlaceholderChunk("type");
1338 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1339 Results.AddResult(Result(Builder.TakeString()));
1343 Results.AddResult(Result("_Nonnull", CCP_Type));
1344 Results.AddResult(Result("_Null_unspecified", CCP_Type));
1345 Results.AddResult(Result("_Nullable", CCP_Type));
1348 static void AddStorageSpecifiers(Sema::ParserCompletionContext CCC,
1349 const LangOptions &LangOpts,
1350 ResultBuilder &Results) {
1351 typedef CodeCompletionResult Result;
1352 // Note: we don't suggest either "auto" or "register", because both
1353 // are pointless as storage specifiers. Elsewhere, we suggest "auto"
1354 // in C++0x as a type specifier.
1355 Results.AddResult(Result("extern"));
1356 Results.AddResult(Result("static"));
1359 static void AddFunctionSpecifiers(Sema::ParserCompletionContext CCC,
1360 const LangOptions &LangOpts,
1361 ResultBuilder &Results) {
1362 typedef CodeCompletionResult Result;
1364 case Sema::PCC_Class:
1365 case Sema::PCC_MemberTemplate:
1366 if (LangOpts.CPlusPlus) {
1367 Results.AddResult(Result("explicit"));
1368 Results.AddResult(Result("friend"));
1369 Results.AddResult(Result("mutable"));
1370 Results.AddResult(Result("virtual"));
1374 case Sema::PCC_ObjCInterface:
1375 case Sema::PCC_ObjCImplementation:
1376 case Sema::PCC_Namespace:
1377 case Sema::PCC_Template:
1378 if (LangOpts.CPlusPlus || LangOpts.C99)
1379 Results.AddResult(Result("inline"));
1382 case Sema::PCC_ObjCInstanceVariableList:
1383 case Sema::PCC_Expression:
1384 case Sema::PCC_Statement:
1385 case Sema::PCC_ForInit:
1386 case Sema::PCC_Condition:
1387 case Sema::PCC_RecoveryInFunction:
1388 case Sema::PCC_Type:
1389 case Sema::PCC_ParenthesizedExpression:
1390 case Sema::PCC_LocalDeclarationSpecifiers:
1395 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt);
1396 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt);
1397 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
1398 ResultBuilder &Results,
1400 static void AddObjCImplementationResults(const LangOptions &LangOpts,
1401 ResultBuilder &Results,
1403 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
1404 ResultBuilder &Results,
1406 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt);
1408 static void AddTypedefResult(ResultBuilder &Results) {
1409 CodeCompletionBuilder Builder(Results.getAllocator(),
1410 Results.getCodeCompletionTUInfo());
1411 Builder.AddTypedTextChunk("typedef");
1412 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1413 Builder.AddPlaceholderChunk("type");
1414 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1415 Builder.AddPlaceholderChunk("name");
1416 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1419 static bool WantTypesInContext(Sema::ParserCompletionContext CCC,
1420 const LangOptions &LangOpts) {
1422 case Sema::PCC_Namespace:
1423 case Sema::PCC_Class:
1424 case Sema::PCC_ObjCInstanceVariableList:
1425 case Sema::PCC_Template:
1426 case Sema::PCC_MemberTemplate:
1427 case Sema::PCC_Statement:
1428 case Sema::PCC_RecoveryInFunction:
1429 case Sema::PCC_Type:
1430 case Sema::PCC_ParenthesizedExpression:
1431 case Sema::PCC_LocalDeclarationSpecifiers:
1434 case Sema::PCC_Expression:
1435 case Sema::PCC_Condition:
1436 return LangOpts.CPlusPlus;
1438 case Sema::PCC_ObjCInterface:
1439 case Sema::PCC_ObjCImplementation:
1442 case Sema::PCC_ForInit:
1443 return LangOpts.CPlusPlus || LangOpts.ObjC1 || LangOpts.C99;
1446 llvm_unreachable("Invalid ParserCompletionContext!");
1449 static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context,
1450 const Preprocessor &PP) {
1451 PrintingPolicy Policy = Sema::getPrintingPolicy(Context, PP);
1452 Policy.AnonymousTagLocations = false;
1453 Policy.SuppressStrongLifetime = true;
1454 Policy.SuppressUnwrittenScope = true;
1458 /// \brief Retrieve a printing policy suitable for code completion.
1459 static PrintingPolicy getCompletionPrintingPolicy(Sema &S) {
1460 return getCompletionPrintingPolicy(S.Context, S.PP);
1463 /// \brief Retrieve the string representation of the given type as a string
1464 /// that has the appropriate lifetime for code completion.
1466 /// This routine provides a fast path where we provide constant strings for
1467 /// common type names.
1468 static const char *GetCompletionTypeString(QualType T,
1469 ASTContext &Context,
1470 const PrintingPolicy &Policy,
1471 CodeCompletionAllocator &Allocator) {
1472 if (!T.getLocalQualifiers()) {
1473 // Built-in type names are constant strings.
1474 if (const BuiltinType *BT = dyn_cast<BuiltinType>(T))
1475 return BT->getNameAsCString(Policy);
1477 // Anonymous tag types are constant strings.
1478 if (const TagType *TagT = dyn_cast<TagType>(T))
1479 if (TagDecl *Tag = TagT->getDecl())
1480 if (!Tag->hasNameForLinkage()) {
1481 switch (Tag->getTagKind()) {
1482 case TTK_Struct: return "struct <anonymous>";
1483 case TTK_Interface: return "__interface <anonymous>";
1484 case TTK_Class: return "class <anonymous>";
1485 case TTK_Union: return "union <anonymous>";
1486 case TTK_Enum: return "enum <anonymous>";
1491 // Slow path: format the type as a string.
1493 T.getAsStringInternal(Result, Policy);
1494 return Allocator.CopyString(Result);
1497 /// \brief Add a completion for "this", if we're in a member function.
1498 static void addThisCompletion(Sema &S, ResultBuilder &Results) {
1499 QualType ThisTy = S.getCurrentThisType();
1500 if (ThisTy.isNull())
1503 CodeCompletionAllocator &Allocator = Results.getAllocator();
1504 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1505 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
1506 Builder.AddResultTypeChunk(GetCompletionTypeString(ThisTy,
1510 Builder.AddTypedTextChunk("this");
1511 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1514 /// \brief Add language constructs that show up for "ordinary" names.
1515 static void AddOrdinaryNameResults(Sema::ParserCompletionContext CCC,
1518 ResultBuilder &Results) {
1519 CodeCompletionAllocator &Allocator = Results.getAllocator();
1520 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1521 PrintingPolicy Policy = getCompletionPrintingPolicy(SemaRef);
1523 typedef CodeCompletionResult Result;
1525 case Sema::PCC_Namespace:
1526 if (SemaRef.getLangOpts().CPlusPlus) {
1527 if (Results.includeCodePatterns()) {
1528 // namespace <identifier> { declarations }
1529 Builder.AddTypedTextChunk("namespace");
1530 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1531 Builder.AddPlaceholderChunk("identifier");
1532 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1533 Builder.AddPlaceholderChunk("declarations");
1534 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1535 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1536 Results.AddResult(Result(Builder.TakeString()));
1539 // namespace identifier = identifier ;
1540 Builder.AddTypedTextChunk("namespace");
1541 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1542 Builder.AddPlaceholderChunk("name");
1543 Builder.AddChunk(CodeCompletionString::CK_Equal);
1544 Builder.AddPlaceholderChunk("namespace");
1545 Results.AddResult(Result(Builder.TakeString()));
1548 Builder.AddTypedTextChunk("using");
1549 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1550 Builder.AddTextChunk("namespace");
1551 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1552 Builder.AddPlaceholderChunk("identifier");
1553 Results.AddResult(Result(Builder.TakeString()));
1555 // asm(string-literal)
1556 Builder.AddTypedTextChunk("asm");
1557 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1558 Builder.AddPlaceholderChunk("string-literal");
1559 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1560 Results.AddResult(Result(Builder.TakeString()));
1562 if (Results.includeCodePatterns()) {
1563 // Explicit template instantiation
1564 Builder.AddTypedTextChunk("template");
1565 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1566 Builder.AddPlaceholderChunk("declaration");
1567 Results.AddResult(Result(Builder.TakeString()));
1571 if (SemaRef.getLangOpts().ObjC1)
1572 AddObjCTopLevelResults(Results, true);
1574 AddTypedefResult(Results);
1577 case Sema::PCC_Class:
1578 if (SemaRef.getLangOpts().CPlusPlus) {
1579 // Using declaration
1580 Builder.AddTypedTextChunk("using");
1581 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1582 Builder.AddPlaceholderChunk("qualifier");
1583 Builder.AddTextChunk("::");
1584 Builder.AddPlaceholderChunk("name");
1585 Results.AddResult(Result(Builder.TakeString()));
1587 // using typename qualifier::name (only in a dependent context)
1588 if (SemaRef.CurContext->isDependentContext()) {
1589 Builder.AddTypedTextChunk("using");
1590 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1591 Builder.AddTextChunk("typename");
1592 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1593 Builder.AddPlaceholderChunk("qualifier");
1594 Builder.AddTextChunk("::");
1595 Builder.AddPlaceholderChunk("name");
1596 Results.AddResult(Result(Builder.TakeString()));
1599 if (CCC == Sema::PCC_Class) {
1600 AddTypedefResult(Results);
1603 Builder.AddTypedTextChunk("public");
1604 if (Results.includeCodePatterns())
1605 Builder.AddChunk(CodeCompletionString::CK_Colon);
1606 Results.AddResult(Result(Builder.TakeString()));
1609 Builder.AddTypedTextChunk("protected");
1610 if (Results.includeCodePatterns())
1611 Builder.AddChunk(CodeCompletionString::CK_Colon);
1612 Results.AddResult(Result(Builder.TakeString()));
1615 Builder.AddTypedTextChunk("private");
1616 if (Results.includeCodePatterns())
1617 Builder.AddChunk(CodeCompletionString::CK_Colon);
1618 Results.AddResult(Result(Builder.TakeString()));
1623 case Sema::PCC_Template:
1624 case Sema::PCC_MemberTemplate:
1625 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns()) {
1626 // template < parameters >
1627 Builder.AddTypedTextChunk("template");
1628 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1629 Builder.AddPlaceholderChunk("parameters");
1630 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1631 Results.AddResult(Result(Builder.TakeString()));
1634 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1635 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1638 case Sema::PCC_ObjCInterface:
1639 AddObjCInterfaceResults(SemaRef.getLangOpts(), Results, true);
1640 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1641 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1644 case Sema::PCC_ObjCImplementation:
1645 AddObjCImplementationResults(SemaRef.getLangOpts(), Results, true);
1646 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1647 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1650 case Sema::PCC_ObjCInstanceVariableList:
1651 AddObjCVisibilityResults(SemaRef.getLangOpts(), Results, true);
1654 case Sema::PCC_RecoveryInFunction:
1655 case Sema::PCC_Statement: {
1656 AddTypedefResult(Results);
1658 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns() &&
1659 SemaRef.getLangOpts().CXXExceptions) {
1660 Builder.AddTypedTextChunk("try");
1661 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1662 Builder.AddPlaceholderChunk("statements");
1663 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1664 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1665 Builder.AddTextChunk("catch");
1666 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1667 Builder.AddPlaceholderChunk("declaration");
1668 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1669 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1670 Builder.AddPlaceholderChunk("statements");
1671 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1672 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1673 Results.AddResult(Result(Builder.TakeString()));
1675 if (SemaRef.getLangOpts().ObjC1)
1676 AddObjCStatementResults(Results, true);
1678 if (Results.includeCodePatterns()) {
1679 // if (condition) { statements }
1680 Builder.AddTypedTextChunk("if");
1681 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1682 if (SemaRef.getLangOpts().CPlusPlus)
1683 Builder.AddPlaceholderChunk("condition");
1685 Builder.AddPlaceholderChunk("expression");
1686 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1687 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1688 Builder.AddPlaceholderChunk("statements");
1689 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1690 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1691 Results.AddResult(Result(Builder.TakeString()));
1693 // switch (condition) { }
1694 Builder.AddTypedTextChunk("switch");
1695 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1696 if (SemaRef.getLangOpts().CPlusPlus)
1697 Builder.AddPlaceholderChunk("condition");
1699 Builder.AddPlaceholderChunk("expression");
1700 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1701 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1702 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1703 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1704 Results.AddResult(Result(Builder.TakeString()));
1707 // Switch-specific statements.
1708 if (!SemaRef.getCurFunction()->SwitchStack.empty()) {
1710 Builder.AddTypedTextChunk("case");
1711 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1712 Builder.AddPlaceholderChunk("expression");
1713 Builder.AddChunk(CodeCompletionString::CK_Colon);
1714 Results.AddResult(Result(Builder.TakeString()));
1717 Builder.AddTypedTextChunk("default");
1718 Builder.AddChunk(CodeCompletionString::CK_Colon);
1719 Results.AddResult(Result(Builder.TakeString()));
1722 if (Results.includeCodePatterns()) {
1723 /// while (condition) { statements }
1724 Builder.AddTypedTextChunk("while");
1725 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1726 if (SemaRef.getLangOpts().CPlusPlus)
1727 Builder.AddPlaceholderChunk("condition");
1729 Builder.AddPlaceholderChunk("expression");
1730 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1731 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1732 Builder.AddPlaceholderChunk("statements");
1733 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1734 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1735 Results.AddResult(Result(Builder.TakeString()));
1737 // do { statements } while ( expression );
1738 Builder.AddTypedTextChunk("do");
1739 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1740 Builder.AddPlaceholderChunk("statements");
1741 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1742 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1743 Builder.AddTextChunk("while");
1744 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1745 Builder.AddPlaceholderChunk("expression");
1746 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1747 Results.AddResult(Result(Builder.TakeString()));
1749 // for ( for-init-statement ; condition ; expression ) { statements }
1750 Builder.AddTypedTextChunk("for");
1751 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1752 if (SemaRef.getLangOpts().CPlusPlus || SemaRef.getLangOpts().C99)
1753 Builder.AddPlaceholderChunk("init-statement");
1755 Builder.AddPlaceholderChunk("init-expression");
1756 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1757 Builder.AddPlaceholderChunk("condition");
1758 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1759 Builder.AddPlaceholderChunk("inc-expression");
1760 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1761 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1762 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1763 Builder.AddPlaceholderChunk("statements");
1764 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1765 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1766 Results.AddResult(Result(Builder.TakeString()));
1769 if (S->getContinueParent()) {
1771 Builder.AddTypedTextChunk("continue");
1772 Results.AddResult(Result(Builder.TakeString()));
1775 if (S->getBreakParent()) {
1777 Builder.AddTypedTextChunk("break");
1778 Results.AddResult(Result(Builder.TakeString()));
1781 // "return expression ;" or "return ;", depending on whether we
1782 // know the function is void or not.
1783 bool isVoid = false;
1784 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(SemaRef.CurContext))
1785 isVoid = Function->getReturnType()->isVoidType();
1786 else if (ObjCMethodDecl *Method
1787 = dyn_cast<ObjCMethodDecl>(SemaRef.CurContext))
1788 isVoid = Method->getReturnType()->isVoidType();
1789 else if (SemaRef.getCurBlock() &&
1790 !SemaRef.getCurBlock()->ReturnType.isNull())
1791 isVoid = SemaRef.getCurBlock()->ReturnType->isVoidType();
1792 Builder.AddTypedTextChunk("return");
1794 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1795 Builder.AddPlaceholderChunk("expression");
1797 Results.AddResult(Result(Builder.TakeString()));
1799 // goto identifier ;
1800 Builder.AddTypedTextChunk("goto");
1801 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1802 Builder.AddPlaceholderChunk("label");
1803 Results.AddResult(Result(Builder.TakeString()));
1806 Builder.AddTypedTextChunk("using");
1807 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1808 Builder.AddTextChunk("namespace");
1809 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1810 Builder.AddPlaceholderChunk("identifier");
1811 Results.AddResult(Result(Builder.TakeString()));
1814 // Fall through (for statement expressions).
1815 case Sema::PCC_ForInit:
1816 case Sema::PCC_Condition:
1817 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1818 // Fall through: conditions and statements can have expressions.
1820 case Sema::PCC_ParenthesizedExpression:
1821 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
1822 CCC == Sema::PCC_ParenthesizedExpression) {
1823 // (__bridge <type>)<expression>
1824 Builder.AddTypedTextChunk("__bridge");
1825 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1826 Builder.AddPlaceholderChunk("type");
1827 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1828 Builder.AddPlaceholderChunk("expression");
1829 Results.AddResult(Result(Builder.TakeString()));
1831 // (__bridge_transfer <Objective-C type>)<expression>
1832 Builder.AddTypedTextChunk("__bridge_transfer");
1833 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1834 Builder.AddPlaceholderChunk("Objective-C type");
1835 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1836 Builder.AddPlaceholderChunk("expression");
1837 Results.AddResult(Result(Builder.TakeString()));
1839 // (__bridge_retained <CF type>)<expression>
1840 Builder.AddTypedTextChunk("__bridge_retained");
1841 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1842 Builder.AddPlaceholderChunk("CF type");
1843 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1844 Builder.AddPlaceholderChunk("expression");
1845 Results.AddResult(Result(Builder.TakeString()));
1849 case Sema::PCC_Expression: {
1850 if (SemaRef.getLangOpts().CPlusPlus) {
1851 // 'this', if we're in a non-static member function.
1852 addThisCompletion(SemaRef, Results);
1855 Builder.AddResultTypeChunk("bool");
1856 Builder.AddTypedTextChunk("true");
1857 Results.AddResult(Result(Builder.TakeString()));
1860 Builder.AddResultTypeChunk("bool");
1861 Builder.AddTypedTextChunk("false");
1862 Results.AddResult(Result(Builder.TakeString()));
1864 if (SemaRef.getLangOpts().RTTI) {
1865 // dynamic_cast < type-id > ( expression )
1866 Builder.AddTypedTextChunk("dynamic_cast");
1867 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1868 Builder.AddPlaceholderChunk("type");
1869 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1870 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1871 Builder.AddPlaceholderChunk("expression");
1872 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1873 Results.AddResult(Result(Builder.TakeString()));
1876 // static_cast < type-id > ( expression )
1877 Builder.AddTypedTextChunk("static_cast");
1878 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1879 Builder.AddPlaceholderChunk("type");
1880 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1881 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1882 Builder.AddPlaceholderChunk("expression");
1883 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1884 Results.AddResult(Result(Builder.TakeString()));
1886 // reinterpret_cast < type-id > ( expression )
1887 Builder.AddTypedTextChunk("reinterpret_cast");
1888 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1889 Builder.AddPlaceholderChunk("type");
1890 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1891 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1892 Builder.AddPlaceholderChunk("expression");
1893 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1894 Results.AddResult(Result(Builder.TakeString()));
1896 // const_cast < type-id > ( expression )
1897 Builder.AddTypedTextChunk("const_cast");
1898 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1899 Builder.AddPlaceholderChunk("type");
1900 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1901 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1902 Builder.AddPlaceholderChunk("expression");
1903 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1904 Results.AddResult(Result(Builder.TakeString()));
1906 if (SemaRef.getLangOpts().RTTI) {
1907 // typeid ( expression-or-type )
1908 Builder.AddResultTypeChunk("std::type_info");
1909 Builder.AddTypedTextChunk("typeid");
1910 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1911 Builder.AddPlaceholderChunk("expression-or-type");
1912 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1913 Results.AddResult(Result(Builder.TakeString()));
1917 Builder.AddTypedTextChunk("new");
1918 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1919 Builder.AddPlaceholderChunk("type");
1920 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1921 Builder.AddPlaceholderChunk("expressions");
1922 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1923 Results.AddResult(Result(Builder.TakeString()));
1925 // new T [ ] ( ... )
1926 Builder.AddTypedTextChunk("new");
1927 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1928 Builder.AddPlaceholderChunk("type");
1929 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
1930 Builder.AddPlaceholderChunk("size");
1931 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
1932 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1933 Builder.AddPlaceholderChunk("expressions");
1934 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1935 Results.AddResult(Result(Builder.TakeString()));
1937 // delete expression
1938 Builder.AddResultTypeChunk("void");
1939 Builder.AddTypedTextChunk("delete");
1940 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1941 Builder.AddPlaceholderChunk("expression");
1942 Results.AddResult(Result(Builder.TakeString()));
1944 // delete [] expression
1945 Builder.AddResultTypeChunk("void");
1946 Builder.AddTypedTextChunk("delete");
1947 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1948 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
1949 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
1950 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1951 Builder.AddPlaceholderChunk("expression");
1952 Results.AddResult(Result(Builder.TakeString()));
1954 if (SemaRef.getLangOpts().CXXExceptions) {
1956 Builder.AddResultTypeChunk("void");
1957 Builder.AddTypedTextChunk("throw");
1958 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1959 Builder.AddPlaceholderChunk("expression");
1960 Results.AddResult(Result(Builder.TakeString()));
1965 if (SemaRef.getLangOpts().CPlusPlus11) {
1967 Builder.AddResultTypeChunk("std::nullptr_t");
1968 Builder.AddTypedTextChunk("nullptr");
1969 Results.AddResult(Result(Builder.TakeString()));
1972 Builder.AddResultTypeChunk("size_t");
1973 Builder.AddTypedTextChunk("alignof");
1974 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1975 Builder.AddPlaceholderChunk("type");
1976 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1977 Results.AddResult(Result(Builder.TakeString()));
1980 Builder.AddResultTypeChunk("bool");
1981 Builder.AddTypedTextChunk("noexcept");
1982 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1983 Builder.AddPlaceholderChunk("expression");
1984 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1985 Results.AddResult(Result(Builder.TakeString()));
1987 // sizeof... expression
1988 Builder.AddResultTypeChunk("size_t");
1989 Builder.AddTypedTextChunk("sizeof...");
1990 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1991 Builder.AddPlaceholderChunk("parameter-pack");
1992 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1993 Results.AddResult(Result(Builder.TakeString()));
1997 if (SemaRef.getLangOpts().ObjC1) {
1998 // Add "super", if we're in an Objective-C class with a superclass.
1999 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) {
2000 // The interface can be NULL.
2001 if (ObjCInterfaceDecl *ID = Method->getClassInterface())
2002 if (ID->getSuperClass()) {
2003 std::string SuperType;
2004 SuperType = ID->getSuperClass()->getNameAsString();
2005 if (Method->isInstanceMethod())
2008 Builder.AddResultTypeChunk(Allocator.CopyString(SuperType));
2009 Builder.AddTypedTextChunk("super");
2010 Results.AddResult(Result(Builder.TakeString()));
2014 AddObjCExpressionResults(Results, true);
2017 if (SemaRef.getLangOpts().C11) {
2019 Builder.AddResultTypeChunk("size_t");
2020 if (SemaRef.PP.isMacroDefined("alignof"))
2021 Builder.AddTypedTextChunk("alignof");
2023 Builder.AddTypedTextChunk("_Alignof");
2024 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2025 Builder.AddPlaceholderChunk("type");
2026 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2027 Results.AddResult(Result(Builder.TakeString()));
2030 // sizeof expression
2031 Builder.AddResultTypeChunk("size_t");
2032 Builder.AddTypedTextChunk("sizeof");
2033 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2034 Builder.AddPlaceholderChunk("expression-or-type");
2035 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2036 Results.AddResult(Result(Builder.TakeString()));
2040 case Sema::PCC_Type:
2041 case Sema::PCC_LocalDeclarationSpecifiers:
2045 if (WantTypesInContext(CCC, SemaRef.getLangOpts()))
2046 AddTypeSpecifierResults(SemaRef.getLangOpts(), Results);
2048 if (SemaRef.getLangOpts().CPlusPlus && CCC != Sema::PCC_Type)
2049 Results.AddResult(Result("operator"));
2052 /// \brief If the given declaration has an associated type, add it as a result
2054 static void AddResultTypeChunk(ASTContext &Context,
2055 const PrintingPolicy &Policy,
2056 const NamedDecl *ND,
2058 CodeCompletionBuilder &Result) {
2062 // Skip constructors and conversion functions, which have their return types
2063 // built into their names.
2064 if (isa<CXXConstructorDecl>(ND) || isa<CXXConversionDecl>(ND))
2067 // Determine the type of the declaration (if it has a type).
2069 if (const FunctionDecl *Function = ND->getAsFunction())
2070 T = Function->getReturnType();
2071 else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2072 if (!BaseType.isNull())
2073 T = Method->getSendResultType(BaseType);
2075 T = Method->getReturnType();
2076 } else if (const EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND))
2077 T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext()));
2078 else if (isa<UnresolvedUsingValueDecl>(ND)) {
2079 /* Do nothing: ignore unresolved using declarations*/
2080 } else if (const ObjCIvarDecl *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
2081 if (!BaseType.isNull())
2082 T = Ivar->getUsageType(BaseType);
2084 T = Ivar->getType();
2085 } else if (const ValueDecl *Value = dyn_cast<ValueDecl>(ND)) {
2086 T = Value->getType();
2087 } else if (const ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND)) {
2088 if (!BaseType.isNull())
2089 T = Property->getUsageType(BaseType);
2091 T = Property->getType();
2094 if (T.isNull() || Context.hasSameType(T, Context.DependentTy))
2097 Result.AddResultTypeChunk(GetCompletionTypeString(T, Context, Policy,
2098 Result.getAllocator()));
2101 static void MaybeAddSentinel(Preprocessor &PP,
2102 const NamedDecl *FunctionOrMethod,
2103 CodeCompletionBuilder &Result) {
2104 if (SentinelAttr *Sentinel = FunctionOrMethod->getAttr<SentinelAttr>())
2105 if (Sentinel->getSentinel() == 0) {
2106 if (PP.getLangOpts().ObjC1 && PP.isMacroDefined("nil"))
2107 Result.AddTextChunk(", nil");
2108 else if (PP.isMacroDefined("NULL"))
2109 Result.AddTextChunk(", NULL");
2111 Result.AddTextChunk(", (void*)0");
2115 static std::string formatObjCParamQualifiers(unsigned ObjCQuals,
2118 if (ObjCQuals & Decl::OBJC_TQ_In)
2120 else if (ObjCQuals & Decl::OBJC_TQ_Inout)
2122 else if (ObjCQuals & Decl::OBJC_TQ_Out)
2124 if (ObjCQuals & Decl::OBJC_TQ_Bycopy)
2125 Result += "bycopy ";
2126 else if (ObjCQuals & Decl::OBJC_TQ_Byref)
2128 if (ObjCQuals & Decl::OBJC_TQ_Oneway)
2129 Result += "oneway ";
2130 if (ObjCQuals & Decl::OBJC_TQ_CSNullability) {
2131 if (auto nullability = AttributedType::stripOuterNullability(Type)) {
2132 switch (*nullability) {
2133 case NullabilityKind::NonNull:
2134 Result += "nonnull ";
2137 case NullabilityKind::Nullable:
2138 Result += "nullable ";
2141 case NullabilityKind::Unspecified:
2142 Result += "null_unspecified ";
2150 static std::string FormatFunctionParameter(const PrintingPolicy &Policy,
2151 const ParmVarDecl *Param,
2152 bool SuppressName = false,
2153 bool SuppressBlock = false,
2154 Optional<ArrayRef<QualType>> ObjCSubsts = None) {
2155 bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext());
2156 if (Param->getType()->isDependentType() ||
2157 !Param->getType()->isBlockPointerType()) {
2158 // The argument for a dependent or non-block parameter is a placeholder
2159 // containing that parameter's type.
2162 if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName)
2163 Result = Param->getIdentifier()->getName();
2165 QualType Type = Param->getType();
2167 Type = Type.substObjCTypeArgs(Param->getASTContext(), *ObjCSubsts,
2168 ObjCSubstitutionContext::Parameter);
2169 if (ObjCMethodParam) {
2170 Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(),
2172 Result += Type.getAsString(Policy) + ")";
2173 if (Param->getIdentifier() && !SuppressName)
2174 Result += Param->getIdentifier()->getName();
2176 Type.getAsStringInternal(Result, Policy);
2181 // The argument for a block pointer parameter is a block literal with
2182 // the appropriate type.
2183 FunctionTypeLoc Block;
2184 FunctionProtoTypeLoc BlockProto;
2186 if (TypeSourceInfo *TSInfo = Param->getTypeSourceInfo()) {
2187 TL = TSInfo->getTypeLoc().getUnqualifiedLoc();
2189 // Look through typedefs.
2190 if (!SuppressBlock) {
2191 if (TypedefTypeLoc TypedefTL = TL.getAs<TypedefTypeLoc>()) {
2192 if (TypeSourceInfo *InnerTSInfo =
2193 TypedefTL.getTypedefNameDecl()->getTypeSourceInfo()) {
2194 TL = InnerTSInfo->getTypeLoc().getUnqualifiedLoc();
2199 // Look through qualified types
2200 if (QualifiedTypeLoc QualifiedTL = TL.getAs<QualifiedTypeLoc>()) {
2201 TL = QualifiedTL.getUnqualifiedLoc();
2205 if (AttributedTypeLoc AttrTL = TL.getAs<AttributedTypeLoc>()) {
2206 TL = AttrTL.getModifiedLoc();
2211 // Try to get the function prototype behind the block pointer type,
2213 if (BlockPointerTypeLoc BlockPtr = TL.getAs<BlockPointerTypeLoc>()) {
2214 TL = BlockPtr.getPointeeLoc().IgnoreParens();
2215 Block = TL.getAs<FunctionTypeLoc>();
2216 BlockProto = TL.getAs<FunctionProtoTypeLoc>();
2223 // We were unable to find a FunctionProtoTypeLoc with parameter names
2224 // for the block; just use the parameter type as a placeholder.
2226 if (!ObjCMethodParam && Param->getIdentifier())
2227 Result = Param->getIdentifier()->getName();
2229 QualType Type = Param->getType().getUnqualifiedType();
2231 if (ObjCMethodParam) {
2232 Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(),
2234 Result += Type.getAsString(Policy) + Result + ")";
2235 if (Param->getIdentifier())
2236 Result += Param->getIdentifier()->getName();
2238 Type.getAsStringInternal(Result, Policy);
2244 // We have the function prototype behind the block pointer type, as it was
2245 // written in the source.
2247 QualType ResultType = Block.getTypePtr()->getReturnType();
2249 ResultType = ResultType.substObjCTypeArgs(Param->getASTContext(),
2251 ObjCSubstitutionContext::Result);
2252 if (!ResultType->isVoidType() || SuppressBlock)
2253 ResultType.getAsStringInternal(Result, Policy);
2255 // Format the parameter list.
2257 if (!BlockProto || Block.getNumParams() == 0) {
2258 if (BlockProto && BlockProto.getTypePtr()->isVariadic())
2264 for (unsigned I = 0, N = Block.getNumParams(); I != N; ++I) {
2267 Params += FormatFunctionParameter(Policy, Block.getParam(I),
2268 /*SuppressName=*/false,
2269 /*SuppressBlock=*/true,
2272 if (I == N - 1 && BlockProto.getTypePtr()->isVariadic())
2278 if (SuppressBlock) {
2279 // Format as a parameter.
2280 Result = Result + " (^";
2281 if (Param->getIdentifier())
2282 Result += Param->getIdentifier()->getName();
2286 // Format as a block literal argument.
2287 Result = '^' + Result;
2290 if (Param->getIdentifier())
2291 Result += Param->getIdentifier()->getName();
2297 /// \brief Add function parameter chunks to the given code completion string.
2298 static void AddFunctionParameterChunks(Preprocessor &PP,
2299 const PrintingPolicy &Policy,
2300 const FunctionDecl *Function,
2301 CodeCompletionBuilder &Result,
2303 bool InOptional = false) {
2304 bool FirstParameter = true;
2306 for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) {
2307 const ParmVarDecl *Param = Function->getParamDecl(P);
2309 if (Param->hasDefaultArg() && !InOptional) {
2310 // When we see an optional default argument, put that argument and
2311 // the remaining default arguments into a new, optional string.
2312 CodeCompletionBuilder Opt(Result.getAllocator(),
2313 Result.getCodeCompletionTUInfo());
2314 if (!FirstParameter)
2315 Opt.AddChunk(CodeCompletionString::CK_Comma);
2316 AddFunctionParameterChunks(PP, Policy, Function, Opt, P, true);
2317 Result.AddOptionalChunk(Opt.TakeString());
2322 FirstParameter = false;
2324 Result.AddChunk(CodeCompletionString::CK_Comma);
2328 // Format the placeholder string.
2329 std::string PlaceholderStr = FormatFunctionParameter(Policy, Param);
2331 if (Function->isVariadic() && P == N - 1)
2332 PlaceholderStr += ", ...";
2334 // Add the placeholder string.
2335 Result.AddPlaceholderChunk(
2336 Result.getAllocator().CopyString(PlaceholderStr));
2339 if (const FunctionProtoType *Proto
2340 = Function->getType()->getAs<FunctionProtoType>())
2341 if (Proto->isVariadic()) {
2342 if (Proto->getNumParams() == 0)
2343 Result.AddPlaceholderChunk("...");
2345 MaybeAddSentinel(PP, Function, Result);
2349 /// \brief Add template parameter chunks to the given code completion string.
2350 static void AddTemplateParameterChunks(ASTContext &Context,
2351 const PrintingPolicy &Policy,
2352 const TemplateDecl *Template,
2353 CodeCompletionBuilder &Result,
2354 unsigned MaxParameters = 0,
2356 bool InDefaultArg = false) {
2357 bool FirstParameter = true;
2359 // Prefer to take the template parameter names from the first declaration of
2361 Template = cast<TemplateDecl>(Template->getCanonicalDecl());
2363 TemplateParameterList *Params = Template->getTemplateParameters();
2364 TemplateParameterList::iterator PEnd = Params->end();
2366 PEnd = Params->begin() + MaxParameters;
2367 for (TemplateParameterList::iterator P = Params->begin() + Start;
2369 bool HasDefaultArg = false;
2370 std::string PlaceholderStr;
2371 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
2372 if (TTP->wasDeclaredWithTypename())
2373 PlaceholderStr = "typename";
2375 PlaceholderStr = "class";
2377 if (TTP->getIdentifier()) {
2378 PlaceholderStr += ' ';
2379 PlaceholderStr += TTP->getIdentifier()->getName();
2382 HasDefaultArg = TTP->hasDefaultArgument();
2383 } else if (NonTypeTemplateParmDecl *NTTP
2384 = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
2385 if (NTTP->getIdentifier())
2386 PlaceholderStr = NTTP->getIdentifier()->getName();
2387 NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
2388 HasDefaultArg = NTTP->hasDefaultArgument();
2390 assert(isa<TemplateTemplateParmDecl>(*P));
2391 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
2393 // Since putting the template argument list into the placeholder would
2394 // be very, very long, we just use an abbreviation.
2395 PlaceholderStr = "template<...> class";
2396 if (TTP->getIdentifier()) {
2397 PlaceholderStr += ' ';
2398 PlaceholderStr += TTP->getIdentifier()->getName();
2401 HasDefaultArg = TTP->hasDefaultArgument();
2404 if (HasDefaultArg && !InDefaultArg) {
2405 // When we see an optional default argument, put that argument and
2406 // the remaining default arguments into a new, optional string.
2407 CodeCompletionBuilder Opt(Result.getAllocator(),
2408 Result.getCodeCompletionTUInfo());
2409 if (!FirstParameter)
2410 Opt.AddChunk(CodeCompletionString::CK_Comma);
2411 AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters,
2412 P - Params->begin(), true);
2413 Result.AddOptionalChunk(Opt.TakeString());
2417 InDefaultArg = false;
2420 FirstParameter = false;
2422 Result.AddChunk(CodeCompletionString::CK_Comma);
2424 // Add the placeholder string.
2425 Result.AddPlaceholderChunk(
2426 Result.getAllocator().CopyString(PlaceholderStr));
2430 /// \brief Add a qualifier to the given code-completion string, if the
2431 /// provided nested-name-specifier is non-NULL.
2433 AddQualifierToCompletionString(CodeCompletionBuilder &Result,
2434 NestedNameSpecifier *Qualifier,
2435 bool QualifierIsInformative,
2436 ASTContext &Context,
2437 const PrintingPolicy &Policy) {
2441 std::string PrintedNNS;
2443 llvm::raw_string_ostream OS(PrintedNNS);
2444 Qualifier->print(OS, Policy);
2446 if (QualifierIsInformative)
2447 Result.AddInformativeChunk(Result.getAllocator().CopyString(PrintedNNS));
2449 Result.AddTextChunk(Result.getAllocator().CopyString(PrintedNNS));
2453 AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result,
2454 const FunctionDecl *Function) {
2455 const FunctionProtoType *Proto
2456 = Function->getType()->getAs<FunctionProtoType>();
2457 if (!Proto || !Proto->getTypeQuals())
2460 // FIXME: Add ref-qualifier!
2462 // Handle single qualifiers without copying
2463 if (Proto->getTypeQuals() == Qualifiers::Const) {
2464 Result.AddInformativeChunk(" const");
2468 if (Proto->getTypeQuals() == Qualifiers::Volatile) {
2469 Result.AddInformativeChunk(" volatile");
2473 if (Proto->getTypeQuals() == Qualifiers::Restrict) {
2474 Result.AddInformativeChunk(" restrict");
2478 // Handle multiple qualifiers.
2479 std::string QualsStr;
2480 if (Proto->isConst())
2481 QualsStr += " const";
2482 if (Proto->isVolatile())
2483 QualsStr += " volatile";
2484 if (Proto->isRestrict())
2485 QualsStr += " restrict";
2486 Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
2489 /// \brief Add the name of the given declaration
2490 static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy,
2491 const NamedDecl *ND,
2492 CodeCompletionBuilder &Result) {
2493 DeclarationName Name = ND->getDeclName();
2497 switch (Name.getNameKind()) {
2498 case DeclarationName::CXXOperatorName: {
2499 const char *OperatorName = nullptr;
2500 switch (Name.getCXXOverloadedOperator()) {
2502 case OO_Conditional:
2503 case NUM_OVERLOADED_OPERATORS:
2504 OperatorName = "operator";
2507 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2508 case OO_##Name: OperatorName = "operator" Spelling; break;
2509 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2510 #include "clang/Basic/OperatorKinds.def"
2512 case OO_New: OperatorName = "operator new"; break;
2513 case OO_Delete: OperatorName = "operator delete"; break;
2514 case OO_Array_New: OperatorName = "operator new[]"; break;
2515 case OO_Array_Delete: OperatorName = "operator delete[]"; break;
2516 case OO_Call: OperatorName = "operator()"; break;
2517 case OO_Subscript: OperatorName = "operator[]"; break;
2519 Result.AddTypedTextChunk(OperatorName);
2523 case DeclarationName::Identifier:
2524 case DeclarationName::CXXConversionFunctionName:
2525 case DeclarationName::CXXDestructorName:
2526 case DeclarationName::CXXLiteralOperatorName:
2527 Result.AddTypedTextChunk(
2528 Result.getAllocator().CopyString(ND->getNameAsString()));
2531 case DeclarationName::CXXUsingDirective:
2532 case DeclarationName::ObjCZeroArgSelector:
2533 case DeclarationName::ObjCOneArgSelector:
2534 case DeclarationName::ObjCMultiArgSelector:
2537 case DeclarationName::CXXConstructorName: {
2538 CXXRecordDecl *Record = nullptr;
2539 QualType Ty = Name.getCXXNameType();
2540 if (const RecordType *RecordTy = Ty->getAs<RecordType>())
2541 Record = cast<CXXRecordDecl>(RecordTy->getDecl());
2542 else if (const InjectedClassNameType *InjectedTy
2543 = Ty->getAs<InjectedClassNameType>())
2544 Record = InjectedTy->getDecl();
2546 Result.AddTypedTextChunk(
2547 Result.getAllocator().CopyString(ND->getNameAsString()));
2551 Result.AddTypedTextChunk(
2552 Result.getAllocator().CopyString(Record->getNameAsString()));
2553 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) {
2554 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2555 AddTemplateParameterChunks(Context, Policy, Template, Result);
2556 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2563 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(Sema &S,
2564 const CodeCompletionContext &CCContext,
2565 CodeCompletionAllocator &Allocator,
2566 CodeCompletionTUInfo &CCTUInfo,
2567 bool IncludeBriefComments) {
2568 return CreateCodeCompletionString(S.Context, S.PP, CCContext, Allocator,
2569 CCTUInfo, IncludeBriefComments);
2572 /// \brief If possible, create a new code completion string for the given
2575 /// \returns Either a new, heap-allocated code completion string describing
2576 /// how to use this result, or NULL to indicate that the string or name of the
2577 /// result is all that is needed.
2578 CodeCompletionString *
2579 CodeCompletionResult::CreateCodeCompletionString(ASTContext &Ctx,
2581 const CodeCompletionContext &CCContext,
2582 CodeCompletionAllocator &Allocator,
2583 CodeCompletionTUInfo &CCTUInfo,
2584 bool IncludeBriefComments) {
2585 CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
2587 PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP);
2588 if (Kind == RK_Pattern) {
2589 Pattern->Priority = Priority;
2590 Pattern->Availability = Availability;
2593 Result.addParentContext(Declaration->getDeclContext());
2594 Pattern->ParentName = Result.getParentName();
2595 // Provide code completion comment for self.GetterName where
2596 // GetterName is the getter method for a property with name
2597 // different from the property name (declared via a property
2598 // getter attribute.
2599 const NamedDecl *ND = Declaration;
2600 if (const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(ND))
2601 if (M->isPropertyAccessor())
2602 if (const ObjCPropertyDecl *PDecl = M->findPropertyDecl())
2603 if (PDecl->getGetterName() == M->getSelector() &&
2604 PDecl->getIdentifier() != M->getIdentifier()) {
2605 if (const RawComment *RC =
2606 Ctx.getRawCommentForAnyRedecl(M)) {
2607 Result.addBriefComment(RC->getBriefText(Ctx));
2608 Pattern->BriefComment = Result.getBriefComment();
2610 else if (const RawComment *RC =
2611 Ctx.getRawCommentForAnyRedecl(PDecl)) {
2612 Result.addBriefComment(RC->getBriefText(Ctx));
2613 Pattern->BriefComment = Result.getBriefComment();
2621 if (Kind == RK_Keyword) {
2622 Result.AddTypedTextChunk(Keyword);
2623 return Result.TakeString();
2626 if (Kind == RK_Macro) {
2627 const MacroInfo *MI = PP.getMacroInfo(Macro);
2628 Result.AddTypedTextChunk(
2629 Result.getAllocator().CopyString(Macro->getName()));
2631 if (!MI || !MI->isFunctionLike())
2632 return Result.TakeString();
2634 // Format a function-like macro with placeholders for the arguments.
2635 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2636 MacroInfo::arg_iterator A = MI->arg_begin(), AEnd = MI->arg_end();
2638 // C99 variadic macros add __VA_ARGS__ at the end. Skip it.
2639 if (MI->isC99Varargs()) {
2643 Result.AddPlaceholderChunk("...");
2647 for (MacroInfo::arg_iterator A = MI->arg_begin(); A != AEnd; ++A) {
2648 if (A != MI->arg_begin())
2649 Result.AddChunk(CodeCompletionString::CK_Comma);
2651 if (MI->isVariadic() && (A+1) == AEnd) {
2652 SmallString<32> Arg = (*A)->getName();
2653 if (MI->isC99Varargs())
2657 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
2661 // Non-variadic macros are simple.
2662 Result.AddPlaceholderChunk(
2663 Result.getAllocator().CopyString((*A)->getName()));
2665 Result.AddChunk(CodeCompletionString::CK_RightParen);
2666 return Result.TakeString();
2669 assert(Kind == RK_Declaration && "Missed a result kind?");
2670 const NamedDecl *ND = Declaration;
2671 Result.addParentContext(ND->getDeclContext());
2673 if (IncludeBriefComments) {
2674 // Add documentation comment, if it exists.
2675 if (const RawComment *RC = Ctx.getRawCommentForAnyRedecl(ND)) {
2676 Result.addBriefComment(RC->getBriefText(Ctx));
2678 else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND))
2679 if (OMD->isPropertyAccessor())
2680 if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())
2681 if (const RawComment *RC = Ctx.getRawCommentForAnyRedecl(PDecl))
2682 Result.addBriefComment(RC->getBriefText(Ctx));
2685 if (StartsNestedNameSpecifier) {
2686 Result.AddTypedTextChunk(
2687 Result.getAllocator().CopyString(ND->getNameAsString()));
2688 Result.AddTextChunk("::");
2689 return Result.TakeString();
2692 for (const auto *I : ND->specific_attrs<AnnotateAttr>())
2693 Result.AddAnnotation(Result.getAllocator().CopyString(I->getAnnotation()));
2695 AddResultTypeChunk(Ctx, Policy, ND, CCContext.getBaseType(), Result);
2697 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) {
2698 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2700 AddTypedNameChunk(Ctx, Policy, ND, Result);
2701 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2702 AddFunctionParameterChunks(PP, Policy, Function, Result);
2703 Result.AddChunk(CodeCompletionString::CK_RightParen);
2704 AddFunctionTypeQualsToCompletionString(Result, Function);
2705 return Result.TakeString();
2708 if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) {
2709 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2711 FunctionDecl *Function = FunTmpl->getTemplatedDecl();
2712 AddTypedNameChunk(Ctx, Policy, Function, Result);
2714 // Figure out which template parameters are deduced (or have default
2716 llvm::SmallBitVector Deduced;
2717 Sema::MarkDeducedTemplateParameters(Ctx, FunTmpl, Deduced);
2718 unsigned LastDeducibleArgument;
2719 for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0;
2720 --LastDeducibleArgument) {
2721 if (!Deduced[LastDeducibleArgument - 1]) {
2722 // C++0x: Figure out if the template argument has a default. If so,
2723 // the user doesn't need to type this argument.
2724 // FIXME: We need to abstract template parameters better!
2725 bool HasDefaultArg = false;
2726 NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam(
2727 LastDeducibleArgument - 1);
2728 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
2729 HasDefaultArg = TTP->hasDefaultArgument();
2730 else if (NonTypeTemplateParmDecl *NTTP
2731 = dyn_cast<NonTypeTemplateParmDecl>(Param))
2732 HasDefaultArg = NTTP->hasDefaultArgument();
2734 assert(isa<TemplateTemplateParmDecl>(Param));
2736 = cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument();
2744 if (LastDeducibleArgument) {
2745 // Some of the function template arguments cannot be deduced from a
2746 // function call, so we introduce an explicit template argument list
2747 // containing all of the arguments up to the first deducible argument.
2748 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2749 AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result,
2750 LastDeducibleArgument);
2751 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2754 // Add the function parameters
2755 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2756 AddFunctionParameterChunks(PP, Policy, Function, Result);
2757 Result.AddChunk(CodeCompletionString::CK_RightParen);
2758 AddFunctionTypeQualsToCompletionString(Result, Function);
2759 return Result.TakeString();
2762 if (const TemplateDecl *Template = dyn_cast<TemplateDecl>(ND)) {
2763 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2765 Result.AddTypedTextChunk(
2766 Result.getAllocator().CopyString(Template->getNameAsString()));
2767 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2768 AddTemplateParameterChunks(Ctx, Policy, Template, Result);
2769 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2770 return Result.TakeString();
2773 if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2774 Selector Sel = Method->getSelector();
2775 if (Sel.isUnarySelector()) {
2776 Result.AddTypedTextChunk(Result.getAllocator().CopyString(
2777 Sel.getNameForSlot(0)));
2778 return Result.TakeString();
2781 std::string SelName = Sel.getNameForSlot(0).str();
2783 if (StartParameter == 0)
2784 Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName));
2786 Result.AddInformativeChunk(Result.getAllocator().CopyString(SelName));
2788 // If there is only one parameter, and we're past it, add an empty
2789 // typed-text chunk since there is nothing to type.
2790 if (Method->param_size() == 1)
2791 Result.AddTypedTextChunk("");
2794 for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(),
2795 PEnd = Method->param_end();
2796 P != PEnd; (void)++P, ++Idx) {
2798 std::string Keyword;
2799 if (Idx > StartParameter)
2800 Result.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2801 if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx))
2802 Keyword += II->getName();
2804 if (Idx < StartParameter || AllParametersAreInformative)
2805 Result.AddInformativeChunk(Result.getAllocator().CopyString(Keyword));
2807 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Keyword));
2810 // If we're before the starting parameter, skip the placeholder.
2811 if (Idx < StartParameter)
2815 QualType ParamType = (*P)->getType();
2816 Optional<ArrayRef<QualType>> ObjCSubsts;
2817 if (!CCContext.getBaseType().isNull())
2818 ObjCSubsts = CCContext.getBaseType()->getObjCSubstitutions(Method);
2820 if (ParamType->isBlockPointerType() && !DeclaringEntity)
2821 Arg = FormatFunctionParameter(Policy, *P, true,
2822 /*SuppressBlock=*/false,
2826 ParamType = ParamType.substObjCTypeArgs(Ctx, *ObjCSubsts,
2827 ObjCSubstitutionContext::Parameter);
2828 Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier(),
2830 Arg += ParamType.getAsString(Policy) + ")";
2831 if (IdentifierInfo *II = (*P)->getIdentifier())
2832 if (DeclaringEntity || AllParametersAreInformative)
2833 Arg += II->getName();
2836 if (Method->isVariadic() && (P + 1) == PEnd)
2839 if (DeclaringEntity)
2840 Result.AddTextChunk(Result.getAllocator().CopyString(Arg));
2841 else if (AllParametersAreInformative)
2842 Result.AddInformativeChunk(Result.getAllocator().CopyString(Arg));
2844 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
2847 if (Method->isVariadic()) {
2848 if (Method->param_size() == 0) {
2849 if (DeclaringEntity)
2850 Result.AddTextChunk(", ...");
2851 else if (AllParametersAreInformative)
2852 Result.AddInformativeChunk(", ...");
2854 Result.AddPlaceholderChunk(", ...");
2857 MaybeAddSentinel(PP, Method, Result);
2860 return Result.TakeString();
2864 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2867 Result.AddTypedTextChunk(
2868 Result.getAllocator().CopyString(ND->getNameAsString()));
2869 return Result.TakeString();
2872 /// \brief Add function overload parameter chunks to the given code completion
2874 static void AddOverloadParameterChunks(ASTContext &Context,
2875 const PrintingPolicy &Policy,
2876 const FunctionDecl *Function,
2877 const FunctionProtoType *Prototype,
2878 CodeCompletionBuilder &Result,
2879 unsigned CurrentArg,
2881 bool InOptional = false) {
2882 bool FirstParameter = true;
2883 unsigned NumParams = Function ? Function->getNumParams()
2884 : Prototype->getNumParams();
2886 for (unsigned P = Start; P != NumParams; ++P) {
2887 if (Function && Function->getParamDecl(P)->hasDefaultArg() && !InOptional) {
2888 // When we see an optional default argument, put that argument and
2889 // the remaining default arguments into a new, optional string.
2890 CodeCompletionBuilder Opt(Result.getAllocator(),
2891 Result.getCodeCompletionTUInfo());
2892 if (!FirstParameter)
2893 Opt.AddChunk(CodeCompletionString::CK_Comma);
2894 // Optional sections are nested.
2895 AddOverloadParameterChunks(Context, Policy, Function, Prototype, Opt,
2896 CurrentArg, P, /*InOptional=*/true);
2897 Result.AddOptionalChunk(Opt.TakeString());
2902 FirstParameter = false;
2904 Result.AddChunk(CodeCompletionString::CK_Comma);
2908 // Format the placeholder string.
2909 std::string Placeholder;
2911 Placeholder = FormatFunctionParameter(Policy, Function->getParamDecl(P));
2913 Placeholder = Prototype->getParamType(P).getAsString(Policy);
2915 if (P == CurrentArg)
2916 Result.AddCurrentParameterChunk(
2917 Result.getAllocator().CopyString(Placeholder));
2919 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Placeholder));
2922 if (Prototype && Prototype->isVariadic()) {
2923 CodeCompletionBuilder Opt(Result.getAllocator(),
2924 Result.getCodeCompletionTUInfo());
2925 if (!FirstParameter)
2926 Opt.AddChunk(CodeCompletionString::CK_Comma);
2928 if (CurrentArg < NumParams)
2929 Opt.AddPlaceholderChunk("...");
2931 Opt.AddCurrentParameterChunk("...");
2933 Result.AddOptionalChunk(Opt.TakeString());
2937 CodeCompletionString *
2938 CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
2939 unsigned CurrentArg, Sema &S,
2940 CodeCompletionAllocator &Allocator,
2941 CodeCompletionTUInfo &CCTUInfo,
2942 bool IncludeBriefComments) const {
2943 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
2945 // FIXME: Set priority, availability appropriately.
2946 CodeCompletionBuilder Result(Allocator,CCTUInfo, 1, CXAvailability_Available);
2947 FunctionDecl *FDecl = getFunction();
2948 const FunctionProtoType *Proto
2949 = dyn_cast<FunctionProtoType>(getFunctionType());
2950 if (!FDecl && !Proto) {
2951 // Function without a prototype. Just give the return type and a
2952 // highlighted ellipsis.
2953 const FunctionType *FT = getFunctionType();
2954 Result.AddResultTypeChunk(Result.getAllocator().CopyString(
2955 FT->getReturnType().getAsString(Policy)));
2956 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2957 Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
2958 Result.AddChunk(CodeCompletionString::CK_RightParen);
2959 return Result.TakeString();
2963 if (IncludeBriefComments && CurrentArg < FDecl->getNumParams())
2964 if (auto RC = S.getASTContext().getRawCommentForAnyRedecl(
2965 FDecl->getParamDecl(CurrentArg)))
2966 Result.addBriefComment(RC->getBriefText(S.getASTContext()));
2967 AddResultTypeChunk(S.Context, Policy, FDecl, QualType(), Result);
2968 Result.AddTextChunk(
2969 Result.getAllocator().CopyString(FDecl->getNameAsString()));
2971 Result.AddResultTypeChunk(
2972 Result.getAllocator().CopyString(
2973 Proto->getReturnType().getAsString(Policy)));
2976 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2977 AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, Result,
2979 Result.AddChunk(CodeCompletionString::CK_RightParen);
2981 return Result.TakeString();
2984 unsigned clang::getMacroUsagePriority(StringRef MacroName,
2985 const LangOptions &LangOpts,
2986 bool PreferredTypeIsPointer) {
2987 unsigned Priority = CCP_Macro;
2989 // Treat the "nil", "Nil" and "NULL" macros as null pointer constants.
2990 if (MacroName.equals("nil") || MacroName.equals("NULL") ||
2991 MacroName.equals("Nil")) {
2992 Priority = CCP_Constant;
2993 if (PreferredTypeIsPointer)
2994 Priority = Priority / CCF_SimilarTypeMatch;
2996 // Treat "YES", "NO", "true", and "false" as constants.
2997 else if (MacroName.equals("YES") || MacroName.equals("NO") ||
2998 MacroName.equals("true") || MacroName.equals("false"))
2999 Priority = CCP_Constant;
3000 // Treat "bool" as a type.
3001 else if (MacroName.equals("bool"))
3002 Priority = CCP_Type + (LangOpts.ObjC1? CCD_bool_in_ObjC : 0);
3008 CXCursorKind clang::getCursorKindForDecl(const Decl *D) {
3010 return CXCursor_UnexposedDecl;
3012 switch (D->getKind()) {
3013 case Decl::Enum: return CXCursor_EnumDecl;
3014 case Decl::EnumConstant: return CXCursor_EnumConstantDecl;
3015 case Decl::Field: return CXCursor_FieldDecl;
3016 case Decl::Function:
3017 return CXCursor_FunctionDecl;
3018 case Decl::ObjCCategory: return CXCursor_ObjCCategoryDecl;
3019 case Decl::ObjCCategoryImpl: return CXCursor_ObjCCategoryImplDecl;
3020 case Decl::ObjCImplementation: return CXCursor_ObjCImplementationDecl;
3022 case Decl::ObjCInterface: return CXCursor_ObjCInterfaceDecl;
3023 case Decl::ObjCIvar: return CXCursor_ObjCIvarDecl;
3024 case Decl::ObjCMethod:
3025 return cast<ObjCMethodDecl>(D)->isInstanceMethod()
3026 ? CXCursor_ObjCInstanceMethodDecl : CXCursor_ObjCClassMethodDecl;
3027 case Decl::CXXMethod: return CXCursor_CXXMethod;
3028 case Decl::CXXConstructor: return CXCursor_Constructor;
3029 case Decl::CXXDestructor: return CXCursor_Destructor;
3030 case Decl::CXXConversion: return CXCursor_ConversionFunction;
3031 case Decl::ObjCProperty: return CXCursor_ObjCPropertyDecl;
3032 case Decl::ObjCProtocol: return CXCursor_ObjCProtocolDecl;
3033 case Decl::ParmVar: return CXCursor_ParmDecl;
3034 case Decl::Typedef: return CXCursor_TypedefDecl;
3035 case Decl::TypeAlias: return CXCursor_TypeAliasDecl;
3036 case Decl::TypeAliasTemplate: return CXCursor_TypeAliasTemplateDecl;
3037 case Decl::Var: return CXCursor_VarDecl;
3038 case Decl::Namespace: return CXCursor_Namespace;
3039 case Decl::NamespaceAlias: return CXCursor_NamespaceAlias;
3040 case Decl::TemplateTypeParm: return CXCursor_TemplateTypeParameter;
3041 case Decl::NonTypeTemplateParm:return CXCursor_NonTypeTemplateParameter;
3042 case Decl::TemplateTemplateParm:return CXCursor_TemplateTemplateParameter;
3043 case Decl::FunctionTemplate: return CXCursor_FunctionTemplate;
3044 case Decl::ClassTemplate: return CXCursor_ClassTemplate;
3045 case Decl::AccessSpec: return CXCursor_CXXAccessSpecifier;
3046 case Decl::ClassTemplatePartialSpecialization:
3047 return CXCursor_ClassTemplatePartialSpecialization;
3048 case Decl::UsingDirective: return CXCursor_UsingDirective;
3049 case Decl::TranslationUnit: return CXCursor_TranslationUnit;
3052 case Decl::UnresolvedUsingValue:
3053 case Decl::UnresolvedUsingTypename:
3054 return CXCursor_UsingDeclaration;
3056 case Decl::ObjCPropertyImpl:
3057 switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
3058 case ObjCPropertyImplDecl::Dynamic:
3059 return CXCursor_ObjCDynamicDecl;
3061 case ObjCPropertyImplDecl::Synthesize:
3062 return CXCursor_ObjCSynthesizeDecl;
3066 return CXCursor_ModuleImportDecl;
3068 case Decl::ObjCTypeParam: return CXCursor_TemplateTypeParameter;
3071 if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
3072 switch (TD->getTagKind()) {
3073 case TTK_Interface: // fall through
3074 case TTK_Struct: return CXCursor_StructDecl;
3075 case TTK_Class: return CXCursor_ClassDecl;
3076 case TTK_Union: return CXCursor_UnionDecl;
3077 case TTK_Enum: return CXCursor_EnumDecl;
3082 return CXCursor_UnexposedDecl;
3085 static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results,
3086 bool IncludeUndefined,
3087 bool TargetTypeIsPointer = false) {
3088 typedef CodeCompletionResult Result;
3090 Results.EnterNewScope();
3092 for (Preprocessor::macro_iterator M = PP.macro_begin(),
3093 MEnd = PP.macro_end();
3095 auto MD = PP.getMacroDefinition(M->first);
3096 if (IncludeUndefined || MD) {
3097 if (MacroInfo *MI = MD.getMacroInfo())
3098 if (MI->isUsedForHeaderGuard())
3101 Results.AddResult(Result(M->first,
3102 getMacroUsagePriority(M->first->getName(),
3104 TargetTypeIsPointer)));
3108 Results.ExitScope();
3112 static void AddPrettyFunctionResults(const LangOptions &LangOpts,
3113 ResultBuilder &Results) {
3114 typedef CodeCompletionResult Result;
3116 Results.EnterNewScope();
3118 Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant));
3119 Results.AddResult(Result("__FUNCTION__", CCP_Constant));
3120 if (LangOpts.C99 || LangOpts.CPlusPlus11)
3121 Results.AddResult(Result("__func__", CCP_Constant));
3122 Results.ExitScope();
3125 static void HandleCodeCompleteResults(Sema *S,
3126 CodeCompleteConsumer *CodeCompleter,
3127 CodeCompletionContext Context,
3128 CodeCompletionResult *Results,
3129 unsigned NumResults) {
3131 CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults);
3134 static enum CodeCompletionContext::Kind mapCodeCompletionContext(Sema &S,
3135 Sema::ParserCompletionContext PCC) {
3137 case Sema::PCC_Namespace:
3138 return CodeCompletionContext::CCC_TopLevel;
3140 case Sema::PCC_Class:
3141 return CodeCompletionContext::CCC_ClassStructUnion;
3143 case Sema::PCC_ObjCInterface:
3144 return CodeCompletionContext::CCC_ObjCInterface;
3146 case Sema::PCC_ObjCImplementation:
3147 return CodeCompletionContext::CCC_ObjCImplementation;
3149 case Sema::PCC_ObjCInstanceVariableList:
3150 return CodeCompletionContext::CCC_ObjCIvarList;
3152 case Sema::PCC_Template:
3153 case Sema::PCC_MemberTemplate:
3154 if (S.CurContext->isFileContext())
3155 return CodeCompletionContext::CCC_TopLevel;
3156 if (S.CurContext->isRecord())
3157 return CodeCompletionContext::CCC_ClassStructUnion;
3158 return CodeCompletionContext::CCC_Other;
3160 case Sema::PCC_RecoveryInFunction:
3161 return CodeCompletionContext::CCC_Recovery;
3163 case Sema::PCC_ForInit:
3164 if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 ||
3165 S.getLangOpts().ObjC1)
3166 return CodeCompletionContext::CCC_ParenthesizedExpression;
3168 return CodeCompletionContext::CCC_Expression;
3170 case Sema::PCC_Expression:
3171 case Sema::PCC_Condition:
3172 return CodeCompletionContext::CCC_Expression;
3174 case Sema::PCC_Statement:
3175 return CodeCompletionContext::CCC_Statement;
3177 case Sema::PCC_Type:
3178 return CodeCompletionContext::CCC_Type;
3180 case Sema::PCC_ParenthesizedExpression:
3181 return CodeCompletionContext::CCC_ParenthesizedExpression;
3183 case Sema::PCC_LocalDeclarationSpecifiers:
3184 return CodeCompletionContext::CCC_Type;
3187 llvm_unreachable("Invalid ParserCompletionContext!");
3190 /// \brief If we're in a C++ virtual member function, add completion results
3191 /// that invoke the functions we override, since it's common to invoke the
3192 /// overridden function as well as adding new functionality.
3194 /// \param S The semantic analysis object for which we are generating results.
3196 /// \param InContext This context in which the nested-name-specifier preceding
3197 /// the code-completion point
3198 static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext,
3199 ResultBuilder &Results) {
3200 // Look through blocks.
3201 DeclContext *CurContext = S.CurContext;
3202 while (isa<BlockDecl>(CurContext))
3203 CurContext = CurContext->getParent();
3206 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext);
3207 if (!Method || !Method->isVirtual())
3210 // We need to have names for all of the parameters, if we're going to
3211 // generate a forwarding call.
3212 for (auto P : Method->params())
3213 if (!P->getDeclName())
3216 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
3217 for (CXXMethodDecl::method_iterator M = Method->begin_overridden_methods(),
3218 MEnd = Method->end_overridden_methods();
3220 CodeCompletionBuilder Builder(Results.getAllocator(),
3221 Results.getCodeCompletionTUInfo());
3222 const CXXMethodDecl *Overridden = *M;
3223 if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl())
3226 // If we need a nested-name-specifier, add one now.
3228 NestedNameSpecifier *NNS
3229 = getRequiredQualification(S.Context, CurContext,
3230 Overridden->getDeclContext());
3233 llvm::raw_string_ostream OS(Str);
3234 NNS->print(OS, Policy);
3235 Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
3237 } else if (!InContext->Equals(Overridden->getDeclContext()))
3240 Builder.AddTypedTextChunk(Results.getAllocator().CopyString(
3241 Overridden->getNameAsString()));
3242 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
3243 bool FirstParam = true;
3244 for (auto P : Method->params()) {
3248 Builder.AddChunk(CodeCompletionString::CK_Comma);
3250 Builder.AddPlaceholderChunk(
3251 Results.getAllocator().CopyString(P->getIdentifier()->getName()));
3253 Builder.AddChunk(CodeCompletionString::CK_RightParen);
3254 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
3255 CCP_SuperCompletion,
3257 CXAvailability_Available,
3259 Results.Ignore(Overridden);
3263 void Sema::CodeCompleteModuleImport(SourceLocation ImportLoc,
3264 ModuleIdPath Path) {
3265 typedef CodeCompletionResult Result;
3266 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3267 CodeCompleter->getCodeCompletionTUInfo(),
3268 CodeCompletionContext::CCC_Other);
3269 Results.EnterNewScope();
3271 CodeCompletionAllocator &Allocator = Results.getAllocator();
3272 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
3273 typedef CodeCompletionResult Result;
3275 // Enumerate all top-level modules.
3276 SmallVector<Module *, 8> Modules;
3277 PP.getHeaderSearchInfo().collectAllModules(Modules);
3278 for (unsigned I = 0, N = Modules.size(); I != N; ++I) {
3279 Builder.AddTypedTextChunk(
3280 Builder.getAllocator().CopyString(Modules[I]->Name));
3281 Results.AddResult(Result(Builder.TakeString(),
3283 CXCursor_ModuleImportDecl,
3284 Modules[I]->isAvailable()
3285 ? CXAvailability_Available
3286 : CXAvailability_NotAvailable));
3288 } else if (getLangOpts().Modules) {
3289 // Load the named module.
3290 Module *Mod = PP.getModuleLoader().loadModule(ImportLoc, Path,
3292 /*IsInclusionDirective=*/false);
3293 // Enumerate submodules.
3295 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
3296 SubEnd = Mod->submodule_end();
3297 Sub != SubEnd; ++Sub) {
3299 Builder.AddTypedTextChunk(
3300 Builder.getAllocator().CopyString((*Sub)->Name));
3301 Results.AddResult(Result(Builder.TakeString(),
3303 CXCursor_ModuleImportDecl,
3304 (*Sub)->isAvailable()
3305 ? CXAvailability_Available
3306 : CXAvailability_NotAvailable));
3310 Results.ExitScope();
3311 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3312 Results.data(),Results.size());
3315 void Sema::CodeCompleteOrdinaryName(Scope *S,
3316 ParserCompletionContext CompletionContext) {
3317 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3318 CodeCompleter->getCodeCompletionTUInfo(),
3319 mapCodeCompletionContext(*this, CompletionContext));
3320 Results.EnterNewScope();
3322 // Determine how to filter results, e.g., so that the names of
3323 // values (functions, enumerators, function templates, etc.) are
3324 // only allowed where we can have an expression.
3325 switch (CompletionContext) {
3328 case PCC_ObjCInterface:
3329 case PCC_ObjCImplementation:
3330 case PCC_ObjCInstanceVariableList:
3332 case PCC_MemberTemplate:
3334 case PCC_LocalDeclarationSpecifiers:
3335 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
3339 case PCC_ParenthesizedExpression:
3340 case PCC_Expression:
3343 if (WantTypesInContext(CompletionContext, getLangOpts()))
3344 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3346 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3348 if (getLangOpts().CPlusPlus)
3349 MaybeAddOverrideCalls(*this, /*InContext=*/nullptr, Results);
3352 case PCC_RecoveryInFunction:
3357 // If we are in a C++ non-static member function, check the qualifiers on
3358 // the member function to filter/prioritize the results list.
3359 if (CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext))
3360 if (CurMethod->isInstance())
3361 Results.setObjectTypeQualifiers(
3362 Qualifiers::fromCVRMask(CurMethod->getTypeQualifiers()));
3364 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3365 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3366 CodeCompleter->includeGlobals());
3368 AddOrdinaryNameResults(CompletionContext, S, *this, Results);
3369 Results.ExitScope();
3371 switch (CompletionContext) {
3372 case PCC_ParenthesizedExpression:
3373 case PCC_Expression:
3375 case PCC_RecoveryInFunction:
3376 if (S->getFnParent())
3377 AddPrettyFunctionResults(getLangOpts(), Results);
3382 case PCC_ObjCInterface:
3383 case PCC_ObjCImplementation:
3384 case PCC_ObjCInstanceVariableList:
3386 case PCC_MemberTemplate:
3390 case PCC_LocalDeclarationSpecifiers:
3394 if (CodeCompleter->includeMacros())
3395 AddMacroResults(PP, Results, false);
3397 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3398 Results.data(),Results.size());
3401 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
3402 ParsedType Receiver,
3403 ArrayRef<IdentifierInfo *> SelIdents,
3404 bool AtArgumentExpression,
3406 ResultBuilder &Results);
3408 void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
3409 bool AllowNonIdentifiers,
3410 bool AllowNestedNameSpecifiers) {
3411 typedef CodeCompletionResult Result;
3412 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3413 CodeCompleter->getCodeCompletionTUInfo(),
3414 AllowNestedNameSpecifiers
3415 ? CodeCompletionContext::CCC_PotentiallyQualifiedName
3416 : CodeCompletionContext::CCC_Name);
3417 Results.EnterNewScope();
3419 // Type qualifiers can come after names.
3420 Results.AddResult(Result("const"));
3421 Results.AddResult(Result("volatile"));
3422 if (getLangOpts().C99)
3423 Results.AddResult(Result("restrict"));
3425 if (getLangOpts().CPlusPlus) {
3426 if (AllowNonIdentifiers) {
3427 Results.AddResult(Result("operator"));
3430 // Add nested-name-specifiers.
3431 if (AllowNestedNameSpecifiers) {
3432 Results.allowNestedNameSpecifiers();
3433 Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy);
3434 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3435 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
3436 CodeCompleter->includeGlobals());
3437 Results.setFilter(nullptr);
3440 Results.ExitScope();
3442 // If we're in a context where we might have an expression (rather than a
3443 // declaration), and what we've seen so far is an Objective-C type that could
3444 // be a receiver of a class message, this may be a class message send with
3445 // the initial opening bracket '[' missing. Add appropriate completions.
3446 if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
3447 DS.getParsedSpecifiers() == DeclSpec::PQ_TypeSpecifier &&
3448 DS.getTypeSpecType() == DeclSpec::TST_typename &&
3449 DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified &&
3450 DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
3451 !DS.isTypeAltiVecVector() &&
3453 (S->getFlags() & Scope::DeclScope) != 0 &&
3454 (S->getFlags() & (Scope::ClassScope | Scope::TemplateParamScope |
3455 Scope::FunctionPrototypeScope |
3456 Scope::AtCatchScope)) == 0) {
3457 ParsedType T = DS.getRepAsType();
3458 if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType())
3459 AddClassMessageCompletions(*this, S, T, None, false, false, Results);
3462 // Note that we intentionally suppress macro results here, since we do not
3463 // encourage using macros to produce the names of entities.
3465 HandleCodeCompleteResults(this, CodeCompleter,
3466 Results.getCompletionContext(),
3467 Results.data(), Results.size());
3470 struct Sema::CodeCompleteExpressionData {
3471 CodeCompleteExpressionData(QualType PreferredType = QualType())
3472 : PreferredType(PreferredType), IntegralConstantExpression(false),
3473 ObjCCollection(false) { }
3475 QualType PreferredType;
3476 bool IntegralConstantExpression;
3477 bool ObjCCollection;
3478 SmallVector<Decl *, 4> IgnoreDecls;
3481 /// \brief Perform code-completion in an expression context when we know what
3482 /// type we're looking for.
3483 void Sema::CodeCompleteExpression(Scope *S,
3484 const CodeCompleteExpressionData &Data) {
3485 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3486 CodeCompleter->getCodeCompletionTUInfo(),
3487 CodeCompletionContext::CCC_Expression);
3488 if (Data.ObjCCollection)
3489 Results.setFilter(&ResultBuilder::IsObjCCollection);
3490 else if (Data.IntegralConstantExpression)
3491 Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
3492 else if (WantTypesInContext(PCC_Expression, getLangOpts()))
3493 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3495 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3497 if (!Data.PreferredType.isNull())
3498 Results.setPreferredType(Data.PreferredType.getNonReferenceType());
3500 // Ignore any declarations that we were told that we don't care about.
3501 for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I)
3502 Results.Ignore(Data.IgnoreDecls[I]);
3504 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3505 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3506 CodeCompleter->includeGlobals());
3508 Results.EnterNewScope();
3509 AddOrdinaryNameResults(PCC_Expression, S, *this, Results);
3510 Results.ExitScope();
3512 bool PreferredTypeIsPointer = false;
3513 if (!Data.PreferredType.isNull())
3514 PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType()
3515 || Data.PreferredType->isMemberPointerType()
3516 || Data.PreferredType->isBlockPointerType();
3518 if (S->getFnParent() &&
3519 !Data.ObjCCollection &&
3520 !Data.IntegralConstantExpression)
3521 AddPrettyFunctionResults(getLangOpts(), Results);
3523 if (CodeCompleter->includeMacros())
3524 AddMacroResults(PP, Results, false, PreferredTypeIsPointer);
3525 HandleCodeCompleteResults(this, CodeCompleter,
3526 CodeCompletionContext(CodeCompletionContext::CCC_Expression,
3527 Data.PreferredType),
3528 Results.data(),Results.size());
3531 void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E) {
3533 CodeCompleteOrdinaryName(S, PCC_RecoveryInFunction);
3534 else if (getLangOpts().ObjC1)
3535 CodeCompleteObjCInstanceMessage(S, E.get(), None, false);
3538 /// \brief The set of properties that have already been added, referenced by
3540 typedef llvm::SmallPtrSet<IdentifierInfo*, 16> AddedPropertiesSet;
3542 /// \brief Retrieve the container definition, if any?
3543 static ObjCContainerDecl *getContainerDef(ObjCContainerDecl *Container) {
3544 if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
3545 if (Interface->hasDefinition())
3546 return Interface->getDefinition();
3551 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3552 if (Protocol->hasDefinition())
3553 return Protocol->getDefinition();
3560 static void AddObjCProperties(const CodeCompletionContext &CCContext,
3561 ObjCContainerDecl *Container,
3562 bool AllowCategories,
3563 bool AllowNullaryMethods,
3564 DeclContext *CurContext,
3565 AddedPropertiesSet &AddedProperties,
3566 ResultBuilder &Results) {
3567 typedef CodeCompletionResult Result;
3569 // Retrieve the definition.
3570 Container = getContainerDef(Container);
3572 // Add properties in this container.
3573 for (const auto *P : Container->properties())
3574 if (AddedProperties.insert(P->getIdentifier()).second)
3575 Results.MaybeAddResult(Result(P, Results.getBasePriority(P), nullptr),
3578 // Add nullary methods
3579 if (AllowNullaryMethods) {
3580 ASTContext &Context = Container->getASTContext();
3581 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
3582 for (auto *M : Container->methods()) {
3583 if (M->getSelector().isUnarySelector())
3584 if (IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0))
3585 if (AddedProperties.insert(Name).second) {
3586 CodeCompletionBuilder Builder(Results.getAllocator(),
3587 Results.getCodeCompletionTUInfo());
3588 AddResultTypeChunk(Context, Policy, M, CCContext.getBaseType(),
3590 Builder.AddTypedTextChunk(
3591 Results.getAllocator().CopyString(Name->getName()));
3593 Results.MaybeAddResult(Result(Builder.TakeString(), M,
3594 CCP_MemberDeclaration + CCD_MethodAsProperty),
3601 // Add properties in referenced protocols.
3602 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3603 for (auto *P : Protocol->protocols())
3604 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
3605 CurContext, AddedProperties, Results);
3606 } else if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)){
3607 if (AllowCategories) {
3608 // Look through categories.
3609 for (auto *Cat : IFace->known_categories())
3610 AddObjCProperties(CCContext, Cat, AllowCategories, AllowNullaryMethods,
3611 CurContext, AddedProperties, Results);
3614 // Look through protocols.
3615 for (auto *I : IFace->all_referenced_protocols())
3616 AddObjCProperties(CCContext, I, AllowCategories, AllowNullaryMethods,
3617 CurContext, AddedProperties, Results);
3619 // Look in the superclass.
3620 if (IFace->getSuperClass())
3621 AddObjCProperties(CCContext, IFace->getSuperClass(), AllowCategories,
3622 AllowNullaryMethods, CurContext,
3623 AddedProperties, Results);
3624 } else if (const ObjCCategoryDecl *Category
3625 = dyn_cast<ObjCCategoryDecl>(Container)) {
3626 // Look through protocols.
3627 for (auto *P : Category->protocols())
3628 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
3629 CurContext, AddedProperties, Results);
3633 void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
3634 SourceLocation OpLoc,
3636 if (!Base || !CodeCompleter)
3639 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
3640 if (ConvertedBase.isInvalid())
3642 Base = ConvertedBase.get();
3644 typedef CodeCompletionResult Result;
3646 QualType BaseType = Base->getType();
3649 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
3650 BaseType = Ptr->getPointeeType();
3651 else if (BaseType->isObjCObjectPointerType())
3657 enum CodeCompletionContext::Kind contextKind;
3660 contextKind = CodeCompletionContext::CCC_ArrowMemberAccess;
3663 if (BaseType->isObjCObjectPointerType() ||
3664 BaseType->isObjCObjectOrInterfaceType()) {
3665 contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess;
3668 contextKind = CodeCompletionContext::CCC_DotMemberAccess;
3672 CodeCompletionContext CCContext(contextKind, BaseType);
3673 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3674 CodeCompleter->getCodeCompletionTUInfo(),
3676 &ResultBuilder::IsMember);
3677 Results.EnterNewScope();
3678 if (const RecordType *Record = BaseType->getAs<RecordType>()) {
3679 // Indicate that we are performing a member access, and the cv-qualifiers
3680 // for the base object type.
3681 Results.setObjectTypeQualifiers(BaseType.getQualifiers());
3683 // Access to a C/C++ class, struct, or union.
3684 Results.allowNestedNameSpecifiers();
3685 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3686 LookupVisibleDecls(Record->getDecl(), LookupMemberName, Consumer,
3687 CodeCompleter->includeGlobals());
3689 if (getLangOpts().CPlusPlus) {
3690 if (!Results.empty()) {
3691 // The "template" keyword can follow "->" or "." in the grammar.
3692 // However, we only want to suggest the template keyword if something
3694 bool IsDependent = BaseType->isDependentType();
3696 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent())
3697 if (DeclContext *Ctx = DepScope->getEntity()) {
3698 IsDependent = Ctx->isDependentContext();
3704 Results.AddResult(Result("template"));
3707 } else if (!IsArrow && BaseType->getAsObjCInterfacePointerType()) {
3708 // Objective-C property reference.
3709 AddedPropertiesSet AddedProperties;
3711 // Add property results based on our interface.
3712 const ObjCObjectPointerType *ObjCPtr
3713 = BaseType->getAsObjCInterfacePointerType();
3714 assert(ObjCPtr && "Non-NULL pointer guaranteed above!");
3715 AddObjCProperties(CCContext, ObjCPtr->getInterfaceDecl(), true,
3716 /*AllowNullaryMethods=*/true, CurContext,
3717 AddedProperties, Results);
3719 // Add properties from the protocols in a qualified interface.
3720 for (auto *I : ObjCPtr->quals())
3721 AddObjCProperties(CCContext, I, true, /*AllowNullaryMethods=*/true,
3722 CurContext, AddedProperties, Results);
3723 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) ||
3724 (!IsArrow && BaseType->isObjCObjectType())) {
3725 // Objective-C instance variable access.
3726 ObjCInterfaceDecl *Class = nullptr;
3727 if (const ObjCObjectPointerType *ObjCPtr
3728 = BaseType->getAs<ObjCObjectPointerType>())
3729 Class = ObjCPtr->getInterfaceDecl();
3731 Class = BaseType->getAs<ObjCObjectType>()->getInterface();
3733 // Add all ivars from this class and its superclasses.
3735 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3736 Results.setFilter(&ResultBuilder::IsObjCIvar);
3737 LookupVisibleDecls(Class, LookupMemberName, Consumer,
3738 CodeCompleter->includeGlobals());
3742 // FIXME: How do we cope with isa?
3744 Results.ExitScope();
3746 // Hand off the results found for code completion.
3747 HandleCodeCompleteResults(this, CodeCompleter,
3748 Results.getCompletionContext(),
3749 Results.data(),Results.size());
3752 void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) {
3756 ResultBuilder::LookupFilter Filter = nullptr;
3757 enum CodeCompletionContext::Kind ContextKind
3758 = CodeCompletionContext::CCC_Other;
3759 switch ((DeclSpec::TST)TagSpec) {
3760 case DeclSpec::TST_enum:
3761 Filter = &ResultBuilder::IsEnum;
3762 ContextKind = CodeCompletionContext::CCC_EnumTag;
3765 case DeclSpec::TST_union:
3766 Filter = &ResultBuilder::IsUnion;
3767 ContextKind = CodeCompletionContext::CCC_UnionTag;
3770 case DeclSpec::TST_struct:
3771 case DeclSpec::TST_class:
3772 case DeclSpec::TST_interface:
3773 Filter = &ResultBuilder::IsClassOrStruct;
3774 ContextKind = CodeCompletionContext::CCC_ClassOrStructTag;
3778 llvm_unreachable("Unknown type specifier kind in CodeCompleteTag");
3781 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3782 CodeCompleter->getCodeCompletionTUInfo(), ContextKind);
3783 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3785 // First pass: look for tags.
3786 Results.setFilter(Filter);
3787 LookupVisibleDecls(S, LookupTagName, Consumer,
3788 CodeCompleter->includeGlobals());
3790 if (CodeCompleter->includeGlobals()) {
3791 // Second pass: look for nested name specifiers.
3792 Results.setFilter(&ResultBuilder::IsNestedNameSpecifier);
3793 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer);
3796 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3797 Results.data(),Results.size());
3800 void Sema::CodeCompleteTypeQualifiers(DeclSpec &DS) {
3801 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3802 CodeCompleter->getCodeCompletionTUInfo(),
3803 CodeCompletionContext::CCC_TypeQualifiers);
3804 Results.EnterNewScope();
3805 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
3806 Results.AddResult("const");
3807 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile))
3808 Results.AddResult("volatile");
3809 if (getLangOpts().C99 &&
3810 !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict))
3811 Results.AddResult("restrict");
3812 if (getLangOpts().C11 &&
3813 !(DS.getTypeQualifiers() & DeclSpec::TQ_atomic))
3814 Results.AddResult("_Atomic");
3815 Results.ExitScope();
3816 HandleCodeCompleteResults(this, CodeCompleter,
3817 Results.getCompletionContext(),
3818 Results.data(), Results.size());
3821 void Sema::CodeCompleteCase(Scope *S) {
3822 if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
3825 SwitchStmt *Switch = getCurFunction()->SwitchStack.back();
3826 QualType type = Switch->getCond()->IgnoreImplicit()->getType();
3827 if (!type->isEnumeralType()) {
3828 CodeCompleteExpressionData Data(type);
3829 Data.IntegralConstantExpression = true;
3830 CodeCompleteExpression(S, Data);
3834 // Code-complete the cases of a switch statement over an enumeration type
3835 // by providing the list of
3836 EnumDecl *Enum = type->castAs<EnumType>()->getDecl();
3837 if (EnumDecl *Def = Enum->getDefinition())
3840 // Determine which enumerators we have already seen in the switch statement.
3841 // FIXME: Ideally, we would also be able to look *past* the code-completion
3842 // token, in case we are code-completing in the middle of the switch and not
3843 // at the end. However, we aren't able to do so at the moment.
3844 llvm::SmallPtrSet<EnumConstantDecl *, 8> EnumeratorsSeen;
3845 NestedNameSpecifier *Qualifier = nullptr;
3846 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC;
3847 SC = SC->getNextSwitchCase()) {
3848 CaseStmt *Case = dyn_cast<CaseStmt>(SC);
3852 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
3853 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CaseVal))
3854 if (EnumConstantDecl *Enumerator
3855 = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
3856 // We look into the AST of the case statement to determine which
3857 // enumerator was named. Alternatively, we could compute the value of
3858 // the integral constant expression, then compare it against the
3859 // values of each enumerator. However, value-based approach would not
3860 // work as well with C++ templates where enumerators declared within a
3861 // template are type- and value-dependent.
3862 EnumeratorsSeen.insert(Enumerator);
3864 // If this is a qualified-id, keep track of the nested-name-specifier
3865 // so that we can reproduce it as part of code completion, e.g.,
3867 // switch (TagD.getKind()) {
3868 // case TagDecl::TK_enum:
3872 // At the XXX, our completions are TagDecl::TK_union,
3873 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union,
3874 // TK_struct, and TK_class.
3875 Qualifier = DRE->getQualifier();
3879 if (getLangOpts().CPlusPlus && !Qualifier && EnumeratorsSeen.empty()) {
3880 // If there are no prior enumerators in C++, check whether we have to
3881 // qualify the names of the enumerators that we suggest, because they
3882 // may not be visible in this scope.
3883 Qualifier = getRequiredQualification(Context, CurContext, Enum);
3886 // Add any enumerators that have not yet been mentioned.
3887 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3888 CodeCompleter->getCodeCompletionTUInfo(),
3889 CodeCompletionContext::CCC_Expression);
3890 Results.EnterNewScope();
3891 for (auto *E : Enum->enumerators()) {
3892 if (EnumeratorsSeen.count(E))
3895 CodeCompletionResult R(E, CCP_EnumInCase, Qualifier);
3896 Results.AddResult(R, CurContext, nullptr, false);
3898 Results.ExitScope();
3900 //We need to make sure we're setting the right context,
3901 //so only say we include macros if the code completer says we do
3902 enum CodeCompletionContext::Kind kind = CodeCompletionContext::CCC_Other;
3903 if (CodeCompleter->includeMacros()) {
3904 AddMacroResults(PP, Results, false);
3905 kind = CodeCompletionContext::CCC_OtherWithMacros;
3908 HandleCodeCompleteResults(this, CodeCompleter,
3910 Results.data(),Results.size());
3913 static bool anyNullArguments(ArrayRef<Expr *> Args) {
3914 if (Args.size() && !Args.data())
3917 for (unsigned I = 0; I != Args.size(); ++I)
3924 typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate;
3926 static void mergeCandidatesWithResults(Sema &SemaRef,
3927 SmallVectorImpl<ResultCandidate> &Results,
3928 OverloadCandidateSet &CandidateSet,
3929 SourceLocation Loc) {
3930 if (!CandidateSet.empty()) {
3931 // Sort the overload candidate set by placing the best overloads first.
3933 CandidateSet.begin(), CandidateSet.end(),
3934 [&](const OverloadCandidate &X, const OverloadCandidate &Y) {
3935 return isBetterOverloadCandidate(SemaRef, X, Y, Loc);
3938 // Add the remaining viable overload candidates as code-completion results.
3939 for (auto &Candidate : CandidateSet)
3940 if (Candidate.Viable)
3941 Results.push_back(ResultCandidate(Candidate.Function));
3945 /// \brief Get the type of the Nth parameter from a given set of overload
3947 static QualType getParamType(Sema &SemaRef,
3948 ArrayRef<ResultCandidate> Candidates,
3951 // Given the overloads 'Candidates' for a function call matching all arguments
3952 // up to N, return the type of the Nth parameter if it is the same for all
3953 // overload candidates.
3955 for (auto &Candidate : Candidates) {
3956 if (auto FType = Candidate.getFunctionType())
3957 if (auto Proto = dyn_cast<FunctionProtoType>(FType))
3958 if (N < Proto->getNumParams()) {
3959 if (ParamType.isNull())
3960 ParamType = Proto->getParamType(N);
3961 else if (!SemaRef.Context.hasSameUnqualifiedType(
3962 ParamType.getNonReferenceType(),
3963 Proto->getParamType(N).getNonReferenceType()))
3964 // Otherwise return a default-constructed QualType.
3972 static void CodeCompleteOverloadResults(Sema &SemaRef, Scope *S,
3973 MutableArrayRef<ResultCandidate> Candidates,
3974 unsigned CurrentArg,
3975 bool CompleteExpressionWithCurrentArg = true) {
3977 if (CompleteExpressionWithCurrentArg)
3978 ParamType = getParamType(SemaRef, Candidates, CurrentArg);
3980 if (ParamType.isNull())
3981 SemaRef.CodeCompleteOrdinaryName(S, Sema::PCC_Expression);
3983 SemaRef.CodeCompleteExpression(S, ParamType);
3985 if (!Candidates.empty())
3986 SemaRef.CodeCompleter->ProcessOverloadCandidates(SemaRef, CurrentArg,
3991 void Sema::CodeCompleteCall(Scope *S, Expr *Fn, ArrayRef<Expr *> Args) {
3995 // When we're code-completing for a call, we fall back to ordinary
3996 // name code-completion whenever we can't produce specific
3997 // results. We may want to revisit this strategy in the future,
3998 // e.g., by merging the two kinds of results.
4000 // FIXME: Provide support for variadic template functions.
4002 // Ignore type-dependent call expressions entirely.
4003 if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args) ||
4004 Expr::hasAnyTypeDependentArguments(Args)) {
4005 CodeCompleteOrdinaryName(S, PCC_Expression);
4009 // Build an overload candidate set based on the functions we find.
4010 SourceLocation Loc = Fn->getExprLoc();
4011 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
4013 SmallVector<ResultCandidate, 8> Results;
4015 Expr *NakedFn = Fn->IgnoreParenCasts();
4016 if (auto ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn))
4017 AddOverloadedCallCandidates(ULE, Args, CandidateSet,
4018 /*PartialOverloading=*/true);
4019 else if (auto UME = dyn_cast<UnresolvedMemberExpr>(NakedFn)) {
4020 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
4021 if (UME->hasExplicitTemplateArgs()) {
4022 UME->copyTemplateArgumentsInto(TemplateArgsBuffer);
4023 TemplateArgs = &TemplateArgsBuffer;
4025 SmallVector<Expr *, 12> ArgExprs(1, UME->getBase());
4026 ArgExprs.append(Args.begin(), Args.end());
4027 UnresolvedSet<8> Decls;
4028 Decls.append(UME->decls_begin(), UME->decls_end());
4029 AddFunctionCandidates(Decls, ArgExprs, CandidateSet, TemplateArgs,
4030 /*SuppressUsedConversions=*/false,
4031 /*PartialOverloading=*/true);
4033 FunctionDecl *FD = nullptr;
4034 if (auto MCE = dyn_cast<MemberExpr>(NakedFn))
4035 FD = dyn_cast<FunctionDecl>(MCE->getMemberDecl());
4036 else if (auto DRE = dyn_cast<DeclRefExpr>(NakedFn))
4037 FD = dyn_cast<FunctionDecl>(DRE->getDecl());
4038 if (FD) { // We check whether it's a resolved function declaration.
4039 if (!getLangOpts().CPlusPlus ||
4040 !FD->getType()->getAs<FunctionProtoType>())
4041 Results.push_back(ResultCandidate(FD));
4043 AddOverloadCandidate(FD, DeclAccessPair::make(FD, FD->getAccess()),
4045 /*SuppressUsedConversions=*/false,
4046 /*PartialOverloading=*/true);
4048 } else if (auto DC = NakedFn->getType()->getAsCXXRecordDecl()) {
4049 // If expression's type is CXXRecordDecl, it may overload the function
4050 // call operator, so we check if it does and add them as candidates.
4051 // A complete type is needed to lookup for member function call operators.
4052 if (isCompleteType(Loc, NakedFn->getType())) {
4053 DeclarationName OpName = Context.DeclarationNames
4054 .getCXXOperatorName(OO_Call);
4055 LookupResult R(*this, OpName, Loc, LookupOrdinaryName);
4056 LookupQualifiedName(R, DC);
4057 R.suppressDiagnostics();
4058 SmallVector<Expr *, 12> ArgExprs(1, NakedFn);
4059 ArgExprs.append(Args.begin(), Args.end());
4060 AddFunctionCandidates(R.asUnresolvedSet(), ArgExprs, CandidateSet,
4061 /*ExplicitArgs=*/nullptr,
4062 /*SuppressUsedConversions=*/false,
4063 /*PartialOverloading=*/true);
4066 // Lastly we check whether expression's type is function pointer or
4068 QualType T = NakedFn->getType();
4069 if (!T->getPointeeType().isNull())
4070 T = T->getPointeeType();
4072 if (auto FP = T->getAs<FunctionProtoType>()) {
4073 if (!TooManyArguments(FP->getNumParams(), Args.size(),
4074 /*PartialOverloading=*/true) ||
4076 Results.push_back(ResultCandidate(FP));
4077 } else if (auto FT = T->getAs<FunctionType>())
4078 // No prototype and declaration, it may be a K & R style function.
4079 Results.push_back(ResultCandidate(FT));
4083 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4084 CodeCompleteOverloadResults(*this, S, Results, Args.size(),
4085 !CandidateSet.empty());
4088 void Sema::CodeCompleteConstructor(Scope *S, QualType Type, SourceLocation Loc,
4089 ArrayRef<Expr *> Args) {
4093 // A complete type is needed to lookup for constructors.
4094 if (!isCompleteType(Loc, Type))
4097 CXXRecordDecl *RD = Type->getAsCXXRecordDecl();
4099 CodeCompleteExpression(S, Type);
4103 // FIXME: Provide support for member initializers.
4104 // FIXME: Provide support for variadic template constructors.
4106 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
4108 for (auto C : LookupConstructors(RD)) {
4109 if (auto FD = dyn_cast<FunctionDecl>(C)) {
4110 AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()),
4112 /*SuppressUsedConversions=*/false,
4113 /*PartialOverloading=*/true);
4114 } else if (auto FTD = dyn_cast<FunctionTemplateDecl>(C)) {
4115 AddTemplateOverloadCandidate(FTD,
4116 DeclAccessPair::make(FTD, C->getAccess()),
4117 /*ExplicitTemplateArgs=*/nullptr,
4119 /*SuppressUsedConversions=*/false,
4120 /*PartialOverloading=*/true);
4124 SmallVector<ResultCandidate, 8> Results;
4125 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4126 CodeCompleteOverloadResults(*this, S, Results, Args.size());
4129 void Sema::CodeCompleteInitializer(Scope *S, Decl *D) {
4130 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D);
4132 CodeCompleteOrdinaryName(S, PCC_Expression);
4136 CodeCompleteExpression(S, VD->getType());
4139 void Sema::CodeCompleteReturn(Scope *S) {
4140 QualType ResultType;
4141 if (isa<BlockDecl>(CurContext)) {
4142 if (BlockScopeInfo *BSI = getCurBlock())
4143 ResultType = BSI->ReturnType;
4144 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(CurContext))
4145 ResultType = Function->getReturnType();
4146 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(CurContext))
4147 ResultType = Method->getReturnType();
4149 if (ResultType.isNull())
4150 CodeCompleteOrdinaryName(S, PCC_Expression);
4152 CodeCompleteExpression(S, ResultType);
4155 void Sema::CodeCompleteAfterIf(Scope *S) {
4156 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4157 CodeCompleter->getCodeCompletionTUInfo(),
4158 mapCodeCompletionContext(*this, PCC_Statement));
4159 Results.setFilter(&ResultBuilder::IsOrdinaryName);
4160 Results.EnterNewScope();
4162 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4163 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4164 CodeCompleter->includeGlobals());
4166 AddOrdinaryNameResults(PCC_Statement, S, *this, Results);
4169 CodeCompletionBuilder Builder(Results.getAllocator(),
4170 Results.getCodeCompletionTUInfo());
4171 Builder.AddTypedTextChunk("else");
4172 if (Results.includeCodePatterns()) {
4173 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4174 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4175 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4176 Builder.AddPlaceholderChunk("statements");
4177 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4178 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4180 Results.AddResult(Builder.TakeString());
4183 Builder.AddTypedTextChunk("else");
4184 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4185 Builder.AddTextChunk("if");
4186 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4187 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4188 if (getLangOpts().CPlusPlus)
4189 Builder.AddPlaceholderChunk("condition");
4191 Builder.AddPlaceholderChunk("expression");
4192 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4193 if (Results.includeCodePatterns()) {
4194 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4195 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4196 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4197 Builder.AddPlaceholderChunk("statements");
4198 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4199 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4201 Results.AddResult(Builder.TakeString());
4203 Results.ExitScope();
4205 if (S->getFnParent())
4206 AddPrettyFunctionResults(getLangOpts(), Results);
4208 if (CodeCompleter->includeMacros())
4209 AddMacroResults(PP, Results, false);
4211 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4212 Results.data(),Results.size());
4215 void Sema::CodeCompleteAssignmentRHS(Scope *S, Expr *LHS) {
4217 CodeCompleteExpression(S, static_cast<Expr *>(LHS)->getType());
4219 CodeCompleteOrdinaryName(S, PCC_Expression);
4222 void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
4223 bool EnteringContext) {
4224 if (!SS.getScopeRep() || !CodeCompleter)
4227 DeclContext *Ctx = computeDeclContext(SS, EnteringContext);
4231 // Try to instantiate any non-dependent declaration contexts before
4233 if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx))
4236 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4237 CodeCompleter->getCodeCompletionTUInfo(),
4238 CodeCompletionContext::CCC_Name);
4239 Results.EnterNewScope();
4241 // The "template" keyword can follow "::" in the grammar, but only
4242 // put it into the grammar if the nested-name-specifier is dependent.
4243 NestedNameSpecifier *NNS = SS.getScopeRep();
4244 if (!Results.empty() && NNS->isDependent())
4245 Results.AddResult("template");
4247 // Add calls to overridden virtual functions, if there are any.
4249 // FIXME: This isn't wonderful, because we don't know whether we're actually
4250 // in a context that permits expressions. This is a general issue with
4251 // qualified-id completions.
4252 if (!EnteringContext)
4253 MaybeAddOverrideCalls(*this, Ctx, Results);
4254 Results.ExitScope();
4256 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4257 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer);
4259 HandleCodeCompleteResults(this, CodeCompleter,
4260 Results.getCompletionContext(),
4261 Results.data(),Results.size());
4264 void Sema::CodeCompleteUsing(Scope *S) {
4268 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4269 CodeCompleter->getCodeCompletionTUInfo(),
4270 CodeCompletionContext::CCC_PotentiallyQualifiedName,
4271 &ResultBuilder::IsNestedNameSpecifier);
4272 Results.EnterNewScope();
4274 // If we aren't in class scope, we could see the "namespace" keyword.
4275 if (!S->isClassScope())
4276 Results.AddResult(CodeCompletionResult("namespace"));
4278 // After "using", we can see anything that would start a
4279 // nested-name-specifier.
4280 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4281 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4282 CodeCompleter->includeGlobals());
4283 Results.ExitScope();
4285 HandleCodeCompleteResults(this, CodeCompleter,
4286 CodeCompletionContext::CCC_PotentiallyQualifiedName,
4287 Results.data(),Results.size());
4290 void Sema::CodeCompleteUsingDirective(Scope *S) {
4294 // After "using namespace", we expect to see a namespace name or namespace
4296 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4297 CodeCompleter->getCodeCompletionTUInfo(),
4298 CodeCompletionContext::CCC_Namespace,
4299 &ResultBuilder::IsNamespaceOrAlias);
4300 Results.EnterNewScope();
4301 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4302 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4303 CodeCompleter->includeGlobals());
4304 Results.ExitScope();
4305 HandleCodeCompleteResults(this, CodeCompleter,
4306 CodeCompletionContext::CCC_Namespace,
4307 Results.data(),Results.size());
4310 void Sema::CodeCompleteNamespaceDecl(Scope *S) {
4314 DeclContext *Ctx = S->getEntity();
4315 if (!S->getParent())
4316 Ctx = Context.getTranslationUnitDecl();
4318 bool SuppressedGlobalResults
4319 = Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx);
4321 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4322 CodeCompleter->getCodeCompletionTUInfo(),
4323 SuppressedGlobalResults
4324 ? CodeCompletionContext::CCC_Namespace
4325 : CodeCompletionContext::CCC_Other,
4326 &ResultBuilder::IsNamespace);
4328 if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) {
4329 // We only want to see those namespaces that have already been defined
4330 // within this scope, because its likely that the user is creating an
4331 // extended namespace declaration. Keep track of the most recent
4332 // definition of each namespace.
4333 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest;
4334 for (DeclContext::specific_decl_iterator<NamespaceDecl>
4335 NS(Ctx->decls_begin()), NSEnd(Ctx->decls_end());
4337 OrigToLatest[NS->getOriginalNamespace()] = *NS;
4339 // Add the most recent definition (or extended definition) of each
4340 // namespace to the list of results.
4341 Results.EnterNewScope();
4342 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator
4343 NS = OrigToLatest.begin(),
4344 NSEnd = OrigToLatest.end();
4346 Results.AddResult(CodeCompletionResult(
4347 NS->second, Results.getBasePriority(NS->second),
4349 CurContext, nullptr, false);
4350 Results.ExitScope();
4353 HandleCodeCompleteResults(this, CodeCompleter,
4354 Results.getCompletionContext(),
4355 Results.data(),Results.size());
4358 void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) {
4362 // After "namespace", we expect to see a namespace or alias.
4363 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4364 CodeCompleter->getCodeCompletionTUInfo(),
4365 CodeCompletionContext::CCC_Namespace,
4366 &ResultBuilder::IsNamespaceOrAlias);
4367 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4368 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4369 CodeCompleter->includeGlobals());
4370 HandleCodeCompleteResults(this, CodeCompleter,
4371 Results.getCompletionContext(),
4372 Results.data(),Results.size());
4375 void Sema::CodeCompleteOperatorName(Scope *S) {
4379 typedef CodeCompletionResult Result;
4380 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4381 CodeCompleter->getCodeCompletionTUInfo(),
4382 CodeCompletionContext::CCC_Type,
4383 &ResultBuilder::IsType);
4384 Results.EnterNewScope();
4386 // Add the names of overloadable operators.
4387 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4388 if (std::strcmp(Spelling, "?")) \
4389 Results.AddResult(Result(Spelling));
4390 #include "clang/Basic/OperatorKinds.def"
4392 // Add any type names visible from the current scope
4393 Results.allowNestedNameSpecifiers();
4394 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4395 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4396 CodeCompleter->includeGlobals());
4398 // Add any type specifiers
4399 AddTypeSpecifierResults(getLangOpts(), Results);
4400 Results.ExitScope();
4402 HandleCodeCompleteResults(this, CodeCompleter,
4403 CodeCompletionContext::CCC_Type,
4404 Results.data(),Results.size());
4407 void Sema::CodeCompleteConstructorInitializer(
4409 ArrayRef <CXXCtorInitializer *> Initializers) {
4413 AdjustDeclIfTemplate(ConstructorD);
4415 CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ConstructorD);
4419 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4420 CodeCompleter->getCodeCompletionTUInfo(),
4421 CodeCompletionContext::CCC_PotentiallyQualifiedName);
4422 Results.EnterNewScope();
4424 // Fill in any already-initialized fields or base classes.
4425 llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
4426 llvm::SmallPtrSet<CanQualType, 4> InitializedBases;
4427 for (unsigned I = 0, E = Initializers.size(); I != E; ++I) {
4428 if (Initializers[I]->isBaseInitializer())
4429 InitializedBases.insert(
4430 Context.getCanonicalType(QualType(Initializers[I]->getBaseClass(), 0)));
4432 InitializedFields.insert(cast<FieldDecl>(
4433 Initializers[I]->getAnyMember()));
4436 // Add completions for base classes.
4437 CodeCompletionBuilder Builder(Results.getAllocator(),
4438 Results.getCodeCompletionTUInfo());
4439 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
4440 bool SawLastInitializer = Initializers.empty();
4441 CXXRecordDecl *ClassDecl = Constructor->getParent();
4442 for (const auto &Base : ClassDecl->bases()) {
4443 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4446 = !Initializers.empty() &&
4447 Initializers.back()->isBaseInitializer() &&
4448 Context.hasSameUnqualifiedType(Base.getType(),
4449 QualType(Initializers.back()->getBaseClass(), 0));
4453 Builder.AddTypedTextChunk(
4454 Results.getAllocator().CopyString(
4455 Base.getType().getAsString(Policy)));
4456 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4457 Builder.AddPlaceholderChunk("args");
4458 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4459 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4460 SawLastInitializer? CCP_NextInitializer
4461 : CCP_MemberDeclaration));
4462 SawLastInitializer = false;
4465 // Add completions for virtual base classes.
4466 for (const auto &Base : ClassDecl->vbases()) {
4467 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4470 = !Initializers.empty() &&
4471 Initializers.back()->isBaseInitializer() &&
4472 Context.hasSameUnqualifiedType(Base.getType(),
4473 QualType(Initializers.back()->getBaseClass(), 0));
4477 Builder.AddTypedTextChunk(
4478 Builder.getAllocator().CopyString(
4479 Base.getType().getAsString(Policy)));
4480 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4481 Builder.AddPlaceholderChunk("args");
4482 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4483 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4484 SawLastInitializer? CCP_NextInitializer
4485 : CCP_MemberDeclaration));
4486 SawLastInitializer = false;
4489 // Add completions for members.
4490 for (auto *Field : ClassDecl->fields()) {
4491 if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))
4494 = !Initializers.empty() &&
4495 Initializers.back()->isAnyMemberInitializer() &&
4496 Initializers.back()->getAnyMember() == Field;
4500 if (!Field->getDeclName())
4503 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
4504 Field->getIdentifier()->getName()));
4505 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4506 Builder.AddPlaceholderChunk("args");
4507 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4508 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4509 SawLastInitializer? CCP_NextInitializer
4510 : CCP_MemberDeclaration,
4512 CXAvailability_Available,
4514 SawLastInitializer = false;
4516 Results.ExitScope();
4518 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4519 Results.data(), Results.size());
4522 /// \brief Determine whether this scope denotes a namespace.
4523 static bool isNamespaceScope(Scope *S) {
4524 DeclContext *DC = S->getEntity();
4528 return DC->isFileContext();
4531 void Sema::CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
4532 bool AfterAmpersand) {
4533 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4534 CodeCompleter->getCodeCompletionTUInfo(),
4535 CodeCompletionContext::CCC_Other);
4536 Results.EnterNewScope();
4538 // Note what has already been captured.
4539 llvm::SmallPtrSet<IdentifierInfo *, 4> Known;
4540 bool IncludedThis = false;
4541 for (const auto &C : Intro.Captures) {
4542 if (C.Kind == LCK_This) {
4543 IncludedThis = true;
4550 // Look for other capturable variables.
4551 for (; S && !isNamespaceScope(S); S = S->getParent()) {
4552 for (const auto *D : S->decls()) {
4553 const auto *Var = dyn_cast<VarDecl>(D);
4555 !Var->hasLocalStorage() ||
4556 Var->hasAttr<BlocksAttr>())
4559 if (Known.insert(Var->getIdentifier()).second)
4560 Results.AddResult(CodeCompletionResult(Var, CCP_LocalDeclaration),
4561 CurContext, nullptr, false);
4565 // Add 'this', if it would be valid.
4566 if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy)
4567 addThisCompletion(*this, Results);
4569 Results.ExitScope();
4571 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4572 Results.data(), Results.size());
4575 /// Macro that optionally prepends an "@" to the string literal passed in via
4576 /// Keyword, depending on whether NeedAt is true or false.
4577 #define OBJC_AT_KEYWORD_NAME(NeedAt,Keyword) ((NeedAt)? "@" Keyword : Keyword)
4579 static void AddObjCImplementationResults(const LangOptions &LangOpts,
4580 ResultBuilder &Results,
4582 typedef CodeCompletionResult Result;
4583 // Since we have an implementation, we can end it.
4584 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
4586 CodeCompletionBuilder Builder(Results.getAllocator(),
4587 Results.getCodeCompletionTUInfo());
4588 if (LangOpts.ObjC2) {
4590 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"dynamic"));
4591 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4592 Builder.AddPlaceholderChunk("property");
4593 Results.AddResult(Result(Builder.TakeString()));
4596 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synthesize"));
4597 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4598 Builder.AddPlaceholderChunk("property");
4599 Results.AddResult(Result(Builder.TakeString()));
4603 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
4604 ResultBuilder &Results,
4606 typedef CodeCompletionResult Result;
4608 // Since we have an interface or protocol, we can end it.
4609 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
4611 if (LangOpts.ObjC2) {
4613 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"property")));
4616 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"required")));
4619 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"optional")));
4623 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
4624 typedef CodeCompletionResult Result;
4625 CodeCompletionBuilder Builder(Results.getAllocator(),
4626 Results.getCodeCompletionTUInfo());
4629 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"class"));
4630 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4631 Builder.AddPlaceholderChunk("name");
4632 Results.AddResult(Result(Builder.TakeString()));
4634 if (Results.includeCodePatterns()) {
4636 // FIXME: Could introduce the whole pattern, including superclasses and
4638 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"interface"));
4639 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4640 Builder.AddPlaceholderChunk("class");
4641 Results.AddResult(Result(Builder.TakeString()));
4644 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
4645 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4646 Builder.AddPlaceholderChunk("protocol");
4647 Results.AddResult(Result(Builder.TakeString()));
4649 // @implementation name
4650 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"implementation"));
4651 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4652 Builder.AddPlaceholderChunk("class");
4653 Results.AddResult(Result(Builder.TakeString()));
4656 // @compatibility_alias name
4657 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"compatibility_alias"));
4658 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4659 Builder.AddPlaceholderChunk("alias");
4660 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4661 Builder.AddPlaceholderChunk("class");
4662 Results.AddResult(Result(Builder.TakeString()));
4664 if (Results.getSema().getLangOpts().Modules) {
4666 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import"));
4667 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4668 Builder.AddPlaceholderChunk("module");
4669 Results.AddResult(Result(Builder.TakeString()));
4673 void Sema::CodeCompleteObjCAtDirective(Scope *S) {
4674 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4675 CodeCompleter->getCodeCompletionTUInfo(),
4676 CodeCompletionContext::CCC_Other);
4677 Results.EnterNewScope();
4678 if (isa<ObjCImplDecl>(CurContext))
4679 AddObjCImplementationResults(getLangOpts(), Results, false);
4680 else if (CurContext->isObjCContainer())
4681 AddObjCInterfaceResults(getLangOpts(), Results, false);
4683 AddObjCTopLevelResults(Results, false);
4684 Results.ExitScope();
4685 HandleCodeCompleteResults(this, CodeCompleter,
4686 CodeCompletionContext::CCC_Other,
4687 Results.data(),Results.size());
4690 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) {
4691 typedef CodeCompletionResult Result;
4692 CodeCompletionBuilder Builder(Results.getAllocator(),
4693 Results.getCodeCompletionTUInfo());
4695 // @encode ( type-name )
4696 const char *EncodeType = "char[]";
4697 if (Results.getSema().getLangOpts().CPlusPlus ||
4698 Results.getSema().getLangOpts().ConstStrings)
4699 EncodeType = "const char[]";
4700 Builder.AddResultTypeChunk(EncodeType);
4701 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"encode"));
4702 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4703 Builder.AddPlaceholderChunk("type-name");
4704 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4705 Results.AddResult(Result(Builder.TakeString()));
4707 // @protocol ( protocol-name )
4708 Builder.AddResultTypeChunk("Protocol *");
4709 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
4710 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4711 Builder.AddPlaceholderChunk("protocol-name");
4712 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4713 Results.AddResult(Result(Builder.TakeString()));
4715 // @selector ( selector )
4716 Builder.AddResultTypeChunk("SEL");
4717 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"selector"));
4718 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4719 Builder.AddPlaceholderChunk("selector");
4720 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4721 Results.AddResult(Result(Builder.TakeString()));
4724 Builder.AddResultTypeChunk("NSString *");
4725 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"\""));
4726 Builder.AddPlaceholderChunk("string");
4727 Builder.AddTextChunk("\"");
4728 Results.AddResult(Result(Builder.TakeString()));
4731 Builder.AddResultTypeChunk("NSArray *");
4732 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"["));
4733 Builder.AddPlaceholderChunk("objects, ...");
4734 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
4735 Results.AddResult(Result(Builder.TakeString()));
4737 // @{key : object, ...}
4738 Builder.AddResultTypeChunk("NSDictionary *");
4739 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"{"));
4740 Builder.AddPlaceholderChunk("key");
4741 Builder.AddChunk(CodeCompletionString::CK_Colon);
4742 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4743 Builder.AddPlaceholderChunk("object, ...");
4744 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4745 Results.AddResult(Result(Builder.TakeString()));
4748 Builder.AddResultTypeChunk("id");
4749 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "("));
4750 Builder.AddPlaceholderChunk("expression");
4751 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4752 Results.AddResult(Result(Builder.TakeString()));
4755 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) {
4756 typedef CodeCompletionResult Result;
4757 CodeCompletionBuilder Builder(Results.getAllocator(),
4758 Results.getCodeCompletionTUInfo());
4760 if (Results.includeCodePatterns()) {
4761 // @try { statements } @catch ( declaration ) { statements } @finally
4763 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"try"));
4764 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4765 Builder.AddPlaceholderChunk("statements");
4766 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4767 Builder.AddTextChunk("@catch");
4768 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4769 Builder.AddPlaceholderChunk("parameter");
4770 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4771 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4772 Builder.AddPlaceholderChunk("statements");
4773 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4774 Builder.AddTextChunk("@finally");
4775 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4776 Builder.AddPlaceholderChunk("statements");
4777 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4778 Results.AddResult(Result(Builder.TakeString()));
4782 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"throw"));
4783 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4784 Builder.AddPlaceholderChunk("expression");
4785 Results.AddResult(Result(Builder.TakeString()));
4787 if (Results.includeCodePatterns()) {
4788 // @synchronized ( expression ) { statements }
4789 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synchronized"));
4790 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4791 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4792 Builder.AddPlaceholderChunk("expression");
4793 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4794 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4795 Builder.AddPlaceholderChunk("statements");
4796 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4797 Results.AddResult(Result(Builder.TakeString()));
4801 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
4802 ResultBuilder &Results,
4804 typedef CodeCompletionResult Result;
4805 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"private")));
4806 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"protected")));
4807 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"public")));
4809 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"package")));
4812 void Sema::CodeCompleteObjCAtVisibility(Scope *S) {
4813 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4814 CodeCompleter->getCodeCompletionTUInfo(),
4815 CodeCompletionContext::CCC_Other);
4816 Results.EnterNewScope();
4817 AddObjCVisibilityResults(getLangOpts(), Results, false);
4818 Results.ExitScope();
4819 HandleCodeCompleteResults(this, CodeCompleter,
4820 CodeCompletionContext::CCC_Other,
4821 Results.data(),Results.size());
4824 void Sema::CodeCompleteObjCAtStatement(Scope *S) {
4825 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4826 CodeCompleter->getCodeCompletionTUInfo(),
4827 CodeCompletionContext::CCC_Other);
4828 Results.EnterNewScope();
4829 AddObjCStatementResults(Results, false);
4830 AddObjCExpressionResults(Results, false);
4831 Results.ExitScope();
4832 HandleCodeCompleteResults(this, CodeCompleter,
4833 CodeCompletionContext::CCC_Other,
4834 Results.data(),Results.size());
4837 void Sema::CodeCompleteObjCAtExpression(Scope *S) {
4838 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4839 CodeCompleter->getCodeCompletionTUInfo(),
4840 CodeCompletionContext::CCC_Other);
4841 Results.EnterNewScope();
4842 AddObjCExpressionResults(Results, false);
4843 Results.ExitScope();
4844 HandleCodeCompleteResults(this, CodeCompleter,
4845 CodeCompletionContext::CCC_Other,
4846 Results.data(),Results.size());
4849 /// \brief Determine whether the addition of the given flag to an Objective-C
4850 /// property's attributes will cause a conflict.
4851 static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) {
4852 // Check if we've already added this flag.
4853 if (Attributes & NewFlag)
4856 Attributes |= NewFlag;
4858 // Check for collisions with "readonly".
4859 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
4860 (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
4863 // Check for more than one of { assign, copy, retain, strong, weak }.
4864 unsigned AssignCopyRetMask = Attributes & (ObjCDeclSpec::DQ_PR_assign |
4865 ObjCDeclSpec::DQ_PR_unsafe_unretained |
4866 ObjCDeclSpec::DQ_PR_copy |
4867 ObjCDeclSpec::DQ_PR_retain |
4868 ObjCDeclSpec::DQ_PR_strong |
4869 ObjCDeclSpec::DQ_PR_weak);
4870 if (AssignCopyRetMask &&
4871 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign &&
4872 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_unsafe_unretained &&
4873 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy &&
4874 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain &&
4875 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_strong &&
4876 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_weak)
4882 void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) {
4886 unsigned Attributes = ODS.getPropertyAttributes();
4888 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4889 CodeCompleter->getCodeCompletionTUInfo(),
4890 CodeCompletionContext::CCC_Other);
4891 Results.EnterNewScope();
4892 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readonly))
4893 Results.AddResult(CodeCompletionResult("readonly"));
4894 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_assign))
4895 Results.AddResult(CodeCompletionResult("assign"));
4896 if (!ObjCPropertyFlagConflicts(Attributes,
4897 ObjCDeclSpec::DQ_PR_unsafe_unretained))
4898 Results.AddResult(CodeCompletionResult("unsafe_unretained"));
4899 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readwrite))
4900 Results.AddResult(CodeCompletionResult("readwrite"));
4901 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_retain))
4902 Results.AddResult(CodeCompletionResult("retain"));
4903 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_strong))
4904 Results.AddResult(CodeCompletionResult("strong"));
4905 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_copy))
4906 Results.AddResult(CodeCompletionResult("copy"));
4907 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nonatomic))
4908 Results.AddResult(CodeCompletionResult("nonatomic"));
4909 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_atomic))
4910 Results.AddResult(CodeCompletionResult("atomic"));
4912 // Only suggest "weak" if we're compiling for ARC-with-weak-references or GC.
4913 if (getLangOpts().ObjCWeak || getLangOpts().getGC() != LangOptions::NonGC)
4914 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_weak))
4915 Results.AddResult(CodeCompletionResult("weak"));
4917 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_setter)) {
4918 CodeCompletionBuilder Setter(Results.getAllocator(),
4919 Results.getCodeCompletionTUInfo());
4920 Setter.AddTypedTextChunk("setter");
4921 Setter.AddTextChunk("=");
4922 Setter.AddPlaceholderChunk("method");
4923 Results.AddResult(CodeCompletionResult(Setter.TakeString()));
4925 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_getter)) {
4926 CodeCompletionBuilder Getter(Results.getAllocator(),
4927 Results.getCodeCompletionTUInfo());
4928 Getter.AddTypedTextChunk("getter");
4929 Getter.AddTextChunk("=");
4930 Getter.AddPlaceholderChunk("method");
4931 Results.AddResult(CodeCompletionResult(Getter.TakeString()));
4933 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nullability)) {
4934 Results.AddResult(CodeCompletionResult("nonnull"));
4935 Results.AddResult(CodeCompletionResult("nullable"));
4936 Results.AddResult(CodeCompletionResult("null_unspecified"));
4937 Results.AddResult(CodeCompletionResult("null_resettable"));
4939 Results.ExitScope();
4940 HandleCodeCompleteResults(this, CodeCompleter,
4941 CodeCompletionContext::CCC_Other,
4942 Results.data(),Results.size());
4945 /// \brief Describes the kind of Objective-C method that we want to find
4946 /// via code completion.
4947 enum ObjCMethodKind {
4948 MK_Any, ///< Any kind of method, provided it means other specified criteria.
4949 MK_ZeroArgSelector, ///< Zero-argument (unary) selector.
4950 MK_OneArgSelector ///< One-argument selector.
4953 static bool isAcceptableObjCSelector(Selector Sel,
4954 ObjCMethodKind WantKind,
4955 ArrayRef<IdentifierInfo *> SelIdents,
4956 bool AllowSameLength = true) {
4957 unsigned NumSelIdents = SelIdents.size();
4958 if (NumSelIdents > Sel.getNumArgs())
4963 case MK_ZeroArgSelector: return Sel.isUnarySelector();
4964 case MK_OneArgSelector: return Sel.getNumArgs() == 1;
4967 if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs())
4970 for (unsigned I = 0; I != NumSelIdents; ++I)
4971 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I))
4977 static bool isAcceptableObjCMethod(ObjCMethodDecl *Method,
4978 ObjCMethodKind WantKind,
4979 ArrayRef<IdentifierInfo *> SelIdents,
4980 bool AllowSameLength = true) {
4981 return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents,
4986 /// \brief A set of selectors, which is used to avoid introducing multiple
4987 /// completions with the same selector into the result set.
4988 typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet;
4991 /// \brief Add all of the Objective-C methods in the given Objective-C
4992 /// container to the set of results.
4994 /// The container will be a class, protocol, category, or implementation of
4995 /// any of the above. This mether will recurse to include methods from
4996 /// the superclasses of classes along with their categories, protocols, and
4997 /// implementations.
4999 /// \param Container the container in which we'll look to find methods.
5001 /// \param WantInstanceMethods Whether to add instance methods (only); if
5002 /// false, this routine will add factory methods (only).
5004 /// \param CurContext the context in which we're performing the lookup that
5007 /// \param AllowSameLength Whether we allow a method to be added to the list
5008 /// when it has the same number of parameters as we have selector identifiers.
5010 /// \param Results the structure into which we'll add results.
5011 static void AddObjCMethods(ObjCContainerDecl *Container,
5012 bool WantInstanceMethods,
5013 ObjCMethodKind WantKind,
5014 ArrayRef<IdentifierInfo *> SelIdents,
5015 DeclContext *CurContext,
5016 VisitedSelectorSet &Selectors,
5017 bool AllowSameLength,
5018 ResultBuilder &Results,
5019 bool InOriginalClass = true) {
5020 typedef CodeCompletionResult Result;
5021 Container = getContainerDef(Container);
5022 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
5023 bool isRootClass = IFace && !IFace->getSuperClass();
5024 for (auto *M : Container->methods()) {
5025 // The instance methods on the root class can be messaged via the
5027 if (M->isInstanceMethod() == WantInstanceMethods ||
5028 (isRootClass && !WantInstanceMethods)) {
5029 // Check whether the selector identifiers we've been given are a
5030 // subset of the identifiers for this particular method.
5031 if (!isAcceptableObjCMethod(M, WantKind, SelIdents, AllowSameLength))
5034 if (!Selectors.insert(M->getSelector()).second)
5037 Result R = Result(M, Results.getBasePriority(M), nullptr);
5038 R.StartParameter = SelIdents.size();
5039 R.AllParametersAreInformative = (WantKind != MK_Any);
5040 if (!InOriginalClass)
5041 R.Priority += CCD_InBaseClass;
5042 Results.MaybeAddResult(R, CurContext);
5046 // Visit the protocols of protocols.
5047 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
5048 if (Protocol->hasDefinition()) {
5049 const ObjCList<ObjCProtocolDecl> &Protocols
5050 = Protocol->getReferencedProtocols();
5051 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5052 E = Protocols.end();
5054 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents,
5055 CurContext, Selectors, AllowSameLength, Results, false);
5059 if (!IFace || !IFace->hasDefinition())
5062 // Add methods in protocols.
5063 for (auto *I : IFace->protocols())
5064 AddObjCMethods(I, WantInstanceMethods, WantKind, SelIdents,
5065 CurContext, Selectors, AllowSameLength, Results, false);
5067 // Add methods in categories.
5068 for (auto *CatDecl : IFace->known_categories()) {
5069 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
5070 CurContext, Selectors, AllowSameLength,
5071 Results, InOriginalClass);
5073 // Add a categories protocol methods.
5074 const ObjCList<ObjCProtocolDecl> &Protocols
5075 = CatDecl->getReferencedProtocols();
5076 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5077 E = Protocols.end();
5079 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents,
5080 CurContext, Selectors, AllowSameLength,
5083 // Add methods in category implementations.
5084 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation())
5085 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents,
5086 CurContext, Selectors, AllowSameLength,
5087 Results, InOriginalClass);
5090 // Add methods in superclass.
5091 if (IFace->getSuperClass())
5092 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind,
5093 SelIdents, CurContext, Selectors,
5094 AllowSameLength, Results, false);
5096 // Add methods in our implementation, if any.
5097 if (ObjCImplementationDecl *Impl = IFace->getImplementation())
5098 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents,
5099 CurContext, Selectors, AllowSameLength,
5100 Results, InOriginalClass);
5104 void Sema::CodeCompleteObjCPropertyGetter(Scope *S) {
5105 // Try to find the interface where getters might live.
5106 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
5108 if (ObjCCategoryDecl *Category
5109 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
5110 Class = Category->getClassInterface();
5116 // Find all of the potential getters.
5117 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5118 CodeCompleter->getCodeCompletionTUInfo(),
5119 CodeCompletionContext::CCC_Other);
5120 Results.EnterNewScope();
5122 VisitedSelectorSet Selectors;
5123 AddObjCMethods(Class, true, MK_ZeroArgSelector, None, CurContext, Selectors,
5124 /*AllowSameLength=*/true, Results);
5125 Results.ExitScope();
5126 HandleCodeCompleteResults(this, CodeCompleter,
5127 CodeCompletionContext::CCC_Other,
5128 Results.data(),Results.size());
5131 void Sema::CodeCompleteObjCPropertySetter(Scope *S) {
5132 // Try to find the interface where setters might live.
5133 ObjCInterfaceDecl *Class
5134 = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
5136 if (ObjCCategoryDecl *Category
5137 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
5138 Class = Category->getClassInterface();
5144 // Find all of the potential getters.
5145 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5146 CodeCompleter->getCodeCompletionTUInfo(),
5147 CodeCompletionContext::CCC_Other);
5148 Results.EnterNewScope();
5150 VisitedSelectorSet Selectors;
5151 AddObjCMethods(Class, true, MK_OneArgSelector, None, CurContext,
5152 Selectors, /*AllowSameLength=*/true, Results);
5154 Results.ExitScope();
5155 HandleCodeCompleteResults(this, CodeCompleter,
5156 CodeCompletionContext::CCC_Other,
5157 Results.data(),Results.size());
5160 void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
5162 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5163 CodeCompleter->getCodeCompletionTUInfo(),
5164 CodeCompletionContext::CCC_Type);
5165 Results.EnterNewScope();
5167 // Add context-sensitive, Objective-C parameter-passing keywords.
5168 bool AddedInOut = false;
5169 if ((DS.getObjCDeclQualifier() &
5170 (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) {
5171 Results.AddResult("in");
5172 Results.AddResult("inout");
5175 if ((DS.getObjCDeclQualifier() &
5176 (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) {
5177 Results.AddResult("out");
5179 Results.AddResult("inout");
5181 if ((DS.getObjCDeclQualifier() &
5182 (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref |
5183 ObjCDeclSpec::DQ_Oneway)) == 0) {
5184 Results.AddResult("bycopy");
5185 Results.AddResult("byref");
5186 Results.AddResult("oneway");
5188 if ((DS.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability) == 0) {
5189 Results.AddResult("nonnull");
5190 Results.AddResult("nullable");
5191 Results.AddResult("null_unspecified");
5194 // If we're completing the return type of an Objective-C method and the
5195 // identifier IBAction refers to a macro, provide a completion item for
5197 // IBAction)<#selector#>:(id)sender
5198 if (DS.getObjCDeclQualifier() == 0 && !IsParameter &&
5199 PP.isMacroDefined("IBAction")) {
5200 CodeCompletionBuilder Builder(Results.getAllocator(),
5201 Results.getCodeCompletionTUInfo(),
5202 CCP_CodePattern, CXAvailability_Available);
5203 Builder.AddTypedTextChunk("IBAction");
5204 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5205 Builder.AddPlaceholderChunk("selector");
5206 Builder.AddChunk(CodeCompletionString::CK_Colon);
5207 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5208 Builder.AddTextChunk("id");
5209 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5210 Builder.AddTextChunk("sender");
5211 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
5214 // If we're completing the return type, provide 'instancetype'.
5216 Results.AddResult(CodeCompletionResult("instancetype"));
5219 // Add various builtin type names and specifiers.
5220 AddOrdinaryNameResults(PCC_Type, S, *this, Results);
5221 Results.ExitScope();
5223 // Add the various type names
5224 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
5225 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5226 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5227 CodeCompleter->includeGlobals());
5229 if (CodeCompleter->includeMacros())
5230 AddMacroResults(PP, Results, false);
5232 HandleCodeCompleteResults(this, CodeCompleter,
5233 CodeCompletionContext::CCC_Type,
5234 Results.data(), Results.size());
5237 /// \brief When we have an expression with type "id", we may assume
5238 /// that it has some more-specific class type based on knowledge of
5239 /// common uses of Objective-C. This routine returns that class type,
5240 /// or NULL if no better result could be determined.
5241 static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) {
5242 ObjCMessageExpr *Msg = dyn_cast_or_null<ObjCMessageExpr>(E);
5246 Selector Sel = Msg->getSelector();
5250 IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0);
5254 ObjCMethodDecl *Method = Msg->getMethodDecl();
5258 // Determine the class that we're sending the message to.
5259 ObjCInterfaceDecl *IFace = nullptr;
5260 switch (Msg->getReceiverKind()) {
5261 case ObjCMessageExpr::Class:
5262 if (const ObjCObjectType *ObjType
5263 = Msg->getClassReceiver()->getAs<ObjCObjectType>())
5264 IFace = ObjType->getInterface();
5267 case ObjCMessageExpr::Instance: {
5268 QualType T = Msg->getInstanceReceiver()->getType();
5269 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
5270 IFace = Ptr->getInterfaceDecl();
5274 case ObjCMessageExpr::SuperInstance:
5275 case ObjCMessageExpr::SuperClass:
5282 ObjCInterfaceDecl *Super = IFace->getSuperClass();
5283 if (Method->isInstanceMethod())
5284 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5285 .Case("retain", IFace)
5286 .Case("strong", IFace)
5287 .Case("autorelease", IFace)
5288 .Case("copy", IFace)
5289 .Case("copyWithZone", IFace)
5290 .Case("mutableCopy", IFace)
5291 .Case("mutableCopyWithZone", IFace)
5292 .Case("awakeFromCoder", IFace)
5293 .Case("replacementObjectFromCoder", IFace)
5294 .Case("class", IFace)
5295 .Case("classForCoder", IFace)
5296 .Case("superclass", Super)
5299 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5301 .Case("alloc", IFace)
5302 .Case("allocWithZone", IFace)
5303 .Case("class", IFace)
5304 .Case("superclass", Super)
5308 // Add a special completion for a message send to "super", which fills in the
5309 // most likely case of forwarding all of our arguments to the superclass
5312 /// \param S The semantic analysis object.
5314 /// \param NeedSuperKeyword Whether we need to prefix this completion with
5315 /// the "super" keyword. Otherwise, we just need to provide the arguments.
5317 /// \param SelIdents The identifiers in the selector that have already been
5318 /// provided as arguments for a send to "super".
5320 /// \param Results The set of results to augment.
5322 /// \returns the Objective-C method declaration that would be invoked by
5323 /// this "super" completion. If NULL, no completion was added.
5324 static ObjCMethodDecl *AddSuperSendCompletion(
5325 Sema &S, bool NeedSuperKeyword,
5326 ArrayRef<IdentifierInfo *> SelIdents,
5327 ResultBuilder &Results) {
5328 ObjCMethodDecl *CurMethod = S.getCurMethodDecl();
5332 ObjCInterfaceDecl *Class = CurMethod->getClassInterface();
5336 // Try to find a superclass method with the same selector.
5337 ObjCMethodDecl *SuperMethod = nullptr;
5338 while ((Class = Class->getSuperClass()) && !SuperMethod) {
5339 // Check in the class
5340 SuperMethod = Class->getMethod(CurMethod->getSelector(),
5341 CurMethod->isInstanceMethod());
5343 // Check in categories or class extensions.
5345 for (const auto *Cat : Class->known_categories()) {
5346 if ((SuperMethod = Cat->getMethod(CurMethod->getSelector(),
5347 CurMethod->isInstanceMethod())))
5356 // Check whether the superclass method has the same signature.
5357 if (CurMethod->param_size() != SuperMethod->param_size() ||
5358 CurMethod->isVariadic() != SuperMethod->isVariadic())
5361 for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(),
5362 CurPEnd = CurMethod->param_end(),
5363 SuperP = SuperMethod->param_begin();
5364 CurP != CurPEnd; ++CurP, ++SuperP) {
5365 // Make sure the parameter types are compatible.
5366 if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(),
5367 (*SuperP)->getType()))
5370 // Make sure we have a parameter name to forward!
5371 if (!(*CurP)->getIdentifier())
5375 // We have a superclass method. Now, form the send-to-super completion.
5376 CodeCompletionBuilder Builder(Results.getAllocator(),
5377 Results.getCodeCompletionTUInfo());
5379 // Give this completion a return type.
5380 AddResultTypeChunk(S.Context, getCompletionPrintingPolicy(S), SuperMethod,
5381 Results.getCompletionContext().getBaseType(),
5384 // If we need the "super" keyword, add it (plus some spacing).
5385 if (NeedSuperKeyword) {
5386 Builder.AddTypedTextChunk("super");
5387 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5390 Selector Sel = CurMethod->getSelector();
5391 if (Sel.isUnarySelector()) {
5392 if (NeedSuperKeyword)
5393 Builder.AddTextChunk(Builder.getAllocator().CopyString(
5394 Sel.getNameForSlot(0)));
5396 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
5397 Sel.getNameForSlot(0)));
5399 ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin();
5400 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) {
5401 if (I > SelIdents.size())
5402 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5404 if (I < SelIdents.size())
5405 Builder.AddInformativeChunk(
5406 Builder.getAllocator().CopyString(
5407 Sel.getNameForSlot(I) + ":"));
5408 else if (NeedSuperKeyword || I > SelIdents.size()) {
5409 Builder.AddTextChunk(
5410 Builder.getAllocator().CopyString(
5411 Sel.getNameForSlot(I) + ":"));
5412 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5413 (*CurP)->getIdentifier()->getName()));
5415 Builder.AddTypedTextChunk(
5416 Builder.getAllocator().CopyString(
5417 Sel.getNameForSlot(I) + ":"));
5418 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5419 (*CurP)->getIdentifier()->getName()));
5424 Results.AddResult(CodeCompletionResult(Builder.TakeString(), SuperMethod,
5425 CCP_SuperCompletion));
5429 void Sema::CodeCompleteObjCMessageReceiver(Scope *S) {
5430 typedef CodeCompletionResult Result;
5431 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5432 CodeCompleter->getCodeCompletionTUInfo(),
5433 CodeCompletionContext::CCC_ObjCMessageReceiver,
5434 getLangOpts().CPlusPlus11
5435 ? &ResultBuilder::IsObjCMessageReceiverOrLambdaCapture
5436 : &ResultBuilder::IsObjCMessageReceiver);
5438 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5439 Results.EnterNewScope();
5440 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5441 CodeCompleter->includeGlobals());
5443 // If we are in an Objective-C method inside a class that has a superclass,
5444 // add "super" as an option.
5445 if (ObjCMethodDecl *Method = getCurMethodDecl())
5446 if (ObjCInterfaceDecl *Iface = Method->getClassInterface())
5447 if (Iface->getSuperClass()) {
5448 Results.AddResult(Result("super"));
5450 AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, None, Results);
5453 if (getLangOpts().CPlusPlus11)
5454 addThisCompletion(*this, Results);
5456 Results.ExitScope();
5458 if (CodeCompleter->includeMacros())
5459 AddMacroResults(PP, Results, false);
5460 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5461 Results.data(), Results.size());
5465 void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
5466 ArrayRef<IdentifierInfo *> SelIdents,
5467 bool AtArgumentExpression) {
5468 ObjCInterfaceDecl *CDecl = nullptr;
5469 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5470 // Figure out which interface we're in.
5471 CDecl = CurMethod->getClassInterface();
5475 // Find the superclass of this class.
5476 CDecl = CDecl->getSuperClass();
5480 if (CurMethod->isInstanceMethod()) {
5481 // We are inside an instance method, which means that the message
5482 // send [super ...] is actually calling an instance method on the
5484 return CodeCompleteObjCInstanceMessage(S, nullptr, SelIdents,
5485 AtArgumentExpression,
5489 // Fall through to send to the superclass in CDecl.
5491 // "super" may be the name of a type or variable. Figure out which
5493 IdentifierInfo *Super = getSuperIdentifier();
5494 NamedDecl *ND = LookupSingleName(S, Super, SuperLoc,
5495 LookupOrdinaryName);
5496 if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) {
5497 // "super" names an interface. Use it.
5498 } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) {
5499 if (const ObjCObjectType *Iface
5500 = Context.getTypeDeclType(TD)->getAs<ObjCObjectType>())
5501 CDecl = Iface->getInterface();
5502 } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) {
5503 // "super" names an unresolved type; we can't be more specific.
5505 // Assume that "super" names some kind of value and parse that way.
5507 SourceLocation TemplateKWLoc;
5509 id.setIdentifier(Super, SuperLoc);
5510 ExprResult SuperExpr = ActOnIdExpression(S, SS, TemplateKWLoc, id,
5512 return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
5514 AtArgumentExpression);
5520 ParsedType Receiver;
5522 Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl));
5523 return CodeCompleteObjCClassMessage(S, Receiver, SelIdents,
5524 AtArgumentExpression,
5528 /// \brief Given a set of code-completion results for the argument of a message
5529 /// send, determine the preferred type (if any) for that argument expression.
5530 static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
5531 unsigned NumSelIdents) {
5532 typedef CodeCompletionResult Result;
5533 ASTContext &Context = Results.getSema().Context;
5535 QualType PreferredType;
5536 unsigned BestPriority = CCP_Unlikely * 2;
5537 Result *ResultsData = Results.data();
5538 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
5539 Result &R = ResultsData[I];
5540 if (R.Kind == Result::RK_Declaration &&
5541 isa<ObjCMethodDecl>(R.Declaration)) {
5542 if (R.Priority <= BestPriority) {
5543 const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration);
5544 if (NumSelIdents <= Method->param_size()) {
5545 QualType MyPreferredType = Method->parameters()[NumSelIdents - 1]
5547 if (R.Priority < BestPriority || PreferredType.isNull()) {
5548 BestPriority = R.Priority;
5549 PreferredType = MyPreferredType;
5550 } else if (!Context.hasSameUnqualifiedType(PreferredType,
5552 PreferredType = QualType();
5559 return PreferredType;
5562 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
5563 ParsedType Receiver,
5564 ArrayRef<IdentifierInfo *> SelIdents,
5565 bool AtArgumentExpression,
5567 ResultBuilder &Results) {
5568 typedef CodeCompletionResult Result;
5569 ObjCInterfaceDecl *CDecl = nullptr;
5571 // If the given name refers to an interface type, retrieve the
5572 // corresponding declaration.
5574 QualType T = SemaRef.GetTypeFromParser(Receiver, nullptr);
5576 if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>())
5577 CDecl = Interface->getInterface();
5580 // Add all of the factory methods in this Objective-C class, its protocols,
5581 // superclasses, categories, implementation, etc.
5582 Results.EnterNewScope();
5584 // If this is a send-to-super, try to add the special "super" send
5587 if (ObjCMethodDecl *SuperMethod
5588 = AddSuperSendCompletion(SemaRef, false, SelIdents, Results))
5589 Results.Ignore(SuperMethod);
5592 // If we're inside an Objective-C method definition, prefer its selector to
5594 if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl())
5595 Results.setPreferredSelector(CurMethod->getSelector());
5597 VisitedSelectorSet Selectors;
5599 AddObjCMethods(CDecl, false, MK_Any, SelIdents,
5600 SemaRef.CurContext, Selectors, AtArgumentExpression,
5603 // We're messaging "id" as a type; provide all class/factory methods.
5605 // If we have an external source, load the entire class method
5606 // pool from the AST file.
5607 if (SemaRef.getExternalSource()) {
5608 for (uint32_t I = 0,
5609 N = SemaRef.getExternalSource()->GetNumExternalSelectors();
5611 Selector Sel = SemaRef.getExternalSource()->GetExternalSelector(I);
5612 if (Sel.isNull() || SemaRef.MethodPool.count(Sel))
5615 SemaRef.ReadMethodPool(Sel);
5619 for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(),
5620 MEnd = SemaRef.MethodPool.end();
5622 for (ObjCMethodList *MethList = &M->second.second;
5623 MethList && MethList->getMethod();
5624 MethList = MethList->getNext()) {
5625 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
5628 Result R(MethList->getMethod(),
5629 Results.getBasePriority(MethList->getMethod()), nullptr);
5630 R.StartParameter = SelIdents.size();
5631 R.AllParametersAreInformative = false;
5632 Results.MaybeAddResult(R, SemaRef.CurContext);
5637 Results.ExitScope();
5640 void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
5641 ArrayRef<IdentifierInfo *> SelIdents,
5642 bool AtArgumentExpression,
5645 QualType T = this->GetTypeFromParser(Receiver);
5647 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5648 CodeCompleter->getCodeCompletionTUInfo(),
5649 CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage,
5652 AddClassMessageCompletions(*this, S, Receiver, SelIdents,
5653 AtArgumentExpression, IsSuper, Results);
5655 // If we're actually at the argument expression (rather than prior to the
5656 // selector), we're actually performing code completion for an expression.
5657 // Determine whether we have a single, best method. If so, we can
5658 // code-complete the expression using the corresponding parameter type as
5659 // our preferred type, improving completion results.
5660 if (AtArgumentExpression) {
5661 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
5663 if (PreferredType.isNull())
5664 CodeCompleteOrdinaryName(S, PCC_Expression);
5666 CodeCompleteExpression(S, PreferredType);
5670 HandleCodeCompleteResults(this, CodeCompleter,
5671 Results.getCompletionContext(),
5672 Results.data(), Results.size());
5675 void Sema::CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
5676 ArrayRef<IdentifierInfo *> SelIdents,
5677 bool AtArgumentExpression,
5678 ObjCInterfaceDecl *Super) {
5679 typedef CodeCompletionResult Result;
5681 Expr *RecExpr = static_cast<Expr *>(Receiver);
5683 // If necessary, apply function/array conversion to the receiver.
5684 // C99 6.7.5.3p[7,8].
5686 ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr);
5687 if (Conv.isInvalid()) // conversion failed. bail.
5689 RecExpr = Conv.get();
5691 QualType ReceiverType = RecExpr? RecExpr->getType()
5692 : Super? Context.getObjCObjectPointerType(
5693 Context.getObjCInterfaceType(Super))
5694 : Context.getObjCIdType();
5696 // If we're messaging an expression with type "id" or "Class", check
5697 // whether we know something special about the receiver that allows
5698 // us to assume a more-specific receiver type.
5699 if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType()) {
5700 if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) {
5701 if (ReceiverType->isObjCClassType())
5702 return CodeCompleteObjCClassMessage(S,
5703 ParsedType::make(Context.getObjCInterfaceType(IFace)),
5705 AtArgumentExpression, Super);
5707 ReceiverType = Context.getObjCObjectPointerType(
5708 Context.getObjCInterfaceType(IFace));
5710 } else if (RecExpr && getLangOpts().CPlusPlus) {
5711 ExprResult Conv = PerformContextuallyConvertToObjCPointer(RecExpr);
5712 if (Conv.isUsable()) {
5713 RecExpr = Conv.get();
5714 ReceiverType = RecExpr->getType();
5718 // Build the set of methods we can see.
5719 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5720 CodeCompleter->getCodeCompletionTUInfo(),
5721 CodeCompletionContext(CodeCompletionContext::CCC_ObjCInstanceMessage,
5722 ReceiverType, SelIdents));
5724 Results.EnterNewScope();
5726 // If this is a send-to-super, try to add the special "super" send
5729 if (ObjCMethodDecl *SuperMethod
5730 = AddSuperSendCompletion(*this, false, SelIdents, Results))
5731 Results.Ignore(SuperMethod);
5734 // If we're inside an Objective-C method definition, prefer its selector to
5736 if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
5737 Results.setPreferredSelector(CurMethod->getSelector());
5739 // Keep track of the selectors we've already added.
5740 VisitedSelectorSet Selectors;
5742 // Handle messages to Class. This really isn't a message to an instance
5743 // method, so we treat it the same way we would treat a message send to a
5745 if (ReceiverType->isObjCClassType() ||
5746 ReceiverType->isObjCQualifiedClassType()) {
5747 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5748 if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface())
5749 AddObjCMethods(ClassDecl, false, MK_Any, SelIdents,
5750 CurContext, Selectors, AtArgumentExpression, Results);
5753 // Handle messages to a qualified ID ("id<foo>").
5754 else if (const ObjCObjectPointerType *QualID
5755 = ReceiverType->getAsObjCQualifiedIdType()) {
5756 // Search protocols for instance methods.
5757 for (auto *I : QualID->quals())
5758 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
5759 Selectors, AtArgumentExpression, Results);
5761 // Handle messages to a pointer to interface type.
5762 else if (const ObjCObjectPointerType *IFacePtr
5763 = ReceiverType->getAsObjCInterfacePointerType()) {
5764 // Search the class, its superclasses, etc., for instance methods.
5765 AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents,
5766 CurContext, Selectors, AtArgumentExpression,
5769 // Search protocols for instance methods.
5770 for (auto *I : IFacePtr->quals())
5771 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
5772 Selectors, AtArgumentExpression, Results);
5774 // Handle messages to "id".
5775 else if (ReceiverType->isObjCIdType()) {
5776 // We're messaging "id", so provide all instance methods we know
5777 // about as code-completion results.
5779 // If we have an external source, load the entire class method
5780 // pool from the AST file.
5781 if (ExternalSource) {
5782 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
5784 Selector Sel = ExternalSource->GetExternalSelector(I);
5785 if (Sel.isNull() || MethodPool.count(Sel))
5788 ReadMethodPool(Sel);
5792 for (GlobalMethodPool::iterator M = MethodPool.begin(),
5793 MEnd = MethodPool.end();
5795 for (ObjCMethodList *MethList = &M->second.first;
5796 MethList && MethList->getMethod();
5797 MethList = MethList->getNext()) {
5798 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
5801 if (!Selectors.insert(MethList->getMethod()->getSelector()).second)
5804 Result R(MethList->getMethod(),
5805 Results.getBasePriority(MethList->getMethod()), nullptr);
5806 R.StartParameter = SelIdents.size();
5807 R.AllParametersAreInformative = false;
5808 Results.MaybeAddResult(R, CurContext);
5812 Results.ExitScope();
5815 // If we're actually at the argument expression (rather than prior to the
5816 // selector), we're actually performing code completion for an expression.
5817 // Determine whether we have a single, best method. If so, we can
5818 // code-complete the expression using the corresponding parameter type as
5819 // our preferred type, improving completion results.
5820 if (AtArgumentExpression) {
5821 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
5823 if (PreferredType.isNull())
5824 CodeCompleteOrdinaryName(S, PCC_Expression);
5826 CodeCompleteExpression(S, PreferredType);
5830 HandleCodeCompleteResults(this, CodeCompleter,
5831 Results.getCompletionContext(),
5832 Results.data(),Results.size());
5835 void Sema::CodeCompleteObjCForCollection(Scope *S,
5836 DeclGroupPtrTy IterationVar) {
5837 CodeCompleteExpressionData Data;
5838 Data.ObjCCollection = true;
5840 if (IterationVar.getAsOpaquePtr()) {
5841 DeclGroupRef DG = IterationVar.get();
5842 for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) {
5844 Data.IgnoreDecls.push_back(*I);
5848 CodeCompleteExpression(S, Data);
5851 void Sema::CodeCompleteObjCSelector(Scope *S,
5852 ArrayRef<IdentifierInfo *> SelIdents) {
5853 // If we have an external source, load the entire class method
5854 // pool from the AST file.
5855 if (ExternalSource) {
5856 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
5858 Selector Sel = ExternalSource->GetExternalSelector(I);
5859 if (Sel.isNull() || MethodPool.count(Sel))
5862 ReadMethodPool(Sel);
5866 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5867 CodeCompleter->getCodeCompletionTUInfo(),
5868 CodeCompletionContext::CCC_SelectorName);
5869 Results.EnterNewScope();
5870 for (GlobalMethodPool::iterator M = MethodPool.begin(),
5871 MEnd = MethodPool.end();
5874 Selector Sel = M->first;
5875 if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents))
5878 CodeCompletionBuilder Builder(Results.getAllocator(),
5879 Results.getCodeCompletionTUInfo());
5880 if (Sel.isUnarySelector()) {
5881 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
5882 Sel.getNameForSlot(0)));
5883 Results.AddResult(Builder.TakeString());
5887 std::string Accumulator;
5888 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) {
5889 if (I == SelIdents.size()) {
5890 if (!Accumulator.empty()) {
5891 Builder.AddInformativeChunk(Builder.getAllocator().CopyString(
5893 Accumulator.clear();
5897 Accumulator += Sel.getNameForSlot(I);
5900 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString( Accumulator));
5901 Results.AddResult(Builder.TakeString());
5903 Results.ExitScope();
5905 HandleCodeCompleteResults(this, CodeCompleter,
5906 CodeCompletionContext::CCC_SelectorName,
5907 Results.data(), Results.size());
5910 /// \brief Add all of the protocol declarations that we find in the given
5911 /// (translation unit) context.
5912 static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext,
5913 bool OnlyForwardDeclarations,
5914 ResultBuilder &Results) {
5915 typedef CodeCompletionResult Result;
5917 for (const auto *D : Ctx->decls()) {
5918 // Record any protocols we find.
5919 if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(D))
5920 if (!OnlyForwardDeclarations || !Proto->hasDefinition())
5921 Results.AddResult(Result(Proto, Results.getBasePriority(Proto),nullptr),
5922 CurContext, nullptr, false);
5926 void Sema::CodeCompleteObjCProtocolReferences(
5927 ArrayRef<IdentifierLocPair> Protocols) {
5928 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5929 CodeCompleter->getCodeCompletionTUInfo(),
5930 CodeCompletionContext::CCC_ObjCProtocolName);
5932 if (CodeCompleter && CodeCompleter->includeGlobals()) {
5933 Results.EnterNewScope();
5935 // Tell the result set to ignore all of the protocols we have
5937 // FIXME: This doesn't work when caching code-completion results.
5938 for (const IdentifierLocPair &Pair : Protocols)
5939 if (ObjCProtocolDecl *Protocol = LookupProtocol(Pair.first,
5941 Results.Ignore(Protocol);
5943 // Add all protocols.
5944 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false,
5947 Results.ExitScope();
5950 HandleCodeCompleteResults(this, CodeCompleter,
5951 CodeCompletionContext::CCC_ObjCProtocolName,
5952 Results.data(),Results.size());
5955 void Sema::CodeCompleteObjCProtocolDecl(Scope *) {
5956 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5957 CodeCompleter->getCodeCompletionTUInfo(),
5958 CodeCompletionContext::CCC_ObjCProtocolName);
5960 if (CodeCompleter && CodeCompleter->includeGlobals()) {
5961 Results.EnterNewScope();
5963 // Add all protocols.
5964 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true,
5967 Results.ExitScope();
5970 HandleCodeCompleteResults(this, CodeCompleter,
5971 CodeCompletionContext::CCC_ObjCProtocolName,
5972 Results.data(),Results.size());
5975 /// \brief Add all of the Objective-C interface declarations that we find in
5976 /// the given (translation unit) context.
5977 static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext,
5978 bool OnlyForwardDeclarations,
5979 bool OnlyUnimplemented,
5980 ResultBuilder &Results) {
5981 typedef CodeCompletionResult Result;
5983 for (const auto *D : Ctx->decls()) {
5984 // Record any interfaces we find.
5985 if (const auto *Class = dyn_cast<ObjCInterfaceDecl>(D))
5986 if ((!OnlyForwardDeclarations || !Class->hasDefinition()) &&
5987 (!OnlyUnimplemented || !Class->getImplementation()))
5988 Results.AddResult(Result(Class, Results.getBasePriority(Class),nullptr),
5989 CurContext, nullptr, false);
5993 void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) {
5994 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5995 CodeCompleter->getCodeCompletionTUInfo(),
5996 CodeCompletionContext::CCC_Other);
5997 Results.EnterNewScope();
5999 if (CodeCompleter->includeGlobals()) {
6001 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6005 Results.ExitScope();
6007 HandleCodeCompleteResults(this, CodeCompleter,
6008 CodeCompletionContext::CCC_ObjCInterfaceName,
6009 Results.data(),Results.size());
6012 void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName,
6013 SourceLocation ClassNameLoc) {
6014 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6015 CodeCompleter->getCodeCompletionTUInfo(),
6016 CodeCompletionContext::CCC_ObjCInterfaceName);
6017 Results.EnterNewScope();
6019 // Make sure that we ignore the class we're currently defining.
6021 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6022 if (CurClass && isa<ObjCInterfaceDecl>(CurClass))
6023 Results.Ignore(CurClass);
6025 if (CodeCompleter->includeGlobals()) {
6027 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6031 Results.ExitScope();
6033 HandleCodeCompleteResults(this, CodeCompleter,
6034 CodeCompletionContext::CCC_ObjCInterfaceName,
6035 Results.data(),Results.size());
6038 void Sema::CodeCompleteObjCImplementationDecl(Scope *S) {
6039 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6040 CodeCompleter->getCodeCompletionTUInfo(),
6041 CodeCompletionContext::CCC_Other);
6042 Results.EnterNewScope();
6044 if (CodeCompleter->includeGlobals()) {
6045 // Add all unimplemented classes.
6046 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6050 Results.ExitScope();
6052 HandleCodeCompleteResults(this, CodeCompleter,
6053 CodeCompletionContext::CCC_ObjCInterfaceName,
6054 Results.data(),Results.size());
6057 void Sema::CodeCompleteObjCInterfaceCategory(Scope *S,
6058 IdentifierInfo *ClassName,
6059 SourceLocation ClassNameLoc) {
6060 typedef CodeCompletionResult Result;
6062 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6063 CodeCompleter->getCodeCompletionTUInfo(),
6064 CodeCompletionContext::CCC_ObjCCategoryName);
6066 // Ignore any categories we find that have already been implemented by this
6068 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
6070 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6071 if (ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)){
6072 for (const auto *Cat : Class->visible_categories())
6073 CategoryNames.insert(Cat->getIdentifier());
6076 // Add all of the categories we know about.
6077 Results.EnterNewScope();
6078 TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
6079 for (const auto *D : TU->decls())
6080 if (const auto *Category = dyn_cast<ObjCCategoryDecl>(D))
6081 if (CategoryNames.insert(Category->getIdentifier()).second)
6082 Results.AddResult(Result(Category, Results.getBasePriority(Category),
6084 CurContext, nullptr, false);
6085 Results.ExitScope();
6087 HandleCodeCompleteResults(this, CodeCompleter,
6088 CodeCompletionContext::CCC_ObjCCategoryName,
6089 Results.data(),Results.size());
6092 void Sema::CodeCompleteObjCImplementationCategory(Scope *S,
6093 IdentifierInfo *ClassName,
6094 SourceLocation ClassNameLoc) {
6095 typedef CodeCompletionResult Result;
6097 // Find the corresponding interface. If we couldn't find the interface, the
6098 // program itself is ill-formed. However, we'll try to be helpful still by
6099 // providing the list of all of the categories we know about.
6101 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6102 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass);
6104 return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc);
6106 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6107 CodeCompleter->getCodeCompletionTUInfo(),
6108 CodeCompletionContext::CCC_ObjCCategoryName);
6110 // Add all of the categories that have have corresponding interface
6111 // declarations in this class and any of its superclasses, except for
6112 // already-implemented categories in the class itself.
6113 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
6114 Results.EnterNewScope();
6115 bool IgnoreImplemented = true;
6117 for (const auto *Cat : Class->visible_categories()) {
6118 if ((!IgnoreImplemented || !Cat->getImplementation()) &&
6119 CategoryNames.insert(Cat->getIdentifier()).second)
6120 Results.AddResult(Result(Cat, Results.getBasePriority(Cat), nullptr),
6121 CurContext, nullptr, false);
6124 Class = Class->getSuperClass();
6125 IgnoreImplemented = false;
6127 Results.ExitScope();
6129 HandleCodeCompleteResults(this, CodeCompleter,
6130 CodeCompletionContext::CCC_ObjCCategoryName,
6131 Results.data(),Results.size());
6134 void Sema::CodeCompleteObjCPropertyDefinition(Scope *S) {
6135 CodeCompletionContext CCContext(CodeCompletionContext::CCC_Other);
6136 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6137 CodeCompleter->getCodeCompletionTUInfo(),
6140 // Figure out where this @synthesize lives.
6141 ObjCContainerDecl *Container
6142 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6144 (!isa<ObjCImplementationDecl>(Container) &&
6145 !isa<ObjCCategoryImplDecl>(Container)))
6148 // Ignore any properties that have already been implemented.
6149 Container = getContainerDef(Container);
6150 for (const auto *D : Container->decls())
6151 if (const auto *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(D))
6152 Results.Ignore(PropertyImpl->getPropertyDecl());
6154 // Add any properties that we find.
6155 AddedPropertiesSet AddedProperties;
6156 Results.EnterNewScope();
6157 if (ObjCImplementationDecl *ClassImpl
6158 = dyn_cast<ObjCImplementationDecl>(Container))
6159 AddObjCProperties(CCContext, ClassImpl->getClassInterface(), false,
6160 /*AllowNullaryMethods=*/false, CurContext,
6161 AddedProperties, Results);
6163 AddObjCProperties(CCContext,
6164 cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(),
6165 false, /*AllowNullaryMethods=*/false, CurContext,
6166 AddedProperties, Results);
6167 Results.ExitScope();
6169 HandleCodeCompleteResults(this, CodeCompleter,
6170 CodeCompletionContext::CCC_Other,
6171 Results.data(),Results.size());
6174 void Sema::CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
6175 IdentifierInfo *PropertyName) {
6176 typedef CodeCompletionResult Result;
6177 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6178 CodeCompleter->getCodeCompletionTUInfo(),
6179 CodeCompletionContext::CCC_Other);
6181 // Figure out where this @synthesize lives.
6182 ObjCContainerDecl *Container
6183 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6185 (!isa<ObjCImplementationDecl>(Container) &&
6186 !isa<ObjCCategoryImplDecl>(Container)))
6189 // Figure out which interface we're looking into.
6190 ObjCInterfaceDecl *Class = nullptr;
6191 if (ObjCImplementationDecl *ClassImpl
6192 = dyn_cast<ObjCImplementationDecl>(Container))
6193 Class = ClassImpl->getClassInterface();
6195 Class = cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl()
6196 ->getClassInterface();
6198 // Determine the type of the property we're synthesizing.
6199 QualType PropertyType = Context.getObjCIdType();
6201 if (ObjCPropertyDecl *Property
6202 = Class->FindPropertyDeclaration(PropertyName)) {
6204 = Property->getType().getNonReferenceType().getUnqualifiedType();
6206 // Give preference to ivars
6207 Results.setPreferredType(PropertyType);
6211 // Add all of the instance variables in this class and its superclasses.
6212 Results.EnterNewScope();
6213 bool SawSimilarlyNamedIvar = false;
6214 std::string NameWithPrefix;
6215 NameWithPrefix += '_';
6216 NameWithPrefix += PropertyName->getName();
6217 std::string NameWithSuffix = PropertyName->getName().str();
6218 NameWithSuffix += '_';
6219 for(; Class; Class = Class->getSuperClass()) {
6220 for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar;
6221 Ivar = Ivar->getNextIvar()) {
6222 Results.AddResult(Result(Ivar, Results.getBasePriority(Ivar), nullptr),
6223 CurContext, nullptr, false);
6225 // Determine whether we've seen an ivar with a name similar to the
6227 if ((PropertyName == Ivar->getIdentifier() ||
6228 NameWithPrefix == Ivar->getName() ||
6229 NameWithSuffix == Ivar->getName())) {
6230 SawSimilarlyNamedIvar = true;
6232 // Reduce the priority of this result by one, to give it a slight
6233 // advantage over other results whose names don't match so closely.
6234 if (Results.size() &&
6235 Results.data()[Results.size() - 1].Kind
6236 == CodeCompletionResult::RK_Declaration &&
6237 Results.data()[Results.size() - 1].Declaration == Ivar)
6238 Results.data()[Results.size() - 1].Priority--;
6243 if (!SawSimilarlyNamedIvar) {
6244 // Create ivar result _propName, that the user can use to synthesize
6245 // an ivar of the appropriate type.
6246 unsigned Priority = CCP_MemberDeclaration + 1;
6247 typedef CodeCompletionResult Result;
6248 CodeCompletionAllocator &Allocator = Results.getAllocator();
6249 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo(),
6250 Priority,CXAvailability_Available);
6252 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
6253 Builder.AddResultTypeChunk(GetCompletionTypeString(PropertyType, Context,
6254 Policy, Allocator));
6255 Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix));
6256 Results.AddResult(Result(Builder.TakeString(), Priority,
6257 CXCursor_ObjCIvarDecl));
6260 Results.ExitScope();
6262 HandleCodeCompleteResults(this, CodeCompleter,
6263 CodeCompletionContext::CCC_Other,
6264 Results.data(),Results.size());
6267 // Mapping from selectors to the methods that implement that selector, along
6268 // with the "in original class" flag.
6269 typedef llvm::DenseMap<
6270 Selector, llvm::PointerIntPair<ObjCMethodDecl *, 1, bool> > KnownMethodsMap;
6272 /// \brief Find all of the methods that reside in the given container
6273 /// (and its superclasses, protocols, etc.) that meet the given
6274 /// criteria. Insert those methods into the map of known methods,
6275 /// indexed by selector so they can be easily found.
6276 static void FindImplementableMethods(ASTContext &Context,
6277 ObjCContainerDecl *Container,
6278 bool WantInstanceMethods,
6279 QualType ReturnType,
6280 KnownMethodsMap &KnownMethods,
6281 bool InOriginalClass = true) {
6282 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) {
6283 // Make sure we have a definition; that's what we'll walk.
6284 if (!IFace->hasDefinition())
6287 IFace = IFace->getDefinition();
6290 const ObjCList<ObjCProtocolDecl> &Protocols
6291 = IFace->getReferencedProtocols();
6292 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6293 E = Protocols.end();
6295 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6296 KnownMethods, InOriginalClass);
6298 // Add methods from any class extensions and categories.
6299 for (auto *Cat : IFace->visible_categories()) {
6300 FindImplementableMethods(Context, Cat, WantInstanceMethods, ReturnType,
6301 KnownMethods, false);
6304 // Visit the superclass.
6305 if (IFace->getSuperClass())
6306 FindImplementableMethods(Context, IFace->getSuperClass(),
6307 WantInstanceMethods, ReturnType,
6308 KnownMethods, false);
6311 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
6312 // Recurse into protocols.
6313 const ObjCList<ObjCProtocolDecl> &Protocols
6314 = Category->getReferencedProtocols();
6315 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6316 E = Protocols.end();
6318 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6319 KnownMethods, InOriginalClass);
6321 // If this category is the original class, jump to the interface.
6322 if (InOriginalClass && Category->getClassInterface())
6323 FindImplementableMethods(Context, Category->getClassInterface(),
6324 WantInstanceMethods, ReturnType, KnownMethods,
6328 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
6329 // Make sure we have a definition; that's what we'll walk.
6330 if (!Protocol->hasDefinition())
6332 Protocol = Protocol->getDefinition();
6333 Container = Protocol;
6335 // Recurse into protocols.
6336 const ObjCList<ObjCProtocolDecl> &Protocols
6337 = Protocol->getReferencedProtocols();
6338 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6339 E = Protocols.end();
6341 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6342 KnownMethods, false);
6345 // Add methods in this container. This operation occurs last because
6346 // we want the methods from this container to override any methods
6347 // we've previously seen with the same selector.
6348 for (auto *M : Container->methods()) {
6349 if (M->isInstanceMethod() == WantInstanceMethods) {
6350 if (!ReturnType.isNull() &&
6351 !Context.hasSameUnqualifiedType(ReturnType, M->getReturnType()))
6354 KnownMethods[M->getSelector()] =
6355 KnownMethodsMap::mapped_type(M, InOriginalClass);
6360 /// \brief Add the parenthesized return or parameter type chunk to a code
6361 /// completion string.
6362 static void AddObjCPassingTypeChunk(QualType Type,
6363 unsigned ObjCDeclQuals,
6364 ASTContext &Context,
6365 const PrintingPolicy &Policy,
6366 CodeCompletionBuilder &Builder) {
6367 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6368 std::string Quals = formatObjCParamQualifiers(ObjCDeclQuals, Type);
6370 Builder.AddTextChunk(Builder.getAllocator().CopyString(Quals));
6371 Builder.AddTextChunk(GetCompletionTypeString(Type, Context, Policy,
6372 Builder.getAllocator()));
6373 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6376 /// \brief Determine whether the given class is or inherits from a class by
6378 static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class,
6383 if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name)
6386 return InheritsFromClassNamed(Class->getSuperClass(), Name);
6389 /// \brief Add code completions for Objective-C Key-Value Coding (KVC) and
6390 /// Key-Value Observing (KVO).
6391 static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property,
6392 bool IsInstanceMethod,
6393 QualType ReturnType,
6394 ASTContext &Context,
6395 VisitedSelectorSet &KnownSelectors,
6396 ResultBuilder &Results) {
6397 IdentifierInfo *PropName = Property->getIdentifier();
6398 if (!PropName || PropName->getLength() == 0)
6401 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
6403 // Builder that will create each code completion.
6404 typedef CodeCompletionResult Result;
6405 CodeCompletionAllocator &Allocator = Results.getAllocator();
6406 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
6408 // The selector table.
6409 SelectorTable &Selectors = Context.Selectors;
6411 // The property name, copied into the code completion allocation region
6414 CodeCompletionAllocator &Allocator;
6416 const char *CopiedKey;
6418 KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key)
6419 : Allocator(Allocator), Key(Key), CopiedKey(nullptr) {}
6421 operator const char *() {
6425 return CopiedKey = Allocator.CopyString(Key);
6427 } Key(Allocator, PropName->getName());
6429 // The uppercased name of the property name.
6430 std::string UpperKey = PropName->getName();
6431 if (!UpperKey.empty())
6432 UpperKey[0] = toUppercase(UpperKey[0]);
6434 bool ReturnTypeMatchesProperty = ReturnType.isNull() ||
6435 Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(),
6436 Property->getType());
6437 bool ReturnTypeMatchesVoid
6438 = ReturnType.isNull() || ReturnType->isVoidType();
6440 // Add the normal accessor -(type)key.
6441 if (IsInstanceMethod &&
6442 KnownSelectors.insert(Selectors.getNullarySelector(PropName)).second &&
6443 ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) {
6444 if (ReturnType.isNull())
6445 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6446 Context, Policy, Builder);
6448 Builder.AddTypedTextChunk(Key);
6449 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6450 CXCursor_ObjCInstanceMethodDecl));
6453 // If we have an integral or boolean property (or the user has provided
6454 // an integral or boolean return type), add the accessor -(type)isKey.
6455 if (IsInstanceMethod &&
6456 ((!ReturnType.isNull() &&
6457 (ReturnType->isIntegerType() || ReturnType->isBooleanType())) ||
6458 (ReturnType.isNull() &&
6459 (Property->getType()->isIntegerType() ||
6460 Property->getType()->isBooleanType())))) {
6461 std::string SelectorName = (Twine("is") + UpperKey).str();
6462 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6463 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6465 if (ReturnType.isNull()) {
6466 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6467 Builder.AddTextChunk("BOOL");
6468 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6471 Builder.AddTypedTextChunk(
6472 Allocator.CopyString(SelectorId->getName()));
6473 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6474 CXCursor_ObjCInstanceMethodDecl));
6478 // Add the normal mutator.
6479 if (IsInstanceMethod && ReturnTypeMatchesVoid &&
6480 !Property->getSetterMethodDecl()) {
6481 std::string SelectorName = (Twine("set") + UpperKey).str();
6482 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6483 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6484 if (ReturnType.isNull()) {
6485 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6486 Builder.AddTextChunk("void");
6487 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6490 Builder.AddTypedTextChunk(
6491 Allocator.CopyString(SelectorId->getName()));
6492 Builder.AddTypedTextChunk(":");
6493 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6494 Context, Policy, Builder);
6495 Builder.AddTextChunk(Key);
6496 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6497 CXCursor_ObjCInstanceMethodDecl));
6501 // Indexed and unordered accessors
6502 unsigned IndexedGetterPriority = CCP_CodePattern;
6503 unsigned IndexedSetterPriority = CCP_CodePattern;
6504 unsigned UnorderedGetterPriority = CCP_CodePattern;
6505 unsigned UnorderedSetterPriority = CCP_CodePattern;
6506 if (const ObjCObjectPointerType *ObjCPointer
6507 = Property->getType()->getAs<ObjCObjectPointerType>()) {
6508 if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) {
6509 // If this interface type is not provably derived from a known
6510 // collection, penalize the corresponding completions.
6511 if (!InheritsFromClassNamed(IFace, "NSMutableArray")) {
6512 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6513 if (!InheritsFromClassNamed(IFace, "NSArray"))
6514 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6517 if (!InheritsFromClassNamed(IFace, "NSMutableSet")) {
6518 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6519 if (!InheritsFromClassNamed(IFace, "NSSet"))
6520 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6524 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6525 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6526 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6527 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6530 // Add -(NSUInteger)countOf<key>
6531 if (IsInstanceMethod &&
6532 (ReturnType.isNull() || ReturnType->isIntegerType())) {
6533 std::string SelectorName = (Twine("countOf") + UpperKey).str();
6534 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6535 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6537 if (ReturnType.isNull()) {
6538 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6539 Builder.AddTextChunk("NSUInteger");
6540 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6543 Builder.AddTypedTextChunk(
6544 Allocator.CopyString(SelectorId->getName()));
6545 Results.AddResult(Result(Builder.TakeString(),
6546 std::min(IndexedGetterPriority,
6547 UnorderedGetterPriority),
6548 CXCursor_ObjCInstanceMethodDecl));
6553 // Add -(id)objectInKeyAtIndex:(NSUInteger)index
6554 if (IsInstanceMethod &&
6555 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
6556 std::string SelectorName
6557 = (Twine("objectIn") + UpperKey + "AtIndex").str();
6558 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6559 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6560 if (ReturnType.isNull()) {
6561 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6562 Builder.AddTextChunk("id");
6563 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6566 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6567 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6568 Builder.AddTextChunk("NSUInteger");
6569 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6570 Builder.AddTextChunk("index");
6571 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6572 CXCursor_ObjCInstanceMethodDecl));
6576 // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes
6577 if (IsInstanceMethod &&
6578 (ReturnType.isNull() ||
6579 (ReturnType->isObjCObjectPointerType() &&
6580 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6581 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6582 ->getName() == "NSArray"))) {
6583 std::string SelectorName
6584 = (Twine(Property->getName()) + "AtIndexes").str();
6585 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6586 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6587 if (ReturnType.isNull()) {
6588 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6589 Builder.AddTextChunk("NSArray *");
6590 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6593 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6594 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6595 Builder.AddTextChunk("NSIndexSet *");
6596 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6597 Builder.AddTextChunk("indexes");
6598 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6599 CXCursor_ObjCInstanceMethodDecl));
6603 // Add -(void)getKey:(type **)buffer range:(NSRange)inRange
6604 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6605 std::string SelectorName = (Twine("get") + UpperKey).str();
6606 IdentifierInfo *SelectorIds[2] = {
6607 &Context.Idents.get(SelectorName),
6608 &Context.Idents.get("range")
6611 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6612 if (ReturnType.isNull()) {
6613 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6614 Builder.AddTextChunk("void");
6615 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6618 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6619 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6620 Builder.AddPlaceholderChunk("object-type");
6621 Builder.AddTextChunk(" **");
6622 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6623 Builder.AddTextChunk("buffer");
6624 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6625 Builder.AddTypedTextChunk("range:");
6626 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6627 Builder.AddTextChunk("NSRange");
6628 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6629 Builder.AddTextChunk("inRange");
6630 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6631 CXCursor_ObjCInstanceMethodDecl));
6635 // Mutable indexed accessors
6637 // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index
6638 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6639 std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str();
6640 IdentifierInfo *SelectorIds[2] = {
6641 &Context.Idents.get("insertObject"),
6642 &Context.Idents.get(SelectorName)
6645 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6646 if (ReturnType.isNull()) {
6647 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6648 Builder.AddTextChunk("void");
6649 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6652 Builder.AddTypedTextChunk("insertObject:");
6653 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6654 Builder.AddPlaceholderChunk("object-type");
6655 Builder.AddTextChunk(" *");
6656 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6657 Builder.AddTextChunk("object");
6658 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6659 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6660 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6661 Builder.AddPlaceholderChunk("NSUInteger");
6662 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6663 Builder.AddTextChunk("index");
6664 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6665 CXCursor_ObjCInstanceMethodDecl));
6669 // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes
6670 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6671 std::string SelectorName = (Twine("insert") + UpperKey).str();
6672 IdentifierInfo *SelectorIds[2] = {
6673 &Context.Idents.get(SelectorName),
6674 &Context.Idents.get("atIndexes")
6677 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6678 if (ReturnType.isNull()) {
6679 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6680 Builder.AddTextChunk("void");
6681 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6684 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6685 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6686 Builder.AddTextChunk("NSArray *");
6687 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6688 Builder.AddTextChunk("array");
6689 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6690 Builder.AddTypedTextChunk("atIndexes:");
6691 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6692 Builder.AddPlaceholderChunk("NSIndexSet *");
6693 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6694 Builder.AddTextChunk("indexes");
6695 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6696 CXCursor_ObjCInstanceMethodDecl));
6700 // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index
6701 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6702 std::string SelectorName
6703 = (Twine("removeObjectFrom") + UpperKey + "AtIndex").str();
6704 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6705 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6706 if (ReturnType.isNull()) {
6707 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6708 Builder.AddTextChunk("void");
6709 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6712 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6713 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6714 Builder.AddTextChunk("NSUInteger");
6715 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6716 Builder.AddTextChunk("index");
6717 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6718 CXCursor_ObjCInstanceMethodDecl));
6722 // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes
6723 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6724 std::string SelectorName
6725 = (Twine("remove") + UpperKey + "AtIndexes").str();
6726 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6727 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6728 if (ReturnType.isNull()) {
6729 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6730 Builder.AddTextChunk("void");
6731 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6734 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6735 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6736 Builder.AddTextChunk("NSIndexSet *");
6737 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6738 Builder.AddTextChunk("indexes");
6739 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6740 CXCursor_ObjCInstanceMethodDecl));
6744 // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object
6745 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6746 std::string SelectorName
6747 = (Twine("replaceObjectIn") + UpperKey + "AtIndex").str();
6748 IdentifierInfo *SelectorIds[2] = {
6749 &Context.Idents.get(SelectorName),
6750 &Context.Idents.get("withObject")
6753 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6754 if (ReturnType.isNull()) {
6755 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6756 Builder.AddTextChunk("void");
6757 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6760 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6761 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6762 Builder.AddPlaceholderChunk("NSUInteger");
6763 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6764 Builder.AddTextChunk("index");
6765 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6766 Builder.AddTypedTextChunk("withObject:");
6767 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6768 Builder.AddTextChunk("id");
6769 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6770 Builder.AddTextChunk("object");
6771 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6772 CXCursor_ObjCInstanceMethodDecl));
6776 // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array
6777 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6778 std::string SelectorName1
6779 = (Twine("replace") + UpperKey + "AtIndexes").str();
6780 std::string SelectorName2 = (Twine("with") + UpperKey).str();
6781 IdentifierInfo *SelectorIds[2] = {
6782 &Context.Idents.get(SelectorName1),
6783 &Context.Idents.get(SelectorName2)
6786 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6787 if (ReturnType.isNull()) {
6788 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6789 Builder.AddTextChunk("void");
6790 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6793 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName1 + ":"));
6794 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6795 Builder.AddPlaceholderChunk("NSIndexSet *");
6796 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6797 Builder.AddTextChunk("indexes");
6798 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6799 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":"));
6800 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6801 Builder.AddTextChunk("NSArray *");
6802 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6803 Builder.AddTextChunk("array");
6804 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6805 CXCursor_ObjCInstanceMethodDecl));
6809 // Unordered getters
6810 // - (NSEnumerator *)enumeratorOfKey
6811 if (IsInstanceMethod &&
6812 (ReturnType.isNull() ||
6813 (ReturnType->isObjCObjectPointerType() &&
6814 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6815 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6816 ->getName() == "NSEnumerator"))) {
6817 std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str();
6818 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6819 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6821 if (ReturnType.isNull()) {
6822 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6823 Builder.AddTextChunk("NSEnumerator *");
6824 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6827 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6828 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
6829 CXCursor_ObjCInstanceMethodDecl));
6833 // - (type *)memberOfKey:(type *)object
6834 if (IsInstanceMethod &&
6835 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
6836 std::string SelectorName = (Twine("memberOf") + UpperKey).str();
6837 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6838 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6839 if (ReturnType.isNull()) {
6840 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6841 Builder.AddPlaceholderChunk("object-type");
6842 Builder.AddTextChunk(" *");
6843 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6846 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6847 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6848 if (ReturnType.isNull()) {
6849 Builder.AddPlaceholderChunk("object-type");
6850 Builder.AddTextChunk(" *");
6852 Builder.AddTextChunk(GetCompletionTypeString(ReturnType, Context,
6854 Builder.getAllocator()));
6856 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6857 Builder.AddTextChunk("object");
6858 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
6859 CXCursor_ObjCInstanceMethodDecl));
6863 // Mutable unordered accessors
6864 // - (void)addKeyObject:(type *)object
6865 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6866 std::string SelectorName
6867 = (Twine("add") + UpperKey + Twine("Object")).str();
6868 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6869 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6870 if (ReturnType.isNull()) {
6871 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6872 Builder.AddTextChunk("void");
6873 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6876 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6877 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6878 Builder.AddPlaceholderChunk("object-type");
6879 Builder.AddTextChunk(" *");
6880 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6881 Builder.AddTextChunk("object");
6882 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6883 CXCursor_ObjCInstanceMethodDecl));
6887 // - (void)addKey:(NSSet *)objects
6888 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6889 std::string SelectorName = (Twine("add") + UpperKey).str();
6890 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6891 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6892 if (ReturnType.isNull()) {
6893 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6894 Builder.AddTextChunk("void");
6895 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6898 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6899 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6900 Builder.AddTextChunk("NSSet *");
6901 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6902 Builder.AddTextChunk("objects");
6903 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6904 CXCursor_ObjCInstanceMethodDecl));
6908 // - (void)removeKeyObject:(type *)object
6909 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6910 std::string SelectorName
6911 = (Twine("remove") + UpperKey + Twine("Object")).str();
6912 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6913 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6914 if (ReturnType.isNull()) {
6915 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6916 Builder.AddTextChunk("void");
6917 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6920 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6921 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6922 Builder.AddPlaceholderChunk("object-type");
6923 Builder.AddTextChunk(" *");
6924 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6925 Builder.AddTextChunk("object");
6926 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6927 CXCursor_ObjCInstanceMethodDecl));
6931 // - (void)removeKey:(NSSet *)objects
6932 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6933 std::string SelectorName = (Twine("remove") + UpperKey).str();
6934 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6935 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6936 if (ReturnType.isNull()) {
6937 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6938 Builder.AddTextChunk("void");
6939 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6942 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6943 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6944 Builder.AddTextChunk("NSSet *");
6945 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6946 Builder.AddTextChunk("objects");
6947 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6948 CXCursor_ObjCInstanceMethodDecl));
6952 // - (void)intersectKey:(NSSet *)objects
6953 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6954 std::string SelectorName = (Twine("intersect") + UpperKey).str();
6955 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6956 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6957 if (ReturnType.isNull()) {
6958 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6959 Builder.AddTextChunk("void");
6960 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6963 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6964 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6965 Builder.AddTextChunk("NSSet *");
6966 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6967 Builder.AddTextChunk("objects");
6968 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6969 CXCursor_ObjCInstanceMethodDecl));
6973 // Key-Value Observing
6974 // + (NSSet *)keyPathsForValuesAffectingKey
6975 if (!IsInstanceMethod &&
6976 (ReturnType.isNull() ||
6977 (ReturnType->isObjCObjectPointerType() &&
6978 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6979 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6980 ->getName() == "NSSet"))) {
6981 std::string SelectorName
6982 = (Twine("keyPathsForValuesAffecting") + UpperKey).str();
6983 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6984 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6986 if (ReturnType.isNull()) {
6987 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6988 Builder.AddTextChunk("NSSet *");
6989 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6992 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6993 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6994 CXCursor_ObjCClassMethodDecl));
6998 // + (BOOL)automaticallyNotifiesObserversForKey
6999 if (!IsInstanceMethod &&
7000 (ReturnType.isNull() ||
7001 ReturnType->isIntegerType() ||
7002 ReturnType->isBooleanType())) {
7003 std::string SelectorName
7004 = (Twine("automaticallyNotifiesObserversOf") + UpperKey).str();
7005 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7006 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7008 if (ReturnType.isNull()) {
7009 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7010 Builder.AddTextChunk("BOOL");
7011 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7014 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7015 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7016 CXCursor_ObjCClassMethodDecl));
7021 void Sema::CodeCompleteObjCMethodDecl(Scope *S,
7022 bool IsInstanceMethod,
7023 ParsedType ReturnTy) {
7024 // Determine the return type of the method we're declaring, if
7026 QualType ReturnType = GetTypeFromParser(ReturnTy);
7027 Decl *IDecl = nullptr;
7028 if (CurContext->isObjCContainer()) {
7029 ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
7030 IDecl = cast<Decl>(OCD);
7032 // Determine where we should start searching for methods.
7033 ObjCContainerDecl *SearchDecl = nullptr;
7034 bool IsInImplementation = false;
7035 if (Decl *D = IDecl) {
7036 if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) {
7037 SearchDecl = Impl->getClassInterface();
7038 IsInImplementation = true;
7039 } else if (ObjCCategoryImplDecl *CatImpl
7040 = dyn_cast<ObjCCategoryImplDecl>(D)) {
7041 SearchDecl = CatImpl->getCategoryDecl();
7042 IsInImplementation = true;
7044 SearchDecl = dyn_cast<ObjCContainerDecl>(D);
7047 if (!SearchDecl && S) {
7048 if (DeclContext *DC = S->getEntity())
7049 SearchDecl = dyn_cast<ObjCContainerDecl>(DC);
7053 HandleCodeCompleteResults(this, CodeCompleter,
7054 CodeCompletionContext::CCC_Other,
7059 // Find all of the methods that we could declare/implement here.
7060 KnownMethodsMap KnownMethods;
7061 FindImplementableMethods(Context, SearchDecl, IsInstanceMethod,
7062 ReturnType, KnownMethods);
7064 // Add declarations or definitions for each of the known methods.
7065 typedef CodeCompletionResult Result;
7066 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7067 CodeCompleter->getCodeCompletionTUInfo(),
7068 CodeCompletionContext::CCC_Other);
7069 Results.EnterNewScope();
7070 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
7071 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7072 MEnd = KnownMethods.end();
7074 ObjCMethodDecl *Method = M->second.getPointer();
7075 CodeCompletionBuilder Builder(Results.getAllocator(),
7076 Results.getCodeCompletionTUInfo());
7078 // If the result type was not already provided, add it to the
7079 // pattern as (type).
7080 if (ReturnType.isNull()) {
7081 QualType ResTy = Method->getSendResultType().stripObjCKindOfType(Context);
7082 AttributedType::stripOuterNullability(ResTy);
7083 AddObjCPassingTypeChunk(ResTy,
7084 Method->getObjCDeclQualifier(), Context, Policy,
7088 Selector Sel = Method->getSelector();
7090 // Add the first part of the selector to the pattern.
7091 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7092 Sel.getNameForSlot(0)));
7094 // Add parameters to the pattern.
7096 for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
7097 PEnd = Method->param_end();
7098 P != PEnd; (void)++P, ++I) {
7099 // Add the part of the selector name.
7101 Builder.AddTypedTextChunk(":");
7102 else if (I < Sel.getNumArgs()) {
7103 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7104 Builder.AddTypedTextChunk(
7105 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
7109 // Add the parameter type.
7111 if ((*P)->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
7112 ParamType = (*P)->getType();
7114 ParamType = (*P)->getOriginalType();
7115 ParamType = ParamType.substObjCTypeArgs(Context, {},
7116 ObjCSubstitutionContext::Parameter);
7117 AttributedType::stripOuterNullability(ParamType);
7118 AddObjCPassingTypeChunk(ParamType,
7119 (*P)->getObjCDeclQualifier(),
7123 if (IdentifierInfo *Id = (*P)->getIdentifier())
7124 Builder.AddTextChunk(Builder.getAllocator().CopyString( Id->getName()));
7127 if (Method->isVariadic()) {
7128 if (Method->param_size() > 0)
7129 Builder.AddChunk(CodeCompletionString::CK_Comma);
7130 Builder.AddTextChunk("...");
7133 if (IsInImplementation && Results.includeCodePatterns()) {
7134 // We will be defining the method here, so add a compound statement.
7135 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7136 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
7137 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
7138 if (!Method->getReturnType()->isVoidType()) {
7139 // If the result type is not void, add a return clause.
7140 Builder.AddTextChunk("return");
7141 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7142 Builder.AddPlaceholderChunk("expression");
7143 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
7145 Builder.AddPlaceholderChunk("statements");
7147 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
7148 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
7151 unsigned Priority = CCP_CodePattern;
7152 if (!M->second.getInt())
7153 Priority += CCD_InBaseClass;
7155 Results.AddResult(Result(Builder.TakeString(), Method, Priority));
7158 // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of
7159 // the properties in this class and its categories.
7160 if (Context.getLangOpts().ObjC2) {
7161 SmallVector<ObjCContainerDecl *, 4> Containers;
7162 Containers.push_back(SearchDecl);
7164 VisitedSelectorSet KnownSelectors;
7165 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7166 MEnd = KnownMethods.end();
7168 KnownSelectors.insert(M->first);
7171 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl);
7173 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl))
7174 IFace = Category->getClassInterface();
7177 for (auto *Cat : IFace->visible_categories())
7178 Containers.push_back(Cat);
7180 for (unsigned I = 0, N = Containers.size(); I != N; ++I)
7181 for (auto *P : Containers[I]->properties())
7182 AddObjCKeyValueCompletions(P, IsInstanceMethod, ReturnType, Context,
7183 KnownSelectors, Results);
7186 Results.ExitScope();
7188 HandleCodeCompleteResults(this, CodeCompleter,
7189 CodeCompletionContext::CCC_Other,
7190 Results.data(),Results.size());
7193 void Sema::CodeCompleteObjCMethodDeclSelector(Scope *S,
7194 bool IsInstanceMethod,
7195 bool AtParameterName,
7196 ParsedType ReturnTy,
7197 ArrayRef<IdentifierInfo *> SelIdents) {
7198 // If we have an external source, load the entire class method
7199 // pool from the AST file.
7200 if (ExternalSource) {
7201 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
7203 Selector Sel = ExternalSource->GetExternalSelector(I);
7204 if (Sel.isNull() || MethodPool.count(Sel))
7207 ReadMethodPool(Sel);
7211 // Build the set of methods we can see.
7212 typedef CodeCompletionResult Result;
7213 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7214 CodeCompleter->getCodeCompletionTUInfo(),
7215 CodeCompletionContext::CCC_Other);
7218 Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType());
7220 Results.EnterNewScope();
7221 for (GlobalMethodPool::iterator M = MethodPool.begin(),
7222 MEnd = MethodPool.end();
7224 for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first :
7226 MethList && MethList->getMethod();
7227 MethList = MethList->getNext()) {
7228 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
7231 if (AtParameterName) {
7232 // Suggest parameter names we've seen before.
7233 unsigned NumSelIdents = SelIdents.size();
7235 NumSelIdents <= MethList->getMethod()->param_size()) {
7236 ParmVarDecl *Param =
7237 MethList->getMethod()->parameters()[NumSelIdents - 1];
7238 if (Param->getIdentifier()) {
7239 CodeCompletionBuilder Builder(Results.getAllocator(),
7240 Results.getCodeCompletionTUInfo());
7241 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7242 Param->getIdentifier()->getName()));
7243 Results.AddResult(Builder.TakeString());
7250 Result R(MethList->getMethod(),
7251 Results.getBasePriority(MethList->getMethod()), nullptr);
7252 R.StartParameter = SelIdents.size();
7253 R.AllParametersAreInformative = false;
7254 R.DeclaringEntity = true;
7255 Results.MaybeAddResult(R, CurContext);
7259 Results.ExitScope();
7260 HandleCodeCompleteResults(this, CodeCompleter,
7261 CodeCompletionContext::CCC_Other,
7262 Results.data(),Results.size());
7265 void Sema::CodeCompletePreprocessorDirective(bool InConditional) {
7266 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7267 CodeCompleter->getCodeCompletionTUInfo(),
7268 CodeCompletionContext::CCC_PreprocessorDirective);
7269 Results.EnterNewScope();
7272 CodeCompletionBuilder Builder(Results.getAllocator(),
7273 Results.getCodeCompletionTUInfo());
7274 Builder.AddTypedTextChunk("if");
7275 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7276 Builder.AddPlaceholderChunk("condition");
7277 Results.AddResult(Builder.TakeString());
7280 Builder.AddTypedTextChunk("ifdef");
7281 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7282 Builder.AddPlaceholderChunk("macro");
7283 Results.AddResult(Builder.TakeString());
7286 Builder.AddTypedTextChunk("ifndef");
7287 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7288 Builder.AddPlaceholderChunk("macro");
7289 Results.AddResult(Builder.TakeString());
7291 if (InConditional) {
7292 // #elif <condition>
7293 Builder.AddTypedTextChunk("elif");
7294 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7295 Builder.AddPlaceholderChunk("condition");
7296 Results.AddResult(Builder.TakeString());
7299 Builder.AddTypedTextChunk("else");
7300 Results.AddResult(Builder.TakeString());
7303 Builder.AddTypedTextChunk("endif");
7304 Results.AddResult(Builder.TakeString());
7307 // #include "header"
7308 Builder.AddTypedTextChunk("include");
7309 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7310 Builder.AddTextChunk("\"");
7311 Builder.AddPlaceholderChunk("header");
7312 Builder.AddTextChunk("\"");
7313 Results.AddResult(Builder.TakeString());
7315 // #include <header>
7316 Builder.AddTypedTextChunk("include");
7317 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7318 Builder.AddTextChunk("<");
7319 Builder.AddPlaceholderChunk("header");
7320 Builder.AddTextChunk(">");
7321 Results.AddResult(Builder.TakeString());
7324 Builder.AddTypedTextChunk("define");
7325 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7326 Builder.AddPlaceholderChunk("macro");
7327 Results.AddResult(Builder.TakeString());
7329 // #define <macro>(<args>)
7330 Builder.AddTypedTextChunk("define");
7331 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7332 Builder.AddPlaceholderChunk("macro");
7333 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7334 Builder.AddPlaceholderChunk("args");
7335 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7336 Results.AddResult(Builder.TakeString());
7339 Builder.AddTypedTextChunk("undef");
7340 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7341 Builder.AddPlaceholderChunk("macro");
7342 Results.AddResult(Builder.TakeString());
7345 Builder.AddTypedTextChunk("line");
7346 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7347 Builder.AddPlaceholderChunk("number");
7348 Results.AddResult(Builder.TakeString());
7350 // #line <number> "filename"
7351 Builder.AddTypedTextChunk("line");
7352 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7353 Builder.AddPlaceholderChunk("number");
7354 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7355 Builder.AddTextChunk("\"");
7356 Builder.AddPlaceholderChunk("filename");
7357 Builder.AddTextChunk("\"");
7358 Results.AddResult(Builder.TakeString());
7361 Builder.AddTypedTextChunk("error");
7362 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7363 Builder.AddPlaceholderChunk("message");
7364 Results.AddResult(Builder.TakeString());
7366 // #pragma <arguments>
7367 Builder.AddTypedTextChunk("pragma");
7368 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7369 Builder.AddPlaceholderChunk("arguments");
7370 Results.AddResult(Builder.TakeString());
7372 if (getLangOpts().ObjC1) {
7374 Builder.AddTypedTextChunk("import");
7375 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7376 Builder.AddTextChunk("\"");
7377 Builder.AddPlaceholderChunk("header");
7378 Builder.AddTextChunk("\"");
7379 Results.AddResult(Builder.TakeString());
7382 Builder.AddTypedTextChunk("import");
7383 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7384 Builder.AddTextChunk("<");
7385 Builder.AddPlaceholderChunk("header");
7386 Builder.AddTextChunk(">");
7387 Results.AddResult(Builder.TakeString());
7390 // #include_next "header"
7391 Builder.AddTypedTextChunk("include_next");
7392 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7393 Builder.AddTextChunk("\"");
7394 Builder.AddPlaceholderChunk("header");
7395 Builder.AddTextChunk("\"");
7396 Results.AddResult(Builder.TakeString());
7398 // #include_next <header>
7399 Builder.AddTypedTextChunk("include_next");
7400 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7401 Builder.AddTextChunk("<");
7402 Builder.AddPlaceholderChunk("header");
7403 Builder.AddTextChunk(">");
7404 Results.AddResult(Builder.TakeString());
7406 // #warning <message>
7407 Builder.AddTypedTextChunk("warning");
7408 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7409 Builder.AddPlaceholderChunk("message");
7410 Results.AddResult(Builder.TakeString());
7412 // Note: #ident and #sccs are such crazy anachronisms that we don't provide
7413 // completions for them. And __include_macros is a Clang-internal extension
7414 // that we don't want to encourage anyone to use.
7416 // FIXME: we don't support #assert or #unassert, so don't suggest them.
7417 Results.ExitScope();
7419 HandleCodeCompleteResults(this, CodeCompleter,
7420 CodeCompletionContext::CCC_PreprocessorDirective,
7421 Results.data(), Results.size());
7424 void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) {
7425 CodeCompleteOrdinaryName(S,
7426 S->getFnParent()? Sema::PCC_RecoveryInFunction
7427 : Sema::PCC_Namespace);
7430 void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) {
7431 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7432 CodeCompleter->getCodeCompletionTUInfo(),
7433 IsDefinition? CodeCompletionContext::CCC_MacroName
7434 : CodeCompletionContext::CCC_MacroNameUse);
7435 if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) {
7436 // Add just the names of macros, not their arguments.
7437 CodeCompletionBuilder Builder(Results.getAllocator(),
7438 Results.getCodeCompletionTUInfo());
7439 Results.EnterNewScope();
7440 for (Preprocessor::macro_iterator M = PP.macro_begin(),
7441 MEnd = PP.macro_end();
7443 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7444 M->first->getName()));
7445 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
7447 CXCursor_MacroDefinition));
7449 Results.ExitScope();
7450 } else if (IsDefinition) {
7451 // FIXME: Can we detect when the user just wrote an include guard above?
7454 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7455 Results.data(), Results.size());
7458 void Sema::CodeCompletePreprocessorExpression() {
7459 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7460 CodeCompleter->getCodeCompletionTUInfo(),
7461 CodeCompletionContext::CCC_PreprocessorExpression);
7463 if (!CodeCompleter || CodeCompleter->includeMacros())
7464 AddMacroResults(PP, Results, true);
7466 // defined (<macro>)
7467 Results.EnterNewScope();
7468 CodeCompletionBuilder Builder(Results.getAllocator(),
7469 Results.getCodeCompletionTUInfo());
7470 Builder.AddTypedTextChunk("defined");
7471 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7472 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7473 Builder.AddPlaceholderChunk("macro");
7474 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7475 Results.AddResult(Builder.TakeString());
7476 Results.ExitScope();
7478 HandleCodeCompleteResults(this, CodeCompleter,
7479 CodeCompletionContext::CCC_PreprocessorExpression,
7480 Results.data(), Results.size());
7483 void Sema::CodeCompletePreprocessorMacroArgument(Scope *S,
7484 IdentifierInfo *Macro,
7485 MacroInfo *MacroInfo,
7486 unsigned Argument) {
7487 // FIXME: In the future, we could provide "overload" results, much like we
7488 // do for function calls.
7490 // Now just ignore this. There will be another code-completion callback
7491 // for the expanded tokens.
7494 void Sema::CodeCompleteNaturalLanguage() {
7495 HandleCodeCompleteResults(this, CodeCompleter,
7496 CodeCompletionContext::CCC_NaturalLanguage,
7500 void Sema::GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,
7501 CodeCompletionTUInfo &CCTUInfo,
7502 SmallVectorImpl<CodeCompletionResult> &Results) {
7503 ResultBuilder Builder(*this, Allocator, CCTUInfo,
7504 CodeCompletionContext::CCC_Recovery);
7505 if (!CodeCompleter || CodeCompleter->includeGlobals()) {
7506 CodeCompletionDeclConsumer Consumer(Builder,
7507 Context.getTranslationUnitDecl());
7508 LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName,
7512 if (!CodeCompleter || CodeCompleter->includeMacros())
7513 AddMacroResults(PP, Builder, true);
7516 Results.insert(Results.end(),
7517 Builder.data(), Builder.data() + Builder.size());