1 //===---------------- SemaCodeComplete.cpp - Code Completion ----*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the code-completion semantic actions.
11 //
12 //===----------------------------------------------------------------------===//
13 #include "clang/AST/DeclCXX.h"
14 #include "clang/AST/DeclObjC.h"
15 #include "clang/AST/ExprCXX.h"
16 #include "clang/AST/ExprObjC.h"
17 #include "clang/AST/QualTypeNames.h"
18 #include "clang/Basic/CharInfo.h"
19 #include "clang/Lex/HeaderSearch.h"
20 #include "clang/Lex/MacroInfo.h"
21 #include "clang/Lex/Preprocessor.h"
22 #include "clang/Sema/CodeCompleteConsumer.h"
23 #include "clang/Sema/Lookup.h"
24 #include "clang/Sema/Overload.h"
25 #include "clang/Sema/Scope.h"
26 #include "clang/Sema/ScopeInfo.h"
27 #include "clang/Sema/SemaInternal.h"
28 #include "llvm/ADT/DenseSet.h"
29 #include "llvm/ADT/SmallBitVector.h"
30 #include "llvm/ADT/SmallPtrSet.h"
31 #include "llvm/ADT/SmallString.h"
32 #include "llvm/ADT/StringExtras.h"
33 #include "llvm/ADT/StringSwitch.h"
34 #include "llvm/ADT/Twine.h"
35 #include <list>
36 #include <map>
37 #include <vector>
38
39 using namespace clang;
40 using namespace sema;
41
42 namespace {
43 /// A container of code-completion results.
44 class ResultBuilder {
45 public:
46 /// The type of a name-lookup filter, which can be provided to the
47 /// name-lookup routines to specify which declarations should be included in
48 /// the result set (when it returns true) and which declarations should be
49 /// filtered out (returns false).
50 typedef bool (ResultBuilder::*LookupFilter)(const NamedDecl *) const;
51
52 typedef CodeCompletionResult Result;
53
54 private:
55 /// The actual results we have found.
56 std::vector<Result> Results;
57
58 /// A record of all of the declarations we have found and placed
59 /// into the result set, used to ensure that no declaration ever gets into
60 /// the result set twice.
61 llvm::SmallPtrSet<const Decl*, 16> AllDeclsFound;
62
63 typedef std::pair<const NamedDecl *, unsigned> DeclIndexPair;
64
65 /// An entry in the shadow map, which is optimized to store
66 /// a single (declaration, index) mapping (the common case) but
67 /// can also store a list of (declaration, index) mappings.
68 class ShadowMapEntry {
69 typedef SmallVector<DeclIndexPair, 4> DeclIndexPairVector;
70
71 /// Contains either the solitary NamedDecl * or a vector
72 /// of (declaration, index) pairs.
73 llvm::PointerUnion<const NamedDecl *, DeclIndexPairVector*> DeclOrVector;
74
75 /// When the entry contains a single declaration, this is
76 /// the index associated with that entry.
77 unsigned SingleDeclIndex;
78
79 public:
ShadowMapEntry()80 ShadowMapEntry() : DeclOrVector(), SingleDeclIndex(0) { }
81
Add(const NamedDecl * ND,unsigned Index)82 void Add(const NamedDecl *ND, unsigned Index) {
83 if (DeclOrVector.isNull()) {
84 // 0 - > 1 elements: just set the single element information.
85 DeclOrVector = ND;
86 SingleDeclIndex = Index;
87 return;
88 }
89
90 if (const NamedDecl *PrevND =
91 DeclOrVector.dyn_cast<const NamedDecl *>()) {
92 // 1 -> 2 elements: create the vector of results and push in the
93 // existing declaration.
94 DeclIndexPairVector *Vec = new DeclIndexPairVector;
95 Vec->push_back(DeclIndexPair(PrevND, SingleDeclIndex));
96 DeclOrVector = Vec;
97 }
98
99 // Add the new element to the end of the vector.
100 DeclOrVector.get<DeclIndexPairVector*>()->push_back(
101 DeclIndexPair(ND, Index));
102 }
103
Destroy()104 void Destroy() {
105 if (DeclIndexPairVector *Vec
106 = DeclOrVector.dyn_cast<DeclIndexPairVector *>()) {
107 delete Vec;
108 DeclOrVector = ((NamedDecl *)nullptr);
109 }
110 }
111
112 // Iteration.
113 class iterator;
114 iterator begin() const;
115 iterator end() const;
116 };
117
118 /// A mapping from declaration names to the declarations that have
119 /// this name within a particular scope and their index within the list of
120 /// results.
121 typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;
122
123 /// The semantic analysis object for which results are being
124 /// produced.
125 Sema &SemaRef;
126
127 /// The allocator used to allocate new code-completion strings.
128 CodeCompletionAllocator &Allocator;
129
130 CodeCompletionTUInfo &CCTUInfo;
131
132 /// If non-NULL, a filter function used to remove any code-completion
133 /// results that are not desirable.
134 LookupFilter Filter;
135
136 /// Whether we should allow declarations as
137 /// nested-name-specifiers that would otherwise be filtered out.
138 bool AllowNestedNameSpecifiers;
139
140 /// If set, the type that we would prefer our resulting value
141 /// declarations to have.
142 ///
143 /// Closely matching the preferred type gives a boost to a result's
144 /// priority.
145 CanQualType PreferredType;
146
147 /// A list of shadow maps, which is used to model name hiding at
148 /// different levels of, e.g., the inheritance hierarchy.
149 std::list<ShadowMap> ShadowMaps;
150
151 /// If we're potentially referring to a C++ member function, the set
152 /// of qualifiers applied to the object type.
153 Qualifiers ObjectTypeQualifiers;
154
155 /// Whether the \p ObjectTypeQualifiers field is active.
156 bool HasObjectTypeQualifiers;
157
158 /// The selector that we prefer.
159 Selector PreferredSelector;
160
161 /// The completion context in which we are gathering results.
162 CodeCompletionContext CompletionContext;
163
164 /// If we are in an instance method definition, the \@implementation
165 /// object.
166 ObjCImplementationDecl *ObjCImplementation;
167
168 void AdjustResultPriorityForDecl(Result &R);
169
170 void MaybeAddConstructorResults(Result R);
171
172 public:
ResultBuilder(Sema & SemaRef,CodeCompletionAllocator & Allocator,CodeCompletionTUInfo & CCTUInfo,const CodeCompletionContext & CompletionContext,LookupFilter Filter=nullptr)173 explicit ResultBuilder(Sema &SemaRef, CodeCompletionAllocator &Allocator,
174 CodeCompletionTUInfo &CCTUInfo,
175 const CodeCompletionContext &CompletionContext,
176 LookupFilter Filter = nullptr)
177 : SemaRef(SemaRef), Allocator(Allocator), CCTUInfo(CCTUInfo),
178 Filter(Filter),
179 AllowNestedNameSpecifiers(false), HasObjectTypeQualifiers(false),
180 CompletionContext(CompletionContext),
181 ObjCImplementation(nullptr)
182 {
183 // If this is an Objective-C instance method definition, dig out the
184 // corresponding implementation.
185 switch (CompletionContext.getKind()) {
186 case CodeCompletionContext::CCC_Expression:
187 case CodeCompletionContext::CCC_ObjCMessageReceiver:
188 case CodeCompletionContext::CCC_ParenthesizedExpression:
189 case CodeCompletionContext::CCC_Statement:
190 case CodeCompletionContext::CCC_Recovery:
191 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl())
192 if (Method->isInstanceMethod())
193 if (ObjCInterfaceDecl *Interface = Method->getClassInterface())
194 ObjCImplementation = Interface->getImplementation();
195 break;
196
197 default:
198 break;
199 }
200 }
201
202 /// Determine the priority for a reference to the given declaration.
203 unsigned getBasePriority(const NamedDecl *D);
204
205 /// Whether we should include code patterns in the completion
206 /// results.
includeCodePatterns() const207 bool includeCodePatterns() const {
208 return SemaRef.CodeCompleter &&
209 SemaRef.CodeCompleter->includeCodePatterns();
210 }
211
212 /// Set the filter used for code-completion results.
setFilter(LookupFilter Filter)213 void setFilter(LookupFilter Filter) {
214 this->Filter = Filter;
215 }
216
data()217 Result *data() { return Results.empty()? nullptr : &Results.front(); }
size() const218 unsigned size() const { return Results.size(); }
empty() const219 bool empty() const { return Results.empty(); }
220
221 /// Specify the preferred type.
setPreferredType(QualType T)222 void setPreferredType(QualType T) {
223 PreferredType = SemaRef.Context.getCanonicalType(T);
224 }
225
226 /// Set the cv-qualifiers on the object type, for us in filtering
227 /// calls to member functions.
228 ///
229 /// When there are qualifiers in this set, they will be used to filter
230 /// out member functions that aren't available (because there will be a
231 /// cv-qualifier mismatch) or prefer functions with an exact qualifier
232 /// match.
setObjectTypeQualifiers(Qualifiers Quals)233 void setObjectTypeQualifiers(Qualifiers Quals) {
234 ObjectTypeQualifiers = Quals;
235 HasObjectTypeQualifiers = true;
236 }
237
238 /// Set the preferred selector.
239 ///
240 /// When an Objective-C method declaration result is added, and that
241 /// method's selector matches this preferred selector, we give that method
242 /// a slight priority boost.
setPreferredSelector(Selector Sel)243 void setPreferredSelector(Selector Sel) {
244 PreferredSelector = Sel;
245 }
246
247 /// Retrieve the code-completion context for which results are
248 /// being collected.
getCompletionContext() const249 const CodeCompletionContext &getCompletionContext() const {
250 return CompletionContext;
251 }
252
253 /// Specify whether nested-name-specifiers are allowed.
allowNestedNameSpecifiers(bool Allow=true)254 void allowNestedNameSpecifiers(bool Allow = true) {
255 AllowNestedNameSpecifiers = Allow;
256 }
257
258 /// Return the semantic analysis object for which we are collecting
259 /// code completion results.
getSema() const260 Sema &getSema() const { return SemaRef; }
261
262 /// Retrieve the allocator used to allocate code completion strings.
getAllocator() const263 CodeCompletionAllocator &getAllocator() const { return Allocator; }
264
getCodeCompletionTUInfo() const265 CodeCompletionTUInfo &getCodeCompletionTUInfo() const { return CCTUInfo; }
266
267 /// Determine whether the given declaration is at all interesting
268 /// as a code-completion result.
269 ///
270 /// \param ND the declaration that we are inspecting.
271 ///
272 /// \param AsNestedNameSpecifier will be set true if this declaration is
273 /// only interesting when it is a nested-name-specifier.
274 bool isInterestingDecl(const NamedDecl *ND,
275 bool &AsNestedNameSpecifier) const;
276
277 /// Check whether the result is hidden by the Hiding declaration.
278 ///
279 /// \returns true if the result is hidden and cannot be found, false if
280 /// the hidden result could still be found. When false, \p R may be
281 /// modified to describe how the result can be found (e.g., via extra
282 /// qualification).
283 bool CheckHiddenResult(Result &R, DeclContext *CurContext,
284 const NamedDecl *Hiding);
285
286 /// Add a new result to this result set (if it isn't already in one
287 /// of the shadow maps), or replace an existing result (for, e.g., a
288 /// redeclaration).
289 ///
290 /// \param R the result to add (if it is unique).
291 ///
292 /// \param CurContext the context in which this result will be named.
293 void MaybeAddResult(Result R, DeclContext *CurContext = nullptr);
294
295 /// Add a new result to this result set, where we already know
296 /// the hiding declaration (if any).
297 ///
298 /// \param R the result to add (if it is unique).
299 ///
300 /// \param CurContext the context in which this result will be named.
301 ///
302 /// \param Hiding the declaration that hides the result.
303 ///
304 /// \param InBaseClass whether the result was found in a base
305 /// class of the searched context.
306 void AddResult(Result R, DeclContext *CurContext, NamedDecl *Hiding,
307 bool InBaseClass);
308
309 /// Add a new non-declaration result to this result set.
310 void AddResult(Result R);
311
312 /// Enter into a new scope.
313 void EnterNewScope();
314
315 /// Exit from the current scope.
316 void ExitScope();
317
318 /// Ignore this declaration, if it is seen again.
Ignore(const Decl * D)319 void Ignore(const Decl *D) { AllDeclsFound.insert(D->getCanonicalDecl()); }
320
321 /// Add a visited context.
addVisitedContext(DeclContext * Ctx)322 void addVisitedContext(DeclContext *Ctx) {
323 CompletionContext.addVisitedContext(Ctx);
324 }
325
326 /// \name Name lookup predicates
327 ///
328 /// These predicates can be passed to the name lookup functions to filter the
329 /// results of name lookup. All of the predicates have the same type, so that
330 ///
331 //@{
332 bool IsOrdinaryName(const NamedDecl *ND) const;
333 bool IsOrdinaryNonTypeName(const NamedDecl *ND) const;
334 bool IsIntegralConstantValue(const NamedDecl *ND) const;
335 bool IsOrdinaryNonValueName(const NamedDecl *ND) const;
336 bool IsNestedNameSpecifier(const NamedDecl *ND) const;
337 bool IsEnum(const NamedDecl *ND) const;
338 bool IsClassOrStruct(const NamedDecl *ND) const;
339 bool IsUnion(const NamedDecl *ND) const;
340 bool IsNamespace(const NamedDecl *ND) const;
341 bool IsNamespaceOrAlias(const NamedDecl *ND) const;
342 bool IsType(const NamedDecl *ND) const;
343 bool IsMember(const NamedDecl *ND) const;
344 bool IsObjCIvar(const NamedDecl *ND) const;
345 bool IsObjCMessageReceiver(const NamedDecl *ND) const;
346 bool IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const;
347 bool IsObjCCollection(const NamedDecl *ND) const;
348 bool IsImpossibleToSatisfy(const NamedDecl *ND) const;
349 //@}
350 };
351 }
352
353 class ResultBuilder::ShadowMapEntry::iterator {
354 llvm::PointerUnion<const NamedDecl *, const DeclIndexPair *> DeclOrIterator;
355 unsigned SingleDeclIndex;
356
357 public:
358 typedef DeclIndexPair value_type;
359 typedef value_type reference;
360 typedef std::ptrdiff_t difference_type;
361 typedef std::input_iterator_tag iterator_category;
362
363 class pointer {
364 DeclIndexPair Value;
365
366 public:
pointer(const DeclIndexPair & Value)367 pointer(const DeclIndexPair &Value) : Value(Value) { }
368
operator ->() const369 const DeclIndexPair *operator->() const {
370 return &Value;
371 }
372 };
373
iterator()374 iterator() : DeclOrIterator((NamedDecl *)nullptr), SingleDeclIndex(0) {}
375
iterator(const NamedDecl * SingleDecl,unsigned Index)376 iterator(const NamedDecl *SingleDecl, unsigned Index)
377 : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) { }
378
iterator(const DeclIndexPair * Iterator)379 iterator(const DeclIndexPair *Iterator)
380 : DeclOrIterator(Iterator), SingleDeclIndex(0) { }
381
operator ++()382 iterator &operator++() {
383 if (DeclOrIterator.is<const NamedDecl *>()) {
384 DeclOrIterator = (NamedDecl *)nullptr;
385 SingleDeclIndex = 0;
386 return *this;
387 }
388
389 const DeclIndexPair *I = DeclOrIterator.get<const DeclIndexPair*>();
390 ++I;
391 DeclOrIterator = I;
392 return *this;
393 }
394
395 /*iterator operator++(int) {
396 iterator tmp(*this);
397 ++(*this);
398 return tmp;
399 }*/
400
operator *() const401 reference operator*() const {
402 if (const NamedDecl *ND = DeclOrIterator.dyn_cast<const NamedDecl *>())
403 return reference(ND, SingleDeclIndex);
404
405 return *DeclOrIterator.get<const DeclIndexPair*>();
406 }
407
operator ->() const408 pointer operator->() const {
409 return pointer(**this);
410 }
411
operator ==(const iterator & X,const iterator & Y)412 friend bool operator==(const iterator &X, const iterator &Y) {
413 return X.DeclOrIterator.getOpaqueValue()
414 == Y.DeclOrIterator.getOpaqueValue() &&
415 X.SingleDeclIndex == Y.SingleDeclIndex;
416 }
417
operator !=(const iterator & X,const iterator & Y)418 friend bool operator!=(const iterator &X, const iterator &Y) {
419 return !(X == Y);
420 }
421 };
422
423 ResultBuilder::ShadowMapEntry::iterator
begin() const424 ResultBuilder::ShadowMapEntry::begin() const {
425 if (DeclOrVector.isNull())
426 return iterator();
427
428 if (const NamedDecl *ND = DeclOrVector.dyn_cast<const NamedDecl *>())
429 return iterator(ND, SingleDeclIndex);
430
431 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->begin());
432 }
433
434 ResultBuilder::ShadowMapEntry::iterator
end() const435 ResultBuilder::ShadowMapEntry::end() const {
436 if (DeclOrVector.is<const NamedDecl *>() || DeclOrVector.isNull())
437 return iterator();
438
439 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end());
440 }
441
442 /// Compute the qualification required to get from the current context
443 /// (\p CurContext) to the target context (\p TargetContext).
444 ///
445 /// \param Context the AST context in which the qualification will be used.
446 ///
447 /// \param CurContext the context where an entity is being named, which is
448 /// typically based on the current scope.
449 ///
450 /// \param TargetContext the context in which the named entity actually
451 /// resides.
452 ///
453 /// \returns a nested name specifier that refers into the target context, or
454 /// NULL if no qualification is needed.
455 static NestedNameSpecifier *
getRequiredQualification(ASTContext & Context,const DeclContext * CurContext,const DeclContext * TargetContext)456 getRequiredQualification(ASTContext &Context,
457 const DeclContext *CurContext,
458 const DeclContext *TargetContext) {
459 SmallVector<const DeclContext *, 4> TargetParents;
460
461 for (const DeclContext *CommonAncestor = TargetContext;
462 CommonAncestor && !CommonAncestor->Encloses(CurContext);
463 CommonAncestor = CommonAncestor->getLookupParent()) {
464 if (CommonAncestor->isTransparentContext() ||
465 CommonAncestor->isFunctionOrMethod())
466 continue;
467
468 TargetParents.push_back(CommonAncestor);
469 }
470
471 NestedNameSpecifier *Result = nullptr;
472 while (!TargetParents.empty()) {
473 const DeclContext *Parent = TargetParents.pop_back_val();
474
475 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Parent)) {
476 if (!Namespace->getIdentifier())
477 continue;
478
479 Result = NestedNameSpecifier::Create(Context, Result, Namespace);
480 }
481 else if (const TagDecl *TD = dyn_cast<TagDecl>(Parent))
482 Result = NestedNameSpecifier::Create(Context, Result,
483 false,
484 Context.getTypeDeclType(TD).getTypePtr());
485 }
486 return Result;
487 }
488
489 /// Determine whether \p Id is a name reserved for the implementation (C99
490 /// 7.1.3, C++ [lib.global.names]).
isReservedName(const IdentifierInfo * Id,bool doubleUnderscoreOnly=false)491 static bool isReservedName(const IdentifierInfo *Id,
492 bool doubleUnderscoreOnly = false) {
493 if (Id->getLength() < 2)
494 return false;
495 const char *Name = Id->getNameStart();
496 return Name[0] == '_' &&
497 (Name[1] == '_' || (Name[1] >= 'A' && Name[1] <= 'Z' &&
498 !doubleUnderscoreOnly));
499 }
500
501 // Some declarations have reserved names that we don't want to ever show.
502 // Filter out names reserved for the implementation if they come from a
503 // system header.
shouldIgnoreDueToReservedName(const NamedDecl * ND,Sema & SemaRef)504 static bool shouldIgnoreDueToReservedName(const NamedDecl *ND, Sema &SemaRef) {
505 const IdentifierInfo *Id = ND->getIdentifier();
506 if (!Id)
507 return false;
508
509 // Ignore reserved names for compiler provided decls.
510 if (isReservedName(Id) && ND->getLocation().isInvalid())
511 return true;
512
513 // For system headers ignore only double-underscore names.
514 // This allows for system headers providing private symbols with a single
515 // underscore.
516 if (isReservedName(Id, /*doubleUnderscoreOnly=*/true) &&
517 SemaRef.SourceMgr.isInSystemHeader(
518 SemaRef.SourceMgr.getSpellingLoc(ND->getLocation())))
519 return true;
520
521 return false;
522 }
523
isInterestingDecl(const NamedDecl * ND,bool & AsNestedNameSpecifier) const524 bool ResultBuilder::isInterestingDecl(const NamedDecl *ND,
525 bool &AsNestedNameSpecifier) const {
526 AsNestedNameSpecifier = false;
527
528 auto *Named = ND;
529 ND = ND->getUnderlyingDecl();
530
531 // Skip unnamed entities.
532 if (!ND->getDeclName())
533 return false;
534
535 // Friend declarations and declarations introduced due to friends are never
536 // added as results.
537 if (ND->getFriendObjectKind() == Decl::FOK_Undeclared)
538 return false;
539
540 // Class template (partial) specializations are never added as results.
541 if (isa<ClassTemplateSpecializationDecl>(ND) ||
542 isa<ClassTemplatePartialSpecializationDecl>(ND))
543 return false;
544
545 // Using declarations themselves are never added as results.
546 if (isa<UsingDecl>(ND))
547 return false;
548
549 if (shouldIgnoreDueToReservedName(ND, SemaRef))
550 return false;
551
552 if (Filter == &ResultBuilder::IsNestedNameSpecifier ||
553 (isa<NamespaceDecl>(ND) &&
554 Filter != &ResultBuilder::IsNamespace &&
555 Filter != &ResultBuilder::IsNamespaceOrAlias &&
556 Filter != nullptr))
557 AsNestedNameSpecifier = true;
558
559 // Filter out any unwanted results.
560 if (Filter && !(this->*Filter)(Named)) {
561 // Check whether it is interesting as a nested-name-specifier.
562 if (AllowNestedNameSpecifiers && SemaRef.getLangOpts().CPlusPlus &&
563 IsNestedNameSpecifier(ND) &&
564 (Filter != &ResultBuilder::IsMember ||
565 (isa<CXXRecordDecl>(ND) &&
566 cast<CXXRecordDecl>(ND)->isInjectedClassName()))) {
567 AsNestedNameSpecifier = true;
568 return true;
569 }
570
571 return false;
572 }
573 // ... then it must be interesting!
574 return true;
575 }
576
CheckHiddenResult(Result & R,DeclContext * CurContext,const NamedDecl * Hiding)577 bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext,
578 const NamedDecl *Hiding) {
579 // In C, there is no way to refer to a hidden name.
580 // FIXME: This isn't true; we can find a tag name hidden by an ordinary
581 // name if we introduce the tag type.
582 if (!SemaRef.getLangOpts().CPlusPlus)
583 return true;
584
585 const DeclContext *HiddenCtx =
586 R.Declaration->getDeclContext()->getRedeclContext();
587
588 // There is no way to qualify a name declared in a function or method.
589 if (HiddenCtx->isFunctionOrMethod())
590 return true;
591
592 if (HiddenCtx == Hiding->getDeclContext()->getRedeclContext())
593 return true;
594
595 // We can refer to the result with the appropriate qualification. Do it.
596 R.Hidden = true;
597 R.QualifierIsInformative = false;
598
599 if (!R.Qualifier)
600 R.Qualifier = getRequiredQualification(SemaRef.Context,
601 CurContext,
602 R.Declaration->getDeclContext());
603 return false;
604 }
605
606 /// A simplified classification of types used to determine whether two
607 /// types are "similar enough" when adjusting priorities.
getSimplifiedTypeClass(CanQualType T)608 SimplifiedTypeClass clang::getSimplifiedTypeClass(CanQualType T) {
609 switch (T->getTypeClass()) {
610 case Type::Builtin:
611 switch (cast<BuiltinType>(T)->getKind()) {
612 case BuiltinType::Void:
613 return STC_Void;
614
615 case BuiltinType::NullPtr:
616 return STC_Pointer;
617
618 case BuiltinType::Overload:
619 case BuiltinType::Dependent:
620 return STC_Other;
621
622 case BuiltinType::ObjCId:
623 case BuiltinType::ObjCClass:
624 case BuiltinType::ObjCSel:
625 return STC_ObjectiveC;
626
627 default:
628 return STC_Arithmetic;
629 }
630
631 case Type::Complex:
632 return STC_Arithmetic;
633
634 case Type::Pointer:
635 return STC_Pointer;
636
637 case Type::BlockPointer:
638 return STC_Block;
639
640 case Type::LValueReference:
641 case Type::RValueReference:
642 return getSimplifiedTypeClass(T->getAs<ReferenceType>()->getPointeeType());
643
644 case Type::ConstantArray:
645 case Type::IncompleteArray:
646 case Type::VariableArray:
647 case Type::DependentSizedArray:
648 return STC_Array;
649
650 case Type::DependentSizedExtVector:
651 case Type::Vector:
652 case Type::ExtVector:
653 return STC_Arithmetic;
654
655 case Type::FunctionProto:
656 case Type::FunctionNoProto:
657 return STC_Function;
658
659 case Type::Record:
660 return STC_Record;
661
662 case Type::Enum:
663 return STC_Arithmetic;
664
665 case Type::ObjCObject:
666 case Type::ObjCInterface:
667 case Type::ObjCObjectPointer:
668 return STC_ObjectiveC;
669
670 default:
671 return STC_Other;
672 }
673 }
674
675 /// Get the type that a given expression will have if this declaration
676 /// is used as an expression in its "typical" code-completion form.
getDeclUsageType(ASTContext & C,const NamedDecl * ND)677 QualType clang::getDeclUsageType(ASTContext &C, const NamedDecl *ND) {
678 ND = ND->getUnderlyingDecl();
679
680 if (const TypeDecl *Type = dyn_cast<TypeDecl>(ND))
681 return C.getTypeDeclType(Type);
682 if (const ObjCInterfaceDecl *Iface = dyn_cast<ObjCInterfaceDecl>(ND))
683 return C.getObjCInterfaceType(Iface);
684
685 QualType T;
686 if (const FunctionDecl *Function = ND->getAsFunction())
687 T = Function->getCallResultType();
688 else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND))
689 T = Method->getSendResultType();
690 else if (const EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND))
691 T = C.getTypeDeclType(cast<EnumDecl>(Enumerator->getDeclContext()));
692 else if (const ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND))
693 T = Property->getType();
694 else if (const ValueDecl *Value = dyn_cast<ValueDecl>(ND))
695 T = Value->getType();
696 else
697 return QualType();
698
699 // Dig through references, function pointers, and block pointers to
700 // get down to the likely type of an expression when the entity is
701 // used.
702 do {
703 if (const ReferenceType *Ref = T->getAs<ReferenceType>()) {
704 T = Ref->getPointeeType();
705 continue;
706 }
707
708 if (const PointerType *Pointer = T->getAs<PointerType>()) {
709 if (Pointer->getPointeeType()->isFunctionType()) {
710 T = Pointer->getPointeeType();
711 continue;
712 }
713
714 break;
715 }
716
717 if (const BlockPointerType *Block = T->getAs<BlockPointerType>()) {
718 T = Block->getPointeeType();
719 continue;
720 }
721
722 if (const FunctionType *Function = T->getAs<FunctionType>()) {
723 T = Function->getReturnType();
724 continue;
725 }
726
727 break;
728 } while (true);
729
730 return T;
731 }
732
getBasePriority(const NamedDecl * ND)733 unsigned ResultBuilder::getBasePriority(const NamedDecl *ND) {
734 if (!ND)
735 return CCP_Unlikely;
736
737 // Context-based decisions.
738 const DeclContext *LexicalDC = ND->getLexicalDeclContext();
739 if (LexicalDC->isFunctionOrMethod()) {
740 // _cmd is relatively rare
741 if (const ImplicitParamDecl *ImplicitParam =
742 dyn_cast<ImplicitParamDecl>(ND))
743 if (ImplicitParam->getIdentifier() &&
744 ImplicitParam->getIdentifier()->isStr("_cmd"))
745 return CCP_ObjC_cmd;
746
747 return CCP_LocalDeclaration;
748 }
749
750 const DeclContext *DC = ND->getDeclContext()->getRedeclContext();
751 if (DC->isRecord() || isa<ObjCContainerDecl>(DC)) {
752 // Explicit destructor calls are very rare.
753 if (isa<CXXDestructorDecl>(ND))
754 return CCP_Unlikely;
755 // Explicit operator and conversion function calls are also very rare.
756 auto DeclNameKind = ND->getDeclName().getNameKind();
757 if (DeclNameKind == DeclarationName::CXXOperatorName ||
758 DeclNameKind == DeclarationName::CXXLiteralOperatorName ||
759 DeclNameKind == DeclarationName::CXXConversionFunctionName)
760 return CCP_Unlikely;
761 return CCP_MemberDeclaration;
762 }
763
764 // Content-based decisions.
765 if (isa<EnumConstantDecl>(ND))
766 return CCP_Constant;
767
768 // Use CCP_Type for type declarations unless we're in a statement, Objective-C
769 // message receiver, or parenthesized expression context. There, it's as
770 // likely that the user will want to write a type as other declarations.
771 if ((isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) &&
772 !(CompletionContext.getKind() == CodeCompletionContext::CCC_Statement ||
773 CompletionContext.getKind()
774 == CodeCompletionContext::CCC_ObjCMessageReceiver ||
775 CompletionContext.getKind()
776 == CodeCompletionContext::CCC_ParenthesizedExpression))
777 return CCP_Type;
778
779 return CCP_Declaration;
780 }
781
AdjustResultPriorityForDecl(Result & R)782 void ResultBuilder::AdjustResultPriorityForDecl(Result &R) {
783 // If this is an Objective-C method declaration whose selector matches our
784 // preferred selector, give it a priority boost.
785 if (!PreferredSelector.isNull())
786 if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(R.Declaration))
787 if (PreferredSelector == Method->getSelector())
788 R.Priority += CCD_SelectorMatch;
789
790 // If we have a preferred type, adjust the priority for results with exactly-
791 // matching or nearly-matching types.
792 if (!PreferredType.isNull()) {
793 QualType T = getDeclUsageType(SemaRef.Context, R.Declaration);
794 if (!T.isNull()) {
795 CanQualType TC = SemaRef.Context.getCanonicalType(T);
796 // Check for exactly-matching types (modulo qualifiers).
797 if (SemaRef.Context.hasSameUnqualifiedType(PreferredType, TC))
798 R.Priority /= CCF_ExactTypeMatch;
799 // Check for nearly-matching types, based on classification of each.
800 else if ((getSimplifiedTypeClass(PreferredType)
801 == getSimplifiedTypeClass(TC)) &&
802 !(PreferredType->isEnumeralType() && TC->isEnumeralType()))
803 R.Priority /= CCF_SimilarTypeMatch;
804 }
805 }
806 }
807
MaybeAddConstructorResults(Result R)808 void ResultBuilder::MaybeAddConstructorResults(Result R) {
809 if (!SemaRef.getLangOpts().CPlusPlus || !R.Declaration ||
810 !CompletionContext.wantConstructorResults())
811 return;
812
813 ASTContext &Context = SemaRef.Context;
814 const NamedDecl *D = R.Declaration;
815 const CXXRecordDecl *Record = nullptr;
816 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D))
817 Record = ClassTemplate->getTemplatedDecl();
818 else if ((Record = dyn_cast<CXXRecordDecl>(D))) {
819 // Skip specializations and partial specializations.
820 if (isa<ClassTemplateSpecializationDecl>(Record))
821 return;
822 } else {
823 // There are no constructors here.
824 return;
825 }
826
827 Record = Record->getDefinition();
828 if (!Record)
829 return;
830
831
832 QualType RecordTy = Context.getTypeDeclType(Record);
833 DeclarationName ConstructorName
834 = Context.DeclarationNames.getCXXConstructorName(
835 Context.getCanonicalType(RecordTy));
836 DeclContext::lookup_result Ctors = Record->lookup(ConstructorName);
837 for (DeclContext::lookup_iterator I = Ctors.begin(),
838 E = Ctors.end();
839 I != E; ++I) {
840 R.Declaration = *I;
841 R.CursorKind = getCursorKindForDecl(R.Declaration);
842 Results.push_back(R);
843 }
844 }
845
isConstructor(const Decl * ND)846 static bool isConstructor(const Decl *ND) {
847 if (const auto *Tmpl = dyn_cast<FunctionTemplateDecl>(ND))
848 ND = Tmpl->getTemplatedDecl();
849 return isa<CXXConstructorDecl>(ND);
850 }
851
MaybeAddResult(Result R,DeclContext * CurContext)852 void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) {
853 assert(!ShadowMaps.empty() && "Must enter into a results scope");
854
855 if (R.Kind != Result::RK_Declaration) {
856 // For non-declaration results, just add the result.
857 Results.push_back(R);
858 return;
859 }
860
861 // Look through using declarations.
862 if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
863 CodeCompletionResult Result(Using->getTargetDecl(),
864 getBasePriority(Using->getTargetDecl()),
865 R.Qualifier);
866 Result.ShadowDecl = Using;
867 MaybeAddResult(Result, CurContext);
868 return;
869 }
870
871 const Decl *CanonDecl = R.Declaration->getCanonicalDecl();
872 unsigned IDNS = CanonDecl->getIdentifierNamespace();
873
874 bool AsNestedNameSpecifier = false;
875 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
876 return;
877
878 // C++ constructors are never found by name lookup.
879 if (isConstructor(R.Declaration))
880 return;
881
882 ShadowMap &SMap = ShadowMaps.back();
883 ShadowMapEntry::iterator I, IEnd;
884 ShadowMap::iterator NamePos = SMap.find(R.Declaration->getDeclName());
885 if (NamePos != SMap.end()) {
886 I = NamePos->second.begin();
887 IEnd = NamePos->second.end();
888 }
889
890 for (; I != IEnd; ++I) {
891 const NamedDecl *ND = I->first;
892 unsigned Index = I->second;
893 if (ND->getCanonicalDecl() == CanonDecl) {
894 // This is a redeclaration. Always pick the newer declaration.
895 Results[Index].Declaration = R.Declaration;
896
897 // We're done.
898 return;
899 }
900 }
901
902 // This is a new declaration in this scope. However, check whether this
903 // declaration name is hidden by a similarly-named declaration in an outer
904 // scope.
905 std::list<ShadowMap>::iterator SM, SMEnd = ShadowMaps.end();
906 --SMEnd;
907 for (SM = ShadowMaps.begin(); SM != SMEnd; ++SM) {
908 ShadowMapEntry::iterator I, IEnd;
909 ShadowMap::iterator NamePos = SM->find(R.Declaration->getDeclName());
910 if (NamePos != SM->end()) {
911 I = NamePos->second.begin();
912 IEnd = NamePos->second.end();
913 }
914 for (; I != IEnd; ++I) {
915 // A tag declaration does not hide a non-tag declaration.
916 if (I->first->hasTagIdentifierNamespace() &&
917 (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary |
918 Decl::IDNS_LocalExtern | Decl::IDNS_ObjCProtocol)))
919 continue;
920
921 // Protocols are in distinct namespaces from everything else.
922 if (((I->first->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol)
923 || (IDNS & Decl::IDNS_ObjCProtocol)) &&
924 I->first->getIdentifierNamespace() != IDNS)
925 continue;
926
927 // The newly-added result is hidden by an entry in the shadow map.
928 if (CheckHiddenResult(R, CurContext, I->first))
929 return;
930
931 break;
932 }
933 }
934
935 // Make sure that any given declaration only shows up in the result set once.
936 if (!AllDeclsFound.insert(CanonDecl).second)
937 return;
938
939 // If the filter is for nested-name-specifiers, then this result starts a
940 // nested-name-specifier.
941 if (AsNestedNameSpecifier) {
942 R.StartsNestedNameSpecifier = true;
943 R.Priority = CCP_NestedNameSpecifier;
944 } else
945 AdjustResultPriorityForDecl(R);
946
947 // If this result is supposed to have an informative qualifier, add one.
948 if (R.QualifierIsInformative && !R.Qualifier &&
949 !R.StartsNestedNameSpecifier) {
950 const DeclContext *Ctx = R.Declaration->getDeclContext();
951 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
952 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr,
953 Namespace);
954 else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
955 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr,
956 false, SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
957 else
958 R.QualifierIsInformative = false;
959 }
960
961 // Insert this result into the set of results and into the current shadow
962 // map.
963 SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size());
964 Results.push_back(R);
965
966 if (!AsNestedNameSpecifier)
967 MaybeAddConstructorResults(R);
968 }
969
AddResult(Result R,DeclContext * CurContext,NamedDecl * Hiding,bool InBaseClass=false)970 void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
971 NamedDecl *Hiding, bool InBaseClass = false) {
972 if (R.Kind != Result::RK_Declaration) {
973 // For non-declaration results, just add the result.
974 Results.push_back(R);
975 return;
976 }
977
978 // Look through using declarations.
979 if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
980 CodeCompletionResult Result(Using->getTargetDecl(),
981 getBasePriority(Using->getTargetDecl()),
982 R.Qualifier);
983 Result.ShadowDecl = Using;
984 AddResult(Result, CurContext, Hiding);
985 return;
986 }
987
988 bool AsNestedNameSpecifier = false;
989 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
990 return;
991
992 // C++ constructors are never found by name lookup.
993 if (isConstructor(R.Declaration))
994 return;
995
996 if (Hiding && CheckHiddenResult(R, CurContext, Hiding))
997 return;
998
999 // Make sure that any given declaration only shows up in the result set once.
1000 if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl()).second)
1001 return;
1002
1003 // If the filter is for nested-name-specifiers, then this result starts a
1004 // nested-name-specifier.
1005 if (AsNestedNameSpecifier) {
1006 R.StartsNestedNameSpecifier = true;
1007 R.Priority = CCP_NestedNameSpecifier;
1008 } else if (Filter == &ResultBuilder::IsMember && !R.Qualifier &&
1009 InBaseClass &&
1010 isa<CXXRecordDecl>(
1011 R.Declaration->getDeclContext()->getRedeclContext()))
1012 R.QualifierIsInformative = true;
1013
1014 // If this result is supposed to have an informative qualifier, add one.
1015 if (R.QualifierIsInformative && !R.Qualifier &&
1016 !R.StartsNestedNameSpecifier) {
1017 const DeclContext *Ctx = R.Declaration->getDeclContext();
1018 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
1019 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr,
1020 Namespace);
1021 else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
1022 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr, false,
1023 SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
1024 else
1025 R.QualifierIsInformative = false;
1026 }
1027
1028 // Adjust the priority if this result comes from a base class.
1029 if (InBaseClass)
1030 R.Priority += CCD_InBaseClass;
1031
1032 AdjustResultPriorityForDecl(R);
1033
1034 if (HasObjectTypeQualifiers)
1035 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(R.Declaration))
1036 if (Method->isInstance()) {
1037 Qualifiers MethodQuals
1038 = Qualifiers::fromCVRMask(Method->getTypeQualifiers());
1039 if (ObjectTypeQualifiers == MethodQuals)
1040 R.Priority += CCD_ObjectQualifierMatch;
1041 else if (ObjectTypeQualifiers - MethodQuals) {
1042 // The method cannot be invoked, because doing so would drop
1043 // qualifiers.
1044 return;
1045 }
1046 }
1047
1048 // Insert this result into the set of results.
1049 Results.push_back(R);
1050
1051 if (!AsNestedNameSpecifier)
1052 MaybeAddConstructorResults(R);
1053 }
1054
AddResult(Result R)1055 void ResultBuilder::AddResult(Result R) {
1056 assert(R.Kind != Result::RK_Declaration &&
1057 "Declaration results need more context");
1058 Results.push_back(R);
1059 }
1060
1061 /// Enter into a new scope.
EnterNewScope()1062 void ResultBuilder::EnterNewScope() { ShadowMaps.emplace_back(); }
1063
1064 /// Exit from the current scope.
ExitScope()1065 void ResultBuilder::ExitScope() {
1066 for (ShadowMap::iterator E = ShadowMaps.back().begin(),
1067 EEnd = ShadowMaps.back().end();
1068 E != EEnd;
1069 ++E)
1070 E->second.Destroy();
1071
1072 ShadowMaps.pop_back();
1073 }
1074
1075 /// Determines whether this given declaration will be found by
1076 /// ordinary name lookup.
IsOrdinaryName(const NamedDecl * ND) const1077 bool ResultBuilder::IsOrdinaryName(const NamedDecl *ND) const {
1078 ND = ND->getUnderlyingDecl();
1079
1080 // If name lookup finds a local extern declaration, then we are in a
1081 // context where it behaves like an ordinary name.
1082 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1083 if (SemaRef.getLangOpts().CPlusPlus)
1084 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
1085 else if (SemaRef.getLangOpts().ObjC1) {
1086 if (isa<ObjCIvarDecl>(ND))
1087 return true;
1088 }
1089
1090 return ND->getIdentifierNamespace() & IDNS;
1091 }
1092
1093 /// Determines whether this given declaration will be found by
1094 /// ordinary name lookup but is not a type name.
IsOrdinaryNonTypeName(const NamedDecl * ND) const1095 bool ResultBuilder::IsOrdinaryNonTypeName(const NamedDecl *ND) const {
1096 ND = ND->getUnderlyingDecl();
1097 if (isa<TypeDecl>(ND))
1098 return false;
1099 // Objective-C interfaces names are not filtered by this method because they
1100 // can be used in a class property expression. We can still filter out
1101 // @class declarations though.
1102 if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND)) {
1103 if (!ID->getDefinition())
1104 return false;
1105 }
1106
1107 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1108 if (SemaRef.getLangOpts().CPlusPlus)
1109 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
1110 else if (SemaRef.getLangOpts().ObjC1) {
1111 if (isa<ObjCIvarDecl>(ND))
1112 return true;
1113 }
1114
1115 return ND->getIdentifierNamespace() & IDNS;
1116 }
1117
IsIntegralConstantValue(const NamedDecl * ND) const1118 bool ResultBuilder::IsIntegralConstantValue(const NamedDecl *ND) const {
1119 if (!IsOrdinaryNonTypeName(ND))
1120 return 0;
1121
1122 if (const ValueDecl *VD = dyn_cast<ValueDecl>(ND->getUnderlyingDecl()))
1123 if (VD->getType()->isIntegralOrEnumerationType())
1124 return true;
1125
1126 return false;
1127 }
1128
1129 /// Determines whether this given declaration will be found by
1130 /// ordinary name lookup.
IsOrdinaryNonValueName(const NamedDecl * ND) const1131 bool ResultBuilder::IsOrdinaryNonValueName(const NamedDecl *ND) const {
1132 ND = ND->getUnderlyingDecl();
1133
1134 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1135 if (SemaRef.getLangOpts().CPlusPlus)
1136 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace;
1137
1138 return (ND->getIdentifierNamespace() & IDNS) &&
1139 !isa<ValueDecl>(ND) && !isa<FunctionTemplateDecl>(ND) &&
1140 !isa<ObjCPropertyDecl>(ND);
1141 }
1142
1143 /// Determines whether the given declaration is suitable as the
1144 /// start of a C++ nested-name-specifier, e.g., a class or namespace.
IsNestedNameSpecifier(const NamedDecl * ND) const1145 bool ResultBuilder::IsNestedNameSpecifier(const NamedDecl *ND) const {
1146 // Allow us to find class templates, too.
1147 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1148 ND = ClassTemplate->getTemplatedDecl();
1149
1150 return SemaRef.isAcceptableNestedNameSpecifier(ND);
1151 }
1152
1153 /// Determines whether the given declaration is an enumeration.
IsEnum(const NamedDecl * ND) const1154 bool ResultBuilder::IsEnum(const NamedDecl *ND) const {
1155 return isa<EnumDecl>(ND);
1156 }
1157
1158 /// Determines whether the given declaration is a class or struct.
IsClassOrStruct(const NamedDecl * ND) const1159 bool ResultBuilder::IsClassOrStruct(const NamedDecl *ND) const {
1160 // Allow us to find class templates, too.
1161 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1162 ND = ClassTemplate->getTemplatedDecl();
1163
1164 // For purposes of this check, interfaces match too.
1165 if (const RecordDecl *RD = dyn_cast<RecordDecl>(ND))
1166 return RD->getTagKind() == TTK_Class ||
1167 RD->getTagKind() == TTK_Struct ||
1168 RD->getTagKind() == TTK_Interface;
1169
1170 return false;
1171 }
1172
1173 /// Determines whether the given declaration is a union.
IsUnion(const NamedDecl * ND) const1174 bool ResultBuilder::IsUnion(const NamedDecl *ND) const {
1175 // Allow us to find class templates, too.
1176 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1177 ND = ClassTemplate->getTemplatedDecl();
1178
1179 if (const RecordDecl *RD = dyn_cast<RecordDecl>(ND))
1180 return RD->getTagKind() == TTK_Union;
1181
1182 return false;
1183 }
1184
1185 /// Determines whether the given declaration is a namespace.
IsNamespace(const NamedDecl * ND) const1186 bool ResultBuilder::IsNamespace(const NamedDecl *ND) const {
1187 return isa<NamespaceDecl>(ND);
1188 }
1189
1190 /// Determines whether the given declaration is a namespace or
1191 /// namespace alias.
IsNamespaceOrAlias(const NamedDecl * ND) const1192 bool ResultBuilder::IsNamespaceOrAlias(const NamedDecl *ND) const {
1193 return isa<NamespaceDecl>(ND->getUnderlyingDecl());
1194 }
1195
1196 /// Determines whether the given declaration is a type.
IsType(const NamedDecl * ND) const1197 bool ResultBuilder::IsType(const NamedDecl *ND) const {
1198 ND = ND->getUnderlyingDecl();
1199 return isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
1200 }
1201
1202 /// Determines which members of a class should be visible via
1203 /// "." or "->". Only value declarations, nested name specifiers, and
1204 /// using declarations thereof should show up.
IsMember(const NamedDecl * ND) const1205 bool ResultBuilder::IsMember(const NamedDecl *ND) const {
1206 ND = ND->getUnderlyingDecl();
1207 return isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND) ||
1208 isa<ObjCPropertyDecl>(ND);
1209 }
1210
isObjCReceiverType(ASTContext & C,QualType T)1211 static bool isObjCReceiverType(ASTContext &C, QualType T) {
1212 T = C.getCanonicalType(T);
1213 switch (T->getTypeClass()) {
1214 case Type::ObjCObject:
1215 case Type::ObjCInterface:
1216 case Type::ObjCObjectPointer:
1217 return true;
1218
1219 case Type::Builtin:
1220 switch (cast<BuiltinType>(T)->getKind()) {
1221 case BuiltinType::ObjCId:
1222 case BuiltinType::ObjCClass:
1223 case BuiltinType::ObjCSel:
1224 return true;
1225
1226 default:
1227 break;
1228 }
1229 return false;
1230
1231 default:
1232 break;
1233 }
1234
1235 if (!C.getLangOpts().CPlusPlus)
1236 return false;
1237
1238 // FIXME: We could perform more analysis here to determine whether a
1239 // particular class type has any conversions to Objective-C types. For now,
1240 // just accept all class types.
1241 return T->isDependentType() || T->isRecordType();
1242 }
1243
IsObjCMessageReceiver(const NamedDecl * ND) const1244 bool ResultBuilder::IsObjCMessageReceiver(const NamedDecl *ND) const {
1245 QualType T = getDeclUsageType(SemaRef.Context, ND);
1246 if (T.isNull())
1247 return false;
1248
1249 T = SemaRef.Context.getBaseElementType(T);
1250 return isObjCReceiverType(SemaRef.Context, T);
1251 }
1252
IsObjCMessageReceiverOrLambdaCapture(const NamedDecl * ND) const1253 bool ResultBuilder::IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const {
1254 if (IsObjCMessageReceiver(ND))
1255 return true;
1256
1257 const VarDecl *Var = dyn_cast<VarDecl>(ND);
1258 if (!Var)
1259 return false;
1260
1261 return Var->hasLocalStorage() && !Var->hasAttr<BlocksAttr>();
1262 }
1263
IsObjCCollection(const NamedDecl * ND) const1264 bool ResultBuilder::IsObjCCollection(const NamedDecl *ND) const {
1265 if ((SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryName(ND)) ||
1266 (!SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryNonTypeName(ND)))
1267 return false;
1268
1269 QualType T = getDeclUsageType(SemaRef.Context, ND);
1270 if (T.isNull())
1271 return false;
1272
1273 T = SemaRef.Context.getBaseElementType(T);
1274 return T->isObjCObjectType() || T->isObjCObjectPointerType() ||
1275 T->isObjCIdType() ||
1276 (SemaRef.getLangOpts().CPlusPlus && T->isRecordType());
1277 }
1278
IsImpossibleToSatisfy(const NamedDecl * ND) const1279 bool ResultBuilder::IsImpossibleToSatisfy(const NamedDecl *ND) const {
1280 return false;
1281 }
1282
1283 /// Determines whether the given declaration is an Objective-C
1284 /// instance variable.
IsObjCIvar(const NamedDecl * ND) const1285 bool ResultBuilder::IsObjCIvar(const NamedDecl *ND) const {
1286 return isa<ObjCIvarDecl>(ND);
1287 }
1288
1289 namespace {
1290 /// Visible declaration consumer that adds a code-completion result
1291 /// for each visible declaration.
1292 class CodeCompletionDeclConsumer : public VisibleDeclConsumer {
1293 ResultBuilder &Results;
1294 DeclContext *CurContext;
1295 std::vector<FixItHint> FixIts;
1296
1297 public:
CodeCompletionDeclConsumer(ResultBuilder & Results,DeclContext * CurContext,std::vector<FixItHint> FixIts=std::vector<FixItHint> ())1298 CodeCompletionDeclConsumer(
1299 ResultBuilder &Results, DeclContext *CurContext,
1300 std::vector<FixItHint> FixIts = std::vector<FixItHint>())
1301 : Results(Results), CurContext(CurContext), FixIts(std::move(FixIts)) {}
1302
FoundDecl(NamedDecl * ND,NamedDecl * Hiding,DeclContext * Ctx,bool InBaseClass)1303 void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,
1304 bool InBaseClass) override {
1305 bool Accessible = true;
1306 if (Ctx)
1307 Accessible = Results.getSema().IsSimplyAccessible(ND, Ctx);
1308 ResultBuilder::Result Result(ND, Results.getBasePriority(ND), nullptr,
1309 false, Accessible, FixIts);
1310 Results.AddResult(Result, CurContext, Hiding, InBaseClass);
1311 }
1312
EnteredContext(DeclContext * Ctx)1313 void EnteredContext(DeclContext* Ctx) override {
1314 Results.addVisitedContext(Ctx);
1315 }
1316 };
1317 }
1318
1319 /// Add type specifiers for the current language as keyword results.
AddTypeSpecifierResults(const LangOptions & LangOpts,ResultBuilder & Results)1320 static void AddTypeSpecifierResults(const LangOptions &LangOpts,
1321 ResultBuilder &Results) {
1322 typedef CodeCompletionResult Result;
1323 Results.AddResult(Result("short", CCP_Type));
1324 Results.AddResult(Result("long", CCP_Type));
1325 Results.AddResult(Result("signed", CCP_Type));
1326 Results.AddResult(Result("unsigned", CCP_Type));
1327 Results.AddResult(Result("void", CCP_Type));
1328 Results.AddResult(Result("char", CCP_Type));
1329 Results.AddResult(Result("int", CCP_Type));
1330 Results.AddResult(Result("float", CCP_Type));
1331 Results.AddResult(Result("double", CCP_Type));
1332 Results.AddResult(Result("enum", CCP_Type));
1333 Results.AddResult(Result("struct", CCP_Type));
1334 Results.AddResult(Result("union", CCP_Type));
1335 Results.AddResult(Result("const", CCP_Type));
1336 Results.AddResult(Result("volatile", CCP_Type));
1337
1338 if (LangOpts.C99) {
1339 // C99-specific
1340 Results.AddResult(Result("_Complex", CCP_Type));
1341 Results.AddResult(Result("_Imaginary", CCP_Type));
1342 Results.AddResult(Result("_Bool", CCP_Type));
1343 Results.AddResult(Result("restrict", CCP_Type));
1344 }
1345
1346 CodeCompletionBuilder Builder(Results.getAllocator(),
1347 Results.getCodeCompletionTUInfo());
1348 if (LangOpts.CPlusPlus) {
1349 // C++-specific
1350 Results.AddResult(Result("bool", CCP_Type +
1351 (LangOpts.ObjC1? CCD_bool_in_ObjC : 0)));
1352 Results.AddResult(Result("class", CCP_Type));
1353 Results.AddResult(Result("wchar_t", CCP_Type));
1354
1355 // typename qualified-id
1356 Builder.AddTypedTextChunk("typename");
1357 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1358 Builder.AddPlaceholderChunk("qualifier");
1359 Builder.AddTextChunk("::");
1360 Builder.AddPlaceholderChunk("name");
1361 Results.AddResult(Result(Builder.TakeString()));
1362
1363 if (LangOpts.CPlusPlus11) {
1364 Results.AddResult(Result("auto", CCP_Type));
1365 Results.AddResult(Result("char16_t", CCP_Type));
1366 Results.AddResult(Result("char32_t", CCP_Type));
1367
1368 Builder.AddTypedTextChunk("decltype");
1369 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1370 Builder.AddPlaceholderChunk("expression");
1371 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1372 Results.AddResult(Result(Builder.TakeString()));
1373 }
1374 } else
1375 Results.AddResult(Result("__auto_type", CCP_Type));
1376
1377 // GNU keywords
1378 if (LangOpts.GNUKeywords) {
1379 // FIXME: Enable when we actually support decimal floating point.
1380 // Results.AddResult(Result("_Decimal32"));
1381 // Results.AddResult(Result("_Decimal64"));
1382 // Results.AddResult(Result("_Decimal128"));
1383
1384 Builder.AddTypedTextChunk("typeof");
1385 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1386 Builder.AddPlaceholderChunk("expression");
1387 Results.AddResult(Result(Builder.TakeString()));
1388
1389 Builder.AddTypedTextChunk("typeof");
1390 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1391 Builder.AddPlaceholderChunk("type");
1392 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1393 Results.AddResult(Result(Builder.TakeString()));
1394 }
1395
1396 // Nullability
1397 Results.AddResult(Result("_Nonnull", CCP_Type));
1398 Results.AddResult(Result("_Null_unspecified", CCP_Type));
1399 Results.AddResult(Result("_Nullable", CCP_Type));
1400 }
1401
AddStorageSpecifiers(Sema::ParserCompletionContext CCC,const LangOptions & LangOpts,ResultBuilder & Results)1402 static void AddStorageSpecifiers(Sema::ParserCompletionContext CCC,
1403 const LangOptions &LangOpts,
1404 ResultBuilder &Results) {
1405 typedef CodeCompletionResult Result;
1406 // Note: we don't suggest either "auto" or "register", because both
1407 // are pointless as storage specifiers. Elsewhere, we suggest "auto"
1408 // in C++0x as a type specifier.
1409 Results.AddResult(Result("extern"));
1410 Results.AddResult(Result("static"));
1411
1412 if (LangOpts.CPlusPlus11) {
1413 CodeCompletionAllocator &Allocator = Results.getAllocator();
1414 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1415
1416 // alignas
1417 Builder.AddTypedTextChunk("alignas");
1418 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1419 Builder.AddPlaceholderChunk("expression");
1420 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1421 Results.AddResult(Result(Builder.TakeString()));
1422
1423 Results.AddResult(Result("constexpr"));
1424 Results.AddResult(Result("thread_local"));
1425 }
1426 }
1427
AddFunctionSpecifiers(Sema::ParserCompletionContext CCC,const LangOptions & LangOpts,ResultBuilder & Results)1428 static void AddFunctionSpecifiers(Sema::ParserCompletionContext CCC,
1429 const LangOptions &LangOpts,
1430 ResultBuilder &Results) {
1431 typedef CodeCompletionResult Result;
1432 switch (CCC) {
1433 case Sema::PCC_Class:
1434 case Sema::PCC_MemberTemplate:
1435 if (LangOpts.CPlusPlus) {
1436 Results.AddResult(Result("explicit"));
1437 Results.AddResult(Result("friend"));
1438 Results.AddResult(Result("mutable"));
1439 Results.AddResult(Result("virtual"));
1440 }
1441 LLVM_FALLTHROUGH;
1442
1443 case Sema::PCC_ObjCInterface:
1444 case Sema::PCC_ObjCImplementation:
1445 case Sema::PCC_Namespace:
1446 case Sema::PCC_Template:
1447 if (LangOpts.CPlusPlus || LangOpts.C99)
1448 Results.AddResult(Result("inline"));
1449 break;
1450
1451 case Sema::PCC_ObjCInstanceVariableList:
1452 case Sema::PCC_Expression:
1453 case Sema::PCC_Statement:
1454 case Sema::PCC_ForInit:
1455 case Sema::PCC_Condition:
1456 case Sema::PCC_RecoveryInFunction:
1457 case Sema::PCC_Type:
1458 case Sema::PCC_ParenthesizedExpression:
1459 case Sema::PCC_LocalDeclarationSpecifiers:
1460 break;
1461 }
1462 }
1463
1464 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt);
1465 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt);
1466 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
1467 ResultBuilder &Results,
1468 bool NeedAt);
1469 static void AddObjCImplementationResults(const LangOptions &LangOpts,
1470 ResultBuilder &Results,
1471 bool NeedAt);
1472 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
1473 ResultBuilder &Results,
1474 bool NeedAt);
1475 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt);
1476
AddTypedefResult(ResultBuilder & Results)1477 static void AddTypedefResult(ResultBuilder &Results) {
1478 CodeCompletionBuilder Builder(Results.getAllocator(),
1479 Results.getCodeCompletionTUInfo());
1480 Builder.AddTypedTextChunk("typedef");
1481 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1482 Builder.AddPlaceholderChunk("type");
1483 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1484 Builder.AddPlaceholderChunk("name");
1485 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1486 }
1487
WantTypesInContext(Sema::ParserCompletionContext CCC,const LangOptions & LangOpts)1488 static bool WantTypesInContext(Sema::ParserCompletionContext CCC,
1489 const LangOptions &LangOpts) {
1490 switch (CCC) {
1491 case Sema::PCC_Namespace:
1492 case Sema::PCC_Class:
1493 case Sema::PCC_ObjCInstanceVariableList:
1494 case Sema::PCC_Template:
1495 case Sema::PCC_MemberTemplate:
1496 case Sema::PCC_Statement:
1497 case Sema::PCC_RecoveryInFunction:
1498 case Sema::PCC_Type:
1499 case Sema::PCC_ParenthesizedExpression:
1500 case Sema::PCC_LocalDeclarationSpecifiers:
1501 return true;
1502
1503 case Sema::PCC_Expression:
1504 case Sema::PCC_Condition:
1505 return LangOpts.CPlusPlus;
1506
1507 case Sema::PCC_ObjCInterface:
1508 case Sema::PCC_ObjCImplementation:
1509 return false;
1510
1511 case Sema::PCC_ForInit:
1512 return LangOpts.CPlusPlus || LangOpts.ObjC1 || LangOpts.C99;
1513 }
1514
1515 llvm_unreachable("Invalid ParserCompletionContext!");
1516 }
1517
getCompletionPrintingPolicy(const ASTContext & Context,const Preprocessor & PP)1518 static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context,
1519 const Preprocessor &PP) {
1520 PrintingPolicy Policy = Sema::getPrintingPolicy(Context, PP);
1521 Policy.AnonymousTagLocations = false;
1522 Policy.SuppressStrongLifetime = true;
1523 Policy.SuppressUnwrittenScope = true;
1524 Policy.SuppressScope = true;
1525 return Policy;
1526 }
1527
1528 /// Retrieve a printing policy suitable for code completion.
getCompletionPrintingPolicy(Sema & S)1529 static PrintingPolicy getCompletionPrintingPolicy(Sema &S) {
1530 return getCompletionPrintingPolicy(S.Context, S.PP);
1531 }
1532
1533 /// Retrieve the string representation of the given type as a string
1534 /// that has the appropriate lifetime for code completion.
1535 ///
1536 /// This routine provides a fast path where we provide constant strings for
1537 /// common type names.
GetCompletionTypeString(QualType T,ASTContext & Context,const PrintingPolicy & Policy,CodeCompletionAllocator & Allocator)1538 static const char *GetCompletionTypeString(QualType T,
1539 ASTContext &Context,
1540 const PrintingPolicy &Policy,
1541 CodeCompletionAllocator &Allocator) {
1542 if (!T.getLocalQualifiers()) {
1543 // Built-in type names are constant strings.
1544 if (const BuiltinType *BT = dyn_cast<BuiltinType>(T))
1545 return BT->getNameAsCString(Policy);
1546
1547 // Anonymous tag types are constant strings.
1548 if (const TagType *TagT = dyn_cast<TagType>(T))
1549 if (TagDecl *Tag = TagT->getDecl())
1550 if (!Tag->hasNameForLinkage()) {
1551 switch (Tag->getTagKind()) {
1552 case TTK_Struct: return "struct <anonymous>";
1553 case TTK_Interface: return "__interface <anonymous>";
1554 case TTK_Class: return "class <anonymous>";
1555 case TTK_Union: return "union <anonymous>";
1556 case TTK_Enum: return "enum <anonymous>";
1557 }
1558 }
1559 }
1560
1561 // Slow path: format the type as a string.
1562 std::string Result;
1563 T.getAsStringInternal(Result, Policy);
1564 return Allocator.CopyString(Result);
1565 }
1566
1567 /// Add a completion for "this", if we're in a member function.
addThisCompletion(Sema & S,ResultBuilder & Results)1568 static void addThisCompletion(Sema &S, ResultBuilder &Results) {
1569 QualType ThisTy = S.getCurrentThisType();
1570 if (ThisTy.isNull())
1571 return;
1572
1573 CodeCompletionAllocator &Allocator = Results.getAllocator();
1574 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1575 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
1576 Builder.AddResultTypeChunk(GetCompletionTypeString(ThisTy,
1577 S.Context,
1578 Policy,
1579 Allocator));
1580 Builder.AddTypedTextChunk("this");
1581 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1582 }
1583
AddStaticAssertResult(CodeCompletionBuilder & Builder,ResultBuilder & Results,const LangOptions & LangOpts)1584 static void AddStaticAssertResult(CodeCompletionBuilder &Builder,
1585 ResultBuilder &Results,
1586 const LangOptions &LangOpts) {
1587 if (!LangOpts.CPlusPlus11)
1588 return;
1589
1590 Builder.AddTypedTextChunk("static_assert");
1591 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1592 Builder.AddPlaceholderChunk("expression");
1593 Builder.AddChunk(CodeCompletionString::CK_Comma);
1594 Builder.AddPlaceholderChunk("message");
1595 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1596 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1597 }
1598
1599 /// Add language constructs that show up for "ordinary" names.
AddOrdinaryNameResults(Sema::ParserCompletionContext CCC,Scope * S,Sema & SemaRef,ResultBuilder & Results)1600 static void AddOrdinaryNameResults(Sema::ParserCompletionContext CCC,
1601 Scope *S,
1602 Sema &SemaRef,
1603 ResultBuilder &Results) {
1604 CodeCompletionAllocator &Allocator = Results.getAllocator();
1605 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1606
1607 typedef CodeCompletionResult Result;
1608 switch (CCC) {
1609 case Sema::PCC_Namespace:
1610 if (SemaRef.getLangOpts().CPlusPlus) {
1611 if (Results.includeCodePatterns()) {
1612 // namespace <identifier> { declarations }
1613 Builder.AddTypedTextChunk("namespace");
1614 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1615 Builder.AddPlaceholderChunk("identifier");
1616 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1617 Builder.AddPlaceholderChunk("declarations");
1618 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1619 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1620 Results.AddResult(Result(Builder.TakeString()));
1621 }
1622
1623 // namespace identifier = identifier ;
1624 Builder.AddTypedTextChunk("namespace");
1625 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1626 Builder.AddPlaceholderChunk("name");
1627 Builder.AddChunk(CodeCompletionString::CK_Equal);
1628 Builder.AddPlaceholderChunk("namespace");
1629 Results.AddResult(Result(Builder.TakeString()));
1630
1631 // Using directives
1632 Builder.AddTypedTextChunk("using");
1633 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1634 Builder.AddTextChunk("namespace");
1635 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1636 Builder.AddPlaceholderChunk("identifier");
1637 Results.AddResult(Result(Builder.TakeString()));
1638
1639 // asm(string-literal)
1640 Builder.AddTypedTextChunk("asm");
1641 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1642 Builder.AddPlaceholderChunk("string-literal");
1643 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1644 Results.AddResult(Result(Builder.TakeString()));
1645
1646 if (Results.includeCodePatterns()) {
1647 // Explicit template instantiation
1648 Builder.AddTypedTextChunk("template");
1649 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1650 Builder.AddPlaceholderChunk("declaration");
1651 Results.AddResult(Result(Builder.TakeString()));
1652 }
1653 }
1654
1655 if (SemaRef.getLangOpts().ObjC1)
1656 AddObjCTopLevelResults(Results, true);
1657
1658 AddTypedefResult(Results);
1659 LLVM_FALLTHROUGH;
1660
1661 case Sema::PCC_Class:
1662 if (SemaRef.getLangOpts().CPlusPlus) {
1663 // Using declaration
1664 Builder.AddTypedTextChunk("using");
1665 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1666 Builder.AddPlaceholderChunk("qualifier");
1667 Builder.AddTextChunk("::");
1668 Builder.AddPlaceholderChunk("name");
1669 Results.AddResult(Result(Builder.TakeString()));
1670
1671 // using typename qualifier::name (only in a dependent context)
1672 if (SemaRef.CurContext->isDependentContext()) {
1673 Builder.AddTypedTextChunk("using");
1674 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1675 Builder.AddTextChunk("typename");
1676 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1677 Builder.AddPlaceholderChunk("qualifier");
1678 Builder.AddTextChunk("::");
1679 Builder.AddPlaceholderChunk("name");
1680 Results.AddResult(Result(Builder.TakeString()));
1681 }
1682
1683 AddStaticAssertResult(Builder, Results, SemaRef.getLangOpts());
1684
1685 if (CCC == Sema::PCC_Class) {
1686 AddTypedefResult(Results);
1687
1688 bool IsNotInheritanceScope =
1689 !(S->getFlags() & Scope::ClassInheritanceScope);
1690 // public:
1691 Builder.AddTypedTextChunk("public");
1692 if (IsNotInheritanceScope && Results.includeCodePatterns())
1693 Builder.AddChunk(CodeCompletionString::CK_Colon);
1694 Results.AddResult(Result(Builder.TakeString()));
1695
1696 // protected:
1697 Builder.AddTypedTextChunk("protected");
1698 if (IsNotInheritanceScope && Results.includeCodePatterns())
1699 Builder.AddChunk(CodeCompletionString::CK_Colon);
1700 Results.AddResult(Result(Builder.TakeString()));
1701
1702 // private:
1703 Builder.AddTypedTextChunk("private");
1704 if (IsNotInheritanceScope && Results.includeCodePatterns())
1705 Builder.AddChunk(CodeCompletionString::CK_Colon);
1706 Results.AddResult(Result(Builder.TakeString()));
1707 }
1708 }
1709 LLVM_FALLTHROUGH;
1710
1711 case Sema::PCC_Template:
1712 case Sema::PCC_MemberTemplate:
1713 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns()) {
1714 // template < parameters >
1715 Builder.AddTypedTextChunk("template");
1716 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1717 Builder.AddPlaceholderChunk("parameters");
1718 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1719 Results.AddResult(Result(Builder.TakeString()));
1720 }
1721
1722 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1723 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1724 break;
1725
1726 case Sema::PCC_ObjCInterface:
1727 AddObjCInterfaceResults(SemaRef.getLangOpts(), Results, true);
1728 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1729 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1730 break;
1731
1732 case Sema::PCC_ObjCImplementation:
1733 AddObjCImplementationResults(SemaRef.getLangOpts(), Results, true);
1734 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1735 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1736 break;
1737
1738 case Sema::PCC_ObjCInstanceVariableList:
1739 AddObjCVisibilityResults(SemaRef.getLangOpts(), Results, true);
1740 break;
1741
1742 case Sema::PCC_RecoveryInFunction:
1743 case Sema::PCC_Statement: {
1744 AddTypedefResult(Results);
1745
1746 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns() &&
1747 SemaRef.getLangOpts().CXXExceptions) {
1748 Builder.AddTypedTextChunk("try");
1749 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1750 Builder.AddPlaceholderChunk("statements");
1751 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1752 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1753 Builder.AddTextChunk("catch");
1754 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1755 Builder.AddPlaceholderChunk("declaration");
1756 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1757 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1758 Builder.AddPlaceholderChunk("statements");
1759 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1760 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1761 Results.AddResult(Result(Builder.TakeString()));
1762 }
1763 if (SemaRef.getLangOpts().ObjC1)
1764 AddObjCStatementResults(Results, true);
1765
1766 if (Results.includeCodePatterns()) {
1767 // if (condition) { statements }
1768 Builder.AddTypedTextChunk("if");
1769 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1770 if (SemaRef.getLangOpts().CPlusPlus)
1771 Builder.AddPlaceholderChunk("condition");
1772 else
1773 Builder.AddPlaceholderChunk("expression");
1774 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1775 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1776 Builder.AddPlaceholderChunk("statements");
1777 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1778 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1779 Results.AddResult(Result(Builder.TakeString()));
1780
1781 // switch (condition) { }
1782 Builder.AddTypedTextChunk("switch");
1783 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1784 if (SemaRef.getLangOpts().CPlusPlus)
1785 Builder.AddPlaceholderChunk("condition");
1786 else
1787 Builder.AddPlaceholderChunk("expression");
1788 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1789 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1790 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1791 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1792 Results.AddResult(Result(Builder.TakeString()));
1793 }
1794
1795 // Switch-specific statements.
1796 if (!SemaRef.getCurFunction()->SwitchStack.empty()) {
1797 // case expression:
1798 Builder.AddTypedTextChunk("case");
1799 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1800 Builder.AddPlaceholderChunk("expression");
1801 Builder.AddChunk(CodeCompletionString::CK_Colon);
1802 Results.AddResult(Result(Builder.TakeString()));
1803
1804 // default:
1805 Builder.AddTypedTextChunk("default");
1806 Builder.AddChunk(CodeCompletionString::CK_Colon);
1807 Results.AddResult(Result(Builder.TakeString()));
1808 }
1809
1810 if (Results.includeCodePatterns()) {
1811 /// while (condition) { statements }
1812 Builder.AddTypedTextChunk("while");
1813 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1814 if (SemaRef.getLangOpts().CPlusPlus)
1815 Builder.AddPlaceholderChunk("condition");
1816 else
1817 Builder.AddPlaceholderChunk("expression");
1818 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1819 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1820 Builder.AddPlaceholderChunk("statements");
1821 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1822 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1823 Results.AddResult(Result(Builder.TakeString()));
1824
1825 // do { statements } while ( expression );
1826 Builder.AddTypedTextChunk("do");
1827 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1828 Builder.AddPlaceholderChunk("statements");
1829 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1830 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1831 Builder.AddTextChunk("while");
1832 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1833 Builder.AddPlaceholderChunk("expression");
1834 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1835 Results.AddResult(Result(Builder.TakeString()));
1836
1837 // for ( for-init-statement ; condition ; expression ) { statements }
1838 Builder.AddTypedTextChunk("for");
1839 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1840 if (SemaRef.getLangOpts().CPlusPlus || SemaRef.getLangOpts().C99)
1841 Builder.AddPlaceholderChunk("init-statement");
1842 else
1843 Builder.AddPlaceholderChunk("init-expression");
1844 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1845 Builder.AddPlaceholderChunk("condition");
1846 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1847 Builder.AddPlaceholderChunk("inc-expression");
1848 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1849 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1850 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1851 Builder.AddPlaceholderChunk("statements");
1852 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1853 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1854 Results.AddResult(Result(Builder.TakeString()));
1855 }
1856
1857 if (S->getContinueParent()) {
1858 // continue ;
1859 Builder.AddTypedTextChunk("continue");
1860 Results.AddResult(Result(Builder.TakeString()));
1861 }
1862
1863 if (S->getBreakParent()) {
1864 // break ;
1865 Builder.AddTypedTextChunk("break");
1866 Results.AddResult(Result(Builder.TakeString()));
1867 }
1868
1869 // "return expression ;" or "return ;", depending on whether we
1870 // know the function is void or not.
1871 bool isVoid = false;
1872 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(SemaRef.CurContext))
1873 isVoid = Function->getReturnType()->isVoidType();
1874 else if (ObjCMethodDecl *Method
1875 = dyn_cast<ObjCMethodDecl>(SemaRef.CurContext))
1876 isVoid = Method->getReturnType()->isVoidType();
1877 else if (SemaRef.getCurBlock() &&
1878 !SemaRef.getCurBlock()->ReturnType.isNull())
1879 isVoid = SemaRef.getCurBlock()->ReturnType->isVoidType();
1880 Builder.AddTypedTextChunk("return");
1881 if (!isVoid) {
1882 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1883 Builder.AddPlaceholderChunk("expression");
1884 }
1885 Results.AddResult(Result(Builder.TakeString()));
1886
1887 // goto identifier ;
1888 Builder.AddTypedTextChunk("goto");
1889 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1890 Builder.AddPlaceholderChunk("label");
1891 Results.AddResult(Result(Builder.TakeString()));
1892
1893 // Using directives
1894 Builder.AddTypedTextChunk("using");
1895 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1896 Builder.AddTextChunk("namespace");
1897 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1898 Builder.AddPlaceholderChunk("identifier");
1899 Results.AddResult(Result(Builder.TakeString()));
1900
1901 AddStaticAssertResult(Builder, Results, SemaRef.getLangOpts());
1902 }
1903 LLVM_FALLTHROUGH;
1904
1905 // Fall through (for statement expressions).
1906 case Sema::PCC_ForInit:
1907 case Sema::PCC_Condition:
1908 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1909 // Fall through: conditions and statements can have expressions.
1910 LLVM_FALLTHROUGH;
1911
1912 case Sema::PCC_ParenthesizedExpression:
1913 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
1914 CCC == Sema::PCC_ParenthesizedExpression) {
1915 // (__bridge <type>)<expression>
1916 Builder.AddTypedTextChunk("__bridge");
1917 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1918 Builder.AddPlaceholderChunk("type");
1919 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1920 Builder.AddPlaceholderChunk("expression");
1921 Results.AddResult(Result(Builder.TakeString()));
1922
1923 // (__bridge_transfer <Objective-C type>)<expression>
1924 Builder.AddTypedTextChunk("__bridge_transfer");
1925 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1926 Builder.AddPlaceholderChunk("Objective-C type");
1927 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1928 Builder.AddPlaceholderChunk("expression");
1929 Results.AddResult(Result(Builder.TakeString()));
1930
1931 // (__bridge_retained <CF type>)<expression>
1932 Builder.AddTypedTextChunk("__bridge_retained");
1933 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1934 Builder.AddPlaceholderChunk("CF type");
1935 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1936 Builder.AddPlaceholderChunk("expression");
1937 Results.AddResult(Result(Builder.TakeString()));
1938 }
1939 // Fall through
1940 LLVM_FALLTHROUGH;
1941
1942 case Sema::PCC_Expression: {
1943 if (SemaRef.getLangOpts().CPlusPlus) {
1944 // 'this', if we're in a non-static member function.
1945 addThisCompletion(SemaRef, Results);
1946
1947 // true
1948 Builder.AddResultTypeChunk("bool");
1949 Builder.AddTypedTextChunk("true");
1950 Results.AddResult(Result(Builder.TakeString()));
1951
1952 // false
1953 Builder.AddResultTypeChunk("bool");
1954 Builder.AddTypedTextChunk("false");
1955 Results.AddResult(Result(Builder.TakeString()));
1956
1957 if (SemaRef.getLangOpts().RTTI) {
1958 // dynamic_cast < type-id > ( expression )
1959 Builder.AddTypedTextChunk("dynamic_cast");
1960 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1961 Builder.AddPlaceholderChunk("type");
1962 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1963 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1964 Builder.AddPlaceholderChunk("expression");
1965 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1966 Results.AddResult(Result(Builder.TakeString()));
1967 }
1968
1969 // static_cast < type-id > ( expression )
1970 Builder.AddTypedTextChunk("static_cast");
1971 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1972 Builder.AddPlaceholderChunk("type");
1973 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1974 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1975 Builder.AddPlaceholderChunk("expression");
1976 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1977 Results.AddResult(Result(Builder.TakeString()));
1978
1979 // reinterpret_cast < type-id > ( expression )
1980 Builder.AddTypedTextChunk("reinterpret_cast");
1981 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1982 Builder.AddPlaceholderChunk("type");
1983 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1984 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1985 Builder.AddPlaceholderChunk("expression");
1986 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1987 Results.AddResult(Result(Builder.TakeString()));
1988
1989 // const_cast < type-id > ( expression )
1990 Builder.AddTypedTextChunk("const_cast");
1991 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1992 Builder.AddPlaceholderChunk("type");
1993 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1994 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1995 Builder.AddPlaceholderChunk("expression");
1996 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1997 Results.AddResult(Result(Builder.TakeString()));
1998
1999 if (SemaRef.getLangOpts().RTTI) {
2000 // typeid ( expression-or-type )
2001 Builder.AddResultTypeChunk("std::type_info");
2002 Builder.AddTypedTextChunk("typeid");
2003 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2004 Builder.AddPlaceholderChunk("expression-or-type");
2005 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2006 Results.AddResult(Result(Builder.TakeString()));
2007 }
2008
2009 // new T ( ... )
2010 Builder.AddTypedTextChunk("new");
2011 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2012 Builder.AddPlaceholderChunk("type");
2013 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2014 Builder.AddPlaceholderChunk("expressions");
2015 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2016 Results.AddResult(Result(Builder.TakeString()));
2017
2018 // new T [ ] ( ... )
2019 Builder.AddTypedTextChunk("new");
2020 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2021 Builder.AddPlaceholderChunk("type");
2022 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
2023 Builder.AddPlaceholderChunk("size");
2024 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
2025 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2026 Builder.AddPlaceholderChunk("expressions");
2027 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2028 Results.AddResult(Result(Builder.TakeString()));
2029
2030 // delete expression
2031 Builder.AddResultTypeChunk("void");
2032 Builder.AddTypedTextChunk("delete");
2033 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2034 Builder.AddPlaceholderChunk("expression");
2035 Results.AddResult(Result(Builder.TakeString()));
2036
2037 // delete [] expression
2038 Builder.AddResultTypeChunk("void");
2039 Builder.AddTypedTextChunk("delete");
2040 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2041 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
2042 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
2043 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2044 Builder.AddPlaceholderChunk("expression");
2045 Results.AddResult(Result(Builder.TakeString()));
2046
2047 if (SemaRef.getLangOpts().CXXExceptions) {
2048 // throw expression
2049 Builder.AddResultTypeChunk("void");
2050 Builder.AddTypedTextChunk("throw");
2051 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2052 Builder.AddPlaceholderChunk("expression");
2053 Results.AddResult(Result(Builder.TakeString()));
2054 }
2055
2056 // FIXME: Rethrow?
2057
2058 if (SemaRef.getLangOpts().CPlusPlus11) {
2059 // nullptr
2060 Builder.AddResultTypeChunk("std::nullptr_t");
2061 Builder.AddTypedTextChunk("nullptr");
2062 Results.AddResult(Result(Builder.TakeString()));
2063
2064 // alignof
2065 Builder.AddResultTypeChunk("size_t");
2066 Builder.AddTypedTextChunk("alignof");
2067 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2068 Builder.AddPlaceholderChunk("type");
2069 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2070 Results.AddResult(Result(Builder.TakeString()));
2071
2072 // noexcept
2073 Builder.AddResultTypeChunk("bool");
2074 Builder.AddTypedTextChunk("noexcept");
2075 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2076 Builder.AddPlaceholderChunk("expression");
2077 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2078 Results.AddResult(Result(Builder.TakeString()));
2079
2080 // sizeof... expression
2081 Builder.AddResultTypeChunk("size_t");
2082 Builder.AddTypedTextChunk("sizeof...");
2083 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2084 Builder.AddPlaceholderChunk("parameter-pack");
2085 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2086 Results.AddResult(Result(Builder.TakeString()));
2087 }
2088 }
2089
2090 if (SemaRef.getLangOpts().ObjC1) {
2091 // Add "super", if we're in an Objective-C class with a superclass.
2092 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) {
2093 // The interface can be NULL.
2094 if (ObjCInterfaceDecl *ID = Method->getClassInterface())
2095 if (ID->getSuperClass()) {
2096 std::string SuperType;
2097 SuperType = ID->getSuperClass()->getNameAsString();
2098 if (Method->isInstanceMethod())
2099 SuperType += " *";
2100
2101 Builder.AddResultTypeChunk(Allocator.CopyString(SuperType));
2102 Builder.AddTypedTextChunk("super");
2103 Results.AddResult(Result(Builder.TakeString()));
2104 }
2105 }
2106
2107 AddObjCExpressionResults(Results, true);
2108 }
2109
2110 if (SemaRef.getLangOpts().C11) {
2111 // _Alignof
2112 Builder.AddResultTypeChunk("size_t");
2113 if (SemaRef.PP.isMacroDefined("alignof"))
2114 Builder.AddTypedTextChunk("alignof");
2115 else
2116 Builder.AddTypedTextChunk("_Alignof");
2117 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2118 Builder.AddPlaceholderChunk("type");
2119 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2120 Results.AddResult(Result(Builder.TakeString()));
2121 }
2122
2123 // sizeof expression
2124 Builder.AddResultTypeChunk("size_t");
2125 Builder.AddTypedTextChunk("sizeof");
2126 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2127 Builder.AddPlaceholderChunk("expression-or-type");
2128 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2129 Results.AddResult(Result(Builder.TakeString()));
2130 break;
2131 }
2132
2133 case Sema::PCC_Type:
2134 case Sema::PCC_LocalDeclarationSpecifiers:
2135 break;
2136 }
2137
2138 if (WantTypesInContext(CCC, SemaRef.getLangOpts()))
2139 AddTypeSpecifierResults(SemaRef.getLangOpts(), Results);
2140
2141 if (SemaRef.getLangOpts().CPlusPlus && CCC != Sema::PCC_Type)
2142 Results.AddResult(Result("operator"));
2143 }
2144
2145 /// If the given declaration has an associated type, add it as a result
2146 /// type chunk.
AddResultTypeChunk(ASTContext & Context,const PrintingPolicy & Policy,const NamedDecl * ND,QualType BaseType,CodeCompletionBuilder & Result)2147 static void AddResultTypeChunk(ASTContext &Context,
2148 const PrintingPolicy &Policy,
2149 const NamedDecl *ND,
2150 QualType BaseType,
2151 CodeCompletionBuilder &Result) {
2152 if (!ND)
2153 return;
2154
2155 // Skip constructors and conversion functions, which have their return types
2156 // built into their names.
2157 if (isConstructor(ND) || isa<CXXConversionDecl>(ND))
2158 return;
2159
2160 // Determine the type of the declaration (if it has a type).
2161 QualType T;
2162 if (const FunctionDecl *Function = ND->getAsFunction())
2163 T = Function->getReturnType();
2164 else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2165 if (!BaseType.isNull())
2166 T = Method->getSendResultType(BaseType);
2167 else
2168 T = Method->getReturnType();
2169 } else if (const EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND)) {
2170 T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext()));
2171 T = clang::TypeName::getFullyQualifiedType(T, Context);
2172 } else if (isa<UnresolvedUsingValueDecl>(ND)) {
2173 /* Do nothing: ignore unresolved using declarations*/
2174 } else if (const ObjCIvarDecl *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
2175 if (!BaseType.isNull())
2176 T = Ivar->getUsageType(BaseType);
2177 else
2178 T = Ivar->getType();
2179 } else if (const ValueDecl *Value = dyn_cast<ValueDecl>(ND)) {
2180 T = Value->getType();
2181 } else if (const ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND)) {
2182 if (!BaseType.isNull())
2183 T = Property->getUsageType(BaseType);
2184 else
2185 T = Property->getType();
2186 }
2187
2188 if (T.isNull() || Context.hasSameType(T, Context.DependentTy))
2189 return;
2190
2191 Result.AddResultTypeChunk(GetCompletionTypeString(T, Context, Policy,
2192 Result.getAllocator()));
2193 }
2194
MaybeAddSentinel(Preprocessor & PP,const NamedDecl * FunctionOrMethod,CodeCompletionBuilder & Result)2195 static void MaybeAddSentinel(Preprocessor &PP,
2196 const NamedDecl *FunctionOrMethod,
2197 CodeCompletionBuilder &Result) {
2198 if (SentinelAttr *Sentinel = FunctionOrMethod->getAttr<SentinelAttr>())
2199 if (Sentinel->getSentinel() == 0) {
2200 if (PP.getLangOpts().ObjC1 && PP.isMacroDefined("nil"))
2201 Result.AddTextChunk(", nil");
2202 else if (PP.isMacroDefined("NULL"))
2203 Result.AddTextChunk(", NULL");
2204 else
2205 Result.AddTextChunk(", (void*)0");
2206 }
2207 }
2208
formatObjCParamQualifiers(unsigned ObjCQuals,QualType & Type)2209 static std::string formatObjCParamQualifiers(unsigned ObjCQuals,
2210 QualType &Type) {
2211 std::string Result;
2212 if (ObjCQuals & Decl::OBJC_TQ_In)
2213 Result += "in ";
2214 else if (ObjCQuals & Decl::OBJC_TQ_Inout)
2215 Result += "inout ";
2216 else if (ObjCQuals & Decl::OBJC_TQ_Out)
2217 Result += "out ";
2218 if (ObjCQuals & Decl::OBJC_TQ_Bycopy)
2219 Result += "bycopy ";
2220 else if (ObjCQuals & Decl::OBJC_TQ_Byref)
2221 Result += "byref ";
2222 if (ObjCQuals & Decl::OBJC_TQ_Oneway)
2223 Result += "oneway ";
2224 if (ObjCQuals & Decl::OBJC_TQ_CSNullability) {
2225 if (auto nullability = AttributedType::stripOuterNullability(Type)) {
2226 switch (*nullability) {
2227 case NullabilityKind::NonNull:
2228 Result += "nonnull ";
2229 break;
2230
2231 case NullabilityKind::Nullable:
2232 Result += "nullable ";
2233 break;
2234
2235 case NullabilityKind::Unspecified:
2236 Result += "null_unspecified ";
2237 break;
2238 }
2239 }
2240 }
2241 return Result;
2242 }
2243
2244 /// Tries to find the most appropriate type location for an Objective-C
2245 /// block placeholder.
2246 ///
2247 /// This function ignores things like typedefs and qualifiers in order to
2248 /// present the most relevant and accurate block placeholders in code completion
2249 /// results.
findTypeLocationForBlockDecl(const TypeSourceInfo * TSInfo,FunctionTypeLoc & Block,FunctionProtoTypeLoc & BlockProto,bool SuppressBlock=false)2250 static void findTypeLocationForBlockDecl(const TypeSourceInfo *TSInfo,
2251 FunctionTypeLoc &Block,
2252 FunctionProtoTypeLoc &BlockProto,
2253 bool SuppressBlock = false) {
2254 if (!TSInfo)
2255 return;
2256 TypeLoc TL = TSInfo->getTypeLoc().getUnqualifiedLoc();
2257 while (true) {
2258 // Look through typedefs.
2259 if (!SuppressBlock) {
2260 if (TypedefTypeLoc TypedefTL = TL.getAs<TypedefTypeLoc>()) {
2261 if (TypeSourceInfo *InnerTSInfo =
2262 TypedefTL.getTypedefNameDecl()->getTypeSourceInfo()) {
2263 TL = InnerTSInfo->getTypeLoc().getUnqualifiedLoc();
2264 continue;
2265 }
2266 }
2267
2268 // Look through qualified types
2269 if (QualifiedTypeLoc QualifiedTL = TL.getAs<QualifiedTypeLoc>()) {
2270 TL = QualifiedTL.getUnqualifiedLoc();
2271 continue;
2272 }
2273
2274 if (AttributedTypeLoc AttrTL = TL.getAs<AttributedTypeLoc>()) {
2275 TL = AttrTL.getModifiedLoc();
2276 continue;
2277 }
2278 }
2279
2280 // Try to get the function prototype behind the block pointer type,
2281 // then we're done.
2282 if (BlockPointerTypeLoc BlockPtr = TL.getAs<BlockPointerTypeLoc>()) {
2283 TL = BlockPtr.getPointeeLoc().IgnoreParens();
2284 Block = TL.getAs<FunctionTypeLoc>();
2285 BlockProto = TL.getAs<FunctionProtoTypeLoc>();
2286 }
2287 break;
2288 }
2289 }
2290
2291 static std::string
2292 formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
2293 FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
2294 bool SuppressBlockName = false,
2295 bool SuppressBlock = false,
2296 Optional<ArrayRef<QualType>> ObjCSubsts = None);
2297
FormatFunctionParameter(const PrintingPolicy & Policy,const ParmVarDecl * Param,bool SuppressName=false,bool SuppressBlock=false,Optional<ArrayRef<QualType>> ObjCSubsts=None)2298 static std::string FormatFunctionParameter(const PrintingPolicy &Policy,
2299 const ParmVarDecl *Param,
2300 bool SuppressName = false,
2301 bool SuppressBlock = false,
2302 Optional<ArrayRef<QualType>> ObjCSubsts = None) {
2303 bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext());
2304 if (Param->getType()->isDependentType() ||
2305 !Param->getType()->isBlockPointerType()) {
2306 // The argument for a dependent or non-block parameter is a placeholder
2307 // containing that parameter's type.
2308 std::string Result;
2309
2310 if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName)
2311 Result = Param->getIdentifier()->getName();
2312
2313 QualType Type = Param->getType();
2314 if (ObjCSubsts)
2315 Type = Type.substObjCTypeArgs(Param->getASTContext(), *ObjCSubsts,
2316 ObjCSubstitutionContext::Parameter);
2317 if (ObjCMethodParam) {
2318 Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(),
2319 Type);
2320 Result += Type.getAsString(Policy) + ")";
2321 if (Param->getIdentifier() && !SuppressName)
2322 Result += Param->getIdentifier()->getName();
2323 } else {
2324 Type.getAsStringInternal(Result, Policy);
2325 }
2326 return Result;
2327 }
2328
2329 // The argument for a block pointer parameter is a block literal with
2330 // the appropriate type.
2331 FunctionTypeLoc Block;
2332 FunctionProtoTypeLoc BlockProto;
2333 findTypeLocationForBlockDecl(Param->getTypeSourceInfo(), Block, BlockProto,
2334 SuppressBlock);
2335 // Try to retrieve the block type information from the property if this is a
2336 // parameter in a setter.
2337 if (!Block && ObjCMethodParam &&
2338 cast<ObjCMethodDecl>(Param->getDeclContext())->isPropertyAccessor()) {
2339 if (const auto *PD = cast<ObjCMethodDecl>(Param->getDeclContext())
2340 ->findPropertyDecl(/*CheckOverrides=*/false))
2341 findTypeLocationForBlockDecl(PD->getTypeSourceInfo(), Block, BlockProto,
2342 SuppressBlock);
2343 }
2344
2345 if (!Block) {
2346 // We were unable to find a FunctionProtoTypeLoc with parameter names
2347 // for the block; just use the parameter type as a placeholder.
2348 std::string Result;
2349 if (!ObjCMethodParam && Param->getIdentifier())
2350 Result = Param->getIdentifier()->getName();
2351
2352 QualType Type = Param->getType().getUnqualifiedType();
2353
2354 if (ObjCMethodParam) {
2355 Result = Type.getAsString(Policy);
2356 std::string Quals =
2357 formatObjCParamQualifiers(Param->getObjCDeclQualifier(), Type);
2358 if (!Quals.empty())
2359 Result = "(" + Quals + " " + Result + ")";
2360 if (Result.back() != ')')
2361 Result += " ";
2362 if (Param->getIdentifier())
2363 Result += Param->getIdentifier()->getName();
2364 } else {
2365 Type.getAsStringInternal(Result, Policy);
2366 }
2367
2368 return Result;
2369 }
2370
2371 // We have the function prototype behind the block pointer type, as it was
2372 // written in the source.
2373 return formatBlockPlaceholder(Policy, Param, Block, BlockProto,
2374 /*SuppressBlockName=*/false, SuppressBlock,
2375 ObjCSubsts);
2376 }
2377
2378 /// Returns a placeholder string that corresponds to an Objective-C block
2379 /// declaration.
2380 ///
2381 /// \param BlockDecl A declaration with an Objective-C block type.
2382 ///
2383 /// \param Block The most relevant type location for that block type.
2384 ///
2385 /// \param SuppressBlockName Determines whether or not the name of the block
2386 /// declaration is included in the resulting string.
2387 static std::string
formatBlockPlaceholder(const PrintingPolicy & Policy,const NamedDecl * BlockDecl,FunctionTypeLoc & Block,FunctionProtoTypeLoc & BlockProto,bool SuppressBlockName,bool SuppressBlock,Optional<ArrayRef<QualType>> ObjCSubsts)2388 formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
2389 FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
2390 bool SuppressBlockName, bool SuppressBlock,
2391 Optional<ArrayRef<QualType>> ObjCSubsts) {
2392 std::string Result;
2393 QualType ResultType = Block.getTypePtr()->getReturnType();
2394 if (ObjCSubsts)
2395 ResultType =
2396 ResultType.substObjCTypeArgs(BlockDecl->getASTContext(), *ObjCSubsts,
2397 ObjCSubstitutionContext::Result);
2398 if (!ResultType->isVoidType() || SuppressBlock)
2399 ResultType.getAsStringInternal(Result, Policy);
2400
2401 // Format the parameter list.
2402 std::string Params;
2403 if (!BlockProto || Block.getNumParams() == 0) {
2404 if (BlockProto && BlockProto.getTypePtr()->isVariadic())
2405 Params = "(...)";
2406 else
2407 Params = "(void)";
2408 } else {
2409 Params += "(";
2410 for (unsigned I = 0, N = Block.getNumParams(); I != N; ++I) {
2411 if (I)
2412 Params += ", ";
2413 Params += FormatFunctionParameter(Policy, Block.getParam(I),
2414 /*SuppressName=*/false,
2415 /*SuppressBlock=*/true, ObjCSubsts);
2416
2417 if (I == N - 1 && BlockProto.getTypePtr()->isVariadic())
2418 Params += ", ...";
2419 }
2420 Params += ")";
2421 }
2422
2423 if (SuppressBlock) {
2424 // Format as a parameter.
2425 Result = Result + " (^";
2426 if (!SuppressBlockName && BlockDecl->getIdentifier())
2427 Result += BlockDecl->getIdentifier()->getName();
2428 Result += ")";
2429 Result += Params;
2430 } else {
2431 // Format as a block literal argument.
2432 Result = '^' + Result;
2433 Result += Params;
2434
2435 if (!SuppressBlockName && BlockDecl->getIdentifier())
2436 Result += BlockDecl->getIdentifier()->getName();
2437 }
2438
2439 return Result;
2440 }
2441
GetDefaultValueString(const ParmVarDecl * Param,const SourceManager & SM,const LangOptions & LangOpts)2442 static std::string GetDefaultValueString(const ParmVarDecl *Param,
2443 const SourceManager &SM,
2444 const LangOptions &LangOpts) {
2445 const SourceRange SrcRange = Param->getDefaultArgRange();
2446 CharSourceRange CharSrcRange = CharSourceRange::getTokenRange(SrcRange);
2447 bool Invalid = CharSrcRange.isInvalid();
2448 if (Invalid)
2449 return "";
2450 StringRef srcText = Lexer::getSourceText(CharSrcRange, SM, LangOpts, &Invalid);
2451 if (Invalid)
2452 return "";
2453
2454 if (srcText.empty() || srcText == "=") {
2455 // Lexer can't determine the value.
2456 // This happens if the code is incorrect (for example class is forward declared).
2457 return "";
2458 }
2459 std::string DefValue(srcText.str());
2460 // FIXME: remove this check if the Lexer::getSourceText value is fixed and
2461 // this value always has (or always does not have) '=' in front of it
2462 if (DefValue.at(0) != '=') {
2463 // If we don't have '=' in front of value.
2464 // Lexer returns built-in types values without '=' and user-defined types values with it.
2465 return " = " + DefValue;
2466 }
2467 return " " + DefValue;
2468 }
2469
2470 /// Add function parameter chunks to the given code completion string.
AddFunctionParameterChunks(Preprocessor & PP,const PrintingPolicy & Policy,const FunctionDecl * Function,CodeCompletionBuilder & Result,unsigned Start=0,bool InOptional=false)2471 static void AddFunctionParameterChunks(Preprocessor &PP,
2472 const PrintingPolicy &Policy,
2473 const FunctionDecl *Function,
2474 CodeCompletionBuilder &Result,
2475 unsigned Start = 0,
2476 bool InOptional = false) {
2477 bool FirstParameter = true;
2478
2479 for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) {
2480 const ParmVarDecl *Param = Function->getParamDecl(P);
2481
2482 if (Param->hasDefaultArg() && !InOptional) {
2483 // When we see an optional default argument, put that argument and
2484 // the remaining default arguments into a new, optional string.
2485 CodeCompletionBuilder Opt(Result.getAllocator(),
2486 Result.getCodeCompletionTUInfo());
2487 if (!FirstParameter)
2488 Opt.AddChunk(CodeCompletionString::CK_Comma);
2489 AddFunctionParameterChunks(PP, Policy, Function, Opt, P, true);
2490 Result.AddOptionalChunk(Opt.TakeString());
2491 break;
2492 }
2493
2494 if (FirstParameter)
2495 FirstParameter = false;
2496 else
2497 Result.AddChunk(CodeCompletionString::CK_Comma);
2498
2499 InOptional = false;
2500
2501 // Format the placeholder string.
2502 std::string PlaceholderStr = FormatFunctionParameter(Policy, Param);
2503 if (Param->hasDefaultArg())
2504 PlaceholderStr += GetDefaultValueString(Param, PP.getSourceManager(), PP.getLangOpts());
2505
2506 if (Function->isVariadic() && P == N - 1)
2507 PlaceholderStr += ", ...";
2508
2509 // Add the placeholder string.
2510 Result.AddPlaceholderChunk(
2511 Result.getAllocator().CopyString(PlaceholderStr));
2512 }
2513
2514 if (const FunctionProtoType *Proto
2515 = Function->getType()->getAs<FunctionProtoType>())
2516 if (Proto->isVariadic()) {
2517 if (Proto->getNumParams() == 0)
2518 Result.AddPlaceholderChunk("...");
2519
2520 MaybeAddSentinel(PP, Function, Result);
2521 }
2522 }
2523
2524 /// Add template parameter chunks to the given code completion string.
AddTemplateParameterChunks(ASTContext & Context,const PrintingPolicy & Policy,const TemplateDecl * Template,CodeCompletionBuilder & Result,unsigned MaxParameters=0,unsigned Start=0,bool InDefaultArg=false)2525 static void AddTemplateParameterChunks(ASTContext &Context,
2526 const PrintingPolicy &Policy,
2527 const TemplateDecl *Template,
2528 CodeCompletionBuilder &Result,
2529 unsigned MaxParameters = 0,
2530 unsigned Start = 0,
2531 bool InDefaultArg = false) {
2532 bool FirstParameter = true;
2533
2534 // Prefer to take the template parameter names from the first declaration of
2535 // the template.
2536 Template = cast<TemplateDecl>(Template->getCanonicalDecl());
2537
2538 TemplateParameterList *Params = Template->getTemplateParameters();
2539 TemplateParameterList::iterator PEnd = Params->end();
2540 if (MaxParameters)
2541 PEnd = Params->begin() + MaxParameters;
2542 for (TemplateParameterList::iterator P = Params->begin() + Start;
2543 P != PEnd; ++P) {
2544 bool HasDefaultArg = false;
2545 std::string PlaceholderStr;
2546 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
2547 if (TTP->wasDeclaredWithTypename())
2548 PlaceholderStr = "typename";
2549 else
2550 PlaceholderStr = "class";
2551
2552 if (TTP->getIdentifier()) {
2553 PlaceholderStr += ' ';
2554 PlaceholderStr += TTP->getIdentifier()->getName();
2555 }
2556
2557 HasDefaultArg = TTP->hasDefaultArgument();
2558 } else if (NonTypeTemplateParmDecl *NTTP
2559 = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
2560 if (NTTP->getIdentifier())
2561 PlaceholderStr = NTTP->getIdentifier()->getName();
2562 NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
2563 HasDefaultArg = NTTP->hasDefaultArgument();
2564 } else {
2565 assert(isa<TemplateTemplateParmDecl>(*P));
2566 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
2567
2568 // Since putting the template argument list into the placeholder would
2569 // be very, very long, we just use an abbreviation.
2570 PlaceholderStr = "template<...> class";
2571 if (TTP->getIdentifier()) {
2572 PlaceholderStr += ' ';
2573 PlaceholderStr += TTP->getIdentifier()->getName();
2574 }
2575
2576 HasDefaultArg = TTP->hasDefaultArgument();
2577 }
2578
2579 if (HasDefaultArg && !InDefaultArg) {
2580 // When we see an optional default argument, put that argument and
2581 // the remaining default arguments into a new, optional string.
2582 CodeCompletionBuilder Opt(Result.getAllocator(),
2583 Result.getCodeCompletionTUInfo());
2584 if (!FirstParameter)
2585 Opt.AddChunk(CodeCompletionString::CK_Comma);
2586 AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters,
2587 P - Params->begin(), true);
2588 Result.AddOptionalChunk(Opt.TakeString());
2589 break;
2590 }
2591
2592 InDefaultArg = false;
2593
2594 if (FirstParameter)
2595 FirstParameter = false;
2596 else
2597 Result.AddChunk(CodeCompletionString::CK_Comma);
2598
2599 // Add the placeholder string.
2600 Result.AddPlaceholderChunk(
2601 Result.getAllocator().CopyString(PlaceholderStr));
2602 }
2603 }
2604
2605 /// Add a qualifier to the given code-completion string, if the
2606 /// provided nested-name-specifier is non-NULL.
2607 static void
AddQualifierToCompletionString(CodeCompletionBuilder & Result,NestedNameSpecifier * Qualifier,bool QualifierIsInformative,ASTContext & Context,const PrintingPolicy & Policy)2608 AddQualifierToCompletionString(CodeCompletionBuilder &Result,
2609 NestedNameSpecifier *Qualifier,
2610 bool QualifierIsInformative,
2611 ASTContext &Context,
2612 const PrintingPolicy &Policy) {
2613 if (!Qualifier)
2614 return;
2615
2616 std::string PrintedNNS;
2617 {
2618 llvm::raw_string_ostream OS(PrintedNNS);
2619 Qualifier->print(OS, Policy);
2620 }
2621 if (QualifierIsInformative)
2622 Result.AddInformativeChunk(Result.getAllocator().CopyString(PrintedNNS));
2623 else
2624 Result.AddTextChunk(Result.getAllocator().CopyString(PrintedNNS));
2625 }
2626
2627 static void
AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder & Result,const FunctionDecl * Function)2628 AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result,
2629 const FunctionDecl *Function) {
2630 const FunctionProtoType *Proto
2631 = Function->getType()->getAs<FunctionProtoType>();
2632 if (!Proto || !Proto->getTypeQuals())
2633 return;
2634
2635 // FIXME: Add ref-qualifier!
2636
2637 // Handle single qualifiers without copying
2638 if (Proto->getTypeQuals() == Qualifiers::Const) {
2639 Result.AddInformativeChunk(" const");
2640 return;
2641 }
2642
2643 if (Proto->getTypeQuals() == Qualifiers::Volatile) {
2644 Result.AddInformativeChunk(" volatile");
2645 return;
2646 }
2647
2648 if (Proto->getTypeQuals() == Qualifiers::Restrict) {
2649 Result.AddInformativeChunk(" restrict");
2650 return;
2651 }
2652
2653 // Handle multiple qualifiers.
2654 std::string QualsStr;
2655 if (Proto->isConst())
2656 QualsStr += " const";
2657 if (Proto->isVolatile())
2658 QualsStr += " volatile";
2659 if (Proto->isRestrict())
2660 QualsStr += " restrict";
2661 Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
2662 }
2663
2664 /// Add the name of the given declaration
AddTypedNameChunk(ASTContext & Context,const PrintingPolicy & Policy,const NamedDecl * ND,CodeCompletionBuilder & Result)2665 static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy,
2666 const NamedDecl *ND,
2667 CodeCompletionBuilder &Result) {
2668 DeclarationName Name = ND->getDeclName();
2669 if (!Name)
2670 return;
2671
2672 switch (Name.getNameKind()) {
2673 case DeclarationName::CXXOperatorName: {
2674 const char *OperatorName = nullptr;
2675 switch (Name.getCXXOverloadedOperator()) {
2676 case OO_None:
2677 case OO_Conditional:
2678 case NUM_OVERLOADED_OPERATORS:
2679 OperatorName = "operator";
2680 break;
2681
2682 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2683 case OO_##Name: OperatorName = "operator" Spelling; break;
2684 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2685 #include "clang/Basic/OperatorKinds.def"
2686
2687 case OO_New: OperatorName = "operator new"; break;
2688 case OO_Delete: OperatorName = "operator delete"; break;
2689 case OO_Array_New: OperatorName = "operator new[]"; break;
2690 case OO_Array_Delete: OperatorName = "operator delete[]"; break;
2691 case OO_Call: OperatorName = "operator()"; break;
2692 case OO_Subscript: OperatorName = "operator[]"; break;
2693 }
2694 Result.AddTypedTextChunk(OperatorName);
2695 break;
2696 }
2697
2698 case DeclarationName::Identifier:
2699 case DeclarationName::CXXConversionFunctionName:
2700 case DeclarationName::CXXDestructorName:
2701 case DeclarationName::CXXLiteralOperatorName:
2702 Result.AddTypedTextChunk(
2703 Result.getAllocator().CopyString(ND->getNameAsString()));
2704 break;
2705
2706 case DeclarationName::CXXDeductionGuideName:
2707 case DeclarationName::CXXUsingDirective:
2708 case DeclarationName::ObjCZeroArgSelector:
2709 case DeclarationName::ObjCOneArgSelector:
2710 case DeclarationName::ObjCMultiArgSelector:
2711 break;
2712
2713 case DeclarationName::CXXConstructorName: {
2714 CXXRecordDecl *Record = nullptr;
2715 QualType Ty = Name.getCXXNameType();
2716 if (const RecordType *RecordTy = Ty->getAs<RecordType>())
2717 Record = cast<CXXRecordDecl>(RecordTy->getDecl());
2718 else if (const InjectedClassNameType *InjectedTy
2719 = Ty->getAs<InjectedClassNameType>())
2720 Record = InjectedTy->getDecl();
2721 else {
2722 Result.AddTypedTextChunk(
2723 Result.getAllocator().CopyString(ND->getNameAsString()));
2724 break;
2725 }
2726
2727 Result.AddTypedTextChunk(
2728 Result.getAllocator().CopyString(Record->getNameAsString()));
2729 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) {
2730 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2731 AddTemplateParameterChunks(Context, Policy, Template, Result);
2732 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2733 }
2734 break;
2735 }
2736 }
2737 }
2738
CreateCodeCompletionString(Sema & S,const CodeCompletionContext & CCContext,CodeCompletionAllocator & Allocator,CodeCompletionTUInfo & CCTUInfo,bool IncludeBriefComments)2739 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(Sema &S,
2740 const CodeCompletionContext &CCContext,
2741 CodeCompletionAllocator &Allocator,
2742 CodeCompletionTUInfo &CCTUInfo,
2743 bool IncludeBriefComments) {
2744 return CreateCodeCompletionString(S.Context, S.PP, CCContext, Allocator,
2745 CCTUInfo, IncludeBriefComments);
2746 }
2747
CreateCodeCompletionStringForMacro(Preprocessor & PP,CodeCompletionAllocator & Allocator,CodeCompletionTUInfo & CCTUInfo)2748 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionStringForMacro(
2749 Preprocessor &PP, CodeCompletionAllocator &Allocator,
2750 CodeCompletionTUInfo &CCTUInfo) {
2751 assert(Kind == RK_Macro);
2752 CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
2753 const MacroInfo *MI = PP.getMacroInfo(Macro);
2754 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Macro->getName()));
2755
2756 if (!MI || !MI->isFunctionLike())
2757 return Result.TakeString();
2758
2759 // Format a function-like macro with placeholders for the arguments.
2760 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2761 MacroInfo::param_iterator A = MI->param_begin(), AEnd = MI->param_end();
2762
2763 // C99 variadic macros add __VA_ARGS__ at the end. Skip it.
2764 if (MI->isC99Varargs()) {
2765 --AEnd;
2766
2767 if (A == AEnd) {
2768 Result.AddPlaceholderChunk("...");
2769 }
2770 }
2771
2772 for (MacroInfo::param_iterator A = MI->param_begin(); A != AEnd; ++A) {
2773 if (A != MI->param_begin())
2774 Result.AddChunk(CodeCompletionString::CK_Comma);
2775
2776 if (MI->isVariadic() && (A + 1) == AEnd) {
2777 SmallString<32> Arg = (*A)->getName();
2778 if (MI->isC99Varargs())
2779 Arg += ", ...";
2780 else
2781 Arg += "...";
2782 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
2783 break;
2784 }
2785
2786 // Non-variadic macros are simple.
2787 Result.AddPlaceholderChunk(
2788 Result.getAllocator().CopyString((*A)->getName()));
2789 }
2790 Result.AddChunk(CodeCompletionString::CK_RightParen);
2791 return Result.TakeString();
2792 }
2793
2794 /// If possible, create a new code completion string for the given
2795 /// result.
2796 ///
2797 /// \returns Either a new, heap-allocated code completion string describing
2798 /// how to use this result, or NULL to indicate that the string or name of the
2799 /// result is all that is needed.
2800 CodeCompletionString *
CreateCodeCompletionString(ASTContext & Ctx,Preprocessor & PP,const CodeCompletionContext & CCContext,CodeCompletionAllocator & Allocator,CodeCompletionTUInfo & CCTUInfo,bool IncludeBriefComments)2801 CodeCompletionResult::CreateCodeCompletionString(ASTContext &Ctx,
2802 Preprocessor &PP,
2803 const CodeCompletionContext &CCContext,
2804 CodeCompletionAllocator &Allocator,
2805 CodeCompletionTUInfo &CCTUInfo,
2806 bool IncludeBriefComments) {
2807 if (Kind == RK_Macro)
2808 return CreateCodeCompletionStringForMacro(PP, Allocator, CCTUInfo);
2809
2810 CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
2811
2812 PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP);
2813 if (Kind == RK_Pattern) {
2814 Pattern->Priority = Priority;
2815 Pattern->Availability = Availability;
2816
2817 if (Declaration) {
2818 Result.addParentContext(Declaration->getDeclContext());
2819 Pattern->ParentName = Result.getParentName();
2820 if (const RawComment *RC =
2821 getPatternCompletionComment(Ctx, Declaration)) {
2822 Result.addBriefComment(RC->getBriefText(Ctx));
2823 Pattern->BriefComment = Result.getBriefComment();
2824 }
2825 }
2826
2827 return Pattern;
2828 }
2829
2830 if (Kind == RK_Keyword) {
2831 Result.AddTypedTextChunk(Keyword);
2832 return Result.TakeString();
2833 }
2834 assert(Kind == RK_Declaration && "Missed a result kind?");
2835 const NamedDecl *ND = Declaration;
2836 Result.addParentContext(ND->getDeclContext());
2837
2838 if (IncludeBriefComments) {
2839 // Add documentation comment, if it exists.
2840 if (const RawComment *RC = getCompletionComment(Ctx, Declaration)) {
2841 Result.addBriefComment(RC->getBriefText(Ctx));
2842 }
2843 }
2844
2845 if (StartsNestedNameSpecifier) {
2846 Result.AddTypedTextChunk(
2847 Result.getAllocator().CopyString(ND->getNameAsString()));
2848 Result.AddTextChunk("::");
2849 return Result.TakeString();
2850 }
2851
2852 for (const auto *I : ND->specific_attrs<AnnotateAttr>())
2853 Result.AddAnnotation(Result.getAllocator().CopyString(I->getAnnotation()));
2854
2855 AddResultTypeChunk(Ctx, Policy, ND, CCContext.getBaseType(), Result);
2856
2857 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) {
2858 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2859 Ctx, Policy);
2860 AddTypedNameChunk(Ctx, Policy, ND, Result);
2861 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2862 AddFunctionParameterChunks(PP, Policy, Function, Result);
2863 Result.AddChunk(CodeCompletionString::CK_RightParen);
2864 AddFunctionTypeQualsToCompletionString(Result, Function);
2865 return Result.TakeString();
2866 }
2867
2868 if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) {
2869 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2870 Ctx, Policy);
2871 FunctionDecl *Function = FunTmpl->getTemplatedDecl();
2872 AddTypedNameChunk(Ctx, Policy, Function, Result);
2873
2874 // Figure out which template parameters are deduced (or have default
2875 // arguments).
2876 llvm::SmallBitVector Deduced;
2877 Sema::MarkDeducedTemplateParameters(Ctx, FunTmpl, Deduced);
2878 unsigned LastDeducibleArgument;
2879 for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0;
2880 --LastDeducibleArgument) {
2881 if (!Deduced[LastDeducibleArgument - 1]) {
2882 // C++0x: Figure out if the template argument has a default. If so,
2883 // the user doesn't need to type this argument.
2884 // FIXME: We need to abstract template parameters better!
2885 bool HasDefaultArg = false;
2886 NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam(
2887 LastDeducibleArgument - 1);
2888 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
2889 HasDefaultArg = TTP->hasDefaultArgument();
2890 else if (NonTypeTemplateParmDecl *NTTP
2891 = dyn_cast<NonTypeTemplateParmDecl>(Param))
2892 HasDefaultArg = NTTP->hasDefaultArgument();
2893 else {
2894 assert(isa<TemplateTemplateParmDecl>(Param));
2895 HasDefaultArg
2896 = cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument();
2897 }
2898
2899 if (!HasDefaultArg)
2900 break;
2901 }
2902 }
2903
2904 if (LastDeducibleArgument) {
2905 // Some of the function template arguments cannot be deduced from a
2906 // function call, so we introduce an explicit template argument list
2907 // containing all of the arguments up to the first deducible argument.
2908 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2909 AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result,
2910 LastDeducibleArgument);
2911 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2912 }
2913
2914 // Add the function parameters
2915 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2916 AddFunctionParameterChunks(PP, Policy, Function, Result);
2917 Result.AddChunk(CodeCompletionString::CK_RightParen);
2918 AddFunctionTypeQualsToCompletionString(Result, Function);
2919 return Result.TakeString();
2920 }
2921
2922 if (const TemplateDecl *Template = dyn_cast<TemplateDecl>(ND)) {
2923 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2924 Ctx, Policy);
2925 Result.AddTypedTextChunk(
2926 Result.getAllocator().CopyString(Template->getNameAsString()));
2927 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
2928 AddTemplateParameterChunks(Ctx, Policy, Template, Result);
2929 Result.AddChunk(CodeCompletionString::CK_RightAngle);
2930 return Result.TakeString();
2931 }
2932
2933 if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2934 Selector Sel = Method->getSelector();
2935 if (Sel.isUnarySelector()) {
2936 Result.AddTypedTextChunk(Result.getAllocator().CopyString(
2937 Sel.getNameForSlot(0)));
2938 return Result.TakeString();
2939 }
2940
2941 std::string SelName = Sel.getNameForSlot(0).str();
2942 SelName += ':';
2943 if (StartParameter == 0)
2944 Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName));
2945 else {
2946 Result.AddInformativeChunk(Result.getAllocator().CopyString(SelName));
2947
2948 // If there is only one parameter, and we're past it, add an empty
2949 // typed-text chunk since there is nothing to type.
2950 if (Method->param_size() == 1)
2951 Result.AddTypedTextChunk("");
2952 }
2953 unsigned Idx = 0;
2954 for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(),
2955 PEnd = Method->param_end();
2956 P != PEnd; (void)++P, ++Idx) {
2957 if (Idx > 0) {
2958 std::string Keyword;
2959 if (Idx > StartParameter)
2960 Result.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2961 if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx))
2962 Keyword += II->getName();
2963 Keyword += ":";
2964 if (Idx < StartParameter || AllParametersAreInformative)
2965 Result.AddInformativeChunk(Result.getAllocator().CopyString(Keyword));
2966 else
2967 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Keyword));
2968 }
2969
2970 // If we're before the starting parameter, skip the placeholder.
2971 if (Idx < StartParameter)
2972 continue;
2973
2974 std::string Arg;
2975 QualType ParamType = (*P)->getType();
2976 Optional<ArrayRef<QualType>> ObjCSubsts;
2977 if (!CCContext.getBaseType().isNull())
2978 ObjCSubsts = CCContext.getBaseType()->getObjCSubstitutions(Method);
2979
2980 if (ParamType->isBlockPointerType() && !DeclaringEntity)
2981 Arg = FormatFunctionParameter(Policy, *P, true,
2982 /*SuppressBlock=*/false,
2983 ObjCSubsts);
2984 else {
2985 if (ObjCSubsts)
2986 ParamType = ParamType.substObjCTypeArgs(Ctx, *ObjCSubsts,
2987 ObjCSubstitutionContext::Parameter);
2988 Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier(),
2989 ParamType);
2990 Arg += ParamType.getAsString(Policy) + ")";
2991 if (IdentifierInfo *II = (*P)->getIdentifier())
2992 if (DeclaringEntity || AllParametersAreInformative)
2993 Arg += II->getName();
2994 }
2995
2996 if (Method->isVariadic() && (P + 1) == PEnd)
2997 Arg += ", ...";
2998
2999 if (DeclaringEntity)
3000 Result.AddTextChunk(Result.getAllocator().CopyString(Arg));
3001 else if (AllParametersAreInformative)
3002 Result.AddInformativeChunk(Result.getAllocator().CopyString(Arg));
3003 else
3004 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
3005 }
3006
3007 if (Method->isVariadic()) {
3008 if (Method->param_size() == 0) {
3009 if (DeclaringEntity)
3010 Result.AddTextChunk(", ...");
3011 else if (AllParametersAreInformative)
3012 Result.AddInformativeChunk(", ...");
3013 else
3014 Result.AddPlaceholderChunk(", ...");
3015 }
3016
3017 MaybeAddSentinel(PP, Method, Result);
3018 }
3019
3020 return Result.TakeString();
3021 }
3022
3023 if (Qualifier)
3024 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
3025 Ctx, Policy);
3026
3027 Result.AddTypedTextChunk(
3028 Result.getAllocator().CopyString(ND->getNameAsString()));
3029 return Result.TakeString();
3030 }
3031
getCompletionComment(const ASTContext & Ctx,const NamedDecl * ND)3032 const RawComment *clang::getCompletionComment(const ASTContext &Ctx,
3033 const NamedDecl *ND) {
3034 if (!ND)
3035 return nullptr;
3036 if (auto *RC = Ctx.getRawCommentForAnyRedecl(ND))
3037 return RC;
3038
3039 // Try to find comment from a property for ObjC methods.
3040 const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(ND);
3041 if (!M)
3042 return nullptr;
3043 const ObjCPropertyDecl *PDecl = M->findPropertyDecl();
3044 if (!PDecl)
3045 return nullptr;
3046
3047 return Ctx.getRawCommentForAnyRedecl(PDecl);
3048 }
3049
getPatternCompletionComment(const ASTContext & Ctx,const NamedDecl * ND)3050 const RawComment *clang::getPatternCompletionComment(const ASTContext &Ctx,
3051 const NamedDecl *ND) {
3052 const ObjCMethodDecl *M = dyn_cast_or_null<ObjCMethodDecl>(ND);
3053 if (!M || !M->isPropertyAccessor())
3054 return nullptr;
3055
3056 // Provide code completion comment for self.GetterName where
3057 // GetterName is the getter method for a property with name
3058 // different from the property name (declared via a property
3059 // getter attribute.
3060 const ObjCPropertyDecl *PDecl = M->findPropertyDecl();
3061 if (!PDecl)
3062 return nullptr;
3063 if (PDecl->getGetterName() == M->getSelector() &&
3064 PDecl->getIdentifier() != M->getIdentifier()) {
3065 if (auto *RC = Ctx.getRawCommentForAnyRedecl(M))
3066 return RC;
3067 if (auto *RC = Ctx.getRawCommentForAnyRedecl(PDecl))
3068 return RC;
3069 }
3070 return nullptr;
3071 }
3072
getParameterComment(const ASTContext & Ctx,const CodeCompleteConsumer::OverloadCandidate & Result,unsigned ArgIndex)3073 const RawComment *clang::getParameterComment(
3074 const ASTContext &Ctx,
3075 const CodeCompleteConsumer::OverloadCandidate &Result,
3076 unsigned ArgIndex) {
3077 auto FDecl = Result.getFunction();
3078 if (!FDecl)
3079 return nullptr;
3080 if (ArgIndex < FDecl->getNumParams())
3081 return Ctx.getRawCommentForAnyRedecl(FDecl->getParamDecl(ArgIndex));
3082 return nullptr;
3083 }
3084
3085 /// Add function overload parameter chunks to the given code completion
3086 /// string.
AddOverloadParameterChunks(ASTContext & Context,const PrintingPolicy & Policy,const FunctionDecl * Function,const FunctionProtoType * Prototype,CodeCompletionBuilder & Result,unsigned CurrentArg,unsigned Start=0,bool InOptional=false)3087 static void AddOverloadParameterChunks(ASTContext &Context,
3088 const PrintingPolicy &Policy,
3089 const FunctionDecl *Function,
3090 const FunctionProtoType *Prototype,
3091 CodeCompletionBuilder &Result,
3092 unsigned CurrentArg,
3093 unsigned Start = 0,
3094 bool InOptional = false) {
3095 bool FirstParameter = true;
3096 unsigned NumParams = Function ? Function->getNumParams()
3097 : Prototype->getNumParams();
3098
3099 for (unsigned P = Start; P != NumParams; ++P) {
3100 if (Function && Function->getParamDecl(P)->hasDefaultArg() && !InOptional) {
3101 // When we see an optional default argument, put that argument and
3102 // the remaining default arguments into a new, optional string.
3103 CodeCompletionBuilder Opt(Result.getAllocator(),
3104 Result.getCodeCompletionTUInfo());
3105 if (!FirstParameter)
3106 Opt.AddChunk(CodeCompletionString::CK_Comma);
3107 // Optional sections are nested.
3108 AddOverloadParameterChunks(Context, Policy, Function, Prototype, Opt,
3109 CurrentArg, P, /*InOptional=*/true);
3110 Result.AddOptionalChunk(Opt.TakeString());
3111 return;
3112 }
3113
3114 if (FirstParameter)
3115 FirstParameter = false;
3116 else
3117 Result.AddChunk(CodeCompletionString::CK_Comma);
3118
3119 InOptional = false;
3120
3121 // Format the placeholder string.
3122 std::string Placeholder;
3123 if (Function) {
3124 const ParmVarDecl *Param = Function->getParamDecl(P);
3125 Placeholder = FormatFunctionParameter(Policy, Param);
3126 if (Param->hasDefaultArg())
3127 Placeholder += GetDefaultValueString(Param, Context.getSourceManager(), Context.getLangOpts());
3128 } else {
3129 Placeholder = Prototype->getParamType(P).getAsString(Policy);
3130 }
3131
3132 if (P == CurrentArg)
3133 Result.AddCurrentParameterChunk(
3134 Result.getAllocator().CopyString(Placeholder));
3135 else
3136 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Placeholder));
3137 }
3138
3139 if (Prototype && Prototype->isVariadic()) {
3140 CodeCompletionBuilder Opt(Result.getAllocator(),
3141 Result.getCodeCompletionTUInfo());
3142 if (!FirstParameter)
3143 Opt.AddChunk(CodeCompletionString::CK_Comma);
3144
3145 if (CurrentArg < NumParams)
3146 Opt.AddPlaceholderChunk("...");
3147 else
3148 Opt.AddCurrentParameterChunk("...");
3149
3150 Result.AddOptionalChunk(Opt.TakeString());
3151 }
3152 }
3153
3154 CodeCompletionString *
CreateSignatureString(unsigned CurrentArg,Sema & S,CodeCompletionAllocator & Allocator,CodeCompletionTUInfo & CCTUInfo,bool IncludeBriefComments) const3155 CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
3156 unsigned CurrentArg, Sema &S,
3157 CodeCompletionAllocator &Allocator,
3158 CodeCompletionTUInfo &CCTUInfo,
3159 bool IncludeBriefComments) const {
3160 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
3161
3162 // FIXME: Set priority, availability appropriately.
3163 CodeCompletionBuilder Result(Allocator,CCTUInfo, 1, CXAvailability_Available);
3164 FunctionDecl *FDecl = getFunction();
3165 const FunctionProtoType *Proto
3166 = dyn_cast<FunctionProtoType>(getFunctionType());
3167 if (!FDecl && !Proto) {
3168 // Function without a prototype. Just give the return type and a
3169 // highlighted ellipsis.
3170 const FunctionType *FT = getFunctionType();
3171 Result.AddResultTypeChunk(Result.getAllocator().CopyString(
3172 FT->getReturnType().getAsString(Policy)));
3173 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3174 Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
3175 Result.AddChunk(CodeCompletionString::CK_RightParen);
3176 return Result.TakeString();
3177 }
3178
3179 if (FDecl) {
3180 if (IncludeBriefComments) {
3181 if (auto RC = getParameterComment(S.getASTContext(), *this, CurrentArg))
3182 Result.addBriefComment(RC->getBriefText(S.getASTContext()));
3183 }
3184 AddResultTypeChunk(S.Context, Policy, FDecl, QualType(), Result);
3185 Result.AddTextChunk(
3186 Result.getAllocator().CopyString(FDecl->getNameAsString()));
3187 } else {
3188 Result.AddResultTypeChunk(
3189 Result.getAllocator().CopyString(
3190 Proto->getReturnType().getAsString(Policy)));
3191 }
3192
3193 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3194 AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, Result,
3195 CurrentArg);
3196 Result.AddChunk(CodeCompletionString::CK_RightParen);
3197
3198 return Result.TakeString();
3199 }
3200
getMacroUsagePriority(StringRef MacroName,const LangOptions & LangOpts,bool PreferredTypeIsPointer)3201 unsigned clang::getMacroUsagePriority(StringRef MacroName,
3202 const LangOptions &LangOpts,
3203 bool PreferredTypeIsPointer) {
3204 unsigned Priority = CCP_Macro;
3205
3206 // Treat the "nil", "Nil" and "NULL" macros as null pointer constants.
3207 if (MacroName.equals("nil") || MacroName.equals("NULL") ||
3208 MacroName.equals("Nil")) {
3209 Priority = CCP_Constant;
3210 if (PreferredTypeIsPointer)
3211 Priority = Priority / CCF_SimilarTypeMatch;
3212 }
3213 // Treat "YES", "NO", "true", and "false" as constants.
3214 else if (MacroName.equals("YES") || MacroName.equals("NO") ||
3215 MacroName.equals("true") || MacroName.equals("false"))
3216 Priority = CCP_Constant;
3217 // Treat "bool" as a type.
3218 else if (MacroName.equals("bool"))
3219 Priority = CCP_Type + (LangOpts.ObjC1? CCD_bool_in_ObjC : 0);
3220
3221
3222 return Priority;
3223 }
3224
getCursorKindForDecl(const Decl * D)3225 CXCursorKind clang::getCursorKindForDecl(const Decl *D) {
3226 if (!D)
3227 return CXCursor_UnexposedDecl;
3228
3229 switch (D->getKind()) {
3230 case Decl::Enum: return CXCursor_EnumDecl;
3231 case Decl::EnumConstant: return CXCursor_EnumConstantDecl;
3232 case Decl::Field: return CXCursor_FieldDecl;
3233 case Decl::Function:
3234 return CXCursor_FunctionDecl;
3235 case Decl::ObjCCategory: return CXCursor_ObjCCategoryDecl;
3236 case Decl::ObjCCategoryImpl: return CXCursor_ObjCCategoryImplDecl;
3237 case Decl::ObjCImplementation: return CXCursor_ObjCImplementationDecl;
3238
3239 case Decl::ObjCInterface: return CXCursor_ObjCInterfaceDecl;
3240 case Decl::ObjCIvar: return CXCursor_ObjCIvarDecl;
3241 case Decl::ObjCMethod:
3242 return cast<ObjCMethodDecl>(D)->isInstanceMethod()
3243 ? CXCursor_ObjCInstanceMethodDecl : CXCursor_ObjCClassMethodDecl;
3244 case Decl::CXXMethod: return CXCursor_CXXMethod;
3245 case Decl::CXXConstructor: return CXCursor_Constructor;
3246 case Decl::CXXDestructor: return CXCursor_Destructor;
3247 case Decl::CXXConversion: return CXCursor_ConversionFunction;
3248 case Decl::ObjCProperty: return CXCursor_ObjCPropertyDecl;
3249 case Decl::ObjCProtocol: return CXCursor_ObjCProtocolDecl;
3250 case Decl::ParmVar: return CXCursor_ParmDecl;
3251 case Decl::Typedef: return CXCursor_TypedefDecl;
3252 case Decl::TypeAlias: return CXCursor_TypeAliasDecl;
3253 case Decl::TypeAliasTemplate: return CXCursor_TypeAliasTemplateDecl;
3254 case Decl::Var: return CXCursor_VarDecl;
3255 case Decl::Namespace: return CXCursor_Namespace;
3256 case Decl::NamespaceAlias: return CXCursor_NamespaceAlias;
3257 case Decl::TemplateTypeParm: return CXCursor_TemplateTypeParameter;
3258 case Decl::NonTypeTemplateParm:return CXCursor_NonTypeTemplateParameter;
3259 case Decl::TemplateTemplateParm:return CXCursor_TemplateTemplateParameter;
3260 case Decl::FunctionTemplate: return CXCursor_FunctionTemplate;
3261 case Decl::ClassTemplate: return CXCursor_ClassTemplate;
3262 case Decl::AccessSpec: return CXCursor_CXXAccessSpecifier;
3263 case Decl::ClassTemplatePartialSpecialization:
3264 return CXCursor_ClassTemplatePartialSpecialization;
3265 case Decl::UsingDirective: return CXCursor_UsingDirective;
3266 case Decl::StaticAssert: return CXCursor_StaticAssert;
3267 case Decl::Friend: return CXCursor_FriendDecl;
3268 case Decl::TranslationUnit: return CXCursor_TranslationUnit;
3269
3270 case Decl::Using:
3271 case Decl::UnresolvedUsingValue:
3272 case Decl::UnresolvedUsingTypename:
3273 return CXCursor_UsingDeclaration;
3274
3275 case Decl::ObjCPropertyImpl:
3276 switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
3277 case ObjCPropertyImplDecl::Dynamic:
3278 return CXCursor_ObjCDynamicDecl;
3279
3280 case ObjCPropertyImplDecl::Synthesize:
3281 return CXCursor_ObjCSynthesizeDecl;
3282 }
3283
3284 case Decl::Import:
3285 return CXCursor_ModuleImportDecl;
3286
3287 case Decl::ObjCTypeParam: return CXCursor_TemplateTypeParameter;
3288
3289 default:
3290 if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
3291 switch (TD->getTagKind()) {
3292 case TTK_Interface: // fall through
3293 case TTK_Struct: return CXCursor_StructDecl;
3294 case TTK_Class: return CXCursor_ClassDecl;
3295 case TTK_Union: return CXCursor_UnionDecl;
3296 case TTK_Enum: return CXCursor_EnumDecl;
3297 }
3298 }
3299 }
3300
3301 return CXCursor_UnexposedDecl;
3302 }
3303
AddMacroResults(Preprocessor & PP,ResultBuilder & Results,bool IncludeUndefined,bool TargetTypeIsPointer=false)3304 static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results,
3305 bool IncludeUndefined,
3306 bool TargetTypeIsPointer = false) {
3307 typedef CodeCompletionResult Result;
3308
3309 Results.EnterNewScope();
3310
3311 for (Preprocessor::macro_iterator M = PP.macro_begin(),
3312 MEnd = PP.macro_end();
3313 M != MEnd; ++M) {
3314 auto MD = PP.getMacroDefinition(M->first);
3315 if (IncludeUndefined || MD) {
3316 if (MacroInfo *MI = MD.getMacroInfo())
3317 if (MI->isUsedForHeaderGuard())
3318 continue;
3319
3320 Results.AddResult(Result(M->first,
3321 getMacroUsagePriority(M->first->getName(),
3322 PP.getLangOpts(),
3323 TargetTypeIsPointer)));
3324 }
3325 }
3326
3327 Results.ExitScope();
3328
3329 }
3330
AddPrettyFunctionResults(const LangOptions & LangOpts,ResultBuilder & Results)3331 static void AddPrettyFunctionResults(const LangOptions &LangOpts,
3332 ResultBuilder &Results) {
3333 typedef CodeCompletionResult Result;
3334
3335 Results.EnterNewScope();
3336
3337 Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant));
3338 Results.AddResult(Result("__FUNCTION__", CCP_Constant));
3339 if (LangOpts.C99 || LangOpts.CPlusPlus11)
3340 Results.AddResult(Result("__func__", CCP_Constant));
3341 Results.ExitScope();
3342 }
3343
HandleCodeCompleteResults(Sema * S,CodeCompleteConsumer * CodeCompleter,CodeCompletionContext Context,CodeCompletionResult * Results,unsigned NumResults)3344 static void HandleCodeCompleteResults(Sema *S,
3345 CodeCompleteConsumer *CodeCompleter,
3346 CodeCompletionContext Context,
3347 CodeCompletionResult *Results,
3348 unsigned NumResults) {
3349 if (CodeCompleter)
3350 CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults);
3351 }
3352
mapCodeCompletionContext(Sema & S,Sema::ParserCompletionContext PCC)3353 static enum CodeCompletionContext::Kind mapCodeCompletionContext(Sema &S,
3354 Sema::ParserCompletionContext PCC) {
3355 switch (PCC) {
3356 case Sema::PCC_Namespace:
3357 return CodeCompletionContext::CCC_TopLevel;
3358
3359 case Sema::PCC_Class:
3360 return CodeCompletionContext::CCC_ClassStructUnion;
3361
3362 case Sema::PCC_ObjCInterface:
3363 return CodeCompletionContext::CCC_ObjCInterface;
3364
3365 case Sema::PCC_ObjCImplementation:
3366 return CodeCompletionContext::CCC_ObjCImplementation;
3367
3368 case Sema::PCC_ObjCInstanceVariableList:
3369 return CodeCompletionContext::CCC_ObjCIvarList;
3370
3371 case Sema::PCC_Template:
3372 case Sema::PCC_MemberTemplate:
3373 if (S.CurContext->isFileContext())
3374 return CodeCompletionContext::CCC_TopLevel;
3375 if (S.CurContext->isRecord())
3376 return CodeCompletionContext::CCC_ClassStructUnion;
3377 return CodeCompletionContext::CCC_Other;
3378
3379 case Sema::PCC_RecoveryInFunction:
3380 return CodeCompletionContext::CCC_Recovery;
3381
3382 case Sema::PCC_ForInit:
3383 if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 ||
3384 S.getLangOpts().ObjC1)
3385 return CodeCompletionContext::CCC_ParenthesizedExpression;
3386 else
3387 return CodeCompletionContext::CCC_Expression;
3388
3389 case Sema::PCC_Expression:
3390 case Sema::PCC_Condition:
3391 return CodeCompletionContext::CCC_Expression;
3392
3393 case Sema::PCC_Statement:
3394 return CodeCompletionContext::CCC_Statement;
3395
3396 case Sema::PCC_Type:
3397 return CodeCompletionContext::CCC_Type;
3398
3399 case Sema::PCC_ParenthesizedExpression:
3400 return CodeCompletionContext::CCC_ParenthesizedExpression;
3401
3402 case Sema::PCC_LocalDeclarationSpecifiers:
3403 return CodeCompletionContext::CCC_Type;
3404 }
3405
3406 llvm_unreachable("Invalid ParserCompletionContext!");
3407 }
3408
3409 /// If we're in a C++ virtual member function, add completion results
3410 /// that invoke the functions we override, since it's common to invoke the
3411 /// overridden function as well as adding new functionality.
3412 ///
3413 /// \param S The semantic analysis object for which we are generating results.
3414 ///
3415 /// \param InContext This context in which the nested-name-specifier preceding
3416 /// the code-completion point
MaybeAddOverrideCalls(Sema & S,DeclContext * InContext,ResultBuilder & Results)3417 static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext,
3418 ResultBuilder &Results) {
3419 // Look through blocks.
3420 DeclContext *CurContext = S.CurContext;
3421 while (isa<BlockDecl>(CurContext))
3422 CurContext = CurContext->getParent();
3423
3424
3425 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext);
3426 if (!Method || !Method->isVirtual())
3427 return;
3428
3429 // We need to have names for all of the parameters, if we're going to
3430 // generate a forwarding call.
3431 for (auto P : Method->parameters())
3432 if (!P->getDeclName())
3433 return;
3434
3435 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
3436 for (const CXXMethodDecl *Overridden : Method->overridden_methods()) {
3437 CodeCompletionBuilder Builder(Results.getAllocator(),
3438 Results.getCodeCompletionTUInfo());
3439 if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl())
3440 continue;
3441
3442 // If we need a nested-name-specifier, add one now.
3443 if (!InContext) {
3444 NestedNameSpecifier *NNS
3445 = getRequiredQualification(S.Context, CurContext,
3446 Overridden->getDeclContext());
3447 if (NNS) {
3448 std::string Str;
3449 llvm::raw_string_ostream OS(Str);
3450 NNS->print(OS, Policy);
3451 Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
3452 }
3453 } else if (!InContext->Equals(Overridden->getDeclContext()))
3454 continue;
3455
3456 Builder.AddTypedTextChunk(Results.getAllocator().CopyString(
3457 Overridden->getNameAsString()));
3458 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
3459 bool FirstParam = true;
3460 for (auto P : Method->parameters()) {
3461 if (FirstParam)
3462 FirstParam = false;
3463 else
3464 Builder.AddChunk(CodeCompletionString::CK_Comma);
3465
3466 Builder.AddPlaceholderChunk(
3467 Results.getAllocator().CopyString(P->getIdentifier()->getName()));
3468 }
3469 Builder.AddChunk(CodeCompletionString::CK_RightParen);
3470 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
3471 CCP_SuperCompletion,
3472 CXCursor_CXXMethod,
3473 CXAvailability_Available,
3474 Overridden));
3475 Results.Ignore(Overridden);
3476 }
3477 }
3478
CodeCompleteModuleImport(SourceLocation ImportLoc,ModuleIdPath Path)3479 void Sema::CodeCompleteModuleImport(SourceLocation ImportLoc,
3480 ModuleIdPath Path) {
3481 typedef CodeCompletionResult Result;
3482 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3483 CodeCompleter->getCodeCompletionTUInfo(),
3484 CodeCompletionContext::CCC_Other);
3485 Results.EnterNewScope();
3486
3487 CodeCompletionAllocator &Allocator = Results.getAllocator();
3488 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
3489 typedef CodeCompletionResult Result;
3490 if (Path.empty()) {
3491 // Enumerate all top-level modules.
3492 SmallVector<Module *, 8> Modules;
3493 PP.getHeaderSearchInfo().collectAllModules(Modules);
3494 for (unsigned I = 0, N = Modules.size(); I != N; ++I) {
3495 Builder.AddTypedTextChunk(
3496 Builder.getAllocator().CopyString(Modules[I]->Name));
3497 Results.AddResult(Result(Builder.TakeString(),
3498 CCP_Declaration,
3499 CXCursor_ModuleImportDecl,
3500 Modules[I]->isAvailable()
3501 ? CXAvailability_Available
3502 : CXAvailability_NotAvailable));
3503 }
3504 } else if (getLangOpts().Modules) {
3505 // Load the named module.
3506 Module *Mod = PP.getModuleLoader().loadModule(ImportLoc, Path,
3507 Module::AllVisible,
3508 /*IsInclusionDirective=*/false);
3509 // Enumerate submodules.
3510 if (Mod) {
3511 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
3512 SubEnd = Mod->submodule_end();
3513 Sub != SubEnd; ++Sub) {
3514
3515 Builder.AddTypedTextChunk(
3516 Builder.getAllocator().CopyString((*Sub)->Name));
3517 Results.AddResult(Result(Builder.TakeString(),
3518 CCP_Declaration,
3519 CXCursor_ModuleImportDecl,
3520 (*Sub)->isAvailable()
3521 ? CXAvailability_Available
3522 : CXAvailability_NotAvailable));
3523 }
3524 }
3525 }
3526 Results.ExitScope();
3527 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3528 Results.data(),Results.size());
3529 }
3530
CodeCompleteOrdinaryName(Scope * S,ParserCompletionContext CompletionContext)3531 void Sema::CodeCompleteOrdinaryName(Scope *S,
3532 ParserCompletionContext CompletionContext) {
3533 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3534 CodeCompleter->getCodeCompletionTUInfo(),
3535 mapCodeCompletionContext(*this, CompletionContext));
3536 Results.EnterNewScope();
3537
3538 // Determine how to filter results, e.g., so that the names of
3539 // values (functions, enumerators, function templates, etc.) are
3540 // only allowed where we can have an expression.
3541 switch (CompletionContext) {
3542 case PCC_Namespace:
3543 case PCC_Class:
3544 case PCC_ObjCInterface:
3545 case PCC_ObjCImplementation:
3546 case PCC_ObjCInstanceVariableList:
3547 case PCC_Template:
3548 case PCC_MemberTemplate:
3549 case PCC_Type:
3550 case PCC_LocalDeclarationSpecifiers:
3551 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
3552 break;
3553
3554 case PCC_Statement:
3555 case PCC_ParenthesizedExpression:
3556 case PCC_Expression:
3557 case PCC_ForInit:
3558 case PCC_Condition:
3559 if (WantTypesInContext(CompletionContext, getLangOpts()))
3560 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3561 else
3562 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3563
3564 if (getLangOpts().CPlusPlus)
3565 MaybeAddOverrideCalls(*this, /*InContext=*/nullptr, Results);
3566 break;
3567
3568 case PCC_RecoveryInFunction:
3569 // Unfiltered
3570 break;
3571 }
3572
3573 // If we are in a C++ non-static member function, check the qualifiers on
3574 // the member function to filter/prioritize the results list.
3575 if (CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext))
3576 if (CurMethod->isInstance())
3577 Results.setObjectTypeQualifiers(
3578 Qualifiers::fromCVRMask(CurMethod->getTypeQualifiers()));
3579
3580 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3581 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3582 CodeCompleter->includeGlobals(),
3583 CodeCompleter->loadExternal());
3584
3585 AddOrdinaryNameResults(CompletionContext, S, *this, Results);
3586 Results.ExitScope();
3587
3588 switch (CompletionContext) {
3589 case PCC_ParenthesizedExpression:
3590 case PCC_Expression:
3591 case PCC_Statement:
3592 case PCC_RecoveryInFunction:
3593 if (S->getFnParent())
3594 AddPrettyFunctionResults(getLangOpts(), Results);
3595 break;
3596
3597 case PCC_Namespace:
3598 case PCC_Class:
3599 case PCC_ObjCInterface:
3600 case PCC_ObjCImplementation:
3601 case PCC_ObjCInstanceVariableList:
3602 case PCC_Template:
3603 case PCC_MemberTemplate:
3604 case PCC_ForInit:
3605 case PCC_Condition:
3606 case PCC_Type:
3607 case PCC_LocalDeclarationSpecifiers:
3608 break;
3609 }
3610
3611 if (CodeCompleter->includeMacros())
3612 AddMacroResults(PP, Results, false);
3613
3614 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3615 Results.data(),Results.size());
3616 }
3617
3618 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
3619 ParsedType Receiver,
3620 ArrayRef<IdentifierInfo *> SelIdents,
3621 bool AtArgumentExpression,
3622 bool IsSuper,
3623 ResultBuilder &Results);
3624
CodeCompleteDeclSpec(Scope * S,DeclSpec & DS,bool AllowNonIdentifiers,bool AllowNestedNameSpecifiers)3625 void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
3626 bool AllowNonIdentifiers,
3627 bool AllowNestedNameSpecifiers) {
3628 typedef CodeCompletionResult Result;
3629 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3630 CodeCompleter->getCodeCompletionTUInfo(),
3631 AllowNestedNameSpecifiers
3632 ? CodeCompletionContext::CCC_PotentiallyQualifiedName
3633 : CodeCompletionContext::CCC_Name);
3634 Results.EnterNewScope();
3635
3636 // Type qualifiers can come after names.
3637 Results.AddResult(Result("const"));
3638 Results.AddResult(Result("volatile"));
3639 if (getLangOpts().C99)
3640 Results.AddResult(Result("restrict"));
3641
3642 if (getLangOpts().CPlusPlus) {
3643 if (getLangOpts().CPlusPlus11 &&
3644 (DS.getTypeSpecType() == DeclSpec::TST_class ||
3645 DS.getTypeSpecType() == DeclSpec::TST_struct))
3646 Results.AddResult("final");
3647
3648 if (AllowNonIdentifiers) {
3649 Results.AddResult(Result("operator"));
3650 }
3651
3652 // Add nested-name-specifiers.
3653 if (AllowNestedNameSpecifiers) {
3654 Results.allowNestedNameSpecifiers();
3655 Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy);
3656 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3657 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
3658 CodeCompleter->includeGlobals(),
3659 CodeCompleter->loadExternal());
3660 Results.setFilter(nullptr);
3661 }
3662 }
3663 Results.ExitScope();
3664
3665 // If we're in a context where we might have an expression (rather than a
3666 // declaration), and what we've seen so far is an Objective-C type that could
3667 // be a receiver of a class message, this may be a class message send with
3668 // the initial opening bracket '[' missing. Add appropriate completions.
3669 if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
3670 DS.getParsedSpecifiers() == DeclSpec::PQ_TypeSpecifier &&
3671 DS.getTypeSpecType() == DeclSpec::TST_typename &&
3672 DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified &&
3673 DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
3674 !DS.isTypeAltiVecVector() &&
3675 S &&
3676 (S->getFlags() & Scope::DeclScope) != 0 &&
3677 (S->getFlags() & (Scope::ClassScope | Scope::TemplateParamScope |
3678 Scope::FunctionPrototypeScope |
3679 Scope::AtCatchScope)) == 0) {
3680 ParsedType T = DS.getRepAsType();
3681 if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType())
3682 AddClassMessageCompletions(*this, S, T, None, false, false, Results);
3683 }
3684
3685 // Note that we intentionally suppress macro results here, since we do not
3686 // encourage using macros to produce the names of entities.
3687
3688 HandleCodeCompleteResults(this, CodeCompleter,
3689 Results.getCompletionContext(),
3690 Results.data(), Results.size());
3691 }
3692
3693 struct Sema::CodeCompleteExpressionData {
CodeCompleteExpressionDataSema::CodeCompleteExpressionData3694 CodeCompleteExpressionData(QualType PreferredType = QualType())
3695 : PreferredType(PreferredType), IntegralConstantExpression(false),
3696 ObjCCollection(false) { }
3697
3698 QualType PreferredType;
3699 bool IntegralConstantExpression;
3700 bool ObjCCollection;
3701 SmallVector<Decl *, 4> IgnoreDecls;
3702 };
3703
3704 /// Perform code-completion in an expression context when we know what
3705 /// type we're looking for.
CodeCompleteExpression(Scope * S,const CodeCompleteExpressionData & Data)3706 void Sema::CodeCompleteExpression(Scope *S,
3707 const CodeCompleteExpressionData &Data) {
3708 ResultBuilder Results(
3709 *this, CodeCompleter->getAllocator(),
3710 CodeCompleter->getCodeCompletionTUInfo(),
3711 CodeCompletionContext(CodeCompletionContext::CCC_Expression,
3712 Data.PreferredType));
3713 if (Data.ObjCCollection)
3714 Results.setFilter(&ResultBuilder::IsObjCCollection);
3715 else if (Data.IntegralConstantExpression)
3716 Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
3717 else if (WantTypesInContext(PCC_Expression, getLangOpts()))
3718 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3719 else
3720 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3721
3722 if (!Data.PreferredType.isNull())
3723 Results.setPreferredType(Data.PreferredType.getNonReferenceType());
3724
3725 // Ignore any declarations that we were told that we don't care about.
3726 for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I)
3727 Results.Ignore(Data.IgnoreDecls[I]);
3728
3729 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3730 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3731 CodeCompleter->includeGlobals(),
3732 CodeCompleter->loadExternal());
3733
3734 Results.EnterNewScope();
3735 AddOrdinaryNameResults(PCC_Expression, S, *this, Results);
3736 Results.ExitScope();
3737
3738 bool PreferredTypeIsPointer = false;
3739 if (!Data.PreferredType.isNull())
3740 PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType()
3741 || Data.PreferredType->isMemberPointerType()
3742 || Data.PreferredType->isBlockPointerType();
3743
3744 if (S->getFnParent() &&
3745 !Data.ObjCCollection &&
3746 !Data.IntegralConstantExpression)
3747 AddPrettyFunctionResults(getLangOpts(), Results);
3748
3749 if (CodeCompleter->includeMacros())
3750 AddMacroResults(PP, Results, false, PreferredTypeIsPointer);
3751 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3752 Results.data(), Results.size());
3753 }
3754
CodeCompletePostfixExpression(Scope * S,ExprResult E)3755 void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E) {
3756 if (E.isInvalid())
3757 CodeCompleteOrdinaryName(S, PCC_RecoveryInFunction);
3758 else if (getLangOpts().ObjC1)
3759 CodeCompleteObjCInstanceMessage(S, E.get(), None, false);
3760 }
3761
3762 /// The set of properties that have already been added, referenced by
3763 /// property name.
3764 typedef llvm::SmallPtrSet<IdentifierInfo*, 16> AddedPropertiesSet;
3765
3766 /// Retrieve the container definition, if any?
getContainerDef(ObjCContainerDecl * Container)3767 static ObjCContainerDecl *getContainerDef(ObjCContainerDecl *Container) {
3768 if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
3769 if (Interface->hasDefinition())
3770 return Interface->getDefinition();
3771
3772 return Interface;
3773 }
3774
3775 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3776 if (Protocol->hasDefinition())
3777 return Protocol->getDefinition();
3778
3779 return Protocol;
3780 }
3781 return Container;
3782 }
3783
3784 /// Adds a block invocation code completion result for the given block
3785 /// declaration \p BD.
AddObjCBlockCall(ASTContext & Context,const PrintingPolicy & Policy,CodeCompletionBuilder & Builder,const NamedDecl * BD,const FunctionTypeLoc & BlockLoc,const FunctionProtoTypeLoc & BlockProtoLoc)3786 static void AddObjCBlockCall(ASTContext &Context, const PrintingPolicy &Policy,
3787 CodeCompletionBuilder &Builder,
3788 const NamedDecl *BD,
3789 const FunctionTypeLoc &BlockLoc,
3790 const FunctionProtoTypeLoc &BlockProtoLoc) {
3791 Builder.AddResultTypeChunk(
3792 GetCompletionTypeString(BlockLoc.getReturnLoc().getType(), Context,
3793 Policy, Builder.getAllocator()));
3794
3795 AddTypedNameChunk(Context, Policy, BD, Builder);
3796 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
3797
3798 if (BlockProtoLoc && BlockProtoLoc.getTypePtr()->isVariadic()) {
3799 Builder.AddPlaceholderChunk("...");
3800 } else {
3801 for (unsigned I = 0, N = BlockLoc.getNumParams(); I != N; ++I) {
3802 if (I)
3803 Builder.AddChunk(CodeCompletionString::CK_Comma);
3804
3805 // Format the placeholder string.
3806 std::string PlaceholderStr =
3807 FormatFunctionParameter(Policy, BlockLoc.getParam(I));
3808
3809 if (I == N - 1 && BlockProtoLoc &&
3810 BlockProtoLoc.getTypePtr()->isVariadic())
3811 PlaceholderStr += ", ...";
3812
3813 // Add the placeholder string.
3814 Builder.AddPlaceholderChunk(
3815 Builder.getAllocator().CopyString(PlaceholderStr));
3816 }
3817 }
3818
3819 Builder.AddChunk(CodeCompletionString::CK_RightParen);
3820 }
3821
AddObjCProperties(const CodeCompletionContext & CCContext,ObjCContainerDecl * Container,bool AllowCategories,bool AllowNullaryMethods,DeclContext * CurContext,AddedPropertiesSet & AddedProperties,ResultBuilder & Results,bool IsBaseExprStatement=false,bool IsClassProperty=false)3822 static void AddObjCProperties(
3823 const CodeCompletionContext &CCContext, ObjCContainerDecl *Container,
3824 bool AllowCategories, bool AllowNullaryMethods, DeclContext *CurContext,
3825 AddedPropertiesSet &AddedProperties, ResultBuilder &Results,
3826 bool IsBaseExprStatement = false, bool IsClassProperty = false) {
3827 typedef CodeCompletionResult Result;
3828
3829 // Retrieve the definition.
3830 Container = getContainerDef(Container);
3831
3832 // Add properties in this container.
3833 const auto AddProperty = [&](const ObjCPropertyDecl *P) {
3834 if (!AddedProperties.insert(P->getIdentifier()).second)
3835 return;
3836
3837 // FIXME: Provide block invocation completion for non-statement
3838 // expressions.
3839 if (!P->getType().getTypePtr()->isBlockPointerType() ||
3840 !IsBaseExprStatement) {
3841 Results.MaybeAddResult(Result(P, Results.getBasePriority(P), nullptr),
3842 CurContext);
3843 return;
3844 }
3845
3846 // Block setter and invocation completion is provided only when we are able
3847 // to find the FunctionProtoTypeLoc with parameter names for the block.
3848 FunctionTypeLoc BlockLoc;
3849 FunctionProtoTypeLoc BlockProtoLoc;
3850 findTypeLocationForBlockDecl(P->getTypeSourceInfo(), BlockLoc,
3851 BlockProtoLoc);
3852 if (!BlockLoc) {
3853 Results.MaybeAddResult(Result(P, Results.getBasePriority(P), nullptr),
3854 CurContext);
3855 return;
3856 }
3857
3858 // The default completion result for block properties should be the block
3859 // invocation completion when the base expression is a statement.
3860 CodeCompletionBuilder Builder(Results.getAllocator(),
3861 Results.getCodeCompletionTUInfo());
3862 AddObjCBlockCall(Container->getASTContext(),
3863 getCompletionPrintingPolicy(Results.getSema()), Builder, P,
3864 BlockLoc, BlockProtoLoc);
3865 Results.MaybeAddResult(
3866 Result(Builder.TakeString(), P, Results.getBasePriority(P)),
3867 CurContext);
3868
3869 // Provide additional block setter completion iff the base expression is a
3870 // statement and the block property is mutable.
3871 if (!P->isReadOnly()) {
3872 CodeCompletionBuilder Builder(Results.getAllocator(),
3873 Results.getCodeCompletionTUInfo());
3874 AddResultTypeChunk(Container->getASTContext(),
3875 getCompletionPrintingPolicy(Results.getSema()), P,
3876 CCContext.getBaseType(), Builder);
3877 Builder.AddTypedTextChunk(
3878 Results.getAllocator().CopyString(P->getName()));
3879 Builder.AddChunk(CodeCompletionString::CK_Equal);
3880
3881 std::string PlaceholderStr = formatBlockPlaceholder(
3882 getCompletionPrintingPolicy(Results.getSema()), P, BlockLoc,
3883 BlockProtoLoc, /*SuppressBlockName=*/true);
3884 // Add the placeholder string.
3885 Builder.AddPlaceholderChunk(
3886 Builder.getAllocator().CopyString(PlaceholderStr));
3887
3888 // When completing blocks properties that return void the default
3889 // property completion result should show up before the setter,
3890 // otherwise the setter completion should show up before the default
3891 // property completion, as we normally want to use the result of the
3892 // call.
3893 Results.MaybeAddResult(
3894 Result(Builder.TakeString(), P,
3895 Results.getBasePriority(P) +
3896 (BlockLoc.getTypePtr()->getReturnType()->isVoidType()
3897 ? CCD_BlockPropertySetter
3898 : -CCD_BlockPropertySetter)),
3899 CurContext);
3900 }
3901 };
3902
3903 if (IsClassProperty) {
3904 for (const auto *P : Container->class_properties())
3905 AddProperty(P);
3906 } else {
3907 for (const auto *P : Container->instance_properties())
3908 AddProperty(P);
3909 }
3910
3911 // Add nullary methods or implicit class properties
3912 if (AllowNullaryMethods) {
3913 ASTContext &Context = Container->getASTContext();
3914 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
3915 // Adds a method result
3916 const auto AddMethod = [&](const ObjCMethodDecl *M) {
3917 IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0);
3918 if (!Name)
3919 return;
3920 if (!AddedProperties.insert(Name).second)
3921 return;
3922 CodeCompletionBuilder Builder(Results.getAllocator(),
3923 Results.getCodeCompletionTUInfo());
3924 AddResultTypeChunk(Context, Policy, M, CCContext.getBaseType(), Builder);
3925 Builder.AddTypedTextChunk(
3926 Results.getAllocator().CopyString(Name->getName()));
3927 Results.MaybeAddResult(
3928 Result(Builder.TakeString(), M,
3929 CCP_MemberDeclaration + CCD_MethodAsProperty),
3930 CurContext);
3931 };
3932
3933 if (IsClassProperty) {
3934 for (const auto *M : Container->methods()) {
3935 // Gather the class method that can be used as implicit property
3936 // getters. Methods with arguments or methods that return void aren't
3937 // added to the results as they can't be used as a getter.
3938 if (!M->getSelector().isUnarySelector() ||
3939 M->getReturnType()->isVoidType() || M->isInstanceMethod())
3940 continue;
3941 AddMethod(M);
3942 }
3943 } else {
3944 for (auto *M : Container->methods()) {
3945 if (M->getSelector().isUnarySelector())
3946 AddMethod(M);
3947 }
3948 }
3949 }
3950
3951 // Add properties in referenced protocols.
3952 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3953 for (auto *P : Protocol->protocols())
3954 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
3955 CurContext, AddedProperties, Results,
3956 IsBaseExprStatement, IsClassProperty);
3957 } else if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)){
3958 if (AllowCategories) {
3959 // Look through categories.
3960 for (auto *Cat : IFace->known_categories())
3961 AddObjCProperties(CCContext, Cat, AllowCategories, AllowNullaryMethods,
3962 CurContext, AddedProperties, Results,
3963 IsBaseExprStatement, IsClassProperty);
3964 }
3965
3966 // Look through protocols.
3967 for (auto *I : IFace->all_referenced_protocols())
3968 AddObjCProperties(CCContext, I, AllowCategories, AllowNullaryMethods,
3969 CurContext, AddedProperties, Results,
3970 IsBaseExprStatement, IsClassProperty);
3971
3972 // Look in the superclass.
3973 if (IFace->getSuperClass())
3974 AddObjCProperties(CCContext, IFace->getSuperClass(), AllowCategories,
3975 AllowNullaryMethods, CurContext, AddedProperties,
3976 Results, IsBaseExprStatement, IsClassProperty);
3977 } else if (const ObjCCategoryDecl *Category
3978 = dyn_cast<ObjCCategoryDecl>(Container)) {
3979 // Look through protocols.
3980 for (auto *P : Category->protocols())
3981 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
3982 CurContext, AddedProperties, Results,
3983 IsBaseExprStatement, IsClassProperty);
3984 }
3985 }
3986
AddRecordMembersCompletionResults(Sema & SemaRef,ResultBuilder & Results,Scope * S,QualType BaseType,RecordDecl * RD,Optional<FixItHint> AccessOpFixIt)3987 static void AddRecordMembersCompletionResults(Sema &SemaRef,
3988 ResultBuilder &Results, Scope *S,
3989 QualType BaseType,
3990 RecordDecl *RD,
3991 Optional<FixItHint> AccessOpFixIt) {
3992 // Indicate that we are performing a member access, and the cv-qualifiers
3993 // for the base object type.
3994 Results.setObjectTypeQualifiers(BaseType.getQualifiers());
3995
3996 // Access to a C/C++ class, struct, or union.
3997 Results.allowNestedNameSpecifiers();
3998 std::vector<FixItHint> FixIts;
3999 if (AccessOpFixIt)
4000 FixIts.emplace_back(AccessOpFixIt.getValue());
4001 CodeCompletionDeclConsumer Consumer(Results, SemaRef.CurContext, std::move(FixIts));
4002 SemaRef.LookupVisibleDecls(RD, Sema::LookupMemberName, Consumer,
4003 SemaRef.CodeCompleter->includeGlobals(),
4004 /*IncludeDependentBases=*/true,
4005 SemaRef.CodeCompleter->loadExternal());
4006
4007 if (SemaRef.getLangOpts().CPlusPlus) {
4008 if (!Results.empty()) {
4009 // The "template" keyword can follow "->" or "." in the grammar.
4010 // However, we only want to suggest the template keyword if something
4011 // is dependent.
4012 bool IsDependent = BaseType->isDependentType();
4013 if (!IsDependent) {
4014 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent())
4015 if (DeclContext *Ctx = DepScope->getEntity()) {
4016 IsDependent = Ctx->isDependentContext();
4017 break;
4018 }
4019 }
4020
4021 if (IsDependent)
4022 Results.AddResult(CodeCompletionResult("template"));
4023 }
4024 }
4025 }
4026
CodeCompleteMemberReferenceExpr(Scope * S,Expr * Base,Expr * OtherOpBase,SourceLocation OpLoc,bool IsArrow,bool IsBaseExprStatement)4027 void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
4028 Expr *OtherOpBase,
4029 SourceLocation OpLoc, bool IsArrow,
4030 bool IsBaseExprStatement) {
4031 if (!Base || !CodeCompleter)
4032 return;
4033
4034 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
4035 if (ConvertedBase.isInvalid())
4036 return;
4037 QualType ConvertedBaseType = ConvertedBase.get()->getType();
4038
4039 enum CodeCompletionContext::Kind contextKind;
4040
4041 if (IsArrow) {
4042 if (const PointerType *Ptr = ConvertedBaseType->getAs<PointerType>())
4043 ConvertedBaseType = Ptr->getPointeeType();
4044 }
4045
4046 if (IsArrow) {
4047 contextKind = CodeCompletionContext::CCC_ArrowMemberAccess;
4048 } else {
4049 if (ConvertedBaseType->isObjCObjectPointerType() ||
4050 ConvertedBaseType->isObjCObjectOrInterfaceType()) {
4051 contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess;
4052 } else {
4053 contextKind = CodeCompletionContext::CCC_DotMemberAccess;
4054 }
4055 }
4056
4057 CodeCompletionContext CCContext(contextKind, ConvertedBaseType);
4058 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4059 CodeCompleter->getCodeCompletionTUInfo(), CCContext,
4060 &ResultBuilder::IsMember);
4061
4062 auto DoCompletion = [&](Expr *Base, bool IsArrow, Optional<FixItHint> AccessOpFixIt) -> bool {
4063 if (!Base)
4064 return false;
4065
4066 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
4067 if (ConvertedBase.isInvalid())
4068 return false;
4069 Base = ConvertedBase.get();
4070
4071 QualType BaseType = Base->getType();
4072
4073 if (IsArrow) {
4074 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
4075 BaseType = Ptr->getPointeeType();
4076 else if (BaseType->isObjCObjectPointerType())
4077 /*Do nothing*/;
4078 else
4079 return false;
4080 }
4081
4082 if (const RecordType *Record = BaseType->getAs<RecordType>()) {
4083 AddRecordMembersCompletionResults(*this, Results, S, BaseType,
4084 Record->getDecl(),
4085 std::move(AccessOpFixIt));
4086 } else if (const auto *TST =
4087 BaseType->getAs<TemplateSpecializationType>()) {
4088 TemplateName TN = TST->getTemplateName();
4089 if (const auto *TD =
4090 dyn_cast_or_null<ClassTemplateDecl>(TN.getAsTemplateDecl())) {
4091 CXXRecordDecl *RD = TD->getTemplatedDecl();
4092 AddRecordMembersCompletionResults(*this, Results, S, BaseType, RD,
4093 std::move(AccessOpFixIt));
4094 }
4095 } else if (const auto *ICNT = BaseType->getAs<InjectedClassNameType>()) {
4096 if (auto *RD = ICNT->getDecl())
4097 AddRecordMembersCompletionResults(*this, Results, S, BaseType, RD,
4098 std::move(AccessOpFixIt));
4099 } else if (!IsArrow && BaseType->isObjCObjectPointerType()) {
4100 // Objective-C property reference.
4101 AddedPropertiesSet AddedProperties;
4102
4103 if (const ObjCObjectPointerType *ObjCPtr =
4104 BaseType->getAsObjCInterfacePointerType()) {
4105 // Add property results based on our interface.
4106 assert(ObjCPtr && "Non-NULL pointer guaranteed above!");
4107 AddObjCProperties(CCContext, ObjCPtr->getInterfaceDecl(), true,
4108 /*AllowNullaryMethods=*/true, CurContext,
4109 AddedProperties, Results, IsBaseExprStatement);
4110 }
4111
4112 // Add properties from the protocols in a qualified interface.
4113 for (auto *I : BaseType->getAs<ObjCObjectPointerType>()->quals())
4114 AddObjCProperties(CCContext, I, true, /*AllowNullaryMethods=*/true,
4115 CurContext, AddedProperties, Results,
4116 IsBaseExprStatement);
4117 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) ||
4118 (!IsArrow && BaseType->isObjCObjectType())) {
4119 // Objective-C instance variable access.
4120 ObjCInterfaceDecl *Class = nullptr;
4121 if (const ObjCObjectPointerType *ObjCPtr =
4122 BaseType->getAs<ObjCObjectPointerType>())
4123 Class = ObjCPtr->getInterfaceDecl();
4124 else
4125 Class = BaseType->getAs<ObjCObjectType>()->getInterface();
4126
4127 // Add all ivars from this class and its superclasses.
4128 if (Class) {
4129 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4130 Results.setFilter(&ResultBuilder::IsObjCIvar);
4131 LookupVisibleDecls(
4132 Class, LookupMemberName, Consumer, CodeCompleter->includeGlobals(),
4133 /*IncludeDependentBases=*/false, CodeCompleter->loadExternal());
4134 }
4135 }
4136
4137 // FIXME: How do we cope with isa?
4138 return true;
4139 };
4140
4141 Results.EnterNewScope();
4142
4143 bool CompletionSucceded = DoCompletion(Base, IsArrow, None);
4144 if (CodeCompleter->includeFixIts()) {
4145 const CharSourceRange OpRange =
4146 CharSourceRange::getTokenRange(OpLoc, OpLoc);
4147 CompletionSucceded |= DoCompletion(
4148 OtherOpBase, !IsArrow,
4149 FixItHint::CreateReplacement(OpRange, IsArrow ? "." : "->"));
4150 }
4151
4152 Results.ExitScope();
4153
4154 if (!CompletionSucceded)
4155 return;
4156
4157 // Hand off the results found for code completion.
4158 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4159 Results.data(), Results.size());
4160 }
4161
CodeCompleteObjCClassPropertyRefExpr(Scope * S,IdentifierInfo & ClassName,SourceLocation ClassNameLoc,bool IsBaseExprStatement)4162 void Sema::CodeCompleteObjCClassPropertyRefExpr(Scope *S,
4163 IdentifierInfo &ClassName,
4164 SourceLocation ClassNameLoc,
4165 bool IsBaseExprStatement) {
4166 IdentifierInfo *ClassNamePtr = &ClassName;
4167 ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(ClassNamePtr, ClassNameLoc);
4168 if (!IFace)
4169 return;
4170 CodeCompletionContext CCContext(
4171 CodeCompletionContext::CCC_ObjCPropertyAccess);
4172 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4173 CodeCompleter->getCodeCompletionTUInfo(), CCContext,
4174 &ResultBuilder::IsMember);
4175 Results.EnterNewScope();
4176 AddedPropertiesSet AddedProperties;
4177 AddObjCProperties(CCContext, IFace, true,
4178 /*AllowNullaryMethods=*/true, CurContext, AddedProperties,
4179 Results, IsBaseExprStatement,
4180 /*IsClassProperty=*/true);
4181 Results.ExitScope();
4182 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4183 Results.data(), Results.size());
4184 }
4185
CodeCompleteTag(Scope * S,unsigned TagSpec)4186 void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) {
4187 if (!CodeCompleter)
4188 return;
4189
4190 ResultBuilder::LookupFilter Filter = nullptr;
4191 enum CodeCompletionContext::Kind ContextKind
4192 = CodeCompletionContext::CCC_Other;
4193 switch ((DeclSpec::TST)TagSpec) {
4194 case DeclSpec::TST_enum:
4195 Filter = &ResultBuilder::IsEnum;
4196 ContextKind = CodeCompletionContext::CCC_EnumTag;
4197 break;
4198
4199 case DeclSpec::TST_union:
4200 Filter = &ResultBuilder::IsUnion;
4201 ContextKind = CodeCompletionContext::CCC_UnionTag;
4202 break;
4203
4204 case DeclSpec::TST_struct:
4205 case DeclSpec::TST_class:
4206 case DeclSpec::TST_interface:
4207 Filter = &ResultBuilder::IsClassOrStruct;
4208 ContextKind = CodeCompletionContext::CCC_ClassOrStructTag;
4209 break;
4210
4211 default:
4212 llvm_unreachable("Unknown type specifier kind in CodeCompleteTag");
4213 }
4214
4215 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4216 CodeCompleter->getCodeCompletionTUInfo(), ContextKind);
4217 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4218
4219 // First pass: look for tags.
4220 Results.setFilter(Filter);
4221 LookupVisibleDecls(S, LookupTagName, Consumer,
4222 CodeCompleter->includeGlobals(),
4223 CodeCompleter->loadExternal());
4224
4225 if (CodeCompleter->includeGlobals()) {
4226 // Second pass: look for nested name specifiers.
4227 Results.setFilter(&ResultBuilder::IsNestedNameSpecifier);
4228 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
4229 CodeCompleter->includeGlobals(),
4230 CodeCompleter->loadExternal());
4231 }
4232
4233 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4234 Results.data(),Results.size());
4235 }
4236
AddTypeQualifierResults(DeclSpec & DS,ResultBuilder & Results,const LangOptions & LangOpts)4237 static void AddTypeQualifierResults(DeclSpec &DS, ResultBuilder &Results,
4238 const LangOptions &LangOpts) {
4239 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
4240 Results.AddResult("const");
4241 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile))
4242 Results.AddResult("volatile");
4243 if (LangOpts.C99 && !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict))
4244 Results.AddResult("restrict");
4245 if (LangOpts.C11 && !(DS.getTypeQualifiers() & DeclSpec::TQ_atomic))
4246 Results.AddResult("_Atomic");
4247 if (LangOpts.MSVCCompat && !(DS.getTypeQualifiers() & DeclSpec::TQ_unaligned))
4248 Results.AddResult("__unaligned");
4249 }
4250
CodeCompleteTypeQualifiers(DeclSpec & DS)4251 void Sema::CodeCompleteTypeQualifiers(DeclSpec &DS) {
4252 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4253 CodeCompleter->getCodeCompletionTUInfo(),
4254 CodeCompletionContext::CCC_TypeQualifiers);
4255 Results.EnterNewScope();
4256 AddTypeQualifierResults(DS, Results, LangOpts);
4257 Results.ExitScope();
4258 HandleCodeCompleteResults(this, CodeCompleter,
4259 Results.getCompletionContext(),
4260 Results.data(), Results.size());
4261 }
4262
CodeCompleteFunctionQualifiers(DeclSpec & DS,Declarator & D,const VirtSpecifiers * VS)4263 void Sema::CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D,
4264 const VirtSpecifiers *VS) {
4265 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4266 CodeCompleter->getCodeCompletionTUInfo(),
4267 CodeCompletionContext::CCC_TypeQualifiers);
4268 Results.EnterNewScope();
4269 AddTypeQualifierResults(DS, Results, LangOpts);
4270 if (LangOpts.CPlusPlus11) {
4271 Results.AddResult("noexcept");
4272 if (D.getContext() == DeclaratorContext::MemberContext &&
4273 !D.isCtorOrDtor() && !D.isStaticMember()) {
4274 if (!VS || !VS->isFinalSpecified())
4275 Results.AddResult("final");
4276 if (!VS || !VS->isOverrideSpecified())
4277 Results.AddResult("override");
4278 }
4279 }
4280 Results.ExitScope();
4281 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4282 Results.data(), Results.size());
4283 }
4284
CodeCompleteBracketDeclarator(Scope * S)4285 void Sema::CodeCompleteBracketDeclarator(Scope *S) {
4286 CodeCompleteExpression(S, QualType(getASTContext().getSizeType()));
4287 }
4288
CodeCompleteCase(Scope * S)4289 void Sema::CodeCompleteCase(Scope *S) {
4290 if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
4291 return;
4292
4293 SwitchStmt *Switch = getCurFunction()->SwitchStack.back().getPointer();
4294 QualType type = Switch->getCond()->IgnoreImplicit()->getType();
4295 if (!type->isEnumeralType()) {
4296 CodeCompleteExpressionData Data(type);
4297 Data.IntegralConstantExpression = true;
4298 CodeCompleteExpression(S, Data);
4299 return;
4300 }
4301
4302 // Code-complete the cases of a switch statement over an enumeration type
4303 // by providing the list of
4304 EnumDecl *Enum = type->castAs<EnumType>()->getDecl();
4305 if (EnumDecl *Def = Enum->getDefinition())
4306 Enum = Def;
4307
4308 // Determine which enumerators we have already seen in the switch statement.
4309 // FIXME: Ideally, we would also be able to look *past* the code-completion
4310 // token, in case we are code-completing in the middle of the switch and not
4311 // at the end. However, we aren't able to do so at the moment.
4312 llvm::SmallPtrSet<EnumConstantDecl *, 8> EnumeratorsSeen;
4313 NestedNameSpecifier *Qualifier = nullptr;
4314 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC;
4315 SC = SC->getNextSwitchCase()) {
4316 CaseStmt *Case = dyn_cast<CaseStmt>(SC);
4317 if (!Case)
4318 continue;
4319
4320 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
4321 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CaseVal))
4322 if (EnumConstantDecl *Enumerator
4323 = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
4324 // We look into the AST of the case statement to determine which
4325 // enumerator was named. Alternatively, we could compute the value of
4326 // the integral constant expression, then compare it against the
4327 // values of each enumerator. However, value-based approach would not
4328 // work as well with C++ templates where enumerators declared within a
4329 // template are type- and value-dependent.
4330 EnumeratorsSeen.insert(Enumerator);
4331
4332 // If this is a qualified-id, keep track of the nested-name-specifier
4333 // so that we can reproduce it as part of code completion, e.g.,
4334 //
4335 // switch (TagD.getKind()) {
4336 // case TagDecl::TK_enum:
4337 // break;
4338 // case XXX
4339 //
4340 // At the XXX, our completions are TagDecl::TK_union,
4341 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union,
4342 // TK_struct, and TK_class.
4343 Qualifier = DRE->getQualifier();
4344 }
4345 }
4346
4347 if (getLangOpts().CPlusPlus && !Qualifier && EnumeratorsSeen.empty()) {
4348 // If there are no prior enumerators in C++, check whether we have to
4349 // qualify the names of the enumerators that we suggest, because they
4350 // may not be visible in this scope.
4351 Qualifier = getRequiredQualification(Context, CurContext, Enum);
4352 }
4353
4354 // Add any enumerators that have not yet been mentioned.
4355 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4356 CodeCompleter->getCodeCompletionTUInfo(),
4357 CodeCompletionContext::CCC_Expression);
4358 Results.EnterNewScope();
4359 for (auto *E : Enum->enumerators()) {
4360 if (EnumeratorsSeen.count(E))
4361 continue;
4362
4363 CodeCompletionResult R(E, CCP_EnumInCase, Qualifier);
4364 Results.AddResult(R, CurContext, nullptr, false);
4365 }
4366 Results.ExitScope();
4367
4368 if (CodeCompleter->includeMacros()) {
4369 AddMacroResults(PP, Results, false);
4370 }
4371 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4372 Results.data(), Results.size());
4373 }
4374
anyNullArguments(ArrayRef<Expr * > Args)4375 static bool anyNullArguments(ArrayRef<Expr *> Args) {
4376 if (Args.size() && !Args.data())
4377 return true;
4378
4379 for (unsigned I = 0; I != Args.size(); ++I)
4380 if (!Args[I])
4381 return true;
4382
4383 return false;
4384 }
4385
4386 typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate;
4387
mergeCandidatesWithResults(Sema & SemaRef,SmallVectorImpl<ResultCandidate> & Results,OverloadCandidateSet & CandidateSet,SourceLocation Loc)4388 static void mergeCandidatesWithResults(Sema &SemaRef,
4389 SmallVectorImpl<ResultCandidate> &Results,
4390 OverloadCandidateSet &CandidateSet,
4391 SourceLocation Loc) {
4392 if (!CandidateSet.empty()) {
4393 // Sort the overload candidate set by placing the best overloads first.
4394 std::stable_sort(
4395 CandidateSet.begin(), CandidateSet.end(),
4396 [&](const OverloadCandidate &X, const OverloadCandidate &Y) {
4397 return isBetterOverloadCandidate(SemaRef, X, Y, Loc,
4398 CandidateSet.getKind());
4399 });
4400
4401 // Add the remaining viable overload candidates as code-completion results.
4402 for (auto &Candidate : CandidateSet) {
4403 if (Candidate.Function && Candidate.Function->isDeleted())
4404 continue;
4405 if (Candidate.Viable)
4406 Results.push_back(ResultCandidate(Candidate.Function));
4407 }
4408 }
4409 }
4410
4411 /// Get the type of the Nth parameter from a given set of overload
4412 /// candidates.
getParamType(Sema & SemaRef,ArrayRef<ResultCandidate> Candidates,unsigned N)4413 static QualType getParamType(Sema &SemaRef,
4414 ArrayRef<ResultCandidate> Candidates,
4415 unsigned N) {
4416
4417 // Given the overloads 'Candidates' for a function call matching all arguments
4418 // up to N, return the type of the Nth parameter if it is the same for all
4419 // overload candidates.
4420 QualType ParamType;
4421 for (auto &Candidate : Candidates) {
4422 if (auto FType = Candidate.getFunctionType())
4423 if (auto Proto = dyn_cast<FunctionProtoType>(FType))
4424 if (N < Proto->getNumParams()) {
4425 if (ParamType.isNull())
4426 ParamType = Proto->getParamType(N);
4427 else if (!SemaRef.Context.hasSameUnqualifiedType(
4428 ParamType.getNonReferenceType(),
4429 Proto->getParamType(N).getNonReferenceType()))
4430 // Otherwise return a default-constructed QualType.
4431 return QualType();
4432 }
4433 }
4434
4435 return ParamType;
4436 }
4437
CodeCompleteOverloadResults(Sema & SemaRef,Scope * S,MutableArrayRef<ResultCandidate> Candidates,unsigned CurrentArg,bool CompleteExpressionWithCurrentArg=true)4438 static void CodeCompleteOverloadResults(Sema &SemaRef, Scope *S,
4439 MutableArrayRef<ResultCandidate> Candidates,
4440 unsigned CurrentArg,
4441 bool CompleteExpressionWithCurrentArg = true) {
4442 QualType ParamType;
4443 if (CompleteExpressionWithCurrentArg)
4444 ParamType = getParamType(SemaRef, Candidates, CurrentArg);
4445
4446 if (ParamType.isNull())
4447 SemaRef.CodeCompleteOrdinaryName(S, Sema::PCC_Expression);
4448 else
4449 SemaRef.CodeCompleteExpression(S, ParamType);
4450
4451 if (!Candidates.empty())
4452 SemaRef.CodeCompleter->ProcessOverloadCandidates(SemaRef, CurrentArg,
4453 Candidates.data(),
4454 Candidates.size());
4455 }
4456
CodeCompleteCall(Scope * S,Expr * Fn,ArrayRef<Expr * > Args)4457 void Sema::CodeCompleteCall(Scope *S, Expr *Fn, ArrayRef<Expr *> Args) {
4458 if (!CodeCompleter)
4459 return;
4460
4461 // When we're code-completing for a call, we fall back to ordinary
4462 // name code-completion whenever we can't produce specific
4463 // results. We may want to revisit this strategy in the future,
4464 // e.g., by merging the two kinds of results.
4465
4466 // FIXME: Provide support for variadic template functions.
4467
4468 // Ignore type-dependent call expressions entirely.
4469 if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args) ||
4470 Expr::hasAnyTypeDependentArguments(Args)) {
4471 CodeCompleteOrdinaryName(S, PCC_Expression);
4472 return;
4473 }
4474
4475 // Build an overload candidate set based on the functions we find.
4476 SourceLocation Loc = Fn->getExprLoc();
4477 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
4478
4479 SmallVector<ResultCandidate, 8> Results;
4480
4481 Expr *NakedFn = Fn->IgnoreParenCasts();
4482 if (auto ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn))
4483 AddOverloadedCallCandidates(ULE, Args, CandidateSet,
4484 /*PartialOverloading=*/true);
4485 else if (auto UME = dyn_cast<UnresolvedMemberExpr>(NakedFn)) {
4486 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
4487 if (UME->hasExplicitTemplateArgs()) {
4488 UME->copyTemplateArgumentsInto(TemplateArgsBuffer);
4489 TemplateArgs = &TemplateArgsBuffer;
4490 }
4491
4492 // Add the base as first argument (use a nullptr if the base is implicit).
4493 SmallVector<Expr *, 12> ArgExprs(
4494 1, UME->isImplicitAccess() ? nullptr : UME->getBase());
4495 ArgExprs.append(Args.begin(), Args.end());
4496 UnresolvedSet<8> Decls;
4497 Decls.append(UME->decls_begin(), UME->decls_end());
4498 const bool FirstArgumentIsBase = !UME->isImplicitAccess() && UME->getBase();
4499 AddFunctionCandidates(Decls, ArgExprs, CandidateSet, TemplateArgs,
4500 /*SuppressUsedConversions=*/false,
4501 /*PartialOverloading=*/true,
4502 FirstArgumentIsBase);
4503 } else {
4504 FunctionDecl *FD = nullptr;
4505 if (auto MCE = dyn_cast<MemberExpr>(NakedFn))
4506 FD = dyn_cast<FunctionDecl>(MCE->getMemberDecl());
4507 else if (auto DRE = dyn_cast<DeclRefExpr>(NakedFn))
4508 FD = dyn_cast<FunctionDecl>(DRE->getDecl());
4509 if (FD) { // We check whether it's a resolved function declaration.
4510 if (!getLangOpts().CPlusPlus ||
4511 !FD->getType()->getAs<FunctionProtoType>())
4512 Results.push_back(ResultCandidate(FD));
4513 else
4514 AddOverloadCandidate(FD, DeclAccessPair::make(FD, FD->getAccess()),
4515 Args, CandidateSet,
4516 /*SuppressUsedConversions=*/false,
4517 /*PartialOverloading=*/true);
4518
4519 } else if (auto DC = NakedFn->getType()->getAsCXXRecordDecl()) {
4520 // If expression's type is CXXRecordDecl, it may overload the function
4521 // call operator, so we check if it does and add them as candidates.
4522 // A complete type is needed to lookup for member function call operators.
4523 if (isCompleteType(Loc, NakedFn->getType())) {
4524 DeclarationName OpName = Context.DeclarationNames
4525 .getCXXOperatorName(OO_Call);
4526 LookupResult R(*this, OpName, Loc, LookupOrdinaryName);
4527 LookupQualifiedName(R, DC);
4528 R.suppressDiagnostics();
4529 SmallVector<Expr *, 12> ArgExprs(1, NakedFn);
4530 ArgExprs.append(Args.begin(), Args.end());
4531 AddFunctionCandidates(R.asUnresolvedSet(), ArgExprs, CandidateSet,
4532 /*ExplicitArgs=*/nullptr,
4533 /*SuppressUsedConversions=*/false,
4534 /*PartialOverloading=*/true);
4535 }
4536 } else {
4537 // Lastly we check whether expression's type is function pointer or
4538 // function.
4539 QualType T = NakedFn->getType();
4540 if (!T->getPointeeType().isNull())
4541 T = T->getPointeeType();
4542
4543 if (auto FP = T->getAs<FunctionProtoType>()) {
4544 if (!TooManyArguments(FP->getNumParams(), Args.size(),
4545 /*PartialOverloading=*/true) ||
4546 FP->isVariadic())
4547 Results.push_back(ResultCandidate(FP));
4548 } else if (auto FT = T->getAs<FunctionType>())
4549 // No prototype and declaration, it may be a K & R style function.
4550 Results.push_back(ResultCandidate(FT));
4551 }
4552 }
4553
4554 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4555 CodeCompleteOverloadResults(*this, S, Results, Args.size(),
4556 !CandidateSet.empty());
4557 }
4558
CodeCompleteConstructor(Scope * S,QualType Type,SourceLocation Loc,ArrayRef<Expr * > Args)4559 void Sema::CodeCompleteConstructor(Scope *S, QualType Type, SourceLocation Loc,
4560 ArrayRef<Expr *> Args) {
4561 if (!CodeCompleter)
4562 return;
4563
4564 // A complete type is needed to lookup for constructors.
4565 CXXRecordDecl *RD =
4566 isCompleteType(Loc, Type) ? Type->getAsCXXRecordDecl() : nullptr;
4567 if (!RD) {
4568 CodeCompleteExpression(S, Type);
4569 return;
4570 }
4571
4572 // FIXME: Provide support for member initializers.
4573 // FIXME: Provide support for variadic template constructors.
4574
4575 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
4576
4577 for (auto C : LookupConstructors(RD)) {
4578 if (auto FD = dyn_cast<FunctionDecl>(C)) {
4579 AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()),
4580 Args, CandidateSet,
4581 /*SuppressUsedConversions=*/false,
4582 /*PartialOverloading=*/true);
4583 } else if (auto FTD = dyn_cast<FunctionTemplateDecl>(C)) {
4584 AddTemplateOverloadCandidate(FTD,
4585 DeclAccessPair::make(FTD, C->getAccess()),
4586 /*ExplicitTemplateArgs=*/nullptr,
4587 Args, CandidateSet,
4588 /*SuppressUsedConversions=*/false,
4589 /*PartialOverloading=*/true);
4590 }
4591 }
4592
4593 SmallVector<ResultCandidate, 8> Results;
4594 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4595 CodeCompleteOverloadResults(*this, S, Results, Args.size());
4596 }
4597
CodeCompleteInitializer(Scope * S,Decl * D)4598 void Sema::CodeCompleteInitializer(Scope *S, Decl *D) {
4599 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D);
4600 if (!VD) {
4601 CodeCompleteOrdinaryName(S, PCC_Expression);
4602 return;
4603 }
4604
4605 CodeCompleteExpression(S, VD->getType());
4606 }
4607
CodeCompleteReturn(Scope * S)4608 void Sema::CodeCompleteReturn(Scope *S) {
4609 QualType ResultType;
4610 if (isa<BlockDecl>(CurContext)) {
4611 if (BlockScopeInfo *BSI = getCurBlock())
4612 ResultType = BSI->ReturnType;
4613 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(CurContext))
4614 ResultType = Function->getReturnType();
4615 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(CurContext))
4616 ResultType = Method->getReturnType();
4617
4618 if (ResultType.isNull())
4619 CodeCompleteOrdinaryName(S, PCC_Expression);
4620 else
4621 CodeCompleteExpression(S, ResultType);
4622 }
4623
CodeCompleteAfterIf(Scope * S)4624 void Sema::CodeCompleteAfterIf(Scope *S) {
4625 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4626 CodeCompleter->getCodeCompletionTUInfo(),
4627 mapCodeCompletionContext(*this, PCC_Statement));
4628 Results.setFilter(&ResultBuilder::IsOrdinaryName);
4629 Results.EnterNewScope();
4630
4631 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4632 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4633 CodeCompleter->includeGlobals(),
4634 CodeCompleter->loadExternal());
4635
4636 AddOrdinaryNameResults(PCC_Statement, S, *this, Results);
4637
4638 // "else" block
4639 CodeCompletionBuilder Builder(Results.getAllocator(),
4640 Results.getCodeCompletionTUInfo());
4641 Builder.AddTypedTextChunk("else");
4642 if (Results.includeCodePatterns()) {
4643 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4644 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4645 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4646 Builder.AddPlaceholderChunk("statements");
4647 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4648 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4649 }
4650 Results.AddResult(Builder.TakeString());
4651
4652 // "else if" block
4653 Builder.AddTypedTextChunk("else");
4654 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4655 Builder.AddTextChunk("if");
4656 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4657 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4658 if (getLangOpts().CPlusPlus)
4659 Builder.AddPlaceholderChunk("condition");
4660 else
4661 Builder.AddPlaceholderChunk("expression");
4662 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4663 if (Results.includeCodePatterns()) {
4664 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4665 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4666 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4667 Builder.AddPlaceholderChunk("statements");
4668 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4669 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4670 }
4671 Results.AddResult(Builder.TakeString());
4672
4673 Results.ExitScope();
4674
4675 if (S->getFnParent())
4676 AddPrettyFunctionResults(getLangOpts(), Results);
4677
4678 if (CodeCompleter->includeMacros())
4679 AddMacroResults(PP, Results, false);
4680
4681 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4682 Results.data(),Results.size());
4683 }
4684
CodeCompleteAssignmentRHS(Scope * S,Expr * LHS)4685 void Sema::CodeCompleteAssignmentRHS(Scope *S, Expr *LHS) {
4686 if (LHS)
4687 CodeCompleteExpression(S, static_cast<Expr *>(LHS)->getType());
4688 else
4689 CodeCompleteOrdinaryName(S, PCC_Expression);
4690 }
4691
CodeCompleteQualifiedId(Scope * S,CXXScopeSpec & SS,bool EnteringContext)4692 void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
4693 bool EnteringContext) {
4694 if (SS.isEmpty() || !CodeCompleter)
4695 return;
4696
4697 // We want to keep the scope specifier even if it's invalid (e.g. the scope
4698 // "a::b::" is not corresponding to any context/namespace in the AST), since
4699 // it can be useful for global code completion which have information about
4700 // contexts/symbols that are not in the AST.
4701 if (SS.isInvalid()) {
4702 CodeCompletionContext CC(CodeCompletionContext::CCC_Name);
4703 CC.setCXXScopeSpecifier(SS);
4704 HandleCodeCompleteResults(this, CodeCompleter, CC, nullptr, 0);
4705 return;
4706 }
4707 // Always pretend to enter a context to ensure that a dependent type
4708 // resolves to a dependent record.
4709 DeclContext *Ctx = computeDeclContext(SS, /*EnteringContext=*/true);
4710 if (!Ctx)
4711 return;
4712
4713 // Try to instantiate any non-dependent declaration contexts before
4714 // we look in them.
4715 if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx))
4716 return;
4717
4718 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4719 CodeCompleter->getCodeCompletionTUInfo(),
4720 CodeCompletionContext::CCC_Name);
4721 Results.EnterNewScope();
4722
4723 // The "template" keyword can follow "::" in the grammar, but only
4724 // put it into the grammar if the nested-name-specifier is dependent.
4725 NestedNameSpecifier *NNS = SS.getScopeRep();
4726 if (!Results.empty() && NNS->isDependent())
4727 Results.AddResult("template");
4728
4729 // Add calls to overridden virtual functions, if there are any.
4730 //
4731 // FIXME: This isn't wonderful, because we don't know whether we're actually
4732 // in a context that permits expressions. This is a general issue with
4733 // qualified-id completions.
4734 if (!EnteringContext)
4735 MaybeAddOverrideCalls(*this, Ctx, Results);
4736 Results.ExitScope();
4737
4738 if (CodeCompleter->includeNamespaceLevelDecls() ||
4739 (!Ctx->isNamespace() && !Ctx->isTranslationUnit())) {
4740 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4741 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer,
4742 /*IncludeGlobalScope=*/true,
4743 /*IncludeDependentBases=*/true,
4744 CodeCompleter->loadExternal());
4745 }
4746
4747 auto CC = Results.getCompletionContext();
4748 CC.setCXXScopeSpecifier(SS);
4749
4750 HandleCodeCompleteResults(this, CodeCompleter, CC, Results.data(),
4751 Results.size());
4752 }
4753
CodeCompleteUsing(Scope * S)4754 void Sema::CodeCompleteUsing(Scope *S) {
4755 if (!CodeCompleter)
4756 return;
4757
4758 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4759 CodeCompleter->getCodeCompletionTUInfo(),
4760 CodeCompletionContext::CCC_PotentiallyQualifiedName,
4761 &ResultBuilder::IsNestedNameSpecifier);
4762 Results.EnterNewScope();
4763
4764 // If we aren't in class scope, we could see the "namespace" keyword.
4765 if (!S->isClassScope())
4766 Results.AddResult(CodeCompletionResult("namespace"));
4767
4768 // After "using", we can see anything that would start a
4769 // nested-name-specifier.
4770 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4771 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4772 CodeCompleter->includeGlobals(),
4773 CodeCompleter->loadExternal());
4774 Results.ExitScope();
4775
4776 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4777 Results.data(), Results.size());
4778 }
4779
CodeCompleteUsingDirective(Scope * S)4780 void Sema::CodeCompleteUsingDirective(Scope *S) {
4781 if (!CodeCompleter)
4782 return;
4783
4784 // After "using namespace", we expect to see a namespace name or namespace
4785 // alias.
4786 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4787 CodeCompleter->getCodeCompletionTUInfo(),
4788 CodeCompletionContext::CCC_Namespace,
4789 &ResultBuilder::IsNamespaceOrAlias);
4790 Results.EnterNewScope();
4791 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4792 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4793 CodeCompleter->includeGlobals(),
4794 CodeCompleter->loadExternal());
4795 Results.ExitScope();
4796 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4797 Results.data(), Results.size());
4798 }
4799
CodeCompleteNamespaceDecl(Scope * S)4800 void Sema::CodeCompleteNamespaceDecl(Scope *S) {
4801 if (!CodeCompleter)
4802 return;
4803
4804 DeclContext *Ctx = S->getEntity();
4805 if (!S->getParent())
4806 Ctx = Context.getTranslationUnitDecl();
4807
4808 bool SuppressedGlobalResults
4809 = Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx);
4810
4811 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4812 CodeCompleter->getCodeCompletionTUInfo(),
4813 SuppressedGlobalResults
4814 ? CodeCompletionContext::CCC_Namespace
4815 : CodeCompletionContext::CCC_Other,
4816 &ResultBuilder::IsNamespace);
4817
4818 if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) {
4819 // We only want to see those namespaces that have already been defined
4820 // within this scope, because its likely that the user is creating an
4821 // extended namespace declaration. Keep track of the most recent
4822 // definition of each namespace.
4823 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest;
4824 for (DeclContext::specific_decl_iterator<NamespaceDecl>
4825 NS(Ctx->decls_begin()), NSEnd(Ctx->decls_end());
4826 NS != NSEnd; ++NS)
4827 OrigToLatest[NS->getOriginalNamespace()] = *NS;
4828
4829 // Add the most recent definition (or extended definition) of each
4830 // namespace to the list of results.
4831 Results.EnterNewScope();
4832 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator
4833 NS = OrigToLatest.begin(),
4834 NSEnd = OrigToLatest.end();
4835 NS != NSEnd; ++NS)
4836 Results.AddResult(CodeCompletionResult(
4837 NS->second, Results.getBasePriority(NS->second),
4838 nullptr),
4839 CurContext, nullptr, false);
4840 Results.ExitScope();
4841 }
4842
4843 HandleCodeCompleteResults(this, CodeCompleter,
4844 Results.getCompletionContext(),
4845 Results.data(),Results.size());
4846 }
4847
CodeCompleteNamespaceAliasDecl(Scope * S)4848 void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) {
4849 if (!CodeCompleter)
4850 return;
4851
4852 // After "namespace", we expect to see a namespace or alias.
4853 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4854 CodeCompleter->getCodeCompletionTUInfo(),
4855 CodeCompletionContext::CCC_Namespace,
4856 &ResultBuilder::IsNamespaceOrAlias);
4857 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4858 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4859 CodeCompleter->includeGlobals(),
4860 CodeCompleter->loadExternal());
4861 HandleCodeCompleteResults(this, CodeCompleter,
4862 Results.getCompletionContext(),
4863 Results.data(),Results.size());
4864 }
4865
CodeCompleteOperatorName(Scope * S)4866 void Sema::CodeCompleteOperatorName(Scope *S) {
4867 if (!CodeCompleter)
4868 return;
4869
4870 typedef CodeCompletionResult Result;
4871 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4872 CodeCompleter->getCodeCompletionTUInfo(),
4873 CodeCompletionContext::CCC_Type,
4874 &ResultBuilder::IsType);
4875 Results.EnterNewScope();
4876
4877 // Add the names of overloadable operators.
4878 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4879 if (std::strcmp(Spelling, "?")) \
4880 Results.AddResult(Result(Spelling));
4881 #include "clang/Basic/OperatorKinds.def"
4882
4883 // Add any type names visible from the current scope
4884 Results.allowNestedNameSpecifiers();
4885 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4886 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4887 CodeCompleter->includeGlobals(),
4888 CodeCompleter->loadExternal());
4889
4890 // Add any type specifiers
4891 AddTypeSpecifierResults(getLangOpts(), Results);
4892 Results.ExitScope();
4893
4894 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4895 Results.data(), Results.size());
4896 }
4897
CodeCompleteConstructorInitializer(Decl * ConstructorD,ArrayRef<CXXCtorInitializer * > Initializers)4898 void Sema::CodeCompleteConstructorInitializer(
4899 Decl *ConstructorD,
4900 ArrayRef <CXXCtorInitializer *> Initializers) {
4901 if (!ConstructorD)
4902 return;
4903
4904 AdjustDeclIfTemplate(ConstructorD);
4905
4906 CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ConstructorD);
4907 if (!Constructor)
4908 return;
4909
4910 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4911 CodeCompleter->getCodeCompletionTUInfo(),
4912 CodeCompletionContext::CCC_PotentiallyQualifiedName);
4913 Results.EnterNewScope();
4914
4915 // Fill in any already-initialized fields or base classes.
4916 llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
4917 llvm::SmallPtrSet<CanQualType, 4> InitializedBases;
4918 for (unsigned I = 0, E = Initializers.size(); I != E; ++I) {
4919 if (Initializers[I]->isBaseInitializer())
4920 InitializedBases.insert(
4921 Context.getCanonicalType(QualType(Initializers[I]->getBaseClass(), 0)));
4922 else
4923 InitializedFields.insert(cast<FieldDecl>(
4924 Initializers[I]->getAnyMember()));
4925 }
4926
4927 // Add completions for base classes.
4928 CodeCompletionBuilder Builder(Results.getAllocator(),
4929 Results.getCodeCompletionTUInfo());
4930 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
4931 bool SawLastInitializer = Initializers.empty();
4932 CXXRecordDecl *ClassDecl = Constructor->getParent();
4933 for (const auto &Base : ClassDecl->bases()) {
4934 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4935 .second) {
4936 SawLastInitializer
4937 = !Initializers.empty() &&
4938 Initializers.back()->isBaseInitializer() &&
4939 Context.hasSameUnqualifiedType(Base.getType(),
4940 QualType(Initializers.back()->getBaseClass(), 0));
4941 continue;
4942 }
4943
4944 Builder.AddTypedTextChunk(
4945 Results.getAllocator().CopyString(
4946 Base.getType().getAsString(Policy)));
4947 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4948 Builder.AddPlaceholderChunk("args");
4949 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4950 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4951 SawLastInitializer? CCP_NextInitializer
4952 : CCP_MemberDeclaration));
4953 SawLastInitializer = false;
4954 }
4955
4956 // Add completions for virtual base classes.
4957 for (const auto &Base : ClassDecl->vbases()) {
4958 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4959 .second) {
4960 SawLastInitializer
4961 = !Initializers.empty() &&
4962 Initializers.back()->isBaseInitializer() &&
4963 Context.hasSameUnqualifiedType(Base.getType(),
4964 QualType(Initializers.back()->getBaseClass(), 0));
4965 continue;
4966 }
4967
4968 Builder.AddTypedTextChunk(
4969 Builder.getAllocator().CopyString(
4970 Base.getType().getAsString(Policy)));
4971 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4972 Builder.AddPlaceholderChunk("args");
4973 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4974 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4975 SawLastInitializer? CCP_NextInitializer
4976 : CCP_MemberDeclaration));
4977 SawLastInitializer = false;
4978 }
4979
4980 // Add completions for members.
4981 for (auto *Field : ClassDecl->fields()) {
4982 if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))
4983 .second) {
4984 SawLastInitializer
4985 = !Initializers.empty() &&
4986 Initializers.back()->isAnyMemberInitializer() &&
4987 Initializers.back()->getAnyMember() == Field;
4988 continue;
4989 }
4990
4991 if (!Field->getDeclName())
4992 continue;
4993
4994 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
4995 Field->getIdentifier()->getName()));
4996 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4997 Builder.AddPlaceholderChunk("args");
4998 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4999 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
5000 SawLastInitializer? CCP_NextInitializer
5001 : CCP_MemberDeclaration,
5002 CXCursor_MemberRef,
5003 CXAvailability_Available,
5004 Field));
5005 SawLastInitializer = false;
5006 }
5007 Results.ExitScope();
5008
5009 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5010 Results.data(), Results.size());
5011 }
5012
5013 /// Determine whether this scope denotes a namespace.
isNamespaceScope(Scope * S)5014 static bool isNamespaceScope(Scope *S) {
5015 DeclContext *DC = S->getEntity();
5016 if (!DC)
5017 return false;
5018
5019 return DC->isFileContext();
5020 }
5021
CodeCompleteLambdaIntroducer(Scope * S,LambdaIntroducer & Intro,bool AfterAmpersand)5022 void Sema::CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
5023 bool AfterAmpersand) {
5024 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5025 CodeCompleter->getCodeCompletionTUInfo(),
5026 CodeCompletionContext::CCC_Other);
5027 Results.EnterNewScope();
5028
5029 // Note what has already been captured.
5030 llvm::SmallPtrSet<IdentifierInfo *, 4> Known;
5031 bool IncludedThis = false;
5032 for (const auto &C : Intro.Captures) {
5033 if (C.Kind == LCK_This) {
5034 IncludedThis = true;
5035 continue;
5036 }
5037
5038 Known.insert(C.Id);
5039 }
5040
5041 // Look for other capturable variables.
5042 for (; S && !isNamespaceScope(S); S = S->getParent()) {
5043 for (const auto *D : S->decls()) {
5044 const auto *Var = dyn_cast<VarDecl>(D);
5045 if (!Var ||
5046 !Var->hasLocalStorage() ||
5047 Var->hasAttr<BlocksAttr>())
5048 continue;
5049
5050 if (Known.insert(Var->getIdentifier()).second)
5051 Results.AddResult(CodeCompletionResult(Var, CCP_LocalDeclaration),
5052 CurContext, nullptr, false);
5053 }
5054 }
5055
5056 // Add 'this', if it would be valid.
5057 if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy)
5058 addThisCompletion(*this, Results);
5059
5060 Results.ExitScope();
5061
5062 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5063 Results.data(), Results.size());
5064 }
5065
5066 /// Macro that optionally prepends an "@" to the string literal passed in via
5067 /// Keyword, depending on whether NeedAt is true or false.
5068 #define OBJC_AT_KEYWORD_NAME(NeedAt,Keyword) ((NeedAt)? "@" Keyword : Keyword)
5069
AddObjCImplementationResults(const LangOptions & LangOpts,ResultBuilder & Results,bool NeedAt)5070 static void AddObjCImplementationResults(const LangOptions &LangOpts,
5071 ResultBuilder &Results,
5072 bool NeedAt) {
5073 typedef CodeCompletionResult Result;
5074 // Since we have an implementation, we can end it.
5075 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
5076
5077 CodeCompletionBuilder Builder(Results.getAllocator(),
5078 Results.getCodeCompletionTUInfo());
5079 if (LangOpts.ObjC2) {
5080 // @dynamic
5081 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"dynamic"));
5082 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5083 Builder.AddPlaceholderChunk("property");
5084 Results.AddResult(Result(Builder.TakeString()));
5085
5086 // @synthesize
5087 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synthesize"));
5088 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5089 Builder.AddPlaceholderChunk("property");
5090 Results.AddResult(Result(Builder.TakeString()));
5091 }
5092 }
5093
AddObjCInterfaceResults(const LangOptions & LangOpts,ResultBuilder & Results,bool NeedAt)5094 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
5095 ResultBuilder &Results,
5096 bool NeedAt) {
5097 typedef CodeCompletionResult Result;
5098
5099 // Since we have an interface or protocol, we can end it.
5100 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
5101
5102 if (LangOpts.ObjC2) {
5103 // @property
5104 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"property")));
5105
5106 // @required
5107 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"required")));
5108
5109 // @optional
5110 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"optional")));
5111 }
5112 }
5113
AddObjCTopLevelResults(ResultBuilder & Results,bool NeedAt)5114 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
5115 typedef CodeCompletionResult Result;
5116 CodeCompletionBuilder Builder(Results.getAllocator(),
5117 Results.getCodeCompletionTUInfo());
5118
5119 // @class name ;
5120 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"class"));
5121 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5122 Builder.AddPlaceholderChunk("name");
5123 Results.AddResult(Result(Builder.TakeString()));
5124
5125 if (Results.includeCodePatterns()) {
5126 // @interface name
5127 // FIXME: Could introduce the whole pattern, including superclasses and
5128 // such.
5129 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"interface"));
5130 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5131 Builder.AddPlaceholderChunk("class");
5132 Results.AddResult(Result(Builder.TakeString()));
5133
5134 // @protocol name
5135 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
5136 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5137 Builder.AddPlaceholderChunk("protocol");
5138 Results.AddResult(Result(Builder.TakeString()));
5139
5140 // @implementation name
5141 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"implementation"));
5142 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5143 Builder.AddPlaceholderChunk("class");
5144 Results.AddResult(Result(Builder.TakeString()));
5145 }
5146
5147 // @compatibility_alias name
5148 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"compatibility_alias"));
5149 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5150 Builder.AddPlaceholderChunk("alias");
5151 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5152 Builder.AddPlaceholderChunk("class");
5153 Results.AddResult(Result(Builder.TakeString()));
5154
5155 if (Results.getSema().getLangOpts().Modules) {
5156 // @import name
5157 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import"));
5158 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5159 Builder.AddPlaceholderChunk("module");
5160 Results.AddResult(Result(Builder.TakeString()));
5161 }
5162 }
5163
CodeCompleteObjCAtDirective(Scope * S)5164 void Sema::CodeCompleteObjCAtDirective(Scope *S) {
5165 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5166 CodeCompleter->getCodeCompletionTUInfo(),
5167 CodeCompletionContext::CCC_Other);
5168 Results.EnterNewScope();
5169 if (isa<ObjCImplDecl>(CurContext))
5170 AddObjCImplementationResults(getLangOpts(), Results, false);
5171 else if (CurContext->isObjCContainer())
5172 AddObjCInterfaceResults(getLangOpts(), Results, false);
5173 else
5174 AddObjCTopLevelResults(Results, false);
5175 Results.ExitScope();
5176 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5177 Results.data(), Results.size());
5178 }
5179
AddObjCExpressionResults(ResultBuilder & Results,bool NeedAt)5180 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) {
5181 typedef CodeCompletionResult Result;
5182 CodeCompletionBuilder Builder(Results.getAllocator(),
5183 Results.getCodeCompletionTUInfo());
5184
5185 // @encode ( type-name )
5186 const char *EncodeType = "char[]";
5187 if (Results.getSema().getLangOpts().CPlusPlus ||
5188 Results.getSema().getLangOpts().ConstStrings)
5189 EncodeType = "const char[]";
5190 Builder.AddResultTypeChunk(EncodeType);
5191 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"encode"));
5192 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5193 Builder.AddPlaceholderChunk("type-name");
5194 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5195 Results.AddResult(Result(Builder.TakeString()));
5196
5197 // @protocol ( protocol-name )
5198 Builder.AddResultTypeChunk("Protocol *");
5199 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
5200 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5201 Builder.AddPlaceholderChunk("protocol-name");
5202 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5203 Results.AddResult(Result(Builder.TakeString()));
5204
5205 // @selector ( selector )
5206 Builder.AddResultTypeChunk("SEL");
5207 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"selector"));
5208 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5209 Builder.AddPlaceholderChunk("selector");
5210 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5211 Results.AddResult(Result(Builder.TakeString()));
5212
5213 // @"string"
5214 Builder.AddResultTypeChunk("NSString *");
5215 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"\""));
5216 Builder.AddPlaceholderChunk("string");
5217 Builder.AddTextChunk("\"");
5218 Results.AddResult(Result(Builder.TakeString()));
5219
5220 // @[objects, ...]
5221 Builder.AddResultTypeChunk("NSArray *");
5222 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"["));
5223 Builder.AddPlaceholderChunk("objects, ...");
5224 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
5225 Results.AddResult(Result(Builder.TakeString()));
5226
5227 // @{key : object, ...}
5228 Builder.AddResultTypeChunk("NSDictionary *");
5229 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"{"));
5230 Builder.AddPlaceholderChunk("key");
5231 Builder.AddChunk(CodeCompletionString::CK_Colon);
5232 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5233 Builder.AddPlaceholderChunk("object, ...");
5234 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5235 Results.AddResult(Result(Builder.TakeString()));
5236
5237 // @(expression)
5238 Builder.AddResultTypeChunk("id");
5239 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "("));
5240 Builder.AddPlaceholderChunk("expression");
5241 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5242 Results.AddResult(Result(Builder.TakeString()));
5243 }
5244
AddObjCStatementResults(ResultBuilder & Results,bool NeedAt)5245 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) {
5246 typedef CodeCompletionResult Result;
5247 CodeCompletionBuilder Builder(Results.getAllocator(),
5248 Results.getCodeCompletionTUInfo());
5249
5250 if (Results.includeCodePatterns()) {
5251 // @try { statements } @catch ( declaration ) { statements } @finally
5252 // { statements }
5253 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"try"));
5254 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5255 Builder.AddPlaceholderChunk("statements");
5256 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5257 Builder.AddTextChunk("@catch");
5258 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5259 Builder.AddPlaceholderChunk("parameter");
5260 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5261 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5262 Builder.AddPlaceholderChunk("statements");
5263 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5264 Builder.AddTextChunk("@finally");
5265 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5266 Builder.AddPlaceholderChunk("statements");
5267 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5268 Results.AddResult(Result(Builder.TakeString()));
5269 }
5270
5271 // @throw
5272 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"throw"));
5273 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5274 Builder.AddPlaceholderChunk("expression");
5275 Results.AddResult(Result(Builder.TakeString()));
5276
5277 if (Results.includeCodePatterns()) {
5278 // @synchronized ( expression ) { statements }
5279 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synchronized"));
5280 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5281 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5282 Builder.AddPlaceholderChunk("expression");
5283 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5284 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5285 Builder.AddPlaceholderChunk("statements");
5286 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5287 Results.AddResult(Result(Builder.TakeString()));
5288 }
5289 }
5290
AddObjCVisibilityResults(const LangOptions & LangOpts,ResultBuilder & Results,bool NeedAt)5291 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
5292 ResultBuilder &Results,
5293 bool NeedAt) {
5294 typedef CodeCompletionResult Result;
5295 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"private")));
5296 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"protected")));
5297 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"public")));
5298 if (LangOpts.ObjC2)
5299 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"package")));
5300 }
5301
CodeCompleteObjCAtVisibility(Scope * S)5302 void Sema::CodeCompleteObjCAtVisibility(Scope *S) {
5303 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5304 CodeCompleter->getCodeCompletionTUInfo(),
5305 CodeCompletionContext::CCC_Other);
5306 Results.EnterNewScope();
5307 AddObjCVisibilityResults(getLangOpts(), Results, false);
5308 Results.ExitScope();
5309 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5310 Results.data(), Results.size());
5311 }
5312
CodeCompleteObjCAtStatement(Scope * S)5313 void Sema::CodeCompleteObjCAtStatement(Scope *S) {
5314 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5315 CodeCompleter->getCodeCompletionTUInfo(),
5316 CodeCompletionContext::CCC_Other);
5317 Results.EnterNewScope();
5318 AddObjCStatementResults(Results, false);
5319 AddObjCExpressionResults(Results, false);
5320 Results.ExitScope();
5321 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5322 Results.data(), Results.size());
5323 }
5324
CodeCompleteObjCAtExpression(Scope * S)5325 void Sema::CodeCompleteObjCAtExpression(Scope *S) {
5326 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5327 CodeCompleter->getCodeCompletionTUInfo(),
5328 CodeCompletionContext::CCC_Other);
5329 Results.EnterNewScope();
5330 AddObjCExpressionResults(Results, false);
5331 Results.ExitScope();
5332 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5333 Results.data(), Results.size());
5334 }
5335
5336 /// Determine whether the addition of the given flag to an Objective-C
5337 /// property's attributes will cause a conflict.
ObjCPropertyFlagConflicts(unsigned Attributes,unsigned NewFlag)5338 static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) {
5339 // Check if we've already added this flag.
5340 if (Attributes & NewFlag)
5341 return true;
5342
5343 Attributes |= NewFlag;
5344
5345 // Check for collisions with "readonly".
5346 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
5347 (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
5348 return true;
5349
5350 // Check for more than one of { assign, copy, retain, strong, weak }.
5351 unsigned AssignCopyRetMask = Attributes & (ObjCDeclSpec::DQ_PR_assign |
5352 ObjCDeclSpec::DQ_PR_unsafe_unretained |
5353 ObjCDeclSpec::DQ_PR_copy |
5354 ObjCDeclSpec::DQ_PR_retain |
5355 ObjCDeclSpec::DQ_PR_strong |
5356 ObjCDeclSpec::DQ_PR_weak);
5357 if (AssignCopyRetMask &&
5358 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign &&
5359 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_unsafe_unretained &&
5360 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy &&
5361 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain &&
5362 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_strong &&
5363 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_weak)
5364 return true;
5365
5366 return false;
5367 }
5368
CodeCompleteObjCPropertyFlags(Scope * S,ObjCDeclSpec & ODS)5369 void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) {
5370 if (!CodeCompleter)
5371 return;
5372
5373 unsigned Attributes = ODS.getPropertyAttributes();
5374
5375 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5376 CodeCompleter->getCodeCompletionTUInfo(),
5377 CodeCompletionContext::CCC_Other);
5378 Results.EnterNewScope();
5379 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readonly))
5380 Results.AddResult(CodeCompletionResult("readonly"));
5381 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_assign))
5382 Results.AddResult(CodeCompletionResult("assign"));
5383 if (!ObjCPropertyFlagConflicts(Attributes,
5384 ObjCDeclSpec::DQ_PR_unsafe_unretained))
5385 Results.AddResult(CodeCompletionResult("unsafe_unretained"));
5386 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readwrite))
5387 Results.AddResult(CodeCompletionResult("readwrite"));
5388 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_retain))
5389 Results.AddResult(CodeCompletionResult("retain"));
5390 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_strong))
5391 Results.AddResult(CodeCompletionResult("strong"));
5392 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_copy))
5393 Results.AddResult(CodeCompletionResult("copy"));
5394 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nonatomic))
5395 Results.AddResult(CodeCompletionResult("nonatomic"));
5396 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_atomic))
5397 Results.AddResult(CodeCompletionResult("atomic"));
5398
5399 // Only suggest "weak" if we're compiling for ARC-with-weak-references or GC.
5400 if (getLangOpts().ObjCWeak || getLangOpts().getGC() != LangOptions::NonGC)
5401 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_weak))
5402 Results.AddResult(CodeCompletionResult("weak"));
5403
5404 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_setter)) {
5405 CodeCompletionBuilder Setter(Results.getAllocator(),
5406 Results.getCodeCompletionTUInfo());
5407 Setter.AddTypedTextChunk("setter");
5408 Setter.AddTextChunk("=");
5409 Setter.AddPlaceholderChunk("method");
5410 Results.AddResult(CodeCompletionResult(Setter.TakeString()));
5411 }
5412 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_getter)) {
5413 CodeCompletionBuilder Getter(Results.getAllocator(),
5414 Results.getCodeCompletionTUInfo());
5415 Getter.AddTypedTextChunk("getter");
5416 Getter.AddTextChunk("=");
5417 Getter.AddPlaceholderChunk("method");
5418 Results.AddResult(CodeCompletionResult(Getter.TakeString()));
5419 }
5420 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nullability)) {
5421 Results.AddResult(CodeCompletionResult("nonnull"));
5422 Results.AddResult(CodeCompletionResult("nullable"));
5423 Results.AddResult(CodeCompletionResult("null_unspecified"));
5424 Results.AddResult(CodeCompletionResult("null_resettable"));
5425 }
5426 Results.ExitScope();
5427 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5428 Results.data(), Results.size());
5429 }
5430
5431 /// Describes the kind of Objective-C method that we want to find
5432 /// via code completion.
5433 enum ObjCMethodKind {
5434 MK_Any, ///< Any kind of method, provided it means other specified criteria.
5435 MK_ZeroArgSelector, ///< Zero-argument (unary) selector.
5436 MK_OneArgSelector ///< One-argument selector.
5437 };
5438
isAcceptableObjCSelector(Selector Sel,ObjCMethodKind WantKind,ArrayRef<IdentifierInfo * > SelIdents,bool AllowSameLength=true)5439 static bool isAcceptableObjCSelector(Selector Sel,
5440 ObjCMethodKind WantKind,
5441 ArrayRef<IdentifierInfo *> SelIdents,
5442 bool AllowSameLength = true) {
5443 unsigned NumSelIdents = SelIdents.size();
5444 if (NumSelIdents > Sel.getNumArgs())
5445 return false;
5446
5447 switch (WantKind) {
5448 case MK_Any: break;
5449 case MK_ZeroArgSelector: return Sel.isUnarySelector();
5450 case MK_OneArgSelector: return Sel.getNumArgs() == 1;
5451 }
5452
5453 if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs())
5454 return false;
5455
5456 for (unsigned I = 0; I != NumSelIdents; ++I)
5457 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I))
5458 return false;
5459
5460 return true;
5461 }
5462
isAcceptableObjCMethod(ObjCMethodDecl * Method,ObjCMethodKind WantKind,ArrayRef<IdentifierInfo * > SelIdents,bool AllowSameLength=true)5463 static bool isAcceptableObjCMethod(ObjCMethodDecl *Method,
5464 ObjCMethodKind WantKind,
5465 ArrayRef<IdentifierInfo *> SelIdents,
5466 bool AllowSameLength = true) {
5467 return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents,
5468 AllowSameLength);
5469 }
5470
5471 namespace {
5472 /// A set of selectors, which is used to avoid introducing multiple
5473 /// completions with the same selector into the result set.
5474 typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet;
5475 }
5476
5477 /// Add all of the Objective-C methods in the given Objective-C
5478 /// container to the set of results.
5479 ///
5480 /// The container will be a class, protocol, category, or implementation of
5481 /// any of the above. This mether will recurse to include methods from
5482 /// the superclasses of classes along with their categories, protocols, and
5483 /// implementations.
5484 ///
5485 /// \param Container the container in which we'll look to find methods.
5486 ///
5487 /// \param WantInstanceMethods Whether to add instance methods (only); if
5488 /// false, this routine will add factory methods (only).
5489 ///
5490 /// \param CurContext the context in which we're performing the lookup that
5491 /// finds methods.
5492 ///
5493 /// \param AllowSameLength Whether we allow a method to be added to the list
5494 /// when it has the same number of parameters as we have selector identifiers.
5495 ///
5496 /// \param Results the structure into which we'll add results.
AddObjCMethods(ObjCContainerDecl * Container,bool WantInstanceMethods,ObjCMethodKind WantKind,ArrayRef<IdentifierInfo * > SelIdents,DeclContext * CurContext,VisitedSelectorSet & Selectors,bool AllowSameLength,ResultBuilder & Results,bool InOriginalClass=true,bool IsRootClass=false)5497 static void AddObjCMethods(ObjCContainerDecl *Container,
5498 bool WantInstanceMethods, ObjCMethodKind WantKind,
5499 ArrayRef<IdentifierInfo *> SelIdents,
5500 DeclContext *CurContext,
5501 VisitedSelectorSet &Selectors, bool AllowSameLength,
5502 ResultBuilder &Results, bool InOriginalClass = true,
5503 bool IsRootClass = false) {
5504 typedef CodeCompletionResult Result;
5505 Container = getContainerDef(Container);
5506 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
5507 IsRootClass = IsRootClass || (IFace && !IFace->getSuperClass());
5508 for (auto *M : Container->methods()) {
5509 // The instance methods on the root class can be messaged via the
5510 // metaclass.
5511 if (M->isInstanceMethod() == WantInstanceMethods ||
5512 (IsRootClass && !WantInstanceMethods)) {
5513 // Check whether the selector identifiers we've been given are a
5514 // subset of the identifiers for this particular method.
5515 if (!isAcceptableObjCMethod(M, WantKind, SelIdents, AllowSameLength))
5516 continue;
5517
5518 if (!Selectors.insert(M->getSelector()).second)
5519 continue;
5520
5521 Result R = Result(M, Results.getBasePriority(M), nullptr);
5522 R.StartParameter = SelIdents.size();
5523 R.AllParametersAreInformative = (WantKind != MK_Any);
5524 if (!InOriginalClass)
5525 R.Priority += CCD_InBaseClass;
5526 Results.MaybeAddResult(R, CurContext);
5527 }
5528 }
5529
5530 // Visit the protocols of protocols.
5531 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
5532 if (Protocol->hasDefinition()) {
5533 const ObjCList<ObjCProtocolDecl> &Protocols
5534 = Protocol->getReferencedProtocols();
5535 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5536 E = Protocols.end();
5537 I != E; ++I)
5538 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5539 Selectors, AllowSameLength, Results, false, IsRootClass);
5540 }
5541 }
5542
5543 if (!IFace || !IFace->hasDefinition())
5544 return;
5545
5546 // Add methods in protocols.
5547 for (auto *I : IFace->protocols())
5548 AddObjCMethods(I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5549 Selectors, AllowSameLength, Results, false, IsRootClass);
5550
5551 // Add methods in categories.
5552 for (auto *CatDecl : IFace->known_categories()) {
5553 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
5554 CurContext, Selectors, AllowSameLength, Results,
5555 InOriginalClass, IsRootClass);
5556
5557 // Add a categories protocol methods.
5558 const ObjCList<ObjCProtocolDecl> &Protocols
5559 = CatDecl->getReferencedProtocols();
5560 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5561 E = Protocols.end();
5562 I != E; ++I)
5563 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5564 Selectors, AllowSameLength, Results, false, IsRootClass);
5565
5566 // Add methods in category implementations.
5567 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation())
5568 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
5569 Selectors, AllowSameLength, Results, InOriginalClass,
5570 IsRootClass);
5571 }
5572
5573 // Add methods in superclass.
5574 // Avoid passing in IsRootClass since root classes won't have super classes.
5575 if (IFace->getSuperClass())
5576 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind,
5577 SelIdents, CurContext, Selectors, AllowSameLength, Results,
5578 /*IsRootClass=*/false);
5579
5580 // Add methods in our implementation, if any.
5581 if (ObjCImplementationDecl *Impl = IFace->getImplementation())
5582 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
5583 Selectors, AllowSameLength, Results, InOriginalClass,
5584 IsRootClass);
5585 }
5586
5587
CodeCompleteObjCPropertyGetter(Scope * S)5588 void Sema::CodeCompleteObjCPropertyGetter(Scope *S) {
5589 // Try to find the interface where getters might live.
5590 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
5591 if (!Class) {
5592 if (ObjCCategoryDecl *Category
5593 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
5594 Class = Category->getClassInterface();
5595
5596 if (!Class)
5597 return;
5598 }
5599
5600 // Find all of the potential getters.
5601 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5602 CodeCompleter->getCodeCompletionTUInfo(),
5603 CodeCompletionContext::CCC_Other);
5604 Results.EnterNewScope();
5605
5606 VisitedSelectorSet Selectors;
5607 AddObjCMethods(Class, true, MK_ZeroArgSelector, None, CurContext, Selectors,
5608 /*AllowSameLength=*/true, Results);
5609 Results.ExitScope();
5610 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5611 Results.data(), Results.size());
5612 }
5613
CodeCompleteObjCPropertySetter(Scope * S)5614 void Sema::CodeCompleteObjCPropertySetter(Scope *S) {
5615 // Try to find the interface where setters might live.
5616 ObjCInterfaceDecl *Class
5617 = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
5618 if (!Class) {
5619 if (ObjCCategoryDecl *Category
5620 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
5621 Class = Category->getClassInterface();
5622
5623 if (!Class)
5624 return;
5625 }
5626
5627 // Find all of the potential getters.
5628 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5629 CodeCompleter->getCodeCompletionTUInfo(),
5630 CodeCompletionContext::CCC_Other);
5631 Results.EnterNewScope();
5632
5633 VisitedSelectorSet Selectors;
5634 AddObjCMethods(Class, true, MK_OneArgSelector, None, CurContext,
5635 Selectors, /*AllowSameLength=*/true, Results);
5636
5637 Results.ExitScope();
5638 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5639 Results.data(), Results.size());
5640 }
5641
CodeCompleteObjCPassingType(Scope * S,ObjCDeclSpec & DS,bool IsParameter)5642 void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
5643 bool IsParameter) {
5644 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5645 CodeCompleter->getCodeCompletionTUInfo(),
5646 CodeCompletionContext::CCC_Type);
5647 Results.EnterNewScope();
5648
5649 // Add context-sensitive, Objective-C parameter-passing keywords.
5650 bool AddedInOut = false;
5651 if ((DS.getObjCDeclQualifier() &
5652 (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) {
5653 Results.AddResult("in");
5654 Results.AddResult("inout");
5655 AddedInOut = true;
5656 }
5657 if ((DS.getObjCDeclQualifier() &
5658 (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) {
5659 Results.AddResult("out");
5660 if (!AddedInOut)
5661 Results.AddResult("inout");
5662 }
5663 if ((DS.getObjCDeclQualifier() &
5664 (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref |
5665 ObjCDeclSpec::DQ_Oneway)) == 0) {
5666 Results.AddResult("bycopy");
5667 Results.AddResult("byref");
5668 Results.AddResult("oneway");
5669 }
5670 if ((DS.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability) == 0) {
5671 Results.AddResult("nonnull");
5672 Results.AddResult("nullable");
5673 Results.AddResult("null_unspecified");
5674 }
5675
5676 // If we're completing the return type of an Objective-C method and the
5677 // identifier IBAction refers to a macro, provide a completion item for
5678 // an action, e.g.,
5679 // IBAction)<#selector#>:(id)sender
5680 if (DS.getObjCDeclQualifier() == 0 && !IsParameter &&
5681 PP.isMacroDefined("IBAction")) {
5682 CodeCompletionBuilder Builder(Results.getAllocator(),
5683 Results.getCodeCompletionTUInfo(),
5684 CCP_CodePattern, CXAvailability_Available);
5685 Builder.AddTypedTextChunk("IBAction");
5686 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5687 Builder.AddPlaceholderChunk("selector");
5688 Builder.AddChunk(CodeCompletionString::CK_Colon);
5689 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5690 Builder.AddTextChunk("id");
5691 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5692 Builder.AddTextChunk("sender");
5693 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
5694 }
5695
5696 // If we're completing the return type, provide 'instancetype'.
5697 if (!IsParameter) {
5698 Results.AddResult(CodeCompletionResult("instancetype"));
5699 }
5700
5701 // Add various builtin type names and specifiers.
5702 AddOrdinaryNameResults(PCC_Type, S, *this, Results);
5703 Results.ExitScope();
5704
5705 // Add the various type names
5706 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
5707 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5708 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5709 CodeCompleter->includeGlobals(),
5710 CodeCompleter->loadExternal());
5711
5712 if (CodeCompleter->includeMacros())
5713 AddMacroResults(PP, Results, false);
5714
5715 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5716 Results.data(), Results.size());
5717 }
5718
5719 /// When we have an expression with type "id", we may assume
5720 /// that it has some more-specific class type based on knowledge of
5721 /// common uses of Objective-C. This routine returns that class type,
5722 /// or NULL if no better result could be determined.
GetAssumedMessageSendExprType(Expr * E)5723 static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) {
5724 ObjCMessageExpr *Msg = dyn_cast_or_null<ObjCMessageExpr>(E);
5725 if (!Msg)
5726 return nullptr;
5727
5728 Selector Sel = Msg->getSelector();
5729 if (Sel.isNull())
5730 return nullptr;
5731
5732 IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0);
5733 if (!Id)
5734 return nullptr;
5735
5736 ObjCMethodDecl *Method = Msg->getMethodDecl();
5737 if (!Method)
5738 return nullptr;
5739
5740 // Determine the class that we're sending the message to.
5741 ObjCInterfaceDecl *IFace = nullptr;
5742 switch (Msg->getReceiverKind()) {
5743 case ObjCMessageExpr::Class:
5744 if (const ObjCObjectType *ObjType
5745 = Msg->getClassReceiver()->getAs<ObjCObjectType>())
5746 IFace = ObjType->getInterface();
5747 break;
5748
5749 case ObjCMessageExpr::Instance: {
5750 QualType T = Msg->getInstanceReceiver()->getType();
5751 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
5752 IFace = Ptr->getInterfaceDecl();
5753 break;
5754 }
5755
5756 case ObjCMessageExpr::SuperInstance:
5757 case ObjCMessageExpr::SuperClass:
5758 break;
5759 }
5760
5761 if (!IFace)
5762 return nullptr;
5763
5764 ObjCInterfaceDecl *Super = IFace->getSuperClass();
5765 if (Method->isInstanceMethod())
5766 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5767 .Case("retain", IFace)
5768 .Case("strong", IFace)
5769 .Case("autorelease", IFace)
5770 .Case("copy", IFace)
5771 .Case("copyWithZone", IFace)
5772 .Case("mutableCopy", IFace)
5773 .Case("mutableCopyWithZone", IFace)
5774 .Case("awakeFromCoder", IFace)
5775 .Case("replacementObjectFromCoder", IFace)
5776 .Case("class", IFace)
5777 .Case("classForCoder", IFace)
5778 .Case("superclass", Super)
5779 .Default(nullptr);
5780
5781 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5782 .Case("new", IFace)
5783 .Case("alloc", IFace)
5784 .Case("allocWithZone", IFace)
5785 .Case("class", IFace)
5786 .Case("superclass", Super)
5787 .Default(nullptr);
5788 }
5789
5790 // Add a special completion for a message send to "super", which fills in the
5791 // most likely case of forwarding all of our arguments to the superclass
5792 // function.
5793 ///
5794 /// \param S The semantic analysis object.
5795 ///
5796 /// \param NeedSuperKeyword Whether we need to prefix this completion with
5797 /// the "super" keyword. Otherwise, we just need to provide the arguments.
5798 ///
5799 /// \param SelIdents The identifiers in the selector that have already been
5800 /// provided as arguments for a send to "super".
5801 ///
5802 /// \param Results The set of results to augment.
5803 ///
5804 /// \returns the Objective-C method declaration that would be invoked by
5805 /// this "super" completion. If NULL, no completion was added.
AddSuperSendCompletion(Sema & S,bool NeedSuperKeyword,ArrayRef<IdentifierInfo * > SelIdents,ResultBuilder & Results)5806 static ObjCMethodDecl *AddSuperSendCompletion(
5807 Sema &S, bool NeedSuperKeyword,
5808 ArrayRef<IdentifierInfo *> SelIdents,
5809 ResultBuilder &Results) {
5810 ObjCMethodDecl *CurMethod = S.getCurMethodDecl();
5811 if (!CurMethod)
5812 return nullptr;
5813
5814 ObjCInterfaceDecl *Class = CurMethod->getClassInterface();
5815 if (!Class)
5816 return nullptr;
5817
5818 // Try to find a superclass method with the same selector.
5819 ObjCMethodDecl *SuperMethod = nullptr;
5820 while ((Class = Class->getSuperClass()) && !SuperMethod) {
5821 // Check in the class
5822 SuperMethod = Class->getMethod(CurMethod->getSelector(),
5823 CurMethod->isInstanceMethod());
5824
5825 // Check in categories or class extensions.
5826 if (!SuperMethod) {
5827 for (const auto *Cat : Class->known_categories()) {
5828 if ((SuperMethod = Cat->getMethod(CurMethod->getSelector(),
5829 CurMethod->isInstanceMethod())))
5830 break;
5831 }
5832 }
5833 }
5834
5835 if (!SuperMethod)
5836 return nullptr;
5837
5838 // Check whether the superclass method has the same signature.
5839 if (CurMethod->param_size() != SuperMethod->param_size() ||
5840 CurMethod->isVariadic() != SuperMethod->isVariadic())
5841 return nullptr;
5842
5843 for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(),
5844 CurPEnd = CurMethod->param_end(),
5845 SuperP = SuperMethod->param_begin();
5846 CurP != CurPEnd; ++CurP, ++SuperP) {
5847 // Make sure the parameter types are compatible.
5848 if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(),
5849 (*SuperP)->getType()))
5850 return nullptr;
5851
5852 // Make sure we have a parameter name to forward!
5853 if (!(*CurP)->getIdentifier())
5854 return nullptr;
5855 }
5856
5857 // We have a superclass method. Now, form the send-to-super completion.
5858 CodeCompletionBuilder Builder(Results.getAllocator(),
5859 Results.getCodeCompletionTUInfo());
5860
5861 // Give this completion a return type.
5862 AddResultTypeChunk(S.Context, getCompletionPrintingPolicy(S), SuperMethod,
5863 Results.getCompletionContext().getBaseType(),
5864 Builder);
5865
5866 // If we need the "super" keyword, add it (plus some spacing).
5867 if (NeedSuperKeyword) {
5868 Builder.AddTypedTextChunk("super");
5869 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5870 }
5871
5872 Selector Sel = CurMethod->getSelector();
5873 if (Sel.isUnarySelector()) {
5874 if (NeedSuperKeyword)
5875 Builder.AddTextChunk(Builder.getAllocator().CopyString(
5876 Sel.getNameForSlot(0)));
5877 else
5878 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
5879 Sel.getNameForSlot(0)));
5880 } else {
5881 ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin();
5882 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) {
5883 if (I > SelIdents.size())
5884 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5885
5886 if (I < SelIdents.size())
5887 Builder.AddInformativeChunk(
5888 Builder.getAllocator().CopyString(
5889 Sel.getNameForSlot(I) + ":"));
5890 else if (NeedSuperKeyword || I > SelIdents.size()) {
5891 Builder.AddTextChunk(
5892 Builder.getAllocator().CopyString(
5893 Sel.getNameForSlot(I) + ":"));
5894 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5895 (*CurP)->getIdentifier()->getName()));
5896 } else {
5897 Builder.AddTypedTextChunk(
5898 Builder.getAllocator().CopyString(
5899 Sel.getNameForSlot(I) + ":"));
5900 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5901 (*CurP)->getIdentifier()->getName()));
5902 }
5903 }
5904 }
5905
5906 Results.AddResult(CodeCompletionResult(Builder.TakeString(), SuperMethod,
5907 CCP_SuperCompletion));
5908 return SuperMethod;
5909 }
5910
CodeCompleteObjCMessageReceiver(Scope * S)5911 void Sema::CodeCompleteObjCMessageReceiver(Scope *S) {
5912 typedef CodeCompletionResult Result;
5913 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5914 CodeCompleter->getCodeCompletionTUInfo(),
5915 CodeCompletionContext::CCC_ObjCMessageReceiver,
5916 getLangOpts().CPlusPlus11
5917 ? &ResultBuilder::IsObjCMessageReceiverOrLambdaCapture
5918 : &ResultBuilder::IsObjCMessageReceiver);
5919
5920 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5921 Results.EnterNewScope();
5922 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5923 CodeCompleter->includeGlobals(),
5924 CodeCompleter->loadExternal());
5925
5926 // If we are in an Objective-C method inside a class that has a superclass,
5927 // add "super" as an option.
5928 if (ObjCMethodDecl *Method = getCurMethodDecl())
5929 if (ObjCInterfaceDecl *Iface = Method->getClassInterface())
5930 if (Iface->getSuperClass()) {
5931 Results.AddResult(Result("super"));
5932
5933 AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, None, Results);
5934 }
5935
5936 if (getLangOpts().CPlusPlus11)
5937 addThisCompletion(*this, Results);
5938
5939 Results.ExitScope();
5940
5941 if (CodeCompleter->includeMacros())
5942 AddMacroResults(PP, Results, false);
5943 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5944 Results.data(), Results.size());
5945
5946 }
5947
CodeCompleteObjCSuperMessage(Scope * S,SourceLocation SuperLoc,ArrayRef<IdentifierInfo * > SelIdents,bool AtArgumentExpression)5948 void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
5949 ArrayRef<IdentifierInfo *> SelIdents,
5950 bool AtArgumentExpression) {
5951 ObjCInterfaceDecl *CDecl = nullptr;
5952 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5953 // Figure out which interface we're in.
5954 CDecl = CurMethod->getClassInterface();
5955 if (!CDecl)
5956 return;
5957
5958 // Find the superclass of this class.
5959 CDecl = CDecl->getSuperClass();
5960 if (!CDecl)
5961 return;
5962
5963 if (CurMethod->isInstanceMethod()) {
5964 // We are inside an instance method, which means that the message
5965 // send [super ...] is actually calling an instance method on the
5966 // current object.
5967 return CodeCompleteObjCInstanceMessage(S, nullptr, SelIdents,
5968 AtArgumentExpression,
5969 CDecl);
5970 }
5971
5972 // Fall through to send to the superclass in CDecl.
5973 } else {
5974 // "super" may be the name of a type or variable. Figure out which
5975 // it is.
5976 IdentifierInfo *Super = getSuperIdentifier();
5977 NamedDecl *ND = LookupSingleName(S, Super, SuperLoc,
5978 LookupOrdinaryName);
5979 if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) {
5980 // "super" names an interface. Use it.
5981 } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) {
5982 if (const ObjCObjectType *Iface
5983 = Context.getTypeDeclType(TD)->getAs<ObjCObjectType>())
5984 CDecl = Iface->getInterface();
5985 } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) {
5986 // "super" names an unresolved type; we can't be more specific.
5987 } else {
5988 // Assume that "super" names some kind of value and parse that way.
5989 CXXScopeSpec SS;
5990 SourceLocation TemplateKWLoc;
5991 UnqualifiedId id;
5992 id.setIdentifier(Super, SuperLoc);
5993 ExprResult SuperExpr = ActOnIdExpression(S, SS, TemplateKWLoc, id,
5994 false, false);
5995 return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
5996 SelIdents,
5997 AtArgumentExpression);
5998 }
5999
6000 // Fall through
6001 }
6002
6003 ParsedType Receiver;
6004 if (CDecl)
6005 Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl));
6006 return CodeCompleteObjCClassMessage(S, Receiver, SelIdents,
6007 AtArgumentExpression,
6008 /*IsSuper=*/true);
6009 }
6010
6011 /// Given a set of code-completion results for the argument of a message
6012 /// send, determine the preferred type (if any) for that argument expression.
getPreferredArgumentTypeForMessageSend(ResultBuilder & Results,unsigned NumSelIdents)6013 static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
6014 unsigned NumSelIdents) {
6015 typedef CodeCompletionResult Result;
6016 ASTContext &Context = Results.getSema().Context;
6017
6018 QualType PreferredType;
6019 unsigned BestPriority = CCP_Unlikely * 2;
6020 Result *ResultsData = Results.data();
6021 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
6022 Result &R = ResultsData[I];
6023 if (R.Kind == Result::RK_Declaration &&
6024 isa<ObjCMethodDecl>(R.Declaration)) {
6025 if (R.Priority <= BestPriority) {
6026 const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration);
6027 if (NumSelIdents <= Method->param_size()) {
6028 QualType MyPreferredType = Method->parameters()[NumSelIdents - 1]
6029 ->getType();
6030 if (R.Priority < BestPriority || PreferredType.isNull()) {
6031 BestPriority = R.Priority;
6032 PreferredType = MyPreferredType;
6033 } else if (!Context.hasSameUnqualifiedType(PreferredType,
6034 MyPreferredType)) {
6035 PreferredType = QualType();
6036 }
6037 }
6038 }
6039 }
6040 }
6041
6042 return PreferredType;
6043 }
6044
AddClassMessageCompletions(Sema & SemaRef,Scope * S,ParsedType Receiver,ArrayRef<IdentifierInfo * > SelIdents,bool AtArgumentExpression,bool IsSuper,ResultBuilder & Results)6045 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
6046 ParsedType Receiver,
6047 ArrayRef<IdentifierInfo *> SelIdents,
6048 bool AtArgumentExpression,
6049 bool IsSuper,
6050 ResultBuilder &Results) {
6051 typedef CodeCompletionResult Result;
6052 ObjCInterfaceDecl *CDecl = nullptr;
6053
6054 // If the given name refers to an interface type, retrieve the
6055 // corresponding declaration.
6056 if (Receiver) {
6057 QualType T = SemaRef.GetTypeFromParser(Receiver, nullptr);
6058 if (!T.isNull())
6059 if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>())
6060 CDecl = Interface->getInterface();
6061 }
6062
6063 // Add all of the factory methods in this Objective-C class, its protocols,
6064 // superclasses, categories, implementation, etc.
6065 Results.EnterNewScope();
6066
6067 // If this is a send-to-super, try to add the special "super" send
6068 // completion.
6069 if (IsSuper) {
6070 if (ObjCMethodDecl *SuperMethod
6071 = AddSuperSendCompletion(SemaRef, false, SelIdents, Results))
6072 Results.Ignore(SuperMethod);
6073 }
6074
6075 // If we're inside an Objective-C method definition, prefer its selector to
6076 // others.
6077 if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl())
6078 Results.setPreferredSelector(CurMethod->getSelector());
6079
6080 VisitedSelectorSet Selectors;
6081 if (CDecl)
6082 AddObjCMethods(CDecl, false, MK_Any, SelIdents,
6083 SemaRef.CurContext, Selectors, AtArgumentExpression,
6084 Results);
6085 else {
6086 // We're messaging "id" as a type; provide all class/factory methods.
6087
6088 // If we have an external source, load the entire class method
6089 // pool from the AST file.
6090 if (SemaRef.getExternalSource()) {
6091 for (uint32_t I = 0,
6092 N = SemaRef.getExternalSource()->GetNumExternalSelectors();
6093 I != N; ++I) {
6094 Selector Sel = SemaRef.getExternalSource()->GetExternalSelector(I);
6095 if (Sel.isNull() || SemaRef.MethodPool.count(Sel))
6096 continue;
6097
6098 SemaRef.ReadMethodPool(Sel);
6099 }
6100 }
6101
6102 for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(),
6103 MEnd = SemaRef.MethodPool.end();
6104 M != MEnd; ++M) {
6105 for (ObjCMethodList *MethList = &M->second.second;
6106 MethList && MethList->getMethod();
6107 MethList = MethList->getNext()) {
6108 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
6109 continue;
6110
6111 Result R(MethList->getMethod(),
6112 Results.getBasePriority(MethList->getMethod()), nullptr);
6113 R.StartParameter = SelIdents.size();
6114 R.AllParametersAreInformative = false;
6115 Results.MaybeAddResult(R, SemaRef.CurContext);
6116 }
6117 }
6118 }
6119
6120 Results.ExitScope();
6121 }
6122
CodeCompleteObjCClassMessage(Scope * S,ParsedType Receiver,ArrayRef<IdentifierInfo * > SelIdents,bool AtArgumentExpression,bool IsSuper)6123 void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
6124 ArrayRef<IdentifierInfo *> SelIdents,
6125 bool AtArgumentExpression,
6126 bool IsSuper) {
6127
6128 QualType T = this->GetTypeFromParser(Receiver);
6129
6130 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6131 CodeCompleter->getCodeCompletionTUInfo(),
6132 CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage,
6133 T, SelIdents));
6134
6135 AddClassMessageCompletions(*this, S, Receiver, SelIdents,
6136 AtArgumentExpression, IsSuper, Results);
6137
6138 // If we're actually at the argument expression (rather than prior to the
6139 // selector), we're actually performing code completion for an expression.
6140 // Determine whether we have a single, best method. If so, we can
6141 // code-complete the expression using the corresponding parameter type as
6142 // our preferred type, improving completion results.
6143 if (AtArgumentExpression) {
6144 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
6145 SelIdents.size());
6146 if (PreferredType.isNull())
6147 CodeCompleteOrdinaryName(S, PCC_Expression);
6148 else
6149 CodeCompleteExpression(S, PreferredType);
6150 return;
6151 }
6152
6153 HandleCodeCompleteResults(this, CodeCompleter,
6154 Results.getCompletionContext(),
6155 Results.data(), Results.size());
6156 }
6157
CodeCompleteObjCInstanceMessage(Scope * S,Expr * Receiver,ArrayRef<IdentifierInfo * > SelIdents,bool AtArgumentExpression,ObjCInterfaceDecl * Super)6158 void Sema::CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
6159 ArrayRef<IdentifierInfo *> SelIdents,
6160 bool AtArgumentExpression,
6161 ObjCInterfaceDecl *Super) {
6162 typedef CodeCompletionResult Result;
6163
6164 Expr *RecExpr = static_cast<Expr *>(Receiver);
6165
6166 // If necessary, apply function/array conversion to the receiver.
6167 // C99 6.7.5.3p[7,8].
6168 if (RecExpr) {
6169 ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr);
6170 if (Conv.isInvalid()) // conversion failed. bail.
6171 return;
6172 RecExpr = Conv.get();
6173 }
6174 QualType ReceiverType = RecExpr? RecExpr->getType()
6175 : Super? Context.getObjCObjectPointerType(
6176 Context.getObjCInterfaceType(Super))
6177 : Context.getObjCIdType();
6178
6179 // If we're messaging an expression with type "id" or "Class", check
6180 // whether we know something special about the receiver that allows
6181 // us to assume a more-specific receiver type.
6182 if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType()) {
6183 if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) {
6184 if (ReceiverType->isObjCClassType())
6185 return CodeCompleteObjCClassMessage(S,
6186 ParsedType::make(Context.getObjCInterfaceType(IFace)),
6187 SelIdents,
6188 AtArgumentExpression, Super);
6189
6190 ReceiverType = Context.getObjCObjectPointerType(
6191 Context.getObjCInterfaceType(IFace));
6192 }
6193 } else if (RecExpr && getLangOpts().CPlusPlus) {
6194 ExprResult Conv = PerformContextuallyConvertToObjCPointer(RecExpr);
6195 if (Conv.isUsable()) {
6196 RecExpr = Conv.get();
6197 ReceiverType = RecExpr->getType();
6198 }
6199 }
6200
6201 // Build the set of methods we can see.
6202 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6203 CodeCompleter->getCodeCompletionTUInfo(),
6204 CodeCompletionContext(CodeCompletionContext::CCC_ObjCInstanceMessage,
6205 ReceiverType, SelIdents));
6206
6207 Results.EnterNewScope();
6208
6209 // If this is a send-to-super, try to add the special "super" send
6210 // completion.
6211 if (Super) {
6212 if (ObjCMethodDecl *SuperMethod
6213 = AddSuperSendCompletion(*this, false, SelIdents, Results))
6214 Results.Ignore(SuperMethod);
6215 }
6216
6217 // If we're inside an Objective-C method definition, prefer its selector to
6218 // others.
6219 if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
6220 Results.setPreferredSelector(CurMethod->getSelector());
6221
6222 // Keep track of the selectors we've already added.
6223 VisitedSelectorSet Selectors;
6224
6225 // Handle messages to Class. This really isn't a message to an instance
6226 // method, so we treat it the same way we would treat a message send to a
6227 // class method.
6228 if (ReceiverType->isObjCClassType() ||
6229 ReceiverType->isObjCQualifiedClassType()) {
6230 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
6231 if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface())
6232 AddObjCMethods(ClassDecl, false, MK_Any, SelIdents,
6233 CurContext, Selectors, AtArgumentExpression, Results);
6234 }
6235 }
6236 // Handle messages to a qualified ID ("id<foo>").
6237 else if (const ObjCObjectPointerType *QualID
6238 = ReceiverType->getAsObjCQualifiedIdType()) {
6239 // Search protocols for instance methods.
6240 for (auto *I : QualID->quals())
6241 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
6242 Selectors, AtArgumentExpression, Results);
6243 }
6244 // Handle messages to a pointer to interface type.
6245 else if (const ObjCObjectPointerType *IFacePtr
6246 = ReceiverType->getAsObjCInterfacePointerType()) {
6247 // Search the class, its superclasses, etc., for instance methods.
6248 AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents,
6249 CurContext, Selectors, AtArgumentExpression,
6250 Results);
6251
6252 // Search protocols for instance methods.
6253 for (auto *I : IFacePtr->quals())
6254 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
6255 Selectors, AtArgumentExpression, Results);
6256 }
6257 // Handle messages to "id".
6258 else if (ReceiverType->isObjCIdType()) {
6259 // We're messaging "id", so provide all instance methods we know
6260 // about as code-completion results.
6261
6262 // If we have an external source, load the entire class method
6263 // pool from the AST file.
6264 if (ExternalSource) {
6265 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
6266 I != N; ++I) {
6267 Selector Sel = ExternalSource->GetExternalSelector(I);
6268 if (Sel.isNull() || MethodPool.count(Sel))
6269 continue;
6270
6271 ReadMethodPool(Sel);
6272 }
6273 }
6274
6275 for (GlobalMethodPool::iterator M = MethodPool.begin(),
6276 MEnd = MethodPool.end();
6277 M != MEnd; ++M) {
6278 for (ObjCMethodList *MethList = &M->second.first;
6279 MethList && MethList->getMethod();
6280 MethList = MethList->getNext()) {
6281 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
6282 continue;
6283
6284 if (!Selectors.insert(MethList->getMethod()->getSelector()).second)
6285 continue;
6286
6287 Result R(MethList->getMethod(),
6288 Results.getBasePriority(MethList->getMethod()), nullptr);
6289 R.StartParameter = SelIdents.size();
6290 R.AllParametersAreInformative = false;
6291 Results.MaybeAddResult(R, CurContext);
6292 }
6293 }
6294 }
6295 Results.ExitScope();
6296
6297
6298 // If we're actually at the argument expression (rather than prior to the
6299 // selector), we're actually performing code completion for an expression.
6300 // Determine whether we have a single, best method. If so, we can
6301 // code-complete the expression using the corresponding parameter type as
6302 // our preferred type, improving completion results.
6303 if (AtArgumentExpression) {
6304 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
6305 SelIdents.size());
6306 if (PreferredType.isNull())
6307 CodeCompleteOrdinaryName(S, PCC_Expression);
6308 else
6309 CodeCompleteExpression(S, PreferredType);
6310 return;
6311 }
6312
6313 HandleCodeCompleteResults(this, CodeCompleter,
6314 Results.getCompletionContext(),
6315 Results.data(),Results.size());
6316 }
6317
CodeCompleteObjCForCollection(Scope * S,DeclGroupPtrTy IterationVar)6318 void Sema::CodeCompleteObjCForCollection(Scope *S,
6319 DeclGroupPtrTy IterationVar) {
6320 CodeCompleteExpressionData Data;
6321 Data.ObjCCollection = true;
6322
6323 if (IterationVar.getAsOpaquePtr()) {
6324 DeclGroupRef DG = IterationVar.get();
6325 for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) {
6326 if (*I)
6327 Data.IgnoreDecls.push_back(*I);
6328 }
6329 }
6330
6331 CodeCompleteExpression(S, Data);
6332 }
6333
CodeCompleteObjCSelector(Scope * S,ArrayRef<IdentifierInfo * > SelIdents)6334 void Sema::CodeCompleteObjCSelector(Scope *S,
6335 ArrayRef<IdentifierInfo *> SelIdents) {
6336 // If we have an external source, load the entire class method
6337 // pool from the AST file.
6338 if (ExternalSource) {
6339 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
6340 I != N; ++I) {
6341 Selector Sel = ExternalSource->GetExternalSelector(I);
6342 if (Sel.isNull() || MethodPool.count(Sel))
6343 continue;
6344
6345 ReadMethodPool(Sel);
6346 }
6347 }
6348
6349 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6350 CodeCompleter->getCodeCompletionTUInfo(),
6351 CodeCompletionContext::CCC_SelectorName);
6352 Results.EnterNewScope();
6353 for (GlobalMethodPool::iterator M = MethodPool.begin(),
6354 MEnd = MethodPool.end();
6355 M != MEnd; ++M) {
6356
6357 Selector Sel = M->first;
6358 if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents))
6359 continue;
6360
6361 CodeCompletionBuilder Builder(Results.getAllocator(),
6362 Results.getCodeCompletionTUInfo());
6363 if (Sel.isUnarySelector()) {
6364 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
6365 Sel.getNameForSlot(0)));
6366 Results.AddResult(Builder.TakeString());
6367 continue;
6368 }
6369
6370 std::string Accumulator;
6371 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) {
6372 if (I == SelIdents.size()) {
6373 if (!Accumulator.empty()) {
6374 Builder.AddInformativeChunk(Builder.getAllocator().CopyString(
6375 Accumulator));
6376 Accumulator.clear();
6377 }
6378 }
6379
6380 Accumulator += Sel.getNameForSlot(I);
6381 Accumulator += ':';
6382 }
6383 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString( Accumulator));
6384 Results.AddResult(Builder.TakeString());
6385 }
6386 Results.ExitScope();
6387
6388 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6389 Results.data(), Results.size());
6390 }
6391
6392 /// Add all of the protocol declarations that we find in the given
6393 /// (translation unit) context.
AddProtocolResults(DeclContext * Ctx,DeclContext * CurContext,bool OnlyForwardDeclarations,ResultBuilder & Results)6394 static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext,
6395 bool OnlyForwardDeclarations,
6396 ResultBuilder &Results) {
6397 typedef CodeCompletionResult Result;
6398
6399 for (const auto *D : Ctx->decls()) {
6400 // Record any protocols we find.
6401 if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(D))
6402 if (!OnlyForwardDeclarations || !Proto->hasDefinition())
6403 Results.AddResult(Result(Proto, Results.getBasePriority(Proto),nullptr),
6404 CurContext, nullptr, false);
6405 }
6406 }
6407
CodeCompleteObjCProtocolReferences(ArrayRef<IdentifierLocPair> Protocols)6408 void Sema::CodeCompleteObjCProtocolReferences(
6409 ArrayRef<IdentifierLocPair> Protocols) {
6410 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6411 CodeCompleter->getCodeCompletionTUInfo(),
6412 CodeCompletionContext::CCC_ObjCProtocolName);
6413
6414 if (CodeCompleter->includeGlobals()) {
6415 Results.EnterNewScope();
6416
6417 // Tell the result set to ignore all of the protocols we have
6418 // already seen.
6419 // FIXME: This doesn't work when caching code-completion results.
6420 for (const IdentifierLocPair &Pair : Protocols)
6421 if (ObjCProtocolDecl *Protocol = LookupProtocol(Pair.first,
6422 Pair.second))
6423 Results.Ignore(Protocol);
6424
6425 // Add all protocols.
6426 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false,
6427 Results);
6428
6429 Results.ExitScope();
6430 }
6431
6432 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6433 Results.data(), Results.size());
6434 }
6435
CodeCompleteObjCProtocolDecl(Scope *)6436 void Sema::CodeCompleteObjCProtocolDecl(Scope *) {
6437 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6438 CodeCompleter->getCodeCompletionTUInfo(),
6439 CodeCompletionContext::CCC_ObjCProtocolName);
6440
6441 if (CodeCompleter->includeGlobals()) {
6442 Results.EnterNewScope();
6443
6444 // Add all protocols.
6445 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true,
6446 Results);
6447
6448 Results.ExitScope();
6449 }
6450
6451 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6452 Results.data(), Results.size());
6453 }
6454
6455 /// Add all of the Objective-C interface declarations that we find in
6456 /// the given (translation unit) context.
AddInterfaceResults(DeclContext * Ctx,DeclContext * CurContext,bool OnlyForwardDeclarations,bool OnlyUnimplemented,ResultBuilder & Results)6457 static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext,
6458 bool OnlyForwardDeclarations,
6459 bool OnlyUnimplemented,
6460 ResultBuilder &Results) {
6461 typedef CodeCompletionResult Result;
6462
6463 for (const auto *D : Ctx->decls()) {
6464 // Record any interfaces we find.
6465 if (const auto *Class = dyn_cast<ObjCInterfaceDecl>(D))
6466 if ((!OnlyForwardDeclarations || !Class->hasDefinition()) &&
6467 (!OnlyUnimplemented || !Class->getImplementation()))
6468 Results.AddResult(Result(Class, Results.getBasePriority(Class),nullptr),
6469 CurContext, nullptr, false);
6470 }
6471 }
6472
CodeCompleteObjCInterfaceDecl(Scope * S)6473 void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) {
6474 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6475 CodeCompleter->getCodeCompletionTUInfo(),
6476 CodeCompletionContext::CCC_ObjCInterfaceName);
6477 Results.EnterNewScope();
6478
6479 if (CodeCompleter->includeGlobals()) {
6480 // Add all classes.
6481 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6482 false, Results);
6483 }
6484
6485 Results.ExitScope();
6486
6487 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6488 Results.data(), Results.size());
6489 }
6490
CodeCompleteObjCSuperclass(Scope * S,IdentifierInfo * ClassName,SourceLocation ClassNameLoc)6491 void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName,
6492 SourceLocation ClassNameLoc) {
6493 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6494 CodeCompleter->getCodeCompletionTUInfo(),
6495 CodeCompletionContext::CCC_ObjCInterfaceName);
6496 Results.EnterNewScope();
6497
6498 // Make sure that we ignore the class we're currently defining.
6499 NamedDecl *CurClass
6500 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6501 if (CurClass && isa<ObjCInterfaceDecl>(CurClass))
6502 Results.Ignore(CurClass);
6503
6504 if (CodeCompleter->includeGlobals()) {
6505 // Add all classes.
6506 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6507 false, Results);
6508 }
6509
6510 Results.ExitScope();
6511
6512 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6513 Results.data(), Results.size());
6514 }
6515
CodeCompleteObjCImplementationDecl(Scope * S)6516 void Sema::CodeCompleteObjCImplementationDecl(Scope *S) {
6517 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6518 CodeCompleter->getCodeCompletionTUInfo(),
6519 CodeCompletionContext::CCC_ObjCImplementation);
6520 Results.EnterNewScope();
6521
6522 if (CodeCompleter->includeGlobals()) {
6523 // Add all unimplemented classes.
6524 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6525 true, Results);
6526 }
6527
6528 Results.ExitScope();
6529
6530 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6531 Results.data(), Results.size());
6532 }
6533
CodeCompleteObjCInterfaceCategory(Scope * S,IdentifierInfo * ClassName,SourceLocation ClassNameLoc)6534 void Sema::CodeCompleteObjCInterfaceCategory(Scope *S,
6535 IdentifierInfo *ClassName,
6536 SourceLocation ClassNameLoc) {
6537 typedef CodeCompletionResult Result;
6538
6539 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6540 CodeCompleter->getCodeCompletionTUInfo(),
6541 CodeCompletionContext::CCC_ObjCCategoryName);
6542
6543 // Ignore any categories we find that have already been implemented by this
6544 // interface.
6545 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
6546 NamedDecl *CurClass
6547 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6548 if (ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)){
6549 for (const auto *Cat : Class->visible_categories())
6550 CategoryNames.insert(Cat->getIdentifier());
6551 }
6552
6553 // Add all of the categories we know about.
6554 Results.EnterNewScope();
6555 TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
6556 for (const auto *D : TU->decls())
6557 if (const auto *Category = dyn_cast<ObjCCategoryDecl>(D))
6558 if (CategoryNames.insert(Category->getIdentifier()).second)
6559 Results.AddResult(Result(Category, Results.getBasePriority(Category),
6560 nullptr),
6561 CurContext, nullptr, false);
6562 Results.ExitScope();
6563
6564 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6565 Results.data(), Results.size());
6566 }
6567
CodeCompleteObjCImplementationCategory(Scope * S,IdentifierInfo * ClassName,SourceLocation ClassNameLoc)6568 void Sema::CodeCompleteObjCImplementationCategory(Scope *S,
6569 IdentifierInfo *ClassName,
6570 SourceLocation ClassNameLoc) {
6571 typedef CodeCompletionResult Result;
6572
6573 // Find the corresponding interface. If we couldn't find the interface, the
6574 // program itself is ill-formed. However, we'll try to be helpful still by
6575 // providing the list of all of the categories we know about.
6576 NamedDecl *CurClass
6577 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6578 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass);
6579 if (!Class)
6580 return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc);
6581
6582 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6583 CodeCompleter->getCodeCompletionTUInfo(),
6584 CodeCompletionContext::CCC_ObjCCategoryName);
6585
6586 // Add all of the categories that have have corresponding interface
6587 // declarations in this class and any of its superclasses, except for
6588 // already-implemented categories in the class itself.
6589 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
6590 Results.EnterNewScope();
6591 bool IgnoreImplemented = true;
6592 while (Class) {
6593 for (const auto *Cat : Class->visible_categories()) {
6594 if ((!IgnoreImplemented || !Cat->getImplementation()) &&
6595 CategoryNames.insert(Cat->getIdentifier()).second)
6596 Results.AddResult(Result(Cat, Results.getBasePriority(Cat), nullptr),
6597 CurContext, nullptr, false);
6598 }
6599
6600 Class = Class->getSuperClass();
6601 IgnoreImplemented = false;
6602 }
6603 Results.ExitScope();
6604
6605 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6606 Results.data(), Results.size());
6607 }
6608
CodeCompleteObjCPropertyDefinition(Scope * S)6609 void Sema::CodeCompleteObjCPropertyDefinition(Scope *S) {
6610 CodeCompletionContext CCContext(CodeCompletionContext::CCC_Other);
6611 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6612 CodeCompleter->getCodeCompletionTUInfo(),
6613 CCContext);
6614
6615 // Figure out where this @synthesize lives.
6616 ObjCContainerDecl *Container
6617 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6618 if (!Container ||
6619 (!isa<ObjCImplementationDecl>(Container) &&
6620 !isa<ObjCCategoryImplDecl>(Container)))
6621 return;
6622
6623 // Ignore any properties that have already been implemented.
6624 Container = getContainerDef(Container);
6625 for (const auto *D : Container->decls())
6626 if (const auto *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(D))
6627 Results.Ignore(PropertyImpl->getPropertyDecl());
6628
6629 // Add any properties that we find.
6630 AddedPropertiesSet AddedProperties;
6631 Results.EnterNewScope();
6632 if (ObjCImplementationDecl *ClassImpl
6633 = dyn_cast<ObjCImplementationDecl>(Container))
6634 AddObjCProperties(CCContext, ClassImpl->getClassInterface(), false,
6635 /*AllowNullaryMethods=*/false, CurContext,
6636 AddedProperties, Results);
6637 else
6638 AddObjCProperties(CCContext,
6639 cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(),
6640 false, /*AllowNullaryMethods=*/false, CurContext,
6641 AddedProperties, Results);
6642 Results.ExitScope();
6643
6644 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6645 Results.data(), Results.size());
6646 }
6647
CodeCompleteObjCPropertySynthesizeIvar(Scope * S,IdentifierInfo * PropertyName)6648 void Sema::CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
6649 IdentifierInfo *PropertyName) {
6650 typedef CodeCompletionResult Result;
6651 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6652 CodeCompleter->getCodeCompletionTUInfo(),
6653 CodeCompletionContext::CCC_Other);
6654
6655 // Figure out where this @synthesize lives.
6656 ObjCContainerDecl *Container
6657 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6658 if (!Container ||
6659 (!isa<ObjCImplementationDecl>(Container) &&
6660 !isa<ObjCCategoryImplDecl>(Container)))
6661 return;
6662
6663 // Figure out which interface we're looking into.
6664 ObjCInterfaceDecl *Class = nullptr;
6665 if (ObjCImplementationDecl *ClassImpl
6666 = dyn_cast<ObjCImplementationDecl>(Container))
6667 Class = ClassImpl->getClassInterface();
6668 else
6669 Class = cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl()
6670 ->getClassInterface();
6671
6672 // Determine the type of the property we're synthesizing.
6673 QualType PropertyType = Context.getObjCIdType();
6674 if (Class) {
6675 if (ObjCPropertyDecl *Property = Class->FindPropertyDeclaration(
6676 PropertyName, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
6677 PropertyType
6678 = Property->getType().getNonReferenceType().getUnqualifiedType();
6679
6680 // Give preference to ivars
6681 Results.setPreferredType(PropertyType);
6682 }
6683 }
6684
6685 // Add all of the instance variables in this class and its superclasses.
6686 Results.EnterNewScope();
6687 bool SawSimilarlyNamedIvar = false;
6688 std::string NameWithPrefix;
6689 NameWithPrefix += '_';
6690 NameWithPrefix += PropertyName->getName();
6691 std::string NameWithSuffix = PropertyName->getName().str();
6692 NameWithSuffix += '_';
6693 for(; Class; Class = Class->getSuperClass()) {
6694 for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar;
6695 Ivar = Ivar->getNextIvar()) {
6696 Results.AddResult(Result(Ivar, Results.getBasePriority(Ivar), nullptr),
6697 CurContext, nullptr, false);
6698
6699 // Determine whether we've seen an ivar with a name similar to the
6700 // property.
6701 if ((PropertyName == Ivar->getIdentifier() ||
6702 NameWithPrefix == Ivar->getName() ||
6703 NameWithSuffix == Ivar->getName())) {
6704 SawSimilarlyNamedIvar = true;
6705
6706 // Reduce the priority of this result by one, to give it a slight
6707 // advantage over other results whose names don't match so closely.
6708 if (Results.size() &&
6709 Results.data()[Results.size() - 1].Kind
6710 == CodeCompletionResult::RK_Declaration &&
6711 Results.data()[Results.size() - 1].Declaration == Ivar)
6712 Results.data()[Results.size() - 1].Priority--;
6713 }
6714 }
6715 }
6716
6717 if (!SawSimilarlyNamedIvar) {
6718 // Create ivar result _propName, that the user can use to synthesize
6719 // an ivar of the appropriate type.
6720 unsigned Priority = CCP_MemberDeclaration + 1;
6721 typedef CodeCompletionResult Result;
6722 CodeCompletionAllocator &Allocator = Results.getAllocator();
6723 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo(),
6724 Priority,CXAvailability_Available);
6725
6726 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
6727 Builder.AddResultTypeChunk(GetCompletionTypeString(PropertyType, Context,
6728 Policy, Allocator));
6729 Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix));
6730 Results.AddResult(Result(Builder.TakeString(), Priority,
6731 CXCursor_ObjCIvarDecl));
6732 }
6733
6734 Results.ExitScope();
6735
6736 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6737 Results.data(), Results.size());
6738 }
6739
6740 // Mapping from selectors to the methods that implement that selector, along
6741 // with the "in original class" flag.
6742 typedef llvm::DenseMap<
6743 Selector, llvm::PointerIntPair<ObjCMethodDecl *, 1, bool> > KnownMethodsMap;
6744
6745 /// Find all of the methods that reside in the given container
6746 /// (and its superclasses, protocols, etc.) that meet the given
6747 /// criteria. Insert those methods into the map of known methods,
6748 /// indexed by selector so they can be easily found.
FindImplementableMethods(ASTContext & Context,ObjCContainerDecl * Container,Optional<bool> WantInstanceMethods,QualType ReturnType,KnownMethodsMap & KnownMethods,bool InOriginalClass=true)6749 static void FindImplementableMethods(ASTContext &Context,
6750 ObjCContainerDecl *Container,
6751 Optional<bool> WantInstanceMethods,
6752 QualType ReturnType,
6753 KnownMethodsMap &KnownMethods,
6754 bool InOriginalClass = true) {
6755 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) {
6756 // Make sure we have a definition; that's what we'll walk.
6757 if (!IFace->hasDefinition())
6758 return;
6759
6760 IFace = IFace->getDefinition();
6761 Container = IFace;
6762
6763 const ObjCList<ObjCProtocolDecl> &Protocols
6764 = IFace->getReferencedProtocols();
6765 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6766 E = Protocols.end();
6767 I != E; ++I)
6768 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6769 KnownMethods, InOriginalClass);
6770
6771 // Add methods from any class extensions and categories.
6772 for (auto *Cat : IFace->visible_categories()) {
6773 FindImplementableMethods(Context, Cat, WantInstanceMethods, ReturnType,
6774 KnownMethods, false);
6775 }
6776
6777 // Visit the superclass.
6778 if (IFace->getSuperClass())
6779 FindImplementableMethods(Context, IFace->getSuperClass(),
6780 WantInstanceMethods, ReturnType,
6781 KnownMethods, false);
6782 }
6783
6784 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
6785 // Recurse into protocols.
6786 const ObjCList<ObjCProtocolDecl> &Protocols
6787 = Category->getReferencedProtocols();
6788 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6789 E = Protocols.end();
6790 I != E; ++I)
6791 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6792 KnownMethods, InOriginalClass);
6793
6794 // If this category is the original class, jump to the interface.
6795 if (InOriginalClass && Category->getClassInterface())
6796 FindImplementableMethods(Context, Category->getClassInterface(),
6797 WantInstanceMethods, ReturnType, KnownMethods,
6798 false);
6799 }
6800
6801 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
6802 // Make sure we have a definition; that's what we'll walk.
6803 if (!Protocol->hasDefinition())
6804 return;
6805 Protocol = Protocol->getDefinition();
6806 Container = Protocol;
6807
6808 // Recurse into protocols.
6809 const ObjCList<ObjCProtocolDecl> &Protocols
6810 = Protocol->getReferencedProtocols();
6811 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6812 E = Protocols.end();
6813 I != E; ++I)
6814 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6815 KnownMethods, false);
6816 }
6817
6818 // Add methods in this container. This operation occurs last because
6819 // we want the methods from this container to override any methods
6820 // we've previously seen with the same selector.
6821 for (auto *M : Container->methods()) {
6822 if (!WantInstanceMethods || M->isInstanceMethod() == *WantInstanceMethods) {
6823 if (!ReturnType.isNull() &&
6824 !Context.hasSameUnqualifiedType(ReturnType, M->getReturnType()))
6825 continue;
6826
6827 KnownMethods[M->getSelector()] =
6828 KnownMethodsMap::mapped_type(M, InOriginalClass);
6829 }
6830 }
6831 }
6832
6833 /// Add the parenthesized return or parameter type chunk to a code
6834 /// completion string.
AddObjCPassingTypeChunk(QualType Type,unsigned ObjCDeclQuals,ASTContext & Context,const PrintingPolicy & Policy,CodeCompletionBuilder & Builder)6835 static void AddObjCPassingTypeChunk(QualType Type,
6836 unsigned ObjCDeclQuals,
6837 ASTContext &Context,
6838 const PrintingPolicy &Policy,
6839 CodeCompletionBuilder &Builder) {
6840 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6841 std::string Quals = formatObjCParamQualifiers(ObjCDeclQuals, Type);
6842 if (!Quals.empty())
6843 Builder.AddTextChunk(Builder.getAllocator().CopyString(Quals));
6844 Builder.AddTextChunk(GetCompletionTypeString(Type, Context, Policy,
6845 Builder.getAllocator()));
6846 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6847 }
6848
6849 /// Determine whether the given class is or inherits from a class by
6850 /// the given name.
InheritsFromClassNamed(ObjCInterfaceDecl * Class,StringRef Name)6851 static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class,
6852 StringRef Name) {
6853 if (!Class)
6854 return false;
6855
6856 if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name)
6857 return true;
6858
6859 return InheritsFromClassNamed(Class->getSuperClass(), Name);
6860 }
6861
6862 /// Add code completions for Objective-C Key-Value Coding (KVC) and
6863 /// Key-Value Observing (KVO).
AddObjCKeyValueCompletions(ObjCPropertyDecl * Property,bool IsInstanceMethod,QualType ReturnType,ASTContext & Context,VisitedSelectorSet & KnownSelectors,ResultBuilder & Results)6864 static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property,
6865 bool IsInstanceMethod,
6866 QualType ReturnType,
6867 ASTContext &Context,
6868 VisitedSelectorSet &KnownSelectors,
6869 ResultBuilder &Results) {
6870 IdentifierInfo *PropName = Property->getIdentifier();
6871 if (!PropName || PropName->getLength() == 0)
6872 return;
6873
6874 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
6875
6876 // Builder that will create each code completion.
6877 typedef CodeCompletionResult Result;
6878 CodeCompletionAllocator &Allocator = Results.getAllocator();
6879 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
6880
6881 // The selector table.
6882 SelectorTable &Selectors = Context.Selectors;
6883
6884 // The property name, copied into the code completion allocation region
6885 // on demand.
6886 struct KeyHolder {
6887 CodeCompletionAllocator &Allocator;
6888 StringRef Key;
6889 const char *CopiedKey;
6890
6891 KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key)
6892 : Allocator(Allocator), Key(Key), CopiedKey(nullptr) {}
6893
6894 operator const char *() {
6895 if (CopiedKey)
6896 return CopiedKey;
6897
6898 return CopiedKey = Allocator.CopyString(Key);
6899 }
6900 } Key(Allocator, PropName->getName());
6901
6902 // The uppercased name of the property name.
6903 std::string UpperKey = PropName->getName();
6904 if (!UpperKey.empty())
6905 UpperKey[0] = toUppercase(UpperKey[0]);
6906
6907 bool ReturnTypeMatchesProperty = ReturnType.isNull() ||
6908 Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(),
6909 Property->getType());
6910 bool ReturnTypeMatchesVoid
6911 = ReturnType.isNull() || ReturnType->isVoidType();
6912
6913 // Add the normal accessor -(type)key.
6914 if (IsInstanceMethod &&
6915 KnownSelectors.insert(Selectors.getNullarySelector(PropName)).second &&
6916 ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) {
6917 if (ReturnType.isNull())
6918 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6919 Context, Policy, Builder);
6920
6921 Builder.AddTypedTextChunk(Key);
6922 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6923 CXCursor_ObjCInstanceMethodDecl));
6924 }
6925
6926 // If we have an integral or boolean property (or the user has provided
6927 // an integral or boolean return type), add the accessor -(type)isKey.
6928 if (IsInstanceMethod &&
6929 ((!ReturnType.isNull() &&
6930 (ReturnType->isIntegerType() || ReturnType->isBooleanType())) ||
6931 (ReturnType.isNull() &&
6932 (Property->getType()->isIntegerType() ||
6933 Property->getType()->isBooleanType())))) {
6934 std::string SelectorName = (Twine("is") + UpperKey).str();
6935 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6936 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6937 .second) {
6938 if (ReturnType.isNull()) {
6939 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6940 Builder.AddTextChunk("BOOL");
6941 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6942 }
6943
6944 Builder.AddTypedTextChunk(
6945 Allocator.CopyString(SelectorId->getName()));
6946 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6947 CXCursor_ObjCInstanceMethodDecl));
6948 }
6949 }
6950
6951 // Add the normal mutator.
6952 if (IsInstanceMethod && ReturnTypeMatchesVoid &&
6953 !Property->getSetterMethodDecl()) {
6954 std::string SelectorName = (Twine("set") + UpperKey).str();
6955 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6956 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6957 if (ReturnType.isNull()) {
6958 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6959 Builder.AddTextChunk("void");
6960 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6961 }
6962
6963 Builder.AddTypedTextChunk(
6964 Allocator.CopyString(SelectorId->getName()));
6965 Builder.AddTypedTextChunk(":");
6966 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6967 Context, Policy, Builder);
6968 Builder.AddTextChunk(Key);
6969 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6970 CXCursor_ObjCInstanceMethodDecl));
6971 }
6972 }
6973
6974 // Indexed and unordered accessors
6975 unsigned IndexedGetterPriority = CCP_CodePattern;
6976 unsigned IndexedSetterPriority = CCP_CodePattern;
6977 unsigned UnorderedGetterPriority = CCP_CodePattern;
6978 unsigned UnorderedSetterPriority = CCP_CodePattern;
6979 if (const ObjCObjectPointerType *ObjCPointer
6980 = Property->getType()->getAs<ObjCObjectPointerType>()) {
6981 if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) {
6982 // If this interface type is not provably derived from a known
6983 // collection, penalize the corresponding completions.
6984 if (!InheritsFromClassNamed(IFace, "NSMutableArray")) {
6985 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6986 if (!InheritsFromClassNamed(IFace, "NSArray"))
6987 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6988 }
6989
6990 if (!InheritsFromClassNamed(IFace, "NSMutableSet")) {
6991 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6992 if (!InheritsFromClassNamed(IFace, "NSSet"))
6993 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6994 }
6995 }
6996 } else {
6997 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6998 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6999 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
7000 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
7001 }
7002
7003 // Add -(NSUInteger)countOf<key>
7004 if (IsInstanceMethod &&
7005 (ReturnType.isNull() || ReturnType->isIntegerType())) {
7006 std::string SelectorName = (Twine("countOf") + UpperKey).str();
7007 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7008 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7009 .second) {
7010 if (ReturnType.isNull()) {
7011 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7012 Builder.AddTextChunk("NSUInteger");
7013 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7014 }
7015
7016 Builder.AddTypedTextChunk(
7017 Allocator.CopyString(SelectorId->getName()));
7018 Results.AddResult(Result(Builder.TakeString(),
7019 std::min(IndexedGetterPriority,
7020 UnorderedGetterPriority),
7021 CXCursor_ObjCInstanceMethodDecl));
7022 }
7023 }
7024
7025 // Indexed getters
7026 // Add -(id)objectInKeyAtIndex:(NSUInteger)index
7027 if (IsInstanceMethod &&
7028 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
7029 std::string SelectorName
7030 = (Twine("objectIn") + UpperKey + "AtIndex").str();
7031 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7032 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7033 if (ReturnType.isNull()) {
7034 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7035 Builder.AddTextChunk("id");
7036 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7037 }
7038
7039 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7040 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7041 Builder.AddTextChunk("NSUInteger");
7042 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7043 Builder.AddTextChunk("index");
7044 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
7045 CXCursor_ObjCInstanceMethodDecl));
7046 }
7047 }
7048
7049 // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes
7050 if (IsInstanceMethod &&
7051 (ReturnType.isNull() ||
7052 (ReturnType->isObjCObjectPointerType() &&
7053 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7054 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
7055 ->getName() == "NSArray"))) {
7056 std::string SelectorName
7057 = (Twine(Property->getName()) + "AtIndexes").str();
7058 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7059 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7060 if (ReturnType.isNull()) {
7061 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7062 Builder.AddTextChunk("NSArray *");
7063 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7064 }
7065
7066 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7067 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7068 Builder.AddTextChunk("NSIndexSet *");
7069 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7070 Builder.AddTextChunk("indexes");
7071 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
7072 CXCursor_ObjCInstanceMethodDecl));
7073 }
7074 }
7075
7076 // Add -(void)getKey:(type **)buffer range:(NSRange)inRange
7077 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7078 std::string SelectorName = (Twine("get") + UpperKey).str();
7079 IdentifierInfo *SelectorIds[2] = {
7080 &Context.Idents.get(SelectorName),
7081 &Context.Idents.get("range")
7082 };
7083
7084 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7085 if (ReturnType.isNull()) {
7086 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7087 Builder.AddTextChunk("void");
7088 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7089 }
7090
7091 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7092 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7093 Builder.AddPlaceholderChunk("object-type");
7094 Builder.AddTextChunk(" **");
7095 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7096 Builder.AddTextChunk("buffer");
7097 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7098 Builder.AddTypedTextChunk("range:");
7099 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7100 Builder.AddTextChunk("NSRange");
7101 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7102 Builder.AddTextChunk("inRange");
7103 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
7104 CXCursor_ObjCInstanceMethodDecl));
7105 }
7106 }
7107
7108 // Mutable indexed accessors
7109
7110 // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index
7111 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7112 std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str();
7113 IdentifierInfo *SelectorIds[2] = {
7114 &Context.Idents.get("insertObject"),
7115 &Context.Idents.get(SelectorName)
7116 };
7117
7118 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7119 if (ReturnType.isNull()) {
7120 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7121 Builder.AddTextChunk("void");
7122 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7123 }
7124
7125 Builder.AddTypedTextChunk("insertObject:");
7126 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7127 Builder.AddPlaceholderChunk("object-type");
7128 Builder.AddTextChunk(" *");
7129 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7130 Builder.AddTextChunk("object");
7131 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7132 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7133 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7134 Builder.AddPlaceholderChunk("NSUInteger");
7135 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7136 Builder.AddTextChunk("index");
7137 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7138 CXCursor_ObjCInstanceMethodDecl));
7139 }
7140 }
7141
7142 // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes
7143 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7144 std::string SelectorName = (Twine("insert") + UpperKey).str();
7145 IdentifierInfo *SelectorIds[2] = {
7146 &Context.Idents.get(SelectorName),
7147 &Context.Idents.get("atIndexes")
7148 };
7149
7150 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7151 if (ReturnType.isNull()) {
7152 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7153 Builder.AddTextChunk("void");
7154 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7155 }
7156
7157 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7158 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7159 Builder.AddTextChunk("NSArray *");
7160 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7161 Builder.AddTextChunk("array");
7162 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7163 Builder.AddTypedTextChunk("atIndexes:");
7164 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7165 Builder.AddPlaceholderChunk("NSIndexSet *");
7166 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7167 Builder.AddTextChunk("indexes");
7168 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7169 CXCursor_ObjCInstanceMethodDecl));
7170 }
7171 }
7172
7173 // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index
7174 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7175 std::string SelectorName
7176 = (Twine("removeObjectFrom") + UpperKey + "AtIndex").str();
7177 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7178 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7179 if (ReturnType.isNull()) {
7180 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7181 Builder.AddTextChunk("void");
7182 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7183 }
7184
7185 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7186 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7187 Builder.AddTextChunk("NSUInteger");
7188 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7189 Builder.AddTextChunk("index");
7190 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7191 CXCursor_ObjCInstanceMethodDecl));
7192 }
7193 }
7194
7195 // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes
7196 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7197 std::string SelectorName
7198 = (Twine("remove") + UpperKey + "AtIndexes").str();
7199 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7200 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7201 if (ReturnType.isNull()) {
7202 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7203 Builder.AddTextChunk("void");
7204 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7205 }
7206
7207 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7208 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7209 Builder.AddTextChunk("NSIndexSet *");
7210 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7211 Builder.AddTextChunk("indexes");
7212 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7213 CXCursor_ObjCInstanceMethodDecl));
7214 }
7215 }
7216
7217 // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object
7218 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7219 std::string SelectorName
7220 = (Twine("replaceObjectIn") + UpperKey + "AtIndex").str();
7221 IdentifierInfo *SelectorIds[2] = {
7222 &Context.Idents.get(SelectorName),
7223 &Context.Idents.get("withObject")
7224 };
7225
7226 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7227 if (ReturnType.isNull()) {
7228 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7229 Builder.AddTextChunk("void");
7230 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7231 }
7232
7233 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7234 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7235 Builder.AddPlaceholderChunk("NSUInteger");
7236 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7237 Builder.AddTextChunk("index");
7238 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7239 Builder.AddTypedTextChunk("withObject:");
7240 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7241 Builder.AddTextChunk("id");
7242 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7243 Builder.AddTextChunk("object");
7244 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7245 CXCursor_ObjCInstanceMethodDecl));
7246 }
7247 }
7248
7249 // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array
7250 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7251 std::string SelectorName1
7252 = (Twine("replace") + UpperKey + "AtIndexes").str();
7253 std::string SelectorName2 = (Twine("with") + UpperKey).str();
7254 IdentifierInfo *SelectorIds[2] = {
7255 &Context.Idents.get(SelectorName1),
7256 &Context.Idents.get(SelectorName2)
7257 };
7258
7259 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7260 if (ReturnType.isNull()) {
7261 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7262 Builder.AddTextChunk("void");
7263 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7264 }
7265
7266 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName1 + ":"));
7267 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7268 Builder.AddPlaceholderChunk("NSIndexSet *");
7269 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7270 Builder.AddTextChunk("indexes");
7271 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7272 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":"));
7273 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7274 Builder.AddTextChunk("NSArray *");
7275 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7276 Builder.AddTextChunk("array");
7277 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7278 CXCursor_ObjCInstanceMethodDecl));
7279 }
7280 }
7281
7282 // Unordered getters
7283 // - (NSEnumerator *)enumeratorOfKey
7284 if (IsInstanceMethod &&
7285 (ReturnType.isNull() ||
7286 (ReturnType->isObjCObjectPointerType() &&
7287 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7288 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
7289 ->getName() == "NSEnumerator"))) {
7290 std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str();
7291 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7292 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7293 .second) {
7294 if (ReturnType.isNull()) {
7295 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7296 Builder.AddTextChunk("NSEnumerator *");
7297 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7298 }
7299
7300 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7301 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
7302 CXCursor_ObjCInstanceMethodDecl));
7303 }
7304 }
7305
7306 // - (type *)memberOfKey:(type *)object
7307 if (IsInstanceMethod &&
7308 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
7309 std::string SelectorName = (Twine("memberOf") + UpperKey).str();
7310 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7311 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7312 if (ReturnType.isNull()) {
7313 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7314 Builder.AddPlaceholderChunk("object-type");
7315 Builder.AddTextChunk(" *");
7316 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7317 }
7318
7319 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7320 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7321 if (ReturnType.isNull()) {
7322 Builder.AddPlaceholderChunk("object-type");
7323 Builder.AddTextChunk(" *");
7324 } else {
7325 Builder.AddTextChunk(GetCompletionTypeString(ReturnType, Context,
7326 Policy,
7327 Builder.getAllocator()));
7328 }
7329 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7330 Builder.AddTextChunk("object");
7331 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
7332 CXCursor_ObjCInstanceMethodDecl));
7333 }
7334 }
7335
7336 // Mutable unordered accessors
7337 // - (void)addKeyObject:(type *)object
7338 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7339 std::string SelectorName
7340 = (Twine("add") + UpperKey + Twine("Object")).str();
7341 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7342 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7343 if (ReturnType.isNull()) {
7344 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7345 Builder.AddTextChunk("void");
7346 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7347 }
7348
7349 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7350 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7351 Builder.AddPlaceholderChunk("object-type");
7352 Builder.AddTextChunk(" *");
7353 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7354 Builder.AddTextChunk("object");
7355 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7356 CXCursor_ObjCInstanceMethodDecl));
7357 }
7358 }
7359
7360 // - (void)addKey:(NSSet *)objects
7361 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7362 std::string SelectorName = (Twine("add") + UpperKey).str();
7363 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7364 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7365 if (ReturnType.isNull()) {
7366 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7367 Builder.AddTextChunk("void");
7368 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7369 }
7370
7371 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7372 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7373 Builder.AddTextChunk("NSSet *");
7374 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7375 Builder.AddTextChunk("objects");
7376 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7377 CXCursor_ObjCInstanceMethodDecl));
7378 }
7379 }
7380
7381 // - (void)removeKeyObject:(type *)object
7382 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7383 std::string SelectorName
7384 = (Twine("remove") + UpperKey + Twine("Object")).str();
7385 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7386 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7387 if (ReturnType.isNull()) {
7388 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7389 Builder.AddTextChunk("void");
7390 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7391 }
7392
7393 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7394 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7395 Builder.AddPlaceholderChunk("object-type");
7396 Builder.AddTextChunk(" *");
7397 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7398 Builder.AddTextChunk("object");
7399 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7400 CXCursor_ObjCInstanceMethodDecl));
7401 }
7402 }
7403
7404 // - (void)removeKey:(NSSet *)objects
7405 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7406 std::string SelectorName = (Twine("remove") + UpperKey).str();
7407 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7408 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7409 if (ReturnType.isNull()) {
7410 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7411 Builder.AddTextChunk("void");
7412 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7413 }
7414
7415 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7416 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7417 Builder.AddTextChunk("NSSet *");
7418 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7419 Builder.AddTextChunk("objects");
7420 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7421 CXCursor_ObjCInstanceMethodDecl));
7422 }
7423 }
7424
7425 // - (void)intersectKey:(NSSet *)objects
7426 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7427 std::string SelectorName = (Twine("intersect") + UpperKey).str();
7428 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7429 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7430 if (ReturnType.isNull()) {
7431 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7432 Builder.AddTextChunk("void");
7433 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7434 }
7435
7436 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7437 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7438 Builder.AddTextChunk("NSSet *");
7439 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7440 Builder.AddTextChunk("objects");
7441 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7442 CXCursor_ObjCInstanceMethodDecl));
7443 }
7444 }
7445
7446 // Key-Value Observing
7447 // + (NSSet *)keyPathsForValuesAffectingKey
7448 if (!IsInstanceMethod &&
7449 (ReturnType.isNull() ||
7450 (ReturnType->isObjCObjectPointerType() &&
7451 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7452 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
7453 ->getName() == "NSSet"))) {
7454 std::string SelectorName
7455 = (Twine("keyPathsForValuesAffecting") + UpperKey).str();
7456 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7457 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7458 .second) {
7459 if (ReturnType.isNull()) {
7460 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7461 Builder.AddTextChunk("NSSet<NSString *> *");
7462 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7463 }
7464
7465 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7466 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7467 CXCursor_ObjCClassMethodDecl));
7468 }
7469 }
7470
7471 // + (BOOL)automaticallyNotifiesObserversForKey
7472 if (!IsInstanceMethod &&
7473 (ReturnType.isNull() ||
7474 ReturnType->isIntegerType() ||
7475 ReturnType->isBooleanType())) {
7476 std::string SelectorName
7477 = (Twine("automaticallyNotifiesObserversOf") + UpperKey).str();
7478 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7479 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7480 .second) {
7481 if (ReturnType.isNull()) {
7482 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7483 Builder.AddTextChunk("BOOL");
7484 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7485 }
7486
7487 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7488 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7489 CXCursor_ObjCClassMethodDecl));
7490 }
7491 }
7492 }
7493
CodeCompleteObjCMethodDecl(Scope * S,Optional<bool> IsInstanceMethod,ParsedType ReturnTy)7494 void Sema::CodeCompleteObjCMethodDecl(Scope *S, Optional<bool> IsInstanceMethod,
7495 ParsedType ReturnTy) {
7496 // Determine the return type of the method we're declaring, if
7497 // provided.
7498 QualType ReturnType = GetTypeFromParser(ReturnTy);
7499 Decl *IDecl = nullptr;
7500 if (CurContext->isObjCContainer()) {
7501 ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
7502 IDecl = OCD;
7503 }
7504 // Determine where we should start searching for methods.
7505 ObjCContainerDecl *SearchDecl = nullptr;
7506 bool IsInImplementation = false;
7507 if (Decl *D = IDecl) {
7508 if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) {
7509 SearchDecl = Impl->getClassInterface();
7510 IsInImplementation = true;
7511 } else if (ObjCCategoryImplDecl *CatImpl
7512 = dyn_cast<ObjCCategoryImplDecl>(D)) {
7513 SearchDecl = CatImpl->getCategoryDecl();
7514 IsInImplementation = true;
7515 } else
7516 SearchDecl = dyn_cast<ObjCContainerDecl>(D);
7517 }
7518
7519 if (!SearchDecl && S) {
7520 if (DeclContext *DC = S->getEntity())
7521 SearchDecl = dyn_cast<ObjCContainerDecl>(DC);
7522 }
7523
7524 if (!SearchDecl) {
7525 HandleCodeCompleteResults(this, CodeCompleter,
7526 CodeCompletionContext::CCC_Other,
7527 nullptr, 0);
7528 return;
7529 }
7530
7531 // Find all of the methods that we could declare/implement here.
7532 KnownMethodsMap KnownMethods;
7533 FindImplementableMethods(Context, SearchDecl, IsInstanceMethod,
7534 ReturnType, KnownMethods);
7535
7536 // Add declarations or definitions for each of the known methods.
7537 typedef CodeCompletionResult Result;
7538 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7539 CodeCompleter->getCodeCompletionTUInfo(),
7540 CodeCompletionContext::CCC_Other);
7541 Results.EnterNewScope();
7542 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
7543 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7544 MEnd = KnownMethods.end();
7545 M != MEnd; ++M) {
7546 ObjCMethodDecl *Method = M->second.getPointer();
7547 CodeCompletionBuilder Builder(Results.getAllocator(),
7548 Results.getCodeCompletionTUInfo());
7549
7550 // Add the '-'/'+' prefix if it wasn't provided yet.
7551 if (!IsInstanceMethod) {
7552 Builder.AddTextChunk(Method->isInstanceMethod() ? "-" : "+");
7553 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7554 }
7555
7556 // If the result type was not already provided, add it to the
7557 // pattern as (type).
7558 if (ReturnType.isNull()) {
7559 QualType ResTy = Method->getSendResultType().stripObjCKindOfType(Context);
7560 AttributedType::stripOuterNullability(ResTy);
7561 AddObjCPassingTypeChunk(ResTy,
7562 Method->getObjCDeclQualifier(), Context, Policy,
7563 Builder);
7564 }
7565
7566 Selector Sel = Method->getSelector();
7567
7568 // Add the first part of the selector to the pattern.
7569 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7570 Sel.getNameForSlot(0)));
7571
7572 // Add parameters to the pattern.
7573 unsigned I = 0;
7574 for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
7575 PEnd = Method->param_end();
7576 P != PEnd; (void)++P, ++I) {
7577 // Add the part of the selector name.
7578 if (I == 0)
7579 Builder.AddTypedTextChunk(":");
7580 else if (I < Sel.getNumArgs()) {
7581 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7582 Builder.AddTypedTextChunk(
7583 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
7584 } else
7585 break;
7586
7587 // Add the parameter type.
7588 QualType ParamType;
7589 if ((*P)->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
7590 ParamType = (*P)->getType();
7591 else
7592 ParamType = (*P)->getOriginalType();
7593 ParamType = ParamType.substObjCTypeArgs(Context, {},
7594 ObjCSubstitutionContext::Parameter);
7595 AttributedType::stripOuterNullability(ParamType);
7596 AddObjCPassingTypeChunk(ParamType,
7597 (*P)->getObjCDeclQualifier(),
7598 Context, Policy,
7599 Builder);
7600
7601 if (IdentifierInfo *Id = (*P)->getIdentifier())
7602 Builder.AddTextChunk(Builder.getAllocator().CopyString( Id->getName()));
7603 }
7604
7605 if (Method->isVariadic()) {
7606 if (Method->param_size() > 0)
7607 Builder.AddChunk(CodeCompletionString::CK_Comma);
7608 Builder.AddTextChunk("...");
7609 }
7610
7611 if (IsInImplementation && Results.includeCodePatterns()) {
7612 // We will be defining the method here, so add a compound statement.
7613 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7614 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
7615 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
7616 if (!Method->getReturnType()->isVoidType()) {
7617 // If the result type is not void, add a return clause.
7618 Builder.AddTextChunk("return");
7619 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7620 Builder.AddPlaceholderChunk("expression");
7621 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
7622 } else
7623 Builder.AddPlaceholderChunk("statements");
7624
7625 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
7626 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
7627 }
7628
7629 unsigned Priority = CCP_CodePattern;
7630 if (!M->second.getInt())
7631 Priority += CCD_InBaseClass;
7632
7633 Results.AddResult(Result(Builder.TakeString(), Method, Priority));
7634 }
7635
7636 // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of
7637 // the properties in this class and its categories.
7638 if (Context.getLangOpts().ObjC2) {
7639 SmallVector<ObjCContainerDecl *, 4> Containers;
7640 Containers.push_back(SearchDecl);
7641
7642 VisitedSelectorSet KnownSelectors;
7643 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7644 MEnd = KnownMethods.end();
7645 M != MEnd; ++M)
7646 KnownSelectors.insert(M->first);
7647
7648
7649 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl);
7650 if (!IFace)
7651 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl))
7652 IFace = Category->getClassInterface();
7653
7654 if (IFace)
7655 for (auto *Cat : IFace->visible_categories())
7656 Containers.push_back(Cat);
7657
7658 if (IsInstanceMethod) {
7659 for (unsigned I = 0, N = Containers.size(); I != N; ++I)
7660 for (auto *P : Containers[I]->instance_properties())
7661 AddObjCKeyValueCompletions(P, *IsInstanceMethod, ReturnType, Context,
7662 KnownSelectors, Results);
7663 }
7664 }
7665
7666 Results.ExitScope();
7667
7668 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7669 Results.data(), Results.size());
7670 }
7671
CodeCompleteObjCMethodDeclSelector(Scope * S,bool IsInstanceMethod,bool AtParameterName,ParsedType ReturnTy,ArrayRef<IdentifierInfo * > SelIdents)7672 void Sema::CodeCompleteObjCMethodDeclSelector(Scope *S,
7673 bool IsInstanceMethod,
7674 bool AtParameterName,
7675 ParsedType ReturnTy,
7676 ArrayRef<IdentifierInfo *> SelIdents) {
7677 // If we have an external source, load the entire class method
7678 // pool from the AST file.
7679 if (ExternalSource) {
7680 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
7681 I != N; ++I) {
7682 Selector Sel = ExternalSource->GetExternalSelector(I);
7683 if (Sel.isNull() || MethodPool.count(Sel))
7684 continue;
7685
7686 ReadMethodPool(Sel);
7687 }
7688 }
7689
7690 // Build the set of methods we can see.
7691 typedef CodeCompletionResult Result;
7692 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7693 CodeCompleter->getCodeCompletionTUInfo(),
7694 CodeCompletionContext::CCC_Other);
7695
7696 if (ReturnTy)
7697 Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType());
7698
7699 Results.EnterNewScope();
7700 for (GlobalMethodPool::iterator M = MethodPool.begin(),
7701 MEnd = MethodPool.end();
7702 M != MEnd; ++M) {
7703 for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first :
7704 &M->second.second;
7705 MethList && MethList->getMethod();
7706 MethList = MethList->getNext()) {
7707 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
7708 continue;
7709
7710 if (AtParameterName) {
7711 // Suggest parameter names we've seen before.
7712 unsigned NumSelIdents = SelIdents.size();
7713 if (NumSelIdents &&
7714 NumSelIdents <= MethList->getMethod()->param_size()) {
7715 ParmVarDecl *Param =
7716 MethList->getMethod()->parameters()[NumSelIdents - 1];
7717 if (Param->getIdentifier()) {
7718 CodeCompletionBuilder Builder(Results.getAllocator(),
7719 Results.getCodeCompletionTUInfo());
7720 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7721 Param->getIdentifier()->getName()));
7722 Results.AddResult(Builder.TakeString());
7723 }
7724 }
7725
7726 continue;
7727 }
7728
7729 Result R(MethList->getMethod(),
7730 Results.getBasePriority(MethList->getMethod()), nullptr);
7731 R.StartParameter = SelIdents.size();
7732 R.AllParametersAreInformative = false;
7733 R.DeclaringEntity = true;
7734 Results.MaybeAddResult(R, CurContext);
7735 }
7736 }
7737
7738 Results.ExitScope();
7739
7740 if (!AtParameterName && !SelIdents.empty() &&
7741 SelIdents.front()->getName().startswith("init")) {
7742 for (const auto &M : PP.macros()) {
7743 if (M.first->getName() != "NS_DESIGNATED_INITIALIZER")
7744 continue;
7745 Results.EnterNewScope();
7746 CodeCompletionBuilder Builder(Results.getAllocator(),
7747 Results.getCodeCompletionTUInfo());
7748 Builder.AddTypedTextChunk(
7749 Builder.getAllocator().CopyString(M.first->getName()));
7750 Results.AddResult(CodeCompletionResult(Builder.TakeString(), CCP_Macro,
7751 CXCursor_MacroDefinition));
7752 Results.ExitScope();
7753 }
7754 }
7755
7756 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7757 Results.data(), Results.size());
7758 }
7759
CodeCompletePreprocessorDirective(bool InConditional)7760 void Sema::CodeCompletePreprocessorDirective(bool InConditional) {
7761 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7762 CodeCompleter->getCodeCompletionTUInfo(),
7763 CodeCompletionContext::CCC_PreprocessorDirective);
7764 Results.EnterNewScope();
7765
7766 // #if <condition>
7767 CodeCompletionBuilder Builder(Results.getAllocator(),
7768 Results.getCodeCompletionTUInfo());
7769 Builder.AddTypedTextChunk("if");
7770 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7771 Builder.AddPlaceholderChunk("condition");
7772 Results.AddResult(Builder.TakeString());
7773
7774 // #ifdef <macro>
7775 Builder.AddTypedTextChunk("ifdef");
7776 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7777 Builder.AddPlaceholderChunk("macro");
7778 Results.AddResult(Builder.TakeString());
7779
7780 // #ifndef <macro>
7781 Builder.AddTypedTextChunk("ifndef");
7782 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7783 Builder.AddPlaceholderChunk("macro");
7784 Results.AddResult(Builder.TakeString());
7785
7786 if (InConditional) {
7787 // #elif <condition>
7788 Builder.AddTypedTextChunk("elif");
7789 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7790 Builder.AddPlaceholderChunk("condition");
7791 Results.AddResult(Builder.TakeString());
7792
7793 // #else
7794 Builder.AddTypedTextChunk("else");
7795 Results.AddResult(Builder.TakeString());
7796
7797 // #endif
7798 Builder.AddTypedTextChunk("endif");
7799 Results.AddResult(Builder.TakeString());
7800 }
7801
7802 // #include "header"
7803 Builder.AddTypedTextChunk("include");
7804 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7805 Builder.AddTextChunk("\"");
7806 Builder.AddPlaceholderChunk("header");
7807 Builder.AddTextChunk("\"");
7808 Results.AddResult(Builder.TakeString());
7809
7810 // #include <header>
7811 Builder.AddTypedTextChunk("include");
7812 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7813 Builder.AddTextChunk("<");
7814 Builder.AddPlaceholderChunk("header");
7815 Builder.AddTextChunk(">");
7816 Results.AddResult(Builder.TakeString());
7817
7818 // #define <macro>
7819 Builder.AddTypedTextChunk("define");
7820 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7821 Builder.AddPlaceholderChunk("macro");
7822 Results.AddResult(Builder.TakeString());
7823
7824 // #define <macro>(<args>)
7825 Builder.AddTypedTextChunk("define");
7826 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7827 Builder.AddPlaceholderChunk("macro");
7828 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7829 Builder.AddPlaceholderChunk("args");
7830 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7831 Results.AddResult(Builder.TakeString());
7832
7833 // #undef <macro>
7834 Builder.AddTypedTextChunk("undef");
7835 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7836 Builder.AddPlaceholderChunk("macro");
7837 Results.AddResult(Builder.TakeString());
7838
7839 // #line <number>
7840 Builder.AddTypedTextChunk("line");
7841 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7842 Builder.AddPlaceholderChunk("number");
7843 Results.AddResult(Builder.TakeString());
7844
7845 // #line <number> "filename"
7846 Builder.AddTypedTextChunk("line");
7847 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7848 Builder.AddPlaceholderChunk("number");
7849 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7850 Builder.AddTextChunk("\"");
7851 Builder.AddPlaceholderChunk("filename");
7852 Builder.AddTextChunk("\"");
7853 Results.AddResult(Builder.TakeString());
7854
7855 // #error <message>
7856 Builder.AddTypedTextChunk("error");
7857 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7858 Builder.AddPlaceholderChunk("message");
7859 Results.AddResult(Builder.TakeString());
7860
7861 // #pragma <arguments>
7862 Builder.AddTypedTextChunk("pragma");
7863 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7864 Builder.AddPlaceholderChunk("arguments");
7865 Results.AddResult(Builder.TakeString());
7866
7867 if (getLangOpts().ObjC1) {
7868 // #import "header"
7869 Builder.AddTypedTextChunk("import");
7870 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7871 Builder.AddTextChunk("\"");
7872 Builder.AddPlaceholderChunk("header");
7873 Builder.AddTextChunk("\"");
7874 Results.AddResult(Builder.TakeString());
7875
7876 // #import <header>
7877 Builder.AddTypedTextChunk("import");
7878 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7879 Builder.AddTextChunk("<");
7880 Builder.AddPlaceholderChunk("header");
7881 Builder.AddTextChunk(">");
7882 Results.AddResult(Builder.TakeString());
7883 }
7884
7885 // #include_next "header"
7886 Builder.AddTypedTextChunk("include_next");
7887 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7888 Builder.AddTextChunk("\"");
7889 Builder.AddPlaceholderChunk("header");
7890 Builder.AddTextChunk("\"");
7891 Results.AddResult(Builder.TakeString());
7892
7893 // #include_next <header>
7894 Builder.AddTypedTextChunk("include_next");
7895 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7896 Builder.AddTextChunk("<");
7897 Builder.AddPlaceholderChunk("header");
7898 Builder.AddTextChunk(">");
7899 Results.AddResult(Builder.TakeString());
7900
7901 // #warning <message>
7902 Builder.AddTypedTextChunk("warning");
7903 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7904 Builder.AddPlaceholderChunk("message");
7905 Results.AddResult(Builder.TakeString());
7906
7907 // Note: #ident and #sccs are such crazy anachronisms that we don't provide
7908 // completions for them. And __include_macros is a Clang-internal extension
7909 // that we don't want to encourage anyone to use.
7910
7911 // FIXME: we don't support #assert or #unassert, so don't suggest them.
7912 Results.ExitScope();
7913
7914 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7915 Results.data(), Results.size());
7916 }
7917
CodeCompleteInPreprocessorConditionalExclusion(Scope * S)7918 void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) {
7919 CodeCompleteOrdinaryName(S,
7920 S->getFnParent()? Sema::PCC_RecoveryInFunction
7921 : Sema::PCC_Namespace);
7922 }
7923
CodeCompletePreprocessorMacroName(bool IsDefinition)7924 void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) {
7925 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7926 CodeCompleter->getCodeCompletionTUInfo(),
7927 IsDefinition? CodeCompletionContext::CCC_MacroName
7928 : CodeCompletionContext::CCC_MacroNameUse);
7929 if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) {
7930 // Add just the names of macros, not their arguments.
7931 CodeCompletionBuilder Builder(Results.getAllocator(),
7932 Results.getCodeCompletionTUInfo());
7933 Results.EnterNewScope();
7934 for (Preprocessor::macro_iterator M = PP.macro_begin(),
7935 MEnd = PP.macro_end();
7936 M != MEnd; ++M) {
7937 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7938 M->first->getName()));
7939 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
7940 CCP_CodePattern,
7941 CXCursor_MacroDefinition));
7942 }
7943 Results.ExitScope();
7944 } else if (IsDefinition) {
7945 // FIXME: Can we detect when the user just wrote an include guard above?
7946 }
7947
7948 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7949 Results.data(), Results.size());
7950 }
7951
CodeCompletePreprocessorExpression()7952 void Sema::CodeCompletePreprocessorExpression() {
7953 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7954 CodeCompleter->getCodeCompletionTUInfo(),
7955 CodeCompletionContext::CCC_PreprocessorExpression);
7956
7957 if (!CodeCompleter || CodeCompleter->includeMacros())
7958 AddMacroResults(PP, Results, true);
7959
7960 // defined (<macro>)
7961 Results.EnterNewScope();
7962 CodeCompletionBuilder Builder(Results.getAllocator(),
7963 Results.getCodeCompletionTUInfo());
7964 Builder.AddTypedTextChunk("defined");
7965 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7966 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7967 Builder.AddPlaceholderChunk("macro");
7968 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7969 Results.AddResult(Builder.TakeString());
7970 Results.ExitScope();
7971
7972 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7973 Results.data(), Results.size());
7974 }
7975
CodeCompletePreprocessorMacroArgument(Scope * S,IdentifierInfo * Macro,MacroInfo * MacroInfo,unsigned Argument)7976 void Sema::CodeCompletePreprocessorMacroArgument(Scope *S,
7977 IdentifierInfo *Macro,
7978 MacroInfo *MacroInfo,
7979 unsigned Argument) {
7980 // FIXME: In the future, we could provide "overload" results, much like we
7981 // do for function calls.
7982
7983 // Now just ignore this. There will be another code-completion callback
7984 // for the expanded tokens.
7985 }
7986
CodeCompleteNaturalLanguage()7987 void Sema::CodeCompleteNaturalLanguage() {
7988 HandleCodeCompleteResults(this, CodeCompleter,
7989 CodeCompletionContext::CCC_NaturalLanguage,
7990 nullptr, 0);
7991 }
7992
CodeCompleteAvailabilityPlatformName()7993 void Sema::CodeCompleteAvailabilityPlatformName() {
7994 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7995 CodeCompleter->getCodeCompletionTUInfo(),
7996 CodeCompletionContext::CCC_Other);
7997 Results.EnterNewScope();
7998 static const char *Platforms[] = {"macOS", "iOS", "watchOS", "tvOS"};
7999 for (const char *Platform : llvm::makeArrayRef(Platforms)) {
8000 Results.AddResult(CodeCompletionResult(Platform));
8001 Results.AddResult(CodeCompletionResult(Results.getAllocator().CopyString(
8002 Twine(Platform) + "ApplicationExtension")));
8003 }
8004 Results.ExitScope();
8005 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8006 Results.data(), Results.size());
8007 }
8008
GatherGlobalCodeCompletions(CodeCompletionAllocator & Allocator,CodeCompletionTUInfo & CCTUInfo,SmallVectorImpl<CodeCompletionResult> & Results)8009 void Sema::GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,
8010 CodeCompletionTUInfo &CCTUInfo,
8011 SmallVectorImpl<CodeCompletionResult> &Results) {
8012 ResultBuilder Builder(*this, Allocator, CCTUInfo,
8013 CodeCompletionContext::CCC_Recovery);
8014 if (!CodeCompleter || CodeCompleter->includeGlobals()) {
8015 CodeCompletionDeclConsumer Consumer(Builder,
8016 Context.getTranslationUnitDecl());
8017 LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName,
8018 Consumer,
8019 !CodeCompleter || CodeCompleter->loadExternal());
8020 }
8021
8022 if (!CodeCompleter || CodeCompleter->includeMacros())
8023 AddMacroResults(PP, Builder, true);
8024
8025 Results.clear();
8026 Results.insert(Results.end(),
8027 Builder.data(), Builder.data() + Builder.size());
8028 }
8029