blob: 623e68b8a5a31bf1647c25d777e0aa19c91aec9d [file] [log] [blame]
Douglas Gregor81b747b2009-09-17 21:32:03 +00001//===---------------- 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//===----------------------------------------------------------------------===//
John McCall2d887082010-08-25 22:03:47 +000013#include "clang/Sema/SemaInternal.h"
Douglas Gregore737f502010-08-12 20:07:10 +000014#include "clang/Sema/Lookup.h"
John McCall120d63c2010-08-24 20:38:10 +000015#include "clang/Sema/Overload.h"
Douglas Gregor81b747b2009-09-17 21:32:03 +000016#include "clang/Sema/CodeCompleteConsumer.h"
Douglas Gregor719770d2010-04-06 17:30:22 +000017#include "clang/Sema/ExternalSemaSource.h"
John McCall5f1e0942010-08-24 08:50:51 +000018#include "clang/Sema/Scope.h"
John McCall781472f2010-08-25 08:40:02 +000019#include "clang/Sema/ScopeInfo.h"
John McCall7cd088e2010-08-24 07:21:54 +000020#include "clang/AST/DeclObjC.h"
Douglas Gregorb9d0ef72009-09-21 19:57:38 +000021#include "clang/AST/ExprCXX.h"
Douglas Gregor24a069f2009-11-17 17:59:40 +000022#include "clang/AST/ExprObjC.h"
Douglas Gregor3f7c7f42009-10-30 16:50:04 +000023#include "clang/Lex/MacroInfo.h"
24#include "clang/Lex/Preprocessor.h"
Douglas Gregord36adf52010-09-16 16:06:31 +000025#include "llvm/ADT/DenseSet.h"
Douglas Gregor86d9a522009-09-21 16:56:56 +000026#include "llvm/ADT/SmallPtrSet.h"
Douglas Gregor6a684032009-09-28 03:51:44 +000027#include "llvm/ADT/StringExtras.h"
Douglas Gregor22f56992010-04-06 19:22:33 +000028#include "llvm/ADT/StringSwitch.h"
Douglas Gregor458433d2010-08-26 15:07:07 +000029#include "llvm/ADT/Twine.h"
Douglas Gregor86d9a522009-09-21 16:56:56 +000030#include <list>
31#include <map>
32#include <vector>
Douglas Gregor81b747b2009-09-17 21:32:03 +000033
34using namespace clang;
John McCall781472f2010-08-25 08:40:02 +000035using namespace sema;
Douglas Gregor81b747b2009-09-17 21:32:03 +000036
Douglas Gregor86d9a522009-09-21 16:56:56 +000037namespace {
38 /// \brief A container of code-completion results.
39 class ResultBuilder {
40 public:
41 /// \brief The type of a name-lookup filter, which can be provided to the
42 /// name-lookup routines to specify which declarations should be included in
43 /// the result set (when it returns true) and which declarations should be
44 /// filtered out (returns false).
45 typedef bool (ResultBuilder::*LookupFilter)(NamedDecl *) const;
46
John McCall0a2c5e22010-08-25 06:19:51 +000047 typedef CodeCompletionResult Result;
Douglas Gregor86d9a522009-09-21 16:56:56 +000048
49 private:
50 /// \brief The actual results we have found.
51 std::vector<Result> Results;
52
53 /// \brief A record of all of the declarations we have found and placed
54 /// into the result set, used to ensure that no declaration ever gets into
55 /// the result set twice.
56 llvm::SmallPtrSet<Decl*, 16> AllDeclsFound;
57
Douglas Gregorfbcb5d62009-12-06 20:23:50 +000058 typedef std::pair<NamedDecl *, unsigned> DeclIndexPair;
59
60 /// \brief An entry in the shadow map, which is optimized to store
61 /// a single (declaration, index) mapping (the common case) but
62 /// can also store a list of (declaration, index) mappings.
63 class ShadowMapEntry {
Chris Lattner5f9e2722011-07-23 10:55:15 +000064 typedef SmallVector<DeclIndexPair, 4> DeclIndexPairVector;
Douglas Gregorfbcb5d62009-12-06 20:23:50 +000065
66 /// \brief Contains either the solitary NamedDecl * or a vector
67 /// of (declaration, index) pairs.
68 llvm::PointerUnion<NamedDecl *, DeclIndexPairVector*> DeclOrVector;
69
70 /// \brief When the entry contains a single declaration, this is
71 /// the index associated with that entry.
72 unsigned SingleDeclIndex;
73
74 public:
75 ShadowMapEntry() : DeclOrVector(), SingleDeclIndex(0) { }
76
77 void Add(NamedDecl *ND, unsigned Index) {
78 if (DeclOrVector.isNull()) {
79 // 0 - > 1 elements: just set the single element information.
80 DeclOrVector = ND;
81 SingleDeclIndex = Index;
82 return;
83 }
84
85 if (NamedDecl *PrevND = DeclOrVector.dyn_cast<NamedDecl *>()) {
86 // 1 -> 2 elements: create the vector of results and push in the
87 // existing declaration.
88 DeclIndexPairVector *Vec = new DeclIndexPairVector;
89 Vec->push_back(DeclIndexPair(PrevND, SingleDeclIndex));
90 DeclOrVector = Vec;
91 }
92
93 // Add the new element to the end of the vector.
94 DeclOrVector.get<DeclIndexPairVector*>()->push_back(
95 DeclIndexPair(ND, Index));
96 }
97
98 void Destroy() {
99 if (DeclIndexPairVector *Vec
100 = DeclOrVector.dyn_cast<DeclIndexPairVector *>()) {
101 delete Vec;
102 DeclOrVector = ((NamedDecl *)0);
103 }
104 }
105
106 // Iteration.
107 class iterator;
108 iterator begin() const;
109 iterator end() const;
110 };
111
Douglas Gregor86d9a522009-09-21 16:56:56 +0000112 /// \brief A mapping from declaration names to the declarations that have
113 /// this name within a particular scope and their index within the list of
114 /// results.
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000115 typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;
Douglas Gregor86d9a522009-09-21 16:56:56 +0000116
117 /// \brief The semantic analysis object for which results are being
118 /// produced.
119 Sema &SemaRef;
Douglas Gregor218937c2011-02-01 19:23:04 +0000120
121 /// \brief The allocator used to allocate new code-completion strings.
Douglas Gregordae68752011-02-01 22:57:45 +0000122 CodeCompletionAllocator &Allocator;
Douglas Gregor86d9a522009-09-21 16:56:56 +0000123
124 /// \brief If non-NULL, a filter function used to remove any code-completion
125 /// results that are not desirable.
126 LookupFilter Filter;
Douglas Gregor45bcd432010-01-14 03:21:49 +0000127
128 /// \brief Whether we should allow declarations as
129 /// nested-name-specifiers that would otherwise be filtered out.
130 bool AllowNestedNameSpecifiers;
131
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +0000132 /// \brief If set, the type that we would prefer our resulting value
133 /// declarations to have.
134 ///
135 /// Closely matching the preferred type gives a boost to a result's
136 /// priority.
137 CanQualType PreferredType;
138
Douglas Gregor86d9a522009-09-21 16:56:56 +0000139 /// \brief A list of shadow maps, which is used to model name hiding at
140 /// different levels of, e.g., the inheritance hierarchy.
141 std::list<ShadowMap> ShadowMaps;
142
Douglas Gregor3cdee122010-08-26 16:36:48 +0000143 /// \brief If we're potentially referring to a C++ member function, the set
144 /// of qualifiers applied to the object type.
145 Qualifiers ObjectTypeQualifiers;
146
147 /// \brief Whether the \p ObjectTypeQualifiers field is active.
148 bool HasObjectTypeQualifiers;
149
Douglas Gregor265f7492010-08-27 15:29:55 +0000150 /// \brief The selector that we prefer.
151 Selector PreferredSelector;
152
Douglas Gregorca45da02010-11-02 20:36:02 +0000153 /// \brief The completion context in which we are gathering results.
Douglas Gregorcee9ff12010-09-20 22:39:41 +0000154 CodeCompletionContext CompletionContext;
155
Douglas Gregorca45da02010-11-02 20:36:02 +0000156 /// \brief If we are in an instance method definition, the @implementation
157 /// object.
158 ObjCImplementationDecl *ObjCImplementation;
159
Douglas Gregorcee9ff12010-09-20 22:39:41 +0000160 void AdjustResultPriorityForDecl(Result &R);
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000161
Douglas Gregor6f942b22010-09-21 16:06:22 +0000162 void MaybeAddConstructorResults(Result R);
163
Douglas Gregor86d9a522009-09-21 16:56:56 +0000164 public:
Douglas Gregordae68752011-02-01 22:57:45 +0000165 explicit ResultBuilder(Sema &SemaRef, CodeCompletionAllocator &Allocator,
Douglas Gregor52779fb2010-09-23 23:01:17 +0000166 const CodeCompletionContext &CompletionContext,
167 LookupFilter Filter = 0)
Douglas Gregor218937c2011-02-01 19:23:04 +0000168 : SemaRef(SemaRef), Allocator(Allocator), Filter(Filter),
169 AllowNestedNameSpecifiers(false), HasObjectTypeQualifiers(false),
Douglas Gregorca45da02010-11-02 20:36:02 +0000170 CompletionContext(CompletionContext),
171 ObjCImplementation(0)
172 {
173 // If this is an Objective-C instance method definition, dig out the
174 // corresponding implementation.
175 switch (CompletionContext.getKind()) {
176 case CodeCompletionContext::CCC_Expression:
177 case CodeCompletionContext::CCC_ObjCMessageReceiver:
178 case CodeCompletionContext::CCC_ParenthesizedExpression:
179 case CodeCompletionContext::CCC_Statement:
180 case CodeCompletionContext::CCC_Recovery:
181 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl())
182 if (Method->isInstanceMethod())
183 if (ObjCInterfaceDecl *Interface = Method->getClassInterface())
184 ObjCImplementation = Interface->getImplementation();
185 break;
186
187 default:
188 break;
189 }
190 }
Douglas Gregor86d9a522009-09-21 16:56:56 +0000191
Douglas Gregord8e8a582010-05-25 21:41:55 +0000192 /// \brief Whether we should include code patterns in the completion
193 /// results.
194 bool includeCodePatterns() const {
195 return SemaRef.CodeCompleter &&
Douglas Gregorf6961522010-08-27 21:18:54 +0000196 SemaRef.CodeCompleter->includeCodePatterns();
Douglas Gregord8e8a582010-05-25 21:41:55 +0000197 }
198
Douglas Gregor86d9a522009-09-21 16:56:56 +0000199 /// \brief Set the filter used for code-completion results.
200 void setFilter(LookupFilter Filter) {
201 this->Filter = Filter;
202 }
203
Douglas Gregor86d9a522009-09-21 16:56:56 +0000204 Result *data() { return Results.empty()? 0 : &Results.front(); }
205 unsigned size() const { return Results.size(); }
206 bool empty() const { return Results.empty(); }
207
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +0000208 /// \brief Specify the preferred type.
209 void setPreferredType(QualType T) {
210 PreferredType = SemaRef.Context.getCanonicalType(T);
211 }
212
Douglas Gregor3cdee122010-08-26 16:36:48 +0000213 /// \brief Set the cv-qualifiers on the object type, for us in filtering
214 /// calls to member functions.
215 ///
216 /// When there are qualifiers in this set, they will be used to filter
217 /// out member functions that aren't available (because there will be a
218 /// cv-qualifier mismatch) or prefer functions with an exact qualifier
219 /// match.
220 void setObjectTypeQualifiers(Qualifiers Quals) {
221 ObjectTypeQualifiers = Quals;
222 HasObjectTypeQualifiers = true;
223 }
224
Douglas Gregor265f7492010-08-27 15:29:55 +0000225 /// \brief Set the preferred selector.
226 ///
227 /// When an Objective-C method declaration result is added, and that
228 /// method's selector matches this preferred selector, we give that method
229 /// a slight priority boost.
230 void setPreferredSelector(Selector Sel) {
231 PreferredSelector = Sel;
232 }
Douglas Gregorca45da02010-11-02 20:36:02 +0000233
Douglas Gregorcee9ff12010-09-20 22:39:41 +0000234 /// \brief Retrieve the code-completion context for which results are
235 /// being collected.
236 const CodeCompletionContext &getCompletionContext() const {
237 return CompletionContext;
238 }
239
Douglas Gregor45bcd432010-01-14 03:21:49 +0000240 /// \brief Specify whether nested-name-specifiers are allowed.
241 void allowNestedNameSpecifiers(bool Allow = true) {
242 AllowNestedNameSpecifiers = Allow;
243 }
244
Douglas Gregorb9d77572010-09-21 00:03:25 +0000245 /// \brief Return the semantic analysis object for which we are collecting
246 /// code completion results.
247 Sema &getSema() const { return SemaRef; }
248
Douglas Gregor218937c2011-02-01 19:23:04 +0000249 /// \brief Retrieve the allocator used to allocate code completion strings.
Douglas Gregordae68752011-02-01 22:57:45 +0000250 CodeCompletionAllocator &getAllocator() const { return Allocator; }
Douglas Gregor218937c2011-02-01 19:23:04 +0000251
Douglas Gregore495b7f2010-01-14 00:20:49 +0000252 /// \brief Determine whether the given declaration is at all interesting
253 /// as a code-completion result.
Douglas Gregor45bcd432010-01-14 03:21:49 +0000254 ///
255 /// \param ND the declaration that we are inspecting.
256 ///
257 /// \param AsNestedNameSpecifier will be set true if this declaration is
258 /// only interesting when it is a nested-name-specifier.
259 bool isInterestingDecl(NamedDecl *ND, bool &AsNestedNameSpecifier) const;
Douglas Gregor6660d842010-01-14 00:41:07 +0000260
261 /// \brief Check whether the result is hidden by the Hiding declaration.
262 ///
263 /// \returns true if the result is hidden and cannot be found, false if
264 /// the hidden result could still be found. When false, \p R may be
265 /// modified to describe how the result can be found (e.g., via extra
266 /// qualification).
267 bool CheckHiddenResult(Result &R, DeclContext *CurContext,
268 NamedDecl *Hiding);
269
Douglas Gregor86d9a522009-09-21 16:56:56 +0000270 /// \brief Add a new result to this result set (if it isn't already in one
271 /// of the shadow maps), or replace an existing result (for, e.g., a
272 /// redeclaration).
Douglas Gregor456c4a12009-09-21 20:12:40 +0000273 ///
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000274 /// \param CurContext the result to add (if it is unique).
Douglas Gregor456c4a12009-09-21 20:12:40 +0000275 ///
276 /// \param R the context in which this result will be named.
277 void MaybeAddResult(Result R, DeclContext *CurContext = 0);
Douglas Gregor86d9a522009-09-21 16:56:56 +0000278
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000279 /// \brief Add a new result to this result set, where we already know
280 /// the hiding declation (if any).
281 ///
282 /// \param R the result to add (if it is unique).
283 ///
284 /// \param CurContext the context in which this result will be named.
285 ///
286 /// \param Hiding the declaration that hides the result.
Douglas Gregor0cc84042010-01-14 15:47:35 +0000287 ///
288 /// \param InBaseClass whether the result was found in a base
289 /// class of the searched context.
290 void AddResult(Result R, DeclContext *CurContext, NamedDecl *Hiding,
291 bool InBaseClass);
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000292
Douglas Gregora4477812010-01-14 16:01:26 +0000293 /// \brief Add a new non-declaration result to this result set.
294 void AddResult(Result R);
295
Douglas Gregor86d9a522009-09-21 16:56:56 +0000296 /// \brief Enter into a new scope.
297 void EnterNewScope();
298
299 /// \brief Exit from the current scope.
300 void ExitScope();
301
Douglas Gregor55385fe2009-11-18 04:19:12 +0000302 /// \brief Ignore this declaration, if it is seen again.
303 void Ignore(Decl *D) { AllDeclsFound.insert(D->getCanonicalDecl()); }
304
Douglas Gregor86d9a522009-09-21 16:56:56 +0000305 /// \name Name lookup predicates
306 ///
307 /// These predicates can be passed to the name lookup functions to filter the
308 /// results of name lookup. All of the predicates have the same type, so that
309 ///
310 //@{
Douglas Gregor791215b2009-09-21 20:51:25 +0000311 bool IsOrdinaryName(NamedDecl *ND) const;
Douglas Gregor4710e5b2010-05-28 00:49:12 +0000312 bool IsOrdinaryNonTypeName(NamedDecl *ND) const;
Douglas Gregorf9578432010-07-28 21:50:18 +0000313 bool IsIntegralConstantValue(NamedDecl *ND) const;
Douglas Gregor01dfea02010-01-10 23:08:15 +0000314 bool IsOrdinaryNonValueName(NamedDecl *ND) const;
Douglas Gregor86d9a522009-09-21 16:56:56 +0000315 bool IsNestedNameSpecifier(NamedDecl *ND) const;
316 bool IsEnum(NamedDecl *ND) const;
317 bool IsClassOrStruct(NamedDecl *ND) const;
318 bool IsUnion(NamedDecl *ND) const;
319 bool IsNamespace(NamedDecl *ND) const;
320 bool IsNamespaceOrAlias(NamedDecl *ND) const;
321 bool IsType(NamedDecl *ND) const;
Douglas Gregoreb5758b2009-09-23 22:26:46 +0000322 bool IsMember(NamedDecl *ND) const;
Douglas Gregor80f4f4c2010-01-14 16:08:12 +0000323 bool IsObjCIvar(NamedDecl *ND) const;
Douglas Gregor8e254cf2010-05-27 23:06:34 +0000324 bool IsObjCMessageReceiver(NamedDecl *ND) const;
Douglas Gregorfb629412010-08-23 21:17:50 +0000325 bool IsObjCCollection(NamedDecl *ND) const;
Douglas Gregor52779fb2010-09-23 23:01:17 +0000326 bool IsImpossibleToSatisfy(NamedDecl *ND) const;
Douglas Gregor86d9a522009-09-21 16:56:56 +0000327 //@}
328 };
329}
330
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000331class ResultBuilder::ShadowMapEntry::iterator {
332 llvm::PointerUnion<NamedDecl*, const DeclIndexPair*> DeclOrIterator;
333 unsigned SingleDeclIndex;
334
335public:
336 typedef DeclIndexPair value_type;
337 typedef value_type reference;
338 typedef std::ptrdiff_t difference_type;
339 typedef std::input_iterator_tag iterator_category;
340
341 class pointer {
342 DeclIndexPair Value;
343
344 public:
345 pointer(const DeclIndexPair &Value) : Value(Value) { }
346
347 const DeclIndexPair *operator->() const {
348 return &Value;
349 }
350 };
351
352 iterator() : DeclOrIterator((NamedDecl *)0), SingleDeclIndex(0) { }
353
354 iterator(NamedDecl *SingleDecl, unsigned Index)
355 : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) { }
356
357 iterator(const DeclIndexPair *Iterator)
358 : DeclOrIterator(Iterator), SingleDeclIndex(0) { }
359
360 iterator &operator++() {
361 if (DeclOrIterator.is<NamedDecl *>()) {
362 DeclOrIterator = (NamedDecl *)0;
363 SingleDeclIndex = 0;
364 return *this;
365 }
366
367 const DeclIndexPair *I = DeclOrIterator.get<const DeclIndexPair*>();
368 ++I;
369 DeclOrIterator = I;
370 return *this;
371 }
372
Chris Lattner66392d42010-09-04 18:12:20 +0000373 /*iterator operator++(int) {
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000374 iterator tmp(*this);
375 ++(*this);
376 return tmp;
Chris Lattner66392d42010-09-04 18:12:20 +0000377 }*/
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000378
379 reference operator*() const {
380 if (NamedDecl *ND = DeclOrIterator.dyn_cast<NamedDecl *>())
381 return reference(ND, SingleDeclIndex);
382
Douglas Gregord490f952009-12-06 21:27:58 +0000383 return *DeclOrIterator.get<const DeclIndexPair*>();
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000384 }
385
386 pointer operator->() const {
387 return pointer(**this);
388 }
389
390 friend bool operator==(const iterator &X, const iterator &Y) {
Douglas Gregord490f952009-12-06 21:27:58 +0000391 return X.DeclOrIterator.getOpaqueValue()
392 == Y.DeclOrIterator.getOpaqueValue() &&
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000393 X.SingleDeclIndex == Y.SingleDeclIndex;
394 }
395
396 friend bool operator!=(const iterator &X, const iterator &Y) {
Douglas Gregord490f952009-12-06 21:27:58 +0000397 return !(X == Y);
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000398 }
399};
400
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000401ResultBuilder::ShadowMapEntry::iterator
402ResultBuilder::ShadowMapEntry::begin() const {
403 if (DeclOrVector.isNull())
404 return iterator();
405
406 if (NamedDecl *ND = DeclOrVector.dyn_cast<NamedDecl *>())
407 return iterator(ND, SingleDeclIndex);
408
409 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->begin());
410}
411
412ResultBuilder::ShadowMapEntry::iterator
413ResultBuilder::ShadowMapEntry::end() const {
414 if (DeclOrVector.is<NamedDecl *>() || DeclOrVector.isNull())
415 return iterator();
416
417 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end());
418}
419
Douglas Gregor456c4a12009-09-21 20:12:40 +0000420/// \brief Compute the qualification required to get from the current context
421/// (\p CurContext) to the target context (\p TargetContext).
422///
423/// \param Context the AST context in which the qualification will be used.
424///
425/// \param CurContext the context where an entity is being named, which is
426/// typically based on the current scope.
427///
428/// \param TargetContext the context in which the named entity actually
429/// resides.
430///
431/// \returns a nested name specifier that refers into the target context, or
432/// NULL if no qualification is needed.
433static NestedNameSpecifier *
434getRequiredQualification(ASTContext &Context,
435 DeclContext *CurContext,
436 DeclContext *TargetContext) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000437 SmallVector<DeclContext *, 4> TargetParents;
Douglas Gregor456c4a12009-09-21 20:12:40 +0000438
439 for (DeclContext *CommonAncestor = TargetContext;
440 CommonAncestor && !CommonAncestor->Encloses(CurContext);
441 CommonAncestor = CommonAncestor->getLookupParent()) {
442 if (CommonAncestor->isTransparentContext() ||
443 CommonAncestor->isFunctionOrMethod())
444 continue;
445
446 TargetParents.push_back(CommonAncestor);
447 }
448
449 NestedNameSpecifier *Result = 0;
450 while (!TargetParents.empty()) {
451 DeclContext *Parent = TargetParents.back();
452 TargetParents.pop_back();
453
Douglas Gregorfb629412010-08-23 21:17:50 +0000454 if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Parent)) {
455 if (!Namespace->getIdentifier())
456 continue;
457
Douglas Gregor456c4a12009-09-21 20:12:40 +0000458 Result = NestedNameSpecifier::Create(Context, Result, Namespace);
Douglas Gregorfb629412010-08-23 21:17:50 +0000459 }
Douglas Gregor456c4a12009-09-21 20:12:40 +0000460 else if (TagDecl *TD = dyn_cast<TagDecl>(Parent))
461 Result = NestedNameSpecifier::Create(Context, Result,
462 false,
463 Context.getTypeDeclType(TD).getTypePtr());
Douglas Gregor0c8296d2009-11-07 00:00:49 +0000464 }
Douglas Gregor456c4a12009-09-21 20:12:40 +0000465 return Result;
466}
467
Douglas Gregor45bcd432010-01-14 03:21:49 +0000468bool ResultBuilder::isInterestingDecl(NamedDecl *ND,
469 bool &AsNestedNameSpecifier) const {
470 AsNestedNameSpecifier = false;
471
Douglas Gregore495b7f2010-01-14 00:20:49 +0000472 ND = ND->getUnderlyingDecl();
473 unsigned IDNS = ND->getIdentifierNamespace();
Douglas Gregorf52cede2009-10-09 22:16:47 +0000474
475 // Skip unnamed entities.
Douglas Gregore495b7f2010-01-14 00:20:49 +0000476 if (!ND->getDeclName())
477 return false;
Douglas Gregor86d9a522009-09-21 16:56:56 +0000478
479 // Friend declarations and declarations introduced due to friends are never
480 // added as results.
John McCall92b7f702010-03-11 07:50:04 +0000481 if (IDNS & (Decl::IDNS_OrdinaryFriend | Decl::IDNS_TagFriend))
Douglas Gregore495b7f2010-01-14 00:20:49 +0000482 return false;
483
Douglas Gregor76282942009-12-11 17:31:05 +0000484 // Class template (partial) specializations are never added as results.
Douglas Gregore495b7f2010-01-14 00:20:49 +0000485 if (isa<ClassTemplateSpecializationDecl>(ND) ||
486 isa<ClassTemplatePartialSpecializationDecl>(ND))
487 return false;
Douglas Gregor86d9a522009-09-21 16:56:56 +0000488
Douglas Gregor76282942009-12-11 17:31:05 +0000489 // Using declarations themselves are never added as results.
Douglas Gregore495b7f2010-01-14 00:20:49 +0000490 if (isa<UsingDecl>(ND))
491 return false;
492
493 // Some declarations have reserved names that we don't want to ever show.
494 if (const IdentifierInfo *Id = ND->getIdentifier()) {
Douglas Gregor86d9a522009-09-21 16:56:56 +0000495 // __va_list_tag is a freak of nature. Find it and skip it.
496 if (Id->isStr("__va_list_tag") || Id->isStr("__builtin_va_list"))
Douglas Gregore495b7f2010-01-14 00:20:49 +0000497 return false;
Douglas Gregor86d9a522009-09-21 16:56:56 +0000498
Douglas Gregorf52cede2009-10-09 22:16:47 +0000499 // Filter out names reserved for the implementation (C99 7.1.3,
Douglas Gregor797efb52010-07-14 17:44:04 +0000500 // C++ [lib.global.names]) if they come from a system header.
Daniel Dunbare013d682009-10-18 20:26:12 +0000501 //
502 // FIXME: Add predicate for this.
Douglas Gregorf52cede2009-10-09 22:16:47 +0000503 if (Id->getLength() >= 2) {
Daniel Dunbare013d682009-10-18 20:26:12 +0000504 const char *Name = Id->getNameStart();
Douglas Gregorf52cede2009-10-09 22:16:47 +0000505 if (Name[0] == '_' &&
Douglas Gregor797efb52010-07-14 17:44:04 +0000506 (Name[1] == '_' || (Name[1] >= 'A' && Name[1] <= 'Z')) &&
507 (ND->getLocation().isInvalid() ||
508 SemaRef.SourceMgr.isInSystemHeader(
509 SemaRef.SourceMgr.getSpellingLoc(ND->getLocation()))))
Douglas Gregore495b7f2010-01-14 00:20:49 +0000510 return false;
Douglas Gregorf52cede2009-10-09 22:16:47 +0000511 }
Douglas Gregor86d9a522009-09-21 16:56:56 +0000512 }
Douglas Gregor6f942b22010-09-21 16:06:22 +0000513
Douglas Gregor9b0ba872010-11-09 03:59:40 +0000514 // Skip out-of-line declarations and definitions.
515 // NOTE: Unless it's an Objective-C property, method, or ivar, where
516 // the contexts can be messy.
517 if (!ND->getDeclContext()->Equals(ND->getLexicalDeclContext()) &&
518 !(isa<ObjCPropertyDecl>(ND) || isa<ObjCIvarDecl>(ND) ||
519 isa<ObjCMethodDecl>(ND)))
520 return false;
521
Douglas Gregora5fb7c32010-08-16 23:05:20 +0000522 if (Filter == &ResultBuilder::IsNestedNameSpecifier ||
523 ((isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND)) &&
524 Filter != &ResultBuilder::IsNamespace &&
Douglas Gregor52779fb2010-09-23 23:01:17 +0000525 Filter != &ResultBuilder::IsNamespaceOrAlias &&
526 Filter != 0))
Douglas Gregora5fb7c32010-08-16 23:05:20 +0000527 AsNestedNameSpecifier = true;
528
Douglas Gregor86d9a522009-09-21 16:56:56 +0000529 // Filter out any unwanted results.
Douglas Gregor45bcd432010-01-14 03:21:49 +0000530 if (Filter && !(this->*Filter)(ND)) {
531 // Check whether it is interesting as a nested-name-specifier.
532 if (AllowNestedNameSpecifiers && SemaRef.getLangOptions().CPlusPlus &&
533 IsNestedNameSpecifier(ND) &&
534 (Filter != &ResultBuilder::IsMember ||
535 (isa<CXXRecordDecl>(ND) &&
536 cast<CXXRecordDecl>(ND)->isInjectedClassName()))) {
537 AsNestedNameSpecifier = true;
538 return true;
539 }
540
Douglas Gregore495b7f2010-01-14 00:20:49 +0000541 return false;
Douglas Gregora5fb7c32010-08-16 23:05:20 +0000542 }
Douglas Gregore495b7f2010-01-14 00:20:49 +0000543 // ... then it must be interesting!
544 return true;
545}
546
Douglas Gregor6660d842010-01-14 00:41:07 +0000547bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext,
548 NamedDecl *Hiding) {
549 // In C, there is no way to refer to a hidden name.
550 // FIXME: This isn't true; we can find a tag name hidden by an ordinary
551 // name if we introduce the tag type.
552 if (!SemaRef.getLangOptions().CPlusPlus)
553 return true;
554
Sebastian Redl7a126a42010-08-31 00:36:30 +0000555 DeclContext *HiddenCtx = R.Declaration->getDeclContext()->getRedeclContext();
Douglas Gregor6660d842010-01-14 00:41:07 +0000556
557 // There is no way to qualify a name declared in a function or method.
558 if (HiddenCtx->isFunctionOrMethod())
559 return true;
560
Sebastian Redl7a126a42010-08-31 00:36:30 +0000561 if (HiddenCtx == Hiding->getDeclContext()->getRedeclContext())
Douglas Gregor6660d842010-01-14 00:41:07 +0000562 return true;
563
564 // We can refer to the result with the appropriate qualification. Do it.
565 R.Hidden = true;
566 R.QualifierIsInformative = false;
567
568 if (!R.Qualifier)
569 R.Qualifier = getRequiredQualification(SemaRef.Context,
570 CurContext,
571 R.Declaration->getDeclContext());
572 return false;
573}
574
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000575/// \brief A simplified classification of types used to determine whether two
576/// types are "similar enough" when adjusting priorities.
Douglas Gregor1827e102010-08-16 16:18:59 +0000577SimplifiedTypeClass clang::getSimplifiedTypeClass(CanQualType T) {
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000578 switch (T->getTypeClass()) {
579 case Type::Builtin:
580 switch (cast<BuiltinType>(T)->getKind()) {
581 case BuiltinType::Void:
582 return STC_Void;
583
584 case BuiltinType::NullPtr:
585 return STC_Pointer;
586
587 case BuiltinType::Overload:
588 case BuiltinType::Dependent:
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000589 return STC_Other;
590
591 case BuiltinType::ObjCId:
592 case BuiltinType::ObjCClass:
593 case BuiltinType::ObjCSel:
594 return STC_ObjectiveC;
595
596 default:
597 return STC_Arithmetic;
598 }
David Blaikie7530c032012-01-17 06:56:22 +0000599
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000600 case Type::Complex:
601 return STC_Arithmetic;
602
603 case Type::Pointer:
604 return STC_Pointer;
605
606 case Type::BlockPointer:
607 return STC_Block;
608
609 case Type::LValueReference:
610 case Type::RValueReference:
611 return getSimplifiedTypeClass(T->getAs<ReferenceType>()->getPointeeType());
612
613 case Type::ConstantArray:
614 case Type::IncompleteArray:
615 case Type::VariableArray:
616 case Type::DependentSizedArray:
617 return STC_Array;
618
619 case Type::DependentSizedExtVector:
620 case Type::Vector:
621 case Type::ExtVector:
622 return STC_Arithmetic;
623
624 case Type::FunctionProto:
625 case Type::FunctionNoProto:
626 return STC_Function;
627
628 case Type::Record:
629 return STC_Record;
630
631 case Type::Enum:
632 return STC_Arithmetic;
633
634 case Type::ObjCObject:
635 case Type::ObjCInterface:
636 case Type::ObjCObjectPointer:
637 return STC_ObjectiveC;
638
639 default:
640 return STC_Other;
641 }
642}
643
644/// \brief Get the type that a given expression will have if this declaration
645/// is used as an expression in its "typical" code-completion form.
Douglas Gregor1827e102010-08-16 16:18:59 +0000646QualType clang::getDeclUsageType(ASTContext &C, NamedDecl *ND) {
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000647 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
648
649 if (TypeDecl *Type = dyn_cast<TypeDecl>(ND))
650 return C.getTypeDeclType(Type);
651 if (ObjCInterfaceDecl *Iface = dyn_cast<ObjCInterfaceDecl>(ND))
652 return C.getObjCInterfaceType(Iface);
653
654 QualType T;
655 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(ND))
Douglas Gregor5291c3c2010-07-13 08:18:22 +0000656 T = Function->getCallResultType();
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000657 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND))
Douglas Gregor5291c3c2010-07-13 08:18:22 +0000658 T = Method->getSendResultType();
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000659 else if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND))
Douglas Gregor5291c3c2010-07-13 08:18:22 +0000660 T = FunTmpl->getTemplatedDecl()->getCallResultType();
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000661 else if (EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND))
662 T = C.getTypeDeclType(cast<EnumDecl>(Enumerator->getDeclContext()));
663 else if (ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND))
664 T = Property->getType();
665 else if (ValueDecl *Value = dyn_cast<ValueDecl>(ND))
666 T = Value->getType();
667 else
668 return QualType();
Douglas Gregor3e64d562011-04-14 20:33:34 +0000669
670 // Dig through references, function pointers, and block pointers to
671 // get down to the likely type of an expression when the entity is
672 // used.
673 do {
674 if (const ReferenceType *Ref = T->getAs<ReferenceType>()) {
675 T = Ref->getPointeeType();
676 continue;
677 }
678
679 if (const PointerType *Pointer = T->getAs<PointerType>()) {
680 if (Pointer->getPointeeType()->isFunctionType()) {
681 T = Pointer->getPointeeType();
682 continue;
683 }
684
685 break;
686 }
687
688 if (const BlockPointerType *Block = T->getAs<BlockPointerType>()) {
689 T = Block->getPointeeType();
690 continue;
691 }
692
693 if (const FunctionType *Function = T->getAs<FunctionType>()) {
694 T = Function->getResultType();
695 continue;
696 }
697
698 break;
699 } while (true);
700
701 return T;
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000702}
703
Douglas Gregorcee9ff12010-09-20 22:39:41 +0000704void ResultBuilder::AdjustResultPriorityForDecl(Result &R) {
705 // If this is an Objective-C method declaration whose selector matches our
706 // preferred selector, give it a priority boost.
707 if (!PreferredSelector.isNull())
708 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(R.Declaration))
709 if (PreferredSelector == Method->getSelector())
710 R.Priority += CCD_SelectorMatch;
Douglas Gregor08f43cd2010-09-20 23:11:55 +0000711
Douglas Gregorcee9ff12010-09-20 22:39:41 +0000712 // If we have a preferred type, adjust the priority for results with exactly-
713 // matching or nearly-matching types.
714 if (!PreferredType.isNull()) {
715 QualType T = getDeclUsageType(SemaRef.Context, R.Declaration);
716 if (!T.isNull()) {
717 CanQualType TC = SemaRef.Context.getCanonicalType(T);
718 // Check for exactly-matching types (modulo qualifiers).
719 if (SemaRef.Context.hasSameUnqualifiedType(PreferredType, TC))
720 R.Priority /= CCF_ExactTypeMatch;
721 // Check for nearly-matching types, based on classification of each.
722 else if ((getSimplifiedTypeClass(PreferredType)
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000723 == getSimplifiedTypeClass(TC)) &&
Douglas Gregorcee9ff12010-09-20 22:39:41 +0000724 !(PreferredType->isEnumeralType() && TC->isEnumeralType()))
725 R.Priority /= CCF_SimilarTypeMatch;
726 }
727 }
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000728}
729
Douglas Gregor6f942b22010-09-21 16:06:22 +0000730void ResultBuilder::MaybeAddConstructorResults(Result R) {
731 if (!SemaRef.getLangOptions().CPlusPlus || !R.Declaration ||
732 !CompletionContext.wantConstructorResults())
733 return;
734
735 ASTContext &Context = SemaRef.Context;
736 NamedDecl *D = R.Declaration;
737 CXXRecordDecl *Record = 0;
738 if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D))
739 Record = ClassTemplate->getTemplatedDecl();
740 else if ((Record = dyn_cast<CXXRecordDecl>(D))) {
741 // Skip specializations and partial specializations.
742 if (isa<ClassTemplateSpecializationDecl>(Record))
743 return;
744 } else {
745 // There are no constructors here.
746 return;
747 }
748
749 Record = Record->getDefinition();
750 if (!Record)
751 return;
752
753
754 QualType RecordTy = Context.getTypeDeclType(Record);
755 DeclarationName ConstructorName
756 = Context.DeclarationNames.getCXXConstructorName(
757 Context.getCanonicalType(RecordTy));
758 for (DeclContext::lookup_result Ctors = Record->lookup(ConstructorName);
759 Ctors.first != Ctors.second; ++Ctors.first) {
760 R.Declaration = *Ctors.first;
761 R.CursorKind = getCursorKindForDecl(R.Declaration);
762 Results.push_back(R);
763 }
764}
765
Douglas Gregore495b7f2010-01-14 00:20:49 +0000766void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) {
767 assert(!ShadowMaps.empty() && "Must enter into a results scope");
768
769 if (R.Kind != Result::RK_Declaration) {
770 // For non-declaration results, just add the result.
771 Results.push_back(R);
772 return;
773 }
774
775 // Look through using declarations.
776 if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
777 MaybeAddResult(Result(Using->getTargetDecl(), R.Qualifier), CurContext);
778 return;
779 }
780
781 Decl *CanonDecl = R.Declaration->getCanonicalDecl();
782 unsigned IDNS = CanonDecl->getIdentifierNamespace();
783
Douglas Gregor45bcd432010-01-14 03:21:49 +0000784 bool AsNestedNameSpecifier = false;
785 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
Douglas Gregore495b7f2010-01-14 00:20:49 +0000786 return;
787
Douglas Gregor6f942b22010-09-21 16:06:22 +0000788 // C++ constructors are never found by name lookup.
789 if (isa<CXXConstructorDecl>(R.Declaration))
790 return;
791
Douglas Gregor86d9a522009-09-21 16:56:56 +0000792 ShadowMap &SMap = ShadowMaps.back();
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000793 ShadowMapEntry::iterator I, IEnd;
794 ShadowMap::iterator NamePos = SMap.find(R.Declaration->getDeclName());
795 if (NamePos != SMap.end()) {
796 I = NamePos->second.begin();
797 IEnd = NamePos->second.end();
798 }
799
800 for (; I != IEnd; ++I) {
801 NamedDecl *ND = I->first;
802 unsigned Index = I->second;
Douglas Gregor86d9a522009-09-21 16:56:56 +0000803 if (ND->getCanonicalDecl() == CanonDecl) {
804 // This is a redeclaration. Always pick the newer declaration.
Douglas Gregor86d9a522009-09-21 16:56:56 +0000805 Results[Index].Declaration = R.Declaration;
806
Douglas Gregor86d9a522009-09-21 16:56:56 +0000807 // We're done.
808 return;
809 }
810 }
811
812 // This is a new declaration in this scope. However, check whether this
813 // declaration name is hidden by a similarly-named declaration in an outer
814 // scope.
815 std::list<ShadowMap>::iterator SM, SMEnd = ShadowMaps.end();
816 --SMEnd;
817 for (SM = ShadowMaps.begin(); SM != SMEnd; ++SM) {
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000818 ShadowMapEntry::iterator I, IEnd;
819 ShadowMap::iterator NamePos = SM->find(R.Declaration->getDeclName());
820 if (NamePos != SM->end()) {
821 I = NamePos->second.begin();
822 IEnd = NamePos->second.end();
823 }
824 for (; I != IEnd; ++I) {
Douglas Gregor86d9a522009-09-21 16:56:56 +0000825 // A tag declaration does not hide a non-tag declaration.
John McCall0d6b1642010-04-23 18:46:30 +0000826 if (I->first->hasTagIdentifierNamespace() &&
Douglas Gregor86d9a522009-09-21 16:56:56 +0000827 (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary |
828 Decl::IDNS_ObjCProtocol)))
829 continue;
830
831 // Protocols are in distinct namespaces from everything else.
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000832 if (((I->first->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol)
Douglas Gregor86d9a522009-09-21 16:56:56 +0000833 || (IDNS & Decl::IDNS_ObjCProtocol)) &&
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000834 I->first->getIdentifierNamespace() != IDNS)
Douglas Gregor86d9a522009-09-21 16:56:56 +0000835 continue;
836
837 // The newly-added result is hidden by an entry in the shadow map.
Douglas Gregor6660d842010-01-14 00:41:07 +0000838 if (CheckHiddenResult(R, CurContext, I->first))
Douglas Gregor86d9a522009-09-21 16:56:56 +0000839 return;
Douglas Gregor86d9a522009-09-21 16:56:56 +0000840
841 break;
842 }
843 }
844
845 // Make sure that any given declaration only shows up in the result set once.
846 if (!AllDeclsFound.insert(CanonDecl))
847 return;
Douglas Gregor265f7492010-08-27 15:29:55 +0000848
Douglas Gregoreb5758b2009-09-23 22:26:46 +0000849 // If the filter is for nested-name-specifiers, then this result starts a
850 // nested-name-specifier.
Douglas Gregor12e13132010-05-26 22:00:08 +0000851 if (AsNestedNameSpecifier) {
Douglas Gregoreb5758b2009-09-23 22:26:46 +0000852 R.StartsNestedNameSpecifier = true;
Douglas Gregor12e13132010-05-26 22:00:08 +0000853 R.Priority = CCP_NestedNameSpecifier;
Douglas Gregorcee9ff12010-09-20 22:39:41 +0000854 } else
855 AdjustResultPriorityForDecl(R);
Douglas Gregor265f7492010-08-27 15:29:55 +0000856
Douglas Gregor0563c262009-09-22 23:15:58 +0000857 // If this result is supposed to have an informative qualifier, add one.
Douglas Gregoreb5758b2009-09-23 22:26:46 +0000858 if (R.QualifierIsInformative && !R.Qualifier &&
859 !R.StartsNestedNameSpecifier) {
Douglas Gregor0563c262009-09-22 23:15:58 +0000860 DeclContext *Ctx = R.Declaration->getDeclContext();
861 if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
862 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, Namespace);
863 else if (TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
864 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, false,
865 SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
866 else
867 R.QualifierIsInformative = false;
868 }
Douglas Gregoreb5758b2009-09-23 22:26:46 +0000869
Douglas Gregor86d9a522009-09-21 16:56:56 +0000870 // Insert this result into the set of results and into the current shadow
871 // map.
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000872 SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size());
Douglas Gregor86d9a522009-09-21 16:56:56 +0000873 Results.push_back(R);
Douglas Gregor6f942b22010-09-21 16:06:22 +0000874
875 if (!AsNestedNameSpecifier)
876 MaybeAddConstructorResults(R);
Douglas Gregor86d9a522009-09-21 16:56:56 +0000877}
878
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000879void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
Douglas Gregor0cc84042010-01-14 15:47:35 +0000880 NamedDecl *Hiding, bool InBaseClass = false) {
Douglas Gregora4477812010-01-14 16:01:26 +0000881 if (R.Kind != Result::RK_Declaration) {
882 // For non-declaration results, just add the result.
883 Results.push_back(R);
884 return;
885 }
886
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000887 // Look through using declarations.
888 if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
889 AddResult(Result(Using->getTargetDecl(), R.Qualifier), CurContext, Hiding);
890 return;
891 }
892
Douglas Gregor45bcd432010-01-14 03:21:49 +0000893 bool AsNestedNameSpecifier = false;
894 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000895 return;
896
Douglas Gregor6f942b22010-09-21 16:06:22 +0000897 // C++ constructors are never found by name lookup.
898 if (isa<CXXConstructorDecl>(R.Declaration))
899 return;
900
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000901 if (Hiding && CheckHiddenResult(R, CurContext, Hiding))
902 return;
903
904 // Make sure that any given declaration only shows up in the result set once.
905 if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl()))
906 return;
907
908 // If the filter is for nested-name-specifiers, then this result starts a
909 // nested-name-specifier.
Douglas Gregor12e13132010-05-26 22:00:08 +0000910 if (AsNestedNameSpecifier) {
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000911 R.StartsNestedNameSpecifier = true;
Douglas Gregor12e13132010-05-26 22:00:08 +0000912 R.Priority = CCP_NestedNameSpecifier;
913 }
Douglas Gregor0cc84042010-01-14 15:47:35 +0000914 else if (Filter == &ResultBuilder::IsMember && !R.Qualifier && InBaseClass &&
915 isa<CXXRecordDecl>(R.Declaration->getDeclContext()
Sebastian Redl7a126a42010-08-31 00:36:30 +0000916 ->getRedeclContext()))
Douglas Gregor0cc84042010-01-14 15:47:35 +0000917 R.QualifierIsInformative = true;
918
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000919 // If this result is supposed to have an informative qualifier, add one.
920 if (R.QualifierIsInformative && !R.Qualifier &&
921 !R.StartsNestedNameSpecifier) {
922 DeclContext *Ctx = R.Declaration->getDeclContext();
923 if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
924 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, Namespace);
925 else if (TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
926 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, false,
Douglas Gregor45bcd432010-01-14 03:21:49 +0000927 SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000928 else
929 R.QualifierIsInformative = false;
930 }
931
Douglas Gregor12e13132010-05-26 22:00:08 +0000932 // Adjust the priority if this result comes from a base class.
933 if (InBaseClass)
934 R.Priority += CCD_InBaseClass;
935
Douglas Gregorcee9ff12010-09-20 22:39:41 +0000936 AdjustResultPriorityForDecl(R);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +0000937
Douglas Gregor3cdee122010-08-26 16:36:48 +0000938 if (HasObjectTypeQualifiers)
939 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(R.Declaration))
940 if (Method->isInstance()) {
941 Qualifiers MethodQuals
942 = Qualifiers::fromCVRMask(Method->getTypeQualifiers());
943 if (ObjectTypeQualifiers == MethodQuals)
944 R.Priority += CCD_ObjectQualifierMatch;
945 else if (ObjectTypeQualifiers - MethodQuals) {
946 // The method cannot be invoked, because doing so would drop
947 // qualifiers.
948 return;
949 }
950 }
951
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000952 // Insert this result into the set of results.
953 Results.push_back(R);
Douglas Gregor6f942b22010-09-21 16:06:22 +0000954
955 if (!AsNestedNameSpecifier)
956 MaybeAddConstructorResults(R);
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000957}
958
Douglas Gregora4477812010-01-14 16:01:26 +0000959void ResultBuilder::AddResult(Result R) {
960 assert(R.Kind != Result::RK_Declaration &&
961 "Declaration results need more context");
962 Results.push_back(R);
963}
964
Douglas Gregor86d9a522009-09-21 16:56:56 +0000965/// \brief Enter into a new scope.
966void ResultBuilder::EnterNewScope() {
967 ShadowMaps.push_back(ShadowMap());
968}
969
970/// \brief Exit from the current scope.
971void ResultBuilder::ExitScope() {
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000972 for (ShadowMap::iterator E = ShadowMaps.back().begin(),
973 EEnd = ShadowMaps.back().end();
974 E != EEnd;
975 ++E)
976 E->second.Destroy();
977
Douglas Gregor86d9a522009-09-21 16:56:56 +0000978 ShadowMaps.pop_back();
979}
980
Douglas Gregor791215b2009-09-21 20:51:25 +0000981/// \brief Determines whether this given declaration will be found by
982/// ordinary name lookup.
983bool ResultBuilder::IsOrdinaryName(NamedDecl *ND) const {
Douglas Gregor4710e5b2010-05-28 00:49:12 +0000984 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
985
Douglas Gregor791215b2009-09-21 20:51:25 +0000986 unsigned IDNS = Decl::IDNS_Ordinary;
987 if (SemaRef.getLangOptions().CPlusPlus)
Douglas Gregor9b30b262010-06-15 20:26:51 +0000988 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
Douglas Gregorca45da02010-11-02 20:36:02 +0000989 else if (SemaRef.getLangOptions().ObjC1) {
990 if (isa<ObjCIvarDecl>(ND))
991 return true;
Douglas Gregorca45da02010-11-02 20:36:02 +0000992 }
993
Douglas Gregor791215b2009-09-21 20:51:25 +0000994 return ND->getIdentifierNamespace() & IDNS;
995}
996
Douglas Gregor01dfea02010-01-10 23:08:15 +0000997/// \brief Determines whether this given declaration will be found by
Douglas Gregor4710e5b2010-05-28 00:49:12 +0000998/// ordinary name lookup but is not a type name.
999bool ResultBuilder::IsOrdinaryNonTypeName(NamedDecl *ND) const {
1000 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
1001 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND))
1002 return false;
1003
1004 unsigned IDNS = Decl::IDNS_Ordinary;
1005 if (SemaRef.getLangOptions().CPlusPlus)
Douglas Gregor9b30b262010-06-15 20:26:51 +00001006 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
Douglas Gregorca45da02010-11-02 20:36:02 +00001007 else if (SemaRef.getLangOptions().ObjC1) {
1008 if (isa<ObjCIvarDecl>(ND))
1009 return true;
Douglas Gregorca45da02010-11-02 20:36:02 +00001010 }
1011
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001012 return ND->getIdentifierNamespace() & IDNS;
1013}
1014
Douglas Gregorf9578432010-07-28 21:50:18 +00001015bool ResultBuilder::IsIntegralConstantValue(NamedDecl *ND) const {
1016 if (!IsOrdinaryNonTypeName(ND))
1017 return 0;
1018
1019 if (ValueDecl *VD = dyn_cast<ValueDecl>(ND->getUnderlyingDecl()))
1020 if (VD->getType()->isIntegralOrEnumerationType())
1021 return true;
1022
1023 return false;
1024}
1025
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001026/// \brief Determines whether this given declaration will be found by
Douglas Gregor01dfea02010-01-10 23:08:15 +00001027/// ordinary name lookup.
1028bool ResultBuilder::IsOrdinaryNonValueName(NamedDecl *ND) const {
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001029 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
1030
Douglas Gregor01dfea02010-01-10 23:08:15 +00001031 unsigned IDNS = Decl::IDNS_Ordinary;
1032 if (SemaRef.getLangOptions().CPlusPlus)
John McCall0d6b1642010-04-23 18:46:30 +00001033 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace;
Douglas Gregor01dfea02010-01-10 23:08:15 +00001034
1035 return (ND->getIdentifierNamespace() & IDNS) &&
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001036 !isa<ValueDecl>(ND) && !isa<FunctionTemplateDecl>(ND) &&
1037 !isa<ObjCPropertyDecl>(ND);
Douglas Gregor01dfea02010-01-10 23:08:15 +00001038}
1039
Douglas Gregor86d9a522009-09-21 16:56:56 +00001040/// \brief Determines whether the given declaration is suitable as the
1041/// start of a C++ nested-name-specifier, e.g., a class or namespace.
1042bool ResultBuilder::IsNestedNameSpecifier(NamedDecl *ND) const {
1043 // Allow us to find class templates, too.
1044 if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1045 ND = ClassTemplate->getTemplatedDecl();
1046
1047 return SemaRef.isAcceptableNestedNameSpecifier(ND);
1048}
1049
1050/// \brief Determines whether the given declaration is an enumeration.
1051bool ResultBuilder::IsEnum(NamedDecl *ND) const {
1052 return isa<EnumDecl>(ND);
1053}
1054
1055/// \brief Determines whether the given declaration is a class or struct.
1056bool ResultBuilder::IsClassOrStruct(NamedDecl *ND) const {
1057 // Allow us to find class templates, too.
1058 if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1059 ND = ClassTemplate->getTemplatedDecl();
1060
1061 if (RecordDecl *RD = dyn_cast<RecordDecl>(ND))
Abramo Bagnara465d41b2010-05-11 21:36:43 +00001062 return RD->getTagKind() == TTK_Class ||
1063 RD->getTagKind() == TTK_Struct;
Douglas Gregor86d9a522009-09-21 16:56:56 +00001064
1065 return false;
1066}
1067
1068/// \brief Determines whether the given declaration is a union.
1069bool ResultBuilder::IsUnion(NamedDecl *ND) const {
1070 // Allow us to find class templates, too.
1071 if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1072 ND = ClassTemplate->getTemplatedDecl();
1073
1074 if (RecordDecl *RD = dyn_cast<RecordDecl>(ND))
Abramo Bagnara465d41b2010-05-11 21:36:43 +00001075 return RD->getTagKind() == TTK_Union;
Douglas Gregor86d9a522009-09-21 16:56:56 +00001076
1077 return false;
1078}
1079
1080/// \brief Determines whether the given declaration is a namespace.
1081bool ResultBuilder::IsNamespace(NamedDecl *ND) const {
1082 return isa<NamespaceDecl>(ND);
1083}
1084
1085/// \brief Determines whether the given declaration is a namespace or
1086/// namespace alias.
1087bool ResultBuilder::IsNamespaceOrAlias(NamedDecl *ND) const {
1088 return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
1089}
1090
Douglas Gregor76282942009-12-11 17:31:05 +00001091/// \brief Determines whether the given declaration is a type.
Douglas Gregor86d9a522009-09-21 16:56:56 +00001092bool ResultBuilder::IsType(NamedDecl *ND) const {
Douglas Gregord32b0222010-08-24 01:06:58 +00001093 if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(ND))
1094 ND = Using->getTargetDecl();
1095
1096 return isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
Douglas Gregor86d9a522009-09-21 16:56:56 +00001097}
1098
Douglas Gregor76282942009-12-11 17:31:05 +00001099/// \brief Determines which members of a class should be visible via
1100/// "." or "->". Only value declarations, nested name specifiers, and
1101/// using declarations thereof should show up.
Douglas Gregoreb5758b2009-09-23 22:26:46 +00001102bool ResultBuilder::IsMember(NamedDecl *ND) const {
Douglas Gregor76282942009-12-11 17:31:05 +00001103 if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(ND))
1104 ND = Using->getTargetDecl();
1105
Douglas Gregorce821962009-12-11 18:14:22 +00001106 return isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND) ||
1107 isa<ObjCPropertyDecl>(ND);
Douglas Gregoreb5758b2009-09-23 22:26:46 +00001108}
1109
Douglas Gregor8e254cf2010-05-27 23:06:34 +00001110static bool isObjCReceiverType(ASTContext &C, QualType T) {
1111 T = C.getCanonicalType(T);
1112 switch (T->getTypeClass()) {
1113 case Type::ObjCObject:
1114 case Type::ObjCInterface:
1115 case Type::ObjCObjectPointer:
1116 return true;
1117
1118 case Type::Builtin:
1119 switch (cast<BuiltinType>(T)->getKind()) {
1120 case BuiltinType::ObjCId:
1121 case BuiltinType::ObjCClass:
1122 case BuiltinType::ObjCSel:
1123 return true;
1124
1125 default:
1126 break;
1127 }
1128 return false;
1129
1130 default:
1131 break;
1132 }
1133
1134 if (!C.getLangOptions().CPlusPlus)
1135 return false;
1136
1137 // FIXME: We could perform more analysis here to determine whether a
1138 // particular class type has any conversions to Objective-C types. For now,
1139 // just accept all class types.
1140 return T->isDependentType() || T->isRecordType();
1141}
1142
1143bool ResultBuilder::IsObjCMessageReceiver(NamedDecl *ND) const {
1144 QualType T = getDeclUsageType(SemaRef.Context, ND);
1145 if (T.isNull())
1146 return false;
1147
1148 T = SemaRef.Context.getBaseElementType(T);
1149 return isObjCReceiverType(SemaRef.Context, T);
1150}
1151
Douglas Gregorfb629412010-08-23 21:17:50 +00001152bool ResultBuilder::IsObjCCollection(NamedDecl *ND) const {
1153 if ((SemaRef.getLangOptions().CPlusPlus && !IsOrdinaryName(ND)) ||
1154 (!SemaRef.getLangOptions().CPlusPlus && !IsOrdinaryNonTypeName(ND)))
1155 return false;
1156
1157 QualType T = getDeclUsageType(SemaRef.Context, ND);
1158 if (T.isNull())
1159 return false;
1160
1161 T = SemaRef.Context.getBaseElementType(T);
1162 return T->isObjCObjectType() || T->isObjCObjectPointerType() ||
1163 T->isObjCIdType() ||
1164 (SemaRef.getLangOptions().CPlusPlus && T->isRecordType());
1165}
Douglas Gregor8e254cf2010-05-27 23:06:34 +00001166
Douglas Gregor52779fb2010-09-23 23:01:17 +00001167bool ResultBuilder::IsImpossibleToSatisfy(NamedDecl *ND) const {
1168 return false;
1169}
1170
Douglas Gregor80f4f4c2010-01-14 16:08:12 +00001171/// \rief Determines whether the given declaration is an Objective-C
1172/// instance variable.
1173bool ResultBuilder::IsObjCIvar(NamedDecl *ND) const {
1174 return isa<ObjCIvarDecl>(ND);
1175}
1176
Douglas Gregor1ca6ae82010-01-14 01:09:38 +00001177namespace {
1178 /// \brief Visible declaration consumer that adds a code-completion result
1179 /// for each visible declaration.
1180 class CodeCompletionDeclConsumer : public VisibleDeclConsumer {
1181 ResultBuilder &Results;
1182 DeclContext *CurContext;
1183
1184 public:
1185 CodeCompletionDeclConsumer(ResultBuilder &Results, DeclContext *CurContext)
1186 : Results(Results), CurContext(CurContext) { }
1187
Erik Verbruggend1205962011-10-06 07:27:49 +00001188 virtual void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,
1189 bool InBaseClass) {
1190 bool Accessible = true;
Douglas Gregor17015ef2011-11-03 16:51:37 +00001191 if (Ctx)
1192 Accessible = Results.getSema().IsSimplyAccessible(ND, Ctx);
1193
Erik Verbruggend1205962011-10-06 07:27:49 +00001194 ResultBuilder::Result Result(ND, 0, false, Accessible);
1195 Results.AddResult(Result, CurContext, Hiding, InBaseClass);
Douglas Gregor1ca6ae82010-01-14 01:09:38 +00001196 }
1197 };
1198}
1199
Douglas Gregor86d9a522009-09-21 16:56:56 +00001200/// \brief Add type specifiers for the current language as keyword results.
Douglas Gregorbca403c2010-01-13 23:51:12 +00001201static void AddTypeSpecifierResults(const LangOptions &LangOpts,
Douglas Gregor86d9a522009-09-21 16:56:56 +00001202 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00001203 typedef CodeCompletionResult Result;
Douglas Gregor12e13132010-05-26 22:00:08 +00001204 Results.AddResult(Result("short", CCP_Type));
1205 Results.AddResult(Result("long", CCP_Type));
1206 Results.AddResult(Result("signed", CCP_Type));
1207 Results.AddResult(Result("unsigned", CCP_Type));
1208 Results.AddResult(Result("void", CCP_Type));
1209 Results.AddResult(Result("char", CCP_Type));
1210 Results.AddResult(Result("int", CCP_Type));
1211 Results.AddResult(Result("float", CCP_Type));
1212 Results.AddResult(Result("double", CCP_Type));
1213 Results.AddResult(Result("enum", CCP_Type));
1214 Results.AddResult(Result("struct", CCP_Type));
1215 Results.AddResult(Result("union", CCP_Type));
1216 Results.AddResult(Result("const", CCP_Type));
1217 Results.AddResult(Result("volatile", CCP_Type));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001218
Douglas Gregor86d9a522009-09-21 16:56:56 +00001219 if (LangOpts.C99) {
1220 // C99-specific
Douglas Gregor12e13132010-05-26 22:00:08 +00001221 Results.AddResult(Result("_Complex", CCP_Type));
1222 Results.AddResult(Result("_Imaginary", CCP_Type));
1223 Results.AddResult(Result("_Bool", CCP_Type));
1224 Results.AddResult(Result("restrict", CCP_Type));
Douglas Gregor86d9a522009-09-21 16:56:56 +00001225 }
1226
Douglas Gregor218937c2011-02-01 19:23:04 +00001227 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor86d9a522009-09-21 16:56:56 +00001228 if (LangOpts.CPlusPlus) {
1229 // C++-specific
Douglas Gregorb05496d2010-09-20 21:11:48 +00001230 Results.AddResult(Result("bool", CCP_Type +
1231 (LangOpts.ObjC1? CCD_bool_in_ObjC : 0)));
Douglas Gregor12e13132010-05-26 22:00:08 +00001232 Results.AddResult(Result("class", CCP_Type));
1233 Results.AddResult(Result("wchar_t", CCP_Type));
Douglas Gregor86d9a522009-09-21 16:56:56 +00001234
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001235 // typename qualified-id
Douglas Gregor218937c2011-02-01 19:23:04 +00001236 Builder.AddTypedTextChunk("typename");
1237 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1238 Builder.AddPlaceholderChunk("qualifier");
1239 Builder.AddTextChunk("::");
1240 Builder.AddPlaceholderChunk("name");
1241 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregord8e8a582010-05-25 21:41:55 +00001242
Douglas Gregor86d9a522009-09-21 16:56:56 +00001243 if (LangOpts.CPlusPlus0x) {
Douglas Gregor12e13132010-05-26 22:00:08 +00001244 Results.AddResult(Result("auto", CCP_Type));
1245 Results.AddResult(Result("char16_t", CCP_Type));
1246 Results.AddResult(Result("char32_t", CCP_Type));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001247
Douglas Gregor218937c2011-02-01 19:23:04 +00001248 Builder.AddTypedTextChunk("decltype");
1249 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1250 Builder.AddPlaceholderChunk("expression");
1251 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1252 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor86d9a522009-09-21 16:56:56 +00001253 }
1254 }
1255
1256 // GNU extensions
1257 if (LangOpts.GNUMode) {
1258 // FIXME: Enable when we actually support decimal floating point.
Douglas Gregora4477812010-01-14 16:01:26 +00001259 // Results.AddResult(Result("_Decimal32"));
1260 // Results.AddResult(Result("_Decimal64"));
1261 // Results.AddResult(Result("_Decimal128"));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001262
Douglas Gregor218937c2011-02-01 19:23:04 +00001263 Builder.AddTypedTextChunk("typeof");
1264 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1265 Builder.AddPlaceholderChunk("expression");
1266 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001267
Douglas Gregor218937c2011-02-01 19:23:04 +00001268 Builder.AddTypedTextChunk("typeof");
1269 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1270 Builder.AddPlaceholderChunk("type");
1271 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1272 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor86d9a522009-09-21 16:56:56 +00001273 }
1274}
1275
John McCallf312b1e2010-08-26 23:41:50 +00001276static void AddStorageSpecifiers(Sema::ParserCompletionContext CCC,
Douglas Gregor01dfea02010-01-10 23:08:15 +00001277 const LangOptions &LangOpts,
Douglas Gregor01dfea02010-01-10 23:08:15 +00001278 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00001279 typedef CodeCompletionResult Result;
Douglas Gregor01dfea02010-01-10 23:08:15 +00001280 // Note: we don't suggest either "auto" or "register", because both
1281 // are pointless as storage specifiers. Elsewhere, we suggest "auto"
1282 // in C++0x as a type specifier.
Douglas Gregora4477812010-01-14 16:01:26 +00001283 Results.AddResult(Result("extern"));
1284 Results.AddResult(Result("static"));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001285}
1286
John McCallf312b1e2010-08-26 23:41:50 +00001287static void AddFunctionSpecifiers(Sema::ParserCompletionContext CCC,
Douglas Gregor01dfea02010-01-10 23:08:15 +00001288 const LangOptions &LangOpts,
Douglas Gregor01dfea02010-01-10 23:08:15 +00001289 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00001290 typedef CodeCompletionResult Result;
Douglas Gregor01dfea02010-01-10 23:08:15 +00001291 switch (CCC) {
John McCallf312b1e2010-08-26 23:41:50 +00001292 case Sema::PCC_Class:
1293 case Sema::PCC_MemberTemplate:
Douglas Gregor01dfea02010-01-10 23:08:15 +00001294 if (LangOpts.CPlusPlus) {
Douglas Gregora4477812010-01-14 16:01:26 +00001295 Results.AddResult(Result("explicit"));
1296 Results.AddResult(Result("friend"));
1297 Results.AddResult(Result("mutable"));
1298 Results.AddResult(Result("virtual"));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001299 }
1300 // Fall through
1301
John McCallf312b1e2010-08-26 23:41:50 +00001302 case Sema::PCC_ObjCInterface:
1303 case Sema::PCC_ObjCImplementation:
1304 case Sema::PCC_Namespace:
1305 case Sema::PCC_Template:
Douglas Gregor01dfea02010-01-10 23:08:15 +00001306 if (LangOpts.CPlusPlus || LangOpts.C99)
Douglas Gregora4477812010-01-14 16:01:26 +00001307 Results.AddResult(Result("inline"));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001308 break;
1309
John McCallf312b1e2010-08-26 23:41:50 +00001310 case Sema::PCC_ObjCInstanceVariableList:
1311 case Sema::PCC_Expression:
1312 case Sema::PCC_Statement:
1313 case Sema::PCC_ForInit:
1314 case Sema::PCC_Condition:
1315 case Sema::PCC_RecoveryInFunction:
1316 case Sema::PCC_Type:
Douglas Gregor02688102010-09-14 23:59:36 +00001317 case Sema::PCC_ParenthesizedExpression:
Douglas Gregor68e3c2e2011-02-15 20:33:25 +00001318 case Sema::PCC_LocalDeclarationSpecifiers:
Douglas Gregor01dfea02010-01-10 23:08:15 +00001319 break;
1320 }
1321}
1322
Douglas Gregorbca403c2010-01-13 23:51:12 +00001323static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt);
1324static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt);
1325static void AddObjCVisibilityResults(const LangOptions &LangOpts,
Douglas Gregorc38c3e12010-01-13 21:54:15 +00001326 ResultBuilder &Results,
1327 bool NeedAt);
Douglas Gregorbca403c2010-01-13 23:51:12 +00001328static void AddObjCImplementationResults(const LangOptions &LangOpts,
Douglas Gregorb6ac2452010-01-13 21:24:21 +00001329 ResultBuilder &Results,
1330 bool NeedAt);
Douglas Gregorbca403c2010-01-13 23:51:12 +00001331static void AddObjCInterfaceResults(const LangOptions &LangOpts,
Douglas Gregorb6ac2452010-01-13 21:24:21 +00001332 ResultBuilder &Results,
1333 bool NeedAt);
Douglas Gregorbca403c2010-01-13 23:51:12 +00001334static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt);
Douglas Gregorb6ac2452010-01-13 21:24:21 +00001335
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001336static void AddTypedefResult(ResultBuilder &Results) {
Douglas Gregor218937c2011-02-01 19:23:04 +00001337 CodeCompletionBuilder Builder(Results.getAllocator());
1338 Builder.AddTypedTextChunk("typedef");
1339 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1340 Builder.AddPlaceholderChunk("type");
1341 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1342 Builder.AddPlaceholderChunk("name");
1343 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001344}
1345
John McCallf312b1e2010-08-26 23:41:50 +00001346static bool WantTypesInContext(Sema::ParserCompletionContext CCC,
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001347 const LangOptions &LangOpts) {
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001348 switch (CCC) {
John McCallf312b1e2010-08-26 23:41:50 +00001349 case Sema::PCC_Namespace:
1350 case Sema::PCC_Class:
1351 case Sema::PCC_ObjCInstanceVariableList:
1352 case Sema::PCC_Template:
1353 case Sema::PCC_MemberTemplate:
1354 case Sema::PCC_Statement:
1355 case Sema::PCC_RecoveryInFunction:
1356 case Sema::PCC_Type:
Douglas Gregor02688102010-09-14 23:59:36 +00001357 case Sema::PCC_ParenthesizedExpression:
Douglas Gregor68e3c2e2011-02-15 20:33:25 +00001358 case Sema::PCC_LocalDeclarationSpecifiers:
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001359 return true;
1360
John McCallf312b1e2010-08-26 23:41:50 +00001361 case Sema::PCC_Expression:
1362 case Sema::PCC_Condition:
Douglas Gregor02688102010-09-14 23:59:36 +00001363 return LangOpts.CPlusPlus;
1364
1365 case Sema::PCC_ObjCInterface:
1366 case Sema::PCC_ObjCImplementation:
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001367 return false;
1368
John McCallf312b1e2010-08-26 23:41:50 +00001369 case Sema::PCC_ForInit:
Douglas Gregor02688102010-09-14 23:59:36 +00001370 return LangOpts.CPlusPlus || LangOpts.ObjC1 || LangOpts.C99;
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001371 }
David Blaikie7530c032012-01-17 06:56:22 +00001372
1373 llvm_unreachable("Invalid ParserCompletionContext!");
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001374}
1375
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00001376static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context,
1377 const Preprocessor &PP) {
1378 PrintingPolicy Policy = Sema::getPrintingPolicy(Context, PP);
Douglas Gregor8ca72082011-10-18 21:20:17 +00001379 Policy.AnonymousTagLocations = false;
1380 Policy.SuppressStrongLifetime = true;
Douglas Gregor25270b62011-11-03 00:16:13 +00001381 Policy.SuppressUnwrittenScope = true;
Douglas Gregor8ca72082011-10-18 21:20:17 +00001382 return Policy;
1383}
1384
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00001385/// \brief Retrieve a printing policy suitable for code completion.
1386static PrintingPolicy getCompletionPrintingPolicy(Sema &S) {
1387 return getCompletionPrintingPolicy(S.Context, S.PP);
1388}
1389
Douglas Gregor8ca72082011-10-18 21:20:17 +00001390/// \brief Retrieve the string representation of the given type as a string
1391/// that has the appropriate lifetime for code completion.
1392///
1393/// This routine provides a fast path where we provide constant strings for
1394/// common type names.
1395static const char *GetCompletionTypeString(QualType T,
1396 ASTContext &Context,
1397 const PrintingPolicy &Policy,
1398 CodeCompletionAllocator &Allocator) {
1399 if (!T.getLocalQualifiers()) {
1400 // Built-in type names are constant strings.
1401 if (const BuiltinType *BT = dyn_cast<BuiltinType>(T))
1402 return BT->getName(Policy);
1403
1404 // Anonymous tag types are constant strings.
1405 if (const TagType *TagT = dyn_cast<TagType>(T))
1406 if (TagDecl *Tag = TagT->getDecl())
1407 if (!Tag->getIdentifier() && !Tag->getTypedefNameForAnonDecl()) {
1408 switch (Tag->getTagKind()) {
1409 case TTK_Struct: return "struct <anonymous>";
1410 case TTK_Class: return "class <anonymous>";
1411 case TTK_Union: return "union <anonymous>";
1412 case TTK_Enum: return "enum <anonymous>";
1413 }
1414 }
1415 }
1416
1417 // Slow path: format the type as a string.
1418 std::string Result;
1419 T.getAsStringInternal(Result, Policy);
1420 return Allocator.CopyString(Result);
1421}
1422
Douglas Gregor01dfea02010-01-10 23:08:15 +00001423/// \brief Add language constructs that show up for "ordinary" names.
John McCallf312b1e2010-08-26 23:41:50 +00001424static void AddOrdinaryNameResults(Sema::ParserCompletionContext CCC,
Douglas Gregor01dfea02010-01-10 23:08:15 +00001425 Scope *S,
1426 Sema &SemaRef,
Douglas Gregor01dfea02010-01-10 23:08:15 +00001427 ResultBuilder &Results) {
Douglas Gregor8ca72082011-10-18 21:20:17 +00001428 CodeCompletionAllocator &Allocator = Results.getAllocator();
1429 CodeCompletionBuilder Builder(Allocator);
1430 PrintingPolicy Policy = getCompletionPrintingPolicy(SemaRef);
Douglas Gregor218937c2011-02-01 19:23:04 +00001431
John McCall0a2c5e22010-08-25 06:19:51 +00001432 typedef CodeCompletionResult Result;
Douglas Gregor01dfea02010-01-10 23:08:15 +00001433 switch (CCC) {
John McCallf312b1e2010-08-26 23:41:50 +00001434 case Sema::PCC_Namespace:
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001435 if (SemaRef.getLangOptions().CPlusPlus) {
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001436 if (Results.includeCodePatterns()) {
1437 // namespace <identifier> { declarations }
Douglas Gregor218937c2011-02-01 19:23:04 +00001438 Builder.AddTypedTextChunk("namespace");
1439 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1440 Builder.AddPlaceholderChunk("identifier");
1441 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1442 Builder.AddPlaceholderChunk("declarations");
1443 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1444 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1445 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001446 }
1447
Douglas Gregor01dfea02010-01-10 23:08:15 +00001448 // namespace identifier = identifier ;
Douglas Gregor218937c2011-02-01 19:23:04 +00001449 Builder.AddTypedTextChunk("namespace");
1450 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1451 Builder.AddPlaceholderChunk("name");
1452 Builder.AddChunk(CodeCompletionString::CK_Equal);
1453 Builder.AddPlaceholderChunk("namespace");
1454 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001455
1456 // Using directives
Douglas Gregor218937c2011-02-01 19:23:04 +00001457 Builder.AddTypedTextChunk("using");
1458 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1459 Builder.AddTextChunk("namespace");
1460 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1461 Builder.AddPlaceholderChunk("identifier");
1462 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001463
1464 // asm(string-literal)
Douglas Gregor218937c2011-02-01 19:23:04 +00001465 Builder.AddTypedTextChunk("asm");
1466 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1467 Builder.AddPlaceholderChunk("string-literal");
1468 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1469 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001470
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001471 if (Results.includeCodePatterns()) {
1472 // Explicit template instantiation
Douglas Gregor218937c2011-02-01 19:23:04 +00001473 Builder.AddTypedTextChunk("template");
1474 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1475 Builder.AddPlaceholderChunk("declaration");
1476 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001477 }
Douglas Gregor01dfea02010-01-10 23:08:15 +00001478 }
Douglas Gregorb6ac2452010-01-13 21:24:21 +00001479
1480 if (SemaRef.getLangOptions().ObjC1)
Douglas Gregorbca403c2010-01-13 23:51:12 +00001481 AddObjCTopLevelResults(Results, true);
Douglas Gregorb6ac2452010-01-13 21:24:21 +00001482
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001483 AddTypedefResult(Results);
Douglas Gregor01dfea02010-01-10 23:08:15 +00001484 // Fall through
1485
John McCallf312b1e2010-08-26 23:41:50 +00001486 case Sema::PCC_Class:
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001487 if (SemaRef.getLangOptions().CPlusPlus) {
Douglas Gregor01dfea02010-01-10 23:08:15 +00001488 // Using declaration
Douglas Gregor218937c2011-02-01 19:23:04 +00001489 Builder.AddTypedTextChunk("using");
1490 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1491 Builder.AddPlaceholderChunk("qualifier");
1492 Builder.AddTextChunk("::");
1493 Builder.AddPlaceholderChunk("name");
1494 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001495
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001496 // using typename qualifier::name (only in a dependent context)
Douglas Gregor01dfea02010-01-10 23:08:15 +00001497 if (SemaRef.CurContext->isDependentContext()) {
Douglas Gregor218937c2011-02-01 19:23:04 +00001498 Builder.AddTypedTextChunk("using");
1499 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1500 Builder.AddTextChunk("typename");
1501 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1502 Builder.AddPlaceholderChunk("qualifier");
1503 Builder.AddTextChunk("::");
1504 Builder.AddPlaceholderChunk("name");
1505 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001506 }
1507
John McCallf312b1e2010-08-26 23:41:50 +00001508 if (CCC == Sema::PCC_Class) {
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001509 AddTypedefResult(Results);
1510
Douglas Gregor01dfea02010-01-10 23:08:15 +00001511 // public:
Douglas Gregor218937c2011-02-01 19:23:04 +00001512 Builder.AddTypedTextChunk("public");
1513 Builder.AddChunk(CodeCompletionString::CK_Colon);
1514 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001515
1516 // protected:
Douglas Gregor218937c2011-02-01 19:23:04 +00001517 Builder.AddTypedTextChunk("protected");
1518 Builder.AddChunk(CodeCompletionString::CK_Colon);
1519 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001520
1521 // private:
Douglas Gregor218937c2011-02-01 19:23:04 +00001522 Builder.AddTypedTextChunk("private");
1523 Builder.AddChunk(CodeCompletionString::CK_Colon);
1524 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001525 }
1526 }
1527 // Fall through
1528
John McCallf312b1e2010-08-26 23:41:50 +00001529 case Sema::PCC_Template:
1530 case Sema::PCC_MemberTemplate:
Douglas Gregord8e8a582010-05-25 21:41:55 +00001531 if (SemaRef.getLangOptions().CPlusPlus && Results.includeCodePatterns()) {
Douglas Gregor01dfea02010-01-10 23:08:15 +00001532 // template < parameters >
Douglas Gregor218937c2011-02-01 19:23:04 +00001533 Builder.AddTypedTextChunk("template");
1534 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1535 Builder.AddPlaceholderChunk("parameters");
1536 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1537 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001538 }
1539
Douglas Gregorbca403c2010-01-13 23:51:12 +00001540 AddStorageSpecifiers(CCC, SemaRef.getLangOptions(), Results);
1541 AddFunctionSpecifiers(CCC, SemaRef.getLangOptions(), Results);
Douglas Gregor01dfea02010-01-10 23:08:15 +00001542 break;
1543
John McCallf312b1e2010-08-26 23:41:50 +00001544 case Sema::PCC_ObjCInterface:
Douglas Gregorbca403c2010-01-13 23:51:12 +00001545 AddObjCInterfaceResults(SemaRef.getLangOptions(), Results, true);
1546 AddStorageSpecifiers(CCC, SemaRef.getLangOptions(), Results);
1547 AddFunctionSpecifiers(CCC, SemaRef.getLangOptions(), Results);
Douglas Gregorb6ac2452010-01-13 21:24:21 +00001548 break;
1549
John McCallf312b1e2010-08-26 23:41:50 +00001550 case Sema::PCC_ObjCImplementation:
Douglas Gregorbca403c2010-01-13 23:51:12 +00001551 AddObjCImplementationResults(SemaRef.getLangOptions(), Results, true);
1552 AddStorageSpecifiers(CCC, SemaRef.getLangOptions(), Results);
1553 AddFunctionSpecifiers(CCC, SemaRef.getLangOptions(), Results);
Douglas Gregorb6ac2452010-01-13 21:24:21 +00001554 break;
1555
John McCallf312b1e2010-08-26 23:41:50 +00001556 case Sema::PCC_ObjCInstanceVariableList:
Douglas Gregorbca403c2010-01-13 23:51:12 +00001557 AddObjCVisibilityResults(SemaRef.getLangOptions(), Results, true);
Douglas Gregorc38c3e12010-01-13 21:54:15 +00001558 break;
1559
John McCallf312b1e2010-08-26 23:41:50 +00001560 case Sema::PCC_RecoveryInFunction:
1561 case Sema::PCC_Statement: {
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001562 AddTypedefResult(Results);
Douglas Gregor01dfea02010-01-10 23:08:15 +00001563
Douglas Gregorec3310a2011-04-12 02:47:21 +00001564 if (SemaRef.getLangOptions().CPlusPlus && Results.includeCodePatterns() &&
1565 SemaRef.getLangOptions().CXXExceptions) {
Douglas Gregor218937c2011-02-01 19:23:04 +00001566 Builder.AddTypedTextChunk("try");
1567 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1568 Builder.AddPlaceholderChunk("statements");
1569 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1570 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1571 Builder.AddTextChunk("catch");
1572 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1573 Builder.AddPlaceholderChunk("declaration");
1574 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1575 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1576 Builder.AddPlaceholderChunk("statements");
1577 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1578 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1579 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001580 }
Douglas Gregorb6ac2452010-01-13 21:24:21 +00001581 if (SemaRef.getLangOptions().ObjC1)
Douglas Gregorbca403c2010-01-13 23:51:12 +00001582 AddObjCStatementResults(Results, true);
Douglas Gregorb6ac2452010-01-13 21:24:21 +00001583
Douglas Gregord8e8a582010-05-25 21:41:55 +00001584 if (Results.includeCodePatterns()) {
1585 // if (condition) { statements }
Douglas Gregor218937c2011-02-01 19:23:04 +00001586 Builder.AddTypedTextChunk("if");
1587 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
Douglas Gregord8e8a582010-05-25 21:41:55 +00001588 if (SemaRef.getLangOptions().CPlusPlus)
Douglas Gregor218937c2011-02-01 19:23:04 +00001589 Builder.AddPlaceholderChunk("condition");
Douglas Gregord8e8a582010-05-25 21:41:55 +00001590 else
Douglas Gregor218937c2011-02-01 19:23:04 +00001591 Builder.AddPlaceholderChunk("expression");
1592 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1593 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1594 Builder.AddPlaceholderChunk("statements");
1595 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1596 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1597 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001598
Douglas Gregord8e8a582010-05-25 21:41:55 +00001599 // switch (condition) { }
Douglas Gregor218937c2011-02-01 19:23:04 +00001600 Builder.AddTypedTextChunk("switch");
1601 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
Douglas Gregord8e8a582010-05-25 21:41:55 +00001602 if (SemaRef.getLangOptions().CPlusPlus)
Douglas Gregor218937c2011-02-01 19:23:04 +00001603 Builder.AddPlaceholderChunk("condition");
Douglas Gregord8e8a582010-05-25 21:41:55 +00001604 else
Douglas Gregor218937c2011-02-01 19:23:04 +00001605 Builder.AddPlaceholderChunk("expression");
1606 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1607 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1608 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1609 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1610 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregord8e8a582010-05-25 21:41:55 +00001611 }
1612
Douglas Gregor01dfea02010-01-10 23:08:15 +00001613 // Switch-specific statements.
John McCall781472f2010-08-25 08:40:02 +00001614 if (!SemaRef.getCurFunction()->SwitchStack.empty()) {
Douglas Gregor01dfea02010-01-10 23:08:15 +00001615 // case expression:
Douglas Gregor218937c2011-02-01 19:23:04 +00001616 Builder.AddTypedTextChunk("case");
1617 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1618 Builder.AddPlaceholderChunk("expression");
1619 Builder.AddChunk(CodeCompletionString::CK_Colon);
1620 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001621
1622 // default:
Douglas Gregor218937c2011-02-01 19:23:04 +00001623 Builder.AddTypedTextChunk("default");
1624 Builder.AddChunk(CodeCompletionString::CK_Colon);
1625 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001626 }
1627
Douglas Gregord8e8a582010-05-25 21:41:55 +00001628 if (Results.includeCodePatterns()) {
1629 /// while (condition) { statements }
Douglas Gregor218937c2011-02-01 19:23:04 +00001630 Builder.AddTypedTextChunk("while");
1631 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
Douglas Gregord8e8a582010-05-25 21:41:55 +00001632 if (SemaRef.getLangOptions().CPlusPlus)
Douglas Gregor218937c2011-02-01 19:23:04 +00001633 Builder.AddPlaceholderChunk("condition");
Douglas Gregord8e8a582010-05-25 21:41:55 +00001634 else
Douglas Gregor218937c2011-02-01 19:23:04 +00001635 Builder.AddPlaceholderChunk("expression");
1636 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1637 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1638 Builder.AddPlaceholderChunk("statements");
1639 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1640 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1641 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregord8e8a582010-05-25 21:41:55 +00001642
1643 // do { statements } while ( expression );
Douglas Gregor218937c2011-02-01 19:23:04 +00001644 Builder.AddTypedTextChunk("do");
1645 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1646 Builder.AddPlaceholderChunk("statements");
1647 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1648 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1649 Builder.AddTextChunk("while");
1650 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1651 Builder.AddPlaceholderChunk("expression");
1652 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1653 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001654
Douglas Gregord8e8a582010-05-25 21:41:55 +00001655 // for ( for-init-statement ; condition ; expression ) { statements }
Douglas Gregor218937c2011-02-01 19:23:04 +00001656 Builder.AddTypedTextChunk("for");
1657 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
Douglas Gregord8e8a582010-05-25 21:41:55 +00001658 if (SemaRef.getLangOptions().CPlusPlus || SemaRef.getLangOptions().C99)
Douglas Gregor218937c2011-02-01 19:23:04 +00001659 Builder.AddPlaceholderChunk("init-statement");
Douglas Gregord8e8a582010-05-25 21:41:55 +00001660 else
Douglas Gregor218937c2011-02-01 19:23:04 +00001661 Builder.AddPlaceholderChunk("init-expression");
1662 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1663 Builder.AddPlaceholderChunk("condition");
1664 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1665 Builder.AddPlaceholderChunk("inc-expression");
1666 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1667 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1668 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1669 Builder.AddPlaceholderChunk("statements");
1670 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1671 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1672 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregord8e8a582010-05-25 21:41:55 +00001673 }
Douglas Gregor01dfea02010-01-10 23:08:15 +00001674
1675 if (S->getContinueParent()) {
1676 // continue ;
Douglas Gregor218937c2011-02-01 19:23:04 +00001677 Builder.AddTypedTextChunk("continue");
1678 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001679 }
1680
1681 if (S->getBreakParent()) {
1682 // break ;
Douglas Gregor218937c2011-02-01 19:23:04 +00001683 Builder.AddTypedTextChunk("break");
1684 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001685 }
1686
1687 // "return expression ;" or "return ;", depending on whether we
1688 // know the function is void or not.
1689 bool isVoid = false;
1690 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(SemaRef.CurContext))
1691 isVoid = Function->getResultType()->isVoidType();
1692 else if (ObjCMethodDecl *Method
1693 = dyn_cast<ObjCMethodDecl>(SemaRef.CurContext))
1694 isVoid = Method->getResultType()->isVoidType();
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001695 else if (SemaRef.getCurBlock() &&
1696 !SemaRef.getCurBlock()->ReturnType.isNull())
1697 isVoid = SemaRef.getCurBlock()->ReturnType->isVoidType();
Douglas Gregor218937c2011-02-01 19:23:04 +00001698 Builder.AddTypedTextChunk("return");
Douglas Gregor93298002010-02-18 04:06:48 +00001699 if (!isVoid) {
Douglas Gregor218937c2011-02-01 19:23:04 +00001700 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1701 Builder.AddPlaceholderChunk("expression");
Douglas Gregor93298002010-02-18 04:06:48 +00001702 }
Douglas Gregor218937c2011-02-01 19:23:04 +00001703 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001704
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001705 // goto identifier ;
Douglas Gregor218937c2011-02-01 19:23:04 +00001706 Builder.AddTypedTextChunk("goto");
1707 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1708 Builder.AddPlaceholderChunk("label");
1709 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001710
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001711 // Using directives
Douglas Gregor218937c2011-02-01 19:23:04 +00001712 Builder.AddTypedTextChunk("using");
1713 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1714 Builder.AddTextChunk("namespace");
1715 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1716 Builder.AddPlaceholderChunk("identifier");
1717 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001718 }
1719
1720 // Fall through (for statement expressions).
John McCallf312b1e2010-08-26 23:41:50 +00001721 case Sema::PCC_ForInit:
1722 case Sema::PCC_Condition:
Douglas Gregorbca403c2010-01-13 23:51:12 +00001723 AddStorageSpecifiers(CCC, SemaRef.getLangOptions(), Results);
Douglas Gregor01dfea02010-01-10 23:08:15 +00001724 // Fall through: conditions and statements can have expressions.
1725
Douglas Gregor02688102010-09-14 23:59:36 +00001726 case Sema::PCC_ParenthesizedExpression:
John McCallf85e1932011-06-15 23:02:42 +00001727 if (SemaRef.getLangOptions().ObjCAutoRefCount &&
1728 CCC == Sema::PCC_ParenthesizedExpression) {
1729 // (__bridge <type>)<expression>
1730 Builder.AddTypedTextChunk("__bridge");
1731 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1732 Builder.AddPlaceholderChunk("type");
1733 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1734 Builder.AddPlaceholderChunk("expression");
1735 Results.AddResult(Result(Builder.TakeString()));
1736
1737 // (__bridge_transfer <Objective-C type>)<expression>
1738 Builder.AddTypedTextChunk("__bridge_transfer");
1739 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1740 Builder.AddPlaceholderChunk("Objective-C type");
1741 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1742 Builder.AddPlaceholderChunk("expression");
1743 Results.AddResult(Result(Builder.TakeString()));
1744
1745 // (__bridge_retained <CF type>)<expression>
1746 Builder.AddTypedTextChunk("__bridge_retained");
1747 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1748 Builder.AddPlaceholderChunk("CF type");
1749 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1750 Builder.AddPlaceholderChunk("expression");
1751 Results.AddResult(Result(Builder.TakeString()));
1752 }
1753 // Fall through
1754
John McCallf312b1e2010-08-26 23:41:50 +00001755 case Sema::PCC_Expression: {
Douglas Gregor01dfea02010-01-10 23:08:15 +00001756 if (SemaRef.getLangOptions().CPlusPlus) {
1757 // 'this', if we're in a non-static member function.
Eli Friedman72899c32012-01-07 04:59:52 +00001758 QualType ThisTy = SemaRef.getCurrentThisType();
Douglas Gregor8ca72082011-10-18 21:20:17 +00001759 if (!ThisTy.isNull()) {
1760 Builder.AddResultTypeChunk(GetCompletionTypeString(ThisTy,
1761 SemaRef.Context,
1762 Policy,
1763 Allocator));
1764 Builder.AddTypedTextChunk("this");
1765 Results.AddResult(Result(Builder.TakeString()));
1766 }
Douglas Gregor01dfea02010-01-10 23:08:15 +00001767
Douglas Gregor8ca72082011-10-18 21:20:17 +00001768 // true
1769 Builder.AddResultTypeChunk("bool");
1770 Builder.AddTypedTextChunk("true");
1771 Results.AddResult(Result(Builder.TakeString()));
1772
1773 // false
1774 Builder.AddResultTypeChunk("bool");
1775 Builder.AddTypedTextChunk("false");
1776 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001777
Douglas Gregorec3310a2011-04-12 02:47:21 +00001778 if (SemaRef.getLangOptions().RTTI) {
1779 // dynamic_cast < type-id > ( expression )
1780 Builder.AddTypedTextChunk("dynamic_cast");
1781 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1782 Builder.AddPlaceholderChunk("type");
1783 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1784 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1785 Builder.AddPlaceholderChunk("expression");
1786 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1787 Results.AddResult(Result(Builder.TakeString()));
1788 }
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001789
1790 // static_cast < type-id > ( expression )
Douglas Gregor218937c2011-02-01 19:23:04 +00001791 Builder.AddTypedTextChunk("static_cast");
1792 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1793 Builder.AddPlaceholderChunk("type");
1794 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1795 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1796 Builder.AddPlaceholderChunk("expression");
1797 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1798 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001799
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001800 // reinterpret_cast < type-id > ( expression )
Douglas Gregor218937c2011-02-01 19:23:04 +00001801 Builder.AddTypedTextChunk("reinterpret_cast");
1802 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1803 Builder.AddPlaceholderChunk("type");
1804 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1805 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1806 Builder.AddPlaceholderChunk("expression");
1807 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1808 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001809
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001810 // const_cast < type-id > ( expression )
Douglas Gregor218937c2011-02-01 19:23:04 +00001811 Builder.AddTypedTextChunk("const_cast");
1812 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1813 Builder.AddPlaceholderChunk("type");
1814 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1815 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1816 Builder.AddPlaceholderChunk("expression");
1817 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1818 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001819
Douglas Gregorec3310a2011-04-12 02:47:21 +00001820 if (SemaRef.getLangOptions().RTTI) {
1821 // typeid ( expression-or-type )
Douglas Gregor8ca72082011-10-18 21:20:17 +00001822 Builder.AddResultTypeChunk("std::type_info");
Douglas Gregorec3310a2011-04-12 02:47:21 +00001823 Builder.AddTypedTextChunk("typeid");
1824 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1825 Builder.AddPlaceholderChunk("expression-or-type");
1826 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1827 Results.AddResult(Result(Builder.TakeString()));
1828 }
1829
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001830 // new T ( ... )
Douglas Gregor218937c2011-02-01 19:23:04 +00001831 Builder.AddTypedTextChunk("new");
1832 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1833 Builder.AddPlaceholderChunk("type");
1834 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1835 Builder.AddPlaceholderChunk("expressions");
1836 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1837 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001838
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001839 // new T [ ] ( ... )
Douglas Gregor218937c2011-02-01 19:23:04 +00001840 Builder.AddTypedTextChunk("new");
1841 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1842 Builder.AddPlaceholderChunk("type");
1843 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
1844 Builder.AddPlaceholderChunk("size");
1845 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
1846 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1847 Builder.AddPlaceholderChunk("expressions");
1848 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1849 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001850
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001851 // delete expression
Douglas Gregor8ca72082011-10-18 21:20:17 +00001852 Builder.AddResultTypeChunk("void");
Douglas Gregor218937c2011-02-01 19:23:04 +00001853 Builder.AddTypedTextChunk("delete");
1854 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1855 Builder.AddPlaceholderChunk("expression");
1856 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001857
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001858 // delete [] expression
Douglas Gregor8ca72082011-10-18 21:20:17 +00001859 Builder.AddResultTypeChunk("void");
Douglas Gregor218937c2011-02-01 19:23:04 +00001860 Builder.AddTypedTextChunk("delete");
1861 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1862 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
1863 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
1864 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1865 Builder.AddPlaceholderChunk("expression");
1866 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001867
Douglas Gregorec3310a2011-04-12 02:47:21 +00001868 if (SemaRef.getLangOptions().CXXExceptions) {
1869 // throw expression
Douglas Gregor8ca72082011-10-18 21:20:17 +00001870 Builder.AddResultTypeChunk("void");
Douglas Gregorec3310a2011-04-12 02:47:21 +00001871 Builder.AddTypedTextChunk("throw");
1872 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1873 Builder.AddPlaceholderChunk("expression");
1874 Results.AddResult(Result(Builder.TakeString()));
1875 }
Douglas Gregora50216c2011-10-18 16:29:03 +00001876
Douglas Gregor12e13132010-05-26 22:00:08 +00001877 // FIXME: Rethrow?
Douglas Gregora50216c2011-10-18 16:29:03 +00001878
1879 if (SemaRef.getLangOptions().CPlusPlus0x) {
1880 // nullptr
Douglas Gregor8ca72082011-10-18 21:20:17 +00001881 Builder.AddResultTypeChunk("std::nullptr_t");
Douglas Gregora50216c2011-10-18 16:29:03 +00001882 Builder.AddTypedTextChunk("nullptr");
1883 Results.AddResult(Result(Builder.TakeString()));
1884
1885 // alignof
Douglas Gregor8ca72082011-10-18 21:20:17 +00001886 Builder.AddResultTypeChunk("size_t");
Douglas Gregora50216c2011-10-18 16:29:03 +00001887 Builder.AddTypedTextChunk("alignof");
1888 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1889 Builder.AddPlaceholderChunk("type");
1890 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1891 Results.AddResult(Result(Builder.TakeString()));
1892
1893 // noexcept
Douglas Gregor8ca72082011-10-18 21:20:17 +00001894 Builder.AddResultTypeChunk("bool");
Douglas Gregora50216c2011-10-18 16:29:03 +00001895 Builder.AddTypedTextChunk("noexcept");
1896 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1897 Builder.AddPlaceholderChunk("expression");
1898 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1899 Results.AddResult(Result(Builder.TakeString()));
1900
1901 // sizeof... expression
Douglas Gregor8ca72082011-10-18 21:20:17 +00001902 Builder.AddResultTypeChunk("size_t");
Douglas Gregora50216c2011-10-18 16:29:03 +00001903 Builder.AddTypedTextChunk("sizeof...");
1904 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1905 Builder.AddPlaceholderChunk("parameter-pack");
1906 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1907 Results.AddResult(Result(Builder.TakeString()));
1908 }
Douglas Gregor01dfea02010-01-10 23:08:15 +00001909 }
1910
1911 if (SemaRef.getLangOptions().ObjC1) {
1912 // Add "super", if we're in an Objective-C class with a superclass.
Ted Kremenek681e2562010-05-31 21:43:10 +00001913 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) {
1914 // The interface can be NULL.
1915 if (ObjCInterfaceDecl *ID = Method->getClassInterface())
Douglas Gregor8ca72082011-10-18 21:20:17 +00001916 if (ID->getSuperClass()) {
1917 std::string SuperType;
1918 SuperType = ID->getSuperClass()->getNameAsString();
1919 if (Method->isInstanceMethod())
1920 SuperType += " *";
1921
1922 Builder.AddResultTypeChunk(Allocator.CopyString(SuperType));
1923 Builder.AddTypedTextChunk("super");
1924 Results.AddResult(Result(Builder.TakeString()));
1925 }
Ted Kremenek681e2562010-05-31 21:43:10 +00001926 }
1927
Douglas Gregorbca403c2010-01-13 23:51:12 +00001928 AddObjCExpressionResults(Results, true);
Douglas Gregor01dfea02010-01-10 23:08:15 +00001929 }
1930
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001931 // sizeof expression
Douglas Gregor8ca72082011-10-18 21:20:17 +00001932 Builder.AddResultTypeChunk("size_t");
Douglas Gregor218937c2011-02-01 19:23:04 +00001933 Builder.AddTypedTextChunk("sizeof");
1934 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1935 Builder.AddPlaceholderChunk("expression-or-type");
1936 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1937 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001938 break;
1939 }
Douglas Gregord32b0222010-08-24 01:06:58 +00001940
John McCallf312b1e2010-08-26 23:41:50 +00001941 case Sema::PCC_Type:
Douglas Gregor68e3c2e2011-02-15 20:33:25 +00001942 case Sema::PCC_LocalDeclarationSpecifiers:
Douglas Gregord32b0222010-08-24 01:06:58 +00001943 break;
Douglas Gregor01dfea02010-01-10 23:08:15 +00001944 }
1945
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001946 if (WantTypesInContext(CCC, SemaRef.getLangOptions()))
1947 AddTypeSpecifierResults(SemaRef.getLangOptions(), Results);
Douglas Gregor01dfea02010-01-10 23:08:15 +00001948
John McCallf312b1e2010-08-26 23:41:50 +00001949 if (SemaRef.getLangOptions().CPlusPlus && CCC != Sema::PCC_Type)
Douglas Gregora4477812010-01-14 16:01:26 +00001950 Results.AddResult(Result("operator"));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001951}
1952
Douglas Gregorff5ce6e2009-12-18 18:53:37 +00001953/// \brief If the given declaration has an associated type, add it as a result
1954/// type chunk.
1955static void AddResultTypeChunk(ASTContext &Context,
Douglas Gregor8987b232011-09-27 23:30:47 +00001956 const PrintingPolicy &Policy,
Douglas Gregorff5ce6e2009-12-18 18:53:37 +00001957 NamedDecl *ND,
Douglas Gregor218937c2011-02-01 19:23:04 +00001958 CodeCompletionBuilder &Result) {
Douglas Gregorff5ce6e2009-12-18 18:53:37 +00001959 if (!ND)
1960 return;
Douglas Gregor6f942b22010-09-21 16:06:22 +00001961
1962 // Skip constructors and conversion functions, which have their return types
1963 // built into their names.
1964 if (isa<CXXConstructorDecl>(ND) || isa<CXXConversionDecl>(ND))
1965 return;
1966
Douglas Gregorff5ce6e2009-12-18 18:53:37 +00001967 // Determine the type of the declaration (if it has a type).
Douglas Gregor6f942b22010-09-21 16:06:22 +00001968 QualType T;
Douglas Gregorff5ce6e2009-12-18 18:53:37 +00001969 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(ND))
1970 T = Function->getResultType();
1971 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND))
1972 T = Method->getResultType();
1973 else if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND))
1974 T = FunTmpl->getTemplatedDecl()->getResultType();
1975 else if (EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND))
1976 T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext()));
1977 else if (isa<UnresolvedUsingValueDecl>(ND)) {
1978 /* Do nothing: ignore unresolved using declarations*/
John McCallf85e1932011-06-15 23:02:42 +00001979 } else if (ValueDecl *Value = dyn_cast<ValueDecl>(ND)) {
Douglas Gregorff5ce6e2009-12-18 18:53:37 +00001980 T = Value->getType();
John McCallf85e1932011-06-15 23:02:42 +00001981 } else if (ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND))
Douglas Gregorff5ce6e2009-12-18 18:53:37 +00001982 T = Property->getType();
1983
1984 if (T.isNull() || Context.hasSameType(T, Context.DependentTy))
1985 return;
1986
Douglas Gregor8987b232011-09-27 23:30:47 +00001987 Result.AddResultTypeChunk(GetCompletionTypeString(T, Context, Policy,
Douglas Gregora63f6de2011-02-01 21:15:40 +00001988 Result.getAllocator()));
Douglas Gregorff5ce6e2009-12-18 18:53:37 +00001989}
1990
Douglas Gregoraaa107a2010-08-23 23:51:41 +00001991static void MaybeAddSentinel(ASTContext &Context, NamedDecl *FunctionOrMethod,
Douglas Gregor218937c2011-02-01 19:23:04 +00001992 CodeCompletionBuilder &Result) {
Douglas Gregoraaa107a2010-08-23 23:51:41 +00001993 if (SentinelAttr *Sentinel = FunctionOrMethod->getAttr<SentinelAttr>())
1994 if (Sentinel->getSentinel() == 0) {
1995 if (Context.getLangOptions().ObjC1 &&
1996 Context.Idents.get("nil").hasMacroDefinition())
Douglas Gregor218937c2011-02-01 19:23:04 +00001997 Result.AddTextChunk(", nil");
Douglas Gregoraaa107a2010-08-23 23:51:41 +00001998 else if (Context.Idents.get("NULL").hasMacroDefinition())
Douglas Gregor218937c2011-02-01 19:23:04 +00001999 Result.AddTextChunk(", NULL");
Douglas Gregoraaa107a2010-08-23 23:51:41 +00002000 else
Douglas Gregor218937c2011-02-01 19:23:04 +00002001 Result.AddTextChunk(", (void*)0");
Douglas Gregoraaa107a2010-08-23 23:51:41 +00002002 }
2003}
2004
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002005static std::string formatObjCParamQualifiers(unsigned ObjCQuals) {
2006 std::string Result;
2007 if (ObjCQuals & Decl::OBJC_TQ_In)
Douglas Gregor6ef92092011-11-09 02:13:45 +00002008 Result += "in ";
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002009 else if (ObjCQuals & Decl::OBJC_TQ_Inout)
Douglas Gregor6ef92092011-11-09 02:13:45 +00002010 Result += "inout ";
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002011 else if (ObjCQuals & Decl::OBJC_TQ_Out)
Douglas Gregor6ef92092011-11-09 02:13:45 +00002012 Result += "out ";
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002013 if (ObjCQuals & Decl::OBJC_TQ_Bycopy)
Douglas Gregor6ef92092011-11-09 02:13:45 +00002014 Result += "bycopy ";
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002015 else if (ObjCQuals & Decl::OBJC_TQ_Byref)
Douglas Gregor6ef92092011-11-09 02:13:45 +00002016 Result += "byref ";
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002017 if (ObjCQuals & Decl::OBJC_TQ_Oneway)
Douglas Gregor6ef92092011-11-09 02:13:45 +00002018 Result += "oneway ";
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002019 return Result;
2020}
2021
Douglas Gregor83482d12010-08-24 16:15:59 +00002022static std::string FormatFunctionParameter(ASTContext &Context,
Douglas Gregor8987b232011-09-27 23:30:47 +00002023 const PrintingPolicy &Policy,
Douglas Gregoraba48082010-08-29 19:47:46 +00002024 ParmVarDecl *Param,
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002025 bool SuppressName = false,
2026 bool SuppressBlock = false) {
Douglas Gregor83482d12010-08-24 16:15:59 +00002027 bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext());
2028 if (Param->getType()->isDependentType() ||
2029 !Param->getType()->isBlockPointerType()) {
2030 // The argument for a dependent or non-block parameter is a placeholder
2031 // containing that parameter's type.
2032 std::string Result;
2033
Douglas Gregoraba48082010-08-29 19:47:46 +00002034 if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName)
Douglas Gregor83482d12010-08-24 16:15:59 +00002035 Result = Param->getIdentifier()->getName();
2036
John McCallf85e1932011-06-15 23:02:42 +00002037 Param->getType().getAsStringInternal(Result, Policy);
Douglas Gregor83482d12010-08-24 16:15:59 +00002038
2039 if (ObjCMethodParam) {
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002040 Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier())
2041 + Result + ")";
Douglas Gregoraba48082010-08-29 19:47:46 +00002042 if (Param->getIdentifier() && !SuppressName)
Douglas Gregor83482d12010-08-24 16:15:59 +00002043 Result += Param->getIdentifier()->getName();
2044 }
2045 return Result;
2046 }
2047
2048 // The argument for a block pointer parameter is a block literal with
2049 // the appropriate type.
Douglas Gregor830072c2011-02-15 22:37:09 +00002050 FunctionTypeLoc *Block = 0;
2051 FunctionProtoTypeLoc *BlockProto = 0;
Douglas Gregor83482d12010-08-24 16:15:59 +00002052 TypeLoc TL;
2053 if (TypeSourceInfo *TSInfo = Param->getTypeSourceInfo()) {
2054 TL = TSInfo->getTypeLoc().getUnqualifiedLoc();
2055 while (true) {
2056 // Look through typedefs.
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002057 if (!SuppressBlock) {
2058 if (TypedefTypeLoc *TypedefTL = dyn_cast<TypedefTypeLoc>(&TL)) {
2059 if (TypeSourceInfo *InnerTSInfo
2060 = TypedefTL->getTypedefNameDecl()->getTypeSourceInfo()) {
2061 TL = InnerTSInfo->getTypeLoc().getUnqualifiedLoc();
2062 continue;
2063 }
2064 }
2065
2066 // Look through qualified types
2067 if (QualifiedTypeLoc *QualifiedTL = dyn_cast<QualifiedTypeLoc>(&TL)) {
2068 TL = QualifiedTL->getUnqualifiedLoc();
Douglas Gregor83482d12010-08-24 16:15:59 +00002069 continue;
2070 }
2071 }
2072
Douglas Gregor83482d12010-08-24 16:15:59 +00002073 // Try to get the function prototype behind the block pointer type,
2074 // then we're done.
2075 if (BlockPointerTypeLoc *BlockPtr
2076 = dyn_cast<BlockPointerTypeLoc>(&TL)) {
Abramo Bagnara723df242010-12-14 22:11:44 +00002077 TL = BlockPtr->getPointeeLoc().IgnoreParens();
Douglas Gregor830072c2011-02-15 22:37:09 +00002078 Block = dyn_cast<FunctionTypeLoc>(&TL);
2079 BlockProto = dyn_cast<FunctionProtoTypeLoc>(&TL);
Douglas Gregor83482d12010-08-24 16:15:59 +00002080 }
2081 break;
2082 }
2083 }
2084
2085 if (!Block) {
2086 // We were unable to find a FunctionProtoTypeLoc with parameter names
2087 // for the block; just use the parameter type as a placeholder.
2088 std::string Result;
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002089 if (!ObjCMethodParam && Param->getIdentifier())
2090 Result = Param->getIdentifier()->getName();
2091
John McCallf85e1932011-06-15 23:02:42 +00002092 Param->getType().getUnqualifiedType().getAsStringInternal(Result, Policy);
Douglas Gregor83482d12010-08-24 16:15:59 +00002093
2094 if (ObjCMethodParam) {
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002095 Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier())
2096 + Result + ")";
Douglas Gregor83482d12010-08-24 16:15:59 +00002097 if (Param->getIdentifier())
2098 Result += Param->getIdentifier()->getName();
2099 }
2100
2101 return Result;
2102 }
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002103
Douglas Gregor83482d12010-08-24 16:15:59 +00002104 // We have the function prototype behind the block pointer type, as it was
2105 // written in the source.
Douglas Gregor38276252010-09-08 22:47:51 +00002106 std::string Result;
2107 QualType ResultType = Block->getTypePtr()->getResultType();
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002108 if (!ResultType->isVoidType() || SuppressBlock)
John McCallf85e1932011-06-15 23:02:42 +00002109 ResultType.getAsStringInternal(Result, Policy);
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002110
2111 // Format the parameter list.
2112 std::string Params;
Douglas Gregor830072c2011-02-15 22:37:09 +00002113 if (!BlockProto || Block->getNumArgs() == 0) {
2114 if (BlockProto && BlockProto->getTypePtr()->isVariadic())
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002115 Params = "(...)";
Douglas Gregorc2760bc2010-10-02 23:49:58 +00002116 else
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002117 Params = "(void)";
Douglas Gregor38276252010-09-08 22:47:51 +00002118 } else {
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002119 Params += "(";
Douglas Gregor38276252010-09-08 22:47:51 +00002120 for (unsigned I = 0, N = Block->getNumArgs(); I != N; ++I) {
2121 if (I)
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002122 Params += ", ";
2123 Params += FormatFunctionParameter(Context, Policy, Block->getArg(I),
2124 /*SuppressName=*/false,
2125 /*SuppressBlock=*/true);
Douglas Gregor38276252010-09-08 22:47:51 +00002126
Douglas Gregor830072c2011-02-15 22:37:09 +00002127 if (I == N - 1 && BlockProto->getTypePtr()->isVariadic())
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002128 Params += ", ...";
Douglas Gregor38276252010-09-08 22:47:51 +00002129 }
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002130 Params += ")";
Douglas Gregore17794f2010-08-31 05:13:43 +00002131 }
Douglas Gregor38276252010-09-08 22:47:51 +00002132
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002133 if (SuppressBlock) {
2134 // Format as a parameter.
2135 Result = Result + " (^";
2136 if (Param->getIdentifier())
2137 Result += Param->getIdentifier()->getName();
2138 Result += ")";
2139 Result += Params;
2140 } else {
2141 // Format as a block literal argument.
2142 Result = '^' + Result;
2143 Result += Params;
2144
2145 if (Param->getIdentifier())
2146 Result += Param->getIdentifier()->getName();
2147 }
2148
Douglas Gregor83482d12010-08-24 16:15:59 +00002149 return Result;
2150}
2151
Douglas Gregor86d9a522009-09-21 16:56:56 +00002152/// \brief Add function parameter chunks to the given code completion string.
2153static void AddFunctionParameterChunks(ASTContext &Context,
Douglas Gregor8987b232011-09-27 23:30:47 +00002154 const PrintingPolicy &Policy,
Douglas Gregor86d9a522009-09-21 16:56:56 +00002155 FunctionDecl *Function,
Douglas Gregor218937c2011-02-01 19:23:04 +00002156 CodeCompletionBuilder &Result,
2157 unsigned Start = 0,
2158 bool InOptional = false) {
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002159 typedef CodeCompletionString::Chunk Chunk;
Douglas Gregor218937c2011-02-01 19:23:04 +00002160 bool FirstParameter = true;
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002161
Douglas Gregor218937c2011-02-01 19:23:04 +00002162 for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) {
Douglas Gregor86d9a522009-09-21 16:56:56 +00002163 ParmVarDecl *Param = Function->getParamDecl(P);
2164
Douglas Gregor218937c2011-02-01 19:23:04 +00002165 if (Param->hasDefaultArg() && !InOptional) {
Douglas Gregor86d9a522009-09-21 16:56:56 +00002166 // When we see an optional default argument, put that argument and
2167 // the remaining default arguments into a new, optional string.
Douglas Gregor218937c2011-02-01 19:23:04 +00002168 CodeCompletionBuilder Opt(Result.getAllocator());
2169 if (!FirstParameter)
2170 Opt.AddChunk(Chunk(CodeCompletionString::CK_Comma));
Douglas Gregor8987b232011-09-27 23:30:47 +00002171 AddFunctionParameterChunks(Context, Policy, Function, Opt, P, true);
Douglas Gregor218937c2011-02-01 19:23:04 +00002172 Result.AddOptionalChunk(Opt.TakeString());
2173 break;
Douglas Gregor86d9a522009-09-21 16:56:56 +00002174 }
2175
Douglas Gregor218937c2011-02-01 19:23:04 +00002176 if (FirstParameter)
2177 FirstParameter = false;
2178 else
2179 Result.AddChunk(Chunk(CodeCompletionString::CK_Comma));
2180
2181 InOptional = false;
Douglas Gregor86d9a522009-09-21 16:56:56 +00002182
2183 // Format the placeholder string.
Douglas Gregor8987b232011-09-27 23:30:47 +00002184 std::string PlaceholderStr = FormatFunctionParameter(Context, Policy,
2185 Param);
Douglas Gregor83482d12010-08-24 16:15:59 +00002186
Douglas Gregore17794f2010-08-31 05:13:43 +00002187 if (Function->isVariadic() && P == N - 1)
2188 PlaceholderStr += ", ...";
2189
Douglas Gregor86d9a522009-09-21 16:56:56 +00002190 // Add the placeholder string.
Douglas Gregordae68752011-02-01 22:57:45 +00002191 Result.AddPlaceholderChunk(
2192 Result.getAllocator().CopyString(PlaceholderStr));
Douglas Gregor86d9a522009-09-21 16:56:56 +00002193 }
Douglas Gregorb3d45252009-09-22 21:42:17 +00002194
2195 if (const FunctionProtoType *Proto
2196 = Function->getType()->getAs<FunctionProtoType>())
Douglas Gregoraaa107a2010-08-23 23:51:41 +00002197 if (Proto->isVariadic()) {
Douglas Gregore17794f2010-08-31 05:13:43 +00002198 if (Proto->getNumArgs() == 0)
Douglas Gregor218937c2011-02-01 19:23:04 +00002199 Result.AddPlaceholderChunk("...");
Douglas Gregoraaa107a2010-08-23 23:51:41 +00002200
Douglas Gregor218937c2011-02-01 19:23:04 +00002201 MaybeAddSentinel(Context, Function, Result);
Douglas Gregoraaa107a2010-08-23 23:51:41 +00002202 }
Douglas Gregor86d9a522009-09-21 16:56:56 +00002203}
2204
2205/// \brief Add template parameter chunks to the given code completion string.
2206static void AddTemplateParameterChunks(ASTContext &Context,
Douglas Gregor8987b232011-09-27 23:30:47 +00002207 const PrintingPolicy &Policy,
Douglas Gregor86d9a522009-09-21 16:56:56 +00002208 TemplateDecl *Template,
Douglas Gregor218937c2011-02-01 19:23:04 +00002209 CodeCompletionBuilder &Result,
2210 unsigned MaxParameters = 0,
2211 unsigned Start = 0,
2212 bool InDefaultArg = false) {
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002213 typedef CodeCompletionString::Chunk Chunk;
Douglas Gregor86d9a522009-09-21 16:56:56 +00002214 bool FirstParameter = true;
2215
2216 TemplateParameterList *Params = Template->getTemplateParameters();
2217 TemplateParameterList::iterator PEnd = Params->end();
2218 if (MaxParameters)
2219 PEnd = Params->begin() + MaxParameters;
Douglas Gregor218937c2011-02-01 19:23:04 +00002220 for (TemplateParameterList::iterator P = Params->begin() + Start;
2221 P != PEnd; ++P) {
Douglas Gregor86d9a522009-09-21 16:56:56 +00002222 bool HasDefaultArg = false;
2223 std::string PlaceholderStr;
2224 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
2225 if (TTP->wasDeclaredWithTypename())
2226 PlaceholderStr = "typename";
2227 else
2228 PlaceholderStr = "class";
2229
2230 if (TTP->getIdentifier()) {
2231 PlaceholderStr += ' ';
2232 PlaceholderStr += TTP->getIdentifier()->getName();
2233 }
2234
2235 HasDefaultArg = TTP->hasDefaultArgument();
2236 } else if (NonTypeTemplateParmDecl *NTTP
Douglas Gregor218937c2011-02-01 19:23:04 +00002237 = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
Douglas Gregor86d9a522009-09-21 16:56:56 +00002238 if (NTTP->getIdentifier())
2239 PlaceholderStr = NTTP->getIdentifier()->getName();
John McCallf85e1932011-06-15 23:02:42 +00002240 NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
Douglas Gregor86d9a522009-09-21 16:56:56 +00002241 HasDefaultArg = NTTP->hasDefaultArgument();
2242 } else {
2243 assert(isa<TemplateTemplateParmDecl>(*P));
2244 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
2245
2246 // Since putting the template argument list into the placeholder would
2247 // be very, very long, we just use an abbreviation.
2248 PlaceholderStr = "template<...> class";
2249 if (TTP->getIdentifier()) {
2250 PlaceholderStr += ' ';
2251 PlaceholderStr += TTP->getIdentifier()->getName();
2252 }
2253
2254 HasDefaultArg = TTP->hasDefaultArgument();
2255 }
2256
Douglas Gregor218937c2011-02-01 19:23:04 +00002257 if (HasDefaultArg && !InDefaultArg) {
Douglas Gregor86d9a522009-09-21 16:56:56 +00002258 // When we see an optional default argument, put that argument and
2259 // the remaining default arguments into a new, optional string.
Douglas Gregor218937c2011-02-01 19:23:04 +00002260 CodeCompletionBuilder Opt(Result.getAllocator());
2261 if (!FirstParameter)
2262 Opt.AddChunk(Chunk(CodeCompletionString::CK_Comma));
Douglas Gregor8987b232011-09-27 23:30:47 +00002263 AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters,
Douglas Gregor218937c2011-02-01 19:23:04 +00002264 P - Params->begin(), true);
2265 Result.AddOptionalChunk(Opt.TakeString());
2266 break;
Douglas Gregor86d9a522009-09-21 16:56:56 +00002267 }
2268
Douglas Gregor218937c2011-02-01 19:23:04 +00002269 InDefaultArg = false;
2270
Douglas Gregor86d9a522009-09-21 16:56:56 +00002271 if (FirstParameter)
2272 FirstParameter = false;
2273 else
Douglas Gregor218937c2011-02-01 19:23:04 +00002274 Result.AddChunk(Chunk(CodeCompletionString::CK_Comma));
Douglas Gregor86d9a522009-09-21 16:56:56 +00002275
2276 // Add the placeholder string.
Douglas Gregordae68752011-02-01 22:57:45 +00002277 Result.AddPlaceholderChunk(
2278 Result.getAllocator().CopyString(PlaceholderStr));
Douglas Gregor86d9a522009-09-21 16:56:56 +00002279 }
2280}
2281
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00002282/// \brief Add a qualifier to the given code-completion string, if the
2283/// provided nested-name-specifier is non-NULL.
Douglas Gregora61a8792009-12-11 18:44:16 +00002284static void
Douglas Gregor218937c2011-02-01 19:23:04 +00002285AddQualifierToCompletionString(CodeCompletionBuilder &Result,
Douglas Gregora61a8792009-12-11 18:44:16 +00002286 NestedNameSpecifier *Qualifier,
2287 bool QualifierIsInformative,
Douglas Gregor8987b232011-09-27 23:30:47 +00002288 ASTContext &Context,
2289 const PrintingPolicy &Policy) {
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00002290 if (!Qualifier)
2291 return;
2292
2293 std::string PrintedNNS;
2294 {
2295 llvm::raw_string_ostream OS(PrintedNNS);
Douglas Gregor8987b232011-09-27 23:30:47 +00002296 Qualifier->print(OS, Policy);
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00002297 }
Douglas Gregor0563c262009-09-22 23:15:58 +00002298 if (QualifierIsInformative)
Douglas Gregordae68752011-02-01 22:57:45 +00002299 Result.AddInformativeChunk(Result.getAllocator().CopyString(PrintedNNS));
Douglas Gregor0563c262009-09-22 23:15:58 +00002300 else
Douglas Gregordae68752011-02-01 22:57:45 +00002301 Result.AddTextChunk(Result.getAllocator().CopyString(PrintedNNS));
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00002302}
2303
Douglas Gregor218937c2011-02-01 19:23:04 +00002304static void
2305AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result,
2306 FunctionDecl *Function) {
Douglas Gregora61a8792009-12-11 18:44:16 +00002307 const FunctionProtoType *Proto
2308 = Function->getType()->getAs<FunctionProtoType>();
2309 if (!Proto || !Proto->getTypeQuals())
2310 return;
2311
Douglas Gregora63f6de2011-02-01 21:15:40 +00002312 // FIXME: Add ref-qualifier!
2313
2314 // Handle single qualifiers without copying
2315 if (Proto->getTypeQuals() == Qualifiers::Const) {
2316 Result.AddInformativeChunk(" const");
2317 return;
2318 }
2319
2320 if (Proto->getTypeQuals() == Qualifiers::Volatile) {
2321 Result.AddInformativeChunk(" volatile");
2322 return;
2323 }
2324
2325 if (Proto->getTypeQuals() == Qualifiers::Restrict) {
2326 Result.AddInformativeChunk(" restrict");
2327 return;
2328 }
2329
2330 // Handle multiple qualifiers.
Douglas Gregora61a8792009-12-11 18:44:16 +00002331 std::string QualsStr;
2332 if (Proto->getTypeQuals() & Qualifiers::Const)
2333 QualsStr += " const";
2334 if (Proto->getTypeQuals() & Qualifiers::Volatile)
2335 QualsStr += " volatile";
2336 if (Proto->getTypeQuals() & Qualifiers::Restrict)
2337 QualsStr += " restrict";
Douglas Gregordae68752011-02-01 22:57:45 +00002338 Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
Douglas Gregora61a8792009-12-11 18:44:16 +00002339}
2340
Douglas Gregor6f942b22010-09-21 16:06:22 +00002341/// \brief Add the name of the given declaration
Douglas Gregor8987b232011-09-27 23:30:47 +00002342static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy,
2343 NamedDecl *ND, CodeCompletionBuilder &Result) {
Douglas Gregor6f942b22010-09-21 16:06:22 +00002344 typedef CodeCompletionString::Chunk Chunk;
2345
2346 DeclarationName Name = ND->getDeclName();
2347 if (!Name)
2348 return;
2349
2350 switch (Name.getNameKind()) {
Douglas Gregora63f6de2011-02-01 21:15:40 +00002351 case DeclarationName::CXXOperatorName: {
2352 const char *OperatorName = 0;
2353 switch (Name.getCXXOverloadedOperator()) {
2354 case OO_None:
2355 case OO_Conditional:
2356 case NUM_OVERLOADED_OPERATORS:
2357 OperatorName = "operator";
2358 break;
2359
2360#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2361 case OO_##Name: OperatorName = "operator" Spelling; break;
2362#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2363#include "clang/Basic/OperatorKinds.def"
2364
2365 case OO_New: OperatorName = "operator new"; break;
2366 case OO_Delete: OperatorName = "operator delete"; break;
2367 case OO_Array_New: OperatorName = "operator new[]"; break;
2368 case OO_Array_Delete: OperatorName = "operator delete[]"; break;
2369 case OO_Call: OperatorName = "operator()"; break;
2370 case OO_Subscript: OperatorName = "operator[]"; break;
2371 }
2372 Result.AddTypedTextChunk(OperatorName);
2373 break;
2374 }
2375
Douglas Gregor6f942b22010-09-21 16:06:22 +00002376 case DeclarationName::Identifier:
2377 case DeclarationName::CXXConversionFunctionName:
Douglas Gregor6f942b22010-09-21 16:06:22 +00002378 case DeclarationName::CXXDestructorName:
2379 case DeclarationName::CXXLiteralOperatorName:
Douglas Gregordae68752011-02-01 22:57:45 +00002380 Result.AddTypedTextChunk(
2381 Result.getAllocator().CopyString(ND->getNameAsString()));
Douglas Gregor6f942b22010-09-21 16:06:22 +00002382 break;
2383
2384 case DeclarationName::CXXUsingDirective:
2385 case DeclarationName::ObjCZeroArgSelector:
2386 case DeclarationName::ObjCOneArgSelector:
2387 case DeclarationName::ObjCMultiArgSelector:
2388 break;
2389
2390 case DeclarationName::CXXConstructorName: {
2391 CXXRecordDecl *Record = 0;
2392 QualType Ty = Name.getCXXNameType();
2393 if (const RecordType *RecordTy = Ty->getAs<RecordType>())
2394 Record = cast<CXXRecordDecl>(RecordTy->getDecl());
2395 else if (const InjectedClassNameType *InjectedTy
2396 = Ty->getAs<InjectedClassNameType>())
2397 Record = InjectedTy->getDecl();
2398 else {
Douglas Gregordae68752011-02-01 22:57:45 +00002399 Result.AddTypedTextChunk(
2400 Result.getAllocator().CopyString(ND->getNameAsString()));
Douglas Gregor6f942b22010-09-21 16:06:22 +00002401 break;
2402 }
2403
Douglas Gregordae68752011-02-01 22:57:45 +00002404 Result.AddTypedTextChunk(
2405 Result.getAllocator().CopyString(Record->getNameAsString()));
Douglas Gregor6f942b22010-09-21 16:06:22 +00002406 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) {
Douglas Gregor218937c2011-02-01 19:23:04 +00002407 Result.AddChunk(Chunk(CodeCompletionString::CK_LeftAngle));
Douglas Gregor8987b232011-09-27 23:30:47 +00002408 AddTemplateParameterChunks(Context, Policy, Template, Result);
Douglas Gregor218937c2011-02-01 19:23:04 +00002409 Result.AddChunk(Chunk(CodeCompletionString::CK_RightAngle));
Douglas Gregor6f942b22010-09-21 16:06:22 +00002410 }
2411 break;
2412 }
2413 }
2414}
2415
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002416CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(Sema &S,
2417 CodeCompletionAllocator &Allocator) {
2418 return CreateCodeCompletionString(S.Context, S.PP, Allocator);
2419}
2420
Douglas Gregor86d9a522009-09-21 16:56:56 +00002421/// \brief If possible, create a new code completion string for the given
2422/// result.
2423///
2424/// \returns Either a new, heap-allocated code completion string describing
2425/// how to use this result, or NULL to indicate that the string or name of the
2426/// result is all that is needed.
2427CodeCompletionString *
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002428CodeCompletionResult::CreateCodeCompletionString(ASTContext &Ctx,
2429 Preprocessor &PP,
Douglas Gregordae68752011-02-01 22:57:45 +00002430 CodeCompletionAllocator &Allocator) {
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002431 typedef CodeCompletionString::Chunk Chunk;
Douglas Gregor218937c2011-02-01 19:23:04 +00002432 CodeCompletionBuilder Result(Allocator, Priority, Availability);
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002433
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002434 PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP);
Douglas Gregor218937c2011-02-01 19:23:04 +00002435 if (Kind == RK_Pattern) {
2436 Pattern->Priority = Priority;
2437 Pattern->Availability = Availability;
2438 return Pattern;
2439 }
Douglas Gregor2b4074f2009-12-01 05:55:20 +00002440
Douglas Gregor2b4074f2009-12-01 05:55:20 +00002441 if (Kind == RK_Keyword) {
Douglas Gregor218937c2011-02-01 19:23:04 +00002442 Result.AddTypedTextChunk(Keyword);
2443 return Result.TakeString();
Douglas Gregor2b4074f2009-12-01 05:55:20 +00002444 }
Douglas Gregor86d9a522009-09-21 16:56:56 +00002445
Douglas Gregor3f7c7f42009-10-30 16:50:04 +00002446 if (Kind == RK_Macro) {
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002447 MacroInfo *MI = PP.getMacroInfo(Macro);
Douglas Gregor2b4074f2009-12-01 05:55:20 +00002448 assert(MI && "Not a macro?");
2449
Douglas Gregordae68752011-02-01 22:57:45 +00002450 Result.AddTypedTextChunk(
2451 Result.getAllocator().CopyString(Macro->getName()));
Douglas Gregor2b4074f2009-12-01 05:55:20 +00002452
2453 if (!MI->isFunctionLike())
Douglas Gregor218937c2011-02-01 19:23:04 +00002454 return Result.TakeString();
Douglas Gregor3f7c7f42009-10-30 16:50:04 +00002455
2456 // Format a function-like macro with placeholders for the arguments.
Douglas Gregor218937c2011-02-01 19:23:04 +00002457 Result.AddChunk(Chunk(CodeCompletionString::CK_LeftParen));
Douglas Gregore4244702011-07-30 08:17:44 +00002458 MacroInfo::arg_iterator A = MI->arg_begin(), AEnd = MI->arg_end();
Douglas Gregorc8dc1352012-01-21 00:43:38 +00002459
2460 // C99 variadic macros add __VA_ARGS__ at the end. Skip it.
2461 if (MI->isC99Varargs()) {
2462 --AEnd;
2463
2464 if (A == AEnd) {
2465 Result.AddPlaceholderChunk("...");
2466 }
Douglas Gregore4244702011-07-30 08:17:44 +00002467 }
Douglas Gregorc8dc1352012-01-21 00:43:38 +00002468
Douglas Gregore4244702011-07-30 08:17:44 +00002469 for (MacroInfo::arg_iterator A = MI->arg_begin(); A != AEnd; ++A) {
Douglas Gregor3f7c7f42009-10-30 16:50:04 +00002470 if (A != MI->arg_begin())
Douglas Gregor218937c2011-02-01 19:23:04 +00002471 Result.AddChunk(Chunk(CodeCompletionString::CK_Comma));
Douglas Gregorc8dc1352012-01-21 00:43:38 +00002472
2473 if (MI->isVariadic() && (A+1) == AEnd) {
2474 llvm::SmallString<32> Arg = (*A)->getName();
2475 if (MI->isC99Varargs())
2476 Arg += ", ...";
2477 else
2478 Arg += "...";
Douglas Gregordae68752011-02-01 22:57:45 +00002479 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
Douglas Gregorc8dc1352012-01-21 00:43:38 +00002480 break;
Douglas Gregor3f7c7f42009-10-30 16:50:04 +00002481 }
Douglas Gregorc8dc1352012-01-21 00:43:38 +00002482
2483 // Non-variadic macros are simple.
2484 Result.AddPlaceholderChunk(
2485 Result.getAllocator().CopyString((*A)->getName()));
Douglas Gregore4244702011-07-30 08:17:44 +00002486 }
Douglas Gregor218937c2011-02-01 19:23:04 +00002487 Result.AddChunk(Chunk(CodeCompletionString::CK_RightParen));
2488 return Result.TakeString();
Douglas Gregor3f7c7f42009-10-30 16:50:04 +00002489 }
2490
Douglas Gregord8e8a582010-05-25 21:41:55 +00002491 assert(Kind == RK_Declaration && "Missed a result kind?");
Douglas Gregor86d9a522009-09-21 16:56:56 +00002492 NamedDecl *ND = Declaration;
2493
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002494 if (StartsNestedNameSpecifier) {
Douglas Gregordae68752011-02-01 22:57:45 +00002495 Result.AddTypedTextChunk(
2496 Result.getAllocator().CopyString(ND->getNameAsString()));
Douglas Gregor218937c2011-02-01 19:23:04 +00002497 Result.AddTextChunk("::");
2498 return Result.TakeString();
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002499 }
Erik Verbruggen6164ea12011-10-14 15:31:08 +00002500
2501 for (Decl::attr_iterator i = ND->attr_begin(); i != ND->attr_end(); ++i) {
2502 if (AnnotateAttr *Attr = dyn_cast_or_null<AnnotateAttr>(*i)) {
2503 Result.AddAnnotation(Result.getAllocator().CopyString(Attr->getAnnotation()));
2504 }
2505 }
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002506
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002507 AddResultTypeChunk(Ctx, Policy, ND, Result);
Douglas Gregorff5ce6e2009-12-18 18:53:37 +00002508
Douglas Gregor86d9a522009-09-21 16:56:56 +00002509 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) {
Douglas Gregor0563c262009-09-22 23:15:58 +00002510 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002511 Ctx, Policy);
2512 AddTypedNameChunk(Ctx, Policy, ND, Result);
Douglas Gregor218937c2011-02-01 19:23:04 +00002513 Result.AddChunk(Chunk(CodeCompletionString::CK_LeftParen));
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002514 AddFunctionParameterChunks(Ctx, Policy, Function, Result);
Douglas Gregor218937c2011-02-01 19:23:04 +00002515 Result.AddChunk(Chunk(CodeCompletionString::CK_RightParen));
Douglas Gregora61a8792009-12-11 18:44:16 +00002516 AddFunctionTypeQualsToCompletionString(Result, Function);
Douglas Gregor218937c2011-02-01 19:23:04 +00002517 return Result.TakeString();
Douglas Gregor86d9a522009-09-21 16:56:56 +00002518 }
2519
2520 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) {
Douglas Gregor0563c262009-09-22 23:15:58 +00002521 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002522 Ctx, Policy);
Douglas Gregor86d9a522009-09-21 16:56:56 +00002523 FunctionDecl *Function = FunTmpl->getTemplatedDecl();
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002524 AddTypedNameChunk(Ctx, Policy, Function, Result);
Douglas Gregor6f942b22010-09-21 16:06:22 +00002525
Douglas Gregor86d9a522009-09-21 16:56:56 +00002526 // Figure out which template parameters are deduced (or have default
2527 // arguments).
Chris Lattner5f9e2722011-07-23 10:55:15 +00002528 SmallVector<bool, 16> Deduced;
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002529 Sema::MarkDeducedTemplateParameters(Ctx, FunTmpl, Deduced);
Douglas Gregor86d9a522009-09-21 16:56:56 +00002530 unsigned LastDeducibleArgument;
2531 for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0;
2532 --LastDeducibleArgument) {
2533 if (!Deduced[LastDeducibleArgument - 1]) {
2534 // C++0x: Figure out if the template argument has a default. If so,
2535 // the user doesn't need to type this argument.
2536 // FIXME: We need to abstract template parameters better!
2537 bool HasDefaultArg = false;
2538 NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam(
Douglas Gregor218937c2011-02-01 19:23:04 +00002539 LastDeducibleArgument - 1);
Douglas Gregor86d9a522009-09-21 16:56:56 +00002540 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
2541 HasDefaultArg = TTP->hasDefaultArgument();
2542 else if (NonTypeTemplateParmDecl *NTTP
2543 = dyn_cast<NonTypeTemplateParmDecl>(Param))
2544 HasDefaultArg = NTTP->hasDefaultArgument();
2545 else {
2546 assert(isa<TemplateTemplateParmDecl>(Param));
2547 HasDefaultArg
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002548 = cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument();
Douglas Gregor86d9a522009-09-21 16:56:56 +00002549 }
2550
2551 if (!HasDefaultArg)
2552 break;
2553 }
2554 }
2555
2556 if (LastDeducibleArgument) {
2557 // Some of the function template arguments cannot be deduced from a
2558 // function call, so we introduce an explicit template argument list
2559 // containing all of the arguments up to the first deducible argument.
Douglas Gregor218937c2011-02-01 19:23:04 +00002560 Result.AddChunk(Chunk(CodeCompletionString::CK_LeftAngle));
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002561 AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result,
Douglas Gregor86d9a522009-09-21 16:56:56 +00002562 LastDeducibleArgument);
Douglas Gregor218937c2011-02-01 19:23:04 +00002563 Result.AddChunk(Chunk(CodeCompletionString::CK_RightAngle));
Douglas Gregor86d9a522009-09-21 16:56:56 +00002564 }
2565
2566 // Add the function parameters
Douglas Gregor218937c2011-02-01 19:23:04 +00002567 Result.AddChunk(Chunk(CodeCompletionString::CK_LeftParen));
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002568 AddFunctionParameterChunks(Ctx, Policy, Function, Result);
Douglas Gregor218937c2011-02-01 19:23:04 +00002569 Result.AddChunk(Chunk(CodeCompletionString::CK_RightParen));
Douglas Gregora61a8792009-12-11 18:44:16 +00002570 AddFunctionTypeQualsToCompletionString(Result, Function);
Douglas Gregor218937c2011-02-01 19:23:04 +00002571 return Result.TakeString();
Douglas Gregor86d9a522009-09-21 16:56:56 +00002572 }
2573
2574 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(ND)) {
Douglas Gregor0563c262009-09-22 23:15:58 +00002575 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002576 Ctx, Policy);
Douglas Gregordae68752011-02-01 22:57:45 +00002577 Result.AddTypedTextChunk(
2578 Result.getAllocator().CopyString(Template->getNameAsString()));
Douglas Gregor218937c2011-02-01 19:23:04 +00002579 Result.AddChunk(Chunk(CodeCompletionString::CK_LeftAngle));
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002580 AddTemplateParameterChunks(Ctx, Policy, Template, Result);
Douglas Gregor218937c2011-02-01 19:23:04 +00002581 Result.AddChunk(Chunk(CodeCompletionString::CK_RightAngle));
2582 return Result.TakeString();
Douglas Gregor86d9a522009-09-21 16:56:56 +00002583 }
2584
Douglas Gregor9630eb62009-11-17 16:44:22 +00002585 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
Douglas Gregor9630eb62009-11-17 16:44:22 +00002586 Selector Sel = Method->getSelector();
2587 if (Sel.isUnarySelector()) {
Douglas Gregordae68752011-02-01 22:57:45 +00002588 Result.AddTypedTextChunk(Result.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00002589 Sel.getNameForSlot(0)));
Douglas Gregor218937c2011-02-01 19:23:04 +00002590 return Result.TakeString();
Douglas Gregor9630eb62009-11-17 16:44:22 +00002591 }
2592
Douglas Gregor813d8342011-02-18 22:29:55 +00002593 std::string SelName = Sel.getNameForSlot(0).str();
Douglas Gregord3c68542009-11-19 01:08:35 +00002594 SelName += ':';
2595 if (StartParameter == 0)
Douglas Gregordae68752011-02-01 22:57:45 +00002596 Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName));
Douglas Gregord3c68542009-11-19 01:08:35 +00002597 else {
Douglas Gregordae68752011-02-01 22:57:45 +00002598 Result.AddInformativeChunk(Result.getAllocator().CopyString(SelName));
Douglas Gregord3c68542009-11-19 01:08:35 +00002599
2600 // If there is only one parameter, and we're past it, add an empty
2601 // typed-text chunk since there is nothing to type.
2602 if (Method->param_size() == 1)
Douglas Gregor218937c2011-02-01 19:23:04 +00002603 Result.AddTypedTextChunk("");
Douglas Gregord3c68542009-11-19 01:08:35 +00002604 }
Douglas Gregor9630eb62009-11-17 16:44:22 +00002605 unsigned Idx = 0;
2606 for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
2607 PEnd = Method->param_end();
2608 P != PEnd; (void)++P, ++Idx) {
2609 if (Idx > 0) {
Douglas Gregord3c68542009-11-19 01:08:35 +00002610 std::string Keyword;
2611 if (Idx > StartParameter)
Douglas Gregor218937c2011-02-01 19:23:04 +00002612 Result.AddChunk(CodeCompletionString::CK_HorizontalSpace);
Douglas Gregor9630eb62009-11-17 16:44:22 +00002613 if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx))
Benjamin Kramera0651c52011-07-26 16:59:25 +00002614 Keyword += II->getName();
Douglas Gregor9630eb62009-11-17 16:44:22 +00002615 Keyword += ":";
Douglas Gregor1f5537a2010-07-08 23:20:03 +00002616 if (Idx < StartParameter || AllParametersAreInformative)
Douglas Gregordae68752011-02-01 22:57:45 +00002617 Result.AddInformativeChunk(Result.getAllocator().CopyString(Keyword));
Douglas Gregorc7b7b7a2010-10-18 21:05:04 +00002618 else
Douglas Gregordae68752011-02-01 22:57:45 +00002619 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Keyword));
Douglas Gregor9630eb62009-11-17 16:44:22 +00002620 }
Douglas Gregord3c68542009-11-19 01:08:35 +00002621
2622 // If we're before the starting parameter, skip the placeholder.
2623 if (Idx < StartParameter)
2624 continue;
Douglas Gregor9630eb62009-11-17 16:44:22 +00002625
2626 std::string Arg;
Douglas Gregor83482d12010-08-24 16:15:59 +00002627
2628 if ((*P)->getType()->isBlockPointerType() && !DeclaringEntity)
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002629 Arg = FormatFunctionParameter(Ctx, Policy, *P, true);
Douglas Gregor83482d12010-08-24 16:15:59 +00002630 else {
John McCallf85e1932011-06-15 23:02:42 +00002631 (*P)->getType().getAsStringInternal(Arg, Policy);
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002632 Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier())
2633 + Arg + ")";
Douglas Gregor83482d12010-08-24 16:15:59 +00002634 if (IdentifierInfo *II = (*P)->getIdentifier())
Douglas Gregoraba48082010-08-29 19:47:46 +00002635 if (DeclaringEntity || AllParametersAreInformative)
Benjamin Kramera0651c52011-07-26 16:59:25 +00002636 Arg += II->getName();
Douglas Gregor83482d12010-08-24 16:15:59 +00002637 }
2638
Douglas Gregore17794f2010-08-31 05:13:43 +00002639 if (Method->isVariadic() && (P + 1) == PEnd)
2640 Arg += ", ...";
2641
Douglas Gregor1f5537a2010-07-08 23:20:03 +00002642 if (DeclaringEntity)
Douglas Gregordae68752011-02-01 22:57:45 +00002643 Result.AddTextChunk(Result.getAllocator().CopyString(Arg));
Douglas Gregor1f5537a2010-07-08 23:20:03 +00002644 else if (AllParametersAreInformative)
Douglas Gregordae68752011-02-01 22:57:45 +00002645 Result.AddInformativeChunk(Result.getAllocator().CopyString(Arg));
Douglas Gregor4ad96852009-11-19 07:41:15 +00002646 else
Douglas Gregordae68752011-02-01 22:57:45 +00002647 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
Douglas Gregor9630eb62009-11-17 16:44:22 +00002648 }
2649
Douglas Gregor2a17af02009-12-23 00:21:46 +00002650 if (Method->isVariadic()) {
Douglas Gregore17794f2010-08-31 05:13:43 +00002651 if (Method->param_size() == 0) {
2652 if (DeclaringEntity)
Douglas Gregor218937c2011-02-01 19:23:04 +00002653 Result.AddTextChunk(", ...");
Douglas Gregore17794f2010-08-31 05:13:43 +00002654 else if (AllParametersAreInformative)
Douglas Gregor218937c2011-02-01 19:23:04 +00002655 Result.AddInformativeChunk(", ...");
Douglas Gregore17794f2010-08-31 05:13:43 +00002656 else
Douglas Gregor218937c2011-02-01 19:23:04 +00002657 Result.AddPlaceholderChunk(", ...");
Douglas Gregore17794f2010-08-31 05:13:43 +00002658 }
Douglas Gregoraaa107a2010-08-23 23:51:41 +00002659
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002660 MaybeAddSentinel(Ctx, Method, Result);
Douglas Gregor2a17af02009-12-23 00:21:46 +00002661 }
2662
Douglas Gregor218937c2011-02-01 19:23:04 +00002663 return Result.TakeString();
Douglas Gregor9630eb62009-11-17 16:44:22 +00002664 }
2665
Douglas Gregor2b4074f2009-12-01 05:55:20 +00002666 if (Qualifier)
Douglas Gregor0563c262009-09-22 23:15:58 +00002667 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002668 Ctx, Policy);
Douglas Gregor2b4074f2009-12-01 05:55:20 +00002669
Douglas Gregordae68752011-02-01 22:57:45 +00002670 Result.AddTypedTextChunk(
2671 Result.getAllocator().CopyString(ND->getNameAsString()));
Douglas Gregor218937c2011-02-01 19:23:04 +00002672 return Result.TakeString();
Douglas Gregor86d9a522009-09-21 16:56:56 +00002673}
2674
Douglas Gregor86d802e2009-09-23 00:34:09 +00002675CodeCompletionString *
2676CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
2677 unsigned CurrentArg,
Douglas Gregor32be4a52010-10-11 21:37:58 +00002678 Sema &S,
Douglas Gregordae68752011-02-01 22:57:45 +00002679 CodeCompletionAllocator &Allocator) const {
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002680 typedef CodeCompletionString::Chunk Chunk;
Douglas Gregor8987b232011-09-27 23:30:47 +00002681 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
John McCallf85e1932011-06-15 23:02:42 +00002682
Douglas Gregor218937c2011-02-01 19:23:04 +00002683 // FIXME: Set priority, availability appropriately.
2684 CodeCompletionBuilder Result(Allocator, 1, CXAvailability_Available);
Douglas Gregor86d802e2009-09-23 00:34:09 +00002685 FunctionDecl *FDecl = getFunction();
Douglas Gregor8987b232011-09-27 23:30:47 +00002686 AddResultTypeChunk(S.Context, Policy, FDecl, Result);
Douglas Gregor86d802e2009-09-23 00:34:09 +00002687 const FunctionProtoType *Proto
2688 = dyn_cast<FunctionProtoType>(getFunctionType());
2689 if (!FDecl && !Proto) {
2690 // Function without a prototype. Just give the return type and a
2691 // highlighted ellipsis.
2692 const FunctionType *FT = getFunctionType();
Douglas Gregora63f6de2011-02-01 21:15:40 +00002693 Result.AddTextChunk(GetCompletionTypeString(FT->getResultType(),
Douglas Gregor8987b232011-09-27 23:30:47 +00002694 S.Context, Policy,
Douglas Gregora63f6de2011-02-01 21:15:40 +00002695 Result.getAllocator()));
Douglas Gregor218937c2011-02-01 19:23:04 +00002696 Result.AddChunk(Chunk(CodeCompletionString::CK_LeftParen));
2697 Result.AddChunk(Chunk(CodeCompletionString::CK_CurrentParameter, "..."));
2698 Result.AddChunk(Chunk(CodeCompletionString::CK_RightParen));
2699 return Result.TakeString();
Douglas Gregor86d802e2009-09-23 00:34:09 +00002700 }
2701
2702 if (FDecl)
Douglas Gregordae68752011-02-01 22:57:45 +00002703 Result.AddTextChunk(
2704 Result.getAllocator().CopyString(FDecl->getNameAsString()));
Douglas Gregor86d802e2009-09-23 00:34:09 +00002705 else
Douglas Gregor218937c2011-02-01 19:23:04 +00002706 Result.AddTextChunk(
Douglas Gregordae68752011-02-01 22:57:45 +00002707 Result.getAllocator().CopyString(
John McCallf85e1932011-06-15 23:02:42 +00002708 Proto->getResultType().getAsString(Policy)));
Douglas Gregor86d802e2009-09-23 00:34:09 +00002709
Douglas Gregor218937c2011-02-01 19:23:04 +00002710 Result.AddChunk(Chunk(CodeCompletionString::CK_LeftParen));
Douglas Gregor86d802e2009-09-23 00:34:09 +00002711 unsigned NumParams = FDecl? FDecl->getNumParams() : Proto->getNumArgs();
2712 for (unsigned I = 0; I != NumParams; ++I) {
2713 if (I)
Douglas Gregor218937c2011-02-01 19:23:04 +00002714 Result.AddChunk(Chunk(CodeCompletionString::CK_Comma));
Douglas Gregor86d802e2009-09-23 00:34:09 +00002715
2716 std::string ArgString;
2717 QualType ArgType;
2718
2719 if (FDecl) {
2720 ArgString = FDecl->getParamDecl(I)->getNameAsString();
2721 ArgType = FDecl->getParamDecl(I)->getOriginalType();
2722 } else {
2723 ArgType = Proto->getArgType(I);
2724 }
2725
John McCallf85e1932011-06-15 23:02:42 +00002726 ArgType.getAsStringInternal(ArgString, Policy);
Douglas Gregor86d802e2009-09-23 00:34:09 +00002727
2728 if (I == CurrentArg)
Douglas Gregor218937c2011-02-01 19:23:04 +00002729 Result.AddChunk(Chunk(CodeCompletionString::CK_CurrentParameter,
Douglas Gregordae68752011-02-01 22:57:45 +00002730 Result.getAllocator().CopyString(ArgString)));
Douglas Gregor86d802e2009-09-23 00:34:09 +00002731 else
Douglas Gregordae68752011-02-01 22:57:45 +00002732 Result.AddTextChunk(Result.getAllocator().CopyString(ArgString));
Douglas Gregor86d802e2009-09-23 00:34:09 +00002733 }
2734
2735 if (Proto && Proto->isVariadic()) {
Douglas Gregor218937c2011-02-01 19:23:04 +00002736 Result.AddChunk(Chunk(CodeCompletionString::CK_Comma));
Douglas Gregor86d802e2009-09-23 00:34:09 +00002737 if (CurrentArg < NumParams)
Douglas Gregor218937c2011-02-01 19:23:04 +00002738 Result.AddTextChunk("...");
Douglas Gregor86d802e2009-09-23 00:34:09 +00002739 else
Douglas Gregor218937c2011-02-01 19:23:04 +00002740 Result.AddChunk(Chunk(CodeCompletionString::CK_CurrentParameter, "..."));
Douglas Gregor86d802e2009-09-23 00:34:09 +00002741 }
Douglas Gregor218937c2011-02-01 19:23:04 +00002742 Result.AddChunk(Chunk(CodeCompletionString::CK_RightParen));
Douglas Gregor86d802e2009-09-23 00:34:09 +00002743
Douglas Gregor218937c2011-02-01 19:23:04 +00002744 return Result.TakeString();
Douglas Gregor86d802e2009-09-23 00:34:09 +00002745}
2746
Chris Lattner5f9e2722011-07-23 10:55:15 +00002747unsigned clang::getMacroUsagePriority(StringRef MacroName,
Douglas Gregorb05496d2010-09-20 21:11:48 +00002748 const LangOptions &LangOpts,
Douglas Gregor1827e102010-08-16 16:18:59 +00002749 bool PreferredTypeIsPointer) {
2750 unsigned Priority = CCP_Macro;
2751
Douglas Gregorb05496d2010-09-20 21:11:48 +00002752 // Treat the "nil", "Nil" and "NULL" macros as null pointer constants.
2753 if (MacroName.equals("nil") || MacroName.equals("NULL") ||
2754 MacroName.equals("Nil")) {
Douglas Gregor1827e102010-08-16 16:18:59 +00002755 Priority = CCP_Constant;
2756 if (PreferredTypeIsPointer)
2757 Priority = Priority / CCF_SimilarTypeMatch;
Douglas Gregorb05496d2010-09-20 21:11:48 +00002758 }
2759 // Treat "YES", "NO", "true", and "false" as constants.
2760 else if (MacroName.equals("YES") || MacroName.equals("NO") ||
2761 MacroName.equals("true") || MacroName.equals("false"))
2762 Priority = CCP_Constant;
2763 // Treat "bool" as a type.
2764 else if (MacroName.equals("bool"))
2765 Priority = CCP_Type + (LangOpts.ObjC1? CCD_bool_in_ObjC : 0);
2766
Douglas Gregor1827e102010-08-16 16:18:59 +00002767
2768 return Priority;
2769}
2770
Douglas Gregore8d7beb2010-09-03 23:30:36 +00002771CXCursorKind clang::getCursorKindForDecl(Decl *D) {
2772 if (!D)
2773 return CXCursor_UnexposedDecl;
2774
2775 switch (D->getKind()) {
2776 case Decl::Enum: return CXCursor_EnumDecl;
2777 case Decl::EnumConstant: return CXCursor_EnumConstantDecl;
2778 case Decl::Field: return CXCursor_FieldDecl;
2779 case Decl::Function:
2780 return CXCursor_FunctionDecl;
2781 case Decl::ObjCCategory: return CXCursor_ObjCCategoryDecl;
2782 case Decl::ObjCCategoryImpl: return CXCursor_ObjCCategoryImplDecl;
Douglas Gregore8d7beb2010-09-03 23:30:36 +00002783 case Decl::ObjCImplementation: return CXCursor_ObjCImplementationDecl;
Douglas Gregor375bb142011-12-27 22:43:10 +00002784
2785 case Decl::ObjCInterface:
2786 if (cast<ObjCInterfaceDecl>(D)->isThisDeclarationADefinition())
2787 return CXCursor_ObjCInterfaceDecl;
2788
2789 // Forward declarations are not directly exposed.
2790 return CXCursor_UnexposedDecl;
2791
Douglas Gregore8d7beb2010-09-03 23:30:36 +00002792 case Decl::ObjCIvar: return CXCursor_ObjCIvarDecl;
2793 case Decl::ObjCMethod:
2794 return cast<ObjCMethodDecl>(D)->isInstanceMethod()
2795 ? CXCursor_ObjCInstanceMethodDecl : CXCursor_ObjCClassMethodDecl;
2796 case Decl::CXXMethod: return CXCursor_CXXMethod;
2797 case Decl::CXXConstructor: return CXCursor_Constructor;
2798 case Decl::CXXDestructor: return CXCursor_Destructor;
2799 case Decl::CXXConversion: return CXCursor_ConversionFunction;
2800 case Decl::ObjCProperty: return CXCursor_ObjCPropertyDecl;
Douglas Gregorbd9482d2012-01-01 21:23:57 +00002801 case Decl::ObjCProtocol:
2802 if (cast<ObjCProtocolDecl>(D)->isThisDeclarationADefinition())
2803 return CXCursor_ObjCProtocolDecl;
2804
2805 return CXCursor_UnexposedDecl;
2806
Douglas Gregore8d7beb2010-09-03 23:30:36 +00002807 case Decl::ParmVar: return CXCursor_ParmDecl;
2808 case Decl::Typedef: return CXCursor_TypedefDecl;
Richard Smith162e1c12011-04-15 14:24:37 +00002809 case Decl::TypeAlias: return CXCursor_TypeAliasDecl;
Douglas Gregore8d7beb2010-09-03 23:30:36 +00002810 case Decl::Var: return CXCursor_VarDecl;
2811 case Decl::Namespace: return CXCursor_Namespace;
2812 case Decl::NamespaceAlias: return CXCursor_NamespaceAlias;
2813 case Decl::TemplateTypeParm: return CXCursor_TemplateTypeParameter;
2814 case Decl::NonTypeTemplateParm:return CXCursor_NonTypeTemplateParameter;
2815 case Decl::TemplateTemplateParm:return CXCursor_TemplateTemplateParameter;
2816 case Decl::FunctionTemplate: return CXCursor_FunctionTemplate;
2817 case Decl::ClassTemplate: return CXCursor_ClassTemplate;
Argyrios Kyrtzidis2dfdb942011-09-30 17:58:23 +00002818 case Decl::AccessSpec: return CXCursor_CXXAccessSpecifier;
Douglas Gregore8d7beb2010-09-03 23:30:36 +00002819 case Decl::ClassTemplatePartialSpecialization:
2820 return CXCursor_ClassTemplatePartialSpecialization;
2821 case Decl::UsingDirective: return CXCursor_UsingDirective;
2822
2823 case Decl::Using:
2824 case Decl::UnresolvedUsingValue:
2825 case Decl::UnresolvedUsingTypename:
2826 return CXCursor_UsingDeclaration;
2827
Douglas Gregor352697a2011-06-03 23:08:58 +00002828 case Decl::ObjCPropertyImpl:
2829 switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
2830 case ObjCPropertyImplDecl::Dynamic:
2831 return CXCursor_ObjCDynamicDecl;
2832
2833 case ObjCPropertyImplDecl::Synthesize:
2834 return CXCursor_ObjCSynthesizeDecl;
2835 }
Douglas Gregor352697a2011-06-03 23:08:58 +00002836
Douglas Gregore8d7beb2010-09-03 23:30:36 +00002837 default:
2838 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
2839 switch (TD->getTagKind()) {
2840 case TTK_Struct: return CXCursor_StructDecl;
2841 case TTK_Class: return CXCursor_ClassDecl;
2842 case TTK_Union: return CXCursor_UnionDecl;
2843 case TTK_Enum: return CXCursor_EnumDecl;
2844 }
2845 }
2846 }
2847
2848 return CXCursor_UnexposedDecl;
2849}
2850
Douglas Gregor590c7d52010-07-08 20:55:51 +00002851static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results,
2852 bool TargetTypeIsPointer = false) {
John McCall0a2c5e22010-08-25 06:19:51 +00002853 typedef CodeCompletionResult Result;
Douglas Gregor590c7d52010-07-08 20:55:51 +00002854
Douglas Gregor3f7c7f42009-10-30 16:50:04 +00002855 Results.EnterNewScope();
Douglas Gregorc7b7b7a2010-10-18 21:05:04 +00002856
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002857 for (Preprocessor::macro_iterator M = PP.macro_begin(),
2858 MEnd = PP.macro_end();
Douglas Gregor590c7d52010-07-08 20:55:51 +00002859 M != MEnd; ++M) {
Douglas Gregor1827e102010-08-16 16:18:59 +00002860 Results.AddResult(Result(M->first,
2861 getMacroUsagePriority(M->first->getName(),
Douglas Gregorb05496d2010-09-20 21:11:48 +00002862 PP.getLangOptions(),
Douglas Gregor1827e102010-08-16 16:18:59 +00002863 TargetTypeIsPointer)));
Douglas Gregor590c7d52010-07-08 20:55:51 +00002864 }
Douglas Gregorc7b7b7a2010-10-18 21:05:04 +00002865
Douglas Gregor3f7c7f42009-10-30 16:50:04 +00002866 Results.ExitScope();
Douglas Gregorc7b7b7a2010-10-18 21:05:04 +00002867
Douglas Gregor3f7c7f42009-10-30 16:50:04 +00002868}
2869
Douglas Gregoraa5f77b2010-08-23 21:54:33 +00002870static void AddPrettyFunctionResults(const LangOptions &LangOpts,
2871 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00002872 typedef CodeCompletionResult Result;
Douglas Gregoraa5f77b2010-08-23 21:54:33 +00002873
2874 Results.EnterNewScope();
Douglas Gregorc7b7b7a2010-10-18 21:05:04 +00002875
Douglas Gregoraa5f77b2010-08-23 21:54:33 +00002876 Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant));
2877 Results.AddResult(Result("__FUNCTION__", CCP_Constant));
2878 if (LangOpts.C99 || LangOpts.CPlusPlus0x)
2879 Results.AddResult(Result("__func__", CCP_Constant));
2880 Results.ExitScope();
2881}
2882
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00002883static void HandleCodeCompleteResults(Sema *S,
2884 CodeCompleteConsumer *CodeCompleter,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002885 CodeCompletionContext Context,
John McCall0a2c5e22010-08-25 06:19:51 +00002886 CodeCompletionResult *Results,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002887 unsigned NumResults) {
Douglas Gregor86d9a522009-09-21 16:56:56 +00002888 if (CodeCompleter)
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002889 CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults);
Douglas Gregor86d9a522009-09-21 16:56:56 +00002890}
2891
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002892static enum CodeCompletionContext::Kind mapCodeCompletionContext(Sema &S,
2893 Sema::ParserCompletionContext PCC) {
2894 switch (PCC) {
John McCallf312b1e2010-08-26 23:41:50 +00002895 case Sema::PCC_Namespace:
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002896 return CodeCompletionContext::CCC_TopLevel;
2897
John McCallf312b1e2010-08-26 23:41:50 +00002898 case Sema::PCC_Class:
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002899 return CodeCompletionContext::CCC_ClassStructUnion;
2900
John McCallf312b1e2010-08-26 23:41:50 +00002901 case Sema::PCC_ObjCInterface:
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002902 return CodeCompletionContext::CCC_ObjCInterface;
2903
John McCallf312b1e2010-08-26 23:41:50 +00002904 case Sema::PCC_ObjCImplementation:
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002905 return CodeCompletionContext::CCC_ObjCImplementation;
2906
John McCallf312b1e2010-08-26 23:41:50 +00002907 case Sema::PCC_ObjCInstanceVariableList:
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002908 return CodeCompletionContext::CCC_ObjCIvarList;
2909
John McCallf312b1e2010-08-26 23:41:50 +00002910 case Sema::PCC_Template:
2911 case Sema::PCC_MemberTemplate:
Douglas Gregor52779fb2010-09-23 23:01:17 +00002912 if (S.CurContext->isFileContext())
2913 return CodeCompletionContext::CCC_TopLevel;
David Blaikie7530c032012-01-17 06:56:22 +00002914 if (S.CurContext->isRecord())
Douglas Gregor52779fb2010-09-23 23:01:17 +00002915 return CodeCompletionContext::CCC_ClassStructUnion;
David Blaikie7530c032012-01-17 06:56:22 +00002916 return CodeCompletionContext::CCC_Other;
Douglas Gregor52779fb2010-09-23 23:01:17 +00002917
John McCallf312b1e2010-08-26 23:41:50 +00002918 case Sema::PCC_RecoveryInFunction:
Douglas Gregor52779fb2010-09-23 23:01:17 +00002919 return CodeCompletionContext::CCC_Recovery;
Douglas Gregora5450a02010-10-18 22:01:46 +00002920
John McCallf312b1e2010-08-26 23:41:50 +00002921 case Sema::PCC_ForInit:
Douglas Gregora5450a02010-10-18 22:01:46 +00002922 if (S.getLangOptions().CPlusPlus || S.getLangOptions().C99 ||
2923 S.getLangOptions().ObjC1)
2924 return CodeCompletionContext::CCC_ParenthesizedExpression;
2925 else
2926 return CodeCompletionContext::CCC_Expression;
2927
2928 case Sema::PCC_Expression:
John McCallf312b1e2010-08-26 23:41:50 +00002929 case Sema::PCC_Condition:
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002930 return CodeCompletionContext::CCC_Expression;
2931
John McCallf312b1e2010-08-26 23:41:50 +00002932 case Sema::PCC_Statement:
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002933 return CodeCompletionContext::CCC_Statement;
Douglas Gregor72db1082010-08-24 01:11:00 +00002934
John McCallf312b1e2010-08-26 23:41:50 +00002935 case Sema::PCC_Type:
Douglas Gregor72db1082010-08-24 01:11:00 +00002936 return CodeCompletionContext::CCC_Type;
Douglas Gregor02688102010-09-14 23:59:36 +00002937
2938 case Sema::PCC_ParenthesizedExpression:
2939 return CodeCompletionContext::CCC_ParenthesizedExpression;
Douglas Gregor68e3c2e2011-02-15 20:33:25 +00002940
2941 case Sema::PCC_LocalDeclarationSpecifiers:
2942 return CodeCompletionContext::CCC_Type;
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002943 }
David Blaikie7530c032012-01-17 06:56:22 +00002944
2945 llvm_unreachable("Invalid ParserCompletionContext!");
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002946}
2947
Douglas Gregorf6961522010-08-27 21:18:54 +00002948/// \brief If we're in a C++ virtual member function, add completion results
2949/// that invoke the functions we override, since it's common to invoke the
2950/// overridden function as well as adding new functionality.
2951///
2952/// \param S The semantic analysis object for which we are generating results.
2953///
2954/// \param InContext This context in which the nested-name-specifier preceding
2955/// the code-completion point
2956static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext,
2957 ResultBuilder &Results) {
2958 // Look through blocks.
2959 DeclContext *CurContext = S.CurContext;
2960 while (isa<BlockDecl>(CurContext))
2961 CurContext = CurContext->getParent();
2962
2963
2964 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext);
2965 if (!Method || !Method->isVirtual())
2966 return;
2967
2968 // We need to have names for all of the parameters, if we're going to
2969 // generate a forwarding call.
2970 for (CXXMethodDecl::param_iterator P = Method->param_begin(),
2971 PEnd = Method->param_end();
2972 P != PEnd;
2973 ++P) {
2974 if (!(*P)->getDeclName())
2975 return;
2976 }
2977
Douglas Gregor8987b232011-09-27 23:30:47 +00002978 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
Douglas Gregorf6961522010-08-27 21:18:54 +00002979 for (CXXMethodDecl::method_iterator M = Method->begin_overridden_methods(),
2980 MEnd = Method->end_overridden_methods();
2981 M != MEnd; ++M) {
Douglas Gregor218937c2011-02-01 19:23:04 +00002982 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregorf6961522010-08-27 21:18:54 +00002983 CXXMethodDecl *Overridden = const_cast<CXXMethodDecl *>(*M);
2984 if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl())
2985 continue;
2986
2987 // If we need a nested-name-specifier, add one now.
2988 if (!InContext) {
2989 NestedNameSpecifier *NNS
2990 = getRequiredQualification(S.Context, CurContext,
2991 Overridden->getDeclContext());
2992 if (NNS) {
2993 std::string Str;
2994 llvm::raw_string_ostream OS(Str);
Douglas Gregor8987b232011-09-27 23:30:47 +00002995 NNS->print(OS, Policy);
Douglas Gregordae68752011-02-01 22:57:45 +00002996 Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
Douglas Gregorf6961522010-08-27 21:18:54 +00002997 }
2998 } else if (!InContext->Equals(Overridden->getDeclContext()))
2999 continue;
3000
Douglas Gregordae68752011-02-01 22:57:45 +00003001 Builder.AddTypedTextChunk(Results.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00003002 Overridden->getNameAsString()));
3003 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
Douglas Gregorf6961522010-08-27 21:18:54 +00003004 bool FirstParam = true;
3005 for (CXXMethodDecl::param_iterator P = Method->param_begin(),
3006 PEnd = Method->param_end();
3007 P != PEnd; ++P) {
3008 if (FirstParam)
3009 FirstParam = false;
3010 else
Douglas Gregor218937c2011-02-01 19:23:04 +00003011 Builder.AddChunk(CodeCompletionString::CK_Comma);
Douglas Gregorf6961522010-08-27 21:18:54 +00003012
Douglas Gregordae68752011-02-01 22:57:45 +00003013 Builder.AddPlaceholderChunk(Results.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00003014 (*P)->getIdentifier()->getName()));
Douglas Gregorf6961522010-08-27 21:18:54 +00003015 }
Douglas Gregor218937c2011-02-01 19:23:04 +00003016 Builder.AddChunk(CodeCompletionString::CK_RightParen);
3017 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
Douglas Gregorf6961522010-08-27 21:18:54 +00003018 CCP_SuperCompletion,
3019 CXCursor_CXXMethod));
3020 Results.Ignore(Overridden);
3021 }
3022}
3023
Douglas Gregor01dfea02010-01-10 23:08:15 +00003024void Sema::CodeCompleteOrdinaryName(Scope *S,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003025 ParserCompletionContext CompletionContext) {
John McCall0a2c5e22010-08-25 06:19:51 +00003026 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00003027 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00003028 mapCodeCompletionContext(*this, CompletionContext));
Douglas Gregorf6961522010-08-27 21:18:54 +00003029 Results.EnterNewScope();
Douglas Gregorcee9ff12010-09-20 22:39:41 +00003030
Douglas Gregor01dfea02010-01-10 23:08:15 +00003031 // Determine how to filter results, e.g., so that the names of
3032 // values (functions, enumerators, function templates, etc.) are
3033 // only allowed where we can have an expression.
3034 switch (CompletionContext) {
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003035 case PCC_Namespace:
3036 case PCC_Class:
3037 case PCC_ObjCInterface:
3038 case PCC_ObjCImplementation:
3039 case PCC_ObjCInstanceVariableList:
3040 case PCC_Template:
3041 case PCC_MemberTemplate:
Douglas Gregor72db1082010-08-24 01:11:00 +00003042 case PCC_Type:
Douglas Gregor68e3c2e2011-02-15 20:33:25 +00003043 case PCC_LocalDeclarationSpecifiers:
Douglas Gregor01dfea02010-01-10 23:08:15 +00003044 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
3045 break;
3046
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003047 case PCC_Statement:
Douglas Gregor02688102010-09-14 23:59:36 +00003048 case PCC_ParenthesizedExpression:
Douglas Gregoreb0d0142010-08-24 23:58:17 +00003049 case PCC_Expression:
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003050 case PCC_ForInit:
3051 case PCC_Condition:
Douglas Gregor4710e5b2010-05-28 00:49:12 +00003052 if (WantTypesInContext(CompletionContext, getLangOptions()))
3053 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3054 else
3055 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
Douglas Gregorf6961522010-08-27 21:18:54 +00003056
3057 if (getLangOptions().CPlusPlus)
3058 MaybeAddOverrideCalls(*this, /*InContext=*/0, Results);
Douglas Gregor01dfea02010-01-10 23:08:15 +00003059 break;
Douglas Gregordc845342010-05-25 05:58:43 +00003060
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003061 case PCC_RecoveryInFunction:
Douglas Gregordc845342010-05-25 05:58:43 +00003062 // Unfiltered
3063 break;
Douglas Gregor01dfea02010-01-10 23:08:15 +00003064 }
3065
Douglas Gregor3cdee122010-08-26 16:36:48 +00003066 // If we are in a C++ non-static member function, check the qualifiers on
3067 // the member function to filter/prioritize the results list.
3068 if (CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext))
3069 if (CurMethod->isInstance())
3070 Results.setObjectTypeQualifiers(
3071 Qualifiers::fromCVRMask(CurMethod->getTypeQualifiers()));
3072
Douglas Gregor1ca6ae82010-01-14 01:09:38 +00003073 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00003074 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3075 CodeCompleter->includeGlobals());
Douglas Gregor2a7925c2009-12-07 09:54:55 +00003076
Douglas Gregorbca403c2010-01-13 23:51:12 +00003077 AddOrdinaryNameResults(CompletionContext, S, *this, Results);
Douglas Gregor2a7925c2009-12-07 09:54:55 +00003078 Results.ExitScope();
3079
Douglas Gregoraa5f77b2010-08-23 21:54:33 +00003080 switch (CompletionContext) {
Douglas Gregor02688102010-09-14 23:59:36 +00003081 case PCC_ParenthesizedExpression:
Douglas Gregor72db1082010-08-24 01:11:00 +00003082 case PCC_Expression:
3083 case PCC_Statement:
3084 case PCC_RecoveryInFunction:
3085 if (S->getFnParent())
3086 AddPrettyFunctionResults(PP.getLangOptions(), Results);
3087 break;
3088
3089 case PCC_Namespace:
3090 case PCC_Class:
3091 case PCC_ObjCInterface:
3092 case PCC_ObjCImplementation:
3093 case PCC_ObjCInstanceVariableList:
3094 case PCC_Template:
3095 case PCC_MemberTemplate:
3096 case PCC_ForInit:
3097 case PCC_Condition:
3098 case PCC_Type:
Douglas Gregor68e3c2e2011-02-15 20:33:25 +00003099 case PCC_LocalDeclarationSpecifiers:
Douglas Gregor72db1082010-08-24 01:11:00 +00003100 break;
Douglas Gregoraa5f77b2010-08-23 21:54:33 +00003101 }
3102
Douglas Gregor0c8296d2009-11-07 00:00:49 +00003103 if (CodeCompleter->includeMacros())
Douglas Gregorbca403c2010-01-13 23:51:12 +00003104 AddMacroResults(PP, Results);
Douglas Gregoraa5f77b2010-08-23 21:54:33 +00003105
Douglas Gregorcee9ff12010-09-20 22:39:41 +00003106 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003107 Results.data(),Results.size());
Douglas Gregor791215b2009-09-21 20:51:25 +00003108}
3109
Douglas Gregorc7b6d882010-09-16 15:14:18 +00003110static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
3111 ParsedType Receiver,
3112 IdentifierInfo **SelIdents,
3113 unsigned NumSelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00003114 bool AtArgumentExpression,
Douglas Gregorc7b6d882010-09-16 15:14:18 +00003115 bool IsSuper,
3116 ResultBuilder &Results);
3117
3118void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
3119 bool AllowNonIdentifiers,
3120 bool AllowNestedNameSpecifiers) {
John McCall0a2c5e22010-08-25 06:19:51 +00003121 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00003122 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00003123 AllowNestedNameSpecifiers
3124 ? CodeCompletionContext::CCC_PotentiallyQualifiedName
3125 : CodeCompletionContext::CCC_Name);
Douglas Gregor2ccccb32010-08-23 18:23:48 +00003126 Results.EnterNewScope();
3127
3128 // Type qualifiers can come after names.
3129 Results.AddResult(Result("const"));
3130 Results.AddResult(Result("volatile"));
3131 if (getLangOptions().C99)
3132 Results.AddResult(Result("restrict"));
3133
3134 if (getLangOptions().CPlusPlus) {
3135 if (AllowNonIdentifiers) {
3136 Results.AddResult(Result("operator"));
3137 }
3138
3139 // Add nested-name-specifiers.
3140 if (AllowNestedNameSpecifiers) {
3141 Results.allowNestedNameSpecifiers();
Douglas Gregor52779fb2010-09-23 23:01:17 +00003142 Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy);
Douglas Gregor2ccccb32010-08-23 18:23:48 +00003143 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3144 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
3145 CodeCompleter->includeGlobals());
Douglas Gregor52779fb2010-09-23 23:01:17 +00003146 Results.setFilter(0);
Douglas Gregor2ccccb32010-08-23 18:23:48 +00003147 }
3148 }
3149 Results.ExitScope();
3150
Douglas Gregorc7b6d882010-09-16 15:14:18 +00003151 // If we're in a context where we might have an expression (rather than a
3152 // declaration), and what we've seen so far is an Objective-C type that could
3153 // be a receiver of a class message, this may be a class message send with
3154 // the initial opening bracket '[' missing. Add appropriate completions.
3155 if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
3156 DS.getTypeSpecType() == DeclSpec::TST_typename &&
3157 DS.getStorageClassSpecAsWritten() == DeclSpec::SCS_unspecified &&
3158 !DS.isThreadSpecified() && !DS.isExternInLinkageSpec() &&
3159 DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified &&
3160 DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
3161 DS.getTypeQualifiers() == 0 &&
3162 S &&
3163 (S->getFlags() & Scope::DeclScope) != 0 &&
3164 (S->getFlags() & (Scope::ClassScope | Scope::TemplateParamScope |
3165 Scope::FunctionPrototypeScope |
3166 Scope::AtCatchScope)) == 0) {
3167 ParsedType T = DS.getRepAsType();
3168 if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType())
Douglas Gregor70c5ac72010-09-20 23:34:21 +00003169 AddClassMessageCompletions(*this, S, T, 0, 0, false, false, Results);
Douglas Gregorc7b6d882010-09-16 15:14:18 +00003170 }
3171
Douglas Gregor4497dd42010-08-24 04:59:56 +00003172 // Note that we intentionally suppress macro results here, since we do not
3173 // encourage using macros to produce the names of entities.
3174
Douglas Gregor52779fb2010-09-23 23:01:17 +00003175 HandleCodeCompleteResults(this, CodeCompleter,
3176 Results.getCompletionContext(),
Douglas Gregor2ccccb32010-08-23 18:23:48 +00003177 Results.data(), Results.size());
3178}
3179
Douglas Gregorfb629412010-08-23 21:17:50 +00003180struct Sema::CodeCompleteExpressionData {
3181 CodeCompleteExpressionData(QualType PreferredType = QualType())
3182 : PreferredType(PreferredType), IntegralConstantExpression(false),
3183 ObjCCollection(false) { }
3184
3185 QualType PreferredType;
3186 bool IntegralConstantExpression;
3187 bool ObjCCollection;
Chris Lattner5f9e2722011-07-23 10:55:15 +00003188 SmallVector<Decl *, 4> IgnoreDecls;
Douglas Gregorfb629412010-08-23 21:17:50 +00003189};
3190
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003191/// \brief Perform code-completion in an expression context when we know what
3192/// type we're looking for.
Douglas Gregorf9578432010-07-28 21:50:18 +00003193///
3194/// \param IntegralConstantExpression Only permit integral constant
3195/// expressions.
Douglas Gregorfb629412010-08-23 21:17:50 +00003196void Sema::CodeCompleteExpression(Scope *S,
3197 const CodeCompleteExpressionData &Data) {
John McCall0a2c5e22010-08-25 06:19:51 +00003198 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00003199 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3200 CodeCompletionContext::CCC_Expression);
Douglas Gregorfb629412010-08-23 21:17:50 +00003201 if (Data.ObjCCollection)
3202 Results.setFilter(&ResultBuilder::IsObjCCollection);
3203 else if (Data.IntegralConstantExpression)
Douglas Gregorf9578432010-07-28 21:50:18 +00003204 Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003205 else if (WantTypesInContext(PCC_Expression, getLangOptions()))
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003206 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3207 else
3208 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
Douglas Gregorfb629412010-08-23 21:17:50 +00003209
3210 if (!Data.PreferredType.isNull())
3211 Results.setPreferredType(Data.PreferredType.getNonReferenceType());
3212
3213 // Ignore any declarations that we were told that we don't care about.
3214 for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I)
3215 Results.Ignore(Data.IgnoreDecls[I]);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003216
3217 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00003218 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3219 CodeCompleter->includeGlobals());
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003220
3221 Results.EnterNewScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003222 AddOrdinaryNameResults(PCC_Expression, S, *this, Results);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003223 Results.ExitScope();
3224
Douglas Gregor590c7d52010-07-08 20:55:51 +00003225 bool PreferredTypeIsPointer = false;
Douglas Gregorfb629412010-08-23 21:17:50 +00003226 if (!Data.PreferredType.isNull())
3227 PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType()
3228 || Data.PreferredType->isMemberPointerType()
3229 || Data.PreferredType->isBlockPointerType();
Douglas Gregor590c7d52010-07-08 20:55:51 +00003230
Douglas Gregoraa5f77b2010-08-23 21:54:33 +00003231 if (S->getFnParent() &&
3232 !Data.ObjCCollection &&
3233 !Data.IntegralConstantExpression)
3234 AddPrettyFunctionResults(PP.getLangOptions(), Results);
3235
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003236 if (CodeCompleter->includeMacros())
Douglas Gregor590c7d52010-07-08 20:55:51 +00003237 AddMacroResults(PP, Results, PreferredTypeIsPointer);
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003238 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregorfb629412010-08-23 21:17:50 +00003239 CodeCompletionContext(CodeCompletionContext::CCC_Expression,
3240 Data.PreferredType),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003241 Results.data(),Results.size());
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003242}
3243
Douglas Gregorac5fd842010-09-18 01:28:11 +00003244void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E) {
3245 if (E.isInvalid())
3246 CodeCompleteOrdinaryName(S, PCC_RecoveryInFunction);
3247 else if (getLangOptions().ObjC1)
3248 CodeCompleteObjCInstanceMessage(S, E.take(), 0, 0, false);
Douglas Gregor78edf512010-09-15 16:23:04 +00003249}
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003250
Douglas Gregor73449212010-12-09 23:01:55 +00003251/// \brief The set of properties that have already been added, referenced by
3252/// property name.
3253typedef llvm::SmallPtrSet<IdentifierInfo*, 16> AddedPropertiesSet;
3254
Douglas Gregor95ac6552009-11-18 01:29:26 +00003255static void AddObjCProperties(ObjCContainerDecl *Container,
Douglas Gregor322328b2009-11-18 22:32:06 +00003256 bool AllowCategories,
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003257 bool AllowNullaryMethods,
Douglas Gregor95ac6552009-11-18 01:29:26 +00003258 DeclContext *CurContext,
Douglas Gregor73449212010-12-09 23:01:55 +00003259 AddedPropertiesSet &AddedProperties,
Douglas Gregor95ac6552009-11-18 01:29:26 +00003260 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00003261 typedef CodeCompletionResult Result;
Douglas Gregor95ac6552009-11-18 01:29:26 +00003262
3263 // Add properties in this container.
3264 for (ObjCContainerDecl::prop_iterator P = Container->prop_begin(),
3265 PEnd = Container->prop_end();
3266 P != PEnd;
Douglas Gregor73449212010-12-09 23:01:55 +00003267 ++P) {
3268 if (AddedProperties.insert(P->getIdentifier()))
3269 Results.MaybeAddResult(Result(*P, 0), CurContext);
3270 }
Douglas Gregor95ac6552009-11-18 01:29:26 +00003271
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003272 // Add nullary methods
3273 if (AllowNullaryMethods) {
3274 ASTContext &Context = Container->getASTContext();
Douglas Gregor8987b232011-09-27 23:30:47 +00003275 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003276 for (ObjCContainerDecl::method_iterator M = Container->meth_begin(),
3277 MEnd = Container->meth_end();
3278 M != MEnd; ++M) {
3279 if (M->getSelector().isUnarySelector())
3280 if (IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0))
3281 if (AddedProperties.insert(Name)) {
3282 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor8987b232011-09-27 23:30:47 +00003283 AddResultTypeChunk(Context, Policy, *M, Builder);
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003284 Builder.AddTypedTextChunk(
3285 Results.getAllocator().CopyString(Name->getName()));
3286
3287 CXAvailabilityKind Availability = CXAvailability_Available;
3288 switch (M->getAvailability()) {
3289 case AR_Available:
3290 case AR_NotYetIntroduced:
3291 Availability = CXAvailability_Available;
3292 break;
3293
3294 case AR_Deprecated:
3295 Availability = CXAvailability_Deprecated;
3296 break;
3297
3298 case AR_Unavailable:
3299 Availability = CXAvailability_NotAvailable;
3300 break;
3301 }
3302
3303 Results.MaybeAddResult(Result(Builder.TakeString(),
3304 CCP_MemberDeclaration + CCD_MethodAsProperty,
3305 M->isInstanceMethod()
3306 ? CXCursor_ObjCInstanceMethodDecl
3307 : CXCursor_ObjCClassMethodDecl,
3308 Availability),
3309 CurContext);
3310 }
3311 }
3312 }
3313
3314
Douglas Gregor95ac6552009-11-18 01:29:26 +00003315 // Add properties in referenced protocols.
3316 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3317 for (ObjCProtocolDecl::protocol_iterator P = Protocol->protocol_begin(),
3318 PEnd = Protocol->protocol_end();
3319 P != PEnd; ++P)
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003320 AddObjCProperties(*P, AllowCategories, AllowNullaryMethods, CurContext,
3321 AddedProperties, Results);
Douglas Gregor95ac6552009-11-18 01:29:26 +00003322 } else if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)){
Douglas Gregor322328b2009-11-18 22:32:06 +00003323 if (AllowCategories) {
3324 // Look through categories.
3325 for (ObjCCategoryDecl *Category = IFace->getCategoryList();
3326 Category; Category = Category->getNextClassCategory())
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003327 AddObjCProperties(Category, AllowCategories, AllowNullaryMethods,
3328 CurContext, AddedProperties, Results);
Douglas Gregor322328b2009-11-18 22:32:06 +00003329 }
Douglas Gregor95ac6552009-11-18 01:29:26 +00003330
3331 // Look through protocols.
Ted Kremenek53b94412010-09-01 01:21:15 +00003332 for (ObjCInterfaceDecl::all_protocol_iterator
3333 I = IFace->all_referenced_protocol_begin(),
3334 E = IFace->all_referenced_protocol_end(); I != E; ++I)
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003335 AddObjCProperties(*I, AllowCategories, AllowNullaryMethods, CurContext,
3336 AddedProperties, Results);
Douglas Gregor95ac6552009-11-18 01:29:26 +00003337
3338 // Look in the superclass.
3339 if (IFace->getSuperClass())
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003340 AddObjCProperties(IFace->getSuperClass(), AllowCategories,
3341 AllowNullaryMethods, CurContext,
Douglas Gregor73449212010-12-09 23:01:55 +00003342 AddedProperties, Results);
Douglas Gregor95ac6552009-11-18 01:29:26 +00003343 } else if (const ObjCCategoryDecl *Category
3344 = dyn_cast<ObjCCategoryDecl>(Container)) {
3345 // Look through protocols.
Ted Kremenek53b94412010-09-01 01:21:15 +00003346 for (ObjCCategoryDecl::protocol_iterator P = Category->protocol_begin(),
3347 PEnd = Category->protocol_end();
Douglas Gregor95ac6552009-11-18 01:29:26 +00003348 P != PEnd; ++P)
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003349 AddObjCProperties(*P, AllowCategories, AllowNullaryMethods, CurContext,
3350 AddedProperties, Results);
Douglas Gregor95ac6552009-11-18 01:29:26 +00003351 }
3352}
3353
Douglas Gregorf5cd27d2012-01-23 15:59:30 +00003354void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
Douglas Gregor81b747b2009-09-17 21:32:03 +00003355 SourceLocation OpLoc,
3356 bool IsArrow) {
Douglas Gregorf5cd27d2012-01-23 15:59:30 +00003357 if (!Base || !CodeCompleter)
Douglas Gregor81b747b2009-09-17 21:32:03 +00003358 return;
3359
Douglas Gregorf5cd27d2012-01-23 15:59:30 +00003360 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
3361 if (ConvertedBase.isInvalid())
3362 return;
3363 Base = ConvertedBase.get();
3364
John McCall0a2c5e22010-08-25 06:19:51 +00003365 typedef CodeCompletionResult Result;
Douglas Gregor86d9a522009-09-21 16:56:56 +00003366
Douglas Gregor81b747b2009-09-17 21:32:03 +00003367 QualType BaseType = Base->getType();
Douglas Gregor86d9a522009-09-21 16:56:56 +00003368
3369 if (IsArrow) {
3370 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
3371 BaseType = Ptr->getPointeeType();
3372 else if (BaseType->isObjCObjectPointerType())
Douglas Gregor3cdee122010-08-26 16:36:48 +00003373 /*Do nothing*/ ;
Douglas Gregor86d9a522009-09-21 16:56:56 +00003374 else
3375 return;
3376 }
3377
Douglas Gregor3da626b2011-07-07 16:03:39 +00003378 enum CodeCompletionContext::Kind contextKind;
3379
3380 if (IsArrow) {
3381 contextKind = CodeCompletionContext::CCC_ArrowMemberAccess;
3382 }
3383 else {
3384 if (BaseType->isObjCObjectPointerType() ||
3385 BaseType->isObjCObjectOrInterfaceType()) {
3386 contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess;
3387 }
3388 else {
3389 contextKind = CodeCompletionContext::CCC_DotMemberAccess;
3390 }
3391 }
3392
Douglas Gregor218937c2011-02-01 19:23:04 +00003393 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor3da626b2011-07-07 16:03:39 +00003394 CodeCompletionContext(contextKind,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003395 BaseType),
3396 &ResultBuilder::IsMember);
Douglas Gregor95ac6552009-11-18 01:29:26 +00003397 Results.EnterNewScope();
3398 if (const RecordType *Record = BaseType->getAs<RecordType>()) {
Douglas Gregor3cdee122010-08-26 16:36:48 +00003399 // Indicate that we are performing a member access, and the cv-qualifiers
3400 // for the base object type.
3401 Results.setObjectTypeQualifiers(BaseType.getQualifiers());
3402
Douglas Gregor95ac6552009-11-18 01:29:26 +00003403 // Access to a C/C++ class, struct, or union.
Douglas Gregor45bcd432010-01-14 03:21:49 +00003404 Results.allowNestedNameSpecifiers();
Douglas Gregor0cc84042010-01-14 15:47:35 +00003405 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00003406 LookupVisibleDecls(Record->getDecl(), LookupMemberName, Consumer,
3407 CodeCompleter->includeGlobals());
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00003408
Douglas Gregor95ac6552009-11-18 01:29:26 +00003409 if (getLangOptions().CPlusPlus) {
3410 if (!Results.empty()) {
3411 // The "template" keyword can follow "->" or "." in the grammar.
3412 // However, we only want to suggest the template keyword if something
3413 // is dependent.
3414 bool IsDependent = BaseType->isDependentType();
3415 if (!IsDependent) {
3416 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent())
3417 if (DeclContext *Ctx = (DeclContext *)DepScope->getEntity()) {
3418 IsDependent = Ctx->isDependentContext();
3419 break;
3420 }
3421 }
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00003422
Douglas Gregor95ac6552009-11-18 01:29:26 +00003423 if (IsDependent)
Douglas Gregora4477812010-01-14 16:01:26 +00003424 Results.AddResult(Result("template"));
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00003425 }
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00003426 }
Douglas Gregor95ac6552009-11-18 01:29:26 +00003427 } else if (!IsArrow && BaseType->getAsObjCInterfacePointerType()) {
3428 // Objective-C property reference.
Douglas Gregor73449212010-12-09 23:01:55 +00003429 AddedPropertiesSet AddedProperties;
Douglas Gregor95ac6552009-11-18 01:29:26 +00003430
3431 // Add property results based on our interface.
3432 const ObjCObjectPointerType *ObjCPtr
3433 = BaseType->getAsObjCInterfacePointerType();
3434 assert(ObjCPtr && "Non-NULL pointer guaranteed above!");
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003435 AddObjCProperties(ObjCPtr->getInterfaceDecl(), true,
3436 /*AllowNullaryMethods=*/true, CurContext,
Douglas Gregor73449212010-12-09 23:01:55 +00003437 AddedProperties, Results);
Douglas Gregor95ac6552009-11-18 01:29:26 +00003438
3439 // Add properties from the protocols in a qualified interface.
3440 for (ObjCObjectPointerType::qual_iterator I = ObjCPtr->qual_begin(),
3441 E = ObjCPtr->qual_end();
3442 I != E; ++I)
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003443 AddObjCProperties(*I, true, /*AllowNullaryMethods=*/true, CurContext,
3444 AddedProperties, Results);
Douglas Gregor95ac6552009-11-18 01:29:26 +00003445 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) ||
John McCallc12c5bb2010-05-15 11:32:37 +00003446 (!IsArrow && BaseType->isObjCObjectType())) {
Douglas Gregor95ac6552009-11-18 01:29:26 +00003447 // Objective-C instance variable access.
3448 ObjCInterfaceDecl *Class = 0;
3449 if (const ObjCObjectPointerType *ObjCPtr
3450 = BaseType->getAs<ObjCObjectPointerType>())
3451 Class = ObjCPtr->getInterfaceDecl();
3452 else
John McCallc12c5bb2010-05-15 11:32:37 +00003453 Class = BaseType->getAs<ObjCObjectType>()->getInterface();
Douglas Gregor95ac6552009-11-18 01:29:26 +00003454
3455 // Add all ivars from this class and its superclasses.
Douglas Gregor80f4f4c2010-01-14 16:08:12 +00003456 if (Class) {
3457 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3458 Results.setFilter(&ResultBuilder::IsObjCIvar);
Douglas Gregor8071e422010-08-15 06:18:01 +00003459 LookupVisibleDecls(Class, LookupMemberName, Consumer,
3460 CodeCompleter->includeGlobals());
Douglas Gregor95ac6552009-11-18 01:29:26 +00003461 }
Douglas Gregor86d9a522009-09-21 16:56:56 +00003462 }
Douglas Gregor95ac6552009-11-18 01:29:26 +00003463
3464 // FIXME: How do we cope with isa?
3465
3466 Results.ExitScope();
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00003467
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00003468 // Hand off the results found for code completion.
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003469 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003470 Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003471 Results.data(),Results.size());
Douglas Gregor81b747b2009-09-17 21:32:03 +00003472}
3473
Douglas Gregor374929f2009-09-18 15:37:17 +00003474void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) {
3475 if (!CodeCompleter)
3476 return;
3477
John McCall0a2c5e22010-08-25 06:19:51 +00003478 typedef CodeCompletionResult Result;
Douglas Gregor86d9a522009-09-21 16:56:56 +00003479 ResultBuilder::LookupFilter Filter = 0;
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003480 enum CodeCompletionContext::Kind ContextKind
3481 = CodeCompletionContext::CCC_Other;
Douglas Gregor374929f2009-09-18 15:37:17 +00003482 switch ((DeclSpec::TST)TagSpec) {
3483 case DeclSpec::TST_enum:
Douglas Gregor86d9a522009-09-21 16:56:56 +00003484 Filter = &ResultBuilder::IsEnum;
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003485 ContextKind = CodeCompletionContext::CCC_EnumTag;
Douglas Gregor374929f2009-09-18 15:37:17 +00003486 break;
3487
3488 case DeclSpec::TST_union:
Douglas Gregor86d9a522009-09-21 16:56:56 +00003489 Filter = &ResultBuilder::IsUnion;
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003490 ContextKind = CodeCompletionContext::CCC_UnionTag;
Douglas Gregor374929f2009-09-18 15:37:17 +00003491 break;
3492
3493 case DeclSpec::TST_struct:
Douglas Gregor374929f2009-09-18 15:37:17 +00003494 case DeclSpec::TST_class:
Douglas Gregor86d9a522009-09-21 16:56:56 +00003495 Filter = &ResultBuilder::IsClassOrStruct;
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003496 ContextKind = CodeCompletionContext::CCC_ClassOrStructTag;
Douglas Gregor374929f2009-09-18 15:37:17 +00003497 break;
3498
3499 default:
David Blaikieb219cfc2011-09-23 05:06:16 +00003500 llvm_unreachable("Unknown type specifier kind in CodeCompleteTag");
Douglas Gregor374929f2009-09-18 15:37:17 +00003501 }
Douglas Gregor86d9a522009-09-21 16:56:56 +00003502
Douglas Gregor218937c2011-02-01 19:23:04 +00003503 ResultBuilder Results(*this, CodeCompleter->getAllocator(), ContextKind);
Douglas Gregor5d2fc402010-01-14 03:27:13 +00003504 CodeCompletionDeclConsumer Consumer(Results, CurContext);
John McCall0d6b1642010-04-23 18:46:30 +00003505
3506 // First pass: look for tags.
3507 Results.setFilter(Filter);
Douglas Gregor8071e422010-08-15 06:18:01 +00003508 LookupVisibleDecls(S, LookupTagName, Consumer,
3509 CodeCompleter->includeGlobals());
John McCall0d6b1642010-04-23 18:46:30 +00003510
Douglas Gregor8071e422010-08-15 06:18:01 +00003511 if (CodeCompleter->includeGlobals()) {
3512 // Second pass: look for nested name specifiers.
3513 Results.setFilter(&ResultBuilder::IsNestedNameSpecifier);
3514 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer);
3515 }
Douglas Gregor86d9a522009-09-21 16:56:56 +00003516
Douglas Gregor52779fb2010-09-23 23:01:17 +00003517 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003518 Results.data(),Results.size());
Douglas Gregor374929f2009-09-18 15:37:17 +00003519}
3520
Douglas Gregor1a480c42010-08-27 17:35:51 +00003521void Sema::CodeCompleteTypeQualifiers(DeclSpec &DS) {
Douglas Gregor218937c2011-02-01 19:23:04 +00003522 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3523 CodeCompletionContext::CCC_TypeQualifiers);
Douglas Gregor1a480c42010-08-27 17:35:51 +00003524 Results.EnterNewScope();
3525 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
3526 Results.AddResult("const");
3527 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile))
3528 Results.AddResult("volatile");
3529 if (getLangOptions().C99 &&
3530 !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict))
3531 Results.AddResult("restrict");
3532 Results.ExitScope();
3533 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003534 Results.getCompletionContext(),
Douglas Gregor1a480c42010-08-27 17:35:51 +00003535 Results.data(), Results.size());
3536}
3537
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003538void Sema::CodeCompleteCase(Scope *S) {
John McCall781472f2010-08-25 08:40:02 +00003539 if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003540 return;
John McCalla8e0cd82011-08-06 07:30:58 +00003541
John McCall781472f2010-08-25 08:40:02 +00003542 SwitchStmt *Switch = getCurFunction()->SwitchStack.back();
John McCalla8e0cd82011-08-06 07:30:58 +00003543 QualType type = Switch->getCond()->IgnoreImplicit()->getType();
3544 if (!type->isEnumeralType()) {
3545 CodeCompleteExpressionData Data(type);
Douglas Gregorfb629412010-08-23 21:17:50 +00003546 Data.IntegralConstantExpression = true;
3547 CodeCompleteExpression(S, Data);
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003548 return;
Douglas Gregorf9578432010-07-28 21:50:18 +00003549 }
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003550
3551 // Code-complete the cases of a switch statement over an enumeration type
3552 // by providing the list of
John McCalla8e0cd82011-08-06 07:30:58 +00003553 EnumDecl *Enum = type->castAs<EnumType>()->getDecl();
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003554
3555 // Determine which enumerators we have already seen in the switch statement.
3556 // FIXME: Ideally, we would also be able to look *past* the code-completion
3557 // token, in case we are code-completing in the middle of the switch and not
3558 // at the end. However, we aren't able to do so at the moment.
3559 llvm::SmallPtrSet<EnumConstantDecl *, 8> EnumeratorsSeen;
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00003560 NestedNameSpecifier *Qualifier = 0;
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003561 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC;
3562 SC = SC->getNextSwitchCase()) {
3563 CaseStmt *Case = dyn_cast<CaseStmt>(SC);
3564 if (!Case)
3565 continue;
3566
3567 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
3568 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CaseVal))
3569 if (EnumConstantDecl *Enumerator
3570 = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
3571 // We look into the AST of the case statement to determine which
3572 // enumerator was named. Alternatively, we could compute the value of
3573 // the integral constant expression, then compare it against the
3574 // values of each enumerator. However, value-based approach would not
3575 // work as well with C++ templates where enumerators declared within a
3576 // template are type- and value-dependent.
3577 EnumeratorsSeen.insert(Enumerator);
3578
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00003579 // If this is a qualified-id, keep track of the nested-name-specifier
3580 // so that we can reproduce it as part of code completion, e.g.,
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003581 //
3582 // switch (TagD.getKind()) {
3583 // case TagDecl::TK_enum:
3584 // break;
3585 // case XXX
3586 //
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00003587 // At the XXX, our completions are TagDecl::TK_union,
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003588 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union,
3589 // TK_struct, and TK_class.
Douglas Gregora2813ce2009-10-23 18:54:35 +00003590 Qualifier = DRE->getQualifier();
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003591 }
3592 }
3593
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00003594 if (getLangOptions().CPlusPlus && !Qualifier && EnumeratorsSeen.empty()) {
3595 // If there are no prior enumerators in C++, check whether we have to
3596 // qualify the names of the enumerators that we suggest, because they
3597 // may not be visible in this scope.
3598 Qualifier = getRequiredQualification(Context, CurContext,
3599 Enum->getDeclContext());
3600
3601 // FIXME: Scoped enums need to start with "EnumDecl" as the context!
3602 }
3603
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003604 // Add any enumerators that have not yet been mentioned.
Douglas Gregor218937c2011-02-01 19:23:04 +00003605 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3606 CodeCompletionContext::CCC_Expression);
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003607 Results.EnterNewScope();
3608 for (EnumDecl::enumerator_iterator E = Enum->enumerator_begin(),
3609 EEnd = Enum->enumerator_end();
3610 E != EEnd; ++E) {
3611 if (EnumeratorsSeen.count(*E))
3612 continue;
3613
Douglas Gregor5c722c702011-02-18 23:30:37 +00003614 CodeCompletionResult R(*E, Qualifier);
3615 R.Priority = CCP_EnumInCase;
3616 Results.AddResult(R, CurContext, 0, false);
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003617 }
3618 Results.ExitScope();
Douglas Gregor2f880e42010-04-06 20:02:15 +00003619
Douglas Gregor3da626b2011-07-07 16:03:39 +00003620 //We need to make sure we're setting the right context,
3621 //so only say we include macros if the code completer says we do
3622 enum CodeCompletionContext::Kind kind = CodeCompletionContext::CCC_Other;
3623 if (CodeCompleter->includeMacros()) {
Douglas Gregorbca403c2010-01-13 23:51:12 +00003624 AddMacroResults(PP, Results);
Douglas Gregor3da626b2011-07-07 16:03:39 +00003625 kind = CodeCompletionContext::CCC_OtherWithMacros;
3626 }
3627
3628
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003629 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor3da626b2011-07-07 16:03:39 +00003630 kind,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003631 Results.data(),Results.size());
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003632}
3633
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003634namespace {
3635 struct IsBetterOverloadCandidate {
3636 Sema &S;
John McCall5769d612010-02-08 23:07:23 +00003637 SourceLocation Loc;
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003638
3639 public:
John McCall5769d612010-02-08 23:07:23 +00003640 explicit IsBetterOverloadCandidate(Sema &S, SourceLocation Loc)
3641 : S(S), Loc(Loc) { }
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003642
3643 bool
3644 operator()(const OverloadCandidate &X, const OverloadCandidate &Y) const {
John McCall120d63c2010-08-24 20:38:10 +00003645 return isBetterOverloadCandidate(S, X, Y, Loc);
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003646 }
3647 };
3648}
3649
Douglas Gregord28dcd72010-05-30 06:10:08 +00003650static bool anyNullArguments(Expr **Args, unsigned NumArgs) {
3651 if (NumArgs && !Args)
3652 return true;
3653
3654 for (unsigned I = 0; I != NumArgs; ++I)
3655 if (!Args[I])
3656 return true;
3657
3658 return false;
3659}
3660
Richard Trieuf81e5a92011-09-09 02:00:50 +00003661void Sema::CodeCompleteCall(Scope *S, Expr *FnIn,
3662 Expr **ArgsIn, unsigned NumArgs) {
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003663 if (!CodeCompleter)
3664 return;
Douglas Gregoref96eac2009-12-11 19:06:04 +00003665
3666 // When we're code-completing for a call, we fall back to ordinary
3667 // name code-completion whenever we can't produce specific
3668 // results. We may want to revisit this strategy in the future,
3669 // e.g., by merging the two kinds of results.
3670
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003671 Expr *Fn = (Expr *)FnIn;
3672 Expr **Args = (Expr **)ArgsIn;
Douglas Gregoref96eac2009-12-11 19:06:04 +00003673
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003674 // Ignore type-dependent call expressions entirely.
Douglas Gregord28dcd72010-05-30 06:10:08 +00003675 if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args, NumArgs) ||
Douglas Gregoref96eac2009-12-11 19:06:04 +00003676 Expr::hasAnyTypeDependentArguments(Args, NumArgs)) {
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003677 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003678 return;
Douglas Gregoref96eac2009-12-11 19:06:04 +00003679 }
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003680
John McCall3b4294e2009-12-16 12:17:52 +00003681 // Build an overload candidate set based on the functions we find.
John McCall5769d612010-02-08 23:07:23 +00003682 SourceLocation Loc = Fn->getExprLoc();
3683 OverloadCandidateSet CandidateSet(Loc);
John McCall3b4294e2009-12-16 12:17:52 +00003684
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003685 // FIXME: What if we're calling something that isn't a function declaration?
3686 // FIXME: What if we're calling a pseudo-destructor?
3687 // FIXME: What if we're calling a member function?
3688
Douglas Gregorc0265402010-01-21 15:46:19 +00003689 typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate;
Chris Lattner5f9e2722011-07-23 10:55:15 +00003690 SmallVector<ResultCandidate, 8> Results;
Douglas Gregorc0265402010-01-21 15:46:19 +00003691
John McCall3b4294e2009-12-16 12:17:52 +00003692 Expr *NakedFn = Fn->IgnoreParenCasts();
3693 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn))
3694 AddOverloadedCallCandidates(ULE, Args, NumArgs, CandidateSet,
3695 /*PartialOverloading=*/ true);
3696 else if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(NakedFn)) {
3697 FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
Douglas Gregorc0265402010-01-21 15:46:19 +00003698 if (FDecl) {
Douglas Gregord28dcd72010-05-30 06:10:08 +00003699 if (!getLangOptions().CPlusPlus ||
3700 !FDecl->getType()->getAs<FunctionProtoType>())
Douglas Gregorc0265402010-01-21 15:46:19 +00003701 Results.push_back(ResultCandidate(FDecl));
3702 else
John McCall86820f52010-01-26 01:37:31 +00003703 // FIXME: access?
John McCall9aa472c2010-03-19 07:35:19 +00003704 AddOverloadCandidate(FDecl, DeclAccessPair::make(FDecl, AS_none),
3705 Args, NumArgs, CandidateSet,
Douglas Gregorc27d6c52010-04-16 17:41:49 +00003706 false, /*PartialOverloading*/true);
Douglas Gregorc0265402010-01-21 15:46:19 +00003707 }
John McCall3b4294e2009-12-16 12:17:52 +00003708 }
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003709
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003710 QualType ParamType;
3711
Douglas Gregorc0265402010-01-21 15:46:19 +00003712 if (!CandidateSet.empty()) {
3713 // Sort the overload candidate set by placing the best overloads first.
3714 std::stable_sort(CandidateSet.begin(), CandidateSet.end(),
John McCall5769d612010-02-08 23:07:23 +00003715 IsBetterOverloadCandidate(*this, Loc));
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003716
Douglas Gregorc0265402010-01-21 15:46:19 +00003717 // Add the remaining viable overload candidates as code-completion reslults.
3718 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(),
3719 CandEnd = CandidateSet.end();
3720 Cand != CandEnd; ++Cand) {
3721 if (Cand->Viable)
3722 Results.push_back(ResultCandidate(Cand->Function));
3723 }
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003724
3725 // From the viable candidates, try to determine the type of this parameter.
3726 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
3727 if (const FunctionType *FType = Results[I].getFunctionType())
3728 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FType))
3729 if (NumArgs < Proto->getNumArgs()) {
3730 if (ParamType.isNull())
3731 ParamType = Proto->getArgType(NumArgs);
3732 else if (!Context.hasSameUnqualifiedType(
3733 ParamType.getNonReferenceType(),
3734 Proto->getArgType(NumArgs).getNonReferenceType())) {
3735 ParamType = QualType();
3736 break;
3737 }
3738 }
3739 }
3740 } else {
3741 // Try to determine the parameter type from the type of the expression
3742 // being called.
3743 QualType FunctionType = Fn->getType();
3744 if (const PointerType *Ptr = FunctionType->getAs<PointerType>())
3745 FunctionType = Ptr->getPointeeType();
3746 else if (const BlockPointerType *BlockPtr
3747 = FunctionType->getAs<BlockPointerType>())
3748 FunctionType = BlockPtr->getPointeeType();
3749 else if (const MemberPointerType *MemPtr
3750 = FunctionType->getAs<MemberPointerType>())
3751 FunctionType = MemPtr->getPointeeType();
3752
3753 if (const FunctionProtoType *Proto
3754 = FunctionType->getAs<FunctionProtoType>()) {
3755 if (NumArgs < Proto->getNumArgs())
3756 ParamType = Proto->getArgType(NumArgs);
3757 }
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003758 }
Douglas Gregoref96eac2009-12-11 19:06:04 +00003759
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003760 if (ParamType.isNull())
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003761 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003762 else
3763 CodeCompleteExpression(S, ParamType);
3764
Douglas Gregor2e4c7a52010-04-06 20:19:47 +00003765 if (!Results.empty())
Douglas Gregoref96eac2009-12-11 19:06:04 +00003766 CodeCompleter->ProcessOverloadCandidates(*this, NumArgs, Results.data(),
3767 Results.size());
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003768}
3769
John McCalld226f652010-08-21 09:40:31 +00003770void Sema::CodeCompleteInitializer(Scope *S, Decl *D) {
3771 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003772 if (!VD) {
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003773 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003774 return;
3775 }
3776
3777 CodeCompleteExpression(S, VD->getType());
3778}
3779
3780void Sema::CodeCompleteReturn(Scope *S) {
3781 QualType ResultType;
3782 if (isa<BlockDecl>(CurContext)) {
3783 if (BlockScopeInfo *BSI = getCurBlock())
3784 ResultType = BSI->ReturnType;
3785 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(CurContext))
3786 ResultType = Function->getResultType();
3787 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(CurContext))
3788 ResultType = Method->getResultType();
3789
3790 if (ResultType.isNull())
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003791 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003792 else
3793 CodeCompleteExpression(S, ResultType);
3794}
3795
Douglas Gregord2d8be62011-07-30 08:36:53 +00003796void Sema::CodeCompleteAfterIf(Scope *S) {
3797 typedef CodeCompletionResult Result;
3798 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3799 mapCodeCompletionContext(*this, PCC_Statement));
3800 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3801 Results.EnterNewScope();
3802
3803 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3804 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3805 CodeCompleter->includeGlobals());
3806
3807 AddOrdinaryNameResults(PCC_Statement, S, *this, Results);
3808
3809 // "else" block
3810 CodeCompletionBuilder Builder(Results.getAllocator());
3811 Builder.AddTypedTextChunk("else");
3812 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3813 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
3814 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
3815 Builder.AddPlaceholderChunk("statements");
3816 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
3817 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
3818 Results.AddResult(Builder.TakeString());
3819
3820 // "else if" block
3821 Builder.AddTypedTextChunk("else");
3822 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3823 Builder.AddTextChunk("if");
3824 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3825 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
3826 if (getLangOptions().CPlusPlus)
3827 Builder.AddPlaceholderChunk("condition");
3828 else
3829 Builder.AddPlaceholderChunk("expression");
3830 Builder.AddChunk(CodeCompletionString::CK_RightParen);
3831 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3832 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
3833 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
3834 Builder.AddPlaceholderChunk("statements");
3835 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
3836 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
3837 Results.AddResult(Builder.TakeString());
3838
3839 Results.ExitScope();
3840
3841 if (S->getFnParent())
3842 AddPrettyFunctionResults(PP.getLangOptions(), Results);
3843
3844 if (CodeCompleter->includeMacros())
3845 AddMacroResults(PP, Results);
3846
3847 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3848 Results.data(),Results.size());
3849}
3850
Richard Trieuf81e5a92011-09-09 02:00:50 +00003851void Sema::CodeCompleteAssignmentRHS(Scope *S, Expr *LHS) {
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003852 if (LHS)
3853 CodeCompleteExpression(S, static_cast<Expr *>(LHS)->getType());
3854 else
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003855 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003856}
3857
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00003858void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
Douglas Gregor81b747b2009-09-17 21:32:03 +00003859 bool EnteringContext) {
3860 if (!SS.getScopeRep() || !CodeCompleter)
3861 return;
3862
Douglas Gregor86d9a522009-09-21 16:56:56 +00003863 DeclContext *Ctx = computeDeclContext(SS, EnteringContext);
3864 if (!Ctx)
3865 return;
Douglas Gregord1cd31a2009-12-11 18:28:39 +00003866
3867 // Try to instantiate any non-dependent declaration contexts before
3868 // we look in them.
John McCall77bb1aa2010-05-01 00:40:08 +00003869 if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx))
Douglas Gregord1cd31a2009-12-11 18:28:39 +00003870 return;
3871
Douglas Gregor218937c2011-02-01 19:23:04 +00003872 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3873 CodeCompletionContext::CCC_Name);
Douglas Gregorf6961522010-08-27 21:18:54 +00003874 Results.EnterNewScope();
Douglas Gregor52779fb2010-09-23 23:01:17 +00003875
Douglas Gregor86d9a522009-09-21 16:56:56 +00003876 // The "template" keyword can follow "::" in the grammar, but only
3877 // put it into the grammar if the nested-name-specifier is dependent.
3878 NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep();
3879 if (!Results.empty() && NNS->isDependent())
Douglas Gregora4477812010-01-14 16:01:26 +00003880 Results.AddResult("template");
Douglas Gregorf6961522010-08-27 21:18:54 +00003881
3882 // Add calls to overridden virtual functions, if there are any.
3883 //
3884 // FIXME: This isn't wonderful, because we don't know whether we're actually
3885 // in a context that permits expressions. This is a general issue with
3886 // qualified-id completions.
3887 if (!EnteringContext)
3888 MaybeAddOverrideCalls(*this, Ctx, Results);
3889 Results.ExitScope();
Douglas Gregor86d9a522009-09-21 16:56:56 +00003890
Douglas Gregorf6961522010-08-27 21:18:54 +00003891 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3892 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer);
3893
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003894 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor430d7a12011-07-25 17:48:11 +00003895 Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003896 Results.data(),Results.size());
Douglas Gregor81b747b2009-09-17 21:32:03 +00003897}
Douglas Gregor49f40bd2009-09-18 19:03:04 +00003898
3899void Sema::CodeCompleteUsing(Scope *S) {
3900 if (!CodeCompleter)
3901 return;
3902
Douglas Gregor218937c2011-02-01 19:23:04 +00003903 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00003904 CodeCompletionContext::CCC_PotentiallyQualifiedName,
3905 &ResultBuilder::IsNestedNameSpecifier);
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00003906 Results.EnterNewScope();
Douglas Gregor86d9a522009-09-21 16:56:56 +00003907
3908 // If we aren't in class scope, we could see the "namespace" keyword.
3909 if (!S->isClassScope())
John McCall0a2c5e22010-08-25 06:19:51 +00003910 Results.AddResult(CodeCompletionResult("namespace"));
Douglas Gregor86d9a522009-09-21 16:56:56 +00003911
3912 // After "using", we can see anything that would start a
3913 // nested-name-specifier.
Douglas Gregor5d2fc402010-01-14 03:27:13 +00003914 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00003915 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3916 CodeCompleter->includeGlobals());
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00003917 Results.ExitScope();
Douglas Gregor86d9a522009-09-21 16:56:56 +00003918
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003919 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003920 CodeCompletionContext::CCC_PotentiallyQualifiedName,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003921 Results.data(),Results.size());
Douglas Gregor49f40bd2009-09-18 19:03:04 +00003922}
3923
3924void Sema::CodeCompleteUsingDirective(Scope *S) {
3925 if (!CodeCompleter)
3926 return;
3927
Douglas Gregor86d9a522009-09-21 16:56:56 +00003928 // After "using namespace", we expect to see a namespace name or namespace
3929 // alias.
Douglas Gregor218937c2011-02-01 19:23:04 +00003930 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3931 CodeCompletionContext::CCC_Namespace,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003932 &ResultBuilder::IsNamespaceOrAlias);
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00003933 Results.EnterNewScope();
Douglas Gregor5d2fc402010-01-14 03:27:13 +00003934 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00003935 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3936 CodeCompleter->includeGlobals());
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00003937 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003938 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor8071e422010-08-15 06:18:01 +00003939 CodeCompletionContext::CCC_Namespace,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003940 Results.data(),Results.size());
Douglas Gregor49f40bd2009-09-18 19:03:04 +00003941}
3942
3943void Sema::CodeCompleteNamespaceDecl(Scope *S) {
3944 if (!CodeCompleter)
3945 return;
3946
Douglas Gregor86d9a522009-09-21 16:56:56 +00003947 DeclContext *Ctx = (DeclContext *)S->getEntity();
3948 if (!S->getParent())
3949 Ctx = Context.getTranslationUnitDecl();
3950
Douglas Gregor52779fb2010-09-23 23:01:17 +00003951 bool SuppressedGlobalResults
3952 = Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx);
3953
Douglas Gregor218937c2011-02-01 19:23:04 +00003954 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00003955 SuppressedGlobalResults
3956 ? CodeCompletionContext::CCC_Namespace
3957 : CodeCompletionContext::CCC_Other,
3958 &ResultBuilder::IsNamespace);
3959
3960 if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) {
Douglas Gregor86d9a522009-09-21 16:56:56 +00003961 // We only want to see those namespaces that have already been defined
3962 // within this scope, because its likely that the user is creating an
3963 // extended namespace declaration. Keep track of the most recent
3964 // definition of each namespace.
3965 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest;
3966 for (DeclContext::specific_decl_iterator<NamespaceDecl>
3967 NS(Ctx->decls_begin()), NSEnd(Ctx->decls_end());
3968 NS != NSEnd; ++NS)
3969 OrigToLatest[NS->getOriginalNamespace()] = *NS;
3970
3971 // Add the most recent definition (or extended definition) of each
3972 // namespace to the list of results.
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00003973 Results.EnterNewScope();
Douglas Gregor86d9a522009-09-21 16:56:56 +00003974 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator
3975 NS = OrigToLatest.begin(), NSEnd = OrigToLatest.end();
3976 NS != NSEnd; ++NS)
John McCall0a2c5e22010-08-25 06:19:51 +00003977 Results.AddResult(CodeCompletionResult(NS->second, 0),
Douglas Gregor608300b2010-01-14 16:14:35 +00003978 CurContext, 0, false);
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00003979 Results.ExitScope();
Douglas Gregor86d9a522009-09-21 16:56:56 +00003980 }
3981
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003982 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003983 Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003984 Results.data(),Results.size());
Douglas Gregor49f40bd2009-09-18 19:03:04 +00003985}
3986
3987void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) {
3988 if (!CodeCompleter)
3989 return;
3990
Douglas Gregor86d9a522009-09-21 16:56:56 +00003991 // After "namespace", we expect to see a namespace or alias.
Douglas Gregor218937c2011-02-01 19:23:04 +00003992 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3993 CodeCompletionContext::CCC_Namespace,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003994 &ResultBuilder::IsNamespaceOrAlias);
Douglas Gregor5d2fc402010-01-14 03:27:13 +00003995 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00003996 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3997 CodeCompleter->includeGlobals());
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003998 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003999 Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004000 Results.data(),Results.size());
Douglas Gregor49f40bd2009-09-18 19:03:04 +00004001}
4002
Douglas Gregored8d3222009-09-18 20:05:18 +00004003void Sema::CodeCompleteOperatorName(Scope *S) {
4004 if (!CodeCompleter)
4005 return;
Douglas Gregor86d9a522009-09-21 16:56:56 +00004006
John McCall0a2c5e22010-08-25 06:19:51 +00004007 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004008 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4009 CodeCompletionContext::CCC_Type,
Douglas Gregor52779fb2010-09-23 23:01:17 +00004010 &ResultBuilder::IsType);
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00004011 Results.EnterNewScope();
Douglas Gregored8d3222009-09-18 20:05:18 +00004012
Douglas Gregor86d9a522009-09-21 16:56:56 +00004013 // Add the names of overloadable operators.
4014#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4015 if (std::strcmp(Spelling, "?")) \
Douglas Gregora4477812010-01-14 16:01:26 +00004016 Results.AddResult(Result(Spelling));
Douglas Gregor86d9a522009-09-21 16:56:56 +00004017#include "clang/Basic/OperatorKinds.def"
4018
4019 // Add any type names visible from the current scope
Douglas Gregor45bcd432010-01-14 03:21:49 +00004020 Results.allowNestedNameSpecifiers();
Douglas Gregor5d2fc402010-01-14 03:27:13 +00004021 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00004022 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4023 CodeCompleter->includeGlobals());
Douglas Gregor86d9a522009-09-21 16:56:56 +00004024
4025 // Add any type specifiers
Douglas Gregorbca403c2010-01-13 23:51:12 +00004026 AddTypeSpecifierResults(getLangOptions(), Results);
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00004027 Results.ExitScope();
Douglas Gregor86d9a522009-09-21 16:56:56 +00004028
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004029 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor8071e422010-08-15 06:18:01 +00004030 CodeCompletionContext::CCC_Type,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004031 Results.data(),Results.size());
Douglas Gregored8d3222009-09-18 20:05:18 +00004032}
Douglas Gregor49f40bd2009-09-18 19:03:04 +00004033
Douglas Gregor0133f522010-08-28 00:00:50 +00004034void Sema::CodeCompleteConstructorInitializer(Decl *ConstructorD,
Sean Huntcbb67482011-01-08 20:30:50 +00004035 CXXCtorInitializer** Initializers,
Douglas Gregor0133f522010-08-28 00:00:50 +00004036 unsigned NumInitializers) {
Douglas Gregor8987b232011-09-27 23:30:47 +00004037 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
Douglas Gregor0133f522010-08-28 00:00:50 +00004038 CXXConstructorDecl *Constructor
4039 = static_cast<CXXConstructorDecl *>(ConstructorD);
4040 if (!Constructor)
4041 return;
4042
Douglas Gregor218937c2011-02-01 19:23:04 +00004043 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00004044 CodeCompletionContext::CCC_PotentiallyQualifiedName);
Douglas Gregor0133f522010-08-28 00:00:50 +00004045 Results.EnterNewScope();
4046
4047 // Fill in any already-initialized fields or base classes.
4048 llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
4049 llvm::SmallPtrSet<CanQualType, 4> InitializedBases;
4050 for (unsigned I = 0; I != NumInitializers; ++I) {
4051 if (Initializers[I]->isBaseInitializer())
4052 InitializedBases.insert(
4053 Context.getCanonicalType(QualType(Initializers[I]->getBaseClass(), 0)));
4054 else
Francois Pichet00eb3f92010-12-04 09:14:42 +00004055 InitializedFields.insert(cast<FieldDecl>(
4056 Initializers[I]->getAnyMember()));
Douglas Gregor0133f522010-08-28 00:00:50 +00004057 }
4058
4059 // Add completions for base classes.
Douglas Gregor218937c2011-02-01 19:23:04 +00004060 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor0c431c82010-08-29 19:27:27 +00004061 bool SawLastInitializer = (NumInitializers == 0);
Douglas Gregor0133f522010-08-28 00:00:50 +00004062 CXXRecordDecl *ClassDecl = Constructor->getParent();
4063 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
4064 BaseEnd = ClassDecl->bases_end();
4065 Base != BaseEnd; ++Base) {
Douglas Gregor0c431c82010-08-29 19:27:27 +00004066 if (!InitializedBases.insert(Context.getCanonicalType(Base->getType()))) {
4067 SawLastInitializer
4068 = NumInitializers > 0 &&
4069 Initializers[NumInitializers - 1]->isBaseInitializer() &&
4070 Context.hasSameUnqualifiedType(Base->getType(),
4071 QualType(Initializers[NumInitializers - 1]->getBaseClass(), 0));
Douglas Gregor0133f522010-08-28 00:00:50 +00004072 continue;
Douglas Gregor0c431c82010-08-29 19:27:27 +00004073 }
Douglas Gregor0133f522010-08-28 00:00:50 +00004074
Douglas Gregor218937c2011-02-01 19:23:04 +00004075 Builder.AddTypedTextChunk(
Douglas Gregordae68752011-02-01 22:57:45 +00004076 Results.getAllocator().CopyString(
John McCallf85e1932011-06-15 23:02:42 +00004077 Base->getType().getAsString(Policy)));
Douglas Gregor218937c2011-02-01 19:23:04 +00004078 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4079 Builder.AddPlaceholderChunk("args");
4080 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4081 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
Douglas Gregor0c431c82010-08-29 19:27:27 +00004082 SawLastInitializer? CCP_NextInitializer
4083 : CCP_MemberDeclaration));
4084 SawLastInitializer = false;
Douglas Gregor0133f522010-08-28 00:00:50 +00004085 }
4086
4087 // Add completions for virtual base classes.
4088 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(),
4089 BaseEnd = ClassDecl->vbases_end();
4090 Base != BaseEnd; ++Base) {
Douglas Gregor0c431c82010-08-29 19:27:27 +00004091 if (!InitializedBases.insert(Context.getCanonicalType(Base->getType()))) {
4092 SawLastInitializer
4093 = NumInitializers > 0 &&
4094 Initializers[NumInitializers - 1]->isBaseInitializer() &&
4095 Context.hasSameUnqualifiedType(Base->getType(),
4096 QualType(Initializers[NumInitializers - 1]->getBaseClass(), 0));
Douglas Gregor0133f522010-08-28 00:00:50 +00004097 continue;
Douglas Gregor0c431c82010-08-29 19:27:27 +00004098 }
Douglas Gregor0133f522010-08-28 00:00:50 +00004099
Douglas Gregor218937c2011-02-01 19:23:04 +00004100 Builder.AddTypedTextChunk(
Douglas Gregordae68752011-02-01 22:57:45 +00004101 Builder.getAllocator().CopyString(
John McCallf85e1932011-06-15 23:02:42 +00004102 Base->getType().getAsString(Policy)));
Douglas Gregor218937c2011-02-01 19:23:04 +00004103 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4104 Builder.AddPlaceholderChunk("args");
4105 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4106 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
Douglas Gregor0c431c82010-08-29 19:27:27 +00004107 SawLastInitializer? CCP_NextInitializer
4108 : CCP_MemberDeclaration));
4109 SawLastInitializer = false;
Douglas Gregor0133f522010-08-28 00:00:50 +00004110 }
4111
4112 // Add completions for members.
4113 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
4114 FieldEnd = ClassDecl->field_end();
4115 Field != FieldEnd; ++Field) {
Douglas Gregor0c431c82010-08-29 19:27:27 +00004116 if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))) {
4117 SawLastInitializer
4118 = NumInitializers > 0 &&
Francois Pichet00eb3f92010-12-04 09:14:42 +00004119 Initializers[NumInitializers - 1]->isAnyMemberInitializer() &&
4120 Initializers[NumInitializers - 1]->getAnyMember() == *Field;
Douglas Gregor0133f522010-08-28 00:00:50 +00004121 continue;
Douglas Gregor0c431c82010-08-29 19:27:27 +00004122 }
Douglas Gregor0133f522010-08-28 00:00:50 +00004123
4124 if (!Field->getDeclName())
4125 continue;
4126
Douglas Gregordae68752011-02-01 22:57:45 +00004127 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00004128 Field->getIdentifier()->getName()));
4129 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4130 Builder.AddPlaceholderChunk("args");
4131 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4132 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
Douglas Gregor0c431c82010-08-29 19:27:27 +00004133 SawLastInitializer? CCP_NextInitializer
Douglas Gregora67e03f2010-09-09 21:42:20 +00004134 : CCP_MemberDeclaration,
4135 CXCursor_MemberRef));
Douglas Gregor0c431c82010-08-29 19:27:27 +00004136 SawLastInitializer = false;
Douglas Gregor0133f522010-08-28 00:00:50 +00004137 }
4138 Results.ExitScope();
4139
Douglas Gregor52779fb2010-09-23 23:01:17 +00004140 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregor0133f522010-08-28 00:00:50 +00004141 Results.data(), Results.size());
4142}
4143
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004144// Macro that expands to @Keyword or Keyword, depending on whether NeedAt is
4145// true or false.
4146#define OBJC_AT_KEYWORD_NAME(NeedAt,Keyword) NeedAt? "@" #Keyword : #Keyword
Douglas Gregorbca403c2010-01-13 23:51:12 +00004147static void AddObjCImplementationResults(const LangOptions &LangOpts,
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004148 ResultBuilder &Results,
4149 bool NeedAt) {
John McCall0a2c5e22010-08-25 06:19:51 +00004150 typedef CodeCompletionResult Result;
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004151 // Since we have an implementation, we can end it.
Douglas Gregora4477812010-01-14 16:01:26 +00004152 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,end)));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004153
Douglas Gregor218937c2011-02-01 19:23:04 +00004154 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004155 if (LangOpts.ObjC2) {
4156 // @dynamic
Douglas Gregor218937c2011-02-01 19:23:04 +00004157 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,dynamic));
4158 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4159 Builder.AddPlaceholderChunk("property");
4160 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004161
4162 // @synthesize
Douglas Gregor218937c2011-02-01 19:23:04 +00004163 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,synthesize));
4164 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4165 Builder.AddPlaceholderChunk("property");
4166 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004167 }
4168}
4169
Douglas Gregorbca403c2010-01-13 23:51:12 +00004170static void AddObjCInterfaceResults(const LangOptions &LangOpts,
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004171 ResultBuilder &Results,
4172 bool NeedAt) {
John McCall0a2c5e22010-08-25 06:19:51 +00004173 typedef CodeCompletionResult Result;
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004174
4175 // Since we have an interface or protocol, we can end it.
Douglas Gregora4477812010-01-14 16:01:26 +00004176 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,end)));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004177
4178 if (LangOpts.ObjC2) {
4179 // @property
Douglas Gregora4477812010-01-14 16:01:26 +00004180 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,property)));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004181
4182 // @required
Douglas Gregora4477812010-01-14 16:01:26 +00004183 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,required)));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004184
4185 // @optional
Douglas Gregora4477812010-01-14 16:01:26 +00004186 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,optional)));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004187 }
4188}
4189
Douglas Gregorbca403c2010-01-13 23:51:12 +00004190static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
John McCall0a2c5e22010-08-25 06:19:51 +00004191 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004192 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004193
4194 // @class name ;
Douglas Gregor218937c2011-02-01 19:23:04 +00004195 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,class));
4196 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4197 Builder.AddPlaceholderChunk("name");
4198 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004199
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004200 if (Results.includeCodePatterns()) {
4201 // @interface name
4202 // FIXME: Could introduce the whole pattern, including superclasses and
4203 // such.
Douglas Gregor218937c2011-02-01 19:23:04 +00004204 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,interface));
4205 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4206 Builder.AddPlaceholderChunk("class");
4207 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004208
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004209 // @protocol name
Douglas Gregor218937c2011-02-01 19:23:04 +00004210 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,protocol));
4211 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4212 Builder.AddPlaceholderChunk("protocol");
4213 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004214
4215 // @implementation name
Douglas Gregor218937c2011-02-01 19:23:04 +00004216 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,implementation));
4217 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4218 Builder.AddPlaceholderChunk("class");
4219 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004220 }
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004221
4222 // @compatibility_alias name
Douglas Gregor218937c2011-02-01 19:23:04 +00004223 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,compatibility_alias));
4224 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4225 Builder.AddPlaceholderChunk("alias");
4226 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4227 Builder.AddPlaceholderChunk("class");
4228 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004229}
4230
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004231void Sema::CodeCompleteObjCAtDirective(Scope *S) {
John McCall0a2c5e22010-08-25 06:19:51 +00004232 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004233 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4234 CodeCompletionContext::CCC_Other);
Douglas Gregorc464ae82009-12-07 09:27:33 +00004235 Results.EnterNewScope();
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004236 if (isa<ObjCImplDecl>(CurContext))
Douglas Gregorbca403c2010-01-13 23:51:12 +00004237 AddObjCImplementationResults(getLangOptions(), Results, false);
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004238 else if (CurContext->isObjCContainer())
Douglas Gregorbca403c2010-01-13 23:51:12 +00004239 AddObjCInterfaceResults(getLangOptions(), Results, false);
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004240 else
Douglas Gregorbca403c2010-01-13 23:51:12 +00004241 AddObjCTopLevelResults(Results, false);
Douglas Gregorc464ae82009-12-07 09:27:33 +00004242 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004243 HandleCodeCompleteResults(this, CodeCompleter,
4244 CodeCompletionContext::CCC_Other,
4245 Results.data(),Results.size());
Douglas Gregorc464ae82009-12-07 09:27:33 +00004246}
4247
Douglas Gregorbca403c2010-01-13 23:51:12 +00004248static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) {
John McCall0a2c5e22010-08-25 06:19:51 +00004249 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004250 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004251
4252 // @encode ( type-name )
Douglas Gregor8ca72082011-10-18 21:20:17 +00004253 const char *EncodeType = "char[]";
4254 if (Results.getSema().getLangOptions().CPlusPlus ||
4255 Results.getSema().getLangOptions().ConstStrings)
4256 EncodeType = " const char[]";
4257 Builder.AddResultTypeChunk(EncodeType);
Douglas Gregor218937c2011-02-01 19:23:04 +00004258 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,encode));
4259 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4260 Builder.AddPlaceholderChunk("type-name");
4261 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4262 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004263
4264 // @protocol ( protocol-name )
Douglas Gregor8ca72082011-10-18 21:20:17 +00004265 Builder.AddResultTypeChunk("Protocol *");
Douglas Gregor218937c2011-02-01 19:23:04 +00004266 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,protocol));
4267 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4268 Builder.AddPlaceholderChunk("protocol-name");
4269 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4270 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004271
4272 // @selector ( selector )
Douglas Gregor8ca72082011-10-18 21:20:17 +00004273 Builder.AddResultTypeChunk("SEL");
Douglas Gregor218937c2011-02-01 19:23:04 +00004274 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,selector));
4275 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4276 Builder.AddPlaceholderChunk("selector");
4277 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4278 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004279}
4280
Douglas Gregorbca403c2010-01-13 23:51:12 +00004281static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) {
John McCall0a2c5e22010-08-25 06:19:51 +00004282 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004283 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004284
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004285 if (Results.includeCodePatterns()) {
4286 // @try { statements } @catch ( declaration ) { statements } @finally
4287 // { statements }
Douglas Gregor218937c2011-02-01 19:23:04 +00004288 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,try));
4289 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4290 Builder.AddPlaceholderChunk("statements");
4291 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4292 Builder.AddTextChunk("@catch");
4293 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4294 Builder.AddPlaceholderChunk("parameter");
4295 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4296 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4297 Builder.AddPlaceholderChunk("statements");
4298 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4299 Builder.AddTextChunk("@finally");
4300 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4301 Builder.AddPlaceholderChunk("statements");
4302 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4303 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004304 }
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004305
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004306 // @throw
Douglas Gregor218937c2011-02-01 19:23:04 +00004307 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,throw));
4308 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4309 Builder.AddPlaceholderChunk("expression");
4310 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004311
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004312 if (Results.includeCodePatterns()) {
4313 // @synchronized ( expression ) { statements }
Douglas Gregor218937c2011-02-01 19:23:04 +00004314 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,synchronized));
4315 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4316 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4317 Builder.AddPlaceholderChunk("expression");
4318 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4319 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4320 Builder.AddPlaceholderChunk("statements");
4321 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4322 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004323 }
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004324}
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004325
Douglas Gregorbca403c2010-01-13 23:51:12 +00004326static void AddObjCVisibilityResults(const LangOptions &LangOpts,
Douglas Gregorc38c3e12010-01-13 21:54:15 +00004327 ResultBuilder &Results,
4328 bool NeedAt) {
John McCall0a2c5e22010-08-25 06:19:51 +00004329 typedef CodeCompletionResult Result;
Douglas Gregora4477812010-01-14 16:01:26 +00004330 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,private)));
4331 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,protected)));
4332 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,public)));
Douglas Gregorc38c3e12010-01-13 21:54:15 +00004333 if (LangOpts.ObjC2)
Douglas Gregora4477812010-01-14 16:01:26 +00004334 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,package)));
Douglas Gregorc38c3e12010-01-13 21:54:15 +00004335}
4336
4337void Sema::CodeCompleteObjCAtVisibility(Scope *S) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004338 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4339 CodeCompletionContext::CCC_Other);
Douglas Gregorc38c3e12010-01-13 21:54:15 +00004340 Results.EnterNewScope();
Douglas Gregorbca403c2010-01-13 23:51:12 +00004341 AddObjCVisibilityResults(getLangOptions(), Results, false);
Douglas Gregorc38c3e12010-01-13 21:54:15 +00004342 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004343 HandleCodeCompleteResults(this, CodeCompleter,
4344 CodeCompletionContext::CCC_Other,
4345 Results.data(),Results.size());
Douglas Gregorc38c3e12010-01-13 21:54:15 +00004346}
4347
4348void Sema::CodeCompleteObjCAtStatement(Scope *S) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004349 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4350 CodeCompletionContext::CCC_Other);
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004351 Results.EnterNewScope();
Douglas Gregorbca403c2010-01-13 23:51:12 +00004352 AddObjCStatementResults(Results, false);
4353 AddObjCExpressionResults(Results, false);
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004354 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004355 HandleCodeCompleteResults(this, CodeCompleter,
4356 CodeCompletionContext::CCC_Other,
4357 Results.data(),Results.size());
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004358}
4359
4360void Sema::CodeCompleteObjCAtExpression(Scope *S) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004361 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4362 CodeCompletionContext::CCC_Other);
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004363 Results.EnterNewScope();
Douglas Gregorbca403c2010-01-13 23:51:12 +00004364 AddObjCExpressionResults(Results, false);
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004365 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004366 HandleCodeCompleteResults(this, CodeCompleter,
4367 CodeCompletionContext::CCC_Other,
4368 Results.data(),Results.size());
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004369}
4370
Douglas Gregor988358f2009-11-19 00:14:45 +00004371/// \brief Determine whether the addition of the given flag to an Objective-C
4372/// property's attributes will cause a conflict.
4373static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) {
4374 // Check if we've already added this flag.
4375 if (Attributes & NewFlag)
4376 return true;
4377
4378 Attributes |= NewFlag;
4379
4380 // Check for collisions with "readonly".
4381 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
4382 (Attributes & (ObjCDeclSpec::DQ_PR_readwrite |
4383 ObjCDeclSpec::DQ_PR_assign |
John McCallf85e1932011-06-15 23:02:42 +00004384 ObjCDeclSpec::DQ_PR_unsafe_unretained |
Douglas Gregor988358f2009-11-19 00:14:45 +00004385 ObjCDeclSpec::DQ_PR_copy |
John McCallf85e1932011-06-15 23:02:42 +00004386 ObjCDeclSpec::DQ_PR_retain |
4387 ObjCDeclSpec::DQ_PR_strong)))
Douglas Gregor988358f2009-11-19 00:14:45 +00004388 return true;
4389
John McCallf85e1932011-06-15 23:02:42 +00004390 // Check for more than one of { assign, copy, retain, strong }.
Douglas Gregor988358f2009-11-19 00:14:45 +00004391 unsigned AssignCopyRetMask = Attributes & (ObjCDeclSpec::DQ_PR_assign |
John McCallf85e1932011-06-15 23:02:42 +00004392 ObjCDeclSpec::DQ_PR_unsafe_unretained |
Douglas Gregor988358f2009-11-19 00:14:45 +00004393 ObjCDeclSpec::DQ_PR_copy |
John McCallf85e1932011-06-15 23:02:42 +00004394 ObjCDeclSpec::DQ_PR_retain|
4395 ObjCDeclSpec::DQ_PR_strong);
Douglas Gregor988358f2009-11-19 00:14:45 +00004396 if (AssignCopyRetMask &&
4397 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign &&
John McCallf85e1932011-06-15 23:02:42 +00004398 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_unsafe_unretained &&
Douglas Gregor988358f2009-11-19 00:14:45 +00004399 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy &&
John McCallf85e1932011-06-15 23:02:42 +00004400 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain &&
4401 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_strong)
Douglas Gregor988358f2009-11-19 00:14:45 +00004402 return true;
4403
4404 return false;
4405}
4406
Douglas Gregora93b1082009-11-18 23:08:07 +00004407void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) {
Steve Naroffece8e712009-10-08 21:55:05 +00004408 if (!CodeCompleter)
4409 return;
Douglas Gregord3c68542009-11-19 01:08:35 +00004410
Steve Naroffece8e712009-10-08 21:55:05 +00004411 unsigned Attributes = ODS.getPropertyAttributes();
4412
John McCall0a2c5e22010-08-25 06:19:51 +00004413 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004414 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4415 CodeCompletionContext::CCC_Other);
Steve Naroffece8e712009-10-08 21:55:05 +00004416 Results.EnterNewScope();
Douglas Gregor988358f2009-11-19 00:14:45 +00004417 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readonly))
John McCall0a2c5e22010-08-25 06:19:51 +00004418 Results.AddResult(CodeCompletionResult("readonly"));
Douglas Gregor988358f2009-11-19 00:14:45 +00004419 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_assign))
John McCall0a2c5e22010-08-25 06:19:51 +00004420 Results.AddResult(CodeCompletionResult("assign"));
John McCallf85e1932011-06-15 23:02:42 +00004421 if (!ObjCPropertyFlagConflicts(Attributes,
4422 ObjCDeclSpec::DQ_PR_unsafe_unretained))
4423 Results.AddResult(CodeCompletionResult("unsafe_unretained"));
Douglas Gregor988358f2009-11-19 00:14:45 +00004424 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readwrite))
John McCall0a2c5e22010-08-25 06:19:51 +00004425 Results.AddResult(CodeCompletionResult("readwrite"));
Douglas Gregor988358f2009-11-19 00:14:45 +00004426 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_retain))
John McCall0a2c5e22010-08-25 06:19:51 +00004427 Results.AddResult(CodeCompletionResult("retain"));
John McCallf85e1932011-06-15 23:02:42 +00004428 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_strong))
4429 Results.AddResult(CodeCompletionResult("strong"));
Douglas Gregor988358f2009-11-19 00:14:45 +00004430 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_copy))
John McCall0a2c5e22010-08-25 06:19:51 +00004431 Results.AddResult(CodeCompletionResult("copy"));
Douglas Gregor988358f2009-11-19 00:14:45 +00004432 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nonatomic))
John McCall0a2c5e22010-08-25 06:19:51 +00004433 Results.AddResult(CodeCompletionResult("nonatomic"));
Fariborz Jahanian27f45232011-06-11 17:14:27 +00004434 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_atomic))
4435 Results.AddResult(CodeCompletionResult("atomic"));
Douglas Gregor988358f2009-11-19 00:14:45 +00004436 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_setter)) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004437 CodeCompletionBuilder Setter(Results.getAllocator());
4438 Setter.AddTypedTextChunk("setter");
4439 Setter.AddTextChunk(" = ");
4440 Setter.AddPlaceholderChunk("method");
4441 Results.AddResult(CodeCompletionResult(Setter.TakeString()));
Douglas Gregor54f01612009-11-19 00:01:57 +00004442 }
Douglas Gregor988358f2009-11-19 00:14:45 +00004443 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_getter)) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004444 CodeCompletionBuilder Getter(Results.getAllocator());
4445 Getter.AddTypedTextChunk("getter");
4446 Getter.AddTextChunk(" = ");
4447 Getter.AddPlaceholderChunk("method");
4448 Results.AddResult(CodeCompletionResult(Getter.TakeString()));
Douglas Gregor54f01612009-11-19 00:01:57 +00004449 }
Steve Naroffece8e712009-10-08 21:55:05 +00004450 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004451 HandleCodeCompleteResults(this, CodeCompleter,
4452 CodeCompletionContext::CCC_Other,
4453 Results.data(),Results.size());
Steve Naroffece8e712009-10-08 21:55:05 +00004454}
Steve Naroffc4df6d22009-11-07 02:08:14 +00004455
Douglas Gregor4ad96852009-11-19 07:41:15 +00004456/// \brief Descripts the kind of Objective-C method that we want to find
4457/// via code completion.
4458enum ObjCMethodKind {
4459 MK_Any, //< Any kind of method, provided it means other specified criteria.
4460 MK_ZeroArgSelector, //< Zero-argument (unary) selector.
4461 MK_OneArgSelector //< One-argument selector.
4462};
4463
Douglas Gregor458433d2010-08-26 15:07:07 +00004464static bool isAcceptableObjCSelector(Selector Sel,
4465 ObjCMethodKind WantKind,
4466 IdentifierInfo **SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004467 unsigned NumSelIdents,
4468 bool AllowSameLength = true) {
Douglas Gregor458433d2010-08-26 15:07:07 +00004469 if (NumSelIdents > Sel.getNumArgs())
4470 return false;
4471
4472 switch (WantKind) {
4473 case MK_Any: break;
4474 case MK_ZeroArgSelector: return Sel.isUnarySelector();
4475 case MK_OneArgSelector: return Sel.getNumArgs() == 1;
4476 }
4477
Douglas Gregorcf544262010-11-17 21:36:08 +00004478 if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs())
4479 return false;
4480
Douglas Gregor458433d2010-08-26 15:07:07 +00004481 for (unsigned I = 0; I != NumSelIdents; ++I)
4482 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I))
4483 return false;
4484
4485 return true;
4486}
4487
Douglas Gregor4ad96852009-11-19 07:41:15 +00004488static bool isAcceptableObjCMethod(ObjCMethodDecl *Method,
4489 ObjCMethodKind WantKind,
4490 IdentifierInfo **SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004491 unsigned NumSelIdents,
4492 bool AllowSameLength = true) {
Douglas Gregor458433d2010-08-26 15:07:07 +00004493 return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004494 NumSelIdents, AllowSameLength);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004495}
Douglas Gregord36adf52010-09-16 16:06:31 +00004496
4497namespace {
4498 /// \brief A set of selectors, which is used to avoid introducing multiple
4499 /// completions with the same selector into the result set.
4500 typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet;
4501}
4502
Douglas Gregor36ecb042009-11-17 23:22:23 +00004503/// \brief Add all of the Objective-C methods in the given Objective-C
4504/// container to the set of results.
4505///
4506/// The container will be a class, protocol, category, or implementation of
4507/// any of the above. This mether will recurse to include methods from
4508/// the superclasses of classes along with their categories, protocols, and
4509/// implementations.
4510///
4511/// \param Container the container in which we'll look to find methods.
4512///
4513/// \param WantInstance whether to add instance methods (only); if false, this
4514/// routine will add factory methods (only).
4515///
4516/// \param CurContext the context in which we're performing the lookup that
4517/// finds methods.
4518///
Douglas Gregorcf544262010-11-17 21:36:08 +00004519/// \param AllowSameLength Whether we allow a method to be added to the list
4520/// when it has the same number of parameters as we have selector identifiers.
4521///
Douglas Gregor36ecb042009-11-17 23:22:23 +00004522/// \param Results the structure into which we'll add results.
4523static void AddObjCMethods(ObjCContainerDecl *Container,
4524 bool WantInstanceMethods,
Douglas Gregor4ad96852009-11-19 07:41:15 +00004525 ObjCMethodKind WantKind,
Douglas Gregord3c68542009-11-19 01:08:35 +00004526 IdentifierInfo **SelIdents,
4527 unsigned NumSelIdents,
Douglas Gregor36ecb042009-11-17 23:22:23 +00004528 DeclContext *CurContext,
Douglas Gregord36adf52010-09-16 16:06:31 +00004529 VisitedSelectorSet &Selectors,
Douglas Gregorcf544262010-11-17 21:36:08 +00004530 bool AllowSameLength,
Douglas Gregor408be5a2010-08-25 01:08:01 +00004531 ResultBuilder &Results,
4532 bool InOriginalClass = true) {
John McCall0a2c5e22010-08-25 06:19:51 +00004533 typedef CodeCompletionResult Result;
Douglas Gregor36ecb042009-11-17 23:22:23 +00004534 for (ObjCContainerDecl::method_iterator M = Container->meth_begin(),
4535 MEnd = Container->meth_end();
4536 M != MEnd; ++M) {
Douglas Gregord3c68542009-11-19 01:08:35 +00004537 if ((*M)->isInstanceMethod() == WantInstanceMethods) {
4538 // Check whether the selector identifiers we've been given are a
4539 // subset of the identifiers for this particular method.
Douglas Gregorcf544262010-11-17 21:36:08 +00004540 if (!isAcceptableObjCMethod(*M, WantKind, SelIdents, NumSelIdents,
4541 AllowSameLength))
Douglas Gregord3c68542009-11-19 01:08:35 +00004542 continue;
Douglas Gregor4ad96852009-11-19 07:41:15 +00004543
Douglas Gregord36adf52010-09-16 16:06:31 +00004544 if (!Selectors.insert((*M)->getSelector()))
4545 continue;
4546
Douglas Gregord3c68542009-11-19 01:08:35 +00004547 Result R = Result(*M, 0);
4548 R.StartParameter = NumSelIdents;
Douglas Gregor4ad96852009-11-19 07:41:15 +00004549 R.AllParametersAreInformative = (WantKind != MK_Any);
Douglas Gregor408be5a2010-08-25 01:08:01 +00004550 if (!InOriginalClass)
4551 R.Priority += CCD_InBaseClass;
Douglas Gregord3c68542009-11-19 01:08:35 +00004552 Results.MaybeAddResult(R, CurContext);
4553 }
Douglas Gregor36ecb042009-11-17 23:22:23 +00004554 }
4555
Douglas Gregore396c7b2010-09-16 15:34:59 +00004556 // Visit the protocols of protocols.
4557 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
Douglas Gregor5e2a1ff2012-01-01 19:29:29 +00004558 if (Protocol->hasDefinition()) {
4559 const ObjCList<ObjCProtocolDecl> &Protocols
4560 = Protocol->getReferencedProtocols();
4561 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
4562 E = Protocols.end();
4563 I != E; ++I)
4564 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents,
4565 NumSelIdents, CurContext, Selectors, AllowSameLength,
4566 Results, false);
4567 }
Douglas Gregore396c7b2010-09-16 15:34:59 +00004568 }
4569
Douglas Gregor36ecb042009-11-17 23:22:23 +00004570 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
Douglas Gregor2e5c15b2011-12-15 05:27:12 +00004571 if (!IFace || !IFace->hasDefinition())
Douglas Gregor36ecb042009-11-17 23:22:23 +00004572 return;
4573
4574 // Add methods in protocols.
4575 const ObjCList<ObjCProtocolDecl> &Protocols= IFace->getReferencedProtocols();
4576 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
4577 E = Protocols.end();
4578 I != E; ++I)
Douglas Gregor4ad96852009-11-19 07:41:15 +00004579 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, NumSelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004580 CurContext, Selectors, AllowSameLength, Results, false);
Douglas Gregor36ecb042009-11-17 23:22:23 +00004581
4582 // Add methods in categories.
4583 for (ObjCCategoryDecl *CatDecl = IFace->getCategoryList(); CatDecl;
4584 CatDecl = CatDecl->getNextClassCategory()) {
Douglas Gregor4ad96852009-11-19 07:41:15 +00004585 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004586 NumSelIdents, CurContext, Selectors, AllowSameLength,
4587 Results, InOriginalClass);
Douglas Gregor36ecb042009-11-17 23:22:23 +00004588
4589 // Add a categories protocol methods.
4590 const ObjCList<ObjCProtocolDecl> &Protocols
4591 = CatDecl->getReferencedProtocols();
4592 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
4593 E = Protocols.end();
4594 I != E; ++I)
Douglas Gregor4ad96852009-11-19 07:41:15 +00004595 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004596 NumSelIdents, CurContext, Selectors, AllowSameLength,
4597 Results, false);
Douglas Gregor36ecb042009-11-17 23:22:23 +00004598
4599 // Add methods in category implementations.
4600 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation())
Douglas Gregor4ad96852009-11-19 07:41:15 +00004601 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004602 NumSelIdents, CurContext, Selectors, AllowSameLength,
4603 Results, InOriginalClass);
Douglas Gregor36ecb042009-11-17 23:22:23 +00004604 }
4605
4606 // Add methods in superclass.
4607 if (IFace->getSuperClass())
Douglas Gregor4ad96852009-11-19 07:41:15 +00004608 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind,
Douglas Gregorcf544262010-11-17 21:36:08 +00004609 SelIdents, NumSelIdents, CurContext, Selectors,
4610 AllowSameLength, Results, false);
Douglas Gregor36ecb042009-11-17 23:22:23 +00004611
4612 // Add methods in our implementation, if any.
4613 if (ObjCImplementationDecl *Impl = IFace->getImplementation())
Douglas Gregor4ad96852009-11-19 07:41:15 +00004614 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004615 NumSelIdents, CurContext, Selectors, AllowSameLength,
4616 Results, InOriginalClass);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004617}
4618
4619
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004620void Sema::CodeCompleteObjCPropertyGetter(Scope *S) {
John McCall0a2c5e22010-08-25 06:19:51 +00004621 typedef CodeCompletionResult Result;
Douglas Gregor4ad96852009-11-19 07:41:15 +00004622
4623 // Try to find the interface where getters might live.
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004624 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004625 if (!Class) {
4626 if (ObjCCategoryDecl *Category
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004627 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
Douglas Gregor4ad96852009-11-19 07:41:15 +00004628 Class = Category->getClassInterface();
4629
4630 if (!Class)
4631 return;
4632 }
4633
4634 // Find all of the potential getters.
Douglas Gregor218937c2011-02-01 19:23:04 +00004635 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4636 CodeCompletionContext::CCC_Other);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004637 Results.EnterNewScope();
4638
Douglas Gregord36adf52010-09-16 16:06:31 +00004639 VisitedSelectorSet Selectors;
4640 AddObjCMethods(Class, true, MK_ZeroArgSelector, 0, 0, CurContext, Selectors,
Douglas Gregorcf544262010-11-17 21:36:08 +00004641 /*AllowSameLength=*/true, Results);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004642 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004643 HandleCodeCompleteResults(this, CodeCompleter,
4644 CodeCompletionContext::CCC_Other,
4645 Results.data(),Results.size());
Douglas Gregor4ad96852009-11-19 07:41:15 +00004646}
4647
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004648void Sema::CodeCompleteObjCPropertySetter(Scope *S) {
John McCall0a2c5e22010-08-25 06:19:51 +00004649 typedef CodeCompletionResult Result;
Douglas Gregor4ad96852009-11-19 07:41:15 +00004650
4651 // Try to find the interface where setters might live.
4652 ObjCInterfaceDecl *Class
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004653 = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004654 if (!Class) {
4655 if (ObjCCategoryDecl *Category
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004656 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
Douglas Gregor4ad96852009-11-19 07:41:15 +00004657 Class = Category->getClassInterface();
4658
4659 if (!Class)
4660 return;
4661 }
4662
4663 // Find all of the potential getters.
Douglas Gregor218937c2011-02-01 19:23:04 +00004664 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4665 CodeCompletionContext::CCC_Other);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004666 Results.EnterNewScope();
4667
Douglas Gregord36adf52010-09-16 16:06:31 +00004668 VisitedSelectorSet Selectors;
4669 AddObjCMethods(Class, true, MK_OneArgSelector, 0, 0, CurContext,
Douglas Gregorcf544262010-11-17 21:36:08 +00004670 Selectors, /*AllowSameLength=*/true, Results);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004671
4672 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004673 HandleCodeCompleteResults(this, CodeCompleter,
4674 CodeCompletionContext::CCC_Other,
4675 Results.data(),Results.size());
Douglas Gregor36ecb042009-11-17 23:22:23 +00004676}
4677
Douglas Gregorafc45782011-02-15 22:19:42 +00004678void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
4679 bool IsParameter) {
John McCall0a2c5e22010-08-25 06:19:51 +00004680 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004681 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4682 CodeCompletionContext::CCC_Type);
Douglas Gregord32b0222010-08-24 01:06:58 +00004683 Results.EnterNewScope();
4684
4685 // Add context-sensitive, Objective-C parameter-passing keywords.
4686 bool AddedInOut = false;
4687 if ((DS.getObjCDeclQualifier() &
4688 (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) {
4689 Results.AddResult("in");
4690 Results.AddResult("inout");
4691 AddedInOut = true;
4692 }
4693 if ((DS.getObjCDeclQualifier() &
4694 (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) {
4695 Results.AddResult("out");
4696 if (!AddedInOut)
4697 Results.AddResult("inout");
4698 }
4699 if ((DS.getObjCDeclQualifier() &
4700 (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref |
4701 ObjCDeclSpec::DQ_Oneway)) == 0) {
4702 Results.AddResult("bycopy");
4703 Results.AddResult("byref");
4704 Results.AddResult("oneway");
4705 }
4706
Douglas Gregorafc45782011-02-15 22:19:42 +00004707 // If we're completing the return type of an Objective-C method and the
4708 // identifier IBAction refers to a macro, provide a completion item for
4709 // an action, e.g.,
4710 // IBAction)<#selector#>:(id)sender
4711 if (DS.getObjCDeclQualifier() == 0 && !IsParameter &&
4712 Context.Idents.get("IBAction").hasMacroDefinition()) {
4713 typedef CodeCompletionString::Chunk Chunk;
4714 CodeCompletionBuilder Builder(Results.getAllocator(), CCP_CodePattern,
4715 CXAvailability_Available);
4716 Builder.AddTypedTextChunk("IBAction");
4717 Builder.AddChunk(Chunk(CodeCompletionString::CK_RightParen));
4718 Builder.AddPlaceholderChunk("selector");
4719 Builder.AddChunk(Chunk(CodeCompletionString::CK_Colon));
4720 Builder.AddChunk(Chunk(CodeCompletionString::CK_LeftParen));
4721 Builder.AddTextChunk("id");
4722 Builder.AddChunk(Chunk(CodeCompletionString::CK_RightParen));
4723 Builder.AddTextChunk("sender");
4724 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
4725 }
4726
Douglas Gregord32b0222010-08-24 01:06:58 +00004727 // Add various builtin type names and specifiers.
4728 AddOrdinaryNameResults(PCC_Type, S, *this, Results);
4729 Results.ExitScope();
4730
4731 // Add the various type names
4732 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
4733 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4734 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4735 CodeCompleter->includeGlobals());
4736
4737 if (CodeCompleter->includeMacros())
4738 AddMacroResults(PP, Results);
4739
4740 HandleCodeCompleteResults(this, CodeCompleter,
4741 CodeCompletionContext::CCC_Type,
4742 Results.data(), Results.size());
4743}
4744
Douglas Gregor22f56992010-04-06 19:22:33 +00004745/// \brief When we have an expression with type "id", we may assume
4746/// that it has some more-specific class type based on knowledge of
4747/// common uses of Objective-C. This routine returns that class type,
4748/// or NULL if no better result could be determined.
4749static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) {
Douglas Gregor78edf512010-09-15 16:23:04 +00004750 ObjCMessageExpr *Msg = dyn_cast_or_null<ObjCMessageExpr>(E);
Douglas Gregor22f56992010-04-06 19:22:33 +00004751 if (!Msg)
4752 return 0;
4753
4754 Selector Sel = Msg->getSelector();
4755 if (Sel.isNull())
4756 return 0;
4757
4758 IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0);
4759 if (!Id)
4760 return 0;
4761
4762 ObjCMethodDecl *Method = Msg->getMethodDecl();
4763 if (!Method)
4764 return 0;
4765
4766 // Determine the class that we're sending the message to.
Douglas Gregor04badcf2010-04-21 00:45:42 +00004767 ObjCInterfaceDecl *IFace = 0;
4768 switch (Msg->getReceiverKind()) {
4769 case ObjCMessageExpr::Class:
John McCallc12c5bb2010-05-15 11:32:37 +00004770 if (const ObjCObjectType *ObjType
4771 = Msg->getClassReceiver()->getAs<ObjCObjectType>())
4772 IFace = ObjType->getInterface();
Douglas Gregor04badcf2010-04-21 00:45:42 +00004773 break;
4774
4775 case ObjCMessageExpr::Instance: {
4776 QualType T = Msg->getInstanceReceiver()->getType();
4777 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
4778 IFace = Ptr->getInterfaceDecl();
4779 break;
4780 }
4781
4782 case ObjCMessageExpr::SuperInstance:
4783 case ObjCMessageExpr::SuperClass:
4784 break;
Douglas Gregor22f56992010-04-06 19:22:33 +00004785 }
4786
4787 if (!IFace)
4788 return 0;
4789
4790 ObjCInterfaceDecl *Super = IFace->getSuperClass();
4791 if (Method->isInstanceMethod())
4792 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
4793 .Case("retain", IFace)
John McCallf85e1932011-06-15 23:02:42 +00004794 .Case("strong", IFace)
Douglas Gregor22f56992010-04-06 19:22:33 +00004795 .Case("autorelease", IFace)
4796 .Case("copy", IFace)
4797 .Case("copyWithZone", IFace)
4798 .Case("mutableCopy", IFace)
4799 .Case("mutableCopyWithZone", IFace)
4800 .Case("awakeFromCoder", IFace)
4801 .Case("replacementObjectFromCoder", IFace)
4802 .Case("class", IFace)
4803 .Case("classForCoder", IFace)
4804 .Case("superclass", Super)
4805 .Default(0);
4806
4807 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
4808 .Case("new", IFace)
4809 .Case("alloc", IFace)
4810 .Case("allocWithZone", IFace)
4811 .Case("class", IFace)
4812 .Case("superclass", Super)
4813 .Default(0);
4814}
4815
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004816// Add a special completion for a message send to "super", which fills in the
4817// most likely case of forwarding all of our arguments to the superclass
4818// function.
4819///
4820/// \param S The semantic analysis object.
4821///
4822/// \param S NeedSuperKeyword Whether we need to prefix this completion with
4823/// the "super" keyword. Otherwise, we just need to provide the arguments.
4824///
4825/// \param SelIdents The identifiers in the selector that have already been
4826/// provided as arguments for a send to "super".
4827///
4828/// \param NumSelIdents The number of identifiers in \p SelIdents.
4829///
4830/// \param Results The set of results to augment.
4831///
4832/// \returns the Objective-C method declaration that would be invoked by
4833/// this "super" completion. If NULL, no completion was added.
4834static ObjCMethodDecl *AddSuperSendCompletion(Sema &S, bool NeedSuperKeyword,
4835 IdentifierInfo **SelIdents,
4836 unsigned NumSelIdents,
4837 ResultBuilder &Results) {
4838 ObjCMethodDecl *CurMethod = S.getCurMethodDecl();
4839 if (!CurMethod)
4840 return 0;
4841
4842 ObjCInterfaceDecl *Class = CurMethod->getClassInterface();
4843 if (!Class)
4844 return 0;
4845
4846 // Try to find a superclass method with the same selector.
4847 ObjCMethodDecl *SuperMethod = 0;
Douglas Gregor78bcd912011-02-16 00:51:18 +00004848 while ((Class = Class->getSuperClass()) && !SuperMethod) {
4849 // Check in the class
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004850 SuperMethod = Class->getMethod(CurMethod->getSelector(),
4851 CurMethod->isInstanceMethod());
4852
Douglas Gregor78bcd912011-02-16 00:51:18 +00004853 // Check in categories or class extensions.
4854 if (!SuperMethod) {
4855 for (ObjCCategoryDecl *Category = Class->getCategoryList(); Category;
4856 Category = Category->getNextClassCategory())
4857 if ((SuperMethod = Category->getMethod(CurMethod->getSelector(),
4858 CurMethod->isInstanceMethod())))
4859 break;
4860 }
4861 }
4862
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004863 if (!SuperMethod)
4864 return 0;
4865
4866 // Check whether the superclass method has the same signature.
4867 if (CurMethod->param_size() != SuperMethod->param_size() ||
4868 CurMethod->isVariadic() != SuperMethod->isVariadic())
4869 return 0;
4870
4871 for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(),
4872 CurPEnd = CurMethod->param_end(),
4873 SuperP = SuperMethod->param_begin();
4874 CurP != CurPEnd; ++CurP, ++SuperP) {
4875 // Make sure the parameter types are compatible.
4876 if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(),
4877 (*SuperP)->getType()))
4878 return 0;
4879
4880 // Make sure we have a parameter name to forward!
4881 if (!(*CurP)->getIdentifier())
4882 return 0;
4883 }
4884
4885 // We have a superclass method. Now, form the send-to-super completion.
Douglas Gregor218937c2011-02-01 19:23:04 +00004886 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004887
4888 // Give this completion a return type.
Douglas Gregor8987b232011-09-27 23:30:47 +00004889 AddResultTypeChunk(S.Context, getCompletionPrintingPolicy(S), SuperMethod,
4890 Builder);
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004891
4892 // If we need the "super" keyword, add it (plus some spacing).
4893 if (NeedSuperKeyword) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004894 Builder.AddTypedTextChunk("super");
4895 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004896 }
4897
4898 Selector Sel = CurMethod->getSelector();
4899 if (Sel.isUnarySelector()) {
4900 if (NeedSuperKeyword)
Douglas Gregordae68752011-02-01 22:57:45 +00004901 Builder.AddTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00004902 Sel.getNameForSlot(0)));
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004903 else
Douglas Gregordae68752011-02-01 22:57:45 +00004904 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00004905 Sel.getNameForSlot(0)));
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004906 } else {
4907 ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin();
4908 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) {
4909 if (I > NumSelIdents)
Douglas Gregor218937c2011-02-01 19:23:04 +00004910 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004911
4912 if (I < NumSelIdents)
Douglas Gregor218937c2011-02-01 19:23:04 +00004913 Builder.AddInformativeChunk(
Douglas Gregordae68752011-02-01 22:57:45 +00004914 Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00004915 Sel.getNameForSlot(I) + ":"));
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004916 else if (NeedSuperKeyword || I > NumSelIdents) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004917 Builder.AddTextChunk(
Douglas Gregordae68752011-02-01 22:57:45 +00004918 Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00004919 Sel.getNameForSlot(I) + ":"));
Douglas Gregordae68752011-02-01 22:57:45 +00004920 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00004921 (*CurP)->getIdentifier()->getName()));
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004922 } else {
Douglas Gregor218937c2011-02-01 19:23:04 +00004923 Builder.AddTypedTextChunk(
Douglas Gregordae68752011-02-01 22:57:45 +00004924 Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00004925 Sel.getNameForSlot(I) + ":"));
Douglas Gregordae68752011-02-01 22:57:45 +00004926 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00004927 (*CurP)->getIdentifier()->getName()));
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004928 }
4929 }
4930 }
4931
Douglas Gregor218937c2011-02-01 19:23:04 +00004932 Results.AddResult(CodeCompletionResult(Builder.TakeString(), CCP_SuperCompletion,
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004933 SuperMethod->isInstanceMethod()
4934 ? CXCursor_ObjCInstanceMethodDecl
4935 : CXCursor_ObjCClassMethodDecl));
4936 return SuperMethod;
4937}
4938
Douglas Gregor8e254cf2010-05-27 23:06:34 +00004939void Sema::CodeCompleteObjCMessageReceiver(Scope *S) {
John McCall0a2c5e22010-08-25 06:19:51 +00004940 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004941 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4942 CodeCompletionContext::CCC_ObjCMessageReceiver,
Douglas Gregor52779fb2010-09-23 23:01:17 +00004943 &ResultBuilder::IsObjCMessageReceiver);
Douglas Gregor8e254cf2010-05-27 23:06:34 +00004944
Douglas Gregor8e254cf2010-05-27 23:06:34 +00004945 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4946 Results.EnterNewScope();
Douglas Gregor8071e422010-08-15 06:18:01 +00004947 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4948 CodeCompleter->includeGlobals());
Douglas Gregor8e254cf2010-05-27 23:06:34 +00004949
4950 // If we are in an Objective-C method inside a class that has a superclass,
4951 // add "super" as an option.
4952 if (ObjCMethodDecl *Method = getCurMethodDecl())
4953 if (ObjCInterfaceDecl *Iface = Method->getClassInterface())
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004954 if (Iface->getSuperClass()) {
Douglas Gregor8e254cf2010-05-27 23:06:34 +00004955 Results.AddResult(Result("super"));
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004956
4957 AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, 0, 0, Results);
4958 }
Douglas Gregor8e254cf2010-05-27 23:06:34 +00004959
4960 Results.ExitScope();
4961
4962 if (CodeCompleter->includeMacros())
4963 AddMacroResults(PP, Results);
Douglas Gregorcee9ff12010-09-20 22:39:41 +00004964 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004965 Results.data(), Results.size());
Douglas Gregor8e254cf2010-05-27 23:06:34 +00004966
4967}
4968
Douglas Gregor2725ca82010-04-21 19:57:20 +00004969void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
4970 IdentifierInfo **SelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00004971 unsigned NumSelIdents,
4972 bool AtArgumentExpression) {
Douglas Gregor2725ca82010-04-21 19:57:20 +00004973 ObjCInterfaceDecl *CDecl = 0;
4974 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
4975 // Figure out which interface we're in.
4976 CDecl = CurMethod->getClassInterface();
4977 if (!CDecl)
4978 return;
4979
4980 // Find the superclass of this class.
4981 CDecl = CDecl->getSuperClass();
4982 if (!CDecl)
4983 return;
4984
4985 if (CurMethod->isInstanceMethod()) {
4986 // We are inside an instance method, which means that the message
4987 // send [super ...] is actually calling an instance method on the
Douglas Gregor6b0656a2010-10-13 21:24:53 +00004988 // current object.
4989 return CodeCompleteObjCInstanceMessage(S, 0,
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004990 SelIdents, NumSelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00004991 AtArgumentExpression,
Douglas Gregor6b0656a2010-10-13 21:24:53 +00004992 CDecl);
Douglas Gregor2725ca82010-04-21 19:57:20 +00004993 }
4994
4995 // Fall through to send to the superclass in CDecl.
4996 } else {
4997 // "super" may be the name of a type or variable. Figure out which
4998 // it is.
4999 IdentifierInfo *Super = &Context.Idents.get("super");
5000 NamedDecl *ND = LookupSingleName(S, Super, SuperLoc,
5001 LookupOrdinaryName);
5002 if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) {
5003 // "super" names an interface. Use it.
5004 } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) {
John McCallc12c5bb2010-05-15 11:32:37 +00005005 if (const ObjCObjectType *Iface
5006 = Context.getTypeDeclType(TD)->getAs<ObjCObjectType>())
5007 CDecl = Iface->getInterface();
Douglas Gregor2725ca82010-04-21 19:57:20 +00005008 } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) {
5009 // "super" names an unresolved type; we can't be more specific.
5010 } else {
5011 // Assume that "super" names some kind of value and parse that way.
5012 CXXScopeSpec SS;
5013 UnqualifiedId id;
5014 id.setIdentifier(Super, SuperLoc);
John McCall60d7b3a2010-08-24 06:29:42 +00005015 ExprResult SuperExpr = ActOnIdExpression(S, SS, id, false, false);
Douglas Gregor2725ca82010-04-21 19:57:20 +00005016 return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005017 SelIdents, NumSelIdents,
5018 AtArgumentExpression);
Douglas Gregor2725ca82010-04-21 19:57:20 +00005019 }
5020
5021 // Fall through
5022 }
5023
John McCallb3d87482010-08-24 05:47:05 +00005024 ParsedType Receiver;
Douglas Gregor2725ca82010-04-21 19:57:20 +00005025 if (CDecl)
John McCallb3d87482010-08-24 05:47:05 +00005026 Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl));
Douglas Gregor2725ca82010-04-21 19:57:20 +00005027 return CodeCompleteObjCClassMessage(S, Receiver, SelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005028 NumSelIdents, AtArgumentExpression,
5029 /*IsSuper=*/true);
Douglas Gregor2725ca82010-04-21 19:57:20 +00005030}
5031
Douglas Gregorb9d77572010-09-21 00:03:25 +00005032/// \brief Given a set of code-completion results for the argument of a message
5033/// send, determine the preferred type (if any) for that argument expression.
5034static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
5035 unsigned NumSelIdents) {
5036 typedef CodeCompletionResult Result;
5037 ASTContext &Context = Results.getSema().Context;
5038
5039 QualType PreferredType;
5040 unsigned BestPriority = CCP_Unlikely * 2;
5041 Result *ResultsData = Results.data();
5042 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
5043 Result &R = ResultsData[I];
5044 if (R.Kind == Result::RK_Declaration &&
5045 isa<ObjCMethodDecl>(R.Declaration)) {
5046 if (R.Priority <= BestPriority) {
5047 ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration);
5048 if (NumSelIdents <= Method->param_size()) {
5049 QualType MyPreferredType = Method->param_begin()[NumSelIdents - 1]
5050 ->getType();
5051 if (R.Priority < BestPriority || PreferredType.isNull()) {
5052 BestPriority = R.Priority;
5053 PreferredType = MyPreferredType;
5054 } else if (!Context.hasSameUnqualifiedType(PreferredType,
5055 MyPreferredType)) {
5056 PreferredType = QualType();
5057 }
5058 }
5059 }
5060 }
5061 }
5062
5063 return PreferredType;
5064}
5065
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005066static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
5067 ParsedType Receiver,
5068 IdentifierInfo **SelIdents,
5069 unsigned NumSelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005070 bool AtArgumentExpression,
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005071 bool IsSuper,
5072 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00005073 typedef CodeCompletionResult Result;
Douglas Gregor24a069f2009-11-17 17:59:40 +00005074 ObjCInterfaceDecl *CDecl = 0;
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005075
Douglas Gregor24a069f2009-11-17 17:59:40 +00005076 // If the given name refers to an interface type, retrieve the
5077 // corresponding declaration.
Douglas Gregor2725ca82010-04-21 19:57:20 +00005078 if (Receiver) {
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005079 QualType T = SemaRef.GetTypeFromParser(Receiver, 0);
Douglas Gregor2725ca82010-04-21 19:57:20 +00005080 if (!T.isNull())
John McCallc12c5bb2010-05-15 11:32:37 +00005081 if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>())
5082 CDecl = Interface->getInterface();
Douglas Gregor24a069f2009-11-17 17:59:40 +00005083 }
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005084
Douglas Gregor36ecb042009-11-17 23:22:23 +00005085 // Add all of the factory methods in this Objective-C class, its protocols,
5086 // superclasses, categories, implementation, etc.
Steve Naroffc4df6d22009-11-07 02:08:14 +00005087 Results.EnterNewScope();
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005088
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005089 // If this is a send-to-super, try to add the special "super" send
5090 // completion.
5091 if (IsSuper) {
5092 if (ObjCMethodDecl *SuperMethod
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005093 = AddSuperSendCompletion(SemaRef, false, SelIdents, NumSelIdents,
5094 Results))
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005095 Results.Ignore(SuperMethod);
5096 }
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005097
Douglas Gregor265f7492010-08-27 15:29:55 +00005098 // If we're inside an Objective-C method definition, prefer its selector to
5099 // others.
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005100 if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl())
Douglas Gregor265f7492010-08-27 15:29:55 +00005101 Results.setPreferredSelector(CurMethod->getSelector());
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005102
Douglas Gregord36adf52010-09-16 16:06:31 +00005103 VisitedSelectorSet Selectors;
Douglas Gregor13438f92010-04-06 16:40:00 +00005104 if (CDecl)
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005105 AddObjCMethods(CDecl, false, MK_Any, SelIdents, NumSelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00005106 SemaRef.CurContext, Selectors, AtArgumentExpression,
5107 Results);
Douglas Gregor2725ca82010-04-21 19:57:20 +00005108 else {
Douglas Gregor13438f92010-04-06 16:40:00 +00005109 // We're messaging "id" as a type; provide all class/factory methods.
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005110
Douglas Gregor719770d2010-04-06 17:30:22 +00005111 // If we have an external source, load the entire class method
Sebastian Redl3c7f4132010-08-18 23:57:06 +00005112 // pool from the AST file.
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005113 if (SemaRef.ExternalSource) {
5114 for (uint32_t I = 0,
5115 N = SemaRef.ExternalSource->GetNumExternalSelectors();
John McCall76bd1f32010-06-01 09:23:16 +00005116 I != N; ++I) {
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005117 Selector Sel = SemaRef.ExternalSource->GetExternalSelector(I);
5118 if (Sel.isNull() || SemaRef.MethodPool.count(Sel))
Douglas Gregor719770d2010-04-06 17:30:22 +00005119 continue;
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005120
5121 SemaRef.ReadMethodPool(Sel);
Douglas Gregor719770d2010-04-06 17:30:22 +00005122 }
5123 }
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005124
5125 for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(),
5126 MEnd = SemaRef.MethodPool.end();
Sebastian Redldb9d2142010-08-02 23:18:59 +00005127 M != MEnd; ++M) {
5128 for (ObjCMethodList *MethList = &M->second.second;
5129 MethList && MethList->Method;
Douglas Gregor13438f92010-04-06 16:40:00 +00005130 MethList = MethList->Next) {
5131 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents,
5132 NumSelIdents))
5133 continue;
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005134
Douglas Gregor13438f92010-04-06 16:40:00 +00005135 Result R(MethList->Method, 0);
5136 R.StartParameter = NumSelIdents;
5137 R.AllParametersAreInformative = false;
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005138 Results.MaybeAddResult(R, SemaRef.CurContext);
Douglas Gregor13438f92010-04-06 16:40:00 +00005139 }
5140 }
5141 }
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005142
5143 Results.ExitScope();
5144}
Douglas Gregor13438f92010-04-06 16:40:00 +00005145
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005146void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
5147 IdentifierInfo **SelIdents,
5148 unsigned NumSelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005149 bool AtArgumentExpression,
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005150 bool IsSuper) {
Douglas Gregore081a612011-07-21 01:05:26 +00005151
5152 QualType T = this->GetTypeFromParser(Receiver);
5153
Douglas Gregor218937c2011-02-01 19:23:04 +00005154 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregore081a612011-07-21 01:05:26 +00005155 CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage,
Douglas Gregor0a47d692011-07-26 15:24:30 +00005156 T, SelIdents, NumSelIdents));
Douglas Gregore081a612011-07-21 01:05:26 +00005157
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005158 AddClassMessageCompletions(*this, S, Receiver, SelIdents, NumSelIdents,
5159 AtArgumentExpression, IsSuper, Results);
Douglas Gregorb9d77572010-09-21 00:03:25 +00005160
5161 // If we're actually at the argument expression (rather than prior to the
5162 // selector), we're actually performing code completion for an expression.
5163 // Determine whether we have a single, best method. If so, we can
5164 // code-complete the expression using the corresponding parameter type as
5165 // our preferred type, improving completion results.
5166 if (AtArgumentExpression) {
5167 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
Douglas Gregore081a612011-07-21 01:05:26 +00005168 NumSelIdents);
Douglas Gregorb9d77572010-09-21 00:03:25 +00005169 if (PreferredType.isNull())
5170 CodeCompleteOrdinaryName(S, PCC_Expression);
5171 else
5172 CodeCompleteExpression(S, PreferredType);
5173 return;
5174 }
5175
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005176 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregore081a612011-07-21 01:05:26 +00005177 Results.getCompletionContext(),
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005178 Results.data(), Results.size());
Steve Naroffc4df6d22009-11-07 02:08:14 +00005179}
5180
Richard Trieuf81e5a92011-09-09 02:00:50 +00005181void Sema::CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
Douglas Gregord3c68542009-11-19 01:08:35 +00005182 IdentifierInfo **SelIdents,
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005183 unsigned NumSelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005184 bool AtArgumentExpression,
Douglas Gregor6b0656a2010-10-13 21:24:53 +00005185 ObjCInterfaceDecl *Super) {
John McCall0a2c5e22010-08-25 06:19:51 +00005186 typedef CodeCompletionResult Result;
Steve Naroffc4df6d22009-11-07 02:08:14 +00005187
5188 Expr *RecExpr = static_cast<Expr *>(Receiver);
Steve Naroffc4df6d22009-11-07 02:08:14 +00005189
Douglas Gregor36ecb042009-11-17 23:22:23 +00005190 // If necessary, apply function/array conversion to the receiver.
5191 // C99 6.7.5.3p[7,8].
John Wiegley429bb272011-04-08 18:41:53 +00005192 if (RecExpr) {
5193 ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr);
5194 if (Conv.isInvalid()) // conversion failed. bail.
5195 return;
5196 RecExpr = Conv.take();
5197 }
Douglas Gregor6b0656a2010-10-13 21:24:53 +00005198 QualType ReceiverType = RecExpr? RecExpr->getType()
5199 : Super? Context.getObjCObjectPointerType(
5200 Context.getObjCInterfaceType(Super))
5201 : Context.getObjCIdType();
Steve Naroffc4df6d22009-11-07 02:08:14 +00005202
Douglas Gregorda892642010-11-08 21:12:30 +00005203 // If we're messaging an expression with type "id" or "Class", check
5204 // whether we know something special about the receiver that allows
5205 // us to assume a more-specific receiver type.
5206 if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType())
5207 if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) {
5208 if (ReceiverType->isObjCClassType())
5209 return CodeCompleteObjCClassMessage(S,
5210 ParsedType::make(Context.getObjCInterfaceType(IFace)),
5211 SelIdents, NumSelIdents,
5212 AtArgumentExpression, Super);
5213
5214 ReceiverType = Context.getObjCObjectPointerType(
5215 Context.getObjCInterfaceType(IFace));
5216 }
5217
Douglas Gregor36ecb042009-11-17 23:22:23 +00005218 // Build the set of methods we can see.
Douglas Gregor218937c2011-02-01 19:23:04 +00005219 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregore081a612011-07-21 01:05:26 +00005220 CodeCompletionContext(CodeCompletionContext::CCC_ObjCInstanceMessage,
Douglas Gregor0a47d692011-07-26 15:24:30 +00005221 ReceiverType, SelIdents, NumSelIdents));
Douglas Gregore081a612011-07-21 01:05:26 +00005222
Douglas Gregor36ecb042009-11-17 23:22:23 +00005223 Results.EnterNewScope();
Douglas Gregor22f56992010-04-06 19:22:33 +00005224
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005225 // If this is a send-to-super, try to add the special "super" send
5226 // completion.
Douglas Gregor6b0656a2010-10-13 21:24:53 +00005227 if (Super) {
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005228 if (ObjCMethodDecl *SuperMethod
5229 = AddSuperSendCompletion(*this, false, SelIdents, NumSelIdents,
5230 Results))
5231 Results.Ignore(SuperMethod);
5232 }
5233
Douglas Gregor265f7492010-08-27 15:29:55 +00005234 // If we're inside an Objective-C method definition, prefer its selector to
5235 // others.
5236 if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
5237 Results.setPreferredSelector(CurMethod->getSelector());
Douglas Gregor36ecb042009-11-17 23:22:23 +00005238
Douglas Gregord36adf52010-09-16 16:06:31 +00005239 // Keep track of the selectors we've already added.
5240 VisitedSelectorSet Selectors;
5241
Douglas Gregorf74a4192009-11-18 00:06:18 +00005242 // Handle messages to Class. This really isn't a message to an instance
5243 // method, so we treat it the same way we would treat a message send to a
5244 // class method.
5245 if (ReceiverType->isObjCClassType() ||
5246 ReceiverType->isObjCQualifiedClassType()) {
5247 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5248 if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface())
Douglas Gregor4ad96852009-11-19 07:41:15 +00005249 AddObjCMethods(ClassDecl, false, MK_Any, SelIdents, NumSelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00005250 CurContext, Selectors, AtArgumentExpression, Results);
Douglas Gregorf74a4192009-11-18 00:06:18 +00005251 }
5252 }
5253 // Handle messages to a qualified ID ("id<foo>").
5254 else if (const ObjCObjectPointerType *QualID
5255 = ReceiverType->getAsObjCQualifiedIdType()) {
5256 // Search protocols for instance methods.
5257 for (ObjCObjectPointerType::qual_iterator I = QualID->qual_begin(),
5258 E = QualID->qual_end();
5259 I != E; ++I)
Douglas Gregor4ad96852009-11-19 07:41:15 +00005260 AddObjCMethods(*I, true, MK_Any, SelIdents, NumSelIdents, CurContext,
Douglas Gregorcf544262010-11-17 21:36:08 +00005261 Selectors, AtArgumentExpression, Results);
Douglas Gregorf74a4192009-11-18 00:06:18 +00005262 }
5263 // Handle messages to a pointer to interface type.
5264 else if (const ObjCObjectPointerType *IFacePtr
5265 = ReceiverType->getAsObjCInterfacePointerType()) {
5266 // Search the class, its superclasses, etc., for instance methods.
Douglas Gregor4ad96852009-11-19 07:41:15 +00005267 AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00005268 NumSelIdents, CurContext, Selectors, AtArgumentExpression,
5269 Results);
Douglas Gregorf74a4192009-11-18 00:06:18 +00005270
5271 // Search protocols for instance methods.
5272 for (ObjCObjectPointerType::qual_iterator I = IFacePtr->qual_begin(),
5273 E = IFacePtr->qual_end();
5274 I != E; ++I)
Douglas Gregor4ad96852009-11-19 07:41:15 +00005275 AddObjCMethods(*I, true, MK_Any, SelIdents, NumSelIdents, CurContext,
Douglas Gregorcf544262010-11-17 21:36:08 +00005276 Selectors, AtArgumentExpression, Results);
Douglas Gregorf74a4192009-11-18 00:06:18 +00005277 }
Douglas Gregor13438f92010-04-06 16:40:00 +00005278 // Handle messages to "id".
5279 else if (ReceiverType->isObjCIdType()) {
Douglas Gregor719770d2010-04-06 17:30:22 +00005280 // We're messaging "id", so provide all instance methods we know
5281 // about as code-completion results.
5282
5283 // If we have an external source, load the entire class method
Sebastian Redl3c7f4132010-08-18 23:57:06 +00005284 // pool from the AST file.
Douglas Gregor719770d2010-04-06 17:30:22 +00005285 if (ExternalSource) {
John McCall76bd1f32010-06-01 09:23:16 +00005286 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
5287 I != N; ++I) {
5288 Selector Sel = ExternalSource->GetExternalSelector(I);
Sebastian Redldb9d2142010-08-02 23:18:59 +00005289 if (Sel.isNull() || MethodPool.count(Sel))
Douglas Gregor719770d2010-04-06 17:30:22 +00005290 continue;
5291
Sebastian Redldb9d2142010-08-02 23:18:59 +00005292 ReadMethodPool(Sel);
Douglas Gregor719770d2010-04-06 17:30:22 +00005293 }
5294 }
5295
Sebastian Redldb9d2142010-08-02 23:18:59 +00005296 for (GlobalMethodPool::iterator M = MethodPool.begin(),
5297 MEnd = MethodPool.end();
5298 M != MEnd; ++M) {
5299 for (ObjCMethodList *MethList = &M->second.first;
5300 MethList && MethList->Method;
Douglas Gregor13438f92010-04-06 16:40:00 +00005301 MethList = MethList->Next) {
5302 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents,
5303 NumSelIdents))
5304 continue;
Douglas Gregord36adf52010-09-16 16:06:31 +00005305
5306 if (!Selectors.insert(MethList->Method->getSelector()))
5307 continue;
5308
Douglas Gregor13438f92010-04-06 16:40:00 +00005309 Result R(MethList->Method, 0);
5310 R.StartParameter = NumSelIdents;
5311 R.AllParametersAreInformative = false;
5312 Results.MaybeAddResult(R, CurContext);
5313 }
5314 }
5315 }
Steve Naroffc4df6d22009-11-07 02:08:14 +00005316 Results.ExitScope();
Douglas Gregorb9d77572010-09-21 00:03:25 +00005317
5318
5319 // If we're actually at the argument expression (rather than prior to the
5320 // selector), we're actually performing code completion for an expression.
5321 // Determine whether we have a single, best method. If so, we can
5322 // code-complete the expression using the corresponding parameter type as
5323 // our preferred type, improving completion results.
5324 if (AtArgumentExpression) {
5325 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
5326 NumSelIdents);
5327 if (PreferredType.isNull())
5328 CodeCompleteOrdinaryName(S, PCC_Expression);
5329 else
5330 CodeCompleteExpression(S, PreferredType);
5331 return;
5332 }
5333
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005334 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregore081a612011-07-21 01:05:26 +00005335 Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005336 Results.data(),Results.size());
Steve Naroffc4df6d22009-11-07 02:08:14 +00005337}
Douglas Gregor55385fe2009-11-18 04:19:12 +00005338
Douglas Gregorfb629412010-08-23 21:17:50 +00005339void Sema::CodeCompleteObjCForCollection(Scope *S,
5340 DeclGroupPtrTy IterationVar) {
5341 CodeCompleteExpressionData Data;
5342 Data.ObjCCollection = true;
5343
5344 if (IterationVar.getAsOpaquePtr()) {
5345 DeclGroupRef DG = IterationVar.getAsVal<DeclGroupRef>();
5346 for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) {
5347 if (*I)
5348 Data.IgnoreDecls.push_back(*I);
5349 }
5350 }
5351
5352 CodeCompleteExpression(S, Data);
5353}
5354
Douglas Gregor458433d2010-08-26 15:07:07 +00005355void Sema::CodeCompleteObjCSelector(Scope *S, IdentifierInfo **SelIdents,
5356 unsigned NumSelIdents) {
5357 // If we have an external source, load the entire class method
5358 // pool from the AST file.
5359 if (ExternalSource) {
5360 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
5361 I != N; ++I) {
5362 Selector Sel = ExternalSource->GetExternalSelector(I);
5363 if (Sel.isNull() || MethodPool.count(Sel))
5364 continue;
5365
5366 ReadMethodPool(Sel);
5367 }
5368 }
5369
Douglas Gregor218937c2011-02-01 19:23:04 +00005370 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5371 CodeCompletionContext::CCC_SelectorName);
Douglas Gregor458433d2010-08-26 15:07:07 +00005372 Results.EnterNewScope();
5373 for (GlobalMethodPool::iterator M = MethodPool.begin(),
5374 MEnd = MethodPool.end();
5375 M != MEnd; ++M) {
5376
5377 Selector Sel = M->first;
5378 if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents, NumSelIdents))
5379 continue;
5380
Douglas Gregor218937c2011-02-01 19:23:04 +00005381 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor458433d2010-08-26 15:07:07 +00005382 if (Sel.isUnarySelector()) {
Douglas Gregordae68752011-02-01 22:57:45 +00005383 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00005384 Sel.getNameForSlot(0)));
Douglas Gregor218937c2011-02-01 19:23:04 +00005385 Results.AddResult(Builder.TakeString());
Douglas Gregor458433d2010-08-26 15:07:07 +00005386 continue;
5387 }
5388
Douglas Gregor2d9e21f2010-08-26 16:46:39 +00005389 std::string Accumulator;
Douglas Gregor458433d2010-08-26 15:07:07 +00005390 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) {
Douglas Gregor2d9e21f2010-08-26 16:46:39 +00005391 if (I == NumSelIdents) {
5392 if (!Accumulator.empty()) {
Douglas Gregordae68752011-02-01 22:57:45 +00005393 Builder.AddInformativeChunk(Builder.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00005394 Accumulator));
Douglas Gregor2d9e21f2010-08-26 16:46:39 +00005395 Accumulator.clear();
5396 }
5397 }
5398
Benjamin Kramera0651c52011-07-26 16:59:25 +00005399 Accumulator += Sel.getNameForSlot(I);
Douglas Gregor2d9e21f2010-08-26 16:46:39 +00005400 Accumulator += ':';
Douglas Gregor458433d2010-08-26 15:07:07 +00005401 }
Douglas Gregordae68752011-02-01 22:57:45 +00005402 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString( Accumulator));
Douglas Gregor218937c2011-02-01 19:23:04 +00005403 Results.AddResult(Builder.TakeString());
Douglas Gregor458433d2010-08-26 15:07:07 +00005404 }
5405 Results.ExitScope();
5406
5407 HandleCodeCompleteResults(this, CodeCompleter,
5408 CodeCompletionContext::CCC_SelectorName,
5409 Results.data(), Results.size());
5410}
5411
Douglas Gregor55385fe2009-11-18 04:19:12 +00005412/// \brief Add all of the protocol declarations that we find in the given
5413/// (translation unit) context.
5414static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext,
Douglas Gregor083128f2009-11-18 04:49:41 +00005415 bool OnlyForwardDeclarations,
Douglas Gregor55385fe2009-11-18 04:19:12 +00005416 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00005417 typedef CodeCompletionResult Result;
Douglas Gregor55385fe2009-11-18 04:19:12 +00005418
5419 for (DeclContext::decl_iterator D = Ctx->decls_begin(),
5420 DEnd = Ctx->decls_end();
5421 D != DEnd; ++D) {
5422 // Record any protocols we find.
5423 if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(*D))
Douglas Gregor5e2a1ff2012-01-01 19:29:29 +00005424 if (!OnlyForwardDeclarations || !Proto->hasDefinition())
Douglas Gregor608300b2010-01-14 16:14:35 +00005425 Results.AddResult(Result(Proto, 0), CurContext, 0, false);
Douglas Gregor55385fe2009-11-18 04:19:12 +00005426 }
5427}
5428
5429void Sema::CodeCompleteObjCProtocolReferences(IdentifierLocPair *Protocols,
5430 unsigned NumProtocols) {
Douglas Gregor218937c2011-02-01 19:23:04 +00005431 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5432 CodeCompletionContext::CCC_ObjCProtocolName);
Douglas Gregor55385fe2009-11-18 04:19:12 +00005433
Douglas Gregor70c23352010-12-09 21:44:02 +00005434 if (CodeCompleter && CodeCompleter->includeGlobals()) {
5435 Results.EnterNewScope();
5436
5437 // Tell the result set to ignore all of the protocols we have
5438 // already seen.
5439 // FIXME: This doesn't work when caching code-completion results.
5440 for (unsigned I = 0; I != NumProtocols; ++I)
5441 if (ObjCProtocolDecl *Protocol = LookupProtocol(Protocols[I].first,
5442 Protocols[I].second))
5443 Results.Ignore(Protocol);
Douglas Gregor55385fe2009-11-18 04:19:12 +00005444
Douglas Gregor70c23352010-12-09 21:44:02 +00005445 // Add all protocols.
5446 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false,
5447 Results);
Douglas Gregor083128f2009-11-18 04:49:41 +00005448
Douglas Gregor70c23352010-12-09 21:44:02 +00005449 Results.ExitScope();
5450 }
5451
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005452 HandleCodeCompleteResults(this, CodeCompleter,
5453 CodeCompletionContext::CCC_ObjCProtocolName,
5454 Results.data(),Results.size());
Douglas Gregor083128f2009-11-18 04:49:41 +00005455}
5456
5457void Sema::CodeCompleteObjCProtocolDecl(Scope *) {
Douglas Gregor218937c2011-02-01 19:23:04 +00005458 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5459 CodeCompletionContext::CCC_ObjCProtocolName);
Douglas Gregor083128f2009-11-18 04:49:41 +00005460
Douglas Gregor70c23352010-12-09 21:44:02 +00005461 if (CodeCompleter && CodeCompleter->includeGlobals()) {
5462 Results.EnterNewScope();
5463
5464 // Add all protocols.
5465 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true,
5466 Results);
Douglas Gregor55385fe2009-11-18 04:19:12 +00005467
Douglas Gregor70c23352010-12-09 21:44:02 +00005468 Results.ExitScope();
5469 }
5470
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005471 HandleCodeCompleteResults(this, CodeCompleter,
5472 CodeCompletionContext::CCC_ObjCProtocolName,
5473 Results.data(),Results.size());
Douglas Gregor55385fe2009-11-18 04:19:12 +00005474}
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005475
5476/// \brief Add all of the Objective-C interface declarations that we find in
5477/// the given (translation unit) context.
5478static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext,
5479 bool OnlyForwardDeclarations,
5480 bool OnlyUnimplemented,
5481 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00005482 typedef CodeCompletionResult Result;
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005483
5484 for (DeclContext::decl_iterator D = Ctx->decls_begin(),
5485 DEnd = Ctx->decls_end();
5486 D != DEnd; ++D) {
Douglas Gregordeacbdc2010-08-11 12:19:30 +00005487 // Record any interfaces we find.
5488 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(*D))
Douglas Gregor7723fec2011-12-15 20:29:51 +00005489 if ((!OnlyForwardDeclarations || !Class->hasDefinition()) &&
Douglas Gregordeacbdc2010-08-11 12:19:30 +00005490 (!OnlyUnimplemented || !Class->getImplementation()))
5491 Results.AddResult(Result(Class, 0), CurContext, 0, false);
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005492 }
5493}
5494
5495void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) {
Douglas Gregor218937c2011-02-01 19:23:04 +00005496 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5497 CodeCompletionContext::CCC_Other);
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005498 Results.EnterNewScope();
5499
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005500 if (CodeCompleter->includeGlobals()) {
5501 // Add all classes.
5502 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
5503 false, Results);
5504 }
5505
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005506 Results.ExitScope();
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005507
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005508 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005509 CodeCompletionContext::CCC_ObjCInterfaceName,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005510 Results.data(),Results.size());
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005511}
5512
Douglas Gregorc83c6872010-04-15 22:33:43 +00005513void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName,
5514 SourceLocation ClassNameLoc) {
Douglas Gregor218937c2011-02-01 19:23:04 +00005515 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005516 CodeCompletionContext::CCC_ObjCInterfaceName);
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005517 Results.EnterNewScope();
5518
5519 // Make sure that we ignore the class we're currently defining.
5520 NamedDecl *CurClass
Douglas Gregorc83c6872010-04-15 22:33:43 +00005521 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005522 if (CurClass && isa<ObjCInterfaceDecl>(CurClass))
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005523 Results.Ignore(CurClass);
5524
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005525 if (CodeCompleter->includeGlobals()) {
5526 // Add all classes.
5527 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
5528 false, Results);
5529 }
5530
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005531 Results.ExitScope();
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005532
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005533 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005534 CodeCompletionContext::CCC_ObjCInterfaceName,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005535 Results.data(),Results.size());
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005536}
5537
5538void Sema::CodeCompleteObjCImplementationDecl(Scope *S) {
Douglas Gregor218937c2011-02-01 19:23:04 +00005539 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5540 CodeCompletionContext::CCC_Other);
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005541 Results.EnterNewScope();
5542
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005543 if (CodeCompleter->includeGlobals()) {
5544 // Add all unimplemented classes.
5545 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
5546 true, Results);
5547 }
5548
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005549 Results.ExitScope();
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005550
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005551 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005552 CodeCompletionContext::CCC_ObjCInterfaceName,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005553 Results.data(),Results.size());
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005554}
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005555
5556void Sema::CodeCompleteObjCInterfaceCategory(Scope *S,
Douglas Gregorc83c6872010-04-15 22:33:43 +00005557 IdentifierInfo *ClassName,
5558 SourceLocation ClassNameLoc) {
John McCall0a2c5e22010-08-25 06:19:51 +00005559 typedef CodeCompletionResult Result;
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005560
Douglas Gregor218937c2011-02-01 19:23:04 +00005561 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor3da626b2011-07-07 16:03:39 +00005562 CodeCompletionContext::CCC_ObjCCategoryName);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005563
5564 // Ignore any categories we find that have already been implemented by this
5565 // interface.
5566 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
5567 NamedDecl *CurClass
Douglas Gregorc83c6872010-04-15 22:33:43 +00005568 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005569 if (ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass))
5570 for (ObjCCategoryDecl *Category = Class->getCategoryList(); Category;
5571 Category = Category->getNextClassCategory())
5572 CategoryNames.insert(Category->getIdentifier());
5573
5574 // Add all of the categories we know about.
5575 Results.EnterNewScope();
5576 TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
5577 for (DeclContext::decl_iterator D = TU->decls_begin(),
5578 DEnd = TU->decls_end();
5579 D != DEnd; ++D)
5580 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(*D))
5581 if (CategoryNames.insert(Category->getIdentifier()))
Douglas Gregor608300b2010-01-14 16:14:35 +00005582 Results.AddResult(Result(Category, 0), CurContext, 0, false);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005583 Results.ExitScope();
5584
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005585 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor3da626b2011-07-07 16:03:39 +00005586 CodeCompletionContext::CCC_ObjCCategoryName,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005587 Results.data(),Results.size());
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005588}
5589
5590void Sema::CodeCompleteObjCImplementationCategory(Scope *S,
Douglas Gregorc83c6872010-04-15 22:33:43 +00005591 IdentifierInfo *ClassName,
5592 SourceLocation ClassNameLoc) {
John McCall0a2c5e22010-08-25 06:19:51 +00005593 typedef CodeCompletionResult Result;
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005594
5595 // Find the corresponding interface. If we couldn't find the interface, the
5596 // program itself is ill-formed. However, we'll try to be helpful still by
5597 // providing the list of all of the categories we know about.
5598 NamedDecl *CurClass
Douglas Gregorc83c6872010-04-15 22:33:43 +00005599 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005600 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass);
5601 if (!Class)
Douglas Gregorc83c6872010-04-15 22:33:43 +00005602 return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005603
Douglas Gregor218937c2011-02-01 19:23:04 +00005604 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor3da626b2011-07-07 16:03:39 +00005605 CodeCompletionContext::CCC_ObjCCategoryName);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005606
5607 // Add all of the categories that have have corresponding interface
5608 // declarations in this class and any of its superclasses, except for
5609 // already-implemented categories in the class itself.
5610 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
5611 Results.EnterNewScope();
5612 bool IgnoreImplemented = true;
5613 while (Class) {
5614 for (ObjCCategoryDecl *Category = Class->getCategoryList(); Category;
5615 Category = Category->getNextClassCategory())
5616 if ((!IgnoreImplemented || !Category->getImplementation()) &&
5617 CategoryNames.insert(Category->getIdentifier()))
Douglas Gregor608300b2010-01-14 16:14:35 +00005618 Results.AddResult(Result(Category, 0), CurContext, 0, false);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005619
5620 Class = Class->getSuperClass();
5621 IgnoreImplemented = false;
5622 }
5623 Results.ExitScope();
5624
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005625 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor3da626b2011-07-07 16:03:39 +00005626 CodeCompletionContext::CCC_ObjCCategoryName,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005627 Results.data(),Results.size());
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005628}
Douglas Gregor322328b2009-11-18 22:32:06 +00005629
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00005630void Sema::CodeCompleteObjCPropertyDefinition(Scope *S) {
John McCall0a2c5e22010-08-25 06:19:51 +00005631 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00005632 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5633 CodeCompletionContext::CCC_Other);
Douglas Gregor322328b2009-11-18 22:32:06 +00005634
5635 // Figure out where this @synthesize lives.
5636 ObjCContainerDecl *Container
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00005637 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
Douglas Gregor322328b2009-11-18 22:32:06 +00005638 if (!Container ||
5639 (!isa<ObjCImplementationDecl>(Container) &&
5640 !isa<ObjCCategoryImplDecl>(Container)))
5641 return;
5642
5643 // Ignore any properties that have already been implemented.
5644 for (DeclContext::decl_iterator D = Container->decls_begin(),
5645 DEnd = Container->decls_end();
5646 D != DEnd; ++D)
5647 if (ObjCPropertyImplDecl *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(*D))
5648 Results.Ignore(PropertyImpl->getPropertyDecl());
5649
5650 // Add any properties that we find.
Douglas Gregor73449212010-12-09 23:01:55 +00005651 AddedPropertiesSet AddedProperties;
Douglas Gregor322328b2009-11-18 22:32:06 +00005652 Results.EnterNewScope();
5653 if (ObjCImplementationDecl *ClassImpl
5654 = dyn_cast<ObjCImplementationDecl>(Container))
Douglas Gregor4b81cde2011-05-05 15:50:42 +00005655 AddObjCProperties(ClassImpl->getClassInterface(), false,
5656 /*AllowNullaryMethods=*/false, CurContext,
Douglas Gregor73449212010-12-09 23:01:55 +00005657 AddedProperties, Results);
Douglas Gregor322328b2009-11-18 22:32:06 +00005658 else
5659 AddObjCProperties(cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(),
Douglas Gregor4b81cde2011-05-05 15:50:42 +00005660 false, /*AllowNullaryMethods=*/false, CurContext,
5661 AddedProperties, Results);
Douglas Gregor322328b2009-11-18 22:32:06 +00005662 Results.ExitScope();
5663
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005664 HandleCodeCompleteResults(this, CodeCompleter,
5665 CodeCompletionContext::CCC_Other,
5666 Results.data(),Results.size());
Douglas Gregor322328b2009-11-18 22:32:06 +00005667}
5668
5669void Sema::CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00005670 IdentifierInfo *PropertyName) {
John McCall0a2c5e22010-08-25 06:19:51 +00005671 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00005672 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5673 CodeCompletionContext::CCC_Other);
Douglas Gregor322328b2009-11-18 22:32:06 +00005674
5675 // Figure out where this @synthesize lives.
5676 ObjCContainerDecl *Container
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00005677 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
Douglas Gregor322328b2009-11-18 22:32:06 +00005678 if (!Container ||
5679 (!isa<ObjCImplementationDecl>(Container) &&
5680 !isa<ObjCCategoryImplDecl>(Container)))
5681 return;
5682
5683 // Figure out which interface we're looking into.
5684 ObjCInterfaceDecl *Class = 0;
5685 if (ObjCImplementationDecl *ClassImpl
5686 = dyn_cast<ObjCImplementationDecl>(Container))
5687 Class = ClassImpl->getClassInterface();
5688 else
5689 Class = cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl()
5690 ->getClassInterface();
5691
Douglas Gregore8426052011-04-18 14:40:46 +00005692 // Determine the type of the property we're synthesizing.
5693 QualType PropertyType = Context.getObjCIdType();
5694 if (Class) {
5695 if (ObjCPropertyDecl *Property
5696 = Class->FindPropertyDeclaration(PropertyName)) {
5697 PropertyType
5698 = Property->getType().getNonReferenceType().getUnqualifiedType();
5699
5700 // Give preference to ivars
5701 Results.setPreferredType(PropertyType);
5702 }
5703 }
5704
Douglas Gregor322328b2009-11-18 22:32:06 +00005705 // Add all of the instance variables in this class and its superclasses.
5706 Results.EnterNewScope();
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005707 bool SawSimilarlyNamedIvar = false;
5708 std::string NameWithPrefix;
5709 NameWithPrefix += '_';
Benjamin Kramera0651c52011-07-26 16:59:25 +00005710 NameWithPrefix += PropertyName->getName();
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005711 std::string NameWithSuffix = PropertyName->getName().str();
5712 NameWithSuffix += '_';
Douglas Gregor322328b2009-11-18 22:32:06 +00005713 for(; Class; Class = Class->getSuperClass()) {
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005714 for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar;
5715 Ivar = Ivar->getNextIvar()) {
Douglas Gregore8426052011-04-18 14:40:46 +00005716 Results.AddResult(Result(Ivar, 0), CurContext, 0, false);
5717
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005718 // Determine whether we've seen an ivar with a name similar to the
5719 // property.
Douglas Gregore8426052011-04-18 14:40:46 +00005720 if ((PropertyName == Ivar->getIdentifier() ||
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005721 NameWithPrefix == Ivar->getName() ||
Douglas Gregore8426052011-04-18 14:40:46 +00005722 NameWithSuffix == Ivar->getName())) {
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005723 SawSimilarlyNamedIvar = true;
Douglas Gregore8426052011-04-18 14:40:46 +00005724
5725 // Reduce the priority of this result by one, to give it a slight
5726 // advantage over other results whose names don't match so closely.
5727 if (Results.size() &&
5728 Results.data()[Results.size() - 1].Kind
5729 == CodeCompletionResult::RK_Declaration &&
5730 Results.data()[Results.size() - 1].Declaration == Ivar)
5731 Results.data()[Results.size() - 1].Priority--;
5732 }
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005733 }
Douglas Gregor322328b2009-11-18 22:32:06 +00005734 }
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005735
5736 if (!SawSimilarlyNamedIvar) {
5737 // Create ivar result _propName, that the user can use to synthesize
Douglas Gregore8426052011-04-18 14:40:46 +00005738 // an ivar of the appropriate type.
5739 unsigned Priority = CCP_MemberDeclaration + 1;
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005740 typedef CodeCompletionResult Result;
5741 CodeCompletionAllocator &Allocator = Results.getAllocator();
5742 CodeCompletionBuilder Builder(Allocator, Priority,CXAvailability_Available);
5743
Douglas Gregor8987b232011-09-27 23:30:47 +00005744 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
Douglas Gregore8426052011-04-18 14:40:46 +00005745 Builder.AddResultTypeChunk(GetCompletionTypeString(PropertyType, Context,
Douglas Gregor8987b232011-09-27 23:30:47 +00005746 Policy, Allocator));
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005747 Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix));
5748 Results.AddResult(Result(Builder.TakeString(), Priority,
5749 CXCursor_ObjCIvarDecl));
5750 }
5751
Douglas Gregor322328b2009-11-18 22:32:06 +00005752 Results.ExitScope();
5753
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005754 HandleCodeCompleteResults(this, CodeCompleter,
5755 CodeCompletionContext::CCC_Other,
5756 Results.data(),Results.size());
Douglas Gregor322328b2009-11-18 22:32:06 +00005757}
Douglas Gregore8f5a172010-04-07 00:21:17 +00005758
Douglas Gregor408be5a2010-08-25 01:08:01 +00005759// Mapping from selectors to the methods that implement that selector, along
5760// with the "in original class" flag.
5761typedef llvm::DenseMap<Selector, std::pair<ObjCMethodDecl *, bool> >
5762 KnownMethodsMap;
Douglas Gregore8f5a172010-04-07 00:21:17 +00005763
5764/// \brief Find all of the methods that reside in the given container
5765/// (and its superclasses, protocols, etc.) that meet the given
5766/// criteria. Insert those methods into the map of known methods,
5767/// indexed by selector so they can be easily found.
5768static void FindImplementableMethods(ASTContext &Context,
5769 ObjCContainerDecl *Container,
5770 bool WantInstanceMethods,
5771 QualType ReturnType,
Douglas Gregor408be5a2010-08-25 01:08:01 +00005772 KnownMethodsMap &KnownMethods,
5773 bool InOriginalClass = true) {
Douglas Gregore8f5a172010-04-07 00:21:17 +00005774 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) {
5775 // Recurse into protocols.
Douglas Gregor2e5c15b2011-12-15 05:27:12 +00005776 if (!IFace->hasDefinition())
5777 return;
5778
Douglas Gregore8f5a172010-04-07 00:21:17 +00005779 const ObjCList<ObjCProtocolDecl> &Protocols
5780 = IFace->getReferencedProtocols();
5781 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
Douglas Gregorea766182010-10-18 18:21:28 +00005782 E = Protocols.end();
Douglas Gregore8f5a172010-04-07 00:21:17 +00005783 I != E; ++I)
5784 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
Douglas Gregorea766182010-10-18 18:21:28 +00005785 KnownMethods, InOriginalClass);
Douglas Gregore8f5a172010-04-07 00:21:17 +00005786
Douglas Gregorea766182010-10-18 18:21:28 +00005787 // Add methods from any class extensions and categories.
5788 for (const ObjCCategoryDecl *Cat = IFace->getCategoryList(); Cat;
5789 Cat = Cat->getNextClassCategory())
Fariborz Jahanian80aa1cd2010-06-22 23:20:40 +00005790 FindImplementableMethods(Context, const_cast<ObjCCategoryDecl*>(Cat),
5791 WantInstanceMethods, ReturnType,
Douglas Gregorea766182010-10-18 18:21:28 +00005792 KnownMethods, false);
5793
5794 // Visit the superclass.
5795 if (IFace->getSuperClass())
5796 FindImplementableMethods(Context, IFace->getSuperClass(),
5797 WantInstanceMethods, ReturnType,
5798 KnownMethods, false);
Douglas Gregore8f5a172010-04-07 00:21:17 +00005799 }
5800
5801 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
5802 // Recurse into protocols.
5803 const ObjCList<ObjCProtocolDecl> &Protocols
5804 = Category->getReferencedProtocols();
5805 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
Douglas Gregorea766182010-10-18 18:21:28 +00005806 E = Protocols.end();
Douglas Gregore8f5a172010-04-07 00:21:17 +00005807 I != E; ++I)
5808 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
Douglas Gregorea766182010-10-18 18:21:28 +00005809 KnownMethods, InOriginalClass);
5810
5811 // If this category is the original class, jump to the interface.
5812 if (InOriginalClass && Category->getClassInterface())
5813 FindImplementableMethods(Context, Category->getClassInterface(),
5814 WantInstanceMethods, ReturnType, KnownMethods,
5815 false);
Douglas Gregore8f5a172010-04-07 00:21:17 +00005816 }
5817
5818 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
Douglas Gregor5e2a1ff2012-01-01 19:29:29 +00005819 if (Protocol->hasDefinition()) {
5820 // Recurse into protocols.
5821 const ObjCList<ObjCProtocolDecl> &Protocols
5822 = Protocol->getReferencedProtocols();
5823 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5824 E = Protocols.end();
5825 I != E; ++I)
5826 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
5827 KnownMethods, false);
5828 }
Douglas Gregore8f5a172010-04-07 00:21:17 +00005829 }
5830
5831 // Add methods in this container. This operation occurs last because
5832 // we want the methods from this container to override any methods
5833 // we've previously seen with the same selector.
5834 for (ObjCContainerDecl::method_iterator M = Container->meth_begin(),
5835 MEnd = Container->meth_end();
5836 M != MEnd; ++M) {
5837 if ((*M)->isInstanceMethod() == WantInstanceMethods) {
5838 if (!ReturnType.isNull() &&
5839 !Context.hasSameUnqualifiedType(ReturnType, (*M)->getResultType()))
5840 continue;
5841
Douglas Gregor408be5a2010-08-25 01:08:01 +00005842 KnownMethods[(*M)->getSelector()] = std::make_pair(*M, InOriginalClass);
Douglas Gregore8f5a172010-04-07 00:21:17 +00005843 }
5844 }
5845}
5846
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005847/// \brief Add the parenthesized return or parameter type chunk to a code
5848/// completion string.
5849static void AddObjCPassingTypeChunk(QualType Type,
5850 ASTContext &Context,
Douglas Gregor8987b232011-09-27 23:30:47 +00005851 const PrintingPolicy &Policy,
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005852 CodeCompletionBuilder &Builder) {
5853 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
Douglas Gregor8987b232011-09-27 23:30:47 +00005854 Builder.AddTextChunk(GetCompletionTypeString(Type, Context, Policy,
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005855 Builder.getAllocator()));
5856 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5857}
5858
5859/// \brief Determine whether the given class is or inherits from a class by
5860/// the given name.
5861static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class,
Chris Lattner5f9e2722011-07-23 10:55:15 +00005862 StringRef Name) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005863 if (!Class)
5864 return false;
5865
5866 if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name)
5867 return true;
5868
5869 return InheritsFromClassNamed(Class->getSuperClass(), Name);
5870}
5871
5872/// \brief Add code completions for Objective-C Key-Value Coding (KVC) and
5873/// Key-Value Observing (KVO).
5874static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property,
5875 bool IsInstanceMethod,
5876 QualType ReturnType,
5877 ASTContext &Context,
Douglas Gregore74c25c2011-05-04 23:50:46 +00005878 VisitedSelectorSet &KnownSelectors,
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005879 ResultBuilder &Results) {
5880 IdentifierInfo *PropName = Property->getIdentifier();
5881 if (!PropName || PropName->getLength() == 0)
5882 return;
5883
Douglas Gregor8987b232011-09-27 23:30:47 +00005884 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
5885
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005886 // Builder that will create each code completion.
5887 typedef CodeCompletionResult Result;
5888 CodeCompletionAllocator &Allocator = Results.getAllocator();
5889 CodeCompletionBuilder Builder(Allocator);
5890
5891 // The selector table.
5892 SelectorTable &Selectors = Context.Selectors;
5893
5894 // The property name, copied into the code completion allocation region
5895 // on demand.
5896 struct KeyHolder {
5897 CodeCompletionAllocator &Allocator;
Chris Lattner5f9e2722011-07-23 10:55:15 +00005898 StringRef Key;
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005899 const char *CopiedKey;
5900
Chris Lattner5f9e2722011-07-23 10:55:15 +00005901 KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key)
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005902 : Allocator(Allocator), Key(Key), CopiedKey(0) { }
5903
5904 operator const char *() {
5905 if (CopiedKey)
5906 return CopiedKey;
5907
5908 return CopiedKey = Allocator.CopyString(Key);
5909 }
5910 } Key(Allocator, PropName->getName());
5911
5912 // The uppercased name of the property name.
5913 std::string UpperKey = PropName->getName();
5914 if (!UpperKey.empty())
5915 UpperKey[0] = toupper(UpperKey[0]);
5916
5917 bool ReturnTypeMatchesProperty = ReturnType.isNull() ||
5918 Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(),
5919 Property->getType());
5920 bool ReturnTypeMatchesVoid
5921 = ReturnType.isNull() || ReturnType->isVoidType();
5922
5923 // Add the normal accessor -(type)key.
5924 if (IsInstanceMethod &&
Douglas Gregore74c25c2011-05-04 23:50:46 +00005925 KnownSelectors.insert(Selectors.getNullarySelector(PropName)) &&
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005926 ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) {
5927 if (ReturnType.isNull())
Douglas Gregor8987b232011-09-27 23:30:47 +00005928 AddObjCPassingTypeChunk(Property->getType(), Context, Policy, Builder);
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005929
5930 Builder.AddTypedTextChunk(Key);
5931 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
5932 CXCursor_ObjCInstanceMethodDecl));
5933 }
5934
5935 // If we have an integral or boolean property (or the user has provided
5936 // an integral or boolean return type), add the accessor -(type)isKey.
5937 if (IsInstanceMethod &&
5938 ((!ReturnType.isNull() &&
5939 (ReturnType->isIntegerType() || ReturnType->isBooleanType())) ||
5940 (ReturnType.isNull() &&
5941 (Property->getType()->isIntegerType() ||
5942 Property->getType()->isBooleanType())))) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00005943 std::string SelectorName = (Twine("is") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00005944 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00005945 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005946 if (ReturnType.isNull()) {
5947 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5948 Builder.AddTextChunk("BOOL");
5949 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5950 }
5951
5952 Builder.AddTypedTextChunk(
5953 Allocator.CopyString(SelectorId->getName()));
5954 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
5955 CXCursor_ObjCInstanceMethodDecl));
5956 }
5957 }
5958
5959 // Add the normal mutator.
5960 if (IsInstanceMethod && ReturnTypeMatchesVoid &&
5961 !Property->getSetterMethodDecl()) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00005962 std::string SelectorName = (Twine("set") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00005963 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00005964 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005965 if (ReturnType.isNull()) {
5966 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5967 Builder.AddTextChunk("void");
5968 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5969 }
5970
5971 Builder.AddTypedTextChunk(
5972 Allocator.CopyString(SelectorId->getName()));
5973 Builder.AddTypedTextChunk(":");
Douglas Gregor8987b232011-09-27 23:30:47 +00005974 AddObjCPassingTypeChunk(Property->getType(), Context, Policy, Builder);
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005975 Builder.AddTextChunk(Key);
5976 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
5977 CXCursor_ObjCInstanceMethodDecl));
5978 }
5979 }
5980
5981 // Indexed and unordered accessors
5982 unsigned IndexedGetterPriority = CCP_CodePattern;
5983 unsigned IndexedSetterPriority = CCP_CodePattern;
5984 unsigned UnorderedGetterPriority = CCP_CodePattern;
5985 unsigned UnorderedSetterPriority = CCP_CodePattern;
5986 if (const ObjCObjectPointerType *ObjCPointer
5987 = Property->getType()->getAs<ObjCObjectPointerType>()) {
5988 if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) {
5989 // If this interface type is not provably derived from a known
5990 // collection, penalize the corresponding completions.
5991 if (!InheritsFromClassNamed(IFace, "NSMutableArray")) {
5992 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
5993 if (!InheritsFromClassNamed(IFace, "NSArray"))
5994 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
5995 }
5996
5997 if (!InheritsFromClassNamed(IFace, "NSMutableSet")) {
5998 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
5999 if (!InheritsFromClassNamed(IFace, "NSSet"))
6000 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6001 }
6002 }
6003 } else {
6004 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6005 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6006 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6007 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6008 }
6009
6010 // Add -(NSUInteger)countOf<key>
6011 if (IsInstanceMethod &&
6012 (ReturnType.isNull() || ReturnType->isIntegerType())) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006013 std::string SelectorName = (Twine("countOf") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006014 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006015 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006016 if (ReturnType.isNull()) {
6017 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6018 Builder.AddTextChunk("NSUInteger");
6019 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6020 }
6021
6022 Builder.AddTypedTextChunk(
6023 Allocator.CopyString(SelectorId->getName()));
6024 Results.AddResult(Result(Builder.TakeString(),
6025 std::min(IndexedGetterPriority,
6026 UnorderedGetterPriority),
6027 CXCursor_ObjCInstanceMethodDecl));
6028 }
6029 }
6030
6031 // Indexed getters
6032 // Add -(id)objectInKeyAtIndex:(NSUInteger)index
6033 if (IsInstanceMethod &&
6034 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
Douglas Gregor62041592011-02-17 03:19:26 +00006035 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006036 = (Twine("objectIn") + UpperKey + "AtIndex").str();
Douglas Gregor62041592011-02-17 03:19:26 +00006037 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006038 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006039 if (ReturnType.isNull()) {
6040 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6041 Builder.AddTextChunk("id");
6042 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6043 }
6044
6045 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6046 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6047 Builder.AddTextChunk("NSUInteger");
6048 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6049 Builder.AddTextChunk("index");
6050 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6051 CXCursor_ObjCInstanceMethodDecl));
6052 }
6053 }
6054
6055 // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes
6056 if (IsInstanceMethod &&
6057 (ReturnType.isNull() ||
6058 (ReturnType->isObjCObjectPointerType() &&
6059 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6060 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6061 ->getName() == "NSArray"))) {
Douglas Gregor62041592011-02-17 03:19:26 +00006062 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006063 = (Twine(Property->getName()) + "AtIndexes").str();
Douglas Gregor62041592011-02-17 03:19:26 +00006064 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006065 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006066 if (ReturnType.isNull()) {
6067 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6068 Builder.AddTextChunk("NSArray *");
6069 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6070 }
6071
6072 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6073 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6074 Builder.AddTextChunk("NSIndexSet *");
6075 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6076 Builder.AddTextChunk("indexes");
6077 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6078 CXCursor_ObjCInstanceMethodDecl));
6079 }
6080 }
6081
6082 // Add -(void)getKey:(type **)buffer range:(NSRange)inRange
6083 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006084 std::string SelectorName = (Twine("get") + UpperKey).str();
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006085 IdentifierInfo *SelectorIds[2] = {
Douglas Gregor62041592011-02-17 03:19:26 +00006086 &Context.Idents.get(SelectorName),
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006087 &Context.Idents.get("range")
6088 };
6089
Douglas Gregore74c25c2011-05-04 23:50:46 +00006090 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006091 if (ReturnType.isNull()) {
6092 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6093 Builder.AddTextChunk("void");
6094 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6095 }
6096
6097 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6098 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6099 Builder.AddPlaceholderChunk("object-type");
6100 Builder.AddTextChunk(" **");
6101 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6102 Builder.AddTextChunk("buffer");
6103 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6104 Builder.AddTypedTextChunk("range:");
6105 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6106 Builder.AddTextChunk("NSRange");
6107 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6108 Builder.AddTextChunk("inRange");
6109 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6110 CXCursor_ObjCInstanceMethodDecl));
6111 }
6112 }
6113
6114 // Mutable indexed accessors
6115
6116 // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index
6117 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006118 std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str();
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006119 IdentifierInfo *SelectorIds[2] = {
6120 &Context.Idents.get("insertObject"),
Douglas Gregor62041592011-02-17 03:19:26 +00006121 &Context.Idents.get(SelectorName)
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006122 };
6123
Douglas Gregore74c25c2011-05-04 23:50:46 +00006124 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006125 if (ReturnType.isNull()) {
6126 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6127 Builder.AddTextChunk("void");
6128 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6129 }
6130
6131 Builder.AddTypedTextChunk("insertObject:");
6132 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6133 Builder.AddPlaceholderChunk("object-type");
6134 Builder.AddTextChunk(" *");
6135 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6136 Builder.AddTextChunk("object");
6137 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6138 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6139 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6140 Builder.AddPlaceholderChunk("NSUInteger");
6141 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6142 Builder.AddTextChunk("index");
6143 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6144 CXCursor_ObjCInstanceMethodDecl));
6145 }
6146 }
6147
6148 // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes
6149 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006150 std::string SelectorName = (Twine("insert") + UpperKey).str();
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006151 IdentifierInfo *SelectorIds[2] = {
Douglas Gregor62041592011-02-17 03:19:26 +00006152 &Context.Idents.get(SelectorName),
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006153 &Context.Idents.get("atIndexes")
6154 };
6155
Douglas Gregore74c25c2011-05-04 23:50:46 +00006156 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006157 if (ReturnType.isNull()) {
6158 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6159 Builder.AddTextChunk("void");
6160 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6161 }
6162
6163 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6164 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6165 Builder.AddTextChunk("NSArray *");
6166 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6167 Builder.AddTextChunk("array");
6168 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6169 Builder.AddTypedTextChunk("atIndexes:");
6170 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6171 Builder.AddPlaceholderChunk("NSIndexSet *");
6172 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6173 Builder.AddTextChunk("indexes");
6174 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6175 CXCursor_ObjCInstanceMethodDecl));
6176 }
6177 }
6178
6179 // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index
6180 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor62041592011-02-17 03:19:26 +00006181 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006182 = (Twine("removeObjectFrom") + UpperKey + "AtIndex").str();
Douglas Gregor62041592011-02-17 03:19:26 +00006183 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006184 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006185 if (ReturnType.isNull()) {
6186 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6187 Builder.AddTextChunk("void");
6188 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6189 }
6190
6191 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6192 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6193 Builder.AddTextChunk("NSUInteger");
6194 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6195 Builder.AddTextChunk("index");
6196 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6197 CXCursor_ObjCInstanceMethodDecl));
6198 }
6199 }
6200
6201 // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes
6202 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor62041592011-02-17 03:19:26 +00006203 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006204 = (Twine("remove") + UpperKey + "AtIndexes").str();
Douglas Gregor62041592011-02-17 03:19:26 +00006205 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006206 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006207 if (ReturnType.isNull()) {
6208 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6209 Builder.AddTextChunk("void");
6210 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6211 }
6212
6213 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6214 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6215 Builder.AddTextChunk("NSIndexSet *");
6216 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6217 Builder.AddTextChunk("indexes");
6218 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6219 CXCursor_ObjCInstanceMethodDecl));
6220 }
6221 }
6222
6223 // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object
6224 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor62041592011-02-17 03:19:26 +00006225 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006226 = (Twine("replaceObjectIn") + UpperKey + "AtIndex").str();
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006227 IdentifierInfo *SelectorIds[2] = {
Douglas Gregor62041592011-02-17 03:19:26 +00006228 &Context.Idents.get(SelectorName),
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006229 &Context.Idents.get("withObject")
6230 };
6231
Douglas Gregore74c25c2011-05-04 23:50:46 +00006232 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006233 if (ReturnType.isNull()) {
6234 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6235 Builder.AddTextChunk("void");
6236 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6237 }
6238
6239 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6240 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6241 Builder.AddPlaceholderChunk("NSUInteger");
6242 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6243 Builder.AddTextChunk("index");
6244 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6245 Builder.AddTypedTextChunk("withObject:");
6246 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6247 Builder.AddTextChunk("id");
6248 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6249 Builder.AddTextChunk("object");
6250 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6251 CXCursor_ObjCInstanceMethodDecl));
6252 }
6253 }
6254
6255 // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array
6256 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor62041592011-02-17 03:19:26 +00006257 std::string SelectorName1
Chris Lattner5f9e2722011-07-23 10:55:15 +00006258 = (Twine("replace") + UpperKey + "AtIndexes").str();
6259 std::string SelectorName2 = (Twine("with") + UpperKey).str();
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006260 IdentifierInfo *SelectorIds[2] = {
Douglas Gregor62041592011-02-17 03:19:26 +00006261 &Context.Idents.get(SelectorName1),
6262 &Context.Idents.get(SelectorName2)
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006263 };
6264
Douglas Gregore74c25c2011-05-04 23:50:46 +00006265 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006266 if (ReturnType.isNull()) {
6267 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6268 Builder.AddTextChunk("void");
6269 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6270 }
6271
6272 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName1 + ":"));
6273 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6274 Builder.AddPlaceholderChunk("NSIndexSet *");
6275 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6276 Builder.AddTextChunk("indexes");
6277 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6278 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":"));
6279 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6280 Builder.AddTextChunk("NSArray *");
6281 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6282 Builder.AddTextChunk("array");
6283 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6284 CXCursor_ObjCInstanceMethodDecl));
6285 }
6286 }
6287
6288 // Unordered getters
6289 // - (NSEnumerator *)enumeratorOfKey
6290 if (IsInstanceMethod &&
6291 (ReturnType.isNull() ||
6292 (ReturnType->isObjCObjectPointerType() &&
6293 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6294 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6295 ->getName() == "NSEnumerator"))) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006296 std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006297 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006298 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006299 if (ReturnType.isNull()) {
6300 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6301 Builder.AddTextChunk("NSEnumerator *");
6302 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6303 }
6304
6305 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6306 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
6307 CXCursor_ObjCInstanceMethodDecl));
6308 }
6309 }
6310
6311 // - (type *)memberOfKey:(type *)object
6312 if (IsInstanceMethod &&
6313 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006314 std::string SelectorName = (Twine("memberOf") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006315 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006316 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006317 if (ReturnType.isNull()) {
6318 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6319 Builder.AddPlaceholderChunk("object-type");
6320 Builder.AddTextChunk(" *");
6321 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6322 }
6323
6324 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6325 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6326 if (ReturnType.isNull()) {
6327 Builder.AddPlaceholderChunk("object-type");
6328 Builder.AddTextChunk(" *");
6329 } else {
6330 Builder.AddTextChunk(GetCompletionTypeString(ReturnType, Context,
Douglas Gregor8987b232011-09-27 23:30:47 +00006331 Policy,
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006332 Builder.getAllocator()));
6333 }
6334 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6335 Builder.AddTextChunk("object");
6336 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
6337 CXCursor_ObjCInstanceMethodDecl));
6338 }
6339 }
6340
6341 // Mutable unordered accessors
6342 // - (void)addKeyObject:(type *)object
6343 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor62041592011-02-17 03:19:26 +00006344 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006345 = (Twine("add") + UpperKey + Twine("Object")).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006346 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006347 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006348 if (ReturnType.isNull()) {
6349 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6350 Builder.AddTextChunk("void");
6351 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6352 }
6353
6354 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6355 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6356 Builder.AddPlaceholderChunk("object-type");
6357 Builder.AddTextChunk(" *");
6358 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6359 Builder.AddTextChunk("object");
6360 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6361 CXCursor_ObjCInstanceMethodDecl));
6362 }
6363 }
6364
6365 // - (void)addKey:(NSSet *)objects
6366 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006367 std::string SelectorName = (Twine("add") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006368 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006369 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006370 if (ReturnType.isNull()) {
6371 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6372 Builder.AddTextChunk("void");
6373 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6374 }
6375
6376 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6377 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6378 Builder.AddTextChunk("NSSet *");
6379 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6380 Builder.AddTextChunk("objects");
6381 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6382 CXCursor_ObjCInstanceMethodDecl));
6383 }
6384 }
6385
6386 // - (void)removeKeyObject:(type *)object
6387 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor62041592011-02-17 03:19:26 +00006388 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006389 = (Twine("remove") + UpperKey + Twine("Object")).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006390 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006391 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006392 if (ReturnType.isNull()) {
6393 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6394 Builder.AddTextChunk("void");
6395 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6396 }
6397
6398 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6399 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6400 Builder.AddPlaceholderChunk("object-type");
6401 Builder.AddTextChunk(" *");
6402 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6403 Builder.AddTextChunk("object");
6404 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6405 CXCursor_ObjCInstanceMethodDecl));
6406 }
6407 }
6408
6409 // - (void)removeKey:(NSSet *)objects
6410 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006411 std::string SelectorName = (Twine("remove") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006412 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006413 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006414 if (ReturnType.isNull()) {
6415 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6416 Builder.AddTextChunk("void");
6417 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6418 }
6419
6420 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6421 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6422 Builder.AddTextChunk("NSSet *");
6423 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6424 Builder.AddTextChunk("objects");
6425 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6426 CXCursor_ObjCInstanceMethodDecl));
6427 }
6428 }
6429
6430 // - (void)intersectKey:(NSSet *)objects
6431 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006432 std::string SelectorName = (Twine("intersect") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006433 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006434 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006435 if (ReturnType.isNull()) {
6436 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6437 Builder.AddTextChunk("void");
6438 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6439 }
6440
6441 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6442 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6443 Builder.AddTextChunk("NSSet *");
6444 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6445 Builder.AddTextChunk("objects");
6446 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6447 CXCursor_ObjCInstanceMethodDecl));
6448 }
6449 }
6450
6451 // Key-Value Observing
6452 // + (NSSet *)keyPathsForValuesAffectingKey
6453 if (!IsInstanceMethod &&
6454 (ReturnType.isNull() ||
6455 (ReturnType->isObjCObjectPointerType() &&
6456 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6457 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6458 ->getName() == "NSSet"))) {
Douglas Gregor62041592011-02-17 03:19:26 +00006459 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006460 = (Twine("keyPathsForValuesAffecting") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006461 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006462 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006463 if (ReturnType.isNull()) {
6464 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6465 Builder.AddTextChunk("NSSet *");
6466 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6467 }
6468
6469 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6470 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
Douglas Gregor3f828d12011-06-02 04:02:27 +00006471 CXCursor_ObjCClassMethodDecl));
6472 }
6473 }
6474
6475 // + (BOOL)automaticallyNotifiesObserversForKey
6476 if (!IsInstanceMethod &&
6477 (ReturnType.isNull() ||
6478 ReturnType->isIntegerType() ||
6479 ReturnType->isBooleanType())) {
6480 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006481 = (Twine("automaticallyNotifiesObserversOf") + UpperKey).str();
Douglas Gregor3f828d12011-06-02 04:02:27 +00006482 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6483 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
6484 if (ReturnType.isNull()) {
6485 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6486 Builder.AddTextChunk("BOOL");
6487 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6488 }
6489
6490 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6491 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6492 CXCursor_ObjCClassMethodDecl));
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006493 }
6494 }
6495}
6496
Douglas Gregore8f5a172010-04-07 00:21:17 +00006497void Sema::CodeCompleteObjCMethodDecl(Scope *S,
6498 bool IsInstanceMethod,
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00006499 ParsedType ReturnTy) {
Douglas Gregore8f5a172010-04-07 00:21:17 +00006500 // Determine the return type of the method we're declaring, if
6501 // provided.
6502 QualType ReturnType = GetTypeFromParser(ReturnTy);
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00006503 Decl *IDecl = 0;
6504 if (CurContext->isObjCContainer()) {
6505 ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
6506 IDecl = cast<Decl>(OCD);
6507 }
Douglas Gregorea766182010-10-18 18:21:28 +00006508 // Determine where we should start searching for methods.
6509 ObjCContainerDecl *SearchDecl = 0;
Douglas Gregore8f5a172010-04-07 00:21:17 +00006510 bool IsInImplementation = false;
John McCalld226f652010-08-21 09:40:31 +00006511 if (Decl *D = IDecl) {
Douglas Gregore8f5a172010-04-07 00:21:17 +00006512 if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) {
6513 SearchDecl = Impl->getClassInterface();
Douglas Gregore8f5a172010-04-07 00:21:17 +00006514 IsInImplementation = true;
6515 } else if (ObjCCategoryImplDecl *CatImpl
Douglas Gregorea766182010-10-18 18:21:28 +00006516 = dyn_cast<ObjCCategoryImplDecl>(D)) {
Douglas Gregore8f5a172010-04-07 00:21:17 +00006517 SearchDecl = CatImpl->getCategoryDecl();
Douglas Gregore8f5a172010-04-07 00:21:17 +00006518 IsInImplementation = true;
Douglas Gregorea766182010-10-18 18:21:28 +00006519 } else
Douglas Gregore8f5a172010-04-07 00:21:17 +00006520 SearchDecl = dyn_cast<ObjCContainerDecl>(D);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006521 }
6522
6523 if (!SearchDecl && S) {
Douglas Gregorea766182010-10-18 18:21:28 +00006524 if (DeclContext *DC = static_cast<DeclContext *>(S->getEntity()))
Douglas Gregore8f5a172010-04-07 00:21:17 +00006525 SearchDecl = dyn_cast<ObjCContainerDecl>(DC);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006526 }
6527
Douglas Gregorea766182010-10-18 18:21:28 +00006528 if (!SearchDecl) {
Douglas Gregore6b1bb62010-08-11 21:23:17 +00006529 HandleCodeCompleteResults(this, CodeCompleter,
6530 CodeCompletionContext::CCC_Other,
6531 0, 0);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006532 return;
6533 }
6534
6535 // Find all of the methods that we could declare/implement here.
6536 KnownMethodsMap KnownMethods;
6537 FindImplementableMethods(Context, SearchDecl, IsInstanceMethod,
Douglas Gregorea766182010-10-18 18:21:28 +00006538 ReturnType, KnownMethods);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006539
Douglas Gregore8f5a172010-04-07 00:21:17 +00006540 // Add declarations or definitions for each of the known methods.
John McCall0a2c5e22010-08-25 06:19:51 +00006541 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00006542 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6543 CodeCompletionContext::CCC_Other);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006544 Results.EnterNewScope();
Douglas Gregor8987b232011-09-27 23:30:47 +00006545 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006546 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
6547 MEnd = KnownMethods.end();
6548 M != MEnd; ++M) {
Douglas Gregor408be5a2010-08-25 01:08:01 +00006549 ObjCMethodDecl *Method = M->second.first;
Douglas Gregor218937c2011-02-01 19:23:04 +00006550 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregore8f5a172010-04-07 00:21:17 +00006551
6552 // If the result type was not already provided, add it to the
6553 // pattern as (type).
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006554 if (ReturnType.isNull())
Douglas Gregor8987b232011-09-27 23:30:47 +00006555 AddObjCPassingTypeChunk(Method->getResultType(), Context, Policy,
6556 Builder);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006557
6558 Selector Sel = Method->getSelector();
6559
6560 // Add the first part of the selector to the pattern.
Douglas Gregordae68752011-02-01 22:57:45 +00006561 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00006562 Sel.getNameForSlot(0)));
Douglas Gregore8f5a172010-04-07 00:21:17 +00006563
6564 // Add parameters to the pattern.
6565 unsigned I = 0;
6566 for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
6567 PEnd = Method->param_end();
6568 P != PEnd; (void)++P, ++I) {
6569 // Add the part of the selector name.
6570 if (I == 0)
Douglas Gregor218937c2011-02-01 19:23:04 +00006571 Builder.AddTypedTextChunk(":");
Douglas Gregore8f5a172010-04-07 00:21:17 +00006572 else if (I < Sel.getNumArgs()) {
Douglas Gregor218937c2011-02-01 19:23:04 +00006573 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6574 Builder.AddTypedTextChunk(
Douglas Gregor813d8342011-02-18 22:29:55 +00006575 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
Douglas Gregore8f5a172010-04-07 00:21:17 +00006576 } else
6577 break;
6578
6579 // Add the parameter type.
Douglas Gregor8987b232011-09-27 23:30:47 +00006580 AddObjCPassingTypeChunk((*P)->getOriginalType(), Context, Policy,
6581 Builder);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006582
6583 if (IdentifierInfo *Id = (*P)->getIdentifier())
Douglas Gregordae68752011-02-01 22:57:45 +00006584 Builder.AddTextChunk(Builder.getAllocator().CopyString( Id->getName()));
Douglas Gregore8f5a172010-04-07 00:21:17 +00006585 }
6586
6587 if (Method->isVariadic()) {
6588 if (Method->param_size() > 0)
Douglas Gregor218937c2011-02-01 19:23:04 +00006589 Builder.AddChunk(CodeCompletionString::CK_Comma);
6590 Builder.AddTextChunk("...");
Douglas Gregore17794f2010-08-31 05:13:43 +00006591 }
Douglas Gregore8f5a172010-04-07 00:21:17 +00006592
Douglas Gregor447107d2010-05-28 00:57:46 +00006593 if (IsInImplementation && Results.includeCodePatterns()) {
Douglas Gregore8f5a172010-04-07 00:21:17 +00006594 // We will be defining the method here, so add a compound statement.
Douglas Gregor218937c2011-02-01 19:23:04 +00006595 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6596 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
6597 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006598 if (!Method->getResultType()->isVoidType()) {
6599 // If the result type is not void, add a return clause.
Douglas Gregor218937c2011-02-01 19:23:04 +00006600 Builder.AddTextChunk("return");
6601 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6602 Builder.AddPlaceholderChunk("expression");
6603 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006604 } else
Douglas Gregor218937c2011-02-01 19:23:04 +00006605 Builder.AddPlaceholderChunk("statements");
Douglas Gregore8f5a172010-04-07 00:21:17 +00006606
Douglas Gregor218937c2011-02-01 19:23:04 +00006607 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
6608 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006609 }
6610
Douglas Gregor408be5a2010-08-25 01:08:01 +00006611 unsigned Priority = CCP_CodePattern;
6612 if (!M->second.second)
6613 Priority += CCD_InBaseClass;
6614
Douglas Gregor218937c2011-02-01 19:23:04 +00006615 Results.AddResult(Result(Builder.TakeString(), Priority,
Douglas Gregor16ed9ad2010-08-17 16:06:07 +00006616 Method->isInstanceMethod()
6617 ? CXCursor_ObjCInstanceMethodDecl
6618 : CXCursor_ObjCClassMethodDecl));
Douglas Gregore8f5a172010-04-07 00:21:17 +00006619 }
6620
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006621 // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of
6622 // the properties in this class and its categories.
6623 if (Context.getLangOptions().ObjC2) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006624 SmallVector<ObjCContainerDecl *, 4> Containers;
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006625 Containers.push_back(SearchDecl);
6626
Douglas Gregore74c25c2011-05-04 23:50:46 +00006627 VisitedSelectorSet KnownSelectors;
6628 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
6629 MEnd = KnownMethods.end();
6630 M != MEnd; ++M)
6631 KnownSelectors.insert(M->first);
6632
6633
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006634 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl);
6635 if (!IFace)
6636 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl))
6637 IFace = Category->getClassInterface();
6638
6639 if (IFace) {
6640 for (ObjCCategoryDecl *Category = IFace->getCategoryList(); Category;
6641 Category = Category->getNextClassCategory())
6642 Containers.push_back(Category);
6643 }
6644
6645 for (unsigned I = 0, N = Containers.size(); I != N; ++I) {
6646 for (ObjCContainerDecl::prop_iterator P = Containers[I]->prop_begin(),
6647 PEnd = Containers[I]->prop_end();
6648 P != PEnd; ++P) {
6649 AddObjCKeyValueCompletions(*P, IsInstanceMethod, ReturnType, Context,
Douglas Gregore74c25c2011-05-04 23:50:46 +00006650 KnownSelectors, Results);
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006651 }
6652 }
6653 }
6654
Douglas Gregore8f5a172010-04-07 00:21:17 +00006655 Results.ExitScope();
6656
Douglas Gregore6b1bb62010-08-11 21:23:17 +00006657 HandleCodeCompleteResults(this, CodeCompleter,
6658 CodeCompletionContext::CCC_Other,
6659 Results.data(),Results.size());
Douglas Gregore8f5a172010-04-07 00:21:17 +00006660}
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006661
6662void Sema::CodeCompleteObjCMethodDeclSelector(Scope *S,
6663 bool IsInstanceMethod,
Douglas Gregor40ed9a12010-07-08 23:37:41 +00006664 bool AtParameterName,
John McCallb3d87482010-08-24 05:47:05 +00006665 ParsedType ReturnTy,
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006666 IdentifierInfo **SelIdents,
6667 unsigned NumSelIdents) {
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006668 // If we have an external source, load the entire class method
Sebastian Redl3c7f4132010-08-18 23:57:06 +00006669 // pool from the AST file.
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006670 if (ExternalSource) {
6671 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
6672 I != N; ++I) {
6673 Selector Sel = ExternalSource->GetExternalSelector(I);
Sebastian Redldb9d2142010-08-02 23:18:59 +00006674 if (Sel.isNull() || MethodPool.count(Sel))
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006675 continue;
Sebastian Redldb9d2142010-08-02 23:18:59 +00006676
6677 ReadMethodPool(Sel);
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006678 }
6679 }
6680
6681 // Build the set of methods we can see.
John McCall0a2c5e22010-08-25 06:19:51 +00006682 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00006683 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6684 CodeCompletionContext::CCC_Other);
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006685
6686 if (ReturnTy)
6687 Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType());
Sebastian Redldb9d2142010-08-02 23:18:59 +00006688
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006689 Results.EnterNewScope();
Sebastian Redldb9d2142010-08-02 23:18:59 +00006690 for (GlobalMethodPool::iterator M = MethodPool.begin(),
6691 MEnd = MethodPool.end();
6692 M != MEnd; ++M) {
6693 for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first :
6694 &M->second.second;
6695 MethList && MethList->Method;
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006696 MethList = MethList->Next) {
6697 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents,
6698 NumSelIdents))
6699 continue;
6700
Douglas Gregor40ed9a12010-07-08 23:37:41 +00006701 if (AtParameterName) {
6702 // Suggest parameter names we've seen before.
6703 if (NumSelIdents && NumSelIdents <= MethList->Method->param_size()) {
6704 ParmVarDecl *Param = MethList->Method->param_begin()[NumSelIdents-1];
6705 if (Param->getIdentifier()) {
Douglas Gregor218937c2011-02-01 19:23:04 +00006706 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregordae68752011-02-01 22:57:45 +00006707 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00006708 Param->getIdentifier()->getName()));
6709 Results.AddResult(Builder.TakeString());
Douglas Gregor40ed9a12010-07-08 23:37:41 +00006710 }
6711 }
6712
6713 continue;
6714 }
6715
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006716 Result R(MethList->Method, 0);
6717 R.StartParameter = NumSelIdents;
6718 R.AllParametersAreInformative = false;
6719 R.DeclaringEntity = true;
6720 Results.MaybeAddResult(R, CurContext);
6721 }
6722 }
6723
6724 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00006725 HandleCodeCompleteResults(this, CodeCompleter,
6726 CodeCompletionContext::CCC_Other,
6727 Results.data(),Results.size());
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006728}
Douglas Gregor87c08a52010-08-13 22:48:40 +00006729
Douglas Gregorf29c5232010-08-24 22:20:20 +00006730void Sema::CodeCompletePreprocessorDirective(bool InConditional) {
Douglas Gregor218937c2011-02-01 19:23:04 +00006731 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00006732 CodeCompletionContext::CCC_PreprocessorDirective);
Douglas Gregorf44e8542010-08-24 19:08:16 +00006733 Results.EnterNewScope();
6734
6735 // #if <condition>
Douglas Gregor218937c2011-02-01 19:23:04 +00006736 CodeCompletionBuilder Builder(Results.getAllocator());
6737 Builder.AddTypedTextChunk("if");
6738 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6739 Builder.AddPlaceholderChunk("condition");
6740 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006741
6742 // #ifdef <macro>
Douglas Gregor218937c2011-02-01 19:23:04 +00006743 Builder.AddTypedTextChunk("ifdef");
6744 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6745 Builder.AddPlaceholderChunk("macro");
6746 Results.AddResult(Builder.TakeString());
6747
Douglas Gregorf44e8542010-08-24 19:08:16 +00006748 // #ifndef <macro>
Douglas Gregor218937c2011-02-01 19:23:04 +00006749 Builder.AddTypedTextChunk("ifndef");
6750 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6751 Builder.AddPlaceholderChunk("macro");
6752 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006753
6754 if (InConditional) {
6755 // #elif <condition>
Douglas Gregor218937c2011-02-01 19:23:04 +00006756 Builder.AddTypedTextChunk("elif");
6757 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6758 Builder.AddPlaceholderChunk("condition");
6759 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006760
6761 // #else
Douglas Gregor218937c2011-02-01 19:23:04 +00006762 Builder.AddTypedTextChunk("else");
6763 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006764
6765 // #endif
Douglas Gregor218937c2011-02-01 19:23:04 +00006766 Builder.AddTypedTextChunk("endif");
6767 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006768 }
6769
6770 // #include "header"
Douglas Gregor218937c2011-02-01 19:23:04 +00006771 Builder.AddTypedTextChunk("include");
6772 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6773 Builder.AddTextChunk("\"");
6774 Builder.AddPlaceholderChunk("header");
6775 Builder.AddTextChunk("\"");
6776 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006777
6778 // #include <header>
Douglas Gregor218937c2011-02-01 19:23:04 +00006779 Builder.AddTypedTextChunk("include");
6780 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6781 Builder.AddTextChunk("<");
6782 Builder.AddPlaceholderChunk("header");
6783 Builder.AddTextChunk(">");
6784 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006785
6786 // #define <macro>
Douglas Gregor218937c2011-02-01 19:23:04 +00006787 Builder.AddTypedTextChunk("define");
6788 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6789 Builder.AddPlaceholderChunk("macro");
6790 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006791
6792 // #define <macro>(<args>)
Douglas Gregor218937c2011-02-01 19:23:04 +00006793 Builder.AddTypedTextChunk("define");
6794 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6795 Builder.AddPlaceholderChunk("macro");
6796 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6797 Builder.AddPlaceholderChunk("args");
6798 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6799 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006800
6801 // #undef <macro>
Douglas Gregor218937c2011-02-01 19:23:04 +00006802 Builder.AddTypedTextChunk("undef");
6803 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6804 Builder.AddPlaceholderChunk("macro");
6805 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006806
6807 // #line <number>
Douglas Gregor218937c2011-02-01 19:23:04 +00006808 Builder.AddTypedTextChunk("line");
6809 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6810 Builder.AddPlaceholderChunk("number");
6811 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006812
6813 // #line <number> "filename"
Douglas Gregor218937c2011-02-01 19:23:04 +00006814 Builder.AddTypedTextChunk("line");
6815 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6816 Builder.AddPlaceholderChunk("number");
6817 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6818 Builder.AddTextChunk("\"");
6819 Builder.AddPlaceholderChunk("filename");
6820 Builder.AddTextChunk("\"");
6821 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006822
6823 // #error <message>
Douglas Gregor218937c2011-02-01 19:23:04 +00006824 Builder.AddTypedTextChunk("error");
6825 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6826 Builder.AddPlaceholderChunk("message");
6827 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006828
6829 // #pragma <arguments>
Douglas Gregor218937c2011-02-01 19:23:04 +00006830 Builder.AddTypedTextChunk("pragma");
6831 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6832 Builder.AddPlaceholderChunk("arguments");
6833 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006834
6835 if (getLangOptions().ObjC1) {
6836 // #import "header"
Douglas Gregor218937c2011-02-01 19:23:04 +00006837 Builder.AddTypedTextChunk("import");
6838 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6839 Builder.AddTextChunk("\"");
6840 Builder.AddPlaceholderChunk("header");
6841 Builder.AddTextChunk("\"");
6842 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006843
6844 // #import <header>
Douglas Gregor218937c2011-02-01 19:23:04 +00006845 Builder.AddTypedTextChunk("import");
6846 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6847 Builder.AddTextChunk("<");
6848 Builder.AddPlaceholderChunk("header");
6849 Builder.AddTextChunk(">");
6850 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006851 }
6852
6853 // #include_next "header"
Douglas Gregor218937c2011-02-01 19:23:04 +00006854 Builder.AddTypedTextChunk("include_next");
6855 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6856 Builder.AddTextChunk("\"");
6857 Builder.AddPlaceholderChunk("header");
6858 Builder.AddTextChunk("\"");
6859 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006860
6861 // #include_next <header>
Douglas Gregor218937c2011-02-01 19:23:04 +00006862 Builder.AddTypedTextChunk("include_next");
6863 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6864 Builder.AddTextChunk("<");
6865 Builder.AddPlaceholderChunk("header");
6866 Builder.AddTextChunk(">");
6867 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006868
6869 // #warning <message>
Douglas Gregor218937c2011-02-01 19:23:04 +00006870 Builder.AddTypedTextChunk("warning");
6871 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6872 Builder.AddPlaceholderChunk("message");
6873 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006874
6875 // Note: #ident and #sccs are such crazy anachronisms that we don't provide
6876 // completions for them. And __include_macros is a Clang-internal extension
6877 // that we don't want to encourage anyone to use.
6878
6879 // FIXME: we don't support #assert or #unassert, so don't suggest them.
6880 Results.ExitScope();
6881
Douglas Gregorf44e8542010-08-24 19:08:16 +00006882 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor721f3592010-08-25 18:41:16 +00006883 CodeCompletionContext::CCC_PreprocessorDirective,
Douglas Gregorf44e8542010-08-24 19:08:16 +00006884 Results.data(), Results.size());
6885}
6886
6887void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) {
Douglas Gregorf29c5232010-08-24 22:20:20 +00006888 CodeCompleteOrdinaryName(S,
John McCallf312b1e2010-08-26 23:41:50 +00006889 S->getFnParent()? Sema::PCC_RecoveryInFunction
6890 : Sema::PCC_Namespace);
Douglas Gregorf44e8542010-08-24 19:08:16 +00006891}
6892
Douglas Gregorf29c5232010-08-24 22:20:20 +00006893void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) {
Douglas Gregor218937c2011-02-01 19:23:04 +00006894 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00006895 IsDefinition? CodeCompletionContext::CCC_MacroName
6896 : CodeCompletionContext::CCC_MacroNameUse);
Douglas Gregor1fbb4472010-08-24 20:21:13 +00006897 if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) {
6898 // Add just the names of macros, not their arguments.
Douglas Gregor218937c2011-02-01 19:23:04 +00006899 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor1fbb4472010-08-24 20:21:13 +00006900 Results.EnterNewScope();
6901 for (Preprocessor::macro_iterator M = PP.macro_begin(),
6902 MEnd = PP.macro_end();
6903 M != MEnd; ++M) {
Douglas Gregordae68752011-02-01 22:57:45 +00006904 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00006905 M->first->getName()));
6906 Results.AddResult(Builder.TakeString());
Douglas Gregor1fbb4472010-08-24 20:21:13 +00006907 }
6908 Results.ExitScope();
6909 } else if (IsDefinition) {
6910 // FIXME: Can we detect when the user just wrote an include guard above?
6911 }
6912
Douglas Gregor52779fb2010-09-23 23:01:17 +00006913 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregor1fbb4472010-08-24 20:21:13 +00006914 Results.data(), Results.size());
6915}
6916
Douglas Gregorf29c5232010-08-24 22:20:20 +00006917void Sema::CodeCompletePreprocessorExpression() {
Douglas Gregor218937c2011-02-01 19:23:04 +00006918 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00006919 CodeCompletionContext::CCC_PreprocessorExpression);
Douglas Gregorf29c5232010-08-24 22:20:20 +00006920
6921 if (!CodeCompleter || CodeCompleter->includeMacros())
6922 AddMacroResults(PP, Results);
6923
6924 // defined (<macro>)
6925 Results.EnterNewScope();
Douglas Gregor218937c2011-02-01 19:23:04 +00006926 CodeCompletionBuilder Builder(Results.getAllocator());
6927 Builder.AddTypedTextChunk("defined");
6928 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6929 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6930 Builder.AddPlaceholderChunk("macro");
6931 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6932 Results.AddResult(Builder.TakeString());
Douglas Gregorf29c5232010-08-24 22:20:20 +00006933 Results.ExitScope();
6934
6935 HandleCodeCompleteResults(this, CodeCompleter,
6936 CodeCompletionContext::CCC_PreprocessorExpression,
6937 Results.data(), Results.size());
6938}
6939
6940void Sema::CodeCompletePreprocessorMacroArgument(Scope *S,
6941 IdentifierInfo *Macro,
6942 MacroInfo *MacroInfo,
6943 unsigned Argument) {
6944 // FIXME: In the future, we could provide "overload" results, much like we
6945 // do for function calls.
6946
Argyrios Kyrtzidis5c5f03e2011-08-18 19:41:28 +00006947 // Now just ignore this. There will be another code-completion callback
6948 // for the expanded tokens.
Douglas Gregorf29c5232010-08-24 22:20:20 +00006949}
6950
Douglas Gregor55817af2010-08-25 17:04:25 +00006951void Sema::CodeCompleteNaturalLanguage() {
Douglas Gregor55817af2010-08-25 17:04:25 +00006952 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregoraf1c6b52010-08-25 17:10:00 +00006953 CodeCompletionContext::CCC_NaturalLanguage,
Douglas Gregor55817af2010-08-25 17:04:25 +00006954 0, 0);
6955}
6956
Douglas Gregordae68752011-02-01 22:57:45 +00006957void Sema::GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,
Chris Lattner5f9e2722011-07-23 10:55:15 +00006958 SmallVectorImpl<CodeCompletionResult> &Results) {
Douglas Gregor218937c2011-02-01 19:23:04 +00006959 ResultBuilder Builder(*this, Allocator, CodeCompletionContext::CCC_Recovery);
Douglas Gregor8071e422010-08-15 06:18:01 +00006960 if (!CodeCompleter || CodeCompleter->includeGlobals()) {
6961 CodeCompletionDeclConsumer Consumer(Builder,
6962 Context.getTranslationUnitDecl());
6963 LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName,
6964 Consumer);
6965 }
Douglas Gregor87c08a52010-08-13 22:48:40 +00006966
6967 if (!CodeCompleter || CodeCompleter->includeMacros())
6968 AddMacroResults(PP, Builder);
6969
6970 Results.clear();
6971 Results.insert(Results.end(),
6972 Builder.data(), Builder.data() + Builder.size());
6973}