1 //===---------------- SemaCodeComplete.cpp - Code Completion ----*- C++ -*-===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // This file defines the code-completion semantic actions.
11 //===----------------------------------------------------------------------===//
12 #include "clang/AST/Decl.h"
13 #include "clang/AST/DeclBase.h"
14 #include "clang/AST/DeclCXX.h"
15 #include "clang/AST/DeclObjC.h"
16 #include "clang/AST/ExprCXX.h"
17 #include "clang/AST/ExprObjC.h"
18 #include "clang/AST/QualTypeNames.h"
19 #include "clang/AST/Type.h"
20 #include "clang/Basic/CharInfo.h"
21 #include "clang/Basic/Specifiers.h"
22 #include "clang/Lex/HeaderSearch.h"
23 #include "clang/Lex/MacroInfo.h"
24 #include "clang/Lex/Preprocessor.h"
25 #include "clang/Sema/CodeCompleteConsumer.h"
26 #include "clang/Sema/Lookup.h"
27 #include "clang/Sema/Overload.h"
28 #include "clang/Sema/Scope.h"
29 #include "clang/Sema/ScopeInfo.h"
30 #include "clang/Sema/SemaInternal.h"
31 #include "llvm/ADT/DenseSet.h"
32 #include "llvm/ADT/SmallBitVector.h"
33 #include "llvm/ADT/SmallPtrSet.h"
34 #include "llvm/ADT/SmallString.h"
35 #include "llvm/ADT/StringExtras.h"
36 #include "llvm/ADT/StringSwitch.h"
37 #include "llvm/ADT/Twine.h"
38 #include "llvm/ADT/iterator_range.h"
39 #include "llvm/Support/Path.h"
45 using namespace clang;
49 /// A container of code-completion results.
52 /// The type of a name-lookup filter, which can be provided to the
53 /// name-lookup routines to specify which declarations should be included in
54 /// the result set (when it returns true) and which declarations should be
55 /// filtered out (returns false).
56 typedef bool (ResultBuilder::*LookupFilter)(const NamedDecl *) const;
58 typedef CodeCompletionResult Result;
61 /// The actual results we have found.
62 std::vector<Result> Results;
64 /// A record of all of the declarations we have found and placed
65 /// into the result set, used to ensure that no declaration ever gets into
66 /// the result set twice.
67 llvm::SmallPtrSet<const Decl *, 16> AllDeclsFound;
69 typedef std::pair<const NamedDecl *, unsigned> DeclIndexPair;
71 /// An entry in the shadow map, which is optimized to store
72 /// a single (declaration, index) mapping (the common case) but
73 /// can also store a list of (declaration, index) mappings.
74 class ShadowMapEntry {
75 typedef SmallVector<DeclIndexPair, 4> DeclIndexPairVector;
77 /// Contains either the solitary NamedDecl * or a vector
78 /// of (declaration, index) pairs.
79 llvm::PointerUnion<const NamedDecl *, DeclIndexPairVector *> DeclOrVector;
81 /// When the entry contains a single declaration, this is
82 /// the index associated with that entry.
83 unsigned SingleDeclIndex;
86 ShadowMapEntry() : DeclOrVector(), SingleDeclIndex(0) {}
87 ShadowMapEntry(const ShadowMapEntry &) = delete;
88 ShadowMapEntry(ShadowMapEntry &&Move) { *this = std::move(Move); }
89 ShadowMapEntry &operator=(const ShadowMapEntry &) = delete;
90 ShadowMapEntry &operator=(ShadowMapEntry &&Move) {
91 SingleDeclIndex = Move.SingleDeclIndex;
92 DeclOrVector = Move.DeclOrVector;
93 Move.DeclOrVector = nullptr;
97 void Add(const NamedDecl *ND, unsigned Index) {
98 if (DeclOrVector.isNull()) {
99 // 0 - > 1 elements: just set the single element information.
101 SingleDeclIndex = Index;
105 if (const NamedDecl *PrevND =
106 DeclOrVector.dyn_cast<const NamedDecl *>()) {
107 // 1 -> 2 elements: create the vector of results and push in the
108 // existing declaration.
109 DeclIndexPairVector *Vec = new DeclIndexPairVector;
110 Vec->push_back(DeclIndexPair(PrevND, SingleDeclIndex));
114 // Add the new element to the end of the vector.
115 DeclOrVector.get<DeclIndexPairVector *>()->push_back(
116 DeclIndexPair(ND, Index));
120 if (DeclIndexPairVector *Vec =
121 DeclOrVector.dyn_cast<DeclIndexPairVector *>()) {
123 DeclOrVector = ((NamedDecl *)nullptr);
129 iterator begin() const;
130 iterator end() const;
133 /// A mapping from declaration names to the declarations that have
134 /// this name within a particular scope and their index within the list of
136 typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;
138 /// The semantic analysis object for which results are being
142 /// The allocator used to allocate new code-completion strings.
143 CodeCompletionAllocator &Allocator;
145 CodeCompletionTUInfo &CCTUInfo;
147 /// If non-NULL, a filter function used to remove any code-completion
148 /// results that are not desirable.
151 /// Whether we should allow declarations as
152 /// nested-name-specifiers that would otherwise be filtered out.
153 bool AllowNestedNameSpecifiers;
155 /// If set, the type that we would prefer our resulting value
156 /// declarations to have.
158 /// Closely matching the preferred type gives a boost to a result's
160 CanQualType PreferredType;
162 /// A list of shadow maps, which is used to model name hiding at
163 /// different levels of, e.g., the inheritance hierarchy.
164 std::list<ShadowMap> ShadowMaps;
166 /// Overloaded C++ member functions found by SemaLookup.
167 /// Used to determine when one overload is dominated by another.
168 llvm::DenseMap<std::pair<DeclContext *, /*Name*/uintptr_t>, ShadowMapEntry>
171 /// If we're potentially referring to a C++ member function, the set
172 /// of qualifiers applied to the object type.
173 Qualifiers ObjectTypeQualifiers;
174 /// The kind of the object expression, for rvalue/lvalue overloads.
175 ExprValueKind ObjectKind;
177 /// Whether the \p ObjectTypeQualifiers field is active.
178 bool HasObjectTypeQualifiers;
180 /// The selector that we prefer.
181 Selector PreferredSelector;
183 /// The completion context in which we are gathering results.
184 CodeCompletionContext CompletionContext;
186 /// If we are in an instance method definition, the \@implementation
188 ObjCImplementationDecl *ObjCImplementation;
190 void AdjustResultPriorityForDecl(Result &R);
192 void MaybeAddConstructorResults(Result R);
195 explicit ResultBuilder(Sema &SemaRef, CodeCompletionAllocator &Allocator,
196 CodeCompletionTUInfo &CCTUInfo,
197 const CodeCompletionContext &CompletionContext,
198 LookupFilter Filter = nullptr)
199 : SemaRef(SemaRef), Allocator(Allocator), CCTUInfo(CCTUInfo),
200 Filter(Filter), AllowNestedNameSpecifiers(false),
201 HasObjectTypeQualifiers(false), CompletionContext(CompletionContext),
202 ObjCImplementation(nullptr) {
203 // If this is an Objective-C instance method definition, dig out the
204 // corresponding implementation.
205 switch (CompletionContext.getKind()) {
206 case CodeCompletionContext::CCC_Expression:
207 case CodeCompletionContext::CCC_ObjCMessageReceiver:
208 case CodeCompletionContext::CCC_ParenthesizedExpression:
209 case CodeCompletionContext::CCC_Statement:
210 case CodeCompletionContext::CCC_Recovery:
211 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl())
212 if (Method->isInstanceMethod())
213 if (ObjCInterfaceDecl *Interface = Method->getClassInterface())
214 ObjCImplementation = Interface->getImplementation();
222 /// Determine the priority for a reference to the given declaration.
223 unsigned getBasePriority(const NamedDecl *D);
225 /// Whether we should include code patterns in the completion
227 bool includeCodePatterns() const {
228 return SemaRef.CodeCompleter &&
229 SemaRef.CodeCompleter->includeCodePatterns();
232 /// Set the filter used for code-completion results.
233 void setFilter(LookupFilter Filter) { this->Filter = Filter; }
235 Result *data() { return Results.empty() ? nullptr : &Results.front(); }
236 unsigned size() const { return Results.size(); }
237 bool empty() const { return Results.empty(); }
239 /// Specify the preferred type.
240 void setPreferredType(QualType T) {
241 PreferredType = SemaRef.Context.getCanonicalType(T);
244 /// Set the cv-qualifiers on the object type, for us in filtering
245 /// calls to member functions.
247 /// When there are qualifiers in this set, they will be used to filter
248 /// out member functions that aren't available (because there will be a
249 /// cv-qualifier mismatch) or prefer functions with an exact qualifier
251 void setObjectTypeQualifiers(Qualifiers Quals, ExprValueKind Kind) {
252 ObjectTypeQualifiers = Quals;
254 HasObjectTypeQualifiers = true;
257 /// Set the preferred selector.
259 /// When an Objective-C method declaration result is added, and that
260 /// method's selector matches this preferred selector, we give that method
261 /// a slight priority boost.
262 void setPreferredSelector(Selector Sel) { PreferredSelector = Sel; }
264 /// Retrieve the code-completion context for which results are
266 const CodeCompletionContext &getCompletionContext() const {
267 return CompletionContext;
270 /// Specify whether nested-name-specifiers are allowed.
271 void allowNestedNameSpecifiers(bool Allow = true) {
272 AllowNestedNameSpecifiers = Allow;
275 /// Return the semantic analysis object for which we are collecting
276 /// code completion results.
277 Sema &getSema() const { return SemaRef; }
279 /// Retrieve the allocator used to allocate code completion strings.
280 CodeCompletionAllocator &getAllocator() const { return Allocator; }
282 CodeCompletionTUInfo &getCodeCompletionTUInfo() const { return CCTUInfo; }
284 /// Determine whether the given declaration is at all interesting
285 /// as a code-completion result.
287 /// \param ND the declaration that we are inspecting.
289 /// \param AsNestedNameSpecifier will be set true if this declaration is
290 /// only interesting when it is a nested-name-specifier.
291 bool isInterestingDecl(const NamedDecl *ND,
292 bool &AsNestedNameSpecifier) const;
294 /// Check whether the result is hidden by the Hiding declaration.
296 /// \returns true if the result is hidden and cannot be found, false if
297 /// the hidden result could still be found. When false, \p R may be
298 /// modified to describe how the result can be found (e.g., via extra
300 bool CheckHiddenResult(Result &R, DeclContext *CurContext,
301 const NamedDecl *Hiding);
303 /// Add a new result to this result set (if it isn't already in one
304 /// of the shadow maps), or replace an existing result (for, e.g., a
307 /// \param R the result to add (if it is unique).
309 /// \param CurContext the context in which this result will be named.
310 void MaybeAddResult(Result R, DeclContext *CurContext = nullptr);
312 /// Add a new result to this result set, where we already know
313 /// the hiding declaration (if any).
315 /// \param R the result to add (if it is unique).
317 /// \param CurContext the context in which this result will be named.
319 /// \param Hiding the declaration that hides the result.
321 /// \param InBaseClass whether the result was found in a base
322 /// class of the searched context.
323 void AddResult(Result R, DeclContext *CurContext, NamedDecl *Hiding,
326 /// Add a new non-declaration result to this result set.
327 void AddResult(Result R);
329 /// Enter into a new scope.
330 void EnterNewScope();
332 /// Exit from the current scope.
335 /// Ignore this declaration, if it is seen again.
336 void Ignore(const Decl *D) { AllDeclsFound.insert(D->getCanonicalDecl()); }
338 /// Add a visited context.
339 void addVisitedContext(DeclContext *Ctx) {
340 CompletionContext.addVisitedContext(Ctx);
343 /// \name Name lookup predicates
345 /// These predicates can be passed to the name lookup functions to filter the
346 /// results of name lookup. All of the predicates have the same type, so that
349 bool IsOrdinaryName(const NamedDecl *ND) const;
350 bool IsOrdinaryNonTypeName(const NamedDecl *ND) const;
351 bool IsIntegralConstantValue(const NamedDecl *ND) const;
352 bool IsOrdinaryNonValueName(const NamedDecl *ND) const;
353 bool IsNestedNameSpecifier(const NamedDecl *ND) const;
354 bool IsEnum(const NamedDecl *ND) const;
355 bool IsClassOrStruct(const NamedDecl *ND) const;
356 bool IsUnion(const NamedDecl *ND) const;
357 bool IsNamespace(const NamedDecl *ND) const;
358 bool IsNamespaceOrAlias(const NamedDecl *ND) const;
359 bool IsType(const NamedDecl *ND) const;
360 bool IsMember(const NamedDecl *ND) const;
361 bool IsObjCIvar(const NamedDecl *ND) const;
362 bool IsObjCMessageReceiver(const NamedDecl *ND) const;
363 bool IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const;
364 bool IsObjCCollection(const NamedDecl *ND) const;
365 bool IsImpossibleToSatisfy(const NamedDecl *ND) const;
370 void PreferredTypeBuilder::enterReturn(Sema &S, SourceLocation Tok) {
371 if (isa<BlockDecl>(S.CurContext)) {
372 if (sema::BlockScopeInfo *BSI = S.getCurBlock()) {
373 ComputeType = nullptr;
374 Type = BSI->ReturnType;
377 } else if (const auto *Function = dyn_cast<FunctionDecl>(S.CurContext)) {
378 ComputeType = nullptr;
379 Type = Function->getReturnType();
381 } else if (const auto *Method = dyn_cast<ObjCMethodDecl>(S.CurContext)) {
382 ComputeType = nullptr;
383 Type = Method->getReturnType();
388 void PreferredTypeBuilder::enterVariableInit(SourceLocation Tok, Decl *D) {
389 auto *VD = llvm::dyn_cast_or_null<ValueDecl>(D);
390 ComputeType = nullptr;
391 Type = VD ? VD->getType() : QualType();
395 void PreferredTypeBuilder::enterFunctionArgument(
396 SourceLocation Tok, llvm::function_ref<QualType()> ComputeType) {
397 this->ComputeType = ComputeType;
402 void PreferredTypeBuilder::enterParenExpr(SourceLocation Tok,
403 SourceLocation LParLoc) {
404 // expected type for parenthesized expression does not change.
405 if (ExpectedLoc == LParLoc)
409 static QualType getPreferredTypeOfBinaryRHS(Sema &S, Expr *LHS,
414 QualType LHSType = LHS->getType();
415 if (LHSType->isPointerType()) {
416 if (Op == tok::plus || Op == tok::plusequal || Op == tok::minusequal)
417 return S.getASTContext().getPointerDiffType();
418 // Pointer difference is more common than subtracting an int from a pointer.
419 if (Op == tok::minus)
424 // No way to infer the type of RHS from LHS.
427 // Prefer the type of the left operand for all of these.
428 // Arithmetic operations.
432 case tok::minusequal:
434 case tok::percentequal:
436 case tok::slashequal:
441 // Comparison operators.
442 case tok::equalequal:
443 case tok::exclaimequal:
447 case tok::greaterequal:
449 return LHS->getType();
450 // Binary shifts are often overloaded, so don't try to guess those.
451 case tok::greatergreater:
452 case tok::greatergreaterequal:
454 case tok::lesslessequal:
455 if (LHSType->isIntegralOrEnumerationType())
456 return S.getASTContext().IntTy;
458 // Logical operators, assume we want bool.
461 case tok::caretcaret:
462 return S.getASTContext().BoolTy;
463 // Operators often used for bit manipulation are typically used with the type
464 // of the left argument.
468 case tok::caretequal:
471 if (LHSType->isIntegralOrEnumerationType())
474 // RHS should be a pointer to a member of the 'LHS' type, but we can't give
475 // any particular type here.
476 case tok::periodstar:
480 // FIXME(ibiryukov): handle the missing op, re-add the assertion.
481 // assert(false && "unhandled binary op");
486 /// Get preferred type for an argument of an unary expression. \p ContextType is
487 /// preferred type of the whole unary expression.
488 static QualType getPreferredTypeOfUnaryArg(Sema &S, QualType ContextType,
492 return S.getASTContext().BoolTy;
494 if (!ContextType.isNull() && ContextType->isPointerType())
495 return ContextType->getPointeeType();
498 if (ContextType.isNull())
500 return S.getASTContext().getPointerType(ContextType.getNonReferenceType());
504 case tok::minusminus:
506 if (ContextType.isNull())
507 return S.getASTContext().IntTy;
508 // leave as is, these operators typically return the same type.
514 assert(false && "unhandled unary op");
519 void PreferredTypeBuilder::enterBinary(Sema &S, SourceLocation Tok, Expr *LHS,
521 ComputeType = nullptr;
522 Type = getPreferredTypeOfBinaryRHS(S, LHS, Op);
526 void PreferredTypeBuilder::enterMemAccess(Sema &S, SourceLocation Tok,
530 // Do we have expected type for Base?
531 if (ExpectedLoc != Base->getBeginLoc())
533 // Keep the expected type, only update the location.
538 void PreferredTypeBuilder::enterUnary(Sema &S, SourceLocation Tok,
539 tok::TokenKind OpKind,
540 SourceLocation OpLoc) {
541 ComputeType = nullptr;
542 Type = getPreferredTypeOfUnaryArg(S, this->get(OpLoc), OpKind);
546 void PreferredTypeBuilder::enterSubscript(Sema &S, SourceLocation Tok,
548 ComputeType = nullptr;
549 Type = S.getASTContext().IntTy;
553 void PreferredTypeBuilder::enterTypeCast(SourceLocation Tok,
555 ComputeType = nullptr;
556 Type = !CastType.isNull() ? CastType.getCanonicalType() : QualType();
560 void PreferredTypeBuilder::enterCondition(Sema &S, SourceLocation Tok) {
561 ComputeType = nullptr;
562 Type = S.getASTContext().BoolTy;
566 class ResultBuilder::ShadowMapEntry::iterator {
567 llvm::PointerUnion<const NamedDecl *, const DeclIndexPair *> DeclOrIterator;
568 unsigned SingleDeclIndex;
571 typedef DeclIndexPair value_type;
572 typedef value_type reference;
573 typedef std::ptrdiff_t difference_type;
574 typedef std::input_iterator_tag iterator_category;
580 pointer(const DeclIndexPair &Value) : Value(Value) {}
582 const DeclIndexPair *operator->() const { return &Value; }
585 iterator() : DeclOrIterator((NamedDecl *)nullptr), SingleDeclIndex(0) {}
587 iterator(const NamedDecl *SingleDecl, unsigned Index)
588 : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) {}
590 iterator(const DeclIndexPair *Iterator)
591 : DeclOrIterator(Iterator), SingleDeclIndex(0) {}
593 iterator &operator++() {
594 if (DeclOrIterator.is<const NamedDecl *>()) {
595 DeclOrIterator = (NamedDecl *)nullptr;
600 const DeclIndexPair *I = DeclOrIterator.get<const DeclIndexPair *>();
606 /*iterator operator++(int) {
612 reference operator*() const {
613 if (const NamedDecl *ND = DeclOrIterator.dyn_cast<const NamedDecl *>())
614 return reference(ND, SingleDeclIndex);
616 return *DeclOrIterator.get<const DeclIndexPair *>();
619 pointer operator->() const { return pointer(**this); }
621 friend bool operator==(const iterator &X, const iterator &Y) {
622 return X.DeclOrIterator.getOpaqueValue() ==
623 Y.DeclOrIterator.getOpaqueValue() &&
624 X.SingleDeclIndex == Y.SingleDeclIndex;
627 friend bool operator!=(const iterator &X, const iterator &Y) {
632 ResultBuilder::ShadowMapEntry::iterator
633 ResultBuilder::ShadowMapEntry::begin() const {
634 if (DeclOrVector.isNull())
637 if (const NamedDecl *ND = DeclOrVector.dyn_cast<const NamedDecl *>())
638 return iterator(ND, SingleDeclIndex);
640 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->begin());
643 ResultBuilder::ShadowMapEntry::iterator
644 ResultBuilder::ShadowMapEntry::end() const {
645 if (DeclOrVector.is<const NamedDecl *>() || DeclOrVector.isNull())
648 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end());
651 /// Compute the qualification required to get from the current context
652 /// (\p CurContext) to the target context (\p TargetContext).
654 /// \param Context the AST context in which the qualification will be used.
656 /// \param CurContext the context where an entity is being named, which is
657 /// typically based on the current scope.
659 /// \param TargetContext the context in which the named entity actually
662 /// \returns a nested name specifier that refers into the target context, or
663 /// NULL if no qualification is needed.
664 static NestedNameSpecifier *
665 getRequiredQualification(ASTContext &Context, const DeclContext *CurContext,
666 const DeclContext *TargetContext) {
667 SmallVector<const DeclContext *, 4> TargetParents;
669 for (const DeclContext *CommonAncestor = TargetContext;
670 CommonAncestor && !CommonAncestor->Encloses(CurContext);
671 CommonAncestor = CommonAncestor->getLookupParent()) {
672 if (CommonAncestor->isTransparentContext() ||
673 CommonAncestor->isFunctionOrMethod())
676 TargetParents.push_back(CommonAncestor);
679 NestedNameSpecifier *Result = nullptr;
680 while (!TargetParents.empty()) {
681 const DeclContext *Parent = TargetParents.pop_back_val();
683 if (const auto *Namespace = dyn_cast<NamespaceDecl>(Parent)) {
684 if (!Namespace->getIdentifier())
687 Result = NestedNameSpecifier::Create(Context, Result, Namespace);
688 } else if (const auto *TD = dyn_cast<TagDecl>(Parent))
689 Result = NestedNameSpecifier::Create(
690 Context, Result, false, Context.getTypeDeclType(TD).getTypePtr());
695 /// Determine whether \p Id is a name reserved for the implementation (C99
696 /// 7.1.3, C++ [lib.global.names]).
697 static bool isReservedName(const IdentifierInfo *Id,
698 bool doubleUnderscoreOnly = false) {
699 if (Id->getLength() < 2)
701 const char *Name = Id->getNameStart();
702 return Name[0] == '_' &&
704 (Name[1] >= 'A' && Name[1] <= 'Z' && !doubleUnderscoreOnly));
707 // Some declarations have reserved names that we don't want to ever show.
708 // Filter out names reserved for the implementation if they come from a
710 static bool shouldIgnoreDueToReservedName(const NamedDecl *ND, Sema &SemaRef) {
711 const IdentifierInfo *Id = ND->getIdentifier();
715 // Ignore reserved names for compiler provided decls.
716 if (isReservedName(Id) && ND->getLocation().isInvalid())
719 // For system headers ignore only double-underscore names.
720 // This allows for system headers providing private symbols with a single
722 if (isReservedName(Id, /*doubleUnderscoreOnly=*/true) &&
723 SemaRef.SourceMgr.isInSystemHeader(
724 SemaRef.SourceMgr.getSpellingLoc(ND->getLocation())))
730 bool ResultBuilder::isInterestingDecl(const NamedDecl *ND,
731 bool &AsNestedNameSpecifier) const {
732 AsNestedNameSpecifier = false;
735 ND = ND->getUnderlyingDecl();
737 // Skip unnamed entities.
738 if (!ND->getDeclName())
741 // Friend declarations and declarations introduced due to friends are never
743 if (ND->getFriendObjectKind() == Decl::FOK_Undeclared)
746 // Class template (partial) specializations are never added as results.
747 if (isa<ClassTemplateSpecializationDecl>(ND) ||
748 isa<ClassTemplatePartialSpecializationDecl>(ND))
751 // Using declarations themselves are never added as results.
752 if (isa<UsingDecl>(ND))
755 if (shouldIgnoreDueToReservedName(ND, SemaRef))
758 if (Filter == &ResultBuilder::IsNestedNameSpecifier ||
759 (isa<NamespaceDecl>(ND) && Filter != &ResultBuilder::IsNamespace &&
760 Filter != &ResultBuilder::IsNamespaceOrAlias && Filter != nullptr))
761 AsNestedNameSpecifier = true;
763 // Filter out any unwanted results.
764 if (Filter && !(this->*Filter)(Named)) {
765 // Check whether it is interesting as a nested-name-specifier.
766 if (AllowNestedNameSpecifiers && SemaRef.getLangOpts().CPlusPlus &&
767 IsNestedNameSpecifier(ND) &&
768 (Filter != &ResultBuilder::IsMember ||
769 (isa<CXXRecordDecl>(ND) &&
770 cast<CXXRecordDecl>(ND)->isInjectedClassName()))) {
771 AsNestedNameSpecifier = true;
777 // ... then it must be interesting!
781 bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext,
782 const NamedDecl *Hiding) {
783 // In C, there is no way to refer to a hidden name.
784 // FIXME: This isn't true; we can find a tag name hidden by an ordinary
785 // name if we introduce the tag type.
786 if (!SemaRef.getLangOpts().CPlusPlus)
789 const DeclContext *HiddenCtx =
790 R.Declaration->getDeclContext()->getRedeclContext();
792 // There is no way to qualify a name declared in a function or method.
793 if (HiddenCtx->isFunctionOrMethod())
796 if (HiddenCtx == Hiding->getDeclContext()->getRedeclContext())
799 // We can refer to the result with the appropriate qualification. Do it.
801 R.QualifierIsInformative = false;
804 R.Qualifier = getRequiredQualification(SemaRef.Context, CurContext,
805 R.Declaration->getDeclContext());
809 /// A simplified classification of types used to determine whether two
810 /// types are "similar enough" when adjusting priorities.
811 SimplifiedTypeClass clang::getSimplifiedTypeClass(CanQualType T) {
812 switch (T->getTypeClass()) {
814 switch (cast<BuiltinType>(T)->getKind()) {
815 case BuiltinType::Void:
818 case BuiltinType::NullPtr:
821 case BuiltinType::Overload:
822 case BuiltinType::Dependent:
825 case BuiltinType::ObjCId:
826 case BuiltinType::ObjCClass:
827 case BuiltinType::ObjCSel:
828 return STC_ObjectiveC;
831 return STC_Arithmetic;
835 return STC_Arithmetic;
840 case Type::BlockPointer:
843 case Type::LValueReference:
844 case Type::RValueReference:
845 return getSimplifiedTypeClass(T->getAs<ReferenceType>()->getPointeeType());
847 case Type::ConstantArray:
848 case Type::IncompleteArray:
849 case Type::VariableArray:
850 case Type::DependentSizedArray:
853 case Type::DependentSizedExtVector:
855 case Type::ExtVector:
856 return STC_Arithmetic;
858 case Type::FunctionProto:
859 case Type::FunctionNoProto:
866 return STC_Arithmetic;
868 case Type::ObjCObject:
869 case Type::ObjCInterface:
870 case Type::ObjCObjectPointer:
871 return STC_ObjectiveC;
878 /// Get the type that a given expression will have if this declaration
879 /// is used as an expression in its "typical" code-completion form.
880 QualType clang::getDeclUsageType(ASTContext &C, const NamedDecl *ND) {
881 ND = ND->getUnderlyingDecl();
883 if (const auto *Type = dyn_cast<TypeDecl>(ND))
884 return C.getTypeDeclType(Type);
885 if (const auto *Iface = dyn_cast<ObjCInterfaceDecl>(ND))
886 return C.getObjCInterfaceType(Iface);
889 if (const FunctionDecl *Function = ND->getAsFunction())
890 T = Function->getCallResultType();
891 else if (const auto *Method = dyn_cast<ObjCMethodDecl>(ND))
892 T = Method->getSendResultType();
893 else if (const auto *Enumerator = dyn_cast<EnumConstantDecl>(ND))
894 T = C.getTypeDeclType(cast<EnumDecl>(Enumerator->getDeclContext()));
895 else if (const auto *Property = dyn_cast<ObjCPropertyDecl>(ND))
896 T = Property->getType();
897 else if (const auto *Value = dyn_cast<ValueDecl>(ND))
898 T = Value->getType();
903 // Dig through references, function pointers, and block pointers to
904 // get down to the likely type of an expression when the entity is
907 if (const auto *Ref = T->getAs<ReferenceType>()) {
908 T = Ref->getPointeeType();
912 if (const auto *Pointer = T->getAs<PointerType>()) {
913 if (Pointer->getPointeeType()->isFunctionType()) {
914 T = Pointer->getPointeeType();
921 if (const auto *Block = T->getAs<BlockPointerType>()) {
922 T = Block->getPointeeType();
926 if (const auto *Function = T->getAs<FunctionType>()) {
927 T = Function->getReturnType();
937 unsigned ResultBuilder::getBasePriority(const NamedDecl *ND) {
941 // Context-based decisions.
942 const DeclContext *LexicalDC = ND->getLexicalDeclContext();
943 if (LexicalDC->isFunctionOrMethod()) {
944 // _cmd is relatively rare
945 if (const auto *ImplicitParam = dyn_cast<ImplicitParamDecl>(ND))
946 if (ImplicitParam->getIdentifier() &&
947 ImplicitParam->getIdentifier()->isStr("_cmd"))
950 return CCP_LocalDeclaration;
953 const DeclContext *DC = ND->getDeclContext()->getRedeclContext();
954 if (DC->isRecord() || isa<ObjCContainerDecl>(DC)) {
955 // Explicit destructor calls are very rare.
956 if (isa<CXXDestructorDecl>(ND))
958 // Explicit operator and conversion function calls are also very rare.
959 auto DeclNameKind = ND->getDeclName().getNameKind();
960 if (DeclNameKind == DeclarationName::CXXOperatorName ||
961 DeclNameKind == DeclarationName::CXXLiteralOperatorName ||
962 DeclNameKind == DeclarationName::CXXConversionFunctionName)
964 return CCP_MemberDeclaration;
967 // Content-based decisions.
968 if (isa<EnumConstantDecl>(ND))
971 // Use CCP_Type for type declarations unless we're in a statement, Objective-C
972 // message receiver, or parenthesized expression context. There, it's as
973 // likely that the user will want to write a type as other declarations.
974 if ((isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) &&
975 !(CompletionContext.getKind() == CodeCompletionContext::CCC_Statement ||
976 CompletionContext.getKind() ==
977 CodeCompletionContext::CCC_ObjCMessageReceiver ||
978 CompletionContext.getKind() ==
979 CodeCompletionContext::CCC_ParenthesizedExpression))
982 return CCP_Declaration;
985 void ResultBuilder::AdjustResultPriorityForDecl(Result &R) {
986 // If this is an Objective-C method declaration whose selector matches our
987 // preferred selector, give it a priority boost.
988 if (!PreferredSelector.isNull())
989 if (const auto *Method = dyn_cast<ObjCMethodDecl>(R.Declaration))
990 if (PreferredSelector == Method->getSelector())
991 R.Priority += CCD_SelectorMatch;
993 // If we have a preferred type, adjust the priority for results with exactly-
994 // matching or nearly-matching types.
995 if (!PreferredType.isNull()) {
996 QualType T = getDeclUsageType(SemaRef.Context, R.Declaration);
998 CanQualType TC = SemaRef.Context.getCanonicalType(T);
999 // Check for exactly-matching types (modulo qualifiers).
1000 if (SemaRef.Context.hasSameUnqualifiedType(PreferredType, TC))
1001 R.Priority /= CCF_ExactTypeMatch;
1002 // Check for nearly-matching types, based on classification of each.
1003 else if ((getSimplifiedTypeClass(PreferredType) ==
1004 getSimplifiedTypeClass(TC)) &&
1005 !(PreferredType->isEnumeralType() && TC->isEnumeralType()))
1006 R.Priority /= CCF_SimilarTypeMatch;
1011 static DeclContext::lookup_result getConstructors(ASTContext &Context,
1012 const CXXRecordDecl *Record) {
1013 QualType RecordTy = Context.getTypeDeclType(Record);
1014 DeclarationName ConstructorName =
1015 Context.DeclarationNames.getCXXConstructorName(
1016 Context.getCanonicalType(RecordTy));
1017 return Record->lookup(ConstructorName);
1020 void ResultBuilder::MaybeAddConstructorResults(Result R) {
1021 if (!SemaRef.getLangOpts().CPlusPlus || !R.Declaration ||
1022 !CompletionContext.wantConstructorResults())
1025 const NamedDecl *D = R.Declaration;
1026 const CXXRecordDecl *Record = nullptr;
1027 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D))
1028 Record = ClassTemplate->getTemplatedDecl();
1029 else if ((Record = dyn_cast<CXXRecordDecl>(D))) {
1030 // Skip specializations and partial specializations.
1031 if (isa<ClassTemplateSpecializationDecl>(Record))
1034 // There are no constructors here.
1038 Record = Record->getDefinition();
1042 for (NamedDecl *Ctor : getConstructors(SemaRef.Context, Record)) {
1043 R.Declaration = Ctor;
1044 R.CursorKind = getCursorKindForDecl(R.Declaration);
1045 Results.push_back(R);
1049 static bool isConstructor(const Decl *ND) {
1050 if (const auto *Tmpl = dyn_cast<FunctionTemplateDecl>(ND))
1051 ND = Tmpl->getTemplatedDecl();
1052 return isa<CXXConstructorDecl>(ND);
1055 void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) {
1056 assert(!ShadowMaps.empty() && "Must enter into a results scope");
1058 if (R.Kind != Result::RK_Declaration) {
1059 // For non-declaration results, just add the result.
1060 Results.push_back(R);
1064 // Look through using declarations.
1065 if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
1066 CodeCompletionResult Result(Using->getTargetDecl(),
1067 getBasePriority(Using->getTargetDecl()),
1069 Result.ShadowDecl = Using;
1070 MaybeAddResult(Result, CurContext);
1074 const Decl *CanonDecl = R.Declaration->getCanonicalDecl();
1075 unsigned IDNS = CanonDecl->getIdentifierNamespace();
1077 bool AsNestedNameSpecifier = false;
1078 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
1081 // C++ constructors are never found by name lookup.
1082 if (isConstructor(R.Declaration))
1085 ShadowMap &SMap = ShadowMaps.back();
1086 ShadowMapEntry::iterator I, IEnd;
1087 ShadowMap::iterator NamePos = SMap.find(R.Declaration->getDeclName());
1088 if (NamePos != SMap.end()) {
1089 I = NamePos->second.begin();
1090 IEnd = NamePos->second.end();
1093 for (; I != IEnd; ++I) {
1094 const NamedDecl *ND = I->first;
1095 unsigned Index = I->second;
1096 if (ND->getCanonicalDecl() == CanonDecl) {
1097 // This is a redeclaration. Always pick the newer declaration.
1098 Results[Index].Declaration = R.Declaration;
1105 // This is a new declaration in this scope. However, check whether this
1106 // declaration name is hidden by a similarly-named declaration in an outer
1108 std::list<ShadowMap>::iterator SM, SMEnd = ShadowMaps.end();
1110 for (SM = ShadowMaps.begin(); SM != SMEnd; ++SM) {
1111 ShadowMapEntry::iterator I, IEnd;
1112 ShadowMap::iterator NamePos = SM->find(R.Declaration->getDeclName());
1113 if (NamePos != SM->end()) {
1114 I = NamePos->second.begin();
1115 IEnd = NamePos->second.end();
1117 for (; I != IEnd; ++I) {
1118 // A tag declaration does not hide a non-tag declaration.
1119 if (I->first->hasTagIdentifierNamespace() &&
1120 (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary |
1121 Decl::IDNS_LocalExtern | Decl::IDNS_ObjCProtocol)))
1124 // Protocols are in distinct namespaces from everything else.
1125 if (((I->first->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol) ||
1126 (IDNS & Decl::IDNS_ObjCProtocol)) &&
1127 I->first->getIdentifierNamespace() != IDNS)
1130 // The newly-added result is hidden by an entry in the shadow map.
1131 if (CheckHiddenResult(R, CurContext, I->first))
1138 // Make sure that any given declaration only shows up in the result set once.
1139 if (!AllDeclsFound.insert(CanonDecl).second)
1142 // If the filter is for nested-name-specifiers, then this result starts a
1143 // nested-name-specifier.
1144 if (AsNestedNameSpecifier) {
1145 R.StartsNestedNameSpecifier = true;
1146 R.Priority = CCP_NestedNameSpecifier;
1148 AdjustResultPriorityForDecl(R);
1150 // If this result is supposed to have an informative qualifier, add one.
1151 if (R.QualifierIsInformative && !R.Qualifier &&
1152 !R.StartsNestedNameSpecifier) {
1153 const DeclContext *Ctx = R.Declaration->getDeclContext();
1154 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
1156 NestedNameSpecifier::Create(SemaRef.Context, nullptr, Namespace);
1157 else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
1158 R.Qualifier = NestedNameSpecifier::Create(
1159 SemaRef.Context, nullptr, false,
1160 SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
1162 R.QualifierIsInformative = false;
1165 // Insert this result into the set of results and into the current shadow
1167 SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size());
1168 Results.push_back(R);
1170 if (!AsNestedNameSpecifier)
1171 MaybeAddConstructorResults(R);
1174 static void setInBaseClass(ResultBuilder::Result &R) {
1175 R.Priority += CCD_InBaseClass;
1176 R.InBaseClass = true;
1179 enum class OverloadCompare { BothViable, Dominates, Dominated };
1180 // Will Candidate ever be called on the object, when overloaded with Incumbent?
1181 // Returns Dominates if Candidate is always called, Dominated if Incumbent is
1182 // always called, BothViable if either may be called dependending on arguments.
1183 // Precondition: must actually be overloads!
1184 static OverloadCompare compareOverloads(const CXXMethodDecl &Candidate,
1185 const CXXMethodDecl &Incumbent,
1186 const Qualifiers &ObjectQuals,
1187 ExprValueKind ObjectKind) {
1188 if (Candidate.isVariadic() != Incumbent.isVariadic() ||
1189 Candidate.getNumParams() != Incumbent.getNumParams() ||
1190 Candidate.getMinRequiredArguments() !=
1191 Incumbent.getMinRequiredArguments())
1192 return OverloadCompare::BothViable;
1193 for (unsigned I = 0, E = Candidate.getNumParams(); I != E; ++I)
1194 if (Candidate.parameters()[I]->getType().getCanonicalType() !=
1195 Incumbent.parameters()[I]->getType().getCanonicalType())
1196 return OverloadCompare::BothViable;
1197 if (!llvm::empty(Candidate.specific_attrs<EnableIfAttr>()) ||
1198 !llvm::empty(Incumbent.specific_attrs<EnableIfAttr>()))
1199 return OverloadCompare::BothViable;
1200 // At this point, we know calls can't pick one or the other based on
1201 // arguments, so one of the two must win. (Or both fail, handled elsewhere).
1202 RefQualifierKind CandidateRef = Candidate.getRefQualifier();
1203 RefQualifierKind IncumbentRef = Incumbent.getRefQualifier();
1204 if (CandidateRef != IncumbentRef) {
1205 // If the object kind is LValue/RValue, there's one acceptable ref-qualifier
1206 // and it can't be mixed with ref-unqualified overloads (in valid code).
1208 // For xvalue objects, we prefer the rvalue overload even if we have to
1209 // add qualifiers (which is rare, because const&& is rare).
1210 if (ObjectKind == clang::VK_XValue)
1211 return CandidateRef == RQ_RValue ? OverloadCompare::Dominates
1212 : OverloadCompare::Dominated;
1214 // Now the ref qualifiers are the same (or we're in some invalid state).
1215 // So make some decision based on the qualifiers.
1216 Qualifiers CandidateQual = Candidate.getMethodQualifiers();
1217 Qualifiers IncumbentQual = Incumbent.getMethodQualifiers();
1218 bool CandidateSuperset = CandidateQual.compatiblyIncludes(IncumbentQual);
1219 bool IncumbentSuperset = IncumbentQual.compatiblyIncludes(CandidateQual);
1220 if (CandidateSuperset == IncumbentSuperset)
1221 return OverloadCompare::BothViable;
1222 return IncumbentSuperset ? OverloadCompare::Dominates
1223 : OverloadCompare::Dominated;
1226 void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
1227 NamedDecl *Hiding, bool InBaseClass = false) {
1228 if (R.Kind != Result::RK_Declaration) {
1229 // For non-declaration results, just add the result.
1230 Results.push_back(R);
1234 // Look through using declarations.
1235 if (const auto *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
1236 CodeCompletionResult Result(Using->getTargetDecl(),
1237 getBasePriority(Using->getTargetDecl()),
1239 Result.ShadowDecl = Using;
1240 AddResult(Result, CurContext, Hiding);
1244 bool AsNestedNameSpecifier = false;
1245 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
1248 // C++ constructors are never found by name lookup.
1249 if (isConstructor(R.Declaration))
1252 if (Hiding && CheckHiddenResult(R, CurContext, Hiding))
1255 // Make sure that any given declaration only shows up in the result set once.
1256 if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl()).second)
1259 // If the filter is for nested-name-specifiers, then this result starts a
1260 // nested-name-specifier.
1261 if (AsNestedNameSpecifier) {
1262 R.StartsNestedNameSpecifier = true;
1263 R.Priority = CCP_NestedNameSpecifier;
1264 } else if (Filter == &ResultBuilder::IsMember && !R.Qualifier &&
1267 R.Declaration->getDeclContext()->getRedeclContext()))
1268 R.QualifierIsInformative = true;
1270 // If this result is supposed to have an informative qualifier, add one.
1271 if (R.QualifierIsInformative && !R.Qualifier &&
1272 !R.StartsNestedNameSpecifier) {
1273 const DeclContext *Ctx = R.Declaration->getDeclContext();
1274 if (const auto *Namespace = dyn_cast<NamespaceDecl>(Ctx))
1276 NestedNameSpecifier::Create(SemaRef.Context, nullptr, Namespace);
1277 else if (const auto *Tag = dyn_cast<TagDecl>(Ctx))
1278 R.Qualifier = NestedNameSpecifier::Create(
1279 SemaRef.Context, nullptr, false,
1280 SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
1282 R.QualifierIsInformative = false;
1285 // Adjust the priority if this result comes from a base class.
1289 AdjustResultPriorityForDecl(R);
1291 if (HasObjectTypeQualifiers)
1292 if (const auto *Method = dyn_cast<CXXMethodDecl>(R.Declaration))
1293 if (Method->isInstance()) {
1294 Qualifiers MethodQuals = Method->getMethodQualifiers();
1295 if (ObjectTypeQualifiers == MethodQuals)
1296 R.Priority += CCD_ObjectQualifierMatch;
1297 else if (ObjectTypeQualifiers - MethodQuals) {
1298 // The method cannot be invoked, because doing so would drop
1302 // Detect cases where a ref-qualified method cannot be invoked.
1303 switch (Method->getRefQualifier()) {
1305 if (ObjectKind != VK_LValue && !MethodQuals.hasConst())
1309 if (ObjectKind == VK_LValue)
1316 /// Check whether this dominates another overloaded method, which should
1317 /// be suppressed (or vice versa).
1318 /// Motivating case is const_iterator begin() const vs iterator begin().
1319 auto &OverloadSet = OverloadMap[std::make_pair(
1320 CurContext, Method->getDeclName().getAsOpaqueInteger())];
1321 for (const DeclIndexPair& Entry : OverloadSet) {
1322 Result &Incumbent = Results[Entry.second];
1323 switch (compareOverloads(*Method,
1324 *cast<CXXMethodDecl>(Incumbent.Declaration),
1325 ObjectTypeQualifiers, ObjectKind)) {
1326 case OverloadCompare::Dominates:
1327 // Replace the dominated overload with this one.
1328 // FIXME: if the overload dominates multiple incumbents then we
1329 // should remove all. But two overloads is by far the common case.
1330 Incumbent = std::move(R);
1332 case OverloadCompare::Dominated:
1333 // This overload can't be called, drop it.
1335 case OverloadCompare::BothViable:
1339 OverloadSet.Add(Method, Results.size());
1342 // Insert this result into the set of results.
1343 Results.push_back(R);
1345 if (!AsNestedNameSpecifier)
1346 MaybeAddConstructorResults(R);
1349 void ResultBuilder::AddResult(Result R) {
1350 assert(R.Kind != Result::RK_Declaration &&
1351 "Declaration results need more context");
1352 Results.push_back(R);
1355 /// Enter into a new scope.
1356 void ResultBuilder::EnterNewScope() { ShadowMaps.emplace_back(); }
1358 /// Exit from the current scope.
1359 void ResultBuilder::ExitScope() {
1360 ShadowMaps.pop_back();
1363 /// Determines whether this given declaration will be found by
1364 /// ordinary name lookup.
1365 bool ResultBuilder::IsOrdinaryName(const NamedDecl *ND) const {
1366 ND = ND->getUnderlyingDecl();
1368 // If name lookup finds a local extern declaration, then we are in a
1369 // context where it behaves like an ordinary name.
1370 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1371 if (SemaRef.getLangOpts().CPlusPlus)
1372 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
1373 else if (SemaRef.getLangOpts().ObjC) {
1374 if (isa<ObjCIvarDecl>(ND))
1378 return ND->getIdentifierNamespace() & IDNS;
1381 /// Determines whether this given declaration will be found by
1382 /// ordinary name lookup but is not a type name.
1383 bool ResultBuilder::IsOrdinaryNonTypeName(const NamedDecl *ND) const {
1384 ND = ND->getUnderlyingDecl();
1385 if (isa<TypeDecl>(ND))
1387 // Objective-C interfaces names are not filtered by this method because they
1388 // can be used in a class property expression. We can still filter out
1389 // @class declarations though.
1390 if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND)) {
1391 if (!ID->getDefinition())
1395 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1396 if (SemaRef.getLangOpts().CPlusPlus)
1397 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
1398 else if (SemaRef.getLangOpts().ObjC) {
1399 if (isa<ObjCIvarDecl>(ND))
1403 return ND->getIdentifierNamespace() & IDNS;
1406 bool ResultBuilder::IsIntegralConstantValue(const NamedDecl *ND) const {
1407 if (!IsOrdinaryNonTypeName(ND))
1410 if (const auto *VD = dyn_cast<ValueDecl>(ND->getUnderlyingDecl()))
1411 if (VD->getType()->isIntegralOrEnumerationType())
1417 /// Determines whether this given declaration will be found by
1418 /// ordinary name lookup.
1419 bool ResultBuilder::IsOrdinaryNonValueName(const NamedDecl *ND) const {
1420 ND = ND->getUnderlyingDecl();
1422 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1423 if (SemaRef.getLangOpts().CPlusPlus)
1424 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace;
1426 return (ND->getIdentifierNamespace() & IDNS) && !isa<ValueDecl>(ND) &&
1427 !isa<FunctionTemplateDecl>(ND) && !isa<ObjCPropertyDecl>(ND);
1430 /// Determines whether the given declaration is suitable as the
1431 /// start of a C++ nested-name-specifier, e.g., a class or namespace.
1432 bool ResultBuilder::IsNestedNameSpecifier(const NamedDecl *ND) const {
1433 // Allow us to find class templates, too.
1434 if (const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1435 ND = ClassTemplate->getTemplatedDecl();
1437 return SemaRef.isAcceptableNestedNameSpecifier(ND);
1440 /// Determines whether the given declaration is an enumeration.
1441 bool ResultBuilder::IsEnum(const NamedDecl *ND) const {
1442 return isa<EnumDecl>(ND);
1445 /// Determines whether the given declaration is a class or struct.
1446 bool ResultBuilder::IsClassOrStruct(const NamedDecl *ND) const {
1447 // Allow us to find class templates, too.
1448 if (const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1449 ND = ClassTemplate->getTemplatedDecl();
1451 // For purposes of this check, interfaces match too.
1452 if (const auto *RD = dyn_cast<RecordDecl>(ND))
1453 return RD->getTagKind() == TTK_Class || RD->getTagKind() == TTK_Struct ||
1454 RD->getTagKind() == TTK_Interface;
1459 /// Determines whether the given declaration is a union.
1460 bool ResultBuilder::IsUnion(const NamedDecl *ND) const {
1461 // Allow us to find class templates, too.
1462 if (const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1463 ND = ClassTemplate->getTemplatedDecl();
1465 if (const auto *RD = dyn_cast<RecordDecl>(ND))
1466 return RD->getTagKind() == TTK_Union;
1471 /// Determines whether the given declaration is a namespace.
1472 bool ResultBuilder::IsNamespace(const NamedDecl *ND) const {
1473 return isa<NamespaceDecl>(ND);
1476 /// Determines whether the given declaration is a namespace or
1477 /// namespace alias.
1478 bool ResultBuilder::IsNamespaceOrAlias(const NamedDecl *ND) const {
1479 return isa<NamespaceDecl>(ND->getUnderlyingDecl());
1482 /// Determines whether the given declaration is a type.
1483 bool ResultBuilder::IsType(const NamedDecl *ND) const {
1484 ND = ND->getUnderlyingDecl();
1485 return isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
1488 /// Determines which members of a class should be visible via
1489 /// "." or "->". Only value declarations, nested name specifiers, and
1490 /// using declarations thereof should show up.
1491 bool ResultBuilder::IsMember(const NamedDecl *ND) const {
1492 ND = ND->getUnderlyingDecl();
1493 return isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND) ||
1494 isa<ObjCPropertyDecl>(ND);
1497 static bool isObjCReceiverType(ASTContext &C, QualType T) {
1498 T = C.getCanonicalType(T);
1499 switch (T->getTypeClass()) {
1500 case Type::ObjCObject:
1501 case Type::ObjCInterface:
1502 case Type::ObjCObjectPointer:
1506 switch (cast<BuiltinType>(T)->getKind()) {
1507 case BuiltinType::ObjCId:
1508 case BuiltinType::ObjCClass:
1509 case BuiltinType::ObjCSel:
1521 if (!C.getLangOpts().CPlusPlus)
1524 // FIXME: We could perform more analysis here to determine whether a
1525 // particular class type has any conversions to Objective-C types. For now,
1526 // just accept all class types.
1527 return T->isDependentType() || T->isRecordType();
1530 bool ResultBuilder::IsObjCMessageReceiver(const NamedDecl *ND) const {
1531 QualType T = getDeclUsageType(SemaRef.Context, ND);
1535 T = SemaRef.Context.getBaseElementType(T);
1536 return isObjCReceiverType(SemaRef.Context, T);
1539 bool ResultBuilder::IsObjCMessageReceiverOrLambdaCapture(
1540 const NamedDecl *ND) const {
1541 if (IsObjCMessageReceiver(ND))
1544 const auto *Var = dyn_cast<VarDecl>(ND);
1548 return Var->hasLocalStorage() && !Var->hasAttr<BlocksAttr>();
1551 bool ResultBuilder::IsObjCCollection(const NamedDecl *ND) const {
1552 if ((SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryName(ND)) ||
1553 (!SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryNonTypeName(ND)))
1556 QualType T = getDeclUsageType(SemaRef.Context, ND);
1560 T = SemaRef.Context.getBaseElementType(T);
1561 return T->isObjCObjectType() || T->isObjCObjectPointerType() ||
1562 T->isObjCIdType() ||
1563 (SemaRef.getLangOpts().CPlusPlus && T->isRecordType());
1566 bool ResultBuilder::IsImpossibleToSatisfy(const NamedDecl *ND) const {
1570 /// Determines whether the given declaration is an Objective-C
1571 /// instance variable.
1572 bool ResultBuilder::IsObjCIvar(const NamedDecl *ND) const {
1573 return isa<ObjCIvarDecl>(ND);
1578 /// Visible declaration consumer that adds a code-completion result
1579 /// for each visible declaration.
1580 class CodeCompletionDeclConsumer : public VisibleDeclConsumer {
1581 ResultBuilder &Results;
1582 DeclContext *InitialLookupCtx;
1583 // NamingClass and BaseType are used for access-checking. See
1584 // Sema::IsSimplyAccessible for details.
1585 CXXRecordDecl *NamingClass;
1587 std::vector<FixItHint> FixIts;
1590 CodeCompletionDeclConsumer(
1591 ResultBuilder &Results, DeclContext *InitialLookupCtx,
1592 QualType BaseType = QualType(),
1593 std::vector<FixItHint> FixIts = std::vector<FixItHint>())
1594 : Results(Results), InitialLookupCtx(InitialLookupCtx),
1595 FixIts(std::move(FixIts)) {
1596 NamingClass = llvm::dyn_cast<CXXRecordDecl>(InitialLookupCtx);
1597 // If BaseType was not provided explicitly, emulate implicit 'this->'.
1598 if (BaseType.isNull()) {
1599 auto ThisType = Results.getSema().getCurrentThisType();
1600 if (!ThisType.isNull()) {
1601 assert(ThisType->isPointerType());
1602 BaseType = ThisType->getPointeeType();
1604 NamingClass = BaseType->getAsCXXRecordDecl();
1607 this->BaseType = BaseType;
1610 void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,
1611 bool InBaseClass) override {
1612 ResultBuilder::Result Result(ND, Results.getBasePriority(ND), nullptr,
1613 false, IsAccessible(ND, Ctx), FixIts);
1614 Results.AddResult(Result, InitialLookupCtx, Hiding, InBaseClass);
1617 void EnteredContext(DeclContext *Ctx) override {
1618 Results.addVisitedContext(Ctx);
1622 bool IsAccessible(NamedDecl *ND, DeclContext *Ctx) {
1623 // Naming class to use for access check. In most cases it was provided
1624 // explicitly (e.g. member access (lhs.foo) or qualified lookup (X::)),
1625 // for unqualified lookup we fallback to the \p Ctx in which we found the
1627 auto *NamingClass = this->NamingClass;
1628 QualType BaseType = this->BaseType;
1629 if (auto *Cls = llvm::dyn_cast_or_null<CXXRecordDecl>(Ctx)) {
1632 // When we emulate implicit 'this->' in an unqualified lookup, we might
1633 // end up with an invalid naming class. In that case, we avoid emulating
1634 // 'this->' qualifier to satisfy preconditions of the access checking.
1635 if (NamingClass->getCanonicalDecl() != Cls->getCanonicalDecl() &&
1636 !NamingClass->isDerivedFrom(Cls)) {
1638 BaseType = QualType();
1641 // The decl was found outside the C++ class, so only ObjC access checks
1642 // apply. Those do not rely on NamingClass and BaseType, so we clear them
1644 NamingClass = nullptr;
1645 BaseType = QualType();
1647 return Results.getSema().IsSimplyAccessible(ND, NamingClass, BaseType);
1652 /// Add type specifiers for the current language as keyword results.
1653 static void AddTypeSpecifierResults(const LangOptions &LangOpts,
1654 ResultBuilder &Results) {
1655 typedef CodeCompletionResult Result;
1656 Results.AddResult(Result("short", CCP_Type));
1657 Results.AddResult(Result("long", CCP_Type));
1658 Results.AddResult(Result("signed", CCP_Type));
1659 Results.AddResult(Result("unsigned", CCP_Type));
1660 Results.AddResult(Result("void", CCP_Type));
1661 Results.AddResult(Result("char", CCP_Type));
1662 Results.AddResult(Result("int", CCP_Type));
1663 Results.AddResult(Result("float", CCP_Type));
1664 Results.AddResult(Result("double", CCP_Type));
1665 Results.AddResult(Result("enum", CCP_Type));
1666 Results.AddResult(Result("struct", CCP_Type));
1667 Results.AddResult(Result("union", CCP_Type));
1668 Results.AddResult(Result("const", CCP_Type));
1669 Results.AddResult(Result("volatile", CCP_Type));
1673 Results.AddResult(Result("_Complex", CCP_Type));
1674 Results.AddResult(Result("_Imaginary", CCP_Type));
1675 Results.AddResult(Result("_Bool", CCP_Type));
1676 Results.AddResult(Result("restrict", CCP_Type));
1679 CodeCompletionBuilder Builder(Results.getAllocator(),
1680 Results.getCodeCompletionTUInfo());
1681 if (LangOpts.CPlusPlus) {
1684 Result("bool", CCP_Type + (LangOpts.ObjC ? CCD_bool_in_ObjC : 0)));
1685 Results.AddResult(Result("class", CCP_Type));
1686 Results.AddResult(Result("wchar_t", CCP_Type));
1688 // typename qualified-id
1689 Builder.AddTypedTextChunk("typename");
1690 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1691 Builder.AddPlaceholderChunk("qualifier");
1692 Builder.AddTextChunk("::");
1693 Builder.AddPlaceholderChunk("name");
1694 Results.AddResult(Result(Builder.TakeString()));
1696 if (LangOpts.CPlusPlus11) {
1697 Results.AddResult(Result("auto", CCP_Type));
1698 Results.AddResult(Result("char16_t", CCP_Type));
1699 Results.AddResult(Result("char32_t", CCP_Type));
1701 Builder.AddTypedTextChunk("decltype");
1702 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1703 Builder.AddPlaceholderChunk("expression");
1704 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1705 Results.AddResult(Result(Builder.TakeString()));
1708 Results.AddResult(Result("__auto_type", CCP_Type));
1711 if (LangOpts.GNUKeywords) {
1712 // FIXME: Enable when we actually support decimal floating point.
1713 // Results.AddResult(Result("_Decimal32"));
1714 // Results.AddResult(Result("_Decimal64"));
1715 // Results.AddResult(Result("_Decimal128"));
1717 Builder.AddTypedTextChunk("typeof");
1718 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1719 Builder.AddPlaceholderChunk("expression");
1720 Results.AddResult(Result(Builder.TakeString()));
1722 Builder.AddTypedTextChunk("typeof");
1723 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1724 Builder.AddPlaceholderChunk("type");
1725 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1726 Results.AddResult(Result(Builder.TakeString()));
1730 Results.AddResult(Result("_Nonnull", CCP_Type));
1731 Results.AddResult(Result("_Null_unspecified", CCP_Type));
1732 Results.AddResult(Result("_Nullable", CCP_Type));
1735 static void AddStorageSpecifiers(Sema::ParserCompletionContext CCC,
1736 const LangOptions &LangOpts,
1737 ResultBuilder &Results) {
1738 typedef CodeCompletionResult Result;
1739 // Note: we don't suggest either "auto" or "register", because both
1740 // are pointless as storage specifiers. Elsewhere, we suggest "auto"
1741 // in C++0x as a type specifier.
1742 Results.AddResult(Result("extern"));
1743 Results.AddResult(Result("static"));
1745 if (LangOpts.CPlusPlus11) {
1746 CodeCompletionAllocator &Allocator = Results.getAllocator();
1747 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1750 Builder.AddTypedTextChunk("alignas");
1751 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1752 Builder.AddPlaceholderChunk("expression");
1753 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1754 Results.AddResult(Result(Builder.TakeString()));
1756 Results.AddResult(Result("constexpr"));
1757 Results.AddResult(Result("thread_local"));
1761 static void AddFunctionSpecifiers(Sema::ParserCompletionContext CCC,
1762 const LangOptions &LangOpts,
1763 ResultBuilder &Results) {
1764 typedef CodeCompletionResult Result;
1766 case Sema::PCC_Class:
1767 case Sema::PCC_MemberTemplate:
1768 if (LangOpts.CPlusPlus) {
1769 Results.AddResult(Result("explicit"));
1770 Results.AddResult(Result("friend"));
1771 Results.AddResult(Result("mutable"));
1772 Results.AddResult(Result("virtual"));
1776 case Sema::PCC_ObjCInterface:
1777 case Sema::PCC_ObjCImplementation:
1778 case Sema::PCC_Namespace:
1779 case Sema::PCC_Template:
1780 if (LangOpts.CPlusPlus || LangOpts.C99)
1781 Results.AddResult(Result("inline"));
1784 case Sema::PCC_ObjCInstanceVariableList:
1785 case Sema::PCC_Expression:
1786 case Sema::PCC_Statement:
1787 case Sema::PCC_ForInit:
1788 case Sema::PCC_Condition:
1789 case Sema::PCC_RecoveryInFunction:
1790 case Sema::PCC_Type:
1791 case Sema::PCC_ParenthesizedExpression:
1792 case Sema::PCC_LocalDeclarationSpecifiers:
1797 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt);
1798 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt);
1799 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
1800 ResultBuilder &Results, bool NeedAt);
1801 static void AddObjCImplementationResults(const LangOptions &LangOpts,
1802 ResultBuilder &Results, bool NeedAt);
1803 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
1804 ResultBuilder &Results, bool NeedAt);
1805 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt);
1807 static void AddTypedefResult(ResultBuilder &Results) {
1808 CodeCompletionBuilder Builder(Results.getAllocator(),
1809 Results.getCodeCompletionTUInfo());
1810 Builder.AddTypedTextChunk("typedef");
1811 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1812 Builder.AddPlaceholderChunk("type");
1813 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1814 Builder.AddPlaceholderChunk("name");
1815 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1816 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1819 static bool WantTypesInContext(Sema::ParserCompletionContext CCC,
1820 const LangOptions &LangOpts) {
1822 case Sema::PCC_Namespace:
1823 case Sema::PCC_Class:
1824 case Sema::PCC_ObjCInstanceVariableList:
1825 case Sema::PCC_Template:
1826 case Sema::PCC_MemberTemplate:
1827 case Sema::PCC_Statement:
1828 case Sema::PCC_RecoveryInFunction:
1829 case Sema::PCC_Type:
1830 case Sema::PCC_ParenthesizedExpression:
1831 case Sema::PCC_LocalDeclarationSpecifiers:
1834 case Sema::PCC_Expression:
1835 case Sema::PCC_Condition:
1836 return LangOpts.CPlusPlus;
1838 case Sema::PCC_ObjCInterface:
1839 case Sema::PCC_ObjCImplementation:
1842 case Sema::PCC_ForInit:
1843 return LangOpts.CPlusPlus || LangOpts.ObjC || LangOpts.C99;
1846 llvm_unreachable("Invalid ParserCompletionContext!");
1849 static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context,
1850 const Preprocessor &PP) {
1851 PrintingPolicy Policy = Sema::getPrintingPolicy(Context, PP);
1852 Policy.AnonymousTagLocations = false;
1853 Policy.SuppressStrongLifetime = true;
1854 Policy.SuppressUnwrittenScope = true;
1855 Policy.SuppressScope = true;
1859 /// Retrieve a printing policy suitable for code completion.
1860 static PrintingPolicy getCompletionPrintingPolicy(Sema &S) {
1861 return getCompletionPrintingPolicy(S.Context, S.PP);
1864 /// Retrieve the string representation of the given type as a string
1865 /// that has the appropriate lifetime for code completion.
1867 /// This routine provides a fast path where we provide constant strings for
1868 /// common type names.
1869 static const char *GetCompletionTypeString(QualType T, ASTContext &Context,
1870 const PrintingPolicy &Policy,
1871 CodeCompletionAllocator &Allocator) {
1872 if (!T.getLocalQualifiers()) {
1873 // Built-in type names are constant strings.
1874 if (const BuiltinType *BT = dyn_cast<BuiltinType>(T))
1875 return BT->getNameAsCString(Policy);
1877 // Anonymous tag types are constant strings.
1878 if (const TagType *TagT = dyn_cast<TagType>(T))
1879 if (TagDecl *Tag = TagT->getDecl())
1880 if (!Tag->hasNameForLinkage()) {
1881 switch (Tag->getTagKind()) {
1883 return "struct <anonymous>";
1885 return "__interface <anonymous>";
1887 return "class <anonymous>";
1889 return "union <anonymous>";
1891 return "enum <anonymous>";
1896 // Slow path: format the type as a string.
1898 T.getAsStringInternal(Result, Policy);
1899 return Allocator.CopyString(Result);
1902 /// Add a completion for "this", if we're in a member function.
1903 static void addThisCompletion(Sema &S, ResultBuilder &Results) {
1904 QualType ThisTy = S.getCurrentThisType();
1905 if (ThisTy.isNull())
1908 CodeCompletionAllocator &Allocator = Results.getAllocator();
1909 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1910 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
1911 Builder.AddResultTypeChunk(
1912 GetCompletionTypeString(ThisTy, S.Context, Policy, Allocator));
1913 Builder.AddTypedTextChunk("this");
1914 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1917 static void AddStaticAssertResult(CodeCompletionBuilder &Builder,
1918 ResultBuilder &Results,
1919 const LangOptions &LangOpts) {
1920 if (!LangOpts.CPlusPlus11)
1923 Builder.AddTypedTextChunk("static_assert");
1924 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1925 Builder.AddPlaceholderChunk("expression");
1926 Builder.AddChunk(CodeCompletionString::CK_Comma);
1927 Builder.AddPlaceholderChunk("message");
1928 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1929 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1930 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1933 static void AddOverrideResults(ResultBuilder &Results,
1934 const CodeCompletionContext &CCContext,
1935 CodeCompletionBuilder &Builder) {
1936 Sema &S = Results.getSema();
1937 const auto *CR = llvm::dyn_cast<CXXRecordDecl>(S.CurContext);
1938 // If not inside a class/struct/union return empty.
1941 // First store overrides within current class.
1942 // These are stored by name to make querying fast in the later step.
1943 llvm::StringMap<std::vector<FunctionDecl *>> Overrides;
1944 for (auto *Method : CR->methods()) {
1945 if (!Method->isVirtual() || !Method->getIdentifier())
1947 Overrides[Method->getName()].push_back(Method);
1950 for (const auto &Base : CR->bases()) {
1951 const auto *BR = Base.getType().getTypePtr()->getAsCXXRecordDecl();
1954 for (auto *Method : BR->methods()) {
1955 if (!Method->isVirtual() || !Method->getIdentifier())
1957 const auto it = Overrides.find(Method->getName());
1958 bool IsOverriden = false;
1959 if (it != Overrides.end()) {
1960 for (auto *MD : it->second) {
1961 // If the method in current body is not an overload of this virtual
1962 // function, then it overrides this one.
1963 if (!S.IsOverload(MD, Method, false)) {
1970 // Generates a new CodeCompletionResult by taking this function and
1971 // converting it into an override declaration with only one chunk in the
1972 // final CodeCompletionString as a TypedTextChunk.
1973 std::string OverrideSignature;
1974 llvm::raw_string_ostream OS(OverrideSignature);
1975 CodeCompletionResult CCR(Method, 0);
1976 PrintingPolicy Policy =
1977 getCompletionPrintingPolicy(S.getASTContext(), S.getPreprocessor());
1978 auto *CCS = CCR.createCodeCompletionStringForOverride(
1979 S.getPreprocessor(), S.getASTContext(), Builder,
1980 /*IncludeBriefComments=*/false, CCContext, Policy);
1981 Results.AddResult(CodeCompletionResult(CCS, Method, CCP_CodePattern));
1987 /// Add language constructs that show up for "ordinary" names.
1988 static void AddOrdinaryNameResults(Sema::ParserCompletionContext CCC, Scope *S,
1989 Sema &SemaRef, ResultBuilder &Results) {
1990 CodeCompletionAllocator &Allocator = Results.getAllocator();
1991 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1993 typedef CodeCompletionResult Result;
1995 case Sema::PCC_Namespace:
1996 if (SemaRef.getLangOpts().CPlusPlus) {
1997 if (Results.includeCodePatterns()) {
1998 // namespace <identifier> { declarations }
1999 Builder.AddTypedTextChunk("namespace");
2000 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2001 Builder.AddPlaceholderChunk("identifier");
2002 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2003 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2004 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2005 Builder.AddPlaceholderChunk("declarations");
2006 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2007 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2008 Results.AddResult(Result(Builder.TakeString()));
2011 // namespace identifier = identifier ;
2012 Builder.AddTypedTextChunk("namespace");
2013 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2014 Builder.AddPlaceholderChunk("name");
2015 Builder.AddChunk(CodeCompletionString::CK_Equal);
2016 Builder.AddPlaceholderChunk("namespace");
2017 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2018 Results.AddResult(Result(Builder.TakeString()));
2021 Builder.AddTypedTextChunk("using namespace");
2022 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2023 Builder.AddPlaceholderChunk("identifier");
2024 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2025 Results.AddResult(Result(Builder.TakeString()));
2027 // asm(string-literal)
2028 Builder.AddTypedTextChunk("asm");
2029 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2030 Builder.AddPlaceholderChunk("string-literal");
2031 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2032 Results.AddResult(Result(Builder.TakeString()));
2034 if (Results.includeCodePatterns()) {
2035 // Explicit template instantiation
2036 Builder.AddTypedTextChunk("template");
2037 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2038 Builder.AddPlaceholderChunk("declaration");
2039 Results.AddResult(Result(Builder.TakeString()));
2041 Results.AddResult(Result("template", CodeCompletionResult::RK_Keyword));
2045 if (SemaRef.getLangOpts().ObjC)
2046 AddObjCTopLevelResults(Results, true);
2048 AddTypedefResult(Results);
2051 case Sema::PCC_Class:
2052 if (SemaRef.getLangOpts().CPlusPlus) {
2053 // Using declaration
2054 Builder.AddTypedTextChunk("using");
2055 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2056 Builder.AddPlaceholderChunk("qualifier");
2057 Builder.AddTextChunk("::");
2058 Builder.AddPlaceholderChunk("name");
2059 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2060 Results.AddResult(Result(Builder.TakeString()));
2062 // using typename qualifier::name (only in a dependent context)
2063 if (SemaRef.CurContext->isDependentContext()) {
2064 Builder.AddTypedTextChunk("using typename");
2065 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2066 Builder.AddPlaceholderChunk("qualifier");
2067 Builder.AddTextChunk("::");
2068 Builder.AddPlaceholderChunk("name");
2069 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2070 Results.AddResult(Result(Builder.TakeString()));
2073 AddStaticAssertResult(Builder, Results, SemaRef.getLangOpts());
2075 if (CCC == Sema::PCC_Class) {
2076 AddTypedefResult(Results);
2078 bool IsNotInheritanceScope =
2079 !(S->getFlags() & Scope::ClassInheritanceScope);
2081 Builder.AddTypedTextChunk("public");
2082 if (IsNotInheritanceScope && Results.includeCodePatterns())
2083 Builder.AddChunk(CodeCompletionString::CK_Colon);
2084 Results.AddResult(Result(Builder.TakeString()));
2087 Builder.AddTypedTextChunk("protected");
2088 if (IsNotInheritanceScope && Results.includeCodePatterns())
2089 Builder.AddChunk(CodeCompletionString::CK_Colon);
2090 Results.AddResult(Result(Builder.TakeString()));
2093 Builder.AddTypedTextChunk("private");
2094 if (IsNotInheritanceScope && Results.includeCodePatterns())
2095 Builder.AddChunk(CodeCompletionString::CK_Colon);
2096 Results.AddResult(Result(Builder.TakeString()));
2098 // FIXME: This adds override results only if we are at the first word of
2099 // the declaration/definition. Also call this from other sides to have
2101 AddOverrideResults(Results, CodeCompletionContext::CCC_ClassStructUnion,
2107 case Sema::PCC_Template:
2108 case Sema::PCC_MemberTemplate:
2109 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns()) {
2110 // template < parameters >
2111 Builder.AddTypedTextChunk("template");
2112 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
2113 Builder.AddPlaceholderChunk("parameters");
2114 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
2115 Results.AddResult(Result(Builder.TakeString()));
2117 Results.AddResult(Result("template", CodeCompletionResult::RK_Keyword));
2120 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2121 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2124 case Sema::PCC_ObjCInterface:
2125 AddObjCInterfaceResults(SemaRef.getLangOpts(), Results, true);
2126 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2127 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2130 case Sema::PCC_ObjCImplementation:
2131 AddObjCImplementationResults(SemaRef.getLangOpts(), Results, true);
2132 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2133 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2136 case Sema::PCC_ObjCInstanceVariableList:
2137 AddObjCVisibilityResults(SemaRef.getLangOpts(), Results, true);
2140 case Sema::PCC_RecoveryInFunction:
2141 case Sema::PCC_Statement: {
2142 AddTypedefResult(Results);
2144 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns() &&
2145 SemaRef.getLangOpts().CXXExceptions) {
2146 Builder.AddTypedTextChunk("try");
2147 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2148 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2149 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2150 Builder.AddPlaceholderChunk("statements");
2151 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2152 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2153 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2154 Builder.AddTextChunk("catch");
2155 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2156 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2157 Builder.AddPlaceholderChunk("declaration");
2158 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2159 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2160 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2161 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2162 Builder.AddPlaceholderChunk("statements");
2163 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2164 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2165 Results.AddResult(Result(Builder.TakeString()));
2167 if (SemaRef.getLangOpts().ObjC)
2168 AddObjCStatementResults(Results, true);
2170 if (Results.includeCodePatterns()) {
2171 // if (condition) { statements }
2172 Builder.AddTypedTextChunk("if");
2173 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2174 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2175 if (SemaRef.getLangOpts().CPlusPlus)
2176 Builder.AddPlaceholderChunk("condition");
2178 Builder.AddPlaceholderChunk("expression");
2179 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2180 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2181 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2182 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2183 Builder.AddPlaceholderChunk("statements");
2184 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2185 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2186 Results.AddResult(Result(Builder.TakeString()));
2188 // switch (condition) { }
2189 Builder.AddTypedTextChunk("switch");
2190 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2191 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2192 if (SemaRef.getLangOpts().CPlusPlus)
2193 Builder.AddPlaceholderChunk("condition");
2195 Builder.AddPlaceholderChunk("expression");
2196 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2197 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2198 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2199 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2200 Builder.AddPlaceholderChunk("cases");
2201 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2202 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2203 Results.AddResult(Result(Builder.TakeString()));
2206 // Switch-specific statements.
2207 if (SemaRef.getCurFunction() &&
2208 !SemaRef.getCurFunction()->SwitchStack.empty()) {
2210 Builder.AddTypedTextChunk("case");
2211 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2212 Builder.AddPlaceholderChunk("expression");
2213 Builder.AddChunk(CodeCompletionString::CK_Colon);
2214 Results.AddResult(Result(Builder.TakeString()));
2217 Builder.AddTypedTextChunk("default");
2218 Builder.AddChunk(CodeCompletionString::CK_Colon);
2219 Results.AddResult(Result(Builder.TakeString()));
2222 if (Results.includeCodePatterns()) {
2223 /// while (condition) { statements }
2224 Builder.AddTypedTextChunk("while");
2225 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2226 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2227 if (SemaRef.getLangOpts().CPlusPlus)
2228 Builder.AddPlaceholderChunk("condition");
2230 Builder.AddPlaceholderChunk("expression");
2231 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2232 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2233 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2234 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2235 Builder.AddPlaceholderChunk("statements");
2236 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2237 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2238 Results.AddResult(Result(Builder.TakeString()));
2240 // do { statements } while ( expression );
2241 Builder.AddTypedTextChunk("do");
2242 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2243 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2244 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2245 Builder.AddPlaceholderChunk("statements");
2246 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2247 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2248 Builder.AddTextChunk("while");
2249 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2250 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2251 Builder.AddPlaceholderChunk("expression");
2252 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2253 Results.AddResult(Result(Builder.TakeString()));
2255 // for ( for-init-statement ; condition ; expression ) { statements }
2256 Builder.AddTypedTextChunk("for");
2257 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2258 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2259 if (SemaRef.getLangOpts().CPlusPlus || SemaRef.getLangOpts().C99)
2260 Builder.AddPlaceholderChunk("init-statement");
2262 Builder.AddPlaceholderChunk("init-expression");
2263 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2264 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2265 Builder.AddPlaceholderChunk("condition");
2266 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2267 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2268 Builder.AddPlaceholderChunk("inc-expression");
2269 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2270 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2271 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2272 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2273 Builder.AddPlaceholderChunk("statements");
2274 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2275 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2276 Results.AddResult(Result(Builder.TakeString()));
2279 if (S->getContinueParent()) {
2281 Builder.AddTypedTextChunk("continue");
2282 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2283 Results.AddResult(Result(Builder.TakeString()));
2286 if (S->getBreakParent()) {
2288 Builder.AddTypedTextChunk("break");
2289 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2290 Results.AddResult(Result(Builder.TakeString()));
2293 // "return expression ;" or "return ;", depending on the return type.
2294 QualType ReturnType;
2295 if (const auto *Function = dyn_cast<FunctionDecl>(SemaRef.CurContext))
2296 ReturnType = Function->getReturnType();
2297 else if (const auto *Method = dyn_cast<ObjCMethodDecl>(SemaRef.CurContext))
2298 ReturnType = Method->getReturnType();
2299 else if (SemaRef.getCurBlock() &&
2300 !SemaRef.getCurBlock()->ReturnType.isNull())
2301 ReturnType = SemaRef.getCurBlock()->ReturnType;;
2302 if (ReturnType.isNull() || ReturnType->isVoidType()) {
2303 Builder.AddTypedTextChunk("return");
2304 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2305 Results.AddResult(Result(Builder.TakeString()));
2307 assert(!ReturnType.isNull());
2308 // "return expression ;"
2309 Builder.AddTypedTextChunk("return");
2310 Builder.AddChunk(clang::CodeCompletionString::CK_HorizontalSpace);
2311 Builder.AddPlaceholderChunk("expression");
2312 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2313 Results.AddResult(Result(Builder.TakeString()));
2314 // When boolean, also add 'return true;' and 'return false;'.
2315 if (ReturnType->isBooleanType()) {
2316 Builder.AddTypedTextChunk("return true");
2317 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2318 Results.AddResult(Result(Builder.TakeString()));
2320 Builder.AddTypedTextChunk("return false");
2321 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2322 Results.AddResult(Result(Builder.TakeString()));
2326 // goto identifier ;
2327 Builder.AddTypedTextChunk("goto");
2328 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2329 Builder.AddPlaceholderChunk("label");
2330 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2331 Results.AddResult(Result(Builder.TakeString()));
2334 Builder.AddTypedTextChunk("using namespace");
2335 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2336 Builder.AddPlaceholderChunk("identifier");
2337 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2338 Results.AddResult(Result(Builder.TakeString()));
2340 AddStaticAssertResult(Builder, Results, SemaRef.getLangOpts());
2344 // Fall through (for statement expressions).
2345 case Sema::PCC_ForInit:
2346 case Sema::PCC_Condition:
2347 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2348 // Fall through: conditions and statements can have expressions.
2351 case Sema::PCC_ParenthesizedExpression:
2352 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
2353 CCC == Sema::PCC_ParenthesizedExpression) {
2354 // (__bridge <type>)<expression>
2355 Builder.AddTypedTextChunk("__bridge");
2356 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2357 Builder.AddPlaceholderChunk("type");
2358 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2359 Builder.AddPlaceholderChunk("expression");
2360 Results.AddResult(Result(Builder.TakeString()));
2362 // (__bridge_transfer <Objective-C type>)<expression>
2363 Builder.AddTypedTextChunk("__bridge_transfer");
2364 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2365 Builder.AddPlaceholderChunk("Objective-C type");
2366 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2367 Builder.AddPlaceholderChunk("expression");
2368 Results.AddResult(Result(Builder.TakeString()));
2370 // (__bridge_retained <CF type>)<expression>
2371 Builder.AddTypedTextChunk("__bridge_retained");
2372 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2373 Builder.AddPlaceholderChunk("CF type");
2374 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2375 Builder.AddPlaceholderChunk("expression");
2376 Results.AddResult(Result(Builder.TakeString()));
2381 case Sema::PCC_Expression: {
2382 if (SemaRef.getLangOpts().CPlusPlus) {
2383 // 'this', if we're in a non-static member function.
2384 addThisCompletion(SemaRef, Results);
2387 Builder.AddResultTypeChunk("bool");
2388 Builder.AddTypedTextChunk("true");
2389 Results.AddResult(Result(Builder.TakeString()));
2392 Builder.AddResultTypeChunk("bool");
2393 Builder.AddTypedTextChunk("false");
2394 Results.AddResult(Result(Builder.TakeString()));
2396 if (SemaRef.getLangOpts().RTTI) {
2397 // dynamic_cast < type-id > ( expression )
2398 Builder.AddTypedTextChunk("dynamic_cast");
2399 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
2400 Builder.AddPlaceholderChunk("type");
2401 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
2402 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2403 Builder.AddPlaceholderChunk("expression");
2404 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2405 Results.AddResult(Result(Builder.TakeString()));
2408 // static_cast < type-id > ( expression )
2409 Builder.AddTypedTextChunk("static_cast");
2410 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
2411 Builder.AddPlaceholderChunk("type");
2412 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
2413 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2414 Builder.AddPlaceholderChunk("expression");
2415 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2416 Results.AddResult(Result(Builder.TakeString()));
2418 // reinterpret_cast < type-id > ( expression )
2419 Builder.AddTypedTextChunk("reinterpret_cast");
2420 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
2421 Builder.AddPlaceholderChunk("type");
2422 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
2423 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2424 Builder.AddPlaceholderChunk("expression");
2425 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2426 Results.AddResult(Result(Builder.TakeString()));
2428 // const_cast < type-id > ( expression )
2429 Builder.AddTypedTextChunk("const_cast");
2430 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
2431 Builder.AddPlaceholderChunk("type");
2432 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
2433 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2434 Builder.AddPlaceholderChunk("expression");
2435 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2436 Results.AddResult(Result(Builder.TakeString()));
2438 if (SemaRef.getLangOpts().RTTI) {
2439 // typeid ( expression-or-type )
2440 Builder.AddResultTypeChunk("std::type_info");
2441 Builder.AddTypedTextChunk("typeid");
2442 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2443 Builder.AddPlaceholderChunk("expression-or-type");
2444 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2445 Results.AddResult(Result(Builder.TakeString()));
2449 Builder.AddTypedTextChunk("new");
2450 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2451 Builder.AddPlaceholderChunk("type");
2452 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2453 Builder.AddPlaceholderChunk("expressions");
2454 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2455 Results.AddResult(Result(Builder.TakeString()));
2457 // new T [ ] ( ... )
2458 Builder.AddTypedTextChunk("new");
2459 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2460 Builder.AddPlaceholderChunk("type");
2461 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
2462 Builder.AddPlaceholderChunk("size");
2463 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
2464 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2465 Builder.AddPlaceholderChunk("expressions");
2466 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2467 Results.AddResult(Result(Builder.TakeString()));
2469 // delete expression
2470 Builder.AddResultTypeChunk("void");
2471 Builder.AddTypedTextChunk("delete");
2472 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2473 Builder.AddPlaceholderChunk("expression");
2474 Results.AddResult(Result(Builder.TakeString()));
2476 // delete [] expression
2477 Builder.AddResultTypeChunk("void");
2478 Builder.AddTypedTextChunk("delete");
2479 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2480 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
2481 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
2482 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2483 Builder.AddPlaceholderChunk("expression");
2484 Results.AddResult(Result(Builder.TakeString()));
2486 if (SemaRef.getLangOpts().CXXExceptions) {
2488 Builder.AddResultTypeChunk("void");
2489 Builder.AddTypedTextChunk("throw");
2490 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2491 Builder.AddPlaceholderChunk("expression");
2492 Results.AddResult(Result(Builder.TakeString()));
2497 if (SemaRef.getLangOpts().CPlusPlus11) {
2499 Builder.AddResultTypeChunk("std::nullptr_t");
2500 Builder.AddTypedTextChunk("nullptr");
2501 Results.AddResult(Result(Builder.TakeString()));
2504 Builder.AddResultTypeChunk("size_t");
2505 Builder.AddTypedTextChunk("alignof");
2506 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2507 Builder.AddPlaceholderChunk("type");
2508 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2509 Results.AddResult(Result(Builder.TakeString()));
2512 Builder.AddResultTypeChunk("bool");
2513 Builder.AddTypedTextChunk("noexcept");
2514 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2515 Builder.AddPlaceholderChunk("expression");
2516 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2517 Results.AddResult(Result(Builder.TakeString()));
2519 // sizeof... expression
2520 Builder.AddResultTypeChunk("size_t");
2521 Builder.AddTypedTextChunk("sizeof...");
2522 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2523 Builder.AddPlaceholderChunk("parameter-pack");
2524 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2525 Results.AddResult(Result(Builder.TakeString()));
2529 if (SemaRef.getLangOpts().ObjC) {
2530 // Add "super", if we're in an Objective-C class with a superclass.
2531 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) {
2532 // The interface can be NULL.
2533 if (ObjCInterfaceDecl *ID = Method->getClassInterface())
2534 if (ID->getSuperClass()) {
2535 std::string SuperType;
2536 SuperType = ID->getSuperClass()->getNameAsString();
2537 if (Method->isInstanceMethod())
2540 Builder.AddResultTypeChunk(Allocator.CopyString(SuperType));
2541 Builder.AddTypedTextChunk("super");
2542 Results.AddResult(Result(Builder.TakeString()));
2546 AddObjCExpressionResults(Results, true);
2549 if (SemaRef.getLangOpts().C11) {
2551 Builder.AddResultTypeChunk("size_t");
2552 if (SemaRef.PP.isMacroDefined("alignof"))
2553 Builder.AddTypedTextChunk("alignof");
2555 Builder.AddTypedTextChunk("_Alignof");
2556 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2557 Builder.AddPlaceholderChunk("type");
2558 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2559 Results.AddResult(Result(Builder.TakeString()));
2562 // sizeof expression
2563 Builder.AddResultTypeChunk("size_t");
2564 Builder.AddTypedTextChunk("sizeof");
2565 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2566 Builder.AddPlaceholderChunk("expression-or-type");
2567 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2568 Results.AddResult(Result(Builder.TakeString()));
2572 case Sema::PCC_Type:
2573 case Sema::PCC_LocalDeclarationSpecifiers:
2577 if (WantTypesInContext(CCC, SemaRef.getLangOpts()))
2578 AddTypeSpecifierResults(SemaRef.getLangOpts(), Results);
2580 if (SemaRef.getLangOpts().CPlusPlus && CCC != Sema::PCC_Type)
2581 Results.AddResult(Result("operator"));
2584 /// If the given declaration has an associated type, add it as a result
2586 static void AddResultTypeChunk(ASTContext &Context,
2587 const PrintingPolicy &Policy,
2588 const NamedDecl *ND, QualType BaseType,
2589 CodeCompletionBuilder &Result) {
2593 // Skip constructors and conversion functions, which have their return types
2594 // built into their names.
2595 if (isConstructor(ND) || isa<CXXConversionDecl>(ND))
2598 // Determine the type of the declaration (if it has a type).
2600 if (const FunctionDecl *Function = ND->getAsFunction())
2601 T = Function->getReturnType();
2602 else if (const auto *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2603 if (!BaseType.isNull())
2604 T = Method->getSendResultType(BaseType);
2606 T = Method->getReturnType();
2607 } else if (const auto *Enumerator = dyn_cast<EnumConstantDecl>(ND)) {
2608 T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext()));
2609 T = clang::TypeName::getFullyQualifiedType(T, Context);
2610 } else if (isa<UnresolvedUsingValueDecl>(ND)) {
2611 /* Do nothing: ignore unresolved using declarations*/
2612 } else if (const auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
2613 if (!BaseType.isNull())
2614 T = Ivar->getUsageType(BaseType);
2616 T = Ivar->getType();
2617 } else if (const auto *Value = dyn_cast<ValueDecl>(ND)) {
2618 T = Value->getType();
2619 } else if (const auto *Property = dyn_cast<ObjCPropertyDecl>(ND)) {
2620 if (!BaseType.isNull())
2621 T = Property->getUsageType(BaseType);
2623 T = Property->getType();
2626 if (T.isNull() || Context.hasSameType(T, Context.DependentTy))
2629 Result.AddResultTypeChunk(
2630 GetCompletionTypeString(T, Context, Policy, Result.getAllocator()));
2633 static void MaybeAddSentinel(Preprocessor &PP,
2634 const NamedDecl *FunctionOrMethod,
2635 CodeCompletionBuilder &Result) {
2636 if (SentinelAttr *Sentinel = FunctionOrMethod->getAttr<SentinelAttr>())
2637 if (Sentinel->getSentinel() == 0) {
2638 if (PP.getLangOpts().ObjC && PP.isMacroDefined("nil"))
2639 Result.AddTextChunk(", nil");
2640 else if (PP.isMacroDefined("NULL"))
2641 Result.AddTextChunk(", NULL");
2643 Result.AddTextChunk(", (void*)0");
2647 static std::string formatObjCParamQualifiers(unsigned ObjCQuals,
2650 if (ObjCQuals & Decl::OBJC_TQ_In)
2652 else if (ObjCQuals & Decl::OBJC_TQ_Inout)
2654 else if (ObjCQuals & Decl::OBJC_TQ_Out)
2656 if (ObjCQuals & Decl::OBJC_TQ_Bycopy)
2657 Result += "bycopy ";
2658 else if (ObjCQuals & Decl::OBJC_TQ_Byref)
2660 if (ObjCQuals & Decl::OBJC_TQ_Oneway)
2661 Result += "oneway ";
2662 if (ObjCQuals & Decl::OBJC_TQ_CSNullability) {
2663 if (auto nullability = AttributedType::stripOuterNullability(Type)) {
2664 switch (*nullability) {
2665 case NullabilityKind::NonNull:
2666 Result += "nonnull ";
2669 case NullabilityKind::Nullable:
2670 Result += "nullable ";
2673 case NullabilityKind::Unspecified:
2674 Result += "null_unspecified ";
2682 /// Tries to find the most appropriate type location for an Objective-C
2683 /// block placeholder.
2685 /// This function ignores things like typedefs and qualifiers in order to
2686 /// present the most relevant and accurate block placeholders in code completion
2688 static void findTypeLocationForBlockDecl(const TypeSourceInfo *TSInfo,
2689 FunctionTypeLoc &Block,
2690 FunctionProtoTypeLoc &BlockProto,
2691 bool SuppressBlock = false) {
2694 TypeLoc TL = TSInfo->getTypeLoc().getUnqualifiedLoc();
2696 // Look through typedefs.
2697 if (!SuppressBlock) {
2698 if (TypedefTypeLoc TypedefTL = TL.getAs<TypedefTypeLoc>()) {
2699 if (TypeSourceInfo *InnerTSInfo =
2700 TypedefTL.getTypedefNameDecl()->getTypeSourceInfo()) {
2701 TL = InnerTSInfo->getTypeLoc().getUnqualifiedLoc();
2706 // Look through qualified types
2707 if (QualifiedTypeLoc QualifiedTL = TL.getAs<QualifiedTypeLoc>()) {
2708 TL = QualifiedTL.getUnqualifiedLoc();
2712 if (AttributedTypeLoc AttrTL = TL.getAs<AttributedTypeLoc>()) {
2713 TL = AttrTL.getModifiedLoc();
2718 // Try to get the function prototype behind the block pointer type,
2720 if (BlockPointerTypeLoc BlockPtr = TL.getAs<BlockPointerTypeLoc>()) {
2721 TL = BlockPtr.getPointeeLoc().IgnoreParens();
2722 Block = TL.getAs<FunctionTypeLoc>();
2723 BlockProto = TL.getAs<FunctionProtoTypeLoc>();
2730 formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
2731 FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
2732 bool SuppressBlockName = false,
2733 bool SuppressBlock = false,
2734 Optional<ArrayRef<QualType>> ObjCSubsts = None);
2737 FormatFunctionParameter(const PrintingPolicy &Policy, const ParmVarDecl *Param,
2738 bool SuppressName = false, bool SuppressBlock = false,
2739 Optional<ArrayRef<QualType>> ObjCSubsts = None) {
2740 // Params are unavailable in FunctionTypeLoc if the FunctionType is invalid.
2741 // It would be better to pass in the param Type, which is usually avaliable.
2742 // But this case is rare, so just pretend we fell back to int as elsewhere.
2745 bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext());
2746 if (Param->getType()->isDependentType() ||
2747 !Param->getType()->isBlockPointerType()) {
2748 // The argument for a dependent or non-block parameter is a placeholder
2749 // containing that parameter's type.
2752 if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName)
2753 Result = Param->getIdentifier()->getName();
2755 QualType Type = Param->getType();
2757 Type = Type.substObjCTypeArgs(Param->getASTContext(), *ObjCSubsts,
2758 ObjCSubstitutionContext::Parameter);
2759 if (ObjCMethodParam) {
2761 "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(), Type);
2762 Result += Type.getAsString(Policy) + ")";
2763 if (Param->getIdentifier() && !SuppressName)
2764 Result += Param->getIdentifier()->getName();
2766 Type.getAsStringInternal(Result, Policy);
2771 // The argument for a block pointer parameter is a block literal with
2772 // the appropriate type.
2773 FunctionTypeLoc Block;
2774 FunctionProtoTypeLoc BlockProto;
2775 findTypeLocationForBlockDecl(Param->getTypeSourceInfo(), Block, BlockProto,
2777 // Try to retrieve the block type information from the property if this is a
2778 // parameter in a setter.
2779 if (!Block && ObjCMethodParam &&
2780 cast<ObjCMethodDecl>(Param->getDeclContext())->isPropertyAccessor()) {
2781 if (const auto *PD = cast<ObjCMethodDecl>(Param->getDeclContext())
2782 ->findPropertyDecl(/*CheckOverrides=*/false))
2783 findTypeLocationForBlockDecl(PD->getTypeSourceInfo(), Block, BlockProto,
2788 // We were unable to find a FunctionProtoTypeLoc with parameter names
2789 // for the block; just use the parameter type as a placeholder.
2791 if (!ObjCMethodParam && Param->getIdentifier())
2792 Result = Param->getIdentifier()->getName();
2794 QualType Type = Param->getType().getUnqualifiedType();
2796 if (ObjCMethodParam) {
2797 Result = Type.getAsString(Policy);
2799 formatObjCParamQualifiers(Param->getObjCDeclQualifier(), Type);
2801 Result = "(" + Quals + " " + Result + ")";
2802 if (Result.back() != ')')
2804 if (Param->getIdentifier())
2805 Result += Param->getIdentifier()->getName();
2807 Type.getAsStringInternal(Result, Policy);
2813 // We have the function prototype behind the block pointer type, as it was
2814 // written in the source.
2815 return formatBlockPlaceholder(Policy, Param, Block, BlockProto,
2816 /*SuppressBlockName=*/false, SuppressBlock,
2820 /// Returns a placeholder string that corresponds to an Objective-C block
2823 /// \param BlockDecl A declaration with an Objective-C block type.
2825 /// \param Block The most relevant type location for that block type.
2827 /// \param SuppressBlockName Determines whether or not the name of the block
2828 /// declaration is included in the resulting string.
2830 formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
2831 FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
2832 bool SuppressBlockName, bool SuppressBlock,
2833 Optional<ArrayRef<QualType>> ObjCSubsts) {
2835 QualType ResultType = Block.getTypePtr()->getReturnType();
2838 ResultType.substObjCTypeArgs(BlockDecl->getASTContext(), *ObjCSubsts,
2839 ObjCSubstitutionContext::Result);
2840 if (!ResultType->isVoidType() || SuppressBlock)
2841 ResultType.getAsStringInternal(Result, Policy);
2843 // Format the parameter list.
2845 if (!BlockProto || Block.getNumParams() == 0) {
2846 if (BlockProto && BlockProto.getTypePtr()->isVariadic())
2852 for (unsigned I = 0, N = Block.getNumParams(); I != N; ++I) {
2855 Params += FormatFunctionParameter(Policy, Block.getParam(I),
2856 /*SuppressName=*/false,
2857 /*SuppressBlock=*/true, ObjCSubsts);
2859 if (I == N - 1 && BlockProto.getTypePtr()->isVariadic())
2865 if (SuppressBlock) {
2866 // Format as a parameter.
2867 Result = Result + " (^";
2868 if (!SuppressBlockName && BlockDecl->getIdentifier())
2869 Result += BlockDecl->getIdentifier()->getName();
2873 // Format as a block literal argument.
2874 Result = '^' + Result;
2877 if (!SuppressBlockName && BlockDecl->getIdentifier())
2878 Result += BlockDecl->getIdentifier()->getName();
2884 static std::string GetDefaultValueString(const ParmVarDecl *Param,
2885 const SourceManager &SM,
2886 const LangOptions &LangOpts) {
2887 const SourceRange SrcRange = Param->getDefaultArgRange();
2888 CharSourceRange CharSrcRange = CharSourceRange::getTokenRange(SrcRange);
2889 bool Invalid = CharSrcRange.isInvalid();
2893 Lexer::getSourceText(CharSrcRange, SM, LangOpts, &Invalid);
2897 if (srcText.empty() || srcText == "=") {
2898 // Lexer can't determine the value.
2899 // This happens if the code is incorrect (for example class is forward
2903 std::string DefValue(srcText.str());
2904 // FIXME: remove this check if the Lexer::getSourceText value is fixed and
2905 // this value always has (or always does not have) '=' in front of it
2906 if (DefValue.at(0) != '=') {
2907 // If we don't have '=' in front of value.
2908 // Lexer returns built-in types values without '=' and user-defined types
2910 return " = " + DefValue;
2912 return " " + DefValue;
2915 /// Add function parameter chunks to the given code completion string.
2916 static void AddFunctionParameterChunks(Preprocessor &PP,
2917 const PrintingPolicy &Policy,
2918 const FunctionDecl *Function,
2919 CodeCompletionBuilder &Result,
2921 bool InOptional = false) {
2922 bool FirstParameter = true;
2924 for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) {
2925 const ParmVarDecl *Param = Function->getParamDecl(P);
2927 if (Param->hasDefaultArg() && !InOptional) {
2928 // When we see an optional default argument, put that argument and
2929 // the remaining default arguments into a new, optional string.
2930 CodeCompletionBuilder Opt(Result.getAllocator(),
2931 Result.getCodeCompletionTUInfo());
2932 if (!FirstParameter)
2933 Opt.AddChunk(CodeCompletionString::CK_Comma);
2934 AddFunctionParameterChunks(PP, Policy, Function, Opt, P, true);
2935 Result.AddOptionalChunk(Opt.TakeString());
2940 FirstParameter = false;
2942 Result.AddChunk(CodeCompletionString::CK_Comma);
2946 // Format the placeholder string.
2947 std::string PlaceholderStr = FormatFunctionParameter(Policy, Param);
2948 if (Param->hasDefaultArg())
2950 GetDefaultValueString(Param, PP.getSourceManager(), PP.getLangOpts());
2952 if (Function->isVariadic() && P == N - 1)
2953 PlaceholderStr += ", ...";
2955 // Add the placeholder string.
2956 Result.AddPlaceholderChunk(
2957 Result.getAllocator().CopyString(PlaceholderStr));
2960 if (const auto *Proto = Function->getType()->getAs<FunctionProtoType>())
2961 if (Proto->isVariadic()) {
2962 if (Proto->getNumParams() == 0)
2963 Result.AddPlaceholderChunk("...");
2965 MaybeAddSentinel(PP, Function, Result);
2969 /// Add template parameter chunks to the given code completion string.
2970 static void AddTemplateParameterChunks(
2971 ASTContext &Context, const PrintingPolicy &Policy,
2972 const TemplateDecl *Template, CodeCompletionBuilder &Result,
2973 unsigned MaxParameters = 0, unsigned Start = 0, bool InDefaultArg = false) {
2974 bool FirstParameter = true;
2976 // Prefer to take the template parameter names from the first declaration of
2978 Template = cast<TemplateDecl>(Template->getCanonicalDecl());
2980 TemplateParameterList *Params = Template->getTemplateParameters();
2981 TemplateParameterList::iterator PEnd = Params->end();
2983 PEnd = Params->begin() + MaxParameters;
2984 for (TemplateParameterList::iterator P = Params->begin() + Start; P != PEnd;
2986 bool HasDefaultArg = false;
2987 std::string PlaceholderStr;
2988 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
2989 if (TTP->wasDeclaredWithTypename())
2990 PlaceholderStr = "typename";
2992 PlaceholderStr = "class";
2994 if (TTP->getIdentifier()) {
2995 PlaceholderStr += ' ';
2996 PlaceholderStr += TTP->getIdentifier()->getName();
2999 HasDefaultArg = TTP->hasDefaultArgument();
3000 } else if (NonTypeTemplateParmDecl *NTTP =
3001 dyn_cast<NonTypeTemplateParmDecl>(*P)) {
3002 if (NTTP->getIdentifier())
3003 PlaceholderStr = NTTP->getIdentifier()->getName();
3004 NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
3005 HasDefaultArg = NTTP->hasDefaultArgument();
3007 assert(isa<TemplateTemplateParmDecl>(*P));
3008 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
3010 // Since putting the template argument list into the placeholder would
3011 // be very, very long, we just use an abbreviation.
3012 PlaceholderStr = "template<...> class";
3013 if (TTP->getIdentifier()) {
3014 PlaceholderStr += ' ';
3015 PlaceholderStr += TTP->getIdentifier()->getName();
3018 HasDefaultArg = TTP->hasDefaultArgument();
3021 if (HasDefaultArg && !InDefaultArg) {
3022 // When we see an optional default argument, put that argument and
3023 // the remaining default arguments into a new, optional string.
3024 CodeCompletionBuilder Opt(Result.getAllocator(),
3025 Result.getCodeCompletionTUInfo());
3026 if (!FirstParameter)
3027 Opt.AddChunk(CodeCompletionString::CK_Comma);
3028 AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters,
3029 P - Params->begin(), true);
3030 Result.AddOptionalChunk(Opt.TakeString());
3034 InDefaultArg = false;
3037 FirstParameter = false;
3039 Result.AddChunk(CodeCompletionString::CK_Comma);
3041 // Add the placeholder string.
3042 Result.AddPlaceholderChunk(
3043 Result.getAllocator().CopyString(PlaceholderStr));
3047 /// Add a qualifier to the given code-completion string, if the
3048 /// provided nested-name-specifier is non-NULL.
3049 static void AddQualifierToCompletionString(CodeCompletionBuilder &Result,
3050 NestedNameSpecifier *Qualifier,
3051 bool QualifierIsInformative,
3052 ASTContext &Context,
3053 const PrintingPolicy &Policy) {
3057 std::string PrintedNNS;
3059 llvm::raw_string_ostream OS(PrintedNNS);
3060 Qualifier->print(OS, Policy);
3062 if (QualifierIsInformative)
3063 Result.AddInformativeChunk(Result.getAllocator().CopyString(PrintedNNS));
3065 Result.AddTextChunk(Result.getAllocator().CopyString(PrintedNNS));
3069 AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result,
3070 const FunctionDecl *Function) {
3071 const auto *Proto = Function->getType()->getAs<FunctionProtoType>();
3072 if (!Proto || !Proto->getMethodQuals())
3075 // FIXME: Add ref-qualifier!
3077 // Handle single qualifiers without copying
3078 if (Proto->getMethodQuals().hasOnlyConst()) {
3079 Result.AddInformativeChunk(" const");
3083 if (Proto->getMethodQuals().hasOnlyVolatile()) {
3084 Result.AddInformativeChunk(" volatile");
3088 if (Proto->getMethodQuals().hasOnlyRestrict()) {
3089 Result.AddInformativeChunk(" restrict");
3093 // Handle multiple qualifiers.
3094 std::string QualsStr;
3095 if (Proto->isConst())
3096 QualsStr += " const";
3097 if (Proto->isVolatile())
3098 QualsStr += " volatile";
3099 if (Proto->isRestrict())
3100 QualsStr += " restrict";
3101 Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
3104 /// Add the name of the given declaration
3105 static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy,
3106 const NamedDecl *ND,
3107 CodeCompletionBuilder &Result) {
3108 DeclarationName Name = ND->getDeclName();
3112 switch (Name.getNameKind()) {
3113 case DeclarationName::CXXOperatorName: {
3114 const char *OperatorName = nullptr;
3115 switch (Name.getCXXOverloadedOperator()) {
3117 case OO_Conditional:
3118 case NUM_OVERLOADED_OPERATORS:
3119 OperatorName = "operator";
3122 #define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
3124 OperatorName = "operator" Spelling; \
3126 #define OVERLOADED_OPERATOR_MULTI(Name, Spelling, Unary, Binary, MemberOnly)
3127 #include "clang/Basic/OperatorKinds.def"
3130 OperatorName = "operator new";
3133 OperatorName = "operator delete";
3136 OperatorName = "operator new[]";
3138 case OO_Array_Delete:
3139 OperatorName = "operator delete[]";
3142 OperatorName = "operator()";
3145 OperatorName = "operator[]";
3148 Result.AddTypedTextChunk(OperatorName);
3152 case DeclarationName::Identifier:
3153 case DeclarationName::CXXConversionFunctionName:
3154 case DeclarationName::CXXDestructorName:
3155 case DeclarationName::CXXLiteralOperatorName:
3156 Result.AddTypedTextChunk(
3157 Result.getAllocator().CopyString(ND->getNameAsString()));
3160 case DeclarationName::CXXDeductionGuideName:
3161 case DeclarationName::CXXUsingDirective:
3162 case DeclarationName::ObjCZeroArgSelector:
3163 case DeclarationName::ObjCOneArgSelector:
3164 case DeclarationName::ObjCMultiArgSelector:
3167 case DeclarationName::CXXConstructorName: {
3168 CXXRecordDecl *Record = nullptr;
3169 QualType Ty = Name.getCXXNameType();
3170 if (const auto *RecordTy = Ty->getAs<RecordType>())
3171 Record = cast<CXXRecordDecl>(RecordTy->getDecl());
3172 else if (const auto *InjectedTy = Ty->getAs<InjectedClassNameType>())
3173 Record = InjectedTy->getDecl();
3175 Result.AddTypedTextChunk(
3176 Result.getAllocator().CopyString(ND->getNameAsString()));
3180 Result.AddTypedTextChunk(
3181 Result.getAllocator().CopyString(Record->getNameAsString()));
3182 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) {
3183 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
3184 AddTemplateParameterChunks(Context, Policy, Template, Result);
3185 Result.AddChunk(CodeCompletionString::CK_RightAngle);
3192 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(
3193 Sema &S, const CodeCompletionContext &CCContext,
3194 CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo,
3195 bool IncludeBriefComments) {
3196 return CreateCodeCompletionString(S.Context, S.PP, CCContext, Allocator,
3197 CCTUInfo, IncludeBriefComments);
3200 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionStringForMacro(
3201 Preprocessor &PP, CodeCompletionAllocator &Allocator,
3202 CodeCompletionTUInfo &CCTUInfo) {
3203 assert(Kind == RK_Macro);
3204 CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
3205 const MacroInfo *MI = PP.getMacroInfo(Macro);
3206 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Macro->getName()));
3208 if (!MI || !MI->isFunctionLike())
3209 return Result.TakeString();
3211 // Format a function-like macro with placeholders for the arguments.
3212 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3213 MacroInfo::param_iterator A = MI->param_begin(), AEnd = MI->param_end();
3215 // C99 variadic macros add __VA_ARGS__ at the end. Skip it.
3216 if (MI->isC99Varargs()) {
3220 Result.AddPlaceholderChunk("...");
3224 for (MacroInfo::param_iterator A = MI->param_begin(); A != AEnd; ++A) {
3225 if (A != MI->param_begin())
3226 Result.AddChunk(CodeCompletionString::CK_Comma);
3228 if (MI->isVariadic() && (A + 1) == AEnd) {
3229 SmallString<32> Arg = (*A)->getName();
3230 if (MI->isC99Varargs())
3234 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
3238 // Non-variadic macros are simple.
3239 Result.AddPlaceholderChunk(
3240 Result.getAllocator().CopyString((*A)->getName()));
3242 Result.AddChunk(CodeCompletionString::CK_RightParen);
3243 return Result.TakeString();
3246 /// If possible, create a new code completion string for the given
3249 /// \returns Either a new, heap-allocated code completion string describing
3250 /// how to use this result, or NULL to indicate that the string or name of the
3251 /// result is all that is needed.
3252 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(
3253 ASTContext &Ctx, Preprocessor &PP, const CodeCompletionContext &CCContext,
3254 CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo,
3255 bool IncludeBriefComments) {
3256 if (Kind == RK_Macro)
3257 return CreateCodeCompletionStringForMacro(PP, Allocator, CCTUInfo);
3259 CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
3261 PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP);
3262 if (Kind == RK_Pattern) {
3263 Pattern->Priority = Priority;
3264 Pattern->Availability = Availability;
3267 Result.addParentContext(Declaration->getDeclContext());
3268 Pattern->ParentName = Result.getParentName();
3269 if (const RawComment *RC =
3270 getPatternCompletionComment(Ctx, Declaration)) {
3271 Result.addBriefComment(RC->getBriefText(Ctx));
3272 Pattern->BriefComment = Result.getBriefComment();
3279 if (Kind == RK_Keyword) {
3280 Result.AddTypedTextChunk(Keyword);
3281 return Result.TakeString();
3283 assert(Kind == RK_Declaration && "Missed a result kind?");
3284 return createCodeCompletionStringForDecl(
3285 PP, Ctx, Result, IncludeBriefComments, CCContext, Policy);
3288 static void printOverrideString(const CodeCompletionString &CCS,
3289 std::string &BeforeName,
3290 std::string &NameAndSignature) {
3291 bool SeenTypedChunk = false;
3292 for (auto &Chunk : CCS) {
3293 if (Chunk.Kind == CodeCompletionString::CK_Optional) {
3294 assert(SeenTypedChunk && "optional parameter before name");
3295 // Note that we put all chunks inside into NameAndSignature.
3296 printOverrideString(*Chunk.Optional, NameAndSignature, NameAndSignature);
3299 SeenTypedChunk |= Chunk.Kind == CodeCompletionString::CK_TypedText;
3301 NameAndSignature += Chunk.Text;
3303 BeforeName += Chunk.Text;
3307 CodeCompletionString *
3308 CodeCompletionResult::createCodeCompletionStringForOverride(
3309 Preprocessor &PP, ASTContext &Ctx, CodeCompletionBuilder &Result,
3310 bool IncludeBriefComments, const CodeCompletionContext &CCContext,
3311 PrintingPolicy &Policy) {
3312 auto *CCS = createCodeCompletionStringForDecl(PP, Ctx, Result,
3313 /*IncludeBriefComments=*/false,
3315 std::string BeforeName;
3316 std::string NameAndSignature;
3317 // For overrides all chunks go into the result, none are informative.
3318 printOverrideString(*CCS, BeforeName, NameAndSignature);
3319 NameAndSignature += " override";
3321 Result.AddTextChunk(Result.getAllocator().CopyString(BeforeName));
3322 Result.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3323 Result.AddTypedTextChunk(Result.getAllocator().CopyString(NameAndSignature));
3324 return Result.TakeString();
3327 CodeCompletionString *CodeCompletionResult::createCodeCompletionStringForDecl(
3328 Preprocessor &PP, ASTContext &Ctx, CodeCompletionBuilder &Result,
3329 bool IncludeBriefComments, const CodeCompletionContext &CCContext,
3330 PrintingPolicy &Policy) {
3331 const NamedDecl *ND = Declaration;
3332 Result.addParentContext(ND->getDeclContext());
3334 if (IncludeBriefComments) {
3335 // Add documentation comment, if it exists.
3336 if (const RawComment *RC = getCompletionComment(Ctx, Declaration)) {
3337 Result.addBriefComment(RC->getBriefText(Ctx));
3341 if (StartsNestedNameSpecifier) {
3342 Result.AddTypedTextChunk(
3343 Result.getAllocator().CopyString(ND->getNameAsString()));
3344 Result.AddTextChunk("::");
3345 return Result.TakeString();
3348 for (const auto *I : ND->specific_attrs<AnnotateAttr>())
3349 Result.AddAnnotation(Result.getAllocator().CopyString(I->getAnnotation()));
3351 AddResultTypeChunk(Ctx, Policy, ND, CCContext.getBaseType(), Result);
3353 if (const auto *Function = dyn_cast<FunctionDecl>(ND)) {
3354 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
3356 AddTypedNameChunk(Ctx, Policy, ND, Result);
3357 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3358 AddFunctionParameterChunks(PP, Policy, Function, Result);
3359 Result.AddChunk(CodeCompletionString::CK_RightParen);
3360 AddFunctionTypeQualsToCompletionString(Result, Function);
3361 return Result.TakeString();
3364 if (const FunctionTemplateDecl *FunTmpl =
3365 dyn_cast<FunctionTemplateDecl>(ND)) {
3366 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
3368 FunctionDecl *Function = FunTmpl->getTemplatedDecl();
3369 AddTypedNameChunk(Ctx, Policy, Function, Result);
3371 // Figure out which template parameters are deduced (or have default
3373 llvm::SmallBitVector Deduced;
3374 Sema::MarkDeducedTemplateParameters(Ctx, FunTmpl, Deduced);
3375 unsigned LastDeducibleArgument;
3376 for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0;
3377 --LastDeducibleArgument) {
3378 if (!Deduced[LastDeducibleArgument - 1]) {
3379 // C++0x: Figure out if the template argument has a default. If so,
3380 // the user doesn't need to type this argument.
3381 // FIXME: We need to abstract template parameters better!
3382 bool HasDefaultArg = false;
3383 NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam(
3384 LastDeducibleArgument - 1);
3385 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
3386 HasDefaultArg = TTP->hasDefaultArgument();
3387 else if (NonTypeTemplateParmDecl *NTTP =
3388 dyn_cast<NonTypeTemplateParmDecl>(Param))
3389 HasDefaultArg = NTTP->hasDefaultArgument();
3391 assert(isa<TemplateTemplateParmDecl>(Param));
3393 cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument();
3401 if (LastDeducibleArgument) {
3402 // Some of the function template arguments cannot be deduced from a
3403 // function call, so we introduce an explicit template argument list
3404 // containing all of the arguments up to the first deducible argument.
3405 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
3406 AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result,
3407 LastDeducibleArgument);
3408 Result.AddChunk(CodeCompletionString::CK_RightAngle);
3411 // Add the function parameters
3412 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3413 AddFunctionParameterChunks(PP, Policy, Function, Result);
3414 Result.AddChunk(CodeCompletionString::CK_RightParen);
3415 AddFunctionTypeQualsToCompletionString(Result, Function);
3416 return Result.TakeString();
3419 if (const auto *Template = dyn_cast<TemplateDecl>(ND)) {
3420 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
3422 Result.AddTypedTextChunk(
3423 Result.getAllocator().CopyString(Template->getNameAsString()));
3424 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
3425 AddTemplateParameterChunks(Ctx, Policy, Template, Result);
3426 Result.AddChunk(CodeCompletionString::CK_RightAngle);
3427 return Result.TakeString();
3429 if (const auto *Method = dyn_cast<ObjCMethodDecl>(ND)) {
3430 Selector Sel = Method->getSelector();
3431 if (Sel.isUnarySelector()) {
3432 Result.AddTypedTextChunk(
3433 Result.getAllocator().CopyString(Sel.getNameForSlot(0)));
3434 return Result.TakeString();
3437 std::string SelName = Sel.getNameForSlot(0).str();
3439 if (StartParameter == 0)
3440 Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName));
3442 Result.AddInformativeChunk(Result.getAllocator().CopyString(SelName));
3444 // If there is only one parameter, and we're past it, add an empty
3445 // typed-text chunk since there is nothing to type.
3446 if (Method->param_size() == 1)
3447 Result.AddTypedTextChunk("");
3450 for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(),
3451 PEnd = Method->param_end();
3452 P != PEnd; (void)++P, ++Idx) {
3454 std::string Keyword;
3455 if (Idx > StartParameter)
3456 Result.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3457 if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx))
3458 Keyword += II->getName();
3460 if (Idx < StartParameter || AllParametersAreInformative)
3461 Result.AddInformativeChunk(Result.getAllocator().CopyString(Keyword));
3463 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Keyword));
3466 // If we're before the starting parameter, skip the placeholder.
3467 if (Idx < StartParameter)
3471 QualType ParamType = (*P)->getType();
3472 Optional<ArrayRef<QualType>> ObjCSubsts;
3473 if (!CCContext.getBaseType().isNull())
3474 ObjCSubsts = CCContext.getBaseType()->getObjCSubstitutions(Method);
3476 if (ParamType->isBlockPointerType() && !DeclaringEntity)
3477 Arg = FormatFunctionParameter(Policy, *P, true,
3478 /*SuppressBlock=*/false, ObjCSubsts);
3481 ParamType = ParamType.substObjCTypeArgs(
3482 Ctx, *ObjCSubsts, ObjCSubstitutionContext::Parameter);
3483 Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier(),
3485 Arg += ParamType.getAsString(Policy) + ")";
3486 if (IdentifierInfo *II = (*P)->getIdentifier())
3487 if (DeclaringEntity || AllParametersAreInformative)
3488 Arg += II->getName();
3491 if (Method->isVariadic() && (P + 1) == PEnd)
3494 if (DeclaringEntity)
3495 Result.AddTextChunk(Result.getAllocator().CopyString(Arg));
3496 else if (AllParametersAreInformative)
3497 Result.AddInformativeChunk(Result.getAllocator().CopyString(Arg));
3499 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
3502 if (Method->isVariadic()) {
3503 if (Method->param_size() == 0) {
3504 if (DeclaringEntity)
3505 Result.AddTextChunk(", ...");
3506 else if (AllParametersAreInformative)
3507 Result.AddInformativeChunk(", ...");
3509 Result.AddPlaceholderChunk(", ...");
3512 MaybeAddSentinel(PP, Method, Result);
3515 return Result.TakeString();
3519 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
3522 Result.AddTypedTextChunk(
3523 Result.getAllocator().CopyString(ND->getNameAsString()));
3524 return Result.TakeString();
3527 const RawComment *clang::getCompletionComment(const ASTContext &Ctx,
3528 const NamedDecl *ND) {
3531 if (auto *RC = Ctx.getRawCommentForAnyRedecl(ND))
3534 // Try to find comment from a property for ObjC methods.
3535 const auto *M = dyn_cast<ObjCMethodDecl>(ND);
3538 const ObjCPropertyDecl *PDecl = M->findPropertyDecl();
3542 return Ctx.getRawCommentForAnyRedecl(PDecl);
3545 const RawComment *clang::getPatternCompletionComment(const ASTContext &Ctx,
3546 const NamedDecl *ND) {
3547 const auto *M = dyn_cast_or_null<ObjCMethodDecl>(ND);
3548 if (!M || !M->isPropertyAccessor())
3551 // Provide code completion comment for self.GetterName where
3552 // GetterName is the getter method for a property with name
3553 // different from the property name (declared via a property
3554 // getter attribute.
3555 const ObjCPropertyDecl *PDecl = M->findPropertyDecl();
3558 if (PDecl->getGetterName() == M->getSelector() &&
3559 PDecl->getIdentifier() != M->getIdentifier()) {
3560 if (auto *RC = Ctx.getRawCommentForAnyRedecl(M))
3562 if (auto *RC = Ctx.getRawCommentForAnyRedecl(PDecl))
3568 const RawComment *clang::getParameterComment(
3569 const ASTContext &Ctx,
3570 const CodeCompleteConsumer::OverloadCandidate &Result, unsigned ArgIndex) {
3571 auto FDecl = Result.getFunction();
3574 if (ArgIndex < FDecl->getNumParams())
3575 return Ctx.getRawCommentForAnyRedecl(FDecl->getParamDecl(ArgIndex));
3579 /// Add function overload parameter chunks to the given code completion
3581 static void AddOverloadParameterChunks(ASTContext &Context,
3582 const PrintingPolicy &Policy,
3583 const FunctionDecl *Function,
3584 const FunctionProtoType *Prototype,
3585 CodeCompletionBuilder &Result,
3586 unsigned CurrentArg, unsigned Start = 0,
3587 bool InOptional = false) {
3588 bool FirstParameter = true;
3589 unsigned NumParams =
3590 Function ? Function->getNumParams() : Prototype->getNumParams();
3592 for (unsigned P = Start; P != NumParams; ++P) {
3593 if (Function && Function->getParamDecl(P)->hasDefaultArg() && !InOptional) {
3594 // When we see an optional default argument, put that argument and
3595 // the remaining default arguments into a new, optional string.
3596 CodeCompletionBuilder Opt(Result.getAllocator(),
3597 Result.getCodeCompletionTUInfo());
3598 if (!FirstParameter)
3599 Opt.AddChunk(CodeCompletionString::CK_Comma);
3600 // Optional sections are nested.
3601 AddOverloadParameterChunks(Context, Policy, Function, Prototype, Opt,
3602 CurrentArg, P, /*InOptional=*/true);
3603 Result.AddOptionalChunk(Opt.TakeString());
3608 FirstParameter = false;
3610 Result.AddChunk(CodeCompletionString::CK_Comma);
3614 // Format the placeholder string.
3615 std::string Placeholder;
3617 const ParmVarDecl *Param = Function->getParamDecl(P);
3618 Placeholder = FormatFunctionParameter(Policy, Param);
3619 if (Param->hasDefaultArg())
3620 Placeholder += GetDefaultValueString(Param, Context.getSourceManager(),
3621 Context.getLangOpts());
3623 Placeholder = Prototype->getParamType(P).getAsString(Policy);
3626 if (P == CurrentArg)
3627 Result.AddCurrentParameterChunk(
3628 Result.getAllocator().CopyString(Placeholder));
3630 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Placeholder));
3633 if (Prototype && Prototype->isVariadic()) {
3634 CodeCompletionBuilder Opt(Result.getAllocator(),
3635 Result.getCodeCompletionTUInfo());
3636 if (!FirstParameter)
3637 Opt.AddChunk(CodeCompletionString::CK_Comma);
3639 if (CurrentArg < NumParams)
3640 Opt.AddPlaceholderChunk("...");
3642 Opt.AddCurrentParameterChunk("...");
3644 Result.AddOptionalChunk(Opt.TakeString());
3648 CodeCompletionString *
3649 CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
3650 unsigned CurrentArg, Sema &S, CodeCompletionAllocator &Allocator,
3651 CodeCompletionTUInfo &CCTUInfo, bool IncludeBriefComments) const {
3652 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
3654 // FIXME: Set priority, availability appropriately.
3655 CodeCompletionBuilder Result(Allocator, CCTUInfo, 1,
3656 CXAvailability_Available);
3657 FunctionDecl *FDecl = getFunction();
3658 const FunctionProtoType *Proto =
3659 dyn_cast<FunctionProtoType>(getFunctionType());
3660 if (!FDecl && !Proto) {
3661 // Function without a prototype. Just give the return type and a
3662 // highlighted ellipsis.
3663 const FunctionType *FT = getFunctionType();
3664 Result.AddResultTypeChunk(Result.getAllocator().CopyString(
3665 FT->getReturnType().getAsString(Policy)));
3666 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3667 Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
3668 Result.AddChunk(CodeCompletionString::CK_RightParen);
3669 return Result.TakeString();
3673 if (IncludeBriefComments) {
3674 if (auto RC = getParameterComment(S.getASTContext(), *this, CurrentArg))
3675 Result.addBriefComment(RC->getBriefText(S.getASTContext()));
3677 AddResultTypeChunk(S.Context, Policy, FDecl, QualType(), Result);
3678 Result.AddTextChunk(
3679 Result.getAllocator().CopyString(FDecl->getNameAsString()));
3681 Result.AddResultTypeChunk(Result.getAllocator().CopyString(
3682 Proto->getReturnType().getAsString(Policy)));
3685 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3686 AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, Result,
3688 Result.AddChunk(CodeCompletionString::CK_RightParen);
3690 return Result.TakeString();
3693 unsigned clang::getMacroUsagePriority(StringRef MacroName,
3694 const LangOptions &LangOpts,
3695 bool PreferredTypeIsPointer) {
3696 unsigned Priority = CCP_Macro;
3698 // Treat the "nil", "Nil" and "NULL" macros as null pointer constants.
3699 if (MacroName.equals("nil") || MacroName.equals("NULL") ||
3700 MacroName.equals("Nil")) {
3701 Priority = CCP_Constant;
3702 if (PreferredTypeIsPointer)
3703 Priority = Priority / CCF_SimilarTypeMatch;
3705 // Treat "YES", "NO", "true", and "false" as constants.
3706 else if (MacroName.equals("YES") || MacroName.equals("NO") ||
3707 MacroName.equals("true") || MacroName.equals("false"))
3708 Priority = CCP_Constant;
3709 // Treat "bool" as a type.
3710 else if (MacroName.equals("bool"))
3711 Priority = CCP_Type + (LangOpts.ObjC ? CCD_bool_in_ObjC : 0);
3716 CXCursorKind clang::getCursorKindForDecl(const Decl *D) {
3718 return CXCursor_UnexposedDecl;
3720 switch (D->getKind()) {
3722 return CXCursor_EnumDecl;
3723 case Decl::EnumConstant:
3724 return CXCursor_EnumConstantDecl;
3726 return CXCursor_FieldDecl;
3727 case Decl::Function:
3728 return CXCursor_FunctionDecl;
3729 case Decl::ObjCCategory:
3730 return CXCursor_ObjCCategoryDecl;
3731 case Decl::ObjCCategoryImpl:
3732 return CXCursor_ObjCCategoryImplDecl;
3733 case Decl::ObjCImplementation:
3734 return CXCursor_ObjCImplementationDecl;
3736 case Decl::ObjCInterface:
3737 return CXCursor_ObjCInterfaceDecl;
3738 case Decl::ObjCIvar:
3739 return CXCursor_ObjCIvarDecl;
3740 case Decl::ObjCMethod:
3741 return cast<ObjCMethodDecl>(D)->isInstanceMethod()
3742 ? CXCursor_ObjCInstanceMethodDecl
3743 : CXCursor_ObjCClassMethodDecl;
3744 case Decl::CXXMethod:
3745 return CXCursor_CXXMethod;
3746 case Decl::CXXConstructor:
3747 return CXCursor_Constructor;
3748 case Decl::CXXDestructor:
3749 return CXCursor_Destructor;
3750 case Decl::CXXConversion:
3751 return CXCursor_ConversionFunction;
3752 case Decl::ObjCProperty:
3753 return CXCursor_ObjCPropertyDecl;
3754 case Decl::ObjCProtocol:
3755 return CXCursor_ObjCProtocolDecl;
3757 return CXCursor_ParmDecl;
3759 return CXCursor_TypedefDecl;
3760 case Decl::TypeAlias:
3761 return CXCursor_TypeAliasDecl;
3762 case Decl::TypeAliasTemplate:
3763 return CXCursor_TypeAliasTemplateDecl;
3765 return CXCursor_VarDecl;
3766 case Decl::Namespace:
3767 return CXCursor_Namespace;
3768 case Decl::NamespaceAlias:
3769 return CXCursor_NamespaceAlias;
3770 case Decl::TemplateTypeParm:
3771 return CXCursor_TemplateTypeParameter;
3772 case Decl::NonTypeTemplateParm:
3773 return CXCursor_NonTypeTemplateParameter;
3774 case Decl::TemplateTemplateParm:
3775 return CXCursor_TemplateTemplateParameter;
3776 case Decl::FunctionTemplate:
3777 return CXCursor_FunctionTemplate;
3778 case Decl::ClassTemplate:
3779 return CXCursor_ClassTemplate;
3780 case Decl::AccessSpec:
3781 return CXCursor_CXXAccessSpecifier;
3782 case Decl::ClassTemplatePartialSpecialization:
3783 return CXCursor_ClassTemplatePartialSpecialization;
3784 case Decl::UsingDirective:
3785 return CXCursor_UsingDirective;
3786 case Decl::StaticAssert:
3787 return CXCursor_StaticAssert;
3789 return CXCursor_FriendDecl;
3790 case Decl::TranslationUnit:
3791 return CXCursor_TranslationUnit;
3794 case Decl::UnresolvedUsingValue:
3795 case Decl::UnresolvedUsingTypename:
3796 return CXCursor_UsingDeclaration;
3798 case Decl::ObjCPropertyImpl:
3799 switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
3800 case ObjCPropertyImplDecl::Dynamic:
3801 return CXCursor_ObjCDynamicDecl;
3803 case ObjCPropertyImplDecl::Synthesize:
3804 return CXCursor_ObjCSynthesizeDecl;
3806 llvm_unreachable("Unexpected Kind!");
3809 return CXCursor_ModuleImportDecl;
3811 case Decl::ObjCTypeParam:
3812 return CXCursor_TemplateTypeParameter;
3815 if (const auto *TD = dyn_cast<TagDecl>(D)) {
3816 switch (TD->getTagKind()) {
3817 case TTK_Interface: // fall through
3819 return CXCursor_StructDecl;
3821 return CXCursor_ClassDecl;
3823 return CXCursor_UnionDecl;
3825 return CXCursor_EnumDecl;
3830 return CXCursor_UnexposedDecl;
3833 static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results,
3834 bool LoadExternal, bool IncludeUndefined,
3835 bool TargetTypeIsPointer = false) {
3836 typedef CodeCompletionResult Result;
3838 Results.EnterNewScope();
3840 for (Preprocessor::macro_iterator M = PP.macro_begin(LoadExternal),
3841 MEnd = PP.macro_end(LoadExternal);
3843 auto MD = PP.getMacroDefinition(M->first);
3844 if (IncludeUndefined || MD) {
3845 MacroInfo *MI = MD.getMacroInfo();
3846 if (MI && MI->isUsedForHeaderGuard())
3850 Result(M->first, MI,
3851 getMacroUsagePriority(M->first->getName(), PP.getLangOpts(),
3852 TargetTypeIsPointer)));
3856 Results.ExitScope();
3859 static void AddPrettyFunctionResults(const LangOptions &LangOpts,
3860 ResultBuilder &Results) {
3861 typedef CodeCompletionResult Result;
3863 Results.EnterNewScope();
3865 Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant));
3866 Results.AddResult(Result("__FUNCTION__", CCP_Constant));
3867 if (LangOpts.C99 || LangOpts.CPlusPlus11)
3868 Results.AddResult(Result("__func__", CCP_Constant));
3869 Results.ExitScope();
3872 static void HandleCodeCompleteResults(Sema *S,
3873 CodeCompleteConsumer *CodeCompleter,
3874 CodeCompletionContext Context,
3875 CodeCompletionResult *Results,
3876 unsigned NumResults) {
3878 CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults);
3881 static CodeCompletionContext
3882 mapCodeCompletionContext(Sema &S, Sema::ParserCompletionContext PCC) {
3884 case Sema::PCC_Namespace:
3885 return CodeCompletionContext::CCC_TopLevel;
3887 case Sema::PCC_Class:
3888 return CodeCompletionContext::CCC_ClassStructUnion;
3890 case Sema::PCC_ObjCInterface:
3891 return CodeCompletionContext::CCC_ObjCInterface;
3893 case Sema::PCC_ObjCImplementation:
3894 return CodeCompletionContext::CCC_ObjCImplementation;
3896 case Sema::PCC_ObjCInstanceVariableList:
3897 return CodeCompletionContext::CCC_ObjCIvarList;
3899 case Sema::PCC_Template:
3900 case Sema::PCC_MemberTemplate:
3901 if (S.CurContext->isFileContext())
3902 return CodeCompletionContext::CCC_TopLevel;
3903 if (S.CurContext->isRecord())
3904 return CodeCompletionContext::CCC_ClassStructUnion;
3905 return CodeCompletionContext::CCC_Other;
3907 case Sema::PCC_RecoveryInFunction:
3908 return CodeCompletionContext::CCC_Recovery;
3910 case Sema::PCC_ForInit:
3911 if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 ||
3912 S.getLangOpts().ObjC)
3913 return CodeCompletionContext::CCC_ParenthesizedExpression;
3915 return CodeCompletionContext::CCC_Expression;
3917 case Sema::PCC_Expression:
3918 return CodeCompletionContext::CCC_Expression;
3919 case Sema::PCC_Condition:
3920 return CodeCompletionContext(CodeCompletionContext::CCC_Expression,
3921 S.getASTContext().BoolTy);
3923 case Sema::PCC_Statement:
3924 return CodeCompletionContext::CCC_Statement;
3926 case Sema::PCC_Type:
3927 return CodeCompletionContext::CCC_Type;
3929 case Sema::PCC_ParenthesizedExpression:
3930 return CodeCompletionContext::CCC_ParenthesizedExpression;
3932 case Sema::PCC_LocalDeclarationSpecifiers:
3933 return CodeCompletionContext::CCC_Type;
3936 llvm_unreachable("Invalid ParserCompletionContext!");
3939 /// If we're in a C++ virtual member function, add completion results
3940 /// that invoke the functions we override, since it's common to invoke the
3941 /// overridden function as well as adding new functionality.
3943 /// \param S The semantic analysis object for which we are generating results.
3945 /// \param InContext This context in which the nested-name-specifier preceding
3946 /// the code-completion point
3947 static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext,
3948 ResultBuilder &Results) {
3949 // Look through blocks.
3950 DeclContext *CurContext = S.CurContext;
3951 while (isa<BlockDecl>(CurContext))
3952 CurContext = CurContext->getParent();
3954 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext);
3955 if (!Method || !Method->isVirtual())
3958 // We need to have names for all of the parameters, if we're going to
3959 // generate a forwarding call.
3960 for (auto P : Method->parameters())
3961 if (!P->getDeclName())
3964 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
3965 for (const CXXMethodDecl *Overridden : Method->overridden_methods()) {
3966 CodeCompletionBuilder Builder(Results.getAllocator(),
3967 Results.getCodeCompletionTUInfo());
3968 if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl())
3971 // If we need a nested-name-specifier, add one now.
3973 NestedNameSpecifier *NNS = getRequiredQualification(
3974 S.Context, CurContext, Overridden->getDeclContext());
3977 llvm::raw_string_ostream OS(Str);
3978 NNS->print(OS, Policy);
3979 Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
3981 } else if (!InContext->Equals(Overridden->getDeclContext()))
3984 Builder.AddTypedTextChunk(
3985 Results.getAllocator().CopyString(Overridden->getNameAsString()));
3986 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
3987 bool FirstParam = true;
3988 for (auto P : Method->parameters()) {
3992 Builder.AddChunk(CodeCompletionString::CK_Comma);
3994 Builder.AddPlaceholderChunk(
3995 Results.getAllocator().CopyString(P->getIdentifier()->getName()));
3997 Builder.AddChunk(CodeCompletionString::CK_RightParen);
3998 Results.AddResult(CodeCompletionResult(
3999 Builder.TakeString(), CCP_SuperCompletion, CXCursor_CXXMethod,
4000 CXAvailability_Available, Overridden));
4001 Results.Ignore(Overridden);
4005 void Sema::CodeCompleteModuleImport(SourceLocation ImportLoc,
4006 ModuleIdPath Path) {
4007 typedef CodeCompletionResult Result;
4008 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4009 CodeCompleter->getCodeCompletionTUInfo(),
4010 CodeCompletionContext::CCC_Other);
4011 Results.EnterNewScope();
4013 CodeCompletionAllocator &Allocator = Results.getAllocator();
4014 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
4015 typedef CodeCompletionResult Result;
4017 // Enumerate all top-level modules.
4018 SmallVector<Module *, 8> Modules;
4019 PP.getHeaderSearchInfo().collectAllModules(Modules);
4020 for (unsigned I = 0, N = Modules.size(); I != N; ++I) {
4021 Builder.AddTypedTextChunk(
4022 Builder.getAllocator().CopyString(Modules[I]->Name));
4023 Results.AddResult(Result(
4024 Builder.TakeString(), CCP_Declaration, CXCursor_ModuleImportDecl,
4025 Modules[I]->isAvailable() ? CXAvailability_Available
4026 : CXAvailability_NotAvailable));
4028 } else if (getLangOpts().Modules) {
4029 // Load the named module.
4031 PP.getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible,
4032 /*IsInclusionDirective=*/false);
4033 // Enumerate submodules.
4035 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
4036 SubEnd = Mod->submodule_end();
4037 Sub != SubEnd; ++Sub) {
4039 Builder.AddTypedTextChunk(
4040 Builder.getAllocator().CopyString((*Sub)->Name));
4041 Results.AddResult(Result(
4042 Builder.TakeString(), CCP_Declaration, CXCursor_ModuleImportDecl,
4043 (*Sub)->isAvailable() ? CXAvailability_Available
4044 : CXAvailability_NotAvailable));
4048 Results.ExitScope();
4049 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4050 Results.data(), Results.size());
4053 void Sema::CodeCompleteOrdinaryName(Scope *S,
4054 ParserCompletionContext CompletionContext) {
4055 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4056 CodeCompleter->getCodeCompletionTUInfo(),
4057 mapCodeCompletionContext(*this, CompletionContext));
4058 Results.EnterNewScope();
4060 // Determine how to filter results, e.g., so that the names of
4061 // values (functions, enumerators, function templates, etc.) are
4062 // only allowed where we can have an expression.
4063 switch (CompletionContext) {
4066 case PCC_ObjCInterface:
4067 case PCC_ObjCImplementation:
4068 case PCC_ObjCInstanceVariableList:
4070 case PCC_MemberTemplate:
4072 case PCC_LocalDeclarationSpecifiers:
4073 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
4077 case PCC_ParenthesizedExpression:
4078 case PCC_Expression:
4081 if (WantTypesInContext(CompletionContext, getLangOpts()))
4082 Results.setFilter(&ResultBuilder::IsOrdinaryName);
4084 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
4086 if (getLangOpts().CPlusPlus)
4087 MaybeAddOverrideCalls(*this, /*InContext=*/nullptr, Results);
4090 case PCC_RecoveryInFunction:
4095 // If we are in a C++ non-static member function, check the qualifiers on
4096 // the member function to filter/prioritize the results list.
4097 auto ThisType = getCurrentThisType();
4098 if (!ThisType.isNull())
4099 Results.setObjectTypeQualifiers(ThisType->getPointeeType().getQualifiers(),
4102 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4103 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4104 CodeCompleter->includeGlobals(),
4105 CodeCompleter->loadExternal());
4107 AddOrdinaryNameResults(CompletionContext, S, *this, Results);
4108 Results.ExitScope();
4110 switch (CompletionContext) {
4111 case PCC_ParenthesizedExpression:
4112 case PCC_Expression:
4114 case PCC_RecoveryInFunction:
4115 if (S->getFnParent())
4116 AddPrettyFunctionResults(getLangOpts(), Results);
4121 case PCC_ObjCInterface:
4122 case PCC_ObjCImplementation:
4123 case PCC_ObjCInstanceVariableList:
4125 case PCC_MemberTemplate:
4129 case PCC_LocalDeclarationSpecifiers:
4133 if (CodeCompleter->includeMacros())
4134 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false);
4136 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4137 Results.data(), Results.size());
4140 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
4141 ParsedType Receiver,
4142 ArrayRef<IdentifierInfo *> SelIdents,
4143 bool AtArgumentExpression, bool IsSuper,
4144 ResultBuilder &Results);
4146 void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
4147 bool AllowNonIdentifiers,
4148 bool AllowNestedNameSpecifiers) {
4149 typedef CodeCompletionResult Result;
4150 ResultBuilder Results(
4151 *this, CodeCompleter->getAllocator(),
4152 CodeCompleter->getCodeCompletionTUInfo(),
4153 AllowNestedNameSpecifiers
4154 // FIXME: Try to separate codepath leading here to deduce whether we
4155 // need an existing symbol or a new one.
4156 ? CodeCompletionContext::CCC_SymbolOrNewName
4157 : CodeCompletionContext::CCC_NewName);
4158 Results.EnterNewScope();
4160 // Type qualifiers can come after names.
4161 Results.AddResult(Result("const"));
4162 Results.AddResult(Result("volatile"));
4163 if (getLangOpts().C99)
4164 Results.AddResult(Result("restrict"));
4166 if (getLangOpts().CPlusPlus) {
4167 if (getLangOpts().CPlusPlus11 &&
4168 (DS.getTypeSpecType() == DeclSpec::TST_class ||
4169 DS.getTypeSpecType() == DeclSpec::TST_struct))
4170 Results.AddResult("final");
4172 if (AllowNonIdentifiers) {
4173 Results.AddResult(Result("operator"));
4176 // Add nested-name-specifiers.
4177 if (AllowNestedNameSpecifiers) {
4178 Results.allowNestedNameSpecifiers();
4179 Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy);
4180 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4181 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
4182 CodeCompleter->includeGlobals(),
4183 CodeCompleter->loadExternal());
4184 Results.setFilter(nullptr);
4187 Results.ExitScope();
4189 // If we're in a context where we might have an expression (rather than a
4190 // declaration), and what we've seen so far is an Objective-C type that could
4191 // be a receiver of a class message, this may be a class message send with
4192 // the initial opening bracket '[' missing. Add appropriate completions.
4193 if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
4194 DS.getParsedSpecifiers() == DeclSpec::PQ_TypeSpecifier &&
4195 DS.getTypeSpecType() == DeclSpec::TST_typename &&
4196 DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified &&
4197 DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
4198 !DS.isTypeAltiVecVector() && S &&
4199 (S->getFlags() & Scope::DeclScope) != 0 &&
4200 (S->getFlags() & (Scope::ClassScope | Scope::TemplateParamScope |
4201 Scope::FunctionPrototypeScope | Scope::AtCatchScope)) ==
4203 ParsedType T = DS.getRepAsType();
4204 if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType())
4205 AddClassMessageCompletions(*this, S, T, None, false, false, Results);
4208 // Note that we intentionally suppress macro results here, since we do not
4209 // encourage using macros to produce the names of entities.
4211 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4212 Results.data(), Results.size());
4215 struct Sema::CodeCompleteExpressionData {
4216 CodeCompleteExpressionData(QualType PreferredType = QualType(),
4217 bool IsParenthesized = false)
4218 : PreferredType(PreferredType), IntegralConstantExpression(false),
4219 ObjCCollection(false), IsParenthesized(IsParenthesized) {}
4221 QualType PreferredType;
4222 bool IntegralConstantExpression;
4223 bool ObjCCollection;
4224 bool IsParenthesized;
4225 SmallVector<Decl *, 4> IgnoreDecls;
4229 /// Information that allows to avoid completing redundant enumerators.
4230 struct CoveredEnumerators {
4231 llvm::SmallPtrSet<EnumConstantDecl *, 8> Seen;
4232 NestedNameSpecifier *SuggestedQualifier = nullptr;
4236 static void AddEnumerators(ResultBuilder &Results, ASTContext &Context,
4237 EnumDecl *Enum, DeclContext *CurContext,
4238 const CoveredEnumerators &Enumerators) {
4239 NestedNameSpecifier *Qualifier = Enumerators.SuggestedQualifier;
4240 if (Context.getLangOpts().CPlusPlus && !Qualifier && Enumerators.Seen.empty()) {
4241 // If there are no prior enumerators in C++, check whether we have to
4242 // qualify the names of the enumerators that we suggest, because they
4243 // may not be visible in this scope.
4244 Qualifier = getRequiredQualification(Context, CurContext, Enum);
4247 Results.EnterNewScope();
4248 for (auto *E : Enum->enumerators()) {
4249 if (Enumerators.Seen.count(E))
4252 CodeCompletionResult R(E, CCP_EnumInCase, Qualifier);
4253 Results.AddResult(R, CurContext, nullptr, false);
4255 Results.ExitScope();
4258 /// Try to find a corresponding FunctionProtoType for function-like types (e.g.
4259 /// function pointers, std::function, etc).
4260 static const FunctionProtoType *TryDeconstructFunctionLike(QualType T) {
4261 assert(!T.isNull());
4262 // Try to extract first template argument from std::function<> and similar.
4263 // Note we only handle the sugared types, they closely match what users wrote.
4264 // We explicitly choose to not handle ClassTemplateSpecializationDecl.
4265 if (auto *Specialization = T->getAs<TemplateSpecializationType>()) {
4266 if (Specialization->getNumArgs() != 1)
4268 const TemplateArgument &Argument = Specialization->getArg(0);
4269 if (Argument.getKind() != TemplateArgument::Type)
4271 return Argument.getAsType()->getAs<FunctionProtoType>();
4273 // Handle other cases.
4274 if (T->isPointerType())
4275 T = T->getPointeeType();
4276 return T->getAs<FunctionProtoType>();
4279 /// Adds a pattern completion for a lambda expression with the specified
4280 /// parameter types and placeholders for parameter names.
4281 static void AddLambdaCompletion(ResultBuilder &Results,
4282 llvm::ArrayRef<QualType> Parameters,
4283 const LangOptions &LangOpts) {
4284 if (!Results.includeCodePatterns())
4286 CodeCompletionBuilder Completion(Results.getAllocator(),
4287 Results.getCodeCompletionTUInfo());
4288 // [](<parameters>) {}
4289 Completion.AddChunk(CodeCompletionString::CK_LeftBracket);
4290 Completion.AddPlaceholderChunk("=");
4291 Completion.AddChunk(CodeCompletionString::CK_RightBracket);
4292 if (!Parameters.empty()) {
4293 Completion.AddChunk(CodeCompletionString::CK_LeftParen);
4295 for (auto Parameter : Parameters) {
4297 Completion.AddChunk(CodeCompletionString::ChunkKind::CK_Comma);
4301 constexpr llvm::StringLiteral NamePlaceholder = "!#!NAME_GOES_HERE!#!";
4302 std::string Type = NamePlaceholder;
4303 Parameter.getAsStringInternal(Type, PrintingPolicy(LangOpts));
4304 llvm::StringRef Prefix, Suffix;
4305 std::tie(Prefix, Suffix) = llvm::StringRef(Type).split(NamePlaceholder);
4306 Prefix = Prefix.rtrim();
4307 Suffix = Suffix.ltrim();
4309 Completion.AddTextChunk(Completion.getAllocator().CopyString(Prefix));
4310 Completion.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4311 Completion.AddPlaceholderChunk("parameter");
4312 Completion.AddTextChunk(Completion.getAllocator().CopyString(Suffix));
4314 Completion.AddChunk(CodeCompletionString::CK_RightParen);
4316 Completion.AddChunk(clang::CodeCompletionString::CK_HorizontalSpace);
4317 Completion.AddChunk(CodeCompletionString::CK_LeftBrace);
4318 Completion.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4319 Completion.AddPlaceholderChunk("body");
4320 Completion.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4321 Completion.AddChunk(CodeCompletionString::CK_RightBrace);
4323 Results.AddResult(Completion.TakeString());
4326 /// Perform code-completion in an expression context when we know what
4327 /// type we're looking for.
4328 void Sema::CodeCompleteExpression(Scope *S,
4329 const CodeCompleteExpressionData &Data) {
4330 ResultBuilder Results(
4331 *this, CodeCompleter->getAllocator(),
4332 CodeCompleter->getCodeCompletionTUInfo(),
4333 CodeCompletionContext(
4334 Data.IsParenthesized
4335 ? CodeCompletionContext::CCC_ParenthesizedExpression
4336 : CodeCompletionContext::CCC_Expression,
4337 Data.PreferredType));
4339 Data.IsParenthesized ? PCC_ParenthesizedExpression : PCC_Expression;
4340 if (Data.ObjCCollection)
4341 Results.setFilter(&ResultBuilder::IsObjCCollection);
4342 else if (Data.IntegralConstantExpression)
4343 Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
4344 else if (WantTypesInContext(PCC, getLangOpts()))
4345 Results.setFilter(&ResultBuilder::IsOrdinaryName);
4347 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
4349 if (!Data.PreferredType.isNull())
4350 Results.setPreferredType(Data.PreferredType.getNonReferenceType());
4352 // Ignore any declarations that we were told that we don't care about.
4353 for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I)
4354 Results.Ignore(Data.IgnoreDecls[I]);
4356 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4357 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4358 CodeCompleter->includeGlobals(),
4359 CodeCompleter->loadExternal());
4361 Results.EnterNewScope();
4362 AddOrdinaryNameResults(PCC, S, *this, Results);
4363 Results.ExitScope();
4365 bool PreferredTypeIsPointer = false;
4366 if (!Data.PreferredType.isNull()) {
4367 PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType() ||
4368 Data.PreferredType->isMemberPointerType() ||
4369 Data.PreferredType->isBlockPointerType();
4370 if (Data.PreferredType->isEnumeralType()) {
4371 EnumDecl *Enum = Data.PreferredType->castAs<EnumType>()->getDecl();
4372 if (auto *Def = Enum->getDefinition())
4374 // FIXME: collect covered enumerators in cases like:
4375 // if (x == my_enum::one) { ... } else if (x == ^) {}
4376 AddEnumerators(Results, Context, Enum, CurContext, CoveredEnumerators());
4380 if (S->getFnParent() && !Data.ObjCCollection &&
4381 !Data.IntegralConstantExpression)
4382 AddPrettyFunctionResults(getLangOpts(), Results);
4384 if (CodeCompleter->includeMacros())
4385 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false,
4386 PreferredTypeIsPointer);
4388 // Complete a lambda expression when preferred type is a function.
4389 if (!Data.PreferredType.isNull() && getLangOpts().CPlusPlus11) {
4390 if (const FunctionProtoType *F =
4391 TryDeconstructFunctionLike(Data.PreferredType))
4392 AddLambdaCompletion(Results, F->getParamTypes(), getLangOpts());
4395 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4396 Results.data(), Results.size());
4399 void Sema::CodeCompleteExpression(Scope *S, QualType PreferredType,
4400 bool IsParenthesized) {
4401 return CodeCompleteExpression(
4402 S, CodeCompleteExpressionData(PreferredType, IsParenthesized));
4405 void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E,
4406 QualType PreferredType) {
4408 CodeCompleteExpression(S, PreferredType);
4409 else if (getLangOpts().ObjC)
4410 CodeCompleteObjCInstanceMessage(S, E.get(), None, false);
4413 /// The set of properties that have already been added, referenced by
4415 typedef llvm::SmallPtrSet<IdentifierInfo *, 16> AddedPropertiesSet;
4417 /// Retrieve the container definition, if any?
4418 static ObjCContainerDecl *getContainerDef(ObjCContainerDecl *Container) {
4419 if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
4420 if (Interface->hasDefinition())
4421 return Interface->getDefinition();
4426 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
4427 if (Protocol->hasDefinition())
4428 return Protocol->getDefinition();
4435 /// Adds a block invocation code completion result for the given block
4436 /// declaration \p BD.
4437 static void AddObjCBlockCall(ASTContext &Context, const PrintingPolicy &Policy,
4438 CodeCompletionBuilder &Builder,
4439 const NamedDecl *BD,
4440 const FunctionTypeLoc &BlockLoc,
4441 const FunctionProtoTypeLoc &BlockProtoLoc) {
4442 Builder.AddResultTypeChunk(
4443 GetCompletionTypeString(BlockLoc.getReturnLoc().getType(), Context,
4444 Policy, Builder.getAllocator()));
4446 AddTypedNameChunk(Context, Policy, BD, Builder);
4447 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4449 if (BlockProtoLoc && BlockProtoLoc.getTypePtr()->isVariadic()) {
4450 Builder.AddPlaceholderChunk("...");
4452 for (unsigned I = 0, N = BlockLoc.getNumParams(); I != N; ++I) {
4454 Builder.AddChunk(CodeCompletionString::CK_Comma);
4456 // Format the placeholder string.
4457 std::string PlaceholderStr =
4458 FormatFunctionParameter(Policy, BlockLoc.getParam(I));
4460 if (I == N - 1 && BlockProtoLoc &&
4461 BlockProtoLoc.getTypePtr()->isVariadic())
4462 PlaceholderStr += ", ...";
4464 // Add the placeholder string.
4465 Builder.AddPlaceholderChunk(
4466 Builder.getAllocator().CopyString(PlaceholderStr));
4470 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4474 AddObjCProperties(const CodeCompletionContext &CCContext,
4475 ObjCContainerDecl *Container, bool AllowCategories,
4476 bool AllowNullaryMethods, DeclContext *CurContext,
4477 AddedPropertiesSet &AddedProperties, ResultBuilder &Results,
4478 bool IsBaseExprStatement = false,
4479 bool IsClassProperty = false, bool InOriginalClass = true) {
4480 typedef CodeCompletionResult Result;
4482 // Retrieve the definition.
4483 Container = getContainerDef(Container);
4485 // Add properties in this container.
4486 const auto AddProperty = [&](const ObjCPropertyDecl *P) {
4487 if (!AddedProperties.insert(P->getIdentifier()).second)
4490 // FIXME: Provide block invocation completion for non-statement
4492 if (!P->getType().getTypePtr()->isBlockPointerType() ||
4493 !IsBaseExprStatement) {
4494 Result R = Result(P, Results.getBasePriority(P), nullptr);
4495 if (!InOriginalClass)
4497 Results.MaybeAddResult(R, CurContext);
4501 // Block setter and invocation completion is provided only when we are able
4502 // to find the FunctionProtoTypeLoc with parameter names for the block.
4503 FunctionTypeLoc BlockLoc;
4504 FunctionProtoTypeLoc BlockProtoLoc;
4505 findTypeLocationForBlockDecl(P->getTypeSourceInfo(), BlockLoc,
4508 Result R = Result(P, Results.getBasePriority(P), nullptr);
4509 if (!InOriginalClass)
4511 Results.MaybeAddResult(R, CurContext);
4515 // The default completion result for block properties should be the block
4516 // invocation completion when the base expression is a statement.
4517 CodeCompletionBuilder Builder(Results.getAllocator(),
4518 Results.getCodeCompletionTUInfo());
4519 AddObjCBlockCall(Container->getASTContext(),
4520 getCompletionPrintingPolicy(Results.getSema()), Builder, P,
4521 BlockLoc, BlockProtoLoc);
4522 Result R = Result(Builder.TakeString(), P, Results.getBasePriority(P));
4523 if (!InOriginalClass)
4525 Results.MaybeAddResult(R, CurContext);
4527 // Provide additional block setter completion iff the base expression is a
4528 // statement and the block property is mutable.
4529 if (!P->isReadOnly()) {
4530 CodeCompletionBuilder Builder(Results.getAllocator(),
4531 Results.getCodeCompletionTUInfo());
4532 AddResultTypeChunk(Container->getASTContext(),
4533 getCompletionPrintingPolicy(Results.getSema()), P,
4534 CCContext.getBaseType(), Builder);
4535 Builder.AddTypedTextChunk(
4536 Results.getAllocator().CopyString(P->getName()));
4537 Builder.AddChunk(CodeCompletionString::CK_Equal);
4539 std::string PlaceholderStr = formatBlockPlaceholder(
4540 getCompletionPrintingPolicy(Results.getSema()), P, BlockLoc,
4541 BlockProtoLoc, /*SuppressBlockName=*/true);
4542 // Add the placeholder string.
4543 Builder.AddPlaceholderChunk(
4544 Builder.getAllocator().CopyString(PlaceholderStr));
4546 // When completing blocks properties that return void the default
4547 // property completion result should show up before the setter,
4548 // otherwise the setter completion should show up before the default
4549 // property completion, as we normally want to use the result of the
4552 Result(Builder.TakeString(), P,
4553 Results.getBasePriority(P) +
4554 (BlockLoc.getTypePtr()->getReturnType()->isVoidType()
4555 ? CCD_BlockPropertySetter
4556 : -CCD_BlockPropertySetter));
4557 if (!InOriginalClass)
4559 Results.MaybeAddResult(R, CurContext);
4563 if (IsClassProperty) {
4564 for (const auto *P : Container->class_properties())
4567 for (const auto *P : Container->instance_properties())
4571 // Add nullary methods or implicit class properties
4572 if (AllowNullaryMethods) {
4573 ASTContext &Context = Container->getASTContext();
4574 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
4575 // Adds a method result
4576 const auto AddMethod = [&](const ObjCMethodDecl *M) {
4577 IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0);
4580 if (!AddedProperties.insert(Name).second)
4582 CodeCompletionBuilder Builder(Results.getAllocator(),
4583 Results.getCodeCompletionTUInfo());
4584 AddResultTypeChunk(Context, Policy, M, CCContext.getBaseType(), Builder);
4585 Builder.AddTypedTextChunk(
4586 Results.getAllocator().CopyString(Name->getName()));
4587 Result R = Result(Builder.TakeString(), M,
4588 CCP_MemberDeclaration + CCD_MethodAsProperty);
4589 if (!InOriginalClass)
4591 Results.MaybeAddResult(R, CurContext);
4594 if (IsClassProperty) {
4595 for (const auto *M : Container->methods()) {
4596 // Gather the class method that can be used as implicit property
4597 // getters. Methods with arguments or methods that return void aren't
4598 // added to the results as they can't be used as a getter.
4599 if (!M->getSelector().isUnarySelector() ||
4600 M->getReturnType()->isVoidType() || M->isInstanceMethod())
4605 for (auto *M : Container->methods()) {
4606 if (M->getSelector().isUnarySelector())
4612 // Add properties in referenced protocols.
4613 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
4614 for (auto *P : Protocol->protocols())
4615 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
4616 CurContext, AddedProperties, Results,
4617 IsBaseExprStatement, IsClassProperty,
4618 /*InOriginalClass*/ false);
4619 } else if (ObjCInterfaceDecl *IFace =
4620 dyn_cast<ObjCInterfaceDecl>(Container)) {
4621 if (AllowCategories) {
4622 // Look through categories.
4623 for (auto *Cat : IFace->known_categories())
4624 AddObjCProperties(CCContext, Cat, AllowCategories, AllowNullaryMethods,
4625 CurContext, AddedProperties, Results,
4626 IsBaseExprStatement, IsClassProperty,
4630 // Look through protocols.
4631 for (auto *I : IFace->all_referenced_protocols())
4632 AddObjCProperties(CCContext, I, AllowCategories, AllowNullaryMethods,
4633 CurContext, AddedProperties, Results,
4634 IsBaseExprStatement, IsClassProperty,
4635 /*InOriginalClass*/ false);
4637 // Look in the superclass.
4638 if (IFace->getSuperClass())
4639 AddObjCProperties(CCContext, IFace->getSuperClass(), AllowCategories,
4640 AllowNullaryMethods, CurContext, AddedProperties,
4641 Results, IsBaseExprStatement, IsClassProperty,
4642 /*InOriginalClass*/ false);
4643 } else if (const auto *Category =
4644 dyn_cast<ObjCCategoryDecl>(Container)) {
4645 // Look through protocols.
4646 for (auto *P : Category->protocols())
4647 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
4648 CurContext, AddedProperties, Results,
4649 IsBaseExprStatement, IsClassProperty,
4650 /*InOriginalClass*/ false);
4654 static void AddRecordMembersCompletionResults(
4655 Sema &SemaRef, ResultBuilder &Results, Scope *S, QualType BaseType,
4656 ExprValueKind BaseKind, RecordDecl *RD, Optional<FixItHint> AccessOpFixIt) {
4657 // Indicate that we are performing a member access, and the cv-qualifiers
4658 // for the base object type.
4659 Results.setObjectTypeQualifiers(BaseType.getQualifiers(), BaseKind);
4661 // Access to a C/C++ class, struct, or union.
4662 Results.allowNestedNameSpecifiers();
4663 std::vector<FixItHint> FixIts;
4665 FixIts.emplace_back(AccessOpFixIt.getValue());
4666 CodeCompletionDeclConsumer Consumer(Results, RD, BaseType, std::move(FixIts));
4667 SemaRef.LookupVisibleDecls(RD, Sema::LookupMemberName, Consumer,
4668 SemaRef.CodeCompleter->includeGlobals(),
4669 /*IncludeDependentBases=*/true,
4670 SemaRef.CodeCompleter->loadExternal());
4672 if (SemaRef.getLangOpts().CPlusPlus) {
4673 if (!Results.empty()) {
4674 // The "template" keyword can follow "->" or "." in the grammar.
4675 // However, we only want to suggest the template keyword if something
4677 bool IsDependent = BaseType->isDependentType();
4679 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent())
4680 if (DeclContext *Ctx = DepScope->getEntity()) {
4681 IsDependent = Ctx->isDependentContext();
4687 Results.AddResult(CodeCompletionResult("template"));
4692 void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
4694 SourceLocation OpLoc, bool IsArrow,
4695 bool IsBaseExprStatement,
4696 QualType PreferredType) {
4697 if (!Base || !CodeCompleter)
4700 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
4701 if (ConvertedBase.isInvalid())
4703 QualType ConvertedBaseType = ConvertedBase.get()->getType();
4705 enum CodeCompletionContext::Kind contextKind;
4708 if (const auto *Ptr = ConvertedBaseType->getAs<PointerType>())
4709 ConvertedBaseType = Ptr->getPointeeType();
4713 contextKind = CodeCompletionContext::CCC_ArrowMemberAccess;
4715 if (ConvertedBaseType->isObjCObjectPointerType() ||
4716 ConvertedBaseType->isObjCObjectOrInterfaceType()) {
4717 contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess;
4719 contextKind = CodeCompletionContext::CCC_DotMemberAccess;
4723 CodeCompletionContext CCContext(contextKind, ConvertedBaseType);
4724 CCContext.setPreferredType(PreferredType);
4725 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4726 CodeCompleter->getCodeCompletionTUInfo(), CCContext,
4727 &ResultBuilder::IsMember);
4729 auto DoCompletion = [&](Expr *Base, bool IsArrow,
4730 Optional<FixItHint> AccessOpFixIt) -> bool {
4734 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
4735 if (ConvertedBase.isInvalid())
4737 Base = ConvertedBase.get();
4739 QualType BaseType = Base->getType();
4740 ExprValueKind BaseKind = Base->getValueKind();
4743 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
4744 BaseType = Ptr->getPointeeType();
4745 BaseKind = VK_LValue;
4746 } else if (BaseType->isObjCObjectPointerType())
4752 if (const RecordType *Record = BaseType->getAs<RecordType>()) {
4753 AddRecordMembersCompletionResults(*this, Results, S, BaseType, BaseKind,
4755 std::move(AccessOpFixIt));
4756 } else if (const auto *TST =
4757 BaseType->getAs<TemplateSpecializationType>()) {
4758 TemplateName TN = TST->getTemplateName();
4759 if (const auto *TD =
4760 dyn_cast_or_null<ClassTemplateDecl>(TN.getAsTemplateDecl())) {
4761 CXXRecordDecl *RD = TD->getTemplatedDecl();
4762 AddRecordMembersCompletionResults(*this, Results, S, BaseType, BaseKind,
4763 RD, std::move(AccessOpFixIt));
4765 } else if (const auto *ICNT = BaseType->getAs<InjectedClassNameType>()) {
4766 if (auto *RD = ICNT->getDecl())
4767 AddRecordMembersCompletionResults(*this, Results, S, BaseType, BaseKind,
4768 RD, std::move(AccessOpFixIt));
4769 } else if (!IsArrow && BaseType->isObjCObjectPointerType()) {
4770 // Objective-C property reference.
4771 AddedPropertiesSet AddedProperties;
4773 if (const ObjCObjectPointerType *ObjCPtr =
4774 BaseType->getAsObjCInterfacePointerType()) {
4775 // Add property results based on our interface.
4776 assert(ObjCPtr && "Non-NULL pointer guaranteed above!");
4777 AddObjCProperties(CCContext, ObjCPtr->getInterfaceDecl(), true,
4778 /*AllowNullaryMethods=*/true, CurContext,
4779 AddedProperties, Results, IsBaseExprStatement);
4782 // Add properties from the protocols in a qualified interface.
4783 for (auto *I : BaseType->getAs<ObjCObjectPointerType>()->quals())
4784 AddObjCProperties(CCContext, I, true, /*AllowNullaryMethods=*/true,
4785 CurContext, AddedProperties, Results,
4786 IsBaseExprStatement, /*IsClassProperty*/ false,
4787 /*InOriginalClass*/ false);
4788 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) ||
4789 (!IsArrow && BaseType->isObjCObjectType())) {
4790 // Objective-C instance variable access.
4791 ObjCInterfaceDecl *Class = nullptr;
4792 if (const ObjCObjectPointerType *ObjCPtr =
4793 BaseType->getAs<ObjCObjectPointerType>())
4794 Class = ObjCPtr->getInterfaceDecl();
4796 Class = BaseType->getAs<ObjCObjectType>()->getInterface();
4798 // Add all ivars from this class and its superclasses.
4800 CodeCompletionDeclConsumer Consumer(Results, Class, BaseType);
4801 Results.setFilter(&ResultBuilder::IsObjCIvar);
4803 Class, LookupMemberName, Consumer, CodeCompleter->includeGlobals(),
4804 /*IncludeDependentBases=*/false, CodeCompleter->loadExternal());
4808 // FIXME: How do we cope with isa?
4812 Results.EnterNewScope();
4814 bool CompletionSucceded = DoCompletion(Base, IsArrow, None);
4815 if (CodeCompleter->includeFixIts()) {
4816 const CharSourceRange OpRange =
4817 CharSourceRange::getTokenRange(OpLoc, OpLoc);
4818 CompletionSucceded |= DoCompletion(
4819 OtherOpBase, !IsArrow,
4820 FixItHint::CreateReplacement(OpRange, IsArrow ? "." : "->"));
4823 Results.ExitScope();
4825 if (!CompletionSucceded)
4828 // Hand off the results found for code completion.
4829 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4830 Results.data(), Results.size());
4833 void Sema::CodeCompleteObjCClassPropertyRefExpr(Scope *S,
4834 IdentifierInfo &ClassName,
4835 SourceLocation ClassNameLoc,
4836 bool IsBaseExprStatement) {
4837 IdentifierInfo *ClassNamePtr = &ClassName;
4838 ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(ClassNamePtr, ClassNameLoc);
4841 CodeCompletionContext CCContext(
4842 CodeCompletionContext::CCC_ObjCPropertyAccess);
4843 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4844 CodeCompleter->getCodeCompletionTUInfo(), CCContext,
4845 &ResultBuilder::IsMember);
4846 Results.EnterNewScope();
4847 AddedPropertiesSet AddedProperties;
4848 AddObjCProperties(CCContext, IFace, true,
4849 /*AllowNullaryMethods=*/true, CurContext, AddedProperties,
4850 Results, IsBaseExprStatement,
4851 /*IsClassProperty=*/true);
4852 Results.ExitScope();
4853 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4854 Results.data(), Results.size());
4857 void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) {
4861 ResultBuilder::LookupFilter Filter = nullptr;
4862 enum CodeCompletionContext::Kind ContextKind =
4863 CodeCompletionContext::CCC_Other;
4864 switch ((DeclSpec::TST)TagSpec) {
4865 case DeclSpec::TST_enum:
4866 Filter = &ResultBuilder::IsEnum;
4867 ContextKind = CodeCompletionContext::CCC_EnumTag;
4870 case DeclSpec::TST_union:
4871 Filter = &ResultBuilder::IsUnion;
4872 ContextKind = CodeCompletionContext::CCC_UnionTag;
4875 case DeclSpec::TST_struct:
4876 case DeclSpec::TST_class:
4877 case DeclSpec::TST_interface:
4878 Filter = &ResultBuilder::IsClassOrStruct;
4879 ContextKind = CodeCompletionContext::CCC_ClassOrStructTag;
4883 llvm_unreachable("Unknown type specifier kind in CodeCompleteTag");
4886 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4887 CodeCompleter->getCodeCompletionTUInfo(), ContextKind);
4888 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4890 // First pass: look for tags.
4891 Results.setFilter(Filter);
4892 LookupVisibleDecls(S, LookupTagName, Consumer,
4893 CodeCompleter->includeGlobals(),
4894 CodeCompleter->loadExternal());
4896 if (CodeCompleter->includeGlobals()) {
4897 // Second pass: look for nested name specifiers.
4898 Results.setFilter(&ResultBuilder::IsNestedNameSpecifier);
4899 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
4900 CodeCompleter->includeGlobals(),
4901 CodeCompleter->loadExternal());
4904 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4905 Results.data(), Results.size());
4908 static void AddTypeQualifierResults(DeclSpec &DS, ResultBuilder &Results,
4909 const LangOptions &LangOpts) {
4910 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
4911 Results.AddResult("const");
4912 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile))
4913 Results.AddResult("volatile");
4914 if (LangOpts.C99 && !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict))
4915 Results.AddResult("restrict");
4916 if (LangOpts.C11 && !(DS.getTypeQualifiers() & DeclSpec::TQ_atomic))
4917 Results.AddResult("_Atomic");
4918 if (LangOpts.MSVCCompat && !(DS.getTypeQualifiers() & DeclSpec::TQ_unaligned))
4919 Results.AddResult("__unaligned");
4922 void Sema::CodeCompleteTypeQualifiers(DeclSpec &DS) {
4923 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4924 CodeCompleter->getCodeCompletionTUInfo(),
4925 CodeCompletionContext::CCC_TypeQualifiers);
4926 Results.EnterNewScope();
4927 AddTypeQualifierResults(DS, Results, LangOpts);
4928 Results.ExitScope();
4929 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4930 Results.data(), Results.size());
4933 void Sema::CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D,
4934 const VirtSpecifiers *VS) {
4935 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4936 CodeCompleter->getCodeCompletionTUInfo(),
4937 CodeCompletionContext::CCC_TypeQualifiers);
4938 Results.EnterNewScope();
4939 AddTypeQualifierResults(DS, Results, LangOpts);
4940 if (LangOpts.CPlusPlus11) {
4941 Results.AddResult("noexcept");
4942 if (D.getContext() == DeclaratorContext::MemberContext &&
4943 !D.isCtorOrDtor() && !D.isStaticMember()) {
4944 if (!VS || !VS->isFinalSpecified())
4945 Results.AddResult("final");
4946 if (!VS || !VS->isOverrideSpecified())
4947 Results.AddResult("override");
4950 Results.ExitScope();
4951 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4952 Results.data(), Results.size());
4955 void Sema::CodeCompleteBracketDeclarator(Scope *S) {
4956 CodeCompleteExpression(S, QualType(getASTContext().getSizeType()));
4959 void Sema::CodeCompleteCase(Scope *S) {
4960 if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
4963 SwitchStmt *Switch = getCurFunction()->SwitchStack.back().getPointer();
4964 // Condition expression might be invalid, do not continue in this case.
4965 if (!Switch->getCond())
4967 QualType type = Switch->getCond()->IgnoreImplicit()->getType();
4968 if (!type->isEnumeralType()) {
4969 CodeCompleteExpressionData Data(type);
4970 Data.IntegralConstantExpression = true;
4971 CodeCompleteExpression(S, Data);
4975 // Code-complete the cases of a switch statement over an enumeration type
4976 // by providing the list of
4977 EnumDecl *Enum = type->castAs<EnumType>()->getDecl();
4978 if (EnumDecl *Def = Enum->getDefinition())
4981 // Determine which enumerators we have already seen in the switch statement.
4982 // FIXME: Ideally, we would also be able to look *past* the code-completion
4983 // token, in case we are code-completing in the middle of the switch and not
4984 // at the end. However, we aren't able to do so at the moment.
4985 CoveredEnumerators Enumerators;
4986 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC;
4987 SC = SC->getNextSwitchCase()) {
4988 CaseStmt *Case = dyn_cast<CaseStmt>(SC);
4992 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
4993 if (auto *DRE = dyn_cast<DeclRefExpr>(CaseVal))
4994 if (auto *Enumerator =
4995 dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
4996 // We look into the AST of the case statement to determine which
4997 // enumerator was named. Alternatively, we could compute the value of
4998 // the integral constant expression, then compare it against the
4999 // values of each enumerator. However, value-based approach would not
5000 // work as well with C++ templates where enumerators declared within a
5001 // template are type- and value-dependent.
5002 Enumerators.Seen.insert(Enumerator);
5004 // If this is a qualified-id, keep track of the nested-name-specifier
5005 // so that we can reproduce it as part of code completion, e.g.,
5007 // switch (TagD.getKind()) {
5008 // case TagDecl::TK_enum:
5012 // At the XXX, our completions are TagDecl::TK_union,
5013 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union,
5014 // TK_struct, and TK_class.
5015 Enumerators.SuggestedQualifier = DRE->getQualifier();
5019 // Add any enumerators that have not yet been mentioned.
5020 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5021 CodeCompleter->getCodeCompletionTUInfo(),
5022 CodeCompletionContext::CCC_Expression);
5023 AddEnumerators(Results, Context, Enum, CurContext, Enumerators);
5025 if (CodeCompleter->includeMacros()) {
5026 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false);
5028 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5029 Results.data(), Results.size());
5032 static bool anyNullArguments(ArrayRef<Expr *> Args) {
5033 if (Args.size() && !Args.data())
5036 for (unsigned I = 0; I != Args.size(); ++I)
5043 typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate;
5045 static void mergeCandidatesWithResults(
5046 Sema &SemaRef, SmallVectorImpl<ResultCandidate> &Results,
5047 OverloadCandidateSet &CandidateSet, SourceLocation Loc) {
5048 // Sort the overload candidate set by placing the best overloads first.
5049 llvm::stable_sort(CandidateSet, [&](const OverloadCandidate &X,
5050 const OverloadCandidate &Y) {
5051 return isBetterOverloadCandidate(SemaRef, X, Y, Loc,
5052 CandidateSet.getKind());
5055 // Add the remaining viable overload candidates as code-completion results.
5056 for (OverloadCandidate &Candidate : CandidateSet) {
5057 if (Candidate.Function && Candidate.Function->isDeleted())
5059 if (Candidate.Viable)
5060 Results.push_back(ResultCandidate(Candidate.Function));
5064 /// Get the type of the Nth parameter from a given set of overload
5066 static QualType getParamType(Sema &SemaRef,
5067 ArrayRef<ResultCandidate> Candidates, unsigned N) {
5069 // Given the overloads 'Candidates' for a function call matching all arguments
5070 // up to N, return the type of the Nth parameter if it is the same for all
5071 // overload candidates.
5073 for (auto &Candidate : Candidates) {
5074 if (const auto *FType = Candidate.getFunctionType())
5075 if (const auto *Proto = dyn_cast<FunctionProtoType>(FType))
5076 if (N < Proto->getNumParams()) {
5077 if (ParamType.isNull())
5078 ParamType = Proto->getParamType(N);
5079 else if (!SemaRef.Context.hasSameUnqualifiedType(
5080 ParamType.getNonReferenceType(),
5081 Proto->getParamType(N).getNonReferenceType()))
5082 // Otherwise return a default-constructed QualType.
5091 ProduceSignatureHelp(Sema &SemaRef, Scope *S,
5092 MutableArrayRef<ResultCandidate> Candidates,
5093 unsigned CurrentArg, SourceLocation OpenParLoc) {
5094 if (Candidates.empty())
5096 SemaRef.CodeCompleter->ProcessOverloadCandidates(
5097 SemaRef, CurrentArg, Candidates.data(), Candidates.size(), OpenParLoc);
5098 return getParamType(SemaRef, Candidates, CurrentArg);
5101 QualType Sema::ProduceCallSignatureHelp(Scope *S, Expr *Fn,
5102 ArrayRef<Expr *> Args,
5103 SourceLocation OpenParLoc) {
5107 // FIXME: Provide support for variadic template functions.
5108 // Ignore type-dependent call expressions entirely.
5109 if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args) ||
5110 Expr::hasAnyTypeDependentArguments(Args)) {
5114 // Build an overload candidate set based on the functions we find.
5115 SourceLocation Loc = Fn->getExprLoc();
5116 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
5118 SmallVector<ResultCandidate, 8> Results;
5120 Expr *NakedFn = Fn->IgnoreParenCasts();
5121 if (auto ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn))
5122 AddOverloadedCallCandidates(ULE, Args, CandidateSet,
5123 /*PartialOverloading=*/true);
5124 else if (auto UME = dyn_cast<UnresolvedMemberExpr>(NakedFn)) {
5125 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
5126 if (UME->hasExplicitTemplateArgs()) {
5127 UME->copyTemplateArgumentsInto(TemplateArgsBuffer);
5128 TemplateArgs = &TemplateArgsBuffer;
5131 // Add the base as first argument (use a nullptr if the base is implicit).
5132 SmallVector<Expr *, 12> ArgExprs(
5133 1, UME->isImplicitAccess() ? nullptr : UME->getBase());
5134 ArgExprs.append(Args.begin(), Args.end());
5135 UnresolvedSet<8> Decls;
5136 Decls.append(UME->decls_begin(), UME->decls_end());
5137 const bool FirstArgumentIsBase = !UME->isImplicitAccess() && UME->getBase();
5138 AddFunctionCandidates(Decls, ArgExprs, CandidateSet, TemplateArgs,
5139 /*SuppressUserConversions=*/false,
5140 /*PartialOverloading=*/true, FirstArgumentIsBase);
5142 FunctionDecl *FD = nullptr;
5143 if (auto *MCE = dyn_cast<MemberExpr>(NakedFn))
5144 FD = dyn_cast<FunctionDecl>(MCE->getMemberDecl());
5145 else if (auto *DRE = dyn_cast<DeclRefExpr>(NakedFn))
5146 FD = dyn_cast<FunctionDecl>(DRE->getDecl());
5147 if (FD) { // We check whether it's a resolved function declaration.
5148 if (!getLangOpts().CPlusPlus ||
5149 !FD->getType()->getAs<FunctionProtoType>())
5150 Results.push_back(ResultCandidate(FD));
5152 AddOverloadCandidate(FD, DeclAccessPair::make(FD, FD->getAccess()),
5154 /*SuppressUserConversions=*/false,
5155 /*PartialOverloading=*/true);
5157 } else if (auto DC = NakedFn->getType()->getAsCXXRecordDecl()) {
5158 // If expression's type is CXXRecordDecl, it may overload the function
5159 // call operator, so we check if it does and add them as candidates.
5160 // A complete type is needed to lookup for member function call operators.
5161 if (isCompleteType(Loc, NakedFn->getType())) {
5162 DeclarationName OpName =
5163 Context.DeclarationNames.getCXXOperatorName(OO_Call);
5164 LookupResult R(*this, OpName, Loc, LookupOrdinaryName);
5165 LookupQualifiedName(R, DC);
5166 R.suppressDiagnostics();
5167 SmallVector<Expr *, 12> ArgExprs(1, NakedFn);
5168 ArgExprs.append(Args.begin(), Args.end());
5169 AddFunctionCandidates(R.asUnresolvedSet(), ArgExprs, CandidateSet,
5170 /*ExplicitArgs=*/nullptr,
5171 /*SuppressUserConversions=*/false,
5172 /*PartialOverloading=*/true);
5175 // Lastly we check whether expression's type is function pointer or
5177 QualType T = NakedFn->getType();
5178 if (!T->getPointeeType().isNull())
5179 T = T->getPointeeType();
5181 if (auto FP = T->getAs<FunctionProtoType>()) {
5182 if (!TooManyArguments(FP->getNumParams(), Args.size(),
5183 /*PartialOverloading=*/true) ||
5185 Results.push_back(ResultCandidate(FP));
5186 } else if (auto FT = T->getAs<FunctionType>())
5187 // No prototype and declaration, it may be a K & R style function.
5188 Results.push_back(ResultCandidate(FT));
5191 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
5192 QualType ParamType =
5193 ProduceSignatureHelp(*this, S, Results, Args.size(), OpenParLoc);
5194 return !CandidateSet.empty() ? ParamType : QualType();
5197 QualType Sema::ProduceConstructorSignatureHelp(Scope *S, QualType Type,
5199 ArrayRef<Expr *> Args,
5200 SourceLocation OpenParLoc) {
5204 // A complete type is needed to lookup for constructors.
5206 isCompleteType(Loc, Type) ? Type->getAsCXXRecordDecl() : nullptr;
5210 // FIXME: Provide support for member initializers.
5211 // FIXME: Provide support for variadic template constructors.
5213 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
5215 for (NamedDecl *C : LookupConstructors(RD)) {
5216 if (auto *FD = dyn_cast<FunctionDecl>(C)) {
5217 AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()), Args,
5219 /*SuppressUserConversions=*/false,
5220 /*PartialOverloading=*/true,
5221 /*AllowExplicit*/ true);
5222 } else if (auto *FTD = dyn_cast<FunctionTemplateDecl>(C)) {
5223 AddTemplateOverloadCandidate(
5224 FTD, DeclAccessPair::make(FTD, C->getAccess()),
5225 /*ExplicitTemplateArgs=*/nullptr, Args, CandidateSet,
5226 /*SuppressUserConversions=*/false,
5227 /*PartialOverloading=*/true);
5231 SmallVector<ResultCandidate, 8> Results;
5232 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
5233 return ProduceSignatureHelp(*this, S, Results, Args.size(), OpenParLoc);
5236 QualType Sema::ProduceCtorInitMemberSignatureHelp(
5237 Scope *S, Decl *ConstructorDecl, CXXScopeSpec SS, ParsedType TemplateTypeTy,
5238 ArrayRef<Expr *> ArgExprs, IdentifierInfo *II, SourceLocation OpenParLoc) {
5242 CXXConstructorDecl *Constructor =
5243 dyn_cast<CXXConstructorDecl>(ConstructorDecl);
5246 // FIXME: Add support for Base class constructors as well.
5247 if (ValueDecl *MemberDecl = tryLookupCtorInitMemberDecl(
5248 Constructor->getParent(), SS, TemplateTypeTy, II))
5249 return ProduceConstructorSignatureHelp(getCurScope(), MemberDecl->getType(),
5250 MemberDecl->getLocation(), ArgExprs,
5255 void Sema::CodeCompleteInitializer(Scope *S, Decl *D) {
5256 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D);
5258 CodeCompleteOrdinaryName(S, PCC_Expression);
5262 CodeCompleteExpressionData Data;
5263 Data.PreferredType = VD->getType();
5264 // Ignore VD to avoid completing the variable itself, e.g. in 'int foo = ^'.
5265 Data.IgnoreDecls.push_back(VD);
5267 CodeCompleteExpression(S, Data);
5270 void Sema::CodeCompleteAfterIf(Scope *S) {
5271 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5272 CodeCompleter->getCodeCompletionTUInfo(),
5273 mapCodeCompletionContext(*this, PCC_Statement));
5274 Results.setFilter(&ResultBuilder::IsOrdinaryName);
5275 Results.EnterNewScope();
5277 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5278 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5279 CodeCompleter->includeGlobals(),
5280 CodeCompleter->loadExternal());
5282 AddOrdinaryNameResults(PCC_Statement, S, *this, Results);
5285 CodeCompletionBuilder Builder(Results.getAllocator(),
5286 Results.getCodeCompletionTUInfo());
5287 Builder.AddTypedTextChunk("else");
5288 if (Results.includeCodePatterns()) {
5289 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5290 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5291 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
5292 Builder.AddPlaceholderChunk("statements");
5293 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
5294 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5296 Results.AddResult(Builder.TakeString());
5299 Builder.AddTypedTextChunk("else if");
5300 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5301 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5302 if (getLangOpts().CPlusPlus)
5303 Builder.AddPlaceholderChunk("condition");
5305 Builder.AddPlaceholderChunk("expression");
5306 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5307 if (Results.includeCodePatterns()) {
5308 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5309 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5310 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
5311 Builder.AddPlaceholderChunk("statements");
5312 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
5313 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5315 Results.AddResult(Builder.TakeString());
5317 Results.ExitScope();
5319 if (S->getFnParent())
5320 AddPrettyFunctionResults(getLangOpts(), Results);
5322 if (CodeCompleter->includeMacros())
5323 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false);
5325 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5326 Results.data(), Results.size());
5329 void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
5330 bool EnteringContext, QualType BaseType,
5331 QualType PreferredType) {
5332 if (SS.isEmpty() || !CodeCompleter)
5335 // We want to keep the scope specifier even if it's invalid (e.g. the scope
5336 // "a::b::" is not corresponding to any context/namespace in the AST), since
5337 // it can be useful for global code completion which have information about
5338 // contexts/symbols that are not in the AST.
5339 if (SS.isInvalid()) {
5340 CodeCompletionContext CC(CodeCompletionContext::CCC_Symbol, PreferredType);
5341 CC.setCXXScopeSpecifier(SS);
5342 // As SS is invalid, we try to collect accessible contexts from the current
5343 // scope with a dummy lookup so that the completion consumer can try to
5344 // guess what the specified scope is.
5345 ResultBuilder DummyResults(*this, CodeCompleter->getAllocator(),
5346 CodeCompleter->getCodeCompletionTUInfo(), CC);
5347 if (!PreferredType.isNull())
5348 DummyResults.setPreferredType(PreferredType);
5349 if (S->getEntity()) {
5350 CodeCompletionDeclConsumer Consumer(DummyResults, S->getEntity(),
5352 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5353 /*IncludeGlobalScope=*/false,
5354 /*LoadExternal=*/false);
5356 HandleCodeCompleteResults(this, CodeCompleter,
5357 DummyResults.getCompletionContext(), nullptr, 0);
5360 // Always pretend to enter a context to ensure that a dependent type
5361 // resolves to a dependent record.
5362 DeclContext *Ctx = computeDeclContext(SS, /*EnteringContext=*/true);
5366 // Try to instantiate any non-dependent declaration contexts before
5368 if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx))
5371 ResultBuilder Results(
5372 *this, CodeCompleter->getAllocator(),
5373 CodeCompleter->getCodeCompletionTUInfo(),
5374 CodeCompletionContext(CodeCompletionContext::CCC_Symbol, PreferredType));
5375 if (!PreferredType.isNull())
5376 Results.setPreferredType(PreferredType);
5377 Results.EnterNewScope();
5379 // The "template" keyword can follow "::" in the grammar, but only
5380 // put it into the grammar if the nested-name-specifier is dependent.
5381 NestedNameSpecifier *NNS = SS.getScopeRep();
5382 if (!Results.empty() && NNS->isDependent())
5383 Results.AddResult("template");
5385 // Add calls to overridden virtual functions, if there are any.
5387 // FIXME: This isn't wonderful, because we don't know whether we're actually
5388 // in a context that permits expressions. This is a general issue with
5389 // qualified-id completions.
5390 if (!EnteringContext)
5391 MaybeAddOverrideCalls(*this, Ctx, Results);
5392 Results.ExitScope();
5394 if (CodeCompleter->includeNamespaceLevelDecls() ||
5395 (!Ctx->isNamespace() && !Ctx->isTranslationUnit())) {
5396 CodeCompletionDeclConsumer Consumer(Results, Ctx, BaseType);
5397 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer,
5398 /*IncludeGlobalScope=*/true,
5399 /*IncludeDependentBases=*/true,
5400 CodeCompleter->loadExternal());
5403 auto CC = Results.getCompletionContext();
5404 CC.setCXXScopeSpecifier(SS);
5406 HandleCodeCompleteResults(this, CodeCompleter, CC, Results.data(),
5410 void Sema::CodeCompleteUsing(Scope *S) {
5414 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5415 CodeCompleter->getCodeCompletionTUInfo(),
5416 // This can be both a using alias or using
5417 // declaration, in the former we expect a new name and a
5418 // symbol in the latter case.
5419 CodeCompletionContext::CCC_SymbolOrNewName,
5420 &ResultBuilder::IsNestedNameSpecifier);
5421 Results.EnterNewScope();
5423 // If we aren't in class scope, we could see the "namespace" keyword.
5424 if (!S->isClassScope())
5425 Results.AddResult(CodeCompletionResult("namespace"));
5427 // After "using", we can see anything that would start a
5428 // nested-name-specifier.
5429 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5430 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5431 CodeCompleter->includeGlobals(),
5432 CodeCompleter->loadExternal());
5433 Results.ExitScope();
5435 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5436 Results.data(), Results.size());
5439 void Sema::CodeCompleteUsingDirective(Scope *S) {
5443 // After "using namespace", we expect to see a namespace name or namespace
5445 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5446 CodeCompleter->getCodeCompletionTUInfo(),
5447 CodeCompletionContext::CCC_Namespace,
5448 &ResultBuilder::IsNamespaceOrAlias);
5449 Results.EnterNewScope();
5450 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5451 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5452 CodeCompleter->includeGlobals(),
5453 CodeCompleter->loadExternal());
5454 Results.ExitScope();
5455 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5456 Results.data(), Results.size());
5459 void Sema::CodeCompleteNamespaceDecl(Scope *S) {
5463 DeclContext *Ctx = S->getEntity();
5464 if (!S->getParent())
5465 Ctx = Context.getTranslationUnitDecl();
5467 bool SuppressedGlobalResults =
5468 Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx);
5470 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5471 CodeCompleter->getCodeCompletionTUInfo(),
5472 SuppressedGlobalResults
5473 ? CodeCompletionContext::CCC_Namespace
5474 : CodeCompletionContext::CCC_Other,
5475 &ResultBuilder::IsNamespace);
5477 if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) {
5478 // We only want to see those namespaces that have already been defined
5479 // within this scope, because its likely that the user is creating an
5480 // extended namespace declaration. Keep track of the most recent
5481 // definition of each namespace.
5482 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest;
5483 for (DeclContext::specific_decl_iterator<NamespaceDecl>
5484 NS(Ctx->decls_begin()),
5485 NSEnd(Ctx->decls_end());
5487 OrigToLatest[NS->getOriginalNamespace()] = *NS;
5489 // Add the most recent definition (or extended definition) of each
5490 // namespace to the list of results.
5491 Results.EnterNewScope();
5492 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator
5493 NS = OrigToLatest.begin(),
5494 NSEnd = OrigToLatest.end();
5497 CodeCompletionResult(NS->second, Results.getBasePriority(NS->second),
5499 CurContext, nullptr, false);
5500 Results.ExitScope();
5503 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5504 Results.data(), Results.size());
5507 void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) {
5511 // After "namespace", we expect to see a namespace or alias.
5512 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5513 CodeCompleter->getCodeCompletionTUInfo(),
5514 CodeCompletionContext::CCC_Namespace,
5515 &ResultBuilder::IsNamespaceOrAlias);
5516 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5517 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5518 CodeCompleter->includeGlobals(),
5519 CodeCompleter->loadExternal());
5520 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5521 Results.data(), Results.size());
5524 void Sema::CodeCompleteOperatorName(Scope *S) {
5528 typedef CodeCompletionResult Result;
5529 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5530 CodeCompleter->getCodeCompletionTUInfo(),
5531 CodeCompletionContext::CCC_Type,
5532 &ResultBuilder::IsType);
5533 Results.EnterNewScope();
5535 // Add the names of overloadable operators. Note that OO_Conditional is not
5536 // actually overloadable.
5537 #define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
5538 if (OO_##Name != OO_Conditional) \
5539 Results.AddResult(Result(Spelling));
5540 #include "clang/Basic/OperatorKinds.def"
5542 // Add any type names visible from the current scope
5543 Results.allowNestedNameSpecifiers();
5544 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5545 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5546 CodeCompleter->includeGlobals(),
5547 CodeCompleter->loadExternal());
5549 // Add any type specifiers
5550 AddTypeSpecifierResults(getLangOpts(), Results);
5551 Results.ExitScope();
5553 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5554 Results.data(), Results.size());
5557 void Sema::CodeCompleteConstructorInitializer(
5558 Decl *ConstructorD, ArrayRef<CXXCtorInitializer *> Initializers) {
5562 AdjustDeclIfTemplate(ConstructorD);
5564 auto *Constructor = dyn_cast<CXXConstructorDecl>(ConstructorD);
5568 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5569 CodeCompleter->getCodeCompletionTUInfo(),
5570 CodeCompletionContext::CCC_Symbol);
5571 Results.EnterNewScope();
5573 // Fill in any already-initialized fields or base classes.
5574 llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
5575 llvm::SmallPtrSet<CanQualType, 4> InitializedBases;
5576 for (unsigned I = 0, E = Initializers.size(); I != E; ++I) {
5577 if (Initializers[I]->isBaseInitializer())
5578 InitializedBases.insert(Context.getCanonicalType(
5579 QualType(Initializers[I]->getBaseClass(), 0)));
5581 InitializedFields.insert(
5582 cast<FieldDecl>(Initializers[I]->getAnyMember()));
5585 // Add completions for base classes.
5586 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
5587 bool SawLastInitializer = Initializers.empty();
5588 CXXRecordDecl *ClassDecl = Constructor->getParent();
5590 auto GenerateCCS = [&](const NamedDecl *ND, const char *Name) {
5591 CodeCompletionBuilder Builder(Results.getAllocator(),
5592 Results.getCodeCompletionTUInfo());
5593 Builder.AddTypedTextChunk(Name);
5594 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5595 if (const auto *Function = dyn_cast<FunctionDecl>(ND))
5596 AddFunctionParameterChunks(PP, Policy, Function, Builder);
5597 else if (const auto *FunTemplDecl = dyn_cast<FunctionTemplateDecl>(ND))
5598 AddFunctionParameterChunks(PP, Policy, FunTemplDecl->getTemplatedDecl(),
5600 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5601 return Builder.TakeString();
5603 auto AddDefaultCtorInit = [&](const char *Name, const char *Type,
5604 const NamedDecl *ND) {
5605 CodeCompletionBuilder Builder(Results.getAllocator(),
5606 Results.getCodeCompletionTUInfo());
5607 Builder.AddTypedTextChunk(Name);
5608 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5609 Builder.AddPlaceholderChunk(Type);
5610 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5612 auto CCR = CodeCompletionResult(
5613 Builder.TakeString(), ND,
5614 SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration);
5615 if (isa<FieldDecl>(ND))
5616 CCR.CursorKind = CXCursor_MemberRef;
5617 return Results.AddResult(CCR);
5619 return Results.AddResult(CodeCompletionResult(
5620 Builder.TakeString(),
5621 SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration));
5623 auto AddCtorsWithName = [&](const CXXRecordDecl *RD, unsigned int Priority,
5624 const char *Name, const FieldDecl *FD) {
5626 return AddDefaultCtorInit(Name,
5627 FD ? Results.getAllocator().CopyString(
5628 FD->getType().getAsString(Policy))
5631 auto Ctors = getConstructors(Context, RD);
5632 if (Ctors.begin() == Ctors.end())
5633 return AddDefaultCtorInit(Name, Name, RD);
5634 for (const NamedDecl *Ctor : Ctors) {
5635 auto CCR = CodeCompletionResult(GenerateCCS(Ctor, Name), RD, Priority);
5636 CCR.CursorKind = getCursorKindForDecl(Ctor);
5637 Results.AddResult(CCR);
5640 auto AddBase = [&](const CXXBaseSpecifier &Base) {
5641 const char *BaseName =
5642 Results.getAllocator().CopyString(Base.getType().getAsString(Policy));
5643 const auto *RD = Base.getType()->getAsCXXRecordDecl();
5645 RD, SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration,
5648 auto AddField = [&](const FieldDecl *FD) {
5649 const char *FieldName =
5650 Results.getAllocator().CopyString(FD->getIdentifier()->getName());
5651 const CXXRecordDecl *RD = FD->getType()->getAsCXXRecordDecl();
5653 RD, SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration,
5657 for (const auto &Base : ClassDecl->bases()) {
5658 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
5660 SawLastInitializer =
5661 !Initializers.empty() && Initializers.back()->isBaseInitializer() &&
5662 Context.hasSameUnqualifiedType(
5663 Base.getType(), QualType(Initializers.back()->getBaseClass(), 0));
5668 SawLastInitializer = false;
5671 // Add completions for virtual base classes.
5672 for (const auto &Base : ClassDecl->vbases()) {
5673 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
5675 SawLastInitializer =
5676 !Initializers.empty() && Initializers.back()->isBaseInitializer() &&
5677 Context.hasSameUnqualifiedType(
5678 Base.getType(), QualType(Initializers.back()->getBaseClass(), 0));
5683 SawLastInitializer = false;
5686 // Add completions for members.
5687 for (auto *Field : ClassDecl->fields()) {
5688 if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))
5690 SawLastInitializer = !Initializers.empty() &&
5691 Initializers.back()->isAnyMemberInitializer() &&
5692 Initializers.back()->getAnyMember() == Field;
5696 if (!Field->getDeclName())
5700 SawLastInitializer = false;
5702 Results.ExitScope();
5704 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5705 Results.data(), Results.size());
5708 /// Determine whether this scope denotes a namespace.
5709 static bool isNamespaceScope(Scope *S) {
5710 DeclContext *DC = S->getEntity();
5714 return DC->isFileContext();
5717 void Sema::CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
5718 bool AfterAmpersand) {
5719 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5720 CodeCompleter->getCodeCompletionTUInfo(),
5721 CodeCompletionContext::CCC_Other);
5722 Results.EnterNewScope();
5724 // Note what has already been captured.
5725 llvm::SmallPtrSet<IdentifierInfo *, 4> Known;
5726 bool IncludedThis = false;
5727 for (const auto &C : Intro.Captures) {
5728 if (C.Kind == LCK_This) {
5729 IncludedThis = true;
5736 // Look for other capturable variables.
5737 for (; S && !isNamespaceScope(S); S = S->getParent()) {
5738 for (const auto *D : S->decls()) {
5739 const auto *Var = dyn_cast<VarDecl>(D);
5740 if (!Var || !Var->hasLocalStorage() || Var->hasAttr<BlocksAttr>())
5743 if (Known.insert(Var->getIdentifier()).second)
5744 Results.AddResult(CodeCompletionResult(Var, CCP_LocalDeclaration),
5745 CurContext, nullptr, false);
5749 // Add 'this', if it would be valid.
5750 if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy)
5751 addThisCompletion(*this, Results);
5753 Results.ExitScope();
5755 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5756 Results.data(), Results.size());
5759 /// Macro that optionally prepends an "@" to the string literal passed in via
5760 /// Keyword, depending on whether NeedAt is true or false.
5761 #define OBJC_AT_KEYWORD_NAME(NeedAt, Keyword) ((NeedAt) ? "@" Keyword : Keyword)
5763 static void AddObjCImplementationResults(const LangOptions &LangOpts,
5764 ResultBuilder &Results, bool NeedAt) {
5765 typedef CodeCompletionResult Result;
5766 // Since we have an implementation, we can end it.
5767 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "end")));
5769 CodeCompletionBuilder Builder(Results.getAllocator(),
5770 Results.getCodeCompletionTUInfo());
5771 if (LangOpts.ObjC) {
5773 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "dynamic"));
5774 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5775 Builder.AddPlaceholderChunk("property");
5776 Results.AddResult(Result(Builder.TakeString()));
5779 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "synthesize"));
5780 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5781 Builder.AddPlaceholderChunk("property");
5782 Results.AddResult(Result(Builder.TakeString()));
5786 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
5787 ResultBuilder &Results, bool NeedAt) {
5788 typedef CodeCompletionResult Result;
5790 // Since we have an interface or protocol, we can end it.
5791 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "end")));
5793 if (LangOpts.ObjC) {
5795 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "property")));
5798 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "required")));
5801 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "optional")));
5805 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
5806 typedef CodeCompletionResult Result;
5807 CodeCompletionBuilder Builder(Results.getAllocator(),
5808 Results.getCodeCompletionTUInfo());
5811 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "class"));
5812 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5813 Builder.AddPlaceholderChunk("name");
5814 Results.AddResult(Result(Builder.TakeString()));
5816 if (Results.includeCodePatterns()) {
5818 // FIXME: Could introduce the whole pattern, including superclasses and
5820 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "interface"));
5821 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5822 Builder.AddPlaceholderChunk("class");
5823 Results.AddResult(Result(Builder.TakeString()));
5826 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "protocol"));
5827 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5828 Builder.AddPlaceholderChunk("protocol");
5829 Results.AddResult(Result(Builder.TakeString()));
5831 // @implementation name
5832 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "implementation"));
5833 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5834 Builder.AddPlaceholderChunk("class");
5835 Results.AddResult(Result(Builder.TakeString()));
5838 // @compatibility_alias name
5839 Builder.AddTypedTextChunk(
5840 OBJC_AT_KEYWORD_NAME(NeedAt, "compatibility_alias"));
5841 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5842 Builder.AddPlaceholderChunk("alias");
5843 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5844 Builder.AddPlaceholderChunk("class");
5845 Results.AddResult(Result(Builder.TakeString()));
5847 if (Results.getSema().getLangOpts().Modules) {
5849 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import"));
5850 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5851 Builder.AddPlaceholderChunk("module");
5852 Results.AddResult(Result(Builder.TakeString()));
5856 void Sema::CodeCompleteObjCAtDirective(Scope *S) {
5857 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5858 CodeCompleter->getCodeCompletionTUInfo(),
5859 CodeCompletionContext::CCC_Other);
5860 Results.EnterNewScope();
5861 if (isa<ObjCImplDecl>(CurContext))
5862 AddObjCImplementationResults(getLangOpts(), Results, false);
5863 else if (CurContext->isObjCContainer())
5864 AddObjCInterfaceResults(getLangOpts(), Results, false);
5866 AddObjCTopLevelResults(Results, false);
5867 Results.ExitScope();
5868 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5869 Results.data(), Results.size());
5872 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) {
5873 typedef CodeCompletionResult Result;
5874 CodeCompletionBuilder Builder(Results.getAllocator(),
5875 Results.getCodeCompletionTUInfo());
5877 // @encode ( type-name )
5878 const char *EncodeType = "char[]";
5879 if (Results.getSema().getLangOpts().CPlusPlus ||
5880 Results.getSema().getLangOpts().ConstStrings)
5881 EncodeType = "const char[]";
5882 Builder.AddResultTypeChunk(EncodeType);
5883 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "encode"));
5884 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5885 Builder.AddPlaceholderChunk("type-name");
5886 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5887 Results.AddResult(Result(Builder.TakeString()));
5889 // @protocol ( protocol-name )
5890 Builder.AddResultTypeChunk("Protocol *");
5891 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "protocol"));
5892 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5893 Builder.AddPlaceholderChunk("protocol-name");
5894 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5895 Results.AddResult(Result(Builder.TakeString()));
5897 // @selector ( selector )
5898 Builder.AddResultTypeChunk("SEL");
5899 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "selector"));
5900 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5901 Builder.AddPlaceholderChunk("selector");
5902 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5903 Results.AddResult(Result(Builder.TakeString()));
5906 Builder.AddResultTypeChunk("NSString *");
5907 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "\""));
5908 Builder.AddPlaceholderChunk("string");
5909 Builder.AddTextChunk("\"");
5910 Results.AddResult(Result(Builder.TakeString()));
5913 Builder.AddResultTypeChunk("NSArray *");
5914 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "["));
5915 Builder.AddPlaceholderChunk("objects, ...");
5916 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
5917 Results.AddResult(Result(Builder.TakeString()));
5919 // @{key : object, ...}
5920 Builder.AddResultTypeChunk("NSDictionary *");
5921 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "{"));
5922 Builder.AddPlaceholderChunk("key");
5923 Builder.AddChunk(CodeCompletionString::CK_Colon);
5924 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5925 Builder.AddPlaceholderChunk("object, ...");
5926 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5927 Results.AddResult(Result(Builder.TakeString()));
5930 Builder.AddResultTypeChunk("id");
5931 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "("));
5932 Builder.AddPlaceholderChunk("expression");
5933 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5934 Results.AddResult(Result(Builder.TakeString()));
5937 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) {
5938 typedef CodeCompletionResult Result;
5939 CodeCompletionBuilder Builder(Results.getAllocator(),
5940 Results.getCodeCompletionTUInfo());
5942 if (Results.includeCodePatterns()) {
5943 // @try { statements } @catch ( declaration ) { statements } @finally
5945 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "try"));
5946 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5947 Builder.AddPlaceholderChunk("statements");
5948 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5949 Builder.AddTextChunk("@catch");
5950 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5951 Builder.AddPlaceholderChunk("parameter");
5952 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5953 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5954 Builder.AddPlaceholderChunk("statements");
5955 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5956 Builder.AddTextChunk("@finally");
5957 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5958 Builder.AddPlaceholderChunk("statements");
5959 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5960 Results.AddResult(Result(Builder.TakeString()));
5964 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "throw"));
5965 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5966 Builder.AddPlaceholderChunk("expression");
5967 Results.AddResult(Result(Builder.TakeString()));
5969 if (Results.includeCodePatterns()) {
5970 // @synchronized ( expression ) { statements }
5971 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "synchronized"));
5972 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5973 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5974 Builder.AddPlaceholderChunk("expression");
5975 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5976 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5977 Builder.AddPlaceholderChunk("statements");
5978 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5979 Results.AddResult(Result(Builder.TakeString()));
5983 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
5984 ResultBuilder &Results, bool NeedAt) {
5985 typedef CodeCompletionResult Result;
5986 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "private")));
5987 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "protected")));
5988 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "public")));
5990 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "package")));
5993 void Sema::CodeCompleteObjCAtVisibility(Scope *S) {
5994 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5995 CodeCompleter->getCodeCompletionTUInfo(),
5996 CodeCompletionContext::CCC_Other);
5997 Results.EnterNewScope();
5998 AddObjCVisibilityResults(getLangOpts(), Results, false);
5999 Results.ExitScope();
6000 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6001 Results.data(), Results.size());
6004 void Sema::CodeCompleteObjCAtStatement(Scope *S) {
6005 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6006 CodeCompleter->getCodeCompletionTUInfo(),
6007 CodeCompletionContext::CCC_Other);
6008 Results.EnterNewScope();
6009 AddObjCStatementResults(Results, false);
6010 AddObjCExpressionResults(Results, false);
6011 Results.ExitScope();
6012 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6013 Results.data(), Results.size());
6016 void Sema::CodeCompleteObjCAtExpression(Scope *S) {
6017 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6018 CodeCompleter->getCodeCompletionTUInfo(),
6019 CodeCompletionContext::CCC_Other);
6020 Results.EnterNewScope();
6021 AddObjCExpressionResults(Results, false);
6022 Results.ExitScope();
6023 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6024 Results.data(), Results.size());
6027 /// Determine whether the addition of the given flag to an Objective-C
6028 /// property's attributes will cause a conflict.
6029 static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) {
6030 // Check if we've already added this flag.
6031 if (Attributes & NewFlag)
6034 Attributes |= NewFlag;
6036 // Check for collisions with "readonly".
6037 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
6038 (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
6041 // Check for more than one of { assign, copy, retain, strong, weak }.
6042 unsigned AssignCopyRetMask =
6044 (ObjCDeclSpec::DQ_PR_assign | ObjCDeclSpec::DQ_PR_unsafe_unretained |
6045 ObjCDeclSpec::DQ_PR_copy | ObjCDeclSpec::DQ_PR_retain |
6046 ObjCDeclSpec::DQ_PR_strong | ObjCDeclSpec::DQ_PR_weak);
6047 if (AssignCopyRetMask && AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign &&
6048 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_unsafe_unretained &&
6049 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy &&
6050 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain &&
6051 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_strong &&
6052 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_weak)
6058 void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) {
6062 unsigned Attributes = ODS.getPropertyAttributes();
6064 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6065 CodeCompleter->getCodeCompletionTUInfo(),
6066 CodeCompletionContext::CCC_Other);
6067 Results.EnterNewScope();
6068 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readonly))
6069 Results.AddResult(CodeCompletionResult("readonly"));
6070 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_assign))
6071 Results.AddResult(CodeCompletionResult("assign"));
6072 if (!ObjCPropertyFlagConflicts(Attributes,
6073 ObjCDeclSpec::DQ_PR_unsafe_unretained))
6074 Results.AddResult(CodeCompletionResult("unsafe_unretained"));
6075 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readwrite))
6076 Results.AddResult(CodeCompletionResult("readwrite"));
6077 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_retain))
6078 Results.AddResult(CodeCompletionResult("retain"));
6079 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_strong))
6080 Results.AddResult(CodeCompletionResult("strong"));
6081 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_copy))
6082 Results.AddResult(CodeCompletionResult("copy"));
6083 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nonatomic))
6084 Results.AddResult(CodeCompletionResult("nonatomic"));
6085 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_atomic))
6086 Results.AddResult(CodeCompletionResult("atomic"));
6088 // Only suggest "weak" if we're compiling for ARC-with-weak-references or GC.
6089 if (getLangOpts().ObjCWeak || getLangOpts().getGC() != LangOptions::NonGC)
6090 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_weak))
6091 Results.AddResult(CodeCompletionResult("weak"));
6093 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_setter)) {
6094 CodeCompletionBuilder Setter(Results.getAllocator(),
6095 Results.getCodeCompletionTUInfo());
6096 Setter.AddTypedTextChunk("setter");
6097 Setter.AddTextChunk("=");
6098 Setter.AddPlaceholderChunk("method");
6099 Results.AddResult(CodeCompletionResult(Setter.TakeString()));
6101 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_getter)) {
6102 CodeCompletionBuilder Getter(Results.getAllocator(),
6103 Results.getCodeCompletionTUInfo());
6104 Getter.AddTypedTextChunk("getter");
6105 Getter.AddTextChunk("=");
6106 Getter.AddPlaceholderChunk("method");
6107 Results.AddResult(CodeCompletionResult(Getter.TakeString()));
6109 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nullability)) {
6110 Results.AddResult(CodeCompletionResult("nonnull"));
6111 Results.AddResult(CodeCompletionResult("nullable"));
6112 Results.AddResult(CodeCompletionResult("null_unspecified"));
6113 Results.AddResult(CodeCompletionResult("null_resettable"));
6115 Results.ExitScope();
6116 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6117 Results.data(), Results.size());
6120 /// Describes the kind of Objective-C method that we want to find
6121 /// via code completion.
6122 enum ObjCMethodKind {
6123 MK_Any, ///< Any kind of method, provided it means other specified criteria.
6124 MK_ZeroArgSelector, ///< Zero-argument (unary) selector.
6125 MK_OneArgSelector ///< One-argument selector.
6128 static bool isAcceptableObjCSelector(Selector Sel, ObjCMethodKind WantKind,
6129 ArrayRef<IdentifierInfo *> SelIdents,
6130 bool AllowSameLength = true) {
6131 unsigned NumSelIdents = SelIdents.size();
6132 if (NumSelIdents > Sel.getNumArgs())
6138 case MK_ZeroArgSelector:
6139 return Sel.isUnarySelector();
6140 case MK_OneArgSelector:
6141 return Sel.getNumArgs() == 1;
6144 if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs())
6147 for (unsigned I = 0; I != NumSelIdents; ++I)
6148 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I))
6154 static bool isAcceptableObjCMethod(ObjCMethodDecl *Method,
6155 ObjCMethodKind WantKind,
6156 ArrayRef<IdentifierInfo *> SelIdents,
6157 bool AllowSameLength = true) {
6158 return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents,
6162 /// A set of selectors, which is used to avoid introducing multiple
6163 /// completions with the same selector into the result set.
6164 typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet;
6166 /// Add all of the Objective-C methods in the given Objective-C
6167 /// container to the set of results.
6169 /// The container will be a class, protocol, category, or implementation of
6170 /// any of the above. This mether will recurse to include methods from
6171 /// the superclasses of classes along with their categories, protocols, and
6172 /// implementations.
6174 /// \param Container the container in which we'll look to find methods.
6176 /// \param WantInstanceMethods Whether to add instance methods (only); if
6177 /// false, this routine will add factory methods (only).
6179 /// \param CurContext the context in which we're performing the lookup that
6182 /// \param AllowSameLength Whether we allow a method to be added to the list
6183 /// when it has the same number of parameters as we have selector identifiers.
6185 /// \param Results the structure into which we'll add results.
6186 static void AddObjCMethods(ObjCContainerDecl *Container,
6187 bool WantInstanceMethods, ObjCMethodKind WantKind,
6188 ArrayRef<IdentifierInfo *> SelIdents,
6189 DeclContext *CurContext,
6190 VisitedSelectorSet &Selectors, bool AllowSameLength,
6191 ResultBuilder &Results, bool InOriginalClass = true,
6192 bool IsRootClass = false) {
6193 typedef CodeCompletionResult Result;
6194 Container = getContainerDef(Container);
6195 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
6196 IsRootClass = IsRootClass || (IFace && !IFace->getSuperClass());
6197 for (ObjCMethodDecl *M : Container->methods()) {
6198 // The instance methods on the root class can be messaged via the
6200 if (M->isInstanceMethod() == WantInstanceMethods ||
6201 (IsRootClass && !WantInstanceMethods)) {
6202 // Check whether the selector identifiers we've been given are a
6203 // subset of the identifiers for this particular method.
6204 if (!isAcceptableObjCMethod(M, WantKind, SelIdents, AllowSameLength))
6207 if (!Selectors.insert(M->getSelector()).second)
6210 Result R = Result(M, Results.getBasePriority(M), nullptr);
6211 R.StartParameter = SelIdents.size();
6212 R.AllParametersAreInformative = (WantKind != MK_Any);
6213 if (!InOriginalClass)
6215 Results.MaybeAddResult(R, CurContext);
6219 // Visit the protocols of protocols.
6220 if (const auto *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
6221 if (Protocol->hasDefinition()) {
6222 const ObjCList<ObjCProtocolDecl> &Protocols =
6223 Protocol->getReferencedProtocols();
6224 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6225 E = Protocols.end();
6227 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
6228 Selectors, AllowSameLength, Results, false, IsRootClass);
6232 if (!IFace || !IFace->hasDefinition())
6235 // Add methods in protocols.
6236 for (ObjCProtocolDecl *I : IFace->protocols())
6237 AddObjCMethods(I, WantInstanceMethods, WantKind, SelIdents, CurContext,
6238 Selectors, AllowSameLength, Results, false, IsRootClass);
6240 // Add methods in categories.
6241 for (ObjCCategoryDecl *CatDecl : IFace->known_categories()) {
6242 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
6243 CurContext, Selectors, AllowSameLength, Results,
6244 InOriginalClass, IsRootClass);
6246 // Add a categories protocol methods.
6247 const ObjCList<ObjCProtocolDecl> &Protocols =
6248 CatDecl->getReferencedProtocols();
6249 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6250 E = Protocols.end();
6252 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
6253 Selectors, AllowSameLength, Results, false, IsRootClass);
6255 // Add methods in category implementations.
6256 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation())
6257 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
6258 Selectors, AllowSameLength, Results, InOriginalClass,
6262 // Add methods in superclass.
6263 // Avoid passing in IsRootClass since root classes won't have super classes.
6264 if (IFace->getSuperClass())
6265 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind,
6266 SelIdents, CurContext, Selectors, AllowSameLength, Results,
6267 /*IsRootClass=*/false);
6269 // Add methods in our implementation, if any.
6270 if (ObjCImplementationDecl *Impl = IFace->getImplementation())
6271 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
6272 Selectors, AllowSameLength, Results, InOriginalClass,
6276 void Sema::CodeCompleteObjCPropertyGetter(Scope *S) {
6277 // Try to find the interface where getters might live.
6278 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
6280 if (ObjCCategoryDecl *Category =
6281 dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
6282 Class = Category->getClassInterface();
6288 // Find all of the potential getters.
6289 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6290 CodeCompleter->getCodeCompletionTUInfo(),
6291 CodeCompletionContext::CCC_Other);
6292 Results.EnterNewScope();
6294 VisitedSelectorSet Selectors;
6295 AddObjCMethods(Class, true, MK_ZeroArgSelector, None, CurContext, Selectors,
6296 /*AllowSameLength=*/true, Results);
6297 Results.ExitScope();
6298 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6299 Results.data(), Results.size());
6302 void Sema::CodeCompleteObjCPropertySetter(Scope *S) {
6303 // Try to find the interface where setters might live.
6304 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
6306 if (ObjCCategoryDecl *Category =
6307 dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
6308 Class = Category->getClassInterface();
6314 // Find all of the potential getters.
6315 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6316 CodeCompleter->getCodeCompletionTUInfo(),
6317 CodeCompletionContext::CCC_Other);
6318 Results.EnterNewScope();
6320 VisitedSelectorSet Selectors;
6321 AddObjCMethods(Class, true, MK_OneArgSelector, None, CurContext, Selectors,
6322 /*AllowSameLength=*/true, Results);
6324 Results.ExitScope();
6325 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6326 Results.data(), Results.size());
6329 void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
6331 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6332 CodeCompleter->getCodeCompletionTUInfo(),
6333 CodeCompletionContext::CCC_Type);
6334 Results.EnterNewScope();
6336 // Add context-sensitive, Objective-C parameter-passing keywords.
6337 bool AddedInOut = false;
6338 if ((DS.getObjCDeclQualifier() &
6339 (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) {
6340 Results.AddResult("in");
6341 Results.AddResult("inout");
6344 if ((DS.getObjCDeclQualifier() &
6345 (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) {
6346 Results.AddResult("out");
6348 Results.AddResult("inout");
6350 if ((DS.getObjCDeclQualifier() &
6351 (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref |
6352 ObjCDeclSpec::DQ_Oneway)) == 0) {
6353 Results.AddResult("bycopy");
6354 Results.AddResult("byref");
6355 Results.AddResult("oneway");
6357 if ((DS.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability) == 0) {
6358 Results.AddResult("nonnull");
6359 Results.AddResult("nullable");
6360 Results.AddResult("null_unspecified");
6363 // If we're completing the return type of an Objective-C method and the
6364 // identifier IBAction refers to a macro, provide a completion item for
6366 // IBAction)<#selector#>:(id)sender
6367 if (DS.getObjCDeclQualifier() == 0 && !IsParameter &&
6368 PP.isMacroDefined("IBAction")) {
6369 CodeCompletionBuilder Builder(Results.getAllocator(),
6370 Results.getCodeCompletionTUInfo(),
6371 CCP_CodePattern, CXAvailability_Available);
6372 Builder.AddTypedTextChunk("IBAction");
6373 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6374 Builder.AddPlaceholderChunk("selector");
6375 Builder.AddChunk(CodeCompletionString::CK_Colon);
6376 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6377 Builder.AddTextChunk("id");
6378 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6379 Builder.AddTextChunk("sender");
6380 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
6383 // If we're completing the return type, provide 'instancetype'.
6385 Results.AddResult(CodeCompletionResult("instancetype"));
6388 // Add various builtin type names and specifiers.
6389 AddOrdinaryNameResults(PCC_Type, S, *this, Results);
6390 Results.ExitScope();
6392 // Add the various type names
6393 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
6394 CodeCompletionDeclConsumer Consumer(Results, CurContext);
6395 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
6396 CodeCompleter->includeGlobals(),
6397 CodeCompleter->loadExternal());
6399 if (CodeCompleter->includeMacros())
6400 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false);
6402 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6403 Results.data(), Results.size());
6406 /// When we have an expression with type "id", we may assume
6407 /// that it has some more-specific class type based on knowledge of
6408 /// common uses of Objective-C. This routine returns that class type,
6409 /// or NULL if no better result could be determined.
6410 static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) {
6411 auto *Msg = dyn_cast_or_null<ObjCMessageExpr>(E);
6415 Selector Sel = Msg->getSelector();
6419 IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0);
6423 ObjCMethodDecl *Method = Msg->getMethodDecl();
6427 // Determine the class that we're sending the message to.
6428 ObjCInterfaceDecl *IFace = nullptr;
6429 switch (Msg->getReceiverKind()) {
6430 case ObjCMessageExpr::Class:
6431 if (const ObjCObjectType *ObjType =
6432 Msg->getClassReceiver()->getAs<ObjCObjectType>())
6433 IFace = ObjType->getInterface();
6436 case ObjCMessageExpr::Instance: {
6437 QualType T = Msg->getInstanceReceiver()->getType();
6438 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
6439 IFace = Ptr->getInterfaceDecl();
6443 case ObjCMessageExpr::SuperInstance:
6444 case ObjCMessageExpr::SuperClass:
6451 ObjCInterfaceDecl *Super = IFace->getSuperClass();
6452 if (Method->isInstanceMethod())
6453 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
6454 .Case("retain", IFace)
6455 .Case("strong", IFace)
6456 .Case("autorelease", IFace)
6457 .Case("copy", IFace)
6458 .Case("copyWithZone", IFace)
6459 .Case("mutableCopy", IFace)
6460 .Case("mutableCopyWithZone", IFace)
6461 .Case("awakeFromCoder", IFace)
6462 .Case("replacementObjectFromCoder", IFace)
6463 .Case("class", IFace)
6464 .Case("classForCoder", IFace)
6465 .Case("superclass", Super)
6468 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
6470 .Case("alloc", IFace)
6471 .Case("allocWithZone", IFace)
6472 .Case("class", IFace)
6473 .Case("superclass", Super)
6477 // Add a special completion for a message send to "super", which fills in the
6478 // most likely case of forwarding all of our arguments to the superclass
6481 /// \param S The semantic analysis object.
6483 /// \param NeedSuperKeyword Whether we need to prefix this completion with
6484 /// the "super" keyword. Otherwise, we just need to provide the arguments.
6486 /// \param SelIdents The identifiers in the selector that have already been
6487 /// provided as arguments for a send to "super".
6489 /// \param Results The set of results to augment.
6491 /// \returns the Objective-C method declaration that would be invoked by
6492 /// this "super" completion. If NULL, no completion was added.
6493 static ObjCMethodDecl *
6494 AddSuperSendCompletion(Sema &S, bool NeedSuperKeyword,
6495 ArrayRef<IdentifierInfo *> SelIdents,
6496 ResultBuilder &Results) {
6497 ObjCMethodDecl *CurMethod = S.getCurMethodDecl();
6501 ObjCInterfaceDecl *Class = CurMethod->getClassInterface();
6505 // Try to find a superclass method with the same selector.
6506 ObjCMethodDecl *SuperMethod = nullptr;
6507 while ((Class = Class->getSuperClass()) && !SuperMethod) {
6508 // Check in the class
6509 SuperMethod = Class->getMethod(CurMethod->getSelector(),
6510 CurMethod->isInstanceMethod());
6512 // Check in categories or class extensions.
6514 for (const auto *Cat : Class->known_categories()) {
6515 if ((SuperMethod = Cat->getMethod(CurMethod->getSelector(),
6516 CurMethod->isInstanceMethod())))
6525 // Check whether the superclass method has the same signature.
6526 if (CurMethod->param_size() != SuperMethod->param_size() ||
6527 CurMethod->isVariadic() != SuperMethod->isVariadic())
6530 for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(),
6531 CurPEnd = CurMethod->param_end(),
6532 SuperP = SuperMethod->param_begin();
6533 CurP != CurPEnd; ++CurP, ++SuperP) {
6534 // Make sure the parameter types are compatible.
6535 if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(),
6536 (*SuperP)->getType()))
6539 // Make sure we have a parameter name to forward!
6540 if (!(*CurP)->getIdentifier())
6544 // We have a superclass method. Now, form the send-to-super completion.
6545 CodeCompletionBuilder Builder(Results.getAllocator(),
6546 Results.getCodeCompletionTUInfo());
6548 // Give this completion a return type.
6549 AddResultTypeChunk(S.Context, getCompletionPrintingPolicy(S), SuperMethod,
6550 Results.getCompletionContext().getBaseType(), Builder);
6552 // If we need the "super" keyword, add it (plus some spacing).
6553 if (NeedSuperKeyword) {
6554 Builder.AddTypedTextChunk("super");
6555 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6558 Selector Sel = CurMethod->getSelector();
6559 if (Sel.isUnarySelector()) {
6560 if (NeedSuperKeyword)
6561 Builder.AddTextChunk(
6562 Builder.getAllocator().CopyString(Sel.getNameForSlot(0)));
6564 Builder.AddTypedTextChunk(
6565 Builder.getAllocator().CopyString(Sel.getNameForSlot(0)));
6567 ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin();
6568 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) {
6569 if (I > SelIdents.size())
6570 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6572 if (I < SelIdents.size())
6573 Builder.AddInformativeChunk(
6574 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
6575 else if (NeedSuperKeyword || I > SelIdents.size()) {
6576 Builder.AddTextChunk(
6577 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
6578 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
6579 (*CurP)->getIdentifier()->getName()));
6581 Builder.AddTypedTextChunk(
6582 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
6583 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
6584 (*CurP)->getIdentifier()->getName()));
6589 Results.AddResult(CodeCompletionResult(Builder.TakeString(), SuperMethod,
6590 CCP_SuperCompletion));
6594 void Sema::CodeCompleteObjCMessageReceiver(Scope *S) {
6595 typedef CodeCompletionResult Result;
6596 ResultBuilder Results(
6597 *this, CodeCompleter->getAllocator(),
6598 CodeCompleter->getCodeCompletionTUInfo(),
6599 CodeCompletionContext::CCC_ObjCMessageReceiver,
6600 getLangOpts().CPlusPlus11
6601 ? &ResultBuilder::IsObjCMessageReceiverOrLambdaCapture
6602 : &ResultBuilder::IsObjCMessageReceiver);
6604 CodeCompletionDeclConsumer Consumer(Results, CurContext);
6605 Results.EnterNewScope();
6606 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
6607 CodeCompleter->includeGlobals(),
6608 CodeCompleter->loadExternal());
6610 // If we are in an Objective-C method inside a class that has a superclass,
6611 // add "super" as an option.
6612 if (ObjCMethodDecl *Method = getCurMethodDecl())
6613 if (ObjCInterfaceDecl *Iface = Method->getClassInterface())
6614 if (Iface->getSuperClass()) {
6615 Results.AddResult(Result("super"));
6617 AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, None, Results);
6620 if (getLangOpts().CPlusPlus11)
6621 addThisCompletion(*this, Results);
6623 Results.ExitScope();
6625 if (CodeCompleter->includeMacros())
6626 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false);
6627 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6628 Results.data(), Results.size());
6631 void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
6632 ArrayRef<IdentifierInfo *> SelIdents,
6633 bool AtArgumentExpression) {
6634 ObjCInterfaceDecl *CDecl = nullptr;
6635 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
6636 // Figure out which interface we're in.
6637 CDecl = CurMethod->getClassInterface();
6641 // Find the superclass of this class.
6642 CDecl = CDecl->getSuperClass();
6646 if (CurMethod->isInstanceMethod()) {
6647 // We are inside an instance method, which means that the message
6648 // send [super ...] is actually calling an instance method on the
6650 return CodeCompleteObjCInstanceMessage(S, nullptr, SelIdents,
6651 AtArgumentExpression, CDecl);
6654 // Fall through to send to the superclass in CDecl.
6656 // "super" may be the name of a type or variable. Figure out which
6658 IdentifierInfo *Super = getSuperIdentifier();
6659 NamedDecl *ND = LookupSingleName(S, Super, SuperLoc, LookupOrdinaryName);
6660 if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) {
6661 // "super" names an interface. Use it.
6662 } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) {
6663 if (const ObjCObjectType *Iface =
6664 Context.getTypeDeclType(TD)->getAs<ObjCObjectType>())
6665 CDecl = Iface->getInterface();
6666 } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) {
6667 // "super" names an unresolved type; we can't be more specific.
6669 // Assume that "super" names some kind of value and parse that way.
6671 SourceLocation TemplateKWLoc;
6673 id.setIdentifier(Super, SuperLoc);
6674 ExprResult SuperExpr = ActOnIdExpression(S, SS, TemplateKWLoc, id,
6675 /*HasTrailingLParen=*/false,
6676 /*IsAddressOfOperand=*/false);
6677 return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
6678 SelIdents, AtArgumentExpression);
6684 ParsedType Receiver;
6686 Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl));
6687 return CodeCompleteObjCClassMessage(S, Receiver, SelIdents,
6688 AtArgumentExpression,
6692 /// Given a set of code-completion results for the argument of a message
6693 /// send, determine the preferred type (if any) for that argument expression.
6694 static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
6695 unsigned NumSelIdents) {
6696 typedef CodeCompletionResult Result;
6697 ASTContext &Context = Results.getSema().Context;
6699 QualType PreferredType;
6700 unsigned BestPriority = CCP_Unlikely * 2;
6701 Result *ResultsData = Results.data();
6702 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
6703 Result &R = ResultsData[I];
6704 if (R.Kind == Result::RK_Declaration &&
6705 isa<ObjCMethodDecl>(R.Declaration)) {
6706 if (R.Priority <= BestPriority) {
6707 const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration);
6708 if (NumSelIdents <= Method->param_size()) {
6709 QualType MyPreferredType =
6710 Method->parameters()[NumSelIdents - 1]->getType();
6711 if (R.Priority < BestPriority || PreferredType.isNull()) {
6712 BestPriority = R.Priority;
6713 PreferredType = MyPreferredType;
6714 } else if (!Context.hasSameUnqualifiedType(PreferredType,
6716 PreferredType = QualType();
6723 return PreferredType;
6726 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
6727 ParsedType Receiver,
6728 ArrayRef<IdentifierInfo *> SelIdents,
6729 bool AtArgumentExpression, bool IsSuper,
6730 ResultBuilder &Results) {
6731 typedef CodeCompletionResult Result;
6732 ObjCInterfaceDecl *CDecl = nullptr;
6734 // If the given name refers to an interface type, retrieve the
6735 // corresponding declaration.
6737 QualType T = SemaRef.GetTypeFromParser(Receiver, nullptr);
6739 if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>())
6740 CDecl = Interface->getInterface();
6743 // Add all of the factory methods in this Objective-C class, its protocols,
6744 // superclasses, categories, implementation, etc.
6745 Results.EnterNewScope();
6747 // If this is a send-to-super, try to add the special "super" send
6750 if (ObjCMethodDecl *SuperMethod =
6751 AddSuperSendCompletion(SemaRef, false, SelIdents, Results))
6752 Results.Ignore(SuperMethod);
6755 // If we're inside an Objective-C method definition, prefer its selector to
6757 if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl())
6758 Results.setPreferredSelector(CurMethod->getSelector());
6760 VisitedSelectorSet Selectors;
6762 AddObjCMethods(CDecl, false, MK_Any, SelIdents, SemaRef.CurContext,
6763 Selectors, AtArgumentExpression, Results);
6765 // We're messaging "id" as a type; provide all class/factory methods.
6767 // If we have an external source, load the entire class method
6768 // pool from the AST file.
6769 if (SemaRef.getExternalSource()) {
6770 for (uint32_t I = 0,
6771 N = SemaRef.getExternalSource()->GetNumExternalSelectors();
6773 Selector Sel = SemaRef.getExternalSource()->GetExternalSelector(I);
6774 if (Sel.isNull() || SemaRef.MethodPool.count(Sel))
6777 SemaRef.ReadMethodPool(Sel);
6781 for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(),
6782 MEnd = SemaRef.MethodPool.end();
6784 for (ObjCMethodList *MethList = &M->second.second;
6785 MethList && MethList->getMethod(); MethList = MethList->getNext()) {
6786 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
6789 Result R(MethList->getMethod(),
6790 Results.getBasePriority(MethList->getMethod()), nullptr);
6791 R.StartParameter = SelIdents.size();
6792 R.AllParametersAreInformative = false;
6793 Results.MaybeAddResult(R, SemaRef.CurContext);
6798 Results.ExitScope();
6801 void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
6802 ArrayRef<IdentifierInfo *> SelIdents,
6803 bool AtArgumentExpression,
6806 QualType T = this->GetTypeFromParser(Receiver);
6808 ResultBuilder Results(
6809 *this, CodeCompleter->getAllocator(),
6810 CodeCompleter->getCodeCompletionTUInfo(),
6811 CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage, T,
6814 AddClassMessageCompletions(*this, S, Receiver, SelIdents,
6815 AtArgumentExpression, IsSuper, Results);
6817 // If we're actually at the argument expression (rather than prior to the
6818 // selector), we're actually performing code completion for an expression.
6819 // Determine whether we have a single, best method. If so, we can
6820 // code-complete the expression using the corresponding parameter type as
6821 // our preferred type, improving completion results.
6822 if (AtArgumentExpression) {
6823 QualType PreferredType =
6824 getPreferredArgumentTypeForMessageSend(Results, SelIdents.size());
6825 if (PreferredType.isNull())
6826 CodeCompleteOrdinaryName(S, PCC_Expression);
6828 CodeCompleteExpression(S, PreferredType);
6832 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6833 Results.data(), Results.size());
6836 void Sema::CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
6837 ArrayRef<IdentifierInfo *> SelIdents,
6838 bool AtArgumentExpression,
6839 ObjCInterfaceDecl *Super) {
6840 typedef CodeCompletionResult Result;
6842 Expr *RecExpr = static_cast<Expr *>(Receiver);
6844 // If necessary, apply function/array conversion to the receiver.
6845 // C99 6.7.5.3p[7,8].
6847 ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr);
6848 if (Conv.isInvalid()) // conversion failed. bail.
6850 RecExpr = Conv.get();
6852 QualType ReceiverType = RecExpr
6853 ? RecExpr->getType()
6854 : Super ? Context.getObjCObjectPointerType(
6855 Context.getObjCInterfaceType(Super))
6856 : Context.getObjCIdType();
6858 // If we're messaging an expression with type "id" or "Class", check
6859 // whether we know something special about the receiver that allows
6860 // us to assume a more-specific receiver type.
6861 if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType()) {
6862 if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) {
6863 if (ReceiverType->isObjCClassType())
6864 return CodeCompleteObjCClassMessage(
6865 S, ParsedType::make(Context.getObjCInterfaceType(IFace)), SelIdents,
6866 AtArgumentExpression, Super);
6869 Context.getObjCObjectPointerType(Context.getObjCInterfaceType(IFace));
6871 } else if (RecExpr && getLangOpts().CPlusPlus) {
6872 ExprResult Conv = PerformContextuallyConvertToObjCPointer(RecExpr);
6873 if (Conv.isUsable()) {
6874 RecExpr = Conv.get();
6875 ReceiverType = RecExpr->getType();
6879 // Build the set of methods we can see.
6880 ResultBuilder Results(
6881 *this, CodeCompleter->getAllocator(),
6882 CodeCompleter->getCodeCompletionTUInfo(),
6883 CodeCompletionContext(CodeCompletionContext::CCC_ObjCInstanceMessage,
6884 ReceiverType, SelIdents));
6886 Results.EnterNewScope();
6888 // If this is a send-to-super, try to add the special "super" send
6891 if (ObjCMethodDecl *SuperMethod =
6892 AddSuperSendCompletion(*this, false, SelIdents, Results))
6893 Results.Ignore(SuperMethod);
6896 // If we're inside an Objective-C method definition, prefer its selector to
6898 if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
6899 Results.setPreferredSelector(CurMethod->getSelector());
6901 // Keep track of the selectors we've already added.
6902 VisitedSelectorSet Selectors;
6904 // Handle messages to Class. This really isn't a message to an instance
6905 // method, so we treat it the same way we would treat a message send to a
6907 if (ReceiverType->isObjCClassType() ||
6908 ReceiverType->isObjCQualifiedClassType()) {
6909 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
6910 if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface())
6911 AddObjCMethods(ClassDecl, false, MK_Any, SelIdents, CurContext,
6912 Selectors, AtArgumentExpression, Results);
6915 // Handle messages to a qualified ID ("id<foo>").
6916 else if (const ObjCObjectPointerType *QualID =
6917 ReceiverType->getAsObjCQualifiedIdType()) {
6918 // Search protocols for instance methods.
6919 for (auto *I : QualID->quals())
6920 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext, Selectors,
6921 AtArgumentExpression, Results);
6923 // Handle messages to a pointer to interface type.
6924 else if (const ObjCObjectPointerType *IFacePtr =
6925 ReceiverType->getAsObjCInterfacePointerType()) {
6926 // Search the class, its superclasses, etc., for instance methods.
6927 AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents,
6928 CurContext, Selectors, AtArgumentExpression, Results);
6930 // Search protocols for instance methods.
6931 for (auto *I : IFacePtr->quals())
6932 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext, Selectors,
6933 AtArgumentExpression, Results);
6935 // Handle messages to "id".
6936 else if (ReceiverType->isObjCIdType()) {
6937 // We're messaging "id", so provide all instance methods we know
6938 // about as code-completion results.
6940 // If we have an external source, load the entire class method
6941 // pool from the AST file.
6942 if (ExternalSource) {
6943 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
6945 Selector Sel = ExternalSource->GetExternalSelector(I);
6946 if (Sel.isNull() || MethodPool.count(Sel))
6949 ReadMethodPool(Sel);
6953 for (GlobalMethodPool::iterator M = MethodPool.begin(),
6954 MEnd = MethodPool.end();
6956 for (ObjCMethodList *MethList = &M->second.first;
6957 MethList && MethList->getMethod(); MethList = MethList->getNext()) {
6958 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
6961 if (!Selectors.insert(MethList->getMethod()->getSelector()).second)
6964 Result R(MethList->getMethod(),
6965 Results.getBasePriority(MethList->getMethod()), nullptr);
6966 R.StartParameter = SelIdents.size();
6967 R.AllParametersAreInformative = false;
6968 Results.MaybeAddResult(R, CurContext);
6972 Results.ExitScope();
6974 // If we're actually at the argument expression (rather than prior to the
6975 // selector), we're actually performing code completion for an expression.
6976 // Determine whether we have a single, best method. If so, we can
6977 // code-complete the expression using the corresponding parameter type as
6978 // our preferred type, improving completion results.
6979 if (AtArgumentExpression) {
6980 QualType PreferredType =
6981 getPreferredArgumentTypeForMessageSend(Results, SelIdents.size());
6982 if (PreferredType.isNull())
6983 CodeCompleteOrdinaryName(S, PCC_Expression);
6985 CodeCompleteExpression(S, PreferredType);
6989 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6990 Results.data(), Results.size());
6993 void Sema::CodeCompleteObjCForCollection(Scope *S,
6994 DeclGroupPtrTy IterationVar) {
6995 CodeCompleteExpressionData Data;
6996 Data.ObjCCollection = true;
6998 if (IterationVar.getAsOpaquePtr()) {
6999 DeclGroupRef DG = IterationVar.get();
7000 for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) {
7002 Data.IgnoreDecls.push_back(*I);
7006 CodeCompleteExpression(S, Data);
7009 void Sema::CodeCompleteObjCSelector(Scope *S,
7010 ArrayRef<IdentifierInfo *> SelIdents) {
7011 // If we have an external source, load the entire class method
7012 // pool from the AST file.
7013 if (ExternalSource) {
7014 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors(); I != N;
7016 Selector Sel = ExternalSource->GetExternalSelector(I);
7017 if (Sel.isNull() || MethodPool.count(Sel))
7020 ReadMethodPool(Sel);
7024 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7025 CodeCompleter->getCodeCompletionTUInfo(),
7026 CodeCompletionContext::CCC_SelectorName);
7027 Results.EnterNewScope();
7028 for (GlobalMethodPool::iterator M = MethodPool.begin(),
7029 MEnd = MethodPool.end();
7032 Selector Sel = M->first;
7033 if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents))
7036 CodeCompletionBuilder Builder(Results.getAllocator(),
7037 Results.getCodeCompletionTUInfo());
7038 if (Sel.isUnarySelector()) {
7039 Builder.AddTypedTextChunk(
7040 Builder.getAllocator().CopyString(Sel.getNameForSlot(0)));
7041 Results.AddResult(Builder.TakeString());
7045 std::string Accumulator;
7046 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) {
7047 if (I == SelIdents.size()) {
7048 if (!Accumulator.empty()) {
7049 Builder.AddInformativeChunk(
7050 Builder.getAllocator().CopyString(Accumulator));
7051 Accumulator.clear();
7055 Accumulator += Sel.getNameForSlot(I);
7058 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(Accumulator));
7059 Results.AddResult(Builder.TakeString());
7061 Results.ExitScope();
7063 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7064 Results.data(), Results.size());
7067 /// Add all of the protocol declarations that we find in the given
7068 /// (translation unit) context.
7069 static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext,
7070 bool OnlyForwardDeclarations,
7071 ResultBuilder &Results) {
7072 typedef CodeCompletionResult Result;
7074 for (const auto *D : Ctx->decls()) {
7075 // Record any protocols we find.
7076 if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(D))
7077 if (!OnlyForwardDeclarations || !Proto->hasDefinition())
7079 Result(Proto, Results.getBasePriority(Proto), nullptr), CurContext,
7084 void Sema::CodeCompleteObjCProtocolReferences(
7085 ArrayRef<IdentifierLocPair> Protocols) {
7086 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7087 CodeCompleter->getCodeCompletionTUInfo(),
7088 CodeCompletionContext::CCC_ObjCProtocolName);
7090 if (CodeCompleter->includeGlobals()) {
7091 Results.EnterNewScope();
7093 // Tell the result set to ignore all of the protocols we have
7095 // FIXME: This doesn't work when caching code-completion results.
7096 for (const IdentifierLocPair &Pair : Protocols)
7097 if (ObjCProtocolDecl *Protocol = LookupProtocol(Pair.first, Pair.second))
7098 Results.Ignore(Protocol);
7100 // Add all protocols.
7101 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false,
7104 Results.ExitScope();
7107 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7108 Results.data(), Results.size());
7111 void Sema::CodeCompleteObjCProtocolDecl(Scope *) {
7112 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7113 CodeCompleter->getCodeCompletionTUInfo(),
7114 CodeCompletionContext::CCC_ObjCProtocolName);
7116 if (CodeCompleter->includeGlobals()) {
7117 Results.EnterNewScope();
7119 // Add all protocols.
7120 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true,
7123 Results.ExitScope();
7126 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7127 Results.data(), Results.size());
7130 /// Add all of the Objective-C interface declarations that we find in
7131 /// the given (translation unit) context.
7132 static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext,
7133 bool OnlyForwardDeclarations,
7134 bool OnlyUnimplemented,
7135 ResultBuilder &Results) {
7136 typedef CodeCompletionResult Result;
7138 for (const auto *D : Ctx->decls()) {
7139 // Record any interfaces we find.
7140 if (const auto *Class = dyn_cast<ObjCInterfaceDecl>(D))
7141 if ((!OnlyForwardDeclarations || !Class->hasDefinition()) &&
7142 (!OnlyUnimplemented || !Class->getImplementation()))
7144 Result(Class, Results.getBasePriority(Class), nullptr), CurContext,
7149 void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) {
7150 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7151 CodeCompleter->getCodeCompletionTUInfo(),
7152 CodeCompletionContext::CCC_ObjCInterfaceName);
7153 Results.EnterNewScope();
7155 if (CodeCompleter->includeGlobals()) {
7157 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
7161 Results.ExitScope();
7163 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7164 Results.data(), Results.size());
7167 void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName,
7168 SourceLocation ClassNameLoc) {
7169 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7170 CodeCompleter->getCodeCompletionTUInfo(),
7171 CodeCompletionContext::CCC_ObjCInterfaceName);
7172 Results.EnterNewScope();
7174 // Make sure that we ignore the class we're currently defining.
7175 NamedDecl *CurClass =
7176 LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
7177 if (CurClass && isa<ObjCInterfaceDecl>(CurClass))
7178 Results.Ignore(CurClass);
7180 if (CodeCompleter->includeGlobals()) {
7182 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
7186 Results.ExitScope();
7188 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7189 Results.data(), Results.size());
7192 void Sema::CodeCompleteObjCImplementationDecl(Scope *S) {
7193 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7194 CodeCompleter->getCodeCompletionTUInfo(),
7195 CodeCompletionContext::CCC_ObjCImplementation);
7196 Results.EnterNewScope();
7198 if (CodeCompleter->includeGlobals()) {
7199 // Add all unimplemented classes.
7200 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
7204 Results.ExitScope();
7206 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7207 Results.data(), Results.size());
7210 void Sema::CodeCompleteObjCInterfaceCategory(Scope *S,
7211 IdentifierInfo *ClassName,
7212 SourceLocation ClassNameLoc) {
7213 typedef CodeCompletionResult Result;
7215 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7216 CodeCompleter->getCodeCompletionTUInfo(),
7217 CodeCompletionContext::CCC_ObjCCategoryName);
7219 // Ignore any categories we find that have already been implemented by this
7221 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
7222 NamedDecl *CurClass =
7223 LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
7224 if (ObjCInterfaceDecl *Class =
7225 dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)) {
7226 for (const auto *Cat : Class->visible_categories())
7227 CategoryNames.insert(Cat->getIdentifier());
7230 // Add all of the categories we know about.
7231 Results.EnterNewScope();
7232 TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
7233 for (const auto *D : TU->decls())
7234 if (const auto *Category = dyn_cast<ObjCCategoryDecl>(D))
7235 if (CategoryNames.insert(Category->getIdentifier()).second)
7237 Result(Category, Results.getBasePriority(Category), nullptr),
7238 CurContext, nullptr, false);
7239 Results.ExitScope();
7241 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7242 Results.data(), Results.size());
7245 void Sema::CodeCompleteObjCImplementationCategory(Scope *S,
7246 IdentifierInfo *ClassName,
7247 SourceLocation ClassNameLoc) {
7248 typedef CodeCompletionResult Result;
7250 // Find the corresponding interface. If we couldn't find the interface, the
7251 // program itself is ill-formed. However, we'll try to be helpful still by
7252 // providing the list of all of the categories we know about.
7253 NamedDecl *CurClass =
7254 LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
7255 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass);
7257 return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc);
7259 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7260 CodeCompleter->getCodeCompletionTUInfo(),
7261 CodeCompletionContext::CCC_ObjCCategoryName);
7263 // Add all of the categories that have have corresponding interface
7264 // declarations in this class and any of its superclasses, except for
7265 // already-implemented categories in the class itself.
7266 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
7267 Results.EnterNewScope();
7268 bool IgnoreImplemented = true;
7270 for (const auto *Cat : Class->visible_categories()) {
7271 if ((!IgnoreImplemented || !Cat->getImplementation()) &&
7272 CategoryNames.insert(Cat->getIdentifier()).second)
7273 Results.AddResult(Result(Cat, Results.getBasePriority(Cat), nullptr),
7274 CurContext, nullptr, false);
7277 Class = Class->getSuperClass();
7278 IgnoreImplemented = false;
7280 Results.ExitScope();
7282 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7283 Results.data(), Results.size());
7286 void Sema::CodeCompleteObjCPropertyDefinition(Scope *S) {
7287 CodeCompletionContext CCContext(CodeCompletionContext::CCC_Other);
7288 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7289 CodeCompleter->getCodeCompletionTUInfo(), CCContext);
7291 // Figure out where this @synthesize lives.
7292 ObjCContainerDecl *Container =
7293 dyn_cast_or_null<ObjCContainerDecl>(CurContext);
7294 if (!Container || (!isa<ObjCImplementationDecl>(Container) &&
7295 !isa<ObjCCategoryImplDecl>(Container)))
7298 // Ignore any properties that have already been implemented.
7299 Container = getContainerDef(Container);
7300 for (const auto *D : Container->decls())
7301 if (const auto *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(D))
7302 Results.Ignore(PropertyImpl->getPropertyDecl());
7304 // Add any properties that we find.
7305 AddedPropertiesSet AddedProperties;
7306 Results.EnterNewScope();
7307 if (ObjCImplementationDecl *ClassImpl =
7308 dyn_cast<ObjCImplementationDecl>(Container))
7309 AddObjCProperties(CCContext, ClassImpl->getClassInterface(), false,
7310 /*AllowNullaryMethods=*/false, CurContext,
7311 AddedProperties, Results);
7313 AddObjCProperties(CCContext,
7314 cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(),
7315 false, /*AllowNullaryMethods=*/false, CurContext,
7316 AddedProperties, Results);
7317 Results.ExitScope();
7319 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7320 Results.data(), Results.size());
7323 void Sema::CodeCompleteObjCPropertySynthesizeIvar(
7324 Scope *S, IdentifierInfo *PropertyName) {
7325 typedef CodeCompletionResult Result;
7326 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7327 CodeCompleter->getCodeCompletionTUInfo(),
7328 CodeCompletionContext::CCC_Other);
7330 // Figure out where this @synthesize lives.
7331 ObjCContainerDecl *Container =
7332 dyn_cast_or_null<ObjCContainerDecl>(CurContext);
7333 if (!Container || (!isa<ObjCImplementationDecl>(Container) &&
7334 !isa<ObjCCategoryImplDecl>(Container)))
7337 // Figure out which interface we're looking into.
7338 ObjCInterfaceDecl *Class = nullptr;
7339 if (ObjCImplementationDecl *ClassImpl =
7340 dyn_cast<ObjCImplementationDecl>(Container))
7341 Class = ClassImpl->getClassInterface();
7343 Class = cast<ObjCCategoryImplDecl>(Container)
7345 ->getClassInterface();
7347 // Determine the type of the property we're synthesizing.
7348 QualType PropertyType = Context.getObjCIdType();
7350 if (ObjCPropertyDecl *Property = Class->FindPropertyDeclaration(
7351 PropertyName, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
7353 Property->getType().getNonReferenceType().getUnqualifiedType();
7355 // Give preference to ivars
7356 Results.setPreferredType(PropertyType);
7360 // Add all of the instance variables in this class and its superclasses.
7361 Results.EnterNewScope();
7362 bool SawSimilarlyNamedIvar = false;
7363 std::string NameWithPrefix;
7364 NameWithPrefix += '_';
7365 NameWithPrefix += PropertyName->getName();
7366 std::string NameWithSuffix = PropertyName->getName().str();
7367 NameWithSuffix += '_';
7368 for (; Class; Class = Class->getSuperClass()) {
7369 for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar;
7370 Ivar = Ivar->getNextIvar()) {
7371 Results.AddResult(Result(Ivar, Results.getBasePriority(Ivar), nullptr),
7372 CurContext, nullptr, false);
7374 // Determine whether we've seen an ivar with a name similar to the
7376 if ((PropertyName == Ivar->getIdentifier() ||
7377 NameWithPrefix == Ivar->getName() ||
7378 NameWithSuffix == Ivar->getName())) {
7379 SawSimilarlyNamedIvar = true;
7381 // Reduce the priority of this result by one, to give it a slight
7382 // advantage over other results whose names don't match so closely.
7383 if (Results.size() &&
7384 Results.data()[Results.size() - 1].Kind ==
7385 CodeCompletionResult::RK_Declaration &&
7386 Results.data()[Results.size() - 1].Declaration == Ivar)
7387 Results.data()[Results.size() - 1].Priority--;
7392 if (!SawSimilarlyNamedIvar) {
7393 // Create ivar result _propName, that the user can use to synthesize
7394 // an ivar of the appropriate type.
7395 unsigned Priority = CCP_MemberDeclaration + 1;
7396 typedef CodeCompletionResult Result;
7397 CodeCompletionAllocator &Allocator = Results.getAllocator();
7398 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo(),
7399 Priority, CXAvailability_Available);
7401 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
7402 Builder.AddResultTypeChunk(
7403 GetCompletionTypeString(PropertyType, Context, Policy, Allocator));
7404 Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix));
7406 Result(Builder.TakeString(), Priority, CXCursor_ObjCIvarDecl));
7409 Results.ExitScope();
7411 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7412 Results.data(), Results.size());
7415 // Mapping from selectors to the methods that implement that selector, along
7416 // with the "in original class" flag.
7417 typedef llvm::DenseMap<Selector,
7418 llvm::PointerIntPair<ObjCMethodDecl *, 1, bool>>
7421 /// Find all of the methods that reside in the given container
7422 /// (and its superclasses, protocols, etc.) that meet the given
7423 /// criteria. Insert those methods into the map of known methods,
7424 /// indexed by selector so they can be easily found.
7425 static void FindImplementableMethods(ASTContext &Context,
7426 ObjCContainerDecl *Container,
7427 Optional<bool> WantInstanceMethods,
7428 QualType ReturnType,
7429 KnownMethodsMap &KnownMethods,
7430 bool InOriginalClass = true) {
7431 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) {
7432 // Make sure we have a definition; that's what we'll walk.
7433 if (!IFace->hasDefinition())
7436 IFace = IFace->getDefinition();
7439 const ObjCList<ObjCProtocolDecl> &Protocols =
7440 IFace->getReferencedProtocols();
7441 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
7442 E = Protocols.end();
7444 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
7445 KnownMethods, InOriginalClass);
7447 // Add methods from any class extensions and categories.
7448 for (auto *Cat : IFace->visible_categories()) {
7449 FindImplementableMethods(Context, Cat, WantInstanceMethods, ReturnType,
7450 KnownMethods, false);
7453 // Visit the superclass.
7454 if (IFace->getSuperClass())
7455 FindImplementableMethods(Context, IFace->getSuperClass(),
7456 WantInstanceMethods, ReturnType, KnownMethods,
7460 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
7461 // Recurse into protocols.
7462 const ObjCList<ObjCProtocolDecl> &Protocols =
7463 Category->getReferencedProtocols();
7464 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
7465 E = Protocols.end();
7467 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
7468 KnownMethods, InOriginalClass);
7470 // If this category is the original class, jump to the interface.
7471 if (InOriginalClass && Category->getClassInterface())
7472 FindImplementableMethods(Context, Category->getClassInterface(),
7473 WantInstanceMethods, ReturnType, KnownMethods,
7477 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
7478 // Make sure we have a definition; that's what we'll walk.
7479 if (!Protocol->hasDefinition())
7481 Protocol = Protocol->getDefinition();
7482 Container = Protocol;
7484 // Recurse into protocols.
7485 const ObjCList<ObjCProtocolDecl> &Protocols =
7486 Protocol->getReferencedProtocols();
7487 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
7488 E = Protocols.end();
7490 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
7491 KnownMethods, false);
7494 // Add methods in this container. This operation occurs last because
7495 // we want the methods from this container to override any methods
7496 // we've previously seen with the same selector.
7497 for (auto *M : Container->methods()) {
7498 if (!WantInstanceMethods || M->isInstanceMethod() == *WantInstanceMethods) {
7499 if (!ReturnType.isNull() &&
7500 !Context.hasSameUnqualifiedType(ReturnType, M->getReturnType()))
7503 KnownMethods[M->getSelector()] =
7504 KnownMethodsMap::mapped_type(M, InOriginalClass);
7509 /// Add the parenthesized return or parameter type chunk to a code
7510 /// completion string.
7511 static void AddObjCPassingTypeChunk(QualType Type, unsigned ObjCDeclQuals,
7512 ASTContext &Context,
7513 const PrintingPolicy &Policy,
7514 CodeCompletionBuilder &Builder) {
7515 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7516 std::string Quals = formatObjCParamQualifiers(ObjCDeclQuals, Type);
7518 Builder.AddTextChunk(Builder.getAllocator().CopyString(Quals));
7519 Builder.AddTextChunk(
7520 GetCompletionTypeString(Type, Context, Policy, Builder.getAllocator()));
7521 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7524 /// Determine whether the given class is or inherits from a class by
7526 static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class, StringRef Name) {
7530 if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name)
7533 return InheritsFromClassNamed(Class->getSuperClass(), Name);
7536 /// Add code completions for Objective-C Key-Value Coding (KVC) and
7537 /// Key-Value Observing (KVO).
7538 static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property,
7539 bool IsInstanceMethod,
7540 QualType ReturnType, ASTContext &Context,
7541 VisitedSelectorSet &KnownSelectors,
7542 ResultBuilder &Results) {
7543 IdentifierInfo *PropName = Property->getIdentifier();
7544 if (!PropName || PropName->getLength() == 0)
7547 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
7549 // Builder that will create each code completion.
7550 typedef CodeCompletionResult Result;
7551 CodeCompletionAllocator &Allocator = Results.getAllocator();
7552 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
7554 // The selector table.
7555 SelectorTable &Selectors = Context.Selectors;
7557 // The property name, copied into the code completion allocation region
7560 CodeCompletionAllocator &Allocator;
7562 const char *CopiedKey;
7564 KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key)
7565 : Allocator(Allocator), Key(Key), CopiedKey(nullptr) {}
7567 operator const char *() {
7571 return CopiedKey = Allocator.CopyString(Key);
7573 } Key(Allocator, PropName->getName());
7575 // The uppercased name of the property name.
7576 std::string UpperKey = PropName->getName();
7577 if (!UpperKey.empty())
7578 UpperKey[0] = toUppercase(UpperKey[0]);
7580 bool ReturnTypeMatchesProperty =
7581 ReturnType.isNull() ||
7582 Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(),
7583 Property->getType());
7584 bool ReturnTypeMatchesVoid = ReturnType.isNull() || ReturnType->isVoidType();
7586 // Add the normal accessor -(type)key.
7587 if (IsInstanceMethod &&
7588 KnownSelectors.insert(Selectors.getNullarySelector(PropName)).second &&
7589 ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) {
7590 if (ReturnType.isNull())
7591 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0, Context, Policy,
7594 Builder.AddTypedTextChunk(Key);
7595 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7596 CXCursor_ObjCInstanceMethodDecl));
7599 // If we have an integral or boolean property (or the user has provided
7600 // an integral or boolean return type), add the accessor -(type)isKey.
7601 if (IsInstanceMethod &&
7602 ((!ReturnType.isNull() &&
7603 (ReturnType->isIntegerType() || ReturnType->isBooleanType())) ||
7604 (ReturnType.isNull() && (Property->getType()->isIntegerType() ||
7605 Property->getType()->isBooleanType())))) {
7606 std::string SelectorName = (Twine("is") + UpperKey).str();
7607 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7608 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7610 if (ReturnType.isNull()) {
7611 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7612 Builder.AddTextChunk("BOOL");
7613 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7616 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorId->getName()));
7617 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7618 CXCursor_ObjCInstanceMethodDecl));
7622 // Add the normal mutator.
7623 if (IsInstanceMethod && ReturnTypeMatchesVoid &&
7624 !Property->getSetterMethodDecl()) {
7625 std::string SelectorName = (Twine("set") + UpperKey).str();
7626 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7627 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7628 if (ReturnType.isNull()) {
7629 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7630 Builder.AddTextChunk("void");
7631 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7634 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorId->getName()));
7635 Builder.AddTypedTextChunk(":");
7636 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0, Context, Policy,
7638 Builder.AddTextChunk(Key);
7639 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7640 CXCursor_ObjCInstanceMethodDecl));
7644 // Indexed and unordered accessors
7645 unsigned IndexedGetterPriority = CCP_CodePattern;
7646 unsigned IndexedSetterPriority = CCP_CodePattern;
7647 unsigned UnorderedGetterPriority = CCP_CodePattern;
7648 unsigned UnorderedSetterPriority = CCP_CodePattern;
7649 if (const auto *ObjCPointer =
7650 Property->getType()->getAs<ObjCObjectPointerType>()) {
7651 if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) {
7652 // If this interface type is not provably derived from a known
7653 // collection, penalize the corresponding completions.
7654 if (!InheritsFromClassNamed(IFace, "NSMutableArray")) {
7655 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
7656 if (!InheritsFromClassNamed(IFace, "NSArray"))
7657 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
7660 if (!InheritsFromClassNamed(IFace, "NSMutableSet")) {
7661 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
7662 if (!InheritsFromClassNamed(IFace, "NSSet"))
7663 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
7667 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
7668 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
7669 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
7670 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
7673 // Add -(NSUInteger)countOf<key>
7674 if (IsInstanceMethod &&
7675 (ReturnType.isNull() || ReturnType->isIntegerType())) {
7676 std::string SelectorName = (Twine("countOf") + UpperKey).str();
7677 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7678 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7680 if (ReturnType.isNull()) {
7681 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7682 Builder.AddTextChunk("NSUInteger");
7683 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7686 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorId->getName()));
7688 Result(Builder.TakeString(),
7689 std::min(IndexedGetterPriority, UnorderedGetterPriority),
7690 CXCursor_ObjCInstanceMethodDecl));
7695 // Add -(id)objectInKeyAtIndex:(NSUInteger)index
7696 if (IsInstanceMethod &&
7697 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
7698 std::string SelectorName = (Twine("objectIn") + UpperKey + "AtIndex").str();
7699 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7700 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7701 if (ReturnType.isNull()) {
7702 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7703 Builder.AddTextChunk("id");
7704 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7707 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7708 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7709 Builder.AddTextChunk("NSUInteger");
7710 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7711 Builder.AddTextChunk("index");
7712 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
7713 CXCursor_ObjCInstanceMethodDecl));
7717 // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes
7718 if (IsInstanceMethod &&
7719 (ReturnType.isNull() ||
7720 (ReturnType->isObjCObjectPointerType() &&
7721 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7722 ReturnType->getAs<ObjCObjectPointerType>()
7723 ->getInterfaceDecl()
7724 ->getName() == "NSArray"))) {
7725 std::string SelectorName = (Twine(Property->getName()) + "AtIndexes").str();
7726 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7727 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7728 if (ReturnType.isNull()) {
7729 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7730 Builder.AddTextChunk("NSArray *");
7731 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7734 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7735 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7736 Builder.AddTextChunk("NSIndexSet *");
7737 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7738 Builder.AddTextChunk("indexes");
7739 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
7740 CXCursor_ObjCInstanceMethodDecl));
7744 // Add -(void)getKey:(type **)buffer range:(NSRange)inRange
7745 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7746 std::string SelectorName = (Twine("get") + UpperKey).str();
7747 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName),
7748 &Context.Idents.get("range")};
7750 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7751 if (ReturnType.isNull()) {
7752 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7753 Builder.AddTextChunk("void");
7754 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7757 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7758 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7759 Builder.AddPlaceholderChunk("object-type");
7760 Builder.AddTextChunk(" **");
7761 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7762 Builder.AddTextChunk("buffer");
7763 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7764 Builder.AddTypedTextChunk("range:");
7765 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7766 Builder.AddTextChunk("NSRange");
7767 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7768 Builder.AddTextChunk("inRange");
7769 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
7770 CXCursor_ObjCInstanceMethodDecl));
7774 // Mutable indexed accessors
7776 // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index
7777 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7778 std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str();
7779 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get("insertObject"),
7780 &Context.Idents.get(SelectorName)};
7782 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7783 if (ReturnType.isNull()) {
7784 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7785 Builder.AddTextChunk("void");
7786 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7789 Builder.AddTypedTextChunk("insertObject:");
7790 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7791 Builder.AddPlaceholderChunk("object-type");
7792 Builder.AddTextChunk(" *");
7793 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7794 Builder.AddTextChunk("object");
7795 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7796 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7797 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7798 Builder.AddPlaceholderChunk("NSUInteger");
7799 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7800 Builder.AddTextChunk("index");
7801 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7802 CXCursor_ObjCInstanceMethodDecl));
7806 // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes
7807 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7808 std::string SelectorName = (Twine("insert") + UpperKey).str();
7809 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName),
7810 &Context.Idents.get("atIndexes")};
7812 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7813 if (ReturnType.isNull()) {
7814 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7815 Builder.AddTextChunk("void");
7816 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7819 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7820 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7821 Builder.AddTextChunk("NSArray *");
7822 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7823 Builder.AddTextChunk("array");
7824 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7825 Builder.AddTypedTextChunk("atIndexes:");
7826 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7827 Builder.AddPlaceholderChunk("NSIndexSet *");
7828 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7829 Builder.AddTextChunk("indexes");
7830 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7831 CXCursor_ObjCInstanceMethodDecl));
7835 // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index
7836 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7837 std::string SelectorName =
7838 (Twine("removeObjectFrom") + UpperKey + "AtIndex").str();
7839 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7840 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7841 if (ReturnType.isNull()) {
7842 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7843 Builder.AddTextChunk("void");
7844 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7847 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7848 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7849 Builder.AddTextChunk("NSUInteger");
7850 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7851 Builder.AddTextChunk("index");
7852 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7853 CXCursor_ObjCInstanceMethodDecl));
7857 // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes
7858 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7859 std::string SelectorName = (Twine("remove") + UpperKey + "AtIndexes").str();
7860 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7861 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7862 if (ReturnType.isNull()) {
7863 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7864 Builder.AddTextChunk("void");
7865 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7868 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7869 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7870 Builder.AddTextChunk("NSIndexSet *");
7871 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7872 Builder.AddTextChunk("indexes");
7873 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7874 CXCursor_ObjCInstanceMethodDecl));
7878 // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object
7879 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7880 std::string SelectorName =
7881 (Twine("replaceObjectIn") + UpperKey + "AtIndex").str();
7882 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName),
7883 &Context.Idents.get("withObject")};
7885 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7886 if (ReturnType.isNull()) {
7887 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7888 Builder.AddTextChunk("void");
7889 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7892 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7893 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7894 Builder.AddPlaceholderChunk("NSUInteger");
7895 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7896 Builder.AddTextChunk("index");
7897 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7898 Builder.AddTypedTextChunk("withObject:");
7899 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7900 Builder.AddTextChunk("id");
7901 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7902 Builder.AddTextChunk("object");
7903 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7904 CXCursor_ObjCInstanceMethodDecl));
7908 // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array
7909 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7910 std::string SelectorName1 =
7911 (Twine("replace") + UpperKey + "AtIndexes").str();
7912 std::string SelectorName2 = (Twine("with") + UpperKey).str();
7913 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName1),
7914 &Context.Idents.get(SelectorName2)};
7916 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7917 if (ReturnType.isNull()) {
7918 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7919 Builder.AddTextChunk("void");
7920 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7923 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName1 + ":"));
7924 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7925 Builder.AddPlaceholderChunk("NSIndexSet *");
7926 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7927 Builder.AddTextChunk("indexes");
7928 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7929 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":"));
7930 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7931 Builder.AddTextChunk("NSArray *");
7932 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7933 Builder.AddTextChunk("array");
7934 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7935 CXCursor_ObjCInstanceMethodDecl));
7939 // Unordered getters
7940 // - (NSEnumerator *)enumeratorOfKey
7941 if (IsInstanceMethod &&
7942 (ReturnType.isNull() ||
7943 (ReturnType->isObjCObjectPointerType() &&
7944 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7945 ReturnType->getAs<ObjCObjectPointerType>()
7946 ->getInterfaceDecl()
7947 ->getName() == "NSEnumerator"))) {
7948 std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str();
7949 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7950 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7952 if (ReturnType.isNull()) {
7953 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7954 Builder.AddTextChunk("NSEnumerator *");
7955 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7958 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7959 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
7960 CXCursor_ObjCInstanceMethodDecl));
7964 // - (type *)memberOfKey:(type *)object
7965 if (IsInstanceMethod &&
7966 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
7967 std::string SelectorName = (Twine("memberOf") + UpperKey).str();
7968 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7969 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7970 if (ReturnType.isNull()) {
7971 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7972 Builder.AddPlaceholderChunk("object-type");
7973 Builder.AddTextChunk(" *");
7974 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7977 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7978 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7979 if (ReturnType.isNull()) {
7980 Builder.AddPlaceholderChunk("object-type");
7981 Builder.AddTextChunk(" *");
7983 Builder.AddTextChunk(GetCompletionTypeString(
7984 ReturnType, Context, Policy, Builder.getAllocator()));
7986 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7987 Builder.AddTextChunk("object");
7988 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
7989 CXCursor_ObjCInstanceMethodDecl));
7993 // Mutable unordered accessors
7994 // - (void)addKeyObject:(type *)object
7995 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7996 std::string SelectorName =
7997 (Twine("add") + UpperKey + Twine("Object")).str();
7998 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7999 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8000 if (ReturnType.isNull()) {
8001 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8002 Builder.AddTextChunk("void");
8003 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8006 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8007 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8008 Builder.AddPlaceholderChunk("object-type");
8009 Builder.AddTextChunk(" *");
8010 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8011 Builder.AddTextChunk("object");
8012 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
8013 CXCursor_ObjCInstanceMethodDecl));
8017 // - (void)addKey:(NSSet *)objects
8018 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
8019 std::string SelectorName = (Twine("add") + UpperKey).str();
8020 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8021 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8022 if (ReturnType.isNull()) {
8023 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8024 Builder.AddTextChunk("void");
8025 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8028 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8029 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8030 Builder.AddTextChunk("NSSet *");
8031 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8032 Builder.AddTextChunk("objects");
8033 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
8034 CXCursor_ObjCInstanceMethodDecl));
8038 // - (void)removeKeyObject:(type *)object
8039 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
8040 std::string SelectorName =
8041 (Twine("remove") + UpperKey + Twine("Object")).str();
8042 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8043 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8044 if (ReturnType.isNull()) {
8045 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8046 Builder.AddTextChunk("void");
8047 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8050 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8051 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8052 Builder.AddPlaceholderChunk("object-type");
8053 Builder.AddTextChunk(" *");
8054 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8055 Builder.AddTextChunk("object");
8056 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
8057 CXCursor_ObjCInstanceMethodDecl));
8061 // - (void)removeKey:(NSSet *)objects
8062 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
8063 std::string SelectorName = (Twine("remove") + UpperKey).str();
8064 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8065 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8066 if (ReturnType.isNull()) {
8067 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8068 Builder.AddTextChunk("void");
8069 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8072 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8073 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8074 Builder.AddTextChunk("NSSet *");
8075 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8076 Builder.AddTextChunk("objects");
8077 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
8078 CXCursor_ObjCInstanceMethodDecl));
8082 // - (void)intersectKey:(NSSet *)objects
8083 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
8084 std::string SelectorName = (Twine("intersect") + UpperKey).str();
8085 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8086 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8087 if (ReturnType.isNull()) {
8088 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8089 Builder.AddTextChunk("void");
8090 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8093 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8094 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8095 Builder.AddTextChunk("NSSet *");
8096 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8097 Builder.AddTextChunk("objects");
8098 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
8099 CXCursor_ObjCInstanceMethodDecl));
8103 // Key-Value Observing
8104 // + (NSSet *)keyPathsForValuesAffectingKey
8105 if (!IsInstanceMethod &&
8106 (ReturnType.isNull() ||
8107 (ReturnType->isObjCObjectPointerType() &&
8108 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
8109 ReturnType->getAs<ObjCObjectPointerType>()
8110 ->getInterfaceDecl()
8111 ->getName() == "NSSet"))) {
8112 std::string SelectorName =
8113 (Twine("keyPathsForValuesAffecting") + UpperKey).str();
8114 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8115 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
8117 if (ReturnType.isNull()) {
8118 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8119 Builder.AddTextChunk("NSSet<NSString *> *");
8120 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8123 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
8124 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
8125 CXCursor_ObjCClassMethodDecl));
8129 // + (BOOL)automaticallyNotifiesObserversForKey
8130 if (!IsInstanceMethod &&
8131 (ReturnType.isNull() || ReturnType->isIntegerType() ||
8132 ReturnType->isBooleanType())) {
8133 std::string SelectorName =
8134 (Twine("automaticallyNotifiesObserversOf") + UpperKey).str();
8135 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8136 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
8138 if (ReturnType.isNull()) {
8139 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8140 Builder.AddTextChunk("BOOL");
8141 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8144 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
8145 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
8146 CXCursor_ObjCClassMethodDecl));
8151 void Sema::CodeCompleteObjCMethodDecl(Scope *S, Optional<bool> IsInstanceMethod,
8152 ParsedType ReturnTy) {
8153 // Determine the return type of the method we're declaring, if
8155 QualType ReturnType = GetTypeFromParser(ReturnTy);
8156 Decl *IDecl = nullptr;
8157 if (CurContext->isObjCContainer()) {
8158 ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
8161 // Determine where we should start searching for methods.
8162 ObjCContainerDecl *SearchDecl = nullptr;
8163 bool IsInImplementation = false;
8164 if (Decl *D = IDecl) {
8165 if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) {
8166 SearchDecl = Impl->getClassInterface();
8167 IsInImplementation = true;
8168 } else if (ObjCCategoryImplDecl *CatImpl =
8169 dyn_cast<ObjCCategoryImplDecl>(D)) {
8170 SearchDecl = CatImpl->getCategoryDecl();
8171 IsInImplementation = true;
8173 SearchDecl = dyn_cast<ObjCContainerDecl>(D);
8176 if (!SearchDecl && S) {
8177 if (DeclContext *DC = S->getEntity())
8178 SearchDecl = dyn_cast<ObjCContainerDecl>(DC);
8182 HandleCodeCompleteResults(this, CodeCompleter,
8183 CodeCompletionContext::CCC_Other, nullptr, 0);
8187 // Find all of the methods that we could declare/implement here.
8188 KnownMethodsMap KnownMethods;
8189 FindImplementableMethods(Context, SearchDecl, IsInstanceMethod, ReturnType,
8192 // Add declarations or definitions for each of the known methods.
8193 typedef CodeCompletionResult Result;
8194 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
8195 CodeCompleter->getCodeCompletionTUInfo(),
8196 CodeCompletionContext::CCC_Other);
8197 Results.EnterNewScope();
8198 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
8199 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
8200 MEnd = KnownMethods.end();
8202 ObjCMethodDecl *Method = M->second.getPointer();
8203 CodeCompletionBuilder Builder(Results.getAllocator(),
8204 Results.getCodeCompletionTUInfo());
8206 // Add the '-'/'+' prefix if it wasn't provided yet.
8207 if (!IsInstanceMethod) {
8208 Builder.AddTextChunk(Method->isInstanceMethod() ? "-" : "+");
8209 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8212 // If the result type was not already provided, add it to the
8213 // pattern as (type).
8214 if (ReturnType.isNull()) {
8215 QualType ResTy = Method->getSendResultType().stripObjCKindOfType(Context);
8216 AttributedType::stripOuterNullability(ResTy);
8217 AddObjCPassingTypeChunk(ResTy, Method->getObjCDeclQualifier(), Context,
8221 Selector Sel = Method->getSelector();
8223 // Add the first part of the selector to the pattern.
8224 Builder.AddTypedTextChunk(
8225 Builder.getAllocator().CopyString(Sel.getNameForSlot(0)));
8227 // Add parameters to the pattern.
8229 for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
8230 PEnd = Method->param_end();
8231 P != PEnd; (void)++P, ++I) {
8232 // Add the part of the selector name.
8234 Builder.AddTypedTextChunk(":");
8235 else if (I < Sel.getNumArgs()) {
8236 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8237 Builder.AddTypedTextChunk(
8238 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
8242 // Add the parameter type.
8244 if ((*P)->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
8245 ParamType = (*P)->getType();
8247 ParamType = (*P)->getOriginalType();
8248 ParamType = ParamType.substObjCTypeArgs(
8249 Context, {}, ObjCSubstitutionContext::Parameter);
8250 AttributedType::stripOuterNullability(ParamType);
8251 AddObjCPassingTypeChunk(ParamType, (*P)->getObjCDeclQualifier(), Context,
8254 if (IdentifierInfo *Id = (*P)->getIdentifier())
8255 Builder.AddTextChunk(Builder.getAllocator().CopyString(Id->getName()));
8258 if (Method->isVariadic()) {
8259 if (Method->param_size() > 0)
8260 Builder.AddChunk(CodeCompletionString::CK_Comma);
8261 Builder.AddTextChunk("...");
8264 if (IsInImplementation && Results.includeCodePatterns()) {
8265 // We will be defining the method here, so add a compound statement.
8266 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8267 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
8268 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
8269 if (!Method->getReturnType()->isVoidType()) {
8270 // If the result type is not void, add a return clause.
8271 Builder.AddTextChunk("return");
8272 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8273 Builder.AddPlaceholderChunk("expression");
8274 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
8276 Builder.AddPlaceholderChunk("statements");
8278 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
8279 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
8282 unsigned Priority = CCP_CodePattern;
8283 auto R = Result(Builder.TakeString(), Method, Priority);
8284 if (!M->second.getInt())
8286 Results.AddResult(std::move(R));
8289 // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of
8290 // the properties in this class and its categories.
8291 if (Context.getLangOpts().ObjC) {
8292 SmallVector<ObjCContainerDecl *, 4> Containers;
8293 Containers.push_back(SearchDecl);
8295 VisitedSelectorSet KnownSelectors;
8296 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
8297 MEnd = KnownMethods.end();
8299 KnownSelectors.insert(M->first);
8301 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl);
8303 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl))
8304 IFace = Category->getClassInterface();
8307 for (auto *Cat : IFace->visible_categories())
8308 Containers.push_back(Cat);
8310 if (IsInstanceMethod) {
8311 for (unsigned I = 0, N = Containers.size(); I != N; ++I)
8312 for (auto *P : Containers[I]->instance_properties())
8313 AddObjCKeyValueCompletions(P, *IsInstanceMethod, ReturnType, Context,
8314 KnownSelectors, Results);
8318 Results.ExitScope();
8320 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8321 Results.data(), Results.size());
8324 void Sema::CodeCompleteObjCMethodDeclSelector(
8325 Scope *S, bool IsInstanceMethod, bool AtParameterName, ParsedType ReturnTy,
8326 ArrayRef<IdentifierInfo *> SelIdents) {
8327 // If we have an external source, load the entire class method
8328 // pool from the AST file.
8329 if (ExternalSource) {
8330 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors(); I != N;
8332 Selector Sel = ExternalSource->GetExternalSelector(I);
8333 if (Sel.isNull() || MethodPool.count(Sel))
8336 ReadMethodPool(Sel);
8340 // Build the set of methods we can see.
8341 typedef CodeCompletionResult Result;
8342 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
8343 CodeCompleter->getCodeCompletionTUInfo(),
8344 CodeCompletionContext::CCC_Other);
8347 Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType());
8349 Results.EnterNewScope();
8350 for (GlobalMethodPool::iterator M = MethodPool.begin(),
8351 MEnd = MethodPool.end();
8353 for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first
8354 : &M->second.second;
8355 MethList && MethList->getMethod(); MethList = MethList->getNext()) {
8356 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
8359 if (AtParameterName) {
8360 // Suggest parameter names we've seen before.
8361 unsigned NumSelIdents = SelIdents.size();
8363 NumSelIdents <= MethList->getMethod()->param_size()) {
8364 ParmVarDecl *Param =
8365 MethList->getMethod()->parameters()[NumSelIdents - 1];
8366 if (Param->getIdentifier()) {
8367 CodeCompletionBuilder Builder(Results.getAllocator(),
8368 Results.getCodeCompletionTUInfo());
8369 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
8370 Param->getIdentifier()->getName()));
8371 Results.AddResult(Builder.TakeString());
8378 Result R(MethList->getMethod(),
8379 Results.getBasePriority(MethList->getMethod()), nullptr);
8380 R.StartParameter = SelIdents.size();
8381 R.AllParametersAreInformative = false;
8382 R.DeclaringEntity = true;
8383 Results.MaybeAddResult(R, CurContext);
8387 Results.ExitScope();
8389 if (!AtParameterName && !SelIdents.empty() &&
8390 SelIdents.front()->getName().startswith("init")) {
8391 for (const auto &M : PP.macros()) {
8392 if (M.first->getName() != "NS_DESIGNATED_INITIALIZER")
8394 Results.EnterNewScope();
8395 CodeCompletionBuilder Builder(Results.getAllocator(),
8396 Results.getCodeCompletionTUInfo());
8397 Builder.AddTypedTextChunk(
8398 Builder.getAllocator().CopyString(M.first->getName()));
8399 Results.AddResult(CodeCompletionResult(Builder.TakeString(), CCP_Macro,
8400 CXCursor_MacroDefinition));
8401 Results.ExitScope();
8405 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8406 Results.data(), Results.size());
8409 void Sema::CodeCompletePreprocessorDirective(bool InConditional) {
8410 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
8411 CodeCompleter->getCodeCompletionTUInfo(),
8412 CodeCompletionContext::CCC_PreprocessorDirective);
8413 Results.EnterNewScope();
8416 CodeCompletionBuilder Builder(Results.getAllocator(),
8417 Results.getCodeCompletionTUInfo());
8418 Builder.AddTypedTextChunk("if");
8419 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8420 Builder.AddPlaceholderChunk("condition");
8421 Results.AddResult(Builder.TakeString());
8424 Builder.AddTypedTextChunk("ifdef");
8425 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8426 Builder.AddPlaceholderChunk("macro");
8427 Results.AddResult(Builder.TakeString());
8430 Builder.AddTypedTextChunk("ifndef");
8431 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8432 Builder.AddPlaceholderChunk("macro");
8433 Results.AddResult(Builder.TakeString());
8435 if (InConditional) {
8436 // #elif <condition>
8437 Builder.AddTypedTextChunk("elif");
8438 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8439 Builder.AddPlaceholderChunk("condition");
8440 Results.AddResult(Builder.TakeString());
8443 Builder.AddTypedTextChunk("else");
8444 Results.AddResult(Builder.TakeString());
8447 Builder.AddTypedTextChunk("endif");
8448 Results.AddResult(Builder.TakeString());
8451 // #include "header"
8452 Builder.AddTypedTextChunk("include");
8453 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8454 Builder.AddTextChunk("\"");
8455 Builder.AddPlaceholderChunk("header");
8456 Builder.AddTextChunk("\"");
8457 Results.AddResult(Builder.TakeString());
8459 // #include <header>
8460 Builder.AddTypedTextChunk("include");
8461 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8462 Builder.AddTextChunk("<");
8463 Builder.AddPlaceholderChunk("header");
8464 Builder.AddTextChunk(">");
8465 Results.AddResult(Builder.TakeString());
8468 Builder.AddTypedTextChunk("define");
8469 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8470 Builder.AddPlaceholderChunk("macro");
8471 Results.AddResult(Builder.TakeString());
8473 // #define <macro>(<args>)
8474 Builder.AddTypedTextChunk("define");
8475 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8476 Builder.AddPlaceholderChunk("macro");
8477 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8478 Builder.AddPlaceholderChunk("args");
8479 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8480 Results.AddResult(Builder.TakeString());
8483 Builder.AddTypedTextChunk("undef");
8484 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8485 Builder.AddPlaceholderChunk("macro");
8486 Results.AddResult(Builder.TakeString());
8489 Builder.AddTypedTextChunk("line");
8490 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8491 Builder.AddPlaceholderChunk("number");
8492 Results.AddResult(Builder.TakeString());
8494 // #line <number> "filename"
8495 Builder.AddTypedTextChunk("line");
8496 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8497 Builder.AddPlaceholderChunk("number");
8498 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8499 Builder.AddTextChunk("\"");
8500 Builder.AddPlaceholderChunk("filename");
8501 Builder.AddTextChunk("\"");
8502 Results.AddResult(Builder.TakeString());
8505 Builder.AddTypedTextChunk("error");
8506 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8507 Builder.AddPlaceholderChunk("message");
8508 Results.AddResult(Builder.TakeString());
8510 // #pragma <arguments>
8511 Builder.AddTypedTextChunk("pragma");
8512 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8513 Builder.AddPlaceholderChunk("arguments");
8514 Results.AddResult(Builder.TakeString());
8516 if (getLangOpts().ObjC) {
8518 Builder.AddTypedTextChunk("import");
8519 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8520 Builder.AddTextChunk("\"");
8521 Builder.AddPlaceholderChunk("header");
8522 Builder.AddTextChunk("\"");
8523 Results.AddResult(Builder.TakeString());
8526 Builder.AddTypedTextChunk("import");
8527 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8528 Builder.AddTextChunk("<");
8529 Builder.AddPlaceholderChunk("header");
8530 Builder.AddTextChunk(">");
8531 Results.AddResult(Builder.TakeString());
8534 // #include_next "header"
8535 Builder.AddTypedTextChunk("include_next");
8536 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8537 Builder.AddTextChunk("\"");
8538 Builder.AddPlaceholderChunk("header");
8539 Builder.AddTextChunk("\"");
8540 Results.AddResult(Builder.TakeString());
8542 // #include_next <header>
8543 Builder.AddTypedTextChunk("include_next");
8544 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8545 Builder.AddTextChunk("<");
8546 Builder.AddPlaceholderChunk("header");
8547 Builder.AddTextChunk(">");
8548 Results.AddResult(Builder.TakeString());
8550 // #warning <message>
8551 Builder.AddTypedTextChunk("warning");
8552 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8553 Builder.AddPlaceholderChunk("message");
8554 Results.AddResult(Builder.TakeString());
8556 // Note: #ident and #sccs are such crazy anachronisms that we don't provide
8557 // completions for them. And __include_macros is a Clang-internal extension
8558 // that we don't want to encourage anyone to use.
8560 // FIXME: we don't support #assert or #unassert, so don't suggest them.
8561 Results.ExitScope();
8563 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8564 Results.data(), Results.size());
8567 void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) {
8568 CodeCompleteOrdinaryName(S, S->getFnParent() ? Sema::PCC_RecoveryInFunction
8569 : Sema::PCC_Namespace);
8572 void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) {
8573 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
8574 CodeCompleter->getCodeCompletionTUInfo(),
8575 IsDefinition ? CodeCompletionContext::CCC_MacroName
8576 : CodeCompletionContext::CCC_MacroNameUse);
8577 if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) {
8578 // Add just the names of macros, not their arguments.
8579 CodeCompletionBuilder Builder(Results.getAllocator(),
8580 Results.getCodeCompletionTUInfo());
8581 Results.EnterNewScope();
8582 for (Preprocessor::macro_iterator M = PP.macro_begin(),
8583 MEnd = PP.macro_end();
8585 Builder.AddTypedTextChunk(
8586 Builder.getAllocator().CopyString(M->first->getName()));
8587 Results.AddResult(CodeCompletionResult(
8588 Builder.TakeString(), CCP_CodePattern, CXCursor_MacroDefinition));
8590 Results.ExitScope();
8591 } else if (IsDefinition) {
8592 // FIXME: Can we detect when the user just wrote an include guard above?
8595 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8596 Results.data(), Results.size());
8599 void Sema::CodeCompletePreprocessorExpression() {
8600 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
8601 CodeCompleter->getCodeCompletionTUInfo(),
8602 CodeCompletionContext::CCC_PreprocessorExpression);
8604 if (!CodeCompleter || CodeCompleter->includeMacros())
8605 AddMacroResults(PP, Results,
8606 !CodeCompleter || CodeCompleter->loadExternal(), true);
8608 // defined (<macro>)
8609 Results.EnterNewScope();
8610 CodeCompletionBuilder Builder(Results.getAllocator(),
8611 Results.getCodeCompletionTUInfo());
8612 Builder.AddTypedTextChunk("defined");
8613 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8614 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8615 Builder.AddPlaceholderChunk("macro");
8616 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8617 Results.AddResult(Builder.TakeString());
8618 Results.ExitScope();
8620 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8621 Results.data(), Results.size());
8624 void Sema::CodeCompletePreprocessorMacroArgument(Scope *S,
8625 IdentifierInfo *Macro,
8626 MacroInfo *MacroInfo,
8627 unsigned Argument) {
8628 // FIXME: In the future, we could provide "overload" results, much like we
8629 // do for function calls.
8631 // Now just ignore this. There will be another code-completion callback
8632 // for the expanded tokens.
8635 // This handles completion inside an #include filename, e.g. #include <foo/ba
8636 // We look for the directory "foo" under each directory on the include path,
8637 // list its files, and reassemble the appropriate #include.
8638 void Sema::CodeCompleteIncludedFile(llvm::StringRef Dir, bool Angled) {
8639 // RelDir should use /, but unescaped \ is possible on windows!
8640 // Our completions will normalize to / for simplicity, this case is rare.
8641 std::string RelDir = llvm::sys::path::convert_to_slash(Dir);
8642 // We need the native slashes for the actual file system interactions.
8643 SmallString<128> NativeRelDir = StringRef(RelDir);
8644 llvm::sys::path::native(NativeRelDir);
8645 llvm::vfs::FileSystem &FS =
8646 getSourceManager().getFileManager().getVirtualFileSystem();
8648 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
8649 CodeCompleter->getCodeCompletionTUInfo(),
8650 CodeCompletionContext::CCC_IncludedFile);
8651 llvm::DenseSet<StringRef> SeenResults; // To deduplicate results.
8653 // Helper: adds one file or directory completion result.
8654 auto AddCompletion = [&](StringRef Filename, bool IsDirectory) {
8655 SmallString<64> TypedChunk = Filename;
8656 // Directory completion is up to the slash, e.g. <sys/
8657 TypedChunk.push_back(IsDirectory ? '/' : Angled ? '>' : '"');
8658 auto R = SeenResults.insert(TypedChunk);
8659 if (R.second) { // New completion
8660 const char *InternedTyped = Results.getAllocator().CopyString(TypedChunk);
8661 *R.first = InternedTyped; // Avoid dangling StringRef.
8662 CodeCompletionBuilder Builder(CodeCompleter->getAllocator(),
8663 CodeCompleter->getCodeCompletionTUInfo());
8664 Builder.AddTypedTextChunk(InternedTyped);
8665 // The result is a "Pattern", which is pretty opaque.
8666 // We may want to include the real filename to allow smart ranking.
8667 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
8671 // Helper: scans IncludeDir for nice files, and adds results for each.
8672 auto AddFilesFromIncludeDir = [&](StringRef IncludeDir,
8674 DirectoryLookup::LookupType_t LookupType) {
8675 llvm::SmallString<128> Dir = IncludeDir;
8676 if (!NativeRelDir.empty()) {
8677 if (LookupType == DirectoryLookup::LT_Framework) {
8678 // For a framework dir, #include <Foo/Bar/> actually maps to
8679 // a path of Foo.framework/Headers/Bar/.
8680 auto Begin = llvm::sys::path::begin(NativeRelDir);
8681 auto End = llvm::sys::path::end(NativeRelDir);
8683 llvm::sys::path::append(Dir, *Begin + ".framework", "Headers");
8684 llvm::sys::path::append(Dir, ++Begin, End);
8686 llvm::sys::path::append(Dir, NativeRelDir);
8692 for (auto It = FS.dir_begin(Dir, EC);
8693 !EC && It != llvm::vfs::directory_iterator(); It.increment(EC)) {
8694 if (++Count == 2500) // If we happen to hit a huge directory,
8695 break; // bail out early so we're not too slow.
8696 StringRef Filename = llvm::sys::path::filename(It->path());
8697 switch (It->type()) {
8698 case llvm::sys::fs::file_type::directory_file:
8699 // All entries in a framework directory must have a ".framework" suffix,
8700 // but the suffix does not appear in the source code's include/import.
8701 if (LookupType == DirectoryLookup::LT_Framework &&
8702 NativeRelDir.empty() && !Filename.consume_back(".framework"))
8705 AddCompletion(Filename, /*IsDirectory=*/true);
8707 case llvm::sys::fs::file_type::regular_file:
8708 // Only files that really look like headers. (Except in system dirs).
8710 // Header extensions from Types.def, which we can't depend on here.
8711 if (!(Filename.endswith_lower(".h") ||
8712 Filename.endswith_lower(".hh") ||
8713 Filename.endswith_lower(".hpp") ||
8714 Filename.endswith_lower(".inc")))
8717 AddCompletion(Filename, /*IsDirectory=*/false);
8725 // Helper: adds results relative to IncludeDir, if possible.
8726 auto AddFilesFromDirLookup = [&](const DirectoryLookup &IncludeDir,
8728 switch (IncludeDir.getLookupType()) {
8729 case DirectoryLookup::LT_HeaderMap:
8730 // header maps are not (currently) enumerable.
8732 case DirectoryLookup::LT_NormalDir:
8733 AddFilesFromIncludeDir(IncludeDir.getDir()->getName(), IsSystem,
8734 DirectoryLookup::LT_NormalDir);
8736 case DirectoryLookup::LT_Framework:
8737 AddFilesFromIncludeDir(IncludeDir.getFrameworkDir()->getName(), IsSystem,
8738 DirectoryLookup::LT_Framework);
8743 // Finally with all our helpers, we can scan the include path.
8744 // Do this in standard order so deduplication keeps the right file.
8745 // (In case we decide to add more details to the results later).
8746 const auto &S = PP.getHeaderSearchInfo();
8747 using llvm::make_range;
8749 // The current directory is on the include path for "quoted" includes.
8750 auto *CurFile = PP.getCurrentFileLexer()->getFileEntry();
8751 if (CurFile && CurFile->getDir())
8752 AddFilesFromIncludeDir(CurFile->getDir()->getName(), false,
8753 DirectoryLookup::LT_NormalDir);
8754 for (const auto &D : make_range(S.quoted_dir_begin(), S.quoted_dir_end()))
8755 AddFilesFromDirLookup(D, false);
8757 for (const auto &D : make_range(S.angled_dir_begin(), S.angled_dir_end()))
8758 AddFilesFromDirLookup(D, false);
8759 for (const auto &D : make_range(S.system_dir_begin(), S.system_dir_end()))
8760 AddFilesFromDirLookup(D, true);
8762 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8763 Results.data(), Results.size());
8766 void Sema::CodeCompleteNaturalLanguage() {
8767 HandleCodeCompleteResults(this, CodeCompleter,
8768 CodeCompletionContext::CCC_NaturalLanguage, nullptr,
8772 void Sema::CodeCompleteAvailabilityPlatformName() {
8773 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
8774 CodeCompleter->getCodeCompletionTUInfo(),
8775 CodeCompletionContext::CCC_Other);
8776 Results.EnterNewScope();
8777 static const char *Platforms[] = {"macOS", "iOS", "watchOS", "tvOS"};
8778 for (const char *Platform : llvm::makeArrayRef(Platforms)) {
8779 Results.AddResult(CodeCompletionResult(Platform));
8780 Results.AddResult(CodeCompletionResult(Results.getAllocator().CopyString(
8781 Twine(Platform) + "ApplicationExtension")));
8783 Results.ExitScope();
8784 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8785 Results.data(), Results.size());
8788 void Sema::GatherGlobalCodeCompletions(
8789 CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo,
8790 SmallVectorImpl<CodeCompletionResult> &Results) {
8791 ResultBuilder Builder(*this, Allocator, CCTUInfo,
8792 CodeCompletionContext::CCC_Recovery);
8793 if (!CodeCompleter || CodeCompleter->includeGlobals()) {
8794 CodeCompletionDeclConsumer Consumer(Builder,
8795 Context.getTranslationUnitDecl());
8796 LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName,
8798 !CodeCompleter || CodeCompleter->loadExternal());
8801 if (!CodeCompleter || CodeCompleter->includeMacros())
8802 AddMacroResults(PP, Builder,
8803 !CodeCompleter || CodeCompleter->loadExternal(), true);
8806 Results.insert(Results.end(), Builder.data(),
8807 Builder.data() + Builder.size());