Bug Summary

File:tools/clang/lib/Sema/SemaCodeComplete.cpp
Warning:line 6551, column 13
Dereference of null pointer

Annotated Source Code

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